@intentius/chant-lexicon-sql 0.124.12 → 0.124.14

package/src/read.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from "vitest";
+import { makePostSynthCtx } from "@intentius/chant-test-utils";
+import type { PostSynthCheck, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { sqlSerializer } from "./serializer";
+import { database, table as chTable, view as chView } from "./clickhouse/entities";
+import { index, schema, table, view } from "./postgres/entities";
+import { canonicalPostgresType, readClickHouse, readPostgres, readSql } from "./read";
+import { readPostgres as fromPostgresSubpath } from "./postgres";
+import { readClickHouse as fromClickHouseSubpath } from "./clickhouse";
+import { tablesOf as pgTablesOf } from "./lint/post-synth/postgres-helpers";
+import { tablesOf as chTablesOf } from "./lint/post-synth/clickhouse-helpers";
+
+const ctxOf = (entities: Record<string, unknown>) => {
+  const out = sqlSerializer.serialize(new Map(Object.entries(entities)) as never) as SerializerResult;
+  return makePostSynthCtx("sql", out.primary);
+};
+
+describe("readPostgres (#3870)", () => {
+  const app = schema`CREATE SCHEMA app`;
+  const users = table`
+    CREATE TABLE ${app}.users (
+      id bigserial PRIMARY KEY,
+      email text NOT NULL UNIQUE,
+      nickname varchar(40) DEFAULT 'anon',
+      tags text[],
+      created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now()
+    )`;
+  const orders = table`
+    CREATE TABLE ${app}.orders (
+      id bigint GENERATED ALWAYS AS IDENTITY,
+      user_id bigint NOT NULL REFERENCES ${users} (id),
+      created_at timestamp,
+      PRIMARY KEY (id)
+    )`;
+  const ordersUser = index`CREATE INDEX orders_user_id ON ${orders} (user_id, (lower('x')))`;
+  const totals = view`CREATE VIEW ${app}.totals AS SELECT user_id, count(*) AS n FROM ${orders} GROUP BY user_id`;
+  const ctx = ctxOf({ app, users, orders, ordersUser, totals });
+
+  test("tables carry typed columns: canonical type, nullability, default, keys", () => {
+    const db = readPostgres(ctx);
+    expect(db.dialect).toBe("postgres");
+    expect(db.tables.map((t) => t.qualifiedName).sort()).toEqual(["app.orders", "app.users"]);
+    const u = db.table("users")!;
+    expect(u.column("id")).toMatchObject({ typeName: "bigint", nullable: false, inPrimaryKey: true });
+    expect(u.column("email")).toMatchObject({ typeName: "text", nullable: false, inPrimaryKey: false });
+    expect(u.column("nickname")).toMatchObject({ typeName: "character varying", nullable: true, default: "'anon'" });
+    expect(u.column("tags")).toMatchObject({ typeName: "text", array: true });
+    expect(u.column("created_at")).toMatchObject({ typeName: "timestamp with time zone", nullable: false, default: "now()" });
+    expect(u.uniques[0]!.columns).toEqual(["email"]);
+    expect(db.table("app.orders")!.column("id")).toMatchObject({ nullable: false, inPrimaryKey: true });
+    expect(db.table("orders")!.column("created_at")).toMatchObject({ typeName: "timestamp without time zone", nullable: true });
+    expect(db.table("orders")!.foreignKeys[0]).toMatchObject({ columns: ["user_id"], references: "users" });
+  });
+
+  test("indexes belong to their table and lead with their bare columns", () => {
+    const db = readPostgres(ctx);
+    expect(db.indexes).toHaveLength(1);
+    expect(db.indexes[0]).toMatchObject({ export: "ordersUser", table: "orders", columns: ["user_id"] });
+    expect(db.table("orders")!.indexes.map((i) => i.export)).toEqual(["ordersUser"]);
+  });
+
+  test("views name their outputs and keep their lineage", () => {
+    const v = readPostgres(ctx).views[0]!;
+    expect(v).toMatchObject({ qualifiedName: "app.totals", materialized: false, outputs: ["user_id", "n"] });
+    expect(v.lineage.map((e) => e.output)).toEqual(["user_id", "n"]);
+  });
+
+  test("canonicalPostgresType spells aliases the way typeName does", () => {
+    expect(canonicalPostgresType("timestamptz")).toBe("timestamp with time zone");
+    expect(canonicalPostgresType("INT4")).toBe("integer");
+    expect(canonicalPostgresType("varchar(10)")).toBe("character varying");
+  });
+
+  test("the checks read the same values, and the dialect subpath exports the same reader", () => {
+    expect(pgTablesOf(ctx)).toBe(readPostgres(ctx).tables);
+    expect(fromPostgresSubpath).toBe(readPostgres);
+    expect(readClickHouse(ctx).tables).toEqual([]);
+    expect(readSql(ctx)?.dialect).toBe("postgres");
+  });
+
+  test("reads a serialized document as well as a context", () => {
+    const doc = JSON.parse((sqlSerializer.serialize(new Map(Object.entries({ app, users })) as never) as SerializerResult).primary) as { dialect: string; objects: unknown[] };
+    expect(readPostgres(doc).table("users")!.column("email")!.nullable).toBe(false);
+    expect(readSql(doc as never)?.dialect).toBe("postgres");
+  });
+
+  test("a project policy written against the read API flags a table without created_at timestamptz NOT NULL", () => {
+    const TIMESTAMPTZ = canonicalPostgresType("timestamptz");
+    const policy: PostSynthCheck = {
+      id: "ORG-CREATED-AT",
+      description: "every table has created_at timestamptz NOT NULL",
+      check(c): PostSynthDiagnostic[] {
+        return readPostgres(c)
+          .tables.filter((t) => {
+            const col = t.column("created_at");
+            return !col || col.typeName !== TIMESTAMPTZ || col.nullable;
+          })
+          .map((t) => ({ checkId: "ORG-CREATED-AT", severity: "error", entity: t.export, message: `${t.qualifiedName} needs created_at timestamptz NOT NULL` }));
+      },
+    };
+    expect(policy.check(ctx).map((d) => d.entity)).toEqual(["orders"]);
+  });
+});
+
+describe("readClickHouse (#3870)", () => {
+  const shop = database`CREATE DATABASE shop ENGINE = Atomic`;
+  const events = chTable`
+    CREATE TABLE ${shop}.events (
+      ts DateTime64(3) CODEC(Delta, ZSTD),
+      kind LowCardinality(String),
+      user_id UInt64,
+      ref Nullable(String) COMMENT 'referrer',
+      label LowCardinality(Nullable(String)) DEFAULT 'x',
+      INDEX kind_idx kind TYPE set(100) GRANULARITY 4
+    )
+    ENGINE = ReplicatedReplacingMergeTree('/ch/{shard}/events', '{replica}', ts)
+    ORDER BY (kind, toDate(ts), user_id)`;
+  const daily = chView`CREATE VIEW ${shop}.daily AS SELECT toDate(ts) AS day, count() AS n FROM ${events} GROUP BY day`;
+  const ctx = ctxOf({ shop, events, daily });
+
+  test("tables carry typed columns, the engine family and the keys", () => {
+    const db = readClickHouse(ctx);
+    const t = db.table("shop.events")!;
+    expect(t).toMatchObject({ qualifiedName: "shop.events", engineFamily: "ReplacingMergeTree", mergeTree: true });
+    expect(t.sortKey).toEqual(["kind", "toDate(ts)", "user_id"]);
+    expect(t.primaryKeyElements).toEqual(t.sortKey);
+    expect(t.column("ts")).toMatchObject({ family: "DateTime64", nullable: false, inSortKey: false, codec: "Delta, ZSTD" });
+    expect(t.column("kind")).toMatchObject({ lowCardinality: true, baseType: "String", nullable: false, inSortKey: true });
+    expect(t.column("ref")).toMatchObject({ nullable: true, comment: "referrer" });
+    expect(t.column("label")).toMatchObject({ nullable: true, lowCardinality: true, default: { kind: "DEFAULT", expr: "'x'" } });
+    expect(t.indexes[0]).toMatchObject({ name: "kind_idx", type: "set(100)" });
+  });
+
+  test("views name their outputs; the checks and the subpath share the reader", () => {
+    const v = readClickHouse(ctx).views[0]!;
+    expect(v).toMatchObject({ materialized: false, outputs: ["day", "n"] });
+    expect(chTablesOf(ctx)).toBe(readClickHouse(ctx).tables);
+    expect(fromClickHouseSubpath).toBe(readClickHouse);
+    expect(readSql(ctx)?.dialect).toBe("clickhouse");
+    expect(readPostgres(ctx).tables).toEqual([]);
+  });
+});

package/src/read.ts

@@ -0,0 +1,69 @@
+/**
+ * `@intentius/chant-lexicon-sql/read`: a typed, read-only view of the SQL
+ * objects a build declares (#3870), for a project's own `lint.policies`.
+ *
+ * A policy's `check(ctx)` gets the build's parsed output in `ctx.docs`.
+ * {@link readPostgres} and {@link readClickHouse} turn the sql lexicon's part
+ * of it into tables with typed columns (SQL type, nullability, default,
+ * comment), keys, indexes and engines, and views with their outputs and
+ * column lineage. The lexicon's own post-synth checks read the same values,
+ * so a project rule sees exactly what `SQLPG101` or `SQLCH113` sees.
+ *
+ * ```ts
+ * import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+ * import { canonicalPostgresType, readPostgres } from "@intentius/chant-lexicon-sql/read";
+ *
+ * const TIMESTAMPTZ = canonicalPostgresType("timestamptz");
+ *
+ * export const createdAt: PostSynthCheck = {
+ *   id: "ORG-CREATED-AT",
+ *   description: "every table has created_at timestamptz NOT NULL",
+ *   check(ctx) {
+ *     return readPostgres(ctx).tables
+ *       .filter((t) => { const c = t.column("created_at"); return !c || c.typeName !== TIMESTAMPTZ || c.nullable; })
+ *       .map((t) => ({ checkId: "ORG-CREATED-AT", severity: "error", entity: t.export,
+ *                      message: `${t.qualifiedName} needs created_at timestamptz NOT NULL` }));
+ *   },
+ * };
+ * ```
+ *
+ * Every value keeps the fields the serializer writes (see the Serialization
+ * page) and adds the derived ones documented on each type. The reads also take
+ * the serialized document itself (`{ dialect, objects }`), for a tool that
+ * holds a recorded build rather than a post-synth context.
+ */
+
+export { readPostgres, canonicalPostgresType } from "./read/postgres";
+export type { PostgresRead, PostgresTableInfo, PostgresColumnInfo, PostgresIndexInfo, PostgresViewInfo } from "./read/postgres";
+export { readClickHouse } from "./read/clickhouse";
+export type { ClickHouseRead, ClickHouseTableInfo, ClickHouseColumnInfo, ClickHouseViewInfo } from "./read/clickhouse";
+export { sqlDocuments, isSqlOutputDocument } from "./read/objects";
+export type {
+  SqlReadSource,
+  SqlOutputDocument,
+  SqlObjectBase,
+  SqlObjectJson,
+  RefJson,
+  LineageJson,
+  PostgresTableJson,
+  PostgresIndexJson,
+  PostgresViewJson,
+  PostgresForeignKeyJson,
+  ClickHouseTableJson,
+  ClickHouseViewJson,
+} from "./read/objects";
+
+import { readClickHouse, type ClickHouseRead } from "./read/clickhouse";
+import { readPostgres, type PostgresRead } from "./read/postgres";
+import { sqlDocuments, type SqlOutputDocument, type SqlReadSource } from "./read/objects";
+
+/**
+ * The build's SQL objects in whichever dialect it declares: one build holds
+ * one dialect. Undefined when the build has no sql output.
+ */
+export function readSql(source: SqlReadSource | SqlOutputDocument): PostgresRead | ClickHouseRead | undefined {
+  const dialect = "objects" in source ? source.dialect : sqlDocuments(source)[0]?.dialect;
+  if (dialect === "postgres") return readPostgres(source);
+  if (dialect === "clickhouse") return readClickHouse(source);
+  return undefined;
+}

package/src/serializer.ts

@@ -25,6 +25,9 @@
  * targets (`sql.postgresMajor`, else the newest pinned major). Post-synth
  * checks and the lock classifier read it; ClickHouse output has no such field.
  *
+ * A clause chant's parser does not know (#3872) is kept in the statement as
+ * written and named in a build warning ({@link unparsedWarnings}).
+ *
  * Rule ids: `SQL` for rules that hold in every dialect, `SQLCH` for the
  * ClickHouse dialect's (#3199), `SQLPG` for Postgres's (#3289).
  */
@@ -36,10 +39,39 @@ import { isClickHouseObject, type ClickHouseObject } from "./clickhouse/entities
 import { isPostgresObject, type PostgresObject } from "./postgres/entities";
 import { POSTGRES_LATEST_MAJOR } from "./spec/postgres-pin";
 import { applyOrder, lineageJson, referenceName, type LineageEdge } from "./core/references";
-import { sqlFileReferences } from "./sql-files";
+import { sqlFileLineOf, sqlFileOf, sqlFileReferences } from "./sql-files";
+import { relative } from "node:path";
+import { getProvenance } from "@intentius/chant/provenance";
+import type { UnparsedClause } from "./core/interpolation";
 
 export { applyOrder } from "./core/references";
 
+/**
+ * A warning for each clause chant's parser does not know (#3872): where it
+ * is (the `.sql` file and line, or the template's file and the line in its
+ * statement), which object, and what follows from it. The statement is sent
+ * as written; the server decides.
+ */
+export function unparsedWarnings(objects: ReadonlyMap<string, Declarable>): string[] {
+  const out: string[] = [];
+  for (const [name, entity] of objects) {
+    const unparsed = (entity as unknown as { props?: { unparsed?: UnparsedClause[] } }).props?.unparsed;
+    if (!unparsed || unparsed.length === 0) continue;
+    const file = sqlFileOf(entity);
+    const start = sqlFileLineOf(entity);
+    const source = getProvenance(entity)?.sourceFile;
+    for (const u of unparsed) {
+      const where = file !== undefined ? `${file}:${start !== undefined ? start + u.line - 1 : u.line}` : `${source ? relative(process.cwd(), source) : "?"}: ${name}, line ${u.line} of its statement`;
+      const on = u.column !== undefined ? ` on column ${u.column}` : "";
+      out.push(
+        `${where}: ${(entity as { sqlName?: string }).sqlName ?? name} has a clause chant does not read, ${u.clause}${on}. ` +
+          "It is sent as written and the server checks it; a plan reads the rest of the object, and classes any change to the clause as one to review",
+      );
+    }
+  }
+  return out;
+}
+
 /** The file the statements are written to, beside the primary output. */
 export const CLICKHOUSE_DDL_FILE = "clickhouse.sql";
 
@@ -104,10 +136,12 @@ function serializePostgres(
     objects: order.map((n) => postgresObjectJson(n, objects.get(n)!, names, extra.get(n))),
   };
   const ddl = order.map((n) => `${(objects.get(n)!.props as { ddl: string }).ddl};`).join("\n\n");
+  const warnings = unparsedWarnings(objects);
   return {
     primary: `${JSON.stringify(doc, null, 2)}\n`,
     files: { [POSTGRES_DDL_FILE]: `${ddl}\n` },
     verbatimFiles: [POSTGRES_DDL_FILE],
+    ...(warnings.length > 0 ? { warnings } : {}),
   };
 }
 
@@ -144,10 +178,12 @@ export const sqlSerializer: Serializer = {
     const ddl = order
       .map((n) => `${(objects.get(n)!.props as { ddl: string }).ddl};`)
       .join("\n\n");
+    const warnings = unparsedWarnings(objects);
     return {
       primary: `${JSON.stringify(doc, null, 2)}\n`,
       files: { [CLICKHOUSE_DDL_FILE]: `${ddl}\n` },
       verbatimFiles: [CLICKHOUSE_DDL_FILE],
+      ...(warnings.length > 0 ? { warnings } : {}),
     };
   },
 };

