diff --git a/docs/postgresql.md b/docs/postgresql.md
index 6fdd73a..4b5e7e7 100644
--- a/docs/postgresql.md
+++ b/docs/postgresql.md
@@ -108,6 +108,17 @@ order the files are read in.
 - SQL identifier delimiters are removed for the parsed model, so the table
   `"user data"` is modeled as `user data` and the column `"user id"` is modeled
   as `user id`.
+- sqlcj models one namespace, so an unqualified and a `public`-qualified name
+  are the same name: `users`, `public.users`, and `"public"."users"` are one
+  table, and `mood`, `public.mood`, and `"public"."mood"` are one type. A schema
+  qualifier is compared without its SQL identifier delimiters and
+  case-insensitively, as every other name is.
+- A table or a type qualified with any other schema is invisible: sqlcj never
+  models it, every statement whose own table or type stands there is ignored
+  before anything it names is resolved, and a query that names such a table is
+  rejected as an unknown table. `search_path` is not followed, so an
+  unqualified name always belongs to the one namespace sqlcj models, whatever a
+  `SET search_path` statement in the snapshot says.
 
 ## Supported Column Types
 
@@ -137,7 +148,7 @@ accepted and map exactly like their unparameterized spellings.
 | `BYTEA` | `byte[]` | A record compares an array component by reference, so two row records holding equal bytes are not `equals`. |
 | `JSON` | `String` | The JSON text itself. PostgreSQL stores it as written, so it reads back exactly as written. sqlcj never parses, validates, or normalizes it. |
 | `JSONB` | `String` | The JSON text itself. PostgreSQL stores a decomposed value, so the text reads back as PostgreSQL renders it rather than as written, and `=` compares by value. sqlcj never parses, validates, or normalizes it. |
