@quillsql/react 2.15.2 → 2.15.4

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

@@ -1,906 +0,0 @@
-import { isValid, parseISO } from 'date-fns';
-import { generatePivotTitle } from '../../internals/ReportBuilder/PivotModal';
-import { extractColumnish, isSelect, isLogicalBinaryExpr, isBigQuery, isNumericColumnType, getColumnName, getTableNames, isBoolColumnType, } from './ast';
-import { generateColumnExpr, isIdColumn } from './util';
-import { getFieldFromExpression } from '../../utils/astFilterProcessing';
-import { isStringType } from '../../utils/columnProcessing';
-// 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
-export 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;
-}
-// THIS IS ONLY USEFUL TO CONVERT FUNCTIONS INTO OTHER FUNCTIONS FOR BIGQUERY FOR FILTERS
-export 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;
-            }
-        });
-    }
-}
-// THIS IS USED TO REPLACE UNITS IN INTERVALS FOR BIGQUERY
-export function recursiveSearchAndReplaceByKey(node, search, replace, searchKey) {
-    if (typeof node !== 'object') {
-        return;
-    }
-    if (node) {
-        Object.keys(node).forEach((key) => {
-            recursiveSearchAndReplaceByKey(node[key], search, replace, searchKey);
-            if (searchKey === key && node[key] === search) {
-                node[key] = replace;
-            }
-        });
-    }
-}
-/**
- * Takes a bigquery AST as input, cleans it, and returns a Select AST.
- */
-export function convertBigQuery(ast) {
-    // For BigQuery, the info we want is nested inside the 'select' key
-    if (isBigQuery(ast)) {
-        const 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');
-        // JANK: If anyone is here this is how you have to do intervals in BigQuery no joke
-        recursiveSearchAndReplaceByKey(newAst.where, 'year', '* 365 DAY', 'unit');
-        recursiveSearchAndReplaceByKey(newAst.where, 'week', '* 7 DAY', 'unit');
-        recursiveSearchAndReplaceByKey(newAst.where, 'month', '* 30 DAY', 'unit');
-        // TODO: handle joins nicely
-        // if (newAst.from && newAst.from.length > 1) {
-        //   newAst.from = [newAst.from![0]!];
-        // }
-        // TODO: handle UNION ALL joins
-        if (newAst._next) {
-            delete newAst._next;
-        }
-        return newAst;
-    }
-    else {
-        // TODO: handle joins nicely
-        // if (ast.from && ast.from.length > 1) {
-        //   ast.from = [ast.from![0]!];
-        // }
-        // TODO: handle UNION ALL joins
-        if (ast._next) {
-            delete ast._next;
-        }
-        return ast;
-    }
-}
-function columnExistsInNewColumns(columns, col) {
-    return columns.find((c) => [c.expr?.value, c.expr?.column, c.expr?.column?.expr?.value, c.as].includes(col));
-}
-/**
- * Replaces the wildcard column selector with their literal column names.
- */
-export function convertWildcardColumns(ast, schemaTables) {
-    if (ast.columns !== '*' &&
-        ast.columns.length !== 0 &&
-        (!ast.columns[0].expr || ast.columns[0].expr.column !== '*')) {
-        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.field,
-            },
-            as: null,
-        })),
-    };
-}
-/**
- * Take a list of AST column objects of any form and turn them into the generic select form
- */
-export function convertColumnToGenericColumns(astColumns) {
-    const genericColumnReferences = [];
-    astColumns.forEach((column) => {
-        const columnName = getColumnName(column);
-        if (!columnName) {
-            return;
-        }
-        genericColumnReferences.push({
-            type: 'expr',
-            expr: {
-                type: 'column_ref',
-                table: null,
-                column: columnName,
-            },
-            as: columnName,
-        });
-    });
-    return genericColumnReferences;
-}
-function cleanASTColumns(ast, columns) {
-    let newColumns = convertColumnToGenericColumns(ast.columns);
-    const columnNames = [];
-    newColumns = newColumns.filter((col) => {
-        if (!columnNames.includes(col.as)) {
-            columnNames.push(col.as);
-            return true;
-        }
-        else {
-            return false;
-        }
-    });
-    newColumns = newColumns.filter((col) => columns.find((c) => c.field === col.as));
-    return newColumns;
-}
-function addAllPivotColumnsToColumnAST(astColumns, pivot) {
-    if (!pivot) {
-        return;
-    }
-    [
-        pivot.aggregations?.map((agg) => [agg.valueField, agg.valueField2])?.flat(),
-        pivot.rowField,
-        pivot.columnField,
-    ]
-        .flat()
-        .filter((field) => typeof field === 'string' && field !== undefined)
-        .forEach((field) => {
-        if (!field || columnExistsInNewColumns(astColumns, field)) {
-            return;
-        }
-        if (field && !astColumns.find((col) => col.as === field)) {
-            astColumns.push(generateColumnExpr(field));
-        }
-    });
-}
-function convertGroupByToPivotData(ast, columns, aliasMap) {
-    if (!ast.groupby) {
-        return {};
-    }
-    if (!Array.isArray(ast.groupby)) {
-        // @ts-ignore
-        ast.groupby = ast.groupby.columns; // change as of node-sql-parser v5.3.4
-        if (!ast.groupby) {
-            return {};
-        }
-    }
-    const pivot = {};
-    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 dateTruncGroup = ast.groupby.find(isDateTrunc);
-    const extractGroup = ast.groupby.find(isExtract);
-    if (dateTruncGroup) {
-        const column = dateTruncGroup.args?.value.find(isCol);
-        const columnName = extractColumnish(column);
-        pivot.rowField = columnName;
-        pivot.rowFieldType = columns.find((c) => c.field === columnName)?.fieldType;
-    }
-    else if (extractGroup) {
-        const column = extractGroup.args?.source;
-        const columnName = extractColumnish(column);
-        pivot.rowField = columnName;
-        pivot.rowFieldType = columns.find((c) => c.field === columnName)?.fieldType;
-    }
-    // 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;
-        if (group?.type === 'number') {
-            const index = typeof group.value === 'number' ? group.value : 1;
-            const equivalentColumn = ast.columns[index - 1];
-            groupValue = extractColumnish(equivalentColumn.expr);
-        }
-        else {
-            groupValue = extractColumnish(group);
-        }
-        if (!groupValue || isIdColumn(groupValue)) {
-            continue;
-        }
-        // 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.
-        const column = columns.find((c) => c.field === groupValue);
-        if (!column ||
-            isNumericColumnType(column.fieldType) ||
-            isIdColumn(column.field)) {
-            continue;
-        }
-        if (!pivot.rowField) {
-            pivot.rowField = groupValue;
-            pivot.rowFieldType = columns.find((c) => c.field === groupValue)?.fieldType;
-        }
-        else if (!pivot.columnField && groupValue !== pivot.rowField) {
-            const columnFieldType = columns.find((c) => c.field === groupValue)?.fieldType;
-            if (!isStringType(columnFieldType || '')) {
-                // try swapping row and column
-                if (isStringType(pivot.rowFieldType || '')) {
-                    pivot.columnField = pivot.rowField;
-                    pivot.columnFieldType = pivot.rowFieldType;
-                    pivot.rowField = groupValue;
-                    pivot.rowFieldType = columnFieldType;
-                    break;
-                }
-                else {
-                    continue;
-                }
-            }
-            pivot.columnField = groupValue;
-            pivot.columnFieldType = columnFieldType;
-        }
-    }
-    return pivot;
-}
-function convertCaseWhenToPivotData(column) {
-    const pivot = {};
-    const columnNode = column.expr?.args?.expr?.args[0]?.result;
-    const columnName = columnNode?.value ?? columnNode?.column?.expr?.value ?? columnNode?.column;
-    if (columnName && typeof columnName === 'string') {
-        if (!isIdColumn(columnName)) {
-            pivot.valueField = columnName;
-            pivot.aggregationType = column?.expr?.name?.toLowerCase();
-            if (pivot.aggregationType === 'avg') {
-                pivot.aggregationType = 'average';
-            }
-            pivot.aggregations = [
-                {
-                    valueField: pivot.valueField,
-                    aggregationType: pivot.aggregationType,
-                },
-            ];
-        }
-    }
-    // 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?.expr?.value ??
-        condNode.left?.column ??
-        condNode.left?.value;
-    if (!isIdColumn(condColumnName)) {
-        pivot.columnField = condColumnName;
-    }
-    return pivot;
-}
-export function convertASTToPivotData(ast, columnInfo) {
-    const newPivot = {};
-    const aliasMap = {};
-    if (ast.columns === '*') {
-        return null;
-    }
-    ast.columns.forEach((column) => {
-        const columnName = getColumnName(column);
-        if (!columnName) {
-            return;
-        }
-        const alias = column.as || columnName;
-        aliasMap[alias] = columnName;
-        if (column.expr?.args?.expr?.type.toLowerCase() === 'case' &&
-            ['double_quote_string', 'column_ref'].includes(column.expr?.args?.expr?.args[0]?.result?.type)) {
-            const caseWhenPivot = convertCaseWhenToPivotData(column);
-            if (caseWhenPivot.aggregations) {
-                caseWhenPivot.aggregations.forEach((agg) => {
-                    if (!newPivot.aggregations?.find((a) => a.valueField === agg.valueField)) {
-                        newPivot.aggregations = newPivot.aggregations ?? [];
-                        newPivot.aggregations.push(agg);
-                    }
-                });
-            }
-            else {
-                if (!newPivot.aggregations?.find((a) => a.valueField === caseWhenPivot.valueField)) {
-                    newPivot.aggregations = newPivot.aggregations ?? [];
-                    newPivot.aggregations.push({
-                        valueField: caseWhenPivot.valueField,
-                        aggregationType: caseWhenPivot.aggregationType,
-                    });
-                }
-            }
-            newPivot.columnField = caseWhenPivot.columnField;
-        }
-        else if (column.expr.type === 'aggr_func' && !isIdColumn(columnName)) {
-            const aggObj = column.expr;
-            let aggregationType = aggObj.name.toLowerCase();
-            if (aggregationType === 'avg') {
-                aggregationType = 'average';
-            }
-            newPivot.aggregations = newPivot.aggregations ?? [];
-            newPivot.aggregations.push({
-                valueField: columnName,
-                aggregationType,
-            });
-        }
-        else if (column.expr.type === 'function') {
-            const functionInfo = column.expr.name;
-            if (Array.isArray(functionInfo.name) &&
-                functionInfo.name[0].value &&
-                ['timestamp_trunc', 'date_trunc', 'date_part'].includes(functionInfo.name[0].value.toLowerCase())) {
-                newPivot.rowField = columnName;
-            }
-        }
-    });
-    const pivotData = convertGroupByToPivotData(ast, columnInfo, aliasMap);
-    const finalPivot = { ...pivotData, ...newPivot };
-    const isColumnDate = columnInfo.find((column) => column.field === finalPivot?.columnField)
-        ?.fieldType === 'date';
-    if (finalPivot) {
-        // Make sure date fields are set to the rowField
-        const isPivot1D = finalPivot.rowField && !finalPivot.columnField;
-        if (finalPivot.columnField && isColumnDate) {
-            [finalPivot.rowField, finalPivot.columnField] = [
-                finalPivot.columnField,
-                finalPivot.rowField,
-            ];
-            finalPivot.rowFieldType = 'date';
-        }
-        // Make sure pivot value field is of numeric type
-        // MAke sure each value field is of numeric type
-        if (finalPivot.aggregations) {
-            finalPivot.aggregations = finalPivot.aggregations.filter((agg) => {
-                const column = columnInfo.find((c) => c.field === agg.valueField);
-                return (column &&
-                    (isNumericColumnType(column.fieldType) ||
-                        isBoolColumnType(column.fieldType)));
-            });
-        }
-        else if (finalPivot.valueField) {
-            const column = columnInfo.find((c) => c.field === finalPivot.valueField);
-            if (!column ||
-                !(isNumericColumnType(column.fieldType) ||
-                    isBoolColumnType(column.fieldType))) {
-                finalPivot.valueField = '';
-                finalPivot.aggregationType = 'count';
-            }
-        }
-        if (finalPivot.rowFieldType === 'date') {
-            finalPivot.sort = true;
-            finalPivot.sortDirection = 'ASC';
-            finalPivot.sortField = finalPivot.rowField;
-            finalPivot.sortFieldType = finalPivot.rowFieldType;
-        }
-        else if (isPivot1D) {
-            finalPivot.sort = true;
-            finalPivot.sortDirection = 'ASC';
-            finalPivot.sortField = finalPivot.rowField;
-            finalPivot.sortFieldType = finalPivot.rowFieldType;
-        }
-    }
-    return finalPivot;
-}
-function addValueFieldToPivot(newAst, pivot, columns) {
-    if (!pivot ||
-        // (pivot.aggregationType === 'count' && (pivot.rowField || pivot.valueField))
-        pivot.aggregations?.some((agg) => agg.aggregationType === 'count' && (agg.valueField || pivot.rowField))) {
-        return;
-    }
-    if (!pivot.aggregations?.length) {
-        let firstNumericNonIdColumn = undefined;
-        (newAst.groupby?.columns ?? newAst.columns).forEach((col) => {
-            const field = getFieldFromExpression(col.expr) || col.as;
-            if (!isIdColumn(field) &&
-                isNumericColumnType(columns.find((c) => c.field === field)?.fieldType)) {
-                firstNumericNonIdColumn = { ...col };
-            }
-        });
-        if (firstNumericNonIdColumn) {
-            pivot.aggregations = [
-                {
-                    valueField: getFieldFromExpression(firstNumericNonIdColumn.expr) ||
-                        firstNumericNonIdColumn.as,
-                    aggregationType: 'sum',
-                },
-            ];
-        }
-        else {
-            const numericColumn = columns.find((c) => isNumericColumnType(c.fieldType) && !isIdColumn(c.field));
-            if (numericColumn) {
-                newAst.columns.push(generateColumnExpr(numericColumn.field));
-                pivot.aggregations = [
-                    {
-                        valueField: numericColumn.field,
-                        aggregationType: 'sum',
-                    },
-                ];
-            }
-            else {
-                pivot.columnField = undefined;
-                pivot.columnFieldType = undefined;
-                pivot.aggregations = [
-                    {
-                        valueField: undefined,
-                        aggregationType: 'count',
-                    },
-                ];
-            }
-        }
-    }
-}
-/**
- * Processes the AST and builds up a new pivot, given the old AST, the old pivot
- * and a list of tables in the schema.
- */
-export function convertGroupBy(ast, schemaTables, prevPivot, prevTable) {
-    if (!isSelect(ast))
-        return { ast, pivot: prevPivot };
-    let newAst = {};
-    let pivot;
-    const newColumns = [];
-    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);
-    // If there is not GROUP BY clause in the AST, we still need to process the
-    // AST but it should pass-through in nature.
-    // @ts-ignore
-    if (!ast.groupby?.columns && !ast.groupby) {
-        // If there was a pivot before, evaluate the pivot.
-        if (prevPivot && (!prevTable || tableNamesInQuery.includes(prevTable))) {
-            // 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.expr?.column?.expr?.value,
-                c.as,
-            ].includes(col));
-            if (prevPivot.aggregations?.length) {
-                for (const agg of prevPivot.aggregations) {
-                    if (agg.valueField) {
-                        newColumns.push(columnAlreadyExists(agg.valueField) ??
-                            generateColumnExpr(agg.valueField));
-                    }
-                    if (agg.valueField2) {
-                        newColumns.push(columnAlreadyExists(agg.valueField) ??
-                            generateColumnExpr(agg.valueField));
-                    }
-                }
-            }
-            if (prevPivot.rowField) {
-                const existingCol = columnAlreadyExists(prevPivot.rowField);
-                newColumns.push(existingCol ?? generateColumnExpr(prevPivot.rowField));
-            }
-            if (prevPivot.columnField) {
-                const existingCol = columnAlreadyExists(prevPivot.columnField);
-                newColumns.push(existingCol ?? generateColumnExpr(prevPivot.columnField));
-            }
-            return { pivot: prevPivot, ast: { ...ast, columns: newColumns } };
-        }
-        pivot = convertASTToPivotData(ast, columns);
-        if (pivot && Object.keys(pivot).length === 0) {
-            pivot = null;
-        }
-        addAllPivotColumnsToColumnAST(ast.columns, pivot);
-        newAst = { ...ast };
-        const cleanedColumns = cleanASTColumns(ast, columns);
-        if (newAst?.columns &&
-            newAst.columns.length > 0 &&
-            cleanedColumns.length === 0) {
-            // no columns remaining, use star as default
-            newAst.columns = [
-                {
-                    expr: {
-                        type: 'column_ref',
-                        table: null,
-                        column: '*',
-                    },
-                    as: null,
-                },
-            ];
-            newAst = convertWildcardColumns(newAst, schemaTables);
-        }
-        else {
-            newAst.columns = cleanedColumns;
-        }
-        addValueFieldToPivot(newAst, pivot, columns);
-        return { pivot, ast: newAst };
-    }
-    pivot = convertASTToPivotData(ast, columns);
-    if (!pivot || pivot == null) {
-        throw new Error('Pivot is null');
-    }
-    addAllPivotColumnsToColumnAST(ast.columns, pivot);
-    newAst = { ...ast };
-    const cleanedColumns = cleanASTColumns(ast, columns);
-    if (newAst?.columns &&
-        newAst.columns.length > 0 &&
-        cleanedColumns.length === 0) {
-        // no columns remaining, use star as default
-        newAst.columns = [
-            {
-                expr: {
-                    type: 'column_ref',
-                    table: null,
-                    column: '*',
-                },
-                as: null,
-            },
-        ];
-        newAst = convertWildcardColumns(newAst, schemaTables);
-    }
-    else {
-        newAst.columns = cleanedColumns;
-    }
-    // ADD sort if pivot has sort
-    if (pivot.sort) {
-        newAst.orderby = [
-            {
-                expr: { type: 'column_ref', table: null, column: pivot.rowField },
-                type: newAst.orderby !== null
-                    ? (newAst.orderby[0]?.type ?? 'DESC')
-                    : 'DESC',
-            },
-        ];
-    }
-    addValueFieldToPivot(newAst, pivot, columns);
-    // @ts-ignore
-    const title = generatePivotTitle(pivot);
-    newAst.groupby = null;
-    newAst.having = null; // don't handle this yet
-    return { pivot: { ...pivot, title }, ast: newAst };
-}
-export 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 === '=' && !isValid(parseISO(obj.right.value))) || // don't do it on date objects
-                    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: {
-                        name: [
-                            {
-                                type: 'default',
-                                value: 'LOWER',
-                            },
-                        ],
-                    },
-                    args: {
-                        type: 'expr_list',
-                        value: [
-                            databaseType === 'BigQuery'
-                                ? {
-                                    type: 'column_ref',
-                                    value: obj.left.column?.expr?.value ||
-                                        obj.left.column ||
-                                        obj.left.value,
-                                }
-                                : {
-                                    type: 'column_ref',
-                                    table: null,
-                                    column: {
-                                        expr: {
-                                            type: 'default',
-                                            value: obj.left.column?.expr?.value ||
-                                                obj.left.column ||
-                                                obj.left.value,
-                                        },
-                                    },
-                                },
-                        ],
-                    },
-                };
-                obj.right = {
-                    type: 'function',
-                    name: {
-                        name: [
-                            {
-                                type: 'default',
-                                value: '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: {
-                        name: [
-                            {
-                                type: 'default',
-                                value: 'LOWER',
-                            },
-                        ],
-                    },
-                    args: {
-                        type: 'expr_list',
-                        value: [
-                            databaseType === 'BigQuery'
-                                ? {
-                                    type: 'column_ref',
-                                    value: obj.left.column?.expr?.value ||
-                                        obj.left.column ||
-                                        obj.left.value,
-                                }
-                                : {
-                                    type: 'double_quote_string',
-                                    value: obj.left.column?.expr?.value ||
-                                        obj.left.column ||
-                                        obj.left.value,
-                                },
-                        ],
-                    },
-                };
-                obj.right = {
-                    type: 'function',
-                    name: {
-                        name: [
-                            {
-                                type: 'default',
-                                value: '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: {
-                        name: [],
-                        schema: {
-                            type: 'default',
-                            value: 'LOWER',
-                        },
-                    },
-                    args: {
-                        type: 'expr_list',
-                        value: [
-                            databaseType === 'BigQuery'
-                                ? {
-                                    type: 'column_ref',
-                                    value: obj.left.column?.expr?.value ||
-                                        obj.left.column ||
-                                        obj.left.value,
-                                }
-                                : {
-                                    type: 'double_quote_string',
-                                    value: obj.left.column?.expr?.value ||
-                                        obj.left.column ||
-                                        obj.left.value,
-                                },
-                        ],
-                    },
-                };
-                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: {
-                            name: [],
-                            schema: {
-                                type: 'default',
-                                value: '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;
-}
-// When there is a single "OR" boolean operator, we ensure that there
-// are no parentheses on that object.
-export function convertRemoveSimpleParentheses(ast) {
-    const node = ast.where;
-    if (isLogicalBinaryExpr(node) &&
-        node.operator === 'OR' &&
-        !isLogicalBinaryExpr(node.left) &&
-        !isLogicalBinaryExpr(node.right) &&
-        node.parentheses) {
-        delete node.parentheses;
-    }
-    return { ...ast, where: node };
-}
-/**
- * Processes an ast and converts all unary_expr nodes or direct column_refs
- * into binary_expr form
- */
-export function convertUnaryToBinary(ast) {
-    const newAst = { ...ast };
-    if (!newAst.where) {
-        return ast;
-    }
-    function searchAndReplace(node) {
-        if (!node) {
-            return { ...node };
-        }
-        else if (node.type === 'binary_expr') {
-            if (node.operator.toLowerCase() === 'and' ||
-                node.operator.toLowerCase() === 'or') {
-                return {
-                    ...node,
-                    left: searchAndReplace(node.left),
-                    right: searchAndReplace(node.right),
-                };
-            }
-            else {
-                return { ...node };
-            }
-        }
-        else if (node.type === 'unary_expr' && node.operator === 'NOT') {
-            // yet to run into any other operator from AI
-            return {
-                type: 'binary_expr',
-                operator: '<>',
-                left: { ...node.expr },
-                right: { type: 'bool', value: true },
-            };
-        }
-        else if (node.type === 'column_ref') {
-            // e.g. WHERE field (boolean)
-            return {
-                type: 'binary_expr',
-                operator: '=',
-                left: { ...node },
-                right: { type: 'bool', value: true },
-            };
-        }
-        else {
-            return { ...node };
-        }
-    }
-    const newWhere = searchAndReplace(newAst.where);
-    return { ...newAst, where: newWhere };
-}
-// converts orderby to standardized form
-export function convertOrderBy(ast, schema) {
-    if (!ast.orderby) {
-        return ast;
-    }
-    const newAst = { ...ast };
-    newAst.orderby = newAst.orderby
-        .map((order) => {
-        const column = order.expr;
-        const columnName = getFieldFromExpression(column);
-        if (!columnName) {
-            return null;
-        }
-        const tables = getTableNames(ast);
-        const columnInfo = schema
-            .filter((t) => tables.includes(t.name))
-            .flatMap((table) => table.columns)
-            .find((c) => c.field === columnName);
-        if (!columnInfo) {
-            return order;
-        }
-        return {
-            ...order,
-            expr: {
-                type: 'column_ref',
-                column: columnName,
-            },
-            type: order.type || 'ASC',
-        };
-    })
-        .filter((order) => order);
-    if (newAst.orderby.length === 0) {
-        newAst.orderby = null;
-    }
-    return newAst;
-}
-export function isSimpleSelectStarQuery(query) {
-    const regex = /^\s*SELECT\s+\*\s+FROM\s+/i;
-    return regex.test(query);
-}
-export function convertQueryToSelectStar(query) {
-    return query.replace(/SELECT\s+.*?\s+FROM/i, 'SELECT * FROM');
-}