Apply enum pre-DDL and placeholder substitution in Table.alter

Table.alter skipped both steps declare performs on adapter output: it
never substituted the PostgreSQL schema placeholder, and never issued
the adapter's pending CREATE TYPE. Adding an enum attribute therefore
emitted a literal "{database}"."enum_<hash>" against a type that was
never created.

declare.alter now accepts an optional schema_name and returns the
pre-DDL alongside the ALTER clauses. The pending types are drained
between the two prepare_declare calls, since both register types as a
side effect and the old definition's types already exist; what the old
parse registers is discarded so it cannot leak into the next declare
on the same adapter.

Adding a non-primary attribute also emitted MySQL's AFTER positioning
clause, which PostgreSQL has no equivalent for. Gate it behind a new
supports_column_position adapter property, dropping the position
before it can force a statement so a reorder-only change stays a
no-op rather than becoming a positionless MODIFY.

Author: MilagrosMarin

src/datajoint/adapters/base.py

@@ -617,6 +617,21 @@ def supports_inline_indexes(self) -> bool:
         """
         return True  # Default for MySQL, override in PostgreSQL
 
+    @property
+    def supports_column_position(self) -> bool:
+        """
+        Whether ALTER TABLE can place a column at a position (``AFTER x``).
+
+        MySQL supports it. PostgreSQL has no such clause and always appends,
+        so the position is dropped rather than emitted.
+
+        Returns
+        -------
+        bool
+            True for MySQL, False for PostgreSQL.
+        """
+        return True  # Default for MySQL, override in PostgreSQL
+
     @property
     def auto_indexes_foreign_keys(self) -> bool:
         """

src/datajoint/adapters/postgres.py

@@ -720,6 +720,14 @@ def supports_inline_indexes(self) -> bool:
         """
         return False
 
+    @property
+    def supports_column_position(self) -> bool:
+        """
+        PostgreSQL has no ``AFTER`` clause in ALTER TABLE; added columns are
+        always appended.
+        """
+        return False
+
     @property
     def auto_indexes_foreign_keys(self) -> bool:
         """

src/datajoint/declare.py

