@quillsql/react 2.13.38 → 2.13.40

package/dist/cjs/utils/queryConstructor.js

@@ -226,7 +226,7 @@ function generateDistinctQueryMySQL(stringFields, query) {
 }
 function generateDistinctQueryPostgres(stringFields, query) {
     const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS ${processColumnReference('field', 'postgresql')}, to_json(ARRAY_AGG(DISTINCT ${field})) AS ${processColumnReference('string_values', 'postgresql')} FROM querytable`;
+        return `SELECT '${field}' AS ${processColumnReference('field', 'postgresql')}, to_json(ARRAY_AGG(DISTINCT "${field}")) AS ${processColumnReference('string_values', 'postgresql')} FROM querytable`;
     });
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
@@ -297,53 +297,115 @@ function create2DPivotQuery(pivot, itemQuery, databaseType, columnFieldValues, d
     if (!pivot || !pivot.columnField) {
         return undefined;
     }
-    if ((0, columnProcessing_1.isStringType)(pivot.rowFieldType || '') || !pivot.rowFieldType) {
+    if ((0, columnProcessing_1.isStringType)(pivot.rowFieldType ?? '') || !pivot.rowFieldType) {
         return create2DStringPivotQuery(pivot, itemQuery, columnFieldValues, databaseType);
     }
     return create2DDatePivotQuery(pivot, itemQuery, columnFieldValues, databaseType, dateBucket);
 }
 function create2DStringPivotQuery(pivot, itemQuery, columnFieldValues, databaseType) {
     const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField) {
+    if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField)
         return undefined;
-    }
     const rowField = pivot.rowField;
-    const valueField = pivot.valueField;
+    if (!pivot.aggregations?.[0]?.valueField && !pivot.valueField)
+        throw new Error('No value field provided for pivot');
+    if (!pivot.aggregations?.[0]?.aggregationType && !pivot.aggregationType)
+        throw new Error('No aggregation type provided for pivot');
     const columnField = pivot.columnField;
     const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
-    const valueFieldAlias = processColumnReference(valueField ?? rowField, databaseType, undefined, false, true);
     const columnFieldAlias = processColumnReference(columnField, databaseType, undefined, false, true);
-    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);
-        if (pivot.valueField === pivot.valueField2) {
-            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)}`;
-            });
+    let caseWhens = [];
+    let valueAliases = [];
+    const seenAggs = {};
+    pivot.aggregations?.forEach((currentAgg) => {
+        // Track duplicate aggregation combos for disambiguation.
+        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
+            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
         }
         else {
-            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)}`;
-            });
+            seenAggs[currentAgg.aggregationType ?? ''] = {
+                ...seenAggs[currentAgg.aggregationType ?? ''],
+                [currentAgg.valueField ?? '']: 1,
+            };
         }
-    }
-    // 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 || ''} ` : ''}`;
+        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString();
+        if (disambiguationIndex === '1')
+            disambiguationIndex = '';
+        const valueFieldAlias = processColumnReference((currentAgg.valueField || rowField || 'count'), databaseType, undefined, false, true);
+        const valueAliasSubstring = currentAgg.valueField
+            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
+            : '';
+        let value2AliasSubstring = '';
+        const disambiguationField = Object.values(seenAggs[currentAgg.aggregationType ?? ''] ?? {}).reduce((acc, v) => acc + v) > 1
+            ? `_${currentAgg.valueField}${disambiguationIndex}`
+            : '';
+        const disambiguation = pivot.aggregations?.length > 1
+            ? `${disambiguationField}_${disambiguationField ? (0, textProcessing_1.matchCasing)(currentAgg.aggregationType, currentAgg.valueField) : currentAgg.aggregationType}`
+            : '';
+        // Wrap the value field in CASE WHEN if its type is bool.
+        const valueExpr = currentAgg.valueFieldType === 'bool'
+            ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`
+            : processValueField(currentAgg.aggregationType, databaseType, valueFieldAlias);
+        if (currentAgg.aggregationType === 'percentage') {
+            if (!currentAgg.valueField)
+                throw new Error('No value field provided for pivot');
+            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
+            // Wrap the second value field if its type is bool.
+            const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool'
+                ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`
+                : valueField2Alias;
+            if (currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2) {
+                caseWhens = columnFieldValues.map((column) => {
+                    return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) / GREATEST(sum(${value2Expr}), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
+                });
+            }
+            else {
+                value2AliasSubstring = `${processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, true)} AS ${valueField2Alias}`;
+                caseWhens = columnFieldValues.map((column) => {
+                    return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${value2Expr} END), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
+                });
+            }
+        }
+        else {
+            caseWhens = [
+                ...caseWhens,
+                ...columnFieldValues.map((column) => {
+                    return `${processAggType(currentAgg.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
+                }),
+            ];
+        }
+        if (valueAliasSubstring)
+            valueAliases.push(valueAliasSubstring);
+        if (value2AliasSubstring)
+            valueAliases.push(value2AliasSubstring);
+    });
+    valueAliases = [
+        `${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}`,
+        ...valueAliases,
+        `${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias}`,
+    ];
+    valueAliases = Array.from(new Set(valueAliases));
+    const sortQuery = pivot.sort && pivot.sortField && pivot.rowLimit
+        ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType)} ${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}` : ''})
+    ,quill_alias AS (
+      SELECT ${valueAliases.length > 0 ? `${valueAliases.join(', ')}` : ''}
+      FROM quill_base_table
+    ),
+    quill_qt_cw AS (
+      SELECT ${rowFieldAlias}
+      ${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''}
+      FROM quill_alias
+      GROUP BY ${rowFieldAlias}
+    ),
+    quill_base_pivot AS (
+      SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} *
+      FROM quill_qt_cw qt
+      ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''}
+    )
     SELECT * FROM quill_base_pivot
-    `
+  `
         .replace(/\s+/g, ' ')
         .trim();
     return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
@@ -353,38 +415,95 @@ function create2DDatePivotQuery(pivot, itemQuery, columnFieldValues, databaseTyp
     if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField) {
         return undefined;
     }
+    if (!pivot.aggregations?.[0]?.valueField && !pivot.valueField)
+        throw new Error('No value field provided for pivot');
+    if (!pivot.aggregations?.[0]?.aggregationType && !pivot.aggregationType)
+        throw new Error('No aggregation type provided for pivot');
+    // const aggregationType = (pivot.aggregations?.[0]?.aggregationType ?? pivot.aggregationType) as any;
     const rowField = pivot.rowField;
     const columnField = pivot.columnField;
     const rowFieldAlias = processColumnReference(rowField, databaseType, undefined, false, true);
-    const 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},`
-        : '';
-    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);
-        // 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) {
-            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)}`;
-            });
+    let caseWhens = [];
+    let valueFieldAliases = [];
+    const seenAggs = {};
+    pivot.aggregations?.forEach((currentAgg) => {
+        // if the aggregation combo has been seen before, increment the count, else add it to the seenAggs array
+        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
+            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
         }
         else {
-            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)}`;
-            });
+            seenAggs[currentAgg.aggregationType ?? ''] = {
+                ...seenAggs[currentAgg.aggregationType ?? ''],
+                [currentAgg.valueField ?? '']: 1,
+            };
         }
