@quereus/quereus 2.9.0 → 3.0.1

package/dist/src/planner/analysis/assertion-classifier.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Classify a `create assertion` for optimizer-hoisting eligibility.
+ *
+ * Recognized canonical form (purely syntactic on the AST):
+ *
+ *   not exists (select 1 from T [where P])
+ *
+ * where `T` is a base table (not a view, CTE, or TVF) and `P` references only
+ * columns of `T`. The negated predicate `not P` is hoisted onto `T` as if it
+ * were a per-row CHECK constraint — see ticket
+ * `3-optimizer-assertion-as-rewrite-premise` for the rationale.
+ *
+ * Anything outside this shape — existential `exists(...)`, aggregate
+ * `(select count(*) ...) = 0`, multi-table joins, non-deterministic calls,
+ * nested subqueries, view-targeted assertions, etc. — is silently rejected;
+ * the assertion falls through to commit-time enforcement, which remains the
+ * source of truth.
+ */
+import type * as AST from '../../parser/ast.js';
+import type { IntegrityAssertionSchema } from '../../schema/assertion.js';
+import type { SchemaManager } from '../../schema/manager.js';
+import { collectColumnNames } from './predicate-shape.js';
+export interface AssertionHoistCandidate {
+    /** Lowercased `schema.table` name of the target base table. */
+    readonly baseTableQualifiedName: string;
+    /**
+     * The inner predicate `P` from `not exists (select 1 from T where P)`.
+     * `undefined` is reserved for the unconditional-empty case
+     * (`not exists (select 1 from T)`) and is currently rejected at the
+     * classifier — synthesizing `check (false)` is too aggressive for a pilot.
+     */
+    readonly innerPredicate?: AST.Expression;
+    /** Lowercased assertion name, for provenance tagging. */
+    readonly assertionName: string;
+}
+/**
+ * Return a hoist candidate if the assertion matches the canonical
+ * `not exists (select 1 from T [where P])` shape with a base-table target
+ * and a determinist column-only predicate. Otherwise `undefined`.
+ */
+export declare function classifyAssertionForHoisting(assertion: IntegrityAssertionSchema, schemaManager: SchemaManager): AssertionHoistCandidate | undefined;
+export { collectColumnNames };
+/**
+ * AST-level NOT pusher. Mirrors `predicate-normalizer.ts:pushNotDown` in
+ * spirit but operates on `AST.Expression` instead of `ScalarPlanNode`. The
+ * result is fed back into `extractCheckConstraints`, which understands ANDs,
+ * comparisons, BETWEEN, and IN — so push NOT down so it ends up at the
+ * leaves where those recognizers can consume it.
+ *
+ * Rewrites (mirroring partial-unique's rejection rules where applicable):
+ *   NOT (a AND b)   → (NOT a) OR (NOT b)
+ *   NOT (a OR b)    → (NOT a) AND (NOT b)
+ *   NOT (NOT x)     → x
+ *   NOT (a = b)     → a <> b      (and `==` ↦ <>)
+ *   NOT (a <> b)    → a = b       (and `!=` ↦ =)
+ *   NOT (a < b)     → a >= b
+ *   NOT (a <= b)    → a > b
+ *   NOT (a > b)     → a <= b
+ *   NOT (a >= b)    → a < b
+ *   NOT (a IS NULL)     → a IS NOT NULL
+ *   NOT (a IS NOT NULL) → a IS NULL
+ *   NOT BETWEEN     → flip the BetweenExpr.not flag
+ *
+ * `InExpr` has no `not` field in this AST (the parser lowers `NOT IN` to a
+ * `UnaryExpr` wrapping an `InExpr`), so negating an `InExpr` falls through to
+ * the wrap-in-NOT fallback. For any other shape the result is
+ * `{ type: 'unary', operator: 'NOT', ... }` — `extractCheckConstraints` will
+ * then ignore it, which is the safe outcome.
+ */
+export declare function negateAst(expr: AST.Expression): AST.Expression;
+//# sourceMappingURL=assertion-classifier.d.ts.map

package/dist/src/planner/analysis/assertion-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-classifier.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/assertion-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,uBAAuB;IACvC,+DAA+D;IAC/D,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC;IACzC,yDAAyD;IACzD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAID;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC3C,SAAS,EAAE,wBAAwB,EACnC,aAAa,EAAE,aAAa,GAC1B,uBAAuB,GAAG,SAAS,CA0ErC;AAyFD,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU,CA8D9D"}

