@quereus/quereus 3.3.0 → 4.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"rename-rewriter.d.ts","sourceRoot":"","sources":["../../../src/schema/rename-rewriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,kBAAkB,CAAC;AAwC7C;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,KACd,OAAO,CAAC;AAcb,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAKT;AAmMD,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAYT;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAoBT"}
+{"version":3,"file":"rename-rewriter.d.ts","sourceRoot":"","sources":["../../../src/schema/rename-rewriter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,kBAAkB,CAAC;AA2C7C;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CACnC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,KACd,OAAO,CAAC;AAcb,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,iBAAiB,EAAE,MAAM,GACvB,OAAO,CAKT;AAuMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAaT;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,CAAC,EAAE,qBAAqB,GAC3C,OAAO,CAoBT;AA0rBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mCAAmC,CAClD,IAAI,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,EAC7B,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,qBAAqB,EAAE,qBAAqB,GAC1C,OAAO,CAkBT"}

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

@@ -18,9 +18,18 @@ function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
             const stmt = node;
             stmt.withClause?.ctes.forEach(cte => visitTableRename(cte.query, oldName, newName, defaultSchemaName, ctx));
             (stmt.columns ?? []).forEach(c => {
-                if (c.type === 'column')
+                if (c.type === 'column') {
                     visitTableRename(c.expr, oldName, newName, defaultSchemaName, ctx);
+                    // A `with inverse` assignment expr can embed a subquery naming any
+                    // table; the assignment's target names a base COLUMN, untouched by a
+                    // table rename (same as the `with defaults` clause below).
+                    (c.inverse ?? []).forEach(a => visitTableRename(a.expr, oldName, newName, defaultSchemaName, ctx));
+                }
             });
+            // `with defaults` clause: each entry's `expr` (an inserted-row default) can
+            // embed a subquery naming any table; the entry's `column` names a base
+            // COLUMN, untouched by a table rename.
+            (stmt.defaults ?? []).forEach(d => visitTableRename(d.expr, oldName, newName, defaultSchemaName, ctx));
             (stmt.from ?? []).forEach(f => visitTableRename(f, oldName, newName, defaultSchemaName, ctx));
             visitTableRename(stmt.where, oldName, newName, defaultSchemaName, ctx);
             (stmt.groupBy ?? []).forEach(g => visitTableRename(g, oldName, newName, defaultSchemaName, ctx));
@@ -37,8 +46,7 @@ function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
             const stmt = node;
             stmt.withClause?.ctes.forEach(cte => visitTableRename(cte.query, oldName, newName, defaultSchemaName, ctx));
             rewriteIdentifierIfTable(stmt.table, oldName, newName, defaultSchemaName, ctx);
-            (stmt.values ?? []).forEach(row => row.forEach(v => visitTableRename(v, oldName, newName, defaultSchemaName, ctx)));
-            visitTableRename(stmt.select, oldName, newName, defaultSchemaName, ctx);
+            visitTableRename(stmt.source, oldName, newName, defaultSchemaName, ctx);
             (stmt.upsertClauses ?? []).forEach(uc => {
                 (uc.assignments ?? []).forEach(a => visitTableRename(a.value, oldName, newName, defaultSchemaName, ctx));
                 visitTableRename(uc.where, oldName, newName, defaultSchemaName, ctx);
@@ -105,11 +113,6 @@ function visitTableRename(node, oldName, newName, defaultSchemaName, ctx) {
             visitTableRename(ss.subquery, oldName, newName, defaultSchemaName, ctx);
             break;
         }
-        case 'mutatingSubquerySource': {
-            const ms = node;
-            visitTableRename(ms.stmt, oldName, newName, defaultSchemaName, ctx);
-            break;
-        }
         case 'binary': {
             const e = node;
             visitTableRename(e.left, oldName, newName, defaultSchemaName, ctx);
@@ -194,7 +197,23 @@ function rewriteIdentifierIfTable(id, oldName, newName, defaultSchemaName, ctx)
 // ──────────────────────────────────────────────────────────────────────
 // Column rename
 // ──────────────────────────────────────────────────────────────────────
-export function renameColumnInAst(node, tableName, oldColName, newColName, defaultSchemaName) {
+/**
+ * Rewrite column references inside a full statement/expression AST, resolving
+ * unqualified refs against the FROM scopes the walk descends (no implicit seed,
+ * unlike {@link renameColumnInCheckExpression}). The walk descends a select
+ * body's trailing `with defaults (…)` clause ({@link AST.SelectStmt.defaults}),
+ * whose entry exprs evaluate in the body's FROM scope.
+ *
+ * When `resolveColumnInSource` is supplied, the scope walk consults it at each
+ * inner FROM frame so an unqualified ref that legitimately binds to a like-named
+ * column on a subquery's own FROM source is NOT false-captured by an enclosing
+ * binding (e.g. a `with defaults` expr `cap + (select max(cap) from lim)` under
+ * a `t.cap` rename must leave the inner `lim.cap` untouched). The same callback
+ * infrastructure backs {@link renameColumnInCheckExpression}; both the forward
+ * propagation (live schema lookup) and the differ's inverse reconcile
+ * (declared-side resolver) pass it so the two stay in parity.
+ */
+export function renameColumnInAst(node, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
     if (!node)
         return false;
     const state = {
@@ -204,6 +223,7 @@ export function renameColumnInAst(node, tableName, oldColName, newColName, defau
         defaultSchema: defaultSchemaName.toLowerCase(),
         scopeStack: [],
         changed: false,
+        resolveColumnInSource,
     };
     visitColumnRename(node, state);
     return state.changed;
@@ -226,9 +246,8 @@ export function renameColumnInAst(node, tableName, oldColName, newColName, defau
  *
  * Limitation: aliased subquery / function-source / CTE-projection inner
  * sources are not asked (the rewriter would need recursive column-set
- * inference on their bodies). Same latent issue exists in
- * `renameColumnInAst` for non-CHECK paths — file a follow-up if it
- * surfaces; the callback infrastructure is already in place.
+ * inference on their bodies). `renameColumnInAst` shares the same callback
+ * (passed by the view-body callers) and the same limitation.
  */
 export function renameColumnInCheckExpression(expr, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
     if (!expr)
@@ -323,7 +342,6 @@ function collectFromBindings(item, state, frame) {
             break;
         }
         case 'subquerySource':
-        case 'mutatingSubquerySource':
         case 'functionSource':
             // Aliased; these don't contribute the renamed underlying table for
             // unqualified resolution purposes.
@@ -425,10 +443,93 @@ function visitColumnRename(node, state) {
                 const frame = buildScopeFrame(stmt.from, state);
                 state.scopeStack.push(frame);
                 try {
+                    // Capture pre-rewrite output names of UNALIASED bare projections: a
+                    // rename that rewrites one shifts the select's OUTPUT name with it, so
+                    // any `new.<old>` refs in sibling `with inverse` exprs must follow
+                    // (a `new.` ref is by view-output name; aliased / computed projections
+                    // keep their output name, so the body rewrite alone covers them).
+                    const preOutputNames = (stmt.columns ?? []).map(c => c.type === 'column' && !c.alias && c.expr.type === 'column' ? c.expr.name : undefined);
                     (stmt.columns ?? []).forEach(c => {
                         if (c.type === 'column')
                             visitColumnRename(c.expr, state);
                     });
+                    // `with inverse` clauses: the assignment target is a bare base-column
+                    // name resolving against this select's FROM — exactly an unqualified
+                    // body ref, so it rides the same scope-aware walk via a synthetic
+                    // probe (the `with defaults` clause below uses the same pattern); the
+                    // assignment expr rewrites like any body expression.
+                    (stmt.columns ?? []).forEach(c => {
+                        if (c.type !== 'column' || !c.inverse?.length)
+                            return;
+                        c.inverse.forEach(a => {
+                            const probe = { type: 'column', name: a.column };
+                            visitColumnRename(probe, state);
+                            if (probe.name !== a.column) {
+                                a.column = probe.name;
+                                state.changed = true;
+                            }
+                            visitColumnRename(a.expr, state);
+                        });
+                    });
+                    // `with defaults` clause: each entry's `column` is a bare base-column
+                    // name of this select's FROM (a projected-away base column), so it
+                    // rides the same scope-aware synthetic probe as a `with inverse`
+                    // target; the entry's `expr` evaluates in the inserted-row context of
+                    // the FROM table — exactly the FROM frame already on the scope stack —
+                    // so it rewrites like any body expression (an inner subquery in the
+                    // expr pushes its own frame and disambiguates a like-named column).
+                    (stmt.defaults ?? []).forEach(d => {
+                        const probe = { type: 'column', name: d.column };
+                        visitColumnRename(probe, state);
+                        if (probe.name !== d.column) {
+                            d.column = probe.name;
+                            state.changed = true;
+                        }
+                        visitColumnRename(d.expr, state);
+                    });
+                    const outputRenames = new Map();
+                    (stmt.columns ?? []).forEach((c, i) => {
+                        const before = preOutputNames[i];
+                        if (before !== undefined && c.type === 'column' && c.expr.type === 'column' && c.expr.name !== before) {
+                            outputRenames.set(before.toLowerCase(), c.expr.name);
+                        }
+                    });
+                    // A star projection covering the renamed table exposes the old column
+                    // name as an OUTPUT name too — the rename shifts it exactly like an
+                    // unaliased bare projection, so sibling `new.<old>` refs must follow.
+                    // Skipped when an explicit projection still exposes the old name
+                    // (first-occurrence resolution keeps `new.<old>` bound to it).
+                    const hasInverseClauses = (stmt.columns ?? []).some(c => c.type === 'column' && !!c.inverse?.length);
+                    if (hasInverseClauses && !outputRenames.has(state.oldCol)) {
+                        const starCoversRenamed = (stmt.columns ?? []).some(c => {
+                            if (c.type !== 'all')
+                                return false;
+                            const boundToRenamed = frame.unaliased.has(state.tableName)
+                                || [...frame.aliasMap.values()].includes(state.tableName);
+                            if (c.table === undefined)
+                                return boundToRenamed;
+                            const q = c.table.toLowerCase();
+                            return frame.aliasMap.get(q) === state.tableName
+                                || (q === state.tableName && frame.unaliased.has(state.tableName));
+                        });
+                        const oldStillExposed = (stmt.columns ?? []).some(c => c.type === 'column'
+                            && (c.alias
+                                ? c.alias.toLowerCase() === state.oldCol
+                                : c.expr.type === 'column' && c.expr.name.toLowerCase() === state.oldCol));
+                        if (starCoversRenamed && !oldStillExposed) {
+                            outputRenames.set(state.oldCol, state.newCol);
+                        }
+                    }
+                    if (outputRenames.size > 0) {
+                        (stmt.columns ?? []).forEach(c => {
+                            if (c.type !== 'column' || !c.inverse?.length)
+                                return;
+                            c.inverse.forEach(a => {
+                                if (renameNewQualifiedRefs(a.expr, outputRenames))
+                                    state.changed = true;
+                            });
+                        });
+                    }
                     (stmt.from ?? []).forEach(f => visitColumnRename(f, state));
                     visitColumnRename(stmt.where, state);
                     (stmt.groupBy ?? []).forEach(g => visitColumnRename(g, state));
@@ -485,8 +586,7 @@ function visitColumnRename(node, state) {
                         }
                     });
                 }
-                (stmt.values ?? []).forEach(row => row.forEach(v => visitColumnRename(v, state)));
-                visitColumnRename(stmt.select, state);
+                visitColumnRename(stmt.source, state);
                 (stmt.upsertClauses ?? []).forEach(uc => {
                     (uc.assignments ?? []).forEach(a => visitColumnRename(a.value, state));
                     visitColumnRename(uc.where, state);
@@ -587,10 +687,6 @@ function visitColumnRename(node, state) {
             visitColumnRename(node.subquery, state);
             break;
         }
-        case 'mutatingSubquerySource': {
-            visitColumnRename(node.stmt, state);
-            break;
-        }
         case 'binary': {
             const e = node;
             visitColumnRename(e.left, state);
@@ -790,4 +886,301 @@ function isResultColumnExposure(col, bodyFrame, state) {
     }
     return bodyFrame.aliasMap.get(qualLower) === state.tableName;
 }
+/**
+ * Rename `new.<old>` → `new.<new>` references inside a `with inverse` assignment
+ * expression, for output columns whose name shifted under a column rename (an
+ * unaliased bare projection of the renamed column). Uniform, depth-blind in-place
+ * walk over the expression's object graph: the `new.` qualifier alone decides (it
+ * is the reserved written-row namespace no FROM source legitimately shadows), so
+ * no scope tracking applies — narrower and simpler than the scope-aware walkers
+ * above. Returns whether any reference was rewritten.
+ */
+function renameNewQualifiedRefs(expr, renames) {
+    let changed = false;
+    const visit = (v) => {
+        if (Array.isArray(v)) {
+            v.forEach(visit);
+            return;
+        }
+        if (v === null || typeof v !== 'object')
+            return;
+        const n = v;
+        if (n.type === 'column' && typeof n.table === 'string' && n.table.toLowerCase() === 'new'
+            && n.schema === undefined && typeof n.name === 'string') {
+            const to = renames.get(n.name.toLowerCase());
+            if (to !== undefined && to !== n.name) {
+                n.name = to;
+                changed = true;
+            }
+        }
+        for (const key of Object.keys(n)) {
+            if (key === 'loc')
+                continue;
+            visit(n[key]);
+        }
+    };
+    visit(expr);
+    return changed;
+}
+/**
+ * Strip table-qualified self-references in a CHECK expression down to the
+ * unqualified form: `check (t.qty > 0)` (or `main.t.qty`) becomes
+ * `check (qty > 0)` so the constraint planner's row-context scope — which
+ * registers bare / `NEW.` / `OLD.` column names only — can resolve it.
+ *
+ * Deliberately NOT done by seeding `<table>.<col>` keys into the constraint
+ * scope: that scope is an ancestor of every subquery planned inside the
+ * CHECK, and a join peer's parent-chain fallback (`MultiScope` first-match
+ * on qualified names) would resolve an inner relation's qualified columns
+ * against the outer row context (observed with lens view expansions).
+ *
+ * The walk mirrors SQL shadowing rules: a qualifier rebound by an inner
+ * FROM (same table re-selected, an alias, or a CTE) is left untouched. A
+ * self-qualified ref inside a subquery is stripped only when no
+ * intervening FROM frame could capture the resulting unqualified name —
+ * real-table sources are asked via `resolveColumnInSource`; subquery /
+ * function / CTE sources are unanalyzable and conservatively block the
+ * strip (the ref then stays qualified and fails to resolve exactly as it
+ * did before this rewrite existed). CTE and derived-table bodies cannot
+ * correlate to the constraint row, so stripping is suppressed inside them.
+ *
+ * Mutates `expr` in place (callers pass a clone of the stored constraint
+ * AST) and returns whether anything was rewritten.
+ */
+export function stripSelfQualifierInCheckExpression(expr, tableName, defaultSchemaName, resolveColumnInSource) {
+    if (!expr)
+        return false;
+    const state = {
+        tableName: tableName.toLowerCase(),
+        defaultSchema: defaultSchemaName.toLowerCase(),
+        resolve: resolveColumnInSource,
+        stack: [],
+        changed: false,
+    };
+    const seed = emptyStripFrame();
+    seed.bound.add(state.tableName);
+    state.stack.push(seed);
+    try {
+        visitStrip(expr, state);
+    }
+    finally {
+        state.stack.pop();
+    }
+    return state.changed;
+}
+function emptyStripFrame() {
+    return { bound: new Set(), realSources: [], hasOpaque: false, cteNames: new Set() };
+}
+function isStripCteName(state, name) {
+    for (const frame of state.stack) {
+        if (frame.cteNames.has(name))
+            return true;
+    }
+    return false;
+}
+function collectStripBindings(item, state, frame) {
+    switch (item.type) {
+        case 'table': {
+            const ts = item;
+            const name = ts.table.name.toLowerCase();
+            frame.bound.add(ts.alias ? ts.alias.toLowerCase() : name);
+            if (ts.table.schema === undefined && isStripCteName(state, name)) {
+                // CTE source — column set not analyzed.
+                frame.hasOpaque = true;
+            }
+            else {
+                frame.realSources.push({ schema: (ts.table.schema ?? state.defaultSchema).toLowerCase(), name });
+            }
+            break;
+        }
+        case 'join': {
+            const join = item;
+            collectStripBindings(join.left, state, frame);
+            collectStripBindings(join.right, state, frame);
+            break;
+        }
+        case 'subquerySource': {
+            frame.bound.add(item.alias.toLowerCase());
+            frame.hasOpaque = true;
+            break;
+        }
+        case 'functionSource': {
+            const fs = item;
+            if (fs.alias)
+                frame.bound.add(fs.alias.toLowerCase());
+            frame.hasOpaque = true;
+            break;
+        }
+    }
+}
+/** Visit a node in a context where stripping must not occur (CTE / derived-table bodies). */
+function visitStripBarrier(node, state) {
+    const barrier = emptyStripFrame();
+    barrier.hasOpaque = true;
+    state.stack.push(barrier);
+    try {
+        visitStrip(node, state);
+    }
+    finally {
+        state.stack.pop();
+    }
+}
+function visitStrip(node, state) {
+    if (!node)
+        return;
+    switch (node.type) {
+        case 'select': {
+            const stmt = node;
+            const withFrame = emptyStripFrame();
+            state.stack.push(withFrame);
+            try {
+                for (const cte of stmt.withClause?.ctes ?? []) {
+                    // A CTE body cannot correlate to the constraint row — no stripping inside.
+                    visitStripBarrier(cte.query, state);
+                    withFrame.cteNames.add(cte.name.toLowerCase());
+                }
+                const frame = buildStripFrame(stmt.from, state);
+                state.stack.push(frame);
+                try {
+                    (stmt.columns ?? []).forEach(c => {
+                        if (c.type === 'column')
+                            visitStrip(c.expr, state);
+                    });
+                    (stmt.from ?? []).forEach(f => visitStrip(f, state));
+                    visitStrip(stmt.where, state);
+                    (stmt.groupBy ?? []).forEach(g => visitStrip(g, state));
+                    visitStrip(stmt.having, state);
+                    (stmt.orderBy ?? []).forEach(o => visitStrip(o.expr, state));
+                    visitStrip(stmt.limit, state);
+                    visitStrip(stmt.offset, state);
+                    visitStrip(stmt.union, state);
+                    if (stmt.compound)
+                        visitStrip(stmt.compound.select, state);
+                }
+                finally {
+                    state.stack.pop();
+                }
+            }
+            finally {
+                state.stack.pop();
+            }
+            break;
+        }
+        case 'values': {
+            node.values.forEach(row => row.forEach(v => visitStrip(v, state)));
+            break;
+        }
+        case 'join': {
+            const join = node;
+            visitStrip(join.left, state);
+            visitStrip(join.right, state);
+            visitStrip(join.condition, state);
+            break;
+        }
+        case 'functionSource': {
+            node.args.forEach(a => visitStrip(a, state));
+            break;
+        }
+        case 'subquerySource': {
+            // A derived table cannot correlate to the constraint row — no stripping inside.
+            visitStripBarrier(node.subquery, state);
+            break;
+        }
+        case 'binary': {
+            const e = node;
+            visitStrip(e.left, state);
+            visitStrip(e.right, state);
+            break;
+        }
+        case 'unary':
+        case 'cast':
+        case 'collate':
+            visitStrip(node.expr, state);
+            break;
+        case 'function':
+            node.args.forEach(a => visitStrip(a, state));
+            break;
+        case 'subquery':
+            visitStrip(node.query, state);
+            break;
+        case 'windowFunction': {
+            const wf = node;
+            visitStrip(wf.function, state);
+            visitStrip(wf.window, state);
+            break;
+        }
+        case 'windowDefinition': {
+            const wd = node;
+            (wd.partitionBy ?? []).forEach(p => visitStrip(p, state));
+            (wd.orderBy ?? []).forEach(o => visitStrip(o.expr, state));
+            break;
+        }
+        case 'case': {
+            const ce = node;
+            visitStrip(ce.baseExpr, state);
+            ce.whenThenClauses.forEach(wt => {
+                visitStrip(wt.when, state);
+                visitStrip(wt.then, state);
+            });
+            visitStrip(ce.elseExpr, state);
+            break;
+        }
+        case 'in': {
+            const ie = node;
+            visitStrip(ie.expr, state);
+            (ie.values ?? []).forEach(v => visitStrip(v, state));
+            visitStrip(ie.subquery, state);
+            break;
+        }
+        case 'exists':
+            visitStrip(node.subquery, state);
+            break;
+        case 'between': {
+            const be = node;
+            visitStrip(be.expr, state);
+            visitStrip(be.lower, state);
+            visitStrip(be.upper, state);
+            break;
+        }
+        case 'column': {
+            stripColumnQualifier(node, state);
+            break;
+        }
+        default:
+            break;
+    }
+}
+function buildStripFrame(from, state) {
+    const frame = emptyStripFrame();
+    (from ?? []).forEach(item => collectStripBindings(item, state, frame));
+    return frame;
+}
+function stripColumnQualifier(col, state) {
+    if (!col.table)
+        return;
+    const qualifier = col.table.toLowerCase();
+    // Innermost-first: a qualifier rebound by any inner FROM resolves there.
+    for (let i = state.stack.length - 1; i >= 1; i--) {
+        if (state.stack[i].bound.has(qualifier))
+            return;
+    }
+    if (qualifier !== state.tableName)
+        return;
+    if (!schemaMatches(col.schema, state.defaultSchema))
+        return;
+    // Strip only when no intervening frame could capture the unqualified name.
+    const colLower = col.name.toLowerCase();
+    for (let i = 1; i < state.stack.length; i++) {
+        const frame = state.stack[i];
+        if (frame.hasOpaque)
+            return;
+        for (const src of frame.realSources) {
+            if (state.resolve(src.schema, src.name, colLower))
+                return;
+        }
+    }
+    col.table = undefined;
+    col.schema = undefined;
+    state.changed = true;
+}
 //# sourceMappingURL=rename-rewriter.js.map