@quereus/quereus 4.7.0 → 4.9.0

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"}

package/dist/src/schema/expression-dependents.js

@@ -0,0 +1,228 @@
+import { expressionToString } from '../emit/ast-stringify.js';
+import { columnReferencedInAst, columnReferencedInCheckExpression, objectRefKey, } from './rename-rewriter.js';
+import { buildColumnSourceResolver } from './column-source-resolver.js';
+import { snapshotObjectRefResolvers } from './object-ref-resolver.js';
+import { reachableObjects } from './object-dependency-closure.js';
+import { collectColumnRepublication } from './column-republication.js';
+/**
+ * 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 function findColumnExpressionDependent(db, tableSchema, columnName, arm) {
+    const resolvers = snapshotObjectRefResolvers(db);
+    const resolveColumnInSource = buildColumnSourceResolver(db);
+    const targetKey = objectRefKey(tableSchema.schemaName, tableSchema.name);
+    // One republication fixpoint per drop (seed first), shared by every probe below:
+    // a view republishing the column by a star (`select * from t`) is a target its
+    // readers reference the column THROUGH, without any body spelling the name.
+    const republication = collectColumnRepublication(db, { targetKey, tableName: tableSchema.name }, columnName, resolvers, resolveColumnInSource);
+    for (const table of tablesProbedTargetFirst(db, targetKey)) {
+        const ownTable = objectRefKey(table.schemaName, table.name) === targetKey;
+        const names = columnProbe(db, resolvers, table.schemaName, ownTable, republication, columnName, resolveColumnInSource);
+        const found = arm === 'check'
+            ? findInChecks(table, names)
+            : findInColumnExpressions(table, ownTable, columnName, names);
+        if (found)
+            return { table, ownTable, ...found };
+    }
+    return 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 function findTableExpressionDependent(db, schemaName, objectName) {
+    const resolvers = snapshotObjectRefResolvers(db);
+    const targetKey = objectRefKey(schemaName, objectName);
+    for (const table of tablesProbedTargetFirst(db, targetKey)) {
+        if (objectRefKey(table.schemaName, table.name) === targetKey)
+            continue;
+        const names = expr => {
+            if (expr === undefined)
+                return undefined;
+            const path = reachableObjects(db, expr, table.schemaName, resolvers, { rowImageContext: true })
+                .namerOf(targetKey)?.path;
+            return path === undefined ? undefined : { path };
+        };
+        const found = findInChecks(table, names) ?? findInColumnExpressions(table, false, undefined, names);
+        if (found)
+            return { table, ownTable: false, ...found };
+    }
+    return 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 function describeDependentTable(table, homeSchemaName) {
+    return table.schemaName.toLowerCase() === homeSchemaName.toLowerCase()
+        ? `'${table.name}'`
+        : `'${table.schemaName}.${table.name}'`;
+}
+/**
+ * Every table in every schema, with the probed table (if it exists) first.
+ *
+ * Order is not cosmetic: the guards report the FIRST hit, and the own-table messages are
+ * the ones users and tests already know. Scanning the target first keeps a self-reference
+ * winning over an unrelated schema's.
+ *
+ * NOTE: past the probed table the order is `_getAllSchemas()` × `getAllTables()` insertion
+ * order, so with TWO referencing tables which one the refusal names follows catalog
+ * insertion rather than any user-visible rule. Harmless while the message is advisory —
+ * every referencing table has to be dealt with anyway. If a caller ever needs to *list*
+ * dependents (a `CASCADE` arm, an introspection function), give it a collect-all entry
+ * point with a defined order rather than calling this in a loop.
+ */
+function* tablesProbedTargetFirst(db, targetKey) {
+    const rest = [];
+    for (const schema of db.schemaManager._getAllSchemas()) {
+        for (const table of schema.getAllTables()) {
+            if (objectRefKey(table.schemaName, table.name) === targetKey)
+                yield table;
+            else
+                rest.push(table);
+        }
+    }
+    yield* rest;
+}
+/**
+ * The column probe for one scanned table — seeded on the probed table itself, unseeded
+ * everywhere else. See this module's header for why that split is load-bearing.
+ *
+ * The column question is not "does the reach CONTAIN this key?" (which is all the table
+ * verb needs) but "does any body in the reach NAME this column?", so this loops the reach's
+ * bodies the way `assertNoAssertionNamesColumn` already does, each under its own resolver.
+ * `homeSchemaName` is the SCANNED table's schema — the root expression's own — because that
+ * is what its unqualified names resolve against.
+ *
+ * Each body is probed against EVERY republication target, not the base table alone: a
+ * reference through `create view v as select * from t` spells the column against `v`, and
+ * only the target sweep sees it. Targets are swept OUTER, bodies inner, base table first —
+ * so every match the base-table sweep finds is found at the body it always was, and the
+ * existing message spellings (`reaches it through view 'v'`) do not move; the widened
+ * targets only ever ADD refusals.
+ *
+ * After the target sweep, the broken-listed arm: a view / MV with an explicit column list
+ * over a `*` covering the column breaks OUTRIGHT on the drop (the star's arity changes),
+ * so an expression whose reach names such an object at all refuses, marked
+ * {@link ProbeMatch.breaksEntirely} so the guard can phrase it honestly.
+ */
+function columnProbe(db, resolvers, homeSchemaName, ownTable, republication, columnName, resolveColumnInSource) {
+    return expr => {
+        if (!expr)
+            return undefined;
+        const reach = reachableObjects(db, expr, homeSchemaName, resolvers, { rowImageContext: true });
+        for (const [targetIndex, target] of republication.targets.entries()) {
+            for (const reached of reach.bodies) {
+                // Seeded ONLY on the probed table's own ROOT body, probing the BASE target: a
+                // CHECK / DEFAULT there is written against the row being written, so an
+                // unqualified name binds the owning table implicitly. A view body below it is
+                // a relation with no such seed, the root body of ANOTHER table's expression
+                // binds that table's row, not ours — and no expression ever binds a VIEW
+                // target implicitly, so a republication target takes the unseeded probe even
+                // at the root (a reference to it can only sit inside a subquery FROM).
+                const seeded = targetIndex === 0 && ownTable && reached.ownerKey === undefined;
+                // Row-image mode, the one non-constant site: a ROOT body is a table's CHECK /
+                // DEFAULT / generated expression and therefore always written-row context —
+                // `'own'` only for the seeded base-target case, `'foreign'` otherwise (another
+                // table's root body binds that table's image; a republication target at the
+                // root still binds the OWNING table's image, not the view being probed).
+                // Anything REACHED below the root is a view / MV body — a relation with no
+                // written row — so `'none'`.
+                const rowImage = reached.ownerKey === undefined ? (seeded ? 'own' : 'foreign') : 'none';
+                const hit = seeded
+                    ? columnReferencedInCheckExpression(reached.body, target.tableName, columnName, reached.resolve, target.targetKey, rowImage, resolveColumnInSource)
+                    : columnReferencedInAst(reached.body, target.tableName, columnName, reached.resolve, target.targetKey, rowImage, resolveColumnInSource);
+                if (hit)
+                    return { path: reached.path };
+            }
+        }
+        for (const broken of republication.brokenListed) {
+            const namer = reach.namerOf(broken.key);
+            if (namer)
+                return { path: namer.path, breaksEntirely: broken.describe };
+        }
+        return undefined;
+    };
+}
+/** The first CHECK constraint of `table` the probe matches, described for an error. */
+function findInChecks(table, names) {
+    for (const check of table.checkConstraints ?? []) {
+        // `!== undefined`, not truthiness: a match with an EMPTY path is a direct match.
+        const match = names(check.expr);
+        if (match !== undefined)
+            return { describe: describeCheck(check), ...match };
+    }
+    return undefined;
+}
+/**
+ * The first column DEFAULT / generated body of `table` the probe matches, described for
+ * an error. `skipColumnName` is the column being dropped, skipped only on the probed
+ * table itself; own-table generated bodies are skipped outright (see
+ * {@link findColumnExpressionDependent}).
+ */
+function findInColumnExpressions(table, ownTable, skipColumnName, names) {
+    const lowerSkip = ownTable ? skipColumnName?.toLowerCase() : undefined;
+    for (const col of table.columns) {
+        if (lowerSkip !== undefined && col.name.toLowerCase() === lowerSkip)
+            continue;
+        // `!== undefined` for the same reason as in {@link findInChecks}: an empty-path
+        // match is a direct hit.
+        const defaultMatch = names(col.defaultValue ?? undefined);
+        if (defaultMatch !== undefined) {
+            return { describe: `the DEFAULT of column '${col.name}'`, ...defaultMatch };
+        }
+        if (ownTable)
+            continue;
+        const generatedMatch = names(col.generatedExpr);
+        if (generatedMatch !== undefined) {
+            return { describe: `the GENERATED expression of column '${col.name}'`, ...generatedMatch };
+        }
+    }
+    return undefined;
+}
+/**
+ * A table-level unnamed CHECK genuinely carries `name: undefined` — the `_check_<table>`
+ * spelling `manager.ts` produces is error text, not stored identity — so there is no name
+ * to quote and the expression stands in for one. That is also the only handle the user
+ * has on it: `DROP CONSTRAINT` resolves by name only, so an unnamed CHECK can only be
+ * removed by rebuilding its table.
+ */
+function describeCheck(check) {
+    return check.name
+        ? `CHECK constraint '${check.name}'`
+        : `the CHECK constraint (${expressionToString(check.expr)})`;
+}
+//# sourceMappingURL=expression-dependents.js.map

package/dist/src/schema/expression-dependents.js.map

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