@quereus/quereus 4.4.0 → 4.4.1

package/dist/src/runtime/foreign-key-actions.d.ts

@@ -1,6 +1,41 @@
 import type { Database } from '../core/database.js';
 import type { TableSchema } from '../schema/table.js';
-import type { Row } from '../common/types.js';
+import type { Row, SqlValue } from '../common/types.js';
+import type { BatchableRestrictFk } from '../planner/building/foreign-key-builder.js';
+/** Per-FK accumulation state for one statement execution. */
+export interface ParentRestrictBatchEntry extends BatchableRestrictFk {
+    /** Deduplicated OLD referenced-key tuples, keyed by an injective serialization. */
+    readonly keys: Map<string, SqlValue[]>;
+}
+export type ParentRestrictBatch = ParentRestrictBatchEntry[];
+/**
+ * Allocate the per-statement-execution accumulation state for the batchable
+ * inbound RESTRICT FKs. Must be called once per execution (never cached on the
+ * emit closure) so a re-run prepared statement starts empty.
+ */
+export declare function createParentRestrictBatch(fks: readonly BatchableRestrictFk[]): ParentRestrictBatch;
+/**
+ * Accumulate one mutated parent row's OLD referenced-key tuples into the batch
+ * — the batched replacement for the per-row RESTRICT probes, applying the same
+ * skip rules: MATCH SIMPLE (a tuple containing NULL is unreferenceable) and,
+ * for UPDATE, the referenced-column-change short-circuit.
+ */
+export declare function accumulateParentRestrictKeys(batch: ParentRestrictBatch, operation: 'delete' | 'update', oldRow: Row, newRow?: Row): void;
+/**
+ * End-of-statement flush: one chunked probe per inbound RESTRICT FK over the
+ * accumulated key tuples. Fired by `runWithStatementSavepoints` after the row
+ * loop and BEFORE the deferred-maintenance flush and the statement savepoint
+ * release, so a hit throws the existing RESTRICT error shape and rolls the
+ * whole statement back. Re-checks the `foreign_keys` pragma and the
+ * trust-the-origin suppression at flush time, mirroring the per-row pre-check.
+ *
+ * The probe selects the FK columns (not `select 1`) so the violating key stays
+ * available for a future richer message; the message itself is unchanged and
+ * matcher-compatible (`/constraint|foreign|fk/i`). Comparison rides plain SQL
+ * `=` / `IN` against the child column — identical collation semantics to the
+ * per-row `NOT EXISTS` by construction.
+ */
+export declare function flushParentRestrictBatch(db: Database, parentTable: TableSchema, operation: 'delete' | 'update', batch: ParentRestrictBatch): Promise<void>;
 /**
  * Executes cascading foreign key actions when a parent row is deleted or updated.
  *

package/dist/src/runtime/foreign-key-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foreign-key-actions.d.ts","sourceRoot":"","sources":["../../../src/runtime/foreign-key-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,oBAAoB,CAAC;AAGlF,OAAO,KAAK,EAAE,GAAG,EAAY,MAAM,oBAAoB,CAAC;AAkBxD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAC7C,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,EAClB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,IAAI,CAAC,CAyDf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,+BAA+B,CACpD,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,GAChB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,0CAA0C,CAC/D,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,EAClB,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACnB,OAAO,CAAC,IAAI,CAAC,CAqJf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,2CAA2C,CAChE,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,GAChB,OAAO,CAAC,IAAI,CAAC,CAwEf;AA+GD;;;;;;;;;;;;GAYG;AACH,wBAAsB,4BAA4B,CACjD,EAAE,EAAE,QAAQ,EACZ,gBAAgB,EAAE,WAAW,EAC7B,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,GACV,OAAO,CAAC,IAAI,CAAC,CAuBf;AAmMD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oCAAoC,CACzD,EAAE,EAAE,QAAQ,EACZ,gBAAgB,EAAE,WAAW,EAC7B,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,GACV,OAAO,CAAC,IAAI,CAAC,CA0Bf"}
+{"version":3,"file":"foreign-key-actions.d.ts","sourceRoot":"","sources":["../../../src/runtime/foreign-key-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,oBAAoB,CAAC;AAGlF,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAexD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4CAA4C,CAAC;AAkBtF,6DAA6D;AAC7D,MAAM,WAAW,wBAAyB,SAAQ,mBAAmB;IACpE,mFAAmF;IACnF,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;CACvC;AAED,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,EAAE,CAAC;AAK7D;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,SAAS,mBAAmB,EAAE,GAAG,mBAAmB,CAElG;AAsDD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,GACV,IAAI,CAcN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAC7C,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,KAAK,EAAE,mBAAmB,GACxB,OAAO,CAAC,IAAI,CAAC,CAmDf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAC7C,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,EAClB,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,IAAI,CAAC,CAoEf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,+BAA+B,CACpD,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,GAChB,OAAO,CAAC,IAAI,CAAC,CAKf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,0CAA0C,CAC/D,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,EAClB,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACnB,OAAO,CAAC,IAAI,CAAC,CA8If;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,2CAA2C,CAChE,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,EACZ,UAAU,UAAQ,GAChB,OAAO,CAAC,IAAI,CAAC,CAwDf;AAoHD;;;;;;;;;;;;GAYG;AACH,wBAAsB,4BAA4B,CACjD,EAAE,EAAE,QAAQ,EACZ,gBAAgB,EAAE,WAAW,EAC7B,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,GACV,OAAO,CAAC,IAAI,CAAC,CAuBf;AA+LD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oCAAoC,CACzD,EAAE,EAAE,QAAQ,EACZ,gBAAgB,EAAE,WAAW,EAC7B,SAAS,EAAE,QAAQ,GAAG,QAAQ,EAC9B,MAAM,EAAE,GAAG,EACX,MAAM,CAAC,EAAE,GAAG,GACV,OAAO,CAAC,IAAI,CAAC,CA0Bf"}

package/dist/src/runtime/foreign-key-actions.js

@@ -7,6 +7,154 @@ import { sqlValueIdentical } from '../util/comparison.js';
 import { resolveSlotBasisSource } from '../schema/lens-prover.js';
 import { findLogicalParentFkRefs, logicalToBasisColumnMap, matchingBasisFksForLensRef, basisFksOverriddenByDivergentLensFk, } from '../schema/lens-fk-discovery.js';
 const log = createLogger('runtime:fk-actions');
+/** Keys probed per child-table query — a handful of compiles per statement, not one per row. */
+const RESTRICT_BATCH_CHUNK = 500;
+/**
+ * Allocate the per-statement-execution accumulation state for the batchable
+ * inbound RESTRICT FKs. Must be called once per execution (never cached on the
+ * emit closure) so a re-run prepared statement starts empty.
+ */
+export function createParentRestrictBatch(fks) {
+    return fks.map(fk => ({ ...fk, keys: new Map() }));
+}
+/**
+ * Injective serialization of a referenced-key tuple for dedup. Each segment is
+ * type-tagged and (for variable-length payloads) length-prefixed, so two
+ * distinct tuples can never collide — a collision would silently drop a probe.
+ */
+function serializeKeyTuple(values) {
+    let out = '';
+    for (const v of values) {
+        if (typeof v === 'number')
+            out += `n${v};`;
+        else if (typeof v === 'bigint')
+            out += `i${v};`;
+        else if (typeof v === 'string')
+            out += `s${v.length}:${v};`;
+        else if (v instanceof Uint8Array)
+            out += `b${v.length}:${Array.from(v).join(',')};`;
+        else
+            out += `x${String(v)};`;
+    }
+    return out;
+}
+/**
+ * The shared UPDATE short-circuit behind every parent-side RESTRICT / cascade site:
+ * true when at least one of `colIndices` would actually STORE a different value.
+ *
+ * Both rows arrive in declared (stored) form: `oldRow` comes from the source scan,
+ * and `newRow` was converted to declared column types by the DML emitters before
+ * the executor's pre-vtab checks run (ticket `json-coerce-once-at-dml-source` —
+ * this used to re-convert `newRow` per cell because it arrived raw). So the test
+ * is plain value identity.
+ *
+ * Deliberately BINARY identity rather than the column's collation: a NOCASE parent
+ * column still stores `'A'` and `'a'` as distinct values, and the child's own match
+ * runs under the CHILD column's collation, which may well be BINARY. A spurious
+ * "changed" costs one redundant RESTRICT probe; a spurious "unchanged" would SKIP
+ * enforcement entirely — so identity is the safe direction.
+ *
+ * NOTE: every caller today supplies declared-form rows (the DML executor's converted
+ * NEW row; materialized-view maintenance passes the changes `applyMaintenance`
+ * reports, i.e. what the backing actually stored). A future caller that hands in a
+ * RAW proposed row would see spurious "changed" on any cell conversion normalizes —
+ * harmless on the cascade path, but a spurious RESTRICT error on the assert path. If
+ * one appears, convert at that caller rather than re-introducing a per-cell coercion
+ * here.
+ */
+function anyReferencedColumnChanged(colIndices, oldRow, newRow) {
+    for (const idx of colIndices) {
+        if (!sqlValueIdentical(oldRow[idx], newRow[idx]))
+            return true;
+    }
+    return false;
+}
+/**
+ * Accumulate one mutated parent row's OLD referenced-key tuples into the batch
+ * — the batched replacement for the per-row RESTRICT probes, applying the same
+ * skip rules: MATCH SIMPLE (a tuple containing NULL is unreferenceable) and,
+ * for UPDATE, the referenced-column-change short-circuit.
+ */
+export function accumulateParentRestrictKeys(batch, operation, oldRow, newRow) {
+    for (const entry of batch) {
+        // UPDATE: only rows that actually re-key a referenced column contribute.
+        if (operation === 'update' && newRow !== undefined) {
+            if (!anyReferencedColumnChanged(entry.parentColIndices, oldRow, newRow))
+                continue;
+        }
+        // MATCH SIMPLE: NULL parent values cannot be referenced.
+        const values = entry.parentColIndices.map(idx => oldRow[idx]);
+        if (values.some(v => v === null || v === undefined))
+            continue;
+        const key = serializeKeyTuple(values);
+        if (!entry.keys.has(key))
+            entry.keys.set(key, values);
+    }
+}
+/**
+ * End-of-statement flush: one chunked probe per inbound RESTRICT FK over the
+ * accumulated key tuples. Fired by `runWithStatementSavepoints` after the row
+ * loop and BEFORE the deferred-maintenance flush and the statement savepoint
+ * release, so a hit throws the existing RESTRICT error shape and rolls the
+ * whole statement back. Re-checks the `foreign_keys` pragma and the
+ * trust-the-origin suppression at flush time, mirroring the per-row pre-check.
+ *
+ * The probe selects the FK columns (not `select 1`) so the violating key stays
+ * available for a future richer message; the message itself is unchanged and
+ * matcher-compatible (`/constraint|foreign|fk/i`). Comparison rides plain SQL
+ * `=` / `IN` against the child column — identical collation semantics to the
+ * per-row `NOT EXISTS` by construction.
+ */
+export async function flushParentRestrictBatch(db, parentTable, operation, batch) {
+    if (db._isFkRestrictSuppressed())
+        return;
+    if (!db.options.getBooleanOption('foreign_keys'))
+        return;
+    for (const entry of batch) {
+        if (entry.keys.size === 0)
+            continue;
+        const { childTable, fk } = entry;
+        const childColQuoted = fk.columns.map(idx => quoteIdentifier(childTable.columns[idx].name));
+        const schemaPrefix = childTable.schemaName.toLowerCase() !== 'main'
+            ? `${quoteIdentifier(childTable.schemaName)}.`
+            : '';
+        const from = `${schemaPrefix}${quoteIdentifier(childTable.name)}`;
+        const tuples = [...entry.keys.values()];
+        for (let i = 0; i < tuples.length; i += RESTRICT_BATCH_CHUNK) {
+            const chunk = tuples.slice(i, i + RESTRICT_BATCH_CHUNK);
+            let whereClause;
+            let params;
+            if (childColQuoted.length === 1) {
+                whereClause = `${childColQuoted[0]} in (${chunk.map(() => '?').join(', ')})`;
+                params = chunk.map(t => t[0]);
+            }
+            else {
+                whereClause = chunk
+                    .map(() => `(${childColQuoted.map(c => `${c} = ?`).join(' and ')})`)
+                    .join(' or ');
+                params = chunk.flat();
+            }
+            const sql = `select ${childColQuoted.join(', ')} from ${from} where ${whereClause} limit 1`;
+            log('RESTRICT batch check (%s): child=%s keys=%d', operation, childTable.name, chunk.length);
+            const stmt = db.prepare(sql);
+            try {
+                stmt.bindAll(params);
+                let referenced = false;
+                for await (const _row of stmt._iterateRowsRaw()) {
+                    referenced = true;
+                    break;
+                }
+                if (referenced) {
+                    const opName = operation === 'delete' ? 'DELETE' : 'UPDATE';
+                    throw new QuereusError(`FOREIGN KEY constraint failed: ${opName} on '${parentTable.name}' violates RESTRICT from '${childTable.name}'`, StatusCode.CONSTRAINT);
+                }
+            }
+            finally {
+                await stmt.finalize();
+            }
+        }
+    }
+}
 /**
  * Executes cascading foreign key actions when a parent row is deleted or updated.
  *
@@ -56,6 +204,17 @@ export async function executeForeignKeyActions(db, parentTable, operation, oldRo
             const parentColIndices = resolveReferencedColumns(fk, parentTable);
             if (parentColIndices.length !== fk.columns.length)
                 continue;
+            // UPDATE: an ON UPDATE action propagates a change to the parent's REFERENCED
+            // columns, so an update that leaves them alone must not touch the child at
+            // all. Without this the child DML re-issues unconditionally: SET DEFAULT /
+            // SET NULL silently re-point or null the child, and CASCADE rewrites the
+            // child to the value it already holds (a real storage write plus a
+            // data-change event with an empty changed-column list). Same short-circuit
+            // the RESTRICT sites and the lens walker already apply.
+            if (operation === 'update' && newRow !== undefined) {
+                if (!anyReferencedColumnChanged(parentColIndices, oldRow, newRow))
+                    continue;
+            }
             // Get old parent values for the referenced columns
             const oldParentValues = parentColIndices.map(idx => oldRow[idx]);
             // Skip if any old value is NULL (NULLs don't participate in FK matching)
@@ -186,14 +345,7 @@ export async function assertTransitiveRestrictsForParentMutation(db, parentTable
             // UPDATE-only short-circuit: skip if no referenced parent column changed.
             let newParentValues;
             if (operation === 'update' && newRow !== undefined) {
-                let anyChanged = false;
-                for (const idx of parentColIndices) {
-                    if (!sqlValueIdentical(oldRow[idx], newRow[idx])) {
-                        anyChanged = true;
-                        break;
-                    }
-                }
-                if (!anyChanged)
+                if (!anyReferencedColumnChanged(parentColIndices, oldRow, newRow))
                     continue;
                 newParentValues = parentColIndices.map(idx => newRow[idx]);
             }
@@ -205,62 +357,61 @@ export async function assertTransitiveRestrictsForParentMutation(db, parentTable
                 : '';
             const sql = `select * from ${schemaPrefix}${quoteIdentifier(childTable.name)} where ${whereClause}`;
             log('TRANSITIVE pre-walk: %s with params %o', sql, oldParentValues);
-            const stmt = db.prepare(sql);
-            try {
-                stmt.bindAll(oldParentValues);
-                for await (const childOldRow of stmt._iterateRowsRaw()) {
-                    let childNewRow;
-                    let childOp;
-                    if (action === 'cascade' && operation === 'delete') {
-                        childOp = 'delete';
-                        childNewRow = undefined;
-                    }
-                    else if (action === 'cascade' && operation === 'update' && newParentValues) {
-                        childOp = 'update';
-                        const next = [...childOldRow];
-                        for (let i = 0; i < fk.columns.length; i++) {
-                            next[fk.columns[i]] = newParentValues[i];
-                        }
-                        childNewRow = next;
-                    }
-                    else if (action === 'setNull') {
-                        childOp = 'update';
-                        const next = [...childOldRow];
-                        for (let i = 0; i < fk.columns.length; i++) {
-                            next[fk.columns[i]] = null;
-                        }
-                        childNewRow = next;
-                    }
-                    else if (action === 'setDefault') {
-                        // SET DEFAULT recursion: pass the child OLD row as both
-                        // old and new. The recursion's column-change short-circuit
-                        // will treat this as "no FK column moved" and the per-target
-                        // cascade SQL (executeSingleFKAction) still fires its own
-                        // RESTRICT enforcement for non-rowid-chained backends. This
-                        // matches the coverage gap SET DEFAULT already has in
-                        // rowid-chained backends — no regression beyond status quo.
-                        childOp = 'update';
-                        childNewRow = childOldRow;
+            // Cached internal statement leased for the whole scan (compiled once per
+            // shape, not re-prepared per parent row). The recursion inside this loop
+            // can re-enter with the SAME SQL text (self-referential / diamond FK graph)
+            // while this statement is still iterating — that re-entry hits the cache's
+            // busy-guard and gets its own fresh one-shot statement, never this live
+            // cursor. See InternalStatementCache.iterate.
+            for await (const childOldRow of db._internalStatementCache.iterate(sql, oldParentValues)) {
+                let childNewRow;
+                let childOp;
+                if (action === 'cascade' && operation === 'delete') {
+                    childOp = 'delete';
+                    childNewRow = undefined;
+                }
+                else if (action === 'cascade' && operation === 'update' && newParentValues) {
+                    childOp = 'update';
+                    const next = [...childOldRow];
+                    for (let i = 0; i < fk.columns.length; i++) {
+                        next[fk.columns[i]] = newParentValues[i];
                     }
-                    else {
-                        continue;
+                    childNewRow = next;
+                }
+                else if (action === 'setNull') {
+                    childOp = 'update';
+                    const next = [...childOldRow];
+                    for (let i = 0; i < fk.columns.length; i++) {
+                        next[fk.columns[i]] = null;
                     }
-                    // Recurse carrying the SAME `lensRouted`: the nested levels are the
-                    // transitive closure of *this* write, so when the top-level write is
-                    // lens-routed every level inherits the logical FK semantics. This is
-                    // load-bearing for a logical RESTRICT sitting below an *agreeing*
-                    // basis cascade (basis + logical both cascade): at runtime that basis
-                    // cascade executes as a basis-direct write — which does NOT fire the
-                    // deeper lens RESTRICT — and the agreeing lens cascade is elided, so it
-                    // never re-enters through the child view either. The ONLY place that
-                    // deeper RESTRICT is caught is this pre-walk recursing with the lens flag
-                    // still set. For a basis-direct top-level write `lensRouted` is already
-                    // false, so the recursion correctly stays basis-only throughout.
-                    await assertTransitiveRestrictsForParentMutation(db, childTable, childOp, childOldRow, childNewRow, lensRouted, visitedSet);
+                    childNewRow = next;
                 }
-            }
-            finally {
-                await stmt.finalize();
+                else if (action === 'setDefault') {
+                    // SET DEFAULT recursion: pass the child OLD row as both
+                    // old and new. The recursion's column-change short-circuit
+                    // will treat this as "no FK column moved" and the per-target
+                    // cascade SQL (executeSingleFKAction) still fires its own
+                    // RESTRICT enforcement for non-rowid-chained backends. This
+                    // matches the coverage gap SET DEFAULT already has in
+                    // rowid-chained backends — no regression beyond status quo.
+                    childOp = 'update';
+                    childNewRow = childOldRow;
+                }
+                else {
+                    continue;
+                }
+                // Recurse carrying the SAME `lensRouted`: the nested levels are the
+                // transitive closure of *this* write, so when the top-level write is
+                // lens-routed every level inherits the logical FK semantics. This is
+                // load-bearing for a logical RESTRICT sitting below an *agreeing*
+                // basis cascade (basis + logical both cascade): at runtime that basis
+                // cascade executes as a basis-direct write — which does NOT fire the
+                // deeper lens RESTRICT — and the agreeing lens cascade is elided, so it
+                // never re-enters through the child view either. The ONLY place that
+                // deeper RESTRICT is caught is this pre-walk recursing with the lens flag
+                // still set. For a basis-direct top-level write `lensRouted` is already
+                // false, so the recursion correctly stays basis-only throughout.
+                await assertTransitiveRestrictsForParentMutation(db, childTable, childOp, childOldRow, childNewRow, lensRouted, visitedSet);
             }
         }
     }
@@ -317,14 +468,7 @@ export async function assertNoRestrictedChildrenForParentMutation(db, parentTabl
             continue;
         // UPDATE: only enforce when at least one referenced parent column changed.
         if (operation === 'update' && newRow !== undefined) {
-            let anyChanged = false;
-            for (const idx of parentColIndices) {
-                if (!sqlValueIdentical(oldRow[idx], newRow[idx])) {
-                    anyChanged = true;
-                    break;
-                }
-            }
-            if (!anyChanged)
+            if (!anyReferencedColumnChanged(parentColIndices, oldRow, newRow))
                 continue;
         }
         // MATCH SIMPLE: NULL parent values cannot be referenced.
@@ -338,21 +482,11 @@ export async function assertNoRestrictedChildrenForParentMutation(db, parentTabl
             : '';
         const sql = `select 1 from ${schemaPrefix}${quoteIdentifier(childTable.name)} where ${whereClause} limit 1`;
         log('RESTRICT check (%s): %s with params %o', operation, sql, oldParentValues);
-        const stmt = db.prepare(sql);
-        try {
-            stmt.bindAll(oldParentValues);
-            let referenced = false;
-            for await (const _row of stmt._iterateRowsRaw()) {
-                referenced = true;
-                break;
-            }
-            if (referenced) {
-                const opName = operation === 'delete' ? 'DELETE' : 'UPDATE';
-                throw new QuereusError(`FOREIGN KEY constraint failed: ${opName} on '${parentTable.name}' violates RESTRICT from '${childTable.name}'`, StatusCode.CONSTRAINT);
-            }
-        }
-        finally {
-            await stmt.finalize();
+        // Cached internal statement (compiled once per shape) rather than a fresh
+        // per-row prepare/finalize — see InternalStatementCache.
+        if (await db._internalStatementCache.probe(sql, oldParentValues)) {
+            const opName = operation === 'delete' ? 'DELETE' : 'UPDATE';
+            throw new QuereusError(`FOREIGN KEY constraint failed: ${opName} on '${parentTable.name}' violates RESTRICT from '${childTable.name}'`, StatusCode.CONSTRAINT);
         }
     }
 }
@@ -390,11 +524,16 @@ async function executeSingleFKAction(db, childTable, fk, action, parentTable, pa
     const qualifiedChildTable = `"${childTable.schemaName}"."${childTable.name}"`;
     switch (action) {
         case 'cascade': {
+            // NOTE: this branches purely on `newRow === undefined` to tell cascade DELETE
+            // from cascade UPDATE. Every current caller passes operation === 'update' with
+            // a defined `newRow` (see the three UPDATE sites in emit/dml-executor.ts) — if a
+            // future caller ever invoked executeForeignKeyActions with operation: 'update'
+            // and no newRow, this would silently issue a child DELETE instead.
             if (newRow === undefined) {
                 // CASCADE DELETE: delete matching child rows
                 const sql = `DELETE FROM ${qualifiedChildTable} WHERE ${whereClause}`;
                 log('CASCADE DELETE: %s with params %o', sql, oldParentValues);
-                await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, oldParentValues));
+                await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, oldParentValues));
             }
             else {
                 // CASCADE UPDATE: update child FK columns to new parent values
@@ -408,7 +547,7 @@ async function executeSingleFKAction(db, childTable, fk, action, parentTable, pa
                 const sql = `UPDATE ${qualifiedChildTable} SET ${setClauses} WHERE ${whereParamsClause}`;
                 const params = [...newParentValues, ...oldParentValues];
                 log('CASCADE UPDATE: %s with params %o', sql, params);
-                await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, params));
+                await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, params));
             }
             break;
         }
@@ -416,7 +555,7 @@ async function executeSingleFKAction(db, childTable, fk, action, parentTable, pa
             const setClauses = childColNames.map(name => `"${name}" = NULL`).join(', ');
             const sql = `UPDATE ${qualifiedChildTable} SET ${setClauses} WHERE ${whereClause}`;
             log('SET NULL: %s with params %o', sql, oldParentValues);
-            await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, oldParentValues));
+            await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, oldParentValues));
             break;
         }
         case 'setDefault': {
@@ -431,7 +570,7 @@ async function executeSingleFKAction(db, childTable, fk, action, parentTable, pa
             }).join(', ');
             const sql = `UPDATE ${qualifiedChildTable} SET ${setClauses} WHERE ${whereClause}`;
             log('SET DEFAULT: %s with params %o', sql, oldParentValues);
-            await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, oldParentValues));
+            await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, oldParentValues));
             break;
         }
     }
@@ -503,7 +642,7 @@ export async function executeLensForeignKeyActions(db, basisParentTable, operati
  * (⇒ skip this ref) when:
  *  - a referenced column has no plain basis projection (cannot read its basis value);
  *  - MATCH SIMPLE: any OLD referenced value is NULL (participates in no FK match); or
- *  - UPDATE: no referenced parent column actually changed (`sqlValueIdentical` short-circuit).
+ *  - UPDATE: no referenced parent column actually changed ({@link anyReferencedColumnChanged}).
  */
 function resolveLensFkParentReferencedValues(ref, parentMap, basisParentTable, operation, oldRow, newRow) {
     // Logical referenced column → basis column → basis index. A column with no plain basis
@@ -525,14 +664,7 @@ function resolveLensFkParentReferencedValues(ref, parentMap, basisParentTable, o
     // UPDATE short-circuit: skip when no referenced parent column actually changed.
     let newParentValues;
     if (operation === 'update' && newRow !== undefined) {
-        let anyChanged = false;
-        for (const i of basisIndices) {
-            if (!sqlValueIdentical(oldRow[i], newRow[i])) {
-                anyChanged = true;
-                break;
-            }
-        }
-        if (!anyChanged)
+        if (!anyReferencedColumnChanged(basisIndices, oldRow, newRow))
             return undefined;
         newParentValues = basisIndices.map(i => newRow[i]);
     }
@@ -607,7 +739,7 @@ async function issueLensFkAction(db, ref, action, operation, oldParentValues, ne
             if (operation === 'delete') {
                 const sql = `delete from ${qualifiedChild} where ${whereClause}`;
                 log('LENS CASCADE DELETE: %s with params %o', sql, oldParentValues);
-                await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, oldParentValues));
+                await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, oldParentValues));
             }
             else {
                 // CASCADE UPDATE: rewrite the child FK columns to the NEW parent values
@@ -616,7 +748,7 @@ async function issueLensFkAction(db, ref, action, operation, oldParentValues, ne
                 const sql = `update ${qualifiedChild} set ${setClauses} where ${whereClause}`;
                 const params = [...(newParentValues ?? []), ...oldParentValues];
                 log('LENS CASCADE UPDATE: %s with params %o', sql, params);
-                await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, params));
+                await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, params));
             }
             break;
         }
