From d007daa31748a6a5bc9bc7c932469fd6da215f24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20=C3=87engel?= <oscngl@gmail.com>
Date: Sat, 10 Oct 2026 00:36:07 +0300
Subject: [PATCH] feat(schema): ignore unmodeled statements and report errors
 in SQL terms

Only CREATE/ALTER/DROP TABLE, CREATE TYPE ... AS ENUM, and
ALTER TYPE ... ADD VALUE change the schema model; every other parsed
statement, including views, schemas, session statements, TRUNCATE,
policies, roles, domains, and non-enum CREATE TYPE, is now ignored
without being resolved against the schema.

Statements that may still change the model are rejected with SQL-term
messages instead of parser class names: unsupported ALTER TABLE and
ALTER TYPE actions, functions or procedures without a dollar-quoted
body, and opaque statements that open as table or type DDL, such as
ALTER FOREIGN TABLE.
---
 docs/postgresql.md                            | 175 ++++++++++-----
 .../schema/parser/DefaultSchemaParser.java    | 211 +++++++++++-------
 .../SqlcjCompilerIntegrationTest.java         |   4 +-
 .../parser/DefaultSchemaParserTest.java       | 126 ++++++++---
 4 files changed, 346 insertions(+), 170 deletions(-)

diff --git a/docs/postgresql.md b/docs/postgresql.md
index be4155b..7df8a81 100644
--- a/docs/postgresql.md
+++ b/docs/postgresql.md
@@ -92,10 +92,13 @@ file, a list of files, or a directory of `.sql` migration files; see
 [`sql[].schema`](configuration.md#sqlschema) for the accepted forms and the
 order the files are read in.
 
-- Only `CREATE TABLE`, `DROP TABLE`, and the `ALTER TABLE` forms listed in
-  [Ordered Table DDL](#ordered-table-ddl) update the schema model. The
-  statements listed in [Ignored Statements](#ignored-statements) are accepted
-  and leave it unchanged. Any other statement in a schema file is rejected.
+- One rule decides every statement: only the `CREATE TABLE`, `DROP TABLE`, and
+  `ALTER TABLE` forms listed in [Ordered Table DDL](#ordered-table-ddl) and the
+  `CREATE TYPE ... AS ENUM` and `ALTER TYPE ... ADD VALUE` forms listed in
+  [Enum Types](#enum-types) update the schema model, and every other statement
+  a schema file records is accepted and leaves it unchanged. Only the few
+  statements listed in [Ignored Statements](#ignored-statements) are rejected
+  instead, because sqlcj cannot tell what they would do to the model.
 - The statements of the schema files of one entry are applied in order to one
   schema model, so each of them sees the tables and columns the statements and
   files before it left.
@@ -244,9 +247,9 @@ left:
 | `ALTER TYPE ... ADD VALUE '<label>' BEFORE '<neighbour>'` | Inserts the label directly before the neighbour. |
 | `ALTER TYPE ... ADD VALUE '<label>' AFTER '<neighbour>'` | Inserts the label directly after the neighbour. |
 | `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. |
-| `CREATE TYPE` of a composite, range, or shell type | Rejected. |
-| `DROP TYPE` | Rejected. sqlcj's parser does not read the statement, so it is reported as a syntax error. |
+| 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). |
 
 Type names are matched case-insensitively, after their SQL identifier
 delimiters are removed, and labels are matched exactly. A statement that repeats
@@ -359,7 +362,7 @@ are recorded with their declared type; see
 | Column-level `CHECK (...)` | Accepted and ignored. |
 | Table-level `FOREIGN KEY (...) REFERENCES ...`, named or unnamed | Accepted and ignored. |
 | Table-level `CHECK (...)`, named or unnamed | Accepted and ignored. |
-| Any statement outside [Ordered Table DDL](#ordered-table-ddl) and [Ignored Statements](#ignored-statements), such as `CREATE VIEW` | Rejected. |
+| A table statement sqlcj's parser cannot read, such as `ALTER FOREIGN TABLE` | Rejected; see [Ignored Statements](#ignored-statements). |
 | Any other table-constraint kind | Rejected. |
 | Unparsable SQL | Rejected. |
 
@@ -392,8 +395,8 @@ statements and files before them left; the enum-type statements are listed in
 | `ALTER TABLE ... ALTER COLUMN ... SET NOT NULL` | Models the column non-null. |
 | `ALTER TABLE ... ALTER COLUMN ... DROP NOT NULL` | Models the column nullable. |
 | `ALTER TABLE IF EXISTS ...` | Does nothing when the table is not modeled. It covers only the table, so a missing column of a modeled table still fails. |
-| Any other `ALTER TABLE` action outside [Ignored Statements](#ignored-statements), such as `SET DEFAULT` | Rejected. |
-| `DROP` of an object that is neither a table nor listed in [Ignored Statements](#ignored-statements), such as `DROP VIEW` | Rejected. |
+| Any other `ALTER TABLE` action outside the constraint actions listed in [Ignored Statements](#ignored-statements), such as `SET DEFAULT` | Rejected as `Unsupported ALTER TABLE action at line <n>`. |
+| `DROP` of any object other than a table, such as `DROP VIEW` or `DROP INDEX` | Ignored; see [Ignored Statements](#ignored-statements). |
 
 One `ALTER TABLE` may state several actions; they are applied in the written
 order. Table and column names are matched case-insensitively, as query analysis
@@ -413,22 +416,64 @@ sqlcj: Invalid schema source /home/dev/project/sql/migrations/V2__orders.sql: Co
 ## Ignored Statements
 
 A schema file records the whole history of a database, not only its tables, so
-these statements are accepted and leave the schema model exactly as the
-statements and files before them left it:
-
-| Statement | Notes |
+one rule decides every statement it states: a statement sqlcj models is applied,
+and every other statement is accepted and leaves the schema model exactly as the
+statements and files before it left it. There is no list of accepted kinds to
+keep up to date.
+
+The modeled statements are the `CREATE TABLE`, `DROP TABLE`, and `ALTER TABLE`
+forms of [Ordered Table DDL](#ordered-table-ddl) and the
+`CREATE TYPE ... AS ENUM` and `ALTER TYPE ... ADD VALUE` forms of
+[Enum Types](#enum-types). Everything else a migration history holds is ignored,
+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,
+- `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,
+- `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
+  `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`.
+
+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
+and a `TRUNCATE` of one are both accepted.
+
+These statements are rejected rather than ignored, because sqlcj cannot tell
+what they would do to the schema model:
+
+| Statement | Diagnostic |
+| --- | --- |
+| 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
+`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>`.
+
+These `ALTER TABLE` actions are ignored like any other unmodeled statement,
+except that the statement still resolves its table:
+
+| Action | Notes |
 | --- | --- |
-| `CREATE INDEX`, `CREATE UNIQUE INDEX` | |
-| `ALTER INDEX` | |
-| `DROP INDEX`, `DROP INDEX IF EXISTS` | |
-| `COMMENT ON TABLE`, `COMMENT ON COLUMN`, `COMMENT ON VIEW` | These are the only `COMMENT ON` targets sqlcj's parser reads; see below. |
-| `CREATE EXTENSION`, `CREATE EXTENSION IF NOT EXISTS` | |
-| `CREATE SEQUENCE`, `ALTER SEQUENCE`, `DROP SEQUENCE` | |
-| `GRANT`, `REVOKE` | |
-| `CREATE FUNCTION`, `CREATE OR REPLACE FUNCTION` | Only with a body delimited by the untagged `$$ ... $$`, such as `AS $$ ... $$`; see below. |
-| `DROP FUNCTION`, `DROP FUNCTION IF EXISTS` | |
-| `CREATE TRIGGER`, `DROP TRIGGER` | |
-| `INSERT`, `UPDATE`, `DELETE` | A migration's data statements do not change the modeled tables. |
 | `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. |
@@ -437,14 +482,11 @@ statements and files before them left it:
 | `ALTER TABLE ... RENAME CONSTRAINT` | |
 
 A constraint an `ALTER TABLE` adds is not recorded, so it is not carried into
-the schema model the way a `CREATE TABLE` constraint is.
-
-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. An ignored `ALTER TABLE`
-action is the one exception: the statement still resolves its table, so
+the schema model the way a `CREATE TABLE` constraint is. Because the table is
+still resolved,
 `ALTER TABLE payments ADD CONSTRAINT payments_pkey PRIMARY KEY (id)` fails when
 `payments` is not modeled, exactly as any other `ALTER TABLE` of a missing
-table does. An ignored action may stand alone or beside modeled actions of one
+table does. Such an action may stand alone or beside modeled actions of one
 `ALTER TABLE`, so
 `ALTER TABLE users ADD COLUMN age INTEGER, ADD CONSTRAINT users_age_check CHECK (age > 0)`
 appends `age` and records nothing for the constraint.
@@ -452,14 +494,15 @@ 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` 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
+- 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`, is captured through the
-  end of the file, so such a function is rejected at the line it begins on and
-  nothing after it is applied.
+  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.
@@ -467,6 +510,18 @@ split or pre-process the SQL to work around them:
   error. The named `ADD CONSTRAINT name CHECK (...)` spelling is ignored as
   listed above.
 
+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.
+- `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).
+
 ## Nulls
 
 Every generated method parameter and every generated result component uses a
@@ -567,13 +622,15 @@ written by an earlier successful run is left unchanged. The writing step itself
 is sequential rather than atomic; see
 [Generated Output and Failures](configuration.md#generated-output-and-failures).
 
-A schema message names the schema source and the offending statement with the
-line it begins on, the table or column the statement refers to, or the syntax
-error with the line and column it was found at. A query message names the
-query, its source, its header line, and the offending column and recorded type:
+A schema message names the schema source and the offending statement or action
+in SQL terms with the line it begins on, the table or column the statement
+refers to, or the syntax error with the line and column it was found at. A query
+message names the query, its source, its header line, and the offending column
+and recorded type:
 
 ```text
-sqlcj: Invalid schema source /home/dev/project/schema.sql: Unsupported schema statement: CreateView at line 12
+sqlcj: Invalid schema source /home/dev/project/schema.sql: Unsupported schema statement: ALTER FOREIGN TABLE at line 12
+sqlcj: Invalid schema source /home/dev/project/schema.sql: Unsupported ALTER TABLE action at line 18
 sqlcj: Invalid schema source /home/dev/project/schema.sql: Encountered unexpected token: ";" at line 4, column 1
 sqlcj: Invalid query 'ListTags' in /home/dev/project/queries.sql at line 5: Column 'tags' has unsupported type JSONB[]
 ```
@@ -686,8 +743,12 @@ Enum types:
   `DefaultSchemaParserTest.shouldModelEnumArraysAndRecordUndeclaredTypesAsUnsupported`
   covers the modeled enum array beside the multidimensional enum array and the
   undeclared type that stay recorded.
-- `DefaultSchemaParserTest.shouldRejectStatementOutsideTheIgnoredList` covers
-  the rejected `ALTER TYPE` actions and the composite `CREATE TYPE`, and
+- `DefaultSchemaParserTest.shouldRejectUnsupportedStatementsInSqlTerms` covers
+  the rejected `ALTER TYPE` actions,
+  `DefaultSchemaParserTest.shouldIgnoreEveryStatementItDoesNotModel` and
+  `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`.
 - `QueryAnalyzerTest.shouldCarryTheEnumTypeOfASelectedColumnAndItsParameter`,
   `QueryAnalyzerTest.shouldCarryTheEnumTypeOfAReturningColumnAndItsParameter`,
@@ -766,20 +827,25 @@ Ordered table DDL:
 
 Ignored statements:
 
-- `DefaultSchemaParserTest.shouldIgnoreDocumentedStatements` covers one spelling
-  per listed statement, including the lower-case `ALTER INDEX` form and
-  `CREATE OR REPLACE FUNCTION ... $$ ... $$ LANGUAGE plpgsql`, and
+- `DefaultSchemaParserTest.shouldIgnoreEveryStatementItDoesNotModel` covers one
+  spelling per statement kind JSqlParser parses, including the lower-case
+  `ALTER INDEX` form, a dollar-quoted `CREATE OR REPLACE FUNCTION` and a
+  dollar-quoted `CREATE PROCEDURE`, the views, schemas, session, privilege,
+  role, policy, domain, and non-enum `CREATE TYPE` statements, and the opaque
+  `ALTER FUNCTION`, `ALTER SCHEMA`, `CREATE AGGREGATE`, and `CREATE CAST`; and
   `DefaultSchemaParserTest.shouldIgnoreConstraintAlterTableActions` covers the
   named and unnamed constraint actions.
 - `DefaultSchemaParserTest.shouldNotResolveAnIgnoredStatementAgainstTheSchema`
-  covers that an ignored statement may name an unmodeled table or column, and
+  covers that an ignored statement, including a view over an unmodeled table and
+  a `TRUNCATE` of one, may name an unmodeled table or column, and
   `DefaultSchemaParserTest.shouldReportTheMissingTableOfAnIgnoredConstraintAction`
   covers that an ignored `ALTER TABLE` action still resolves its table.
 - `DefaultSchemaParserTest.shouldApplyAModeledActionBesideAnIgnoredConstraintAction`
   covers an ignored action beside a modeled one.
-- `DefaultSchemaParserTest.shouldRejectStatementOutsideTheIgnoredList` covers the
-  kind and the line of each rejected statement, including the single-quoted
-  function body, and
+- `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
@@ -788,8 +854,9 @@ Ignored statements:
   covers that a single-quoted body is rejected at its own line even when it
   captures a later dollar-quoted body.
 - `SqlcjCompilerIntegrationTest.shouldReportTheMigrationFileAndLineOfAnUnsupportedStatement`
-  covers the migration file and line of a rejected statement that follows an
-  ignored one, and that no file is written.
+  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
+  is written.
 
 Nulls:
 
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 1d581d3..5aa0e08 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
@@ -14,6 +14,7 @@
 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;
@@ -21,42 +22,34 @@
 import net.sf.jsqlparser.statement.alter.AlterExpression;
 import net.sf.jsqlparser.statement.alter.AlterOperation;
 import net.sf.jsqlparser.statement.alter.AlterType;
-import net.sf.jsqlparser.statement.alter.sequence.AlterSequence;
-import net.sf.jsqlparser.statement.comment.Comment;
-import net.sf.jsqlparser.statement.create.extension.CreateExtension;
-import net.sf.jsqlparser.statement.create.function.CreateFunction;
-import net.sf.jsqlparser.statement.create.index.CreateIndex;
-import net.sf.jsqlparser.statement.create.sequence.CreateSequence;
 import net.sf.jsqlparser.statement.create.table.CheckConstraint;
 import net.sf.jsqlparser.statement.create.table.ColumnDefinition;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
 import net.sf.jsqlparser.statement.create.table.ForeignKeyIndex;
 import net.sf.jsqlparser.statement.create.table.Index;
-import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.statement.create.type.CreateType;
 import net.sf.jsqlparser.statement.create.type.EnumTypeDefinition;
-import net.sf.jsqlparser.statement.delete.Delete;
 import net.sf.jsqlparser.statement.drop.Drop;
-import net.sf.jsqlparser.statement.grant.Grant;
-import net.sf.jsqlparser.statement.grant.Revoke;
-import net.sf.jsqlparser.statement.insert.Insert;
-import net.sf.jsqlparser.statement.update.Update;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicReference;
-import java.util.regex.Pattern;
 
 public class DefaultSchemaParser implements SchemaParser {
 
     /**
-     * The opening words of an {@code ALTER INDEX} statement, which the parser
-     * reports only as an opaque unsupported statement.
+     * The words PostgreSQL allows between the verb and {@code TABLE} of a table
+     * statement.
      */
-    private static final Pattern ALTER_INDEX = Pattern.compile(
-        "^ALTER\\s+INDEX\\b",
-        Pattern.CASE_INSENSITIVE
+    private static final Set<String> TABLE_MODIFIERS = Set.of(
+        "GLOBAL",
+        "LOCAL",
+        "TEMP",
+        "TEMPORARY",
+        "UNLOGGED",
+        "FOREIGN"
     );
 
     /** Resolves the type a column declaration states. */
@@ -130,6 +123,15 @@ private int statementLine(List<Integer> lines, int index) {
     /**
      * Applies one statement to the tables and enum types the statements before
      * it left.
+     *
+     * <p>Only the statements sqlcj models are applied: {@code CREATE TABLE},
+     * {@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.
      */
     private void apply(Statement statement, int line, List<Table> tables, List<EnumType> enums) {
         if (statement instanceof CreateTable createTable) {
@@ -143,20 +145,84 @@ private void apply(Statement statement, int line, List<Table> tables, List<EnumT
                 && createType.getDefinition() instanceof EnumTypeDefinition definition
         ) {
             applyCreateEnumType(createType, definition, enums);
-        } else if (
-            statement instanceof AlterType alterType
-                && alterType.getAction() == AlterType.Action.ADD_VALUE
-        ) {
+        } else if (statement instanceof AlterType alterType) {
+            if (alterType.getAction() != AlterType.Action.ADD_VALUE) {
+                throw unsupportedAlterTypeAction(line);
+            }
+
             applyAddEnumValue(alterType, enums);
-        } else if (!isIgnored(statement)) {
-            throw unsupportedStatement(statement, line);
+        } 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
+     * anything else. The words are compared case-insensitively, as PostgreSQL
+     * reads them.
+     *
+     * <p>A table opening is {@code CREATE}, {@code ALTER}, or {@code DROP}, then
+     * any of PostgreSQL's table modifiers, then {@code TABLE}. A type opening is
+     * {@code CREATE} or {@code ALTER}, then {@code TYPE}. A statement sqlcj
+     * cannot read is ignored unless it opens this way, because such a statement
+     * may change the tables or the enum types the schema models.
+     */
+    private String tableOrTypeOpening(List<String> words) {
+        if (words.isEmpty()) {
+            return null;
+        }
+
+        String verb = upperCase(words.get(0));
+
+        if (!"CREATE".equals(verb) && !"ALTER".equals(verb) && !"DROP".equals(verb)) {
+            return null;
         }
+
+        if (!"DROP".equals(verb) && words.size() > 1 && "TYPE".equals(upperCase(words.get(1)))) {
+            return verb + " TYPE";
+        }
+
+        int index = 1;
+
+        while (index < words.size() && TABLE_MODIFIERS.contains(upperCase(words.get(index)))) {
+            index++;
+        }
+
+        if (index >= words.size() || !"TABLE".equals(upperCase(words.get(index)))) {
+            return null;
+        }
+
+        return String.join(
+            " ",
+            words.subList(0, index + 1).stream()
+                .map(this::upperCase)
+                .toList()
+        );
+    }
+
+    private String upperCase(String word) {
+        return word.toUpperCase(Locale.ROOT);
     }
 
     /**
      * Appends one enum type with its declared labels. A repeated type name
      * fails, as PostgreSQL rejects it, and so does a repeated label. An enum is
-     * the only type sqlcj models; every other {@code CREATE TYPE} is rejected.
+     * the only type sqlcj models; a {@code CREATE TYPE} of any other kind is
+     * ignored, and a column of such a type is recorded with its declared type.
      */
     private void applyCreateEnumType(
         CreateType createType,
@@ -243,59 +309,17 @@ private int labelPosition(AlterType alterType, EnumType enumType) {
     }
 
     /**
-     * Reports whether a statement is one of the documented statements a schema
-     * source may state without changing the schema model. Such a statement is
-     * not resolved against the schema at all.
-     */
-    private boolean isIgnored(Statement statement) {
-        if (statement instanceof Drop drop) {
-            return isIgnoredDropObject(drop);
-        }
-
-        if (statement instanceof CreateFunction createFunction) {
-            return hasDollarQuotedBody(createFunction);
-        }
-
-        if (statement instanceof UnsupportedStatement unsupported) {
-            return ALTER_INDEX.matcher(unsupported.toString()).find();
-        }
-
-        return statement instanceof CreateIndex
-            || statement instanceof Comment
-            || statement instanceof CreateExtension
-            || statement instanceof CreateSequence
-            || statement instanceof AlterSequence
-            || statement instanceof Grant
-            || statement instanceof Revoke
-            || statement instanceof CreateTrigger
-            || statement instanceof Insert
-            || statement instanceof Update
-            || statement instanceof Delete;
-    }
-
-    /**
-     * A dropped table is modeled and the listed dropped objects are ignored;
-     * any other dropped object, such as a view, is rejected.
-     */
-    private boolean isIgnoredDropObject(Drop drop) {
-        return switch (drop.getObjectType()) {
-            case INDEX, SEQUENCE, FUNCTION, TRIGGER -> true;
-            default -> false;
-        };
-    }
-
-    /**
-     * Reports whether a {@code CREATE FUNCTION} 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 is
-     * rejected instead of ignored.
+     * 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(CreateFunction createFunction) {
-        List<String> parts = createFunction.getFunctionDeclarationParts();
+    private boolean hasDollarQuotedBody(CreateFunctionalStatement functional) {
+        List<String> parts = functional.getFunctionDeclarationParts();
 
         return parts != null
             && parts.stream()
@@ -363,7 +387,7 @@ private void applyAlterTable(Alter alter, int line, List<EnumType> enums, List<T
         }
 
         for (AlterExpression expression : alter.getAlterExpressions()) {
-            tables.set(index, applyAlterExpression(alter, line, expression, enums, tables, index));
+            tables.set(index, applyAlterExpression(line, expression, enums, tables, index));
         }
     }
 
@@ -371,10 +395,9 @@ private void applyAlterTable(Alter alter, int line, List<EnumType> enums, List<T
      * Applies one {@code ALTER TABLE} action and returns the altered table. A
      * constraint action is accepted and leaves the table unchanged; an action
      * that cannot be recognized as one of those forms, such as
-     * {@code SET DEFAULT}, is rejected like any other unsupported statement.
+     * {@code SET DEFAULT}, is rejected naming the statement it belongs to.
      */
     private Table applyAlterExpression(
-        Alter alter,
         int line,
         AlterExpression expression,
         List<EnumType> enums,
@@ -401,14 +424,14 @@ private Table applyAlterExpression(
         }
 
         if (operation == AlterOperation.ALTER) {
-            return alterColumns(alter, line, expression, enums, table);
+            return alterColumns(line, expression, enums, table);
         }
 
         if (isIgnoredConstraintAction(expression)) {
             return table;
         }
 
-        throw unsupportedStatement(alter, line);
+        throw unsupportedAlterTableAction(line);
     }
 
     /**
@@ -450,7 +473,6 @@ private boolean isIgnoredConstraintKind(Index index) {
      * column's position and nullability, or a nullability change.
      */
     private Table alterColumns(
-        Alter alter,
         int line,
         AlterExpression expression,
         List<EnumType> enums,
@@ -458,7 +480,7 @@ private Table alterColumns(
     ) {
         if (isNotEmpty(expression.getColDataTypeList())) {
             if (!statesNewTypes(expression.getColDataTypeList())) {
-                throw unsupportedStatement(alter, line);
+                throw unsupportedAlterTableAction(line);
             }
 
             return changeColumnTypes(expression, enums, table);
@@ -484,7 +506,7 @@ private Table alterColumns(
             );
         }
 
-        throw unsupportedStatement(alter, line);
+        throw unsupportedAlterTableAction(line);
     }
 
     /**
@@ -782,10 +804,31 @@ private IllegalArgumentException labelAlreadyExists(String typeName, String labe
         );
     }
 
-    private UnsupportedOperationException unsupportedStatement(Statement statement, int line) {
+    private UnsupportedOperationException unsupportedAlterTableAction(int line) {
+        return new UnsupportedOperationException(
+            "Unsupported ALTER TABLE action at line %d".formatted(line)
+        );
+    }
+
+    private UnsupportedOperationException unsupportedAlterTypeAction(int line) {
+        return new UnsupportedOperationException(
+            "Unsupported ALTER TYPE action at line %d".formatted(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(statement.getClass().getSimpleName(), line)
+            "Unsupported schema statement: %s at line %d".formatted(opening, line)
         );
     }
 
diff --git a/sqlcj-cli/src/test/java/dev/sqlcj/compiler/SqlcjCompilerIntegrationTest.java b/sqlcj-cli/src/test/java/dev/sqlcj/compiler/SqlcjCompilerIntegrationTest.java
index f738d59..6d68948 100644
--- a/sqlcj-cli/src/test/java/dev/sqlcj/compiler/SqlcjCompilerIntegrationTest.java
+++ b/sqlcj-cli/src/test/java/dev/sqlcj/compiler/SqlcjCompilerIntegrationTest.java
@@ -2966,6 +2966,8 @@ void shouldReportTheMigrationFileAndLineOfAnUnsupportedStatement() throws IOExce
                 CREATE VIEW active_users AS
                 SELECT id
                 FROM users;
+
+                ALTER FOREIGN TABLE users ADD COLUMN name TEXT;
                 """
         );
 
@@ -2993,7 +2995,7 @@ void shouldReportTheMigrationFileAndLineOfAnUnsupportedStatement() throws IOExce
 
         assertEquals(
             "Invalid schema source %s: ".formatted(unsupported)
-                + "Unsupported schema statement: CreateView at line 3",
+                + "Unsupported schema statement: ALTER FOREIGN TABLE at line 7",
             exception.getMessage()
         );
 
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 f09c37a..f5e934e 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
@@ -786,7 +786,7 @@ CREATE TABLE users (
                 id BIGINT NOT NULL
             );
 
-            CREATE VIEW active_users AS SELECT id FROM users;
+            ALTER FOREIGN TABLE users ADD COLUMN name TEXT;
             """;
 
         UnsupportedOperationException exception = assertThrows(
@@ -795,7 +795,7 @@ CREATE TABLE users (
         );
 
         assertEquals(
-            "Unsupported schema statement: CreateView at line 5",
+            "Unsupported schema statement: ALTER FOREIGN TABLE at line 5",
             exception.getMessage()
         );
     }
@@ -814,7 +814,7 @@ void shouldRejectUnsupportedAlterTableAction() {
         );
 
         assertEquals(
-            "Unsupported schema statement: Alter at line 1",
+            "Unsupported ALTER TABLE action at line 1",
             exception.getMessage()
         );
     }
@@ -833,7 +833,7 @@ void shouldRejectAlterColumnSetStatistics() {
         );
 
         assertEquals(
-            "Unsupported schema statement: Alter at line 1",
+            "Unsupported ALTER TABLE action at line 1",
             exception.getMessage()
         );
     }
@@ -855,14 +855,14 @@ void shouldRejectAlterColumnAddIdentity() {
         );
 
         assertEquals(
-            "Unsupported schema statement: Alter at line 1",
+            "Unsupported ALTER TABLE action at line 1",
             exception.getMessage()
         );
     }
 
     /**
-     * Every statement of the documented ignored list is accepted and leaves the
-     * schema the statements before it left.
+     * Every statement outside the forms sqlcj models is accepted and leaves the
+     * schema the statements before it left, whatever object it states.
      */
     @ParameterizedTest
     @ValueSource(
@@ -892,11 +892,45 @@ void shouldRejectAlterColumnAddIdentity() {
             "DROP TRIGGER users_touch ON users;",
             "INSERT INTO users (id) VALUES (1);",
             "UPDATE users SET name = 'new';",
-            "DELETE FROM users;"
+            "DELETE FROM users;",
+            "CREATE VIEW active_users AS SELECT id FROM users;",
+            "CREATE OR REPLACE VIEW active_users AS SELECT id FROM users;",
+            "DROP VIEW active_users;",
+            "CREATE MATERIALIZED VIEW active_users AS SELECT id FROM users;",
+            "REFRESH MATERIALIZED VIEW active_users;",
+            "DROP MATERIALIZED VIEW active_users;",
+            "CREATE SCHEMA app;",
+            "DROP SCHEMA app;",
+            "SET statement_timeout = 0;",
+            "SET search_path = public;",
+            "RESET ALL;",
+            "TRUNCATE users;",
+            "CREATE POLICY users_owner ON users USING (true);",
+            "CREATE ROLE readonly;",
+            "CREATE USER reader;",
+            "ALTER ROLE readonly NOLOGIN;",
+            "ALTER DEFAULT PRIVILEGES GRANT SELECT ON TABLES TO readonly;",
+            "CREATE DOMAIN positive AS INTEGER CHECK (VALUE > 0);",
+            "ALTER DOMAIN positive DROP NOT NULL;",
+            "CREATE TYPE address AS (street TEXT, city TEXT);",
+            "CREATE TYPE bounds AS RANGE (subtype = numeric);",
+            "CREATE TYPE opaque_state;",
+            "SELECT pg_catalog.set_config('search_path', '', false);",
+            "CREATE PROCEDURE touch() AS $$ BEGIN END; $$ LANGUAGE plpgsql;",
+            "ANALYZE users;",
+            "COMMIT;",
+            "ALTER FUNCTION touch() RENAME TO touched;",
+            "ALTER SCHEMA app RENAME TO archive;",
+            "CREATE AGGREGATE total (INTEGER) (sfunc = add, stype = INTEGER);",
+            "CREATE CAST (INTEGER AS TEXT) WITH FUNCTION render(INTEGER);"
         }
     )
-    void shouldIgnoreDocumentedStatements(String statement) {
-        assertEquals(parser.parse(BASE_SCHEMA).tables(), applied(statement).tables());
+    void shouldIgnoreEveryStatementItDoesNotModel(String statement) {
+        Schema base = parser.parse(BASE_SCHEMA);
+        Schema schema = applied(statement);
+
+        assertEquals(base.tables(), schema.tables());
+        assertEquals(base.enums(), schema.enums());
     }
 
     /**
@@ -909,11 +943,40 @@ void shouldNotResolveAnIgnoredStatementAgainstTheSchema() {
             CREATE INDEX payments_total_idx ON payments (total);
             COMMENT ON COLUMN users.nickname IS 'the nickname';
             INSERT INTO payments (total) VALUES (1);
+            CREATE VIEW payment_totals AS SELECT total FROM payments;
+            TRUNCATE payments;
             """);
 
         assertEquals(parser.parse(BASE_SCHEMA).tables(), schema.tables());
     }
 
+    /**
+     * 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
+     * declared type, like a column of any type sqlcj cannot map.
+     */
+    @Test
+    void shouldRecordAColumnOfAnIgnoredCompositeType() {
+        Schema schema = parser.parse("""
+            CREATE TYPE address AS (street TEXT, city TEXT);
+
+            CREATE TABLE places (
+                id       BIGINT NOT NULL,
+                location address
+            );
+            """);
+
+        assertTrue(schema.enums().isEmpty());
+
+        assertEquals(
+            List.of(
+                new Column("id", ColumnType.BIGINT, false),
+                new Column("location", null, true, "ADDRESS")
+            ),
+            table(schema, "places").columns()
+        );
+    }
+
     /**
      * An {@code ALTER TABLE} action that states a constraint is accepted and
      * leaves the table unchanged, named or unnamed.
@@ -980,28 +1043,32 @@ void shouldApplyAModeledActionBesideAnIgnoredConstraintAction() {
     }
 
     /**
-     * A statement outside the ignored list is rejected naming its kind and the
-     * line it begins on.
+     * A statement sqlcj rejects is reported in SQL terms, naming the statement
+     * or the action and the line it begins on, never a parser class.
      */
     @ParameterizedTest
     @CsvSource(
         delimiter = '|',
         quoteCharacter = '"',
         value = {
-            "CREATE VIEW active_users AS SELECT id FROM users;|CreateView",
-            "CREATE TYPE address AS (street TEXT, city TEXT);|CreateType",
-            "ALTER TYPE status RENAME TO state;|AlterType",
-            "ALTER TYPE status RENAME VALUE 'draft' TO 'new';|AlterType",
-            "CREATE DOMAIN positive AS INTEGER CHECK (VALUE > 0);|CreateDomain",
-            "CREATE SCHEMA app;|CreateSchema",
-            "DROP VIEW active_users;|Drop",
-            "SELECT id FROM users;|PlainSelect",
-            "ALTER TABLE users ALTER COLUMN name SET DEFAULT 'new';|Alter",
-            "CREATE FUNCTION one() RETURNS integer AS 'SELECT 1' LANGUAGE sql;|CreateFunction",
-            "ALTER FUNCTION touch() RENAME TO touched;|UnsupportedStatement"
+            "ALTER TABLE users ALTER COLUMN name SET DEFAULT 'new';"
+                + "|Unsupported ALTER TABLE action at line 1",
+            "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;"
+                + "|Unsupported schema statement: ALTER FOREIGN TABLE at line 1"
         }
     )
-    void shouldRejectStatementOutsideTheIgnoredList(String statement, String kind) {
+    void shouldRejectUnsupportedStatementsInSqlTerms(String statement, String message) {
         Schema schema = parser.parse(BASE_SCHEMA);
 
         UnsupportedOperationException exception = assertThrows(
@@ -1009,10 +1076,7 @@ void shouldRejectStatementOutsideTheIgnoredList(String statement, String kind) {
             () -> parser.parse(schema, statement)
         );
 
-        assertEquals(
-            "Unsupported schema statement: %s at line 1".formatted(kind),
-            exception.getMessage()
-        );
+        assertEquals(message, exception.getMessage());
     }
 
     /**
@@ -1036,7 +1100,7 @@ void shouldRejectASingleQuotedFunctionBodyThatCapturesALaterDollarQuotedBody() {
         );
 
         assertEquals(
-            "Unsupported schema statement: CreateFunction at line 2",
+            "Unsupported schema statement: CREATE FUNCTION without a dollar-quoted body at line 2",
             exception.getMessage()
         );
     }
@@ -1063,7 +1127,7 @@ CREATE OR REPLACE FUNCTION touch() RETURNS trigger AS $$
             $$ LANGUAGE plpgsql;
 
             -- another ; separator
-            CREATE VIEW active_tags AS SELECT id FROM tags;
+            ALTER FOREIGN TABLE tags ADD COLUMN label TEXT;
             """;
 
         UnsupportedOperationException exception = assertThrows(
@@ -1072,7 +1136,7 @@ CREATE OR REPLACE FUNCTION touch() RETURNS trigger AS $$
         );
 
         assertEquals(
-            "Unsupported schema statement: CreateView at line 15",
+            "Unsupported schema statement: ALTER FOREIGN TABLE at line 15",
             exception.getMessage()
         );
     }