From eb458da9b4965fdeb9c5d62dfee0e627118d2b27 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=96mer=20=C3=87engel?= <oscngl@gmail.com>
Date: Sat, 10 Oct 2026 19:39:04 +0300
Subject: [PATCH] feat(schema): model enum renames and replace an enum on its
 name

ALTER TYPE ... RENAME TO renames a modeled enum in its position and every
scalar and array column of that type follows it; RENAME VALUE renames a
label in its position. A CREATE TYPE ... AS ENUM or RENAME TO onto a
modeled enum's name replaces that enum, so the migration that replaces an
enum loads in either usual shape. OWNER TO and the attribute actions are
ignored without resolving the type, RENAME TO and SET SCHEMA of an
unmodeled type are ignored, and SET SCHEMA of a modeled enum is rejected
naming the action.
---
 docs/postgresql.md                            |  36 ++-
 .../schema/parser/DefaultSchemaParser.java    | 235 +++++++++++++--
 .../compiler/PostgresIntegrationTest.java     | 119 ++++++++
 .../parser/DefaultSchemaParserTest.java       | 284 +++++++++++++++++-
 4 files changed, 633 insertions(+), 41 deletions(-)

diff --git a/docs/postgresql.md b/docs/postgresql.md
index dbbaff9..faf12ed 100644
--- a/docs/postgresql.md
+++ b/docs/postgresql.md
@@ -94,9 +94,10 @@ order the files are read in.
 
 - 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
+  `CREATE TYPE ... AS ENUM` and `ALTER TYPE ... ADD VALUE`, `RENAME TO`, and
+  `RENAME 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
@@ -247,17 +248,29 @@ 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 as `Unsupported ALTER TYPE action at line <n>`. |
+| `ALTER TYPE ... RENAME TO <name>` | Renames the type in its position, keeping its labels, and every column of that type, scalar and array alike, follows it. |
+| `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. |
 | `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
+[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
-a type or 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. 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:
 
 ```text
-sqlcj: Invalid schema source /home/dev/project/sql/migrations/V2__stages.sql: Type already exists in schema: stage_setting
 sqlcj: Invalid schema source /home/dev/project/sql/migrations/V2__stages.sql: Type not found in schema: stage_setting
 sqlcj: Invalid schema source /home/dev/project/sql/migrations/V2__stages.sql: Label already exists in type stage_setting: indoor
 sqlcj: Invalid schema source /home/dev/project/sql/migrations/V2__stages.sql: Label not found in type stage_setting: covered
@@ -424,9 +437,8 @@ 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 TYPE ... AS ENUM` and `ALTER TYPE` 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` of any target, including `TABLE`, `COLUMN`, `VIEW`, `TYPE`,
@@ -464,7 +476,7 @@ what they would do to the schema model:
 | Statement | Diagnostic |
 | --- | --- |
 | 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 |
