@intentius/chant-lexicon-sql 0.124.45 → 0.124.48

package/dist/postgres/entities.js

@@ -66,6 +66,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 +194,11 @@ export const STATEMENTS_OF = {
     aggregate: ["aggregate"],
     trigger: ["trigger"],
     eventTrigger: ["eventTrigger"],
+    operator: ["operator"],
+    statistics: ["statistics"],
+    foreignDataWrapper: ["foreignDataWrapper"],
+    foreignServer: ["foreignServer"],
+    publication: ["publication"],
     collation: ["collation"],
     cast: ["cast"],
     policy: ["policy"],
@@ -215,6 +221,11 @@ const TAG_OF = {
     aggregate: "aggregate",
     trigger: "trigger",
     eventTrigger: "eventTrigger",
+    operator: "operator",
+    statistics: "statistics",
+    foreignDataWrapper: "foreignDataWrapper",
+    foreignServer: "foreignServer",
+    publication: "publication",
     collation: "collation",
     cast: "cast",
     policy: "policy",
@@ -240,6 +251,11 @@ export const STATEMENT_NAMES = {
     aggregate: "CREATE AGGREGATE",
     trigger: "CREATE TRIGGER",
     eventTrigger: "CREATE EVENT TRIGGER",
+    operator: "CREATE OPERATOR",
+    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 +289,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 = [];
@@ -906,6 +938,83 @@ 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 "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 +1471,43 @@ 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);
+}
+/**
+ * `` 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,11 @@ export declare const POSTGRES_ENTITY_TYPES: {
     readonly collation: "Postgres::Collation";
     readonly cast: "Postgres::Cast";
     readonly eventTrigger: "Postgres::EventTrigger";
+    readonly operator: "Postgres::Operator";
+    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;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,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,11 @@ export const POSTGRES_ENTITY_TYPES = {
     collation: "Postgres::Collation",
     cast: "Postgres::Cast",
     eventTrigger: "Postgres::EventTrigger",
+    operator: "Postgres::Operator",
+    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;AAiDD,wEAAwE;AACxE,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAO,CAAC;AA8JrE,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,11 @@ 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.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 +65,10 @@ const UNREFERENCED = new Set([
     POSTGRES_ENTITY_TYPES.extension,
     POSTGRES_ENTITY_TYPES.cast,
     POSTGRES_ENTITY_TYPES.eventTrigger,
+    POSTGRES_ENTITY_TYPES.operator,
+    POSTGRES_ENTITY_TYPES.statistics,
+    POSTGRES_ENTITY_TYPES.foreignServer,
+    POSTGRES_ENTITY_TYPES.publication,
 ]);
 /** The tag each entity type is declared with (`table`, `func`, ...). */
 export const POSTGRES_TAG_OF = TAG;
@@ -115,6 +124,14 @@ function bareSpots(tokens) {
         }
         if (node.statement === "eventTrigger")
             name(node.function);
+        if (node.statement === "foreignServer")
+            name(node.wrapper);
+        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 +144,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 +177,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 +200,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,18 @@ 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[]>;
 //# 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,CA0E3G"}

package/dist/postgres/live/catalog-kinds.js

@@ -21,6 +21,7 @@ import { notExtensionOwned, scopeSql } from "./catalog.js";
 import { POSTGRES_ENTITY_TYPES } from "../entity-types.js";
 import { quoteIdent } from "../keywords.js";
 import { stripMarker } from "../../core/ownership.js";
+import { isSecretOption } from "../secret-options.js";
 const C = 'COLLATE "C"';
 const str = (v) => (v === null || v === undefined ? undefined : String(v));
 const literal = (s) => `'${s.replace(/'/g, "''")}'`;
@@ -299,3 +300,208 @@ export async function readRoutineKinds(client, scope) {
     }
     return out;
 }
+/** An operator named by another's COMMUTATOR or NEGATOR, as `OPERATOR(schema.symbol)`. */
+const operatorRef = (column) => `(SELECT 'OPERATOR(' || pg_catalog.quote_ident(rn.nspname) || '.' || r.oprname || ')' FROM pg_catalog.pg_operator r JOIN pg_catalog.pg_namespace rn ON rn.oid = r.oprnamespace WHERE r.oid = ${column})`;
+/**
+ * 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 async function readOperators(client, scope) {
+    const s = scopeSql("n.nspname", scope);
+    const rows = await client.query(`SELECT o.oid::text AS oid, n.nspname AS schema, o.oprname AS name,
+            CASE WHEN o.oprleft <> 0 THEN pg_catalog.format_type(o.oprleft, NULL) END AS leftarg,
+            CASE WHEN o.oprright <> 0 THEN pg_catalog.format_type(o.oprright, NULL) END AS rightarg,
+            ${proc("o.oprcode::pg_catalog.regproc")} AS func, ${operatorRef("o.oprcom")} AS commutator, ${operatorRef("o.oprnegate")} AS negator,
+            ${proc("o.oprrest::pg_catalog.regproc")} AS restrict, ${proc("o.oprjoin::pg_catalog.regproc")} AS join_func,
+            o.oprcanhash AS hashes, o.oprcanmerge AS merges,
+            pg_catalog.obj_description(o.oid, 'pg_operator') AS comment, ${dependentsOf("pg_operator", "o.oid")} AS dependents
+     FROM pg_catalog.pg_operator o JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace
+     WHERE ${s.sql} AND o.oid >= 16384 AND ${notExtensionOwned("pg_operator", "o.oid")}
+     ORDER BY n.nspname ${C}, o.oprname ${C}, pg_catalog.format_type(o.oprleft, NULL) ${C} NULLS FIRST, pg_catalog.format_type(o.oprright, NULL) ${C} NULLS FIRST`, s.params);
+    return rows.map((r) => {
+        const left = str(r.leftarg);
+        const right = str(r.rightarg);
+        const signature = `(${left ?? "NONE"},${right ?? "NONE"})`;
+        const name = `${quoteIdent(String(r.schema))}.${r.name}`;
+        const opts = [`FUNCTION = ${r.func}`];
+        if (left)
+            opts.push(`LEFTARG = ${left}`);
+        if (right)
+            opts.push(`RIGHTARG = ${right}`);
+        if (str(r.commutator))
+            opts.push(`COMMUTATOR = ${r.commutator}`);
+        if (str(r.negator))
+            opts.push(`NEGATOR = ${r.negator}`);
+        if (str(r.restrict))
+            opts.push(`RESTRICT = ${r.restrict}`);
+        if (str(r.join_func))
+            opts.push(`JOIN = ${r.join_func}`);
+        if (r.hashes === true)
+            opts.push("HASHES");
+        if (r.merges === true)
+            opts.push("MERGES");
+        return {
+            type: POSTGRES_ENTITY_TYPES.operator,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            signature,
+            ...withComment(r),
+            ...dependents(r),
+            statement: [`CREATE OPERATOR ${name} (${opts.join(", ")})`, ...commentOn(`OPERATOR ${name}${signature}`, r.comment)].join(";\n"),
+        };
+    });
+}
+/** An `OPTIONS (...)` clause from a catalog `text[]` of `name=value`, and the names left out because they hold a credential. */
+function optionsOf(raw) {
+    const kept = [];
+    const omitted = [];
+    for (const entry of raw ?? []) {
+        const at = entry.indexOf("=");
+        const name = at < 0 ? entry : entry.slice(0, at);
+        if (isSecretOption(name))
+            omitted.push(name);
+        else
+            kept.push(`${quoteIdent(name)} ${literal(at < 0 ? "" : entry.slice(at + 1))}`);
+    }
+    return { clause: kept.length > 0 ? ` OPTIONS (${kept.join(", ")})` : "", omitted };
+}
+const omittedWarning = (omitted) => omitted.length > 0 ? { warnings: [`the option${omitted.length === 1 ? "" : "s"} ${omitted.join(", ")} hold${omitted.length === 1 ? "s" : ""} a credential and ${omitted.length === 1 ? "is" : "are"} left out; the environment supplies it`] } : {};
+/**
+ * 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 async function readDatabaseKinds(client, scope) {
+    const out = [...(await readOperators(client, scope))];
+    const s = scopeSql("n.nspname", scope);
+    const stats = await client.query(`SELECT e.oid::text AS oid, n.nspname AS schema, e.stxname AS name, pg_catalog.pg_get_statisticsobjdef(e.oid) AS def,
+            pg_catalog.obj_description(e.oid, 'pg_statistic_ext') AS comment
+     FROM pg_catalog.pg_statistic_ext e JOIN pg_catalog.pg_namespace n ON n.oid = e.stxnamespace
+     WHERE ${s.sql} AND ${notExtensionOwned("pg_statistic_ext", "e.oid")}
+     ORDER BY n.nspname ${C}, e.stxname ${C}`, s.params);
+    for (const r of stats) {
+        const q = qname(String(r.schema), String(r.name));
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.statistics,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            statement: [String(r.def), ...commentOn(`STATISTICS ${q}`, r.comment)].join(";\n"),
+        });
+    }
+    const wrappers = await client.query(`SELECT w.oid::text AS oid, w.fdwname AS name, ${proc("w.fdwhandler::pg_catalog.regproc")} AS handler, ${proc("w.fdwvalidator::pg_catalog.regproc")} AS validator,
+            w.fdwoptions AS options, pg_catalog.obj_description(w.oid, 'pg_foreign_data_wrapper') AS comment, ${dependentsOf("pg_foreign_data_wrapper", "w.oid")} AS dependents
+     FROM pg_catalog.pg_foreign_data_wrapper w
+     WHERE ${notExtensionOwned("pg_foreign_data_wrapper", "w.oid")}
+     ORDER BY w.fdwname ${C}`);
+    for (const r of wrappers) {
+        const name = quoteIdent(String(r.name));
+        const { clause, omitted } = optionsOf(r.options);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.foreignDataWrapper,
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            ...omittedWarning(omitted),
+            statement: [
+                `CREATE FOREIGN DATA WRAPPER ${name}${str(r.handler) ? ` HANDLER ${r.handler}` : ""}${str(r.validator) ? ` VALIDATOR ${r.validator}` : ""}${clause}`,
+                ...commentOn(`FOREIGN DATA WRAPPER ${name}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    const servers = await client.query(`SELECT v.oid::text AS oid, v.srvname AS name, v.srvtype AS type, v.srvversion AS version, w.fdwname AS wrapper, v.srvoptions AS options,
+            pg_catalog.obj_description(v.oid, 'pg_foreign_server') AS comment, ${dependentsOf("pg_foreign_server", "v.oid")} AS dependents
+     FROM pg_catalog.pg_foreign_server v JOIN pg_catalog.pg_foreign_data_wrapper w ON w.oid = v.srvfdw
+     WHERE ${notExtensionOwned("pg_foreign_server", "v.oid")}
+     ORDER BY v.srvname ${C}`);
+    for (const r of servers) {
+        const name = quoteIdent(String(r.name));
+        const { clause, omitted } = optionsOf(r.options);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.foreignServer,
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            ...omittedWarning(omitted),
+            statement: [
+                `CREATE SERVER ${name}${str(r.type) ? ` TYPE ${literal(String(r.type))}` : ""}${str(r.version) ? ` VERSION ${literal(String(r.version))}` : ""} FOREIGN DATA WRAPPER ${quoteIdent(String(r.wrapper))}${clause}`,
+                ...commentOn(`SERVER ${name}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    out.push(...(await readPublications(client)));
+    return out;
+}
+/** Publications. Column lists, row filters and schema members are 15's; they are read where the catalog has them. */
+async function readPublications(client) {
+    const has = async (catalog, column) => {
+        const rows = await client.query(column
+            ? `SELECT 1 AS x FROM pg_catalog.pg_attribute WHERE attrelid = to_regclass('pg_catalog.${catalog}') AND attname = '${column}' AND NOT attisdropped`
+            : `SELECT 1 AS x WHERE to_regclass('pg_catalog.${catalog}') IS NOT NULL`);
+        return rows.length > 0;
+    };
+    const columnLists = await has("pg_publication_rel", "prattrs");
+    const schemaMembers = await has("pg_publication_namespace");
+    const pubs = await client.query(`SELECT p.oid::text AS oid, p.pubname AS name, p.puballtables AS alltables, p.pubinsert, p.pubupdate, p.pubdelete, p.pubtruncate,
+            pg_catalog.to_jsonb(p) AS def, pg_catalog.obj_description(p.oid, 'pg_publication') AS comment
+     FROM pg_catalog.pg_publication p
+     WHERE ${notExtensionOwned("pg_publication", "p.oid")}
+     ORDER BY p.pubname ${C}`);
+    const out = [];
+    for (const r of pubs) {
+        const name = quoteIdent(String(r.name));
+        const d = (typeof r.def === "string" ? JSON.parse(r.def) : r.def);
+        const tables = r.alltables
+            ? []
+            : await client.query(`SELECT n.nspname AS schema, c.relname AS name,
+                  ${columnLists ? "ARRAY(SELECT pg_catalog.quote_ident(a.attname) FROM pg_catalog.pg_attribute a WHERE a.attrelid = r.prrelid AND a.attnum = ANY(r.prattrs::pg_catalog.int2[]) ORDER BY a.attnum)" : "NULL::text[]"} AS columns,
+                  ${columnLists ? "pg_catalog.pg_get_expr(r.prqual, r.prrelid)" : "NULL::text"} AS filter
+           FROM pg_catalog.pg_publication_rel r JOIN pg_catalog.pg_class c ON c.oid = r.prrelid JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+           WHERE r.prpubid = $1::oid ORDER BY n.nspname ${C}, c.relname ${C}`, [String(r.oid)]);
+        const schemas = schemaMembers && !r.alltables
+            ? await client.query(`SELECT n.nspname AS name FROM pg_catalog.pg_publication_namespace pn JOIN pg_catalog.pg_namespace n ON n.oid = pn.pnnspid WHERE pn.pnpubid = $1::oid ORDER BY n.nspname ${C}`, [String(r.oid)])
+            : [];
+        const members = [
+            ...tables.map((t) => {
+                const columns = t.columns ?? [];
+                return `${qname(String(t.schema), String(t.name))}${columns.length > 0 ? ` (${columns.join(", ")})` : ""}${str(t.filter) ? ` WHERE (${t.filter})` : ""}`;
+            }),
+        ];
+        const clauses = [];
+        if (r.alltables)
+            clauses.push("FOR ALL TABLES");
+        else if (members.length > 0 || schemas.length > 0) {
+            const parts = [];
+            if (members.length > 0)
+                parts.push(`TABLE ${members.join(", ")}`);
+            if (schemas.length > 0)
+                parts.push(`TABLES IN SCHEMA ${schemas.map((x) => quoteIdent(String(x.name))).join(", ")}`);
+            clauses.push(`FOR ${parts.join(", ")}`);
+        }
+        const publish = [r.pubinsert && "insert", r.pubupdate && "update", r.pubdelete && "delete", r.pubtruncate && "truncate"].filter(Boolean);
+        const options = [];
+        if (publish.length !== 4)
+            options.push(`publish = ${literal(publish.join(", "))}`);
+        if (d.pubviaroot === true)
+            options.push("publish_via_partition_root = true");
+        if (d.pubgencols !== undefined && d.pubgencols !== "n")
+            options.push("publish_generated_columns = stored");
+        if (options.length > 0)
+            clauses.push(`WITH (${options.join(", ")})`);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.publication,
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            statement: [`CREATE PUBLICATION ${name}${clauses.length > 0 ? ` ${clauses.join(" ")}` : ""}`, ...commentOn(`PUBLICATION ${name}`, r.comment)].join(";\n"),
+        });
+    }
+    return out;
+}

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

