@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/src/codegen/registry.ts

@@ -39,6 +39,16 @@ const KINDS: Record<string, string> = {
   PostgresCollation: POSTGRES_ENTITY_TYPES.collation,
   PostgresCast: POSTGRES_ENTITY_TYPES.cast,
   PostgresEventTrigger: POSTGRES_ENTITY_TYPES.eventTrigger,
+  PostgresOperator: POSTGRES_ENTITY_TYPES.operator,
+  PostgresOperatorClass: POSTGRES_ENTITY_TYPES.operatorClass,
+  PostgresOperatorFamily: POSTGRES_ENTITY_TYPES.operatorFamily,
+  PostgresForeignTable: POSTGRES_ENTITY_TYPES.foreignTable,
+  PostgresTextSearchConfiguration: POSTGRES_ENTITY_TYPES.textSearchConfiguration,
+  PostgresTextSearchDictionary: POSTGRES_ENTITY_TYPES.textSearchDictionary,
+  PostgresStatistics: POSTGRES_ENTITY_TYPES.statistics,
+  PostgresForeignDataWrapper: POSTGRES_ENTITY_TYPES.foreignDataWrapper,
+  PostgresForeignServer: POSTGRES_ENTITY_TYPES.foreignServer,
+  PostgresPublication: POSTGRES_ENTITY_TYPES.publication,
   PostgresExtension: POSTGRES_ENTITY_TYPES.extension,
   PostgresFunction: POSTGRES_ENTITY_TYPES.function,
   PostgresProcedure: POSTGRES_ENTITY_TYPES.procedure,

package/src/composites/catalog.test.ts

@@ -24,11 +24,13 @@ describe("the sql composite catalog", () => {
       "CdcMirror",
       "EventsTable",
       "JoinTable",
+      "OtelTables",
       "RefreshedView",
       "ReplacingTable",
       "RollupView",
       "ShardedTable",
       "SoftDeleteTable",
+      "StreamIngest",
       "TenantTable",
     ]);
     expect(catalogued, "regenerate with `npm run generate:composite-catalogs -- sql`").toEqual(exported);
@@ -47,11 +49,14 @@ describe("the sql composite catalog", () => {
       ReplacingTable: ["ClickHouseTable"],
       RollupView: ["ClickHouseTable", "ClickHouseView"],
       ShardedTable: ["ClickHouseTable"],
+      OtelTables: ["ClickHouseTable", "ClickHouseView"],
+      StreamIngest: ["ClickHouseTable", "ClickHouseView"],
     });
     for (const entry of compositeCatalog) {
       expect(entry.lexicon, entry.name).toBe("sql");
       expect(entry.description.length, entry.name).toBeGreaterThan(0);
-      expect(entry.params.find((p) => p.name === "name")?.required, entry.name).toBe(true);
+      // OtelTables declares a fixed set of tables, so it takes no name.
+      if (entry.name !== "OtelTables") expect(entry.params.find((p) => p.name === "name")?.required, entry.name).toBe(true);
     }
   });
 

package/src/composites/catalog.ts

@@ -215,6 +215,41 @@ export const compositeCatalog: CompositeEntry[] = [
       }
     ]
   },
+  {
+    "name": "OtelTables",
+    "lexicon": "sql",
+    "description": "The logs, traces and metrics tables the OpenTelemetry Collector's clickhouse exporter writes, as it creates them at v0.130.0.",
+    "bundles": [
+      "ClickHouseTable",
+      "ClickHouseView"
+    ],
+    "params": [
+      {
+        "name": "database",
+        "type": "string",
+        "required": false,
+        "description": "The database the tables are created in, the exporter's `database`."
+      },
+      {
+        "name": "ttl",
+        "type": "string",
+        "required": false,
+        "description": "How long rows are kept, as the exporter's `ttl` takes it: a Go duration such as `72h` or `30m`."
+      },
+      {
+        "name": "tables",
+        "type": "OtelTableNames",
+        "required": false,
+        "description": "Table names other than the exporter's defaults, as set on the exporter."
+      },
+      {
+        "name": "traceIdLookup",
+        "type": "boolean",
+        "required": false,
+        "description": "Declare the trace-id lookup table and its materialized view (default true)."
+      }
+    ]
+  },
   {
     "name": "RefreshedView",
     "lexicon": "sql",
@@ -473,6 +508,71 @@ export const compositeCatalog: CompositeEntry[] = [
       }
     ]
   },
