Cypher

Cypher's core innovation is its visual, ASCII-art syntax for describing graph patterns. Nodes are represented by parentheses (), relationships by arrows --> or --, and properties by curly braces {}. This makes queries highly readable and intuitive, closely mirroring a whiteboard diagram.

Example: MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'Berlin'}) RETURN p.name

• (p:Person) is a node with the label Person.
• -[:LIVES_IN]-> is a directed relationship of type LIVES_IN.
• (c:City {name: 'Berlin'}) is a target node with label City and a property filter.

Cypher uses a structured set of declarative clauses that describe what to find or do, not how to do it. The database's query optimizer determines the most efficient execution path.

Key Clauses:

• MATCH: Describes patterns to find in the graph.
• WHERE: Filters results with predicates.
• RETURN: Defines the result set to output.
• CREATE / MERGE: Creates new graph elements or ensures they exist.
• SET / REMOVE: Updates or deletes properties and labels.
• DELETE: Removes nodes and relationships.

Queries chain these clauses, e.g., MATCH a pattern, WHERE to filter, then RETURN results.

The MERGE clause ensures a pattern exists in the graph. It acts as a combination of MATCH and CREATE.

• If the entire pattern already exists, MERGE simply matches it.
• If any part is missing, it creates the missing elements.

This is critical for idempotent data loading and avoiding duplicates. It is often used with ON CREATE SET and ON MATCH SET to specify properties to set only on creation or update.

Example: MERGE (c:Company {taxId: '12345'}) ON CREATE SET c.founded = date() ON MATCH SET c.lastSeen = date() ensures a company node exists and updates timestamps appropriately.

Cypher excels at querying paths—sequences of connected nodes and relationships. It allows for expressive and efficient traversal queries.

• Variable-length paths: Use * to match paths of unspecified depth.
  • (a)-[:KNOWS*1..3]->(b) finds paths where a KNOWS b via 1 to 3 hops.
  • (a)-[:KNOWS*]->(b) finds paths of any length.
• Named paths: Assign an entire path to a variable for later use: path = (a)-[:KNOWS*2..4]->(b).
• Shortest path functions: Built-in algorithms like shortestPath() find optimal routes.

This feature is fundamental for social network analysis, recommendation engines, and fraud detection.

Cypher provides powerful aggregation functions and list operations for transforming result sets, similar to SQL's GROUP BY but with graph-aware semantics.

Aggregation: Functions like collect(), count(), sum(), avg() group results by a key.

• RETURN p.name, collect(c.name) AS cities returns a person's name and a list of their cities.

List & Map Projections: Create complex structures directly in the RETURN.

• RETURN p {.name, .age, employer: [(p)-[:WORKS_FOR]->(c) | c.name]} projects a map with the person's properties and a derived list of employer names.

List Comprehensions: Process elements within a list: [x IN list WHERE x.prop > 10 | x.value].

Cypher queries execute within full ACID transactions, ensuring data integrity. Multiple statements in a single transaction are atomic.

For complex, multi-step operations, Cypher supports procedural logic through:

• WITH Clause: Pipes results from one part of a query to the next, enabling step-wise transformations and conditional logic.
• FOREACH Clause: Iterates over a list to perform updating operations.
• CALL Subquery: Isolates sub-queries for modular logic.
• User-Defined Procedures & Functions: Extend Cypher's capabilities with custom logic written in Java, Python, or other languages, callable via CALL my.procedure(input).

This combination allows Cypher to handle sophisticated data migration, graph algorithms, and ETL workflows.

The MATCH clause is used to find patterns in the graph. It describes the shape of the data using nodes in parentheses () and relationships in brackets [].

Example: Find a Person and their City

cypherCopy
MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'London'})
RETURN p.name, p.age

• (p:Person): A node with the label Person, assigned to variable p.
• -[:LIVES_IN]->: A directed relationship of type LIVES_IN.
• (c:City {name: 'London'}): A City node with a property name equal to 'London'.
• The query returns the names and ages of all people who live in London.

The CREATE clause is used to insert new graph elements. You can create nodes, relationships, and set their properties in a single statement.

Example: Create a New Person and Connect Them

cypherCopy
CREATE (p:Person {
    name: 'Alice',
    employeeId: 123,
    joined: date()
})
WITH p
MATCH (c:City {name: 'Berlin'})
CREATE (p)-[:WORKS_IN {since: 2023}]->(c)
RETURN p, c

• Creates a new Person node with three properties.
• The WITH clause pipes the created node p to the next part of the query.
• Matches an existing City node for Berlin.
• Creates a new WORKS_IN relationship from Alice to Berlin, with a property since.
• Note: CREATE will always create new data, even if it duplicates existing patterns.

The MERGE clause ensures a pattern exists in the graph. It will match an existing pattern or create it if it doesn't exist, preventing duplicates. It is often used with ON CREATE and ON MATCH.

Example: Get or Create a Unique Company

cypherCopy
MERGE (c:Company {legalName: 'Inferensys Ltd'})
ON CREATE SET c.created = timestamp(), c.status = 'new'
ON MATCH SET c.lastAccessed = timestamp()
RETURN c

