rawsql-ts 0.10.2-beta → 0.10.4-beta

package/dist/utils/OperatorPrecedence.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorPrecedence = void 0;
+/**
+ * SQL operator precedence definitions
+ * Higher numbers indicate higher precedence (tighter binding)
+ */
+class OperatorPrecedence {
+    /**
+     * Get the precedence of an operator
+     * @param operator The operator string
+     * @returns The precedence number (higher = tighter binding)
+     */
+    static getPrecedence(operator) {
+        const precedence = this.precedenceMap[operator.toLowerCase()];
+        return precedence !== undefined ? precedence : 0;
+    }
+    /**
+     * Check if operator1 has higher or equal precedence than operator2
+     */
+    static hasHigherOrEqualPrecedence(operator1, operator2) {
+        return this.getPrecedence(operator1) >= this.getPrecedence(operator2);
+    }
+    /**
+     * Check if an operator is a logical operator (AND/OR)
+     */
+    static isLogicalOperator(operator) {
+        const op = operator.toLowerCase();
+        return op === 'and' || op === 'or';
+    }
+    /**
+     * Check if an operator is a BETWEEN operator
+     */
+    static isBetweenOperator(operator) {
+        const op = operator.toLowerCase();
+        return op === 'between' || op === 'not between';
+    }
+    /**
+     * Check if a string is a comparison operator
+     */
+    static isComparisonOperator(operator) {
+        const lowerOp = operator.toLowerCase();
+        return ['=', '!=', '<>', '<', '>', '<=', '>=', 'like', 'ilike', 'in', 'not in'].includes(lowerOp);
+    }
+}
+exports.OperatorPrecedence = OperatorPrecedence;
+OperatorPrecedence.precedenceMap = {
+    // Logical operators (lowest precedence)
+    'or': 1,
+    'and': 2,
+    // Comparison operators
+    '=': 10,
+    '!=': 10,
+    '<>': 10,
+    '<': 10,
+    '<=': 10,
+    '>': 10,
+    '>=': 10,
+    'like': 10,
+    'ilike': 10,
+    'not like': 10,
+    'not ilike': 10,
+    'in': 10,
+    'not in': 10,
+    'is': 10,
+    'is not': 10,
+    'between': 15, // BETWEEN has higher precedence than logical operators
+    'not between': 15,
+    // Arithmetic operators
+    '+': 20,
+    '-': 20,
+    '*': 30,
+    '/': 30,
+    '%': 30,
+    '^': 40,
+    // Type casting
+    '::': 50,
+    // Highest precedence operators
+    'unary+': 100,
+    'unary-': 100,
+    'not': 100
+};
+//# sourceMappingURL=OperatorPrecedence.js.map

package/dist/utils/OperatorPrecedence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperatorPrecedence.js","sourceRoot":"","sources":["../../src/utils/OperatorPrecedence.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,MAAa,kBAAkB;IA0C3B;;;;OAIG;IACI,MAAM,CAAC,aAAa,CAAC,QAAgB;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;QAC9D,OAAO,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,0BAA0B,CAAC,SAAiB,EAAE,SAAiB;QACzE,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;IAC1E,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,iBAAiB,CAAC,QAAgB;QAC5C,MAAM,EAAE,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QAClC,OAAO,EAAE,KAAK,KAAK,IAAI,EAAE,KAAK,IAAI,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,iBAAiB,CAAC,QAAgB;QAC5C,MAAM,EAAE,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QAClC,OAAO,EAAE,KAAK,SAAS,IAAI,EAAE,KAAK,aAAa,CAAC;IACpD,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,oBAAoB,CAAC,QAAgB;QAC/C,MAAM,OAAO,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACvC,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACtG,CAAC;;AAjFL,gDAkFC;AAjF2B,gCAAa,GAA2B;IAC5D,wCAAwC;IACxC,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;IAER,uBAAuB;IACvB,GAAG,EAAE,EAAE;IACP,IAAI,EAAE,EAAE;IACR,IAAI,EAAE,EAAE;IACR,GAAG,EAAE,EAAE;IACP,IAAI,EAAE,EAAE;IACR,GAAG,EAAE,EAAE;IACP,IAAI,EAAE,EAAE;IACR,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,UAAU,EAAE,EAAE;IACd,WAAW,EAAE,EAAE;IACf,IAAI,EAAE,EAAE;IACR,QAAQ,EAAE,EAAE;IACZ,IAAI,EAAE,EAAE;IACR,QAAQ,EAAE,EAAE;IACZ,SAAS,EAAE,EAAE,EAAG,uDAAuD;IACvE,aAAa,EAAE,EAAE;IAEjB,uBAAuB;IACvB,GAAG,EAAE,EAAE;IACP,GAAG,EAAE,EAAE;IACP,GAAG,EAAE,EAAE;IACP,GAAG,EAAE,EAAE;IACP,GAAG,EAAE,EAAE;IACP,GAAG,EAAE,EAAE;IAEP,eAAe;IACf,IAAI,EAAE,EAAE;IAER,+BAA+B;IAC/B,QAAQ,EAAE,GAAG;IACb,QAAQ,EAAE,GAAG;IACb,KAAK,EAAE,GAAG;CACb,CAAC"}

package/dist/utils/ParameterRemover.d.ts