-    }
+        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString();
+        if (disambiguationIndex === '1')
+            disambiguationIndex = '';
+        const valueFieldAlias = processColumnReference((currentAgg.valueField ?? rowField), databaseType, undefined, false, true);
+        const valueAliasSubstring = currentAgg.valueField
+            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
+            : '';
+        let value2AliasSubstring = '';
+        const disambiguationField = Object.values(seenAggs[currentAgg.aggregationType ?? ''] ?? {}).reduce((acc, v) => acc + v) > 1 ? `_${currentAgg.valueField}${disambiguationIndex}` : '';
+        const disambiguation = pivot.aggregations?.length > 1
+            ? `${disambiguationField}_${disambiguationField ? (0, textProcessing_1.matchCasing)(currentAgg.aggregationType, currentAgg.valueField) : currentAgg.aggregationType}`
+            : '';
+        // Wrap the value field in CASE WHEN if its type is bool.
+        const valueExpr = currentAgg.valueFieldType === 'bool'
+            ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`
+            : processValueField(currentAgg.aggregationType, databaseType, valueFieldAlias);
+        if (currentAgg.aggregationType === 'percentage') {
+            if (!currentAgg.valueField)
+                throw new Error('No value field provided for pivot');
+            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
+            // Wrap the second value field if its type is bool.
+            const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool'
+                ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`
+                : valueField2Alias;
+            // edge case. if the user picks amount and amount, we assume they want a pie chart like breakdown of amount. so the summation of valueField2 has to be moved outside of the case whe
+            if (currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2) {
+                caseWhens = [
+                    ...caseWhens,
+                    ...columnFieldValues.map((column) => {
+                        return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) / GREATEST(sum(${value2Expr}), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
+                    }),
+                ];
+            }
+            else {
+                value2AliasSubstring = `${processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, true)} AS ${valueField2Alias}`;
+                caseWhens = [
+                    ...caseWhens,
+                    ...columnFieldValues.map((column) => {
+                        return `sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${value2Expr} END), 1) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
+                    }),
+                ];
+            }
+        }
+        else {
+            caseWhens = [
+                ...caseWhens,
+                ...columnFieldValues.map((column) => {
+                    return `${processAggType(currentAgg.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(column, databaseType)}' THEN ${valueExpr} END) AS ${processColumnReference(column + disambiguation, databaseType, '_', true)}`;
+                }),
+            ];
+        }
+        if (valueAliasSubstring)
+            valueFieldAliases.push(valueAliasSubstring);
+        if (value2AliasSubstring)
+            valueFieldAliases.push(value2AliasSubstring);
+    });
+    valueFieldAliases = [
+        `${processColumnReference(rowField, databaseType, undefined, true)} AS ${rowFieldAlias}`,
+        ...valueFieldAliases,
+        `${processColumnReference(columnField, databaseType, undefined, true)} AS ${columnFieldAlias}`,
+    ];
+    valueFieldAliases = Array.from(new Set(valueFieldAliases));
     // pivot sort matters in the base query when there is a rowLimit. In mssql, an orderby must be accompanied by a limit in a subquery and not allowed in a cte
     const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType)} ${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_alias AS (SELECT ${valueFieldAliases.length > 0 ? `${valueFieldAliases.join(', ')}` : ''} FROM quill_base_table),
     quill_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${rowFieldAlias}${caseWhens.length > 0 ? `, ${caseWhens.join(', ')}` : ''} FROM quill_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)}),
     quill_base_pivot AS (SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} * FROM quill_qt_agg qt
     ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''})
