@quereus/quereus 4.5.0 → 4.7.0

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

@@ -4,10 +4,39 @@
  * 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 the source subtree is settled (and may carry
- * physical access nodes between the join and its table references).
+ * Registered THREE times, all bottom-up. Only the first derives an estimate the plan
+ * did not have; the other two recover one that a later pass dropped, because
+ * `FilterNode.withChildren` carries `selectivity` forward only when the predicate
+ * child is the same object, and several passes rewrite inside a predicate:
+ *
+ *   - `filter-selectivity` (Physical pass), the primary stamp. 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 so it precedes `filter-conjunct-ordering`, which copies the stamp forward).
+ *     Recovers the estimate for a Filter whose predicate PostOptimization itself
+ *     rewrote — `scalar-subquery-cache` wrapping an uncorrelated scalar subquery's
+ *     inner re-mints every scalar ancestor up to the predicate. It has to run inside
+ *     that pass, not merely after it, because the cost readers later in the pass
+ *     (join-physical-selection, key-set-seek, the materialization advisory) consult
+ *     the stamp.
+ *   - `filter-selectivity-final` (FinalEstimates pass, order 37), the backstop behind
+ *     every plan-mutating pass. Recovers the estimate for a Filter re-minted by the
+ *     Materialization advisory (order 35) — which rebuilds every path on which it
+ *     marks a `with` clause for shared materialization or injects a `CacheNode` — and
+ *     for any future pass ordered before it. Its stamp is read only at emission, so
+ *     it cannot substitute for the PostOptimization registration.
+ *
+ * The `selectivity !== undefined` guard below makes the second and third registrations
+ * a no-op on every Filter whose stamp survived, so they only ever fill in, never
+ * overwrite. All three 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); later sources are the same shape or further lowered — a `CacheNode` the
+ * advisory newly slid under the Filter is a generic single-relation wrapper that both
+ * `extractRowSourceTableSchema` and `collectColumnOrigins` descend, so the re-derived
+ * number matches what the Physical pass produced.
  *
  * Node-level accessors (`estimatedRows` / `computePhysical`) carry no OptContext,
  * so a Filter cannot consult `context.stats` from inside itself. This rule holds
@@ -15,29 +44,38 @@
  * flows through `estimatedRows` automatically.
  *
  * Two paths:
- *   - **single-table** — `extractTableSchema` finds one base table under the
- *     Filter; hand the whole predicate to the provider, which decomposes its
- *     boolean structure itself.
- *   - **multi-relation** — the source spans several tables (a join). Split the
- *     predicate into conjuncts, attribute each to the base table(s) its columns
- *     come from, estimate per conjunct, and combine.
+ *   - **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 { createLogger } from '../../../common/logger.js';
 import { FilterNode } from '../../nodes/filter.js';
-import { BinaryOpNode } from '../../nodes/scalar.js';
-import { ColumnReferenceNode } from '../../nodes/reference.js';
-import { extractTableSchema } from '../../util/key-utils.js';
+import { extractRowSourceTableSchema } from '../../util/key-utils.js';
 import { collectColumnOrigins } from '../../util/column-origins.js';
 import { splitConjuncts } from '../../analysis/predicate-conjuncts.js';
 import { combineConjunctive } from '../../stats/selectivity-combine.js';
+import { estimateConjunctSelectivity, makeColumnStatsResolver } from '../../stats/conjunct-selectivity.js';
 const log = createLogger('optimizer:rule:filter-selectivity');
