@quereus/quereus 4.8.0 → 4.10.0

package/dist/src/schema/column-republication.d.ts

@@ -0,0 +1,126 @@
+import type { Database } from '../core/database.js';
+import type { ObjectRefResolvers } from './object-ref-resolver.js';
+import type { ResolveColumnInSource } from './rename-rewriter.js';
+/**
+ * Column REPUBLICATION: which views / materialized views expose a table's
+ * column as one of their own output columns — a bare passthrough projection
+ * (`select x from t`), or a `*` / `t.*` whose frame binds the table.
+ *
+ * Two verbs consume the same lineage, which is why it lives here in `schema/`
+ * rather than inside either verb's emitter:
+ *
+ * - `ALTER TABLE … RENAME COLUMN` re-targets its propagation on every
+ *   republisher, breadth-first, because rewriting a body shifts the name that
+ *   body PUBLISHES and its readers then need the same rename with the view as
+ *   the target ({@link scanShiftedPublishers}, driven by
+ *   `runtime/emit/column-rename-cascade.ts`).
+ * - `ALTER TABLE … DROP COLUMN` refuses when a live rule (CHECK / DEFAULT /
+ *   generated body / assertion) reads the column, and a rule can read it
+ *   THROUGH a republisher without any body in the chain spelling the column's
+ *   name (`create view v as select * from t` + a rule reading `v.x`). The
+ *   drop guards therefore probe each reached body against every republication
+ *   target ({@link collectColumnRepublication}), not against the base table
+ *   alone — restoring the invariant that the drop refuses exactly the
+ *   references a rename would have rewritten.
+ */
+/** One round's rename target: the object whose published column shifts old → new. */
+export interface ColumnRenameCascadeTarget {
+    /** Canonical `<schema>.<name>` key of the target (see {@link objectRefKey}). */
+    targetKey: string;
+    /** The target's bare name — what unqualified references in dependent bodies spell. */
+    tableName: string;
+}
+/** Visited-set key for one (target, column) pair of a cascade / fixpoint round. */
+export declare const visitKeyOf: (target: ColumnRenameCascadeTarget, oldColLower: string) => string;
+export interface ShiftScanOpts {
+    /**
+     * Probe a spine clone with the round's rewrite applied first — the read-only
+     * pre-flight, whose bodies have not been rewritten yet. The live driver's
+     * scan runs after the round's in-place rewrites and reads the live ASTs.
+     */
+    probeOnClone: boolean;
+    /** MVs whose published names cannot shift (pre-existing staleness — the
+     *  backing columns are not renamed for those). */
+    isMvExcluded: (mv: {
+        schemaName: string;
+        name: string;
+        derivation: {
+            stale?: boolean;
+        };
+    }) => boolean;
+    /** Called once per dependent whose published names the target's rename shifts. */
+    onShifted: (dependent: ColumnRenameCascadeTarget) => void;
+    /** Pre-flight only: a shifted dependent ALSO already publishes `newCol`. */
+    onCollision?: (kind: 'view' | 'materialized view', schemaName: string, name: string) => void;
+    /**
+     * Called for a view / MV with an EXPLICIT column list whose body republishes
+     * the column. Such an object never shifts a published name (the list pins
+     * them — why the rename skips it), but a column DROP changes the arity its
+     * `*` produces and breaks the object outright. Only the drop's fixpoint
+     * passes this; when absent the object is skipped without paying the probe,
+     * exactly as the cascade always has.
+     */
+    onListedShifted?: (kind: 'view' | 'materialized view', schemaName: string, name: string) => void;
+}
+/**
+ * One round's dependent scan, shared by the rename cascade (pre-flight and
+ * live driver) and the drop fixpoint: every schema's plain views and
+ * maintained tables. An explicit column list pins the published names (the
+ * same guard `cte.columns` is inside the CTE exposure analysis), so a listed
+ * object is never a shift target — it is reported through
+ * {@link ShiftScanOpts.onListedShifted} instead, when that arm is wired.
+ */
+export declare function scanShiftedPublishers(db: Database, target: ColumnRenameCascadeTarget, oldCol: string, newCol: string, resolvers: ObjectRefResolvers, resolveColumnInSource: ResolveColumnInSource, opts: ShiftScanOpts): void;
+/** A listed view / MV a column drop would break outright — see {@link ColumnRepublication.brokenListed}. */
+export interface BrokenListedRepublisher {
+    /** Canonical `<schema>.<name>` key, for `ObjectReach.namerOf`. */
+    key: string;
+    /** Error-message spelling: `view 'v'` / `materialized view 'm'`. */
+    describe: string;
+}
+/** What {@link collectColumnRepublication} returns — the drop guards' lineage answer. */
+export interface ColumnRepublication {
+    /**
+     * The seed plus every view / MV that republishes the column, transitively,
+     * breadth-first — the SEED FIRST, so a guard sweeping targets in order
+     * reports base-table matches with the message spelling it always has.
+     */
+    targets: ReadonlyArray<ColumnRenameCascadeTarget>;
+    /**
+     * Views / MVs with an EXPLICIT column list whose body republishes the
+     * column. These are NOT targets — a pinned list publishes no shifted name —
+     * but dropping the column changes the arity their `*` produces and breaks
+     * the object outright, so a rule whose reach names one at all must refuse.
+     */
+    brokenListed: ReadonlyArray<BrokenListedRepublisher>;
+}
+/**
+ * Read-only republication fixpoint for `ALTER TABLE … DROP COLUMN`: the same
+ * breadth-first walk the rename cascade's pre-flight runs
+ * (`assertColumnRenameCascadePublishable`), minus its collision arm, plus the
+ * listed-object arm above.
+ *
+ * Nothing is renamed here, so each round probes with a SENTINEL new name
+ * ({@link PROBE_COLUMN_NAME} — the same trick `columnReferencedInAst` uses):
+ * `probeOnClone` applies the sentinel rename to a spine clone and asks
+ * `bodyExposesRenamedColumn` against it, mutating nothing. Downstream rounds
+ * keep asking about `columnName` unchanged — a republisher exposes the column
+ * under its own name, which is what its readers spell.
+ *
+ * The pristine catalog gives the same answers the cascade's live rounds would,
+ * for the pre-flight's own reason: a round only rewrites references binding
+ * ITS OWN target, which no other round's exposure question consults.
+ *
+ * MATERIALIZED VIEWS are treated exactly like views — `isMvExcluded` never
+ * fires — deliberately CONSERVATIVE: an MV's backing columns survive the drop,
+ * so a rule reading the column through the MV would in fact keep working
+ * (against frozen contents, with the MV marked stale and its next
+ * `refresh materialized view` failing). Refusing anyway keeps one rule for
+ * both object kinds and matches what the named-projection spelling already
+ * does (pinned by 41.10.2 §27) and what `DROP TABLE` does for the same object.
+ * The cascade's stale-MV exclusion is rename-specific (a pre-stale MV's
+ * backing columns are not renamed) and has no drop analogue, so staleness is
+ * not consulted at all.
+ */
+export declare function collectColumnRepublication(db: Database, seed: ColumnRenameCascadeTarget, columnName: string, resolvers: ObjectRefResolvers, resolveColumnInSource: ResolveColumnInSource): ColumnRepublication;
+//# sourceMappingURL=column-republication.d.ts.map

