@quereus/quereus 2.9.0 → 3.0.0

package/dist/src/planner/rules/join/rule-join-greedy-commute.js

@@ -1,6 +1,14 @@
 import { createLogger } from '../../../common/logger.js';
 import { JoinNode } from '../../nodes/join-node.js';
+import { hasSingletonFd } from '../../util/fd-utils.js';
 const log = createLogger('optimizer:rule:join-greedy-commute');
+/** True when the relation provably emits at most one row. */
+function isSingleton(node) {
+    const colCount = node.getAttributes().length;
+    if (colCount === 0)
+        return node.physical?.estimatedRows === 1;
+    return hasSingletonFd(node.physical?.fds, colCount);
+}
 /**
  * Rule: Join Greedy Commute
  *
@@ -19,8 +27,8 @@ export function ruleJoinGreedyCommute(node, _context) {
     const leftRows = node.getLeftSource().estimatedRows ?? Number.POSITIVE_INFINITY;
     const rightRows = node.getRightSource().estimatedRows ?? Number.POSITIVE_INFINITY;
     // Prefer known finite estimatedRows; also detect <=1 row driver on either side
-    const leftIsSingleton = node.getLeftSource().physical.uniqueKeys?.some(k => k.length === 0) === true;
-    const rightIsSingleton = node.getRightSource().physical.uniqueKeys?.some(k => k.length === 0) === true;
+    const leftIsSingleton = isSingleton(node.getLeftSource());
+    const rightIsSingleton = isSingleton(node.getRightSource());
     // If right is strictly better driver (smaller or singleton), swap
     const shouldSwap = (rightIsSingleton && !leftIsSingleton) || (!rightIsSingleton && !leftIsSingleton && rightRows < leftRows);
     if (!shouldSwap)

package/dist/src/planner/rules/join/rule-join-greedy-commute.js.map

@@ -1 +1 @@
-{"version":3,"file":"rule-join-greedy-commute.js","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-greedy-commute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,MAAM,GAAG,GAAG,YAAY,CAAC,oCAAoC,CAAC,CAAC;AAE/D;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAc,EAAE,QAAoB;IACxE,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAExE,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,aAAa,IAAI,MAAM,CAAC,iBAAiB,CAAC;IAChF,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC,aAAa,IAAI,MAAM,CAAC,iBAAiB,CAAC;IAElF,+EAA+E;IAC/E,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;IACrG,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,KAAK,IAAI,CAAC;IAEvG,kEAAkE;IAClE,MAAM,UAAU,GAAG,CAAC,gBAAgB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,gBAAgB,IAAI,CAAC,eAAe,IAAI,SAAS,GAAG,QAAQ,CAAC,CAAC;IAC7H,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAE7B,GAAG,CAAC,wFAAwF,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IAEnI,qEAAqE;IACrE,MAAM,OAAO,GAAG,IAAI,QAAQ,CAC1B,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,cAAc,EAAwB,EAC3C,IAAI,CAAC,aAAa,EAAwB,EAC1C,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,gBAAgB,EAAE,EACvB,IAAI,CAAC,eAAe,EAAE,CACvB,CAAC;IAEF,OAAO,OAAO,CAAC;AACjB,CAAC"}
+{"version":3,"file":"rule-join-greedy-commute.js","sourceRoot":"","sources":["../../../../../src/planner/rules/join/rule-join-greedy-commute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,MAAM,GAAG,GAAG,YAAY,CAAC,oCAAoC,CAAC,CAAC;AAE/D,6DAA6D;AAC7D,SAAS,WAAW,CAAC,IAAwB;IAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,MAAM,CAAC;IAC7C,IAAI,QAAQ,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,QAAQ,EAAE,aAAa,KAAK,CAAC,CAAC;IAC9D,OAAO,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAc,EAAE,QAAoB;IACxE,IAAI,CAAC,CAAC,IAAI,YAAY,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAExE,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,aAAa,IAAI,MAAM,CAAC,iBAAiB,CAAC;IAChF,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC,aAAa,IAAI,MAAM,CAAC,iBAAiB,CAAC;IAElF,+EAA+E;IAC/E,MAAM,eAAe,GAAG,WAAW,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IAC1D,MAAM,gBAAgB,GAAG,WAAW,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IAE5D,kEAAkE;IAClE,MAAM,UAAU,GAAG,CAAC,gBAAgB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,gBAAgB,IAAI,CAAC,eAAe,IAAI,SAAS,GAAG,QAAQ,CAAC,CAAC;IAC7H,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAE7B,GAAG,CAAC,wFAAwF,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IAEnI,qEAAqE;IACrE,MAAM,OAAO,GAAG,IAAI,QAAQ,CAC1B,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,cAAc,EAAwB,EAC3C,IAAI,CAAC,aAAa,EAAwB,EAC1C,IAAI,CAAC,WAAW,EAAE,EAClB,IAAI,CAAC,gBAAgB,EAAE,EACvB,IAAI,CAAC,eAAe,EAAE,CACvB,CAAC;IAEF,OAAO,OAAO,CAAC;AACjB,CAAC"}

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"}

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

@@ -0,0 +1,60 @@
+/**
+ * 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 { createLogger } from '../../../common/logger.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { EmptyRelationNode } from '../../nodes/empty-relation-node.js';
+import { splitConjuncts } from '../../analysis/predicate-conjuncts.js';
+import { checkSatisfiability } from '../../analysis/sat-checker.js';
+import { isLiteralFalsy } from './rule-empty-relation-folding.js';
+const log = createLogger('optimizer:rule:filter-contradiction');
+export function ruleFilterContradiction(node, _ctx) {
+    if (!(node instanceof FilterNode))
+        return null;
+    // `Filter(_, lit-false|null|0|0n)` is the empty-folding rule's job; bail out
+    // so this rule doesn't dispatch to the sat-checker for predicates the
+    // sibling rule will collapse anyway.
+    if (isLiteralFalsy(node.predicate)) {
+        return null;
+    }
+    const sourcePhysical = node.source.physical;
+    const domains = sourcePhysical.domainConstraints ?? [];
+    const bindings = sourcePhysical.constantBindings ?? [];
+    const conjuncts = splitConjuncts(node.predicate);
+    const sourceAttrs = node.source.getAttributes();
+    const attrIdToIndex = new Map();
+    sourceAttrs.forEach((a, i) => attrIdToIndex.set(a.id, i));
+    const collationOf = (col) => {
+        const attr = sourceAttrs[col];
+        return attr?.type.collationName;
+    };
+    const result = checkSatisfiability(conjuncts, domains, bindings, (attrId) => attrIdToIndex.get(attrId), collationOf);
+    if (result !== 'unsat')
+        return null;
+    log('Filter predicate provably unsatisfiable → Empty');
+    return new EmptyRelationNode(node.scope, node.getAttributes(), node.getType());
+}
+//# sourceMappingURL=rule-filter-contradiction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-filter-contradiction.js","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-filter-contradiction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAElE,MAAM,GAAG,GAAG,YAAY,CAAC,qCAAqC,CAAC,CAAC;AAEhE,MAAM,UAAU,uBAAuB,CAAC,IAAc,EAAE,IAAgB;IACvE,IAAI,CAAC,CAAC,IAAI,YAAY,UAAU,CAAC;QAAE,OAAO,IAAI,CAAC;IAE/C,6EAA6E;IAC7E,sEAAsE;IACtE,qCAAqC;IACrC,IAAI,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;IAC5C,MAAM,OAAO,GAAG,cAAc,CAAC,iBAAiB,IAAI,EAAE,CAAC;IACvD,MAAM,QAAQ,GAAG,cAAc,CAAC,gBAAgB,IAAI,EAAE,CAAC;IACvD,MAAM,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAEjD,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IAChD,MAAM,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;IAChD,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAE1D,MAAM,WAAW,GAAG,CAAC,GAAW,EAAsB,EAAE;QACvD,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;QAC9B,OAAO,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC;IACjC,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,mBAAmB,CACjC,SAAS,EACT,OAAO,EACP,QAAQ,EACR,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EACrC,WAAW,CACX,CAAC;IAEF,IAAI,MAAM,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAEpC,GAAG,CAAC,iDAAiD,CAAC,CAAC;IACvD,OAAO,IAAI,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;AAChF,CAAC"}

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

@@ -0,0 +1,45 @@
+/**
+ * Rule: Predicate Inference (Equivalence-Class driven)
+ *
+ * Materializes inferred equality predicates derived from combining
+ * (predicate-derived) constant bindings with (source-derived) equivalence
+ * classes. When `t.k = u.k` is known via a join's equi-pair and `t.k = V`
+ * is asserted in the filter, the rule emits `u.k = V` so the predicate is
+ * visible to vtab access plans on the `u` side independently.
+ *
+ * Simple form (always run):
+ *   Filter(predicate, source)
+ *   - Extract `predBindings` from the predicate (col-index → constant value).
+ *   - Cross with `source.physical.equivClasses`: for every EC member of a
+ *     bound column that is not itself bound by the predicate, emit a new
+ *     `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.
+ *
+ * Fixpoint guard: the rule's emission set is `{otherIdx ∈ EC | otherIdx
+ * is not already in predBoundIdx}`. On a second invocation the
+ * inferred conjuncts have themselves contributed bindings, so every EC
+ * member is in `predBoundIdx` and the rule yields nothing. The registry's
+ * per-node `markRuleApplied` is a belt-and-suspenders second guard.
+ *
+ * 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).
+ *   - SEMI/ANTI: only the left side is in the output; no right inference
+ *     can arise here. Treat as LEFT for branch injection.
+ *
+ * See ticket `3-rule-predicate-inference-equivalence` for the full design.
+ */
+import type { OptContext as _OptContext } from '../../framework/context.js';
+export declare function rulePredicateInferenceEquivalence(node: import('../../nodes/plan-node.js').PlanNode, _context: _OptContext): import('../../nodes/plan-node.js').PlanNode | null;
+//# sourceMappingURL=rule-predicate-inference-equivalence.d.ts.map

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

@@ -0,0 +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;AAoB5E,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,OAAO,0BAA0B,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,0BAA0B,EAAE,QAAQ,GAAG,IAAI,CA2D9K"}