@quereus/quereus 2.9.0 → 3.0.1

package/dist/src/planner/analysis/partial-unique-extraction.js

@@ -0,0 +1,347 @@
+/**
+ * Extract *guarded* FDs from partial UNIQUE constraints — those synthesized
+ * from `CREATE UNIQUE INDEX (K) WHERE P`. Inside the partial scope `P`, the
+ * columns `K` form a key, so `K → all_other_cols` holds; outside the scope
+ * the FD does not hold. We encode this as a guarded FD whose guard is the
+ * AND-conjunctive decomposition of `P` into clauses the FD-machinery can
+ * activate (see `GuardClause` in plan-node.ts).
+ *
+ * `TableReferenceNode.computePhysical` calls this alongside CHECK-derived
+ * FDs; Filter activation in `FilterNode` discharges the guard when a
+ * surrounding predicate entails every clause.
+ *
+ * Soundness rule: every conjunct of `P` must map to a recognized clause. A
+ * predicate with any unrecognized conjunct produces *no* FD — discharging on
+ * a weaker partial predicate would falsely activate the FD for rows the
+ * unrecognized conjunct excludes.
+ *
+ * Recognized conjunct shapes:
+ *   col = literal              ⇒ eq-literal
+ *   literal = col              ⇒ eq-literal (normalized)
+ *   col1 = col2                ⇒ eq-column
+ *   col IS NULL                ⇒ is-null (negated:false)
+ *   col IS NOT NULL            ⇒ is-null (negated:true)
+ *   NOT col  (NOT-NULL numeric col) ⇒ eq-literal { col, value: 0 }    (SQL false)
+ *   col IN (lit, lit, …)       ⇒ or-of [eq-literal …] (singleton collapses)
+ *   a OR b OR …                ⇒ or-of [recognize(a), recognize(b), …]
+ *   col >  literal             ⇒ range { col, min: lit, minInc: false, maxInc: false }
+ *   col >= literal             ⇒ range { col, min: lit, minInc: true,  maxInc: false }
+ *   col <  literal             ⇒ range { col, max: lit, maxInc: false, minInc: false }
+ *   col <= literal             ⇒ range { col, max: lit, maxInc: true,  minInc: false }
+ *   literal op col             ⇒ flipped to col op' literal, then as above
+ *   col BETWEEN lo AND hi      ⇒ range { col, min: lo, max: hi, minInc: true, maxInc: true }
+ *
+ * `NOT col` is rewritten to `col = 0` (SQLite encodes boolean FALSE as 0).
+ * This excludes NULL rows semantically — but the NOT-NULL gate below is
+ * syntactic, so `NOT col` on a nominally-nullable UC column is rejected to
+ * avoid double-counting that exclusion across producer and consumer. The
+ * rewrite is additionally gated on the column's logical type being numeric:
+ * for TEXT/BLOB/BOOLEAN columns `col = 0` is not equivalent to `NOT col`
+ * (TEXT `''` is falsy but is not equal-to-integer-0 under the strict
+ * `sqlValueEquals` comparison used by the consumer), so the rewrite would
+ * falsely activate a `col = 0` guard for rows the runtime UC never excluded.
+ *
+ * NOT-NULL gate: every UC column must be effectively non-NULL inside the
+ * partial scope. A column qualifies if either (a) it is declared NOT NULL on
+ * the table, or (b) the partial predicate has a matching `col IS NOT NULL`
+ * conjunct. Case (b) is sound because the FD only activates when a
+ * surrounding predicate entails every guard clause, including that
+ * `IS NOT NULL` clause — so discharge cannot falsely activate the FD over
+ * rows where the UC column could be NULL. A nullable UC column whose
+ * `IS NOT NULL` is not in the predicate would allow multiple NULLs inside
+ * scope, so `K → others` would not hold; those are rejected. Mirrors the
+ * relation-level rule in `relationTypeFromTableSchema` (type-utils.ts),
+ * relaxed for partial scopes that establish non-nullness themselves.
+ *
+ * Out-of-scope shapes (filed as backlog tickets in the implement ticket):
+ *   - function-call / cast-wrapped column references in IN / NOT shapes
+ *   - standalone `col` (truthy test) — only `NOT col` is recognized
+ *   - IN / NOT / OR inside CHECK implication disjuncts
+ *   - NOT BETWEEN (decomposes to a disjunction of two ranges)
+ *   - symbolic/parameter range bounds (`age >= ?`)
+ *   - per-column collation-aware text bound comparison
+ */
+import { columnIndexFromExpr, flattenDisjunction, flipComparison, literalValue } from './predicate-shape.js';
+const cache = new WeakMap();
+export function getPartialUniqueGuardedFds(tableSchema) {
+    let cached = cache.get(tableSchema);
+    if (!cached) {
+        cached = extractPartialUniqueGuardedFds(tableSchema);
+        cache.set(tableSchema, cached);
+    }
+    return cached;
+}
+export function extractPartialUniqueGuardedFds(tableSchema) {
+    const out = [];
+    const ucs = tableSchema.uniqueConstraints;
+    if (!ucs)
+        return out;
+    const colCount = tableSchema.columns.length;
+    const isColumnNotNullDeclared = (col) => tableSchema.columns[col]?.notNull === true;
+    const isColumnNumericDeclared = (col) => tableSchema.columns[col]?.logicalType?.isNumeric === true;
+    for (const uc of ucs) {
+        if (uc.predicate === undefined)
+            continue;
+        const clauses = recognizeGuardClauses(uc.predicate, tableSchema.columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared);
+        if (!clauses)
+            continue;
+        if (clauses.length === 0)
+            continue;
+        // NOT-NULL gate: each UC column must be effectively non-NULL inside the
+        // partial scope — either declared NOT NULL, or forced so by an
+        // `IS NOT NULL` conjunct of the partial predicate (which is one of the
+        // guard clauses, so discharge will require it).
+        const nonNullByPredicate = new Set();
+        for (const c of clauses) {
+            if (c.kind === 'is-null' && c.negated === true)
+                nonNullByPredicate.add(c.column);
+        }
+        const allUcColumnsNonNullable = uc.columns.every(idx => tableSchema.columns[idx]?.notNull === true || nonNullByPredicate.has(idx));
+        if (!allUcColumnsNonNullable)
+            continue;
+        const det = Array.from(uc.columns);
+        const detSet = new Set(det);
+        const dep = [];
+        for (let i = 0; i < colCount; i++) {
+            if (!detSet.has(i))
+                dep.push(i);
+        }
+        if (dep.length === 0)
+            continue;
+        const guard = { clauses };
+        out.push({ determinants: det, dependents: dep, guard });
+    }
+    return out;
+}
+/**
+ * Decompose a partial-index predicate into AND-conjunctive guard clauses.
+ *
+ * Returns `undefined` (NOT `[]`) if any conjunct fails to map to a recognized
+ * `GuardClause` — the entire FD must be skipped in that case. Returns `[]`
+ * only for trivially empty inputs (which the caller treats as "no FD").
+ */
+function recognizeGuardClauses(expr, columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared) {
+    const conjuncts = [];
+    const stack = [expr];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        if (cur.type === 'binary' && cur.operator === 'AND') {
+            const b = cur;
+            // Preserve textual order: push right then left so left is processed first.
+            stack.push(b.right, b.left);
+            continue;
+        }
+        conjuncts.push(cur);
+    }
+    const clauses = [];
+    for (const conjunct of conjuncts) {
+        const clause = recognizeClause(conjunct, columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared);
+        if (!clause)
+            return undefined;
+        clauses.push(clause);
+    }
+    return clauses;
+}
+/**
+ * Recognize one conjunct (or disjunct, when called recursively from
+ * `recognizeOr`) as a guard clause.
+ *
+ * Accepted shapes:
+ *   col = literal       ⇒ eq-literal { column, value }
+ *   literal = col       ⇒ eq-literal { column, value }     (normalized)
+ *   col1 = col2         ⇒ eq-column  { left, right }
+ *   col IS NULL         ⇒ is-null    { column, negated:false }
+ *   col IS NOT NULL     ⇒ is-null    { column, negated:true }
+ *   NOT col             ⇒ eq-literal { column, value: 0 }   (declared NOT NULL + numeric only)
+ *   col IN (lit, …)     ⇒ or-of [eq-literal { col, lit_i } …]
+ *   a OR b OR …         ⇒ or-of [recognize(a), recognize(b), …]
+ *   col >  literal      ⇒ range { col, min: lit, minInc: false, maxInc: false }
+ *   col >= literal      ⇒ range { col, min: lit, minInc: true,  maxInc: false }
+ *   col <  literal      ⇒ range { col, max: lit, maxInc: false, minInc: false }
+ *   col <= literal      ⇒ range { col, max: lit, maxInc: true,  minInc: false }
+ *   literal op col      ⇒ flipped to col op' literal, then as above
+ *   col BETWEEN lo AND hi ⇒ range { col, min: lo, max: hi, minInc: true, maxInc: true }
+ *
+ * `=` and `==` are interchangeable. NULL-literal bounds are rejected. Anything
+ * else returns undefined — the whole predicate is then dropped on the floor
+ * by the caller.
+ *
+ * For `NOT col`, only declared-NOT-NULL **and** declared-numeric columns are
+ * accepted: the rewrite to `col = 0` implicitly excludes NULL rows, but the
+ * NOT-NULL gate for the UC is syntactic. Rather than teach the gate about
+ * `NOT col`, the simpler/sound choice is to reject `NOT col` on
+ * nominally-nullable columns at the producer. The numeric gate is required
+ * because `col = 0` (under strict `sqlValueEquals`) only matches numeric
+ * zero — TEXT `''` and BOOLEAN `false` are falsy but compare unequal to
+ * integer 0, so the rewrite would falsely activate the FD for rows the
+ * runtime UC never excluded.
+ */
+function recognizeClause(expr, columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared) {
+    if (expr.type === 'unary') {
+        const u = expr;
+        if (u.operator === 'IS NULL' || u.operator === 'IS NOT NULL') {
+            const col = columnIndexFromExpr(u.expr, columnIndexMap);
+            if (col === undefined)
+                return undefined;
+            return { kind: 'is-null', column: col, negated: u.operator === 'IS NOT NULL' };
+        }
+        if (u.operator === 'NOT') {
+            const col = columnIndexFromExpr(u.expr, columnIndexMap);
+            if (col === undefined)
+                return undefined;
+            if (!isColumnNotNullDeclared(col))
+                return undefined;
+            if (!isColumnNumericDeclared(col))
+                return undefined;
+            return { kind: 'eq-literal', column: col, value: 0 };
+        }
+        return undefined;
+    }
+    if (expr.type === 'in') {
+        return recognizeIn(expr, columnIndexMap);
+    }
+    if (expr.type === 'between') {
+        return recognizeBetween(expr, columnIndexMap);
+    }
+    if (expr.type === 'binary') {
+        const b = expr;
+        if (b.operator === 'OR') {
+            return recognizeOr(b, columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared);
+        }
+        if (b.operator === '=' || b.operator === '==') {
+            const lIdx = columnIndexFromExpr(b.left, columnIndexMap);
+            const rIdx = columnIndexFromExpr(b.right, columnIndexMap);
+            if (lIdx !== undefined && rIdx !== undefined) {
+                if (lIdx === rIdx)
+                    return undefined;
+                return { kind: 'eq-column', left: lIdx, right: rIdx };
+            }
+            if (lIdx !== undefined) {
+                const lit = literalValue(b.right);
+                if (lit === undefined)
+                    return undefined;
+                return { kind: 'eq-literal', column: lIdx, value: lit };
+            }
+            if (rIdx !== undefined) {
+                const lit = literalValue(b.left);
+                if (lit === undefined)
+                    return undefined;
+                return { kind: 'eq-literal', column: rIdx, value: lit };
+            }
+            return undefined;
+        }
+        if (b.operator === '<' || b.operator === '<=' || b.operator === '>' || b.operator === '>=') {
+            return recognizeRange(b, columnIndexMap);
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Recognize `col op literal` (or operand-flipped `literal op col`) as a range
+ * guard. NULL literal bounds are rejected.
+ */
+function recognizeRange(b, columnIndexMap) {
+    const lIdx = columnIndexFromExpr(b.left, columnIndexMap);
+    const rIdx = columnIndexFromExpr(b.right, columnIndexMap);
+    let colIdx;
+    let lit;
+    let op;
+    if (lIdx !== undefined) {
+        lit = literalValue(b.right);
+        colIdx = lIdx;
+        op = b.operator;
+    }
+    else if (rIdx !== undefined) {
+        lit = literalValue(b.left);
+        colIdx = rIdx;
+        op = flipComparison(b.operator);
+    }
+    else {
+        return undefined;
+    }
+    if (lit === undefined || lit === null || colIdx === undefined)
+        return undefined;
+    switch (op) {
+        case '>':
+            return { kind: 'range', column: colIdx, min: lit, minInclusive: false, maxInclusive: false };
+        case '>=':
+            return { kind: 'range', column: colIdx, min: lit, minInclusive: true, maxInclusive: false };
+        case '<':
+            return { kind: 'range', column: colIdx, max: lit, minInclusive: false, maxInclusive: false };
+        case '<=':
+            return { kind: 'range', column: colIdx, max: lit, minInclusive: false, maxInclusive: true };
+    }
+    return undefined;
+}
+/**
+ * Recognize `col BETWEEN literal AND literal` as a closed-interval range
+ * guard. `NOT BETWEEN` is rejected (decomposes to a disjunction of two range
+ * halves which doesn't fit a single range clause).
+ */
+function recognizeBetween(expr, columnIndexMap) {
+    if (expr.not === true)
+        return undefined;
+    const colIdx = columnIndexFromExpr(expr.expr, columnIndexMap);
+    if (colIdx === undefined)
+        return undefined;
+    const lo = literalValue(expr.lower);
+    const hi = literalValue(expr.upper);
+    if (lo === undefined || lo === null)
+        return undefined;
+    if (hi === undefined || hi === null)
+        return undefined;
+    return { kind: 'range', column: colIdx, min: lo, max: hi, minInclusive: true, maxInclusive: true };
+}
+/**
+ * Recognize `col IN (lit, lit, …)` as an `or-of` of `eq-literal` clauses.
+ * IN-with-subquery, non-literal values, or any other shape returns undefined.
+ * A singleton list collapses to a bare `eq-literal`.
+ */
+function recognizeIn(expr, columnIndexMap) {
+    if (expr.subquery !== undefined)
+        return undefined;
+    if (!expr.values || expr.values.length === 0)
+        return undefined;
+    const col = columnIndexFromExpr(expr.expr, columnIndexMap);
+    if (col === undefined)
+        return undefined;
+    const subs = [];
+    for (const v of expr.values) {
+        const lit = literalValue(v);
+        if (lit === undefined)
+            return undefined;
+        subs.push({ kind: 'eq-literal', column: col, value: lit });
+    }
+    if (subs.length === 1)
+        return subs[0];
+    return { kind: 'or-of', clauses: subs };
+}
+/**
+ * Recognize a top-level `OR` chain as a flat `or-of`. Each disjunct must
+ * itself be a recognized clause. Nested `or-of` clauses are inlined so the
+ * result is single-level. A singleton (degenerate) collapses to the
+ * underlying clause.
+ */
+function recognizeOr(expr, columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared) {
+    const disjuncts = flattenDisjunction(expr);
+    if (disjuncts.length === 0)
+        return undefined;
+    const subs = [];
+    for (const d of disjuncts) {
+        const sub = recognizeClause(d, columnIndexMap, isColumnNotNullDeclared, isColumnNumericDeclared);
+        if (!sub)
+            return undefined;
+        if (sub.kind === 'or-of') {
+            for (const s of sub.clauses)
+                subs.push(s);
+        }
+        else {
+            subs.push(sub);
+        }
+    }
+    if (subs.length === 1)
+        return subs[0];
+    return { kind: 'or-of', clauses: subs };
+}
+//# sourceMappingURL=partial-unique-extraction.js.map

package/dist/src/planner/analysis/partial-unique-extraction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-unique-extraction.js","sourceRoot":"","sources":["../../../../src/planner/analysis/partial-unique-extraction.ts"],"names":[],"mappings":"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"}

package/dist/src/planner/analysis/predicate-conjuncts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Conjunct helpers for predicate rewriting.
+ *
+ * `splitConjuncts` flattens an AND-tree into its individual conjuncts;
+ * `combineConjuncts` rebuilds an AND-tree from a list. Operators that need to
+ * partition / push / inspect predicates conjunct-by-conjunct (subquery
+ * decorrelation, aggregate predicate pushdown, etc.) share these.
+ */
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+/** Split an AND-tree into its conjuncts. Non-AND predicates yield a single-element list. */
+export declare function splitConjuncts(pred: ScalarPlanNode): ScalarPlanNode[];
+/** Combine conjuncts back into a left-associative AND-tree; returns null when empty. */
+export declare function combineConjuncts(conjuncts: ScalarPlanNode[]): ScalarPlanNode | null;
+//# sourceMappingURL=predicate-conjuncts.d.ts.map

package/dist/src/planner/analysis/predicate-conjuncts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-conjuncts.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/predicate-conjuncts.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,4FAA4F;AAC5F,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,GAAG,cAAc,EAAE,CAYrE;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,cAAc,EAAE,GAAG,cAAc,GAAG,IAAI,CAUnF"}

package/dist/src/planner/analysis/predicate-conjuncts.js

@@ -0,0 +1,31 @@
+/**
+ * Conjunct helpers for predicate rewriting.
+ *
+ * `splitConjuncts` flattens an AND-tree into its individual conjuncts;
+ * `combineConjuncts` rebuilds an AND-tree from a list. Operators that need to
+ * partition / push / inspect predicates conjunct-by-conjunct (subquery
+ * decorrelation, aggregate predicate pushdown, etc.) share these.
+ */
+import { BinaryOpNode } from '../nodes/scalar.js';
+/** Split an AND-tree into its conjuncts. Non-AND predicates yield a single-element list. */
+export function splitConjuncts(pred) {
+    const result = [];
+    const stack = [pred];
+    while (stack.length) {
+        const n = stack.pop();
+        if (n instanceof BinaryOpNode && n.expression.operator === 'AND') {
+            stack.push(n.left, n.right);
+        }
+        else {
+            result.push(n);
+        }
+    }
+    return result;
+}
+/** Combine conjuncts back into a left-associative AND-tree; returns null when empty. */
+export function combineConjuncts(conjuncts) {
+    if (conjuncts.length === 0)
+        return null;
+    return conjuncts.reduce((acc, cur) => new BinaryOpNode(cur.scope, { type: 'binary', operator: 'AND', left: acc.expression, right: cur.expression }, acc, cur));
+}
+//# sourceMappingURL=predicate-conjuncts.js.map

package/dist/src/planner/analysis/predicate-conjuncts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-conjuncts.js","sourceRoot":"","sources":["../../../../src/planner/analysis/predicate-conjuncts.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,4FAA4F;AAC5F,MAAM,UAAU,cAAc,CAAC,IAAoB;IAClD,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,MAAM,KAAK,GAAqB,CAAC,IAAI,CAAC,CAAC;IACvC,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC;QACrB,MAAM,CAAC,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QACvB,IAAI,CAAC,YAAY,YAAY,IAAI,CAAC,CAAC,UAAU,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;YAClE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACP,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAChB,CAAC;IACF,CAAC;IACD,OAAO,MAAM,CAAC;AACf,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,gBAAgB,CAAC,SAA2B;IAC3D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CACpC,IAAI,YAAY,CACf,GAAG,CAAC,KAAK,EACT,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,UAAU,EAAE,KAAK,EAAE,GAAG,CAAC,UAAU,EAAE,EAChF,GAAG,EACH,GAAG,CACH,CACD,CAAC;AACH,CAAC"}

package/dist/src/planner/analysis/predicate-shape.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shape recognizers for declared-predicate AST trees (CHECK constraints,
+ * partial-index WHERE clauses). Shared by `check-extraction.ts` and
+ * `partial-unique-extraction.ts`; both pull `col`-style references, literal
+ * values, and "which columns are mentioned anywhere" out of small AST shapes.
+ *
+ * These helpers are intentionally syntactic — they do not interpret types,
+ * collations, or coercions. Callers wanting semantic equivalence should layer
+ * that on top.
+ */
+import type * as AST from '../../parser/ast.js';
+import type { SqlValue } from '../../common/types.js';
+/**
+ * Return the column index for an `AST.ColumnExpr` or unqualified
+ * `AST.IdentifierExpr` that names a column in `columnIndexMap`; undefined
+ * otherwise. Schema-qualified identifiers (`other.foo`) are rejected.
+ */
+export declare function columnIndexFromExpr(expr: AST.Expression, columnIndexMap: ReadonlyMap<string, number>): number | undefined;
+/**
+ * Return the literal `SqlValue` for an `AST.LiteralExpr`, or undefined for any
+ * other expression shape (functions, casts, casts-of-literals, etc.). Only
+ * compile-time literals count for binding/domain purposes.
+ */
+export declare function literalValue(expr: AST.Expression): SqlValue | undefined;
+/**
+ * Flip a comparison operator across its operands: if you rewrite `b op a` as
+ * `a flipComparison(op) b`, the truth value is preserved. Unrecognized
+ * operators (including `=`/`==`) round-trip unchanged.
+ *
+ * Used by `partial-unique-extraction.ts`, `check-extraction.ts`, and
+ * `fd-utils.ts` to normalize `lit op col` into `col flipped lit`. Distinct
+ * from predicate negation (the same-named `flipComparison` in
+ * `predicate-normalizer.ts` returns `NOT op` instead of `swap-operands op`).
+ */
+export declare function flipComparison(op: string): string;
+/**
+ * Flatten a top-level `OR` chain into an array of disjunct expressions.
+ * Non-OR roots return as a single-element array. Textual order is preserved.
+ *
+ * Shared by `check-extraction.ts` (implication-form CHECK recognition) and
+ * `partial-unique-extraction.ts` (top-level OR guard recognition).
+ */
+export declare function flattenDisjunction(expr: AST.Expression): AST.Expression[];
+/**
+ * Collect the set of column indices referenced by `expr`. Only column /
+ * identifier nodes naming columns in `columnIndexMap` count. Returns an empty
+ * set when the expression references zero recognized columns; the caller can
+ * distinguish "no columns" (constant expression) from "exactly one column"
+ * by inspecting the size.
+ */
+export declare function collectColumnNames(expr: AST.Expression, columnIndexMap: ReadonlyMap<string, number>): Set<number>;
+//# sourceMappingURL=predicate-shape.d.ts.map

package/dist/src/planner/analysis/predicate-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-shape.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/predicate-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,GAAG,CAAC,UAAU,EACpB,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,MAAM,GAAG,SAAS,CAWpB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,GAAG,QAAQ,GAAG,SAAS,CAMvE;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQjD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,EAAE,CAczE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,GAAG,CAAC,UAAU,EACpB,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACzC,GAAG,CAAC,MAAM,CAAC,CAwBb"}

package/dist/src/planner/analysis/predicate-shape.js

@@ -0,0 +1,119 @@
+/**
+ * Shape recognizers for declared-predicate AST trees (CHECK constraints,
+ * partial-index WHERE clauses). Shared by `check-extraction.ts` and
+ * `partial-unique-extraction.ts`; both pull `col`-style references, literal
+ * values, and "which columns are mentioned anywhere" out of small AST shapes.
+ *
+ * These helpers are intentionally syntactic — they do not interpret types,
+ * collations, or coercions. Callers wanting semantic equivalence should layer
+ * that on top.
+ */
+/**
+ * Return the column index for an `AST.ColumnExpr` or unqualified
+ * `AST.IdentifierExpr` that names a column in `columnIndexMap`; undefined
+ * otherwise. Schema-qualified identifiers (`other.foo`) are rejected.
+ */
+export function columnIndexFromExpr(expr, columnIndexMap) {
+    if (expr.type === 'column') {
+        const ref = expr;
+        return columnIndexMap.get(ref.name.toLowerCase());
+    }
+    if (expr.type === 'identifier') {
+        const ref = expr;
+        if (ref.schema)
+            return undefined;
+        return columnIndexMap.get(ref.name.toLowerCase());
+    }
+    return undefined;
+}
+/**
+ * Return the literal `SqlValue` for an `AST.LiteralExpr`, or undefined for any
+ * other expression shape (functions, casts, casts-of-literals, etc.). Only
+ * compile-time literals count for binding/domain purposes.
+ */
+export function literalValue(expr) {
+    if (expr.type !== 'literal')
+        return undefined;
+    const lit = expr;
+    const v = lit.value;
+    if (v instanceof Promise)
+        return undefined;
+    return v;
+}
+/**
+ * Flip a comparison operator across its operands: if you rewrite `b op a` as
+ * `a flipComparison(op) b`, the truth value is preserved. Unrecognized
+ * operators (including `=`/`==`) round-trip unchanged.
+ *
+ * Used by `partial-unique-extraction.ts`, `check-extraction.ts`, and
+ * `fd-utils.ts` to normalize `lit op col` into `col flipped lit`. Distinct
+ * from predicate negation (the same-named `flipComparison` in
+ * `predicate-normalizer.ts` returns `NOT op` instead of `swap-operands op`).
+ */
+export function flipComparison(op) {
+    switch (op) {
+        case '<': return '>';
+        case '<=': return '>=';
+        case '>': return '<';
+        case '>=': return '<=';
+        default: return op;
+    }
+}
+/**
+ * Flatten a top-level `OR` chain into an array of disjunct expressions.
+ * Non-OR roots return as a single-element array. Textual order is preserved.
+ *
+ * Shared by `check-extraction.ts` (implication-form CHECK recognition) and
+ * `partial-unique-extraction.ts` (top-level OR guard recognition).
+ */
+export function flattenDisjunction(expr) {
+    const out = [];
+    const stack = [expr];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        if (cur.type === 'binary' && cur.operator === 'OR') {
+            const b = cur;
+            // Preserve textual order: push right then left so left is popped first.
+            stack.push(b.right, b.left);
+            continue;
+        }
+        out.push(cur);
+    }
+    return out;
+}
+/**
+ * Collect the set of column indices referenced by `expr`. Only column /
+ * identifier nodes naming columns in `columnIndexMap` count. Returns an empty
+ * set when the expression references zero recognized columns; the caller can
+ * distinguish "no columns" (constant expression) from "exactly one column"
+ * by inspecting the size.
+ */
+export function collectColumnNames(expr, columnIndexMap) {
+    const out = new Set();
+    const stack = [expr];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        const idx = node.type === 'column' || node.type === 'identifier'
+            ? columnIndexFromExpr(node, columnIndexMap)
+            : undefined;
+        if (idx !== undefined)
+            out.add(idx);
+        for (const key of Object.keys(node)) {
+            const v = node[key];
+            if (!v)
+                continue;
+            if (Array.isArray(v)) {
+                for (const item of v) {
+                    if (item && typeof item === 'object' && 'type' in item) {
+                        stack.push(item);
+                    }
+                }
+            }
+            else if (typeof v === 'object' && 'type' in v) {
+                stack.push(v);
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=predicate-shape.js.map

package/dist/src/planner/analysis/predicate-shape.js.map

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

package/dist/src/planner/analysis/sat-checker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Per-column constraint-satisfiability checker.
+ *
+ * Folds the conjunction of (predicate conjuncts ∧ source domain constraints ∧
+ * literal constant bindings) into per-column accumulators, then asks:
+ * "is there any value of every mentioned column that satisfies every fact?"
+ *
+ * The fragment is intentionally narrow:
+ *   - Single-column comparisons against literals (= / == / != / < / <= / > / >=).
+ *   - Single-column BETWEEN literal AND literal (positive form).
+ *   - Single-column IN (lit, lit, ...) and intersection across IN-lists.
+ *     The empty form `x IN ()` is also recognized as trivially `unsat`.
+ *   - Range from `DomainConstraint { kind: 'range' }`.
+ *   - Enum from `DomainConstraint { kind: 'enum' }`.
+ *   - Literal `ConstantBinding`.
+ *
+ * Everything else (LIKE, function calls, cross-column comparisons, OR-trees,
+ * CASE, IS NULL, NOT IN with non-literal RHS, …) marks the touched columns as
+ * `sawUnknown`. The checker only ever returns `unsat` when an in-scope subset
+ * proves a contradiction — false positives are never emitted.
+ *
+ * Used by `rule-filter-contradiction` to recognize `Filter(child, false)` cases
+ * that const-folding can then collapse to `EmptyRelationNode`.
+ */
+import type { ScalarPlanNode, DomainConstraint, ConstantBinding } from '../nodes/plan-node.js';
+export type SatResult = 'sat' | 'unsat' | 'unknown';
+/**
+ * Returns `'unsat'` iff the conjunction is provably contradictory within the
+ * supported fragment; `'sat'` when no contradiction is found and every
+ * mentioned clause was in scope; `'unknown'` otherwise. Never returns false
+ * `'unsat'`.
+ *
+ * `attrIndex(attrId)` maps an attribute id visible to the predicate's
+ * `ColumnReferenceNode`s back to the physical column index used by
+ * `domains` / `bindings`. Pass an identity-style mapper if the caller has
+ * already aligned them.
+ *
+ * `getCollation(col)` is optional; when supplied, equality / range comparisons
+ * for that column use the named collation (TEXT only — numeric comparisons are
+ * collation-independent). Defaults to BINARY.
+ */
+export declare function checkSatisfiability(conjuncts: ReadonlyArray<ScalarPlanNode>, domains: ReadonlyArray<DomainConstraint>, bindings: ReadonlyArray<ConstantBinding>, attrIndex: (attrId: number) => number | undefined, getCollation?: (col: number) => string | undefined): SatResult;
+//# sourceMappingURL=sat-checker.d.ts.map

package/dist/src/planner/analysis/sat-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sat-checker.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/sat-checker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EACX,cAAc,EACd,gBAAgB,EAChB,eAAe,EACf,MAAM,uBAAuB,CAAC;AAe/B,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAC;AAyBpD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,aAAa,CAAC,cAAc,CAAC,EACxC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,EACxC,QAAQ,EAAE,aAAa,CAAC,eAAe,CAAC,EACxC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EACjD,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,GAChD,SAAS,CA6EX"}