@quereus/quereus 4.6.0 → 4.8.0

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

@@ -1,20 +1,23 @@
 import { asRun } from '../types.js';
 import { emitCallFromPlan } from '../emitters.js';
 import { createRowSlot } from '../context-helpers.js';
-import { QuereusError } from '../../common/errors.js';
+import { QuereusError, RelationNotFoundError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
 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 } from '../../schema/rename-rewriter.js';
+import { renameTableInAst, renameColumnInAst, renameColumnInCheckExpression, renameColumnInColumnExpressions, renameTableInColumnExpressions } from '../../schema/rename-rewriter.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 { emitAlterSchemaEvent } from './alter-schema-event.js';
+import { buildColumnSourceResolver } from '../../schema/column-source-resolver.js';
+import { assertNoColumnDefaultNamesColumn, 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 { isMaintainedTable } from '../../schema/derivation.js';
 import { inferType } from '../../types/registry.js';
 const log = createLogger('runtime:emit:alter-table');
@@ -35,7 +38,9 @@ export function emitAlterTable(plan, ctx) {
     // (via a row slot over the backfill's row descriptor). When the new column also carries a
     // CHECK, its predicates ride alongside as further callbacks, evaluated per backfilled row
     // against `[...existingRow, backfilledValue]`. Slot order is fixed: backfill first
-    // (present whenever checks are), then the checks in order.
+    // (present whenever checks are), then the checks in order — this MUST match
+    // `AlterTableNode.addColumnExpressions()` (planner/nodes/alter-table-node.ts), which is
+    // the order the optimizer rewrites these children in via getChildren/withChildren.
     const backfill = action.type === 'addColumn' ? action.backfill : undefined;
     const checks = action.type === 'addColumn' ? action.checks : undefined;
     const params = [
@@ -68,58 +73,66 @@ export function emitAlterTable(plan, ctx) {
                 ? `cannot ALTER TABLE '${tableSchema.name}': it is a materialized view — use ALTER MATERIALIZED VIEW for tags`
                 : `cannot ALTER '${tableSchema.name}': it is a materialized view — its shape is defined by the view body (drop and recreate to change it)`, StatusCode.ERROR);
         }
-        switch (action.type) {
-            case 'renameTable':
-                return runRenameTable(rctx, tableSchema, schema, action.newName);
-            case 'renameColumn':
-                return runRenameColumn(rctx, tableSchema, schema, action.oldName, action.newName);
-            case 'addColumn': {
-                // Slot order set in `params`: backfill callback first (if any), then check callbacks.
-                const backfillCb = backfill ? args[0] : undefined;
-                const checkCbs = args.slice(backfill ? 1 : 0);
-                return runAddColumn(rctx, tableSchema, schema, action.column, backfill, backfillCb, checks, checkCbs);
-            }
-            case 'dropColumn':
-                return runDropColumn(rctx, tableSchema, schema, action.name);
-            case 'dropConstraint':
-                return runDropConstraint(rctx, tableSchema, schema, action.name);
-            case 'renameConstraint':
-                return runRenameConstraint(rctx, tableSchema, schema, action.oldName, action.newName);
-            case 'alterPrimaryKey':
-                return runAlterPrimaryKey(rctx, tableSchema, schema, action.columns);
-            case 'alterColumn':
-                return runAlterColumn(rctx, tableSchema, schema, action);
-            case 'setTags': {
-                const target = action.target;
-                if (action.mode === 'merge') {
-                    // ADD TAGS — per-key merge onto the live tag set.
+        // Every arm runs under the statement-scoped schema-event scope: an arm that fails
+        // after the module call has already let an emitter-backed module announce the
+        // statement (it emits from inside `module.alterTable`, not at the statement's end),
+        // so the failure path must retract that announcement. See
+        // {@link withStatementScopedSchemaEvents} for why this sits at the statement
+        // boundary rather than inside any one arm's revert.
+        return withStatementScopedSchemaEvents(rctx, async () => {
+            switch (action.type) {
+                case 'renameTable':
+                    return runRenameTable(rctx, tableSchema, schema, action.newName, plan.sql);
+                case 'renameColumn':
+                    return runRenameColumn(rctx, tableSchema, schema, action.oldName, action.newName, plan.sql);
+                case 'addColumn': {
+                    // Slot order set in `params`: backfill callback first (if any), then check callbacks.
+                    const backfillCb = backfill ? args[0] : undefined;
+                    const checkCbs = args.slice(backfill ? 1 : 0);
+                    return runAddColumn(rctx, tableSchema, schema, action.column, plan.sql, backfill, backfillCb, checks, checkCbs);
+                }
+                case 'dropColumn':
+                    return runDropColumn(rctx, tableSchema, schema, action.name, plan.sql);
+                case 'dropConstraint':
+                    return runDropConstraint(rctx, tableSchema, schema, action.name, plan.sql);
+                case 'renameConstraint':
+                    return runRenameConstraint(rctx, tableSchema, schema, action.oldName, action.newName, plan.sql);
+                case 'alterPrimaryKey':
+                    return runAlterPrimaryKey(rctx, tableSchema, schema, action.columns, plan.sql);
+                case 'alterColumn':
+                    return runAlterColumn(rctx, tableSchema, schema, action, plan.sql);
+                case 'setTags': {
+                    const target = action.target;
+                    if (action.mode === 'merge') {
+                        // ADD TAGS — per-key merge onto the live tag set.
+                        if (target.kind === 'column')
+                            return runMergeColumnTags(rctx, tableSchema, target.columnName, action.tags);
+                        if (target.kind === 'constraint')
+                            return runMergeConstraintTags(rctx, tableSchema, target.constraintName, action.tags);
+                        return runMergeTableTags(rctx, tableSchema, action.tags);
+                    }
+                    // SET TAGS — whole-set replace.
                     if (target.kind === 'column')
-                        return runMergeColumnTags(rctx, tableSchema, target.columnName, action.tags);
+                        return runSetColumnTags(rctx, tableSchema, target.columnName, action.tags);
                     if (target.kind === 'constraint')
-                        return runMergeConstraintTags(rctx, tableSchema, target.constraintName, action.tags);
-                    return runMergeTableTags(rctx, tableSchema, action.tags);
+                        return runSetConstraintTags(rctx, tableSchema, target.constraintName, action.tags);
+                    return runSetTableTags(rctx, tableSchema, action.tags);
                 }
-                // SET TAGS — whole-set replace.
-                if (target.kind === 'column')
-                    return runSetColumnTags(rctx, tableSchema, target.columnName, action.tags);
-                if (target.kind === 'constraint')
-                    return runSetConstraintTags(rctx, tableSchema, target.constraintName, action.tags);
-                return runSetTableTags(rctx, tableSchema, action.tags);
-            }
-            case 'dropTags': {
-                // DROP TAGS — per-key delete (atomic NOTFOUND if any key absent).
-                const target = action.target;
-                if (target.kind === 'column')
-                    return runDropColumnTags(rctx, tableSchema, target.columnName, action.keys);
-                if (target.kind === 'constraint')
-                    return runDropConstraintTags(rctx, tableSchema, target.constraintName, action.keys);
-                return runDropTableTags(rctx, tableSchema, action.keys);
+                case 'dropTags': {
+                    // DROP TAGS — per-key delete (atomic NOTFOUND if any key absent).
+                    const target = action.target;
+                    if (target.kind === 'column')
+                        return runDropColumnTags(rctx, tableSchema, target.columnName, action.keys);
+                    if (target.kind === 'constraint')
+                        return runDropConstraintTags(rctx, tableSchema, target.constraintName, action.keys);
+                    return runDropTableTags(rctx, tableSchema, action.keys);
+                }
+                case 'setMaintained':
+                    return runSetMaintained(rctx, tableSchema, schema, action.columns, action.select);
+                case 'dropMaintained':
+                    return runDropMaintained(rctx, tableSchema, schema);
             }
-            case 'setMaintained':
-                return runSetMaintained(rctx, tableSchema, schema, action.columns, action.select);
-            case 'dropMaintained':
-                return runDropMaintained(rctx, tableSchema, schema);
-        }
+        });
     }
     const note = (() => {
         switch (action.type) {
@@ -155,7 +168,7 @@ export function emitAlterTable(plan, ctx) {
         note,
     };
 }
-async function runRenameTable(rctx, tableSchema, schema, newName) {
+async function runRenameTable(rctx, tableSchema, schema, newName, sql) {
     const oldName = tableSchema.name;
     // Check for name conflict
     if (schema.getTable(newName)) {
@@ -186,7 +199,9 @@ async function runRenameTable(rctx, tableSchema, schema, newName) {
     // omit the hook.
     const module = requireVtabModule(tableSchema);
     if (module.renameTable) {
-        await module.renameTable(rctx.db, tableSchema.schemaName, oldName, newName);
+        // `sql` marks this call as the statement's own action: an emitter-backed module
+        // emits its schema-change event iff it is present (see VirtualTableModule.renameTable).
+        await module.renameTable(rctx.db, tableSchema.schemaName, oldName, newName, sql);
     }
     // Events this transaction already recorded still carry the OLD name; relabel them so
     // the commit delivers every event under the name the table has at delivery. AFTER the
@@ -196,9 +211,11 @@ async function runRenameTable(rctx, tableSchema, schema, newName) {
     // matching where the other ALTER arms call `remapBatchedDataEvents`.
     //
     // NOTE: batched SCHEMA events are deliberately out of scope here. A schema event
-    // records a DDL operation, not current state — relabelling `objectName` without
-    // rewriting its `ddl` text would produce an incoherent instruction. How a rename
-    // crosses the wire to a peer is `fix/sync-schema-migrations-replicate-empty-ddl`.
+    // records a DDL operation, not current state — each now carries the statement's own
+    // canonical `ddl` text (and, for a rename, `oldObjectName`), so relabelling
+    // `objectName` without rewriting that text would produce an incoherent instruction.
+    // A consumer replays the schema events in order; the rename is one of them, carrying
+    // this very statement's SQL, so earlier events legitimately name the old table.
     rctx.db._getEventEmitter().renameBatchedEvents(tableSchema.schemaName, oldName, newName);
     // Deferred constraint checks this transaction already parked carry evaluators compiled
     // against the OLD name — their scan leaves would connect to a table that no longer
@@ -265,13 +282,18 @@ async function runRenameTable(rctx, tableSchema, schema, newName) {
     await module.finalizeRename?.(rctx.db, tableSchema.schemaName, oldName, newName);
     // The public schema-change event, for a module with no emitter of its own — see
     // {@link emitAlterSchemaEvent} for why every arm emits at its tail rather than
-    // alongside the module call. Names only the NEW table: `DatabaseSchemaChangeEvent`
-    // has no old-object-name field, and the emitting backends have the identical gap.
-    emitAlterSchemaEvent(rctx, tableSchema, { type: 'alter', objectType: 'table', objectName: newName });
+    // alongside the module call. `objectName` is the NEW table; `oldObjectName` says
+    // what it renamed FROM, so a receiver can tell which of its tables the event is about.
+    emitAlterSchemaEvent(rctx, tableSchema, {
+        type: 'alter', objectType: 'table',
+        objectName: newName,
+        oldObjectName: oldName,
+        ddl: sql,
+    });
     log('Renamed table %s.%s to %s', tableSchema.schemaName, oldName, newName);
     return null;
 }
-async function runRenameColumn(rctx, tableSchema, schema, oldName, newName) {
+async function runRenameColumn(rctx, tableSchema, schema, oldName, newName, sql) {
     const colIndex = tableSchema.columnIndexMap.get(oldName.toLowerCase());
     if (colIndex === undefined) {
         throw new QuereusError(`Column '${oldName}' not found in table '${tableSchema.name}'`, StatusCode.ERROR);
@@ -290,7 +312,7 @@ async function runRenameColumn(rctx, tableSchema, schema, oldName, newName) {
     // this probe runs pre-mutation while the propagation runs post-) is that
     // `isTableInUnaliasedScope` skips the renamed table itself and probes only OTHER
     // sources, whose column sets this rename does not touch.
-    const resolveColumnInSource = buildColumnSourceResolver(rctx.db);
+    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));
     assertRenamedColumnBackingNamesFree(tableSchema, colIndex, oldName, newName);
     const existingCol = tableSchema.columns[colIndex];
@@ -309,6 +331,7 @@ async function runRenameColumn(rctx, tableSchema, schema, oldName, newName) {
             oldName,
             newName,
             newColumnDefAst: newColumnDef,
+            ddl: sql,
         });
     }
     else {
@@ -348,6 +371,7 @@ async function runRenameColumn(rctx, tableSchema, schema, oldName, newName) {
         objectName: tableSchema.name,
         columnName: newName,
         oldColumnName: oldName,
+        ddl: sql,
     });
     log('Renamed column %s.%s.%s to %s', tableSchema.schemaName, tableSchema.name, oldName, newName);
     return null;
@@ -423,7 +447,7 @@ function assertInlineConstraintNamesFree(tableSchema, columnDef) {
         seen.add(declared.name.toLowerCase());
     }
 }
-async function runAddColumn(rctx, tableSchema, schema, columnDef, backfill, backfillCb, checks, checkCbs) {
+async function runAddColumn(rctx, tableSchema, schema, columnDef, sql, backfill, backfillCb, checks, checkCbs) {
     // Validate column doesn't already exist
     if (tableSchema.columnIndexMap.has(columnDef.name.toLowerCase())) {
         throw new QuereusError(`Column '${columnDef.name}' already exists in table '${tableSchema.name}'`, StatusCode.ERROR);
@@ -578,10 +602,19 @@ async function runAddColumn(rctx, tableSchema, schema, columnDef, backfill, back
     // the inverse event remap.
     let addedColIndex;
     try {
+        // `ddl` marks this call — and only this one — as the statement's own action: the
+        // inline-constraint installs below and any revert calls pass none, so an
+        // emitter-backed module announces exactly ONE event for the whole statement.
+        //
+        // That marker settles HOW MANY events a successful statement announces, not whether a
+        // failed one announces any: this call is not the end of the statement, so a failure in
+        // the inline-constraint installs below leaves this announcement already batched. The
+        // statement-scoped retraction wrapped around the whole arm dispatch is what removes it.
         updatedTableSchema = await module.alterTable(rctx.db, tableSchema.schemaName, tableSchema.name, {
             type: 'addColumn',
             columnDef,
             backfillEvaluator,
+            ddl: sql,
         });
         // Events this transaction already batched for the table still describe the
         // pre-ADD column set; insert the backfilled value at the new slot so a listener
@@ -695,6 +728,9 @@ async function runAddColumn(rctx, tableSchema, schema, columnDef, backfill, back
             // orphans) and — store-backed — persists. Thread the returned schema forward so
             // each constraint layers on the last. The module's answer carries no
             // generated-column bookkeeping of its own, so re-derive it each round.
+            // Deliberately NO `ddl`: this is an engine-internal sub-step of the ADD COLUMN
+            // statement, so an emitter-backed module must announce nothing for it — the
+            // statement's one event rode the `addColumn` call above.
             const withConstraint = await module.alterTable(rctx.db, tableSchema.schemaName, tableSchema.name, {
                 type: 'addConstraint',
                 constraint,
@@ -720,14 +756,14 @@ async function runAddColumn(rctx, tableSchema, schema, columnDef, backfill, back
     });
     // ONE event for the whole statement, even when the column declared inline constraints.
     // The install loop above makes a second `module.alterTable(addConstraint)` round-trip per
-    // inline constraint, and an emitter-backed module therefore announces `alter`/`column`
-    // followed by an `alter`/`table` per constraint — an artifact of its internal call
-    // pattern, not a second thing the application did. The deliberate divergence from that
-    // shape: do not "fix" this into two events.
+    // inline constraint; an emitter-backed module now agrees on one event too, because only
+    // the `addColumn` call carried `ddl` and a module emits iff it is set. Do not "fix"
+    // this into per-constraint events on either path.
     emitAlterSchemaEvent(rctx, tableSchema, {
         type: 'alter', objectType: 'column',
         objectName: tableSchema.name,
         columnName: columnDef.name,
+        ddl: sql,
     });
     log('Added column %s to table %s.%s', columnDef.name, tableSchema.schemaName, tableSchema.name);
     return null;
@@ -746,6 +782,14 @@ async function runAddColumn(rctx, tableSchema, schema, columnDef, backfill, back
  * mask the original violation. Restoring the catalog entry is a no-op when the ALTER failed
  * before registering anything (the original schema is still the live one).
  *
+ * Every module call here passes no `ddl`, deliberately: an emitter-backed module emits only
+ * for a call carrying `ddl`, so the unwinding itself announces nothing. That is the SECOND
+ * line of defence, not the only one — the failed statement's own `addColumn` call DID carry
+ * `ddl`, and an emitter-backed module already batched an event for it before we got here.
+ * What actually keeps a failed ADD COLUMN silent is the statement-scoped retraction the whole
+ * arm dispatch runs under (`withStatementScopedSchemaEvents` in `emitAlterTable`'s `run()`),
+ * which drops that event as the error propagates.
+ *
  * NOTE: the hand-back is by NAME, so it assumes a name resolves to the constraint this
  * ALTER installed. A pre-existing constraint can legitimately share an auto-name (nothing
  * rejects `constraint _check_w check (…)` on a table that later gets `add column w …
@@ -808,6 +852,12 @@ async function validateBackfillAgainstChecks(rctx, columnOnlySchema, newCheckCon
         const checkSql = expressionToString(cc.expr);
         const sql = `select 1 from ${qualifiedTable} where not (${checkSql}) limit 1`;
         const stmt = rctx.db.prepare(sql);
+        // The CHECK is SCHEMA-AUTHORED: it belongs to the altered table's own DDL, so a
+        // bare relation name inside it means the ALTERED table's schema — not the session
+        // path this freshly-prepared validation statement would otherwise inherit. Owning
+        // schema ONLY, matching `schemaAuthoredContext` (planner/building/schema-authored-context.ts),
+        // which decides the same thing for every CHECK the DML builders compile.
+        stmt._schemaPathOverride = [columnOnlySchema.schemaName];
         try {
             let violated = false;
             for await (const _row of stmt._iterateRowsRaw()) {
@@ -884,7 +934,7 @@ function predicateReferencesColumn(expr, columnName) {
     visit(expr);
     return found;
 }
-async function runDropColumn(rctx, tableSchema, schema, columnName) {
+async function runDropColumn(rctx, tableSchema, schema, columnName, sql) {
     const colIndex = tableSchema.columnIndexMap.get(columnName.toLowerCase());
     if (colIndex === undefined) {
         throw new QuereusError(`Column '${columnName}' not found in table '${tableSchema.name}'`, StatusCode.ERROR);
@@ -917,6 +967,16 @@ async function runDropColumn(rctx, tableSchema, schema, columnName) {
             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` /
+    // `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);
+    assertNoCheckConstraintNamesColumn(rctx.db, tableSchema, columnName);
+    assertNoForeignKeyReferencesColumn(rctx.db, tableSchema, columnName);
+    assertNoAssertionNamesColumn(rctx.db, tableSchema, columnName);
     // Call module.alterTable for data + schema update
     const module = requireVtabModule(tableSchema);
     if (!module.alterTable) {
@@ -925,6 +985,7 @@ async function runDropColumn(rctx, tableSchema, schema, columnName) {
     const updatedTableSchema = await module.alterTable(rctx.db, tableSchema.schemaName, tableSchema.name, {
         type: 'dropColumn',
         columnName,
+        ddl: sql,
     });
     // Events this transaction already batched for the table still carry the pre-drop
     // arity; drop the slot so a listener at commit pairs value i with column i of the
@@ -951,6 +1012,7 @@ async function runDropColumn(rctx, tableSchema, schema, columnName) {
         type: 'drop', objectType: 'column',
         objectName: tableSchema.name,
         columnName,
+        ddl: sql,
     });
     log('Dropped column %s from table %s.%s', columnName, tableSchema.schemaName, tableSchema.name);
     return null;
@@ -965,7 +1027,7 @@ async function runDropColumn(rctx, tableSchema, schema, columnName) {
  * module owns the actual array rewrite and, for a UNIQUE, tearing down the
  * implicit covering index that backs it.
  */
-async function runDropConstraint(rctx, tableSchema, schema, constraintName) {
+async function runDropConstraint(rctx, tableSchema, schema, constraintName, sql) {
     const constraintClass = resolveNamedConstraintClass(tableSchema, constraintName);
     if (constraintClass === 'unique') {
         rejectDerivedFromIndex(tableSchema, constraintName, 'DROP');
@@ -977,6 +1039,7 @@ async function runDropConstraint(rctx, tableSchema, schema, constraintName) {
     const updatedTableSchema = await module.alterTable(rctx.db, tableSchema.schemaName, tableSchema.name, {
         type: 'dropConstraint',
         constraintName,
+        ddl: sql,
     });
     schema.addTable(updatedTableSchema);
     rctx.db.schemaManager.getChangeNotifier().notifyChange({
@@ -989,6 +1052,7 @@ async function runDropConstraint(rctx, tableSchema, schema, constraintName) {
     emitAlterSchemaEvent(rctx, tableSchema, {
         type: 'alter', objectType: 'table',
         objectName: tableSchema.name,
+        ddl: sql,
     });
     log('Dropped constraint %s from table %s.%s', constraintName, tableSchema.schemaName, tableSchema.name);
     return null;
@@ -999,7 +1063,7 @@ async function runDropConstraint(rctx, tableSchema, schema, constraintName) {
  * name must not already address a constraint), and rejects renaming a UNIQUE
  * derived from an explicit index. Routed through `module.alterTable`.
  */
-async function runRenameConstraint(rctx, tableSchema, schema, oldName, newName) {
+async function runRenameConstraint(rctx, tableSchema, schema, oldName, newName, sql) {
     const constraintClass = resolveNamedConstraintClass(tableSchema, oldName);
     if (constraintClass === 'unique') {
         rejectDerivedFromIndex(tableSchema, oldName, 'RENAME');
@@ -1030,6 +1094,7 @@ async function runRenameConstraint(rctx, tableSchema, schema, oldName, newName)
         type: 'renameConstraint',
         oldName,
         newName,
+        ddl: sql,
     });
     schema.addTable(updatedTableSchema);
     rctx.db.schemaManager.getChangeNotifier().notifyChange({
@@ -1044,6 +1109,7 @@ async function runRenameConstraint(rctx, tableSchema, schema, oldName, newName)
     emitAlterSchemaEvent(rctx, tableSchema, {
         type: 'alter', objectType: 'table',
         objectName: tableSchema.name,
+        ddl: sql,
     });
     log('Renamed constraint %s.%s.%s to %s', tableSchema.schemaName, tableSchema.name, oldName, newName);
     return null;
@@ -1061,7 +1127,7 @@ function rejectDerivedFromIndex(tableSchema, constraintName, op) {
         throw new QuereusError(`Cannot ${op} CONSTRAINT '${constraintName}' on '${tableSchema.name}': it is backed by index '${uc.derivedFromIndex}' (created via CREATE UNIQUE INDEX). Use DROP INDEX '${uc.derivedFromIndex}' instead.`, StatusCode.CONSTRAINT);
     }
 }
-async function runAlterColumn(rctx, tableSchema, schema, action) {
+async function runAlterColumn(rctx, tableSchema, schema, action, sql) {
     const colIndex = tableSchema.columnIndexMap.get(action.columnName.toLowerCase());
     if (colIndex === undefined) {
         throw new QuereusError(`Column '${action.columnName}' not found in table '${tableSchema.name}'`, StatusCode.ERROR);
@@ -1118,6 +1184,7 @@ async function runAlterColumn(rctx, tableSchema, schema, action) {
         setDataType: action.setDataType,
         setDefault: action.setDefault,
         setCollation: action.setCollation,
+        ddl: sql,
     });
     // Events this transaction already batched still carry the PRE-conversion value at
     // the altered column (`SET DATA TYPE`'s normalization, `SET NOT NULL`'s null →
@@ -1141,11 +1208,12 @@ async function runAlterColumn(rctx, tableSchema, schema, action) {
     });
     // All four attribute forms (SET/DROP NOT NULL, SET DATA TYPE, SET/DROP DEFAULT,
     // SET COLLATE) report the same `alter`/`column` shape — the event says which column
-    // changed, not which attribute.
+    // changed, not which attribute; `ddl` says which attribute, exactly.
     emitAlterSchemaEvent(rctx, tableSchema, {
         type: 'alter', objectType: 'column',
         objectName: tableSchema.name,
         columnName: action.columnName,
+        ddl: sql,
     });
     log('Altered column %s.%s.%s', tableSchema.schemaName, tableSchema.name, action.columnName);
     return null;
@@ -1268,7 +1336,7 @@ function runDropConstraintTags(rctx, tableSchema, constraintName, keys) {
     log('Dropped tags on constraint %s.%s.%s', tableSchema.schemaName, tableSchema.name, constraintName);
     return null;
 }
-async function runAlterPrimaryKey(rctx, tableSchema, schema, columns) {
+async function runAlterPrimaryKey(rctx, tableSchema, schema, columns, sql) {
     const newPkDef = columns.map(col => {
         const idx = tableSchema.columnIndexMap.get(col.name.toLowerCase());
         if (idx === undefined) {
@@ -1299,7 +1367,7 @@ async function runAlterPrimaryKey(rctx, tableSchema, schema, columns) {
     if (module.alterTable) {
         try {
             const schemaChangePk = newPkDef.map(pk => ({ index: pk.index, desc: pk.desc ?? false }));
-            const updatedTableSchema = await module.alterTable(rctx.db, tableSchema.schemaName, tableSchema.name, { type: 'alterPrimaryKey', newPkColumns: schemaChangePk });
+            const updatedTableSchema = await module.alterTable(rctx.db, tableSchema.schemaName, tableSchema.name, { type: 'alterPrimaryKey', newPkColumns: schemaChangePk, ddl: sql });
             // Events this transaction already recorded identify their rows by the RETIRED
             // key; re-derive each from its own row image so the commit delivers every event
             // under the key the table has at delivery. AFTER the module call (a module
@@ -1329,6 +1397,7 @@ async function runAlterPrimaryKey(rctx, tableSchema, schema, columns) {
             emitAlterSchemaEvent(rctx, tableSchema, {
                 type: 'alter', objectType: 'table',
                 objectName: tableSchema.name,
+                ddl: sql,
             });
             log('Altered primary key of %s.%s (native)', tableSchema.schemaName, tableSchema.name);
             return null;
@@ -1397,6 +1466,7 @@ async function runAlterPrimaryKey(rctx, tableSchema, schema, columns) {
     emitAlterSchemaEvent(rctx, tableSchema, {
         type: 'alter', objectType: 'table',
         objectName: tableSchema.name,
+        ddl: sql,
     });
     log('Altered primary key of %s.%s (rebuild)', tableSchema.schemaName, tableSchema.name);
     return null;
@@ -1495,7 +1565,7 @@ export function buildShadowTableDdl(tableSchema, shadowName, survivingColumns, n
 async function runSetMaintained(rctx, tableSchema, schema, columns, select) {
     const live = schema.getTable(tableSchema.name);
     if (!live) {
-        throw new QuereusError(`no such table: ${tableSchema.name}`, StatusCode.ERROR);
+        throw new RelationNotFoundError(`no such table: ${tableSchema.name}`);
     }
     const explicit = columns !== undefined && columns.length > 0;
     // Any omitted-insert defaults ride inside `select` (→ derivation.selectAst).
@@ -1654,6 +1724,11 @@ async function propagateTableRenameInSchema(db, schema, renamedSchemaName, oldNa
                 });
             }
         }
+        // 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
@@ -1691,6 +1766,20 @@ function rewriteTableForTableRename(table, renamedSchemaLower, oldName, newName)
         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)
+        changed = true;
     if (!changed)
         return table;
     return Object.freeze({
@@ -1700,21 +1789,6 @@ function rewriteTableForTableRename(table, renamedSchemaLower, oldName, newName)
         indexes: table.indexes ? Object.freeze(newIndexes) : table.indexes,
     });
 }
-/**
- * The catalog-backed {@link ResolveColumnInSource} the column-rename rewriters consult
- * to keep their unqualified-reference walk scope-aware. Built once per statement and
- * shared by the pre-flight probe in {@link runRenameColumn} and the real propagation
- * below, so the two cannot drift apart. Note it resolves against the LIVE catalog on
- * every call, so sharing it does not by itself freeze the answer between the two passes
- * — see the pre-flight's comment for why they agree anyway.
- */
-function buildColumnSourceResolver(db) {
-    return (s, t, col) => {
-        const targetSchema = db.schemaManager.getSchema(s);
-        const targetTable = targetSchema?.getTable(t);
-        return targetTable?.columnIndexMap.has(col.toLowerCase()) ?? false;
-    };
-}
 async function propagateColumnRename(rctx, renamedSchemaName, tableName, oldCol, newCol, preStaleMvs, resolveColumnInSource) {
     const schemaManager = rctx.db.schemaManager;
     for (const schema of schemaManager._getAllSchemas()) {
@@ -1769,6 +1843,10 @@ async function propagateColumnRenameInSchema(db, schema, renamedSchemaName, tabl
                 });
             }
         }
+        // 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
@@ -1786,7 +1864,7 @@ function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCo
     const newChecks = table.checkConstraints.map(cc => {
         const rewrote = isRenamedTable
             ? renameColumnInCheckExpression(cc.expr, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource)
-            : renameColumnInAst(cc.expr, tableName, oldCol, newCol, renamedSchemaLower);
+            : renameColumnInAst(cc.expr, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource);
         if (!rewrote)
             return cc;
         changed = true;
@@ -1832,12 +1910,29 @@ function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCo
     const newIndexes = (table.indexes ?? []).map(idx => {
         const rewrote = isRenamedTable
             ? renameColumnInCheckExpression(idx.predicate, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource)
-            : renameColumnInAst(idx.predicate, tableName, oldCol, newCol, renamedSchemaLower);
+            : renameColumnInAst(idx.predicate, tableName, oldCol, newCol, renamedSchemaLower, resolveColumnInSource);
         if (!rewrote)
             return idx;
         changed = true;
         return { ...idx };
     });
+    // Column-level expressions — a DEFAULT (`b integer default (new.a + 1)`) and a
+    // generated column's body (`g integer generated always as (a + 1)`). Same branch split
+    // the checks and predicates use above: the renamed table's own columns take the seeded
+    // walk (a generated body's bare `a` binds to the owning table; a default's `new.a`
+    // names its row image), any other table's take the unseeded one (it can reach here only
+    // through a subquery, whose FROM must bind the ref).
+    //
+    // 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
+    // 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);
+    if (columnsRewritten)
+        changed = true;
     if (!changed)
         return table;
     return Object.freeze({
@@ -1847,6 +1942,31 @@ function rewriteTableForColumnRename(table, renamedSchemaLower, tableName, oldCo
         indexes: table.indexes ? Object.freeze(newIndexes) : table.indexes,
     });
 }
+/**
+ * The unseeded arm of the column-expression rewrite above, for a table that is NOT the
+ * renamed one. `renameColumnInColumnExpressions` is deliberately seeded-only (that is the
+ * whole reason it exists), so the other branch walks the two fields directly with
+ * {@link renameColumnInAst} — the same entry point the checks and predicates arms use for
+ * a foreign table, and for the same reason: an unqualified ref in someone else's default
+ * must bind inside its own subquery's FROM, never to this table.
+ *
+ * `resolveColumnInSource` is as load-bearing here as on the seeded arm, and for the mirror
+ * reason: without it the walk cannot tell that an inner FROM source exposes the old name,
+ * so a nested `(select (select max(a) from other) from t)` rewrites the INNER `a` — which
+ * binds to `other` — and the default silently starts reading a different column. It also
+ * 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) {
+    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))
+                changed = true;
+        }
+    }
+    return changed;
+}
 /**
  * Build a minimal constraints array from an existing ColumnSchema
  * so that the ColumnDef AST accurately represents the column.