rawsql-ts 0.26.0 → 0.27.0

package/dist/esm/transformers/StaticPredicatePlacementOptimizer.js

@@ -0,0 +1,1435 @@
+import { DistinctOn, SubQuerySource, TableSource, WhereClause } from "../models/Clause";
+import { BinarySelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+import { ArrayExpression, ArrayQueryExpression, BetweenExpression, BinaryExpression, CaseExpression, CastExpression, ColumnReference, FunctionCall, InlineQuery, JsonPredicateExpression, ParameterExpression, ParenExpression, TupleExpression, TypeValue, UnaryExpression, ValueList } from "../models/ValueComponent";
+import { SelectQueryParser } from "../parsers/SelectQueryParser";
+import { ValueParser } from "../parsers/ValueParser";
+import { formatSqlComponent, hasSqlComponentFormatOverride } from "./SqlComponentFormatter";
+import { SelectOutputCollector } from "./SelectOutputCollector";
+const VOLATILE_OR_UNSUPPORTED_FUNCTION_REASON = "Predicate contains a function call; volatile and expression predicates are not moved in the safe-only implementation.";
+const normalizeIdentifier = (value) => value.trim().toLowerCase();
+const unwrapParens = (expression) => {
+    let candidate = expression;
+    while (candidate instanceof ParenExpression) {
+        candidate = candidate.expression;
+    }
+    return candidate;
+};
+const isBinaryOperator = (expression, operator) => {
+    const candidate = unwrapParens(expression);
+    return candidate instanceof BinaryExpression
+        && candidate.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 rebuildWhereWithoutTerms = (query, termsToRemove) => {
+    if (!query.whereClause || termsToRemove.size === 0) {
+        return;
+    }
+    const remaining = collectTopLevelAndTerms(query.whereClause.condition)
+        .filter(term => !termsToRemove.has(term));
+    if (remaining.length === 0) {
+        query.whereClause = null;
+        return;
+    }
+    let rebuilt = remaining[0];
+    for (let index = 1; index < remaining.length; index += 1) {
+        rebuilt = new BinaryExpression(rebuilt, "and", remaining[index]);
+    }
+    query.whereClause = new WhereClause(rebuilt);
+};
+const cloneValueComponent = (expression, options) => {
+    return ValueParser.parse(formatSqlComponent(expression, options));
+};
+const cloneColumnReference = (reference) => {
+    var _a, _b;
+    const namespaces = (_b = (_a = reference.namespaces) === null || _a === void 0 ? void 0 : _a.map(namespace => namespace.name)) !== null && _b !== void 0 ? _b : null;
+    return new ColumnReference(namespaces, reference.column.name);
+};
+const columnReferenceText = (reference) => {
+    const namespace = reference.getNamespace();
+    return namespace ? `${namespace}.${reference.column.name}` : reference.column.name;
+};
+const sameColumnReference = (left, right) => {
+    return normalizeIdentifier(left.column.name) === normalizeIdentifier(right.column.name)
+        && normalizeIdentifier(left.getNamespace()) === normalizeIdentifier(right.getNamespace());
+};
+const appendUnique = (items, value) => {
+    if (!items.includes(value)) {
+        items.push(value);
+    }
+};
+export class StaticPredicatePlacementOptimizer {
+    plan(input, options = {}) {
+        var _a, _b, _c;
+        const parsed = this.parseInput(input, options);
+        const warnings = [...parsed.warnings];
+        const errors = [...parsed.errors];
+        if (!parsed.query) {
+            return this.buildResult({
+                query: null,
+                sql: parsed.sql,
+                applied: [],
+                skipped: [],
+                warnings,
+                errors,
+                dryRun: (_a = options.dryRun) !== null && _a !== void 0 ? _a : true,
+                formatterGeneratedSource: parsed.formatterGeneratedSource
+            });
+        }
+        if (!(parsed.query instanceof SimpleSelectQuery)) {
+            warnings.push({
+                code: "UNSUPPORTED_ROOT_QUERY",
+                message: "Static predicate placement currently supports only SimpleSelectQuery roots."
+            });
+            return this.buildResult({
+                query: parsed.query,
+                sql: parsed.sql,
+                applied: [],
+                skipped: [],
+                warnings,
+                errors,
+                dryRun: (_b = options.dryRun) !== null && _b !== void 0 ? _b : true,
+                formatterGeneratedSource: parsed.formatterGeneratedSource
+            });
+        }
+        const query = parsed.query;
+        const applied = [];
+        const skipped = [];
+        const movedTerms = [];
+        for (const term of query.whereClause ? collectTopLevelAndTerms(query.whereClause.condition) : []) {
+            const candidate = this.analyzeCandidate(query, term, options);
+            if (!candidate) {
+                continue;
+            }
+            if ("code" in candidate) {
+                skipped.push(this.makeSkipped(term, candidate, options));
+                continue;
+            }
+            const target = this.resolveTarget(query, candidate);
+            if ("code" in target) {
+                skipped.push(this.makeSkipped(term, target, options));
+                continue;
+            }
+            let appliedReason = "";
+            if (target.kind === "simple") {
+                const targetColumns = this.resolveTargetColumns(query, target.query, candidate.references);
+                if ("code" in targetColumns) {
+                    skipped.push(this.makeSkipped(term, targetColumns, options));
+                    continue;
+                }
+                const placement = this.resolveTargetPlacement(target.query, targetColumns);
+                if ("code" in placement) {
+                    skipped.push(this.makeSkipped(term, placement, options));
+                    continue;
+                }
+                const movedPredicate = this.rebasePredicate(candidate.expression, targetColumns, options);
+                target.query.appendWhere(movedPredicate);
+                appliedReason = placement.reason;
+            }
+            else {
+                const placements = [];
+                let skip = null;
+                for (const branch of target.branches) {
+                    const placement = this.resolveTargetPlacement(branch.query, branch.targetColumns);
+                    if ("code" in placement) {
+                        skip = placement;
+                        break;
+                    }
+                    placements.push(placement);
+                }
+                if (skip) {
+                    skipped.push(this.makeSkipped(term, skip, options));
+                    continue;
+                }
+                for (const branch of target.branches) {
+                    const movedPredicate = this.rebasePredicate(candidate.expression, branch.targetColumns, options);
+                    branch.query.appendWhere(movedPredicate);
+                }
+                appliedReason = placements.some(item => /group by/i.test(item.reason))
+                    ? "Predicate is distributed to every UNION branch by output column position; grouped branches only receive GROUP BY-key predicates."
+                    : "Predicate is distributed to every UNION branch by output column position before unsafe query boundaries.";
+            }
+            movedTerms.push(term);
+            applied.push({
+                kind: "move_static_predicate",
+                predicateSql: candidate.predicateSql,
+                fromScopeId: "scope:root",
+                toScopeId: target.scopeId,
+                reason: appliedReason,
+                columnReferences: candidate.references.map(columnReferenceText)
+            });
+        }
+        rebuildWhereWithoutTerms(query, new Set(movedTerms));
+        const sql = applied.length > 0 || hasSqlComponentFormatOverride(options)
+            ? formatSqlComponent(query, options)
+            : parsed.sql;
+        return this.buildResult({
+            query,
+            sql,
+            applied,
+            skipped,
+            warnings,
+            errors,
+            dryRun: (_c = options.dryRun) !== null && _c !== void 0 ? _c : true,
+            formatterGeneratedSource: parsed.formatterGeneratedSource
+        });
+    }
+    optimize(input, options = {}) {
+        var _a;
+        return this.plan(input, Object.assign(Object.assign({}, options), { dryRun: (_a = options.dryRun) !== null && _a !== void 0 ? _a : false }));
+    }
+    parseInput(input, options) {
+        const warnings = [];
+        const errors = [];
+        try {
+            const sourceSql = typeof input === "string"
+                ? input
+                : formatSqlComponent(input, options);
+            if (typeof input !== "string" && options.cloneInput === false) {
+                return {
+                    query: input,
+                    sql: sourceSql,
+                    formatterGeneratedSource: false,
+                    warnings,
+                    errors
+                };
+            }
+            if (typeof input !== "string") {
+                warnings.push({
+                    code: "AST_INPUT_FORMATTED",
+                    message: "AST input is cloned through formatter output so the caller-owned query is not mutated."
+                });
+            }
+            return {
+                query: SelectQueryParser.parse(sourceSql),
+                sql: sourceSql,
+                formatterGeneratedSource: typeof input !== "string",
+                warnings,
+                errors
+            };
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            errors.push({
+                code: "PARSE_FAILED",
+                message: "Static predicate placement could not parse the input SQL.",
+                detail
+            });
+            return {
+                query: null,
+                sql: typeof input === "string" ? input : "",
+                formatterGeneratedSource: typeof input !== "string",
+                warnings,
+                errors
+            };
+        }
+    }
+    analyzeCandidate(root, expression, options) {
+        if (this.collectParameterNames(expression).length > 0) {
+            return null;
+        }
+        const unsupported = this.findUnsupportedExpression(expression, this.isExistsPredicate(expression));
+        if (unsupported) {
+            return unsupported;
+        }
+        const references = this.collectRootColumnReferences(root, expression);
+        if (references.length === 0) {
+            return {
+                code: "NO_COLUMN_REFERENCE",
+                reason: "Static predicate has no outer column reference to anchor the move."
+            };
+        }
+        return {
+            expression,
+            predicateSql: formatSqlComponent(expression, options),
+            references
+        };
+    }
+    isExistsPredicate(expression) {
+        const candidate = unwrapParens(expression);
+        if (!(candidate instanceof UnaryExpression)) {
+            return false;
+        }
+        const operator = candidate.operator.value.trim().toLowerCase();
+        return operator === "exists" && unwrapParens(candidate.expression) instanceof InlineQuery;
+    }
+    findUnsupportedExpression(expression, allowExistsSubquery) {
+        let found = null;
+        const visitSelect = (query) => {
+            var _a, _b, _c, _d;
+            if (found) {
+                return;
+            }
+            if (query instanceof BinarySelectQuery) {
+                found = {
+                    code: "UNION_BOUNDARY",
+                    reason: "Static predicate would need distribution into a UNION branch, which is unsupported."
+                };
+                return;
+            }
+            if (!(query instanceof SimpleSelectQuery)) {
+                found = {
+                    code: "UNSUPPORTED_SUBQUERY",
+                    reason: "Static predicate contains a non-simple subquery, which is unsupported."
+                };
+                return;
+            }
+            query.selectClause.items.forEach(item => visit(item.value));
+            for (const join of (_b = (_a = query.fromClause) === null || _a === void 0 ? void 0 : _a.joins) !== null && _b !== void 0 ? _b : []) {
+                if (join.condition) {
+                    visit(join.condition.condition);
+                }
+                const source = join.source.datasource;
+                if (source instanceof SubQuerySource) {
+                    visitSelect(source.query);
+                }
+            }
+            if (query.whereClause) {
+                visit(query.whereClause.condition);
+            }
+            if (query.havingClause) {
+                visit(query.havingClause.condition);
+            }
+            for (const cte of (_d = (_c = query.withClause) === null || _c === void 0 ? void 0 : _c.tables) !== null && _d !== void 0 ? _d : []) {
+                if (cte.query instanceof SimpleSelectQuery || cte.query instanceof BinarySelectQuery) {
+                    visitSelect(cte.query);
+                }
+            }
+        };
+        const visit = (value) => {
+            if (found) {
+                return;
+            }
+            const candidate = unwrapParens(value);
+            if (candidate instanceof BinaryExpression) {
+                visit(candidate.left);
+                visit(candidate.right);
+                return;
+            }
+            if (candidate instanceof FunctionCall) {
+                found = {
+                    code: "FUNCTION_PREDICATE_UNSUPPORTED",
+                    reason: VOLATILE_OR_UNSUPPORTED_FUNCTION_REASON
+                };
+                return;
+            }
+            if (candidate instanceof CaseExpression) {
+                found = {
+                    code: "CASE_PREDICATE_UNSUPPORTED",
+                    reason: "CASE predicates are not moved in the first safe-only implementation."
+                };
+                return;
+            }
+            if (candidate instanceof InlineQuery) {
+                if (!allowExistsSubquery) {
+                    found = {
+                        code: "SUBQUERY_PREDICATE_UNSUPPORTED",
+                        reason: "Subquery predicates are only moved when they are simple EXISTS predicates."
+                    };
+                    return;
+                }
+                visitSelect(candidate.selectQuery);
+                return;
+            }
+            if (candidate instanceof ArrayQueryExpression) {
+                found = {
+                    code: "SUBQUERY_PREDICATE_UNSUPPORTED",
+                    reason: "Array subquery predicates are not moved in the first safe-only implementation."
+                };
+                return;
+            }
+            if (candidate instanceof UnaryExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof CastExpression) {
+                visit(candidate.input);
+                return;
+            }
+            if (candidate instanceof JsonPredicateExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof ArrayExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof ValueList) {
+                candidate.values.forEach(visit);
+                return;
+            }
+            if (candidate instanceof TupleExpression) {
+                candidate.values.forEach(visit);
+                return;
+            }
+            if (candidate instanceof TypeValue && candidate.argument) {
+                visit(candidate.argument);
+            }
+        };
+        visit(expression);
+        return found;
+    }
+    resolveTarget(root, candidate) {
+        const boundary = this.findRootQueryBoundary(root);
+        if (boundary) {
+            return boundary;
+        }
+        if (!root.fromClause) {
+            return {
+                code: "NO_FROM_CLAUSE",
+                reason: "Predicate has no FROM source that can receive it safely."
+            };
+        }
+        const bindings = [];
+        for (const reference of candidate.references) {
+            const binding = this.resolveSourceBinding(root, root, reference);
+            if ("code" in binding) {
+                return binding;
+            }
+            if (!bindings.some(item => item.source === binding.source)) {
+                bindings.push(binding);
+            }
+        }
+        if (bindings.length !== 1) {
+            return {
+                code: "MULTIPLE_SOURCE_REFERENCES",
+                reason: "Static predicate references multiple source query blocks; moving it may change semantics."
+            };
+        }
+        const binding = bindings[0];
+        const nullableSide = this.findNullableSideBoundary(root.fromClause, binding);
+        if (nullableSide) {
+            return nullableSide;
+        }
+        const upstream = this.resolveUpstreamQuery(root, binding, candidate.references);
+        if ("code" in upstream) {
+            return upstream;
+        }
+        return upstream;
+    }
+    findRootQueryBoundary(query) {
+        if (this.hasDistinctOnBoundary(query)) {
+            return {
+                code: "DISTINCT_BOUNDARY",
+                reason: "Predicate crosses DISTINCT ON boundary; moving it may change semantics."
+            };
+        }
+        if (this.hasWindowUsage(query)) {
+            return {
+                code: "WINDOW_BOUNDARY",
+                reason: "Predicate crosses WINDOW boundary; moving it may change semantics."
+            };
+        }
+        return null;
+    }
+    resolveTargetPlacement(query, targetColumns) {
+        const hasOrdinaryDistinct = this.hasOrdinaryDistinct(query);
+        if (this.hasDistinctOnBoundary(query)) {
+            return {
+                code: "DISTINCT_BOUNDARY",
+                reason: "Predicate crosses DISTINCT ON boundary; moving it may change semantics."
+            };
+        }
+        if (this.hasWindowUsage(query)) {
+            return {
+                code: "WINDOW_BOUNDARY",
+                reason: "Predicate crosses WINDOW boundary; moving it may change semantics."
+            };
+        }
+        if (query.limitClause || query.offsetClause || query.fetchClause) {
+            return {
+                code: "ROW_LIMIT_BOUNDARY",
+                reason: "Predicate crosses LIMIT/OFFSET/FETCH boundary; moving it may change row selection semantics."
+            };
+        }
+        if (query.fromClause && this.hasOuterJoin(query.fromClause)) {
+            return {
+                code: "OUTER_JOIN_BOUNDARY",
+                reason: "Target query contains an OUTER JOIN boundary that is not moved across in the safe-only implementation."
+            };
+        }
+        if (query.groupByClause) {
+            const allReferencesAreGroupKeys = targetColumns.every(item => this.isGroupKeyColumn(query, item.targetColumn));
+            if (!allReferencesAreGroupKeys) {
+                return {
+                    code: "GROUP_BY_BOUNDARY",
+                    reason: "Predicate references a target column that is not proven to be a GROUP BY key."
+                };
+            }
+            return {
+                reason: "Predicate references only GROUP BY keys; it is moved into pre-aggregation WHERE."
+            };
+        }
+        if (query.havingClause) {
+            return {
+                code: "GROUP_BY_BOUNDARY",
+                reason: "Predicate crosses HAVING aggregation boundary; moving it may change semantics."
+            };
+        }
+        if (hasOrdinaryDistinct) {
+            return {
+                reason: "Predicate references direct ordinary DISTINCT output columns; it is moved into the DISTINCT input WHERE."
+            };
+        }
+        return {
+            reason: "All outer references resolve to direct upstream outputs before unsafe query boundaries."
+        };
+    }
+    resolveSourceBinding(contextRoot, query, column) {
+        const fromClause = query.fromClause;
+        if (!fromClause) {
+            return {
+                code: "NO_FROM_CLAUSE",
+                reason: "Predicate has no FROM source that can receive it safely."
+            };
+        }
+        const bindings = this.getSourceBindings(fromClause);
+        const namespace = normalizeIdentifier(column.getNamespace());
+        const columnName = column.column.name;
+        if (namespace) {
+            const matches = bindings.filter(binding => normalizeIdentifier(binding.alias) === namespace);
+            if (matches.length !== 1) {
+                return {
+                    code: "AMBIGUOUS_COLUMN_SOURCE",
+                    reason: `Column source alias '${column.getNamespace()}' is not uniquely resolvable.`
+                };
+            }
+            const matchCount = this.getOutputColumnMatchCount(contextRoot, matches[0], columnName);
+            if (matchCount === 0) {
+                return {
+                    code: "COLUMN_NOT_AVAILABLE_UPSTREAM",
+                    reason: `Column '${columnReferenceText(column)}' is not a direct output of the referenced source.`
+                };
+            }
+            if (matchCount > 1) {
+                return {
+                    code: "AMBIGUOUS_COLUMN_REFERENCE",
+                    reason: `Column '${columnReferenceText(column)}' resolves to multiple outputs in the referenced source.`
+                };
+            }
+            return matches[0];
+        }
+        const matches = [];
+        for (const binding of bindings) {
+            const matchCount = this.getOutputColumnMatchCount(contextRoot, binding, columnName);
+            if (matchCount > 1) {
+                return {
+                    code: "AMBIGUOUS_COLUMN_REFERENCE",
+                    reason: `Column '${columnName}' resolves to multiple outputs in source '${binding.alias}'.`
+                };
+            }
+            if (matchCount === 1) {
+                matches.push(binding);
+            }
+        }
+        if (matches.length !== 1) {
+            return {
+                code: "AMBIGUOUS_COLUMN_REFERENCE",
+                reason: matches.length === 0
+                    ? `Column '${columnName}' is not uniquely resolvable to a safe upstream source.`
+                    : `Column '${columnName}' is ambiguous across source query blocks.`
+            };
+        }
+        return matches[0];
+    }
+    resolveUpstreamQuery(root, binding, references) {
+        const source = binding.source.datasource;
+        if (source instanceof SubQuerySource) {
+            if (source.query instanceof SimpleSelectQuery) {
+                return {
+                    kind: "simple",
+                    query: source.query,
+                    scopeId: `subquery:${binding.alias}`,
+                    sourceBinding: binding
+                };
+            }
+            if (source.query instanceof BinarySelectQuery) {
+                return this.resolveUnionTarget(root, source.query, `subquery:${binding.alias}`, references);
+            }
+            return {
+                code: "UNION_BOUNDARY",
+                reason: "Predicate would need distribution into a UNION or non-simple subquery, which is unsupported."
+            };
+        }
+        if (!(source instanceof TableSource)) {
+            return {
+                code: "UNSUPPORTED_SOURCE",
+                reason: "Only CTE and simple derived-table sources can receive moved static predicates."
+            };
+        }
+        const cteName = source.table.name;
+        const commonTable = this.findCte(root, cteName);
+        if (!commonTable) {
+            return {
+                code: "NO_SAFE_UPSTREAM_QUERY",
+                reason: "The referenced source is a base table, so there is no upstream query block to move into."
+            };
+        }
+        const referenceCount = this.countTableSourceReferences(root, cteName);
+        if (referenceCount !== 1) {
+            return {
+                code: "CTE_REUSE_UNSUPPORTED",
+                reason: `CTE '${cteName}' is referenced ${referenceCount} times; moving a predicate into it may affect other consumers.`
+            };
+        }
+        if (commonTable.query instanceof BinarySelectQuery) {
+            return this.resolveUnionTarget(root, commonTable.query, `cte:${commonTable.getSourceAliasName()}`, references);
+        }
+        if (!(commonTable.query instanceof SimpleSelectQuery)) {
+            return {
+                code: "UNSUPPORTED_CTE_QUERY",
+                reason: "Writable or non-select CTE bodies are not moved into by static predicate placement."
+            };
+        }
+        return {
+            kind: "simple",
+            query: commonTable.query,
+            scopeId: `cte:${commonTable.getSourceAliasName()}`,
+            sourceBinding: binding,
+            cteName: commonTable.getSourceAliasName()
+        };
+    }
+    resolveUnionTarget(root, query, scopeId, references) {
+        const branches = this.collectUnionBranches(query);
+        if ("code" in branches) {
+            return branches;
+        }
+        const outputIndexes = new Map();
+        for (const reference of references) {
+            const outputIndex = this.resolveUnionOutputIndex(root, branches[0], reference.column.name);
+            if ("code" in outputIndex) {
+                return outputIndex;
+            }
+            outputIndexes.set(reference, outputIndex.index);
+        }
+        const branchTargets = [];
+        for (const branch of branches) {
+            const targetColumns = [];
+            for (const [reference, outputIndex] of outputIndexes.entries()) {
+                const targetColumn = this.resolveTargetColumnByOutputIndex(root, branch, outputIndex, reference);
+                if ("code" in targetColumn) {
+                    return targetColumn;
+                }
+                targetColumns.push(targetColumn);
+            }
+            branchTargets.push(this.resolveDeepestBranchTarget(root, branch, targetColumns));
+        }
+        return {
+            kind: "union",
+            scopeId,
+            branches: branchTargets
+        };
+    }
+    resolveTargetColumns(root, query, references) {
+        const resolved = [];
+        for (const reference of references) {
+            const matches = this.collectSelectOutputs(root, query).filter(item => normalizeIdentifier(item.name) === normalizeIdentifier(reference.column.name));
+            if (matches.length !== 1) {
+                return {
+                    code: "AMBIGUOUS_TARGET_COLUMN",
+                    reason: matches.length === 0
+                        ? `Target query does not expose '${reference.column.name}' as a direct output column.`
+                        : `Target query exposes multiple '${reference.column.name}' columns.`
+                };
+            }
+            const value = matches[0].value;
+            if (!(value instanceof ColumnReference)) {
+                return {
+                    code: "EXPRESSION_OUTPUT_UNSUPPORTED",
+                    reason: `Target output '${reference.column.name}' is an expression, not a direct column reference.`
+                };
+            }
+            const sourceResolution = this.verifyColumnResolvableInQuery(query, value);
+            if (sourceResolution) {
+                return sourceResolution;
+            }
+            resolved.push({
+                sourceColumn: reference,
+                targetColumn: value
+            });
+        }
+        return resolved;
+    }
+    resolveDeepestBranchTarget(contextRoot, query, targetColumns, visited = new Set()) {
+        if (visited.has(query) || targetColumns.length === 0) {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        const nextVisited = new Set(visited);
+        nextVisited.add(query);
+        const bindings = [];
+        for (const item of targetColumns) {
+            const binding = this.resolveSourceBinding(contextRoot, query, item.targetColumn);
+            if ("code" in binding) {
+                return { query, targetColumns: [...targetColumns] };
+            }
+            if (!bindings.some(existing => existing.source === binding.source)) {
+                bindings.push(binding);
+            }
+        }
+        if (bindings.length !== 1) {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        const binding = bindings[0];
+        const nullableSide = query.fromClause
+            ? this.findNullableSideBoundary(query.fromClause, binding)
+            : null;
+        if (nullableSide) {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        const upstream = this.resolveUpstreamQuery(contextRoot, binding, targetColumns.map(item => item.targetColumn));
+        if ("code" in upstream || upstream.kind === "union") {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        const upstreamColumns = this.resolveTargetColumns(contextRoot, upstream.query, targetColumns.map(item => item.targetColumn));
+        if ("code" in upstreamColumns) {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        const placement = this.resolveTargetPlacement(upstream.query, upstreamColumns);
+        if ("code" in placement) {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        const rebasedColumns = upstreamColumns.map((item, index) => ({
+            sourceColumn: targetColumns[index].sourceColumn,
+            targetColumn: item.targetColumn
+        }));
+        return this.resolveDeepestBranchTarget(contextRoot, upstream.query, rebasedColumns, nextVisited);
+    }
+    verifyColumnResolvableInQuery(query, column) {
+        if (!query.fromClause) {
+            return {
+                code: "NO_TARGET_FROM_CLAUSE",
+                reason: "Target query has no FROM clause where the moved column can be resolved."
+            };
+        }
+        const bindings = this.getSourceBindings(query.fromClause);
+        const namespace = normalizeIdentifier(column.getNamespace());
+        if (namespace) {
+            const matches = bindings.filter(binding => normalizeIdentifier(binding.alias) === namespace);
+            return matches.length === 1
+                ? null
+                : {
+                    code: "AMBIGUOUS_TARGET_COLUMN",
+                    reason: `Target column '${columnReferenceText(column)}' is not uniquely resolvable in the destination query.`
+                };
+        }
+        if (bindings.length === 1) {
+            return null;
+        }
+        return {
+            code: "AMBIGUOUS_TARGET_COLUMN",
+            reason: `Unqualified target column '${column.column.name}' is ambiguous in a multi-source destination query.`
+        };
+    }
+    isGroupKeyColumn(query, column) {
+        const groupBy = query.groupByClause;
+        if (!groupBy || groupBy.mode || groupBy.grouping.length === 0) {
+            return false;
+        }
+        return groupBy.grouping.some(grouping => {
+            const candidate = unwrapParens(grouping);
+            return candidate instanceof ColumnReference
+                && this.sameResolvableColumnInQuery(query, candidate, column);
+        });
+    }
+    sameResolvableColumnInQuery(query, left, right) {
+        if (sameColumnReference(left, right)) {
+            return true;
+        }
+        if (normalizeIdentifier(left.column.name) !== normalizeIdentifier(right.column.name)) {
+            return false;
+        }
+        const leftSource = this.resolveColumnSourceAlias(query, left);
+        const rightSource = this.resolveColumnSourceAlias(query, right);
+        return leftSource !== null && leftSource === rightSource;
+    }
+    resolveColumnSourceAlias(query, column) {
+        if (!query.fromClause) {
+            return null;
+        }
+        const bindings = this.getSourceBindings(query.fromClause);
+        const namespace = normalizeIdentifier(column.getNamespace());
+        if (namespace) {
+            const matches = bindings.filter(binding => normalizeIdentifier(binding.alias) === namespace);
+            return matches.length === 1 ? normalizeIdentifier(matches[0].alias) : null;
+        }
+        return bindings.length === 1 ? normalizeIdentifier(bindings[0].alias) : null;
+    }
+    rebasePredicate(expression, targetColumns, options) {
+        const cloned = cloneValueComponent(expression, options);
+        const visitSelect = (query, inheritedLocalAliases) => {
+            var _a, _b, _c, _d;
+            if (!(query instanceof SimpleSelectQuery)) {
+                return;
+            }
+            const localAliases = new Set(inheritedLocalAliases);
+            for (const alias of this.collectSourceAliases(query)) {
+                localAliases.add(alias);
+            }
+            query.selectClause.items.forEach(item => visit(item.value, localAliases));
+            for (const join of (_b = (_a = query.fromClause) === null || _a === void 0 ? void 0 : _a.joins) !== null && _b !== void 0 ? _b : []) {
+                if (join.condition) {
+                    visit(join.condition.condition, localAliases);
+                }
+                const source = join.source.datasource;
+                if (source instanceof SubQuerySource) {
+                    visitSelect(source.query, localAliases);
+                }
+            }
+            if (query.whereClause) {
+                visit(query.whereClause.condition, localAliases);
+            }
+            if (query.havingClause) {
+                visit(query.havingClause.condition, localAliases);
+            }
+            for (const cte of (_d = (_c = query.withClause) === null || _c === void 0 ? void 0 : _c.tables) !== null && _d !== void 0 ? _d : []) {
+                if (cte.query instanceof SimpleSelectQuery || cte.query instanceof BinarySelectQuery) {
+                    visitSelect(cte.query, localAliases);
+                }
+            }
+        };
+        const visit = (value, localAliases) => {
+            const candidate = unwrapParens(value);
+            if (candidate instanceof ColumnReference) {
+                const namespace = normalizeIdentifier(candidate.getNamespace());
+                if (namespace && localAliases.has(namespace)) {
+                    return;
+                }
+                const target = targetColumns.find(item => sameColumnReference(candidate, item.sourceColumn));
+                if (target) {
+                    candidate.qualifiedName = cloneColumnReference(target.targetColumn).qualifiedName;
+                }
+                return;
+            }
+            if (candidate instanceof BinaryExpression) {
+                visit(candidate.left, localAliases);
+                visit(candidate.right, localAliases);
+                return;
+            }
+            if (candidate instanceof UnaryExpression) {
+                visit(candidate.expression, localAliases);
+                return;
+            }
+            if (candidate instanceof InlineQuery) {
+                visitSelect(candidate.selectQuery, localAliases);
+                return;
+            }
+            if (candidate instanceof FunctionCall) {
+                if (candidate.argument) {
+                    visit(candidate.argument, localAliases);
+                }
+                if (candidate.filterCondition) {
+                    visit(candidate.filterCondition, localAliases);
+                }
+                return;
+            }
+            if (candidate instanceof CastExpression) {
+                visit(candidate.input, localAliases);
+                return;
+            }
+            if (candidate instanceof CaseExpression) {
+                if (candidate.condition) {
+                    visit(candidate.condition, localAliases);
+                }
+                for (const pair of candidate.switchCase.cases) {
+                    visit(pair.key, localAliases);
+                    visit(pair.value, localAliases);
+                }
+                if (candidate.switchCase.elseValue) {
+                    visit(candidate.switchCase.elseValue, localAliases);
+                }
+                return;
+            }
+            if (candidate instanceof BetweenExpression) {
+                visit(candidate.expression, localAliases);
+                visit(candidate.lower, localAliases);
+                visit(candidate.upper, localAliases);
+                return;
+            }
+            if (candidate instanceof JsonPredicateExpression) {
+                visit(candidate.expression, localAliases);
+                return;
+            }
+            if (candidate instanceof ArrayExpression) {
+                visit(candidate.expression, localAliases);
+                return;
+            }
+            if (candidate instanceof ValueList) {
+                candidate.values.forEach(item => visit(item, localAliases));
+                return;
+            }
+            if (candidate instanceof TupleExpression) {
+                candidate.values.forEach(item => visit(item, localAliases));
+                return;
+            }
+            if (candidate instanceof TypeValue && candidate.argument) {
+                visit(candidate.argument, localAliases);
+            }
+        };
+        visit(cloned, new Set());
+        return cloned;
+    }
+    getSourceBindings(fromClause) {
+        var _a, _b, _c;
+        const bindings = [{
+                source: fromClause.source,
+                alias: (_a = fromClause.source.getAliasName()) !== null && _a !== void 0 ? _a : "",
+                join: null,
+                joinIndex: -1,
+                isPrimary: true
+            }];
+        for (let index = 0; index < ((_b = fromClause.joins) !== null && _b !== void 0 ? _b : []).length; index += 1) {
+            const join = fromClause.joins[index];
+            bindings.push({
+                source: join.source,
+                alias: (_c = join.source.getAliasName()) !== null && _c !== void 0 ? _c : "",
+                join,
+                joinIndex: index,
+                isPrimary: false
+            });
+        }
+        return bindings;
+    }
+    findNullableSideBoundary(fromClause, binding) {
+        var _a;
+        const joins = (_a = fromClause.joins) !== null && _a !== void 0 ? _a : [];
+        if (binding.isPrimary) {
+            return this.hasLaterJoinThatNullsPriorSources(joins, -1)
+                ? {
+                    code: "OUTER_JOIN_NULLABLE_SIDE",
+                    reason: "Predicate crosses OUTER JOIN nullable side; moving it may change semantics."
+                }
+                : null;
+        }
+        const join = binding.join;
+        if (!join) {
+            return null;
+        }
+        const joinType = join.joinType.value.toLowerCase();
+        if (joinType.includes("left")) {
+            return {
+                code: "OUTER_JOIN_NULLABLE_SIDE",
+                reason: "Predicate crosses LEFT JOIN nullable side; moving it may change semantics."
+            };
+        }
+        if (joinType.includes("full")) {
+            return {
+                code: "OUTER_JOIN_NULLABLE_SIDE",
+                reason: "Predicate crosses FULL JOIN nullable side; moving it may change semantics."
+            };
+        }
+        if (this.hasLaterJoinThatNullsPriorSources(joins, binding.joinIndex)) {
+            return {
+                code: "OUTER_JOIN_NULLABLE_SIDE",
+                reason: "Predicate crosses later RIGHT/FULL JOIN nullable side; moving it may change semantics."
+            };
+        }
+        return null;
+    }
+    hasLaterJoinThatNullsPriorSources(joins, sourceJoinIndex) {
+        return joins
+            .slice(sourceJoinIndex + 1)
+            .some(join => {
+            const joinType = join.joinType.value.toLowerCase();
+            return joinType.includes("right") || joinType.includes("full");
+        });
+    }
+    hasOuterJoin(fromClause) {
+        var _a;
+        return ((_a = fromClause.joins) !== null && _a !== void 0 ? _a : []).some(join => {
+            const joinType = join.joinType.value.toLowerCase();
+            return joinType.includes("left") || joinType.includes("right") || joinType.includes("full") || joinType.includes("outer");
+        });
+    }
+    hasDistinctOnBoundary(query) {
+        return query.selectClause.distinct instanceof DistinctOn;
+    }
+    hasOrdinaryDistinct(query) {
+        return query.selectClause.distinct !== null && !this.hasDistinctOnBoundary(query);
+    }
+    getOutputColumnMatchCount(root, binding, columnName) {
+        const target = this.resolveSourceQueryForColumns(root, binding.source);
+        if (!target) {
+            return 0;
+        }
+        if (target instanceof BinarySelectQuery) {
+            const branches = this.collectUnionBranches(target);
+            if ("code" in branches) {
+                return 0;
+            }
+            return this.collectSelectOutputs(root, branches[0]).filter(item => normalizeIdentifier(item.name) === normalizeIdentifier(columnName)).length;
+        }
+        if (!(target instanceof SimpleSelectQuery)) {
+            return 0;
+        }
+        return this.collectSelectOutputs(root, target).filter(item => normalizeIdentifier(item.name) === normalizeIdentifier(columnName)).length;
+    }
+    collectUnionBranches(query) {
+        const branches = [];
+        const visit = (select) => {
+            var _a;
+            if (select instanceof SimpleSelectQuery) {
+                branches.push(select);
+                return null;
+            }
+            if (!(select instanceof BinarySelectQuery)) {
+                return {
+                    code: "UNION_BOUNDARY",
+                    reason: "Predicate would need distribution into a non-simple UNION branch, which is unsupported."
+                };
+            }
+            const operator = select.operator.value.trim().toLowerCase();
+            if (operator !== "union" && operator !== "union all") {
+                return {
+                    code: "UNION_BOUNDARY",
+                    reason: `Predicate would need distribution through '${select.operator.value}', which is unsupported.`
+                };
+            }
+            return (_a = visit(select.left)) !== null && _a !== void 0 ? _a : visit(select.right);
+        };
+        const skip = visit(query);
+        return skip !== null && skip !== void 0 ? skip : branches;
+    }
+    resolveUnionOutputIndex(root, firstBranch, outputColumnName) {
+        const matches = [];
+        this.collectSelectOutputs(root, firstBranch).forEach((item, index) => {
+            if (normalizeIdentifier(item.name) === normalizeIdentifier(outputColumnName)) {
+                matches.push(index);
+            }
+        });
+        if (matches.length !== 1) {
+            return {
+                code: "AMBIGUOUS_TARGET_COLUMN",
+                reason: matches.length === 0
+                    ? `UNION output does not expose '${outputColumnName}' from its first branch.`
+                    : `UNION first branch exposes multiple '${outputColumnName}' columns.`
+            };
+        }
+        return { index: matches[0] };
+    }
+    resolveTargetColumnByOutputIndex(root, query, outputIndex, sourceColumn) {
+        const output = this.collectSelectOutputs(root, query)[outputIndex];
+        if (!output) {
+            return {
+                code: "UNION_COLUMN_MISMATCH",
+                reason: `UNION branch does not expose column '${sourceColumn.column.name}' at output position ${outputIndex + 1}.`
+            };
+        }
+        if (!(output.value instanceof ColumnReference)) {
+            return {
+                code: "EXPRESSION_OUTPUT_UNSUPPORTED",
+                reason: `UNION branch output at position ${outputIndex + 1} for '${sourceColumn.column.name}' is an expression, not a direct column reference.`
+            };
+        }
+        const sourceResolution = this.verifyColumnResolvableInQuery(query, output.value);
+        if (sourceResolution) {
+            return sourceResolution;
+        }
+        return {
+            sourceColumn,
+            targetColumn: output.value
+        };
+    }
+    collectSelectOutputs(root, query) {
+        var _a, _b, _c, _d;
+        const commonTables = [
+            ...((_b = (_a = query.withClause) === null || _a === void 0 ? void 0 : _a.tables) !== null && _b !== void 0 ? _b : []),
+            ...((_d = (_c = root.withClause) === null || _c === void 0 ? void 0 : _c.tables) !== null && _d !== void 0 ? _d : [])
+        ];
+        const collector = new SelectOutputCollector(null, commonTables.length > 0 ? commonTables : null);
+        return collector.collect(query);
+    }
+    resolveSourceQueryForColumns(root, source) {
+        var _a;
+        if (source.datasource instanceof SubQuerySource) {
+            return source.datasource.query;
+        }
+        if (source.datasource instanceof TableSource) {
+            const cteQuery = (_a = this.findCte(root, source.datasource.table.name)) === null || _a === void 0 ? void 0 : _a.query;
+            return cteQuery instanceof SimpleSelectQuery || cteQuery instanceof BinarySelectQuery
+                ? cteQuery
+                : null;
+        }
+        return null;
+    }
+    findCte(root, name) {
+        var _a, _b;
+        const normalized = normalizeIdentifier(name);
+        const matches = ((_b = (_a = root.withClause) === null || _a === void 0 ? void 0 : _a.tables) !== null && _b !== void 0 ? _b : [])
+            .filter(table => normalizeIdentifier(table.getSourceAliasName()) === normalized);
+        return matches.length === 1 ? matches[0] : null;
+    }
+    countTableSourceReferences(query, tableName) {
+        const normalized = normalizeIdentifier(tableName);
+        let count = 0;
+        const visitSelect = (select) => {
+            var _a, _b;
+            if (select instanceof BinarySelectQuery) {
+                visitSelect(select.left);
+                visitSelect(select.right);
+                return;
+            }
+            if (!(select instanceof SimpleSelectQuery)) {
+                return;
+            }
+            if (select.fromClause) {
+                for (const binding of this.getSourceBindings(select.fromClause)) {
+                    const source = binding.source.datasource;
+                    if (source instanceof TableSource && normalizeIdentifier(source.table.name) === normalized) {
+                        count += 1;
+                    }
+                    if (source instanceof SubQuerySource) {
+                        visitSelect(source.query);
+                    }
+                }
+            }
+            for (const cte of (_b = (_a = select.withClause) === null || _a === void 0 ? void 0 : _a.tables) !== null && _b !== void 0 ? _b : []) {
+                if (cte.query instanceof SimpleSelectQuery || cte.query instanceof BinarySelectQuery) {
+                    visitSelect(cte.query);
+                }
+            }
+        };
+        visitSelect(query);
+        return count;
+    }
+    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 alias = source.getAliasName();
+            if (alias) {
+                aliases.add(normalizeIdentifier(alias));
+            }
+        }
+        return aliases;
+    }
+    collectRootColumnReferences(root, expression) {
+        const references = [];
+        const rootAliases = this.collectSourceAliases(root);
+        const visitSelect = (query, inheritedLocalAliases) => {
+            var _a, _b, _c, _d;
+            if (!(query instanceof SimpleSelectQuery)) {
+                return;
+            }
+            const localAliases = new Set(inheritedLocalAliases);
+            for (const alias of this.collectSourceAliases(query)) {
+                localAliases.add(alias);
+            }
+            query.selectClause.items.forEach(item => visit(item.value, localAliases));
+            for (const join of (_b = (_a = query.fromClause) === null || _a === void 0 ? void 0 : _a.joins) !== null && _b !== void 0 ? _b : []) {
+                if (join.condition) {
+                    visit(join.condition.condition, localAliases);
+                }
+                const source = join.source.datasource;
+                if (source instanceof SubQuerySource) {
+                    visitSelect(source.query, localAliases);
+                }
+            }
+            if (query.whereClause) {
+                visit(query.whereClause.condition, localAliases);
+            }
+            if (query.havingClause) {
+                visit(query.havingClause.condition, localAliases);
+            }
+            for (const cte of (_d = (_c = query.withClause) === null || _c === void 0 ? void 0 : _c.tables) !== null && _d !== void 0 ? _d : []) {
+                if (cte.query instanceof SimpleSelectQuery || cte.query instanceof BinarySelectQuery) {
+                    visitSelect(cte.query, localAliases);
+                }
+            }
+        };
+        const collect = (reference) => {
+            if (!references.some(existing => sameColumnReference(existing, reference))) {
+                references.push(reference);
+            }
+        };
+        const visit = (value, localAliases) => {
+            const candidate = unwrapParens(value);
+            if (candidate instanceof ColumnReference) {
+                const namespace = normalizeIdentifier(candidate.getNamespace());
+                if (namespace) {
+                    if (rootAliases.has(namespace) && !localAliases.has(namespace)) {
+                        collect(candidate);
+                    }
+                    return;
+                }
+                if (localAliases.size === 0) {
+                    collect(candidate);
+                }
+                return;
+            }
+            if (candidate instanceof BinaryExpression) {
+                visit(candidate.left, localAliases);
+                visit(candidate.right, localAliases);
+                return;
+            }
+            if (candidate instanceof UnaryExpression) {
+                visit(candidate.expression, localAliases);
+                return;
+            }
+            if (candidate instanceof InlineQuery) {
+                visitSelect(candidate.selectQuery, localAliases);
+                return;
+            }
+            if (candidate instanceof FunctionCall) {
+                if (candidate.argument) {
+                    visit(candidate.argument, localAliases);
+                }
+                if (candidate.filterCondition) {
+                    visit(candidate.filterCondition, localAliases);
+                }
+                return;
+            }
+            if (candidate instanceof CastExpression) {
+                visit(candidate.input, localAliases);
+                return;
+            }
+            if (candidate instanceof CaseExpression) {
+                if (candidate.condition) {
+                    visit(candidate.condition, localAliases);
+                }
+                for (const pair of candidate.switchCase.cases) {
+                    visit(pair.key, localAliases);
+                    visit(pair.value, localAliases);
+                }
+                if (candidate.switchCase.elseValue) {
+                    visit(candidate.switchCase.elseValue, localAliases);
+                }
+                return;
+            }
+            if (candidate instanceof BetweenExpression) {
+                visit(candidate.expression, localAliases);
+                visit(candidate.lower, localAliases);
+                visit(candidate.upper, localAliases);
+                return;
+            }
+            if (candidate instanceof JsonPredicateExpression) {
+                visit(candidate.expression, localAliases);
+                return;
+            }
+            if (candidate instanceof ArrayExpression) {
+                visit(candidate.expression, localAliases);
+                return;
+            }
+            if (candidate instanceof ArrayQueryExpression) {
+                visitSelect(candidate.query, localAliases);
+                return;
+            }
+            if (candidate instanceof ValueList) {
+                candidate.values.forEach(item => visit(item, localAliases));
+                return;
+            }
+            if (candidate instanceof TupleExpression) {
+                candidate.values.forEach(item => visit(item, localAliases));
+                return;
+            }
+            if (candidate instanceof TypeValue && candidate.argument) {
+                visit(candidate.argument, localAliases);
+            }
+        };
+        visit(expression, new Set());
+        return references;
+    }
+    hasWindowUsage(query) {
+        if (query.windowClause) {
+            return true;
+        }
+        let found = false;
+        const visit = (value) => {
+            if (found) {
+                return;
+            }
+            const candidate = unwrapParens(value);
+            if (candidate instanceof FunctionCall) {
+                if (candidate.over) {
+                    found = true;
+                    return;
+                }
+                if (candidate.argument) {
+                    visit(candidate.argument);
+                }
+                if (candidate.filterCondition) {
+                    visit(candidate.filterCondition);
+                }
+                return;
+            }
+            if (candidate instanceof BinaryExpression) {
+                visit(candidate.left);
+                visit(candidate.right);
+                return;
+            }
+            if (candidate instanceof UnaryExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof CastExpression) {
+                visit(candidate.input);
+                return;
+            }
+            if (candidate instanceof CaseExpression) {
+                if (candidate.condition) {
+                    visit(candidate.condition);
+                }
+                for (const pair of candidate.switchCase.cases) {
+                    visit(pair.key);
+                    visit(pair.value);
+                }
+                if (candidate.switchCase.elseValue) {
+                    visit(candidate.switchCase.elseValue);
+                }
+                return;
+            }
+            if (candidate instanceof ValueList) {
+                candidate.values.forEach(visit);
+            }
+        };
+        query.selectClause.items.forEach(item => visit(item.value));
+        return found;
+    }
+    collectParameterNames(expression) {
+        const names = [];
+        const visitSelect = (query) => {
+            var _a, _b, _c, _d;
+            if (query instanceof BinarySelectQuery) {
+                visitSelect(query.left);
+                visitSelect(query.right);
+                return;
+            }
+            if (!(query instanceof SimpleSelectQuery)) {
+                return;
+            }
+            query.selectClause.items.forEach(item => visit(item.value));
+            for (const join of (_b = (_a = query.fromClause) === null || _a === void 0 ? void 0 : _a.joins) !== null && _b !== void 0 ? _b : []) {
+                if (join.condition) {
+                    visit(join.condition.condition);
+                }
+                const source = join.source.datasource;
+                if (source instanceof SubQuerySource) {
+                    visitSelect(source.query);
+                }
+            }
+            if (query.whereClause) {
+                visit(query.whereClause.condition);
+            }
+            if (query.havingClause) {
+                visit(query.havingClause.condition);
+            }
+            for (const cte of (_d = (_c = query.withClause) === null || _c === void 0 ? void 0 : _c.tables) !== null && _d !== void 0 ? _d : []) {
+                if (cte.query instanceof SimpleSelectQuery || cte.query instanceof BinarySelectQuery) {
+                    visitSelect(cte.query);
+                }
+            }
+        };
+        const visit = (value) => {
+            const candidate = unwrapParens(value);
+            if (candidate instanceof ParameterExpression) {
+                appendUnique(names, candidate.name.value);
+                return;
+            }
+            if (candidate instanceof BinaryExpression) {
+                visit(candidate.left);
+                visit(candidate.right);
+                return;
+            }
+            if (candidate instanceof UnaryExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof InlineQuery) {
+                visitSelect(candidate.selectQuery);
+                return;
+            }
+            if (candidate instanceof ArrayQueryExpression) {
+                visitSelect(candidate.query);
+                return;
+            }
+            if (candidate instanceof FunctionCall) {
+                if (candidate.argument) {
+                    visit(candidate.argument);
+                }
+                if (candidate.filterCondition) {
+                    visit(candidate.filterCondition);
+                }
+                return;
+            }
+            if (candidate instanceof CastExpression) {
+                visit(candidate.input);
+                return;
+            }
+            if (candidate instanceof CaseExpression) {
+                if (candidate.condition) {
+                    visit(candidate.condition);
+                }
+                for (const pair of candidate.switchCase.cases) {
+                    visit(pair.key);
+                    visit(pair.value);
+                }
+                if (candidate.switchCase.elseValue) {
+                    visit(candidate.switchCase.elseValue);
+                }
+                return;
+            }
+            if (candidate instanceof BetweenExpression) {
+                visit(candidate.expression);
+                visit(candidate.lower);
+                visit(candidate.upper);
+                return;
+            }
+            if (candidate instanceof JsonPredicateExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof ArrayExpression) {
+                visit(candidate.expression);
+                return;
+            }
+            if (candidate instanceof ValueList) {
+                candidate.values.forEach(visit);
+                return;
+            }
+            if (candidate instanceof TupleExpression) {
+                candidate.values.forEach(visit);
+                return;
+            }
+            if (candidate instanceof TypeValue && candidate.argument) {
+                visit(candidate.argument);
+            }
+        };
+        visit(expression);
+        return names;
+    }
+    makeSkipped(expression, draft, options) {
+        return Object.assign({ predicateSql: formatSqlComponent(expression, options), scopeId: "scope:root" }, draft);
+    }
+    buildResult(params) {
+        return {
+            ok: params.errors.length === 0,
+            sql: params.sql,
+            query: params.query,
+            applied: params.applied,
+            skipped: params.skipped,
+            warnings: params.warnings,
+            errors: params.errors,
+            safety: {
+                mode: "safe_only",
+                unsafeRewriteApplied: false,
+                dryRun: params.dryRun,
+                formatterGeneratedSource: params.formatterGeneratedSource
+            },
+            staticPredicateMoves: params.applied
+        };
+    }
+}
+export const planStaticPredicatePlacement = (input, options = {}) => {
+    return new StaticPredicatePlacementOptimizer().plan(input, options);
+};
+export const optimizeStaticPredicatePlacement = (input, options = {}) => {
+    return new StaticPredicatePlacementOptimizer().optimize(input, options);
+};
+//# sourceMappingURL=StaticPredicatePlacementOptimizer.js.map