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

package/tests/QueryBuilder.test.ts

@@ -0,0 +1,1320 @@
+// write tests for QueryBuilder
+
+import { MDM_COLUMN_TYPE, ResolvedExpressionType } from '../src/js-lib/ParseContext';
+import { IMDMColumnConfigWithParsedMeta } from '../src/js-lib/ParseContext';
+import { QueryBuilder, QueryBuilderImpl } from '../src/query-builder/QueryBuilder';
+import { MockQueryResolver } from './mocks/MockQueryResolver';
+import { createPaginationBuilder } from '../src/query-builder/PaginationBuilder';
+import { RUNTIME_LOGGEDIN_EMAIL, RUNTIME_LOGGEDIN_NAME } from '../src/runtime_var';
+
+describe('QueryBuilder', () => {
+  const mockQueryResolver = new MockQueryResolver('TestTable');
+  const mockRuntimeVariables = {
+    $RUNTIME_LOGGEDIN_EMAIL: 'test@mdm.com',
+    $RUNTIME_LOGGEDIN_NAME: 'Test User',
+  };
+
+  test('should create sql query when table does not have formula columns', () => {
+    const filterResolverSpy = jest.spyOn(mockQueryResolver, 'filterResolver');
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Amount', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Amount', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT [Amount], [Status] FROM [mdm].[dbo].[TestTable] WHERE [Amount] > 100 AND LOWER([Status]) = 'active' ORDER BY [Amount] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+    expect(filterResolverSpy).toHaveBeenCalledTimes(1);
+    filterResolverSpy.mockRestore();
+  });
+
+  test('should create sql query with pagination based on mssql database', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Amount', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Amount', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: new MockQueryResolver('TestTable'),
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT [Amount], [Status] FROM [mdm].[dbo].[TestTable] WHERE [Amount] > 100 AND LOWER([Status]) = 'active' ORDER BY [Amount] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create sql query when table does not have formula columns and distinct is true', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Amount'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Amount', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Amount', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT DISTINCT [Amount] FROM [mdm].[dbo].[TestTable] WHERE [Amount] > 100 AND LOWER([Status]) = 'active' ORDER BY [Amount] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression as column expression', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status', 'Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Amount', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Amount', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE [Amount] > 100 AND LOWER([Status]) = 'active' ORDER BY [Amount] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression as column expression and distinct is true', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Status', 'Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Amount', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Amount', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT DISTINCT [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE [Amount] > 100 AND LOWER([Status]) = 'active' OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression as column expression with dependency only on native columns', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+      Revenue: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Revenue',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] * 0.25'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status', 'Result', 'Revenue'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Amount', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Amount', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT [Amount], [Status], [Amount] + 100 AS [Result], [Amount] * 0.25 AS [Revenue] FROM [mdm].[dbo].[TestTable] WHERE [Amount] > 100 AND LOWER([Status]) = 'active' ORDER BY [Amount] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create sql query when table has multiple formula columns with resolved expression as column expression', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Price: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Price', columnMeta: {} },
+      Quantity: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'Quantity',
+        columnMeta: {},
+      },
+      SalePrice: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'SalePrice',
+        columnMeta: {},
+      },
+      Cost: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Cost',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Price] * [Quantity]'],
+            },
+          },
+          deps: ['Price', 'Quantity'],
+        },
+      },
+      Profit: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Profit',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[SalePrice] - [Cost]'],
+            },
+          },
+          deps: ['SalePrice', 'Cost'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Price', 'Quantity', 'Cost', 'Profit'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Price', operator: '>', value: 100 },
+          { column: 'Quantity', operator: '=', value: 100 },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Price', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Price], [Quantity], [SalePrice], [Price] * [Quantity] AS [Cost] FROM [mdm].[dbo].[TestTable] WHERE [Price] > 100 AND [Quantity] = 100 ORDER BY [Price] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY), cte_staging_cte_main AS (SELECT *, [SalePrice] - [Cost] AS [Profit] FROM cte_main) SELECT * FROM cte_staging_cte_main`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression as cte', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Price: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Price', columnMeta: {} },
+      Quantity: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'Quantity',
+        columnMeta: {},
+      },
+      SalePrice: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'SalePrice',
+        columnMeta: {},
+      },
+      Cost: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Cost',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.CTE,
+              cteName: 'cte_cost',
+              value: [
+                'cte_cost AS (SELECT *, [Price] * [Quantity] AS [Cost] FROM $RUNTIME_TABLE_NAME)',
+              ],
+            },
+          },
+        },
+      },
+      Profit: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Profit',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[SalePrice] - [Cost]'],
+            },
+          },
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Price', 'Quantity', 'Cost', 'Profit'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Price', operator: '>', value: 100 },
+          { column: 'Quantity', operator: '=', value: 100 },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Price', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Price], [Quantity] FROM [mdm].[dbo].[TestTable] WHERE [Price] > 100 AND [Quantity] = 100 ORDER BY [Price] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY), cte_cost AS (SELECT *, [Price] * [Quantity] AS [Cost] FROM cte_main), cte_staging_cte_cost AS (SELECT *, [SalePrice] - [Cost] AS [Profit] FROM cte_cost) SELECT * FROM cte_staging_cte_cost`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression as column expression with filter and sort and distinct is true', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Result', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active') SELECT DISTINCT [Result] FROM cte_main WHERE [Result] > 100 ORDER BY [Result] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression as cte with filter and sort', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Price: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Price', columnMeta: {} },
+      Quantity: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'Quantity',
+        columnMeta: {},
+      },
+      SalePrice: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'SalePrice',
+        columnMeta: {},
+      },
+      Profit: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Profit',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[SalePrice] - [Cost]'],
+            },
+          },
+          deps: ['SalePrice', 'Cost'],
+        },
+      },
+      Cost: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Cost',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.CTE,
+              cteName: 'cte_cost',
+              value: [
+                'cte_cost AS (SELECT *, [Price] * [Quantity] AS [Cost] FROM $RUNTIME_TABLE_NAME)',
+              ],
+            },
+          },
+          deps: ['Price', 'Quantity'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Price', 'Quantity', 'Cost', 'Profit'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Cost', operator: '>', value: 100 },
+          { column: 'Quantity', operator: '=', value: 100 },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Profit', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Price], [Quantity], [SalePrice] FROM [mdm].[dbo].[TestTable] WHERE [Quantity] = 100), cte_cost AS (SELECT *, [Price] * [Quantity] AS [Cost] FROM cte_main), cte_staging_cte_cost AS (SELECT *, [SalePrice] - [Cost] AS [Profit] FROM cte_cost WHERE [Cost] > 100 ORDER BY [Profit] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY) SELECT * FROM cte_staging_cte_cost`,
+    );
+  });
+
+  test('should create sql query when table has formula columns with resolved expression containing aggregate function as cte with filter and sort', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Price: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Price', columnMeta: {} },
+      Quantity: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'Quantity',
+        columnMeta: {},
+      },
+      SalePrice: {
+        columnType: MDM_COLUMN_TYPE.NUMBER,
+        columnName: 'SalePrice',
+        columnMeta: {},
+      },
+      Cost: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Cost',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.CTE,
+              cteName: 'cte_cost',
+              value: [
+                'cte_cost AS (SELECT *, [Price] * [Quantity] AS [Cost] FROM $RUNTIME_TABLE_NAME)',
+              ],
+            },
+          },
+          deps: ['Price', 'Quantity'],
+        },
+      },
+      MinPrice: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'MinPrice',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.CTE,
+              cteName: 'cte_MinAmount_0_17',
+              value: [
+                'cte_union_MinAmount_0_17 AS (SELECT PK, [Cost] AS [val_MinAmount] FROM $RUNTIME_TABLE_NAME UNION ALL SELECT PK, [SalePrice] AS [val_MinAmount] FROM $RUNTIME_TABLE_NAME), cte_agg_MinAmount_0_17 AS (SELECT PK, MIN([val_MinAmount]) AS [MinAmount] FROM cte_union_MinAmount_0_17 GROUP BY PK), cte_MinAmount_0_17 AS (SELECT $RUNTIME_TABLE_NAME.*, [MinAmount] FROM $RUNTIME_TABLE_NAME INNER JOIN cte_agg_MinAmount_0_17 ON $RUNTIME_TABLE_NAME.PK = cte_agg_MinAmount_0_17.PK)',
+              ],
+            },
+          },
+          deps: ['Cost', 'SalePrice'],
+        },
+      },
+      Profit: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Profit',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[SalePrice] - [Cost]'],
+            },
+          },
+          deps: ['SalePrice', 'Cost'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Price', 'Quantity', 'Cost', 'Profit', 'MinPrice'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Cost', operator: '>', value: 100 },
+          { column: 'Quantity', operator: '=', value: 100 },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'MinPrice', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Price], [Quantity], [SalePrice] FROM [mdm].[dbo].[TestTable] WHERE [Quantity] = 100), cte_cost AS (SELECT *, [Price] * [Quantity] AS [Cost] FROM cte_main), cte_staging_cte_cost AS (SELECT *, [SalePrice] - [Cost] AS [Profit] FROM cte_cost WHERE [Cost] > 100), cte_union_MinAmount_0_17 AS (SELECT PK, [Cost] AS [val_MinAmount] FROM cte_staging_cte_cost UNION ALL SELECT PK, [SalePrice] AS [val_MinAmount] FROM cte_staging_cte_cost), cte_agg_MinAmount_0_17 AS (SELECT PK, MIN([val_MinAmount]) AS [MinAmount] FROM cte_union_MinAmount_0_17 GROUP BY PK), cte_MinAmount_0_17 AS (SELECT cte_staging_cte_cost.*, [MinAmount] FROM cte_staging_cte_cost INNER JOIN cte_agg_MinAmount_0_17 ON cte_staging_cte_cost.PK = cte_agg_MinAmount_0_17.PK), cte_post_cte_MinAmount_0_17 AS (SELECT * FROM cte_MinAmount_0_17 ORDER BY [MinPrice] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY) SELECT * FROM cte_post_cte_MinAmount_0_17`,
+    );
+  });
+
+  test('shouild create query including dependencies which are not part of selected columns', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Result'], // does not include 'Amount' column but it is a dependency of 'Result' column
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Result', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active') SELECT * FROM cte_main WHERE [Result] > 100 ORDER BY [Result] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should return calculation order', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Price: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Price', columnMeta: {} },
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      F1: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'F1',
+        columnMeta: { deps: ['Amount'] },
+      },
+      F2: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'F2',
+        columnMeta: { deps: ['Amount', 'Status'] },
+      },
+      F3: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'F3',
+        columnMeta: { deps: ['Amount', 'F1'] },
+      },
+      F4: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'F4',
+        columnMeta: { deps: ['F2', 'Status'] },
+      },
+      F5: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'F5',
+        columnMeta: { deps: ['F1', 'F3'] },
+      },
+    };
+
+    const queryBuilder = new QueryBuilderImpl(
+      {
+        distinct: true,
+        selectedColumns: ['Status', 'Result'], // does not include 'Amount' column but it is a dependency of 'Result' column
+        databaseDetails: {
+          dataTableName: 'TestTable',
+
+          schema: 'dbo',
+          database: 'mdm',
+        },
+        primaryKeyColumns: ['PK'],
+        filterConfig: { rules: [], combinator: 'and', not: false },
+        pagination: { skip: 100, take: 200 },
+        sortConfig: [{ column: 'F1', order: 'ASC' }],
+        columnConfigMap: mockColumnConfigMap,
+        queryResolver: mockQueryResolver,
+        runtimeVariables: mockRuntimeVariables,
+      },
+      createPaginationBuilder(),
+    );
+
+    const calcOrder = queryBuilder.getCalculationOrder(new Set(['F1', 'F2', 'F3', 'F4', 'F5']));
+    expect(calcOrder.nativeColumns).toEqual(new Set(['Amount', 'Status']));
+    expect(
+      calcOrder.formulaColumnsByDependencyLevel.map((c) => c.map((c) => c.columnName)),
+    ).toEqual([['F1', 'F2'], ['F3', 'F4'], ['F5']]);
+  });
+
+  test('should create count query', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Status', 'Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Result', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Status], [Amount], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active') SELECT COUNT(*) AS row_count FROM cte_main WHERE [Result] > 100`,
+    );
+  });
+
+  test('should create distinct count query with formula column having filter', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Result', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'), cte_distinct_cte_main AS (SELECT DISTINCT [Result] FROM cte_main WHERE [Result] > 100) SELECT COUNT(*) AS row_count FROM cte_distinct_cte_main`,
+    );
+  });
+
+  test('should create distinct count query with formula column having no filters on formula column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT DISTINCT [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active') SELECT COUNT(*) AS row_count FROM cte_main`,
+    );
+  });
+
+  test('should create count query for multiple columns with formula column dependency on just native column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Status', 'Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `SELECT COUNT(*) AS row_count FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'`,
+    );
+  });
+
+  test('should create count query for multiple columns with formula column dependency on another formula column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+      Result_2: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result_2',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Result] * 2'],
+            },
+          },
+          deps: ['Result'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Result', 'Result_2'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'), cte_staging_cte_main AS (SELECT *, [Result] * 2 AS [Result_2] FROM cte_main) SELECT COUNT(*) AS row_count FROM cte_staging_cte_main`,
+    );
+  });
+
+  test('should create distinct count query for multiple columns with formula column dependency on another formula column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+      Result_2: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result_2',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Result] * 2'],
+            },
+          },
+          deps: ['Result'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Result_2'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'), cte_staging_cte_main AS (SELECT *, [Result] * 2 AS [Result_2] FROM cte_main), cte_distinct_cte_staging_cte_main AS (SELECT DISTINCT [Result_2] FROM cte_staging_cte_main) SELECT COUNT(*) AS row_count FROM cte_distinct_cte_staging_cte_main`,
+    );
+  });
+
+  test('should add search expression to the query with only native columns', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Status', order: 'ASC' }],
+      searchExpression: `WHERE (LOWER(CAST([Amount] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Status] AS VARCHAR)) LIKE '%2%')`,
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT [Amount], [Status] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active' AND (LOWER(CAST([Amount] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Status] AS VARCHAR)) LIKE '%2%') ORDER BY [Status] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should add search expression to the query with formula columns having resolved expression as column expression', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status', 'Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Status', order: 'ASC' }],
+      searchExpression: `WHERE (LOWER(CAST([Amount] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Status] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Result] AS VARCHAR)) LIKE '%2%')`,
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active') SELECT * FROM cte_main WHERE (LOWER(CAST([Amount] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Status] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Result] AS VARCHAR)) LIKE '%2%') ORDER BY [Status] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should add search expression to the query with formula columns dependent on another formula column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+      Total: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Total',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Result] + 100'],
+            },
+          },
+          deps: ['Result'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status', 'Result', 'Total'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Status', operator: '=', value: 'Active' },
+          { column: 'Result', operator: '=', value: 200 },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Status', order: 'ASC' }],
+      searchExpression: `WHERE (LOWER(CAST([Amount] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Status] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Result] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Total] AS VARCHAR)) LIKE '%2%')`,
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Amount], [Status], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'), cte_staging_cte_main AS (SELECT *, [Result] + 100 AS [Total] FROM cte_main WHERE [Result] = 200) SELECT * FROM cte_staging_cte_main WHERE (LOWER(CAST([Amount] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Status] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Result] AS VARCHAR)) LIKE '%2%' OR LOWER(CAST([Total] AS VARCHAR)) LIKE '%2%') ORDER BY [Status] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should resolve runtime variables', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      LoggedInInfo: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'LoggedInInfo',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: [
+                `CONCAT('Name: ', '${RUNTIME_LOGGEDIN_NAME}', ', Email: ', '${RUNTIME_LOGGEDIN_EMAIL}')`,
+              ],
+            },
+          },
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      selectedColumns: ['Amount', 'Status', 'LoggedInInfo'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Status', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.build();
+    expect(sql?.finalQuery).toBe(
+      `SELECT [Amount], [Status], CONCAT('Name: ', 'Test User', ', Email: ', 'test@mdm.com') AS [LoggedInInfo] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active' ORDER BY [Status] ASC OFFSET 100 ROWS FETCH NEXT 200 ROWS ONLY`,
+    );
+  });
+
+  test('should create distinct count query with formula column dependency on just native column and more than one selected column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Status', 'Result'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [
+          { column: 'Result', operator: '>', value: 100 },
+          { column: 'Status', operator: '=', value: 'Active' },
+        ],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Status], [Amount], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'), cte_distinct_cte_main AS (SELECT DISTINCT [Status], [Result] FROM cte_main WHERE [Result] > 100) SELECT COUNT(*) AS row_count FROM cte_distinct_cte_main`,
+    );
+  });
+
+  test('should create distinct count query for multiple columns with formula column dependency on another formula column and more than one selected column', () => {
+    const mockColumnConfigMap: Record<string, IMDMColumnConfigWithParsedMeta> = {
+      Amount: { columnType: MDM_COLUMN_TYPE.NUMBER, columnName: 'Amount', columnMeta: {} },
+      Status: { columnType: MDM_COLUMN_TYPE.TEXT, columnName: 'Status', columnMeta: {} },
+      Result: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Amount] + 100'],
+            },
+          },
+          deps: ['Amount'],
+        },
+      },
+      Result_2: {
+        columnType: MDM_COLUMN_TYPE.FORMULA,
+        columnName: 'Result_2',
+        columnMeta: {
+          sqlQueryProps: {
+            resolvedExpression: {
+              type: ResolvedExpressionType.COLUMN,
+              value: ['[Result] * 2'],
+            },
+          },
+          deps: ['Result'],
+        },
+      },
+    };
+    const queryBuilder = new QueryBuilder({
+      distinct: true,
+      selectedColumns: ['Status', 'Result_2'],
+      databaseDetails: {
+        dataTableName: 'TestTable',
+
+        schema: 'dbo',
+        database: 'mdm',
+      },
+      primaryKeyColumns: ['PK'],
+      filterConfig: {
+        rules: [{ column: 'Status', operator: '=', value: 'Active' }],
+        combinator: 'and',
+        not: false,
+      },
+      pagination: { skip: 100, take: 200 },
+      sortConfig: [{ column: 'Result', order: 'ASC' }],
+      columnConfigMap: mockColumnConfigMap,
+      queryResolver: mockQueryResolver,
+      runtimeVariables: mockRuntimeVariables,
+    });
+    const sql = queryBuilder.buildCountQuery();
+    expect(sql?.finalQuery).toBe(
+      `WITH cte_main AS (SELECT [Status], [Amount], [Amount] + 100 AS [Result] FROM [mdm].[dbo].[TestTable] WHERE LOWER([Status]) = 'active'), cte_staging_cte_main AS (SELECT *, [Result] * 2 AS [Result_2] FROM cte_main), cte_distinct_cte_staging_cte_main AS (SELECT DISTINCT [Status], [Result_2] FROM cte_staging_cte_main) SELECT COUNT(*) AS row_count FROM cte_distinct_cte_staging_cte_main`,
+    );
+  });
+});