This document summarizes a presentation about Cypher, the graph query language for Neo4j. Cypher was created because existing query mechanisms for Neo4j like the Java API were too verbose and prescriptive, while other graph query languages like SPARQL had limitations for Neo4j's data model. Cypher aims to make querying simple with a declarative pattern matching approach using ASCII art patterns. It has a familiar SQL-like structure and borrows concepts like START, MATCH, WHERE, RETURN, and ORDER BY. The implementation evaluates queries lazily through an execution plan of operators like Parameters, Nodes, PatternMatch, and Aggregation.

1. Cypher Query Language
Chicago Graph Database Meet-Up
Max De Marzi

2. What is Cypher?
• Graph Query Language for Neo4j
• Aims to make querying simple

3. Why Cypher?
• Existing Neo4j query mechanisms were not
simple enough
• Too verbose (Java API)
• Too prescriptive (Gremlin)

4. SQL?
• Unable to express paths
• these are crucial for graph-based
reasoning
• Neo4j is schema/table free

5. SPARQL?
• SPARQL designed for a different data
model
• namespaces
• properties as nodes
• high learning curve

6. Design

7. Design Decisions
Declarative
Most of the time, Neo4j knows better than you
Imperative Declarative
follow relationship specify starting point
breadth-first vs depth-first specify desired outcome
explicit algorithm algorithm adaptable
based on query

8. Design Decisions
Pattern matching

9. Design Decisions
Pattern matching
A
B C

10. Design Decisions
Pattern matching

11. Design Decisions
Pattern matching

12. Design Decisions
Pattern matching

13. Design Decisions
Pattern matching

14. Design Decisions
ASCII-art patterns
() --> ()

15. Design Decisions
Directed relationship
A B
(A) --> (B)

16. Design Decisions
Undirected relationship
A B
(A) -- (B)

17. Design Decisions
specific relationships
LOVES
A B
A -[:LOVES]-> B

18. Design Decisions
Joined paths
A B C
A --> B --> C

19. Design Decisions
multiple paths
A
B C
A --> B --> C, A --> C
A --> B --> C <-- A

20. Design Decisions
Variable length paths
A B
A B
A B
...
A -[*]-> B

21. Design Decisions
Optional relationships
A B
A -[?]-> B

22. Design Decisions
Familiar for SQL users
select
start
from
match
where
where
group by
return
order by

23. START
SELECT *
FROM Person
WHERE firstName = “Max”
START max=node:persons(firstName = “Max”)
RETURN max

24. MATCH
SELECT skills.*
FROM users
JOIN skills ON users.id = skills.user_id
WHERE users.id = 101
START user = node(101)
MATCH user --> skills
RETURN skills

25. Optional MATCH
SELECT skills.*
FROM users
LEFT JOIN skills ON users.id = skills.user_id
WHERE users.id = 101
START user = node(101)
MATCH user –[?]-> skills
RETURN skills

26. SELECT skills.*, user_skill.*
FROM users
JOIN user_skill ON users.id = user_skill.user_id
JOIN skills ON user_skill.skill_id = skill.id WHERE
users.id = 1

27. START user = node(1)
MATCH user -[user_skill]-> skill
RETURN skill, user_skill

28. Indexes
Used as multiple starting points, not to speed
up any traversals
START a = node:nodes_index(type='User') MATCH
a-[r:knows]-b
RETURN ID(a), ID(b), r.weight

29. http://maxdemarzi.com/2012/03/16/jung-in-neo4j-par