@@ -74,6 +74,8 @@ export interface LivePgObject {
     dependents?: string[];
     /** Why no declaration can hold this object; it is read so import can say it left it out. */
     unsupported?: string;
+    /** What was left out of an object that is otherwise read (an option that holds a credential), for import to say. */
+    warnings?: string[];
 }
 /** What {@link readLiveSchema} reads. */
 export interface SchemaScope {

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

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAKjF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,iEAAiE;AACjE,eAAO,MAAM,cAAc,UAAmD,CAAC;AAE/E,gHAAgH;AAChH,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uIAAuI;IACvI,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iIAAiI;IACjI,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,4FAA4F;IAC5F,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,gHAAgH;IAChH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2GAA2G;IAC3G,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAqBD,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAM/F;AAED,yGAAyG;AACzG,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,EAAE,KAAK,MAAM,KAAG,MAC4F,CAAC;AAa9J,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAQD,yFAAyF;AACzF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,CAKtH;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAa9E;AAcD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,GAAE,WAAgB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA+f7G;AAED,+HAA+H;AAC/H,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,GAAG,SAAS,EAAE,MAAM,MAAM,EAAE,YAAY,MAAM,KAAG,MAA6D,CAAC;AAEnK;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GAAG,YAAY,EAAE,CAW1H"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAKjF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG3D,iEAAiE;AACjE,eAAO,MAAM,cAAc,UAAmD,CAAC;AAE/E,gHAAgH;AAChH,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,kBAAkB,CAAC;IACzB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,+FAA+F;IAC/F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uIAAuI;IACvI,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iIAAiI;IACjI,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,4FAA4F;IAC5F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oHAAoH;IACpH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,yCAAyC;AACzC,MAAM,WAAW,WAAW;IAC1B,gHAAgH;IAChH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2GAA2G;IAC3G,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC3B;AAqBD,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAM/F;AAED,yGAAyG;AACzG,eAAO,MAAM,iBAAiB,GAAI,SAAS,MAAM,EAAE,KAAK,MAAM,KAAG,MAC4F,CAAC;AAa9J,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAQD,yFAAyF;AACzF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,CAKtH;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,cAAc,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,CAa9E;AAcD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,GAAE,WAAgB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAkgB7G;AAED,+HAA+H;AAC/H,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,GAAG,SAAS,EAAE,MAAM,MAAM,EAAE,YAAY,MAAM,KAAG,MAA6D,CAAC;AAEnK;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,SAAS,GAAG,YAAY,EAAE,CAW1H"}

