@intentius/chant-lexicon-sql 0.124.18 → 0.124.21

package/src/postgres/plan/normalize.ts

@@ -46,13 +46,20 @@
 import { isTrivia, tokenizeText, type Token } from "../tokens";
 import { identValue } from "../parser";
 import { quoteIdent } from "../keywords";
-import { COLUMN_TYPES } from "../../generated/postgres";
+import { COLUMN_TYPES, FUNCTIONS } from "../../generated/postgres";
 import { stripMarker } from "../../core/ownership";
 import { sequenceDefaults } from "../live/catalog";
 import type {
+  AggregateArgDef,
+  AggregateProps,
+  CastProps,
   CheckDef,
+  CollationProps,
   ColumnDef,
+  CompositeTypeProps,
   DomainProps,
+  EventTriggerProps,
+  RangeTypeProps,
   EnumProps,
   ExclusionDef,
   ExtensionProps,
@@ -333,8 +340,14 @@ export type CanonicalKind =
   | "materializedView"
   | "sequence"
   | "enum"
+  | "composite"
+  | "range"
   | "domain"
   | "extension"
+  | "aggregate"
+  | "collation"
+  | "cast"
+  | "eventTrigger"
   | "function"
   | "procedure"
   | "trigger"
@@ -373,7 +386,13 @@ const kindOf: Record<string, CanonicalKind> = {
   "Postgres::MaterializedView": "materializedView",
   "Postgres::Sequence": "sequence",
   "Postgres::Enum": "enum",
+  "Postgres::CompositeType": "composite",
+  "Postgres::RangeType": "range",
   "Postgres::Domain": "domain",
+  "Postgres::Aggregate": "aggregate",
+  "Postgres::Collation": "collation",
+  "Postgres::Cast": "cast",
+  "Postgres::EventTrigger": "eventTrigger",
   "Postgres::Extension": "extension",
   "Postgres::Function": "function",
   "Postgres::Procedure": "procedure",
@@ -595,6 +614,96 @@ function triggerFields(p: TriggerProps, defaultSchema: string, fields: Record<st
     : undefined;
 }
 
+// ── Types, aggregates, collations, casts, event triggers (#3911) ──────
+
+/** The kinds that live in no schema. */
+const UNPLACED: ReadonlySet<CanonicalKind> = new Set(["schema", "extension", "role", "cast", "eventTrigger"]);
+
+/**
+ * A function named where an object calls it (an aggregate's SFUNC, a cast's
+ * or an event trigger's function), as the catalog's `regproc` prints it with
+ * an empty search_path: a `pg_catalog` function bare, any other qualified. A
+ * bare name that is no built-in function's is in the default schema.
+ */
+export function canonicalFunctionName(text: string, defaultSchema: string): string {
+  const pieces = canonicalName(text).split(/\.(?=(?:[^"]*"[^"]*")*[^"]*$)/);
+  if (pieces.length >= 2) return pieces[0] === "pg_catalog" ? pieces.slice(1).join(".") : pieces.join(".");
+  const bare = identValue(pieces[0]!);
+  return FUNCTIONS[bare] !== undefined ? pieces[0]! : `${quoteIdent(defaultSchema)}.${pieces[0]}`;
+}
+
+/** A collation named in a type or an attribute: canonical, a `pg_catalog` one bare (`"C"`), as the catalog prints it. */
+export const canonicalCollation = (text: string): string => canonicalName(text).replace(/^pg_catalog\./, "");
+
+/** A definition list's value as compared: a string constant's value, a word folded, other text canonical. */
+function defValue(v: string): string {
+  const t = v.trim();
+  if (/^([Ee]?'|\$)/.test(t)) return stringValue(t) ?? t;
+  if (/^"/.test(t)) return identValue(t);
+  if (/^[A-Za-z_][A-Za-z0-9_$]*$/.test(t)) return t.toLowerCase();
+  return canonicalExpr(t) ?? t;
+}
+
+/** A Postgres boolean option's value (`true`, `on`, `1`, `yes`), as written or given with no value. */
+const isTrue = (v: string | undefined): boolean => v !== undefined && /^(true|on|1|yes|t|y)$/i.test(defValue(v));
+
+/** The name Postgres gives a range type's multirange type when none is written: `range` in its name becomes `multirange`, else `_multirange` is added. */
+export function defaultMultirangeName(range: string): string {
+  const at = range.indexOf("range");
+  return at >= 0 ? `${range.slice(0, at)}multi${range.slice(at)}` : `${range}_multirange`;
+}
+
+/** An aggregate's identity among its overloads: `(integer)`, `(*)`, `(text ORDER BY integer)`. */
+export function aggregateSignature(p: Pick<AggregateProps, "args" | "orderBy">, defaultSchema: string): string {
+  const types = (l: readonly AggregateArgDef[]) => l.map((a) => canonicalArgType(a.type, defaultSchema)).join(",");
+  if (p.orderBy) return `(${p.args.length > 0 ? `${types(p.args)} ` : ""}ORDER BY ${types(p.orderBy)})`;
+  return p.args.length === 0 ? "(*)" : `(${types(p.args)})`;
+}
+
+const AGGREGATE_FUNCTIONS = new Set(["sfunc", "finalfunc", "combinefunc", "serialfunc", "deserialfunc", "msfunc", "minvfunc", "mfinalfunc"]);
+const AGGREGATE_TYPES = new Set(["stype", "mstype"]);
+const AGGREGATE_FLAGS = new Set(["finalfunc_extra", "mfinalfunc_extra", "hypothetical"]);
+
+/** An aggregate's definition as compared: each option canonical, the ones at their defaults left out. */
+function aggregateOptions(p: AggregateProps, defaultSchema: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  // A FINALFUNC_MODIFY not written is READ_ONLY for a plain aggregate, READ_WRITE for an ordered-set one.
+  const modifyDefault = p.orderBy ? "read_write" : "read_only";
+  for (const [k, v] of Object.entries(p.options)) {
+    if (AGGREGATE_FUNCTIONS.has(k)) out[k] = canonicalFunctionName(v, defaultSchema);
+    else if (AGGREGATE_TYPES.has(k)) out[k] = canonicalType(v, defaultSchema)!;
+    else if (AGGREGATE_FLAGS.has(k)) {
+      if (isTrue(v)) out[k] = "true";
+    } else if (k === "sspace" || k === "msspace") {
+      if (Number(defValue(v)) !== 0) out[k] = String(Number(defValue(v)));
+    } else if (k === "finalfunc_modify" || k === "mfinalfunc_modify") {
+      if (defValue(v) !== modifyDefault) out[k] = defValue(v);
+    } else if (k === "sortop") {
+      out[k] = v.trim().replace(/^OPERATOR\s*\(\s*(.*?)\s*\)$/is, "$1").replace(/^pg_catalog\s*\.\s*/i, "");
+    } else if (k === "parallel") {
+      if (defValue(v) !== "unsafe") out[k] = defValue(v);
+    } else out[k] = defValue(v);
+  }
+  return Object.fromEntries(Object.entries(out).sort(([a], [b]) => (a < b ? -1 : 1)));
+}
+
+/** A collation's definition as compared: its provider (`libc` unless written) and locales, `deterministic` only when false. VERSION is the provider's, and is not compared. */
+function collationFields(p: CollationProps, fields: Record<string, unknown>): void {
+  const o = Object.fromEntries(Object.entries(p.options).map(([k, v]) => [k, defValue(v)]));
+  const provider = o.provider ?? "libc";
+  fields.provider = provider;
+  if (provider === "libc") {
+    fields.lcCollate = o.lc_collate ?? o.locale;
+    fields.lcCtype = o.lc_ctype ?? o.locale;
+  } else fields.locale = o.locale ?? o.lc_collate;
+  fields.nondeterministic = p.options.deterministic !== undefined && !isTrue(p.options.deterministic);
+  fields.rules = o.rules;
+}
+
+/** A cast's name, `(source AS target)`, its types canonical. */
+export const castName = (p: Pick<CastProps, "sourceType" | "targetType">, defaultSchema: string): string =>
+  `(${canonicalType(p.sourceType, defaultSchema)} AS ${canonicalType(p.targetType, defaultSchema)})`;
+
 /**
  * A definition in canonical form. `props` is an entity's props, declared or
  * parsed from what the server printed; `defaultSchema` qualifies a bare name.
@@ -602,7 +711,7 @@ function triggerFields(p: TriggerProps, defaultSchema: string, fields: Record<st
 export function canonicalPgObject(entityType: string, props: Record<string, unknown>, defaultSchema = "public"): CanonicalPgObject {
   const kind = kindOf[entityType];
   if (!kind) throw new Error(`not a Postgres entity type: ${entityType}`);
-  const schemaOf = (p: { schema?: string }) => (kind === "schema" || kind === "extension" || kind === "role" || ACCESS_KINDS.has(kind) ? undefined : (p.schema ?? defaultSchema));
+  const schemaOf = (p: { schema?: string }) => (UNPLACED.has(kind) || ACCESS_KINDS.has(kind) ? undefined : (p.schema ?? defaultSchema));
   const base: Pick<CanonicalPgObject, "kind" | "schema" | "name" | "signature"> = { kind, schema: schemaOf(props as { schema?: string }), name: String(props.name) };
   const fields: Record<string, unknown> = { comment: comment(props.comment as string | undefined) };
   const columns: CanonicalColumn[] = [];
@@ -623,6 +732,48 @@ export function canonicalPgObject(entityType: string, props: Record<string, unkn
     case "enum":
       fields.labels = (props as unknown as EnumProps).labels;
       break;
+    case "composite": {
+      const p = props as unknown as CompositeTypeProps;
+      fields.attributeDefs = p.attributes.map((a) => `${quoteIdent(a.name)} ${canonicalType(a.type, defaultSchema)}${a.collate ? ` collate ${canonicalCollation(a.collate)}` : ""}`);
+      break;
+    }
+    case "range": {
+      const p = props as unknown as RangeTypeProps;
+      fields.subtype = canonicalType(p.subtype, defaultSchema);
+      fields.subtypeOpclass = p.subtypeOpclass ? canonicalName(p.subtypeOpclass).replace(/^pg_catalog\./, "") : undefined;
+      fields.collation = p.collation ? canonicalCollation(p.collation) : undefined;
+      fields.canonical = p.canonical ? canonicalFunctionName(p.canonical, defaultSchema) : undefined;
+      fields.subtypeDiff = p.subtypeDiff ? canonicalFunctionName(p.subtypeDiff, defaultSchema) : undefined;
+      // The multirange type is always named: as written, else as Postgres derives it, in the range's schema.
+      fields.multirange = p.multirangeTypeName
+        ? canonicalName(p.multirangeTypeName, base.schema)
+        : canonicalName(quoteIdent(defaultMultirangeName(base.name)), base.schema);
+      break;
+    }
+    case "aggregate": {
+      const p = props as unknown as AggregateProps;
+      base.signature = aggregateSignature(p, defaultSchema);
+      fields.definition = aggregateOptions(p, defaultSchema);
+      break;
+    }
+    case "collation":
+      collationFields(props as unknown as CollationProps, fields);
+      break;
+    case "cast": {
+      const p = props as unknown as CastProps;
+      base.name = castName(p, defaultSchema);
+      fields.castMethod = p.method;
+      fields.function = p.functionName ? canonicalFunctionName(p.functionName, defaultSchema) : undefined;
+      fields.context = p.context === "explicit" ? undefined : p.context;
+      break;
+    }
+    case "eventTrigger": {
+      const p = props as unknown as EventTriggerProps;
+      fields.event = p.event.toLowerCase();
+      fields.tags = p.tags && p.tags.length > 0 ? [...new Set(p.tags.map((t) => t.toUpperCase().replace(/\s+/g, " ").trim()))].sort() : undefined;
+      fields.function = canonicalFunctionName(p.functionName, defaultSchema);
+      break;
+    }
     case "function":
     case "procedure": {
       const p = props as unknown as RoutineProps;

package/src/postgres/plan/rules.ts

@@ -357,6 +357,27 @@ export const PG_CLASSIFIER_RULES = {
     "chant's parser does not know this clause, so it cannot tell which lock the change takes or whether an in-place statement makes it; the plan refuses it rather than guess. Review it: make it by hand with the ALTER the server documents for the clause, or as expand and contract.",
     `${DOCS}/sql-altertable.html`,
   ),
+  SQLPG300: rule(
+    "SQLPG300",
+    "metadata",
+    "Drop and create a type, aggregate, collation, cast or event trigger",
+    "A composite or range type's definition, a collation's, a cast's and an event trigger's have no ALTER, and an aggregate's argument types, state type and final function cannot be replaced: the object is dropped and created in one transaction. Nothing on the server depends on it (a column, a view, a function or a cast would make the DROP fail); the locks are on its catalog rows only.",
+    `${DOCS}/sql-createtype.html`,
+  ),
+  SQLPG301: rule(
+    "SQLPG301",
+    "expand",
+    "Change a type, aggregate, collation or cast that other objects depend on",
+    "No ALTER makes the change, and DROP refuses while a column, a view, a function or another object depends on the object. Create the new definition under another name, move what depends on it, then drop the old.",
+    `${DOCS}/sql-droptype.html`,
+  ),
+  SQLPG302: rule(
+    "SQLPG302",
+    "metadata",
+    "Replace an aggregate's definition",
+    "CREATE OR REPLACE AGGREGATE (14 and later) replaces the aggregate's functions and options in the catalog; no table is locked. Its argument types, its result and its kind (plain, ordered-set, hypothetical-set) have to stay the same, so a change of the state type or the final function is dropped and created instead (SQLPG300).",
+    `${DOCS}/sql-createaggregate.html`,
+  ),
   SQLPG270: rule("SQLPG270", "drop", "Drop an object", "The object and, for a table, a materialized view or a sequence, its data are gone.", `${DOCS}/sql-droptable.html`),
 } as const satisfies Record<string, PgClassifierRule>;
 

package/src/postgres/plan/schema.ts

@@ -28,7 +28,7 @@ export interface PgDiffObject extends CanonicalPgObject {
   foreign?: string;
   /** The export name, against a server. */
   exportName?: string;
-  /** What depends on a routine on the server (a view, a trigger, a default), which a DROP FUNCTION would refuse. */
+  /** What depends on a routine, type, aggregate, collation or cast on the server (a view, a trigger, a column), which a DROP would refuse. */
   dependents?: string[];
 }
 
@@ -99,15 +99,17 @@ export function pgSchemaFromBuildFile(path: string, defaultSchema = "public"): P
 /**
  * The namespace an object's name is unique in: relations (tables, views,
  * sequences, indexes) share one per schema, types and domains another,
- * functions and procedures a third (told apart by their parameter types),
+ * functions, procedures and aggregates a third (told apart by their
+ * parameter types), collations a fourth; a cast is named by its two types,
  * a trigger's or a policy's name is unique on its table, and a role's in the
  * cluster.
  */
 export function pgNamespace(kind: string): string {
   if (kind === "schema" || kind === "extension" || kind === "trigger" || kind === "policy" || kind === "role") return kind;
+  if (kind === "collation" || kind === "cast" || kind === "eventTrigger") return kind;
   if (kind === "grant" || kind === "defaultPrivileges") return "grant";
-  if (kind === "enum" || kind === "domain") return "type";
-  if (kind === "function" || kind === "procedure") return "routine";
+  if (kind === "enum" || kind === "domain" || kind === "composite" || kind === "range") return "type";
+  if (kind === "function" || kind === "procedure" || kind === "aggregate") return "routine";
   return "relation";
 }
 

package/src/postgres/testing/fake-client.ts

@@ -11,6 +11,8 @@ export interface FakeCatalog {
   tables?: Array<{ schema: string; name: string; comment?: string; columns?: Array<{ name: string; type: string; notnull?: boolean; dflt?: string }> }>;
   views?: Array<{ schema: string; name: string; def: string; materialized?: boolean; comment?: string }>;
   indexes?: Array<{ schema: string; name: string; table: string; def: string }>;
+  /** What the undeclarable-kind probes (`../live/undeclarable.ts`) find, by the coverage table's kind. Default: nothing. */
+  undeclarable?: Array<{ kind: string; schema?: string; name: string }>;
 }
 
 export function fakeClient(catalog: FakeCatalog, log: string[] = []): PostgresClient {
@@ -20,6 +22,9 @@ export function fakeClient(catalog: FakeCatalog, log: string[] = []): PostgresCl
     async query<T>(sql: string): Promise<T[]> {
       log.push(sql);
       const rows = (r: unknown[]) => r as T[];
+      // A probe for one undeclarable kind (`../live/undeclarable.ts`), which its comment names.
+      const probe = /^\/\* chant undeclarable: (.+?) \*\//.exec(sql);
+      if (probe) return rows((catalog.undeclarable ?? []).filter((u) => u.kind === probe[1]).map((u) => ({ schema: u.schema ?? null, name: u.name, owner: null })));
       if (sql.includes("FROM pg_catalog.pg_namespace n WHERE")) return rows((catalog.schemas ?? []).map((s, i) => ({ oid: String(100 + i), name: s.name, comment: s.comment ?? null })));
       if (sql.includes("c.relkind IN ('r', 'p')")) {
         return rows(tables.map((t) => ({ oid: t.oid, schema: t.schema, name: t.name, kind: "r", persistence: "p", ispartition: false, typed: false, partkey: null, bound: null, parents: [], reloptions: null, am: "heap", tablespace: null, comment: t.comment ?? null })));

package/src/postgres/testing/roundtrip-schema.ts

@@ -3,7 +3,9 @@
  * kind the dialect declares, with what the catalog's printers rewrite most
  * (type aliases, literal casts, `IN` lists, unnamed constraints, identity and
  * sequence options, storage parameters, comments), an extension and the
- * domain over its type, a partitioned table and a partition, an ORM's
+ * domain over its type, a collation, composite and range types (and a
+ * multirange column), plain and ordered-set aggregates, a cast and an event
+ * trigger (#3911), a partitioned table and a partition, an ORM's
  * revision table that import leaves out, and an object carrying chant's
  * ownership trailer.
  */
@@ -42,5 +44,21 @@ CREATE VIEW app.order_totals AS
   FROM app.users u LEFT JOIN app.orders o ON o.user_id = u.id
   GROUP BY u.id, u.email;
 CREATE MATERIALIZED VIEW app.daily AS SELECT placed_at::date AS day, count(*) AS n FROM app.orders GROUP BY 1 WITH NO DATA;
+CREATE COLLATION app.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false);
+COMMENT ON COLLATION app.ci IS 'Case-insensitive';
+CREATE TYPE app.pair AS (a integer, b text COLLATE "C");
+COMMENT ON TYPE app.pair IS 'Two values';
+CREATE TYPE app.floatrange AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi);
+CREATE TABLE app.people (id integer PRIMARY KEY, nick text COLLATE app.ci, span app.floatrange, tags app.floatmultirange);
+CREATE FUNCTION app.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$;
+CREATE AGGREGATE app.total(integer) (SFUNC = app.add2, STYPE = integer, INITCOND = '0', PARALLEL = SAFE);
+COMMENT ON AGGREGATE app.total(integer) IS 'A sum';
+CREATE FUNCTION app.middle(v double precision[]) RETURNS double precision LANGUAGE sql IMMUTABLE AS $$ SELECT v[(array_length(v, 1) + 1) / 2] $$;
+CREATE AGGREGATE app.median_of(ORDER BY double precision) (SFUNC = pg_catalog.array_append, STYPE = double precision[], FINALFUNC = app.middle);
+CREATE FUNCTION app.pair_text(p app.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$;
+CREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair) AS ASSIGNMENT;
+COMMENT ON CAST (app.pair AS text) IS 'a:b';
+CREATE FUNCTION app.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;
+CREATE EVENT TRIGGER app_audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION app.audit();
 CREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);
 `;

package/src/postgres.ts

@@ -17,7 +17,11 @@ export {
   extension,
   func,
   procedure,
+  aggregate,
   trigger,
+  eventTrigger,
+  collation,
+  cast,
   policy,
   role,
   grant,
@@ -37,7 +41,14 @@ export {
   type PostgresIndex,
   type PostgresSequence,
   type PostgresEnum,
+  type PostgresCompositeType,
+  type PostgresRangeType,
+  type PostgresType,
   type PostgresDomain,
+  type PostgresAggregate,
+  type PostgresCollation,
+  type PostgresCast,
+  type PostgresEventTrigger,
   type PostgresExtension,
   type PostgresFunction,
   type PostgresProcedure,
@@ -56,6 +67,14 @@ export {
   type ViewProps,
   type SequenceProps,
   type EnumProps,
+  type CompositeTypeProps,
+  type CompositeAttributeDef,
+  type RangeTypeProps,
+  type AggregateProps,
+  type AggregateArgDef,
+  type CollationProps,
+  type CastProps,
+  type EventTriggerProps,
   type DomainProps,
   type ExtensionProps,
   type RoutineProps,

package/src/skill-defs.ts

@@ -54,7 +54,7 @@ export const sqlSkills = createSkillsLoader(import.meta.url, [
     file: "chant-sql-postgres.md",
     name: "chant-sql-postgres",
     description:
-      "Declare Postgres schemas, tables, constraints, indexes, views, sequences, enum and domain types, extensions, functions, procedures, triggers, policies, roles and grants as SQL-shaped tagged templates, with references, lineage and the SQLPG lint rules",
+      "Declare Postgres schemas, tables, constraints, indexes, views, sequences, enum, composite, range and domain types, collations, casts, aggregates, event triggers, extensions, functions, procedures, triggers, policies, roles and grants as SQL-shaped tagged templates, with references, lineage and the SQLPG lint rules",
     triggers: [
       { type: "context" as const, value: "postgres" },
       { type: "context" as const, value: "postgres schema" },

package/src/skills/chant-sql-postgres.md

@@ -1,6 +1,6 @@
 ---
 skill: chant-sql-postgres
-description: Declare Postgres schemas, tables, constraints, indexes, views, sequences, enum and domain types, extensions, functions, procedures, triggers, policies, roles and grants as SQL-shaped tagged templates, with references, lineage and the SQLPG lint rules
+description: Declare Postgres schemas, tables, constraints, indexes, views, sequences, enum, composite, range and domain types, collations, casts, aggregates, event triggers, extensions, functions, procedures, triggers, policies, roles and grants as SQL-shaped tagged templates, with references, lineage and the SQLPG lint rules
 user-invocable: true
 ---
 # Declaring a Postgres schema with chant
@@ -34,12 +34,16 @@ The export name (`users`) is the object's identity in chant. The name in the SQL
 | `index` | `CREATE INDEX` | `Postgres::Index` |
 | `view` | `CREATE VIEW`, `CREATE MATERIALIZED VIEW` | `Postgres::View`, `Postgres::MaterializedView` |
 | `sequence` | `CREATE SEQUENCE` | `Postgres::Sequence` |
-| `type` | `CREATE TYPE ... AS ENUM` | `Postgres::Enum` |
+| `type` | `CREATE TYPE ... AS ENUM`, `AS (...)`, `AS RANGE` | `Postgres::Enum`, `Postgres::CompositeType`, `Postgres::RangeType` |
 | `domain` | `CREATE DOMAIN` | `Postgres::Domain` |
 | `extension` | `CREATE EXTENSION` | `Postgres::Extension` |
 | `func` | `CREATE FUNCTION` | `Postgres::Function` |
 | `procedure` | `CREATE PROCEDURE` | `Postgres::Procedure` |
+| `aggregate` | `CREATE AGGREGATE` | `Postgres::Aggregate` |
 | `trigger` | `CREATE TRIGGER` | `Postgres::Trigger` |
+| `eventTrigger` | `CREATE EVENT TRIGGER` | `Postgres::EventTrigger` |
+| `collation` | `CREATE COLLATION` | `Postgres::Collation` |
+| `cast` | `CREATE CAST` | `Postgres::Cast` |
 | `policy` | `CREATE POLICY` | `Postgres::Policy` |
 | `role` | `CREATE ROLE` (no password, no memberships) | `Postgres::Role` |
 | `grant` | `GRANT`, `REVOKE`, `ALTER DEFAULT PRIVILEGES` | `Postgres::Grant`, `Postgres::DefaultPrivileges` |
@@ -185,4 +189,4 @@ chant build src --lexicon sql -o dist/schema.json
 
 ## Not covered
 
-`ALTER` (other than a table's row-level security), role memberships, rules, aggregates, event triggers and the composite and range forms of `CREATE TYPE` are not declared with the tags. Planning a schema change (`chant sql diff`, `chant sql plan`, the lock classes) is the `chant-sql-postgres-plan` skill. Apply and the expand-and-contract migration Op have their own skills, which arrive with the code they describe.
+`ALTER` (other than a table's row-level security), role memberships, rules, operators, extended statistics, foreign data objects, publications and subscriptions, text search objects and base types are not declared with the tags. An aggregate is identified by its argument types; a cast is named `(source AS target)` and an event trigger lives in no schema. A definition change to a composite or range type, collation, cast or event trigger is a drop and a create, refused while something depends on it. Planning a schema change (`chant sql diff`, `chant sql plan`, the lock classes) is the `chant-sql-postgres-plan` skill. Apply and the expand-and-contract migration Op have their own skills, which arrive with the code they describe.

package/src/skills/chant-sql.md

@@ -35,9 +35,11 @@ The export name (`events`) is the object's identity in chant. The name in the SQ
 
 A dictionary is a `dictionary` template holding `CREATE DICTIONARY`, with its attributes, `PRIMARY KEY`, `SOURCE`, `LAYOUT` and `LIFETIME`. Its attributes are columns (`${ratesDict.columns.rate}`). Any change but its comment is SQLCH245, and the applier replaces it with `CREATE OR REPLACE DICTIONARY`. Keep passwords out of `SOURCE`: name a server-side named collection instead.
 
+A table over a table function is a `table` template, `CREATE TABLE t [(cols)] AS numbers(10)`, with no engine; a change is SQLCH219 (`CREATE OR REPLACE TABLE`). `CREATE TABLE ... AS other`, `AS SELECT` and `CLONE AS`, live and window views, named collections (credentials), masking policies, workloads, resources and `CREATE INDEX` are refused with the reason.
+
 A SQL user-defined function is a `func` template holding `CREATE FUNCTION name AS (x) -> expr`, with no database in its name. A changed expression is SQLCH260 (`CREATE OR REPLACE FUNCTION`). It carries no ownership marker, so chant never drops one.
 
-Users, roles, row policies and grants are `user`, `role`, `policy` and `grant` templates. Never write a password: `IDENTIFIED BY` is refused, a user declared without `IDENTIFIED` is created by the environment with its password, and chant manages the rest of it. Grants are compared per grantee: every `grant` naming a grantee adds up to its complete list, and anything else it holds is revoked (SQLCH274). None of these is ever dropped by chant. They are planned and applied only where the profile sets `access: true` (`sql.profiles.<env>.access`); elsewhere each is reported `filtered`.
+Users, roles, row policies, quotas, settings profiles and grants are `user`, `role`, `policy`, `quota`, `settingsProfile` and `grant` templates; a quota or profile is changed with `ALTER` (SQLCH275, SQLCH276), never replaced. Never write a password: `IDENTIFIED BY` is refused, a user declared without `IDENTIFIED` is created by the environment with its password, and chant manages the rest of it. Grants are compared per grantee: every `grant` naming a grantee adds up to its complete list, and anything else it holds is revoked (SQLCH274). None of these is ever dropped by chant. They are planned and applied only where the profile sets `access: true` (`sql.profiles.<env>.access`); elsewhere each is reported `filtered`.
 
 ## Interpolations
 

package/src/unknown-clauses.test.ts

@@ -58,7 +58,8 @@ describe("the ClickHouse parser keeps a clause it does not know", () => {
     // Unbalanced parentheses, a word that is not a key word, an unknown statement kind.
     expect(() => ch("CREATE TABLE a.t (x UInt64) ENGINE = Log FUTURE_THING (a")).toThrow(/unbalanced parentheses|expected/);
     expect(() => ch("CREATE TABLE a.t (x UInt64) ENGINE = Log 'stray'")).toThrow(/unexpected token/);
-    expect(() => ch("CREATE NAMED COLLECTION c AS a = 1")).toThrow(/expected DATABASE, TABLE/);
+    expect(() => ch("CREATE NAMED COLLECTION c AS a = 1")).toThrow(/NAMED COLLECTION is not declared/);
+    expect(() => ch("CREATE SOMETHING c")).toThrow(/expected DATABASE, TABLE/);
   });
 });
 

package/src/validate.ts

@@ -31,6 +31,8 @@ const REQUIRED_ENTITIES = [
   "Role",
   "RowPolicy",
   "Grant",
+  "Quota",
+  "SettingsProfile",
   "PostgresSchema",
   "PostgresTable",
   "PostgresIndex",
@@ -38,7 +40,13 @@ const REQUIRED_ENTITIES = [
   "PostgresMaterializedView",
   "PostgresSequence",
   "PostgresEnum",
+  "PostgresCompositeType",
+  "PostgresRangeType",
   "PostgresDomain",
+  "PostgresAggregate",
+  "PostgresCollation",
+  "PostgresCast",
+  "PostgresEventTrigger",
   "PostgresExtension",
   "PostgresFunction",
   "PostgresProcedure",