@@ -405,37 +524,91 @@ function create1DPivotQuery(pivot, itemQuery, dateBucket = 'month', databaseType
 // 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) {
+    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 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);
-        if (pivot.valueField !== pivot.valueField2) {
-            value2AliasSubstring =
-                valueField && valueField !== pivot.valueField2
-                    ? `, ${processColumnReference(`${pivot.valueField2}`, databaseType, undefined, true)} AS ${value2Alias}`
-                    : '';
+    const rowAlias = processColumnReference(rowField, databaseType, undefined, true);
+    let quillAggSelects = [rowAlias];
+    let valueFieldAliases = [];
+    const seenAggs = {};
+    pivot.aggregations?.forEach((currentAgg) => {
+        if (!currentAgg.valueField)
+            currentAgg.valueField = undefined;
+        // Track duplicates to disambiguate names
+        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
+            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
         }
-        quillSelectSubstring = `${rowAlias}, sum(${valueAlias}) / GREATEST(sum(${value2Alias}), 1) as ${processColumnReference(`${valueField ?? ''}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)}`;
-    }
-    // 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
-      `
+        else {
+            seenAggs[currentAgg.aggregationType ?? ''] = {
+                ...seenAggs[currentAgg.aggregationType ?? ''],
+                [currentAgg.valueField ?? '']: 1,
+            };
+        }
+        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString() ?? '';
+        if (disambiguationIndex === '1')
+            disambiguationIndex = '';
+        // This is the alias (from quill_alias CTE) for the field
+        const valueFieldAlias = processColumnReference((currentAgg.valueField || rowField || 'count'), databaseType, undefined, false, true);
+        // In the base query, we select the raw column.
+        const valueAliasSubstring = currentAgg.valueField
+            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
+            : '';
+        let value2AliasSubstring = '';
+        const disambiguation = pivot.aggregations?.length > 1
+            ? `${disambiguationIndex}_${currentAgg.aggregationType}`
+            : '';
+        // Wrap the field in a CASE WHEN if it's boolean
+        let valueExpr = !currentAgg.valueField ? '*' : valueFieldAlias;
+        if (currentAgg.valueFieldType === 'bool') {
+            valueExpr = `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`;
+        }
+        if (currentAgg.aggregationType === 'percentage') {
+            if (!currentAgg.valueField) {
+                throw new Error('No value field provided for percentage aggregation');
+            }
+            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
+            let value2Expr = valueField2Alias;
+            if ((currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool') {
+                value2Expr = `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`;
+            }
+            value2AliasSubstring = currentAgg.valueField2 && currentAgg.valueField !== currentAgg.valueField2
+                ? `${processColumnReference(currentAgg.valueField2, databaseType, undefined, true)} AS ${valueField2Alias}`
+                : '';
+            const percentageExpr = currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2
+                ? `sum(${valueExpr}) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool' ? 'COUNT(*)' : 'SUM(sum(' + valueExpr + ')) OVER ()'}`
+                : `sum(${valueExpr}) / GREATEST(sum(${value2Expr}), 1)`;
+            quillAggSelects = [
+                ...quillAggSelects,
+                `${percentageExpr} as ${processColumnReference(`${currentAgg.valueField ?? ''}${disambiguation}`, databaseType, undefined, false, true)}`,
+            ];
+        }
+        else {
+            quillAggSelects = [
+                ...quillAggSelects,
+                `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || 'count') + disambiguation, databaseType)}`,
+            ];
+        }
+        if (valueAliasSubstring)
+            valueFieldAliases.push(valueAliasSubstring);
+        if (value2AliasSubstring)
+            valueFieldAliases.push(value2AliasSubstring);
+    });
+    valueFieldAliases = Array.from(new Set(valueFieldAliases));
+    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}${valueFieldAliases.length > 0 ? `, ${valueFieldAliases.join(', ')}` : ''}
+       FROM quill_base_table
+     ),
+     quill_qt_cw AS (
+       SELECT ${quillAggSelects.join(', ')} FROM quill_alias GROUP BY ${rowAlias}
+     ),
+     quill_base_pivot AS (
+       SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} *
+       FROM quill_qt_cw qt ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''}
+     )
+     SELECT * FROM quill_base_pivot`
         .replace(/\s+/g, ' ')
         .trim();
     return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
@@ -446,33 +619,76 @@ function create1DDatePivotQuery(pivot, itemQuery, dateBucket = 'month', database
         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 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);
-        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)} 
-        `;
-    }
+    let quillAggSelects = [`${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(rowField, databaseType)}`];
+    let valueFieldAliases = [];
+    const seenAggs = {};
+    pivot.aggregations?.forEach((currentAgg) => {
+        if (!currentAgg.valueField)
+            currentAgg.valueField = undefined;
+        // if the aggregation combo has been seen before, increment the count, else add it to the seenAggs array
+        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
+            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
+        }
+        else {
+            seenAggs[currentAgg.aggregationType ?? ''] = {
+                ...seenAggs[currentAgg.aggregationType ?? ''],
+                [currentAgg.valueField ?? '']: 1,
+            };
+        }
+        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString() ?? '';
+        if (disambiguationIndex === '1')
+            disambiguationIndex = '';
+        const valueFieldAlias = processColumnReference((currentAgg.valueField || rowField || 'count'), databaseType, undefined, false, true);
+        const valueAliasSubstring = currentAgg.valueField
+            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
+            : '';
+        let value2AliasSubstring = '';
+        const disambiguation = pivot.aggregations?.length > 1
+            ? `${disambiguationIndex}_${currentAgg.aggregationType}`
+            : '';
+        // Wrap the field in a CASE WHEN if it's boolean
+        let valueExpr = !currentAgg.valueField ? '*' : valueFieldAlias;
+        if (currentAgg.valueFieldType === 'bool') {
+            valueExpr = `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`;
+        }
+        if (currentAgg.aggregationType === 'percentage') {
+            if (!currentAgg.valueField) {
+                throw new Error('No value field provided for percentage aggregation');
+            }
+            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
+            value2AliasSubstring = currentAgg.valueField2 && currentAgg.valueField !== currentAgg.valueField2
+                ? `${processColumnReference(currentAgg.valueField2, databaseType, undefined, true)} AS ${valueField2Alias}`
+                : '';
+            let value2Expr = valueField2Alias;
+            if ((currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool') {
+                value2Expr = `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`;
+            }
+            const percentageExpr = currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2
+                ? `sum(${valueExpr}) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool' ? 'COUNT(*)' : 'SUM(sum(' + valueExpr + ')) OVER ()'}`
+                : `sum(${valueExpr}) / GREATEST(sum(${value2Expr}), 1)`;
+            quillAggSelects = [
+                ...quillAggSelects,
+                `${percentageExpr} as ${processColumnReference(`${currentAgg.valueField}${disambiguation}`, databaseType, undefined, false, true)}`,
+            ];
+        }
+        else {
+            quillAggSelects = [
+                ...quillAggSelects,
+                `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || 'count') + disambiguation, databaseType)}`,
+            ];
+        }
+        if (valueAliasSubstring)
+            valueFieldAliases.push(valueAliasSubstring);
+        if (value2AliasSubstring)
+            valueFieldAliases.push(value2AliasSubstring);
+    });
+    valueFieldAliases = Array.from(new Set(valueFieldAliases));
     // 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}
