1
2
3
4
5
6
# Connect to local database
cypher-shell -u neo4j -p password

# Connect to remote database
cypher-shell -a bolt://hostname:7687 -u neo4j -p password

1
2
3
4
5
6
7
8
# Python (neo4j-driver)
from neo4j import GraphDatabase

driver = GraphDatabase.driver(
    "bolt://localhost:7687", 
    auth=("neo4j", "password")
)

1
2
3
4
5
6
// Node with label and properties
CREATE (:Person {name: 'Alice', age: 30})

// Relationship with type and properties
CREATE ()-[:KNOWS {since: 2020}]->()

1
2
3
4
MATCH (pattern) 
WHERE condition 
RETURN results

1
2
3
4
5
6
7
8
9
10
11
12
13
// Create a single node
CREATE (p:Person {name: 'John', age: 35})

// Create multiple nodes
CREATE (p1:Person {name: 'Alice'})
CREATE (p2:Person {name: 'Bob'})

// Create a relationship
CREATE (p1)-[:KNOWS]->(p2)

// Create node with relationship in one command
CREATE (p1:Person {name: 'Alice'})-[:WORKS_AT]->(c:Company {name: 'Tech Corp'})

1
2
3
4
5
6
7
8
9
10
// Create node if not exists, otherwise match
MERGE (p:Person {name: 'John'})
ON CREATE SET p.created = timestamp()
ON MATCH SET p.lastSeen = timestamp()

// Merge with relationship
MERGE (p:Person {name: 'Alice'})
MERGE (c:Company {name: 'Google'})
MERGE (p)-[:WORKS_AT]->(c)

1
2
3
4
5
6
7
8
9
10
11
// Find all people
MATCH (p:Person) RETURN p

// Find people named John
MATCH (p:Person {name: 'John'}) RETURN p

// Complex pattern matching
MATCH (p:Person)-[:KNOWS]->(friend:Person)
WHERE p.name = 'Alice'
RETURN friend.name

1
2
3
4
5
6
7
8
9
10
// Comparison operators
MATCH (p:Person)
WHERE p.age > 30 AND p.city = 'New York'
RETURN p

// Pattern-based conditions
MATCH (p:Person)-[:WORKS_AT]->(c:Company)
WHERE c.name STARTS WITH 'Tech'
RETURN p, c

1
2
3
4
MATCH (p:Person {name: 'John'})
SET p.age = 36
SET p += {email: 'john@example.com'}

1
2
3
MATCH (p:Person {name: 'John'})
REMOVE p.age

1
2
3
4
5
6
7
8
// Delete node
MATCH (p:Person {name: 'John'})
DELETE p

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

1
2
3
4
MATCH path = shortestPath((p1:Person)-[:KNOWS*]-(p2:Person))
WHERE p1.name = 'Alice' AND p2.name = 'Bob'
RETURN path

1
2
3
4
MATCH path = (start:Person)-[:KNOWS*1..3]->(end:Person)
WHERE start.name = 'Alice'
RETURN path

1
2
3
4
5
6
7
8
9
10
11
12
// Count connections
MATCH (p:Person)-[:KNOWS]->(friend)
RETURN p.name, COUNT(friend) as friendCount

// Collect related nodes
MATCH (p:Person)-[:WORKS_AT]->(c:Company)
RETURN c.name, COLLECT(p.name) as employees

// Sum numerical properties
MATCH (p:Person)
RETURN SUM(p.salary) as totalSalary

1
2
3
4
5
6
7
8
MATCH (p:Person)
RETURN p.name, 
       CASE 
         WHEN p.age < 20 THEN 'Young'
         WHEN p.age < 40 THEN 'Middle-aged'
         ELSE 'Senior'
       END as ageGroup

1
2
3
4
5
6
7
8
// Use first non-null value
RETURN COALESCE(p.nickname, p.name) as displayName

// Check property existence
MATCH (p:Person)
WHERE EXISTS(p.email)
RETURN p.name

1
2
3
4
5
6
CREATE INDEX ON :Person(name)

// Unique constraint
CREATE CONSTRAINT ON (p:Person) 
ASSERT p.email IS UNIQUE

1
2
3
4
5
6
7
LOAD CSV WITH HEADERS 
FROM 'file:///users.csv' AS row
CREATE (p:Person {
  name: row.name, 
  age: toInteger(row.age)
})

1
2
3
4
MATCH (p:Person)
WITH p.name as Name, p.age as Age
RETURN Name, Age

1
2
3
// Analyze query performance
PROFILE MATCH (p:Person) RETURN p

1
2
3
4
5
6
// Find friends of friends not yet connected
MATCH (p:Person)-[:KNOWS]->(friend)-[:KNOWS]->(recommendation)
WHERE NOT (p)-[:KNOWS]->(recommendation)
AND p <> recommendation
RETURN DISTINCT recommendation

1
2
3
4
5
6
// Find most connected individuals
MATCH (p:Person)-[:KNOWS]-(friend)
RETURN p.name, COUNT(DISTINCT friend) as connectionCount
ORDER BY connectionCount DESC
LIMIT 10