@@ -649,6 +649,10 @@ def _make_attribute_alter(new: list[str], old: list[str], primary_key: list[str]
                 else:
                     if idx >= 1 and old_names[idx - 1] != (prev[1] or prev[0]):
                         after = prev[0]
+            if not adapter.supports_column_position:
+                # Without an AFTER clause a reorder-only change has nothing to
+                # emit, so drop the position before it can force a statement.
+                after = None
             if new_def not in old or after:
                 # Determine command type
                 if (old_name or new_name) not in old_names:
@@ -667,7 +671,14 @@ def _make_attribute_alter(new: list[str], old: list[str], primary_key: list[str]
     return sql
 
 
-def alter(definition: str, old_definition: str, context: dict, adapter) -> tuple[list[str], list[str]]:
+def alter(
+    definition: str,
+    old_definition: str,
+    context: dict,
+    adapter,
+    *,
+    schema_name: str | None = None,
+) -> tuple[list[str], list[str], list[str]]:
     """
     Generate SQL ALTER commands for table definition changes.
 
@@ -681,14 +692,19 @@ def alter(definition: str, old_definition: str, context: dict, adapter) -> tuple
         Namespace for resolving foreign key references.
     adapter : DatabaseAdapter
         Database adapter for backend-specific SQL generation.
+    schema_name : str, optional
+        Schema the table lives in. Required to collect pre-DDL for backends that
+        declare column types separately (PostgreSQL enums); omitting it yields an
+        empty ``pre_ddl``.
 
     Returns
     -------
     tuple
-        Two-element tuple:
+        Three-element tuple:
 
         - sql : list[str] - SQL ALTER commands
         - new_stores : list[str] - New external stores used
+        - pre_ddl : list[str] - DDL to run before the ALTER (e.g. CREATE TYPE)
 
     Raises
     ------
@@ -705,6 +721,15 @@ def alter(definition: str, old_definition: str, context: dict, adapter) -> tuple
         _fk_attribute_map,
         _column_comments,
     ) = prepare_declare(definition, context, adapter)
+
+    # prepare_declare registers backend types (PostgreSQL enums) on the adapter as
+    # a side effect. Drain them here, between the two parses: the old definition's
+    # types already exist in the database, so draining after both would emit
+    # CREATE TYPE for those as well.
+    pre_ddl = []
+    if schema_name and hasattr(adapter, "get_pending_enum_ddl"):
+        pre_ddl.extend(adapter.get_pending_enum_ddl(schema_name))
+
     (
         table_comment_,
         primary_key_,
@@ -716,6 +741,11 @@ def alter(definition: str, old_definition: str, context: dict, adapter) -> tuple
         _column_comments_,
     ) = prepare_declare(old_definition, context, adapter)
 
+    # Discard what the old definition registered, so it cannot leak into the next
+    # declare() on this adapter (get_pending_enum_ddl clears as it reads).
+    if schema_name and hasattr(adapter, "get_pending_enum_ddl"):
+        adapter.get_pending_enum_ddl(schema_name)
+
     # analyze differences between declarations
     sql = list()
     if primary_key != primary_key_:
@@ -731,7 +761,7 @@ def alter(definition: str, old_definition: str, context: dict, adapter) -> tuple
         # For PostgreSQL: would need COMMENT ON TABLE, but that's not an ALTER TABLE clause
         # Keep MySQL syntax for now (ALTER TABLE ... COMMENT="...")
         sql.append(f'COMMENT="{table_comment}"')
-    return sql, [e for e in external_stores if e not in external_stores_]
+    return sql, [e for e in external_stores if e not in external_stores_], pre_ddl
 
 
 def _parse_index_args(args: str) -> list[str]:

src/datajoint/table.py

@@ -322,14 +322,33 @@ def alter(self, prompt=True, context=None):
             context = dict(frame.f_globals, **frame.f_locals)
             del frame
         old_definition = self.describe(context=context)
-        sql, _external_stores = alter(self.definition, old_definition, context, self.connection.adapter)
+        sql, _external_stores, pre_ddl = alter(
+            self.definition,
+            old_definition,
+            context,
+            self.connection.adapter,
+            schema_name=self.database,
+        )
         if not sql:
             if prompt:
                 logger.warning("Nothing to alter.")
         else:
-            sql = "ALTER TABLE {tab}\n\t".format(tab=self.full_table_name) + ",\n\t".join(sql)
+            # Same two steps declare() performs on its own output: substitute the
+            # adapter's schema placeholder, and issue any pre-DDL the attribute
+            # types depend on. The attribute SQL is joined in after the format
+            # call, so it never passes through str.format.
+            sql = _substitute_database(
+                "ALTER TABLE {tab}\n\t".format(tab=self.full_table_name) + ",\n\t".join(sql),
+                self.database,
+            )
             if not prompt or user_choice(sql + "\n\nExecute?") == "yes":
                 try:
+                    for ddl in pre_ddl:
+                        try:
+                            self.connection.query(_substitute_database(ddl, self.database))
+                        except Exception:
+                            # Ignore errors (type may already exist)
+                            pass
                     self.connection.query(sql)
                 except AccessError:
                     # skip if no create privilege

tests/integration/test_multi_backend.py

@@ -167,3 +167,46 @@ class Commented(dj.Manual):
 
     # Cleanup
     schema.drop()
+
+
+@pytest.mark.backend_agnostic
+def test_alter_adds_enum_attribute(connection_by_backend, backend, prefix):
+    """Altering a table to add an enum attribute works on both backends.
+
+    On PostgreSQL an enum column's type is emitted as a schema-qualified
+    placeholder and the type must be created before the ALTER runs, so this
+    exercises both the placeholder substitution and the pre-DDL path.
+    """
+    schema = dj.Schema(
+        f"{prefix}_multi_backend_{backend}_alter_enum",
+        connection=connection_by_backend,
+    )
+
+    @schema
+    class Subject(dj.Manual):
+        definition = """
+        subject_id : int32
+        ---
+        species : enum('mouse', 'rat')
+        """
+
+    assert Subject.is_declared
+
+    # A second enum with different values resolves to a distinct type name, so
+    # the altered column cannot reuse the type created at declaration.
+    Subject.definition = """
+    subject_id : int32
+    ---
+    species : enum('mouse', 'rat')
+    status  : enum('active', 'retired', 'transferred')
+    """
+    Subject.alter(prompt=False)
+
+    heading = Subject().heading
+    assert "status" in heading.names
+
+    # The added column round-trips a value from its own domain.
+    Subject.insert1({"subject_id": 1, "species": "mouse", "status": "active"})
+    assert (Subject & {"subject_id": 1}).fetch1("status") == "active"
+
+    schema.drop()