rawsql-ts 0.28.0 → 0.30.0

package/dist/transformers/ParameterConditionPlacementOptimizer.js

@@ -5,71 +5,12 @@ const Clause_1 = require("../models/Clause");
 const SelectQuery_1 = require("../models/SelectQuery");
 const ValueComponent_1 = require("../models/ValueComponent");
 const SelectQueryParser_1 = require("../parsers/SelectQueryParser");
-const ValueParser_1 = require("../parsers/ValueParser");
 const SqlComponentFormatter_1 = require("./SqlComponentFormatter");
 const SelectOutputCollector_1 = require("./SelectOutputCollector");
+const TopLevelAndConditionDeduper_1 = require("./TopLevelAndConditionDeduper");
+const PredicateExpressionUtils_1 = require("./PredicateExpressionUtils");
 const SUPPORTED_OPERATORS = new Set(["=", "<>", "!=", "<", "<=", ">", ">=", "like", "ilike", "in"]);
 const VOLATILE_OR_UNSUPPORTED_FUNCTION_REASON = "Condition 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 ValueComponent_1.ParenExpression) {
-        candidate = candidate.expression;
-    }
-    return candidate;
-};
-const isBinaryOperator = (expression, operator) => {
-    const candidate = unwrapParens(expression);
-    return candidate instanceof ValueComponent_1.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 ValueComponent_1.BinaryExpression(rebuilt, "and", remaining[index]);
-    }
-    query.whereClause = new Clause_1.WhereClause(rebuilt);
-};
-const cloneValueComponent = (expression, options) => {
-    return ValueParser_1.ValueParser.parse((0, SqlComponentFormatter_1.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 ValueComponent_1.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);
-    }
-};
 class ParameterConditionPlacementOptimizer {
     plan(input, options = {}) {
         var _a, _b, _c;
@@ -108,7 +49,7 @@ class ParameterConditionPlacementOptimizer {
         const applied = [];
         const skipped = [];
         const movedTerms = [];
-        for (const term of query.whereClause ? collectTopLevelAndTerms(query.whereClause.condition) : []) {
+        for (const term of query.whereClause ? (0, PredicateExpressionUtils_1.collectTopLevelAndTerms)(query.whereClause.condition) : []) {
             const candidate = this.analyzeCandidate(term, options);
             if (!candidate) {
                 continue;
@@ -123,7 +64,11 @@ class ParameterConditionPlacementOptimizer {
                 continue;
             }
             let appliedReason = "";
-            if (target.kind === "simple") {
+            if (target.kind === "join_on") {
+                this.appendJoinOnCondition(target.join, candidate.expression, options);
+                appliedReason = target.reason;
+            }
+            else if (target.kind === "simple") {
                 const targetColumns = this.resolveTargetColumns(query, target.query, candidate.references);
                 if ("code" in targetColumns) {
                     skipped.push(this.makeSkipped(term, targetColumns, options));
@@ -136,6 +81,7 @@ class ParameterConditionPlacementOptimizer {
                 }
                 const movedCondition = this.rebaseCondition(candidate.expression, targetColumns, options);
                 target.query.appendWhere(movedCondition);
+                (0, TopLevelAndConditionDeduper_1.dedupeWhereTopLevelAndConditions)(target.query, options);
                 appliedReason = placement.reason;
             }
             else {
@@ -156,6 +102,7 @@ class ParameterConditionPlacementOptimizer {
                 for (const branch of target.branches) {
                     const movedCondition = this.rebaseCondition(candidate.expression, branch.targetColumns, options);
                     branch.query.appendWhere(movedCondition);
+                    (0, TopLevelAndConditionDeduper_1.dedupeWhereTopLevelAndConditions)(branch.query, options);
                 }
                 appliedReason = placements.some(item => /group by/i.test(item.reason))
                     ? "Condition is distributed to every UNION branch by output column position; grouped branches only receive GROUP BY-key predicates."
@@ -169,10 +116,10 @@ class ParameterConditionPlacementOptimizer {
                 toScopeId: target.scopeId,
                 reason: appliedReason,
                 parameterNames: candidate.parameterNames,
-                columnReferences: candidate.references.map(columnReferenceText)
+                columnReferences: candidate.references.map(PredicateExpressionUtils_1.columnReferenceText)
             });
         }
-        rebuildWhereWithoutTerms(query, new Set(movedTerms));
+        (0, PredicateExpressionUtils_1.rebuildWhereWithoutTerms)(query, new Set(movedTerms));
         const sql = applied.length > 0 || (0, SqlComponentFormatter_1.hasSqlComponentFormatOverride)(options)
             ? (0, SqlComponentFormatter_1.formatSqlComponent)(query, options)
             : parsed.sql;
@@ -270,7 +217,7 @@ class ParameterConditionPlacementOptimizer {
             if (found) {
                 return;
             }
-            const candidate = unwrapParens(value);
+            const candidate = (0, PredicateExpressionUtils_1.unwrapParens)(value);
             if (candidate instanceof ValueComponent_1.BinaryExpression) {
                 visit(candidate.left);
                 visit(candidate.right);
@@ -331,7 +278,7 @@ class ParameterConditionPlacementOptimizer {
     findUnsupportedParameterPredicateShape(expression) {
         const visit = (value) => {
             var _a;
-            const candidate = unwrapParens(value);
+            const candidate = (0, PredicateExpressionUtils_1.unwrapParens)(value);
             if (candidate instanceof ValueComponent_1.BetweenExpression) {
                 return null;
             }
@@ -354,16 +301,22 @@ class ParameterConditionPlacementOptimizer {
                 }
                 return null;
             }
+            if (candidate instanceof ValueComponent_1.UnaryExpression) {
+                const operator = candidate.operator.value.trim().toLowerCase();
+                if (operator === "not") {
+                    return visit(candidate.expression);
+                }
+            }
             return {
                 code: "UNSUPPORTED_PARAMETER_CONDITION",
-                reason: "Only simple binary, BETWEEN, and whole OR/AND parameter predicates are moved in the safe-only implementation."
+                reason: "Only simple binary, BETWEEN, and whole OR/AND/NOT parameter predicates are moved in the safe-only implementation."
             };
         };
         return visit(expression);
     }
     isSupportedInPredicate(expression) {
-        const left = unwrapParens(expression.left);
-        const right = unwrapParens(expression.right);
+        const left = (0, PredicateExpressionUtils_1.unwrapParens)(expression.left);
+        const right = (0, PredicateExpressionUtils_1.unwrapParens)(expression.right);
         if (!(left instanceof ValueComponent_1.ColumnReference)) {
             return false;
         }
@@ -374,9 +327,10 @@ class ParameterConditionPlacementOptimizer {
             return false;
         }
         return right.values.length > 0
-            && right.values.every(value => unwrapParens(value) instanceof ValueComponent_1.ParameterExpression);
+            && right.values.every(value => (0, PredicateExpressionUtils_1.unwrapParens)(value) instanceof ValueComponent_1.ParameterExpression);
     }
     resolveTarget(root, candidate) {
+        var _a;
         const boundary = this.findRootQueryBoundary(root);
         if (boundary) {
             return boundary;
@@ -404,12 +358,25 @@ class ParameterConditionPlacementOptimizer {
             };
         }
         const binding = bindings[0];
+        if ((_a = binding.join) === null || _a === void 0 ? void 0 : _a.lateral) {
+            return {
+                code: "LATERAL_JOIN_BOUNDARY",
+                reason: "Condition crosses a LATERAL JOIN boundary; moving it may change semantics."
+            };
+        }
         const nullableSide = this.findNullableSideBoundary(root.fromClause, binding);
         if (nullableSide) {
             return nullableSide;
         }
         const upstream = this.resolveUpstreamQuery(root, binding, candidate.references);
         if ("code" in upstream) {
+            if (upstream.code === "NO_SAFE_UPSTREAM_QUERY") {
+                const joinOnTarget = this.resolveBaseTableJoinOnTarget(root, binding);
+                if (!("code" in joinOnTarget)) {
+                    return joinOnTarget;
+                }
+                return joinOnTarget;
+            }
             return upstream;
         }
         return upstream;
@@ -491,10 +458,10 @@ class ParameterConditionPlacementOptimizer {
             };
         }
         const bindings = this.getSourceBindings(fromClause);
-        const namespace = normalizeIdentifier(column.getNamespace());
+        const namespace = column.getNamespace();
         const columnName = column.column.name;
         if (namespace) {
-            const matches = bindings.filter(binding => normalizeIdentifier(binding.alias) === namespace);
+            const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(binding.alias, namespace));
             if (matches.length !== 1) {
                 return {
                     code: "AMBIGUOUS_COLUMN_SOURCE",
@@ -502,16 +469,19 @@ class ParameterConditionPlacementOptimizer {
                 };
             }
             const matchCount = this.getOutputColumnMatchCount(contextRoot, matches[0], columnName);
+            if (matchCount === 0 && this.isBaseTableBinding(contextRoot, matches[0])) {
+                return matches[0];
+            }
             if (matchCount === 0) {
                 return {
                     code: "COLUMN_NOT_AVAILABLE_UPSTREAM",
-                    reason: `Column '${columnReferenceText(column)}' is not a direct output of the referenced source.`
+                    reason: `Column '${(0, PredicateExpressionUtils_1.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.`
+                    reason: `Column '${(0, PredicateExpressionUtils_1.columnReferenceText)(column)}' resolves to multiple outputs in the referenced source.`
                 };
             }
             return matches[0];
@@ -630,7 +600,7 @@ class ParameterConditionPlacementOptimizer {
     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));
+            const matches = this.collectDirectOutputMatches(root, query, reference.column.name);
             if (matches.length !== 1) {
                 return {
                     code: "AMBIGUOUS_TARGET_COLUMN",
@@ -657,6 +627,57 @@ class ParameterConditionPlacementOptimizer {
         }
         return resolved;
     }
+    resolveBaseTableJoinOnTarget(root, binding) {
+        var _a, _b, _c;
+        if (!root.fromClause || !this.isBaseTableBinding(root, binding)) {
+            return {
+                code: "NO_SAFE_UPSTREAM_QUERY",
+                reason: "The referenced source is a base table, so there is no upstream query block to move into."
+            };
+        }
+        if (this.hasOuterJoin(root.fromClause)) {
+            return {
+                code: "OUTER_JOIN_BOUNDARY",
+                reason: "Condition crosses an OUTER JOIN boundary; moving it into JOIN ON may change semantics."
+            };
+        }
+        const join = binding.isPrimary
+            ? (_b = (_a = root.fromClause.joins) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : null
+            : binding.join;
+        if (join === null || join === void 0 ? void 0 : join.lateral) {
+            return {
+                code: "LATERAL_JOIN_BOUNDARY",
+                reason: "Condition crosses a LATERAL JOIN boundary; moving it into JOIN ON may change semantics."
+            };
+        }
+        if (!join || !this.isInnerJoin(join)) {
+            return {
+                code: "NO_SAFE_JOIN_ON_TARGET",
+                reason: "Base-table conditions are moved only into INNER JOIN ON clauses in the safe-only implementation."
+            };
+        }
+        if (!(join.condition instanceof Clause_1.JoinOnClause)) {
+            return {
+                code: "NO_SAFE_JOIN_ON_TARGET",
+                reason: "Base-table conditions are moved only into existing JOIN ON clauses, not USING or conditionless joins."
+            };
+        }
+        return {
+            kind: "join_on",
+            join,
+            scopeId: `join_on:${(_c = join.source.getAliasName()) !== null && _c !== void 0 ? _c : "unknown"}`,
+            reason: binding.isPrimary
+                ? "Condition references the primary source of an INNER JOIN; it is moved into the first JOIN ON clause."
+                : "Condition references the joined source of an INNER JOIN; it is moved into that JOIN ON clause."
+        };
+    }
+    appendJoinOnCondition(join, expression, options) {
+        if (!(join.condition instanceof Clause_1.JoinOnClause)) {
+            return;
+        }
+        join.condition.condition = new ValueComponent_1.BinaryExpression(join.condition.condition, "and", (0, PredicateExpressionUtils_1.cloneValueComponent)(expression, options));
+        join.condition.condition = (0, TopLevelAndConditionDeduper_1.dedupeTopLevelAndConditions)(join.condition.condition, options);
+    }
     resolveTargetColumnByOutputIndex(root, query, outputIndex, sourceColumn) {
         const output = this.collectSelectOutputs(root, query)[outputIndex];
         if (!output) {
@@ -665,6 +686,15 @@ class ParameterConditionPlacementOptimizer {
                 reason: `UNION branch does not expose column '${sourceColumn.column.name}' at output position ${outputIndex + 1}.`
             };
         }
+        else if ((0, PredicateExpressionUtils_1.identifiersEqual)(output.name, sourceColumn.column.name)) {
+            const matches = this.collectDirectOutputMatches(root, query, sourceColumn.column.name);
+            if (matches.length > 1) {
+                return {
+                    code: "AMBIGUOUS_TARGET_COLUMN",
+                    reason: `UNION branch exposes multiple '${sourceColumn.column.name}' columns.`
+                };
+            }
+        }
         if (!(output.value instanceof ValueComponent_1.ColumnReference)) {
             return {
                 code: "EXPRESSION_OUTPUT_UNSUPPORTED",
@@ -707,7 +737,10 @@ class ParameterConditionPlacementOptimizer {
             return { query, targetColumns: [...targetColumns] };
         }
         const upstream = this.resolveUpstreamQuery(contextRoot, binding, targetColumns.map(item => item.targetColumn));
-        if ("code" in upstream || upstream.kind === "union") {
+        if ("code" in upstream) {
+            return { query, targetColumns: [...targetColumns] };
+        }
+        if (upstream.kind !== "simple") {
             return { query, targetColumns: [...targetColumns] };
         }
         const upstreamColumns = this.resolveTargetColumns(contextRoot, upstream.query, targetColumns.map(item => item.targetColumn));
@@ -732,14 +765,14 @@ class ParameterConditionPlacementOptimizer {
             };
         }
         const bindings = this.getSourceBindings(query.fromClause);
-        const namespace = normalizeIdentifier(column.getNamespace());
+        const namespace = column.getNamespace();
         if (namespace) {
-            const matches = bindings.filter(binding => normalizeIdentifier(binding.alias) === namespace);
+            const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(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.`
+                    reason: `Target column '${(0, PredicateExpressionUtils_1.columnReferenceText)(column)}' is not uniquely resolvable in the destination query.`
                 };
         }
         if (bindings.length === 1) {
@@ -756,16 +789,16 @@ class ParameterConditionPlacementOptimizer {
             return false;
         }
         return groupBy.grouping.some(grouping => {
-            const candidate = unwrapParens(grouping);
+            const candidate = (0, PredicateExpressionUtils_1.unwrapParens)(grouping);
             return candidate instanceof ValueComponent_1.ColumnReference
                 && this.sameResolvableColumnInQuery(query, candidate, column);
         });
     }
     sameResolvableColumnInQuery(query, left, right) {
-        if (sameColumnReference(left, right)) {
+        if ((0, PredicateExpressionUtils_1.sameColumnReference)(left, right)) {
             return true;
         }
-        if (normalizeIdentifier(left.column.name) !== normalizeIdentifier(right.column.name)) {
+        if (!(0, PredicateExpressionUtils_1.identifiersEqual)(left.column.name, right.column.name)) {
             return false;
         }
         const leftSource = this.resolveColumnSourceAlias(query, left);
@@ -777,19 +810,19 @@ class ParameterConditionPlacementOptimizer {
             return null;
         }
         const bindings = this.getSourceBindings(query.fromClause);
-        const namespace = normalizeIdentifier(column.getNamespace());
+        const namespace = column.getNamespace();
         if (namespace) {
-            const matches = bindings.filter(binding => normalizeIdentifier(binding.alias) === namespace);
-            return matches.length === 1 ? normalizeIdentifier(matches[0].alias) : null;
+            const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(binding.alias, namespace));
+            return matches.length === 1 ? matches[0].alias : null;
         }
-        return bindings.length === 1 ? normalizeIdentifier(bindings[0].alias) : null;
+        return bindings.length === 1 ? bindings[0].alias : null;
     }
     rebaseCondition(expression, targetColumns, options) {
-        const cloned = cloneValueComponent(expression, options);
+        const cloned = (0, PredicateExpressionUtils_1.cloneValueComponent)(expression, options);
         for (const reference of this.collectColumnReferences(cloned)) {
-            const target = targetColumns.find(item => sameColumnReference(reference, item.sourceColumn));
+            const target = targetColumns.find(item => (0, PredicateExpressionUtils_1.sameColumnReference)(reference, item.sourceColumn));
             if (target) {
-                reference.qualifiedName = cloneColumnReference(target.targetColumn).qualifiedName;
+                reference.qualifiedName = (0, PredicateExpressionUtils_1.cloneColumnReference)(target.targetColumn).qualifiedName;
             }
         }
         return cloned;
@@ -800,33 +833,45 @@ class ParameterConditionPlacementOptimizer {
                 source: fromClause.source,
                 alias: (_a = fromClause.source.getAliasName()) !== null && _a !== void 0 ? _a : "",
                 join: null,
+                joinIndex: -1,
                 isPrimary: true
             }];
-        for (const join of (_b = fromClause.joins) !== null && _b !== void 0 ? _b : []) {
+        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;
     }
+    isBaseTableBinding(root, binding) {
+        const source = binding.source.datasource;
+        return source instanceof Clause_1.TableSource && !this.findCte(root, source.table.name);
+    }
+    isInnerJoin(join) {
+        const joinType = join.joinType.value.trim().toLowerCase();
+        return joinType === "join" || joinType === "inner join";
+    }
     findNullableSideBoundary(fromClause, binding) {
         var _a;
-        if (!binding.join) {
-            const rightOrFull = ((_a = fromClause.joins) !== null && _a !== void 0 ? _a : []).some(join => {
-                const joinType = join.joinType.value.toLowerCase();
-                return joinType.includes("right") || joinType.includes("full");
-            });
-            return rightOrFull
+        const joins = (_a = fromClause.joins) !== null && _a !== void 0 ? _a : [];
+        if (binding.isPrimary) {
+            return this.hasLaterJoinThatNullsPriorSources(joins, -1)
                 ? {
                     code: "OUTER_JOIN_NULLABLE_SIDE",
                     reason: "Condition crosses OUTER JOIN nullable side; moving it may change semantics."
                 }
                 : null;
         }
-        const joinType = binding.join.joinType.value.toLowerCase();
+        const join = binding.join;
+        if (!join) {
+            return null;
+        }
+        const joinType = join.joinType.value.toLowerCase();
         if (joinType.includes("left")) {
             return {
                 code: "OUTER_JOIN_NULLABLE_SIDE",
@@ -839,8 +884,22 @@ class ParameterConditionPlacementOptimizer {
                 reason: "Condition crosses FULL JOIN nullable side; moving it may change semantics."
             };
         }
+        if (this.hasLaterJoinThatNullsPriorSources(joins, binding.joinIndex)) {
+            return {
+                code: "OUTER_JOIN_NULLABLE_SIDE",
+                reason: "Condition 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 => {
@@ -864,12 +923,12 @@ class ParameterConditionPlacementOptimizer {
             if ("code" in branches) {
                 return 0;
             }
-            return this.collectSelectOutputs(root, branches[0]).filter(item => normalizeIdentifier(item.name) === normalizeIdentifier(columnName)).length;
+            return this.collectDirectOutputMatches(root, branches[0], columnName).length;
         }
         if (!(target instanceof SelectQuery_1.SimpleSelectQuery)) {
             return 0;
         }
-        return this.collectSelectOutputs(root, target).filter(item => normalizeIdentifier(item.name) === normalizeIdentifier(columnName)).length;
+        return this.collectDirectOutputMatches(root, target, columnName, true).length;
     }
     collectUnionBranches(query) {
         const branches = [];
@@ -900,7 +959,7 @@ class ParameterConditionPlacementOptimizer {
     resolveUnionOutputIndex(root, firstBranch, outputColumnName) {
         const matches = [];
         this.collectSelectOutputs(root, firstBranch).forEach((item, index) => {
-            if (normalizeIdentifier(item.name) === normalizeIdentifier(outputColumnName)) {
+            if ((0, PredicateExpressionUtils_1.identifiersEqual)(item.name, outputColumnName)) {
                 matches.push(index);
             }
         });
@@ -923,6 +982,98 @@ class ParameterConditionPlacementOptimizer {
         const collector = new SelectOutputCollector_1.SelectOutputCollector(null, commonTables.length > 0 ? commonTables : null);
         return collector.collect(query);
     }
+    collectDirectOutputMatches(root, query, columnName, includeUnprovenPotential = false) {
+        const collectedMatches = this.collectSelectOutputs(root, query).filter(item => (0, PredicateExpressionUtils_1.identifiersEqual)(item.name, columnName));
+        if (collectedMatches.length > 0) {
+            return this.hasExplicitOutputMatch(query, columnName)
+                ? [...collectedMatches, ...this.inferWildcardOutputMatches(root, query, columnName, true)]
+                : collectedMatches;
+        }
+        return this.inferWildcardOutputMatches(root, query, columnName, includeUnprovenPotential);
+    }
+    hasExplicitOutputMatch(query, columnName) {
+        return query.selectClause.items.some(item => {
+            if (item.identifier) {
+                return (0, PredicateExpressionUtils_1.identifiersEqual)(item.identifier.name, columnName);
+            }
+            return item.value instanceof ValueComponent_1.ColumnReference
+                && item.value.column.name !== "*"
+                && (0, PredicateExpressionUtils_1.identifiersEqual)(item.value.column.name, columnName);
+        });
+    }
+    inferWildcardOutputMatches(root, query, columnName, includeUnprovenPotential) {
+        const matches = [];
+        query.selectClause.items.forEach((item, outputIndex) => {
+            if (item.identifier || !(item.value instanceof ValueComponent_1.ColumnReference) || item.value.column.name !== "*") {
+                return;
+            }
+            const targetColumn = this.inferWildcardTargetColumn(root, query, item.value, columnName, includeUnprovenPotential);
+            if (!targetColumn) {
+                return;
+            }
+            if (targetColumn === "ambiguous") {
+                matches.push(this.createInferredOutputColumn(columnName, new ValueComponent_1.ColumnReference(null, columnName), outputIndex), this.createInferredOutputColumn(columnName, new ValueComponent_1.ColumnReference(null, columnName), outputIndex));
+                return;
+            }
+            matches.push(this.createInferredOutputColumn(columnName, targetColumn, outputIndex));
+        });
+        return matches;
+    }
+    inferWildcardTargetColumn(root, query, wildcard, columnName, includeUnprovenPotential) {
+        if (!query.fromClause) {
+            return null;
+        }
+        const bindings = this.getSourceBindings(query.fromClause);
+        if (wildcard.namespaces === null) {
+            if (bindings.length !== 1) {
+                return "ambiguous";
+            }
+            return this.resolveWildcardColumnFromBinding(root, query, bindings[0], columnName, includeUnprovenPotential);
+        }
+        const namespace = wildcard.getNamespace();
+        const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(binding.alias, namespace));
+        if (matches.length === 0) {
+            return null;
+        }
+        return matches.length === 1
+            ? this.resolveWildcardColumnFromBinding(root, query, matches[0], columnName, includeUnprovenPotential)
+            : "ambiguous";
+    }
+    resolveWildcardColumnFromBinding(root, query, binding, columnName, includeUnprovenPotential) {
+        const matches = this.collectSourceOutputMatches(root, query, binding.source, columnName);
+        if (matches.length > 1) {
+            return "ambiguous";
+        }
+        if (matches.length === 1) {
+            const value = matches[0].value;
+            return value instanceof ValueComponent_1.ColumnReference ? value : null;
+        }
+        return includeUnprovenPotential && binding.source.datasource instanceof Clause_1.TableSource
+            ? this.createColumnForBinding(binding, columnName)
+            : null;
+    }
+    collectSourceOutputMatches(root, query, source, columnName) {
+        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_1.SelectOutputCollector(null, commonTables.length > 0 ? commonTables : null);
+        return collector.collect(source).filter(item => (0, PredicateExpressionUtils_1.identifiersEqual)(item.name, columnName));
+    }
+    createColumnForBinding(binding, columnName) {
+        return new ValueComponent_1.ColumnReference(binding.alias ? [binding.alias] : null, columnName);
+    }
+    createInferredOutputColumn(name, value, outputIndex) {
+        return {
+            name,
+            value,
+            outputIndex,
+            sourceAlias: value.getNamespace() || null,
+            sourceName: null,
+            sourceColumnName: name
+        };
+    }
     resolveSourceQueryForColumns(root, source) {
         var _a;
         if (source.datasource instanceof Clause_1.SubQuerySource) {
@@ -938,13 +1089,13 @@ class ParameterConditionPlacementOptimizer {
     }
     findCte(root, name) {
         var _a, _b;
-        const normalized = normalizeIdentifier(name);
+        const normalized = (0, PredicateExpressionUtils_1.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);
+            .filter(table => (0, PredicateExpressionUtils_1.normalizeIdentifier)(table.getSourceAliasName()) === normalized);
         return matches.length === 1 ? matches[0] : null;
     }
     countTableSourceReferences(query, tableName) {
-        const normalized = normalizeIdentifier(tableName);
+        const normalized = (0, PredicateExpressionUtils_1.normalizeIdentifier)(tableName);
         let count = 0;
         const visitSelect = (select) => {
             var _a, _b;
@@ -959,7 +1110,7 @@ class ParameterConditionPlacementOptimizer {
             if (select.fromClause) {
                 for (const binding of this.getSourceBindings(select.fromClause)) {
                     const source = binding.source.datasource;
-                    if (source instanceof Clause_1.TableSource && normalizeIdentifier(source.table.name) === normalized) {
+                    if (source instanceof Clause_1.TableSource && (0, PredicateExpressionUtils_1.normalizeIdentifier)(source.table.name) === normalized) {
                         count += 1;
                     }
                     if (source instanceof Clause_1.SubQuerySource) {
@@ -985,7 +1136,7 @@ class ParameterConditionPlacementOptimizer {
             if (found) {
                 return;
             }
-            const candidate = unwrapParens(value);
+            const candidate = (0, PredicateExpressionUtils_1.unwrapParens)(value);
             if (candidate instanceof ValueComponent_1.FunctionCall) {
                 if (candidate.over) {
                     found = true;
@@ -1035,9 +1186,9 @@ class ParameterConditionPlacementOptimizer {
     collectColumnReferences(expression) {
         const references = [];
         const visit = (value) => {
-            const candidate = unwrapParens(value);
+            const candidate = (0, PredicateExpressionUtils_1.unwrapParens)(value);
             if (candidate instanceof ValueComponent_1.ColumnReference) {
-                if (!references.some(existing => sameColumnReference(existing, candidate))) {
+                if (!references.some(existing => (0, PredicateExpressionUtils_1.sameColumnReference)(existing, candidate))) {
                     references.push(candidate);
                 }
                 return;
@@ -1109,9 +1260,9 @@ class ParameterConditionPlacementOptimizer {
     collectParameterNames(expression) {
         const names = [];
         const visit = (value) => {
-            const candidate = unwrapParens(value);
+            const candidate = (0, PredicateExpressionUtils_1.unwrapParens)(value);
             if (candidate instanceof ValueComponent_1.ParameterExpression) {
-                appendUnique(names, candidate.name.value);
+                (0, PredicateExpressionUtils_1.appendUnique)(names, candidate.name.value);
                 return;
             }
             if (candidate instanceof ValueComponent_1.BinaryExpression) {