Cypher Query Language

Cypher's most distinctive feature is its use of ASCII-art to visually represent graph patterns. Nodes are defined within parentheses (), and relationships are defined using arrows --> or --, with square brackets [] for details.

• Example: (:Person)-[:WORKS_AT]->(:Company) intuitively reads as "a Person works at a Company."
• This declarative syntax allows users to describe what they want from the graph, not how to traverse it procedurally, making queries more readable and writable than equivalent SQL joins or imperative code.

Cypher is natively designed for the property graph model, directly mapping its core constructs: nodes, relationships, properties, and labels.

• Nodes ((n:Label {key: 'value'})) represent entities and can have multiple labels and key-value properties.
• Relationships (-[r:TYPE {key: 'value'}]-) are directed, named connections that are first-class citizens with their own properties.
• This native alignment eliminates the impedance mismatch common when using relational languages for graph data, enabling efficient storage and retrieval of connected data.

Cypher uses a structured set of declarative clauses that compose like sentences to build complex queries from simple parts.

Core clauses include:

• MATCH: Describes the pattern to find in the graph.
• WHERE: Filters patterns based on node/relationship properties or labels.
• RETURN: Specifies what data to output.
• CREATE/MERGE: Creates new graph elements or ensures they exist.
• SET/REMOVE: Updates properties and labels.
• DELETE: Removes elements.
• WITH: Pipes query results between stages, enabling multi-pass queries for aggregation and post-processing.

Cypher excels at querying variable-depth connections, a complex task in relational systems. It uses a concise syntax to traverse paths of unknown or variable length.

• Syntax: (:Person)-[:KNOWS*1..5]->(:Person) finds paths where one Person KNOWS another, from 1 to 5 hops away.
• The asterisk * denotes the variable-length traversal, and the range 1..5 defines the minimum and maximum depth.
• This enables powerful queries for finding shortest paths, discovering indirect connections, and analyzing network neighborhoods without recursive CTEs or multiple joins.

The language includes built-in functions and aggregators specifically designed for graph analytics.

Key functions include:

• Path functions: nodes(path), relationships(path), length(path).
• Shortest path: shortestPath() and allShortestPaths() algorithms.
• Aggregations on relationships: Collecting or counting across connections, e.g., COUNT(r) for incoming/outgoing edges.
• List comprehensions & pattern comprehensions: Allow in-line filtering and projection of subgraph patterns directly within a RETURN clause, enabling complex result shaping.

Cypher queries are executed by a graph database engine (like Neo4j) that leverages index-free adjacency—a storage model where each node holds direct pointers to its connected relationships. This allows for constant-time traversals regardless of graph size.

• The Cypher planner generates an execution plan that optimizes pattern matching order, index usage, and join strategies.
• It supports parameterized queries ($param) for security and performance, preventing injection and enabling plan caching.
• This combination allows Cypher to execute deep, multi-hop queries with millisecond latency on highly connected data, a performance profile central to its utility for real-time knowledge graph applications.

The fundamental operation in Cypher is pattern matching. Use parentheses () to represent nodes and arrows --> or <-- to represent directed relationships.

• Find all people: MATCH (p:Person) RETURN p
• Find a person's friends: MATCH (p:Person)-[:FRIEND_OF]->(friend) WHERE p.name = 'Alice' RETURN friend
• Find mutual connections: MATCH (a:Person)-[:FRIEND_OF]->(m)<-[:FRIEND_OF]-(b) WHERE a.name = 'Alice' AND b.name = 'Bob' RETURN m

The MATCH clause defines the pattern to find, WHERE filters results, and RETURN specifies what data to output.

Cypher uses CREATE, MERGE, SET, and DELETE to modify the graph.

• Create a node with properties: CREATE (p:Person {name: 'Charlie', age: 30})
• Merge a node (Create if not exists): MERGE (c:Company {name: 'Inferensys'}) ON CREATE SET c.founded = 2023
• Create a relationship between existing nodes: MATCH (a:Person), (b:Person) WHERE a.name = 'Alice' AND b.name = 'Bob' CREATE (a)-[:WORKS_WITH]->(b)
• Update a property: MATCH (p:Person {name: 'Charlie'}) SET p.age = 31
• Delete a node and its relationships: MATCH (p:Person {name: 'Charlie'}) DETACH DELETE p

