@quereus/quereus 2.8.0 → 3.0.0

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

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

@@ -0,0 +1,210 @@
+/**
+ * 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 { createLogger } from '../../../common/logger.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { JoinNode } from '../../nodes/join-node.js';
+import { BinaryOpNode, LiteralNode } from '../../nodes/scalar.js';
+import { ColumnReferenceNode, ParameterReferenceNode } from '../../nodes/reference.js';
+import { extractEqualityFds } from '../../util/fd-utils.js';
+const log = createLogger('optimizer:rule:predicate-inference-equivalence');
+export function rulePredicateInferenceEquivalence(node, _context) {
+    if (!(node instanceof FilterNode))
+        return null;
+    const filter = node;
+    const source = filter.source;
+    const sourcePhys = source.physical;
+    const ecs = sourcePhys?.equivClasses;
+    if (!ecs || ecs.length === 0)
+        return null;
+    const sourceAttrs = source.getAttributes();
+    const attrIdToIndex = new Map();
+    sourceAttrs.forEach((a, i) => attrIdToIndex.set(a.id, i));
+    const { constantBindings: predBindings } = extractEqualityFds(filter.predicate, attrIdToIndex);
+    if (predBindings.length === 0)
+        return null;
+    // Columns the predicate itself directly pins. Used both to find which
+    // EC members already have a binding and as the fixpoint guard: once
+    // every EC member is in this set, the rule contributes nothing further.
+    const predBoundIdx = new Set();
+    for (const b of predBindings)
+        for (const c of b.attrs)
+            predBoundIdx.add(c);
+    const inferred = [];
+    const seen = new Set();
+    for (const binding of predBindings) {
+        for (const predIdx of binding.attrs) {
+            for (const cls of ecs) {
+                if (!cls.includes(predIdx))
+                    continue;
+                for (const otherIdx of cls) {
+                    if (otherIdx === predIdx)
+                        continue;
+                    if (predBoundIdx.has(otherIdx))
+                        continue;
+                    const key = `${otherIdx}|${valueSignature(binding.value)}`;
+                    if (seen.has(key))
+                        continue;
+                    seen.add(key);
+                    const attr = sourceAttrs[otherIdx];
+                    if (!attr)
+                        continue;
+                    const conjunct = synthesizeEquality(filter.scope, attr, otherIdx, binding.value);
+                    inferred.push({ sourceColIdx: otherIdx, value: binding.value, conjunct });
+                }
+            }
+        }
+    }
+    if (inferred.length === 0)
+        return null;
+    log('Inferring %d new equality conjunct(s) on Filter from EC × bindings', inferred.length);
+    // AND every inferred conjunct into the predicate.
+    let combinedPredicate = filter.predicate;
+    for (const inf of inferred) {
+        combinedPredicate = andTogether(filter.scope, combinedPredicate, inf.conjunct);
+    }
+    // Powerful form: branch injection below inner/cross joins.
+    let newSource = source;
+    if (source instanceof JoinNode) {
+        newSource = tryBranchInjection(source, inferred) ?? source;
+    }
+    return new FilterNode(filter.scope, newSource, combinedPredicate);
+}
+/**
+ * For an inner or cross JoinNode whose output bears `inferred` conjuncts,
+ * inject single-side conjuncts as FilterNode wrappers on the corresponding
+ * branch. Returns the rebuilt join, or null if no inferred conjunct lands
+ * on either branch.
+ */
+function tryBranchInjection(join, inferred) {
+    // Only inner / cross are safe — see file-level "Safety" notes.
+    if (join.joinType !== 'inner' && join.joinType !== 'cross')
+        return null;
+    const leftAttrs = join.left.getAttributes();
+    const rightAttrs = join.right.getAttributes();
+    const leftCount = leftAttrs.length;
+    const leftBranchConjuncts = [];
+    const rightBranchConjuncts = [];
+    for (const inf of inferred) {
+        if (inf.sourceColIdx < leftCount) {
+            // Left-branch: attribute id is stable, so re-synthesize against the
+            // branch's local column index (which is `sourceColIdx` itself).
+            const attr = leftAttrs[inf.sourceColIdx];
+            if (!attr)
+                continue;
+            leftBranchConjuncts.push(synthesizeEquality(join.scope, attr, inf.sourceColIdx, inf.value));
+        }
+        else {
+            const rightIdx = inf.sourceColIdx - leftCount;
+            const attr = rightAttrs[rightIdx];
+            if (!attr)
+                continue;
+            rightBranchConjuncts.push(synthesizeEquality(join.scope, attr, rightIdx, inf.value));
+        }
+    }
+    if (leftBranchConjuncts.length === 0 && rightBranchConjuncts.length === 0)
+        return null;
+    let newLeft = join.left;
+    let newRight = join.right;
+    if (leftBranchConjuncts.length > 0) {
+        const leftPred = combineAnds(join.scope, leftBranchConjuncts);
+        newLeft = new FilterNode(join.left.scope, join.left, leftPred);
+    }
+    if (rightBranchConjuncts.length > 0) {
+        const rightPred = combineAnds(join.scope, rightBranchConjuncts);
+        newRight = new FilterNode(join.right.scope, join.right, rightPred);
+    }
+    log('Injecting %d left + %d right branch filter(s) below %s join', leftBranchConjuncts.length, rightBranchConjuncts.length, join.joinType);
+    return new JoinNode(join.scope, newLeft, newRight, join.joinType, join.condition, join.usingColumns);
+}
+function synthesizeEquality(scope, attr, columnIndex, value) {
+    const colExpr = attr.relationName
+        ? { type: 'column', name: attr.name, table: attr.relationName }
+        : { type: 'column', name: attr.name };
+    const colRef = new ColumnReferenceNode(scope, colExpr, attr.type, attr.id, columnIndex);
+    let valueNode;
+    if (value.kind === 'literal') {
+        const litExpr = { type: 'literal', value: value.value };
+        valueNode = new LiteralNode(scope, litExpr);
+    }
+    else {
+        const paramExpr = typeof value.paramRef === 'string'
+            ? { type: 'parameter', name: value.paramRef }
+            : { type: 'parameter', index: value.paramRef };
+        valueNode = new ParameterReferenceNode(scope, paramExpr, value.paramRef, attr.type);
+    }
+    const eqAst = {
+        type: 'binary',
+        operator: '=',
+        left: colRef.expression,
+        right: valueNode.expression,
+    };
+    return new BinaryOpNode(scope, eqAst, colRef, valueNode);
+}
+function andTogether(scope, left, right) {
+    const ast = {
+        type: 'binary',
+        operator: 'AND',
+        left: left.expression,
+        right: right.expression,
+    };
+    return new BinaryOpNode(scope, ast, left, right);
+}
+function combineAnds(scope, conjuncts) {
+    let acc = conjuncts[0];
+    for (let i = 1; i < conjuncts.length; i++) {
+        acc = andTogether(scope, acc, conjuncts[i]);
+    }
+    return acc;
+}
+function valueSignature(value) {
+    if (value.kind === 'literal') {
+        const v = value.value;
+        if (v === null)
+            return 'lit:null';
+        if (v instanceof Uint8Array)
+            return `lit:blob:${Array.from(v).join(',')}`;
+        return `lit:${typeof v}:${String(v)}`;
+    }
+    return `param:${value.paramRef}`;
+}
+//# sourceMappingURL=rule-predicate-inference-equivalence.js.map

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

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

