sqlmodel-ext 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

sqlmodel_ext/__init__.py

@@ -20,7 +20,7 @@ Quick start::
     user = await user.save(session)
     users = await User.get(session, fetch_mode="all")
 """
-__version__ = "0.2.1"
+__version__ = "0.3.0"
 
 # Base
 from sqlmodel_ext.base import SQLModelBase, ExtraIgnoreModelBase

sqlmodel_ext/_compat.py

@@ -14,6 +14,7 @@ if sys.version_info >= (3, 14):
     from enum import StrEnum
     from typing import Literal, Union, get_args, get_origin
 
+    from pydantic_core import PydanticUndefined
     from sqlalchemy import String
     from sqlalchemy.orm.attributes import InstrumentedAttribute
 
@@ -27,6 +28,24 @@ if sys.version_info >= (3, 14):
     import sqlmodel.main
     _original_get_sqlalchemy_type = sqlmodel.main.get_sqlalchemy_type
 
+    def _get_explicit_sa_type(field):
+        """
+        Extract an explicit ``sa_type`` from a SQLModel/Pydantic FieldInfo.
+
+        Matches upstream ``sqlmodel.main._get_sqlmodel_field_value`` semantics:
+        prefers ``FieldInfoMetadata.sa_type`` then falls back to the direct
+        ``field.sa_type`` attribute. Returns ``PydanticUndefined`` when unset.
+        """
+        # Prefer FieldInfoMetadata.sa_type (set via Field(sa_type=...))
+        metadata = getattr(field, 'metadata', None)
+        if metadata:
+            for item in metadata:
+                sa_type = getattr(item, 'sa_type', PydanticUndefined)
+                if sa_type is not PydanticUndefined:
+                    return sa_type
+        # Fallback to direct attribute
+        return getattr(field, 'sa_type', PydanticUndefined)
+
     def _patched_get_sqlalchemy_type(field):
         """
         Fix SQLModel's get_sqlalchemy_type for Python 3.14 type issues.
@@ -34,6 +53,17 @@ if sys.version_info >= (3, 14):
         Handles ForwardRef, ClassVar, Literal, Mapped, and custom types
         that cause issubclass errors under PEP 649.
         """
+        # Respect explicit sa_type from Field(sa_type=...) — must take
+        # precedence over annotation-based auto-detection, matching upstream
+        # SQLModel behavior (sqlmodel/main.py::get_sqlalchemy_type checks
+        # sa_type before everything else). Without this, fields like
+        # ``options: list[str] | None = Field(sa_type=JSON)`` incorrectly
+        # get JSONB from the Union[list, None] -> JSONB branch below,
+        # breaking non-PostgreSQL dialects (e.g., SQLite in tests).
+        explicit_sa_type = _get_explicit_sa_type(field)
+        if explicit_sa_type is not PydanticUndefined:
+            return explicit_sa_type
+
         # Check field.metadata (Pydantic-processed Annotated types)
         metadata = getattr(field, 'metadata', None)
         if metadata:

sqlmodel_ext/mixins/polymorphic.py

@@ -453,6 +453,22 @@ class AutoPolymorphicIdentityMixin:
                 # other subclasses' rows won't have values for these columns.
                 # Pydantic-level constraints still apply when creating specific subclasses.
                 column.nullable = True
+
+                # Clear Python-side and server-side defaults on the shared column.
+                # Otherwise, a Pydantic field default (e.g. ``some_field: int = 5``)
+                # gets propagated into Column.default by ``get_column_from_field()``.
+                # When sibling subclasses that do NOT declare this field are inserted,
+                # the attribute is absent from their model_fields and from the
+                # instance's ``__dict__``; the ORM falls back to Column.default and
+                # writes the declaring subclass's default into the sibling row,
+                # silently polluting unrelated rows across the STI table.
+                # The declaring subclass itself is unaffected: Pydantic populates the
+                # instance attribute at ``__init__`` time, and the ORM reads the
+                # value directly from the instance on flush without ever consulting
+                # Column.default.
+                column.default = None
+                column.server_default = None
+
                 parent_table.append_column(column)
             except Exception as e:
                 logger.warning(f"Failed to create column {field_name} for {cls.__name__}: {e}")