Cypher Match Pfad mit verschiedenen Tiefen

Question

Ich habe eine Frage, ich habe versucht, Informationen aus einer bestimmten Situation zu bekommen, die in meiner Neo4j-Datenbank aufgetreten ist. Hier ist die Knotenkonfiguration.

Ich brauche alle Knoten zu erhalten, die zu a und für alle eingehenden Verbindungen verbunden sind, muss ich dort eingehenden Verbindungsknoten finden und für den scheidenden alle von dort ausgehenden Knoten.

So würde ich erwarten a, b, c, d, l, f und e. Nicht g, h, i, j und k.

Was auch immer ich versuche, ich bekomme nicht das komplette Set in einer Abfrage. Ich bekomme oder zu viel oder zu wenig.

MATCH (n)-[r]-(m) WHERE n.name="a" 
RETURN n,m,r 

gibt nur a, b, c, f und l.

MATCH (n)-[r]-(m)-[s]->(x) 
WHERE n.name="a" 
RETURN n,m,r,s,x 

, dann verliere ich b und l.

Also muss ich etwas falsch machen. Gibt es eine Abfrage, die mir die Daten liefert, die ich brauche?

Answer 1

In Anbetracht dieser Ausgangsdatensatz (Das Datenmodell im Druckbild angezeigt):

CREATE (a:Node {name : 'a'}) 
CREATE (b:Node {name : 'b'}) 
CREATE (c:Node {name : 'c'}) 
CREATE (d:Node {name : 'd'}) 
CREATE (e:Node {name : 'e'}) 
CREATE (f:Node {name : 'f'}) 
CREATE (g:Node {name : 'g'}) 
CREATE (h:Node {name : 'h'}) 
CREATE (i:Node {name : 'i'}) 
CREATE (j:Node {name : 'j'}) 
CREATE (k:Node {name : 'k'}) 
CREATE (l:Node {name : 'l'}) 

CREATE (a)-[:CONNECTED_TO]->(c) 
CREATE (c)-[:CONNECTED_TO]->(d) 
CREATE (a)-[:CONNECTED_TO]->(l) 
CREATE (b)-[:CONNECTED_TO]->(a) 
CREATE (a)-[:CONNECTED_TO]->(f) 
CREATE (f)-[:CONNECTED_TO]->(e) 
CREATE (g)-[:CONNECTED_TO]->(f) 
CREATE (i)-[:CONNECTED_TO]->(g) 
CREATE (i)-[:CONNECTED_TO]->(h) 
CREATE (i)-[:CONNECTED_TO]->(j) 
CREATE (j)-[:CONNECTED_TO]->(k) 

Diese Abfrage sollte funktionieren:

// Match de start point 'A' 
MATCH (a:Node {name : 'a'}) 
// Match incoming nodes and optionally (0..1) incoming of incoming nodes 
MATCH (a)<-[:CONNECTED_TO]-(b:Node)<-[:CONNECTED_TO*0..1]-(c:Node) 
// collect b and c into rows, pass a to the next context 
WITH a, collect(b) + collect(c) as rows 
// Match outgoing nodes and optionally (0..1) outgoing of outgoing nodes 
MATCH (a)-[:CONNECTED_TO]->(b:Node)-[:CONNECTED_TO*0..1]->(c:Node) 
// collect all into rows 
WITH collect(a) + collect(b) + collect(c) + rows as rows 
// unwind 
UNWIND rows AS unwinded 
// return distinct nodes 
RETURN DISTINCT unwinded 
ORDER BY unwinded.name 

Das Ergebnis wird sein:

╒════════════╕ 
│"unwinded" │ 
╞════════════╡ 
│{"name":"a"}│ 
├────────────┤ 
│{"name":"b"}│ 
├────────────┤ 
│{"name":"c"}│ 
├────────────┤ 
│{"name":"d"}│ 
├────────────┤ 
│{"name":"e"}│ 
├────────────┤ 
│{"name":"f"}│ 
├────────────┤ 
│{"name":"l"}│ 
└────────────┘ 

EDIT:

Überarbeitete Abfrage:

MATCH (in2:Node)-[:CONNECTED_TO*0..1]->(in:Node)-[:CONNECTED_TO]->(a:Node {name : 'a'})-[:CONNECTED_TO]->(out:Node)-[:CONNECTED_TO*0..1]->(out2:Node) 
WITH collect(in2) + collect(in) + collect(a) + collect(out) + collect(out2) as rows 
UNWIND rows AS unwinded 
RETURN distinct unwinded 
ORDER BY unwinded.name 

Die obige Abfrage das gleiche Ergebnis erzeugt aber nur eine MATCH für das gesamte Muster anstelle von 3 verschiedenen MATCH es verwendet wird.