package/dist/src/planner/rules/predicate/rule-sargable-range-rewrite.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rule: Sargable Range Rewrite
+ *
+ * For predicates of the form `f(col) = c` where `f` is a monotone-but-lossy
+ * bucket conversion (e.g. `date(datetime_col) = '2024-01-15'`), rewrite the
+ * conjunct to a half-open range on the underlying column:
+ *
+ *   f(col) = c   →   col >= lower(c)  AND  col < upper(c)
+ *
+ * The half-open bounds come from `ScalarPlanNode.rangeRewriteIn(attrId, c)`,
+ * which delegates to `LogicalType.bucketBounds` on the column's logical type.
+ * The rewritten `col op literal` shape is what `analysis/constraint-extractor`
+ * already recognizes, so the resulting range can be pushed through
+ * `rule-predicate-pushdown` into the Retrieve pipeline and consumed by
+ * `rule-select-access-path` (IndexSeek, range scans, etc.).
+ *
+ * NULL semantics: a null constant is left alone (`f(col) = null` is already
+ * null, which WHERE / ON treat as false). A null column value satisfies neither
+ * `col >= L` nor `col < U` (both yield null), so row-rejection behavior
+ * matches the original predicate.
+ *
+ * Only the `=` shape is handled in this pass; `<`/`<=`/`>`/`>=` need direction
+ * analysis on `monotonicityIn` and asymmetric bound mapping — tracked
+ * separately in the optimization backlog.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext } from '../../framework/context.js';
+export declare function ruleSargableRangeRewrite(node: PlanNode, _context: OptContext): PlanNode | null;
+//# sourceMappingURL=rule-sargable-range-rewrite.d.ts.map

package/dist/src/planner/rules/predicate/rule-sargable-range-rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-sargable-range-rewrite.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/predicate/rule-sargable-range-rewrite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,0BAA0B,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAa7D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAuB9F"}

package/dist/src/planner/rules/predicate/rule-sargable-range-rewrite.js

