@quereus/quereus 4.6.0 → 4.8.0

package/dist/src/schema/rename-rewriter.d.ts

@@ -9,6 +9,32 @@ import type * as AST from '../parser/ast.js';
  */
 export type ResolveColumnInSource = (schemaName: string, tableName: string, columnName: string) => boolean;
 export declare function renameTableInAst(node: AST.AstNode | undefined, oldName: string, newName: string, defaultSchemaName: string): boolean;
+/**
+ * Whether `node` refers to the table/view `name` in schema `defaultSchemaName` —
+ * read-only, nothing is mutated.
+ *
+ * Deliberately the SAME traversal {@link renameTableInAst} uses, run with
+ * `dryRun`, so "refers to" can never drift from "would have been rewritten by a
+ * rename". That equivalence is the whole point: the DROP guard refuses exactly
+ * the cases `ALTER TABLE … RENAME` would have followed. A second traversal — or
+ * a `renameTableInAst(clone, name, name, …)` trick, which would silently
+ * re-case identifiers — would both break it.
+ *
+ * `name` is passed as both old and new name; under `dryRun` the new name is
+ * never read.
+ *
+ * The column-level probes ({@link columnReferencedInAst},
+ * {@link columnReferencedInCheckExpression}) reach the same equivalence a
+ * different way — a real rename, to a sentinel name, over a throwaway
+ * {@link spineCloneAst} copy — because the column walker has ~8 mutation points
+ * and a CTE-re-exposure branch that reads the new name, so threading `dryRun`
+ * through it is the riskier of the two. Neither flaw of the identity-rename
+ * trick warned against above applies there: the mutated node is a discarded
+ * clone (nothing user-visible is re-cased), and the target is a fresh name no
+ * column can hold, so `newCol !== oldCol` and the re-exposure branch answers
+ * exactly as it would for a real rename to an unused name.
+ */
+export declare function tableReferencedInAst(node: AST.AstNode | undefined, name: string, defaultSchemaName: string): boolean;
 /**
  * Rewrite the renamed table inside every partial-index predicate of `indexes`,
  * in place. A predicate may carry a table-qualified self-reference
@@ -35,6 +61,31 @@ export declare function renameTableInIndexPredicates(indexes: ReadonlyArray<{
 export declare function renameTableInCheckConstraints(checks: ReadonlyArray<{
     readonly expr: AST.Expression;
 }> | undefined, oldName: string, newName: string, defaultSchemaName: string): boolean;
+/**
+ * Rewrite the renamed table inside the two expressions a `ColumnSchema` can carry —
+ * a column DEFAULT (`w integer default ((select min(v) from u))`, however authored:
+ * inline, or via `ALTER TABLE … ALTER COLUMN … SET DEFAULT`, which writes the same
+ * field) and a generated column's body (`g integer generated always as ((select
+ * min(u.v) from u) + id)`) — in place.
+ *
+ * Unlike the column-rename counterpart ({@link renameColumnInColumnExpressions}) there
+ * is no seeded/unseeded split: {@link renameTableInAst} resolves nothing against an
+ * implicit owning table, so the SAME entry point is correct for the renamed table's own
+ * columns (a self-referencing default, `default ((select count(*) from t))`) and for
+ * every other table's.
+ *
+ * Same sharing and idempotence story as {@link renameTableInCheckConstraints}: the
+ * `Expression` is the very AST the catalog's `TableSchema` holds, so one in-place
+ * rewrite reaches every holder and a second call with the same pair finds nothing
+ * naming `oldName` and returns false.
+ *
+ * The parameter is structurally typed rather than `ColumnSchema[]` so this module stays
+ * free of catalog imports; `ColumnSchema` satisfies it.
+ */
+export declare function renameTableInColumnExpressions(columns: ReadonlyArray<{
+    readonly defaultValue?: AST.Expression | null;
+    readonly generatedExpr?: AST.Expression;
+}> | undefined, oldName: string, newName: string, defaultSchemaName: string): boolean;
 /**
  * Rewrite column references inside a full statement/expression AST, resolving
  * unqualified refs against the FROM scopes the walk descends (no implicit seed,
@@ -72,8 +123,54 @@ export declare function renameColumnInAst(node: AST.AstNode | undefined, tableNa
  * sources are not asked (the rewriter would need recursive column-set
  * inference on their bodies). `renameColumnInAst` shares the same callback
  * (passed by the view-body callers) and the same limitation.
+ *
+ * The seed also makes this walk the owner of the `new.` / `old.` **row-image**
+ * namespace: a CHECK may name the row being written explicitly
+ * (`check (new.a > 0)`, `check on delete (old.a > 0)` — `docs/sql-ddl.md`
+ * § CHECK Constraints), and those qualifiers name the owning table's row, not
+ * anything a FROM clause binds. So the qualified-ref case matches them too —
+ * but only here, never through `renameColumnInAst`, where a `new.` ref belongs
+ * to some other table's row image.
+ *
+ * That match is scope-**aware**, not depth-blind, because `new` and `old` are
+ * not reserved words in this parser: `create table "new" (…)` is legal, so a
+ * CHECK may legitimately contain `(select max("new".a) from "new")`. The match
+ * therefore requires that no FROM/WITH frame above the seed rebind the
+ * qualifier — see `matchesRowImage`.
  */
 export declare function renameColumnInCheckExpression(expr: AST.AstNode | undefined, tableName: string, oldColName: string, newColName: string, defaultSchemaName: string, resolveColumnInSource?: ResolveColumnInSource): boolean;
