@quillsql/react 2.15.17 → 2.16.0

package/dist/index.cjs

@@ -646,12 +646,9 @@ var formatPercent = (value) => {
   return formatterPercent.format(Number(value));
 };
 var _getUTCDateHelper = (value, fmt) => {
-  if (value === null || value === void 0) {
-    return "-";
-  }
   const parsedDate = (0, import_date_fns.parse)(value, fmt, /* @__PURE__ */ new Date());
   const utcDate = (0, import_date_fns.isValid)(parsedDate) ? (0, import_date_fns_tz.utcToZonedTime)(parsedDate, "UTC") : (0, import_date_fns_tz.utcToZonedTime)(new Date(value), "UTC");
-  if (!(0, import_date_fns.isValid)(utcDate)) return "-";
+  if (!(0, import_date_fns.isValid)(utcDate)) return value;
   return (0, import_date_fns.format)(utcDate, fmt);
 };
 var format_YYYY = (value) => _getUTCDateHelper(value, "yyyy");
@@ -662,11 +659,8 @@ var format_MMM_dd_yyyy = (value) => {
   return _getUTCDateHelper(value, "dd MMM yyyy");
 };
 var format_MMM_d_MMM_d = (value, dateRange, databaseType) => {
-  if (value === null || value === void 0) {
-    return "-";
-  }
   const utcDate = (0, import_date_fns.parseISO)(value.split("T")[0]);
-  if (!(0, import_date_fns.isValid)(utcDate)) return "-";
+  if (!(0, import_date_fns.isValid)(utcDate)) return "Invalid date";
   let weekStartsOn = 1;
   if (databaseType && ["mssql"].includes(databaseType)) {
     weekStartsOn = 0;
@@ -697,21 +691,15 @@ var format_MMM_d_MMM_d = (value, dateRange, databaseType) => {
   }
 };
 var format_MMM_dd_hh_mm_ap_pm = (value) => {
-  if (value === null || value === void 0) {
-    return "-";
-  }
   const utcDate = (0, import_date_fns_tz.utcToZonedTime)(new Date(value), "UTC");
-  if (!(0, import_date_fns.isValid)(utcDate)) return "-";
+  if (!(0, import_date_fns.isValid)(utcDate)) return "Invalid date";
   const formatStr = utcDate.getMinutes() === 0 ? "MMM do h a" : "MMM do h:mm a";
   const res = (0, import_date_fns.format)(utcDate, formatStr);
   return res.slice(0, -2) + res.slice(-2).toLowerCase();
 };
 var format_wo_yyyy = (value) => {
-  if (value === null || value === void 0) {
-    return "-";
-  }
   const utcDate = (0, import_date_fns_tz.utcToZonedTime)(new Date(value), "UTC");
-  if (!(0, import_date_fns.isValid)(utcDate)) return "-";
+  if (!(0, import_date_fns.isValid)(utcDate)) return "Invalid date";
   return `${(0, import_date_fns.getWeek)(utcDate)},${utcDate.getFullYear()}`;
 };
 function parseNumber(value) {
@@ -14793,21 +14781,6 @@ function isDateFormat(xAxisFormat) {
   const isDate = DATE_FORMATS.includes(xAxisFormat);
   return isDate;
 }
-function getComparisonInterval(comparisonRange, dateBucket) {
-  const dayCount = (0, import_date_fns5.differenceInDays)(
-    comparisonRange.endDate,
-    comparisonRange.startDate
-  );
-  if (!isNaN(dayCount)) {
-    if (dateBucket === "month") {
-      return Math.floor(dayCount / 30) + " month";
-    } else if (dateBucket === "year") {
-      return Math.floor(dayCount / 365) + " year";
-    } else {
-      return dayCount + " day";
-    }
-  }
-}
 function getDateBucketFromRange(dateRange) {
   const difference = (0, import_date_fns5.differenceInDays)(dateRange.end, dateRange.start);
   if (difference < 14) {
@@ -16621,439 +16594,854 @@ function parseValueFromBigQueryDates(rows, columns) {
   });
 }
 
-// src/utils/merge.ts
-var import_date_fns7 = require("date-fns");
-var import_date_fns_tz2 = require("date-fns-tz");
-function mergeComparisonRange(resp) {
-  if (resp.chartType === "table") return resp;
-  const compRows = resp.compareRows;
-  if (!compRows) return resp;
-  const newRows = resp.rows.map((row, i) => {
-    if (i < compRows.length) {
-      const compRow = compRows[i];
-      const newRow = { ...row };
-      for (const [key, value] of Object.entries(compRow)) {
-        newRow[`comparison_${key}`] = value;
-      }
-      return newRow;
-    }
-    return row;
-  });
-  return { ...resp, rows: newRows };
-}
-function dateAdder(date, interval2) {
-  const match = interval2.match(/^(\d+)\s+(day|month|year)$/);
-  if (!match) {
-    throw new Error(`Invalid interval format: ${interval2}`);
-  }
-  const [, valueStr, unit] = match;
-  if (!valueStr || !unit) {
-    throw new Error("Could not parse interval");
-  }
-  const value = parseInt(valueStr, 10);
-  const parsedDate = typeof date === "string" ? new Date(date) : date;
-  switch (unit) {
-    case "day":
-      return (0, import_date_fns7.add)(parsedDate, { days: value });
-    case "month":
-      return (0, import_date_fns7.add)(parsedDate, { months: value });
-    case "year":
-      return (0, import_date_fns7.add)(parsedDate, { years: value });
-    default:
-      throw new Error(`Unsupported interval unit: ${unit}`);
-  }
-}
-function dateTrunc(date, granularity = "day", databaseType) {
-  const weekStartsOn = databaseType === "mssql" ? 0 : 1;
-  const timeZone = "UTC";
-  const zonedDate = (0, import_date_fns_tz2.utcToZonedTime)(date, timeZone);
-  switch (granularity.toLowerCase()) {
-    case "week":
-      return (0, import_date_fns7.startOfWeek)(zonedDate, { weekStartsOn });
-    case "month":
-      return (0, import_date_fns7.startOfMonth)(zonedDate);
-    case "day":
-      return (0, import_date_fns7.startOfDay)(zonedDate);
-    case "year":
-      return (0, import_date_fns7.startOfYear)(zonedDate);
-    default:
-      throw new Error(`Unsupported granularity: ${granularity}`);
-  }
-}
-function mergeComparisonPivotColumns({
-  pivot,
-  rows,
-  compRows
-}) {
-  if (!compRows || !compRows.length) return rows;
-  const mappedCompRows = compRows.filter((compRow) => compRow.name !== pivot.rowField).map((compRow) => ({ ...compRow, name: `comparison_${compRow.name}` }));
-  return rows.concat(mappedCompRows);
-}
-function mergeComparisonPivotRows({
+// src/utils/pivotConstructor.ts
+async function generatePivotWithSQL({
   pivot,
-  rows,
-  compRows,
-  databaseType,
+  report,
+  client,
   dateBucket,
-  comparisonInterval,
-  columnFieldValues
+  dateFilter,
+  distinctStrings,
+  dashboardName,
+  tenants,
+  additionalProcessing,
+  pivotQuery,
+  comparisonPivotQuery,
+  getPivotRowCount = true,
+  caller,
+  getToken
 }) {
-  if (!compRows || !compRows.length) return rows;
-  if (pivot.columnField && columnFieldValues && columnFieldValues.length > 0) {
-    return merge2DPivotRows(
-      pivot,
-      rows,
-      compRows,
-      columnFieldValues,
-      databaseType,
-      dateBucket,
-      comparisonInterval
-    );
-  }
-  if (pivot.rowField) {
-    return merge1DPivotRows(
-      pivot,
-      rows,
-      compRows,
-      databaseType,
-      dateBucket,
-      comparisonInterval
-    );
-  }
-  return mergeAggregatedRows(pivot, rows, compRows);
-}
-function merge2DPivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval) {
-  if (!pivot || !pivot.columnField) {
-    return [];
-  }
-  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
-    return merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues);
-  }
-  return merge2DDatePivotRows(
-    pivot,
-    rows,
-    compRows,
-    columnFieldValues,
-    databaseType,
-    dateBucket,
-    comparisonInterval
-  );
-}
-function merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues) {
-  if (!pivot.rowField || !pivot.aggregations?.some((agg) => agg.valueField)) {
-    return rows;
+  const databaseType = client.databaseType || "postgresql";
+  if (!pivot.aggregations?.length && pivot.aggregationType) {
+    pivot.aggregations = [
+      {
+        aggregationType: pivot.aggregationType,
+        valueField: pivot.valueField,
+        valueFieldType: pivot.valueFieldType,
+        valueField2: pivot.valueField2,
+        valueField2Type: pivot.valueField2Type
+      }
+    ];
   }
-  return rows.map((row) => {
-    const matchingCompRow = compRows.find(
-      (compRow) => compRow[pivot.rowField] === row[pivot.rowField]
-    );
-    const comparisonFields = columnFieldValues.reduce(
-      (acc, fieldValue) => {
-        acc[`comparison_${fieldValue}`] = matchingCompRow ? matchingCompRow[fieldValue] || null : null;
-        return acc;
-      },
-      {}
-    );
-    return {
-      ...row,
-      ...comparisonFields
-    };
-  });
-}
-function merge2DDatePivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval) {
-  if (!comparisonInterval || !pivot.rowField) {
-    return rows;
-  }
-  return rows.map((row) => {
-    const rowDate = typeof row[pivot.rowField] === "string" ? new Date(row[pivot.rowField]) : row[pivot.rowField];
-    const truncatedRowDate = dateTrunc(rowDate, dateBucket, databaseType);
-    const matchingCompRow = compRows.find((compRow) => {
-      const comparisonDateWithInterval = dateAdder(
-        compRow[pivot.rowField],
-        comparisonInterval
-      );
-      const truncatedCompRowDate = dateTrunc(
-        comparisonDateWithInterval,
-        dateBucket,
-        databaseType
-      );
-      return truncatedRowDate.toISOString() === truncatedCompRowDate.toISOString();
-    });
-    const comparisonFields = columnFieldValues.reduce(
-      (acc, fieldValue) => {
-        acc[`comparison_${fieldValue}`] = matchingCompRow ? matchingCompRow[fieldValue] || null : null;
-        return acc;
-      },
-      {}
-    );
-    return {
-      ...row,
-      ...comparisonFields
-    };
+  const pivotConfig = {
+    rowField: pivot.rowField,
+    rowFieldType: pivot.rowFieldType,
+    columnField: pivot.columnField,
+    aggregations: pivot.aggregations?.map((agg) => ({
+      aggregationType: agg.aggregationType,
+      valueField: agg.valueField,
+      valueFieldType: agg.valueFieldType
+    }))
+  };
+  const resp = await quillFetch({
+    client,
+    task: "pivot-template",
+    metadata: {
+      clientId: client.clientId,
+      pivot: pivotConfig,
+      itemQuery: report?.queryString,
+      dashboardName,
+      tenants
+    },
+    credentials: "same-origin",
+    getToken
   });
-}
-function merge1DPivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval) {
-  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
-    return merge1DStringPivotRows(pivot, rows, compRows);
+  if (resp.data?.success === false) {
+    throw resp.data.errorMessage;
   }
-  return merge1DDatePivotRows(
-    pivot,
-    rows,
-    compRows,
-    databaseType,
-    dateBucket,
-    comparisonInterval
-  );
-}
-function merge1DStringPivotRows(pivot, rows, compRows) {
-  if (!pivot.rowField || !pivot.valueField) {
-    return rows;
+  const queryResponseRows = resp.data?.rows || resp.queries?.queryResults?.[0]?.rows || [];
+  const queryResponseFields = resp.data?.fields || resp.queries?.queryResults?.[0]?.fields || [];
+  const rowCount = resp.queries?.queryResults?.[1]?.rows?.[0]?.row_count || 0;
+  parseValueFromBigQueryDates(queryResponseRows, queryResponseFields);
+  const responseRows = queryResponseRows;
+  const responseFields = queryResponseFields;
+  const rows = pivot.rowField ? responseRows.map(
+    (row) => !row[pivot.rowField] ? { ...row, [pivot.rowField]: "-" } : row
+  ) : responseRows;
+  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];
+        }
+      });
+    });
   }
