添加临时节点和关系

src/main/java/com/keymobile/metadata/metadataRelation/controller/MetaDataController.java

 package com.keymobile.metadata.metadataRelation.controller;
 
+import com.alibaba.fastjson.JSONObject;
 import com.keymobile.metadata.metadataRelation.pojo.BaseRelationship;
 import com.keymobile.metadata.metadataRelation.pojo.MetaData;
+import com.keymobile.metadata.metadataRelation.pojo.TempNode;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.Edge;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.MetaModel;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.Node;
@@ -12,6 +14,7 @@ import com.keymobile.metadata.metadataRelation.service.impl.MongoDbServiceImpl;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
+import org.apache.commons.lang3.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -41,6 +44,9 @@ public class MetaDataController {
     private IMetadataService metadataService;
 
     @Autowired
+    private MongoDbServiceImpl mongoDbService;
+
+    @Autowired
     private IBaseRelationshipService baseRelationshipService;
     /**
      * 查询元数据，关系
@@ -79,6 +85,31 @@ public class MetaDataController {
             result.getNodes().add(node);
             nodeMap.put(metaData.getId(),node);
         }
+
+        List<TempNode> allTempNode = metadataService.findAllTempNode();
+        for (TempNode tempNode : allTempNode) {
+            Node node = new Node();
+            String[] strings = tempNode.getMetadataId().split("=");
+            String modelName = strings[0];
+
+            node.setId(tempNode.getMetadataId());
+            node.setIcon(modelName);
+            if(!metaModelMap.containsKey(modelName)){
+                MetaModel  model = new MetaModel();
+                String iconContext = getIconByModelId(modelName);
+                model.setModelName(modelName);
+                model.setCnName(modelName);
+                model.setDescription("");
+                model.setIcon(iconContext);
+                metaModelMap.put(modelName,model);
+            }
+
+            node.setName(tempNode.getName());
+            node.setType("TempNode");
+            result.getNodes().add(node);
+            nodeMap.put(tempNode.getId(),node);
+        }
+
         logger.info("节点的数量："+result.getNodes().size());
         List<BaseRelationship> baseRelationshipList = baseRelationshipService.findAllRelation();
         for(BaseRelationship baseRelationship:baseRelationshipList){
@@ -96,11 +127,15 @@ public class MetaDataController {
                 endMEtaId = nodeMap.get(endId).getId();
             }
 
-            edge.setFromId(startMetaId);
-            edge.setToId(endMEtaId);
-            edge.setType(baseRelationship.getName());
+            if (StringUtils.isNotBlank(startMetaId) && StringUtils.isNotBlank(endMEtaId)) {
+                edge.setFromId(startMetaId);
+                edge.setToId(endMEtaId);
+                edge.setType(baseRelationship.getName());
+
+                result.getEdges().add(edge);
+            }
+
 
-            result.getEdges().add(edge);
         }
 
         logger.info("关系的数量："+result.getEdges().size());
@@ -299,8 +334,29 @@ public class MetaDataController {
         logger.info("开始同步元数据：从mongo到neo4j");
         String flag = "success";
         metadataService.syschroRelationFromMongo(catalogName);
+        metadataService.createTempNode(catalogName);
         return flag;
     }
 
+    @PostMapping("/addTempRelation")
+    public void addTempRelation(@RequestParam String catalogName, @RequestBody List<JSONObject> list) {
+        mongoDbService.saveTempRelation(list, catalogName);
+    }
+
+    @PostMapping("/removeTempRelation")
+    public void removeTempRelation(@RequestParam String sqlId, @RequestParam String catalogName) {
+        mongoDbService.removeTempRelation(sqlId, catalogName);
+    }
+
+    @PostMapping("/createTempNode")
+    public void createTempNode(@RequestParam String catalogName) {
+        metadataService.createTempNode(catalogName);
+    }
+
+    @PostMapping("/deleteTempNode")
+    public void deleteTempNode(@RequestParam String sqlId) {
+        metadataService.deleteTempNode(sqlId);
+    }
+
 
 }

src/main/java/com/keymobile/metadata/metadataRelation/pojo/TempNode.java

+package com.keymobile.metadata.metadataRelation.pojo;
+
+import org.neo4j.ogm.annotation.NodeEntity;
+
+/**
+ * @author mahx
+ * @version 1.0
+ * @date 2021/11/10 18:14
+ */
+@NodeEntity(label = "TempNode")
+public class TempNode extends BaseNode {
+
+    private String sqlId;
+
+    private String metadataId;
+
+    public String getSqlId() {
+        return sqlId;
+    }
+
+    public void setSqlId(String sqlId) {
+        this.sqlId = sqlId;
+    }
+
+    public String getMetadataId() {
+        return metadataId;
+    }
+
+    public void setMetadataId(String metadataId) {
+        this.metadataId = metadataId;
+    }
+}

src/main/java/com/keymobile/metadata/metadataRelation/respository/CompositionRelationRespository.java

@@ -24,4 +24,7 @@ public interface CompositionRelationRespository extends Neo4jRepository<Composit
     @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Composition]->(target) return p")
     List<CompositionRelation> addConpositionRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
 
