Add type aliases for numeric types (e.g. uint8, float64)

docs/src/design/tables/attributes.md

@@ -77,6 +77,42 @@ sending/receiving an opaque data file to/from a DataJoint pipeline.
 - `filepath@store`: a [filepath](filepath.md) used to link non-DataJoint managed files
 into a DataJoint pipeline.
 
+## Numeric type aliases
+
+DataJoint provides convenient type aliases that map to standard MySQL numeric types.
+These aliases use familiar naming conventions from NumPy and other numerical computing
+libraries, making table definitions more readable and explicit about data precision.
+
+| Alias | MySQL Type | Description |
+|-------|------------|-------------|
+| `bool` | `tinyint` | Boolean value (0 or 1) |
+| `int8` | `tinyint` | 8-bit signed integer (-128 to 127) |
+| `uint8` | `tinyint unsigned` | 8-bit unsigned integer (0 to 255) |
+| `int16` | `smallint` | 16-bit signed integer (-32,768 to 32,767) |
+| `uint16` | `smallint unsigned` | 16-bit unsigned integer (0 to 65,535) |
+| `int32` | `int` | 32-bit signed integer |
+| `uint32` | `int unsigned` | 32-bit unsigned integer |
+| `int64` | `bigint` | 64-bit signed integer |
+| `uint64` | `bigint unsigned` | 64-bit unsigned integer |
+| `float32` | `float` | 32-bit single-precision floating point |
+| `float64` | `double` | 64-bit double-precision floating point |
+
+Example usage:
+
+```python
+@schema
+class Measurement(dj.Manual):
+    definition = """
+    measurement_id : int
+    ---
+    temperature : float32       # single-precision temperature reading
+    precise_value : float64     # double-precision measurement
+    sample_count : uint32       # unsigned 32-bit counter
+    sensor_flags : uint8        # 8-bit status flags
+    is_valid : bool             # boolean flag
+    """
+```
+
 ## Datatypes not (yet) supported
 
 -  `binary`

src/datajoint/declare.py

@@ -15,6 +15,21 @@
 from .settings import config
 
 UUID_DATA_TYPE = "binary(16)"
