@quillsql/react 2.12.37 → 2.12.39

package/dist/esm/utils/pivotConstructor.js

@@ -0,0 +1,151 @@
+import { dateFormatOptions } from '../ChartBuilder';
+import { isNumericColumnType } from '../components/ReportBuilder/ast';
+import { getDateString } from '../internals/ReportBuilder/PivotModal';
+import { processColumnName } from './columnProcessing';
+import { getData } from './dataFetcher';
+import { getComparisonInterval } from './dates';
+import { generatePivotQuery } from './queryConstructor';
+import { snakeCaseToTitleCase } from './textProcessing';
+export async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilter, distinctStrings) {
+    if (dateFilter && dateFilter.startDate) {
+        dateFilter.start = dateFilter.startDate;
+        dateFilter.end = dateFilter.endDate;
+        if (dateFilter.comparisonRange && dateFilter.comparisonRange.startDate) {
+            dateFilter.comparisonRange.start = dateFilter.comparisonRange.startDate;
+            dateFilter.comparisonRange.end = dateFilter.comparisonRange.endDate;
+        }
+    }
+    let comparisonInterval = undefined;
+    if (dateFilter && dateFilter.comparisonRange) {
+        comparisonInterval = getComparisonInterval({
+            startDate: dateFilter.comparisonRange.start,
+            endDate: dateFilter.comparisonRange.end,
+        }, dateBucket);
+    }
+    if (pivot.rowField && !pivot.rowFieldType) {
+        const rowColumn = report.columns.find((column) => column.field === pivot.rowField);
+        pivot.rowFieldType = rowColumn?.format || 'string';
+    }
+    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());
+    }
+    if (!report.itemQuery) {
+        return undefined;
+    }
+    const sqlQuery = generatePivotQuery(pivot, report.itemQuery, client.databaseType, comparisonInterval, distinctStrings ? distinctStrings : distinctStringValues, dateBucket);
+    if (sqlQuery && report.rows.length > 0) {
+        const hostedBody = {
+            metadata: {
+                preQueries: [sqlQuery],
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                getCustomFields: false,
+                runQueryConfig: {
+                    overridePost: true,
+                    convertDatatypes: true,
+                },
+                useNewNodeSql: true,
+            },
+        };
+        const cloudBody = { ...hostedBody };
+        const resp = await 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 = processColumnName(key);
+                    if (processedKey !== key) {
+                        row[processedKey] = row[key];
+                        delete row[key];
+                    }
+                });
+            });
+        }
+        const columns = resp.queryResults[0].fields
+            .map((field) => ({
+            field: processColumnName(field.name),
+            label: snakeCaseToTitleCase(processColumnName(field.name.replace('comparison_', 'comparison '))),
+            format: field.name === pivot.rowField
+                ? 'string'
+                : pivot.valueFieldType ?? 'whole_number',
+        }))
+            .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] = getDateString(row[pivot.rowField], undefined, dateBucket);
+            });
+            // add a row for each date in the range that doesn't have a value
+            if (pivot.rowField &&
+                !['string', 'varchar'].includes(pivot.rowFieldType) &&
+                dateFilter) {
+                const dateSet = new Set(rows.map((row) => row[pivot.rowField]));
+                // create a loop that will go through each formatted date and add a row if it doesn't exist going to the current date
+                for (let date = dateFilter.start ?? dateFilter.startDate; date <= dateFilter.end; date = new Date(date.getTime() + 24 * 60 * 60 * 1000)) {
+                    const formattedDate = getDateString(date.toDateString(), undefined, dateBucket);
+                    if (!dateSet.has(formattedDate)) {
+                        const newRow = {};
+                        newRow[pivot.rowField] = formattedDate;
+                        rows.push(newRow);
+                        dateSet.add(formattedDate);
+                    }
+                    // order the rows by the date field
+                    rows.sort((a, b) => {
+                        return new Date(a[pivot.rowField]) < new Date(b[pivot.rowField])
+                            ? -1
+                            : 1;
+                    });
+                }
+            }
+        }
+        if (pivot.sort) {
+            rows.sort((a, b) => {
+                if (pivot.sortDirection === 'ASC') {
+                    if (dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                        // @ts-ignore
+                        return new Date(a[pivot.sortField]) - new Date(b[pivot.sortField]);
+                    }
+                    else if (isNumericColumnType(pivot.sortFieldType)) {
+                        return a[pivot.sortField] - b[pivot.sortField];
+                    }
+                    return a[pivot.sortField].localeCompare(b[pivot.sortField]);
+                }
+                else {
+                    if (dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                        // @ts-ignore
+                        return new Date(b[pivot.sortField]) - new Date(a[pivot.sortField]);
+                    }
+                    else if (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/esm/utils/pivotProcessing.d.ts

@@ -0,0 +1,17 @@
+import { Pivot } from '../internals/ReportBuilder/PivotModal';
+import { ColumnInternal } from '../models/Columns';
+export declare function pivotToSql(pivot: Pivot, query: string, columns: ColumnInternal[]): string;
+export declare function isValidPivot(pivot: Pivot): boolean;
+export declare function getPossiblePivotFieldOptions(columns: ColumnInternal[], uniqueValues: {
+    [field: string]: any;
+}): {
+    rowFields: string[];
+    columnFields: string[];
+    valueFields: string[];
+};
+export declare function cleanPivot(pivot: Pivot, possibleColumns: {
+    rowFields: any;
+    columnFields: any;
+    valueFields: any;
+}): Pivot;
+//# sourceMappingURL=pivotProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"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;AAInD,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;;;;EA4CvC;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/esm/utils/pivotProcessing.js

@@ -0,0 +1,135 @@
+import { isIdColumn } from '../components/ReportBuilder/util';
+import { MAX_PIVOT_UNIQUE_VALUES } from './constants';
+import { DATE_FORMAT_TYPES, NUMBER_FORMAT_TYPES } from './valueFormatter';
+export function pivotToSql(pivot, query, columns) {
+    const processedAggType = pivot.aggregationType?.toLowerCase() === 'average'
+        ? 'avg'
+        : pivot.aggregationType?.toLowerCase();
+    if ((!pivot.rowField && pivot.valueField && processedAggType) ||
+        (!pivot.valueField && pivot.rowField && processedAggType === 'count')) {
+        // table aggregation
+        return `with
+    original_query as (${query})
+    SELECT ${processedAggType}(${pivot.valueField ?? pivot.rowField}) FROM original_query`;
+    }
+    else if (!pivot.columnField &&
+        processedAggType &&
+        pivot.rowField &&
+        pivot.valueField) {
+        // 1-d pivot
+        return `with
+    original_query as (${query})
+    SELECT ${pivot.rowField}, ${processedAggType}(${pivot.valueField}) FROM original_query GROUP BY ${pivot.rowField}`;
+    }
+    else if (pivot.columnField &&
+        pivot.rowField &&
+        pivot.valueField &&
+        processedAggType) {
+        // 2-d pivot
+        const sqlQuery = generateTwoDPivotQuery({ ...pivot, aggregationType: processedAggType }, query, columns);
+        return sqlQuery;
+    }
+    return query;
+}
+function generateTwoDPivotQuery(pivot, query, columns) {
+    const caseWhens = columns.map((column) => {
+        return `${pivot.aggregationType}(
+      CASE WHEN ${pivot.columnField} = '${column.field}' THEN ${pivot.valueField} ELSE 0 END
+    ) AS "${column.field}"`;
+    });
+    return `WITH
+    original_query as (${query})
+  SELECT ${pivot.rowField}, ${caseWhens.join(', ')}
+  FROM original_query GROUP BY ${pivot.rowField}`;
+}
+export function isValidPivot(pivot) {
+    if (pivot.rowField && pivot.aggregationType === 'count') {
+        return true;
+    }
+    else if (pivot.rowField &&
+        pivot.valueField &&
+        pivot.aggregationType &&
+        !pivot.columnField) {
+        return true;
+    }
+    else if (pivot.valueField &&
+        pivot.aggregationType &&
+        !pivot.columnField &&
+        !pivot.rowField) {
+        return true;
+    }
+    else if (pivot.rowField &&
+        pivot.columnField &&
+        pivot.valueField &&
+        pivot.aggregationType) {
+        return true;
+    }
+    return false;
+}
+export function getPossiblePivotFieldOptions(columns, uniqueValues) {
+    const rowFields = [];
+    const columnFields = [];
+    const valueFields = [];
+    for (const column of columns) {
+        // row fields can be dates or strings
+        if (DATE_FORMAT_TYPES.includes(column.format)) {
+            rowFields.push(column.field);
+        }
+        // column fields can be strings
+        if (column.jsType === 'string') {
+            const possibleValues = uniqueValues ? uniqueValues[column.field] : 0;
+            const isNullValuesOnly = !possibleValues ||
+                (Object.keys(possibleValues).length === 1 &&
+                    Object.keys(possibleValues)[0] === 'null');
+            if (!isNullValuesOnly &&
+                Object.keys(possibleValues).length <= MAX_PIVOT_UNIQUE_VALUES) {
+                columnFields.push(column.field);
+            }
+            if (!isNullValuesOnly &&
+                Object.keys(possibleValues).length <= MAX_PIVOT_UNIQUE_VALUES) {
+                rowFields.push(column.field);
+            }
+        }
+        // value fields can be numbers
+        if (NUMBER_FORMAT_TYPES.includes(column.format)) {
+            if (!isIdColumn(column.field)) {
+                valueFields.push(column.field);
+            }
+        }
+    }
+    return {
+        rowFields,
+        columnFields,
+        valueFields,
+    };
+}
+export function cleanPivot(pivot, possibleColumns) {
+    if (possibleColumns.columnFields.length === 0 &&
+        possibleColumns.rowFields.length === 0 &&
+        possibleColumns.valueFields.length === 0) {
+        return pivot;
+    }
+    // Swap row field and column field if the AI put a date field as the column field
+    if (pivot.columnField &&
+        !possibleColumns.columnFields.includes(pivot.columnField)) {
+        if (possibleColumns.rowFields.includes(pivot.columnField)) {
+            const rowField = pivot.rowField;
+            pivot.rowField = pivot.columnField;
+            pivot.columnField = possibleColumns.columnFields.includes(rowField)
+                ? rowField
+                : undefined;
+        }
+    }
+    if (pivot.rowField && !possibleColumns.rowFields.includes(pivot.rowField)) {
+        pivot.rowField = '';
+    }
+    if (pivot.valueField &&
+        !possibleColumns.valueFields.includes(pivot.valueField)) {
+        pivot.valueField = '';
+    }
+    if (pivot.columnField &&
+        !possibleColumns.columnFields.includes(pivot.columnField)) {
+        pivot.columnField = undefined;
+    }
+    return pivot;
+}

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

@@ -0,0 +1,7 @@
+import { Pivot } from '../internals/ReportBuilder/PivotModal';
+export declare function processColumnReference(column: string, databaseType: string, fallbackOnNull?: 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[], databaseType: string, comparisonInterval?: string, distinctStrings?: string[], dateBucket?: string): string | undefined;
+//# sourceMappingURL=queryConstructor.d.ts.map

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

@@ -0,0 +1 @@
+{"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,CACpC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,UAiBxB;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/esm/utils/queryConstructor.js

@@ -0,0 +1,226 @@
+import { isValidPivot } from './pivotProcessing';
+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 replaceBigQuerySpecialCharacters(column) {
+    return column.replaceAll('/', 'quill_forward_slash');
+}
+export function processColumnReference(column, databaseType, fallbackOnNull) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        const columnParts = column.split('.');
+        if (columnParts.length > 1) {
+            return `"${columnParts[0]}"."${columnParts[1]}"`;
+        }
+        if (column === '' && fallbackOnNull) {
+            return `"${fallbackOnNull}"`;
+        }
+        return `"${column}"`;
+    }
+    const columnParts = column.split('.');
+    if (columnParts.length > 1) {
+        return `\`${columnParts[0]}\`.\`${columnParts[1]}\``;
+    }
+    return `\`${replaceBigQuerySpecialCharacters(column)}\``;
+}
+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
+        ? `${processColumnReference(valueField, databaseType)} ELSE 0`
+        : `1 ELSE 0`;
+}
+export 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 '));
+}
+export function generateDistinctQuery(stringFields, query, databaseType) {
+    const distinctQueries = stringFields.map((field) => {
+        return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, ARRAY_AGG(DISTINCT ${field}) AS ${processColumnReference('string_values', databaseType)} FROM querytable`;
+    });
+    const distinctQuery = distinctQueries.join(' UNION ALL ');
+    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
+}
+export function generateMinMaxRangeQueries(columnFields, query, databaseType) {
+    const distinctQueries = columnFields.map((field) => {
+        const wrappedField = ['postgresql', 'snowflake'].includes(databaseType.toLowerCase())
+            ? `"${field}"`
+            : field;
+        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) {
+    if (!isValidPivot(pivot)) {
+        return undefined;
+    }
+    if (pivot.columnField) {
+        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings);
+    }
+    if (pivot.rowField) {
+        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
+    }
+    return createAggregationValuePivot(pivot, itemQueries, databaseType);
+}
+function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues) {
+    if (!pivot || !pivot.columnField) {
+        return undefined;
+    }
+    if (!columnFieldValues) {
+        return undefined;
+    }
+    if (['string', 'varchar'].includes(pivot.rowFieldType) ||
+        !pivot.rowFieldType) {
+        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType);
+    }
+    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket, comparisonInterval);
+}
+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 = 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 ${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.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(rowField, databaseType)}`
+        : '';
+    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}
+  SELECT * FROM quill_qt_cw qt 
+  ${joinQuery}`;
+}
+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 = 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 ${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 ${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 ${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.${processColumnReference(`${rowField}`, databaseType)}`;
+}
+function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
+    if (['string', 'varchar'].includes(pivot.rowFieldType) ||
+        !pivot.rowFieldType) {
+        return create1DStringPivotQuery(pivot, itemQueries, databaseType);
+    }
+    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
+}
+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 ${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.${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}
+  SELECT * FROM quill_qt_cw qt
+  ${joinQuery}`;
+}
+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 ${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 ${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}
+  SELECT * FROM quill_qt_agg qt 
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
+}
+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}(${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}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`${valueField}`, databaseType)} FROM quill_qt)
+      ${compareCTE} ${compareAggregation}
+      SELECT * FROM quill_qt_agg qt 
+      ${joinQuery}`;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAUpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,eAAO,MAAM,YAAY,EAAE,WAkB1B,CAAC;AAEF,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,mBAAmB,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA0G1D;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAkB/C,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAsDb"}