@@ -0,0 +1,161 @@
+/**
+ * Rule: Sargable Range Rewrite
+ *
+ * For predicates of the form `f(col) = c` where `f` is a monotone-but-lossy
+ * bucket conversion (e.g. `date(datetime_col) = '2024-01-15'`), rewrite the
+ * conjunct to a half-open range on the underlying column:
+ *
+ *   f(col) = c   →   col >= lower(c)  AND  col < upper(c)
+ *
+ * The half-open bounds come from `ScalarPlanNode.rangeRewriteIn(attrId, c)`,
+ * which delegates to `LogicalType.bucketBounds` on the column's logical type.
+ * The rewritten `col op literal` shape is what `analysis/constraint-extractor`
+ * already recognizes, so the resulting range can be pushed through
+ * `rule-predicate-pushdown` into the Retrieve pipeline and consumed by
+ * `rule-select-access-path` (IndexSeek, range scans, etc.).
+ *
+ * NULL semantics: a null constant is left alone (`f(col) = null` is already
+ * null, which WHERE / ON treat as false). A null column value satisfies neither
+ * `col >= L` nor `col < U` (both yield null), so row-rejection behavior
+ * matches the original predicate.
+ *
+ * Only the `=` shape is handled in this pass; `<`/`<=`/`>`/`>=` need direction
+ * analysis on `monotonicityIn` and asymmetric bound mapping — tracked
+ * separately in the optimization backlog.
+ */
+import { createLogger } from '../../../common/logger.js';
+import { PlanNodeType } from '../../nodes/plan-node-type.js';
+import { FilterNode } from '../../nodes/filter.js';
+import { BinaryOpNode, LiteralNode } from '../../nodes/scalar.js';
+import { ColumnReferenceNode, ParameterReferenceNode } from '../../nodes/reference.js';
+import { splitConjuncts, combineConjuncts } from '../../analysis/predicate-conjuncts.js';
+import { getSyncLiteral } from '../../../parser/utils.js';
+const log = createLogger('optimizer:rule:sargable-range-rewrite');
+export function ruleSargableRangeRewrite(node, _context) {
+    if (node.nodeType !== PlanNodeType.Filter)
+        return null;
+    const filter = node;
+    const conjuncts = splitConjuncts(filter.predicate);
+    let rewrittenCount = 0;
+    const out = [];
+    for (const c of conjuncts) {
+        const rewritten = tryRewriteEqualityToRange(c);
+        if (rewritten) {
+            out.push(rewritten);
+            rewrittenCount++;
+        }
+        else {
+            out.push(c);
+        }
+    }
+    if (rewrittenCount === 0)
+        return null;
+    const combined = combineConjuncts(out);
+    if (!combined)
+        return null;
+    log('Rewrote %d sargable bucket-equality conjunct(s)', rewrittenCount);
+    return new FilterNode(filter.scope, filter.source, combined);
+}
+/**
+ * Recognize a `f(col) = const` conjunct and lift it to a half-open range on
+ * `col`. Returns the rewritten AND-tree on success, or `undefined` when the
+ * conjunct is not in the recognized shape / the function declines the rewrite.
+ */
+function tryRewriteEqualityToRange(expr) {
+    if (expr.nodeType !== PlanNodeType.BinaryOp)
+        return undefined;
+    const bin = expr;
+    if (bin.expression.operator !== '=')
+        return undefined;
+    // Exactly one side must be a literal constant; the other is the candidate
+    // function-shaped expression.
+    const leftLit = isLiteralConstant(bin.left);
+    const rightLit = isLiteralConstant(bin.right);
+    if (leftLit === rightLit)
+        return undefined; // both or neither
+    const literalSide = leftLit ? bin.left : bin.right;
+    const candidateSide = leftLit ? bin.right : bin.left;
+    const literalValue = getLiteralValue(literalSide);
+    if (literalValue === null)
+        return undefined;
+    // The candidate must depend on exactly one column attribute. Other leaves
+    // (literals / parameters) are fine — `rangeRewriteIn` itself enforces that
+    // the operand at the trait index is a bare ColumnReferenceNode.
+    const colRef = findUniqueColumnReference(candidateSide);
+    if (!colRef)
+        return undefined;
+    const bounds = candidateSide.rangeRewriteIn(colRef.attributeId, literalValue);
+    if (!bounds)
+        return undefined;
+    // Build `col >= L AND col < U` reusing the original ColumnReferenceNode (so
+    // the attribute id survives verbatim for downstream constraint extraction).
+    const scope = expr.scope;
+    const colType = colRef.getType();
+    const lower = makeComparison(scope, colRef, '>=', bounds.lowerInclusive, colType);
+    const upper = makeComparison(scope, colRef, '<', bounds.upperExclusive, colType);
+    const andAst = {
+        type: 'binary',
+        operator: 'AND',
+        left: lower.expression,
+        right: upper.expression,
+    };
+    return new BinaryOpNode(scope, andAst, lower, upper);
+}
+function makeComparison(scope, colRef, op, value, colType) {
+    const litExpr = { type: 'literal', value };
+    const literal = new LiteralNode(scope, litExpr, colType);
+    const ast = {
+        type: 'binary',
+        operator: op,
+        left: colRef.expression,
+        right: litExpr,
+    };
+    return new BinaryOpNode(scope, ast, colRef, literal);
+}
+/** Strip a planner-inserted CastNode wrapper. */
+function unwrapCast(node) {
+    return node.nodeType === PlanNodeType.Cast ? node.operand : node;
+}
+function isLiteralConstant(node) {
+    return unwrapCast(node).nodeType === PlanNodeType.Literal;
+}
+function getLiteralValue(node) {
+    const lit = unwrapCast(node);
+    return getSyncLiteral(lit.expression);
+}
+/**
+ * Walk the subtree's leaves and return the single `ColumnReferenceNode` if
+ * exactly one is found and every other leaf is a literal or parameter; return
+ * undefined for zero, two, or any unrecognized leaf shape (subqueries,
+ * function-of-other-column, etc.).
+ */
+function findUniqueColumnReference(node) {
+    let found;
+    let ok = true;
+    const visit = (n) => {
+        if (!ok)
+            return;
+        const children = n.getChildren();
+        if (children.length === 0) {
+            if (n instanceof ColumnReferenceNode) {
+                if (found && found !== n) {
+                    ok = false;
+                    return;
+                }
+                found = n;
+                return;
+            }
+            if (n instanceof LiteralNode || n instanceof ParameterReferenceNode) {
+                return;
+            }
+            ok = false;
+            return;
+        }
+        for (const c of children) {
+            visit(c);
+        }
+    };
+    visit(node);
+    return ok ? found : undefined;
+}
+//# sourceMappingURL=rule-sargable-range-rewrite.js.map