@@ -0,0 +1,225 @@
+import { SqlComponent, SqlComponentVisitor } from "../models/SqlComponent";
+/**
+ * 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 declare class ParameterRemover implements SqlComponentVisitor<SqlComponent | null> {
+    private handlers;
+    private visitedNodes;
+    private isRootVisit;
+    constructor();
+    /**
+     * Reset the visited nodes tracking
+     */
+    private reset;
+    /**
+     * 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: SqlComponent): SqlComponent | null;
+    /**
+     * Internal visit method used for all nodes.
+     * This separates the visit flag management from the actual node visitation logic.
+     */
+    private visitNode;
+    /**
+     * Visit SimpleSelectQuery node
+     */
+    private visitSimpleSelectQuery;
+    /**
+     * Visit BinarySelectQuery node
+     */
+    private visitBinarySelectQuery;
+    /**
+     * Visit ValuesQuery node
+     */
+    private visitValuesQuery;
+    /**
+     * Visit WithClause node
+     */
+    private visitWithClause;
+    /**
+     * Visit CommonTable node
+     */
+    private visitCommonTable;
+    /**
+     * Visit SelectClause node
+     */
+    private visitSelectClause;
+    /**
+     * Visit SelectItem node
+     */
+    private visitSelectItem;
+    private visitIdentifierString;
+    private visitRawString;
+    private visitColumnReference;
+    private visitParameterExpression;
+    private visitLiteralValue;
+    private visitTableSource;
+    private visitForClause;
+    private visitDistinctComponent;
+    /**
+     * Visit SourceExpression node
+     */
+    private visitSourceExpression;
+    /**
+     * Visit ParenSource node
+     */
+    private visitParenSource;
+    /**
+     * Visit SourceAliasExpression node
+     */
+    private visitSourceAliasExpression;
+    /**
+     * Visit SubQuerySource node
+     */
+    private visitSubQuerySource;
+    /**
+     * Visit InlineQuery node
+     */
+    private visitInlineQuery;
+    /**
+     * Visit FromClause node
+     */
+    private visitFromClause;
+    /**
+     * Visit JoinClause node
+     */
+    private visitJoinClause;
+    /**
+     * Visit JoinOnClause node
+     */
+    private visitJoinOnClause;
+    /**
+     * Visit JoinUsingClause node
+     */
+    private visitJoinUsingClause;
+    /**
+     * Visit WhereClause node - key method for parameter removal
+     */
+    private visitWhereClause;
+    /**
+     * Visit ParenExpression node
+     */
+    private visitParenExpression;
+    /**
+     * Visit BinaryExpression node - improved logic for right-associative parser structure
+     */
+    private visitBinaryExpression;
+    /**
+     * Handle comparison expressions, accounting for right-associative parser structure
+     */
+    private handleComparisonExpression;
+    /**
+     * Restructure expressions like "id = (1 AND ...)" to "(id = 1) AND ..."
+     */
+    private restructureComparisonWithLogical;
+    /**
+     * 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"
+     */
+    private wouldCreateNonsensicalExpression;
+    /**
+     * Check if a ValueComponent contains a ParameterExpression anywhere in its tree
+     */
+    private containsParameter;
+    /**
+     * Visit UnaryExpression node
+     */
+    private visitUnaryExpression;
+    /**
+     * Visit CaseExpression node
+     */
+    private visitCaseExpression;
+    /**
+     * Visit CaseKeyValuePair node
+     */
+    private visitCaseKeyValuePair;
+    /**
+     * Visit SwitchCaseArgument node
+     */
+    private visitSwitchCaseArgument;
+    /**
+     * Visit BetweenExpression node
+    */
+    private visitBetweenExpression;
+    /**
+     * Visit FunctionCall node
+     */
+    private visitFunctionCall;
+    /**
+     * Visit ArrayExpression node
+     */
+    private visitArrayExpression;
+    /**
+     * Visit TupleExpression node
+     */
+    private visitTupleExpression;
+    /**
+     * Visit CastExpression node
+     */
+    private visitCastExpression;
+    /**
+     * Visit WindowFrameExpression node
+     */
+    private visitWindowFrameExpression;
+    /**
+     * Visit WindowFrameSpec node
+     */
+    private visitWindowFrameSpec;
+    /**
+     * Visit TypeValue node
+     */
+    private visitTypeValue;
+    /**
+     * Visit GroupByClause node
+     */
+    private visitGroupByClause;
+    /**
+     * Visit HavingClause node
+     */
+    private visitHavingClause;
+    /**
+     * Visit OrderByClause node
+     */
+    private visitOrderByClause;
+    /**
+     * Visit OrderByItem node
+     */
+    private visitOrderByItem;
+    /**
+     * Visit WindowFrameClause node
+     */
+    private visitWindowFrameClause;
+    /**
+     * Visit WindowsClause node
+     */
+    private visitWindowsClause;
+    /**
+     * Visit LimitClause node
+     */
+    private visitLimitClause;
+    /**
+     * Visit OffsetClause node
+     */
+    private visitOffsetClause;
+    /**
+     * Visit FetchClause node
+     */
+    private visitFetchClause;
+    /**
+     * Visit FetchExpression node
+     */
+    private visitFetchExpression;
+    /**
+     * 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: SqlComponent): SqlComponent | null;
+}