GeneralManager 0.52.1__tar.gz → 0.53.0__tar.gz

{generalmanager-0.52.1/src/GeneralManager.egg-info → generalmanager-0.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.52.1
+Version: 0.53.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.52.1 → generalmanager-0.53.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.52.1"
+version = "0.53.0"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.52.1 → generalmanager-0.53.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.52.1
+Version: 0.53.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.52.1 → generalmanager-0.53.0}/src/general_manager/bucket/database_bucket.py

@@ -257,11 +257,44 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             ),
         )
 
-    def _build_manager(self, pk: Any) -> GeneralManagerType:
+    def _build_manager_from_primary_key(self, pk: Any) -> GeneralManagerType:
         if self._search_date is None:
             return self._manager_class(pk)
         return self._manager_class(pk, search_date=self._search_date)
 
+    def _can_trust_orm_instance(self, instance: models.Model) -> bool:
+        interface_model = getattr(self._manager_class.Interface, "_model", None)
+        if isinstance(interface_model, type) and issubclass(
+            interface_model, models.Model
+        ):
+            if not isinstance(instance, interface_model):
+                return False
+        get_deferred_fields = getattr(instance, "get_deferred_fields", None)
+        if callable(get_deferred_fields) and get_deferred_fields():
+            return False
+        if self._search_date is not None and not (
+            hasattr(instance, "_history") or hasattr(instance, "history_date")
+        ):
+            return False
+        return True
+
+    def _build_manager_from_instance(
+        self,
+        instance: models.Model,
+    ) -> GeneralManagerType:
+        interface_hydrate = getattr(
+            self._manager_class.Interface, "_from_trusted_orm_instance", None
+        )
+        manager_hydrate = self._manager_class._from_trusted_orm_instance
+        if callable(interface_hydrate) and self._can_trust_orm_instance(instance):
+            return manager_hydrate(instance, search_date=self._search_date)
+        return self._build_manager_from_primary_key(instance.pk)
+
+    def _build_manager(self, value: Any) -> GeneralManagerType:
+        if isinstance(value, models.Model):
+            return self._build_manager_from_instance(value)
+        return self._build_manager_from_primary_key(value)
+
     @staticmethod
     def _copy_filter_definitions(
         definitions: dict[str, Any] | None,
@@ -314,6 +347,11 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             return None
         if query.distinct:
             return None
+        if getattr(self._data, "_prefetch_related_lookups", ()):
+            return None
+        deferred_loading = getattr(query, "deferred_loading", None)
+        if isinstance(deferred_loading, tuple) and deferred_loading[0]:
+            return None
         try:
             sql, params = self._data.query.sql_with_params()
         except (EmptyResultSet, FieldError, TypeError, ValueError):
@@ -370,6 +408,28 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         context.set_orm_bucket_result(signature, primary_keys)
         return primary_keys
 
+    def _get_run_scoped_rows(self) -> tuple[models.Model, ...] | None:
+        """
+        Load or reuse a bounded model-row snapshot for trusted hydration.
+        """
+        context = current_calculation_run_context()
+        if context is None:
+            return None
+        signature = self._query_signature()
+        if signature is None:
+            return None
+        cached = context.get_orm_bucket_rows(signature)
+        if cached is not None:
+            return cached  # type: ignore[return-value]
+
+        rows = tuple(self._data[: MAX_RUN_SCOPED_BUCKET_RESULT_ROWS + 1])
+        if len(rows) > MAX_RUN_SCOPED_BUCKET_RESULT_ROWS:
+            return None
+        primary_keys = tuple(row.pk for row in rows)
+        context.set_orm_bucket_rows(signature, rows)
+        context.set_orm_bucket_result(signature, primary_keys)
+        return rows
+
     def _peek_run_scoped_primary_keys(self) -> tuple[Any, ...] | None:
         """
         Return an already cached primary-key snapshot without evaluating the ORM.
@@ -393,6 +453,19 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             return None
         return cached  # type: ignore[return-value]
 
+    def _peek_run_scoped_rows(self) -> tuple[models.Model, ...] | None:
+        """Return cached model rows without evaluating the ORM."""
+        context = current_calculation_run_context()
+        if context is None:
+            return None
+        signature = self._query_signature()
+        if signature is None:
+            return None
+        cached = context.get_orm_bucket_rows(signature)
+        if cached is None:
+            return None
+        return cached  # type: ignore[return-value]
+
     @staticmethod
     def _snapshot_get_primary_key(kwargs: dict[str, Any]) -> Any | None:
         """
@@ -458,13 +531,18 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             GeneralManagerType: Manager instance for each primary key in the queryset.
         """
         self._track_effective_dependencies()
-        primary_keys = self._get_run_scoped_primary_keys()
+        rows = self._get_run_scoped_rows()
+        if rows is not None:
+            for row in rows:
+                yield self._build_manager_from_instance(row)
+            return
+        primary_keys = self._peek_run_scoped_primary_keys()
         if primary_keys is not None:
             for primary_key in primary_keys:
-                yield self._build_manager(primary_key)
+                yield self._build_manager_from_primary_key(primary_key)
             return
         for item in self._data:
-            yield self._build_manager(item.pk)
+            yield self._build_manager_from_instance(item)
 
     def __or__(
         self,
@@ -585,7 +663,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         """
         ids: list[int] = []
         for obj in query_set:
-            inst = self._build_manager(obj.pk)
+            inst = self._build_manager_from_instance(obj)
             keep = True
             for k, val, root in python_filters:
                 lookup = k.split("__", 1)[1] if "__" in k else ""
@@ -704,15 +782,20 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             GeneralManagerType | None: First manager instance if available.
         """
         self._track_effective_dependencies()
+        rows = self._peek_run_scoped_rows()
+        if rows is not None:
+            if not rows:
+                return None
+            return self._build_manager_from_instance(rows[0])
         primary_keys = self._peek_run_scoped_primary_keys()
         if primary_keys is not None:
             if not primary_keys:
                 return None
-            return self._build_manager(primary_keys[0])
+            return self._build_manager_from_primary_key(primary_keys[0])
         first_element = self._data.first()
         if first_element is None:
             return None
-        return self._build_manager(first_element.pk)
+        return self._build_manager_from_instance(first_element)
 
     def last(self) -> GeneralManagerType | None:
         """
@@ -722,15 +805,20 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             GeneralManagerType | None: Last manager instance if available.
         """
         self._track_effective_dependencies()
+        rows = self._peek_run_scoped_rows()
+        if rows is not None:
+            if not rows:
+                return None
+            return self._build_manager_from_instance(rows[-1])
         primary_keys = self._peek_run_scoped_primary_keys()
         if primary_keys is not None:
             if not primary_keys:
                 return None
-            return self._build_manager(primary_keys[-1])
+            return self._build_manager_from_primary_key(primary_keys[-1])
         first_element = self._data.last()
         if first_element is None:
             return None
-        return self._build_manager(first_element.pk)
+        return self._build_manager_from_instance(first_element)
 
     def count(self) -> int:
         """
@@ -778,18 +866,28 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             models.MultipleObjectsReturned: Propagated when multiple rows satisfy the lookup.
         """
         self._track_effective_dependencies()
+        rows = self._peek_run_scoped_rows()
+        if rows is not None:
+            requested_primary_key = self._snapshot_get_primary_key(kwargs)
+            if requested_primary_key is not None:
+                matches = [row for row in rows if row.pk == requested_primary_key]
+                if len(matches) == 1:
+                    return self._build_manager_from_instance(matches[0])
+                if len(matches) > 1:
+                    raise self._data.model.MultipleObjectsReturned
+                raise self._data.model.DoesNotExist
         primary_keys = self._peek_run_scoped_primary_keys()
         if primary_keys is not None:
             requested_primary_key = self._snapshot_get_primary_key(kwargs)
             if requested_primary_key is not None:
                 match_count = primary_keys.count(requested_primary_key)
                 if match_count == 1:
-                    return self._build_manager(requested_primary_key)
+                    return self._build_manager_from_primary_key(requested_primary_key)
                 if match_count > 1:
                     raise self._data.model.MultipleObjectsReturned
                 raise self._data.model.DoesNotExist
         element = self._data.get(**kwargs)
-        return self._build_manager(element.pk)
+        return self._build_manager_from_instance(element)
 
     def __getitem__(
         self, item: int | slice
@@ -815,12 +913,17 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
                 run_scoped_cacheable=self._run_scoped_cacheable,
             )
         self._track_effective_dependencies()
+        rows = self._peek_run_scoped_rows()
+        if rows is not None:
+            if item < 0:
+                raise ValueError
+            return self._build_manager_from_instance(rows[item])
         primary_keys = self._peek_run_scoped_primary_keys()
         if primary_keys is not None:
             if item < 0:
                 raise ValueError
-            return self._build_manager(primary_keys[item])
-        return self._build_manager(self._data[item].pk)
+            return self._build_manager_from_primary_key(primary_keys[item])
+        return self._build_manager_from_instance(self._data[item])
 
     def __len__(self) -> int:
         """
@@ -926,7 +1029,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             objs = list(qs)
 
             def key_func(obj: models.Model) -> tuple[object, ...]:
-                inst = self._build_manager(obj.pk)
+                inst = self._build_manager_from_instance(obj)
                 values = []
                 for k in key:
                     if k in properties:

{generalmanager-0.52.1 → generalmanager-0.53.0}/src/general_manager/cache/dependency_shards.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import hashlib
+from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import Any, Iterable, Literal
+from typing import Any, Iterable, Literal, Mapping
 
 from django.core.cache import cache
 
@@ -37,6 +38,14 @@ class ReverseDependencyMembership:
     simple_dependencies: frozenset[SimpleDependency] = field(default_factory=frozenset)
 
 
+@dataclass(frozen=True, slots=True)
+class _DependencyShardPlan:
+    shard_keys: frozenset[str]
+    composite_dependencies: frozenset[CompositeDependency]
+    simple_dependencies: frozenset[SimpleDependency]
+    lookup_registrations: frozenset[tuple[str, str, str]]
+
+
 def _hash_text(value: str) -> str:
     return hashlib.sha256(value.encode("utf-8")).hexdigest()
 
@@ -104,19 +113,78 @@ def cache_set_members(key: str) -> set[str]:
     return set(members)
 
 
+def _cache_get_many(keys: Iterable[str]) -> dict[str, Any]:
+    key_tuple = tuple(dict.fromkeys(keys))
+    if not key_tuple:
+        return {}
+    return dict(cache.get_many(key_tuple))
+
+
+def _cache_set_many(payloads: Mapping[str, Any]) -> None:
+    if payloads:
+        cache.set_many(dict(payloads), None)
+
+
+def _cache_delete_many(keys: Iterable[str]) -> None:
+    key_tuple = tuple(dict.fromkeys(keys))
+    if not key_tuple:
+        return
+    delete_many = getattr(cache, "delete_many", None)
+    if callable(delete_many):
+        delete_many(key_tuple)
+        return
+    for key in key_tuple:
+        cache.delete(key)
+
+
+def _cache_member_set(value: Any) -> set[str]:
+    if value is None:
+        return set()
+    if isinstance(value, (set, frozenset, list, tuple)):
+        return {member for member in value if isinstance(member, str)}
+    return set()
+
+
+def _cache_set_add_many(additions: Mapping[str, set[str]]) -> None:
+    pending = {key: set(members) for key, members in additions.items() if members}
+    if not pending:
+        return
+
+    existing_sets = _cache_get_many(pending)
+    payloads: dict[str, set[str]] = {}
+    for key, members in pending.items():
+        current = _cache_member_set(existing_sets.get(key, set()))
+        current.update(members)
+        payloads[key] = current
+    _cache_set_many(payloads)
+
+
+def _cache_set_discard_many(removals: Mapping[str, set[str]]) -> None:
+    pending = {key: set(members) for key, members in removals.items() if members}
+    if not pending:
+        return
+
+    existing_sets = _cache_get_many(pending)
+    payloads: dict[str, set[str]] = {}
+    delete_keys: list[str] = []
+    for key, members in pending.items():
+        current = _cache_member_set(existing_sets.get(key, set()))
+        current.difference_update(members)
+        if current:
+            payloads[key] = current
+        else:
+            delete_keys.append(key)
+
+    _cache_set_many(payloads)
+    _cache_delete_many(delete_keys)
+
+
 def _cache_set_add(key: str, member: str) -> None:
-    members = cache_set_members(key)
-    members.add(member)
-    cache.set(key, members, None)
+    _cache_set_add_many({key: {member}})
 
 
 def _cache_set_discard(key: str, member: str) -> None:
-    members = cache_set_members(key)
-    members.discard(member)
-    if members:
-        cache.set(key, members, None)
-    else:
-        cache.delete(key)
+    _cache_set_discard_many({key: {member}})
 
 
 def _lookup_name_for_candidate(lookup: str) -> str:
@@ -190,20 +258,31 @@ def _shard_keys_for_dependency(
     manager_name: str,
     action: DependencyAction,
     identifier: str,
-) -> tuple[set[str], set[CompositeDependency], set[SimpleDependency]]:
+) -> _DependencyShardPlan:
     shard_keys: set[str] = set()
     composites: set[CompositeDependency] = set()
     simple_dependencies: set[SimpleDependency] = set()