• Attempts to find a Company node with legalName: 'Inferensys Ltd'.
• ON CREATE: If the node is created, it sets the created and status properties.
• ON MATCH: If the node already exists, it updates the lastAccessed property.
• This is the Cypher equivalent of an "upsert" operation, critical for maintaining data integrity.

The SET clause updates properties on nodes or relationships. REMOVE deletes properties or labels.

Example: Update a User's Profile

cypherCopy
MATCH (u:User {userId: 'u456'})
SET u.department = 'Engineering',
    u.lastUpdated = datetime()
REMOVE u.temporaryFlag
RETURN u

Example: Add or Remove a Label

cypherCopy
MATCH (p:Person {name: 'Bob'})
SET p:Archived  // Adds the 'Archived' label
// REMOVE p:Archived // Would remove the label

• SET can add new properties or overwrite existing ones.
• Labels are treated as a special type of property and can be added/removed with SET/REMOVE.
• Combining MATCH with SET is the standard pattern for in-place updates.

Cypher uses WHERE for filtering patterns, WITH for piping and aggregating intermediate results, and ORDER BY for sorting.

Example: Complex Filtering and Counting

cypherCopy
MATCH (p:Person)-[:WORKS_FOR]->(co:Company)
WHERE p.age > 25 AND co.industry = 'Technology'
WITH co, count(p) AS employeeCount
WHERE employeeCount > 50
RETURN co.name, employeeCount
ORDER BY employeeCount DESC

• Finds people over 25 who work for tech companies.
• WITH passes the company and a count of its matched employees to the next stage.
• The second WHERE clause filters these aggregated results to only companies with more than 50 such employees.
• Finally, results are returned sorted by the count in descending order. This demonstrates chaining query stages.

Cypher excels at finding paths. Variable-length relationships use * to traverse an unspecified number of hops.

Example: Find Shortest Path

cypherCopy
MATCH path = shortestPath(
  (a:Person {name: 'Alice'})-[*..6]-(b:Person {name: 'Bob'})
)
RETURN path, length(path)

Example: Find All Colleagues Up to 2 Hops Away

cypherCopy
MATCH (p:Person {name: 'Charlie'})-[:WORKS_WITH*1..2]-(colleague:Person)
RETURN DISTINCT colleague.name

• [*..6]: A path of any relationship type, up to 6 hops deep.
• shortestPath(): A built-in function to find the shortest path matching the pattern.
• [:WORKS_WITH*1..2]: Traverses WORKS_WITH relationships 1 or 2 hops out.
• These patterns are fundamental for social network analysis, fraud detection (finding rings), and supply chain mapping.

The underlying data model for which Cypher is designed. A property graph consists of:

• Nodes (Vertices): Represent entities, with optional key-value properties.
• Relationships (Edges): Directed, typed connections between nodes, which can also have properties.
• Labels: Tags that categorize nodes into types. Cypher's ASCII-art syntax (()-[]->()) is a direct visual representation of this model, making it intuitive for pattern matching.

An International Organization for Standardization (ISO) standard query language for property graphs, currently in development. GQL aims to be a unifying, vendor-neutral language. Cypher is a primary influence on the GQL standard. While Cypher is the native language for Neo4j, GQL is positioned to become a portable standard across multiple graph database systems, similar to SQL's role for relational databases.

The World Wide Web Consortium (W3C) standard query language for RDF triplestores. It serves a similar purpose to Cypher but for a different underlying data model.

• Key Difference: SPARQL queries a global graph of subject-predicate-object triples, while Cypher queries a labeled property graph with properties on both nodes and edges.
• Use Case: SPARQL is dominant in semantic web and linked open data projects, whereas Cypher is prevalent in enterprise analytics and transactional applications using property graphs.

A native graph storage design principle that critically enables Cypher's traversal performance. In a natively stored graph, connected nodes contain direct physical pointers or references to each other.

• Traversal Mechanism: A query like MATCH (a:Person)-[:KNOWS]->(b) can be executed by following these physical pointers from node a to node b.
• Performance Impact: This allows traversal speed to be independent of total graph size, relying only on the number of connections actually traversed, enabling millisecond-speed queries on billion-node graphs.

An open-source initiative to make the Cypher query language specification and related tools available to the community and other database vendors. The goal was to standardize Cypher's syntax and semantics outside of Neo4j.

• Outcome: This effort contributed significantly to the development of the ISO GQL standard. While OpenCypher itself is not a formal standard, it established Cypher as a leading language paradigm and influenced several other graph query processors and engines.

The set of transaction properties—Atomicity, Consistency, Isolation, Durability—that Cypher operations typically execute within in databases like Neo4j.

• Atomicity: A Cypher write query (CREATE, MERGE, SET, DELETE) either fully succeeds or is completely rolled back.
• Consistency: Each query leaves the graph in a valid state, respecting schema constraints.
• Isolation: Concurrent Cypher queries do not interfere with each other's intermediate states.
• Durability: Committed writes are permanently stored. This guarantees reliable data manipulation, making Cypher suitable for mission-critical, operational workloads.