package/dist/src/schema/column-republication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-republication.d.ts","sourceRoot":"","sources":["../../../src/schema/column-republication.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAQnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,qFAAqF;AACrF,MAAM,WAAW,yBAAyB;IACzC,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,mFAAmF;AACnF,eAAO,MAAM,UAAU,GAAI,QAAQ,yBAAyB,EAAE,aAAa,MAAM,KAAG,MAC/C,CAAC;AAEtC,MAAM,WAAW,aAAa;IAC7B;;;;OAIG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB;sDACkD;IAClD,YAAY,EAAE,CAAC,EAAE,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAE,KAAK,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,KAAK,OAAO,CAAC;IACrG,kFAAkF;IAClF,SAAS,EAAE,CAAC,SAAS,EAAE,yBAAyB,KAAK,IAAI,CAAC;IAC1D,4EAA4E;IAC5E,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7F;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACjG;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,EAAE,EAAE,QAAQ,EACZ,MAAM,EAAE,yBAAyB,EACjC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,kBAAkB,EAC7B,qBAAqB,EAAE,qBAAqB,EAC5C,IAAI,EAAE,aAAa,GACjB,IAAI,CA2CN;AAED,4GAA4G;AAC5G,MAAM,WAAW,uBAAuB;IACvC,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ,oEAAoE;IACpE,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,yFAAyF;AACzF,MAAM,WAAW,mBAAmB;IACnC;;;;OAIG;IACH,OAAO,EAAE,aAAa,CAAC,yBAAyB,CAAC,CAAC;IAClD;;;;;OAKG;IACH,YAAY,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAC;CACrD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,0BAA0B,CACzC,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,yBAAyB,EAC/B,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,kBAAkB,EAC7B,qBAAqB,EAAE,qBAAqB,GAC1C,mBAAmB,CA4BrB"}

