@intentius/chant-lexicon-sql 0.124.48 → 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
@@ -195,6 +196,11 @@ export const STATEMENTS_OF = {
     trigger: ["trigger"],
     eventTrigger: ["eventTrigger"],
     operator: ["operator"],
+    operatorClass: ["operatorClass"],
+    operatorFamily: ["operatorFamily"],
+    foreignTable: ["foreignTable"],
+    textSearchConfiguration: ["textSearchConfiguration"],
+    textSearchDictionary: ["textSearchDictionary"],
     statistics: ["statistics"],
     foreignDataWrapper: ["foreignDataWrapper"],
     foreignServer: ["foreignServer"],
@@ -222,6 +228,12 @@ const TAG_OF = {
     trigger: "trigger",
     eventTrigger: "eventTrigger",
     operator: "operator",
+    operatorClass: "operatorClass",
+    operatorFamily: "operatorFamily",
+    foreignTable: "foreignTable",
+    textSearchConfiguration: "textSearchConfiguration",
+    textSearchDictionary: "textSearchDictionary",
+    textSearchMapping: undefined,
     statistics: "statistics",
     foreignDataWrapper: "foreignDataWrapper",
     foreignServer: "foreignServer",
@@ -252,6 +264,12 @@ export const STATEMENT_NAMES = {
     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",
@@ -364,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 }) };
@@ -389,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) {
@@ -466,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) => {
@@ -524,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;
         }
     }
