fix: Clean up PostgreSQL enum types when dropping tables

When a table with enum columns is dropped, the associated enum types
should also be cleaned up to avoid orphaned types in the schema.

Changes:
- Added get_table_enum_types_sql() to query enum types used by a table
- Added drop_enum_type_ddl() to generate DROP TYPE IF EXISTS CASCADE
- Updated drop_quick() to:
  1. Query for enum types before dropping the table
  2. Drop the table
  3. Clean up enum types (best-effort, ignores errors if type is shared)

The cleanup uses CASCADE to handle any remaining dependencies and
ignores errors since enum types may be shared across tables.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dimitri-yatsenko

src/datajoint/adapters/postgres.py

@@ -1248,3 +1248,74 @@ def drop_enum_type_sql(self, schema: str, table: str, column: str) -> str:
         """
         type_name = f"{schema}_{table}_{column}_enum"
         return f"DROP TYPE IF EXISTS {self.quote_identifier(type_name)} CASCADE"
+
+    def get_table_enum_types_sql(self, schema_name: str, table_name: str) -> str:
+        """
+        Query to get enum types used by a table's columns.
+
+        Parameters
+        ----------
+        schema_name : str
+            Schema name.
+        table_name : str
+            Table name.
+
+        Returns
+        -------
+        str
+            SQL query that returns enum type names (schema-qualified).
+        """
+        return f"""
+            SELECT DISTINCT
+                n.nspname || '.' || t.typname as enum_type
+            FROM pg_catalog.pg_type t
+            JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+            JOIN pg_catalog.pg_attribute a ON a.atttypid = t.oid
+            JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+            JOIN pg_catalog.pg_namespace cn ON cn.oid = c.relnamespace
+            WHERE t.typtype = 'e'
+            AND cn.nspname = {self.quote_string(schema_name)}
+            AND c.relname = {self.quote_string(table_name)}
+        """
+
+    def drop_enum_types_for_table(self, schema_name: str, table_name: str) -> list[str]:
+        """
+        Generate DROP TYPE statements for all enum types used by a table.
+
+        Parameters
+        ----------
+        schema_name : str
+            Schema name.
+        table_name : str
+            Table name.
+
+        Returns
+        -------
+        list[str]
+            List of DROP TYPE IF EXISTS statements.
+        """
+        # Returns list of DDL statements - caller should execute query first
+        # to get actual enum types, then call this with results
+        return []  # Placeholder - actual implementation requires query execution
+
+    def drop_enum_type_ddl(self, enum_type_name: str) -> str:
+        """
+        Generate DROP TYPE IF EXISTS statement for a PostgreSQL enum.
+
+        Parameters
+        ----------
+        enum_type_name : str
+            Fully qualified enum type name (schema.typename).
+
+        Returns
+        -------
+        str
+            DROP TYPE IF EXISTS statement with CASCADE.
+        """
+        # Split schema.typename and quote each part
+        parts = enum_type_name.split(".")
+        if len(parts) == 2:
+            qualified_name = f"{self.quote_identifier(parts[0])}.{self.quote_identifier(parts[1])}"
+        else:
+            qualified_name = self.quote_identifier(enum_type_name)
+        return f"DROP TYPE IF EXISTS {qualified_name} CASCADE"

src/datajoint/table.py

@@ -1052,9 +1052,31 @@ def drop_quick(self):
 
             delete_table_lineages(self.connection, self.database, self.table_name)
 
+            # For PostgreSQL, get enum types used by this table before dropping
+            # (we need to query this before the table is dropped)
+            enum_types_to_drop = []
+            adapter = self.connection.adapter
+            if hasattr(adapter, "get_table_enum_types_sql"):
+                try:
+                    enum_query = adapter.get_table_enum_types_sql(self.database, self.table_name)
+                    result = self.connection.query(enum_query)
+                    enum_types_to_drop = [row[0] for row in result.fetchall()]
+                except Exception:
+                    pass  # Ignore errors - enum cleanup is best-effort
+
             query = "DROP TABLE %s" % self.full_table_name
             self.connection.query(query)
             logger.info("Dropped table %s" % self.full_table_name)
+
+            # For PostgreSQL, clean up enum types after dropping the table
+            if enum_types_to_drop and hasattr(adapter, "drop_enum_type_ddl"):
+                for enum_type in enum_types_to_drop:
+                    try:
+                        drop_ddl = adapter.drop_enum_type_ddl(enum_type)
+                        self.connection.query(drop_ddl)
+                        logger.debug("Dropped enum type %s" % enum_type)
+                    except Exception:
+                        pass  # Ignore errors - type may be used by other tables
         else:
             logger.info("Nothing to drop: table %s is not declared" % self.full_table_name)