rawsql-ts 0.19.0 → 0.21.0

package/dist/esm/transformers/SSSQLFilterBuilder.js

@@ -1,14 +1,38 @@
-import { WhereClause, TableSource } from "../models/Clause";
-import { BinaryExpression, ColumnReference, IdentifierString, LiteralValue, ParameterExpression, ParenExpression } from "../models/ValueComponent";
+import { WhereClause, SubQuerySource, TableSource } from "../models/Clause";
+import { SimpleSelectQuery } from "../models/SelectQuery";
+import { BinaryExpression, ColumnReference, IdentifierString, InlineQuery, LiteralValue, ParameterExpression, ParenExpression, RawString, UnaryExpression } from "../models/ValueComponent";
 import { SelectQueryParser } from "../parsers/SelectQueryParser";
 import { UpstreamSelectQueryFinder } from "./UpstreamSelectQueryFinder";
-import { SelectableColumnCollector, DuplicateDetectionMode } from "./SelectableColumnCollector";
 import { ColumnReferenceCollector } from "./ColumnReferenceCollector";
+import { SelectableColumnCollector, DuplicateDetectionMode } from "./SelectableColumnCollector";
+import { ParameterCollector } from "./ParameterCollector";
+import { SqlFormatter } from "./SqlFormatter";
+import { CTECollector } from "./CTECollector";
 import { collectSupportedOptionalConditionBranches } from "./PruneOptionalConditionBranches";
+const SUPPORTED_SCALAR_OPERATORS = new Set(["=", "<>", "<", "<=", ">", ">=", "like", "ilike"]);
+let formatter = null;
 const normalizeIdentifier = (value) => value.trim().toLowerCase();
+const normalizeSql = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
 const normalizeColumnReferenceKey = (reference) => {
     return `${normalizeIdentifier(reference.getNamespace())}.${normalizeIdentifier(reference.column.name)}`;
 };
