@quillsql/react 2.12.28 → 2.12.30

package/dist/cjs/utils/pivotConstructor.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generatePivotWithSQL = void 0;
+const ChartBuilder_1 = require("../ChartBuilder");
+const ast_1 = require("../components/ReportBuilder/ast");
 const PivotModal_1 = require("../internals/ReportBuilder/PivotModal");
+const columnProcessing_1 = require("./columnProcessing");
 const dataFetcher_1 = require("./dataFetcher");
 const dates_1 = require("./dates");
 const queryConstructor_1 = require("./queryConstructor");
+const textProcessing_1 = require("./textProcessing");
 async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilter, distinctStrings) {
     if (dateFilter && dateFilter.startDate) {
         dateFilter.start = dateFilter.startDate;
@@ -25,7 +29,12 @@ async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilte
         const rowColumn = report.columns.find((column) => column.field === pivot.rowField);
         pivot.rowFieldType = rowColumn.format;
     }
-    const sqlQuery = (0, queryConstructor_1.generatePivotQuery)(pivot, report.itemQuery, report.rows, dateBucket, comparisonInterval, distinctStrings);
+    let distinctStringValues = undefined;
+    if (!distinctStrings && report.rows && pivot.columnField) {
+        const distinctValues = Array.from(new Set(report.rows.map((row) => row[pivot.columnField])));
+        distinctStringValues = distinctValues.map((value) => value.toString());
+    }
+    const sqlQuery = (0, queryConstructor_1.generatePivotQuery)(pivot, report.itemQuery, client.databaseType, comparisonInterval, distinctStrings ? distinctStrings : distinctStringValues, dateBucket);
     if (sqlQuery && report.rows.length > 0) {
         const hostedBody = {
             metadata: {
@@ -39,18 +48,39 @@ async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilte
                     overridePost: true,
                     convertDatatypes: true,
                 },
+                useNewNodeSql: true,
             },
         };
         const cloudBody = { ...hostedBody };
-        const resp = await (0, dataFetcher_1.getData)(client, 'query', 'same-origin', hostedBody, cloudBody);
+        const resp = await (0, dataFetcher_1.getData)(client, 'query', 'same-origin', hostedBody, cloudBody, 'POST', 'fetch-pivot');
         // With our current design we have to remove the second row field but leave the first for comparison purposes.
         const rows = resp.queryResults[0].rows;
+        if (pivot.columnField && client.databaseType.toLowerCase() === 'bigquery') {
+            rows.forEach((row) => {
+                Object.keys(row).forEach((key) => {
+                    const processedKey = (0, columnProcessing_1.processColumnName)(key);
+                    if (processedKey !== key) {
+                        row[processedKey] = row[key];
+                        delete row[key];
+                    }
+                });
+            });
+        }
         const columns = resp.queryResults[0].fields
             .map((field) => ({
-            field: field.name,
-            label: field.name.replace('comparison_', 'comparison '),
+            field: (0, columnProcessing_1.processColumnName)(field.name),
+            label: (0, textProcessing_1.snakeCaseToTitleCase)((0, columnProcessing_1.processColumnName)(field.name.replace('comparison_', 'comparison '))),
         }))
-            .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0);
+            .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0)
+            .sort((a, b) => {
+            if (a.field === pivot.rowField) {
+                return -1;
+            }
+            if (b.field === pivot.rowField) {
+                return 1;
+            }
+            return 0;
+        });
         if (pivot.rowField && !['string', 'varchar'].includes(pivot.rowFieldType)) {
             rows.forEach((row) => {
                 row[pivot.rowField] = (0, PivotModal_1.getDateString)(row[pivot.rowField], undefined, dateBucket);
@@ -78,6 +108,38 @@ async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilte
                 }
             }
         }