+
+# Type aliases for numeric types
+TYPE_ALIASES = {
+    "FLOAT32": "float",
+    "FLOAT64": "double",
+    "INT64": "bigint",
+    "UINT64": "bigint unsigned",
+    "INT32": "int",
+    "UINT32": "int unsigned",
+    "INT16": "smallint",
+    "UINT16": "smallint unsigned",
+    "INT8": "tinyint",
+    "UINT8": "tinyint unsigned",
+    "BOOL": "tinyint",
+}
 MAX_TABLE_NAME_LENGTH = 64
 CONSTANT_LITERALS = {
     "CURRENT_TIMESTAMP",
@@ -25,13 +40,25 @@
 TYPE_PATTERN = {
     k: re.compile(v, re.I)
     for k, v in dict(
+        # Type aliases must come before INTEGER and FLOAT patterns to avoid prefix matching
+        FLOAT32=r"float32$",
+        FLOAT64=r"float64$",
+        INT64=r"int64$",
+        UINT64=r"uint64$",
+        INT32=r"int32$",
+        UINT32=r"uint32$",
+        INT16=r"int16$",
+        UINT16=r"uint16$",
+        INT8=r"int8$",
+        UINT8=r"uint8$",
+        BOOL=r"bool$",  # aliased to tinyint
+        # Native MySQL types
         INTEGER=r"((tiny|small|medium|big|)int|integer)(\s*\(.+\))?(\s+unsigned)?(\s+auto_increment)?|serial$",
         DECIMAL=r"(decimal|numeric)(\s*\(.+\))?(\s+unsigned)?$",
         FLOAT=r"(double|float|real)(\s*\(.+\))?(\s+unsigned)?$",
         STRING=r"(var)?char\s*\(.+\)$",
         JSON=r"json$",
         ENUM=r"enum\s*\(.+\)$",
-        BOOL=r"bool(ean)?$",  # aliased to tinyint(1)
         TEMPORAL=r"(date|datetime|time|timestamp|year)(\s*\(.+\))?$",
         INTERNAL_BLOB=r"(tiny|small|medium|long|)blob$",
         EXTERNAL_BLOB=r"blob@(?P<store>[a-z][\-\w]*)$",
@@ -51,7 +78,7 @@
     "EXTERNAL_BLOB",
     "FILEPATH",
     "ADAPTED",
-}
+} | set(TYPE_ALIASES)
 NATIVE_TYPES = set(TYPE_PATTERN) - SPECIAL_TYPES
 EXTERNAL_TYPES = {
     "EXTERNAL_ATTACH",
@@ -460,6 +487,8 @@ def substitute_special_type(match, category, foreign_key_sql, context):
         if category in SPECIAL_TYPES:
             # recursive redefinition from user-defined datatypes.
             substitute_special_type(match, category, foreign_key_sql, context)
+    elif category in TYPE_ALIASES:
+        match["type"] = TYPE_ALIASES[category]
     else:
         assert False, "Unknown special type"
 

tests/conftest.py

@@ -23,6 +23,7 @@
 
 from . import schema, schema_advanced, schema_external, schema_simple
 from . import schema_uuid as schema_uuid_module
+from . import schema_type_aliases as schema_type_aliases_module
 
 # Configure logging for container management
 logger = logging.getLogger(__name__)
@@ -771,6 +772,21 @@ def schema_uuid(connection_test, prefix):
     schema.drop()
 
 
+@pytest.fixture(scope="module")
+def schema_type_aliases(connection_test, prefix):
+    """Schema for testing numeric type aliases."""
+    schema = dj.Schema(
+        prefix + "_type_aliases",
+        context=schema_type_aliases_module.LOCALS_TYPE_ALIASES,
+        connection=connection_test,
+    )
+    schema(schema_type_aliases_module.TypeAliasTable)
+    schema(schema_type_aliases_module.TypeAliasPrimaryKey)
+    schema(schema_type_aliases_module.TypeAliasNullable)
+    yield schema
+    schema.drop()
+
+
 @pytest.fixture(scope="session")
 def http_client():
     # Initialize httpClient with relevant timeout.

tests/schema_type_aliases.py

@@ -0,0 +1,50 @@
+"""
+Schema for testing numeric type aliases.
+"""
+
+import inspect
+
+import datajoint as dj
+
+
+class TypeAliasTable(dj.Manual):
+    definition = """
+    # Table with all numeric type aliases
+    id : int
+    ---
+    val_float32 : float32     # 32-bit float
+    val_float64 : float64     # 64-bit float
+    val_int64 : int64         # 64-bit signed integer
+    val_uint64 : uint64       # 64-bit unsigned integer
+    val_int32 : int32         # 32-bit signed integer
+    val_uint32 : uint32       # 32-bit unsigned integer
+    val_int16 : int16         # 16-bit signed integer
+    val_uint16 : uint16       # 16-bit unsigned integer
+    val_int8 : int8           # 8-bit signed integer
+    val_uint8 : uint8         # 8-bit unsigned integer
+    val_bool : bool           # boolean value
+    """
+
+
+class TypeAliasPrimaryKey(dj.Manual):
+    definition = """
+    # Table with type alias in primary key
+    pk_int32 : int32
+    pk_uint16 : uint16
+    ---
+    value : varchar(100)
+    """
+
+
+class TypeAliasNullable(dj.Manual):
+    definition = """
+    # Table with nullable type alias columns
+    id : int
+    ---
+    nullable_float32 = null : float32
+    nullable_int64 = null : int64
+    """
+
+
+LOCALS_TYPE_ALIASES = {k: v for k, v in locals().items() if inspect.isclass(v)}
+__all__ = list(LOCALS_TYPE_ALIASES)

tests/test_type_aliases.py

@@ -0,0 +1,184 @@
+"""
+Tests for numeric type aliases (float32, float64, int8, int16, int32, int64, etc.)
+"""
+
+import pytest
+
+from datajoint.declare import TYPE_ALIASES, SPECIAL_TYPES, match_type
+
+from .schema_type_aliases import TypeAliasTable, TypeAliasPrimaryKey, TypeAliasNullable
+
+
+class TestTypeAliasPatterns:
+    """Test that type alias patterns are correctly defined and matched."""
+
+    @pytest.mark.parametrize(
+        "alias,expected_category",
+        [
+            ("float32", "FLOAT32"),
+            ("float64", "FLOAT64"),
+            ("int64", "INT64"),
+            ("uint64", "UINT64"),
+            ("int32", "INT32"),
+            ("uint32", "UINT32"),
+            ("int16", "INT16"),
+            ("uint16", "UINT16"),
+            ("int8", "INT8"),
+            ("uint8", "UINT8"),
+            ("bool", "BOOL"),
+        ],
+    )
+    def test_type_alias_pattern_matching(self, alias, expected_category):
+        """Test that type aliases are matched to correct categories."""
+        category = match_type(alias)
+        assert category == expected_category
+        assert category in SPECIAL_TYPES
+        assert category in TYPE_ALIASES
+
+    @pytest.mark.parametrize(
+        "alias,expected_mysql_type",
+        [
+            ("float32", "float"),
+            ("float64", "double"),
+            ("int64", "bigint"),
+            ("uint64", "bigint unsigned"),
+            ("int32", "int"),
+            ("uint32", "int unsigned"),
+            ("int16", "smallint"),
+            ("uint16", "smallint unsigned"),
+            ("int8", "tinyint"),
+            ("uint8", "tinyint unsigned"),
+            ("bool", "tinyint"),
+        ],
+    )
+    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 = TYPE_ALIASES[category]
+        assert mysql_type == expected_mysql_type
+
+    @pytest.mark.parametrize(
+        "native_type,expected_category",
+        [
+            ("int", "INTEGER"),
+            ("bigint", "INTEGER"),
+            ("smallint", "INTEGER"),
+            ("tinyint", "INTEGER"),
+            ("float", "FLOAT"),
+            ("double", "FLOAT"),
+        ],
+    )
+    def test_native_types_still_work(self, native_type, expected_category):
+        """Test that native MySQL types still match correctly."""
+        category = match_type(native_type)
+        assert category == expected_category
+
+
+class TestTypeAliasTableCreation:
+    """Test table creation with type aliases."""
+
+    def test_create_table_with_all_aliases(self, schema_type_aliases):
+        """Test that tables with all type aliases can be created."""
+        assert TypeAliasTable().full_table_name is not None
+
+    def test_create_table_with_alias_primary_key(self, schema_type_aliases):
+        """Test that tables with type aliases in primary key can be created."""
+        assert TypeAliasPrimaryKey().full_table_name is not None
+
+    def test_create_table_with_nullable_aliases(self, schema_type_aliases):
+        """Test that tables with nullable type alias columns can be created."""
+        assert TypeAliasNullable().full_table_name is not None
+
+
+class TestTypeAliasHeading:
+    """Test that headings correctly preserve type alias information."""
+
+    def test_heading_preserves_type_aliases(self, schema_type_aliases):
+        """Test that heading shows original type aliases."""
+        heading = TypeAliasTable().heading
+        heading_str = repr(heading)
+
+        # Check that type aliases appear in the heading representation
+        assert "float32" in heading_str
+        assert "float64" in heading_str
+        assert "int64" in heading_str
+        assert "uint64" in heading_str
+        assert "int32" in heading_str
+        assert "uint32" in heading_str
+        assert "int16" in heading_str
+        assert "uint16" in heading_str
+        assert "int8" in heading_str
+        assert "uint8" in heading_str
+        assert "bool" in heading_str
+
+
+class TestTypeAliasInsertFetch:
+    """Test inserting and fetching data with type aliases."""
+
+    def test_insert_and_fetch(self, schema_type_aliases):
+        """Test inserting and fetching values with type aliases."""
+        table = TypeAliasTable()
+        table.delete()
+
+        test_data = dict(
+            id=1,
+            val_float32=3.14,
+            val_float64=2.718281828,
+            val_int64=9223372036854775807,  # max int64
+            val_uint64=18446744073709551615,  # max uint64
+            val_int32=2147483647,  # max int32
+            val_uint32=4294967295,  # max uint32
+            val_int16=32767,  # max int16
+            val_uint16=65535,  # max uint16
+            val_int8=127,  # max int8
+            val_uint8=255,  # max uint8
+            val_bool=1,  # boolean true
+        )
+
+        table.insert1(test_data)
+        fetched = table.fetch1()
+
+        assert fetched["id"] == test_data["id"]
+        assert abs(fetched["val_float32"] - test_data["val_float32"]) < 0.001
+        assert abs(fetched["val_float64"] - test_data["val_float64"]) < 1e-9
+        assert fetched["val_int64"] == test_data["val_int64"]
+        assert fetched["val_uint64"] == test_data["val_uint64"]
+        assert fetched["val_int32"] == test_data["val_int32"]
+        assert fetched["val_uint32"] == test_data["val_uint32"]
+        assert fetched["val_int16"] == test_data["val_int16"]
+        assert fetched["val_uint16"] == test_data["val_uint16"]
+        assert fetched["val_int8"] == test_data["val_int8"]
+        assert fetched["val_uint8"] == test_data["val_uint8"]
+        assert fetched["val_bool"] == test_data["val_bool"]
+
+    def test_insert_primary_key_with_aliases(self, schema_type_aliases):
+        """Test using type aliases in primary key."""
+        table = TypeAliasPrimaryKey()
+        table.delete()
+
+        table.insert1(dict(pk_int32=100, pk_uint16=200, value="test"))
+        fetched = (table & dict(pk_int32=100, pk_uint16=200)).fetch1()
+
+        assert fetched["pk_int32"] == 100
+        assert fetched["pk_uint16"] == 200
+        assert fetched["value"] == "test"
+
+    def test_nullable_type_aliases(self, schema_type_aliases):
+        """Test nullable columns with type aliases."""
+        table = TypeAliasNullable()
+        table.delete()
+
+        # Insert with NULL values
+        table.insert1(dict(id=1, nullable_float32=None, nullable_int64=None))
+        fetched = table.fetch1()
+
+        assert fetched["id"] == 1
+        assert fetched["nullable_float32"] is None
+        assert fetched["nullable_int64"] is None
+
+        # Insert with actual values
+        table.insert1(dict(id=2, nullable_float32=1.5, nullable_int64=999))
+        fetched = (table & dict(id=2)).fetch1()
+
+        assert fetched["nullable_float32"] == 1.5
+        assert fetched["nullable_int64"] == 999