package/dist/src/planner/analysis/assertion-classifier.js

@@ -0,0 +1,286 @@
+/**
+ * Classify a `create assertion` for optimizer-hoisting eligibility.
+ *
+ * Recognized canonical form (purely syntactic on the AST):
+ *
+ *   not exists (select 1 from T [where P])
+ *
+ * where `T` is a base table (not a view, CTE, or TVF) and `P` references only
+ * columns of `T`. The negated predicate `not P` is hoisted onto `T` as if it
+ * were a per-row CHECK constraint — see ticket
+ * `3-optimizer-assertion-as-rewrite-premise` for the rationale.
+ *
+ * Anything outside this shape — existential `exists(...)`, aggregate
+ * `(select count(*) ...) = 0`, multi-table joins, non-deterministic calls,
+ * nested subqueries, view-targeted assertions, etc. — is silently rejected;
+ * the assertion falls through to commit-time enforcement, which remains the
+ * source of truth.
+ */
+import { containsNonDeterministicCall } from './check-extraction.js';
+import { collectColumnNames } from './predicate-shape.js';
+const allDeterministic = () => true;
+/**
+ * Return a hoist candidate if the assertion matches the canonical
+ * `not exists (select 1 from T [where P])` shape with a base-table target
+ * and a determinist column-only predicate. Otherwise `undefined`.
+ */
+export function classifyAssertionForHoisting(assertion, schemaManager) {
+    const expr = assertion.checkExpression;
+    if (!expr)
+        return undefined;
+    // Outer: NOT. The parser preserves lexeme case verbatim, so we
+    // compare case-insensitively to handle both `NOT EXISTS` and `not exists`.
+    if (expr.type !== 'unary')
+        return undefined;
+    const outer = expr;
+    if (outer.operator.toUpperCase() !== 'NOT')
+        return undefined;
+    // Inner: EXISTS (...)
+    if (outer.expr.type !== 'exists')
+        return undefined;
+    const existsExpr = outer.expr;
+    const sel = existsExpr.subquery;
+    // Strict shape gates on the inner SELECT.
+    if (sel.compound)
+        return undefined;
+    if (sel.union)
+        return undefined;
+    if (sel.groupBy && sel.groupBy.length > 0)
+        return undefined;
+    if (sel.having)
+        return undefined;
+    if (sel.orderBy && sel.orderBy.length > 0)
+        return undefined;
+    if (sel.limit)
+        return undefined;
+    if (sel.offset)
+        return undefined;
+    if (sel.withClause)
+        return undefined;
+    // Single base-table FROM clause.
+    const fromClauses = sel.from;
+    if (!fromClauses || fromClauses.length !== 1)
+        return undefined;
+    const fromItem = fromClauses[0];
+    if (fromItem.type !== 'table')
+        return undefined;
+    const tableSource = fromItem;
+    // Resolve to a base TableSchema.
+    const tableSchema = schemaManager.findTable(tableSource.table.name, tableSource.table.schema);
+    if (!tableSchema)
+        return undefined;
+    // Unconditional-empty case is out of scope for this pilot — it would
+    // synthesize `check (false)` on T, which is correct but too aggressive
+    // without further safeguards.
+    const innerPredicate = sel.where;
+    if (!innerPredicate)
+        return undefined;
+    // The inner predicate may only reference columns of T (no correlated refs).
+    // `collectColumnNames` walks for column / identifier nodes that resolve via
+    // `columnIndexMap` — any unrecognized reference (column from a different
+    // table, qualified `other.x`, etc.) is silently excluded from the set, so
+    // we need to verify the predicate doesn't reference anything else. We do
+    // that by scanning for any column / identifier node that doesn't resolve.
+    if (predicateReferencesForeignColumns(innerPredicate, tableSchema.columnIndexMap)) {
+        return undefined;
+    }
+    // Non-determinism / subquery / aggregate gate. `containsNonDeterministicCall`
+    // rejects any subquery or exists node, which is exactly the conservative
+    // behaviour we want for the inner predicate (the OUTER `not exists` is
+    // fine — we already structurally matched it; we only check the inner
+    // predicate body here).
+    if (containsNonDeterministicCall(innerPredicate, allDeterministic)) {
+        return undefined;
+    }
+    // The whole inner predicate must not contain aggregates (functions like
+    // count/sum/min/max/avg). `allDeterministic` accepts every function, so we
+    // add a separate aggregate-reject pass.
+    if (containsAggregateCall(innerPredicate))
+        return undefined;
+    return {
+        baseTableQualifiedName: `${tableSchema.schemaName.toLowerCase()}.${tableSchema.name.toLowerCase()}`,
+        innerPredicate,
+        assertionName: assertion.name.toLowerCase(),
+    };
+}
+const AGGREGATE_NAMES = new Set([
+    'count', 'sum', 'avg', 'min', 'max',
+    'total', 'group_concat',
+    'json_group_array', 'json_group_object',
+]);
+function containsAggregateCall(expr) {
+    const stack = [expr];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'function') {
+            const fn = node;
+            if (AGGREGATE_NAMES.has(fn.name.toLowerCase()))
+                return true;
+        }
+        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 false;
+}
+/**
+ * True if any `column` / `identifier` node in `expr` does NOT resolve via the
+ * target table's `columnIndexMap`. Catches correlated references (`u.foo`
+ * where `u` is some other table) and qualified `schema.table.col` references
+ * that don't belong to the target table.
+ */
+function predicateReferencesForeignColumns(expr, columnIndexMap) {
+    const stack = [expr];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'column') {
+            const col = node;
+            // Reject schema-qualified or foreign-table-qualified references.
+            if (col.schema)
+                return true;
+            if (col.table) {
+                // Could be the target table's name; accept only if resolves.
+                if (!columnIndexMap.has(col.name.toLowerCase()))
+                    return true;
+            }
+            else {
+                if (!columnIndexMap.has(col.name.toLowerCase()))
+                    return true;
+            }
+        }
+        else if (node.type === 'identifier') {
+            const id = node;
+            if (id.schema)
+                return true;
+            // Identifiers used as column references must resolve.
+            if (!columnIndexMap.has(id.name.toLowerCase())) {
+                // Identifier could also be e.g. a function-call name nested under a
+                // `function` node — those are visited via the function node itself,
+                // not as direct identifiers in expression position. Be conservative:
+                // reject the assertion. The conservative path matches the rest of
+                // the classifier — when in doubt, fall through to commit-time
+                // enforcement.
+                return true;
+            }
+        }
+        for (const key of Object.keys(node)) {
+            // Skip identifier name nodes wrapped inside function calls (already handled).
+            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 false;
+}
+// Re-export for tests / callers that want to drive these directly.
+export { collectColumnNames };
+/**
+ * AST-level NOT pusher. Mirrors `predicate-normalizer.ts:pushNotDown` in
+ * spirit but operates on `AST.Expression` instead of `ScalarPlanNode`. The
+ * result is fed back into `extractCheckConstraints`, which understands ANDs,
+ * comparisons, BETWEEN, and IN — so push NOT down so it ends up at the
+ * leaves where those recognizers can consume it.
+ *
+ * Rewrites (mirroring partial-unique's rejection rules where applicable):
+ *   NOT (a AND b)   → (NOT a) OR (NOT b)
+ *   NOT (a OR b)    → (NOT a) AND (NOT b)
+ *   NOT (NOT x)     → x
+ *   NOT (a = b)     → a <> b      (and `==` ↦ <>)
+ *   NOT (a <> b)    → a = b       (and `!=` ↦ =)
+ *   NOT (a < b)     → a >= b
+ *   NOT (a <= b)    → a > b
+ *   NOT (a > b)     → a <= b
+ *   NOT (a >= b)    → a < b
+ *   NOT (a IS NULL)     → a IS NOT NULL
+ *   NOT (a IS NOT NULL) → a IS NULL
+ *   NOT BETWEEN     → flip the BetweenExpr.not flag
+ *
+ * `InExpr` has no `not` field in this AST (the parser lowers `NOT IN` to a
+ * `UnaryExpr` wrapping an `InExpr`), so negating an `InExpr` falls through to
+ * the wrap-in-NOT fallback. For any other shape the result is
+ * `{ type: 'unary', operator: 'NOT', ... }` — `extractCheckConstraints` will
+ * then ignore it, which is the safe outcome.
+ */
+export function negateAst(expr) {
+    if (expr.type === 'unary') {
+        const u = expr;
+        const uOp = u.operator.toUpperCase();
+        if (uOp === 'NOT') {
+            // Double-negation eliminates.
+            return u.expr;
+        }
+        if (uOp === 'IS NULL') {
+            return { type: 'unary', operator: 'IS NOT NULL', expr: u.expr };
+        }
+        if (uOp === 'IS NOT NULL') {
+            return { type: 'unary', operator: 'IS NULL', expr: u.expr };
+        }
+        // Fall through to the wrap-in-NOT fallback.
+    }
+    if (expr.type === 'binary') {
+        const b = expr;
+        const op = b.operator.toUpperCase();
+        switch (op) {
+            case 'AND':
+                return {
+                    type: 'binary',
+                    operator: 'OR',
+                    left: negateAst(b.left),
+                    right: negateAst(b.right),
+                };
+            case 'OR':
+                return {
+                    type: 'binary',
+                    operator: 'AND',
+                    left: negateAst(b.left),
+                    right: negateAst(b.right),
+                };
+            case '=':
+            case '==':
+                return { type: 'binary', operator: '<>', left: b.left, right: b.right };
+            case '<>':
+            case '!=':
+                return { type: 'binary', operator: '=', left: b.left, right: b.right };
+            case '<':
+                return { type: 'binary', operator: '>=', left: b.left, right: b.right };
+            case '<=':
+                return { type: 'binary', operator: '>', left: b.left, right: b.right };
+            case '>':
+                return { type: 'binary', operator: '<=', left: b.left, right: b.right };
+            case '>=':
+                return { type: 'binary', operator: '<', left: b.left, right: b.right };
+            default:
+                break;
+        }
+    }
+    if (expr.type === 'between') {
+        const bt = expr;
+        return { ...bt, not: !bt.not };
+    }
+    // Fallback: wrap in a fresh NOT. `extractCheckConstraints` ignores top-level
+    // NOT, so this contributes nothing — the safe outcome for unrecognized shapes.
+    return { type: 'unary', operator: 'NOT', expr };
+}
+//# sourceMappingURL=assertion-classifier.js.map