package/src/sql-files.ts

@@ -18,7 +18,9 @@
  * `MATERIALIZED VIEW`, `DICTIONARY`, `FUNCTION`, `USER`, `ROLE` and `ROW
  * POLICY`, and `GRANT` (#3711). Any other statement, and any
  * statement that does not parse, throws a {@link SqlFileError} naming every
- * such statement: none is left out.
+ * such statement: none is left out. A statement that parses except for a
+ * clause the parser does not know (#3872) is read, kept as written, and the
+ * clause listed in its object's `unparsed` with the line it is on.
  *
  * A name is a reference where it is qualified (`app.users`), or bare where an
  * object is named (`REFERENCES users`, `FROM users`, an index's table, a
@@ -27,7 +29,7 @@
 
 import type { Declarable } from "@intentius/chant/declarable";
 import type { SqlDialect } from "./dialects";
-import { SqlFileError, type ReadOptions } from "./files/common";
+import { SqlFileError, type FileLine, type ReadOptions } from "./files/common";
 import { postgresTag, readPostgres, templateStrings } from "./files/postgres";
 import { clickhouseTag, readClickHouse } from "./files/clickhouse";
 import { exportNames as pgExportNames, objectsToIR as pgObjectsToIR, type ImportedPgObject } from "./postgres/import/ir";
@@ -52,6 +54,14 @@ export interface SqlFileObject {
   ddl: string;
   /** The file it came from, the `origin` it was read under. */
   origin: string;
+  /** The line its statement starts on in the file, from 1. */
+  line?: number;
+  /**
+   * Clauses in it chant's parser does not know (#3872), each with the line
+   * it starts on: kept in `ddl` as written, for the server to check. Absent
+   * when there are none.
+   */
+  unparsed?: Array<{ clause: string; line: number; column?: string }>;
 }
 
 /** A file to read: its DDL and the name errors give it. */
@@ -64,8 +74,8 @@ type Imported = ImportedPgObject | ImportedObject;
 const qualifierOf = (o: Imported): string | undefined => ("schema" in o ? o.schema : "database" in o ? o.database : undefined);
 const qualifiedName = (o: Imported): string => (qualifierOf(o) ? `${qualifierOf(o)}.${o.name}` : o.name);
 
-function readObjects(dialect: SqlDialect, sources: readonly SqlFileSource[]): Array<Imported & { origin: string }> {
-  const out: Array<Imported & { origin: string }> = [];
+function readObjects(dialect: SqlDialect, sources: readonly SqlFileSource[]): Array<Imported & FileLine & { origin: string }> {
+  const out: Array<Imported & FileLine & { origin: string }> = [];
   for (const source of sources) {
     const problems: string[] = [];
     const objects = dialect === "postgres" ? readPostgres(source.ddl, source, problems) : readClickHouse(source.ddl, source, problems);
@@ -75,6 +85,9 @@ function readObjects(dialect: SqlDialect, sources: readonly SqlFileSource[]): Ar
   return out;
 }
 
+/** An object's line and unknown clauses, the fields that are set. */
+const fileMeta = (o: FileLine): FileLine => ({ ...(o.line !== undefined ? { line: o.line } : {}), ...(o.unparsed ? { unparsed: o.unparsed } : {}) });
+
 /** Export names for objects read from files, unique across them. */
 function namesFor(dialect: SqlDialect, objects: readonly Imported[]): string[] {
   return dialect === "postgres" ? pgExportNames(objects as ImportedPgObject[]) : chExportNames(objects as ImportedObject[]);
@@ -84,7 +97,7 @@ function namesFor(dialect: SqlDialect, objects: readonly Imported[]): string[] {
 export function readSqlFile(dialect: SqlDialect, ddl: string, options: ReadOptions): SqlFileObject[] {
   const objects = readObjects(dialect, [{ ...options, ddl }]);
   const names = namesFor(dialect, objects);
-  return objects.map((o, i) => ({ export: names[i]!, type: o.type, name: qualifiedName(o), ddl: o.ddl, origin: o.origin }));
+  return objects.map((o, i) => ({ export: names[i]!, type: o.type, name: qualifiedName(o), ddl: o.ddl, origin: o.origin, ...fileMeta(o) }));
 }
 
 /**
@@ -100,7 +113,7 @@ export function sqlFileDeclarations(dialect: SqlDialect, ddl: string, options: R
   if (!file) throw new SqlFileError(options.origin, ["the DDL creates no objects"]);
   return {
     content: file.content,
-    objects: ir.resources.map((r, i) => ({ export: r.logicalId, type: r.type, name: qualifiedName(objects[i]!), ddl: objects[i]!.ddl, origin: options.origin })),
+    objects: ir.resources.map((r, i) => ({ export: r.logicalId, type: r.type, name: qualifiedName(objects[i]!), ddl: objects[i]!.ddl, origin: options.origin, ...fileMeta(objects[i]!) })),
   };
 }
 
@@ -109,7 +122,13 @@ export function sqlFileOf(entity: unknown): string | undefined {
   return typeof entity === "object" && entity !== null ? ((entity as Record<symbol, unknown>)[FROM_FILE] as string | undefined) : undefined;
 }
 
+/** The line an entity read from a `.sql` file starts on in it. Undefined for any other entity. */
+export function sqlFileLineOf(entity: unknown): number | undefined {
+  return typeof entity === "object" && entity !== null ? ((entity as Record<symbol, unknown>)[FROM_LINE] as number | undefined) : undefined;
+}
+
 const FROM_FILE = Symbol.for("chant.sql.fromFile");
+const FROM_LINE = Symbol.for("chant.sql.fromLine");
 
 /** A declared entity as a template target: its export, type and name. */
 function targetOf(dialect: SqlDialect, exportName: string, entity: Declarable): PgTemplateItem | undefined {
@@ -150,6 +169,7 @@ export function sqlFileEntities(dialect: SqlDialect, sources: readonly SqlFileSo
 
   const items: PgTemplateItem[] = objects.map((o, i) => ({ exportName: names[i]!, type: o.type, ...("schema" in o && o.schema ? { schema: o.schema } : {}), ...("database" in o && o.database ? { database: o.database } : {}), name: o.name, ddl: o.ddl }) as PgTemplateItem);
   const origin = new Map(objects.map((o, i) => [names[i]!, o.origin]));
+  const lineOf = new Map(objects.map((o, i) => [names[i]!, o.line]));
   const knownItems = [...known].map(([n, e]) => targetOf(dialect, n, e)).filter((t): t is PgTemplateItem => t !== undefined);
   const declared = new Map(knownItems.map((t) => [`${t.type} ${qualifiedName(t as Imported)}`, t.exportName]));
   const seen = new Map<string, string>();
@@ -186,6 +206,7 @@ export function sqlFileEntities(dialect: SqlDialect, sources: readonly SqlFileSo
     try {
       const entity = tagOf(it.type)!(templateStrings(body.parts), ...values);
       Object.defineProperty(entity, FROM_FILE, { value: origin.get(it.exportName), enumerable: false });
+      if (lineOf.get(it.exportName) !== undefined) Object.defineProperty(entity, FROM_LINE, { value: lineOf.get(it.exportName), enumerable: false });
       built.set(it.exportName, entity);
     } catch (e) {
       failed.add(it.exportName);

package/src/sql-types.ts

@@ -22,6 +22,9 @@
  *   (`./lint/post-synth/postgres-names.ts`'s `typeIdentity`), the type
  *   family in ClickHouse; `never` when it cannot be told.
  *
+ * A column that carries a clause chant does not read (#3872) keeps the type
+ * that was read, with `nullable` and `cmp` `never`.
+ *
  * A view's column that is one column reference (`${t.columns.c}`, `o.${t.columns.c}`)
  * is that column's type; any other expression is `unknown`.
  */
@@ -108,6 +111,17 @@ interface RelationEntry {
 
 const UNKNOWN_COLUMN = (name: string): ColumnEntry => ({ name, sqlType: "unknown", ts: "unknown", nullable: "never" });
 
+/** The columns that carry a clause chant does not read (#3872). */
+const opaqueColumns = (o: OutputObject): Set<string> =>
+  new Set(((o.unparsed as Array<{ column?: string }> | undefined) ?? []).flatMap((u) => (u.column !== undefined ? [u.column] : [])));
+
+/**
+ * A column with a clause chant does not read (#3872): its type is what was
+ * read, but whether it can be NULL and how it compares in a key are not
+ * told, so it fits every slot rather than a guessed one.
+ */
+const opaque = (c: ColumnEntry): ColumnEntry => ({ name: c.name, sqlType: c.sqlType, ts: c.ts, nullable: "never" });
+
 const posix = (p: string) => p.split(sep).join("/");
 
 /** Where a declaration came from: its file relative to the project, and its export. */
@@ -215,13 +229,15 @@ function postgresEntries(objects: OutputObject[], major: number, entities: Reado
         for (const c of pt?.columns ?? []) if (!inherited.has(c.name)) inherited.set(c.name, c.type);
       }
       const pk = new Set(t.primaryKey?.columns ?? []);
+      const unread = opaqueColumns(o);
       columns = names.map((name) => {
         const c = own.get(name);
         const text = c?.type ?? inherited.get(name);
         if (text === undefined) return UNKNOWN_COLUMN(name);
         const ty = pgType(p, text);
         const notNull = c?.notNull === true || pk.has(name) || c?.generated?.kind === "identity" || ty.notNull;
-        return { name, sqlType: ty.sqlType, ts: ty.ts, nullable: !notNull, cmp: typeIdentity(p, text) };
+        const entry: ColumnEntry = { name, sqlType: ty.sqlType, ts: ty.ts, nullable: !notNull, cmp: typeIdentity(p, text) };
+        return unread.has(name) ? opaque(entry) : entry;
       });
     } else {
       columns = names.map((name) => {
@@ -265,9 +281,10 @@ function clickhouseEntries(objects: OutputObject[], entities: ReadonlyMap<string
     const entity = entities.get(exportName);
     if (!o || !entity || !CH_RELATIONS.has(o.type)) return undefined;
     const declared = new Map(((o.columns as Array<{ name: string; type?: string; nullable?: boolean }> | undefined) ?? []).map((c) => [c.name, c]));
+    const unread = opaqueColumns(o);
     const columns = runtimeColumns(entity).map((name) => {
       const c = declared.get(name);
-      if (c) return chColumn(name, c.type, c.nullable);
+      if (c) return unread.has(name) ? opaque(chColumn(name, c.type, c.nullable)) : chColumn(name, c.type, c.nullable);
       const via = passthrough(o, name, quoteIdentifier);
       const source = via && entryOf(via.export)?.columns.find((x) => x.name === via.column);
       return source ? { ...source, name } : UNKNOWN_COLUMN(name);