@quereus/quereus 2.8.0 → 3.0.0

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

@@ -0,0 +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,CAwF5F"}

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

@@ -0,0 +1,113 @@
+/**
+ * Rule: Monotonic Merge Join
+ *
+ * Required Characteristics:
+ * - Node must be a logical JoinNode (not already physical)
+ * - Both inputs advertise `MonotonicOn` on (at least) one of the equi-pair
+ *   attributes, with matching direction (ASC for v1, since the merge-join
+ *   emitter assumes ASC ordering).
+ *
+ * Why this rule exists alongside `rule-join-physical-selection`:
+ * The existing rule chooses merge-join when both sources' `physical.ordering`
+ * matches the equi-pair attribute order positionally. That misses the canonical
+ * case where a merge-join's *output* declares `monotonicOn = [l.X, r.X]` but
+ * `ordering` reflects only the left side — a parent join on `r.X` then sees
+ * the right ordering implicitly through `monotonicOn` but not through
+ * `ordering[0]`. This rule looks the equi-pair attrs up directly in
+ * `monotonicOn`, recognising those (and other future MonotonicOn-propagating
+ * paths) without sorting.
+ *
+ * Out of scope (TODO):
+ * - Composite monotonic-on prefixes (multi-key streaming merge keyed on
+ *   `(X, Y)` when both sides are jointly monotonic on the prefix).
+ * - Right and full outer joins — emitter doesn't support them today.
+ * - Recognising `monotonicOn(asc)` vs `monotonicOn(desc)` by reversing one
+ *   side via Sort. That defeats this rule's premise (the rule's whole point is
+ *   that no sort is needed because both sides are already monotonic).
+ */
+import { createLogger } from '../../../common/logger.js';
+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';
+const log = createLogger('optimizer:rule:monotonic-merge-join');
+export function ruleMonotonicMergeJoin(node, _context) {
+    if (!(node instanceof JoinNode))
+        return null;
+    const joinType = node.joinType;
+    if (joinType !== 'inner' && joinType !== 'left' && joinType !== 'semi' && joinType !== 'anti')
+        return null;
+    const leftAttrs = node.left.getAttributes();
+    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);
+    if (!extracted || extracted.equiPairs.length === 0)
+        return null;
+    // Defer to `rule-join-physical-selection` whenever both sides' physical
+    // ordering already covers ALL equi-pairs in merge-ready order. The
+    // 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))
+        return null;
+    const leftMon = PlanNodeCharacteristics.getMonotonicOn(node.left);
+    const rightMon = PlanNodeCharacteristics.getMonotonicOn(node.right);
+    if (leftMon.length === 0 || rightMon.length === 0)
+        return null;
+    // 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.
+    const matchedIndices = [];
+    for (let i = 0; i < extracted.equiPairs.length; i++) {
+        const pair = extracted.equiPairs[i];
+        const l = leftMon.find(m => m.attrId === pair.leftAttrId && m.direction === 'asc');
+        if (!l)
+            continue;
+        const r = rightMon.find(m => m.attrId === pair.rightAttrId && m.direction === 'asc');
+        if (!r)
+            continue;
+        matchedIndices.push(i);
+    }
+    if (matchedIndices.length === 0)
+        return null;
+    // v1: pick a single driving equi-pair. Other equi-pairs (matched or not)
+    // must be evaluated as residual conjuncts — the merge-join emitter assumes
+    // the right side is sorted lexicographically across ALL listed equi-pair
+    // columns, which we cannot guarantee for non-driving keys.
+    // TODO: composite monotonic-on prefixes — recognise when both sides are
+    // jointly MonotonicOn on a multi-key prefix and use multiple driving keys.
+    const drivingIndex = matchedIndices[0];
+    const driving = [extracted.equiPairs[drivingIndex]];
+    // Residualize the rest. For pairs that originated from a real `=` BinaryOpNode
+    // (ON-condition path), reuse the original node. For USING-derived pairs,
+    // `equiPairNodes[i]` is undefined — bail out and let the existing
+    // ordering-based rule handle USING-with-multiple-pairs.
+    const extras = [];
+    for (let i = 0; i < extracted.equiPairs.length; i++) {
+        if (i === drivingIndex)
+            continue;
+        const orig = extracted.equiPairNodes[i];
+        if (!orig)
+            return null;
+        extras.push(orig);
+    }
+    const residual = combineResidual(extracted.residual, extras);
+    // Cost gate: even with the precondition met, hash or nested-loop may win
+    // on tiny inputs. Don't regress those.
+    const leftRows = node.left.estimatedRows ?? 100;
+    const rightRows = node.right.estimatedRows ?? 100;
+    const mergeC = mergeJoinCost(leftRows, rightRows, false, false);
+    const hashC = hashJoinCost(Math.min(leftRows, rightRows), Math.max(leftRows, rightRows));
+    const nlC = nestedLoopJoinCost(leftRows, rightRows);
+    if (Math.min(hashC, nlC) < mergeC) {
+        log('Skipping monotonic-merge: cheaper alternative exists (merge=%.2f, hash=%.2f, nl=%.2f)', mergeC, hashC, nlC);
+        return null;
+    }
+    log('Selecting monotonic merge-join on equi-pair %d=%d (merge=%.2f, hash=%.2f, nl=%.2f)', driving[0].leftAttrId, driving[0].rightAttrId, mergeC, hashC, nlC);
+    return new MergeJoinNode(node.scope, node.left, node.right, joinType, driving, residual, node.getAttributes().slice());
+}
+//# sourceMappingURL=rule-monotonic-merge-join.js.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1,20 @@
+/**
+ * Rule: Aggregate Predicate Pushdown
+ *
+ * Subsumes WHERE-on-group-by-column and HAVING-on-group-by-column. For a
+ *   FilterNode(predicate, AggregateNode|StreamAggregateNode|HashAggregateNode)
+ * each conjunct of `predicate` that references only GROUP-BY columns (or
+ * columns FD-determined by them in the aggregate's output FDs) is rewritten
+ * onto the aggregate's source attribute IDs and moved below the aggregate.
+ * Conjuncts referencing aggregate outputs (sum/count/etc.) or non-column
+ * GROUP-BY expressions stay above.
+ *
+ * Aggregate output indices in `physical.fds` come exclusively from
+ * bare-`ColumnReferenceNode` GROUP BYs (per `propagateAggregateFds`), so every
+ * output column in the FD closure has a known source attribute and can be
+ * rewritten.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleAggregatePredicatePushdown(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-aggregate-predicate-pushdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-aggregate-predicate-pushdown.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-aggregate-predicate-pushdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAiD,MAAM,0BAA0B,CAAC;AAExG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAqB7D,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CA8EpG"}

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

@@ -0,0 +1,181 @@
+/**
+ * Rule: Aggregate Predicate Pushdown
+ *
+ * Subsumes WHERE-on-group-by-column and HAVING-on-group-by-column. For a
+ *   FilterNode(predicate, AggregateNode|StreamAggregateNode|HashAggregateNode)
+ * each conjunct of `predicate` that references only GROUP-BY columns (or
+ * columns FD-determined by them in the aggregate's output FDs) is rewritten
+ * onto the aggregate's source attribute IDs and moved below the aggregate.
+ * Conjuncts referencing aggregate outputs (sum/count/etc.) or non-column
+ * GROUP-BY expressions stay above.
+ *
+ * Aggregate output indices in `physical.fds` come exclusively from
+ * bare-`ColumnReferenceNode` GROUP BYs (per `propagateAggregateFds`), so every
+ * output column in the FD closure has a known source attribute and can be
+ * rewritten.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { isRelationalNode } from '../../nodes/plan-node.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { AggregateNode } from '../../nodes/aggregate-node.js';
+import { StreamAggregateNode } from '../../nodes/stream-aggregate.js';
+import { HashAggregateNode } from '../../nodes/hash-aggregate.js';
+import { ColumnReferenceNode } from '../../nodes/reference.js';
+import { normalizePredicate } from '../../analysis/predicate-normalizer.js';
+import { splitConjuncts, combineConjuncts } from '../../analysis/predicate-conjuncts.js';
+import { computeClosure } from '../../util/fd-utils.js';
+const log = createLogger('optimizer:rule:aggregate-predicate-pushdown');
+function isAggregateNode(node) {
+    return node instanceof AggregateNode
+        || node instanceof StreamAggregateNode
+        || node instanceof HashAggregateNode;
+}
+export function ruleAggregatePredicatePushdown(node, _context) {
+    if (node.nodeType !== PlanNodeType.Filter)
+        return null;
+    const filter = node;
+    if (!isAggregateNode(filter.source))
+        return null;
+    const agg = filter.source;
+    // Scalar aggregate (no GROUP BY): the predicate selects on the single output
+    // row, so nothing is pushable.
+    if (agg.groupBy.length === 0)
+        return null;
+    const aggAttrs = agg.getAttributes();
+    const sourceAttrs = agg.source.getAttributes();
+    // Build the output → source mapping for bare-column GROUP BYs. Aggregate
+    // output columns (indices ≥ groupCount) have no source mapping. Non-column
+    // GROUP BY expressions (`group_${i}`) also have no source mapping.
+    const outputToSource = new Map();
+    const groupByOutputIndices = new Set();
+    for (let i = 0; i < agg.groupBy.length; i++) {
+        const gbExpr = agg.groupBy[i];
+        if (!(gbExpr instanceof ColumnReferenceNode))
+            continue;
+        const outAttrId = aggAttrs[i].id;
+        const srcAttrId = gbExpr.attributeId;
+        const srcIdx = sourceAttrs.findIndex(a => a.id === srcAttrId);
+        if (srcIdx < 0)
+            continue;
+        outputToSource.set(outAttrId, { sourceAttrId: srcAttrId, sourceColIdx: srcIdx });
+        groupByOutputIndices.add(i);
+    }
+    if (outputToSource.size === 0)
+        return null;
+    // Map output attribute id → output column index, used to test FD closure
+    // membership.
+    const outAttrIdToIndex = new Map();
+    aggAttrs.forEach((a, i) => outAttrIdToIndex.set(a.id, i));
+    // FD closure on the aggregate's output indices, seeded by the bare-column
+    // GROUP BY output indices. With composite GROUP BYs and inherited source
+    // FDs, this can widen `outputToSource` membership to FD-dependent columns
+    // (which by `propagateAggregateFds`'s projection are themselves bare-column
+    // GROUP BY outputs and therefore already in `outputToSource`).
+    const aggFds = agg.physical.fds ?? [];
+    const pushableOutputIndices = computeClosure(groupByOutputIndices, aggFds);
+    // Normalize → split → partition conjuncts.
+    const normalized = normalizePredicate(filter.predicate);
+    const conjuncts = splitConjuncts(normalized);
+    const pushable = [];
+    const remaining = [];
+    for (const conj of conjuncts) {
+        if (isConjunctPushable(conj, outAttrIdToIndex, outputToSource, pushableOutputIndices)) {
+            pushable.push(conj);
+        }
+        else {
+            remaining.push(conj);
+        }
+    }
+    if (pushable.length === 0)
+        return null;
+    // Rewrite pushable conjuncts: rebind output column refs to source ones.
+    const rewrittenPushable = pushable.map(c => rewriteOutputToSource(c, outputToSource, sourceAttrs));
+    const pushedPredicate = combineConjuncts(rewrittenPushable);
+    const newSource = new FilterNode(agg.source.scope, agg.source, pushedPredicate);
+    // Rebuild the aggregate over the filtered source, preserving attribute IDs.
+    const newAgg = rebuildAggregate(agg, newSource);
+    log('Pushed %d/%d conjunct(s) below %s', pushable.length, conjuncts.length, agg.nodeType);
+    if (remaining.length === 0) {
+        return newAgg;
+    }
+    const residualPredicate = combineConjuncts(remaining);
+    return new FilterNode(filter.scope, newAgg, residualPredicate);
+}
+function isConjunctPushable(conj, outAttrIdToIndex, outputToSource, pushableOutputIndices) {
+    const referenced = collectReferencedAttributeIds(conj);
+    if (referenced.size === 0) {
+        // Constant conjunct: safe to push (and safe to keep above too — pushing
+        // reduces work below). Keep above to avoid spurious rule firings; the
+        // rule only "fires" when there's a real column-driven push.
+        return false;
+    }
+    for (const attrId of referenced) {
+        const idx = outAttrIdToIndex.get(attrId);
+        if (idx === undefined)
+            return false;
+        if (!pushableOutputIndices.has(idx))
+            return false;
+        // Every pushable index must have a source mapping for rewrite.
+        if (!outputToSource.has(attrId))
+            return false;
+    }
+    return true;
+}
+function collectReferencedAttributeIds(expr) {
+    const ids = new Set();
+    walkScalar(expr, n => {
+        if (n instanceof ColumnReferenceNode) {
+            ids.add(n.attributeId);
+        }
+    });
+    return ids;
+}
+function walkScalar(expr, fn) {
+    fn(expr);
+    for (const c of expr.getChildren()) {
+        if (!isRelationalNode(c)) {
+            walkScalar(c, fn);
+        }
+    }
+}
+function rewriteOutputToSource(expr, outputToSource, sourceAttrs) {
+    if (expr instanceof ColumnReferenceNode) {
+        const mapping = outputToSource.get(expr.attributeId);
+        if (mapping === undefined)
+            return expr;
+        const srcAttr = sourceAttrs.find(a => a.id === mapping.sourceAttrId);
+        // `sourceAttrs` was indexed against to build `outputToSource`; the lookup must hit.
+        if (!srcAttr)
+            return expr;
+        return new ColumnReferenceNode(expr.scope, expr.expression, srcAttr.type, mapping.sourceAttrId, mapping.sourceColIdx);
+    }
+    const children = expr.getChildren();
+    if (children.length === 0)
+        return expr;
+    const newChildren = [];
+    let changed = false;
+    for (const c of children) {
+        if (isRelationalNode(c)) {
+            newChildren.push(c);
+            continue;
+        }
+        const replaced = rewriteOutputToSource(c, outputToSource, sourceAttrs);
+        newChildren.push(replaced);
+        if (replaced !== c)
+            changed = true;
+    }
+    if (!changed)
+        return expr;
+    return expr.withChildren(newChildren);
+}
+function rebuildAggregate(agg, newSource) {
+    if (agg instanceof AggregateNode) {
+        return new AggregateNode(agg.scope, newSource, agg.groupBy, agg.aggregates, undefined, agg.getAttributes());
+    }
+    if (agg instanceof StreamAggregateNode) {
+        return new StreamAggregateNode(agg.scope, newSource, agg.groupBy, agg.aggregates, undefined, agg.getAttributes());
+    }
+    return new HashAggregateNode(agg.scope, newSource, agg.groupBy, agg.aggregates, undefined, agg.getAttributes());
+}
+//# sourceMappingURL=rule-aggregate-predicate-pushdown.js.map

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

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

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

@@ -0,0 +1,46 @@
+/**
+ * Rule: Empty-Relation Folding
+ *
+ * Const-fold pass that recognizes provably-empty subtrees and replaces them
+ * with `EmptyRelationNode`, preserving attribute IDs and `RelationType` shape
+ * so consumers above the rewrite keep working.
+ *
+ * Recognized shapes (E = EmptyRelationNode):
+ *   - Filter(x, lit-false / lit-null / lit-0) → E with x's schema
+ *   - Filter(E, _)                            → E (pass-through)
+ *   - Project(E, projections)                 → E with project's schema
+ *   - Sort(E, _) / LimitOffset(E, _) / Distinct(E) → E (schema unchanged)
+ *   - Join(E, R, inner|cross|semi)            → E with join's schema
+ *   - Join(L, E, inner|cross|semi)            → E with join's schema
+ *   - Join(E, R, left)                        → E (empty driving side)
+ *   - Join(L, E, right)                       → E (symmetric)
+ *   - Join(E, _, anti)                        → E (anti drives from left)
+ *   - Join(E, E, full)                        → E (both sides empty)
+ *
+ * Deliberately NOT folded (sound reasons):
+ *   - Join(L, E, left)     — returns L null-padded on right
+ *   - Join(E, R, right)    — symmetric
+ *   - Join(L, E, anti)     — anti with empty right returns all of L
+ *   - Single-side-empty FULL — still emits null-padded rows for non-empty side
+ *
+ * Runs in the Structural pass (TopDown) after the IND rules. Cascade is
+ * 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.md`.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+/**
+ * WHERE-clause truthiness: `false`, `null`, `0`, `0n` all reject every row.
+ * Conservatively cover only the canonical "no rows" literals. Other coercions
+ * (e.g. empty string, 0.0) are left out; if needed, expand here.
+ */
+export declare function isLiteralFalsy(node: PlanNode): boolean;
+export declare function ruleFilterFoldEmpty(node: PlanNode, _ctx: OptContext): PlanNode | null;
+export declare function ruleProjectFoldEmpty(node: PlanNode, _ctx: OptContext): PlanNode | null;
+export declare function ruleSortFoldEmpty(node: PlanNode, _ctx: OptContext): PlanNode | null;
+export declare function ruleLimitOffsetFoldEmpty(node: PlanNode, _ctx: OptContext): PlanNode | null;
+export declare function ruleDistinctFoldEmpty(node: PlanNode, _ctx: OptContext): PlanNode | null;
+export declare function ruleJoinFoldEmpty(node: PlanNode, _ctx: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-empty-relation-folding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-empty-relation-folding.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-empty-relation-folding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AA2B7D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAItD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAWrF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAKtF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAKnF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAK1F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAKvF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAwCnF"}

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

@@ -0,0 +1,156 @@
+/**
+ * Rule: Empty-Relation Folding
+ *
+ * Const-fold pass that recognizes provably-empty subtrees and replaces them
+ * with `EmptyRelationNode`, preserving attribute IDs and `RelationType` shape
+ * so consumers above the rewrite keep working.
+ *
+ * Recognized shapes (E = EmptyRelationNode):
+ *   - Filter(x, lit-false / lit-null / lit-0) → E with x's schema
+ *   - Filter(E, _)                            → E (pass-through)
+ *   - Project(E, projections)                 → E with project's schema
+ *   - Sort(E, _) / LimitOffset(E, _) / Distinct(E) → E (schema unchanged)
+ *   - Join(E, R, inner|cross|semi)            → E with join's schema
+ *   - Join(L, E, inner|cross|semi)            → E with join's schema
+ *   - Join(E, R, left)                        → E (empty driving side)
+ *   - Join(L, E, right)                       → E (symmetric)
+ *   - Join(E, _, anti)                        → E (anti drives from left)
+ *   - Join(E, E, full)                        → E (both sides empty)
+ *
+ * Deliberately NOT folded (sound reasons):
+ *   - Join(L, E, left)     — returns L null-padded on right
+ *   - Join(E, R, right)    — symmetric
+ *   - Join(L, E, anti)     — anti with empty right returns all of L
+ *   - Single-side-empty FULL — still emits null-padded rows for non-empty side
+ *
+ * Runs in the Structural pass (TopDown) after the IND rules. Cascade is
+ * 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.md`.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { ProjectNode } from '../../nodes/project-node.js';
+import { SortNode } from '../../nodes/sort.js';
+import { LimitOffsetNode } from '../../nodes/limit-offset.js';
+import { DistinctNode } from '../../nodes/distinct-node.js';
+import { JoinNode } from '../../nodes/join-node.js';
+import { AliasNode } from '../../nodes/alias-node.js';
+import { LiteralNode } from '../../nodes/scalar.js';
+import { EmptyRelationNode } from '../../nodes/empty-relation-node.js';
+const log = createLogger('optimizer:rule:empty-relation-folding');
+/**
+ * Detects EmptyRelation, including the common case where it sits beneath one
+ * or more attribute-renaming wrappers (Alias) introduced by FROM-clause
+ * subquery aliases. Looking through Alias is sound here because the *host*
+ * fold (Join, Project, etc.) produces an EmptyRelation carrying the host's
+ * own attributes — the wrapped Alias's rename is discarded along with the
+ * Alias itself.
+ */
+function isEmpty(node) {
+    if (node instanceof EmptyRelationNode)
+        return true;
+    if (node instanceof AliasNode)
+        return isEmpty(node.source);
+    return false;
+}
+/**
+ * WHERE-clause truthiness: `false`, `null`, `0`, `0n` all reject every row.
+ * Conservatively cover only the canonical "no rows" literals. Other coercions
+ * (e.g. empty string, 0.0) are left out; if needed, expand here.
+ */
+export function isLiteralFalsy(node) {
+    if (!(node instanceof LiteralNode))
+        return false;
+    const v = node.expression.value;
+    return v === false || v === null || v === 0 || v === 0n;
+}
+export function ruleFilterFoldEmpty(node, _ctx) {
+    if (!(node instanceof FilterNode))
+        return null;
+    if (isEmpty(node.source)) {
+        log('Filter(Empty, _) → Empty');
+        return node.source;
+    }
+    if (isLiteralFalsy(node.predicate)) {
+        log('Filter(x, lit-false) → Empty');
+        return new EmptyRelationNode(node.scope, node.getAttributes(), node.getType());
+    }
+    return null;
+}
+export function ruleProjectFoldEmpty(node, _ctx) {
+    if (!(node instanceof ProjectNode))
+        return null;
+    if (!isEmpty(node.source))
+        return null;
+    log('Project(Empty, _) → Empty');
+    return new EmptyRelationNode(node.scope, node.getAttributes(), node.getType());
+}
+export function ruleSortFoldEmpty(node, _ctx) {
+    if (!(node instanceof SortNode))
+        return null;
+    if (!isEmpty(node.source))
+        return null;
+    log('Sort(Empty, _) → Empty');
+    return node.source;
+}
+export function ruleLimitOffsetFoldEmpty(node, _ctx) {
+    if (!(node instanceof LimitOffsetNode))
+        return null;
+    if (!isEmpty(node.source))
+        return null;
+    log('LimitOffset(Empty, _) → Empty');
+    return node.source;
+}
+export function ruleDistinctFoldEmpty(node, _ctx) {
+    if (!(node instanceof DistinctNode))
+        return null;
+    if (!isEmpty(node.source))
+        return null;
+    log('Distinct(Empty) → Empty');
+    return node.source;
+}
+export function ruleJoinFoldEmpty(node, _ctx) {
+    if (!(node instanceof JoinNode))
+        return null;
+    const leftEmpty = isEmpty(node.left);
+    const rightEmpty = isEmpty(node.right);
+    if (!leftEmpty && !rightEmpty)
+        return null;
+    let fold = false;
+    switch (node.joinType) {
+        case 'inner':
+        case 'cross':
+            fold = leftEmpty || rightEmpty;
+            break;
+        case 'left':
+            // LEFT JOIN: empty left → empty output. Empty right → keep (null-pad L).
+            fold = leftEmpty;
+            break;
+        case 'right':
+            // RIGHT JOIN: empty right → empty output. Empty left → keep (null-pad R).
+            fold = rightEmpty;
+            break;
+        case 'full':
+            // FULL JOIN: only fold when BOTH sides empty; one empty side still
+            // emits null-padded rows from the non-empty side.
+            fold = leftEmpty && rightEmpty;
+            break;
+        case 'semi':
+            // SEMI JOIN: empty L → empty. Empty R → empty (no matches possible).
+            fold = leftEmpty || rightEmpty;
+            break;
+        case 'anti':
+            // ANTI JOIN: empty L → empty. Empty R → all of L (do NOT fold).
+            fold = leftEmpty;
+            break;
+        default:
+            return null;
+    }
+    if (!fold)
+        return null;
+    log('Join(%s) with empty side(s) → Empty', node.joinType);
+    return new EmptyRelationNode(node.scope, node.getAttributes(), node.getType());
+}
+//# sourceMappingURL=rule-empty-relation-folding.js.map

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

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

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

@@ -0,0 +1,30 @@
+/**
+ * Rule: Filter Predicate Contradiction
+ *
+ * Folds Filter nodes whose conjuncts together with the source's
+ * `domainConstraints` and literal `constantBindings` are provably
+ * unsatisfiable. The empty result is materialized as `EmptyRelationNode`
+ * carrying the Filter's own attribute IDs / RelationType, so the const-fold
+ * cascade (Project / Sort / LimitOffset / Distinct / inner-or-cross-or-semi
+ * Join) can drop the parent subtree.
+ *
+ * Scope (see `analysis/sat-checker.ts`):
+ *   - Single-column comparisons against literals (= / != / < / <= / > / >=).
+ *   - Single-column BETWEEN literal AND literal.
+ *   - Single-column IN (lit, lit, ...) and intersection across IN-lists.
+ *   - Domain-vs-predicate intersection.
+ *
+ * Out of scope (treated as `unknown`, never folded):
+ *   - OR / CASE branch analysis, cross-column arithmetic, LIKE, IS NULL,
+ *     user-function reasoning. The sat-checker tracks an `unknown` flag
+ *     per column so an in-scope contradiction on column `a` still fires
+ *     even if an unrelated LIKE on column `b` is present.
+ *
+ * Registered at Structural pass priority 27 — runs alongside the empty-
+ * relation-folding rules so any `Filter(_, false)` produced by other rules
+ * has already been collapsed.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleFilterContradiction(node: PlanNode, _ctx: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-filter-contradiction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-filter-contradiction.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-filter-contradiction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAS7D,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAoCzF"}