更改neo4j语法为悦邻图库的语法

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

@@ -11,7 +11,7 @@ import java.util.List;
 @Repository
 public interface CompositionRelationRespository extends GraphDbRepository<CompositionRelation, Long> {
 
-    @Query("MATCH (n{metadataId: $startId}),(n1{metadataId: $endId}),p=(n)-[r:Composition]->(n1) return p")
+    @Query("g.match((n{metadataId: $startId}),(n1{metadataId: $endId}),p=(n)-[r:Composition]->(n1)).return(p)")
     List<CompositionRelation> findCompositionRelationship(@Param("startId") String startId, @Param("endId") String endId);
 
 
@@ -22,10 +22,10 @@ public interface CompositionRelationRespository extends GraphDbRepository<Compos
      * @param targetId
      * @return
      */
-    @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Composition]->(target) return p")
+    @Query("g.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")
+    @Query("g.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/ExecuteRelationRepository.java

@@ -18,10 +18,10 @@ public interface ExecuteRelationRepository extends GraphDbRepository<ExecuteRela
      * @param targetId
      * @return
      */
-    @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Execute]->(target)  return p")
+    @Query("g.match((source:BaseNode),(target:BaseNode)).where(source.metadataId=$sourceId and target.metadataId=$targetId).create(p=(source)-[r:Execute]->(target)).return(p)")
     List<ExecuteRelation> addExecuteRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
 
-    @Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
+    @Query("g.match((n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1)).return(p)")
     List<ExecuteRelation> findExecuteRelationship(@Param("startId") String startId, @Param("endId") String endId);
 
 

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

