Auf einen Blick: Neo4j Graph Database Queries bietet einen ausführlichen Leitfaden zur Ausführung von Abfragen in Neo4j, der sich auf das Erstellen von Knoten und Beziehungen mit Syntaxbeispielen für ein effektives Datenmanagement konzentriert.
- Anleitungen zum Start des Neo4j-Servers und zur Nutzung der Shell.
- Beispiele für das Erstellen von Knoten und den Aufbau von Beziehungen.
- Methoden zum Abfragen und Auflisten von Knoten und deren Beziehungen.
Im vorherigen Blogbeitrag, in dem wir Neo4j vorgestellt haben. Hier erklären wir Abfragen. Zuerst den Server starten und dann die Shell öffnen:
cd neo4j bin
./neo4j start
./cypher-shell -a bolt://localhost:7687 -u neo4j -p xxx
Knoten und Beziehungen erstellen
Hier erstellen wir zwei Knoten. Jeder hat das Label Friends und eine Namenseigenschaft . Beziehungen , die beide Eigenschaften haben können, können ebenfalls Eigenschaften haben.
CREATE (x:Friends { name: 'Walker' })
CREATE (y:Friends { name: 'Stephen' })
return x,y;
+------------------------------------------------------------+
| x | y |
+------------------------------------------------------------+
| (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) |
+------------------------------------------------------------+
1 row available after 15 ms, consumed after another 0 ms
Added 2 nodes, Set 2 properties, Added 2 labels
Hinweis: Rechtschreibung und Kasus sind wichtig. Neo4j gibt keine Vorwarnung, wenn etwas falsch geschrieben ist. Achte also beim Erstellen von Beziehungen zum Beispiel darauf, da diese ohne Vorwarnung leer sind. Achte also nach erstellten x-Beziehungen und x-Zeilen , die nach jeder Aussage verfügbar sind, um sicherzugehen, dass es funktioniert hat. Dann erstellen wir eine Beziehung (genannt Kante) von Stephen zu Walker. Wir geben dieser Relation den beliebigen Namen Friend. Wir setzen die Buchstaben x, y und r vor Objekte, damit wir sie in folgenden Schritten referenzieren können. Es ist also eine Kurznotation. Außerdem bringt sie das erstellte Objekt in den Scope. Das Verfahren zur Erstellung einer Relation besteht darin, die Knoten mit einer MATCH- und WHERE-Anweisung zusammenzuführen und dann die CREATE mit einem Richtungspfeil zu vergeben, der die Richtung der Relation anzeigt, oder eine einfache Linie, falls sie in beide Richtungen läuft. Zum Beispiel, wenn Stephen ein Freund von Walker ist, dann ist Walker ein Freund von Stephen. Der Pfeil könnte also eine einfache Linie sein. Sie verwenden doppelte Zeilen --, →, ←, wenn Sie die Richtung in der Abfrageanweisung (z. B. MATCH) angeben wollen, aber nicht in der Erstellungsanweisung.
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Stephen" AND x.name = "Walker"
CREATE (x)-[r:Friend]->(y)
RETURN type(r);
+----------+
| type(r) |
+----------+
| "Friend" |
+----------+
Liste alle Freundknoten auf
Nun probieren wir verschiedene Abfragen aus. Diese Liste listet alle Knoten auf, da wir ihr keine WHERE-Bedingung gegeben haben.
match(n:Friends)
return n;
+------------------------------+
| n |
+------------------------------+
| (:Friends {name: "Walker"}) |
| (:Friends {name: "Stephen"}) |
+------------------------------+
Liste alle Freundesbeziehungen auf.
MATCH (a:Friends)-[:Friend]->(b:Friends)
RETURN a.name, b.name;
+----------------------+
| a.name | b.name |
+----------------------+
| "Walker" | "Stephen" |
+----------------------+
Mach Raj-Freunde von Stephen.
CREATE (y:Friends { name: 'Raj' });
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Stephen" AND x.name = "Raj"
CREATE (x)-[r:Friend]->(y)
RETURN type(r);
Achte darauf, dass der Befehl (hauptsächlich die MATCH-Anweisung) funktioniert hat, indem du auf die zurückgegebenen Zahlen achtest. Erinnere dich an das, was wir über Rechtschreibfehler und Kasus gesagt haben.
1 row available after 3 ms, consumed after another 0 ms
Created 1 relationships
Zeigen Sie alle Freundesbeziehungen. Beachten Sie, dass jetzt auch die gerade hinzugefügte Beziehung enthalten ist
MATCH (a:Friends)-[r:Friend]->(b:Friends)
RETURN a.name, b.name;
+----------------------+
| a.name | b.name |
+----------------------+
| "Walker" | "Stephen" |
| "Raj" | "Stephen" |
+----------------------+
Füge noch eine weitere hinzu, Teresa, und mach sie dann zu Rajs Freundin.
CREATE (x:Friends { name: 'Teresa' })
return x;
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Stephen" AND x.name = "Raj"
CREATE (x)-[r:Friend]->(y);
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Raj" AND x.name = "Teresa"
CREATE (x)-[r:Friend]->(y)
RETURN type(r);
Unten sind Freunde von Freunden, die nicht zueinander sind. Das wäre, Teresa und Stephen sind keine Freunde. Um das mathematisch zu fassen, was das Verständnis erleichtern könnte, könnten wir sagen, dass wir nach der Schnittmenge u und nichtFreund suchen und dann WO NICHT anwenden, um Objekte außerhalb dieser Schnittstelle zu finden. Um uns zu erinnern, welche Freunde wir haben, um das Sehen zu erleichtern, erstens:
Match (a:Friends)--(b)
return a,b;
+-------------------------------------------------------------+
| a | b |
+-------------------------------------------------------------+
| (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) |
| (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) |
| (:Friends {name: "Stephen"}) | (:Friends {name: "Walker"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Teresa"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Teresa"}) | (:Friends {name: "Raj"}) |
+-------------------------------------------------------------+
Die Anfrage friends who.are-not-friends-of listet Teresa und Stephen auf, weil Teresa keine Freundin von Stephen ist. Mit anderen Worten: Der erste Teil der Abfrage zeigt alle Beziehungen für jene in der Variable u aufgeführten Personen an, dann listet er an, wer nicht in u ist.
Match (u:Friends)-[:Friend]->(:Friends)-[:Friend]->(notFriend:Friends)
WHERE NOT (u)-[:Friend]->(notFriend)
RETURN u, notFriend;
+------------------------------------------------------------+
| u | notFriend |
+------------------------------------------------------------+
| (:Friends {name: "Teresa"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Teresa"}) | (:Friends {name: "Stephen"}) |
+------------------------------------------------------------+
Gerichtete Beziehungen
Jetzt schaffen wir eine Beziehung in die entgegengesetzte Richtung Freund A < - Freund B statt Freund A -> Freund B , indem wir den Richtungspfeil an die erste Position in der CREATE-Erklärung setzen.
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Raj" AND x.name = "Teresa"
CREATE (x)< -[r:Friend]-(y)
RETURN type(r);
Listen Sie nun alle Relationen auf, zuerst die linke, dann die nicht-gerichtete und dann nach rechts. Eine ausgehende Beziehung von einem Friends-Knoten zu einem anderen ist dieselbe wie eine eingehende Beziehung, da die Knoten gleich sind. Die erste und letzte Abfrage listen also dieselben 4 Relationen auf. Und eine bidirektionale Abfrage listet 8 auf, da ein eingehender und ein ausgehender Knoten beide als Relation in beide Richtungen gelten, was die -- bedeutet.. Es wäre einfacher, all das zu sehen, wenn wir eine Gruppe von Knoten Kunden und eine andere AccountManager nennen würden, da es keine logische Symmetrie geben würde. Wir werden Beispiele wie diese in späteren Blogbeiträgen aufbauen.
Match (a:Friends)< --(b) return a,b; +------------------------------------------------------------+ | a | b | +------------------------------------------------------------+ | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Walker"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Teresa"}) | +------------------------------------------------------------+ Match (a:Friends)--(b) return a,b; +-------------------------------------------------------------+ | a | b | +-------------------------------------------------------------+ | (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Walker"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Teresa"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) | | (:Friends {name: "Teresa"}) | (:Friends {name: "Raj"}) | +-------------------------------------------------------------+ 8 rows available after 22 ms, consumed after another 2 ms Match (a:Friends)-->(b)
return a,b;
+------------------------------------------------------------+
| a | b |
+------------------------------------------------------------+
| (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Teresa"}) | (:Friends {name: "Raj"}) |
+------------------------------------------------------------+
4 rows available after 24 ms, consumed after another 2 ms
Leitfaden zur Datenvisualisierung
- Der Datenvisualisierungs-Anfängerleitfaden
- Einführung in Graphdatenbanken
- Anwendungsfälle für Graphdatenbanken
- Einführung in die Neo4j-Graphdatenbank
- Neo4j-Graphdatenbank-Abfragen
- Matplotlib-Streu- und Liniendiagramme erklärt
- Wie man Nebenhandlungen in Matplotlib hinzufügt
- Matplotlib-Logarithmische Skala
- Verwendung von Matplotlib zum Zeichnen von Diagrammen und Graphen
- Wie man 3D-Diagramme mit Matplotlib zeichnet
- Plotly Python Tutorial
- Ermöglichung der Bürgerdatenwissenschaftler
Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.