sqlparser-devexpress 2.3.2 → 2.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlparser-devexpress",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "main": "src/index.js",
   "type": "module",
   "scripts": {

package/src/core/converter.js

@@ -140,10 +140,10 @@ function DevExpressConverter() {
 
         let comparison = [left, operatorToken, right];
 
-        if (isFunctionNullCheck(ast.left, true)) {
-            comparison = [[left, operatorToken, right], 'or', [left, operatorToken, null]];
-        } else if (isFunctionNullCheck(ast.right, true)) {
-            comparison = [[left, operatorToken, right], 'or', [right, operatorToken, null]];
+        if ((ast.left && isFunctionNullCheck(ast.left, true)) || (ast.value && isFunctionNullCheck(ast.value, false))) {
+            comparison = [[left, operatorToken, right], 'or', [left, operatorToken, null, {type: "ISNULL", defaultValue: (ast.left ?? ast.value).args[1]?.value}]];
+        } else if (ast.right && isFunctionNullCheck(ast.right, true)) {
+            comparison = [[left, operatorToken, right], 'or', [right, operatorToken, null, {type: "ISNULL", defaultValue: ast.right.args[1]?.value}]];
         }
 
         // Apply short-circuit evaluation if enabled
@@ -322,7 +322,7 @@ function DevExpressConverter() {
      * @returns {boolean} True if the condition is always true.
      */
     function isAlwaysTrue(condition) {
-        return Array.isArray(condition) && condition.length === 3 && evaluateExpression(...condition) == true;
+        return Array.isArray(condition) && condition.length >= 3 && evaluateExpression(...condition) == true;
     }
 
     /**
@@ -331,7 +331,7 @@ function DevExpressConverter() {
      * @returns {boolean} True if the condition is always false.
      */
     function isAlwaysFalse(condition) {
-        return Array.isArray(condition) && condition.length === 3 && evaluateExpression(...condition) == false;
+        return Array.isArray(condition) && condition.length >= 3 && evaluateExpression(...condition) == false;
     }
 
     /**

package/src/core/parser.js

@@ -1,4 +1,4 @@
-import { LITERALS, OPERATOR_PRECEDENCE, UNSUPPORTED_PATTERN } from "../constants.js";
+import { LITERALS, LOGICAL_OPERATORS, OPERATOR_PRECEDENCE, UNSUPPORTED_PATTERN } from "../constants.js";
 import { Tokenizer } from "./tokenizer.js";
 
 
@@ -78,20 +78,20 @@ export function parse(input, variables = []) {
 	}
 
 	function parseFunction() {
-		const funcName = currentToken.value.toUpperCase();
+		const functionName = currentToken.value.toUpperCase();
 		next();
 
-		expectedToken(currentToken, "(", `Expected ( after ${funcName}`);
+		expectedToken(currentToken, "(", `Expected ( after ${functionName}`);
 
 		next();
 
-		const args = [];
+		const functionArgs = [];
 		while (currentToken && currentToken.value !== ")") {
-			args.push(parseExpression());
+			functionArgs.push(parseExpression());
 			if (currentToken && currentToken.value === ",") next();
 		}
 
-		expectedToken(currentToken, ")", `Expected ) after ${funcName}`);
+		expectedToken(currentToken, ")", `Expected ) after ${functionName}`);
 
 		next(); // Consume the closing parenthesis
 
@@ -99,17 +99,22 @@ export function parse(input, variables = []) {
 		if (currentToken && currentToken.type === "operator") {
 			const operator = currentToken.value;
 			next(); // Move to the next token after the operator
-			const value = parseValue(); // Parse the value after the operator
+			const rightOperand = parseValue(); // Parse the value after the operator
+			const nodeType = LOGICAL_OPERATORS.includes(operator.toLowerCase()) ? "logical" : "comparison";
+
+			if(nodeType === "logical") {
+				return { type: "logical", operator, left: { type: "function", name: functionName, args: functionArgs }, right: rightOperand  };
+			}
 
 			return {
 				type: "comparison",
-				left: { type: "function", name: funcName, args },
+				left: { type: "function", name: functionName, args: functionArgs },
 				operator,
-				value
+				value: rightOperand 
 			};
 		}
 
-		return { type: "function", name: funcName, args };
+		return { type: "function", name: functionName, args: functionArgs };
 	}
 
 	// Parses logical expressions using operator precedence
@@ -165,6 +170,21 @@ export function parse(input, variables = []) {
 
 			if (operator === "between") return parseBetweenComparison(field, operator);
 
+			if (currentToken.type === "function") {
+				const functionNode = parseFunction();
+
+				// Wrap the function inside a comparison if it's directly after an operator
+				const leftComparison = {
+					type: "comparison",
+					field,
+					operator,
+					value: functionNode.left
+				};
+			
+				functionNode.left = leftComparison;
+				return functionNode;
+			}
+
 			// For other comparison operators, parse a single right-hand value
 			const valueType = currentToken.type;
 			const value = parseValue(operator);
@@ -184,39 +204,59 @@ export function parse(input, variables = []) {
 	function parseValue(operatorToken) {
 		if (!currentToken) throw new Error("Unexpected end of input");
 
-		if(currentToken.type === "function") return parseFunction();
+		// Handle function without consuming the token
+		if (currentToken.type === "function") {
+			return parseFunction();
+		}
 
 		const token = currentToken;
 		next(); // Move to the next token
 
-		if (token.type === "number") return Number(token.value);
-		if (token.type === "string") return token.value.slice(1, -1).replace(/''/g, "");
-		if (token.type === "identifier") return token.value;
-		if (token.type === "null") return null;
+		switch (token.type) {
+			case "number":
+				return Number(token.value);
 
-		// Handle placeholders like `{VariableName}`
-		if (token.type === "placeholder") {
-			const val = token.value.slice(1, -1);
-			if (!variables.includes(val)) variables.push(val);
-			return { type: "placeholder", value: val };
-		}
+			case "string":
+				return token.value.slice(1, -1).replace(/''/g, "");
 
-		operatorToken = operatorToken?.toUpperCase();
+			case "identifier":
+				return token.value;
 
-		// Handle IN operator which requires a list of values
-		if (operatorToken && (operatorToken === "IN" || operatorToken === "NOT IN")) return parseInList(token);
+			case "null":
+				return null;
 
-		// Handle ({Placeholder}) syntax for placeholders inside parentheses
-		const nextToken = tokenizer.peekNextToken();
-		if(token.type === "paren" && currentToken && currentToken.type === "placeholder" && nextToken && nextToken.type === "paren") {
-			const val = parseValue();
-			return { type: "placeholder", value: val };
+			case "placeholder": {
+				const val = token.value.slice(1, -1);
+				if (!variables.includes(val)) variables.push(val);
+				return { type: "placeholder", value: val };
+			}
+
+			case "paren": {
+				if (currentToken.type === "function") {
+					return parseFunction();
+				}
+				// Handle ({Placeholder}) syntax for placeholders inside parentheses
+				const nextToken = tokenizer.peekNextToken();
+				if (currentToken && currentToken.type === "placeholder" &&
+					nextToken && nextToken.type === "paren") {
+					const val = parseValue();
+					return { type: "placeholder", value: val };
+				}
+				break;
+			}
+		}
+
+		// Handle IN or NOT IN operator (outside switch as intended)
+		operatorToken = operatorToken?.toUpperCase();
+		if (operatorToken === "IN" || operatorToken === "NOT IN") {
+			return parseInList(token);
 		}
 
 		throw new Error(`Unexpected value: ${token.value}`);
 	}
 
 
+
 	// Start parsing and return the AST with extracted variables
 	return { ast: parseExpression(), variables };
 }

package/src/debug.js

@@ -28,7 +28,7 @@
 //     return convertToDevExpressFormat({ ast: astTree, resultObject: sampleData });
 // }
 
-// const devexpress = parseFilterString("(ISNULL(TicketID, 0) = ISNULL({CustomerOrders.OrderID}, 0))", sampleData);
+// const devexpress = parseFilterString("CompanyID = ISNULL({LeadDocument.CompanyID},0) OR (ISNULL(CompanyID,0) = 0))", sampleData);
 // console.log("DevExpress Filter:", JSON.stringify(devexpress, null, 2));
 // // const devexpress = parseFilterString("(RS2ID in ({LeadStatementGlobalRpt.StateID}) Or ({LeadStatementGlobalRpt.StateID} =0)) And (RS3ID  in (0,{LeadStatementGlobalRpt.RegionID}) Or {LeadStatementGlobalRpt.RegionID} =0 )", sampleData);
 

package/tests/parser.test.js

@@ -137,11 +137,11 @@ describe("Parser SQL to dx Filter Builder", () => {
             expected: [
                 ["SourceID", "=", 2],
                 "or",
-                ["SourceID", "=", null],
+                ["SourceID", "=", null,{ "defaultValue": 0, "type": "ISNULL"}],
                 "or",
                 ["SourceID", "=", 0],
                 "or",
-                ["SourceID", "=", null]
+                ["SourceID", "=", null,{ "defaultValue": 0, "type": "ISNULL"}]
             ]
         },
         {
@@ -153,14 +153,14 @@ describe("Parser SQL to dx Filter Builder", () => {
                     [
                         ["CompanyID", "=", 0],
                         "or",
-                        ["CompanyID", "=", null]
+                        ["CompanyID", "=", null,{ "defaultValue": 0, "type": "ISNULL"}]
                     ]
                 ],
                 "and",
                 [
                     ["IsSubdealer", "=", true],
                     "or",
-                    ["IsSubdealer", "=", null]
+                    ["IsSubdealer", "=", null,{ "defaultValue": 0, "type": "ISNULL"}]
                 ]
             ]
         },
@@ -187,7 +187,22 @@ describe("Parser SQL to dx Filter Builder", () => {
             expected: [
                 ["TicketID", "=", 123],
                 "or",
-                ["TicketID", "=", null]
+                ["TicketID", "=", null,{ "defaultValue": 0, "type": "ISNULL"}]
+            ]
+        },
+        {
+            input: "CompanyID = ISNULL({LeadDocument.CompanyID},0) OR (ISNULL(CompanyID,0) = 0))",
+            expected: [
+                ["CompanyID", "=", 7],
+                "or",
+                ["CompanyID", "=", null,{ "defaultValue": 0, "type": "ISNULL"}],
+                "or",
+                ["CompanyID", "=", 0],
+                "or",
+                ["CompanyID", "=", null,{ "defaultValue": 0, "type": "ISNULL"},
+
+                ]
+                
             ]
         }
     ];