30. Complicated Match
Some UGLY recursive self join on the groups
table
START max=node:person(name=“Max")
MATCH group <-[:BELONGS_TO*]- max
RETURN group

31. Where
SELECT person.*
FROM person
WHERE person.age >32
OR person.hair = "bald"
START person = node:persons("name:*") WHERE
person.age >32
OR person.hair = "bald"
RETURN person

32. Return
SELECT person.name, count(*)
FROM Person
GROUP BY person.name
ORDER BY person.name
START person=node:persons("name:*") RETURN
person.name, count(*)
ORDER BY person.name

33. Order By, Parameters
Same as SQL
{node_id} expected as part of request
START me = node({node_id})
MATCH (me)-[?:follows]->(friends)-[?:follows]->(fof)-[?:follows]->(fofof)-
[?:follows]->others
RETURN me.name, friends.name, fof.name, fofof.name, count(others)
ORDER BY friends.name, fof.name, fofof.name, count(others) DESC

34. http://maxdemarzi.com/2012/02/13/visualizing-a-netw

35. Graph Functions
Some UGLY multiple recursive self and inner joins on
the user and all related tables
START lucy=node(1000), kevin=node(759) MATCH p
= shortestPath( lucy-[*]-kevin ) RETURN p

36. Aggregate Functions
ID: get the neo4j assigned identifier
Count: add up the number of occurrences
Min: get the lowest value
Max: get the highest value
Avg: get the average of a numeric value
Distinct: remove duplicates
START me = node:nodes_index(type = 'user')
MATCH (me)-[r?:wrote]-()
RETURN ID(me), me.name, count(r), min(r.date), max(r.date)" ORDER
BY ID(me)

37. Functions
Collect: put all values in a list
START a = node:nodes_index(type='User')
MATCH a-[:follows]->b
RETURN a.name, collect(b.name)

38. http://maxdemarzi.com/2012/02/02/graph-visualizatio

39. Combine Functions
Collect the ID of friends
START me = node:nodes_index(type = 'user')"
MATCH (me)<-[r?:wrote]-(friends)
RETURN ID(me), me.name, collect(ID(friends)), collect(r.date)
ORDER BY ID(me)

40. http://maxdemarzi.com/2012/03/08/connections-in-time/

41. Uses
Recommend Friends
START me = node({node_id})
MATCH (me)-[:friends]->(friend)-[:friends]->(foaf)
RETURN foaf.name

42. Uses
Six Degrees of Kevin Bacon
Length: counts the number of nodes along a path
Extract: gets the nodes/relationships from a path
START me=node({start_node_id}),
them=node({destination_node_id})
MATCH path = allShortestPaths( me-[?*]->them )
RETURN length(path),
extract(person in nodes(path) : person.name)

43. Uses
Similar Users
Users who rated same items within 2 points.
Abs: gets absolute numeric value
START me = node(user1)
MATCH (me)-[myRating:RATED]->(i)<-[otherRating:RATED]-(u)
WHERE abs(myRating.rating-otherRating.rating)<=2
RETURN u

44. Boolean Operations
Items with a rating > 7 that similar users rated, but I have not
And: this and that are true
Or: this or that is true
Not: this is false
START me=node(user1),
similarUsers=node(3) (result received in the first query)
MATCH (similarUsers)-[r:RATED]->(item)
WHERE r.rating > 7 AND NOT((me)-[:RATED]->(item))
RETURN item
http://thought-bytes.blogspot.com/2012/02/similarity-based-recommendation

45. Predicates
ALL: closure is true for all items
ANY: closure is true for any item
NONE: closure is true for no items
SINGLE: closure is true for exactly 1 item
START london = node(1), moscow = node(2)
MATCH path = london -[*]-> moscow
WHERE all(city in nodes(path) where
city.capital = true)

46. Design Decisions
Parsed, not an internal DSL
Execution Semantics Serialisation
Type System Portability

47. Design Decisions
Database vs Application
Design Goal: single user
interaction expressible as
single query
Queries have enough logic to
find required data, not enough
to process it

48. Implementation

49. Implementation
• Recursive matching with backtracking
START x=... MATCH x-->y, x-->z, y-->z, z-->a-->b, z-->b

50. Implementation
Execution Plan
start n=node(0) Cypher is Pipes
return n
lazily evaluated
Parameters() pulling from pipes underneath
Nodes(n)
Extract([n])
ColumnFilter([n])

51. Implementation
Execution Plan
start n=node(0)
match n-[*]-> b
return n.name, n, count(*)
order by n.age
Parameters()
Nodes(n)
PatternMatch(n-[*]->b)
Extract([n.name, n])
EagerAggregation( keys: [n.name, n], aggregates: [count(*)])
Extract([n.age])
Sort(n.age ASC)
ColumnFilter([n.name,n,count(*)])

52. Implementation
Execution Plan
start n=node(0)
match n-[*]-> b
return n.name, n, count(*)
order by n.name
Parameters()
Nodes(n)
PatternMatch(n-[*]->b)
Extract([n.name, n])
Sort(n.name ASC,n ASC)
EagerAgregation( keys: [n.name, n], aggregates: [count(*)])
ColumnFilter([n.name,n,count(*)])

53. Thanks for Listening!
Questions?
maxdemarzi.com