@quereus/quereus 2.8.0 → 3.0.0

package/dist/src/planner/util/fd-utils.js

@@ -0,0 +1,1416 @@
+/**
+ * Functional dependency (FD) and equivalence-class (EC) helpers used by
+ * `computePhysical` on relational plan nodes. See `docs/optimizer.md`
+ * section "Functional Dependency Tracking" for the propagation table and
+ * design rationale.
+ */
+import { createLogger } from '../../common/logger.js';
+import { ColumnReferenceNode, ParameterReferenceNode } from '../nodes/reference.js';
+import { BetweenNode, BinaryOpNode, CastNode, CollateNode, LiteralNode, UnaryOpNode } from '../nodes/scalar.js';
+import { InNode } from '../nodes/subquery.js';
+import { compareSqlValues } from '../../util/comparison.js';
+import { flipComparison } from '../analysis/predicate-shape.js';
+const log = createLogger('planner:fd');
+/**
+ * Per-node cap on the number of FDs we materialize. The propagation rules
+ * are conservative enough that hitting this in practice is rare; the cap
+ * is a safety valve for pathological plans.
+ */
+export const MAX_FDS_PER_NODE = 64;
+/**
+ * Closure of `attrs` under `fds`. Iterative fixed-point.
+ *
+ * Guarded FDs (`fd.guard !== undefined`) are skipped — they are only valid
+ * under a surrounding predicate, and the closure layer has no notion of one.
+ * Filter activation strips the guard before the FD reaches closure consumers.
+ *
+ * O(|fds| × growth) — terminates when no new attribute is added in a pass.
+ */
+export function computeClosure(attrs, fds) {
+    const closure = new Set(attrs);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const fd of fds) {
+            if (fd.guard !== undefined)
+                continue;
+            if (fd.determinants.every(d => closure.has(d))) {
+                for (const dep of fd.dependents) {
+                    if (!closure.has(dep)) {
+                        closure.add(dep);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    return closure;
+}
+/**
+ * Expand a list of equivalence classes into bi-directional FDs over the same
+ * column indices, then concatenate with the existing FDs. For a class
+ * `{c0, c1, ..., ck}` this emits `{ci} → {cj}` for every distinct ordered pair
+ * — enough for `computeClosure` to derive every member from any one of them.
+ */
+export function expandEcsToFds(ecs, fds) {
+    const out = fds.slice();
+    for (const cls of ecs) {
+        if (cls.length < 2)
+            continue;
+        for (let i = 0; i < cls.length; i++) {
+            for (let j = 0; j < cls.length; j++) {
+                if (i === j)
+                    continue;
+                out.push({ determinants: [cls[i]], dependents: [cls[j]] });
+            }
+        }
+    }
+    return out;
+}
+/** True iff `attrs` determines every attribute in `target` under `fds`. */
+export function determines(attrs, target, fds) {
+    if (target.size === 0)
+        return true;
+    const closure = computeClosure(attrs, fds);
+    for (const t of target) {
+        if (!closure.has(t))
+            return false;
+    }
+    return true;
+}
+/**
+ * Smallest subset of `attrs` whose closure equals the closure of `attrs`.
+ * Greedy minimization: try dropping each attribute; keep the drop iff the
+ * resulting closure is unchanged. O(|attrs|² × |fds|).
+ */
+export function minimalCover(attrs, fds) {
+    const fullClosure = computeClosure(attrs, fds);
+    const result = new Set(attrs);
+    for (const a of [...result]) {
+        const trial = new Set(result);
+        trial.delete(a);
+        const trialClosure = computeClosure(trial, fds);
+        if (trialClosure.size === fullClosure.size) {
+            let same = true;
+            for (const x of fullClosure) {
+                if (!trialClosure.has(x)) {
+                    same = false;
+                    break;
+                }
+            }
+            if (same)
+                result.delete(a);
+        }
+    }
+    return result;
+}
+// Structural-only equality: compares determinants/dependents/guard. The
+// optional `source` provenance tag (`declared-check` vs `assertion`) is NOT
+// compared here, so two structurally-identical FDs from different sources
+// collapse to one in `addFd` / `mergeFds`. The first-merged source wins —
+// table references merge declared-check contributions before hoisted
+// assertion contributions, so `declared-check` is preferred on collisions.
+function fdsEqual(a, b) {
+    if (a.determinants.length !== b.determinants.length)
+        return false;
+    if (a.dependents.length !== b.dependents.length)
+        return false;
+    const aDet = new Set(a.determinants);
+    for (const d of b.determinants)
+        if (!aDet.has(d))
+            return false;
+    const aDep = new Set(a.dependents);
+    for (const d of b.dependents)
+        if (!aDep.has(d))
+            return false;
+    return guardsEqual(a.guard, b.guard);
+}
+function guardsEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.clauses.length !== b.clauses.length)
+        return false;
+    // Order-insensitive clause comparison.
+    const used = new Array(b.clauses.length).fill(false);
+    for (const ac of a.clauses) {
+        let matched = false;
+        for (let i = 0; i < b.clauses.length; i++) {
+            if (used[i])
+                continue;
+            if (guardClauseEquals(ac, b.clauses[i])) {
+                used[i] = true;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+function guardClauseEquals(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === 'eq-literal' && b.kind === 'eq-literal') {
+        return a.column === b.column && sqlValueEquals(a.value, b.value);
+    }
+    if (a.kind === 'eq-column' && b.kind === 'eq-column') {
+        // Order-insensitive on left/right.
+        return (a.left === b.left && a.right === b.right)
+            || (a.left === b.right && a.right === b.left);
+    }
+    if (a.kind === 'is-null' && b.kind === 'is-null') {
+        return a.column === b.column && a.negated === b.negated;
+    }
+    if (a.kind === 'range' && b.kind === 'range') {
+        if (a.column !== b.column)
+            return false;
+        const aHasMin = a.min !== undefined;
+        const bHasMin = b.min !== undefined;
+        if (aHasMin !== bHasMin)
+            return false;
+        if (aHasMin && !sqlValueEquals(a.min, b.min))
+            return false;
+        if (aHasMin && a.minInclusive !== b.minInclusive)
+            return false;
+        const aHasMax = a.max !== undefined;
+        const bHasMax = b.max !== undefined;
+        if (aHasMax !== bHasMax)
+            return false;
+        if (aHasMax && !sqlValueEquals(a.max, b.max))
+            return false;
+        if (aHasMax && a.maxInclusive !== b.maxInclusive)
+            return false;
+        return true;
+    }
+    if (a.kind === 'or-of' && b.kind === 'or-of') {
+        if (a.clauses.length !== b.clauses.length)
+            return false;
+        // Order-insensitive sub-clause comparison.
+        const used = new Array(b.clauses.length).fill(false);
+        for (const ac of a.clauses) {
+            let matched = false;
+            for (let i = 0; i < b.clauses.length; i++) {
+                if (used[i])
+                    continue;
+                if (guardClauseEquals(ac, b.clauses[i])) {
+                    used[i] = true;
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched)
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+function determinantsEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const aSet = new Set(a);
+    for (const x of b)
+        if (!aSet.has(x))
+            return false;
+    return true;
+}
+function dependentsSubset(sub, sup) {
+    const supSet = new Set(sup);
+    for (const x of sub)
+        if (!supSet.has(x))
+            return false;
+    return true;
+}
+/**
+ * Add a single FD, dropping any existing entry with the same determinants
+ * (and same guard) whose dependents are a subset of the new one (subsumption).
+ * When the resulting list exceeds the cap, drop FDs whose determinants are
+ * not a subset of any `keyHints` entry on the same node.
+ *
+ * Guard-aware: FDs with different `guard` predicates are kept side-by-side
+ * even when their determinants/dependents match — they are logically distinct
+ * facts and may be activated by different surrounding predicates.
+ */
+export function addFd(fds, next, opts = {}) {
+    if (next.dependents.length === 0)
+        return fds.slice();
+    const result = [];
+    let subsumedByExisting = false;
+    for (const existing of fds) {
+        if (fdsEqual(existing, next)) {
+            subsumedByExisting = true;
+            result.push(existing);
+            continue;
+        }
+        if (determinantsEqual(existing.determinants, next.determinants) &&
+            guardsEqual(existing.guard, next.guard)) {
+            // Same determinants and guard: keep whichever has the larger dependent set.
+            if (dependentsSubset(existing.dependents, next.dependents)) {
+                // existing ⊂ next, drop existing
+                continue;
+            }
+            if (dependentsSubset(next.dependents, existing.dependents)) {
+                subsumedByExisting = true;
+            }
+        }
+        result.push(existing);
+    }
+    if (!subsumedByExisting)
+        result.push(next);
+    return enforceCap(result, opts);
+}
+function enforceCap(fds, opts) {
+    const cap = opts.cap ?? MAX_FDS_PER_NODE;
+    if (fds.length <= cap)
+        return fds;
+    const keyHints = opts.keyHints ?? [];
+    const keySet = keyHints.map(k => new Set(k));
+    const isSubsetOfAnyKey = (det) => {
+        if (keySet.length === 0)
+            return false;
+        return keySet.some(ks => det.every(d => ks.has(d)));
+    };
+    const preferred = fds.filter(fd => isSubsetOfAnyKey(fd.determinants));
+    const other = fds.filter(fd => !isSubsetOfAnyKey(fd.determinants));
+    let kept;
+    if (preferred.length >= cap) {
+        kept = preferred.slice(0, cap);
+    }
+    else {
+        kept = preferred.concat(other.slice(0, cap - preferred.length));
+    }
+    log('FD cap reached: dropped %d FD(s) from %d', fds.length - kept.length, fds.length);
+    return kept;
+}
+/** Merge two FD lists, applying subsumption via `addFd`. */
+export function mergeFds(a, b, opts = {}) {
+    let result = a.slice();
+    for (const fd of b) {
+        result = addFd(result, fd, opts);
+    }
+    return result;
+}
+/**
+ * Project FDs through a column mapping (oldCol → newCol). FDs whose
+ * determinants lose any column are dropped entirely (the projection breaks
+ * the determinant set). Dependents that don't survive are filtered out;
+ * an FD whose dependents are completely filtered is dropped.
+ *
+ * Exception: an FD with empty determinants (the singleton "at-most-one-row"
+ * marker) survives as long as at least one dependent does — losing some
+ * dependent columns to projection doesn't invalidate the at-most-one-row
+ * claim on the surviving columns.
+ *
+ * Guarded FDs additionally require every column referenced in `guard.clauses`
+ * to be in the mapping — if any guard column is dropped the guard becomes
+ * unobservable and the FD can never be re-activated downstream.
+ */
+export function projectFds(fds, mapping) {
+    const result = [];
+    for (const fd of fds) {
+        const newDet = [];
+        let miss = false;
+        for (const d of fd.determinants) {
+            const m = mapping.get(d);
+            if (m === undefined) {
+                miss = true;
+                break;
+            }
+            newDet.push(m);
+        }
+        if (miss)
+            continue;
+        const newDep = [];
+        for (const d of fd.dependents) {
+            const m = mapping.get(d);
+            if (m !== undefined)
+                newDep.push(m);
+        }
+        if (newDep.length === 0)
+            continue;
+        let newGuard;
+        if (fd.guard !== undefined) {
+            const mappedGuard = projectGuard(fd.guard, mapping);
+            if (!mappedGuard)
+                continue;
+            newGuard = mappedGuard;
+        }
+        result.push(newGuard
+            ? { determinants: newDet, dependents: newDep, guard: newGuard }
+            : { determinants: newDet, dependents: newDep });
+    }
+    return result;
+}
+function projectGuard(guard, mapping) {
+    const clauses = [];
+    for (const clause of guard.clauses) {
+        const mapped = projectClause(clause, mapping);
+        if (mapped === undefined)
+            return undefined;
+        clauses.push(mapped);
+    }
+    return { clauses };
+}
+function projectClause(clause, mapping) {
+    switch (clause.kind) {
+        case 'eq-literal': {
+            const m = mapping.get(clause.column);
+            if (m === undefined)
+                return undefined;
+            return { kind: 'eq-literal', column: m, value: clause.value };
+        }
+        case 'eq-column': {
+            const ml = mapping.get(clause.left);
+            const mr = mapping.get(clause.right);
+            if (ml === undefined || mr === undefined)
+                return undefined;
+            return { kind: 'eq-column', left: ml, right: mr };
+        }
+        case 'is-null': {
+            const m = mapping.get(clause.column);
+            if (m === undefined)
+                return undefined;
+            return { kind: 'is-null', column: m, negated: clause.negated };
+        }
+        case 'range': {
+            const m = mapping.get(clause.column);
+            if (m === undefined)
+                return undefined;
+            return { ...clause, column: m };
+        }
+        case 'or-of': {
+            const sub = [];
+            for (const c of clause.clauses) {
+                const mapped = projectClause(c, mapping);
+                // Same conservative rule as the rest of projectGuard: if any nested
+                // column drops out the whole clause is unrecoverable.
+                if (mapped === undefined)
+                    return undefined;
+                sub.push(mapped);
+            }
+            return { kind: 'or-of', clauses: sub };
+        }
+    }
+}
+/** Shift all column indices in `fds` (including any `guard` columns) by `offset`. */
+export function shiftFds(fds, offset) {
+    if (offset === 0)
+        return fds.slice();
+    return fds.map(fd => {
+        const shifted = {
+            determinants: fd.determinants.map(d => d + offset),
+            dependents: fd.dependents.map(d => d + offset),
+        };
+        if (fd.guard !== undefined) {
+            return { ...shifted, guard: shiftGuard(fd.guard, offset) };
+        }
+        return shifted;
+    });
+}
+function shiftGuard(guard, offset) {
+    return { clauses: guard.clauses.map(c => shiftClause(c, offset)) };
+}
+function shiftClause(clause, offset) {
+    switch (clause.kind) {
+        case 'eq-literal':
+            return { kind: 'eq-literal', column: clause.column + offset, value: clause.value };
+        case 'eq-column':
+            return { kind: 'eq-column', left: clause.left + offset, right: clause.right + offset };
+        case 'is-null':
+            return { kind: 'is-null', column: clause.column + offset, negated: clause.negated };
+        case 'range':
+            return { ...clause, column: clause.column + offset };
+        case 'or-of':
+            return { kind: 'or-of', clauses: clause.clauses.map(c => shiftClause(c, offset)) };
+    }
+}
+/**
+ * Return the unconditional twin of `fd` — drop the guard but keep determinants
+ * and dependents. Used by Filter activation when the surrounding predicate
+ * entails the guard.
+ */
+export function stripGuard(fd) {
+    if (fd.guard === undefined)
+        return fd;
+    return { determinants: fd.determinants, dependents: fd.dependents };
+}
+/** Shift all column indices in `classes` by `offset`. */
+export function shiftEquivClasses(classes, offset) {
+    if (offset === 0)
+        return classes.map(c => c.slice());
+    return classes.map(c => c.map(x => x + offset));
+}
+function normalizeClass(cls) {
+    const dedup = Array.from(new Set(cls));
+    dedup.sort((a, b) => a - b);
+    return dedup;
+}
+/**
+ * Merge two equivalence-class sets, taking the transitive closure of
+ * overlapping classes (union-find style).
+ */
+export function mergeEquivClasses(a, b) {
+    const classes = [...a, ...b].map(c => normalizeClass(c));
+    let merged = true;
+    while (merged) {
+        merged = false;
+        outer: for (let i = 0; i < classes.length; i++) {
+            const ci = classes[i];
+            const ciSet = new Set(ci);
+            for (let j = i + 1; j < classes.length; j++) {
+                const cj = classes[j];
+                let overlap = false;
+                for (const x of cj) {
+                    if (ciSet.has(x)) {
+                        overlap = true;
+                        break;
+                    }
+                }
+                if (overlap) {
+                    classes[i] = normalizeClass([...ci, ...cj]);
+                    classes.splice(j, 1);
+                    merged = true;
+                    break outer;
+                }
+            }
+        }
+    }
+    return classes.filter(c => c.length >= 2);
+}
+/** Add a new equality `a ≡ b` to an existing class list. */
+export function addEquivalence(classes, a, b) {
+    if (a === b)
+        return classes.map(c => c.slice());
+    return mergeEquivClasses(classes, [[a, b]]);
+}
+/**
+ * Build an FD `key → {0..columnCount-1} \ key` from a superkey. The canonical
+ * way to encode "K is a unique key on a relation": K determines every other
+ * output column. K = ∅ produces the "at-most-one-row" singleton FD.
+ *
+ * Returns undefined when K covers every column (the all-columns case has no
+ * non-trivial encoding — that case is communicated via `RelationType.isSet`
+ * instead).
+ */
+export function superkeyToFd(key, columnCount) {
+    const keySet = new Set(key);
+    const dependents = [];
+    for (let i = 0; i < columnCount; i++) {
+        if (!keySet.has(i))
+            dependents.push(i);
+    }
+    if (dependents.length === 0)
+        return undefined;
+    return { determinants: key.slice(), dependents };
+}
+/**
+ * True iff the closure of `attrs` under `fds` covers `{0..columnCount-1}` —
+ * i.e., `attrs` is a superkey of the relation. Replaces the legacy "covers a
+ * `uniqueKeys` entry" check; FDs are the canonical surface now.
+ */
+export function isSuperkey(attrs, fds, columnCount) {
+    if (columnCount <= 0)
+        return true;
+    const closure = computeClosure(attrs, fds ?? []);
+    for (let i = 0; i < columnCount; i++) {
+        if (!closure.has(i))
+            return false;
+    }
+    return true;
+}
+/**
+ * Enumerate the minimal full-cover key sets discoverable from `fds`: for each
+ * FD `K → Y` whose closure covers all columns, return `K` (greedily minimized
+ * within `K`). Deduplicated by set equality.
+ *
+ * Excludes the trivial "all-columns is a superkey" tautology — only FDs with
+ * `K ⊊ all_cols` are considered, since the all-cols case is encoded via
+ * `RelationType.isSet`.
+ */
+export function deriveKeysFromFds(fds, columnCount) {
+    if (!fds || fds.length === 0)
+        return [];
+    const results = [];
+    const seen = new Set();
+    for (const fd of fds) {
+        if (fd.guard !== undefined)
+            continue;
+        if (fd.determinants.length >= columnCount)
+            continue;
+        const det = new Set(fd.determinants);
+        if (!isSuperkey(det, fds, columnCount))
+            continue;
+        const minimal = minimalCover(det, fds);
+        // Ensure the minimal cover still covers all columns (it should — minimalCover
+        // only drops attrs whose removal doesn't change closure).
+        const sorted = Array.from(minimal).sort((a, b) => a - b);
+        const key = sorted.join(',');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        results.push(sorted);
+    }
+    return results;
+}
+/**
+ * True iff the FD set encodes any non-trivial key — i.e., there exists some
+ * FD whose determinants form a superkey of `columnCount` columns with the
+ * determinant set strictly smaller than all columns. This is the FD-surface
+ * replacement for "the relation has a known unique key smaller than its full
+ * column list" (the old `uniqueKeys.length > 0` check), excluding the
+ * tautological all-columns case which carries no information.
+ */
+export function hasAnyKey(fds, columnCount) {
+    if (!fds || fds.length === 0)
+        return false;
+    return fds.some(fd => fd.guard === undefined &&
+        fd.determinants.length < columnCount &&
+        isSuperkey(new Set(fd.determinants), fds, columnCount));
+}
+/**
+ * True iff the relation has at-most-one-row — i.e., some FD `∅ → Y` exists
+ * whose closure covers every column. Replaces the legacy `[[]]` singleton
+ * marker on `uniqueKeys`.
+ */
+export function hasSingletonFd(fds, columnCount) {
+    if (!fds)
+        return false;
+    return fds.some(fd => fd.guard === undefined &&
+        fd.determinants.length === 0 &&
+        isSuperkey(new Set(), fds, columnCount));
+}
+/**
+ * Build the singleton FD `∅ → {0..columnCount-1}` that encodes
+ * "at-most-one-row". Returns undefined when `columnCount === 0` (no
+ * dependents).
+ */
+export function singletonFd(columnCount) {
+    if (columnCount <= 0)
+        return undefined;
+    const dependents = [];
+    for (let i = 0; i < columnCount; i++)
+        dependents.push(i);
+    return { determinants: [], dependents };
+}
+/**
+ * True iff `attrs` is asserted to be a unique key by the FD set — i.e., there
+ * exists some FD whose determinants are a subset of `attrs` and whose closure
+ * covers all columns. Stricter than `isSuperkey`: the trivial "all-cols is a
+ * superkey of itself" tautology does NOT count, because no FD makes that claim.
+ *
+ * Use this when you need a positive uniqueness claim (e.g., the
+ * sort/window strict-monotonicOn check). For "would attrs functionally
+ * determine the rest of the relation under closure?" use `isSuperkey` directly.
+ */
+export function isAssertedKey(attrs, fds, columnCount) {
+    if (!fds || fds.length === 0)
+        return false;
+    for (const fd of fds) {
+        if (fd.guard !== undefined)
+            continue;
+        // Determinants must be a subset of attrs.
+        let subset = true;
+        for (const d of fd.determinants) {
+            if (!attrs.has(d)) {
+                subset = false;
+                break;
+            }
+        }
+        if (!subset)
+            continue;
+        // Determinants closure must cover all columns.
+        if (isSuperkey(new Set(fd.determinants), fds, columnCount))
+            return true;
+    }
+    return false;
+}
+/**
+ * Walk `predicate` (assumed to be a normalized conjunction) and extract FDs,
+ * equivalence-class contributions, and constant bindings from equality
+ * conjuncts.
+ *
+ * `attrIdToIndex` maps an attribute ID to its column index in the predicate's
+ * relation. Equality conjuncts referencing attributes outside this map
+ * (correlated subqueries, etc.) are silently ignored.
+ *
+ * Recognized shapes (per AND-conjunct):
+ *   - `col = literal`  ⇒ FD `∅ → col`  +  binding `{col} → literal value`.
+ *   - `col = ?`        ⇒ FD `∅ → col`  +  binding `{col} → parameter ref`.
+ *   - `col1 = col2`    ⇒ FDs `{col1} → {col2}` and `{col2} → {col1}` plus an
+ *     equivalence pair `[col1, col2]`.
+ *
+ * Non-equality conjuncts contribute nothing.
+ */
+export function extractEqualityFds(predicate, attrIdToIndex) {
+    const fds = [];
+    const equivPairs = [];
+    const constantBindings = [];
+    const stack = [predicate];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (!(n instanceof BinaryOpNode))
+            continue;
+        const op = n.expression.operator;
+        if (op === 'AND') {
+            stack.push(n.left, n.right);
+            continue;
+        }
+        if (op !== '=')
+            continue;
+        const lIsCol = n.left instanceof ColumnReferenceNode;
+        const rIsCol = n.right instanceof ColumnReferenceNode;
+        const lConst = constantValueOf(n.left);
+        const rConst = constantValueOf(n.right);
+        if (lIsCol && rIsCol) {
+            const lIdx = attrIdToIndex.get(n.left.attributeId);
+            const rIdx = attrIdToIndex.get(n.right.attributeId);
+            if (lIdx !== undefined && rIdx !== undefined && lIdx !== rIdx) {
+                fds.push({ determinants: [lIdx], dependents: [rIdx] });
+                fds.push({ determinants: [rIdx], dependents: [lIdx] });
+                equivPairs.push([lIdx, rIdx]);
+            }
+            continue;
+        }
+        if (lIsCol && rConst !== undefined) {
+            const lIdx = attrIdToIndex.get(n.left.attributeId);
+            if (lIdx !== undefined) {
+                fds.push({ determinants: [], dependents: [lIdx] });
+                constantBindings.push({ attrs: [lIdx], value: rConst });
+            }
+            continue;
+        }
+        if (rIsCol && lConst !== undefined) {
+            const rIdx = attrIdToIndex.get(n.right.attributeId);
+            if (rIdx !== undefined) {
+                fds.push({ determinants: [], dependents: [rIdx] });
+                constantBindings.push({ attrs: [rIdx], value: lConst });
+            }
+            continue;
+        }
+    }
+    return { fds, equivPairs, constantBindings };
+}
+function buildPredicateFacts(predicate, attrIdToIndex, isColumnNumeric) {
+    const literalEqs = new Map();
+    const columnEqs = new Map();
+    const isNullCols = new Set();
+    const isNotNullCols = new Set();
+    const inListEqs = new Map();
+    const rangeBounds = new Map();
+    const addColumnEq = (a, b) => {
+        if (a === b)
+            return;
+        let aSet = columnEqs.get(a);
+        if (!aSet) {
+            aSet = new Set();
+            columnEqs.set(a, aSet);
+        }
+        aSet.add(b);
+        let bSet = columnEqs.get(b);
+        if (!bSet) {
+            bSet = new Set();
+            columnEqs.set(b, bSet);
+        }
+        bSet.add(a);
+    };
+    const columnIndexOf = (n) => {
+        if (n instanceof ColumnReferenceNode) {
+            return attrIdToIndex.get(n.attributeId);
+        }
+        return undefined;
+    };
+    const tightenLowerBound = (col, value, inclusive) => {
+        const cur = rangeBounds.get(col);
+        if (!cur) {
+            rangeBounds.set(col, { min: value, minInclusive: inclusive, maxInclusive: false });
+            return;
+        }
+        if (cur.min === undefined) {
+            cur.min = value;
+            cur.minInclusive = inclusive;
+            return;
+        }
+        const cmp = compareSqlValues(value, cur.min);
+        if (cmp > 0) {
+            cur.min = value;
+            cur.minInclusive = inclusive;
+        }
+        else if (cmp === 0 && cur.minInclusive && !inclusive) {
+            // Tighten: same value, but new bound is exclusive (excludes the boundary).
+            cur.minInclusive = false;
+        }
+    };
+    const tightenUpperBound = (col, value, inclusive) => {
+        const cur = rangeBounds.get(col);
+        if (!cur) {
+            rangeBounds.set(col, { max: value, maxInclusive: inclusive, minInclusive: false });
+            return;
+        }
+        if (cur.max === undefined) {
+            cur.max = value;
+            cur.maxInclusive = inclusive;
+            return;
+        }
+        const cmp = compareSqlValues(value, cur.max);
+        if (cmp < 0) {
+            cur.max = value;
+            cur.maxInclusive = inclusive;
+        }
+        else if (cmp === 0 && cur.maxInclusive && !inclusive) {
+            cur.maxInclusive = false;
+        }
+    };
+    const recordComparison = (col, op, lit) => {
+        switch (op) {
+            case '>':
+                tightenLowerBound(col, lit, false);
+                return;
+            case '>=':
+                tightenLowerBound(col, lit, true);
+                return;
+            case '<':
+                tightenUpperBound(col, lit, false);
+                return;
+            case '<=':
+                tightenUpperBound(col, lit, true);
+                return;
+        }
+    };
+    const stack = [predicate];
+    while (stack.length > 0) {
+        const n = stack.pop();
+        if (n instanceof BinaryOpNode) {
+            const op = n.expression.operator;
+            if (op === 'AND') {
+                stack.push(n.left, n.right);
+                continue;
+            }
+            if (op === '=' || op === '==') {
+                const lIdx = columnIndexOf(n.left);
+                const rIdx = columnIndexOf(n.right);
+                if (lIdx !== undefined && rIdx !== undefined) {
+                    addColumnEq(lIdx, rIdx);
+                    continue;
+                }
+                if (lIdx !== undefined) {
+                    const lit = literalSqlValueOf(n.right);
+                    if (lit !== undefined)
+                        literalEqs.set(lIdx, lit);
+                    continue;
+                }
+                if (rIdx !== undefined) {
+                    const lit = literalSqlValueOf(n.left);
+                    if (lit !== undefined)
+                        literalEqs.set(rIdx, lit);
+                }
+                continue;
+            }
+            // IS / IS NOT may be written as binary with literal NULL on the right.
+            if (op === 'IS' || op === 'IS NOT') {
+                const lIdx = columnIndexOf(n.left);
+                if (lIdx === undefined)
+                    continue;
+                const lit = literalSqlValueOf(n.right);
+                if (lit !== null)
+                    continue;
+                if (op === 'IS')
+                    isNullCols.add(lIdx);
+                else
+                    isNotNullCols.add(lIdx);
+                continue;
+            }
+            if (op === '<' || op === '<=' || op === '>' || op === '>=') {
+                const lIdx = columnIndexOf(n.left);
+                const rIdx = columnIndexOf(n.right);
+                if (lIdx !== undefined && rIdx === undefined) {
+                    const lit = literalSqlValueOf(n.right);
+                    if (lit === undefined || lit === null)
+                        continue;
+                    recordComparison(lIdx, op, lit);
+                }
+                else if (rIdx !== undefined && lIdx === undefined) {
+                    const lit = literalSqlValueOf(n.left);
+                    if (lit === undefined || lit === null)
+                        continue;
+                    recordComparison(rIdx, flipComparison(op), lit);
+                }
+                continue;
+            }
+            continue;
+        }
+        if (n instanceof BetweenNode) {
+            if (n.expression.not === true)
+                continue;
+            const cIdx = columnIndexOf(n.expr);
+            if (cIdx === undefined)
+                continue;
+            const lo = literalSqlValueOf(n.lower);
+            const hi = literalSqlValueOf(n.upper);
+            if (lo !== undefined && lo !== null)
+                tightenLowerBound(cIdx, lo, true);
+            if (hi !== undefined && hi !== null)
+                tightenUpperBound(cIdx, hi, true);
+            continue;
+        }
+        if (n instanceof UnaryOpNode) {
+            const op = n.expression.operator;
+            const cIdx = columnIndexOf(n.operand);
+            if (cIdx === undefined)
+                continue;
+            if (op === 'IS NULL')
+                isNullCols.add(cIdx);
+            else if (op === 'IS NOT NULL')
+                isNotNullCols.add(cIdx);
+            // `WHERE NOT col` excludes both NULL and zero rows. Pin `col = 0` so
+            // it discharges partial-UC guards rewritten the same way at production.
+            // Numeric-only: for TEXT/BLOB/BOOLEAN columns `col = 0` (strict
+            // `sqlValueEquals`) is not equivalent to `NOT col` (TEXT `''` and
+            // boolean `false` are falsy but compare unequal to integer 0), so the
+            // rewrite would falsely discharge a `col = 0` guard for rows the
+            // runtime filter actually keeps. `IS NOT NULL` is still recorded —
+            // that's sound regardless of type.
+            else if (op === 'NOT') {
+                if (isColumnNumeric(cIdx))
+                    literalEqs.set(cIdx, 0);
+                isNotNullCols.add(cIdx);
+            }
+            continue;
+        }
+        if (n instanceof InNode) {
+            // Literal-only IN-list with a column-reference condition: capture
+            // the OR-set so `or-of [eq-literal …]` guards can discharge.
+            if (n.source !== undefined)
+                continue;
+            if (!n.values || n.values.length === 0)
+                continue;
+            const cIdx = columnIndexOf(n.condition);
+            if (cIdx === undefined)
+                continue;
+            const set = new Set();
+            let allLiterals = true;
+            for (const v of n.values) {
+                const lit = literalSqlValueOf(v);
+                if (lit === undefined) {
+                    allLiterals = false;
+                    break;
+                }
+                set.add(lit);
+            }
+            if (!allLiterals)
+                continue;
+            // If a previous IN on the same column was captured, intersect to keep
+            // the strongest set (`col IN (a,b) AND col IN (b,c)` ⇒ {b}).
+            const prev = inListEqs.get(cIdx);
+            if (prev) {
+                const intersected = new Set();
+                for (const x of set) {
+                    for (const y of prev) {
+                        if (sqlValueEquals(x, y))
+                            intersected.add(x);
+                    }
+                }
+                inListEqs.set(cIdx, intersected);
+            }
+            else {
+                inListEqs.set(cIdx, set);
+            }
+            // A singleton IN also pins the literal.
+            if (set.size === 1) {
+                const only = set.values().next().value;
+                literalEqs.set(cIdx, only);
+            }
+        }
+    }
+    return { literalEqs, columnEqs, isNullCols, isNotNullCols, inListEqs, rangeBounds };
+}
+function literalSqlValueOf(n) {
+    let cur = n;
+    while (cur instanceof CastNode || cur instanceof CollateNode) {
+        cur = cur.operand;
+    }
+    if (cur instanceof LiteralNode) {
+        const v = cur.expression.value;
+        if (v instanceof Promise)
+            return undefined;
+        return v;
+    }
+    return undefined;
+}
+function ecIndexOf(col, ecs) {
+    for (let i = 0; i < ecs.length; i++) {
+        if (ecs[i].includes(col))
+            return i;
+    }
+    return undefined;
+}
+function bindingForColumn(col, bindings) {
+    for (const b of bindings)
+        if (b.attrs.includes(col))
+            return b;
+    return undefined;
+}
+/**
+ * Decide whether the surrounding `predicate` (combined with the source's ECs
+ * and constant bindings) entails every clause in `guard`. Conservative — when
+ * in doubt, returns `false`.
+ *
+ * `isColumnNonNullable(col)` reports whether the source's output column is
+ * declared NOT NULL; the helper uses it to discharge `is-null negated:true`
+ * guards from type information alone.
+ *
+ * `isColumnNumeric(col)` reports whether the source's output column has a
+ * numeric logical type. Used to gate the `NOT col → col = 0` rewrite: only
+ * sound for numeric columns since the consumer matches `eq-literal{col, 0}`
+ * via strict `sqlValueEquals`, which treats TEXT `''`, BLOB, and boolean
+ * `false` as unequal to integer 0.
+ */
+export function predicateImpliesGuard(predicate, guard, ecs, bindings, attrIdToIndex, isColumnNonNullable, isColumnNumeric) {
+    const facts = buildPredicateFacts(predicate, attrIdToIndex, isColumnNumeric);
+    for (const clause of guard.clauses) {
+        if (!clauseEntailed(clause, facts, ecs, bindings, isColumnNonNullable)) {
+            return false;
+        }
+    }
+    return true;
+}
+function clauseEntailed(clause, facts, ecs, bindings, isColumnNonNullable) {
+    switch (clause.kind) {
+        case 'eq-literal': {
+            const { column, value } = clause;
+            // Direct conjunct match.
+            const direct = facts.literalEqs.get(column);
+            if (direct !== undefined && sqlValueEquals(direct, value))
+                return true;
+            // Via EC: any column in `column`'s EC pinned to the literal.
+            const ecIdx = ecIndexOf(column, ecs);
+            if (ecIdx !== undefined) {
+                for (const peer of ecs[ecIdx]) {
+                    const peerLit = facts.literalEqs.get(peer);
+                    if (peerLit !== undefined && sqlValueEquals(peerLit, value))
+                        return true;
+                }
+            }
+            // Via binding: source already pins `column` to the same literal.
+            const binding = bindingForColumn(column, bindings);
+            if (binding && binding.value.kind === 'literal' && sqlValueEquals(binding.value.value, value)) {
+                return true;
+            }
+            return false;
+        }
+        case 'eq-column': {
+            const { left, right } = clause;
+            if (left === right)
+                return true;
+            // Same EC.
+            const li = ecIndexOf(left, ecs);
+            const ri = ecIndexOf(right, ecs);
+            if (li !== undefined && li === ri)
+                return true;
+            // Direct conjunct match.
+            const leftPeers = facts.columnEqs.get(left);
+            if (leftPeers && leftPeers.has(right))
+                return true;
+            // Bound to the same ConstantValue (literal or parameter) on both sides.
+            const lBind = bindingForColumn(left, bindings);
+            const rBind = bindingForColumn(right, bindings);
+            if (lBind && rBind && constantValueEquals(lBind.value, rBind.value))
+                return true;
+            return false;
+        }
+        case 'is-null': {
+            const { column, negated } = clause;
+            if (negated) {
+                // "col IS NOT NULL" guard.
+                if (facts.isNotNullCols.has(column))
+                    return true;
+                if (isColumnNonNullable(column))
+                    return true;
+                return false;
+            }
+            // "col IS NULL" guard.
+            return facts.isNullCols.has(column);
+        }
+        case 'range': {
+            // Try the guard column and every EC peer / binding-shared column —
+            // any of them carrying a subset range discharges the guard.
+            const cands = candidateColumns(clause.column, ecs, bindings);
+            for (const c of cands) {
+                const filter = facts.rangeBounds.get(c);
+                if (filter && filterRangeSubsetOfGuardRange(filter, clause))
+                    return true;
+            }
+            return false;
+        }
+        case 'or-of': {
+            // (a) Any sub-clause directly entailed by facts ⇒ OR entailed.
+            for (const sub of clause.clauses) {
+                if (clauseEntailed(sub, facts, ecs, bindings, isColumnNonNullable))
+                    return true;
+            }
+            // (b) Pure-IN specialization: every sub-clause is eq-literal on the
+            //     same column. Entailed when the filter pins that column to a
+            //     subset of the OR-set.
+            return inListEntailed(clause, facts, ecs, bindings);
+        }
+    }
+}
+/**
+ * Specialized discharge for `or-of` clauses whose sub-clauses are all
+ * `eq-literal` on the same column (the IN-list shape). Entailed when the
+ * filter pins that column — via direct literal, IN-list, EC peer, or constant
+ * binding — to a subset of the OR-set. Returns false for any other `or-of`
+ * shape.
+ */
+function inListEntailed(clause, facts, ecs, bindings) {
+    if (clause.clauses.length === 0)
+        return false;
+    let column;
+    const orSet = [];
+    for (const sub of clause.clauses) {
+        if (sub.kind !== 'eq-literal')
+            return false;
+        if (column === undefined)
+            column = sub.column;
+        else if (column !== sub.column)
+            return false;
+        orSet.push(sub.value);
+    }
+    if (column === undefined)
+        return false;
+    const inOrSet = (v) => {
+        for (const x of orSet)
+            if (sqlValueEquals(x, v))
+                return true;
+        return false;
+    };
+    // Try the column itself and every EC peer plus columns bound to the same
+    // ConstantValue (those are pinned to the same literal).
+    const cands = candidateColumns(column, ecs, bindings);
+    for (const c of cands) {
+        const direct = facts.literalEqs.get(c);
+        if (direct !== undefined && inOrSet(direct))
+            return true;
+        const inList = facts.inListEqs.get(c);
+        if (inList !== undefined && inList.size > 0) {
+            let allIn = true;
+            for (const v of inList) {
+                if (!inOrSet(v)) {
+                    allIn = false;
+                    break;
+                }
+            }
+            if (allIn)
+                return true;
+        }
+        // Source binding pins this candidate to a literal in the OR-set.
+        const binding = bindingForColumn(c, bindings);
+        if (binding && binding.value.kind === 'literal' && inOrSet(binding.value.value)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * True iff every value satisfying `filter` also satisfies `guard`. Per-side
+ * check: a guard side with no bound is trivially satisfied; otherwise the
+ * filter must have a matching bound that is strictly tighter, or equal-and-
+ * compatible on inclusivity. BINARY collation for text comparison — consistent
+ * with how DomainConstraint range subsumption is handled today.
+ */
+function filterRangeSubsetOfGuardRange(filter, guard) {
+    if (guard.min !== undefined) {
+        if (filter.min === undefined)
+            return false;
+        const cmp = compareSqlValues(filter.min, guard.min);
+        if (cmp < 0)
+            return false;
+        if (cmp === 0 && filter.minInclusive && !guard.minInclusive)
+            return false;
+    }
+    if (guard.max !== undefined) {
+        if (filter.max === undefined)
+            return false;
+        const cmp = compareSqlValues(filter.max, guard.max);
+        if (cmp > 0)
+            return false;
+        if (cmp === 0 && filter.maxInclusive && !guard.maxInclusive)
+            return false;
+    }
+    return true;
+}
+function candidateColumns(column, ecs, bindings) {
+    const out = new Set();
+    out.add(column);
+    const ecIdx = ecIndexOf(column, ecs);
+    if (ecIdx !== undefined) {
+        for (const c of ecs[ecIdx])
+            out.add(c);
+    }
+    // Columns sharing a ConstantBinding with `column` are also pinned to the
+    // same value.
+    const ownBinding = bindingForColumn(column, bindings);
+    if (ownBinding) {
+        for (const c of ownBinding.attrs)
+            out.add(c);
+    }
+    return Array.from(out);
+}
+/**
+ * If `n` is "constant" relative to the filter's input stream — true for one
+ * full execution — return its `ConstantValue`; otherwise undefined.
+ *
+ * `LiteralNode` is constant at all times. `ParameterReferenceNode` is
+ * constant for the duration of a single execution: the parameter is bound
+ * once before iteration and the same value is observed by every row. That
+ * matches the scope `computePhysical` describes (per-execution properties),
+ * so the EC layer treats parameters and literals uniformly. Subqueries /
+ * correlated expressions remain rejected — they can vary per-row.
+ *
+ * `CastNode` and `CollateNode` are peeled through: they don't change row-wise
+ * behaviour (constant-after-cast is still constant). For a literal under a
+ * cast the inner `SqlValue` is reported as-is — downstream consumers needing
+ * the post-cast value must apply the cast themselves.
+ */
+function constantValueOf(n) {
+    while (n instanceof CastNode || n instanceof CollateNode) {
+        n = n.operand;
+    }
+    if (n instanceof LiteralNode) {
+        const v = n.expression.value;
+        if (v instanceof Promise)
+            return undefined;
+        return { kind: 'literal', value: v };
+    }
+    if (n instanceof ParameterReferenceNode) {
+        return { kind: 'parameter', paramRef: n.nameOrIndex };
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// ConstantBinding helpers
+// ---------------------------------------------------------------------------
+// Structural value-equality used by `mergeConstantBindings` to coalesce
+// bindings on identical values. ConstantBinding.source is NOT compared at
+// merge time — see `fdsEqual` for the dedup-precedence rule.
+function constantValueEquals(a, b) {
+    if (a.kind !== b.kind)
+        return false;
+    if (a.kind === 'literal' && b.kind === 'literal') {
+        const av = a.value;
+        const bv = b.value;
+        if (av === bv)
+            return true;
+        // Compare bigint/number/string by their textual form; everything else by identity.
+        if (av instanceof Uint8Array && bv instanceof Uint8Array) {
+            if (av.length !== bv.length)
+                return false;
+            for (let i = 0; i < av.length; i++)
+                if (av[i] !== bv[i])
+                    return false;
+            return true;
+        }
+        return false;
+    }
+    if (a.kind === 'parameter' && b.kind === 'parameter') {
+        return a.paramRef === b.paramRef;
+    }
+    return false;
+}
+function unionAttrs(a, b) {
+    const out = new Set(a);
+    for (const x of b)
+        out.add(x);
+    return Array.from(out).sort((x, y) => x - y);
+}
+function normalizeBinding(b) {
+    const attrs = Array.from(new Set(b.attrs)).sort((x, y) => x - y);
+    return { attrs, value: b.value };
+}
+/**
+ * Merge two binding lists, coalescing bindings that share a `ConstantValue`
+ * by unioning their `attrs`. Caps the result at `MAX_FDS_PER_NODE`; later
+ * additions are dropped when the cap is exceeded — bindings sourced from
+ * earlier nodes are preferred since they typically sit closer to keyed
+ * columns. Truncations are logged under `quereus:planner:fd`.
+ */
+export function mergeConstantBindings(a, b) {
+    const result = a.map(normalizeBinding);
+    for (const raw of b) {
+        const next = normalizeBinding(raw);
+        let merged = false;
+        for (let i = 0; i < result.length; i++) {
+            if (constantValueEquals(result[i].value, next.value)) {
+                result[i] = { attrs: unionAttrs(result[i].attrs, next.attrs), value: result[i].value };
+                merged = true;
+                break;
+            }
+        }
+        if (!merged)
+            result.push(next);
+    }
+    return enforceBindingCap(result);
+}
+function enforceBindingCap(bindings) {
+    if (bindings.length <= MAX_FDS_PER_NODE)
+        return bindings;
+    const kept = bindings.slice(0, MAX_FDS_PER_NODE);
+    log('ConstantBinding cap reached: dropped %d binding(s) from %d', bindings.length - kept.length, bindings.length);
+    return kept;
+}
+/**
+ * Extend `bindings` over `ecs`: if a binding pins column `c` to value `v` and
+ * `c` is in an equivalence class `{c, c2, ...}`, fold every member of that
+ * class into the binding's `attrs`. This is what lets predicate-inference
+ * rules consume bindings directly without walking ECs.
+ */
+export function closeConstantBindingsOverEcs(bindings, ecs) {
+    if (bindings.length === 0)
+        return [];
+    if (ecs.length === 0)
+        return bindings.map(normalizeBinding);
+    const result = [];
+    for (const binding of bindings) {
+        const expanded = new Set(binding.attrs);
+        let grew = true;
+        while (grew) {
+            grew = false;
+            for (const cls of ecs) {
+                const overlap = cls.some(c => expanded.has(c));
+                if (!overlap)
+                    continue;
+                for (const c of cls) {
+                    if (!expanded.has(c)) {
+                        expanded.add(c);
+                        grew = true;
+                    }
+                }
+            }
+        }
+        result.push({ attrs: Array.from(expanded).sort((x, y) => x - y), value: binding.value });
+    }
+    // Two bindings might now alias to the same value/attrs after closure; coalesce.
+    return mergeConstantBindings(result, []);
+}
+/**
+ * Project bindings through `mapping` (oldCol → newCol). A binding whose
+ * `attrs` lose every member is dropped; otherwise the surviving members are
+ * remapped.
+ */
+export function projectConstantBindings(bindings, mapping) {
+    const out = [];
+    for (const binding of bindings) {
+        const mapped = [];
+        for (const c of binding.attrs) {
+            const m = mapping.get(c);
+            if (m !== undefined && !mapped.includes(m))
+                mapped.push(m);
+        }
+        if (mapped.length === 0)
+            continue;
+        out.push({ attrs: mapped.sort((x, y) => x - y), value: binding.value });
+    }
+    return mergeConstantBindings(out, []);
+}
+/** Shift `attrs` by `offset` (column-index translation for joins). */
+export function shiftConstantBindings(bindings, offset) {
+    if (offset === 0)
+        return bindings.map(normalizeBinding);
+    return bindings.map(binding => ({
+        attrs: binding.attrs.map(c => c + offset).sort((x, y) => x - y),
+        value: binding.value,
+    }));
+}
+function sqlValueEquals(a, b) {
+    if (a === b)
+        return true;
+    if (a instanceof Uint8Array && b instanceof Uint8Array) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++)
+            if (a[i] !== b[i])
+                return false;
+        return true;
+    }
+    return false;
+}
+// Structural-only equality. The optional `source` provenance tag is NOT
+// compared — see `fdsEqual` above for the dedup-precedence rule.
+function domainConstraintEquals(a, b) {
+    if (a.column !== b.column || a.kind !== b.kind)
+        return false;
+    if (a.kind === 'range' && b.kind === 'range') {
+        const aHasMin = a.min !== undefined;
+        const bHasMin = b.min !== undefined;
+        if (aHasMin !== bHasMin)
+            return false;
+        if (aHasMin && !sqlValueEquals(a.min, b.min))
+            return false;
+        if (aHasMin && a.minInclusive !== b.minInclusive)
+            return false;
+        const aHasMax = a.max !== undefined;
+        const bHasMax = b.max !== undefined;
+        if (aHasMax !== bHasMax)
+            return false;
+        if (aHasMax && !sqlValueEquals(a.max, b.max))
+            return false;
+        if (aHasMax && a.maxInclusive !== b.maxInclusive)
+            return false;
+        return true;
+    }
+    if (a.kind === 'enum' && b.kind === 'enum') {
+        if (a.values.length !== b.values.length)
+            return false;
+        for (let i = 0; i < a.values.length; i++) {
+            if (!sqlValueEquals(a.values[i], b.values[i]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+/**
+ * Concatenate two domain-constraint lists, dropping structurally equal
+ * duplicates. We deliberately do NOT intersect overlapping range/enum
+ * constraints on the same column — that's deferred to the
+ * predicate-contradiction-detection ticket. Caps at `MAX_FDS_PER_NODE`.
+ */
+export function mergeDomainConstraints(a, b) {
+    const result = a.slice();
+    for (const next of b) {
+        if (result.some(existing => domainConstraintEquals(existing, next)))
+            continue;
+        result.push(next);
+    }
+    return enforceDomainCap(result);
+}
+function enforceDomainCap(domains) {
+    if (domains.length <= MAX_FDS_PER_NODE)
+        return domains;
+    const kept = domains.slice(0, MAX_FDS_PER_NODE);
+    log('DomainConstraint cap reached: dropped %d domain(s) from %d', domains.length - kept.length, domains.length);
+    return kept;
+}
+/**
+ * Project domain constraints through `mapping` (oldCol → newCol). Drops any
+ * constraint whose column is not in the mapping; remaps the rest.
+ */
+export function projectDomainConstraints(domains, mapping) {
+    const out = [];
+    for (const domain of domains) {
+        const mapped = mapping.get(domain.column);
+        if (mapped === undefined)
+            continue;
+        out.push({ ...domain, column: mapped });
+    }
+    return mergeDomainConstraints(out, []);
+}
+/** Shift every domain constraint's `column` by `offset` (join translation). */
+export function shiftDomainConstraints(domains, offset) {
+    if (offset === 0)
+        return domains.slice();
+    return domains.map(domain => ({ ...domain, column: domain.column + offset }));
+}
+//# sourceMappingURL=fd-utils.js.map