package/dist/src/planner/rules/predicate/rule-sargable-range-rewrite.js.map

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

package/dist/src/planner/rules/sort/rule-orderby-fd-pruning.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Rule: ORDER BY FD pruning
+ *
+ * Drops trailing ORDER BY keys that are functionally determined by the
+ * preceding bare-column keys under the source's FDs and equivalence classes.
+ *
+ * For a SortNode with ≥ 2 keys, walk the keys front-to-back maintaining
+ * `determined = closure({leading bare-column source-indices}, fds, ECs)`.
+ * Drop any trailing key whose expression is a bare `ColumnReferenceNode` and
+ * whose source-attribute index is already in `determined`. Direction and
+ * NULL placement on the dropped trailing key are irrelevant — once the
+ * preceding keys pin every value of that column to a single value per group,
+ * the trailing key cannot reorder anything.
+ *
+ * Sort-key matcher semantics: only bare `ColumnReferenceNode` keys
+ * participate in either direction of the reasoning. A non-bare-column key
+ * contributes nothing to `determined` (we can't prove what expression values
+ * "determine"), and a non-bare-column key cannot be dropped. The rule walks
+ * past non-bare keys treating them as opaque.
+ *
+ * Reasoning space: `fds`/`equivClasses` from `node.source.physical` are in
+ * source-attribute-INDEX space (positions in `source.getAttributes()`), NOT
+ * attribute IDs. The rule converts each sort-key's `ColumnReferenceNode.
+ * attributeId` to its source-attribute index before feeding `computeClosure`
+ * — mirroring how `SortNode.computePhysical` does its `leadIdx` lookup.
+ *
+ * Soundness: equality-class FDs from a `WHERE a = b` filter or a join key
+ * are sound here because every surviving row has equal values on the EC
+ * members, so the trailing key is a no-op tiebreaker.
+ *
+ * Ordering with other rules: this is a Structural-pass rule. It must run
+ * before `monotonic-limit-pushdown` (PostOptimization priority 8) so single-
+ * key reductions can enable the pushdown. That ordering is automatic since
+ * Structural runs before PostOptimization.
+ */
+import type { PlanNode } from '../../nodes/plan-node.js';
+import type { OptContext as _OptContext } from '../../framework/context.js';
+export declare function ruleOrderByFdPruning(node: PlanNode, _context: _OptContext): PlanNode | null;
+//# sourceMappingURL=rule-orderby-fd-pruning.d.ts.map

package/dist/src/planner/rules/sort/rule-orderby-fd-pruning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-orderby-fd-pruning.d.ts","sourceRoot":"","sources":["../../../../../src/planner/rules/sort/rule-orderby-fd-pruning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAO5E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAmD3F"}