@oneuptime/common 11.6.0 → 11.6.1

package/Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel.ts

@@ -77,6 +77,15 @@ export default class AnalyticsBaseModel extends CommonModel {
     materializedViews?: Array<MaterializedView> | undefined;
     enableMCP?: boolean | undefined;
     ttlExpression?: string | undefined; // e.g. "retentionDate DELETE"
+    /*
+     * Generic event/entity tables carry `_id` and `createdAt`. Derived
+     * AggregatingMergeTree targets do not represent independently-addressable
+     * rows: their identity is exactly their aggregation key, and an arbitrary
+     * creation timestamp has no stable meaning after merges. Those models set
+     * this false so ClickHouse can enforce that every non-key column is an
+     * aggregate measure. Defaults true for backward compatibility.
+     */
+    includeBaseColumns?: boolean | undefined;
     /*
      * Column that `findBy` falls back to when the caller doesn't
      * specify a `sort`. Defaults to `createdAt` (matching the legacy
@@ -100,31 +109,39 @@ export default class AnalyticsBaseModel extends CommonModel {
       this.tableEngine = data.tableEngine;
     }
 
-    columns.push(
-      new AnalyticsTableColumn({
-        key: "_id",
-        title: "ID",
-        description: "ID of this object",
-        required: true,
-        type: TableColumnType.ObjectID,
-        /*
-         * Ids are UUIDv7 (time-ordered — see ObjectID.generateTimeOrdered),
-         * so consecutive rows share their 48-bit timestamp prefix and ZSTD
-         * compresses them well; random v4 ids were incompressible.
-         */
-        codec: { codec: "ZSTD", level: 1 },
-      }),
-    );
+    if (data.includeBaseColumns !== false) {
+      columns.push(
+        new AnalyticsTableColumn({
+          key: "_id",
+          title: "ID",
+          description: "ID of this object",
+          required: true,
+          type: TableColumnType.ObjectID,
+          /*
+           * Ids are UUIDv7 (time-ordered — see ObjectID.generateTimeOrdered),
+           * so consecutive rows share their 48-bit timestamp prefix and ZSTD
+           * compresses them well; random v4 ids were incompressible.
+           */
+          codec: { codec: "ZSTD", level: 1 },
+        }),
+      );
 
-    columns.push(
-      new AnalyticsTableColumn({
-        key: "createdAt",
-        title: "Created",
-        description: "Date and Time when the object was created.",
-        required: true,
-        type: TableColumnType.Date,
-      }),
-    );
+      columns.push(
+        new AnalyticsTableColumn({
+          key: "createdAt",
+          title: "Created",
+          description: "Date and Time when the object was created.",
+          required: true,
+          type: TableColumnType.Date,
+        }),
+      );
+    }
+
+    if (data.includeBaseColumns === false && !data.defaultSortColumn) {
+      throw new BadDataException(
+        "defaultSortColumn is required when includeBaseColumns is false because createdAt is not part of the table schema",
+      );
+    }
 
     if (!data.primaryKeys || data.primaryKeys.length === 0) {
       throw new BadDataException("Primary keys are required");

package/Models/AnalyticsModels/MetricBaselineHourly.ts

@@ -234,6 +234,8 @@ GROUP BY projectId, name, primaryEntityId, day, hourOfWeek`,
       tableSettings:
         "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
       ttlExpression: "day + INTERVAL 90 DAY",
+      includeBaseColumns: false,
+      defaultSortColumn: "day",
     });
   }
 }

package/Models/AnalyticsModels/MetricItemAggMV1m.ts

@@ -110,9 +110,10 @@ export default class MetricItemAggMV1m extends AnalyticsBaseModel {
       key: "retentionDate",
       title: "Retention Date",
       description:
-        "Date after which this row is eligible for TTL deletion. Computed by the MV as max(retentionDate) per bucket — inherits from the source MetricItemV3 rows.",
+        "Latest date after which this aggregate bucket is eligible for TTL deletion. Stored as SimpleAggregateFunction(max, DateTime) so partial rows keep the maximum expiry when AggregatingMergeTree merges them.",
       required: true,
       type: TableColumnType.Date,
+      simpleAggregateFunction: "max",
     });
 
     super({
@@ -156,7 +157,7 @@ SELECT
   countState(toFloat64(coalesce(value, sum, 0))) AS valueCountState,
   minState(toFloat64(coalesce(value, sum, 0))) AS valueMinState,
   maxState(toFloat64(coalesce(value, sum, 0))) AS valueMaxState,
-  max(retentionDate) AS retentionDate
+  maxSimpleState(retentionDate) AS retentionDate
 FROM MetricItemV3
 GROUP BY projectId, name, primaryEntityId, bucketTime`,
         },
