@quereus/quereus 4.8.0 → 4.9.0

package/dist/src/runtime/emit/alter-table.js

@@ -7,17 +7,19 @@ import { createLogger } from '../../common/logger.js';
 import { buildColumnIndexMap, withGeneratedColumnGraph, requireVtabModule, resolveNamedConstraintClass, namedConstraintExists, assertConstraintNameFree, validateCollationForType, columnDefToSchema } from '../../schema/table.js';
 import { validateForeignKeyCollations, buildForeignKeyConstraintSchema, extractColumnLevelCheckConstraints, extractColumnLevelForeignKeys, extractColumnLevelUniqueConstraints } from '../../schema/constraint-builder.js';
 import { quoteIdentifier, expressionToString, astToString } from '../../emit/ast-stringify.js';
-import { renameTableInAst, renameColumnInAst, renameColumnInCheckExpression, renameColumnInColumnExpressions, renameTableInColumnExpressions } from '../../schema/rename-rewriter.js';
+import { renameTableInAst, renameColumnInAst, renameColumnInCheckExpression, renameColumnInColumnExpressions, renameTableInCheckConstraints, renameTableInIndexPredicates, renameTableInColumnExpressions, objectRefKey } from '../../schema/rename-rewriter.js';
+import { snapshotObjectRefResolvers, tableRenameTargetsFor } from '../../schema/object-ref-resolver.js';
 import { assertCatalogObjectPersistable, assertRenameDependentsPersistable } from '../../schema/catalog-persistability.js';
 import { assertUniqueConstraintIndexNameFree, assertUniqueConstraintNotDuplicated, uniqueConstraintColumnSetKey } from '../../schema/catalog.js';
 import { isTruthy } from '../../util/comparison.js';
 import { assertDdlTransactionPolicy, isExplicitTransactionOpen } from './ddl-transaction-policy.js';
 import { buildColumnSourceResolver } from '../../schema/column-source-resolver.js';
-import { assertNoColumnDefaultNamesColumn, assertNoCheckConstraintNamesColumn, assertNoAssertionNamesColumn, assertNoForeignKeyReferencesColumn } from './drop-column-guards.js';
+import { assertNoColumnExpressionNamesColumn, assertNoCheckConstraintNamesColumn, assertNoAssertionNamesColumn, assertNoForeignKeyReferencesColumn } from './drop-column-guards.js';
 import { emitAlterSchemaEvent, withStatementScopedSchemaEvents } from './alter-schema-event.js';
 import { foldDefaultToType, validateAndParse } from '../../types/validation.js';
 import { snapshotStaleMaterializedViews, propagateTableRenameToMaterializedViews, propagateColumnRenameToMaterializedViews, restoreUnaffectedMaterializedViews, attachMaintainedDerivation, detachMaintainedDerivation, } from './materialized-view-helpers.js';
 import { propagateTableRenameToAssertions, propagateColumnRenameToAssertions, } from './assertion-rename-helpers.js';
+import { assertColumnRenameCascadePublishable, runColumnRenameCascade } from './column-rename-cascade.js';
 import { isMaintainedTable } from '../../schema/derivation.js';
 import { inferType } from '../../types/registry.js';
 const log = createLogger('runtime:emit:alter-table');