+    @Query("match (source:BaseNode),(target:BaseNode) where id(source)=$sourceId and id(target)=$targetId merge p=(source)-[r:Composition]->(target) return p")
+    CompositionRelation mergeConpositionRelation(@Param("sourceId") Long sourceId, @Param("targetId") Long targetId);
+
 }

src/main/java/com/keymobile/metadata/metadataRelation/respository/InputRelationReRepository.java

@@ -25,4 +25,7 @@ public interface InputRelationReRepository extends Neo4jRepository<InputRelation
     @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Input]->(target) return p")
     List<InputRelation> addInputRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
 
+    @Query("match (source:BaseNode),(target:BaseNode) where id(source)=$sourceId and id(target)=$targetId merge p=(source)-[r:Input]->(target) return p")
+    InputRelation mergeInputRelation(@Param("sourceId") Long sourceId, @Param("targetId") Long targetId);
+
 }

src/main/java/com/keymobile/metadata/metadataRelation/respository/MetadataRepository.java

 package com.keymobile.metadata.metadataRelation.respository;
 
 import com.keymobile.metadata.metadataRelation.pojo.MetaData;
+import org.springframework.data.mongodb.core.query.Meta;
 import org.springframework.data.neo4j.annotation.Query;
 import org.springframework.data.neo4j.repository.Neo4jRepository;
 import org.springframework.data.repository.query.Param;
