Use <djblob> for automatic serialization, fix is_blob detection

Type system changes:
- Core type `blob` stores raw bytes without serialization
- Built-in type `<djblob>` handles automatic serialization/deserialization
- Update jobs table to use <djblob> for key and error_stack columns
- Remove enable_python_native_blobs config check (always enabled)

Bug fixes:
- Fix is_blob detection to include NATIVE_BLOB types (longblob, mediumblob, etc.)
- Fix original_type fallback when None
- Fix test_type_aliases to use lowercase keys for CORE_TYPE_SQL lookup
- Allow None context for built-in types in heading initialization
- Update native type warning message wording

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

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

Author: dimitri-yatsenko

src/datajoint/blob.py

@@ -13,7 +13,6 @@
 import numpy as np
 
 from .errors import DataJointError
-from .settings import config
 
 deserialize_lookup = {
     0: {"dtype": None, "scalar_type": "UNKNOWN"},
@@ -89,12 +88,6 @@ def __init__(self, squeeze=False):
         self.protocol = None
 
     def set_dj0(self):
-        if not config.get("enable_python_native_blobs"):
-            raise DataJointError(
-                """v0.12+ python native blobs disabled.
-                See also: https://github.com/datajoint/datajoint-python#python-native-blobs"""
-            )
-
         self.protocol = b"dj0\0"  # when using new blob features
 
     def squeeze(self, array, convert_to_scalar=True):

src/datajoint/declare.py

@@ -530,9 +530,9 @@ def compile_attribute(line, in_key, foreign_key_sql, context):
         match["comment"] = ":{type}:{comment}".format(**match)
         substitute_special_type(match, category, foreign_key_sql, context)
     elif category in NATIVE_TYPES:
-        # Non-standard native type - warn user
+        # Native type - warn user
         logger.warning(
-            f"Non-standard native type '{match['type']}' in attribute '{match['name']}'. "
+            f"Native type '{match['type']}' is used in attribute '{match['name']}'. "
             "Consider using a core DataJoint type for better portability."
         )
 

src/datajoint/fetch.py

@@ -83,7 +83,7 @@ def _get(connection, attr, data, squeeze, download_path):
         return uuid_module.UUID(bytes=data)
 
     if attr.is_blob:
-        return data  # raw bytes
+        return data  # raw bytes (use <djblob> for automatic deserialization)
 
     # Native types - pass through unchanged
     return data

src/datajoint/heading.py

@@ -286,7 +286,7 @@ def _init_from_database(self):
                 autoincrement=bool(re.search(r"auto_increment", attr["Extra"], flags=re.I)),
                 numeric=any(TYPE_PATTERN[t].match(attr["type"]) for t in ("DECIMAL", "INTEGER", "FLOAT")),
                 string=any(TYPE_PATTERN[t].match(attr["type"]) for t in ("ENUM", "TEMPORAL", "STRING")),
-                is_blob=bool(TYPE_PATTERN["BLOB"].match(attr["type"])),
+                is_blob=any(TYPE_PATTERN[t].match(attr["type"]) for t in ("BLOB", "NATIVE_BLOB")),
                 uuid=False,
                 json=bool(TYPE_PATTERN["JSON"].match(attr["type"])),
                 adapter=None,
@@ -316,7 +316,7 @@ def _init_from_database(self):
 
             # process AttributeTypes (adapted types in angle brackets)
             if special and TYPE_PATTERN["ADAPTED"].match(attr["type"]):
-                assert context is not None, "Declaration context is not set"
+                # Context can be None for built-in types that are globally registered
                 adapter_name = special["type"]
                 try:
                     adapter_result = get_adapter(context, adapter_name)
@@ -338,7 +338,7 @@ 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"])
+                original_type = attr["original_type"] or attr["type"]
                 try:
                     category = next(c for c in SPECIAL_TYPES if TYPE_PATTERN[c].match(original_type))
                 except StopIteration:

src/datajoint/jobs.py

@@ -4,7 +4,6 @@
 from .errors import DuplicateError
 from .hash import key_hash
 from .heading import Heading
-from .settings import config
 from .table import Table
 
 ERROR_MESSAGE_LENGTH = 2047
@@ -27,9 +26,9 @@ def __init__(self, conn, database):
         key_hash  :char(32)  # key hash
         ---
         status  :enum('reserved','error','ignore')  # if tuple is missing, the job is available
-        key=null  :blob  # structure containing the key
+        key=null  :<djblob>  # structure containing the key
         error_message=""  :varchar({error_message_length})  # error message returned if failed
-        error_stack=null  :mediumblob  # error stack if failed
+        error_stack=null  :<djblob>  # error stack if failed
         user="" :varchar(255) # database user
         host=""  :varchar(255)  # system hostname
         pid=0  :int unsigned  # system process id
@@ -76,8 +75,7 @@ def reserve(self, table_name, key):
             user=self._user,
         )
         try:
-            with config.override(enable_python_native_blobs=True):
-                self.insert1(job, ignore_extra_fields=True)
+            self.insert1(job, ignore_extra_fields=True)
         except DuplicateError:
             return False
         return True
@@ -107,8 +105,7 @@ def ignore(self, table_name, key):
             user=self._user,
         )
         try:
-            with config.override(enable_python_native_blobs=True):
-                self.insert1(job, ignore_extra_fields=True)
+            self.insert1(job, ignore_extra_fields=True)
         except DuplicateError:
             return False
         return True
@@ -135,20 +132,19 @@ def error(self, table_name, key, error_message, error_stack=None):
         """
         if len(error_message) > ERROR_MESSAGE_LENGTH:
             error_message = error_message[: ERROR_MESSAGE_LENGTH - len(TRUNCATION_APPENDIX)] + TRUNCATION_APPENDIX
-        with config.override(enable_python_native_blobs=True):
-            self.insert1(
-                dict(
-                    table_name=table_name,
-                    key_hash=key_hash(key),
-                    status="error",
-                    host=platform.node(),
-                    pid=os.getpid(),
-                    connection_id=self.connection.connection_id,
-                    user=self._user,
-                    key=key,
-                    error_message=error_message,
-                    error_stack=error_stack,
-                ),
-                replace=True,
-                ignore_extra_fields=True,
-            )
+        self.insert1(
+            dict(
+                table_name=table_name,
+                key_hash=key_hash(key),
+                status="error",
+                host=platform.node(),
+                pid=os.getpid(),
+                connection_id=self.connection.connection_id,
+                user=self._user,
+                key=key,
+                error_message=error_message,
+                error_stack=error_stack,
+            ),
+            replace=True,
+            ignore_extra_fields=True,
+        )

src/datajoint/table.py

@@ -975,8 +975,7 @@ def __make_placeholder(self, name, value, ignore_extra_fields=False, row=None):
             # Numeric - convert to string
             elif attr.numeric:
                 value = str(int(value) if isinstance(value, bool) else value)
-            # Blob - pass through as bytes (adapters handle serialization)
-            # elif attr.is_blob: pass through unchanged
+            # Blob - pass through as bytes (use <djblob> for automatic serialization)
 
         return name, placeholder, value
 

tests/test_type_aliases.py

@@ -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 CORE_TYPE_SQL
+        assert category.lower() in CORE_TYPE_SQL  # CORE_TYPE_SQL uses lowercase keys
 
     @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 = CORE_TYPE_SQL[category]
+        mysql_type = CORE_TYPE_SQL[category.lower()]  # CORE_TYPE_SQL uses lowercase keys
         assert mysql_type == expected_mysql_type
 
     @pytest.mark.parametrize(