@@ -624,7 +756,7 @@ async function issueLensFkAction(db, ref, action, operation, oldParentValues, ne
             const setClauses = childLogicalColumns.map(c => `${quoteIdentifier(c)} = null`).join(', ');
             const sql = `update ${qualifiedChild} set ${setClauses} where ${whereClause}`;
             log('LENS SET NULL: %s with params %o', sql, oldParentValues);
-            await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, oldParentValues));
+            await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, oldParentValues));
             break;
         }
         case 'setDefault': {
@@ -638,7 +770,7 @@ async function issueLensFkAction(db, ref, action, operation, oldParentValues, ne
             }).join(', ');
             const sql = `update ${qualifiedChild} set ${setClauses} where ${whereClause}`;
             log('LENS SET DEFAULT: %s with params %o', sql, oldParentValues);
-            await withFkCascadeReentry(db, () => db._execWithinTransaction(sql, oldParentValues));
+            await withFkCascadeReentry(db, () => db._internalStatementCache.run(sql, oldParentValues));
             break;
         }
     }
@@ -745,21 +877,11 @@ async function assertNoLensChildReferences(db, ref, parentSlot, operation, oldPa
     const whereClause = ref.childLogicalColumns.map(c => `${quoteIdentifier(c)} = ?`).join(' and ');
     const sql = `select 1 from ${qualifiedChild} where ${whereClause} limit 1`;
     log('LENS RESTRICT check (%s): %s with params %o', operation, sql, oldParentValues);
-    const stmt = db.prepare(sql);
-    try {
-        stmt.bindAll(oldParentValues);
-        let referenced = false;
-        for await (const _row of stmt._iterateRowsRaw()) {
-            referenced = true;
-            break;
-        }
-        if (referenced) {
-            const opName = operation === 'delete' ? 'DELETE' : 'UPDATE';
-            throw new QuereusError(`FOREIGN KEY constraint failed: ${opName} on '${parentSlot.logicalTable.name}' violates RESTRICT from '${childTable.name}'`, StatusCode.CONSTRAINT);
-        }
-    }
-    finally {
-        await stmt.finalize();
+    // Cached internal statement (compiled once per shape) rather than a fresh
+    // per-row prepare/finalize — see InternalStatementCache.
+    if (await db._internalStatementCache.probe(sql, oldParentValues)) {
+        const opName = operation === 'delete' ? 'DELETE' : 'UPDATE';
+        throw new QuereusError(`FOREIGN KEY constraint failed: ${opName} on '${parentSlot.logicalTable.name}' violates RESTRICT from '${childTable.name}'`, StatusCode.CONSTRAINT);
     }
 }
 //# sourceMappingURL=foreign-key-actions.js.map