Neo4j Cheatsheet

// Cypher query language
// Nodes: (n:Label {prop: value})
// Relationships: -[:TYPE]->
// Patterns: (a)-[:KNOWS]->(b)

// Show all
MATCH (n) RETURN n LIMIT 25;
CALL db.labels();
CALL db.relationshipTypes();

// Create node
CREATE (p:Person {name: "Alice", age: 30})
RETURN p;

// Create multiple
CREATE (a:Person {name: "Alice"}),
       (b:Person {name: "Bob"}),
       (a)-[:KNOWS {since: 2020}]->(b);

// Create relationship between existing
MATCH (a:Person {name:"Alice"}), (b:Person {name:"Bob"})
CREATE (a)-[:FRIENDS_WITH]->(b);

// MERGE (create if not exists)
MERGE (p:Person {name: "Alice"})
ON CREATE SET p.created = timestamp()
ON MATCH SET p.lastSeen = timestamp();

// Find by label
MATCH (p:Person) RETURN p;

// Find by property
MATCH (p:Person {name: "Alice"}) RETURN p;

// WHERE clause
MATCH (p:Person) WHERE p.age > 25 RETURN p.name, p.age;

// Follow relationships
MATCH (a:Person)-[:KNOWS]->(b:Person)
RETURN a.name, b.name;

// Variable-length paths
MATCH (a)-[*1..3]->(b) RETURN a, b;

// Shortest path
MATCH p = shortestPath((a)-[*]-(b))
WHERE a.name = "Alice" AND b.name = "Eve"
RETURN p;

// Ordering & limiting
MATCH (p:Person) RETURN p ORDER BY p.age DESC LIMIT 10;
MATCH (p:Person) RETURN count(p);

// Set properties
MATCH (p:Person {name: "Alice"})
SET p.age = 31, p.city = "Portland";

// Add label
MATCH (p:Person {name: "Alice"})
SET p:Employee;

// Remove property
MATCH (p:Person {name: "Alice"})
REMOVE p.age;

// Remove label
MATCH (p:Employee {name: "Alice"})
REMOVE p:Employee;

// Delete node (must have no relationships)
MATCH (p:Person {name: "Bob"})
DELETE p;

// Delete node + relationships
MATCH (p:Person {name: "Bob"})
DETACH DELETE p;

// Delete relationship
MATCH (a)-[r:KNOWS]->(b)
DELETE r;

// Delete all
MATCH (n) DETACH DELETE n;

// Undirected
(a)--(b)

// Directed
(a)-->(b)   (a)<--(b)

// With type
(a)-[:KNOWS]->(b)

// With properties
(a)-[:KNOWS {since: 2020}]->(b)

// Multiple hops
(a)-[:KNOWS]->(b)-[:KNOWS]->(c)

// Variable length
(a)-[*2]->(b)      // exactly 2 hops
(a)-[*1..5]->(b)    // 1 to 5 hops
(a)-[*]->(b)        // any number of hops

// Aggregation
count(n)   sum(n.val)   avg(n.val)
min(n.val)   max(n.val)
collect(n.name)          // collect into list

// String
toString(n)   toUpper(s)   toLower(s)
trim(s)   replace(s, old, new)
substring(s, start, len)

// List
size(list)   head(list)   tail(list)
range(1, 10)

// Path
length(path)   nodes(path)   relationships(path)