@quillsql/react 2.13.7 → 2.13.9

package/dist/esm/utils/queryConstructor.js

@@ -16,36 +16,65 @@ function replaceBigQuerySpecialCharacters(column) {
 }
 export function processColumnReference(column, databaseType, fallbackOnNull, 
 // for mysql, we only want to use double quotes for pivot column field aliases
-isPivotFieldAlias) {
-    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+isPivotColumnFieldAlias, isPivotValueFieldAlias) {
+    if (['postgresql'].includes(databaseType.toLowerCase())) {
+        if (isPivotColumnFieldAlias) {
+            return `"${column.replaceAll('"', '')}"`;
+        }
         const columnParts = column.split('.');
         if (columnParts.length > 1) {
-            return `"${columnParts[0]}"."${columnParts[1]}"`;
+            return (`"` +
+                columnParts.map((part) => part.replaceAll('"', '')).join('"."') +
+                `"`);
         }
         if (column === '' && fallbackOnNull) {
             return `"${fallbackOnNull}"`;
         }
-        return `"${column}"`;
+        return `"${column.replaceAll('"', '')}"`;
     }
     if (['mysql'].includes(databaseType.toLowerCase())) {
-        if (isPivotFieldAlias) {
-            return `"${column}"`;
+        if (isPivotColumnFieldAlias) {
+            return `\`${column.replaceAll(`\``, '').replaceAll(`"`, '')}\``;
         }
         const columnParts = column.split('.');
         if (columnParts.length > 1) {
-            return `${columnParts[0]}.${columnParts[1]}`;
+            return (`\`` +
+                columnParts.map((part) => part.replaceAll(`\``, '')).join('`.`') +
+                `\``);
         }
         if (column === '' && fallbackOnNull) {
             return `${fallbackOnNull}`;
         }
         // Wrap MySQL columns in backticks to handle whitespace
-        return `\`${column}\``;
+        return `\`${column.replaceAll(`\``, '')}\``;
+    }
+    if (['snowflake'].includes(databaseType.toLowerCase())) {
+        if (isPivotColumnFieldAlias) {
+            return `"${column.replaceAll('"', '')}"`;
+        }
+        if (isPivotValueFieldAlias) {
+            const cleanedColumn = column.replaceAll(')', '').replaceAll('(', '_');
+            return `${cleanedColumn}`;
+        }
+        // const columnParts = column.split('.');
+        // if (columnParts.length > 1) {
+        //   return '"' + columnParts.join('"."') + '"';
+        // }
+        if (column === '' && fallbackOnNull) {
+            return `${fallbackOnNull}`;
+        }
+        return column;
+    }
+    if (isPivotColumnFieldAlias) {
+        return `\`${column.replaceAll('`', '')}\``;
     }
     const columnParts = column.split('.');
     if (columnParts.length > 1) {
-        return `\`${columnParts[0]}\`.\`${columnParts[1]}\``;
+        return (`\`` +
+            columnParts.map((part) => part.replaceAll(`\``, '')).join('`.`') +
+            `\``);
     }
-    return `\`${replaceBigQuerySpecialCharacters(column)}\``;
+    return `\`${replaceBigQuerySpecialCharacters(column.replaceAll('`', ''))}\``;
 }
 export function replaceSpacesWithUnderscores(column) {
     return column.replaceAll(' ', '_');
@@ -115,6 +144,8 @@ export function generateDistinctQuery(stringFields, query, databaseType) {
             return generateDistinctQueryMySQL(stringFields, query);
         case 'postgresql':
             return generateDistinctQueryPostgres(stringFields, query);
+        case 'snowflake':
+            return generateDistinctQuerySnowflake(stringFields, query);
         default:
             return generateDistinctQueryDefault(stringFields, query, databaseType);
     }
@@ -127,21 +158,6 @@ function generateDistinctQueryDefault(stringFields, query, databaseType) {
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
 }
 function generateDistinctQueryMySQL(stringFields, query) {
-    //   WITH querytable AS (
-    //     SELECT DISTINCT merchant, user_name, category
-    //     FROM transactions
-    // )
-    // SELECT 'merchant' AS field, JSON_ARRAYAGG(merchant) AS string_values
-    // FROM (SELECT DISTINCT merchant FROM querytable) AS distinct_merchants
-    // UNION ALL
-    // SELECT 'user_name' AS field, JSON_ARRAYAGG(user_name) AS string_values
-    // FROM (SELECT DISTINCT user_name FROM querytable) AS distinct_user_names
-    // UNION ALL
-    // SELECT 'category' AS field, JSON_ARRAYAGG(category) AS string_values
-    // FROM (SELECT DISTINCT category FROM querytable) AS distinct_categories;
-    // const distinctQueries = stringFields.map((field) => {
-    //   return `SELECT '${field}' AS ${processColumnReference('field', 'mysql')}, JSON_ARRAYAGG(${field}) AS ${processColumnReference('string_values', 'mysql')} FROM querytable`;
-    // });
     const distinctQueries = stringFields.map((field) => {
         return `
       SELECT '${field}' AS ${processColumnReference('field', 'mysql')}, 
@@ -158,29 +174,40 @@ function generateDistinctQueryPostgres(stringFields, query) {
     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;
+}
 export function generateMinMaxRangeQueries(columnFields, query, databaseType) {
+    const max = databaseType.toLowerCase() === 'snowflake' ? 'GREATEST' : 'MAX';
     const distinctQueries = columnFields.map((field) => {
-        const wrappedField = ['postgresql', 'snowflake'].includes(databaseType.toLowerCase())
+        const wrappedField = ['postgresql'].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}) AS min_range, ${max}(${wrappedField}) AS max_range FROM querytable`;
     });
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
 }
-export function generatePivotQuery(pivot, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket) {
+export function generatePivotQuery(pivot, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket, rowLimit) {
     if (!isValidPivot(pivot)) {
         return undefined;
     }
     if (pivot.columnField) {
-        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings);
+        console.log('1');
+        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings, rowLimit);
     }
     if (pivot.rowField) {
-        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
+        console.log('2');
+        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval, rowLimit);
     }
