django-bulk-hooks 0.2.67__tar.gz → 0.2.68__tar.gz

{django_bulk_hooks-0.2.67 → django_bulk_hooks-0.2.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.67
+Version: 0.2.68
 Summary: Hook-style hooks for Django bulk operations like bulk_create and bulk_update.
 License: MIT
 Keywords: django,bulk,hooks

{django_bulk_hooks-0.2.67 → django_bulk_hooks-0.2.68}/django_bulk_hooks/dispatcher.py

@@ -126,12 +126,16 @@ class HookDispatcher:
         # NEW: Preload relationships needed for condition evaluation
         if condition:
             condition_relationships = self._extract_condition_relationships(condition, changeset.model_cls)
+            logger.info(f"🔍 CONDITION: {handler_cls.__name__}.{method_name} has condition, extracted relationships: {condition_relationships}")
             if condition_relationships:
+                logger.info(f"🔗 PRELOADING: Preloading condition relationships for {len(changeset.changes)} records")
                 self._preload_condition_relationships(changeset, condition_relationships)
 
         # Filter records based on condition (now safe - relationships are preloaded)
         if condition:
+            logger.info(f"⚡ EVALUATING: Checking condition for {handler_cls.__name__}.{method_name} on {len(changeset.changes)} records")
             filtered_changes = [change for change in changeset.changes if condition.check(change.new_record, change.old_record)]
+            logger.info(f"✅ CONDITION: {len(filtered_changes)}/{len(changeset.changes)} records passed condition filter")
 
             if not filtered_changes:
                 # No records match condition, skip this hook

{django_bulk_hooks-0.2.67 → django_bulk_hooks-0.2.68}/django_bulk_hooks/operations/coordinator.py

@@ -366,8 +366,19 @@ class BulkOperationCoordinator:
         Returns:
             Number of rows updated
         """
-        # Step 1: Fetch old state (before database update)
-        old_instances = list(self.queryset)
+        # Step 0: Extract relationships that hooks might access to avoid N+1 queries
+        hook_relationships = self._extract_hook_relationships()
+
+        # Step 1: Fetch old state (before database update) with relationships preloaded
+        if hook_relationships:
+            logger.info(f"🔗 BULK PRELOAD: Fetching {self.queryset.count()} old instances with select_related({list(hook_relationships)})")
+            old_queryset = self.queryset.select_related(*hook_relationships)
+        else:
+            logger.info(f"🔗 BULK PRELOAD: Fetching {self.queryset.count()} old instances without select_related")
+            old_queryset = self.queryset
+
+        old_instances = list(old_queryset)
+        logger.info(f"✅ Fetched {len(old_instances)} old instances")
         if not old_instances:
             return 0
 
@@ -380,11 +391,20 @@ class BulkOperationCoordinator:
         if update_count == 0:
             return 0
 
-        # Step 3: Fetch new state (after database update)
+        # Step 3: Fetch new state (after database update) with relationships preloaded
         # This captures any Subquery/F() computed values
         # Use primary keys to fetch updated instances since queryset filters may no longer match
         pks = [inst.pk for inst in old_instances]
-        new_instances = list(self.model_cls.objects.filter(pk__in=pks))
+
+        if hook_relationships:
+            logger.info(f"🔗 BULK PRELOAD: Fetching {len(pks)} new instances with select_related({list(hook_relationships)})")
+            new_queryset = self.model_cls.objects.filter(pk__in=pks).select_related(*hook_relationships)
+        else:
+            logger.info(f"🔗 BULK PRELOAD: Fetching {len(pks)} new instances without select_related")
+            new_queryset = self.model_cls.objects.filter(pk__in=pks)
+
+        new_instances = list(new_queryset)
+        logger.info(f"✅ Fetched {len(new_instances)} new instances")
 
         # Step 4: Build changeset
         changeset = build_changeset_for_update(
@@ -870,6 +890,57 @@ class BulkOperationCoordinator:
         # Clean up temporary metadata
         self._cleanup_upsert_metadata(result_objects)
 
+    def _extract_hook_relationships(self):
+        """
+        Extract all relationship paths that hooks might access for this model and its MTI parents.
+
+        This prevents N+1 queries by preloading all relationships that any hook
+        (condition or @select_related) might access during bulk operations.
+
+        Returns:
+            set: Set of relationship field names to preload with select_related
+        """
+        relationships = set()
+
+        # Get the dispatcher to access hook registry
+        dispatcher = self.dispatcher
+
+        # Get all models in the inheritance chain (including parents for MTI)
+        models_to_check = self._get_models_in_chain(self.model_cls)
+
+        # Check hooks for all relevant events that might run during bulk operations
+        events_to_check = ['before_update', 'after_update', 'validate_update']
+
+        for model_cls in models_to_check:
+            logger.info(f"🔍 BULK PRELOAD: Checking hooks for model {model_cls.__name__}")
+            for event in events_to_check:
+                hooks = dispatcher.registry.get_hooks(model_cls, event)
+                logger.info(f"  🔍 Found {len(hooks)} hooks for {model_cls.__name__}.{event}")
+
+                for handler_cls, method_name, condition, priority in hooks:
+                    logger.info(f"    → Checking {handler_cls.__name__}.{method_name}")
+
+                    # Extract relationships from conditions
+                    if condition:
+                        condition_relationships = dispatcher._extract_condition_relationships(condition, model_cls)
+                        if condition_relationships:
+                            logger.info(f"      📋 Condition relationships for {model_cls.__name__}: {condition_relationships}")
+                            relationships.update(condition_relationships)
+
+                    # Extract relationships from @select_related decorators
+                    try:
+                        method = getattr(handler_cls, method_name, None)
+                        if method:
+                            select_related_fields = getattr(method, "_select_related_fields", None)
+                            if select_related_fields and hasattr(select_related_fields, '__iter__'):
+                                logger.info(f"      🔗 @select_related fields on {handler_cls.__name__}.{method_name}: {list(select_related_fields)}")
+                                relationships.update(select_related_fields)
+                    except Exception as e:
+                        logger.warning(f"      ❌ Failed to extract @select_related from {handler_cls.__name__}.{method_name}: {e}")
+
+        logger.info(f"🔗 BULK PRELOAD: Total extracted relationships for {self.model_cls.__name__}: {list(relationships)}")
+        return relationships
+
     def _cleanup_upsert_metadata(self, result_objects):
         """
         Clean up temporary metadata added during upsert operations.

{django_bulk_hooks-0.2.67 → django_bulk_hooks-0.2.68}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-bulk-hooks"
-version = "0.2.67"
+version = "0.2.68"
 description = "Hook-style hooks for Django bulk operations like bulk_create and bulk_update."
 authors = ["Konrad Beck <konrad.beck@merchantcapital.co.za>"]
 readme = "README.md"