@quillsql/react 2.15.3 → 2.15.4

package/dist/cjs/utils/queryConstructor.js

@@ -1,949 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processSingleQuotes = processSingleQuotes;
-exports.processAggType = processAggType;
-exports.processColumnReference = processColumnReference;
-exports.replaceSpacesWithUnderscores = replaceSpacesWithUnderscores;
-exports.processDateTrunc = processDateTrunc;
-exports.processValueField = processValueField;
-exports.generateCountQuery = generateCountQuery;
-exports.generateDistinctQuery = generateDistinctQuery;
-exports.generateMinMaxDateRangeQueries = generateMinMaxDateRangeQueries;
-exports.generatePivotQuery = generatePivotQuery;
-exports.additionalProcessingOnPivotQuery = additionalProcessingOnPivotQuery;
-exports.generateRowCountQuery = generateRowCountQuery;
-const columnType_1 = require("./columnType");
-const constants_1 = require("./constants");
-const pivotProcessing_1 = require("./pivotProcessing");
-const textProcessing_1 = require("./textProcessing");
-function processSingleQuotes(value, databaseType) {
-    if (['postgresql', 'snowflake', 'clickhouse'].includes(databaseType.toLowerCase())) {
-        return value.replaceAll("'", "''");
-    }
-    return value.replaceAll("'", "\\'");
-}
-function processAggType(aggType, hasColumnField = false) {
-    if (aggType === 'count' && hasColumnField)
-        return 'SUM';
-    return aggType?.toLowerCase() === 'average' ? 'AVG' : aggType?.toLowerCase();
-}
-function replaceBigQuerySpecialCharacters(column) {
-    return column.replaceAll('/', 'quill_forward_slash');
-}
-function processColumnReference(column, databaseType, fallbackOnNull, 
-// for mysql, we only want to use double quotes for pivot column field aliases
-isColumnFieldAlias, isValueFieldAlias) {
-    switch (databaseType.toLowerCase()) {
-        case 'postgresql':
-        case 'clickhouse': {
-            if (column === '') {
-                return fallbackOnNull ? `"${fallbackOnNull}"` : `"_"`;
-            }
-            if (isColumnFieldAlias) {
-                return `"${column.replaceAll('"', '')}"`;
-            }
-            const columnParts = column.split('.');
-            if (columnParts.length > 1) {
-                return (`"` +
-                    columnParts.map((part) => part.replaceAll('"', '')).join('"."') +
-                    `"`);
-            }
-            return `"${column.replaceAll('"', '')}"`;
-        }
-        case 'mysql': {
-            if (column === '') {
-                return fallbackOnNull ? `${fallbackOnNull}` : '_';
-            }
-            if (isColumnFieldAlias) {
-                return `\`${column.replaceAll(`\``, '').replaceAll(`"`, '')}\``;
-            }
-            const columnParts = column.split('.');
-            if (columnParts.length > 1) {
-                return (`\`` +
-                    columnParts.map((part) => part.replaceAll(`\``, '')).join('`.`') +
-                    `\``);
-            }
-            // Wrap MySQL columns in backticks to handle whitespace
-            return `\`${column.replaceAll(`\``, '')}\``;
-        }
-        case 'snowflake': {
-            if (column === '') {
-                return fallbackOnNull ? `${fallbackOnNull}` : '_';
-            }
-            if (isColumnFieldAlias) {
-                return `"${column.replaceAll('"', '')}"`;
-            }
-            if (isValueFieldAlias) {
-                const cleanedColumn = column.replaceAll(')', '').replaceAll('(', '_');
-                return `${cleanedColumn}`;
-            }
-            // const columnParts = column.split('.');
-            // if (columnParts.length > 1) {
-            //   return '"' + columnParts.join('"."') + '"';
-            // }
-            return column;
-        }
-        case 'bigquery': {
-            if (column === '') {
-                return fallbackOnNull ? `\`${fallbackOnNull}\`` : '`_`';
-            }
-            if (isColumnFieldAlias) {
-                return `\`${replaceBigQuerySpecialCharacters(column.replaceAll('`', ''))}\``;
-            }
-            const columnParts = column.split('.');
-            if (columnParts.length > 1) {
-                return (`\`` +
-                    columnParts.map((part) => part.replaceAll(`\``, '')).join('`.`') +
-                    `\``);
-            }
-            return `\`${replaceBigQuerySpecialCharacters(column.replaceAll('`', ''))}\``;
-        }
-        case 'mssql': {
-            if (column === '') {
-                return fallbackOnNull ? `[${fallbackOnNull}]` : `[_]`;
-            }
-            if (isColumnFieldAlias) {
-                return `[${column.replaceAll(']', '').replaceAll('[', '')}]`;
-            }
-            const columnParts = column.split('.');
-            if (columnParts.length > 1) {
-                return (`[` +
-                    columnParts
-                        .map((part) => part.replaceAll(']', '').replaceAll('[', ''))
-                        .join('].[`') +
-                    `]`);
-            }
-            return `[${column.replaceAll(']', '').replaceAll('[', '')}]`;
-        }
-        case 'databricks': {
-            if (column === '') {
-                return fallbackOnNull ? `[${fallbackOnNull}]` : `_`;
-            }
-            if (isColumnFieldAlias) {
-                return `\`${column.replaceAll(`\``, '').replaceAll(`"`, '')}\``;
-            }
-            const columnParts = column.split('.');
-            if (columnParts.length > 1) {
-                return (`\`` +
-                    columnParts.map((part) => part.replaceAll(`\``, '')).join('`.`') +
-                    `\``);
-            }
-            // Wrap MySQL columns in backticks to handle whitespace
-            return `\`${column.replaceAll(`\``, '')}\``;
-        }
-        default:
-            return column;
-    }
-}
-function replaceSpacesWithUnderscores(column) {
-    return column.replaceAll(' ', '_');
-}
-function processInterval(interval, rowField, databaseType) {
-    if (['postgresql', 'snowflake', 'clickhouse'].includes(databaseType.toLowerCase())) {
-        return `(${processColumnReference(rowField, databaseType)} + INTERVAL '${interval}')`;
-    }
-    else if (databaseType.toLowerCase() === 'mysql') {
-        return `(${processColumnReference(rowField, databaseType)} + INTERVAL ${interval})`;
-    }
-    return `TIMESTAMP_ADD(${processColumnReference(rowField, databaseType)}, INTERVAL ${interval} )`;
-}
-function processDateTrunc(dateBucket, rowField, databaseType, comparisonInterval) {
-    const dateField = comparisonInterval
-        ? processInterval(comparisonInterval, rowField, databaseType)
-        : processColumnReference(rowField, databaseType);
-    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
-        return `date_trunc('${dateBucket}', ${dateField})`;
-    }
-    if (['clickhouse'].includes(databaseType.toLowerCase())) {
-        return `dateTrunc('${dateBucket}', ${dateField})`;
-    }
-    if (['databricks'].includes(databaseType.toLowerCase())) {
-        return `DATE_TRUNC('${dateBucket}', ${dateField})`;
-    }
-    if (['mysql'].includes(databaseType.toLowerCase())) {
-        switch (dateBucket.toLowerCase()) {
-            case 'year':
-                return `DATE_FORMAT(${dateField}, '%Y-01-01 00:00:00')`;
-            case 'month':
-                return `DATE_FORMAT(${dateField}, '%Y-%m-01 00:00:00')`;
-            case 'week':
-                return `DATE_FORMAT(${dateField}, '%Y-%U-1 00:00:00')`;
-            case 'day':
-            default:
-                return `DATE(${dateField})`;
-        }
-    }
-    if (['mssql'].includes(databaseType.toLowerCase())) {
-        // note DATETRUNC is for mssql >= 2022
-        return `DATETRUNC(${dateBucket}, ${dateField})`;
-        // return `FORMAT(${dateField}, '${mssqlDateBucketFormat(dateBucket)}')`;
-    }
-    return `TIMESTAMP_TRUNC(${dateField}, ${dateBucket})`;
-}
-function processValueField(aggType, databaseType, valueField) {
-    if (aggType === 'min' ||
-        aggType === 'max' ||
-        aggType?.toLowerCase() === 'average')
-        return `${processColumnReference(valueField, databaseType)} ELSE null`;
-    if (aggType === 'count')
-        return `1 ELSE 0`;
-    return valueField
-        ? `${processColumnReference(valueField, databaseType)} ELSE 0`
-        : `1 ELSE 0`;
-}
-function generateCountQuery(fields, query, databaseType) {
-    let countQuery = [];
-    let cteQuery = `WITH querytable AS (${query.replace(';', '')}) `;
-    let cte = [];
-    switch (databaseType.toLowerCase()) {
-        case 'mysql':
-            cte = fields.map((field, index) => {
-                return `, distinct_cte_${index} AS (SELECT DISTINCT ${processColumnReference(field, databaseType, undefined, true)} FROM querytable LIMIT ${constants_1.MAX_PIVOT_UNIQUE_VALUES + 1})`;
-            });
-            countQuery = fields.map((field, index) => {
-                return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, COUNT(*) AS ${processColumnReference('count', databaseType)} FROM distinct_cte_${index}`;
-            });
-            cteQuery += cte.join(' ');
-            break;
-        default:
-            countQuery = fields.map((field) => {
-                return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, COUNT(DISTINCT ${processColumnReference(field, databaseType, undefined, true)}) AS ${processColumnReference('count', databaseType)} FROM querytable`;
-            });
-    }
-    return cteQuery + countQuery.join(' UNION ALL ');
-}
-function generateDistinctQuery(stringFields, query, databaseType) {
-    switch (databaseType.toLowerCase()) {
-        case 'mysql':
-            return generateDistinctQueryMySQL(stringFields, query);
-        case 'bigquery':
-            return generateDistinctQueryBigQuery(stringFields, query);
-        case 'postgresql':
-            return generateDistinctQueryPostgres(stringFields, query);
-        case 'snowflake':
-            return generateDistinctQuerySnowflake(stringFields, query);
-        case 'mssql':
-            return generateDistinctQueryMSSQL(stringFields, query);
-        case 'databricks':
-            return generateDistinctQueryDatabricks(stringFields, query);
-        case 'clickhouse': // works with default for now
-        default:
-            return generateDistinctQueryDefault(stringFields, query, databaseType);
-    }
-}
-function generateDistinctQueryDefault(stringFields, query, databaseType) {
-    const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, ARRAY_AGG(DISTINCT ${field}) AS ${processColumnReference('string_values', databaseType)} FROM querytable`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-function generateDistinctQueryMySQL(stringFields, query) {
-    const distinctQueries = stringFields.map((field) => {
-        return `
-      SELECT '${field}' AS ${processColumnReference('field', 'mysql')}, 
-             JSON_ARRAYAGG(\`${field}\`) AS ${processColumnReference('string_values', 'mysql')}
-      FROM (SELECT DISTINCT \`${field}\` FROM querytable) AS distinct_${replaceSpacesWithUnderscores(field)}`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-function generateDistinctQueryBigQuery(stringFields, query) {
-    const distinctQueries = stringFields.map((field) => {
-        return `
-      SELECT '${field}' AS ${processColumnReference('field', 'bigquery')}, 
-             ARRAY_AGG(\`${field}\`) AS ${processColumnReference('string_values', 'bigquery')}
-      FROM (SELECT \`${field}\` FROM querytable WHERE \`${field}\` IS NOT NULL GROUP BY \`${field}\`) AS distinct_${replaceSpacesWithUnderscores(field)}`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-function generateDistinctQueryPostgres(stringFields, query) {
-    const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS ${processColumnReference('field', 'postgresql')}, to_json(ARRAY_AGG(DISTINCT "${field}")) AS ${processColumnReference('string_values', 'postgresql')} FROM querytable`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-function generateDistinctQuerySnowflake(stringFields, query) {
-    const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS "field", ARRAY_AGG(DISTINCT "${field}") AS "string_values" FROM querytable`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-// Not the ideal way to do things, but node-sql-parser doesn't support
-// DISTINCT or JSON PATH for transactsql at the moment
-// Note, this does not return an array like the other functions, so we need to keep that in mind
-// for mssql distinct values when we attempt to parse them
-function generateDistinctQueryMSSQL(stringFields, query) {
-    const escapeFieldName = (field) => field.replace(/'/g, "''");
-    const distinctQueries = stringFields.map((field) => {
-        return `
-      SELECT 
-        '${escapeFieldName(field)}' AS field,
-        STRING_AGG(${field}, ',') AS string_values
-      FROM (
-        SELECT ${field}
-        FROM querytable
-        WHERE ${field} IS NOT NULL
-        GROUP BY ${field}
-      ) AS grouped
-      `
-            .replace(/\s+/g, ' ')
-            .trim();
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `
-    WITH querytable AS (
-      ${query.replace(';', '')}
-    )
-    ${distinctQuery}`
-        .replace(/\s+/g, ' ')
-        .trim();
-}
-function generateDistinctQueryDatabricks(stringFields, query) {
-    const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS ${processColumnReference('field', 'databricks')}, collect_set(\`${field}\`) AS ${processColumnReference('string_values', 'databricks')} FROM querytable`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-function generateMinMaxDateRangeQueries(columnFields, query, databaseType) {
-    const max = 'MAX';
-    const min = 'MIN';
-    const cast = databaseType.toLowerCase() === 'snowflake' ? '::TIMESTAMP_TZ' : '';
-    const distinctQueries = columnFields.map((field) => {
-        const wrappedField = ['postgresql', 'clickhouse'].includes(databaseType.toLowerCase())
-            ? `"${field}"`
-            : field;
-        return `SELECT '${field}' AS field, ${min}(${wrappedField})${cast} AS min_range, ${max}(${wrappedField})${cast} AS max_range FROM querytable`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-function generatePivotQuery(pivot, itemQuery, databaseType, distinctStrings, dateBucket) {
-    if (!(0, pivotProcessing_1.isValidPivot)(pivot).valid) {
-        return undefined;
-    }
-    if (pivot.columnField && distinctStrings && distinctStrings.length > 0) {
-        return create2DPivotQuery(pivot, itemQuery, databaseType, distinctStrings, dateBucket);
-    }
-    if (pivot.rowField) {
-        return create1DPivotQuery(pivot, itemQuery, dateBucket, databaseType);
-    }
-    return createAggregationValuePivot(pivot, itemQuery, databaseType);
-}
-function create2DPivotQuery(pivot, itemQuery, databaseType, columnFieldValues, dateBucket) {
-    if (!pivot || !pivot.columnField) {
-        return undefined;
-    }
-    if ((0, columnType_1.isStringType)(pivot.rowFieldType ?? '') || !pivot.rowFieldType) {
-        return create2DStringPivotQuery(pivot, itemQuery, columnFieldValues, databaseType);
-    }
-    return create2DDatePivotQuery(pivot, itemQuery, columnFieldValues, databaseType, dateBucket);
-}
-function create2DStringPivotQuery(pivot, itemQuery, columnFieldValues, databaseType) {
-    const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField)
-        return undefined;
-    const rowField = pivot.rowField;
-    if (!pivot.aggregations?.[0]?.valueField &&
-        pivot.aggregations?.[0]?.aggregationType !== 'count' &&
-        !pivot.valueField &&
-        pivot.aggregationType !== 'count')
-        throw new Error('No value field provided for pivot');
-    if (!pivot.aggregations?.[0]?.aggregationType && !pivot.aggregationType)
-        throw new Error('No aggregation type provided for pivot');
-    const columnField = pivot.columnField;
-    const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
-    const columnFieldAlias = processColumnReference(columnField, databaseType, undefined, false, true);
-    let caseWhens = [];
-    let valueAliases = [];
-    const seenAggs = {};
-    pivot.aggregations?.forEach((currentAgg) => {
-        // Track duplicate aggregation combos for disambiguation.
-        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
-            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
-        }
-        else {
-            seenAggs[currentAgg.aggregationType ?? ''] = {
-                ...seenAggs[currentAgg.aggregationType ?? ''],
-                [currentAgg.valueField ?? '']: 1,
-            };
-        }
-        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString();
-        if (disambiguationIndex === '1')
-            disambiguationIndex = '';
-        const valueFieldAlias = processColumnReference(currentAgg.valueField || rowField || 'count', databaseType, undefined, false, true);
-        const valueAliasSubstring = currentAgg.valueField
-            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
-            : '';
-        let value2AliasSubstring = '';
-        const disambiguationField = Object.values(seenAggs[currentAgg.aggregationType ?? ''] ?? {}).reduce((acc, v) => acc + v) > 1
-            ? `_${currentAgg.valueField}${disambiguationIndex}`
-            : '';
-        const disambiguation = pivot.aggregations?.length > 1
-            ? `${disambiguationField}_${disambiguationField ? (0, textProcessing_1.matchCasing)(currentAgg.aggregationType, currentAgg.valueField) : currentAgg.aggregationType}`
-            : '';
-        // Wrap the value field in CASE WHEN if its type is bool.
-        const valueExpr = currentAgg.valueFieldType === 'bool'
-            ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`
-            : processValueField(currentAgg.aggregationType, databaseType, valueFieldAlias);
-        if (currentAgg.aggregationType === 'percentage') {
-            if (!currentAgg.valueField)
-                throw new Error('No value field provided for pivot');
-            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
-            // Wrap the second value field if its type is bool.
-            const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool'
-                ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`
-                : valueField2Alias;
-            if (currentAgg.valueField === currentAgg.valueField2 ||
-                !currentAgg.valueField2) {
-                caseWhens = [
-                    ...caseWhens,
-                    ...columnFieldValues.map((column) => {
-                        return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(${value2Expr}), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
-                    }),
-                ];
-            }
-            else {
-                value2AliasSubstring = `${processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, true)} AS ${valueField2Alias}`;
-                caseWhens = [
-                    ...caseWhens,
-                    ...columnFieldValues.map((column) => {
-                        return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${value2Expr} END), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
-                    }),
-                ];
-            }
-        }
-        else {
-            caseWhens = [
-                ...caseWhens,
-                ...columnFieldValues.map((column) => {
-                    return `${processAggType(currentAgg.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
-                }),
-            ];
-        }
-        if (valueAliasSubstring)
-            valueAliases.push(valueAliasSubstring);
-        if (value2AliasSubstring)
-            valueAliases.push(value2AliasSubstring);
-    });
-    valueAliases = [
-        `${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}`,
-        ...valueAliases,
-        `${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias}`,
-    ];
-    valueAliases = Array.from(new Set(valueAliases));
-    const sortQuery = pivot.sort && pivot.sortField && pivot.rowLimit
-        ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, undefined, true)} ${pivot.sortDirection || ''} `
-        : '';
-    const pivotQuery = `
-    ,quill_alias AS (
-      SELECT ${valueAliases.length > 0 ? `${valueAliases.join(', ')}` : ''}
-      FROM quill_base_table
-    ),
-    quill_qt_cw AS (
-      SELECT ${rowFieldAlias}
-      ${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''}
-      FROM quill_alias
-      GROUP BY ${rowFieldAlias}
-    ),
-    quill_base_pivot AS (
-      SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} *
-      FROM quill_qt_cw qt
-      ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''}
-    )
-    SELECT * FROM quill_base_pivot
-  `
-        .replace(/\s+/g, ' ')
-        .trim();
-    return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
-}
-function create2DDatePivotQuery(pivot, itemQuery, columnFieldValues, databaseType, dateBucket = 'month') {
-    const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField) {
-        return undefined;
-    }
-    if (!pivot.aggregations?.[0]?.valueField &&
-        pivot.aggregations?.[0]?.aggregationType !== 'count' &&
-        !pivot.valueField &&
-        pivot.aggregationType !== 'count')
-        throw new Error('No value field provided for pivot');
-    if (!pivot.aggregations?.[0]?.aggregationType && !pivot.aggregationType)
-        throw new Error('No aggregation type provided for pivot');
-    // const aggregationType = (pivot.aggregations?.[0]?.aggregationType ?? pivot.aggregationType) as any;
-    const rowField = pivot.rowField;
-    const columnField = pivot.columnField;
-    const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
-    const columnFieldAlias = processColumnReference(columnField, databaseType, undefined, false, true);
-    let caseWhens = [];
-    let valueFieldAliases = [];
-    const seenAggs = {};
-    pivot.aggregations?.forEach((currentAgg) => {
-        // if the aggregation combo has been seen before, increment the count, else add it to the seenAggs array
-        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
-            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
-        }
-        else {
-            seenAggs[currentAgg.aggregationType ?? ''] = {
-                ...seenAggs[currentAgg.aggregationType ?? ''],
-                [currentAgg.valueField ?? '']: 1,
-            };
-        }
-        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString();
-        if (disambiguationIndex === '1')
-            disambiguationIndex = '';
-        const valueFieldAlias = processColumnReference(currentAgg.valueField ?? rowField, databaseType, undefined, false, true);
-        const valueAliasSubstring = currentAgg.valueField
-            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
-            : '';
-        let value2AliasSubstring = '';
-        const disambiguationField = Object.values(seenAggs[currentAgg.aggregationType ?? ''] ?? {}).reduce((acc, v) => acc + v) > 1
-            ? `_${currentAgg.valueField}${disambiguationIndex}`
-            : '';
-        const disambiguation = pivot.aggregations?.length > 1
-            ? `${disambiguationField}_${disambiguationField ? (0, textProcessing_1.matchCasing)(currentAgg.aggregationType, currentAgg.valueField) : currentAgg.aggregationType}`
-            : '';
-        // Wrap the value field in CASE WHEN if its type is bool.
-        const valueExpr = currentAgg.valueFieldType === 'bool'
-            ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`
-            : processValueField(currentAgg.aggregationType, databaseType, valueFieldAlias);
-        if (currentAgg.aggregationType === 'percentage') {
-            if (!currentAgg.valueField)
-                throw new Error('No value field provided for pivot');
-            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
-            // Wrap the second value field if its type is bool.
-            const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool'
-                ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`
-                : valueField2Alias;
-            // edge case. if the user picks amount and amount, we assume they want a pie chart like breakdown of amount. so the summation of valueField2 has to be moved outside of the case whe
-            if (currentAgg.valueField === currentAgg.valueField2 ||
-                !currentAgg.valueField2) {
-                caseWhens = [
-                    ...caseWhens,
-                    ...columnFieldValues.map((column) => {
-                        return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(${value2Expr}), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
-                    }),
-                ];
-            }
-            else {
-                value2AliasSubstring = `${processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, true)} AS ${valueField2Alias}`;
-                caseWhens = [
-                    ...caseWhens,
-                    ...columnFieldValues.map((column) => {
-                        return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${value2Expr} END), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
-                    }),
-                ];
-            }
-        }
-        else {
-            caseWhens = [
-                ...caseWhens,
-                ...columnFieldValues.map((column) => {
-                    return `${processAggType(currentAgg.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
-                }),
-            ];
-        }
-        if (valueAliasSubstring)
-            valueFieldAliases.push(valueAliasSubstring);
-        if (value2AliasSubstring)
-            valueFieldAliases.push(value2AliasSubstring);
-    });
-    valueFieldAliases = [
-        `${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}`,
-        ...valueFieldAliases,
-        `${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias}`,
-    ];
-    valueFieldAliases = Array.from(new Set(valueFieldAliases));
-    // pivot sort matters in the base query when there is a rowLimit. In mssql, an orderby must be accompanied by a limit in a subquery and not allowed in a cte
-    const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, undefined, true)} ${pivot.sortDirection || ''} ` : ''}`;
-    const pivotQuery = `
-    , quill_alias AS (SELECT ${valueFieldAliases.length > 0 ? `${valueFieldAliases.join(', ')}` : ''} FROM quill_base_table),
-    quill_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${rowFieldAlias}${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''} FROM quill_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)}),
-    quill_base_pivot AS (SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} * FROM quill_qt_agg qt
-    ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''})
-    SELECT * FROM quill_base_pivot
-    `
-        .replace(/\s+/g, ' ')
-        .trim();
-    return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
-}
-function create1DPivotQuery(pivot, itemQuery, dateBucket = 'month', databaseType) {
-    if ((0, columnType_1.isStringType)(pivot.rowFieldType || '') || !pivot.rowFieldType) {
-        return create1DStringPivotQuery(pivot, itemQuery, databaseType);
-    }
-    return create1DDatePivotQuery(pivot, itemQuery, dateBucket, databaseType);
-}
-// we have an item query that is guaranteed to end in SELECT * FROM [quill_base_table]
-// also, stop fetching the comparison rows in the same query, since we're no longer wrapping everything in
-// their own with statements and withs with the same name will conflict
-function create1DStringPivotQuery(pivot, itemQuery, databaseType) {
-    const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery)
-        return undefined;
-    const rowField = pivot.rowField;
-    const rowAlias = processColumnReference(rowField, databaseType, undefined, true);
-    let quillAggSelects = [rowAlias];
-    let valueFieldAliases = [];
-    const seenAggs = {};
-    pivot.aggregations?.forEach((currentAgg) => {
-        if (!currentAgg.valueField)
-            currentAgg.valueField = undefined;
-        // Track duplicates to disambiguate names
-        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
-            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
-        }
-        else {
-            seenAggs[currentAgg.aggregationType ?? ''] = {
-                ...seenAggs[currentAgg.aggregationType ?? ''],
-                [currentAgg.valueField ?? '']: 1,
-            };
-        }
-        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString() ?? '';
-        if (disambiguationIndex === '1')
-            disambiguationIndex = '';
-        // This is the alias (from quill_alias CTE) for the field
-        const valueFieldAlias = processColumnReference(currentAgg.valueField || rowField || 'count', databaseType, undefined, false, true);
-        // In the base query, we select the raw column.
-        const valueAliasSubstring = currentAgg.valueField
-            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
-            : '';
-        let value2AliasSubstring = '';
-        const disambiguation = pivot.aggregations?.length > 1
-            ? `${disambiguationIndex}` +
-                (currentAgg.aggregationType !== 'count'
-                    ? `_${currentAgg.aggregationType}`
-                    : '')
-            : '';
-        // Wrap the field in a CASE WHEN if it's boolean
-        let valueExpr = !currentAgg.valueField ? '*' : valueFieldAlias;
-        if (currentAgg.valueFieldType === 'bool') {
-            valueExpr = `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`;
-        }
-        if (currentAgg.aggregationType === 'percentage') {
-            let countPercentage = false;
-            if (!currentAgg.valueField) {
-                countPercentage = true;
-                // throw new Error('No value field provided for percentage aggregation');
-            }
-            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField ?? 'count', databaseType, undefined, false, true);
-            let value2Expr = valueField2Alias;
-            if ((currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool') {
-                value2Expr = `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`;
-            }
-            value2AliasSubstring =
-                currentAgg.valueField2 &&
-                    currentAgg.valueField !== currentAgg.valueField2
-                    ? `${processColumnReference(currentAgg.valueField2, databaseType, undefined, true)} AS ${valueField2Alias}`
-                    : '';
-            const percentageExpr = countPercentage
-                ? 'CAST(COUNT(*) AS FLOAT) / (SELECT COUNT(*) FROM quill_base_table)'
-                : currentAgg.valueField === currentAgg.valueField2 ||
-                    !currentAgg.valueField2
-                    ? `CAST(sum(${valueExpr}) AS FLOAT) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool' ? 'COUNT(*)' : 'SUM(sum(' + valueExpr + ')) OVER ()'}`
-                    : `CAST(sum(${valueExpr}) AS FLOAT) / GREATEST(sum(${value2Expr}), 1)`;
-            quillAggSelects = [
-                ...quillAggSelects,
-                `${percentageExpr} as ${processColumnReference(`${currentAgg.valueField ?? (disambiguation ? 'count' : 'percentage')}${disambiguation}`, databaseType, undefined, false, true)}`,
-            ];
-        }
-        else {
-            quillAggSelects = [
-                ...quillAggSelects,
-                `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || 'count') + disambiguation, databaseType)}`,
-            ];
-        }
-        if (valueAliasSubstring)
-            valueFieldAliases.push(valueAliasSubstring);
-        if (value2AliasSubstring)
-            valueFieldAliases.push(value2AliasSubstring);
-    });
-    valueFieldAliases = Array.from(new Set(valueFieldAliases));
-    const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit
-        ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, undefined, true)} ${pivot.sortDirection || ''} `
-        : ''}`;
-    const pivotQuery = `, quill_alias AS (
-       SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowAlias}${valueFieldAliases.length > 0 ? `, ${valueFieldAliases.join(', ')}` : ''}
-       FROM quill_base_table
-     ),
-     quill_qt_cw AS (
-       SELECT ${quillAggSelects.join(', ')} FROM quill_alias GROUP BY ${rowAlias}
-     ),
-     quill_base_pivot AS (
-       SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} *
-       FROM quill_qt_cw qt ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''}
-     )
-     SELECT * FROM quill_base_pivot`
-        .replace(/\s+/g, ' ')
-        .trim();
-    return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
-}
-function create1DDatePivotQuery(pivot, itemQuery, dateBucket = 'month', databaseType) {
-    const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery) {
-        return undefined;
-    }
-    const rowField = pivot.rowField || '';
-    const rowFieldAlias = processColumnReference(rowField, databaseType, undefined);
-    let quillAggSelects = [
-        `${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(rowField, databaseType)}`,
-    ];
-    let valueFieldAliases = [];
-    const seenAggs = {};
-    pivot.aggregations?.forEach((currentAgg) => {
-        if (!currentAgg.valueField)
-            currentAgg.valueField = undefined;
-        // if the aggregation combo has been seen before, increment the count, else add it to the seenAggs array
-        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
-            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
-        }
-        else {
-            seenAggs[currentAgg.aggregationType ?? ''] = {
-                ...seenAggs[currentAgg.aggregationType ?? ''],
-                [currentAgg.valueField ?? '']: 1,
-            };
-        }
-        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString() ?? '';
-        if (disambiguationIndex === '1')
-            disambiguationIndex = '';
-        const valueFieldAlias = processColumnReference(currentAgg.valueField || rowField || 'count', databaseType, undefined, false, true);
-        const valueAliasSubstring = currentAgg.valueField
-            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
-            : '';
-        let value2AliasSubstring = '';
-        const disambiguation = pivot.aggregations?.length > 1
-            ? `${disambiguationIndex}` +
-                (currentAgg.aggregationType !== 'count'
-                    ? `_${currentAgg.aggregationType}`
-                    : '')
-            : '';
-        // Wrap the field in a CASE WHEN if it's boolean
-        let valueExpr = !currentAgg.valueField ? '*' : valueFieldAlias;
-        if (currentAgg.valueFieldType === 'bool') {
-            valueExpr = `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`;
-        }
-        if (currentAgg.aggregationType === 'percentage') {
-            let countPercentage = false;
-            if (!currentAgg.valueField) {
-                countPercentage = true;
-                // throw new Error('No value field provided for percentage aggregation');
-            }
-            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField ?? 'count', databaseType, undefined, false, true);
-            value2AliasSubstring =
-                currentAgg.valueField2 &&
-                    currentAgg.valueField !== currentAgg.valueField2
-                    ? `${processColumnReference(currentAgg.valueField2, databaseType, undefined, true)} AS ${valueField2Alias}`
-                    : '';
-            let value2Expr = valueField2Alias;
-            if ((currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool') {
-                value2Expr = `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`;
-            }
-            const percentageExpr = countPercentage
-                ? 'CAST(COUNT(*) AS FLOAT) / (SELECT COUNT(*) FROM quill_base_table)'
-                : currentAgg.valueField === currentAgg.valueField2 ||
-                    !currentAgg.valueField2
-                    ? `CAST(sum(${valueExpr}) AS FLOAT) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool' ? 'COUNT(*)' : 'SUM(sum(' + valueExpr + ')) OVER ()'}`
-                    : `CAST(sum(${valueExpr}) AS FLOAT) / GREATEST(sum(${value2Expr}), 1)`;
-            quillAggSelects = [
-                ...quillAggSelects,
-                `${percentageExpr} as ${processColumnReference(`${currentAgg.valueField ?? (disambiguation ? 'count' : 'percentage')}${disambiguation}`, databaseType, undefined, false, true)}`,
-            ];
-        }
-        else {
-            quillAggSelects = [
-                ...quillAggSelects,
-                `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || 'count') + disambiguation, databaseType)}`,
-            ];
-        }
-        if (valueAliasSubstring)
-            valueFieldAliases.push(valueAliasSubstring);
-        if (value2AliasSubstring)
-            valueFieldAliases.push(value2AliasSubstring);
-    });
-    valueFieldAliases = Array.from(new Set(valueFieldAliases));
-    // pivot sort matters in the base query when there is a rowLimit. In mssql, an orderby must be accompanied by a limit in a subquery and not allowed in a cte
-    const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, undefined, true)} ${pivot.sortDirection || ''} ` : ''}`;
-    const pivotQuery = `, quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}${valueFieldAliases.length > 0 ? `, ${valueFieldAliases.join(', ')}` : ''}
-    FROM quill_base_table),
-    quill_qt_agg AS (SELECT ${quillAggSelects.join(', ')}
-    FROM quill_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)}),
-    quill_base_pivot AS (SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} * FROM quill_qt_agg qt 
-    ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''})
-    SELECT * FROM quill_base_pivot
-    `
-        .replace(/\s+/g, ' ')
-        .trim();
-    return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
-}
-function createAggregationValuePivot(pivot, itemQuery, databaseType) {
-    const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery)
-        return undefined;
-    let quillAggSelects = [];
-    let valueFieldAliases = [];
-    const seenAggs = {};
-    pivot.aggregations?.forEach((currentAgg) => {
-        if (!currentAgg.valueField)
-            currentAgg.valueField = undefined;
-        // Track duplicate aggregation combos for disambiguation.
-        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
-            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
-        }
-        else {
-            seenAggs[currentAgg.aggregationType ?? ''] = {
-                ...seenAggs[currentAgg.aggregationType ?? ''],
-                [currentAgg.valueField ?? '']: 1,
-            };
-        }
-        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString() ?? '';
-        if (disambiguationIndex === '1')
-            disambiguationIndex = '';
-        const valueFieldAlias = processColumnReference(currentAgg.valueField || 'count', databaseType, undefined, false, true);
-        const valueAliasSubstring = currentAgg.valueField
-            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
-            : '';
-        let value2AliasSubstring = '';
-        const disambiguation = pivot.aggregations?.length > 1
-            ? `${disambiguationIndex}_${currentAgg.aggregationType}`
-            : '';
-        // If the field type is bool, wrap it in a CASE WHEN
-        let valueExpr = !currentAgg.valueField ? '*' : valueFieldAlias;
-        valueExpr =
-            currentAgg.valueFieldType === 'bool'
-                ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`
-                : valueExpr;
-        if (currentAgg.aggregationType === 'percentage') {
-            if (!currentAgg.valueField) {
-                throw new Error('No value field provided for percentage aggregation');
-            }
-            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
-            const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool'
-                ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`
-                : valueField2Alias;
-            value2AliasSubstring =
-                currentAgg.valueField2 &&
-                    currentAgg.valueField !== currentAgg.valueField2
-                    ? `${processColumnReference(currentAgg.valueField2, databaseType, undefined, true)} AS ${valueField2Alias}`
-                    : '';
-            const percentageExpr = currentAgg.valueField === currentAgg.valueField2 ||
-                !currentAgg.valueField2
-                ? `CAST(sum(${valueExpr}) AS FLOAT) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool' ? 'COUNT(*)' : 'SUM(sum(' + valueExpr + ')) OVER ()'}`
-                : `CAST(sum(${valueExpr}) AS FLOAT) / GREATEST(sum(${value2Expr}), 1)`;
-            quillAggSelects = [
-                ...quillAggSelects,
-                `${percentageExpr} as ${processColumnReference(`${currentAgg.valueField ?? ''}${disambiguation}`, databaseType, undefined, false, true)}`,
-            ];
-        }
-        else {
-            quillAggSelects = [
-                ...quillAggSelects,
-                `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || 'count') + disambiguation, databaseType)}`,
-            ];
-        }
-        if (valueAliasSubstring)
-            valueFieldAliases.push(valueAliasSubstring);
-        if (value2AliasSubstring)
-            valueFieldAliases.push(value2AliasSubstring);
-    });
-    valueFieldAliases = Array.from(new Set(valueFieldAliases));
-    if (valueFieldAliases.length === 0) {
-        valueFieldAliases = ['*'];
-    }
-    const sortQuery = pivot.sort && pivot.sortField && pivot.rowLimit
-        ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, undefined, true)} ${pivot.sortDirection || ''} `
-        : '';
-    const pivotQuery = `, quill_alias AS (
-        SELECT ${valueFieldAliases.join(', ')} FROM quill_base_table
-      ),
-      quill_qt_agg AS (
-        SELECT ${quillAggSelects.join(', ')} FROM quill_alias
-      ),
-      quill_base_pivot AS (
-        SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql'
-        ? `TOP ${pivot.rowLimit}`
-        : ''} * FROM quill_qt_agg qt
-        ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql'
-        ? ` LIMIT ${pivot.rowLimit}`
-        : ''}
-      )
-      SELECT * FROM quill_base_pivot`
-        .replace(/\s+/g, ' ')
-        .trim();
-    return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
-}
-function additionalProcessingOnPivotQuery(pivot, query, additionalProcessing, databaseType = 'postgresql') {
-    if (!additionalProcessing || !query)
-        return query;
-    const isValidBaseQuery = query.match(/SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/);
-    if (!isValidBaseQuery) {
-        return undefined;
-    }
-    if (!pivot.aggregations || pivot.aggregations.length === 0) {
-        if (pivot.aggregationType) {
-            pivot.aggregations = [
-                {
-                    aggregationType: pivot.aggregationType,
-                    valueField: pivot.valueField,
-                    valueField2: pivot.valueField2,
-                },
-            ];
-        }
-        else {
-            throw new Error('No aggregations provided for pivot');
-        }
-    }
-    let rowsPerPage = 0;
-    let currentInterval = 0;
-    let offset = 0;
-    let limit = 1000;
-    let sortQuery = '';
-    if (additionalProcessing.page) {
-        const page = additionalProcessing.page.page || 0;
-        if (additionalProcessing.page.rowsPerRequest) {
-            limit = additionalProcessing.page.rowsPerRequest;
-        }
-        rowsPerPage = additionalProcessing.page.rowsPerPage || 0;
-        currentInterval = page ? Math.floor(page / (limit / rowsPerPage)) : 0;
-        offset = currentInterval * limit;
-    }
-    const disambiguation = pivot.aggregations.length > 1
-        ? `_${(0, textProcessing_1.matchCasing)(pivot.aggregations?.[0]?.aggregationType, pivot.aggregations?.[0]?.valueField)}`
-        : '';
-    if (additionalProcessing.sort) {
-        sortQuery = `ORDER BY ${processColumnReference(additionalProcessing.sort.field, databaseType, undefined, true)} ${additionalProcessing.sort.direction || ''}`;
-    }
-    else {
-        const valueFieldAlias = processColumnReference((pivot.aggregations?.[0]?.valueField ?? '') + disambiguation, databaseType, undefined, false, true);
-        const defaultSortField = pivot.sortField || pivot.rowField || valueFieldAlias;
-        const defaultSortDirection = pivot.sortDirection || '';
-        if (defaultSortField !== `"_"`) {
-            sortQuery = `ORDER BY ${processColumnReference(defaultSortField, databaseType, undefined, true)} ${defaultSortDirection}`;
-        }
-        else {
-            sortQuery = '';
-        }
-    }
-    const additionalProcessingQuery = `
-    SELECT * 
-    FROM quill_base_pivot ${sortQuery}${databaseType.toLowerCase() === 'mssql' ? ` OFFSET ${offset} ROWS FETCH NEXT ${limit} ROWS ONLY` : ` LIMIT ${limit} OFFSET ${offset}`}
-    `
-        .replace(/\s+/g, ' ')
-        .trim();
-    return query.replace(/SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/, additionalProcessingQuery);
-}
-function generateRowCountQuery(query, databaseType) {
-    if (!query)
-        return query;
-    const isValidBaseQuery = query.match(/SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/);
-    if (!isValidBaseQuery) {
-        return undefined;
-    }
-    const rowCountQuery = `, subview_row_count_cte AS (SELECT * FROM quill_base_pivot)
-            SELECT count(*) as ${processColumnReference('row_count', databaseType || 'postgresql', undefined, true)} FROM subview_row_count_cte
-            `
-        .replace(/\s+/g, ' ')
-        .trim();
-    return query.replace(/SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/, rowCountQuery);
-}