@quereus/quereus 4.4.1 → 4.6.0

package/dist/src/planner/rules/join/rule-join-physical-selection.js

@@ -3,12 +3,18 @@
  *
  * Required Characteristics:
  * - Node must be a logical JoinNode (not already a physical join)
- * - Node must have an equi-join predicate for hash/merge join consideration
+ * - Node must have an equi-join predicate for hash/merge/index-NL consideration
+ * - Neither side may be correlated (a correlated side must keep the
+ *   nested-loop driver — hash/merge drain a side outside any outer row's scope)
  *
  * Applied When:
- * - Logical JoinNode with equi-join predicates where hash or merge join is cheaper than nested loop
+ * - Logical JoinNode with equi-join predicates where hash join, merge join, or
+ *   an index-nested-loop (per-outer-row seek into the inner side, built by
+ *   `index-nested-loop.ts`) is cheaper than the plain nested loop
  *
- * Benefits: Replaces O(n*m) nested loop with O(n+m) hash/merge join for equi-joins
+ * Benefits: Replaces the O(n*m) nested loop with an O(n+m) hash/merge join, or
+ * with an O(n·seek) index-nested-loop when the inner side's module can answer
+ * an equality seek on the join key
  */
 import { createLogger } from '../../../common/logger.js';
 import { JoinNode } from '../../nodes/join-node.js';
@@ -17,8 +23,11 @@ import { MergeJoinNode } from '../../nodes/merge-join-node.js';
 import { SortNode } from '../../nodes/sort.js';
 import { ColumnReferenceNode } from '../../nodes/reference.js';
 import { nestedLoopJoinCost, hashJoinCost, mergeJoinCost } from '../../cost/index.js';
-import { extractEquiPairs, extractEquiPairsFromUsing, isOrderedOnEquiPairs, reorderEquiPairsForMerge, } from './equi-pair-extractor.js';
+import { extractEquiPairs, isOrderedOnEquiPairs, reorderEquiPairsForMerge, } from './equi-pair-extractor.js';
 import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
+import { isCorrelatedSubquery } from '../../cache/correlation-detector.js';
+import { physicalSourceRows } from '../../util/row-estimates.js';
+import { tryIndexNestedLoop } from './index-nested-loop.js';
 const log = createLogger('optimizer:rule:join-physical-selection');
 /**
  * Create a SortNode that sorts a source on the equi-pair columns for this side.
@@ -40,15 +49,18 @@ function createSortForEquiPairs(source, equiPairs, side, scope) {
     });
     return new SortNode(scope, source, sortKeys);
 }
-export function ruleJoinPhysicalSelection(node, _context) {
+export function ruleJoinPhysicalSelection(node, context) {
     // Guard: only apply to logical JoinNode, not already-physical nodes
     if (!(node instanceof JoinNode))
         return null;
-    // A join exposing `exists … as` match flags stays the nested-loop JoinNode (the
-    // only emitter that derives the flag bit); the physical Bloom/Merge variants do
-    // not carry or emit the appended flag column, so converting would drop it. Read
-    // half: existence joins forgo hash/merge selection — documented limitation.
-    if (node.hasExistenceColumns)
+    // A correlated side must keep the nested-loop driver: hash and merge both
+    // drain a side once, outside any outer row's scope, so a subtree reading
+    // outer columns would resolve against no row (LATERAL is a parsed, supported
+    // join form, so `join lateral (…) on <equality>` reaches this rule with a
+    // correlated right side — converting it to a hash join raised "No row
+    // context found" at runtime). This is also what makes the index-nested-loop
+    // rewrite below idempotent: its own output has a correlated right side.
+    if (isCorrelatedSubquery(node.left) || isCorrelatedSubquery(node.right))
         return null;
     const joinType = node.joinType;
     // Support INNER, LEFT, SEMI, and ANTI joins
@@ -59,24 +71,63 @@ export function ruleJoinPhysicalSelection(node, _context) {
     const rightAttrs = node.right.getAttributes();
     const leftAttrIds = new Set(leftAttrs.map(a => a.id));
     const rightAttrIds = new Set(rightAttrs.map(a => a.id));
-    // Try to extract equi-join pairs from condition (or USING)
-    let extracted = null;
-    if (node.condition) {
-        extracted = extractEquiPairs(node.condition, leftAttrIds, rightAttrIds);
-    }
-    else if (node.usingColumns) {
-        extracted = extractEquiPairsFromUsing(node.usingColumns, leftAttrs, rightAttrs);
-    }
+    // Try to extract equi-join pairs from the condition. A USING join has one too —
+    // `buildUsingCondition` desugars it at build time — so there is no separate path.
+    const extracted = extractEquiPairs(node.condition, leftAttrIds, rightAttrIds);
     if (!extracted || extracted.equiPairs.length === 0)
         return null;
-    // Cost comparison: nested loop vs hash join vs merge join
-    const leftRows = node.left.estimatedRows ?? 100;
-    const rightRows = node.right.estimatedRows ?? 100;
+    // Cost comparison: nested loop vs hash join vs merge join vs index-nested-loop.
+    // Physical relay first: by PostOptimization both sides are physical access
+    // nodes (or wrappers over them) which declare no logical `estimatedRows`
+    // getter — the catalog-derived count lives in `physical.estimatedRows` (see
+    // planner/util/row-estimates.ts). `||` not `??`: 0 is the un-analyzed
+    // "unknown" sentinel, not "empty" (same collapse rule-select-access-path
+    // applies), so an un-analyzed table costs exactly as it did under the old
+    // logical-getter read (which yielded undefined → 100).
+    const leftRows = physicalSourceRows(node.left.physical, node.left) || 100;
+    const rightRows = physicalSourceRows(node.right.physical, node.right) || 100;
     const nlCost = nestedLoopJoinCost(leftRows, rightRows);
+    // Index-nested-loop candidate: the logical JoinNode survives with its right
+    // leaf replaced by a per-outer-row correlated IndexSeek. Considered BEFORE
+    // the existence early-return below — index-NL keeps the nested-loop emitter
+    // (the only one that derives `exists … as` flag bits) and `withChildren`
+    // threads `existence` verbatim, so existence joins CAN take this path,
+    // unlike hash/merge which drop the appended flag column.
+    const indexNL = tryIndexNestedLoop(node, extracted.equiPairs, leftRows, context);
+    // Rebuild with the seek-bearing right side, KEEPING the ON condition on the
+    // join. It is redundant when the seek is exact, but it is the safety net
+    // when the seek over-fetches (a COARSER_SAFE collation cover, a module
+    // returning a superset) — and it costs one predicate evaluation per emitted
+    // row, not per scanned row.
+    const rebuildWithIndexNL = () => {
+        log('Selecting index-nested-loop join (cost=%.2f) for %d outer rows', indexNL.cost, leftRows);
+        return node.withChildren(node.condition
+            ? [node.left, indexNL.newRight, node.condition]
+            : [node.left, indexNL.newRight]);
+    };
+    // A join exposing `exists … as` match flags stays the nested-loop JoinNode (the
+    // only emitter that derives the flag bit); the physical Bloom/Merge variants do
+    // not carry or emit the appended flag column, so converting would drop it. Read
+    // half: existence joins forgo hash/merge selection — documented limitation.
+    // Index-NL remains available (see above): only plain NL and index-NL compete.
+    if (node.hasExistenceColumns) {
+        if (indexNL && indexNL.cost < nlCost)
+            return rebuildWithIndexNL();
+        return null;
+    }
     // Hash join cost: build side is the smaller input
     const buildRows = Math.min(leftRows, rightRows);
     const probeRows = Math.max(leftRows, rightRows);
     const hashCostValue = hashJoinCost(buildRows, probeRows);
+    // Merge join is a candidate only when EVERY pair has matched declared
+    // collations: merge needs both inputs physically ordered under the key's
+    // comparison collation, and the ordering property is collation-blind — a
+    // matched declared collation is what makes each input's advertised order
+    // equal the merge comparator's order (see EquiJoinPair.collationsMatch).
+    // Any mismatched pair ⇒ merge unavailable; hash vs nested-loop compete.
+    // (Merging on just the matched subset would be sound but is deliberately
+    // not attempted — rare shape, minimal-change tradeoff.)
+    const mergeAvailable = extracted.equiPairs.every(p => p.collationsMatch);
     // Merge join cost: depends on whether inputs are already sorted.
     // Try reordering equi-pairs to match the source orderings first.
     let mergeEquiPairs = extracted.equiPairs;
@@ -90,22 +141,38 @@ export function ruleJoinPhysicalSelection(node, _context) {
             rightOrdered = true;
         }
     }
-    const mergeCostValue = mergeJoinCost(leftRows, rightRows, !leftOrdered, !rightOrdered);
+    const mergeCostValue = mergeAvailable
+        ? mergeJoinCost(leftRows, rightRows, !leftOrdered, !rightOrdered)
+        : Infinity;
+    // Hash and merge each scan the inner side once, so the inner subtree's
+    // first-row latency is charged ONCE to each — locally here, not in the
+    // shared cost functions (which other callers use latency-free). Index-NL's
+    // formula charges it per outer row (per seek). Plain nested-loop's formula
+    // is deliberately left alone: it is the no-change fallback, and if it wins
+    // nothing is rewritten.
+    const rightLatencyMs = node.right.physical.expectedLatencyMs ?? 0;
     let bestAlgo = 'nested-loop';
     let bestCost = nlCost;
-    if (hashCostValue < bestCost) {
+    if (hashCostValue + rightLatencyMs < bestCost) {
         bestAlgo = 'hash';
-        bestCost = hashCostValue;
+        bestCost = hashCostValue + rightLatencyMs;
     }
-    if (mergeCostValue < bestCost) {
+    if (mergeCostValue + rightLatencyMs < bestCost) {
         bestAlgo = 'merge';
-        bestCost = mergeCostValue;
+        bestCost = mergeCostValue + rightLatencyMs;
+    }
+    if (indexNL && indexNL.cost < bestCost) {
+        bestAlgo = 'index-nl';
+        bestCost = indexNL.cost;
     }
     if (bestAlgo === 'nested-loop') {
-        log('Nested loop cheapest (nl=%.2f, hash=%.2f, merge=%.2f) for %d x %d rows', nlCost, hashCostValue, mergeCostValue, leftRows, rightRows);
+        log('Nested loop cheapest (nl=%.2f, hash=%.2f, merge=%.2f, indexNL=%.2f) for %d x %d rows', nlCost, hashCostValue, mergeCostValue, indexNL?.cost ?? Infinity, leftRows, rightRows);
         return null;
     }
-    log('Selecting %s join (nl=%.2f, hash=%.2f, merge=%.2f) for %d x %d rows', bestAlgo, nlCost, hashCostValue, mergeCostValue, leftRows, rightRows);
+    if (bestAlgo === 'index-nl') {
+        return rebuildWithIndexNL();
+    }
+    log('Selecting %s join (nl=%.2f, hash=%.2f, merge=%.2f, indexNL=%.2f) for %d x %d rows', bestAlgo, nlCost, hashCostValue, mergeCostValue, indexNL?.cost ?? Infinity, leftRows, rightRows);
     // Preserve attribute IDs from the logical JoinNode
     const preserveAttrs = node.getAttributes().slice();
     if (bestAlgo === 'merge') {
@@ -139,8 +206,9 @@ export function ruleJoinPhysicalSelection(node, _context) {
         // Swap: left becomes build, right becomes probe
         probeSource = node.right;
         buildSource = node.left;
-        // Flip equi-pair directions
+        // Flip equi-pair directions; spread so the collation flags survive.
         equiPairs = extracted.equiPairs.map(p => ({
+            ...p,
             leftAttrId: p.rightAttrId,
             rightAttrId: p.leftAttrId
         }));

package/dist/src/planner/rules/join/rule-join-physical-selection.js.map

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

package/dist/src/planner/rules/join/rule-monotonic-merge-join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-monotonic-merge-join.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-monotonic-merge-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAA6B,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAU7D,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA4F5F"}
+{"version":3,"file":"rule-monotonic-merge-join.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-monotonic-merge-join.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAA6B,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAU7D,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAqG5F"}

package/dist/src/planner/rules/join/rule-monotonic-merge-join.js

@@ -30,7 +30,7 @@ import { JoinNode } from '../../nodes/join-node.js';
 import { MergeJoinNode } from '../../nodes/merge-join-node.js';
 import { nestedLoopJoinCost, hashJoinCost, mergeJoinCost } from '../../cost/index.js';
 import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
-import { extractEquiPairs, extractEquiPairsFromUsing, combineResidual, isMergeReadyOnAllPairs } from './equi-pair-extractor.js';
+import { extractEquiPairs, combineResidual, isMergeReadyOnAllPairs } from './equi-pair-extractor.js';
 const log = createLogger('optimizer:rule:monotonic-merge-join');
 export function ruleMonotonicMergeJoin(node, _context) {
     if (!(node instanceof JoinNode))
@@ -46,9 +46,9 @@ export function ruleMonotonicMergeJoin(node, _context) {
     const rightAttrs = node.right.getAttributes();
     const leftAttrIds = new Set(leftAttrs.map(a => a.id));
     const rightAttrIds = new Set(rightAttrs.map(a => a.id));
-    const extracted = node.condition
-        ? extractEquiPairs(node.condition, leftAttrIds, rightAttrIds)
-        : extractEquiPairsFromUsing(node.usingColumns, leftAttrs, rightAttrs);
+    // A USING join carries a desugared condition (see `buildUsingCondition`), so the
+    // one extractor covers both spellings.
+    const extracted = extractEquiPairs(node.condition, leftAttrIds, rightAttrIds);
     if (!extracted || extracted.equiPairs.length === 0)
         return null;
     // Defer to `rule-join-physical-selection` whenever both sides' physical
@@ -56,7 +56,11 @@ export function ruleMonotonicMergeJoin(node, _context) {
     // ordering-based path produces a multi-key merge join with full
     // unique-key propagation; demoting pairs to residual here would lose that
     // propagation. Our rule is meant to *extend* recognition, not regress it.
-    if (isMergeReadyOnAllPairs(node.left, node.right, extracted.equiPairs))
+    // Defer only when that rule can actually take merge: it requires EVERY
+    // pair `collationsMatch` (see EquiJoinPair.collationsMatch) — with any
+    // mismatched pair it never merges, so there is nothing to defer to.
+    if (extracted.equiPairs.every(p => p.collationsMatch)
+        && isMergeReadyOnAllPairs(node.left, node.right, extracted.equiPairs))
         return null;
     const leftMon = PlanNodeCharacteristics.getMonotonicOn(node.left);
     const rightMon = PlanNodeCharacteristics.getMonotonicOn(node.right);
@@ -65,9 +69,15 @@ export function ruleMonotonicMergeJoin(node, _context) {
     // Find equi-pairs where BOTH sides are MonotonicOn on their respective
     // attrId with matching direction. v1 requires ASC because the merge-join
     // emitter assumes ASC; DESC-DESC streaming would need a reversed compareKeys.
+    // The driving merge key must have matched declared collations: each side's
+    // monotonicOn (like `ordering`) is implicitly under its OWN declared
+    // collation, and the merge comparator resolves the pair's collation — only
+    // a matched pair makes those the same order (see EquiJoinPair.collationsMatch).
     const matchedIndices = [];
     for (let i = 0; i < extracted.equiPairs.length; i++) {
         const pair = extracted.equiPairs[i];
+        if (!pair.collationsMatch)
+            continue;
         const l = leftMon.find(m => m.attrId === pair.leftAttrId && m.direction === 'asc');
         if (!l)
             continue;

package/dist/src/planner/rules/join/rule-monotonic-merge-join.js.map

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

package/dist/src/planner/rules/predicate/rule-empty-relation-folding.d.ts

@@ -27,7 +27,7 @@
  * bounded: rules chain within a single node visit via the per-node fixed-
  * point loop in `applyPassRules`, but the Structural pass itself is one
  * top-down traversal — a parent already visited won't re-fire when an inner
- * Filter folds. See "Cascade limits" in `docs/optimizer-rules.md`.
+ * Filter folds. See "Cascade limits" in `docs/optimizer-rule-families.md`.
  */
 import type { PlanNode } from '../../nodes/plan-node.js';
 import type { OptContext } from '../../framework/context.js';

package/dist/src/planner/rules/predicate/rule-empty-relation-folding.js

@@ -27,7 +27,7 @@
  * bounded: rules chain within a single node visit via the per-node fixed-
  * point loop in `applyPassRules`, but the Structural pass itself is one
  * top-down traversal — a parent already visited won't re-fire when an inner
- * Filter folds. See "Cascade limits" in `docs/optimizer-rules.md`.
+ * Filter folds. See "Cascade limits" in `docs/optimizer-rule-families.md`.
  */
 import { createLogger } from '../../../common/logger.js';
 import { FilterNode } from '../../nodes/filter.js';

package/dist/src/planner/rules/predicate/rule-filter-conjunct-ordering.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Rule: Filter Conjunct Ordering
+ *
+ * Reorders the top-level AND conjuncts of a FilterNode predicate so the
+ * emitter's conjunct early exit (runtime/emit/filter.ts) skips expensive
+ * conjuncts for every row an earlier conjunct already rejects. The sort key is
+ * `compareConjunctRank` (`cost/conjunct-cost.ts`): cost tier first, then —
+ * within a tier — estimated filtering bought per unit work,
+ * `(1 - selectivity) / cost` descending, with plain subtree cost breaking
+ * ratio ties.
+ *
+ * Selectivity comes from the shared per-conjunct estimator
+ * (`stats/conjunct-selectivity.ts`), gated on `statsOnlySelectivity` — real
+ * statistics only, never the NaiveStatsProvider's fabricated per-nodeType
+ * guess, whose numbers differ BY NODE KIND and would reorder conjuncts on no
+ * information at all. When no conjunct gets a real estimate the rule sorts
+ * with `compareConjunctCost` verbatim — an explicit branch, so a query with no
+ * ANALYZE'd statistics orders bit-identically to the cost-only rule.
+ *
+ * Soundness: SQL AND is commutative under three-valued logic, and a Filter
+ * rejects on both `false` and `NULL`, so any permutation of the conjuncts
+ * keeps the row set identical. Reordering changes only evaluation COUNTS,
+ * which is why the rule refuses when any conjunct's subtree carries a side
+ * effect.
+ *
+ * NOTE (tripwire): "row set identical" is a claim about VALUES, not about
+ * thrown errors. A conjunct written after a guard (`v <> 0 and 10 / v > 1`)
+ * may run on rows the guard would have rejected once it sorts ahead of the
+ * guard. Harmless today — every arithmetic edge quereus defines returns NULL
+ * rather than throwing (division by zero included, pinned in
+ * test/logic/07.7.4-where-conjunct-ordering.sqllogic), and a cheap guard
+ * already sorts first. It only becomes real if a scalar function that THROWS
+ * on bad input ships and a query guards it with a conjunct in a more expensive
+ * tier (e.g. `exists (...) and parse(x) > 0`). Selectivity adds a SECOND route
+ * past a guard: a statistics-strong conjunct can now sort ahead of a cheaper
+ * same-tier guard even where cost alone would have kept the guard first. At
+ * that point either gate the reorder on a per-function "may raise" trait or
+ * tell users to guard with CASE, as PostgreSQL does.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleFilterConjunctOrdering(node: PlanNode, context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-filter-conjunct-ordering.d.ts.map

package/dist/src/planner/rules/predicate/rule-filter-conjunct-ordering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-filter-conjunct-ordering.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-filter-conjunct-ordering.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAc7D,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA8C/F"}

package/dist/src/planner/rules/predicate/rule-filter-conjunct-ordering.js

@@ -0,0 +1,119 @@
+/**
+ * Rule: Filter Conjunct Ordering
+ *
+ * Reorders the top-level AND conjuncts of a FilterNode predicate so the
+ * emitter's conjunct early exit (runtime/emit/filter.ts) skips expensive
+ * conjuncts for every row an earlier conjunct already rejects. The sort key is
+ * `compareConjunctRank` (`cost/conjunct-cost.ts`): cost tier first, then —
+ * within a tier — estimated filtering bought per unit work,
+ * `(1 - selectivity) / cost` descending, with plain subtree cost breaking
+ * ratio ties.
+ *
+ * Selectivity comes from the shared per-conjunct estimator
+ * (`stats/conjunct-selectivity.ts`), gated on `statsOnlySelectivity` — real
+ * statistics only, never the NaiveStatsProvider's fabricated per-nodeType
+ * guess, whose numbers differ BY NODE KIND and would reorder conjuncts on no
+ * information at all. When no conjunct gets a real estimate the rule sorts
+ * with `compareConjunctCost` verbatim — an explicit branch, so a query with no
+ * ANALYZE'd statistics orders bit-identically to the cost-only rule.
+ *
+ * Soundness: SQL AND is commutative under three-valued logic, and a Filter
+ * rejects on both `false` and `NULL`, so any permutation of the conjuncts
+ * keeps the row set identical. Reordering changes only evaluation COUNTS,
+ * which is why the rule refuses when any conjunct's subtree carries a side
+ * effect.
+ *
+ * NOTE (tripwire): "row set identical" is a claim about VALUES, not about
+ * thrown errors. A conjunct written after a guard (`v <> 0 and 10 / v > 1`)
+ * may run on rows the guard would have rejected once it sorts ahead of the
+ * guard. Harmless today — every arithmetic edge quereus defines returns NULL
+ * rather than throwing (division by zero included, pinned in
+ * test/logic/07.7.4-where-conjunct-ordering.sqllogic), and a cheap guard
+ * already sorts first. It only becomes real if a scalar function that THROWS
+ * on bad input ships and a query guards it with a conjunct in a more expensive
+ * tier (e.g. `exists (...) and parse(x) > 0`). Selectivity adds a SECOND route
+ * past a guard: a statistics-strong conjunct can now sort ahead of a cheaper
+ * same-tier guard even where cost alone would have kept the guard first. At
+ * that point either gate the reorder on a per-function "may raise" trait or
+ * tell users to guard with CASE, as PostgreSQL does.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
+import { splitConjuncts, combineConjuncts } from '../../analysis/predicate-conjuncts.js';
+import { classifyConjunctCost, compareConjunctCost, compareConjunctRank, UNKNOWN_CONJUNCT_SELECTIVITY, } from '../../cost/conjunct-cost.js';
+import { collectColumnOrigins } from '../../util/column-origins.js';
+import { estimateConjunctSelectivity } from '../../stats/conjunct-selectivity.js';
+const log = createLogger('optimizer:rule:filter-conjunct-ordering');
+export function ruleFilterConjunctOrdering(node, context) {
+    if (node.nodeType !== PlanNodeType.Filter)
+        return null;
+    const filter = node;
+    const conjuncts = splitConjuncts(filter.predicate);
+    if (conjuncts.length < 2)
+        return null;
+    // Predicates are pure today, but reordering under early exit changes how
+    // often each conjunct runs — refuse outright when any conjunct carries a
+    // side effect. This guard is what makes sideEffectMode 'safe' honest.
+    if (conjuncts.some(c => PlanNodeCharacteristics.subtreeHasSideEffects(c)))
+        return null;
+    const costs = conjuncts.map(classifyConjunctCost);
+    const selectivities = estimateSelectivities(filter, conjuncts, context);
+    // Array.prototype.sort is stable, so equal-key conjuncts keep source order —
+    // the determinism requirement.
+    let sorted;
+    if (selectivities === undefined) {
+        // No conjunct got a real estimate (or the provider has none to give):
+        // sort with the cost-only comparator verbatim, so the order is
+        // bit-identical to the pre-selectivity rule.
+        const ranked = conjuncts.map((conjunct, i) => ({ conjunct, cost: costs[i] }));
+        sorted = [...ranked].sort((a, b) => compareConjunctCost(a.cost, b.cost));
+    }
+    else {
+        const ranked = conjuncts.map((conjunct, i) => ({
+            conjunct,
+            cost: { ...costs[i], selectivity: selectivities[i] ?? UNKNOWN_CONJUNCT_SELECTIVITY },
+        }));
+        sorted = [...ranked].sort((a, b) => compareConjunctRank(a.cost, b.cost));
+    }
+    // Already ordered → null. This is not an optimization: it is the fixed point
+    // that stops the rewrite loop (an unconditional rebuild would flip conjunct
+    // order forever). The key depends only on the node and on `context.stats`,
+    // which is stable within one optimize(), so the sort is idempotent.
+    if (sorted.every((entry, i) => entry.conjunct === conjuncts[i]))
+        return null;
+    // length >= 2, so combineConjuncts cannot return null.
+    const reordered = combineConjuncts(sorted.map(entry => entry.conjunct));
+    log(`Reordered ${conjuncts.length} conjuncts (${selectivities === undefined ? 'cost only' : 'cost + selectivity'})`);
+    // Construct directly rather than via withPredicate (which drops selectivity
+    // on any predicate change): reordering does not change the conjunct SET, so
+    // the estimate stamped by rule-filter-selectivity remains exactly as valid.
+    return new FilterNode(filter.scope, filter.source, reordered, undefined, filter.selectivity);
+}
+/**
+ * Per-conjunct selectivities aligned with `conjuncts`, or undefined when the
+ * whole filter must fall back to cost-only ordering: the provider implements no
+ * `statsOnlySelectivity`, the source exposes no base-column origins (HAVING over
+ * an aggregate, a set operation, a `values` clause, …), or no conjunct could be
+ * estimated. The provider check comes first so the origins walk — a full pass
+ * over the source subtree — is skipped outright for a provider that omits the
+ * method.
+ *
+ * NOTE (tripwire): that short-circuit does NOT help the production
+ * `CatalogStatsProvider`, which always implements `statsOnlySelectivity`. A
+ * database with nothing ANALYZEd therefore still pays one origins walk per
+ * multi-conjunct Filter here, on top of the one `rule-filter-selectivity`
+ * already pays. Unmeasured; if it ever profiles hot, memoize the map per pass on
+ * OptContext keyed by the source node — the fix noted at that rule.
+ */
+function estimateSelectivities(filter, conjuncts, context) {
+    if (context.stats.statsOnlySelectivity == null)
+        return undefined;
+    const origins = collectColumnOrigins(filter.source);
+    if (origins.size === 0)
+        return undefined;
+    const estimates = conjuncts.map(c => estimateConjunctSelectivity(c, origins, context));
+    return estimates.some(e => e !== undefined) ? estimates : undefined;
+}
+//# sourceMappingURL=rule-filter-conjunct-ordering.js.map

package/dist/src/planner/rules/predicate/rule-filter-conjunct-ordering.js.map

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

package/dist/src/planner/rules/predicate/rule-filter-selectivity.d.ts

@@ -4,14 +4,55 @@
  * Stamps a stats-derived selectivity onto a FilterNode so its `estimatedRows`
  * reflects real column statistics instead of the flat DEFAULT_FILTER_SELECTIVITY.
  *
- * Runs in the Physical pass (bottom-up), which fires AFTER the Structural pass —
- * predicate-pushdown / grow-retrieve have already put the Filter in its final
- * position over its final source, so `extractTableSchema` sees the settled tree.
+ * Registered TWICE, both bottom-up:
+ *
+ *   - `filter-selectivity` (Physical pass), which fires AFTER the Structural pass —
+ *     predicate-pushdown / grow-retrieve have already put the Filter in its final
+ *     position over its final source, so the source subtree is settled (and may carry
+ *     physical access nodes between the join and its table references). This stamp is
+ *     what the physical and PostOptimization cost readers consult.
+ *   - `filter-selectivity-restamp` (PostOptimization pass, registered first in that
+ *     pass), which recovers the estimate for a Filter whose stamp was dropped by
+ *     `FilterNode.withChildren` because PostOptimization rewrote something inside its
+ *     predicate — `scalar-subquery-cache` wrapping an uncorrelated scalar subquery's
+ *     inner re-mints every scalar ancestor up to the predicate. Without it, any query
+ *     with a subquery in its `where` plans on the flat DEFAULT_FILTER_SELECTIVITY.
+ *
+ * The `selectivity !== undefined` guard below makes the second registration a no-op on
+ * every Filter whose stamp survived, so it only ever fills in, never overwrites. Both
+ * firings read a physical source subtree (`select-access-path` has already replaced
+ * Retrieve with an access node by the Physical pass's own bottom-up order);
+ * PostOptimization sources are the same shape or further lowered.
  *
  * Node-level accessors (`estimatedRows` / `computePhysical`) carry no OptContext,
  * so a Filter cannot consult `context.stats` from inside itself. This rule holds
  * the context, does the lookup, and mints a stamped Filter — the estimate then
  * flows through `estimatedRows` automatically.
+ *
+ * Two paths:
+ *   - **single-table** — `extractRowSourceTableSchema` finds one base table under
+ *     the Filter *whose rows are the ones arriving at it*; hand the whole predicate
+ *     to the provider, which decomposes its boolean structure itself.
+ *   - **multi-relation** — the source spans several tables (a join), or the strict
+ *     walk declined. Split the predicate into conjuncts, attribute each to the base
+ *     table(s) its columns come from, estimate per conjunct, and combine.
+ *
+ * The strict walk matters because an aggregate's output rows are a different
+ * population from its source's, so no fraction of the base table describes them at
+ * all: over `select cat, count(*) as ct from o group by cat having ct > 2` the
+ * permissive `extractTableSchema` reaches `o` through the aggregate, but `o`'s row
+ * count and column distributions say nothing about how many GROUPS survive `ct > 2`.
+ *
+ * Both paths hand the provider a {@link ColumnStatsResolver} built from
+ * `collectColumnOrigins`, so a column in the predicate is matched to statistics by
+ * ATTRIBUTE IDENTITY rather than by the name in its AST. `ProjectNode` forwards the
+ * source attribute id for a bare column reference and mints a fresh one for a
+ * computed expression, which is exactly the distinction wanted: `select cat as qty`
+ * still reads `o.cat`'s statistics, while `select id * 7 as qty` reads none rather
+ * than borrowing `o.qty`'s because the alias happens to collide. A CTE reference
+ * republishes its body's columns under per-reference relation instances, so a `with`
+ * clause estimates like the equivalent subquery while the two arms of a CTE self-join
+ * still count as two relations — see `column-origins.ts`.
  */
 import type { PlanNode } from '../../nodes/plan-node.js';
 import type { OptContext } from '../../framework/context.js';

package/dist/src/planner/rules/predicate/rule-filter-selectivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-filter-selectivity.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-filter-selectivity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM7D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA6B1F"}
+{"version":3,"file":"rule-filter-selectivity.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-filter-selectivity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAW7D,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAwC1F"}