@quillsql/react 2.15.3 → 2.15.4

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

@@ -1,801 +0,0 @@
-// A collection of reusable, pure, utility functions for the Report Builder.
-import { getQuarter, format, addMinutes } from 'date-fns';
-import { DATE_DESCRIPTION_MAP } from './bigDateMap';
-import { snakeAndCamelCaseToTitleCase } from '../../utils/textProcessing';
-import { isAfterBigQuery, isBeforeBigQuery, isEqualsBigQuery, isInTheLastIntervalBigQuery, isTheCurrentIntervalBigQuery, } from '../../utils/parserBigQuery';
-import { isInTheLastIntervalPostgres, isTheCurrentIntervalPostgres, } from '../../utils/parserPostgres';
-import { getFieldFromExpression } from '../../utils/astFilterProcessing';
-/**
- * A node that is "in" or "not in" where none of the variants are selected.
- */
-export const isNodeEmptyCollection = (node) => {
-    return (['IN', 'NOT IN'].includes(node.operator) &&
-        node.right.type === 'expr_list' &&
-        node.right.value.length === 1 &&
-        node.right.value[0].type === 'function' &&
-        ['lower', 'upper'].includes(node.right.value[0].name.toLowerCase()) &&
-        node.right.value[0].args.type === 'expr_list' &&
-        node.right.value[0].args.value.length === 1 &&
-        node.right.value[0].args.value[0].value === '');
-};
-export function isTopLevelBoolean(node) {
-    // override normal logic for conditions added by users
-    if (node.isCondition !== undefined) {
-        return true;
-    }
-    if (!node.parentheses &&
-        node.type === 'binary_expr' &&
-        (node.operator === 'AND' || node.operator === 'OR')) {
-        return true;
-    }
-    return false;
-}
-export function hasTopLevelOrBoolean(ast) {
-    if (ast.where && ast.where.operator === 'OR') {
-        return true;
-    }
-    return false;
-}
-// Returns whether the node is a date_trunc function.
-export const isDateTrunc = (node) => {
-    try {
-        return node &&
-            node.type === 'function' &&
-            node.name === 'date_trunc' &&
-            node.args &&
-            node.args.type === 'expr_list' &&
-            node.args?.value.length === 2 &&
-            node.args?.value[0].type === 'single_quote_string' &&
-            // The right-side value can either be a double-quoted string literal or
-            // a cast to some sort of date-ish type. We handle these variants:
-            //  -> date_trunc('month', '2024-01-01'::DATE)
-            //  -> date_trunc('month', "2024-01-01")
-            //  -> date_trunc('month', TIMESTAMP '2024-01-01')
-            //  -> date_trunc('month', DATE '2024-01-01')
-            node.args?.value[1].type === 'cast'
-            ? node.args?.value[1].expr.type === 'single_quote_string'
-            : ['timestamp', 'date', 'column_ref', 'double_quote_string'].includes(node.args?.value[1].type);
-    }
-    catch (e) {
-        return false;
-    }
-};
-// Returns whether the given node is a raw column reference.
-export const isColumnReferenceish = (node) => {
-    return node && ['column_ref', 'double_quote_string'].includes(node.type);
-};
-export function generateColumnExpr(name) {
-    return {
-        type: 'expr',
-        expr: {
-            type: 'column_ref',
-            table: null,
-            column: name,
-        },
-        as: null,
-    };
-}
-// Returns whether this column node is either a date_trunc or extract
-// function which implies that it is some sort of date/timestamp type.
-// TODO: replace me with actual code that checks against dbtype.
-export const isColumnDateish = (col) => {
-    return (col &&
-        col?.expr?.type === 'function' &&
-        ['date_trunc', 'extract'].includes(col?.expr?.name?.toLowerCase()));
-};
-export function areObjectsEqualish(left, right) {
-    if (left === null || right === null)
-        return false;
-    if (left === undefined || right === undefined)
-        return false;
-    if (typeof left !== 'object' || typeof right !== 'object')
-        return false;
-    for (const [key, value] of Object.entries(left)) {
-        if (typeof value === 'string') {
-            if (!right[key])
-                return false;
-            if (right[key].toLowerCase() !== value.toLowerCase())
-                return false;
-        }
-        else if (typeof value === 'object') {
-            if (!areObjectsEqualish(value, right[key]))
-                return false;
-        }
-        else if (!value) {
-            if (!right[key])
-                return false;
-        }
-        else {
-            console.error('unknown type: ', typeof value);
-        }
-    }
-    return true;
-}
-export function formatDateComparisonNode(node) {
-    for (const [key, callback] of Object.entries(DATE_DESCRIPTION_MAP)) {
-        const partialObject = JSON.parse(key);
-        if (areObjectsEqualish(partialObject, node)) {
-            return callback(node);
-        }
-    }
-    return null;
-}
-export function getInTheCurrentIntervalSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = snakeAndCamelCaseToTitleCase(node.left.args.value[0].column);
-        const periodValue = node.left.args.value[1].column.toLowerCase();
-        return `${dateColumn} in the current ${periodValue}`;
-    }
-    return null;
-}
-const BIG_QUERY_DAY_TO_INTERVAL_MAP = {
-    '* 365 day': 'year',
-    '* 30 day': 'month',
-    '* 7 day': 'week',
-};
-export function getInTheLastIntervalSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = snakeAndCamelCaseToTitleCase(node.left.column || node.left.args.value[0].columns || '');
-        const amount = node.right.args.value[1].expr.value;
-        let unit = node.right.args.value[1].unit.toLowerCase();
-        if (unit.includes('*')) {
-            unit = BIG_QUERY_DAY_TO_INTERVAL_MAP[unit];
-        }
-        return `${dateColumn} in the last ${amount} ${unit}${amount > 1 ? 's' : ''}`;
-    }
-    return null;
-}
-export function getInThePreviousIntervalSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = snakeAndCamelCaseToTitleCase(node.left.args.value[0].column);
-        const periodValue = node.left.args.value[1].column.toLowerCase();
-        return `${dateColumn} in the previous ${periodValue}`;
-    }
-    return null;
-}
-export function getIsEqualsSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = snakeAndCamelCaseToTitleCase(node.left.args.value[1].column);
-        const type = node.right.args.value[1].column.toLowerCase();
-        const value = node.right.args.value[0].value;
-        // using date-fns can I parse the date to short month year
-        const date = new Date(value);
-        if (type === 'year') {
-            return `${dateColumn} is in ${format(addMinutes(date, date.getTimezoneOffset()), 'yyyy')}`;
-        }
-        else if (type === 'month') {
-            return `${dateColumn} is in ${format(addMinutes(date, date.getTimezoneOffset()), 'MMM yyyy')}`;
-        }
-        else if (type === 'quarter') {
-            return `${dateColumn} is in ${format(addMinutes(date, date.getTimezoneOffset()), 'QQQ yyyy')}`;
-        }
-        return `${dateColumn} is in the ${type} of ${value}`;
-    }
-    return null;
-}
-export function getIsAfterSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = snakeAndCamelCaseToTitleCase(node.left?.column || node.left?.args?.value[0]?.columns || '');
-        const value = node.right?.value || node.right?.args?.value[0]?.value || '';
-        if (!dateColumn || !value) {
-            return null;
-        }
-        return `${dateColumn} is after ${value}`;
-    }
-    return null;
-}
-export function getIsBeforeSentence(node, databaseType) {
-    if (databaseType === 'BigQuery') {
-        const dateColumn = snakeAndCamelCaseToTitleCase(node.left?.column || node.left?.args?.value[0]?.columns || '');
-        const value = node.right?.value || node.right?.args?.value[0]?.value || '';
-        if (!dateColumn || !value) {
-            return null;
-        }
-        return `${dateColumn} is before ${value}`;
-    }
-    return null;
-}
-// "created_at" >= date_trunc ('year', CURRENT_DATE) - INTERVAL '1 year'
-// or
-// "created_at" >= CURRENT_DATE - INTERVAL '1 year'
-// in the last year aka one interval from today
-export const isInTheLastInterval = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return isInTheLastIntervalBigQuery(node);
-    }
-    return isInTheLastIntervalPostgres(node);
-};
-export const isAfter = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return isAfterBigQuery(node);
-    }
-};
-export const isBefore = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return isBeforeBigQuery(node);
-    }
-};
-// "created_at" >= date_trunc ('year', CURRENT_DATE - INTERVAL '1 year')
-// this year
-export const isTheCurrentInterval = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return isTheCurrentIntervalBigQuery(node);
-    }
-    return isTheCurrentIntervalPostgres(node);
-};
-// "created_at" >= date_trunc ('year', CURRENT_DATE - INTERVAL '1 year')
-// this year
-export const isEquals = (node, databaseType) => {
-    if (databaseType && databaseType.toLowerCase() === 'bigquery') {
-        return isEqualsBigQuery(node);
-    }
-    return false;
-};
-export const isThePreviousInterval = (node) => {
-    const isInsideOfDateTrunc = ['='].includes(node.operator) &&
-        node.left.name &&
-        node.left.name.toLowerCase() === 'timestamp_trunc' &&
-        node.left.type === 'function' &&
-        node.right.name &&
-        node.right.name.toLowerCase() === 'timestamp_trunc' &&
-        node.right.args.value[0]?.name?.toLowerCase() === 'timestamp_sub' &&
-        node.right.args.value[0].args.value[0].name.toLowerCase() ===
-            'current_timestamp';
-    return isInsideOfDateTrunc;
-};
-/**
- * Returns whether this node is the root of a binary expression
- * where the left child is a string but really should be
- * interpreted as a column name.
- */
-export const isColumnComparison = (node) => {
-    const ops = [
-        '>=',
-        '>',
-        '<=',
-        '<',
-        'AND',
-        'OR',
-        '!=',
-        '=',
-        'LIKE',
-        'NOT LIKE',
-        'IN',
-        'NOT IN',
-        'BETWEEN',
-        '-',
-        '+',
-        'IS NOT',
-        'IS',
-    ];
-    return (ops.includes(node.operator) &&
-        node.left &&
-        (node.left.type === 'column_ref' ||
-            node.left.type === 'double_quote_string' ||
-            (node.left.type === 'function' &&
-                ['lower', 'upper'].includes(node.left.name.toLowerCase()))));
-};
-// Returns a new date object with timezone adjusted
-export const newUTCDate = (dateString) => {
-    let date = new Date(dateString);
-    // If the date is invalid, try appending a 1 (eg. "April" => "April 1")
-    if (Number.isNaN(date.getDate())) {
-        date = new Date(`${dateString} 1`);
-    }
-    date.setMinutes(date.getMinutes() + date.getTimezoneOffset()); // TZ adjust
-    // Default to using the current year, unless explicitly overridden
-    const dateYear = date.getFullYear();
-    if (!dateString.includes(dateYear.toString())) {
-        date.setFullYear(new Date().getFullYear());
-    }
-    return date;
-};
-const getPeriod = (node, databaseType) => {
-    if (databaseType === 'BigQuery') {
-        return node.left.args.value[1]?.column.toLowerCase();
-    }
-    else {
-        return node.left.args.value[0]?.value.toLowerCase();
-    }
-};
-/**
- * Takes the right side of a dateTruncEquals expression (ie. the suffix)
- * and returns a pretty string representation of what that value means.
- *
- * eg. date_trunc('year', TIMESTAMP '2023-01-01') would be "in 2023"
- * eg. date_trunc('month', TIMESTAMP '2023-01-01') would be "in Jan 2023"
- * eg. date_trunc('quarter', TIMESTAMP '2023-01-01') would be "in Q1 2023"
- */
-export function dateTruncSuffixToString(node, databaseType) {
-    const period = getPeriod(node, databaseType);
-    const dateNode = node.right.value ? node.right : node.right.args.value[1];
-    const rawDateStr = dateNode.type === 'cast' ? dateNode.expr.value : dateNode.value;
-    const date = newUTCDate(rawDateStr);
-    switch (period) {
-        case 'year':
-            return `in ${date.getFullYear()}`;
-        case 'quarter':
-            return `in Q${getQuarter(date)} ${date.getFullYear()}`;
-        case 'month':
-            return `in ${date.toLocaleString('default', { month: 'short', year: 'numeric' })}`;
-        case 'week':
-            return `week of ${date.toDateString()}`;
-        case 'day':
-            return `on ${date.toDateString()}`;
-        case 'hour':
-            return `hour of ${date.toLocaleString()}`;
-        default:
-            return `${period} of ${date}`;
-    }
-}
-/**
- * Takes an extract binary expression and returns a string version
- * of what the AST means.
- *
- * eg. extract(YEAR FROM "created_at") = 2023 would be "in 2023"
- * eg. extract(MONTH FROM "created_at") = 1 would be "in January"
- * eg. TODO: add more variants as they come up
- */
-export function extractSuffixToString(node) {
-    const period = node.left.args.field.toLowerCase();
-    const value = node.right.value;
-    switch (period) {
-        case 'year': {
-            return `is ${value}`;
-        }
-        case 'month': {
-            const date = new Date(2000, value - 1, 1);
-            date.setMinutes(date.getMinutes() + date.getTimezoneOffset()); // TZ adjust
-            return `in ${date.toLocaleString('default', { month: 'long' })}`;
-        }
-        default: {
-            return `${period} is ${value}`;
-        }
-    }
-}
-export function tryConvertDateEquality(node, databaseType) {
-    if (isDateTruncEquals(node)) {
-        const columnNode = node.left.args.value[1];
-        const columnName = columnNode.column ?? columnNode.value;
-        const cleanColumnName = snakeAndCamelCaseToTitleCase(columnName.replaceAll('_at', ''));
-        const prettyDateSuffix = dateTruncSuffixToString(node, databaseType);
-        return `${cleanColumnName} ${prettyDateSuffix}`;
-    }
-    else if (isExtractEquals(node)) {
-        const columnNode = node.left.args.source;
-        const columnName = columnNode.column ?? columnNode.value;
-        const cleanColumnName = snakeAndCamelCaseToTitleCase(columnName.replaceAll('_at', ''));
-        const prettyDateSuffix = extractSuffixToString(node);
-        return `${cleanColumnName} ${prettyDateSuffix}`;
-    }
-    return undefined;
-}
-/**
- * Returns whether this node is an equality of a date column with a
- * date trunc.
- */
-export const isDateTruncEquals = (node) => {
-    return (node.type === 'binary_expr' &&
-        node.operator === '=' &&
-        isDateTrunc(node.left) &&
-        (node.right.type === 'single_quote_string' || // is a string literal
-            (node.right.type === 'cast' &&
-                node.right.expr.type === 'single_quote_string') || // or is string casted to non-string
-            isDateTrunc(node.right)) // or is a date_trunc
-    );
-};
-/**
- * Returns whether this node is an equality of a date column with extract.
- */
-export const isExtractEquals = (node) => {
-    return (node.type === 'binary_expr' &&
-        node.operator === '=' &&
-        node.left.type === 'extract' &&
-        node.right.type === 'number');
-};
-export function showNodeAsRow(node, ast) {
-    // if the expression is something like status = "completed"
-    if (node.left.type === 'column_ref') {
-        return true;
-    }
-    if (!['AND', 'OR'].includes(node.operator)) {
-        return true;
-    }
-    if ((ast.left?.left?.left?.left || ast.right?.left?.left?.left) &&
-        node.left.left?.type === 'column_ref') {
-        return true;
-    }
-    return false;
-}
-export function getPostgresBasicType(column) {
-    if (!column)
-        return undefined;
-    let format;
-    if (column.dataTypeID) {
-        switch (column.dataTypeID) {
-            case 16: // boolean
-                format = 'boolean';
-                break;
-            case 20: // int8
-            case 21: // int2
-            case 23: // int4
-            case 700: // float4
-            case 701: // float8
-            case 1700: // numeric
-                format = 'number';
-                break;
-            case 1082: // date
-            case 1083: // time
-            case 1184: // timestamptz
-            case 1114: // timestamp
-                format = 'date';
-                break;
-            case 1043: // varchar
-            default:
-                format = 'string';
-        }
-    }
-    return format;
-}
-export const deepCopy = (obj) => JSON.parse(JSON.stringify(obj));
-export const trimEndS = (s) => (s.endsWith('s') ? s.slice(0, -1) : s);
-const getDateColumnAndPath = (node) => {
-    // "created_at" <= ...
-    if (node.left && node.left.type === 'column_ref') {
-        return { dateColumn: node.left.column, dateColumnPath: 'left.column' };
-    }
-    // LOWER("created_at") <= ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        ['lower', 'upper'].includes(node.left.name.toLowerCase()) &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 1 &&
-        node.left.args.value[0].type === 'double_quote_string') {
-        return {
-            dateColumn: node.left.args.value[0].value,
-            dateColumnPath: 'left.args.value.0.value',
-        };
-    }
-    // LOWER("created_at") <= ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        ['lower', 'upper'].includes(node.left.name.toLowerCase()) &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 1 &&
-        node.left.args.value[0].type === 'column_ref') {
-        return {
-            dateColumn: node.left.args.value[0].column,
-            dateColumnPath: 'left.args.value.0.column',
-        };
-    }
-    // date_trunc('...', "...") = ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        node.left.name.toLowerCase() === 'date_trunc' &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 2 &&
-        node.left.args.value[1].type === 'column_ref') {
-        return {
-            dateColumn: node.left.args.value[1].column,
-            dateColumnPath: 'left.args.value.1.column',
-        };
-    }
-    // date_trunc('...', "...") = ...
-    if (node.left &&
-        node.left.type === 'function' &&
-        node.left.name.toLowerCase() === 'date_trunc' &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 2 &&
-        node.left.args.value[1].type === 'double_quote_string') {
-        return {
-            dateColumn: node.left.args.value[1].value,
-            dateColumnPath: 'left.args.value.1.value',
-        };
-    }
-    // unknown
-    return { dateColumn: null, dateColumnPath: '' };
-};
-const parseIntervalNode = (node) => {
-    if (node.type !== 'interval')
-        return null;
-    if (node.unit && node.unit.length > 0) {
-        return {
-            intervalCount: parseInt(node.expr.value),
-            intervalType: node.unit,
-        };
-    }
-    const parts = node.expr.value.split(' ');
-    return {
-        intervalCount: parts.length > 1 ? parseInt(parts[0]) : 1,
-        intervalType: trimEndS(parts.length > 1 ? parts[1] : 'year'),
-    };
-};
-// Parses the interval and path to the interval (used to change the interval)
-// from a node using one of many pre-defined patterns. Otherwise null.
-const getIntervalAndPath = (node) => {
-    if (node.right && node.right.right && node.right.right.type === 'interval') {
-        const interval = parseIntervalNode(node.right.right);
-        const { intervalCount, intervalType } = interval ?? {};
-        return {
-            intervalCount,
-            intervalType,
-            intervalPaths: ['right.right.expr.value'],
-        };
-    }
-    // date_trunc('...', "...") = date_trunc('...', ...)
-    if (node.left &&
-        node.left.type === 'function' &&
-        node.left.name.toLowerCase() === 'date_trunc' &&
-        node.left.args.type == 'expr_list' &&
-        node.left.args.value.length === 2 &&
-        node.right &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'date_trunc' &&
-        node.right.args.type == 'expr_list' &&
-        node.right.args.value.length === 2) {
-        // date_trunc('day', "created_at") >= date_trunc('day', CURRENT_DATE - INTERVAL '90 days')
-        if (node.right &&
-            node.right.type === 'function' &&
-            node.right.name.toLowerCase() === 'date_trunc' &&
-            node.right.args.type == 'expr_list' &&
-            node.right.args.value.length === 2 &&
-            node.right.args.value[1].type === 'binary_expr' &&
-            node.right.args.value[1].right.type === 'interval') {
-            return parseIntervalNode(node.right.args.value[1].right);
-        }
-        const intervalType = node.right.args.value[0].value;
-        return {
-            intervalCount: null,
-            intervalType: trimEndS(intervalType ?? 'year'),
-            intervalPaths: ['right.args.value.0.value', 'left.args.value.0.value'],
-        };
-    }
-    // "created_at" >= DATE_TRUNC('day', CURRENT_DATE - INTERVAL '90 days')
-    if (node.left &&
-        node.left.type === 'column_ref' &&
-        node.right &&
-        node.right.type === 'function' &&
-        node.right.name.toLowerCase() === 'date_trunc' &&
-        node.right.args.type == 'expr_list' &&
-        node.right.args.value.length === 2 &&
-        node.right.args.value[1].type === 'binary_expr' &&
-        node.right.args.value[1].right &&
-        node.right.args.value[1].right.type === 'interval') {
-        const interval = parseIntervalNode(node.right.node.right.args.value[1].right);
-        const { intervalCount, intervalType } = interval ?? {};
-        return {
-            intervalCount,
-            intervalType,
-            intervalPaths: ['right.args.value.0.value'],
-        };
-    }
-    // unknown
-    return { intervalCount: 1, intervalType: '', intervalPaths: [] };
-};
-const getDateFilterType = (node) => {
-    if (isDateTruncEquals(node))
-        return 'equals';
-    if (node.operator === '>=' &&
-        node.left &&
-        node.left.type === 'column_ref' &&
-        node.right &&
-        node.right.type === 'binary_expr' &&
-        node.right.operator == '-' &&
-        node.right.right &&
-        node.right.right.type == 'interval') {
-        // ... >= ... - INTERVAL '...'
-        return 'in the last';
-    }
-    else if (node.operator === '=' &&
-        node.left?.type === 'function' &&
-        node.left?.name === 'date_trunc' &&
-        node.right?.type === 'function' &&
-        node.right?.name === 'date_trunc' &&
-        node.right.args.type === 'expr_list' &&
-        node.right.args.value.length === 2 &&
-        node.right.args.value[1].type === 'function' &&
-        ['current_date', 'now'].includes(node.right.args.value[1].name.toLowerCase())) {
-        // DATE_TRUNC('...', ...) = DATE_TRUNC('...', ...)
-        return 'in the current';
-    }
-    else {
-        // ... = DATE_TRUNC('...', ... - INTERVAL '...');
-        return 'in the previous';
-    }
-};
-export const getDateFilterInfo = (node) => {
-    const { dateColumn, dateColumnPath } = getDateColumnAndPath(node);
-    const interval = getIntervalAndPath(node);
-    const { intervalCount, intervalType } = interval ?? {};
-    const intervalPaths = interval?.intervalPaths;
-    const dateFilterType = getDateFilterType(node);
-    return {
-        dateColumn,
-        dateColumnPath,
-        dateFilterType,
-        intervalCount,
-        intervalType,
-        intervalPaths,
-    };
-};
-// NEED TO UPDATE FOR MORE POTENTIAL CASES
-function getNodeTable(node) {
-    if (node.table) {
-        return node.table;
-    }
-    if (node.args && node.args.value?.[0]?.table) {
-        return node.args.value[0].table;
-    }
-    return null;
-}
-// Recursively remove filters that don't apply to the given table
-function removeNonSelectedTableFilters(node, table, columns, uniqueValues) {
-    if (!node) {
-        return null;
-    }
-    if (node.left && node.left.type !== 'binary_expr') {
-        const referencedTable = getNodeTable(node.left);
-        const referencedColumn = getFieldFromExpression(node.left);
-        if (!referencedColumn) {
-            return null;
-        }
-        if (uniqueValues &&
-            (node.operator === 'IN' ||
-                (node.operator === 'NOT IN' &&
-                    node.right?.type === 'expr_list' &&
-                    node.right.value))) {
-            node.right.value = node.right.value.filter((value) => {
-                const field = getFieldFromExpression(value);
-                const check = field &&
-                    uniqueValues[referencedColumn] &&
-                    uniqueValues[referencedColumn].includes(field);
-                return check;
-            });
-            if (!node.right.value || !node.right.value.length) {
-                return null;
-            }
-        }
-        if ((referencedTable && referencedTable !== table) ||
-            !columns.includes(referencedColumn)) {
-            return null;
-        }
-        else {
-            if (node.left.value) {
-                node.left.column = node.left.value;
-            }
-            else if (node.left.args?.value?.[0]?.value) {
-                node.left.args.value[0].column = node.left.args.value[0].value;
-            }
-            return node;
-        }
-    }
-    node.left = removeNonSelectedTableFilters(node.left, table, columns, uniqueValues);
-    node.right = removeNonSelectedTableFilters(node.right, table, columns, uniqueValues);
-    if (node.left && node.right) {
-        return node;
-    }
-    else if (node.left) {
-        return node.left;
-    }
-    else if (node.right) {
-        return node.right;
-    }
-    else {
-        return null;
-    }
-}
-function removeNonSelectedTableOrderBys(orderby, table, columns) {
-    if (!orderby || !orderby.length) {
-        return null;
-    }
-    return orderby
-        .filter((node) => node.expr &&
-        node.expr.table === table &&
-        columns.includes(node.expr.column))
-        .map((node) => {
-        return { ...node, expr: { ...node.expr, table: null } };
-    });
-}
-export function removeNonSelectedTableReferences(ast, table, columns, uniqueValues) {
-    ast.columns = ast.columns.filter((col) => {
-        return col.table === table || col.expr.table === table || !col.expr.table;
-    });
-    if (!ast.where)
-        return ast;
-    ast.where = removeNonSelectedTableFilters(ast.where, table, columns, uniqueValues);
-    ast.orderby = removeNonSelectedTableOrderBys(ast.orderby, table, columns);
-    return ast;
-}
-function recursiveRemoveTableReference(node, table, as) {
-    if (!node || typeof node !== 'object') {
-        return node;
-    }
-    if (node.length) {
-        return node.map((n) => recursiveRemoveTableReference(n, table, as));
-    }
-    if (node.table && node.as && node.table === table && node.as === as) {
-        node.as = null;
-    }
-    else if (node.table && node.table === as) {
-        node.table = table;
-    }
-    Object.keys(node).forEach((key) => {
-        if (typeof node[key] === 'object') {
-            node[key] = recursiveRemoveTableReference(node[key], table, as);
-        }
-    });
-    return node;
-}
-export function removeTableNameAlias(ast, schema) {
-    if (!ast.from?.length || !ast.from) {
-        return ast;
-    }
-    const referencedTables = deepCopy(ast.from);
-    // In the context of where this function is used, (ReportBuilder AI)
-    // ast.from should only contain one table (if not, it would have triggered a retry)
-    referencedTables.forEach((from) => {
-        let table = from.table;
-        if (!schema.find((s) => s.name === table)) {
-            // if the table isn't actually there, replace with a table that fits columns
-            const referencedColumns = ast.columns.map((col) => getFieldFromExpression(col.expr) || getFieldFromExpression(col));
-            const schemaTable = schema.find((s) => {
-                return referencedColumns.every((col) => s.columns.find((c) => c.field === col));
-            });
-            if (schemaTable) {
-                ast = recursiveRemoveTableReference(ast, schemaTable.name, table);
-                table = schemaTable.name;
-            }
-        }
-        const as = from.as;
-        if (as) {
-            ast = recursiveRemoveTableReference(ast, table, as);
-        }
-    });
-    return ast;
-}
-export function allNumericNodesValidInTree(node) {
-    if (!node)
-        return true;
-    if (node.type === 'number') {
-        const value = parseFloat(node.value);
-        if (Number.isNaN(value)) {
-            return false;
-        }
-        else {
-            node.value = value;
-            return true;
-        }
-    }
-    const isLeftValid = allNumericNodesValidInTree(node.left);
-    const isRightValid = allNumericNodesValidInTree(node.right);
-    return isLeftValid && isRightValid;
-}
-export function isIdColumn(columnName) {
-    return (columnName &&
-        (columnName.toLowerCase() === 'id' ||
-            columnName.toLowerCase().endsWith('_id') ||
-            columnName.endsWith('Id')));
-}
-// This function determines if a node is a custom node type.
-// This will parse out date filters and some numeric filters that are unique (between).
-export function getCustomSentence(node, databaseType) {
-    if (isTheCurrentInterval(node, databaseType)) {
-        return getInTheCurrentIntervalSentence(node, databaseType);
-    }
-    else if (isInTheLastInterval(node, databaseType)) {
-        return getInTheLastIntervalSentence(node, databaseType);
-    }
-    else if (isAfter(node, databaseType)) {
-        return getIsAfterSentence(node, databaseType);
-    }
-    else if (isBefore(node, databaseType)) {
-        return getIsBeforeSentence(node, databaseType);
-    }
-    else if (isThePreviousInterval(node)) {
-        return getInThePreviousIntervalSentence(node, databaseType);
-    }
-    else if (isEquals(node, databaseType)) {
-        return getIsEqualsSentence(node, databaseType);
-    }
-    return null;
-}