package/dist/src/planner/analysis/assertion-classifier.js.map

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

package/dist/src/planner/analysis/assertion-hoist-cache.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Per-table hoist of "trivially universal" `create assertion` predicates into
+ * FD / EC / constant-binding / domain-constraint contributions. Reuses ticket
+ * #1's `extractCheckConstraints` walker via a synthetic `RowConstraintSchema`
+ * whose `expr` is the negated inner predicate from the assertion's canonical
+ * `not exists (select 1 from T [where P])` shape.
+ *
+ * Cached per (SchemaManager, TableSchema). Invalidated by schema-change
+ * events: any `assertion_*` event bumps a generation counter; lookups whose
+ * cached generation is stale recompute. Table-side invalidation rides on
+ * `TableSchema` identity — ALTER TABLE swaps the schema instance, which is
+ * the cache key.
+ *
+ * Soundness: hoisted facts add to the optimizer's premises; they NEVER
+ * suppress commit-time assertion enforcement (that remains the source of
+ * truth in `AssertionEvaluator`).
+ */
+import type { ConstantBinding, DomainConstraint, FunctionalDependency } from '../nodes/plan-node.js';
+import type { TableSchema } from '../../schema/table.js';
+import type { SchemaManager } from '../../schema/manager.js';
+export interface HoistedConstraintsForTable {
+    readonly fds: ReadonlyArray<FunctionalDependency>;
+    readonly equivPairs: ReadonlyArray<readonly [number, number]>;
+    readonly constantBindings: ReadonlyArray<ConstantBinding>;
+    readonly domainConstraints: ReadonlyArray<DomainConstraint>;
+}
+/**
+ * Build (or look up) the hoisted constraint contributions for `table` derived
+ * from every qualifying `create assertion` known to `schemaManager`. Safe to
+ * call from `TableReferenceNode.computePhysical` — results are cached per
+ * (manager, table-instance) and invalidated by assertion schema-change events.
+ */
+export declare function getAssertionHoistedConstraints(schemaManager: SchemaManager, table: TableSchema): HoistedConstraintsForTable;
+//# sourceMappingURL=assertion-hoist-cache.d.ts.map

