@quillsql/react 2.13.35 → 2.13.37

package/dist/cjs/utils/queryConstructor.js

@@ -1,11 +1,17 @@
 "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 columnProcessing_1 = require("./columnProcessing");
 const constants_1 = require("./constants");
 const pivotProcessing_1 = require("./pivotProcessing");
@@ -92,6 +98,23 @@ isPivotColumnFieldAlias, isPivotValueFieldAlias) {
             }
             return `\`${replaceBigQuerySpecialCharacters(column.replaceAll('`', ''))}\``;
         }
+        case 'mssql': {
+            if (column === '') {
+                return fallbackOnNull ? `[${fallbackOnNull}]` : `[_]`;
+            }
+            if (isPivotColumnFieldAlias) {
+                return `[${column.replaceAll(']', '').replaceAll('[', '')}]`;
+            }
+            const columnParts = column.split('.');
+            if (columnParts.length > 1) {
+                return (`[` +
+                    columnParts
+                        .map((part) => part.replaceAll(']', '').replaceAll('[', ''))
+                        .join('].[`') +
+                    `]`);
+            }
+            return `[${column.replaceAll(']', '').replaceAll('[', '')}]`;
+        }
         default:
             return column;
     }
@@ -109,27 +132,33 @@ function processInterval(interval, rowField, databaseType) {
     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())) {
-        const dateField = comparisonInterval
-            ? processInterval(comparisonInterval, rowField, databaseType)
-            : processColumnReference(rowField, databaseType);
         return `date_trunc('${dateBucket}', ${dateField})`;
     }
     if (['clickhouse'].includes(databaseType.toLowerCase())) {
-        const dateField = comparisonInterval
-            ? processInterval(comparisonInterval, rowField, databaseType)
-            : processColumnReference(rowField, databaseType);
         return `dateTrunc('${dateBucket}', ${dateField})`;
     }
     if (['mysql'].includes(databaseType.toLowerCase())) {
-        const dateField = comparisonInterval
-            ? processInterval(comparisonInterval, rowField, databaseType)
-            : processColumnReference(rowField, databaseType);
-        return `extract(${dateBucket} from ${dateField})`;
+        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)}')`;
     }