+/**
+ * Whether `node` refers to `tableName`.`columnName` — read-only with respect to
+ * the caller's AST; a throwaway {@link spineCloneAst} copy is what gets
+ * rewritten.
+ *
+ * Same equivalence {@link tableReferencedInAst} establishes for the table verb,
+ * and for the same reason: "refers to" must mean "would have been rewritten by
+ * `ALTER TABLE … RENAME COLUMN`", or a DROP guard built on it refuses a
+ * different set of cases than the rename follows. See that function's comment
+ * for why the column verb reaches it by clone+sentinel rather than by `dryRun`.
+ *
+ * `resolveColumnInSource` is **not optional in practice**: without it the walk
+ * has no way to tell that an unqualified ref inside a subquery binds to a
+ * like-named column on the subquery's own FROM source, and a caller asking
+ * "does this body name `t.v`?" gets `true` for a body whose only `v` is
+ * another table's. Every caller should pass the catalog-backed resolver
+ * (`buildColumnSourceResolver`).
+ *
+ * NOTE: one spine clone plus one walk per probe, and the DROP COLUMN guard probes every
+ * live assertion. Trivial at the handful-of-assertions scale schemas have today, and it
+ * only runs on DDL; if a schema ever carries assertions by the hundred, filter by
+ * `tableReferencedInAst` (no clone) before paying for the column probe.
+ */
+export declare function columnReferencedInAst(node: AST.AstNode | undefined, tableName: string, columnName: string, defaultSchemaName: string, resolveColumnInSource?: ResolveColumnInSource): boolean;
+/**
+ * {@link columnReferencedInAst} for an expression that resolves unqualified refs
+ * against an implicit binding to `tableName` — a CHECK expression or a
+ * partial-index predicate. Uses {@link renameColumnInCheckExpression}'s seeded
+ * entry point so the probe answers for exactly the scope that expression is
+ * planned in.
+ */
+export declare function columnReferencedInCheckExpression(expr: AST.AstNode | undefined, tableName: string, columnName: string, defaultSchemaName: string, resolveColumnInSource?: ResolveColumnInSource): boolean;
 /**
  * Rewrite the renamed column inside every partial-index predicate of `indexes`,
  * in place. A predicate resolves unqualified refs against the indexed table
@@ -92,6 +189,12 @@ export declare function renameColumnInCheckExpression(expr: AST.AstNode | undefi
  *
  * The parameter is structurally typed rather than `IndexSchema[]` so this module
  * stays free of catalog imports; `IndexSchema` satisfies it.
+ *
+ * Sharing the seeded entry point also brings its `new.` / `old.` row-image match
+ * along, which is inert here: a partial-index predicate describes rows already
+ * stored, has no written-row context, and a predicate naming one would not plan
+ * in the first place. Nothing to suppress — noted so the shared entry point does
+ * not read as an oversight.
  */
 export declare function renameColumnInIndexPredicates(indexes: ReadonlyArray<{
     readonly predicate?: AST.Expression;
@@ -109,6 +212,45 @@ export declare function renameColumnInIndexPredicates(indexes: ReadonlyArray<{
 export declare function renameColumnInCheckConstraints(checks: ReadonlyArray<{
     readonly expr: AST.Expression;
 }> | undefined, tableName: string, oldColName: string, newColName: string, defaultSchemaName: string, resolveColumnInSource?: ResolveColumnInSource): boolean;
+/**
+ * Rewrite the renamed column inside the two expressions a `ColumnSchema` can carry —
+ * a column DEFAULT (`b integer default (new.a + 1)`, however authored: inline, or via
+ * `ALTER TABLE … ALTER COLUMN … SET DEFAULT`, which writes the same field) and a
+ * generated column's body (`g integer generated always as (a + 1)`) — in place, for
+ * every column of the renamed table itself.
+ *
+ * The seeded {@link renameColumnInCheckExpression} entry point is correct for both, for
+ * the two halves of what the seed provides:
+ *
+ * - The implicit unaliased binding to the owning table is what makes a generated
+ *   column's **bare** `a` resolve — it has no FROM clause to bind against, exactly like
+ *   a CHECK.
+ * - The seed also owns the `new.` / `old.` **row-image** namespace, which is what makes a
+ *   default's `new.a` resolve. A default is evaluated against the row being written, so
+ *   that qualifier names this table's row image, not anything a FROM binds.
+ *
+ * Case folding (`NEW.A`) and the shadowing edge (a real table literally named `new`,
+ * reached from a subquery inside the expression) therefore behave exactly as they do for
+ * a CHECK, because the same walk decides all three.
+ *
+ * Only pass the renamed table's OWN columns. A default on a *different* table can reach
+ * this table only through a subquery, so an unqualified ref there must bind inside that
+ * subquery's FROM — that caller wants {@link renameColumnInAst}, whose walk has no seed.
+ *
+ * Same sharing and idempotence story as {@link renameColumnInCheckConstraints}: a
+ * module's rename hook rebuilds only the renamed column's `ColumnSchema` and keeps every
+ * other one by reference, and even the rebuilt one carries the SAME expression nodes
+ * (`buildConstraintsFromColumn` passes them into the reconstructed `ColumnDef` by
+ * reference and `columnDefToSchema` assigns them straight back), so one in-place rewrite
+ * reaches every holder and a second call with the same pair is a no-op.
+ *
+ * The parameter is structurally typed rather than `ColumnSchema[]` so this module stays
+ * free of catalog imports; `ColumnSchema` satisfies it.
+ */
+export declare function renameColumnInColumnExpressions(columns: ReadonlyArray<{
+    readonly defaultValue?: AST.Expression | null;
+    readonly generatedExpr?: AST.Expression;
+}> | undefined, tableName: string, oldColName: string, newColName: string, defaultSchemaName: string, resolveColumnInSource?: ResolveColumnInSource): boolean;
 /**
  * Strip table-qualified self-references in a CHECK expression down to the
  * unqualified form: `check (t.qty > 0)` (or `main.t.qty`) becomes

package/dist/src/schema/rename-rewriter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rename-rewriter.d.ts","sourceRoot":"","sources":["../../../src/schema/rename-rewriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,kBAAkB,CAAC;AA2C7C;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,KACd,OAAO,CAAC;AAcb,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAKT;AAyMD;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EAC3E,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAGT;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC5C,MAAM,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EACpE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAGT;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAaT;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAoBT;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC5C,OAAO,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EAC3E,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAGT;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC7C,MAAM,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EACpE,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAGT;AA0rBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mCAAmC,CAClD,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,EAAE,qBAAqB,GAC1C,OAAO,CAkBT"}
+{"version":3,"file":"rename-rewriter.d.ts","sourceRoot":"","sources":["../../../src/schema/rename-rewriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,kBAAkB,CAAC;AAmD7C;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,KACd,OAAO,CAAC;AAwBb,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAKT;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAKT;AA4MD;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EAC3E,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAGT;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC5C,MAAM,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EACpE,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAGT;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,aAAa,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,aAAa,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC;CACxC,CAAC,GAAG,SAAS,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAOT;AAoBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAcT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAqBT;AASD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAKT;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAChD,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAKT;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,6BAA6B,CAC5C,OAAO,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EAC3E,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAGT;AAED;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAC7C,MAAM,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,CAAA;CAAE,CAAC,GAAG,SAAS,EACpE,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAGT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,+BAA+B,CAC9C,OAAO,EAAE,aAAa,CAAC;IACtB,QAAQ,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,UAAU,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,aAAa,CAAC,EAAE,GAAG,CAAC,UAAU,CAAC;CACxC,CAAC,GAAG,SAAS,EACd,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAOT;AAmwBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mCAAmC,CAClD,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,EAAE,qBAAqB,GAC1C,OAAO,CAkBT"}

package/dist/src/schema/rename-rewriter.js

@@ -1,8 +1,6 @@
+import { spineCloneAst } from '../util/ast-spine-clone.js';
 const eq = (a, b) => (a ?? '').toLowerCase() === (b ?? '').toLowerCase();
 const schemaMatches = (nodeSchema, defaultSchema) => nodeSchema === undefined || eq(nodeSchema, defaultSchema);
-// ──────────────────────────────────────────────────────────────────────
-// Table rename
-// ──────────────────────────────────────────────────────────────────────
 export function renameTableInAst(node, oldName, newName, defaultSchemaName) {
     if (!node)
         return false;
@@ -10,9 +8,44 @@ export function renameTableInAst(node, oldName, newName, defaultSchemaName) {
     visitTableRename(node, oldName, newName, defaultSchemaName, ctx);
     return ctx.changed;
 }
+/**
+ * Whether `node` refers to the table/view `name` in schema `defaultSchemaName` —
+ * read-only, nothing is mutated.
+ *
+ * Deliberately the SAME traversal {@link renameTableInAst} uses, run with
+ * `dryRun`, so "refers to" can never drift from "would have been rewritten by a
+ * rename". That equivalence is the whole point: the DROP guard refuses exactly
+ * the cases `ALTER TABLE … RENAME` would have followed. A second traversal — or
+ * a `renameTableInAst(clone, name, name, …)` trick, which would silently
+ * re-case identifiers — would both break it.
+ *
+ * `name` is passed as both old and new name; under `dryRun` the new name is
+ * never read.
+ *
+ * The column-level probes ({@link columnReferencedInAst},
+ * {@link columnReferencedInCheckExpression}) reach the same equivalence a
+ * different way — a real rename, to a sentinel name, over a throwaway
+ * {@link spineCloneAst} copy — because the column walker has ~8 mutation points
+ * and a CTE-re-exposure branch that reads the new name, so threading `dryRun`
+ * through it is the riskier of the two. Neither flaw of the identity-rename
+ * trick warned against above applies there: the mutated node is a discarded
+ * clone (nothing user-visible is re-cased), and the target is a fresh name no
+ * column can hold, so `newCol !== oldCol` and the re-exposure branch answers
+ * exactly as it would for a real rename to an unused name.
+ */
+export function tableReferencedInAst(node, name, defaultSchemaName) {
+    if (!node)
+        return false;
+    const ctx = { changed: false, dryRun: true };
+    visitTableRename(node, name, name, defaultSchemaName, ctx);
+    return ctx.changed;
+}
 function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
     if (!node)
         return;
+    // A dry run only answers yes/no — stop as soon as the answer is known.
+    if (ctx.dryRun && ctx.changed)
+        return;
     switch (node.type) {
         case 'select': {
             const stmt = node;
@@ -91,7 +124,8 @@ function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
         case 'table': {
             const ts = node;
             if (eq(ts.table.name, oldName) && schemaMatches(ts.table.schema, defaultSchemaName)) {
-                ts.table.name = newName;
+                if (!ctx.dryRun)
+                    ts.table.name = newName;
                 ctx.changed = true;
             }
             break;
@@ -176,7 +210,8 @@ function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
         case 'column': {
             const col = node;
             if (col.table && eq(col.table, oldName) && schemaMatches(col.schema, defaultSchemaName)) {
-                col.table = newName;
+                if (!ctx.dryRun)
+                    col.table = newName;
                 ctx.changed = true;
             }
             break;
@@ -190,8 +225,9 @@ function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
  * Apply an in-place expression rewrite across a schema-object collection,
  * skipping items whose expression is absent. Returns whether any item changed.
  *
- * Backs the four `rename*In{IndexPredicates,CheckConstraints}` entry points
- * below, which differ only in which field they pluck and which walker they run.
+ * Backs the `rename{Column,Table}In{IndexPredicates,CheckConstraints,ColumnExpressions}`
+ * entry points below, which differ only in which field they pluck and which walker they
+ * run.
  */
 function rewriteEach(items, pick, rewrite) {
     let changed = false;
@@ -228,11 +264,40 @@ export function renameTableInIndexPredicates(indexes, oldName, newName, defaultS
 export function renameTableInCheckConstraints(checks, oldName, newName, defaultSchemaName) {
     return rewriteEach(checks, cc => cc.expr, expr => renameTableInAst(expr, oldName, newName, defaultSchemaName));
 }
+/**
+ * Rewrite the renamed table inside the two expressions a `ColumnSchema` can carry —
+ * a column DEFAULT (`w integer default ((select min(v) from u))`, however authored:
+ * inline, or via `ALTER TABLE … ALTER COLUMN … SET DEFAULT`, which writes the same
+ * field) and a generated column's body (`g integer generated always as ((select
+ * min(u.v) from u) + id)`) — in place.
+ *
+ * Unlike the column-rename counterpart ({@link renameColumnInColumnExpressions}) there
+ * is no seeded/unseeded split: {@link renameTableInAst} resolves nothing against an
+ * implicit owning table, so the SAME entry point is correct for the renamed table's own
+ * columns (a self-referencing default, `default ((select count(*) from t))`) and for
+ * every other table's.
+ *
+ * Same sharing and idempotence story as {@link renameTableInCheckConstraints}: the
+ * `Expression` is the very AST the catalog's `TableSchema` holds, so one in-place
+ * rewrite reaches every holder and a second call with the same pair finds nothing
+ * naming `oldName` and returns false.
+ *
+ * The parameter is structurally typed rather than `ColumnSchema[]` so this module stays
+ * free of catalog imports; `ColumnSchema` satisfies it.
+ */
+export function renameTableInColumnExpressions(columns, oldName, newName, defaultSchemaName) {
+    const rewrite = (expr) => renameTableInAst(expr, oldName, newName, defaultSchemaName);
+    // Both walks always run — `||` on the results, not short-circuited between them.
+    const defaultsChanged = rewriteEach(columns, c => c.defaultValue ?? undefined, rewrite);
+    const generatedChanged = rewriteEach(columns, c => c.generatedExpr, rewrite);
+    return defaultsChanged || generatedChanged;
+}
 function rewriteIdentifierIfTable(id, oldName, newName, defaultSchemaName, ctx) {
     if (!id)
         return;
     if (eq(id.name, oldName) && schemaMatches(id.schema, defaultSchemaName)) {
-        id.name = newName;
+        if (!ctx.dryRun)
+            id.name = newName;
         ctx.changed = true;
     }
 }
@@ -266,6 +331,7 @@ export function renameColumnInAst(node, tableName, oldColName, newColName, defau
         scopeStack: [],
         changed: false,
         resolveColumnInSource,
+        matchRowImageQualifier: false,
     };
     visitColumnRename(node, state);
     return state.changed;
@@ -290,6 +356,20 @@ export function renameColumnInAst(node, tableName, oldColName, newColName, defau
  * sources are not asked (the rewriter would need recursive column-set
  * inference on their bodies). `renameColumnInAst` shares the same callback
  * (passed by the view-body callers) and the same limitation.
+ *
+ * The seed also makes this walk the owner of the `new.` / `old.` **row-image**
+ * namespace: a CHECK may name the row being written explicitly
+ * (`check (new.a > 0)`, `check on delete (old.a > 0)` — `docs/sql-ddl.md`
+ * § CHECK Constraints), and those qualifiers name the owning table's row, not
+ * anything a FROM clause binds. So the qualified-ref case matches them too —
+ * but only here, never through `renameColumnInAst`, where a `new.` ref belongs
+ * to some other table's row image.
+ *
+ * That match is scope-**aware**, not depth-blind, because `new` and `old` are
+ * not reserved words in this parser: `create table "new" (…)` is legal, so a
+ * CHECK may legitimately contain `(select max("new".a) from "new")`. The match
+ * therefore requires that no FROM/WITH frame above the seed rebind the
+ * qualifier — see `matchesRowImage`.
  */
 export function renameColumnInCheckExpression(expr, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
     if (!expr)
@@ -302,6 +382,7 @@ export function renameColumnInCheckExpression(expr, tableName, oldColName, newCo
         scopeStack: [],
         changed: false,
         resolveColumnInSource,
+        matchRowImageQualifier: true,
     };
     const frame = emptyFrame();
     frame.unaliased.add(state.tableName);
@@ -314,6 +395,52 @@ export function renameColumnInCheckExpression(expr, tableName, oldColName, newCo
     }
     return state.changed;
 }
+/**
+ * Sentinel rename target for the two read-only column probes below. No user
+ * column can hold this name, and the probe rewrites *to* it, so it can never
+ * collide with anything the walk is looking for.
+ */
+const PROBE_COLUMN_NAME = '__quereus_column_probe__';
+/**
+ * Whether `node` refers to `tableName`.`columnName` — read-only with respect to
+ * the caller's AST; a throwaway {@link spineCloneAst} copy is what gets
+ * rewritten.
+ *
+ * Same equivalence {@link tableReferencedInAst} establishes for the table verb,
+ * and for the same reason: "refers to" must mean "would have been rewritten by
+ * `ALTER TABLE … RENAME COLUMN`", or a DROP guard built on it refuses a
+ * different set of cases than the rename follows. See that function's comment
+ * for why the column verb reaches it by clone+sentinel rather than by `dryRun`.
+ *
+ * `resolveColumnInSource` is **not optional in practice**: without it the walk
+ * has no way to tell that an unqualified ref inside a subquery binds to a
+ * like-named column on the subquery's own FROM source, and a caller asking
+ * "does this body name `t.v`?" gets `true` for a body whose only `v` is
+ * another table's. Every caller should pass the catalog-backed resolver
+ * (`buildColumnSourceResolver`).
+ *
+ * NOTE: one spine clone plus one walk per probe, and the DROP COLUMN guard probes every
+ * live assertion. Trivial at the handful-of-assertions scale schemas have today, and it
+ * only runs on DDL; if a schema ever carries assertions by the hundred, filter by
+ * `tableReferencedInAst` (no clone) before paying for the column probe.
+ */
+export function columnReferencedInAst(node, tableName, columnName, defaultSchemaName, resolveColumnInSource) {
+    if (!node)
+        return false;
+    return renameColumnInAst(spineCloneAst(node), tableName, columnName, PROBE_COLUMN_NAME, defaultSchemaName, resolveColumnInSource);
+}
+/**
+ * {@link columnReferencedInAst} for an expression that resolves unqualified refs
+ * against an implicit binding to `tableName` — a CHECK expression or a
+ * partial-index predicate. Uses {@link renameColumnInCheckExpression}'s seeded
+ * entry point so the probe answers for exactly the scope that expression is
+ * planned in.
+ */
+export function columnReferencedInCheckExpression(expr, tableName, columnName, defaultSchemaName, resolveColumnInSource) {
+    if (!expr)
+        return false;
+    return renameColumnInCheckExpression(spineCloneAst(expr), tableName, columnName, PROBE_COLUMN_NAME, defaultSchemaName, resolveColumnInSource);
+}
 /**
  * Rewrite the renamed column inside every partial-index predicate of `indexes`,
  * in place. A predicate resolves unqualified refs against the indexed table
@@ -332,6 +459,12 @@ export function renameColumnInCheckExpression(expr, tableName, oldColName, newCo
  *
  * The parameter is structurally typed rather than `IndexSchema[]` so this module
  * stays free of catalog imports; `IndexSchema` satisfies it.
+ *
+ * Sharing the seeded entry point also brings its `new.` / `old.` row-image match
+ * along, which is inert here: a partial-index predicate describes rows already
+ * stored, has no written-row context, and a predicate naming one would not plan
+ * in the first place. Nothing to suppress — noted so the shared entry point does
+ * not read as an oversight.
  */
 export function renameColumnInIndexPredicates(indexes, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
     return rewriteEach(indexes, idx => idx.predicate, expr => renameColumnInCheckExpression(expr, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource));
@@ -349,6 +482,48 @@ export function renameColumnInIndexPredicates(indexes, tableName, oldColName, ne
 export function renameColumnInCheckConstraints(checks, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
     return rewriteEach(checks, cc => cc.expr, expr => renameColumnInCheckExpression(expr, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource));
 }
+/**
+ * Rewrite the renamed column inside the two expressions a `ColumnSchema` can carry —
+ * a column DEFAULT (`b integer default (new.a + 1)`, however authored: inline, or via
+ * `ALTER TABLE … ALTER COLUMN … SET DEFAULT`, which writes the same field) and a
+ * generated column's body (`g integer generated always as (a + 1)`) — in place, for
+ * every column of the renamed table itself.
+ *
+ * The seeded {@link renameColumnInCheckExpression} entry point is correct for both, for
+ * the two halves of what the seed provides:
+ *
+ * - The implicit unaliased binding to the owning table is what makes a generated
+ *   column's **bare** `a` resolve — it has no FROM clause to bind against, exactly like
+ *   a CHECK.
+ * - The seed also owns the `new.` / `old.` **row-image** namespace, which is what makes a
+ *   default's `new.a` resolve. A default is evaluated against the row being written, so
+ *   that qualifier names this table's row image, not anything a FROM binds.
+ *
+ * Case folding (`NEW.A`) and the shadowing edge (a real table literally named `new`,
+ * reached from a subquery inside the expression) therefore behave exactly as they do for
+ * a CHECK, because the same walk decides all three.
+ *
+ * Only pass the renamed table's OWN columns. A default on a *different* table can reach
+ * this table only through a subquery, so an unqualified ref there must bind inside that
+ * subquery's FROM — that caller wants {@link renameColumnInAst}, whose walk has no seed.
+ *
+ * Same sharing and idempotence story as {@link renameColumnInCheckConstraints}: a
+ * module's rename hook rebuilds only the renamed column's `ColumnSchema` and keeps every
+ * other one by reference, and even the rebuilt one carries the SAME expression nodes
+ * (`buildConstraintsFromColumn` passes them into the reconstructed `ColumnDef` by
+ * reference and `columnDefToSchema` assigns them straight back), so one in-place rewrite
+ * reaches every holder and a second call with the same pair is a no-op.
+ *
+ * The parameter is structurally typed rather than `ColumnSchema[]` so this module stays
+ * free of catalog imports; `ColumnSchema` satisfies it.
+ */
+export function renameColumnInColumnExpressions(columns, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
+    const rewrite = (expr) => renameColumnInCheckExpression(expr, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource);
+    // Both walks always run — `||` on the results, not short-circuited between them.
+    const defaultsChanged = rewriteEach(columns, c => c.defaultValue ?? undefined, rewrite);
+    const generatedChanged = rewriteEach(columns, c => c.generatedExpr, rewrite);
+    return defaultsChanged || generatedChanged;
+}
 function emptyFrame() {
     return {
         unaliased: new Set(),
@@ -509,6 +684,66 @@ function isQualifierShadowedInScope(state, qualifier) {
     }
     return false;
 }
+/**
+ * Whether a qualified column ref names the **row image** of the table this
+ * seeded walk was entered for — `new.<col>` / `old.<col>` inside one of its own
+ * CHECK expressions. Only the seeded entry point sets
+ * `matchRowImageQualifier`; see {@link renameColumnInCheckExpression} for why
+ * that scoping is what keeps another table's `new.` ref out of this match.
+ *
+ * A schema-qualified `main.new.a` is a real three-part table reference, never a
+ * row image, so it is excluded outright.
+ *
+ * `qualifierLower` is `col.table` already lowercased by the caller.
+ */
+function matchesRowImage(state, col, qualifierLower) {
+    if (!state.matchRowImageQualifier)
+        return false;
+    if (col.schema !== undefined)
+        return false;
+    if (qualifierLower !== 'new' && qualifierLower !== 'old')
+        return false;
+    return !isQualifierReboundAboveSeed(state, qualifierLower);
+}
+/**
+ * Whether any real FROM / WITH frame rebinds `qualifier` to a row source of its
+ * own, which would make a `new.` / `old.` ref name that source rather than the
+ * row image. `new` and `old` are not reserved words here — `create table "new"`
+ * is legal — so this scan is what stops the row-image match from false-firing
+ * inside `check ((select max("new".a) from "new") >= 0)`.
+ *
+ * The scan starts at index 1: frame 0 is the implicit seed
+ * {@link renameColumnInCheckExpression} pushes for the owning table, which is
+ * not a FROM binding and must not count as a rebind. All four ways a frame can
+ * bind a qualifier are checked — an unaliased source, an alias, a CTE name in
+ * scope, and a shadowing-but-not-exposing CTE source.
+ *
+ * Deliberately "any enclosing frame wins" rather than innermost-first: a frame
+ * only sits above index 0 while the walk is *inside* the subquery that pushed
+ * it, so every such frame really does enclose the reference. A top-level
+ * `new.a` in `check (new.a > 0 and (select count(*) from "new") >= 0)` is
+ * visited with only the seed on the stack and still matches.
+ *
+ * NOTE: the residual is a *correlated* `new.<col>` written inside a subquery
+ * that selects from a real table named `new` — left alone by both the rewrite
+ * and the drop refusal, since the qualifier is ambiguous there anyway. If that
+ * ever needs to resolve to the row image, it needs a spelling that distinguishes
+ * the two (the SQL standard has none), not a change to this scan.
+ */
+function isQualifierReboundAboveSeed(state, qualifier) {
+    for (let i = 1; i < state.scopeStack.length; i++) {
+        const frame = state.scopeStack[i];
+        if (frame.unaliased.has(qualifier))
+            return true;
+        if (frame.aliasMap.has(qualifier))
+            return true;
+        if (frame.ctesInScope.has(qualifier))
+            return true;
+        if (frame.ctesShadowingSource.has(qualifier))
+            return true;
+    }
+    return false;
+}
 function visitColumnRename(node, state) {
     if (!node)
         return;
@@ -830,7 +1065,11 @@ function visitColumnRename(node, state) {
                     (col.schema === undefined || eq(col.schema, state.defaultSchema)) &&
                     !isQualifierShadowedInScope(state, qualifierLower);
                 const viaAlias = aliasResolvesToTable(state, col.table);
-                if (directHit || viaAlias) {
+                // Row-image match is tried LAST so a table genuinely named `new` or
+                // `old` that is itself the renamed table keeps resolving through
+                // `directHit` exactly as it did before this path existed.
+                const rowImageHit = !directHit && !viaAlias && matchesRowImage(state, col, qualifierLower);
+                if (directHit || viaAlias || rowImageHit) {
                     col.name = state.newCol;
                     state.changed = true;
                 }
@@ -971,6 +1210,12 @@ function isResultColumnExposure(col, bodyFrame, state) {
  * is the reserved written-row namespace no FROM source legitimately shadows), so
  * no scope tracking applies — narrower and simpler than the scope-aware walkers
  * above. Returns whether any reference was rewritten.
+ *
+ * Depth-blind **on purpose**, unlike the row-image match in `matchesRowImage`.
+ * The two look alike but answer different questions: this one rewrites by view
+ * *output* name inside a `with inverse` expr, whose grammar admits no FROM
+ * clause that could rebind `new`, whereas a CHECK body may contain a subquery
+ * selecting from a real table named `"new"` and so must consult the scope stack.
  */
 function renameNewQualifiedRefs(expr, renames) {
     let changed = false;