@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/postgres/plan/report.js

@@ -0,0 +1,21 @@
+/** A Postgres schema diff as text (the shared core's report, with the refusal of expand-and-contract changes). */
+import { renderChangeSet } from "../../core/classifier.js";
+import { PG_CHANGE_CLASSES, PG_CLASSIFIER_RULES } from "./rules.js";
+import { renderMigrationOpSuggestions } from "../migrate/handoff.js";
+export function renderPgDiff(diff, opts = {}) {
+    const rewrites = diff.changes.filter((c) => c.class === "rewrite").length;
+    const trailer = [
+        ...(rewrites > 0
+            ? ["", `Warning: ${rewrites} change(s) rewrite or read a table under ACCESS EXCLUSIVE, which blocks its reads and writes until done; the rule names the form that does not.`]
+            : []),
+        ...(diff.refused.length > 0
+            ? [
+                "",
+                `Refused: ${diff.refused.length} change(s) keep no old reader working when made in place. Each runs as expand and contract ` +
+                    "(add the new, write both, backfill, move readers, drop the old), as a migration Op, not as one statement.",
+                ...renderMigrationOpSuggestions(diff.migrationOps ?? []),
+            ]
+            : []),
+    ];
+    return renderChangeSet(diff, { ...(opts.title ? { title: opts.title } : {}), rules: PG_CLASSIFIER_RULES, classes: PG_CHANGE_CLASSES, trailer });
+}

package/dist/postgres/plan/rules.js

