@quereus/quereus 4.8.0 → 4.9.0

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

package/dist/src/schema/object-dependency-closure.d.ts

@@ -0,0 +1,127 @@
+import type * as AST from '../parser/ast.js';
+import type { Database } from '../core/database.js';
+import { type ResolveObjectRef, type TableRenameOpts } from './rename-rewriter.js';
+import type { ObjectRefResolvers } from './object-ref-resolver.js';
+/**
+ * The catalog query "can this stored body REACH that object?", as opposed to the
+ * one-hop "does this stored body NAME that object?" the rename walkers answer.
+ *
+ * A DROP guard that only asks the one-hop question is defeated by a view: an
+ * assertion body reading `v` where `create view v as select * from t` names `t`
+ * nowhere, so `drop table t` is accepted and every later write to the whole
+ * database fails on an assertion whose text does not mention `t`. Reach is the
+ * closure over STORED bodies — an assertion body names views and materialized
+ * views, whose bodies name further views and base tables — and this module is
+ * the one place that closure is computed, so the guard families that consume it
+ * cannot end up disagreeing about what "reaches" means.
+ *
+ * Each body is walked under ITS OWN home-schema resolver, so an unqualified
+ * name in a view body means what the planner would make of it *in that body*,
+ * not what it would mean in the root body. That is the whole reason
+ * {@link ObjectRefResolvers} is a per-home-schema factory over one snapshot.
+ *
+ * Scope-awareness survives the widening because the walk is
+ * {@link collectTableRefsInAst}, the third sink over the very traversal the
+ * rename uses: a body whose `with t as (…)` merely shadows the name still
+ * contributes no reference, so the closure cannot false-refuse where the direct
+ * probe already does not.
+ */
+/**
+ * One stored body the closure walked, and how the root got to it.
+ *
+ * The root body itself is a `ReachedBody` with an empty {@link path} and no
+ * {@link ownerKey} — it is an assertion's CHECK, or a table's CHECK / DEFAULT /
+ * generated expression, none of which is a catalog object with a key of its own.
+ */
+export interface ReachedBody {
+    /**
+     * Canonical `<schema>.<name>` key of the view / materialized view owning this
+     * body, or `undefined` for the ROOT body the closure started from.
+     */
+    ownerKey: string | undefined;
+    /**
+     * The stored bodies traversed from the root to this one INCLUSIVE, root-first,
+     * each described for an error message: `view 'v'`, `materialized view 'm'`.
+     * Empty for the root body itself, which is what tells a caller its match is
+     * direct and needs no "reaches it through …" clause.
+     */
+    path: ReadonlyArray<string>;
+    /** The AST to walk — an assertion/CHECK expression at the root, a view body below it. */
+    body: AST.AstNode;
+    /** Planner-parity resolver for THIS body's home schema. */
+    resolve: ResolveObjectRef;
+}
+/** What {@link reachableObjects} returns: the walked bodies, and who named what. */
+export interface ObjectReach {
+    /**
+     * The root body followed by every stored body reached from it, breadth-first.
+     * A caller asking a question the closure does not answer itself — "does any
+     * body in the reach name `t.x`?" — probes these in order.
+     */
+    readonly bodies: ReadonlyArray<ReachedBody>;
+    /**
+     * The body that NAMES `key`, or `undefined` when nothing in the reach does.
+     * Breadth-first, so the answer is the shortest chain from the root and its
+     * {@link ReachedBody.path} is the shortest path to quote in an error.
+     *
+     * NOTE: two chains of EQUAL length to the same object tie on queue order,
+     * i.e. the order the parent bodies happened to name their children. Harmless
+     * while the path is advisory — either chain is a true one, and dropping the
+     * rule is the escape hatch for both — but a caller that ever needs a
+     * deterministic chain (a stable error-message fixture, say) has to order the
+     * candidates itself.
+     */
+    namerOf(key: string): ReachedBody | undefined;
+}
+/**
+ * Every object reachable from `root` through stored view / materialized-view
+ * bodies, plus the bodies traversed to get there.
+ *
+ * `homeSchemaName` is the root body's OWN schema — the assertion's schema, or
+ * the schema of the table carrying the CHECK / DEFAULT — because that is what
+ * the root's unqualified names resolve against.
+ *
+ * `resolvers` is REQUIRED rather than built here, and the reason is snapshot
+ * discipline (see {@link import('./object-ref-resolver.js').snapshotObjectRefResolvers}):
+ * a caller looping over many roots must share ONE pre-mutation snapshot, and a
+ * default would silently give each root its own.
+ *
+ * Termination is a visited set of object keys, so a mutually-referencing or
+ * otherwise malformed catalog is walked once per object rather than forever. A
+ * body naming an object that does not exist is not an error: the resolver's
+ * miss→home fallback keys it stably and the expansion below simply finds
+ * nothing to expand.
+ *
+ * `rootOpts` applies to the ROOT body's collection ONLY, never to a body
+ * reached below it. Every reached body is a view / materialized-view body — a
+ * relation, with no written-row context — so
+ * {@link import('./rename/table-rename.js').TableRenameOpts.rowImageContext}
+ * would be wrong there. It is REQUIRED at a root that is a table's CHECK
+ * constraint or column DEFAULT / generated body, where a bare `new.a` names the
+ * row image: rooted there without the flag, a table literally called `new`
+ * would land in the reach and false-refuse its own drop
+ * (`schema/expression-dependents.ts` passes it for exactly that reason). The
+ * assertion guards pass nothing: an assertion CHECK owns no `new.` / `old.`
+ * namespace either.
+ *
+ * Root-only stays correct even though a reached body CAN carry a bare unbound
+ * `new.` qualifier — a `with inverse` / `with defaults` expression holds one
+ * legitimately (`CREATE VIEW` accepts it there; the refs name the enclosing
+ * select's output row) — because the walker suppresses those SUBTREES itself,
+ * unconditionally, wherever the walk entered (`rename/table-rename.ts`,
+ * `visitRowImageSubtree`). The suppression travels with the position, not with
+ * this flag, so a reached view body self-suppresses and leaking `rootOpts`
+ * downward would change no answer. Pinned by
+ * `test/logic/41.10.4-drop-object-expression-dependents.sqllogic` (drop of a
+ * table named `new` reached through a `with inverse` view).
+ */
+export declare function reachableObjects(db: Database, root: AST.AstNode, homeSchemaName: string, resolvers: ObjectRefResolvers, rootOpts?: TableRenameOpts): ObjectReach;
+/**
+ * The `reaches it through view 'v2' -> view 'v1'` clause for a
+ * {@link ReachedBody.path}, or the empty string when the match is direct.
+ * Shared so every guard consuming the closure phrases an indirect refusal the
+ * same way — a user told to fix a rule whose body does not mention the dropped
+ * object needs the chain, or the message is unactionable.
+ */
+export declare function describeReachPath(path: ReadonlyArray<string>): string;
+//# sourceMappingURL=object-dependency-closure.d.ts.map