package/dist/src/schema/column-republication.js

@@ -0,0 +1,121 @@
+import { isMaintainedTable } from './derivation.js';
+import { PROBE_COLUMN_NAME, bodyExposesRenamedColumn, bodyPublishesColumnNamed, objectRefKey, renameColumnInAst, } from './rename-rewriter.js';
+import { spineCloneAst } from '../util/ast-spine-clone.js';
+/** Visited-set key for one (target, column) pair of a cascade / fixpoint round. */
+export const visitKeyOf = (target, oldColLower) => `${target.targetKey}:${oldColLower}`;
+/**
+ * One round's dependent scan, shared by the rename cascade (pre-flight and
+ * live driver) and the drop fixpoint: every schema's plain views and
+ * maintained tables. An explicit column list pins the published names (the
+ * same guard `cte.columns` is inside the CTE exposure analysis), so a listed
+ * object is never a shift target — it is reported through
+ * {@link ShiftScanOpts.onListedShifted} instead, when that arm is wired.
+ */
+export function scanShiftedPublishers(db, target, oldCol, newCol, resolvers, resolveColumnInSource, opts) {
+    for (const schema of db.schemaManager._getAllSchemas()) {
+        const resolve = resolvers.forHomeSchema(schema.name);
+        const shifted = (body) => {
+            let probe = body;
+            if (opts.probeOnClone) {
+                probe = spineCloneAst(body);
+                // Row-image mode 'none': a view / MV body is a relation with no written
+                // row (its `with inverse` / `with defaults` subtrees self-suppress).
+                renameColumnInAst(probe, target.tableName, oldCol, newCol, resolve, target.targetKey, 'none', resolveColumnInSource);
+            }
+            return bodyExposesRenamedColumn(probe, target.tableName, oldCol, newCol, resolve, target.targetKey, resolveColumnInSource);
+        };
+        for (const view of Array.from(schema.getAllViews())) {
+            if (view.columns && view.columns.length > 0) {
+                if (opts.onListedShifted && shifted(view.selectAst)) {
+                    opts.onListedShifted('view', schema.name, view.name);
+                }
+                continue;
+            }
+            if (!shifted(view.selectAst))
+                continue;
+            if (opts.onCollision && bodyPublishesColumnNamed(view.selectAst, newCol, resolve, resolveColumnInSource)) {
+                opts.onCollision('view', schema.name, view.name);
+            }
+            opts.onShifted({ targetKey: objectRefKey(schema.name, view.name), tableName: view.name });
+        }
+        for (const table of Array.from(schema.getAllTables())) {
+            if (!isMaintainedTable(table))
+                continue;
+            if (opts.isMvExcluded(table))
+                continue;
+            const d = table.derivation;
+            if (d.columns && d.columns.length > 0) {
+                if (opts.onListedShifted && shifted(d.selectAst)) {
+                    opts.onListedShifted('materialized view', schema.name, table.name);
+                }
+                continue;
+            }
+            if (!shifted(d.selectAst))
+                continue;
+            if (opts.onCollision && bodyPublishesColumnNamed(d.selectAst, newCol, resolve, resolveColumnInSource)) {
+                opts.onCollision('materialized view', schema.name, table.name);
+            }
+            opts.onShifted({ targetKey: objectRefKey(schema.name, table.name), tableName: table.name });
+        }
+    }
+}
+/**
+ * Read-only republication fixpoint for `ALTER TABLE … DROP COLUMN`: the same
+ * breadth-first walk the rename cascade's pre-flight runs
+ * (`assertColumnRenameCascadePublishable`), minus its collision arm, plus the
+ * listed-object arm above.
+ *
+ * Nothing is renamed here, so each round probes with a SENTINEL new name
+ * ({@link PROBE_COLUMN_NAME} — the same trick `columnReferencedInAst` uses):
+ * `probeOnClone` applies the sentinel rename to a spine clone and asks
+ * `bodyExposesRenamedColumn` against it, mutating nothing. Downstream rounds
+ * keep asking about `columnName` unchanged — a republisher exposes the column
+ * under its own name, which is what its readers spell.
+ *
+ * The pristine catalog gives the same answers the cascade's live rounds would,
+ * for the pre-flight's own reason: a round only rewrites references binding
+ * ITS OWN target, which no other round's exposure question consults.
+ *
+ * MATERIALIZED VIEWS are treated exactly like views — `isMvExcluded` never
+ * fires — deliberately CONSERVATIVE: an MV's backing columns survive the drop,
+ * so a rule reading the column through the MV would in fact keep working
+ * (against frozen contents, with the MV marked stale and its next
+ * `refresh materialized view` failing). Refusing anyway keeps one rule for
+ * both object kinds and matches what the named-projection spelling already
+ * does (pinned by 41.10.2 §27) and what `DROP TABLE` does for the same object.
+ * The cascade's stale-MV exclusion is rename-specific (a pre-stale MV's
+ * backing columns are not renamed) and has no drop analogue, so staleness is
+ * not consulted at all.
+ */
+export function collectColumnRepublication(db, seed, columnName, resolvers, resolveColumnInSource) {
+    const colLower = columnName.toLowerCase();
+    const targets = [seed];
+    const brokenListed = [];
+    const flaggedListed = new Set();
+    const visited = new Set([visitKeyOf(seed, colLower)]);
+    const queue = [seed];
+    while (queue.length > 0) {
+        const target = queue.shift();
+        scanShiftedPublishers(db, target, columnName, PROBE_COLUMN_NAME, resolvers, resolveColumnInSource, {
+            probeOnClone: true,
+            isMvExcluded: () => false,
+            onShifted: dependent => {
+                const key = visitKeyOf(dependent, colLower);
+                if (visited.has(key))
+                    return;
+                visited.add(key);
+                targets.push(dependent);
+                queue.push(dependent);
+            },
+            onListedShifted: (kind, schemaName, name) => {
+                const key = objectRefKey(schemaName, name);
+                if (flaggedListed.has(key))
+                    return;
+                flaggedListed.add(key);
+                brokenListed.push({ key, describe: `${kind} '${name}'` });
+            },
+        });
+    }
+    return { targets, brokenListed };
+}
+//# sourceMappingURL=column-republication.js.map