-    return createAggregationValuePivot(pivot, itemQueries, databaseType);
+    console.log('3');
+    return createAggregationValuePivot(pivot, itemQueries, databaseType, rowLimit);
 }
-function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues) {
+function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues, rowLimit) {
     if (!pivot || !pivot.columnField) {
         return undefined;
     }
@@ -189,123 +216,363 @@ function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, compar
     }
     if (['string', 'varchar'].includes(pivot.rowFieldType || '') ||
         !pivot.rowFieldType) {
-        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType);
+        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType, rowLimit);
     }
-    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket, comparisonInterval);
+    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket, comparisonInterval, rowLimit);
 }
-function create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType) {
+function create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType, rowLimit) {
     if (!pivot.columnField || !pivot.rowField) {
         return undefined;
     }
     const rowField = pivot.rowField;
     const valueField = pivot.valueField;
     const columnField = pivot.columnField;
+    const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
+    const valueFieldAlias = processColumnReference(valueField, databaseType, undefined, false, true);
+    const columnFieldAlias = processColumnReference(columnField, databaseType, undefined, false, true);
+    const max = databaseType.toLowerCase() === 'snowflake' ? 'GREATEST' : 'MAX';
+    const valueAliasSubstring = valueField
+        ? `${processColumnReference(valueField, databaseType, undefined, true)} AS ${valueFieldAlias},`
+        : '';
+    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)}`;
+            });
+            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)}`;
+            });
+            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.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.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.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.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 ${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField)} END) AS ${processColumnReference(column, databaseType, '_', true)}`;
+        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 ${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField)} END) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
+        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 ${processColumnReference(rowField, databaseType)} as ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${processColumnReference(rowField, databaseType)})`
+        ? `, quill_ct_cw as (SELECT ${rowFieldAlias} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_c_alias GROUP BY ${rowFieldAlias})`
         : '';
     const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(rowField, databaseType)}`
+        ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)} = qt.${rowFieldAlias}`
         : '';
     return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_qt_cw AS (SELECT ${processColumnReference(rowField, databaseType)}, ${caseWhens.join(', ')} FROM quill_qt GROUP BY ${processColumnReference(rowField, databaseType)})
-  ${compareCTE} ${compareCaseWhenCTE}
+  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.join(', ')} FROM quill_alias GROUP BY ${rowFieldAlias})
+  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
   SELECT * FROM quill_qt_cw qt 
