@oneuptime/common 11.5.0 → 11.5.2

package/Server/Services/MetricService.ts

@@ -560,10 +560,14 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       aggregateBy.aggregateColumnName.toString();
     const aggregationTimestampColumn: string =
       aggregateBy.aggregationTimestampColumnName.toString();
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp!,
-      endDate: aggregateBy.endTimestamp!,
-    }).toLowerCase();
+    const resolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const bucketByTime: boolean =
+      !AggregateUtil.isTotalAggregation(resolvedInterval);
 
     /*
      * Group-by columns from the caller need to be carried through the
@@ -671,7 +675,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
      * always whole numbers in practice).
      */
     statement.append(
-      `SELECT quantileExactWeighted(${percentileLevel})(__pcl_pair.1, toUInt64(greatest(0, round(__pcl_pair.2)))) as ${aggregationColumn}, date_trunc('${aggregationInterval}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval})) as ${aggregationTimestampColumn}`,
+      `SELECT quantileExactWeighted(${percentileLevel})(__pcl_pair.1, toUInt64(greatest(0, round(__pcl_pair.2)))) as ${aggregationColumn}, ${AggregateUtil.buildBucketTimestampSelect(resolvedInterval, aggregationTimestampColumn)}`,
     );
 
     for (const key of groupByKeys) {
@@ -699,13 +703,33 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     statement.append(this.getRetentionReadFilter());
     statement.append(SQL`) `);
 
-    statement.append(SQL` GROUP BY `).append(`${aggregationTimestampColumn}`);
+    /*
+     * `Total` collapses the window into one row per group: the timestamp
+     * becomes an aggregate (`min(...)`) and drops out of GROUP BY, and
+     * when nothing else is grouped the clause is omitted entirely.
+     */
+    const percentileGroupByTerms: Array<string> = [];
+    if (bucketByTime) {
+      percentileGroupByTerms.push(aggregationTimestampColumn);
+    }
     for (const key of groupByKeys) {
-      statement.append(`, ${key}`);
+      percentileGroupByTerms.push(key);
     }
     attributeGroupKeys.forEach((_key: string, index: number) => {
-      statement.append(`, __attr_grp_${index}`);
+      percentileGroupByTerms.push(`__attr_grp_${index}`);
     });
+    if (percentileGroupByTerms.length > 0) {
+      statement
+        .append(SQL` GROUP BY `)
+        .append(percentileGroupByTerms.join(", "));
+    } else {
+      /*
+       * Group-less Total: suppress the single phantom row an empty window
+       * would otherwise return (min(time) → 1970 epoch). Only reachable
+       * under Total — a bucketed query always groups by the time column.
+       */
+      statement.append(SQL` HAVING count() > 0`);
+    }
 
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
@@ -832,10 +856,14 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       aggregateBy.aggregateColumnName.toString();
     const aggregationTimestampColumn: string =
       aggregateBy.aggregationTimestampColumnName.toString();
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp!,
-      endDate: aggregateBy.endTimestamp!,
-    }).toLowerCase();
+    const resolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const bucketByTime: boolean =
+      !AggregateUtil.isTotalAggregation(resolvedInterval);
 
     const groupByKeys: Array<string> = [];
     if (aggregateBy.groupBy) {
@@ -871,7 +899,7 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     const statement: Statement = SQL``;
 
     statement.append(
-      `SELECT ${aggregationExpression} as ${aggregationColumn}, date_trunc('${aggregationInterval}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval})) as ${aggregationTimestampColumn}`,
+      `SELECT ${aggregationExpression} as ${aggregationColumn}, ${AggregateUtil.buildBucketTimestampSelect(resolvedInterval, aggregationTimestampColumn)}`,
     );
     for (const key of groupByKeys) {
       statement.append(`, ${key}`);
@@ -916,13 +944,32 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       statement.append(this.getRetentionReadFilter());
     }
 
-    statement.append(SQL` GROUP BY `).append(`${aggregationTimestampColumn}`);
+    /*
+     * `Total` drops the time bucket from GROUP BY (it becomes an
+     * aggregate `min(...)`), leaving one row per group — or a single
+     * global row when nothing else is grouped, in which case the GROUP
+     * BY clause is omitted entirely.
+     */
+    const scalarGroupByTerms: Array<string> = [];
+    if (bucketByTime) {
+      scalarGroupByTerms.push(aggregationTimestampColumn);
+    }
     for (const key of groupByKeys) {
-      statement.append(`, ${key}`);
+      scalarGroupByTerms.push(key);
     }
     attributeGroupKeys.forEach((_key: string, index: number) => {
-      statement.append(`, __attr_grp_${index}`);
+      scalarGroupByTerms.push(`__attr_grp_${index}`);
     });
+    if (scalarGroupByTerms.length > 0) {
+      statement.append(SQL` GROUP BY `).append(scalarGroupByTerms.join(", "));
+    } else {
+      /*
+       * Group-less Total: suppress the single phantom row an empty window
+       * would otherwise return (min(time) → 1970 epoch). Only reachable
+       * under Total — a bucketed query always groups by the time column.
+       */
+      statement.append(SQL` HAVING count() > 0`);
+    }
 
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
@@ -1044,18 +1091,54 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
       .append(outerWhereStatement)
       .append(SQL` AND retentionDate >= now()`);
 
-    statement
-      .append(SQL` GROUP BY `)
-      .append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+    /*
+     * Mirror the base builder's Total handling: the SELECT above (shared
+     * toAggregateSelectStatement) already emits `min(time)` for a `Total`
+     * interval, so the time column must NOT appear in GROUP BY — grouping
+     * by an aggregate alias is a ClickHouse error. Omit the clause
+     * entirely when nothing else is grouped.
+     */
+    const mutableResolvedInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
+    const mutableBucketByTime: boolean = !AggregateUtil.isTotalAggregation(
+      mutableResolvedInterval,
+    );
+    const mutableHasGroupBy: boolean = Boolean(
+      aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0,
+    );
 
-    if (aggregateBy.groupBy && Object.keys(aggregateBy.groupBy).length > 0) {
+    if (mutableBucketByTime) {
+      statement
+        .append(SQL` GROUP BY `)
+        .append(`${aggregateBy.aggregationTimestampColumnName.toString()}`);
+      if (mutableHasGroupBy) {
+        statement
+          .append(SQL` , `)
+          .append(
+            this.statementGenerator.toGroupByStatement(aggregateBy.groupBy!),
+          );
+      }
+    } else if (mutableHasGroupBy) {
       statement
-        .append(SQL` , `)
+        .append(SQL` GROUP BY `)
         .append(
-          this.statementGenerator.toGroupByStatement(aggregateBy.groupBy),
+          this.statementGenerator.toGroupByStatement(aggregateBy.groupBy!),
         );
     }
 
+    /*
+     * Group-less Total: suppress the single phantom row an empty window
+     * would otherwise return (min(time) → 1970 epoch). No-op for bucketed
+     * or grouped queries.
+     */
+    if (!mutableBucketByTime && !mutableHasGroupBy) {
+      statement.append(SQL` HAVING count() > 0`);
+    }
+
     statement.append(SQL` ORDER BY `).append(sortStatement);
 
     statement.append(
@@ -1236,14 +1319,18 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     const interval: AggregationInterval = AggregateUtil.getAggregationInterval({
       startDate: aggregateBy.startTimestamp!,
       endDate: aggregateBy.endTimestamp!,
+      aggregationInterval: aggregateBy.aggregationInterval,
     });
     /*
-     * The MV is bucketed at 1 minute, so all values of AggregationInterval
-     * (Minute / Hour / Day / Week / Month / Year) are >= MV resolution
-     * and acceptable. Kept as a no-op read so the dependency on
-     * AggregateUtil makes the intent obvious.
+     * The MV is bucketed at 1 minute, so every time-bucketed interval
+     * (Minute / Hour / Day / Week / Month / Year) is >= MV resolution and
+     * acceptable — the honored interval flows into the date_trunc below.
+     * `Total` (whole-window, no bucketing) is the one exception: fall back
+     * to the raw-table builder, which knows how to collapse the window.
      */
-    void interval;
+    if (AggregateUtil.isTotalAggregation(interval)) {
+      return null;
+    }
 
     const queryRecord: Record<string, unknown> =
       (aggregateBy.query as unknown as Record<string, unknown>) || {};
@@ -1510,8 +1597,17 @@ export class MetricService extends AnalyticsDatabaseService<Metric> {
     const interval: AggregationInterval = AggregateUtil.getAggregationInterval({
       startDate: aggregateBy.startTimestamp!,
       endDate: aggregateBy.endTimestamp!,
+      aggregationInterval: aggregateBy.aggregationInterval,
     });
-    void interval;
+    /*
+     * `Total` (whole-window, no bucketing) is not served by this
+     * time-bucketed per-host MV — fall back to the raw-table builder.
+     * Every other interval is >= the MV's 1-minute resolution and flows
+     * into the date_trunc below.
+     */
+    if (AggregateUtil.isTotalAggregation(interval)) {
+      return null;
+    }
 
     if (!this.database) {
       this.useDefaultDatabase();

package/Server/Services/SpanService.ts

@@ -245,6 +245,17 @@ export class SpanService extends AnalyticsDatabaseService<Span> {
       return null;
     }
 
+    /*
+     * This projection path derives its bucket interval from the window
+     * and buckets by minute; it does not implement the explicit
+     * `aggregationInterval` override (nor the `Total` whole-window mode).
+     * When a caller pins an interval, fall back to the generic base
+     * builder, which honors it.
+     */
+    if (aggregateBy.aggregationInterval !== undefined) {
+      return null;
+    }
+
     /*
      * Only the aggregates whose states the projection stores. P95 etc.
      * must fall back: the projection has no quantile(0.95) state and

package/Server/Types/AnalyticsDatabase/AggregateBy.ts

@@ -16,12 +16,51 @@ export class AggregateUtil {
    * code reconstructing the server's bucket grid (heartbeat
    * availability charts) always agrees with the interval the
    * statement generator compiles into `toStartOfInterval(...)`.
+   *
+   * `aggregationInterval`, when provided, pins the bucket size
+   * independent of the window (including `Total` for a single
+   * whole-window bucket per group).
    */
   @CaptureSpan()
   public static getAggregationInterval(data: {
     startDate: Date;
     endDate: Date;
+    aggregationInterval?: AggregationInterval | undefined;
   }): AggregationInterval {
     return AggregationIntervalUtil.getAggregationIntervalForWindow(data);
   }
+
+  /**
+   * True when the resolved interval means "no time bucketing" — the
+   * entire window collapses into one aggregate per group.
+   */
+  public static isTotalAggregation(interval: AggregationInterval): boolean {
+    return interval === AggregationInterval.Total;
+  }
+
+  /**
+   * The SELECT fragment that produces the bucket timestamp column,
+   * already aliased to `timestampColumn`. Shared by every aggregate SQL
+   * builder so the `Total` (whole-window) shape stays identical across
+   * paths:
+   *
+   *   - normal interval → `date_trunc('<i>', toStartOfInterval(col, INTERVAL 1 <i>)) as col`
+   *   - Total           → `min(col) as col` (one row per group; the
+   *     earliest sample timestamp in the window is the bucket label)
+   *
+   * `timestampColumn` is a model-validated identifier (see
+   * AnalyticsDatabaseService._aggregateBy), so raw interpolation here is
+   * consistent with the surrounding builders.
+   */
+  public static buildBucketTimestampSelect(
+    resolvedInterval: AggregationInterval,
+    timestampColumn: string,
+  ): string {
+    if (AggregateUtil.isTotalAggregation(resolvedInterval)) {
+      return `min(${timestampColumn}) as ${timestampColumn}`;
+    }
+
+    const interval: string = resolvedInterval.toLowerCase();
+    return `date_trunc('${interval}', toStartOfInterval(${timestampColumn}, INTERVAL 1 ${interval})) as ${timestampColumn}`;
+  }
 }

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -51,6 +51,7 @@ import JSONFunctions from "../../../Types/JSONFunctions";
 import AggregateBy, {
   AggregateUtil,
 } from "../../Types/AnalyticsDatabase/AggregateBy";
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
 import CaptureSpan from "../Telemetry/CaptureSpan";
 import { getPercentileLevel } from "../../../Types/BaseDatabase/AggregationType";
 
@@ -1194,10 +1195,12 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
 
     const selectStatement: Statement = new Statement();
 
-    const aggregationInterval: string = AggregateUtil.getAggregationInterval({
-      startDate: aggregateBy.startTimestamp!,
-      endDate: aggregateBy.endTimestamp!,
-    });
+    const aggregationInterval: AggregationInterval =
+      AggregateUtil.getAggregationInterval({
+        startDate: aggregateBy.startTimestamp!,
+        endDate: aggregateBy.endTimestamp!,
+        aggregationInterval: aggregateBy.aggregationInterval,
+      });
     const aggregationColumn: string =
       aggregateBy.aggregateColumnName.toString();
     const aggregationTimestampColumn: string =
@@ -1212,7 +1215,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
         : `${aggregateBy.aggregationType.toLocaleLowerCase()}(${aggregationColumn})`;
 
     selectStatement.append(
-      `${aggregationExpression} as ${aggregationColumn}, date_trunc('${aggregationInterval.toLowerCase()}', toStartOfInterval(${aggregationTimestampColumn}, INTERVAL 1 ${aggregationInterval.toLowerCase()})) as ${aggregationTimestampColumn}`,
+      `${aggregationExpression} as ${aggregationColumn}, ${AggregateUtil.buildBucketTimestampSelect(aggregationInterval, aggregationTimestampColumn)}`,
     );
 
     const columns: Array<string> = [

package/Tests/Server/Services/AnalyticsDatabaseService.test.ts

@@ -11,6 +11,7 @@ import AnalyticsTableEngine from "../../../Types/AnalyticsDatabase/AnalyticsTabl
 import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
+import SortOrder from "../../../Types/BaseDatabase/SortOrder";
 import BadDataException from "../../../Types/Exception/BadDataException";
 import GenericObject from "../../../Types/GenericObject";
 import ObjectID from "../../../Types/ObjectID";
@@ -314,6 +315,89 @@ describe("AnalyticsDatabaseService", () => {
         ),
       ).rejects.toThrow("Invalid aggregationTimestampColumnName");
     });
+
+    test("should reject an unrecognized aggregationInterval", async () => {
+      await expect(
+        service.aggregateBy(
+          makeAggregateBy({ aggregationInterval: "NotAnInterval" }),
+        ),
+      ).rejects.toThrow("Invalid aggregationInterval");
+    });
+  });
+
+  /*
+   * The base AnalyticsDatabaseService.toAggregateStatement is what every
+   * analytics model that does NOT override aggregation (Log, AuditLog, …)
+   * uses. Exercise its aggregationInterval / Total GROUP BY assembly here,
+   * since MetricService's own builders bypass it.
+   */
+  describe("toAggregateStatement aggregationInterval (base path)", () => {
+    beforeEach(() => {
+      jest.spyOn(logger, "debug").mockImplementation(() => {
+        return undefined!;
+      });
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    const makeBaseAggregateBy: (overrides?: Record<string, unknown>) => any = (
+      overrides: Record<string, unknown> = {},
+    ): any => {
+      return {
+        aggregationType: AggregationType.Sum,
+        aggregateColumnName: "column_2",
+        aggregationTimestampColumnName: "column_ObjectID",
+        startTimestamp: new Date("2024-01-01"),
+        endTimestamp: new Date("2024-01-02"),
+        query: {},
+        sort: { column_ObjectID: SortOrder.Ascending },
+        limit: 10,
+        skip: 0,
+        props: { isRoot: true },
+        ...overrides,
+      };
+    };
+
+    test("derives the window bucket and groups by time when interval is omitted", () => {
+      const query: string = service.toAggregateStatement(makeBaseAggregateBy())
+        .statement.query;
+
+      // 1-day window derives an Hour bucket, grouped by the time column.
+      expect(query).toContain(
+        "date_trunc('hour', toStartOfInterval(column_ObjectID, INTERVAL 1 hour))",
+      );
+      expect(query).toContain("GROUP BY column_ObjectID");
+      expect(query).not.toContain("min(column_ObjectID)");
+    });
+
+    test("Total with no group-by drops the time bucket and guards empty windows", () => {
+      const query: string = service.toAggregateStatement(
+        makeBaseAggregateBy({ aggregationInterval: "Total" }),
+      ).statement.query;
+
+      expect(query).toContain("min(column_ObjectID) as column_ObjectID");
+      expect(query).not.toContain("date_trunc");
+      expect(query).not.toContain("GROUP BY");
+      expect(query).toContain("HAVING count() > 0");
+    });
+
+    test("Total with a model-column group-by keeps the column, drops the time bucket", () => {
+      const query: string = service.toAggregateStatement(
+        makeBaseAggregateBy({
+          aggregationInterval: "Total",
+          groupBy: { column_1: true },
+        }),
+      ).statement.query;
+
+      expect(query).toContain("min(column_ObjectID) as column_ObjectID");
+      expect(query).toContain("GROUP BY");
+      // The time column must not be a grouping key under Total.
+      expect(query).not.toContain("GROUP BY column_ObjectID");
+      // A grouped query never needs the empty-window guard.
+      expect(query).not.toContain("HAVING count() > 0");
+    });
   });
 
   describe("toDeleteStatement", () => {

package/Tests/Server/Services/MetricServiceAggregate.test.ts

@@ -3,6 +3,7 @@ import { MetricService } from "../../../Server/Services/MetricService";
 import Metric from "../../../Models/AnalyticsModels/Metric";
 import AggregateBy from "../../../Server/Types/AnalyticsDatabase/AggregateBy";
 import { Statement } from "../../../Server/Utils/AnalyticsDatabase/Statement";
+import AggregationInterval from "../../../Types/BaseDatabase/AggregationInterval";
 import AggregationType from "../../../Types/BaseDatabase/AggregationType";
 import InBetween from "../../../Types/BaseDatabase/InBetween";
 import SortOrder from "../../../Types/BaseDatabase/SortOrder";
@@ -191,4 +192,170 @@ describe("MetricService aggregate statement generation", () => {
       expect(query).toContain("GROUP BY time");
     });
   });
+
+  /*
+   * The `aggregationInterval` override lets callers pin the time bucket
+   * independent of the query window (the two scenarios from the customer
+   * thread: "daily uptime per host over a week" and "one weekly average
+   * per host"). The buildAggregateBy window is 5 minutes, so its
+   * window-derived interval is Minute — every assertion below proves the
+   * override wins over that default.
+   */
+  describe("explicit aggregationInterval override", () => {
+    it("pins a Day bucket over the window-derived Minute (per-host daily)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Day,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain(
+        "date_trunc('day', toStartOfInterval(time, INTERVAL 1 day))",
+      );
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+      // The 5-minute window's default Minute bucket must NOT leak through.
+      expect(query).not.toContain("date_trunc('minute'");
+    });
+
+    it("honors an explicit Day interval on the minute MV fast path", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Day,
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("MetricItemAggMV1m");
+      expect(query).toContain("date_trunc('day'");
+    });
+
+    it("honors an explicit Day interval on the percentile path", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationType: AggregationType.P90,
+        aggregationInterval: AggregationInterval.Day,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("quantileExactWeighted(0.9)");
+      expect(query).toContain("date_trunc('day'");
+      expect(query).toContain("GROUP BY time, __attr_grp_0");
+    });
+
+    it("reproduces the window-derived bucket SQL when omitted (regression)", () => {
+      /*
+       * Distribution hint forces the base scalar builder (skips the MVs).
+       * The 5-minute window must still derive a Minute bucket, unchanged.
+       */
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy();
+      (
+        service as unknown as {
+          pointTypeHintByAggregate: WeakMap<AggregateBy<Metric>, string | null>;
+        }
+      ).pointTypeHintByAggregate.set(aggregateBy, "Histogram");
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain(
+        "date_trunc('minute', toStartOfInterval(time, INTERVAL 1 minute))",
+      );
+      expect(query).toContain("GROUP BY time");
+      expect(query).not.toContain("min(time) as time");
+      expect(query).not.toContain("HAVING count() > 0");
+    });
+  });
+
+  /*
+   * `Total` = no time bucketing: the entire window collapses into a single
+   * aggregate per group. The bucket timestamp becomes `min(time)` (an
+   * aggregate, not a group key), so `time` must drop out of GROUP BY —
+   * and the clause disappears entirely when nothing else is grouped.
+   */
+  describe("Total (whole-window) aggregation", () => {
+    it("collapses the window into one row per host (scalar Avg)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("min(time) as time");
+      expect(query).not.toContain("date_trunc");
+      expect(query).toContain("GROUP BY __attr_grp_0");
+      expect(query).not.toContain("GROUP BY time");
+    });
+
+    it("emits a single global aggregate with no GROUP BY when nothing is grouped", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+        /*
+         * An attribute filter (not a host filter) blocks every MV and
+         * routes to the base scalar builder without a group-by.
+         */
+        query: {
+          projectId: projectId,
+          name: "http.client.request.duration",
+          time: new InBetween(startDate, endDate),
+          attributes: { "oneuptime.service.name": "starship-web" },
+        } as unknown as AggregateBy<Metric>["query"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).not.toContain("MetricItemAggMV1m");
+      expect(query).toContain("min(time) as time");
+      expect(query).not.toContain("GROUP BY");
+      // The phantom row an empty window would return is suppressed.
+      expect(query).toContain("HAVING count() > 0");
+    });
+
+    it("falls back from the minute MV to the base table for Total", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      // The time-bucketed MV cannot serve a whole-window aggregation.
+      expect(query).not.toContain("MetricItemAggMV1m");
+      expect(query).toContain("min(time) as time");
+      expect(query).not.toContain("GROUP BY");
+      expect(query).toContain("HAVING count() > 0");
+    });
+
+    it("keeps a model-column groupBy while dropping the time bucket (Total)", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationInterval: AggregationInterval.Total,
+        groupBy: { metricPointType: true } as AggregateBy<Metric>["groupBy"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("min(time) as time");
+      // The model column survives as the sole grouping key...
+      expect(query).toContain("GROUP BY metricPointType");
+      // ...and the time bucket is gone (it is now an aggregate).
+      expect(query).not.toContain("GROUP BY time");
+      expect(query).not.toContain("date_trunc");
+      // A grouped query never emits the empty-window guard.
+      expect(query).not.toContain("HAVING count() > 0");
+    });
+
+    it("collapses the window into one row per host on the percentile path", () => {
+      const aggregateBy: AggregateBy<Metric> = buildAggregateBy({
+        aggregationType: AggregationType.P90,
+        aggregationInterval: AggregationInterval.Total,
+        groupByAttributeKeys: ["host.name"],
+      });
+
+      const query: string = getQuery(aggregateBy);
+
+      expect(query).toContain("quantileExactWeighted(0.9)");
+      expect(query).toContain("min(time) as time");
+      expect(query).toContain("GROUP BY __attr_grp_0");
+      expect(query).not.toContain("date_trunc");
+    });
+  });
 });

