Index Seeks/Scans, Label/Type Lookups, Join/Apply Operators, Eagerization, and Sort/Aggregation Costs

Learning outcomes

Plans become actionable only when operator names are tied to mechanisms. This lesson groups the operators by what they do to rows: locate starts, traverse, combine streams, materialize, sort and aggregate.

1. Leaf operators choose where work begins

Names can change or be specialized by release/runtime. The stable question is: how did the plan locate the first candidate entities, and how many rows emerged?

CYPHER 25EXPLAIN MATCH (p:Product)WHERE p.categoryCode='CAM' AND p.price >= 150RETURN p.productId,p.price;EXPLAIN MATCH (p:Product)RETURN p.productId,p.price;

2. Expand transforms bound nodes into relationship rows

Expand(All) follows relationships from a bound node and introduces the relationship/end node. Expand(Into) is used when both endpoints are already bound and Neo4j needs to test/find relationships between them. Look at rows before and after expansion: that delta is graph-shape work.

CYPHER 25PROFILEMATCH (c:Customer {customerId:$customerId})-[placed:PLACED]->(o:Order)-[line:CONTAINS]->(p:Product)RETURN count(placed) AS placedRows,count(line) AS lineRows;

3. Apply and joins combine row streams

Apply is a nested-loop family: for each left-side row, the right-side subtree is evaluated with imported variables. Semi/anti variants answer existence/non-existence questions without returning the right-side rows. Hash joins combine streams around common bound nodes when the planner judges that shape useful. Do not rewrite simply to eliminate the word “Apply”; measure the rows and repeated right-side work.

CYPHER 25EXPLAINMATCH (c:Customer {customerId:$customerId})CALL (c) {  MATCH (c)-[:PLACED]->(o:Order)  RETURN count(o) AS orderCount}RETURN c.customerId,orderCount;

4. Eagerization protects semantics but buffers work

Cypher is generally lazy: rows can flow upward as soon as they are produced. Some operations must consume/materialize upstream rows first. Eager can be inserted to preserve isolation when reads and writes could otherwise interfere; EagerAggregation groups rows; Sort must retain rows to order them. Blocking behavior matters when the upstream cardinality is large.

CYPHER 25PROFILEMATCH (c:Customer {labTag:'ch10'})-[:PLACED]->(o:Order {labTag:'ch10'})WITH c.segment AS segment,count(o) AS ordersRETURN segment,ordersORDER BY orders DESC;

5. Deliberately wrong: optimize the final row count

A query returning three aggregate rows can still expand through thousands of intermediate rows and buffer them before aggregation/sort. The repair is to inspect the entire tree and especially the transitions where estimated/actual rows jump, DB hits accumulate, or eager memory appears.

Summary and next step

Operators are mechanisms, not grades. Next, we add the time dimension: statistics evolve, plans are cached, parameters can be skewed, and one captured plan is not automatically representative.

Authoritative references

• Current Neo4j versions — Release/LTS snapshot used for this chapter.
• Understanding query plans — EXPLAIN/PROFILE, plan columns, rows, DB hits, memory and plan reading.
• Operators — Current operator families and operator semantics.
• Operators in detail — Current seek/scan, expand, apply/join, eager, sort and aggregation operators.
• Statistics and execution plans — Statistics collection, selectivity, replanning thresholds and manual preparation.
• Query caches — Per-database query caches, cache sizing and current query-size behavior.
• Cypher runtimes — Slotted, pipelined and parallel runtime boundaries.
• Operator summary — Leaf, eager, updating and other current operator families.
• Advanced query tuning — Current examples of plan/operator changes and index-backed optimizations.