@quillsql/react 2.16.0 → 2.16.1

package/dist/index.js

@@ -14787,6 +14787,21 @@ function isDateFormat(xAxisFormat) {
   const isDate = DATE_FORMATS.includes(xAxisFormat);
   return isDate;
 }
+function getComparisonInterval(comparisonRange, dateBucket) {
+  const dayCount = differenceInDays2(
+    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 = differenceInDays2(dateRange.end, dateRange.start);
   if (difference < 14) {
@@ -16600,759 +16615,305 @@ function parseValueFromBigQueryDates(rows, columns) {
   });
 }
 
-// src/utils/pivotConstructor.ts
-async function generatePivotWithSQL({
-  pivot,
-  report,
-  client,
-  dateBucket,
-  dateFilter,
-  distinctStrings,
-  dashboardName,
-  tenants,
-  additionalProcessing,
-  pivotQuery,
-  comparisonPivotQuery,
-  getPivotRowCount = true,
-  caller,
-  getToken
-}) {
-  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
+// src/utils/merge.ts
+import {
+  add,
+  startOfDay as startOfDay3,
+  startOfMonth,
+  startOfWeek as startOfWeek3,
+  startOfYear
+} from "date-fns";
+import { utcToZonedTime as utcToZonedTime2 } from "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;
       }
-    ];
-  }
-  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
+      return newRow;
+    }
+    return row;
   });
-  if (resp.data?.success === false) {
-    throw resp.data.errorMessage;
+  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 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];
-        }
-      });
-    });
+  const [, valueStr, unit] = match;
+  if (!valueStr || !unit) {
+    throw new Error("Could not parse interval");
   }
-  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;
-    }
-    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;
-      });
-    }
+  const value = parseInt(valueStr, 10);
+  const parsedDate = typeof date === "string" ? new Date(date) : date;
+  switch (unit) {
+    case "day":
+      return add(parsedDate, { days: value });
+    case "month":
+      return add(parsedDate, { months: value });
+    case "year":
+      return add(parsedDate, { years: value });
+    default:
+      throw new Error(`Unsupported interval unit: ${unit}`);
   }
-  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 generatePivotTableYAxis(pivot, cols, yAxisField) {
-  if (pivot?.aggregationType === "count") {
-    return [
-      {
-        field: pivot.valueField ?? "count",
-        label: yAxisField.label,
-        format: yAxisField.format
-      }
-    ];
+function dateTrunc(date, granularity = "day", databaseType) {
+  const weekStartsOn = databaseType === "mssql" ? 0 : 1;
+  const timeZone = "UTC";
+  const zonedDate = utcToZonedTime2(date, timeZone);
+  switch (granularity.toLowerCase()) {
+    case "week":
+      return startOfWeek3(zonedDate, { weekStartsOn });
+    case "month":
+      return startOfMonth(zonedDate);
+    case "day":
+      return startOfDay3(zonedDate);
+    case "year":
+      return startOfYear(zonedDate);
+    default:
+      throw new Error(`Unsupported granularity: ${granularity}`);
   }
-  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}` : ""}`
-  );
+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);
 }