@@ -12,7 +12,7 @@ import java.util.List;
 public interface InputRelationReRepository extends GraphDbRepository<InputRelation, Long> {
 
 
-    @Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
+    @Query("g.match((n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1)).return(p)")
     List<InputRelation> findInputRelationship(@Param("startId") String startId, @Param("endId") String endId);
 
 
@@ -23,10 +23,10 @@ public interface InputRelationReRepository extends GraphDbRepository<InputRelati
      * @param targetId
      * @return
      */
-    @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Input]->(target) return p")
+    @Query("g.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")
+    @Query("g.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

@@ -14,10 +14,10 @@ public interface MetadataRepository extends GraphDbRepository<MetaData, Long> {
     List<MetaData> findMetadataByName(String name);
 
     //删除指定节点
-    @Query("match (n) where n.metadataId =~'.*+catalogName+.*' return n")
+    @Query("g.match((n)).where(n.metadataId =~'.*+catalogName+.*').return(n)")
     void deleteMetaDataByCatalogName(String catalogName);
 
-    @Query("match (n:MetaData ) where n.metadataId =~{modelName} return n")
+    @Query("g.match((n:MetaData)).where(n.metadataId =~{modelName}).return(n)")
     List<MetaData> findMetaDataByModelName(@Param("modelName") String dataName);
 
     //MATCH p=(a:MetaData{metadataId:"Table=1=b148ad31504d4487bd81ecebbc7522c3"})-[r:Composition]->() -[*]->()<-[r1:Composition]-(b:MetaData{metadataId:"Table=368=600efbf1fb4a4bd1910dbc1b567d6691"})
@@ -30,14 +30,14 @@ public interface MetadataRepository extends GraphDbRepository<MetaData, Long> {
      * @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);
      */
-    @Query("match data=(na:MetaData{name:{0}})<-[rel*1..3]->(nb:MetaData) return data")
+    @Query("g.match(data=(na:MetaData{name:{0}})<-[rel*1..3]->(nb:MetaData)).return(data)")
     List<MetaData> findMetaData(@Param("dataName") String dataName, @Param("n") int n);
 
 
-    @Query("match (data:MetaData{system:{parentName}}) return data limit {limit} ")
+    @Query("g.match((data:MetaData{system:{parentName}})).return(data).limit({limit}) ")
     List<MetaData> findMetaDataByParentName(@Param("parentName") String parentName, @Param("limit")  Integer count );
 
-    @Query("MATCH p=(n:MetaData {metadataId:{parentId}})-[r:Composition]->(m) RETURN m limit {limit} ")
+    @Query("g.match(p=(n:MetaData {metadataId:{parentId}})-[r:Composition]->(m)).return(m).limit({limit}) ")
     List<MetaData> findMetaDataByParentId(@Param("parentId") String parentId, @Param("limit") Integer count );
 
 

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

@@ -11,7 +11,7 @@ import java.util.List;
 @Repository
 public interface OutputRelationRepository extends GraphDbRepository<OutputRelation, Long> {
 
-    @Query("MATCH (n:MetaData{metadataId: $startId}),(n1:MetaData{metadataId: $endId}),p=(n)-[]-(n1) return p")
+    @Query("g.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);
 
 
@@ -22,10 +22,10 @@ public interface OutputRelationRepository extends GraphDbRepository<OutputRelati
      * @param targetId
      * @return
      */
-    @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Output]->(target) return p")
+    @Query("g.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")
+    @Query("g.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/PostRelationRepository.java

@@ -13,6 +13,6 @@ import org.springframework.data.repository.query.Param;
  */
 public interface PostRelationRepository extends GraphDbRepository<PostRelation, Long> {
 
-    @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Post]->(target) return p")
+    @Query("g.match((source:BaseNode),(target:BaseNode)).where(source.metadataId=$sourceId and target.metadataId=$targetId).create(p=(source)-[r:Post]->(target)).return(p)")
     PostRelation mergePostRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
 }

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

@@ -12,6 +12,6 @@ import org.springframework.data.repository.query.Param;
  */
 public interface PreRelationRepository extends GraphDbRepository<PreRelation, Long> {
 
-    @Query("match (source:BaseNode),(target:BaseNode) where source.metadataId=$sourceId and target.metadataId=$targetId create p=(source)-[r:Pre]->(target) return p")
+    @Query("g.match((source:BaseNode),(target:BaseNode)).where(source.metadataId=$sourceId and target.metadataId=$targetId).create(p=(source)-[r:Pre]->(target)).return(p)")
     PreRelation mergePreRelation(@Param("sourceId") String sourceId, @Param("targetId") String targetId);
 }

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

@@ -23,7 +23,7 @@ public interface TempNodeRepository extends GraphDbRepository<TempNode, Long> {
 
     Long deleteTempNodesByCatalogName(String catalogName);
 
-    @Query("match (source:BaseNode)-[r]-(target:BaseNode) where source.catalogName=$catalogName or target.catalogName=$catalogName delete r")
+    @Query("g.match((source:BaseNode)-[r]-(target:BaseNode)).where(source.catalogName=$catalogName or target.catalogName=$catalogName).delete(r)")
     Long deleteAllRelation(@Param("catalogName") String catalogName);
 
     List<TempNode> findByCatalogNameAndEtlJobIdAndParentIdAndName(String catalogName, String etlJobId, Long parentId, String name);

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

@@ -12,6 +12,6 @@ import org.springframework.data.repository.query.Param;
  */
 public interface TempRelationRepository extends GraphDbRepository<TempRelation, Long> {
 
-    @Query("match (source:BaseNode),(target:BaseNode) where id(source)=$sourceId and id(target)=$targetId merge p=(source)-[r:TempRelation]->(target) return p")
+    @Query("g.match((source:BaseNode),(target:BaseNode)).where(id(source)=$sourceId and id(target)=$targetId).merge(p=(source)-[r:TempRelation]->(target)).return(p)")
     TempRelation mergeTempRelation(@Param("sourceId") Long sourceId, @Param("targetId") Long targetId);
 }

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

@@ -14,9 +14,9 @@ public interface Neo4jETLJobRepository extends GraphDbRepository<Neo4jETLJob, Lo
 
     Neo4jETLJob findNeo4jETLJobByMetadataId(String metadataId);
 
-    @Query("match(n:Neo4jETLJob{metadataId:{jobId}}) -[r:Composition]->(m)-[r1:流向]->(t) return t")
+    @Query("g.match((n:Neo4jETLJob{metadataId:{jobId}})-[r:Composition]->(m)-[r1:流向]->(t)).return(t)")
     List<BaseNode> getSources(@Param("jobId") String jobId);
 
-    @Query("match(n:Neo4jETLJob{metadataId:{jobId}}) -[r:Composition]->(m)<-[r1:流向]-(t) return t")
+    @Query("g.match((n:Neo4jETLJob{metadataId:{jobId}})-[r:Composition]->(m)<-[r1:流向]-(t)).return(t)")
     List<BaseNode> getTarget(@Param("jobId") String jobId);
 }

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

@@ -13,12 +13,10 @@ import java.util.List;
 public interface Neo4jETLScriptRepository extends GraphDbRepository<Neo4jETLScript, Long> {
     Neo4jETLScript findNeo4jETLScriptByMetadataId(String metadataId);
 
-    @Query("match(n:Neo4jETLScript{metadataId:{scriptId}})<-[r1:流向]-(t) return t" +
-            " union match(n:Neo4jETLScript{metadataId:{scriptId}})<-[r1:TempRelation*1..]-(t) return t")
+    @Query("g.match((n:Neo4jETLScript{metadataId:{scriptId}})<-[r1:流向]-(t)).return(t).union(g.match((n:Neo4jETLScript{metadataId:{scriptId}})<-[r1:TempRelation*1..]-(t)).return(t))")
     List<BaseNode> getSources(@Param("scriptId") String scriptId);
 
 
-    @Query("match(n:Neo4jETLScript{metadataId:{scriptId}})-[r1:流向]->(t) return t" +
-            " union match(n:Neo4jETLScript{metadataId:{scriptId}})-[r1:TempRelation*1..]->(t) return t")
+    @Query("g.match((n:Neo4jETLScript{metadataId:{scriptId}})-[r1:流向]->(t)).return(t).union(g.match((n:Neo4jETLScript{metadataId:{scriptId}})-[r1:TempRelation*1..]->(t)).return(t))")
     List<BaseNode> getTargets(@Param("scriptId") String scriptId);
 }

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

@@ -14,10 +14,10 @@ public interface Neo4jFileRepository extends GraphDbRepository<Neo4jFile, Long>
     Neo4jFile findNeo4jFileByMetadataId(String metadataId);
 
 
-    @Query("match(n:Neo4jFile{metadataId:{fileId}})<-[r1:流向]-(t:Neo4jTable) return t")
+    @Query("g.match((n:Neo4jFile{metadataId:{fileId}})<-[r1:流向]-(t:Neo4jTable)).return(t)")
     List<BaseNode> getSources(@Param("fileId") String fileId);
 
 
-    @Query("match(n:Neo4jFile{metadataId:{fileId}})-[r1:流向]->(t:Neo4jTable) return t" )
+    @Query("g.match((n:Neo4jFile{metadataId:{fileId}})-[r1:流向]->(t:Neo4jTable)).return(t)" )
     List<BaseNode> getTargets(@Param("fileId") String fileId);
 }

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

@@ -14,24 +14,24 @@ public interface Neo4jSchemaRepository extends GraphDbRepository<Neo4jSchema, Lo
 
     Neo4jSchema findNeo4jSchemaByMetadataId(String metadataId);
 
-    @Query("match (n:Neo4jSchema{metadataId:{schemaId}} )-[r:Composition]->(m)   return m order by m.name ")
+    @Query("g.match((n:Neo4jSchema{metadataId:{schemaId}})-[r:Composition]->(m)).return(m).orderBy(m.name)")
     List<BaseNode> getChildrenBySchemaId(@Param("schemaId") String schemaId);
 
 
-    @Query("match (n:Neo4jSchema{metadataId:{schemaId}} )-[r:Composition]->(m:neo4jTable)   return m order by m.name ")
+    @Query("g.match((n:Neo4jSchema{metadataId:{schemaId}})-[r:Composition]->(m:neo4jTable)).return(m).orderBy(m.name)")
     List<BaseNode> getTableBySchemaId(@Param("schemaId") String schemaId);
 
-    @Query("match (n:Neo4jSchema{metadataId:{schemaId}} )-[r:Composition]->(m:neo4jTable)   return m order by m.name ")
+    @Query("g.match((n:Neo4jSchema{metadataId:{schemaId}})-[r:Composition]->(m:neo4jTable)).return(m).orderBy(m.name)")
     List<BaseNode> getColumnBySchemaId(@Param("schemaId") String schemaId);
 
-    @Query("match (n:Neo4jSchema{metadataId:{schemaId}} )-[r:Composition]->(m:neo4jView)   return m order by m.name ")
+    @Query("g.match((n:Neo4jSchema{metadataId:{schemaId}})-[r:Composition]->(m:neo4jView)).return(m).orderBy(m.name)")
     List<BaseNode> getViewBySchemaId(@Param("schemaId") String schemaId);
 
 
-    @Query("match (n:Neo4jSchema{metadataId:{schemaId}} )-[r:Composition]->(m:neo4jFunction)   return m order by m.name ")
+    @Query("g.match((n:Neo4jSchema{metadataId:{schemaId}})-[r:Composition]->(m:neo4jFunction)).return(m).orderBy(m.name)")
     List<BaseNode> getFunctionBySchemaId(@Param("schemaId") String schemaId);
 
 
-    @Query("match (n:Neo4jSchema{metadataId:{schemaId}} )-[r:Composition]->(m:neo4jProcedure)   return m order by m.name ")
+    @Query("g.match((n:Neo4jSchema{metadataId:{schemaId}})-[r:Composition]->(m:neo4jProcedure)).return(m).orderBy(m.name)")
     List<BaseNode> getProcedureBySchemaId(@Param("schemaId") String schemaId);
 }

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

@@ -16,10 +16,10 @@ public interface Neo4jSystemRepository extends GraphDbRepository<Neo4jSystem, Lo
 
     List<Neo4jSystem> findNeo4jSystemByName(String metadataName);
 //  @Query("MATCH p=(n:MetaData {metadataId:{parentId}})-[r:Composition]->(m) RETURN m limit {limit} ")
-    @Query("match (n:Neo4jSystem{metadataId:{systemId}} )-[r:Composition]->(m:Neo4jSchema)   return m ")
+    @Query("g.match((n:Neo4jSystem{metadataId:{systemId}})-[r:Composition]->(m:Neo4jSchema)).return(m)")
     List<Neo4jSchema> getSchemaBySystemId(@Param("systemId") String systemId);
 
 
-    @Query("match (n:Neo4jSystem{metadataId:{systemId}} )-[r:Composition]->(m:Neo4jETLJob)   return m ")
+    @Query("g.match((n:Neo4jSystem{metadataId:{systemId}})-[r:Composition]->(m:Neo4jETLJob)).return(m)")
     List<Neo4jETLJob> getEtlJobBySystemId(@Param("systemId") String systemId);
 }

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

