@quillsql/react 2.12.29 → 2.12.30

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

@@ -0,0 +1,2729 @@
+/* eslint-disable no-undef */
+import { 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 field IN ('value 1', '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 field NOT IN ('value 1', '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 field IN ('value 1', '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 field NOT IN ('value 1', '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);
+    });
+});