Neo4j und Cypher Cheat Sheet

Vollständige Referenz für essenzielle Unix/Linux-Kommandozeilen-Tools: find, grep, sed, awk, xargs und Textverarbeitungs-Utilities.

Ein praktischer Quick-Reference-Guide für Neo4j Graphdatenbank-Operationen und die Cypher-Abfragesprache. Die Befehle sind nach Kategorien geordnet und mit realistischen Beispielen versehen.

Daten erstellen

Knoten erstellen

-- Create a single node
CREATE (p:Person {name: 'Alice', age: 30})

-- Create multiple nodes in one query
CREATE (p1:Person {name: 'Alice'}),
       (p2:Person {name: 'Bob'}),
       (p3:Person {name: 'Charlie'})

-- Create node with multiple labels
CREATE (p:Person:Employee {name: 'Alice', department: 'Engineering'})

-- Create node and return it
CREATE (p:Person {name: 'Alice'})
RETURN p

Beziehungen erstellen

-- Create a relationship between existing nodes
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:KNOWS]->(b)

-- Create relationship with properties
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:KNOWS {since: 2020, strength: 'strong'}]->(b)

-- Create nodes and relationship in one query
CREATE (a:Person {name: 'Alice'})-[:WORKS_FOR {role: 'Engineer'}]->(c:Company {name: 'TechCorp'})

-- Create multiple relationships
MATCH (a:Person {name: 'Alice'})
CREATE (a)-[:LIVES_IN]->(:City {name: 'Seattle'}),
       (a)-[:WORKS_FOR]->(:Company {name: 'TechCorp'})

MERGE (Erstellen, falls nicht vorhanden)

-- Create node only if it does not exist
MERGE (p:Person {name: 'Alice'})

-- MERGE with ON CREATE and ON MATCH
MERGE (p:Person {name: 'Alice'})
ON CREATE SET p.created = timestamp(), p.age = 30
ON MATCH SET p.lastSeen = timestamp()

-- MERGE relationship
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
MERGE (a)-[r:KNOWS]->(b)
ON CREATE SET r.since = 2020

Muster abgleichen (Matching Patterns)

Basis-MATCH

-- Find all nodes with a label
MATCH (p:Person)
RETURN p

-- Find nodes with property filter
MATCH (p:Person {name: 'Alice'})
RETURN p

-- Find with multiple conditions
MATCH (p:Person)
WHERE p.age > 25 AND p.city = 'Seattle'
RETURN p.name, p.age

-- Limit results
MATCH (p:Person)
RETURN p
LIMIT 10

Beziehungsmuster

-- Outgoing relationship
MATCH (a:Person {name: 'Alice'})-[:KNOWS]->(b)
RETURN b.name

-- Incoming relationship
MATCH (a)<-[:WORKS_FOR]-(e:Person)
RETURN a.name AS company, e.name AS employee

-- Any direction
MATCH (a:Person)-[:KNOWS]-(b:Person)
RETURN a.name, b.name

-- Multiple hops (2 hops away)
MATCH (a:Person {name: 'Alice'})-[:KNOWS*2]->(b)
RETURN DISTINCT b.name

-- Variable length paths (1 to 3 hops)
MATCH (a:Person {name: 'Alice'})-[:KNOWS*1..3]->(b)
RETURN DISTINCT b.name

-- Any length path
MATCH (a:Person {name: 'Alice'})-[:KNOWS*]->(b)
RETURN DISTINCT b.name

Optionale Muster

-- Äquivalent zu LEFT JOIN (gibt null zurück, wenn kein Treffer vorliegt)
MATCH (p:Person)
OPTIONAL MATCH (p)-[:WORKS_FOR]->(c:Company)
RETURN p.name, c.name AS company

-- Optionale Beziehung mit Bedingung MATCH (p:Person) OPTIONAL MATCH (p)-[r:WORKS_FOR]->(c:Company) WHERE r.role = 'Engineer' RETURN p.name, c.name

## Updating Data

### SET (Add/Update Properties)

```cypher
-- Eine Eigenschaft aktualisieren
MATCH (p:Person {name: 'Alice'})
SET p.age = 31

-- Mehrere Eigenschaften hinzufügen
MATCH (p:Person {name: 'Alice'})
SET p.age = 31, p.city = 'Portland', p.updated = timestamp()

-- Alle Eigenschaften ersetzen
MATCH (p:Person {name: 'Alice'})
SET p = {name: 'Alice', age: 31, city: 'Portland'}

-- Zu bestehenden Eigenschaften hinzufügen
MATCH (p:Person {name: 'Alice'})
SET p += {age: 31, city: 'Portland'}

-- Label hinzufügen
MATCH (p:Person {name: 'Alice'})
SET p:Employee

REMOVE (Delete Properties or Labels)

-- Eine Eigenschaft entfernen
MATCH (p:Person {name: 'Alice'})
REMOVE p.tempProperty

-- Mehrere Eigenschaften entfernen
MATCH (p:Person {name: 'Alice'})
REMOVE p.tempProperty, p.draft

-- Ein Label entfernen
MATCH (p:Person {name: 'Alice'})
REMOVE p:Employee

-- Mehrere Labels entfernen
MATCH (p:Person {name: 'Alice'})
REMOVE p:Employee:Contractor

DELETE (Delete Nodes and Relationships)

-- Einen Knoten löschen (darf keine Beziehungen haben)
MATCH (p:Person {name: 'Alice'})
DELETE p

-- Eine Beziehung löschen
MATCH (a:Person {name: 'Alice'})-[r:KNOWS]->(b:Person {name: 'Bob'})
DELETE r

-- Knoten und alle seine Beziehungen löschen
MATCH (p:Person {name: 'Alice'})
DETACH DELETE p

-- Alle Knoten eines Typs löschen (gefährlich!)
MATCH (p:Person)
DETACH DELETE p

Relationships

Creating Relationships

-- Einfache Beziehung
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CREATE (a)-[:FRIEND]->(b)

-- Mit Eigenschaften
MATCH (a:Person {name: 'Alice'}), (b:Company {name: 'TechCorp'})
CREATE (a)-[:WORKS_FOR {since: 2020, role: 'Engineer'}]->(b)

-- Mehrere Beziehungstypen (Verwendung von | für ODER in Patterns)
MATCH (a:Person)-[r:KNOWS|FRIEND]->(b:Person)
RETURN type(r), a.name, b.name

Traversing Relationships

-- Ausgehend (Pfeil zeigt nach rechts)
MATCH (a:Person)-[:KNOWS]->(b)
RETURN a.name, b.name

-- Eingehend (Pfeil zeigt nach links)
MATCH (a:Person)<-[:KNOWS]-(b)
RETURN a.name, b.name

-- In beide Richtungen (keine Pfeilspitze)
MATCH (a:Person)-[:KNOWS]-(b)
RETURN a.name, b.name

-- Benannte Beziehung für den Zugriff auf Eigenschaften
MATCH (a:Person)-[r:KNOWS]->(b)
RETURN r.since, a.name, b.name

-- Variable Länge (min. 1, max. 5 Hops)
MATCH (a:Person)-[:KNOWS*1..5]->(b)
RETURN a.name, b.name

-- Exakte Länge (genau 2 Hops)
MATCH (a:Person)-[:KNOWS*2]->(b)
RETURN a.name, b.name
## Filtern

### WHERE-Klausel

```cypher
-- Basic comparison
MATCH (p:Person)
WHERE p.age > 30
RETURN p.name