+        if (pivot.sort) {
+            rows.sort((a, b) => {
+                if (pivot.sortDirection === 'ASC') {
+                    if (ChartBuilder_1.dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                        // @ts-ignore
+                        return new Date(a[pivot.sortField]) - new Date(b[pivot.sortField]);
+                    }
+                    else if ((0, ast_1.isNumericColumnType)(pivot.sortFieldType)) {
+                        return a[pivot.sortField] - b[pivot.sortField];
+                    }
+                    return a[pivot.sortField].localeCompare(b[pivot.sortField]);
+                }
+                else {
+                    if (ChartBuilder_1.dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                        // @ts-ignore
+                        return new Date(b[pivot.sortField]) - new Date(a[pivot.sortField]);
+                    }
+                    else if ((0, ast_1.isNumericColumnType)(pivot.sortFieldType)) {
+                        return b[pivot.sortField] - a[pivot.sortField];
+                    }
+                    return b[pivot.sortField].localeCompare(a[pivot.sortField]);
+                }
+            });
+        }
+        // for the case of count agg on no value field
+        columns.forEach((column) => {
+            if (['null', 'undefined'].includes(column.label.toLowerCase()) &&
+                !pivot.valueField &&
+                pivot.aggregationType === 'count') {
+                column.label = 'Count';
+            }
+        });
         return {
             rows: rows,
             columns: columns,

package/dist/cjs/utils/pivotProcessing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pivotProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotProcessing.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAC9D,OAAO,EAAU,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG3D,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EAAE,GACxB,MAAM,CAsCR;AAkBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,WAgBxC;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,EAAE,EACzB,YAAY,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE;;;;EAsCvC;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,eAAe,EAAE;IACf,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,GACA,KAAK,CAqCP"}
+{"version":3,"file":"pivotProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotProcessing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGnD,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EAAE,GACxB,MAAM,CAsCR;AAkBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,WA0BxC;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,EAAE,EACzB,YAAY,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE;;;;EAsCvC;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,eAAe,EAAE;IACf,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,GACA,KAAK,CAqCP"}

package/dist/cjs/utils/pivotProcessing.js

@@ -49,10 +49,16 @@ function isValidPivot(pivot) {
     if (pivot.rowField && pivot.aggregationType === 'count') {
         return true;
     }
-    else if (pivot.rowField && pivot.valueField && pivot.aggregationType) {
+    else if (pivot.rowField &&
+        pivot.valueField &&
+        pivot.aggregationType &&
+        !pivot.columnField) {
         return true;
     }
-    else if (pivot.valueField && pivot.aggregationType) {
+    else if (pivot.valueField &&
+        pivot.aggregationType &&
+        !pivot.columnField &&
+        !pivot.rowField) {
         return true;
     }
     else if (pivot.rowField &&
@@ -65,10 +71,10 @@ function isValidPivot(pivot) {
 }
 exports.isValidPivot = isValidPivot;
 function getPossiblePivotFieldOptions(columns, uniqueValues) {
-    let rowFields = [];
-    let columnFields = [];
-    let valueFields = [];
-    for (let column of columns) {
+    const rowFields = [];
+    const columnFields = [];
+    const valueFields = [];
+    for (const column of columns) {
         // row fields can be dates or strings
         if (valueFormatter_1.DATE_FORMAT_TYPES.includes(column.format)) {
             rowFields.push(column.field);

package/dist/cjs/utils/queryConstructor.d.ts

@@ -1,5 +1,7 @@
 import { Pivot } from '../internals/ReportBuilder/PivotModal';
-export declare function generateDistinctQuery(stringFields: string[], query: string): string;
+export declare function processColumnReference(column: string, databaseType: string): string;
+export declare function generateCountQuery(fields: string[], query: string, databaseType: string): string;
+export declare function generateDistinctQuery(stringFields: string[], query: string, databaseType: string): string;
 export declare function generateMinMaxRangeQueries(columnFields: string[], query: string, databaseType: string): string;
-export declare function generatePivotQuery(pivot: Pivot, itemQueries: string[], rows: any[], dateBucket?: string, comparisonInterval?: string, distinctStrings?: string[]): string | undefined;
+export declare function generatePivotQuery(pivot: Pivot, itemQueries: string[], databaseType: string, comparisonInterval?: string, distinctStrings?: string[], dateBucket?: string): string | undefined;
 //# sourceMappingURL=queryConstructor.d.ts.map

package/dist/cjs/utils/queryConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAe9D,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAQ1E;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAcrB;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,GAAG,EAAE,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,eAAe,CAAC,EAAE,MAAM,EAAE,GACzB,MAAM,GAAG,SAAS,CAuBpB"}
+{"version":3,"file":"queryConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAmB9D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAa1E;AAgDD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EAAE,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAUrB;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UASrB;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAcrB;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,YAAY,EAAE,MAAM,EACpB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAwBpB"}

package/dist/cjs/utils/queryConstructor.js

@@ -1,22 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatePivotQuery = exports.generateMinMaxRangeQueries = exports.generateDistinctQuery = void 0;
+exports.generatePivotQuery = exports.generateMinMaxRangeQueries = exports.generateDistinctQuery = exports.generateCountQuery = exports.processColumnReference = void 0;
 const pivotProcessing_1 = require("./pivotProcessing");
-function processAggType(aggType) {
-    if (aggType === 'count')
+function processSingleQuotes(value, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        return value.replaceAll("'", "''");
+    }
+    return value.replaceAll("'", "\\'");
+}
+function processAggType(aggType, hasColumnField = false) {
+    if (aggType === 'count' && hasColumnField)
         return 'SUM';
     return aggType?.toLowerCase() === 'average' ? 'AVG' : aggType?.toLowerCase();
 }
-function processValueField(aggType, valueField) {
-    if (aggType === 'min' || aggType === 'max')
-        return `"${valueField}" ELSE null`;
+function replaceBigQuerySpecialCharacters(column) {
+    return column.replaceAll('/', 'quill_forward_slash');
+}
+function processColumnReference(column, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        const columnParts = column.split('.');
+        if (columnParts.length > 1) {
+            return `"${columnParts[0]}"."${columnParts[1]}"`;
+        }
+        return `"${column}"`;
+    }
+    const columnParts = column.split('.');
+    if (columnParts.length > 1) {
+        return `\`${columnParts[0]}\`.\`${columnParts[1]}\``;
+    }
+    return `\`${replaceBigQuerySpecialCharacters(column)}\``;
+}
+exports.processColumnReference = processColumnReference;
+function processInterval(interval, rowField, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        return `(${processColumnReference(rowField, databaseType)} + INTERVAL '${interval}')`;
+    }
+    return `TIMESTAMP_ADD(${processColumnReference(rowField, databaseType)}, INTERVAL ${interval} )`;
+}
+function processDateTrunc(dateBucket, rowField, databaseType, comparisonInterval) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        const date = comparisonInterval
+            ? processInterval(comparisonInterval, rowField, databaseType)
+            : processColumnReference(rowField, databaseType);
+        return `date_trunc('${dateBucket}', ${date})`;
+    }
+    const date = comparisonInterval
+        ? processInterval(comparisonInterval, rowField, databaseType)
+        : processColumnReference(rowField, databaseType);
+    return `TIMESTAMP_TRUNC(${date}, ${dateBucket})`;
+}
+function processValueField(aggType, databaseType, valueField) {
+    if (aggType === 'min' ||
+        aggType === 'max' ||
+        aggType?.toLowerCase() === 'average')
+        return `${processColumnReference(valueField, databaseType)} ELSE null`;
     if (aggType === 'count')
         return `1 ELSE 0`;
-    return valueField ? `"${valueField}" ELSE 0` : `1 ELSE 0`;
+    return valueField
+        ? `${processColumnReference(valueField, databaseType)} ELSE 0`
+        : `1 ELSE 0`;
+}
+function generateCountQuery(fields, query, databaseType) {
+    const countQuery = fields.map((field) => {
+        return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, COUNT(DISTINCT ${processColumnReference(field, databaseType)}) AS ${processColumnReference('count', databaseType)} FROM querytable`;
+    });
+    return (`WITH querytable AS (${query.replace(';', '')}) ` +
+        countQuery.join(' UNION ALL '));
 }
-function generateDistinctQuery(stringFields, query) {
+exports.generateCountQuery = generateCountQuery;
+function generateDistinctQuery(stringFields, query, databaseType) {
     const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS field, ARRAY_AGG(DISTINCT ${field}) AS string_values FROM querytable`;
+        return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, ARRAY_AGG(DISTINCT ${field}) AS ${processColumnReference('string_values', databaseType)} FROM querytable`;
     });
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
@@ -33,136 +87,144 @@ function generateMinMaxRangeQueries(columnFields, query, databaseType) {
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
 }
 exports.generateMinMaxRangeQueries = generateMinMaxRangeQueries;
-function generatePivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings) {
+function generatePivotQuery(pivot, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket) {
     if (!(0, pivotProcessing_1.isValidPivot)(pivot)) {
         return undefined;
     }
     if (pivot.columnField) {
-        return create2DPivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings);
+        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings);
     }
     if (pivot.rowField) {
-        return create1DPivotQuery(pivot, itemQueries, dateBucket, comparisonInterval);
+        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
     }
-    return createAggregationValuePivot(pivot, itemQueries);
+    return createAggregationValuePivot(pivot, itemQueries, databaseType);
 }
 exports.generatePivotQuery = generatePivotQuery;
-function create2DPivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings) {
+function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues) {
     if (!pivot || !pivot.columnField) {
         return undefined;
     }
-    // @ts-ignore
-    const columnValues = rows.map((row) => row[pivot.columnField]);
-    const distinctColumnValues = distinctStrings
-        ? distinctStrings
-        : Array.from(new Set(columnValues)).filter((value) => value !== undefined && value !== null);
-    if (distinctColumnValues.length === 0) {
+    if (!columnFieldValues) {
         return undefined;
     }
     if (['string', 'varchar'].includes(pivot.rowFieldType) ||
         !pivot.rowFieldType) {
-        return create2DStringPivotQuery(pivot, itemQueries, distinctColumnValues);
+        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType);
     }
-    return create2DDatePivotQuery(pivot, itemQueries, distinctColumnValues, dateBucket, comparisonInterval);
+    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket, comparisonInterval);
 }
-function create2DStringPivotQuery(pivot, itemQueries, distinctColumnValues) {
-    const caseWhens = distinctColumnValues.map((column) => {
-        return `${processAggType(pivot.aggregationType)}(CASE WHEN "${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "${column}"`;
+function create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType) {
+    if (!pivot.columnField || !pivot.rowField) {
+        return undefined;
+    }
+    const rowField = pivot.rowField;
+    const valueField = pivot.valueField;
+    const columnField = pivot.columnField;
+    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)}`;
     });
-    const caseWhensCompare = distinctColumnValues.map((column) => {
-        return `${processAggType(pivot.aggregationType)}(CASE WHEN "${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "comparison_${column}"`;
+    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)}`;
     });
     const compareCTE = itemQueries[1]
         ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
         : '';
     const compareCaseWhenCTE = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT "${pivot.rowField}" as "comparison_${pivot.rowField}", ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${pivot.rowField})`
+        ? `, quill_ct_cw as (SELECT ${processColumnReference(rowField, databaseType)} as ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${processColumnReference(rowField, databaseType)})`
         : '';
     const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct."comparison_${pivot.rowField}" = qt."${pivot.rowField}"`
+        ? `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 ${pivot.rowField}, ${caseWhens.join(', ')} FROM quill_qt GROUP BY ${pivot.rowField})
+  quill_qt_cw AS (SELECT ${processColumnReference(rowField, databaseType)}, ${caseWhens.join(', ')} FROM quill_qt GROUP BY ${processColumnReference(rowField, databaseType)})
   ${compareCTE} ${compareCaseWhenCTE}
   SELECT * FROM quill_qt_cw qt 
   ${joinQuery}`;
 }
-function create2DDatePivotQuery(pivot, itemQueries, distinctColumnValues, dateBucket = 'month', comparisonInterval) {
-    const caseWhens = distinctColumnValues.map((column) => {
-        return `${processAggType(pivot.aggregationType)}(CASE WHEN qt."${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "${column}"`;
+function create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket = 'month', comparisonInterval) {
+    if (!pivot.columnField || !pivot.rowField) {
+        return undefined;
+    }
+    const rowField = pivot.rowField;
+    const columnField = pivot.columnField;
+    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)}`;
     });
-    const caseWhensCompare = distinctColumnValues.map((column) => {
-        return `${processAggType(pivot.aggregationType)}(CASE WHEN "${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "comparison_${column}"`;
+    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)}`;
     });
     const compareCTE = itemQueries[1] && comparisonInterval
         ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
         : '';
     const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_ct_cw as (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as comparison_${pivot.rowField}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))`
+        ? `, 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)})`
         : '';
     const joinQuery = itemQueries[1] && comparisonInterval
-        ? `LEFT JOIN quill_ct_cw ct ON qt."${pivot.rowField}" = date_trunc('${dateBucket}', (ct."comparison_${pivot.rowField}" + INTERVAL '${comparisonInterval} day'))`
+        ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${processColumnReference(`${rowField}`, databaseType)} = ${processDateTrunc(dateBucket, `ct.comparison_${rowField}`, databaseType, comparisonInterval)}`
         : '';
     return `WITH quill_query_table AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_qt_agg as (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as ${pivot.rowField}, ${caseWhens.join(', ')} FROM quill_query_table qt GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))
+  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}
   SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt."${pivot.rowField}"`;
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
 }
-function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', comparisonInterval) {
+function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
     if (['string', 'varchar'].includes(pivot.rowFieldType) ||
         !pivot.rowFieldType) {
-        return create1DStringPivotQuery(pivot, itemQueries);
+        return create1DStringPivotQuery(pivot, itemQueries, databaseType);
     }
-    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, comparisonInterval);
+    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
 }
-function create1DStringPivotQuery(pivot, itemQueries) {
+function create1DStringPivotQuery(pivot, itemQueries, databaseType) {
+    const rowField = pivot.rowField;
+    const valueField = pivot.valueField;
     const compareCTE = itemQueries[1]
         ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
         : '';
     const compareCaseWhenCTE = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT ${pivot.rowField} as "comparison_${pivot.rowField}", ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as comparison_${pivot.valueField} FROM quill_ct GROUP BY ${pivot.rowField})`
+        ? `, 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)})`
         : '';
     const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct."comparison_${pivot.rowField}" = qt."${pivot.rowField}"`
+        ? `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 ${pivot.rowField}, ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as ${pivot.valueField} FROM quill_qt GROUP BY ${pivot.rowField})
+  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}
-  SELECT * FROM quill_qt_cw qt 
+  SELECT * FROM quill_qt_cw qt
   ${joinQuery}`;
 }
-function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', comparisonInterval) {
+function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
+    const rowField = pivot.rowField;
+    const valueField = pivot.valueField;
     const compareCTE = itemQueries[1] && comparisonInterval
         ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
         : '';
     const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
-        ? `, quill_ct_cw as (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as comparison_${pivot.rowField}, ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as comparison_${pivot.valueField} FROM quill_ct GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))`
+        ? `, 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)})`
         : '';
     const joinQuery = itemQueries[1] && comparisonInterval
-        ? `LEFT JOIN quill_ct_cw ct ON qt."${pivot.rowField}" = date_trunc('${dateBucket}', (ct."comparison_${pivot.rowField}" + INTERVAL '${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 date_trunc('${dateBucket}', ${pivot.rowField}) as ${pivot.rowField}, ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as ${pivot.valueField} FROM quill_qt GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))
+  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}
   SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt."${pivot.rowField}"`;
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
 }
-function createAggregationValuePivot(pivot, itemQueries) {
-    let aggregationType = processAggType(pivot.aggregationType);
-    if (pivot.aggregationType === 'count') {
-        aggregationType = 'COUNT';
-    }
+function createAggregationValuePivot(pivot, itemQueries, databaseType) {
+    const valueField = pivot.valueField;
+    const aggregationType = processAggType(pivot.aggregationType);
     if (!pivot.valueField)
         return undefined;
     const compareCTE = itemQueries[1]
         ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
         : '';
     const compareAggregation = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT ${aggregationType}(${pivot.valueField}) as comparison_${pivot.valueField} FROM quill_ct)`
+        ? `, quill_ct_cw as (SELECT ${aggregationType}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField}`, databaseType)} FROM quill_ct)`
         : '';
     const joinQuery = itemQueries[1] ? `CROSS JOIN quill_ct_cw ct` : '';
     return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-      quill_qt_agg AS (SELECT ${aggregationType}(${pivot.valueField}) as ${pivot.valueField} FROM quill_qt)
+      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}`;

