Die Abfragesprache Cypher wurde ursprünglich speziell für das grafische DBMS Neo4j entwickelt . Cyphers Ziel ist es, eine für Menschen lesbare SQL-Datenbank-Abfragesprache für Graphendatenbanken bereitzustellen. Heutzutage wird Cypher von mehreren Graph-DBMS unterstützt. OpenCypher wurde erstellt, um Cypher zu standardisieren.
Die Grundlagen der Arbeit mit dem Neo4j-DBMS werden im Artikel Grundlagen der Arbeit mit Neo4j in einem Browser beschrieben .
Betrachten Sie zum Kennenlernen von Cypher ein Beispiel eines Stammbaums, der aus dem klassischen Prolog-Lehrbuch von I. Bratko entlehnt wurde. In diesem Beispiel wird gezeigt, wie Sie einem Diagramm Knoten und Links hinzufügen, ihnen Beschriftungen und Attribute zuweisen und Fragen stellen.
Lassen Sie uns also einen Stammbaum auf dem Bild unten zeigen.
Mal sehen, wie man das entsprechende Diagramm in Cypher erstellt:
CREATE (pam:Person {name: "Pam"}), (tom:Person {name: "Tom"}), (kate:Person {name: "Kate"}), (mary:Person {name: "Mary"}), (bob:Person {name: "Bob"}), (liz:Person {name: "Liz"}), (dick:Person {name: "Dick"}), (ann:Person {name: "Ann"}), (pat:Person {name: "Pat"}), (jack:Person {name: "Jack"}), (jim:Person {name: "Jim"}), (joli:Person {name: "Joli"}), (pam)-[:PARENT]->(bob), (tom)-[:PARENT]->(bob), (tom)-[:PARENT]->(liz), (kate)-[:PARENT]->(liz), (mary)-[:PARENT]->(ann), (bob)-[:PARENT]->(ann), (bob)-[:PARENT]->(pat), (dick)-[:PARENT]->(jim), (ann)-[:PARENT]->(jim), (pat)-[:PARENT]->(joli), (jack)-[:PARENT]->(joli)
Eine CREATE-Anforderung zum Hinzufügen von Daten zu einem grafischen DBMS besteht aus zwei Teilen: Hinzufügen von Knoten und Hinzufügen von Verknüpfungen zwischen diesen. Jedem hinzuzufügenden Knoten wird im Rahmen dieser Anfrage ein Name zugewiesen, über den dann Verknüpfungen erstellt werden. Knoten und Kommunikationen können Dokumente speichern. In unserem Fall enthalten die Knoten Dokumente mit den Namensfeldern und die Dokumentverknüpfungen nicht. Auch Knoten und Links können beschriftet werden. In unserem Fall haben die Knoten die Bezeichnung Person und die Verknüpfungen sind PARENT. Die Bezeichnung in Anforderungen wird durch einen Doppelpunkt vor dem Namen hervorgehoben.
Also sagte uns Neo4j: Es wurden Added 12 labels, created 12 nodes, set 12 properties, created 11 relationships, completed after 9 ms.
Mal sehen, was wir haben:
MATCH (p:Person) RETURN p
Niemand verbietet uns, das Erscheinungsbild des resultierenden Graphen zu bearbeiten:
Was kann man damit machen? Sie können überprüfen, ob es sich beispielsweise um Pam handelt
Bobs Eltern:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Bob"}) RETURN ans
Wir erhalten den entsprechenden Untergraphen:
Dies ist jedoch nicht genau das, was wir brauchen. Ändern Sie die Anfrage:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Bob"}) RETURN ans IS NOT NULL
Jetzt als Antwort werden wir true . Und wenn wir fragen:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Liz"}) RETURN ans IS NOT NULL
Wir bekommen nichts ... Hier müssen Sie das Wort OPTIONAL , wenn
Das Ergebnis ist leer, dann wird false zurückgegeben:
OPTIONAL MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Liz"}) RETURN ans IS NOT NULL
Jetzt bekommen wir die erwartete Antwort false .
Als nächstes können Sie sehen, wer der Elternteil von wem ist:
MATCH (p1:Person)-[:PARENT]->(p2:Person) RETURN p1, p2
Öffnen Sie die Ergebnisregisterkarte mit Text und sehen Sie eine Tabelle mit zwei Spalten:
╒═══════════════╤═══════════════╕ │"p1" │"p2" │ ╞═══════════════╪═══════════════╡ │{"name":"Pam"} │{"name":"Bob"} │ ├───────────────┼───────────────┤ │{"name":"Tom"} │{"name":"Bob"} │ ├───────────────┼───────────────┤ │{"name":"Tom"} │{"name":"Liz"} │ ├───────────────┼───────────────┤ │{"name":"Kate"}│{"name":"Liz"} │ ├───────────────┼───────────────┤ │{"name":"Mary"}│{"name":"Ann"} │ ├───────────────┼───────────────┤ │{"name":"Bob"} │{"name":"Ann"} │ ├───────────────┼───────────────┤ │{"name":"Bob"} │{"name":"Pat"} │ ├───────────────┼───────────────┤ │{"name":"Dick"}│{"name":"Jim"} │ ├───────────────┼───────────────┤ │{"name":"Ann"} │{"name":"Jim"} │ ├───────────────┼───────────────┤ │{"name":"Pat"} │{"name":"Joli"}│ ├───────────────┼───────────────┤ │{"name":"Jack"}│{"name":"Joli"}│ └───────────────┴───────────────┘
Was können wir noch lernen? Zum Beispiel, wer ist der Elternteil eines bestimmten Mitglieds der Gattung, zum Beispiel für Bob:
MATCH (parent:Person)-[:PARENT]->(:Person {name: "Bob"}) RETURN parent.name
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Tom" │ ├─────────────┤ │"Pam" │ └─────────────┘
Als Antwort fordern wir hier nicht den gesamten Knoten an, sondern nur dessen spezifisches Attribut.
Wir können auch herausfinden, wer Bobs Kinder sind:
MATCH (:Person {name: "Bob"})-[:PARENT]->(child:Person) RETURN child.name
╒════════════╕ │"child.name"│ ╞════════════╡ │"Ann" │ ├────────────┤ │"Pat" │ └────────────┘
Wir können auch fragen, wer Kinder hat:
MATCH (parent:Person)-[:PARENT]->(:Person) RETURN parent.name
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Pam" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Kate" │ ├─────────────┤ │"Mary" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Dick" │ ├─────────────┤ │"Ann" │ ├─────────────┤ │"Pat" │ ├─────────────┤ │"Jack" │ └─────────────┘
Hmm, Tom und Bob haben sich zweimal getroffen.
MATCH (parent:Person)-[:PARENT]->(:Person) RETURN DISTINCT parent.name
Wir haben das Wort DISTINCT zum Rückgabeergebnis der Abfrage hinzugefügt, was bedeutet
ähnlich wie in SQL.
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Pam" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Kate" │ ├─────────────┤ │"Mary" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Dick" │ ├─────────────┤ │"Ann" │ ├─────────────┤ │"Pat" │ ├─────────────┤ │"Jack" │ └─────────────┘
Möglicherweise stellen Sie auch fest, dass Neo4j die Eltern in der Reihenfolge an uns zurückgibt, in der sie in der CREATE Anforderung eingegeben wurden.
Fragen wir nun, wer Großvater oder Großmutter ist:
MATCH (grandparent:Person)-[:PARENT]->()-[:PARENT]->(:Person) RETURN DISTINCT grandparent.name
Großartig, das wars:
╒══════════════════╕ │"grandparent.name"│ ╞══════════════════╡ │"Tom" │ ├──────────────────┤ │"Pam" │ ├──────────────────┤ │"Bob" │ ├──────────────────┤ │"Mary" │ └──────────────────┘
In der Abfragevorlage haben wir einen namenlosen Zwischenknoten () und zwei Relationen vom Typ PARENT .
Wir finden jetzt heraus, wer der Vater ist. Der Vater ist ein Mann, der ein Kind hat. Daher fehlen uns Daten darüber, wer der Mann ist. Um festzustellen, wer eine Mutter ist, müssen Sie daher wissen, wer eine Frau ist. Fügen Sie die relevanten Informationen zu unserer Datenbank hinzu. Zu diesem Zweck weisen wir den vorhandenen Knoten die Bezeichnungen Male und Female zu.
MATCH (p:Person) WHERE p.name IN ["Tom", "Dick", "Bob", "Jim", "Jack"] SET p:Male
MATCH (p:Person) WHERE p.name IN ["Pam", "Kate", "Mary", "Liz", "Ann", "Pat", "Joli"] SET p:Female
Lassen Sie uns erklären, was wir hier gemacht haben: Wir haben alle Knoten mit der Bezeichnung Person und überprüft
die Namenseigenschaft gemäß der in eckigen Klammern angegebenen Liste und den entsprechenden Knoten die Bezeichnung Male bzw. Female .
Überprüfen Sie:
MATCH (p:Person) WHERE p:Male RETURN p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Tom" │ ├────────┤ │"Bob" │ ├────────┤ │"Dick" │ ├────────┤ │"Jack" │ ├────────┤ │"Jim" │ └────────┘
MATCH (p:Person) WHERE p:Female RETURN p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Pam" │ ├────────┤ │"Kate" │ ├────────┤ │"Mary" │ ├────────┤ │"Liz" │ ├────────┤ │"Ann" │ ├────────┤ │"Pat" │ ├────────┤ │"Joli" │ └────────┘
Wir haben alle Knoten mit der Bezeichnung Person angefordert, die auch die Bezeichnung Male bzw. Female haben. Aber wir könnten unsere Anfragen ein wenig anders stellen:
MATCH (p:Person:Male) RETURN p.name MATCH (p:Person:Female) RETURN p.name
Schauen wir uns noch einmal unser Diagramm an:
Neo4j Browser hat die Knoten in zwei verschiedenen Farben gemalt, entsprechend den Markierungen von Male und
Weiblich
Ok, jetzt können wir alle Väter aus der Datenbank abfragen:
MATCH (p:Person:Male)-[:PARENT]->(:Person) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Tom" │ ├────────┤ │"Bob" │ ├────────┤ │"Dick" │ ├────────┤ │"Jack" │ └────────┘
Und Mütter:
MATCH (p:Person:Female)-[:PARENT]->(:Person) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Pam" │ ├────────┤ │"Kate" │ ├────────┤ │"Mary" │ ├────────┤ │"Ann" │ ├────────┤ │"Pat" │ └────────┘
Formulieren wir nun eine Bruder-Schwester-Beziehung. X ist Bruder von Y,
Wenn er ein Mann ist und für X und Y gibt es mindestens einen gemeinsamen Elternteil. Ähnliches gilt für
Beziehungsschwester.
Bruder Attitude über Cypher:
MATCH (brother:Person:Male)<-[:PARENT]-()-[:PARENT]->(p:Person) RETURN brother.name, p.name
╒══════════════╤════════╕ │"brother.name"│"p.name"│ ╞══════════════╪════════╡ │"Bob" │"Liz" │ └──────────────┴────────┘
Schwester Haltung zu Cypher:
MATCH (sister:Person:Female)<-[:PARENT]-()-[:PARENT]->(p:Person) RETURN sister.name, p.name
╒═════════════╤════════╕ │"sister.name"│"p.name"│ ╞═════════════╪════════╡ │"Liz" │"Bob" │ ├─────────────┼────────┤ │"Ann" │"Pat" │ ├─────────────┼────────┤ │"Pat" │"Ann" │ └─────────────┴────────┘
So können wir herausfinden, wer wessen Elternteil ist und wer wessen Großvater oder Großmutter ist. Aber was ist mit den entfernteren Vorfahren? Mit Urgroßvätern, Ururgroßvätern oder so weiter? Wir werden nicht für jeden dieser Fälle eine entsprechende Regel schreiben, und sie wird jedes Mal problematischer. Tatsächlich ist alles einfach: X ist ein Vorfahr für Y, wenn es ein Vorfahr für ein übergeordnetes Y ist. Cypher bietet ein Muster * , mit dem Sie eine Folge von Beziehungen beliebiger Länge anfordern können:
MATCH (p:Person)-[*]->(s:Person) RETURN DISTINCT p.name, s.name
Es gibt wirklich ein Problem dabei: Es wird irgendwelche Verbindungen geben. Fügen Sie einen Verweis auf den Link PARENT :
MATCH (p:Person)-[:PARENT*]->(s:Person) RETURN DISTINCT p.name, s.name
Um die Länge des Artikels nicht zu vergrößern, finden wir alle Vorfahren von Joli :
MATCH (p:Person)-[:PARENT*]->(:Person {name: "Joli"}) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Jack" │ ├────────┤ │"Pat" │ ├────────┤ │"Bob" │ ├────────┤ │"Pam" │ ├────────┤ │"Tom" │ └────────┘
Betrachten Sie eine komplexere Regel, um herauszufinden, wer mit wem verwandt ist.
Erstens sind Verwandte Vorfahren und Nachkommen, zum Beispiel ein Sohn und eine Mutter, eine Großmutter und ein Enkel. Zweitens sind Verwandte Brüder und Schwestern, einschließlich Cousins, Second Cousins und so weiter, was in Bezug auf Vorfahren bedeutet, dass sie einen gemeinsamen Vorfahren haben. Und drittens gelten Verwandte, die gemeinsame Nachkommen haben, zum Beispiel Ehemann und Ehefrau, als Verwandte.
In Cypher müssen Sie UNION für viele Muster verwenden:
MATCH (r1:Person)-[:PARENT*]-(r2:Person) RETURN DISTINCT r1.name, r2.name UNION MATCH (r1:Person)<-[:PARENT*]-(:Person)-[:PARENT*]->(r2:Person) RETURN DISTINCT r1.name, r2.name UNION MATCH (r1:Person)-[:PARENT*]->(:Person)<-[:PARENT*]-(r2:Person) RETURN DISTINCT r1.name, r2.name
Hier werden in der ersten Regel Verbindungen verwendet, deren Richtung für uns unerheblich ist. Eine solche Verbindung ist ohne Pfeil, nur mit einem Strich angedeutet - . Die zweite und dritte Regel sind offensichtlich und vertraut geschrieben.
Wir geben hier nicht das Ergebnis der Gesamtabfrage an, sondern sagen nur, dass es sich bei den gefundenen Verwandtenpaaren um 132 handelt, was mit dem berechneten Wert als Anzahl der geordneten Paare von 12 übereinstimmt. Wir könnten diese Abfrage auch angeben, indem wir das Vorkommen der Variablen r1 oder r2 durch (:Person {name: "Liz"}) ist jedoch in unserem Fall nicht sehr sinnvoll, da alle Personen in unserer Datenbank offensichtlich Verwandte sind.
Dies schließt unsere Diskussion über die Identifizierung von Beziehungen zwischen Personen in unserer Datenbank ab.
Zuletzt überlegen Sie, wie Sie Knoten und Verknüpfungen entfernen.
Um alle unsere Personen zu löschen, können Sie die Anfrage ausführen:
MATCH (p:Person) DELETE p
Neo4j teilt uns jedoch mit, dass Sie keine Knoten mit Links löschen können.
Daher löschen wir zuerst die Links und wiederholen dann das Entfernen von Knoten:
MATCH (p1:Person)-[r]->(p2:Person) DELETE r
Was wir jetzt gemacht haben: Zwei Personen, zwischen denen eine Verbindung besteht, verglichen, diese Verbindung als r und dann gelöscht.
Fazit
Der Artikel zeigt anhand eines einfachen Beispiels für ein soziales Diagramm, wie die Funktionen der Cypher-Abfragesprache verwendet werden. Insbesondere haben wir untersucht, wie Sie Knoten und Links mit einer Abfrage hinzufügen, nach verwandten Daten suchen, einschließlich indirekter Links, und wie Sie Knoten Bezeichnungen zuweisen. Weitere Informationen zu Cypher finden Sie unter den folgenden Links. Ein guter Ausgangspunkt ist die "Neo4j Cypher Refcard".
Neo4j ist bei weitem nicht das einzige Graph-DBMS. Zu den bekanntesten zählen Cayley , Dgraph mit GraphQL-Abfragesprache, Multi-Model- ArangoDB und OrientDB . Von besonderem Interesse ist möglicherweise Blazegraph mit Unterstützung für RDF und SPARQL.
Referenzen
Bibliographie
- Robinson Jan, Weber Jim und Eifrem Emil. Graph-Datenbanken. Neue Funktionen
für die Arbeit mit verwandten Daten / Per. aus dem Englischen - 2nd ed. - M .: DMK-Press,
2016 - 256 s. - Bratko I. Programmierung in Prologsprache für künstliche Intelligenz:
trans. aus dem Englischen - M .: Mir, 1990 .-- 560 S.: krank.
Nachwort
Der Autor des Artikels kennt nur zwei Unternehmen (beide aus St. Petersburg), die graphische DBMS für ihre Produkte verwenden. Aber ich würde gerne wissen, wie viele Unternehmen von Lesern dieses Artikels sie in ihrer Entwicklung verwenden. Daher schlage ich vor, an der Umfrage teilzunehmen. Schreiben Sie auch über Ihre Erfahrungen in den Kommentaren, es wird sehr interessant zu wissen sein.