-/**
- * Selectivity of an inequality (`<` `<=` `>` `>=`) comparing a column of one table
- * to a column of another. The standard uniform-distribution estimate for a
- * two-sided inequality is 1/3: there is no cross-table histogram, so nothing
- * better than the uniform assumption is available here.
- */
-export const CROSS_RELATION_INEQUALITY_SELECTIVITY = 1 / 3;
 export function ruleFilterSelectivity(node, context) {
     const filter = node;
     // Idempotent: a prior fire already stamped this Filter → decline. (The pass
@@ -45,13 +83,34 @@ export function ruleFilterSelectivity(node, context) {
     // makes the rule safe on any already-stamped node regardless.)
     if (filter.selectivity !== undefined)
         return null;
-    // extractTableSchema walks single-child wrappers (Filter/Project/Sort/Retrieve/
-    // TableReference) to the base table. It returns undefined for a join / other
-    // multi-relation source, which is what the second path handles.
-    const tableSchema = extractTableSchema(filter.source);
+    // extractRowSourceTableSchema walks single-child wrappers (Filter/Project/Sort/
+    // Retrieve/TableReference) to the base table, but stops at any operator whose
+    // output rows are not its source's rows (aggregate, recursive CTE, set operation).
+    // It returns undefined for those and for a join / other multi-relation source,
+    // which is what the second path handles.
+    const tableSchema = extractRowSourceTableSchema(filter.source);
+    // Attribute id → base-table column, for every base column under the Filter. Both
+    // paths need it: the multi-relation path to route a conjunct to a relation, and
+    // both paths to identify a predicate's columns by identity rather than by name.
+    //
+    // NOTE: this walk covers the whole source subtree and this rule fires per
+    // FilterNode, so a stack of N filters over one large subtree costs O(N·subtree) —
+    // and unlike before, it now runs for EVERY Filter, not only filters over joins.
+    // `rule-filter-conjunct-ordering` (PostOptimization) runs the SAME walk again on
+    // each Filter it ranks, so the walk now happens twice per Filter. A Filter that is
+    // permanently unstampable (computed projection, set-operation output, un-analyzed
+    // table) also pays it a third and fourth time, because neither the
+    // `filter-selectivity-restamp` nor the `filter-selectivity-final` registration can
+    // short-circuit on a stamp that will never exist — measured only as "extra walks",
+    // not profiled. The walk is
+    // cheap per node and filter stacks are shallow; if it ever shows up in an
+    // optimizer profile, memoize the map per pass on OptContext keyed by the source
+    // node (or — for the single-table path only — build the resolver from the one
+    // TableReferenceNode the strict walk already found, O(columns) not O(subtree)).
+    const origins = collectColumnOrigins(filter.source);
     const sel = tableSchema
-        ? singleTableSelectivity(tableSchema, filter, context)
-        : multiRelationSelectivity(filter, context);
+        ? singleTableSelectivity(tableSchema, filter, origins, context)
+        : multiRelationSelectivity(filter, origins, context);
     if (sel === undefined)
         return null;
     const clamped = Math.min(1, Math.max(0, sel));
@@ -60,7 +119,7 @@ export function ruleFilterSelectivity(node, context) {
     return new FilterNode(filter.scope, filter.source, filter.predicate, undefined, clamped);
 }
 // ── Single-table path ───────────────────────────────────────────────────
-function singleTableSelectivity(tableSchema, filter, context) {
+function singleTableSelectivity(tableSchema, filter, origins, context) {
     // CatalogStatsProvider recurses over the predicate's boolean structure, so
     // `a = 1 and b = 2` combines the two per-column estimates rather than falling
     // back to a flat per-nodeType guess. It still returns undefined when it can say
@@ -69,7 +128,12 @@ function singleTableSelectivity(tableSchema, filter, context) {
     // NOTE: this path is deliberately NOT gated on real statistics existing — it may
     // still stamp a NaiveStatsProvider number, as it always has. The multi-relation
     // path below IS gated; see the comment there for why the asymmetry is on purpose.
-    const sel = context.stats.selectivity(tableSchema, filter.predicate);
+    //
+    // Schema equality is the right narrowing here: the strict walk established that
+    // exactly this table's rows arrive at the Filter, so any origin under it belongs
+    // to that one reference anyway.
+    const resolve = makeColumnStatsResolver(origins, origin => origin.table === tableSchema);
+    const sel = context.stats.selectivity(tableSchema, filter.predicate, resolve);
     if (sel === undefined)
         return undefined;
     log('Filter over %s: stamping selectivity %f', tableSchema.name, sel);
@@ -91,26 +155,20 @@ function singleTableSelectivity(tableSchema, filter, context) {
  * the base-table fraction is applied to post-aggregate cardinality. Imprecise but
  * not unsound; deliberately not special-cased.
  *
- * NOTE: the stamped number is currently visible on `FilterNode.selectivity` but does
- * NOT yet move `estimatedRows` above a join: `JoinNode.computePhysical` derives its
- * own cardinality from its children's LOGICAL `estimatedRows`, and a physical access
- * node (SeqScan/IndexScan over a Retrieve) exposes none — so the join reports
- * undefined rows and the Filter has nothing to multiply. Tracked in backlog
- * `debt-join-rows-from-physical-children`; nothing here needs to change when it lands.
- *
- * NOTE: `collectColumnOrigins` walks the whole source subtree and this rule fires
- * per FilterNode, so a stack of N filters over one large subtree costs O(N·subtree).
- * Filters over joins are few and the walk is cheap per node; if this ever shows up
- * in optimizer profiles, compute the map once per pass and cache it on OptContext.
+ * NOTE: the stamped number does move `estimatedRows` above a join — the join family
+ * derives its physical cardinality from its children's PHYSICAL counts
+ * (`physicalSourceRows` / `joinPhysicalRows`), so a Filter over a join has a real
+ * number to multiply. It still has nothing to multiply above a `union`/`union all`,
+ * where `SetOperationNode` stamps no count at all (backlog
+ * `debt-row-estimates-die-at-set-operations`).
  */
-function multiRelationSelectivity(filter, context) {
-    const origins = collectColumnOrigins(filter.source);
+function multiRelationSelectivity(filter, origins, context) {
     if (origins.size === 0)
         return undefined;
     const conjuncts = splitConjuncts(filter.predicate);
     const known = [];
     for (const conjunct of conjuncts) {
-        const sel = estimateConjunct(conjunct, origins, context);
+        const sel = estimateConjunctSelectivity(conjunct, origins, context);
         if (sel !== undefined)
             known.push(sel);
     }
@@ -125,118 +183,9 @@ function multiRelationSelectivity(filter, context) {
     return combined;
 }
 function countRelations(origins) {
-    const refs = new Set();
+    const relations = new Set();
     for (const origin of origins.values())
-        refs.add(origin.ref);
-    return refs.size;
-}
-/** Estimate one conjunct, or undefined when it cannot be attributed / estimated. */
-function estimateConjunct(conjunct, origins, context) {
-    const refs = conjunctRelations(conjunct, origins);
-    if (refs === undefined)
-        return undefined;
-    if (refs.size === 1) {
-        const [ref] = refs;
-        return singleRelationConjunct(ref.tableSchema, conjunct, context);
-    }
-    if (refs.size === 2) {
-        return crossRelationConjunct(conjunct, origins, context);
-    }
-    // Three or more relations in one conjunct: no model for it here.
-    return undefined;
-}
-/**
- * The distinct relations a conjunct's column references come from.
- *
- * Returns undefined when the conjunct references no column at all, or references
- * any attribute that is not a base-table column (a computed projection, an
- * aggregate output, a join existence flag, a set-operation output, a column of a
- * table inside a scalar subquery) — in either case there are no statistics to
- * consult.
- */
-function conjunctRelations(conjunct, origins) {
-    const refs = new Set();
-    const stack = [conjunct];
-    while (stack.length > 0) {
-        const n = stack.pop();
-        if (n instanceof ColumnReferenceNode) {
-            const origin = origins.get(n.attributeId);
-            if (!origin)
-                return undefined;
-            refs.add(origin.ref);
-            continue;
-        }
-        for (const child of n.getChildren())
-            stack.push(child);
-    }
-    return refs.size > 0 ? refs : undefined;
-}
-/**
- * A conjunct over exactly one relation: hand it to the provider as if it were a
- * single-table predicate.
- *
- * `statsOnlySelectivity` — not `selectivity` — IS the statistics gate. `selectivity`
- * always returns a number (CatalogStatsProvider falls through to NaiveStatsProvider,
- * which answers a flat 0.1 for any BinaryOp), so using it here would replace 0.5 with
- * 0.1 on essentially every filter-over-join in the codebase — including the many tests
- * that never run ANALYZE — churning plan shapes with no information behind the change.
- * It also covers the subtler case of an analyzed table with a predicate the catalog
- * cannot read (`lower(o.cat) = 'x'`), which a column-stats-presence check would let
- * through. A provider that does not implement it is treated as having no statistics.
- */
-function singleRelationConjunct(table, conjunct, context) {
-    return context.stats.statsOnlySelectivity?.(table, conjunct);
-}
-function hasColumnStats(origin) {
-    return origin.table.statistics?.columnStats.has(origin.columnName.toLowerCase()) ?? false;
-}
-/**
- * A conjunct comparing a column of one relation to a column of another
- * (`o.qty > l.qty`, `a.id = b.id`). Only a plain binary comparison with a bare
- * column reference on each side is modelled; anything else is unknown.
- *
- * Gated on real column statistics for BOTH compared columns, for the same reason as
- * {@link singleRelationConjunct}: `joinSelectivity` falls back to
- * `NaiveStatsProvider`'s `1/max(rowCount)` whenever it cannot read a distinct count,
- * so table-level `statistics` being present is not enough on its own.
- */
-function crossRelationConjunct(conjunct, origins, context) {
-    if (!(conjunct instanceof BinaryOpNode))
-        return undefined;
-    if (!(conjunct.left instanceof ColumnReferenceNode))
-        return undefined;
-    if (!(conjunct.right instanceof ColumnReferenceNode))
-        return undefined;
-    const leftOrigin = origins.get(conjunct.left.attributeId);
-    const rightOrigin = origins.get(conjunct.right.attributeId);
-    if (!leftOrigin || !rightOrigin)
-        return undefined;
-    if (!hasColumnStats(leftOrigin) || !hasColumnStats(rightOrigin))
-        return undefined;
-    const op = conjunct.expression.operator;
-    if (op === '=' || op === '==')
-        return equiJoinSelectivity(conjunct, leftOrigin, rightOrigin, context);
-    // `extractEquiJoinColumns` accepts only `=`, so the catalog declines a `<>` and
-    // `joinSelectivity` answers from NaiveStatsProvider, which is capped at 0.5. The
-    // complement is therefore bounded to [0.5, 1] — it can only ever relax the
-    // estimate relative to DEFAULT_FILTER_SELECTIVITY, and the true value for a
-    // cross-relation `<>` is near 1, so the bound errs in the right direction.
-    if (op === '!=' || op === '<>') {
-        const eq = equiJoinSelectivity(conjunct, leftOrigin, rightOrigin, context);
-        return eq === undefined ? undefined : 1 - eq;
-    }
-    if (op === '<' || op === '<=' || op === '>' || op === '>=') {
-        return CROSS_RELATION_INEQUALITY_SELECTIVITY;
-    }
-    return undefined;
-}
-/**
- * Argument order matters: `CatalogStatsProvider.joinSelectivity` reads the column
- * pair off the condition's own child order (`extractEquiJoinColumns`) and
- * `fkPkSelectivity` interprets left/right against the tables it was handed. So the
- * table owning the conjunct's LEFT child must be passed first.
- */
-function equiJoinSelectivity(conjunct, leftOrigin, rightOrigin, context) {
-    return context.stats.joinSelectivity?.(leftOrigin.table, rightOrigin.table, conjunct);
+        relations.add(origin.relation);
+    return relations.size;
 }
 //# sourceMappingURL=rule-filter-selectivity.js.map

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

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

package/dist/src/planner/rules/predicate/rule-join-predicate-pushdown.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Rule: Join Predicate Pushdown
+ *
+ * For a `FilterNode(predicate, JoinNode)`, each conjunct of `predicate` whose
+ * column references all land on ONE side of the join is MOVED onto that side's
+ * branch (wrapped as a `FilterNode` around `join.left` / `join.right`).
+ * Cross-side conjuncts, and anything the refusals below reject, stay in a
+ * residual Filter above the rebuilt join.
+ *
+ * Why this is sound — the null-extension argument. A side may receive a
+ * conjunct exactly when that side's columns are NEVER null-extended in the
+ * join's output (read straight off `buildJoinAttributes` in
+ * `nodes/join-utils.ts`). For such a side, every output row carries that side's
+ * genuine input values, so rejecting an input row before the join removes
+ * precisely the output rows the conjunct would have removed after it. On a
+ * null-extended side the two differ: `left join r … where r.date > 'x'` drops
+ * the NULL-padded rows after the join, but pushing `r.date > 'x'` below would
+ * KEEP them (the left row simply finds no match and is padded again).
+ *
+ * | joinType | null-extended side | conjuncts pushable to |
+ * |----------|--------------------|-----------------------|
+ * | `inner`  | neither            | left and right        |
+ * | `cross`  | neither            | left and right        |
+ * | `left`   | right              | left only             |
+ * | `right`  | left               | right only            |
+ * | `full`   | both               | neither — rule declines |
+ * | `semi`   | n/a (output is left columns) | left only   |
+ * | `anti`   | n/a (output is left columns) | left only   |
+ *
+ * For `semi`/`anti` the left-only restriction is moot in practice —
+ * `buildJoinAttributes` returns only the left attributes, so a Filter above such
+ * a join cannot reference a right column at all — but it is encoded anyway so
+ * the table is exhaustive and the reasoning stays local.
+ *
+ * Attribution is a plain attribute-id set test: ids are minted per node instance
+ * and are stable across this pass's rewrites, so a self-join's two branches
+ * carry distinct ids, and a join's `exists … as` flag ids are in neither side's
+ * set (a conjunct over a flag falls out as un-pushable with no special case).
+ *
+ * Refusals:
+ * - A conjunct whose subtree references a RELATIONAL child (any subquery) is
+ *   left above. The id collector descends through relational children too, so
+ *   `exists (select 1 from x where x.a = e.id and x.b = t.id)` contributes `x`'s
+ *   own ids — which belong to neither side — and the conjunct is declined. That
+ *   descent is load-bearing: a scalar-only walk would see only `e.id` and push a
+ *   conjunct onto the left branch where `t.id` does not resolve.
+ * - Symmetrically, a conjunct naming a column from OUTSIDE the join — an outer
+ *   reference, when this `Filter(Join)` is itself the body of a correlated
+ *   subquery — sees an id in neither side's set and is declined.
+ *   NOTE: sound but pessimistic — `x.a = <outer>.b` would be safe on the `x`
+ *   branch. Ignoring "in neither side" ids instead of refusing on them would
+ *   recover that. {@link collectSubtreeAttributeIds} does not distinguish a
+ *   genuinely-outer id from a subquery-internal one, but
+ *   `analysis/predicate-dependencies.ts` does — its `correlated` set is exactly
+ *   the outer ids, and swapping this walk for it is the whole change. Left alone
+ *   until a real correlated body is measured losing a seek to it; the swap also
+ *   makes more conjuncts pushable, which needs its own plan-shape coverage.
+ * - A conjunct with NO column references (`where 1 = 1`, `where :p > 0`) stays
+ *   above; pushing it buys nothing and would make the rule fire on plans it
+ *   should leave alone.
+ * - A non-functional conjunct (`random() < e.amount`) stays above — moving it
+ *   below the join changes how many times it is evaluated.
+ * - A branch whose subtree carries a write keeps ITS conjuncts above while the
+ *   other branch still receives its own (per-branch refusal, unlike
+ *   `rule-predicate-inference-equivalence`'s outright one).
+ *
+ * A pushed conjunct is MOVED, not copied. A redundant copy above would
+ * re-evaluate per output row for no gain and, worse, make the rule
+ * non-idempotent — it would find the same pushable conjunct on every visit.
+ * With a move, a re-visit of the residual Filter finds nothing pushable and
+ * returns null, which is the termination argument.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleJoinPredicatePushdown(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-join-predicate-pushdown.d.ts.map

package/dist/src/planner/rules/predicate/rule-join-predicate-pushdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-join-predicate-pushdown.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-join-predicate-pushdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAsC,MAAM,0BAA0B,CAAC;AAC7F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAyE7D,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA0E/F"}

package/dist/src/planner/rules/predicate/rule-join-predicate-pushdown.js

@@ -0,0 +1,208 @@
+/**
+ * Rule: Join Predicate Pushdown
+ *
+ * For a `FilterNode(predicate, JoinNode)`, each conjunct of `predicate` whose
+ * column references all land on ONE side of the join is MOVED onto that side's
+ * branch (wrapped as a `FilterNode` around `join.left` / `join.right`).
+ * Cross-side conjuncts, and anything the refusals below reject, stay in a
+ * residual Filter above the rebuilt join.
+ *
+ * Why this is sound — the null-extension argument. A side may receive a
+ * conjunct exactly when that side's columns are NEVER null-extended in the
+ * join's output (read straight off `buildJoinAttributes` in
+ * `nodes/join-utils.ts`). For such a side, every output row carries that side's
+ * genuine input values, so rejecting an input row before the join removes
+ * precisely the output rows the conjunct would have removed after it. On a
+ * null-extended side the two differ: `left join r … where r.date > 'x'` drops
+ * the NULL-padded rows after the join, but pushing `r.date > 'x'` below would
+ * KEEP them (the left row simply finds no match and is padded again).
+ *
+ * | joinType | null-extended side | conjuncts pushable to |
+ * |----------|--------------------|-----------------------|
+ * | `inner`  | neither            | left and right        |
+ * | `cross`  | neither            | left and right        |
+ * | `left`   | right              | left only             |
+ * | `right`  | left               | right only            |
+ * | `full`   | both               | neither — rule declines |
+ * | `semi`   | n/a (output is left columns) | left only   |
+ * | `anti`   | n/a (output is left columns) | left only   |
+ *
+ * For `semi`/`anti` the left-only restriction is moot in practice —
+ * `buildJoinAttributes` returns only the left attributes, so a Filter above such
+ * a join cannot reference a right column at all — but it is encoded anyway so
+ * the table is exhaustive and the reasoning stays local.
+ *
+ * Attribution is a plain attribute-id set test: ids are minted per node instance
+ * and are stable across this pass's rewrites, so a self-join's two branches
+ * carry distinct ids, and a join's `exists … as` flag ids are in neither side's
+ * set (a conjunct over a flag falls out as un-pushable with no special case).
+ *
+ * Refusals:
+ * - A conjunct whose subtree references a RELATIONAL child (any subquery) is
+ *   left above. The id collector descends through relational children too, so
+ *   `exists (select 1 from x where x.a = e.id and x.b = t.id)` contributes `x`'s
+ *   own ids — which belong to neither side — and the conjunct is declined. That
+ *   descent is load-bearing: a scalar-only walk would see only `e.id` and push a
+ *   conjunct onto the left branch where `t.id` does not resolve.
+ * - Symmetrically, a conjunct naming a column from OUTSIDE the join — an outer
+ *   reference, when this `Filter(Join)` is itself the body of a correlated
+ *   subquery — sees an id in neither side's set and is declined.
+ *   NOTE: sound but pessimistic — `x.a = <outer>.b` would be safe on the `x`
+ *   branch. Ignoring "in neither side" ids instead of refusing on them would
+ *   recover that. {@link collectSubtreeAttributeIds} does not distinguish a
+ *   genuinely-outer id from a subquery-internal one, but
+ *   `analysis/predicate-dependencies.ts` does — its `correlated` set is exactly
+ *   the outer ids, and swapping this walk for it is the whole change. Left alone
+ *   until a real correlated body is measured losing a seek to it; the swap also
+ *   makes more conjuncts pushable, which needs its own plan-shape coverage.
+ * - A conjunct with NO column references (`where 1 = 1`, `where :p > 0`) stays
+ *   above; pushing it buys nothing and would make the rule fire on plans it
+ *   should leave alone.
+ * - A non-functional conjunct (`random() < e.amount`) stays above — moving it
+ *   below the join changes how many times it is evaluated.
+ * - A branch whose subtree carries a write keeps ITS conjuncts above while the
+ *   other branch still receives its own (per-branch refusal, unlike
+ *   `rule-predicate-inference-equivalence`'s outright one).
+ *
+ * A pushed conjunct is MOVED, not copied. A redundant copy above would
+ * re-evaluate per output row for no gain and, worse, make the rule
+ * non-idempotent — it would find the same pushable conjunct on every visit.
+ * With a move, a re-visit of the residual Filter finds nothing pushable and
+ * returns null, which is the termination argument.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { JoinNode } from '../../nodes/join-node.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
+import { splitConjuncts, combineConjuncts } from '../../analysis/predicate-conjuncts.js';
+import { PlanNodeCharacteristics } from '../../framework/characteristics.js';
+const log = createLogger('optimizer:rule:join-predicate-pushdown');
+/** The sides of `joinType` that are never null-extended in the output — see the header table. */
+function pushableSides(joinType) {
+    switch (joinType) {
+        case 'inner':
+        case 'cross':
+            return new Set(['left', 'right']);
+        case 'left':
+        case 'semi':
+        case 'anti':
+            return new Set(['left']);
+        case 'right':
+            return new Set(['right']);
+        case 'full':
+            return new Set();
+        default:
+            return new Set();
+    }
+}
+/**
+ * Every attribute id any `ColumnReferenceNode` in `expr`'s WHOLE subtree names —
+ * descending through relational children as well as scalar ones. See the
+ * file-header refusal notes for why the relational descent is required.
+ */
+function collectSubtreeAttributeIds(expr) {
+    const ids = new Set();
+    // Iterative worklist so a deep predicate cannot overflow the native stack.
+    const stack = [expr];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current instanceof ColumnReferenceNode) {
+            ids.add(current.attributeId);
+        }
+        for (const child of current.getChildren()) {
+            stack.push(child);
+        }
+    }
+    return ids;
+}
+/** The single side `ids` lands entirely on, or null when it spans / escapes both. */
+function attributeSide(ids, leftIds, rightIds) {
+    let allLeft = true;
+    let allRight = true;
+    for (const id of ids) {
+        if (!leftIds.has(id))
+            allLeft = false;
+        if (!rightIds.has(id))
+            allRight = false;
+        if (!allLeft && !allRight)
+            return null;
+    }
+    // A self-join mints distinct ids per branch, so the two sets are disjoint and
+    // a non-empty `ids` can satisfy at most one of these.
+    if (allLeft)
+        return 'left';
+    if (allRight)
+        return 'right';
+    return null;
+}
+export function ruleJoinPredicatePushdown(node, _context) {
+    if (node.nodeType !== PlanNodeType.Filter)
+        return null;
+    const filter = node;
+    const join = filter.source;
+    if (!(join instanceof JoinNode))
+        return null;
+    const sides = pushableSides(join.joinType);
+    if (sides.size === 0)
+        return null;
+    const leftIds = new Set(join.left.getAttributes().map(a => a.id));
+    const rightIds = new Set(join.right.getAttributes().map(a => a.id));
+    const conjuncts = splitConjuncts(normalizePredicate(filter.predicate));
+    let leftPush = [];
+    let rightPush = [];
+    const residual = [];
+    for (const conj of conjuncts) {
+        const ids = collectSubtreeAttributeIds(conj);
+        // No column reference at all (`1 = 1`, `:p > 0`): nothing to gain below.
+        if (ids.size === 0) {
+            residual.push(conj);
+            continue;
+        }
+        // Non-deterministic / write-bearing conjunct: moving it changes how many
+        // times it is evaluated.
+        if (!PlanNodeCharacteristics.isFunctional(conj)) {
+            residual.push(conj);
+            continue;
+        }
+        const side = attributeSide(ids, leftIds, rightIds);
+        if (side === null || !sides.has(side)) {
+            residual.push(conj);
+            continue;
+        }
+        (side === 'left' ? leftPush : rightPush).push(conj);
+    }
+    // Per-branch side-effect refusal: a branch carrying a write keeps its own
+    // conjuncts above while the other branch still receives its.
+    if (leftPush.length > 0 && PlanNodeCharacteristics.subtreeHasSideEffects(join.left)) {
+        log('join-predicate-pushdown: left branch has side effects; keeping its conjuncts above');
+        residual.push(...leftPush);
+        leftPush = [];
+    }
+    if (rightPush.length > 0 && PlanNodeCharacteristics.subtreeHasSideEffects(join.right)) {
+        log('join-predicate-pushdown: right branch has side effects; keeping its conjuncts above');
+        residual.push(...rightPush);
+        rightPush = [];
+    }
+    if (leftPush.length === 0 && rightPush.length === 0)
+        return null;
+    const newLeft = leftPush.length > 0
+        ? new FilterNode(join.left.scope, join.left, combineConjuncts(leftPush))
+        : join.left;
+    const newRight = rightPush.length > 0
+        ? new FilterNode(join.right.scope, join.right, combineConjuncts(rightPush))
+        : join.right;
+    // `withChildren` (not `new JoinNode(...)`) so `existence` and `usingColumns`
+    // thread through — a dropped existence spec strands every upstream reference
+    // to the flag's attribute id.
+    const newChildren = join.condition
+        ? [newLeft, newRight, join.condition]
+        : [newLeft, newRight];
+    const newJoin = join.withChildren(newChildren);
+    log('Pushed %d left + %d right conjunct(s) below %s join (%d residual)', leftPush.length, rightPush.length, join.joinType, residual.length);
+    if (residual.length === 0)
+        return newJoin;
+    return new FilterNode(filter.scope, newJoin, combineConjuncts(residual));
+}
+//# sourceMappingURL=rule-join-predicate-pushdown.js.map

package/dist/src/planner/rules/predicate/rule-join-predicate-pushdown.js.map

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