kind: reference search: Neo4j, Cypher, MATCH, WHERE, RETURN, Knoten, Beziehung, Label, Muster, count, WITH, shortestPath, CREATE, MERGE, SET, DELETE, Constraint, Index

Cypher für Neo4j

Cypher zum Nachschlagen, so wie in Filmdatenbank als Graph mit Neo4j: Muster aus Knoten und Beziehungen, Abfragen, Zählen und Gruppieren, Wege durch den Graphen, Daten ändern, Schlüssel und Indizes. Zum Vergleich steht jeweils dabei, wie dasselbe in SQL aussieht; SQL selbst steht unter SQL.

1. Muster

Eine Abfrage beschreibt, wie das Gesuchte im Graphen aussieht, als Zeichnung aus Text:

Muster Bedeutung
(m) ein Knoten, irgendeiner; m ist sein Name in dieser Abfrage
(m:Movie) ein Knoten mit dem Label Movie
(m:Movie {year: 1985}) mit einer Eigenschaft, die genau diesen Wert hat
(:Genre {name: 'Comedy'}) ohne Namen, wenn er später nicht gebraucht wird
(p)-[:ACTOR]->(m) eine Beziehung vom Typ ACTOR von p zu m
(p)-[r]->(m) eine Beziehung irgendeines Typs, mit dem Namen r; type(r) nennt ihren Typ
(a)-[:ACTOR]->(m)<-[:ACTOR]-(b) zwei Personen, die im selben Film spielen
(a)-[:ACTOR*..8]-(b) ein Weg aus höchstens 8 Beziehungen, in beliebiger Richtung (ohne Pfeilspitze)

Labels schreibt man groß (Movie), Beziehungstypen ganz groß (IN_GENRE), Eigenschaften klein (title). Groß- und Kleinschreibung zählt: :movie findet nichts.

2. Abfragen

MATCH (p:Person)-[:COMPOSER]->(m:Movie)
WHERE p.birth_year >= 1970 AND m.runtime < 100
RETURN DISTINCT p.name, p.birth_year
ORDER BY p.birth_year DESC, p.name
LIMIT 10;
Teil Was er tut In SQL
MATCH muster sucht alle Stellen im Graphen, auf die das Muster passt FROM und JOIN
WHERE bedingung behält nur die, für die sie gilt: =, <>, <, AND, OR, NOT, IS NULL WHERE
RETURN a, b.name AS name was ausgegeben wird; DISTINCT ohne Wiederholungen SELECT
ORDER BY x DESC, y sortiert, DESC absteigend; bei gleichem x nach y ORDER BY
LIMIT 10, SKIP 10 nur die ersten 10, die ersten 10 überspringen LIMIT, OFFSET

Texte stehen in einfachen oder doppelten Anführungszeichen. WHERE m.title CONTAINS 'Future', STARTS WITH und ENDS WITH suchen Teile von Texten, =~ '(?i).*zukunft.*' mit einem regulären Ausdruck, ohne Groß- und Kleinschreibung. Im Neo4j Browser zeigt RETURN m den Graphen, RETURN m.title eine Tabelle.

Zählen und gruppieren

MATCH (m:Movie)-[:IN_GENRE]->(g:Genre)
RETURN g.name, count(m) AS movies, round(avg(m.runtime)) AS minutes
ORDER BY movies DESC;

count, avg, min, max, sum und collect (alle Werte als Liste) fassen zusammen. Gruppiert wird nach allem anderen, was in RETURN steht, hier nach g.name; ein GROUP BY wie in SQL gibt es nicht. Eine Bedingung an ein gezähltes Ergebnis, in SQL HAVING, schreibt man mit WITH, das ein Zwischenergebnis weitergibt:

MATCH (d:Person)-[:DIRECTOR]->(m:Movie)<-[:CINEMATOGRAPHER]-(c:Person)
WITH d, c, count(m) AS together
WHERE together >= 3
RETURN d.name, c.name, together
ORDER BY together DESC;

Über mehrere Schritte

MATCH (:Person {name: 'Michael J. Fox'})-[:ACTOR]->(m:Movie)-[:IN_GENRE]->(g:Genre)
RETURN g.name, count(m) AS movies
ORDER BY movies DESC;

Ein Muster darf über mehrere Knoten gehen: von einer Person zu ihren Filmen und weiter zu deren Genres. In SQL wäre das eine lange Kette von JOINs.

MATCH (a:Person {name: 'Dwayne Johnson'}), (b:Person {name: 'Eddie Murphy'})
MATCH path = shortestPath((a)-[:ACTOR*..8]-(b))
RETURN path, length(path);

shortestPath findet den kürzesten Weg zwischen zwei Knoten, hier über gemeinsame Filme und höchstens 8 Beziehungen lang. length(path) zählt seine Beziehungen, nodes(path) gibt seine Knoten als Liste.

Ein Weg mit offener Länge (*) ohne Obergrenze kann in einem großen Graphen sehr lange dauern: Gib immer eine an, wie *..8.

3. Daten ändern

// einen Knoten anlegen
CREATE (:Genre {id: 99, name: 'Heimatfilm'});
// eine Beziehung zwischen zwei gefundenen Knoten anlegen
MATCH (m:Movie {id: 233}), (g:Genre {id: 99})
CREATE (m)-[:IN_GENRE]->(g);
// den Knoten finden, oder anlegen, wenn es ihn noch nicht gibt
MERGE (g:Genre {name: 'Heimatfilm'});
// eine Eigenschaft ändern oder anlegen
MATCH (m:Movie {id: 233}) SET m.runtime = 116;
// einen Knoten löschen, aber nur, wenn keine Beziehung mehr an ihm hängt
MATCH (g:Genre {id: 99}) DELETE g;
// ihn mit allen seinen Beziehungen löschen
MATCH (g:Genre {id: 99}) DETACH DELETE g;
MATCH (n) DETACH DELETE n löscht den ganzen Graphen, ohne Rückfrage. Die Filmdaten holst du danach nur zurück, indem du sie neu lädst.

Schlüssel und Indizes

CREATE CONSTRAINT movie_id IF NOT EXISTS FOR (m:Movie) REQUIRE m.id IS NODE KEY;
CREATE INDEX movie_title IF NOT EXISTS FOR (m:Movie) ON (m.title);
SHOW CONSTRAINTS;
SHOW INDEXES;

Ein Schlüssel verlangt, dass jeder Knoten mit dem Label die Eigenschaft hat und kein Wert doppelt vorkommt, wie ein Primärschlüssel in SQL. Ein Index macht die Suche nach einer Eigenschaft schnell und verbietet nichts.

4. SQL und Cypher

Frage SQL Cypher
ein Film SELECT * FROM movie WHERE title = '…' MATCH (m:Movie {title: '…'}) RETURN m
die Genres eines Films movie JOIN movie_genre JOIN genre (m:Movie)-[:IN_GENRE]->(g:Genre)
Filme je Genre GROUP BY genre.name RETURN g.name, count(m)
nur große Gruppen HAVING count(*) >= 3 WITH …, count(m) AS n WHERE n >= 3
ein Weg über viele Schritte ein JOIN je Schritt, oder rekursiv shortestPath((a)-[*..8]-(b))

5. Zum Nachschlagen