rawsql-ts 0.29.0 → 0.30.0

package/dist/src/index.d.ts

@@ -80,6 +80,7 @@ export * from './transformers/SSSQLFilterBuilder';
 export type { FormattableSqlComponent, SqlComponentFormatter, SqlComponentFormatOptions } from './transformers/SqlComponentFormatter';
 export * from './transformers/ConditionOptimization';
 export * from './transformers/ParameterConditionPlacementOptimizer';
+export * from './transformers/PredicateReachabilityAnalyzer';
 export * from './transformers/StaticPredicatePlacementOptimizer';
 export * from './transformers/PruneOptionalConditionBranches';
 export { SchemaInfo, optimizeUnusedLeftJoins, optimizeUnusedLeftJoinsToFixedPoint, optimizeUnusedCtes, optimizeUnusedCtesToFixedPoint } from './transformers/OptimizeUnusedLeftJoins';

package/dist/src/transformers/PredicateExpressionUtils.d.ts

@@ -0,0 +1,16 @@
+import { WhereClause } from "../models/Clause";
+import { BinaryExpression, ColumnReference, ValueComponent } from "../models/ValueComponent";
+import { SqlComponentFormatOptions } from "./SqlComponentFormatter";
+export declare const normalizeIdentifier: (value: string) => string;
+export declare const identifiersEqual: (left: string, right: string) => boolean;
+export declare const unwrapParens: (expression: ValueComponent) => ValueComponent;
+export declare const isBinaryOperator: (expression: ValueComponent, operator: string) => expression is BinaryExpression;
+export declare const collectTopLevelAndTerms: (expression: ValueComponent) => ValueComponent[];
+export declare const rebuildWhereWithoutTerms: (query: {
+    whereClause: WhereClause | null;
+}, termsToRemove: ReadonlySet<ValueComponent>) => void;
+export declare const cloneValueComponent: (expression: ValueComponent, options: SqlComponentFormatOptions) => ValueComponent;
+export declare const cloneColumnReference: (reference: ColumnReference) => ColumnReference;
+export declare const columnReferenceText: (reference: ColumnReference) => string;
+export declare const sameColumnReference: (left: ColumnReference, right: ColumnReference) => boolean;
+export declare const appendUnique: <T>(items: T[], value: T) => void;

package/dist/src/transformers/PredicateReachabilityAnalyzer.d.ts

@@ -0,0 +1,88 @@
+import { SelectQuery, SimpleSelectQuery } from "../models/SelectQuery";
+import { SqlComponentFormatOptions } from "./SqlComponentFormatter";
+export type PredicateReachabilityInput = string | SelectQuery | SimpleSelectQuery;
+export interface PredicateReachabilityOptions extends SqlComponentFormatOptions {
+    cloneInput?: boolean;
+}
+export interface PredicateReachabilityWarning {
+    code: string;
+    message: string;
+    detail?: unknown;
+}
+export interface PredicateReachabilityError {
+    code: string;
+    message: string;
+    detail?: unknown;
+}
+export type PredicateReachabilityMode = "rewrite_safe" | "debug_only";
+export type PredicateReachabilityRelation = "origin" | "direct_output" | "join_equivalence";
+export type PredicateReachabilityProbeKind = "count" | "sample";
+export interface PredicateReachabilityScopeTarget {
+    kind: "scope" | "cte" | "table" | "subquery" | "source";
+    name: string;
+}
+export interface PredicateReachabilityTarget {
+    scopeId: string;
+    relation: PredicateReachabilityRelation;
+    mode: PredicateReachabilityMode;
+    predicateSql: string;
+    via?: readonly string[];
+}
+export interface PredicateReachabilityBlocked {
+    scopeId: string;
+    relation: PredicateReachabilityRelation;
+    code: string;
+    reason: string;
+    via?: readonly string[];
+}
+export interface PredicateReachabilityProbeTarget {
+    scopeId: string;
+    relation: PredicateReachabilityRelation;
+    mode: PredicateReachabilityMode;
+    predicateSql: string;
+    target: PredicateReachabilityScopeTarget;
+    probeKinds: readonly PredicateReachabilityProbeKind[];
+    caution?: string;
+}
+export interface PredicateReachabilityPredicate {
+    predicateSql: string;
+    originScopeId: string;
+    columnReferences: readonly string[];
+    reaches: readonly PredicateReachabilityTarget[];
+    blocked: readonly PredicateReachabilityBlocked[];
+    probeTargets: readonly PredicateReachabilityProbeTarget[];
+}
+export interface PredicateReachabilitySafety {
+    mode: "debug_only";
+    sqlRewritten: false;
+}
+export interface PredicateReachabilityResult {
+    ok: boolean;
+    query: SelectQuery | null;
+    predicates: readonly PredicateReachabilityPredicate[];
+    warnings: readonly PredicateReachabilityWarning[];
+    errors: readonly PredicateReachabilityError[];
+    safety: PredicateReachabilitySafety;
+}
+export declare class PredicateReachabilityAnalyzer {
+    analyze(input: PredicateReachabilityInput, options?: PredicateReachabilityOptions): PredicateReachabilityResult;
+    private analyzeScope;
+    private buildProbeTargets;
+    private describeScopeTarget;
+    private resolveDirectOutputReach;
+    private resolveJoinEquivalenceReach;
+    private collectJoinEqualities;
+    private resolveSourceQuery;
+    private resolveDirectOutputColumn;
+    private collectSelectOutputs;
+    private findCte;
+    private resolveSourceBinding;
+    private resolveSourceBindingFromList;
+    private getSourceBindings;
+    private scopeIdForBinding;
+    private isInnerJoin;
+    private rebasePredicate;
+    private collectOuterColumnReferences;
+    private buildResult;
+}
+export declare const analyzePredicateReachability: (input: PredicateReachabilityInput, options?: PredicateReachabilityOptions) => PredicateReachabilityResult;