@@ -547,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
@@ -780,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");
@@ -947,6 +970,119 @@ function build(tag, strings, rawValues) {
             // 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"]);
@@ -1479,6 +1615,45 @@ export function eventTrigger(strings, ...values) {
 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.

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

@@ -18,6 +18,11 @@ export declare const POSTGRES_ENTITY_TYPES: {
     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";

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,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

@@ -18,6 +18,11 @@ export const POSTGRES_ENTITY_TYPES = {
     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",

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;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"}
+{"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

@@ -41,6 +41,11 @@ const TAG = {
     [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",
@@ -66,8 +71,10 @@ const UNREFERENCED = new Set([
     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.foreignServer,
     POSTGRES_ENTITY_TYPES.publication,
 ]);
 /** The tag each entity type is declared with (`table`, `func`, ...). */
@@ -126,6 +133,14 @@ function bareSpots(tokens) {
             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);

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

@@ -39,4 +39,10 @@ export declare function readOperators(client: PostgresClient, scope: SchemaScope
  * 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;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"}
+{"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"}

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

@@ -437,6 +437,7 @@ export async function readDatabaseKinds(client, scope) {
         });
     }
     out.push(...(await readPublications(client)));
+    out.push(...(await readOperatorClasses(client, scope)), ...(await readTextSearch(client, scope)), ...(await readForeignTables(client, scope)));
     return out;
 }
 /** Publications. Column lists, row filters and schema members are 15's; they are read where the catalog has them. */
@@ -505,3 +506,248 @@ async function readPublications(client) {
     }
     return out;
 }
+// ── Operator classes and families, text search, foreign tables (#4406) ──
+/** An object named by `schema`.`name` columns, as a clause: a `pg_catalog` one bare. */
+const refName = (schema, name) => `CASE WHEN ${schema} = 'pg_catalog' THEN pg_catalog.quote_ident(${name}) ELSE pg_catalog.quote_ident(${schema}) || '.' || pg_catalog.quote_ident(${name}) END`;
+/** An operand type, `NONE` for the missing side of a prefix operator. */
+const operand = (column) => `CASE WHEN ${column} = 0 THEN 'NONE' ELSE pg_catalog.format_type(${column}, NULL) END`;
+/**
+ * Operator classes and families. A class carries its members: the operators
+ * and support functions that depend on it (`pg_depend`, a member made by
+ * CREATE OPERATOR CLASS depends on the class; one added by ALTER OPERATOR
+ * FAMILY ... ADD depends on the family and is "loose"). A family named as its
+ * class, in the same schema, is the one CREATE OPERATOR CLASS made for it and
+ * is the class's; every other family is read, with a warning when it holds
+ * loose members, which a declaration cannot carry.
+ */
+async function readOperatorClasses(client, scope) {
+    const out = [];
+    const s = scopeSql("n.nspname", scope);
+    const member = (catalog, alias) => `JOIN pg_catalog.pg_depend dep ON dep.classid = '${catalog}'::pg_catalog.regclass AND dep.objid = ${alias}.oid AND dep.refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass AND dep.refobjid = c.oid`;
+    const classes = await client.query(`SELECT c.oid::text AS oid, n.nspname AS schema, c.opcname AS name, am.amname AS method, c.opcdefault AS isdefault,
+            pg_catalog.format_type(c.opcintype, NULL) AS type,
+            CASE WHEN c.opckeytype <> 0 THEN pg_catalog.format_type(c.opckeytype, NULL) END AS storage,
+            CASE WHEN f.opfname = c.opcname AND f.opfnamespace = c.opcnamespace THEN NULL ELSE ${refName("fn.nspname", "f.opfname")} END AS family,
+            ARRAY(SELECT 'OPERATOR ' || o.amopstrategy || ' ' || pg_catalog.quote_ident(opn.nspname) || '.' || op.oprname ||
+                         ' (' || ${operand("o.amoplefttype")} || ', ' || ${operand("o.amoprighttype")} || ')' ||
+                         CASE WHEN o.amoppurpose = 'o' THEN ' FOR ORDER BY ' || (SELECT pg_catalog.quote_ident(sn.nspname) || '.' || pg_catalog.quote_ident(sf.opfname)
+                              FROM pg_catalog.pg_opfamily sf JOIN pg_catalog.pg_namespace sn ON sn.oid = sf.opfnamespace WHERE sf.oid = o.amopsortfamily) ELSE '' END
+                  FROM pg_catalog.pg_amop o ${member("pg_catalog.pg_amop", "o")}
+                  JOIN pg_catalog.pg_operator op ON op.oid = o.amopopr JOIN pg_catalog.pg_namespace opn ON opn.oid = op.oprnamespace
+                  ORDER BY o.amopstrategy, o.amoplefttype, o.amoprighttype) AS operators,
+            ARRAY(SELECT 'FUNCTION ' || p.amprocnum || ' (' || ${operand("p.amproclefttype")} || ', ' || ${operand("p.amprocrighttype")} || ') ' || p.amproc::pg_catalog.regprocedure::pg_catalog.text
+                  FROM pg_catalog.pg_amproc p ${member("pg_catalog.pg_amproc", "p")}
+                  ORDER BY p.amprocnum, p.amproclefttype, p.amprocrighttype) AS functions,
+            pg_catalog.obj_description(c.oid, 'pg_opclass') AS comment, ${dependentsOf("pg_opclass", "c.oid")} AS dependents
+     FROM pg_catalog.pg_opclass c JOIN pg_catalog.pg_namespace n ON n.oid = c.opcnamespace JOIN pg_catalog.pg_am am ON am.oid = c.opcmethod
+     JOIN pg_catalog.pg_opfamily f ON f.oid = c.opcfamily JOIN pg_catalog.pg_namespace fn ON fn.oid = f.opfnamespace
+     WHERE ${s.sql} AND c.oid >= 16384 AND ${notExtensionOwned("pg_opclass", "c.oid")}
+     ORDER BY n.nspname ${C}, c.opcname ${C}, am.amname ${C}`, s.params);
+    for (const r of classes) {
+        const q = qname(String(r.schema), String(r.name));
+        const method = String(r.method);
+        const items = [...(r.operators ?? []), ...(r.functions ?? []), ...(str(r.storage) ? [`STORAGE ${r.storage}`] : [])];
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.operatorClass,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            signature: ` USING ${method}`,
+            ...withComment(r),
+            ...dependents(r),
+            ...(items.length === 0 ? { unsupported: "no operator, support function or storage type of it could be read; a CREATE OPERATOR CLASS needs at least one" } : {}),
+            statement: [
+                `CREATE OPERATOR CLASS ${q}${r.isdefault === true ? " DEFAULT" : ""} FOR TYPE ${r.type} USING ${method}${str(r.family) ? ` FAMILY ${r.family}` : ""} AS\n    ${items.join(",\n    ")}`,
+                ...commentOn(`OPERATOR CLASS ${q} USING ${method}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    const families = await client.query(`SELECT f.oid::text AS oid, n.nspname AS schema, f.opfname AS name, am.amname AS method,
+            (SELECT count(*) FROM (SELECT o.oid FROM pg_catalog.pg_amop o WHERE o.amopfamily = f.oid UNION ALL SELECT p.oid FROM pg_catalog.pg_amproc p WHERE p.amprocfamily = f.oid) m
+              WHERE NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend dep WHERE dep.classid IN ('pg_catalog.pg_amop'::pg_catalog.regclass, 'pg_catalog.pg_amproc'::pg_catalog.regclass)
+                                AND dep.objid = m.oid AND dep.refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass)) AS loose,
+            pg_catalog.obj_description(f.oid, 'pg_opfamily') AS comment, ${dependentsOf("pg_opfamily", "f.oid")} AS dependents
+     FROM pg_catalog.pg_opfamily f JOIN pg_catalog.pg_namespace n ON n.oid = f.opfnamespace JOIN pg_catalog.pg_am am ON am.oid = f.opfmethod
+     WHERE ${s.sql} AND f.oid >= 16384 AND ${notExtensionOwned("pg_opfamily", "f.oid")}
+       AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_opclass c WHERE c.opcfamily = f.oid AND c.opcname = f.opfname AND c.opcnamespace = f.opfnamespace)
+     ORDER BY n.nspname ${C}, f.opfname ${C}, am.amname ${C}`, s.params);
+    for (const r of families) {
+        const q = qname(String(r.schema), String(r.name));
+        const method = String(r.method);
+        const loose = Number(r.loose ?? 0);
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.operatorFamily,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            signature: ` USING ${method}`,
+            ...withComment(r),
+            ...dependents(r),
+            ...(loose > 0 ? { warnings: [`${loose} loose member${loose === 1 ? "" : "s"} added with ALTER OPERATOR FAMILY ... ADD ${loose === 1 ? "is" : "are"} left out; a declaration holds the family and its classes' members`] } : {}),
+            statement: [`CREATE OPERATOR FAMILY ${q} USING ${method}`, ...commentOn(`OPERATOR FAMILY ${q} USING ${method}`, r.comment)].join(";\n"),
+        });
+    }
+    return out;
+}
+/**
+ * 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 function parseDictionaryOptions(init) {
+    if (init === undefined || init.trim() === "")
+        return [];
+    const out = [];
+    const item = /\s*("(?:[^"]|"")+"|[^\s=,]+)\s*=\s*'((?:[^']|'')*)'\s*(?:,|$)/y;
+    let at = 0;
+    while (at < init.length) {
+        item.lastIndex = at;
+        const m = item.exec(init);
+        if (!m)
+            return undefined;
+        const name = m[1].startsWith('"') ? m[1].slice(1, -1).replace(/""/g, '"') : m[1];
+        out.push([name, m[2].replace(/''/g, "'").replace(/\\\\/g, "\\")]);
+        at = item.lastIndex;
+    }
+    return out;
+}
+/** Text search dictionaries and configurations; a configuration's mappings are the ALTER ... ADD MAPPING statements after its CREATE. */
+async function readTextSearch(client, scope) {
+    const out = [];
+    const s = scopeSql("n.nspname", scope);
+    const dictionaries = await client.query(`SELECT d.oid::text AS oid, n.nspname AS schema, d.dictname AS name, d.dictinitoption AS init,
+            (SELECT ${refName("tn.nspname", "t.tmplname")} FROM pg_catalog.pg_ts_template t JOIN pg_catalog.pg_namespace tn ON tn.oid = t.tmplnamespace WHERE t.oid = d.dicttemplate) AS template,
+            pg_catalog.obj_description(d.oid, 'pg_ts_dict') AS comment, ${dependentsOf("pg_ts_dict", "d.oid")} AS dependents
+     FROM pg_catalog.pg_ts_dict d JOIN pg_catalog.pg_namespace n ON n.oid = d.dictnamespace
+     WHERE ${s.sql} AND d.oid >= 16384 AND ${notExtensionOwned("pg_ts_dict", "d.oid")}
+     ORDER BY n.nspname ${C}, d.dictname ${C}`, s.params);
+    for (const r of dictionaries) {
+        const q = qname(String(r.schema), String(r.name));
+        const options = parseDictionaryOptions(str(r.init));
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.textSearchDictionary,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            ...(options === undefined ? { unsupported: `its options (${str(r.init)}) are not in the form the server writes them` } : {}),
+            statement: [
+                `CREATE TEXT SEARCH DICTIONARY ${q} (${["TEMPLATE = " + r.template, ...(options ?? []).map(([k, v]) => `${quoteIdent(k)} = ${literal(v)}`)].join(", ")})`,
+                ...commentOn(`TEXT SEARCH DICTIONARY ${q}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    const configurations = await client.query(`SELECT c.oid::text AS oid, n.nspname AS schema, c.cfgname AS name,
+            (SELECT ${refName("pn.nspname", "p.prsname")} FROM pg_catalog.pg_ts_parser p JOIN pg_catalog.pg_namespace pn ON pn.oid = p.prsnamespace WHERE p.oid = c.cfgparser) AS parser,
+            ARRAY(SELECT tt.alias || E'\\t' || pg_catalog.string_agg((SELECT ${refName("dn.nspname", "d.dictname")} FROM pg_catalog.pg_ts_dict d JOIN pg_catalog.pg_namespace dn ON dn.oid = d.dictnamespace WHERE d.oid = m.mapdict), ', ' ORDER BY m.mapseqno)
+                  FROM pg_catalog.pg_ts_config_map m, pg_catalog.ts_token_type(c.cfgparser) tt WHERE m.mapcfg = c.oid AND tt.tokid = m.maptokentype
+                  GROUP BY tt.tokid, tt.alias ORDER BY tt.tokid) AS mappings,
+            pg_catalog.obj_description(c.oid, 'pg_ts_config') AS comment, ${dependentsOf("pg_ts_config", "c.oid")} AS dependents
+     FROM pg_catalog.pg_ts_config c JOIN pg_catalog.pg_namespace n ON n.oid = c.cfgnamespace
+     WHERE ${s.sql} AND c.oid >= 16384 AND ${notExtensionOwned("pg_ts_config", "c.oid")}
+     ORDER BY n.nspname ${C}, c.cfgname ${C}`, s.params);
+    for (const r of configurations) {
+        const q = qname(String(r.schema), String(r.name));
+        // Token types that share their dictionaries share an ADD MAPPING, in the parser's token order.
+        const groups = new Map();
+        for (const line of r.mappings ?? []) {
+            const [token, dictionaries] = line.split("\t");
+            groups.set(dictionaries, [...(groups.get(dictionaries) ?? []), quoteIdent(token)]);
+        }
+        out.push({
+            type: POSTGRES_ENTITY_TYPES.textSearchConfiguration,
+            schema: String(r.schema),
+            name: String(r.name),
+            oid: String(r.oid),
+            ...withComment(r),
+            ...dependents(r),
+            statement: [
+                `CREATE TEXT SEARCH CONFIGURATION ${q} (PARSER = ${r.parser})`,
+                ...[...groups].map(([dicts, tokens]) => `ALTER TEXT SEARCH CONFIGURATION ${q} ADD MAPPING FOR ${tokens.join(", ")} WITH ${dicts}`),
+                ...commentOn(`TEXT SEARCH CONFIGURATION ${q}`, r.comment),
+            ].join(";\n"),
+        });
+    }
+    return out;
+}
+/**
+ * Foreign tables: their columns (type, collation, default, NOT NULL and
+ * OPTIONS), CHECK constraints, server and OPTIONS. One that is a partition,
+ * inherits or has a generated column is read as unsupported, since a
+ * declaration does not hold those. An option that holds a credential is left
+ * out and said so.
+ */
+async function readForeignTables(client, scope) {
+    const s = scopeSql("n.nspname", scope);
+    const tables = await client.query(`SELECT c.oid::text AS oid, n.nspname AS schema, c.relname AS name, c.relispartition AS ispartition,
+            EXISTS (SELECT 1 FROM pg_catalog.pg_inherits i WHERE i.inhrelid = c.oid) AS inherits,
+            fs.srvname AS server, ft.ftoptions AS options,
+            pg_catalog.obj_description(c.oid, 'pg_class') AS comment, ${dependentsOf("pg_class", "c.oid")} AS dependents
+     FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+     JOIN pg_catalog.pg_foreign_table ft ON ft.ftrelid = c.oid JOIN pg_catalog.pg_foreign_server fs ON fs.oid = ft.ftserver
+     WHERE c.relkind = 'f' AND ${s.sql} AND ${notExtensionOwned("pg_class", "c.oid")}
+     ORDER BY n.nspname ${C}, c.relname ${C}`, s.params);
+    if (tables.length === 0)
+        return [];
+    const oids = tables.map((t) => String(t.oid));
+    const columns = await client.query(`SELECT a.attrelid::text AS rel, a.attname AS name, pg_catalog.format_type(a.atttypid, a.atttypmod) AS type, a.attnotnull AS notnull,
+            a.attgenerated::text AS generated, pg_catalog.pg_get_expr(d.adbin, d.adrelid, true) AS dflt,
+            CASE WHEN a.attcollation <> 0 AND a.attcollation <> t.typcollation THEN ${collationName("a.attcollation")} END AS collation,
+            a.attfdwoptions AS options, pg_catalog.col_description(a.attrelid, a.attnum) AS comment
+     FROM pg_catalog.pg_attribute AS a JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+     LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+     WHERE a.attrelid = ANY($1::oid[]) AND a.attnum > 0 AND NOT a.attisdropped
+     ORDER BY a.attrelid, a.attnum`, [oids]);
+    const checks = await client.query(`SELECT k.conrelid::text AS rel, k.conname AS name, pg_catalog.pg_get_constraintdef(k.oid, true) AS def, pg_catalog.obj_description(k.oid, 'pg_constraint') AS comment
+     FROM pg_catalog.pg_constraint k
+     WHERE k.conrelid = ANY($1::oid[]) AND k.contype = 'c' AND k.conislocal
+     ORDER BY k.conrelid, k.conname ${C}`, [oids]);
+    return tables.map((t) => {
+        const rel = String(t.oid);
+        const q = qname(String(t.schema), String(t.name));
+        const omitted = [];
+        const lines = [];
+        const commentLines = [];
+        let generated = false;
+        for (const c of columns.filter((x) => String(x.rel) === rel)) {
+            const parts = [quoteIdent(String(c.name)), String(c.type)];
+            const opts = optionsOf(c.options);
+            omitted.push(...opts.omitted);
+            if (opts.clause)
+                parts.push(opts.clause.trim());
+            if (str(c.collation))
+                parts.push(`COLLATE ${c.collation}`);
+            if (str(c.generated))
+                generated = true;
+            else if (str(c.dflt))
+                parts.push(`DEFAULT ${c.dflt}`);
+            if (c.notnull === true)
+                parts.push("NOT NULL");
+            lines.push(parts.join(" "));
+            commentLines.push(...commentOn(`COLUMN ${q}.${quoteIdent(String(c.name))}`, c.comment));
+        }
+        for (const k of checks.filter((x) => String(x.rel) === rel)) {
+            lines.push(`CONSTRAINT ${quoteIdent(String(k.name))} ${k.def}`);
+            commentLines.push(...commentOn(`CONSTRAINT ${quoteIdent(String(k.name))} ON ${q}`, k.comment));
+        }
+        const { clause, omitted: tableOmitted } = optionsOf(t.options);
+        omitted.push(...tableOmitted);
+        const unsupported = t.ispartition === true ? "it is a partition of another table (CREATE FOREIGN TABLE ... PARTITION OF is not declared)" : t.inherits === true ? "it inherits from another table (INHERITS is not declared on a foreign table)" : generated ? "it has a generated column (not declared on a foreign table)" : undefined;
+        return {
+            type: POSTGRES_ENTITY_TYPES.foreignTable,
+            schema: String(t.schema),
+            name: String(t.name),
+            oid: rel,
+            ...withComment(t),
+            ...dependents(t),
+            ...omittedWarning(omitted),
+            ...(unsupported ? { unsupported } : {}),
+            statement: [
+                `CREATE FOREIGN TABLE ${q} (${lines.length > 0 ? `\n    ${lines.join(",\n    ")}\n` : ""}) SERVER ${quoteIdent(String(t.server))}${clause}`,
+                ...commentOn(`FOREIGN TABLE ${q}`, t.comment),
+                ...commentLines,
+            ].join(";\n"),
+        };
+    });
+}

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;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"}
+{"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,CAoBtK;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"}

package/dist/postgres/live/describe-resources.js

@@ -45,6 +45,8 @@ export function declaredAddress(entity, defaultSchema) {
         entity.type === POSTGRES_ENTITY_TYPES.procedure ||
         entity.type === POSTGRES_ENTITY_TYPES.aggregate ||
         entity.type === POSTGRES_ENTITY_TYPES.operator ||
+        entity.type === POSTGRES_ENTITY_TYPES.operatorClass ||
+        entity.type === POSTGRES_ENTITY_TYPES.operatorFamily ||
         entity.type === POSTGRES_ENTITY_TYPES.trigger ||
         entity.type === POSTGRES_ENTITY_TYPES.policy) {
         const signature = canonicalPgObject(entity.type, entity.props, defaultSchema).signature;