@quillsql/react 2.13.35 → 2.13.37

package/dist/cjs/utils/astFilterProcessing.js

@@ -612,7 +612,8 @@ const queryPatterns = [
                     },
                     unit: function (astWhere) {
                         return (astWhere.right?.args?.value[0]?.column?.expr?.value?.toLowerCase() ??
-                            astWhere.right?.args?.value[0]?.column.toLowerCase() ??
+                            astWhere.right?.args?.value[0]?.column?.toLowerCase() ??
+                            astWhere.right?.args?.value[0]?.value?.toLowerCase() ??
                             null);
                     },
                     ast: {
@@ -724,7 +725,7 @@ const queryPatterns = [
                         if (unit === '') {
                             return stripTimeS(astWhere.left?.right?.right?.expr?.value
                                 ?.split(' ')[1]
-                                .toLowerCase());
+                                ?.toLowerCase());
                         }
                         else {
                             return unit;
@@ -3032,6 +3033,114 @@ const queryPatterns = [
                     },
                 },
             ],
+            mssql: [
+                {
+                    query: `
+            SELECT * FROM transactions
+            WHERE transaction_date >= DATEADD(DAY, -90, GETDATE())
+          `,
+                    value: function (astWhere) {
+                        return astWhere.right?.args?.value[1]?.value
+                            ? -astWhere.right?.args?.value[1]?.value
+                            : null;
+                    },
+                    unit: function (astWhere) {
+                        return (astWhere.right?.args?.value[0]?.column?.toLowerCase() ?? null);
+                    },
+                    ast: {
+                        with: null,
+                        type: 'select',
+                        options: null,
+                        distinct: null,
+                        columns: [
+                            {
+                                expr: {
+                                    type: 'column_ref',
+                                    table: null,
+                                    column: '*',
+                                },
+                                as: null,
+                            },
+                        ],
+                        into: {
+                            position: null,
+                        },
+                        from: [
+                            {
+                                db: null,
+                                table: 'transactions',
+                                as: null,
+                                table_hint: null,
+                                temporal_table: null,
+                                operator: null,
+                            },
+                        ],
+                        for: null,
+                        where: {
+                            type: 'binary_expr',
+                            operator: '>=',
+                            left: {
+                                type: 'column_ref',
+                                table: null,
+                                db: null,
+                                schema: null,
+                                column: 'transaction_date',
+                                collate: null,
+                            },
+                            right: {
+                                type: 'function',
+                                name: {
+                                    name: [
+                                        {
+                                            type: 'default',
+                                            value: 'DATEADD',
+                                        },
+                                    ],
+                                },
+                                args: {
+                                    type: 'expr_list',
+                                    value: [
+                                        {
+                                            type: 'column_ref',
+                                            table: null,
+                                            db: null,
+                                            schema: null,
+                                            column: 'DAY',
+                                            collate: null,
+                                        },
+                                        {
+                                            type: 'number',
+                                            value: -90,
+                                        },
+                                        {
+                                            type: 'function',
+                                            name: {
+                                                name: [
+                                                    {
+                                                        type: 'default',
+                                                        value: 'GETDATE',
+                                                    },
+                                                ],
+                                            },
+                                            args: {
+                                                type: 'expr_list',
+                                                value: [],
+                                            },
+                                            over: null,
+                                        },
+                                    ],
+                                },
+                                over: null,
+                            },
+                        },
+                        groupby: null,
+                        having: null,
+                        top: null,
+                        orderby: null,
+                        limit: null,
+                    },
+                },
+            ],
         },
     },
     {
@@ -5958,6 +6067,133 @@ const queryPatterns = [
                     },
                 },
             ],