-    const dateField = comparisonInterval
-        ? processInterval(comparisonInterval, rowField, databaseType)
-        : processColumnReference(rowField, databaseType);
     return `TIMESTAMP_TRUNC(${dateField}, ${dateBucket})`;
 }
 function processValueField(aggType, databaseType, valueField) {
@@ -172,6 +201,8 @@ function generateDistinctQuery(stringFields, query, databaseType) {
             return generateDistinctQueryPostgres(stringFields, query);
         case 'snowflake':
             return generateDistinctQuerySnowflake(stringFields, query);
+        case 'mssql':
+            return generateDistinctQueryMSSQL(stringFields, query);
         default:
             return generateDistinctQueryDefault(stringFields, query, databaseType);
     }
@@ -207,44 +238,73 @@ function generateDistinctQuerySnowflake(stringFields, query) {
     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 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}) AS min_range, ${max}(${wrappedField}) AS max_range FROM querytable`;
+        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, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket, rowLimit) {
+function generatePivotQuery(pivot, itemQuery, databaseType, distinctStrings, dateBucket) {
     if (!(0, pivotProcessing_1.isValidPivot)(pivot).valid) {
         return undefined;
     }
-    if (pivot.columnField) {
-        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings, rowLimit);
+    if (pivot.columnField && distinctStrings && distinctStrings.length > 0) {
+        return create2DPivotQuery(pivot, itemQuery, databaseType, distinctStrings, dateBucket);
     }
     if (pivot.rowField) {
-        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval, rowLimit);
+        return create1DPivotQuery(pivot, itemQuery, dateBucket, databaseType);
     }
-    return createAggregationValuePivot(pivot, itemQueries, databaseType, rowLimit);
+    return createAggregationValuePivot(pivot, itemQuery, databaseType);
 }
-function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues, rowLimit) {
+function create2DPivotQuery(pivot, itemQuery, databaseType, columnFieldValues, dateBucket) {
     if (!pivot || !pivot.columnField) {
         return undefined;
     }
-    if (!columnFieldValues) {
-        return undefined;
-    }
     if ((0, columnProcessing_1.isStringType)(pivot.rowFieldType || '') || !pivot.rowFieldType) {
-        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType, rowLimit);
+        return create2DStringPivotQuery(pivot, itemQuery, columnFieldValues, databaseType);
     }
-    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket, comparisonInterval, rowLimit);
+    return create2DDatePivotQuery(pivot, itemQuery, columnFieldValues, databaseType, dateBucket);
 }
-function create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType, rowLimit) {
-    if (!pivot.columnField || !pivot.rowField) {
+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;
@@ -253,97 +313,44 @@ function create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databas
     const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
     const valueFieldAlias = processColumnReference(valueField ?? rowField, databaseType, undefined, false, true);
     const columnFieldAlias = processColumnReference(columnField, databaseType, undefined, false, true);
-    const max = 'GREATEST';
     const valueAliasSubstring = valueField
         ? `${processColumnReference(valueField, databaseType, undefined, true)} AS ${valueFieldAlias},`
         : '';
+    let value2AliasSubstring = '';
+    let caseWhens = columnFieldValues.map((column) => {
+        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) AS ${processColumnReference(column, databaseType, '_', true)}`;
+    });
     if (pivot.aggregationType === 'percentage' && pivot.valueField2) {
         const valueField2Alias = processColumnReference(pivot.valueField2, databaseType, undefined, false, true);
-        const value2AliasSubstring = `${processColumnReference(pivot.valueField2, databaseType, undefined, true)} AS ${valueField2Alias},`;
         if (pivot.valueField === pivot.valueField2) {
-            const caseWhens = columnFieldValues.map((column) => {
-                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(${processColumnReference(pivot.valueField2, databaseType)}), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
+            caseWhens = columnFieldValues.map((column) => {
+                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / GREATEST(sum(${processColumnReference(pivot.valueField2, databaseType)}), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
             });
-            const caseWhensCompare = columnFieldValues.map((column) => {
-                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)}) / ${max}(sum(${processColumnReference(pivot.valueField2, databaseType)}), 1) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
+        }
+        else {
+            value2AliasSubstring = `${processColumnReference(pivot.valueField2, databaseType, undefined, true)} AS ${valueField2Alias},`;
+            caseWhens = columnFieldValues.map((column) => {
+                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField2Alias)} END), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
             });
-            const compareCTE = itemQueries[1]
-                ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-                : '';
-            const aliasCTE = itemQueries[1]
-                ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-      ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_ct)`
-                : '';
-            const compareCaseWhenCTE = itemQueries[1]
-                ? `, quill_ct_cw as (SELECT ${rowFieldAlias} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}${caseWhensCompare.length > 0 ? `, ${caseWhensCompare.join(', ')}` : ''} FROM quill_c_alias GROUP BY ${rowFieldAlias})`
-                : '';
-            const joinQuery = itemQueries[1]
-                ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)} = qt.${rowFieldAlias}`
-                : '';
-            return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-    quill_alias AS (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-    ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_qt),
-    quill_qt_cw AS (SELECT ${rowFieldAlias}${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''} FROM quill_alias GROUP BY ${rowFieldAlias})
-    ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-    SELECT * FROM quill_qt_cw qt 
-    ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
         }
-        const caseWhens = columnFieldValues.map((column) => {
-            return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField2Alias)} END), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
-        });
-        const caseWhensCompare = columnFieldValues.map((column) => {
-            return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField2Alias)} END), 1) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
-        });
-        const compareCTE = itemQueries[1]
-            ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-            : '';
-        const aliasCTE = itemQueries[1]
-            ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring} ${value2AliasSubstring}
-    ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_ct)`
-            : '';
-        const compareCaseWhenCTE = itemQueries[1]
-            ? `, quill_ct_cw as (SELECT ${rowFieldAlias} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}${caseWhensCompare.length > 0 ? `, ${caseWhensCompare.join(', ')}` : ''} FROM quill_c_alias GROUP BY ${rowFieldAlias})`
-            : '';
-        const joinQuery = itemQueries[1]
-            ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)} = qt.${rowFieldAlias}`
-            : '';
-        return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring} ${value2AliasSubstring}
-  ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_qt),
-  quill_qt_cw AS (SELECT ${rowFieldAlias}${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''} FROM quill_alias GROUP BY ${rowFieldAlias})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_cw qt 
-  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
     }