package/dist/src/planner/analysis/assertion-hoist-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion-hoist-cache.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/assertion-hoist-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EACX,eAAe,EAEf,gBAAgB,EAChB,oBAAoB,EACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAkC,MAAM,uBAAuB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAO7D,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,GAAG,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,gBAAgB,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAC1D,QAAQ,CAAC,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CAC5D;AAgDD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC7C,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,WAAW,GAChB,0BAA0B,CAmE5B"}

package/dist/src/planner/analysis/assertion-hoist-cache.js

@@ -0,0 +1,119 @@
+/**
+ * Per-table hoist of "trivially universal" `create assertion` predicates into
+ * FD / EC / constant-binding / domain-constraint contributions. Reuses ticket
+ * #1's `extractCheckConstraints` walker via a synthetic `RowConstraintSchema`
+ * whose `expr` is the negated inner predicate from the assertion's canonical
+ * `not exists (select 1 from T [where P])` shape.
+ *
+ * Cached per (SchemaManager, TableSchema). Invalidated by schema-change
+ * events: any `assertion_*` event bumps a generation counter; lookups whose
+ * cached generation is stale recompute. Table-side invalidation rides on
+ * `TableSchema` identity — ALTER TABLE swaps the schema instance, which is
+ * the cache key.
+ *
+ * Soundness: hoisted facts add to the optimizer's premises; they NEVER
+ * suppress commit-time assertion enforcement (that remains the source of
+ * truth in `AssertionEvaluator`).
+ */
+import { createLogger } from '../../common/logger.js';
+import { extractCheckConstraints } from './check-extraction.js';
+import { classifyAssertionForHoisting, negateAst } from './assertion-classifier.js';
+const log = createLogger('planner:analysis:assertion-hoist');
+const EMPTY = {
+    fds: [],
+    equivPairs: [],
+    constantBindings: [],
+    domainConstraints: [],
+};
+const registries = new WeakMap();
+function getRegistry(schemaManager) {
+    let reg = registries.get(schemaManager);
+    if (reg)
+        return reg;
+    const newReg = {
+        generation: 0,
+        cache: new WeakMap(),
+        unsubscribe: () => undefined,
+    };
+    const notifier = schemaManager.getChangeNotifier();
+    newReg.unsubscribe = notifier.addListener((event) => {
+        if (event.type === 'assertion_added' ||
+            event.type === 'assertion_removed' ||
+            event.type === 'assertion_modified') {
+            newReg.generation++;
+        }
+    });
+    registries.set(schemaManager, newReg);
+    reg = newReg;
+    return reg;
+}
+const allDeterministic = () => true;
+/**
+ * Build (or look up) the hoisted constraint contributions for `table` derived
+ * from every qualifying `create assertion` known to `schemaManager`. Safe to
+ * call from `TableReferenceNode.computePhysical` — results are cached per
+ * (manager, table-instance) and invalidated by assertion schema-change events.
+ */
+export function getAssertionHoistedConstraints(schemaManager, table) {
+    // Re-entrancy guard: when AssertionEvaluator is compiling an assertion's
+    // own violation query, returning the hoisted facts would let the optimizer
+    // fold the violation query to empty (the assertion's claim would prove
+    // itself), defeating commit-time enforcement. Skip the cache entirely so
+    // non-suppressed lookups continue to see fully-hoisted results.
+    if (schemaManager.isAssertionHoistSuppressed()) {
+        return EMPTY;
+    }
+    const reg = getRegistry(schemaManager);
+    const cached = reg.cache.get(table);
+    if (cached && cached.generation === reg.generation) {
+        return cached.value;
+    }
+    const targetName = `${table.schemaName.toLowerCase()}.${table.name.toLowerCase()}`;
+    const synthChecks = [];
+    const provenanceByCheckIdx = [];
+    for (const assertion of schemaManager.getAllAssertions()) {
+        const candidate = classifyAssertionForHoisting(assertion, schemaManager);
+        if (!candidate)
+            continue;
+        if (candidate.baseTableQualifiedName !== targetName)
+            continue;
+        if (!candidate.innerPredicate)
+            continue;
+        // Synthetic check on T: per-row `not P`. `operations` is unused by
+        // extractCheckConstraints; defaulting to 0 is safe.
+        synthChecks.push({
+            name: `__assertion_${candidate.assertionName}`,
+            expr: negateAst(candidate.innerPredicate),
+            operations: 0,
+        });
+        provenanceByCheckIdx.push({ kind: 'assertion', name: candidate.assertionName });
+        log('Hoisted assertion %s onto %s', candidate.assertionName, targetName);
+    }
+    let result = EMPTY;
+    if (synthChecks.length > 0) {
+        // Run each synthetic check separately so we can tag provenance per
+        // assertion. (extractCheckConstraints iterates checks but does not
+        // surface which check produced which fact.)
+        const fds = [];
+        const equivPairs = [];
+        const constantBindings = [];
+        const domainConstraints = [];
+        for (let i = 0; i < synthChecks.length; i++) {
+            const prov = provenanceByCheckIdx[i];
+            const ext = extractCheckConstraints([synthChecks[i]], table.columnIndexMap, allDeterministic);
+            for (const fd of ext.fds)
+                fds.push({ ...fd, source: prov });
+            for (const p of ext.equivPairs)
+                equivPairs.push(p);
+            for (const b of ext.constantBindings)
+                constantBindings.push({ ...b, source: prov });
+            for (const d of ext.domainConstraints) {
+                domainConstraints.push({ ...d, source: prov });
+            }
+        }
+        result = { fds, equivPairs, constantBindings, domainConstraints };
+    }
+    reg.cache.set(table, { generation: reg.generation, value: result });
+    return result;
+}
+//# sourceMappingURL=assertion-hoist-cache.js.map