@@ -172,6 +173,8 @@ GROUP BY projectId, name, primaryEntityId, bucketTime`,
       tableSettings:
         "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
       ttlExpression: "retentionDate DELETE",
+      includeBaseColumns: false,
+      defaultSortColumn: "bucketTime",
     });
   }
 }

package/Models/AnalyticsModels/MetricItemAggMV1mByContainer.ts

@@ -111,9 +111,10 @@ export default class MetricItemAggMV1mByContainer extends AnalyticsBaseModel {
       key: "retentionDate",
       title: "Retention Date",
       description:
-        "Date after which this row is eligible for TTL deletion. Computed by the MV as max(retentionDate) per bucket — inherits from the source MetricItemV3 rows.",
+        "Latest date after which this aggregate bucket is eligible for TTL deletion. Stored as SimpleAggregateFunction(max, DateTime) so partial rows keep the maximum expiry when AggregatingMergeTree merges them.",
       required: true,
       type: TableColumnType.Date,
+      simpleAggregateFunction: "max",
     });
 
     super({
@@ -159,7 +160,7 @@ SELECT
   countState(toFloat64(coalesce(value, sum, 0))) AS valueCountState,
   minState(toFloat64(coalesce(value, sum, 0))) AS valueMinState,
   maxState(toFloat64(coalesce(value, sum, 0))) AS valueMaxState,
-  max(retentionDate) AS retentionDate
+  maxSimpleState(retentionDate) AS retentionDate
 FROM MetricItemV3
 WHERE containerEntityKey != ''
 GROUP BY projectId, name, containerEntityKey, bucketTime`,
@@ -173,6 +174,8 @@ GROUP BY projectId, name, containerEntityKey, bucketTime`,
       tableSettings:
         "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
       ttlExpression: "retentionDate DELETE",
+      includeBaseColumns: false,
+      defaultSortColumn: "bucketTime",
     });
   }
 }

package/Models/AnalyticsModels/MetricItemAggMV1mByHostV2.ts

@@ -114,9 +114,10 @@ export default class MetricItemAggMV1mByHostV2 extends AnalyticsBaseModel {
       key: "retentionDate",
       title: "Retention Date",
       description:
-        "Date after which this row is eligible for TTL deletion. Computed by the MV as max(retentionDate) per bucket — inherits from the source MetricItemV3 rows.",
+        "Latest date after which this aggregate bucket is eligible for TTL deletion. Stored as SimpleAggregateFunction(max, DateTime) so partial rows keep the maximum expiry when AggregatingMergeTree merges them.",
       required: true,
       type: TableColumnType.Date,
+      simpleAggregateFunction: "max",
     });
 
     super({
@@ -162,7 +163,7 @@ SELECT
   countState(toFloat64(coalesce(value, sum, 0))) AS valueCountState,
   minState(toFloat64(coalesce(value, sum, 0))) AS valueMinState,
   maxState(toFloat64(coalesce(value, sum, 0))) AS valueMaxState,
-  max(retentionDate) AS retentionDate
+  maxSimpleState(retentionDate) AS retentionDate
 FROM MetricItemV3
 WHERE hostEntityKey != ''
 GROUP BY projectId, name, hostEntityKey, bucketTime`,