package/dist/cjs/utils/report.d.ts

@@ -0,0 +1,7 @@
+import { AdditionalProcessing } from './tableProcessing';
+export declare function fetchReport(reportId: string, client: any, useReportTask?: boolean, filters?: any[], additionalProcessing?: AdditionalProcessing, dateBucket?: string, customFields?: any): Promise<{
+    report: any;
+    error?: string;
+}>;
+export declare const formatRowsFromReport: (report: any) => any;
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,GAAG,EACX,aAAa,UAAO,EACpB,OAAO,GAAE,GAAG,EAAO,EACnB,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,GAAG,GACjB,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAsF1C;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAe/C,CAAC"}

package/dist/cjs/utils/report.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatRowsFromReport = exports.fetchReport = void 0;
+const dashboard_1 = require("./dashboard");
+const dataFetcher_1 = require("./dataFetcher");
+const error_1 = require("./error");
+const errorProcessing_1 = require("./errorProcessing");
+const logging_1 = require("./logging");
+const merge_1 = require("./merge");
+const valueFormatter_1 = require("./valueFormatter");
+async function fetchReport(reportId, client, useReportTask = true, filters = [], additionalProcessing, dateBucket, customFields) {
+    let reportInfo = undefined;
+    let errorMessage = undefined;
+    try {
+        // Remove extra fields on each filter so we don't confuse the backend.
+        const hostedBody = {
+            metadata: {
+                reportId,
+                dashboardItemId: reportId,
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                task: useReportTask ? 'report' : 'item',
+                databaseType: client.databaseType,
+                filters: filters,
+                customFields,
+                additionalProcessing,
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = {
+            id: reportId,
+            filters: filters,
+            useNewNodeSql: true,
+        };
+        const resp = await (0, dataFetcher_1.getData)(client, 'itempost', 'omit', hostedBody, cloudBody, 'POST', 'fetch-data');
+        (0, errorProcessing_1.processFilterErrorList)(resp);
+        const dashboardItem = { ...resp, filtersApplied: filters };
+        if (resp.errorMessage) {
+            throw new error_1.DataLoadError(resp?.errorMessage, { ...resp, useReportTask });
+        }
+        if (resp.compareRows) {
+            (0, merge_1.mergeComparisonRange)(resp);
+        }
+        reportInfo = await (0, dashboard_1.cleanDashboardItem)(dashboardItem, filters, client, dateBucket);
+        if (additionalProcessing) {
+            reportInfo.pagination = additionalProcessing.page;
+            reportInfo.sort = additionalProcessing.sort;
+        }
+    }
+    catch (error) {
+        if (error instanceof error_1.DataLoadError) {
+            if (error.data.useReportTask) {
+                (0, logging_1.internalLog)('USING ITEM AS BACKUP');
+                const { report, error } = await fetchReport(reportId, client, false, filters, additionalProcessing, dateBucket, customFields);
+                reportInfo = report;
+                errorMessage = error;
+            }
+            else {
+                reportInfo = {
+                    ...error.data.data,
+                    id: error.data.data._id,
+                    error: error.message,
+                    adminError: error.data.adminErrorMessage,
+                };
+                errorMessage = error.message;
+            }
+        }
+        else {
+            reportInfo = {
+                id: reportId,
+                rows: [],
+                columns: [],
+            };
+            errorMessage = error.message;
+        }
+    }
+    return { report: reportInfo, error: errorMessage };
+}
+exports.fetchReport = fetchReport;
+const formatRowsFromReport = (report) => {
+    return report.rows.map((row) => {
+        return report.columns.reduce((formattedRow, column) => {
+            // Apply the format function to each field in the row
+            const formattedValue = (0, valueFormatter_1.quillFormat)({
+                value: row[column.field],
+                format: column.format,
+            });
+            formattedRow[column.field] = formattedValue;
+            return formattedRow;
+        }, {});
+    });
+};
+exports.formatRowsFromReport = formatRowsFromReport;

package/dist/cjs/utils/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,kBAAkB,WAAkB,GAAG,oCA6EnD,CAAC;AAEF,eAAO,MAAM,6BAA6B,WAChC,GAAG;;;EA2CZ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,kBAAkB,WAAkB,GAAG,oCA+EnD,CAAC;AAEF,eAAO,MAAM,6BAA6B,WAChC,GAAG;;;EA6CZ,CAAC"}