N+1 Diagnosis & Repair

Batching sends many same-shaped statements in one round trip, one parameter set per row, instead of a request-and-wait per row. The database still does each row's work; what disappears is the per-row waiting.

Four families: pull the link into the parents' statement with a join fetch, load the whole page's links in one extra bulk statement, project the read down to the fields it needs, or serve the link from a cache.

The line that first touches a deferred link while iterating — an ordinary field read, not a query call. The list read is one statement; every touch inside the iteration adds another.

A mapper holds saved objects in an in-memory identity map and defers the write until a flush. A read by the same id hands back that instance, so the assertion passes whether or not a statement ever reached the database.

Count at the connection or driver, the one boundary every statement crosses, and hold the counter in per-request state read where the work closes - after rendering, so late fetches are included.

Three things: the statements share one text and differ only in parameters; the layer may reorder them, grouping by shape while keeping parents before children; and nothing between them forces an early trip to the database.

A to-one link only adds columns, so a join fetch usually fits. A to-many link adds rows and interacts badly with paging and with a second collection, so a bulk statement covering the whole page usually fits better.

Each level's touch runs once per row produced by the level above it, so counts compose by multiplication: one list read, one per parent, then one per child of every parent. Levels multiply rather than add.

Every defect that needs a boundary crossing: reads of not-yet-loaded data after the context is gone, work done on detached objects, stale reads, and anything the database supplies. One open context keeps every object live and every read answered from memory.

Give each phase its own boundary: seed and close, run the code under test in a context it enters itself, then assert in a fresh context or with a plain SELECT. The assertion must never read through the tracked set that produced the state.

Cascading turns one save into a write per reachable child row, and a collection whose elements the layer cannot match to stored rows is replaced wholesale: the existing rows are deleted and the current contents inserted again.

Volume is the multiplier. At three rows a per-row statement loop costs three statements and milliseconds, no page boundary or batch limit is crossed, and a full scan is the fastest access path anyway, so the defect is real but produces no visible symptom.

Record the per-request count as a number - on the request record and as a distribution keyed by route - alert on per-route drift rather than an absolute threshold, and sample grouped statement text only above a threshold.

A measured window that excludes setup, an assertion on the property rather than an observed number - the count must not grow when rows grow - and a failure message printing the repeated statement shape.

Measure round trips, not statements: a batch executes the same statements as before. Read the layer's or driver's batch counters, watch how runtime scales when link latency is added, then look for the things that silently split a batch.

A fetch-plan change still loads whole objects into the tracked set for every row. A projection asks only for the columns the response shows, and a cache removes the statement entirely for data read far more often than it changes.

Ask what runs per element, not what the line says. Follow every helper called inside an iteration down to whether it reads storage or touches a link the caller never loaded, and size the collection it is called over.

Show that the statement count moves with the number of rows walked. Capture statements per request alongside the result size in both environments; a count that tracks rows one-for-one while each statement stays fast identifies the emitter.

Measure first: record today's count per operation into a checked-in baseline file, then ratchet it - exceeding fails, coming in under lowers the recorded number, raising it is a reviewed change. Report-only first, deterministic always, with a self-diagnosing failure message.

When the change is uniform and its rows can be named by a predicate rather than enumerated. One statement removes the trips and the per-row object work, but hooks, concurrency checks and cascades no longer run.

Default to fixing the read. A mapping change applies to every read of that type, so it trades one screen's extra statements for over-fetching everywhere else. Change the mapping only when every read genuinely needs the link.

Classify the escapes by the mechanism that hid them — no boundary crossed, no volume, no second observer — then buy the cheapest signal for the classes that actually escape. Realism costs feedback time, so spend it on representative paths, not everywhere.