-  ${joinQuery}`;
+  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
 }
-function create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket = 'month', comparisonInterval) {
+function create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket = 'month', comparisonInterval, rowLimit) {
     if (!pivot.columnField || !pivot.rowField) {
         return undefined;
     }
     const rowField = pivot.rowField;
     const columnField = pivot.columnField;
+    const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
+    const valueFieldAlias = processColumnReference(pivot.valueField ?? rowField, databaseType, undefined, false, true);
+    const columnFieldAlias = processColumnReference(columnField, databaseType, undefined, false, true);
+    const valueAliasSubstring = pivot.valueField
+        ? `${processColumnReference(pivot.valueField, databaseType, undefined, true)} AS ${valueFieldAlias},`
+        : '';
+    const max = databaseType.toLowerCase() === 'snowflake' ? 'GREATEST' : 'MAX';
+    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)}`;
+            });
+            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)}`;
+            });
+            const compareCTE = itemQueries[1] && comparisonInterval
+                ? `, 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] && comparisonInterval
+                ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_c_alias GROUP BY ${processDateTrunc(dateBucket, rowField, 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.join(', ')} FROM quill_alias GROUP BY ${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]
+            ? `, 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.join(', ')} FROM quill_c_alias GROUP BY ${processDateTrunc(dateBucket, rowField, 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.join(', ')} FROM quill_alias GROUP BY ${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 qt.${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, pivot.valueField)} END) AS ${processColumnReference(column, databaseType, '_', true)}`;
+        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 ${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, pivot.valueField)} END) AS ${processColumnReference(`comparison_${column}`, databaseType, '_', true)}`;
+        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]
+        ? `, 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_${rowField}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})`
+        ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowFieldAlias}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_c_alias GROUP BY ${processDateTrunc(dateBucket, rowField, 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)}`
+        ? `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_qt_agg as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(rowField, databaseType)}, ${caseWhens.join(', ')} FROM quill_query_table qt GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})
-  ${compareCTE} ${compareCaseWhenCTE}
+  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.join(', ')} FROM quill_alias GROUP BY ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)})
+  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
   SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
+  ${joinQuery} ORDER BY qt.${rowFieldAlias}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
 }
-function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
+function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval, rowLimit) {
+    console.log('HELLO 0: ', JSON.stringify(pivot), itemQueries);
     if (['string', 'varchar'].includes(pivot.rowFieldType || '') ||
         !pivot.rowFieldType) {
-        return create1DStringPivotQuery(pivot, itemQueries, databaseType);
+        return create1DStringPivotQuery(pivot, itemQueries, databaseType, rowLimit);
     }
-    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
+    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval, rowLimit);
 }
-function create1DStringPivotQuery(pivot, itemQueries, databaseType) {
+function create1DStringPivotQuery(pivot, itemQueries, databaseType, rowLimit) {
     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 = databaseType.toLowerCase() === 'snowflake' ? 'GREATEST' : 'MAX';
+    const valueAliasSubstring = valueField
+        ? `, ${processColumnReference(`${valueField}`, databaseType, undefined, true)} AS ${valueAlias}`
+        : ``;
+    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 ${valueField ? valueAlias : countAlias}_PERCENTAGE FROM quill_alias GROUP BY ${rowAlias})
+  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
+  SELECT * FROM quill_qt_cw qt
+  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    }
     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 ${processColumnReference(`${rowField}`, databaseType)} as  ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField || 'count'}`, databaseType)} FROM quill_ct GROUP BY ${processColumnReference(`${rowField}`, databaseType)})`
+        ? `, 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_qt_cw AS (SELECT ${processColumnReference(`${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`${valueField}` || 'count', databaseType)} FROM quill_qt GROUP BY ${processColumnReference(`${rowField}`, databaseType)})
-  ${compareCTE} ${compareCaseWhenCTE}
+  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}`;
+  ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
 }
-function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
+function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval, rowLimit) {
     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 = databaseType.toLowerCase() === 'snowflake' ? 'GREATEST' : 'MAX';
+    // 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'}`, databaseType)}_PERCENTAGE 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 ${valueField ? valueFieldAlias : countAlias}_PERCENTAGE FROM quill_alias GROUP BY ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)})
+  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
+  SELECT * FROM quill_qt_agg qt 
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    }
     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, rowField, databaseType)} as ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField || 'count'}`, databaseType)} FROM quill_ct GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})`
