dsl-to-sql 1.0.0-fabric-1p-development.1

package/tests/js-lib/CallExpressionVisitor.test.ts

@@ -0,0 +1,820 @@
+import { createJsToSqlParser } from '../../src/js-lib/JsToSqlParser';
+import {
+  IMDMColumnConfigWithParsedMeta,
+  MDM_COLUMN_TYPE,
+  ParseContext,
+} from '../../src/js-lib/ParseContext';
+
+// Mock ParseContext for testing
+function createMockContext(
+  columnNames: string[],
+  currentColumnId: string,
+  isCompositeKey: boolean = false,
+): ParseContext {
+  const tableName = 'TestTable';
+  const columnConfigMap = columnNames.reduce(
+    (acc, columnName) => {
+      acc[columnName] = {
+        columnName,
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnMeta: { tableName },
+      };
+      return acc;
+    },
+    {} as Record<string, IMDMColumnConfigWithParsedMeta>,
+  );
+  const primaryKeyColumns = isCompositeKey ? ['PK1', 'PK2'] : ['PK'];
+  return new ParseContext({
+    columnConfigMap,
+    currentColumnId,
+    primaryKeyColumns,
+    tableName,
+  });
+}
+
+describe('CallExpressionVisitor', () => {
+  describe('Logical Functions', () => {
+    test('should transform IF function to Sql case-when', () => {
+      const formula = `IF(Amount > 100, 'High', 'Low')`;
+      const expectedSql = `CASE WHEN [Amount] > 100 THEN 'High' ELSE 'Low' END`;
+      const context = createMockContext(['Amount'], 'Status');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform AND function to Sql AND operator', () => {
+      const formula = `AND(Amount > 100, Status == 'Active')`;
+      const expectedSql = `CASE WHEN [Amount] > 100 AND [Status] = 'Active' THEN 'true' ELSE 'false' END`;
+      const context = createMockContext(['Amount', 'Status'], 'Result');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform OR function to Sql OR operator', () => {
+      const formula = `OR(Amount > 100, Status == 'Active')`;
+      const expectedSql = `CASE WHEN [Amount] > 100 OR [Status] = 'Active' THEN 'true' ELSE 'false' END`;
+      const context = createMockContext(['Amount', 'Status'], 'Result');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform NOT function to Sql NOT operator', () => {
+      const formula = `NOT(Amount > 100)`;
+      const expectedSql = `CASE WHEN [Amount] > 100 THEN CAST(0 AS BIT) ELSE CAST(1 AS BIT) END`;
+      const context = createMockContext(['Amount'], 'Result');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform XOR function to Sql XOR operator', () => {
+      const formula = `XOR(Amount > 100, Status == 'Active')`;
+      const expectedSql = `CASE WHEN [Amount] > 100 AND NOT [Status] = 'Active' OR NOT [Amount] > 100 AND [Status] = 'Active' THEN '1' ELSE '0' END`;
+      const context = createMockContext(['Amount', 'Status'], 'Result');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+  });
+
+  describe('Date Functions', () => {
+    test('should transform DATEADD function to Sql DATEADD function', () => {
+      const formula = `DATEADD(PurchaseDate, 10)`;
+      const expectedSql = `DATEADD(DAY, 10, [PurchaseDate])`;
+      const context = createMockContext(['PurchaseDate'], 'ExpirationDate');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform DATEADD with TODAY() function to Sql DATEADD function', () => {
+      const formula = `DATEADD(TODAY(), 5)`;
+      const expectedSql = `DATEADD(DAY, 5, CURRENT_DATE)`;
+      const context = createMockContext([], 'FutureDate');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform DATEDIFF function to Sql DATEDIFF function', () => {
+      const formula = `DATEDIFF(StartDate, EndDate)`;
+      const expectedSql = `DATEDIFF(DAY, [StartDate], [EndDate])`;
+      const context = createMockContext(['StartDate', 'EndDate'], 'Duration');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform DATEDIFF with TODAY() function to Sql DATEDIFF function', () => {
+      const formula = `DATEDIFF(StartDate, TODAY())`;
+      const expectedSql = `DATEDIFF(DAY, [StartDate], CURRENT_DATE)`;
+      const context = createMockContext(['StartDate'], 'DaysUntilToday');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform DAY function to Sql DAY function', () => {
+      const formula = `DAY(PurchaseDate)`;
+      const expectedSql = `DAY([PurchaseDate])`;
+      const context = createMockContext(['PurchaseDate'], 'Day');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform EOMONTH function to Sql EOMONTH function', () => {
+      const formula = `EOMONTH(PurchaseDate)`;
+      const expectedSql = `EOMONTH([PurchaseDate])`;
+      const context = createMockContext(['PurchaseDate'], 'EndOfMonth');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MONTH function to Sql MONTH function', () => {
+      const formula = `MONTH(PurchaseDate)`;
+      const expectedSql = `MONTH([PurchaseDate])`;
+      const context = createMockContext(['PurchaseDate'], 'Month');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform NOW function to Sql NOW function', () => {
+      const formula = `NOW()`;
+      const expectedSql = `CURRENT_TIMESTAMP`;
+      const context = createMockContext([], 'CurrentTimestamp');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform TODAY function to Sql TODAY function', () => {
+      const formula = `TODAY()`;
+      const expectedSql = `CURRENT_DATE`;
+      const context = createMockContext([], 'CurrentDate');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform YEAR function to Sql YEAR function', () => {
+      const formula = `YEAR(PurchaseDate)`;
+      const expectedSql = `YEAR([PurchaseDate])`;
+      const context = createMockContext(['PurchaseDate'], 'PurchaseYear');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+  });
+
+  describe('String Functions', () => {
+    test('should transform CONCATENATE function to Sql CONCAT function', () => {
+      const formula = `CONCATENATE(Name, LastName)`;
+      const expectedSql = `CONCAT([Name], [LastName])`;
+      const context = createMockContext(['Name', 'LastName'], 'FullName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform ISBLANK function to Sql case-when function', () => {
+      const formula = `ISBLANK(Name)`;
+      const expectedSql = `CASE WHEN [Name] IS NULL THEN CAST(1 AS BIT) ELSE CAST(0 AS BIT) END`;
+      const context = createMockContext(['Name'], 'IsBlank');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform ISEMPTY function to Sql case-when function', () => {
+      const formula = `ISEMPTY(Name)`;
+      const expectedSql = `CASE WHEN [Name] IS NULL THEN CAST(1 AS BIT) ELSE CAST(0 AS BIT) END`;
+      const context = createMockContext(['Name'], 'IsEmpty');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform LEFT function to Sql LEFT function', () => {
+      const formula = `LEFT(Name, 3)`;
+      const expectedSql = `LEFT([Name], 3)`;
+      const context = createMockContext(['Name'], 'LeftName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform LEN function to Sql LEN function', () => {
+      const formula = `LEN(Name)`;
+      const expectedSql = `LEN([Name])`;
+      const context = createMockContext(['Name'], 'LenName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform LOWER function to Sql LOWER function', () => {
+      const formula = `LOWER(Name)`;
+      const expectedSql = `LOWER([Name])`;
+      const context = createMockContext(['Name'], 'LowerName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MATCH function to Sql MATCH function', () => {
+      const formula = `MATCH(Name, 'John')`;
+      const expectedSql = `CASE WHEN [Name] LIKE 'John' THEN 'true' ELSE 'false' END`;
+      const context = createMockContext(['Name'], 'MatchName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MID function to Sql MID function', () => {
+      const formula = `MID(Name, 1, 3)`;
+      const expectedSql = `SUBSTRING([Name], 1, 3)`;
+      const context = createMockContext(['Name'], 'MidName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform NUMBERVALUE function to Sql NUMBERVALUE function', () => {
+      const formula = `NUMBERVALUE(Amount)`;
+      const expectedSql = `CAST([Amount] AS FLOAT)`;
+      const context = createMockContext(['Amount'], 'NumberValueAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform REPLACE function to Sql REPLACE function', () => {
+      const formula = `REPLACE(Name,0, 2, 'SQL')`;
+      const expectedSql = `STUFF([Name], 0, 2, 'SQL')`;
+      const context = createMockContext(['Name'], 'ReplaceName');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform REPT function to Sql REPT function', () => {
+      const formula = `REPT('Hello', 3)`;
+      const expectedSql = `REPLICATE('Hello', 3)`;
+      const context = createMockContext([], 'ReptAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform RIGHT function to Sql RIGHT function', () => {
+      const formula = `RIGHT(Amount, 3)`;
+      const expectedSql = `RIGHT([Amount], 3)`;
+      const context = createMockContext(['Amount'], 'RightAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform TRIM function to Sql TRIM function', () => {
+      const formula = `TRIM(Amount)`;
+      const expectedSql = `TRIM([Amount])`;
+      const context = createMockContext(['Amount'], 'TrimAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform UPPER function to Sql UPPER function', () => {
+      const formula = `UPPER(Amount)`;
+      const expectedSql = `UPPER([Amount])`;
+      const context = createMockContext(['Amount'], 'UpperAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform VALUE function to Sql VALUE function', () => {
+      const formula = `VALUE(Amount)`;
+      const expectedSql = `CAST([Amount] AS FLOAT)`;
+      const context = createMockContext(['Amount'], 'ValueAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform TEXT function to Sql TEXT function for date', () => {
+      const formula = `TEXT(ShipDate, 'mm/dd/yyyy')`;
+      const expectedSql = `FORMAT([ShipDate], 'MM/dd/yyyy', 'en-US')`;
+      const context = createMockContext(['ShipDate'], 'FormattedShipDate');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform TEXT function to Sql TEXT function for date to extract month', () => {
+      const formula = `TEXT(ShipDate, 'm')`;
+      const expectedSql = `FORMAT([ShipDate], '%M', 'en-US')`;
+      const context = createMockContext(['ShipDate'], 'FormattedShipDate');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform TEXT function to Sql TEXT function for number with currency', () => {
+      const formula = `TEXT(Amount, '$###,###.00')`;
+      const expectedSql = `FORMAT([Amount], '$###,###.00', 'en-US')`;
+      const context = createMockContext(['Amount'], 'FormattedAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+  });
+
+  describe('Math Functions', () => {
+    test('should transform ABS function to Sql ABS function', () => {
+      const formula = `ABS(Amount)`;
+      const expectedSql = `ABS([Amount])`;
+      const context = createMockContext(['Amount'], 'AbsAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform AVERAGE function to Sql expression', () => {
+      const formula = `AVERAGE(M1, M2, M3)`;
+      const expectedSql = `CAST(((COALESCE([M1], 0) + COALESCE([M2], 0) + COALESCE([M3], 0))/3) AS FLOAT)`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'AvgAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform AVERAGEIF function to Sql expression', () => {
+      const formula = `AVERAGEIF([M1, M2, M3], '>1000')`;
+      const expectedSql = `cte_union_AvgAmount AS (SELECT PK, [M1] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M2] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M3] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME), cte_filter_AvgAmount AS (SELECT PK, val_AvgAmount FROM cte_union_AvgAmount WHERE [val_AvgAmount] > 1000), cte_avg_AvgAmount AS (SELECT PK, AVG(val_AvgAmount) AS AvgAmount FROM cte_filter_AvgAmount GROUP BY PK), cte_AvgAmount AS (SELECT $RUNTIME_TABLE_NAME.*, AvgAmount FROM $RUNTIME_TABLE_NAME INNER JOIN cte_avg_AvgAmount ON $RUNTIME_TABLE_NAME.PK = cte_avg_AvgAmount.PK)`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'AvgAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform AVERAGEXNEG function to Sql expression', () => {
+      const formula = `AVERAGEEXNEG([M1, M2, M3])`;
+      const expectedSql = `cte_union_AvgAmount AS (SELECT PK, [M1] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M2] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M3] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME), cte_filter_AvgAmount AS (SELECT PK, val_AvgAmount FROM cte_union_AvgAmount WHERE val_AvgAmount >= 0), cte_avg_AvgAmount AS (SELECT PK, AVG(val_AvgAmount) AS AvgAmount FROM cte_filter_AvgAmount GROUP BY PK), cte_AvgAmount AS (SELECT $RUNTIME_TABLE_NAME.*, AvgAmount FROM $RUNTIME_TABLE_NAME INNER JOIN cte_avg_AvgAmount ON $RUNTIME_TABLE_NAME.PK = cte_avg_AvgAmount.PK)`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'AvgAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform AVERAGEXZERO function to Sql expression', () => {
+      const formula = `AVERAGEEXZERO([M1, M2, M3])`;
+      const expectedSql = `cte_union_AvgAmount AS (SELECT PK, [M1] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M2] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M3] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME), cte_filter_AvgAmount AS (SELECT PK, val_AvgAmount FROM cte_union_AvgAmount WHERE val_AvgAmount != 0), cte_avg_AvgAmount AS (SELECT PK, AVG(val_AvgAmount) AS AvgAmount FROM cte_filter_AvgAmount GROUP BY PK), cte_AvgAmount AS (SELECT $RUNTIME_TABLE_NAME.*, AvgAmount FROM $RUNTIME_TABLE_NAME INNER JOIN cte_avg_AvgAmount ON $RUNTIME_TABLE_NAME.PK = cte_avg_AvgAmount.PK)`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'AvgAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform AVERAGEXZERONEG function to Sql expression', () => {
+      const formula = `AVERAGEEXZERONEG([M1, M2, M3])`;
+      const expectedSql = `cte_union_AvgAmount AS (SELECT PK, [M1] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M2] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M3] AS val_AvgAmount FROM $RUNTIME_TABLE_NAME), cte_filter_AvgAmount AS (SELECT PK, val_AvgAmount FROM cte_union_AvgAmount WHERE val_AvgAmount > 0), cte_avg_AvgAmount AS (SELECT PK, AVG(val_AvgAmount) AS AvgAmount FROM cte_filter_AvgAmount GROUP BY PK), cte_AvgAmount AS (SELECT $RUNTIME_TABLE_NAME.*, AvgAmount FROM $RUNTIME_TABLE_NAME INNER JOIN cte_avg_AvgAmount ON $RUNTIME_TABLE_NAME.PK = cte_avg_AvgAmount.PK)`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'AvgAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform DATE function to Sql expression', () => {
+      const formula = `DATE("date_column", "dd-MM-yyyy")`;
+      const expectedSql = `FORMAT('date_column', 'dd-MM-yyyy')`;
+      const context = createMockContext(['date_column'], 'dd-MM-yyyy');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform CEILING function to Sql CEIL function', () => {
+      const formula = `CEILING(Amount)`;
+      const expectedSql = `CEILING([Amount])`;
+      const context = createMockContext(['Amount'], 'CeilAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform DIVIDE function to Sql DIVIDE function', () => {
+      const formula = `DIVIDE(Amount, 100)`;
+      const expectedSql = `CASE WHEN CAST(100 AS FLOAT) = 0 THEN NULL ELSE CAST([Amount] AS FLOAT) / CAST(100 AS FLOAT) END`;
+      const context = createMockContext(['Amount'], 'DivideAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform INDEXOF function to Sql INDEXOF function', () => {
+      const formula = `INDEXOF([Amount, 10000, 20000], 10000)`;
+      const expectedSql = `CASE WHEN [Amount] = 10000 THEN 0 WHEN 10000 = 10000 THEN 1 WHEN 20000 = 10000 THEN 2 ELSE -1 END`;
+      const context = createMockContext(['Amount'], 'IndexOfAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform IN function to Sql IN function', () => {
+      const formula = `IN(First_Name,['saranya','srinidhi'])`;
+      const expectedSql = `CASE WHEN [First_Name] IN ('saranya', 'srinidhi') THEN 1 ELSE 0 END`;
+      const context = createMockContext(['First_Name'], '[saranya,srinidhi]');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform ISNUMBER function to Sql ISNUMERIC function', () => {
+      const formula = `ISNUMBER(Amount)`;
+      const expectedSql = `ISNUMERIC([Amount])`;
+      const context = createMockContext(['Amount'], 'IsNumericAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform EXP function to Sql EXP function', () => {
+      const formula = `EXP(Amount)`;
+      const expectedSql = `EXP([Amount])`;
+      const context = createMockContext(['Amount'], 'ExpAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform FLOOR function to Sql FLOOR function', () => {
+      const formula = `FLOOR(Amount)`;
+      const expectedSql = `FLOOR([Amount])`;
+      const context = createMockContext(['Amount'], 'FloorAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform LOG function to Sql LOG function', () => {
+      const formula = `LOG(Amount)`;
+      const expectedSql = `LOG([Amount])`;
+      const context = createMockContext(['Amount'], 'LogAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MAX function to Sql MAX function', () => {
+      const formula = `MAX(M1, M2, M3)`;
+      const expectedSql = `GREATEST([M1], [M2], [M3])`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'MaxAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MIN function to Sql MIN function', () => {
+      const formula = `MIN(M1, M2, M3)`;
+      const expectedSql = `LEAST([M1], [M2], [M3])`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'MinAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MOD function to Sql MOD function', () => {
+      const formula = `MOD(Amount, 100)`;
+      const expectedSql = `[Amount] % 100`;
+      const context = createMockContext(['Amount'], 'ModAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform ODD function to Sql ODD function', () => {
+      const formula = `ODD(Amount)`;
+      const expectedSql = `CASE WHEN [Amount] % 2 = 1 THEN [Amount] ELSE [Amount] + 1 END`;
+      const context = createMockContext(['Amount'], 'OddAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform EVEN function to Sql EVEN function', () => {
+      const formula = `EVEN(Amount)`;
+      const expectedSql = `CASE WHEN CAST(FLOOR([Amount]) AS INT) % 2 = 0 THEN CAST(FLOOR([Amount]) AS INT) ELSE CAST(FLOOR([Amount]) AS INT) + 1 END`;
+      const context = createMockContext(['Amount'], 'EvenAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform SWITCH function to Sql SWITCH function', () => {
+      const formula = `SWITCH(Age, 30, "Young", 50, "Old", "Other")`;
+      const expectedSql = `CASE WHEN [Age] = 30 THEN 'Young' WHEN [Age] = 50 THEN 'Old' ELSE 'Other' END`;
+      const context = createMockContext(['Age'], 'switchColumn');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform POW function to Sql POW function', () => {
+      const formula = `POW(Amount, 2)`;
+      const expectedSql = `POWER([Amount], 2)`;
+      const context = createMockContext(['Amount'], 'PowAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform PCT function to Sql PCT function', () => {
+      const formula = `Sales + PCT(15)`;
+      const expectedSql = `[Sales] * (1 + (CAST(15 AS FLOAT) / 100))`;
+      const context = createMockContext(['Sales'], 'PctAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform IFNA function to Sql IFNA function', () => {
+      const formula = `IFNA(Amount, 0)`;
+      const expectedSql = `COALESCE([Amount], 0)`;
+      const context = createMockContext(['Amount'], '0');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform RAND function to Sql RAND function', () => {
+      const formula = `RAND()`;
+      const expectedSql = `RAND()`;
+      const context = createMockContext([], 'RandAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform RANDBETWEEN function to Sql RANDBETWEEN function', () => {
+      const formula = `RANDBETWEEN(100, 200)`;
+      const expectedSql = `(RAND() * (200 - 100) + 100)`;
+      const context = createMockContext([], 'RandBetweenAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform ROUND function to Sql ROUND function', () => {
+      const formula = `ROUND(Amount, 2)`;
+      const expectedSql = `ROUND([Amount], 2)`;
+      const context = createMockContext(['Amount'], 'RoundAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform SUM function to Sql SUM function', () => {
+      const formula = `SUM(M1, M2, M3)`;
+      const expectedSql = `(COALESCE([M1], 0) + COALESCE([M2], 0) + COALESCE([M3], 0))`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'SumAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform SQRT function to Sql SQRT function', () => {
+      const formula = `SQRT(Amount)`;
+      const expectedSql = `SQRT([Amount])`;
+      const context = createMockContext(['Amount'], 'SqrtAmount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+
+    test('should transform MEDIAN function to Sql MEDIAN function', () => {
+      const formula = `MEDIAN(M1, M2, M3)`;
+      const expectedSql = `[cte_union_Median_Amount] AS (SELECT PK, [M1] AS [val_Median_Amount] FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M2] AS [val_Median_Amount] FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [M3] AS [val_Median_Amount] FROM $RUNTIME_TABLE_NAME), [cte_agg_Median_Amount] AS (SELECT DISTINCT PK, PERCENTILE_CONT(0.50) WITHIN GROUP(ORDER BY [val_Median_Amount]) OVER (PARTITION BY PK) AS Median_Amount FROM [cte_union_Median_Amount]), [cte_Median_Amount] AS (SELECT $RUNTIME_TABLE_NAME.*, Median_Amount FROM $RUNTIME_TABLE_NAME INNER JOIN [cte_agg_Median_Amount] ON $RUNTIME_TABLE_NAME.PK = [cte_agg_Median_Amount].PK)`;
+      const context = createMockContext(['M1', 'M2', 'M3'], 'Median_Amount');
+      const parser = createJsToSqlParser(context);
+      const ast = parser.parse(formula);
+      const sql = parser.toSql(ast);
+      expect(sql).toBe(expectedSql);
+    });
+  });
+
+  test('should throw error for unsupported function', () => {
+    const formula = `UNSUPPORTED_FUNCTION([Amount] > 100)`;
+    const context = createMockContext(['Amount'], 'Result');
+    const parser = createJsToSqlParser(context);
+    expect(() => parser.parse(formula)).toThrow('Unsupported function: UNSUPPORTED_FUNCTION');
+  });
+
+  test('should transform LOGGEDIN_EMAIL function to Sql $RUNTIME_LOGGEDIN_EMAIL function', () => {
+    const formula = `LOGGEDIN_EMAIL`;
+    const expectedSql = `'$RUNTIME_LOGGEDIN_EMAIL'`;
+    const context = createMockContext([], 'Email');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform CURRENT_DATE function to Sql $RUNTIME_CURRENT_DATE function', () => {
+    const formula = `{{CURRENT_DATE}}`;
+    const expectedSql = `'$RUNTIME_CURRENT_DATE'`;
+    const context = createMockContext([], 'CurrentDate');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform CURRENT_DATE function to Sql $RUNTIME_CURRENT_DATETIME function', () => {
+    const formula = `{{CURRENT_DATETIME}}`;
+    const expectedSql = `'$RUNTIME_CURRENT_DATETIME'`;
+    const context = createMockContext([], 'CurrentDateTime');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform LOGGEDIN_NAME function to Sql $RUNTIME_LOGGEDIN_NAME function', () => {
+    const formula = `{{LOGGEDIN_NAME}}`;
+    const expectedSql = `'$RUNTIME_LOGGEDIN_NAME'`;
+    const context = createMockContext([], 'Person');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform LOGGEDIN_EMAIL function to Sql $RUNTIME_LOGGEDIN_EMAIL function', () => {
+    const formula = `{{LOGGEDIN_EMAIL}}`;
+    const expectedSql = `'$RUNTIME_LOGGEDIN_EMAIL'`;
+    const context = createMockContext([], 'Email');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform UUID function to Sql NEWID() function', () => {
+    const formula = `UUID`;
+    const expectedSql = `NEWID()`;
+    const context = createMockContext([], 'UniqueId');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform FROMEXCELDATE function to Sql DATEADD() function', () => {
+    const formula = `FROMEXCELDATE(123)`;
+    const expectedSql = `DATEADD(DAY, 123 - 2, '1900-01-01')`;
+    const context = createMockContext([], '123');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform HAS function to Sql HAS() function', () => {
+    const formula = `HAS([id,employee_id],1)`;
+    const expectedSql = `CASE WHEN [id] = 1 OR [employee_id] = 1 THEN 1 ELSE 0 END`;
+    const context = createMockContext(['id', 'employee_id'], '1');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform HAS_SOME function to Sql HAS_SOME() function', () => {
+    const formula = `HAS_SOME([id,employee_id],[1,2])`;
+    const expectedSql = `CASE WHEN [id] = 1 OR [id] = 2 OR [employee_id] = 1 OR [employee_id] = 2 THEN 1 ELSE 0 END`;
+    const context = createMockContext(['id', 'employee_id'], '[1,2]');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform HAS_ALL function to Sql HAS_ALL() function', () => {
+    const formula = `HAS_ALL([id,employee_id],[1,2])`;
+    const expectedSql = `CASE WHEN [id] = 1 OR [employee_id] = 1 OR [id] = 2 OR [employee_id] = 2 THEN 1 ELSE 0 END`;
+    const context = createMockContext(['id', 'employee_id'], '[1,2]');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform FIND function to SQL', () => {
+    const formula = `FIND("T", Name)`;
+    const expectedSql = `CHARINDEX('T', [Name])`;
+    const context = createMockContext(['Name'], 'FindName');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform FIND with start argument to SQL', () => {
+    const formula = `FIND("T", Name, 5)`;
+    const expectedSql = `CHARINDEX('T', [Name], 5)`;
+    const context = createMockContext(['Name'], 'FindNameStart');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform nested FIND inside LEFT', () => {
+    const formula = `LEFT(Name, FIND("T", Name) - 1)`;
+    const expectedSql = `LEFT([Name], (COALESCE(CHARINDEX('T', [Name]), 0) - COALESCE(1, 0)))`;
+    const context = createMockContext(['Name'], 'FindNested');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+
+  test('should transform nested FIND inside MID', () => {
+    const formula = `MID(Name, FIND("T", Name) + 1, LEN(Name))`;
+    const expectedSql = `SUBSTRING([Name], (COALESCE(CHARINDEX('T', [Name]), 0) + COALESCE(1, 0)), LEN([Name]))`;
+    const context = createMockContext(['Name'], 'FindMid');
+    const parser = createJsToSqlParser(context);
+    const ast = parser.parse(formula);
+    const sql = parser.toSql(ast);
+    expect(sql).toBe(expectedSql);
+  });
+});