@quillsql/react 2.15.16 → 2.16.0

package/dist/index.cjs

@@ -14781,21 +14781,6 @@ function isDateFormat(xAxisFormat) {
   const isDate = DATE_FORMATS.includes(xAxisFormat);
   return isDate;
 }
-function getComparisonInterval(comparisonRange, dateBucket) {
-  const dayCount = (0, import_date_fns5.differenceInDays)(
-    comparisonRange.endDate,
-    comparisonRange.startDate
-  );
-  if (!isNaN(dayCount)) {
-    if (dateBucket === "month") {
-      return Math.floor(dayCount / 30) + " month";
-    } else if (dateBucket === "year") {
-      return Math.floor(dayCount / 365) + " year";
-    } else {
-      return dayCount + " day";
-    }
-  }
-}
 function getDateBucketFromRange(dateRange) {
   const difference = (0, import_date_fns5.differenceInDays)(dateRange.end, dateRange.start);
   if (difference < 14) {
@@ -16609,311 +16594,771 @@ function parseValueFromBigQueryDates(rows, columns) {
   });
 }
 
-// src/utils/merge.ts
-var import_date_fns7 = require("date-fns");
-var import_date_fns_tz2 = require("date-fns-tz");
-function mergeComparisonRange(resp) {
-  if (resp.chartType === "table") return resp;
-  const compRows = resp.compareRows;
-  if (!compRows) return resp;
-  const newRows = resp.rows.map((row, i) => {
-    if (i < compRows.length) {
-      const compRow = compRows[i];
-      const newRow = { ...row };
-      for (const [key, value] of Object.entries(compRow)) {
-        newRow[`comparison_${key}`] = value;
+// 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
       }
-      return newRow;
-    }
-    return row;
+    ];
+  }
+  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 { ...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}`);
+  if (resp.data?.success === false) {
+    throw resp.data.errorMessage;
   }
-  const [, valueStr, unit] = match;
-  if (!valueStr || !unit) {
-    throw new Error("Could not parse interval");
+  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 value = parseInt(valueStr, 10);
-  const parsedDate = typeof date === "string" ? new Date(date) : date;
-  switch (unit) {
-    case "day":
-      return (0, import_date_fns7.add)(parsedDate, { days: value });
-    case "month":
-      return (0, import_date_fns7.add)(parsedDate, { months: value });
-    case "year":
-      return (0, import_date_fns7.add)(parsedDate, { years: value });
-    default:
-      throw new Error(`Unsupported interval unit: ${unit}`);
+  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;
+      });
+    }
   }
+  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 dateTrunc(date, granularity = "day", databaseType) {
-  const weekStartsOn = databaseType === "mssql" ? 0 : 1;
-  const timeZone = "UTC";
-  const zonedDate = (0, import_date_fns_tz2.utcToZonedTime)(date, timeZone);
-  switch (granularity.toLowerCase()) {
-    case "week":
-      return (0, import_date_fns7.startOfWeek)(zonedDate, { weekStartsOn });
-    case "month":
-      return (0, import_date_fns7.startOfMonth)(zonedDate);
-    case "day":
-      return (0, import_date_fns7.startOfDay)(zonedDate);
-    case "year":
-      return (0, import_date_fns7.startOfYear)(zonedDate);
-    default:
-      throw new Error(`Unsupported granularity: ${granularity}`);
+function 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 mergeComparisonPivotColumns({
-  pivot,
-  rows,
-  compRows
-}) {
-  if (!compRows || !compRows.length) return rows;
-  const mappedCompRows = compRows.filter((compRow) => compRow.name !== pivot.rowField).map((compRow) => ({ ...compRow, name: `comparison_${compRow.name}` }));
-  return rows.concat(mappedCompRows);
+function 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 mergeComparisonPivotRows({
+async function generatePivotTable({
   pivot,
-  rows,
-  compRows,
-  databaseType,
   dateBucket,
-  comparisonInterval,
-  columnFieldValues
+  dateFilter,
+  report,
+  client,
+  getToken,
+  eventTracking,
+  uniqueValues,
+  dashboardName,
+  tenants,
+  additionalProcessing,
+  caller,
+  pivotQuery
 }) {
-  if (!compRows || !compRows.length) return rows;
-  if (pivot.columnField && columnFieldValues && columnFieldValues.length > 0) {
-    return merge2DPivotRows(
-      pivot,
-      rows,
-      compRows,
-      columnFieldValues,
-      databaseType,
-      dateBucket,
-      comparisonInterval
-    );
-  }
-  if (pivot.rowField) {
-    return merge1DPivotRows(
-      pivot,
-      rows,
-      compRows,
-      databaseType,
-      dateBucket,
-      comparisonInterval
-    );
+  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}`);
   }
-  return mergeAggregatedRows(pivot, rows, compRows);
+  throw Error("Failed to generate pivot table: invalid report");
 }
-function merge2DPivotRows(pivot, rows, compRows, columnFieldValues, databaseType, dateBucket, comparisonInterval) {
-  if (!pivot || !pivot.columnField) {
-    return [];
-  }
-  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
-    return merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues);
+
+// src/utils/paginationProcessing.ts
+var DEFAULT_PAGINATION = {
+  page: 0,
+  rowsPerPage: 10,
+  rowsPerRequest: 600
+};
+var DEFAULT_TABLE_PAGINATION = {
+  page: 0,
+  rowsPerPage: 10,
+  rowsPerRequest: 50
+};
+function shouldFetchMore(pagination, page, maxPage, currentRowCount) {
+  if (!pagination || currentRowCount && currentRowCount >= pagination.rowsPerPage * (page + 1)) {
+    return false;
   }
-  return merge2DDatePivotRows(
-    pivot,
-    rows,
-    compRows,
-    columnFieldValues,
-    databaseType,
-    dateBucket,
-    comparisonInterval
+  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 merge2DStringPivotRows(pivot, rows, compRows, columnFieldValues) {
-  if (!pivot.rowField || !pivot.aggregations?.some((agg) => agg.valueField)) {
-    return rows;
+function shouldSortInMemory(pagination, rowCount) {
+  if (!rowCount || rowCount < pagination.rowsPerRequest) {
+    return true;
   }
-  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
-    };
-  });
+  return false;
 }
-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;
-      },
-      {}
-    );
+
+// 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 {
-      ...row,
-      ...comparisonFields
+      ...defaultDashboardItem,
+      id: item._id,
+      name: item.name
     };