package/dist/src/schema/object-dependency-closure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-dependency-closure.d.ts","sourceRoot":"","sources":["../../../src/schema/object-dependency-closure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAA6C,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC9H,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAGnE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC3B;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B;;;;;OAKG;IACH,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B,yFAAyF;IACzF,IAAI,EAAE,GAAG,CAAC,OAAO,CAAC;IAClB,2DAA2D;IAC3D,OAAO,EAAE,gBAAgB,CAAC;CAC1B;AAED,oFAAoF;AACpF,MAAM,WAAW,WAAW;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC5C;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,gBAAgB,CAC/B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,GAAG,CAAC,OAAO,EACjB,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,kBAAkB,EAC7B,QAAQ,CAAC,EAAE,eAAe,GACxB,WAAW,CA+Bb;AAgDD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAErE"}

package/dist/src/schema/object-dependency-closure.js

@@ -0,0 +1,117 @@
+import { collectTableRefsInAst, objectRefKeySchema } from './rename-rewriter.js';
+import { isMaintainedTable } from './derivation.js';
+/**
+ * Every object reachable from `root` through stored view / materialized-view
+ * bodies, plus the bodies traversed to get there.
+ *
+ * `homeSchemaName` is the root body's OWN schema — the assertion's schema, or
+ * the schema of the table carrying the CHECK / DEFAULT — because that is what
+ * the root's unqualified names resolve against.
+ *
+ * `resolvers` is REQUIRED rather than built here, and the reason is snapshot
+ * discipline (see {@link import('./object-ref-resolver.js').snapshotObjectRefResolvers}):
+ * a caller looping over many roots must share ONE pre-mutation snapshot, and a
+ * default would silently give each root its own.
+ *
+ * Termination is a visited set of object keys, so a mutually-referencing or
+ * otherwise malformed catalog is walked once per object rather than forever. A
+ * body naming an object that does not exist is not an error: the resolver's
+ * miss→home fallback keys it stably and the expansion below simply finds
+ * nothing to expand.
+ *
+ * `rootOpts` applies to the ROOT body's collection ONLY, never to a body
+ * reached below it. Every reached body is a view / materialized-view body — a
+ * relation, with no written-row context — so
+ * {@link import('./rename/table-rename.js').TableRenameOpts.rowImageContext}
+ * would be wrong there. It is REQUIRED at a root that is a table's CHECK
+ * constraint or column DEFAULT / generated body, where a bare `new.a` names the
+ * row image: rooted there without the flag, a table literally called `new`
+ * would land in the reach and false-refuse its own drop
+ * (`schema/expression-dependents.ts` passes it for exactly that reason). The
+ * assertion guards pass nothing: an assertion CHECK owns no `new.` / `old.`
+ * namespace either.
+ *
+ * Root-only stays correct even though a reached body CAN carry a bare unbound
+ * `new.` qualifier — a `with inverse` / `with defaults` expression holds one
+ * legitimately (`CREATE VIEW` accepts it there; the refs name the enclosing
+ * select's output row) — because the walker suppresses those SUBTREES itself,
+ * unconditionally, wherever the walk entered (`rename/table-rename.ts`,
+ * `visitRowImageSubtree`). The suppression travels with the position, not with
+ * this flag, so a reached view body self-suppresses and leaking `rootOpts`
+ * downward would change no answer. Pinned by
+ * `test/logic/41.10.4-drop-object-expression-dependents.sqllogic` (drop of a
+ * table named `new` reached through a `with inverse` view).
+ */
+export function reachableObjects(db, root, homeSchemaName, resolvers, rootOpts) {
+    const bodies = [];
+    const namer = new Map();
+    /** Object keys already expanded (or found not to be a stored body). */
+    const visited = new Set();
+    const queue = [{
+            ownerKey: undefined,
+            path: [],
+            body: root,
+            resolve: resolvers.forHomeSchema(homeSchemaName),
+        }];
+    // Breadth-first: `namer` and `path` then carry the SHORTEST chain to each
+    // object, which is the one an error message should quote.
+    for (let head = 0; head < queue.length; head++) {
+        const current = queue[head];
+        bodies.push(current);
+        // `ownerKey === undefined` identifies the ROOT uniquely — every body reached
+        // below it gets one from `childBody`.
+        const opts = current.ownerKey === undefined ? rootOpts : undefined;
+        for (const [key, nameLower] of collectTableRefsInAst(current.body, current.resolve, opts)) {
+            if (!namer.has(key))
+                namer.set(key, current);
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            const child = expandStoredBody(db, key, nameLower, resolvers, current);
+            if (child)
+                queue.push(child);
+        }
+    }
+    return { bodies, namerOf: key => namer.get(key) };
+}
+/**
+ * The stored body of the object `key` names, as a child of `parent` — or
+ * `undefined` when the key names something with no body to follow: a base table,
+ * or nothing at all.
+ *
+ * A materialized view is looked up as a TABLE (one `TableSchema`, one catalog
+ * name) and its body hangs off `derivation.selectAst`; see `schema/derivation.ts`.
+ */
+function expandStoredBody(db, key, nameLower, resolvers, parent) {
+    const schema = db.schemaManager.getSchema(objectRefKeySchema(key, nameLower));
+    if (!schema)
+        return undefined;
+    const view = schema.getView(nameLower);
+    if (view)
+        return childBody(key, `view '${view.name}'`, view.selectAst, view.schemaName, resolvers, parent);
+    const table = schema.getTable(nameLower);
+    if (isMaintainedTable(table)) {
+        return childBody(key, `materialized view '${table.name}'`, table.derivation.selectAst, table.schemaName, resolvers, parent);
+    }
+    return undefined;
+}
+/** A reached stored body, with the parent's path extended by its own description. */
+function childBody(ownerKey, describe, body, ownerSchemaName, resolvers, parent) {
+    return {
+        ownerKey,
+        path: [...parent.path, describe],
+        body,
+        resolve: resolvers.forHomeSchema(ownerSchemaName),
+    };
+}
+/**
+ * The `reaches it through view 'v2' -> view 'v1'` clause for a
+ * {@link ReachedBody.path}, or the empty string when the match is direct.
+ * Shared so every guard consuming the closure phrases an indirect refusal the
+ * same way — a user told to fix a rule whose body does not mention the dropped
+ * object needs the chain, or the message is unactionable.
+ */
+export function describeReachPath(path) {
+    return path.length === 0 ? '' : ` through ${path.join(' -> ')}`;
+}
+//# sourceMappingURL=object-dependency-closure.js.map

