@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/postgres/apply/statements.js

@@ -44,11 +44,13 @@ export const pgQualified = (schema, name) => (schema ? `${quoteIdent(schema)}.${
  */
 export const objectIdent = (o) => o.kind === "cast"
     ? o.name
-    : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.kind === "eventTrigger"
+    : o.kind === "schema" || o.kind === "extension" || o.kind === "role" || o.kind === "eventTrigger" || o.kind === "foreignDataWrapper" || o.kind === "foreignServer" || o.kind === "publication"
         ? quoteIdent(o.name)
         : o.kind === "trigger" || o.kind === "policy"
             ? `${quoteIdent(o.name)}${o.signature ?? ""}`
-            : `${pgQualified(o.schema, o.name)}${o.signature ?? ""}`;
+            : o.kind === "operator"
+                ? `${o.schema ? `${quoteIdent(o.schema)}.` : ""}${o.name}${o.signature ?? ""}`
+                : `${pgQualified(o.schema, o.name)}${o.signature ?? ""}`;
 /** The words a statement names the object's kind with. */
 export const KIND_WORDS = {
     schema: "SCHEMA",
@@ -68,6 +70,16 @@ export const KIND_WORDS = {
     collation: "COLLATION",
     cast: "CAST",
     eventTrigger: "EVENT TRIGGER",
+    operator: "OPERATOR",
+    operatorClass: "OPERATOR CLASS",
+    operatorFamily: "OPERATOR FAMILY",
+    foreignTable: "FOREIGN TABLE",
+    textSearchConfiguration: "TEXT SEARCH CONFIGURATION",
+    textSearchDictionary: "TEXT SEARCH DICTIONARY",
+    statistics: "STATISTICS",
+    foreignDataWrapper: "FOREIGN DATA WRAPPER",
+    foreignServer: "SERVER",
+    publication: "PUBLICATION",
     trigger: "TRIGGER",
     policy: "POLICY",
     role: "ROLE",
@@ -242,7 +254,7 @@ function identitySetClauses(options) {
         out.push("SET NO CYCLE");
     return out;
 }
-const COLUMN_FIELD = /^columns\.(.+?)(?:\.(type|default|notNull|generated|identity|collate|storage|comment))?$/;
+const COLUMN_FIELD = /^columns\.(.+?)(?:\.(type|default|notNull|generated|identity|collate|storage|options|comment))?$/;
 // ── Constraints ────────────────────────────────────────────────────────
 /** A table's declared constraints in the canonical order (primary key, unique, check, foreign key, exclusion), each with its props. */
 function declaredConstraintDefs(p) {
@@ -480,6 +492,196 @@ export function setNotNullSteps(table, column, live) {
     steps[0] = { ...steps[0], precheck: nullPrecheck(table, column) };
     return steps;
 }
+/** An `OPTIONS (...)` clause that takes the options `have` to `want`: ADD, SET and DROP per option; empty when they agree. */
+function optionsClause(want, have) {
+    const w = (want ?? {});
+    const h = (have ?? {});
+    const parts = [
+        ...Object.keys(w).filter((k) => !(k in h)).map((k) => `ADD ${quoteIdent(k)} ${pgString(w[k])}`),
+        ...Object.keys(w).filter((k) => k in h && h[k] !== w[k]).map((k) => `SET ${quoteIdent(k)} ${pgString(w[k])}`),
+        ...Object.keys(h).filter((k) => !(k in w)).map((k) => `DROP ${quoteIdent(k)}`),
+    ];
+    return parts.length > 0 ? `OPTIONS (${parts.join(", ")})` : "";
+}
+/** A publication's table as `ADD TABLE` writes it: its name, column list and row filter. */
+const publicationTable = (t) => `${t.table}${t.columns && t.columns.length > 0 ? ` (${t.columns.map(quoteIdent).join(", ")})` : ""}${t.where ? ` WHERE (${t.where})` : ""}`;
+/**
+ * The ALTER statements that take a foreign data wrapper, a foreign server or
+ * a publication to the declaration, in place (SQLPG303): one ALTER for a
+ * wrapper or server; for a publication one SET (...) for its options, and a
+ * DROP and ADD per table or schema that changed.
+ */
+function alteredSteps(d, live, target) {
+    const out = [];
+    const f = d.fields;
+    const l = live.fields;
+    if (d.kind === "foreignDataWrapper") {
+        const clauses = [
+            !same(f.handler, l.handler) ? (f.handler ? `HANDLER ${String(f.handler)}` : "NO HANDLER") : "",
+            !same(f.validator, l.validator) ? (f.validator ? `VALIDATOR ${String(f.validator)}` : "NO VALIDATOR") : "",
+            optionsClause(f.options, l.options),
+        ].filter(Boolean);
+        if (clauses.length > 0)
+            out.push(`ALTER FOREIGN DATA WRAPPER ${target} ${clauses.join(" ")}`);
+    }
+    else if (d.kind === "foreignServer") {
+        const clauses = [!same(f.version, l.version) ? `VERSION ${f.version === undefined ? "NULL" : pgString(String(f.version))}` : "", optionsClause(f.options, l.options)].filter(Boolean);
+        if (clauses.length > 0)
+            out.push(`ALTER SERVER ${target} ${clauses.join(" ")}`);
+    }
+    else if (d.kind === "publication") {
+        const sets = [];
+        if (!same(f.publish, l.publish))
+            sets.push(`publish = ${pgString((f.publish ?? ["insert", "update", "delete", "truncate"]).join(", "))}`);
+        if (!same(f.viaRoot, l.viaRoot))
+            sets.push(`publish_via_partition_root = ${f.viaRoot === true}`);
+        if (!same(f.generatedColumns, l.generatedColumns))
+            sets.push(`publish_generated_columns = ${String(f.generatedColumns ?? "none")}`);
+        if (sets.length > 0)
+            out.push(`ALTER PUBLICATION ${target} SET (${sets.join(", ")})`);
+        const want = f.tables ?? [];
+        const have = l.tables ?? [];
+        const kept = (m) => want.some((w) => w.table === m.table && same(w, m));
+        for (const m of have)
+            if (!kept(m))
+                out.push(`ALTER PUBLICATION ${target} DROP TABLE ${m.table}`);
+        for (const m of want)
+            if (!have.some((h) => h.table === m.table && same(h, m)))
+                out.push(`ALTER PUBLICATION ${target} ADD TABLE ${publicationTable(m)}`);
+        const wantSchemas = f.schemas ?? [];
+        const haveSchemas = l.schemas ?? [];
+        for (const s of haveSchemas)
+            if (!wantSchemas.includes(s))
+                out.push(`ALTER PUBLICATION ${target} DROP TABLES IN SCHEMA ${s}`);
+        for (const s of wantSchemas)
+            if (!haveSchemas.includes(s))
+                out.push(`ALTER PUBLICATION ${target} ADD TABLES IN SCHEMA ${s}`);
+    }
+    return out.map((sql) => step(sql, "metadata", "SQLPG303"));
+}
+// ── Operators, text search and foreign tables (#4406) ──────────────────
+/**
+ * The clauses of `ALTER OPERATOR ... SET (...)` for the attributes the diff
+ * found changeable in place (SQLPG304): RESTRICT and JOIN to the declared
+ * estimator or NONE, COMMUTATOR and NEGATOR to the declared operator, and
+ * HASHES and MERGES as bare words, since they can only be turned on.
+ */
+function operatorSetClauses(d, changes) {
+    const definition = (d.fields.definition ?? {});
+    return changes.map((c) => {
+        const key = c.field.replace(/^definition\./, "");
+        const value = definition[key];
+        if (key === "hashes" || key === "merges")
+            return key.toUpperCase();
+        if (key === "commutator" || key === "negator")
+            return `${key.toUpperCase()} = OPERATOR(${value})`;
+        return `${key.toUpperCase()} = ${value ?? "NONE"}`;
+    });
+}
+/**
+ * A text search configuration's mappings, or a dictionary's options, taken to
+ * the declaration in place (SQLPG305). For a configuration: DROP MAPPING for
+ * the token types no longer mapped, ALTER MAPPING for those whose dictionaries
+ * changed, ADD MAPPING for the new ones, one statement for the token types
+ * that share their dictionaries; the dictionaries are named as the
+ * declaration wrote them. For a dictionary: one ALTER with each option that
+ * differs set, and each option the declaration dropped named with no value,
+ * which removes it.
+ */
+function textSearchSteps(obj, live, target) {
+    const d = obj.canonical;
+    if (d.kind === "textSearchDictionary") {
+        const want = (d.fields.options ?? {});
+        const have = (live.fields.options ?? {});
+        const parts = [
+            ...Object.keys(want).filter((k) => have[k] !== want[k]).map((k) => `${quoteIdent(k)} = ${pgString(want[k])}`),
+            ...Object.keys(have).filter((k) => !(k in want)).map((k) => quoteIdent(k)),
+        ];
+        return parts.length > 0 ? [step(`ALTER TEXT SEARCH DICTIONARY ${target} (${parts.join(", ")})`, "metadata", "SQLPG305")] : [];
+    }
+    const want = (d.fields.mappings ?? {});
+    const have = (live.fields.mappings ?? {});
+    const written = new Map();
+    for (const m of obj.props.mappings)
+        for (const t of m.tokens)
+            written.set(t.toLowerCase(), m.dictionaries);
+    const group = (tokens) => {
+        const out = new Map();
+        for (const t of tokens) {
+            const key = JSON.stringify(want[t]);
+            out.set(key, [...(out.get(key) ?? []), t]);
+        }
+        return out;
+    };
+    const dropped = Object.keys(have).filter((t) => !(t in want));
+    const added = Object.keys(want).filter((t) => !(t in have));
+    const changed = Object.keys(want).filter((t) => t in have && JSON.stringify(have[t]) !== JSON.stringify(want[t]));
+    const names = (tokens) => tokens.map(quoteIdent).join(", ");
+    const out = [];
+    if (dropped.length > 0)
+        out.push(step(`ALTER TEXT SEARCH CONFIGURATION ${target} DROP MAPPING FOR ${names(dropped)}`, "metadata", "SQLPG305"));
+    for (const [verb, tokens] of [["ALTER", changed], ["ADD", added]]) {
+        for (const members of group(tokens).values())
+            out.push(step(`ALTER TEXT SEARCH CONFIGURATION ${target} ${verb} MAPPING FOR ${names(members)} WITH ${written.get(members[0]).join(", ")}`, "metadata", "SQLPG305"));
+    }
+    return out;
+}
+/**
+ * A foreign table's changes in place (SQLPG306), as ALTER FOREIGN TABLE
+ * makes them: ADD and DROP COLUMN, a column's type, default, NOT NULL and
+ * OPTIONS, CHECK constraints added and dropped, and the table's OPTIONS.
+ * A column added with options gets them in an ALTER of its own, since ADD
+ * COLUMN has no OPTIONS clause.
+ */
+function foreignTableSteps(c, obj, live, alterKind) {
+    const d = obj.canonical;
+    const props = obj.props;
+    const make = (sql) => step(sql, "metadata", "SQLPG306");
+    if (c.field === "options") {
+        const clause = optionsClause(d.fields.options, live.fields.options);
+        return clause ? [make(`${alterKind} ${clause}`)] : [];
+    }
+    if (c.field.startsWith("constraints.")) {
+        const key = c.field.slice("constraints.".length);
+        // A declared CHECK the server lacks is added; one it has and the declaration dropped is dropped by the server's name.
+        if (c.before === undefined) {
+            const i = d.constraints.findIndex((a) => (a.name ?? a.kind.toLowerCase()) === key && !live.constraints.some((b) => sameConstraint(a, b)));
+            return i >= 0 && props.checks[i] ? [make(`${alterKind} ADD ${constraintSql("CHECK", props.checks[i])}`)] : [];
+        }
+        return [make(`${alterKind} DROP CONSTRAINT ${quoteIdent(key)}`)];
+    }
+    const m = COLUMN_FIELD.exec(c.field);
+    if (!m)
+        return [];
+    const name = m[1];
+    const prop = m[2];
+    const def = props.columns.find((x) => x.name === name);
+    const column = `${alterKind} ALTER COLUMN ${quoteIdent(name)}`;
+    const liveColumn = live.columns.find((x) => x.name === name);
+    if (prop === undefined) {
+        if (!def)
+            return [make(`${alterKind} DROP COLUMN ${quoteIdent(name)}`)];
+        const options = optionsClause(def.options, undefined);
+        return [make(`${alterKind} ADD COLUMN ${columnDefinition(def)}`), ...(options ? [make(`${column} ${options}`)] : [])];
+    }
+    if (!def)
+        return [];
+    switch (prop) {
+        case "type":
+        case "collate":
+            return def.type ? [make(`${column} TYPE ${def.type}${def.collate ? ` COLLATE ${def.collate}` : prop === "collate" ? ' COLLATE "default"' : ""}`)] : [];
+        case "default":
+            return [make(def.default !== undefined ? `${column} SET DEFAULT ${def.default}` : `${column} DROP DEFAULT`)];
+        case "notNull":
+            return [make(`${column} ${def.notNull ? "SET" : "DROP"} NOT NULL`)];
+        case "options": {
+            const clause = optionsClause(def.options, liveColumn?.options);
+            return clause ? [make(`${column} ${clause}`)] : [];
+        }
+        default:
+            return [];
+    }
+}
 /**
  * The statements for an object that exists on the server, change by change.
  * `live` is the server's definition, matched to the declaration (a renamed
@@ -510,6 +712,16 @@ export function alterSteps(obj, live, changes, opts) {
             steps.push(...createSteps(obj, opts.marker, { cls: c.class, rule: c.rule }));
             continue;
         }
+        if (c.rule === "SQLPG306") {
+            steps.push(...foreignTableSteps(c, obj, live, alterKind));
+            continue;
+        }
+        if (d.kind === "foreignTable" && c.rule === "SQLPG216" && /^constraints\.[^.]+\.comment$/.test(c.field)) {
+            const name = c.field.split(".")[1];
+            const declared = d.constraints.find((a) => (a.name ?? a.kind.toLowerCase()) === name);
+            steps.push(step(`COMMENT ON CONSTRAINT ${quoteIdent(name)} ON ${target} IS ${declared?.comment === undefined ? "NULL" : pgString(declared.comment)}`, c.class, c.rule));
+            continue;
+        }
         if (c.field.startsWith("constraints.")) {
             if (!constraintsDone)
                 steps.push(...constraintSteps(obj, live, notNullChecks));
@@ -517,7 +729,7 @@ export function alterSteps(obj, live, changes, opts) {
             continue;
         }
         const col = COLUMN_FIELD.exec(c.field);
-        if (col && (d.kind === "table")) {
+        if (col && (d.kind === "table" || d.kind === "foreignTable")) {
             const name = col[1];
             const prop = col[2];
             const def = columns.get(name);
@@ -633,6 +845,18 @@ export function alterSteps(obj, live, changes, opts) {
             case "SQLPG229":
                 steps.push(step(`ALTER INDEX ${objectIdent(live)} RENAME TO ${quoteIdent(d.name)}`, c.class, c.rule));
                 break;
+            case "SQLPG303":
+                if (!steps.some((s) => s.rule === "SQLPG303"))
+                    steps.push(...alteredSteps(d, live, target));
+                break;
+            case "SQLPG304":
+                if (!steps.some((s) => s.rule === "SQLPG304"))
+                    steps.push(step(`ALTER OPERATOR ${target} SET (${operatorSetClauses(d, changes.filter((x) => x.rule === "SQLPG304")).join(", ")})`, c.class, c.rule));
+                break;
+            case "SQLPG305":
+                if (!steps.some((s) => s.rule === "SQLPG305"))
+                    steps.push(...textSearchSteps(obj, live, target));
+                break;
             case "SQLPG250":
             case "SQLPG280":
             case "SQLPG302":
@@ -756,15 +980,30 @@ const DROP_ORDER = {
     defaultPrivileges: 0,
     policy: 0,
     trigger: 0,
+    // A publication reads tables, extended statistics are on one: both go before it.
+    publication: 0,
+    statistics: 0,
     materializedView: 1,
     view: 2,
     index: 3,
     table: 4,
+    // A foreign table reads a foreign server (below) and a type; a view on it goes before.
+    foreignTable: 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,
+    operator: 5.5,
+    // A class names operators and functions; a family goes after its classes.
+    operatorClass: 5.2,
+    operatorFamily: 5.3,
+    // A configuration maps token types to dictionaries, so it goes first.
+    textSearchConfiguration: 5.7,
+    textSearchDictionary: 5.8,
+    // A server before its wrapper, a wrapper before the handler function it calls.
+    foreignServer: 5.5,
+    foreignDataWrapper: 5.6,
     // A routine after what calls it (a view, a trigger, a default), before the types its parameters use.
     function: 6,
     procedure: 6,

package/dist/postgres/constraint-names.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The names Postgres gives a constraint or an index that the DDL leaves
+ * unnamed, so a reader of the declarations can spell them without a server.
+ *
+ * `makeObjectName` and the `Choose*Name` functions are from the Postgres
+ * source (`src/backend/commands/indexcmds.c`, `src/backend/catalog/heap.c`,
+ * `src/backend/commands/tablecmds.c`): the table name, then the column
+ * names joined with `_`, then a label (`pkey`, `key`, `fkey`, `check`),
+ * cut to 63 bytes by shortening the longer of the first two parts one
+ * character at a time. A name already taken gets a number after the label
+ * (`orders_pkey1`).
+ *
+ * A name the author writes always wins; these are for the rest. Drizzle's
+ * own derived names (`orders_user_id_users_id_fk`) differ from them, which is
+ * why the Drizzle export names every constraint it writes.
+ */
+/** `makeObjectName(name1, name2, label)`: ASCII names only. */
+export declare function makeObjectName(name1: string, name2: string | undefined, label: string | undefined): string;
+/** The first of `label`, `label1`, `label2`, ... that gives a name not in `taken`. */
+export declare function chooseName(name1: string, name2: string | undefined, label: string, taken: ReadonlySet<string>): string;
+/** The column names of a key or foreign key, joined as Postgres joins them. */
+export declare const columnsAddition: (columns: readonly string[]) => string;
+/**
+ * The identifiers `expr` reads as column names: words outside quotes and
+ * string literals that are not followed by `(`, and are in `columns`.
+ */
+export declare function referencedColumns(expr: string, columns: readonly string[]): string[];
+/** A check constraint's default name: the column when the expression reads one, else just the table. */
+export declare function checkName(table: string, expr: string, columns: readonly string[], taken: ReadonlySet<string>): string;
+//# sourceMappingURL=constraint-names.d.ts.map

package/dist/postgres/constraint-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-names.d.ts","sourceRoot":"","sources":["../../src/postgres/constraint-names.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,+DAA+D;AAC/D,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAkB1G;AAED,sFAAsF;AACtF,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAKtH;AAED,+EAA+E;AAC/E,eAAO,MAAM,eAAe,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,MAA2B,CAAC;AAEzF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CASpF;AAED,wGAAwG;AACxG,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,CAGrH"}

package/dist/postgres/constraint-names.js

@@ -0,0 +1,72 @@
+/**
+ * The names Postgres gives a constraint or an index that the DDL leaves
+ * unnamed, so a reader of the declarations can spell them without a server.
+ *
+ * `makeObjectName` and the `Choose*Name` functions are from the Postgres
+ * source (`src/backend/commands/indexcmds.c`, `src/backend/catalog/heap.c`,
+ * `src/backend/commands/tablecmds.c`): the table name, then the column
+ * names joined with `_`, then a label (`pkey`, `key`, `fkey`, `check`),
+ * cut to 63 bytes by shortening the longer of the first two parts one
+ * character at a time. A name already taken gets a number after the label
+ * (`orders_pkey1`).
+ *
+ * A name the author writes always wins; these are for the rest. Drizzle's
+ * own derived names (`orders_user_id_users_id_fk`) differ from them, which is
+ * why the Drizzle export names every constraint it writes.
+ */
+const NAMEDATALEN = 64;
+/** `makeObjectName(name1, name2, label)`: ASCII names only. */
+export function makeObjectName(name1, name2, label) {
+    let overhead = 0;
+    let n2 = 0;
+    if (name2 !== undefined) {
+        n2 = name2.length;
+        overhead++;
+    }
+    if (label !== undefined)
+        overhead += label.length + 1;
+    const avail = NAMEDATALEN - 1 - overhead;
+    let n1 = name1.length;
+    while (n1 + n2 > avail) {
+        if (n1 > n2)
+            n1--;
+        else
+            n2--;
+    }
+    let name = name1.slice(0, n1);
+    if (name2 !== undefined)
+        name += `_${name2.slice(0, n2)}`;
+    if (label !== undefined)
+        name += `_${label}`;
+    return name;
+}
+/** The first of `label`, `label1`, `label2`, ... that gives a name not in `taken`. */
+export function chooseName(name1, name2, label, taken) {
+    let pass = 0;
+    let candidate = makeObjectName(name1, name2, label);
+    while (taken.has(candidate))
+        candidate = makeObjectName(name1, name2, `${label}${++pass}`);
+    return candidate;
+}
+/** The column names of a key or foreign key, joined as Postgres joins them. */
+export const columnsAddition = (columns) => columns.join("_");
+/**
+ * The identifiers `expr` reads as column names: words outside quotes and
+ * string literals that are not followed by `(`, and are in `columns`.
+ */
+export function referencedColumns(expr, columns) {
+    const known = new Set(columns);
+    const found = new Set();
+    const re = /'(?:[^']|'')*'|"((?:[^"]|"")+)"|([A-Za-z_][\w$]*)(?!\s*\()(?!\s*\.)/g;
+    for (let m = re.exec(expr); m; m = re.exec(expr)) {
+        const name = m[1] !== undefined ? m[1].replace(/""/g, '"') : m[2];
+        if (name !== undefined && known.has(m[1] !== undefined ? name : name.toLowerCase()))
+            found.add(m[1] !== undefined ? name : name.toLowerCase());
+    }
+    return [...found];
+}
+/** A check constraint's default name: the column when the expression reads one, else just the table. */
+export function checkName(table, expr, columns, taken) {
+    const refs = referencedColumns(expr, columns);
+    return chooseName(table, refs.length === 1 ? refs[0] : undefined, "check", taken);
+}