@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/postgres/parser.js

@@ -0,0 +1,1824 @@
+/**
+ * A hand-written, lossless parser for the Postgres statements the dialect
+ * declares (chant #3278, #3279): `CREATE SCHEMA`, `TABLE`, `INDEX`, `VIEW`,
+ * `MATERIALIZED VIEW`, `SEQUENCE`, `TYPE ... AS ENUM`, `TYPE ... AS (...)` and
+ * `TYPE ... AS RANGE`, `DOMAIN`, `EXTENSION`, `FUNCTION`, `PROCEDURE` and
+ * `TRIGGER` (#3680), `AGGREGATE`, `COLLATION`, `CAST` and `EVENT TRIGGER`
+ * (#3911), `POLICY` and `ROLE`, `GRANT`,
+ * `REVOKE` and `ALTER DEFAULT PRIVILEGES` on schemas, tables, columns,
+ * sequences and routines, `ALTER TABLE ... ROW LEVEL SECURITY` (#3681), and
+ * `COMMENT ON` for those objects.
+ *
+ * A function's or procedure's body is a string (`AS $$ ... $$`), kept
+ * verbatim: Postgres stores it as written and prints it back unchanged. A
+ * SQL-standard body (`RETURN expr`, `BEGIN ATOMIC ... END`) is refused, since
+ * the server stores it parsed and prints it back rewritten.
+ *
+ * As for ClickHouse (#3196), statement structure is parsed and expressions are
+ * not: a default, a check, a generated expression, an index element, a
+ * partition bound and a view's query are token spans, verbatim, with the
+ * interpolations inside them recorded. Postgres itself is the backstop.
+ *
+ * What the spike measured as missing is closed here: a column default is a
+ * `b_expr`, so a top-level `IN`, `AND`, `LIKE` or `IS NULL` in it is an error
+ * at that token; `LIKE ... INCLUDING` and `ON COMMIT` take only their own
+ * option words; a storage parameter list (`WITH (fillfactor = 70)`) is parsed
+ * as `name [= value]` items; a type cannot be a reserved word (`a ARRAY[4]`
+ * fails at `ARRAY`); and a range partition bound cannot be empty.
+ *
+ * An interpolation (`ref` token) is accepted wherever a name, a type or an
+ * expression goes. Lint parses with every interpolation still a `ref`.
+ *
+ * Grammar source: the Postgres 18 reference pages for each statement
+ * (sql-createtable, sql-createindex, sql-createview,
+ * sql-creatematerializedview, sql-createsequence, sql-createtype,
+ * sql-createdomain, sql-createextension, sql-createschema, sql-createfunction,
+ * sql-createprocedure, sql-createtrigger, sql-createaggregate,
+ * sql-createcollation, sql-createcast, sql-createeventtrigger, sql-comment) and
+ * `src/backend/parser/gram.y` at `REL_18_6` where a page is silent.
+ */
+import { kw, SqlCursor } from "../core/cursor.js";
+import { SqlSyntaxError } from "../core/tokens.js";
+import { keywordCategory } from "./keywords.js";
+export { SqlSyntaxError };
+/** An identifier as Postgres reads it: an unquoted name folds to lower case, a quoted one is exact. */
+export function identValue(t) {
+    const text = typeof t === "string" ? t : t.text;
+    const quoted = typeof t === "string" ? /^(U&)?"/i.test(text) : t.kind === "qident";
+    if (quoted) {
+        if (/^[Uu]&/.test(text))
+            return text.slice(3, -1).replace(/""/g, '"');
+        return text.slice(1, -1).replace(/""/g, '"');
+    }
+    return text.toLowerCase();
+}
+const isKeywordToken = (t) => t.kind === "ident" && keywordCategory(t.text) !== undefined;
+const isNameToken = (t) => t !== undefined && (t.kind === "ident" || t.kind === "qident" || t.kind === "ref");
+/** Words that end a column's type or a column clause: a column constraint, or a clause after the type. */
+const COLUMN_CLAUSE = [
+    "CONSTRAINT",
+    "NOT",
+    "NULL",
+    "DEFAULT",
+    "GENERATED",
+    "UNIQUE",
+    "PRIMARY",
+    "CHECK",
+    "REFERENCES",
+    "COLLATE",
+    "DEFERRABLE",
+    "INITIALLY",
+    "COMPRESSION",
+    "STORAGE",
+    "ENFORCED",
+];
+/** A column's clause words, and its constraints' attributes: an unknown clause stops at the next (#3872). */
+const COLUMN_WORDS = [...COLUMN_CLAUSE, "REFERENCES", "ON", "MATCH", "NO", "WITH", "INCLUDE", "USING"];
+/** The clauses after a table's column list. */
+const TABLE_WORDS = ["INHERITS", "PARTITION", "USING", "WITH", "WITHOUT", "ON", "TABLESPACE", "FOR", "DEFAULT"];
+/** The clauses after an index's elements. */
+const INDEX_WORDS = ["INCLUDE", "NULLS", "WITH", "TABLESPACE", "WHERE"];
+/** The clauses before a view's AS. */
+const VIEW_WORDS = ["USING", "WITH", "TABLESPACE", "AS"];
+/** `LIKE source_table [ like_option ... ]`'s option words. */
+const LIKE_OPTIONS = ["COMMENTS", "COMPRESSION", "CONSTRAINTS", "DEFAULTS", "GENERATED", "IDENTITY", "INDEXES", "STATISTICS", "STORAGE", "ALL"];
+/**
+ * Words a `b_expr` cannot hold at its top level (gram.y): a column default and
+ * a domain default are `b_expr`, which has no `IN`, boolean operators, pattern
+ * matching, `BETWEEN`, `IS NULL`-style tests or `AT TIME ZONE`.
+ */
+const NOT_IN_B_EXPR = ["IN", "AND", "OR", "LIKE", "ILIKE", "SIMILAR", "BETWEEN", "ISNULL", "NOTNULL", "AT", "COLLATE", "OVERLAPS"];
+/** `CREATE TYPE ... AS RANGE`'s options (sql-createtype). */
+export const RANGE_OPTIONS = ["subtype", "subtype_opclass", "collation", "canonical", "subtype_diff", "multirange_type_name"];
+/** `CREATE AGGREGATE`'s options (sql-createaggregate), the old form's `basetype` aside. */
+export const AGGREGATE_OPTIONS = [
+    "sfunc",
+    "stype",
+    "sspace",
+    "finalfunc",
+    "finalfunc_extra",
+    "finalfunc_modify",
+    "combinefunc",
+    "serialfunc",
+    "deserialfunc",
+    "initcond",
+    "msfunc",
+    "minvfunc",
+    "mstype",
+    "msspace",
+    "mfinalfunc",
+    "mfinalfunc_extra",
+    "mfinalfunc_modify",
+    "minitcond",
+    "sortop",
+    "parallel",
+    "hypothetical",
+];
+/** `CREATE COLLATION`'s options (sql-createcollation). */
+export const COLLATION_OPTIONS = ["locale", "lc_collate", "lc_ctype", "provider", "deterministic", "rules", "version"];
+/** What may follow `IS` inside a `b_expr`. */
+const B_EXPR_IS = [["DISTINCT", "FROM"], ["NOT", "DISTINCT", "FROM"], ["DOCUMENT"], ["NOT", "DOCUMENT"]];
+class PgParser extends SqlCursor {
+    /** A multi-word stop is written with spaces: `"WITH CHECK OPTION"`. A stop never ends an expression at its first token. */
+    stopsAt(stop) {
+        return stop.some((s) => this.is(...s.split(" ")));
+    }
+    /** `[` opens and `]` closes, as `(` and `)` do. */
+    depthChange(t) {
+        if (t.kind === "punct" && (t.text === "(" || t.text === "["))
+            return 1;
+        if (t.kind === "punct" && (t.text === ")" || t.text === "]"))
+            return -1;
+        return 0;
+    }
+    /**
+     * An expression span, up to a top-level `,` (unless `stopAtComma` is
+     * false), `)`, `]` or `;`, or a stop that is not its first token.
+     */
+    expr(stop = [], stopAtComma = true) {
+        const from = this.idx();
+        const refs = [];
+        let depth = 0;
+        const startP = this.p;
+        for (;;) {
+            const t = this.peek();
+            if (t === undefined)
+                break;
+            if (depth === 0) {
+                if (t.kind === "punct" && (t.text === ")" || t.text === "]" || t.text === ";" || (stopAtComma && t.text === ",")))
+                    break;
+                if (this.p > startP && this.stopsAt(stop))
+                    break;
+            }
+            depth += this.depthChange(t);
+            if (t.kind === "ref")
+                refs.push(t.part);
+            this.p++;
+        }
+        if (this.p === startP)
+            this.fail("expected an expression");
+        return this.span(from, refs);
+    }
+    isOp(text, n = 0) {
+        const t = this.peek(n);
+        return t !== undefined && t.kind === "op" && t.text === text;
+    }
+    /** A ColId: an identifier, or a key word that is neither reserved nor a type/function name word. */
+    colId(t, what) {
+        if (!isNameToken(t))
+            this.fail(`expected ${what}`, t);
+        const k = t.kind === "ident" ? keywordCategory(t.text) : undefined;
+        if (k === "R" || k === "T")
+            this.fail(`expected ${what} ('${t.text}' is a reserved key word; quote it to use it as a name)`, t);
+    }
+    nameTok(what) {
+        const t = this.next();
+        this.colId(t, what);
+        const i = this.idx(-1);
+        return { text: t.kind === "ref" ? "" : identValue(t), span: { from: i, to: i + 1, refs: t.kind === "ref" ? [t.part] : [] } };
+    }
+    /** `name`, `schema.name`, `db.schema.name`. The first piece is a ColId; a piece after a dot may be any word. */
+    qualifiedName(what = "a name") {
+        const from = this.idx();
+        const refs = [];
+        const pieces = [];
+        const one = () => {
+            const t = this.next();
+            if (pieces.length === 0)
+                this.colId(t, what);
+            else if (!isNameToken(t))
+                this.fail(`expected ${what}`, t);
+            if (t.kind === "ref")
+                refs.push(t.part);
+            pieces.push(t.kind === "ref" ? "" : identValue(t));
+        };
+        one();
+        while (this.isPunct(".") && isNameToken(this.peek(1))) {
+            this.p++;
+            one();
+        }
+        if (this.isPunct("."))
+            this.fail(`expected ${what}`, this.peek(1));
+        return { pieces, span: this.span(from, refs) };
+    }
+    ifNotExists() {
+        return this.acceptSeq("IF", "NOT", "EXISTS");
+    }
+    checkedParens() {
+        const span = this.parenthesized();
+        this.checkSpan(span);
+        return span;
+    }
+    /** `(a, b, c)`: a list of names. */
+    nameList(what = "a column name") {
+        this.expectPunct("(");
+        const out = [];
+        for (;;) {
+            out.push((({ text, span }) => ({ name: text, span }))(this.nameTok(what)));
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            return out;
+        }
+    }
+    /** A comma-separated list of expression spans inside parentheses. */
+    parenList() {
+        this.expectPunct("(");
+        const out = [];
+        if (this.acceptPunct(")"))
+            return out;
+        for (;;) {
+            out.push(this.expr());
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            return out;
+        }
+    }
+    /**
+     * `( name [= value] [, ...] )`: storage parameters (`WITH (fillfactor = 70)`)
+     * or index parameters. A name may be qualified (`toast.autovacuum_enabled`);
+     * a value is a number, a string, a word or a signed number.
+     */
+    reloptions() {
+        const from = this.idx();
+        this.expectPunct("(");
+        const refs = [];
+        for (;;) {
+            const t = this.next();
+            if (t.kind === "ref")
+                refs.push(t.part);
+            else if (t.kind !== "ident" && t.kind !== "qident")
+                this.fail("expected a storage parameter name", t);
+            if (this.acceptPunct(".")) {
+                const u = this.next();
+                if (u.kind !== "ident" && u.kind !== "qident")
+                    this.fail("expected a storage parameter name", u);
+            }
+            if (this.isOp("=")) {
+                this.p++;
+                if (this.isOp("-") || this.isOp("+"))
+                    this.p++;
+                const v = this.next();
+                if (v.kind === "ref")
+                    refs.push(v.part);
+                else if (!["number", "string", "ident", "qident"].includes(v.kind))
+                    this.fail("expected a storage parameter value", v);
+            }
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            break;
+        }
+        // The span keeps the parentheses: `(fillfactor = 70)`.
+        return this.span(from, refs);
+    }
+    /** Constraint attributes after a constraint, recorded on it. */
+    constraintAttributes(node) {
+        for (;;) {
+            if (this.acceptSeq("NOT", "DEFERRABLE"))
+                node.deferrable = false;
+            else if (this.accept("DEFERRABLE"))
+                node.deferrable = true;
+            else if (this.acceptSeq("INITIALLY", "DEFERRED"))
+                node.initiallyDeferred = true;
+            else if (this.acceptSeq("INITIALLY", "IMMEDIATE"))
+                node.initiallyDeferred = false;
+            else if (this.acceptSeq("NOT", "VALID"))
+                node.notValid = true;
+            else if (this.acceptSeq("NO", "INHERIT"))
+                node.noInherit = true;
+            else if (this.acceptSeq("NOT", "ENFORCED"))
+                node.notEnforced = true;
+            else if (this.accept("ENFORCED"))
+                node.notEnforced = false;
+            else if (this.accept("INCLUDE"))
+                node.include = this.parenthesized();
+            else if (kw(this.peek(), "WITH") && this.isPunct("(", 1)) {
+                this.p++;
+                node.with = this.reloptions();
+            }
+            else if (this.acceptSeq("USING", "INDEX", "TABLESPACE"))
+                this.nameTok("a tablespace");
+            else
+                break;
+        }
+    }
+    references() {
+        const table = this.qualifiedName("a referenced table");
+        const node = { table, columns: [] };
+        if (this.isPunct("(")) {
+            this.expectPunct("(");
+            for (;;) {
+                this.accept("PERIOD");
+                const { text, span } = this.nameTok("a referenced column");
+                node.columns.push({ name: text, span });
+                if (this.acceptPunct(","))
+                    continue;
+                this.expectPunct(")");
+                break;
+            }
+        }
+        if (this.accept("MATCH")) {
+            if (!this.accept("FULL", "PARTIAL", "SIMPLE"))
+                this.fail("expected FULL, PARTIAL or SIMPLE");
+            node.match = this.tokens[this.idx(-1)].text.toUpperCase();
+        }
+        for (;;) {
+            if (this.acceptSeq("ON", "DELETE"))
+                node.onDelete = this.fkAction();
+            else if (this.acceptSeq("ON", "UPDATE"))
+                node.onUpdate = this.fkAction();
+            else
+                break;
+        }
+        return node;
+    }
+    fkAction() {
+        const from = this.idx();
+        if (this.acceptSeq("NO", "ACTION") || this.accept("RESTRICT") || this.accept("CASCADE"))
+            return this.span(from, []);
+        if (this.acceptSeq("SET", "NULL") || this.acceptSeq("SET", "DEFAULT")) {
+            if (this.isPunct("("))
+                this.nameList();
+            return this.span(from, []);
+        }
+        return this.fail("expected NO ACTION, RESTRICT, CASCADE, SET NULL or SET DEFAULT");
+    }
+    /** `(a, b [, c WITHOUT OVERLAPS | PERIOD c])` for a key. */
+    keyColumns() {
+        this.expectPunct("(");
+        const out = [];
+        for (;;) {
+            this.accept("PERIOD");
+            const { text, span } = this.nameTok("a column name");
+            out.push({ name: text, span });
+            this.acceptSeq("WITHOUT", "OVERLAPS");
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            return out;
+        }
+    }
+    /** A table constraint, after an optional `CONSTRAINT name`. Undefined when the element is not one. */
+    tableConstraint() {
+        const from = this.idx();
+        let name;
+        if (kw(this.peek(), "CONSTRAINT")) {
+            this.p++;
+            name = this.nameTok("a constraint name").text;
+        }
+        const at = (kind, extra = {}) => ({
+            name,
+            kind,
+            columns: [],
+            ...extra,
+            span: { from, to: from, refs: [] },
+        });
+        let node;
+        if (this.accept("CHECK"))
+            node = at("CHECK", { expr: this.checkedParens() });
+        else if (this.acceptSeq("PRIMARY", "KEY"))
+            node = at("PRIMARY KEY", { columns: this.keyColumns() });
+        else if (this.accept("UNIQUE")) {
+            // NULLS [NOT] DISTINCT comes before the column list.
+            const nnd = this.acceptSeq("NULLS", "NOT", "DISTINCT") ? true : this.acceptSeq("NULLS", "DISTINCT") ? false : undefined;
+            node = at("UNIQUE", { columns: this.keyColumns(), nullsNotDistinct: nnd });
+        }
+        else if (this.acceptSeq("FOREIGN", "KEY")) {
+            const columns = this.keyColumns();
+            this.expect("REFERENCES");
+            node = at("FOREIGN KEY", { columns, references: this.references() });
+        }
+        else if (kw(this.peek(), "EXCLUDE") && (this.isPunct("(", 1) || kw(this.peek(1), "USING"))) {
+            this.p++;
+            const using = this.accept("USING") ? this.nameTok("an access method").text : undefined;
+            if (this.isPunct("(") && this.isPunct(")", 1))
+                this.fail("expected an exclusion element", this.peek(1));
+            node = at("EXCLUDE", { expr: this.parenthesized(), using });
+        }
+        else if (this.acceptSeq("NOT", "NULL")) {
+            const { text, span } = this.nameTok("a column name");
+            node = at("NOT NULL", { columns: [{ name: text, span }] });
+        }
+        else {
+            if (name !== undefined)
+                this.fail("expected CHECK, PRIMARY KEY, UNIQUE, FOREIGN KEY, EXCLUDE or NOT NULL");
+            return undefined;
+        }
+        this.constraintAttributes(node);
+        if (node.kind === "EXCLUDE" && this.accept("WHERE")) {
+            node.where = this.checkedParens();
+            this.constraintAttributes(node);
+        }
+        node.span = this.span(from, []);
+        return node;
+    }
+    column(typed) {
+        const { text, span } = this.nameTok("a column name");
+        const col = { name: text, nameSpan: span, constraints: [] };
+        if (!typed)
+            this.acceptSeq("WITH", "OPTIONS");
+        const at = this.peek();
+        const bare = at === undefined || (at.kind === "punct" && (at.text === "," || at.text === ")"));
+        if (typed && !bare && !this.stopsAt(COLUMN_CLAUSE))
+            col.type = this.typeName();
+        else if (typed)
+            this.fail("expected a column type");
+        for (;;) {
+            if (this.accept("COMPRESSION"))
+                col.compression = this.expr(COLUMN_CLAUSE);
+            else if (this.accept("STORAGE"))
+                col.storage = this.expr(COLUMN_CLAUSE);
+            else if (this.accept("COLLATE"))
+                col.collate = this.expr(COLUMN_CLAUSE);
+            else if (!this.columnConstraint(col) && !this.unknownClause(COLUMN_WORDS, { inList: true, column: text || undefined }))
+                break;
+        }
+        const after = this.peek();
+        if (after && !(after.kind === "punct" && (after.text === "," || after.text === ")")))
+            this.fail("expected a column constraint, ',' or ')'");
+        return col;
+    }
+    /**
+     * A type name: `[schema.]name [(modifiers)]`, the SQL multi-word forms
+     * (`double precision`, `character varying`, `timestamp with time zone`,
+     * `interval day to second`, `bit varying`), `SETOF`-free, and array bounds
+     * (`int[]`, `int[3]`, `int ARRAY[3]`). An interpolated type is one token.
+     * A reserved word is never a type.
+     */
+    typeName() {
+        const from = this.idx();
+        const refs = [];
+        const t = this.next();
+        if (t.kind === "ref")
+            refs.push(t.part);
+        else if (t.kind !== "ident" && t.kind !== "qident")
+            this.fail("expected a type", t);
+        else if (t.kind === "ident" && keywordCategory(t.text) === "R")
+            this.fail("expected a type", t);
+        const first = t.kind === "ident" ? t.text.toUpperCase() : "";
+        if (t.kind !== "ref")
+            while (this.isPunct(".") && isNameToken(this.peek(1)))
+                this.p += 2;
+        const precision = () => {
+            if (this.isPunct("(") && this.isPunct(")", 1))
+                this.fail("expected a type modifier", this.peek(1));
+            if (this.isPunct("("))
+                refs.push(...this.parenthesized().refs);
+        };
+        if (first === "DOUBLE")
+            this.expect("PRECISION");
+        else if (["CHARACTER", "CHAR", "NCHAR", "NATIONAL", "BIT", "VARCHAR"].includes(first)) {
+            if (first === "NATIONAL")
+                this.expect("CHARACTER", "CHAR");
+            this.accept("VARYING");
+            precision();
+        }
+        else if (first === "TIME" || first === "TIMESTAMP") {
+            precision();
+            if (!this.acceptSeq("WITH", "TIME", "ZONE"))
+                this.acceptSeq("WITHOUT", "TIME", "ZONE");
+        }
+        else if (first === "INTERVAL") {
+            const FIELDS = ["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"];
+            if (this.accept(...FIELDS) && this.accept("TO"))
+                this.expect(...FIELDS);
+            precision();
+        }
+        else
+            precision();
+        for (;;) {
+            if (this.isPunct("[")) {
+                this.p++;
+                if (this.peek()?.kind === "number")
+                    this.p++;
+                this.expectPunct("]");
+            }
+            else if (this.accept("ARRAY")) {
+                if (this.isPunct("[")) {
+                    this.p++;
+                    if (this.peek()?.kind === "number")
+                        this.p++;
+                    this.expectPunct("]");
+                }
+            }
+            else
+                break;
+        }
+        return this.span(from, refs);
+    }
+    /** An expression span with the operand check {@link checkSpan} makes. */
+    checkedExpr(stop = [], stopAtComma = true) {
+        const span = this.expr(stop, stopAtComma);
+        this.checkSpan(span);
+        return span;
+    }
+    /** A `b_expr` (a column or domain default): an expression with none of {@link NOT_IN_B_EXPR} at its top level. */
+    bExpr(stop) {
+        const span = this.checkedExpr(stop);
+        let depth = 0;
+        const sig = [];
+        for (let i = span.from; i < span.to; i++) {
+            const t = this.tokens[i];
+            if (t.kind !== "ws" && t.kind !== "comment")
+                sig.push(t);
+        }
+        for (let k = 0; k < sig.length; k++) {
+            const t = sig[k];
+            depth += this.depthChange(t);
+            if (depth !== 0 || t.kind !== "ident")
+                continue;
+            const word = t.text.toUpperCase();
+            if (NOT_IN_B_EXPR.includes(word))
+                this.fail("expected the end of the default (a default cannot hold this operator unparenthesized)", t);
+            if (word === "IS") {
+                const ok = B_EXPR_IS.some((seq) => seq.every((w, n) => kw(sig[k + 1 + n], w)));
+                if (!ok)
+                    this.fail("expected the end of the default (a default cannot hold IS unparenthesized)", t);
+            }
+        }
+        return span;
+    }
+    /**
+     * Since Postgres 14 removed postfix operators, an operand is never followed
+     * directly by a name that is not a key word, nor by another literal. That
+     * catches a misspelt key word after an expression (`DEFAULT 'x' CHEK (...)`)
+     * at its token, which a plain span would accept.
+     */
+    checkSpan(span) {
+        let prev;
+        const operandEnd = (x) => x.kind === "string" ||
+            x.kind === "number" ||
+            x.kind === "qident" ||
+            x.kind === "param" ||
+            x.kind === "ref" ||
+            (x.kind === "punct" && (x.text === ")" || x.text === "]")) ||
+            (x.kind === "ident" && !isKeywordToken(x));
+        for (let i = span.from; i < span.to; i++) {
+            const t = this.tokens[i];
+            if (t.kind === "ws" || t.kind === "comment")
+                continue;
+            if (prev && prev.kind === "punct" && prev.text === "," && t.kind === "punct" && t.text === ")")
+                this.fail("expected an expression", t);
+            // Two operands in a row: `z 0`, `(a) 'x'`. A name before a string is a typed literal (`date '2020-01-01'`).
+            if (prev && operandEnd(prev) && (t.kind === "number" || t.kind === "qident" || t.kind === "param" || (t.kind === "string" && prev.kind !== "ident"))) {
+                this.fail("expected an operator, a key word or the end of the expression", t);
+            }
+            if (prev && t.kind === "ident" && !isKeywordToken(t) && operandEnd(prev)) {
+                this.fail("expected an operator, a key word or the end of the expression", t);
+            }
+            prev = t;
+        }
+    }
+    /** One column constraint; false when there is none here. */
+    columnConstraint(col) {
+        const from = this.idx();
+        let name;
+        if (kw(this.peek(), "CONSTRAINT")) {
+            this.p++;
+            name = this.nameTok("a constraint name").text;
+        }
+        const push = (kind, extra = {}) => {
+            const node = { name, kind, columns: [], ...extra, span: { from, to: from, refs: [] } };
+            this.constraintAttributes(node);
+            node.span = this.span(from, []);
+            col.constraints.push(node);
+        };
+        if (this.acceptSeq("NOT", "NULL")) {
+            col.notNull = true;
+            if (name !== undefined)
+                col.notNullName = name;
+            this.acceptSeq("NO", "INHERIT");
+        }
+        else if (this.accept("NULL"))
+            col.notNull = false;
+        else if (this.accept("DEFAULT"))
+            col.default = this.bExpr(COLUMN_CLAUSE);
+        else if (kw(this.peek(), "GENERATED")) {
+            this.p++;
+            let always;
+            if (this.accept("ALWAYS"))
+                always = true;
+            else {
+                this.expect("BY");
+                this.expect("DEFAULT");
+                always = false;
+            }
+            this.expect("AS");
+            if (this.accept("IDENTITY")) {
+                col.generated = { kind: "identity", always, options: this.isPunct("(") ? this.parenthesized() : undefined };
+            }
+            else {
+                if (!always)
+                    this.fail("expected IDENTITY (a generated column is GENERATED ALWAYS AS)");
+                const expr = this.checkedParens();
+                // Neither word is VIRTUAL, the default from 18 (the pinned major); 14 to 17 require STORED.
+                const kind = this.accept("STORED") ? "stored" : (this.accept("VIRTUAL"), "virtual");
+                col.generated = { kind, expr, always };
+            }
+        }
+        else if (this.accept("CHECK"))
+            push("CHECK", { expr: this.checkedParens() });
+        else if (this.accept("UNIQUE")) {
+            const nnd = this.acceptSeq("NULLS", "NOT", "DISTINCT") ? true : this.acceptSeq("NULLS", "DISTINCT") ? false : undefined;
+            push("UNIQUE", { nullsNotDistinct: nnd });
+        }
+        else if (this.acceptSeq("PRIMARY", "KEY"))
+            push("PRIMARY KEY");
+        else if (this.accept("REFERENCES"))
+            push("FOREIGN KEY", { references: this.references() });
+        else if (name === undefined && col.constraints.length > 0 && kw(this.peek(), "DEFERRABLE", "INITIALLY", "NOT")) {
+            // `DEFERRABLE` / `INITIALLY ...` written after the constraint it qualifies.
+            const last = col.constraints[col.constraints.length - 1];
+            const before = this.p;
+            this.constraintAttributes(last);
+            if (this.p === before)
+                return false;
+        }
+        else {
+            if (name !== undefined)
+                this.fail("expected a column constraint");
+            return false;
+        }
+        return true;
+    }
+    tableElements(node, typed) {
+        this.expectPunct("(");
+        if (this.acceptPunct(")"))
+            return;
+        for (;;) {
+            if (this.accept("LIKE"))
+                node.like.push(this.likeClause());
+            else {
+                const c = this.tableConstraint();
+                if (c)
+                    node.constraints.push(c);
+                else
+                    node.columns.push(this.column(typed));
+            }
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            return;
+        }
+    }
+    /** `LIKE source [ { INCLUDING | EXCLUDING } option ... ]`, as written after `LIKE`. */
+    likeClause() {
+        const from = this.idx();
+        const source = this.qualifiedName("a table name");
+        while (this.accept("INCLUDING", "EXCLUDING")) {
+            if (!this.accept(...LIKE_OPTIONS))
+                this.fail(`expected ${LIKE_OPTIONS.join(", ")}`);
+        }
+        return this.span(from, source.span.refs);
+    }
+    persistence() {
+        this.accept("GLOBAL", "LOCAL");
+        if (this.accept("TEMPORARY", "TEMP"))
+            return "temporary";
+        if (this.accept("UNLOGGED"))
+            return "unlogged";
+        return undefined;
+    }
+    parse() {
+        if (this.accept("COMMENT"))
+            return this.comment();
+        if (this.accept("GRANT"))
+            return this.grant(false, false);
+        if (this.accept("REVOKE"))
+            return this.grant(true, false);
+        if (this.acceptSeq("ALTER", "DEFAULT", "PRIVILEGES"))
+            return this.defaultPrivileges();
+        if (this.acceptSeq("ALTER", "TABLE"))
+            return this.rowSecurity();
+        this.expect("CREATE");
+        const orReplace = this.acceptSeq("OR", "REPLACE");
+        if (!orReplace && this.accept("POLICY"))
+            return this.policy();
+        if (!orReplace && this.accept("ROLE"))
+            return this.role();
+        if (!orReplace && kw(this.peek(), "USER", "GROUP"))
+            this.fail("expected ROLE (declare a role with CREATE ROLE; LOGIN is an option of it)");
+        if (this.accept("FUNCTION"))
+            return this.routine("function", orReplace);
+        if (this.accept("PROCEDURE"))
+            return this.routine("procedure", orReplace);
+        if (this.accept("AGGREGATE"))
+            return this.aggregate(orReplace);
+        if (this.accept("TRIGGER"))
+            return this.trigger(orReplace, false);
+        if (this.acceptSeq("CONSTRAINT", "TRIGGER"))
+            return this.trigger(orReplace, true);
+        if (!orReplace) {
+            if (this.accept("SCHEMA"))
+                return this.schema();
+            if (this.accept("EXTENSION"))
+                return this.extension();
+            if (this.accept("DOMAIN"))
+                return this.domain();
+            if (this.accept("TYPE"))
+                return this.typeDef();
+            if (this.accept("COLLATION"))
+                return this.collation();
+            if (this.accept("CAST"))
+                return this.cast();
+            if (this.acceptSeq("EVENT", "TRIGGER"))
+                return this.eventTrigger();
+            if (kw(this.peek(), "UNIQUE", "INDEX"))
+                return this.index();
+        }
+        const persistence = this.persistence();
+        if (!orReplace && this.accept("TABLE"))
+            return this.table(persistence);
+        if (!orReplace && this.accept("SEQUENCE"))
+            return this.sequence(persistence);
+        if (persistence === "unlogged")
+            return this.fail("expected TABLE or SEQUENCE");
+        const recursive = this.accept("RECURSIVE");
+        if (!orReplace && !recursive && persistence === undefined && this.acceptSeq("MATERIALIZED", "VIEW"))
+            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");
+    }
+    schema() {
+        const node = { statement: "schema", ifNotExists: this.ifNotExists() };
+        if (!kw(this.peek(), "AUTHORIZATION"))
+            node.name = this.qualifiedName("a schema name");
+        if (this.accept("AUTHORIZATION")) {
+            const from = this.idx();
+            const t = this.next();
+            if (!isNameToken(t))
+                this.fail("expected a role name", t);
+            node.authorization = this.span(from, t.kind === "ref" ? [t.part] : []);
+        }
+        if (kw(this.peek(), "CREATE", "GRANT"))
+            this.fail("schema elements inside CREATE SCHEMA are not declared here; declare each object on its own");
+        return node;
+    }
+    extension() {
+        const node = { statement: "extension", ifNotExists: this.ifNotExists(), name: this.qualifiedName("an extension name"), cascade: false };
+        this.accept("WITH");
+        for (;;) {
+            if (this.accept("SCHEMA"))
+                node.schema = this.nameTok("a schema name").span;
+            else if (this.accept("VERSION")) {
+                const from = this.idx();
+                const t = this.next();
+                if (!["ident", "qident", "string", "ref"].includes(t.kind))
+                    this.fail("expected a version", t);
+                node.version = this.span(from, t.kind === "ref" ? [t.part] : []);
+            }
+            else if (this.accept("CASCADE"))
+                node.cascade = true;
+            else
+                return node;
+        }
+    }
+    domain() {
+        const name = this.qualifiedName("a domain name");
+        this.accept("AS");
+        const STOP = ["COLLATE", "DEFAULT", "CONSTRAINT", "NOT", "NULL", "CHECK"];
+        const node = { statement: "domain", name, type: this.typeName(), checks: [] };
+        for (;;) {
+            if (this.accept("COLLATE"))
+                node.collate = this.expr(STOP);
+            else if (this.accept("DEFAULT"))
+                node.default = this.bExpr(STOP);
+            else {
+                let cname;
+                if (this.accept("CONSTRAINT"))
+                    cname = this.nameTok("a constraint name").text;
+                if (this.acceptSeq("NOT", "NULL"))
+                    node.notNull = true;
+                else if (this.accept("NULL"))
+                    node.notNull = false;
+                else if (this.accept("CHECK")) {
+                    const expr = this.checkedParens();
+                    node.checks.push({ name: cname, expr, ...(this.acceptSeq("NOT", "VALID") ? { notValid: true } : {}) });
+                }
+                else if (cname !== undefined)
+                    this.fail("expected NOT NULL, NULL or CHECK");
+                else
+                    return node;
+            }
+        }
+    }
+    /** `CREATE TYPE name AS ENUM (...)`, `AS (...)` (a composite type) or `AS RANGE (...)`. */
+    typeDef() {
+        const name = this.qualifiedName("a type name");
+        if (!this.accept("AS")) {
+            if (this.isPunct("("))
+                this.fail("expected AS (a base type, CREATE TYPE name (INPUT = ...), is written in C and is not declared here; declare ENUM, RANGE or composite types, or a domain with its own tag)");
+            this.fail("expected AS (a shell type, CREATE TYPE name with nothing after it, is not declared on its own)");
+        }
+        if (this.accept("RANGE")) {
+            const options = this.definition("a range option");
+            this.checkDefinition(options, RANGE_OPTIONS, ["subtype"], "a range type");
+            return { statement: "range", name, options };
+        }
+        if (this.isPunct("("))
+            return this.composite(name);
+        if (!this.accept("ENUM"))
+            this.fail("expected ENUM, RANGE or '(' (a domain has its own tag)");
+        const labels = this.parenList();
+        for (const l of labels) {
+            const sig = this.tokens.slice(l.from, l.to).filter((t) => t.kind !== "ws" && t.kind !== "comment");
+            if (sig.length !== 1 || (sig[0].kind !== "string" && sig[0].kind !== "ref"))
+                this.fail("expected a string label", sig[0]);
+        }
+        return { statement: "enum", name, labels };
+    }
+    /** A composite type's attribute list, after `AS`. */
+    composite(name) {
+        const node = { statement: "composite", name, attributes: [] };
+        this.expectPunct("(");
+        if (this.acceptPunct(")"))
+            return node;
+        for (;;) {
+            const { text, span } = this.nameTok("an attribute name");
+            const attr = { name: text, nameSpan: span, type: this.typeName() };
+            if (this.accept("COLLATE"))
+                attr.collate = this.qualifiedName("a collation").span;
+            node.attributes.push(attr);
+            if (this.acceptPunct(","))
+                continue;
+            if (!this.isPunct(")"))
+                this.fail("expected COLLATE, ',' or ')' (an attribute of a composite type has a name, a type and a collation, and no constraints)");
+            this.expectPunct(")");
+            return node;
+        }
+    }
+    /**
+     * `( name [= value] [, ...] )`: a definition list, as `CREATE AGGREGATE`,
+     * `CREATE COLLATION` and `CREATE TYPE ... AS RANGE` take it. A value is an
+     * expression span: a type, a function or operator name, a string, a number.
+     */
+    definition(what) {
+        this.expectPunct("(");
+        const out = [];
+        if (this.acceptPunct(")"))
+            return out;
+        for (;;) {
+            const from = this.idx();
+            const t = this.next();
+            if (t.kind !== "ident" && t.kind !== "qident")
+                this.fail(`expected ${what}`, t);
+            const elem = { name: identValue(t), nameSpan: this.span(from, []) };
+            if (this.isOp("=")) {
+                this.p++;
+                elem.value = this.expr();
+            }
+            out.push(elem);
+            if (this.acceptPunct(","))
+                continue;
+            this.expectPunct(")");
+            return out;
+        }
+    }
+    /** A definition list's names against the ones the statement takes: an unknown or repeated one fails at its name, a missing required one at the end. */
+    checkDefinition(elems, known, required, what) {
+        const seen = new Set();
+        for (const e of elems) {
+            const at = this.tokens[e.nameSpan.from];
+            if (!known.includes(e.name))
+                this.fail(`expected an option of ${what} (${known.join(", ")})`, at);
+            if (seen.has(e.name))
+                this.fail(`${e.name} is given twice`, at);
+            seen.add(e.name);
+        }
+        for (const r of required)
+            if (!seen.has(r))
+                this.fail(`expected ${r.toUpperCase()} (${what} needs it)`, this.lastSeen());
+    }
+    aggregate(orReplace) {
+        const name = this.qualifiedName("an aggregate name");
+        const node = { statement: "aggregate", orReplace, name, args: [], star: false, options: [] };
+        this.expectPunct("(");
+        const t = this.peek();
+        if ((t?.kind === "ident" || t?.kind === "qident") && this.isOp("=", 1)) {
+            this.fail("expected the argument types (the old form, CREATE AGGREGATE name (BASETYPE = ..., SFUNC = ...), is not declared; write name(argtype) (SFUNC = ..., STYPE = ...))");
+        }
+        const args = (into) => {
+            for (;;) {
+                const at = this.peek();
+                const arg = this.routineArg();
+                if (arg.mode === "OUT" || arg.mode === "INOUT")
+                    this.fail("expected IN or VARIADIC (an aggregate's arguments are inputs)", at);
+                if (arg.default)
+                    this.fail("expected ',' or ')' (an aggregate's argument takes no default)", this.lastSeen());
+                into.push(arg);
+                if (!this.acceptPunct(","))
+                    return;
+            }
+        };
+        if (this.isOp("*")) {
+            this.p++;
+            node.star = true;
+        }
+        else if (!this.is("ORDER", "BY"))
+            args(node.args);
+        if (!node.star && this.acceptSeq("ORDER", "BY")) {
+            node.orderBy = [];
+            args(node.orderBy);
+        }
+        this.expectPunct(")");
+        node.options = this.definition("an aggregate option");
+        this.checkDefinition(node.options, AGGREGATE_OPTIONS, ["sfunc", "stype"], "an aggregate");
+        return node;
+    }
+    collation() {
+        const ifNotExists = this.ifNotExists();
+        const name = this.qualifiedName("a collation name");
+        if (this.accept("FROM")) {
+            this.fail("expected '(' (CREATE COLLATION ... FROM copies another collation's settings, which the server keeps as the copy's own; write them: (provider = ..., locale = ...))", this.lastSeen());
+        }
+        const options = this.definition("a collation option");
+        this.checkDefinition(options, COLLATION_OPTIONS, [], "a collation");
+        return { statement: "collation", ifNotExists, name, options };
+    }
+    cast() {
+        this.expectPunct("(");
+        const source = this.typeName();
+        this.expect("AS");
+        const target = this.typeName();
+        this.expectPunct(")");
+        const node = { statement: "cast", source, target, method: "function", context: "explicit" };
+        if (this.acceptSeq("WITH", "FUNCTION")) {
+            node.function = this.qualifiedName("a cast function");
+            if (this.isPunct("("))
+                node.functionArgs = this.parenthesized();
+        }
+        else if (this.acceptSeq("WITHOUT", "FUNCTION"))
+            node.method = "binary";
+        else if (this.acceptSeq("WITH", "INOUT"))
+            node.method = "inout";
+        else
+            this.fail("expected WITH FUNCTION, WITHOUT FUNCTION or WITH INOUT");
+        if (this.acceptSeq("AS", "ASSIGNMENT"))
+            node.context = "assignment";
+        else if (this.acceptSeq("AS", "IMPLICIT"))
+            node.context = "implicit";
+        return node;
+    }
+    eventTrigger() {
+        const { text, span } = this.nameTok("an event trigger name");
+        if (this.isPunct("."))
+            this.fail("expected ON (an event trigger's name is not schema-qualified; it is the database's)");
+        this.expect("ON");
+        const event = this.nameTok("an event");
+        const node = { statement: "eventTrigger", name: { pieces: [text], span }, event: { name: event.text, span: event.span }, filters: [], function: { pieces: [], span: { from: 0, to: 0, refs: [] } } };
+        if (this.accept("WHEN")) {
+            do {
+                const variable = this.nameTok("a filter variable");
+                if (variable.text !== "tag")
+                    this.fail("expected TAG (the only filter variable an event trigger has)", this.tokens[variable.span.from]);
+                this.expect("IN");
+                const values = this.parenList();
+                for (const v of values) {
+                    const sig = this.tokens.slice(v.from, v.to).filter((t) => t.kind !== "ws" && t.kind !== "comment");
+                    if (sig.length !== 1 || (sig[0].kind !== "string" && sig[0].kind !== "ref"))
+                        this.fail("expected a command tag as a string ('CREATE TABLE')", sig[0]);
+                }
+                node.filters.push({ variable: variable.text, values });
+            } while (this.accept("AND"));
+        }
+        this.expect("EXECUTE");
+        this.expect("FUNCTION", "PROCEDURE");
+        node.function = this.qualifiedName("an event trigger function");
+        this.expectPunct("(");
+        if (!this.isPunct(")"))
+            this.fail("expected ')' (an event trigger's function takes no arguments)");
+        this.expectPunct(")");
+        return node;
+    }
+    table(persistence) {
+        const ifNotExists = this.ifNotExists();
+        const node = { statement: "table", persistence, ifNotExists, name: this.qualifiedName("a table name"), columns: [], constraints: [], like: [] };
+        if (this.accept("OF")) {
+            node.ofType = this.qualifiedName("a type name");
+            if (this.isPunct("("))
+                this.tableElements(node, false);
+        }
+        else if (this.acceptSeq("PARTITION", "OF")) {
+            node.partitionOf = this.qualifiedName("a partitioned table");
+            if (this.isPunct("("))
+                this.tableElements(node, false);
+            node.partitionBound = this.partitionBound();
+        }
+        else {
+            if (!this.isPunct("("))
+                this.fail("expected the column list (CREATE TABLE ... AS is not declared here)");
+            this.tableElements(node, true);
+        }
+        for (;;) {
+            if (this.accept("INHERITS")) {
+                this.expectPunct("(");
+                node.inherits = [];
+                do
+                    node.inherits.push(this.qualifiedName("a parent table"));
+                while (this.acceptPunct(","));
+                this.expectPunct(")");
+            }
+            else if (this.acceptSeq("PARTITION", "BY")) {
+                const from = this.idx();
+                this.expect("RANGE", "LIST", "HASH");
+                if (this.isPunct(")", 1))
+                    this.fail("expected a partition key", this.peek(1));
+                node.partitionBy = this.span(from, this.parenthesized().refs);
+            }
+            else if (this.accept("USING"))
+                node.using = this.nameTok("an access method").span;
+            else if (kw(this.peek(), "WITH") && this.isPunct("(", 1)) {
+                this.p++;
+                node.with = this.reloptions();
+            }
+            else if (this.acceptSeq("WITHOUT", "OIDS"))
+                continue;
+            else if (this.acceptSeq("ON", "COMMIT")) {
+                const from = this.idx();
+                if (!(this.acceptSeq("PRESERVE", "ROWS") || this.acceptSeq("DELETE", "ROWS") || this.accept("DROP")))
+                    this.fail("expected PRESERVE ROWS, DELETE ROWS or DROP");
+                node.onCommit = this.span(from, []);
+            }
+            else if (this.accept("TABLESPACE"))
+                node.tablespace = this.nameTok("a tablespace").span;
+            else if (!this.unknownClause(TABLE_WORDS))
+                break;
+        }
+        return node;
+    }
+    /** `DEFAULT`, or `FOR VALUES IN (...)`, `FROM (...) TO (...)` or `WITH (MODULUS n, REMAINDER m)`. */
+    partitionBound() {
+        const from = this.idx();
+        if (this.accept("DEFAULT"))
+            return this.span(from, []);
+        this.expect("FOR");
+        this.expect("VALUES");
+        const refs = [];
+        const values = () => {
+            if (this.isPunct("(") && this.isPunct(")", 1))
+                this.fail("expected a partition bound value", this.peek(1));
+            refs.push(...this.checkedParens().refs);
+        };
+        if (this.accept("IN"))
+            values();
+        else if (this.accept("FROM")) {
+            values();
+            this.expect("TO");
+            values();
+        }
+        else if (this.accept("WITH")) {
+            this.expectPunct("(");
+            for (const w of ["MODULUS", "REMAINDER"]) {
+                if (!this.accept(w))
+                    this.fail(`expected ${w}`);
+                const t = this.next();
+                if (t.kind !== "number" && t.kind !== "ref")
+                    this.fail("expected a number", t);
+                if (w === "MODULUS")
+                    this.expectPunct(",");
+            }
+            this.expectPunct(")");
+        }
+        else
+            this.fail("expected IN, FROM or WITH");
+        return this.span(from, refs);
+    }
+    index() {
+        const unique = this.accept("UNIQUE");
+        this.expect("INDEX");
+        const concurrently = this.accept("CONCURRENTLY");
+        const ifNotExists = this.ifNotExists();
+        let name;
+        if (!(kw(this.peek(), "ON") && !ifNotExists)) {
+            // An index lives in its table's schema: CREATE INDEX takes an unqualified name.
+            const { text, span } = this.nameTok("an index name");
+            if (this.isPunct("."))
+                this.fail("expected ON (an index name is not schema-qualified; the index is created in its table's schema)");
+            name = { pieces: [text], span };
+        }
+        this.expect("ON");
+        const only = this.accept("ONLY");
+        const node = { statement: "index", unique, concurrently, ifNotExists, name, only, table: this.qualifiedName("a table name"), elements: [] };
+        if (this.accept("USING"))
+            node.using = this.nameTok("an access method").text;
+        if (this.isPunct("(") && this.isPunct(")", 1))
+            this.fail("expected an index column or expression", this.peek(1));
+        for (const span of this.parenList()) {
+            const sig = this.tokens.slice(span.from, span.to).filter((t) => t.kind !== "ws" && t.kind !== "comment");
+            const first = sig[0];
+            // A column element is a bare name, then only opclass, collation and ordering words.
+            const column = first && (first.kind === "ident" || first.kind === "qident") && sig.slice(1).every((t) => t.kind === "ident" || t.kind === "qident")
+                ? identValue(first)
+                : undefined;
+            node.elements.push({ span, ...(column !== undefined ? { column } : {}) });
+        }
+        for (;;) {
+            if (this.accept("INCLUDE"))
+                node.include = this.parenthesized();
+            else if (this.acceptSeq("NULLS", "NOT", "DISTINCT"))
+                node.nullsNotDistinct = true;
+            else if (this.acceptSeq("NULLS", "DISTINCT"))
+                node.nullsNotDistinct = false;
+            else if (kw(this.peek(), "WITH") && this.isPunct("(", 1)) {
+                this.p++;
+                node.with = this.reloptions();
+            }
+            else if (this.accept("TABLESPACE"))
+                node.tablespace = this.nameTok("a tablespace").span;
+            else if (this.accept("WHERE"))
+                node.where = this.checkedExpr([], false);
+            else if (!this.unknownClause(INDEX_WORDS))
+                return node;
+        }
+    }
+    view(materialized, orReplace, temporary, recursive) {
+        const ifNotExists = materialized ? this.ifNotExists() : false;
+        const node = {
+            statement: "view",
+            materialized,
+            orReplace,
+            temporary,
+            recursive,
+            ifNotExists,
+            name: this.qualifiedName("a view name"),
+            columnNames: [],
+            query: { from: 0, to: 0, refs: [] },
+        };
+        if (this.isPunct("("))
+            node.columnNames = this.nameList();
+        for (;;) {
+            if (materialized && this.accept("USING"))
+                node.using = this.nameTok("an access method").span;
+            else if (kw(this.peek(), "WITH") && this.isPunct("(", 1)) {
+                this.p++;
+                node.with = this.reloptions();
+            }
+            else if (materialized && this.accept("TABLESPACE"))
+                node.tablespace = this.nameTok("a tablespace").span;
+            else if (!this.unknownClause(VIEW_WORDS))
+                break;
+        }
+        this.expect("AS");
+        const tail = materialized
+            ? ["WITH DATA", "WITH NO DATA"]
+            : ["WITH CHECK OPTION", "WITH CASCADED CHECK OPTION", "WITH LOCAL CHECK OPTION"];
+        node.query = this.expr(tail, false);
+        if (materialized) {
+            if (this.acceptSeq("WITH", "DATA"))
+                node.withData = true;
+            else if (this.acceptSeq("WITH", "NO", "DATA"))
+                node.withData = false;
+        }
+        else if (kw(this.peek(), "WITH")) {
+            const from = this.idx();
+            this.p++;
+            this.accept("CASCADED", "LOCAL");
+            this.expect("CHECK");
+            this.expect("OPTION");
+            node.checkOption = this.span(from, []);
+        }
+        return node;
+    }
+    sequence(persistence) {
+        const node = { statement: "sequence", persistence, ifNotExists: this.ifNotExists(), name: this.qualifiedName("a sequence name"), options: [] };
+        const STOP = ["AS", "INCREMENT", "MINVALUE", "MAXVALUE", "NO", "START", "RESTART", "CACHE", "CYCLE", "OWNED", "SEQUENCE", "LOGGED", "UNLOGGED"];
+        const value = () => {
+            const span = this.expr(STOP);
+            this.checkSpan(span);
+            return span;
+        };
+        for (;;) {
+            if (this.atEnd())
+                return node;
+            if (this.accept("AS"))
+                node.options.push({ option: "AS", value: this.typeName() });
+            else if (this.accept("INCREMENT")) {
+                this.accept("BY");
+                node.options.push({ option: "INCREMENT", value: value() });
+            }
+            else if (this.acceptSeq("NO", "MINVALUE") || this.acceptSeq("NO", "MAXVALUE") || this.acceptSeq("NO", "CYCLE")) {
+                node.options.push({ option: `NO ${this.tokens[this.idx(-1)].text.toUpperCase()}` });
+            }
+            else if (this.accept("MINVALUE", "MAXVALUE", "CACHE")) {
+                node.options.push({ option: this.tokens[this.idx(-1)].text.toUpperCase(), value: value() });
+            }
+            else if (this.accept("START")) {
+                this.accept("WITH");
+                node.options.push({ option: "START", value: value() });
+            }
+            else if (this.accept("CYCLE"))
+                node.options.push({ option: "CYCLE" });
+            else if (this.acceptSeq("OWNED", "BY")) {
+                if (this.accept("NONE"))
+                    node.options.push({ option: "OWNED BY", value: this.span(this.idx(-1), []) });
+                else
+                    node.options.push({ option: "OWNED BY", value: this.qualifiedName("a column").span });
+            }
+            else if (!this.unknownClause(STOP))
+                return node;
+        }
+    }
+    /** Whether `a b` continues one type name (`double precision`, `character varying`, `timestamp with time zone`) rather than being a name and a type. */
+    continuesType(a, b) {
+        if (a?.kind !== "ident" || b?.kind !== "ident")
+            return false;
+        const x = a.text.toUpperCase();
+        const y = b.text.toUpperCase();
+        if (x === "DOUBLE")
+            return y === "PRECISION";
+        if (["CHARACTER", "CHAR", "NCHAR", "BIT", "VARCHAR"].includes(x))
+            return y === "VARYING";
+        if (x === "NATIONAL")
+            return y === "CHARACTER" || y === "CHAR";
+        if (x === "TIME" || x === "TIMESTAMP")
+            return y === "WITH" || y === "WITHOUT";
+        if (x === "INTERVAL")
+            return ["YEAR", "MONTH", "DAY", "HOUR", "MINUTE", "SECOND"].includes(y);
+        return false;
+    }
+    /** `[IN | OUT | INOUT | VARIADIC] [name] type [{DEFAULT | =} expr]`. */
+    routineArg() {
+        const arg = { type: { from: 0, to: 0, refs: [] } };
+        // A mode word is a mode unless it is the whole parameter (a type of that name) or the parameter's type follows nothing else.
+        if (kw(this.peek(), "IN", "OUT", "INOUT", "VARIADIC") && !(this.isPunct(",", 1) || this.isPunct(")", 1))) {
+            arg.mode = this.next().text.toUpperCase();
+        }
+        const a = this.peek();
+        const b = this.peek(1);
+        const named = a !== undefined &&
+            (a.kind === "ident" || a.kind === "qident") &&
+            b !== undefined &&
+            (b.kind === "ident" || b.kind === "qident" || b.kind === "ref") &&
+            !(b.kind === "ident" && keywordCategory(b.text) === "R") &&
+            !kw(b, "DEFAULT") &&
+            !this.continuesType(a, b);
+        if (named) {
+            const { text, span } = this.nameTok("a parameter name");
+            arg.name = text;
+            arg.nameSpan = span;
+        }
+        if (kw(this.peek(), "SETOF"))
+            this.fail("expected a parameter type (SETOF is a return type)");
+        arg.type = this.typeName();
+        if (this.isOp("%"))
+            this.fail("expected the end of the parameter (write the column's type: %TYPE is resolved once, when the function is created)");
+        if (this.accept("DEFAULT") || (this.isOp("=") && (this.p++, true)))
+            arg.default = this.checkedExpr([], true);
+        return arg;
+    }
+    routine(kind, orReplace) {
+        const node = { statement: kind, orReplace, name: this.qualifiedName(`a ${kind} name`), args: [], options: [], set: [], body: [] };
+        this.expectPunct("(");
+        if (!this.acceptPunct(")")) {
+            for (;;) {
+                node.args.push(this.routineArg());
+                if (this.acceptPunct(","))
+                    continue;
+                this.expectPunct(")");
+                break;
+            }
+        }
+        if (kind === "function" && this.accept("RETURNS")) {
+            if (this.accept("TABLE")) {
+                this.expectPunct("(");
+                node.returnsTable = [];
+                for (;;) {
+                    const { text, span } = this.nameTok("a column name");
+                    node.returnsTable.push({ name: text, nameSpan: span, type: this.typeName() });
+                    if (this.acceptPunct(","))
+                        continue;
+                    this.expectPunct(")");
+                    break;
+                }
+            }
+            else {
+                const setof = this.accept("SETOF");
+                node.returns = { setof, type: this.typeName() };
+            }
+        }
+        const word = (what) => {
+            const from = this.idx();
+            const t = this.next();
+            if (!["ident", "qident", "string", "ref", "number"].includes(t.kind))
+                this.fail(`expected ${what}`, t);
+            return this.span(from, t.kind === "ref" ? [t.part] : []);
+        };
+        const option = (option, value, flag) => node.options.push({ option, ...(value ? { value } : {}), ...(flag !== undefined ? { flag } : {}) });
+        const forFunction = (what) => {
+            if (kind === "procedure")
+                this.fail(`expected LANGUAGE, SECURITY, SET or AS (${what} is not an attribute of a procedure)`, this.lastSeen());
+        };
+        for (;;) {
+            if (this.accept("LANGUAGE"))
+                node.language = word("a language name");
+            else if (this.accept("TRANSFORM")) {
+                const from = this.idx();
+                const refs = [];
+                do {
+                    this.expect("FOR");
+                    this.expect("TYPE");
+                    refs.push(...this.typeName().refs);
+                } while (this.acceptPunct(","));
+                option("TRANSFORM", this.span(from, refs));
+            }
+            else if (kw(this.peek(), "IMMUTABLE", "STABLE", "VOLATILE")) {
+                forFunction(this.peek().text.toUpperCase());
+                option("VOLATILITY", word("a volatility"));
+            }
+            else if (this.acceptSeq("NOT", "LEAKPROOF")) {
+                forFunction("LEAKPROOF");
+                option("LEAKPROOF", undefined, false);
+            }
+            else if (this.accept("LEAKPROOF")) {
+                forFunction("LEAKPROOF");
+                option("LEAKPROOF", undefined, true);
+            }
+            else if (this.acceptSeq("CALLED", "ON", "NULL", "INPUT")) {
+                forFunction("CALLED ON NULL INPUT");
+                option("STRICT", undefined, false);
+            }
+            else if (this.acceptSeq("RETURNS", "NULL", "ON", "NULL", "INPUT") || this.accept("STRICT")) {
+                forFunction("STRICT");
+                option("STRICT", undefined, true);
+            }
+            else if (this.acceptSeq("EXTERNAL", "SECURITY") || this.accept("SECURITY")) {
+                if (this.accept("DEFINER"))
+                    option("SECURITY", undefined, true);
+                else {
+                    this.expect("INVOKER");
+                    option("SECURITY", undefined, false);
+                }
+            }
+            else if (this.accept("PARALLEL")) {
+                forFunction("PARALLEL");
+                if (!kw(this.peek(), "UNSAFE", "RESTRICTED", "SAFE"))
+                    this.fail("expected UNSAFE, RESTRICTED or SAFE");
+                option("PARALLEL", word("UNSAFE, RESTRICTED or SAFE"));
+            }
+            else if (kw(this.peek(), "COST", "ROWS")) {
+                const o = this.next().text.toUpperCase();
+                forFunction(o);
+                const from = this.idx();
+                const t = this.next();
+                if (t.kind !== "number" && t.kind !== "ref")
+                    this.fail("expected a number", t);
+                option(o, this.span(from, t.kind === "ref" ? [t.part] : []));
+            }
+            else if (this.accept("SUPPORT")) {
+                forFunction("SUPPORT");
+                option("SUPPORT", this.qualifiedName("a support function").span);
+            }
+            else if (this.accept("WINDOW")) {
+                forFunction("WINDOW");
+                option("WINDOW", undefined, true);
+            }
+            else if (this.accept("SET")) {
+                const param = this.qualifiedName("a configuration parameter");
+                if (this.acceptSeq("FROM", "CURRENT")) {
+                    this.fail("expected TO or = (SET ... FROM CURRENT takes the value of the session that runs the CREATE; write the value)", this.lastSeen());
+                }
+                if (!this.accept("TO")) {
+                    if (!this.isOp("="))
+                        this.fail("expected TO or =");
+                    this.p++;
+                }
+                const from = this.idx();
+                const refs = [];
+                for (;;) {
+                    if (this.isOp("-") || this.isOp("+"))
+                        this.p++;
+                    const t = this.next();
+                    if (t.kind === "ref")
+                        refs.push(t.part);
+                    else if (!["ident", "qident", "string", "number"].includes(t.kind))
+                        this.fail("expected a value", t);
+                    if (this.acceptPunct(","))
+                        continue;
+                    break;
+                }
+                node.set.push({ name: param.pieces.join("."), value: this.span(from, refs) });
+            }
+            else if (this.accept("AS")) {
+                if (node.body.length > 0)
+                    this.fail("expected one AS clause", this.lastSeen());
+                for (;;) {
+                    const from = this.idx();
+                    const t = this.next();
+                    if (t.kind !== "string")
+                        this.fail("expected the definition as a string constant (AS $$ ... $$)", t);
+                    node.body.push(this.span(from, []));
+                    if (this.acceptPunct(","))
+                        continue;
+                    break;
+                }
+            }
+            else if (kw(this.peek(), "RETURN") || this.is("BEGIN", "ATOMIC")) {
+                this.fail("expected AS (a SQL-standard body is stored parsed and printed back rewritten, so it cannot be compared with what was written; write the body as a string: AS $$ ... $$)");
+            }
+            else
+                break;
+        }
+        if (node.body.length === 0)
+            this.fail("expected AS and the body, as a string constant (AS $$ ... $$)");
+        return node;
+    }
+    /** The last significant token read. */
+    lastSeen() {
+        return this.tokens[this.idx(-1)];
+    }
+    trigger(orReplace, constraint) {
+        const { text, span } = this.nameTok("a trigger name");
+        if (this.isPunct("."))
+            this.fail("expected BEFORE, AFTER or INSTEAD OF (a trigger name is not schema-qualified; the trigger is its table's)");
+        const name = { pieces: [text], span };
+        let timing;
+        if (this.accept("BEFORE"))
+            timing = "BEFORE";
+        else if (this.accept("AFTER"))
+            timing = "AFTER";
+        else if (this.acceptSeq("INSTEAD", "OF"))
+            timing = "INSTEAD OF";
+        else
+            return this.fail("expected BEFORE, AFTER or INSTEAD OF");
+        const events = [];
+        do {
+            if (this.accept("INSERT", "DELETE", "TRUNCATE"))
+                events.push({ event: this.lastSeen().text.toUpperCase(), columns: [] });
+            else if (this.accept("UPDATE")) {
+                const columns = [];
+                if (this.accept("OF")) {
+                    do
+                        columns.push((({ text, span }) => ({ name: text, span }))(this.nameTok("a column name")));
+                    while (this.acceptPunct(","));
+                }
+                events.push({ event: "UPDATE", columns });
+            }
+            else
+                this.fail("expected INSERT, UPDATE, DELETE or TRUNCATE");
+        } while (this.accept("OR"));
+        this.expect("ON");
+        const node = { statement: "trigger", orReplace, constraint, name, timing, events, table: this.qualifiedName("a table name"), referencing: [], function: { pieces: [], span: { from: 0, to: 0, refs: [] } }, args: [] };
+        for (;;) {
+            if (this.accept("FROM"))
+                node.from = this.qualifiedName("a referenced table");
+            else if (this.acceptSeq("NOT", "DEFERRABLE"))
+                node.deferrable = false;
+            else if (this.accept("DEFERRABLE"))
+                node.deferrable = true;
+            else if (this.acceptSeq("INITIALLY", "DEFERRED"))
+                node.initiallyDeferred = true;
+            else if (this.acceptSeq("INITIALLY", "IMMEDIATE"))
+                node.initiallyDeferred = false;
+            else if (this.accept("REFERENCING")) {
+                do {
+                    if (!this.accept("OLD", "NEW"))
+                        this.fail("expected OLD or NEW");
+                    const which = this.lastSeen().text.toUpperCase();
+                    this.expect("TABLE");
+                    this.accept("AS");
+                    node.referencing.push({ which, name: this.nameTok("a transition table name").text });
+                } while (kw(this.peek(), "OLD", "NEW"));
+            }
+            else if (this.accept("FOR")) {
+                this.accept("EACH");
+                if (!this.accept("ROW", "STATEMENT"))
+                    this.fail("expected ROW or STATEMENT");
+                node.forEach = this.lastSeen().text.toUpperCase();
+            }
+            else if (this.accept("WHEN")) {
+                if (!this.isPunct("("))
+                    this.fail("expected '(' (a WHEN condition is parenthesized)");
+                node.when = this.parenthesized();
+            }
+            else
+                break;
+        }
+        this.expect("EXECUTE");
+        this.expect("FUNCTION", "PROCEDURE");
+        node.function = this.qualifiedName("a trigger function");
+        this.expectPunct("(");
+        if (!this.acceptPunct(")")) {
+            for (;;) {
+                const from = this.idx();
+                if (this.isOp("-"))
+                    this.p++;
+                const t = this.next();
+                if (!["string", "number", "ident", "qident", "ref"].includes(t.kind))
+                    this.fail("expected a trigger argument (a string, a number or a name)", t);
+                node.args.push(this.span(from, t.kind === "ref" ? [t.part] : []));
+                if (this.acceptPunct(","))
+                    continue;
+                this.expectPunct(")");
+                break;
+            }
+        }
+        return node;
+    }
+    /** A role name where one is granted to or named: an identifier, an interpolation, or PUBLIC (`public`). */
+    roleSpec(what = "a role name") {
+        const t = this.peek();
+        if (kw(t, "CURRENT_USER", "CURRENT_ROLE", "SESSION_USER"))
+            this.fail(`expected ${what} (name the role: ${t.text.toUpperCase()} is whichever role runs the statement)`);
+        if (kw(t, "PUBLIC")) {
+            const i = this.idx();
+            this.p++;
+            return { name: "public", span: { from: i, to: i + 1, refs: [] } };
+        }
+        const n = this.next();
+        if (!isNameToken(n))
+            this.fail(`expected ${what}`, n);
+        const i = this.idx(-1);
+        return { name: n.kind === "ref" ? "" : identValue(n), span: { from: i, to: i + 1, refs: n.kind === "ref" ? [n.part] : [] } };
+    }
+    roleList(what) {
+        const out = [this.roleSpec(what)];
+        while (this.acceptPunct(","))
+            out.push(this.roleSpec(what));
+        return out;
+    }
+    policy() {
+        const { text, span } = this.nameTok("a policy name");
+        this.expect("ON");
+        const node = { statement: "policy", name: { pieces: [text], span }, table: this.qualifiedName("a table name"), roles: [] };
+        if (this.accept("AS")) {
+            if (this.accept("PERMISSIVE"))
+                node.permissive = true;
+            else {
+                this.expect("RESTRICTIVE");
+                node.permissive = false;
+            }
+        }
+        if (this.accept("FOR")) {
+            if (!this.accept("ALL", "SELECT", "INSERT", "UPDATE", "DELETE"))
+                this.fail("expected ALL, SELECT, INSERT, UPDATE or DELETE");
+            node.command = this.lastSeen().text.toUpperCase();
+        }
+        if (this.accept("TO"))
+            node.roles = this.roleList();
+        if (this.accept("USING")) {
+            if (!this.isPunct("("))
+                this.fail("expected '('");
+            node.using = this.parenthesized();
+        }
+        if (this.acceptSeq("WITH", "CHECK")) {
+            if (!this.isPunct("("))
+                this.fail("expected '('");
+            node.check = this.parenthesized();
+        }
+        return node;
+    }
+    role() {
+        const { text, span } = this.nameTok("a role name");
+        const node = { statement: "role", name: { pieces: [text], span }, options: [] };
+        this.accept("WITH");
+        const FLAGS = ["SUPERUSER", "NOSUPERUSER", "CREATEDB", "NOCREATEDB", "CREATEROLE", "NOCREATEROLE", "INHERIT", "NOINHERIT", "LOGIN", "NOLOGIN", "REPLICATION", "NOREPLICATION", "BYPASSRLS", "NOBYPASSRLS"];
+        for (;;) {
+            if (this.atEnd())
+                return node;
+            if (kw(this.peek(), ...FLAGS))
+                node.options.push({ option: this.next().text.toUpperCase() });
+            else if (this.acceptSeq("CONNECTION", "LIMIT")) {
+                const from = this.idx();
+                if (this.isOp("-"))
+                    this.p++;
+                const t = this.next();
+                if (t.kind !== "number" && t.kind !== "ref")
+                    this.fail("expected a number", t);
+                node.options.push({ option: "CONNECTION LIMIT", value: this.span(from, t.kind === "ref" ? [t.part] : []) });
+            }
+            else if (kw(this.peek(), "PASSWORD", "ENCRYPTED", "UNENCRYPTED") || this.is("VALID", "UNTIL")) {
+                this.fail("expected a role option (a password is the environment's secret, never a declaration's: set it where the environment's credentials are kept)");
+            }
+            else if (kw(this.peek(), "IN", "ROLE", "ADMIN", "USER", "SYSID")) {
+                this.fail("expected a role option (who is a member of which role is the environment's: grant memberships where the roles are provisioned)");
+            }
+            else
+                return this.fail("expected a role option");
+        }
+    }
+    /** `GRANT|REVOKE privileges ON target TO|FROM roles`, after GRANT or REVOKE; for default privileges, `on` is a plural kind and there are no objects. */
+    grant(revoke, defaults) {
+        const grantOptionFor = revoke && this.acceptSeq("GRANT", "OPTION", "FOR");
+        const privileges = [];
+        if (this.accept("ALL")) {
+            this.accept("PRIVILEGES");
+            const columns = this.isPunct("(") ? this.nameList() : [];
+            privileges.push({ privilege: "ALL", columns });
+        }
+        else {
+            const KNOWN = ["SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER", "MAINTAIN", "USAGE", "CREATE", "EXECUTE"];
+            do {
+                const t = this.next();
+                if (!kw(t, ...KNOWN)) {
+                    if (t.kind === "ident" || t.kind === "qident" || t.kind === "ref") {
+                        this.fail("expected a privilege (a role granted to a role is membership, which is the environment's: grant it where the roles are provisioned)", t);
+                    }
+                    this.fail("expected a privilege", t);
+                }
+                privileges.push({ privilege: t.text.toUpperCase(), columns: this.isPunct("(") ? this.nameList() : [] });
+            } while (this.acceptPunct(","));
+        }
+        this.expect("ON");
+        const node = { statement: "grant", revoke, grantOptionFor, privileges, on: "TABLE", objects: [], grantees: [], withGrantOption: false, defaults };
+        if (defaults) {
+            if (!this.accept("TABLES", "SEQUENCES", "FUNCTIONS", "ROUTINES", "TYPES", "SCHEMAS"))
+                this.fail("expected TABLES, SEQUENCES, FUNCTIONS, ROUTINES, TYPES or SCHEMAS");
+            node.on = this.lastSeen().text.toUpperCase();
+        }
+        else {
+            if (this.accept("ALL")) {
+                this.fail("expected an object (ALL ... IN SCHEMA grants on what exists when it runs; grant on each declared object, and use ALTER DEFAULT PRIVILEGES for what is created later)", this.lastSeen());
+            }
+            if (kw(this.peek(), "DATABASE", "DOMAIN", "TYPE", "LANGUAGE", "LARGE", "TABLESPACE", "FOREIGN", "PARAMETER")) {
+                this.fail("expected TABLE, SEQUENCE, SCHEMA, FUNCTION, PROCEDURE or ROUTINE (privileges on this kind of object are not declared)");
+            }
+            if (this.accept("TABLE", "SEQUENCE", "SCHEMA", "FUNCTION", "PROCEDURE", "ROUTINE"))
+                node.on = this.lastSeen().text.toUpperCase();
+            const routine = node.on === "FUNCTION" || node.on === "PROCEDURE" || node.on === "ROUTINE";
+            do {
+                const name = this.qualifiedName(node.on === "SCHEMA" ? "a schema name" : "an object name");
+                node.objects.push(routine && this.isPunct("(") ? { name, args: this.parenthesized() } : { name });
+            } while (this.acceptPunct(","));
+        }
+        if (revoke)
+            this.expect("FROM");
+        else
+            this.expect("TO");
+        this.accept("GROUP");
+        node.grantees = this.roleList();
+        if (!revoke && this.acceptSeq("WITH", "GRANT", "OPTION"))
+            node.withGrantOption = true;
+        if (this.acceptSeq("GRANTED", "BY"))
+            this.fail("expected the end of the statement (GRANTED BY names another grantor; chant grants as the role it runs as)", this.lastSeen());
+        if (revoke && this.accept("CASCADE", "RESTRICT")) {
+            if (this.lastSeen().text.toUpperCase() === "CASCADE")
+                this.fail("expected the end of the statement (CASCADE revokes what others granted from it; revoke each grant)", this.lastSeen());
+        }
+        return node;
+    }
+    defaultPrivileges() {
+        let forRoles;
+        let inSchemas;
+        for (;;) {
+            if (this.accept("FOR")) {
+                this.expect("ROLE", "USER");
+                forRoles = this.roleList();
+            }
+            else if (this.acceptSeq("IN", "SCHEMA")) {
+                inSchemas = [];
+                do
+                    inSchemas.push((({ text, span }) => ({ name: text, span }))(this.nameTok("a schema name")));
+                while (this.acceptPunct(","));
+            }
+            else
+                break;
+        }
+        let node;
+        if (this.accept("GRANT"))
+            node = this.grant(false, true);
+        else {
+            this.expect("REVOKE");
+            node = this.grant(true, true);
+        }
+        return { ...node, ...(forRoles ? { forRoles } : {}), ...(inSchemas ? { inSchemas } : {}) };
+    }
+    rowSecurity() {
+        this.accept("ONLY");
+        const table = this.qualifiedName("a table name");
+        let action;
+        if (this.accept("ENABLE"))
+            action = "ENABLE";
+        else if (this.accept("DISABLE"))
+            action = "DISABLE";
+        else if (this.accept("FORCE"))
+            action = "FORCE";
+        else if (this.acceptSeq("NO", "FORCE"))
+            action = "NO FORCE";
+        else
+            return this.fail("expected ENABLE, DISABLE, FORCE or NO FORCE ROW LEVEL SECURITY (a table's other changes are its CREATE TABLE's)");
+        this.expect("ROW");
+        this.expect("LEVEL");
+        this.expect("SECURITY");
+        return { statement: "rowSecurity", table, action };
+    }
+    comment() {
+        this.expect("ON");
+        let objectType;
+        let on;
+        let target;
+        let args;
+        if (this.accept("CONSTRAINT")) {
+            objectType = "CONSTRAINT";
+            target = this.qualifiedName("a constraint name");
+            this.expect("ON");
+            if (this.accept("DOMAIN"))
+                objectType = "DOMAIN CONSTRAINT";
+            on = this.qualifiedName("a table name");
+        }
+        else if (this.accept("TRIGGER", "POLICY")) {
+            objectType = this.lastSeen().text.toUpperCase();
+            target = this.qualifiedName(`a ${objectType.toLowerCase()} name`);
+            this.expect("ON");
+            on = this.qualifiedName("a table name");
+        }
+        else if (this.accept("ROLE")) {
+            objectType = "ROLE";
+            target = this.qualifiedName("a role name");
+        }
+        else if (this.acceptSeq("EVENT", "TRIGGER")) {
+            objectType = "EVENT TRIGGER";
+            target = this.qualifiedName("an event trigger name");
+        }
+        else if (this.accept("CAST")) {
+            objectType = "CAST";
+            const from = this.idx();
+            this.expectPunct("(");
+            const source = this.typeName();
+            this.expect("AS");
+            const castTarget = this.typeName();
+            this.expectPunct(")");
+            target = { pieces: [], span: this.span(from, [...source.refs, ...castTarget.refs]) };
+            this.expect("IS");
+            const node = { statement: "comment", objectType, target, cast: { source, target: castTarget } };
+            if (!this.accept("NULL"))
+                node.text = this.commentText();
+            return node;
+        }
+        else if (this.accept("AGGREGATE", "COLLATION")) {
+            objectType = this.lastSeen().text.toUpperCase();
+            target = this.qualifiedName(`an ${objectType.toLowerCase()} name`);
+            if (objectType === "AGGREGATE") {
+                if (!this.isPunct("("))
+                    this.fail("expected '(' and the aggregate's argument types");
+                args = this.parenthesized();
+            }
+        }
+        else {
+            if (this.acceptSeq("MATERIALIZED", "VIEW"))
+                objectType = "MATERIALIZED VIEW";
+            else if (this.accept("TABLE", "COLUMN", "INDEX", "VIEW", "SEQUENCE", "TYPE", "DOMAIN", "SCHEMA", "EXTENSION", "FUNCTION", "PROCEDURE")) {
+                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");
+            target = this.qualifiedName("an object name");
+            if ((objectType === "FUNCTION" || objectType === "PROCEDURE") && this.isPunct("("))
+                args = this.parenthesized();
+        }
+        this.expect("IS");
+        const node = { statement: "comment", objectType, target, on, ...(args ? { args } : {}) };
+        if (!this.accept("NULL"))
+            node.text = this.commentText();
+        return node;
+    }
+    /** A comment's text: a string, or an interpolation. */
+    commentText() {
+        const t = this.peek();
+        if (t?.kind !== "string" && t?.kind !== "ref")
+            this.fail("expected a string or NULL");
+        const from = this.idx();
+        this.p++;
+        return this.span(from, t.kind === "ref" ? [t.part] : []);
+    }
+    /** Statements separated by `;`, to the end. */
+    parseMany() {
+        const out = [];
+        while (this.peek() !== undefined) {
+            if (this.acceptPunct(";"))
+                continue;
+            const before = this.unknownClauses.length;
+            const node = this.parse();
+            if (this.unknownClauses.length > before)
+                node.unknown = this.unknownClauses.slice(before);
+            out.push(node);
+            if (this.peek() !== undefined && !this.isPunct(";"))
+                this.fail(`unexpected token after the ${describe(out[out.length - 1])}`);
+        }
+        if (out.length === 0)
+            this.fail("expected a statement");
+        return out;
+    }
+}
+const describe = (n) => n.statement === "comment"
+    ? "COMMENT ON"
+    : n.statement === "enum"
+        ? "type definition"
+        : n.statement === "grant"
+            ? n.defaults
+                ? "ALTER DEFAULT PRIVILEGES"
+                : n.revoke
+                    ? "REVOKE"
+                    : "GRANT"
+            : n.statement === "rowSecurity"
+                ? "ALTER TABLE"
+                : `${n.statement} definition`;
+/**
+ * Parse a template: one CREATE, optionally followed by COMMENT ON statements,
+ * separated by `;`. Throws {@link SqlSyntaxError} located in the template.
+ */
+export function parseStatements(tokens) {
+    return new PgParser(tokens).parseMany();
+}