Neo4j Advanced: Cypher Query Optimization & Graph Algorithms

Graph databases excel at handling highly connected data, and Neo4j is the leading graph database. However, as your graph grows, naive Cypher queries can become slow. This advanced tutorial dives into Cypher query optimization techniques and graph algorithms that will help you write efficient, production-ready queries. You'll learn how to use profiling tools, design effective indexes, and leverage the Graph Data Science (GDS) library for analytics. We'll also cover common pitfalls and debugging strategies. By the end, you'll be able to optimize complex traversals and apply algorithms like PageRank and Shortest Path to real-world problems such as recommendation engines and fraud detection.

Understanding Query Execution Plans

Before optimizing, you need to understand how Neo4j executes your query. Use EXPLAIN to see the plan without running it, and PROFILE to get runtime statistics. Key operators include NodeByLabelScan (full scan), NodeIndexSeek (index lookup), Expand(All) (traversal), and Filter (post-filtering). Aim to reduce db hits (number of records accessed). For example, a query that does a NodeByLabelScan on 1 million nodes is slow; an index seek on a property reduces hits to 1.

PROFILE
MATCH (p:Person {id: '123'})
RETURN p.name;

Indexing Strategies for Graphs

Neo4j supports single-property indexes, composite indexes, and full-text indexes. For graph traversals, indexing on node labels and properties used in MATCH or WHERE is crucial. Composite indexes can speed up queries filtering on multiple properties. Also consider index-backed ordering: if you ORDER BY a property, an index can avoid a sort. Use SHOW INDEXES to monitor. Example: CREATE INDEX ON :Person(name, age).

CREATE INDEX person_name_age_idx FOR (n:Person) ON (n.name, n.age);
// Then query uses index:
MATCH (p:Person {name: 'Alice', age: 30})
RETURN p;

Efficient Pattern Matching and Traversals

Variable-length pattern matching (e.g., [:FRIEND*1..3]) can cause exponential path expansion. Instead, use APOC path expander for controlled traversals. Also, filter early: add WHERE clauses before expansions. Use shortestPath for shortest path queries. For example, to find friends of friends efficiently:

// Inefficient: full expansion
MATCH (a:Person {id: '1'})-[:FRIEND*2]->(b)
RETURN DISTINCT b;

// Efficient: APOC path expander with limit
CALL apoc.path.expand(a, 'FRIEND', 'Person', 1, 2) YIELD path
RETURN last(nodes(path)) AS b;

Using the Graph Data Science (GDS) Library

GDS provides in-memory graph algorithms for analytics. Common algorithms: PageRank (importance), Shortest Path (distance), Community Detection (Louvain), and Node Similarity. Load a graph into memory, run algorithm, and stream results. Example: PageRank to find influential users.

CALL gds.graph.project('myGraph', 'Person', 'FRIEND')
YIELD graphName;

CALL gds.pageRank.stream('myGraph')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS name, score
ORDER BY score DESC LIMIT 10;

Optimizing Write Queries with Batching

Large batch inserts can overwhelm the transaction log. Use UNWIND with parameter lists and periodic commit (in older versions) or call in subqueries with CALL { ... } IN TRANSACTIONS. Example: batch create nodes.

UNWIND $persons AS person
CALL {
  WITH person
  CREATE (p:Person {id: person.id, name: person.name})
} IN TRANSACTIONS OF 1000 ROWS;

Advanced Profiling: Identifying Hotspots

Use PROFILE to see operator-level stats. Look for high db hits in Expand(All) or Filter. If a Filter follows an index seek, consider moving the condition into the index (composite index). Also, use the Neo4j browser's visual explain plan. Example: profile a query that filters on a non-indexed property after a match.

PROFILE
MATCH (p:Person)
WHERE p.age > 30 AND p.name = 'Alice'
RETURN p;