@intentius/chant-lexicon-sql 0.124.19 → 0.124.21

package/src/mcp/postgres.ts

@@ -81,7 +81,7 @@ export function postgresSearch(params: Record<string, unknown>): unknown {
   };
 }
 
-const TAGS = { schema: pg.schema, table: pg.table, index: pg.index, view: pg.view, sequence: pg.sequence, type: pg.type, domain: pg.domain, extension: pg.extension, func: pg.func, procedure: pg.procedure, trigger: pg.trigger, policy: pg.policy, role: pg.role, grant: pg.grant } as const;
+const TAGS = { schema: pg.schema, table: pg.table, index: pg.index, view: pg.view, sequence: pg.sequence, type: pg.type, domain: pg.domain, extension: pg.extension, func: pg.func, procedure: pg.procedure, aggregate: pg.aggregate, trigger: pg.trigger, eventTrigger: pg.eventTrigger, collation: pg.collation, cast: pg.cast, policy: pg.policy, role: pg.role, grant: pg.grant } as const;
 export const POSTGRES_TAGS = Object.keys(TAGS);
 
 /** Parse one statement with the Postgres tag; an error comes back as SQLPG001 with its line and column. */

package/src/plugin.ts

@@ -99,15 +99,21 @@ export const sqlPlugin: LexiconPlugin = {
       },
       { name: "dictionary", isTag: true, description: "A ClickHouse CREATE DICTIONARY, parsed into a dictionary entity with its attributes, key, source and layout" },
       { name: "user", isTag: true, description: "A ClickHouse CREATE USER, parsed into a user entity; its password is the environment's" },
+      { name: "quota", isTag: true, description: "A ClickHouse CREATE QUOTA, parsed into a quota entity with its key, its intervals' limits and whom it applies to" },
+      { name: "settingsProfile", isTag: true, description: "A ClickHouse CREATE SETTINGS PROFILE, parsed into a settings profile entity with its settings, constraints and inherited profiles" },
       { name: "schema", isTag: true, description: "A Postgres CREATE SCHEMA, parsed into a schema entity" },
       { name: "index", isTag: true, description: "A Postgres CREATE INDEX, parsed into an index entity" },
       { name: "sequence", isTag: true, description: "A Postgres CREATE SEQUENCE, parsed into a sequence entity" },
-      { name: "type", isTag: true, description: "A Postgres CREATE TYPE ... AS ENUM, parsed into an enum entity" },
+      { name: "type", isTag: true, description: "A Postgres CREATE TYPE ... AS ENUM, AS (...) or AS RANGE, parsed into an enum, composite or range type entity" },
       { name: "domain", isTag: true, description: "A Postgres CREATE DOMAIN, parsed into a domain entity" },
       { name: "extension", isTag: true, description: "A Postgres CREATE EXTENSION, parsed into an extension entity" },
       { name: "func", isTag: true, description: "A Postgres CREATE FUNCTION, parsed into a function entity with its body kept verbatim, or a ClickHouse CREATE FUNCTION (a named lambda)" },
       { name: "procedure", isTag: true, description: "A Postgres CREATE PROCEDURE, parsed into a procedure entity with its body kept verbatim" },
+      { name: "aggregate", isTag: true, description: "A Postgres CREATE AGGREGATE, parsed into an aggregate entity identified by its argument types" },
       { name: "trigger", isTag: true, description: "A Postgres CREATE TRIGGER, parsed into a trigger entity on its table" },
+      { name: "eventTrigger", isTag: true, description: "A Postgres CREATE EVENT TRIGGER, parsed into the database's event trigger entity" },
+      { name: "collation", isTag: true, description: "A Postgres CREATE COLLATION, parsed into a collation entity" },
+      { name: "cast", isTag: true, description: "A Postgres CREATE CAST, parsed into a cast entity named by its two types" },
       { name: "policy", isTag: true, description: "A Postgres CREATE POLICY, parsed into a row-level security policy on its table, or a ClickHouse CREATE ROW POLICY" },
       { name: "role", isTag: true, description: "A Postgres CREATE ROLE without a password or memberships, parsed into a role entity, or a ClickHouse CREATE ROLE" },
       { name: "grant", isTag: true, description: "A Postgres GRANT, REVOKE or ALTER DEFAULT PRIVILEGES, parsed into the privileges it declares, or a ClickHouse GRANT of privileges or roles" },

