@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/postgres/parser.js

@@ -116,6 +116,12 @@ export const AGGREGATE_OPTIONS = [
 ];
 /** `CREATE COLLATION`'s options (sql-createcollation). */
 export const COLLATION_OPTIONS = ["locale", "lc_collate", "lc_ctype", "provider", "deterministic", "rules", "version"];
+/** `CREATE OPERATOR`'s options (sql-createoperator); `procedure` is the old spelling of `function`. */
+export const OPERATOR_OPTIONS = ["function", "procedure", "leftarg", "rightarg", "commutator", "negator", "restrict", "join", "hashes", "merges"];
+/** `CREATE STATISTICS`'s kinds (sql-createstatistics). */
+export const STATISTICS_KINDS = ["ndistinct", "dependencies", "mcv"];
+/** `CREATE PUBLICATION ... WITH (...)`'s options (sql-createpublication); `publish_generated_columns` is 18's. */
+export const PUBLICATION_OPTIONS = ["publish", "publish_via_partition_root", "publish_generated_columns"];
 /** What may follow `IS` inside a `b_expr`. */
 const B_EXPR_IS = [["DISTINCT", "FROM"], ["NOT", "DISTINCT", "FROM"], ["DOCUMENT"], ["NOT", "DOCUMENT"]];
 class PgParser extends SqlCursor {
@@ -414,7 +420,7 @@ class PgParser extends SqlCursor {
         node.span = this.span(from, []);
         return node;
     }
-    column(typed) {
+    column(typed, foreign = false) {
         const { text, span } = this.nameTok("a column name");
         const col = { name: text, nameSpan: span, constraints: [] };
         if (!typed)
@@ -426,7 +432,11 @@ class PgParser extends SqlCursor {
         else if (typed)
             this.fail("expected a column type");
         for (;;) {
-            if (this.accept("COMPRESSION"))
+            if (foreign && kw(this.peek(), "OPTIONS") && this.isPunct("(", 1)) {
+                this.p++;
+                col.options = this.genericOptions();
+            }
+            else if (this.accept("COMPRESSION"))
                 col.compression = this.expr(COLUMN_CLAUSE);
             else if (this.accept("STORAGE"))
                 col.storage = this.expr(COLUMN_CLAUSE);
@@ -690,6 +700,8 @@ class PgParser extends SqlCursor {
             return this.grant(true, false);
         if (this.acceptSeq("ALTER", "DEFAULT", "PRIVILEGES"))
             return this.defaultPrivileges();
+        if (this.acceptSeq("ALTER", "TEXT", "SEARCH", "CONFIGURATION"))
+            return this.textSearchMapping();
         if (this.acceptSeq("ALTER", "TABLE"))
             return this.rowSecurity();
         this.expect("CREATE");
@@ -725,6 +737,30 @@ class PgParser extends SqlCursor {
                 return this.cast();
             if (this.acceptSeq("EVENT", "TRIGGER"))
                 return this.eventTrigger();
+            if (this.accept("OPERATOR")) {
+                // CLASS and FAMILY are words an operator's schema may be named: `class.+` is still an operator.
+                if (kw(this.peek(), "CLASS") && !this.isPunct(".", 1)) {
+                    this.p++;
+                    return this.operatorClass();
+                }
+                if (kw(this.peek(), "FAMILY") && !this.isPunct(".", 1)) {
+                    this.p++;
+                    return this.operatorFamily();
+                }
+                return this.operator();
+            }
+            if (this.acceptSeq("TEXT", "SEARCH"))
+                return this.textSearch();
+            if (this.accept("STATISTICS"))
+                return this.statistics();
+            if (this.acceptSeq("FOREIGN", "TABLE"))
+                return this.foreignTable();
+            if (this.acceptSeq("FOREIGN", "DATA", "WRAPPER"))
+                return this.foreignDataWrapper();
+            if (this.accept("SERVER"))
+                return this.foreignServer();
+            if (this.accept("PUBLICATION"))
+                return this.publication();
             if (kw(this.peek(), "UNIQUE", "INDEX"))
                 return this.index();
         }
@@ -740,7 +776,7 @@ class PgParser extends SqlCursor {
             return this.view(true, false, false, false);
         if (this.accept("VIEW"))
             return this.view(false, orReplace, persistence === "temporary", recursive);
-        return this.fail("expected SCHEMA, TABLE, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, TRIGGER, EVENT TRIGGER, COLLATION, CAST, POLICY or ROLE");
+        return this.fail("expected SCHEMA, TABLE, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, TRIGGER, EVENT TRIGGER, COLLATION, CAST, OPERATOR, OPERATOR CLASS, OPERATOR FAMILY, TEXT SEARCH CONFIGURATION, TEXT SEARCH DICTIONARY, STATISTICS, FOREIGN TABLE, FOREIGN DATA WRAPPER, SERVER, PUBLICATION, POLICY or ROLE");
     }
     schema() {
         const node = { statement: "schema", ifNotExists: this.ifNotExists() };
@@ -993,6 +1029,299 @@ class PgParser extends SqlCursor {
         this.expectPunct(")");
         return node;
     }
+    /** An unqualified, database-wide object's name (a wrapper, a server, a publication). */
+    databaseName(what) {
+        const { text, span } = this.nameTok(what);
+        if (this.isPunct("."))
+            this.fail(`expected ${what} without a schema (it belongs to the database)`);
+        return { pieces: [text], span };
+    }
+    /** `( name 'value' [, ...] )`: a foreign data wrapper's or server's options. */
+    genericOptions() {
+        this.expectPunct("(");
+        const out = [];
+        const seen = new Set();
+        for (;;) {
+            const t = this.next();
+            if (t.kind !== "ident" && t.kind !== "qident")
+                this.fail("expected an option name", t);
+            const nameSpan = this.span(this.idx(-1), []);
+            const name = identValue(t);
+            if (seen.has(name))
+                this.fail(`${name} is given twice`, t);
+            seen.add(name);
+            const v = this.next();
+            if (v.kind !== "string" && v.kind !== "ref")
+                this.fail("expected the option's value, a string", v);
+            out.push({ name, nameSpan, value: this.span(this.idx(-1), v.kind === "ref" ? [v.part] : []) });
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            return out;
+        }
+    }
+    /** `[schema.]symbol`: an operator's name, its symbol made of operator characters. */
+    operatorName() {
+        const from = this.idx();
+        const refs = [];
+        const pieces = [];
+        const symbol = () => {
+            const t = this.next();
+            if (t.kind !== "op")
+                this.fail("expected the operator's symbol (operator characters, such as ===)", t);
+            pieces.push(t.text);
+        };
+        if (this.peek()?.kind === "op")
+            symbol();
+        else {
+            const t = this.next();
+            this.colId(t, "a schema name");
+            if (t.kind === "ref")
+                refs.push(t.part);
+            pieces.push(t.kind === "ref" ? "" : identValue(t));
+            this.expectPunct(".");
+            symbol();
+        }
+        return { pieces, span: this.span(from, refs) };
+    }
+    operator() {
+        const name = this.operatorName();
+        const options = this.definition("an operator option");
+        this.checkDefinition(options, OPERATOR_OPTIONS, [], "an operator");
+        if (!options.some((o) => o.name === "function" || o.name === "procedure"))
+            this.fail("expected FUNCTION (an operator needs the function it calls)", this.lastSeen());
+        return { statement: "operator", name, options };
+    }
+    /** The member list of `CREATE OPERATOR CLASS ... AS`: an operator, a support function or the storage type. */
+    operatorClassItem() {
+        const number = () => {
+            const t = this.next();
+            if (t.kind !== "number" && t.kind !== "ref")
+                this.fail("expected the strategy or support number", t);
+            return this.span(this.idx(-1), t.kind === "ref" ? [t.part] : []);
+        };
+        if (this.accept("OPERATOR")) {
+            const item = { kind: "operator", number: number(), operator: this.operatorName() };
+            if (this.isPunct("("))
+                item.types = this.parenthesized();
+            if (this.accept("FOR")) {
+                if (this.accept("SEARCH"))
+                    return item;
+                if (!this.acceptSeq("ORDER", "BY"))
+                    this.fail("expected SEARCH or ORDER BY");
+                item.orderBy = this.qualifiedName("a sort operator family");
+            }
+            return item;
+        }
+        if (this.accept("FUNCTION")) {
+            const n = number();
+            const types = this.isPunct("(") ? this.parenthesized() : undefined;
+            const fn = this.qualifiedName("a function name");
+            if (!this.isPunct("("))
+                this.fail("expected '(' and the function's argument types");
+            return { kind: "function", number: n, ...(types ? { types } : {}), function: fn, args: this.parenthesized() };
+        }
+        if (this.accept("STORAGE"))
+            return { kind: "storage", type: this.typeName() };
+        return this.fail("expected OPERATOR, FUNCTION or STORAGE");
+    }
+    operatorClass() {
+        const name = this.qualifiedName("an operator class name");
+        const isDefault = this.accept("DEFAULT");
+        this.expect("FOR");
+        this.expect("TYPE");
+        const type = this.typeName();
+        this.expect("USING");
+        const method = this.nameTok("an index access method").text;
+        const node = { statement: "operatorClass", name, default: isDefault, type, method, items: [] };
+        if (this.accept("FAMILY"))
+            node.family = this.qualifiedName("an operator family name");
+        this.expect("AS");
+        do
+            node.items.push(this.operatorClassItem());
+        while (this.acceptPunct(","));
+        return node;
+    }
+    operatorFamily() {
+        const name = this.qualifiedName("an operator family name");
+        this.expect("USING");
+        return { statement: "operatorFamily", name, method: this.nameTok("an index access method").text };
+    }
+    /** After `CREATE TEXT SEARCH`: a dictionary or a configuration. A parser and a template are C code. */
+    textSearch() {
+        if (this.accept("DICTIONARY")) {
+            const name = this.qualifiedName("a text search dictionary name");
+            const options = this.definition("a dictionary option");
+            // The options past TEMPLATE belong to the template; a name given twice is still wrong.
+            this.checkDefinition(options, options.map((o) => o.name), ["template"], "a text search dictionary");
+            return { statement: "textSearchDictionary", name, options };
+        }
+        if (this.accept("CONFIGURATION")) {
+            const name = this.qualifiedName("a text search configuration name");
+            const options = this.definition("a configuration option");
+            this.checkDefinition(options, ["parser", "copy"], [], "a text search configuration");
+            if (options.some((o) => o.name === "copy"))
+                this.fail("expected PARSER (COPY copies mappings chant does not read; name the parser and write the mappings)", this.tokens[options.find((o) => o.name === "copy").nameSpan.from]);
+            if (!options.some((o) => o.name === "parser"))
+                this.fail("expected PARSER (a configuration needs the parser that splits text into tokens)", this.lastSeen());
+            return { statement: "textSearchConfiguration", name, options };
+        }
+        return this.fail("expected DICTIONARY or CONFIGURATION (a text search parser and a text search template are C code an extension installs)");
+    }
+    /** `ALTER TEXT SEARCH CONFIGURATION name ADD MAPPING FOR token_type [, ...] WITH dictionary [, ...]`. */
+    textSearchMapping() {
+        const name = this.qualifiedName("a text search configuration name");
+        if (!this.acceptSeq("ADD", "MAPPING"))
+            this.fail("expected ADD MAPPING (a configuration's mappings are declared with ADD MAPPING after its CREATE)");
+        this.expect("FOR");
+        const node = { statement: "textSearchMapping", name, tokens: [], dictionaries: [] };
+        do
+            node.tokens.push((({ text, span }) => ({ name: text, span }))(this.nameTok("a token type")));
+        while (this.acceptPunct(","));
+        this.expect("WITH");
+        do
+            node.dictionaries.push(this.qualifiedName("a text search dictionary name"));
+        while (this.acceptPunct(","));
+        return node;
+    }
+    /** `CREATE FOREIGN TABLE`: the column list form. A key, a generated column, INHERITS and PARTITION OF are not declared. */
+    foreignTable() {
+        const ifNotExists = this.ifNotExists();
+        const name = this.qualifiedName("a foreign table name");
+        if (kw(this.peek(), "PARTITION"))
+            this.fail("expected the column list (a foreign table that is a partition, PARTITION OF, is not declared here)");
+        const node = { statement: "foreignTable", ifNotExists, name, columns: [], constraints: [], server: { pieces: [], span: this.span(this.idx(), []) }, options: [] };
+        this.expectPunct("(");
+        if (!this.acceptPunct(")")) {
+            for (;;) {
+                if (kw(this.peek(), "LIKE"))
+                    this.fail("LIKE is not declared on a foreign table; write its columns");
+                const c = this.tableConstraint();
+                if (c)
+                    node.constraints.push(c);
+                else
+                    node.columns.push(this.column(true, true));
+                if (this.acceptPunct(","))
+                    continue;
+                this.expectPunct(")");
+                break;
+            }
+        }
+        if (kw(this.peek(), "INHERITS"))
+            this.fail("expected SERVER (INHERITS is not declared on a foreign table)");
+        this.expect("SERVER");
+        node.server = this.databaseName("a server name");
+        if (this.accept("OPTIONS"))
+            node.options = this.genericOptions();
+        // A foreign table has CHECK and NOT NULL constraints and a default; Postgres refuses the rest, and a generated column is not read.
+        const bad = (c, what) => this.fail(`${what} (a foreign table holds CHECK and NOT NULL constraints only; the remote server keeps the rest)`, this.tokens[c.span.from]);
+        for (const c of [...node.constraints, ...node.columns.flatMap((x) => x.constraints)]) {
+            if (c.kind !== "CHECK" && c.kind !== "NOT NULL")
+                bad(c, `expected CHECK or NOT NULL, not ${c.kind}`);
+            if (c.notEnforced !== undefined)
+                bad(c, "ENFORCED and NOT ENFORCED are 18's and are not declared on a foreign table");
+        }
+        for (const col of node.columns)
+            if (col.generated)
+                this.fail(`expected no generated column (${col.name} is GENERATED ${col.generated.kind.toUpperCase()}; a foreign table's generated columns are not declared)`, this.tokens[col.nameSpan.from]);
+        return node;
+    }
+    statistics() {
+        const ifNotExists = this.ifNotExists();
+        const name = this.qualifiedName("a statistics name");
+        const kinds = [];
+        if (this.isPunct("(")) {
+            for (const k of this.nameList("a statistics kind")) {
+                if (!STATISTICS_KINDS.includes(k.name))
+                    this.fail(`expected a statistics kind (${STATISTICS_KINDS.join(", ")})`, this.tokens[k.span.from]);
+                kinds.push(k.name);
+            }
+        }
+        this.expect("ON");
+        const targets = [];
+        do
+            targets.push(this.expr(["FROM"]));
+        while (this.acceptPunct(","));
+        this.expect("FROM");
+        const table = this.qualifiedName("a table name");
+        return { statement: "statistics", ifNotExists, name, kinds, targets, table };
+    }
+    foreignDataWrapper() {
+        const node = { statement: "foreignDataWrapper", name: this.databaseName("a foreign data wrapper name"), options: [] };
+        for (;;) {
+            if (this.accept("HANDLER"))
+                node.handler = this.qualifiedName("a handler function");
+            else if (this.acceptSeq("NO", "HANDLER"))
+                node.handler = null;
+            else if (this.accept("VALIDATOR"))
+                node.validator = this.qualifiedName("a validator function");
+            else if (this.acceptSeq("NO", "VALIDATOR"))
+                node.validator = null;
+            else if (this.accept("OPTIONS"))
+                node.options = this.genericOptions();
+            else
+                return node;
+        }
+    }
+    foreignServer() {
+        const ifNotExists = this.ifNotExists();
+        const name = this.databaseName("a server name");
+        const node = { statement: "foreignServer", ifNotExists, name, options: [] };
+        const string = (what) => {
+            const t = this.next();
+            if (t.kind !== "string" && t.kind !== "ref")
+                this.fail(`expected ${what} as a string`, t);
+            return this.span(this.idx(-1), t.kind === "ref" ? [t.part] : []);
+        };
+        if (this.accept("TYPE"))
+            node.type = string("the server type");
+        if (this.accept("VERSION"))
+            node.version = string("the server version");
+        if (!this.acceptSeq("FOREIGN", "DATA", "WRAPPER"))
+            this.fail("expected FOREIGN DATA WRAPPER (a server names the wrapper it is for)");
+        node.wrapper = this.qualifiedName("a foreign data wrapper name");
+        if (this.accept("OPTIONS"))
+            node.options = this.genericOptions();
+        return node;
+    }
+    publication() {
+        const node = { statement: "publication", name: this.databaseName("a publication name"), allTables: false, items: [], options: [] };
+        if (this.accept("FOR")) {
+            if (this.acceptSeq("ALL", "TABLES"))
+                node.allTables = true;
+            else {
+                let mode;
+                do {
+                    if (this.accept("TABLE"))
+                        mode = "table";
+                    else if (this.acceptSeq("TABLES", "IN", "SCHEMA"))
+                        mode = "schema";
+                    else if (mode === undefined)
+                        this.fail("expected ALL TABLES, TABLE or TABLES IN SCHEMA");
+                    if (mode === "schema") {
+                        node.items.push({ kind: "schema", schema: this.qualifiedName("a schema name") });
+                        continue;
+                    }
+                    this.accept("ONLY");
+                    const table = this.qualifiedName("a table name");
+                    if (this.isOp("*"))
+                        this.p++;
+                    const item = { kind: "table", table };
+                    if (this.isPunct("("))
+                        item.columns = this.nameList("a column name");
+                    if (this.accept("WHERE"))
+                        item.where = this.checkedParens();
+                    node.items.push(item);
+                } while (this.acceptPunct(","));
+            }
+        }
+        if (kw(this.peek(), "WITH") && this.isPunct("(", 1)) {
+            this.p++;
+            node.options = this.definition("a publication option");
+            this.checkDefinition(node.options, PUBLICATION_OPTIONS, [], "a publication");
+        }
+        return node;
+    }
     table(persistence) {
         const ifNotExists = this.ifNotExists();
         const node = { statement: "table", persistence, ifNotExists, name: this.qualifiedName("a table name"), columns: [], constraints: [], like: [] };
@@ -1747,6 +2076,43 @@ class PgParser extends SqlCursor {
                 node.text = this.commentText();
             return node;
         }
+        else if (this.acceptSeq("FOREIGN", "DATA", "WRAPPER")) {
+            objectType = "FOREIGN DATA WRAPPER";
+            target = this.qualifiedName("a foreign data wrapper name");
+        }
+        else if (kw(this.peek(), "OPERATOR") && kw(this.peek(1), "CLASS", "FAMILY") && !this.isPunct(".", 2)) {
+            this.p++;
+            objectType = `OPERATOR ${this.next().text.toUpperCase()}`;
+            target = this.qualifiedName(`an ${objectType.toLowerCase()} name`);
+            this.expect("USING");
+            const using = this.nameTok("an index access method").text;
+            this.expect("IS");
+            const node = { statement: "comment", objectType, target, using };
+            if (!this.accept("NULL"))
+                node.text = this.commentText();
+            return node;
+        }
+        else if (this.acceptSeq("TEXT", "SEARCH")) {
+            if (!this.accept("CONFIGURATION", "DICTIONARY"))
+                this.fail("expected CONFIGURATION or DICTIONARY");
+            objectType = `TEXT SEARCH ${this.lastSeen().text.toUpperCase()}`;
+            target = this.qualifiedName(`a ${objectType.toLowerCase()} name`);
+        }
+        else if (this.acceptSeq("FOREIGN", "TABLE")) {
+            objectType = "FOREIGN TABLE";
+            target = this.qualifiedName("a foreign table name");
+        }
+        else if (this.accept("OPERATOR")) {
+            objectType = "OPERATOR";
+            target = this.operatorName();
+            if (!this.isPunct("("))
+                this.fail("expected '(' and the operator's operand types");
+            args = this.parenthesized();
+        }
+        else if (this.accept("SERVER", "PUBLICATION", "STATISTICS")) {
+            objectType = this.lastSeen().text.toUpperCase();
+            target = this.qualifiedName(`a ${objectType.toLowerCase()} name`);
+        }
         else if (this.accept("AGGREGATE", "COLLATION")) {
             objectType = this.lastSeen().text.toUpperCase();
             target = this.qualifiedName(`an ${objectType.toLowerCase()} name`);
@@ -1763,7 +2129,7 @@ class PgParser extends SqlCursor {
                 objectType = this.tokens[this.idx(-1)].text.toUpperCase();
             }
             else
-                return this.fail("expected TABLE, COLUMN, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, SCHEMA, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, COLLATION, CAST, TRIGGER, EVENT TRIGGER, POLICY, ROLE or CONSTRAINT");
+                return this.fail("expected TABLE, COLUMN, INDEX, VIEW, MATERIALIZED VIEW, SEQUENCE, TYPE, DOMAIN, SCHEMA, EXTENSION, FUNCTION, PROCEDURE, AGGREGATE, COLLATION, CAST, OPERATOR, TRIGGER, EVENT TRIGGER, STATISTICS, FOREIGN TABLE, FOREIGN DATA WRAPPER, SERVER, PUBLICATION, OPERATOR CLASS, OPERATOR FAMILY, TEXT SEARCH CONFIGURATION, TEXT SEARCH DICTIONARY, POLICY, ROLE or CONSTRAINT");
             target = this.qualifiedName("an object name");
             if ((objectType === "FUNCTION" || objectType === "PROCEDURE") && this.isPunct("("))
                 args = this.parenthesized();

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

@@ -1 +1 @@
-{"version":3,"file":"deep.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/deep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAmB,KAAK,qBAAqB,EAAwD,MAAM,mCAAmC,CAAC;AAEtJ,OAAO,EAAyC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACvF,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7E,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAMrG,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA2BrC,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAGhD;AA2FD,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,KAAK,CAkEpH;AAED,wBAAsB,oBAAoB,CACxC,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;CAC/E,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAyEhC"}
+{"version":3,"file":"deep.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/deep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAmB,KAAK,qBAAqB,EAAwD,MAAM,mCAAmC,CAAC;AAEtJ,OAAO,EAAyC,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACvF,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7E,OAAO,EAAkD,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAMrG,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAqCrC,+EAA+E;AAC/E,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,GAAG,KAAK,CAGhD;AA6GD,uGAAuG;AACvG,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,KAAK,CA4EpH;AAED,wBAAsB,oBAAoB,CACxC,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;CAC/E,GAAG,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAyEhC"}

package/dist/postgres/plan/deep.js

@@ -37,6 +37,16 @@ const TAG = {
     [POSTGRES_ENTITY_TYPES.collation]: tags.collation,
     [POSTGRES_ENTITY_TYPES.cast]: tags.cast,
     [POSTGRES_ENTITY_TYPES.eventTrigger]: tags.eventTrigger,
+    [POSTGRES_ENTITY_TYPES.operator]: tags.operator,
+    [POSTGRES_ENTITY_TYPES.operatorClass]: tags.operatorClass,
+    [POSTGRES_ENTITY_TYPES.operatorFamily]: tags.operatorFamily,
+    [POSTGRES_ENTITY_TYPES.foreignTable]: tags.foreignTable,
+    [POSTGRES_ENTITY_TYPES.textSearchConfiguration]: tags.textSearchConfiguration,
+    [POSTGRES_ENTITY_TYPES.textSearchDictionary]: tags.textSearchDictionary,
+    [POSTGRES_ENTITY_TYPES.statistics]: tags.statistics,
+    [POSTGRES_ENTITY_TYPES.foreignDataWrapper]: tags.foreignDataWrapper,
+    [POSTGRES_ENTITY_TYPES.foreignServer]: tags.foreignServer,
+    [POSTGRES_ENTITY_TYPES.publication]: tags.publication,
     [POSTGRES_ENTITY_TYPES.extension]: tags.extension,
     [POSTGRES_ENTITY_TYPES.function]: tags.func,
     [POSTGRES_ENTITY_TYPES.procedure]: tags.procedure,
@@ -129,6 +139,24 @@ const PROP_OF_FIELD = {
     context: ["context"],
     event: ["event"],
     tags: ["tags"],
+    targets: ["targets"],
+    kinds: ["kinds"],
+    handler: ["handler", "handlerName", "noHandler"],
+    validator: ["validator", "validatorName", "noValidator"],
+    serverType: ["serverType"],
+    wrapper: ["wrapper", "wrapperName"],
+    server: ["serverName"],
+    family: ["family"],
+    items: ["items"],
+    template: ["template"],
+    parser: ["parser"],
+    mappings: ["mappings"],
+    allTables: ["allTables"],
+    tables: ["tables"],
+    schemas: ["schemas"],
+    publish: [],
+    viaRoot: [],
+    generatedColumns: [],
 };
 /** Props keys that hold constraints, by constraint kind. */
 const CONSTRAINT_PROPS = {
@@ -155,6 +183,9 @@ export function inDeclaredVocabulary(declared, live, d, l) {
     if (d.kind === "aggregate" && d.signature === l.signature)
         for (const key of ["args", "orderBy"])
             adopt(key);
+    if (d.kind === "operator" && d.signature === l.signature)
+        for (const key of ["leftArg", "rightArg"])
+            adopt(key);
     if (d.kind === "cast" && d.name === l.name)
         for (const key of ["sourceType", "targetType"])
             adopt(key);
@@ -174,7 +205,7 @@ export function inDeclaredVocabulary(declared, live, d, l) {
                 if (f !== "schema" || d.kind === "extension")
                     adopt(key);
     }
-    if (d.kind === "table") {
+    if (d.kind === "table" || d.kind === "foreignTable") {
         const declaredColumns = declared.columns ?? [];
         const liveColumns = live.columns ?? [];
         // Columns are matched by name and listed in the declaration's order, the
@@ -195,7 +226,15 @@ export function inDeclaredVocabulary(declared, live, d, l) {
         ].map((c) => c.value);
     }
     // An aggregate's or a collation's `options` is the declaration's only when every field read from it is the same (a role's `options` shares the key).
-    const optionFields = d.kind === "aggregate" ? ["definition"] : d.kind === "collation" ? ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"] : undefined;
+    const optionFields = d.kind === "aggregate" || d.kind === "operator"
+        ? ["definition"]
+        : d.kind === "collation"
+            ? ["provider", "lcCollate", "lcCtype", "locale", "nondeterministic", "rules"]
+            : d.kind === "foreignDataWrapper" || d.kind === "foreignServer" || d.kind === "foreignTable" || d.kind === "textSearchDictionary"
+                ? ["options"]
+                : d.kind === "publication"
+                    ? ["publish", "viaRoot", "generatedColumns"]
+                    : undefined;
     if (optionFields) {
         if (optionFields.every((f) => JSON.stringify(d.fields[f]) === JSON.stringify(l.fields[f])))
             adopt("options");
@@ -207,9 +246,9 @@ export function inDeclaredVocabulary(declared, live, d, l) {
         out.method = live.method;
         out.functionArgs = live.functionArgs;
     }
-    if (d.kind === "table" || d.kind === "domain") {
+    if (d.kind === "table" || d.kind === "domain" || d.kind === "foreignTable") {
         // A constraint the declaration says the same as the server is the declaration's (its name included or left out).
-        const kinds = d.kind === "domain" ? ["CHECK"] : Object.keys(CONSTRAINT_PROPS);
+        const kinds = d.kind === "table" ? Object.keys(CONSTRAINT_PROPS) : ["CHECK"];
         for (const kind of kinds) {
             const key = CONSTRAINT_PROPS[kind];
             const dl = d.constraints.filter((c) => c.kind === kind);

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

@@ -1 +1 @@
-{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC3F,OAAO,EAAkE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvH,OAAO,EAAmE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAe,KAAK,YAAY,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAExE,4HAA4H;AAC5H,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC;AAE3E,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,QAAQ,CAAC;IACvD,6EAA6E;IAC7E,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,8FAA8F;IAC9F,YAAY,CAAC,EAAE,6BAA6B,EAAE,CAAC;IAC/C,sHAAsH;IACtH,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;CACzB;AAqHD,gDAAgD;AAChD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CAa5E;AA4OD;;;GAGG;AACH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,YAAY,CAAC,CAAC,CAUpJ;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,YAAY,CAqClJ"}
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAoB,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC3F,OAAO,EAAkE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvH,OAAO,EAAmE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAe,KAAK,YAAY,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/E,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAC;AAExE,4HAA4H;AAC5H,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,MAAM,QAAQ,GAAG,gBAAgB,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC;AAE3E,MAAM,WAAW,YAAa,SAAQ,SAAS,CAAC,QAAQ,CAAC;IACvD,6EAA6E;IAC7E,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB,8FAA8F;IAC9F,YAAY,CAAC,EAAE,6BAA6B,EAAE,CAAC;IAC/C,sHAAsH;IACtH,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;CACzB;AAqHD,gDAAgD;AAChD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CAa5E;AAoXD;;;GAGG;AACH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,YAAY,CAAC,CAAC,CAUpJ;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,EAAE,QAAQ,EAAE,SAAS,cAAc,EAAE,EAAE,OAAO,GAAE,aAAkB,GAAG,YAAY,CAqClJ"}