package/dist/postgres/live/catalog.js

@@ -50,7 +50,7 @@ import { hasChantTrailerKey, RECEIPTS_TRAILER_KEY, stripMarker } from "../../cor
 import { MIGRATION_TRAILER_KEY } from "../migrate/names.js";
 import { isProviderOwned, providerData } from "../providers/index.js";
 import { FOREIGN_TABLES } from "../../core/foreign-tables.js";
-import { readCollations, readRoutineKinds, readTypeKinds } from "./catalog-kinds.js";
+import { readCollations, readDatabaseKinds, readRoutineKinds, readTypeKinds } from "./catalog-kinds.js";
 /** The server's own schemas, never part of a declared schema. */
 export const SYSTEM_SCHEMAS = ["pg_catalog", "information_schema", "pg_toast"];
 /** Tables another tool keeps its migration history in, by name, with the tool; both dialects share the list. */
@@ -535,6 +535,8 @@ export async function readLiveSchema(client, scope = {}) {
     }
     // Aggregates, casts and event triggers, after the functions they call (#3911).
     out.push(...(await readRoutineKinds(client, scope)));
+    // Extended statistics, foreign data wrappers and servers, and publications (#3911).
+    out.push(...(await readDatabaseKinds(client, scope)));
     // Triggers: the ones written by hand, not a foreign key's or a partition's clone of its parent's.
     {
         const rows = await client.query(`SELECT t.oid::text AS oid, n.nspname AS schema, c.relname AS table_name, t.tgname AS name, pg_catalog.pg_get_triggerdef(t.oid, true) AS def,

package/dist/postgres/live/describe-resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAGL,KAAK,uBAAuB,EAG7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAoD,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AAYjH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EAAE,aAAa,EAAE,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAiBtK;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQxI;AAED,+HAA+H;AAC/H,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,GAAG,SAAS,CAWhJ;AAqDD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAMlC"}
+{"version":3,"file":"describe-resources.d.ts","sourceRoot":"","sources":["../../../src/postgres/live/describe-resources.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAGL,KAAK,uBAAuB,EAG7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAAoD,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AAoBjH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,EAAE,aAAa,EAAE,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAkBtK;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG;IAAE,MAAM,EAAE,kBAAkB,GAAG,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQxI;AAED,+HAA+H;AAC/H,wBAAgB,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,GAAG,SAAS,CAWhJ;AAqDD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,uBAAuB,CAAC,CAMlC"}