@@ -17,46 +17,46 @@ public interface Neo4jTableRepository extends GraphDbRepository<Neo4jTable, Long
     List<Neo4jTable> findNeo4jTableByNameAndIsSystemAndIsEnvironment(String name,String systemName,String isEnvironment);
 
     //match (n:Neo4jTable{metadataId:"Table=1=de175ee0b21c473f915cefaad6d798f1"})-[r1:流向]->(n1)-[r0:TempInput*0..]->(m)-[r:流向]->(m1) return m1
-    @Query("match (n:Neo4jTable{metadataId:{tableId}})<-[r1:流向]-(n1)<-[r0:TempRelation*0..]-(m)<-[r:流向]-(m1) return m1 ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})<-[r1:流向]-(n1)<-[r0:TempRelation*0..]-(m)<-[r:流向]-(m1)).return(m1)")
     List<BaseNode> getSourceTable(@Param("tableId") String tableId);
 
 //    @Query("match (n{metadataId:{tableId}} )-[r1:流向]->(m1)-[r:流向]->(m)   return m ")
-    @Query("match (n:Neo4jTable{metadataId:{tableId}})-[r1:流向]->(n1)-[r0:TempRelation*0..]->(m)-[r:流向]->(m1) return m1 ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})-[r1:流向]->(n1)-[r0:TempRelation*0..]->(m)-[r:流向]->(m1)).return(m1)")
     List<BaseNode> getTargetTable(@Param("tableId") String tableId);
 
