feat: enhance async handling in SafeDeferredColumnLoader and add tests for fallback behavior

Author: 50Bytes-dev

sqlmodel/deferred_column.py

@@ -24,9 +24,10 @@ def __init__(self, parent, strategy_key, fallback_value=None):
     def _load_for_state(self, state, passive):
         """
         Override the default behavior to return fallback value instead of raising
-        DetachedInstanceError when session is None.
+        DetachedInstanceError or MissingGreenlet when session is None or async context is missing.
         """
         from sqlalchemy.orm import LoaderCallableStatus
+        from sqlalchemy.orm.attributes import set_committed_value
 
         if not state.key:
             return LoaderCallableStatus.ATTR_EMPTY
@@ -37,13 +38,54 @@ def _load_for_state(self, state, passive):
         if not passive & PassiveFlag.SQL_OK:
             return LoaderCallableStatus.PASSIVE_NO_RESULT
 
+        # Check if the attribute is already loaded
+        if self.key not in state.unloaded:
+            # Attribute is already loaded, use parent implementation
+            return super()._load_for_state(state, passive)
+
         # Check if we have a session before attempting to load
         session = _state_session(state)
         if session is None:
-            # No session available, return fallback value directly
+            # No session available, set fallback value directly on the instance
+            instance = state.obj()
+            if instance is not None:
+                set_committed_value(instance, self.key, self.fallback_value)
+                return LoaderCallableStatus.ATTR_WAS_SET
             return self.fallback_value
 
-        # We have a session, use the parent implementation
+        # Check if this is an async session context that might cause MissingGreenlet
+        try:
+            # Try to access session._connection_for_bind to check if we're in async context
+            # without proper greenlet
+            if hasattr(session, "get_bind") and hasattr(
+                session, "_connection_for_bind"
+            ):
+                # This is a more elegant way to detect async context issues
+                # If we're in async session without greenlet context, this will fail
+                session.get_bind()
+        except Exception as e:
+            # Handle async-related errors (MissingGreenlet, etc.)
+            error_msg = str(e).lower()
+            if any(
+                keyword in error_msg
+                for keyword in [
+                    "greenlet",
+                    "await_only",
+                    "asyncio",
+                    "async",
+                    "missinggreenlet",
+                ]
+            ):
+                # This is an async-related error, set fallback value directly
+                instance = state.obj()
+                if instance is not None:
+                    set_committed_value(instance, self.key, self.fallback_value)
+                    return LoaderCallableStatus.ATTR_WAS_SET
+                return self.fallback_value
+            # For other exceptions, re-raise them
+            raise
+
+        # We have a proper session, use the parent implementation
         return super()._load_for_state(state, passive)
 
 

tests/test_async_fallback.py

@@ -0,0 +1,57 @@
+"""
+Test async behavior of deferred_column_property
+"""
+
+from typing import Optional
+
+from sqlalchemy import create_engine
+from sqlmodel import Field, SQLModel, deferred_column_property
+
+
+def test_async_fallback_value():
+    """Test that deferred_column_property returns fallback value in async context without greenlet"""
+
+    class AsyncTestModel(SQLModel, table=True):
+        __tablename__ = "async_test_model"
+
+        id: Optional[int] = Field(default=None, primary_key=True)
+        name: str
+        value: int = 0
+
+        @classmethod
+        def __declare_last__(cls):
+            cls.computed_value = deferred_column_property(
+                cls.__table__.c.value * 2,
+                fallback_value=-999,
+                deferred=True,
+            )
+
+    # Create regular engine first to set up data
+    sync_engine = create_engine("sqlite:///:memory:")
+    SQLModel.metadata.create_all(sync_engine)
+
+    from sqlmodel import Session
+
+    with Session(sync_engine) as session:
+        test_record = AsyncTestModel(name="AsyncTest", value=5)
+        session.add(test_record)
+        session.commit()
+        session.refresh(test_record)
+        record_id = test_record.id
+
+    # Now test with async session context (simulating MissingGreenlet scenario)
+    with Session(sync_engine) as session:
+        record = session.get(AsyncTestModel, record_id)
+        assert record is not None
+
+        # Close session to simulate detached state that might cause async issues
+        session.close()
+
+        # This should return fallback value without raising MissingGreenlet
+        computed = record.computed_value
+        assert computed == -999
+
+
+if __name__ == "__main__":
+    test_async_fallback_value()
+    print("✅ Async fallback test passed!")