-    const caseWhens = columnFieldValues.map((column) => {
-        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) AS ${processColumnReference(column, databaseType, '_', true)}`;
-    });
-    const caseWhensCompare = columnFieldValues.map((column) => {
-        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
-    });
-    const compareCTE = itemQueries[1]
-        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-        : '';
-    const aliasCTE = itemQueries[1]
-        ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-    ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_ct)`
-        : '';
-    const compareCaseWhenCTE = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT ${rowFieldAlias} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}${caseWhensCompare.length > 0 ? `, ${caseWhensCompare.join(', ')}` : ''} FROM quill_c_alias GROUP BY ${rowFieldAlias})`
-        : '';
-    const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)} = qt.${rowFieldAlias}`
-        : '';
-    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-  ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_qt),
-  quill_qt_cw AS (SELECT ${rowFieldAlias}${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''} FROM quill_alias GROUP BY ${rowFieldAlias})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_cw qt 
-  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    // 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)} ${pivot.sortDirection || ''} ` : ''}`;
+    const pivotQuery = `
+    ,quill_alias AS (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring} ${value2AliasSubstring}
+    ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} 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, itemQueries, columnFieldValues, databaseType, dateBucket = 'month', comparisonInterval, rowLimit) {
-    if (!pivot.columnField || !pivot.rowField) {
+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;
     }
     const rowField = pivot.rowField;
@@ -354,246 +361,205 @@ function create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseT
     const valueAliasSubstring = pivot.valueField
         ? `${processColumnReference(pivot.valueField, databaseType, undefined, true)} AS ${valueFieldAlias},`
         : '';
-    const max = 'GREATEST';
+    let value2AliasSubstring = '';
+    let caseWhens = columnFieldValues.map((column) => {
+        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) AS ${processColumnReference(column, databaseType, '_', true)}`;
+    });
     if (pivot.aggregationType === 'percentage' && pivot.valueField2) {
         const valueField2Alias = processColumnReference(pivot.valueField2, databaseType, undefined, false, true);
-        const value2AliasSubstring = `${processColumnReference(pivot.valueField2, databaseType, undefined, true)} AS ${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 when
         if (pivot.valueField === pivot.valueField2) {
-            const caseWhens = columnFieldValues.map((column) => {
-                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(${processColumnReference(valueField2Alias, databaseType)}), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
+            caseWhens = columnFieldValues.map((column) => {
+                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / GREATEST(sum(${processColumnReference(valueField2Alias, databaseType)}), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
             });
-            const caseWhensCompare = columnFieldValues.map((column) => {
-                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(${processColumnReference(valueField2Alias, databaseType)}), 1) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
+        }
+        else {
+            value2AliasSubstring = `${processColumnReference(pivot.valueField2, databaseType, undefined, true)} AS ${valueField2Alias},`;
+            caseWhens = columnFieldValues.map((column) => {
+                return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField2Alias)} END), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
             });
-            const compareCTE = itemQueries[1] && comparisonInterval
-                ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-                : '';
-            const aliasCTE = itemQueries[1] && comparisonInterval
-                ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-      ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_ct)`
-                : '';
-            const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-                ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}${caseWhensCompare.length > 0 ? `, ${caseWhensCompare.join(', ')}` : ''} FROM quill_c_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)})`
-                : '';
-            const joinQuery = itemQueries[1] && comparisonInterval
-                ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${rowFieldAlias} = ${processDateTrunc(dateBucket, `ct.comparison_${rowFieldAlias}`, databaseType, comparisonInterval)}`
-                : '';
-            return `WITH quill_query_table AS (${itemQueries[0]?.replaceAll(';', '')}),
-        quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-        ${processColumnReference(columnField, databaseType, undefined, true, true)} AS ${columnFieldAlias} FROM quill_query_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)})
-        ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-        SELECT * FROM quill_qt_agg qt 
-        ${joinQuery} ORDER BY qt.${rowFieldAlias}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
         }
-        const caseWhens = columnFieldValues.map((column) => {
-            return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField2Alias)} END), 1) AS ${processColumnReference(column, databaseType, '_', true)}`;
-        });
-        const caseWhensCompare = columnFieldValues.map((column) => {
-            return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) / ${max}(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField2Alias)} END), 1) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
-        });
-        const compareCTE = itemQueries[1] && comparisonInterval
-            ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-            : '';
-        const aliasCTE = itemQueries[1] && comparisonInterval
-            ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring} ${value2AliasSubstring}
-    ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_ct)`
-            : '';
-        const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-            ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}${caseWhensCompare.length > 0 ? `, ${caseWhensCompare.join(', ')}` : ''} FROM quill_c_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)})`
-            : '';
-        const joinQuery = itemQueries[1] && comparisonInterval
-            ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${rowFieldAlias} = ${processDateTrunc(dateBucket, `ct.comparison_${rowFieldAlias}`, databaseType, comparisonInterval)}`
-            : '';
-        return `WITH quill_query_table AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring} ${value2AliasSubstring}
-  ${processColumnReference(columnField, databaseType, undefined, true, true)} AS ${columnFieldAlias} FROM quill_query_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)})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt.${rowFieldAlias}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
     }
