Cypher: Shared Nodes ausschließen?

Question

Ich habe, was sich wie eine ziemlich einfache Cypher-Frage fühlt.

Ich habe die folgenden Daten, wobei ich zwei A-Knoten und 3 B-Knoten mit b1 zu a1, b2 zu a2 verwandt und b3 zu a1 und a2. Mein Ziel ist das Schreiben einer Cypher-Anweisung, die bei einem bestimmten A-Knoten die B-Knoten zurückgibt, die nur mit ihm verbunden sind und nicht mit einem anderen A-Knoten in Beziehung stehen. Wenn beispielsweise der Knoten a1 zurückgegeben wird, sollte die Abfrage b1 zurückgeben, und wenn der Knoten a2 übergeben wird, sollte b2 zurückgegeben werden. Der b3-Knoten, der sich sowohl auf a1 als auch auf a2 bezieht, sollte niemals von dieser Abfrage zurückgegeben werden, unabhängig davon, welcher Knoten angegeben wurde. Anders gesagt, ich versuche, die B-Knoten zu finden, die für einen gegebenen A-Knoten einzigartig sind, da die resultierenden B-Knoten nicht mit irgendeinem anderen A-Knoten verwandt sind als der, der in meiner Übereinstimmung spezifiziert ist.

Dieses Beispiel Daten werden (hoffentlich) mein Ziel klarer machen:

CREATE (n:A { code: 'a1' }) 
CREATE (n:A { code: 'a2' }) 
CREATE (n:B { code: 'b1' }) 
CREATE (n:B { code: 'b2' }) 
CREATE (n:B { code: 'b3' }) 

match (a:A), (b:B) where a.code = 'a1' and b.code = 'b1' create (a)<-[r:A_AND_B]-(b) return a, r, b 
match (a:A), (b:B) where a.code = 'a2' and b.code = 'b2' create (a)<-[r:A_AND_B]-(b) return a, r, b 
match (a:A), (b:B) where a.code = 'a1' and b.code = 'b3' create (a)<-[r:A_AND_B]-(b) return a, r, b 
match (a:A), (b:B) where a.code = 'a2' and b.code = 'b3' create (a)<-[r:A_AND_B]-(b) return a, r, b 

Wenn ich die gemeinsamen b3 Knoten aufzunehmen bereit war, würde die Abfrage einfach sein und sein:

Spiel (a: A) - [r: A_AND_B] - (b: B) wobei a.code = 'a1' zurück b

Dies gibt b1 und b2 zurück. Da ich jedoch alle B-Knoten einschließen möchte, die sich auf einen anderen A-Knoten beziehen (b2 sollte in diesem Fall nicht zurückgegeben werden), habe ich Schwierigkeiten, den richtigen Ansatz und die richtige Syntax zu finden.

Ich erkundete Cyphers WITH und OPTIONAL MATCH mit bisherigem Glück. Ich bin auch in der Lage zu erreichen, was ich will, wenn ich zwei getrennte Abfragen verwende, was ein bisschen ein Betrüger ist und die Lerngelegenheit umgeht.

Kann jemand einen Schub geben?

Answer 1

Wie wäre es etwa so:

match (a:A)-[:A_AND_B]-(b:B) 
where a.code = 'a1' 
match (b)-[r:A_AND_B]-(:A) 
with b, count(r) as c 
where c = 1 
return b