django-bulk-hooks 0.1.231__py3-none-any.whl → 0.1.233__py3-none-any.whl

django_bulk_hooks/queryset.py

@@ -1,8 +1,11 @@
 import logging
 
-from django.db import models, transaction, connections
+from django.db import models, transaction
 from django.db.models import AutoField, Case, Value, When
+
 from django_bulk_hooks import engine
+
+logger = logging.getLogger(__name__)
 from django_bulk_hooks.constants import (
     AFTER_CREATE,
     AFTER_DELETE,
@@ -16,8 +19,6 @@ from django_bulk_hooks.constants import (
 )
 from django_bulk_hooks.context import HookContext
 
-logger = logging.getLogger(__name__)
-
 
 class HookQuerySetMixin:
     """
@@ -26,24 +27,12 @@ class HookQuerySetMixin:
     """
 
     @transaction.atomic
-    def delete(self) -> int:
-        """
-        Delete objects from the database with complete hook support.
-
-        This method runs the complete hook cycle:
-        VALIDATE_DELETE → BEFORE_DELETE → DB delete → AFTER_DELETE
-        """
+    def delete(self):
         objs = list(self)
         if not objs:
             return 0
 
         model_cls = self.model
-
-        # Validate that all objects have primary keys
-        for obj in objs:
-            if obj.pk is None:
-                raise ValueError("Cannot delete objects without primary keys")
-
         ctx = HookContext(model_cls)
 
         # Run validation hooks first
@@ -61,19 +50,7 @@ class HookQuerySetMixin:
         return result
 
     @transaction.atomic
-    def update(self, **kwargs) -> int:
-        """
-        Update objects with field values and run complete hook cycle.
-        
-        This method runs the complete hook cycle for all updates:
-        VALIDATE_UPDATE → BEFORE_UPDATE → DB update → AFTER_UPDATE
-        
-        Supports both simple field updates and complex expressions (Subquery, Case, etc.).
-        """
-        # Extract custom parameters
-        bypass_hooks = kwargs.pop('bypass_hooks', False)
-        bypass_validation = kwargs.pop('bypass_validation', False)
-        
+    def update(self, **kwargs):
         instances = list(self)
         if not instances:
             return 0
@@ -81,105 +58,85 @@ class HookQuerySetMixin:
         model_cls = self.model
         pks = [obj.pk for obj in instances]
 
-        # Load originals for hook comparison
+        # Load originals for hook comparison and ensure they match the order of instances
+        # Use the base manager to avoid recursion
         original_map = {
             obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
         }
         originals = [original_map.get(obj.pk) for obj in instances]
 
-        # Identify complex database expressions (Subquery, Case, F, CombinedExpression, etc.)
-        complex_fields = {}
-        simple_fields = {}
-        for field_name, value in kwargs.items():
-            is_complex = (
-                (hasattr(value, "query") and hasattr(value.query, "model"))
-                or (
-                    hasattr(value, "get_source_expressions")
-                    and value.get_source_expressions()
-                )
-            )
-            if is_complex:
-                complex_fields[field_name] = value
-            else:
-                simple_fields[field_name] = value
-        has_subquery = bool(complex_fields)
+        # Resolve subqueries to actual values before applying to instances
+        resolved_kwargs = self._resolve_subquery_values(kwargs)
 
-        # Run hooks only if not bypassed
-        if not bypass_hooks:
-            ctx = HookContext(model_cls)
-            # Run VALIDATE_UPDATE hooks
-            if not bypass_validation:
-                engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
-
-            # Resolve complex expressions in one shot per field and apply values
-            if has_subquery:
-                # Build annotations for complex fields
-                annotations = {f"__computed_{name}": expr for name, expr in complex_fields.items()}
-                annotation_aliases = list(annotations.keys())
-                if annotations:
-                    computed_rows = (
-                        model_cls._base_manager.filter(pk__in=pks)
-                        .annotate(**annotations)
-                        .values("pk", *annotation_aliases)
-                    )
-                    computed_map = {}
-                    for row in computed_rows:
-                        pk = row["pk"]
-                        field_values = {}
-                        for fname in complex_fields.keys():
-                            alias = f"__computed_{fname}"
-                            field_values[fname] = row.get(alias)
-                        computed_map[pk] = field_values
-
-                    for instance in instances:
-                        values_for_instance = computed_map.get(instance.pk, {})
-                        for fname, fval in values_for_instance.items():
-                            setattr(instance, fname, fval)
-
-            # Apply simple values directly
-            if simple_fields:
-                for obj in instances:
-                    for field, value in simple_fields.items():
-                        setattr(obj, field, value)
-            
-            # Run BEFORE_UPDATE hooks with updated instances
+        # Apply resolved field updates to instances
+        for obj in instances:
+            for field, value in resolved_kwargs.items():
+                setattr(obj, field, value)
+
+        # Check if we're in a bulk operation context to prevent double hook execution
+        from django_bulk_hooks.context import get_bypass_hooks
+
+        current_bypass_hooks = get_bypass_hooks()
+
+        # If we're in a bulk operation context, skip hooks to prevent double execution
+        if current_bypass_hooks:
+            logger.debug("update: skipping hooks (bulk context)")
+            ctx = HookContext(model_cls, bypass_hooks=True)
+        else:
+            logger.debug("update: running hooks (standalone)")
+            ctx = HookContext(model_cls, bypass_hooks=False)
+            # Run validation hooks first
+            engine.run(model_cls, VALIDATE_UPDATE, instances, originals, ctx=ctx)
+            # Then run BEFORE_UPDATE hooks
             engine.run(model_cls, BEFORE_UPDATE, instances, originals, ctx=ctx)
 
-        # Determine if model uses MTI
-        def _is_mti(m):
-            for parent in m._meta.all_parents:
-                if parent._meta.concrete_model is not m._meta.concrete_model:
-                    return True
-            return False
+        # Use Django's built-in update logic directly
+        # Call the base QuerySet implementation to avoid recursion
+        # Use original kwargs so Django can handle subqueries at database level
+        update_count = super().update(**kwargs)
 
-        is_mti = _is_mti(model_cls)
+        # Since we resolved subqueries upfront, we don't need the post-refresh logic
 
-        if is_mti:
-            # Use MTI-aware bulk update across tables
-            fields_to_update = list(kwargs.keys())
-            result = self._mti_bulk_update(instances, fields_to_update)
+        # Run AFTER_UPDATE hooks only for standalone updates
+        if not current_bypass_hooks:
+            logger.debug("update: running AFTER_UPDATE")
+            engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
         else:
-            if has_subquery:
-                # For complex expressions on single-table models, use Django's native update
-                result = super().update(**kwargs)
-                if not bypass_hooks:
-                    # Reload instances to ensure we have DB-final values
-                    updated_instances = list(model_cls._base_manager.filter(pk__in=pks))
-                    updated_map = {obj.pk: obj for obj in updated_instances}
-                    instances = [updated_map.get(obj.pk, obj) for obj in instances]
+            logger.debug("update: skipping AFTER_UPDATE (bulk context)")
+
+        return update_count
+
+    def _resolve_subquery_values(self, kwargs):
+        """
+        Resolve Subquery objects to their actual values by evaluating them
+        against the database. This ensures hooks receive resolved values
+        instead of raw Subquery objects.
+        """
+        resolved_kwargs = {}
+        for field, value in kwargs.items():
+            if hasattr(value, "query") and hasattr(value, "resolve_expression"):
+                # This is a subquery - we need to resolve it
+                try:
+                    # Create a temporary queryset to evaluate the subquery
+                    temp_qs = self.model._default_manager.all()
+                    temp_qs = temp_qs.annotate(_temp_field=value)
+                    temp_qs = temp_qs.values("_temp_field")
+
+                    # Get the resolved value (assuming single result for update context)
+                    resolved_value = temp_qs.first()["_temp_field"]
+                    resolved_kwargs[field] = resolved_value
+                except Exception:
+                    # If resolution fails, use the original subquery
+                    # Django's update() will handle it at the database level
+                    logger.warning(
+                        f"Failed to resolve subquery for field {field}, using original"
+                    )
+                    resolved_kwargs[field] = value
             else:
-                # Simple updates on single-table models
-                base_manager = model_cls._base_manager
-                fields_to_update = list(kwargs.keys())
-                base_manager.bulk_update(instances, fields_to_update)
-                result = len(instances)
+                # Not a subquery, use as-is
+                resolved_kwargs[field] = value
 
-        # Run AFTER_UPDATE hooks only if not bypassed
-        if not bypass_hooks:
-            ctx = HookContext(model_cls)
-            engine.run(model_cls, AFTER_UPDATE, instances, originals, ctx=ctx)
-        
-        return result
+        return resolved_kwargs
 
     @transaction.atomic
     def bulk_create(
@@ -192,34 +149,37 @@ class HookQuerySetMixin:
         unique_fields=None,
         bypass_hooks=False,
         bypass_validation=False,
-    ) -> list:
+    ):
         """
-        Insert each of the instances into the database with complete hook support.
-
-        This method runs the complete hook cycle:
-        VALIDATE_CREATE → BEFORE_CREATE → DB create → AFTER_CREATE
-
-        Behaves like Django's bulk_create but supports multi-table inheritance (MTI)
-        models and hooks. All arguments are supported and passed through to the correct logic.
+        Insert each of the instances into the database. Behaves like Django's bulk_create,
+        but supports multi-table inheritance (MTI) models and hooks. All arguments are supported and
+        passed through to the correct logic. For MTI, only a subset of options may be supported.
         """
         model_cls = self.model
 
