Der effizienteste Weg, um Ergebnisse von Neo4j zu erhalten

Question

Ich muss einen Knoten und alle damit verbundenen Knoten basierend auf einer Beziehung zurückgeben. Ein Beispiel für die Abfrage wäre wie:

MATCH (n) where id(n)= {neo_id} 
OPTIONAL MATCH p=(n)-[:OWNS]->(q) 

Wäre es effizienter zu sein, Knoten zu bekommen ‚n‘ auf eigenem und dann die Pfade in einem separaten Anruf erhalten, oder soll ich ein callthat gibt ‚n‘ tun und P'.

Addt. Information: Ich muss dies für mehrere Beziehungen tun, und ich habe festgestellt, dass jedes Mal, wenn ich eine Beziehung hinzufüge, die Kombinatorik zwischen allen Pfaden die Leistung verschlechtert. Beispiel:

MATCH (n) where id(n)= {neo_id} 
OPTIONAL MATCH p=(n)-[:OWNS]->(q:Something) 
OPTIONAL MATCH o=(n)-[:USES]->(r:SomethingElse) 
. 
. 
. 
OPTIONAL MATCH l=(n)-[:LOCATED_IN]->(r:NthSomethingElse) 
RETURN n, p, o,..., l 

oder

//Call 1 
MATCH (n) where id(n)= {neo_id} 
RETURN n 

//Call 2 
MATCH (n) where id(n)= {neo_id} 
OPTIONAL MATCH p=(n)-[:OWNS]->(q:Something) 
RETURN p 

//Call 3 
MATCH (n) where id(n)= {neo_id} 
OPTIONAL MATCH o=(n)-[:USES]->(r:SomethingElse) 
RETURN o 
. 
. 
. 
//Call nth 
MATCH (n) where id(n)= {neo_id} 
OPTIONAL MATCH l=(n)-[:LOCATED_IN]->(r:NthSomethingElse) 
RETURN l 

Answer 1

Wenn Sie wollen immer n bekommen (falls vorhanden), auch wenn sie keine Beziehungen hat, dann Ihre erste Abfrage ist wirklich der einzige Weg, das zu tun. Wenn Sie das nicht möchten, hat die Kombination der 2 Klauseln in 1 wahrscheinlich wenig Einfluss auf die Leistung.

Der Grund, warum Sie eine Verlangsamung jedes Mal bemerken, wenn Sie ein weiteres MATCH hinzufügen, liegt an "kartesischen Produkten". Das heißt: Wenn eine MATCH oder OPTIONAL MATCH Klausel "normalerweise" N Datenzeilen erzeugen würde, aber vorherige Klauseln in der gleichen Abfrage bereits M Datenzeilen erzeugt hätten, wäre die tatsächliche resultierende Anzahl von Zeilen M * N. So hat jedes extra MATCH einen multiplikativen Effekt auf die Anzahl der Datenzeilen. Je nach Anwendungsfall können Sie möglicherweise kartesische Produkte vermeiden, indem Sie die Aggregation auf die Ergebnisse aller (oder hoffentlich der meisten) MATCH Klauseln anwenden, die N in 1 (oder eine andere kleinere Zahl) verwandeln können. Zum Beispiel:

MATCH (n) where id(n)= {neo_id} 
OPTIONAL MATCH p=(n)-[:OWNS]->(:Something) 
WITH n, COLLECT(p) AS owns 
OPTIONAL MATCH o=(n)-[:USES]->(:SomethingElse) 
WITH n, owns, COLLECT(o) AS uses 
OPTIONAL MATCH l=(n)-[:LOCATED_IN]->(:NthSomethingElse) 
WITH n, owns, uses, COLLECT(l) AS located_in 
RETURN n, owns, uses, located_in;