@quillsql/react 2.12.28 → 2.12.29

package/dist/esm/utils/queryConstructor.js

@@ -1,19 +1,69 @@
 import { isValidPivot } from './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) {
+function replaceBigQuerySpecialCharacters(column) {
+    return column.replaceAll('/', 'quill_forward_slash');
+}
+export 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)}\``;
+}
+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')
-        return `"${valueField}" ELSE null`;
+        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`;
+}
+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) {
+export 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;
@@ -28,135 +78,144 @@ export function generateMinMaxRangeQueries(columnFields, query, databaseType) {
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
 }
-export function generatePivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings) {
+export function generatePivotQuery(pivot, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket) {
     if (!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);
 }
-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 valueField = pivot.valueField;
+    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) {
+function createAggregationValuePivot(pivot, itemQueries, databaseType) {
+    const valueField = pivot.valueField;
     let aggregationType = processAggType(pivot.aggregationType);
-    if (pivot.aggregationType === 'count') {
-        aggregationType = 'COUNT';
-    }
     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/esm/utils/queryConstructor.uspec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryConstructor.uspec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryConstructor.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.uspec.ts"],"names":[],"mappings":""}

package/dist/esm/utils/queryConstructor.uspec.js

@@ -0,0 +1,223 @@
+import { generatePivotQuery } from './queryConstructor';
+const removeExtraSpacesAndNewLines = (str) => {
+    return str.replace(/\s+/g, ' ').trim();
+};
+describe('queryConstructor', () => {
+    let default2DPivot = {
+        rowField: 'merchant',
+        rowFieldType: 'string',
+        columnField: 'user',
+        valueField: 'amount',
+        aggregationType: 'sum',
+    };
+    const nonComparisonQuery = ['select * from transactions'];
+    const comparisonQueries = [
+        `select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'`,
+        `select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01'`,
+    ];
+    describe('bigquery - generatePivotQuery', () => {
+        let databaseType = 'bigquery';
+        it('should return a 2d string pivot query', async () => {
+            const query = generatePivotQuery(default2DPivot, nonComparisonQuery, databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_cw AS (SELECT \`merchant\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` 
+      FROM quill_qt GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, nonComparisonQuery, databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS (select * from transactions), 
+      quill_qt_agg as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(CASE WHEN qt.\`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN qt.\`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` FROM quill_query_table qt 
+      GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) 
+      SELECT * FROM quill_qt_agg qt ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+                columnField: undefined,
+            }, nonComparisonQuery, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_agg AS (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(\`amount\`) as \`amount\` FROM quill_qt GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) 
+      SELECT * FROM quill_qt_agg qt ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d string pivot query', async () => {
+            const query = generatePivotQuery({ ...default2DPivot, columnField: undefined }, nonComparisonQuery, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_cw AS (SELECT \`merchant\`, sum(\`amount\`) as \`amount\` 
+      FROM quill_qt GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a value aggregation query', async () => {
+            const query = generatePivotQuery(
+            // @ts-ignore
+            { ...default2DPivot, columnField: undefined, rowField: undefined }, nonComparisonQuery, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_agg AS (SELECT sum(\`amount\`) as \`amount\` FROM quill_qt) SELECT * FROM quill_qt_agg qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d string pivot query with comparison', async () => {
+            const query = generatePivotQuery(default2DPivot, comparisonQueries, databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_qt AS 
+      (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_cw AS (SELECT \`merchant\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` FROM quill_qt GROUP BY \`merchant\`) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT \`merchant\` as \`comparison_merchant\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`comparison_value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`comparison_value2\` FROM quill_ct GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt JOIN quill_ct_cw ct ON ct.\`comparison_merchant\` = qt.\`merchant\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query with comparison', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, comparisonQueries, databaseType, '90', ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(CASE WHEN qt.\`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN qt.\`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` 
+      FROM quill_query_table qt GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`comparison_created_at\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`comparison_value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`comparison_value2\` 
+      FROM quill_ct GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) 
+      SELECT * FROM quill_qt_agg qt 
+      LEFT JOIN quill_ct_cw \`ct\` ON qt.\`created_at\` = TIMESTAMP_TRUNC(TIMESTAMP_ADD(\`ct\`.\`comparison_created_at\`, INTERVAL 90 ), month) 
+      ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d date pivot query with comparison', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+                columnField: undefined,
+            }, comparisonQueries, databaseType, '3 month');
+            const expected = `WITH quill_qt AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg AS (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(\`amount\`) as \`amount\` FROM quill_qt GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`comparison_created_at\`, 
+      sum(\`amount\`) as \`comparison_amount\` FROM quill_ct GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month))
+      SELECT * FROM quill_qt_agg qt LEFT JOIN quill_ct_cw \`ct\` ON qt.\`created_at\` = TIMESTAMP_TRUNC(TIMESTAMP_ADD(\`ct\`.\`comparison_created_at\`, INTERVAL 3 month ), month) 
+      ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d string pivot query with comparison', async () => {
+            const query = generatePivotQuery({ ...default2DPivot, columnField: undefined }, comparisonQueries, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_cw AS (SELECT \`merchant\`, sum(\`amount\`) as \`amount\` FROM quill_qt GROUP BY \`merchant\`) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT \`merchant\` as \`comparison_merchant\`, sum(\`amount\`) as \`comparison_amount\` FROM quill_ct GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt JOIN quill_ct_cw ct ON ct.\`comparison_merchant\` = qt.\`merchant\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a value aggregation query', async () => {
+            const query = generatePivotQuery(
+            // @ts-ignore
+            { ...default2DPivot, columnField: undefined, rowField: undefined }, comparisonQueries, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg AS (SELECT sum(\`amount\`) as \`amount\` FROM quill_qt) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT sum(\`amount\`) as \`comparison_amount\` FROM quill_ct) 
+      SELECT * FROM quill_qt_agg qt CROSS JOIN quill_ct_cw ct`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+    });
+    describe('postgresql - generatePivotQuery', () => {
+        let databaseType = 'postgresql';
+        it('should return a 2d string pivot query', async () => {
+            const query = generatePivotQuery(default2DPivot, ['select * from transactions'], databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_qt AS (select * from transactions),
+      quill_qt_cw AS 
+      (SELECT \"merchant\", sum(CASE WHEN \"user\" = 'value1' THEN \"amount\" ELSE 0 END) AS \"value1\", 
+      sum(CASE WHEN \"user\" = 'value2' THEN \"amount\" ELSE 0 END) AS \"value2\" FROM quill_qt GROUP BY \"merchant\")
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, ['select * from transactions'], databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS (select * from transactions),
+      quill_qt_agg as (SELECT date_trunc('month', \"created_at\") as \"created_at\", 
+      sum(CASE WHEN qt.\"user\" = 'value1' THEN \"amount\" ELSE 0 END) AS \"value1\", 
+      sum(CASE WHEN qt.\"user\" = 'value2' THEN \"amount\" ELSE 0 END) AS \"value2\" 
+      FROM quill_query_table qt 
+      GROUP BY date_trunc('month', \"created_at\"))
+      SELECT * FROM quill_qt_agg qt ORDER BY qt.\"created_at\"`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+                columnField: undefined,
+            }, ['select * from transactions'], databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions),
+      quill_qt_agg AS (SELECT date_trunc('month', \"created_at\") as \"created_at\", sum(\"amount\") as \"amount\"
+      FROM quill_qt 
+      GROUP BY date_trunc('month', \"created_at\"))
+      SELECT * FROM quill_qt_agg qt ORDER BY qt.\"created_at\"`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d string pivot query', async () => {
+            const query = generatePivotQuery({ ...default2DPivot, columnField: undefined }, ['select * from transactions'], databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions),
+      quill_qt_cw AS (SELECT "merchant", sum("amount") as "amount"
+      FROM quill_qt 
+      GROUP BY "merchant")
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a value aggregation query', async () => {
+            const query = generatePivotQuery(
+            // @ts-ignore
+            { ...default2DPivot, columnField: undefined, rowField: undefined }, ['select * from transactions'], databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_agg AS (SELECT sum("amount") as "amount" FROM quill_qt) SELECT * FROM quill_qt_agg qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query with comparison', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, comparisonQueries, databaseType, '90 DAY', ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS 
+      (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg as (SELECT date_trunc('month', \"created_at\") as \"created_at\", 
+      sum(CASE WHEN qt.\"user\" = 'value1' THEN \"amount\" ELSE 0 END) AS \"value1\", 
+      sum(CASE WHEN qt.\"user\" = 'value2' THEN \"amount\" ELSE 0 END) AS \"value2\" FROM quill_query_table qt GROUP BY date_trunc('month', \"created_at\")) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT date_trunc('month', \"created_at\") as \"comparison_created_at\", 
+      sum(CASE WHEN \"user\" = 'value1' THEN \"amount\" ELSE 0 END) AS \"comparison_value1\", 
+      sum(CASE WHEN \"user\" = 'value2' THEN \"amount\" ELSE 0 END) AS \"comparison_value2\" FROM quill_ct GROUP BY date_trunc('month', \"created_at\")) 
+      SELECT * FROM quill_qt_agg qt LEFT JOIN quill_ct_cw \"ct\" ON qt.\"created_at\" = date_trunc('month', (\"ct\".\"comparison_created_at\" + INTERVAL '90 DAY')) 
+      ORDER BY qt.\"created_at\"`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+    });
+});

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

@@ -16,6 +16,7 @@ export declare const getUniqueValuesByColumns: (columns: Column[], query: string
         [value: string]: boolean;
     };
 } | null>;
+export declare const getCountsByColumns: (columns: Column[], query: string, client: any, customFields: any[]) => Promise<Column[]>;
 export declare const getDateRangeByColumns: (columns: Column[], query: string, client: any, customFields: any[]) => Promise<{
     [column: string]: {
         dateRange: {

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

@@ -1 +1 @@
-{"version":3,"file":"tableProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/tableProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAS3C,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,IAAI,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD;AAED,eAAO,MAAM,cAAc,YAChB,MAAM,EAAE,qBACE,MAAM,EAAE,KAC1B,OAUF,CAAC;AAEF,eAAO,MAAM,wBAAwB,YAC1B,MAAM,EAAE,SACV,MAAM,QACP,GAAG,UACD,GAAG,gBACG,GAAG,EAAE;;;;SA6DpB,CAAC;AAkDF,eAAO,MAAM,qBAAqB,YACvB,MAAM,EAAE,SACV,MAAM,UACL,GAAG,gBACG,GAAG,EAAE;;mBAEY;YAAE,KAAK,EAAE,IAAI,CAAC;YAAC,GAAG,EAAE,IAAI,CAAA;SAAE;;SAc1D,CAAC;AAqDF,eAAO,MAAM,gBAAgB,WACnB,WAAW,UACX,GAAG,eACE,GAAG,YACN,GAAG,iBACE,GAAG;;EA4CnB,CAAC"}
+{"version":3,"file":"tableProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/tableProcessing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAW3C,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5C,IAAI,CAAC,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACrD;AAED,eAAO,MAAM,cAAc,YAChB,MAAM,EAAE,qBACE,MAAM,EAAE,KAC1B,OAUF,CAAC;AAEF,eAAO,MAAM,wBAAwB,YAC1B,MAAM,EAAE,SACV,MAAM,QACP,GAAG,UACD,GAAG,gBACG,GAAG,EAAE;;;;SAiEpB,CAAC;AAEF,eAAO,MAAM,kBAAkB,YACpB,MAAM,EAAE,SACV,MAAM,UACL,GAAG,gBACG,GAAG,EAAE,KAClB,QAAQ,MAAM,EAAE,CA2ClB,CAAC;AAkDF,eAAO,MAAM,qBAAqB,YACvB,MAAM,EAAE,SACV,MAAM,UACL,GAAG,gBACG,GAAG,EAAE;;mBAEY;YAAE,KAAK,EAAE,IAAI,CAAC;YAAC,GAAG,EAAE,IAAI,CAAA;SAAE;;SAiB1D,CAAC;AA2DF,eAAO,MAAM,gBAAgB,WACnB,WAAW,UACX,GAAG,eACE,GAAG,YACN,GAAG,iBACE,GAAG;;EA4CnB,CAAC"}

package/dist/esm/utils/tableProcessing.js

@@ -1,7 +1,8 @@
 import { getData } from './dataFetcher';
+import { parseDateByDatabaseType } from './dates';
 import { processFilterErrorList } from './errorProcessing';
 import { mergeComparisonRange } from './merge';
-import { generateDistinctQuery, generateMinMaxRangeQueries, } from './queryConstructor';
+import { generateCountQuery, generateDistinctQuery, generateMinMaxRangeQueries, } from './queryConstructor';
 export const hasColumnAlias = (columns, referencedColumns) => {
     if (!referencedColumns) {
         return true;
@@ -48,7 +49,7 @@ export const getUniqueValuesByColumns = async (columns, query, rows, client, cus
         }
     }
     else {
-        const distinctValueQuery = generateDistinctQuery(stringNames, query);
+        const distinctValueQuery = generateDistinctQuery(stringNames, query, client.databaseType);
         const distinctStrings = await fetchDistinctStrings(distinctValueQuery, client, customFields);
         if (!distinctStrings) {
             return {};
@@ -59,6 +60,39 @@ export const getUniqueValuesByColumns = async (columns, query, rows, client, cus
     }
     return uniqueValues;
 };
+export const getCountsByColumns = async (columns, query, client, customFields) => {
+    const stringNames = columns.map((column) => column.field);
+    const countQuery = generateCountQuery(stringNames, query, client.databaseType);
+    try {
+        const hostedBody = {
+            metadata: {
+                query: countQuery,
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                customFieldsByTable: customFields,
+            },
+        };
+        const cloudBody = { countQuery };
+        const data = await getData(client, 'dashquery', 'same-origin', hostedBody, cloudBody);
+        if (data.errorMessage) {
+            return columns;
+        }
+        const results = data.rows.map((columnInfo) => {
+            return { field: columnInfo.field, count: columnInfo.count };
+        });
+        const filteredColumns = columns.filter((column) => {
+            const columnInfo = results.find((result) => result.field === column.field);
+            return columnInfo.count <= 50;
+        });
+        return filteredColumns;
+    }
+    catch (e) {
+        console.error(e);
+        return columns;
+    }
+};
 const fetchDistinctStrings = async (query, client, customFields) => {
     try {
         const hostedBody = {
@@ -95,7 +129,9 @@ const fetchDistinctStrings = async (query, client, customFields) => {
     }
 };
 export const getDateRangeByColumns = async (columns, query, client, customFields) => {
-    const columnNames = columns.map((column) => column.field);
+    const columnNames = columns.map(
+    // @ts-ignore
+    (column) => column.field || column.name);
     const distinctValueQuery = generateMinMaxRangeQueries(columnNames, query, client.databaseType);
     const dateRanges = await fetchDateRanges(distinctValueQuery, client, customFields);
     return dateRanges;
@@ -120,8 +156,8 @@ const fetchDateRanges = async (query, client, customFields) => {
         const results = data.rows.reduce((acc, currentValue) => {
             acc[currentValue.field] = {
                 dateRange: {
-                    start: new Date(currentValue.min_range),
-                    end: new Date(currentValue.max_range),
+                    start: parseDateByDatabaseType(currentValue.min_range, client.databaseType),
+                    end: parseDateByDatabaseType(currentValue.max_range, client.databaseType),
                 },
             };
             return acc;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/react",
-  "version": "2.12.28",
+  "version": "2.12.29",
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",

package/dist/cjs/internals/ReportBuilder/PivotModal.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=PivotModal.spec.d.ts.map

package/dist/cjs/internals/ReportBuilder/PivotModal.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PivotModal.spec.d.ts","sourceRoot":"","sources":["../../../../src/internals/ReportBuilder/PivotModal.spec.ts"],"names":[],"mappings":""}