@@ -176,6 +177,8 @@ GROUP BY projectId, name, hostEntityKey, bucketTime`,
       tableSettings:
         "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
       ttlExpression: "retentionDate DELETE",
+      includeBaseColumns: false,
+      defaultSortColumn: "bucketTime",
     });
   }
 }

package/Models/AnalyticsModels/MetricItemAggMV1mByK8sCluster.ts

@@ -110,9 +110,10 @@ export default class MetricItemAggMV1mByK8sCluster extends AnalyticsBaseModel {
       key: "retentionDate",
       title: "Retention Date",
       description:
-        "Date after which this row is eligible for TTL deletion. Computed by the MV as max(retentionDate) per bucket — inherits from the source MetricItemV3 rows.",
+        "Latest date after which this aggregate bucket is eligible for TTL deletion. Stored as SimpleAggregateFunction(max, DateTime) so partial rows keep the maximum expiry when AggregatingMergeTree merges them.",
       required: true,
       type: TableColumnType.Date,
+      simpleAggregateFunction: "max",
     });
 
     super({
@@ -160,7 +161,7 @@ SELECT
   countState(toFloat64(coalesce(value, sum, 0))) AS valueCountState,
   minState(toFloat64(coalesce(value, sum, 0))) AS valueMinState,
   maxState(toFloat64(coalesce(value, sum, 0))) AS valueMaxState,
-  max(retentionDate) AS retentionDate
+  maxSimpleState(retentionDate) AS retentionDate
 FROM MetricItemV3
 WHERE k8sClusterEntityKey != ''
 GROUP BY projectId, name, k8sClusterEntityKey, bucketTime`,
@@ -174,6 +175,8 @@ GROUP BY projectId, name, k8sClusterEntityKey, bucketTime`,
       tableSettings:
         "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
       ttlExpression: "retentionDate DELETE",
+      includeBaseColumns: false,
+      defaultSortColumn: "bucketTime",
     });
   }
 }

package/Models/AnalyticsModels/MetricItemAggMV1mByService.ts

@@ -112,9 +112,10 @@ export default class MetricItemAggMV1mByService extends AnalyticsBaseModel {
       key: "retentionDate",
       title: "Retention Date",
       description:
-        "Date after which this row is eligible for TTL deletion. Computed by the MV as max(retentionDate) per bucket — inherits from the source MetricItemV3 rows.",
+        "Latest date after which this aggregate bucket is eligible for TTL deletion. Stored as SimpleAggregateFunction(max, DateTime) so partial rows keep the maximum expiry when AggregatingMergeTree merges them.",
       required: true,
       type: TableColumnType.Date,
+      simpleAggregateFunction: "max",
     });
 
     super({
@@ -160,7 +161,7 @@ SELECT
   countState(toFloat64(coalesce(value, sum, 0))) AS valueCountState,
   minState(toFloat64(coalesce(value, sum, 0))) AS valueMinState,
   maxState(toFloat64(coalesce(value, sum, 0))) AS valueMaxState,
-  max(retentionDate) AS retentionDate
+  maxSimpleState(retentionDate) AS retentionDate
 FROM MetricItemV3
 WHERE serviceEntityKey != ''
 GROUP BY projectId, name, serviceEntityKey, bucketTime`,
