@quillsql/react 2.10.39 → 2.11.1

package/dist/cjs/components/ReportBuilder/convert.js

@@ -0,0 +1,730 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRemoveSimpleParentheses = exports.convertStringComparison = exports.applyPivot = exports.convertGroupBy = exports.convertWildcardColumns = exports.convertBigQuery = exports.recursiveSearchAndReplace = exports.convertDateComparison = void 0;
+const ast_1 = require("./ast");
+const util_1 = require("./util");
+// Helper functions that preprocess the AST.
+// Find and replace certain pre-set date comparison queries with their
+// more stable counterparts.
+// TODO: implement me
+// eslint-disable-next-line no-unused-vars
+function convertDateComparison(node) {
+    function searchAndReplace(obj) {
+        if (Array.isArray(obj)) {
+            // If the current node is an array, process each element of the array
+            obj.forEach((element) => {
+                searchAndReplace(element);
+            });
+        }
+        else if (typeof obj === 'object' && obj !== null) {
+            // "Created in the past 90 days" should be written in SQL as:
+            // "created_at" >= date_trunc('day', CURRENT_DATE) - INTERVAL '90 days';
+            // "created_at" >= date_trunc('month', CURRENT_DATE) - INTERVAL '6 months';
+            // TODO: add more matchers here
+        }
+        else {
+            // If the current object does not match the pattern, continue searching its properties
+            Object.values(obj).forEach((value) => {
+                searchAndReplace(value);
+            });
+        }
+    }
+    // Start the recursive search and replace from the root node
+    searchAndReplace(node);
+    return node;
+}
+exports.convertDateComparison = convertDateComparison;
+// THIS IS ONLY USEFUL TO CONVERT FUNCTIONS INTO OTHER FUNCTIONS FOR BIGQUERY FOR FILTERS
+function recursiveSearchAndReplace(node, search, replace) {
+    if (typeof node !== 'object') {
+        return;
+    }
+    if (node) {
+        Object.keys(node).forEach((key) => {
+            recursiveSearchAndReplace(node[key], search, replace);
+            if (node[key] === search) {
+                node[key] = replace;
+            }
+        });
+    }
+}
+exports.recursiveSearchAndReplace = recursiveSearchAndReplace;
+/**
+ * Takes a bigquery AST as input, cleans it, and returns a Select AST.
+ */
+function convertBigQuery(ast) {
+    // For BigQuery, the info we want is nested inside the 'select' key
+    if ((0, ast_1.isBigQuery)(ast)) {
+        let newAst = ast.select;
+        newAst.from?.forEach((tbl) => {
+            tbl.table = tbl.table.replaceAll('`', '');
+        });
+        if (newAst.columns && Array.isArray(newAst.columns)) {
+            newAst.columns.forEach((col) => {
+                if (col.expr && !col.type) {
+                    col.type = 'expr';
+                }
+            });
+        }
+        // Look through every node in the AST convert every instance of DATE_SUB to TIMESTAMP_SUB
+        recursiveSearchAndReplace(newAst.where, 'DATE_SUB', 'TIMESTAMP_SUB');
+        recursiveSearchAndReplace(newAst.where, 'CURRENT_DATE', 'CURRENT_TIMESTAMP');
+        recursiveSearchAndReplace(newAst.where, 'DATE_TRUNC', 'TIMESTAMP_TRUNC');
+        recursiveSearchAndReplace(newAst.where, 'DATE', 'TIMESTAMP');
+        // TODO: handle joins nicely
+        if (newAst.from?.length > 1) {
+            newAst.from = [newAst.from[0]];
+        }
+        // TODO: handle UNION ALL joins
+        if (newAst._next) {
+            delete newAst._next;
+        }
+        return newAst;
+    }
+    else {
+        return ast;
+    }
+}
+exports.convertBigQuery = convertBigQuery;
+/**
+ * Replaces the wildcard column selector with their literal column names.
+ */
+function convertWildcardColumns(ast, schemaTables) {
+    if (ast.columns !== '*' && ast.columns.length !== 0)
+        return ast;
+    if (!ast.from)
+        return ast;
+    // Map SELECT(*) to their actual columns
+    const tableNamesInQuery = ast.from.map((tbl) => tbl.table);
+    const allColumns = schemaTables
+        .filter((t) => tableNamesInQuery.includes(t.displayName))
+        .flatMap((table) => table.columns);
+    return {
+        ...ast,
+        columns: allColumns.map((column) => ({
+            type: 'expr',
+            expr: {
+                type: 'column_ref',
+                table: null,
+                column: column.name,
+            },
+            as: null,
+        })),
+    };
+}
+exports.convertWildcardColumns = convertWildcardColumns;
+/**
+ * Processes the AST and builds up a new pivot, given the old AST, the old pivot
+ * and a list of tables in the schema.
+ */
+function convertGroupBy(ast, prevPivot = null, schemaTables) {
+    if (!(0, ast_1.isSelect)(ast))
+        return { ast, pivot: prevPivot };
+    let newAst = {};
+    let pivot = {};
+    let newColumns = [];
+    let aliasMap = {};
+    const tableNamesInQuery = (ast.from ?? []).map((tbl) => {
+        // This assumes that all the entries in the from clause are BaseFrom.
+        // TODO: Handle Join, TableExpr, and Dual (maybe not the last one).
+        return tbl.table;
+    });
+    const columns = schemaTables
+        .filter((t) => tableNamesInQuery.includes(t.displayName))
+        .flatMap((table) => table.columns)
+        .map((column) => ({
+        field: column.displayName,
+        fieldType: column.fieldType,
+    }));
+    // If there is not GROUP BY clause in the AST, we still need to process the
+    // AST but it should pass-through in nature.
+    if (!ast.groupby) {
+        // If there was a pivot before, evaluate the pivot.
+        if (prevPivot) {
+            // Make sure that the AST includes all the columns on the prevPivot
+            const columnAlreadyExists = (col) => ast.columns.find((c) => [c.expr?.value, c.expr?.column, c.as].includes(col));
+            if (prevPivot.valueField) {
+                const existingCol = columnAlreadyExists(prevPivot.valueField);
+                newColumns.push(existingCol ?? (0, util_1.generateColumnExpr)(prevPivot.valueField));
+            }
+            if (prevPivot.rowField) {
+                const existingCol = columnAlreadyExists(prevPivot.rowField);
+                newColumns.push(existingCol ?? (0, util_1.generateColumnExpr)(prevPivot.rowField));
+            }
+            if (prevPivot.columnField) {
+                const existingCol = columnAlreadyExists(prevPivot.columnField);
+                newColumns.push(existingCol ?? (0, util_1.generateColumnExpr)(prevPivot.columnField));
+            }
+            ast.columns = newColumns;
+            return { pivot: prevPivot, ast };
+        }
+        for (let i = 0; i < ast.columns.length; i++) {
+            const column = ast.columns[i];
+            // Extract out the column name, note that there are several ways
+            // that a column node could be structured so we need to check.
+            let columnName;
+            let columnAs = null;
+            let columnTable = null;
+            if (column.type === 'expr') {
+                columnAs = column.as;
+                columnTable = column.expr.table;
+                if (column.expr.type === 'column_ref') {
+                    columnName = column.expr.column;
+                }
+                else if (column.expr.type === 'string') {
+                    columnName = column.expr.value;
+                }
+                else if (column.expr.type === 'double_quote_string') {
+                    columnName = column.expr?.value;
+                }
+                else if (column.expr?.args?.expr) {
+                    columnName = column.expr?.args?.expr?.value;
+                }
+                if (column.expr.type === 'aggr_func') {
+                    pivot.aggregationType = column.expr.name.toLowerCase();
+                    pivot.valueField = column.expr.args?.expr?.value;
+                    if (column.expr.args.expr.type === 'column_ref') {
+                        columnTable = column.expr.args.expr.table;
+                        columnName = column.expr.args.expr.column;
+                    }
+                    else if (column.expr.args.expr.type === 'double_quote_string') {
+                        columnName = column.expr.args.expr?.value;
+                    }
+                    else if (column.expr?.args?.expr) {
+                        columnName = column.expr?.args?.expr?.value;
+                    }
+                }
+            }
+            if (columnName === '*') {
+                // TODO: make valueField be a number
+                pivot.valueField = columns[0].field;
+                columnName = columns[0].field;
+            }
+            newColumns.push({
+                type: 'expr',
+                expr: {
+                    type: 'column_ref',
+                    table: columnTable,
+                    column: columnName,
+                },
+                as: columnAs,
+            });
+        }
+        newAst = { ...ast };
+        newAst.columns = newColumns;
+        const newPivot = Object.keys(pivot).length === 0 ? null : pivot;
+        return { pivot: newPivot, ast: newAst };
+    }
+    // Iterate over columns to find aggr_func -> set pivot.aggregationType and pivot.valueField
+    for (let i = 0; i < ast.columns.length; i++) {
+        const column = ast.columns[i];
+        const field = columns.find((c) => c.field === column.expr?.args?.expr?.column);
+        if (column?.expr?.type === 'aggr_func') {
+            // CASE WHEN
+            if (column.expr?.args?.expr?.type.toLowerCase() === 'case' &&
+                ['double_quote_string', 'column_ref'].includes(column.expr?.args?.expr?.args[0]?.result?.type)) {
+                // The result of the CASE is the column to use
+                const columnNode = column.expr?.args?.expr?.args[0]?.result;
+                const columnName = columnNode?.value ?? columnNode?.column;
+                pivot.valueField = columnName;
+                pivot.aggregationType = column?.expr?.name?.toLowerCase();
+                const findByName = (x) => [x.expr?.value, x.expr?.column].includes(columnName);
+                if (!newColumns.find(findByName)) {
+                    newColumns.push({
+                        type: 'expr',
+                        expr: {
+                            type: 'column_ref',
+                            table: null,
+                            column: columnName,
+                        },
+                        as: null,
+                    });
+                }
+                // We need to extract a column name from the condition expression of
+                // the CASE and we'll use that as the columnField in our pivot.
+                const condNode = column.expr?.args?.expr?.args[0]?.cond;
+                const condColumnName = condNode.left?.column ?? condNode.left?.value;
+                pivot.columnField = condColumnName;
+                const findByColName = (x) => [x.expr?.value, x.expr?.column].includes(condColumnName);
+                if (!newColumns.find(findByColName)) {
+                    // Make sure the column we extracted is in our column list.
+                    newColumns.push({
+                        type: 'expr',
+                        expr: {
+                            type: 'column_ref',
+                            table: null,
+                            column: condColumnName,
+                        },
+                        as: null,
+                    });
+                }
+                // REGULAR
+            }
+            else if (
+            // sum("amount")
+            column.expr?.args?.expr?.type === 'double_quote_string' ||
+                // sum(amount)
+                column.expr?.args?.expr?.type === 'column_ref' ||
+                // count(*)
+                column.expr?.args?.expr?.type === 'star') {
+                console.log(column);
+                const columnNode = column.expr?.args?.expr;
+                const columnName = columnNode?.value || columnNode?.column;
+                // if count(*), make the value field an actual column
+                if (columnName === '*') {
+                    // TODO: make valueField be a number
+                    pivot.valueField = columns[0].field;
+                    pivot.aggregationType = column?.expr?.name.toLowerCase();
+                    const findByName = (x) => [x.expr?.value, x.expr?.column].includes(columns[0].field);
+                    if (!newColumns.find(findByName)) {
+                        newColumns.push({
+                            type: 'expr',
+                            expr: {
+                                type: 'column_ref',
+                                table: null,
+                                column: columns[0].field,
+                            },
+                            as: null,
+                        });
+                    }
+                }
+                else {
+                    // ONLY SET VALUE FIELD IF THE FIELD TYPE IS A NUMBER
+                    if ((0, ast_1.isNumericColumnType)(field?.fieldType)) {
+                        pivot.valueField = columnName;
+                        pivot.aggregationType = column?.expr?.name.toLowerCase();
+                    }
+                    const findByName = (x) => [x.expr?.value, x.expr?.column].includes(columnName);
+                    if (!newColumns.find(findByName)) {
+                        newColumns.push({
+                            type: 'expr',
+                            expr: {
+                                type: 'column_ref',
+                                table: null,
+                                column: columnName,
+                            },
+                            as: null,
+                        });
+                    }
+                }
+            }
+            else {
+                // normal column?
+                const columnName = column.expr?.column || column.expr?.value;
+                const findByName = (x) => [x.expr?.value, x.expr?.column].includes(columnName);
+                if (!newColumns.find(findByName)) {
+                    newColumns.push(column);
+                }
+            }
+        }
+        else if (column.expr?.type === 'function') {
+            // date_trunc("month", "created_at") as month
+            if (column.type === 'expr' &&
+                column.expr?.type.toLowerCase() === 'function' &&
+                column.expr?.name.toLowerCase() === 'date_trunc' &&
+                column.expr?.args?.type === 'expr_list' &&
+                column.as) {
+                const columnObj = column.expr?.args?.value[1];
+                const periodObj = column.expr?.args?.value[0];
+                aliasMap[column.as] = columnObj?.value ?? columnObj.column;
+                newColumns.push({
+                    type: 'expr',
+                    expr: {
+                        type: 'function',
+                        name: 'DATE_TRUNC',
+                        args: {
+                            type: 'expr_list',
+                            value: [
+                                { type: 'single_quote_string', value: periodObj?.value },
+                                {
+                                    type: 'column_ref',
+                                    table: null,
+                                    column: columnObj?.value ?? columnObj.column,
+                                },
+                            ],
+                        },
+                    },
+                    as: columnObj?.value ?? columnObj.column,
+                });
+            }
+            else if (column.type === 'expr' &&
+                column.expr?.type.toLowerCase() === 'function' &&
+                column.expr?.name.toLowerCase() === 'date' &&
+                column.expr?.args?.type === 'expr_list' &&
+                column.as) {
+                const columnObj = column.expr?.args?.value[0];
+                aliasMap[column.as] = columnObj?.value ?? columnObj.column;
+                newColumns.push({
+                    type: 'expr',
+                    expr: {
+                        type: 'function',
+                        name: 'DATE_TRUNC',
+                        args: {
+                            type: 'expr_list',
+                            value: [
+                                { type: 'single_quote_string', value: 'day' },
+                                {
+                                    type: 'column_ref',
+                                    table: null,
+                                    column: columnObj?.value ?? columnObj.column,
+                                },
+                            ],
+                        },
+                    },
+                    as: columnObj?.value ?? columnObj.column,
+                });
+            }
+            else {
+                newColumns.push(column);
+            }
+        }
+        else if (column.type === 'expr' &&
+            column.expr?.type.toLowerCase() === 'extract' &&
+            column.as) {
+            const cast_type = column.expr?.args.cast_type;
+            const source = column.expr?.args.source;
+            const field = column.expr?.args.field;
+            aliasMap[column.as] = source?.value ?? source.column;
+            newColumns.push({
+                type: 'expr',
+                expr: {
+                    type: 'extract',
+                    args: { field, cast_type, source },
+                },
+                as: source?.value ?? source.column,
+            });
+        }
+        else {
+            const columnNode = column.expr;
+            newColumns.push({
+                type: 'expr',
+                expr: {
+                    type: 'column_ref',
+                    table: columnNode.table,
+                    column: columnNode.args?.length
+                        ? columnNode.args?.value.find((elem) => ['double_quote_string', 'column_ref'].includes(elem.type))?.value
+                        : columnNode.column ?? columnNode?.value,
+                },
+                as: null,
+            });
+        }
+    }
+    // Look for a date_trunc in the GROUP BY and set it to the rowField.
+    // If there are no date_trunc in the GROUP BY, we also need to check
+    // to see if there was a date_trunc column that was given an alias and
+    // that alias is used in the GROUP BY (which is also set to rowField).
+    const isDateTrunc = (item) => ['function', 'date_trunc'].includes(item.type);
+    const isExtract = (item) => 'extract' === item.type;
+    const isCol = (x) => ['double_quote_string', 'column_ref'].includes(x.type);
+    const isAlias = (x) => isCol(x) && aliasMap[(0, ast_1.extractColumnish)(x)];
+    const dateTruncGroup = ast.groupby.find(isDateTrunc);
+    const extractGroup = ast.groupby.find(isExtract);
+    if (dateTruncGroup) {
+        const column = dateTruncGroup.args?.value.find(isCol);
+        pivot.rowField = (0, ast_1.extractColumnish)(column);
+    }
+    else if (extractGroup) {
+        const column = extractGroup.args?.source;
+        pivot.rowField = (0, ast_1.extractColumnish)(column);
+    }
+    else if (aliasMap) {
+        const match = ast.groupby.find(isAlias);
+        const matchColumnish = (0, ast_1.extractColumnish)(match);
+        if (matchColumnish) {
+            const actualColumnName = aliasMap[matchColumnish];
+            pivot.rowField = actualColumnName;
+        }
+    }
+    // Otherwise, set the first groupby to rowField then set
+    // next field to columnField (if there is one)
+    for (let j = 0; j < ast.groupby.length; j++) {
+        const group = ast.groupby[j];
+        let groupValue = (0, ast_1.extractColumnish)(group);
+        // check if this value is an alias, if so use concrete value
+        if (groupValue && aliasMap[groupValue]) {
+            groupValue = aliasMap[groupValue];
+        }
+        // Try to set the rowField and columnField.
+        if (!pivot.rowField) {
+            pivot.rowField = groupValue;
+        }
+        else if (!pivot.columnField && groupValue !== pivot.rowField) {
+            pivot.columnField = groupValue;
+        }
+    }
+    newAst = { ...ast };
+    newAst.groupby = null;
+    newAst.columns = newColumns;
+    // Automatically order by the rowField if this is a 1D pivot (ie. no columnField)
+    // we also want to automatically order by rowField if the rowField is date-ish.
+    // TODO: dateish check breaks for plain date-type columns (ie. non date_trunc/extract)
+    const isPivot1D = pivot.rowField && !pivot.columnField;
+    const isRowFieldDateish = (0, util_1.isColumnDateish)(newAst.columns.find((c) => c.as === pivot?.rowField));
+    const isAutoOrderBy = isPivot1D || isRowFieldDateish;
+    newAst.orderby = isAutoOrderBy
+        ? [
+            {
+                expr: { type: 'column_ref', table: null, column: pivot.rowField },
+                type: newAst.orderby !== null
+                    ? newAst.orderby[0]?.type ?? 'DESC'
+                    : 'DESC',
+            },
+        ]
+        : null;
+    // If the AI didn't generate an aggregate, add one.
+    if (!pivot.valueField) {
+        pivot.valueField = columns[0].field;
+        pivot.aggregationType = 'sum';
+    }
+    return { pivot, ast: newAst };
+}
+exports.convertGroupBy = convertGroupBy;
+/**
+ * Applies a pivot to an object with {rows, fields} keys, returning
+ * a new object with the aggragation applied to the rows and the
+ * corresponding fields updated to reflect the accurate types.
+ */
+function applyPivot(data, pivot, schema) {
+    const newRows = [];
+    const { rows, fields } = data;
+    const { aggregationType, valueField, rowField, columnField } = pivot;
+    if (rows.length === 0)
+        return { rows, fields };
+    if ((rowField || columnField) && !valueField)
+        return { rows, fields };
+    if (columnField && !Object.keys(schema).includes(columnField))
+        return { rows, fields };
+    const AGGREGATORS = {
+        sum: (prev, next, _count = 0) => Number(prev) + Number(next),
+        max: (prev, next, _count = 0) => Math.max(Number(prev), Number(next)),
+        min: (prev, next, _count = 0) => Math.min(Number(prev), Number(next)),
+        count: (_prev, _next, count = 0) => Number(count) + 1,
+        avg: (prev, next, count = 0) => (Number(prev) * count + Number(next)) / (count + 1),
+    };
+    if (!columnField) {
+        // Simple 1D pivot
+        const keys = Object.keys(rows[0]);
+        for (const row of rows) {
+            let newRow = newRows.find((r) => r[rowField] === row[rowField]);
+            if (newRow) {
+                // Aggregate the existing row with this row
+                newRow[valueField] = AGGREGATORS[aggregationType](newRow[valueField], row[valueField], newRow.count ?? 0);
+                newRow.count = (newRow.count ?? 0) + 1;
+            }
+            else {
+                // Build up a new row and add it to our new rows array.
+                newRow = keys.reduce((obj, key) => {
+                    obj[key] = row[key];
+                    return obj;
+                }, {});
+                newRow.count = 1;
+                newRows.push(newRow);
+            }
+        }
+        // Remove the count property before returning
+        for (const row of newRows) {
+            delete row.count;
+        }
+        return { rows: newRows, fields };
+    }
+    else {
+        // 2D Pivot with rowField and columnField
+        const columnVariants = Object.keys(schema[columnField]);
+        const rowFieldColumnType = fields.find((f) => f.name === rowField);
+        const valueFieldColumnType = fields.find((f) => f.name === valueField);
+        const newFields = [
+            rowFieldColumnType,
+            ...columnVariants.map((name) => {
+                return { ...valueFieldColumnType, name };
+            }),
+        ];
+        for (const row of rows) {
+            let newRow = newRows.find((r) => r[rowField] === row[rowField]);
+            if (newRow) {
+                // Aggregate the existing row with this row
+                newRow[row[columnField]] = AGGREGATORS[aggregationType](newRow[row[columnField]], row[valueField], newRow[`${row[columnField]}_count`] ?? 0);
+                newRow[`${row[columnField]}_count`] += 1;
+            }
+            else {
+                // Build up a new row and add it to our new rows array.
+                const defaultAllColumnVariants = columnVariants.reduce((obj, key) => {
+                    // set each variant to the default value (eg. 0)
+                    obj[key] = aggregationType === 'min' ? Number.MAX_VALUE : 0;
+                    obj[`${key}_count`] = 0;
+                    return obj;
+                }, {});
+                newRow = {
+                    [rowField]: row[rowField],
+                    ...defaultAllColumnVariants,
+                };
+                newRow[row[columnField]] =
+                    aggregationType === 'count' ? 1 : row[valueField];
+                newRow[`${row[columnField]}_count`] = 1;
+                newRows.push(newRow);
+            }
+        }
+        // Remove the _count properties before returning
+        for (const row of newRows) {
+            for (const key in row) {
+                if (key.endsWith('_count')) {
+                    // Show a special output for no entries so that we
+                    // don't show our dummy defaults like 0 or Number.MAX_VALUE
+                    if (row[key] === 0) {
+                        row[key.replace('_count', '')] = '-';
+                    }
+                    delete row[key];
+                }
+            }
+        }
+        return { rows: newRows, fields: newFields };
+    }
+}
+exports.applyPivot = applyPivot;
+function convertStringComparison(node, databaseType) {
+    // Function to recursively search and replace the pattern in the object
+    function searchAndReplace(obj) {
+        if (Array.isArray(obj)) {
+            // If the current node is an array, process each element of the array
+            obj.forEach((element) => {
+                searchAndReplace(element);
+            });
+        }
+        else if (typeof obj === 'object' && obj !== null) {
+            // If the current node is an object, check for the pattern
+            if (obj.type === 'binary_expr' &&
+                (obj.operator === '=' ||
+                    obj.operator === 'LIKE' ||
+                    obj.operator === 'ILIKE') &&
+                obj.left &&
+                (obj.left.type === 'column_ref' ||
+                    obj.left.type === 'double_quote_string') &&
+                obj.right &&
+                obj.right.type === 'single_quote_string') {
+                // Pattern found, modify the current object to use LOWER and LIKE
+                obj.operator = 'LIKE';
+                obj.left = {
+                    type: 'function',
+                    name: 'LOWER',
+                    args: {
+                        type: 'expr_list',
+                        value: [
+                            databaseType === 'BigQuery'
+                                ? { type: 'column_ref', value: obj.left.column }
+                                : { type: 'double_quote_string', value: obj.left.column },
+                        ],
+                    },
+                };
+                obj.right = {
+                    type: 'function',
+                    name: 'LOWER',
+                    args: {
+                        type: 'expr_list',
+                        value: [
+                            {
+                                type: 'single_quote_string',
+                                value: `%${obj.right.value.replaceAll('%', '')}%`,
+                            },
+                        ],
+                    },
+                };
+            }
+            else if (obj.type === 'binary_expr' &&
+                (obj.operator === '!=' ||
+                    obj.operator === 'NOT LIKE' ||
+                    obj.operator === 'NOT ILIKE' ||
+                    obj.operator === '<>') &&
+                obj.left &&
+                (obj.left.type === 'column_ref' ||
+                    obj.left.type === 'double_quote_string') &&
+                obj.right &&
+                obj.right.type === 'single_quote_string') {
+                // Pattern found, modify the current object to use LOWER and LIKE
+                obj.operator = 'NOT LIKE';
+                obj.left = {
+                    type: 'function',
+                    name: 'LOWER',
+                    args: {
+                        type: 'expr_list',
+                        value: [
+                            databaseType === 'BigQuery'
+                                ? { type: 'column_ref', value: obj.left.column }
+                                : { type: 'double_quote_string', value: obj.left.column },
+                        ],
+                    },
+                };
+                obj.right = {
+                    type: 'function',
+                    name: 'LOWER',
+                    args: {
+                        type: 'expr_list',
+                        value: [
+                            {
+                                type: 'single_quote_string',
+                                value: `%${obj.right.value.replaceAll('%', '')}%`,
+                            },
+                        ],
+                    },
+                };
+            }
+            else if (obj.type === 'binary_expr' &&
+                (obj.operator === 'NOT IN' || obj.operator === 'IN') &&
+                obj.left &&
+                (obj.left.type === 'column_ref' ||
+                    obj.left.type === 'double_quote_string') &&
+                obj.right &&
+                obj.right.type === 'expr_list' &&
+                obj.right.value &&
+                obj.right.value.length &&
+                obj.right.value[0].type === 'single_quote_string') {
+                obj.left = {
+                    type: 'function',
+                    name: 'LOWER',
+                    args: {
+                        type: 'expr_list',
+                        value: [
+                            databaseType === 'BigQuery'
+                                ? { type: 'column_ref', value: obj.left.column }
+                                : { type: 'double_quote_string', value: obj.left.column },
+                        ],
+                    },
+                };
+                obj.right = {
+                    type: 'expr_list',
+                    // convert NOT IN ('fuel', 'food') to NOT IN (LOWER('fuel'), LOWER('food'))
+                    value: obj.right.value.map((elem) => ({
+                        type: 'function',
+                        name: 'LOWER',
+                        args: {
+                            type: 'expr_list',
+                            value: [{ type: 'single_quote_string', value: elem.value }],
+                        },
+                    })),
+                };
+            }
+            else {
+                // If the current object does not match the pattern, continue searching its properties
+                Object.values(obj).forEach((value) => {
+                    searchAndReplace(value);
+                });
+            }
+        }
+    }
+    // Start the recursive search and replace from the root node
+    searchAndReplace(node);
+    return node;
+}
+exports.convertStringComparison = convertStringComparison;
+// When there is a single "OR" boolean operator, we ensure that there
+// are no parentheses on that object.
+function convertRemoveSimpleParentheses(ast) {
+    const node = ast.where;
+    if ((0, ast_1.isLogicalBinaryExpr)(node) &&
+        node.operator === 'OR' &&
+        !(0, ast_1.isLogicalBinaryExpr)(node.left) &&
+        !(0, ast_1.isLogicalBinaryExpr)(node.right) &&
+        node.parentheses) {
+        delete node.parentheses;
+    }
+    return { ...ast, where: node };
+}
+exports.convertRemoveSimpleParentheses = convertRemoveSimpleParentheses;