-- Find friends of user 123
SELECT friend_id FROM friendships WHERE user_id = 123;

-- Find friends of friends (2 hops)
SELECT f2.friend_id
FROM friendships f1
JOIN friendships f2 ON f1.friend_id = f2.user_id
WHERE f1.user_id = 123;

-- Find friends of friends of friends (3 hops)
SELECT f3.friend_id
FROM friendships f1
JOIN friendships f2 ON f1.friend_id = f2.user_id
JOIN friendships f3 ON f2.friend_id = f3.user_id
WHERE f1.user_id = 123;

    A
   / \
  B   C
   \ /
    D

Bridges:
A-B, A-B, A-C, B-D, B-D, C-D, C-D

Vertex A: degree 3 (odd)  - connects to 3 bridges
Vertex B: degree 5 (odd)  - connects to 5 bridges
Vertex C: degree 3 (odd)  - connects to 3 bridges
Vertex D: degree 3 (odd)  - connects to 3 bridges

Result: 4 vertices with odd degree → No Eulerian path exists!

Undirected:     Directed:
A --- B         A --> B
                (A follows B, but B doesn't follow A)

   5
A --- B
|     |
3     2
|     |
C --- D
   4

Start at A, explore all neighbors, then neighbors' neighbors:
A → [B, C] → [D, E, F] → ...

Start at A, go deep before wide:
A → B → D → (backtrack) → C → E → ...

Customer
├── Order #1
│   ├── Item A
│   └── Item B
└── Order #2
    └── Item C

Customer ←→ Order ←→ Product
    ↓          ↓         ↓
 Address   Shipping   Category

-- Declarative (what you want, not how to get it)
SELECT customer.name, order.total
FROM customers
JOIN orders ON customers.id = orders.customer_id;

(Alice:Person {name: "Alice", age: 30})
  -[:KNOWS {since: 2015}]->
(Bob:Person {name: "Bob", age: 28})
  -[:WORKS_AT]->
(Acme:Company {name: "Acme Corp", founded: 2010})
  <-[:WORKS_AT]-
(Alice)

       KNOWS {since:2015}
Alice ───────────────────→ Bob
  │                         │
  │ WORKS_AT                │ WORKS_AT
  ↓                         ↓
         Acme Corp

<Alice> <knows> <Bob>
<Alice> <age> "30"
<Bob> <worksAt> <AcmeCorp>

Edge1: {Alice, Bob, Charlie} - "group chat"

-- Relational: "Join users and friendships and friendships again"
SELECT u3.name
FROM users u1
JOIN friendships f1 ON u1.id = f1.user_id
JOIN friendships f2 ON f1.friend_id = f2.user_id
JOIN users u3 ON f2.friend_id = u3.id
WHERE u1.name = 'Alice';

// Graph: "Follow KNOWS relationships 2 hops from Alice"
MATCH (alice:Person {name: 'Alice'})-[:KNOWS*2]->(friend)
RETURN friend.name

Master (Writes)
  ↓ Replicate
Replica 1 (Reads) ← Load balancer ← Clients
Replica 2 (Reads)
Replica 3 (Reads)

-- SQL: Think in tables
SELECT u2.name
FROM users u1
JOIN friendships f ON u1.id = f.user_id
JOIN users u2 ON f.friend_id = u2.id
WHERE u1.name = 'Alice';

-- Cypher: Think in graphs
MATCH (alice:Person {name: 'Alice'})-[:KNOWS]->(friend)
RETURN friend.name

-- SQL: 3 JOINs
SELECT u2.name, c.name
FROM users u1
JOIN friendships f ON u1.id = f.user_id
JOIN users u2 ON f.friend_id = u2.id
JOIN cities c ON u2.city_id = c.id
WHERE u1.name = 'Alice'
  AND u1.city_id = u2.city_id;

-- Cypher: Natural pattern matching
MATCH (alice:Person {name: 'Alice'})-[:KNOWS]->(friend)-[:LIVES_IN]->(city)
WHERE alice.city = friend.city
RETURN friend.name, city.name

Node Record (9 bytes):
┌────────┬────────┬────────┬────────┬────────┐
│ In Use │ Next   │ Next   │ Labels │ Extra  │
│ (1 bit)│ Rel    │ Prop   │        │        │
│        │ (4 B)  │ (4 B)  │        │        │
└────────┴────────┴────────┴────────┴────────┘

Relationship Record (33 bytes):
┌────────┬────────┬────────┬────────┬────────┬────────┬────────┬────────┐
│ In Use │ First  │ Second │ Rel    │ First  │ First  │ Second │ Second │
│ (1 bit)│ Node   │ Node   │ Type   │ Prev   │ Next   │ Prev   │ Next   │
│        │ (4 B)  │ (4 B)  │ (4 B)  │ Rel    │ Rel    │ Rel    │ Rel    │
│        │        │        │        │ (4 B)  │ (4 B)  │ (4 B)  │ (4 B)  │
└────────┴────────┴────────┴────────┴────────┴────────┴────────┴────────┘

// Before: No way to distinguish node types
MATCH (n {name: 'Alice'})  // Scans ALL nodes!

// After: Label-based indexing
MATCH (alice:Person {name: 'Alice'})  // Only scans Person nodes

CREATE INDEX FOR (p:Person) ON (p.name)

TraversalDescription td = Traversal.description()
    .breadthFirst()
    .relationships(KNOWS, Direction.OUTGOING)
    .evaluator(Evaluators.toDepth(2));

for (Path path : td.traverse(startNode)) {
    // Process path
}

MATCH (start)-[:KNOWS*1..2]->(friend)
RETURN friend

Client → HTTP POST /cypher → Neo4j
       ← JSON response ←

Client → Binary query → Neo4j
       ← Binary result ←

        Write Leader
       /      |      \
  Follower Follower Follower
    (read)   (read)   (read)

// Call Java procedure from Cypher
CALL apoc.path.subgraphAll(startNode, {maxLevel: 3})
YIELD nodes, relationships

// Create separate databases
CREATE DATABASE social_network;
CREATE DATABASE recommendations;

// Switch between them
:use social_network
MATCH (p:Person) RETURN count(p);

:use recommendations
MATCH (u:User) RETURN count(u);

// Query across multiple databases
USE fabric.graphA, fabric.graphB
MATCH (p:Person)
WHERE p.age > 30
RETURN p.name

CREATE ROLE analyst;
GRANT MATCH {*} ON GRAPH social TO analyst;
DENY WRITE ON GRAPH social TO analyst;

// Create vector index for embeddings
CREATE VECTOR INDEX user_embeddings
FOR (u:User) ON (u.embedding)
OPTIONS {dimension: 256, similarity: 'cosine'};

// Similarity search
MATCH (u:User)
WHERE u.embedding SIMILAR TO $query_vector
RETURN u.name, vector.similarity(u.embedding, $query_vector) AS score
ORDER BY score DESC LIMIT 10;

@prefix ex: <http://example.org/> .

ex:Alice ex:knows ex:Bob .
ex:Alice ex:age "30"^^xsd:integer .
ex:Bob ex:worksAt ex:AcmeCorp .

PREFIX ex: <http://example.org/>

SELECT ?friend
WHERE {
  ex:Alice ex:knows ?friend .
  ?friend ex:age ?age .
  FILTER (?age > 25)
}

CREATE (alice:Person {name: "Alice", age: 30})
CREATE (bob:Person {name: "Bob", age: 28})
CREATE (alice)-[:KNOWS {since: 2015}]->(bob)

MATCH (alice:Person {name: "Alice"})-[k:KNOWS]->(friend:Person)
WHERE friend.age > 25
RETURN friend.name, k.since

// Find all missions affected by a specific component failure
MATCH (failure:Failure {component: 'O-ring'})<-[:EXPERIENCED]-(mission:Mission)
MATCH (mission)-[:USED]->(component)
RETURN mission.name, collect(component.name) AS components

// Real-time: "Customers who bought X also bought Y"
MATCH (product:Product {id: $product_id})<-[:PURCHASED]-(buyer:User)
MATCH (buyer)-[:PURCHASED]->(other:Product)
WHERE other <> product
RETURN other.name, count(*) AS score
ORDER BY score DESC LIMIT 10

Politician A → Company B (Panama) → Company C (BVI) → Bank Account D

// Load entities and relationships
CREATE (p:Person {name: "Politician A"})
CREATE (c1:Company {name: "Company B", jurisdiction: "Panama"})
CREATE (c2:Company {name: "Company C", jurisdiction: "BVI"})
CREATE (b:BankAccount {number: "D123"})

CREATE (p)-[:SHAREHOLDER_OF]->(c1)
CREATE (c1)-[:OWNS]->(c2)
CREATE (c2)-[:HAS_ACCOUNT]->(b)

// Find all politicians connected to offshore accounts (any depth)
MATCH path = (p:Person {type: 'Politician'})-[*]-(account:BankAccount)
WHERE account.jurisdiction IN ['BVI', 'Panama', 'Cayman Islands']
RETURN p.name, length(path) AS hops, account.number
ORDER BY hops ASC

(Origin:City)-[route:SHIP_VIA {cost, time, carrier}]->(Destination:City)

MATCH path = shortestPath(
  (origin:City {name: 'San Francisco'})-[r:SHIP_VIA*]-(dest:City {name: 'New York'})
)
WHERE ALL(rel IN relationships(path) WHERE rel.delivery_days <= 1)
WITH path, reduce(cost = 0, rel IN relationships(path) | cost + rel.cost) AS total_cost
RETURN path, total_cost
ORDER BY total_cost ASC
LIMIT 1

# PyTorch Geometric on Neo4j data
from torch_geometric.data import Data

# Load graph from Neo4j
query = "MATCH (a)-[r]->(b) RETURN id(a), id(b), r.weight"
edges = neo4j.execute(query)

# Convert to PyTorch tensor
edge_index = torch.tensor([[e.a for e in edges], [e.b for e in edges]])
data = Data(edge_index=edge_index)

# Train GNN
model = GCNConv(in_channels=128, out_channels=64)

CREATE (product:Product {
  name: "Smartphone X",
  image_embedding: $image_vector,    // 512-dim vector
  description: "The latest...",
  price: 999.99
})

// Relationship with timestamp
CREATE (alice)-[:KNOWS {from: date('2020-01-01'), to: date('2021-12-31')}]->(bob)

// Query: Who was Alice's friend in 2020?
MATCH (alice)-[k:KNOWS]->(friend)
WHERE date('2020-06-15') >= k.from AND date('2020-06-15') <= k.to
RETURN friend.name

SELECT p.name
FROM GRAPH social_network
MATCH (p:Person)-[:KNOWS]->(friend)
WHERE friend.age > 30

1736: Euler (graph theory foundations)
  ↓
1970: Codd (relational model dominates)
  ↓
2000: Neo4j prototype (native graph storage)
  ↓
2010: Neo4j 1.0 (first production graph database)
  ↓
2013: Cypher (expressive query language)
  ↓
2016: Bolt & Clustering (production scale)
  ↓
2024: GQL standard (SQL of graphs)
  ↓
Future: Graph + AI, distributed graphs, multi-modal data