@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/postgres/plan/diff.js

@@ -201,7 +201,7 @@ function diffUnparsed(key, before, after, out, hints) {
     }
 }
 /** The kinds (#3911) whose definition has no ALTER: a change is a drop and a create, or (an aggregate's) CREATE OR REPLACE. */
-const REPLACED_KINDS = new Set(["composite", "range", "aggregate", "collation", "cast", "eventTrigger"]);
+const REPLACED_KINDS = new Set(["composite", "range", "aggregate", "collation", "cast", "eventTrigger", "operator", "operatorClass", "operatorFamily", "statistics"]);
 /** What each of {@link REPLACED_KINDS} compares besides its name and comment. */
 const DEFINITION = {
     composite: ["attributeDefs"],
@@ -210,7 +210,142 @@ const DEFINITION = {
     collation: ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"],
     cast: ["castMethod", "function", "context"],
     eventTrigger: ["event", "tags", "function"],
+    operator: ["definition"],
+    // A class's members, type, family and default flag have no ALTER; a family has no definition besides its name and method (its identity).
+    operatorClass: ["default", "dataType", "family", "items"],
+    operatorFamily: [],
+    statistics: ["table", "kinds", "targets"],
 };
+/** The kinds (#3911) the server alters in place, with the fields that cannot be altered (the object is dropped and created) and those that can. */
+const ALTERED_KINDS = {
+    foreignDataWrapper: { recreate: [], inPlace: ["handler", "validator", "options"] },
+    foreignServer: { recreate: ["serverType", "wrapper"], inPlace: ["version", "options"] },
+    publication: { recreate: ["allTables"], inPlace: ["tables", "schemas", "publish", "viaRoot", "generatedColumns"] },
+    // ALTER TEXT SEARCH DICTIONARY sets options and cannot change the template; ALTER TEXT SEARCH CONFIGURATION maps token types and cannot change the parser (SQLPG305).
+    textSearchDictionary: { recreate: ["template"], inPlace: ["options"], rule: "SQLPG305" },
+    textSearchConfiguration: { recreate: ["parser"], inPlace: ["mappings"], rule: "SQLPG305" },
+};
+/**
+ * A foreign data wrapper's, foreign server's or publication's change: the
+ * comment and each field ALTER reaches in place (SQLPG303); a field it does
+ * not reach (a server's type and wrapper, a publication's FOR ALL TABLES) by
+ * dropping and creating the object (SQLPG300), refused while something
+ * depends on it (SQLPG301).
+ */
+function diffAltered(key, before, after, out) {
+    if (!same(before.fields.comment, after.fields.comment))
+        out.push(change(key, "comment", "SQLPG216", show(before.fields.comment), show(after.fields.comment)));
+    const { recreate, inPlace, rule = "SQLPG303" } = ALTERED_KINDS[after.kind];
+    const replaced = recreate.filter((k) => !same(before.fields[k], after.fields[k]));
+    // An object that lives in a schema is another object under another name: a rename between builds is a drop and a create.
+    if (after.schema !== undefined && (before.schema !== after.schema || before.name !== after.name))
+        replaced.unshift("name");
+    if (replaced.length > 0) {
+        const value = (o, k) => (k === "name" ? qualified(o) : (show(o.fields[k]) ?? "-"));
+        const was = replaced.map((k) => `${k} ${value(before, k)}`).join("; ");
+        const now = replaced.map((k) => `${k} ${value(after, k)}`).join("; ");
+        if (before.dependents && before.dependents.length > 0) {
+            out.push(change(key, replaced.join(", "), "SQLPG301", was, now, { note: `${before.dependents.join(", ")} depend${before.dependents.length === 1 ? "s" : ""} on it` }));
+        }
+        else
+            out.push(change(key, replaced.join(", "), "SQLPG300", was, now));
+        return;
+    }
+    for (const k of inPlace)
+        if (!same(before.fields[k], after.fields[k]))
+            out.push(change(key, k, rule, show(before.fields[k]), show(after.fields[k])));
+}
+/**
+ * Which of an operator's attributes `ALTER OPERATOR ... SET` can change from
+ * what the server holds (the Postgres 18 page, with the supported majors):
+ * RESTRICT and JOIN on every major, set or removed; from 17 COMMUTATOR and
+ * NEGATOR when the operator has none, and HASHES and MERGES when off, never
+ * back. Anything else about the definition is dropped and created.
+ */
+function operatorAlterable(key, before, after, major) {
+    if (key === "restrict" || key === "join")
+        return true;
+    if (major < 17)
+        return false;
+    if (key === "commutator" || key === "negator")
+        return before[key] === undefined && after[key] !== undefined;
+    if (key === "hashes" || key === "merges")
+        return before[key] === undefined && after[key] === "true";
+    return false;
+}
+/** An operator's change: in place (SQLPG304) when every attribute that changed is one ALTER OPERATOR reaches, else dropped and created like the other kinds without an ALTER. */
+function diffOperator(key, before, after, out, major) {
+    const bo = (before.fields.definition ?? {});
+    const ao = (after.fields.definition ?? {});
+    const renamed = before.schema !== after.schema || before.name !== after.name || before.signature !== after.signature;
+    // In the order the page lists them, so the statement reads the same whatever the order the options were written in.
+    const ORDER = ["restrict", "join", "commutator", "negator", "hashes", "merges"];
+    const rank = (k) => (ORDER.includes(k) ? ORDER.indexOf(k) : ORDER.length);
+    const changed = [...new Set([...Object.keys(bo), ...Object.keys(ao)])].filter((k) => !same(bo[k], ao[k])).sort((a, b) => rank(a) - rank(b) || (a < b ? -1 : 1));
+    if (renamed || !changed.every((k) => operatorAlterable(k, bo, ao, major))) {
+        diffReplaced(key, before, after, out);
+        return;
+    }
+    if (!same(before.fields.comment, after.fields.comment))
+        out.push(change(key, "comment", "SQLPG216", show(before.fields.comment), show(after.fields.comment)));
+    const note = major < 17 ? undefined : "from 17 ALTER OPERATOR also sets a commutator's or negator's own commutator or negator";
+    for (const k of changed)
+        out.push(change(key, `definition.${k}`, "SQLPG304", show(bo[k]), show(ao[k]), note && (k === "commutator" || k === "negator") ? { note } : {}));
+}
+/**
+ * A foreign table's columns, as ALTER FOREIGN TABLE changes them (SQLPG306):
+ * all catalog changes, none reading the remote side. A column is its name
+ * (a rename is a drop and an add); its comment is the generic comment rule.
+ */
+function diffForeignColumns(key, before, after, out) {
+    const byName = new Map(before.columns.map((c) => [c.name, c]));
+    const afterNames = new Set(after.columns.map((c) => c.name));
+    for (const b of before.columns)
+        if (!afterNames.has(b.name))
+            out.push(change(key, `columns.${b.name}`, "SQLPG306", `${b.name} ${b.type ?? ""}`.trim(), undefined));
+    for (const a of after.columns) {
+        const b = byName.get(a.name);
+        if (!b) {
+            out.push(change(key, `columns.${a.name}`, "SQLPG306", undefined, `${a.name} ${a.type ?? ""}`.trim()));
+            continue;
+        }
+        const at = `columns.${a.name}`;
+        if (b.type !== a.type)
+            out.push(change(key, `${at}.type`, "SQLPG306", b.type, a.type));
+        if (b.collate !== a.collate)
+            out.push(change(key, `${at}.collate`, "SQLPG306", b.collate, a.collate));
+        if (b.default !== a.default)
+            out.push(change(key, `${at}.default`, "SQLPG306", b.default, a.default));
+        if (b.notNull !== a.notNull)
+            out.push(change(key, `${at}.notNull`, "SQLPG306", b.notNull ? "NOT NULL" : "NULL", a.notNull ? "NOT NULL" : "NULL"));
+        if (!same(b.options, a.options))
+            out.push(change(key, `${at}.options`, "SQLPG306", show(b.options), show(a.options)));
+        if (b.comment !== a.comment)
+            out.push(change(key, `${at}.comment`, "SQLPG216", b.comment, a.comment));
+    }
+}
+/** A foreign table's CHECK constraints: a dropped one first, so a constraint replaced under its name is dropped before it is added. */
+function diffForeignConstraints(key, before, after, out) {
+    const label = (c) => (c.name ? `${c.name}: ${c.body}` : c.body);
+    const remaining = [...before.constraints];
+    const added = [];
+    const comments = [];
+    for (const a of after.constraints) {
+        const i = remaining.findIndex((b) => sameConstraint(a, b));
+        if (i < 0) {
+            added.push(a);
+            continue;
+        }
+        const b = remaining.splice(i, 1)[0];
+        if (b.comment !== a.comment)
+            comments.push(change(key, `constraints.${a.name ?? b.name}.comment`, "SQLPG216", b.comment, a.comment));
+    }
+    for (const b of remaining)
+        out.push(change(key, `constraints.${b.name ?? b.kind.toLowerCase()}`, "SQLPG306", label(b), undefined));
+    for (const a of added)
+        out.push(change(key, `constraints.${a.name ?? a.kind.toLowerCase()}`, "SQLPG306", undefined, label(a)));
+    out.push(...comments);
+}
 /**
  * A type's, aggregate's, collation's, cast's or event trigger's change: its
  * comment in place; its definition by CREATE OR REPLACE AGGREGATE where that
@@ -251,6 +386,15 @@ function diffObject(key, before, after, out, hints, major) {
         if (!same(b, a))
             out.push(change(key, name, rule, show(b), show(a), extra));
     };
+    if (after.kind === "operator") {
+        diffOperator(key, before, after, out, major);
+        return;
+    }
+    // A foreign table moved to another server is another table: ALTER FOREIGN TABLE has no SERVER action.
+    if (after.kind === "foreignTable" && before.schema === after.schema && before.name === after.name && !same(before.fields.server, after.fields.server)) {
+        out.push(change(key, "server", before.dependents && before.dependents.length > 0 ? "SQLPG301" : "SQLPG300", show(before.fields.server), show(after.fields.server), before.dependents && before.dependents.length > 0 ? { note: `${before.dependents.join(", ")} depend${before.dependents.length === 1 ? "s" : ""} on it` } : {}));
+        return;
+    }
     if (REPLACED_KINDS.has(after.kind)) {
         // A cast is named by its types, and an aggregate's argument types are its identity: either changed, between two builds, is another object.
         if (after.kind === "cast" && before.name !== after.name) {
@@ -260,6 +404,10 @@ function diffObject(key, before, after, out, hints, major) {
         diffReplaced(key, before, after, out);
         return;
     }
+    if (after.kind in ALTERED_KINDS) {
+        diffAltered(key, before, after, out);
+        return;
+    }
     if (before.schema !== after.schema || before.name !== after.name) {
         out.push(change(key, "name", after.kind === "index" ? "SQLPG229" : "SQLPG228", qualified(before), qualified(after)));
     }
@@ -387,6 +535,11 @@ function diffObject(key, before, after, out, hints, major) {
             field("attributes", "SQLPG294");
             field("connectionLimit", "SQLPG294");
             break;
+        case "foreignTable":
+            diffForeignColumns(key, before, after, out);
+            diffForeignConstraints(key, before, after, out);
+            field("options", "SQLPG306");
+            break;
         case "table":
             if (!same(before.fields.rowSecurity, after.fields.rowSecurity) || !same(before.fields.forceRowSecurity, after.fields.forceRowSecurity)) {
                 const state = (o) => (o.fields.rowSecurity ? (o.fields.forceRowSecurity ? "enabled, forced" : "enabled") : o.fields.forceRowSecurity ? "disabled, forced" : "disabled");

package/dist/postgres/plan/normalize.d.ts

@@ -42,7 +42,7 @@
  * plan or a deep read has one (`./server-normalize.ts`). Offline, between two
  * builds, only the rules apply.
  */
-import type { AggregateProps, CastProps, RoutineProps } from "../entities.js";
+import type { OperatorProps, AggregateProps, CastProps, RoutineProps } from "../entities.js";
 /** The integer type a serial spelling stands for, or undefined for any other type. */
 export declare const serialBase: (type: string | undefined) => string | undefined;
 /** A qualified name in canonical form: each piece unquoted where it can be, the default schema added to a bare one. */
@@ -73,6 +73,8 @@ export interface CanonicalColumn {
     collate?: string;
     compression?: string;
     storage?: string;
+    /** A foreign table column's `OPTIONS`, sorted by name. */
+    options?: Record<string, string>;
     comment?: string;
 }
 export interface CanonicalConstraint {
@@ -85,7 +87,7 @@ export interface CanonicalConstraint {
     notValid?: boolean;
     comment?: string;
 }
-export type CanonicalKind = "schema" | "table" | "index" | "view" | "materializedView" | "sequence" | "enum" | "composite" | "range" | "domain" | "extension" | "aggregate" | "collation" | "cast" | "eventTrigger" | "function" | "procedure" | "trigger" | "policy" | "role" | "grant" | "defaultPrivileges";
+export type CanonicalKind = "schema" | "table" | "index" | "view" | "materializedView" | "sequence" | "enum" | "composite" | "range" | "domain" | "extension" | "aggregate" | "collation" | "cast" | "eventTrigger" | "operator" | "operatorClass" | "operatorFamily" | "foreignTable" | "textSearchConfiguration" | "textSearchDictionary" | "statistics" | "foreignDataWrapper" | "foreignServer" | "publication" | "function" | "procedure" | "trigger" | "policy" | "role" | "grant" | "defaultPrivileges";
 /** The kinds whose declarations are privileges, compared as the access they add up to (`../access/`), not one by one. */
 export declare const ACCESS_KINDS: ReadonlySet<CanonicalKind>;
 /** The kinds a profile manages only when it says so (`sql.profiles.<env>.access`). */
@@ -135,6 +137,30 @@ export declare const canonicalCollation: (text: string) => string;
 export declare function defaultMultirangeName(range: string): string;
 /** An aggregate's identity among its overloads: `(integer)`, `(*)`, `(text ORDER BY integer)`. */
 export declare function aggregateSignature(p: Pick<AggregateProps, "args" | "orderBy">, defaultSchema: string): string;
+/** An operator's identity among its overloads: its operand types, `(integer,integer)`, `NONE` for a missing side. */
+export declare function operatorSignature(p: Pick<OperatorProps, "leftArg" | "rightArg">, defaultSchema: string): string;
+/**
+ * An operator named where another object names it (a COMMUTATOR or NEGATOR):
+ * `OPERATOR(app.===)`, `app.===` or a bare symbol, which the server looks for
+ * in the new operator's own schema, as `schema.symbol`.
+ */
+export declare function canonicalOperatorRef(text: string, ownSchema: string): string;
+/**
+ * A name where an object is named (a text search parser, template or
+ * dictionary, an operator family): the schema left off when it is
+ * `pg_catalog` or the default schema, since a bare name is looked for in both.
+ * The catalog prints every schema, so both sides are brought to this form.
+ */
+export declare function canonicalRef(text: string, defaultSchema: string): string;
+/** An operator named in an operator class: `OPERATOR(app.<<)`, `app.<<` or a bare symbol, by `canonicalRef`'s rule for the schema. */
+export declare function canonicalOperatorName(text: string, defaultSchema: string): string;
+/**
+ * The kinds of statistics gathered, sorted. Left out, the server builds all
+ * three, except for a lone expression, which gets none of them (only the
+ * expression's own statistics); `pg_get_statisticsobjdef` prints the list only
+ * when it is not that default.
+ */
+export declare function statisticsKinds(kinds: readonly string[] | undefined, targets: readonly string[]): string[] | undefined;
 /** A cast's name, `(source AS target)`, its types canonical. */
 export declare const castName: (p: Pick<CastProps, "sourceType" | "targetType">, defaultSchema: string) => string;
 /**

package/dist/postgres/plan/normalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/normalize.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/normalize.ts"],"names":[],"mappings":"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"}

package/dist/postgres/plan/normalize.js

@@ -303,6 +303,16 @@ const kindOf = {
     "Postgres::Collation": "collation",
     "Postgres::Cast": "cast",
     "Postgres::EventTrigger": "eventTrigger",
+    "Postgres::Operator": "operator",
+    "Postgres::OperatorClass": "operatorClass",
+    "Postgres::OperatorFamily": "operatorFamily",
+    "Postgres::ForeignTable": "foreignTable",
+    "Postgres::TextSearchConfiguration": "textSearchConfiguration",
+    "Postgres::TextSearchDictionary": "textSearchDictionary",
+    "Postgres::Statistics": "statistics",
+    "Postgres::ForeignDataWrapper": "foreignDataWrapper",
+    "Postgres::ForeignServer": "foreignServer",
+    "Postgres::Publication": "publication",
     "Postgres::Extension": "extension",
     "Postgres::Function": "function",
     "Postgres::Procedure": "procedure",
@@ -524,7 +534,7 @@ function triggerFields(p, defaultSchema, fields) {
 }
 // ── Types, aggregates, collations, casts, event triggers (#3911) ──────
 /** The kinds that live in no schema. */
-const UNPLACED = new Set(["schema", "extension", "role", "cast", "eventTrigger"]);
+const UNPLACED = new Set(["schema", "extension", "role", "cast", "eventTrigger", "foreignDataWrapper", "foreignServer", "publication"]);
 /**
  * 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
@@ -616,6 +626,183 @@ function collationFields(p, fields) {
     fields.nondeterministic = p.options.deterministic !== undefined && !isTrue(p.options.deterministic);
     fields.rules = o.rules;
 }
+/** An operator's identity among its overloads: its operand types, `(integer,integer)`, `NONE` for a missing side. */
+export function operatorSignature(p, defaultSchema) {
+    const side = (t) => (t === undefined ? "NONE" : canonicalArgType(t, defaultSchema));
+    return `(${side(p.leftArg)},${side(p.rightArg)})`;
+}
+/**
+ * An operator named where another object names it (a COMMUTATOR or NEGATOR):
+ * `OPERATOR(app.===)`, `app.===` or a bare symbol, which the server looks for
+ * in the new operator's own schema, as `schema.symbol`.
+ */
+export function canonicalOperatorRef(text, ownSchema) {
+    const inner = text.trim().replace(/^OPERATOR\s*\(\s*(.*?)\s*\)$/is, "$1");
+    const m = /^("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\s*\.\s*(\S.*)$/s.exec(inner);
+    return `${quoteIdent(m ? identValue(m[1]) : ownSchema)}.${(m ? m[2] : inner).trim()}`;
+}
+/** An operator's definition as compared: each function and operator named canonically, a flag only when set. */
+function operatorOptions(p, ownSchema, defaultSchema) {
+    const out = {};
+    for (const [k, v] of Object.entries(p.options)) {
+        if (k === "function" || k === "restrict" || k === "join")
+            out[k] = canonicalFunctionName(v, defaultSchema);
+        else if (k === "commutator" || k === "negator")
+            out[k] = canonicalOperatorRef(v, ownSchema);
+        else if (k === "hashes" || k === "merges") {
+            if (isTrue(v))
+                out[k] = "true";
+        }
+        else
+            out[k] = defValue(v);
+    }
+    return Object.fromEntries(Object.entries(out).sort(([a], [b]) => (a < b ? -1 : 1)));
+}
+/**
+ * A name where an object is named (a text search parser, template or
+ * dictionary, an operator family): the schema left off when it is
+ * `pg_catalog` or the default schema, since a bare name is looked for in both.
+ * The catalog prints every schema, so both sides are brought to this form.
+ */
+export function canonicalRef(text, defaultSchema) {
+    const pieces = canonicalName(text).split(/\.(?=(?:[^"]*"[^"]*")*[^"]*$)/);
+    if (pieces.length >= 2) {
+        const schema = identValue(pieces[0]);
+        return schema === "pg_catalog" || schema === defaultSchema ? pieces.slice(1).join(".") : pieces.join(".");
+    }
+    return pieces[0];
+}
+/** An operator named in an operator class: `OPERATOR(app.<<)`, `app.<<` or a bare symbol, by `canonicalRef`'s rule for the schema. */
+export function canonicalOperatorName(text, defaultSchema) {
+    const inner = text.trim().replace(/^OPERATOR\s*\(\s*(.*?)\s*\)$/is, "$1").trim();
+    const m = /^("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\s*\.\s*(\S.*)$/s.exec(inner);
+    if (!m)
+        return inner;
+    const schema = identValue(m[1]);
+    return schema === "pg_catalog" || schema === defaultSchema ? m[2].trim() : `${quoteIdent(schema)}.${m[2].trim()}`;
+}
+/** A comma list split at its top level: `numeric(12,2), text` is two items. */
+function splitTopLevel(text) {
+    const out = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of text) {
+        if (ch === "(" || ch === "[")
+            depth++;
+        else if (ch === ")" || ch === "]")
+            depth--;
+        if (ch === "," && depth === 0) {
+            out.push(current.trim());
+            current = "";
+        }
+        else
+            current += ch;
+    }
+    if (current.trim() !== "")
+        out.push(current.trim());
+    return out;
+}
+/**
+ * The operand types a support function of an operator class is registered
+ * for when `FUNCTION n (left, right)` does not say (sql-createopclass): a
+ * B-tree comparison function's (1) and a hash function's (1, 2) are the
+ * function's own input types, a B-tree `in_range` function's (3) its first
+ * and third, and every other support function's the class's type. The catalog
+ * always stores both, so a declaration is brought to them.
+ */
+function supportTypes(method, number, classType, args) {
+    if (method === "btree" && number === 1)
+        return [args[0] ?? classType, args[1] ?? args[0] ?? classType];
+    if (method === "btree" && number === 3)
+        return [args[0] ?? classType, args[2] ?? classType];
+    if (method === "hash" && (number === 1 || number === 2))
+        return [args[0] ?? classType, args[0] ?? classType];
+    return [classType, classType];
+}
+/** An operator class as compared: its type, family, default flag and members, each member canonical and the list sorted. */
+function operatorClassFields(p, schema, defaultSchema, fields) {
+    const type = canonicalType(p.dataType, defaultSchema);
+    fields.default = p.default === true;
+    fields.dataType = type;
+    // A class with no FAMILY is in a family of its own name; so is one that names that family.
+    const own = canonicalRef(`${quoteIdent(schema)}.${quoteIdent(p.name)}`, defaultSchema);
+    const named = p.family === undefined ? own : /^\s*("(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)\s*$/.test(p.family) && identValue(p.family.trim()) === p.name ? own : canonicalRef(p.family, defaultSchema);
+    fields.family = named === own ? undefined : named;
+    const side = (t) => (t.trim().toUpperCase() === "NONE" ? "NONE" : canonicalArgType(t, defaultSchema));
+    const members = p.items.map((i) => {
+        if (i.kind === "storage")
+            return { rank: 2, number: 0, text: `storage ${canonicalType(i.type, defaultSchema)}` };
+        const n = Number(i.number);
+        if (i.kind === "operator") {
+            const [l, r] = i.types !== undefined ? splitTopLevel(i.types) : [type, type];
+            const sorted = i.orderBy !== undefined ? ` for order by ${canonicalRef(i.orderBy, defaultSchema)}` : "";
+            return { rank: 0, number: n, text: `operator ${n} ${canonicalOperatorName(i.operator, defaultSchema)} (${side(l ?? type)},${side(r ?? l ?? type)})${sorted}` };
+        }
+        const args = splitTopLevel(i.args).map((a) => canonicalArgType(a, defaultSchema));
+        const given = i.types !== undefined ? splitTopLevel(i.types).map(side) : undefined;
+        const [l, r] = given ? [given[0], given[1] ?? given[0]] : supportTypes(p.method, n, type, args);
+        return { rank: 1, number: n, text: `function ${n} (${l},${r}) ${canonicalFunctionName(i.function, defaultSchema)}(${args.join(",")})` };
+    });
+    members.sort((a, b) => a.rank - b.rank || a.number - b.number || (a.text < b.text ? -1 : 1));
+    fields.items = members.map((m) => m.text);
+}
+/** A dictionary option's value as compared: a string constant's value, a quoted name's, a bare word folded, a number as written. */
+function dictionaryValue(v) {
+    const t = v.trim();
+    if (/^([Ee]?'|\$)/.test(t))
+        return stringValue(t) ?? t;
+    if (/^"/.test(t))
+        return identValue(t);
+    return t.toLowerCase();
+}
+/** A text search configuration's mappings as compared: each token type to its dictionaries in order, sorted by token type. */
+function mappingFields(p, defaultSchema) {
+    const out = {};
+    for (const m of p.mappings)
+        for (const t of m.tokens)
+            out[t.toLowerCase()] = m.dictionaries.map((d) => canonicalRef(d, defaultSchema));
+    const entries = Object.entries(out).sort(([a], [b]) => (a < b ? -1 : 1));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+/** An `OPTIONS (...)` list as compared: by name, none as nothing. */
+function sortedOptions(options) {
+    const entries = Object.entries(options ?? {}).sort(([a], [b]) => (a < b ? -1 : 1));
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+const STATISTICS_ALL = ["dependencies", "mcv", "ndistinct"];
+/**
+ * The kinds of statistics gathered, sorted. Left out, the server builds all
+ * three, except for a lone expression, which gets none of them (only the
+ * expression's own statistics); `pg_get_statisticsobjdef` prints the list only
+ * when it is not that default.
+ */
+export function statisticsKinds(kinds, targets) {
+    if (kinds && kinds.length > 0) {
+        const sorted = [...new Set(kinds.map((k) => k.toLowerCase()))].sort();
+        return sorted.join() === STATISTICS_ALL.join() ? undefined : sorted;
+    }
+    const lone = targets.length === 1 && !/^"?[A-Za-z_][A-Za-z0-9_$]*"?$/.test(targets[0].trim());
+    return lone ? ["none"] : undefined;
+}
+/** Every action a publication publishes when `publish` is not given. */
+const PUBLISH_ALL = ["delete", "insert", "truncate", "update"];
+/** A publication as compared: its tables with their column lists and row filters, its schemas, and each option at its default left out. */
+function publicationFields(p, defaultSchema, fields) {
+    fields.allTables = p.allTables === true;
+    const tables = p.tables.map((t) => ({
+        table: canonicalName(t.tableName, defaultSchema),
+        ...(t.columns && t.columns.length > 0 ? { columns: [...t.columns].sort() } : {}),
+        ...(t.where ? { where: canonicalExpr(t.where) } : {}),
+    }));
+    fields.tables = tables.length > 0 ? tables.sort((a, b) => (a.table < b.table ? -1 : 1)) : undefined;
+    fields.schemas = p.schemas.length > 0 ? p.schemas.map((s) => quoteIdent(identValue(s))).sort() : undefined;
+    const o = p.options;
+    const publish = o.publish === undefined ? PUBLISH_ALL : [...new Set(defValue(o.publish).split(",").map((x) => x.trim().toLowerCase()).filter(Boolean))].sort();
+    fields.publish = publish.join() === PUBLISH_ALL.join() ? undefined : publish;
+    fields.viaRoot = isTrue(o.publish_via_partition_root);
+    const generated = o.publish_generated_columns === undefined ? "none" : defValue(o.publish_generated_columns);
+    fields.generatedColumns = generated === "none" ? undefined : generated;
+}
 /** A cast's name, `(source AS target)`, its types canonical. */
 export const castName = (p, defaultSchema) => `(${canonicalType(p.sourceType, defaultSchema)} AS ${canonicalType(p.targetType, defaultSchema)})`;
 /**
@@ -688,6 +875,78 @@ export function canonicalPgObject(entityType, props, defaultSchema = "public") {
             fields.function = canonicalFunctionName(p.functionName, defaultSchema);
             break;
         }
+        case "operator": {
+            const p = props;
+            base.signature = operatorSignature(p, defaultSchema);
+            fields.definition = operatorOptions(p, base.schema, defaultSchema);
+            break;
+        }
+        case "operatorClass":
+            operatorClassFields(props, base.schema, defaultSchema, fields);
+            base.signature = ` USING ${props.method}`;
+            break;
+        case "operatorFamily":
+            base.signature = ` USING ${props.method}`;
+            break;
+        case "textSearchDictionary": {
+            const p = props;
+            fields.template = canonicalRef(p.template, defaultSchema);
+            fields.options = sortedOptions(Object.fromEntries(Object.entries(p.options).map(([k, v]) => [k.toLowerCase(), dictionaryValue(v)])));
+            break;
+        }
+        case "textSearchConfiguration": {
+            const p = props;
+            fields.parser = canonicalRef(p.parser, defaultSchema);
+            fields.mappings = mappingFields(p, defaultSchema);
+            break;
+        }
+        case "foreignTable": {
+            const p = props;
+            p.columns.forEach((c, position) => {
+                const options = sortedOptions(c.options);
+                columns.push({
+                    name: c.name,
+                    position,
+                    type: canonicalType(c.type, defaultSchema),
+                    notNull: c.notNull === true,
+                    default: canonicalExpr(c.default),
+                    collate: c.collate ? canonicalName(c.collate) : undefined,
+                    comment: comment(c.comment),
+                    ...(options ? { options } : {}),
+                });
+            });
+            for (const c of p.checks)
+                constraints.push({ kind: "CHECK", name: c.name, body: ["check", canonicalExpr(c.expr), c.noInherit ? "no inherit" : ""].filter(Boolean).join(" "), ...(c.notValid ? { notValid: true } : {}), comment: comment(c.comment) });
+            fields.server = quoteIdent(p.serverName);
+            fields.options = sortedOptions(p.options);
+            break;
+        }
+        case "statistics": {
+            const p = props;
+            fields.table = canonicalName(p.tableName, defaultSchema);
+            const targets = p.targets.map((t) => canonicalExpr(t)).sort();
+            fields.targets = targets;
+            fields.kinds = statisticsKinds(p.kinds, p.targets);
+            break;
+        }
+        case "foreignDataWrapper": {
+            const p = props;
+            fields.handler = p.handlerName && !p.noHandler ? canonicalFunctionName(p.handlerName, defaultSchema) : undefined;
+            fields.validator = p.validatorName && !p.noValidator ? canonicalFunctionName(p.validatorName, defaultSchema) : undefined;
+            fields.options = sortedOptions(p.options);
+            break;
+        }
+        case "foreignServer": {
+            const p = props;
+            fields.serverType = p.serverType;
+            fields.version = p.version;
+            fields.wrapper = quoteIdent(identValue(p.wrapperName));
+            fields.options = sortedOptions(p.options);
+            break;
+        }
+        case "publication":
+            publicationFields(props, defaultSchema, fields);
+            break;
         case "function":
         case "procedure": {
             const p = props;

package/dist/postgres/plan/rules.d.ts

@@ -96,6 +96,10 @@ export declare const PG_CLASSIFIER_RULES: {
     readonly SQLPG300: PgClassifierRule;
     readonly SQLPG301: PgClassifierRule;
     readonly SQLPG302: PgClassifierRule;
+    readonly SQLPG303: PgClassifierRule;
+    readonly SQLPG304: PgClassifierRule;
+    readonly SQLPG305: PgClassifierRule;
+    readonly SQLPG306: PgClassifierRule;
     readonly SQLPG270: PgClassifierRule;
 };
 export type PgClassifierRuleId = keyof typeof PG_CLASSIFIER_RULES;

package/dist/postgres/plan/rules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAkB,KAAK,aAAa,EAAE,KAAK,cAAc,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAErH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEhH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAY1D,CAAC;AASF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqUqB,CAAC;AAEtD,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,mBAAmB,CAAC"}
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAkB,KAAK,aAAa,EAAE,KAAK,cAAc,IAAI,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAErH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEhH,MAAM,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAC;AAEhE,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAY1D,CAAC;AASF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiWqB,CAAC;AAEtD,MAAM,MAAM,kBAAkB,GAAG,MAAM,OAAO,mBAAmB,CAAC"}

package/dist/postgres/plan/rules.js

@@ -108,8 +108,12 @@ export const PG_CLASSIFIER_RULES = {
     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`),
+    SQLPG300: rule("SQLPG300", "metadata", "Drop and create a type, aggregate, collation, cast, event trigger, operator, operator class or family, foreign table's server, text search object, statistics object, foreign server or publication", "A composite or range type's definition, a collation's, a cast's, an event trigger's, an operator's function and operands, and any attribute of it that SQLPG304 does not alter, an operator class's members, type, family and default flag, an operator family's index method, and extended statistics' have no ALTER (ALTER OPERATOR CLASS and ALTER OPERATOR FAMILY change a name, an owner or a schema only), an aggregate's argument types, state type and final function cannot be replaced, and neither can a foreign server's type or wrapper, a foreign table's server, a text search configuration's parser, a text search dictionary's template or a publication's FOR ALL TABLES: the object is dropped and created in one transaction. Nothing on the server depends on it (a column, a view, an index, a function or a cast would make the DROP fail); the locks are on its catalog rows only. Dropped statistics are empty until the next ANALYZE, and a publication that is dropped stops its subscribers until it is created again.", `${DOCS}/sql-createtype.html`),
+    SQLPG301: rule("SQLPG301", "expand", "Change a type, aggregate, collation, cast, operator, operator class, text search object, foreign table's server, foreign server or publication that other objects depend on", "No ALTER makes the change, and DROP refuses while a column, a view, an index, 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`),
+    SQLPG303: rule("SQLPG303", "metadata", "Alter a foreign data wrapper, foreign server or publication in place", "ALTER FOREIGN DATA WRAPPER (handler, validator, options), ALTER SERVER (version, options) and ALTER PUBLICATION (SET options, ADD and DROP TABLE and TABLES IN SCHEMA) change the object's catalog rows under a brief lock; no table is rewritten. A publication's change reaches its subscribers as the walsender next reads it: a table added is not copied to a subscription until the subscriber runs REFRESH PUBLICATION.", `${DOCS}/sql-alterpublication.html`),
+    SQLPG304: rule("SQLPG304", "metadata", "Alter an operator in place", "ALTER OPERATOR ... SET changes the operator's catalog row under a brief lock; no index or table is read. RESTRICT and JOIN can be set or removed (NONE) on every supported major. From 17, COMMUTATOR and NEGATOR can be set when the operator has none, and HASHES and MERGES turned on, never off (the Postgres 18 page: \"Can only be changed if the operator does not have an existing commutator\", \"Can only be enabled and not disabled\"); setting a commutator or negator also sets the other operator's. On 14 to 16 only RESTRICT and JOIN are alterable, so any other change drops and creates the operator (SQLPG300), as does a change of function or operands on any major.", `${DOCS}/sql-alteroperator.html`),
+    SQLPG305: rule("SQLPG305", "metadata", "Alter a text search configuration's mappings or a dictionary's options in place", "ALTER TEXT SEARCH CONFIGURATION ADD MAPPING, ALTER MAPPING and DROP MAPPING change the token types mapped to dictionaries; ALTER TEXT SEARCH DICTIONARY sets a template's options, and an option named with no value is removed. Both change catalog rows under a brief lock and leave the parser or template as it is, so a parser or template change is dropped and created (SQLPG300). A tsvector already stored keeps the tokens it was built with: rebuild the columns and indexes that hold one when the mappings or options change what a word becomes. The same applies on 14 to 18.", `${DOCS}/sql-altertsconfig.html`),
+    SQLPG306: rule("SQLPG306", "metadata", "Alter a foreign table in place", "ALTER FOREIGN TABLE adds and drops columns, changes a column's type, default, NOT NULL and OPTIONS, adds and drops CHECK and NOT NULL constraints, and sets the table's OPTIONS, all in the catalog. Nothing is checked against the remote side and no row is rewritten or scanned (\"It is the user's responsibility to ensure that the table definition matches the remote side\"), so a CHECK is added with no validation pass. A foreign table's server cannot be altered, so a change of server is dropped and created (SQLPG300).", `${DOCS}/sql-alterforeigntable.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

@@ -73,7 +73,7 @@ export function pgSchemaFromBuildFile(path, defaultSchema = "public") {
 export function pgNamespace(kind) {
     if (kind === "schema" || kind === "extension" || kind === "trigger" || kind === "policy" || kind === "role")
         return kind;
-    if (kind === "collation" || kind === "cast" || kind === "eventTrigger")
+    if (kind === "collation" || kind === "cast" || kind === "eventTrigger" || kind === "operator" || kind === "operatorClass" || kind === "operatorFamily" || kind === "textSearchConfiguration" || kind === "textSearchDictionary" || kind === "statistics" || kind === "foreignDataWrapper" || kind === "foreignServer" || kind === "publication")
         return kind;
     if (kind === "grant" || kind === "defaultPrivileges")
         return "grant";

package/dist/postgres/plan/statements.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The Postgres statement classifier (#4407): a migration file's statements,
+ * each given the class and rule the schema-diff classifier (`./rules.ts`)
+ * gives the same change, with the lock the rule's restriction names. It reads
+ * text and contacts no server.
+ *
+ * `CREATE`, `GRANT`, `REVOKE`, `COMMENT ON` and `ALTER TABLE ... ROW LEVEL
+ * SECURITY` go through the declaration parser (`../parser.ts`). The parser
+ * has no `ALTER` grammar, so the other `ALTER` and `DROP` statements are read
+ * word by word from the same tokens.
+ *
+ * A statement alone cannot decide some changes. `ALTER COLUMN ... TYPE` is a
+ * catalog change or a table rewrite by the column's old type, which the file
+ * does not state: it is `undecided`, naming SQLPG206 and SQLPG207 (and
+ * SQLPG208 with a `USING` expression). `CREATE OR REPLACE VIEW` is SQLPG250
+ * or SQLPG251 by whether the columns stay. A statement no rule covers is
+ * `unclassified` with a note.
+ */
+import { type StatementVerdict } from "../../core/statement-class.js";
+/**
+ * Classify a migration's up statements, in order. The statements are the
+ * file's own text, one per entry (a Flyway file after placeholder
+ * substitution).
+ */
+export declare function classifyPgStatements(statements: readonly string[]): StatementVerdict[];
+//# sourceMappingURL=statements.d.ts.map

package/dist/postgres/plan/statements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/statements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EAA0E,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAuP3I;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,gBAAgB,EAAE,CAyBtF"}