neo4j cypher Abfrage, um einen mittleren Knoten zu löschen und alle seine Elternknoten zu Kindknoten

Question

Wenn ich ein Diagramm durch Ausführen dieser Abfrage, dann möchte ich einen mittleren Knoten sagen 'und' und verbinden Sie den vorherigen Knoten sagen 'Grafik 'zu seinen untergeordneten Knoten sagen ‚db‘ durch seine entsprechenden abgehenden Beziehungen auf Basis von gleich ‚SEQID‘

MERGE (n:Person { name: 'graph'}) 

MERGE (n:Person { name: 'and'}) 

MERGE (n:Person { name: 'relational' }) 

MERGE (n:Person { name: 'nosql'}) 

MERGE (n:Person { name: 'server'}) 

MERGE (n:Person { name: 'db'}) 

MERGE (a:Person { name: 'graph'}) MERGE (b:Person { name: 'and' }) MERGE (a)-[:NEXT{seqid:1}]->(b) 

MERGE (a:Person { name: 'and' }) MERGE (b:Person { name: 'db'}) MERGE (a)-[:NEXT{seqid:1 , caps: 'true'}]->(b) 

MERGE (a:Person { name: 'relational'}) MERGE (b:Person { name: 'db'}) MERGE (a)-[:NEXT{seqid:1}]->(b) 

MERGE (a:Person { name: 'nosql'}) MERGE (b:Person { name: 'db' }) MERGE (a)-[:NEXT{seqid:2, caps: 'true'}]->(b) 

MERGE (a:Person { name: 'server'}) MERGE (b:Person { name: 'and' }) MERGE (a)-[:NEXT{seqid:1}]->(b) 

MERGE (a:Person { name: 'and' }) MERGE (b:Person { name: 'db'}) MERGE (a)-[:NEXT{seqid:1}]->(b) 

MERGE (a:Person { name: 'server'}) MERGE (b:Person { name: 'and'}) MERGE (a)-[:CONNECTS{seqid:2}]->(b) 

MERGE (a:Person { name: 'and' }) MERGE (b:Person { name: 'db'}) MERGE (a)-[:CONNECTS{seqid:2, caps: 'true'}]->(b) 

dh

(graph)-[:NEXT{seqid:1 , caps: 'true'}]->(db) 

(relational)-[:NEXT{seqid:1}]->(db) 

(nosql)-[:NEXT{seqid:2, caps: 'true'}]->(db) 

(server)-[:NEXT{seqid:1}]->(db) 

(server)-[:CONNECTS{seqid:2, caps: 'true'}]->(db) 

pls mir helfen, dieses Problem zu lösen ........ .....

(ich bin mit Neo4j 2.3.6 Community Edition über java api in Embedded-Modus ..)

Answer 1

Das Hindernis dabei ist, dass Beziehungstypen nicht dynamisch erstellt werden. Sie können nicht nach eingehenden Beziehungen suchen, deren Typ nicht kennen, und eine neue Beziehung desselben Typs erstellen.

Wenn Sie die Typen der Beziehungen kennen, die Sie verarbeiten müssen, und diese explizit adressieren können, können Sie dies mit Cypher tun. Hier ist die Abfrage dies für alle zu tun: NEXT Beziehungen, Kopieren über die Eigenschaften der Beziehung von dem mittleren Knoten zum Endknoten über auf die neuen Beziehung erstellt:

MATCH (middle:Person{name:'and'}) 
WITH middle 
MATCH (from:Person)-[rFrom:NEXT]->(middle) 
WHERE exists(rFrom.seqid) 
WITH middle, rFrom, from 
MATCH (middle)-[rTo:NEXT]->(to:Person) 
WHERE rTo.seqid = rFrom.seqid 
WITH middle, rFrom, from, rTo, to 
CREATE (from)-[rNew:NEXT]->(to) 
SET rNew += rTo 
DELETE rFrom 

Sie wollen, dies zu wiederholen, für jeden Beziehungstyp, an dem Sie interessiert sind, und wenn es keine Beziehungen mehr zu oder von Ihrem mittleren Knoten gibt, löschen Sie den Knoten.

Beachten Sie, dass bei der Aktualisierung auf neo4j 3 die Bibliothek APOC Procedures Prozeduren für das Refactoring von Diagrammen enthält, die leicht darauf reagieren.

EDIT

Altered meine Cypher oben statt MERGE zu tun CREATE.

Außerdem wurde das Löschen der Beziehungen vom mittleren zum nächsten Knoten entfernt, da Sie scheinbar die Beziehungseigenschaften aus der Beziehung zwischen dem mittleren und dem nächsten Knoten übernehmen möchten und mehrere eingehende Beziehungen zum mittlerer Knoten mit demselben Typ und derselben ID, aber nur eine einzelne Beziehung vom mittleren Knoten mit diesem Typ und dieser ID.

Das bedeutet, dass Ihr Verhältnis eingehender Beziehungen mit demselben Typ und derselben ID nicht den ausgehenden Beziehungen desselben Typs und derselben ID entspricht. Daher werden diese ausgehenden Beziehungen beim Erstellen der neuen Beziehungen wiederverwendet.

Erst nachdem Sie alle neuen Beziehungen erstellt haben, sollten Sie den mittleren Knoten trennen und löschen.

Answer 2

Hinzufügen einer weiteren Antwort, die alle Anforderungen erfüllt, aber Neo4j 3.0.x oder höher erfordert. Insbesondere erfordert dies die apoc.create.relationship()-Prozedur von APOC Procedures, die uns das Erstellen einer Beziehung mit einem dynamischen Typ ermöglicht, die aus den übereinstimmenden Beziehungen bereitgestellt wird.

Dies wird für alle Beziehungen auf einmal sorgen (zumindest diejenigen mit SEQID), so dass wir in Ordnung sein sollten, den mittleren Knoten am Ende zu lösen und zu lösen.

MATCH (middle:Person{name:'and'}) 
WITH middle 
MATCH (from:Person)-[rFrom]->(middle) 
WHERE EXISTS(rFrom.seqid) 
WITH middle, rFrom, from 
MATCH (middle)-[rTo]->(to:Person) 
WHERE TYPE(rTo) = TYPE(rFrom) AND rTo.seqid = rFrom.seqid 
WITH middle, rFrom, from, rTo, to 
CALL apoc.create.relationship(from, TYPE(rFrom), PROPERTIES(rTo), to) YIELD rel 
DETACH DELETE middle