package/Tests/Types/BaseDatabase/AggregationIntervalUtil.test.ts

@@ -53,6 +53,34 @@ describe("AggregationIntervalUtil", () => {
       },
     );
 
+    test("an explicit override wins over the window-derived interval", () => {
+      // A 2-hour window derives Minute, but the override pins Day.
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalForWindow({
+          ...windowOf(2 * HOUR),
+          aggregationInterval: AggregationInterval.Day,
+        }),
+      ).toBe(AggregationInterval.Day);
+    });
+
+    test("the Total override is returned verbatim (whole-window bucketing)", () => {
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalForWindow({
+          ...windowOf(14 * DAY),
+          aggregationInterval: AggregationInterval.Total,
+        }),
+      ).toBe(AggregationInterval.Total);
+    });
+
+    test("an invalid override falls through to the window-derived interval", () => {
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalForWindow({
+          ...windowOf(2 * HOUR),
+          aggregationInterval: "NotAnInterval" as AggregationInterval,
+        }),
+      ).toBe(AggregationInterval.Minute);
+    });
+
     test("returns the widest interval as the window grows", () => {
       const order: Array<AggregationInterval> = [
         AggregationInterval.Minute,
@@ -105,6 +133,18 @@ describe("AggregationIntervalUtil", () => {
       },
     );
 
+    test("Total has no fixed width, so it maps to a very large sentinel > Year", () => {
+      expect(
+        AggregationIntervalUtil.getAggregationIntervalMs(
+          AggregationInterval.Total,
+        ),
+      ).toBeGreaterThan(
+        AggregationIntervalUtil.getAggregationIntervalMs(
+          AggregationInterval.Year,
+        ),
+      );
+    });
+
     test("intervals are strictly increasing in width", () => {
       const ordered: Array<AggregationInterval> = [
         AggregationInterval.Minute,