@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/postgres/entities.js

@@ -2,7 +2,8 @@
  * The Postgres entities: `schema`, `table`, `index`, `view`, `sequence`,
  * `type` (enum, composite and range), `domain`, `extension`, `func`,
  * `procedure`, `aggregate`, `trigger`, `eventTrigger`, `collation`, `cast`,
- * `policy`, `role` and `grant` tagged templates that parse their DDL at fold
+ * `operatorClass`, `operatorFamily`, `foreignTable`, `textSearchConfiguration`,
+ * `textSearchDictionary`, `policy`, `role` and `grant` tagged templates that parse their DDL at fold
  * time into one Declarable each (chant #3278, #3279, #3680, #3681, #3911).
  *
  * ```ts
@@ -66,6 +67,7 @@ export { SqlLiteral, SqlTemplateError } from "../core/template.js";
 export { quoteIdent } from "./keywords.js";
 export { POSTGRES_ENTITY_TYPES } from "./entity-types.js";
 import { POSTGRES_ENTITY_TYPES } from "./entity-types.js";
+import { isSecretOption } from "./secret-options.js";
 /**
  * A string as a quoted Postgres string literal: `'` doubled, a backslash left
  * as written (standard_conforming_strings is on). An interpolated plain string
@@ -193,6 +195,16 @@ export const STATEMENTS_OF = {
     aggregate: ["aggregate"],
     trigger: ["trigger"],
     eventTrigger: ["eventTrigger"],
+    operator: ["operator"],
+    operatorClass: ["operatorClass"],
+    operatorFamily: ["operatorFamily"],
+    foreignTable: ["foreignTable"],
+    textSearchConfiguration: ["textSearchConfiguration"],
+    textSearchDictionary: ["textSearchDictionary"],
+    statistics: ["statistics"],
+    foreignDataWrapper: ["foreignDataWrapper"],
+    foreignServer: ["foreignServer"],
+    publication: ["publication"],
     collation: ["collation"],
     cast: ["cast"],
     policy: ["policy"],
@@ -215,6 +227,17 @@ const TAG_OF = {
     aggregate: "aggregate",
     trigger: "trigger",
     eventTrigger: "eventTrigger",
+    operator: "operator",
+    operatorClass: "operatorClass",
+    operatorFamily: "operatorFamily",
+    foreignTable: "foreignTable",
+    textSearchConfiguration: "textSearchConfiguration",
+    textSearchDictionary: "textSearchDictionary",
+    textSearchMapping: undefined,
+    statistics: "statistics",
+    foreignDataWrapper: "foreignDataWrapper",
+    foreignServer: "foreignServer",
+    publication: "publication",
     collation: "collation",
     cast: "cast",
     policy: "policy",
@@ -240,6 +263,17 @@ export const STATEMENT_NAMES = {
     aggregate: "CREATE AGGREGATE",
     trigger: "CREATE TRIGGER",
     eventTrigger: "CREATE EVENT TRIGGER",
+    operator: "CREATE OPERATOR",
+    operatorClass: "CREATE OPERATOR CLASS",
+    operatorFamily: "CREATE OPERATOR FAMILY",
+    foreignTable: "CREATE FOREIGN TABLE",
+    textSearchConfiguration: "CREATE TEXT SEARCH CONFIGURATION",
+    textSearchDictionary: "CREATE TEXT SEARCH DICTIONARY",
+    textSearchMapping: "ALTER TEXT SEARCH CONFIGURATION",
+    statistics: "CREATE STATISTICS",
+    foreignDataWrapper: "CREATE FOREIGN DATA WRAPPER",
+    foreignServer: "CREATE SERVER",
+    publication: "CREATE PUBLICATION",
     collation: "CREATE COLLATION",
     cast: "CREATE CAST",
     policy: "CREATE POLICY",
@@ -273,6 +307,22 @@ function definitionValues(ctx, elems, path) {
         out[e.name] = e.value ? req(text(ctx, e.value, path)) : "true";
     return out;
 }
+/** A database-wide object's name (a wrapper, a server, a publication): one piece, or an interpolated object's name. */
+function databaseObjectName(ctx, n) {
+    feed(ctx, n.span, "name");
+    return n.pieces[0] || identValue(req(text(ctx, n.span)));
+}
+/** An `OPTIONS (...)` list's values by option name, each a string constant's value. */
+function genericOptionValues(tag, ctx, options) {
+    const out = {};
+    for (const o of options) {
+        if (isSecretOption(o.name)) {
+            throw new SqlTemplateError(tag, `the option ${o.name} holds a credential, which the environment supplies (a user mapping, or its secret store); a declaration never carries one`, 0, 0);
+        }
+        out[o.name] = req(stringValue(text(ctx, o.value, "options")));
+    }
+    return out;
+}
 /** A qualified name's schema and name. An interpolated schema names the schema; an interpolated object gives both. */
 function qualified(ctx, n) {
     const pieces = [];
@@ -332,7 +382,7 @@ function columnName(ctx, c) {
     const v = t?.kind === "ref" ? ctx.values[t.part] : undefined;
     return isColumnRef(v) ? v.attribute : req(text(ctx, c.span));
 }
-function columnDef(ctx, c) {
+function columnDef(ctx, c, tag = "table") {
     for (const span of [c.nameSpan, c.type, c.default, c.collate, c.compression, c.storage, c.generated?.expr, c.generated?.options])
         feed(ctx, span, "columns");
     const def = { name: columnName(ctx, { name: c.name, span: c.nameSpan }) };
@@ -357,6 +407,8 @@ function columnDef(ctx, c) {
     set("collate", text(ctx, c.collate));
     set("compression", text(ctx, c.compression));
     set("storage", text(ctx, c.storage));
+    if (c.options && c.options.length > 0)
+        def.options = genericOptionValues(tag, ctx, c.options);
     return def;
 }
 function deferral(c) {
@@ -434,7 +486,7 @@ function exclusionDef(ctx, c) {
  * the object itself, one of its columns, or one of its named constraints.
  * Anything else is refused, since a template declares one object.
  */
-function applyComments(tag, ctx, comments, self, objectTypes, parts = {}) {
+function applyComments(tag, ctx, comments, self, objectTypes, parts = {}, using) {
     let comment;
     const isSelf = (q) => q.name === self.name && (q.schema === undefined || self.schema === undefined || q.schema === self.schema);
     const refuse = (c, why) => {
@@ -492,6 +544,9 @@ function applyComments(tag, ctx, comments, self, objectTypes, parts = {}) {
             }
             else if (!isSelf(qualified(ctx, c.target)))
                 refuse(c, `names another object than ${sqlNameOf(self)}`);
+            // An operator class or family is named by its index method too.
+            if (using !== undefined && c.using !== using)
+                refuse(c, `names another index method than ${using}`);
             comment = value;
         }
     }
@@ -515,7 +570,7 @@ function lastDot(ctx, span) {
 export function followOnStray(tag, rest) {
     if (tag === "grant")
         return rest[0];
-    return rest.find((n) => n.statement !== "comment" && !(tag === "table" && n.statement === "rowSecurity"));
+    return rest.find((n) => n.statement !== "comment" && !(tag === "table" && n.statement === "rowSecurity") && !(tag === "textSearchConfiguration" && n.statement === "textSearchMapping"));
 }
 /**
  * The interpolations that sit inside a string constant (a routine's
@@ -748,7 +803,7 @@ function build(tag, strings, rawValues) {
     }
     const stray = followOnStray(tag, rest);
     if (stray) {
-        throw new SqlTemplateError(tag, `holds a second statement (${STATEMENT_NAMES[stray.statement]}); a template declares one object, followed only by COMMENT ON statements for it${tag === "table" ? " and ALTER TABLE ... ROW LEVEL SECURITY" : ""}`, 0, 0);
+        throw new SqlTemplateError(tag, `holds a second statement (${STATEMENT_NAMES[stray.statement]}); a template declares one object, followed only by COMMENT ON statements for it${tag === "table" ? " and ALTER TABLE ... ROW LEVEL SECURITY" : tag === "textSearchConfiguration" ? " and ALTER TEXT SEARCH CONFIGURATION ... ADD MAPPING" : ""}`, 0, 0);
     }
     const comments = rest.filter((n) => n.statement === "comment");
     const rowSecurity = rest.filter((n) => n.statement === "rowSecurity");
@@ -906,6 +961,196 @@ function build(tag, strings, rawValues) {
             }, []);
             return make(POSTGRES_ENTITY_TYPES.eventTrigger, { name }, props);
         }
+        case "operator": {
+            const q = qualified(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, q, ["OPERATOR"]);
+            const opt = definitionValues(ctx, node.options, "options");
+            const { leftarg, rightarg, procedure, ...rest } = opt;
+            const props = stripUnset({ ...q, leftArg: leftarg, rightArg: rightarg, options: { ...rest, function: opt.function ?? procedure }, comment, ddl, source });
+            // The symbol is unquoted wherever the operator is named: `app.===`.
+            return make(POSTGRES_ENTITY_TYPES.operator, q, props, undefined, q.schema ? `${quoteIdent(q.schema)}.${q.name}` : q.name);
+        }
+        case "operatorClass": {
+            const q = qualified(ctx, node.name);
+            if (node.method === "")
+                throw new SqlTemplateError(tag, "the index method is written out, not interpolated", 0, 0);
+            const comment = applyComments(tag, ctx, comments, q, ["OPERATOR CLASS"], {}, node.method);
+            const items = node.items.map((i) => {
+                if (i.kind === "storage")
+                    return { kind: "storage", type: req(text(ctx, i.type, "items")) };
+                if (i.kind === "function") {
+                    feed(ctx, i.function.span, "items");
+                    return stripUnset({ kind: "function", number: req(text(ctx, i.number, "items")), types: text(ctx, i.types, "items"), function: targetName(ctx, i.function), args: text(ctx, i.args, "items") ?? "" });
+                }
+                return stripUnset({
+                    kind: "operator",
+                    number: req(text(ctx, i.number, "items")),
+                    operator: req(text(ctx, i.operator.span, "items")),
+                    types: text(ctx, i.types, "items"),
+                    orderBy: i.orderBy ? targetName(ctx, i.orderBy) : undefined,
+                });
+            });
+            const props = stripUnset({
+                ...q,
+                default: node.default || undefined,
+                dataType: req(text(ctx, node.type, "dataType")),
+                method: node.method,
+                family: node.family ? targetName(ctx, node.family) : undefined,
+                items,
+                comment,
+                ddl,
+                source,
+            });
+            return make(POSTGRES_ENTITY_TYPES.operatorClass, q, props);
+        }
+        case "operatorFamily": {
+            const q = qualified(ctx, node.name);
+            if (node.method === "")
+                throw new SqlTemplateError(tag, "the index method is written out, not interpolated", 0, 0);
+            const comment = applyComments(tag, ctx, comments, q, ["OPERATOR FAMILY"], {}, node.method);
+            const props = stripUnset({ ...q, method: node.method, comment, ddl, source });
+            return make(POSTGRES_ENTITY_TYPES.operatorFamily, q, props);
+        }
+        case "foreignTable": {
+            const q = qualified(ctx, node.name);
+            const columns = node.columns.map((c) => columnDef(ctx, c, tag));
+            const checks = [];
+            const file = (c, cols) => {
+                if (c.kind === "CHECK")
+                    checks.push(checkDef(ctx, c));
+                else if (c.kind === "NOT NULL") {
+                    const col = columns.find((x) => x.name === cols[0]);
+                    if (!col)
+                        throw new SqlTemplateError(tag, `NOT NULL ${cols[0]} names no column of ${sqlNameOf(q)}`, 0, 0);
+                    col.notNull = true;
+                    if (c.name)
+                        col.notNullName = c.name;
+                }
+            };
+            node.columns.forEach((c, i) => c.constraints.forEach((k) => file(k, [columns[i].name])));
+            node.constraints.forEach((k) => file(k, k.columns.map((x) => columnName(ctx, x))));
+            const named = new Map();
+            for (const c of checks)
+                if (c.name)
+                    named.set(c.name, c);
+            const comment = applyComments(tag, ctx, comments, q, ["FOREIGN TABLE"], { columns: new Map(columns.map((c) => [c.name, c])), constraints: named });
+            const props = strip({
+                ...q,
+                ifNotExists: node.ifNotExists || undefined,
+                columns,
+                checks,
+                serverName: databaseObjectName(ctx, node.server),
+                options: genericOptionValues(tag, ctx, node.options),
+                comment,
+                ddl,
+                source,
+            }, ["columns", "checks", "options"]);
+            return make(POSTGRES_ENTITY_TYPES.foreignTable, q, props, columns.map((c) => c.name));
+        }
+        case "textSearchDictionary": {
+            const q = qualified(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, q, ["TEXT SEARCH DICTIONARY"]);
+            const { template, ...options } = definitionValues(ctx, node.options, "options");
+            const props = strip({ ...q, template: req(template), options, comment, ddl, source }, ["options"]);
+            return make(POSTGRES_ENTITY_TYPES.textSearchDictionary, q, props);
+        }
+        case "textSearchConfiguration": {
+            const q = qualified(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, q, ["TEXT SEARCH CONFIGURATION"]);
+            const opt = definitionValues(ctx, node.options, "options");
+            const seen = new Set();
+            const mappings = rest
+                .filter((n) => n.statement === "textSearchMapping")
+                .map((m) => {
+                feed(ctx, m.name.span, "mappings");
+                const t = qualified(ctx, m.name);
+                if (t.name !== q.name || (t.schema !== undefined && q.schema !== undefined && t.schema !== q.schema)) {
+                    throw new SqlTemplateError(tag, `ADD MAPPING names another configuration (${sqlNameOf(t)}) than ${sqlNameOf(q)}`, 0, 0);
+                }
+                const tokens = m.tokens.map((x) => x.name || identValue(req(text(ctx, x.span, "mappings"))));
+                for (const tok of tokens) {
+                    if (seen.has(tok))
+                        throw new SqlTemplateError(tag, `the token type ${tok} is mapped twice in ${sqlNameOf(q)}`, 0, 0);
+                    seen.add(tok);
+                }
+                for (const d of m.dictionaries)
+                    feed(ctx, d.span, "mappings");
+                return { tokens, dictionaries: m.dictionaries.map((d) => sqlNameOf(qualified(ctx, d))) };
+            });
+            const props = strip({ ...q, parser: req(opt.parser), mappings, comment, ddl, source }, ["mappings"]);
+            return make(POSTGRES_ENTITY_TYPES.textSearchConfiguration, q, props);
+        }
+        case "textSearchMapping":
+            // Only a configuration's follow-on statement (`followOnStray`); first in a template it is refused above.
+            throw new SqlTemplateError(tag, "holds an ALTER TEXT SEARCH CONFIGURATION before any CREATE", 0, 0);
+        case "statistics": {
+            const q = qualified(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, q, ["STATISTICS"]);
+            const props = strip({
+                ...q,
+                ifNotExists: node.ifNotExists || undefined,
+                kinds: node.kinds.length > 0 ? node.kinds : undefined,
+                targets: node.targets.map((t) => req(text(ctx, t, "targets"))),
+                table: target(ctx, node.table),
+                tableName: sqlNameOf(qualified(ctx, node.table)),
+                comment,
+                ddl,
+                source,
+            }, ["targets"]);
+            return make(POSTGRES_ENTITY_TYPES.statistics, q, props);
+        }
+        case "foreignDataWrapper": {
+            const name = databaseObjectName(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, { name }, ["FOREIGN DATA WRAPPER"]);
+            const props = strip({
+                name,
+                handler: node.handler ? target(ctx, node.handler) : undefined,
+                handlerName: node.handler ? targetName(ctx, node.handler) : undefined,
+                noHandler: node.handler === null ? true : undefined,
+                validator: node.validator ? target(ctx, node.validator) : undefined,
+                validatorName: node.validator ? targetName(ctx, node.validator) : undefined,
+                noValidator: node.validator === null ? true : undefined,
+                options: genericOptionValues(tag, ctx, node.options),
+                comment,
+                ddl,
+                source,
+            }, ["options"]);
+            return make(POSTGRES_ENTITY_TYPES.foreignDataWrapper, { name }, props);
+        }
+        case "foreignServer": {
+            const name = databaseObjectName(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, { name }, ["SERVER"]);
+            const props = strip({
+                name,
+                ifNotExists: node.ifNotExists || undefined,
+                serverType: node.type ? stringValue(text(ctx, node.type, "serverType")) : undefined,
+                version: node.version ? stringValue(text(ctx, node.version, "version")) : undefined,
+                wrapper: target(ctx, node.wrapper),
+                wrapperName: targetName(ctx, node.wrapper),
+                options: genericOptionValues(tag, ctx, node.options),
+                comment,
+                ddl,
+                source,
+            }, ["options"]);
+            return make(POSTGRES_ENTITY_TYPES.foreignServer, { name }, props);
+        }
+        case "publication": {
+            const name = databaseObjectName(ctx, node.name);
+            const comment = applyComments(tag, ctx, comments, { name }, ["PUBLICATION"]);
+            const tables = node.items.flatMap((i) => i.kind !== "table"
+                ? []
+                : [
+                    stripUnset({
+                        table: target(ctx, i.table),
+                        tableName: sqlNameOf(qualified(ctx, i.table)),
+                        columns: i.columns?.map((c) => columnName(ctx, { name: c.name, span: c.span })),
+                        where: text(ctx, i.where, "tables"),
+                    }),
+                ]);
+            const schemas = node.items.flatMap((i) => (i.kind === "schema" ? [qualified(ctx, i.schema).name] : []));
+            const props = strip({ name, allTables: node.allTables || undefined, tables, schemas, options: definitionValues(ctx, node.options, "options"), comment, ddl, source }, ["tables", "schemas", "options"]);
+            return make(POSTGRES_ENTITY_TYPES.publication, { name }, props);
+        }
         case "domain": {
             const q = qualified(ctx, node.name);
             const checks = node.checks.map((c) => stripUnset({ name: c.name, expr: req(text(ctx, c.expr, "checks")), notValid: c.notValid }));
@@ -1362,6 +1607,82 @@ export function cast(strings, ...values) {
 export function eventTrigger(strings, ...values) {
     return build("eventTrigger", strings, values);
 }
+/**
+ * `` operator`CREATE OPERATOR app.=== (FUNCTION = ${fn}, LEFTARG = int, RIGHTARG = int)` ``:
+ * one operator, identified by its name and operand types, as a function is by
+ * its name and parameter types.
+ */
+export function operator(strings, ...values) {
+    return build("operator", strings, values);
+}
+/**
+ * `` operatorClass`CREATE OPERATOR CLASS app.ops DEFAULT FOR TYPE int USING btree AS OPERATOR 1 <, FUNCTION 1 ${cmp}(int, int)` ``:
+ * one operator class, identified by its name and index method. Creating one takes a superuser.
+ */
+export function operatorClass(strings, ...values) {
+    return build("operatorClass", strings, values);
+}
+/**
+ * `` operatorFamily`CREATE OPERATOR FAMILY app.ops USING btree` ``: one operator
+ * family, identified by its name and index method. Its members come with the
+ * operator classes that name it. Creating one takes a superuser.
+ */
+export function operatorFamily(strings, ...values) {
+    return build("operatorFamily", strings, values);
+}
+/**
+ * `` foreignTable`CREATE FOREIGN TABLE app.remote_orders (id int, total numeric) SERVER ${remote} OPTIONS (table_name 'orders')` ``:
+ * one foreign table. It has its own tag, not `table`, because it is another
+ * kind of relation: another CREATE and ALTER, no key, index, partitioning or
+ * storage clauses, and a server it cannot move off.
+ */
+export function foreignTable(strings, ...values) {
+    return build("foreignTable", strings, values);
+}
+/**
+ * `` textSearchDictionary`CREATE TEXT SEARCH DICTIONARY app.english_stop (TEMPLATE = snowball, Language = english, StopWords = english)` ``:
+ * one text search dictionary: a template and its options.
+ */
+export function textSearchDictionary(strings, ...values) {
+    return build("textSearchDictionary", strings, values);
+}
+/**
+ * `` textSearchConfiguration`CREATE TEXT SEARCH CONFIGURATION app.english2 (PARSER = default); ALTER TEXT SEARCH CONFIGURATION app.english2 ADD MAPPING FOR asciiword WITH ${dict}` ``:
+ * one text search configuration: a parser, and the dictionaries each token
+ * type it finds is looked up in.
+ */
+export function textSearchConfiguration(strings, ...values) {
+    return build("textSearchConfiguration", strings, values);
+}
+/**
+ * `` statistics`CREATE STATISTICS name (ndistinct, dependencies) ON a, b FROM ${table}` ``:
+ * extended statistics on columns or expressions of one table.
+ */
+export function statistics(strings, ...values) {
+    return build("statistics", strings, values);
+}
+/**
+ * `` foreignDataWrapper`CREATE FOREIGN DATA WRAPPER name HANDLER ${fn} OPTIONS (...)` ``:
+ * one foreign data wrapper, the database's (no schema). Creating one takes a superuser.
+ */
+export function foreignDataWrapper(strings, ...values) {
+    return build("foreignDataWrapper", strings, values);
+}
+/**
+ * `` foreignServer`CREATE SERVER name FOREIGN DATA WRAPPER ${fdw} OPTIONS (host 'db.internal')` ``:
+ * one foreign server, the database's. Its user mappings carry credentials and are
+ * not declared; an option that holds a secret is the environment's to supply.
+ */
+export function foreignServer(strings, ...values) {
+    return build("foreignServer", strings, values);
+}
+/**
+ * `` publication`CREATE PUBLICATION name FOR TABLE ${t} WITH (publish = 'insert')` ``:
+ * one logical-replication publication, the database's.
+ */
+export function publication(strings, ...values) {
+    return build("publication", strings, values);
+}
 /** `` trigger`CREATE [OR REPLACE] [CONSTRAINT] TRIGGER name ... ON ${table} ... EXECUTE FUNCTION ${fn}()` ``: one trigger on its table. */
 export function trigger(strings, ...values) {
     return build("trigger", strings, values);

package/dist/postgres/entity-types.d.ts

@@ -17,6 +17,16 @@ export declare const POSTGRES_ENTITY_TYPES: {
     readonly collation: "Postgres::Collation";
     readonly cast: "Postgres::Cast";
     readonly eventTrigger: "Postgres::EventTrigger";
+    readonly operator: "Postgres::Operator";
+    readonly operatorClass: "Postgres::OperatorClass";
+    readonly operatorFamily: "Postgres::OperatorFamily";
+    readonly foreignTable: "Postgres::ForeignTable";
+    readonly textSearchConfiguration: "Postgres::TextSearchConfiguration";
+    readonly textSearchDictionary: "Postgres::TextSearchDictionary";
+    readonly statistics: "Postgres::Statistics";
+    readonly foreignDataWrapper: "Postgres::ForeignDataWrapper";
+    readonly foreignServer: "Postgres::ForeignServer";
+    readonly publication: "Postgres::Publication";
     readonly extension: "Postgres::Extension";
     readonly function: "Postgres::Function";
     readonly procedure: "Postgres::Procedure";

package/dist/postgres/entity-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-types.d.ts","sourceRoot":"","sources":["../../src/postgres/entity-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;CAuBxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"entity-types.d.ts","sourceRoot":"","sources":["../../src/postgres/entity-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCxB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/postgres/entity-types.js

@@ -17,6 +17,16 @@ export const POSTGRES_ENTITY_TYPES = {
     collation: "Postgres::Collation",
     cast: "Postgres::Cast",
     eventTrigger: "Postgres::EventTrigger",
+    operator: "Postgres::Operator",
+    operatorClass: "Postgres::OperatorClass",
+    operatorFamily: "Postgres::OperatorFamily",
+    foreignTable: "Postgres::ForeignTable",
+    textSearchConfiguration: "Postgres::TextSearchConfiguration",
+    textSearchDictionary: "Postgres::TextSearchDictionary",
+    statistics: "Postgres::Statistics",
+    foreignDataWrapper: "Postgres::ForeignDataWrapper",
+    foreignServer: "Postgres::ForeignServer",
+    publication: "Postgres::Publication",
     extension: "Postgres::Extension",
     function: "Postgres::Function",
     procedure: "Postgres::Procedure",

package/dist/postgres/import/generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/postgres/import/generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAKjE,kGAAkG;AAClG,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AACD,KAAK,IAAI,GAAG,cAAc,CAAC;AAE3B,uHAAuH;AACvH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAwCD,wEAAwE;AACxE,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAO,CAAC;AA+HrE,0DAA0D;AAC1D,eAAO,MAAM,QAAQ,GAAI,MAAM,YAAY,KAAG,MAA0F,CAAC;AAEzI;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,GAAE,SAAS,IAAI,EAAU,GAAG;IAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CAAE,CA6BhJ;AAaD,qBAAa,iBAAkB,YAAW,mBAAmB;IAG/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAFpC,QAAQ,CAAC,UAAU,QAAQ;gBAEE,MAAM,CAAC,EAAE,MAAM,YAAA;IAE5C,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,aAAa,EAAE;CAqB1C"}
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/postgres/import/generator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAKjE,kGAAkG;AAClG,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AACD,KAAK,IAAI,GAAG,cAAc,CAAC;AAE3B,uHAAuH;AACvH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAwDD,wEAAwE;AACxE,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAO,CAAC;AAmKrE,0DAA0D;AAC1D,eAAO,MAAM,QAAQ,GAAI,MAAM,YAAY,KAAG,MAA0F,CAAC;AAEzI;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,GAAE,SAAS,IAAI,EAAU,GAAG;IAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;CAAE,CA6BhJ;AAaD,qBAAa,iBAAkB,YAAW,mBAAmB;IAG/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAFpC,QAAQ,CAAC,UAAU,QAAQ;gBAEE,MAAM,CAAC,EAAE,MAAM,YAAA;IAE5C,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,aAAa,EAAE;CAqB1C"}

package/dist/postgres/import/generator.js

@@ -40,6 +40,16 @@ const TAG = {
     [POSTGRES_ENTITY_TYPES.collation]: "collation",
     [POSTGRES_ENTITY_TYPES.cast]: "cast",
     [POSTGRES_ENTITY_TYPES.eventTrigger]: "eventTrigger",
+    [POSTGRES_ENTITY_TYPES.operator]: "operator",
+    [POSTGRES_ENTITY_TYPES.operatorClass]: "operatorClass",
+    [POSTGRES_ENTITY_TYPES.operatorFamily]: "operatorFamily",
+    [POSTGRES_ENTITY_TYPES.foreignTable]: "foreignTable",
+    [POSTGRES_ENTITY_TYPES.textSearchConfiguration]: "textSearchConfiguration",
+    [POSTGRES_ENTITY_TYPES.textSearchDictionary]: "textSearchDictionary",
+    [POSTGRES_ENTITY_TYPES.statistics]: "statistics",
+    [POSTGRES_ENTITY_TYPES.foreignDataWrapper]: "foreignDataWrapper",
+    [POSTGRES_ENTITY_TYPES.foreignServer]: "foreignServer",
+    [POSTGRES_ENTITY_TYPES.publication]: "publication",
     [POSTGRES_ENTITY_TYPES.extension]: "extension",
     [POSTGRES_ENTITY_TYPES.function]: "func",
     [POSTGRES_ENTITY_TYPES.procedure]: "procedure",
@@ -60,6 +70,12 @@ const UNREFERENCED = new Set([
     POSTGRES_ENTITY_TYPES.extension,
     POSTGRES_ENTITY_TYPES.cast,
     POSTGRES_ENTITY_TYPES.eventTrigger,
+    POSTGRES_ENTITY_TYPES.operator,
+    // An index names a class, but a class and its own family share a name; a configuration shares one with a dictionary, which a mapping names.
+    POSTGRES_ENTITY_TYPES.operatorClass,
+    POSTGRES_ENTITY_TYPES.textSearchConfiguration,
+    POSTGRES_ENTITY_TYPES.statistics,
+    POSTGRES_ENTITY_TYPES.publication,
 ]);
 /** The tag each entity type is declared with (`table`, `func`, ...). */
 export const POSTGRES_TAG_OF = TAG;
@@ -115,6 +131,22 @@ function bareSpots(tokens) {
         }
         if (node.statement === "eventTrigger")
             name(node.function);
+        if (node.statement === "foreignServer")
+            name(node.wrapper);
+        if (node.statement === "foreignTable") {
+            for (const c of node.columns)
+                if (c.type)
+                    first(c.type.from, c.type.to);
+            name(node.server);
+        }
+        if (node.statement === "operatorClass")
+            first(node.type.from, node.type.to);
+        if (node.statement === "foreignDataWrapper") {
+            name(node.handler ?? undefined);
+            name(node.validator ?? undefined);
+        }
+        if (node.statement === "statistics")
+            name(node.table);
         if (node.statement === "index" || node.statement === "policy")
             name(node.table);
         if (node.statement === "trigger") {
@@ -127,6 +159,31 @@ function bareSpots(tokens) {
     }
     return out;
 }
+/** The tokens that name a schema in a publication's `TABLES IN SCHEMA a, b`, past the first, which follows the word SCHEMA. */
+function schemaSpots(tokens) {
+    const out = new Set();
+    let nodes;
+    try {
+        nodes = parseStatements(tokens);
+    }
+    catch {
+        return out;
+    }
+    for (const node of nodes) {
+        if (node.statement !== "publication")
+            continue;
+        for (const i of node.items) {
+            if (i.kind !== "schema")
+                continue;
+            for (let k = i.schema.span.from; k < i.schema.span.to; k++)
+                if (!isTrivia(tokens[k])) {
+                    out.add(k);
+                    break;
+                }
+        }
+    }
+    return out;
+}
 function templateBody(item, byQualified, schemaExport) {
     const tokens = tokenizeText(item.ddl, 0);
     const sig = [];
@@ -135,6 +192,7 @@ function templateBody(item, byQualified, schemaExport) {
             sig.push(i);
     });
     const spots = bareSpots(tokens);
+    const schemaAt = item.type === POSTGRES_ENTITY_TYPES.publication ? schemaSpots(tokens) : new Set();
     const replace = new Map();
     const isSelf = (target) => target === item || (target.exportName === item.exportName && target.type === item.type);
     for (let k = 0; k < sig.length; k++) {
@@ -157,10 +215,15 @@ function templateBody(item, byQualified, schemaExport) {
         }
         const dot = tokens[sig[k + 1] ?? -1];
         const b = tokens[sig[k + 2] ?? -1];
+        // An operator's own `schema.symbol`: the schema is the schema's export, though the symbol is no name.
+        if (item.type === POSTGRES_ENTITY_TYPES.operator && isName(a) && dot?.kind === "punct" && dot.text === "." && b?.kind === "op" && identValue(a) === item.schema && schemaExport.has(item.schema)) {
+            replace.set(sig[k], { to: sig[k] + 1, ref: schemaExport.get(item.schema) });
+            continue;
+        }
         if (!isName(a) || dot?.kind !== "punct" || dot.text !== "." || !isName(b)) {
             // An extension's `WITH SCHEMA app`, a grant's `ON SCHEMA app`, default privileges' `IN SCHEMA app`.
-            const bySchemaWord = item.type === POSTGRES_ENTITY_TYPES.extension || item.type === POSTGRES_ENTITY_TYPES.grant || item.type === POSTGRES_ENTITY_TYPES.defaultPrivileges;
-            if (bySchemaWord && isName(a) && prev?.kind === "ident" && prev.text.toUpperCase() === "SCHEMA") {
+            const bySchemaWord = item.type === POSTGRES_ENTITY_TYPES.extension || item.type === POSTGRES_ENTITY_TYPES.grant || item.type === POSTGRES_ENTITY_TYPES.defaultPrivileges || schemaAt.size > 0;
+            if (bySchemaWord && isName(a) && ((prev?.kind === "ident" && prev.text.toUpperCase() === "SCHEMA") || schemaAt.has(sig[k]))) {
                 const s = schemaExport.get(identValue(a));
                 if (s)
                     replace.set(sig[k], { to: sig[k] + 1, ref: s });

package/dist/postgres/import/live-export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-export.d.ts","sourceRoot":"","sources":["../../../src/postgres/import/live-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAS9D,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8HAA8H;IAC9H,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAyCvF"}
+{"version":3,"file":"live-export.d.ts","sourceRoot":"","sources":["../../../src/postgres/import/live-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAS9D,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8HAA8H;IAC9H,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0CvF"}

package/dist/postgres/import/live-export.js

@@ -77,6 +77,8 @@ export async function exportResources(options) {
             warnings.push(`${o.schema ? `${o.schema}.` : ""}${o.name} is kept by ${o.foreign}; left out, since declaring it would have chant change what that tool owns`);
             continue;
         }
+        for (const w of o.warnings ?? [])
+            warnings.push(`${o.schema ? `${o.schema}.` : ""}${o.name}: ${w}`);
         objects.push({ type: o.type, ...(o.schema ? { schema: o.schema } : {}), name: o.name, ddl: o.statement });
     }
     return objectsToIR([...objects, ...access], warnings);

package/dist/postgres/live/catalog-kinds.d.ts

@@ -25,4 +25,24 @@ export declare function readTypeKinds(client: PostgresClient, scope: SchemaScope
 export declare function readCollations(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]>;
 /** Aggregates, casts and event triggers: read after the functions they call. */
 export declare function readRoutineKinds(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]>;
+/**
+ * Operators: the ones a schema defines, not the server's own (oids below the
+ * first normal object id) or an extension's. Identified by name and operand
+ * types, `NONE` for a missing side (`DROP OPERATOR`'s spelling).
+ */
+export declare function readOperators(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]>;
+/**
+ * The kinds of object #3911 adds that belong to the database or hang off a
+ * table: extended statistics (printed by the server), foreign data wrappers
+ * and servers, and publications, each assembled from its catalog rows. A
+ * wrapper, server or publication is the database's, so the schema scope does
+ * not narrow it. A credential in an option is left out and said so.
+ */
+export declare function readDatabaseKinds(client: PostgresClient, scope: SchemaScope): Promise<LivePgObject[]>;
+/**
+ * A dictionary's `dictinitoption`, which the server prints as
+ * `name = 'value', ...` (a quote and a backslash doubled in the value), as a
+ * list of name and value; undefined when the text is not that form.
+ */
+export declare function parseDictionaryOptions(init: string | undefined): Array<[string, string]> | undefined;
 //# sourceMappingURL=catalog-kinds.d.ts.map

package/dist/postgres/live/catalog-kinds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog-kinds.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/catalog-kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAA+B,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AA0C7F,4GAA4G;AAC5G,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA0EvG;AAED,kFAAkF;AAClF,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAuCxG;AAID,gFAAgF;AAChF,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA8H1G"}
+{"version":3,"file":"catalog-kinds.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/catalog-kinds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAA+B,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AA2C7F,4GAA4G;AAC5G,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA0EvG;AAED,kFAAkF;AAClF,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAuCxG;AAID,gFAAgF;AAChF,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA8H1G;AAMD;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAwCvG;AAkBD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA2E3G;AA0KD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAcpG"}