+            mssql: [
+                {
+                    query: `
+            SELECT * FROM transactions
+            WHERE DATETRUNC(MONTH, transaction_date) = DATETRUNC(MONTH, GETDATE());
+          `,
+                    value: function () {
+                        return 0;
+                    },
+                    unit: function (astWhere) {
+                        return astWhere.left?.args?.value[0]?.column ?? null;
+                    },
+                    ast: {
+                        with: null,
+                        type: 'select',
+                        options: null,
+                        distinct: null,
+                        columns: [
+                            {
+                                expr: {
+                                    type: 'column_ref',
+                                    table: null,
+                                    column: '*',
+                                },
+                                as: null,
+                            },
+                        ],
+                        into: {
+                            position: null,
+                        },
+                        from: [
+                            {
+                                db: null,
+                                table: 'transactions',
+                                as: null,
+                                table_hint: null,
+                                temporal_table: null,
+                                operator: null,
+                            },
+                        ],
+                        for: null,
+                        where: {
+                            type: 'binary_expr',
+                            operator: '=',
+                            left: {
+                                type: 'function',
+                                name: {
+                                    name: [
+                                        {
+                                            type: 'default',
+                                            value: 'DATETRUNC',
+                                        },
+                                    ],
+                                },
+                                args: {
+                                    type: 'expr_list',
+                                    value: [
+                                        {
+                                            type: 'column_ref',
+                                            table: null,
+                                            db: null,
+                                            schema: null,
+                                            column: 'MONTH',
+                                            collate: null,
+                                        },
+                                        {
+                                            type: 'column_ref',
+                                            table: null,
+                                            db: null,
+                                            schema: null,
+                                            column: 'transaction_date',
+                                            collate: null,
+                                        },
+                                    ],
+                                },
+                                over: null,
+                            },
+                            right: {
+                                type: 'function',
+                                name: {
+                                    name: [
+                                        {
+                                            type: 'default',
+                                            value: 'DATETRUNC',
+                                        },
+                                    ],
+                                },
+                                args: {
+                                    type: 'expr_list',
+                                    value: [
+                                        {
+                                            type: 'column_ref',
+                                            table: null,
+                                            db: null,
+                                            schema: null,
+                                            column: 'MONTH',
+                                            collate: null,
+                                        },
+                                        {
+                                            type: 'function',
+                                            name: {
+                                                name: [
+                                                    {
+                                                        type: 'default',
+                                                        value: 'GETDATE',
+                                                    },
+                                                ],
+                                            },
+                                            args: {
+                                                type: 'expr_list',
+                                                value: [],
+                                            },
+                                            over: null,
+                                        },
+                                    ],
+                                },
+                                over: null,
+                            },
+                        },
+                        groupby: null,
+                        having: null,
+                        top: null,
+                        orderby: null,
+                        limit: null,
+                    },
+                },
+            ],
         },
     },
     {
@@ -7622,57 +7858,263 @@ const queryPatterns = [
                     },
                 },
             ],