@@ -174,6 +175,8 @@ GROUP BY projectId, name, serviceEntityKey, bucketTime`,
       tableSettings:
         "ttl_only_drop_parts = 1, non_replicated_deduplication_window = 10000",
       ttlExpression: "retentionDate DELETE",
+      includeBaseColumns: false,
+      defaultSortColumn: "bucketTime",
     });
   }
 }

package/Server/Services/AnalyticsDatabaseService.ts

@@ -983,7 +983,19 @@ export default class AnalyticsDatabaseService<
         onBeforeFind.select = {} as any;
       }
 
-      if (!(onBeforeFind.select as any)["_id"]) {
+      /*
+       * Derived aggregate targets deliberately omit AnalyticsBaseModel's
+       * synthetic `_id`: the aggregation key is the row identity. Only force
+       * `_id` into generic reads when the model actually declares it.
+       */
+      if (
+        this.model.tableColumns.some(
+          (column: AnalyticsTableColumn): boolean => {
+            return column.key === "_id";
+          },
+        ) &&
+        !(onBeforeFind.select as any)["_id"]
+      ) {
         (onBeforeFind.select as any)["_id"] = true;
       }
 

package/Server/Utils/AnalyticsDatabase/StatementGenerator.ts

@@ -69,6 +69,8 @@ export interface EntityScopeQueryValue {
   attributeValue: string;
 }
 
+const SIMPLE_AGGREGATE_FUNCTION_NAME_REGEX: RegExp = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
 export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
   public model!: TBaseModel;
   public modelType!: { new (): TBaseModel };
@@ -1361,6 +1363,32 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
    * column. Scalar types ignore the rest of the column.
    */
   public toColumnType(column: AnalyticsTableColumn): Statement {
+    const simpleAggregateFunction: string | undefined =
+      column.simpleAggregateFunction;
+
+    if (simpleAggregateFunction !== undefined) {
+      if (column.type === TableColumnType.AggregateFunction) {
+        throw new BadDataException(
+          `Column ${column.key} cannot declare both AggregateFunction and SimpleAggregateFunction.`,
+        );
+      }
+
+      /*
+       * The function name is emitted as raw ClickHouse DDL, so accept only a
+       * plain function identifier. Besides catching accidental whitespace /
+       * empty definitions, this prevents a model field from injecting another
+       * type or table clause into generated schema SQL.
+       */
+      if (
+        simpleAggregateFunction.trim() !== simpleAggregateFunction ||
+        !SIMPLE_AGGREGATE_FUNCTION_NAME_REGEX.test(simpleAggregateFunction)
+      ) {
+        throw new BadDataException(
+          `Column ${column.key} has invalid simpleAggregateFunction "${simpleAggregateFunction}".`,
+        );
+      }
+    }
+
     if (column.type === TableColumnType.AggregateFunction) {
       const def: string | undefined = column.aggregateFunctionDefinition;
       if (!def) {
@@ -1371,7 +1399,7 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       return SQL`AggregateFunction(`.append(def).append(SQL`)`);
     }
 
-    const statement: Statement | undefined = {
+    const scalarStatement: Statement | undefined = {
       [TableColumnType.Text]: SQL`String`,
       [TableColumnType.ObjectID]: SQL`String`,
       [TableColumnType.Boolean]: SQL`Bool`,
@@ -1394,13 +1422,21 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
       [TableColumnType.UInt64]: SQL`UInt64`,
     }[column.type];
 
-    if (!statement) {
+    if (!scalarStatement) {
       throw new BadDataException(
         `Unknown column type: ${column.type}. Please add support for this column type.`,
       );
     }
 
-    return statement;
+    if (simpleAggregateFunction) {
+      return SQL`SimpleAggregateFunction(`
+        .append(simpleAggregateFunction)
+        .append(SQL`, `)
+        .append(scalarStatement)
+        .append(SQL`)`);
+    }
+
+    return scalarStatement;
   }
 
   /**
@@ -1413,7 +1449,8 @@ export default class StatementGenerator<TBaseModel extends AnalyticsBaseModel> {
    */
   public toFullColumnType(column: AnalyticsTableColumn): Statement {
     const isAggregateFunction: boolean =
-      column.type === TableColumnType.AggregateFunction;
+      column.type === TableColumnType.AggregateFunction ||
+      Boolean(column.simpleAggregateFunction);
 
     let typeStatement: Statement = this.toColumnType(column);
 

package/Tests/Models/AnalyticsModels/AnalyticsBaseModel.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, test } from "@jest/globals";
+import AnalyticsBaseModel from "../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import AnalyticsTableEngine from "../../../Types/AnalyticsDatabase/AnalyticsTableEngine";
+import AnalyticsTableColumn from "../../../Types/AnalyticsDatabase/TableColumn";
+import TableColumnType from "../../../Types/AnalyticsDatabase/TableColumnType";
+
+type ModelOptions = ConstructorParameters<typeof AnalyticsBaseModel>[0];
+
+function projectIdColumn(): AnalyticsTableColumn {
+  return new AnalyticsTableColumn({
+    key: "projectId",
+    title: "Project ID",
+    description: "Tenant",
+    required: true,
+    type: TableColumnType.Text,
+  });
+}
+
+function modelOptions(overrides: Partial<ModelOptions> = {}): ModelOptions {
+  return {
+    tableName: "TestAnalyticsTable",
+    singularName: "Test row",
+    pluralName: "Test rows",
+    tableColumns: [projectIdColumn()],
+    primaryKeys: ["projectId"],
+    sortKeys: ["projectId"],
+    partitionKey: "projectId",
+    tableEngine: AnalyticsTableEngine.MergeTree,
+    ...overrides,
+  };
+}
+
+describe("AnalyticsBaseModel base-column policy", () => {
+  test("adds _id and createdAt by default for regular analytics models", () => {
+    const suppliedColumns: Array<AnalyticsTableColumn> = [projectIdColumn()];
+    const model: AnalyticsBaseModel = new AnalyticsBaseModel(
+      modelOptions({ tableColumns: suppliedColumns }),
+    );
+
+    expect(
+      model.tableColumns.map((column: AnalyticsTableColumn) => {
+        return column.key;
+      }),
+    ).toEqual(["projectId", "_id", "createdAt"]);
+    expect(model.getTableColumn("_id")?.type).toBe(TableColumnType.ObjectID);
+    expect(model.getTableColumn("_id")?.codec).toEqual({
+      codec: "ZSTD",
+      level: 1,
+    });
+    expect(model.getTableColumn("createdAt")?.type).toBe(TableColumnType.Date);
+
+    // Construction copies the caller's array instead of mutating it.
+    expect(
+      suppliedColumns.map((column: AnalyticsTableColumn) => {
+        return column.key;
+      }),
+    ).toEqual(["projectId"]);
+  });
+
+  test("omits synthetic columns when includeBaseColumns is false", () => {
+    const model: AnalyticsBaseModel = new AnalyticsBaseModel(
+      modelOptions({
+        includeBaseColumns: false,
+        defaultSortColumn: "projectId",
+      }),
+    );
+
+    expect(
+      model.tableColumns.map((column: AnalyticsTableColumn) => {
+        return column.key;
+      }),
+    ).toEqual(["projectId"]);
+    expect(model.getTableColumn("_id")).toBeNull();
+    expect(model.getTableColumn("createdAt")).toBeNull();
+    expect(model.defaultSortColumn).toBe("projectId");
+  });
+
+  test("requires a real default sort column when base columns are omitted", () => {
+    expect(() => {
+      return new AnalyticsBaseModel(
+        modelOptions({
+          includeBaseColumns: false,
+        }),
+      );
+    }).toThrow(
+      "defaultSortColumn is required when includeBaseColumns is false",
+    );
+  });
+
+  test("rejects createdAt as a strict model's default sort because it is absent", () => {
+    expect(() => {
+      return new AnalyticsBaseModel(
+        modelOptions({
+          includeBaseColumns: false,
+          defaultSortColumn: "createdAt",
+        }),
+      );
+    }).toThrow("defaultSortColumn createdAt is not part of tableColumns");
+  });
+
+  test("still validates primary and sort keys against the strict column set", () => {
+    expect(() => {
+      return new AnalyticsBaseModel(
+        modelOptions({
+          includeBaseColumns: false,
+          defaultSortColumn: "projectId",
+          sortKeys: ["projectId", "createdAt"],
+        }),
+      );
+    }).toThrow("Sort key createdAt is not part of tableColumns");
+
+    expect(() => {
+      return new AnalyticsBaseModel(
+        modelOptions({
+          includeBaseColumns: false,
+          defaultSortColumn: "projectId",
+          primaryKeys: ["_id"],
+        }),
+      );
+    }).toThrow("Primary key _id is not part of tableColumns");
+  });
+});

package/Tests/Server/Utils/AnalyticsDatabase/ClusterAwareSchema.test.ts

@@ -15,13 +15,21 @@ import {
 } from "../../../../Server/Utils/AnalyticsDatabase/ClusterConfig";
 import UpdateBy from "../../../../Server/Types/AnalyticsDatabase/UpdateBy";
 import "../../TestingUtils/Init";
-import AnalyticsBaseModel from "../../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
+import AnalyticsBaseModel, {
+  AnalyticsBaseModelType,
+} from "../../../../Models/AnalyticsModels/AnalyticsBaseModel/AnalyticsBaseModel";
 import Route from "../../../../Types/API/Route";
 import AnalyticsTableEngine from "../../../../Types/AnalyticsDatabase/AnalyticsTableEngine";
 import AnalyticsTableColumn, {
   SkipIndexType,
 } from "../../../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../../../Types/AnalyticsDatabase/TableColumnType";
+import MetricItemAggMV1m from "../../../../Models/AnalyticsModels/MetricItemAggMV1m";
+import MetricItemAggMV1mByHostV2 from "../../../../Models/AnalyticsModels/MetricItemAggMV1mByHostV2";
+import MetricItemAggMV1mByService from "../../../../Models/AnalyticsModels/MetricItemAggMV1mByService";
+import MetricItemAggMV1mByK8sCluster from "../../../../Models/AnalyticsModels/MetricItemAggMV1mByK8sCluster";
+import MetricItemAggMV1mByContainer from "../../../../Models/AnalyticsModels/MetricItemAggMV1mByContainer";
+import MetricBaselineHourly from "../../../../Models/AnalyticsModels/MetricBaselineHourly";
 
 const CLUSTER_ENV_KEY: string = "CLICKHOUSE_CLUSTER_NAME";
 const SHARDING_ENV_KEY: string = "CLICKHOUSE_SHARDING_KEY";
@@ -167,12 +175,38 @@ describe("ClickHouse cluster-aware schema (always-on)", () => {
               required: true,
               type: TableColumnType.ObjectID,
             }),
+            new AnalyticsTableColumn({
+              key: "bucketTime",
+              title: "Bucket",
+              description: "Bucket",
+              required: true,
+              type: TableColumnType.Date,
+            }),
+            new AnalyticsTableColumn({
+              key: "retentionDate",
+              title: "Retention",
+              description: "Retention",
+              required: true,
+              type: TableColumnType.Date,
+              simpleAggregateFunction: "max",
+            }),
+            new AnalyticsTableColumn({
+              key: "valueState",
+              title: "Value",
+              description: "Value",
+              required: true,
+              type: TableColumnType.AggregateFunction,
+              aggregateFunctionDefinition: "sum, Float64",
+            }),
           ],
           crudApiPath: new Route("agg"),
-          primaryKeys: ["projectId"],
-          sortKeys: ["projectId"],
+          primaryKeys: ["projectId", "bucketTime"],
+          sortKeys: ["projectId", "bucketTime"],
           partitionKey: "toYYYYMM(bucketTime)",
           tableEngine: AnalyticsTableEngine.AggregatingMergeTree,
+          ttlExpression: "retentionDate DELETE",
+          includeBaseColumns: false,
+          defaultSortColumn: "bucketTime",
         });
       }
     }
@@ -215,6 +249,133 @@ describe("ClickHouse cluster-aware schema (always-on)", () => {
       expect(fullText(stmt)).toContain("MetricItemAggMV1mLocal");
     });
 
+    test("AggregatingMergeTree CREATE uses real measures without the dimension bypass", () => {
+      const stmt: Statement = aggregatingGen.toTableCreateStatement();
+      expect(stmt.query).toContain("SimpleAggregateFunction(max, DateTime)");
+      expect(stmt.query).toContain("AggregateFunction(sum, Float64)");
+      expect(fullText(stmt)).not.toContain('"_id"');
+      expect(fullText(stmt)).not.toContain('"createdAt"');
+      expect(stmt.query).not.toContain("allow_dimensions_outside_sorting_key");
+    });
+
+    test("all metric aggregate models satisfy the strict off-key measure invariant", () => {
+      const models: Array<AnalyticsBaseModel> = [
+        new MetricItemAggMV1m(),
+        new MetricItemAggMV1mByHostV2(),
+        new MetricItemAggMV1mByService(),
+        new MetricItemAggMV1mByK8sCluster(),
+        new MetricItemAggMV1mByContainer(),
+        new MetricBaselineHourly(),
+      ];
+
+      for (const model of models) {
+        expect(model.tableEngine).toBe(
+          AnalyticsTableEngine.AggregatingMergeTree,
+        );
+        expect(model.getTableColumn("_id")).toBeNull();
+        expect(model.getTableColumn("createdAt")).toBeNull();
+        expect(model.getTableColumn("updatedAt")).toBeNull();
+        expect(model.defaultSortColumn).toBeTruthy();
+        expect(model.sortKeys).toContain(model.defaultSortColumn);
+        expect(model.tableSettings).not.toContain(
+          "allow_dimensions_outside_sorting_key",
+        );
+
+        for (const column of model.tableColumns) {
+          if (model.sortKeys.includes(column.key)) {
+            continue;
+          }
+          expect(
+            column.type === TableColumnType.AggregateFunction ||
+              Boolean(column.simpleAggregateFunction),
+          ).toBe(true);
+        }
+
+        const retentionDate: AnalyticsTableColumn | null =
+          model.getTableColumn("retentionDate");
+        if (retentionDate) {
+          expect(retentionDate.simpleAggregateFunction).toBe("max");
+          expect(model.materializedViews[0]?.query).toContain(
+            "maxSimpleState(retentionDate) AS retentionDate",
+          );
+        }
+      }
+    });
+
+    test("every concrete metric aggregate model generates strict ClickHouse DDL", () => {
+      const modelTypes: Array<AnalyticsBaseModelType> = [
+        MetricItemAggMV1m,
+        MetricItemAggMV1mByHostV2,
+        MetricItemAggMV1mByService,
+        MetricItemAggMV1mByK8sCluster,
+        MetricItemAggMV1mByContainer,
+        MetricBaselineHourly,
+      ];
+
+      for (const modelType of modelTypes) {
+        const model: AnalyticsBaseModel = new modelType();
+        const generator: StatementGenerator<AnalyticsBaseModel> =
+          new StatementGenerator<AnalyticsBaseModel>({
+            modelType,
+            database: ClickhouseAppInstance,
+          });
+        const statement: Statement = generator.toTableCreateStatement();
+        const ddl: string = fullText(statement);
+
+        expect(statement.query).toContain(
+          "ENGINE = ReplicatedAggregatingMergeTree",
+        );
+        expect(ddl).toContain(`${model.tableName}Local`);
+        expect(ddl).not.toContain('"_id"');
+        expect(ddl).not.toContain('"createdAt"');
+        expect(ddl).not.toContain('"updatedAt"');
+        expect(statement.query).not.toContain(
+          "allow_dimensions_outside_sorting_key",
+        );
+
+        if (model.getTableColumn("retentionDate")) {
+          expect(statement.query).toContain(
+            "retentionDate SimpleAggregateFunction(max, DateTime)",
+          );
+          expect(statement.query).toContain("TTL retentionDate DELETE");
+        } else {
+          expect(statement.query).not.toContain("retentionDate");
+        }
+      }
+    });
+
+    test("retention materialized views emit the state type their targets declare", () => {
+      const models: Array<AnalyticsBaseModel> = [
+        new MetricItemAggMV1m(),
+        new MetricItemAggMV1mByHostV2(),
+        new MetricItemAggMV1mByService(),
+        new MetricItemAggMV1mByK8sCluster(),
+        new MetricItemAggMV1mByContainer(),
+      ];
+
+      for (const model of models) {
+        const query: string = model.materializedViews[0]?.query || "";
+        expect(query).toContain(
+          "maxSimpleState(retentionDate) AS retentionDate",
+        );
+        expect(query).not.toContain("max(retentionDate) AS retentionDate");
+        expect(
+          model.getTableColumn("retentionDate")?.simpleAggregateFunction,
+        ).toBe("max");
+      }
+
+      const baseline: MetricBaselineHourly = new MetricBaselineHourly();
+      expect(baseline.getTableColumn("retentionDate")).toBeNull();
+      expect(baseline.materializedViews[0]?.query).not.toContain(
+        "retentionDate",
+      );
+    });
+
+    test("plain MergeTree CREATE does NOT add the aggregating-only setting", () => {
+      const stmt: Statement = spanGen.toTableCreateStatement();
+      expect(stmt.query).not.toContain("allow_dimensions_outside_sorting_key");
+    });
+
     test("Distributed wrapper uses the model sharding key and local table", () => {
       const q: string = spanGen.toDistributedTableCreateStatement().query;
       expect(q).toContain("ON CLUSTER 'oneuptime'");