+  {
+    "name": "StreamIngest",
+    "lexicon": "sql",
+    "description": "A stream table, the materialized view that reads it, and the MergeTree target the view writes.",
+    "bundles": [
+      "ClickHouseTable",
+      "ClickHouseView"
+    ],
+    "params": [
+      {
+        "name": "name",
+        "type": "string",
+        "required": true,
+        "description": "The target table's name."
+      },
+      {
+        "name": "columns",
+        "type": "string",
+        "required": true,
+        "description": "The target's columns, as SQL: `ts DateTime, user_id UInt64, kind LowCardinality(String)`."
+      },
+      {
+        "name": "engine",
+        "type": "string",
+        "required": true,
+        "description": "The stream table's engine, with a named collection as its first argument rather than inline credentials: `Kafka(kafka_creds)`, `S3Queue(lake_creds)`."
+      },
+      {
+        "name": "settings",
+        "type": "string",
+        "required": false,
+        "description": "The engine's settings, the body of a `SETTINGS` clause: `kafka_topic_list = 'events', kafka_group_name = 'ingest', kafka_format = 'JSONEachRow'`."
+      },
+      {
+        "name": "streamColumns",
+        "type": "string",
+        "required": false,
+        "description": "The stream table's columns when they differ from the target's: the message as it arrives."
+      },
+      {
+        "name": "select",
+        "type": "string",
+        "required": false,
+        "description": "The view's select list over the stream table, each item aliased to a target column."
+      },
+      {
+        "name": "orderBy",
+        "type": "string",
+        "required": true,
+        "description": "The target's sort key (a column list or an expression)."
+      },
+      {
+        "name": "targetEngine",
+        "type": "string",
+        "required": false,
+        "description": "The target's engine (default `MergeTree`)."
+      },
+      {
+        "name": "partitionBy",
+        "type": "string",
+        "required": false,
+        "description": "The target's partition key."
+      }
+    ]
+  },
   {
     "name": "TenantTable",
     "lexicon": "sql",

package/src/composites/clickhouse.ts

@@ -5,3 +5,5 @@ export { EventsTable, type EventsTableProps, type EventsTableMembers } from "./e
 export { RollupView, type RollupViewProps, type RollupViewMembers } from "./rollup-view";
 export { CdcMirror, type CdcMirrorProps, type CdcMirrorMembers } from "./cdc-mirror";
 export { ShardedTable, type ShardedTableProps, type ShardedTableMembers } from "./sharded-table";
+export { OtelTables, OTEL_EXPORTER_DEFAULT_TABLES, otelTtlClause, type OtelTablesProps, type OtelTablesMembers, type OtelTableNames } from "./otel-tables";
+export { StreamIngest, type StreamIngestProps, type StreamIngestMembers } from "./stream-ingest";

package/src/composites/composites.test.ts

@@ -234,7 +234,7 @@ describe("the composites pass the lexicon's post-synth checks", () => {
     const ids = clickhouse.map((c) => c.id).sort();
     expect(ids[0]).toBe("SQL101");
     expect(ids).toContain("SQLCH101");
-    expect(ids.at(-1)).toBe("SQLCH127");
+    expect(ids.at(-1)).toBe("SQLCH128");
     expect(clickhouse.flatMap((check) => check.check(ctx))).toEqual([]);
   });
 });

package/src/composites/otel-tables.test.ts