package/dist/src/planner/analysis/assertion-hoist-cache.js.map

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

package/dist/src/planner/analysis/binding-extractor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Binding-key extraction for incremental delta planning.
+ *
+ * Wraps `analyzeRowSpecific` and packages its per-relation classifications
+ * into a `BindingMode` per `TableReferenceNode` instance. The shape is
+ * consumer-neutral — assertions, materialized views, and any other change-
+ * driven consumer can register a `DeltaSubscription` against the same
+ * `PlanBindings`.
+ *
+ * - 'row' bindings carry the unique-key columns to bind on (PK preferred,
+ *   else the lex-min covered key under FD closure).
+ * - 'group' bindings carry the minimal GROUP BY columns recovered from
+ *   `analyzeRowSpecific.groupKeys`.
+ * - 'global' bindings carry no extra metadata — the consumer evaluates its
+ *   plan once for any dependency change.
+ */
+import { PlanNode, type RelationalPlanNode } from '../nodes/plan-node.js';
+/**
+ * The way one plan instance binds to its changes.
+ *
+ * - `'global'`: the plan re-runs once when any dependency table changes.
+ * - `'row'`: the plan binds on `keyColumns` (output-column indices on the
+ *   table reference). Consumers parameterize per changed PK tuple.
+ * - `'group'`: the plan binds on `groupColumns` (output-column indices on
+ *   the table reference). Consumers parameterize per changed group-key
+ *   tuple, including OLD and NEW projections when group membership shifts.
+ */
+export type BindingMode = {
+    kind: 'global';
+} | {
+    kind: 'row';
+    keyColumns: number[];
+} | {
+    kind: 'group';
+    groupColumns: number[];
+};
+/**
+ * Per-`TableReferenceNode` binding info for a plan, plus a quick lookup
+ * from `relationKey` to the qualified base table name (lowercased).
+ */
+export interface PlanBindings {
+    /** For each TableReference instance in the plan, how this plan is bound to its changes. */
+    perRelation: Map<string, BindingMode>;
+    /** Convenience: relationKey → base table name (lowercased `schema.table`). */
+    relationToBase: Map<string, string>;
+}
+/**
+ * Walk a plan and emit the per-`TableReferenceNode` binding modes the runtime
+ * needs to parameterize a delta-driven consumer over the same plan.
+ *
+ * The selection rule for `'row'` matches what the assertion path already
+ * picks: prefer the primary key when it's covered, else fall back to the
+ * first covered unique key (lex-min by column index). For `'group'`,
+ * `groupKeys.get(relKey)` from `analyzeRowSpecific` is copied through
+ * verbatim — already in the table reference's output-column space.
+ */
+export declare function extractBindings(plan: PlanNode | RelationalPlanNode): PlanBindings;
+//# sourceMappingURL=binding-extractor.d.ts.map

package/dist/src/planner/analysis/binding-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-extractor.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/binding-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI1E;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GACpB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,MAAM,EAAE,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAE7C;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B,2FAA2F;IAC3F,WAAW,EAAE,GAAG,CAAC,MAAM,EAAoB,WAAW,CAAC,CAAC;IACxD,8EAA8E;IAC9E,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,GAAG,YAAY,CA6CjF"}