+    const pivotQuery = `, quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, undefined, true)} AS ${rowFieldAlias}${valueFieldAliases.length > 0 ? `, ${valueFieldAliases.join(', ')}` : ''}
     FROM quill_base_table),
-    quill_qt_agg AS (SELECT ${quillAggSubstring}
+    quill_qt_agg AS (SELECT ${quillAggSelects.join(', ')}
     FROM quill_alias GROUP BY ${databaseType.toLowerCase() === 'clickhouse' ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)}),
     quill_base_pivot AS (SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql' ? `TOP ${pivot.rowLimit}` : ''} * FROM quill_qt_agg qt 
     ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql' ? ` LIMIT ${pivot.rowLimit}` : ''})
@@ -484,27 +700,89 @@ function create1DDatePivotQuery(pivot, itemQuery, dateBucket = 'month', database
 }
 function createAggregationValuePivot(pivot, itemQuery, databaseType) {
     const isValidBaseQuery = itemQuery.match(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/);
-    if (!isValidBaseQuery || !pivot.valueField) {
+    if (!isValidBaseQuery)
         return undefined;
-    }
-    const valueField = pivot.valueField;
-    const aggregationType = processAggType(pivot.aggregationType);
-    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);
-        value2AliasSubstring = `, ${value2Alias}`;
-        quillAggSubstring = `SELECT sum(${valueAlias}) / GREATEST(sum(${value2Alias}), 1) as ${processColumnReference(`${valueField}_${(0, textProcessing_1.matchCasing)('percentage', valueField)}`, databaseType, undefined, false, true)}`;
-    }
-    // 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
-        `
+    let quillAggSelects = [];
+    let valueFieldAliases = [];
+    const seenAggs = {};
+    pivot.aggregations?.forEach((currentAgg) => {
+        if (!currentAgg.valueField)
+            currentAgg.valueField = undefined;
+        // Track duplicate aggregation combos for disambiguation.
+        if (seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']) {
+            seenAggs[currentAgg.aggregationType ?? ''][currentAgg.valueField ?? ''] += 1;
+        }
+        else {
+            seenAggs[currentAgg.aggregationType ?? ''] = {
+                ...seenAggs[currentAgg.aggregationType ?? ''],
+                [currentAgg.valueField ?? '']: 1,
+            };
+        }
+        let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? '']?.[currentAgg.valueField ?? '']?.toString() ?? '';
+        if (disambiguationIndex === '1')
+            disambiguationIndex = '';
+        const valueFieldAlias = processColumnReference((currentAgg.valueField || 'count'), databaseType, undefined, false, true);
+        const valueAliasSubstring = currentAgg.valueField
+            ? `${processColumnReference(currentAgg.valueField, databaseType, undefined, true)} AS ${valueFieldAlias}`
+            : '';
+        let value2AliasSubstring = '';
+        const disambiguation = pivot.aggregations?.length > 1
+            ? `${disambiguationIndex}_${currentAgg.aggregationType}`
+            : '';
+        // If the field type is bool, wrap it in a CASE WHEN
+        let valueExpr = !currentAgg.valueField ? '*' : valueFieldAlias;
+        valueExpr = currentAgg.valueFieldType === 'bool'
+            ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`
+            : valueExpr;
+        if (currentAgg.aggregationType === 'percentage') {
+            if (!currentAgg.valueField) {
+                throw new Error('No value field provided for percentage aggregation');
+            }
+            const valueField2Alias = processColumnReference(currentAgg.valueField2 ?? currentAgg.valueField, databaseType, undefined, false, true);
+            const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool'
+                ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`
+                : valueField2Alias;
+            value2AliasSubstring = currentAgg.valueField2 && currentAgg.valueField !== currentAgg.valueField2
+                ? `${processColumnReference(currentAgg.valueField2, databaseType, undefined, true)} AS ${valueField2Alias}`
+                : '';
+            const percentageExpr = currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2
+                ? `sum(${valueExpr}) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === 'bool' ? 'COUNT(*)' : 'SUM(sum(' + valueExpr + ')) OVER ()'}`
+                : `sum(${valueExpr}) / GREATEST(sum(${value2Expr}), 1)`;
+            quillAggSelects = [
+                ...quillAggSelects,
+                `${percentageExpr} as ${processColumnReference(`${currentAgg.valueField ?? ''}${disambiguation}`, databaseType, undefined, false, true)}`,
+            ];
+        }
+        else {
+            quillAggSelects = [
+                ...quillAggSelects,
+                `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || 'count') + disambiguation, databaseType)}`,
+            ];
+        }
+        if (valueAliasSubstring)
+            valueFieldAliases.push(valueAliasSubstring);
+        if (value2AliasSubstring)
+            valueFieldAliases.push(value2AliasSubstring);
+    });
+    valueFieldAliases = Array.from(new Set(valueFieldAliases));
+    const sortQuery = pivot.sort && pivot.sortField && pivot.rowLimit
+        ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType)} ${pivot.sortDirection || ''} `
+        : '';
+    const pivotQuery = `, quill_alias AS (
+        SELECT ${valueFieldAliases.join(', ')} FROM quill_base_table
+      ),
+      quill_qt_agg AS (
+        SELECT ${quillAggSelects.join(', ')} FROM quill_alias
+      ),
+      quill_base_pivot AS (
+        SELECT ${pivot.rowLimit && databaseType.toLowerCase() === 'mssql'
+        ? `TOP ${pivot.rowLimit}`
+        : ''} * FROM quill_qt_agg qt
+        ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== 'mssql'
+        ? ` LIMIT ${pivot.rowLimit}`
+        : ''}
+      )
+      SELECT * FROM quill_base_pivot`
         .replace(/\s+/g, ' ')
         .trim();
     return itemQuery.replace(/SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/, pivotQuery);
@@ -516,19 +794,19 @@ function additionalProcessingOnPivotQuery(pivot, query, additionalProcessing, da
     if (!isValidBaseQuery) {
         return undefined;
     }
+    if (!pivot.aggregations || pivot.aggregations.length === 0) {
+        if (pivot.aggregationType) {
+            pivot.aggregations = [{ aggregationType: pivot.aggregationType, valueField: pivot.valueField, valueField2: pivot.valueField2 }];
+        }
+        else {
+            throw new Error('No aggregations provided for pivot');
+        }
+    }
     let rowsPerPage = 0;
     let currentInterval = 0;
     let offset = 0;
     let limit = 1000;
-    let sortQuery = `${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)}`
-                : ''}`;
+    let sortQuery = '';
     if (additionalProcessing.page) {
         const page = additionalProcessing.page.page || 0;
         if (additionalProcessing.page.rowsPerRequest) {
@@ -538,9 +816,18 @@ function additionalProcessingOnPivotQuery(pivot, query, additionalProcessing, da
         currentInterval = page ? Math.floor(page / (limit / rowsPerPage)) : 0;
         offset = currentInterval * limit;
     }
+    const disambiguation = pivot.aggregations.length > 1
+        ? `_${(0, textProcessing_1.matchCasing)(pivot.aggregations?.[0]?.aggregationType, pivot.aggregations?.[0]?.valueField)}`
+        : '';
     if (additionalProcessing.sort) {
         sortQuery = `ORDER BY ${processColumnReference(additionalProcessing.sort.field, databaseType)} ${additionalProcessing.sort.direction || ''}`;
     }
+    else {
+        const valueFieldAlias = processColumnReference((pivot.aggregations?.[0]?.valueField ?? '') + disambiguation, databaseType, undefined, false, true);
+        const defaultSortField = pivot.sortField || pivot.rowField || valueFieldAlias;
+        const defaultSortDirection = pivot.sortDirection || '';
+        sortQuery = `ORDER BY ${processColumnReference(defaultSortField, databaseType)} ${defaultSortDirection}`;
+    }
     const additionalProcessingQuery = `
     SELECT * 
     FROM quill_base_pivot ${sortQuery}${databaseType === 'mssql' ? ` OFFSET ${offset} ROWS FETCH NEXT ${limit} ROWS ONLY` : ` LIMIT ${limit} OFFSET ${offset}`}