Fix table_name and uuid type resolution bugs

- Fix Table.table_name property to delegate to metaclass for UserTable subclasses
  (table_name was returning None instead of computed name)
- Fix heading type loading to preserve database type for core types (uuid, etc.)
  instead of overwriting with alias from comment
- Add original_type field to Attribute for storing the alias while keeping
  the actual SQL type in type field
- Fix tests: remove obsolete test_external.py, update resolve_dtype tests
  to expect 3 return values, update type alias tests to use CORE_TYPE_SQL
- Update pyproject.toml pytest_env to use D: prefix for default-only vars

Test results improved from 174 passed/284 errors to 381 passed/62 errors.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: dimitri-yatsenko

pyproject.toml

@@ -153,19 +153,19 @@ skip = ".git,*.pdf,*.svg,*.csv,*.ipynb,*.drawio"
 ignore-words-list = "rever,numer,astroid"
 
 [tool.pytest_env]
-# Default environment variables for tests
-# When running from host: DJ_HOST=localhost (set via pixi task)
+# Default environment variables for tests (D: prefix = only set if not defined)
+# When running from host: DJ_HOST=localhost (set via command line or pixi task)
 # When running in devcontainer/docker: DJ_HOST=db (docker-compose service name)
-DJ_HOST="db"
-DJ_PORT="3306"
-DJ_USER="root"
-DJ_PASS="password"
-DJ_TEST_USER="datajoint"
-DJ_TEST_PASSWORD="datajoint"
-S3_ENDPOINT="minio:9000"
-S3_ACCESS_KEY="datajoint"
-S3_SECRET_KEY="datajoint"
-S3_BUCKET="datajoint.test"
+"D:DJ_HOST" = "db"
+"D:DJ_PORT" = "3306"
+"D:DJ_USER" = "root"
+"D:DJ_PASS" = "password"
+"D:DJ_TEST_USER" = "datajoint"
+"D:DJ_TEST_PASSWORD" = "datajoint"
+"D:S3_ENDPOINT" = "minio:9000"
+"D:S3_ACCESS_KEY" = "datajoint"
+"D:S3_SECRET_KEY" = "datajoint"
+"D:S3_BUCKET" = "datajoint.test"
 
 
 [tool.pixi.workspace]

src/datajoint/heading.py

@@ -50,6 +50,7 @@ def decode(self, stored, *, key=None):
 default_attribute_properties = dict(  # these default values are set in computed attributes
     name=None,
     type="expression",
+    original_type=None,  # For core types, stores the alias (e.g., "uuid") while type has db type ("binary(16)")
     in_key=False,
     nullable=False,
     default=None,
@@ -292,6 +293,7 @@ def _init_from_database(self):
                 store=None,
                 attribute_expression=None,
                 is_hidden=attr["name"].startswith("_"),
+                original_type=None,  # May be set later for core type aliases
             )
 
             if any(TYPE_PATTERN[t].match(attr["type"]) for t in ("INTEGER", "FLOAT")):
@@ -303,7 +305,14 @@ def _init_from_database(self):
             special = re.match(r":(?P<type>[^:]+):(?P<comment>.*)", attr["comment"])
             if special:
                 special = special.groupdict()
-                attr.update(special)
+                attr["comment"] = special["comment"]  # Always update the comment
+                # Only update the type for adapted types (angle brackets)
+                # Core types (uuid, float32, etc.) keep the database type for SQL
+                if special["type"].startswith("<"):
+                    attr["type"] = special["type"]
+                else:
+                    # Store the original type name for display but keep db_type for SQL
+                    attr["original_type"] = special["type"]
 
             # process AttributeTypes (adapted types in angle brackets)
             if special and TYPE_PATTERN["ADAPTED"].match(attr["type"]):
@@ -328,18 +337,15 @@ def _init_from_database(self):
 
             # Handle core type aliases (uuid, float32, etc.)
             if special:
+                # Check original_type for core type detection (not attr["type"] which is now db type)
+                original_type = attr.get("original_type", attr["type"])
                 try:
-                    category = next(c for c in SPECIAL_TYPES if TYPE_PATTERN[c].match(attr["type"]))
+                    category = next(c for c in SPECIAL_TYPES if TYPE_PATTERN[c].match(original_type))
                 except StopIteration:
-                    if attr["type"].startswith("external"):
-                        url = (
-                            "https://docs.datajoint.io/python/admin/5-blob-config.html"
-                            "#migration-between-datajoint-v0-11-and-v0-12"
-                        )
+                    if original_type.startswith("external"):
                         raise DataJointError(
-                            "Legacy datatype `{type}`. Migrate your external stores to datajoint 0.12: {url}".format(
-                                url=url, **attr
-                            )
+                            f"Legacy datatype `{original_type}`. Migrate your external stores to datajoint 0.12: "
+                            "https://docs.datajoint.io/python/admin/5-blob-config.html#migration-between-datajoint-v0-11-and-v0-12"
                         )
                     # Not a special type - that's fine, could be native passthrough
                     category = None

src/datajoint/table.py

@@ -77,6 +77,10 @@ class Table(QueryExpression):
 
     @property
     def table_name(self):
+        # For UserTable subclasses, table_name is computed by the metaclass.
+        # Delegate to the class's table_name if _table_name is not set.
+        if self._table_name is None:
+            return type(self).table_name
         return self._table_name
 
     @property

tests/test_attribute_type.py

@@ -248,9 +248,10 @@ def teardown_method(self):
 
     def test_resolve_native_dtype(self):
         """Test resolving a native dtype."""
-        final_dtype, chain = resolve_dtype("longblob")
+        final_dtype, chain, store = resolve_dtype("longblob")
         assert final_dtype == "longblob"
         assert chain == []
+        assert store is None
 
     def test_resolve_custom_dtype(self):
         """Test resolving a custom dtype."""
@@ -266,10 +267,11 @@ def encode(self, value, *, key=None):
             def decode(self, stored, *, key=None):
                 return stored
 
-        final_dtype, chain = resolve_dtype("<test_resolve>")
+        final_dtype, chain, store = resolve_dtype("<test_resolve>")
         assert final_dtype == "varchar(100)"
         assert len(chain) == 1
         assert chain[0].type_name == "test_resolve"
+        assert store is None
 
     def test_resolve_chained_dtype(self):
         """Test resolving a chained dtype."""
@@ -296,11 +298,12 @@ def encode(self, value, *, key=None):
             def decode(self, stored, *, key=None):
                 return stored
 
-        final_dtype, chain = resolve_dtype("<test_outer>")
+        final_dtype, chain, store = resolve_dtype("<test_outer>")
         assert final_dtype == "longblob"
         assert len(chain) == 2
         assert chain[0].type_name == "test_outer"
         assert chain[1].type_name == "test_inner"
+        assert store is None
 
     def test_circular_reference_detection(self):
         """Test that circular type references are detected."""

tests/test_external.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from datajoint.declare import SQL_TYPE_ALIASES, SPECIAL_TYPES, match_type
+from datajoint.declare import CORE_TYPE_SQL, SPECIAL_TYPES, match_type
 
 from .schema_type_aliases import TypeAliasTable, TypeAliasPrimaryKey, TypeAliasNullable
 
@@ -33,7 +33,7 @@ def test_type_alias_pattern_matching(self, alias, expected_category):
         category = match_type(alias)
         assert category == expected_category
         assert category in SPECIAL_TYPES
-        assert category in SQL_TYPE_ALIASES
+        assert category in CORE_TYPE_SQL
 
     @pytest.mark.parametrize(
         "alias,expected_mysql_type",
@@ -54,7 +54,7 @@ def test_type_alias_pattern_matching(self, alias, expected_category):
     def test_type_alias_mysql_mapping(self, alias, expected_mysql_type):
         """Test that type aliases map to correct MySQL types."""
         category = match_type(alias)
-        mysql_type = SQL_TYPE_ALIASES[category]
+        mysql_type = CORE_TYPE_SQL[category]
         assert mysql_type == expected_mysql_type
 
     @pytest.mark.parametrize(