package/dist/src/schema/column-republication.js.map

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

package/dist/src/schema/column-source-resolver.d.ts

@@ -1,18 +1,41 @@
-import type { SchemaManager } from './manager.js';
+import type { Database } from '../core/database.js';
 import type { ResolveColumnInSource } from './rename-rewriter.js';
 /**
  * The catalog-backed {@link ResolveColumnInSource} every scope-aware walk over a
  * schema-object expression consults to tell an unqualified reference that binds to an
  * inner FROM source from one that binds to the table under consideration.
  *
- * Three callers, one definition, so no two of them can disagree about what a name
+ * Four callers, one definition, so no two of them can disagree about what a name
  * resolves to: `runRenameColumn`'s pre-flight probe and its real propagation, the
- * DROP COLUMN guards in `runtime/emit/drop-column-guards.ts`, and the constraint
- * planner's self-qualifier strip (`planner/building/constraint-builder.ts`).
+ * DROP COLUMN guards (`runtime/emit/drop-column-guards.ts` and
+ * `schema/expression-dependents.ts`), and the constraint planner's self-qualifier
+ * strip (`planner/building/constraint-builder.ts`).
+ *
+ * A source may be a TABLE (a maintained table included — its backing columns are
+ * real) or a VIEW. A view exposes a column when its explicit column list names it,
+ * or — with no list — when its body publishes it ({@link bodyPublishesColumnNamed}:
+ * a result-column alias, a bare projection, or a `*` / `t.*` / `a.*` over a source
+ * that exposes it — a FROM alias only changes which qualifier names the source, so
+ * `select * from t a` publishes exactly what `select * from t` does). The view arm
+ * recurses through this same resolver, so a view over a
+ * view answers too; views cannot be recursive, so the per-question in-flight set is
+ * insurance against a malformed catalog, the same role the visited set plays in
+ * `reachableObjects`.
  *
  * Resolves against the LIVE catalog on every call, so sharing one instance across
  * passes does not by itself freeze the answer between them — see the rename
- * pre-flight's comment for why its two passes agree anyway.
+ * pre-flight's comment for why its two passes agree anyway. The view arm's
+ * unqualified names likewise resolve LIVE down the view's home schema path
+ * ({@link Database._homeSchemaPath}), matching how the view body plans.
+ *
+ * NOTE: deliberately NO cross-call memo. The rename propagation shares one
+ * instance across its pre-flight and its live cascade rounds, and the rounds
+ * rewrite view bodies in place — a memoized "does view X expose col?" answer taken
+ * before a round would be stale after it. The per-question in-flight set bounds the
+ * recursion instead. The one hot-ish caller is `constraint-builder.ts` at
+ * plan-build time, where the view arm only runs for a CHECK whose subquery FROMs a
+ * view; if that ever profiles hot, add a cross-call memo guarded by a catalog
+ * generation counter.
  */