@@ -0,0 +1,115 @@
+/**
+ * The Postgres change classifier's rules (#3279, #3275 question 3): every way
+ * a declared Postgres object can change, the class of change it is on the
+ * server, and the restriction behind the class, cited from the Postgres 18
+ * documentation (the pinned major), with the differences across the
+ * supported majors 14 to 18 stated where there are any.
+ *
+ * The classes are by the lock a change takes and whether it reads or
+ * rewrites the table ("Explicit Locking", `ALTER TABLE`'s Notes):
+ *
+ * - `metadata`: a catalog change under a brief lock; no row is read or
+ *   written. Most `ALTER TABLE` forms take `ACCESS EXCLUSIVE` even so, which
+ *   queues behind every running query, so the applier (#3280) sets a
+ *   `lock_timeout`.
+ * - `validate`: every row is read to check a constraint, under a lock weaker
+ *   than `ACCESS EXCLUSIVE` (`SHARE UPDATE EXCLUSIVE` for `VALIDATE
+ *   CONSTRAINT`, so reads and writes go on).
+ * - `concurrently`: an index build, which blocks writes for its whole run
+ *   unless it is `CONCURRENTLY`, and `CONCURRENTLY` cannot run inside a
+ *   transaction block.
+ * - `rewrite`: the table is rewritten, or read in full, under `ACCESS
+ *   EXCLUSIVE`, blocking reads and writes for the duration.
+ * - `expand`: no in-place change keeps old readers working (a rename, a type
+ *   change with no cast in place, a change of partitioning): it is made as
+ *   expand and contract, by the migration Op (#3281). A plan refuses it.
+ *
+ * Creating and dropping whole objects are classed `create` and `drop`.
+ */
+import { classifierRule } from "../../core/classifier.js";
+export const PG_CHANGE_CLASSES = {
+    order: ["create", "metadata", "validate", "concurrently", "rewrite", "expand", "drop"],
+    label: {
+        create: "create",
+        metadata: "metadata only",
+        validate: "validates under a weaker lock",
+        concurrently: "needs CONCURRENTLY",
+        rewrite: "ACCESS EXCLUSIVE rewrite or scan",
+        expand: "EXPAND AND CONTRACT",
+        drop: "drop",
+    },
+    disruption: { create: "in-place", metadata: "in-place", validate: "rolling", concurrently: "rolling", rewrite: "rolling", expand: "replace", drop: "destroy" },
+};
+const DOCS = "https://www.postgresql.org/docs/18";
+const ALTER_TABLE = `${DOCS}/sql-altertable.html`;
+const LOCKING = `${DOCS}/explicit-locking.html`;
+const CREATE_INDEX = `${DOCS}/sql-createindex.html#SQL-CREATEINDEX-CONCURRENTLY`;
+const rule = (id, cls, title, restriction, cite) => classifierRule(id, cls, title, restriction, cite);
+export const PG_CLASSIFIER_RULES = {
+    SQLPG200: rule("SQLPG200", "create", "Create an object", "A new object is created; nothing existing changes. A table created in the same plan as its indexes needs no CONCURRENTLY.", `${DOCS}/sql-createtable.html`),
+    SQLPG201: rule("SQLPG201", "metadata", "Add a column", "ADD COLUMN with no default, or with a non-volatile default, changes only the catalog under ACCESS EXCLUSIVE: the default is stored once and read for existing rows (since 11, so in every supported major). A NOT NULL column needs that default.", ALTER_TABLE),
+    SQLPG202: rule("SQLPG202", "rewrite", "Add a column whose value has to be computed for every row", "ADD COLUMN with a volatile default (clock_timestamp(), random(), gen_random_uuid(), nextval()), a STORED generated column or an identity column rewrites the whole table under ACCESS EXCLUSIVE. A VIRTUAL generated column (18) does not.", ALTER_TABLE),
+    SQLPG203: rule("SQLPG203", "expand", "Add a NOT NULL column with no default", "ADD COLUMN ... NOT NULL with no default fails on a table that has rows. Add it nullable, backfill it, then set NOT NULL.", ALTER_TABLE),
+    SQLPG204: rule("SQLPG204", "metadata", "Drop a column", "DROP COLUMN only hides the column in the catalog under ACCESS EXCLUSIVE; its space is reclaimed as rows are rewritten. The data is gone.", ALTER_TABLE),
+    SQLPG205: rule("SQLPG205", "expand", "Rename a column", "RENAME COLUMN is a catalog change, but every reader still using the old name fails the moment it runs: add the new column, write both, move readers, drop the old.", ALTER_TABLE),
+    SQLPG206: rule("SQLPG206", "metadata", "Change a column's type without a rewrite", "ALTER COLUMN TYPE to a binary-coercible type (varchar(n) to a longer varchar or to text, numeric(p,s) to a wider precision or to unconstrained numeric, cidr to inet) needs no rewrite; indexes on the column may still be rebuilt. ACCESS EXCLUSIVE, briefly.", ALTER_TABLE),
+    SQLPG207: rule("SQLPG207", "rewrite", "Change a column's type with a rewrite", "ALTER COLUMN TYPE that is not binary-coercible (integer to bigint, a shorter varchar, real to double precision) rewrites the table and rebuilds its indexes under ACCESS EXCLUSIVE.", ALTER_TABLE),
+    SQLPG208: rule("SQLPG208", "expand", "Change a column's type across kinds", "A type change between kinds (text to integer, a type to an enum) needs a USING expression and breaks readers that expect the old type: add the new column, backfill, move readers, drop the old.", ALTER_TABLE),
+    SQLPG209: rule("SQLPG209", "metadata", "Change a column's default", "SET DEFAULT and DROP DEFAULT change only the catalog; existing rows keep their values.", ALTER_TABLE),
+    SQLPG210: rule("SQLPG210", "validate", "Set NOT NULL", "SET NOT NULL alone reads the whole table under ACCESS EXCLUSIVE, unless a valid CHECK (column IS NOT NULL) constraint already proves it (since 12). So it is made as four statements: that check added NOT VALID, validated under SHARE UPDATE EXCLUSIVE while writes go on, SET NOT NULL, which the check proves without a scan, and the check dropped. Rows where the column is NULL fail the validation; the first statement's pre-check counts them.", ALTER_TABLE),
+    SQLPG211: rule("SQLPG211", "metadata", "Drop NOT NULL", "DROP NOT NULL changes only the catalog.", ALTER_TABLE),
+    SQLPG212: rule("SQLPG212", "rewrite", "Change a generated column's expression", "ALTER COLUMN SET EXPRESSION (17 and later) rewrites a STORED generated column under ACCESS EXCLUSIVE; on 14 to 16 the column has to be dropped and added. A VIRTUAL column (18) changes only the catalog.", ALTER_TABLE),
+    SQLPG213: rule("SQLPG213", "metadata", "Change a column's identity", "ADD, SET and DROP IDENTITY change the column's sequence and the catalog, not the rows.", ALTER_TABLE),
+    SQLPG214: rule("SQLPG214", "rewrite", "Change a column's collation", "A collation change is ALTER COLUMN TYPE with COLLATE: the column's indexes are rebuilt under ACCESS EXCLUSIVE.", ALTER_TABLE),
+    SQLPG215: rule("SQLPG215", "metadata", "Change a column's storage or compression", "SET STORAGE and SET COMPRESSION apply to values written afterwards; existing values are not rewritten.", ALTER_TABLE),
+    SQLPG216: rule("SQLPG216", "metadata", "Change a comment", "COMMENT ON changes only the catalog.", `${DOCS}/sql-comment.html`),
+    SQLPG217: rule("SQLPG217", "metadata", "Add a constraint NOT VALID", "ADD CONSTRAINT ... NOT VALID checks new rows only and reads none of the existing ones; a foreign key takes SHARE ROW EXCLUSIVE on both tables, briefly. Validate it as a separate step.", ALTER_TABLE),
+    SQLPG218: rule("SQLPG218", "validate", "Add a CHECK constraint", "ADD CONSTRAINT ... CHECK alone reads every row under ACCESS EXCLUSIVE. On a table that exists it is made as two statements: the check added NOT VALID (SQLPG217), which reads no rows, then VALIDATE CONSTRAINT (SQLPG220) in a transaction of its own, which reads them under SHARE UPDATE EXCLUSIVE while writes go on. Rows the check refuses fail the validation; the first statement's pre-check counts them.", ALTER_TABLE),
+    SQLPG219: rule("SQLPG219", "validate", "Add a foreign key", "ADD FOREIGN KEY alone reads every row under SHARE ROW EXCLUSIVE on both tables, which blocks writes to them for the scan. On a table that exists it is made as two statements: the key added NOT VALID (SQLPG217), which takes that lock briefly and reads no rows, then VALIDATE CONSTRAINT (SQLPG220) in a transaction of its own, which reads them under SHARE UPDATE EXCLUSIVE while writes go on. Orphan rows fail the validation; the first statement's pre-check counts them.", ALTER_TABLE),
+    SQLPG220: rule("SQLPG220", "validate", "Validate a constraint", "VALIDATE CONSTRAINT reads every row under SHARE UPDATE EXCLUSIVE, so reads and writes go on (ROW SHARE on a foreign key's referenced table).", LOCKING),
+    SQLPG221: rule("SQLPG221", "concurrently", "Add a primary key or unique constraint", "ADD PRIMARY KEY or UNIQUE builds its index under ACCESS EXCLUSIVE. Build the unique index CONCURRENTLY first, then ADD CONSTRAINT ... USING INDEX, which changes only the catalog.", ALTER_TABLE),
+    SQLPG222: rule("SQLPG222", "rewrite", "Add an exclusion constraint", "ADD CONSTRAINT ... EXCLUDE builds its index under ACCESS EXCLUSIVE; there is no concurrent form.", ALTER_TABLE),
+    SQLPG223: rule("SQLPG223", "metadata", "Drop a constraint", "DROP CONSTRAINT changes the catalog under ACCESS EXCLUSIVE, briefly; a primary key's or unique constraint's index goes with it.", ALTER_TABLE),
+    SQLPG224: rule("SQLPG224", "metadata", "Change storage parameters", "SET and RESET of storage parameters change the catalog; fillfactor and the autovacuum parameters take only SHARE UPDATE EXCLUSIVE. Rows are not rewritten; a new fillfactor applies to pages written afterwards.", ALTER_TABLE),
+    SQLPG225: rule("SQLPG225", "rewrite", "Make a table LOGGED or UNLOGGED", "SET LOGGED and SET UNLOGGED rewrite the table under ACCESS EXCLUSIVE.", ALTER_TABLE),
+    SQLPG226: rule("SQLPG226", "rewrite", "Change a table's access method or tablespace", "SET ACCESS METHOD (15 and later) and SET TABLESPACE rewrite the table under ACCESS EXCLUSIVE.", ALTER_TABLE),
+    SQLPG227: rule("SQLPG227", "expand", "Change partitioning or inheritance", "A table's partition key, its parent or bound, INHERITS and OF type cannot be altered in place: a new table is filled and swapped in. DETACH PARTITION CONCURRENTLY (14 and later) and ATTACH PARTITION, which takes SHARE UPDATE EXCLUSIVE on the parent, are the steps.", `${DOCS}/ddl-partitioning.html`),
+    SQLPG228: rule("SQLPG228", "expand", "Rename an object or move it to another schema", "RENAME and SET SCHEMA are catalog changes, but every reader still using the old name fails at once: create the new name (a view over the old object works), move readers, drop the old.", ALTER_TABLE),
+    SQLPG229: rule("SQLPG229", "metadata", "Rename an index", "ALTER INDEX ... RENAME changes only the catalog; nothing reads an index by name.", `${DOCS}/sql-alterindex.html`),
+    SQLPG240: rule("SQLPG240", "concurrently", "Create an index CONCURRENTLY", "CREATE INDEX CONCURRENTLY builds the index without blocking writes (SHARE UPDATE EXCLUSIVE), in two scans, and cannot run inside a transaction block; a failed build leaves an INVALID index to drop.", CREATE_INDEX),
+    SQLPG241: rule("SQLPG241", "concurrently", "Create an index without CONCURRENTLY", "CREATE INDEX on an existing table takes SHARE, which blocks every write to the table until the build ends. Declare it CONCURRENTLY.", CREATE_INDEX),
+    SQLPG242: rule("SQLPG242", "concurrently", "Drop an index", "DROP INDEX takes ACCESS EXCLUSIVE on the table; DROP INDEX CONCURRENTLY waits for running queries instead, and cannot run inside a transaction block.", `${DOCS}/sql-dropindex.html`),
+    SQLPG243: rule("SQLPG243", "concurrently", "Change an index", "An index's definition cannot be altered: it is dropped and created, both CONCURRENTLY to keep writes going (SQLPG240, SQLPG242).", CREATE_INDEX),
+    SQLPG250: rule("SQLPG250", "metadata", "Change a view's query, keeping its columns", "CREATE OR REPLACE VIEW replaces the query under ACCESS EXCLUSIVE on the view when the new query keeps the old columns, by name, in order, and only appends new ones.", `${DOCS}/sql-createview.html`),
+    SQLPG251: rule("SQLPG251", "expand", "Change a view's columns", "A view whose columns are removed, renamed or reordered cannot be replaced: it is dropped and created, and every view and reader on top of it with it.", `${DOCS}/sql-createview.html`),
+    SQLPG252: rule("SQLPG252", "rewrite", "Change a materialized view's query", "A materialized view's query cannot be altered: it is dropped and created, and its rows are computed again, with every view on top of it dropped too.", `${DOCS}/sql-creatematerializedview.html`),
+    SQLPG253: rule("SQLPG253", "metadata", "Change a view's options", "ALTER VIEW ... SET (check_option, security_barrier, security_invoker) changes only the catalog.", `${DOCS}/sql-alterview.html`),
+    SQLPG260: rule("SQLPG260", "metadata", "Add an enum label", "ALTER TYPE ... ADD VALUE changes only the catalog; since 12 it can run in a transaction block, but the new label cannot be used in that transaction.", `${DOCS}/sql-altertype.html`),
+    SQLPG261: rule("SQLPG261", "expand", "Remove or reorder enum labels", "An enum label cannot be removed and labels cannot be reordered in place: a new type is created, columns are moved to it, and the old one is dropped.", `${DOCS}/sql-altertype.html`),
+    SQLPG262: rule("SQLPG262", "validate", "Add a domain constraint", "ALTER DOMAIN ADD CONSTRAINT (and SET NOT NULL) checks every column of the domain's type in every table; ADD CONSTRAINT ... NOT VALID skips existing rows and VALIDATE CONSTRAINT checks them later.", `${DOCS}/sql-alterdomain.html`),
+    SQLPG263: rule("SQLPG263", "metadata", "Change a domain's default or drop its constraint", "ALTER DOMAIN SET DEFAULT, DROP NOT NULL and DROP CONSTRAINT change only the catalog.", `${DOCS}/sql-alterdomain.html`),
+    SQLPG264: rule("SQLPG264", "expand", "Change a domain's data type", "A domain's underlying type cannot be altered: a new domain is created and columns are moved to it.", `${DOCS}/sql-alterdomain.html`),
+    SQLPG265: rule("SQLPG265", "metadata", "Change a sequence's options", "ALTER SEQUENCE changes the sequence's own row; tables are not touched. A sequence's AS type bounds its values.", `${DOCS}/sql-altersequence.html`),
+    SQLPG266: rule("SQLPG266", "metadata", "Change an extension's version or schema", "ALTER EXTENSION UPDATE runs the extension's update script, which may itself alter objects; SET SCHEMA moves its objects.", `${DOCS}/sql-alterextension.html`),
+    SQLPG267: rule("SQLPG267", "metadata", "Change a schema's owner", "ALTER SCHEMA ... OWNER TO changes only the catalog.", `${DOCS}/sql-alterschema.html`),
+    SQLPG268: rule("SQLPG268", "expand", "Change an object's kind", "A view and a materialized view, or a table and either, are different kinds of object: the old one is dropped and the new one created.", `${DOCS}/sql-createview.html`),
+    SQLPG280: rule("SQLPG280", "metadata", "Replace a function's or procedure's definition", "CREATE OR REPLACE FUNCTION (or PROCEDURE) replaces the body and attributes in the catalog; it locks no table, and a call already running finishes with the old definition. The parameter types, the result and the input parameters' names have to stay the same.", `${DOCS}/sql-createfunction.html`),
+    SQLPG281: rule("SQLPG281", "metadata", "Drop and create a function or procedure", "CREATE OR REPLACE refuses a change of the result type, the output parameters, an input parameter's name, a removed parameter default or the routine's kind: the routine is dropped and created in one transaction. Nothing on the server depends on it (a view, a trigger, a column default would make the DROP fail).", `${DOCS}/sql-createfunction.html`),
+    SQLPG282: rule("SQLPG282", "expand", "Change a function's result or parameters while other objects depend on it", "DROP FUNCTION refuses while a view, a trigger, a column default or another routine depends on the function, and CREATE OR REPLACE cannot make this change. Create the new definition under a new name (or signature), move what depends on it, then drop the old.", `${DOCS}/sql-dropfunction.html`),
+    SQLPG283: rule("SQLPG283", "metadata", "Create a trigger on an existing table", "CREATE TRIGGER takes SHARE ROW EXCLUSIVE on its table: writes and other schema changes to the table wait until the transaction commits, but no row is read. The applier's lock_timeout bounds the wait behind long-running transactions.", `${DOCS}/sql-createtrigger.html`),
+    SQLPG284: rule("SQLPG284", "metadata", "Change a trigger", "CREATE OR REPLACE TRIGGER (14 and later) replaces the trigger under SHARE ROW EXCLUSIVE on its table. A constraint trigger has no OR REPLACE, and a trigger moved to another table is another trigger: each is dropped (ACCESS EXCLUSIVE, briefly) and created in one transaction.", `${DOCS}/sql-createtrigger.html`),
+    SQLPG285: rule("SQLPG285", "drop", "Drop a trigger", "DROP TRIGGER takes ACCESS EXCLUSIVE on its table, briefly; no row is read or lost, and the table's writes no longer fire it.", `${DOCS}/sql-droptrigger.html`),
+    SQLPG290: rule("SQLPG290", "metadata", "Create a policy on an existing table", "CREATE POLICY takes ACCESS EXCLUSIVE on its table, briefly; no row is read. Where row-level security is on, the rows each role sees change when the transaction commits.", `${DOCS}/sql-createpolicy.html`),
+    SQLPG291: rule("SQLPG291", "metadata", "Change a policy", "ALTER POLICY changes its roles, USING and WITH CHECK under ACCESS EXCLUSIVE on the table, briefly. Its command, AS RESTRICTIVE and table cannot be altered, nor an expression taken away: the policy is dropped and created in one transaction, so no session sees the table without it.", `${DOCS}/sql-alterpolicy.html`),
+    SQLPG292: rule("SQLPG292", "drop", "Drop a policy", "DROP POLICY takes ACCESS EXCLUSIVE on its table, briefly; the rows it let a role see are hidden from that role at once, or, if it was the last policy, every non-owner sees none.", `${DOCS}/sql-droppolicy.html`),
+    SQLPG293: rule("SQLPG293", "metadata", "Turn row-level security on or off, or force it on the owner", "ALTER TABLE ... ENABLE, DISABLE, FORCE or NO FORCE ROW LEVEL SECURITY changes only the catalog, under ACCESS EXCLUSIVE, briefly. With it on and no policy that lets a role in, that role sees no rows; FORCE subjects the table's owner too.", `${DOCS}/ddl-rowsecurity.html`),
+    SQLPG294: rule("SQLPG294", "metadata", "Change a role's attributes", "ALTER ROLE changes the role in the cluster's catalog, for every database on the server, at once; sessions already open keep the attributes they started with until they reconnect.", `${DOCS}/sql-alterrole.html`),
+    SQLPG296: rule("SQLPG296", "metadata", "Grant a privilege", "GRANT adds to the object's privileges in the catalog; no row is read and the role can use it from its next statement.", `${DOCS}/sql-grant.html`),
+    SQLPG297: rule("SQLPG297", "metadata", "Revoke a privilege", "REVOKE removes from the object's privileges in the catalog. The role loses it at once: its next statement that needs it fails, so move every reader off it first.", `${DOCS}/sql-revoke.html`),
+    SQLPG298: rule("SQLPG298", "metadata", "Change default privileges", "ALTER DEFAULT PRIVILEGES changes what objects created afterwards are given; objects that exist keep their privileges.", `${DOCS}/sql-alterdefaultprivileges.html`),
+    SQLPG299: rule("SQLPG299", "expand", "Change a clause chant does not read", "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`),
+};

package/dist/postgres/plan/schema.js

@@ -0,0 +1,105 @@
+/**
+ * The two sides a Postgres diff compares: a build's output (the
+ * declarations), or what a live server's catalog prints. Both are parsed with
+ * the tag each object was declared with and brought to canonical form
+ * (`./normalize.ts`), so the diff compares like with like.
+ */
+import { readFileSync } from "node:fs";
+import { previouslyIn } from "../../core/normalize.js";
+import { liveProps } from "./deep.js";
+import { canonicalPgObject } from "./normalize.js";
+import { identValue } from "../parser.js";
+/** The rename hints in a statement: the object's (a comment before the CREATE) and each column's (a comment on its line). */
+export function renameHints(ddl) {
+    const lines = ddl.split("\n");
+    const createAt = lines.findIndex((l) => /\bCREATE\b/i.test(l.replace(/--.*$/, "")));
+    const before = lines.slice(0, Math.max(createAt, 0)).map((l) => l.trim()).filter((l) => l.startsWith("--"));
+    const columns = {};
+    for (const line of lines.slice(createAt + 1)) {
+        const m = /^\s*("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\b.*?(--.*)$/.exec(line);
+        if (!m)
+            continue;
+        const prev = previouslyIn([m[2]]);
+        if (prev)
+            columns[identValue(m[1])] = identValue(prev);
+    }
+    const prev = previouslyIn(before);
+    return { ...(prev ? { previously: prev } : {}), columns };
+}
+/** One object, from its type and statements, in the diff's form. */
+export function diffObject(type, ddl, defaultSchema) {
+    const props = liveProps({ type, statement: ddl });
+    const canonical = canonicalPgObject(type, props, defaultSchema);
+    const hints = renameHints(ddl);
+    const lineage = props.lineage;
+    const declaredColumns = props.columns;
+    return {
+        ...canonical,
+        type,
+        ...(hints.previously ? { previously: identValue(hints.previously) } : {}),
+        columnPreviously: hints.columns,
+        ...(props.concurrently === true ? { concurrently: true } : {}),
+        ...(canonical.kind === "view" || canonical.kind === "materializedView"
+            ? { outputs: Array.isArray(declaredColumns) && declaredColumns.length > 0 ? declaredColumns : (lineage ?? []).map((e) => e.output) }
+            : {}),
+    };
+}
+/** The objects a Postgres `chant build` output holds, keyed by export name. */
+export function pgSchemaFromBuildOutput(json, defaultSchema = "public") {
+    const doc = JSON.parse(json);
+    if (doc.dialect !== "postgres" || !Array.isArray(doc.objects))
+        throw new Error('not a Postgres build output: expected { dialect: "postgres", objects: [...] }');
+    return doc.objects.map((o) => ({ key: o.export, canonical: { ...diffObject(o.type, o.ddl, defaultSchema), exportName: o.export } }));
+}
+/** The major a Postgres build recorded (`postgresMajor`), or undefined for output that predates the field. */
+export function pgBuildMajor(json) {
+    const m = JSON.parse(json).postgresMajor;
+    return typeof m === "number" ? m : undefined;
+}
+export function pgBuildFileMajor(path) {
+    return pgBuildMajor(readFileSync(path, "utf-8"));
+}
+export function pgSchemaFromBuildFile(path, defaultSchema = "public") {
+    return pgSchemaFromBuildOutput(readFileSync(path, "utf-8"), defaultSchema);
+}
+/**
+ * The namespace an object's name is unique in: relations (tables, views,
+ * sequences, indexes) share one per schema, types and domains another,
+ * 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) {
+    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" || kind === "composite" || kind === "range")
+        return "type";
+    if (kind === "function" || kind === "procedure" || kind === "aggregate")
+        return "routine";
+    return "relation";
+}
+/** The identity an object has on a server: its kind's namespace, its qualified name, and its signature where it has one. */
+export function qualifiedKey(o) {
+    return `${pgNamespace(o.kind)} ${o.schema ? `${o.schema}.` : ""}${o.name}${o.signature ?? ""}`;
+}
+/** The declared objects re-keyed by qualified name, the only identity a server has. */
+export function keyedByQualifiedName(objects) {
+    return objects.map((o) => ({ key: qualifiedKey(o.canonical), canonical: { ...o.canonical, exportName: o.canonical.exportName ?? o.key } }));
+}
+/** What a server holds, in the diff's form, keyed by qualified name. */
+export function pgSchemaFromLive(live, defaultSchema) {
+    // A routine with a SQL-standard body is not one a declaration can hold (`../parser.ts`): never chant's, never compared.
+    return live.filter((o) => !o.unsupported).map((o) => {
+        const canonical = {
+            ...diffObject(o.type, o.statement, defaultSchema),
+            ...(o.foreign ? { foreign: o.foreign } : {}),
+            ...(o.dependents && o.dependents.length > 0 ? { dependents: o.dependents } : {}),
+        };
+        return { key: qualifiedKey(canonical), canonical };
+    });
+}

package/dist/postgres/plan/server-normalize.js

@@ -0,0 +1,166 @@
+/**
+ * The backstop for normalization against a live server: what the rules in
+ * `./normalize.ts` cannot see (a view's `SELECT *`, which the server expands;
+ * the parentheses it adds inside a check) is asked of the server itself.
+ *
+ * For each declared table or view whose expressions still differ from the
+ * server's, the declaration's expressions are created as a temporary object
+ * (`CREATE TEMP VIEW`, or a `CREATE TEMP TABLE` holding the columns' types,
+ * defaults and generated expressions and the checks) inside a transaction
+ * that is always rolled back, with a short `lock_timeout`, and read back with
+ * the same printers the catalog read uses. A trigger's `WHEN` and a policy's
+ * `USING` and `WITH CHECK`, which the server prints with the casts it
+ * resolved, are read back from a trigger or policy on a temporary copy of the
+ * table (`CREATE TEMP TABLE ... (LIKE table)`). Nothing is left behind: Postgres
+ * DDL is transactional and a temporary object lives in the session's own
+ * schema. A server that refuses (no TEMP privilege, a lock not granted in
+ * time, an expression it rejects) leaves the rules' answer standing.
+ */
+import { quoteIdent } from "../keywords.js";
+import { canonicalExpr } from "./normalize.js";
+async function rolledBack(client, defaultSchema, body) {
+    await client.query("BEGIN");
+    try {
+        await client.query("SET LOCAL lock_timeout = '1s'");
+        await client.query("SET LOCAL statement_timeout = '10s'");
+        await client.query(`SELECT pg_catalog.set_config('search_path', $1, true)`, [quoteIdent(defaultSchema)]);
+        return await body();
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        await client.query("ROLLBACK").catch(() => undefined);
+    }
+}
+const emptyPath = (client) => client.query(`SELECT pg_catalog.set_config('search_path', '', true)`);
+/** A view's query as the server prints it, canonical, and its output columns. */
+async function viewQuery(client, query, defaultSchema) {
+    return rolledBack(client, defaultSchema, async () => {
+        await client.query(`CREATE TEMP VIEW chant_normalize AS ${query}`);
+        await emptyPath(client);
+        const [row] = await client.query(`SELECT pg_catalog.pg_get_viewdef('pg_temp.chant_normalize'::pg_catalog.regclass, true) AS def`);
+        const cols = await client.query(`SELECT a.attname AS name FROM pg_catalog.pg_attribute a WHERE a.attrelid = 'pg_temp.chant_normalize'::pg_catalog.regclass AND a.attnum > 0 ORDER BY a.attnum`);
+        return { query: canonicalExpr(String(row?.def ?? "").trim().replace(/;$/, "")), outputs: cols.map((c) => String(c.name)) };
+    });
+}
+/** A table's defaults, generated expressions and checks as the server prints them, canonical. */
+async function tableExpressions(client, o, defaultSchema) {
+    const columns = o.columns.filter((c) => c.type !== undefined);
+    if (columns.length === 0)
+        return undefined;
+    const defs = columns.map((c) => {
+        const type = /^(small|big)?serial$/.test(c.type) ? c.type.replace("serial", "int").replace("smallint", "smallint").replace(/^int$/, "integer") : c.type;
+        const parts = [quoteIdent(c.name), type];
+        if (c.collate)
+            parts.push(`COLLATE ${c.collate}`);
+        if (c.generated) {
+            const [kind, ...expr] = c.generated.split(" ");
+            parts.push(`GENERATED ALWAYS AS (${expr.join(" ")}) ${kind === "virtual" ? "VIRTUAL" : "STORED"}`);
+        }
+        else if (c.default !== undefined)
+            parts.push(`DEFAULT ${c.default}`);
+        return parts.join(" ");
+    });
+    const checks = o.constraints.filter((c) => c.kind === "CHECK").map((c, i) => `CONSTRAINT chant_check_${String(i).padStart(4, "0")} ${c.body.replace(/^check /, "CHECK (").replace(/( no inherit| not enforced)*$/, ")$&")}`);
+    return rolledBack(client, defaultSchema, async () => {
+        await client.query(`CREATE TEMP TABLE chant_normalize (${[...defs, ...checks].join(", ")})`);
+        await emptyPath(client);
+        const cols = await client.query(`SELECT a.attname AS name, a.attgenerated AS generated, pg_catalog.pg_get_expr(d.adbin, d.adrelid, true) AS expr
+       FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+       WHERE a.attrelid = 'pg_temp.chant_normalize'::pg_catalog.regclass AND a.attnum > 0 AND NOT a.attisdropped`);
+        const cons = await client.query(`SELECT c.conname AS name, pg_catalog.pg_get_constraintdef(c.oid, true) AS def FROM pg_catalog.pg_constraint c
+       WHERE c.conrelid = 'pg_temp.chant_normalize'::pg_catalog.regclass AND c.contype = 'c' ORDER BY c.conname`);
+        const defaults = new Map();
+        const generated = new Map();
+        for (const r of cols) {
+            if (r.expr === null || r.expr === undefined)
+                continue;
+            if (r.generated === "s" || r.generated === "v")
+                generated.set(String(r.name), `${r.generated === "s" ? "stored" : "virtual"} ${canonicalExpr(String(r.expr))}`);
+            else
+                defaults.set(String(r.name), canonicalExpr(String(r.expr)));
+        }
+        const printed = cons.map((r) => String(r.def).replace(/^CHECK /, "")).map((d) => canonicalExpr(d));
+        return { defaults, generated, checks: printed };
+    });
+}
+/** A trigger's WHEN condition as the server prints it, canonical. */
+async function triggerWhen(client, o, defaultSchema) {
+    const when = o.fields.when;
+    // An INSTEAD OF trigger, on a view, takes no WHEN.
+    if (typeof when !== "string" || o.fields.timing === "instead of")
+        return undefined;
+    const events = (o.fields.events ?? []).map((e) => e.replace(/^(\w+)( of )?/, (_m, ev, of) => `${ev.toUpperCase()}${of ? " OF " : ""}`));
+    return rolledBack(client, defaultSchema, async () => {
+        await client.query(`CREATE TEMP TABLE chant_normalize (LIKE ${String(o.fields.table)})`);
+        await client.query(`CREATE FUNCTION pg_temp.chant_normalize() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN RETURN NULL; END'`);
+        await client.query(`CREATE TRIGGER chant_normalize ${String(o.fields.timing).toUpperCase()} ${events.join(" OR ")} ON pg_temp.chant_normalize ` +
+            `FOR EACH ${o.fields.forEach === "row" ? "ROW" : "STATEMENT"} WHEN (${when}) EXECUTE FUNCTION pg_temp.chant_normalize()`);
+        await emptyPath(client);
+        const [row] = await client.query(`SELECT pg_catalog.pg_get_triggerdef(t.oid, true) AS def FROM pg_catalog.pg_trigger t WHERE t.tgrelid = 'pg_temp.chant_normalize'::pg_catalog.regclass`);
+        const m = / WHEN \((.*)\) EXECUTE (?:FUNCTION|PROCEDURE) /s.exec(String(row?.def ?? ""));
+        return m ? canonicalExpr(m[1]) : undefined;
+    });
+}
+/** A policy's USING and WITH CHECK as the server prints them, canonical, from a policy on a temporary copy of its table. */
+async function policyExpressions(client, o, defaultSchema) {
+    const using = o.fields.using;
+    const check = o.fields.check;
+    if (using === undefined && check === undefined)
+        return undefined;
+    return rolledBack(client, defaultSchema, async () => {
+        await client.query(`CREATE TEMP TABLE chant_normalize (LIKE ${String(o.fields.table)})`);
+        await client.query([`CREATE POLICY chant_normalize ON pg_temp.chant_normalize FOR ${String(o.fields.command ?? "all").toUpperCase()}`, using !== undefined ? `USING (${using})` : "", check !== undefined ? `WITH CHECK (${check})` : ""]
+            .filter(Boolean)
+            .join(" "));
+        await emptyPath(client);
+        const [row] = await client.query(`SELECT pg_catalog.pg_get_expr(p.polqual, p.polrelid, true) AS qual, pg_catalog.pg_get_expr(p.polwithcheck, p.polrelid, true) AS withcheck
+       FROM pg_catalog.pg_policy p WHERE p.polrelid = 'pg_temp.chant_normalize'::pg_catalog.regclass`);
+        return { ...(row?.qual ? { using: canonicalExpr(String(row.qual)) } : {}), ...(row?.withcheck ? { check: canonicalExpr(String(row.withcheck)) } : {}) };
+    });
+}
+/**
+ * The declared object with its expressions in the server's own printing,
+ * when the server answers; the object unchanged otherwise. Only the
+ * expressions are touched: everything else stays the rules'.
+ */
+export async function serverNormalized(client, o, defaultSchema) {
+    if ((o.kind === "view" || o.kind === "materializedView") && typeof o.fields.query === "string") {
+        const q = await viewQuery(client, o.fields.query, defaultSchema);
+        // A declared column list names the outputs; otherwise the server's names do (`SELECT *` expanded).
+        return q === undefined ? o : { ...o, fields: { ...o.fields, query: q.query }, ...(o.fields.columns === undefined ? { outputs: q.outputs } : {}) };
+    }
+    if (o.kind === "policy") {
+        const e = await policyExpressions(client, o, defaultSchema);
+        return e === undefined ? o : { ...o, fields: { ...o.fields, ...e } };
+    }
+    if (o.kind === "trigger") {
+        const when = await triggerWhen(client, o, defaultSchema);
+        return when === undefined ? o : { ...o, fields: { ...o.fields, when } };
+    }
+    if (o.kind === "table") {
+        const e = await tableExpressions(client, o, defaultSchema);
+        if (!e)
+            return o;
+        let i = 0;
+        return {
+            ...o,
+            columns: o.columns.map((c) => ({
+                ...c,
+                ...(c.default !== undefined && e.defaults.has(c.name) && !/^(small|big)?serial$/.test(c.type ?? "") ? { default: e.defaults.get(c.name) } : {}),
+                ...(c.generated !== undefined && e.generated.has(c.name) ? { generated: e.generated.get(c.name) } : {}),
+            })),
+            constraints: o.constraints.map((c) => {
+                if (c.kind !== "CHECK")
+                    return c;
+                const printed = e.checks[i++];
+                if (printed === undefined)
+                    return c;
+                const tail = /( no inherit| not enforced)*$/.exec(c.body)?.[0] ?? "";
+                return { ...c, body: `check ${printed}${tail}` };
+            }),
+        };
+    }
+    return o;
+}

package/dist/postgres/providers/aurora.js

@@ -0,0 +1,44 @@
+import { rds } from "./rds.js";
+import { words } from "./types.js";
+/**
+ * Amazon Aurora PostgreSQL. Roles and refused statements are RDS's (Aurora
+ * uses the same master-user model). The extension list is the table
+ * "Extensions supported for Aurora PostgreSQL 18" on the Aurora release-notes
+ * page, read 2026-10-03; package names were mapped to extension names as in
+ * rds.ts (h3-pg is `h3`, pgvector is `vector`, pg_roaringbitmap is
+ * `roaringbitmap`). Aurora adds apg_plan_mgmt, aurora_stat_utils, aws_ml,
+ * pg_ad_mapping and pg_columnmask.
+ */
+export const aurora = {
+    ...rds,
+    provider: "aurora",
+    label: "Amazon Aurora PostgreSQL",
+    sources: [
+        {
+            url: "https://docs.aws.amazon.com/AmazonRDS/latest/AuroraPostgreSQLReleaseNotes/AuroraPostgreSQL.Extensions.html",
+            readOn: "2026-10-03",
+            covers: "allowedExtensions (Aurora PostgreSQL 18 table)",
+        },
+        ...rds.sources.filter((s) => s.covers !== "allowedExtensions (major 18 table)"),
+    ],
+    allowedExtensions: words(`
+    address_standardizer address_standardizer_data_us amcheck apg_plan_mgmt aurora_stat_utils auto_explain autoinc
+    aws_commons aws_lambda aws_ml aws_s3 bloom bool_plperl btree_gin btree_gist citext cube dblink dict_int dict_xsyn
+    earthdistance fuzzystrmatch h3 h3_postgis hll hstore hstore_plperl hypopg insert_username intagg intarray ip4r isn
+    jsonb_plperl lo log_fdw ltree moddatetime mysql_fdw oracle_fdw orafce pg_ad_mapping pg_bigm pg_buffercache
+    pg_columnmask pg_cron pg_freespacemap pg_hint_plan pg_partman pg_prewarm pg_proctab pg_repack pg_similarity
+    pg_stat_statements pg_tle pg_trgm pg_visibility pgaudit pgcrypto pgdam pglogical pgrouting pgrowlocks pgstattuple
+    pgtap plcoffee plls plperl plpgsql plprofiler pltcl plv8 postgis postgis_raster postgis_tiger_geocoder
+    postgis_topology postgres_fdw prefix rdkit rds_activity_stream rds_tools refint roaringbitmap seg sslinfo
+    tablefunc tcn tds_fdw tsm_system_rows tsm_system_time unaccent uuid-ossp vector wal2json
+  `),
+    providerExtensions: [
+        "apg_plan_mgmt", "aurora_stat_utils", "aws_commons", "aws_lambda", "aws_ml", "aws_s3", "log_fdw",
+        "pg_ad_mapping", "pg_columnmask", "pgdam", "rds_activity_stream", "rds_tools",
+    ],
+    toCheck: [
+        "per-release differences inside major 18, and the other majors' tables",
+        "pgdam and pg_columnmask were listed by the page with no description read",
+        ...rds.toCheck.filter((t) => !t.startsWith("per-major")),
+    ],
+};

package/dist/postgres/providers/azure.js

@@ -0,0 +1,53 @@
+import { words, COMMON_REFUSED } from "./types.js";
+/**
+ * Azure Database for PostgreSQL flexible server. The extension list is "List
+ * of extensions and modules by name", the entries available on major 18,
+ * read 2026-10-03. Besides being on that list, an extension must be allow-
+ * listed in the server's `azure.extensions` parameter before CREATE EXTENSION
+ * succeeds, and some also need `shared_preload_libraries`; that is server
+ * configuration, not something the list says, so it is not modelled.
+ * Roles are the three the access-control page names: azure_pg_admin (the
+ * pseudo-superuser the administrator belongs to), azuresu (Microsoft's
+ * control-plane superuser) and the administrator role the customer names.
+ */
+export const azure = {
+    provider: "azure",
+    label: "Azure Database for PostgreSQL flexible server",
+    sources: [
+        {
+            url: "https://learn.microsoft.com/en-us/azure/postgresql/extensions/concepts-extensions-versions",
+            readOn: "2026-10-03",
+            covers: "allowedExtensions (entries with a major 18 version)",
+        },
+        {
+            url: "https://learn.microsoft.com/en-us/azure/postgresql/security/security-access-control",
+            readOn: "2026-10-03",
+            covers: "reservedRoles (azure_pg_admin, azuresu); the public schema is owned by azure_pg_admin",
+        },
+    ],
+    reservedRoles: ["azure_pg_admin", "azuresu"],
+    reservedSchemas: [],
+    allowedExtensions: words(`
+    address_standardizer address_standardizer_data_us age amcheck anon auto_explain azure_ai azure_storage bloom
+    btree_gin btree_gist citext credcheck cube dblink dict_int dict_xsyn earthdistance fuzzystrmatch hll hstore hypopg
+    intagg intarray ip4r isn lo login_hook ltree oracle_fdw orafce pageinspect pgaudit pg_buffercache pg_cron pgcrypto
+    pg_diskann pg_failover_slots pg_freespacemap pg_hint_plan pg_ivm pglogical pg_partman pg_partman_bgw pg_prewarm
+    pg_repack pgrouting pgrowlocks pg_squeeze pg_stat_statements pgstattuple pg_trgm pg_visibility plpgsql
+    plpgsql_check plv8 pointcloud postgis postgis_raster postgis_sfcgal postgis_tiger_geocoder postgis_topology
+    postgres_fdw postgres_protobuf rdkit semver session_variable sslinfo tablefunc tdigest tds_fdw temporal_tables
+    timescaledb topn tsm_system_rows tsm_system_time unaccent uuid-ossp vector wal2json
+  `),
+    extensionListComplete: true,
+    providerExtensions: ["azure_ai", "azure_storage", "pg_diskann"],
+    refusedStatements: [
+        ...COMMON_REFUSED,
+        { id: "alter-azure-pg-admin", pattern: /^(ALTER|DROP) (ROLE|USER) "?AZURE_PG_ADMIN"?\b/, reason: "azure_pg_admin is a system-managed restricted role and cannot be modified" },
+        { id: "grant-to-azure-pg-admin", pattern: /^GRANT\b.*\bTO "?AZURE_PG_ADMIN"?\b/, reason: "azure_pg_admin is a system-managed restricted role; granting membership in it is refused" },
+    ],
+    toCheck: [
+        "the azure.extensions allowlist parameter and shared_preload_libraries needs: https://learn.microsoft.com/en-us/azure/postgresql/extensions/how-to-allow-extensions (the page rendered no body)",
+        "reservedSchemas: none read from a page: https://learn.microsoft.com/en-us/azure/postgresql/security/security-access-control",
+        "wal2json and pg_partman_bgw are logical-decoding or background-worker modules that may not take CREATE EXTENSION: https://learn.microsoft.com/en-us/azure/postgresql/extensions/concepts-extensions-versions",
+        "older majors' lists",
+    ],
+};

package/dist/postgres/providers/cloud-sql.js

@@ -0,0 +1,41 @@
+import { words, COMMON_REFUSED } from "./types.js";
+/**
+ * Google Cloud SQL for PostgreSQL. The extension list is the tables on
+ * "Configure PostgreSQL extensions" (PostGIS, data type, language and
+ * miscellaneous groups), read 2026-10-03. Names are the `CREATE EXTENSION`
+ * names: the page's pgAudit is `pgaudit`, pgTAP is `pgtap`, pgvector is
+ * `vector`. The page says a customer cannot create their own extensions.
+ * Roles are the `cloudsql*` names the Cloud SQL users page lists.
+ */
+export const cloudSql = {
+    provider: "cloud-sql",
+    label: "Google Cloud SQL for PostgreSQL",
+    sources: [
+        { url: "https://cloud.google.com/sql/docs/postgres/extensions", readOn: "2026-10-03", covers: "allowedExtensions, superuser requirement" },
+        { url: "https://cloud.google.com/sql/docs/postgres/users", readOn: "2026-10-03", covers: "reservedRoles (the cloudsql* roles)" },
+    ],
+    reservedRoles: [
+        "cloudsqlsuperuser", "cloudsqladmin", "cloudsqlagent", "cloudsqlconnpooladmin", "cloudsqliamgroup",
+        "cloudsqliamgroupserviceaccount", "cloudsqliamgroupuser", "cloudsqliamserviceaccount", "cloudsqliamuser",
+        "cloudsqlimportexport", "cloudsqlinactiveuser", "cloudsqllogical", "cloudsqlobservability", "cloudsqlreplica",
+    ],
+    reservedSchemas: [],
+    allowedExtensions: words(`
+    address_standardizer address_standardizer_data_us amcheck auto_explain autoinc bloom btree_gin btree_gist chkpass
+    citext cube dblink dict_int earthdistance fuzzystrmatch google_ml_integration google_read_only_session hll hstore
+    insert_username intagg intarray ip4r isn lo ltree moddatetime oracle_fdw orafce pageinspect pg_background pg_bigm
+    pg_buffercache pg_cron pg_freespacemap pg_hint_plan pg_ivm pg_partman pg_prewarm pg_proctab pg_qualstats pg_repack
+    pg_similarity pg_squeeze pg_stat_statements pg_textsearch pg_trgm pg_visibility pg_wait_sampling pgaudit pgcrypto
+    pgfincore pglogical pgrowlocks pgstattuple pgtap pgtt plpgsql plpgsql_check plv8 postgis postgis_raster
+    postgis_sfcgal postgis_tiger_geocoder postgis_topology postgres_fdw prefix rdkit roaringbitmap sslinfo tablefunc
+    tcn tds_fdw temporal_tables tsm_system_rows tsm_system_time unaccent uuid-ossp vector
+  `),
+    extensionListComplete: true,
+    providerExtensions: ["google_ml_integration", "google_read_only_session"],
+    refusedStatements: COMMON_REFUSED,
+    toCheck: [
+        "anon (the page lists postgresql_anonymizer; the CREATE EXTENSION name was not read): https://cloud.google.com/sql/docs/postgres/extensions",
+        "the list is for the newest major; older majors drop some entries",
+        "reservedSchemas: no page read names a schema Cloud SQL owns: https://cloud.google.com/sql/docs/postgres/users",
+    ],
+};