-    const caseWhens = columnFieldValues.map((column) => {
-        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) AS ${processColumnReference(column, databaseType, '_', true)}`;
-    });
-    const caseWhensCompare = columnFieldValues.map((column) => {
-        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueFieldAlias)} END) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
-    });
-    const compareCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-        : '';
-    const aliasCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-    ${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias} FROM quill_ct)`
-        : '';
-    const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}${caseWhensCompare.length > 0 ? `, ${caseWhensCompare.join(', ')}` : ''} FROM quill_c_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)})`
-        : '';
-    const joinQuery = itemQueries[1] && comparisonInterval
-        ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${rowFieldAlias} = ${processDateTrunc(dateBucket, `ct.comparison_${rowFieldAlias}`, databaseType, comparisonInterval)}`
-        : '';
-    return `WITH quill_query_table AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring}
-  ${processColumnReference(columnField, databaseType, undefined, true, true)} AS ${columnFieldAlias} FROM quill_query_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)})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt.${rowFieldAlias}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    // 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)} ${pivot.sortDirection || ''} ` : ''}`;
+    const pivotQuery = `
+    , quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}, ${valueAliasSubstring} ${value2AliasSubstring}
+    ${processColumnReference(columnField, databaseType, undefined, true, true)} AS ${columnFieldAlias} 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, itemQueries, dateBucket = 'month', databaseType, comparisonInterval, rowLimit) {
+function create1DPivotQuery(pivot, itemQuery, dateBucket = 'month', databaseType) {
     if ((0, columnProcessing_1.isStringType)(pivot.rowFieldType || '') || !pivot.rowFieldType) {
-        return create1DStringPivotQuery(pivot, itemQueries, databaseType, rowLimit);
+        return create1DStringPivotQuery(pivot, itemQuery, databaseType);
     }
-    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval, rowLimit);
+    return create1DDatePivotQuery(pivot, itemQuery, dateBucket, databaseType);
 }