@@ -13,6 +14,8 @@ public interface MetadataRepository extends Neo4jRepository<MetaData,Long> {
 
     MetaData findMetadataByName(String name);
 
+    MetaData findMetaDataByMetadataId(String id);
+
     /**
      * @Query("MATCH (n : MetaData { metadataId : $startId }), (n1 : MetaData { metadataId : $endId }), p=(n)-[]-(n1) return p")
      *     List<OutputRelation> findOutputRelationship(@Param("startId") String startId, @Param("endId") String endId);

src/main/java/com/keymobile/metadata/metadataRelation/respository/OutputRelationRepository.java

@@ -24,5 +24,8 @@ public interface OutputRelationRepository extends Neo4jRepository<OutputRelation
     @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Output]->(target) return p")
     List<OutputRelation> addOutRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
 
+    @Query("match (source:BaseNode),(target:BaseNode) where id(source)=$sourceId and id(target)=$targetId merge p=(source)-[r:Output]->(target) return p")
+    OutputRelation mergeOutRelation(@Param("sourceId") Long sourceId, @Param("targetId") Long targetId);
+
 
 }

src/main/java/com/keymobile/metadata/metadataRelation/respository/TempNodeRepository.java

+package com.keymobile.metadata.metadataRelation.respository;
+
+import com.keymobile.metadata.metadataRelation.pojo.TempNode;
+import org.springframework.data.neo4j.annotation.Query;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+import org.springframework.data.repository.query.Param;
+
+/**
+ * @author mahx
+ * @version 1.0
+ * @date 2021/11/10 18:15
+ */
+public interface TempNodeRepository extends Neo4jRepository<TempNode, Long> {
+
+    Long deleteTempNodesBySqlId(String sqlId);
+
+    @Query("match (source:BaseNode)-[r]-(target:BaseNode) where source.sqlId=$sqlId or target.sqlId=$sqlId delete r")
+    Long deleteAllRelation(@Param("sqlId") String sqlId);
+}

src/main/java/com/keymobile/metadata/metadataRelation/service/IMetadataService.java

@@ -2,6 +2,7 @@ package com.keymobile.metadata.metadataRelation.service;
 
 import com.keymobile.metadata.metadataRelation.pojo.BaseRelationship;
 import com.keymobile.metadata.metadataRelation.pojo.MetaData;
+import com.keymobile.metadata.metadataRelation.pojo.TempNode;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.ReturnReslult;
 import org.springframework.data.mongodb.core.query.Meta;
 
@@ -66,4 +67,10 @@ public interface IMetadataService {
 
 
     List<String> findAllNodeTypes();
+
+    void createTempNode(String catalogName);
+
+    void deleteTempNode(String sqlId);
+
+    List<TempNode> findAllTempNode();
 }

src/main/java/com/keymobile/metadata/metadataRelation/service/impl/MetadataServiceImpl.java

 package com.keymobile.metadata.metadataRelation.service.impl;
 
+import com.alibaba.fastjson.JSONObject;
 import com.keymobile.metadata.metadataRelation.config.Neo4jConfig;
 import com.keymobile.metadata.metadataRelation.pojo.*;
 import com.keymobile.metadata.metadataRelation.pojo.returnBean.Edge;
@@ -9,19 +10,20 @@ import com.keymobile.metadata.metadataRelation.respository.*;
 import com.keymobile.metadata.metadataRelation.service.IBaseRelationshipService;
 import com.keymobile.metadata.metadataRelation.service.IMetadataService;
 import com.keymobile.metadata.metadataRelation.util.Neo4jTool;
+import org.apache.commons.lang.StringUtils;
 import org.neo4j.driver.v1.*;
+import org.neo4j.driver.v1.Record;
 import org.neo4j.driver.v1.types.Node;
 import org.neo4j.driver.v1.types.Path;
 import org.neo4j.driver.v1.types.Relationship;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 @Service
 public class MetadataServiceImpl implements IMetadataService {
@@ -40,6 +42,8 @@ public class MetadataServiceImpl implements IMetadataService {
     private OutputRelationRepository outputRelationRepository;
     @Autowired
     private ExecuteRelationRepository executeRelationRepository;
+    @Autowired
+    private TempNodeRepository tempNodeRepository;
 
     @Autowired
     private MongoDbServiceImpl mongoDbServiceImpl;
@@ -185,7 +189,7 @@ public class MetadataServiceImpl implements IMetadataService {
                 metaData.setMetadataId(sourceId);
                 metaData.setName(name);
                 metaDataMap.put(sourceId,metaData);
-                MetaData metadata = metadataRepository.findMetadataByName(name);
+                MetaData metadata = metadataRepository.findMetaDataByMetadataId(sourceId);
                 if(metadata !=null){
 
                 }else{
@@ -205,7 +209,7 @@ public class MetadataServiceImpl implements IMetadataService {
                         MetaData parentData = new MetaData();
                         parentData.setMetadataId(parentId);
                         String parentName = (String) parentAlttriuteMap.get("name");
-                        MetaData parentMetadata = metadataRepository.findMetadataByName(parentName);
+                        MetaData parentMetadata = metadataRepository.findMetaDataByMetadataId(parentId);
                         parentData.setName(parentName);
                         if(parentMetadata !=null){
 
@@ -240,7 +244,7 @@ public class MetadataServiceImpl implements IMetadataService {
                 metaData.setName(name);
                 metaDataMap.put(targetId,metaData);
 
-                MetaData neo4jData = metadataRepository.findMetadataByName(name);
+                MetaData neo4jData = metadataRepository.findMetaDataByMetadataId(targetId);
                 if(neo4jData !=null){
 
                 }else{
@@ -263,7 +267,7 @@ public class MetadataServiceImpl implements IMetadataService {
                         String parentName = (String) parentAlttriuteMap.get("name");
                         parentData.setName(parentName);
 
-                        MetaData parentMetadata = metadataRepository.findMetadataByName(parentName);
+                        MetaData parentMetadata = metadataRepository.findMetaDataByMetadataId(parentId);
                         if(parentMetadata !=null){
 
                         }else{
@@ -384,9 +388,89 @@ public class MetadataServiceImpl implements IMetadataService {
             int size = objects.size();
             String  type = "";
             Object object = objects.get(size-1);
-
             labels.add(object.toString());
         }
         return  labels;
     }
+
+    private Long createNode(Map<String, Long> nameIdMap, String sqlId, String name, boolean isTable) {
+        Long nodeId = nameIdMap.get(name);
+        if (nodeId == null) {
+            String[] split = StringUtils.split(name, '.');
+            if (split.length == 2) {
+                String tableName = split[0];
+                String columnName = split[1];
+                Long tableId = createNode(nameIdMap, sqlId, tableName, true);
+                nodeId = createNode(nameIdMap, sqlId, columnName, false);
+                if (tableId != null && nodeId != null) {
+                    compositionRelationRespository.mergeConpositionRelation(tableId, nodeId);
+                }
+            } else {
+                TempNode tempNode = new TempNode();
+                String modelName = isTable ? "TempTable" : "TempColumn";
+                tempNode.setMetadataId(modelName + "=" + UUID.randomUUID());
+                tempNode.setName(name);
+                tempNode.setSqlId(sqlId);
+                tempNode = tempNodeRepository.save(tempNode);
+                nodeId = tempNode.getId();
+                nameIdMap.put(name, nodeId);
+            }
+        }
+        return nodeId;
+    }
+
+    @Override
+    public void createTempNode(String catalogName) {
+        int page = 0, pageSize = 500;
+        long totalElement = mongoDbServiceImpl.countTempRelation(PageRequest.of(page, pageSize), catalogName);
+        Map<String, Long> sqlIdNodeIdMap = new HashMap<>();
+        Map<String, Long> nameIdMap = new HashMap<>();
+        for (; page < totalElement; page += pageSize) {
+            List<JSONObject> list = mongoDbServiceImpl.findTempRelationByPage(PageRequest.of(page, pageSize, Sort.by("sqlId")), catalogName);
+            for (JSONObject relation : list) {
+                String sqlId = relation.getString("sqlId");
+                deleteTempNode(sqlId);
+                MetaData metadata = metadataRepository.findMetaDataByMetadataId(sqlId);
+                if (metadata == null) {
+                    logger.error("id : {} is not found", sqlId);
+                    continue;
+                }
+                Long id = metadata.getId();
+                if (!sqlIdNodeIdMap.containsKey(sqlId)) {
+                    sqlIdNodeIdMap.put(sqlId, id);
+                    nameIdMap = new HashMap<>();
+                }
+                String source = relation.getString("source");
+                String target = relation.getString("target");
+                if (StringUtils.isBlank(source) || StringUtils.isBlank(target)) {
+                    continue;
+                }
+
+                String type = relation.getString("type");
+                if ("Input".equalsIgnoreCase(type)) {
+                    Long nodeId = createNode(nameIdMap, sqlId, source, false);
+                    if (nodeId != null) {
+                        inputRelationReRepository.mergeInputRelation(nodeId, id);
+                    }
+                }
+                if ("Output".equalsIgnoreCase(type)) {
+                    Long nodeId = createNode(nameIdMap, sqlId, target, false);
+                    if (nodeId != null) {
+                        outputRelationRepository.mergeOutRelation(id, nodeId);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void deleteTempNode(String sqlId) {
+        tempNodeRepository.deleteAllRelation(sqlId);
+        tempNodeRepository.deleteTempNodesBySqlId(sqlId);
+    }
+
+    @Override
+    public List<TempNode> findAllTempNode() {
+        return (List<TempNode>) tempNodeRepository.findAll();
+    }
 }

src/main/java/com/keymobile/metadata/metadataRelation/service/impl/MongoDbServiceImpl.java

 package com.keymobile.metadata.metadataRelation.service.impl;
 
+import com.alibaba.fastjson.JSONObject;
 import com.keymobile.metadata.metadataRelation.pojo.RelationMongo;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Pageable;
 import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
 
 import java.util.List;
 
 @Service
 public class MongoDbServiceImpl {
     private static final Logger logger = LoggerFactory.getLogger(MongoDbServiceImpl.class);
+    private static final String PREFIX_MD_RELATION_TEMP_NODE = "md_relation_temp_node_";
     @Autowired
     private MongoTemplate mongoTemplate;
 
@@ -46,4 +52,28 @@ public class MongoDbServiceImpl {
         }
 
     }
+
+    public void saveTempRelation(List<JSONObject> list, String catalogName) {
+        if (CollectionUtils.isEmpty(list)) {
+            return ;
+        }
+        list.forEach(o -> mongoTemplate.save(o, PREFIX_MD_RELATION_TEMP_NODE + catalogName));
+    }
+
+    public void removeTempRelation(String sqlId, String catalogName) {
+        Query query = Query.query(Criteria.where("sqlId").is(sqlId));
+        mongoTemplate.remove(query, PREFIX_MD_RELATION_TEMP_NODE + catalogName);
+    }
+
+    public List<JSONObject> findTempRelationByPage(Pageable pageable, String catalogName) {
+        Query query = new Query();
+        query.with(pageable);
+        return mongoTemplate.find(query, JSONObject.class, PREFIX_MD_RELATION_TEMP_NODE + catalogName);
+    }
+
+    public long countTempRelation(Pageable pageable, String catalogName) {
+        Query query = new Query();
+        query.with(pageable);
+        return mongoTemplate.count(query, JSONObject.class, PREFIX_MD_RELATION_TEMP_NODE + catalogName);
+    }
 }