@intentius/chant-lexicon-sql 0.124.46 → 0.124.48

package/src/codegen/classifier-page.ts

@@ -10,6 +10,7 @@ const LABEL: Record<string, string> = {
   drop: "drop",
   metadata: "metadata only",
   rewrite: "background rewrite",
+  replace: "replace table",
   rebuild: "rebuild",
 };
 
@@ -22,7 +23,7 @@ export function renderClassifierPage(): string {
   return `---
 title: "Planning ClickHouse Changes"
 label: "Planning and the Change Classifier"
-description: "How a ClickHouse schema change is classified as metadata only, a background rewrite or a rebuild, each with the ALTER restriction behind it"
+description: "How a ClickHouse schema change is classified as metadata only, a background rewrite, a replacement or a rebuild, each with the ALTER restriction behind it"
 diataxis: reference
 group: "ClickHouse"
 order: 1
@@ -36,9 +37,10 @@ Every change between two ClickHouse schemas is classified before anything runs:
 |---|---|
 | metadata only | the server records the change and touches no existing data |
 | background rewrite | a mutation rewrites existing parts in the background, with no rollback |
+| replace table | ClickHouse cannot alter a stream-engine table, and it stores no rows, so the applier drops and creates it around the views that read it |
 | rebuild | ClickHouse cannot make the change to the existing table, and the data has to be copied into a new one; a plan refuses to make it in place |
 
-Two commands report the classification, and \`chant lifecycle plan\` reports it as each update's disruption (metadata only is \`in-place\`, a rewrite \`rolling\`, a rebuild \`replace\`):
+Two commands report the classification, and \`chant lifecycle plan\` reports it as each update's disruption (metadata only is \`in-place\`, a rewrite \`rolling\`, a replacement or a rebuild \`replace\`):
 
 \`\`\`bash
 chant sql diff base.json head.json     # two chant build outputs, offline
@@ -47,13 +49,28 @@ chant sql plan prod schema.json        # a build output against the prod server
 
 Both exit 2 when a change needs a rebuild. \`chant sql diff\` compares a pull request's base and head builds with no server. \`chant sql plan\` reads the server \`sql.profiles.<env>\` binds, and asks that server's formatter about any expression the normalization rules leave different, so the server's own rewriting (\`INTERVAL 1 DAY\` as \`toIntervalDay(1)\`, \`a+b*2\` as \`a + (b * 2)\`) is not reported as a change.
 
-\`chant sql plan\` also exits 2 when a declared database holds an object whose definition it cannot read. It names each one under \`Refused\` (\`unreadable\` in \`--json\`) instead of leaving it out. Dictionaries are read and planned like the other objects: any change but a comment replaces one (SQLCH245).
+\`chant sql plan\` also exits 2 when a declared database holds an object whose definition it cannot read. It names each one under \`Refused\` (\`unreadable\` in \`--json\`) instead of leaving it out. It exits 2 as well when the build names a named collection the server doesn't have, naming each under \`Refused\` (\`namedCollections.missing\` in \`--json\`); see [Named collections](../clickhouse-ddl/#named-collections). Dictionaries are read and planned like the other objects: any change but a comment replaces one (SQLCH245).
 
 A clause chant's parser does not know ([Plain .sql Files](../sql-files/#clauses-chant-does-not-read)) is compared as text, and the rest of its object is planned as usual. A change to one is SQLCH290, refused for review with no rebuild Op suggested, since chant cannot tell what the change takes. A clause only the server prints is a hint, not a change: a newer server printing a clause with its default looks the same as a clause removed from the declaration.
 
+## Stream tables
+
+A table on Kafka, S3Queue, AzureQueue, RabbitMQ, NATS or FileLog stores no rows. It is the consumer that a materialized view reads through, and the position it has reached lives in the broker's committed offsets or in Keeper. There is no \`ALTER\` for its engine arguments, settings or columns, and there is nothing to copy, so a change to one is neither metadata nor a rebuild. It is SQLCH225, in the replace class (\`diffStreamTable\` in \`src/clickhouse/plan/diff.ts\`). The plan refuses nothing for it.
+
+The applier makes the change in place, in this order (\`replaceStreamSteps\` in \`src/clickhouse/apply/statements.ts\`): \`DETACH TABLE\` for each materialized view on the server that reads the table, \`DROP TABLE ... SYNC\`, the declared \`CREATE TABLE\`, then \`ATTACH TABLE\` for the same views. The plan names the views in a hint. Messages wait in the broker, and files wait in the bucket, while the views are detached. A change that moves a table to or from a stream engine is still SQLCH223, a rebuild, and \`ClickHouseRebuildOp\` refuses a stream-engine table by name (\`streamRefusal\` in \`src/clickhouse/rebuild/observe.ts\`).
+
+Two replacements lose the table's position, and the change carries a note saying so (\`positionWarnings\` in \`src/clickhouse/plan/stream.ts\`):
+
+- A different \`kafka_group_name\`, as a setting or as the third engine argument, is a different consumer group. It starts from its own committed offsets, or from the start of the topic when it has none.
+- A different S3Queue \`keeper_path\` is a different record of processed files. Every file already seen is processed again.
+
+An apply killed between the detach and the attach leaves the views detached, and a detached view is not in \`system.tables\`. Nothing re-attaches it: run \`ATTACH TABLE\` for each view by hand, then plan again. This has not been run against a server.
+
+The \`StreamIngest\` composite declares the stream table, the view and the MergeTree target together: see [Composites](../composites/#streamingest).
+
 ## After the plan
 
-The plan only reports. [\`clickhouseApply\`](../applying/) makes the metadata-only and background-rewrite changes, and refuses a rebuild the same way the plan does, sending nothing for that object. A rebuild runs as \`ClickHouseRebuildOp\`, a gated migration Op that creates the new table, backfills it, verifies it and swaps it in: see [Rebuilding a Table](../rebuild/). Both commands print the Op declaration to start from for each refused table.
+The plan only reports. [\`clickhouseApply\`](../applying/) makes the metadata-only, background-rewrite and stream-table changes, and refuses a rebuild the same way the plan does, sending nothing for that object. A rebuild runs as \`ClickHouseRebuildOp\`, a gated migration Op that creates the new table, backfills it, verifies it and swaps it in: see [Rebuilding a Table](../rebuild/). Both commands print the Op declaration to start from for each refused table.
 
 \`chant migrate\` plays no part in any of this. It translates a file from one lexicon's format into another's, such as a GitHub Actions workflow into GitLab CI, and does not run schema migrations.
 

package/src/codegen/clickhouse-module.ts

@@ -269,6 +269,9 @@ export function renderClickHouseModule(catalog: ClickHouseCatalog): RenderedModu
     `/** The table functions (\`system.table_functions\`): \`numbers\`, \`remote\`, \`s3\`. */`,
     `export const TABLE_FUNCTIONS: readonly string[] = ${JSON.stringify(catalog.tableFunctions)};`,
     "",
+    `/** The input and output formats (\`system.formats\`): \`Parquet\`, \`JSONEachRow\`. */`,
+    `export const FORMATS: readonly string[] = ${JSON.stringify(catalog.formats.map((f) => f.name))};`,
+    "",
     `export const SKIP_INDEX_TYPES: Readonly<Record<SkipIndexType, SkipIndexSpec>> = {`,
     ...indexLines,
     "};",

package/src/codegen/coverage-page.ts

@@ -9,7 +9,7 @@ import type { SqlDialect } from "../dialects";
 
 const cell = (s: string) => s.replace(/\|/g, "\\|").replace(/[{}<>]/g, (c) => `\\${c}`);
 
-const STATUS: Record<KindRow["status"], string> = { declared: "declared", refused: "refused", "out-of-scope": "out of scope" };
+const STATUS: Record<KindRow["status"], string> = { declared: "declared", referenced: "referenced", refused: "refused", "out-of-scope": "out of scope" };
 
 function table(dialect: SqlDialect): string {
   const rows = [...KIND_COVERAGE[dialect]].sort((a, b) => (a.command < b.command ? -1 : a.command > b.command ? 1 : 0));
@@ -27,7 +27,8 @@ function table(dialect: SqlDialect): string {
 function counts(dialect: SqlDialect): string {
   const rows = KIND_COVERAGE[dialect];
   const n = (s: KindRow["status"]) => rows.filter((r) => r.status === s).length;
-  return `${n("declared")} declared, ${n("refused")} refused, ${n("out-of-scope")} out of scope`;
+  const referenced = n("referenced") > 0 ? `, ${n("referenced")} referenced` : "";
+  return `${n("declared")} declared${referenced}, ${n("refused")} refused, ${n("out-of-scope")} out of scope`;
 }
 
 export function renderCoveragePage(): string {
@@ -36,7 +37,7 @@ export function renderCoveragePage(): string {
   return `---
 title: "Object Coverage"
 label: "Object Coverage"
-description: "Every kind of object each pinned Postgres and ClickHouse server can create, marked declared, refused with a reason, or out of scope, and what import does with each"
+description: "Every kind of object each pinned Postgres and ClickHouse server can create, marked declared, referenced, refused with a reason, or out of scope, and what import does with each"
 diataxis: reference
 order: 3
 ---
@@ -46,6 +47,7 @@ order: 3
 Each row is a \`CREATE\` command a pinned server has, or one form of a command where chant treats the forms apart (\`CREATE TYPE ... AS ENUM\` is declared, \`CREATE TYPE ... AS RANGE\` is not). The commands come from the servers' own sources at each pinned version (\`scripts/sql-create-commands.ts\`), and a test fails when a pinned server has a command with no row here, so a new server release cannot add a kind nobody looked at.
 
 - **declared**: a tag declares it, and import writes it as that declaration.
+- **referenced**: the environment's, and never declared: a declaration names one, and chant never reads its values. A ClickHouse named collection is one ([#4395](https://github.com/INTENTIUS/chant/issues/4395)): \`ENGINE = S3(lake_creds, format = 'Parquet')\` names \`lake_creds\`, the build records the name, and \`chant sql plan\` fails when the server has no collection of that name. \`chant import --from <env>\` lists the server's SQL-defined collections as prerequisites and imports the rest. See [Named collections](../clickhouse-ddl/#named-collections).
 - **refused**: no declaration holds it yet. \`chant import --from <env>\` fails when the server has one, naming every such object (kind, schema, name) at once, and \`chant import schema.sql\` fails on the statement. Nothing is left out without a word.
 - **out of scope**: the environment's, not a schema's: import never reads it.
 

package/src/codegen/docs.ts

@@ -122,7 +122,7 @@ Postgres:
 - [Getting Started with Postgres](./postgres-getting-started/): declare a
   schema, apply it to a local server, add a column and an index, and see a
   rename refused.
-- [Declaring Postgres Objects](./postgres-ddl/): the eight tags,
+- [Declaring Postgres Objects](./postgres-ddl/): the tags for every schema-level kind,
   constraints, \`nextval(\${seq})\`, \`COMMENT ON\` and \`literal()\`.
 - [Importing a Postgres Server](./postgres-importing/): canonical text from
   the catalog's printers, and the objects that belong to someone else.

package/src/codegen/postgres-classifier-page.ts

@@ -72,7 +72,7 @@ Two rules change class across the supported majors: a STORED generated column's
 
 ## Identity and renames
 
-An object is identified by its export name between two builds, and by its schema-qualified name against a server, which has no export names. Tables, views, materialized views, sequences and indexes share one namespace per schema, types and domains another, and schemas and extensions are matched by name. Functions, procedures and aggregates share a namespace of their own and are told apart by their input parameter types, so an overload is another object; composite and range types share the types' namespace, collations have one of their own, a cast is named by its two types and an event trigger by its name in the database; a trigger is matched by its name on its table.
+An object is identified by its export name between two builds, and by its schema-qualified name against a server, which has no export names. Tables, views, materialized views, sequences and indexes share one namespace per schema, types and domains another, and schemas and extensions are matched by name. Functions, procedures and aggregates share a namespace of their own and are told apart by their input parameter types, so an overload is another object; composite and range types share the types' namespace, collations have one of their own, extended statistics another, an operator by its symbol and operand types, a cast by its two types and an event trigger, a foreign data wrapper, a foreign server and a publication by their names in the database; a trigger is matched by its name on its table.
 
 A rename is declared where it happens. Before a CREATE, \`-- previously: <old name>\` says the object had another name; on a column's line, it says the column did:
 

package/src/codegen/registry.ts

@@ -39,6 +39,11 @@ 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,
+  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);
+  });
+});