@quereus/quereus 4.4.1 → 4.6.0

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

@@ -4,18 +4,63 @@
  * 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 { createLogger } from '../../../common/logger.js';
 import { FilterNode } from '../../nodes/filter.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');
 export function ruleFilterSelectivity(node, context) {
     const filter = node;
@@ -24,25 +69,104 @@ 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-table source — leave the default 0.5 there (multi-column / join
-    // selectivity is parked in backlog feat-conjunction-and-join-selectivity).
-    const tableSchema = extractTableSchema(filter.source);
-    if (!tableSchema)
-        return null;
-    // NOTE: conjunctive predicates (`a = 1 and b = 2`) are NOT decomposed. The
-    // CatalogStatsProvider finds no single column child on the AND root and falls
-    // back to NaiveStatsProvider's coarse per-nodeType heuristic (0.1 for any
-    // BinaryOp). Crude but not a regression vs. the old flat 0.5 — conjunction
-    // decomposition is parked in backlog feat-conjunction-and-join-selectivity.
-    const sel = context.stats.selectivity(tableSchema, filter.predicate);
+    // 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. 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, origins, context)
+        : multiRelationSelectivity(filter, origins, context);
     if (sel === undefined)
         return null;
     const clamped = Math.min(1, Math.max(0, sel));
-    log('Filter over %s: stamping selectivity %f', tableSchema.name, clamped);
     // Rebuild the identical Filter (same scope, source, predicate → same output
     // attribute ids) with only the added estimate — hence sideEffectMode 'safe'.
     return new FilterNode(filter.scope, filter.source, filter.predicate, undefined, clamped);
 }
+// ── Single-table path ───────────────────────────────────────────────────
+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
+    // nothing at all, in which case the naive heuristic applies as before.
+    //
+    // 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.
+    //
+    // 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);
+    return sel;
+}
+// ── Multi-relation path ─────────────────────────────────────────────────
+/**
+ * Estimate a filter whose source spans several base tables by attributing each
+ * conjunct to the relation(s) its columns come from.
+ *
+ * NOTE: join type is ignored. A `left`/`right`/`full` join emits NULL-extended
+ * rows, which makes a predicate on the non-preserved side more selective than the
+ * base-table fraction suggests and one on the preserved side less so. Applying the
+ * base-table fraction either way is the conventional simplification, not an
+ * oversight.
+ *
+ * NOTE: an `aggregate` between the Filter and the join forwards group-key attribute
+ * ids unchanged, so a predicate on a group key is attributed to its base table and
+ * the base-table fraction is applied to post-aggregate cardinality. Imprecise but
+ * not unsound; deliberately not special-cased.
+ *
+ * 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, origins, context) {
+    if (origins.size === 0)
+        return undefined;
+    const conjuncts = splitConjuncts(filter.predicate);
+    const known = [];
+    for (const conjunct of conjuncts) {
+        const sel = estimateConjunctSelectivity(conjunct, origins, context);
+        if (sel !== undefined)
+            known.push(sel);
+    }
+    // Nothing estimable → leave the Filter unstamped exactly as before this path existed.
+    if (known.length === 0)
+        return undefined;
+    const combined = combineConjunctive(known);
+    // countRelations walks the whole origin map; keep it off the hot path.
+    if (log.enabled) {
+        log('Filter over %d relations: %d/%d conjuncts estimated, stamping %f', countRelations(origins), known.length, conjuncts.length, combined);
+    }
+    return combined;
+}
+function countRelations(origins) {
+    const relations = new Set();
+    for (const origin of origins.values())
+        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":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,MAAM,GAAG,GAAG,YAAY,CAAC,mCAAmC,CAAC,CAAC;AAE9D,MAAM,UAAU,qBAAqB,CAAC,IAAc,EAAE,OAAmB;IACxE,MAAM,MAAM,GAAG,IAAkB,CAAC;IAElC,4EAA4E;IAC5E,2EAA2E;IAC3E,+DAA+D;IAC/D,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAElD,gFAAgF;IAChF,6EAA6E;IAC7E,wEAAwE;IACxE,2EAA2E;IAC3E,MAAM,WAAW,GAAG,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACtD,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IAE9B,2EAA2E;IAC3E,8EAA8E;IAC9E,0EAA0E;IAC1E,2EAA2E;IAC3E,4EAA4E;IAC5E,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;IACrE,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAEnC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;IAC9C,GAAG,CAAC,yCAAyC,EAAE,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAE1E,4EAA4E;IAC5E,6EAA6E;IAC7E,OAAO,IAAI,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;AAC1F,CAAC"}
+{"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,73 @@
+/**
+ * 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, but only after separating a genuinely-outer id from a
+ *   subquery-internal one, which this walk does not currently distinguish.
+ *   Left alone until a real correlated body is measured losing a seek to it.
+ * - 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoEG;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,205 @@
+/**
+ * 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, but only after separating a genuinely-outer id from a
+ *   subquery-internal one, which this walk does not currently distinguish.
+ *   Left alone until a real correlated body is measured losing a seek to it.
+ * - 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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"}

package/dist/src/planner/rules/predicate/rule-predicate-inference-equivalence.d.ts

@@ -15,14 +15,17 @@
  *     `col = value` conjunct.
  *   - AND the new conjuncts into the filter predicate.
  *
- * Powerful form (additional when source is an inner/cross JoinNode):
- *   - Split the newly-inferred conjuncts by which side of the join their
- *     columns reference. For each single-side conjunct, inject a FilterNode
- *     wrapping that side of the join, re-keyed onto the branch's local
- *     column indices.
- *   - The outer FilterNode still carries the augmented predicate; the
- *     branch filter is what subsequent predicate-pushdown can carry into
- *     the leaf's Retrieve pipeline.
+ * Getting the inferred conjunct onto the branch is NOT this rule's job.
+ * `rule-join-predicate-pushdown` (registered immediately after this one, so it
+ * fires on this rule's own output within the same node visit) moves every
+ * single-side conjunct of the augmented predicate — original and inferred alike —
+ * onto the branch it constrains, and `rule-predicate-pushdown` then carries it
+ * across that branch's Alias into its Retrieve. This rule used to inject those
+ * branch Filters itself, back when no rule could cross a join; doing both now
+ * materializes the same conjunct twice on one branch (`u.k = 5 AND u.k = 5`), so
+ * the injection was removed rather than duplicated. Disabling
+ * `join-predicate-pushdown` therefore also stops inferred conjuncts from reaching
+ * a branch — they still land in the Filter above the join.
  *
  * Fixpoint guard: the rule's emission set is `{otherIdx ∈ EC | otherIdx
  * is not already in predBoundIdx}`. On a second invocation the
@@ -33,10 +36,10 @@
  * Safety:
  *   - LEFT/RIGHT/FULL joins: per `propagateJoinFds`, NULL-padded sides drop
  *     their bindings/ECs, so the EC visible at the filter's source is
- *     restricted to the preserved side. The rule additionally refuses
- *     branch injection on these join types (outer filter only).
+ *     restricted to the preserved side — no conjunct over a null-extended
+ *     side can be inferred here in the first place.
  *   - SEMI/ANTI: only the left side is in the output; no right inference
- *     can arise here. Treat as LEFT for branch injection.
+ *     can arise here.
  *
  * See ticket `3-rule-predicate-inference-equivalence` for the full design.
  */

package/dist/src/planner/rules/predicate/rule-predicate-inference-equivalence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-predicate-inference-equivalence.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-predicate-inference-equivalence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,KAAK,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAqB5E,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,OAAO,0BAA0B,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,0BAA0B,EAAE,QAAQ,GAAG,IAAI,CA2D9K"}
+{"version":3,"file":"rule-predicate-inference-equivalence.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-predicate-inference-equivalence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAGH,OAAO,KAAK,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAW5E,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,OAAO,0BAA0B,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,0BAA0B,EAAE,QAAQ,GAAG,IAAI,CAuD9K"}