@quillsql/react 2.12.37 → 2.12.38

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

@@ -0,0 +1,717 @@
+import { isValid, parseISO } from 'date-fns';
+import { generatePivotTitle } from '../../internals/ReportBuilder/PivotModal';
+import { extractColumnish, isSelect, isLogicalBinaryExpr, isBigQuery, isNumericColumnType, getColumnName, } from './ast';
+import { generateColumnExpr, isIdColumn } from './util';
+import { convertColumnInfoToColumnInternal } 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.name,
+            },
+            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.valueField, pivot.rowField, pivot.columnField].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 {};
+    }
+    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 = 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) {
+            pivot.columnField = groupValue;
+        }
+    }
+    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';
+            }
+        }
+    }
+    // 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);
+            newPivot.valueField = caseWhenPivot.valueField;
+            newPivot.aggregationType = caseWhenPivot.aggregationType;
+            newPivot.columnField = caseWhenPivot.columnField;
+        }
+        else if (column.expr.type === 'aggr_func' && !isIdColumn(columnName)) {
+            const aggObj = column.expr;
+            newPivot.aggregationType = aggObj.name.toLowerCase();
+            if (newPivot.aggregationType === 'avg') {
+                newPivot.aggregationType = 'average';
+            }
+            newPivot.valueField = columnName;
+        }
+        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
+        if (finalPivot.valueField) {
+            const column = columnInfo.find((c) => c.field === finalPivot.valueField);
+            if (!column || !isNumericColumnType(column.fieldType)) {
+                // @ts-ignore
+                finalPivot.valueField = null;
+                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) {
+        return;
+    }
+    if (!pivot.valueField) {
+        let firstNumericNonIdColumn = undefined;
+        newAst.columns.forEach((col) => {
+            if (!isIdColumn(col.as) &&
+                isNumericColumnType(columns.find((c) => c.field === col.as)?.fieldType)) {
+                firstNumericNonIdColumn = { ...col };
+            }
+        });
+        if (firstNumericNonIdColumn) {
+            pivot.valueField = firstNumericNonIdColumn.as;
+            pivot.aggregationType = 'sum';
+        }
+        else {
+            pivot.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, prevPivot = null, schemaTables) {
+    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)
+        .map((column) => {
+        return convertColumnInfoToColumnInternal(column);
+    });
+    // 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.expr?.column?.expr?.value,
+                c.as,
+            ].includes(col));
+            if (prevPivot.valueField) {
+                const existingCol = columnAlreadyExists(prevPivot.valueField);
+                newColumns.push(existingCol ?? generateColumnExpr(prevPivot.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));
+            }
+            ast.columns = newColumns;
+            return { pivot: prevPivot, ast };
+        }
+        pivot = convertASTToPivotData(ast, columns);
+        if (pivot && Object.keys(pivot).length === 0) {
+            pivot = null;
+        }
+        addAllPivotColumnsToColumnAST(ast.columns, pivot);
+        newAst = { ...ast };
+        newAst.columns = cleanASTColumns(ast, columns);
+        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 };
+    newAst.groupby = null;
+    newAst.columns = cleanASTColumns(ast, columns);
+    // 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);
+    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 };
+}