@quillsql/react 2.12.36 → 2.12.37

package/dist/esm/utils/pivotConstructor.js

@@ -1,151 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

@@ -1,132 +0,0 @@
-import { isIdColumn } from '../components/ReportBuilder/util';
-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 <= 36) {
-                columnFields.push(column.field);
-            }
-            if (!isNullValuesOnly && Object.keys(possibleValues).length <= 36) {
-                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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,226 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,CAuG1D;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAkB/C,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAsDb"}