package/dist/src/transformers/StaticPredicatePlacementOptimizer.d.ts

@@ -60,6 +60,7 @@ export interface StaticPredicatePlacementResult {
 }
 export declare class StaticPredicatePlacementOptimizer {
     plan(input: StaticPredicatePlacementInput, options?: StaticPredicatePlacementOptions): StaticPredicatePlacementResult;
+    private placePredicatesInScopes;
     optimize(input: StaticPredicatePlacementInput, options?: StaticPredicatePlacementOptions): StaticPredicatePlacementResult;
     private parseInput;
     private analyzeCandidate;
@@ -68,6 +69,7 @@ export declare class StaticPredicatePlacementOptimizer {
     private resolveTarget;
     private findRootQueryBoundary;
     private resolveTargetPlacement;
+    private findNullableSideBoundaryForTargetColumns;
     private resolveSourceBinding;
     private resolveUpstreamQuery;
     private resolveUnionTarget;

package/dist/transformers/ParameterConditionPlacementOptimizer.js

@@ -5,80 +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 isCaseSensitiveIdentifier = (value) => /[A-Z]/.test(value.trim());
-const identifiersEqual = (left, right) => {
-    const trimmedLeft = left.trim();
-    const trimmedRight = right.trim();
-    return isCaseSensitiveIdentifier(trimmedLeft) || isCaseSensitiveIdentifier(trimmedRight)
-        ? trimmedLeft === trimmedRight
-        : trimmedLeft.toLowerCase() === trimmedRight.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 identifiersEqual(left.column.name, right.column.name)
-        && identifiersEqual(left.getNamespace(), right.getNamespace());
-};
-const appendUnique = (items, value) => {
-    if (!items.includes(value)) {
-        items.push(value);
-    }
-};
 class ParameterConditionPlacementOptimizer {
     plan(input, options = {}) {
         var _a, _b, _c;
@@ -117,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;
@@ -184,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;
@@ -285,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);
@@ -346,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;
             }
@@ -383,8 +315,8 @@ class ParameterConditionPlacementOptimizer {
         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;
         }
@@ -395,7 +327,7 @@ 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;
@@ -529,7 +461,7 @@ class ParameterConditionPlacementOptimizer {
         const namespace = column.getNamespace();
         const columnName = column.column.name;
         if (namespace) {
-            const matches = bindings.filter(binding => identifiersEqual(binding.alias, namespace));
+            const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(binding.alias, namespace));
             if (matches.length !== 1) {
                 return {
                     code: "AMBIGUOUS_COLUMN_SOURCE",
@@ -543,13 +475,13 @@ class ParameterConditionPlacementOptimizer {
             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];
@@ -743,7 +675,7 @@ class ParameterConditionPlacementOptimizer {
         if (!(join.condition instanceof Clause_1.JoinOnClause)) {
             return;
         }
-        join.condition.condition = new ValueComponent_1.BinaryExpression(join.condition.condition, "and", cloneValueComponent(expression, options));
+        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) {
@@ -754,7 +686,7 @@ class ParameterConditionPlacementOptimizer {
                 reason: `UNION branch does not expose column '${sourceColumn.column.name}' at output position ${outputIndex + 1}.`
             };
         }
-        else if (identifiersEqual(output.name, sourceColumn.column.name)) {
+        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 {
@@ -835,12 +767,12 @@ class ParameterConditionPlacementOptimizer {
         const bindings = this.getSourceBindings(query.fromClause);
         const namespace = column.getNamespace();
         if (namespace) {
-            const matches = bindings.filter(binding => identifiersEqual(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) {
@@ -857,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 (!identifiersEqual(left.column.name, right.column.name)) {
+        if (!(0, PredicateExpressionUtils_1.identifiersEqual)(left.column.name, right.column.name)) {
             return false;
         }
         const leftSource = this.resolveColumnSourceAlias(query, left);
@@ -880,17 +812,17 @@ class ParameterConditionPlacementOptimizer {
         const bindings = this.getSourceBindings(query.fromClause);
         const namespace = column.getNamespace();
         if (namespace) {
-            const matches = bindings.filter(binding => identifiersEqual(binding.alias, namespace));
+            const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(binding.alias, namespace));
             return matches.length === 1 ? matches[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;
@@ -1027,7 +959,7 @@ class ParameterConditionPlacementOptimizer {
     resolveUnionOutputIndex(root, firstBranch, outputColumnName) {
         const matches = [];
         this.collectSelectOutputs(root, firstBranch).forEach((item, index) => {
-            if (identifiersEqual(item.name, outputColumnName)) {
+            if ((0, PredicateExpressionUtils_1.identifiersEqual)(item.name, outputColumnName)) {
                 matches.push(index);
             }
         });
@@ -1051,7 +983,7 @@ class ParameterConditionPlacementOptimizer {
         return collector.collect(query);
     }
     collectDirectOutputMatches(root, query, columnName, includeUnprovenPotential = false) {
-        const collectedMatches = this.collectSelectOutputs(root, query).filter(item => identifiersEqual(item.name, columnName));
+        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)]
@@ -1062,11 +994,11 @@ class ParameterConditionPlacementOptimizer {
     hasExplicitOutputMatch(query, columnName) {
         return query.selectClause.items.some(item => {
             if (item.identifier) {
-                return identifiersEqual(item.identifier.name, columnName);
+                return (0, PredicateExpressionUtils_1.identifiersEqual)(item.identifier.name, columnName);
             }
             return item.value instanceof ValueComponent_1.ColumnReference
                 && item.value.column.name !== "*"
-                && identifiersEqual(item.value.column.name, columnName);
+                && (0, PredicateExpressionUtils_1.identifiersEqual)(item.value.column.name, columnName);
         });
     }
     inferWildcardOutputMatches(root, query, columnName, includeUnprovenPotential) {
@@ -1099,7 +1031,7 @@ class ParameterConditionPlacementOptimizer {
             return this.resolveWildcardColumnFromBinding(root, query, bindings[0], columnName, includeUnprovenPotential);
         }
         const namespace = wildcard.getNamespace();
-        const matches = bindings.filter(binding => identifiersEqual(binding.alias, namespace));
+        const matches = bindings.filter(binding => (0, PredicateExpressionUtils_1.identifiersEqual)(binding.alias, namespace));
         if (matches.length === 0) {
             return null;
         }
@@ -1127,7 +1059,7 @@ class ParameterConditionPlacementOptimizer {
             ...((_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 => identifiersEqual(item.name, columnName));
+        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);
@@ -1157,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;
@@ -1178,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) {
@@ -1204,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;
@@ -1254,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;
@@ -1328,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) {