Cypher Basics

Cypher is Neo4j's declarative query language, designed to be visual and intuitive. Cypher uses ASCII-art patterns to describe graph structures, making queries readable even without deep database expertise.

---

Why Cypher?

• Visual syntax — patterns look like the graph they describe
• Declarative — you describe what you want, not how to get it
• Powerful — supports pattern matching, filtering, aggregation, and more
• Standardised — the basis for the GQL (Graph Query Language) ISO standard

---

Core Concepts

Node Patterns

Nodes are represented with parentheses:

()                          // Anonymous node
(p)                         // Node bound to variable p
(:Person)                   // Node with label Person
(p:Person)                  // Node with label, bound to variable p
(p:Person {name: "Alice"})  // Node with label and property filter

Relationship Patterns

Relationships are represented with square brackets and arrows:

-->                              // Anonymous directed relationship
-[r]->                           // Relationship bound to variable r
-[:PURCHASED]->                  // Relationship with type PURCHASED
-[r:PURCHASED]->                 // Relationship with type, bound to variable
-[r:PURCHASED {date: "2024-01-15"}]->  // With property filter

Full Pattern

Combine nodes and relationships into a pattern:

(alice:Person {name: "Alice"})-[:PURCHASED]->(product:Product)

---

MATCH — Reading Data

The MATCH clause finds patterns in the graph:

Find all nodes with a label

MATCH (p:Person)
RETURN p

Find nodes by property

MATCH (p:Person {name: "Alice"})
RETURN p

Find related nodes

MATCH (p:Person)-[:PURCHASED]->(product:Product)
RETURN p.name, product.name

Traverse multiple hops

// Friends of friends
MATCH (p:Person {name: "Alice"})-[:FRIENDS_WITH]->()-[:FRIENDS_WITH]->(fof)
RETURN fof.name

---

WHERE — Filtering Results

The WHERE clause adds conditions to your query:

Comparison operators

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

String matching

MATCH (p:Person)
WHERE p.name STARTS WITH "A"
RETURN p.name

MATCH (p:Person)
WHERE p.name CONTAINS "li"
RETURN p.name

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

Boolean operators

MATCH (p:Person)
WHERE p.age > 25 AND p.name <> "Bob"
RETURN p.name

Checking existence

// Nodes with an email property
MATCH (p:Person)
WHERE p.email IS NOT NULL
RETURN p.name

// Nodes that have a specific relationship
MATCH (p:Person)
WHERE EXISTS { (p)-[:PURCHASED]->(:Product) }
RETURN p.name

List predicates

MATCH (p:Person)
WHERE p.age IN [25, 30, 35]
RETURN p.name

---

RETURN — Shaping Output