-        # Validate inputs
-        if not isinstance(objs, (list, tuple)):
-            raise TypeError("objs must be a list or tuple")
+        # When you bulk insert you don't get the primary keys back (if it's an
+        # autoincrement, except if can_return_rows_from_bulk_insert=True), so
+        # you can't insert into the child tables which references this. There
+        # are two workarounds:
+        # 1) This could be implemented if you didn't have an autoincrement pk
+        # 2) You could do it by doing O(n) normal inserts into the parent
+        #    tables to get the primary keys back and then doing a single bulk
+        #    insert into the childmost table.
+        # We currently set the primary keys on the objects when using
+        # PostgreSQL via the RETURNING ID clause. It should be possible for
+        # Oracle as well, but the semantics for extracting the primary keys is
+        # trickier so it's not done yet.
+        if batch_size is not None and batch_size <= 0:
+            raise ValueError("Batch size must be a positive integer.")
 
         if not objs:
             return objs
 
         if any(not isinstance(obj, model_cls) for obj in objs):
             raise TypeError(
-                f"bulk_create expected instances of {model_cls.__name__}, "
-                f"but got {set(type(obj).__name__ for obj in objs)}"
+                f"bulk_create expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        if batch_size is not None and batch_size <= 0:
-            raise ValueError("batch_size must be a positive integer.")
-
         # Check for MTI - if we detect multi-table inheritance, we need special handling
         # This follows Django's approach: check that the parents share the same concrete model
         # with our model to detect the inheritance pattern ConcreteGrandParent ->
@@ -233,12 +193,12 @@ class HookQuerySetMixin:
 
         # Fire hooks before DB ops
         if not bypass_hooks:
-            ctx = HookContext(model_cls, bypass_hooks=False)
+            ctx = HookContext(model_cls, bypass_hooks=False)  # Pass bypass_hooks
             if not bypass_validation:
                 engine.run(model_cls, VALIDATE_CREATE, objs, ctx=ctx)
             engine.run(model_cls, BEFORE_CREATE, objs, ctx=ctx)
         else:
-            ctx = HookContext(model_cls, bypass_hooks=True)
+            ctx = HookContext(model_cls, bypass_hooks=True)  # Pass bypass_hooks
             logger.debug("bulk_create bypassed hooks")
 
         # For MTI models, we need to handle them specially
@@ -280,129 +240,78 @@ class HookQuerySetMixin:
     @transaction.atomic
     def bulk_update(
         self, objs, fields, bypass_hooks=False, bypass_validation=False, **kwargs
-    ) -> int:
+    ):
         """
-        Bulk update objects in the database with complete hook support.
-
-        This method always runs the complete hook cycle:
-        VALIDATE_UPDATE → BEFORE_UPDATE → DB update → AFTER_UPDATE
-
-        Args:
-            objs: List of model instances to update
-            fields: List of field names to update
-            bypass_hooks: DEPRECATED - kept for backward compatibility only
-            bypass_validation: DEPRECATED - kept for backward compatibility only
-            **kwargs: Additional arguments passed to Django's bulk_update
+        Bulk update objects in the database with MTI support.
         """
         model_cls = self.model
 
         if not objs:
             return []
 
