rawsql-ts 0.11.44-beta → 0.12.1

package/dist/esm/utils/ParameterRemover.js

@@ -0,0 +1,779 @@
+import { CommonTable, Distinct, DistinctOn, ForClause, FromClause, GroupByClause, HavingClause, JoinClause, JoinOnClause, JoinUsingClause, LimitClause, OffsetClause, FetchClause, FetchExpression, OrderByClause, OrderByItem, ParenSource, SelectClause, SelectItem, SourceAliasExpression, SourceExpression, SubQuerySource, TableSource, WhereClause, WindowFrameClause, WindowsClause, WithClause } from "../models/Clause";
+import { BinarySelectQuery, SimpleSelectQuery, ValuesQuery } from "../models/SelectQuery";
+import { ArrayExpression, BetweenExpression, BinaryExpression, CaseExpression, CaseKeyValuePair, CastExpression, ColumnReference, FunctionCall, InlineQuery, ParenExpression, ParameterExpression, SwitchCaseArgument, TupleExpression, UnaryExpression, WindowFrameExpression, IdentifierString, RawString, WindowFrameSpec, LiteralValue, TypeValue } from "../models/ValueComponent";
+import { OperatorPrecedence } from "./OperatorPrecedence";
+/**
+ * Helper visitor to detect if a component tree contains any ParameterExpression
+ */
+class ParameterDetector {
+    constructor() {
+        this.handlers = new Map();
+        // ParameterExpression always returns true
+        this.handlers.set(ParameterExpression.kind, () => true);
+        // Binary expressions check both sides
+        this.handlers.set(BinaryExpression.kind, (expr) => this.visit(expr.left) || this.visit(expr.right));
+        // Parenthesized expressions check inner expression
+        this.handlers.set(ParenExpression.kind, (expr) => this.visit(expr.expression));
+        // Unary expressions check inner expression
+        this.handlers.set(UnaryExpression.kind, (expr) => this.visit(expr.expression));
+        // Function calls check argument if present
+        this.handlers.set(FunctionCall.kind, (expr) => expr.argument ? this.visit(expr.argument) : false);
+        // Case expressions check condition and switch cases
+        this.handlers.set(CaseExpression.kind, (expr) => {
+            const conditionHasParam = expr.condition ? this.visit(expr.condition) : false;
+            const switchCaseHasParam = this.visit(expr.switchCase);
+            return conditionHasParam || switchCaseHasParam;
+        });
+        // Between expressions check all three parts
+        this.handlers.set(BetweenExpression.kind, (expr) => this.visit(expr.expression) || this.visit(expr.lower) || this.visit(expr.upper));
+        // Default case: no parameters for simple types
+        // (ColumnReference, LiteralValue, IdentifierString, etc.)
+    }
+    visit(component) {
+        const handler = this.handlers.get(component.getKind());
+        if (handler) {
+            return handler(component);
+        }
+        return false; // Default: no parameters
+    }
+    static detect(component) {
+        const detector = new ParameterDetector();
+        return detector.visit(component);
+    }
+}
+/**
+ * Helper to analyze SQL expression structure safely
+ */
+class ExpressionAnalyzer {
+    /**
+     * Check if a component is a binary expression with logical operator (AND/OR)
+     */
+    static isLogicalBinaryExpression(component) {
+        if (component.getKind() !== BinaryExpression.kind) {
+            return false;
+        }
+        const expr = component;
+        return OperatorPrecedence.isLogicalOperator(expr.operator.value);
+    }
+    /**
+     * Check if a component is a comparison operator
+     */
+    static isComparisonBinaryExpression(component) {
+        if (component.getKind() !== BinaryExpression.kind) {
+            return false;
+        }
+        const expr = component;
+        return OperatorPrecedence.isComparisonOperator(expr.operator.value);
+    }
+}
+/**
+ * Utility class to traverse and remove ParameterExpression nodes from the SQL AST.
+ * This removes any binary expression containing a ParameterExpression as a whole.
+ * For compound logical expressions (AND/OR), only the parameterized parts are removed.
+ * If all conditions are removed from a logical expression, the parent node is removed as well.
+ */
+export class ParameterRemover {
+    constructor() {
+        this.visitedNodes = new Set();
+        this.isRootVisit = true;
+        this.handlers = new Map();
+        // Setup handlers for all component types
+        // SelectQuery types
+        this.handlers.set(SimpleSelectQuery.kind, (expr) => this.visitSimpleSelectQuery(expr));
+        this.handlers.set(BinarySelectQuery.kind, (expr) => this.visitBinarySelectQuery(expr));
+        this.handlers.set(ValuesQuery.kind, (expr) => this.visitValuesQuery(expr));
+        // WithClause and CommonTable
+        this.handlers.set(WithClause.kind, (expr) => this.visitWithClause(expr));
+        this.handlers.set(CommonTable.kind, (expr) => this.visitCommonTable(expr));
+        // SelectClause and SelectItem
+        this.handlers.set(SelectClause.kind, (expr) => this.visitSelectClause(expr));
+        this.handlers.set(SelectItem.kind, (expr) => this.visitSelectItem(expr));
+        this.handlers.set(Distinct.kind, (expr) => this.visitDistinctComponent(expr));
+        this.handlers.set(DistinctOn.kind, (expr) => this.visitDistinctComponent(expr));
+        // Identifiers and raw strings
+        this.handlers.set(IdentifierString.kind, (expr) => this.visitIdentifierString(expr));
+        this.handlers.set(RawString.kind, (expr) => this.visitRawString(expr));
+        this.handlers.set(ColumnReference.kind, (expr) => this.visitColumnReference(expr));
+        this.handlers.set(ParameterExpression.kind, (expr) => this.visitParameterExpression(expr));
+        this.handlers.set(LiteralValue.kind, (expr) => this.visitLiteralValue(expr));
+        // Source components
+        this.handlers.set(SourceExpression.kind, (expr) => this.visitSourceExpression(expr));
+        this.handlers.set(TableSource.kind, (expr) => this.visitTableSource(expr));
+        this.handlers.set(ParenSource.kind, (expr) => this.visitParenSource(expr));
+        this.handlers.set(SourceAliasExpression.kind, (expr) => this.visitSourceAliasExpression(expr));
+        // Subqueries and inline queries
+        this.handlers.set(SubQuerySource.kind, (expr) => this.visitSubQuerySource(expr));
+        this.handlers.set(InlineQuery.kind, (expr) => this.visitInlineQuery(expr));
+        // FROM and JOIN clauses
+        this.handlers.set(FromClause.kind, (expr) => this.visitFromClause(expr));
+        this.handlers.set(JoinClause.kind, (expr) => this.visitJoinClause(expr));
+        this.handlers.set(JoinOnClause.kind, (expr) => this.visitJoinOnClause(expr));
+        this.handlers.set(JoinUsingClause.kind, (expr) => this.visitJoinUsingClause(expr));
+        // WHERE clause
+        this.handlers.set(WhereClause.kind, (expr) => this.visitWhereClause(expr));
+        // Value components that might contain subqueries or parameters
+        this.handlers.set(ParenExpression.kind, (expr) => this.visitParenExpression(expr));
+        this.handlers.set(BinaryExpression.kind, (expr) => this.visitBinaryExpression(expr));
+        this.handlers.set(UnaryExpression.kind, (expr) => this.visitUnaryExpression(expr));
+        this.handlers.set(CaseExpression.kind, (expr) => this.visitCaseExpression(expr));
+        this.handlers.set(CaseKeyValuePair.kind, (expr) => this.visitCaseKeyValuePair(expr));
+        this.handlers.set(SwitchCaseArgument.kind, (expr) => this.visitSwitchCaseArgument(expr));
+        this.handlers.set(BetweenExpression.kind, (expr) => this.visitBetweenExpression(expr));
+        this.handlers.set(FunctionCall.kind, (expr) => this.visitFunctionCall(expr));
+        this.handlers.set(ArrayExpression.kind, (expr) => this.visitArrayExpression(expr));
+        this.handlers.set(TupleExpression.kind, (expr) => this.visitTupleExpression(expr));
+        this.handlers.set(CastExpression.kind, (expr) => this.visitCastExpression(expr));
+        this.handlers.set(WindowFrameExpression.kind, (expr) => this.visitWindowFrameExpression(expr));
+        this.handlers.set(WindowFrameSpec.kind, (expr) => this.visitWindowFrameSpec(expr));
+        this.handlers.set(TypeValue.kind, (expr) => this.visitTypeValue(expr));
+        // Other clauses
+        this.handlers.set(GroupByClause.kind, (expr) => this.visitGroupByClause(expr));
+        this.handlers.set(HavingClause.kind, (expr) => this.visitHavingClause(expr));
+        this.handlers.set(OrderByClause.kind, (expr) => this.visitOrderByClause(expr));
+        this.handlers.set(OrderByItem.kind, (expr) => this.visitOrderByItem(expr));
+        this.handlers.set(WindowFrameClause.kind, (expr) => this.visitWindowFrameClause(expr));
+        this.handlers.set(WindowsClause.kind, (expr) => this.visitWindowsClause(expr));
+        this.handlers.set(LimitClause.kind, (expr) => this.visitLimitClause(expr));
+        this.handlers.set(ForClause.kind, (expr) => this.visitForClause(expr));
+        this.handlers.set(OffsetClause.kind, (expr) => this.visitOffsetClause(expr));
+        this.handlers.set(FetchClause.kind, (expr) => this.visitFetchClause(expr));
+        this.handlers.set(FetchExpression.kind, (expr) => this.visitFetchExpression(expr));
+    }
+    /**
+     * Reset the visited nodes tracking
+     */
+    reset() {
+        this.visitedNodes.clear();
+    }
+    /**
+     * Main entry point for the visitor pattern.
+     * @param arg The SQL component to visit
+     * @returns The component with parameter expressions removed, or null if the entire component should be removed
+     */
+    visit(arg) {
+        // If not a root visit, just visit the node and return
+        if (!this.isRootVisit) {
+            return this.visitNode(arg);
+        }
+        // If this is a root visit, we need to reset the state
+        this.reset();
+        this.isRootVisit = false;
+        try {
+            return this.visitNode(arg);
+        }
+        finally {
+            // Regardless of success or failure, reset the root visit flag
+            this.isRootVisit = true;
+        }
+    }
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    visitNode(arg) {
+        var _a, _b;
+        // Check for circular references - if node already visited, return as is
+        if (this.visitedNodes.has(arg)) {
+            return arg;
+        }
+        // Mark as visited node
+        this.visitedNodes.add(arg);
+        // Handle null values
+        if (!arg) {
+            return null;
+        }
+        const handler = this.handlers.get(arg.getKind());
+        if (handler) {
+            return handler(arg);
+        }
+        // Provide more detailed error message
+        const kindSymbol = ((_a = arg.getKind()) === null || _a === void 0 ? void 0 : _a.toString()) || 'unknown';
+        const constructor = ((_b = arg.constructor) === null || _b === void 0 ? void 0 : _b.name) || 'unknown';
+        throw new Error(`[ParameterRemover] No handler for ${constructor} with kind ${kindSymbol}.`);
+    }
+    /**
+     * Visit SimpleSelectQuery node
+     */
+    visitSimpleSelectQuery(query) {
+        const withClause = query.withClause ? this.visit(query.withClause) : null;
+        // SelectClause is required
+        if (!query.selectClause) {
+            throw new Error("[ParameterRemover] SimpleSelectQuery missing required selectClause");
+        }
+        const selectClause = this.visit(query.selectClause);
+        const fromClause = query.fromClause ? this.visit(query.fromClause) : null;
+        const whereClause = query.whereClause ? this.visit(query.whereClause) : null;
+        const groupByClause = query.groupByClause ? this.visit(query.groupByClause) : null;
+        const havingClause = query.havingClause ? this.visit(query.havingClause) : null;
+        const orderByClause = query.orderByClause ? this.visit(query.orderByClause) : null;
+        const windowClause = query.windowClause ? this.visit(query.windowClause) : null;
+        const limitClause = query.limitClause ? this.visit(query.limitClause) : null;
+        const offsetClause = query.offsetClause ? this.visit(query.offsetClause) : null;
+        const fetchClause = query.fetchClause ? this.visit(query.fetchClause) : null;
+        const forClause = query.forClause ? this.visit(query.forClause) : null;
+        return new SimpleSelectQuery({
+            withClause,
+            selectClause,
+            fromClause,
+            whereClause,
+            groupByClause,
+            havingClause,
+            orderByClause,
+            windowClause,
+            limitClause,
+            offsetClause,
+            fetchClause,
+            forClause
+        });
+    }
+    /**
+     * Visit BinarySelectQuery node
+     */
+    visitBinarySelectQuery(query) {
+        if (!query.left || !query.right) {
+            return null;
+        }
+        const left = this.visit(query.left);
+        if (!left) {
+            return null;
+        }
+        const right = this.visit(query.right);
+        if (!right) {
+            return null;
+        }
+        const operation = query.operator;
+        return new BinarySelectQuery(left, operation.value, right);
+    }
+    /**
+     * Visit ValuesQuery node
+     */
+    visitValuesQuery(query) {
+        // Since ValuesQuery doesn't typically contain parameters in WHERE conditions,
+        // we'll just return it as is for now
+        return query;
+    }
+    /**
+     * Visit WithClause node
+     */
+    visitWithClause(clause) {
+        if (!clause.tables) {
+            return null;
+        }
+        const tables = clause.tables
+            .map(table => this.visit(table))
+            .filter(table => table !== null);
+        if (tables.length === 0) {
+            return null;
+        }
+        return new WithClause(clause.recursive, tables);
+    }
+    /**
+     * Visit CommonTable node
+     */
+    visitCommonTable(table) {
+        if (!table.aliasExpression || !table.query) {
+            return null;
+        }
+        const aliasExpression = this.visit(table.aliasExpression);
+        if (!aliasExpression) {
+            return null;
+        }
+        const selectQuery = this.visit(table.query);
+        if (!selectQuery) {
+            return null;
+        }
+        return new CommonTable(selectQuery, aliasExpression, table.materialized);
+    }
+    /**
+     * Visit SelectClause node
+     */
+    visitSelectClause(clause) {
+        if (!clause.items) {
+            throw new Error("[ParameterRemover] SelectClause missing required items");
+        }
+        const items = clause.items
+            .map(item => this.visit(item))
+            .filter(item => item !== null);
+        const distinct = clause.distinct ? this.visit(clause.distinct) : null;
+        if (items.length === 0) {
+            throw new Error("[ParameterRemover] SelectClause must have at least one item");
+        }
+        return new SelectClause(items, distinct);
+    }
+    /**
+     * Visit SelectItem node
+     */
+    visitSelectItem(item) {
+        var _a;
+        if (!item.value) {
+            return null;
+        }
+        const value = this.visit(item.value);
+        if (!value) {
+            return null;
+        }
+        return new SelectItem(value, ((_a = item.identifier) === null || _a === void 0 ? void 0 : _a.name) || null);
+    }
+    // Simple visitor methods that return the node unchanged
+    visitIdentifierString(identifier) { return identifier; }
+    visitRawString(str) { return str; }
+    visitColumnReference(ref) { return ref; }
+    visitParameterExpression(param) { return null; }
+    visitLiteralValue(literal) { return literal; }
+    visitTableSource(source) { return source; }
+    visitForClause(clause) { return clause; }
+    visitDistinctComponent(component) { return component; }
+    /**
+     * Visit SourceExpression node
+     */
+    visitSourceExpression(source) {
+        if (!source.datasource) {
+            return source; // Return as is instead of null
+        }
+        const sourceComponent = this.visit(source.datasource);
+        if (!sourceComponent) {
+            return source; // Return as is instead of null
+        }
+        return new SourceExpression(sourceComponent, source.aliasExpression);
+    }
+    /**
+     * Visit ParenSource node
+     */
+    visitParenSource(source) {
+        return new ParenSource(this.visit(source.source));
+    }
+    /**
+     * Visit SourceAliasExpression node
+     */
+    visitSourceAliasExpression(expr) {
+        const table = expr.table;
+        const columns = expr.columns;
+        const columnNames = columns ? columns.map(col => col.name) : null;
+        return new SourceAliasExpression(table.name, columnNames);
+    }
+    /**
+     * Visit SubQuerySource node
+     */
+    visitSubQuerySource(source) {
+        if (!source.query) {
+            return null;
+        }
+        const query = this.visit(source.query);
+        if (!query) {
+            return null;
+        }
+        return new SubQuerySource(query);
+    }
+    /**
+     * Visit InlineQuery node
+     */
+    visitInlineQuery(query) {
+        if (!query.selectQuery) {
+            return null;
+        }
+        const selectQuery = this.visit(query.selectQuery);
+        if (!selectQuery) {
+            return null;
+        }
+        return new InlineQuery(selectQuery);
+    }
+    /**
+     * Visit FromClause node
+     */
+    visitFromClause(clause) {
+        if (!clause.source) {
+            return clause; // Return as is instead of null
+        }
+        // Always keep the source, even if something inside might change
+        const source = this.visit(clause.source);
+        let joins = null;
+        if (clause.joins) {
+            const processedJoins = clause.joins
+                .map(join => this.visit(join))
+                .filter(join => join !== null);
+            if (processedJoins.length > 0) {
+                joins = processedJoins;
+            }
+        }
+        return new FromClause(source || clause.source, joins);
+    }
+    /**
+     * Visit JoinClause node
+     */
+    visitJoinClause(clause) {
+        if (!clause.source) {
+            return null;
+        }
+        const source = this.visit(clause.source);
+        if (!source) {
+            return null;
+        }
+        const condition = clause.condition ? this.visit(clause.condition) : null;
+        return new JoinClause(clause.joinType.value, source, condition, clause.lateral);
+    }
+    /**
+     * Visit JoinOnClause node
+     */
+    visitJoinOnClause(clause) {
+        const condition = this.visit(clause.condition);
+        // If condition has been removed (contains only parameters), return null
+        if (!condition) {
+            return null;
+        }
+        return new JoinOnClause(condition);
+    }
+    /**
+     * Visit JoinUsingClause node
+     */
+    visitJoinUsingClause(clause) {
+        return clause;
+    }
+    /**
+     * Visit WhereClause node - key method for parameter removal
+     */
+    visitWhereClause(clause) {
+        const condition = this.visit(clause.condition);
+        // If the entire condition has been removed (contains only parameters), return null
+        if (!condition) {
+            return null;
+        }
+        return new WhereClause(condition);
+    }
+    /**
+     * Visit ParenExpression node
+     */
+    visitParenExpression(expr) {
+        const innerExpression = this.visit(expr.expression);
+        // If the inner expression has been removed (contains only parameters), return null
+        if (!innerExpression) {
+            return null;
+        }
+        return new ParenExpression(innerExpression);
+    }
+    /**
+     * Visit BinaryExpression node - improved logic for right-associative parser structure
+     */
+    visitBinaryExpression(expr) {
+        const operator = expr.operator.value.toLowerCase();
+        if (OperatorPrecedence.isLogicalOperator(operator)) {
+            // Handle logical operators normally
+            const left = this.visit(expr.left);
+            const right = this.visit(expr.right);
+            if (!left && !right) {
+                return null;
+            }
+            if (!left && right) {
+                return right;
+            }
+            if (left && !right) {
+                return left;
+            }
+            return new BinaryExpression(left, expr.operator.value, right);
+        }
+        else {
+            // For comparison operators, handle right-associative parser structure
+            return this.handleComparisonExpression(expr);
+        }
+    }
+    /**
+     * Handle comparison expressions, accounting for right-associative parser structure
+     */
+    handleComparisonExpression(expr) {
+        const left = this.visit(expr.left);
+        // Check if the right side is a logical expression (AND/OR) using type-safe analysis
+        if (ExpressionAnalyzer.isLogicalBinaryExpression(expr.right)) {
+            // This is the problematic case: comparison = (logical expression)
+            // We need to restructure this as: (comparison) logical (other parts)
+            return this.restructureComparisonWithLogical(expr, left);
+        }
+        // Normal comparison processing
+        const right = this.visit(expr.right);
+        if (!left || !right) {
+            return null;
+        }
+        return new BinaryExpression(left, expr.operator.value, right);
+    }
+    /**
+     * Restructure expressions like "id = (1 AND ...)" to "(id = 1) AND ..."
+     */
+    restructureComparisonWithLogical(expr, processedLeft) {
+        if (!processedLeft) {
+            return null;
+        }
+        const rightBinary = expr.right;
+        const logicalOperator = rightBinary.operator.value;
+        // Process the logical expression's left side as the right side of our comparison
+        const comparisonRight = this.visit(rightBinary.left);
+        if (!comparisonRight) {
+            // If the comparison right side contains only parameters, 
+            // try to process the logical expression's right side
+            return this.visit(rightBinary.right);
+        }
+        // Create the restructured comparison: "id = 1"
+        const restructuredComparison = new BinaryExpression(processedLeft, expr.operator.value, comparisonRight);
+        // Process the remaining logical expression's right side
+        const logicalRight = this.visit(rightBinary.right);
+        if (!logicalRight) {
+            // Only the left comparison is valid
+            return restructuredComparison;
+        }
+        // Combine: "(id = 1) AND (remaining expression)"
+        return new BinaryExpression(restructuredComparison, logicalOperator, logicalRight);
+    }
+    /**
+     * Check if an operator is a logical operator     */
+    /**
+     * Check if the resulting expression would be nonsensical
+     * This is a heuristic to detect cases like "name = age > 18"
+     */
+    wouldCreateNonsensicalExpression(left, operator, right) {
+        // Only apply this check for simple cases where we have a direct comparison operator
+        // followed by another comparison operator in the right side
+        if (OperatorPrecedence.isComparisonOperator(operator) && ExpressionAnalyzer.isComparisonBinaryExpression(right)) {
+            const rightBinary = right;
+            if (rightBinary.operator && OperatorPrecedence.isComparisonOperator(rightBinary.operator.value)) {
+                // Additional check: make sure this isn't a legitimate nested case
+                // If the left side is a simple column and the right side is a comparison,
+                // this is likely nonsensical (like "name = age > 18")
+                if (left.getKind().toString().includes('ColumnReference')) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a ValueComponent contains a ParameterExpression anywhere in its tree
+     */
+    containsParameter(component) {
+        return ParameterDetector.detect(component);
+    }
+    /**
+     * Visit UnaryExpression node
+     */
+    visitUnaryExpression(expr) {
+        const expression = this.visit(expr.expression);
+        // If the expression has been removed (contains only parameters), return null
+        if (!expression) {
+            return null;
+        }
+        return new UnaryExpression(expr.operator.value, expression);
+    }
+    /**
+     * Visit CaseExpression node
+     */
+    visitCaseExpression(expr) {
+        const condition = expr.condition ? this.visit(expr.condition) : null;
+        const switchCase = this.visit(expr.switchCase);
+        // If switchCase has been removed (contains only parameters), return null
+        if (!switchCase) {
+            return null;
+        }
+        return new CaseExpression(condition, switchCase);
+    }
+    /**
+     * Visit CaseKeyValuePair node
+     */
+    visitCaseKeyValuePair(pair) {
+        // If either key or value contains parameters, remove the entire pair
+        if (this.containsParameter(pair.key) || this.containsParameter(pair.value)) {
+            return null;
+        }
+        const key = this.visit(pair.key);
+        const value = this.visit(pair.value);
+        return new CaseKeyValuePair(key, value);
+    }
+    /**
+     * Visit SwitchCaseArgument node
+     */
+    visitSwitchCaseArgument(arg) {
+        // Process all case pairs, filter out null results
+        const cases = arg.cases
+            .map(caseItem => this.visit(caseItem))
+            .filter(caseItem => caseItem !== null);
+        // Process the else value if it exists
+        const elseValue = arg.elseValue ? this.visit(arg.elseValue) : null;
+        // If no cases remain and no else value, remove the entire switch case
+        if (cases.length === 0 && !elseValue) {
+            return null;
+        }
+        return new SwitchCaseArgument(cases, elseValue);
+    }
+    /**
+     * Visit BetweenExpression node
+    */
+    visitBetweenExpression(expr) {
+        // If any part of the expression contains a parameter, remove the entire expression
+        if (this.containsParameter(expr.expression) ||
+            this.containsParameter(expr.lower) ||
+            this.containsParameter(expr.upper)) {
+            return null;
+        }
+        const expression = this.visit(expr.expression);
+        const lower = this.visit(expr.lower);
+        const upper = this.visit(expr.upper);
+        return new BetweenExpression(expression, lower, upper, expr.negated);
+    }
+    /**
+     * Visit FunctionCall node
+     */
+    visitFunctionCall(call) {
+        const argument = call.argument ? this.visit(call.argument) : null;
+        const over = call.over ? this.visit(call.over) : null;
+        // Preserve any surviving FILTER predicates when rebuilding aggregate calls.
+        const filterCondition = call.filterCondition ? this.visit(call.filterCondition) : null;
+        return new FunctionCall(call.qualifiedName.namespaces, call.qualifiedName.name, argument, over, call.withinGroup, call.withOrdinality, call.internalOrderBy, filterCondition);
+    }
+    /**
+     * Visit ArrayExpression node
+     */
+    visitArrayExpression(expr) {
+        const expression = this.visit(expr.expression);
+        // If the expression has been removed (contains only parameters), return null
+        if (!expression) {
+            return null;
+        }
+        return new ArrayExpression(expression);
+    }
+    /**
+     * Visit TupleExpression node
+     */
+    visitTupleExpression(expr) {
+        const values = expr.values
+            .map(value => this.visit(value))
+            .filter(value => value !== null);
+        return new TupleExpression(values);
+    }
+    /**
+     * Visit CastExpression node
+     */
+    visitCastExpression(expr) {
+        // If the input contains a parameter, remove the entire expression
+        if (this.containsParameter(expr.input)) {
+            return null;
+        }
+        const input = this.visit(expr.input);
+        const castType = this.visit(expr.castType);
+        // If the input has been removed, return null
+        if (!input) {
+            return null;
+        }
+        return new CastExpression(input, castType);
+    }
+    /**
+     * Visit WindowFrameExpression node
+     */
+    visitWindowFrameExpression(expr) {
+        const partition = expr.partition ? this.visit(expr.partition) : null;
+        const order = expr.order ? this.visit(expr.order) : null;
+        const frameSpec = expr.frameSpec ? this.visit(expr.frameSpec) : null;
+        return new WindowFrameExpression(partition, order, frameSpec);
+    }
+    /**
+     * Visit WindowFrameSpec node
+     */
+    visitWindowFrameSpec(spec) {
+        return spec;
+    }
+    /**
+     * Visit TypeValue node
+     */
+    visitTypeValue(type) {
+        const argument = type.argument ? this.visit(type.argument) : null;
+        return new TypeValue(type.qualifiedName.namespaces, type.qualifiedName.name, argument);
+    }
+    /**
+     * Visit GroupByClause node
+     */
+    visitGroupByClause(clause) {
+        if (!clause.grouping || clause.grouping.length === 0) {
+            return null;
+        }
+        const grouping = clause.grouping
+            .map(expr => this.visit(expr))
+            .filter(expr => expr !== null);
+        if (grouping.length === 0) {
+            return null;
+        }
+        return new GroupByClause(grouping);
+    }
+    /**
+     * Visit HavingClause node
+     */
+    visitHavingClause(clause) {
+        const condition = this.visit(clause.condition);
+        // If the condition has been removed (contains only parameters), return null
+        if (!condition) {
+            return null;
+        }
+        return new HavingClause(condition);
+    }
+    /**
+     * Visit OrderByClause node
+     */
+    visitOrderByClause(clause) {
+        const items = clause.order
+            .map((item) => this.visit(item))
+            .filter((item) => item !== null);
+        return new OrderByClause(items);
+    }
+    /**
+     * Visit OrderByItem node
+     */
+    visitOrderByItem(item) {
+        const value = this.visit(item.value);
+        return new OrderByItem(value, item.sortDirection, item.nullsPosition);
+    }
+    /**
+     * Visit WindowFrameClause node
+     */
+    visitWindowFrameClause(clause) {
+        const expression = this.visit(clause.expression);
+        return new WindowFrameClause(clause.name.name, expression);
+    }
+    /**
+     * Visit WindowsClause node
+     */
+    visitWindowsClause(clause) {
+        const windows = clause.windows.map(window => this.visit(window));
+        return new WindowsClause(windows);
+    }
+    /**
+     * Visit LimitClause node
+     */
+    visitLimitClause(clause) {
+        const value = this.visit(clause.value);
+        return new LimitClause(value);
+    }
+    /**
+     * Visit OffsetClause node
+     */
+    visitOffsetClause(clause) {
+        const value = this.visit(clause.value);
+        return new OffsetClause(value);
+    }
+    /**
+     * Visit FetchClause node
+     */
+    visitFetchClause(clause) {
+        const expression = this.visit(clause.expression);
+        return new FetchClause(expression);
+    }
+    /**
+     * Visit FetchExpression node
+     */
+    visitFetchExpression(expression) {
+        const count = this.visit(expression.count);
+        return new FetchExpression(expression.type, count, expression.unit);
+    }
+    /**
+     * Static method to apply parameter removal transformation on an SQL AST
+     * @param node The SQL AST node to transform
+     * @returns The transformed SQL AST with parameter expressions removed
+     */
+    static remove(node) {
+        const remover = new ParameterRemover();
+        return remover.visit(node);
+    }
+}
+//# sourceMappingURL=ParameterRemover.js.map