@intentius/chant-lexicon-sql 0.124.12 → 0.124.13

package/src/core/cursor.ts

@@ -33,10 +33,56 @@ export const unquoteWith = (text: string, quotes: string): string => {
   return inner;
 };
 
+/**
+ * A clause the parser does not know, kept as written (#3872): a server
+ * release can add a clause before chant's parser reads it, and the statement
+ * still goes to the server as the author wrote it. What chant reads around it
+ * is read; the clause itself is opaque.
+ */
+export interface UnknownClause {
+  /** Its leading words, upper case, as a message names it: `TABLESPACE_POLICY`. */
+  clause: string;
+  /** The whole clause, from its first word to where a clause the parser knows starts. */
+  span: Span;
+  /** The column (or dictionary attribute) the clause is written on, when it is one of a column's. */
+  column?: string;
+}
+
+/** Edit distance with a swap of two neighbours as one edit, for telling a misspelt clause from a new one. */
+function distance(a: string, b: string): number {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => Array.from({ length: b.length + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const row = d[i]!;
+      row[j] = Math.min(d[i - 1]![j]! + 1, row[j - 1]! + 1, d[i - 1]![j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1));
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) row[j] = Math.min(row[j]!, d[i - 2]![j - 2]! + 1);
+    }
+  }
+  return d[a.length]![b.length]!;
+}
+
+/**
+ * The known clause word `word` is a misspelling of, if any: one edit from a
+ * known word of four letters or more (two neighbouring letters swapped is
+ * one), two from one of seven or more. A word
+ * that close is taken as a typo, which fails, not as a new clause, which warns.
+ */
+export function misspelling(word: string, known: readonly string[]): string | undefined {
+  const w = word.toUpperCase();
+  for (const k of known) {
+    if (k.length < 4 || k === w) continue;
+    const d = distance(w, k);
+    if (d === 1 || (d === 2 && k.length >= 7 && w.length >= 7)) return k;
+  }
+  return undefined;
+}
+
 export class SqlCursor {
   /** Indexes of the significant (non-trivia) tokens. */
   protected readonly sig: number[];
   protected p = 0;
+  /** The clauses read so far that the parser does not know (#3872), in order. */
+  protected readonly unknownClauses: UnknownClause[] = [];
 
   constructor(protected readonly tokens: Token[]) {
     this.sig = tokens.map((t, i) => (isTrivia(t) ? -1 : i)).filter((i) => i >= 0);
@@ -161,6 +207,56 @@ export class SqlCursor {
     return this.span(from, refs);
   }
 
+  /**
+   * At a clause boundary, a clause this parser does not know (#3872): a bare
+   * word that is not one of `known`, read up to the next top-level word of
+   * `known`, the statement's end, or (with `inList`, inside a column list) the
+   * element's `,` or `)`, its parentheses balanced. Recorded and returned.
+   *
+   * Undefined when the next token cannot start one: the end, punctuation, a
+   * string, a number, a quoted name or an interpolation, a word shorter than
+   * three letters or with a digit in it, or a word of `known`
+   * (a clause the parser knows, out of place). A word one letter from a known
+   * one fails here as a misspelling, and a run holding a top-level `SELECT`,
+   * `CREATE` or `INSERT` as a query or a second statement: genuinely
+   * malformed SQL stays an error.
+   */
+  protected unknownClause(known: readonly string[], options: { inList?: boolean; column?: string } = {}): UnknownClause | undefined {
+    const t = this.peek();
+    // A clause starts with a key word: three letters or more, no digits.
+    if (t === undefined || t.kind !== "ident" || !/^[A-Za-z_]{3,}$/.test(t.text)) return undefined;
+    const word = t.text.toUpperCase();
+    if (known.includes(word)) return undefined;
+    const near = misspelling(word, known);
+    if (near !== undefined) this.fail(`expected a clause ('${t.text}' is not one chant reads, and is one letter from ${near}: is it misspelt?)`, t);
+    const from = this.idx();
+    const startP = this.p;
+    // Its name: the first word, and when that is written in upper case, the upper-case words after it (`SQL SECURITY`), not a name it takes.
+    const words = [word];
+    const upper = (u: Token | undefined) => u?.kind === "ident" && /^[A-Z_]+$/.test(u.text) && !known.includes(u.text);
+    if (upper(t)) for (let n = 1; n < 3 && upper(this.peek(n)); n++) words.push(this.peek(n)!.text);
+    const refs: number[] = [];
+    let depth = 0;
+    for (;;) {
+      const u = this.peek();
+      if (u === undefined) break;
+      if (depth === 0) {
+        if (u.kind === "punct" && (u.text === ";" || u.text === ")" || (options.inList === true && u.text === ","))) break;
+        if (this.p > startP && u.kind === "ident" && known.includes(u.text.toUpperCase())) break;
+        // A query or a second statement is not a clause: `CREATE TABLE ... AS SELECT`, `... PARALLEL WITH CREATE ...`.
+        if (kw(u, "SELECT", "CREATE", "INSERT")) this.fail(`expected a clause (${u.text.toUpperCase()} starts a query or a statement, which is not declared here)`, u);
+      }
+      depth += this.depthChange(u);
+      if (depth < 0) break;
+      if (u.kind === "ref") refs.push(u.part);
+      this.p++;
+    }
+    if (depth !== 0) this.fail(`unbalanced parentheses in the ${words.join(" ")} clause`, t);
+    const clause: UnknownClause = { clause: words.join(" "), span: this.span(from, refs), ...(options.column !== undefined ? { column: options.column } : {}) };
+    this.unknownClauses.push(clause);
+    return clause;
+  }
+
   /** `( ... )` balanced: the span between the parentheses. */
   protected parenthesized(): Span {
     this.expectPunct("(");

package/src/core/interpolation.ts

@@ -12,7 +12,7 @@
 
 import type { AttrRef } from "@intentius/chant/attrref";
 import { isTrivia, SqlSyntaxError, tokenize, tokenizeText, untokenize, type LexicalRules, type Token } from "./tokens";
-import type { Span } from "./cursor";
+import type { Span, UnknownClause } from "./cursor";
 import type { LineageEdge } from "./references";
 import type { SqlObject } from "./entity";
 import { interpolationLine, spliceText, SqlTemplateError } from "./template";
@@ -124,6 +124,37 @@ export function spanText(ctx: TemplateCtx, span: Span | undefined, path?: string
   return untokenize(ctx.tokens.slice(span.from, span.to), (i) => ctx.d.renderReference(ctx.values[i], i)).trim();
 }
 
+/**
+ * A clause the parser does not know (#3872), as an entity's props carry it:
+ * kept in the DDL as written, its text here so a plan can compare it and a
+ * build can warn about it.
+ */
+export interface UnparsedClause {
+  /** Its leading words, upper case: `TABLESPACE_POLICY`. */
+  clause: string;
+  /** The clause as written, interpolations rendered. */
+  text: string;
+  /** The column (or dictionary attribute) it is written on, when it is one of a column's. */
+  column?: string;
+  /** The line of the statement (the props' `ddl`) it starts on, from 1. */
+  line: number;
+}
+
+/** A parsed statement's unknown clauses as props carry them; undefined when there are none. */
+export function unparsedClauses(ctx: TemplateCtx, unknown: readonly UnknownClause[] | undefined): UnparsedClause[] | undefined {
+  if (!unknown || unknown.length === 0) return undefined;
+  const render = (i: number) => ctx.d.renderReference(ctx.values[i], i);
+  return unknown.map((u) => {
+    const before = untokenize(ctx.tokens.slice(0, u.span.from), render).replace(/^\s+/, "");
+    return {
+      clause: u.clause,
+      text: spanText(ctx, u.span, "unparsed") ?? u.clause,
+      ...(u.column !== undefined ? { column: u.column } : {}),
+      line: before.split("\n").length,
+    };
+  });
+}
+
 /** A parse error as the tag reports it: on the template line, or in the interpolated text it came from. */
 export function templateSyntaxError(tag: string, parts: readonly string[], err: SqlSyntaxError): SqlTemplateError {
   const where =

package/src/files/clickhouse.ts

@@ -20,7 +20,7 @@ import { isAccessStatement, parseAccess, type AccessNode } from "../clickhouse/a
 import type { Token } from "../clickhouse/tokens";
 import { CLICKHOUSE_TAG_OF } from "../clickhouse/import/generator";
 import { describeStatement, type ImportedObject } from "../clickhouse/import/ir";
-import { firstLine, quoteBare, splitTokens, tokensText, type ReadOptions } from "./common";
+import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, type FileLine, type ReadOptions } from "./common";
 import { templateSafe, templateStrings } from "./postgres";
 
 type Tag = (strings: TemplateStringsArray, ...values: unknown[]) => Declarable;
@@ -82,15 +82,16 @@ export function clickhouseTag(type: string): Tag | undefined {
 }
 
 /** The objects a file of ClickHouse DDL declares. Problems are collected, not thrown, so a file is reported whole. */
-export function readClickHouse(ddl: string, options: ReadOptions, problems: string[]): ImportedObject[] {
-  const objects: ImportedObject[] = [];
+export function readClickHouse(ddl: string, options: ReadOptions, problems: string[]): Array<ImportedObject & FileLine> {
+  const objects: Array<ImportedObject & FileLine> = [];
   for (const stmt of splitTokens(tokenizeText(ddl, 0), isTrivia)) {
     let sql = tokensText(stmt);
+    const line = lineAt(ddl, stmt[0]!.start);
     if (isAccessStatement(sql)) {
       try {
         const read = readAccess(sql, options);
         if (typeof read === "string") problems.push(`${read}: ${firstLine(sql)}`);
-        else objects.push(read);
+        else objects.push({ ...read, line });
       } catch (e) {
         problems.push(`does not parse (${e instanceof Error ? e.message : String(e)}): ${firstLine(sql)}`);
       }
@@ -109,7 +110,8 @@ export function readClickHouse(ddl: string, options: ReadOptions, problems: stri
         const at = tokens.indexOf(only);
         sql = tokensText(tokens.slice(0, at)) + `${quoteBare(options.schema)}.` + tokensText(tokens.slice(at));
       }
-      objects.push(describeStatement(sql));
+      const unparsed = fileUnparsed(node.unknown, tokens, sql, line);
+      objects.push({ ...describeStatement(sql), line, ...(unparsed ? { unparsed } : {}) });
     } catch (e) {
       problems.push(`does not parse (${e instanceof Error ? e.message : String(e)}): ${firstLine(sql)}`);
     }

package/src/files/common.ts

@@ -1,6 +1,7 @@
 /** What reading a file of DDL shares across dialects. */
 
 import type { Token } from "../core/tokens";
+import type { UnknownClause } from "../core/cursor";
 
 export interface ReadOptions {
   /** Names the DDL in errors: a file's path, a command. */
@@ -47,6 +48,28 @@ export function splitTokens(tokens: readonly Token[], isTrivia: (t: Token) => bo
 
 export const tokensText = (tokens: readonly Token[]): string => tokens.map((t) => t.text).join("");
 
+/** Where an object's statement starts in its file, and the clauses in it chant does not read (#3872). */
+export interface FileLine {
+  /** The line its statement starts on, from 1. */
+  line?: number;
+  /** Each clause the parser does not know, with the file line it starts on; absent when there are none. */
+  unparsed?: Array<{ clause: string; line: number; column?: string }>;
+}
+
+/** A statement's unknown clauses with their lines in the file: `line` is the statement's, `sql` its text, `tokens` its tokens. */
+export function fileUnparsed(
+  unknown: readonly UnknownClause[] | undefined,
+  tokens: readonly Token[],
+  sql: string,
+  line: number,
+): FileLine["unparsed"] {
+  if (!unknown || unknown.length === 0) return undefined;
+  return unknown.map((u) => ({ clause: u.clause, line: line + lineAt(sql, tokens[u.span.from]?.start ?? 0) - 1, ...(u.column !== undefined ? { column: u.column } : {}) }));
+}
+
+/** The line, from 1, that offset `at` of `text` is on. */
+export const lineAt = (text: string, at: number): number => text.slice(0, at).split("\n").length;
+
 /** A statement's first line, for a message. */
 export const firstLine = (s: string): string => (s.split("\n")[0] ?? "").slice(0, 100);
 

package/src/files/postgres.ts

@@ -26,7 +26,7 @@ import * as tags from "../postgres/entities";
 import { POSTGRES_ENTITY_TYPES, type PostgresEntityType } from "../postgres/entity-types";
 import { POSTGRES_TAG_OF } from "../postgres/import/generator";
 import type { ImportedPgObject } from "../postgres/import/ir";
-import { firstLine, quoteBare, splitTokens, tokensText, type ReadOptions } from "./common";
+import { fileUnparsed, firstLine, lineAt, quoteBare, splitTokens, tokensText, type FileLine, type ReadOptions } from "./common";
 
 type Tag = (strings: TemplateStringsArray, ...values: unknown[]) => Declarable;
 
@@ -54,6 +54,10 @@ interface PgFileObject {
   statements: Token[][];
   /** Table constraints folded in from ALTER TABLE ... ADD, as SQL text. */
   constraints: string[];
+  /** The line its CREATE starts on in the file. */
+  line: number;
+  /** The clauses in it the parser does not know, with their lines (#3872). */
+  unparsed: FileLine["unparsed"];
 }
 
 /** Transaction control, which declares nothing. */
@@ -69,8 +73,8 @@ function isTransactionControl(sig: readonly Token[]): boolean {
  * joined as one declaration's DDL. Problems are collected, not thrown, so a
  * file is reported whole.
  */
-export function readPostgres(ddl: string, options: ReadOptions, problems: string[]): ImportedPgObject[] {
-  const parsed: Array<{ tokens: Token[]; node: StatementNode }> = [];
+export function readPostgres(ddl: string, options: ReadOptions, problems: string[]): Array<ImportedPgObject & FileLine> {
+  const parsed: Array<{ tokens: Token[]; node: StatementNode; line: number }> = [];
   const alters: Array<{ table: string[]; constraint: string; sql: string }> = [];
   for (const stmt of splitTokens(tokenizeText(ddl, 0), isTrivia)) {
     const sig = stmt.filter((t) => !isTrivia(t));
@@ -89,7 +93,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
     }
     try {
       const tokens = tokenizeText(sql, 0);
-      for (const node of parseStatements(tokens)) parsed.push({ tokens, node });
+      for (const node of parseStatements(tokens)) parsed.push({ tokens, node, line: lineAt(ddl, stmt[0]!.start) });
     } catch (e) {
       const what = word(sig[0], "ALTER") && word(sig[1], "TABLE") ? "an ALTER TABLE other than ADD of a table constraint or ROW LEVEL SECURITY" : `does not parse (${e instanceof Error ? e.message : String(e)})`;
       problems.push(`${what}: ${firstLine(sql)}`);
@@ -118,7 +122,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
   /** Objects by namespace and name: `rel` (anything in a schema), `index`, `schema`, `extension`, `role`, and `trigger`/`policy` with their table. */
   const owners = new Map<string, PgFileObject>();
   const followOns: Array<{ tokens: Token[]; node: StatementNode; inserts: Set<number> }> = [];
-  for (const { tokens, node } of parsed) {
+  for (const { tokens, node, line } of parsed) {
     const inserts = new Set<number>();
     /** Qualifies an unqualified name in the statement, when `schema` is set. */
     const mark = (n: NameNode | undefined) => {
@@ -170,7 +174,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
     }
     const ownName = !["schema", "extension", "index", "trigger", "policy", "role", "grant"].includes(node.statement);
     if (ownName && "name" in node) mark(node.name);
-    const object: PgFileObject = { node, statements: [rewrite(tokens, inserts, options.schema)], constraints: [] };
+    const object: PgFileObject = { node, statements: [rewrite(tokens, inserts, options.schema)], constraints: [], line, unparsed: fileUnparsed("unknown" in node ? node.unknown : undefined, tokens, tokensText(tokens), line) };
     objects.push(object);
     const k = ownerKey(node, tokens, nameOf, qualify);
     if (k) owners.set(k, object);
@@ -196,7 +200,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
     table.constraints.push(qualifyConstraint(alter.constraint, options.schema));
   }
 
-  const out: ImportedPgObject[] = [];
+  const out: Array<ImportedPgObject & FileLine> = [];
   for (const o of objects) {
     const [create = [], ...rest] = o.statements;
     const ddlText = [o.constraints.length > 0 ? addConstraints(create, o.constraints) : tokensText(create), ...rest.map((c) => tokensText(c))].join(";\n");
@@ -205,7 +209,7 @@ export function readPostgres(ddl: string, options: ReadOptions, problems: string
       problems.push(`${identity}: ${firstLine(ddlText)}`);
       continue;
     }
-    out.push({ ...identity, ddl: ddlText });
+    out.push({ ...identity, ddl: ddlText, line: o.line, ...(o.unparsed ? { unparsed: o.unparsed } : {}) });
   }
   return out;
 }

package/src/import-parser.ts

@@ -9,7 +9,8 @@
  * anything else is ClickHouse.
  *
  * A statement that declares nothing, or does not parse, is an error naming
- * it (`./sql-files.ts`); none is left out.
+ * it (`./sql-files.ts`); none is left out. A clause the parser does not know
+ * (#3872) is kept in the template as written.
  */
 
 import type { ParserOptions, TemplateIR, TemplateParser } from "@intentius/chant/import/parser";

package/src/lint/post-synth/clickhouse-helpers.ts

@@ -8,10 +8,23 @@
  */
 
 import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
-import { TABLE_ENGINES, TYPE_FAMILIES } from "../../generated/clickhouse";
 import type { ColumnDef, EngineDef } from "../../clickhouse/entities";
+import { baseEngineName, splitTop } from "../../clickhouse/expressions";
+import { readClickHouse, type ClickHouseTableInfo, type ClickHouseViewInfo } from "../../read/clickhouse";
 import { clickhouseObjects, type OutputObject } from "./sql-helpers";
 
+export {
+  bareName,
+  baseEngineName,
+  engineSpec,
+  isMergeTree,
+  isNullableType,
+  keyElements,
+  splitTop,
+  typeFamily,
+  unwrapType,
+} from "../../clickhouse/expressions";
+
 export interface TableObject extends OutputObject {
   columns: ColumnDef[];
   indexes: Array<{ name: string; expr: string; type: string; granularity?: string }>;
@@ -38,28 +51,14 @@ export const isMaterializedView = (o: OutputObject): o is ViewObject => o.type =
 export const isAnyView = (o: OutputObject): o is ViewObject =>
   o.type === "ClickHouse::View" || o.type === "ClickHouse::MaterializedView";
 
-export function tablesOf(ctx: PostSynthContext): TableObject[] {
-  return clickhouseObjects(ctx).filter(isTable);
-}
-
-export function viewsOf(ctx: PostSynthContext): ViewObject[] {
-  return clickhouseObjects(ctx).filter(isAnyView);
-}
-
-/** The engine's catalog entry, when the pinned server has the engine. */
-export function engineSpec(engine: EngineDef | undefined) {
-  return engine ? (TABLE_ENGINES as Record<string, (typeof TABLE_ENGINES)[keyof typeof TABLE_ENGINES]>)[engine.name] : undefined;
-}
-
-/** A MergeTree family engine, replicated or not. */
-export function isMergeTree(engine: EngineDef | undefined): boolean {
-  return engineSpec(engine)?.mergeTree === true;
+/** The build's tables as the public read API types them (`@intentius/chant-lexicon-sql/read`), so a project policy reads what the checks read. */
+export function tablesOf(ctx: PostSynthContext): ClickHouseTableInfo[] {
+  return readClickHouse(ctx).tables;
 }
 
-/** The engine without its `Replicated` prefix: `ReplicatedReplacingMergeTree` is `ReplacingMergeTree`. */
-export function baseEngineName(engine: EngineDef): string {
-  const spec = engineSpec(engine) as { replicates?: string } | undefined;
-  return spec?.replicates ?? engine.name;
+/** The build's views and materialized views, as the public read API types them. */
+export function viewsOf(ctx: PostSynthContext): ClickHouseViewInfo[] {
+  return readClickHouse(ctx).views;
 }
 
 /**
@@ -72,63 +71,6 @@ export function engineArguments(engine: EngineDef): string[] {
   return args;
 }
 
-/** Split on commas that are not inside parentheses, brackets or quotes. */
-export function splitTop(text: string, separator = ","): string[] {
-  const parts: string[] = [];
-  let depth = 0;
-  let quote: string | undefined;
-  let start = 0;
-  for (let i = 0; i < text.length; i++) {
-    const c = text[i]!;
-    if (quote) {
-      if (c === "\\") i++;
-      else if (c === quote) quote = undefined;
-      continue;
-    }
-    if (c === "'" || c === '"' || c === "`") quote = c;
-    else if (c === "(" || c === "[") depth++;
-    else if (c === ")" || c === "]") depth--;
-    else if (c === separator && depth === 0) {
-      parts.push(text.slice(start, i).trim());
-      start = i + 1;
-    }
-  }
-  const last = text.slice(start).trim();
-  if (last !== "" || parts.length > 0) parts.push(last);
-  return parts.filter((p) => p !== "");
-}
-
-/** `(a, b)` is the list `a`, `b`; `a, b` is the same; `tuple()` and `()` are empty. */
-export function keyElements(expr: string): string[] {
-  let text = expr.trim();
-  if (/^tuple\s*\(\s*\)$/i.test(text) || text === "()") return [];
-  if (text.startsWith("(") && closingParen(text, 0) === text.length - 1) text = text.slice(1, -1);
-  return splitTop(text).map((e) => e.replace(/\s+(ASC|DESC)$/i, "").replace(/\s+/g, " ").trim());
-}
-
-function closingParen(text: string, open: number): number {
-  let depth = 0;
-  let quote: string | undefined;
-  for (let i = open; i < text.length; i++) {
-    const c = text[i]!;
-    if (quote) {
-      if (c === "\\") i++;
-      else if (c === quote) quote = undefined;
-    } else if (c === "'" || c === '"' || c === "`") quote = c;
-    else if (c === "(") depth++;
-    else if (c === ")" && --depth === 0) return i;
-  }
-  return -1;
-}
-
-/** The column a bare name refers to: `a` or `` `a b` ``, else undefined. */
-export function bareName(element: string): string | undefined {
-  const text = element.trim();
-  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(text)) return text;
-  const quoted = /^`((?:[^`]|``)*)`$/.exec(text) ?? /^"((?:[^"]|"")*)"$/.exec(text);
-  return quoted ? quoted[1]!.replace(/``|""/g, (m) => m[0]!) : undefined;
-}
-
 const WORDS = new Set(
   (
     "AS AND OR NOT IN IS NULL LIKE ILIKE BETWEEN CASE WHEN THEN ELSE END ASC DESC INTERVAL DISTINCT TRUE FALSE " +
@@ -154,25 +96,6 @@ export function mentionedNames(expr: string): string[] {
   return names;
 }
 
-/** A type with its `Nullable(...)` and `LowCardinality(...)` wrappers removed. */
-export function unwrapType(type: string | undefined): string {
-  let t = (type ?? "").trim();
-  for (;;) {
-    const m = /^(Nullable|LowCardinality)\s*\(([\s\S]*)\)$/i.exec(t);
-    if (!m) return t;
-    t = m[2]!.trim();
-  }
-}
-
-/** The canonical family of a column's type (`BIGINT UNSIGNED` is `UInt64`), or its leading word when unknown. */
-export function typeFamily(type: string | undefined): string {
-  const head = /^[A-Za-z_][A-Za-z0-9_ ]*?(?=\s*\(|$)/.exec(unwrapType(type))?.[0]?.trim() ?? "";
-  const table = TYPE_FAMILIES as Record<string, { canonical: string } | undefined>;
-  return (table[head] ?? table[head.toUpperCase()])?.canonical ?? head;
-}
-
-export const isNullableType = (type: string | undefined): boolean => /^Nullable\s*\(/i.test((type ?? "").trim());
-
 export function columnByName(table: { columns: ColumnDef[] }, name: string): ColumnDef | undefined {
   return table.columns.find((c) => c.name === name);
 }

package/src/lint/post-synth/postgres-helpers.ts

@@ -8,54 +8,26 @@
 import type { PostSynthCheck, PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
 import { POSTGRES_MAJORS, VERSION_RANGES } from "../../generated/postgres";
 import type { VersionRange } from "../../postgres/catalog-types";
-import type { ColumnDef, KeyDef } from "../../postgres/entities";
-import { postgresMajorOf, postgresObjects, type OutputObject } from "./sql-helpers";
+import { readPostgres, type PostgresIndexInfo, type PostgresTableInfo, type PostgresViewInfo } from "../../read/postgres";
+import type { PostgresIndexJson, PostgresTableJson, PostgresViewJson } from "../../read/objects";
+import { postgresMajorOf, type OutputObject } from "./sql-helpers";
 
-export interface PgTable extends OutputObject {
-  sqlName: string;
-  like: string[];
-  schema?: string;
-  comment?: string;
-  columns: Array<ColumnDef & { comment?: string }>;
-  primaryKey?: KeyDef;
-  uniques: KeyDef[];
-  checks: Array<{ name?: string; expr: string; notEnforced?: boolean }>;
-  foreignKeys: Array<{ name?: string; columns: string[]; refTable: string; refColumns: string[] }>;
-  exclusions: unknown[];
-  inherits: unknown[];
-  partitionOf?: unknown;
-  ofType?: unknown;
-  persistence?: string;
-  with?: string;
-}
-
-export interface PgIndex extends OutputObject {
-  sqlName: string;
-  schema?: string;
-  table: string;
-  tableName: string;
-  unique?: boolean;
-  method?: string;
-  elements: Array<{ expr: string; column?: string }>;
-  include?: string;
-  where?: string;
-  with?: string;
-}
-
-export interface PgView extends OutputObject {
-  sqlName: string;
-  schema?: string;
-  query: string;
-  with?: string;
-}
+/**
+ * The objects as the public read API types them (`../../read/postgres.ts`,
+ * `@intentius/chant-lexicon-sql/read`): the checks and a project's own
+ * `lint.policies` read the same values.
+ */
+export type PgTable = PostgresTableInfo;
+export type PgIndex = PostgresIndexInfo;
+export type PgView = PostgresViewInfo;
 
-export const isTable = (o: OutputObject): o is PgTable => o.type === "Postgres::Table";
-export const isIndex = (o: OutputObject): o is PgIndex => o.type === "Postgres::Index";
-export const isView = (o: OutputObject): o is PgView => o.type === "Postgres::View";
-export const isMaterializedView = (o: OutputObject): o is PgView => o.type === "Postgres::MaterializedView";
+export const isTable = (o: OutputObject): o is OutputObject & PostgresTableJson => o.type === "Postgres::Table";
+export const isIndex = (o: OutputObject): o is OutputObject & PostgresIndexJson => o.type === "Postgres::Index";
+export const isView = (o: OutputObject): o is OutputObject & PostgresViewJson => o.type === "Postgres::View";
+export const isMaterializedView = (o: OutputObject): o is OutputObject & PostgresViewJson => o.type === "Postgres::MaterializedView";
 
-export const tablesOf = (ctx: PostSynthContext): PgTable[] => postgresObjects(ctx).filter(isTable);
-export const indexesOf = (ctx: PostSynthContext): PgIndex[] => postgresObjects(ctx).filter(isIndex);
+export const tablesOf = (ctx: PostSynthContext): PgTable[] => readPostgres(ctx).tables;
+export const indexesOf = (ctx: PostSynthContext): PgIndex[] => readPostgres(ctx).indexes;
 
 /** The major the build targets (`postgresMajor` in the output), else the newest pinned. */
 export const targetMajor = (ctx: PostSynthContext): number => postgresMajorOf(ctx, PINNED_MAJOR);
@@ -87,14 +59,7 @@ export function storageParams(text: string | undefined): Map<string, string> {
 }
 
 /** The leading bare-column elements of an index, in order; stops at the first expression. */
-export function leadingColumns(index: PgIndex): string[] {
-  const out: string[] = [];
-  for (const e of index.elements) {
-    if (!e.column) break;
-    out.push(e.column);
-  }
-  return out;
-}
+export const leadingColumns = (index: PgIndex): string[] => index.columns;
 
 /** A check over the build's Postgres objects, so each check file holds its rule. */
 export function checkOf(

package/src/lint/post-synth/postgres-names.ts

@@ -12,13 +12,13 @@
  */
 
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
-import { COLUMN_TYPES, FUNCTIONS, INDEX_ACCESS_METHODS, KEYWORDS, OPERATOR_CLASSES } from "../../generated/postgres";
+import { COLUMN_TYPES, FUNCTIONS, INDEX_ACCESS_METHODS, KEYWORDS, OPERATOR_CLASSES, POSTGRES_MAJORS } from "../../generated/postgres";
 import { EXTENSION_OBJECTS } from "../../postgres/overlays/extension-objects";
 import { GRAMMAR_TYPE_SPELLINGS, SERIAL_TYPES, SERIAL_WIDTH_SPELLINGS, TYPE_SPELLINGS } from "../../postgres/overlays/types";
 import { isTrivia, tokenizeText, type Token } from "../../postgres/tokens";
 import type { ColumnTypeSpec } from "../../postgres/catalog-types";
-import { targetMajor, type PgTable } from "./postgres-helpers";
-import { postgresObjects, type OutputObject } from "./sql-helpers";
+import { dialectObjects, recordedPostgresMajor, type PostgresTableJson as PgTable } from "../../read/objects";
+import type { OutputObject } from "./sql-helpers";
 
 // ── Catalog lookups ────────────────────────────────────────────────────
 
@@ -120,7 +120,7 @@ export interface PgProject {
 }
 
 export function projectOf(ctx: PostSynthContext): PgProject {
-  return projectFromObjects(postgresObjects(ctx), targetMajor(ctx));
+  return projectFromObjects(dialectObjects(ctx, "postgres"), recordedPostgresMajor(ctx, POSTGRES_MAJORS[POSTGRES_MAJORS.length - 1]!));
 }
 
 /** The project a set of output objects declares, at `major`: for a reader that holds the build output itself (`chant sql types`). */
@@ -386,7 +386,7 @@ function providesFunction(e: (typeof EXTENSION_OBJECTS)[string], name: string):
 export function expressionsOf(o: OutputObject): Array<{ where: string; expr: string }> {
   const out: Array<{ where: string; expr: string }> = [];
   if (o.type === "Postgres::Table") {
-    const t = o as PgTable;
+    const t = o as unknown as PgTable;
     for (const c of t.columns) {
       if (c.default) out.push({ where: `column ${c.name}'s DEFAULT`, expr: c.default });
       if (c.generated?.expr) out.push({ where: `generated column ${c.name}`, expr: c.generated.expr });
@@ -483,7 +483,7 @@ export function interpolatedTable(p: PgProject, ref: unknown, sqlName: string |
   const o = p.byExport.get(ref);
   if (!o || o.type !== "Postgres::Table") return undefined;
   if (sqlName !== undefined && o.sqlName !== sqlName) return undefined;
-  return o as PgTable;
+  return o as unknown as PgTable;
 }
 
 /**