-- Multiple conditions
MATCH (p:Person)
WHERE p.age > 25 AND p.city = 'Seattle'
RETURN p.name

-- OR condition
MATCH (p:Person)
WHERE p.city = 'Seattle' OR p.city = 'Portland'
RETURN p.name

-- String matching
MATCH (p:Person)
WHERE p.name STARTS WITH 'A'
RETURN p.name

MATCH (p:Person)
WHERE p.name ENDS WITH 'son'
RETURN p.name

MATCH (p:Person)
WHERE p.name CONTAINS 'ali'
RETURN p.name

-- Regular expression
MATCH (p:Person)
WHERE p.name =~ 'A.*'
RETURN p.name

IN und Bereiche

-- IN list
MATCH (p:Person)
WHERE p.city IN ['Seattle', 'Portland', 'San Francisco']
RETURN p.name

-- Numeric range
MATCH (p:Person)
WHERE p.age >= 25 AND p.age <= 35
RETURN p.name

-- Using IN with numbers
MATCH (p:Person)
WHERE p.age IN [25, 30, 35, 40]
RETURN p.name

EXISTS und Musterabgleich

-- Check if property exists
MATCH (p:Person)
WHERE EXISTS(p.email)
RETURN p.name

-- Check if relationship exists
MATCH (p:Person)
WHERE EXISTS((p)-[:WORKS_FOR]->())
RETURN p.name

-- NOT EXISTS
MATCH (p:Person)
WHERE NOT EXISTS((p)-[:WORKS_FOR]->())
RETURN p.name

-- Pattern in WHERE
MATCH (p:Person)
WHERE (p)-[:LIVES_IN]->(:City {name: 'Seattle'})
RETURN p.name

NULL-Behandlung

-- Check for null
MATCH (p:Person)
WHERE p.email IS NULL
RETURN p.name

-- Check for not null
MATCH (p:Person)
WHERE p.email IS NOT NULL
RETURN p.name

-- Coalesce (return first non-null)
MATCH (p:Person)
RETURN p.name, COALESCE(p.nickname, p.name, 'Unknown') AS displayName

-- Default value with CASE
MATCH (p:Person)
RETURN p.name,
       CASE WHEN p.age IS NULL THEN 'Unknown'
            ELSE toString(p.age)
       END AS age

Aggregation

COUNT

-- Alle Knoten zählen
MATCH (p:Person)
RETURN COUNT(p)

-- Zählen mit Gruppierung
MATCH (p:Person)-[:LIVES_IN]->(c:City)
RETURN c.name, COUNT(p) AS population

-- Eindeutige Werte zählen MATCH (p:Person) RETURN COUNT(DISTINCT p.city) AS cities

-- Beziehungen zählen MATCH (p:Person)-[r:KNOWS]->() RETURN p.name, COUNT(r) AS friends

### SUM, AVG, MIN, MAX