-  return rows.map((row) => {
-    const matchingCompRow = compRows.find(
-      (compRow) => compRow[pivot.rowField] === row[pivot.rowField]
-    );
-    let aggregationSuffix = "";
-    if (matchingCompRow && pivot.aggregationType === "percentage") {
-      if (matchingCompRow[`${pivot.valueField}_Percentage`]) {
-        aggregationSuffix = "_Percentage";
-      } else if (matchingCompRow[`${pivot.valueField}_PERCENTAGE`]) {
-        aggregationSuffix = "_PERCENTAGE";
-      } else {
-        aggregationSuffix = "_percentage";
-      }
+  const columns = responseFields?.map((field) => ({
+    field: processColumnName(field.field || field.name),
+    label: snakeCaseToTitleCase(
+      processColumnName(
+        (field.field || field.name).replace("comparison_", "comparison ")
+      )
+    ),
+    format: (field.field || field.name) === pivot.rowField ? "string" : pivot.aggregations?.find(
+      (agg) => agg.valueField === (field.field || field.name) || `${agg.valueField}_percentage` === (field.field || field.name) || !agg.valueField && agg.aggregationType === "percentage" && (field.field || field.name)?.endsWith("percentage")
+    )?.aggregationType === "percentage" ? "percent" : "whole_number",
+    fieldType: field.fieldType,
+    jsType: field.jsType,
+    dataTypeID: field.dataTypeID
+  })).filter(
+    (field, index) => field.field !== "comparison_" + pivot.rowField || index === 0
+  ).sort((a, b) => {
+    if (a.field === pivot.rowField) {
+      return -1;
     }
-    return {
-      ...row,
-      [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow ? matchingCompRow[`${pivot.valueField}${aggregationSuffix}`] : null
-    };
+    if (b.field === pivot.rowField) {
+      return 1;
+    }
+    return 0;
   });
-}
-function merge1DDatePivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval) {
-  if (!comparisonInterval || !pivot.rowField) {
-    return rows;
-  }
-  return rows.map((row) => {
-    const rowDate = typeof row[pivot.rowField] === "string" ? new Date(row[pivot.rowField]) : row[pivot.rowField];
-    const truncatedRowDate = dateTrunc(rowDate, dateBucket, databaseType);
-    const matchingCompRow = compRows.find((compRow) => {
-      const comparisonDateWithInterval = dateAdder(
-        compRow[`${pivot.rowField}`],
-        comparisonInterval
-      );
-      const truncatedCompRowDate = dateTrunc(
-        comparisonDateWithInterval,
+  if (pivot.rowField && !isStringType(pivot.rowFieldType || "")) {
+    rows.forEach((row) => {
+      row.__quillRawDate = typeof row[pivot.rowField || ""] === "object" ? row[pivot.rowField || ""].value : row[pivot.rowField || ""];
+      let value = typeof row[pivot.rowField || ""] === "object" ? row[pivot.rowField || ""].value : row[pivot.rowField || ""];
+      if (dateBucket === "week" && dateFilter?.startDate && dateFilter?.endDate) {
+        const rowDate = new Date(value);
+        if (rowDate < dateFilter.startDate) {
+          value = dateFilter.startDate.toISOString();
+        } else if (rowDate > dateFilter.endDate) {
+          value = dateFilter.endDate.toISOString();
+        }
+      }
+      const dateString = getDateString(
+        value,
+        dateFilter?.startDate && dateFilter?.endDate ? { start: dateFilter.startDate, end: dateFilter.endDate } : void 0,
         dateBucket,
         databaseType
       );
-      return truncatedRowDate.toISOString() === truncatedCompRowDate.toISOString();
+      row[pivot.rowField || ""] = dateString;
     });
-    let aggregationSuffix = "";
-    if (matchingCompRow && pivot.aggregationType === "percentage") {
-      if (matchingCompRow[`${pivot.valueField}_Percentage`]) {
-        aggregationSuffix = "_Percentage";
-      } else if (matchingCompRow[`${pivot.valueField}_PERCENTAGE`]) {
-        aggregationSuffix = "_PERCENTAGE";
-      } else {
-        aggregationSuffix = "_percentage";
+    if (pivot.rowField && pivot.rowFieldType && !isStringType(pivot.rowFieldType) && dateFilter?.startDate && dateFilter?.endDate) {
+      const dateSet = new Set(
+        rows.map((row) => row[pivot.rowField || ""])
+      );
+      for (let date = dateFilter.startDate; date <= dateFilter.endDate; date = new Date(date.getTime() + 24 * 60 * 60 * 1e3)) {
+        const formattedDate = getDateString(
+          date.toISOString(),
+          { start: dateFilter.startDate, end: dateFilter.endDate },
+          dateBucket,
+          databaseType
+        );
+        if (!dateSet.has(formattedDate)) {
+          const newRow = {};
+          newRow[pivot.rowField] = formattedDate;
+          newRow.__quillRawDate = date.toISOString();
+          rows.push(newRow);
+          dateSet.add(formattedDate);
+        }
       }
     }
-    return {
-      ...row,
-      [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow?.[`${pivot.valueField}${aggregationSuffix}`] || null
-    };
+    if (!pivot.sort) {
+      rows.sort((a, b) => {
+        if (a.__quillRawDate < b.__quillRawDate) {
+          return -1;
+        }
+        if (a.__quillRawDate > b.__quillRawDate) {
+          return 1;
+        }
+        return 0;
+      });
+    }
+  }
+  columns?.forEach((column, index) => {
+    if (column.label && ["null", "undefined"].includes(column.label.toLowerCase()) && !pivot.columnField && !pivot.aggregations?.[index]?.valueField && pivot.aggregations?.[index]?.aggregationType === "count") {
+      column.label = "Count";
+    }
+  });
+  const numericColumns = columns?.filter(
+    (column) => column.format === "whole_number" || column.format === "percentage"
+  );
+  rows.forEach((row) => {
+    numericColumns?.forEach((column) => {
+      row[column.field] = row[column.field] ?? 0;
+    });
   });
+  return {
+    rows,
+    columns: columns ?? [],
+    rowCount: rowCount || rows.length,
+    pivotQuery: report?.queryString || "",
+    comparisonPivotQuery: comparisonPivotQuery || ""
+  };
 }
-function mergeAggregatedRows(pivot, rows, compRows) {
-  return rows.map((row, i) => {
-    let aggregationSuffix = "";
-    if (compRows[i] && pivot.aggregationType === "percentage") {
-      if (compRows[i][`${pivot.valueField}_Percentage`]) {
-        aggregationSuffix = "_Percentage";
-      } else if (compRows[i][`${pivot.valueField}_PERCENTAGE`]) {
-        aggregationSuffix = "_PERCENTAGE";
-      } else {
-        aggregationSuffix = "_percentage";
+function generatePivotTableYAxis(pivot, cols, yAxisField) {
+  if (pivot?.aggregationType === "count") {
+    return [
+      {
+        field: pivot.valueField ?? "count",
+        label: yAxisField.label,
+        format: yAxisField.format
       }
+    ];
+  }
+  return [
+    {
+      field: pivot.valueField ?? "count",
+      label: yAxisField.label,
+      format: yAxisField.format
     }
-    const compRow = {
-      [`comparison_${pivot.valueField}${aggregationSuffix}`]: compRows[i]?.[`${pivot.valueField}${aggregationSuffix}`]
-    };
-    return { ...row, ...compRow };
-  });
+  ];
 }
-
-// src/utils/queryConstructor.ts
-function processSingleQuotes(value, databaseType) {
-  if (["postgresql", "snowflake", "clickhouse"].includes(
-    databaseType.toLowerCase()
-  )) {
-    return value.replaceAll("'", "''");
+function generatePivotTitle(pivot) {
+  if (pivot.rowField && !pivot.valueField && pivot.aggregations?.[0]) {
+    return snakeAndCamelCaseToTitleCase(
+      `${pivot.aggregations[0].aggregationType} of ${pivot.rowField}${pivot.columnField ? ` by ${pivot.columnField}` : ""}
+      `
+    );
+  } else if (!pivot.rowField && pivot.aggregations?.[0]?.valueField) {
+    return snakeAndCamelCaseToTitleCase(
+      `${pivot.aggregations[0].aggregationType} of ${pivot.aggregations[0].valueField}
+      `
+    );
   }
-  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");
+  return snakeAndCamelCaseToTitleCase(
+    `${pivot.aggregations?.[0]?.aggregationType ?? "Aggregation"} of ${pivot.aggregations?.[0]?.valueField ?? "value"}${pivot.rowField ? ` by ${pivot.rowField}` : ""}${pivot.columnField ? ` and ${pivot.columnField}` : ""}`
+  );
 }
-function processColumnReference(column, databaseType, fallbackOnNull, isColumnFieldAlias, isValueFieldAlias) {
-  switch (databaseType.toLowerCase()) {
-    case "postgresql":
-    case "clickhouse": {
-      if (column === "") {
-        return fallbackOnNull ? `"${fallbackOnNull}"` : `"_"`;
-      }
-      if (isColumnFieldAlias) {
-        return `"${column.replaceAll('"', "")}"`;
-      }
-      const columnParts = column.split(".");
-      if (columnParts.length > 1) {
-        return `"` + columnParts.map((part) => part.replaceAll('"', "")).join('"."') + `"`;
-      }
-      return `"${column.replaceAll('"', "")}"`;
-    }
-    case "mysql": {
-      if (column === "") {
-        return fallbackOnNull ? `${fallbackOnNull}` : "_";
-      }
-      if (isColumnFieldAlias) {
-        return `\`${column.replaceAll(`\``, "").replaceAll(`"`, "")}\``;
-      }
-      const columnParts = column.split(".");
-      if (columnParts.length > 1) {
-        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
-      }
-      return `\`${column.replaceAll(`\``, "")}\``;
-    }
-    case "snowflake": {
-      if (column === "") {
-        return fallbackOnNull ? `${fallbackOnNull}` : "_";
-      }
-      if (isColumnFieldAlias) {
-        return `"${column.replaceAll('"', "")}"`;
-      }
-      if (isValueFieldAlias) {
-        const cleanedColumn = column.replaceAll(")", "").replaceAll("(", "_");
-        return `${cleanedColumn}`;
-      }
-      return column;
-    }
-    case "bigquery": {
-      if (column === "") {
-        return fallbackOnNull ? `\`${fallbackOnNull}\`` : "`_`";
-      }
-      if (isColumnFieldAlias) {
-        return `\`${replaceBigQuerySpecialCharacters(column.replaceAll("`", ""))}\``;
-      }
-      const columnParts = column.split(".");
-      if (columnParts.length > 1) {
-        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
-      }
-      return `\`${replaceBigQuerySpecialCharacters(column.replaceAll("`", ""))}\``;
-    }
-    case "mssql": {
-      if (column === "") {
-        return fallbackOnNull ? `[${fallbackOnNull}]` : `[_]`;
-      }
-      if (isColumnFieldAlias) {
-        return `[${column.replaceAll("]", "").replaceAll("[", "")}]`;
-      }
-      const columnParts = column.split(".");
-      if (columnParts.length > 1) {
-        return `[` + columnParts.map((part) => part.replaceAll("]", "").replaceAll("[", "")).join("].[`") + `]`;
-      }
-      return `[${column.replaceAll("]", "").replaceAll("[", "")}]`;
+async function generatePivotTable({
+  pivot,
+  dateBucket,
+  dateFilter,
+  report,
+  client,
+  getToken,
+  eventTracking,
+  uniqueValues,
+  dashboardName,
+  tenants,
+  additionalProcessing,
+  caller,
+  pivotQuery
+}) {
+  try {
+    if (report && client) {
+      const pivotTable = await generatePivotWithSQL({
+        pivotQuery,
+        pivot,
+        report,
+        client,
+        dateBucket,
+        dateFilter,
+        dashboardName,
+        tenants,
+        additionalProcessing,
+        caller,
+        getToken
+      });
+      return pivotTable;
     }
-    case "databricks": {
-      if (column === "") {
-        return fallbackOnNull ? `[${fallbackOnNull}]` : `_`;
-      }
-      if (isColumnFieldAlias) {
-        return `\`${column.replaceAll(`\``, "").replaceAll(`"`, "")}\``;
-      }
-      const columnParts = column.split(".");
-      if (columnParts.length > 1) {
-        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
+  } catch (e) {
+    eventTracking?.logError?.({
+      type: "bug",
+      // TODO: determine type
+      severity: "high",
+      message: "Error generating pivot table",
+      errorMessage: e.message,
+      errorStack: e.stack,
+      errorData: {
+        caller: "PivotModal",
+        function: "generatePivotTable"
       }
-      return `\`${column.replaceAll(`\``, "")}\``;
-    }
-    default:
-      return column;
+    });
+    throw Error(`Failed to generate pivot table with SQL: ${e}`);
   }
+  throw Error("Failed to generate pivot table: invalid report");
 }
-function replaceSpacesWithUnderscores(column) {
-  return column.replaceAll(" ", "_");
-}
-function processInterval(interval2, rowField, databaseType) {
-  if (["postgresql", "snowflake", "clickhouse"].includes(
-    databaseType.toLowerCase()
-  )) {
-    return `(${processColumnReference(rowField, databaseType)} + INTERVAL '${interval2}')`;
-  } else if (databaseType.toLowerCase() === "mysql") {
-    return `(${processColumnReference(rowField, databaseType)} + INTERVAL ${interval2})`;
+
+// src/utils/paginationProcessing.ts
+var DEFAULT_PAGINATION = {
+  page: 0,
+  rowsPerPage: 10,
+  rowsPerRequest: 600
+};
+var DEFAULT_TABLE_PAGINATION = {
+  page: 0,
+  rowsPerPage: 10,
+  rowsPerRequest: 50
+};
+function shouldFetchMore(pagination, page, maxPage, currentRowCount) {
+  if (!pagination || currentRowCount && currentRowCount >= pagination.rowsPerPage * (page + 1)) {
+    return false;
   }
-  return `TIMESTAMP_ADD(${processColumnReference(rowField, databaseType)}, INTERVAL ${interval2} )`;
+  const indexAdjustedPage = page;
+  const pageInterval = Math.floor(
+    indexAdjustedPage * pagination.rowsPerPage / pagination.rowsPerRequest
+  );
+  const indexAdjustedPreviousPage = maxPage;
+  const previousPageInterval = Math.floor(
+    indexAdjustedPreviousPage * pagination.rowsPerPage / pagination.rowsPerRequest
+  );
+  return pageInterval > previousPageInterval;
 }
-function processDateTrunc(dateBucket, rowField, databaseType, comparisonInterval) {
-  const dateField = comparisonInterval ? processInterval(comparisonInterval, rowField, databaseType) : processColumnReference(rowField, databaseType);
-  if (["postgresql", "snowflake"].includes(databaseType.toLowerCase())) {
-    return `date_trunc('${dateBucket}', ${dateField})`;
-  }
-  if (["clickhouse"].includes(databaseType.toLowerCase())) {
-    return `dateTrunc('${dateBucket}', ${dateField})`;
-  }
-  if (["databricks"].includes(databaseType.toLowerCase())) {
-    return `DATE_TRUNC('${dateBucket}', ${dateField})`;
-  }
-  if (["mysql"].includes(databaseType.toLowerCase())) {
-    switch (dateBucket.toLowerCase()) {
-      case "year":
-        return `DATE_FORMAT(${dateField}, '%Y-01-01 00:00:00')`;
-      case "month":
-        return `DATE_FORMAT(${dateField}, '%Y-%m-01 00:00:00')`;
-      case "week":
-        return `DATE_FORMAT(${dateField}, '%Y-%U-1 00:00:00')`;
-      case "day":
-      default:
-        return `DATE(${dateField})`;
-    }
-  }
-  if (["mssql"].includes(databaseType.toLowerCase())) {
-    return `DATETRUNC(${dateBucket}, ${dateField})`;
+function shouldSortInMemory(pagination, rowCount) {
+  if (!rowCount || rowCount < pagination.rowsPerRequest) {
+    return true;
   }
-  return `TIMESTAMP_TRUNC(${dateField}, ${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`;
+  return false;
 }
-function generateCountQuery(fields, query, databaseType) {
-  let countQuery = [];
-  let cteQuery = `WITH querytable AS (${query.replace(";", "")}) `;
-  let cte = [];
-  switch (databaseType.toLowerCase()) {
-    case "mysql":
-      cte = fields.map((field, index) => {
-        return `, distinct_cte_${index} AS (SELECT DISTINCT ${processColumnReference(field, databaseType, void 0, true)} FROM querytable LIMIT ${MAX_PIVOT_UNIQUE_VALUES + 1})`;
-      });
-      countQuery = fields.map((field, index) => {
-        return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, COUNT(*) AS ${processColumnReference("count", databaseType)} FROM distinct_cte_${index}`;
-      });
-      cteQuery += cte.join(" ");
-      break;
-    default:
-      countQuery = fields.map((field) => {
-        return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, COUNT(DISTINCT ${processColumnReference(field, databaseType, void 0, true)}) AS ${processColumnReference("count", databaseType)} FROM querytable`;
-      });
+
+// src/utils/dashboard.ts
+var defaultDashboardItem = {
+  id: "",
+  name: "",
+  dashboardName: "",
+  rows: [],
+  compareRows: [],
+  columns: [],
+  chartType: "",
+  pivot: null,
+  yAxisFields: [],
+  xAxisLabel: "",
+  xAxisField: "",
+  xAxisFormat: "string",
+  order: -1,
+  filtersApplied: [],
+  queryString: "",
+  rowCount: 0,
+  columnInternal: []
+};
+async function cleanDashboardItem({
+  item,
+  dashboardFilters,
+  getToken,
+  eventTracking,
+  client,
+  dateBucket,
+  additionalProcessing,
+  customFields,
+  skipPivotFetch,
+  tenants
+}) {
+  if (!item) return defaultDashboardItem;
+  if (!item.rows) {
+    return {
+      ...defaultDashboardItem,
+      id: item._id,
+      name: item.name
+    };
   }
-  return cteQuery + countQuery.join(" UNION ALL ");
-}
-function generateDistinctQuery(stringFields, query, databaseType) {
+  const fields = item.fields || [];
+  const columnsWithCustomFields = [...item.columns ?? []];
+  if (item.includeCustomFields && item.rows?.length > 0) {
+    const tables = item.referencedTables ?? [];
+    tables.forEach((table) => {
+      const _customFields = customFields?.[table] ?? [];
+      _customFields.forEach((field) => {
+        const isJsonCustomField = !!field.refColumn;
+        if (item.rows[0][field.field] !== void 0 && !item.columns.some((col) => col.field === field.field)) {
+          const result_field = fields.find((f) => f.name === field.field);
+          const converted_field = convertPostgresColumn(result_field ?? {});
+          columnsWithCustomFields.push({
+            field: field.field,
+            format: converted_field.format,
+            label: snakeAndCamelCaseToTitleCase(field.field),
+            fieldType: converted_field.fieldType,
+            dataTypeID: converted_field.dataTypeID,
+            jsType: converted_field.jsType,
+            inferFormat: isJsonCustomField
+          });
+        }
+      });
+    });
+  }
+  const processedColumns = item.columns.map((col) => {
+    return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
+  });
+  const columnInternal = (item.includeCustomFields ? columnsWithCustomFields : item.columns).map((col) => {
+    const field = item.fields?.find((f) => f.name === col.field);
+    const converted_field = convertPostgresColumn(field ?? {});
+    return {
+      fieldType: converted_field.fieldType,
+      dataTypeID: converted_field.dataTypeID,
+      jsType: converted_field.jsType,
+      ...col,
+      label: snakeAndCamelCaseToTitleCase(col.label)
+    };
+  });
+  let pivotTable;
+  let pivotError;
+  try {
+    const shouldPaginatePivotAsTable = item.chartType === "table";
+    const pivotChartProcessing = {
+      page: DEFAULT_PAGINATION
+    };
+    pivotTable = await getPivotTable(
+      {
+        ...item,
+        pivot: item.pivot && !skipPivotFetch ? {
+          ...item.pivot,
+          aggregations: item.pivot.aggregations ?? [
+            {
+              valueField: item.pivot.valueField,
+              valueFieldType: item.pivot.valueFieldType,
+              valueField2: item.pivot.valueField2,
+              valueField2Type: item.pivot.valueField2Type,
+              aggregationType: item.pivot.aggregationType
+            }
+          ]
+        } : void 0
+      },
+      dashboardFilters,
+      item.dashboardName,
+      getToken,
+      client,
+      eventTracking,
+      dateBucket,
+      shouldPaginatePivotAsTable ? additionalProcessing : pivotChartProcessing,
+      tenants,
+      customFields
+    );
+  } catch (e) {
+    pivotTable = void 0;
+    eventTracking?.logError?.({
+      type: "bug",
+      // TODO: determine type
+      severity: "high",
+      message: "Error fetching pivot table",
+      errorMessage: e.message,
+      errorStack: e.stack,
+      errorData: {
+        caller: "cleanDashboardItem",
+        function: "cleanDashboardItem"
+      }
+    });
+    console.error("Error fetching pivot table", e);
+    pivotError = "Error fetching pivot table";
+  }
+  const referenceLineYValues = [];
+  for (const key in item) {
+    if (key.startsWith("referenceLine_")) {
+      const field = key.slice(14);
+      if (!item[key] || !item[key][0]) continue;
+      const value = Object.values(item[key][0])[0];
+      referenceLineYValues.push({ label: field, query: [value, value] });
+    }
+  }
+  if (item.referenceLines) {
+    for (const referenceLine of item.referenceLines) {
+      if (Array.isArray(referenceLine.query)) {
+        referenceLineYValues.push({
+          label: referenceLine.label,
+          query: referenceLine.query
+        });
+      } else if (referenceLine.query === "") {
+        referenceLineYValues.push({
+          label: referenceLine.label,
+          query: (pivotTable?.rows ? pivotTable.rows : item.rows).map(
+            (row) => Number(row[referenceLine.label]) || 0
+          )
+        });
+      }
+    }
+  }
+  return {
+    id: item._id ?? item.id,
+    name: item.name,
+    dashboardName: item.dashboardName,
+    // section: item.section,
+    rows: item.rows,
+    pivotRows: pivotTable ? pivotTable.rows : void 0,
+    pivotColumns: pivotTable ? pivotTable.columns : void 0,
+    compareRows: item.compareRows,
+    columns: processedColumns.map((column) => {
+      return {
+        field: column.field,
+        format: column.format,
+        label: column.label,
+        inferFormat: column.inferFormat
+      };
+    }),
+    includeCustomFields: item.includeCustomFields,
+    columnInternal,
+    columnsWithCustomFields,
+    chartType: item.chartType,
+    dateField: item.dateField,
+    pivot: pivotError ? void 0 : item.pivot ? {
+      ...item.pivot,
+      aggregations: item.pivot.aggregations ?? [
+        {
+          valueField: item.pivot.valueField,
+          valueFieldType: item.pivot.valueFieldType,
+          valueField2: item.pivot.valueField2,
+          valueField2Type: item.pivot.valueField2Type,
+          aggregationType: item.pivot.aggregationType
+        }
+      ],
+      columnValues: item.distinctStrings
+    } : void 0,
+    yAxisFields: pivotTable ? extractPivotedYAxis(pivotTable, item) : item.yAxisFields,
+    xAxisLabel: item.xAxisLabel,
+    xAxisField: item.xAxisField,
+    xAxisFormat: item.xAxisFormat,
+    order: item.order,
+    filtersApplied: item.filtersApplied,
+    filterMap: item.filterMap,
+    flags: item.flags,
+    rowCount: item.rowCount ? parseInt(item.rowCount) : item.rows.length,
+    pivotRowCount: pivotTable ? pivotTable.rowCount : void 0,
+    template: item.template,
+    sort: item.sort,
+    itemQuery: item.itemQuery,
+    queryString: item.queryString,
+    pivotQuery: pivotTable?.pivotQuery,
+    comparisonPivotQuery: pivotTable?.comparisonPivotQuery,
+    referencedTables: item?.referencedTables || [],
+    referencedColumns: item?.referencedColumns || {},
+    error: item.error ?? pivotError,
+    referenceLineYValues,
+    referenceLines: item.referenceLines
+  };
+}
+async function getPivotTable(report, dashboardFilters, dashboardName, getToken, client, eventTracking, dateBucketInitial, additionalProcessing, tenants, customFields) {
+  if (!report) return void 0;
+  const dateFilter = Object.values(dashboardFilters ?? {}).find(
+    (filter) => filter.filterType === "date_range" || filter.operator === "BETWEEN"
+  );
+  if (dateFilter?.operator === "BETWEEN") {
+    dateFilter.startDate = dateFilter.value[0];
+    dateFilter.endDate = dateFilter.value[1];
+  }
+  const pivot = report?.pivot;
+  const data = report || {};
+  if (pivot && client) {
+    if (report.rowCount === 0 || report.rows.length === 0) {
+      const columns = [];
+      if (pivot.rowField) {
+        columns.push({
+          field: pivot.rowField,
+          label: snakeCaseToTitleCase(processColumnName(pivot.rowField)),
+          format: pivot.rowFieldType || "string",
+          jsType: convertFieldTypeToJSType(pivot.rowFieldType || "string"),
+          fieldType: pivot.rowFieldType || "string",
+          dataTypeID: fieldTypeToDataTypeID(pivot.rowFieldType || "string")
+        });
+      }
+      for (const agg of pivot.aggregations ?? []) {
+        if (agg.valueField) {
+          columns.push({
+            field: agg.valueField,
+            label: snakeCaseToTitleCase(processColumnName(agg.valueField)),
+            //FIXME: valueFieldType is not always the same as the format
+            format: agg.valueFieldType ?? "whole_number",
+            jsType: agg.valueFieldType ?? "number",
+            fieldType: agg.valueFieldType ?? "number",
+            dataTypeID: fieldTypeToDataTypeID(agg.valueFieldType ?? "number")
+          });
+        }
+      }
+      return {
+        rows: [],
+        rowCount: 0,
+        pivotQuery: report.queryString ?? "",
+        columns
+      };
+    }
+    try {
+      let dateBucket = dateBucketInitial;
+      let filterDateRange = void 0;
+      if (dateFilter && dateFilter.startDate && dateFilter.endDate) {
+        filterDateRange = {
+          start: dateFilter.startDate,
+          end: dateFilter.endDate
+        };
+      } else if (report.dateRange) {
+        filterDateRange = report.dateRange;
+      }
+      if (!dateBucket && filterDateRange) {
+        dateBucket = getDateBucketFromRange(filterDateRange);
+      }
+      const pivotTable = await generatePivotWithSQL({
+        pivot,
+        report,
+        client,
+        dateBucket,
+        dateFilter,
+        dashboardName,
+        tenants,
+        additionalProcessing,
+        getToken
+      });
+      return pivotTable;
+    } catch (e) {
+      eventTracking?.logError?.({
+        type: "bug",
+        // TODO: determine type
+        severity: "high",
+        message: "Error fetching pivot table",
+        errorMessage: e.message,
+        errorStack: e.stack,
+        errorData: {
+          caller: "getPivotTable",
+          function: "getPivotTable"
+        }
+      });
+      console.error("Error fetching pivot table", e);
+      throw e;
+    }
+  }
+  return pivot && data.rows ? generatePivotTable({
+    pivot,
+    report,
+    client,
+    uniqueValues: report.distinctStrings,
+    dashboardName,
+    tenants,
+    dateFilter,
+    additionalProcessing,
+    getToken,
+    eventTracking
+  }) : void 0;
+}
+function extractPivotedYAxis(pivotTable, itemInfo, config = void 0) {
+  if (!pivotTable) return itemInfo?.yAxisFields ?? [];
+  const pivot = itemInfo?.pivot || config?.pivot;
+  if (!pivot.columnField && !pivot.rowField) return itemInfo?.yAxisFields ?? [];
+  const yAxisFields = config ? config.yAxisFields : itemInfo?.yAxisFields;
+  return yAxisFields && yAxisFields.length > 0 ? generatePivotTableYAxis(pivot, pivotTable.columns, yAxisFields[0]) : yAxisFields;
+}
+async function getDashboard(dashboardName, client, getToken, tenants, flags) {
+  const { data: resp } = await quillFetch({
+    client,
+    task: "dashboard",
+    metadata: {
+      name: dashboardName,
+      clientId: client.publicKey,
+      databaseType: client.databaseType,
+      useNewNodeSql: true,
+      tenants,
+      flags
+    },
+    getToken
+  });
+  return {
+    ...resp,
+    createdAt: resp.createdAt && new Date(resp.createdAt),
+    dateFilter: resp.dateFilter ? {
+      ...resp.dateFilter,
+      presetOptions: resp.dateFilter.presetOptions?.map(
+        (preset) => ({
+          ...preset,
+          loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
+          loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
+        })
+      ),
+      defaultPresetRanges: resp.dateFilter.defaultPresetRanges?.map(
+        (preset) => ({
+          ...preset,
+          loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
+          loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
+        })
+      )
+    } : void 0
+  };
+}
+
+// src/utils/chartBuilder.ts
+var numberFormatOptions = [
+  "whole_number",
+  "one_decimal_place",
+  "two_decimal_places",
+  "dollar_amount",
+  "dollar_cents",
+  "percentage"
+];
+var dateFormatOptions = [
+  "MMM_yyyy",
+  "MMM_dd",
+  "MMM_dd_yyyy",
+  "MMM_dd_hh:mm_ap_pm",
+  "hh_ap_pm",
+  "date",
+  "timestamptz"
+];
+var NUMBER_OPTIONS = [
+  { value: "whole_number", label: "whole number" },
+  { value: "one_decimal_place", label: "one decimal place" },
+  { value: "two_decimal_places", label: "two decimal places" },
+  { value: "dollar_amount", label: "dollar amount" },
+  { value: "dollar_cents", label: "dollar and cent amount" },
+  { value: "percent", label: "percentage" }
+];
+var DATE_OPTIONS = [
+  { value: "MMM_yyyy", label: "month" },
+  { value: "MMM_dd", label: "day" },
+  { value: "MMM_dd_yyyy", label: "day and year" },
+  { value: "MMM_dd_hh:mm_ap_pm", label: "day and time" },
+  { value: "hh_ap_pm", label: "hour" }
+];
+var ALL_FORMAT_OPTIONS = [
+  ...NUMBER_OPTIONS,
+  ...DATE_OPTIONS,
+  { value: "string", label: "string" }
+];
+function createInitialFormData(columns) {
+  const firstNumberColumn = columns?.find(
+    (col) => numberFormatOptions.includes(col.format)
+  );
+  const firstStringColumn = columns?.find(
+    (col) => !numberFormatOptions.includes(col.format) && !dateFormatOptions.includes(col.format)
+  );
+  const firstDateColumn = columns?.find(
+    (col) => dateFormatOptions.includes(col.format)
+  );
+  const xAxisField = firstStringColumn?.field || firstDateColumn?.field || firstNumberColumn?.field || columns?.[0]?.field || "";
+  const xAxisFormat = firstStringColumn?.format || firstDateColumn?.format || firstNumberColumn?.format || columns?.[0]?.format || "string";
+  const formEmptyState = {
+    name: "",
+    columns: columns.map((col) => {
+      return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
+    }),
+    xAxisField,
+    xAxisFormat,
+    yAxisFields: [
+      {
+        field: firstNumberColumn?.field || columns?.[0]?.field || "",
+        label: "",
+        format: firstNumberColumn?.format || columns?.[0]?.format || "string"
+      }
+    ],
+    xAxisLabel: "",
+    chartType: firstNumberColumn ? "line" : "table",
+    pivot: null,
+    template: true,
+    referenceLines: []
+  };
+  return formEmptyState;
+}
+
+// src/utils/error.ts
+var DataLoadError = class extends Error {
+  data;
+  constructor(message, data) {
+    super(message);
+    this.name = "DataLoadError";
+    this.data = data;
+  }
+};
+
+// src/utils/errorProcessing.ts
+function processFilterErrorList(resp) {
+  if (!resp || !resp.filterErrorList || !Array.isArray(resp.filterErrorList)) {
+    return;
+  }
+}
+
+// src/utils/queryConstructor.ts
+function replaceBigQuerySpecialCharacters(column) {
+  return column.replaceAll("/", "quill_forward_slash");
+}
+function processColumnReference(column, databaseType, fallbackOnNull, isColumnFieldAlias, isValueFieldAlias) {
+  switch (databaseType.toLowerCase()) {
+    case "postgresql":
+    case "clickhouse": {
+      if (column === "") {
+        return fallbackOnNull ? `"${fallbackOnNull}"` : `"_"`;
+      }
+      if (isColumnFieldAlias) {
+        return `"${column.replaceAll('"', "")}"`;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `"` + columnParts.map((part) => part.replaceAll('"', "")).join('"."') + `"`;
+      }
+      return `"${column.replaceAll('"', "")}"`;
+    }
+    case "mysql": {
+      if (column === "") {
+        return fallbackOnNull ? `${fallbackOnNull}` : "_";
+      }
+      if (isColumnFieldAlias) {
+        return `\`${column.replaceAll(`\``, "").replaceAll(`"`, "")}\``;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
+      }
+      return `\`${column.replaceAll(`\``, "")}\``;
+    }
+    case "snowflake": {
+      if (column === "") {
+        return fallbackOnNull ? `${fallbackOnNull}` : "_";
+      }
+      if (isColumnFieldAlias) {
+        return `"${column.replaceAll('"', "")}"`;
+      }
+      if (isValueFieldAlias) {
+        const cleanedColumn = column.replaceAll(")", "").replaceAll("(", "_");
+        return `${cleanedColumn}`;
+      }
+      return column;
+    }
+    case "bigquery": {
+      if (column === "") {
+        return fallbackOnNull ? `\`${fallbackOnNull}\`` : "`_`";
+      }
+      if (isColumnFieldAlias) {
+        return `\`${replaceBigQuerySpecialCharacters(column.replaceAll("`", ""))}\``;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
+      }
+      return `\`${replaceBigQuerySpecialCharacters(column.replaceAll("`", ""))}\``;
+    }
+    case "mssql": {
+      if (column === "") {
+        return fallbackOnNull ? `[${fallbackOnNull}]` : `[_]`;
+      }
+      if (isColumnFieldAlias) {
+        return `[${column.replaceAll("]", "").replaceAll("[", "")}]`;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `[` + columnParts.map((part) => part.replaceAll("]", "").replaceAll("[", "")).join("].[`") + `]`;
+      }
+      return `[${column.replaceAll("]", "").replaceAll("[", "")}]`;
+    }
+    case "databricks": {
+      if (column === "") {
+        return fallbackOnNull ? `[${fallbackOnNull}]` : `_`;
+      }
+      if (isColumnFieldAlias) {
+        return `\`${column.replaceAll(`\``, "").replaceAll(`"`, "")}\``;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
+      }
+      return `\`${column.replaceAll(`\``, "")}\``;
+    }
+    default:
+      return column;
+  }
+}
+function replaceSpacesWithUnderscores(column) {
+  return column.replaceAll(" ", "_");
+}
+function generateCountQuery(fields, query, databaseType) {
+  let countQuery = [];
+  let cteQuery = `WITH querytable AS (${query.replace(";", "")}) `;
+  let cte = [];
+  switch (databaseType.toLowerCase()) {
+    case "mysql":
+      cte = fields.map((field, index) => {
+        return `, distinct_cte_${index} AS (SELECT DISTINCT ${processColumnReference(field, databaseType, void 0, true)} FROM querytable LIMIT ${MAX_PIVOT_UNIQUE_VALUES + 1})`;
+      });
+      countQuery = fields.map((field, index) => {
+        return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, COUNT(*) AS ${processColumnReference("count", databaseType)} FROM distinct_cte_${index}`;
+      });
+      cteQuery += cte.join(" ");
+      break;
+    default:
+      countQuery = fields.map((field) => {
+        return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, COUNT(DISTINCT ${processColumnReference(field, databaseType, void 0, true)}) AS ${processColumnReference("count", databaseType)} FROM querytable`;
+      });
+  }
+  return cteQuery + countQuery.join(" UNION ALL ");
+}
+function generateDistinctQuery(stringFields, query, databaseType) {
   switch (databaseType.toLowerCase()) {
     case "mysql":
       return generateDistinctQueryMySQL(stringFields, query);
@@ -17150,1123 +17538,12 @@ function generateMinMaxDateRangeQueries(columnFields, query, databaseType) {
   const distinctQueries = columnFields.map((field) => {
     const wrappedField = ["postgresql", "clickhouse"].includes(
       databaseType.toLowerCase()
-    ) ? `"${field}"` : field;
-    return `SELECT '${field}' AS field, ${min2}(${wrappedField})${cast} AS min_range, ${max2}(${wrappedField})${cast} AS max_range FROM querytable`;
+    ) ? processColumnReference(field, databaseType) : field;
+    return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, ${min2}(${wrappedField})${cast} AS ${processColumnReference("min_range", databaseType)}, ${max2}(${wrappedField})${cast} AS ${processColumnReference("max_range", databaseType)} FROM querytable`;
   });
   const distinctQuery = distinctQueries.join(" UNION ALL ");
   return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
 }
-function generatePivotQuery(pivot, itemQuery, databaseType, distinctStrings, dateBucket) {
-  if (!isValidPivot(pivot).valid) {
-    return void 0;
-  }
-  if (pivot.columnField && distinctStrings && distinctStrings.length > 0) {
-    return create2DPivotQuery(
-      pivot,
-      itemQuery,
-      databaseType,
-      distinctStrings,
-      dateBucket
-    );
-  }
-  if (pivot.rowField) {
-    return create1DPivotQuery(pivot, itemQuery, dateBucket, databaseType);
-  }
-  return createAggregationValuePivot(pivot, itemQuery, databaseType);
-}
-function create2DPivotQuery(pivot, itemQuery, databaseType, columnFieldValues, dateBucket) {
-  if (!pivot || !pivot.columnField) {
-    return void 0;
-  }
-  if (isStringType(pivot.rowFieldType ?? "") || !pivot.rowFieldType) {
-    return create2DStringPivotQuery(
-      pivot,
-      itemQuery,
-      columnFieldValues,
-      databaseType
-    );
-  }
-  return create2DDatePivotQuery(
-    pivot,
-    itemQuery,
-    columnFieldValues,
-    databaseType,
-    dateBucket
-  );
-}
-function create2DStringPivotQuery(pivot, itemQuery, columnFieldValues, databaseType) {
-  const isValidBaseQuery = itemQuery.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField)
-    return void 0;
-  const rowField = pivot.rowField;
-  if (!pivot.aggregations?.[0]?.valueField && pivot.aggregations?.[0]?.aggregationType !== "count" && !pivot.valueField && pivot.aggregationType !== "count")
-    throw new Error("No value field provided for pivot");
-  if (!pivot.aggregations?.[0]?.aggregationType && !pivot.aggregationType)
-    throw new Error("No aggregation type provided for pivot");
-  const columnField = pivot.columnField;
-  const rowFieldAlias = processColumnReference(
-    rowField,
-    databaseType,
-    void 0,
-    false,
-    true
-  );
-  const columnFieldAlias = processColumnReference(
-    columnField,
-    databaseType,
-    void 0,
-    false,
-    true
-  );
-  let caseWhens = [];
-  let valueAliases = [];
-  const seenAggs = {};
-  pivot.aggregations?.forEach((currentAgg) => {
-    if (seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]) {
-      seenAggs[currentAgg.aggregationType ?? ""][currentAgg.valueField ?? ""] += 1;
-    } else {
-      seenAggs[currentAgg.aggregationType ?? ""] = {
-        ...seenAggs[currentAgg.aggregationType ?? ""],
-        [currentAgg.valueField ?? ""]: 1
-      };
-    }
-    let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]?.toString();
-    if (disambiguationIndex === "1") disambiguationIndex = "";
-    const valueFieldAlias = processColumnReference(
-      currentAgg.valueField || rowField || "count",
-      databaseType,
-      void 0,
-      false,
-      true
-    );
-    const valueAliasSubstring = currentAgg.valueField ? `${processColumnReference(currentAgg.valueField, databaseType, void 0, true)} AS ${valueFieldAlias}` : "";
-    let value2AliasSubstring = "";
-    const disambiguationField = Object.values(seenAggs[currentAgg.aggregationType ?? ""] ?? {}).reduce(
-      (acc, v) => acc + v
-    ) > 1 ? `_${currentAgg.valueField}${disambiguationIndex}` : "";
-    const disambiguation = pivot.aggregations?.length > 1 ? `${disambiguationField}_${disambiguationField ? matchCasing(currentAgg.aggregationType, currentAgg.valueField) : currentAgg.aggregationType}` : "";
-    const valueExpr = currentAgg.valueFieldType === "bool" ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END` : processValueField(
-      currentAgg.aggregationType,
-      databaseType,
-      valueFieldAlias
-    );
-    if (currentAgg.aggregationType === "percentage") {
-      if (!currentAgg.valueField)
-        throw new Error("No value field provided for pivot");
-      const valueField2Alias = processColumnReference(
-        currentAgg.valueField2 ?? currentAgg.valueField,
-        databaseType,
-        void 0,
-        false,
-        true
-      );
-      const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool" ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END` : valueField2Alias;
-      if (currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2) {
-        caseWhens = [
-          ...caseWhens,
-          ...columnFieldValues.map((column) => {
-            return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-              column,
-              databaseType
-            )}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(${value2Expr}), 1) AS ${processColumnReference(
-              column + disambiguation,
-              databaseType,
-              "_",
-              true
-            )}`;
-          })
-        ];
-      } else {
-        value2AliasSubstring = `${processColumnReference(
-          currentAgg.valueField2 ?? currentAgg.valueField,
-          databaseType,
-          void 0,
-          true
-        )} AS ${valueField2Alias}`;
-        caseWhens = [
-          ...caseWhens,
-          ...columnFieldValues.map((column) => {
-            return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-              column,
-              databaseType
-            )}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-              column,
-              databaseType
-            )}' THEN ${value2Expr} END), 1) AS ${processColumnReference(
-              column + disambiguation,
-              databaseType,
-              "_",
-              true
-            )}`;
-          })
-        ];
-      }
-    } else {
-      caseWhens = [
-        ...caseWhens,
-        ...columnFieldValues.map((column) => {
-          return `${processAggType(currentAgg.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-            column,
-            databaseType
-          )}' THEN ${valueExpr} END) AS ${processColumnReference(column + disambiguation, databaseType, "_", true)}`;
-        })
-      ];
-    }
-    if (valueAliasSubstring) valueAliases.push(valueAliasSubstring);
-    if (value2AliasSubstring) valueAliases.push(value2AliasSubstring);
-  });
-  valueAliases = [
-    `${processColumnReference(rowField, databaseType, void 0, true)} AS ${rowFieldAlias}`,
-    ...valueAliases,
-    `${processColumnReference(columnField, databaseType, void 0, true)} AS ${columnFieldAlias}`
-  ];
-  valueAliases = Array.from(new Set(valueAliases));
-  const sortQuery = pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, void 0, true)} ${pivot.sortDirection || ""} ` : "";
-  const pivotQuery = `
-    ,quill_alias AS (
-      SELECT ${valueAliases.length > 0 ? `${valueAliases.join(", ")}` : ""}
-      FROM quill_base_table
-    ),
-    quill_qt_cw AS (
-      SELECT ${rowFieldAlias}
-      ${caseWhens.length > 0 ? `, ${caseWhens.join(", ")}` : ""}
-      FROM quill_alias
-      GROUP BY ${rowFieldAlias}
-    ),
-    quill_base_pivot AS (
-      SELECT ${pivot.rowLimit && databaseType.toLowerCase() === "mssql" ? `TOP ${pivot.rowLimit}` : ""} *
-      FROM quill_qt_cw qt
-      ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== "mssql" ? ` LIMIT ${pivot.rowLimit}` : ""}
-    )
-    SELECT * FROM quill_base_pivot
-  `.replace(/\s+/g, " ").trim();
-  return itemQuery.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/,
-    pivotQuery
-  );
-}
-function create2DDatePivotQuery(pivot, itemQuery, columnFieldValues, databaseType, dateBucket = "month") {
-  const isValidBaseQuery = itemQuery.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery || !pivot.columnField || !pivot.rowField) {
-    return void 0;
-  }
-  if (!pivot.aggregations?.[0]?.valueField && pivot.aggregations?.[0]?.aggregationType !== "count" && !pivot.valueField && pivot.aggregationType !== "count")
-    throw new Error("No value field provided for pivot");
-  if (!pivot.aggregations?.[0]?.aggregationType && !pivot.aggregationType)
-    throw new Error("No aggregation type provided for pivot");
-  const rowField = pivot.rowField;
-  const columnField = pivot.columnField;
-  const rowFieldAlias = processColumnReference(
-    rowField,
-    databaseType,
-    void 0,
-    false,
-    true
-  );
-  const columnFieldAlias = processColumnReference(
-    columnField,
-    databaseType,
-    void 0,
-    false,
-    true
-  );
-  let caseWhens = [];
-  let valueFieldAliases = [];
-  const seenAggs = {};
-  pivot.aggregations?.forEach((currentAgg) => {
-    if (seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]) {
-      seenAggs[currentAgg.aggregationType ?? ""][currentAgg.valueField ?? ""] += 1;
-    } else {
-      seenAggs[currentAgg.aggregationType ?? ""] = {
-        ...seenAggs[currentAgg.aggregationType ?? ""],
-        [currentAgg.valueField ?? ""]: 1
-      };
-    }
-    let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]?.toString();
-    if (disambiguationIndex === "1") disambiguationIndex = "";
-    const valueFieldAlias = processColumnReference(
-      currentAgg.valueField ?? rowField,
-      databaseType,
-      void 0,
-      false,
-      true
-    );
-    const valueAliasSubstring = currentAgg.valueField ? `${processColumnReference(currentAgg.valueField, databaseType, void 0, true)} AS ${valueFieldAlias}` : "";
-    let value2AliasSubstring = "";
-    const disambiguationField = Object.values(seenAggs[currentAgg.aggregationType ?? ""] ?? {}).reduce(
-      (acc, v) => acc + v
-    ) > 1 ? `_${currentAgg.valueField}${disambiguationIndex}` : "";
-    const disambiguation = pivot.aggregations?.length > 1 ? `${disambiguationField}_${disambiguationField ? matchCasing(currentAgg.aggregationType, currentAgg.valueField) : currentAgg.aggregationType}` : "";
-    const valueExpr = currentAgg.valueFieldType === "bool" ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END` : processValueField(
-      currentAgg.aggregationType,
-      databaseType,
-      valueFieldAlias
-    );
-    if (currentAgg.aggregationType === "percentage") {
-      if (!currentAgg.valueField)
-        throw new Error("No value field provided for pivot");
-      const valueField2Alias = processColumnReference(
-        currentAgg.valueField2 ?? currentAgg.valueField,
-        databaseType,
-        void 0,
-        false,
-        true
-      );
-      const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool" ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END` : valueField2Alias;
-      if (currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2) {
-        caseWhens = [
-          ...caseWhens,
-          ...columnFieldValues.map((column) => {
-            return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-              column,
-              databaseType
-            )}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(${value2Expr}), 1) AS ${processColumnReference(
-              column + disambiguation,
-              databaseType,
-              "_",
-              true
-            )}`;
-          })
-        ];
-      } else {
-        value2AliasSubstring = `${processColumnReference(
-          currentAgg.valueField2 ?? currentAgg.valueField,
-          databaseType,
-          void 0,
-          true
-        )} AS ${valueField2Alias}`;
-        caseWhens = [
-          ...caseWhens,
-          ...columnFieldValues.map((column) => {
-            return `CAST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-              column,
-              databaseType
-            )}' THEN ${valueExpr} END) AS FLOAT) / GREATEST(sum(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-              column,
-              databaseType
-            )}' THEN ${value2Expr} END), 1) AS ${processColumnReference(
-              column + disambiguation,
-              databaseType,
-              "_",
-              true
-            )}`;
-          })
-        ];
-      }
-    } else {
-      caseWhens = [
-        ...caseWhens,
-        ...columnFieldValues.map((column) => {
-          return `${processAggType(currentAgg.aggregationType, true)}(CASE WHEN ${columnFieldAlias} = '${processSingleQuotes(
-            column,
-            databaseType
-          )}' THEN ${valueExpr} END) AS ${processColumnReference(column + disambiguation, databaseType, "_", true)}`;
-        })
-      ];
-    }
-    if (valueAliasSubstring) valueFieldAliases.push(valueAliasSubstring);
-    if (value2AliasSubstring) valueFieldAliases.push(value2AliasSubstring);
-  });
-  valueFieldAliases = [
-    `${processColumnReference(rowField, databaseType, void 0, true)} AS ${rowFieldAlias}`,
-    ...valueFieldAliases,
-    `${processColumnReference(columnField, databaseType, void 0, true)} AS ${columnFieldAlias}`
-  ];
-  valueFieldAliases = Array.from(new Set(valueFieldAliases));
-  const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, void 0, true)} ${pivot.sortDirection || ""} ` : ""}`;
-  const pivotQuery = `
-    , quill_alias AS (SELECT ${valueFieldAliases.length > 0 ? `${valueFieldAliases.join(", ")}` : ""} FROM quill_base_table),
-    quill_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${rowFieldAlias}${caseWhens.length > 0 ? `, ${caseWhens.join(", ")}` : ""} FROM quill_alias GROUP BY ${databaseType.toLowerCase() === "clickhouse" ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)}),
-    quill_base_pivot AS (SELECT ${pivot.rowLimit && databaseType.toLowerCase() === "mssql" ? `TOP ${pivot.rowLimit}` : ""} * FROM quill_qt_agg qt
-    ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== "mssql" ? ` LIMIT ${pivot.rowLimit}` : ""})
-    SELECT * FROM quill_base_pivot
-    `.replace(/\s+/g, " ").trim();
-  return itemQuery.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/,
-    pivotQuery
-  );
-}
-function create1DPivotQuery(pivot, itemQuery, dateBucket = "month", databaseType) {
-  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
-    return create1DStringPivotQuery(pivot, itemQuery, databaseType);
-  }
-  return create1DDatePivotQuery(pivot, itemQuery, dateBucket, databaseType);
-}
-function create1DStringPivotQuery(pivot, itemQuery, databaseType) {
-  const isValidBaseQuery = itemQuery.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery) return void 0;
-  const rowField = pivot.rowField;
-  const rowAlias = processColumnReference(
-    rowField,
-    databaseType,
-    void 0,
-    true
-  );
-  let quillAggSelects = [rowAlias];
-  let valueFieldAliases = [];
-  const seenAggs = {};
-  pivot.aggregations?.forEach((currentAgg) => {
-    if (!currentAgg.valueField) currentAgg.valueField = void 0;
-    if (seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]) {
-      seenAggs[currentAgg.aggregationType ?? ""][currentAgg.valueField ?? ""] += 1;
-    } else {
-      seenAggs[currentAgg.aggregationType ?? ""] = {
-        ...seenAggs[currentAgg.aggregationType ?? ""],
-        [currentAgg.valueField ?? ""]: 1
-      };
-    }
-    let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]?.toString() ?? "";
-    if (disambiguationIndex === "1") disambiguationIndex = "";
-    const valueFieldAlias = processColumnReference(
-      currentAgg.valueField || rowField || "count",
-      databaseType,
-      void 0,
-      false,
-      true
-    );
-    const valueAliasSubstring = currentAgg.valueField ? `${processColumnReference(currentAgg.valueField, databaseType, void 0, true)} AS ${valueFieldAlias}` : "";
-    let value2AliasSubstring = "";
-    const disambiguation = pivot.aggregations?.length > 1 ? `${disambiguationIndex}` + (currentAgg.aggregationType !== "count" ? `_${currentAgg.aggregationType}` : "") : "";
-    let valueExpr = !currentAgg.valueField ? "*" : valueFieldAlias;
-    if (currentAgg.valueFieldType === "bool") {
-      valueExpr = `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`;
-    }
-    if (currentAgg.aggregationType === "percentage") {
-      let countPercentage = false;
-      if (!currentAgg.valueField) {
-        countPercentage = true;
-      }
-      const valueField2Alias = processColumnReference(
-        currentAgg.valueField2 ?? currentAgg.valueField ?? "count",
-        databaseType,
-        void 0,
-        false,
-        true
-      );
-      let value2Expr = valueField2Alias;
-      if ((currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool") {
-        value2Expr = `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`;
-      }
-      value2AliasSubstring = currentAgg.valueField2 && currentAgg.valueField !== currentAgg.valueField2 ? `${processColumnReference(currentAgg.valueField2, databaseType, void 0, true)} AS ${valueField2Alias}` : "";
-      const percentageExpr = countPercentage ? "CAST(COUNT(*) AS FLOAT) / (SELECT COUNT(*) FROM quill_base_table)" : currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2 ? `CAST(sum(${valueExpr}) AS FLOAT) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool" ? "COUNT(*)" : "SUM(sum(" + valueExpr + ")) OVER ()"}` : `CAST(sum(${valueExpr}) AS FLOAT) / GREATEST(sum(${value2Expr}), 1)`;
-      quillAggSelects = [
-        ...quillAggSelects,
-        `${percentageExpr} as ${processColumnReference(
-          `${currentAgg.valueField ?? (disambiguation ? "count" : "percentage")}${disambiguation}`,
-          databaseType,
-          void 0,
-          false,
-          true
-        )}`
-      ];
-    } else {
-      quillAggSelects = [
-        ...quillAggSelects,
-        `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference(
-          (currentAgg.valueField || "count") + disambiguation,
-          databaseType
-        )}`
-      ];
-    }
-    if (valueAliasSubstring) valueFieldAliases.push(valueAliasSubstring);
-    if (value2AliasSubstring) valueFieldAliases.push(value2AliasSubstring);
-  });
-  valueFieldAliases = Array.from(new Set(valueFieldAliases));
-  const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, void 0, true)} ${pivot.sortDirection || ""} ` : ""}`;
-  const pivotQuery = `, quill_alias AS (
-       SELECT ${processColumnReference(`${rowField}`, databaseType, void 0, true)} AS ${rowAlias}${valueFieldAliases.length > 0 ? `, ${valueFieldAliases.join(", ")}` : ""}
-       FROM quill_base_table
-     ),
-     quill_qt_cw AS (
-       SELECT ${quillAggSelects.join(", ")} FROM quill_alias GROUP BY ${rowAlias}
-     ),
-     quill_base_pivot AS (
-       SELECT ${pivot.rowLimit && databaseType.toLowerCase() === "mssql" ? `TOP ${pivot.rowLimit}` : ""} *
-       FROM quill_qt_cw qt ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== "mssql" ? ` LIMIT ${pivot.rowLimit}` : ""}
-     )
-     SELECT * FROM quill_base_pivot`.replace(/\s+/g, " ").trim();
-  return itemQuery.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/,
-    pivotQuery
-  );
-}
-function create1DDatePivotQuery(pivot, itemQuery, dateBucket = "month", databaseType) {
-  const isValidBaseQuery = itemQuery.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery) {
-    return void 0;
-  }
-  const rowField = pivot.rowField || "";
-  const rowFieldAlias = processColumnReference(
-    rowField,
-    databaseType,
-    void 0
-  );
-  let quillAggSelects = [
-    `${processDateTrunc(dateBucket, rowFieldAlias, databaseType)} as ${processColumnReference(rowField, databaseType)}`
-  ];
-  let valueFieldAliases = [];
-  const seenAggs = {};
-  pivot.aggregations?.forEach((currentAgg) => {
-    if (!currentAgg.valueField) currentAgg.valueField = void 0;
-    if (seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]) {
-      seenAggs[currentAgg.aggregationType ?? ""][currentAgg.valueField ?? ""] += 1;
-    } else {
-      seenAggs[currentAgg.aggregationType ?? ""] = {
-        ...seenAggs[currentAgg.aggregationType ?? ""],
-        [currentAgg.valueField ?? ""]: 1
-      };
-    }
-    let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]?.toString() ?? "";
-    if (disambiguationIndex === "1") disambiguationIndex = "";
-    const valueFieldAlias = processColumnReference(
-      currentAgg.valueField || rowField || "count",
-      databaseType,
-      void 0,
-      false,
-      true
-    );
-    const valueAliasSubstring = currentAgg.valueField ? `${processColumnReference(currentAgg.valueField, databaseType, void 0, true)} AS ${valueFieldAlias}` : "";
-    let value2AliasSubstring = "";
-    const disambiguation = pivot.aggregations?.length > 1 ? `${disambiguationIndex}` + (currentAgg.aggregationType !== "count" ? `_${currentAgg.aggregationType}` : "") : "";
-    let valueExpr = !currentAgg.valueField ? "*" : valueFieldAlias;
-    if (currentAgg.valueFieldType === "bool") {
-      valueExpr = `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END`;
-    }
-    if (currentAgg.aggregationType === "percentage") {
-      let countPercentage = false;
-      if (!currentAgg.valueField) {
-        countPercentage = true;
-      }
-      const valueField2Alias = processColumnReference(
-        currentAgg.valueField2 ?? currentAgg.valueField ?? "count",
-        databaseType,
-        void 0,
-        false,
-        true
-      );
-      value2AliasSubstring = currentAgg.valueField2 && currentAgg.valueField !== currentAgg.valueField2 ? `${processColumnReference(currentAgg.valueField2, databaseType, void 0, true)} AS ${valueField2Alias}` : "";
-      let value2Expr = valueField2Alias;
-      if ((currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool") {
-        value2Expr = `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END`;
-      }
-      const percentageExpr = countPercentage ? "CAST(COUNT(*) AS FLOAT) / (SELECT COUNT(*) FROM quill_base_table)" : currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2 ? `CAST(sum(${valueExpr}) AS FLOAT) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool" ? "COUNT(*)" : "SUM(sum(" + valueExpr + ")) OVER ()"}` : `CAST(sum(${valueExpr}) AS FLOAT) / GREATEST(sum(${value2Expr}), 1)`;
-      quillAggSelects = [
-        ...quillAggSelects,
-        `${percentageExpr} as ${processColumnReference(
-          `${currentAgg.valueField ?? (disambiguation ? "count" : "percentage")}${disambiguation}`,
-          databaseType,
-          void 0,
-          false,
-          true
-        )}`
-      ];
-    } else {
-      quillAggSelects = [
-        ...quillAggSelects,
-        `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference((currentAgg.valueField || "count") + disambiguation, databaseType)}`
-      ];
-    }
-    if (valueAliasSubstring) valueFieldAliases.push(valueAliasSubstring);
-    if (value2AliasSubstring) valueFieldAliases.push(value2AliasSubstring);
-  });
-  valueFieldAliases = Array.from(new Set(valueFieldAliases));
-  const sortQuery = `${pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, void 0, true)} ${pivot.sortDirection || ""} ` : ""}`;
-  const pivotQuery = `, quill_alias AS (SELECT ${processColumnReference(`${rowField}`, databaseType, void 0, true)} AS ${rowFieldAlias}${valueFieldAliases.length > 0 ? `, ${valueFieldAliases.join(", ")}` : ""}
-    FROM quill_base_table),
-    quill_qt_agg AS (SELECT ${quillAggSelects.join(", ")}
-    FROM quill_alias GROUP BY ${databaseType.toLowerCase() === "clickhouse" ? processColumnReference(`${rowField}`, databaseType) : processDateTrunc(dateBucket, rowFieldAlias, databaseType)}),
-    quill_base_pivot AS (SELECT ${pivot.rowLimit && databaseType.toLowerCase() === "mssql" ? `TOP ${pivot.rowLimit}` : ""} * FROM quill_qt_agg qt 
-    ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== "mssql" ? ` LIMIT ${pivot.rowLimit}` : ""})
-    SELECT * FROM quill_base_pivot
-    `.replace(/\s+/g, " ").trim();
-  return itemQuery.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/,
-    pivotQuery
-  );
-}
-function createAggregationValuePivot(pivot, itemQuery, databaseType) {
-  const isValidBaseQuery = itemQuery.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery) return void 0;
-  let quillAggSelects = [];
-  let valueFieldAliases = [];
-  const seenAggs = {};
-  pivot.aggregations?.forEach((currentAgg) => {
-    if (!currentAgg.valueField) currentAgg.valueField = void 0;
-    if (seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]) {
-      seenAggs[currentAgg.aggregationType ?? ""][currentAgg.valueField ?? ""] += 1;
-    } else {
-      seenAggs[currentAgg.aggregationType ?? ""] = {
-        ...seenAggs[currentAgg.aggregationType ?? ""],
-        [currentAgg.valueField ?? ""]: 1
-      };
-    }
-    let disambiguationIndex = seenAggs[currentAgg.aggregationType ?? ""]?.[currentAgg.valueField ?? ""]?.toString() ?? "";
-    if (disambiguationIndex === "1") disambiguationIndex = "";
-    const valueFieldAlias = processColumnReference(
-      currentAgg.valueField || "count",
-      databaseType,
-      void 0,
-      false,
-      true
-    );
-    const valueAliasSubstring = currentAgg.valueField ? `${processColumnReference(currentAgg.valueField, databaseType, void 0, true)} AS ${valueFieldAlias}` : "";
-    let value2AliasSubstring = "";
-    const disambiguation = pivot.aggregations?.length > 1 ? `${disambiguationIndex}_${currentAgg.aggregationType}` : "";
-    let valueExpr = !currentAgg.valueField ? "*" : valueFieldAlias;
-    valueExpr = currentAgg.valueFieldType === "bool" ? `CASE WHEN ${valueFieldAlias} THEN 1 ELSE 0 END` : valueExpr;
-    if (currentAgg.aggregationType === "percentage") {
-      if (!currentAgg.valueField) {
-        throw new Error("No value field provided for percentage aggregation");
-      }
-      const valueField2Alias = processColumnReference(
-        currentAgg.valueField2 ?? currentAgg.valueField,
-        databaseType,
-        void 0,
-        false,
-        true
-      );
-      const value2Expr = (currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool" ? `CASE WHEN ${valueField2Alias} THEN 1 ELSE 0 END` : valueField2Alias;
-      value2AliasSubstring = currentAgg.valueField2 && currentAgg.valueField !== currentAgg.valueField2 ? `${processColumnReference(currentAgg.valueField2, databaseType, void 0, true)} AS ${valueField2Alias}` : "";
-      const percentageExpr = currentAgg.valueField === currentAgg.valueField2 || !currentAgg.valueField2 ? `CAST(sum(${valueExpr}) AS FLOAT) / ${(currentAgg.valueField2Type ?? currentAgg.valueFieldType) === "bool" ? "COUNT(*)" : "SUM(sum(" + valueExpr + ")) OVER ()"}` : `CAST(sum(${valueExpr}) AS FLOAT) / GREATEST(sum(${value2Expr}), 1)`;
-      quillAggSelects = [
-        ...quillAggSelects,
-        `${percentageExpr} as ${processColumnReference(
-          `${currentAgg.valueField ?? ""}${disambiguation}`,
-          databaseType,
-          void 0,
-          false,
-          true
-        )}`
-      ];
-    } else {
-      quillAggSelects = [
-        ...quillAggSelects,
-        `${processAggType(currentAgg.aggregationType)}(${valueExpr}) AS ${processColumnReference(
-          (currentAgg.valueField || "count") + disambiguation,
-          databaseType
-        )}`
-      ];
-    }
-    if (valueAliasSubstring) valueFieldAliases.push(valueAliasSubstring);
-    if (value2AliasSubstring) valueFieldAliases.push(value2AliasSubstring);
-  });
-  valueFieldAliases = Array.from(new Set(valueFieldAliases));
-  if (valueFieldAliases.length === 0) {
-    valueFieldAliases = ["*"];
-  }
-  const sortQuery = pivot.sort && pivot.sortField && pivot.rowLimit ? ` ORDER BY ${processColumnReference(pivot.sortField, databaseType, void 0, true)} ${pivot.sortDirection || ""} ` : "";
-  const pivotQuery = `, quill_alias AS (
-        SELECT ${valueFieldAliases.join(", ")} FROM quill_base_table
-      ),
-      quill_qt_agg AS (
-        SELECT ${quillAggSelects.join(", ")} FROM quill_alias
-      ),
-      quill_base_pivot AS (
-        SELECT ${pivot.rowLimit && databaseType.toLowerCase() === "mssql" ? `TOP ${pivot.rowLimit}` : ""} * FROM quill_qt_agg qt
-        ${sortQuery}${pivot.rowLimit && databaseType.toLowerCase() !== "mssql" ? ` LIMIT ${pivot.rowLimit}` : ""}
-      )
-      SELECT * FROM quill_base_pivot`.replace(/\s+/g, " ").trim();
-  return itemQuery.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_table["'\]`]?\s*$/,
-    pivotQuery
-  );
-}
-function additionalProcessingOnPivotQuery(pivot, query, additionalProcessing, databaseType = "postgresql") {
-  if (!additionalProcessing || !query) return query;
-  const isValidBaseQuery = query.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery) {
-    return void 0;
-  }
-  if (!pivot.aggregations || pivot.aggregations.length === 0) {
-    if (pivot.aggregationType) {
-      pivot.aggregations = [
-        {
-          aggregationType: pivot.aggregationType,
-          valueField: pivot.valueField,
-          valueField2: pivot.valueField2
-        }
-      ];
-    } else {
-      throw new Error("No aggregations provided for pivot");
-    }
-  }
-  let rowsPerPage = 0;
-  let currentInterval = 0;
-  let offset = 0;
-  let limit = 1e3;
-  let sortQuery = "";
-  if (additionalProcessing.page) {
-    const page = additionalProcessing.page.page || 0;
-    if (additionalProcessing.page.rowsPerRequest) {
-      limit = additionalProcessing.page.rowsPerRequest;
-    }
-    rowsPerPage = additionalProcessing.page.rowsPerPage || 0;
-    currentInterval = page ? Math.floor(page / (limit / rowsPerPage)) : 0;
-    offset = currentInterval * limit;
-  }
-  const disambiguation = pivot.aggregations.length > 1 ? `_${matchCasing(pivot.aggregations?.[0]?.aggregationType, pivot.aggregations?.[0]?.valueField)}` : "";
-  if (additionalProcessing.sort) {
-    sortQuery = `ORDER BY ${processColumnReference(additionalProcessing.sort.field, databaseType, void 0, true)} ${additionalProcessing.sort.direction || ""}`;
-  } else {
-    const valueFieldAlias = processColumnReference(
-      (pivot.aggregations?.[0]?.valueField ?? "") + disambiguation,
-      databaseType,
-      void 0,
-      false,
-      true
-    );
-    const defaultSortField = pivot.sortField || pivot.rowField || valueFieldAlias;
-    const defaultSortDirection = pivot.sortDirection || "";
-    if (defaultSortField !== `"_"`) {
-      sortQuery = `ORDER BY ${processColumnReference(defaultSortField, databaseType, void 0, true)} ${defaultSortDirection}`;
-    } else {
-      sortQuery = "";
-    }
-  }
-  const additionalProcessingQuery = `
-    SELECT * 
-    FROM quill_base_pivot ${sortQuery}${databaseType.toLowerCase() === "mssql" ? ` OFFSET ${offset} ROWS FETCH NEXT ${limit} ROWS ONLY` : ` LIMIT ${limit} OFFSET ${offset}`}
-    `.replace(/\s+/g, " ").trim();
-  return query.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/,
-    additionalProcessingQuery
-  );
-}
-function generateRowCountQuery(query, databaseType) {
-  if (!query) return query;
-  const isValidBaseQuery = query.match(
-    /SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/
-  );
-  if (!isValidBaseQuery) {
-    return void 0;
-  }
-  const rowCountQuery = `, subview_row_count_cte AS (SELECT * FROM quill_base_pivot)
-            SELECT count(*) as ${processColumnReference("row_count", databaseType || "postgresql", void 0, true)} FROM subview_row_count_cte
-            `.replace(/\s+/g, " ").trim();
-  return query.replace(
-    /SELECT \* FROM\s+["'[`]?quill_base_pivot["'\]`]?\s*$/,
-    rowCountQuery
-  );
-}
-
-// src/utils/pivotConstructor.ts
-async function generatePivotWithSQL({
-  pivot,
-  report,
-  client,
-  dateBucket,
-  dateFilter,
-  distinctStrings,
-  dashboardName,
-  tenants,
-  additionalProcessing,
-  pivotQuery,
-  comparisonPivotQuery,
-  getPivotRowCount = true,
-  caller,
-  getToken
-}) {
-  let sqlQuery = pivotQuery;
-  let comparisonPivotSql = comparisonPivotQuery;
-  const databaseType = client.databaseType || "postgresql";
-  if (!pivotQuery && pivot.columnField && !pivot.columnValues && !distinctStrings) {
-    if (!report?.rows) {
-      throw new Error("No distinct strings provided for column field");
-    } else {
-      distinctStrings = Array.from(
-        new Set(
-          report.rows.map((row) => row[pivot.columnField]).filter((value) => value !== null && value !== void 0)
-        )
-      );
-    }
-  }
-  if (!pivot.aggregations?.length && pivot.aggregationType) {
-    pivot.aggregations = [
-      {
-        aggregationType: pivot.aggregationType,
-        valueField: pivot.valueField,
-        valueFieldType: pivot.valueFieldType,
-        valueField2: pivot.valueField2,
-        valueField2Type: pivot.valueField2Type
-      }
-    ];
-  }
-  let comparisonInterval = void 0;
-  if (dateFilter && dateFilter.comparisonRange) {
-    comparisonInterval = getComparisonInterval(
-      {
-        startDate: dateFilter.comparisonRange.startDate,
-        endDate: dateFilter.comparisonRange.endDate
-      },
-      dateBucket
-    );
-  }
-  if (pivot.rowField && !pivot.rowFieldType) {
-    const rowColumn = report?.columns.find(
-      (column) => column.field === pivot.rowField
-    );
-    pivot.rowFieldType = rowColumn?.format || "string";
-  }
-  const filteredDistinctStrings = distinctStrings?.filter(
-    (value) => value !== null && value !== void 0 && value !== ""
-  );
-  const pivotColumnFields = filteredDistinctStrings?.slice(
-    0,
-    MAX_PIVOT_UNIQUE_VALUES
-  );
-  if (!pivotQuery && report) {
-    if (!report.itemQuery) {
-      throw Error("No item query found in report");
-    }
-    const itemQuery = report.itemQuery[0];
-    const comparisonQuery = report.itemQuery[1];
-    if (!itemQuery) {
-      throw Error("No item query found in report");
-    }
-    sqlQuery = generatePivotQuery(
-      pivot,
-      itemQuery,
-      databaseType,
-      pivotColumnFields,
-      dateBucket
-    );
-    comparisonPivotSql = comparisonQuery ? generatePivotQuery(
-      pivot,
-      comparisonQuery,
-      databaseType,
-      pivotColumnFields,
-      dateBucket
-    ) : "";
-  }
-  if (!sqlQuery) {
-    throw "Error generating pivot query";
-  }
-  const paginatedSqlQuery = additionalProcessingOnPivotQuery(
-    pivot,
-    sqlQuery,
-    additionalProcessing,
-    client.databaseType
-  );
-  const paginatedComparisonQuery = comparisonPivotSql ? additionalProcessingOnPivotQuery(
-    pivot,
-    comparisonPivotSql,
-    additionalProcessing,
-    client.databaseType
-  ) : "";
-  const preQueries = [paginatedSqlQuery];
-  getPivotRowCount = getPivotRowCount && (report?.chartType === "table" || caller === "ReportBuilder");
-  if (getPivotRowCount) {
-    const pivotRowCountQuery = generateRowCountQuery(
-      sqlQuery,
-      client.databaseType
-    );
-    preQueries.push(pivotRowCountQuery);
-  }
-  if (paginatedComparisonQuery) {
-    preQueries.push(paginatedComparisonQuery);
-  }
-  const { data: resp } = await quillFetch({
-    client,
-    task: "query",
-    metadata: {
-      preQueries,
-      clientId: client.publicKey,
-      databaseType,
-      runQueryConfig: {
-        overridePost: true,
-        convertDatatypes: true
-      },
-      useNewNodeSql: true,
-      dashboardName,
-      tenants
-    },
-    urlParameters: `caller=generatePivot&task=query`,
-    credentials: "same-origin",
-    getToken
-  });
-  if (resp.success === false) {
-    throw resp.errorMessage;
-  }
-  const queryResponseRows = resp?.queryResults?.[0]?.rows || [];
-  const queryResponseFields = resp?.queryResults?.[0]?.fields || [];
-  const queryComparisonResponseRows = (getPivotRowCount ? resp?.queryResults?.[2]?.rows : resp?.queryResults?.[1]?.rows) || [];
-  const queryComparisonResponseFields = (getPivotRowCount ? resp?.queryResults?.[2]?.fields : resp?.queryResults?.[1]?.fields) || [];
-  parseValueFromBigQueryDates(queryResponseRows, queryResponseFields);
-  parseValueFromBigQueryDates(
-    queryComparisonResponseRows,
-    queryComparisonResponseFields
-  );
-  const responseRows = mergeComparisonPivotRows({
-    pivot,
-    rows: queryResponseRows,
-    compRows: queryComparisonResponseRows,
-    databaseType,
-    dateBucket,
-    comparisonInterval,
-    columnFieldValues: pivotColumnFields
-  });
-  const responseFields = mergeComparisonPivotColumns({
-    pivot,
-    rows: queryResponseFields,
-    compRows: queryComparisonResponseFields
-  });
-  const rows = pivot.rowField ? responseRows.map(
-    (row) => !row[pivot.rowField] ? { ...row, [pivot.rowField]: "-" } : row
-  ) : responseRows;
-  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 = responseFields?.map((field) => ({
-    field: processColumnName(field.name),
-    label: snakeCaseToTitleCase(
-      processColumnName(field.name.replace("comparison_", "comparison "))
-    ),
-    format: field.name === pivot.rowField ? "string" : (
-      // This scary equation is calculating which aggregation a column is associated with.
-      // Eg you have 7 columns and 2 aggregations, you can assume column 0 is the row field, 1-3 is aggregation 0, and 4-6 is aggregation 1.
-      // pivot.aggregations?.[
-      //     Math.floor(
-      //       (index - 1) /
-      //         Math.floor(
-      //           (responseFields.length - 1) /
-      //             (pivot.aggregations?.length ?? 1),
-      //         ),
-      //     )
-      //   ]?.aggregationType === 'percentage'
-      pivot.aggregations?.find(
-        (agg) => agg.valueField === field.name || `${agg.valueField}_percentage` === field.name || !agg.valueField && agg.aggregationType === "percentage" && field.name.endsWith("percentage")
-      )?.aggregationType === "percentage" ? "percent" : "whole_number"
-    ),
-    fieldType: field.fieldType,
-    jsType: field.jsType,
-    dataTypeID: field.dataTypeID
-  })).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 && !isStringType(pivot.rowFieldType || "")) {
-    rows.forEach((row) => {
-      row.__quillRawDate = typeof row[pivot.rowField || ""] === "object" ? row[pivot.rowField || ""].value : row[pivot.rowField || ""];
-      let value = typeof row[pivot.rowField || ""] === "object" ? row[pivot.rowField || ""].value : row[pivot.rowField || ""];
-      if (dateBucket === "week" && dateFilter?.startDate && dateFilter?.endDate) {
-        const rowDate = new Date(value);
-        if (rowDate < dateFilter.startDate) {
-          value = dateFilter.startDate.toISOString();
-        } else if (rowDate > dateFilter.endDate) {
-          value = dateFilter.endDate.toISOString();
-        }
-      }
-      const dateString = getDateString(
-        value,
-        dateFilter?.startDate && dateFilter?.endDate ? { start: dateFilter.startDate, end: dateFilter.endDate } : void 0,
-        dateBucket,
-        databaseType
-      );
-      row[pivot.rowField || ""] = dateString;
-    });
-    if (pivot.rowField && pivot.rowFieldType && !isStringType(pivot.rowFieldType) && dateFilter?.startDate && dateFilter?.endDate) {
-      const dateSet = new Set(
-        rows.map((row) => row[pivot.rowField || ""])
-      );
-      for (let date = dateFilter.startDate; date <= dateFilter.endDate; date = new Date(date.getTime() + 24 * 60 * 60 * 1e3)) {
-        const formattedDate = getDateString(
-          date.toISOString(),
-          { start: dateFilter.startDate, end: dateFilter.endDate },
-          dateBucket,
-          databaseType
-        );
-        if (!dateSet.has(formattedDate)) {
-          const newRow = {};
-          newRow[pivot.rowField] = formattedDate;
-          newRow.__quillRawDate = date.toISOString();
-          rows.push(newRow);
-          dateSet.add(formattedDate);
-        }
-      }
-    }
-    if (!pivot.sort) {
-      rows.sort((a, b) => {
-        if (a.__quillRawDate < b.__quillRawDate) {
-          return -1;
-        }
-        if (a.__quillRawDate > b.__quillRawDate) {
-          return 1;
-        }
-        return 0;
-      });
-    }
-  }
-  columns?.forEach((column, index) => {
-    if (column.label && ["null", "undefined"].includes(column.label.toLowerCase()) && !pivot.columnField && !pivot.aggregations?.[index]?.valueField && pivot.aggregations?.[index]?.aggregationType === "count") {
-      column.label = "Count";
-    }
-  });
-  const numericColumns = columns?.filter(
-    (column) => column.format === "whole_number" || column.format === "percentage"
-  );
-  rows.forEach((row) => {
-    numericColumns?.forEach((column) => {
-      row[column.field] = row[column.field] ?? 0;
-    });
-  });
-  return {
-    rows,
-    columns: columns ?? [],
-    rowCount: getPivotRowCount ? Number(resp?.queryResults?.[1]?.rows?.[0]?.["row_count"]) ?? rows.length : 0,
-    pivotQuery: sqlQuery,
-    comparisonPivotQuery: comparisonPivotSql
-  };
-}
-function generatePivotTableYAxis(pivot, cols, yAxisField) {
-  if (pivot?.aggregationType === "count") {
-    return [
-      {
-        field: pivot.valueField ?? "count",
-        label: yAxisField.label,
-        format: yAxisField.format
-      }
-    ];
-  }
-  return [
-    {
-      field: pivot.valueField ?? "count",
-      label: yAxisField.label,
-      format: yAxisField.format
-    }
-  ];
-}
-function generatePivotTitle(pivot) {
-  if (pivot.rowField && !pivot.valueField && pivot.aggregations?.[0]) {
-    return snakeAndCamelCaseToTitleCase(
-      `${pivot.aggregations[0].aggregationType} of ${pivot.rowField}${pivot.columnField ? ` by ${pivot.columnField}` : ""}
-      `
-    );
-  } else if (!pivot.rowField && pivot.aggregations?.[0]?.valueField) {
-    return snakeAndCamelCaseToTitleCase(
-      `${pivot.aggregations[0].aggregationType} of ${pivot.aggregations[0].valueField}
-      `
-    );
-  }
-  return snakeAndCamelCaseToTitleCase(
-    `${pivot.aggregations?.[0]?.aggregationType ?? "Aggregation"} of ${pivot.aggregations?.[0]?.valueField ?? "value"}${pivot.rowField ? ` by ${pivot.rowField}` : ""}${pivot.columnField ? ` and ${pivot.columnField}` : ""}`
-  );
-}
-async function generatePivotTable({
-  pivot,
-  dateBucket,
-  dateFilter,
-  report,
-  client,
-  getToken,
-  eventTracking,
-  uniqueValues,
-  dashboardName,
-  tenants,
-  additionalProcessing,
-  caller,
-  pivotQuery
-}) {
-  try {
-    if (report && client) {
-      const pivotTable = await generatePivotWithSQL({
-        pivotQuery,
-        pivot,
-        report,
-        client,
-        dateBucket,
-        dateFilter,
-        distinctStrings: pivot.columnField && uniqueValues?.[pivot.columnField] ? uniqueValues[pivot.columnField] : [],
-        dashboardName,
-        tenants,
-        additionalProcessing,
-        caller,
-        getToken
-      });
-      return pivotTable;
-    }
-  } catch (e) {
-    eventTracking?.logError?.({
-      type: "bug",
-      // TODO: determine type
-      severity: "high",
-      message: "Error generating pivot table",
-      errorMessage: e.message,
-      errorStack: e.stack,
-      errorData: {
-        caller: "PivotModal",
-        function: "generatePivotTable"
-      }
-    });
-    throw Error(`Failed to generate pivot table with SQL: ${e}`);
-  }
-  throw Error("Failed to generate pivot table: invalid report");
-}
-
-// src/utils/errorProcessing.ts
-function processFilterErrorList(resp) {
-  if (!resp || !resp.filterErrorList || !Array.isArray(resp.filterErrorList)) {
-    return;
-  }
-}
-
-// src/utils/paginationProcessing.ts
-var DEFAULT_PAGINATION = {
-  page: 0,
-  rowsPerPage: 10,
-  rowsPerRequest: 600
-};
-var DEFAULT_TABLE_PAGINATION = {
-  page: 0,
-  rowsPerPage: 10,
-  rowsPerRequest: 50
-};
-function shouldFetchMore(pagination, page, maxPage, currentRowCount) {
-  if (!pagination || currentRowCount && currentRowCount >= pagination.rowsPerPage * (page + 1)) {
-    return false;
-  }
-  const indexAdjustedPage = page;
-  const pageInterval = Math.floor(
-    indexAdjustedPage * pagination.rowsPerPage / pagination.rowsPerRequest
-  );
-  const indexAdjustedPreviousPage = maxPage;
-  const previousPageInterval = Math.floor(
-    indexAdjustedPreviousPage * pagination.rowsPerPage / pagination.rowsPerRequest
-  );
-  return pageInterval > previousPageInterval;
-}
-function shouldSortInMemory(pagination, rowCount) {
-  if (!rowCount || rowCount < pagination.rowsPerRequest) {
-    return true;
-  }
-  return false;
-}
 
 // src/utils/tableProcessing.ts
 var getUniqueValuesByQuery = async ({
@@ -19008,493 +18285,8 @@ var fetchTableByAST = async (ast, client, getToken, tenants, eventTracking, dash
   return { rows, columns, rowCount, error, itemQuery, referencedTables };
 };
 
-// src/utils/dashboard.ts
-var defaultDashboardItem = {
-  id: "",
-  name: "",
-  dashboardName: "",
-  rows: [],
-  compareRows: [],
-  columns: [],
-  chartType: "",
-  pivot: null,
-  yAxisFields: [],
-  xAxisLabel: "",
-  xAxisField: "",
-  xAxisFormat: "string",
-  order: -1,
-  filtersApplied: [],
-  queryString: "",
-  rowCount: 0,
-  columnInternal: []
-};
-async function cleanDashboardItem({
-  item,
-  dashboardFilters,
-  getToken,
-  eventTracking,
-  client,
-  dateBucket,
-  additionalProcessing,
-  customFields,
-  skipPivotFetch,
-  tenants
-}) {
-  if (!item) return defaultDashboardItem;
-  if (!item.rows) {
-    return {
-      ...defaultDashboardItem,
-      id: item._id,
-      name: item.name
-    };
-  }
-  const fields = item.fields || [];
-  const columnsWithCustomFields = [...item.columns ?? []];
-  if (item.includeCustomFields && item.rows?.length > 0) {
-    const tables = item.referencedTables ?? [];
-    tables.forEach((table) => {
-      const _customFields = customFields?.[table] ?? [];
-      _customFields.forEach((field) => {
-        const isJsonCustomField = !!field.refColumn;
-        if (item.rows[0][field.field] !== void 0 && !item.columns.some((col) => col.field === field.field)) {
-          const result_field = fields.find((f) => f.name === field.field);
-          const converted_field = convertPostgresColumn(result_field ?? {});
-          columnsWithCustomFields.push({
-            field: field.field,
-            format: converted_field.format,
-            label: snakeAndCamelCaseToTitleCase(field.field),
-            fieldType: converted_field.fieldType,
-            dataTypeID: converted_field.dataTypeID,
-            jsType: converted_field.jsType,
-            inferFormat: isJsonCustomField
-          });
-        }
-      });
-    });
-  }
-  const processedColumns = item.columns.map((col) => {
-    return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
-  });
-  const columnInternal = (item.includeCustomFields ? columnsWithCustomFields : item.columns).map((col) => {
-    const field = item.fields?.find((f) => f.name === col.field);
-    const converted_field = convertPostgresColumn(field ?? {});
-    return {
-      fieldType: converted_field.fieldType,
-      dataTypeID: converted_field.dataTypeID,
-      jsType: converted_field.jsType,
-      ...col,
-      label: snakeAndCamelCaseToTitleCase(col.label)
-    };
-  });
-  let pivotTable;
-  let pivotError;
-  try {
-    const shouldPaginatePivotAsTable = item.chartType === "table";
-    const pivotChartProcessing = {
-      page: DEFAULT_PAGINATION
-    };
-    pivotTable = await getPivotTable(
-      {
-        ...item,
-        pivot: item.pivot && !skipPivotFetch ? {
-          ...item.pivot,
-          aggregations: item.pivot.aggregations ?? [
-            {
-              valueField: item.pivot.valueField,
-              valueFieldType: item.pivot.valueFieldType,
-              valueField2: item.pivot.valueField2,
-              valueField2Type: item.pivot.valueField2Type,
-              aggregationType: item.pivot.aggregationType
-            }
-          ]
-        } : void 0
-      },
-      dashboardFilters,
-      item.dashboardName,
-      getToken,
-      client,
-      eventTracking,
-      dateBucket,
-      shouldPaginatePivotAsTable ? additionalProcessing : pivotChartProcessing,
-      tenants,
-      customFields
-    );
-  } catch (e) {
-    pivotTable = void 0;
-    eventTracking?.logError?.({
-      type: "bug",
-      // TODO: determine type
-      severity: "high",
-      message: "Error fetching pivot table",
-      errorMessage: e.message,
-      errorStack: e.stack,
-      errorData: {
-        caller: "cleanDashboardItem",
-        function: "cleanDashboardItem"
-      }
-    });
-    console.error("Error fetching pivot table", e);
-    pivotError = "Error fetching pivot table";
-  }
-  const referenceLineYValues = [];
-  for (const key in item) {
-    if (key.startsWith("referenceLine_")) {
-      const field = key.slice(14);
-      if (!item[key] || !item[key][0]) continue;
-      const value = Object.values(item[key][0])[0];
-      referenceLineYValues.push({ label: field, query: [value, value] });
-    }
-  }
-  if (item.referenceLines) {
-    for (const referenceLine of item.referenceLines) {
-      if (Array.isArray(referenceLine.query)) {
-        referenceLineYValues.push({
-          label: referenceLine.label,
-          query: referenceLine.query
-        });
-      } else if (referenceLine.query === "") {
-        referenceLineYValues.push({
-          label: referenceLine.label,
-          query: (pivotTable?.rows ? pivotTable.rows : item.rows).map(
-            (row) => Number(row[referenceLine.label]) || 0
-          )
-        });
-      }
-    }
-  }
-  return {
-    id: item._id ?? item.id,
-    name: item.name,
-    dashboardName: item.dashboardName,
-    // section: item.section,
-    rows: item.rows,
-    pivotRows: pivotTable ? pivotTable.rows : void 0,
-    pivotColumns: pivotTable ? pivotTable.columns : void 0,
-    compareRows: item.compareRows,
-    columns: processedColumns.map((column) => {
-      return {
-        field: column.field,
-        format: column.format,
-        label: column.label,
-        inferFormat: column.inferFormat
-      };
-    }),
-    includeCustomFields: item.includeCustomFields,
-    columnInternal,
-    columnsWithCustomFields,
-    chartType: item.chartType,
-    dateField: item.dateField,
-    pivot: pivotError ? void 0 : item.pivot ? {
-      ...item.pivot,
-      aggregations: item.pivot.aggregations ?? [
-        {
-          valueField: item.pivot.valueField,
-          valueFieldType: item.pivot.valueFieldType,
-          valueField2: item.pivot.valueField2,
-          valueField2Type: item.pivot.valueField2Type,
-          aggregationType: item.pivot.aggregationType
-        }
-      ],
-      columnValues: item.distinctStrings
-    } : void 0,
-    yAxisFields: pivotTable ? extractPivotedYAxis(pivotTable, item) : item.yAxisFields,
-    xAxisLabel: item.xAxisLabel,
-    xAxisField: item.xAxisField,
-    xAxisFormat: item.xAxisFormat,
-    order: item.order,
-    filtersApplied: item.filtersApplied,
-    filterMap: item.filterMap,
-    flags: item.flags,
-    rowCount: item.rowCount ? parseInt(item.rowCount) : item.rows.length,
-    pivotRowCount: pivotTable ? pivotTable.rowCount : void 0,
-    template: item.template,
-    sort: item.sort,
-    itemQuery: item.itemQuery,
-    queryString: item.queryString,
-    pivotQuery: pivotTable?.pivotQuery,
-    comparisonPivotQuery: pivotTable?.comparisonPivotQuery,
-    referencedTables: item?.referencedTables || [],
-    referencedColumns: item?.referencedColumns || {},
-    error: item.error ?? pivotError,
-    referenceLineYValues,
-    referenceLines: item.referenceLines
-  };
-}
-async function getPivotTable(report, dashboardFilters, dashboardName, getToken, client, eventTracking, dateBucketInitial, additionalProcessing, tenants, customFields) {
-  if (!report) return void 0;
-  const dateFilter = Object.values(dashboardFilters ?? {}).find(
-    (filter) => filter.filterType === "date_range" || filter.operator === "BETWEEN"
-  );
-  if (dateFilter?.operator === "BETWEEN") {
-    dateFilter.startDate = dateFilter.value[0];
-    dateFilter.endDate = dateFilter.value[1];
-  }
-  const pivot = report?.pivot;
-  const data = report || {};
-  if (pivot && client) {
-    if (report.rowCount === 0 || report.rows.length === 0) {
-      const columns = [];
-      if (pivot.rowField) {
-        columns.push({
-          field: pivot.rowField,
-          label: snakeCaseToTitleCase(processColumnName(pivot.rowField)),
-          format: pivot.rowFieldType || "string",
-          jsType: convertFieldTypeToJSType(pivot.rowFieldType || "string"),
-          fieldType: pivot.rowFieldType || "string",
-          dataTypeID: fieldTypeToDataTypeID(pivot.rowFieldType || "string")
-        });
-      }
-      for (const agg of pivot.aggregations ?? []) {
-        if (agg.valueField) {
-          columns.push({
-            field: agg.valueField,
-            label: snakeCaseToTitleCase(processColumnName(agg.valueField)),
-            //FIXME: valueFieldType is not always the same as the format
-            format: agg.valueFieldType ?? "whole_number",
-            jsType: agg.valueFieldType ?? "number",
-            fieldType: agg.valueFieldType ?? "number",
-            dataTypeID: fieldTypeToDataTypeID(agg.valueFieldType ?? "number")
-          });
-        }
-      }
-      const pivotQuery = generatePivotQuery(
-        pivot,
-        report.itemQuery?.[0],
-        client.databaseType
-      );
-      return {
-        rows: [],
-        rowCount: 0,
-        pivotQuery: pivotQuery ?? "",
-        columns
-      };
-    }
-    try {
-      let dateBucket = dateBucketInitial;
-      let filterDateRange = void 0;
-      if (dateFilter && dateFilter.startDate && dateFilter.endDate) {
-        filterDateRange = {
-          start: dateFilter.startDate,
-          end: dateFilter.endDate
-        };
-      } else if (report.dateRange) {
-        filterDateRange = report.dateRange;
-      }
-      if (!dateBucket && filterDateRange) {
-        dateBucket = getDateBucketFromRange(filterDateRange);
-      }
-      if (pivot.columnField && !report.distinctStrings) {
-        const columnFieldColumn = (report.columnsWithCustomFields ?? report.columns).find((col) => col.field === pivot.columnField);
-        if (!columnFieldColumn) {
-          console.error(
-            "could not find pivot column field on report",
-            pivot.columnField
-          );
-        }
-        const unique = await getUniqueValuesByQuery({
-          columns: [columnFieldColumn],
-          query: report.queryString,
-          client,
-          getToken,
-          dashboardName,
-          tenants,
-          customFields: customFields ?? {},
-          eventTracking
-        });
-        report.distinctStrings = unique?.[pivot.columnField] ?? [];
-      }
-      if (pivot.columnField && !report.distinctStrings) {
-        const columnFieldColumn = (report.columnsWithCustomFields ?? report.columns).find((col) => col.field === pivot.columnField);
-        if (!columnFieldColumn) {
-          console.error(
-            "could not find pivot column field on report",
-            pivot.columnField
-          );
-        }
-        const unique = await getUniqueValuesByQuery({
-          columns: [columnFieldColumn],
-          query: report.queryString,
-          client,
-          getToken,
-          dashboardName,
-          tenants,
-          customFields: customFields ?? {},
-          eventTracking
-        });
-        report.distinctStrings = unique?.[pivot.columnField] ?? [];
-      }
-      const pivotTable = await generatePivotWithSQL({
-        pivot,
-        report,
-        client,
-        dateBucket,
-        dateFilter,
-        distinctStrings: report.distinctStrings,
-        dashboardName,
-        tenants,
-        additionalProcessing,
-        getToken
-      });
-      return pivotTable;
-    } catch (e) {
-      eventTracking?.logError?.({
-        type: "bug",
-        // TODO: determine type
-        severity: "high",
-        message: "Error fetching pivot table",
-        errorMessage: e.message,
-        errorStack: e.stack,
-        errorData: {
-          caller: "getPivotTable",
-          function: "getPivotTable"
-        }
-      });
-      console.error("Error fetching pivot table", e);
-      throw e;
-    }
-  }
-  return pivot && data.rows ? generatePivotTable({
-    pivot,
-    report,
-    client,
-    uniqueValues: report.distinctStrings,
-    dashboardName,
-    tenants,
-    dateFilter,
-    additionalProcessing,
-    getToken,
-    eventTracking
-  }) : void 0;
-}
-function extractPivotedYAxis(pivotTable, itemInfo, config = void 0) {
-  if (!pivotTable) return itemInfo?.yAxisFields ?? [];
-  const pivot = itemInfo?.pivot || config?.pivot;
-  if (!pivot.columnField && !pivot.rowField) return itemInfo?.yAxisFields ?? [];
-  const yAxisFields = config ? config.yAxisFields : itemInfo?.yAxisFields;
-  return yAxisFields && yAxisFields.length > 0 ? generatePivotTableYAxis(pivot, pivotTable.columns, yAxisFields[0]) : yAxisFields;
-}
-async function getDashboard(dashboardName, client, getToken, tenants, flags) {
-  const { data: resp } = await quillFetch({
-    client,
-    task: "dashboard",
-    metadata: {
-      name: dashboardName,
-      clientId: client.publicKey,
-      databaseType: client.databaseType,
-      useNewNodeSql: true,
-      tenants,
-      flags
-    },
-    getToken
-  });
-  return {
-    ...resp,
-    createdAt: resp.createdAt && new Date(resp.createdAt),
-    dateFilter: resp.dateFilter ? {
-      ...resp.dateFilter,
-      presetOptions: resp.dateFilter.presetOptions?.map(
-        (preset) => ({
-          ...preset,
-          loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
-          loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
-        })
-      ),
-      defaultPresetRanges: resp.dateFilter.defaultPresetRanges?.map(
-        (preset) => ({
-          ...preset,
-          loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
-          loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
-        })
-      )
-    } : void 0
-  };
-}
-
-// src/utils/chartBuilder.ts
-var numberFormatOptions = [
-  "whole_number",
-  "one_decimal_place",
-  "two_decimal_places",
-  "dollar_amount",
-  "dollar_cents",
-  "percentage"
-];
-var dateFormatOptions = [
-  "MMM_yyyy",
-  "MMM_dd",
-  "MMM_dd_yyyy",
-  "MMM_dd_hh:mm_ap_pm",
-  "hh_ap_pm",
-  "date",
-  "timestamptz"
-];
-var NUMBER_OPTIONS = [
-  { value: "whole_number", label: "whole number" },
-  { value: "one_decimal_place", label: "one decimal place" },
-  { value: "two_decimal_places", label: "two decimal places" },
-  { value: "dollar_amount", label: "dollar amount" },
-  { value: "dollar_cents", label: "dollar and cent amount" },
-  { value: "percent", label: "percentage" }
-];
-var DATE_OPTIONS = [
-  { value: "MMM_yyyy", label: "month" },
-  { value: "MMM_dd", label: "day" },
-  { value: "MMM_dd_yyyy", label: "day and year" },
-  { value: "MMM_dd_hh:mm_ap_pm", label: "day and time" },
-  { value: "hh_ap_pm", label: "hour" }
-];
-var ALL_FORMAT_OPTIONS = [
-  ...NUMBER_OPTIONS,
-  ...DATE_OPTIONS,
-  { value: "string", label: "string" }
-];
-function createInitialFormData(columns) {
-  const firstNumberColumn = columns?.find(
-    (col) => numberFormatOptions.includes(col.format)
-  );
-  const firstStringColumn = columns?.find(
-    (col) => !numberFormatOptions.includes(col.format) && !dateFormatOptions.includes(col.format)
-  );
-  const firstDateColumn = columns?.find(
-    (col) => dateFormatOptions.includes(col.format)
-  );
-  const xAxisField = firstStringColumn?.field || firstDateColumn?.field || firstNumberColumn?.field || columns?.[0]?.field || "";
-  const xAxisFormat = firstStringColumn?.format || firstDateColumn?.format || firstNumberColumn?.format || columns?.[0]?.format || "string";
-  const formEmptyState = {
-    name: "",
-    columns: columns.map((col) => {
-      return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
-    }),
-    xAxisField,
-    xAxisFormat,
-    yAxisFields: [
-      {
-        field: firstNumberColumn?.field || columns?.[0]?.field || "",
-        label: "",
-        format: firstNumberColumn?.format || columns?.[0]?.format || "string"
-      }
-    ],
-    xAxisLabel: "",
-    chartType: firstNumberColumn ? "line" : "table",
-    pivot: null,
-    template: true,
-    referenceLines: []
-  };
-  return formEmptyState;
-}
-
-// src/utils/error.ts
-var DataLoadError = class extends Error {
-  data;
-  constructor(message, data) {
-    super(message);
-    this.name = "DataLoadError";
-    this.data = data;
-  }
-};
-
 // src/components/ReportBuilder/convert.ts
-var import_date_fns8 = require("date-fns");
+var import_date_fns7 = require("date-fns");
 function recursiveSearchAndReplace(node, search, replace) {
   if (typeof node !== "object") {
     return;
@@ -19803,7 +18595,7 @@ function convertStringComparison(node, databaseType) {
         searchAndReplace(element);
       });
     } else if (typeof obj === "object" && obj !== null) {
-      if (obj.type === "binary_expr" && (obj.operator === "=" && !(0, import_date_fns8.isValid)((0, import_date_fns8.parseISO)(obj.right.value)) || // don't do it on date objects
+      if (obj.type === "binary_expr" && (obj.operator === "=" && !(0, import_date_fns7.isValid)((0, import_date_fns7.parseISO)(obj.right.value)) || // don't do it on date objects
       obj.operator === "LIKE" || obj.operator === "ILIKE") && obj.left && (obj.left.type === "column_ref" || obj.left.type === "double_quote_string") && obj.right && obj.right.type === "single_quote_string") {
         obj.operator = "LIKE";
         obj.left = {
@@ -23144,6 +21936,29 @@ var import_jspdf = __toESM(require("jspdf"), 1);
 
 // src/hooks/useDashboard.ts
 var import_react2 = require("react");
+
+// src/utils/merge.ts
+var import_date_fns8 = require("date-fns");
+var import_date_fns_tz2 = require("date-fns-tz");
+function mergeComparisonRange(resp) {
+  if (resp.chartType === "table") return resp;
+  const compRows = resp.compareRows;
+  if (!compRows) return resp;
+  const newRows = resp.rows.map((row, i) => {
+    if (i < compRows.length) {
+      const compRow = compRows[i];
+      const newRow = { ...row };
+      for (const [key, value] of Object.entries(compRow)) {
+        newRow[`comparison_${key}`] = value;
+      }
+      return newRow;
+    }
+    return row;
+  });
+  return { ...resp, rows: newRows };
+}
+
+// src/hooks/useDashboard.ts
 var useDashboardInternal = (dashboardName, customFilters) => {
   const [dashboard] = (0, import_react2.useContext)(DashboardContext);
   const {
@@ -28368,7 +27183,7 @@ var ChartTooltipPrimary = (props) => /* @__PURE__ */ (0, import_jsx_runtime31.js
             paddingTop: 2,
             paddingBottom: 2
           },
-          children: props.label && !isNaN(new Date(props.label)) && props.dateFormatter ? props.dateFormatter(props.label) : props.label && !isNaN(new Date(props.label)) ? (0, import_date_fns10.format)(new Date(props.label), "MMM yyyy") : props.label || "-"
+          children: !isNaN(new Date(props.label)) && props.dateFormatter ? props.dateFormatter(props.label) : !isNaN(new Date(props.label)) ? (0, import_date_fns10.format)(new Date(props.label), "MMM yyyy") : props.label
         }
       )
     }
@@ -28417,9 +27232,9 @@ function reformatComparisonPayload(props, primaryLabel, comparisonLabel) {
       const nameKey = isComparison ? `comparison_${props.xAxisField}` : props.xAxisField;
       const days = LABEL_TO_DAYS[primaryLabel] ?? 0;
       const primaryDate = item.payload[props.xAxisField] ?? 0;
-      const compDate = primaryDate ? (0, import_date_fns10.subDays)(new Date(primaryDate), days + 1) : /* @__PURE__ */ new Date();
+      const compDate = (0, import_date_fns10.subDays)(new Date(primaryDate), days + 1);
       const date = item.payload[nameKey] ?? (0, import_date_fns10.format)(compDate, props.xAxisFormat);
-      const name2 = props.dateFormatter ? props.dateFormatter(date) : date;
+      const name2 = props.dateFormatter(date);
       const color2 = item.color;
       const value = props.valueFormatter(item.value, item.name);
       if (!columnsByKey[""]) {
@@ -28451,7 +27266,7 @@ function reformatComparisonPayload(props, primaryLabel, comparisonLabel) {
   return columnsByKey;
 }
 function getTooltipLabel(props, altTooltipLabel, isDateXAxis) {
-  return props.payload.length <= 2 && altTooltipLabel && isDateXAxis ? altTooltipLabel && !isNaN(new Date(altTooltipLabel)) && props.dateFormatter ? props.dateFormatter(altTooltipLabel) : altTooltipLabel && !isNaN(new Date(altTooltipLabel)) ? (0, import_date_fns10.format)(new Date(altTooltipLabel), "MMM yyyy") : altTooltipLabel || "-" : props.label && !isNaN(new Date(props.label)) && props.dateFormatter ? props.dateFormatter(props.label) : props.label && !isNaN(new Date(props.label)) ? (0, import_date_fns10.format)(new Date(props.label), "MMM yyyy") : props.label || "-";
+  return props.payload.length <= 2 && altTooltipLabel && isDateXAxis ? !isNaN(new Date(altTooltipLabel)) && props.dateFormatter ? props.dateFormatter(altTooltipLabel) : !isNaN(new Date(altTooltipLabel)) ? (0, import_date_fns10.format)(new Date(altTooltipLabel), "MMM yyyy") : altTooltipLabel : !isNaN(new Date(props.label)) && props.dateFormatter ? props.dateFormatter(props.label) : !isNaN(new Date(props.label)) ? (0, import_date_fns10.format)(new Date(props.label), "MMM yyyy") : props.label;
 }
 function ChartTooltipComparison(props) {
   const isDateXAxis = isDateFormat(props.xAxisFormat);
@@ -42572,7 +41387,6 @@ function ChartBuilder({
   }, [reportId]);
   const [windowWidth, setWindowWidth] = (0, import_react43.useState)(1200);
   const [rows, setRows] = (0, import_react43.useState)(report?.rows ?? []);
-  const [itemQuery, setItemQuery] = (0, import_react43.useState)(report?.itemQuery);
   const [rowCount, setRowCount] = (0, import_react43.useState)(report?.rowCount ?? 0);
   const [maxPage, setMaxPage] = (0, import_react43.useState)(0);
   const [isLoading, setIsLoading] = (0, import_react43.useState)(false);
@@ -43302,7 +42116,7 @@ function ChartBuilder({
           pivot,
           dateBucket,
           dateFilter,
-          report: report ? { ...report, ...tableInfo ?? { itemQuery } } : void 0,
+          report: report ? { ...report, ...tableInfo } : void 0,
           client,
           uniqueValues,
           dashboardName: destinationDashboardName,
@@ -43463,7 +42277,6 @@ function ChartBuilder({
       setCurrentProcessing(processing);
       setRows(tableInfo.rows);
       setProcessedColumns(processColumns(tableInfo.columns));
-      setItemQuery(tableInfo.itemQuery);
       fetchRowCount(processing, overrideFilters);
       if (formData.pivot) {
         try {
@@ -44369,7 +43182,7 @@ function ChartBuilder({
                                       uniqueValuesIsLoading: initialUniqueValuesIsLoading,
                                       initialSelectedPivotTable: selectedPivotTable,
                                       pivotRecommendationsEnabled,
-                                      report: report ? { ...report, ...{ itemQuery } } : void 0,
+                                      report,
                                       dashboardName: destinationDashboardName || "",
                                       dateFilter: filtersEnabled ? currentDashboardFilters?.find(
                                         (f) => f.filterType === "date_range"