-| An `ALTER TYPE` action other than `ADD VALUE` | `Unsupported ALTER TYPE action at line <n>` |
+| 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` |
 | 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 |
 
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 7e38f6b..4fe9795 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
@@ -292,9 +292,9 @@ private boolean statesWords(List<String> tokens, int index, String... words) {
      *
      * <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.
+     * {@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.
      */
     private void apply(Statement statement, int line, List<Table> tables, List<EnumType> enums) {
         if (statement instanceof CreateTable createTable) {
@@ -309,11 +309,7 @@ private void apply(Statement statement, int line, List<Table> tables, List<EnumT
         ) {
             applyCreateEnumType(createType, definition, enums);
         } else if (statement instanceof AlterType alterType) {
-            if (alterType.getAction() != AlterType.Action.ADD_VALUE) {
-                throw unsupportedAlterTypeAction(line);
-            }
-
-            applyAddEnumValue(alterType, enums);
+            applyAlterType(alterType, line, enums, tables);
         }
     }
 
@@ -367,10 +363,12 @@ private String upperCase(String word) {
     }
 
     /**
-     * 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; a {@code CREATE TYPE} of any other kind is
-     * ignored, and a column of such a type is recorded with its declared type.
+     * Appends one enum type with its declared labels, and replaces a modeled
+     * enum of the same name in its position, because the {@code DROP TYPE} that
+     * 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.
      */
     private void applyCreateEnumType(
         CreateType createType,
@@ -379,9 +377,7 @@ private void applyCreateEnumType(
     ) {
         String typeName = MultiPartName.unquote(createType.getName());
 
-        if (indexOfEnum(enums, typeName) >= 0) {
-            throw typeAlreadyExists(typeName);
-        }
+        int index = indexOfEnum(enums, typeName);
 
         List<String> labels = new ArrayList<>();
 
@@ -395,14 +391,208 @@ private void applyCreateEnumType(
             labels.add(label);
         }
 
-        enums.add(new EnumType(typeName, labels));
+        EnumType enumType = new EnumType(typeName, labels);
+
+        if (index < 0) {
+            enums.add(enumType);
+
+            return;
+        }
+
+        enums.set(index, enumType);
+    }
+
+    /**
+     * Applies one {@code ALTER TYPE} action, resolving the stated type name,
+     * with its SQL identifier delimiters removed, among the modeled enum types.
+     *
+     * <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
+     * composite type. Every other action sqlcj models resolves the type, and an
+     * action sqlcj does not model is rejected naming the action.
+     */
+    private void applyAlterType(
+        AlterType alterType,
+        int line,
+        List<EnumType> enums,
+        List<Table> tables
+    ) {
+        AlterType.Action action = alterType.getAction();
+
+        if (ignoresAlterTypeAction(action)) {
+            return;
+        }
+
+        if (action == AlterType.Action.ADD_VALUE) {
+            applyAddEnumValue(alterType, 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);
+            default -> throw unsupportedAlterTypeAction(String.valueOf(action), line);
+        }
+    }
+
+    /**
+     * Reports whether one {@code ALTER TYPE} action cannot change a modeled
+     * enum type: {@code OWNER TO} and the attribute actions, which belong to a
+     * composite type.
+     */
+    private boolean ignoresAlterTypeAction(AlterType.Action action) {
+        return switch (action) {
+            case OWNER, RENAME_ATTRIBUTE, ATTRIBUTES -> true;
+            default -> false;
+        };
+    }
+
+    /**
+     * Renames one label of an enum type in its position, so the modeled labels
+     * keep PostgreSQL's sort order. A missing old label and a new label the
+     * type already has both fail, as PostgreSQL rejects them.
+     */
+    private void renameEnumLabel(
+        AlterType alterType,
+        String typeName,
+        int index,
+        List<EnumType> enums
+    ) {
+        if (index < 0) {
+            throw typeNotFound(typeName);
+        }
+
+        EnumType enumType = enums.get(index);
+        String label = alterType.getValue().getNotExcapedValue();
+        String newLabel = alterType.getNewValue().getNotExcapedValue();
+
+        int position = enumType.labels().indexOf(label);
+
+        if (position < 0) {
+            throw labelNotFound(typeName, label);
+        }
+
+        if (enumType.labels().contains(newLabel)) {
+            throw labelAlreadyExists(typeName, newLabel);
+        }
+
+        List<String> labels = new ArrayList<>(enumType.labels());
+
+        labels.set(position, newLabel);
+
+        enums.set(index, new EnumType(enumType.name(), labels));
+    }
+
+    /**
+     * Renames one enum type in its position, keeping its labels, and renames
+     * the type of every column of it, scalar and array alike, because a column
+     * names its enum type by that name. A modeled enum of the new name is
+     * removed, because the {@code DROP TYPE} that freed the name is never seen;
+     * a column still naming it keeps that name, so it is modeled as a column of
+     * the renamed enum with its labels, the column PostgreSQL would have
+     * removed.
+     */
+    private void renameEnumType(
+        AlterType alterType,
+        String typeName,
+        int index,
+        List<EnumType> enums,
+        List<Table> tables
+    ) {
+        if (index < 0) {
+            ignoreUnmodeledType(alterType, typeName);
+
+            return;
+        }
+
+        String newName = MultiPartName.unquote(alterType.getNewName());
+        int replaced = indexOfEnum(enums, newName);
+        int renamed = index;
+
+        if (replaced >= 0 && replaced != index) {
+            enums.remove(replaced);
+
+            if (replaced < index) {
+                renamed--;
+            }
+        }
+
+        enums.set(renamed, new EnumType(newName, enums.get(renamed).labels()));
+
+        tables.replaceAll(table -> renameColumnEnumType(table, typeName, newName));
+    }
+
+    /**
+     * Rejects {@code SET SCHEMA} of a modeled enum type, because its columns
+     * keep the type in a namespace sqlcj does not model.
+     */
+    private void moveEnumTypeToSchema(
+        AlterType alterType,
+        int line,
+        String typeName,
+        int index
+    ) {
+        if (index < 0) {
+            ignoreUnmodeledType(alterType, typeName);
+
+            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());
+
+        for (int i = 0; i < columns.size(); i++) {
+            Column column = columns.get(i);
+
+            if (column.enumType() == null || !column.enumType().equalsIgnoreCase(oldName)) {
+                continue;
+            }
+
+            columns.set(
+                i,
+                new Column(
+                    column.name(),
+                    column.type(),
+                    column.nullable(),
+                    column.unsupportedType(),
+                    newName,
+                    column.array(),
+                    column.blankPadded()
+                )
+            );
+        }
+
+        return new Table(table.name(), columns, table.constraints());
     }
 
     /**
      * Inserts one label into an enum type: after the last label by default, and
      * otherwise directly before or after the stated neighbor, so the modeled
-     * labels stay in PostgreSQL's sort order. Adding a value is the only
-     * {@code ALTER TYPE} action sqlcj models; every other action is rejected.
+     * labels stay in PostgreSQL's sort order.
      *
      * <p>As PostgreSQL does, {@code IF NOT EXISTS} is decided by the label
      * alone: a label the type already has is a no-op even when the stated
@@ -1063,10 +1253,6 @@ private IllegalArgumentException typeNotFound(String typeName) {
         return new IllegalArgumentException("Type not found in schema: " + typeName);
     }
 
-    private IllegalArgumentException typeAlreadyExists(String typeName) {
-        return new IllegalArgumentException("Type already exists in schema: " + typeName);
-    }
-
     private IllegalArgumentException labelNotFound(String typeName, String label) {
         return new IllegalArgumentException(
             "Label not found in type %s: %s".formatted(typeName, label)
@@ -1100,9 +1286,10 @@ private UnsupportedOperationException unsupportedAlterTableAction(int line, Stri
         );
     }
 
-    private UnsupportedOperationException unsupportedAlterTypeAction(int line) {
+    /** The failure of one rejected {@code ALTER TYPE} action, naming the action. */
+    private UnsupportedOperationException unsupportedAlterTypeAction(String action, int line) {
         return new UnsupportedOperationException(
-            "Unsupported ALTER TYPE action at line %d".formatted(line)
+            "Unsupported ALTER TYPE action: %s at line %d".formatted(action, line)
         );
     }
 
diff --git a/sqlcj-cli/src/test/java/dev/sqlcj/compiler/PostgresIntegrationTest.java b/sqlcj-cli/src/test/java/dev/sqlcj/compiler/PostgresIntegrationTest.java
index 270b268..44e03da 100644
--- a/sqlcj-cli/src/test/java/dev/sqlcj/compiler/PostgresIntegrationTest.java
+++ b/sqlcj-cli/src/test/java/dev/sqlcj/compiler/PostgresIntegrationTest.java
@@ -204,6 +204,42 @@ title   VARCHAR(255)
         );
         """;
 
+    /**
+     * A snapshot that replaces its enum type the way a migration does: the
+     * replacement is declared beside the original type, the enum column and the
+     * enum array column are retyped, the original type is dropped, and the
+     * replacement is renamed onto its name. One of its labels is then renamed,
+     * so PostgreSQL and sqlcj both end with one type named
+     * {@code stage_setting} carrying the replacement's labels.
+     */
+    private static final String REPLACED_STAGE_SETTING_SCHEMA = """
+        CREATE TYPE stage_setting AS ENUM ('indoor', 'outdoor');
+
+        CREATE TABLE stage_events
+        (
+            id      BIGINT PRIMARY KEY,
+            setting stage_setting,
+            past    stage_setting[],
+            title   VARCHAR(255)
+        );
+
+        CREATE TYPE stage_setting_new AS ENUM ('indoor', 'covered', 'outdoor');
+
+        ALTER TABLE stage_events
+            ALTER COLUMN setting TYPE stage_setting_new
+                USING setting::text::stage_setting_new;
+
+        ALTER TABLE stage_events
+            ALTER COLUMN past TYPE stage_setting_new[]
+                USING past::text[]::stage_setting_new[];
+
+        DROP TYPE stage_setting;
+
+        ALTER TYPE stage_setting_new RENAME TO stage_setting;
+
+        ALTER TYPE stage_setting RENAME VALUE 'covered' TO 'partly covered';
+        """;
+
     /**
      * A snapshot declaring a one-dimensional array of every element type sqlcj
      * maps: each mapped scalar type other than {@code BYTEA}, {@code JSON}, and
@@ -507,6 +543,7 @@ void resetDatabase() throws Exception {
         execute("DROP TABLE IF EXISTS stage_events");
         execute("DROP TABLE IF EXISTS array_values");
         execute("DROP TYPE IF EXISTS stage_setting");
+        execute("DROP TYPE IF EXISTS stage_setting_new");
         execute("DROP TABLE IF EXISTS albums");
         execute("DROP TABLE IF EXISTS studios");
         execute("DROP TYPE IF EXISTS album_kind");
@@ -2007,6 +2044,88 @@ INSERT INTO stage_events (id, setting, title)
         }
     }
 
+    /**
+     * Proves the replace-an-enum migration end to end: the schema that renames
+     * the replacement type onto the replaced name and then renames one of its
+     * labels is run as PostgreSQL DDL, and the generated enum carries the
+     * labels PostgreSQL ends with, in its own sort order. A list predicate over
+     * the retyped column binds its labels as a server array of the renamed
+     * type, which PostgreSQL would reject under the replacement's own name, and
+     * the enum array column is read back as constants of the generated enum.
+     */
+    @Test
+    void shouldExecuteGeneratedCodeOverAReplacedEnumTypeAgainstPostgres() throws Exception {
+        execute(REPLACED_STAGE_SETTING_SCHEMA);
+
+        Path classesDirectory = generateAndCompile(
+            REPLACED_STAGE_SETTING_SCHEMA,
+            """
+                -- name: ListStageEventsBySettings :many
+                SELECT id, setting, past, title
+                FROM stage_events
+                WHERE setting = ANY($1)
+                ORDER BY id;
+                """
+        );
+
+        execute("""
+            INSERT INTO stage_events (id, setting, past, title)
+            VALUES
+                (1, 'indoor', '{indoor}', 'Indoor Stage'),
+                (2, 'partly covered', '{indoor,outdoor}', 'Covered Stage'),
+                (3, 'outdoor', '{outdoor,indoor}', 'Outdoor Stage')
+            """);
+
+        try (URLClassLoader classLoader = classLoader(classesDirectory)) {
+            Class<?> stageSetting = Class.forName(
+                "generated.StageSetting",
+                true,
+                classLoader
+            );
+
+            Object[] constants = stageSetting.getEnumConstants();
+
+            assertEquals(
+                List.of("INDOOR", "PARTLY_COVERED", "OUTDOOR"),
+                Arrays.stream(constants).map(Object::toString).toList()
+            );
+
+            Method label = stageSetting.getMethod("label");
+
+            List<Object> labels = new ArrayList<>();
+
+            for (Object constant : constants) {
+                labels.add(label.invoke(constant));
+            }
+
+            assertEquals(enumLabels("stage_setting"), labels);
+
+            Object repository = newRepository(classLoader);
+
+            Object rows = repository.getClass()
+                .getMethod("listStageEventsBySettings", List.class)
+                .invoke(repository, List.of(constants[0], constants[2]));
+
+            List<Object> titles = new ArrayList<>();
+
+            for (Object row : (List<?>) rows) {
+                titles.add(component(row, "title"));
+            }
+
+            assertEquals(List.of("Indoor Stage", "Outdoor Stage"), titles);
+
+            Object first = ((List<?>) rows).get(0);
+
+            assertEquals(constants[0], component(first, "setting"));
+            assertEquals(List.of(constants[0]), component(first, "past"));
+
+            assertEquals(
+                List.of(constants[2], constants[0]),
+                component(((List<?>) rows).get(1), "past")
+            );
+        }
+    }
+
     /**
      * Proves that a one-dimensional array round trips through generated code
      * for every element type sqlcj maps: a non-empty list holding a
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 0c2a904..17485fc 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
@@ -1279,9 +1279,6 @@ void shouldApplyAModeledActionBesideAnIgnoredConstraintAction() {
                 + "|Unsupported ALTER TABLE action: ALTER COLUMN name SET FOO 1 at line 1",
             "ALTER TABLE users ALTER COLUMN name text;"
                 + "|Unsupported ALTER TABLE action: ALTER COLUMN name text 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",
             "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;"
@@ -2226,11 +2223,20 @@ void shouldIgnoreAddValueIfNotExistsForAnExistingLabel(String statement) {
         delimiter = '|',
         quoteCharacter = '"',
         value = {
-            "CREATE TYPE stage_setting AS ENUM ('covered');|Type already exists in schema: stage_setting",
             "CREATE TYPE shelf_state AS ENUM ('new', 'new');|Label already exists in type shelf_state: new",
             "ALTER TYPE shelf_state ADD VALUE 'stocked';|Type not found in schema: shelf_state",
             "ALTER TYPE stage_setting ADD VALUE 'indoor';|Label already exists in type stage_setting: indoor",
-            "ALTER TYPE stage_setting ADD VALUE 'hybrid' AFTER 'missing';|Label not found in type stage_setting: missing"
+            "ALTER TYPE stage_setting ADD VALUE 'hybrid' AFTER 'missing';|Label not found in type stage_setting: missing",
+            "ALTER TYPE shelf_state RENAME VALUE 'stocked' TO 'kept';"
+                + "|Type not found in schema: shelf_state",
+            "ALTER TYPE stage_setting RENAME VALUE 'missing' TO 'covered';"
+                + "|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"
         }
     )
     void shouldReportTheEnumStatementItCannotApply(String statement, String message) {
@@ -2401,6 +2407,274 @@ void shouldIgnoreDropTypeAndKeepTheModeledEnum() {
         );
     }
 
+    /**
+     * {@code ALTER TYPE ... RENAME VALUE} renames one label in its position, so
+     * the modeled labels keep PostgreSQL's sort order.
+     */
+    @Test
+    void shouldRenameAnEnumLabelInItsPosition() {
+        Schema schema = parser.parse(
+            parser.parse(
+                enumSchema(),
+                "ALTER TYPE stage_setting ADD VALUE 'covered' BEFORE 'outdoor';"
+            ),
+            "ALTER TYPE stage_setting RENAME VALUE 'covered' TO 'partly covered';"
+        );
+
+        assertEquals(
+            List.of(
+                new EnumType("stage_setting", List.of("indoor", "partly covered", "outdoor"))
+            ),
+            schema.enums()
+        );
+    }
+
+    /**
+     * {@code ALTER TYPE ... RENAME TO} renames the enum type in its position,
+     * keeping its labels, and the columns of that type follow it, scalar and
+     * array alike. A column of another enum type keeps its own type.
+     */
+    @Test
+    void shouldRenameAModeledEnumAndTheColumnsOfIt() {
+        Schema schema = parser.parse(
+            parser.parse(
+                parser.parse(enumSchema(), "CREATE TYPE shelf_state AS ENUM ('stocked');"),
+                """
+                    CREATE TABLE stages (
+                        setting       stage_setting NOT NULL,
+                        past_settings stage_setting[],
+                        state         shelf_state
+                    );
+                    """
+            ),
+            "ALTER TYPE stage_setting RENAME TO stage_mood;"
+        );
+
+        assertEquals(
+            List.of(
+                new EnumType("stage_mood", List.of("indoor", "outdoor")),
+                new EnumType("shelf_state", List.of("stocked"))
+            ),
+            schema.enums()
+        );
+
+        assertEquals(
+            List.of(
+                new Column("setting", ColumnType.ENUM, false, null, "stage_mood"),
+                new Column("past_settings", ColumnType.ENUM, true, null, "stage_mood", true),
+                new Column("state", ColumnType.ENUM, true, null, "shelf_state")
+            ),
+            table(schema, "stages").columns()
+        );
+    }
+
+    /**
+     * Both names of a rename are read without their SQL identifier delimiters,
+     * as every other modeled name is.
+     */
+    @Test
+    void shouldUnquoteBothNamesOfARenamedEnumType() {
+        Schema schema = parser.parse(
+            parser.parse(enumSchema(), "CREATE TABLE stages (setting stage_setting);"),
+            "ALTER TYPE \"stage_setting\" RENAME TO \"Stage Mood\";"
+        );
+
+        assertEquals(
+            List.of(new EnumType("Stage Mood", List.of("indoor", "outdoor"))),
+            schema.enums()
+        );
+
+        assertEquals(
+            List.of(new Column("setting", ColumnType.ENUM, true, null, "Stage Mood")),
+            table(schema, "stages").columns()
+        );
+    }
+
+    /**
+     * A {@code CREATE TYPE ... AS ENUM} of a name a modeled enum already has
+     * replaces that enum in its position, because the {@code DROP TYPE} that
+     * freed the name is never seen.
+     */
+    @Test
+    void shouldReplaceAModeledEnumByCreateTypeInItsPosition() {
+        Schema schema = parser.parse(
+            parser.parse(enumSchema(), "CREATE TYPE shelf_state AS ENUM ('stocked');"),
+            "CREATE TYPE stage_setting AS ENUM ('indoor', 'covered', 'outdoor');"
+        );
+
+        assertEquals(
+            List.of(
+                new EnumType("stage_setting", List.of("indoor", "covered", "outdoor")),
+                new EnumType("shelf_state", List.of("stocked"))
+            ),
+            schema.enums()
+        );
+    }
+
+    /**
+     * The replace-an-enum migration that renames the old type away, declares
+     * the new one under the original name, and retypes the column loads, and
+     * the column ends as a column of the newly declared type. The
+     * {@code DROP TYPE} of the renamed type is ignored, so that type stays
+     * modeled.
+     */
+    @Test
+    void shouldLoadTheMigrationThatRenamesTheReplacedEnumAway() {
+        Schema schema = parser.parse(
+            parser.parse(
+                enumSchema(),
+                "CREATE TABLE stages (setting stage_setting NOT NULL);"
+            ),
+            """
+                ALTER TYPE stage_setting RENAME TO stage_setting_old;
+
+                CREATE TYPE stage_setting AS ENUM ('indoor', 'covered', 'outdoor');
+
+                ALTER TABLE stages
+                    ALTER COLUMN setting TYPE stage_setting USING setting::text::stage_setting;
+
+                DROP TYPE stage_setting_old;
+                """
+        );
+
+        assertEquals(
+            List.of(
+                new EnumType("stage_setting_old", List.of("indoor", "outdoor")),
+                new EnumType("stage_setting", List.of("indoor", "covered", "outdoor"))
+            ),
+            schema.enums()
+        );
+
+        assertEquals(
+            List.of(new Column("setting", ColumnType.ENUM, false, null, "stage_setting")),
+            table(schema, "stages").columns()
+        );
+    }
+
+    /**
+     * The replace-an-enum migration that declares the new type beside the old
+     * one, retypes the columns, and renames the new type onto the original name
+     * loads: the one modeled enum carries the original name and the new labels,
+     * and both columns name it again.
+     */
+    @Test
+    void shouldLoadTheMigrationThatRenamesTheNewEnumOntoTheReplacedName() {
+        Schema schema = parser.parse(
+            parser.parse(
+                enumSchema(),
+                """
+                    CREATE TABLE stages (
+                        setting       stage_setting NOT NULL,
+                        past_settings stage_setting[]
+                    );
+                    """
+            ),
+            """
+                CREATE TYPE stage_setting_new AS ENUM ('indoor', 'covered', 'outdoor');
+
+                ALTER TABLE stages
+                    ALTER COLUMN setting TYPE stage_setting_new
+                        USING setting::text::stage_setting_new;
+
+                ALTER TABLE stages
+                    ALTER COLUMN past_settings TYPE stage_setting_new[]
+                        USING past_settings::text[]::stage_setting_new[];
+
+                DROP TYPE stage_setting;
+
+                ALTER TYPE stage_setting_new RENAME TO stage_setting;
+                """
+        );
+
+        assertEquals(
+            List.of(
+                new EnumType("stage_setting", List.of("indoor", "covered", "outdoor"))
+            ),
+            schema.enums()
+        );
+
+        assertEquals(
+            List.of(
+                new Column("setting", ColumnType.ENUM, false, null, "stage_setting"),
+                new Column("past_settings", ColumnType.ENUM, true, null, "stage_setting", true)
+            ),
+            table(schema, "stages").columns()
+        );
+    }
+
+    /**
+     * {@code OWNER TO} and the attribute actions, which belong to a composite
+     * type, cannot change a modeled enum and are ignored without the stated
+     * type being resolved at all, so a type sqlcj does not model, qualified or
+     * not, does not fail.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TYPE stage_setting OWNER TO app;",
+            "ALTER TYPE status OWNER TO app;",
+            "ALTER TYPE public.status OWNER TO app;",
+            "ALTER TYPE stage_setting RENAME ATTRIBUTE a TO b;",
+            "ALTER TYPE status RENAME ATTRIBUTE a TO b;",
+            "ALTER TYPE stage_setting ADD ATTRIBUTE c text;",
+            "ALTER TYPE stage_setting DROP ATTRIBUTE c;",
+            "ALTER TYPE stage_setting ALTER ATTRIBUTE c TYPE int;",
+            "ALTER TYPE status ADD ATTRIBUTE c text;"
+        }
+    )
+    void shouldIgnoreTheAlterTypeActionsThatCannotChangeAModeledEnum(String statement) {
+        Schema schema = parser.parse(enumSchema(), statement);
+
+        assertEquals(
+            List.of(new EnumType("stage_setting", List.of("indoor", "outdoor"))),
+            schema.enums()
+        );
+    }
+
+    /**
+     * {@code RENAME TO} and {@code SET SCHEMA} of a type sqlcj does not model
+     * are ignored, because such a type is none of its enum types.
+     */
+    @ParameterizedTest
+    @ValueSource(
+        strings = {
+            "ALTER TYPE status RENAME TO state;",
+            "ALTER TYPE status SET SCHEMA archive;"
+        }
+    )
+    void shouldIgnoreRenamingAndMovingATypeItDoesNotModel(String statement) {
+        Schema schema = parser.parse(enumSchema(), statement);
+
+        assertEquals(
+            List.of(new EnumType("stage_setting", List.of("indoor", "outdoor"))),
+            schema.enums()
+        );
+    }
+
+    /**
+     * {@code SET SCHEMA} of a modeled enum is rejected, because its columns
+     * keep the type in a namespace sqlcj does not model. The failure names the
+     * action and the line its own statement begins on.
+     */
+    @Test
+    void shouldRejectSetSchemaOfAModeledEnum() {
+        Schema schema = enumSchema();
+
+        UnsupportedOperationException exception = assertThrows(
+            UnsupportedOperationException.class,
+            () -> parser.parse(schema, """
+                ALTER TYPE stage_setting OWNER TO app;
+
+                ALTER TYPE stage_setting SET SCHEMA archive;
+                """)
+        );
+
+        assertEquals(
+            "Unsupported ALTER TYPE action: SET SCHEMA archive at line 3",
+            exception.getMessage()
+        );
+    }
+
     /** A schema declaring the enum type the enum tests apply statements to. */
     private Schema enumSchema() {
         return parser.parse("CREATE TYPE stage_setting AS ENUM ('indoor', 'outdoor');");