-export declare function buildColumnSourceResolver(schemaManager: SchemaManager): ResolveColumnInSource;
+export declare function buildColumnSourceResolver(db: Database): ResolveColumnInSource;
 //# sourceMappingURL=column-source-resolver.d.ts.map

package/dist/src/schema/column-source-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"column-source-resolver.d.ts","sourceRoot":"","sources":["../../../src/schema/column-source-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,aAAa,EAAE,aAAa,GAAG,qBAAqB,CAM7F"}
+{"version":3,"file":"column-source-resolver.d.ts","sourceRoot":"","sources":["../../../src/schema/column-source-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAoB,MAAM,sBAAsB,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,QAAQ,GAAG,qBAAqB,CAyB7E"}

package/dist/src/schema/column-source-resolver.js

@@ -1,22 +1,91 @@
+import { bodyPublishesColumnNamed, objectRefKey } from './rename-rewriter.js';
 /**
  * The catalog-backed {@link ResolveColumnInSource} every scope-aware walk over a
  * schema-object expression consults to tell an unqualified reference that binds to an
  * inner FROM source from one that binds to the table under consideration.
  *
- * Three callers, one definition, so no two of them can disagree about what a name
+ * Four callers, one definition, so no two of them can disagree about what a name
  * resolves to: `runRenameColumn`'s pre-flight probe and its real propagation, the
- * DROP COLUMN guards in `runtime/emit/drop-column-guards.ts`, and the constraint
- * planner's self-qualifier strip (`planner/building/constraint-builder.ts`).
+ * DROP COLUMN guards (`runtime/emit/drop-column-guards.ts` and
+ * `schema/expression-dependents.ts`), and the constraint planner's self-qualifier
+ * strip (`planner/building/constraint-builder.ts`).
+ *
+ * A source may be a TABLE (a maintained table included — its backing columns are
+ * real) or a VIEW. A view exposes a column when its explicit column list names it,
+ * or — with no list — when its body publishes it ({@link bodyPublishesColumnNamed}:
+ * a result-column alias, a bare projection, or a `*` / `t.*` / `a.*` over a source
+ * that exposes it — a FROM alias only changes which qualifier names the source, so
+ * `select * from t a` publishes exactly what `select * from t` does). The view arm
+ * recurses through this same resolver, so a view over a
+ * view answers too; views cannot be recursive, so the per-question in-flight set is
+ * insurance against a malformed catalog, the same role the visited set plays in
+ * `reachableObjects`.
  *
  * Resolves against the LIVE catalog on every call, so sharing one instance across
  * passes does not by itself freeze the answer between them — see the rename
- * pre-flight's comment for why its two passes agree anyway.
+ * pre-flight's comment for why its two passes agree anyway. The view arm's
+ * unqualified names likewise resolve LIVE down the view's home schema path
+ * ({@link Database._homeSchemaPath}), matching how the view body plans.
+ *
+ * NOTE: deliberately NO cross-call memo. The rename propagation shares one
+ * instance across its pre-flight and its live cascade rounds, and the rounds
+ * rewrite view bodies in place — a memoized "does view X expose col?" answer taken
+ * before a round would be stale after it. The per-question in-flight set bounds the
+ * recursion instead. The one hot-ish caller is `constraint-builder.ts` at
+ * plan-build time, where the view arm only runs for a CHECK whose subquery FROMs a
+ * view; if that ever profiles hot, add a cross-call memo guarded by a catalog
+ * generation counter.
+ */
+export function buildColumnSourceResolver(db) {
+    const answer = (schemaName, sourceName, columnName, inFlight) => {
+        const targetSchema = db.schemaManager.getSchema(schemaName);
+        if (!targetSchema)
+            return false;
+        const colLower = columnName.toLowerCase();
+        const table = targetSchema.getTable(sourceName);
+        if (table)
+            return table.columnIndexMap.has(colLower);
+        const view = targetSchema.getView(sourceName);
+        if (!view)
+            return false;
+        if (view.columns && view.columns.length > 0) {
+            return view.columns.some(c => c.toLowerCase() === colLower);
+        }
+        const key = `${objectRefKey(targetSchema.name, view.name)}:${colLower}`;
+        if (inFlight.has(key))
+            return false;
+        inFlight.add(key);
+        try {
+            const recurse = (s, t, c) => answer(s, t, c, inFlight);
+            return bodyPublishesColumnNamed(view.selectAst, columnName, liveHomePathResolver(db, view.schemaName), recurse);
+        }
+        finally {
+            inFlight.delete(key);
+        }
+    };
+    return (schemaName, sourceName, columnName) => answer(schemaName, sourceName, columnName, new Set());
+}
+/**
+ * Live {@link ResolveObjectRef} for one home schema — the same resolution rule
+ * `snapshotObjectRefResolvers` snapshots (qualified passthrough; unqualified →
+ * first home-path schema holding a table or view of the name; miss → home key),
+ * answered against the live catalog. Live is right here: this resolver's contract
+ * is live answers, and the rename cascade's mid-statement body rewrites change
+ * published COLUMNS, never the object names this resolves.
  */
-export function buildColumnSourceResolver(schemaManager) {
-    return (s, t, col) => {
-        const targetSchema = schemaManager.getSchema(s);
-        const targetTable = targetSchema?.getTable(t);
-        return targetTable?.columnIndexMap.has(col.toLowerCase()) ?? false;
+function liveHomePathResolver(db, homeSchemaName) {
+    return (schema, name) => {
+        if (schema !== undefined)
+            return objectRefKey(schema, name);
+        for (const pathSchemaName of db._homeSchemaPath(homeSchemaName)) {
+            const pathSchema = db.schemaManager.getSchema(pathSchemaName);
+            if (!pathSchema)
+                continue;
+            if (pathSchema.getTable(name) !== undefined || pathSchema.getView(name) !== undefined) {
+                return objectRefKey(pathSchemaName, name);
+            }
+        }
+        return objectRefKey(homeSchemaName, name);
     };
 }
 //# sourceMappingURL=column-source-resolver.js.map

package/dist/src/schema/column-source-resolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"column-source-resolver.js","sourceRoot":"","sources":["../../../src/schema/column-source-resolver.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,yBAAyB,CAAC,aAA4B;IACrE,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE;QACpB,MAAM,YAAY,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,WAAW,GAAG,YAAY,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;QAC9C,OAAO,WAAW,EAAE,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,IAAI,KAAK,CAAC;IACpE,CAAC,CAAC;AACH,CAAC"}
+{"version":3,"file":"column-source-resolver.js","sourceRoot":"","sources":["../../../src/schema/column-source-resolver.ts"],"names":[],"mappings":"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"}

package/dist/src/schema/expression-dependents.d.ts

@@ -0,0 +1,160 @@
+import type { Database } from '../core/database.js';
+import type { TableSchema } from './table.js';
+/**
+ * The catalog query "which stored, table-attached expressions reference this object?",
+ * shared by every DROP guard that has to refuse breaking one.
+ *
+ * A CHECK constraint, a column DEFAULT and a `GENERATED ALWAYS AS` body may all contain
+ * a subquery, so any of them can legitimately name a column or a table belonging to some
+ * OTHER table, in some other schema. `ALTER TABLE … RENAME` has always known this — it
+ * rewrites those expressions across every table in every schema — while the DROP guards
+ * used to scan only the altered table's own constraints and columns. The gap let
+ * `alter table t drop column v` and `drop table t` succeed while another table's CHECK
+ * still read `t.v`, leaving that table unwritable with an error naming neither the
+ * dropped object nor the constraint that broke.
+ *
+ * Everything here therefore walks the catalog the same way the rename propagation does —
+ * ONE {@link snapshotObjectRefResolvers} snapshot, a resolver per OWNING schema, the same
+ * scope-aware probes — so "the drop refuses exactly what a rename would have rewritten"
+ * holds by construction rather than by comment.
+ *
+ * **The own-table / other-table probe split is load-bearing.** It mirrors
+ * `rewriteTableForColumnRename`'s `isRenamedTable` branch:
+ *
+ * - On the **probed table itself**, the *seeded* probe
+ *   ({@link columnReferencedInCheckExpression}) — an unqualified name in a CHECK /
+ *   DEFAULT there binds the owning table implicitly.
+ * - On **any other table**, the *unseeded* probe ({@link columnReferencedInAst}) — no
+ *   implicit binding, so only an explicit reference through a subquery counts. Getting
+ *   this backwards false-refuses on every table that merely happens to have a like-named
+ *   column.
+ *
+ * The seed answers only that binding question. What a bare `new.` / `old.` qualifier
+ * NAMES is a separate, explicitly-passed
+ * {@link import('./rename-rewriter.js').RowImageContext} — `'own'` on the seeded
+ * base-target probe, `'foreign'` on every other ROOT body (that table's row image is its
+ * own columns, not ours), `'none'` on the view / MV bodies below the root. See
+ * {@link columnProbe}.
+ *
+ * Partial-index predicates need no arm: the parser rejects a subquery in a partial-index
+ * predicate, so such a predicate can only name its own table, and `runDropColumn`'s
+ * existing predicate guard covers that case.
+ *
+ * Views are deliberately NOT probed as *dependents*. Dropping a table or column out from
+ * under a plain view stays allowed and breaks the view — the engine's stated asymmetry
+ * (see `runtime/emit/assertion-drop-guard.ts`): a broken view breaks queries OF that view,
+ * while a broken CHECK makes a whole table unwritable.
+ *
+ * Each probe runs over the REACH of the stored expression — {@link reachableObjects}, the
+ * same breadth-first closure over stored view / materialized-view bodies the assertion
+ * guards consume — not over the expression alone. Two consequences, both load-bearing:
+ *
+ * - A DIRECT reference matches exactly where a rename would have rewritten it, so the two
+ *   definitions still cannot drift; the reach path is empty there, which is what keeps the
+ *   guards' direct message spelling unchanged.
+ * - An INDIRECT reference — the expression names a view, whose body names the dropped
+ *   object, to any depth — matches too. Without that, `check (n < (select max(v) from vv))`
+ *   over `create view vv as select v from t` let `drop table t` /
+ *   `alter table t drop column v` through and left the referencing table unwritable with
+ *   an error naming neither the dropped object nor the constraint that broke.
+ *
+ * The root body is walked with `rowImageContext` and every body below it without — see
+ * `reachableObjects`' `rootOpts`. Rooting a CHECK / DEFAULT without it would put a table
+ * literally called `new` in the reach and false-refuse its own drop.
+ *
+ * NOTE: each probe walks every table in every schema, re-walking already-parsed ASTs, and
+ * now builds one closure PER STORED EXPRESSION rather than per table. The closure only
+ * expands objects a body actually names, so an expression naming no view adds no reached
+ * bodies at all — but it is still one extra walk per expression for the COLUMN verb, which
+ * pays `collectTableRefsInAst` to build the reach and then the column probe on top (the
+ * table verb reads its answer straight off the reach, so it is walk-for-walk with the
+ * one-hop probe it replaced). The COLUMN verb additionally runs one republication
+ * fixpoint per guard call (`schema/column-republication.ts` — a catalog sweep per round)
+ * and probes bodies × targets instead of bodies × 1; targets beyond the base table exist
+ * only when some view republishes the dropped column, so the common case pays one sweep
+ * and nothing else. Reasoned from the call shape, not measured. DDL is rare and
+ * schemas hold handfuls of tables, so this is not worth optimising now; if it ever shows as
+ * hot, gate each table on a cheap literal name scan of its stored SQL before paying for the
+ * AST walk.
+ */
+/** A stored, table-attached expression that references a probed object. */
+export interface ExpressionDependent {
+    /** The table carrying the expression. */
+    table: TableSchema;
+    /** True when {@link table} IS the probed table (a self-reference), false otherwise. */
+    ownTable: boolean;
+    /** What to call it in an error: `CHECK constraint 'ck1'`, `the DEFAULT of column 'w'`, … */
+    describe: string;
+    /**
+     * The stored bodies the expression traversed to reach the probed object, each already
+     * described (`view 'v'`, `materialized view 'm'`) — EMPTY when the expression names the
+     * object itself. Feed it to `describeReachPath` to phrase an indirect refusal.
+     */
+    path: ReadonlyArray<string>;
+    /**
+     * Present when the match is not a body NAMING the column but a view / MV the drop
+     * would BREAK OUTRIGHT: the object declares an explicit column list over a body
+     * whose `*` republishes the dropped column, so the drop changes the star's arity
+     * and every reference to the object breaks — not just references to one column.
+     * The value is the object's description (`view 'v'`), for the refusal message.
+     */
+    breaksEntirely?: string;
+}
+/**
+ * Which family of stored expressions a column probe walks. The two exist separately
+ * because `runDropColumn` reports them through two guards with two different messages,
+ * ordered by widening blast radius.
+ */
+export type ColumnExpressionArm = 
+/** CHECK constraint expressions. */
+'check'
+/** Column DEFAULT and `GENERATED ALWAYS AS` expressions. */
+ | 'columnExpression';
+/**
+ * The FIRST table in ANY schema whose `arm` expressions name
+ * `<tableSchema.schemaName>.<tableSchema.name>.<columnName>`, or `undefined` when none
+ * does. The probed table itself is scanned first, so a self-reference is always the one
+ * reported and the guards' own-table messages never change spelling because an unrelated
+ * schema happens to sort earlier.
+ *
+ * Only the first hit is returned: every caller is a guard that throws on it, and stopping
+ * early keeps the walk off the remaining schemas.
+ *
+ * Two expressions are skipped on the probed table itself, both deliberately:
+ *
+ * - The dropped column's **own** DEFAULT / generated body — it goes away with the column,
+ *   so a self-naming default (`a integer default (new.a)`) is not something the drop
+ *   orphans.
+ * - **Every** own-table generated body — `runDropColumn` already refuses off
+ *   `generatedColumnDependencies`, the resolved column-index map
+ *   `extractGeneratedColumnDependencies` builds, and reporting it twice would only change
+ *   which of two messages the user sees. A generated body on ANOTHER table is not covered
+ *   by that map and IS reported here.
+ */
+export declare function findColumnExpressionDependent(db: Database, tableSchema: TableSchema, columnName: string, arm: ColumnExpressionArm): ExpressionDependent | undefined;
+/**
+ * The FIRST table in ANY schema whose CHECK / DEFAULT / `GENERATED ALWAYS AS` expressions
+ * name `<schemaName>.<objectName>`, or `undefined` when none does.
+ *
+ * The dropped object itself is skipped: its own CHECKs naming itself vanish with it, so
+ * refusing on them would make every self-referencing table undroppable. (The column verb
+ * keeps its target in the walk — a column drop leaves the rest of the table behind.)
+ *
+ * All three arms run with the walker's `rowImageContext` on the ROOT expression, exactly as
+ * `renameTableInCheckConstraints` / `renameTableInColumnExpressions` do: these
+ * expressions evaluate against a written row, so a bare `new.` / `old.` qualifier names
+ * that row image rather than a table literally called `new`.
+ *
+ * The match is `namerOf` over the expression's whole reach, so a CHECK that reads a view
+ * whose body reads the dropped object matches too, and `path` carries the shortest chain
+ * for the error to quote — empty exactly when the expression names the object itself.
+ */
+export declare function findTableExpressionDependent(db: Database, schemaName: string, objectName: string): ExpressionDependent | undefined;
+/**
+ * How an error should spell `table` when the object being dropped lives in `homeSchemaName`:
+ * bare when the two share a schema, schema-qualified when they do not — the same rule the
+ * rest of the engine's messages follow, and the only way a cross-schema refusal names a
+ * table the user can actually find.
+ */
+export declare function describeDependentTable(table: TableSchema, homeSchemaName: string): string;
+//# sourceMappingURL=expression-dependents.d.ts.map

package/dist/src/schema/expression-dependents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-dependents.d.ts","sourceRoot":"","sources":["../../../src/schema/expression-dependents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,YAAY,CAAC;AAanE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AAEH,2EAA2E;AAC3E,MAAM,WAAW,mBAAmB;IACnC,yCAAyC;IACzC,KAAK,EAAE,WAAW,CAAC;IACnB,uFAAuF;IACvF,QAAQ,EAAE,OAAO,CAAC;IAClB,4FAA4F;IAC5F,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB;AAC9B,oCAAoC;AAClC,OAAO;AACT,4DAA4D;GAC1D,kBAAkB,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,6BAA6B,CAC5C,EAAE,EAAE,QAAQ,EACZ,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,mBAAmB,GACtB,mBAAmB,GAAG,SAAS,CAoBjC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAC3C,EAAE,EAAE,QAAQ,EACZ,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GAChB,mBAAmB,GAAG,SAAS,CAgBjC;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAIzF"}