@quereus/quereus 4.16.0 → 4.17.0

package/dist/src/planner/rules/aggregate/rule-groupby-fd-simplification.d.ts

@@ -5,7 +5,9 @@
  * GROUP BY columns under the aggregate-output FDs and equivalence classes.
  * Each dropped column is re-emitted as a `MIN(<original-column>)` picker
  * aggregate so the output attribute IDs (and therefore downstream binding)
- * are preserved.
+ * are preserved. The picker relies on the BUILT-IN `min`'s semantics (any
+ * value from the group, since the group is a single source row); the rule
+ * declines when `min/1` has been shadowed by a user-registered function.
  *
  * The aggregate's own `physical.fds` and `physical.equivClasses` are already
  * projected onto its output column indices by `propagateAggregateFds`, so

package/dist/src/planner/rules/aggregate/rule-groupby-fd-simplification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-groupby-fd-simplification.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-groupby-fd-simplification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAmD,MAAM,0BAA0B,CAAC;AAC1G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAY7D,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAuJhG"}
+{"version":3,"file":"rule-groupby-fd-simplification.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-groupby-fd-simplification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAmD,MAAM,0BAA0B,CAAC;AAC1G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAY7D,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA0JhG"}

package/dist/src/planner/rules/aggregate/rule-groupby-fd-simplification.js

@@ -5,7 +5,9 @@
  * GROUP BY columns under the aggregate-output FDs and equivalence classes.
  * Each dropped column is re-emitted as a `MIN(<original-column>)` picker
  * aggregate so the output attribute IDs (and therefore downstream binding)
- * are preserved.
+ * are preserved. The picker relies on the BUILT-IN `min`'s semantics (any
+ * value from the group, since the group is a single source row); the rule
+ * declines when `min/1` has been shadowed by a user-registered function.
  *
  * The aggregate's own `physical.fds` and `physical.equivClasses` are already
  * projected onto its output column indices by `propagateAggregateFds`, so
