From 5add5907e5b42cf500a74544faf7b7e4de52629b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20=C3=87engel?= <oscngl@gmail.com>
Date: Sat, 10 Oct 2026 14:48:25 +0300
Subject: [PATCH] feat(schema): split schema sources so unreadable statements
 fail alone

Split each schema source at the statement separators JSqlParser's own
token manager reports and parse every statement alone. A tagged
dollar-quoted body ends at the next occurrence of its delimiter, and psql
meta-command lines such as \restrict are blanked before lexing.

A statement the parser cannot read is ignored unless it opens as table or
type DDL. An unreadable ALTER TABLE whose every top-level action adds a
constraint or an identity is ignored without resolving its table, which
lets pg_dump identity columns load. Any other unreadable table or type
statement is rejected with the parser's reason at its file line and
column. Functions and procedures with bodies that are not dollar-quoted
are now ignored.
---
 docs/postgresql.md                            | 168 +++++---
 .../schema/parser/DefaultSchemaParser.java    | 301 +++++++++-----
 .../schema/parser/SchemaSourceSplitter.java   | 286 +++++++++++++
 .../parser/DefaultSchemaParserTest.java       | 384 ++++++++++++++----
 4 files changed, 921 insertions(+), 218 deletions(-)
 create mode 100644 sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaSourceSplitter.java