-| The name of an enum type the schema declares | The generated Java enum of that type | Matched without SQL identifier delimiters and case-insensitively, as PostgreSQL resolves an unquoted type name. See [Enum Types](#enum-types). |
+| The name of an enum type the schema declares | The generated Java enum of that type | Matched without SQL identifier delimiters and case-insensitively, as PostgreSQL resolves an unquoted type name. A `public`-qualified name resolves as its unqualified name, so `public.mood` and `"public"."mood"` are the type `mood`, and a name qualified with any other schema never resolves. See [Enum Types](#enum-types). |
 | A one-dimensional array of any spelling above except `BYTEA`, `JSON`, and `JSONB`, written `type[]` or `type[n]` | `java.util.List<T>` of the element's Java type | The declared size is ignored, as PostgreSQL ignores it. See [Array Types](#array-types). |
 
 Any spelling that is not listed above has no Java mapping. Such a column is
@@ -252,23 +263,29 @@ left:
 | `ALTER TYPE ... RENAME VALUE '<label>' TO '<new label>'` | Renames the label in its position, so the modeled labels keep PostgreSQL's sort order. |
 | A `CREATE TYPE ... AS ENUM (...)` or an `ALTER TYPE ... RENAME TO` whose name a modeled enum already has | Replaces that enum in its position with the newly declared or renamed one, because the `DROP TYPE ... CASCADE` that freed the name is never seen. This is how the migration that replaces an enum loads, in either of its usual shapes: renaming the old type away before declaring the new one under its name, or declaring the new type beside it and renaming the new type onto its name once the columns are retyped. A column that still names a replaced enum keeps that name, so it is modeled as a column of the replacing enum with its labels, which is the same unseen `DROP TYPE ... CASCADE` case: PostgreSQL would have removed the column. |
 | `ALTER TYPE ... OWNER TO`, `RENAME ATTRIBUTE`, `ADD ATTRIBUTE`, `DROP ATTRIBUTE`, and `ALTER ATTRIBUTE` | Ignored. Ownership cannot change a modeled enum and the attribute actions belong to a composite type, so the stated type is not resolved at all. |
-| `ALTER TYPE ... SET SCHEMA <schema>` | Rejected for a modeled enum as `Unsupported ALTER TYPE action: SET SCHEMA <schema> at line <n>`, because the columns of that type would keep it in a namespace sqlcj does not model. Ignored for a type sqlcj does not model. |
-| `ALTER TYPE ... RENAME TO` of a type sqlcj does not model | Ignored, because such a type is none of its enum types. |
+| `ALTER TYPE ... SET SCHEMA <schema>` | Rejected for a modeled enum as `Unsupported ALTER TYPE action: SET SCHEMA <schema> at line <n>`, because the columns of that type would keep it in a namespace sqlcj does not model. |
+| `ALTER TYPE ... SET SCHEMA public` | Does nothing for a modeled enum: the type already stands in the one namespace sqlcj models. |
+| `ALTER TYPE ... RENAME TO` or `SET SCHEMA` of a type sqlcj does not model | Ignored, however the type is qualified, because such a type is none of its enum types. |
+| A `CREATE TYPE` or an `ALTER TYPE` whose own type is qualified with a schema other than `public` | Ignored before anything it states is resolved, so it never touches the modeled enum of the same unqualified name and neither a repeated label nor a missing label or neighbour fails. |
 | `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` | 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). |
 
 An `ALTER TYPE` written in a form sqlcj's parser cannot read, such as a
 qualified `RENAME TO` target, several actions joined by commas, or
-`SET (...)`, is rejected as unreadable type DDL; see
+`SET (...)`, is rejected as unreadable type DDL, unless its own type is
+qualified with a schema other than `public`, which is ignored; see
 [Ignored Statements](#ignored-statements).
 
 Type names are matched case-insensitively, after their SQL identifier
-delimiters are removed, and labels are matched exactly. A type name is the
-statement's own name, so `public.stage_setting` and `stage_setting` are
-different names: a `RENAME TO` or `SET SCHEMA` of a qualified name that matches
-no modeled enum fails as a missing type rather than being ignored, because it
-may state one. A statement that repeats a label, or that refers to a type or a
-label that is not modeled, is rejected as PostgreSQL rejects it:
+delimiters are removed, and labels are matched exactly. Because sqlcj models one
+namespace, a type name resolves by its unqualified name, so
+`CREATE TYPE public.stage_setting` and `CREATE TYPE "public"."stage_setting"`
+declare the type `stage_setting` and replace a modeled `stage_setting` rather
+than adding a second enum, and `ADD VALUE`, `RENAME VALUE`, and `RENAME TO`
+written through `public.stage_setting` act on that one type and name it
+unqualified in their diagnostics. A statement that repeats a label, or that
+refers to a type or a label that is not modeled, is rejected as PostgreSQL
+rejects it:
 
 ```text
 sqlcj: Invalid schema source /home/dev/project/sql/migrations/V2__stages.sql: Type not found in schema: stage_setting
@@ -409,9 +426,12 @@ as `Table not found in schema: <t>`.
 
 Because sqlcj models one namespace, a `LIKE` or `PARTITION OF` source and an
 `ATTACH` or `DETACH PARTITION` partition resolve by their unqualified name, so
-`public.t` is `t`. Until sqlcj models namespaces, such a name qualified with any
-other schema names a table sqlcj leaves unmodeled and fails as
-`Table not found in schema: <schema>.<t>` rather than resolving to a modeled `t`.
+`public.t` is `t`. Such a name qualified with any other schema names a table
+sqlcj leaves unmodeled rather than a modeled `t`: a `LIKE` or `PARTITION OF`
+source fails as `Table not found in schema: <schema>.<t>`, because the created
+table's columns would otherwise be unknown, and an `ATTACH` or
+`DETACH PARTITION` partition is ignored, like any other partition sqlcj does not
+model.
 
 A `CREATE TABLE` with neither an element list, `()`, nor `PARTITION OF`, such as
 `CREATE TABLE c LIKE t` without the parentheses PostgreSQL requires, states no
@@ -433,7 +453,7 @@ statements and files before them left; the enum-type statements are listed in
 | --- | --- |
 | `CREATE TABLE` | Adds the table after the tables already modeled. |
 | `CREATE TABLE IF NOT EXISTS` | Does nothing when the table already exists. |
-| `DROP TABLE`, with one or several names | Removes each named table and, recursively, every partition of it, as PostgreSQL does. |
+| `DROP TABLE`, with one or several names | Removes each named table and, recursively, every partition of it, as PostgreSQL does. A name qualified with a schema other than `public` names a table sqlcj leaves unmodeled and is skipped without failing, because the statement may name a modeled table beside it. |
 | `DROP TABLE IF EXISTS` | Does nothing for a name that is not modeled. |
 | `ALTER TABLE ... ADD COLUMN` | Appends the column, typed exactly as a `CREATE TABLE` column of the same declaration, and records its column-level `PRIMARY KEY` or `UNIQUE`. |
 | `ALTER TABLE ... ADD COLUMN IF NOT EXISTS` | Does nothing when the column already exists. |
@@ -447,7 +467,9 @@ 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 the ignored actions listed in [Ignored Statements](#ignored-statements), such as `SET SCHEMA` | Rejected as `Unsupported ALTER TABLE action: <action> at line <n>`, quoting the action's own SQL. |
+| `ALTER TABLE ... SET SCHEMA <schema>`, as the statement's sole action, which is the only form PostgreSQL accepts | Removes the table, keeping the order of the remaining ones, because it moves out of the one namespace sqlcj models. `SET SCHEMA public` does nothing: the table already stands there. A table with modeled partitions is rejected as `Unsupported ALTER TABLE action: SET SCHEMA <schema> at line <n>`, because its partitions would stay in the modeled namespace following a parent sqlcj no longer models. |
+| A `CREATE TABLE` or an `ALTER TABLE` whose own table is qualified with a schema other than `public` | Ignored before anything it names is resolved, so neither its rejected clauses, its rejected actions, nor its `LIKE` and `PARTITION OF` sources are resolved and a modeled table of the same unqualified name is left alone. |
+| Any other `ALTER TABLE` action outside the ignored actions listed in [Ignored Statements](#ignored-statements) | Rejected as `Unsupported ALTER TABLE action: <action> at line <n>`, quoting the action's own SQL. |
 | `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
@@ -509,7 +531,10 @@ Everything else a migration history holds is ignored, including
   `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 `CREATE TYPE` of a composite, range, or shell type, and `DROP TYPE`,
+- a `CREATE TABLE`, `ALTER TABLE`, `CREATE TYPE`, or `ALTER TYPE` whose own
+  table or type is qualified with a schema other than `public`, readable or not,
+  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`.
@@ -525,8 +550,8 @@ what they would do to the schema model:
 | --- | --- |
 | An `ALTER TABLE` action outside [Ordered Table DDL](#ordered-table-ddl) and the ignored actions below | `Unsupported ALTER TABLE action: <action> at line <n>`, quoting the action's own SQL |
 | A `CREATE TABLE ... AS SELECT`, `OF <type>`, or `INHERITS`, whose columns sqlcj cannot determine | `Unsupported CREATE TABLE clause: <clause> at line <n>`, naming `AS SELECT`, `OF <type>`, or `INHERITS` |
-| An `ALTER TYPE ... SET SCHEMA` of a modeled enum type | `Unsupported ALTER TYPE action: SET SCHEMA <schema> at line <n>` |
-| 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` |
+| An `ALTER TYPE ... SET SCHEMA <other schema>` of a modeled enum type | `Unsupported ALTER TYPE action: SET SCHEMA <schema> at line <n>` |
+| A statement sqlcj's parser cannot read that opens as table or type DDL, outside the `ALTER TABLE` actions below and the names of another schema 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
@@ -537,6 +562,16 @@ 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>`.
 
+An unreadable statement that opens as `CREATE` or `ALTER TABLE` or as `CREATE`
+or `ALTER TYPE` is ignored instead when the object it names stands in a schema
+sqlcj does not model, decided from its words alone: the qualifier before the
+dot of the name that follows the opening words, an optional `IF [NOT] EXISTS`,
+and an optional `ONLY`. An unreadable
+`ALTER TABLE reporting.users ALTER COLUMN x SET DATA TYPE int` is therefore
+ignored, while the same statement about `users` or `public.users` stays rejected
+with the parser's reason. An unreadable `DROP TABLE` keeps its handling, because
+another of its names may be modeled.
+
 Every `ALTER TABLE` action that cannot change a column's existence, name, type,
 or nullability is ignored like any other unmodeled statement, except that the
 statement still resolves its table:
@@ -584,10 +619,13 @@ sqlcj's parser has no form of its own for the table-level actions listed from
 `OWNER TO` down in the table above. It reports such an action as the text that
 runs to the end of the statement, so sqlcj splits that text at the commas
 outside parentheses, with its own SQL lexer, and every action in it must be one
-of those. `ALTER TABLE users SET SCHEMA archive` is therefore rejected as
-`Unsupported ALTER TABLE action: SET SCHEMA archive at line <n>`, because it
-moves the table out of the one namespace sqlcj models, and a modeled action
-written after such an action is rejected rather than skipped, so
+of those. `SET SCHEMA` is not among them: written as the statement's sole
+action, the only form PostgreSQL accepts, it is applied as
+[Ordered Table DDL](#ordered-table-ddl) states, and written beside another
+action, as in `ALTER TABLE users ADD COLUMN x int, SET SCHEMA archive` or
+`ALTER TABLE users SET SCHEMA archive, OWNER TO app`, it is rejected as
+`Unsupported ALTER TABLE action: SET SCHEMA archive at line <n>`. A modeled
+action written after an ignored action is rejected rather than skipped, so
 `ALTER TABLE users OWNER TO app, ADD COLUMN x int` is rejected as
 `Unsupported ALTER TABLE action: ADD COLUMN x int at line <n>`. Written the
 other way round, `ALTER TABLE users ADD COLUMN x int, OWNER TO app` appends `x`.
@@ -611,7 +649,8 @@ 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.
+written beside it, stays rejected with the parser's reason, unless its table
+stands in a schema sqlcj does not model.
 
 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
@@ -872,6 +911,23 @@ Enum types:
   composite type leaves recorded, and
   `DefaultSchemaParserTest.shouldIgnoreDropTypeAndKeepTheModeledEnum` covers the
   ignored `DROP TYPE` and the enum and enum column that survive it.
+- `DefaultSchemaParserTest.shouldModelAPublicQualifiedTypeNameAsItsUnqualifiedName`
+  covers the unqualified, `public`-qualified, quoted, and upper-case qualifier
+  forms of a `CREATE TYPE` that replaces a modeled enum and of `ADD VALUE`,
+  `RENAME VALUE`, and `RENAME TO`;
+  `DefaultSchemaParserTest.shouldIgnoreATypeStatementOfAnotherSchema` covers
+  every `CREATE TYPE` and `ALTER TYPE` of another schema that is ignored,
+  including the repeated label and the missing neighbour that are never
+  resolved; and
+  `DefaultSchemaParserTest.shouldIgnoreSetSchemaPublicOfAModeledEnum` covers
+  `SET SCHEMA public` of a modeled enum.
+- `DefaultSchemaParserTest.shouldModelPublicQualifiedEnumColumnTypes` covers the
+  `public`-qualified enum column and enum array, quoted and unquoted, through
+  `CREATE TABLE`, `ADD COLUMN`, and `ALTER COLUMN ... TYPE`, beside the
+  multidimensional and other-schema types that stay recorded, and
+  `QueryAnalyzerTest.shouldResolveAPublicQualifiedEnumCastType` covers the
+  `public`-qualified enum array cast and the rejected cast type of another
+  schema.
 - `QueryAnalyzerTest.shouldCarryTheEnumTypeOfASelectedColumnAndItsParameter`,
   `QueryAnalyzerTest.shouldCarryTheEnumTypeOfAReturningColumnAndItsParameter`,
   `QueryAnalyzerTest.shouldAcceptARepeatedIndexOfOneEnumType`, and
@@ -926,8 +982,10 @@ Enum types:
   `DefaultSchemaParserTest.shouldRejectTheCreateTableClausesWhoseColumnsItCannotDetermine`,
   and `DefaultSchemaParserTest.shouldRejectASourceOrPartitionOfAnotherSchema`
   cover the repeated column name, the missing source, each rejected clause at
-  the line of its own statement, and the interim rule for a source and a
-  partition qualified with another schema.
+  the line of its own statement, and the `LIKE` and `PARTITION OF` source
+  qualified with another schema; and
+  `DefaultSchemaParserTest.shouldIgnoreAPartitionOfAnotherSchema` covers the
+  `ATTACH` and `DETACH PARTITION` partition qualified that way.
 - `SqlcjCompilerIntegrationTest.shouldGenerateCompilableRepositoriesOverCopiedTableColumns`
   generates and compiles `SELECT *` row records and a repository over a `LIKE`
   table and a `PARTITION OF` table.
@@ -975,6 +1033,21 @@ Ordered table DDL:
   `DefaultSchemaParserTest.shouldReportAStatementThatRepeatsAColumnName`, and
   `DefaultSchemaParserTest.shouldReportTheLineOfARejectedAlterTableAction`
   cover the rejected statements and their messages.
+- `DefaultSchemaParserTest.shouldModelAPublicQualifiedTableNameAsItsUnqualifiedName`
+  covers the unqualified, `public`-qualified, quoted, and upper-case qualifier
+  forms of one `CREATE TABLE`, `ALTER TABLE`, and `DROP TABLE`;
+  `DefaultSchemaParserTest.shouldIgnoreAStatementAboutATableOfAnotherSchema`
+  covers every ignored statement of another schema, including the clauses,
+  actions, and sources it never resolves; and
+  `DefaultSchemaParserTest.shouldSkipTheDroppedNamesOfAnotherSchema` covers the
+  `DROP TABLE` that carries on past such a name.
+- `DefaultSchemaParserTest.shouldIgnoreSetSchemaPublicOfAModeledTable`,
+  `DefaultSchemaParserTest.shouldRemoveATableMovedToAnotherSchema`, and
+  `DefaultSchemaParserTest.shouldRejectSetSchemaOfATableWithModeledPartitions`
+  cover the `SET SCHEMA` no-op, the removed table, and the rejected action and
+  its line for a table with modeled partitions, and
+  `DefaultSchemaParserTest.shouldRejectUnsupportedStatementsInSqlTerms` covers
+  `SET SCHEMA` written beside another action.
 - `SqlcjCompilerIntegrationTest.shouldGenerateTheSameRepositoryFromAlteringMigrationsAndASnapshot`
   generates one compilable repository from migrations that rename, add, drop, and
   alter columns, byte-identical to the one generated from the equivalent
@@ -1024,11 +1097,18 @@ Ignored statements:
   `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.shouldIgnoreAnUnreadableStatementQualifiedWithAnotherSchema`
+  covers the ignored unreadable `CREATE` and `ALTER TABLE` and `CREATE` and
+  `ALTER TYPE` of another schema, including the `ONLY` and `IF [NOT] EXISTS`
+  spellings, and
+  `DefaultSchemaParserTest.shouldRejectAnUnreadableStatementOfTheModeledSchema`
+  covers the same statements still rejected unqualified and
+  `public`-qualified.
 - `DefaultSchemaParserTest.shouldRejectUnsupportedStatementsInSqlTerms` covers
   the exact message and line of each statement and action rejected in SQL terms,
-  including `SET SCHEMA` alone and after a modeled action, a modeled action
-  written after an ignored one, an unrecognized `ALTER COLUMN` action, and the
-  upper- and lower-case `ALTER FOREIGN TABLE`, and
+  including `SET SCHEMA` after a modeled action, a modeled action written after
+  an ignored one, an unrecognized `ALTER COLUMN` action, and the upper- and
+  lower-case `ALTER FOREIGN TABLE`, and
   `DefaultSchemaParserTest.shouldRejectUnsupportedSchemaStatement`,
   `DefaultSchemaParserTest.shouldReportTheLineOfARejectedStatementAfterCommentsAndAFunctionBody`,
   and
diff --git a/docs/queries.md b/docs/queries.md
index e9a33bb..815c064 100644
--- a/docs/queries.md
+++ b/docs/queries.md
@@ -78,6 +78,14 @@ configuration entry.
 ### Sources
 
 - The `FROM` item must be a table of that schema, optionally with an alias.
+- sqlcj models one namespace, so a source resolves by its unqualified name:
+  `users`, `public.users`, and `"public"."users"` are one table, matched without
+  SQL identifier delimiters and case-insensitively. A source qualified with any
+  other schema names a table sqlcj leaves unmodeled and is rejected as
+  `Table not found in schema: <schema>.<t>`, in a `FROM`, a `JOIN`, and the
+  target of an `INSERT`, an `UPDATE`, and a `DELETE` alike. `search_path` is
+  not followed; see
+  [Schema Snapshot Input](postgresql.md#schema-snapshot-input).
 - A table may be joined with `JOIN`, `INNER JOIN`, `LEFT JOIN`, or
   `LEFT OUTER JOIN`, and inner and left joins may be chained in any order. A
   comma-separated source list and every other join modifier — `RIGHT`, `FULL`, a
@@ -900,6 +908,11 @@ Reads:
   `QueryAnalyzerTest.shouldResolveQueryParametersInsideNestedAndOrExpressions`,
   and `QueryAnalyzerTest.shouldResolveQueryParametersInsideInExpression` cover
   the accepted read shapes.
+- `QueryAnalyzerTest.shouldResolveAPublicQualifiedSource` covers the
+  unqualified, `public`-qualified, quoted, and upper-case qualifier forms of one
+  source, and `QueryAnalyzerTest.shouldRejectASourceOfAnotherSchema` covers the
+  rejected message of a source of another schema in a `FROM`, an `INNER` and a
+  `LEFT JOIN`, and an `INSERT`, an `UPDATE`, and a `DELETE` target.
 - `SqlcjCompilerIntegrationTest.shouldExecuteGeneratedAliasedQualifiedQuery`,
   `SqlcjCompilerIntegrationTest.shouldExecuteGeneratedJoinQueryWithDuplicateColumnNames`,
   `SqlcjCompilerIntegrationTest.shouldExecuteGeneratedJoinQueryWithProjectionAliases`,
diff --git a/sqlcj-cli/src/main/java/dev/sqlcj/analysis/QueryAnalyzer.java b/sqlcj-cli/src/main/java/dev/sqlcj/analysis/QueryAnalyzer.java
index 64f6c44..f07081d 100644
--- a/sqlcj-cli/src/main/java/dev/sqlcj/analysis/QueryAnalyzer.java
+++ b/sqlcj-cli/src/main/java/dev/sqlcj/analysis/QueryAnalyzer.java
@@ -5,6 +5,7 @@
 import dev.sqlcj.schema.ColumnType;
 import dev.sqlcj.schema.Schema;
 import dev.sqlcj.schema.parser.ColumnTypeMapping;
+import dev.sqlcj.schema.parser.SchemaNamespace;
 import dev.sqlcj.sql.ParsedSql;
 import dev.sqlcj.type.DefaultTypeResolver;
 import dev.sqlcj.type.TypeResolver;
@@ -1017,11 +1018,27 @@ private Source toSource(Table table, Schema schema, boolean leftJoined) {
             table.getAlias() == null
                 ? table.getUnquotedName()
                 : table.getAlias().getUnquotedName(),
-            findTable(schema, table.getUnquotedName()),
+            findSourceTable(schema, table),
             leftJoined
         );
     }
 
+    /**
+     * The modeled table one query source names. sqlcj models one namespace, so
+     * an unqualified and a {@code public}-qualified name are the same table,
+     * and a name qualified with any other schema names a table sqlcj leaves
+     * unmodeled and fails as a missing table.
+     */
+    private dev.sqlcj.schema.Table findSourceTable(Schema schema, Table table) {
+        if (!SchemaNamespace.isModeled(table)) {
+            throw new IllegalArgumentException(
+                "Table not found in schema: " + SchemaNamespace.declaredName(table)
+            );
+        }
+
+        return findTable(schema, table.getUnquotedName());
+    }
+
     /**
      * Accepts only a bare {@code JOIN} or explicit {@code INNER JOIN}, or a
      * {@code LEFT JOIN} in its bare or {@code LEFT OUTER JOIN} spelling, of one
diff --git a/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/ColumnTypeMapping.java b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/ColumnTypeMapping.java
index a1b7a72..ceb3dad 100644
--- a/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/ColumnTypeMapping.java
+++ b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/ColumnTypeMapping.java
@@ -2,11 +2,11 @@
 
 import dev.sqlcj.schema.ColumnType;
 import dev.sqlcj.schema.EnumType;
-import net.sf.jsqlparser.schema.MultiPartName;
 import net.sf.jsqlparser.statement.create.table.ColDataType;
 
 import java.util.List;
 import java.util.Locale;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
@@ -22,6 +22,9 @@ public final class ColumnTypeMapping {
     /** One parenthesized type argument group, such as {@code (10, 2)}. */
     private static final Pattern TYPE_ARGUMENTS = Pattern.compile("\\([^)]*\\)");
 
+    /** The array dimension groups a declared type text ends with. */
+    private static final Pattern TRAILING_DIMENSIONS = Pattern.compile("(\\[[^\\[\\]]*\\])+$");
+
     /**
      * One declared SQL type and the type sqlcj maps it to.
      *
@@ -64,7 +67,8 @@ public boolean mapped() {
      * recorded like any other unmapped type.
      */
     public MappedType map(ColDataType declaredType, List<EnumType> enums) {
-        String typeName = typeName(declaredType);
+        String elementText = elementText(declaredType.getDataType());
+        String typeName = typeName(elementText);
         int arrayDimensions = arrayDimensions(declaredType);
         boolean array = arrayDimensions == 1;
 
@@ -83,7 +87,7 @@ public MappedType map(ColDataType declaredType, List<EnumType> enums) {
                     );
                 }
             } else {
-                EnumType enumType = declaredEnum(declaredType, enums);
+                EnumType enumType = declaredEnum(elementText, enums);
 
                 if (enumType != null) {
                     return new MappedType(
@@ -137,13 +141,18 @@ public boolean isArrayElementType(ColumnType type) {
     }
 
     /**
-     * The enum type an unmapped declared type names, or {@code null} when the
-     * schema declares no such type. The declared type is matched without its
-     * SQL identifier delimiters and case-insensitively, as PostgreSQL resolves
-     * an unquoted type name.
+     * The enum type an unmapped declared element type names, or {@code null}
+     * when the schema declares no such type. The name is resolved in the one
+     * namespace sqlcj models, so a {@code public}-qualified name resolves as
+     * its unqualified name and a name of any other schema never resolves; see
+     * {@link SchemaNamespace}.
      */
-    private EnumType declaredEnum(ColDataType declaredType, List<EnumType> enums) {
-        String typeName = MultiPartName.unquote(declaredType.getDataType());
+    private EnumType declaredEnum(String elementText, List<EnumType> enums) {
+        String typeName = SchemaNamespace.modeledTypeName(elementText);
+
+        if (typeName == null) {
+            return null;
+        }
 
         return enums.stream()
             .filter(enumType -> enumType.name().equalsIgnoreCase(typeName))
@@ -154,28 +163,44 @@ private EnumType declaredEnum(ColDataType declaredType, List<EnumType> enums) {
     /**
      * Reports how many array dimensions a declaration states. The parser
      * reports an array's dimensions separately from its element type, so a
-     * declaration with any dimension is an array of the reported type.
+     * declaration with any dimension is an array of the reported type, except
+     * that a qualified element type carries its dimensions inside its own text,
+     * as in {@code public.mood[]}.
      */
     private int arrayDimensions(ColDataType declaredType) {
         List<Integer> arrayData = declaredType.getArrayData();
 
-        return arrayData == null
+        int dimensions = arrayData == null
             ? 0
             : arrayData.size();
+
+        return dimensions + textDimensions(declaredType.getDataType());
+    }
+
+    /** How many array dimension groups a declared type text itself ends with. */
+    private int textDimensions(String dataType) {
+        Matcher matcher = TRAILING_DIMENSIONS.matcher(dataType);
+
+        if (!matcher.find()) {
+            return 0;
+        }
+
+        return (int) matcher.group().chars().filter(character -> character == '[').count();
+    }
+
+    /** The declared element type text, without its array dimension groups. */
+    private String elementText(String dataType) {
+        return TRAILING_DIMENSIONS.matcher(dataType).replaceAll("");
     }
 
     /**
-     * Returns the canonical spelling of a declared SQL type: upper case,
+     * Returns the canonical spelling of a declared element type: upper case,
      * without type arguments such as a length or a precision, and with single
      * spaces between the remaining words.
      */
-    private String typeName(ColDataType declaredType) {
-        String dataType = declaredType
-            .getDataType()
-            .toUpperCase(Locale.ROOT);
-
+    private String typeName(String elementText) {
         return TYPE_ARGUMENTS
-            .matcher(dataType)
+            .matcher(elementText.toUpperCase(Locale.ROOT))
             .replaceAll(" ")
             .replaceAll("\\s+", " ")
             .trim();
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 1739bbd..c5b5ca4 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
@@ -75,8 +75,10 @@ public Schema parse(Schema schema, String sql) {
      * 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.
+     * schema models; such a statement is ignored as well when it names its own
+     * table or type in a schema sqlcj does not model, and an unreadable
+     * {@code ALTER TABLE} when every one of its top-level actions cannot change
+     * a modeled column.
      */
     private void apply(
         SchemaSourceSplitter.SourceStatement statement,
@@ -104,7 +106,11 @@ private void apply(
 
         String opening = tableOrTypeOpening(statement.tokens());
 
-        if (opening == null || ignoresEveryAlterTableAction(opening, statement.tokens())) {
+        if (
+            opening == null
+                || namesAnotherSchema(opening, statement.tokens())
+                || ignoresEveryAlterTableAction(opening, statement.tokens())
+        ) {
             return;
         }
 
@@ -143,6 +149,38 @@ private SchemaParseException unreadableStatement(
         return new SchemaParseException(SqlParseReason.of(located, true), located);
     }
 
+    /**
+     * Reports whether an unreadable statement names its own table or type in a
+     * schema sqlcj does not model, which is decided from the statement's tokens
+     * alone: the qualifier before the dot of the name that follows the opening
+     * words, the optional {@code IF [NOT] EXISTS}, and the optional
+     * {@code ONLY}. Such a statement cannot change what the schema models and
+     * is ignored, like a readable statement of the same name.
+     *
+     * <p>{@code DROP TABLE} is excluded, because it may name a modeled table
+     * beside a table of another schema.
+     */
+    private boolean namesAnotherSchema(String opening, List<String> tokens) {
+        if (opening.startsWith("DROP")) {
+            return false;
+        }
+
+        int index = opening.split(" ").length;
+
+        if (statesWords(tokens, index, "IF", "NOT", "EXISTS")) {
+            index += 3;
+        } else if (statesWords(tokens, index, "IF", "EXISTS")) {
+            index += 2;
+        }
+
+        if (statesWords(tokens, index, "ONLY")) {
+            index++;
+        }
+
+        return statesWords(tokens, index + 1, ".")
+            && !SchemaNamespace.isModeled(tokens.get(index));
+    }
+
     /**
      * Reports whether an unreadable statement is an {@code ALTER TABLE} whose
      * every top-level action is ignored, which is decided from the statement's
@@ -298,12 +336,21 @@ private boolean statesWords(List<String> tokens, int index, String... words) {
      * {@code CREATE TYPE ... AS ENUM}, and {@code ALTER TYPE}. Every other
      * statement a schema source may record is ignored and is not resolved
      * against the schema at all.
+     *
+     * <p>A statement whose own table or type stands in a schema sqlcj does not
+     * model is ignored the same way, before anything it names is resolved; see
+     * {@link SchemaNamespace}. {@code DROP TABLE} is the one statement that
+     * carries on, skipping such a name among its names.
      */
     private void apply(Statement statement, int line, List<Table> tables, List<EnumType> enums) {
         if (statement instanceof CreateTable createTable) {
-            applyCreateTable(createTable, line, enums, tables);
+            if (SchemaNamespace.isModeled(createTable.getTable())) {
+                applyCreateTable(createTable, line, enums, tables);
+            }
         } else if (statement instanceof Alter alter) {
-            applyAlterTable(alter, line, enums, tables);
+            if (SchemaNamespace.isModeled(alter.getTable())) {
+                applyAlterTable(alter, line, enums, tables);
+            }
         } else if (statement instanceof Drop drop && drop.getObjectType() == Drop.ObjectType.TABLE) {
             applyDropTable(drop, tables);
         } else if (
@@ -371,14 +418,19 @@ private String upperCase(String word) {
      * freed the name is never seen. A repeated label fails, as PostgreSQL
      * rejects it. An enum is 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.
+     * with its declared type. A type of a schema sqlcj does not model is
+     * ignored as well.
      */
     private void applyCreateEnumType(
         CreateType createType,
         EnumTypeDefinition definition,
         List<EnumType> enums
     ) {
-        String typeName = MultiPartName.unquote(createType.getName());
+        String typeName = SchemaNamespace.modeledTypeName(createType.getName());
+
+        if (typeName == null) {
+            return;
+        }
 
         int index = indexOfEnum(enums, typeName);
 
@@ -406,8 +458,10 @@ private void applyCreateEnumType(
     }
 
     /**
-     * Applies one {@code ALTER TYPE} action, resolving the stated type name,
-     * with its SQL identifier delimiters removed, among the modeled enum types.
+     * Applies one {@code ALTER TYPE} action, resolving the stated type name in
+     * the one namespace sqlcj models, so a {@code public}-qualified name
+     * resolves as its unqualified name and a type of any other schema is
+     * ignored.
      *
      * <p>An action that cannot change a modeled enum is ignored without the
      * type being resolved at all: ownership and the attribute actions of a
@@ -426,19 +480,24 @@ private void applyAlterType(
             return;
         }
 
+        String typeName = SchemaNamespace.modeledTypeName(alterType.getName());
+
+        if (typeName == null) {
+            return;
+        }
+
         if (action == AlterType.Action.ADD_VALUE) {
-            applyAddEnumValue(alterType, enums);
+            applyAddEnumValue(alterType, typeName, enums);
 
             return;
         }
 
-        String typeName = MultiPartName.unquote(alterType.getName());
         int index = indexOfEnum(enums, typeName);
 
         switch (action) {
             case RENAME_VALUE -> renameEnumLabel(alterType, typeName, index, enums);
             case RENAME -> renameEnumType(alterType, typeName, index, enums, tables);
-            case SET_SCHEMA -> moveEnumTypeToSchema(alterType, line, typeName, index);
+            case SET_SCHEMA -> moveEnumTypeToSchema(alterType, line, index);
             default -> throw unsupportedAlterTypeAction(String.valueOf(action), line);
         }
     }
@@ -508,8 +567,6 @@ private void renameEnumType(
         List<Table> tables
     ) {
         if (index < 0) {
-            ignoreUnmodeledType(alterType, typeName);
-
             return;
         }
 
@@ -532,38 +589,18 @@ private void renameEnumType(
 
     /**
      * Rejects {@code SET SCHEMA} of a modeled enum type, because its columns
-     * keep the type in a namespace sqlcj does not model.
+     * would keep the type in a namespace sqlcj does not model. A move into the
+     * one namespace it models leaves the type where it already is, and a type
+     * sqlcj does not model is ignored.
      */
-    private void moveEnumTypeToSchema(
-        AlterType alterType,
-        int line,
-        String typeName,
-        int index
-    ) {
-        if (index < 0) {
-            ignoreUnmodeledType(alterType, typeName);
-
+    private void moveEnumTypeToSchema(AlterType alterType, int line, int index) {
+        if (index < 0 || SchemaNamespace.isModeled(alterType.getNewName())) {
             return;
         }
 
         throw unsupportedAlterTypeAction("SET SCHEMA " + alterType.getNewName(), line);
     }
 
-    /**
-     * Ignores an {@code ALTER TYPE} action on a type sqlcj does not model,
-     * because such a type is none of its enum types.
-     *
-     * <p>A type name is the statement's own name with its SQL identifier
-     * delimiters removed, so {@code public.mood} and {@code mood} are different
-     * names. A qualified name that matches no modeled enum may therefore still
-     * state one, and fails as a missing type rather than being ignored.
-     */
-    private void ignoreUnmodeledType(AlterType alterType, String typeName) {
-        if (alterType.getName().contains(".")) {
-            throw typeNotFound(typeName);
-        }
-    }
-
     /** Renames the enum type of every column of {@code oldName}. */
     private Table renameColumnEnumType(Table table, String oldName, String newName) {
         List<Column> columns = new ArrayList<>(table.columns());
@@ -601,9 +638,7 @@ private Table renameColumnEnumType(Table table, String oldName, String newName)
      * alone: a label the type already has is a no-op even when the stated
      * neighbor is not one of its labels.
      */
-    private void applyAddEnumValue(AlterType alterType, List<EnumType> enums) {
-        String typeName = MultiPartName.unquote(alterType.getName());
-
+    private void applyAddEnumValue(AlterType alterType, String typeName, List<EnumType> enums) {
         int index = indexOfEnum(enums, typeName);
 
         if (index < 0) {
@@ -726,11 +761,19 @@ private void applyDropTable(Drop drop, List<Table> tables) {
      * tables as they stand before it drops anything, as PostgreSQL resolves
      * every name of one statement before deleting any of them. A name that is
      * not modeled fails, unless the statement declares {@code IF EXISTS}.
+     *
+     * <p>A name qualified with a schema sqlcj does not model names a table it
+     * leaves unmodeled and is skipped without failing, because the statement
+     * may name a modeled table beside it.
      */
     private List<String> droppedTableNames(Drop drop, List<Table> tables) {
         List<String> names = new ArrayList<>();
 
         for (net.sf.jsqlparser.schema.Table dropped : drop.getNames()) {
+            if (!SchemaNamespace.isModeled(dropped)) {
+                continue;
+            }
+
             String tableName = dropped.getUnquotedName();
 
             if (indexOfTable(tables, tableName) < 0) {
@@ -796,11 +839,71 @@ private void applyAlterTable(Alter alter, int line, List<EnumType> enums, List<T
             throw tableNotFound(tableName);
         }
 
+        String schemaName = soleSetSchemaAction(alter);
+
+        if (schemaName != null) {
+            moveTableToSchema(line, schemaName, tables, index);
+
+            return;
+        }
+
         for (AlterExpression expression : alter.getAlterExpressions()) {
             applyToTableAndPartitions(line, expression, enums, tables, index);
         }
     }
 
+    /**
+     * The schema a {@code SET SCHEMA} written as the statement's sole action
+     * names, or {@code null} for every other {@code ALTER TABLE}, including a
+     * {@code SET SCHEMA} written beside another action, which PostgreSQL does
+     * not accept and sqlcj rejects.
+     *
+     * <p>The parser has no form of its own for the action and reports it as the
+     * text that runs to the end of the statement, so that text is lexed with
+     * the parser's own lexer and must state exactly {@code SET SCHEMA <schema>}.
+     */
+    private String soleSetSchemaAction(Alter alter) {
+        List<AlterExpression> expressions = alter.getAlterExpressions();
+
+        if (expressions.size() != 1) {
+            return null;
+        }
+
+        AlterExpression expression = expressions.get(0);
+
+        if (expression.getOperation() != AlterOperation.UNSPECIFIC || expression.getOptionalSpecifier() == null) {
+            return null;
+        }
+
+        List<String> tokens = SchemaSourceSplitter.tokens(expression.getOptionalSpecifier());
+
+        return tokens.size() == 3 && statesWords(tokens, 0, "SET", "SCHEMA")
+            ? tokens.get(2)
+            : null;
+    }
+
+    /**
+     * Moves one table out of the schema model, because sqlcj models the tables
+     * of one namespace alone: the table is removed, keeping the order of the
+     * remaining ones, and a move into the namespace it models leaves the table
+     * where it already is.
+     *
+     * <p>A table with modeled partitions is rejected naming the action, because
+     * its partitions would stay in the modeled namespace following a parent
+     * sqlcj no longer models.
+     */
+    private void moveTableToSchema(int line, String schemaName, List<Table> tables, int index) {
+        if (SchemaNamespace.isModeled(schemaName)) {
+            return;
+        }
+
+        if (indexOfPartition(tables, tables.get(index).name()) >= 0) {
+            throw unsupportedAlterTableAction(line, "SET SCHEMA " + schemaName);
+        }
+
+        tables.remove(index);
+    }
+
     /**
      * Applies one {@code ALTER TABLE} action to the table at {@code index} and,
      * when the action changes a modeled column, to every partition of that
@@ -1007,7 +1110,9 @@ private Table ignoreUnspecificActions(int line, AlterExpression expression, Tabl
      * trigger and rule switches, constraint validation, replica identity,
      * clustering, storage parameters, the tablespace, logging, the access
      * method, inheritance, and the typed-table form. {@code SET SCHEMA} is not
-     * among them, because it moves the table out of the namespace sqlcj models.
+     * among them: it moves the table out of the namespace sqlcj models and is
+     * applied as the statement's sole action, which is the only form PostgreSQL
+     * accepts, so written beside another action it is rejected here.
      */
     private boolean ignoresTableLevelAction(List<String> action) {
         return statesWords(action, 0, "OWNER", "TO")
@@ -1426,27 +1531,20 @@ private int indexOfTable(List<Table> tables, String tableName) {
      * {@code -1} when sqlcj does not model it.
      *
      * <p>sqlcj models one namespace, so an unqualified and a
-     * {@code public}-qualified name are the same table. A name qualified with
-     * any other schema names a table sqlcj leaves unmodeled, and fails as a
-     * missing table rather than resolving to a modeled table of the same
-     * unqualified name.
+     * {@code public}-qualified name are the same table, and a name qualified
+     * with any other schema names a table sqlcj leaves unmodeled rather than
+     * the modeled table of the same unqualified name; see
+     * {@link SchemaNamespace}.
      */
     private int indexOfReferencedTable(
         List<Table> tables,
         net.sf.jsqlparser.schema.Table referenced
     ) {
-        String tableName = referenced.getUnquotedName();
-        String declaredSchema = referenced.getSchemaName();
-
-        if (declaredSchema != null) {
-            String schemaName = MultiPartName.unquote(declaredSchema);
-
-            if (!"public".equalsIgnoreCase(schemaName)) {
-                throw tableNotFound(schemaName + "." + tableName);
-            }
+        if (!SchemaNamespace.isModeled(referenced)) {
+            return -1;
         }
 
-        return indexOfTable(tables, tableName);
+        return indexOfTable(tables, referenced.getUnquotedName());
     }
 
     /** Enum type names are matched case-insensitively, as a column names them. */
@@ -1642,7 +1740,7 @@ private Table referencedTable(
         int index = indexOfReferencedTable(tables, referenced);
 
         if (index < 0) {
-            throw tableNotFound(referenced.getUnquotedName());
+            throw tableNotFound(SchemaNamespace.declaredName(referenced));
         }
 
         return tables.get(index);
diff --git a/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaNamespace.java b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaNamespace.java
new file mode 100644
index 0000000..6c80511
--- /dev/null
+++ b/sqlcj-cli/src/main/java/dev/sqlcj/schema/parser/SchemaNamespace.java
@@ -0,0 +1,106 @@
+package dev.sqlcj.schema.parser;
+
+import net.sf.jsqlparser.schema.MultiPartName;
+import net.sf.jsqlparser.schema.Table;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The one PostgreSQL namespace sqlcj models.
+ *
+ * <p>An unqualified and a {@code public}-qualified name are the same name, so
+ * {@code users}, {@code public.users}, and {@code "public"."users"} name one
+ * table and {@code mood}, {@code public.mood}, and {@code "public"."mood"} name
+ * one type. A name qualified with any other schema names an object sqlcj leaves
+ * unmodeled. A schema source's {@code search_path} is never read, so it never
+ * decides which schema an unqualified name belongs to.
+ *
+ * <p>A schema qualifier is compared without its SQL identifier delimiters and
+ * case-insensitively, as every other name sqlcj resolves is.
+ */
+public final class SchemaNamespace {
+
+    /** The one schema sqlcj models. */
+    private static final String MODELED_SCHEMA = "public";
+
+    private SchemaNamespace() {
+    }
+
+    /**
+     * Reports whether a declared schema qualifier names the modeled schema. A
+     * name without a qualifier does, and a qualified name does when its
+     * qualifier is {@code public}.
+     */
+    public static boolean isModeled(String declaredSchema) {
+        return declaredSchema == null || MODELED_SCHEMA.equalsIgnoreCase(MultiPartName.unquote(declaredSchema));
+    }
+
+    /**
+     * Reports whether sqlcj models the schema of the table one statement or
+     * query names.
+     */
+    public static boolean isModeled(Table table) {
+        return isModeled(table.getSchemaName());
+    }
+
+    /**
+     * The name a diagnostic states for the table one statement or query names:
+     * its own name, qualified with its schema when sqlcj does not model that
+     * schema, each part without its SQL identifier delimiters.
+     */
+    public static String declaredName(Table table) {
+        String declaredSchema = table.getSchemaName();
+
+        return isModeled(declaredSchema)
+            ? table.getUnquotedName()
+            : MultiPartName.unquote(declaredSchema) + "." + table.getUnquotedName();
+    }
+
+    /**
+     * The modeled name a declared type name states, or {@code null} when it is
+     * qualified with a schema sqlcj does not model.
+     *
+     * <p>The parser reports a type name as one text, its qualifier and its SQL
+     * identifier delimiters included, so the text is split at the dots that
+     * stand outside double quotes and each part is read without its delimiters.
+     */
+    public static String modeledTypeName(String declaredType) {
+        List<String> parts = parts(declaredType);
+
+        if (parts.size() == 1) {
+            return parts.get(0);
+        }
+
+        return parts.size() == 2 && MODELED_SCHEMA.equalsIgnoreCase(parts.get(0))
+            ? parts.get(1)
+            : null;
+    }
+
+    /**
+     * The parts of one possibly qualified name text, split at the dots that
+     * stand outside double quotes, each without its SQL identifier delimiters.
+     */
+    private static List<String> parts(String declaredName) {
+        List<String> parts = new ArrayList<>();
+        StringBuilder part = new StringBuilder();
+        boolean delimited = false;
+
+        for (int i = 0; i < declaredName.length(); i++) {
+            char character = declaredName.charAt(i);
+
+            if (character == '"') {
+                delimited = !delimited;
+            } else if (character == '.' && !delimited) {
+                parts.add(part.toString());
+                part.setLength(0);
+            } else {
+                part.append(character);
+            }
+        }
+
+        parts.add(part.toString());
+
+        return parts;
+    }
+}
diff --git a/sqlcj-cli/src/test/java/dev/sqlcj/analysis/QueryAnalyzerTest.java b/sqlcj-cli/src/test/java/dev/sqlcj/analysis/QueryAnalyzerTest.java
index aa2f76d..c3a7a66 100644
--- a/sqlcj-cli/src/test/java/dev/sqlcj/analysis/QueryAnalyzerTest.java
+++ b/sqlcj-cli/src/test/java/dev/sqlcj/analysis/QueryAnalyzerTest.java
@@ -5039,4 +5039,114 @@ void shouldRejectANameUsedAsBothAListAndItsElement() {
             exception.getMessage()
         );
     }
+
+    /**
+     * sqlcj models one namespace, so an unqualified and a
+     * {@code public}-qualified query source are the same table and analyze
+     * alike. The qualifier is matched without its SQL identifier delimiters and
+     * case-insensitively.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "users",
+            "public.users",
+            "\"public\".\"users\"",
+            "PUBLIC.users"
+        }
+    )
+    void shouldResolveAPublicQualifiedSource(String declaredName) {
+        String sql = "SELECT id, name FROM %s WHERE id = $1".formatted(declaredName);
+
+        QueryModel model = analyzer.analyze(
+            new Query("GetUser", QueryType.ONE, sql),
+            parser.parse(sql),
+            schema
+        );
+
+        assertEquals("users", model.table());
+
+        assertEquals(
+            List.of(
+                new QueryColumn("id", ColumnType.BIGINT, false),
+                new QueryColumn("name", ColumnType.VARCHAR, true)
+            ),
+            model.columns()
+        );
+
+        assertEquals(
+            List.of(new QueryParameter(1, "id", ColumnType.BIGINT)),
+            model.parameters()
+        );
+    }
+
+    /**
+     * A source qualified with a schema other than {@code public} names a table
+     * sqlcj leaves unmodeled, so it is rejected as a missing table rather than
+     * resolving to the modeled table of the same unqualified name, in every
+     * query that names a table.
+     */
+    @ParameterizedTest
+    @CsvSource(
+        delimiter = '|',
+        quoteCharacter = '"',
+        value = {
+            "MANY|SELECT id FROM reporting.users",
+            "MANY|SELECT u.id FROM users u JOIN reporting.profiles p ON p.user_id = u.id",
+            "MANY|SELECT u.id FROM users u LEFT JOIN reporting.profiles p ON p.user_id = u.id",
+            "EXEC|INSERT INTO reporting.users (name) VALUES ($1)",
+            "EXEC|UPDATE reporting.users SET name = $1 WHERE id = $2",
+            "EXEC|DELETE FROM reporting.users WHERE id = $1"
+        }
+    )
+    void shouldRejectASourceOfAnotherSchema(QueryType type, String sql) {
+        Query query = new Query("TouchUsers", type, sql);
+        ParsedSql parsedSql = parser.parse(sql);
+
+        IllegalArgumentException exception = assertThrows(
+            IllegalArgumentException.class,
+            () -> analyzer.analyze(query, parsedSql, joinSchema)
+        );
+
+        assertEquals(
+            "Table not found in schema: reporting."
+                + (sql.contains("profiles") ? "profiles" : "users"),
+            exception.getMessage()
+        );
+    }
+
+    /**
+     * A cast type resolves its enum in the one namespace sqlcj models, so a
+     * {@code public}-qualified cast names the declared enum, scalar and array
+     * alike, and a cast type of any other schema is rejected with its declared
+     * text.
+     */
+    @Test
+    void shouldResolveAPublicQualifiedEnumCastType() {
+        String sql = "SELECT handle::public.stage_setting[] AS s FROM stages";
+
+        QueryModel model = analyzer.analyze(
+            new Query("ListStageSettings", QueryType.MANY, sql),
+            parser.parse(sql),
+            enumSchema
+        );
+
+        assertEquals(
+            List.of(new QueryColumn("s", ColumnType.ENUM, true, "stage_setting", true)),
+            model.columns()
+        );
+
+        String unmapped = "SELECT handle::reporting.stage_setting AS s FROM stages";
+        Query query = new Query("ListStageSettings", QueryType.MANY, unmapped);
+        ParsedSql parsedSql = parser.parse(unmapped);
+
+        assertEquals(
+            "Result column 's' has unsupported cast type REPORTING.STAGE_SETTING",
+            assertThrows(
+                UnsupportedOperationException.class,
+                () -> analyzer.analyze(query, parsedSql, enumSchema)
+            )
+                .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 7d6b703..b19245b 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
@@ -1294,8 +1294,6 @@ void shouldApplyAModeledActionBesideAnIgnoredConstraintAction() {
         delimiter = '|',
         quoteCharacter = '"',
         value = {
-            "ALTER TABLE users SET SCHEMA archive;"
-                + "|Unsupported ALTER TABLE action: SET SCHEMA archive at line 1",
             "ALTER TABLE users ADD COLUMN x int, SET SCHEMA archive;"
                 + "|Unsupported ALTER TABLE action: SET SCHEMA archive at line 1",
             "ALTER TABLE users OWNER TO app, ADD COLUMN x int;"
@@ -1336,12 +1334,12 @@ void shouldReportTheLineOfARejectedAlterTableAction() {
             () -> parser.parse(schema, """
                 ALTER TABLE users OWNER TO app;
 
-                ALTER TABLE users SET SCHEMA archive;
+                ALTER TABLE users ALTER COLUMN name SET VISIBLE;
                 """)
         );
 
         assertEquals(
-            "Unsupported ALTER TABLE action: SET SCHEMA archive at line 3",
+            "Unsupported ALTER TABLE action: ALTER COLUMN name SET VISIBLE at line 3",
             exception.getMessage()
         );
     }
@@ -2244,7 +2242,11 @@ void shouldIgnoreAddValueIfNotExistsForAnExistingLabel(String statement) {
         );
     }
 
-    /** Each enum diagnostic names the type and, where it applies, the label. */
+    /**
+     * Each enum diagnostic names the type and, where it applies, the label. A
+     * {@code public}-qualified name resolves as its unqualified name, so the
+     * diagnostic names it unqualified.
+     */
     @ParameterizedTest
     @CsvSource(
         delimiter = '|',
@@ -2260,10 +2262,10 @@ void shouldIgnoreAddValueIfNotExistsForAnExistingLabel(String statement) {
                 + "|Label not found in type stage_setting: missing",
             "ALTER TYPE stage_setting RENAME VALUE 'indoor' TO 'outdoor';"
                 + "|Label already exists in type stage_setting: outdoor",
-            "ALTER TYPE public.stage_setting RENAME TO stage;"
-                + "|Type not found in schema: public.stage_setting",
-            "ALTER TYPE public.stage_setting SET SCHEMA archive;"
-                + "|Type not found in schema: public.stage_setting"
+            "ALTER TYPE public.shelf_state ADD VALUE 'stocked';"
+                + "|Type not found in schema: shelf_state",
+            "ALTER TYPE \"public\".\"shelf_state\" RENAME VALUE 'stocked' TO 'kept';"
+                + "|Type not found in schema: shelf_state"
         }
     )
     void shouldReportTheEnumStatementItCannotApply(String statement, String message) {
@@ -3160,12 +3162,11 @@ void shouldNotFollowTheSourceOfALikeCopy() {
     }
 
     /**
-     * Until sqlcj models namespaces, a table name qualified with a schema other
-     * than {@code public} names a table it leaves unmodeled, so a
-     * {@code LIKE} or {@code PARTITION OF} source and an {@code ATTACH} or
-     * {@code DETACH PARTITION} partition written that way fails as a missing
-     * table rather than resolving to the modeled table of the same unqualified
-     * name.
+     * A table name qualified with a schema other than {@code public} names a
+     * table sqlcj leaves unmodeled rather than the modeled table of the same
+     * unqualified name, so a {@code LIKE} or {@code PARTITION OF} source
+     * written that way fails as a missing table: the created table's columns
+     * would otherwise be unknown.
      */
     @ParameterizedTest
     @CsvSource(
@@ -3174,11 +3175,7 @@ void shouldNotFollowTheSourceOfALikeCopy() {
             "CREATE TABLE c (LIKE reporting.events);"
                 + "|Table not found in schema: reporting.events",
             "CREATE TABLE events_2026 PARTITION OF reporting.events DEFAULT;"
-                + "|Table not found in schema: reporting.events",
-            "ALTER TABLE events ATTACH PARTITION reporting.events_2026 DEFAULT;"
-                + "|Table not found in schema: reporting.events_2026",
-            "ALTER TABLE events DETACH PARTITION reporting.events_2026;"
-                + "|Table not found in schema: reporting.events_2026"
+                + "|Table not found in schema: reporting.events"
         }
     )
     void shouldRejectASourceOrPartitionOfAnotherSchema(String statement, String message) {
@@ -3194,6 +3191,348 @@ void shouldRejectASourceOrPartitionOfAnotherSchema(String statement, String mess
         );
     }
 
+    /**
+     * An {@code ATTACH} or {@code DETACH PARTITION} partition qualified with a
+     * schema other than {@code public} names a table sqlcj leaves unmodeled and
+     * is ignored, like any other partition it does not model, so the modeled
+     * table of the same unqualified name keeps its own link.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TABLE events ATTACH PARTITION reporting.events_2026 DEFAULT;",
+            "ALTER TABLE events DETACH PARTITION reporting.events_2026;"
+        }
+    )
+    void shouldIgnoreAPartitionOfAnotherSchema(String statement) {
+        Schema schema = partitionedSchema();
+
+        assertEquals(schema, parser.parse(schema, statement));
+        assertEquals("events", table(parser.parse(schema, statement), "events_2026").partitionOf());
+    }
+
+    /**
+     * sqlcj models one namespace, so an unqualified and a
+     * {@code public}-qualified table name are the same table: a
+     * {@code CREATE TABLE}, an {@code ALTER TABLE}, and a {@code DROP TABLE}
+     * written either way leave the same schema model. The qualifier is matched
+     * without its SQL identifier delimiters and case-insensitively.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "users",
+            "public.users",
+            "\"public\".\"users\"",
+            "PUBLIC.users",
+            "\"PUBLIC\".users"
+        }
+    )
+    void shouldModelAPublicQualifiedTableNameAsItsUnqualifiedName(String declaredName) {
+        Schema schema = parser.parse(
+            """
+                CREATE TABLE %s (
+                    id   BIGINT NOT NULL,
+                    note TEXT
+                );
+
+                ALTER TABLE %s ADD COLUMN label VARCHAR(32);
+                ALTER TABLE %s ALTER COLUMN note SET NOT NULL;
+                """.formatted(declaredName, declaredName, declaredName)
+        );
+
+        assertEquals(List.of("users"), tableNames(schema));
+
+        assertEquals(
+            List.of(
+                new Column("id", ColumnType.BIGINT, false),
+                new Column("note", ColumnType.TEXT, false),
+                new Column("label", ColumnType.VARCHAR, true)
+            ),
+            table(schema, "users").columns()
+        );
+
+        assertEquals(
+            List.of(),
+            tableNames(parser.parse(schema, "DROP TABLE %s;".formatted(declaredName)))
+        );
+    }
+
+    /**
+     * A statement whose own table stands in a schema sqlcj does not model
+     * cannot change what the schema models and is ignored before anything it
+     * names is resolved, so neither its rejected clauses, its rejected actions,
+     * nor its sources are resolved and a modeled table of the same unqualified
+     * name is left alone.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "CREATE TABLE reporting.users (code TEXT);",
+            "CREATE TABLE IF NOT EXISTS reporting.users (code TEXT);",
+            "CREATE TABLE reporting.copy (LIKE missing);",
+            "CREATE TABLE reporting.copy PARTITION OF missing DEFAULT;",
+            "CREATE TABLE reporting.copy OF missing_type;",
+            "CREATE TABLE reporting.copy AS SELECT 1;",
+            "ALTER TABLE reporting.users ADD COLUMN id TEXT;",
+            "ALTER TABLE reporting.users DROP COLUMN id;",
+            "ALTER TABLE reporting.users RENAME TO orders;",
+            "ALTER TABLE reporting.users ALTER COLUMN name SET VISIBLE;",
+            "ALTER TABLE reporting.users SET SCHEMA public;",
+            "ALTER TABLE reporting.missing ADD COLUMN x INTEGER;",
+            "ALTER TABLE \"reporting\".\"users\" DROP COLUMN id;",
+            "DROP TABLE reporting.users;",
+            "DROP TABLE reporting.missing;"
+        }
+    )
+    void shouldIgnoreAStatementAboutATableOfAnotherSchema(String statement) {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        assertEquals(schema, parser.parse(schema, statement));
+    }
+
+    /**
+     * A {@code DROP TABLE} carries on past a name qualified with a schema sqlcj
+     * does not model, without failing, and removes the modeled tables it names
+     * beside it.
+     */
+    @Test
+    void shouldSkipTheDroppedNamesOfAnotherSchema() {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        assertEquals(
+            List.of("users"),
+            tableNames(parser.parse(schema, "DROP TABLE reporting.missing, orders;"))
+        );
+    }
+
+    /**
+     * An unreadable statement that opens as table or type DDL is ignored when
+     * the object it names is qualified with a schema sqlcj does not model,
+     * which is decided from the statement's tokens alone.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TABLE reporting.users ALTER COLUMN name SET DATA TYPE text;",
+            "ALTER TABLE ONLY reporting.users ALTER COLUMN name SET DATA TYPE text;",
+            "ALTER TABLE IF EXISTS reporting.users ALTER COLUMN name SET DATA TYPE text;",
+            "CREATE TABLE reporting.copy (id WITH OPTIONS NOT NULL);",
+            "CREATE TABLE IF NOT EXISTS reporting.copy (id WITH OPTIONS NOT NULL);",
+            "CREATE TYPE reporting.pair AS (a int, b);",
+            "ALTER TYPE reporting.pair SET (RECEIVE = f);",
+            "ALTER TYPE reporting.stage_setting ADD VALUE 'a', ADD VALUE 'b';"
+        }
+    )
+    void shouldIgnoreAnUnreadableStatementQualifiedWithAnotherSchema(String statement) {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        assertEquals(schema, parser.parse(schema, statement));
+    }
+
+    /**
+     * The same unreadable statements stay rejected when the object they name
+     * stands in the one namespace sqlcj models, unqualified or
+     * {@code public}-qualified.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TABLE users ALTER COLUMN name SET DATA TYPE text;",
+            "ALTER TABLE public.users ALTER COLUMN name SET DATA TYPE text;",
+            "ALTER TABLE ONLY \"public\".\"users\" ALTER COLUMN name SET DATA TYPE text;",
+            "CREATE TABLE public.copy (id WITH OPTIONS NOT NULL);",
+            "CREATE TYPE public.pair AS (a int, b);",
+            "ALTER TYPE public.pair SET (RECEIVE = f);"
+        }
+    )
+    void shouldRejectAnUnreadableStatementOfTheModeledSchema(String statement) {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        assertThrows(SchemaParseException.class, () -> parser.parse(schema, statement));
+    }
+
+    /**
+     * {@code ALTER TABLE ... SET SCHEMA public} leaves the table where it
+     * already is, because sqlcj models that namespace.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TABLE users SET SCHEMA public;",
+            "ALTER TABLE users SET SCHEMA \"public\";",
+            "ALTER TABLE users SET SCHEMA PUBLIC;"
+        }
+    )
+    void shouldIgnoreSetSchemaPublicOfAModeledTable(String statement) {
+        Schema schema = parser.parse(BASE_SCHEMA);
+
+        assertEquals(schema, parser.parse(schema, statement));
+    }
+
+    /**
+     * {@code ALTER TABLE ... SET SCHEMA} of any other schema moves the table
+     * out of the one namespace sqlcj models, so the table is removed and the
+     * remaining ones keep their order.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TABLE users SET SCHEMA archive;",
+            "ALTER TABLE users SET SCHEMA \"Archive\";"
+        }
+    )
+    void shouldRemoveATableMovedToAnotherSchema(String statement) {
+        assertEquals(List.of("orders"), tableNames(applied(statement)));
+    }
+
+    /**
+     * {@code SET SCHEMA} of a table with modeled partitions is rejected naming
+     * the action and the line its own statement begins on, because its
+     * partitions would stay in the modeled namespace following a parent sqlcj
+     * no longer models.
+     */
+    @Test
+    void shouldRejectSetSchemaOfATableWithModeledPartitions() {
+        Schema schema = partitionedSchema();
+
+        assertEquals(
+            "Unsupported ALTER TABLE action: SET SCHEMA archive at line 3",
+            assertThrows(
+                UnsupportedOperationException.class,
+                () -> parser.parse(schema, """
+                    ALTER TABLE events OWNER TO app;
+
+                    ALTER TABLE events SET SCHEMA archive;
+                    """)
+            )
+                .getMessage()
+        );
+    }
+
+    /**
+     * An unqualified and a {@code public}-qualified type name are the same
+     * type, so a qualified {@code CREATE TYPE} replaces a modeled enum of that
+     * name in its position rather than adding a second one, and every
+     * {@code ALTER TYPE} action written that way acts on the modeled enum.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "stage_setting",
+            "public.stage_setting",
+            "\"public\".\"stage_setting\"",
+            "PUBLIC.stage_setting"
+        }
+    )
+    void shouldModelAPublicQualifiedTypeNameAsItsUnqualifiedName(String declaredName) {
+        Schema schema = parser.parse(
+            enumSchema(),
+            """
+                CREATE TYPE %s AS ENUM ('indoor', 'outdoor');
+
+                ALTER TYPE %s ADD VALUE 'covered' BEFORE 'outdoor';
+                ALTER TYPE %s RENAME VALUE 'indoor' TO 'inside';
+                """.formatted(declaredName, declaredName, declaredName)
+        );
+
+        assertEquals(
+            List.of(new EnumType("stage_setting", List.of("inside", "covered", "outdoor"))),
+            schema.enums()
+        );
+
+        assertEquals(
+            List.of(new EnumType("stage", List.of("inside", "covered", "outdoor"))),
+            parser.parse(schema, "ALTER TYPE %s RENAME TO stage;".formatted(declaredName)).enums()
+        );
+    }
+
+    /**
+     * Every {@code CREATE TYPE} and {@code ALTER TYPE} of a type qualified with
+     * a schema sqlcj does not model is ignored before anything it states is
+     * resolved, so the modeled enum of the same unqualified name is left alone.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "CREATE TYPE reporting.stage_setting AS ENUM ('indoor', 'indoor');",
+            "ALTER TYPE reporting.stage_setting ADD VALUE 'covered';",
+            "ALTER TYPE reporting.stage_setting ADD VALUE 'indoor';",
+            "ALTER TYPE reporting.stage_setting ADD VALUE 'covered' AFTER 'missing';",
+            "ALTER TYPE reporting.stage_setting RENAME VALUE 'indoor' TO 'inside';",
+            "ALTER TYPE reporting.stage_setting RENAME TO stage;",
+            "ALTER TYPE reporting.stage_setting SET SCHEMA public;",
+            "ALTER TYPE reporting.stage_setting SET SCHEMA archive;",
+            "ALTER TYPE \"reporting\".\"stage_setting\" ADD VALUE 'covered';"
+        }
+    )
+    void shouldIgnoreATypeStatementOfAnotherSchema(String statement) {
+        Schema schema = enumSchema();
+
+        assertEquals(schema, parser.parse(schema, statement));
+    }
+
+    /**
+     * {@code ALTER TYPE ... SET SCHEMA public} of a modeled enum leaves the
+     * type where it already is, because sqlcj models that namespace.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TYPE stage_setting SET SCHEMA public;",
+            "ALTER TYPE public.stage_setting SET SCHEMA \"public\";"
+        }
+    )
+    void shouldIgnoreSetSchemaPublicOfAModeledEnum(String statement) {
+        Schema schema = enumSchema();
+
+        assertEquals(schema, parser.parse(schema, statement));
+    }
+
+    /**
+     * A column whose declared type names a modeled enum qualified with
+     * {@code public} is modeled as an enum column, scalar and array alike,
+     * through every path that types a column, and a type qualified with any
+     * other schema never resolves and is recorded with its declared text, as
+     * an unmapped {@code public}-qualified type is.
+     */
+    @Test
+    void shouldModelPublicQualifiedEnumColumnTypes() {
+        Schema schema = parser.parse(
+            enumSchema(),
+            """
+                CREATE TABLE stages (
+                    setting  public.stage_setting NOT NULL,
+                    covered  "public"."stage_setting",
+                    past     public.stage_setting[],
+                    quoted   "public"."stage_setting"[],
+                    sized    public.stage_setting[4],
+                    nested   public.stage_setting[][],
+                    external reporting.stage_setting,
+                    legacy   public.citext[]
+                );
+
+                ALTER TABLE stages ADD COLUMN added public.stage_setting[];
+                ALTER TABLE stages ALTER COLUMN covered TYPE "public"."stage_setting"[];
+                """
+        );
+
+        assertEquals(
+            List.of(
+                new Column("setting", ColumnType.ENUM, false, null, "stage_setting"),
+                new Column("covered", ColumnType.ENUM, true, null, "stage_setting", true),
+                new Column("past", ColumnType.ENUM, true, null, "stage_setting", true),
+                new Column("quoted", ColumnType.ENUM, true, null, "stage_setting", true),
+                new Column("sized", ColumnType.ENUM, true, null, "stage_setting", true),
+                new Column("nested", null, true, "PUBLIC.STAGE_SETTING[][]"),
+                new Column("external", null, true, "REPORTING.STAGE_SETTING"),
+                new Column("legacy", null, true, "PUBLIC.CITEXT[]"),
+                new Column("added", ColumnType.ENUM, true, null, "stage_setting", true)
+            ),
+            table(schema, "stages").columns()
+        );
+    }
+
     /** The schema whose {@code events} table the copying tests read. */
     private Schema partitionedSchema() {
         return parser.parse(