+    lookup_registrations: set[tuple[str, str, str]] = set()
 
     if action == "all":
         shard_keys.add(all_records_shard_key(manager_name))
         simple_dependencies.add((manager_name, action, identifier))
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(shard_keys),
+            frozenset(composites),
+            frozenset(simple_dependencies),
+            frozenset(lookup_registrations),
+        )
 
     if action == "request_query":
         shard_keys.add(request_query_shard_key(manager_name))
         simple_dependencies.add((manager_name, action, identifier))
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(shard_keys),
+            frozenset(composites),
+            frozenset(simple_dependencies),
+            frozenset(lookup_registrations),
+        )
 
     if action == "identification":
         shard_keys.add(
@@ -216,19 +295,39 @@ def _shard_keys_for_dependency(
             )
         )
         simple_dependencies.add((manager_name, action, identifier))
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(shard_keys),
+            frozenset(composites),
+            frozenset(simple_dependencies),
+            frozenset(lookup_registrations),
+        )
 
     if action not in {"filter", "exclude"}:
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(),
+            frozenset(),
+            frozenset(),
+            frozenset(),
+        )
 
     params = parse_dependency_identifier(identifier)
     if not isinstance(params, dict):
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(),
+            frozenset(),
+            frozenset(),
+            frozenset(),
+        )
 
     if not params:
         shard_keys.add(all_records_shard_key(manager_name))
         simple_dependencies.add((manager_name, action, identifier))
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(shard_keys),
+            frozenset(composites),
+            frozenset(simple_dependencies),
+            frozenset(lookup_registrations),
+        )
 
     sort_lookups = [
         str(lookup).removeprefix("__sort__")
@@ -239,18 +338,23 @@ def _shard_keys_for_dependency(
         composite = (manager_name, action, identifier)
         composites.add(composite)
         for sort_lookup in sort_lookups:
-            _register_lookup(manager_name, action, sort_lookup)
+            lookup_registrations.add((manager_name, action, sort_lookup))
             shard_keys.add(
                 composite_lookup_shard_key(manager_name, action, sort_lookup)
             )
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(shard_keys),
+            frozenset(composites),
+            frozenset(simple_dependencies),
+            frozenset(lookup_registrations),
+        )
 
     if len(params) > 1:
         composite = (manager_name, action, identifier)
         composites.add(composite)
         for lookup in params:
             candidate_lookup = _lookup_name_for_candidate(str(lookup))
-            _register_lookup(manager_name, action, candidate_lookup)
+            lookup_registrations.add((manager_name, action, candidate_lookup))
             shard_keys.add(
                 composite_lookup_shard_key(
                     manager_name,
@@ -258,12 +362,17 @@ def _shard_keys_for_dependency(
                     candidate_lookup,
                 )
             )
-        return shard_keys, composites, simple_dependencies
+        return _DependencyShardPlan(
+            frozenset(shard_keys),
+            frozenset(composites),
+            frozenset(simple_dependencies),
+            frozenset(lookup_registrations),
+        )
 
     lookup, value = next(iter(params.items()))
     spec = lookup_spec_from_key(str(lookup))
     candidate_lookup = "__".join(spec.attr_path)
-    _register_lookup(manager_name, action, candidate_lookup)
+    lookup_registrations.add((manager_name, action, candidate_lookup))
     if spec.operator == "eq":
         shard_keys.add(
             exact_lookup_shard_key(manager_name, action, spec.lookup, "eq", value)
@@ -273,56 +382,96 @@ def _shard_keys_for_dependency(
             scan_lookup_shard_key(manager_name, action, spec.lookup, spec.operator)
         )
     simple_dependencies.add((manager_name, action, identifier))
-    return shard_keys, composites, simple_dependencies
+    return _DependencyShardPlan(
+        frozenset(shard_keys),
+        frozenset(composites),
+        frozenset(simple_dependencies),
+        frozenset(lookup_registrations),
+    )
 
 
-def record_cache_dependencies(
+def _reverse_membership_for_dependencies(
     cache_key: str,
-    dependencies: Iterable[Dependency],
-) -> None:
-    """Record dependency metadata for one cache key in deterministic shards."""
-    dependency_set = set(dependencies)
-    if not dependency_set:
-        return
-
-    clear_legacy_dependency_index()
-    remove_cache_key_from_shards(cache_key)
-
+    dependency_set: set[Dependency],
+) -> tuple[ReverseDependencyMembership, set[tuple[str, str, str]]]:
     shard_keys: set[str] = set()
     composites: set[CompositeDependency] = set()
     simple_dependencies: set[SimpleDependency] = set()
-    for manager_name, action, identifier in dependency_set:
-        new_shards, new_composites, new_simple = _shard_keys_for_dependency(
-            manager_name,
-            action,
-            identifier,
-        )
-        shard_keys.update(new_shards)
-        composites.update(new_composites)
-        simple_dependencies.update(new_simple)
+    lookup_registrations: set[tuple[str, str, str]] = set()
 
-    for shard_key in shard_keys:
-        _cache_set_add(shard_key, cache_key)
+    for manager_name, action, identifier in dependency_set:
+        plan = _shard_keys_for_dependency(manager_name, action, identifier)
+        shard_keys.update(plan.shard_keys)
+        composites.update(plan.composite_dependencies)
+        simple_dependencies.update(plan.simple_dependencies)
+        lookup_registrations.update(plan.lookup_registrations)
 
-    cache.set(
-        reverse_membership_key(cache_key),
+    return (
         ReverseDependencyMembership(
             cache_key=cache_key,
             shard_keys=frozenset(shard_keys),
             composite_dependencies=frozenset(composites),
             simple_dependencies=frozenset(simple_dependencies),
         ),
-        None,
+        lookup_registrations,
     )
-    _cache_set_add(REVERSE_MEMBERSHIP_REGISTRY_KEY, reverse_membership_key(cache_key))
+
+
+def record_cache_dependencies(
+    cache_key: str,
+    dependencies: Iterable[Dependency],
+) -> None:
+    """Record dependency metadata for one cache key in deterministic shards."""
+    record_many_cache_dependencies(((cache_key, dependencies),))
 
 
 def record_many_cache_dependencies(
     entries: Iterable[tuple[str, Iterable[Dependency]]],
 ) -> None:
     """Record dependency metadata for many cache keys."""
+    normalized: dict[str, set[Dependency]] = {}
     for cache_key, dependencies in entries:
-        record_cache_dependencies(cache_key, dependencies)
+        dependency_set = set(dependencies)
+        if dependency_set:
+            normalized.setdefault(cache_key, set()).update(dependency_set)
+    if not normalized:
+        return
+
+    clear_legacy_dependency_index()
+
+    reverse_keys = {
+        cache_key: reverse_membership_key(cache_key) for cache_key in normalized
+    }
+    existing_reverses = _cache_get_many(reverse_keys.values())
+
+    shard_removals: dict[str, set[str]] = defaultdict(set)
+    for cache_key, reverse_key in reverse_keys.items():
+        reverse = existing_reverses.get(reverse_key)
+        if isinstance(reverse, ReverseDependencyMembership):
+            for shard_key in reverse.shard_keys:
+                shard_removals[shard_key].add(cache_key)
+
+    _cache_set_discard_many(shard_removals)
+
+    set_additions: dict[str, set[str]] = defaultdict(set)
+    reverse_payloads: dict[str, ReverseDependencyMembership] = {}
+
+    for cache_key, dependency_set in normalized.items():
+        reverse, lookup_registrations = _reverse_membership_for_dependencies(
+            cache_key,
+            dependency_set,
+        )
+        for shard_key in reverse.shard_keys:
+            set_additions[shard_key].add(cache_key)
+        for manager_name, action, lookup in lookup_registrations:
+            set_additions[lookup_registry_key(manager_name, action)].add(lookup)
+
+        reverse_key = reverse_keys[cache_key]
+        reverse_payloads[reverse_key] = reverse
+        set_additions[REVERSE_MEMBERSHIP_REGISTRY_KEY].add(reverse_key)
+
+    _cache_set_add_many(set_additions)
+    _cache_set_many(reverse_payloads)
 
 
 def remove_cache_key_from_shards(cache_key: str) -> None:

{generalmanager-0.52.1 → generalmanager-0.53.0}/src/general_manager/cache/run_context.py

@@ -26,6 +26,7 @@ _active_context: ContextVar["CalculationRunContext | None"] = ContextVar(
     default=None,
 )
 ORM_BUCKET_RESULT_PREFIX = "orm_bucket_result"
+ORM_BUCKET_ROW_RESULT_PREFIX = "orm_bucket_row_result"
 BUCKET_INDEX_PREFIX = "bucket_index"
 DEFAULT_DEPENDENCY_CACHE_PUBLISH_BATCH_SIZE = 1000
 logger = get_logger("cache.run_context")
@@ -191,9 +192,18 @@ class CalculationRunContext:
         """Store an ORM bucket result for the active run."""
         self.set((ORM_BUCKET_RESULT_PREFIX, key), value)
 
+    def get_orm_bucket_rows(self, key: Hashable) -> object:
+        """Return cached ORM bucket rows for key, or None when absent."""
+        return self.get((ORM_BUCKET_ROW_RESULT_PREFIX, key))
+
+    def set_orm_bucket_rows(self, key: Hashable, value: object) -> None:
+        """Store ORM bucket rows for the active run."""
+        self.set((ORM_BUCKET_ROW_RESULT_PREFIX, key), value)
+
     def clear_orm_bucket_results(self) -> None:
         """Discard all run-scoped ORM bucket result entries."""
         self.discard_prefix((ORM_BUCKET_RESULT_PREFIX,))
+        self.discard_prefix((ORM_BUCKET_ROW_RESULT_PREFIX,))
 
     def _bucket_index_cache_key(
         self,