@quillsql/react 2.12.31 → 2.12.33

package/dist/esm/utils/astFilterProcessing.uspec.js

@@ -1,2877 +0,0 @@
-/* eslint-disable no-undef */
-import { BoolOperator, DateOperator, FieldTypes, FilterNames, NullOperator, NumberOperator, StringOperator, TimeUnit, } from '../models/Filter';
-import { astToFilter, filterToAst } from './astFilterProcessing';
-import { format, subDays, subMonths, subYears } from 'date-fns';
-import * as fs from 'fs';
-import * as path from 'path';
-const astLookup = () => {
-    const filePath = path.join(__dirname, 'astFilterProcessingInputs.json');
-    const fileContent = fs.readFileSync(filePath, 'utf-8');
-    return JSON.parse(fileContent);
-};
-const parseSelectSQL = (sql, db) => astLookup()[sql][db ?? 'default'];
-describe('Filter to AST - String', () => {
-    it('should convert Filter to AST for string field - Is', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringInFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Is,
-            value: ['value 1', 'value 2'],
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) IN (LOWER('value 1'), LOWER('value 2'))";
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNot', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringInFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNot,
-            value: ['value 1', 'value 2'],
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) NOT IN (LOWER('value 1'), LOWER('value 2'))";
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNull', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNull,
-            value: null,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field IS NULL';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNotNull', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNotNull,
-            value: null,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field IS NOT NULL';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsExactly (Redshift)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = "SELECT * FROM t WHERE LOWER(field) = LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsExactly (Snowflake)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = "SELECT * FROM t WHERE LOWER(field) = LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsExactly (Bigquery)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = "SELECT * FROM t WHERE LOWER(field) = LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsExactly (PostgresQL)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) = LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsExactly (MySQL)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) = LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNotExactly (Redshift)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNotExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = "SELECT * FROM t WHERE LOWER(field) <> LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNotExactly (Snowflake)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNotExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = "SELECT * FROM t WHERE LOWER(field) <> LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNotExactly (BigQuery)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNotExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = "SELECT * FROM t WHERE LOWER(field) <> LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNotExactly (PostgresQL)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNotExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) <> LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - IsNotExactly (MySQL)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNotExactly,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) <> LOWER('value 1')";
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - Contains (Redshift)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Contains,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = "SELECT * FROM t WHERE LOWER(field) LIKE LOWER('%value 1%')";
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - Contains (Snowflake)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Contains,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = "SELECT * FROM t WHERE LOWER(field) LIKE LOWER('%value 1%')";
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - Contains (BigQuery)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Contains,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = "SELECT * FROM t WHERE LOWER(field) LIKE LOWER('%value 1%')";
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - Contains (PostgresQL)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Contains,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) LIKE LOWER('%value 1%')";
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for string field - Contains (MySQL)', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Contains,
-            value: 'value 1',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = "SELECT * FROM t WHERE LOWER(field) LIKE LOWER('%value 1%')";
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - String', () => {
-    it('should convert AST to Filter for string field - Is', () => {
-        const sql = "SELECT * FROM t WHERE LOWER(field) IN (LOWER('value 1'), LOWER('value 2'))";
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.StringInFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Is,
-            value: ['value 1', 'value 2'],
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for string field - IsNot', () => {
-        const sql = "SELECT * FROM t WHERE LOWER(field) NOT IN (LOWER('value 1'), LOWER('value 2'))";
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.StringInFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNot,
-            value: ['value 1', 'value 2'],
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for string field - IsNull', () => {
-        const sql = 'SELECT * FROM t WHERE field IS NULL';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNull,
-            value: null,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for string field - IsNotNull', () => {
-        const sql = 'SELECT * FROM t WHERE field IS NOT NULL';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNotNull,
-            value: null,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for string field - IsExactly', () => {
-        const sql = "SELECT * FROM t WHERE field = 'value 1'";
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsExactly,
-            value: 'value 1',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for string field - IsNotExactly', () => {
-        const sql = "SELECT * FROM t WHERE field <> 'value 1'";
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.IsNotExactly,
-            value: 'value 1',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for string field - Contains', () => {
-        const sql = "SELECT * FROM t WHERE field LIKE '%value 1%'";
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.StringFilter,
-            type: FieldTypes.String,
-            operator: StringOperator.Contains,
-            value: 'value 1',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Numeric', () => {
-    it('should convert Filter to AST for numeric field - EqualTo', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.EqualTo,
-            value: 123,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field = 123';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - NotEqualTo', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.NotEqualTo,
-            value: 123,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field <> 123';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - GreaterThan', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.GreaterThan,
-            value: 123,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field > 123';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - LessThan', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.LessThan,
-            value: 123,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field < 123';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - GreaterThanOrEqualTo', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.GreaterThanOrEqualTo,
-            value: 123,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field >= 123';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - LessThanOrEqualTo', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.LessThanOrEqualTo,
-            value: 123,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field <= 123';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - IsNull', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNull,
-            value: null,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field IS NULL';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for numeric field - IsNotNull', () => {
-        const filter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNotNull,
-            value: null,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = 'SELECT * FROM t WHERE field IS NOT NULL';
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Numeric', () => {
-    it('should convert AST to Filter for numeric field - EqualTo', () => {
-        const sql = 'SELECT * FROM t WHERE field = 123';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.EqualTo,
-            value: 123,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - NotEqualTo', () => {
-        const sql = 'SELECT * FROM t WHERE field <> 123';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.NotEqualTo,
-            value: 123,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - GreaterThan', () => {
-        const sql = 'SELECT * FROM t WHERE field > 123';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.GreaterThan,
-            value: 123,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - LessThan', () => {
-        const sql = 'SELECT * FROM t WHERE field < 123';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.LessThan,
-            value: 123,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - GreaterThanOrEqualTo', () => {
-        const sql = 'SELECT * FROM t WHERE field >= 123';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.GreaterThanOrEqualTo,
-            value: 123,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - LessThanOrEqualTo', () => {
-        const sql = 'SELECT * FROM t WHERE field <= 123';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NumericFilter,
-            type: FieldTypes.Numeric,
-            operator: NumberOperator.LessThanOrEqualTo,
-            value: 123,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - IsNotNull', () => {
-        const sql = 'SELECT * FROM t WHERE field IS NOT NULL';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNotNull,
-            value: null,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for numeric field - IsNull', () => {
-        const sql = 'SELECT * FROM t WHERE field IS NULL';
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'field',
-            name: FilterNames.NullFilter,
-            type: FieldTypes.Null,
-            operator: NullOperator.IsNull,
-            value: null,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Date (Custom)', () => {
-    it('should convert Filter to AST for date field - Custom', () => {
-        const filter = {
-            field: 'date_field',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: '2024-05-12',
-                endDate: '2024-06-11',
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = "SELECT * FROM t WHERE date_field BETWEEN '2024-05-12' AND '2024-06-11'";
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Date (Custom)', () => {
-    it('should convert AST to Filter for date field - Custom', () => {
-        const sql = "SELECT * FROM t WHERE date_field BETWEEN '2024-05-12' AND '2024-06-11'";
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'date_field',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: '2024-05-12',
-                endDate: '2024-06-11',
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Date (InTheLast', () => {
-    it('should convert Filter to AST for date field - InTheLast (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= DATEADD(day, -90, CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheLast (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= CURRENT_DATE() - INTERVAL '90 DAY'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheLast (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheLast (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= CURDATE() - INTERVAL 1 MONTH
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheLast (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 30,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= CURRENT_DATE - INTERVAL '30 months'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Date (InTheLast)', () => {
-    it('should convert AST to Filter for date field (Redshift-1) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= DATEADD(day, -90, CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-2) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= DATEADD(day, -90, GETDATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-1) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= CURRENT_DATE() - INTERVAL '1 YEAR'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-2) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(YEAR, -1, CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (BigQuery) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'bigquery');
-        const filter = astToFilter(ast.where, 'bigquery');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-1) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= CURDATE() - INTERVAL 1 MONTH
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-2) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= DATE_SUB(CURDATE(), INTERVAL 1 MONTH)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-3) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= DATE_SUB(NOW(), INTERVAL 1 MONTH)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Postgres) - InTheLast', () => {
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= CURRENT_DATE - INTERVAL 1 month
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheLast,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Date (InTheCurrent', () => {
-    it('should convert Filter to AST for date field - InTheCurrent Year (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('year', CURRENT_DATE)
-      AND transaction_date < (DATE_TRUNC('year', CURRENT_DATE) + INTERVAL '1 year')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Year (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Year (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Year (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Year (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('year', transaction_date) = DATE_TRUNC('year', CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Quarter (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Quarter,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('quarter', CURRENT_DATE)
-      AND transaction_date < (DATE_TRUNC('quarter', CURRENT_DATE) + INTERVAL '1 quarter')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Quarter (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Quarter,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND QUARTER(transaction_date) = QUARTER(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Quarter (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Quarter,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(QUARTER FROM transaction_date) = EXTRACT(QUARTER FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Quarter (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Quarter,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND QUARTER(transaction_date) = QUARTER(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Month (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Quarter,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('quarter', transaction_date) = DATE_TRUNC('quarter', CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Month (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('month', CURRENT_DATE)
-      AND transaction_date < (DATE_TRUNC('month', CURRENT_DATE) + INTERVAL '1 month')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Month (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Month (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Month (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Month (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('month', transaction_date) = DATE_TRUNC('month', CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Week (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Week,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('week', CURRENT_DATE)
-      AND transaction_date < (DATE_TRUNC('week', CURRENT_DATE) + INTERVAL '1 week')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Week (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Week,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-      AND WEEK(transaction_date) = WEEK(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Week (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Week,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-      AND EXTRACT(WEEK FROM transaction_date) = EXTRACT(WEEK FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Week (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Week,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-      AND WEEK(transaction_date) = WEEK(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Week (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Week,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('week', transaction_date) = DATE_TRUNC('week', CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Day (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('day', CURRENT_DATE)
-      AND transaction_date < (DATE_TRUNC('day', CURRENT_DATE) + INTERVAL '1 day')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Day (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-      AND DAY(transaction_date) = DAY(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Day (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-      AND EXTRACT(DAY FROM transaction_date) = EXTRACT(DAY FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Day (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-      AND DAY(transaction_date) = DAY(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Day (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('day', transaction_date) = DATE_TRUNC('day', CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Hour (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Hour,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('hour', CURRENT_TIMESTAMP)
-      AND transaction_date < (DATE_TRUNC('hour', CURRENT_TIMESTAMP) + INTERVAL '1 hour')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Hour (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Hour,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_TIMESTAMP())
-      AND MONTH(transaction_date) = MONTH(CURRENT_TIMESTAMP())
-      AND DAY(transaction_date) = DAY(CURRENT_TIMESTAMP())
-      AND HOUR(transaction_date) = HOUR(CURRENT_TIMESTAMP())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Hour (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Hour,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_TIMESTAMP())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_TIMESTAMP())
-      AND EXTRACT(DAY FROM transaction_date) = EXTRACT(DAY FROM CURRENT_TIMESTAMP())
-      AND EXTRACT(HOUR FROM transaction_date) = EXTRACT(HOUR FROM CURRENT_TIMESTAMP())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Hour (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Hour,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_TIMESTAMP())
-      AND MONTH(transaction_date) = MONTH(CURRENT_TIMESTAMP())
-      AND DAY(transaction_date) = DAY(CURRENT_TIMESTAMP())
-      AND HOUR(transaction_date) = HOUR(CURRENT_TIMESTAMP())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InTheCurrent Hour (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Hour,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('hour', transaction_date) = DATE_TRUNC('hour', CURRENT_TIMESTAMP)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Date (InTheCurrent)', () => {
-    it('should convert AST to Filter for date field (Redshift-1) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE)
-      AND EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-2) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_TRUNC('month', CURRENT_DATE)
-      AND transaction_date < (DATE_TRUNC('month', CURRENT_DATE) + INTERVAL '1 month')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-3) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-4) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(DAY FROM transaction_date) = EXTRACT(DAY FROM CURRENT_DATE)
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE)
-      AND EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-5) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE)
-      AND EXTRACT(DAY FROM transaction_date) = EXTRACT(DAY FROM CURRENT_DATE)
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-1) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-2) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-3) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-4) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND DAY(transaction_date) = DAY(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-5) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(DAY FROM transaction_date) = EXTRACT(DAY FROM CURRENT_DATE())
-      AND EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (BigQuery-1) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'bigquery');
-        const filter = astToFilter(ast.where, 'bigquery');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (BigQuery-2) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE EXTRACT(YEAR FROM transaction_date) = EXTRACT(YEAR FROM CURRENT_DATE())
-      AND EXTRACT(DAY FROM transaction_date) = EXTRACT(DAY FROM CURRENT_DATE())
-      AND EXTRACT(MONTH FROM transaction_date) = EXTRACT(MONTH FROM CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'bigquery');
-        const filter = astToFilter(ast.where, 'bigquery');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-1) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-2) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURDATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-1) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE YEAR(transaction_date) = YEAR(CURRENT_DATE())
-      AND DAY(transaction_date) = DAY(CURRENT_DATE())
-      AND MONTH(transaction_date) = MONTH(CURRENT_DATE())
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Postgres-1) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE DATE_TRUNC('month', transaction_date) = DATE_TRUNC('month', CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Postgres-2) - InTheCurrent', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE created_at >= date_trunc('month', CURRENT_DATE)
-      AND created_at < (date_trunc('month', CURRENT_DATE) + INTERVAL '1 month')
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'created_at',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InTheCurrent,
-            value: {
-                value: 0,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Date (InThePrevious)', () => {
-    it('should convert Filter to AST for date field - InThePrevious (Redshift)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 100,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'redshift');
-        const sql = `
-      SELECT * FROM transactions 
-      WHERE transaction_date >= DATEADD(month, -200, CURRENT_DATE) 
-      AND transaction_date < DATEADD(month, -100, CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'redshift').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InThePrevious (Snowflake)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 100,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'snowflake');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= CURRENT_DATE() - INTERVAL '200 MONTHS'
-      AND transaction_date < CURRENT_DATE() - INTERVAL '100 MONTHS'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'snowflake').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InThePrevious (BigQuery)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 100,
-                unit: TimeUnit.Month,
-            },
-        };
-        const ast = filterToAst(filter, 'bigquery');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 200 MONTH)
-      AND transaction_date < DATE_SUB(CURRENT_DATE(), INTERVAL 100 MONTH)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'bigquery').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InThePrevious (MySQL)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 2,
-                unit: TimeUnit.Year,
-            },
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= CURDATE() - INTERVAL 4 YEAR
-      AND transaction_date < CURDATE() - INTERVAL 2 YEAR
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - InThePrevious (Postgres)', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 40,
-                unit: TimeUnit.Day,
-            },
-        };
-        const ast = filterToAst(filter, 'postgresql');
-        const sql = `
-      SELECT *
-      FROM transactions
-      WHERE transaction_date >= CURRENT_DATE - INTERVAL '80 days'
-      AND transaction_date < CURRENT_DATE - INTERVAL '40 days'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'postgresql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Date (InThePrevious)', () => {
-    it('should convert AST to Filter for date field (Redshift-1) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(day, -180, CURRENT_DATE)
-      AND transaction_date < DATEADD(day, -90, CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-2) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(day, -180, GETDATE())
-      AND transaction_date < DATEADD(day, -90, GETDATE())
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-1) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= CURRENT_DATE() - INTERVAL '2 YEARS'
-      AND transaction_date < CURRENT_DATE() - INTERVAL '1 YEAR'
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 1,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-2) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(YEAR, -2, CURRENT_DATE())
-      AND transaction_date < DATEADD(YEAR, -1, CURRENT_DATE())
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 1,
-                unit: TimeUnit.Year,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (BigQuery) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 180 DAY)
-      AND transaction_date < DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'bigquery');
-        const filter = astToFilter(ast.where, 'bigquery');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 90,
-                unit: TimeUnit.Day,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-1) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= CURDATE() - INTERVAL 2 MONTH
-      AND transaction_date < CURDATE() - INTERVAL 1 MONTH
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-2) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_SUB(CURDATE(), INTERVAL 2 MONTH)
-      AND transaction_date < DATE_SUB(CURDATE(), INTERVAL 1 MONTH)
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-3) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_SUB(NOW(), INTERVAL 2 MONTH)
-      AND transaction_date < DATE_SUB(NOW(), INTERVAL 1 MONTH)
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Postgres) - InThePrevious', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= CURRENT_DATE - INTERVAL 2 month
-      AND transaction_date < CURRENT_DATE - INTERVAL 1 month
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.InThePrevious,
-            value: {
-                value: 1,
-                unit: TimeUnit.Month,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('AST to Filter - Date (InThePrevious Custom Cases)', () => {
-    it('should convert AST to Filter for date field (Redshift-1) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(day, -200, CURRENT_DATE)
-      AND transaction_date < DATEADD(day, -90, CURRENT_DATE)
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const currentDate = new Date();
-        const dateMinus200Days = subDays(currentDate, 200);
-        const dateMinus90Days = subDays(currentDate, 90);
-        const formattedStartDate = format(dateMinus200Days, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus90Days, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Redshift-2) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(day, -200, GETDATE())
-      AND transaction_date < DATEADD(day, -90, GETDATE())
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'redshift');
-        const filter = astToFilter(ast.where, 'redshift');
-        const currentDate = new Date();
-        const dateMinus200Days = subDays(currentDate, 200);
-        const dateMinus90Days = subDays(currentDate, 90);
-        const formattedStartDate = format(dateMinus200Days, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus90Days, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-1) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= CURRENT_DATE() - INTERVAL '4 YEARS'
-      AND transaction_date < CURRENT_DATE() - INTERVAL '1 YEAR'
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const currentDate = new Date();
-        const dateMinus4Years = subYears(currentDate, 4);
-        const dateMinus1Year = subYears(currentDate, 1);
-        const formattedStartDate = format(dateMinus4Years, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus1Year, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Snowflake-2) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATEADD(YEAR, -4, CURRENT_DATE())
-      AND transaction_date < DATEADD(YEAR, -1, CURRENT_DATE())
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'snowflake');
-        const filter = astToFilter(ast.where, 'snowflake');
-        const currentDate = new Date();
-        const dateMinus4Years = subYears(currentDate, 4);
-        const dateMinus1Year = subYears(currentDate, 1);
-        const formattedStartDate = format(dateMinus4Years, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus1Year, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (BigQuery) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 200 DAY)
-      AND transaction_date < DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'bigquery');
-        const filter = astToFilter(ast.where, 'bigquery');
-        const currentDate = new Date();
-        const dateMinus200Days = subDays(currentDate, 200);
-        const dateMinus90Days = subDays(currentDate, 90);
-        const formattedStartDate = format(dateMinus200Days, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus90Days, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-1) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= CURDATE() - INTERVAL 3 MONTH
-      AND transaction_date < CURDATE() - INTERVAL 1 MONTH
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const currentDate = new Date();
-        const dateMinus3Months = subMonths(currentDate, 3);
-        const dateMinus1Month = subMonths(currentDate, 1);
-        const formattedStartDate = format(dateMinus3Months, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus1Month, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-2) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_SUB(CURDATE(), INTERVAL 3 MONTH)
-      AND transaction_date < DATE_SUB(CURDATE(), INTERVAL 1 MONTH)
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const currentDate = new Date();
-        const dateMinus3Months = subMonths(currentDate, 3);
-        const dateMinus1Month = subMonths(currentDate, 1);
-        const formattedStartDate = format(dateMinus3Months, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus1Month, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (MySQL-3) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= DATE_SUB(NOW(), INTERVAL 3 MONTH)
-      AND transaction_date < DATE_SUB(NOW(), INTERVAL 1 MONTH)
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'mysql');
-        const filter = astToFilter(ast.where, 'mysql');
-        const currentDate = new Date();
-        const dateMinus3Months = subMonths(currentDate, 3);
-        const dateMinus1Month = subMonths(currentDate, 1);
-        const formattedStartDate = format(dateMinus3Months, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus1Month, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field (Postgres) - InThePrevious Custom', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= CURRENT_DATE - INTERVAL 3 month
-      AND transaction_date < CURRENT_DATE - INTERVAL 1 month
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const currentDate = new Date();
-        const dateMinus3Months = subMonths(currentDate, 3);
-        const dateMinus1Month = subMonths(currentDate, 1);
-        const formattedStartDate = format(dateMinus3Months, 'yyyy-MM-dd');
-        const formattedEndDate = format(dateMinus1Month, 'yyyy-MM-dd');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: {
-                startDate: formattedStartDate,
-                endDate: formattedEndDate,
-            },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Date (Date Comparison Operators)', () => {
-    it('should convert Filter to AST for date field - EqualTo', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.EqualTo,
-            value: '2023-10-21',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date = '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - NotEqualTo', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.NotEqualTo,
-            value: '2023-10-21',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date <> '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - LessThan', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.LessThan,
-            value: '2023-10-21',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date < '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - LessThanOrEqualTo', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.LessThanOrEqualTo,
-            value: '2023-10-21',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date <= '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - GreaterThan', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.GreaterThan,
-            value: '2023-10-21',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date > '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for date field - GreaterThanOrEqualTo', () => {
-        const filter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.GreaterThanOrEqualTo,
-            value: '2023-10-21',
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql, 'mysql').where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Date (Date Comparison Operators)', () => {
-    it('should convert AST to Filter for date field - EqualTo', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date = '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateCustomFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.Custom,
-            value: { startDate: '2023-10-21', endDate: '2023-10-21' },
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field - NotEqualTo', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date <> '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.NotEqualTo,
-            value: '2023-10-21',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field - LessThan', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date < '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.LessThan,
-            value: '2023-10-21',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field - LessThanOrEqualTo', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date <= '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.LessThanOrEqualTo,
-            value: '2023-10-21',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field - GreaterThan', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date > '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.GreaterThan,
-            value: '2023-10-21',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for date field - GreaterThanOrEqualTo', () => {
-        const sql = `
-      SELECT * FROM transactions
-      WHERE transaction_date >= '2023-10-21'
-    `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql, 'postgresql');
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'transaction_date',
-            name: FilterNames.DateComparisonFilter,
-            type: FieldTypes.Date,
-            operator: DateOperator.GreaterThanOrEqualTo,
-            value: '2023-10-21',
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});
-describe('Filter to AST - Bool', () => {
-    it('should convert Filter to AST for boolean field - IsTrue', () => {
-        const filter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.EqualTo,
-            value: true,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something = TRUE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for boolean field - IsFalse', () => {
-        const filter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.EqualTo,
-            value: false,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something = FALSE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for boolean field - IsNotTrue', () => {
-        const filter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.NotEqualTo,
-            value: true,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something <> TRUE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-    it('should convert Filter to AST for boolean field - IsNotFalse', () => {
-        const filter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.NotEqualTo,
-            value: false,
-        };
-        const ast = filterToAst(filter, 'mysql');
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something <> FALSE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const expectedAst = parseSelectSQL(sql).where;
-        expect(ast).toEqual(expectedAst);
-    });
-});
-describe('AST to Filter - Bool', () => {
-    it('should convert AST to Filter for boolean field - IsTrue', () => {
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something = TRUE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.EqualTo,
-            value: true,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for boolean field - IsFalse', () => {
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something = FALSE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.EqualTo,
-            value: false,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for boolean field - IsNotTrue', () => {
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something <> TRUE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.NotEqualTo,
-            value: true,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-    it('should convert AST to Filter for boolean field - IsNotFalse', () => {
-        const sql = `
-        SELECT * FROM transactions
-        WHERE is_something <> FALSE
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-        const ast = parseSelectSQL(sql);
-        const filter = astToFilter(ast.where, 'postgresql');
-        const expectedFilter = {
-            field: 'is_something',
-            name: FilterNames.BooleanFilter,
-            type: FieldTypes.Boolean,
-            operator: BoolOperator.NotEqualTo,
-            value: false,
-        };
-        expect(filter).toEqual(expectedFilter);
-    });
-});