Cypher Query Language

Cypher's most distinctive feature is its use of ASCII-art syntax to visually represent graph patterns. Nodes are depicted with parentheses (), relationships with arrows --> or --, and properties within curly braces {}. This makes complex graph traversals intuitive to write and read.

• Example: MATCH (p:Person)-[:LIVES_IN]->(c:City {name: 'Berlin'}) RETURN p.name
• The pattern (p:Person)-[:LIVES_IN]->(c:City...) directly mirrors the visual structure of the graph, connecting a Person node to a City node via a LIVES_IN relationship.

Like SQL, Cypher is a declarative language. You specify what data to find (the pattern), not how to traverse the graph. The Cypher query planner and optimizer determine the most efficient execution path, leveraging indexes and graph statistics.

• Key clauses follow a logical flow: MATCH (find patterns), WHERE (filter results), RETURN (project data).
• This abstraction allows developers to focus on the data model and business logic, while the database engine handles performance optimization.

Cypher is natively designed for the property graph model, which consists of:

• Nodes (vertices) with labels (e.g., :Person, :Product) and key-value properties.
• Relationships (edges) with a type (e.g., :PURCHASED, :WORKS_FOR) and direction, which can also have properties.
• This model is more flexible for many enterprise use cases than the RDF triple model, allowing attributes to be directly attached to both entities and connections.

Cypher provides a comprehensive set of clauses for full CRUD (Create, Read, Update, Delete) operations on the graph.

• Read Clauses: MATCH, OPTIONAL MATCH, WHERE, RETURN, ORDER BY, LIMIT.
• Write Clauses: CREATE (nodes/relationships), MERGE (create or match), SET (update properties), DELETE/DETACH DELETE (remove elements), REMOVE (delete labels/properties).
• Combining Operations: Read and write clauses can be combined in a single query, enabling complex transactional operations like finding a pattern and creating new connected data.

Cypher excels at expressing complex traversals and pathfinding queries using a concise syntax for variable-length relationships.

• Use * to match paths of arbitrary length: (:Person)-[:KNOWS*]->(:Person).
• Specify a range: [:KNOWS*2..5] finds paths between 2 and 5 hops long.
• The shortestPath() and allShortestPaths() functions provide optimized algorithms for common graph problems, directly within the query language.

Cypher supports powerful aggregation functions and operations on collections, similar to features in modern programming languages.

• Aggregation: Functions like COUNT(), COLLECT(), SUM(), and AVG() work with GROUP BY semantics.
• List & Map Projection: Create lists and maps directly in RETURN: RETURN p.name, [ (p)-[:HAS_SKILL]->(s) | s.name ] AS skills.
• Pattern Comprehensions: A compact syntax for filtering and projecting within a sub-pattern, enabling complex nested queries without multiple MATCH clauses.

The most basic query retrieves all nodes of a specific type (label). Use MATCH with parentheses and a colon.

Example: MATCH (p:Person) RETURN p

• Returns all nodes labeled Person.
• The RETURN clause specifies what data to output.
• You can limit results: MATCH (p:Person) RETURN p LIMIT 10.

Cypher excels at finding connected data. Use arrows (--> or <--) to traverse relationships, specifying their type in square brackets.

Example: MATCH (p:Person)-[:WORKS_FOR]->(c:Company) RETURN p.name, c.name

• Finds all Person nodes connected to a Company node via a WORKS_FOR relationship.
• The direction of the arrow matters; -[:WORKS_FOR]-> means the relationship goes from Person to Company.
• Returns the names of the people and their employers.

The WHERE clause filters results based on node/relationship properties, similar to SQL.

Example: MATCH (p:Person) WHERE p.age > 30 AND p.name STARTS WITH 'A' RETURN p

• Filters Person nodes where the age property is greater than 30 and the name property starts with 'A'.
• Can use operators: =, <>, <, >, CONTAINS, ENDS WITH.
• WHERE is often used with pattern matching: MATCH (p)-[:LIKES]->(m:Movie) WHERE m.year = 2023 RETURN p.name.

The CREATE clause inserts new graph elements. Use parentheses for nodes and brackets for relationships.

Example: CREATE (alice:Person {name: 'Alice', age: 30}), (bob:Person {name: 'Bob'}), (alice)-[:KNOWS {since: 2020}]->(bob)

• Creates two Person nodes with property sets ({...}).
• Creates a KNOWS relationship from alice to bob with a since property.
• Tip: Use MERGE instead of CREATE to avoid duplicates, as it checks for existence first.

Find paths of uncertain depth using the * operator. Essential for hierarchical or network data.

Examples:

• MATCH (p:Person)-[:FRIEND_OF*1..3]->(fof:Person) RETURN p, fof
  • Finds friends-of-friends, traversing 1 to 3 FRIEND_OF hops.
• MATCH path = (c:Company)<-[:WORKS_FOR*]-(e:Employee)
  • Finds all employees connected to a company at any depth (unbounded).
  • The path variable captures the entire sequence of nodes and relationships.

Use aggregation functions (COUNT, SUM, AVG, COLLECT) with RETURN and GROUP BY logic.

Example: MATCH (p:Person)-[:REVIEWED]->(m:Movie) RETURN m.title, AVG(p.rating) AS avg_rating, COUNT(*) AS reviews ORDER BY avg_rating DESC

• For each movie, calculates the average rating and counts the number of reviews.
• Groups results implicitly by the non-aggregated column (m.title).
• ORDER BY sorts the final results. COLLECT(p.name) would create a list of reviewer names.

Graph Query Optimization refers to the techniques used by graph database engines to efficiently execute declarative queries like those written in Cypher. This involves:

• Cost-Based Planners: Analyzing statistics about the graph (e.g., node degree, label selectivity) to choose the most efficient execution plan.
• Index Utilization: Leveraging indexes on node labels, relationship types, or property values to avoid full graph scans.
• Join Strategy Selection: Deciding the optimal order and method for matching multiple patterns in a query, which is critical for performance in connected data.

Graph Pattern Matching is the core computational task performed by Cypher. It involves finding all subgraphs within a larger property graph that conform to a specified pattern.

• Cypher Syntax: Patterns are expressed intuitively using parentheses for nodes (), arrows for relationships -->, and square brackets for details [:KNOWS].
• Example: The pattern (p:Person)-[:LIVES_IN]->(c:City) matches all person nodes connected to city nodes via a LIVES_IN relationship.
• This declarative approach abstracts away the procedural traversal logic, allowing developers to focus on what data they want, not how to retrieve it.