support passing fields as annotated types

Author: proever

sqlmodel/main.py

@@ -51,7 +51,7 @@
 from sqlalchemy.orm.instrumentation import is_instrumented
 from sqlalchemy.sql.schema import MetaData
 from sqlalchemy.sql.sqltypes import LargeBinary, Time
-from typing_extensions import Literal, deprecated, get_origin
+from typing_extensions import Literal, _AnnotatedAlias, deprecated, get_origin
 
 from ._compat import (  # type: ignore[attr-defined]
     IS_PYDANTIC_V2,
@@ -561,48 +561,59 @@ def get_sqlalchemy_type(field: Any) -> Any:
         return sa_type
 
     type_ = get_type_from_field(field)
-    metadata = get_field_metadata(field)
+    if isinstance(type_, _AnnotatedAlias):
+        class_to_compare = type_.__origin__
+        if len(type_.__metadata__) == 1:
+            metadata = get_field_metadata(type_.__metadata__[0])
+        else:
+            # not sure if this is the right behavior
+            raise ValueError(
+                f"AnnotatedAlias with multiple metadata is not supported: {type_}"
+            )
+    else:
+        class_to_compare = type_
+        metadata = get_field_metadata(field)
 
     # Check enums first as an enum can also be a str, needed by Pydantic/FastAPI
-    if issubclass(type_, Enum):
+    if issubclass(class_to_compare, Enum):
         return sa_Enum(type_)
-    if issubclass(type_, str):
+    if issubclass(class_to_compare, str):
         max_length = getattr(metadata, "max_length", None)
         if max_length:
             return AutoString(length=max_length)
         return AutoString
-    if issubclass(type_, float):
+    if issubclass(class_to_compare, float):
         return Float
-    if issubclass(type_, bool):
+    if issubclass(class_to_compare, bool):
         return Boolean
-    if issubclass(type_, int):
+    if issubclass(class_to_compare, int):
         return Integer
-    if issubclass(type_, datetime):
+    if issubclass(class_to_compare, datetime):
         return DateTime
-    if issubclass(type_, date):
+    if issubclass(class_to_compare, date):
         return Date
-    if issubclass(type_, timedelta):
+    if issubclass(class_to_compare, timedelta):
         return Interval
-    if issubclass(type_, time):
+    if issubclass(class_to_compare, time):
         return Time
-    if issubclass(type_, bytes):
+    if issubclass(class_to_compare, bytes):
         return LargeBinary
-    if issubclass(type_, Decimal):
+    if issubclass(class_to_compare, Decimal):
         return Numeric(
             precision=getattr(metadata, "max_digits", None),
             scale=getattr(metadata, "decimal_places", None),
         )
-    if issubclass(type_, ipaddress.IPv4Address):
+    if issubclass(class_to_compare, ipaddress.IPv4Address):
         return AutoString
-    if issubclass(type_, ipaddress.IPv4Network):
+    if issubclass(class_to_compare, ipaddress.IPv4Network):
         return AutoString
-    if issubclass(type_, ipaddress.IPv6Address):
+    if issubclass(class_to_compare, ipaddress.IPv6Address):
         return AutoString
-    if issubclass(type_, ipaddress.IPv6Network):
+    if issubclass(class_to_compare, ipaddress.IPv6Network):
         return AutoString
-    if issubclass(type_, Path):
+    if issubclass(class_to_compare, Path):
         return AutoString
-    if issubclass(type_, uuid.UUID):
+    if issubclass(class_to_compare, uuid.UUID):
         return GUID
     raise ValueError(f"{type_} has no matching SQLAlchemy type")