package/dist/src/schema/object-dependency-closure.js.map

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

package/dist/src/schema/object-ref-resolver.d.ts

@@ -0,0 +1,83 @@
+import type { Database } from '../core/database.js';
+import { type ResolveObjectRef, type TableRenameTarget } from './rename-rewriter.js';
+/**
+ * Per-home-schema {@link ResolveObjectRef} factory over ONE catalog snapshot.
+ * The rename propagation walks dependents living in many schemas, and each
+ * dependent's unqualified names resolve under ITS OWN home schema path — so
+ * one statement needs one snapshot and many resolvers derived from it.
+ */
+export interface ObjectRefResolvers {
+    /** Resolver for a stored body owned by `homeSchemaName`. Cached per home schema. */
+    forHomeSchema(homeSchemaName: string): ResolveObjectRef;
+    /**
+     * A sibling snapshot with one table rename applied — the catalog as it will
+     * look AFTER the statement. Used only to check the rename post-condition
+     * ({@link import('./rename/table-rename.js').renameTableInAst}: a rewritten
+     * reference must still resolve to the renamed object). Derived from this
+     * snapshot's name sets, never the live catalog, so the SNAPSHOT DISCIPLINE
+     * below holds for both.
+     */
+    withTableRenamed(schemaName: string, oldName: string, newName: string): ObjectRefResolvers;
+}
+/**
+ * The catalog-backed {@link ResolveObjectRef} the rename walkers consult to decide
+ * whether a table/view reference written in a stored body denotes the object being
+ * renamed / probed. It answers the way the PLANNER answers for that body — against
+ * the owning object's home schema path ({@link Database._homeSchemaPath}:
+ * `[homeSchema, ...session default path]`) — not against a single "default schema".
+ *
+ * Resolution rules:
+ * - **Qualified** (`schema` present) → `objectRefKey(schema, name)`, no catalog
+ *   lookup. A qualified name means what it says even when the object does not
+ *   exist (it may be the one about to be created, or the one just renamed away).
+ * - **Unqualified** → the first schema in the home path holding a table or view
+ *   (a materialized view is a table) of that name.
+ * - **Miss in every schema** → the home schema's key, so a body naming an object
+ *   that does not exist still gets a stable key rather than `undefined` —
+ *   `undefined` is reserved for "no resolver could be consulted at all".
+ *
+ * NOTE: "the way the planner answers" is exact for the body kinds that plan under
+ * {@link Database._homeSchemaPath} — view bodies, materialized-view bodies, and
+ * assertion checks (`planner/stored-body-context.ts`). A CHECK constraint or a
+ * column DEFAULT / generated expression is stricter still: it plans under
+ * `schemaAuthoredContext` (`planner/building/schema-authored-context.ts`), the
+ * owning schema and NOTHING else, so an unqualified name the owning schema does
+ * not hold is an error there rather than a fallthrough down the session path.
+ * This resolver applies the looser home-path rule to all of them, which is
+ * deliberately safe rather than exact: the two rules can only disagree when the
+ * home schema lacks the name, and such a CHECK / DEFAULT cannot be evaluated at
+ * all — so no VALID body is ever matched (or missed) differently. Tighten to a
+ * per-body-kind path only if a rename ever needs to be right about a body the
+ * planner itself rejects.
+ *
+ * SNAPSHOT DISCIPLINE — the single most likely way to get this wrong: build the
+ * snapshot (`snapshotObjectRefResolvers` / `buildObjectRefResolver`) BEFORE the
+ * statement's first catalog mutation, and pass the same instance through the whole
+ * statement. Name-set lookups answer from the snapshot, NOT the live catalog, and
+ * that is load-bearing: rename propagation runs after the catalog swap, when the
+ * old name is gone — a live lookup of a bare `t` under `[main, temp]` after
+ * `main.t` was renamed would fall through to `temp.t` and silently match (or miss)
+ * the wrong object. The pre-mutation snapshot resolves every reference the way the
+ * body planned before the statement started, which is the question the rename is
+ * asking. (The session `schema_path` option is read at resolver-derivation time;
+ * it cannot change mid-statement.)
+ */
+export declare function snapshotObjectRefResolvers(db: Database): ObjectRefResolvers;
+/**
+ * Per-home-schema {@link TableRenameTarget} factory for one `ALTER TABLE … RENAME TO`
+ * statement: binds the renamed object's identity to a pre-mutation `resolve` and a
+ * post-rename `resolveAfter` (the {@link ObjectRefResolvers.withTableRenamed} sibling),
+ * both derived per body-owning home schema. One statement builds this once and hands
+ * every walk the target for the walked body's owner, which is what lets the rewrite
+ * enforce its post-condition — a rewritten reference must still resolve to the renamed
+ * object — at the sink.
+ */
+export declare function tableRenameTargetsFor(resolvers: ObjectRefResolvers, schemaName: string, oldName: string, newName: string): (homeSchemaName: string) => TableRenameTarget;
+/**
+ * Single-home convenience over {@link snapshotObjectRefResolvers}, for callers
+ * that walk bodies of one owning schema only (the DROP guards, a store module's
+ * own-table rewrite). Same snapshot discipline: build before the statement's
+ * first catalog mutation.
+ */
+export declare function buildObjectRefResolver(db: Database, homeSchemaName: string): ResolveObjectRef;
+//# sourceMappingURL=object-ref-resolver.d.ts.map

package/dist/src/schema/object-ref-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-ref-resolver.d.ts","sourceRoot":"","sources":["../../../src/schema/object-ref-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAgB,KAAK,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEnG;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAClC,oFAAoF;IACpF,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACxD;;;;;;;OAOG;IACH,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAAC;CAC3F;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,QAAQ,GAAG,kBAAkB,CAa3E;AAqCD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACpC,SAAS,EAAE,kBAAkB,EAC7B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACb,CAAC,cAAc,EAAE,MAAM,KAAK,iBAAiB,CAiB/C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,GAAG,gBAAgB,CAE7F"}