@@ -0,0 +1,118 @@
+/**
+ * `OtelTables` (#4397): the tables the OpenTelemetry Collector's clickhouse
+ * exporter writes, as its create statements at contrib v0.130.0 declare them.
+ */
+
+import { describe, expect, test } from "vitest";
+import { expandComposite } from "@intentius/chant/composite";
+import type { Declarable } from "@intentius/chant/declarable";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
+import { CLICKHOUSE_ENTITY_TYPES, type ClickHouseObject, type ClickHouseTable, type TableProps, type ViewProps } from "../clickhouse/entities";
+import { sqlSerializer } from "../serializer";
+import { postSynthChecks } from "../lint/post-synth";
+import { sqlWorkspaceOutputs } from "../workspace-outputs";
+import { OtelTables, otelTtlClause } from "./index";
+
+const props = (e: unknown) => (e as ClickHouseObject & { props: TableProps }).props;
+const columns = (e: unknown) => props(e).columns.map((c) => c.name);
+
+describe("OtelTables", () => {
+  test("defaults: the exporter's seven tables, unqualified, plus the trace-id lookup table and view", () => {
+    const t = OtelTables({});
+    expect(Object.entries(t).map(([k, e]) => [k, (e as Declarable).entityType, props(e).database, props(e).name])).toEqual([
+      ["logs", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_logs"],
+      ["traces", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_traces"],
+      ["metricsGauge", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_metrics_gauge"],
+      ["metricsSum", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_metrics_sum"],
+      ["metricsSummary", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_metrics_summary"],
+      ["metricsHistogram", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_metrics_histogram"],
+      ["metricsExponentialHistogram", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_metrics_exponential_histogram"],
+      ["traceIdTs", CLICKHOUSE_ENTITY_TYPES.table, undefined, "otel_traces_trace_id_ts"],
+      ["traceIdTsView", CLICKHOUSE_ENTITY_TYPES.materializedView, undefined, "otel_traces_trace_id_ts_mv"],
+    ]);
+    expect(props(t.logs).ttl).toBeUndefined();
+    expect(props(t.logs).engine).toEqual({ name: "MergeTree" });
+    expect(props(t.logs).settings).toEqual({ index_granularity: "8192", ttl_only_drop_parts: "1" });
+  });
+
+  test("the columns of the exporter's create statements, in their order", () => {
+    const t = OtelTables({});
+    expect(columns(t.logs)).toEqual([
+      "Timestamp", "TimestampTime", "TraceId", "SpanId", "TraceFlags", "SeverityText", "SeverityNumber", "ServiceName", "Body",
+      "ResourceSchemaUrl", "ResourceAttributes", "ScopeSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "LogAttributes",
+    ]);
+    expect(columns(t.traces)).toEqual([
+      "Timestamp", "TraceId", "SpanId", "ParentSpanId", "TraceState", "SpanName", "SpanKind", "ServiceName", "ResourceAttributes",
+      "ScopeName", "ScopeVersion", "SpanAttributes", "Duration", "StatusCode", "StatusMessage", "Events", "Links",
+    ]);
+    const head = [
+      "ResourceAttributes", "ResourceSchemaUrl", "ScopeName", "ScopeVersion", "ScopeAttributes", "ScopeDroppedAttrCount", "ScopeSchemaUrl",
+      "ServiceName", "MetricName", "MetricDescription", "MetricUnit", "Attributes", "StartTimeUnix", "TimeUnix",
+    ];
+    expect(columns(t.metricsGauge)).toEqual([...head, "Value", "Flags", "Exemplars"]);
+    expect(columns(t.metricsSum)).toEqual([...head, "Value", "Flags", "Exemplars", "AggregationTemporality", "IsMonotonic"]);
+    expect(columns(t.metricsSummary)).toEqual([...head, "Count", "Sum", "ValueAtQuantiles", "Flags"]);
+    expect(columns(t.metricsHistogram)).toEqual([...head, "Count", "Sum", "BucketCounts", "ExplicitBounds", "Exemplars", "Flags", "Min", "Max", "AggregationTemporality"]);
+    expect(columns(t.metricsExponentialHistogram)).toEqual([
+      ...head, "Count", "Sum", "Scale", "ZeroCount", "PositiveOffset", "PositiveBucketCounts", "NegativeOffset", "NegativeBucketCounts",
+      "Exemplars", "Flags", "Min", "Max", "AggregationTemporality",
+    ]);
+    expect(columns(t.traceIdTs)).toEqual(["TraceId", "Start", "End"]);
+    expect(props(t.logs).columns.find((c) => c.name === "Timestamp")?.codec).toBe("Delta(8), ZSTD(1)");
+    expect(props(t.traces).columns.find((c) => c.name === "Events")?.type?.replace(/\s+/g, " ")).toBe(
+      "Nested ( Timestamp DateTime64(9), Name LowCardinality(String), Attributes Map(LowCardinality(String), String) )",
+    );
+    expect(props(t.logs).indexes.map((i) => i.name)).toEqual([
+      "idx_trace_id", "idx_res_attr_key", "idx_res_attr_value", "idx_scope_attr_key", "idx_scope_attr_value", "idx_log_attr_key", "idx_log_attr_value", "idx_body",
+    ]);
+  });
+
+  test("database, ttl and table names reach every member; the view reads the traces table into the lookup table", () => {
+    const t = OtelTables({ database: "otel", ttl: "72h", tables: { traces: "spans", exponentialHistogram: "otel_metrics_exp_histogram" } });
+    expect(props(t.traces)).toMatchObject({ database: "otel", name: "spans", ttl: "toDateTime(Timestamp) + toIntervalDay(3)" });
+    expect(props(t.logs).ttl).toBe("TimestampTime + toIntervalDay(3)");
+    expect(props(t.metricsExponentialHistogram)).toMatchObject({ name: "otel_metrics_exp_histogram", ttl: "toDateTime(TimeUnix) + toIntervalDay(3)" });
+    expect(props(t.traceIdTs)).toMatchObject({ database: "otel", name: "spans_trace_id_ts", ttl: "toDateTime(Start) + toIntervalDay(3)" });
+    const view = (t.traceIdTsView as unknown as { props: ViewProps }).props;
+    expect(view.name).toBe("spans_trace_id_ts_mv");
+    expect(view.to).toBe(t.traceIdTs);
+    expect(view.reads).toEqual([t.traces]);
+  });
+
+  test("traceIdLookup: false leaves out the lookup table and view", () => {
+    const t = OtelTables({ traceIdLookup: false });
+    expect(Object.keys(t)).not.toContain("traceIdTs");
+    expect(Object.keys(t)).not.toContain("traceIdTsView");
+  });
+
+  test("the TTL is rendered as the exporter's GenerateTTLExpr renders it", () => {
+    expect(otelTtlClause(undefined, "t")).toBe("");
+    expect(otelTtlClause("0", "t")).toBe("");
+    expect(otelTtlClause("48h", "t")).toBe("TTL t + toIntervalDay(2)");
+    expect(otelTtlClause("12h", "t")).toBe("TTL t + toIntervalHour(12)");
+    expect(otelTtlClause("1h30m", "t")).toBe("TTL t + toIntervalMinute(90)");
+    expect(otelTtlClause("90s", "t")).toBe("TTL t + toIntervalSecond(90)");
+    expect(() => otelTtlClause("3d", "t")).toThrow(/not a Go duration/);
+  });
+
+  test("passes the lexicon's post-synth checks, and orders the view after both tables", () => {
+    const entities = new Map<string, Declarable>();
+    for (const [k, v] of expandComposite("otel", OtelTables({ database: "otel", ttl: "72h" }))) entities.set(k, v);
+    const out = sqlSerializer.serialize(entities) as SerializerResult;
+    const doc = JSON.parse(out.primary) as { applyOrder: string[] };
+    expect(doc.applyOrder.indexOf("otelTraces")).toBeLessThan(doc.applyOrder.indexOf("otelTraceIdTsView"));
+    expect(doc.applyOrder.indexOf("otelTraceIdTs")).toBeLessThan(doc.applyOrder.indexOf("otelTraceIdTsView"));
+    const ctx = makePostSynthCtx("sql", out.primary, entities);
+    const checks = postSynthChecks.filter((c) => c.id.startsWith("SQLCH") || c.id === "SQL101");
+    expect(checks.flatMap((check) => check.check(ctx))).toEqual([]);
+  });
+
+  test("its tables and columns are workspace outputs another member can link to", () => {
+    const entities = new Map<string, Declarable>();
+    for (const [k, v] of expandComposite("otel", OtelTables({ database: "otel" }))) entities.set(k, v);
+    const names = sqlWorkspaceOutputs(entities)!.outputs.map((o) => o.name);
+    expect(names).toEqual(expect.arrayContaining(["otel.otel_logs", "otel.otel_logs.Body", "otel.otel_traces.Events", "otel.otel_traces_trace_id_ts_mv"]));
+    expect((OtelTables({}).logs as ClickHouseTable).entityType).toBe(CLICKHOUSE_ENTITY_TYPES.table);
+  });
+});

package/src/composites/otel-tables.ts

@@ -0,0 +1,339 @@
+/**
+ * `OtelTables`: the tables the OpenTelemetry Collector's `clickhouse` exporter writes, declared here so the exporter can run with `create_schema: false`.
+ *
+ * The DDL follows the exporter's own create statements at
+ * opentelemetry-collector-contrib v0.130.0, the otel lexicon's
+ * `COLLECTOR_PIN`, column for column:
+ *
+ * - `exporter/clickhouseexporter/internal/sqltemplates/logs_table.sql`
+ * - `exporter/clickhouseexporter/internal/sqltemplates/traces_table.sql`
+ * - `exporter/clickhouseexporter/internal/sqltemplates/traces_id_ts_lookup_table.sql`
+ * - `exporter/clickhouseexporter/internal/sqltemplates/traces_id_ts_lookup_mv.sql`
+ * - `exporter/clickhouseexporter/internal/sqltemplates/metrics_gauge_table.sql`,
+ *   `metrics_sum_table.sql`, `metrics_summary_table.sql`,
+ *   `metrics_histogram_table.sql` and `metrics_exp_histogram_table.sql`
+ *
+ * The table names default to the exporter's (`exporter/clickhouseexporter/config.go`,
+ * `createDefaultConfig`): `otel_logs`, `otel_traces` and `otel_metrics_<type>`.
+ * The exponential histogram table is `otel_metrics_exponential_histogram`:
+ * `defaultExpHistogramSuffix` in config.go is `_exponential_histogram`, though
+ * the README's option list says `otel_metrics_exp_histogram`. The code decides.
+ *
+ * With `create_schema: true` the exporter's traces exporter also creates a
+ * trace-id lookup table, `<traces>_trace_id_ts`, and a materialized view,
+ * `<traces>_trace_id_ts_mv`, that fills it from the traces table
+ * (`createTraceTables` in `exporter_traces.go`). The README's trace query
+ * reads the lookup table to bound a trace's time range. Both are declared
+ * here unless `traceIdLookup` is false.
+ *
+ * What differs from the exporter's DDL, none of it a column:
+ *
+ * - The engine is `MergeTree`, the exporter's default `table_engine`. A
+ *   replicated setup declares its own tables.
+ * - `IF NOT EXISTS` and `ON CLUSTER` are left out; the sql lexicon plans the
+ *   tables instead.
+ * - The metrics templates put `TTL` before `PARTITION BY`; here it follows
+ *   `ORDER BY`, as in the logs and traces templates. ClickHouse reads the
+ *   clauses the same in either order.
+ * - The exporter's JSON tables (`logs_json_table.sql`, `traces_json_table.sql`)
+ *   are used only behind the `clickhouse.json` feature gate (alpha, off by
+ *   default, `factory.go`) and are not declared.
+ *
+ * The database is not declared. Unqualified, the tables are created in the
+ * server's `default` database, which is the exporter's default `database`.
+ */
+
+import { Composite } from "@intentius/chant/composite";
+import { table, view, type ClickHouseTable, type ClickHouseView } from "../clickhouse/entities";
+
+/** The table names the exporter writes, by its config key. Each defaults to the exporter's. */
+export interface OtelTableNames {
+  /** `logs_table_name` (default `otel_logs`). */
+  logs?: string;
+  /** `traces_table_name` (default `otel_traces`). */
+  traces?: string;
+  /** `metrics_tables.gauge.name` (default `otel_metrics_gauge`). */
+  gauge?: string;
+  /** `metrics_tables.sum.name` (default `otel_metrics_sum`). */
+  sum?: string;
+  /** `metrics_tables.summary.name` (default `otel_metrics_summary`). */
+  summary?: string;
+  /** `metrics_tables.histogram.name` (default `otel_metrics_histogram`). */
+  histogram?: string;
+  /** `metrics_tables.exponential_histogram.name` (default `otel_metrics_exponential_histogram`). */
+  exponentialHistogram?: string;
+}
+
+export interface OtelTablesProps {
+  /** The database the tables are created in, the exporter's `database`. Unset, the names are unqualified and land in `default`. */
+  database?: string;
+  /**
+   * How long rows are kept, as the exporter's `ttl` takes it: a Go duration
+   * such as `72h` or `30m`. Rendered the way the exporter renders it
+   * (`GenerateTTLExpr` in `internal/clickhouse.go`): whole days as
+   * `toIntervalDay`, else hours, minutes or seconds. Unset or zero, no TTL.
+   */
+  ttl?: string;
+  /** Table names other than the exporter's defaults, as set on the exporter. */
+  tables?: OtelTableNames;
+  /** Declare the trace-id lookup table and its materialized view (default true). */
+  traceIdLookup?: boolean;
+}
+
+export type OtelTablesMembers = {
+  logs: ClickHouseTable;
+  traces: ClickHouseTable;
+  /** `<traces>_trace_id_ts`, absent when `traceIdLookup` is false. */
+  traceIdTs?: ClickHouseTable;
+  /** `<traces>_trace_id_ts_mv`, absent when `traceIdLookup` is false. */
+  traceIdTsView?: ClickHouseView;
+  metricsGauge: ClickHouseTable;
+  metricsSum: ClickHouseTable;
+  metricsSummary: ClickHouseTable;
+  metricsHistogram: ClickHouseTable;
+  metricsExponentialHistogram: ClickHouseTable;
+};
+
+/** The exporter's default table names at v0.130.0 (`createDefaultConfig` in `config.go`). */
+export const OTEL_EXPORTER_DEFAULT_TABLES: Readonly<Required<OtelTableNames>> = Object.freeze({
+  logs: "otel_logs",
+  traces: "otel_traces",
+  gauge: "otel_metrics_gauge",
+  sum: "otel_metrics_sum",
+  summary: "otel_metrics_summary",
+  histogram: "otel_metrics_histogram",
+  exponentialHistogram: "otel_metrics_exponential_histogram",
+});
+
+const GO_UNITS_S: Record<string, number> = { ns: 1e-9, us: 1e-6, "µs": 1e-6, "μs": 1e-6, ms: 1e-3, s: 1, m: 60, h: 3600 };
+
+/** A Go duration in whole seconds, or an error naming the value. Go's `time.ParseDuration` has no day unit. */
+function goDurationSeconds(d: string): number {
+  const text = d.trim();
+  if (/^0$/.test(text)) return 0;
+  if (!/^((\d+(\.\d*)?|\.\d+)(ns|us|µs|μs|ms|s|m|h))+$/.test(text)) {
+    throw new Error(`OtelTables: ttl ${JSON.stringify(d)} is not a Go duration such as 72h or 30m`);
+  }
+  let total = 0;
+  for (const part of text.matchAll(/(\d+(?:\.\d*)?|\.\d+)(ns|us|µs|μs|ms|s|m|h)/g)) total += Number(part[1]) * GO_UNITS_S[part[2]!]!;
+  return Math.floor(total);
+}
+
+/**
+ * The TTL clause the exporter writes for `ttl` over `timeField`, or "" for none
+ * (`GenerateTTLExpr` in `internal/clickhouse.go` at v0.130.0).
+ */
+export function otelTtlClause(ttl: string | undefined, timeField: string): string {
+  if (ttl === undefined) return "";
+  const s = goDurationSeconds(ttl);
+  if (s <= 0) return "";
+  if (s % 86400 === 0) return `TTL ${timeField} + toIntervalDay(${s / 86400})`;
+  if (s % 3600 === 0) return `TTL ${timeField} + toIntervalHour(${s / 3600})`;
+  if (s % 60 === 0) return `TTL ${timeField} + toIntervalMinute(${s / 60})`;
+  return `TTL ${timeField} + toIntervalSecond(${s})`;
+}
+
+// The column lists of the exporter's create statements, as written there.
+
+const METRIC_HEAD = `
+    ResourceAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+    ResourceSchemaUrl String CODEC(ZSTD(1)),
+    ScopeName String CODEC(ZSTD(1)),
+    ScopeVersion String CODEC(ZSTD(1)),
+    ScopeAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+    ScopeDroppedAttrCount UInt32 CODEC(ZSTD(1)),
+    ScopeSchemaUrl String CODEC(ZSTD(1)),
+    ServiceName LowCardinality(String) CODEC(ZSTD(1)),
+    MetricName String CODEC(ZSTD(1)),
+    MetricDescription String CODEC(ZSTD(1)),
+    MetricUnit String CODEC(ZSTD(1)),
+    Attributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+    StartTimeUnix DateTime64(9) CODEC(Delta, ZSTD(1)),
+    TimeUnix DateTime64(9) CODEC(Delta, ZSTD(1)),`;
+
+const EXEMPLARS = `
+    Exemplars Nested (
+      FilteredAttributes Map(LowCardinality(String), String),
+      TimeUnix DateTime64(9),
+      Value Float64,
+      SpanId String,
+      TraceId String
+    ) CODEC(ZSTD(1)),`;
+
+const METRIC_INDEXES = `
+    INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+    INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+    INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+    INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+    INDEX idx_attr_key mapKeys(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+    INDEX idx_attr_value mapValues(Attributes) TYPE bloom_filter(0.01) GRANULARITY 1`;
+
+/** The columns each metric table adds between the shared head and the indexes. */
+const METRIC_BODIES = {
+  gauge: `
+    Value Float64 CODEC(ZSTD(1)),
+    Flags UInt32 CODEC(ZSTD(1)),${EXEMPLARS}`,
+  sum: `
+    Value Float64 CODEC(ZSTD(1)),
+    Flags UInt32 CODEC(ZSTD(1)),${EXEMPLARS}
+    AggregationTemporality Int32 CODEC(ZSTD(1)),
+    IsMonotonic Boolean CODEC(Delta, ZSTD(1)),`,
+  summary: `
+    Count UInt64 CODEC(Delta, ZSTD(1)),
+    Sum Float64 CODEC(ZSTD(1)),
+    ValueAtQuantiles Nested (
+      Quantile Float64,
+      Value Float64
+    ) CODEC(ZSTD(1)),
+    Flags UInt32 CODEC(ZSTD(1)),`,
+  histogram: `
+    Count UInt64 CODEC(Delta, ZSTD(1)),
+    Sum Float64 CODEC(ZSTD(1)),
+    BucketCounts Array(UInt64) CODEC(ZSTD(1)),
+    ExplicitBounds Array(Float64) CODEC(ZSTD(1)),${EXEMPLARS}
+    Flags UInt32 CODEC(ZSTD(1)),
+    Min Float64 CODEC(ZSTD(1)),
+    Max Float64 CODEC(ZSTD(1)),
+    AggregationTemporality Int32 CODEC(ZSTD(1)),`,
+  exponentialHistogram: `
+    Count UInt64 CODEC(Delta, ZSTD(1)),
+    Sum Float64 CODEC(ZSTD(1)),
+    Scale Int32 CODEC(ZSTD(1)),
+    ZeroCount UInt64 CODEC(ZSTD(1)),
+    PositiveOffset Int32 CODEC(ZSTD(1)),
+    PositiveBucketCounts Array(UInt64) CODEC(ZSTD(1)),
+    NegativeOffset Int32 CODEC(ZSTD(1)),
+    NegativeBucketCounts Array(UInt64) CODEC(ZSTD(1)),${EXEMPLARS}
+    Flags UInt32 CODEC(ZSTD(1)),
+    Min Float64 CODEC(ZSTD(1)),
+    Max Float64 CODEC(ZSTD(1)),
+    AggregationTemporality Int32 CODEC(ZSTD(1)),`,
+} as const;
+
+/** The logs, traces and metrics tables the OpenTelemetry Collector's clickhouse exporter writes, as it creates them at v0.130.0. */
+export const OtelTables = Composite<OtelTablesProps, OtelTablesMembers>((props) => {
+  const names = { ...OTEL_EXPORTER_DEFAULT_TABLES, ...props.tables };
+  const q = (name: string) => (props.database ? `${props.database}.${name}` : name);
+  const ttl = (field: string) => otelTtlClause(props.ttl, field);
+
+  const logs = table`
+    CREATE TABLE ${q(names.logs)} (
+      Timestamp DateTime64(9) CODEC(Delta(8), ZSTD(1)),
+      TimestampTime DateTime DEFAULT toDateTime(Timestamp),
+      TraceId String CODEC(ZSTD(1)),
+      SpanId String CODEC(ZSTD(1)),
+      TraceFlags UInt8,
+      SeverityText LowCardinality(String) CODEC(ZSTD(1)),
+      SeverityNumber UInt8,
+      ServiceName LowCardinality(String) CODEC(ZSTD(1)),
+      Body String CODEC(ZSTD(1)),
+      ResourceSchemaUrl LowCardinality(String) CODEC(ZSTD(1)),
+      ResourceAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+      ScopeSchemaUrl LowCardinality(String) CODEC(ZSTD(1)),
+      ScopeName String CODEC(ZSTD(1)),
+      ScopeVersion LowCardinality(String) CODEC(ZSTD(1)),
+      ScopeAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+      LogAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+      INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1,
+      INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_scope_attr_key mapKeys(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_scope_attr_value mapValues(ScopeAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_log_attr_key mapKeys(LogAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_log_attr_value mapValues(LogAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_body Body TYPE tokenbf_v1(32768, 3, 0) GRANULARITY 8
+    )
+    ENGINE = MergeTree
+    PARTITION BY toDate(TimestampTime)
+    PRIMARY KEY (ServiceName, TimestampTime)
+    ORDER BY (ServiceName, TimestampTime, Timestamp)
+    ${ttl("TimestampTime")}
+    SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1`;
+
+  const traces = table`
+    CREATE TABLE ${q(names.traces)} (
+      Timestamp DateTime64(9) CODEC(Delta, ZSTD(1)),
+      TraceId String CODEC(ZSTD(1)),
+      SpanId String CODEC(ZSTD(1)),
+      ParentSpanId String CODEC(ZSTD(1)),
+      TraceState String CODEC(ZSTD(1)),
+      SpanName LowCardinality(String) CODEC(ZSTD(1)),
+      SpanKind LowCardinality(String) CODEC(ZSTD(1)),
+      ServiceName LowCardinality(String) CODEC(ZSTD(1)),
+      ResourceAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+      ScopeName String CODEC(ZSTD(1)),
+      ScopeVersion String CODEC(ZSTD(1)),
+      SpanAttributes Map(LowCardinality(String), String) CODEC(ZSTD(1)),
+      Duration UInt64 CODEC(ZSTD(1)),
+      StatusCode LowCardinality(String) CODEC(ZSTD(1)),
+      StatusMessage String CODEC(ZSTD(1)),
+      Events Nested (
+        Timestamp DateTime64(9),
+        Name LowCardinality(String),
+        Attributes Map(LowCardinality(String), String)
+      ) CODEC(ZSTD(1)),
+      Links Nested (
+        TraceId String,
+        SpanId String,
+        TraceState String,
+        Attributes Map(LowCardinality(String), String)
+      ) CODEC(ZSTD(1)),
+      INDEX idx_trace_id TraceId TYPE bloom_filter(0.001) GRANULARITY 1,
+      INDEX idx_res_attr_key mapKeys(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_res_attr_value mapValues(ResourceAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_span_attr_key mapKeys(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_span_attr_value mapValues(SpanAttributes) TYPE bloom_filter(0.01) GRANULARITY 1,
+      INDEX idx_duration Duration TYPE minmax GRANULARITY 1
+    )
+    ENGINE = MergeTree
+    PARTITION BY toDate(Timestamp)
+    ORDER BY (ServiceName, SpanName, toDateTime(Timestamp))
+    ${ttl("toDateTime(Timestamp)")}
+    SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1`;
+
+  const metric = (name: string, body: string) => table`
+    CREATE TABLE ${q(name)} (${METRIC_HEAD}${body}${METRIC_INDEXES}
+    )
+    ENGINE = MergeTree
+    PARTITION BY toDate(TimeUnix)
+    ORDER BY (ServiceName, MetricName, Attributes, toUnixTimestamp64Nano(TimeUnix))
+    ${ttl("toDateTime(TimeUnix)")}
+    SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1`;
+
+  const members: OtelTablesMembers = {
+    logs,
+    traces,
+    metricsGauge: metric(names.gauge, METRIC_BODIES.gauge),
+    metricsSum: metric(names.sum, METRIC_BODIES.sum),
+    metricsSummary: metric(names.summary, METRIC_BODIES.summary),
+    metricsHistogram: metric(names.histogram, METRIC_BODIES.histogram),
+    metricsExponentialHistogram: metric(names.exponentialHistogram, METRIC_BODIES.exponentialHistogram),
+  };
+
+  if (props.traceIdLookup !== false) {
+    const traceIdTs = table`
+      CREATE TABLE ${q(`${names.traces}_trace_id_ts`)} (
+        TraceId String CODEC(ZSTD(1)),
+        Start DateTime CODEC(Delta, ZSTD(1)),
+        End DateTime CODEC(Delta, ZSTD(1)),
+        INDEX idx_trace_id TraceId TYPE bloom_filter(0.01) GRANULARITY 1
+      )
+      ENGINE = MergeTree
+      PARTITION BY toDate(Start)
+      ORDER BY (TraceId, Start)
+      ${ttl("toDateTime(Start)")}
+      SETTINGS index_granularity = 8192, ttl_only_drop_parts = 1`;
+    const traceIdTsView = view`
+      CREATE MATERIALIZED VIEW ${q(`${names.traces}_trace_id_ts_mv`)} TO ${traceIdTs} AS
+      SELECT
+        TraceId,
+        min(Timestamp) AS Start,
+        max(Timestamp) AS End
+      FROM ${traces}
+      WHERE TraceId != ''
+      GROUP BY TraceId`;
+    members.traceIdTs = traceIdTs;
+    members.traceIdTsView = traceIdTsView;
+  }
+  return members;
+}, "OtelTables");