@quereus/quereus 2.9.0 → 3.0.1

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

@@ -208,33 +208,118 @@ export function renameColumnInAst(node, tableName, oldColName, newColName, defau
     visitColumnRename(node, state);
     return state.changed;
 }
-function buildScopeFrame(from, defaultSchema) {
-    const frame = { unaliased: new Set(), aliasMap: new Map() };
+/**
+ * Rewrite a column reference inside a CHECK expression. Unlike
+ * `renameColumnInAst`, this entry point seeds the scope stack with an
+ * implicit unaliased binding to `tableName` so top-level unqualified
+ * `ColumnExpr` nodes resolve to the owning table. CHECK expressions
+ * cannot reference other tables at top level, so the implicit binding
+ * is safe there.
+ *
+ * When `resolveColumnInSource` is supplied, the scope walk consults it at
+ * each inner FROM frame: if any real-table source in that frame exposes
+ * `oldColName`, the unqualified ref binds inside the subquery and the
+ * walk stops before reaching the seed. This stops the rewriter from
+ * false-positively rewriting an inner unqualified ref that legitimately
+ * binds to a like-named column on the subquery's FROM (e.g.
+ * `check ((select min(v) from u) > 0)` when `u` also has a `v` column).
+ *
+ * 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.
+ */
+export function renameColumnInCheckExpression(expr, tableName, oldColName, newColName, defaultSchemaName, resolveColumnInSource) {
+    if (!expr)
+        return false;
+    const state = {
+        tableName: tableName.toLowerCase(),
+        oldCol: oldColName.toLowerCase(),
+        newCol: newColName,
+        defaultSchema: defaultSchemaName.toLowerCase(),
+        scopeStack: [],
+        changed: false,
+        resolveColumnInSource,
+    };
+    const frame = emptyFrame();
+    frame.unaliased.add(state.tableName);
+    state.scopeStack.push(frame);
+    try {
+        visitColumnRename(expr, state);
+    }
+    finally {
+        state.scopeStack.pop();
+    }
+    return state.changed;
+}
+function emptyFrame() {
+    return {
+        unaliased: new Set(),
+        aliasMap: new Map(),
+        ctesExposingRenamed: new Set(),
+        ctesInScope: new Set(),
+        ctesShadowingSource: new Set(),
+        realSources: [],
+    };
+}
+function buildScopeFrame(from, state) {
+    const frame = emptyFrame();
     if (!from)
         return frame;
     for (const item of from) {
-        collectFromBindings(item, defaultSchema, frame);
+        collectFromBindings(item, state, frame);
     }
     return frame;
 }
-function collectFromBindings(item, defaultSchema, frame) {
+function collectFromBindings(item, state, frame) {
     switch (item.type) {
         case 'table': {
             const ts = item;
-            const schema = (ts.table.schema ?? defaultSchema).toLowerCase();
             const name = ts.table.name.toLowerCase();
+            // Unqualified reference to a CTE in scope — the CTE shadows any
+            // same-named real table. Whether it re-exposes the renamed column
+            // determines whether unqualified refs against this source rewrite.
+            if (ts.table.schema === undefined && isCteInScope(state, name)) {
+                if (isCteExposingInScope(state, name)) {
+                    if (ts.alias) {
+                        frame.aliasMap.set(ts.alias.toLowerCase(), state.tableName);
+                    }
+                    else {
+                        frame.unaliased.add(state.tableName);
+                        // The CTE name acts as an implicit qualifier for refs like "a.k".
+                        frame.aliasMap.set(name, state.tableName);
+                    }
+                }
+                else {
+                    // Shadowing-but-not-exposing: the source binds to the CTE
+                    // row source, not the renamed real table. Record the
+                    // qualifier (alias if present, otherwise the source name)
+                    // so qualified column refs against it don't short-circuit
+                    // to the renamed table.
+                    frame.ctesShadowingSource.add(ts.alias ? ts.alias.toLowerCase() : name);
+                }
+                // Shadowing-but-not-exposing: do not bind as the renamed table.
+                break;
+            }
+            const schemaLower = (ts.table.schema ?? state.defaultSchema).toLowerCase();
             if (ts.alias) {
                 frame.aliasMap.set(ts.alias.toLowerCase(), name);
             }
-            else if (schema === defaultSchema.toLowerCase() || ts.table.schema === undefined) {
+            else if (schemaLower === state.defaultSchema || ts.table.schema === undefined) {
                 frame.unaliased.add(name);
             }
+            // Record as a real-table source so the unqualified-scope walk can
+            // ask whether this source exposes the renamed column. Both aliased
+            // and unaliased real sources are recorded — asking "does u expose
+            // col v" is the same question regardless of any alias.
+            frame.realSources.push({ schema: schemaLower, name });
             break;
         }
         case 'join': {
             const join = item;
-            collectFromBindings(join.left, defaultSchema, frame);
-            collectFromBindings(join.right, defaultSchema, frame);
+            collectFromBindings(join.left, state, frame);
+            collectFromBindings(join.right, state, frame);
             break;
         }
         case 'subquerySource':
@@ -245,46 +330,119 @@ function collectFromBindings(item, defaultSchema, frame) {
             break;
     }
 }
-function isTableInUnaliasedScope(state) {
+/**
+ * Innermost-first walk: an inner non-exposing same-name CTE shadows an
+ * outer exposing one, so a `ctesInScope` hit without a matching
+ * `ctesExposingRenamed` entry wins. `isCteInScope` (below) intentionally
+ * stays OR-shaped — it only gates "is this source a CTE rather than a
+ * real table?", a question for which any enclosing CTE suffices.
+ */
+function isCteExposingInScope(state, name) {
+    for (let i = state.scopeStack.length - 1; i >= 0; i--) {
+        const frame = state.scopeStack[i];
+        if (frame.ctesExposingRenamed.has(name))
+            return true;
+        if (frame.ctesInScope.has(name))
+            return false;
+    }
+    return false;
+}
+function isCteInScope(state, name) {
     for (const frame of state.scopeStack) {
+        if (frame.ctesInScope.has(name))
+            return true;
+    }
+    return false;
+}
+/**
+ * Innermost-first walk: a closer same-name CTE shadows an outer unaliased
+ * binding to the renamed real table. When a `resolveColumnInSource`
+ * callback is configured, also stop at any inner FROM frame whose real
+ * sources expose `oldCol` — the unqualified ref binds inside that frame
+ * and an outer seed binding must not capture it.
+ */
+function isTableInUnaliasedScope(state) {
+    for (let i = state.scopeStack.length - 1; i >= 0; i--) {
+        const frame = state.scopeStack[i];
+        if (frame.ctesInScope.has(state.tableName))
+            return false;
+        if (state.resolveColumnInSource && frame.realSources.length > 0) {
+            for (const src of frame.realSources) {
+                // The renamed table itself trivially exposes oldCol; defer to
+                // the existing `unaliased` check below so we don't
+                // double-capture.
+                if (src.name === state.tableName && src.schema === state.defaultSchema)
+                    continue;
+                if (state.resolveColumnInSource(src.schema, src.name, state.oldCol))
+                    return false;
+            }
+        }
         if (frame.unaliased.has(state.tableName))
             return true;
     }
     return false;
 }
+/**
+ * Innermost-first walk: a closer alias binding wins over an outer one
+ * (standard SQL alias shadowing).
+ */
 function aliasResolvesToTable(state, alias) {
     const aliasLower = alias.toLowerCase();
-    for (const frame of state.scopeStack) {
-        const target = frame.aliasMap.get(aliasLower);
+    for (let i = state.scopeStack.length - 1; i >= 0; i--) {
+        const target = state.scopeStack[i].aliasMap.get(aliasLower);
         if (target !== undefined)
             return target === state.tableName;
     }
     return false;
 }
+/**
+ * Walk the scope stack innermost-first to decide whether a qualifier
+ * resolves to a non-exposing shadowing CTE rather than the renamed real
+ * table. A closer rebind to the real table (via unaliased binding or alias)
+ * wins over an outer shadowing entry.
+ */
+function isQualifierShadowedInScope(state, qualifier) {
+    for (let i = state.scopeStack.length - 1; i >= 0; i--) {
+        const frame = state.scopeStack[i];
+        if (frame.ctesShadowingSource.has(qualifier))
+            return true;
+        // Closer rebind to the real table wins → not shadowed at this point.
+        if (frame.aliasMap.get(qualifier) === state.tableName)
+            return false;
+        if (qualifier === state.tableName && frame.unaliased.has(state.tableName))
+            return false;
+    }
+    return false;
+}
 function visitColumnRename(node, state) {
     if (!node)
         return;
     switch (node.type) {
         case 'select': {
             const stmt = node;
-            stmt.withClause?.ctes.forEach(cte => visitColumnRename(cte.query, state));
-            const frame = buildScopeFrame(stmt.from, state.defaultSchema);
-            state.scopeStack.push(frame);
+            pushWithFrame(stmt.withClause, state);
             try {
-                (stmt.columns ?? []).forEach(c => {
-                    if (c.type === 'column')
-                        visitColumnRename(c.expr, state);
-                });
-                (stmt.from ?? []).forEach(f => visitColumnRename(f, state));
-                visitColumnRename(stmt.where, state);
-                (stmt.groupBy ?? []).forEach(g => visitColumnRename(g, state));
-                visitColumnRename(stmt.having, state);
-                (stmt.orderBy ?? []).forEach(o => visitColumnRename(o.expr, state));
-                visitColumnRename(stmt.limit, state);
-                visitColumnRename(stmt.offset, state);
-                visitColumnRename(stmt.union, state);
-                if (stmt.compound)
-                    visitColumnRename(stmt.compound.select, state);
+                const frame = buildScopeFrame(stmt.from, state);
+                state.scopeStack.push(frame);
+                try {
+                    (stmt.columns ?? []).forEach(c => {
+                        if (c.type === 'column')
+                            visitColumnRename(c.expr, state);
+                    });
+                    (stmt.from ?? []).forEach(f => visitColumnRename(f, state));
+                    visitColumnRename(stmt.where, state);
+                    (stmt.groupBy ?? []).forEach(g => visitColumnRename(g, state));
+                    visitColumnRename(stmt.having, state);
+                    (stmt.orderBy ?? []).forEach(o => visitColumnRename(o.expr, state));
+                    visitColumnRename(stmt.limit, state);
+                    visitColumnRename(stmt.offset, state);
+                    visitColumnRename(stmt.union, state);
+                    if (stmt.compound)
+                        visitColumnRename(stmt.compound.select, state);
+                }
+                finally {
+                    state.scopeStack.pop();
+                }
             }
             finally {
                 state.scopeStack.pop();
@@ -293,80 +451,90 @@ function visitColumnRename(node, state) {
         }
         case 'insert': {
             const stmt = node;
-            stmt.withClause?.ctes.forEach(cte => visitColumnRename(cte.query, state));
-            const targetIsRenamed = eq(stmt.table.name, state.tableName) &&
-                (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema));
-            if (targetIsRenamed && stmt.columns) {
-                stmt.columns = stmt.columns.map(c => {
-                    if (c.toLowerCase() === state.oldCol) {
-                        state.changed = true;
-                        return state.newCol;
-                    }
-                    return c;
-                });
-            }
-            if (targetIsRenamed) {
-                (stmt.upsertClauses ?? []).forEach(uc => {
-                    if (uc.conflictTarget) {
-                        uc.conflictTarget = uc.conflictTarget.map(c => {
-                            if (c.toLowerCase() === state.oldCol) {
-                                state.changed = true;
-                                return state.newCol;
-                            }
-                            return c;
-                        });
-                    }
-                    if (uc.assignments) {
-                        for (const a of uc.assignments) {
-                            if (a.column.toLowerCase() === state.oldCol) {
-                                a.column = state.newCol;
-                                state.changed = true;
+            pushWithFrame(stmt.withClause, state);
+            try {
+                const targetIsRenamed = eq(stmt.table.name, state.tableName) &&
+                    (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema));
+                if (targetIsRenamed && stmt.columns) {
+                    stmt.columns = stmt.columns.map(c => {
+                        if (c.toLowerCase() === state.oldCol) {
+                            state.changed = true;
+                            return state.newCol;
+                        }
+                        return c;
+                    });
+                }
+                if (targetIsRenamed) {
+                    (stmt.upsertClauses ?? []).forEach(uc => {
+                        if (uc.conflictTarget) {
+                            uc.conflictTarget = uc.conflictTarget.map(c => {
+                                if (c.toLowerCase() === state.oldCol) {
+                                    state.changed = true;
+                                    return state.newCol;
+                                }
+                                return c;
+                            });
+                        }
+                        if (uc.assignments) {
+                            for (const a of uc.assignments) {
+                                if (a.column.toLowerCase() === state.oldCol) {
+                                    a.column = state.newCol;
+                                    state.changed = true;
+                                }
                             }
                         }
-                    }
+                    });
+                }
+                (stmt.values ?? []).forEach(row => row.forEach(v => visitColumnRename(v, state)));
+                visitColumnRename(stmt.select, state);
+                (stmt.upsertClauses ?? []).forEach(uc => {
+                    (uc.assignments ?? []).forEach(a => visitColumnRename(a.value, state));
+                    visitColumnRename(uc.where, state);
                 });
+                (stmt.returning ?? []).forEach(r => {
+                    if (r.type === 'column')
+                        visitColumnRename(r.expr, state);
+                });
+                (stmt.contextValues ?? []).forEach(cv => visitColumnRename(cv.value, state));
+            }
+            finally {
+                state.scopeStack.pop();
             }
-            (stmt.values ?? []).forEach(row => row.forEach(v => visitColumnRename(v, state)));
-            visitColumnRename(stmt.select, state);
-            (stmt.upsertClauses ?? []).forEach(uc => {
-                (uc.assignments ?? []).forEach(a => visitColumnRename(a.value, state));
-                visitColumnRename(uc.where, state);
-            });
-            (stmt.returning ?? []).forEach(r => {
-                if (r.type === 'column')
-                    visitColumnRename(r.expr, state);
-            });
-            (stmt.contextValues ?? []).forEach(cv => visitColumnRename(cv.value, state));
             break;
         }
         case 'update': {
             const stmt = node;
-            stmt.withClause?.ctes.forEach(cte => visitColumnRename(cte.query, state));
-            const targetIsRenamed = eq(stmt.table.name, state.tableName) &&
-                (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema));
-            if (targetIsRenamed) {
-                for (const a of stmt.assignments) {
-                    if (a.column.toLowerCase() === state.oldCol) {
-                        a.column = state.newCol;
-                        state.changed = true;
+            pushWithFrame(stmt.withClause, state);
+            try {
+                const targetIsRenamed = eq(stmt.table.name, state.tableName) &&
+                    (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema));
+                if (targetIsRenamed) {
+                    for (const a of stmt.assignments) {
+                        if (a.column.toLowerCase() === state.oldCol) {
+                            a.column = state.newCol;
+                            state.changed = true;
+                        }
                     }
                 }
-            }
-            // Push a scope frame so unqualified column refs in WHERE/RETURNING
-            // resolve against the update target.
-            const frame = { unaliased: new Set(), aliasMap: new Map() };
-            if (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema)) {
-                frame.unaliased.add(stmt.table.name.toLowerCase());
-            }
-            state.scopeStack.push(frame);
-            try {
-                stmt.assignments.forEach(a => visitColumnRename(a.value, state));
-                visitColumnRename(stmt.where, state);
-                (stmt.returning ?? []).forEach(r => {
-                    if (r.type === 'column')
-                        visitColumnRename(r.expr, state);
-                });
-                (stmt.contextValues ?? []).forEach(cv => visitColumnRename(cv.value, state));
+                // Push a scope frame so unqualified column refs in WHERE/RETURNING
+                // resolve against the update target.
+                const frame = emptyFrame();
+                if (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema)) {
+                    frame.unaliased.add(stmt.table.name.toLowerCase());
+                }
+                state.scopeStack.push(frame);
+                try {
+                    stmt.assignments.forEach(a => visitColumnRename(a.value, state));
+                    visitColumnRename(stmt.where, state);
+                    (stmt.returning ?? []).forEach(r => {
+                        if (r.type === 'column')
+                            visitColumnRename(r.expr, state);
+                    });
+                    (stmt.contextValues ?? []).forEach(cv => visitColumnRename(cv.value, state));
+                }
+                finally {
+                    state.scopeStack.pop();
+                }
             }
             finally {
                 state.scopeStack.pop();
@@ -375,19 +543,24 @@ function visitColumnRename(node, state) {
         }
         case 'delete': {
             const stmt = node;
-            stmt.withClause?.ctes.forEach(cte => visitColumnRename(cte.query, state));
-            const frame = { unaliased: new Set(), aliasMap: new Map() };
-            if (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema)) {
-                frame.unaliased.add(stmt.table.name.toLowerCase());
-            }
-            state.scopeStack.push(frame);
+            pushWithFrame(stmt.withClause, state);
             try {
-                visitColumnRename(stmt.where, state);
-                (stmt.returning ?? []).forEach(r => {
-                    if (r.type === 'column')
-                        visitColumnRename(r.expr, state);
-                });
-                (stmt.contextValues ?? []).forEach(cv => visitColumnRename(cv.value, state));
+                const frame = emptyFrame();
+                if (stmt.table.schema === undefined || eq(stmt.table.schema, state.defaultSchema)) {
+                    frame.unaliased.add(stmt.table.name.toLowerCase());
+                }
+                state.scopeStack.push(frame);
+                try {
+                    visitColumnRename(stmt.where, state);
+                    (stmt.returning ?? []).forEach(r => {
+                        if (r.type === 'column')
+                            visitColumnRename(r.expr, state);
+                    });
+                    (stmt.contextValues ?? []).forEach(cv => visitColumnRename(cv.value, state));
+                }
+                finally {
+                    state.scopeStack.pop();
+                }
             }
             finally {
                 state.scopeStack.pop();
@@ -481,7 +654,8 @@ function visitColumnRename(node, state) {
             if (col.table) {
                 const qualifierLower = col.table.toLowerCase();
                 const directHit = qualifierLower === state.tableName &&
-                    (col.schema === undefined || eq(col.schema, state.defaultSchema));
+                    (col.schema === undefined || eq(col.schema, state.defaultSchema)) &&
+                    !isQualifierShadowedInScope(state, qualifierLower);
                 const viaAlias = aliasResolvesToTable(state, col.table);
                 if (directHit || viaAlias) {
                     col.name = state.newCol;
@@ -503,4 +677,117 @@ function visitColumnRename(node, state) {
             break;
     }
 }
+/**
+ * Push a with-frame that registers any CTEs in the given WITH clause that
+ * re-expose the renamed column. CTEs are visited in declaration order so
+ * later CTEs see earlier ones in the same WITH.
+ *
+ * For `with recursive`, each CTE's name is registered in `ctesInScope`
+ * *before* its body is visited so self-references inside the recursive step
+ * resolve to the CTE (not to a same-named renamed table). For non-recursive
+ * WITH, the name is registered only after the body — a non-recursive body
+ * must not see itself.
+ *
+ * Caller is responsible for popping the frame via `state.scopeStack.pop()`.
+ */
+function pushWithFrame(withClause, state) {
+    const frame = emptyFrame();
+    state.scopeStack.push(frame);
+    if (withClause) {
+        for (const cte of withClause.ctes) {
+            const nameLower = cte.name.toLowerCase();
+            if (withClause.recursive) {
+                frame.ctesInScope.add(nameLower);
+            }
+            visitColumnRename(cte.query, state);
+            if (cteExposesRenamedColumn(cte, state)) {
+                frame.ctesExposingRenamed.add(nameLower);
+            }
+            frame.ctesInScope.add(nameLower);
+        }
+    }
+    return frame;
+}
+/**
+ * Rebuild a with-frame's `ctesExposingRenamed` set for exposure analysis
+ * without re-visiting CTE bodies (they were already visited).
+ */
+function analyzeWithFrame(withClause, state) {
+    const frame = emptyFrame();
+    if (!withClause)
+        return frame;
+    state.scopeStack.push(frame);
+    try {
+        for (const cte of withClause.ctes) {
+            if (cteExposesRenamedColumn(cte, state)) {
+                frame.ctesExposingRenamed.add(cte.name.toLowerCase());
+            }
+            frame.ctesInScope.add(cte.name.toLowerCase());
+        }
+    }
+    finally {
+        state.scopeStack.pop();
+    }
+    return frame;
+}
+/**
+ * Determine whether a CTE re-exposes the renamed column under name `state.newCol`
+ * (the column has already been rewritten inside its body if the body referenced it).
+ *
+ * Returns false when:
+ * - The CTE has an explicit column list (renaming the input to fixed names).
+ * - The body is not a SELECT (INSERT/UPDATE/DELETE WITH RETURNING — out of scope).
+ * - No passthrough result column references the renamed table's column.
+ */
+function cteExposesRenamedColumn(cte, state) {
+    if (cte.columns)
+        return false;
+    const query = cte.query;
+    if (query.type !== 'select')
+        return false;
+    const select = query;
+    // Recreate the body's own with-frame so nested CTE refs in `select.from`
+    // resolve correctly during exposure analysis.
+    const bodyWithFrame = analyzeWithFrame(select.withClause, state);
+    state.scopeStack.push(bodyWithFrame);
+    try {
+        const bodyFrame = buildScopeFrame(select.from, state);
+        for (const col of select.columns ?? []) {
+            if (isResultColumnExposure(col, bodyFrame, state))
+                return true;
+        }
+        return false;
+    }
+    finally {
+        state.scopeStack.pop();
+    }
+}
+function isResultColumnExposure(col, bodyFrame, state) {
+    if (col.type === 'all') {
+        if (col.table === undefined) {
+            return bodyFrame.unaliased.has(state.tableName);
+        }
+        const qualLower = col.table.toLowerCase();
+        if (qualLower === state.tableName && bodyFrame.unaliased.has(state.tableName))
+            return true;
+        return bodyFrame.aliasMap.get(qualLower) === state.tableName;
+    }
+    if (col.alias !== undefined)
+        return false;
+    const expr = col.expr;
+    if (expr.type !== 'column')
+        return false;
+    const colExpr = expr;
+    if (colExpr.name.toLowerCase() !== state.newCol.toLowerCase())
+        return false;
+    if (colExpr.table === undefined) {
+        return bodyFrame.unaliased.has(state.tableName);
+    }
+    const qualLower = colExpr.table.toLowerCase();
+    if (qualLower === state.tableName &&
+        (colExpr.schema === undefined || eq(colExpr.schema, state.defaultSchema))) {
+        return true;
+    }
+    return bodyFrame.aliasMap.get(qualLower) === state.tableName;
+}
 //# sourceMappingURL=rename-rewriter.js.map