-  });
-}
-function merge1DPivotRows(pivot, rows, compRows, databaseType, dateBucket, comparisonInterval) {
-  if (isStringType(pivot.rowFieldType || "") || !pivot.rowFieldType) {
-    return merge1DStringPivotRows(pivot, rows, compRows);
   }
-  return merge1DDatePivotRows(
-    pivot,
-    rows,
-    compRows,
-    databaseType,
-    dateBucket,
-    comparisonInterval
-  );
-}
-function merge1DStringPivotRows(pivot, rows, compRows) {
-  if (!pivot.rowField || !pivot.valueField) {
-    return rows;
+  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 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 {
-      ...row,
-      [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow ? matchingCompRow[`${pivot.valueField}${aggregationSuffix}`] : null
-    };
+  const processedColumns = item.columns.map((col) => {
+    return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
   });
-}
-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";
-      }
-    }
+  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 {
-      ...row,
-      [`comparison_${pivot.valueField}${aggregationSuffix}`]: matchingCompRow?.[`${pivot.valueField}${aggregationSuffix}`] || null
+      fieldType: converted_field.fieldType,
+      dataTypeID: converted_field.dataTypeID,
+      jsType: converted_field.jsType,
+      ...col,
+      label: snakeAndCamelCaseToTitleCase(col.label)
     };
   });
-}
-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";
+  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] });
     }
-    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("'", "''");
   }
-  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('"."') + `"`;
+  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 `"${column.replaceAll('"', "")}"`;
     }