-        # Validate inputs
-        if not isinstance(objs, (list, tuple)):
-            raise TypeError("objs must be a list or tuple")
-
-        if not isinstance(fields, (list, tuple)):
-            raise TypeError("fields must be a list or tuple")
-
-        if not objs:
-            return []
-
-        if not fields:
-            raise ValueError("fields cannot be empty")
-
-        # Validate that all objects are instances of the model
-        for obj in objs:
-            if not isinstance(obj, model_cls):
-                raise TypeError(
-                    f"Expected instances of {model_cls.__name__}, got {type(obj).__name__}"
-                )
-            if obj.pk is None:
-                raise ValueError("All objects must have a primary key")
-
-        # Load originals for hook comparison
-        pks = [obj.pk for obj in objs]
-        original_map = {
-            obj.pk: obj for obj in model_cls._base_manager.filter(pk__in=pks)
-        }
-        originals = [original_map.get(obj.pk) for obj in objs]
-
-        # Run VALIDATE_UPDATE hooks
-        if not bypass_validation:
-            ctx = HookContext(model_cls)
-            engine.run(
-                model_cls, VALIDATE_UPDATE, objs, originals, ctx=ctx
+        if any(not isinstance(obj, model_cls) for obj in objs):
+            raise TypeError(
+                f"bulk_update expected instances of {model_cls.__name__}, but got {set(type(obj).__name__ for obj in objs)}"
             )
 
-        # Run BEFORE_UPDATE hooks
-        if not bypass_hooks:
-            ctx = HookContext(model_cls)
-            engine.run(
-                model_cls, BEFORE_UPDATE, objs, originals, ctx=ctx
-            )
+        logger.debug(
+            f"bulk_update {model_cls.__name__} bypass_hooks={bypass_hooks} objs={len(objs)}"
+        )
 
-        # Determine if model uses MTI
-        def _is_mti(m):
-            for parent in m._meta.all_parents:
-                if parent._meta.concrete_model is not m._meta.concrete_model:
-                    return True
-            return False
+        # Check for MTI
+        is_mti = False
+        for parent in model_cls._meta.all_parents:
+            if parent._meta.concrete_model is not model_cls._meta.concrete_model:
+                is_mti = True
+                break
 
-        if _is_mti(model_cls):
-            # Use MTI-aware bulk update across tables
+        if not bypass_hooks:
+            logger.debug("bulk_update: hooks will run in update()")
+            ctx = HookContext(model_cls, bypass_hooks=False)
+            originals = [None] * len(objs)  # Placeholder for after_update call
+        else:
+            logger.debug("bulk_update: hooks bypassed")
+            ctx = HookContext(model_cls, bypass_hooks=True)
+            originals = [None] * len(
+                objs
+            )  # Ensure originals is defined for after_update call
+
+        # Handle auto_now fields like Django's update_or_create does
+        fields_set = set(fields)
+        pk_fields = model_cls._meta.pk_fields
+        for field in model_cls._meta.local_concrete_fields:
+            # Only add auto_now fields (like updated_at) that aren't already in the fields list
+            # Don't include auto_now_add fields (like created_at) as they should only be set on creation
+            if hasattr(field, "auto_now") and field.auto_now:
+                if field.name not in fields_set and field.name not in pk_fields:
+                    fields_set.add(field.name)
+                    if field.name != field.attname:
+                        fields_set.add(field.attname)
+        fields = list(fields_set)
+
+        # Handle MTI models differently
+        if is_mti:
             result = self._mti_bulk_update(objs, fields, **kwargs)
         else:
-            # Perform database update using Django's native bulk_update
-            # We use the base manager to avoid recursion
-            base_manager = model_cls._base_manager
-            result = base_manager.bulk_update(objs, fields, **kwargs)
+            # For single-table models, use Django's built-in bulk_update
+            django_kwargs = {
+                k: v
+                for k, v in kwargs.items()
+                if k not in ["bypass_hooks", "bypass_validation"]
+            }
+            logger.debug("Calling Django bulk_update")
+            result = super().bulk_update(objs, fields, **django_kwargs)
+            logger.debug(f"Django bulk_update done: {result}")
 
-        # Run AFTER_UPDATE hooks
+        # Note: We don't run AFTER_UPDATE hooks here to prevent double execution
+        # The update() method will handle all hook execution based on thread-local state
         if not bypass_hooks:
-            ctx = HookContext(model_cls)
-            engine.run(model_cls, AFTER_UPDATE, objs, originals, ctx=ctx)
+            logger.debug("bulk_update: skipping AFTER_UPDATE (update() will handle)")
+        else:
+            logger.debug("bulk_update: hooks bypassed")
 
         return result
 
-    @transaction.atomic
-    def bulk_delete(self, objs, **kwargs) -> int:
-        """
-        Delete the given objects from the database with complete hook support.
-
-        This method runs the complete hook cycle:
-        VALIDATE_DELETE → BEFORE_DELETE → DB delete → AFTER_DELETE
-
-        This is a convenience method that provides a bulk_delete interface
-        similar to bulk_create and bulk_update.
-        """
-        model_cls = self.model
-
-        # Extract custom kwargs
-        kwargs.pop("bypass_hooks", False)
-
-        # Validate inputs
-        if not isinstance(objs, (list, tuple)):
-            raise TypeError("objs must be a list or tuple")
-
-        if not objs:
-            return 0
-
-        # Validate that all objects are instances of the model
-        for obj in objs:
-            if not isinstance(obj, model_cls):
-                raise TypeError(
-                    f"Expected instances of {model_cls.__name__}, got {type(obj).__name__}"
-                )
-
-        # Get the pks to delete
-        pks = [obj.pk for obj in objs if obj.pk is not None]
-        if not pks:
-            return 0
-
-        # Use the delete() method which already has hook support
-        return self.filter(pk__in=pks).delete()
-
     def _detect_modified_fields(self, new_instances, original_instances):
         """
         Detect fields that were modified during BEFORE_UPDATE hooks by comparing
@@ -504,83 +413,50 @@ class HookQuerySetMixin:
         # Then we can use Django's bulk_create for the child objects
         parent_objects_map = {}
 
-        # Step 1: Insert into parent tables to get primary keys back
+        # Step 1: Do O(n) normal inserts into parent tables to get primary keys back
+        # Get bypass_hooks from kwargs
         bypass_hooks = kwargs.get("bypass_hooks", False)
         bypass_validation = kwargs.get("bypass_validation", False)
 
-        # If DB supports returning rows from bulk insert, batch per parent model
-        supports_returning = connections[self.db].features.can_return_rows_from_bulk_insert
-
-        if supports_returning:
-            # For each parent level in the chain, create instances in batch preserving order
-            current_parents_per_obj = {id(obj): None for obj in batch}
+        for obj in batch:
+            parent_instances = {}
+            current_parent = None
             for model_class in inheritance_chain[:-1]:
-                parent_objs = [
-                    self._create_parent_instance(obj, model_class, current_parents_per_obj[id(obj)])
-                    for obj in batch
-                ]
+                parent_obj = self._create_parent_instance(
+                    obj, model_class, current_parent
+                )
 
+                # Fire parent hooks if not bypassed
                 if not bypass_hooks:
                     ctx = HookContext(model_class)
                     if not bypass_validation:
-                        engine.run(model_class, VALIDATE_CREATE, parent_objs, ctx=ctx)
-                    engine.run(model_class, BEFORE_CREATE, parent_objs, ctx=ctx)
-
-                # Bulk insert parents using base manager to avoid hook recursion
-                created_parents = model_class._base_manager.using(self.db).bulk_create(
-                    parent_objs, batch_size=len(parent_objs)
+                        engine.run(model_class, VALIDATE_CREATE, [parent_obj], ctx=ctx)
+                    engine.run(model_class, BEFORE_CREATE, [parent_obj], ctx=ctx)
+
+                # Use Django's base manager to create the object and get PKs back
+                # This bypasses hooks and the MTI exception
+                field_values = {
+                    field.name: getattr(parent_obj, field.name)
+                    for field in model_class._meta.local_fields
+                    if hasattr(parent_obj, field.name)
+                    and getattr(parent_obj, field.name) is not None
+                }
+                created_obj = model_class._base_manager.using(self.db).create(
+                    **field_values
                 )
 
-                # After create hooks
-                if not bypass_hooks:
-                    engine.run(model_class, AFTER_CREATE, created_parents, ctx=ctx)
-
-                # Update maps and state for next parent level
-                for obj, parent_obj in zip(batch, created_parents):
-                    # Ensure state reflects saved
-                    parent_obj._state.adding = False
-                    parent_obj._state.db = self.db
-                    # Record for this object and level
-                    if id(obj) not in parent_objects_map:
-                        parent_objects_map[id(obj)] = {}
-                    parent_objects_map[id(obj)][model_class] = parent_obj
-                    current_parents_per_obj[id(obj)] = parent_obj
-        else:
-            # Fallback: per-row parent inserts (original behavior)
-            for obj in batch:
-                parent_instances = {}
-                current_parent = None
-                for model_class in inheritance_chain[:-1]:
-                    parent_obj = self._create_parent_instance(
-                        obj, model_class, current_parent
-                    )
-
-                    if not bypass_hooks:
-                        ctx = HookContext(model_class)
-                        if not bypass_validation:
-                            engine.run(model_class, VALIDATE_CREATE, [parent_obj], ctx=ctx)
-                        engine.run(model_class, BEFORE_CREATE, [parent_obj], ctx=ctx)
-
-                    field_values = {
-                        field.name: getattr(parent_obj, field.name)
-                        for field in model_class._meta.local_fields
-                        if hasattr(parent_obj, field.name)
-                        and getattr(parent_obj, field.name) is not None
-                    }
-                    created_obj = model_class._base_manager.using(self.db).create(
-                        **field_values
-                    )
+                # Update the parent_obj with the created object's PK
+                parent_obj.pk = created_obj.pk
+                parent_obj._state.adding = False
+                parent_obj._state.db = self.db
 
-                    parent_obj.pk = created_obj.pk
-                    parent_obj._state.adding = False
-                    parent_obj._state.db = self.db
-
-                    if not bypass_hooks:
-                        engine.run(model_class, AFTER_CREATE, [parent_obj], ctx=ctx)
+                # Fire AFTER_CREATE hooks for parent
+                if not bypass_hooks:
+                    engine.run(model_class, AFTER_CREATE, [parent_obj], ctx=ctx)
 
-                    parent_instances[model_class] = parent_obj
-                    current_parent = parent_obj
-                parent_objects_map[id(obj)] = parent_instances
+                parent_instances[model_class] = parent_obj
+                current_parent = parent_obj
+            parent_objects_map[id(obj)] = parent_instances
 
         # Step 2: Create all child objects and do single bulk insert into childmost table
         child_model = inheritance_chain[-1]
@@ -806,8 +682,7 @@ class HookQuerySetMixin:
         # For MTI, we need to handle parent links correctly
         # The root model (first in chain) has its own PK
         # Child models use the parent link to reference the root PK
-        # Root model (first in chain) has its own PK; kept for clarity
-        # root_model = inheritance_chain[0]
+        root_model = inheritance_chain[0]
 
         # Get the primary keys from the objects
         # If objects have pk set but are not loaded from DB, use those PKs
@@ -891,7 +766,7 @@ class HookQuerySetMixin:
                         **{f"{filter_field}__in": pks}
                     ).update(**case_statements)
                     total_updated += updated_count
-                except Exception:
+                except Exception as e:
                     import traceback
 
                     traceback.print_exc()