diff --git a/docs/postgresql.md b/docs/postgresql.md
index 7df8a81..06dafdd 100644
--- a/docs/postgresql.md
+++ b/docs/postgresql.md
@@ -249,7 +249,7 @@ left:
 | `ALTER TYPE ... ADD VALUE IF NOT EXISTS '<label>'` | Does nothing when the type already has the label. As PostgreSQL does, the existing label decides before the neighbour, so a neighbour the type does not have is not resolved at all. |
 | Any other `ALTER TYPE` action, such as `RENAME TO`, `RENAME VALUE`, `OWNER TO`, `SET SCHEMA`, or an attribute change | Rejected as `Unsupported ALTER TYPE action at line <n>`. |
 | `CREATE TYPE` of a composite, range, or shell type | Ignored. A column of such a type is recorded with its declared type, as [Unsupported Types and DDL](#unsupported-types-and-ddl) describes. |
-| `DROP TYPE` | Rejected. sqlcj's parser does not read the statement, so it is reported as a syntax error; see [Ignored Statements](#ignored-statements). |
+| `DROP TYPE` | Ignored. sqlcj's parser cannot read the statement, and an unreadable statement that does not open as table or type DDL is ignored, so an enum the schema models stays modeled with its labels and the columns of that type stay modeled; see [Ignored Statements](#ignored-statements). |
 
 Type names are matched case-insensitively, after their SQL identifier
 delimiters are removed, and labels are matched exactly. A statement that repeats
@@ -428,24 +428,30 @@ forms of [Ordered Table DDL](#ordered-table-ddl) and the
 including
 
 - `CREATE INDEX`, `CREATE UNIQUE INDEX`, `ALTER INDEX`, and `DROP INDEX`,
-- `COMMENT ON TABLE`, `COMMENT ON COLUMN`, and `COMMENT ON VIEW`, the only
-  `COMMENT ON` targets sqlcj's parser reads; see below,
+- `COMMENT ON` of any target, including `TABLE`, `COLUMN`, `VIEW`, `TYPE`,
+  `INDEX`, `FUNCTION`, `SCHEMA`, `EXTENSION`, and `CONSTRAINT`,
 - `CREATE EXTENSION`, `CREATE SEQUENCE`, `ALTER SEQUENCE`, and `DROP SEQUENCE`,
 - `GRANT`, `REVOKE`, and `ALTER DEFAULT PRIVILEGES`,
 - `CREATE FUNCTION`, `CREATE PROCEDURE`, `DROP FUNCTION`, `CREATE TRIGGER`, and
-  `DROP TRIGGER`; a function or procedure body must be dollar-quoted, as below,
+  `DROP TRIGGER`, with a body written any way: the untagged `$$ ... $$`, a
+  tagged `$body$ ... $body$`, a single-quoted `AS 'SELECT 1'`, or `RETURN 1`,
+- `DO` blocks, with an untagged or a tagged body and with or without a stated
+  `LANGUAGE`,
 - `INSERT`, `UPDATE`, `DELETE`, and `TRUNCATE`, a migration's data statements,
 - `CREATE VIEW`, `DROP VIEW`, and the `CREATE`, `REFRESH`, and `DROP` forms of
   `MATERIALIZED VIEW`,
 - `CREATE SCHEMA` and `DROP SCHEMA`,
-- `SET`, `RESET`, `ANALYZE`, `COMMIT`, and a plain `SELECT`, such as the
+- `SET`, including `SET search_path TO a, b`, `RESET`, `ANALYZE`, `VACUUM`,
+  `LOCK TABLE`, `BEGIN`, `COMMIT`, `COPY`, and a plain `SELECT`, such as the
   `SELECT pg_catalog.set_config(...)` a `pg_dump` snapshot opens with,
-- `CREATE POLICY`, `CREATE ROLE`, `CREATE USER`, and `ALTER ROLE`,
-- `CREATE DOMAIN` and `ALTER DOMAIN`,
-- a `CREATE TYPE` of a composite, range, or shell type, and
-- a statement sqlcj's parser reports only as opaque text and that does not open
-  as table or type DDL, such as `ALTER FUNCTION`, `ALTER SCHEMA`,
-  `CREATE AGGREGATE`, or `CREATE CAST`.
+- `CREATE POLICY`, `DROP POLICY`, `CREATE ROLE`, `CREATE USER`, and
+  `ALTER ROLE`,
+- `CREATE DOMAIN`, `ALTER DOMAIN`, and `DROP DOMAIN`,
+- `CREATE RULE` and `CREATE EVENT TRIGGER`,
+- a `CREATE TYPE` of a composite, range, or shell type, and `DROP TYPE`, and
+- a statement sqlcj's parser cannot read, or reports only as opaque text, and
+  that does not open as table or type DDL, such as `ALTER FUNCTION`,
+  `ALTER SCHEMA`, `CREATE AGGREGATE`, or `CREATE CAST`.
 
 An ignored statement is not resolved against the schema at all, so it may name a
 table or a column the snapshot does not model: a view over an unmodeled table
@@ -458,14 +464,14 @@ what they would do to the schema model:
 | --- | --- |
 | An `ALTER TABLE` action outside [Ordered Table DDL](#ordered-table-ddl) and the constraint actions below | `Unsupported ALTER TABLE action at line <n>` |
 | An `ALTER TYPE` action other than `ADD VALUE` | `Unsupported ALTER TYPE action at line <n>` |
-| A `CREATE FUNCTION` or `CREATE PROCEDURE` whose body is not delimited by the untagged `$$ ... $$` | `Unsupported schema statement: CREATE FUNCTION without a dollar-quoted body at line <n>`, with `CREATE PROCEDURE` for a procedure |
-| A statement sqlcj's parser reports only as opaque text and that opens as table or type DDL | `Unsupported schema statement: ALTER FOREIGN TABLE at line <n>`, quoting the opening words |
-
-An opaque statement opens as table DDL when its first words are `CREATE`,
-`ALTER`, or `DROP`, then any of `GLOBAL`, `LOCAL`, `TEMP`, `TEMPORARY`,
-`UNLOGGED`, or `FOREIGN`, then `TABLE`, and as type DDL when they are `CREATE`
-or `ALTER`, then `TYPE`. The words are matched case-insensitively and the
-diagnostic quotes them in upper case, single-spaced, so both
+| A statement sqlcj's parser cannot read that opens as table or type DDL, outside the `ALTER TABLE` actions below | The parser's own reason with the line and column of the unexpected token, as in `Encountered unexpected token: "DATA" at line 18, column 41` |
+| A statement sqlcj's parser reports only as opaque text, or as several statements, and that opens as table or type DDL | `Unsupported schema statement: ALTER FOREIGN TABLE at line <n>`, quoting the opening words |
+
+A statement opens as table DDL when its first words are `CREATE`, `ALTER`, or
+`DROP`, then any of `GLOBAL`, `LOCAL`, `TEMP`, `TEMPORARY`, `UNLOGGED`, or
+`FOREIGN`, then `TABLE`, and as type DDL when they are `CREATE` or `ALTER`, then
+`TYPE`. The words are matched case-insensitively and the diagnostic quotes them
+in upper case, single-spaced, so both
 `ALTER FOREIGN TABLE ft ADD COLUMN x integer` and its lower-case spelling are
 rejected as `Unsupported schema statement: ALTER FOREIGN TABLE at line <n>`.
 
@@ -477,7 +483,7 @@ except that the statement still resolves its table:
 | `ALTER TABLE ... ADD [CONSTRAINT name] PRIMARY KEY (...)` | Named or unnamed. |
 | `ALTER TABLE ... ADD [CONSTRAINT name] UNIQUE (...)` | Named or unnamed. |
 | `ALTER TABLE ... ADD [CONSTRAINT name] FOREIGN KEY (...) REFERENCES ...` | Named or unnamed. |
-| `ALTER TABLE ... ADD CONSTRAINT name CHECK (...)` | The unnamed `ADD CHECK (...)` spelling is a syntax error for sqlcj's parser; see below. |
+| `ALTER TABLE ... ADD CONSTRAINT name CHECK (...)` | |
 | `ALTER TABLE ... DROP CONSTRAINT [IF EXISTS] name` | |
 | `ALTER TABLE ... RENAME CONSTRAINT` | |
 
@@ -491,36 +497,54 @@ table does. Such an action may stand alone or beside modeled actions of one
 `ALTER TABLE users ADD COLUMN age INTEGER, ADD CONSTRAINT users_age_check CHECK (age > 0)`
 appends `age` and records nothing for the constraint.
 
-Three limitations follow from what sqlcj's SQL parser reads, and sqlcj does not
-split or pre-process the SQL to work around them:
-
-- A `CREATE FUNCTION` or `CREATE PROCEDURE` is ignored only when its body is
-  delimited by the untagged `$$ ... $$`, which is the only dollar-quote
-  delimiter sqlcj's parser reads. A tagged delimiter such as
-  `$body$ ... $body$` is not read at all: it is a syntax error, reported for the
-  closing delimiter, as in
-  `Encountered unexpected token: "$body$" at line 1, column 74`. A body written
-  any other way, such as `AS 'SELECT 1' LANGUAGE sql` or `RETURN 1`, is captured
-  through the end of the file, so such a function or procedure is rejected at
-  the line it begins on and nothing after it is applied.
-- `COMMENT ON` is read only for the `TABLE`, `COLUMN`, and `VIEW` targets. Any
-  other target, such as `COMMENT ON TYPE`, is a syntax error rather than an
-  ignored statement.
-- `ALTER TABLE ... ADD CHECK (...)` without a constraint name is a syntax
-  error. The named `ADD CONSTRAINT name CHECK (...)` spelling is ignored as
-  listed above.
+An `ALTER TABLE` sqlcj's parser cannot read is classified by its words instead,
+and ignored when every one of its top-level actions — the parts separated by
+the commas that stand outside parentheses — begins with one of
+
+- `ADD CONSTRAINT <name>`,
+- `ADD CHECK`, `ADD UNIQUE`, or `ADD EXCLUDE`,
+- `ADD PRIMARY KEY` or `ADD FOREIGN KEY`, or
+- `ALTER [COLUMN] <name> ADD GENERATED`.
+
+PostgreSQL 16 writes `ALTER TABLE ONLY public.t ALTER COLUMN id ADD GENERATED
+... AS IDENTITY (SEQUENCE NAME ...)` for every identity column of a
+`pg_dump --schema-only` snapshot, and sqlcj's parser reads neither that form nor
+an `EXCLUDE`, `DEFERRABLE INITIALLY DEFERRED`, `UNIQUE USING INDEX`,
+`PRIMARY KEY USING INDEX`, or `NOT VALID` constraint, nor an unnamed
+`ADD CHECK`. None of them can change a modeled column's existence, name, type,
+or nullability, which comes from `NOT NULL` alone. Such a statement is ignored
+without its table being resolved, like every other ignored statement, so it also
+loads for a table the snapshot does not model. Every other unreadable
+`ALTER TABLE`, including `ALTER COLUMN ... SET DATA TYPE` and an ignored action
+written beside it, stays rejected with the parser's reason.
+
+sqlcj splits a schema file at the statement separators its own SQL lexer
+reports and parses each statement alone, so a statement the parser cannot read
+fails only itself:
+
+- A separator inside a quoted string, a quoted identifier, a comment, or the
+  untagged `$$ ... $$` literal is not a boundary. A tagged dollar-quoted body
+  ends at the next occurrence of its own opening delimiter, as PostgreSQL ends
+  it, whether that delimiter stands alone or is glued to the body as in
+  `$fn$BEGIN ... END$fn$`. A body that is never closed fails the source as
+  `Unterminated dollar-quoted string at line <n>, column <c>`.
+- A psql meta-command line, a line whose first non-blank character is a
+  backslash, such as the `\restrict` and `\unrestrict` lines recent `pg_dump`
+  releases write, is skipped. Every line and column a diagnostic reports is a
+  position in the file as it was written.
+- An escape string that quotes a single quote with a backslash, such as
+  `E'it\'s'`, is mis-lexed by sqlcj's SQL lexer and fails the whole file.
+  Writing the doubled `E'it''s'`, or the ordinary `'it''s'`, avoids it.
 
 sqlcj reads only the statements a schema file states, so a schema change a
 statement makes indirectly is never seen:
 
-- DDL inside a function or procedure body belongs to that body, which is one
-  literal to sqlcj's parser, so a table or a type the body creates or alters is
-  not modeled. The same holds for DDL inside a `DO` block, which sqlcj's parser
-  does not read at all: a `DO` statement is reported as a syntax error.
+- DDL inside a function or procedure body, or inside a `DO` block, belongs to
+  that body, so a table or a type the body creates, alters, or drops is not
+  modeled.
 - `DROP TYPE ... CASCADE` drops every column of the dropped type, and sqlcj
-  never models those columns as dropped. sqlcj's parser does not read
-  `DROP TYPE` at all either, so such a statement is reported as a syntax error;
-  see [Enum Types](#enum-types).
+  never models those columns as dropped; `DROP TYPE` itself is ignored, so the
+  enum stays modeled with its labels; see [Enum Types](#enum-types).
 
 ## Nulls
 
@@ -749,7 +773,8 @@ Enum types:
   `DefaultSchemaParserTest.shouldRecordAColumnOfAnIgnoredCompositeType` cover
   the ignored composite, range, and shell `CREATE TYPE` and the column a
   composite type leaves recorded, and
-  `DefaultSchemaParserTest.shouldRejectDropType` covers `DROP TYPE`.
+  `DefaultSchemaParserTest.shouldIgnoreDropTypeAndKeepTheModeledEnum` covers the
+  ignored `DROP TYPE` and the enum and enum column that survive it.
 - `QueryAnalyzerTest.shouldCarryTheEnumTypeOfASelectedColumnAndItsParameter`,
   `QueryAnalyzerTest.shouldCarryTheEnumTypeOfAReturningColumnAndItsParameter`,
   `QueryAnalyzerTest.shouldAcceptARepeatedIndexOfOneEnumType`, and
@@ -842,17 +867,48 @@ Ignored statements:
   covers that an ignored `ALTER TABLE` action still resolves its table.
 - `DefaultSchemaParserTest.shouldApplyAModeledActionBesideAnIgnoredConstraintAction`
   covers an ignored action beside a modeled one.
+- `DefaultSchemaParserTest.shouldIgnoreEveryUnreadableStatementThatIsNotTableOrTypeDdl`
+  covers one spelling per statement kind sqlcj's parser cannot read, including
+  the untagged, tagged, and `LANGUAGE` forms of `DO`, `DROP TYPE`, every
+  `COMMENT ON` target the parser does not read, `SET search_path TO a, b`,
+  `DROP POLICY`, `DROP DOMAIN`, `VACUUM`, `LOCK TABLE`, `BEGIN`, `COPY ... TO`,
+  `CREATE RULE`, `CREATE EVENT TRIGGER`, and the single-quoted, `RETURN`, and
+  tagged function and procedure bodies.
+- `DefaultSchemaParserTest.shouldIgnoreTheUnreadableAlterTableActionsThatCannotChangeAColumn`
+  and
+  `DefaultSchemaParserTest.shouldIgnoreThePgDumpIdentityAlterTableAction` cover
+  every ignored unreadable action, alone and two in one statement, on a table
+  the schema does not model, including the multi-line `pg_dump` identity form.
 - `DefaultSchemaParserTest.shouldRejectUnsupportedStatementsInSqlTerms` covers
-  the exact message and line of each rejected statement and action, including
-  the single-quoted function and procedure bodies and the upper- and lower-case
-  `ALTER FOREIGN TABLE`, and
-  `DefaultSchemaParserTest.shouldRejectUnsupportedSchemaStatement` and
-  `DefaultSchemaParserTest.shouldReportTheLineOfARejectedStatementAfterCommentsAndAFunctionBody`
-  cover the reported line after comments that contain a statement separator and
-  after a multi-line dollar-quoted body.
-- `DefaultSchemaParserTest.shouldRejectASingleQuotedFunctionBodyThatCapturesALaterDollarQuotedBody`
-  covers that a single-quoted body is rejected at its own line even when it
-  captures a later dollar-quoted body.
+  the exact message and line of each statement and action rejected in SQL terms,
+  including the upper- and lower-case `ALTER FOREIGN TABLE`, and
+  `DefaultSchemaParserTest.shouldRejectUnsupportedSchemaStatement`,
+  `DefaultSchemaParserTest.shouldReportTheLineOfARejectedStatementAfterCommentsAndAFunctionBody`,
+  and
+  `DefaultSchemaParserTest.shouldReportTheLineOfARejectedStatementAfterUnreadableOnesAndATaggedBody`
+  cover the reported line after comments that contain a statement separator,
+  after a dollar-quoted body, and after a blanked meta-command line and
+  unreadable statements.
+- `DefaultSchemaParserTest.shouldRejectAnUnreadableAlterColumnActionAtItsFileLineAndColumn`,
+  `DefaultSchemaParserTest.shouldRejectAnUnreadableAlterTableActionBesideAnIgnoredOne`,
+  and
+  `DefaultSchemaParserTest.shouldRejectAnUnreadableCreateTypeAtItsFileLineAndColumn`
+  cover the parser's reason at the file line and column of `SET DATA TYPE`, of
+  `SET DATA TYPE` beside an ignored action in a statement that begins in the
+  middle of a line, and of an unreadable `CREATE TYPE`.
+- `DefaultSchemaParserTest.shouldApplyTheStatementsAroundUnreadableOnesAndNotModelDdlInsideABody`
+  covers the statements applied before and after unreadable ones and the DDL of
+  an untagged, a tagged, and a glued `$fn$BEGIN ... END$fn$` body that is not
+  modeled;
+  `DefaultSchemaParserTest.shouldApplyTheStatementsAfterAFunctionBodyThatIsNotDollarQuoted`
+  covers the statements after a single-quoted body.
+- `DefaultSchemaParserTest.shouldSkipPsqlMetaCommandLines` covers a schema source
+  with `\restrict` and `\unrestrict` lines, and
+  `DefaultSchemaParserTest.shouldRejectAnUnterminatedDollarQuotedBody` covers the
+  located failure of a tagged body that is never closed.
+- `DefaultSchemaParserTest.shouldLoadTheMigrationFilesInOrder` covers a migration
+  history that states `COMMENT ON TYPE` beside the targets the parser reads,
+  loaded unchanged.
 - `SqlcjCompilerIntegrationTest.shouldReportTheMigrationFileAndLineOfAnUnsupportedStatement`
   covers the migration file, the SQL-term message, and the line of a rejected
   statement that follows an ignored index and an ignored view, and that no file
diff --git a/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/DefaultSchemaParser.java b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/DefaultSchemaParser.java
index 5aa0e08..e048fcc 100644
--- a/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/DefaultSchemaParser.java
+++ b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/DefaultSchemaParser.java
@@ -9,12 +9,8 @@
 import dev.sqlcj.sql.SqlParseReason;
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.StringValue;
-import net.sf.jsqlparser.parser.CCJSqlParser;
-import net.sf.jsqlparser.parser.CCJSqlParserConstants;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
-import net.sf.jsqlparser.parser.Token;
 import net.sf.jsqlparser.schema.MultiPartName;
-import net.sf.jsqlparser.statement.CreateFunctionalStatement;
 import net.sf.jsqlparser.statement.Statement;
 import net.sf.jsqlparser.statement.Statements;
 import net.sf.jsqlparser.statement.UnsupportedStatement;
@@ -35,7 +31,6 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
 
 public class DefaultSchemaParser implements SchemaParser {
 
@@ -57,67 +52,236 @@ public class DefaultSchemaParser implements SchemaParser {
 
     @Override
     public Schema parse(Schema schema, String sql) {
-        AtomicReference<CCJSqlParser> parser = new AtomicReference<>();
+        List<Table> tables = new ArrayList<>(schema.tables());
+        List<EnumType> enums = new ArrayList<>(schema.enums());
+
+        for (SchemaSourceSplitter.SourceStatement statement : SchemaSourceSplitter.split(sql)) {
+            apply(statement, tables, enums);
+        }
+
+        return new Schema(tables, enums);
+    }
+
+    /**
+     * Parses one statement of a schema source alone and applies it, so that a
+     * statement the parser cannot read fails only itself.
+     *
+     * <p>A statement the parser reads as exactly one statement of a kind of its
+     * own is applied as any parsed statement is. Every other statement is
+     * unreadable: the parser states a syntax failure for it, reports it only as
+     * opaque text, or reads it as several statements. An unreadable statement is
+     * ignored unless it opens as table or type DDL, which may change what the
+     * schema models, and an unreadable {@code ALTER TABLE} is ignored as well
+     * when every one of its top-level actions cannot change a modeled column.
+     */
+    private void apply(
+        SchemaSourceSplitter.SourceStatement statement,
+        List<Table> tables,
+        List<EnumType> enums
+    ) {
+        Statements parsed = null;
+        JSQLParserException failure = null;
 
         try {
-            Statements statements = CCJSqlParserUtil.parseStatements(sql, parser::set);
+            parsed = CCJSqlParserUtil.parseStatements(statement.sql());
+        } catch (JSQLParserException e) {
+            failure = e;
+        }
 
-            List<Table> tables = new ArrayList<>(schema.tables());
-            List<EnumType> enums = new ArrayList<>(schema.enums());
+        if (
+            parsed != null
+                && parsed.size() == 1
+                && !(parsed.get(0) instanceof UnsupportedStatement)
+        ) {
+            apply(parsed.get(0), statement.line(), tables, enums);
 
-            if (!statements.isEmpty()) {
-                List<Integer> lines = statementLines(parser.get());
+            return;
+        }
 
-                for (int i = 0; i < statements.size(); i++) {
-                    apply(statements.get(i), statementLine(lines, i), tables, enums);
-                }
-            }
+        String opening = tableOrTypeOpening(statement.tokens());
+
+        if (opening == null || ignoresEveryAlterTableAction(opening, statement.tokens())) {
+            return;
+        }
+
+        if (failure != null) {
+            throw unreadableStatement(statement, failure);
+        }
+
+        throw unsupportedOpening(opening, statement.line());
+    }
+
+    /**
+     * The failure of an unreadable statement, stating the parser's reason at the
+     * position of the unexpected token in the file. The parser reads one
+     * statement at a time and therefore reports positions within it, so a
+     * rejected statement alone is parsed a second time preceded by the line
+     * breaks and spaces that stand before it in the file. A second parse that
+     * unexpectedly succeeds leaves the first reason, which names a position
+     * within the statement.
+     */
+    private SchemaParseException unreadableStatement(
+        SchemaSourceSplitter.SourceStatement statement,
+        JSQLParserException failure
+    ) {
+        String padded = "\n".repeat(statement.line() - 1)
+            + " ".repeat(statement.column() - 1)
+            + statement.sql();
 
-            return new Schema(tables, enums);
+        JSQLParserException located = failure;
+
+        try {
+            CCJSqlParserUtil.parseStatements(padded);
         } catch (JSQLParserException e) {
-            throw new SchemaParseException(SqlParseReason.of(e, true), e);
+            located = e;
         }
+
+        return new SchemaParseException(SqlParseReason.of(located, true), located);
     }
 
     /**
-     * The line each statement of one parsed source begins on, in order.
+     * Reports whether an unreadable statement is an {@code ALTER TABLE} whose
+     * every top-level action is ignored, which is decided from the statement's
+     * tokens alone, without rewriting it and without resolving its table.
      *
-     * <p>The parser reports no position per statement, so the lines are read
-     * from the token chain of its parse tree: the first token, and the first
-     * token after each statement separator, begins a statement. A comment is a
-     * special token outside the chain and a dollar-quoted function body is one
-     * literal token, so neither contributes a separator.
+     * <p>None of those actions can change a modeled column's existence, name,
+     * type, or nullability: nullability comes from {@code NOT NULL} alone, and
+     * PostgreSQL requires a column to be {@code NOT NULL} already before
+     * {@code ADD GENERATED ... AS IDENTITY}. Without this rule no
+     * {@code pg_dump} snapshot with an identity column loads, because the parser
+     * reads neither the identity form {@code pg_dump} writes nor an
+     * {@code EXCLUDE}, {@code DEFERRABLE INITIALLY DEFERRED},
+     * {@code UNIQUE USING INDEX}, or {@code NOT VALID} constraint, nor an
+     * unnamed {@code ADD CHECK}.
      */
-    private List<Integer> statementLines(CCJSqlParser parser) {
-        List<Integer> lines = new ArrayList<>();
-
-        Token token = parser.getASTRoot().jjtGetFirstToken();
-        boolean starting = true;
-
-        while (token != null && token.kind != CCJSqlParserConstants.EOF) {
-            if (token.kind == CCJSqlParserConstants.ST_SEMICOLON) {
-                starting = true;
-            } else {
-                if (starting) {
-                    lines.add(token.beginLine);
-                }
+    private boolean ignoresEveryAlterTableAction(String opening, List<String> tokens) {
+        if (!"ALTER TABLE".equals(opening)) {
+            return false;
+        }
+
+        int index = afterAlteredTableName(tokens);
+
+        if (index < 0) {
+            return false;
+        }
+
+        return topLevelActions(tokens.subList(index, tokens.size())).stream()
+            .allMatch(this::ignoresAlterTableAction);
+    }
+
+    /**
+     * The index of the first action token of an {@code ALTER TABLE}, after the
+     * optional {@code IF EXISTS} and {@code ONLY} and the altered table's
+     * possibly qualified name, or {@code -1} when the statement ends inside
+     * that name.
+     */
+    private int afterAlteredTableName(List<String> tokens) {
+        int index = 2;
+
+        if (statesWords(tokens, index, "IF", "EXISTS")) {
+            index += 2;
+        }
+
+        if (statesWords(tokens, index, "ONLY")) {
+            index++;
+        }
+
+        if (index >= tokens.size()) {
+            return -1;
+        }
 
-                starting = false;
+        index++;
+
+        while (statesWords(tokens, index, ".")) {
+            if (index + 1 >= tokens.size()) {
+                return -1;
             }
 
-            token = token.next;
+            index += 2;
+        }
+
+        return index;
+    }
+
+    /**
+     * The actions of one {@code ALTER TABLE}, split at the commas that stand
+     * outside parentheses, so a comma of a column or parameter list belongs to
+     * its action.
+     */
+    private List<List<String>> topLevelActions(List<String> tokens) {
+        List<List<String>> actions = new ArrayList<>();
+        List<String> action = new ArrayList<>();
+        int depth = 0;
+
+        for (String token : tokens) {
+            if ("(".equals(token)) {
+                depth++;
+            } else if (")".equals(token)) {
+                depth--;
+            } else if (",".equals(token) && depth == 0) {
+                actions.add(action);
+                action = new ArrayList<>();
+
+                continue;
+            }
+
+            action.add(token);
+        }
+
+        actions.add(action);
+
+        return actions;
+    }
+
+    /**
+     * Reports whether one action of an unreadable {@code ALTER TABLE} begins as
+     * an added constraint or as {@code ALTER [COLUMN] <name> ADD GENERATED}. The
+     * words are compared case-insensitively, as PostgreSQL reads them.
+     */
+    private boolean ignoresAlterTableAction(List<String> action) {
+        if (statesWords(action, 0, "ADD")) {
+            return addsIgnoredConstraint(action);
+        }
+
+        if (!statesWords(action, 0, "ALTER")) {
+            return false;
+        }
+
+        int index = statesWords(action, 1, "COLUMN")
+            ? 2
+            : 1;
+
+        return index < action.size() && statesWords(action, index + 1, "ADD", "GENERATED");
+    }
+
+    private boolean addsIgnoredConstraint(List<String> action) {
+        if (statesWords(action, 1, "CONSTRAINT")) {
+            return action.size() > 2;
         }
 
-        return lines;
+        return statesWords(action, 1, "CHECK")
+            || statesWords(action, 1, "UNIQUE")
+            || statesWords(action, 1, "EXCLUDE")
+            || statesWords(action, 1, "PRIMARY", "KEY")
+            || statesWords(action, 1, "FOREIGN", "KEY");
     }
 
     /**
-     * The line of the statement at {@code index}, clamped to the last line
-     * found. The clamp only covers a source whose statements are not separated
-     * by semicolons, which PostgreSQL itself rejects.
+     * Reports whether the tokens from {@code index} on are {@code words},
+     * compared case-insensitively.
      */
-    private int statementLine(List<Integer> lines, int index) {
-        return lines.get(Math.min(index, lines.size() - 1));
+    private boolean statesWords(List<String> tokens, int index, String... words) {
+        if (index + words.length > tokens.size()) {
+            return false;
+        }
+
+        for (int i = 0; i < words.length; i++) {
+            if (!words[i].equalsIgnoreCase(tokens.get(index + i))) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
@@ -128,10 +292,7 @@ private int statementLine(List<Integer> lines, int index) {
      * {@code ALTER TABLE}, {@code DROP TABLE},
      * {@code CREATE TYPE ... AS ENUM}, and {@code ALTER TYPE ... ADD VALUE}.
      * Every other statement a schema source may record is ignored and is not
-     * resolved against the schema at all, with two exceptions the parser forces:
-     * a function or procedure whose body it captures through the end of the
-     * source, and a statement it reports only as opaque text that opens as table
-     * or type DDL, which may change what the schema models.
+     * resolved against the schema at all.
      */
     private void apply(Statement statement, int line, List<Table> tables, List<EnumType> enums) {
         if (statement instanceof CreateTable createTable) {
@@ -151,24 +312,9 @@ private void apply(Statement statement, int line, List<Table> tables, List<EnumT
             }
 
             applyAddEnumValue(alterType, enums);
-        } else if (statement instanceof CreateFunctionalStatement functional) {
-            if (!hasDollarQuotedBody(functional)) {
-                throw unsupportedFunctionBody(functional, line);
-            }
-        } else if (statement instanceof UnsupportedStatement unsupported) {
-            String opening = tableOrTypeOpening(words(unsupported.toString()));
-
-            if (opening != null) {
-                throw unsupportedOpening(opening, line);
-            }
         }
     }
 
-    /** The whitespace-separated words of a statement's text. */
-    private List<String> words(String text) {
-        return List.of(text.trim().split("\\s+"));
-    }
-
     /**
      * The table or type DDL opening that {@code words} begin with, in upper case
      * and separated by single spaces, or {@code null} when they begin with
@@ -308,25 +454,6 @@ private int labelPosition(AlterType alterType, EnumType enumType) {
             : index + 1;
     }
 
-    /**
-     * Reports whether a {@code CREATE FUNCTION} or {@code CREATE PROCEDURE}
-     * states a dollar-quoted body, which the parser lexes as one literal token.
-     * It captures a body written any other way through the end of the source, so
-     * such a function or procedure is rejected instead of ignored.
-     *
-     * <p>A captured statement separator and everything after it is part of a
-     * later statement rather than of this function, so only the parts before the
-     * first {@code ";"} part decide.
-     */
-    private boolean hasDollarQuotedBody(CreateFunctionalStatement functional) {
-        List<String> parts = functional.getFunctionDeclarationParts();
-
-        return parts != null
-            && parts.stream()
-                .takeWhile(part -> !";".equals(part))
-                .anyMatch(part -> StringValue.getDollarQuoteDelimiter(part) != null);
-    }
-
     /**
      * Appends one table. A repeated table name fails, as PostgreSQL rejects it,
      * unless the statement declares {@code IF NOT EXISTS}.
@@ -816,16 +943,6 @@ private UnsupportedOperationException unsupportedAlterTypeAction(int line) {
         );
     }
 
-    private UnsupportedOperationException unsupportedFunctionBody(
-        CreateFunctionalStatement functional,
-        int line
-    ) {
-        return new UnsupportedOperationException(
-            "Unsupported schema statement: CREATE %s without a dollar-quoted body at line %d"
-                .formatted(upperCase(functional.getKind()), line)
-        );
-    }
-
     private UnsupportedOperationException unsupportedOpening(String opening, int line) {
         return new UnsupportedOperationException(
             "Unsupported schema statement: %s at line %d".formatted(opening, line)
diff --git a/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaSourceSplitter.java b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaSourceSplitter.java
new file mode 100644
index 0000000..94aea1d
--- /dev/null
+++ b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaSourceSplitter.java
@@ -0,0 +1,286 @@
+package dev.sqlcj.schema.parser;
+
+import dev.sqlcj.sql.SqlParseReason;
+import net.sf.jsqlparser.parser.CCJSqlParserConstants;
+import net.sf.jsqlparser.parser.CCJSqlParserTokenManager;
+import net.sf.jsqlparser.parser.SimpleCharStream;
+import net.sf.jsqlparser.parser.StringProvider;
+import net.sf.jsqlparser.parser.Token;
+import net.sf.jsqlparser.parser.TokenMgrException;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Splits one schema source into the statements it states, so that each of them
+ * is parsed alone and a statement the parser cannot read fails only itself.
+ *
+ * <p>The boundaries come from the SQL parser's own token manager, which reports
+ * a statement separator outside quoted strings, quoted identifiers, comments,
+ * and the untagged {@code $$ ... $$} literal it lexes as one token. A tagged
+ * delimiter such as {@code $body$} is lexed as an ordinary word instead, so a
+ * tagged body is kept whole here by pairing its delimiters, as PostgreSQL pairs
+ * them.
+ */
+final class SchemaSourceSplitter {
+
+    /**
+     * The opening delimiter of a tagged dollar-quoted string, which the token
+     * manager may glue to the text that follows it.
+     */
+    private static final Pattern DOLLAR_QUOTE_TAG = Pattern.compile("\\$[A-Za-z_][A-Za-z0-9_]*\\$");
+
+    private SchemaSourceSplitter() {
+    }
+
+    /**
+     * One statement of a schema source: its own SQL text including the
+     * separator, the line and column it begins on in the whole source, and the
+     * images of its tokens without that separator.
+     */
+    record SourceStatement(String sql, int line, int column, List<String> tokens) {
+    }
+
+    /**
+     * The statements of one schema source, in order. A separator with no tokens
+     * before it states no statement, and text after the last separator is one
+     * statement of its own, which the parser then rejects as PostgreSQL does.
+     *
+     * <p>A psql meta-command line, such as the {@code \restrict} lines recent
+     * {@code pg_dump} releases write, is blanked before lexing, because its
+     * first character is a lexical error. Blanking keeps every later line and
+     * column, so a reported position is always a position in the source as the
+     * user wrote it.
+     */
+    static List<SourceStatement> split(String source) {
+        String lexable = blankMetaCommandLines(source);
+        int[] lineStarts = lineStarts(lexable);
+
+        List<SourceStatement> statements = new ArrayList<>();
+        List<String> tokens = new ArrayList<>();
+        int start = -1;
+
+        CCJSqlParserTokenManager tokenManager = tokenManager(lexable, 1, 1);
+
+        try {
+            while (true) {
+                Token token = tokenManager.getNextToken();
+
+                if (token.kind == CCJSqlParserConstants.EOF) {
+                    break;
+                }
+
+                int tokenStart = offset(lineStarts, token.beginLine, token.beginColumn);
+
+                if (token.kind == CCJSqlParserConstants.ST_SEMICOLON) {
+                    if (start >= 0) {
+                        statements.add(
+                            statement(
+                                lexable,
+                                lineStarts,
+                                start,
+                                tokenStart + token.image.length(),
+                                tokens
+                            )
+                        );
+
+                        tokens = new ArrayList<>();
+                        start = -1;
+                    }
+
+                    continue;
+                }
+
+                if (start < 0) {
+                    start = tokenStart;
+                }
+
+                tokens.add(token.image);
+
+                String tag = dollarQuoteTag(token.image);
+
+                if (tag != null) {
+                    int bodyEnd = bodyEnd(lexable, tokenStart + tag.length(), tag, token);
+
+                    tokenManager = tokenManager(
+                        lexable.substring(bodyEnd),
+                        lineOf(lineStarts, bodyEnd),
+                        columnOf(lineStarts, bodyEnd)
+                    );
+                }
+            }
+        } catch (TokenMgrException e) {
+            throw new SchemaParseException(SqlParseReason.of(e, true), e);
+        }
+
+        if (start >= 0) {
+            statements.add(statement(lexable, lineStarts, start, lexable.length(), tokens));
+        }
+
+        return statements;
+    }
+
+    /**
+     * A token manager over {@code text}, which begins at {@code line} and
+     * {@code column} of the whole source, so every token it reports carries a
+     * position in that source.
+     */
+    private static CCJSqlParserTokenManager tokenManager(String text, int line, int column) {
+        return new CCJSqlParserTokenManager(
+            new SimpleCharStream(new StringProvider(text), line, column)
+        );
+    }
+
+    private static SourceStatement statement(
+        String source,
+        int[] lineStarts,
+        int start,
+        int end,
+        List<String> tokens
+    ) {
+        return new SourceStatement(
+            source.substring(start, end),
+            lineOf(lineStarts, start),
+            columnOf(lineStarts, start),
+            List.copyOf(tokens)
+        );
+    }
+
+    /**
+     * The opening delimiter of a tagged dollar-quoted string the token image
+     * begins with, or {@code null}. The token manager reports such a delimiter
+     * as an ordinary word, glued to neighboring text where there is no
+     * whitespace between them, as in {@code $fn$BEGIN}.
+     */
+    private static String dollarQuoteTag(String image) {
+        Matcher matcher = DOLLAR_QUOTE_TAG.matcher(image);
+
+        return matcher.lookingAt()
+            ? matcher.group()
+            : null;
+    }
+
+    /**
+     * The offset directly after the closing delimiter of a tagged
+     * dollar-quoted string, which PostgreSQL finds at the next occurrence of
+     * the opening delimiter. A body that is never closed fails the source at
+     * the delimiter that opened it.
+     */
+    private static int bodyEnd(String source, int searchFrom, String tag, Token opening) {
+        int closing = source.indexOf(tag, searchFrom);
+
+        if (closing < 0) {
+            throw new SchemaParseException(
+                "Unterminated dollar-quoted string at line %d, column %d"
+                    .formatted(opening.beginLine, opening.beginColumn),
+                null
+            );
+        }
+
+        return closing + tag.length();
+    }
+
+    /**
+     * The source with every character of a psql meta-command line, a line whose
+     * first non-blank character is a backslash, replaced by a space. Line breaks
+     * are kept, so the blanked source has the lines and columns of the original.
+     */
+    private static String blankMetaCommandLines(String source) {
+        char[] characters = source.toCharArray();
+        int lineStart = 0;
+
+        for (int i = 0; i <= characters.length; i++) {
+            if (i == characters.length || characters[i] == '\n' || characters[i] == '\r') {
+                blankMetaCommandLine(characters, lineStart, i);
+
+                if (
+                    i + 1 < characters.length
+                        && characters[i] == '\r'
+                        && characters[i + 1] == '\n'
+                ) {
+                    i++;
+                }
+
+                lineStart = i + 1;
+            }
+        }
+
+        return new String(characters);
+    }
+
+    private static void blankMetaCommandLine(char[] characters, int from, int to) {
+        for (int i = from; i < to; i++) {
+            if (characters[i] == ' ' || characters[i] == '\t') {
+                continue;
+            }
+
+            if (characters[i] != '\\') {
+                return;
+            }
+
+            Arrays.fill(characters, from, to, ' ');
+
+            return;
+        }
+    }
+
+    /**
+     * The offset each line of the source begins at, counting {@code \n},
+     * {@code \r\n}, and {@code \r} as one line break, as the token manager
+     * counts them.
+     */
+    private static int[] lineStarts(String source) {
+        List<Integer> starts = new ArrayList<>();
+
+        starts.add(0);
+
+        for (int i = 0; i < source.length(); i++) {
+            char character = source.charAt(i);
+
+            if (character != '\n' && character != '\r') {
+                continue;
+            }
+
+            if (character == '\r' && i + 1 < source.length() && source.charAt(i + 1) == '\n') {
+                i++;
+            }
+
+            starts.add(i + 1);
+        }
+
+        int[] lineStarts = new int[starts.size()];
+
+        for (int i = 0; i < starts.size(); i++) {
+            lineStarts[i] = starts.get(i);
+        }
+
+        return lineStarts;
+    }
+
+    /**
+     * The offset of one line and column. The token manager counts a tab as one
+     * column, so a column is the position of a character within its line.
+     */
+    private static int offset(int[] lineStarts, int line, int column) {
+        return lineStarts[line - 1] + column - 1;
+    }
+
+    private static int lineOf(int[] lineStarts, int offset) {
+        return lineIndexOf(lineStarts, offset) + 1;
+    }
+
+    private static int columnOf(int[] lineStarts, int offset) {
+        return offset - lineStarts[lineIndexOf(lineStarts, offset)] + 1;
+    }
+
+    private static int lineIndexOf(int[] lineStarts, int offset) {
+        int index = Arrays.binarySearch(lineStarts, offset);
+
+        return index >= 0
+            ? index
+            : -index - 2;
+    }
+}
diff --git a/sqlcj-cli/src/test/java/dev/sqlcj/schema/parser/DefaultSchemaParserTest.java b/sqlcj-cli/src/test/java/dev/sqlcj/schema/parser/DefaultSchemaParserTest.java
index f5e934e..4117989 100644
--- a/sqlcj-cli/src/test/java/dev/sqlcj/schema/parser/DefaultSchemaParserTest.java
+++ b/sqlcj-cli/src/test/java/dev/sqlcj/schema/parser/DefaultSchemaParserTest.java
@@ -16,7 +16,6 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -79,7 +78,7 @@ CREATE TABLE region (
 
     /**
      * The second migration file, whose {@code COMMENT ON TYPE} statement
-     * JSqlParser does not parse.
+     * JSqlParser does not parse and which is therefore ignored.
      */
     private static final String STAGE_MIGRATION = """
         CREATE TYPE stage_setting AS ENUM ('indoor', 'outdoor');
@@ -107,9 +106,6 @@ region      text NOT NULL REFERENCES region (code),
         ALTER TABLE stage ADD COLUMN opened_at TIMESTAMP NOT NULL DEFAULT now();
         """;
 
-    /** The statement of {@link #STAGE_MIGRATION} that fails to parse. */
-    private static final String COMMENT_ON_TYPE_STATEMENT = "COMMENT ON TYPE stage_setting IS 'Whether a stage is covered';\n";
-
     private final SchemaParser parser = new DefaultSchemaParser();
 
     @Test
@@ -950,6 +946,108 @@ void shouldNotResolveAnIgnoredStatementAgainstTheSchema() {
         assertEquals(parser.parse(BASE_SCHEMA).tables(), schema.tables());
     }
 
+    /**
+     * A statement sqlcj's parser cannot read at all is ignored like any parsed
+     * statement outside the modeled forms, because it does not open as table or
+     * type DDL and therefore cannot change what the schema models.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "DO $$ BEGIN RAISE NOTICE 'x'; END $$;",
+            "DO $do$ BEGIN RAISE NOTICE 'x'; END $do$;",
+            "DO LANGUAGE plpgsql $$ BEGIN END $$;",
+            "DROP TYPE stage_setting;",
+            "COMMENT ON TYPE stage_setting IS 'the setting';",
+            "COMMENT ON INDEX users_email_idx IS 'the index';",
+            "COMMENT ON FUNCTION touch() IS 'the trigger function';",
+            "COMMENT ON SCHEMA public IS 'the schema';",
+            "COMMENT ON EXTENSION pgcrypto IS 'the extension';",
+            "COMMENT ON CONSTRAINT users_email_key ON users IS 'the constraint';",
+            "SET search_path TO app, public;",
+            "DROP POLICY users_owner ON users;",
+            "DROP DOMAIN positive;",
+            "VACUUM;",
+            "VACUUM ANALYZE users;",
+            "LOCK TABLE users IN ACCESS EXCLUSIVE MODE;",
+            "BEGIN;",
+            "COPY users (id, email) TO stdout;",
+            "CREATE RULE users_nodelete AS ON DELETE TO users DO NOTHING;",
+            "CREATE EVENT TRIGGER users_ddl ON ddl_command_start EXECUTE FUNCTION touch();",
+            "CREATE FUNCTION one() RETURNS integer AS 'SELECT 1' LANGUAGE sql;",
+            "CREATE PROCEDURE one() AS 'SELECT 1' LANGUAGE sql;",
+            "CREATE FUNCTION two() RETURNS integer LANGUAGE sql RETURN 1;",
+            "CREATE FUNCTION touch() RETURNS trigger AS $fn$BEGIN RETURN NEW; END$fn$ "
+                + "LANGUAGE plpgsql;"
+        }
+    )
+    void shouldIgnoreEveryUnreadableStatementThatIsNotTableOrTypeDdl(String statement) {
+        Schema base = parser.parse(BASE_SCHEMA);
+        Schema schema = applied(statement);
+
+        assertEquals(base.tables(), schema.tables());
+        assertEquals(base.enums(), schema.enums());
+    }
+
+    /**
+     * An unreadable {@code ALTER TABLE} whose every top-level action adds a
+     * constraint or an identity is ignored without its table being resolved, so
+     * it is ignored for a table the schema does not model at all.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TABLE payments ALTER id ADD GENERATED;",
+            "ALTER TABLE payments ALTER COLUMN id ADD GENERATED;",
+            "ALTER TABLE payments ADD CONSTRAINT payments_excl EXCLUDE USING gist (id WITH =);",
+            "ALTER TABLE payments ADD EXCLUDE USING gist (id WITH =);",
+            "ALTER TABLE payments ADD CONSTRAINT payments_key UNIQUE (id) "
+                + "DEFERRABLE INITIALLY DEFERRED;",
+            "ALTER TABLE payments ADD UNIQUE (id) DEFERRABLE INITIALLY DEFERRED;",
+            "ALTER TABLE payments ADD CONSTRAINT payments_key UNIQUE USING INDEX payments_idx;",
+            "ALTER TABLE payments ADD PRIMARY KEY USING INDEX payments_idx;",
+            "ALTER TABLE payments ADD FOREIGN KEY (id) REFERENCES users (id) NOT VALID;",
+            "ALTER TABLE payments ADD CONSTRAINT payments_check CHECK (id > 0) NOT VALID;",
+            "ALTER TABLE payments ADD CHECK (id > 0) NOT VALID;",
+            "ALTER TABLE payments ADD CHECK (id > 0);",
+            "alter table payments add check (id > 0) not valid;",
+            "ALTER TABLE IF EXISTS ONLY payments ADD CHECK (id > 0);",
+            "ALTER TABLE payments ADD CHECK (id > 0), "
+                + "ADD CONSTRAINT payments_key UNIQUE (id) DEFERRABLE;"
+        }
+    )
+    void shouldIgnoreTheUnreadableAlterTableActionsThatCannotChangeAColumn(String statement) {
+        Schema base = parser.parse(BASE_SCHEMA);
+        Schema schema = applied(statement);
+
+        assertEquals(base.tables(), schema.tables());
+        assertEquals(base.enums(), schema.enums());
+    }
+
+    /**
+     * The identity form {@code pg_dump} writes for every identity column spans
+     * several lines and names a sequence, and is ignored like the single-line
+     * forms.
+     */
+    @Test
+    void shouldIgnoreThePgDumpIdentityAlterTableAction() {
+        Schema base = parser.parse(BASE_SCHEMA);
+
+        Schema schema = applied("""
+            ALTER TABLE ONLY public.payments ALTER COLUMN id ADD GENERATED BY DEFAULT AS IDENTITY (
+                SEQUENCE NAME public.payments_id_seq
+                START WITH 1
+                INCREMENT BY 1
+                NO MINVALUE
+                NO MAXVALUE
+                CACHE 1
+            );
+            """);
+
+        assertEquals(base.tables(), schema.tables());
+        assertEquals(base.enums(), schema.enums());
+    }
+
     /**
      * A {@code CREATE TYPE} that is not an enum is ignored rather than modeled,
      * so a column of that type is recorded with the canonical spelling of its
@@ -1056,12 +1154,6 @@ void shouldApplyAModeledActionBesideAnIgnoredConstraintAction() {
             "ALTER TYPE status RENAME TO state;|Unsupported ALTER TYPE action at line 1",
             "ALTER TYPE status RENAME VALUE 'draft' TO 'new';"
                 + "|Unsupported ALTER TYPE action at line 1",
-            "CREATE FUNCTION one() RETURNS integer AS 'SELECT 1' LANGUAGE sql;"
-                + "|Unsupported schema statement: CREATE FUNCTION without a dollar-quoted body"
-                + " at line 1",
-            "CREATE PROCEDURE one() AS 'SELECT 1' LANGUAGE sql;"
-                + "|Unsupported schema statement: CREATE PROCEDURE without a dollar-quoted body"
-                + " at line 1",
             "ALTER FOREIGN TABLE ft ADD COLUMN x integer;"
                 + "|Unsupported schema statement: ALTER FOREIGN TABLE at line 1",
             "alter foreign table ft add column x integer;"
@@ -1080,29 +1172,22 @@ void shouldRejectUnsupportedStatementsInSqlTerms(String statement, String messag
     }
 
     /**
-     * A single-quoted function body captures the rest of the source, including a
-     * later dollar-quoted body, so the function is still rejected at the line it
-     * begins on and nothing after it is applied.
+     * A function body that is not dollar-quoted ends at its own separator, so it
+     * is ignored like any other function and the statements after it, including a
+     * later dollar-quoted body, are applied.
      */
     @Test
-    void shouldRejectASingleQuotedFunctionBodyThatCapturesALaterDollarQuotedBody() {
-        String sql = """
+    void shouldApplyTheStatementsAfterAFunctionBodyThatIsNotDollarQuoted() {
+        Schema schema = parser.parse("""
             CREATE TABLE users (id BIGINT);
             CREATE FUNCTION one() RETURNS integer AS 'SELECT 1' LANGUAGE sql;
             CREATE TABLE later (id BIGINT);
             DROP TABLE users;
             CREATE FUNCTION touch() RETURNS trigger AS $$ BEGIN RETURN NEW; END; $$ LANGUAGE plpgsql;
-            """;
-
-        UnsupportedOperationException exception = assertThrows(
-            UnsupportedOperationException.class,
-            () -> parser.parse(sql)
-        );
+            CREATE TABLE last (id BIGINT);
+            """);
 
-        assertEquals(
-            "Unsupported schema statement: CREATE FUNCTION without a dollar-quoted body at line 2",
-            exception.getMessage()
-        );
+        assertEquals(List.of("later", "last"), tableNames(schema));
     }
 
     /**
@@ -1141,6 +1226,186 @@ CREATE OR REPLACE FUNCTION touch() RETURNS trigger AS $$
         );
     }
 
+    /**
+     * An unreadable {@code ALTER TABLE} action outside the ignored ones is
+     * rejected with the parser's own reason at the line and column the
+     * unexpected token stands at in the file.
+     */
+    @Test
+    void shouldRejectAnUnreadableAlterColumnActionAtItsFileLineAndColumn() {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        SchemaParseException exception = assertThrows(
+            SchemaParseException.class,
+            () -> parser.parse(schema, """
+                CREATE INDEX users_email_idx ON users (email);
+
+                ALTER TABLE users ALTER COLUMN name SET DATA TYPE text;
+                """)
+        );
+
+        assertEquals(
+            "Encountered unexpected token: \"DATA\" at line 3, column 41",
+            exception.getMessage()
+        );
+    }
+
+    /**
+     * An ignored action beside an unreadable one does not make the statement
+     * ignored, and a statement that begins in the middle of a line is reported
+     * at the column it begins at.
+     */
+    @Test
+    void shouldRejectAnUnreadableAlterTableActionBesideAnIgnoredOne() {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        SchemaParseException exception = assertThrows(
+            SchemaParseException.class,
+            () -> parser.parse(
+                schema,
+                "CREATE INDEX users_email_idx ON users (email); "
+                    + "ALTER TABLE users ALTER COLUMN name SET DATA TYPE text, "
+                    + "ADD CHECK (id > 0);\n"
+            )
+        );
+
+        assertEquals(
+            "Encountered unexpected token: \"DATA\" at line 1, column 88",
+            exception.getMessage()
+        );
+    }
+
+    /** An unreadable {@code CREATE TYPE} is rejected at its file position too. */
+    @Test
+    void shouldRejectAnUnreadableCreateTypeAtItsFileLineAndColumn() {
+        SchemaParseException exception = assertThrows(
+            SchemaParseException.class,
+            () -> parser.parse("""
+                CREATE TABLE payments (id BIGINT NOT NULL);
+
+                CREATE TYPE pair AS (a int, b);
+                """)
+        );
+
+        assertEquals(
+            "Encountered unexpected token: \")\" at line 3, column 30",
+            exception.getMessage()
+        );
+    }
+
+    /**
+     * Each statement is parsed alone, so the statements before and after an
+     * unreadable one are applied. A dollar-quoted body is kept whole whether its
+     * delimiter is tagged or not, and whether the tag is glued to the body or
+     * not, so DDL the body states is not modeled and a {@code DROP TABLE} it
+     * states drops nothing.
+     */
+    @Test
+    void shouldApplyTheStatementsAroundUnreadableOnesAndNotModelDdlInsideABody() {
+        Schema schema = parser.parse("""
+            CREATE TABLE users (id BIGINT NOT NULL);
+            DO $$ BEGIN RAISE NOTICE 'start'; END $$;
+            DO $do$ BEGIN RAISE NOTICE 'tagged'; END $do$;
+            CREATE FUNCTION touch() RETURNS trigger AS $fn$BEGIN
+                CREATE TABLE glued_inner (id BIGINT);
+            END$fn$ LANGUAGE plpgsql;
+            CREATE FUNCTION bump() RETURNS integer AS $body$
+            BEGIN
+                CREATE TABLE tagged_inner (id BIGINT);
+                DROP TABLE users;
+                RETURN 1;
+            END
+            $body$ LANGUAGE plpgsql;
+            COMMENT ON TYPE stage_setting IS 'ignored';
+            CREATE TABLE orders (id BIGINT NOT NULL);
+            """);
+
+        assertEquals(List.of("users", "orders"), tableNames(schema));
+    }
+
+    /**
+     * A rejected statement keeps its own line after a blanked psql meta-command
+     * line, unreadable statements, and a multi-line tagged body, each of which
+     * the schema source keeps its line numbering through.
+     */
+    @Test
+    void shouldReportTheLineOfARejectedStatementAfterUnreadableOnesAndATaggedBody() {
+        String sql = """
+            \\restrict aBcD1234
+            CREATE TABLE users (id BIGINT NOT NULL);
+            DO $$ BEGIN RAISE NOTICE 'start'; END $$;
+            CREATE FUNCTION bump() RETURNS integer AS $body$
+            BEGIN
+                CREATE TABLE tagged_inner (id BIGINT);
+                RETURN 1;
+            END
+            $body$ LANGUAGE plpgsql;
+            COMMENT ON TYPE stage_setting IS 'ignored';
+            ALTER FOREIGN TABLE users ADD COLUMN label TEXT;
+            """;
+
+        UnsupportedOperationException exception = assertThrows(
+            UnsupportedOperationException.class,
+            () -> parser.parse(sql)
+        );
+
+        assertEquals(
+            "Unsupported schema statement: ALTER FOREIGN TABLE at line 11",
+            exception.getMessage()
+        );
+    }
+
+    /**
+     * A psql meta-command line, which recent {@code pg_dump} releases write
+     * around the dumped statements, is skipped rather than lexed, because its
+     * first character is a lexical error.
+     */
+    @Test
+    void shouldSkipPsqlMetaCommandLines() {
+        Schema schema = parser.parse("""
+            \\restrict aBcD1234
+
+            CREATE TABLE users (
+                id BIGINT NOT NULL
+            );
+
+            \\unrestrict aBcD1234
+            """);
+
+        assertEquals(List.of("users"), tableNames(schema));
+
+        assertEquals(
+            List.of(new Column("id", ColumnType.BIGINT, false)),
+            table(schema, "users").columns()
+        );
+    }
+
+    /**
+     * A tagged dollar-quoted body that is never closed fails the schema source
+     * at the delimiter that opened it, because everything after it would belong
+     * to that body.
+     */
+    @Test
+    void shouldRejectAnUnterminatedDollarQuotedBody() {
+        String sql = """
+            CREATE TABLE users (id BIGINT NOT NULL);
+            CREATE FUNCTION bump() RETURNS integer AS $body$
+            BEGIN
+                RETURN 1;
+            END;
+            """;
+
+        SchemaParseException exception = assertThrows(
+            SchemaParseException.class,
+            () -> parser.parse(sql)
+        );
+
+        assertEquals(
+            "Unterminated dollar-quoted string at line 2, column 43",
+            exception.getMessage()
+        );
+    }
+
     /**
      * Each source is applied to the schema the previous ones left, and leaves
      * their schema untouched.
@@ -1673,45 +1938,18 @@ void shouldLoadASingleFileSchemaWithEnumArrayIndexAndFunctionStatements() {
     }
 
     /**
-     * A migration file of the kind published sqlc examples use fails on its
-     * {@code COMMENT ON TYPE} statement, which JSqlParser does not parse, and
-     * the failure states the reason and the location of that statement.
-     */
-    @Test
-    void shouldRejectTheCommentOnTypeStatementOfAMigrationFile() {
-        Schema schema = parser.parse(REGION_MIGRATION);
-
-        SchemaParseException exception = assertThrows(
-            SchemaParseException.class,
-            () -> parser.parse(schema, STAGE_MIGRATION)
-        );
-
-        assertEquals(
-            "Encountered unexpected token: \"TYPE\" at line 14, column 12",
-            exception.getMessage()
-        );
-    }
-
-    /**
-     * Without that one statement the same migration files load in order: the
-     * remaining {@code COMMENT ON} targets, the enum type, and the reshaping
-     * statements are applied, the enum column is modeled from the declared
-     * type, and the enum-array and text-array columns are recorded as
-     * unsupported.
+     * Migration files of the kind published sqlc examples use load in order and
+     * unchanged: the {@code COMMENT ON TYPE} statement JSqlParser cannot read is
+     * ignored beside the targets it reads, the enum type and the reshaping
+     * statements are applied, the enum column is modeled from the declared type,
+     * and the enum-array and text-array columns are recorded as unsupported.
      */
     @Test
-    void shouldLoadTheMigrationFilesInOrderWithoutTheCommentOnTypeStatement() {
-        String loadableStageMigration = STAGE_MIGRATION.replace(
-            COMMENT_ON_TYPE_STATEMENT,
-            ""
-        );
-
-        assertNotEquals(STAGE_MIGRATION, loadableStageMigration);
-
+    void shouldLoadTheMigrationFilesInOrder() {
         Schema schema = parser.parse(
             parser.parse(
                 parser.parse(REGION_MIGRATION),
-                loadableStageMigration
+                STAGE_MIGRATION
             ),
             RESHAPE_STAGE_MIGRATION
         );
@@ -1987,22 +2225,28 @@ CREATE TABLE stages (
     }
 
     /**
-     * {@code DROP TYPE} removes an enum type sqlcj models, so it stays
-     * rejected. sqlcj's parser does not read the statement at all, so it is
-     * reported as a syntax error rather than as an unsupported statement.
+     * {@code DROP TYPE} is ignored, because sqlcj's parser cannot read it and it
+     * does not open as table or type DDL, so a modeled enum survives it and the
+     * columns of that type stay modeled.
      */
     @Test
-    void shouldRejectDropType() {
-        Schema schema = enumSchema();
+    void shouldIgnoreDropTypeAndKeepTheModeledEnum() {
+        Schema schema = parser.parse(
+            parser.parse(
+                enumSchema(),
+                "CREATE TABLE stages (setting stage_setting NOT NULL);"
+            ),
+            "DROP TYPE stage_setting;"
+        );
 
-        SchemaParseException exception = assertThrows(
-            SchemaParseException.class,
-            () -> parser.parse(schema, "DROP TYPE stage_setting;")
+        assertEquals(
+            List.of(new EnumType("stage_setting", List.of("indoor", "outdoor"))),
+            schema.enums()
         );
 
         assertEquals(
-            "Encountered unexpected token: \"TYPE\" at line 1, column 6",
-            exception.getMessage()
+            List.of(new Column("setting", ColumnType.ENUM, false, null, "stage_setting")),
+            table(schema, "stages").columns()
         );
     }