+        ? `, 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 ${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)}`
+        ? `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_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`${valueField || 'count'}`, databaseType)} FROM quill_qt GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})
-  ${compareCTE} ${compareCaseWhenCTE}
+  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 ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)})
+  ${compareCTE} ${aliasCTE} ${compareCaseWhenCTE}
   SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
 }
-function createAggregationValuePivot(pivot, itemQueries, databaseType) {
+function createAggregationValuePivot(pivot, itemQueries, databaseType, rowLimit) {
     const valueField = pivot.valueField;
     const aggregationType = processAggType(pivot.aggregationType);
     if (!pivot.valueField)
         return undefined;
+    const valueAlias = processColumnReference(valueField, databaseType, undefined, false, true);
+    if (aggregationType === 'percentage' && pivot.valueField2) {
+        const value2Alias = processColumnReference(pivot.valueField2, databaseType, undefined, false, true);
+        const max = databaseType.toLowerCase() === 'snowflake' ? 'GREATEST' : 'MAX';
+        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}_PERCENTAGE`, 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}, ${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}`, databaseType)}_PERCENTAGE FROM quill_alias)
+      ${compareCTE} ${aliasCTE} ${compareAggregation}
+      SELECT * FROM quill_qt_agg qt
+      ${joinQuery}${rowLimit ? ` LIMIT ${rowLimit}` : ''}`;
+    }
     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_ct)`
+        ? `, 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_qt_agg AS (SELECT ${aggregationType}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`${valueField}`, databaseType)} FROM quill_qt)
-      ${compareCTE} ${compareAggregation}
-      SELECT * FROM quill_qt_agg qt 
-      ${joinQuery}`;
+    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}` : ''}`;
 }

package/dist/esm/utils/report.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAU,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EACL,kBAAkB,EAClB,KAAK,EACL,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAa1B,OAAO,EACL,oBAAoB,EAIrB,MAAM,mBAAmB,CAAC;AAI3B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE;QAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,OAAO,EAAE,cAAc,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7D,aAAa,EAAE,GAAG,EAAE,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,mBAAmB,CAAC;IAClC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,WAkB1B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,mBAGnC,CAAC;AA2BF,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,EAC3B,aAAa,UAAO,EACpB,OAAO,GAAE,GAAG,EAAO,EACnB,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,GAAG,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,YAAY,CAAC,EAAE,OAAO,EACtB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAuI1D;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,EAC3B,aAAa,UAAO,EACpB,OAAO,GAAE,GAAG,EAAO,EACnB,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,YAAY,CAAC,EAAE,GAAG,EAClB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmC7B;AAED,wBAAsB,UAAU,CAAC,EAC/B,MAAM,EACN,eAAe,EACf,MAAM,GACP,EAAE;IACD,MAAM,EAAE,GAAG,CAAC;IACZ,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,mBAAmB,CAAC;CAC7B,GAAG,OAAO,CAAC,GAAG,CAAC,CA4Cf;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAkB/C,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAsDb;AAED,eAAO,MAAM,6BAA6B,YAC/B,GAAG,YACF,GAAG,UACL,KAAK,EAAE,UACP,mBAAmB,UACnB,KAAK,qBACM,GAAG,iBACP,MAAM,qBACF;IACjB,aAAa,EAAE,mBAAmB,CAAC;IACnC,UAAU,EAAE,kBAAkB,CAAC;CAChC,WACQ,mBAAmB,iBACb,GAAG,qBACC,OAAO,iBACX,OAAO,eACT,oBAAoB,KAChC,QAAQ,iBAAiB,CAgK3B,CAAC"}
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAU,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EACL,kBAAkB,EAClB,KAAK,EACL,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAY1B,OAAO,EACL,oBAAoB,EAIrB,MAAM,mBAAmB,CAAC;AAI3B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE;QAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,OAAO,EAAE,cAAc,EAAE,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7D,aAAa,EAAE,GAAG,EAAE,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,mBAAmB,CAAC;IAClC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,WAkB1B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,mBAGnC,CAAC;AA2BF,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,EAC3B,aAAa,UAAO,EACpB,OAAO,GAAE,GAAG,EAAO,EACnB,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,GAAG,EAClB,QAAQ,CAAC,EAAE,OAAO,EAClB,YAAY,CAAC,EAAE,OAAO,EACtB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAuI1D;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,EAC3B,aAAa,UAAO,EACpB,OAAO,GAAE,GAAG,EAAO,EACnB,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,YAAY,CAAC,EAAE,GAAG,EAClB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAmC7B;AAED,wBAAsB,UAAU,CAAC,EAC/B,MAAM,EACN,eAAe,EACf,MAAM,GACP,EAAE;IACD,MAAM,EAAE,GAAG,CAAC;IACZ,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,mBAAmB,CAAC;CAC7B,GAAG,OAAO,CAAC,GAAG,CAAC,CA4Cf;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAkB/C,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAsDb;AAED,eAAO,MAAM,6BAA6B,YAC/B,GAAG,YACF,GAAG,UACL,KAAK,EAAE,UACP,mBAAmB,UACnB,KAAK,qBACM,GAAG,iBACP,MAAM,qBACF;IACjB,aAAa,EAAE,mBAAmB,CAAC;IACnC,UAAU,EAAE,kBAAkB,CAAC;CAChC,WACQ,mBAAmB,iBACb,GAAG,qBACC,OAAO,iBACX,OAAO,eACT,oBAAoB,KAChC,OAAO,CAAC,iBAAiB,CAgK3B,CAAC"}