-    @Query("match (n{metadataId:{startTable}} )<-[r1:流向]-(m1)<-[r:流向]-(m{metadataId:{entTable}})   return m1 ")
+    @Query("g.match((n{metadataId:{startTable}})<-[r1:流向]-(m1)<-[r:流向]-(m{metadataId:{entTable}})).return(m1)")
     List<BaseNode> getSourceEtlScriptBetween2Table(@Param("startTable") String startTable,@Param("entTable") String entTable);
 
-    @Query("match (n:Neo4jTable{metadataId:{startTable}} )-[r1:流向]->(m1)-[r:流向]->(m{metadataId:{entTable}})   return m1 ")
+    @Query("g.match((n:Neo4jTable{metadataId:{startTable}})-[r1:流向]->(m1)-[r:流向]->(m{metadataId:{entTable}})).return(m1)")
     List<BaseNode> getTargetEtlScriptBetween2Table(@Param("startTable") String startTable,@Param("entTable") String entTable);
 
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}} )<-[r1:流向]-(m1) <-[r:Composition]-(m)  return m ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})<-[r1:流向]-(m1)<-[r:Composition]-(m)).return(m)")
     List<BaseNode> getSourceEtlJob(@Param("tableId") String tableId);
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}} )-[r1:流向]->(m1) <-[r:Composition]-(m)   return m ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})-[r1:流向]->(m1)<-[r:Composition]-(m)).return(m)")
     List<BaseNode> getTargetEtlJob(@Param("tableId") String tableId);
 
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}} ) <-[r:Composition]-(m)   return m ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})<-[r:Composition]-(m)).return(m)")
     List<BaseNode> getSchema(@Param("tableId") String tableId);
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}} ) -[r:Composition]->(m:Neo4jColumn)   return m ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})-[r:Composition]->(m:Neo4jColumn)).return(m)")
     List<Neo4jColumn> getColumnByTableId(@Param("tableId") String tableId);
 
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}})<-[r1:流向]-(m1) return m1 ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})<-[r1:流向]-(m1)).return(m1)")
     List<BaseNode> getSources(@Param("tableId") String tableId);
 
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}})-[r1:流向]->(m1) return m1 ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})-[r1:流向]->(m1)).return(m1)")
     List<BaseNode> getTargets(@Param("tableId") String tableId);
 
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}})<-[r1:Composition]-(m1) return m1 ")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})<-[r1:Composition]-(m1)).return(m1)")
     List<BaseNode> getParent(@Param("tableId") String tableId);
 
-    @Query("match (n:Neo4jTable{metadataId:{tableId}})  DELETE n")
+    @Query("g.match((n:Neo4jTable{metadataId:{tableId}})).delete(n)")
     Long deleteByTableId(@Param("tableId") String tableId);
 
 }