@@ -133,9 +135,12 @@ export function ruleGroupByFdSimplification(node, context) {
     if (keptGroupBy.length === 0)
         return null;
     // Synthesize picker MIN aggregates for each dropped column, in original order.
-    const minSchema = context.db._findFunction('min', 1);
+    // Gate on schema identity, not name: `addFunction` overwrites by name/numArgs, so
+    // a user `min/1` and `_findFunction('min', 1)` would otherwise agree with each
+    // other while disagreeing with the built-in semantics this rewrite relies on.
+    const minSchema = context.db._findBuiltinFunction('min', 1);
     if (!minSchema || !isAggregateFunctionSchema(minSchema)) {
-        log('min/1 not registered as aggregate; skipping');
+        log('min/1 is not the built-in aggregate; skipping');
         return null;
     }
     const pickerAggregates = [];

package/dist/src/planner/rules/aggregate/rule-groupby-fd-simplification.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-groupby-fd-simplification.js","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-groupby-fd-simplification.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"rule-groupby-fd-simplification.js","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-groupby-fd-simplification.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/aggregate/rule-minmax-index-boundary.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Rule: answer an ungrouped MIN / MAX from the index boundary.
+ *
+ * `min(c)` over any relation `S` equals `min(c)` over
+ * `(S where c is not null order by c asc limit 1)`; `max(c)` is the same with
+ * `desc`. The identity holds for every `S`, so this is a pure plan-shape change —
+ * never a different answer, only a cheaper one.
+ *
+ * The rewrite builds exactly that shape and hands it to the planner's existing
+ * sort-absorption probe (`trySortAbsorbViaIndexOrdering`). The `AggregateNode`
+ * itself is kept, unchanged, on top:
+ *
+ *   Aggregate [max(c)]                  <- unchanged
+ *     └─ LimitOffset(limit=1)           <- new
+ *          └─ Filter(c is not null)     <- new, only when `c` is nullable
+ *               └─ Retrieve(t)          <- equipped with an ordering access plan
+ *
+ * Keeping the aggregate is what makes the two hard cases free:
+ *
+ *  - Empty relation. An ungrouped aggregate over zero rows still emits exactly one
+ *    row, and min/max finalize an empty accumulator to NULL — so
+ *    `select max(c) from empty_table` keeps returning one NULL row with no special
+ *    casing here.
+ *  - The comparator. This rule never compares values itself. It delegates "does
+ *    index order agree with the argument's semantic order" to the same access-plan
+ *    ordering claim plain `ORDER BY` relies on, and min/max already rank under the
+ *    same semantic comparator ORDER BY uses, so the two agree by construction.
+ *
+ * The probe runs BEFORE anything is committed: if it returns null the rule returns
+ * null and the plan is left byte-identical. No Sort, Filter or Limit is ever
+ * introduced into a plan that cannot serve the ordering.
+ *
+ * Neither shipped backend walks an index backwards (both require the requested
+ * direction to equal the index column's declared direction), so in practice:
+ *
+ *   min(c) + ascending index on c (incl. the primary key) -> boundary read
+ *   max(c) + descending index on c                        -> boundary read
+ *   max(c) + only an ascending index on c                 -> unchanged, full scan
+ *   either + no index                                     -> unchanged, full scan
+ *
+ * Making `max(c)` fast off an ascending index needs backwards index walks, tracked
+ * separately as `feat-reverse-index-walk-for-desc-ordering`.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleMinMaxIndexBoundary(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-minmax-index-boundary.d.ts.map

package/dist/src/planner/rules/aggregate/rule-minmax-index-boundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-minmax-index-boundary.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-minmax-index-boundary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAsC,MAAM,0BAA0B,CAAC;AAC7F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAkB7D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA4D5F"}

package/dist/src/planner/rules/aggregate/rule-minmax-index-boundary.js

@@ -0,0 +1,200 @@
+/**
+ * Rule: answer an ungrouped MIN / MAX from the index boundary.
+ *
+ * `min(c)` over any relation `S` equals `min(c)` over
+ * `(S where c is not null order by c asc limit 1)`; `max(c)` is the same with
+ * `desc`. The identity holds for every `S`, so this is a pure plan-shape change —
+ * never a different answer, only a cheaper one.
+ *
+ * The rewrite builds exactly that shape and hands it to the planner's existing
+ * sort-absorption probe (`trySortAbsorbViaIndexOrdering`). The `AggregateNode`
+ * itself is kept, unchanged, on top:
+ *
+ *   Aggregate [max(c)]                  <- unchanged
+ *     └─ LimitOffset(limit=1)           <- new
+ *          └─ Filter(c is not null)     <- new, only when `c` is nullable
+ *               └─ Retrieve(t)          <- equipped with an ordering access plan
+ *
+ * Keeping the aggregate is what makes the two hard cases free:
+ *
+ *  - Empty relation. An ungrouped aggregate over zero rows still emits exactly one
+ *    row, and min/max finalize an empty accumulator to NULL — so
+ *    `select max(c) from empty_table` keeps returning one NULL row with no special
+ *    casing here.
+ *  - The comparator. This rule never compares values itself. It delegates "does
+ *    index order agree with the argument's semantic order" to the same access-plan
+ *    ordering claim plain `ORDER BY` relies on, and min/max already rank under the
+ *    same semantic comparator ORDER BY uses, so the two agree by construction.
+ *
+ * The probe runs BEFORE anything is committed: if it returns null the rule returns
+ * null and the plan is left byte-identical. No Sort, Filter or Limit is ever
+ * introduced into a plan that cannot serve the ordering.
+ *
+ * Neither shipped backend walks an index backwards (both require the requested
+ * direction to equal the index column's declared direction), so in practice:
+ *
+ *   min(c) + ascending index on c (incl. the primary key) -> boundary read
+ *   max(c) + descending index on c                        -> boundary read
+ *   max(c) + only an ascending index on c                 -> unchanged, full scan
+ *   either + no index                                     -> unchanged, full scan
+ *
+ * Making `max(c)` fast off an ascending index needs backwards index walks, tracked
+ * separately as `feat-reverse-index-walk-for-desc-ordering`.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { AggregateNode } from '../../nodes/aggregate-node.js';
+import { AggregateFunctionCallNode } from '../../nodes/aggregate-function.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { SortNode } from '../../nodes/sort.js';
+import { LimitOffsetNode } from '../../nodes/limit-offset.js';
+import { LiteralNode, UnaryOpNode } from '../../nodes/scalar.js';
+import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
+import { trySortAbsorbViaIndexOrdering } from '../retrieve/rule-grow-retrieve.js';
+const log = createLogger('optimizer:rule:minmax-index-boundary');
+export function ruleMinMaxIndexBoundary(node, context) {
+    if (!(node instanceof AggregateNode))
+        return null;
+    const call = soleUngroupedAggregateCall(node);
+    if (!call)
+        return null;
+    const extremum = classifyExtremum(call, context);
+    if (!extremum)
+        return null;
+    const colRef = boundaryColumn(call);
+    if (!colRef)
+        return null;
+    if (!sourceAcceptsTruncation(node))
+        return null;
+    const scope = node.scope;
+    // NOTE: two different sources of truth decide "can a NULL reach this column" — this
+    // line reads the column reference's own type, while `nullSafeOrderingPrefixLength`
+    // (vtab/best-access-plan.ts) reads `tableSchema.columns[i].notNull`. They agree today
+    // because a bare table column's `columnType` is built from that same schema column,
+    // and the DESC direction fails safe either way (a missing filter makes the ordering
+    // claim be refused, so the rule declines). The ASC direction does NOT fail safe: an
+    // ordering claim over a nullable ASC column is granted unconditionally, so a type that
+    // under-reports nullability would skip this filter and `min(c)` would return NULL.
+    // Revisit if a rewrite ever narrows a ColumnReferenceNode's nullability, or if a
+    // non-table relation becomes reachable through the absorb probe's chain walk.
+    const inner = colRef.getType().nullable
+        ? new FilterNode(scope, node.source, buildIsNotNull(scope, colRef))
+        : node.source;
+    // Probe-then-commit: build a throwaway Sort purely to ask whether the access
+    // path can serve this ordering. `trySortAbsorbViaIndexOrdering` is
+    // side-effect-free, so a null answer costs nothing and leaves the plan alone.
+    const probe = new SortNode(scope, inner, [
+        { expression: colRef, direction: extremum.direction, nulls: undefined },
+    ]);
+    const absorbed = trySortAbsorbViaIndexOrdering(probe, context);
+    if (!absorbed) {
+        log('access path cannot serve %s ordering for %s; leaving the aggregate alone', extremum.direction, colRef.toString());
+        return null;
+    }
+    // NOTE: the `Literal(null)` OFFSET is load-bearing, not cosmetic. `ruleGrowRetrieve`'s
+    // LimitOffset arm (`buildRequest`, rule-grow-retrieve.ts) would otherwise swallow this
+    // node into `Retrieve.source`, where the index-style branch of `ruleSelectAccessPath`
+    // never executes it — the early stop would silently vanish and the scan would run to
+    // completion. That arm refuses every LIMIT whose OFFSET is a non-numeric literal, which
+    // is exactly this shape. Its own comment invites reading a null/absent OFFSET as 0
+    // instead of refusing; if that ever changes, this rewrite needs its own guard, and
+    // test/optimizer/minmax-index-boundary.spec.ts pins the LIMITOFFSET still being present
+    // above the access leaf.
+    const limited = new LimitOffsetNode(scope, absorbed, literal(scope, 1), literal(scope, null));
+    log('rewrote %s(%s) into an index-boundary read', extremum.name, colRef.toString());
+    return node.withChildren([limited, ...node.getChildren().slice(1)]);
+}
+/**
+ * The node's single aggregate call, when it is an ungrouped aggregate carrying
+ * exactly one of them.
+ *
+ * Two aggregates decline: `select min(c), max(c) from t` needs both ends of the
+ * index (out of scope for this rewrite), and `select max(c), count(*) from t` would
+ * be answered WRONG by it — `count(*)` genuinely needs every row, so truncating the
+ * source to one row would return 1.
+ */
+function soleUngroupedAggregateCall(node) {
+    if (node.groupBy.length !== 0)
+        return null;
+    if (node.aggregates.length !== 1)
+        return null;
+    const expr = node.aggregates[0].expression;
+    return expr instanceof AggregateFunctionCallNode ? expr : null;
+}
+/**
+ * Identify the call as the BUILTIN `min`/`max` over one argument.
+ *
+ * The gate is `Database._isBuiltinFunction` — schema identity against the built-in
+ * registration — not a name match and not a comparison against what the name resolves
+ * to now. `addFunction` overwrites by `name/numArgs`, so after
+ * `db.createAggregateFunction('min', …)` the call and `_findFunction('min', 1)` return
+ * the SAME shadow and comparing them proves nothing; the rewrite would then truncate a
+ * user aggregate's source to one row and change its answer. `FILTER (where …)` and an
+ * aggregate-level `ORDER BY` both decline; `DISTINCT` is accepted in either state
+ * because `min(distinct c) = min(c)`.
+ */
+function classifyExtremum(call, context) {
+    if (call.args.length !== 1)
+        return null;
+    if (call.filter)
+        return null;
+    if (call.orderBy && call.orderBy.length > 0)
+        return null;
+    if (!context.db._isBuiltinFunction(call.functionSchema))
+        return null;
+    for (const candidate of [{ name: 'min', direction: 'asc' }, { name: 'max', direction: 'desc' }]) {
+        if (call.functionSchema.name === candidate.name) {
+            return { name: candidate.name, direction: candidate.direction };
+        }
+    }
+    return null;
+}
+/** The aggregated column, when the argument is a bare column reference. */
+function boundaryColumn(call) {
+    const arg = call.args[0];
+    return arg instanceof ColumnReferenceNode ? arg : null;
+}
+/**
+ * Whether it is sound to read only a prefix of the aggregate's source.
+ *
+ * The rewrite truncates how much of the source is read, so a source that writes
+ * must decline. The idempotence guard is belt-and-braces: `applyPassRules` never
+ * re-offers a rule its own output (the applied-rule set is inherited across the
+ * re-mint), so the rule cannot stack LimitOffsets on itself.
+ */
+function sourceAcceptsTruncation(node) {
+    if (node.source instanceof LimitOffsetNode)
+        return false;
+    return !PlanNodeCharacteristics.subtreeHasSideEffects(node.source);
+}
+/**
+ * `<col> IS NOT NULL`, the predicate that does two jobs.
+ *
+ * Correctness first: ORDER BY in this engine places NULLs FIRST for BOTH directions
+ * (`orderByNullResult`, util/comparison.ts), so without this filter `limit 1` would
+ * hand the aggregate a NULL and `max(d)` would return NULL whenever the column has
+ * any NULL at all.
+ *
+ * It also unlocks the descending case: `nullSafeOrderingPrefixLength`
+ * (vtab/best-access-plan.ts) refuses a DESC ordering claim over a column NULLs could
+ * reach unless a NULL-excluding filter is present in the request, and `IS NOT NULL`
+ * is one of its recognized ops.
+ *
+ * NOTE: when the module does NOT consume this as a seek bound, the ordered walk steps
+ * over the whole NULL run before reaching the first real value — bounded by the NULL
+ * count, so at worst an index entry plus a row per NULL (roughly twice a plain scan on
+ * an all-NULL column, free on a column with few NULLs). Worth acting on only if a
+ * mostly-NULL indexed column shows up slower than before this rewrite existed.
+ */
+function buildIsNotNull(scope, colRef) {
+    const ast = {
+        type: 'unary',
+        operator: 'IS NOT NULL',
+        expr: colRef.expression,
+    };
+    return new UnaryOpNode(scope, ast, colRef);
+}
+function literal(scope, value) {
+    return new LiteralNode(scope, { type: 'literal', value });
+}
+//# sourceMappingURL=rule-minmax-index-boundary.js.map

package/dist/src/planner/rules/aggregate/rule-minmax-index-boundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-minmax-index-boundary.js","sourceRoot":"","sources":["../../../../../src/planner/rules/aggregate/rule-minmax-index-boundary.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/rules/cache/rule-nested-loop-right-cache.d.ts

@@ -21,5 +21,34 @@
  */
 import { PlanNode } from '../../nodes/plan-node.js';
 import type { OptContext } from '../../framework/context.js';
+import { JoinNode } from '../../nodes/join-node.js';
+/**
+ * Would this join's right side be wrapped in a `CacheNode` by
+ * {@link ruleNestedLoopRightCache}? The single source of truth for that
+ * question: the rule below calls it and then builds the node, and
+ * `rule-join-physical-selection` calls it to decide whether a plain nested loop
+ * pays its inner side's first-row latency ONCE (cached: one open plus N buffer
+ * replays) or once per outer row (uncached: N re-opens). Neither caller may
+ * restate any of the gates.
+ *
+ * Every gate is a decline; the comments on each explain what it protects.
+ */
+export declare function canCacheNestedLoopRight(node: JoinNode, context: OptContext): boolean;
+/**
+ * Is this join's right side opened ONCE per join rather than once per outer row?
+ * True two ways: it is already materialized (a `CacheNode` from this rule on an
+ * earlier visit, or from the cte / in-subquery / mutating-subquery caches — all
+ * of which scan once and replay a buffer), or {@link canCacheNestedLoopRight}
+ * says this rule is about to make it so.
+ *
+ * `rule-join-physical-selection` asks THIS question, not the cacheability one:
+ * the two differ exactly on an already-cached right side, which
+ * `canCacheNestedLoopRight` declines (nothing left to do) but which pays its
+ * first-row latency once, not per outer row. Pricing that side per outer row
+ * made the selection rule re-visit a join this rule had just improved, re-price
+ * its nested loop as if the cache were not there, and convert it to a hash join
+ * — discarding the cache and landing on the costlier plan.
+ */
+export declare function nestedLoopRightOpensOnce(node: JoinNode, context: OptContext): boolean;
 export declare function ruleNestedLoopRightCache(node: PlanNode, context: OptContext): PlanNode | null;
 //# sourceMappingURL=rule-nested-loop-right-cache.d.ts.map

package/dist/src/planner/rules/cache/rule-nested-loop-right-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-nested-loop-right-cache.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-nested-loop-right-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAuF7D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAqF7F"}
+{"version":3,"file":"rule-nested-loop-right-cache.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-nested-loop-right-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7D,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAqFpD;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CA+DpF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAIrF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA8B7F"}

package/dist/src/planner/rules/cache/rule-nested-loop-right-cache.js

@@ -103,14 +103,18 @@ function estimateRightRows(node) {
     }
     return max;
 }
-export function ruleNestedLoopRightCache(node, context) {
-    // Only logical JoinNodes reach here uncached. By PostOptimization,
-    // join-physical-selection has already converted every equi-join it wanted to
-    // hash/merge (those materialize their build side), so any surviving logical
-    // JoinNode IS a nested loop — the exact structural signal we need.
-    if (!(node instanceof JoinNode)) {
-        return null;
-    }
+/**
+ * Would this join's right side be wrapped in a `CacheNode` by
+ * {@link ruleNestedLoopRightCache}? The single source of truth for that
+ * question: the rule below calls it and then builds the node, and
+ * `rule-join-physical-selection` calls it to decide whether a plain nested loop
+ * pays its inner side's first-row latency ONCE (cached: one open plus N buffer
+ * replays) or once per outer row (uncached: N re-opens). Neither caller may
+ * restate any of the gates.
+ *
+ * Every gate is a decline; the comments on each explain what it protects.
+ */
+export function canCacheNestedLoopRight(node, context) {
     // Driver gate: only the left-driven join types re-scan the right side.
     // `right` / `full` buffer the left side once and scan the right side once
     // (`emitLoopJoin.driveFromRight`), so caching their right side is pure waste.
@@ -124,23 +128,23 @@ export function ruleNestedLoopRightCache(node, context) {
     // (same reopen count until the buffer fills, a win after), just data-dependent
     // rather than the guaranteed replay inner/cross/left get.
     if (node.joinType === 'right' || node.joinType === 'full') {
-        return null;
+        return false;
     }
     const right = node.right;
     // Already cached (e.g. by cte / in-subquery / mutating-subquery cache).
     if (CapabilityDetectors.isCached(right) && right.isCached()) {
-        return null;
+        return false;
     }
     // Purity gate: side effects are the mutating-subquery-cache rule's job.
     // Double-wrapping a write would change nothing and only burn memory.
     if (PlanNodeCharacteristics.subtreeHasSideEffects(right)) {
-        return null;
+        return false;
     }
     // Determinism gate: a non-deterministic right side (e.g. `random()`) must be
     // re-evaluated per left row to preserve today's observable behavior; caching
     // would freeze the first scan's values across every subsequent left row.
     if (!PlanNodeCharacteristics.isDeterministic(right)) {
-        return null;
+        return false;
     }
     // Correlation gate: a right subtree that references left attributes (a
     // parameterized/lateral seek produced by predicate pushdown) is
@@ -149,24 +153,59 @@ export function ruleNestedLoopRightCache(node, context) {
     // separate JoinNode.condition child, not inside the right subtree — so the
     // bare right access has no external refs and is cacheable.
     if (isCorrelatedSubquery(right)) {
-        return null;
+        return false;
     }
     // CTE-safety gate: eagerly materializing a CTE-backed right side breaks the
     // join's row-context at runtime (see subtreeTouchesCte above).
     if (subtreeTouchesCte(right)) {
-        return null;
+        return false;
     }
     // Size gate (memory safety): materializing an unbounded right side trades I/O
     // for memory. Respect the existing nested-loop caching threshold.
     const estimatedRows = estimateRightRows(right) ?? context.tuning.defaultRowEstimate;
     if (estimatedRows > context.tuning.join.maxRightRowsForCaching) {
         log('Right side too large to cache (%d rows > %d), skipping', estimatedRows, context.tuning.join.maxRightRowsForCaching);
+        return false;
+    }
+    return true;
+}
+/**
+ * Is this join's right side opened ONCE per join rather than once per outer row?
+ * True two ways: it is already materialized (a `CacheNode` from this rule on an
+ * earlier visit, or from the cte / in-subquery / mutating-subquery caches — all
+ * of which scan once and replay a buffer), or {@link canCacheNestedLoopRight}
+ * says this rule is about to make it so.
+ *
+ * `rule-join-physical-selection` asks THIS question, not the cacheability one:
+ * the two differ exactly on an already-cached right side, which
+ * `canCacheNestedLoopRight` declines (nothing left to do) but which pays its
+ * first-row latency once, not per outer row. Pricing that side per outer row
+ * made the selection rule re-visit a join this rule had just improved, re-price
+ * its nested loop as if the cache were not there, and convert it to a hash join
+ * — discarding the cache and landing on the costlier plan.
+ */
+export function nestedLoopRightOpensOnce(node, context) {
+    const right = node.right;
+    if (CapabilityDetectors.isCached(right) && right.isCached())
+        return true;
+    return canCacheNestedLoopRight(node, context);
+}
+export function ruleNestedLoopRightCache(node, context) {
+    // Only logical JoinNodes reach here uncached. By PostOptimization,
+    // join-physical-selection has already converted every equi-join it wanted to
+    // hash/merge (those materialize their build side), so any surviving logical
+    // JoinNode IS a nested loop — the exact structural signal we need.
+    if (!(node instanceof JoinNode)) {
+        return null;
+    }
+    if (!canCacheNestedLoopRight(node, context)) {
         return null;
     }
-    log('Caching pure nested-loop right side (%s, %d rows)', node.joinType, estimatedRows);
+    const right = node.right;
+    log('Caching pure nested-loop right side (%s)', node.joinType);
     // Memory strategy + a CacheNode threshold (which degrades to pass-through
     // past its limit) mirrors the sibling mutating-subquery-cache rule. Spill is
-    // unreachable under the size gate above (maxRightRowsForCaching <
+    // unreachable under `canCacheNestedLoopRight`'s size gate (maxRightRowsForCaching <
     // cache.spillThreshold), so 'memory' is the only live choice here.
     const threshold = CachingAnalysis.getCacheThreshold(right);
     const cached = new CacheNode(right.scope, right, 'memory', threshold);

package/dist/src/planner/rules/cache/rule-nested-loop-right-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-nested-loop-right-cache.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-nested-loop-right-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACnH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAE3E,MAAM,GAAG,GAAG,YAAY,CAAC,wCAAwC,CAAC,CAAC;AAEnE;;;;;;;;;;;;;GAaG;AACH,MAAM,cAAc,GAA8B,IAAI,GAAG,CAAC;IACzD,YAAY,CAAC,YAAY;IACzB,YAAY,CAAC,GAAG;IAChB,YAAY,CAAC,YAAY;IACzB,YAAY,CAAC,uBAAuB;CACpC,CAAC,CAAC;AAEH,6EAA6E;AAC7E,SAAS,iBAAiB,CAAC,IAAc;IACxC,MAAM,KAAK,GAAe,CAAC,IAAI,CAAC,CAAC;IACjC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QAC7B,IAAI,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC;YAAE,OAAO,IAAI,CAAC;QACtD,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,SAAS,iBAAiB,CAAC,IAAc;IACxC,IAAI,GAAuB,CAAC;IAC5B,MAAM,QAAQ,GAAG,CAAC,IAAwB,EAAQ,EAAE;QACnD,IAAI,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;YACjD,GAAG,GAAG,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACtD,CAAC;IACF,CAAC,CAAC;IACF,MAAM,KAAK,GAAe,CAAC,IAAI,CAAC,CAAC;IACjC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,OAAO,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QAC7B,QAAQ,CAAC,OAAO,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC1C,IAAI,OAAO,YAAY,eAAe,EAAE,CAAC;YACxC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC;QACpE,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;YAC3C,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC;IACF,CAAC;IACD,OAAO,GAAG,CAAC;AACZ,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,IAAc,EAAE,OAAmB;IAC3E,mEAAmE;IACnE,6EAA6E;IAC7E,4EAA4E;IAC5E,mEAAmE;IACnE,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,uEAAuE;IACvE,0EAA0E;IAC1E,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,8EAA8E;IAC9E,yEAAyE;IACzE,4EAA4E;IAC5E,8EAA8E;IAC9E,yEAAyE;IACzE,+EAA+E;IAC/E,0DAA0D;IAC1D,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,MAAM,EAAE,CAAC;QAC3D,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;IAEzB,wEAAwE;IACxE,IAAI,mBAAmB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;QAC7D,OAAO,IAAI,CAAC;IACb,CAAC;IAED,wEAAwE;IACxE,qEAAqE;IACrE,IAAI,uBAAuB,CAAC,qBAAqB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1D,OAAO,IAAI,CAAC;IACb,CAAC;IAED,6EAA6E;IAC7E,6EAA6E;IAC7E,yEAAyE;IACzE,IAAI,CAAC,uBAAuB,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,uEAAuE;IACvE,gEAAgE;IAChE,uEAAuE;IACvE,wEAAwE;IACxE,2EAA2E;IAC3E,2DAA2D;IAC3D,IAAI,oBAAoB,CAAC,KAAK,CAAC,EAAE,CAAC;QACjC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,4EAA4E;IAC5E,+DAA+D;IAC/D,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,8EAA8E;IAC9E,kEAAkE;IAClE,MAAM,aAAa,GAAG,iBAAiB,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IACpF,IAAI,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAChE,GAAG,CAAC,wDAAwD,EAC3D,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAC5D,OAAO,IAAI,CAAC;IACb,CAAC;IAED,GAAG,CAAC,mDAAmD,EAAE,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;IAEvF,0EAA0E;IAC1E,6EAA6E;IAC7E,kEAAkE;IAClE,mEAAmE;IACnE,MAAM,SAAS,GAAG,eAAe,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC3D,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IAEtE,+EAA+E;IAC/E,+EAA+E;IAC/E,0EAA0E;IAC1E,OAAO,IAAI,CAAC,YAAY,CACvB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAC1E,CAAC;AACH,CAAC"}
+{"version":3,"file":"rule-nested-loop-right-cache.js","sourceRoot":"","sources":["../../../../../src/planner/rules/cache/rule-nested-loop-right-cache.ts"],"names":[],"mappings":"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"}