@@ -174,6 +176,17 @@ async function runRenameTable(rctx, tableSchema, schema, newName, sql) {
     if (schema.getTable(newName)) {
         throw new QuereusError(`Table '${newName}' already exists`, StatusCode.ERROR);
     }
+    // Reference resolution for every walk this statement runs, snapshotted BEFORE
+    // the first side effect: the propagation below rewrites dependents after the
+    // catalog swap, and each reference must resolve the way its body PLANNED —
+    // against the pre-rename catalog — or a bare `t` would fall through to a
+    // same-named table further down the schema path once `main.t` is gone.
+    // `targetFor` pairs that pre-mutation resolution with its post-rename sibling
+    // snapshot, per body-owning home schema, so every rewrite can hold its
+    // post-condition (a rewritten reference still resolves to the renamed table,
+    // schema-qualifying when the bare new name would otherwise re-bind).
+    const objectResolvers = snapshotObjectRefResolvers(rctx.db);
+    const targetFor = tableRenameTargetsFor(objectResolvers, tableSchema.schemaName, oldName, newName);
     // Pre-flight, BEFORE the first side effect (`module.renameTable`): every catalog
     // entry this rename would rewrite must still be persistable. Both the rename
     // propagation and the store's catalog write are unfailable (notifier try/catch,
@@ -187,7 +200,7 @@ async function runRenameTable(rctx, tableSchema, schema, newName, sql) {
         // substitutes `newName`, which is already under test as the record's own name.
         assertCatalogObjectPersistable(rctx.db, 'materializedView', { ...tableSchema, name: newName });
     }
-    assertRenameDependentsPersistable(rctx.db, schema, ast => renameTableInAst(ast, oldName, newName, tableSchema.schemaName), t => rewriteTableForTableRename(t, tableSchema.schemaName.toLowerCase(), oldName, newName));
+    assertRenameDependentsPersistable(rctx.db, home => ast => renameTableInAst(ast, targetFor(home)), t => rewriteTableForTableRename(t, targetFor));
     // Clone schema with new name
     const updatedTableSchema = {
         ...tableSchema,
@@ -230,7 +243,7 @@ async function runRenameTable(rctx, tableSchema, schema, newName, sql) {
     // vanished old name. `propagateTableRename` runs the same rewrite over every
     // table in the catalog, but only after the notify; it is idempotent, so this
     // call simply makes that pass a no-op for this one table.
-    const renamedTableSchema = rewriteTableForTableRename(updatedTableSchema, tableSchema.schemaName.toLowerCase(), oldName, newName);
+    const renamedTableSchema = rewriteTableForTableRename(updatedTableSchema, targetFor);
     // Remove old, add new in the catalog
     schema.removeTable(oldName);
     schema.addTable(renamedTableSchema);
@@ -251,7 +264,7 @@ async function runRenameTable(rctx, tableSchema, schema, newName, sql) {
     // predicates in this and other tables, view and materialized-view bodies).
     // Best-effort AST rewrite — there is no global dependency tracker yet, so we
     // walk the catalog and patch in-place.
-    await propagateTableRename(rctx, tableSchema.schemaName, oldName, newName, preStaleMvs);
+    await propagateTableRename(rctx, preStaleMvs, targetFor);
     // Renaming a MAINTAINED table is an ordinary table rename plus a maintenance
     // re-key: the row-time plan is keyed by `schema.name`, so release the old key
     // and re-register under the new one, then move the persisted MV catalog entry
@@ -310,10 +323,24 @@ async function runRenameColumn(rctx, tableSchema, schema, oldName, newName, sql)
     // resolver with `propagateColumnRename` so the two passes cannot drift apart in
     // code; what makes them agree at RUNTIME (the resolver reads the LIVE catalog, and
     // this probe runs pre-mutation while the propagation runs post-) is that
-    // `isTableInUnaliasedScope` skips the renamed table itself and probes only OTHER
+    // `unqualifiedRefBindsTarget` skips the renamed table itself and probes only OTHER
     // sources, whose column sets this rename does not touch.
-    const resolveColumnInSource = buildColumnSourceResolver(rctx.db.schemaManager);
-    assertRenameDependentsPersistable(rctx.db, schema, ast => renameColumnInAst(ast, tableSchema.name, oldName, newName, tableSchema.schemaName, resolveColumnInSource), t => rewriteTableForColumnRename(t, tableSchema.schemaName.toLowerCase(), tableSchema.name, oldName, newName, resolveColumnInSource));
+    const resolveColumnInSource = buildColumnSourceResolver(rctx.db);
+    // Reference-resolution snapshot, BEFORE the first side effect — same discipline
+    // (and same reasoning) as the table-rename arm above.
+    const objectResolvers = snapshotObjectRefResolvers(rctx.db);
+    const renamedTableKey = objectRefKey(tableSchema.schemaName, tableSchema.name);
+    assertRenameDependentsPersistable(rctx.db, 
+    // Row-image mode 'none': the probed bodies are view / MV bodies — relations
+    // with no written row (their `with inverse` / `with defaults` subtrees
+    // self-suppress inside the walker).
+    home => ast => renameColumnInAst(ast, tableSchema.name, oldName, newName, objectResolvers.forHomeSchema(home), renamedTableKey, 'none', resolveColumnInSource), t => rewriteTableForColumnRename(t, tableSchema.name, oldName, newName, objectResolvers, renamedTableKey, resolveColumnInSource));
+    // Pre-flight the CASCADE, still before the first side effect: a dependent view /
+    // materialized view whose published names the rename would shift must not end up
+    // publishing two columns of the new name (its own `newName` plus the shifted
+    // passthrough). The live cascade rewrites bodies in place with no rollback, so
+    // the refusal has to land here, while the statement is still a clean no-op.
+    assertColumnRenameCascadePublishable(rctx.db, { targetKey: renamedTableKey, tableName: tableSchema.name }, oldName, newName, objectResolvers, resolveColumnInSource);
     assertRenamedColumnBackingNamesFree(tableSchema, colIndex, oldName, newName);
     const existingCol = tableSchema.columns[colIndex];
     // Build a ColumnDef AST for the renamed column (preserving type info)
@@ -365,7 +392,7 @@ async function runRenameColumn(rctx, tableSchema, schema, oldName, newName, sql)
     });
     // Propagate the rename into dependent objects (CHECK / FK / partial-index
     // predicates in this and other tables, view and materialized-view bodies).
-    await propagateColumnRename(rctx, tableSchema.schemaName, tableSchema.name, oldName, newName, preStaleMvs, resolveColumnInSource);
+    await propagateColumnRename(rctx, tableSchema.name, oldName, newName, preStaleMvs, objectResolvers, renamedTableKey, resolveColumnInSource);
     emitAlterSchemaEvent(rctx, tableSchema, {
         type: 'alter', objectType: 'column',
         objectName: tableSchema.name,
@@ -967,13 +994,15 @@ async function runDropColumn(rctx, tableSchema, schema, columnName, sql) {
             throw new QuereusError(`Cannot drop column '${columnName}' from '${tableSchema.name}': it is referenced by the WHERE clause of partial index '${idx.name}'`, StatusCode.CONSTRAINT);
         }
     }
-    // Validate: the remaining dependents `module.alterTable` cannot narrow — a sibling
-    // column's DEFAULT, a CHECK on this table, a foreign key in another table pointing AT
-    // the column, and an assertion body. All four run before `requireVtabModule` /
+    // Validate: the remaining dependents `module.alterTable` cannot narrow — a column
+    // DEFAULT / generated body, a CHECK constraint, a foreign key in another table pointing
+    // AT the column, and an assertion body. All four run before `requireVtabModule` /
     // `module.alterTable`, so a refused drop persists nothing. Ordered by widening blast
-    // radius (a column of this table → this table → another table → the whole database), so
-    // the most locally-explainable violation is the one reported.
-    assertNoColumnDefaultNamesColumn(rctx.db, tableSchema, columnName);
+    // radius (a column expression → a CHECK → a foreign key → the whole database), so the
+    // most locally-explainable violation is the one reported. The first two scan every
+    // table in every schema and report a dependent on the ALTERED table first, so their
+    // messages for a same-table dependent are unchanged by that widening.
+    assertNoColumnExpressionNamesColumn(rctx.db, tableSchema, columnName);
     assertNoCheckConstraintNamesColumn(rctx.db, tableSchema, columnName);
     assertNoForeignKeyReferencesColumn(rctx.db, tableSchema, columnName);
     assertNoAssertionNamesColumn(rctx.db, tableSchema, columnName);
@@ -1666,30 +1695,40 @@ async function rebuildViaShadowTable(rctx, tableSchema, _schema, survivingColumn
     });
 }
 /**
- * Propagates a table rename into every dependent schema object the catalog
- * knows about: CHECK expressions, FK references, partial-index predicates,
- * view bodies, and materialized-view bodies. Walks every schema (not just the
- * renamed table's home schema) so cross-schema FK references are picked up.
- * View `selectAst` is mutated in place because the planner re-walks it on
- * every reference.
+ * Propagates a table rename into every dependent schema object the catalog knows
+ * about: CHECK expressions, FK references, partial-index predicates, view bodies,
+ * assertion bodies, and materialized-view bodies. EVERY schema is walked for every
+ * object kind — a view / assertion / MV elsewhere over the renamed table is as much a
+ * dependent as a cross-schema foreign key, and the per-home-schema resolver is what
+ * keeps that from over-matching (see {@link snapshotObjectRefResolvers}). View
+ * `selectAst` is mutated in place because the planner re-walks it on every reference.
+ *
+ * Two global passes, not one combined per-schema pass: the MV pass re-plans each body
+ * it rewrites, so every plain VIEW in every schema must already carry the new name
+ * before the first MV re-plans — an MV in `main` may read a view in `temp`.
  */
-async function propagateTableRename(rctx, renamedSchemaName, oldName, newName, preStaleMvs) {
-    for (const schema of rctx.db.schemaManager._getAllSchemas()) {
-        await propagateTableRenameInSchema(rctx.db, schema, renamedSchemaName, oldName, newName, preStaleMvs);
+async function propagateTableRename(rctx, preStaleMvs, targetFor) {
+    const schemas = Array.from(rctx.db.schemaManager._getAllSchemas());
+    for (const schema of schemas) {
+        propagateTableRenameInSchema(rctx.db, schema, targetFor);
+    }
+    for (const schema of schemas) {
+        await propagateTableRenameToMaterializedViews(rctx.db, schema, preStaleMvs, targetFor(schema.name));
     }
     // After all per-schema rewrites and their cascade events: restore any MV this
     // statement's events marked stale that the rename provably did not affect
     // (e.g. a dependent of another source whose only change was an FK rewrite).
     await restoreUnaffectedMaterializedViews(rctx.db, preStaleMvs);
 }
-async function propagateTableRenameInSchema(db, schema, renamedSchemaName, oldName, newName, preStaleMvs) {
+/** Tables, views and assertions of one schema. Materialized views are a separate
+ *  global pass — see {@link propagateTableRename}. */
+function propagateTableRenameInSchema(db, schema, targetFor) {
     const notifier = db.schemaManager.getChangeNotifier();
-    const renamedSchemaLower = renamedSchemaName.toLowerCase();
     for (const table of Array.from(schema.getAllTables())) {
-        // Skip the just-renamed table when iterating the home schema; the FK
-        // `referencedTable` field on its own FKs (if any self-reference) is
-        // still pointing at the old name and needs rewriting too.
-        const updated = rewriteTableForTableRename(table, renamedSchemaLower, oldName, newName);
+        // The just-renamed table is deliberately NOT skipped: it already carries its
+        // new name, but a self-referencing FK's `referencedTable` (and its own CHECK /
+        // DEFAULT / index-predicate ASTs) still name the old one and need rewriting.
+        const updated = rewriteTableForTableRename(table, targetFor);
         if (updated !== table) {
             schema.addTable(updated);
             notifier.notifyChange({
@@ -1701,110 +1740,122 @@ async function propagateTableRenameInSchema(db, schema, renamedSchemaName, oldNa
             });
         }
     }
-    if (schema.name.toLowerCase() === renamedSchemaLower) {
-        for (const view of Array.from(schema.getAllViews())) {
-            // The body walk also descends the trailing `with defaults (…)` clause
-            // (now stored on `selectAst.defaults`), so a clause-only rewrite — a
-            // defaults-expr subquery referencing the renamed table even when the body
-            // never names it — flips `bodyChanged` and fires the (single) view_modified.
-            const bodyChanged = renameTableInAst(view.selectAst, oldName, newName, renamedSchemaName);
-            if (bodyChanged) {
-                const updatedView = { ...view, sql: astToString(view.selectAst) };
-                schema.addView(updatedView);
-                // The rewriter mutated `view.selectAst` (including its defaults clause) in
-                // place, so `oldObject` shares the rewritten AST (only `newObject.sql`
-                // differs). No consumer reads `oldObject.selectAst`; mirrors the table
-                // loop above (no clone).
-                notifier.notifyChange({
-                    type: 'view_modified',
-                    schemaName: schema.name,
-                    objectName: updatedView.name,
-                    oldObject: view,
-                    newObject: updatedView,
-                });
-            }
+    // Bodies owned by this schema resolve their unqualified names under ITS home
+    // path — one target per schema walked, all over the pre-mutation snapshot. A
+    // bare `t` matches only when it RESOLVES to the renamed object's key under that
+    // path, so a `temp`-owned body meaning `temp.t` survives a rename of `main.t`.
+    const target = targetFor(schema.name);
+    for (const view of Array.from(schema.getAllViews())) {
+        // The body walk also descends the trailing `with defaults (…)` clause
+        // (now stored on `selectAst.defaults`), so a clause-only rewrite — a
+        // defaults-expr subquery referencing the renamed table even when the body
+        // never names it — flips `bodyChanged` and fires the (single) view_modified.
+        const bodyChanged = renameTableInAst(view.selectAst, target);
+        if (bodyChanged) {
+            const updatedView = { ...view, sql: astToString(view.selectAst) };
+            schema.addView(updatedView);
+            // The rewriter mutated `view.selectAst` (including its defaults clause) in
+            // place, so `oldObject` shares the rewritten AST (only `newObject.sql`
+            // differs). No consumer reads `oldObject.selectAst`; mirrors the table
+            // loop above (no clone).
+            notifier.notifyChange({
+                type: 'view_modified',
+                schemaName: schema.name,
+                objectName: updatedView.name,
+                oldObject: view,
+                newObject: updatedView,
+            });
         }
-        // Assertions: same in-place body rewrite as plain views, plus a regenerated
-        // `violationSql` (the text the commit-time evaluator re-parses). Assertions
-        // feed no materialized view, so order against the MV pass is free; sitting
-        // next to the view loop keeps the plain schema-level objects together.
-        propagateTableRenameToAssertions(db, schema, renamedSchemaName, oldName, newName);
-        // Materialized views: same in-place body rewrite as plain views ("MV ≡
-        // faster view"), plus the derived-field re-key, row-time re-registration,
-        // and staleness discipline the MV record needs. Runs AFTER the view loop
-        // so a body reading the renamed table through a view re-plans against the
-        // already-rewritten view.
-        await propagateTableRenameToMaterializedViews(db, schema, renamedSchemaName, oldName, newName, preStaleMvs);
     }
+    // Assertions: same in-place body rewrite as plain views, plus a regenerated
+    // `violationSql` (the text the commit-time evaluator re-parses). Assertions
+    // feed no materialized view, so order against the MV pass is free; sitting
+    // next to the view loop keeps the plain schema-level objects together.
+    propagateTableRenameToAssertions(db, schema, target);
 }
-function rewriteTableForTableRename(table, renamedSchemaLower, oldName, newName) {
-    const oldLower = oldName.toLowerCase();
+/**
+ * Rewrite one table's own definition for a table rename. The three
+ * expression-bearing arms — CHECK constraints, partial-index predicates, and
+ * column DEFAULT / generated bodies — go through the SAME collection helpers
+ * the store module's catalog rewrite calls (`renameTableIn{CheckConstraints,
+ * IndexPredicates,ColumnExpressions}`), so the per-arm row-image-context
+ * decision (CHECKs and column expressions evaluate against a written row,
+ * predicates do not) exists in exactly one place and the engine path and the
+ * store path cannot disagree about it. The helpers rewrite in place and
+ * report "did anything change", which is all the former hand-rolled loops
+ * computed beyond the rewrite — their per-item `{...cc}` / `{...idx}` shallow
+ * copies achieved nothing (the ASTs are shared by reference either way;
+ * flipping `changed` is what re-registers the table and fires
+ * `table_modified`).
+ *
+ * The FK arm stays hand-rolled: it maps a name field rather than walking an
+ * AST, and an unqualified `referencedTable` binds the CHILD table's own
+ * schema (never the session path — see `assertNoForeignKeyReferencesColumn`),
+ * so the key comparison composes it from `fk.referencedSchema ?? table.schemaName`.
+ */
+function rewriteTableForTableRename(table, targetFor) {
+    const target = targetFor(table.schemaName);
+    const targetKey = objectRefKey(target.schemaName, target.oldName);
     let changed = false;
-    const newChecks = table.checkConstraints.map(cc => {
-        const rewrote = renameTableInAst(cc.expr, oldName, newName, renamedSchemaLower);
-        if (!rewrote)
-            return cc;
+    if (renameTableInCheckConstraints(table.checkConstraints, target))
         changed = true;
-        return { ...cc };
-    });
     const newFks = (table.foreignKeys ?? []).map(fk => {
-        const fkSchemaLower = (fk.referencedSchema ?? table.schemaName).toLowerCase();
-        if (fkSchemaLower !== renamedSchemaLower)
-            return fk;
-        if (fk.referencedTable.toLowerCase() !== oldLower)
+        if (objectRefKey(fk.referencedSchema ?? table.schemaName, fk.referencedTable) !== targetKey)
             return fk;
         changed = true;
-        return { ...fk, referencedTable: newName };
+        return { ...fk, referencedTable: target.newName };
     });
     // Partial-index predicates: the AST is mutated in place, so the derived
     // UNIQUE constraint of a unique partial index (which shares the predicate
     // by reference — see appendIndexToTableSchema) is rewritten with it.
-    const newIndexes = (table.indexes ?? []).map(idx => {
-        const rewrote = renameTableInAst(idx.predicate, oldName, newName, renamedSchemaLower);
-        if (!rewrote)
-            return idx;
+    if (renameTableInIndexPredicates(table.indexes, target))
         changed = true;
-        return { ...idx };
-    });
     // Column-level expressions — a DEFAULT (`w integer default ((select min(v) from u))`)
     // and a generated column's body. Unlike the column verb's arm, no seeded/unseeded
     // split: `renameTableInAst` resolves nothing against an implicit owning table, so one
     // entry point covers the renamed table's own self-referencing default and every other
     // table's alike.
-    //
-    // Also unlike the collections above, no per-item shallow copy: the rewrite is in place
-    // and a `ColumnSchema`'s own fields are untouched, so a fresh column object would only
-    // make the catalog's array stop being identical to the one the module's rename hook
-    // just handed back. Flipping `changed` is what re-registers the table and fires
-    // `table_modified`, which is all the copies above achieve either.
-    const columnsRewritten = renameTableInColumnExpressions(table.columns, oldName, newName, renamedSchemaLower);
-    if (columnsRewritten)
+    if (renameTableInColumnExpressions(table.columns, target))
         changed = true;
     if (!changed)
         return table;
     return Object.freeze({
         ...table,
-        checkConstraints: Object.freeze(newChecks),
         foreignKeys: table.foreignKeys ? Object.freeze(newFks) : table.foreignKeys,
-        indexes: table.indexes ? Object.freeze(newIndexes) : table.indexes,
     });
 }
-async function propagateColumnRename(rctx, renamedSchemaName, tableName, oldCol, newCol, preStaleMvs, resolveColumnInSource) {
-    const schemaManager = rctx.db.schemaManager;
-    for (const schema of schemaManager._getAllSchemas()) {
-        await propagateColumnRenameInSchema(rctx.db, schema, renamedSchemaName, tableName, oldCol, newCol, resolveColumnInSource, preStaleMvs);
-    }
-    // After all per-schema rewrites and their cascade events: restore any MV this
-    // statement's events marked stale that the rename provably did not affect — a
-    // body that never names the renamed column, or a `select *` body whose output
+/**
+ * The column-verb mirror of {@link propagateTableRename} — same all-schema scope for
+ * every dependent object kind, same two-global-passes shape per round (views everywhere
+ * before the first MV re-plans) — plus the one dimension the table verb does not have:
+ * a rewritten view / MV body can SHIFT THE NAME the object publishes (a bare or `*`
+ * passthrough of the renamed column), and the objects reading it then need the same
+ * rename with the view as the target. The worklist lives in `column-rename-cascade.ts`;
+ * each round re-enters the two passes below through the callback (threaded to avoid an
+ * import cycle), so every dependent kind is covered at every depth.
+ */
+async function propagateColumnRename(rctx, tableName, oldCol, newCol, preStaleMvs, resolvers, targetKey, resolveColumnInSource) {
+    await runColumnRenameCascade(rctx.db, { targetKey, tableName }, oldCol, newCol, preStaleMvs, resolvers, resolveColumnInSource, async (target) => {
+        const schemas = Array.from(rctx.db.schemaManager._getAllSchemas());
+        for (const schema of schemas) {
+            propagateColumnRenameInSchema(rctx.db, schema, target.tableName, oldCol, newCol, resolvers, target.targetKey, resolveColumnInSource);
+        }
+        for (const schema of schemas) {
+            await propagateColumnRenameToMaterializedViews(rctx.db, schema, target.tableName, oldCol, newCol, preStaleMvs, resolvers.forHomeSchema(schema.name), target.targetKey, resolveColumnInSource);
+        }
+    });
+    // After the whole cascade (once, not per round) and its events: restore any MV
+    // this statement's events marked stale that the rename provably did not affect —
+    // a body that never names the renamed column, or a `select *` body whose output
     // is a pure name shift (carried onto the live backing by the pass).
     await restoreUnaffectedMaterializedViews(rctx.db, preStaleMvs);
 }
-async function propagateColumnRenameInSchema(db, schema, renamedSchemaName, tableName, oldCol, newCol, resolveColumnInSource, preStaleMvs) {
+/** Tables, views and assertions of one schema. Materialized views are a separate
+ *  global pass — see {@link propagateColumnRename}. */
+function propagateColumnRenameInSchema(db, schema, tableName, oldCol, newCol, resolvers, targetKey, resolveColumnInSource) {
     const notifier = db.schemaManager.getChangeNotifier();
-    const renamedSchemaLower = renamedSchemaName.toLowerCase();
     for (const table of Array.from(schema.getAllTables())) {
-        const updated = rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCol, newCol, resolveColumnInSource);
+        const updated = rewriteTableForColumnRename(table, tableName, oldCol, newCol, resolvers, targetKey, resolveColumnInSource);
         if (updated !== table) {
             schema.addTable(updated);
             notifier.notifyChange({
@@ -1816,65 +1867,66 @@ async function propagateColumnRenameInSchema(db, schema, renamedSchemaName, tabl
             });
         }
     }
-    if (schema.name.toLowerCase() === renamedSchemaLower) {
-        for (const view of Array.from(schema.getAllViews())) {
-            // The body walk also descends the trailing `with defaults (…)` clause (now
-            // on `selectAst.defaults`): the entry `column` (a base column of the view's
-            // FROM table, usually projected away) rewrites via the same scope-aware
-            // synthetic probe as a `with inverse` target, and the entry exprs rewrite in
-            // the FROM frame — so a clause-only change flips `bodyChanged`. The live
-            // `resolveColumnInSource` keeps the walk scope-aware so an unqualified ref
-            // inside a defaults-expr subquery that binds a like-named column on its own
-            // FROM is not false-captured (the differ's inverse reconcile passes the
-            // declared-side resolver for parity).
-            const bodyChanged = renameColumnInAst(view.selectAst, tableName, oldCol, newCol, renamedSchemaName, resolveColumnInSource);
-            if (bodyChanged) {
-                const updatedView = { ...view, sql: astToString(view.selectAst) };
-                schema.addView(updatedView);
-                // The rewriter mutated `view.selectAst` (including its defaults clause) in
-                // place, so `oldObject` shares the rewritten AST (only `sql` differs). No
-                // consumer reads `oldObject.selectAst`; mirrors the table loop above (no clone).
-                notifier.notifyChange({
-                    type: 'view_modified',
-                    schemaName: schema.name,
-                    objectName: updatedView.name,
-                    oldObject: view,
-                    newObject: updatedView,
-                });
-            }
+    // Bodies owned by this schema resolve under ITS home path, over the pre-mutation
+    // snapshot — same per-schema resolver, and same all-schema scope, as the
+    // table-rename loop.
+    const resolve = resolvers.forHomeSchema(schema.name);
+    for (const view of Array.from(schema.getAllViews())) {
+        // The body walk also descends the trailing `with defaults (…)` clause (now
+        // on `selectAst.defaults`): the entry `column` (a base column of the view's
+        // FROM table, usually projected away) rewrites via the same scope-aware
+        // synthetic probe as a `with inverse` target, and the entry exprs rewrite in
+        // the FROM frame — so a clause-only change flips `bodyChanged`. The live
+        // `resolveColumnInSource` keeps the walk scope-aware so an unqualified ref
+        // inside a defaults-expr subquery that binds a like-named column on its own
+        // FROM is not false-captured (the differ's inverse reconcile passes the
+        // declared-side resolver for parity).
+        const bodyChanged = renameColumnInAst(view.selectAst, tableName, oldCol, newCol, resolve, targetKey, 'none', resolveColumnInSource);
+        if (bodyChanged) {
+            const updatedView = { ...view, sql: astToString(view.selectAst) };
+            schema.addView(updatedView);
+            // The rewriter mutated `view.selectAst` (including its defaults clause) in
+            // place, so `oldObject` shares the rewritten AST (only `sql` differs). No
+            // consumer reads `oldObject.selectAst`; mirrors the table loop above (no clone).
+            notifier.notifyChange({
+                type: 'view_modified',
+                schemaName: schema.name,
+                objectName: updatedView.name,
+                oldObject: view,
+                newObject: updatedView,
+            });
         }
-        // Assertions: same in-place body rewrite as plain views (unseeded walker —
-        // an assertion body owns its own FROM scopes), plus a regenerated
-        // `violationSql`.
-        propagateColumnRenameToAssertions(db, schema, renamedSchemaName, tableName, oldCol, newCol, resolveColumnInSource);
-        // Materialized views: same in-place body rewrite as plain views, then the
-        // MV-specific tail — backing-column rename for a shifted output name,
-        // row-time re-registration, staleness discipline (the listener marked every
-        // dependent MV stale during the rename's notify; only statement-local
-        // staleness is cleared, per the pre-statement snapshot).
-        await propagateColumnRenameToMaterializedViews(db, schema, renamedSchemaName, tableName, oldCol, newCol, preStaleMvs, resolveColumnInSource);
     }
+    // Assertions: same in-place body rewrite as plain views (unseeded walker —
+    // an assertion body owns its own FROM scopes), plus a regenerated
+    // `violationSql`.
+    propagateColumnRenameToAssertions(db, schema, tableName, oldCol, newCol, resolve, targetKey, resolveColumnInSource);
 }
-function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCol, newCol, resolveColumnInSource) {
+function rewriteTableForColumnRename(table, tableName, oldCol, newCol, resolvers, targetKey, resolveColumnInSource) {
     const oldColLower = oldCol.toLowerCase();
-    const tableLower = tableName.toLowerCase();
-    const isRenamedTable = table.schemaName.toLowerCase() === renamedSchemaLower &&
-        table.name.toLowerCase() === tableLower;
+    const resolve = resolvers.forHomeSchema(table.schemaName);
+    // Key comparison, so a same-named table in another schema never takes the
+    // seeded branch.
+    const isRenamedTable = objectRefKey(table.schemaName, table.name) === targetKey;
     let changed = false;
+    // Row-image modes: a CHECK is written-row context wherever it lives — 'own'
+    // when its image IS the renamed table, 'foreign' when it is another table's
+    // (a bare `new.`/`old.` there names THAT table's row, never the renamed one,
+    // even for a table literally called `new`).
     const newChecks = table.checkConstraints.map(cc => {
         const rewrote = isRenamedTable
-            ? renameColumnInCheckExpression(cc.expr, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource)
-            : renameColumnInAst(cc.expr, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource);
+            ? renameColumnInCheckExpression(cc.expr, tableName, oldCol, newCol, resolve, targetKey, 'own', resolveColumnInSource)
+            : renameColumnInAst(cc.expr, tableName, oldCol, newCol, resolve, targetKey, 'foreign', resolveColumnInSource);
         if (!rewrote)
             return cc;
         changed = true;
         return { ...cc };
     });
     const newFks = (table.foreignKeys ?? []).map(fk => {
-        const fkSchemaLower = (fk.referencedSchema ?? table.schemaName).toLowerCase();
-        if (fkSchemaLower !== renamedSchemaLower)
-            return fk;
-        if (fk.referencedTable.toLowerCase() !== tableLower)
+        // An unqualified `referencedTable` binds the CHILD table's own schema
+        // (never the session path — see `assertNoForeignKeyReferencesColumn`),
+        // hence the composed key rather than the resolver.
+        if (objectRefKey(fk.referencedSchema ?? table.schemaName, fk.referencedTable) !== targetKey)
             return fk;
         if (!fk.referencedColumnNames || fk.referencedColumnNames.length === 0)
             return fk;
@@ -1907,10 +1959,12 @@ function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCo
     // expressions above, via `renameColumnInCheckConstraints`). Both use the same
     // idempotent `renameColumnInIndexPredicates`, so this pass then finds nothing naming
     // `oldCol`, `rewrote` is false, and the table is not needlessly re-registered.
+    // Row-image mode 'none' on both arms: a predicate describes rows already
+    // stored, so it has no written-row context regardless of which table owns it.
     const newIndexes = (table.indexes ?? []).map(idx => {
         const rewrote = isRenamedTable
-            ? renameColumnInCheckExpression(idx.predicate, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource)
-            : renameColumnInAst(idx.predicate, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource);
+            ? renameColumnInCheckExpression(idx.predicate, tableName, oldCol, newCol, resolve, targetKey, 'none', resolveColumnInSource)
+            : renameColumnInAst(idx.predicate, tableName, oldCol, newCol, resolve, targetKey, 'none', resolveColumnInSource);
         if (!rewrote)
             return idx;
         changed = true;
@@ -1929,8 +1983,8 @@ function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCo
     // built and handed back. Flipping `changed` is what re-registers the table and fires
     // `table_modified`, which is all the copies above achieve either.
     const columnsRewritten = isRenamedTable
-        ? renameColumnInColumnExpressions(table.columns, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource)
-        : rewriteOtherTableColumnExpressions(table.columns, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource);
+        ? renameColumnInColumnExpressions(table.columns, tableName, oldCol, newCol, resolve, targetKey, resolveColumnInSource)
+        : rewriteOtherTableColumnExpressions(table.columns, tableName, oldCol, newCol, resolve, targetKey, resolveColumnInSource);
     if (columnsRewritten)
         changed = true;
     if (!changed)
@@ -1957,11 +2011,14 @@ function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCo
  * keeps this pass in step with the pre-flight persistability probe, which runs the same
  * rewriter with the resolver supplied.
  */
-function rewriteOtherTableColumnExpressions(columns, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource) {
+function rewriteOtherTableColumnExpressions(columns, tableName, oldCol, newCol, resolve, targetKey, resolveColumnInSource) {
     let changed = false;
     for (const col of columns) {
         for (const expr of [col.defaultValue, col.generatedExpr]) {
-            if (expr && renameColumnInAst(expr, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource))
+            // 'foreign': another table's DEFAULT / generated body is written-row
+            // context whose image is THAT table — a bare `new.`/`old.` there names
+            // nothing this rename cares about.
+            if (expr && renameColumnInAst(expr, tableName, oldCol, newCol, resolve, targetKey, 'foreign', resolveColumnInSource))
                 changed = true;
         }
     }