🔗

// Create node
CREATE (n:Person {name: "John", age: 30})

// Create multiple nodes
CREATE (a:Person {name: "Alice"}),
       (b:Person {name: "Bob"})

// Create with return
CREATE (n:Movie {title: "Matrix", year: 1999})
RETURN n

// Multiple labels
CREATE (n:Person:Actor {name: "Tom Hanks"})

// Create relationship
MATCH (a:Person {name: "Alice"}),
      (b:Person {name: "Bob"})
CREATE (a)-[r:KNOWS]->(b)

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

// Create node and relationship together
CREATE (a:Person {name: "Alice"})
       -[:WORKS_AT]->
       (c:Company {name: "Acme"})

// Relationship types: -[r:TYPE]->  <-[r:TYPE]-  -[r:TYPE]-

// All nodes
MATCH (n) RETURN n

// By label
MATCH (p:Person) RETURN p

// By property
MATCH (p:Person {name: "John"}) RETURN p
MATCH (p:Person) WHERE p.age > 25 RETURN p

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

// Variable length paths
MATCH (a)-[*1..3]->(b)  // 1 to 3 hops
MATCH (a)-[*]->(b)      // Any length

// WHERE clause
MATCH (p:Person)
WHERE p.age >= 18 AND p.age <= 65
RETURN p

// String matching
WHERE p.name STARTS WITH "A"
WHERE p.name ENDS WITH "son"
WHERE p.name CONTAINS "oh"
WHERE p.name =~ ".*pattern.*"  // Regex

// Sorting and limiting
MATCH (p:Person)
RETURN p.name, p.age
ORDER BY p.age DESC
SKIP 10
LIMIT 5

// Set property
MATCH (p:Person {name: "John"})
SET p.age = 31

// Set multiple properties
SET p.age = 31, p.city = "NYC"

// Add to existing (merge properties)
SET p += {age: 31, city: "NYC"}

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

// Add/remove labels
SET p:Employee
REMOVE p:Contractor

// Create if not exists
MERGE (p:Person {name: "John"})

// With ON CREATE / ON MATCH
MERGE (p:Person {name: "John"})
ON CREATE SET p.created = timestamp()
ON MATCH SET p.updated = timestamp()

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

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

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

// Delete node and all relationships
MATCH (p:Person {name: "John"})
DETACH DELETE p

// Delete all
MATCH (n) DETACH DELETE n

// Count
MATCH (p:Person) RETURN count(p)

// Group by
MATCH (p:Person)
RETURN p.city, count(*) as count
ORDER BY count DESC

// Aggregations
MATCH (p:Person)
RETURN 
  count(p) as total,
  avg(p.age) as avgAge,
  min(p.age) as minAge,
  max(p.age) as maxAge,
  sum(p.salary) as totalSalary

// Collect into list
MATCH (p:Person)-[:WORKS_AT]->(c:Company)
RETURN c.name, collect(p.name) as employees

// Shortest path
MATCH p = shortestPath(
  (a:Person {name: "Alice"})-[*]-(b:Person {name: "Bob"})
)
RETURN p

// All shortest paths
MATCH p = allShortestPaths(
  (a:Person)-[*]-(b:Person)
)
RETURN p

// Path length
MATCH p = (a)-[*]->(b)
RETURN length(p)

// Path nodes and relationships
RETURN nodes(p), relationships(p)

// Create index
CREATE INDEX FOR (p:Person) ON (p.name)

// Composite index
CREATE INDEX FOR (p:Person) ON (p.name, p.age)

// Text index (for CONTAINS, STARTS WITH)
CREATE TEXT INDEX FOR (p:Person) ON (p.name)

// Show indexes
SHOW INDEXES

// Drop index
DROP INDEX index_name

// Unique constraint
CREATE CONSTRAINT FOR (p:Person)
REQUIRE p.email IS UNIQUE

// Node key (composite unique)
CREATE CONSTRAINT FOR (p:Person)
REQUIRE (p.firstName, p.lastName) IS NODE KEY

// Not null
CREATE CONSTRAINT FOR (p:Person)
REQUIRE p.name IS NOT NULL

// Show constraints
SHOW CONSTRAINTS

// Drop constraint
DROP CONSTRAINT constraint_name