-    case "mysql": {
-      if (column === "") {
-        return fallbackOnNull ? `${fallbackOnNull}` : "_";
-      }
-      if (isColumnFieldAlias) {
-        return `\`${column.replaceAll(`\``, "").replaceAll(`"`, "")}\``;
-      }
-      const columnParts = column.split(".");
-      if (columnParts.length > 1) {
-        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
-      }
+  }
+  return {
+    id: item._id ?? item.id,
+    name: item.name,
+    dashboardName: item.dashboardName,
+    // section: item.section,
+    rows: item.rows,
+    pivotRows: pivotTable ? pivotTable.rows : void 0,
+    pivotColumns: pivotTable ? pivotTable.columns : void 0,
+    compareRows: item.compareRows,
+    columns: processedColumns.map((column) => {
+      return {
+        field: column.field,
+        format: column.format,
+        label: column.label,
+        inferFormat: column.inferFormat
+      };
+    }),
+    includeCustomFields: item.includeCustomFields,
+    columnInternal,
+    columnsWithCustomFields,
+    chartType: item.chartType,
+    dateField: item.dateField,
+    pivot: pivotError ? void 0 : item.pivot ? {
+      ...item.pivot,
+      aggregations: item.pivot.aggregations ?? [
+        {
+          valueField: item.pivot.valueField,
+          valueFieldType: item.pivot.valueFieldType,
+          valueField2: item.pivot.valueField2,
+          valueField2Type: item.pivot.valueField2Type,
+          aggregationType: item.pivot.aggregationType
+        }
+      ],
+      columnValues: item.distinctStrings
+    } : void 0,
+    yAxisFields: pivotTable ? extractPivotedYAxis(pivotTable, item) : item.yAxisFields,
+    xAxisLabel: item.xAxisLabel,
+    xAxisField: item.xAxisField,
+    xAxisFormat: item.xAxisFormat,
+    order: item.order,
+    filtersApplied: item.filtersApplied,
+    filterMap: item.filterMap,
+    flags: item.flags,
+    rowCount: item.rowCount ? parseInt(item.rowCount) : item.rows.length,
+    pivotRowCount: pivotTable ? pivotTable.rowCount : void 0,
+    template: item.template,
+    sort: item.sort,
+    itemQuery: item.itemQuery,
+    queryString: item.queryString,
+    pivotQuery: pivotTable?.pivotQuery,
+    comparisonPivotQuery: pivotTable?.comparisonPivotQuery,
+    referencedTables: item?.referencedTables || [],
+    referencedColumns: item?.referencedColumns || {},
+    error: item.error ?? pivotError,
+    referenceLineYValues,
+    referenceLines: item.referenceLines
+  };
+}
+async function getPivotTable(report, dashboardFilters, dashboardName, getToken, client, eventTracking, dateBucketInitial, additionalProcessing, tenants, customFields) {
+  if (!report) return void 0;
+  const dateFilter = Object.values(dashboardFilters ?? {}).find(
+    (filter) => filter.filterType === "date_range" || filter.operator === "BETWEEN"
+  );
+  if (dateFilter?.operator === "BETWEEN") {
+    dateFilter.startDate = dateFilter.value[0];
+    dateFilter.endDate = dateFilter.value[1];
+  }
+  const pivot = report?.pivot;
+  const data = report || {};
+  if (pivot && client) {
+    if (report.rowCount === 0 || report.rows.length === 0) {
+      const columns = [];
+      if (pivot.rowField) {
+        columns.push({
+          field: pivot.rowField,
+          label: snakeCaseToTitleCase(processColumnName(pivot.rowField)),
+          format: pivot.rowFieldType || "string",
+          jsType: convertFieldTypeToJSType(pivot.rowFieldType || "string"),
+          fieldType: pivot.rowFieldType || "string",
+          dataTypeID: fieldTypeToDataTypeID(pivot.rowFieldType || "string")
+        });
+      }
+      for (const agg of pivot.aggregations ?? []) {
+        if (agg.valueField) {
+          columns.push({
+            field: agg.valueField,
+            label: snakeCaseToTitleCase(processColumnName(agg.valueField)),
+            //FIXME: valueFieldType is not always the same as the format
+            format: agg.valueFieldType ?? "whole_number",
+            jsType: agg.valueFieldType ?? "number",
+            fieldType: agg.valueFieldType ?? "number",
+            dataTypeID: fieldTypeToDataTypeID(agg.valueFieldType ?? "number")
+          });
+        }
+      }
+      return {
+        rows: [],
+        rowCount: 0,
+        pivotQuery: report.queryString ?? "",
+        columns
+      };
+    }
+    try {
+      let dateBucket = dateBucketInitial;
+      let filterDateRange = void 0;
+      if (dateFilter && dateFilter.startDate && dateFilter.endDate) {
+        filterDateRange = {
+          start: dateFilter.startDate,
+          end: dateFilter.endDate
+        };
+      } else if (report.dateRange) {
+        filterDateRange = report.dateRange;
+      }
+      if (!dateBucket && filterDateRange) {
+        dateBucket = getDateBucketFromRange(filterDateRange);
+      }
+      const pivotTable = await generatePivotWithSQL({
+        pivot,
+        report,
+        client,
+        dateBucket,
+        dateFilter,
+        dashboardName,
+        tenants,
+        additionalProcessing,
+        getToken
+      });
+      return pivotTable;
+    } catch (e) {
+      eventTracking?.logError?.({
+        type: "bug",
+        // TODO: determine type
+        severity: "high",
+        message: "Error fetching pivot table",
+        errorMessage: e.message,
+        errorStack: e.stack,
+        errorData: {
+          caller: "getPivotTable",
+          function: "getPivotTable"
+        }
+      });
+      console.error("Error fetching pivot table", e);
+      throw e;
+    }
+  }
+  return pivot && data.rows ? generatePivotTable({
+    pivot,
+    report,
+    client,
+    uniqueValues: report.distinctStrings,
+    dashboardName,
+    tenants,
+    dateFilter,
+    additionalProcessing,
+    getToken,
+    eventTracking
+  }) : void 0;
+}
+function extractPivotedYAxis(pivotTable, itemInfo, config = void 0) {
+  if (!pivotTable) return itemInfo?.yAxisFields ?? [];
+  const pivot = itemInfo?.pivot || config?.pivot;
+  if (!pivot.columnField && !pivot.rowField) return itemInfo?.yAxisFields ?? [];
+  const yAxisFields = config ? config.yAxisFields : itemInfo?.yAxisFields;
+  return yAxisFields && yAxisFields.length > 0 ? generatePivotTableYAxis(pivot, pivotTable.columns, yAxisFields[0]) : yAxisFields;
+}
+async function getDashboard(dashboardName, client, getToken, tenants, flags) {
+  const { data: resp } = await quillFetch({
+    client,
+    task: "dashboard",
+    metadata: {
+      name: dashboardName,
+      clientId: client.publicKey,
+      databaseType: client.databaseType,
+      useNewNodeSql: true,
+      tenants,
+      flags
+    },
+    getToken
+  });
+  return {
+    ...resp,
+    createdAt: resp.createdAt && new Date(resp.createdAt),
+    dateFilter: resp.dateFilter ? {
+      ...resp.dateFilter,
+      presetOptions: resp.dateFilter.presetOptions?.map(
+        (preset) => ({
+          ...preset,
+          loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
+          loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
+        })
+      ),
+      defaultPresetRanges: resp.dateFilter.defaultPresetRanges?.map(
+        (preset) => ({
+          ...preset,
+          loopStart: preset.loopStart ? new Date(preset.loopStart) : void 0,
+          loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : void 0
+        })
+      )
+    } : void 0
+  };
+}
+
+// src/utils/chartBuilder.ts
+var numberFormatOptions = [
+  "whole_number",
+  "one_decimal_place",
+  "two_decimal_places",
+  "dollar_amount",
+  "dollar_cents",
+  "percentage"
+];
+var dateFormatOptions = [
+  "MMM_yyyy",
+  "MMM_dd",
+  "MMM_dd_yyyy",
+  "MMM_dd_hh:mm_ap_pm",
+  "hh_ap_pm",
+  "date",
+  "timestamptz"
+];
+var NUMBER_OPTIONS = [
+  { value: "whole_number", label: "whole number" },
+  { value: "one_decimal_place", label: "one decimal place" },
+  { value: "two_decimal_places", label: "two decimal places" },
+  { value: "dollar_amount", label: "dollar amount" },
+  { value: "dollar_cents", label: "dollar and cent amount" },
+  { value: "percent", label: "percentage" }
+];
+var DATE_OPTIONS = [
+  { value: "MMM_yyyy", label: "month" },
+  { value: "MMM_dd", label: "day" },
+  { value: "MMM_dd_yyyy", label: "day and year" },
+  { value: "MMM_dd_hh:mm_ap_pm", label: "day and time" },
+  { value: "hh_ap_pm", label: "hour" }
+];
+var ALL_FORMAT_OPTIONS = [
+  ...NUMBER_OPTIONS,
+  ...DATE_OPTIONS,
+  { value: "string", label: "string" }
+];
+function createInitialFormData(columns) {
+  const firstNumberColumn = columns?.find(
+    (col) => numberFormatOptions.includes(col.format)
+  );
+  const firstStringColumn = columns?.find(
+    (col) => !numberFormatOptions.includes(col.format) && !dateFormatOptions.includes(col.format)
+  );
+  const firstDateColumn = columns?.find(
+    (col) => dateFormatOptions.includes(col.format)
+  );
+  const xAxisField = firstStringColumn?.field || firstDateColumn?.field || firstNumberColumn?.field || columns?.[0]?.field || "";
+  const xAxisFormat = firstStringColumn?.format || firstDateColumn?.format || firstNumberColumn?.format || columns?.[0]?.format || "string";
+  const formEmptyState = {
+    name: "",
+    columns: columns.map((col) => {
+      return { ...col, label: snakeAndCamelCaseToTitleCase(col.label) };
+    }),
+    xAxisField,
+    xAxisFormat,
+    yAxisFields: [
+      {
+        field: firstNumberColumn?.field || columns?.[0]?.field || "",
+        label: "",
+        format: firstNumberColumn?.format || columns?.[0]?.format || "string"
+      }
+    ],
+    xAxisLabel: "",
+    chartType: firstNumberColumn ? "line" : "table",
+    pivot: null,
+    template: true,
+    referenceLines: []
+  };
+  return formEmptyState;
+}
+
+// src/utils/error.ts
+var DataLoadError = class extends Error {
+  data;
+  constructor(message, data) {
+    super(message);
+    this.name = "DataLoadError";
+    this.data = data;
+  }
+};
+
+// src/utils/errorProcessing.ts
+function processFilterErrorList(resp) {
+  if (!resp || !resp.filterErrorList || !Array.isArray(resp.filterErrorList)) {
+    return;
+  }
+}
+
+// src/utils/queryConstructor.ts
+function replaceBigQuerySpecialCharacters(column) {
+  return column.replaceAll("/", "quill_forward_slash");
+}
+function processColumnReference(column, databaseType, fallbackOnNull, isColumnFieldAlias, isValueFieldAlias) {
+  switch (databaseType.toLowerCase()) {
+    case "postgresql":
+    case "clickhouse": {
+      if (column === "") {
+        return fallbackOnNull ? `"${fallbackOnNull}"` : `"_"`;
+      }
+      if (isColumnFieldAlias) {
+        return `"${column.replaceAll('"', "")}"`;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `"` + columnParts.map((part) => part.replaceAll('"', "")).join('"."') + `"`;
+      }
+      return `"${column.replaceAll('"', "")}"`;
+    }
+    case "mysql": {
+      if (column === "") {
+        return fallbackOnNull ? `${fallbackOnNull}` : "_";
+      }
+      if (isColumnFieldAlias) {
+        return `\`${column.replaceAll(`\``, "").replaceAll(`"`, "")}\``;
+      }
+      const columnParts = column.split(".");
+      if (columnParts.length > 1) {
+        return `\`` + columnParts.map((part) => part.replaceAll(`\``, "")).join("`.`") + `\``;
+      }
       return `\`${column.replaceAll(`\``, "")}\``;
     }
     case "snowflake": {
@@ -16975,51 +17420,6 @@ 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(";", "")}) `;
@@ -17054,1206 +17454,95 @@ function generateDistinctQuery(stringFields, query, databaseType) {
     case "mssql":
       return generateDistinctQueryMSSQL(stringFields, query);
     case "databricks":
-      return generateDistinctQueryDatabricks(stringFields, query);
-    case "clickhouse":
-    // works with default for now
-    default:
-      return generateDistinctQueryDefault(stringFields, query, databaseType);
-  }
-}
-function generateDistinctQueryDefault(stringFields, query, databaseType) {
-  const distinctQueries = stringFields.map((field) => {
-    return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, ARRAY_AGG(DISTINCT ${field}) AS ${processColumnReference("string_values", databaseType)} FROM querytable`;
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
-}
-function generateDistinctQueryMySQL(stringFields, query) {
-  const distinctQueries = stringFields.map((field) => {
-    return `
-      SELECT '${field}' AS ${processColumnReference("field", "mysql")}, 
-             JSON_ARRAYAGG(\`${field}\`) AS ${processColumnReference("string_values", "mysql")}
-      FROM (SELECT DISTINCT \`${field}\` FROM querytable) AS distinct_${replaceSpacesWithUnderscores(field)}`;
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
-}
-function generateDistinctQueryBigQuery(stringFields, query) {
-  const distinctQueries = stringFields.map((field) => {
-    return `
-      SELECT '${field}' AS ${processColumnReference("field", "bigquery")}, 
-             ARRAY_AGG(\`${field}\`) AS ${processColumnReference("string_values", "bigquery")}
-      FROM (SELECT \`${field}\` FROM querytable WHERE \`${field}\` IS NOT NULL GROUP BY \`${field}\`) AS distinct_${replaceSpacesWithUnderscores(field)}`;
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
-}
-function generateDistinctQueryPostgres(stringFields, query) {
-  const distinctQueries = stringFields.map((field) => {
-    return `SELECT '${field}' AS ${processColumnReference("field", "postgresql")}, to_json(ARRAY_AGG(DISTINCT "${field}")) AS ${processColumnReference("string_values", "postgresql")} FROM querytable`;
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
-}
-function generateDistinctQuerySnowflake(stringFields, query) {
-  const distinctQueries = stringFields.map((field) => {
-    return `SELECT '${field}' AS "field", ARRAY_AGG(DISTINCT "${field}") AS "string_values" FROM querytable`;
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
-}
-function generateDistinctQueryMSSQL(stringFields, query) {
-  const escapeFieldName = (field) => field.replace(/'/g, "''");
-  const distinctQueries = stringFields.map((field) => {
-    return `
-      SELECT 
-        '${escapeFieldName(field)}' AS field,
-        STRING_AGG(${field}, ',') AS string_values
-      FROM (
-        SELECT ${field}
-        FROM querytable
-        WHERE ${field} IS NOT NULL
-        GROUP BY ${field}
-      ) AS grouped
-      `.replace(/\s+/g, " ").trim();
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `
-    WITH querytable AS (
-      ${query.replace(";", "")}
-    )
-    ${distinctQuery}`.replace(/\s+/g, " ").trim();
-}
-function generateDistinctQueryDatabricks(stringFields, query) {
-  const distinctQueries = stringFields.map((field) => {
-    return `SELECT '${field}' AS ${processColumnReference("field", "databricks")}, collect_set(\`${field}\`) AS ${processColumnReference("string_values", "databricks")} FROM querytable`;
-  });
-  const distinctQuery = distinctQueries.join(" UNION ALL ");
-  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
-}
-function generateMinMaxDateRangeQueries(columnFields, query, databaseType) {
-  const max2 = "MAX";
-  const min2 = "MIN";
-  const cast = databaseType.toLowerCase() === "snowflake" ? "::TIMESTAMP_TZ" : "";
-  const distinctQueries = columnFields.map((field) => {
-    const wrappedField = ["postgresql", "clickhouse"].includes(
-      databaseType.toLowerCase()
-    ) ? `"${field}"` : field;
-    return `SELECT '${field}' AS field, ${min2}(${wrappedField})${cast} AS min_range, ${max2}(${wrappedField})${cast} AS max_range FROM querytable`;
-  });
-  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}`);
+      return generateDistinctQueryDatabricks(stringFields, query);
+    case "clickhouse":
+    // works with default for now
+    default:
+      return generateDistinctQueryDefault(stringFields, query, databaseType);
   }
-  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;
-  }
+function generateDistinctQueryDefault(stringFields, query, databaseType) {
+  const distinctQueries = stringFields.map((field) => {
+    return `SELECT '${field}' AS ${processColumnReference("field", databaseType)}, ARRAY_AGG(DISTINCT ${field}) AS ${processColumnReference("string_values", databaseType)} FROM querytable`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
 }
-
-// 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 generateDistinctQueryMySQL(stringFields, query) {
+  const distinctQueries = stringFields.map((field) => {
+    return `
+      SELECT '${field}' AS ${processColumnReference("field", "mysql")}, 
+             JSON_ARRAYAGG(\`${field}\`) AS ${processColumnReference("string_values", "mysql")}
+      FROM (SELECT DISTINCT \`${field}\` FROM querytable) AS distinct_${replaceSpacesWithUnderscores(field)}`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
 }
-function shouldSortInMemory(pagination, rowCount) {
-  if (!rowCount || rowCount < pagination.rowsPerRequest) {
-    return true;
-  }
-  return false;
+function generateDistinctQueryBigQuery(stringFields, query) {
+  const distinctQueries = stringFields.map((field) => {
+    return `
+      SELECT '${field}' AS ${processColumnReference("field", "bigquery")}, 
+             ARRAY_AGG(\`${field}\`) AS ${processColumnReference("string_values", "bigquery")}
+      FROM (SELECT \`${field}\` FROM querytable WHERE \`${field}\` IS NOT NULL GROUP BY \`${field}\`) AS distinct_${replaceSpacesWithUnderscores(field)}`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
+}
+function generateDistinctQueryPostgres(stringFields, query) {
+  const distinctQueries = stringFields.map((field) => {
+    return `SELECT '${field}' AS ${processColumnReference("field", "postgresql")}, to_json(ARRAY_AGG(DISTINCT "${field}")) AS ${processColumnReference("string_values", "postgresql")} FROM querytable`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
+}
+function generateDistinctQuerySnowflake(stringFields, query) {
+  const distinctQueries = stringFields.map((field) => {
+    return `SELECT '${field}' AS "field", ARRAY_AGG(DISTINCT "${field}") AS "string_values" FROM querytable`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
+}
+function generateDistinctQueryMSSQL(stringFields, query) {
+  const escapeFieldName = (field) => field.replace(/'/g, "''");
+  const distinctQueries = stringFields.map((field) => {
+    return `
+      SELECT 
+        '${escapeFieldName(field)}' AS field,
+        STRING_AGG(${field}, ',') AS string_values
+      FROM (
+        SELECT ${field}
+        FROM querytable
+        WHERE ${field} IS NOT NULL
+        GROUP BY ${field}
+      ) AS grouped
+      `.replace(/\s+/g, " ").trim();
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `
+    WITH querytable AS (
+      ${query.replace(";", "")}
+    )
+    ${distinctQuery}`.replace(/\s+/g, " ").trim();
+}
+function generateDistinctQueryDatabricks(stringFields, query) {
+  const distinctQueries = stringFields.map((field) => {
+    return `SELECT '${field}' AS ${processColumnReference("field", "databricks")}, collect_set(\`${field}\`) AS ${processColumnReference("string_values", "databricks")} FROM querytable`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
+}
+function generateMinMaxDateRangeQueries(columnFields, query, databaseType) {
+  const max2 = "MAX";
+  const min2 = "MIN";
+  const cast = databaseType.toLowerCase() === "snowflake" ? "::TIMESTAMP_TZ" : "";
+  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`;
+  });
+  const distinctQuery = distinctQueries.join(" UNION ALL ");
+  return `WITH querytable AS (${query.replace(";", "")}) ` + distinctQuery;
 }
 
 // src/utils/tableProcessing.ts
@@ -18894,595 +18183,110 @@ var fetchResultsByReport = async ({
     if (e instanceof Error && e.name === "AbortError") {
       throw e;
     }
-    eventTracking?.logError?.({
-      type: "bug",
-      // TODO: determine type
-      severity: "high",
-      message: "Error fetching results by report",
-      errorMessage: e.message,
-      errorStack: e.stack,
-      errorData: {
-        caller: "fetchResultsByReport",
-        function: "fetchResultsByReport"
-      }
-    });
-    rows = [];
-    columns = [];
-    rowCount = 0;
-    error = e.message;
-  }
-  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;
-    }
-    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
-      };
-    }
-    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] ?? [];
+    eventTracking?.logError?.({
+      type: "bug",
+      // TODO: determine type
+      severity: "high",
+      message: "Error fetching results by report",
+      errorMessage: e.message,
+      errorStack: e.stack,
+      errorData: {
+        caller: "fetchResultsByReport",
+        function: "fetchResultsByReport"
       }
-      const pivotTable = await generatePivotWithSQL({
-        pivot,
-        report,
-        client,
-        dateBucket,
-        dateFilter,
-        distinctStrings: report.distinctStrings,
+    });
+    rows = [];
+    columns = [];
+    rowCount = 0;
+    error = e.message;
+  }
+  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,
-        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"
-        }
+        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;
+          }
+        });
       });
-      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"
+  } 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"
       }
-    ],
-    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;
+    });
+    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/components/ReportBuilder/convert.ts
-var import_date_fns8 = require("date-fns");
+var import_date_fns7 = require("date-fns");
 function recursiveSearchAndReplace(node, search, replace) {
   if (typeof node !== "object") {
     return;
@@ -19791,7 +18595,7 @@ function convertStringComparison(node, databaseType) {
         searchAndReplace(element);
       });
     } else if (typeof obj === "object" && obj !== null) {
-      if (obj.type === "binary_expr" && (obj.operator === "=" && !(0, import_date_fns8.isValid)((0, import_date_fns8.parseISO)(obj.right.value)) || // don't do it on date objects
+      if (obj.type === "binary_expr" && (obj.operator === "=" && !(0, import_date_fns7.isValid)((0, import_date_fns7.parseISO)(obj.right.value)) || // don't do it on date objects
       obj.operator === "LIKE" || obj.operator === "ILIKE") && obj.left && (obj.left.type === "column_ref" || obj.left.type === "double_quote_string") && obj.right && obj.right.type === "single_quote_string") {
         obj.operator = "LIKE";
         obj.left = {
@@ -23132,6 +21936,29 @@ var import_jspdf = __toESM(require("jspdf"), 1);
 
 // src/hooks/useDashboard.ts
 var import_react2 = require("react");
+
+// src/utils/merge.ts
+var import_date_fns8 = require("date-fns");
+var import_date_fns_tz2 = require("date-fns-tz");
+function mergeComparisonRange(resp) {
+  if (resp.chartType === "table") return resp;
+  const compRows = resp.compareRows;
+  if (!compRows) return resp;
+  const newRows = resp.rows.map((row, i) => {
+    if (i < compRows.length) {
+      const compRow = compRows[i];
+      const newRow = { ...row };
+      for (const [key, value] of Object.entries(compRow)) {
+        newRow[`comparison_${key}`] = value;
+      }
+      return newRow;
+    }
+    return row;
+  });
+  return { ...resp, rows: newRows };
+}
+
+// src/hooks/useDashboard.ts
 var useDashboardInternal = (dashboardName, customFilters) => {
   const [dashboard] = (0, import_react2.useContext)(DashboardContext);
   const {
@@ -38940,6 +37767,9 @@ var import_react46 = __toESM(require("@monaco-editor/react"), 1);
 
 // src/ChartBuilder.tsx
 var import_react43 = require("react");
+var import_core = require("@dnd-kit/core");
+var import_sortable = require("@dnd-kit/sortable");
+var import_utilities = require("@dnd-kit/utilities");
 
 // src/internals/ReportBuilder/PivotModal.tsx
 var import_react40 = require("react");
@@ -42182,6 +41012,173 @@ var CHART_TO_LABELS = {
   "World map": { xAxisLabel: "Country", yAxisLabel: "Value" },
   gauge: { xAxisLabel: "Value" }
 };
+function SortableColumnItem({
+  column,
+  index,
+  rows,
+  columns,
+  handleChange,
+  deleteRef,
+  deleteButtonMargin,
+  handleRemoveField,
+  SelectComponent,
+  TextInputComponent,
+  DeleteButtonComponent
+}) {
+  const { attributes, listeners, setNodeRef, transform, transition: transition2 } = (0, import_sortable.useSortable)({ id: column.field });
+  const style2 = {
+    transform: import_utilities.CSS.Transform.toString(transform),
+    transition: transition2
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("div", { style: style2, ref: setNodeRef, children: /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        gap: 4
+      },
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(
+          "div",
+          {
+            style: {
+              cursor: "grab",
+              display: "flex",
+              gap: 2,
+              flexDirection: "row",
+              paddingTop: 8,
+              paddingBottom: 8,
+              paddingLeft: 8,
+              paddingRight: 8,
+              borderRadius: 4
+            },
+            className: "handle",
+            ...attributes,
+            ...listeners,
+            children: [
+              /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("style", { children: `.handle{background:white;} .handle:hover{background:rgba(0,0,0,0.03);}` }),
+              /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)("div", { style: { display: "flex", gap: 2, flexDirection: "column" }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                  "div",
+                  {
+                    style: {
+                      width: 3,
+                      height: 3,
+                      borderRadius: 3,
+                      background: "#9CA0A7"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                  "div",
+                  {
+                    style: {
+                      width: 3,
+                      height: 3,
+                      borderRadius: 3,
+                      background: "#9CA0A7"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                  "div",
+                  {
+                    style: {
+                      width: 3,
+                      height: 3,
+                      borderRadius: 3,
+                      background: "#9CA0A7"
+                    }
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)("div", { style: { display: "flex", gap: 2, flexDirection: "column" }, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                  "div",
+                  {
+                    style: {
+                      width: 3,
+                      height: 3,
+                      borderRadius: 3,
+                      background: "#9CA0A7"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                  "div",
+                  {
+                    style: {
+                      width: 3,
+                      height: 3,
+                      borderRadius: 3,
+                      background: "#9CA0A7"
+                    }
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                  "div",
+                  {
+                    style: {
+                      width: 3,
+                      height: 3,
+                      borderRadius: 3,
+                      background: "#9CA0A7"
+                    }
+                  }
+                )
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)("div", { style: { flex: 1, display: "flex", gap: 12 }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+            SelectComponent,
+            {
+              value: column.field,
+              onChange: (e) => handleChange(e.target.value, "columns.field", index),
+              options: rows[0] ? Object.keys(rows[0]).map((elem) => ({
+                label: elem,
+                value: elem
+              })) : columns.map((elem) => ({
+                label: elem.field,
+                value: elem.field
+              })),
+              width: 200,
+              hideEmptyOption: true
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+            TextInputComponent,
+            {
+              id: `chart-builder-column-label-${index}`,
+              width: 200,
+              value: column.label,
+              placeholder: "Column Label",
+              onChange: (e) => handleChange(e.target.value, "columns.label", index)
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+            SelectComponent,
+            {
+              value: column.format,
+              onChange: (e) => handleChange(e.target.value, "columns.format", index),
+              options: ALL_FORMAT_OPTIONS,
+              width: 200,
+              hideEmptyOption: true
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("div", { ref: deleteRef, style: { marginLeft: deleteButtonMargin }, children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+            DeleteButtonComponent,
+            {
+              onClick: () => handleRemoveField("columns", index)
+            }
+          ) })
+        ] })
+      ]
+    }
+  ) });
+}
 function getPivotMetricOptions(pivot, selectedPivotTable, chartType) {
   if (["metric", "gauge"].includes(chartType) && selectedPivotTable) {
     return selectedPivotTable.columns.map((elem) => ({
@@ -42390,7 +41387,6 @@ function ChartBuilder({
   }, [reportId]);
   const [windowWidth, setWindowWidth] = (0, import_react43.useState)(1200);
   const [rows, setRows] = (0, import_react43.useState)(report?.rows ?? []);
-  const [itemQuery, setItemQuery] = (0, import_react43.useState)(report?.itemQuery);
   const [rowCount, setRowCount] = (0, import_react43.useState)(report?.rowCount ?? 0);
   const [maxPage, setMaxPage] = (0, import_react43.useState)(0);
   const [isLoading, setIsLoading] = (0, import_react43.useState)(false);
@@ -43120,7 +42116,7 @@ function ChartBuilder({
           pivot,
           dateBucket,
           dateFilter,
-          report: report ? { ...report, ...tableInfo ?? { itemQuery } } : void 0,
+          report: report ? { ...report, ...tableInfo } : void 0,
           client,
           uniqueValues,
           dashboardName: destinationDashboardName,
@@ -43281,7 +42277,6 @@ function ChartBuilder({
       setCurrentProcessing(processing);
       setRows(tableInfo.rows);
       setProcessedColumns(processColumns(tableInfo.columns));
-      setItemQuery(tableInfo.itemQuery);
       fetchRowCount(processing, overrideFilters);
       if (formData.pivot) {
         try {
@@ -43647,6 +42642,26 @@ function ChartBuilder({
     );
     setFormData({ ...formData, [fieldName]: updatedArray });
   };
+  const columnDragSensors = (0, import_core.useSensors)(
+    (0, import_core.useSensor)(import_core.PointerSensor),
+    (0, import_core.useSensor)(import_core.KeyboardSensor, {
+      coordinateGetter: import_sortable.sortableKeyboardCoordinates
+    })
+  );
+  const handleColumnDragEnd = (event) => {
+    const { active, over } = event;
+    if (!active || !over) return;
+    if (active.id !== over.id) {
+      const oldIndex = formData.columns.findIndex(
+        (col) => col.field === active.id
+      );
+      const newIndex = formData.columns.findIndex(
+        (col) => col.field === over.id
+      );
+      const newColumns = (0, import_sortable.arrayMove)(formData.columns, oldIndex, newIndex);
+      setFormData({ ...formData, columns: newColumns });
+    }
+  };
   const handleSubmit = (event) => {
     event.preventDefault();
   };
@@ -44167,7 +43182,7 @@ function ChartBuilder({
                                       uniqueValuesIsLoading: initialUniqueValuesIsLoading,
                                       initialSelectedPivotTable: selectedPivotTable,
                                       pivotRecommendationsEnabled,
-                                      report: report ? { ...report, ...{ itemQuery } } : void 0,
+                                      report,
                                       dashboardName: destinationDashboardName || "",
                                       dateFilter: filtersEnabled ? currentDashboardFilters?.find(
                                         (f) => f.filterType === "date_range"
@@ -44555,141 +43570,98 @@ function ChartBuilder({
                               formData.pivot && selectedPivotTable && selectedPivotTable.columns && formData.chartType === "table" ? (
                                 // THIS CASE IF FOR PIVOT TABLES ONLY
                                 selectedPivotTable.columns.map(
-                                  (column, index) => /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(
-                                    ChartBuilderInputRowContainer,
-                                    {
-                                      children: [
-                                        /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                          SelectComponent,
-                                          {
-                                            value: column.field,
-                                            onChange: (e) => handleChange(
-                                              e.target.value,
-                                              "pivot.field",
-                                              index
-                                            ),
-                                            options: selectedPivotTable.columns.map(
-                                              (elem) => ({
-                                                label: elem.field,
-                                                value: elem.field
-                                              })
-                                            ),
-                                            disabled: index === 0,
-                                            width: 200,
-                                            hideEmptyOption: true
-                                          }
+                                  (column, index) => /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(ChartBuilderInputRowContainer, { children: [
+                                    /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                                      SelectComponent,
+                                      {
+                                        value: column.field,
+                                        onChange: (e) => handleChange(
+                                          e.target.value,
+                                          "pivot.field",
+                                          index
                                         ),
-                                        /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                          TextInputComponent,
-                                          {
-                                            id: `chart-builder-column-label-${index}`,
-                                            width: 200,
-                                            value: column.label,
-                                            placeholder: "Column Label",
-                                            onChange: (e) => handleChange(
-                                              e.target.value,
-                                              "pivot.label",
-                                              index
-                                            )
-                                          }
+                                        options: selectedPivotTable.columns.map(
+                                          (elem) => ({
+                                            label: elem.field,
+                                            value: elem.field
+                                          })
                                         ),
-                                        /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                          SelectComponent,
-                                          {
-                                            value: (
-                                              // The first index use rowField for the rest of them use value fields
-                                              column.format
-                                            ),
-                                            onChange: (e) => handleChange(
-                                              e.target.value,
-                                              "pivot.format",
-                                              index
-                                            ),
-                                            options: formData.pivot && index === 0 && selectedPivotTable?.columns.length > 1 ? isDateField(
-                                              formData.pivot.rowFieldType || ""
-                                            ) ? [{ label: "date", value: "string" }] : [{ label: "string", value: "string" }] : [
-                                              ...NUMBER_OPTIONS,
-                                              { label: "string", value: "string" }
-                                            ],
-                                            width: 200,
-                                            hideEmptyOption: true
-                                          }
+                                        disabled: index === 0,
+                                        width: 200,
+                                        hideEmptyOption: true
+                                      }
+                                    ),
+                                    /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                                      TextInputComponent,
+                                      {
+                                        id: `chart-builder-column-label-${index}`,
+                                        width: 200,
+                                        value: column.label,
+                                        placeholder: "Column Label",
+                                        onChange: (e) => handleChange(
+                                          e.target.value,
+                                          "pivot.label",
+                                          index
                                         )
-                                      ]
-                                    },
-                                    "column" + index
-                                  )
+                                      }
+                                    ),
+                                    /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                                      SelectComponent,
+                                      {
+                                        value: (
+                                          // The first index use rowField for the rest of them use value fields
+                                          column.format
+                                        ),
+                                        onChange: (e) => handleChange(
+                                          e.target.value,
+                                          "pivot.format",
+                                          index
+                                        ),
+                                        options: formData.pivot && index === 0 && selectedPivotTable?.columns.length > 1 ? isDateField(
+                                          formData.pivot.rowFieldType || ""
+                                        ) ? [{ label: "date", value: "string" }] : [{ label: "string", value: "string" }] : [
+                                          ...NUMBER_OPTIONS,
+                                          { label: "string", value: "string" }
+                                        ],
+                                        width: 200,
+                                        hideEmptyOption: true
+                                      }
+                                    )
+                                  ] }, "column" + index)
                                 )
-                              ) : formData.columns.map(
-                                (column, index) => /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(
-                                  ChartBuilderInputRowContainer,
-                                  {
-                                    children: [
-                                      /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                        SelectComponent,
-                                        {
-                                          value: column.field,
-                                          onChange: (e) => handleChange(
-                                            e.target.value,
-                                            "columns.field",
-                                            index
-                                          ),
-                                          options: rows[0] ? Object.keys(rows[0]).map((elem) => ({
-                                            label: elem,
-                                            value: elem
-                                          })) : columns.map((elem) => ({
-                                            label: elem.field,
-                                            value: elem.field
-                                          })),
-                                          width: 200,
-                                          hideEmptyOption: true
-                                        }
-                                      ),
-                                      /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                        TextInputComponent,
-                                        {
-                                          id: `chart-builder-column-label-${index}`,
-                                          width: 200,
-                                          value: column.label,
-                                          placeholder: "Column Label",
-                                          onChange: (e) => handleChange(
-                                            e.target.value,
-                                            "columns.label",
-                                            index
-                                          )
-                                        }
-                                      ),
-                                      /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                        SelectComponent,
-                                        {
-                                          value: column.format,
-                                          onChange: (e) => handleChange(
-                                            e.target.value,
-                                            "columns.format",
-                                            index
-                                          ),
-                                          options: ALL_FORMAT_OPTIONS,
-                                          width: 200,
-                                          hideEmptyOption: true
-                                        }
-                                      ),
-                                      /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                        "div",
-                                        {
-                                          ref: deleteRef,
-                                          style: { marginLeft: deleteButtonMargin },
-                                          children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
-                                            DeleteButtonComponent,
-                                            {
-                                              onClick: () => handleRemoveField("columns", index)
-                                            }
-                                          )
-                                        }
+                              ) : /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                                import_core.DndContext,
+                                {
+                                  sensors: columnDragSensors,
+                                  collisionDetection: import_core.closestCenter,
+                                  onDragEnd: handleColumnDragEnd,
+                                  children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                                    import_sortable.SortableContext,
+                                    {
+                                      items: formData.columns.map((col) => col.field),
+                                      strategy: import_sortable.verticalListSortingStrategy,
+                                      children: formData.columns.map(
+                                        (column, index) => /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(
+                                          SortableColumnItem,
+                                          {
+                                            column,
+                                            index,
+                                            rows,
+                                            columns,
+                                            handleChange,
+                                            deleteRef,
+                                            deleteButtonMargin,
+                                            handleRemoveField,
+                                            SelectComponent,
+                                            TextInputComponent,
+                                            DeleteButtonComponent
+                                          },
+                                          column.field
+                                        )
                                       )
-                                    ]
-                                  },
-                                  "column" + index
-                                )
+                                    }
+                                  )
+                                }
                               ),
                               /* @__PURE__ */ (0, import_jsx_runtime65.jsx)("div", { children: !// hide when pivoted and chartType === 'table'
                               (formData.pivot && selectedPivotTable && selectedPivotTable.columns && formData.chartType === "table") && /* @__PURE__ */ (0, import_jsx_runtime65.jsxs)(
@@ -48858,9 +47830,9 @@ var useReportBuilder = ({
 
 // src/components/ReportBuilder/AddColumnModal.tsx
 var import_react48 = require("react");
-var import_core = require("@dnd-kit/core");
-var import_sortable = require("@dnd-kit/sortable");
-var import_utilities = require("@dnd-kit/utilities");
+var import_core2 = require("@dnd-kit/core");
+var import_sortable2 = require("@dnd-kit/sortable");
+var import_utilities2 = require("@dnd-kit/utilities");
 var import_jsx_runtime67 = require("react/jsx-runtime");
 function AddColumnModal({
   onSave,
@@ -48929,10 +47901,10 @@ function AddColumnModal({
       setTimeout(() => setInitialLoad(false), 200);
     }
   }, [schemaLoading]);
-  const sensors = (0, import_core.useSensors)(
-    (0, import_core.useSensor)(import_core.PointerSensor),
-    (0, import_core.useSensor)(import_core.KeyboardSensor, {
-      coordinateGetter: import_sortable.sortableKeyboardCoordinates
+  const sensors = (0, import_core2.useSensors)(
+    (0, import_core2.useSensor)(import_core2.PointerSensor),
+    (0, import_core2.useSensor)(import_core2.KeyboardSensor, {
+      coordinateGetter: import_sortable2.sortableKeyboardCoordinates
     })
   );
   function handleDragEnd(event) {
@@ -48942,7 +47914,7 @@ function AddColumnModal({
       setOrderedColumnNames((orderedColumnNames2) => {
         const oldIndex = orderedColumnNames2.indexOf(active.id);
         const newIndex = orderedColumnNames2.indexOf(over.id);
-        return (0, import_sortable.arrayMove)(orderedColumnNames2, oldIndex, newIndex);
+        return (0, import_sortable2.arrayMove)(orderedColumnNames2, oldIndex, newIndex);
       });
     }
   }
@@ -48986,16 +47958,16 @@ function AddColumnModal({
           }
         ),
         schemaLoading || initialLoad ? /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(LoadingComponent, {}) : schema.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(
-          import_core.DndContext,
+          import_core2.DndContext,
           {
             sensors,
-            collisionDetection: import_core.closestCenter,
+            collisionDetection: import_core2.closestCenter,
             onDragEnd: handleDragEnd,
             children: /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(
-              import_sortable.SortableContext,
+              import_sortable2.SortableContext,
               {
                 items: orderedColumnNames,
-                strategy: import_sortable.verticalListSortingStrategy,
+                strategy: import_sortable2.verticalListSortingStrategy,
                 children: /* @__PURE__ */ (0, import_jsx_runtime67.jsxs)(
                   "div",
                   {
@@ -49203,9 +48175,9 @@ var SortableItem = ({
   selectedColumns,
   SelectColumn
 }) => {
-  const { attributes, listeners, setNodeRef, transform, transition: transition2 } = (0, import_sortable.useSortable)({ id: id2 });
+  const { attributes, listeners, setNodeRef, transform, transition: transition2 } = (0, import_sortable2.useSortable)({ id: id2 });
   const style2 = {
-    transform: import_utilities.CSS.Transform.toString(transform),
+    transform: import_utilities2.CSS.Transform.toString(transform),
     transition: transition2
   };
   const handleSelect = () => {
@@ -49234,11 +48206,11 @@ var SortableItem = ({
 };
 
 // src/components/ReportBuilder/DraggableColumns.tsx
-var import_core2 = require("@dnd-kit/core");
+var import_core3 = require("@dnd-kit/core");
 
 // src/components/ReportBuilder/DraggableItem.tsx
-var import_sortable2 = require("@dnd-kit/sortable");
-var import_utilities2 = require("@dnd-kit/utilities");
+var import_sortable3 = require("@dnd-kit/sortable");
+var import_utilities3 = require("@dnd-kit/utilities");
 var import_jsx_runtime68 = require("react/jsx-runtime");
 function DraggableItem({
   id: id2,
@@ -49247,9 +48219,9 @@ function DraggableItem({
   DraggableColumnComponent,
   loading
 }) {
-  const { attributes, listeners, setNodeRef, transform, transition: transition2 } = (0, import_sortable2.useSortable)({ id: id2 });
+  const { attributes, listeners, setNodeRef, transform, transition: transition2 } = (0, import_sortable3.useSortable)({ id: id2 });
   const style2 = {
-    transform: import_utilities2.CSS.Transform.toString(transform),
+    transform: import_utilities3.CSS.Transform.toString(transform),
     transition: transition2
   };
   return /* @__PURE__ */ (0, import_jsx_runtime68.jsx)("div", { style: { ...style2 }, ref: setNodeRef, children: /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(
@@ -49274,7 +48246,7 @@ function DraggableItem({
 }
 
 // src/components/ReportBuilder/DraggableColumns.tsx
-var import_sortable3 = require("@dnd-kit/sortable");
+var import_sortable4 = require("@dnd-kit/sortable");
 var import_react49 = require("react");
 var import_jsx_runtime69 = require("react/jsx-runtime");
 function DraggableColumns({
@@ -49283,10 +48255,10 @@ function DraggableColumns({
   DraggableColumnComponent,
   loading
 }) {
-  const sensors = (0, import_core2.useSensors)(
-    (0, import_core2.useSensor)(import_core2.PointerSensor),
-    (0, import_core2.useSensor)(import_core2.KeyboardSensor, {
-      coordinateGetter: import_sortable3.sortableKeyboardCoordinates
+  const sensors = (0, import_core3.useSensors)(
+    (0, import_core3.useSensor)(import_core3.PointerSensor),
+    (0, import_core3.useSensor)(import_core3.KeyboardSensor, {
+      coordinateGetter: import_sortable4.sortableKeyboardCoordinates
     })
   );
   const columnNames = (0, import_react49.useMemo)(() => {
@@ -49303,7 +48275,7 @@ function DraggableColumns({
     if (active.id !== over.id) {
       const oldIndex = columnNames.findIndex((c) => c.endsWith(active.id));
       const newIndex = columnNames.findIndex((c) => c.endsWith(over.id));
-      const newOrder = (0, import_sortable3.arrayMove)(columnNames, oldIndex, newIndex);
+      const newOrder = (0, import_sortable4.arrayMove)(columnNames, oldIndex, newIndex);
       const orderToColumns = newOrder.map((name2) => {
         const [table, field] = name2.split(".");
         return columns.find(
@@ -49320,16 +48292,16 @@ function DraggableColumns({
     onColumnOrderChange(newColumns);
   }
   return /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(
-    import_core2.DndContext,
+    import_core3.DndContext,
     {
       sensors,
-      collisionDetection: import_core2.closestCenter,
+      collisionDetection: import_core3.closestCenter,
       onDragEnd: handleDragEnd,
       children: /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(
-        import_sortable3.SortableContext,
+        import_sortable4.SortableContext,
         {
           items: columnNames,
-          strategy: import_sortable3.verticalListSortingStrategy,
+          strategy: import_sortable4.verticalListSortingStrategy,
           children: /* @__PURE__ */ (0, import_jsx_runtime69.jsxs)(
             "div",
             {