-async function generatePivotTable({
+function mergeComparisonPivotRows({
   pivot,
+  rows,
+  compRows,
+  databaseType,
   dateBucket,
-  dateFilter,
-  report,
-  client,
-  getToken,
-  eventTracking,
-  uniqueValues,
-  dashboardName,
-  tenants,
-  additionalProcessing,
-  caller,
-  pivotQuery
+  comparisonInterval,
+  columnFieldValues
 }) {
-  try {
-    if (report && client) {
-      const pivotTable = await generatePivotWithSQL({
-        pivotQuery,
-        pivot,
-        report,
-        client,
-        dateBucket,
-        dateFilter,
-        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}`);
+  if (!compRows || !compRows.length) return rows;
+  if (pivot.columnField && columnFieldValues && columnFieldValues.length > 0) {
+    return merge2DPivotRows(
+      pivot,
+      rows,
+      compRows,
+      columnFieldValues,
+      databaseType,
+      dateBucket,
+      comparisonInterval
+    );
   }
-  throw Error("Failed to generate pivot table: invalid report");
+  if (pivot.rowField) {
+    return merge1DPivotRows(
+      pivot,
+      rows,
+      compRows,
+      databaseType,
+      dateBucket,
+      comparisonInterval
+    );
+  }
+  return mergeAggregatedRows(pivot, rows, compRows);
 }
-
-// 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;
+function merge2DPivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval) {
+  if (!pivot || !pivot.columnField) {
+    return [];
   }
-  const indexAdjustedPage = page;
-  const pageInterval = Math.floor(
-    indexAdjustedPage * pagination.rowsPerPage / pagination.rowsPerRequest
-  );
-  const indexAdjustedPreviousPage = maxPage;
-  const previousPageInterval = Math.floor(
-    indexAdjustedPreviousPage * pagination.rowsPerPage / pagination.rowsPerRequest
+  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
+    return merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues);
+  }
+  return merge2DDatePivotRows(
+    pivot,
+    rows,
+    compRows,
+    columnFieldValues,
+    databaseType,
+    dateBucket,
+    comparisonInterval
   );
-  return pageInterval > previousPageInterval;
 }
-function shouldSortInMemory(pagination, rowCount) {
-  if (!rowCount || rowCount < pagination.rowsPerRequest) {
-    return true;
+function merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues) {
+  if (!pivot.rowField || !pivot.aggregations?.some((agg) => agg.valueField)) {
+    return rows;
   }
-  return false;
+  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
+    };
+  });
 }
-
-// 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) {
+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 {
-      ...defaultDashboardItem,
-      id: item._id,
-      name: item.name
+      ...row,
+      ...comparisonFields
     };
+  });
+}
+function merge1DPivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval) {
+  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
+    return merge1DStringPivotRows(pivot, rows, compRows);
   }
-  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
-          });
-        }
-      });
-    });
+  return merge1DDatePivotRows(
+    pivot,
+    rows,
+    compRows,
+    databaseType,
+    dateBucket,
+    comparisonInterval
+  );
+}
+function merge1DStringPivotRows(pivot, rows, compRows) {
+  if (!pivot.rowField || !pivot.valueField) {
+    return rows;
   }
-  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 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";
+      }
+    }
     return {
-      fieldType: converted_field.fieldType,
-      dataTypeID: converted_field.dataTypeID,
-      jsType: converted_field.jsType,
-      ...col,
-      label: snakeAndCamelCaseToTitleCase(col.label)
+      ...row,
+      [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow ? matchingCompRow[`${pivot.valueField}${aggregationSuffix}`] : null
     };
   });
-  let pivotTable;
-  let pivotError;
-  try {
-    const shouldPaginatePivotAsTable = item.chartType === "table";
-    const pivotChartProcessing = {
-      page: DEFAULT_PAGINATION
+}
+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,
+        dateBucket,
+        databaseType
+      );
+      return truncatedRowDate.toISOString() === truncatedCompRowDate.toISOString();
+    });
+    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";
+      }
+    }
+    return {
+      ...row,
+      [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow?.[`${pivot.valueField}${aggregationSuffix}`] || null
     };
-    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"
+  });
+}
+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";
       }
-    });
-    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] });
     }
+    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("'", "''");
   }
-  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 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");
+}
+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 {
-    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('"', "")}"`;
+      return `"${column.replaceAll('"', "")}"`;
     }
     case "mysql": {
       if (column === "") {
@@ -17426,6 +16987,51 @@ function processColumnReference(column, databaseType, fallbackOnNull, isColumnFi
 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})`;
+  }
+  return `TIMESTAMP_ADD(${processColumnReference(rowField, databaseType)}, INTERVAL ${interval2} )`;
+}
+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})`;
+  }
+  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`;
+}
 function generateCountQuery(fields, query, databaseType) {
   let countQuery = [];
   let cteQuery = `WITH querytable AS (${query.replace(";", "")}) `;
@@ -17544,12 +17150,1123 @@ function generateMinMaxDateRangeQueries(columnFields, query, databaseType) {
   const distinctQueries = columnFields.map((field) => {
     const wrappedField = ["postgresql", "clickhouse"].includes(
       databaseType.toLowerCase()
-    ) ? 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`;
+    ) ? `"${field}"` : field;
+    return `SELECT '${field}' AS field, ${min2}(${wrappedField})${cast} AS min_range, ${max2}(${wrappedField})${cast} AS max_range 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 ({
@@ -18209,86 +18926,571 @@ var fetchResultsByReport = async ({
   if (client.databaseType && client.databaseType.toLowerCase() === "bigquery") {
     parseValueFromBigQueryDates(rows, columns);
   }
-  return { rows, columns, rowCount, error };
-};
-var fetchTableByAST = async (ast, client, getToken, tenants, eventTracking, dashboardName, processing, customFields, rowsOnly, rowCountOnly) => {
-  let rows = [];
-  let columns = [];
-  let rowCount;
-  let error;
-  let itemQuery;
-  let referencedTables;
-  try {
-    const fetchResp = await quillFetch({
-      client,
-      task: "patterns",
-      metadata: {
-        clientId: client.publicKey,
-        ast,
-        customFields,
-        additionalProcessing: processing,
-        useUpdatedDataGathering: true,
-        useNewNodeSql: true,
-        rowsOnly,
-        rowCountOnly,
-        dashboardName,
-        tenants
-      },
-      getToken
-    });
-    const resp = await parseFetchResponse(
-      client,
-      "patterns",
-      fetchResp,
-      getToken
-    );
-    if (resp.errorMessage || resp.name === "error") {
-      throw new Error(resp.errorMessage);
-    }
-    processFilterErrorList(resp);
-    if (resp.rowCount !== void 0) {
-      rowCount = resp.rowCount;
+  return { rows, columns, rowCount, error };
+};
+var fetchTableByAST = async (ast, client, getToken, tenants, eventTracking, dashboardName, processing, customFields, rowsOnly, rowCountOnly) => {
+  let rows = [];
+  let columns = [];
+  let rowCount;
+  let error;
+  let itemQuery;
+  let referencedTables;
+  try {
+    const fetchResp = await quillFetch({
+      client,
+      task: "patterns",
+      metadata: {
+        clientId: client.publicKey,
+        ast,
+        customFields,
+        additionalProcessing: processing,
+        useUpdatedDataGathering: true,
+        useNewNodeSql: true,
+        rowsOnly,
+        rowCountOnly,
+        dashboardName,
+        tenants
+      },
+      getToken
+    });
+    const resp = await parseFetchResponse(
+      client,
+      "patterns",
+      fetchResp,
+      getToken
+    );
+    if (resp.errorMessage || resp.name === "error") {
+      throw new Error(resp.errorMessage);
+    }
+    processFilterErrorList(resp);
+    if (resp.rowCount !== void 0) {
+      rowCount = resp.rowCount;
+    }
+    const gatheredRows = resp.rows && resp.rows.length ? resp.rows : [];
+    columns = resp.fields.map((elem) => convertPostgresColumn(elem));
+    rows = gatheredRows;
+    itemQuery = resp.itemQuery;
+    referencedTables = resp.referencedTables;
+    if (customFields) {
+      const tables = referencedTables ?? [];
+      tables.forEach((table) => {
+        const _customFields = customFields?.[table] ?? [];
+        columns.forEach((col) => {
+          if (_customFields.some((field) => {
+            return field.field === col.field;
+          })) {
+            col.inferFormat = true;
+          }
+        });
+      });
+    }
+  } catch (e) {
+    eventTracking?.logError?.({
+      type: "bug",
+      // TODO: determine type
+      severity: "high",
+      message: "Error fetching table by AST",
+      errorMessage: e.message,
+      errorStack: e.stack,
+      errorData: {
+        caller: "fetchTableByAST",
+        function: "fetchTableByAST"
+      }
+    });
+    rows = [];
+    columns = [];
+    rowCount = 0;
+    error = e.message;
+  }
+  if (client.databaseType && client.databaseType.toLowerCase() === "bigquery") {
+    parseValueFromBigQueryDates(rows, columns);
+  }
+  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
+      };
     }
-    const gatheredRows = resp.rows && resp.rows.length ? resp.rows : [];
-    columns = resp.fields.map((elem) => convertPostgresColumn(elem));
-    rows = gatheredRows;
-    itemQuery = resp.itemQuery;
-    referencedTables = resp.referencedTables;
-    if (customFields) {
-      const tables = referencedTables ?? [];
-      tables.forEach((table) => {
-        const _customFields = customFields?.[table] ?? [];
-        columns.forEach((col) => {
-          if (_customFields.some((field) => {
-            return field.field === col.field;
-          })) {
-            col.inferFormat = true;
-          }
+    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;
     }
-  } catch (e) {
-    eventTracking?.logError?.({
-      type: "bug",
-      // TODO: determine type
-      severity: "high",
-      message: "Error fetching table by AST",
-      errorMessage: e.message,
-      errorStack: e.stack,
-      errorData: {
-        caller: "fetchTableByAST",
-        function: "fetchTableByAST"
-      }
-    });
-    rows = [];
-    columns = [];
-    rowCount = 0;
-    error = e.message;
   }
-  if (client.databaseType && client.databaseType.toLowerCase() === "bigquery") {
-    parseValueFromBigQueryDates(rows, columns);
+  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;
   }
-  return { rows, columns, rowCount, error, itemQuery, referencedTables };
 };
 
 // src/components/ReportBuilder/convert.ts
@@ -21942,35 +23144,6 @@ import jsPDF from "jspdf";
 
 // src/hooks/useDashboard.ts
 import { useContext, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
-
-// src/utils/merge.ts
-import {
-  add,
-  startOfDay as startOfDay3,
-  startOfMonth,
-  startOfWeek as startOfWeek3,
-  startOfYear
-} from "date-fns";
-import { utcToZonedTime as utcToZonedTime2 } from "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] = useContext(DashboardContext);
   const {
@@ -30549,23 +31722,53 @@ function QuillMetricComponent({
                       width: "100%"
                     }
                   }
-                ) : !report?.rows?.[0] || report.rows[0][report.xAxisField] === null ? /* @__PURE__ */ jsx43(
+                ) : !report?.rows || report?.rows?.length === 0 || report.rows[0]?.[report.xAxisField] === null || report.rows[0]?.[report.xAxisField] === void 0 ? /* @__PURE__ */ jsx43(
                   "div",
                   {
                     style: {
-                      display: "flex",
-                      flex: "1 0 auto",
-                      // height: '100%',
-                      margin: "auto",
-                      justifyContent: "center",
-                      alignItems: "center",
-                      fontSize: 13,
-                      fontFamily: theme?.fontFamily,
-                      color: theme?.secondaryTextColor,
-                      maxWidth: "100%",
-                      width: "100%"
+                      padding: 0,
+                      height: "100%",
+                      width: "100%",
+                      boxSizing: "content-box",
+                      flex: 1
                     },
-                    children: "No results"
+                    children: /* @__PURE__ */ jsx43(
+                      "div",
+                      {
+                        style: {
+                          fontFamily: theme?.fontFamily,
+                          fontSize: 32,
+                          color: theme?.primaryTextColor,
+                          fontWeight: "600",
+                          textOverflow: "ellipsis",
+                          margin: 0,
+                          whiteSpace: "nowrap",
+                          boxSizing: "content-box",
+                          maxWidth: "100%",
+                          textAlign: "left",
+                          overflow: "hidden",
+                          height: "100%",
+                          minHeight: "80px",
+                          display: "flex",
+                          width: "100%",
+                          flexDirection: "row",
+                          justifyContent: "center",
+                          alignItems: "center"
+                        },
+                        children: /* @__PURE__ */ jsx43(
+                          "span",
+                          {
+                            style: {
+                              fontFamily: theme?.fontFamily,
+                              fontSize: 13,
+                              color: theme?.secondaryTextColor,
+                              fontWeight: "normal"
+                            },
+                            children: "No results"
+                          }
+                        )
+                      }
+                    )
                   }
                 ) : /* @__PURE__ */ jsx43(
                   MetricDisplay,
@@ -31756,7 +32959,7 @@ function USMap({
     acc[curr[xAxisField]?.toString()] = curr;
     return acc;
   }, {});
-  const measureField = yAxisFields[0].field;
+  const measureField = yAxisFields[0]?.field;
   const [scaleLog, setScaleLog] = useState14(null);
   useEffect12(() => {
     import("d3-scale").then((scale) => {
@@ -31792,6 +32995,29 @@ function USMap({
   const hoveredValue = useMemo12(() => {
     return !hoveredState ? void 0 : mappedData[fipsToNames[hoveredState]?.abbreviation ?? ""]?.[measureField] ?? mappedData[fipsToNames[hoveredState]?.name ?? ""]?.[measureField] ?? mappedData[fipsToNames[hoveredState]?.abbreviation?.toLowerCase() ?? ""]?.[measureField] ?? mappedData[fipsToNames[hoveredState]?.name?.toLowerCase() ?? ""]?.[measureField];
   }, [hoveredState, mappedData, measureField]);
+  if (!measureField) {
+    return /* @__PURE__ */ jsx45(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flex: "1 0 auto",
+          marginLeft: "auto",
+          marginRight: "auto",
+          marginTop: "auto",
+          marginBottom: "auto",
+          justifyContent: "center",
+          alignItems: "center",
+          fontSize: 13,
+          color: theme?.secondaryTextColor,
+          fontFamily: theme?.fontFamily,
+          ...containerStyle
+        },
+        className,
+        children: "No results"
+      }
+    );
+  }
   return /* @__PURE__ */ jsxs34(
     "div",
     {
@@ -31924,7 +33150,7 @@ function WorldMap({
     acc[curr[xAxisField]?.toString()] = curr;
     return acc;
   }, {});
-  const measureField = yAxisFields[0].field;
+  const measureField = yAxisFields[0]?.field;
   const [scaleLog, setScaleLog] = useState14(null);
   useEffect12(() => {
     import("d3-scale").then((scale) => {
@@ -31960,6 +33186,29 @@ function WorldMap({
   const hoveredValue = useMemo12(() => {
     return !hoveredCountry ? void 0 : mappedData[isoToNames[hoveredCountry]?.abbreviation ?? ""]?.[measureField] ?? mappedData[isoToNames[hoveredCountry]?.name ?? ""]?.[measureField] ?? mappedData[isoToNames[hoveredCountry]?.abbreviation?.toLowerCase() ?? ""]?.[measureField] ?? mappedData[isoToNames[hoveredCountry]?.name?.toLowerCase() ?? ""]?.[measureField];
   }, [hoveredCountry, mappedData, measureField]);
+  if (!measureField) {
+    return /* @__PURE__ */ jsx45(
+      "div",
+      {
+        style: {
+          display: "flex",
+          flex: "1 0 auto",
+          marginLeft: "auto",
+          marginRight: "auto",
+          marginTop: "auto",
+          marginBottom: "auto",
+          justifyContent: "center",
+          alignItems: "center",
+          fontSize: 13,
+          color: theme?.secondaryTextColor,
+          fontFamily: theme?.fontFamily,
+          ...containerStyle
+        },
+        className,
+        children: "No results"
+      }
+    );
+  }
   return /* @__PURE__ */ jsxs34(
     "div",
     {
@@ -34467,27 +35716,41 @@ var ChartDisplay = ({
     );
   }
   if (config?.chartType?.toLowerCase() === "metric") {
-    if (!config?.rows || config?.rows?.length === 0 || // @ts-ignore
-    config?.rows[0][config?.xAxisField] === null) {
+    if (!config?.rows || config?.rows?.length === 0 || config?.rows[0]?.[config?.xAxisField] === null || config?.rows[0]?.[config?.xAxisField] === void 0) {
       return /* @__PURE__ */ jsx48(
         "div",
         {
           style: {
-            display: "flex",
-            flex: "1 0 auto",
-            // height: containerStyle?.height || '100%',
-            margin: "auto",
-            justifyContent: "center",
-            alignItems: "center",
-            fontSize: 13,
             fontFamily: theme?.fontFamily,
-            color: theme?.secondaryTextColor,
+            fontSize: 32,
+            color: theme?.primaryTextColor,
+            fontWeight: "600",
+            textOverflow: "ellipsis",
+            margin: 0,
+            whiteSpace: "nowrap",
+            boxSizing: "content-box",
             maxWidth: "100%",
+            textAlign: "left",
+            overflow: "hidden",
+            height: containerStyle?.height || "100%",
+            display: "flex",
             width: "100%",
+            flexDirection: "row",
+            alignItems: "center",
             ...containerStyle
           },
           className,
-          children: "No results"
+          children: /* @__PURE__ */ jsx48(
+            "span",
+            {
+              style: {
+                fontFamily: theme?.fontFamily,
+                fontSize: 13,
+                color: theme?.secondaryTextColor
+              },
+              children: "No results"
+            }
+          )
         }
       );
     }
@@ -41440,15 +42703,19 @@ function ChartBuilderWithModal(props) {
       title: title || "Add to dashboard",
       width: isHorizontalView ? modalWidth : void 0,
       height: isHorizontalView ? modalHeight : void 0,
-      children: (props.reportId ? dashboard[props.reportId] ?? props.tempReport : props.tempReport) ? /* @__PURE__ */ jsx65(
-        ChartBuilder,
-        {
-          ...props,
-          filtersEnabled: filtersEnabledState,
-          onFiltersEnabledChanged: setFiltersEnabledState,
-          runQueryOnMount: filtersEnabledState
-        }
-      ) : /* @__PURE__ */ jsx65("div", { style: { padding: 20 }, children: /* @__PURE__ */ jsx65(QuillLoadingComponent, {}) })
+      children: (() => {
+        const resolvedReport = props.reportId ? dashboard[props.reportId] ?? props.tempReport : props.tempReport;
+        return resolvedReport ? /* @__PURE__ */ jsx65(
+          ChartBuilder,
+          {
+            ...props,
+            tempReport: resolvedReport,
+            filtersEnabled: filtersEnabledState,
+            onFiltersEnabledChanged: setFiltersEnabledState,
+            runQueryOnMount: filtersEnabledState
+          }
+        ) : /* @__PURE__ */ jsx65("div", { style: { padding: 20 }, children: /* @__PURE__ */ jsx65(QuillLoadingComponent, {}) });
+      })()
     }
   ) });
 }
@@ -41498,6 +42765,7 @@ function ChartBuilder({
   hideSubmitButton = false,
   hideDateRangeFilter = false,
   showTableFormatOptions,
+  showDashboardFilterFields,
   initialUniqueValues,
   initialUniqueValuesIsLoading,
   pivotRecommendationsEnabled = true,
@@ -41527,9 +42795,10 @@ function ChartBuilder({
   const { tenants, flags } = useContext26(TenantContext);
   const report = useMemo21(() => {
     return reportId && !tempReport ? allReportsById[reportId] : tempReport;
-  }, [reportId]);
+  }, [reportId, tempReport, allReportsById]);
   const [windowWidth, setWindowWidth] = useState28(1200);
   const [rows, setRows] = useState28(report?.rows ?? []);
+  const [itemQuery, setItemQuery] = useState28(report?.itemQuery);
   const [rowCount, setRowCount] = useState28(report?.rowCount ?? 0);
   const [maxPage, setMaxPage] = useState28(0);
   const [isLoading, setIsLoading] = useState28(false);
@@ -42259,7 +43528,7 @@ function ChartBuilder({
           pivot,
           dateBucket,
           dateFilter,
-          report: report ? { ...report, ...tableInfo } : void 0,
+          report: report ? { ...report, ...tableInfo ?? { itemQuery } } : void 0,
           client,
           uniqueValues,
           dashboardName: destinationDashboardName,
@@ -42420,6 +43689,7 @@ function ChartBuilder({
       setCurrentProcessing(processing);
       setRows(tableInfo.rows);
       setProcessedColumns(processColumns(tableInfo.columns));
+      setItemQuery(tableInfo.itemQuery);
       fetchRowCount(processing, overrideFilters);
       if (formData.pivot) {
         try {
@@ -43325,7 +44595,7 @@ function ChartBuilder({
                                       uniqueValuesIsLoading: initialUniqueValuesIsLoading,
                                       initialSelectedPivotTable: selectedPivotTable,
                                       pivotRecommendationsEnabled,
-                                      report,
+                                      report: report ? { ...report, ...{ itemQuery } } : void 0,
                                       dashboardName: destinationDashboardName || "",
                                       dateFilter: filtersEnabled ? currentDashboardFilters?.find(
                                         (f) => f.filterType === "date_range"
@@ -44018,7 +45288,7 @@ function ChartBuilder({
                           ]
                         }
                       ),
-                      specificDashboardFilters.length > 0 && isAdmin && /* @__PURE__ */ jsxs47(
+                      specificDashboardFilters.length > 0 && (showDashboardFilterFields || isAdmin) && /* @__PURE__ */ jsxs47(
                         "div",
                         {
                           style: {
@@ -44029,7 +45299,7 @@ function ChartBuilder({
                           },
                           children: [
                             /* @__PURE__ */ jsx65(HeaderComponent, { label: "Dashboard filter fields" }),
-                            isAdmin && formData.dateField && dashboardConfig[formData.dashboardName ?? destinationDashboardName ?? ""]?.config.dateFilter?.label && /* @__PURE__ */ jsxs47(ChartBuilderInputRowContainer, { children: [
+                            (showDashboardFilterFields || isAdmin) && formData.dateField && dashboardConfig[formData.dashboardName ?? destinationDashboardName ?? ""]?.config.dateFilter?.label && /* @__PURE__ */ jsxs47(ChartBuilderInputRowContainer, { children: [
                               /* @__PURE__ */ jsx65(
                                 TextInputComponent,
                                 {
@@ -44968,6 +46238,7 @@ function SQLEditor({
   CheckboxComponent = QuillChartBuilderCheckboxComponent,
   defaultQuery,
   destinationDashboard,
+  destinationSection,
   onChangeQuery,
   onChangeData,
   onChangeColumns,
@@ -44977,12 +46248,16 @@ function SQLEditor({
   onCloseChartBuilder,
   isChartBuilderEnabled = false,
   isAdminEnabled = false,
+  chartBuilderOptions,
   chartBuilderTitle,
   runQueryOnMount = false,
   onAddToDashboardComplete,
+  onSubmitCreateReport,
+  onSubmitEditReport,
   onSaveQueryComplete,
   addToDashboardButtonLabel = "Add to dashboard",
   report = void 0,
+  reportId = void 0,
   organizationName = void 0,
   isChartBuilderHorizontalView = true,
   containerStyle = { height: "100vh" },
@@ -44993,7 +46268,7 @@ function SQLEditor({
   const [sqlPrompt, setSqlPrompt] = useState30("");
   const [client] = useContext28(ClientContext);
   const [theme] = useContext28(ThemeContext);
-  const { tenants } = useContext28(TenantContext);
+  const { tenants, flags } = useContext28(TenantContext);
   const { dashboards } = useDashboards();
   const {
     data,
@@ -45002,6 +46277,7 @@ function SQLEditor({
   } = useDashboardInternal(destinationDashboard);
   const { getToken, quillFetchWithToken } = useContext28(FetchContext);
   const { eventTracking } = useContext28(EventTrackingContext);
+  const { allReportsById } = useAllReports();
   const destinationDashboardConfig = useMemo22(() => {
     return dashboards?.find((d) => d.name === destinationDashboard);
   }, [dashboards, destinationDashboard]);
@@ -45069,6 +46345,46 @@ function SQLEditor({
       reload();
     }
   }, [data, dashboardIsLoading]);
+  useEffect24(() => {
+    const loadReport = async () => {
+      let reportToLoad;
+      if (!client) {
+        return;
+      }
+      try {
+        if (!reportId) {
+          throw new Error("Report ID is required");
+        }
+        reportToLoad = allReportsById[reportId];
+        if (!reportToLoad) {
+          throw new Error("Report not found");
+        }
+        setQuery(reportToLoad.queryString || "");
+        setTempReport(reportToLoad);
+        if (reportToLoad.rows && reportToLoad.rows.length > 0) {
+          setRows(reportToLoad.rows);
+          setDisplayTable(true);
+        }
+      } catch (err) {
+        console.error(err);
+        eventTracking?.logError?.({
+          type: "bug",
+          severity: "high",
+          message: "Error loading report",
+          errorMessage: err.message,
+          errorStack: err.stack,
+          errorData: {
+            caller: "SQLEditor",
+            function: "loadReport"
+          }
+        });
+        setErrorMessage("Error when loading report");
+      }
+    };
+    if (reportId && client) {
+      loadReport();
+    }
+  }, [allReportsById[reportId || ""], client]);
   const dynamicHeight = tableRef.current ? tableRef.current.clientHeight : cachedHeight;
   const rowsPerPage = Math.max(
     DEFAULT_ROWS_PER_PAGE,
@@ -45887,13 +47203,38 @@ function SQLEditor({
             isHorizontalView: isChartBuilderHorizontalView,
             isOpen: isChartBuilderOpen,
             setIsOpen: setIsChartBuilderOpen,
-            onAddToDashboardComplete,
+            onAddToDashboardComplete: reportId || report?.id ? (data2) => {
+              if (onSubmitEditReport) {
+                onSubmitEditReport(data2);
+              } else if (onAddToDashboardComplete) {
+                onAddToDashboardComplete(data2);
+              }
+              if (!isAdminEnabled && destinationDashboard) {
+                reload(destinationDashboard, false, {
+                  report: data2,
+                  action: "upsert"
+                });
+              }
+            } : (data2) => {
+              if (onSubmitCreateReport) {
+                onSubmitCreateReport(data2);
+              } else if (onAddToDashboardComplete) {
+                onAddToDashboardComplete(data2);
+              }
+              if (!isAdminEnabled && destinationDashboard) {
+                reload(destinationDashboard, false, {
+                  report: data2,
+                  action: "upsert"
+                });
+              }
+            },
             destinationDashboard,
+            destinationSection,
             isAdmin: isAdminEnabled,
             title: chartBuilderTitle,
             buttonLabel: addToDashboardButtonLabel,
             tempReport,
-            reportId: report?.id,
+            reportId: reportId || report?.id,
             organizationName,
             CardComponent,
             TableComponent,
@@ -45918,6 +47259,8 @@ function SQLEditor({
             CheckboxComponent,
             hideDateRangeFilter: true,
             hideDeleteButton: true,
+            showTableFormatOptions: chartBuilderOptions?.showTableFormatOptions,
+            showDashboardFilterFields: chartBuilderOptions?.showDashboardFilterFields,
             onClickChartElement,
             isEditingMode: true
           }
@@ -45937,7 +47280,7 @@ function SQLEditor({
             isAdmin: false,
             title: "Save query",
             buttonLabel: "Save query",
-            tempReport,
+            tempReport: { ...tempReport, dashboardName: SAVED_QUERIES_DASHBOARD },
             reportId: report?.id,
             organizationName,
             CardComponent,
@@ -47705,7 +49048,6 @@ var useReportBuilderInternal = ({
         }
         report = allReportsById[reportId];
         if (!report) {
-          console.log("no report");
           throw new Error("Report not found");
         }
         const { ast: newAst, pivot: newPivot } = await fetchASTFromQuillReport(
@@ -50255,6 +51597,8 @@ var SaveReport = ({
   onSubmitEditReport = () => void 0,
   onSubmitCreateReport = () => void 0,
   destinationSection,
+  showTableFormatOptions,
+  showDashboardFilterFields,
   SelectComponent = QuillSelectComponent,
   TextInputComponent = QuillTextInput,
   ButtonComponent = MemoizedButton,
@@ -50287,6 +51631,7 @@ var SaveReport = ({
   ),
   submitButtonLabel
 }) => {
+  const { reload } = useDashboardInternal(reportBuilder.destinationDashboard ?? null);
   return /* @__PURE__ */ jsxs59("div", { children: [
     SaveTrigger,
     /* @__PURE__ */ jsx79(
@@ -50299,7 +51644,17 @@ var SaveReport = ({
         isHorizontalView: true,
         isOpen,
         setIsOpen,
-        onAddToDashboardComplete: reportBuilder.reportId ? onSubmitEditReport : onSubmitCreateReport,
+        onAddToDashboardComplete: reportBuilder.reportId ? (data) => {
+          onSubmitEditReport(data);
+          if (!isAdminEnabled && reportBuilder.destinationDashboard) {
+            reload(reportBuilder.destinationDashboard, false, { report: data, action: "upsert" });
+          }
+        } : (data) => {
+          onSubmitCreateReport(data);
+          if (!isAdminEnabled && reportBuilder.destinationDashboard) {
+            reload(reportBuilder.destinationDashboard, false, { report: data, action: "upsert" });
+          }
+        },
         destinationDashboard: reportBuilder.destinationDashboard,
         destinationSection,
         initialUniqueValues: reportBuilder.columnUniqueValues,
@@ -50328,6 +51683,8 @@ var SaveReport = ({
         FormContainer: ChartBuilderFormContainer,
         hideDateRangeFilter: true,
         hideDeleteButton: true,
+        showTableFormatOptions,
+        showDashboardFilterFields,
         buttonLabel: submitButtonLabel ?? (!!reportBuilder.reportId ? "Save changes" : "Add to dashboard"),
         onClickChartElement,
         isEditingMode: true
@@ -50423,6 +51780,7 @@ function ReportBuilder({
   containerStyle,
   className,
   pivotRecommendationsEnabled = true,
+  chartBuilderOptions,
   reportId,
   hideCopySQL = true,
   isChartBuilderHorizontalView = true,
@@ -50862,6 +52220,8 @@ function ReportBuilder({
             ErrorMessageComponent,
             PivotRowContainer,
             PivotColumnContainer,
+            showTableFormatOptions: chartBuilderOptions?.showTableFormatOptions,
+            showDashboardFilterFields: chartBuilderOptions?.showDashboardFilterFields,
             onClickChartElement,
             submitButtonLabel
           }
@@ -50882,7 +52242,7 @@ function ReportBuilder({
             isAdmin: false,
             title: "Save query",
             buttonLabel: "Save query",
-            tempReport,
+            tempReport: { ...tempReport, dashboardName: SAVED_QUERIES_DASHBOARD },
             reportId,
             organizationName,
             CardComponent,