+const normalizeColumnReferenceText = (reference) => {
+    const namespace = reference.getNamespace();
+    return namespace ? `${namespace}.${reference.column.name}` : reference.column.name;
+};
+const normalizeScalarOperator = (value) => {
+    if (!value) {
+        return "=";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "!=") {
+        return "<>";
+    }
+    if (SUPPORTED_SCALAR_OPERATORS.has(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unsupported SSSQL operator '${value}'.`);
+};
 const isExplicitEqualityScaffoldValue = (value) => {
     var _a;
     if (value === null || value === undefined) {
@@ -40,26 +64,69 @@ const makeParameterName = (filterName) => {
         .replace(/\./g, "_")
         .replace(/[^a-zA-Z0-9_]/g, "_");
 };
-const buildOptionalEqualityBranch = (column, parameterName) => {
-    const parameter = new ParameterExpression(parameterName);
+const unwrapParens = (expression) => {
+    let candidate = expression;
+    while (candidate instanceof ParenExpression) {
+        candidate = candidate.expression;
+    }
+    return candidate;
+};
+const isBinaryOperator = (expression, operator) => {
+    return expression instanceof BinaryExpression && expression.operator.value.trim().toLowerCase() === operator;
+};
+const collectTopLevelAndTerms = (expression) => {
+    const candidate = unwrapParens(expression);
+    if (!isBinaryOperator(candidate, "and")) {
+        return [expression];
+    }
+    return [
+        ...collectTopLevelAndTerms(candidate.left),
+        ...collectTopLevelAndTerms(candidate.right)
+    ];
+};
+const collectTopLevelOrTerms = (expression) => {
+    const candidate = unwrapParens(expression);
+    if (!isBinaryOperator(candidate, "or")) {
+        return [expression];
+    }
+    return [
+        ...collectTopLevelOrTerms(candidate.left),
+        ...collectTopLevelOrTerms(candidate.right)
+    ];
+};
+const getGuardedParameterName = (expression) => {
+    const candidate = unwrapParens(expression);
+    if (!isBinaryOperator(candidate, "is")) {
+        return null;
+    }
+    if (!(candidate.left instanceof ParameterExpression)) {
+        return null;
+    }
+    const right = unwrapParens(candidate.right);
+    const isNull = (right instanceof LiteralValue && right.value === null)
+        || (right instanceof RawString && right.value.trim().toLowerCase() === "null");
+    if (!isNull) {
+        return null;
+    }
+    return candidate.left.name.value;
+};
+const buildOptionalScalarBranch = (column, parameterName, operator) => {
+    const guard = new BinaryExpression(new ParameterExpression(parameterName), "is", new LiteralValue(null));
+    const predicate = new BinaryExpression(new ColumnReference(column.getNamespace() || null, column.column.name), operator, new ParameterExpression(parameterName));
+    return new ParenExpression(new BinaryExpression(guard, "or", predicate));
+};
+const buildOptionalExistsBranch = (parameterName, subquery, kind) => {
     const guard = new BinaryExpression(new ParameterExpression(parameterName), "is", new LiteralValue(null));
-    const equality = new BinaryExpression(new ColumnReference(column.getNamespace() || null, column.column.name), "=", parameter);
-    return new ParenExpression(new BinaryExpression(guard, "or", equality));
+    const existsExpression = new UnaryExpression("exists", new InlineQuery(subquery));
+    const predicate = kind === "exists"
+        ? existsExpression
+        : new UnaryExpression("not", existsExpression);
+    return new ParenExpression(new BinaryExpression(guard, "or", predicate));
 };
 const rebuildWhereWithoutTerm = (query, termToRemove) => {
     if (!query.whereClause) {
         return;
     }
-    const collectTopLevelAndTerms = (expression) => {
-        if (expression instanceof BinaryExpression &&
-            expression.operator.value.trim().toLowerCase() === "and") {
-            return [
-                ...collectTopLevelAndTerms(expression.left),
-                ...collectTopLevelAndTerms(expression.right)
-            ];
-        }
-        return [expression];
-    };
     const terms = collectTopLevelAndTerms(query.whereClause.condition).filter(term => term !== termToRemove);
     if (terms.length === 0) {
         query.whereClause = null;
@@ -71,6 +138,213 @@ const rebuildWhereWithoutTerm = (query, termToRemove) => {
     }
     query.whereClause = new WhereClause(rebuilt);
 };
+const formatSqlComponent = (component) => {
+    formatter !== null && formatter !== void 0 ? formatter : (formatter = new SqlFormatter());
+    return formatter.format(component).formattedSql;
+};
+const enforceSubqueryConstraints = (sql) => {
+    if (!sql.trim()) {
+        throw new Error("SSSQL EXISTS/NOT EXISTS scaffold query must not be empty.");
+    }
+    if (sql.includes(";")) {
+        throw new Error("SSSQL EXISTS/NOT EXISTS scaffold query must not contain semicolons or multiple statements.");
+    }
+    if (/\blateral\b/i.test(sql)) {
+        throw new Error("LATERAL is not supported in SSSQL EXISTS/NOT EXISTS scaffold.");
+    }
+};
+const substituteAnchorPlaceholders = (sql, formattedColumns) => {
+    const usedIndexes = new Set();
+    const replaced = sql.replace(/\$c(\d+)/g, (_, indexDigits) => {
+        const index = Number(indexDigits);
+        if (!Number.isInteger(index)) {
+            throw new Error(`Invalid placeholder '$c${indexDigits}' in SSSQL scaffold query.`);
+        }
+        if (index < 0 || index >= formattedColumns.length) {
+            throw new Error(`Placeholder '$c${index}' references a missing SSSQL scaffold anchor column.`);
+        }
+        usedIndexes.add(index);
+        return formattedColumns[index];
+    });
+    if (formattedColumns.length === 0) {
+        return replaced;
+    }
+    for (let index = 0; index < formattedColumns.length; index += 1) {
+        if (!usedIndexes.has(index)) {
+            throw new Error(`Missing placeholder '$c${index}' for SSSQL scaffold anchor column.`);
+        }
+    }
+    return replaced;
+};
+const getScalarBranchDetails = (expression, parameterName) => {
+    const meaningfulTerms = collectTopLevelOrTerms(expression)
+        .filter(term => getGuardedParameterName(term) !== parameterName);
+    if (meaningfulTerms.length !== 1) {
+        return null;
+    }
+    const predicate = unwrapParens(meaningfulTerms[0]);
+    if (!(predicate instanceof BinaryExpression)) {
+        return null;
+    }
+    const left = unwrapParens(predicate.left);
+    const right = unwrapParens(predicate.right);
+    if (left instanceof ColumnReference && right instanceof ParameterExpression && right.name.value === parameterName) {
+        try {
+            return {
+                operator: normalizeScalarOperator(predicate.operator.value),
+                target: normalizeColumnReferenceText(left)
+            };
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    if (right instanceof ColumnReference && left instanceof ParameterExpression && left.name.value === parameterName) {
+        try {
+            return {
+                operator: normalizeScalarOperator(predicate.operator.value),
+                target: normalizeColumnReferenceText(right)
+            };
+        }
+        catch (_b) {
+            return null;
+        }
+    }
+    return null;
+};
+const hasSelectQuery = (value) => {
+    return typeof value === "object" && value !== null && "selectQuery" in value;
+};
+const collectColumnReferencesDeep = (value) => {
+    const references = [];
+    const visited = new WeakSet();
+    const walk = (candidate) => {
+        if (!candidate || typeof candidate !== "object") {
+            return;
+        }
+        if (candidate instanceof ColumnReference) {
+            references.push(candidate);
+            return;
+        }
+        if (visited.has(candidate)) {
+            return;
+        }
+        visited.add(candidate);
+        if (Array.isArray(candidate)) {
+            for (const item of candidate) {
+                walk(item);
+            }
+            return;
+        }
+        for (const child of Object.values(candidate)) {
+            walk(child);
+        }
+    };
+    walk(value);
+    return references;
+};
+const getExistsBranchKind = (expression, parameterName) => {
+    const meaningfulTerms = collectTopLevelOrTerms(expression)
+        .filter(term => getGuardedParameterName(term) !== parameterName);
+    if (meaningfulTerms.length !== 1) {
+        return null;
+    }
+    const predicate = unwrapParens(meaningfulTerms[0]);
+    const isInlineQueryValue = (value) => {
+        return value instanceof InlineQuery || hasSelectQuery(value);
+    };
+    if (predicate instanceof UnaryExpression && predicate.operator.value.trim().toLowerCase() === "exists") {
+        return isInlineQueryValue(unwrapParens(predicate.expression)) ? "exists" : null;
+    }
+    if (predicate instanceof UnaryExpression && predicate.operator.value.trim().toLowerCase() === "not exists") {
+        return isInlineQueryValue(unwrapParens(predicate.expression)) ? "not-exists" : null;
+    }
+    if (predicate instanceof UnaryExpression &&
+        predicate.operator.value.trim().toLowerCase() === "not" &&
+        unwrapParens(predicate.expression) instanceof UnaryExpression) {
+        const nested = unwrapParens(predicate.expression);
+        if (nested.operator.value.trim().toLowerCase() === "exists"
+            && isInlineQueryValue(unwrapParens(nested.expression))) {
+            return "not-exists";
+        }
+    }
+    return null;
+};
+const getExistsPredicateDetails = (expression, parameterName) => {
+    const meaningfulTerms = collectTopLevelOrTerms(expression)
+        .filter(term => getGuardedParameterName(term) !== parameterName);
+    if (meaningfulTerms.length !== 1) {
+        return null;
+    }
+    const predicate = unwrapParens(meaningfulTerms[0]);
+    const isInlineQueryValue = (value) => {
+        return value instanceof InlineQuery || hasSelectQuery(value);
+    };
+    if (predicate instanceof UnaryExpression && predicate.operator.value.trim().toLowerCase() === "exists") {
+        const candidate = unwrapParens(predicate.expression);
+        if (isInlineQueryValue(candidate)) {
+            return {
+                kind: "exists",
+                subquery: candidate.selectQuery
+            };
+        }
+        return null;
+    }
+    if (predicate instanceof UnaryExpression && predicate.operator.value.trim().toLowerCase() === "not exists") {
+        const candidate = unwrapParens(predicate.expression);
+        if (isInlineQueryValue(candidate)) {
+            return {
+                kind: "not-exists",
+                subquery: candidate.selectQuery
+            };
+        }
+        return null;
+    }
+    if (predicate instanceof UnaryExpression &&
+        predicate.operator.value.trim().toLowerCase() === "not" &&
+        unwrapParens(predicate.expression) instanceof UnaryExpression) {
+        const nested = unwrapParens(predicate.expression);
+        const candidate = unwrapParens(nested.expression);
+        if (nested.operator.value.trim().toLowerCase() === "exists" && isInlineQueryValue(candidate)) {
+            return {
+                kind: "not-exists",
+                subquery: candidate.selectQuery
+            };
+        }
+    }
+    return null;
+};
+const getBranchInfo = (branch) => {
+    const scalar = getScalarBranchDetails(branch.expression, branch.parameterName);
+    if (scalar) {
+        return {
+            parameterName: branch.parameterName,
+            kind: "scalar",
+            operator: scalar.operator,
+            target: scalar.target,
+            query: branch.query,
+            expression: branch.expression,
+            sql: formatSqlComponent(branch.expression)
+        };
+    }
+    const existsKind = getExistsBranchKind(branch.expression, branch.parameterName);
+    if (existsKind) {
+        return {
+            parameterName: branch.parameterName,
+            kind: existsKind,
+            query: branch.query,
+            expression: branch.expression,
+            sql: formatSqlComponent(branch.expression)
+        };
+    }
+    return {
+        parameterName: branch.parameterName,
+        kind: "expression",
+        query: branch.query,
+        expression: branch.expression,
+        sql: formatSqlComponent(branch.expression)
+    };
+};
 /**
  * Builds and refreshes truthful SSSQL optional filter branches.
  * Runtime callers should use pruning, not dynamic predicate injection.
@@ -80,49 +354,180 @@ export class SSSQLFilterBuilder {
         this.tableColumnResolver = tableColumnResolver;
         this.finder = new UpstreamSelectQueryFinder(this.tableColumnResolver);
     }
+    list(query) {
+        const parsed = this.parseQuery(query);
+        return collectSupportedOptionalConditionBranches(parsed).map(getBranchInfo);
+    }
     scaffold(query, filters) {
         const parsed = this.parseQuery(query);
         for (const [filterName, filterValue] of Object.entries(filters)) {
             if (!isExplicitEqualityScaffoldValue(filterValue)) {
-                throw new Error(`SSSQL scaffold only supports equality filters in v1. Use refresh for pre-authored branches: '${filterName}'.`);
+                throw new Error(`SSSQL scaffold only supports equality filters in v1. Use structured scaffold or refresh for pre-authored branches: '${filterName}'.`);
             }
-            const target = this.resolveTarget(parsed, filterName);
-            target.query.appendWhere(buildOptionalEqualityBranch(target.column, target.parameterName));
+            this.scaffoldBranch(parsed, {
+                target: filterName,
+                parameterName: makeParameterName(filterName),
+                operator: "="
+            });
+        }
+        return parsed;
+    }
+    scaffoldBranch(query, spec) {
+        const parsed = this.parseQuery(query);
+        if (spec.kind === "exists" || spec.kind === "not-exists") {
+            this.scaffoldExistsBranch(parsed, spec);
+            return parsed;
         }
+        this.scaffoldScalarBranch(parsed, spec);
         return parsed;
     }
     refresh(query, filters) {
         const parsed = this.parseQuery(query);
         for (const [filterName, filterValue] of Object.entries(filters)) {
-            const target = this.resolveTarget(parsed, filterName);
-            const matches = collectSupportedOptionalConditionBranches(parsed)
-                .filter(branch => branch.parameterName === target.parameterName);
+            let parameterName = filterName;
+            let target = null;
+            let matches = collectSupportedOptionalConditionBranches(parsed)
+                .filter(branch => branch.parameterName === parameterName);
+            if (matches.length === 0) {
+                target = this.resolveTarget(parsed, filterName);
+                parameterName = target.parameterName;
+                matches = collectSupportedOptionalConditionBranches(parsed)
+                    .filter(branch => branch.parameterName === parameterName);
+            }
             if (matches.length === 0) {
+                if (!target) {
+                    target = this.resolveTarget(parsed, filterName);
+                    parameterName = target.parameterName;
+                }
                 if (!isExplicitEqualityScaffoldValue(filterValue)) {
                     throw new Error(`No existing SSSQL branch was found for '${filterName}', and v1 scaffold only supports equality filters.`);
                 }
-                target.query.appendWhere(buildOptionalEqualityBranch(target.column, target.parameterName));
+                this.scaffoldScalarBranch(parsed, {
+                    target: filterName,
+                    parameterName: target.parameterName,
+                    operator: "="
+                });
                 continue;
             }
             if (matches.length > 1) {
-                throw new Error(`Multiple SSSQL branches matched parameter ':${target.parameterName}'. Refresh is ambiguous.`);
+                throw new Error(`Multiple SSSQL branches matched parameter ':${parameterName}'. Refresh is ambiguous.`);
             }
             const [match] = matches;
             if (!match) {
                 continue;
             }
-            if (match.query === target.query) {
+            const correlatedPlan = this.buildCorrelatedRefreshPlan(parsed, match);
+            if (correlatedPlan) {
+                if (correlatedPlan.target.query === match.query) {
+                    continue;
+                }
+                this.rebaseMovedBranchByAlias(match.expression, correlatedPlan.sourceAlias, correlatedPlan.target.column);
+                rebuildWhereWithoutTerm(match.query, match.expression);
+                correlatedPlan.target.query.appendWhere(match.expression);
                 continue;
             }
-            this.rebaseMovedBranch(match.expression, match.query, target.column);
+            if (!target) {
+                target = this.resolveTarget(parsed, filterName);
+            }
+            if (match.query !== target.query) {
+                this.rebaseMovedBranch(match.expression, match.query, target.column);
+                rebuildWhereWithoutTerm(match.query, match.expression);
+                target.query.appendWhere(match.expression);
+            }
+        }
+        return parsed;
+    }
+    remove(query, spec) {
+        const parsed = this.parseQuery(query);
+        const matches = this.findMatchingBranchInfos(parsed, spec);
+        if (matches.length === 0) {
+            return parsed;
+        }
+        if (matches.length > 1) {
+            throw new Error(`Multiple SSSQL branches matched parameter ':${spec.parameterName}'. Remove is ambiguous.`);
+        }
+        const [match] = matches;
+        if (!match) {
+            return parsed;
+        }
+        rebuildWhereWithoutTerm(match.query, match.expression);
+        return parsed;
+    }
+    removeAll(query) {
+        const parsed = this.parseQuery(query);
+        const matches = this.list(parsed);
+        for (const match of matches) {
             rebuildWhereWithoutTerm(match.query, match.expression);
-            target.query.appendWhere(match.expression);
         }
         return parsed;
     }
     parseQuery(query) {
         return typeof query === "string" ? SelectQueryParser.parse(query) : query;
     }
+    findMatchingBranchInfos(root, spec) {
+        const normalizedOperator = spec.operator ? normalizeScalarOperator(spec.operator) : undefined;
+        const normalizedTarget = spec.target ? normalizeIdentifier(spec.target) : undefined;
+        return this.list(root).filter(branch => {
+            if (branch.parameterName !== spec.parameterName) {
+                return false;
+            }
+            if (spec.kind && branch.kind !== spec.kind) {
+                return false;
+            }
+            if (normalizedOperator && branch.operator !== normalizedOperator) {
+                return false;
+            }
+            if (normalizedTarget && (!branch.target || normalizeIdentifier(branch.target) !== normalizedTarget)) {
+                return false;
+            }
+            return true;
+        });
+    }
+    scaffoldScalarBranch(root, spec) {
+        var _a;
+        const target = this.resolveTarget(root, spec.target);
+        const parameterName = ((_a = spec.parameterName) === null || _a === void 0 ? void 0 : _a.trim()) || target.parameterName;
+        const operator = normalizeScalarOperator(spec.operator);
+        const branch = buildOptionalScalarBranch(target.column, parameterName, operator);
+        const branchSql = normalizeSql(formatSqlComponent(branch));
+        const duplicate = this.list(root).find(existing => existing.query === target.query &&
+            normalizeSql(existing.sql) === branchSql);
+        if (duplicate) {
+            return;
+        }
+        target.query.appendWhere(branch);
+    }
+    scaffoldExistsBranch(root, spec) {
+        const parameterName = spec.parameterName.trim();
+        if (!parameterName) {
+            throw new Error("SSSQL EXISTS/NOT EXISTS scaffold requires parameterName.");
+        }
+        if (spec.anchorColumns.length === 0) {
+            throw new Error("SSSQL EXISTS/NOT EXISTS scaffold requires at least one anchorColumn.");
+        }
+        const anchorTargets = spec.anchorColumns.map(anchorColumn => this.resolveTarget(root, anchorColumn));
+        const targetQueries = [...new Set(anchorTargets.map(target => target.query))];
+        if (targetQueries.length !== 1) {
+            throw new Error("SSSQL EXISTS/NOT EXISTS scaffold anchor columns must resolve within one query scope.");
+        }
+        const targetQuery = targetQueries[0];
+        const formattedColumns = anchorTargets.map(target => formatSqlComponent(target.column));
+        const substitutedSql = substituteAnchorPlaceholders(spec.query, formattedColumns).trim();
+        enforceSubqueryConstraints(substitutedSql);
+        const subquery = SelectQueryParser.parse(substitutedSql);
+        const parameterNames = new Set(ParameterCollector.collect(subquery).map(parameter => parameter.name.value));
+        if (parameterNames.size !== 1 || !parameterNames.has(parameterName)) {
+            throw new Error(`SSSQL ${spec.kind.toUpperCase()} scaffold query must reference only parameter ':${parameterName}'.`);
+        }
+        const branch = buildOptionalExistsBranch(parameterName, subquery, spec.kind);
+        const branchSql = normalizeSql(formatSqlComponent(branch));
+        const duplicate = this.list(root).find(existing => existing.query === targetQuery &&
+            normalizeSql(existing.sql) === branchSql);
+        if (duplicate) {
+            return;
+        }
+        targetQuery.appendWhere(branch);
+    }
     resolveTarget(root, filterName) {
         var _a;
         const qualified = parseQualifiedFilterName(filterName);
@@ -210,14 +615,140 @@ export class SSSQLFilterBuilder {
         }
         return (_a = source.getAliasName()) !== null && _a !== void 0 ? _a : source.datasource.table.name;
     }
+    buildCorrelatedRefreshPlan(root, branch) {
+        const details = getExistsPredicateDetails(branch.expression, branch.parameterName);
+        if (!details) {
+            return null;
+        }
+        const sourceAliases = this.collectSourceAliases(branch.query);
+        const candidatesByKey = new Map();
+        for (const reference of new ColumnReferenceCollector().collect(details.subquery)) {
+            const namespace = normalizeIdentifier(reference.getNamespace());
+            if (!namespace || !sourceAliases.has(namespace)) {
+                continue;
+            }
+            const column = normalizeIdentifier(reference.column.name);
+            const key = `${namespace}.${column}`;
+            if (!candidatesByKey.has(key)) {
+                candidatesByKey.set(key, { namespace, column });
+            }
+        }
+        const candidates = [...candidatesByKey.values()];
+        if (candidates.length === 0) {
+            throw new Error(`SSSQL refresh could not infer a correlated anchor for ':${branch.parameterName}'.`);
+        }
+        if (candidates.length > 1) {
+            const listed = candidates.map(candidate => `${candidate.namespace}.${candidate.column}`).join(", ");
+            throw new Error(`SSSQL refresh found multiple correlated anchor candidates for ':${branch.parameterName}' (${listed}).`);
+        }
+        const [anchor] = candidates;
+        if (!anchor) {
+            throw new Error(`SSSQL refresh could not infer a correlated anchor for ':${branch.parameterName}'.`);
+        }
+        return {
+            target: this.resolveCorrelatedAnchorTarget(root, branch.query, anchor, branch.parameterName),
+            sourceAlias: anchor.namespace
+        };
+    }
+    collectSourceAliases(query) {
+        var _a, _b;
+        const aliases = new Set();
+        for (const source of (_b = (_a = query.fromClause) === null || _a === void 0 ? void 0 : _a.getSources()) !== null && _b !== void 0 ? _b : []) {
+            const sourceAlias = this.getSourceAlias(source);
+            if (sourceAlias) {
+                aliases.add(sourceAlias);
+            }
+        }
+        return aliases;
+    }
+    resolveCorrelatedAnchorTarget(root, sourceQuery, anchor, parameterName) {
+        const sourceExpression = this.findSourceExpressionByAlias(sourceQuery, anchor.namespace, parameterName);
+        const upstreamQuery = this.resolveSourceExpressionToUpstreamQuery(root, sourceExpression, parameterName);
+        if (!upstreamQuery) {
+            return {
+                query: sourceQuery,
+                column: new ColumnReference(anchor.namespace, anchor.column),
+                parameterName
+            };
+        }
+        return this.resolveAnchorTargetInQuery(upstreamQuery, anchor, parameterName);
+    }
+    findSourceExpressionByAlias(query, alias, parameterName) {
+        var _a, _b;
+        const matches = ((_b = (_a = query.fromClause) === null || _a === void 0 ? void 0 : _a.getSources()) !== null && _b !== void 0 ? _b : [])
+            .filter(source => this.getSourceAlias(source) === alias);
+        if (matches.length === 0) {
+            throw new Error(`SSSQL refresh could not resolve correlated alias '${alias}' for ':${parameterName}'.`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`SSSQL refresh found multiple correlated sources for alias '${alias}' and ':${parameterName}'.`);
+        }
+        return matches[0];
+    }
+    resolveSourceExpressionToUpstreamQuery(root, source, parameterName) {
+        if (source.datasource instanceof SubQuerySource) {
+            if (source.datasource.query instanceof SimpleSelectQuery) {
+                return source.datasource.query;
+            }
+            throw new Error(`SSSQL refresh requires a simple query anchor for ':${parameterName}'.`);
+        }
+        if (!(source.datasource instanceof TableSource)) {
+            return null;
+        }
+        const cteName = normalizeIdentifier(source.datasource.table.name);
+        const cteMatches = new CTECollector()
+            .collect(root)
+            .filter(cte => normalizeIdentifier(cte.getSourceAliasName()) === cteName);
+        if (cteMatches.length === 0) {
+            return null;
+        }
+        if (cteMatches.length > 1) {
+            throw new Error(`SSSQL refresh found multiple CTE anchors for ':${parameterName}' (${source.datasource.table.name}).`);
+        }
+        const [cte] = cteMatches;
+        if (!cte) {
+            return null;
+        }
+        const cteQuery = cte.query;
+        if (!(cteQuery instanceof SimpleSelectQuery)) {
+            throw new Error(`SSSQL refresh requires a simple CTE anchor for ':${parameterName}'.`);
+        }
+        return cteQuery;
+    }
+    resolveAnchorTargetInQuery(query, anchor, parameterName) {
+        const collector = new SelectableColumnCollector(this.tableColumnResolver, false, DuplicateDetectionMode.FullName, { upstream: true });
+        const matches = collector.collect(query)
+            .filter((entry) => entry.value instanceof ColumnReference)
+            .filter(entry => normalizeIdentifier(entry.name) === anchor.column);
+        if (matches.length === 0) {
+            throw new Error(`SSSQL refresh could not resolve correlated anchor column '${anchor.column}' for ':${parameterName}'.`);
+        }
+        if (matches.length > 1) {
+            throw new Error(`SSSQL refresh found multiple correlated anchor columns '${anchor.column}' for ':${parameterName}'.`);
+        }
+        return {
+            query,
+            column: matches[0].value,
+            parameterName
+        };
+    }
+    getSourceAlias(source) {
+        const explicitAlias = source.getAliasName();
+        if (explicitAlias) {
+            return normalizeIdentifier(explicitAlias);
+        }
+        if (source.datasource instanceof TableSource) {
+            return normalizeIdentifier(source.datasource.table.name);
+        }
+        return null;
+    }
     rebaseMovedBranch(expression, sourceQuery, targetColumn) {
         var _a, _b, _c;
         const targetNamespace = targetColumn.qualifiedName.namespaces
             ? targetColumn.qualifiedName.namespaces.map(namespace => namespace.name)
             : null;
         const targetColumnName = normalizeIdentifier(targetColumn.column.name);
-        const sourceAliases = new Set(new ColumnReferenceCollector()
-            .collect(expression)
+        const sourceAliases = new Set(collectColumnReferencesDeep(expression)
             .filter(reference => normalizeIdentifier(reference.column.name) === targetColumnName)
             .map(reference => normalizeIdentifier(reference.getNamespace()))
             .filter(namespace => namespace.length > 0));
@@ -236,13 +767,29 @@ export class SSSQLFilterBuilder {
         if (!availableAliases.has(sourceAlias)) {
             return;
         }
-        for (const reference of new ColumnReferenceCollector().collect(expression)) {
+        for (const reference of collectColumnReferencesDeep(expression)) {
             if (normalizeIdentifier(reference.getNamespace()) !== sourceAlias) {
                 continue;
             }
             reference.qualifiedName.namespaces = (_c = targetNamespace === null || targetNamespace === void 0 ? void 0 : targetNamespace.map(namespace => new IdentifierString(namespace))) !== null && _c !== void 0 ? _c : null;
         }
     }
+    rebaseMovedBranchByAlias(expression, sourceAlias, targetColumn) {
+        var _a;
+        const normalizedSourceAlias = normalizeIdentifier(sourceAlias);
+        if (!normalizedSourceAlias) {
+            return;
+        }
+        const targetNamespace = targetColumn.qualifiedName.namespaces
+            ? targetColumn.qualifiedName.namespaces.map(namespace => namespace.name)
+            : null;
+        for (const reference of collectColumnReferencesDeep(expression)) {
+            if (normalizeIdentifier(reference.getNamespace()) !== normalizedSourceAlias) {
+                continue;
+            }
+            reference.qualifiedName.namespaces = (_a = targetNamespace === null || targetNamespace === void 0 ? void 0 : targetNamespace.map(namespace => new IdentifierString(namespace))) !== null && _a !== void 0 ? _a : null;
+        }
+    }
 }
 export const scaffoldSssqlQuery = (sqlContent, filters) => ({
     query: new SSSQLFilterBuilder().scaffold(sqlContent, filters)