package/src/postgres/apply/apply.ts

@@ -151,7 +151,7 @@ export const refName = (o: { kind: CanonicalKind; schema?: string; name: string;
     ? `${o.name}${o.signature ?? ""}`
     : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.schema === undefined
       ? o.name
-      : `${o.schema}.${o.name}${o.kind === "function" || o.kind === "procedure" ? (o.signature ?? "") : ""}`;
+      : `${o.schema}.${o.name}${o.kind === "function" || o.kind === "procedure" || o.kind === "aggregate" ? (o.signature ?? "") : ""}`;
 
 /**
  * The objects a Postgres `chant build` output declares, in creation order,
@@ -564,7 +564,13 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
       "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",
@@ -577,7 +583,7 @@ function liveCanonicalAddress(o: LivePgObject): { kind: CanonicalKind; schema?:
   )[o.type];
   return {
     kind,
-    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" && kind !== "role" ? { schema: o.schema } : {}),
+    ...(o.schema !== undefined && kind !== "schema" && kind !== "extension" && kind !== "role" && kind !== "cast" && kind !== "eventTrigger" ? { schema: o.schema } : {}),
     name: o.name,
     ...(o.signature !== undefined ? { signature: o.signature } : {}),
   };

package/src/postgres/apply/statements.ts

@@ -100,12 +100,15 @@ export const pgString = (value: string): string => `'${value.replace(/'/g, "''")
 export const pgQualified = (schema: string | undefined, name: string): string => (schema ? `${quoteIdent(schema)}.${quoteIdent(name)}` : quoteIdent(name));
 
 /**
- * An object's name in a statement. A schema and an extension have no schema;
- * a routine is named with its parameter types (`app.f(integer,text)`), a
- * trigger with its table (`touch ON app.users`).
+ * An object's name in a statement. A schema, an extension and an event
+ * trigger have no schema; a routine or an aggregate is named with its
+ * parameter types (`app.f(integer,text)`), a trigger with its table
+ * (`touch ON app.users`), a cast by its types (`(app.money AS numeric)`).
  */
 export const objectIdent = (o: { kind: CanonicalKind; schema?: string; name: string; signature?: string }): string =>
-  o.kind === "schema" || o.kind === "extension" || o.kind === "role"
+  o.kind === "cast"
+    ? o.name
+    : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.kind === "eventTrigger"
     ? quoteIdent(o.name)
     : o.kind === "trigger" || o.kind === "policy"
       ? `${quoteIdent(o.name)}${o.signature ?? ""}`
@@ -120,10 +123,16 @@ export const KIND_WORDS: Readonly<Record<CanonicalKind, string>> = {
   materializedView: "MATERIALIZED VIEW",
   sequence: "SEQUENCE",
   enum: "TYPE",
+  composite: "TYPE",
+  range: "TYPE",
   domain: "DOMAIN",
   extension: "EXTENSION",
   function: "FUNCTION",
   procedure: "PROCEDURE",
+  aggregate: "AGGREGATE",
+  collation: "COLLATION",
+  cast: "CAST",
+  eventTrigger: "EVENT TRIGGER",
   trigger: "TRIGGER",
   policy: "POLICY",
   role: "ROLE",
@@ -254,7 +263,12 @@ export function createSteps(
     // A table's row-level security is access, which only a profile that manages access applies.
     if (i > 0 && opts.access === false && firstNode(s)?.statement === "rowSecurity") return;
     let sql = s.text;
-    const replaceable = obj.canonical.kind === "view" || obj.canonical.kind === "function" || obj.canonical.kind === "procedure" || (obj.canonical.kind === "trigger" && obj.canonical.fields.constraint !== true);
+    const replaceable =
+      obj.canonical.kind === "view" ||
+      obj.canonical.kind === "function" ||
+      obj.canonical.kind === "procedure" ||
+      obj.canonical.kind === "aggregate" ||
+      (obj.canonical.kind === "trigger" && obj.canonical.fields.constraint !== true);
     if (i === 0 && opts.orReplace && replaceable && !/^\s*CREATE\s+OR\s+REPLACE\b/i.test(sql)) sql = sql.replace(/\bCREATE\s+/i, "CREATE OR REPLACE ");
     const concurrently = i === 0 && obj.canonical.kind === "index" && obj.props.concurrently === true;
     out.push({ ...step(sql, cls, opts.rule, !concurrently), ...(concurrently ? { buildsIndex: objectIdent(obj.canonical) } : {}) });
@@ -528,7 +542,7 @@ export const isRefused = (c: PgChange): boolean => c.class === "expand";
 export const isDestructive = (c: PgChange): boolean => c.rule === "SQLPG204";
 
 /** Changes that replace the object: drop it and create it again from its declaration. */
-export const isRecreate = (c: PgChange): boolean => c.rule === "SQLPG252" || c.rule === "SQLPG243" || c.rule === "SQLPG281";
+export const isRecreate = (c: PgChange): boolean => c.rule === "SQLPG252" || c.rule === "SQLPG243" || c.rule === "SQLPG281" || c.rule === "SQLPG300";
 
 /**
  * SET NOT NULL on a table that exists, without reading the table under
@@ -692,6 +706,7 @@ export function alterSteps(
         break;
       case "SQLPG250":
       case "SQLPG280":
+      case "SQLPG302":
         steps.push(...createSteps(obj, opts.marker, { orReplace: true, cls: c.class, rule: c.rule }).slice(0, 1));
         break;
       case "SQLPG291": {
@@ -872,11 +887,19 @@ const DROP_ORDER: Record<CanonicalKind, number> = {
   index: 3,
   table: 4,
   sequence: 5,
+  // An event trigger and a cast before the function they call; an aggregate before its functions.
+  eventTrigger: 5.5,
+  cast: 5.5,
+  aggregate: 5.5,
   // A routine after what calls it (a view, a trigger, a default), before the types its parameters use.
   function: 6,
   procedure: 6,
   domain: 7,
+  composite: 7.5,
+  range: 7.5,
   enum: 8,
+  // A collation after the types and columns that use it.
+  collation: 8.5,
   extension: 9,
   schema: 10,
   // A role is the cluster's: never dropped by a prune (`../live/catalog.ts` reads only the declared ones).

package/src/postgres/entities.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "vitest";
 import { isDeclarable } from "@intentius/chant/declarable";
 import { getInterpolationFields } from "@intentius/chant/provenance";
-import { domain, extension, index, isColumnRef, literal, schema, sequence, SqlTemplateError, table, type, view } from "./entities";
+import { domain, extension, index, isColumnRef, literal, schema, sequence, SqlTemplateError, table, type, view, type EnumProps } from "./entities";
 
 const app = schema`CREATE SCHEMA app`;
 const orderStatus = type`CREATE TYPE ${app}.order_status AS ENUM ('placed', 'paid')`;
@@ -121,7 +121,7 @@ describe("indexes, views and the rest", () => {
     const e = extension`CREATE EXTENSION IF NOT EXISTS citext WITH SCHEMA ${app} VERSION '1.6'`;
     expect(e.props).toMatchObject({ name: "citext", schema: "app", version: "1.6", ifNotExists: true });
     expect(e.dependsOn).toEqual([app]);
-    expect(orderStatus.props.labels).toEqual(["placed", "paid"]);
+    expect((orderStatus.props as EnumProps).labels).toEqual(["placed", "paid"]);
   });
 });
 

package/src/postgres/entities.ts

@@ -1,8 +1,9 @@
 /**
  * The Postgres entities: `schema`, `table`, `index`, `view`, `sequence`,
- * `type`, `domain`, `extension`, `func`, `procedure`, `trigger`, `policy`,
- * `role` and `grant` tagged templates that parse their DDL at fold time into
- * one Declarable each (chant #3278, #3279, #3680, #3681).
+ * `type` (enum, composite and range), `domain`, `extension`, `func`,
+ * `procedure`, `aggregate`, `trigger`, `eventTrigger`, `collation`, `cast`,
+ * `policy`, `role` and `grant` tagged templates that parse their DDL at fold
+ * time into one Declarable each (chant #3278, #3279, #3680, #3681, #3911).
  *
  * ```ts
  * import { schema, table, index } from "@intentius/chant-lexicon-sql/postgres";
@@ -56,7 +57,7 @@
 import type { AttrRef } from "@intentius/chant/attrref";
 import { setInterpolationFields } from "@intentius/chant/provenance";
 import { isTrivia, POSTGRES_LEXICAL, SqlSyntaxError, untokenize, type Token } from "./tokens";
-import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode } from "./parser";
+import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type DefElem, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode } from "./parser";
 import { keywordCategory, quoteIdent } from "./keywords";
 import { feed, lineage, spanText as text, splice as spliceWith, templateSyntaxError, unparsedClauses, type TemplateCtx, type TemplateDialect, type UnparsedClause } from "../core/interpolation";
 import { SqlObject, isColumnRefOf, isSqlObjectOf, makeSqlEntity } from "../core/entity";
@@ -260,6 +261,86 @@ export interface EnumProps extends CommonProps {
   labels: string[];
 }
 
+/** A composite type's attribute, as written. */
+export interface CompositeAttributeDef {
+  name: string;
+  type: string;
+  collate?: string;
+}
+
+export interface CompositeTypeProps extends CommonProps {
+  attributes: CompositeAttributeDef[];
+}
+
+export interface RangeTypeProps extends CommonProps {
+  /** `SUBTYPE`: the element type. */
+  subtype: string;
+  subtypeOpclass?: string;
+  collation?: string;
+  /** `CANONICAL`: the function that canonicalizes a value (a C function). */
+  canonical?: string;
+  subtypeDiff?: string;
+  /** `MULTIRANGE_TYPE_NAME`: the multirange type's name, when it is not the one Postgres derives. */
+  multirangeTypeName?: string;
+}
+
+/** One argument of an aggregate, as written. */
+export interface AggregateArgDef {
+  /** `in` when not written. */
+  mode: "in" | "variadic";
+  name?: string;
+  type: string;
+}
+
+export interface AggregateProps extends CommonProps {
+  orReplace?: boolean;
+  /** The arguments; empty for `(*)`. An ordered-set aggregate's direct arguments. */
+  args: AggregateArgDef[];
+  /** An ordered-set aggregate's aggregated arguments (`ORDER BY ...`). */
+  orderBy?: AggregateArgDef[];
+  /**
+   * The definition: each option by its name, folded (`sfunc`, `stype`,
+   * `initcond`), to its value as written; an option given without a value
+   * (`HYPOTHETICAL`, `FINALFUNC_EXTRA`) to `true`.
+   */
+  options: Record<string, string>;
+}
+
+export interface CollationProps extends CommonProps {
+  ifNotExists?: boolean;
+  /** Each option by its name, folded (`provider`, `locale`, `deterministic`), to its value as written. */
+  options: Record<string, string>;
+}
+
+export interface CastProps extends Omit<CommonProps, "schema"> {
+  /** `(source AS target)`: a cast is named by its two types and lives in no schema. */
+  name: string;
+  /** The source type as written. */
+  sourceType: string;
+  /** The target type as written. */
+  targetType: string;
+  /** `WITH FUNCTION` (`function`), `WITHOUT FUNCTION` (`binary`) or `WITH INOUT` (`inout`). */
+  method: "function" | "binary" | "inout";
+  /** The cast function: the entity when interpolated, else its name. */
+  function?: PostgresObject | string;
+  /** The cast function's SQL name. */
+  functionName?: string;
+  /** The cast function's parameter types, when written. */
+  functionArgs?: string;
+  /** `explicit` (the default), `AS ASSIGNMENT` or `AS IMPLICIT`. */
+  context: "explicit" | "assignment" | "implicit";
+}
+
+export interface EventTriggerProps extends Omit<CommonProps, "schema"> {
+  /** `ddl_command_start`, `ddl_command_end`, `sql_drop`, `table_rewrite` or `login`. */
+  event: string;
+  /** `WHEN TAG IN (...)`: the command tags it fires for; every one when absent. */
+  tags?: string[];
+  /** The function it executes: the entity when interpolated, else its name. */
+  function: PostgresObject | string;
+  functionName: string;
+}
+
 export interface DomainProps extends CommonProps {
   /** The underlying data type. */
   dataType: string;
@@ -488,11 +569,44 @@ export interface PostgresEnum extends PostgresObject {
   readonly props: EnumProps;
 }
 
+export interface PostgresCompositeType extends PostgresObject {
+  readonly entityType: "Postgres::CompositeType";
+  readonly props: CompositeTypeProps;
+}
+
+export interface PostgresRangeType extends PostgresObject {
+  readonly entityType: "Postgres::RangeType";
+  readonly props: RangeTypeProps;
+}
+
+/** What the `type` tag declares: an enum, a composite or a range type. */
+export type PostgresType = PostgresEnum | PostgresCompositeType | PostgresRangeType;
+
 export interface PostgresDomain extends PostgresObject {
   readonly entityType: "Postgres::Domain";
   readonly props: DomainProps;
 }
 
+export interface PostgresAggregate extends PostgresObject {
+  readonly entityType: "Postgres::Aggregate";
+  readonly props: AggregateProps;
+}
+
+export interface PostgresCollation extends PostgresObject {
+  readonly entityType: "Postgres::Collation";
+  readonly props: CollationProps;
+}
+
+export interface PostgresCast extends PostgresObject {
+  readonly entityType: "Postgres::Cast";
+  readonly props: CastProps;
+}
+
+export interface PostgresEventTrigger extends PostgresObject {
+  readonly entityType: "Postgres::EventTrigger";
+  readonly props: EventTriggerProps;
+}
+
 export interface PostgresExtension extends PostgresObject {
   readonly entityType: "Postgres::Extension";
   readonly props: ExtensionProps;
@@ -637,23 +751,46 @@ export const POSTGRES_TEMPLATES: TemplateDialect = {
 
 type Ctx = TemplateCtx;
 
-export type PostgresTag = "schema" | "table" | "index" | "view" | "sequence" | "type" | "domain" | "extension" | "func" | "procedure" | "trigger" | "policy" | "role" | "grant";
-
-const STATEMENT_OF: Record<PostgresTag, StatementNode["statement"]> = {
-  schema: "schema",
-  table: "table",
-  index: "index",
-  view: "view",
-  sequence: "sequence",
-  type: "enum",
-  domain: "domain",
-  extension: "extension",
-  func: "function",
-  procedure: "procedure",
-  trigger: "trigger",
-  policy: "policy",
-  role: "role",
-  grant: "grant",
+export type PostgresTag =
+  | "schema"
+  | "table"
+  | "index"
+  | "view"
+  | "sequence"
+  | "type"
+  | "domain"
+  | "extension"
+  | "func"
+  | "procedure"
+  | "aggregate"
+  | "trigger"
+  | "eventTrigger"
+  | "collation"
+  | "cast"
+  | "policy"
+  | "role"
+  | "grant";
+
+/** The statements each tag holds. */
+export const STATEMENTS_OF: Record<PostgresTag, readonly StatementNode["statement"][]> = {
+  schema: ["schema"],
+  table: ["table"],
+  index: ["index"],
+  view: ["view"],
+  sequence: ["sequence"],
+  type: ["enum", "composite", "range"],
+  domain: ["domain"],
+  extension: ["extension"],
+  func: ["function"],
+  procedure: ["procedure"],
+  aggregate: ["aggregate"],
+  trigger: ["trigger"],
+  eventTrigger: ["eventTrigger"],
+  collation: ["collation"],
+  cast: ["cast"],
+  policy: ["policy"],
+  role: ["role"],
+  grant: ["grant"],
 };
 
 const TAG_OF: Record<StatementNode["statement"], PostgresTag | undefined> = {
@@ -663,11 +800,17 @@ const TAG_OF: Record<StatementNode["statement"], PostgresTag | undefined> = {
   view: "view",
   sequence: "sequence",
   enum: "type",
+  composite: "type",
+  range: "type",
   domain: "domain",
   extension: "extension",
   function: "func",
   procedure: "procedure",
+  aggregate: "aggregate",
   trigger: "trigger",
+  eventTrigger: "eventTrigger",
+  collation: "collation",
+  cast: "cast",
   policy: "policy",
   role: "role",
   grant: "grant",
@@ -683,11 +826,17 @@ export const STATEMENT_NAMES: Record<StatementNode["statement"], string> = {
   view: "CREATE VIEW",
   sequence: "CREATE SEQUENCE",
   enum: "CREATE TYPE",
+  composite: "CREATE TYPE",
+  range: "CREATE TYPE",
   domain: "CREATE DOMAIN",
   extension: "CREATE EXTENSION",
   function: "CREATE FUNCTION",
   procedure: "CREATE PROCEDURE",
+  aggregate: "CREATE AGGREGATE",
   trigger: "CREATE TRIGGER",
+  eventTrigger: "CREATE EVENT TRIGGER",
+  collation: "CREATE COLLATION",
+  cast: "CREATE CAST",
   policy: "CREATE POLICY",
   role: "CREATE ROLE",
   grant: "GRANT",
@@ -715,6 +864,13 @@ export function stringValue(s: string | undefined): string | undefined {
   return s;
 }
 
+/** A definition list's values, by option name: each value as written, interpolations rendered; an option with no value is `true`. */
+function definitionValues(ctx: Ctx, elems: readonly DefElem[], path: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const e of elems) out[e.name] = e.value ? req(text(ctx, e.value, path)) : "true";
+  return out;
+}
+
 /** A qualified name's schema and name. An interpolated schema names the schema; an interpolated object gives both. */
 function qualified(ctx: Ctx, n: NameNode): { schema?: string; name: string } {
   const pieces: string[] = [];
@@ -926,7 +1082,12 @@ function applyComments(
       if (value !== undefined) constraint!.comment = value;
     } else {
       if (!objectTypes.includes(c.objectType)) refuse(c, `does not comment on the ${tag} this template declares`);
-      if (c.objectType === "TRIGGER" || c.objectType === "POLICY") {
+      if (c.objectType === "CAST") {
+        // `COMMENT ON CAST (source AS target)`: the two types, as the CREATE CAST writes them.
+        const loose = (x: string) => x.toLowerCase().replace(/\s+/g, " ").replace(/\s*([(),.])\s*/g, "$1");
+        const named = `(${req(text(ctx, c.cast!.source))} AS ${req(text(ctx, c.cast!.target))})`;
+        if (loose(named) !== loose(self.name)) refuse(c, `names another cast than ${self.name}`);
+      } else if (c.objectType === "TRIGGER" || c.objectType === "POLICY") {
         // `COMMENT ON TRIGGER name ON table`: the name is the trigger's, the table its own.
         if (qualified(ctx, c.target).name !== self.name || !c.on || !isSelf({ ...qualified(ctx, c.on), name: self.name })) refuse(c, `names another ${c.objectType.toLowerCase()} than ${self.name}`);
       } else if (!isSelf(qualified(ctx, c.target))) refuse(c, `names another object than ${sqlNameOf(self)}`);
@@ -1152,7 +1313,7 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
     throw templateSyntaxError(tag, parts, err);
   }
   const [node, ...rest] = nodes as [StatementNode, ...StatementNode[]];
-  if (node.statement !== STATEMENT_OF[tag]) {
+  if (!STATEMENTS_OF[tag].includes(node.statement)) {
     const holds = STATEMENT_NAMES[node.statement];
     const use = TAG_OF[node.statement];
     throw new SqlTemplateError(
@@ -1194,9 +1355,9 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
   const dependsOn = [...new Set([...values, ...(joined?.refs ?? [])].filter((v) => isPostgresObject(v) || isColumnRef(v)))];
   const slots: TypedSlot[] = [];
   const unparsed = unparsedClauses(ctx, nodes.flatMap((n) => ("unknown" in n && n.unknown ? n.unknown : [])));
-  const make = <T extends PostgresObject>(type: PostgresEntityType, q: { schema?: string; name: string }, props: object, columnNames?: readonly string[]): T => {
+  const make = <T extends PostgresObject>(type: PostgresEntityType, q: { schema?: string; name: string }, props: object, columnNames?: readonly string[], sqlName = sqlNameOf(q)): T => {
     if (unparsed) (props as { unparsed?: UnparsedClause[] }).unparsed = unparsed;
-    const entity = makeSqlEntity(PostgresObject.prototype as PostgresObject, type, sqlNameOf(q), props, columnNames, dependsOn) as T;
+    const entity = makeSqlEntity(PostgresObject.prototype as PostgresObject, type, sqlName, props, columnNames, dependsOn) as T;
     const fed = ctx.fed.map((paths) => [...paths].sort());
     if (!joined) setInterpolationFields(entity, fed);
     else {
@@ -1239,6 +1400,99 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
       const props: EnumProps = stripUnset({ ...q, labels: node.labels.map((l) => req(stringValue(text(ctx, l, "labels")))), comment, ddl, source });
       return make(POSTGRES_ENTITY_TYPES.enum, q, props);
     }
+    case "composite": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["TYPE"]);
+      const attributes = node.attributes.map((a) => {
+        feed(ctx, a.nameSpan, "attributes");
+        return stripUnset({ name: columnName(ctx, { name: a.name, span: a.nameSpan }), type: req(text(ctx, a.type, "attributes")), collate: text(ctx, a.collate, "attributes") }) as CompositeAttributeDef;
+      });
+      const props: CompositeTypeProps = strip({ ...q, attributes, comment, ddl, source }, ["attributes"]);
+      return make(POSTGRES_ENTITY_TYPES.composite, q, props);
+    }
+    case "range": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["TYPE"]);
+      const opt = definitionValues(ctx, node.options, "options");
+      const props: RangeTypeProps = stripUnset({
+        ...q,
+        subtype: req(opt.subtype),
+        subtypeOpclass: opt.subtype_opclass,
+        collation: opt.collation,
+        canonical: opt.canonical,
+        subtypeDiff: opt.subtype_diff,
+        multirangeTypeName: opt.multirange_type_name,
+        comment,
+        ddl,
+        source,
+      });
+      return make(POSTGRES_ENTITY_TYPES.range, q, props);
+    }
+    case "aggregate": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["AGGREGATE"]);
+      const arg = (a: (typeof node.args)[number]): AggregateArgDef => stripUnset({ mode: (a.mode?.toLowerCase() ?? "in") as AggregateArgDef["mode"], name: a.name, type: req(text(ctx, a.type, "args")) });
+      const props: AggregateProps = strip(
+        {
+          ...q,
+          orReplace: node.orReplace || undefined,
+          args: node.args.map(arg),
+          orderBy: node.orderBy?.map(arg),
+          options: definitionValues(ctx, node.options, "options"),
+          comment,
+          ddl,
+          source,
+        },
+        ["args"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.aggregate, q, props);
+    }
+    case "collation": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["COLLATION"]);
+      const props: CollationProps = stripUnset({ ...q, ifNotExists: node.ifNotExists || undefined, options: definitionValues(ctx, node.options, "options"), comment, ddl, source });
+      return make(POSTGRES_ENTITY_TYPES.collation, q, props);
+    }
+    case "cast": {
+      const sourceType = req(text(ctx, node.source, "sourceType"));
+      const targetType = req(text(ctx, node.target, "targetType"));
+      const name = `(${sourceType} AS ${targetType})`;
+      const comment = applyComments(tag, ctx, comments, { name }, ["CAST"]);
+      const props: CastProps = stripUnset({
+        name,
+        sourceType,
+        targetType,
+        method: node.method,
+        function: node.function ? target(ctx, node.function) : undefined,
+        functionName: node.function ? targetName(ctx, node.function) : undefined,
+        functionArgs: node.functionArgs ? text(ctx, node.functionArgs, "functionArgs") : undefined,
+        context: node.context,
+        comment,
+        ddl,
+        source,
+      });
+      return make(POSTGRES_ENTITY_TYPES.cast, { name }, props, undefined, name);
+    }
+    case "eventTrigger": {
+      const name = node.name.pieces[0] || identValue(req(text(ctx, node.name.span)));
+      feed(ctx, node.name.span, "name");
+      const comment = applyComments(tag, ctx, comments, { name }, ["EVENT TRIGGER"]);
+      const tags = node.filters.flatMap((f) => f.values.map((v) => req(stringValue(text(ctx, v, "tags")))));
+      const props: EventTriggerProps = strip(
+        {
+          name,
+          event: node.event.name || identValue(req(text(ctx, node.event.span, "event"))),
+          tags: tags.length > 0 ? tags : undefined,
+          function: target(ctx, node.function),
+          functionName: targetName(ctx, node.function),
+          comment,
+          ddl,
+          source,
+        },
+        [],
+      );
+      return make(POSTGRES_ENTITY_TYPES.eventTrigger, { name }, props);
+    }
     case "domain": {
       const q = qualified(ctx, node.name);
       const checks = node.checks.map((c) => stripUnset({ name: c.name, expr: req(text(ctx, c.expr, "checks")), notValid: c.notValid }) as CheckDef);
@@ -1644,9 +1898,13 @@ export function sequence(strings: TemplateStringsArray, ...values: unknown[]): P
   return build("sequence", strings, values) as PostgresSequence;
 }
 
-/** `` type`CREATE TYPE name AS ENUM (...)` ``: one enum type. */
-export function type(strings: TemplateStringsArray, ...values: unknown[]): PostgresEnum {
-  return build("type", strings, values) as PostgresEnum;
+/**
+ * `` type`CREATE TYPE name AS ENUM (...)` ``: one enum type; `AS (attribute
+ * type, ...)` a composite type, `AS RANGE (SUBTYPE = ...)` a range type (and
+ * its multirange type, which Postgres creates with it).
+ */
+export function type(strings: TemplateStringsArray, ...values: unknown[]): PostgresType {
+  return build("type", strings, values) as PostgresType;
 }
 
 /** `` domain`CREATE DOMAIN ...` ``: one domain. */
@@ -1673,6 +1931,36 @@ export function procedure(strings: TemplateStringsArray, ...values: unknown[]):
   return build("procedure", strings, values) as PostgresProcedure;
 }
 
+/**
+ * `` aggregate`CREATE [OR REPLACE] AGGREGATE name(argtype, ...) (SFUNC = ..., STYPE = ...)` ``:
+ * one aggregate, identified, as a function is, by its argument types.
+ */
+export function aggregate(strings: TemplateStringsArray, ...values: unknown[]): PostgresAggregate {
+  return build("aggregate", strings, values) as PostgresAggregate;
+}
+
+/** `` collation`CREATE COLLATION name (provider = icu, locale = '...')` ``: one collation. */
+export function collation(strings: TemplateStringsArray, ...values: unknown[]): PostgresCollation {
+  return build("collation", strings, values) as PostgresCollation;
+}
+
+/**
+ * `` cast`CREATE CAST (source AS target) WITH FUNCTION ${fn}(source) [AS ASSIGNMENT | AS IMPLICIT]` ``:
+ * one cast, named by its two types. Creating one takes owning the source or
+ * the target type.
+ */
+export function cast(strings: TemplateStringsArray, ...values: unknown[]): PostgresCast {
+  return build("cast", strings, values) as PostgresCast;
+}
+
+/**
+ * `` eventTrigger`CREATE EVENT TRIGGER name ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION ${fn}()` ``:
+ * one event trigger, the database's (no schema). Creating one takes a superuser.
+ */
+export function eventTrigger(strings: TemplateStringsArray, ...values: unknown[]): PostgresEventTrigger {
+  return build("eventTrigger", strings, values) as PostgresEventTrigger;
+}
+
 /** `` trigger`CREATE [OR REPLACE] [CONSTRAINT] TRIGGER name ... ON ${table} ... EXECUTE FUNCTION ${fn}()` ``: one trigger on its table. */
 export function trigger(strings: TemplateStringsArray, ...values: unknown[]): PostgresTrigger {
   return build("trigger", strings, values) as PostgresTrigger;

package/src/postgres/entity-types.ts

@@ -11,7 +11,13 @@ export const POSTGRES_ENTITY_TYPES = {
   materializedView: "Postgres::MaterializedView",
   sequence: "Postgres::Sequence",
   enum: "Postgres::Enum",
+  composite: "Postgres::CompositeType",
+  range: "Postgres::RangeType",
   domain: "Postgres::Domain",
+  aggregate: "Postgres::Aggregate",
+  collation: "Postgres::Collation",
+  cast: "Postgres::Cast",
+  eventTrigger: "Postgres::EventTrigger",
   extension: "Postgres::Extension",
   function: "Postgres::Function",
   procedure: "Postgres::Procedure",