-function create1DStringPivotQuery(pivot, itemQueries, databaseType, rowLimit) {
+// 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 valueField = pivot.valueField;
     const rowAlias = processColumnReference(rowField, databaseType, undefined, false, true);
     const valueAlias = processColumnReference(valueField ?? rowField, databaseType, undefined, false, true);
     const countAlias = processColumnReference('count', databaseType);
-    const max = 'GREATEST';
     const valueAliasSubstring = valueField
         ? `, ${processColumnReference(`${valueField}`, databaseType, undefined, true)} AS ${valueAlias}`
         : ``;
+    let value2AliasSubstring = '';
+    let quillSelectSubstring = `${rowAlias}, ${processAggType(pivot.aggregationType)}(${valueField ? valueAlias : '*'}) as ${valueField ? valueAlias : countAlias}`;
     if (pivot.aggregationType === 'percentage' && pivot.valueField2) {
         const value2Alias = processColumnReference(pivot.valueField2, databaseType, undefined, false, true);
-        const value2AliasSubstring = valueField && valueField !== pivot.valueField2
-            ? `, ${processColumnReference(`${pivot.valueField2}`, databaseType, undefined, true)} AS ${value2Alias}`
-            : ``;
-        const compareCTE = itemQueries[1]
-            ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-            : '';
-        const aliasCTE = itemQueries[1]
-            ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowAlias}${valueAliasSubstring}${value2AliasSubstring} FROM quill_ct)`
-            : '';
-        const compareCaseWhenCTE = itemQueries[1]
-            ? `, quill_ct_cw as (SELECT ${rowAlias} as ${processColumnReference(`comparison_${rowAlias}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${valueField ? valueAlias : '*'}) as ${processColumnReference(`comparison_${valueField ? valueAlias : countAlias}`, databaseType)} FROM quill_c_alias GROUP BY ${rowAlias})`
-            : '';
-        const joinQuery = itemQueries[1]
-            ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(`${rowField}`, databaseType)}`
-            : '';
-        return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowAlias}${valueAliasSubstring}${value2AliasSubstring} FROM quill_qt),
-  quill_qt_cw AS (SELECT ${rowAlias}, sum(${valueAlias}) / ${max}(sum(${value2Alias}), 1) as ${processColumnReference(`${valueField ?? ''}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)} FROM quill_alias GROUP BY ${rowAlias})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_cw qt
-  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+        if (pivot.valueField !== pivot.valueField2) {
+            value2AliasSubstring =
+                valueField && valueField !== pivot.valueField2
+                    ? `, ${processColumnReference(`${pivot.valueField2}`, databaseType, undefined, true)} AS ${value2Alias}`
+                    : '';
+        }
+        quillSelectSubstring = `${rowAlias}, sum(${valueAlias}) / GREATEST(sum(${value2Alias}), 1) as ${processColumnReference(`${valueField ?? ''}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)}`;
     }
-    const compareCTE = itemQueries[1]
-        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-        : '';
-    const aliasCTE = itemQueries[1]
-        ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowAlias}${valueAliasSubstring} FROM quill_ct)`
-        : '';
-    const compareCaseWhenCTE = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT ${rowAlias} as ${processColumnReference(`comparison_${rowAlias}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${valueField ? valueAlias : '*'}) as ${processColumnReference(`comparison_${valueField ? valueAlias : countAlias}`, databaseType)} FROM quill_c_alias GROUP BY ${rowAlias})`
-        : '';
-    const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(`${rowField}`, databaseType)}`
-        : '';
-    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowAlias}${valueAliasSubstring} FROM quill_qt),
-  quill_qt_cw AS (SELECT ${rowAlias}, ${processAggType(pivot.aggregationType)}(${valueField ? valueAlias : '*'}) as ${valueField ? valueAlias : countAlias} FROM quill_alias GROUP BY ${rowAlias})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_cw qt
-  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    // 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)} ${pivot.sortDirection || ''} ` : ''}`;
+    const pivotQuery = `, quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowAlias}${valueAliasSubstring}${value2AliasSubstring} FROM quill_base_table),
+      quill_qt_cw AS (SELECT ${quillSelectSubstring} 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, itemQueries, dateBucket = 'month', databaseType, comparisonInterval, rowLimit) {
+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 valueField = pivot.valueField;
     const rowFieldAlias = processColumnReference(rowField, databaseType, undefined);
     const valueFieldAlias = processColumnReference(valueField ?? rowField, databaseType, undefined, false, true);
-    const countAlias = processColumnReference('count', databaseType);
-    const valueAliasSubstring = valueField
-        ? `, ${processColumnReference(`${valueField}`, databaseType, undefined, true)} AS ${valueFieldAlias}`
-        : ``;
-    const max = 'GREATEST';
+    const comparisonValueFieldAlias = processColumnReference(valueField ?? rowField, databaseType, undefined, false, true);
+    const countAlias = processColumnReference(`count`, databaseType);
+    const valueAliasSubstring = valueField ? `, ${valueFieldAlias}` : ``;
+    let value2AliasSubstring = '';
+    let quillAggSubstring = `
+        ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(`${rowField}`, databaseType)}
+        , ${processAggType(pivot.aggregationType)}(${valueField ? valueFieldAlias : rowFieldAlias}) as ${valueField ? comparisonValueFieldAlias : countAlias} 
+    `;
     // this "and" is for typescript. in reality, pivot.valueField2 must exist if pivot.aggregationType === 'percentage'
     if (pivot.aggregationType === 'percentage' && pivot.valueField2) {
         const valueField2Alias = processColumnReference(pivot.valueField2, databaseType, undefined, false, true);
-        const value2AliasSubstring = valueField !== pivot.valueField2
-            ? `, ${processColumnReference(`${pivot.valueField2}`, databaseType, undefined, true)} AS ${valueField2Alias}`
-            : '';
-        const compareCTE = itemQueries[1] && comparisonInterval
-            ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-            : '';
-        const aliasCTE = itemQueries[1] && comparisonInterval
-            ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}${valueAliasSubstring}${value2AliasSubstring} FROM quill_ct)`
-            : '';
-        const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-            ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}, 
-      sum(${processColumnReference(`${valueFieldAlias}`, databaseType, undefined, true)}) / ${max}(sum(${processColumnReference(`${valueField2Alias}`, databaseType, undefined, true)}), 1) as ${processColumnReference(`comparison_${valueField ? valueFieldAlias : 'count'}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)} FROM quill_c_alias GROUP BY ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)})`
-            : '';
-        const joinQuery = itemQueries[1] && comparisonInterval
-            ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${processColumnReference(rowField, databaseType)} = ${processDateTrunc(dateBucket, `ct.comparison_${rowField}`, databaseType, comparisonInterval)}`
-            : '';
-        return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}${valueAliasSubstring}${value2AliasSubstring} FROM quill_qt),
-  quill_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(`${rowField}`, databaseType)}, sum(${valueFieldAlias}) / ${max}(sum(${valueField2Alias}), 1) as ${processColumnReference(`${valueField ?? ''}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)} FROM quill_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+        value2AliasSubstring =
+            valueField !== pivot.valueField2 ? `, ${valueField2Alias}` : '';
+        quillAggSubstring = `
+        ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(rowField, databaseType)}
+        , sum(${valueFieldAlias}) / GREATEST(sum(${valueField2Alias}), 1) as ${processColumnReference(`${valueField ?? ''}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)} 
+        `;
     }
-    const compareCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-        : '';
-    const aliasCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_c_alias as (SELECT ${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}${valueAliasSubstring} FROM quill_ct)`
-        : '';
-    const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}, 
-      ${processAggType(pivot.aggregationType)}(${valueFieldAlias}) as ${processColumnReference(`comparison_${valueField ? valueFieldAlias : 'count'}`, databaseType)} FROM quill_c_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)})`
-        : '';
-    const joinQuery = itemQueries[1] && comparisonInterval
-        ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${processColumnReference(rowField, databaseType)} = ${processDateTrunc(dateBucket, `ct.comparison_${rowField}`, databaseType, comparisonInterval)}`
-        : '';
-    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}${valueAliasSubstring} FROM quill_qt),
-  quill_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(`${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${valueField ? valueFieldAlias : rowFieldAlias}) as ${valueField ? valueFieldAlias : countAlias} FROM quill_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)})
-  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    // 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)} ${pivot.sortDirection || ''} ` : ''}`;
+    const pivotQuery = `, quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}${valueAliasSubstring}
+    ${value2AliasSubstring}
+    FROM quill_base_table),
+    quill_qt_agg AS (SELECT ${quillAggSubstring}
+    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, itemQueries, databaseType, rowLimit) {
+function createAggregationValuePivot(pivot, itemQuery, databaseType) {
+    const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
+    if (!isValidBaseQuery || !pivot.valueField) {
+        return undefined;
+    }
     const valueField = pivot.valueField;
     const aggregationType = processAggType(pivot.aggregationType);
-    if (!pivot.valueField)
-        return undefined;
     const valueAlias = processColumnReference(valueField, databaseType, undefined, false, true);
+    let value2AliasSubstring = '';
+    let quillAggSubstring = `SELECT ${aggregationType}(${valueAlias}) as ${processColumnReference(valueField, databaseType)}`;
     if (aggregationType === 'percentage' && pivot.valueField2) {
         const value2Alias = processColumnReference(pivot.valueField2, databaseType, undefined, false, true);
-        const max = 'GREATEST';
-        const compareCTE = itemQueries[1]
-            ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-            : '';
-        const aliasCTE = itemQueries[1]
-            ? `, quill_c_alias as (SELECT ${processColumnReference(valueField, databaseType, undefined, true)} AS ${valueAlias}, ${processColumnReference(pivot.valueField2, databaseType, undefined, true)} AS ${value2Alias} FROM quill_ct)`
-            : '';
-        const compareAggregation = itemQueries[1]
-            ? `, quill_ct_cw as (SELECT sum(${processColumnReference(`${valueField}`, databaseType)}) / ${max}(sum(${processColumnReference(`${pivot.valueField2}`, databaseType)}), 1)  as ${processColumnReference(`comparison_${valueField}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)} FROM quill_c_alias)`
-            : '';
-        const joinQuery = itemQueries[1] ? `CROSS JOIN quill_ct_cw ct` : '';
-        return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}), quill_alias AS (SELECT ${processColumnReference(`${valueField}`, databaseType, undefined, true)} AS ${valueAlias}, ${processColumnReference(`${pivot.valueField2}`, databaseType, undefined, true)} AS ${value2Alias} FROM quill_qt),
-      quill_qt_agg AS (SELECT sum(${valueAlias}) / ${max}(sum(${value2Alias}), 1) as ${processColumnReference(`${valueField}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType)} FROM quill_alias)
-      ${compareCTE} ${aliasCTE} ${compareAggregation}
-      SELECT * FROM quill_qt_agg qt
-      ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+        value2AliasSubstring = `, ${value2Alias}`;
+        quillAggSubstring = `SELECT sum(${valueAlias}) / GREATEST(sum(${value2Alias}), 1) as ${processColumnReference(`${valueField}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)}`;
     }
-    const compareCTE = itemQueries[1]
-        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
-        : '';
-    const aliasCTE = itemQueries[1]
-        ? `, quill_c_alias as (SELECT ${processColumnReference(valueField, databaseType, undefined, true)} AS ${valueAlias} FROM quill_ct)`
-        : '';
-    const compareAggregation = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT ${aggregationType}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField}`, databaseType)} FROM quill_c_alias)`
-        : '';
-    const joinQuery = itemQueries[1] ? `CROSS JOIN quill_ct_cw ct` : '';
-    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}), quill_alias AS (SELECT ${processColumnReference(`${valueField}`, databaseType, undefined, true)} AS ${valueAlias} FROM quill_qt),
-      quill_qt_agg AS (SELECT ${aggregationType}(${valueAlias}) as ${processColumnReference(`${valueField}`, databaseType)} FROM quill_alias)
-      ${compareCTE} ${aliasCTE} ${compareAggregation}
-      SELECT * FROM quill_qt_agg qt
-      ${joinQuery} ${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    // 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)} ${pivot.sortDirection || ''} ` : ''}`;
+    const pivotQuery = `, quill_alias AS (SELECT ${valueAlias}${value2AliasSubstring} FROM quill_base_table),
+        quill_qt_agg AS (${quillAggSubstring} 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;
+    }
+    let rowsPerPage = 0;
+    let currentInterval = 0;
+    let offset = 0;
+    let limit = 1000;
+    let sortQuery = `${pivot.sort && pivot.sortField
+        ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, undefined, true)} ${pivot.sortDirection || ''}`
+        : pivot.rowField
+            ? `ORDER BY ${processColumnReference(`${pivot.rowField}`, databaseType)}`
+            : pivot.valueField
+                ? pivot.aggregationType === 'percentage'
+                    ? `ORDER BY ${processColumnReference(`${pivot.valueField}_${(0, textProcessing_1.matchCasing)('percentage', pivot.valueField)}`, databaseType, undefined, false, true)}`
+                    : `ORDER BY ${processColumnReference(pivot.valueField, databaseType, undefined, false, true)}`
+                : ''}`;
+    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;
+    }
+    if (additionalProcessing.sort) {
+        sortQuery = `ORDER BY ${processColumnReference(additionalProcessing.sort.field, databaseType)} ${additionalProcessing.sort.direction || ''}`;
+    }
+    const additionalProcessingQuery = `
+    SELECT * 
+    FROM quill_base_pivot ${sortQuery}${databaseType === '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);
 }