```cypher
-- Summe
MATCH (p:Person)
RETURN SUM(p.salary) AS totalSalary

-- Durchschnitt
MATCH (p:Person)
RETURN AVG(p.age) AS averageAge

-- Minimum und Maximum
MATCH (p:Person)
RETURN MIN(p.age) AS youngest, MAX(p.age) AS oldest

-- Mit Gruppierung
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
RETURN c.name, AVG(p.salary) AS avgSalary, COUNT(p) AS employees

COLLECT and DISTINCT

-- In eine Liste sammeln
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
RETURN c.name, COLLECT(p.name) AS employees

-- Eindeutige Werte
MATCH (p:Person)
RETURN DISTINCT p.city

-- Eindeutig sammeln
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
RETURN c.name, COLLECT(DISTINCT p.department) AS departments

-- Verschachteltes Sammeln
MATCH (c:Company)<-[:WORKS_FOR]-(p:Person)-[:HAS_SKILL]->(s:Skill)
RETURN c.name, COLLECT(DISTINCT {person: p.name, skill: s.name}) AS skills

Ordering and Pagination

ORDER BY

-- Aufsteigend (Standard)
MATCH (p:Person)
RETURN p.name, p.age
ORDER BY p.age

-- Absteigend
MATCH (p:Person)
RETURN p.name, p.age
ORDER BY p.age DESC

-- Mehrere Spalten
MATCH (p:Person)
RETURN p.name, p.city, p.age
ORDER BY p.city, p.age DESC

-- Sortierung nach aggregiertem Wert
MATCH (p:Person)-[:KNOWS]->(f)
RETURN p.name, COUNT(f) AS friendCount
ORDER BY friendCount DESC

SKIP and LIMIT

-- Ergebnisse begrenzen
MATCH (p:Person)
RETURN p.name
ORDER BY p.name
LIMIT 10

-- Ergebnisse überspringen (Offset)
MATCH (p:Person)
RETURN p.name
ORDER BY p.name
SKIP 10

-- Pagination (Seite 2 mit 10 Einträgen pro Seite)
MATCH (p:Person)
RETURN p.name
ORDER BY p.name
SKIP 10 LIMIT 10

WITH Clause

Chaining Queries

-- Filtern nach der Aggregation
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
WITH c, COUNT(p) AS employeeCount
WHERE employeeCount > 5
RETURN c.name, employeeCount

-- Daten zwischen den Stufen transformieren
MATCH (p:Person)
WITH p.name AS personName, p.age AS personAge
WHERE personAge > 30
RETURN personName, personAge

-- Mehrere Aggregationen
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
WITH c, COLLECT(p.name) AS employees, AVG(p.salary) AS avgSalary
WHERE avgSalary > 50000
RETURN c.name, employees, avgSalary
-- Zuerst berechnen, dann filtern
MATCH (p:Person)
WITH p, p.salary * 1.1 AS newSalary
WHERE newSalary > 100000
RETURN p.name, newSalary

Renaming Variables

-- Umbenennen zur besseren Übersicht
MATCH (p:Person)-[:WORKS_FOR]->(comp:Company)
WITH p AS employee, comp AS employer
RETURN employee.name, employer.name

-- Nur benötigte Variablen beibehalten
MATCH (p:Person)-[:WORKS_FOR]->(c:Company)
WITH p.name AS name, c.name AS company
RETURN name, company

Indexes and Constraints

CREATE INDEX

-- Index für eine einzelne Eigenschaft
CREATE INDEX person_name IF NOT EXISTS
FOR (p:Person) ON (p.name)

-- Zusammengesetzter Index (Composite Index)
CREATE INDEX person_city_age IF NOT EXISTS
FOR (p:Person) ON (p.city, p.age)

-- Volltext-Index
CREATE FULLTEXT INDEX person_fulltext IF NOT EXISTS
FOR (p:Person) ON EACH [p.name, p.bio]

-- Indizes anzeigen
SHOW INDEXES

-- Index löschen
DROP INDEX person_name IF EXISTS

CREATE CONSTRAINT

-- Unique Constraint (Eindeutigkeitsbeschränkung)
CREATE CONSTRAINT person_email_unique IF NOT EXISTS
FOR (p:Person) REQUIRE p.email IS UNIQUE

-- Existence Constraint (Eigenschaft muss existieren)
CREATE CONSTRAINT person_name_exists IF NOT EXISTS
FOR (p:Person) REQUIRE p.name IS NOT NULL

-- Node Key Constraint (zusammengesetzt eindeutig + nicht null)
CREATE CONSTRAINT person_key IF NOT EXISTS
FOR (p:Person) REQUIRE (p.firstName, p.lastName) IS NODE KEY

-- Existence Constraint für Beziehungen
CREATE CONSTRAINT works_since_exists IF NOT EXISTS
FOR ()-[r:WORKS_FOR]-()
REQUIRE r.since IS NOT NULL

-- Constraints anzeigen
SHOW CONSTRAINTS

-- Constraint löschen
DROP CONSTRAINT person_email_unique IF EXISTS

Procedures

Calling Procedures

-- Integrierte Prozedur aufrufen
CALL db.labels()

-- Aufruf mit Argumenten
CALL db.schema.visualization()

-- APOC-Prozedur aufrufen (falls installiert)
CALL apoc.help('search')

-- Aufrufen und Ergebnisse filtern
CALL db.indexes()
YIELD name, state
WHERE state = 'ONLINE'
RETURN name, state

-- Aufruf mit YIELD und WHERE
CALL dbms.security.listUsers()
YIELD username, roles
WHERE 'admin' IN roles
RETURN username

Listing Available Procedures

-- Alle Prozeduren auflisten
SHOW PROCEDURES

-- Funktionen auflisten
SHOW FUNCTIONS

-- Nach Kategorie filtern
SHOW PROCEDURES YIELD name, category
WHERE category = 'ADMIN'
RETURN name

Database Management

Database Operations

-- Datenbanken auflisten
SHOW DATABASES

-- Aktuelle Datenbank anzeigen
SHOW DEFAULT DATABASE

-- Datenbank erstellen (nur Enterprise)
CREATE DATABASE myDatabase IF NOT EXISTS

-- Datenbank starten
START DATABASE myDatabase

-- Datenbank stoppen
STOP DATABASE myDatabase

-- Datenbank löschen (nur Enterprise)
DROP DATABASE myDatabase IF EXISTS

-- Datenbank-Kontext wechseln
:use myDatabase

Database Statistics

-- Knotenanzahl abrufen
MATCH (n)
RETURN count(n) AS nodeCount

-- Anzahl nach Label abrufen
MATCH (n)
RETURN labels(n) AS labels, count(*) AS count

-- Beziehungsanzahl abrufen
MATCH ()-[r]->()
RETURN count(r) AS relationshipCount

-- Anzahl nach Beziehungstyp abrufen
MATCH ()-[r]->()
RETURN type(r) AS type, count(*) AS count

-- Statistiken zur Existenz von Properties
CALL db.stats.retrieve('GRAPH COUNTS')
YIELD data
RETURN data

User Management

User Operations

-- Benutzer erstellen
CREATE USER alice SET PASSWORD 'password123' CHANGE NOT REQUIRED

-- Benutzer erstellen, Passwortänderung erforderlich
CREATE USER bob SET PASSWORD 'tempPassword' CHANGE REQUIRED

-- Benutzerpasswort ändern
ALTER USER alice SET PASSWORD 'newPassword456'

-- Benutzerstatus ändern
ALTER USER alice SET STATUS SUSPENDED
ALTER USER bob SET STATUS ACTIVE

-- Benutzer löschen
DROP USER alice IF EXISTS

-- Benutzer auflisten
SHOW USERS

Role Management

-- Rolle erstellen
CREATE ROLE analyst

-- Rolle einem Benutzer zuweisen
GRANT ROLE analyst TO alice

-- Rolle einem Benutzer entziehen
REVOKE ROLE analyst FROM alice

-- Rollen auflisten
SHOW ROLES

-- Zugewiesene Benutzerrollen anzeigen
SHOW POPULATED ROLES

Privileges

-- Lesezugriff gewähren
GRANT READ {name, age} ON GRAPH * NODES Person TO analyst

-- Traverse-Recht gewähren (Traversierung möglich, aber kein Datenlesen)
GRANT TRAVERSE ON GRAPH * TO analyst

-- Schreibzugriff gewähren
GRANT WRITE ON GRAPH * TO analyst

-- Alle Berechtigungen gewähren
GRANT ALL ON DATABASE * TO admin

-- Berechtigungen entziehen
REVOKE READ ON GRAPH * FROM analyst

Import and Export

LOAD CSV

-- CSV mit Headern laden
LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
CREATE (p:Person {name: row.name, age: toInteger(row.age)})

-- CSV ohne Header laden
LOAD CSV FROM 'file:///data.csv' AS row
CREATE (p:Person {name: row[0], age: toInteger(row[1])})

-- Mit Feldterminator
LOAD CSV WITH HEADERS FROM 'file:///data.tsv' AS row
FIELDTERMINATOR '\t'
CREATE (p:Person {name: row.name})

-- Batch-Verarbeitung mit periodic commit
USING PERIODIC COMMIT 1000
LOAD CSV WITH HEADERS FROM 'file:///people.csv' AS row
CREATE (p:Person {name: row.name})

-- Beziehungen aus CSV erstellen
LOAD CSV WITH HEADERS FROM 'file:///works_for.csv' AS row
MATCH (p:Person {name: row.personName})
MATCH (c:Company {name: row.companyName})
CREATE (p)-[:WORKS_FOR {role: row.role}]->(c)

APOC Load (if APOC is installed)

-- JSON laden
CALL apoc.load.json('file:///data.json')
YIELD value
CREATE (p:Person SET p = value)

-- JSON von URL laden
CALL apoc.load.json('https://api.example.com/users')
YIELD value
CREATE (p:Person {name: value.name})

-- Export nach JSON
CALL apoc.export.json.query(
  'MATCH (p:Person) RETURN p.name',
  'people.json',
  {stream: true}
)

-- Export nach CSV
CALL apoc.export.csv.query(
  'MATCH (p:Person) RETURN p.name, p.age',
  'people.csv',
  {stream: true}
)

Path Functions

Shortest Path

-- Kürzesten Pfad finden
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
MATCH path = shortestPath((a)-[:KNOWS*]-(b))
RETURN path

-- Kürzester Pfad mit maximaler Länge
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
CALL apoc.algo.shortestPath(a, b, 'KNOWS')
YIELD path
RETURN path

-- Alle kürzesten Pfade
MATCH (a:Person {name: 'Alice'}), (b:Person {name: 'Bob'})
MATCH path = allShortestPaths((a)-[:KNOWS*]-(b))
RETURN path

Path Operations

-- Pfad und dessen Länge zurückgeben
MATCH path = (a:Person {name: 'Alice'})-[:KNOWS*1..5]-(b)
RETURN path, length(path) AS hops

-- Knoten aus Pfad abrufen
MATCH path = (a)-[:KNOWS*]-(b)
RETURN [node IN nodes(path) | node.name] AS names

-- Beziehungen aus Pfad abrufen
MATCH path = (a)-[:KNOWS*]-(b)
RETURN [rel IN relationships(path) | type(rel)] AS relTypes

-- Start- und Endknoten abrufen
MATCH path = (a)-[:KNOWS*]-(b)
RETURN startNode(path).name AS start, endNode(path).name AS end

Common Functions

String Functions

-- Konkatenation
RETURN toString(42) + ' items' AS result

-- toUpper / toLower
MATCH (p:Person)
RETURN toUpper(p.name) AS nameUpper, toLower(p.name) AS nameLower

-- Substring
RETURN substring('Hello World', 0, 5) AS result  -- 'Hello'

-- Trim
RETURN trim('  hello  ') AS result  -- 'hello'

-- Replace
RETURN replace('hello world', 'world', 'Neo4j') AS result

-- Split
RETURN split('a,b,c', ',') AS result  -- ['a', 'b', 'c']

-- Left / Right
RETURN left('Hello', 3) AS result  -- 'Hel'
RETURN right('Hello', 3) AS result  -- 'llo'

-- String-Matching
RETURN ltrim('  hello') AS result  -- 'hello' (left trim)
RETURN rtrim('hello  ') AS result  -- 'hello' (right trim)

Numeric Functions

-- Absoluter Wert
RETURN abs(-42) AS result  -- 42

-- Rundung
RETURN round(3.7) AS result  -- 4
RETURN floor(3.7) AS result  -- 3
RETURN ceil(3.2) AS result   -- 4

-- Zufall
RETURN rand() AS random  -- 0.0 bis 1.0
RETURN toInteger(rand() * 100) AS randomInt  -- 0 bis 99

-- Vorzeichen
RETURN sign(-42) AS result  -- -1
RETURN sign(42) AS result   -- 1
RETURN sign(0) AS result    -- 0

-- Quadratwurzel
RETURN sqrt(16) AS result  -- 4.0

-- Potenz
RETURN 2^10 AS result      -- 1024
RETURN pow(2, 10) AS result  -- 1024.0

List Functions

-- Größe einer Liste
RETURN size([1, 2, 3, 4, 5]) AS result  -- 5

-- Erstes und letztes Element
RETURN head([1, 2, 3]) AS result   -- 1
RETURN last([1, 2, 3]) AS result   -- 3

-- Bereich (Range)
RETURN range(0, 10) AS result      -- [0,1,2,3,4,5,6,7,8,9,10]
RETURN range(0, 10, 2) AS result   -- [0,2,4,6,8,10]

-- List Comprehension
MATCH (p:Person)
RETURN [x IN p.skills WHERE x <> 'legacy' | toUpper(x)] AS skills

-- Reduce
RETURN reduce(total = 0, x IN [1,2,3,4,5] | total + x) AS sum  -- 15

-- Unwind (Liste in Zeilen expandieren)
UNWIND [1, 2, 3] AS x
RETURN x * 2 AS doubled

-- Verschachtelte Listen glätten (Flatten)
RETURN [[1,2], [3,4]] AS nested, flatten([[1,2], [3,4]]) AS flat

Temporal Functions

-- Aktuelles Datum und Uhrzeit
RETURN date() AS today
RETURN datetime() AS now
RETURN time() AS currentTime
RETURN timestamp() AS unixTimestamp

-- Spezifisches Datum erstellen
RETURN date('2026-02-16') AS specificDate
RETURN date({year: 2026, month: 2, day: 16}) AS specificDate

-- Datumsarithmetik
MATCH (p:Person)
WHERE date(p.birthDate) > date('2000-01-01')
RETURN p.name

-- Datumsbestandteile
WITH datetime() AS dt
RETURN dt.year, dt.month, dt.day, dt.hour, dt.minute

-- Zeitspanne (Duration)
RETURN duration.between(date('2020-01-01'), date('2026-02-16')) AS diff
RETURN duration.inDays(date('2020-01-01'), date('2026-02-16')).days AS days

Type Conversion

-- In String konvertieren
RETURN toString(42) AS result
RETURN toString(true) AS result

-- In Integer konvertieren
RETURN toInteger('42') AS result
RETURN toInteger(3.7) AS result  -- 3

-- In Float konvertieren
RETURN toFloat('3.14') AS result

-- In Boolean konvertieren
RETURN toBoolean('true') AS result
RETURN toBoolean(1) AS result

-- Typ prüfen
RETURN apoc.meta.type(42) AS result        -- 'Long'
RETURN apoc.meta.type('hello') AS result   -- 'String'
RETURN apoc.meta.type([1,2,3]) AS result   -- 'List'

Coalesce and Null Handling

-- COALESCE: gibt den ersten Nicht-Null-Wert zurück
RETURN COALESCE(null, null, 'hello') AS result  -- 'hello'

-- NullIf: gibt null zurück, wenn die Werte übereinstimmen
RETURN nullif('hello', 'hello') AS result  -- null
RETURN nullif('hello', 'world') AS result  -- 'hello'
-- CASE-Ausdruck
MATCH (p:Person)
RETURN p.name,
       CASE
         WHEN p.age < 18 THEN 'Minor'
         WHEN p.age < 65 THEN 'Adult'
         ELSE 'Senior'
       END AS category

Graph Data Science (GDS)

The Neo4j Graph Data Science library provides algorithms for analyzing graph structures. Most algorithms support multiple execution modes.

Setup and Configuration

-- GDS-Bibliotheksversion prüfen
CALL gds.version()

-- Alle verfügbaren Algorithmen auflisten
CALL gds.list()

-- Prüfen, ob GDS korrekt installiert ist
RETURN gds.version() AS gdsVersion

Graph Projection

-- Einen benannten Graphen projizieren (native Projektion)
CALL gds.graph.project(
  'myGraph',
  'Person',
  'KNOWS'
)

-- Projektion mit mehreren Node-Labels und Beziehungstypen
CALL gds.graph.project(
  'socialNetwork',
  ['Person', 'Company'],
  ['KNOWS', 'WORKS_FOR']
)

-- Projektion mit Beziehungseigenschaften
CALL gds.graph.project(
  'weightedGraph',
  'Person',
  {
    KNOWS: {
      properties: ['weight', 'since']
    }
  }
)

-- Projektion mittels Cypher-Abfrage (Cypher-Projektion)
CALL gds.graph.project.cypher(
  'cypherGraph',
  'MATCH (p:Person) RETURN id(p) AS id',
  'MATCH (p:Person)-[:KNOWS]->(q:Person) RETURN id(p) AS source, id(q) AS target'
)

-- Alle projizierten Graphen auflisten
CALL gds.graph.list()

-- Details eines spezifischen Graphen abrufen
CALL gds.graph.list('myGraph')
YIELD graphName, nodeCount, relationshipCount

-- Einen projizierten Graphen löschen
CALL gds.graph.drop('myGraph')

-- Graphen ohne Fehlermeldung löschen, falls er nicht existiert
CALL gds.graph.drop('myGraph', false)

Centrality Algorithms

Centrality algorithms identify important nodes in a network.

-- PageRank: Misst die Wichtigkeit eines Nodes basierend auf eingehenden Beziehungen
CALL gds.pageRank.stream('myGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC
LIMIT 10

-- PageRank im Write-Modus (speichert den Score in der Datenbank)
CALL gds.pageRank.write('myGraph', {
  writeProperty: 'pagerank'
})

-- PageRank mit benutzerdefiniertem Damping-Faktor
CALL gds.pageRank.stream('myGraph', {
  dampingFactor: 0.85,
  maxIterations: 20
})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score

-- Betweenness Centrality: Misst, wie oft ein Node auf kürzesten Pfaden liegt
CALL gds.betweenness.stream('myGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC

-- Betweenness mit sampled approximation (schneller bei großen Graphen)
CALL gds.betweenness.stream('myGraph', {
  samplingSize: 1000
})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score

-- Degree Centrality: Zählt die Anzahl der Beziehungen pro Node
CALL gds.degree.stream('myGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC
-- Degree Centrality für eine spezifische Beziehungsrichtung
CALL gds.degree.stream('myGraph', {
  orientation: 'REVERSE'
})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score

-- Closeness Centrality: Misst die durchschnittliche Distanz zu allen anderen Knoten
CALL gds.closeness.stream('myGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC

-- Closeness mit Wasserman-Faust-Variante (für nicht zusammenhängende Graphen)
CALL gds.closeness.stream('myGraph', {
  useWassermanFaust: true
})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score

Community Detection

Community detection algorithms find clusters of densely connected nodes.

-- Louvain: Erkennt Communities durch Maximierung der Modularität
CALL gds.louvain.stream('myGraph')
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId
ORDER BY communityId

-- Louvain im Write-Modus
CALL gds.louvain.write('myGraph', {
  writeProperty: 'community'
})

-- Louvain mit maximalen Iterationen und Hierarchieebenen
CALL gds.louvain.stream('myGraph', {
  maxIterations: 20,
  includeIntermediateCommunities: true
})
YIELD nodeId, communityId, intermediateCommunityIds
RETURN gds.util.asNode(nodeId).name AS name, communityId

-- Label Propagation: Verbreitet Labels durch das Netzwerk
CALL gds.labelPropagation.stream('myGraph')
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId
ORDER BY communityId

-- Label Propagation mit Seed-Property
CALL gds.labelPropagation.stream('myGraph', {
  seedProperty: 'initialCommunity'
})
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name AS name, communityId

-- Weakly Connected Components (WCC): Findet nicht zusammenhängende Subgraphen
CALL gds.wcc.stream('myGraph')
YIELD nodeId, componentId
RETURN gds.util.asNode(nodeId).name AS name, componentId
ORDER BY componentId

-- WCC im Write-Modus
CALL gds.wcc.write('myGraph', {
  writeProperty: 'component'
})

-- Anzahl der Knoten pro Komponente abrufen
CALL gds.wcc.stream('myGraph')
YIELD componentId
RETURN componentId, count(*) AS componentSize
ORDER BY componentSize DESC

-- Strongly Connected Components (SCC): Gegenseitig erreichbare Knoten
CALL gds.scc.stream('myGraph')
YIELD nodeId, componentId
RETURN gds.util.asNode(nodeId).name AS name, componentId
ORDER BY componentId

-- Triangle Count: Zählt die Dreiecke, an denen jeder Knoten beteiligt ist
CALL gds.triangleCount.stream('myGraph')
YIELD nodeId, triangleCount
RETURN gds.util.asNode(nodeId).name AS name, triangleCount
ORDER BY triangleCount DESC

-- Local Clustering Coefficient: Wie stark die Nachbarn eines Knotens untereinander vernetzt sind
CALL gds.localClusteringCoefficient.stream('myGraph')
YIELD nodeId, localClusteringCoefficient
RETURN gds.util.asNode(nodeId).name AS name, localClusteringCoefficient
ORDER BY localClusteringCoefficient DESC

Path Finding Algorithms

Path finding algorithms find optimal routes between nodes.

-- Dijkstra Shortest Path: Findet den kürzesten Pfad basierend auf dem Gewicht
MATCH (source:Person {name: 'Alice'}), (target:Person {name: 'Bob'})
CALL gds.shortestPath.dijkstra.stream('myGraph', {
  sourceNode: source,
  targetNode: target,
  relationshipWeightProperty: 'weight'
})
YIELD index, sourceNode, targetNode, totalCost, nodeIds, costs, path
RETURN
  [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS nodeNames,
  costs,
  totalCost

-- Dijkstra mit mehreren Zielen
MATCH (source:Person {name: 'Alice'})
CALL gds.shortestPath.dijkstra.stream('myGraph', {
  sourceNode: source,
  relationshipWeightProperty: 'weight'
})
YIELD nodeIds, totalCost
RETURN totalCost, size(nodeIds) AS pathLength
ORDER BY totalCost
LIMIT 5

-- A* (A-Star) Kürzester Pfad: Nutzt Heuristiken für eine schnellere Pfadfindung
MATCH (source:Person {name: 'Alice'}), (target:Person {name: 'Bob'})
CALL gds.shortestPath.astar.stream('myGraph', {
  sourceNode: source,
  targetNode: target,
  relationshipWeightProperty: 'weight',
  latitudeProperty: 'lat',
  longitudeProperty: 'lon'
})
YIELD nodeIds, totalCost
RETURN [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS path, totalCost

-- Yen's K-Shortest Paths: Findet die K kürzesten Pfade
MATCH (source:Person {name: 'Alice'}), (target:Person {name: 'Bob'})
CALL gds.allShortestPaths.yens.stream('myGraph', {
  sourceNode: source,
  targetNode: target,
  k: 3,
  relationshipWeightProperty: 'weight'
})
YIELD index, nodeIds, totalCost
RETURN index, [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS path, totalCost
ORDER BY index

-- Breadth-First Search (BFS): Ebene-für-Ebene-Traversierung
MATCH (source:Person {name: 'Alice'})
CALL gds.bfs.stream('myGraph', {
  sourceNode: source
})
YIELD nodeIds
RETURN [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS visitedNodes

-- BFS mit Zielknoten
MATCH (source:Person {name: 'Alice'}), (target:Person {name: 'Bob'})
CALL gds.bfs.stream('myGraph', {
  sourceNode: source,
  targetNodes: [target]
})
YIELD nodeIds
RETURN [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS path

-- Depth-First Search (DFS): Exploriert tief, bevor Backtracking erfolgt
MATCH (source:Person {name: 'Alice'})
CALL gds.dfs.stream('myGraph', {
  sourceNode: source
})
YIELD nodeIds
RETURN [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS visitedNodes

-- Alle kürzesten Pfade (ungewichtet)
MATCH (source:Person {name: 'Alice'}), (target:Person {name: 'Bob'})
CALL gds.allShortestPaths.stream('myGraph', {
  sourceNode: source,
  targetNode: target
})
YIELD nodeIds
RETURN [nodeId IN nodeIds | gds.util.asNode(nodeId).name] AS path

Similarity Algorithms

Similarity algorithms measure how alike nodes are based on their connections.

-- Jaccard-Ähnlichkeit: Schnittmenge über Vereinigungsmenge der Nachbarn
CALL gds.nodeSimilarity.stream('myGraph', {
  topK: 5,
  similarityCutoff: 0.1
})
YIELD node1, node2, similarity
RETURN
  gds.util.asNode(node1).name AS person1,
  gds.util.asNode(node2).name AS person2,
  similarity
ORDER BY similarity DESC

-- Node Similarity mit Write-Modus
CALL gds.nodeSimilarity.write('myGraph', {
  writeRelationshipType: 'SIMILAR',
  writeProperty: 'score',
  topK: 10
})

-- Filterung nach spezifischen Knoten
MATCH (p:Person)
WHERE p.name IN ['Alice', 'Bob', 'Charlie']
WITH collect(p) AS people
CALL gds.nodeSimilarity.stream('myGraph', {
  nodeFilter: people
})
YIELD node1, node2, similarity
RETURN gds.util.asNode(node1).name, gds.util.asNode(node2).name, similarity

-- Cosine-Ähnlichkeit: Vektorbasiertes Ähnlichkeitsmaß
CALL gds.nodeSimilarity.cosine.stream('myGraph', {
  nodeProperties: ['feature1', 'feature2', 'feature3']
})
YIELD node1, node2, similarity
RETURN
  gds.util.asNode(node1).name AS person1,
  gds.util.asNode(node2).name AS person2,
  similarity
ORDER BY similarity DESC

-- Pearson-Ähnlichkeit: Korrelationsbasiertes Ähnlichkeitsmaß
CALL gds.nodeSimilarity.pearson.stream('myGraph', {
  nodeProperties: ['rating1', 'rating2']
})
YIELD node1, node2, similarity
RETURN
  gds.util.asNode(node1).name AS item1,
  gds.util.asNode(node2).name AS item2,
  similarity
ORDER BY similarity DESC

-- Euklidische Distanz: Geometrischer Abstand zwischen Knoten
CALL gds.alpha.similarity.euclidean.stream({
nodeProperties: 'embedding',
  data: [
    {item: 'Alice', properties: [1.0, 2.0, 3.0]},
    {item: 'Bob', properties: [4.0, 5.0, 6.0]}
  ]
})
YIELD item1, item2, similarity
RETURN item1, item2, similarity

Link Prediction Algorithms

Link prediction algorithms estimate the likelihood of future connections.

-- Adamic Adar: Gewichtet gemeinsame Nachbarn nach ihrem Grad
MATCH (p1:Person {name: 'Alice'})
MATCH (p2:Person {name: 'Bob'})
RETURN gds.alpha.linkprediction.adamicAdar(p1, p2, {
  relationshipType: 'KNOWS',
  direction: 'BOTH'
}) AS score

-- Common Neighbors: Zählt gemeinsam genutzte Nachbarn
MATCH (p1:Person {name: 'Alice'})
MATCH (p2:Person {name: 'Bob'})
RETURN gds.alpha.linkprediction.commonNeighbors(p1, p2, {
  relationshipType: 'KNOWS',
  direction: 'BOTH'
}) AS commonNeighborCount

-- Preferential Attachment: Produkt der Nachbaranzahlen
MATCH (p1:Person {name: 'Alice'})
MATCH (p2:Person {name: 'Bob'})
RETURN gds.alpha.linkprediction.preferentialAttachment(p1, p2, {
  relationshipType: 'KNOWS',
  direction: 'BOTH'
}) AS score

-- Resource Allocation: Ähnlich wie Adamic Adar, jedoch mit anderer Gewichtung
MATCH (p1:Person {name: 'Alice'})
MATCH (p2:Person {name: 'Bob'})
RETURN gds.alpha.linkprediction.resourceAllocation(p1, p2, {
  relationshipType: 'KNOWS',
  direction: 'BOTH'
}) AS score

-- Total Neighbors: Gesamtzahl der eindeutigen Nachbarn beider Knoten
MATCH (p1:Person {name: 'Alice'})
MATCH (p2:Person {name: 'Bob'})
RETURN gds.alpha.linkprediction.totalNeighbors(p1, p2, {
  relationshipType: 'KNOWS',
  direction: 'BOTH'
}) AS totalNeighbors

-- Batch-Link-Vorhersage für alle nicht verbundenen Paare
MATCH (p1:Person), (p2:Person)
WHERE p1.name < p2.name
AND NOT EXISTS((p1)-[:KNOWS]-(p2))
WITH p1, p2,
     gds.alpha.linkprediction.adamicAdar(p1, p2, {
       relationshipType: 'KNOWS',
       direction: 'BOTH'
     }) AS score
WHERE score > 0
RETURN p1.name, p2.name, score
ORDER BY score DESC
LIMIT 10

Node Embeddings

Node embedding algorithms create vector representations of nodes.

-- FastRP (Fast Random Projection): Schnelle Generierung von Embeddings
CALL gds.fastRP.stream('myGraph', {
  embeddingDimension: 128,
  randomSeed: 42
})
YIELD nodeId, embedding
RETURN gds.util.asNode(nodeId).name AS name, embedding

-- FastRP mit Iterationsgewichten
CALL gds.fastRP.stream('myGraph', {
  embeddingDimension: 256,
  iterationWeights: [0.8, 0.2, 0.02]
})
YIELD nodeId, embedding
RETURN gds.util.asNode(nodeId).name AS name, embedding

-- FastRP im Write-Modus
CALL gds.fastRP.write('myGraph', {
  embeddingDimension: 128,
  writeProperty: 'embedding'
})

-- FastRP mit Relationship-Weight-Property
CALL gds.fastRP.stream('myGraph', {
  embeddingDimension: 128,
  relationshipWeightProperty: 'weight'
})
YIELD nodeId, embedding
RETURN gds.util.asNode(nodeId).name AS name, embedding

-- Node2Vec: Embedding basierend auf Random Walks
CALL gds.node2vec.stream('myGraph', {
  embeddingDimension: 128,
  walkLength: 80,
  walksPerNode: 10,
  returnFactor: 1.0,
  inOutFactor: 1.0
})
YIELD nodeId, embedding
RETURN gds.util.asNode(nodeId).name AS name, embedding

-- Node2Vec im Write-Modus
CALL gds.node2vec.write('myGraph', {
  embeddingDimension: 64,
  writeProperty: 'node2vecEmbedding'
})

-- GraphSAGE: Embedding mittels Neural Network Sampling
CALL gds.beta.graphSage.stream('myGraph', {
  embeddingDimension: 128,
  sampleSizes: [25, 10],
  aggregator: 'mean'
})
YIELD nodeId, embedding
RETURN gds.util.asNode(nodeId).name AS name, embedding

-- GraphSAGE mit Write-Modus
CALL gds.beta.graphSage.write('myGraph', {
  embeddingDimension: 128,
  writeProperty: 'graphSageEmbedding',
  modelName: 'myGraphSageModel'
})

-- GraphSAGE-Modell für die spätere Verwendung trainieren
CALL gds.beta.graphSage.train('myGraph', {
  embeddingDimension: 128,
  modelName: 'myGraphSageModel',
  sampleSizes: [25, 10]
})
YIELD modelInfo
RETURN modelInfo

-- HashGNN: Hash-basiertes Embedding für große Graphen
CALL gds.alpha.hashgnn.stream('myGraph', {
  embeddingDimension: 128,
  iterations: 5
})
YIELD nodeId, embedding
RETURN gds.util.asNode(nodeId).name AS name, embedding

Graph Projection Modes

GDS algorithms support different execution modes for various use cases.

-- STREAM-Modus: Gibt Ergebnisse direkt zurück (Standard für die meisten obigen Beispiele)
CALL gds.pageRank.stream('myGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score

-- WRITE-Modus: Schreibt Ergebnisse zurück in die Datenbank
CALL gds.pageRank.write('myGraph', {
  writeProperty: 'pagerank',
  maxIterations: 20
})
YIELD nodePropertiesWritten, ranIterations
RETURN nodePropertiesWritten, ranIterations

-- MUTATE-Modus: Fügt Ergebnisse dem projizierten Graphen hinzu (nicht der Datenbank)
CALL gds.pageRank.mutate('myGraph', {
  mutateProperty: 'pagerank'
})
YIELD nodePropertiesWritten, ranIterations
RETURN nodePropertiesWritten, ranIterations

-- STATS-Modus: Gibt nur zusammenfassende Statistiken zurück
CALL gds.pageRank.stats('myGraph')
YIELD ranIterations, didConverge, preProcessingMillis, computeMillis

-- ESTIMATE-Modus: Schätzt Speicherbedarf und Zeit vor der Ausführung
CALL gds.pageRank.stats.estimate('myGraph', {
  maxIterations: 20
})
YIELD bytesMin, bytesMax, nodeCount, relationshipCount

-- Speicherbedarf für Schreibvorgang schätzen
CALL gds.pageRank.write.estimate('myGraph', {
  writeProperty: 'pagerank'
})
YIELD bytesMin, bytesMax, requiredMemory
RETURN requiredMemory

Pregel API (Custom Algorithms)

-- Einen benutzerdefinierten Pregel-Algorithmus ausführen
CALL gds.alpha.pregel.stream('myGraph', {
  maxIterations: 10,
  aggregator: 'single',
  defaultValue: 0.0
})
YIELD nodeId, values
RETURN gds.util.asNode(nodeId).name AS name, values

-- Pregel mit Message-Parsing
CALL gds.alpha.pregel.write('myGraph', {
  maxIterations: 20,
  writeProperty: 'pregelResult'
})
YIELD nodePropertiesWritten
RETURN nodePropertiesWritten

Common GDS Patterns

-- Algorithmus auf gefiltertem Subgraphen ausführen
CALL gds.graph.project.subgraph(
  'filteredGraph',
  'myGraph',
  'n.age > 25',
  '*'
)

-- Mehrere Algorithmen ausführen und Ergebnisse kombinieren
CALL gds.pageRank.stream('myGraph')
YIELD nodeId, score AS pagerank
WITH nodeId, pagerank
CALL gds.degree.stream('myGraph')
YIELD nodeId AS degreeNodeId, score AS degree
WHERE nodeId = degreeNodeId
RETURN
  gds.util.asNode(nodeId).name AS name,
pagerank,
  degree

-- Algorithmus-Ergebnisse in einen anderen Graphen exportieren
CALL gds.pageRank.mutate('myGraph', {
  mutateProperty: 'pagerank'
})
YIELD nodePropertiesWritten
WITH 1 AS _
CALL gds.graph.project(
  'enrichedGraph',
  '*',
  '*',
  {
    nodeProperties: ['pagerank'],
    relationshipProperties: []
  }
)
RETURN 'Graph created with PageRank' AS result

Quick Reference

Node Syntax

(n)           -- Beliebiger Knoten
(n:Label)     -- Knoten mit Label
(n:Label {prop: value})  -- Knoten mit Label und Eigenschaft
(n:L1:L2)     -- Knoten mit mehreren Labels

Relationship Syntax

-[r]->        -- Ausgehende Beziehung
-[r:TYPE]->   -- Typisierte ausgehende Beziehung
-[r:TYPE*]->  -- Variable Länge
-[r:TYPE*2..5]->  -- Min. 2, max. 5 Hops

Common Patterns

-- Pattern erstellen
CREATE (a)-[:REL]->(b)

-- Pattern suchen
MATCH (a)-[:REL]->(b)

-- Pattern mergen (erstellen, falls nicht vorhanden)
MERGE (a)-[:REL]->(b)

-- Pfad zurückgeben
MATCH p = (a)-[:REL*]->(b)
RETURN p

Nächste Schritte

• Monitoring Cheat Sheet — Prometheus/Grafana für Graph-Workloads
• Docker CLI Cheat Sheet — Neo4j-Deployments containerisieren
• Kubernetes kubectl Cheat Sheet — Neo4j auf Kubernetes deployen

Ressourcen & Verwandte Plattformen

• tobias-weiss.org - Weitere Cheat Sheets, Artikel und Shop-Produkte
• graphwiz.ai - KI, Knowledge Graphs und agentische Entwicklung
• courses.graphwiz.ai - Interaktive Übungsprüfungen und Lernleitfäden
• ki-kompetenz-training.org - EU AI Act konforme KI-Kompetenztrainings

Verwandte Cheat Sheets

• GraphRAG auf graphwiz.ai - Knowledge Graphs + KI
• PostgreSQL Cheat Sheet - Relationale Speicherung