MERGE is crucial for ensuring data integrity and preventing duplicates.

Use WHERE for conditional logic and aggregate functions like COUNT(), COLLECT(), and SUM() for data summarization.

• Filter by property value: MATCH (p:Person) WHERE p.age > 25 RETURN p
• Filter by string pattern: MATCH (p:Person) WHERE p.name STARTS WITH 'Al' RETURN p
• Count nodes: MATCH (p:Person) RETURN COUNT(p) AS total_people
• Group and aggregate: MATCH (p:Person)-[:WORKS_AT]->(c:Company) RETURN c.name, COLLECT(p.name) AS employees, COUNT(p) AS headcount
• Order and limit results: MATCH (p:Person) RETURN p ORDER BY p.age DESC LIMIT 10

Aggregations implicitly group by non-aggregated columns in the RETURN clause.

Cypher excels at traversing paths of unknown depth using variable-length relationship patterns.

• Find paths of any length: MATCH path = (a:Person)-[:FRIEND_OF*]->(b:Person) WHERE a.name = 'Alice' AND b.name = 'David' RETURN path
• Find paths of length 1 to 3: MATCH (a)-[:CONNECTED_TO*1..3]->(b)
• Find the shortest path: MATCH path = shortestPath((a:Person)-[:FRIEND_OF*]-(b:Person)) WHERE a.name = 'Alice' AND b.name = 'Zoe' RETURN path
• Return path length and nodes: MATCH p = (a)-[*]->(b) RETURN length(p), nodes(p)

This is essential for recommendation systems, fraud detection (finding rings), and supply chain analysis.

OPTIONAL MATCH and the WITH clause are powerful for constructing complex queries.

• OPTIONAL MATCH returns null for missing parts of a pattern, acting like a LEFT OUTER JOIN: MATCH (p:Person) OPTIONAL MATCH (p)-[:HAS_DEGREE]->(d:Degree) RETURN p.name, d.type
• The WITH clause pipes query results from one part to the next, enabling intermediate filtering and aggregation:

cypherCopy
MATCH (p:Person)-[:PURCHASED]->(prod:Product)
WITH p, COUNT(prod) AS purchase_count
WHERE purchase_count > 5
RETURN p.name, purchase_count

WITH is key for breaking down complex queries into readable, logical stages.

Cypher provides functional operations for processing collections.

• List comprehension creates a list by filtering or transforming another list: RETURN [x IN range(1,10) WHERE x % 2 = 0 | x * 2] AS doubled_evens
• UNWIND converts a list into individual rows, enabling batch operations:

cypherCopy
WITH ['AI', 'Graphs', 'ML'] AS topics
UNWIND topics AS topic
MERGE (t:Topic {name: topic})
RETURN t

• REDUCE aggregates elements in a list: MATCH p=(a)-[*]->(b) RETURN reduce(totalCost = 0, r IN relationships(p) | totalCost + r.cost) AS pathCost These constructs are vital for data transformation within a query.

The Property Graph Model is the fundamental data structure that Cypher is designed to query and manipulate. It consists of:

• Nodes (Vertices): Represent entities, which can have labels (e.g., Person, Product) and properties (key-value pairs like name: 'Alice').
• Relationships (Edges): Represent directed connections between nodes, which have a type (e.g., PURCHASED, WORKS_FOR) and can also contain properties (e.g., since: 2020).
• This model's intuitive, whiteboard-friendly structure makes it the dominant paradigm for modern graph databases like Neo4j, upon which Cypher is built.

Graph Pattern Matching is the foundational computational task that Cypher executes. It involves finding all subgraphs within a larger data graph that are isomorphic (structurally identical) to a given query pattern.

• Cypher as a Pattern Matcher: A Cypher MATCH clause, like (a:Person)-[:WORKS_FOR]->(b:Company), is a declarative specification of a graph pattern. The query engine's core job is to efficiently locate all instances of this pattern.
• Complexity: Subgraph isomorphism is an NP-complete problem in general. Cypher engines use sophisticated query optimization—leveraging indexes, statistics, and cost-based planners—to make real-time pattern matching feasible on large graphs.