-        },
-    },
-];
-/**
- * A function generator for functions that checks whether an ast pattern (testWhere) is
- * equivalent to a predetermined ast pattern (where)
- */
-function generateWhereChecker(astWhere) {
-    function generateCheckFunction(where) {
-        let resultString = `testWhere.type === '${where.type}'`;
-        function recurseNode(node, testWhereNode) {
-            switch (node.type) {
-                case 'binary_expr':
-                    resultString = resultString.concat(` && (!${testWhereNode}.operator || ${testWhereNode}.operator === '${node.operator}' || (['<=', '<'].includes(${testWhereNode}.operator) && ['<=', '<'].includes('${node.operator}')) || (['>=', '>'].includes(${testWhereNode}.operator) && ['>=', '>'].includes('${node.operator}')))`);
-                    resultString = resultString.concat(` && (!${testWhereNode}?.left?.type || ${testWhereNode}?.left?.type === '${node.left.type}' || (['column_ref', 'double_quote_string', 'single_quote_string'].includes(${testWhereNode}?.left?.type) && ['column_ref', 'double_quote_string', 'single_quote_string'].includes('${node.left.type}')))`);
-                    resultString = resultString.concat(` && (!${testWhereNode}?.right?.type || ${testWhereNode}?.right?.type === '${node.right.type}' || (['column_ref', 'double_quote_string', 'single_quote_string'].includes(${testWhereNode}?.right?.type) && ['column_ref', 'double_quote_string', 'single_quote_string'].includes('${node.right.type}')))`);
-                    if (node.operator === 'AND' &&
-                        node.left?.left?.type !== 'extract' &&
-                        !(node.left?.left?.type === 'function' &&
-                            ['hour', 'day', 'week', 'month', 'year'].includes(node.left?.left?.name?.name?.[0]?.value?.toLowerCase()))) {
-                        recurseNode(node.left, testWhereNode.concat(`?.left`));
-                    }
-                    recurseNode(node.right, testWhereNode.concat(`?.right`));
-                    break;
-                case 'function':
-                    if (node?.name && typeof node.name === 'string') {
-                        resultString = resultString.concat(` && (${testWhereNode}?.name?.toLowerCase() === '${node.name.toLowerCase()} ` +
-                            `|| (['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes(${testWhereNode}?.name)) ` +
-                            `&& ['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes('${node.name}')) ` +
-                            `|| (['year', 'month', 'quarter', 'day', 'week', 'hour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
-                            `&& ['year', 'month', 'quarter', 'day', 'week', 'hour'].includes('${node.name.toLowerCase()}')) ` +
-                            `|| (['toyear', 'tomonth', 'toquarter', 'tohour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
-                            `&& ['toyear', 'tomonth', 'toquarter', 'tohour'].includes('${node.name.toLowerCase()}')) ` +
-                            `|| (['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
-                            `&& ['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes('${node.name.toLowerCase()}'))` +
-                            `|| (['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
-                            `&& ['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes('${node.name.toLowerCase()}')) ` +
-                            `|| (['tointervalyear', 'tointervalmonth', 'tointervalday', 'tointervalquarter', 'tointervalweek', 'tointervalhour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
-                            `&& ['tointervalyear', 'tointervalmonth', 'tointervalday', 'tointervalquarter', 'tointervalweek', 'tointervalhour'].includes('${node.name.toLowerCase()}')))`);
-                    }
-                    else if (node?.name?.name?.length > 0) {
-                        resultString = resultString.concat(` && (${testWhereNode}?.name?.name[0]?.value === '${node.name.name[0].value}' ` +
-                            `|| (['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes(${testWhereNode}?.name?.name[0]?.value) ` +
-                            `&& ['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes('${node.name.name[0].value}')) ` +
-                            `|| (['year', 'month', 'quarter', 'day', 'week', 'hour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
-                            `&& ['year', 'month', 'quarter', 'day', 'week', 'hour'].includes('${node.name.name[0].value.toLowerCase()}'))` +
-                            `|| (['toyear', 'tomonth', 'toquarter', 'tohour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
-                            `&& ['toyear', 'tomonth', 'toquarter', 'tohour'].includes('${node.name.name[0].value.toLowerCase()}'))` +
-                            `|| (['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
-                            `&& ['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes('${node.name.name[0].value.toLowerCase()}'))` +
-                            `|| (['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
+            mssql: [
+                {
+                    query: `
+          SELECT * FROM transactions
+          WHERE transaction_date >= DATEADD(YEAR, -2, GETDATE()) 
+          AND transaction_date < DATEADD(YEAR, -1, GETDATE());
+        `,
+                    value: function (astWhere) {
+                        if (astWhere.right.operator === 'AND') {
+                            // Avoid AND chains
+                            return -1;
+                        }
+                        const operatorLeft = astWhere.left.operator;
+                        const operatorRight = astWhere.right.operator;
+                        const valueLeft = astWhere.left.right?.args?.value[1]?.value
+                            ? -astWhere.left.right?.args?.value[1]?.value
+                            : null;
+                        const valueRight = astWhere.right.right?.args?.value[1]?.value
+                            ? -astWhere.right.right?.args?.value[1]?.value
+                            : null;
+                        if (!valueLeft || !valueRight) {
+                            return null;
+                        }
+                        if (operatorLeft === '>=' &&
+                            operatorRight === '<' &&
+                            valueLeft == valueRight * 2) {
+                            return valueRight;
+                        }
+                        else if (operatorLeft === '<' &&
+                            operatorRight === '>=' &&
+                            valueLeft * 2 == valueRight) {
+                            return valueLeft;
+                        }
+                        else {
+                            const unitLeft = astWhere.left?.right?.args?.value[0]?.column?.toLowerCase() ??
+                                null;
+                            const unitRight = astWhere.right?.right?.args?.value[0]?.column?.toLowerCase() ??
+                                null;
+                            return parseStartEndDate(operatorLeft, operatorRight, valueLeft, valueRight, stripTimeS(unitLeft.toLowerCase()), stripTimeS(unitRight.toLowerCase()));
+                        }
+                    },
+                    unit: function (astWhere) {
+                        const unitLeft = astWhere.left?.right?.args?.value[0]?.column?.toLowerCase() ??
+                            null;
+                        const unitRight = astWhere.right?.right?.args?.value[0]?.column?.toLowerCase() ??
+                            null;
+                        return stripTimeS(unitLeft.toLowerCase()) ===
+                            stripTimeS(unitRight.toLowerCase())
+                            ? stripTimeS(unitLeft.toLowerCase())
+                            : null;
+                    },
+                    ast: {
+                        with: null,
+                        type: 'select',
+                        options: null,
+                        distinct: null,
+                        columns: [
+                            {
+                                expr: {
+                                    type: 'column_ref',
+                                    table: null,
+                                    column: '*',
+                                },
+                                as: null,
+                            },
+                        ],
+                        into: {
+                            position: null,
+                        },
+                        from: [
+                            {
+                                db: null,
+                                table: 'transactions',
+                                as: null,
+                                table_hint: null,
+                                temporal_table: null,
+                                operator: null,
+                            },
+                        ],
+                        for: null,
+                        where: {
+                            type: 'binary_expr',
+                            operator: 'AND',
+                            left: {
+                                type: 'binary_expr',
+                                operator: '>=',
+                                left: {
+                                    type: 'column_ref',
+                                    table: null,
+                                    db: null,
+                                    schema: null,
+                                    column: 'transaction_date',
+                                    collate: null,
+                                },
+                                right: {
+                                    type: 'function',
+                                    name: {
+                                        name: [
+                                            {
+                                                type: 'default',
+                                                value: 'DATEADD',
+                                            },
+                                        ],
+                                    },
+                                    args: {
+                                        type: 'expr_list',
+                                        value: [
+                                            {
+                                                type: 'column_ref',
+                                                table: null,
+                                                db: null,
+                                                schema: null,
+                                                column: 'YEAR',
+                                                collate: null,
+                                            },
+                                            {
+                                                type: 'number',
+                                                value: -2,
+                                            },
+                                            {
+                                                type: 'function',
+                                                name: {
+                                                    name: [
+                                                        {
+                                                            type: 'default',
+                                                            value: 'GETDATE',
+                                                        },
+                                                    ],
+                                                },
+                                                args: {
+                                                    type: 'expr_list',
+                                                    value: [],
+                                                },
+                                                over: null,
+                                            },
+                                        ],
+                                    },
+                                    over: null,
+                                },
+                            },
+                            right: {
+                                type: 'binary_expr',
+                                operator: '<',
+                                left: {
+                                    type: 'column_ref',
+                                    table: null,
+                                    db: null,
+                                    schema: null,
+                                    column: 'transaction_date',
+                                    collate: null,
+                                },
+                                right: {
+                                    type: 'function',
+                                    name: {
+                                        name: [
+                                            {
+                                                type: 'default',
+                                                value: 'DATEADD',
+                                            },
+                                        ],
+                                    },
+                                    args: {
+                                        type: 'expr_list',
+                                        value: [
+                                            {
+                                                type: 'column_ref',
+                                                table: null,
+                                                db: null,
+                                                schema: null,
+                                                column: 'YEAR',
+                                                collate: null,
+                                            },
+                                            {
+                                                type: 'number',
+                                                value: -1,
+                                            },
+                                            {
+                                                type: 'function',
+                                                name: {
+                                                    name: [
+                                                        {
+                                                            type: 'default',
+                                                            value: 'GETDATE',
+                                                        },
+                                                    ],
+                                                },
+                                                args: {
+                                                    type: 'expr_list',
+                                                    value: [],
+                                                },
+                                                over: null,
+                                            },
+                                        ],
+                                    },
+                                    over: null,
+                                },
+                            },
+                        },
+                        groupby: null,
+                        having: null,
+                        top: null,
+                        orderby: null,
+                        limit: null,
+                    },
+                },
+            ],
+        },
+    },
+];
+/**
+ * A function generator for functions that checks whether an ast pattern (testWhere) is
+ * equivalent to a predetermined ast pattern (where)
+ */
+function generateWhereChecker(astWhere) {
+    function generateCheckFunction(where) {
+        let resultString = `testWhere.type === '${where.type}'`;
+        function recurseNode(node, testWhereNode) {
+            switch (node.type) {
+                case 'binary_expr':
+                    resultString = resultString.concat(` && (!${testWhereNode}.operator || ${testWhereNode}.operator === '${node.operator}' || (['<=', '<'].includes(${testWhereNode}.operator) && ['<=', '<'].includes('${node.operator}')) || (['>=', '>'].includes(${testWhereNode}.operator) && ['>=', '>'].includes('${node.operator}')))`);
+                    resultString = resultString.concat(` && (!${testWhereNode}?.left?.type || ${testWhereNode}?.left?.type === '${node.left.type}' || (['column_ref', 'double_quote_string', 'single_quote_string'].includes(${testWhereNode}?.left?.type) && ['column_ref', 'double_quote_string', 'single_quote_string'].includes('${node.left.type}')))`);
+                    resultString = resultString.concat(` && (!${testWhereNode}?.right?.type || ${testWhereNode}?.right?.type === '${node.right.type}' || (['column_ref', 'double_quote_string', 'single_quote_string'].includes(${testWhereNode}?.right?.type) && ['column_ref', 'double_quote_string', 'single_quote_string'].includes('${node.right.type}')))`);
+                    if (node.operator === 'AND' &&
+                        node.left?.left?.type !== 'extract' &&
+                        !(node.left?.left?.type === 'function' &&
+                            ['hour', 'day', 'week', 'month', 'year'].includes(node.left?.left?.name?.name?.[0]?.value?.toLowerCase()))) {
+                        recurseNode(node.left, testWhereNode.concat(`?.left`));
+                    }
+                    recurseNode(node.right, testWhereNode.concat(`?.right`));
+                    break;
+                case 'function':
+                    if (node?.name && typeof node.name === 'string') {
+                        resultString = resultString.concat(` && (${testWhereNode}?.name?.toLowerCase() === '${node.name.toLowerCase()} ` +
+                            `|| (['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes(${testWhereNode}?.name)) ` +
+                            `&& ['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes('${node.name}')) ` +
+                            `|| (['year', 'month', 'quarter', 'day', 'week', 'hour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
+                            `&& ['year', 'month', 'quarter', 'day', 'week', 'hour'].includes('${node.name.toLowerCase()}')) ` +
+                            `|| (['toyear', 'tomonth', 'toquarter', 'tohour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
+                            `&& ['toyear', 'tomonth', 'toquarter', 'tohour'].includes('${node.name.toLowerCase()}')) ` +
+                            `|| (['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
+                            `&& ['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes('${node.name.toLowerCase()}'))` +
+                            `|| (['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
+                            `&& ['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes('${node.name.toLowerCase()}')) ` +
+                            `|| (['tointervalyear', 'tointervalmonth', 'tointervalday', 'tointervalquarter', 'tointervalweek', 'tointervalhour'].includes(${testWhereNode}?.name?.toLowerCase()) ` +
+                            `&& ['tointervalyear', 'tointervalmonth', 'tointervalday', 'tointervalquarter', 'tointervalweek', 'tointervalhour'].includes('${node.name.toLowerCase()}')))`);
+                    }
+                    else if (node?.name?.name?.length > 0) {
+                        resultString = resultString.concat(` && (${testWhereNode}?.name?.name[0]?.value === '${node.name.name[0].value}' ` +
+                            `|| (['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes(${testWhereNode}?.name?.name[0]?.value) ` +
+                            `&& ['CURRENT_DATE', 'CURRENT_TIMESTAMP', 'now', 'today'].includes('${node.name.name[0].value}')) ` +
+                            `|| (['year', 'month', 'quarter', 'day', 'week', 'hour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
+                            `&& ['year', 'month', 'quarter', 'day', 'week', 'hour'].includes('${node.name.name[0].value.toLowerCase()}'))` +
+                            `|| (['toyear', 'tomonth', 'toquarter', 'tohour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
+                            `&& ['toyear', 'tomonth', 'toquarter', 'tohour'].includes('${node.name.name[0].value.toLowerCase()}'))` +
+                            `|| (['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
+                            `&& ['tostartofyear', 'tostartofmonth', 'tostartofquarter', 'tostartofday', 'tostartofweek', 'tostartofhour'].includes('${node.name.name[0].value.toLowerCase()}'))` +
+                            `|| (['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
                             `&& ['truncyear', 'truncquarter', 'truncmonth', 'truncweek', 'truncday', 'trunchour'].includes('${node.name.name[0].value.toLowerCase()}')) ` +
                             `|| (['tointervalyear', 'tointervalmonth', 'tointervalday', 'tointervalquarter', 'tointervalweek', 'tointervalhour'].includes(${testWhereNode}?.name?.name[0]?.value?.toLowerCase()) ` +
                             `&& ['tointervalyear', 'tointervalmonth', 'tointervalday', 'tointervalquarter', 'tointervalweek', 'tointervalhour'].includes('${node.name.name[0].value.toLowerCase()}')))`);
@@ -7825,6 +8267,37 @@ function fieldColumnToLowerCaseAst(field, db, isColumnRef) {
                 },
                 over: null,
             };
+        case 'mssql':
+            return {
+                type: 'function',
+                name: {
+                    name: [
+                        {
+                            type: 'default',
+                            value: 'LOWER',
+                        },
+                    ],
+                },
+                args: {
+                    type: 'expr_list',
+                    value: [
+                        isColumnRef
+                            ? {
+                                type: 'column_ref',
+                                table: null,
+                                db: null,
+                                schema: null,
+                                column: field,
+                                collate: null,
+                            }
+                            : {
+                                type: 'single_quote_string',
+                                value: field,
+                            },
+                    ],
+                },
+                over: null,
+            };
         case 'postgresql':
         case 'clickhouse':
         default:
@@ -7876,7 +8349,7 @@ function lowerFunctionToField(lower, db) {
             lower.name.toLowerCase() === 'lower') ||
             lower.name?.name[0]?.value?.toLowerCase() === 'lower' ||
             lower.name?.schema?.value?.toLowerCase() === 'lower'))) {
-        return '';
+        return null;
     }
     switch (db) {
         case 'redshift':
@@ -7885,18 +8358,22 @@ function lowerFunctionToField(lower, db) {
         case 'mysql':
         case 'postgresql':
         case 'clickhouse':
-            return getFieldFromExpression(lower) ?? '';
+        case 'mssql':
+            return getFieldFromExpression(lower, db) ?? '';
         default:
-            return '';
+            return null;
     }
 }
 /**
  * Function that extracts a field value
  */
-function getFieldFromExpression(expr) {
+function getFieldFromExpression(expr, databaseType) {
     return (expr.column?.expr?.value ||
         expr.column ||
         expr.args?.value?.[1]?.expr?.column ||
+        (databaseType === 'mssql'
+            ? (expr.args?.value?.[1]?.column ?? expr.args.value?.[0]?.column)
+            : null) ||
         expr.args?.value?.[1]?.args?.value?.[0]?.column?.expr?.value ||
         expr.args?.value?.[0]?.value?.expr?.value ||
         expr.args?.value?.[1]?.column?.expr?.value ||
@@ -8034,6 +8511,7 @@ const astToFilter = (ast, db, columns) => {
         case 'redshift':
         case 'postgresql':
         case 'clickhouse':
+        case 'mssql':
             leftExpr = left;
             while (leftExpr.type === 'binary_expr') {
                 leftExpr = leftExpr.left;
@@ -8044,10 +8522,10 @@ const astToFilter = (ast, db, columns) => {
                         leftExpr.args?.value[1]?.column?.expr?.value ??
                             leftExpr.args?.value[0]?.column?.expr?.value ??
                             lowerFunctionToField(leftExpr, db) ??
-                            getFieldFromExpression(leftExpr);
+                            getFieldFromExpression(leftExpr, db);
                     break;
                 default:
-                    field = getFieldFromExpression(leftExpr);
+                    field = getFieldFromExpression(leftExpr, db);
                     if (!field) {
                         console.error('Could not determine field: ', leftExpr);
                         return null;
@@ -8061,7 +8539,7 @@ const astToFilter = (ast, db, columns) => {
             while (leftExpr.type === 'binary_expr') {
                 leftExpr = leftExpr.left;
             }
-            field = getFieldFromExpression(leftExpr);
+            field = getFieldFromExpression(leftExpr, db);
             if (!field) {
                 console.error('Could not determine field: ', leftExpr);
                 return null;
@@ -8229,19 +8707,19 @@ const astToFilter = (ast, db, columns) => {
     switch (filterName) {
         case Filter_1.FilterType.StringFilter:
             return {
-                field: lowerFunctionToField(field, db).replaceAll('%', ''),
+                field: (lowerFunctionToField(field, db) ?? '').replaceAll('%', ''),
                 filterType: filterName,
                 fieldType: Filter_1.FieldType.String,
                 operator: mappedOperator,
-                value: lowerFunctionToField(right, db).replaceAll('%', ''),
+                value: (lowerFunctionToField(right, db) ?? '').replaceAll('%', ''),
             };
         case Filter_1.FilterType.StringInFilter:
             return {
-                field: lowerFunctionToField(field, db).replaceAll('%', ''),
+                field: (lowerFunctionToField(field, db) ?? '').replaceAll('%', ''),
                 filterType: filterName,
                 fieldType: Filter_1.FieldType.String,
                 operator: mappedOperator,
-                value: right.value.map((v) => lowerFunctionToField(v, db).replaceAll('%', '')),
+                value: right.value.map((v) => (lowerFunctionToField(v, db) ?? '').replaceAll('%', '')),
             };
         case Filter_1.FilterType.NumericFilter:
             return {
@@ -8764,6 +9242,64 @@ const filterToAst = (filter, db) => {
                                             },
                                         },
                                     };
+                                case 'mssql':
+                                    return {
+                                        type: 'binary_expr',
+                                        operator: '>=',
+                                        left: {
+                                            type: 'column_ref',
+                                            table: null,
+                                            db: null,
+                                            schema: null,
+                                            column: field,
+                                            collate: null,
+                                        },
+                                        right: {
+                                            type: 'function',
+                                            name: {
+                                                name: [
+                                                    {
+                                                        type: 'default',
+                                                        value: 'DATEADD',
+                                                    },
+                                                ],
+                                            },
+                                            args: {
+                                                type: 'expr_list',
+                                                value: [
+                                                    {
+                                                        type: 'column_ref',
+                                                        table: null,
+                                                        db: null,
+                                                        schema: null,
+                                                        column: filter.value.unit,
+                                                        collate: null,
+                                                    },
+                                                    {
+                                                        type: 'number',
+                                                        value: -filter.value.value,
+                                                    },
+                                                    {
+                                                        type: 'function',
+                                                        name: {
+                                                            name: [
+                                                                {
+                                                                    type: 'default',
+                                                                    value: 'GETDATE',
+                                                                },
+                                                            ],
+                                                        },
+                                                        args: {
+                                                            type: 'expr_list',
+                                                            value: [],
+                                                        },
+                                                        over: null,
+                                                    },
+                                                ],
+                                            },
+                                            over: null,
+                                        },
+                                    };
                                 default:
                                     console.error('Unknown database source: ', db);
                                     return null;
@@ -9451,6 +9987,85 @@ const filterToAst = (filter, db) => {
                                             },
                                         },
                                     };
+                                case 'mssql':
+                                    return {
+                                        type: 'binary_expr',
+                                        operator: '=',
+                                        left: {
+                                            type: 'function',
+                                            name: {
+                                                name: [
+                                                    {
+                                                        type: 'default',
+                                                        value: 'DATETRUNC',
+                                                    },
+                                                ],
+                                            },
+                                            args: {
+                                                type: 'expr_list',
+                                                value: [
+                                                    {
+                                                        type: 'column_ref',
+                                                        table: null,
+                                                        db: null,
+                                                        schema: null,
+                                                        column: filter.value.unit,
+                                                        collate: null,
+                                                    },
+                                                    {
+                                                        type: 'column_ref',
+                                                        table: null,
+                                                        db: null,
+                                                        schema: null,
+                                                        column: field,
+                                                        collate: null,
+                                                    },
+                                                ],
+                                            },
+                                            over: null,
+                                        },
+                                        right: {
+                                            type: 'function',
+                                            name: {
+                                                name: [
+                                                    {
+                                                        type: 'default',
+                                                        value: 'DATETRUNC',
+                                                    },
+                                                ],
+                                            },
+                                            args: {
+                                                type: 'expr_list',
+                                                value: [
+                                                    {
+                                                        type: 'column_ref',
+                                                        table: null,
+                                                        db: null,
+                                                        schema: null,
+                                                        column: filter.value.unit,
+                                                        collate: null,
+                                                    },
+                                                    {
+                                                        type: 'function',
+                                                        name: {
+                                                            name: [
+                                                                {
+                                                                    type: 'default',
+                                                                    value: 'GETDATE',
+                                                                },
+                                                            ],
+                                                        },
+                                                        args: {
+                                                            type: 'expr_list',
+                                                            value: [],
+                                                        },
+                                                        over: null,
+                                                    },
+                                                ],
+                                            },
+                                            over: null,
+                                        },
+                                    };
                                 default:
                                     console.error('Unknown database source: ', db);
                                     return null;
@@ -10061,6 +10676,126 @@ const filterToAst = (filter, db) => {
                                         },
                                         parentheses: true,
                                     };
+                                case 'mssql':
+                                    return {
+                                        type: 'binary_expr',
+                                        operator: 'AND',
+                                        left: {
+                                            type: 'binary_expr',
+                                            operator: '>=',
+                                            left: {
+                                                type: 'column_ref',
+                                                table: null,
+                                                db: null,
+                                                schema: null,
+                                                column: field,
+                                                collate: null,
+                                            },
+                                            right: {
+                                                type: 'function',
+                                                name: {
+                                                    name: [
+                                                        {
+                                                            type: 'default',
+                                                            value: 'DATEADD',
+                                                        },
+                                                    ],
+                                                },
+                                                args: {
+                                                    type: 'expr_list',
+                                                    value: [
+                                                        {
+                                                            type: 'column_ref',
+                                                            table: null,
+                                                            db: null,
+                                                            schema: null,
+                                                            column: filter.value.unit,
+                                                            collate: null,
+                                                        },
+                                                        {
+                                                            type: 'number',
+                                                            value: -filter.value.value * 2,
+                                                        },
+                                                        {
+                                                            type: 'function',
+                                                            name: {
+                                                                name: [
+                                                                    {
+                                                                        type: 'default',
+                                                                        value: 'GETDATE',
+                                                                    },
+                                                                ],
+                                                            },
+                                                            args: {
+                                                                type: 'expr_list',
+                                                                value: [],
+                                                            },
+                                                            over: null,
+                                                        },
+                                                    ],
+                                                },
+                                                over: null,
+                                            },
+                                        },
+                                        right: {
+                                            type: 'binary_expr',
+                                            operator: '<',
+                                            left: {
+                                                type: 'column_ref',
+                                                table: null,
+                                                db: null,
+                                                schema: null,
+                                                column: field,
+                                                collate: null,
+                                            },
+                                            right: {
+                                                type: 'function',
+                                                name: {
+                                                    name: [
+                                                        {
+                                                            type: 'default',
+                                                            value: 'DATEADD',
+                                                        },
+                                                    ],
+                                                },
+                                                args: {
+                                                    type: 'expr_list',
+                                                    value: [
+                                                        {
+                                                            type: 'column_ref',
+                                                            table: null,
+                                                            db: null,
+                                                            schema: null,
+                                                            column: filter.value.unit,
+                                                            collate: null,
+                                                        },
+                                                        {
+                                                            type: 'number',
+                                                            value: -filter.value.value,
+                                                        },
+                                                        {
+                                                            type: 'function',
+                                                            name: {
+                                                                name: [
+                                                                    {
+                                                                        type: 'default',
+                                                                        value: 'GETDATE',
+                                                                    },
+                                                                ],
+                                                            },
+                                                            args: {
+                                                                type: 'expr_list',
+                                                                value: [],
+                                                            },
+                                                            over: null,
+                                                        },
+                                                    ],
+                                                },
+                                                over: null,
+                                            },
+                                        },
+                                        parentheses: true,
+                                    };
                                 default:
                                     console.error('Unknown database source: ', db);
                                     return null;