django-bulk-hooks 0.2.42__py3-none-any.whl → 0.2.50__py3-none-any.whl

django_bulk_hooks/operations/coordinator.py

@@ -29,7 +29,6 @@ class BulkOperationCoordinator:
     Services are created lazily and cached.
     """
 
-
     def __init__(self, queryset):
         """
         Initialize coordinator for a queryset.
@@ -133,6 +132,23 @@ class BulkOperationCoordinator:
         # Validate
         self.analyzer.validate_for_create(objs)
 
+        # For upsert operations, classify records upfront
+        existing_record_ids = set()
+        existing_pks_map = {}
+        if update_conflicts and unique_fields:
+            # For MTI models, query the parent model that has the unique fields
+            query_model = None
+            if self.mti_handler.is_mti_model():
+                query_model = self.mti_handler.find_model_with_unique_fields(unique_fields)
+                logger.info(f"MTI model detected: querying {query_model.__name__} for unique fields {unique_fields}")
+            
+            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(
+                objs, unique_fields, query_model=query_model
+            )
+            logger.info(f"Upsert operation: {len(existing_record_ids)} existing, {len(objs) - len(existing_record_ids)} new records")
+            logger.debug(f"Existing record IDs: {existing_record_ids}")
+            logger.debug(f"Existing PKs map: {existing_pks_map}")
+
         # Build initial changeset
         changeset = build_changeset_for_create(
             self.model_cls,
@@ -153,6 +169,8 @@ class BulkOperationCoordinator:
                 update_conflicts=update_conflicts,
                 update_fields=update_fields,
                 unique_fields=unique_fields,
+                existing_record_ids=existing_record_ids,
+                existing_pks_map=existing_pks_map,
             )
 
         return self._execute_with_mti_hooks(
@@ -222,14 +240,17 @@ class BulkOperationCoordinator:
 
     @transaction.atomic
     def update_queryset(
-        self, update_kwargs, bypass_hooks=False, bypass_validation=False,
+        self,
+        update_kwargs,
+        bypass_hooks=False,
+        bypass_validation=False,
     ):
         """
         Execute queryset.update() with full hook support.
-        
+
         ARCHITECTURE & PERFORMANCE TRADE-OFFS
         ======================================
-        
+
         To support hooks with queryset.update(), we must:
         1. Fetch old state (SELECT all matching rows)
         2. Execute database update (UPDATE in SQL)
@@ -238,29 +259,29 @@ class BulkOperationCoordinator:
         5. Run BEFORE_UPDATE hooks (CAN modify instances)
         6. Persist BEFORE_UPDATE modifications (bulk_update)
         7. Run AFTER_UPDATE hooks (read-only side effects)
-        
+
         Performance Cost:
         - 2 SELECT queries (before/after)
         - 1 UPDATE query (actual update)
         - 1 bulk_update (if hooks modify data)
-        
+
         Trade-off: Hooks require loading data into Python. If you need
         maximum performance and don't need hooks, use bypass_hooks=True.
-        
+
         Hook Semantics:
         - BEFORE_UPDATE hooks run after the DB update and CAN modify instances
         - Modifications are auto-persisted (framework handles complexity)
         - AFTER_UPDATE hooks run after BEFORE_UPDATE and are read-only
         - This enables cascade logic and computed fields based on DB values
         - User expectation: BEFORE_UPDATE hooks can modify data
-        
+
         Why this approach works well:
         - Allows hooks to see Subquery/F() computed values
         - Enables HasChanged conditions on complex expressions
         - Maintains SQL performance (Subquery stays in database)
         - Meets user expectations: BEFORE_UPDATE can modify instances
         - Clean separation: BEFORE for modifications, AFTER for side effects
-        
+
         For true "prevent write" semantics, intercept at a higher level
         or use bulk_update() directly (which has true before semantics).
         """
@@ -277,19 +298,21 @@ class BulkOperationCoordinator:
         )
 
     def _execute_queryset_update_with_hooks(
-        self, update_kwargs, bypass_validation=False,
+        self,
+        update_kwargs,
+        bypass_validation=False,
     ):
         """
         Execute queryset update with full hook lifecycle support.
-        
+
         This method implements the fetch-update-fetch pattern required
         to support hooks with queryset.update(). BEFORE_UPDATE hooks can
         modify instances and modifications are auto-persisted.
-        
+
         Args:
             update_kwargs: Dict of fields to update
             bypass_validation: Skip validation hooks if True
-            
+
         Returns:
             Number of rows updated
         """
@@ -373,11 +396,11 @@ class BulkOperationCoordinator:
     def _run_before_update_hooks_with_tracking(self, instances, models_in_chain, changeset):
         """
         Run BEFORE_UPDATE hooks and detect modifications.
-        
+
         This is what users expect - BEFORE_UPDATE hooks can modify instances
         and those modifications will be automatically persisted. The framework
         handles the complexity internally.
-        
+
         Returns:
             Set of field names that were modified by hooks
         """
@@ -399,10 +422,10 @@ class BulkOperationCoordinator:
     def _snapshot_instance_state(self, instances):
         """
         Create a snapshot of current instance field values.
-        
+
         Args:
             instances: List of model instances
-            
+
         Returns:
             Dict mapping pk -> {field_name: value}
         """
@@ -432,11 +455,11 @@ class BulkOperationCoordinator:
     def _detect_modifications(self, instances, pre_hook_state):
         """
         Detect which fields were modified by comparing to snapshot.
-        
+
         Args:
             instances: List of model instances
             pre_hook_state: Previous state snapshot from _snapshot_instance_state
-            
+
         Returns:
             Set of field names that were modified
         """
@@ -463,16 +486,15 @@ class BulkOperationCoordinator:
     def _persist_hook_modifications(self, instances, modified_fields):
         """
         Persist modifications made by hooks using bulk_update.
-        
+
         This creates a "cascade" effect similar to Salesforce workflows.
-        
+
         Args:
             instances: List of modified instances
             modified_fields: Set of field names that were modified
         """
         logger.info(
-            f"Hooks modified {len(modified_fields)} field(s): "
-            f"{', '.join(sorted(modified_fields))}",
+            f"Hooks modified {len(modified_fields)} field(s): {', '.join(sorted(modified_fields))}",
         )
         logger.info("Auto-persisting modifications via bulk_update")
 
@@ -555,14 +577,14 @@ class BulkOperationCoordinator:
     def _build_changeset_for_model(self, original_changeset, target_model_cls):
         """
         Build a changeset for a specific model in the MTI inheritance chain.
-        
+
         This allows parent model hooks to receive the same instances but with
         the correct model_cls for hook registration matching.
-        
+
         Args:
             original_changeset: The original changeset (for child model)
             target_model_cls: The model class to build changeset for (parent model)
-            
+
         Returns:
             ChangeSet for the target model
         """
@@ -586,18 +608,18 @@ class BulkOperationCoordinator:
     ):
         """
         Execute operation with hooks for entire MTI inheritance chain.
-        
+
         This method dispatches hooks for both child and parent models when
         dealing with MTI models, ensuring parent model hooks fire when
         child instances are created/updated/deleted.
-        
+
         Args:
             changeset: ChangeSet for the child model
             operation: Callable that performs the actual DB operation
             event_prefix: 'create', 'update', or 'delete'
             bypass_hooks: Skip all hooks if True
             bypass_validation: Skip validation hooks if True
-            
+
         Returns:
             Result of operation
         """
@@ -627,13 +649,25 @@ class BulkOperationCoordinator:
         # AFTER phase - for all models in chain
         # Use result if operation returns modified data (for create operations)
         if result and isinstance(result, list) and event_prefix == "create":
-            # Rebuild changeset with assigned PKs for AFTER hooks
-            from django_bulk_hooks.helpers import build_changeset_for_create
-            changeset = build_changeset_for_create(changeset.model_cls, result)
-
-        for model_cls in models_in_chain:
-            model_changeset = self._build_changeset_for_model(changeset, model_cls)
-            self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
+            # Check if this was an upsert operation
+            is_upsert = self._is_upsert_operation(result)
+            if is_upsert:
+                # Split hooks for upsert: after_create for created, after_update for updated
+                self._dispatch_upsert_after_hooks(result, models_in_chain)
+            else:
+                # Normal create operation
+                from django_bulk_hooks.helpers import build_changeset_for_create
+
+                changeset = build_changeset_for_create(changeset.model_cls, result)
+
+                for model_cls in models_in_chain:
+                    model_changeset = self._build_changeset_for_model(changeset, model_cls)
+                    self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
+        else:
+            # Non-create operations (update, delete)
+            for model_cls in models_in_chain:
+                model_changeset = self._build_changeset_for_model(changeset, model_cls)
+                self.dispatcher.dispatch(model_changeset, f"after_{event_prefix}", bypass_hooks=False)
 
         return result
 
@@ -655,11 +689,13 @@ class BulkOperationCoordinator:
         for field_name in update_kwargs.keys():
             try:
                 field = self.model_cls._meta.get_field(field_name)
-                if (field.is_relation and
-                    not field.many_to_many and
-                    not field.one_to_many and
-                    hasattr(field, "attname") and
-                    field.attname == field_name):
+                if (
+                    field.is_relation
+                    and not field.many_to_many
+                    and not field.one_to_many
+                    and hasattr(field, "attname")
+                    and field.attname == field_name
+                ):
                     # This is a FK field being updated by its attname (e.g., business_id)
                     # Add the relationship name (e.g., 'business') to skip list
                     fk_relationships.add(field.name)
@@ -668,3 +704,117 @@ class BulkOperationCoordinator:
                 continue
 
         return fk_relationships
+
+    def _is_upsert_operation(self, result_objects):
+        """
+        Check if the operation was an upsert (with update_conflicts=True).
+
+        Args:
+            result_objects: List of objects returned from the operation
+
+        Returns:
+            True if this was an upsert operation, False otherwise
+        """
+        if not result_objects:
+            return False
+
+        # Check if any object has upsert metadata
+        return hasattr(result_objects[0], "_bulk_hooks_upsert_metadata")
+
+    def _dispatch_upsert_after_hooks(self, result_objects, models_in_chain):
+        """
+        Dispatch after hooks for upsert operations, splitting by create/update.
+
+        This matches Salesforce behavior:
+        - Records that were created fire after_create hooks
+        - Records that were updated fire after_update hooks
+
+        Args:
+            result_objects: List of objects returned from the operation
+            models_in_chain: List of model classes in the MTI inheritance chain
+        """
+        # Split objects based on metadata set by the executor
+        created_objects = []
+        updated_objects = []
+
+        if not result_objects:
+            return
+
+        for obj in result_objects:
+            # Check if metadata was set
+            if hasattr(obj, "_bulk_hooks_was_created"):
+                was_created = getattr(obj, "_bulk_hooks_was_created", True)
+                if was_created:
+                    created_objects.append(obj)
+                else:
+                    updated_objects.append(obj)
+            else:
+                # Fallback: if no metadata, check timestamps
+                model_cls = obj.__class__
+                if hasattr(model_cls, "created_at") and hasattr(model_cls, "updated_at"):
+                    # Reload from DB to get accurate timestamps
+                    db_obj = model_cls.objects.filter(pk=obj.pk).values("created_at", "updated_at").first()
+                    if db_obj:
+                        created_at = db_obj["created_at"]
+                        updated_at = db_obj["updated_at"]
+                        if created_at and updated_at:
+                            time_diff = abs((updated_at - created_at).total_seconds())
+                            if time_diff <= 1.0:  # Within 1 second = just created
+                                created_objects.append(obj)
+                            else:
+                                updated_objects.append(obj)
+                        else:
+                            # No timestamps, default to created
+                            created_objects.append(obj)
+                    else:
+                        # Object not found, treat as created
+                        created_objects.append(obj)
+                else:
+                    # No timestamp fields, default to created
+                    created_objects.append(obj)
+
+        logger.info(f"Upsert after hooks: {len(created_objects)} created, {len(updated_objects)} updated")
+
+        # Dispatch after_create hooks for created objects
+        if created_objects:
+            from django_bulk_hooks.helpers import build_changeset_for_create
+
+            create_changeset = build_changeset_for_create(self.model_cls, created_objects)
+
+            for model_cls in models_in_chain:
+                model_changeset = self._build_changeset_for_model(create_changeset, model_cls)
+                self.dispatcher.dispatch(model_changeset, "after_create", bypass_hooks=False)
+
+        # Dispatch after_update hooks for updated objects
+        if updated_objects:
+            # Fetch old records for proper change detection
+            old_records_map = self.analyzer.fetch_old_records_map(updated_objects)
+
+            from django_bulk_hooks.helpers import build_changeset_for_update
+
+            update_changeset = build_changeset_for_update(
+                self.model_cls,
+                updated_objects,
+                update_kwargs={},  # Empty since we don't know specific fields
+                old_records_map=old_records_map,
+            )
+
+            for model_cls in models_in_chain:
+                model_changeset = self._build_changeset_for_model(update_changeset, model_cls)
+                self.dispatcher.dispatch(model_changeset, "after_update", bypass_hooks=False)
+
+        # Clean up temporary metadata
+        self._cleanup_upsert_metadata(result_objects)
+
+    def _cleanup_upsert_metadata(self, result_objects):
+        """
+        Clean up temporary metadata added during upsert operations.
+
+        Args:
+            result_objects: List of objects to clean up
+        """
+        for obj in result_objects:
+            if hasattr(obj, "_bulk_hooks_was_created"):
+                delattr(obj, "_bulk_hooks_was_created")
+            if hasattr(obj, "_bulk_hooks_upsert_metadata"):
+                delattr(obj, "_bulk_hooks_upsert_metadata")

django_bulk_hooks/operations/mti_handler.py

@@ -20,7 +20,7 @@ class MTIHandler:
 
     This service detects MTI models and builds execution plans.
     It does NOT execute database operations - that's the BulkExecutor's job.
-    
+
     Responsibilities:
     - Detect MTI models
     - Build inheritance chains
@@ -45,8 +45,9 @@ class MTIHandler:
         Returns:
             bool: True if model has concrete parent models
         """
-        for parent in self.model_cls._meta.all_parents:
-            if parent._meta.concrete_model != self.model_cls._meta.concrete_model:
+        # Check if this model has concrete parent models (not abstract)
+        for parent in self.model_cls._meta.parents.keys():
+            if not parent._meta.abstract and parent._meta.concrete_model != self.model_cls._meta.concrete_model:
                 return True
         return False
 
@@ -73,15 +74,11 @@ class MTIHandler:
         current_model = self.model_cls
 
         while current_model:
-            if not current_model._meta.proxy:
+            if not current_model._meta.proxy and not current_model._meta.abstract:
                 chain.append(current_model)
 
-            # Get concrete parent models
-            parents = [
-                parent
-                for parent in current_model._meta.parents.keys()
-                if not parent._meta.proxy
-            ]
+            # Get concrete parent models (not abstract, not proxy)
+            parents = [parent for parent in current_model._meta.parents.keys() if not parent._meta.proxy and not parent._meta.abstract]
 
             current_model = parents[0] if parents else None
 
@@ -113,6 +110,37 @@ class MTIHandler:
         """
         return list(model_cls._meta.local_fields)
 
+    def find_model_with_unique_fields(self, unique_fields):
+        """
+        Find which model in the inheritance chain to query for existing records.
+
+        For MTI upsert operations, we need to determine if the parent record exists
+        to properly fire AFTER_CREATE vs AFTER_UPDATE hooks. This is critical because:
+        - If parent exists but child doesn't: creating child for existing parent → AFTER_UPDATE
+        - If neither exists: creating both parent and child → AFTER_CREATE
+
+        Therefore, we return the root parent model to check if the parent record exists,
+        regardless of where the unique fields are defined.
+
+        Args:
+            unique_fields: List of field names forming the unique constraint
+
+        Returns:
+            Model class to query for existing records (root parent for MTI)
+        """
+        if not unique_fields:
+            return self.model_cls
+
+        inheritance_chain = self.get_inheritance_chain()
+
+        # For MTI models with multiple levels, return the root parent model
+        # This ensures we check if the parent exists, which determines create vs update hooks
+        if len(inheritance_chain) > 1:
+            return inheritance_chain[0]  # Root parent model
+
+        # For non-MTI models (shouldn't happen, but safe fallback)
+        return self.model_cls
+
     # ==================== MTI BULK CREATE PLANNING ====================
 
     def build_create_plan(
@@ -127,10 +155,10 @@ class MTIHandler:
     ):
         """
         Build an execution plan for bulk creating MTI model instances.
-        
+
         This method does NOT execute any database operations.
         It returns a plan that the BulkExecutor will execute.
-        
+
         Args:
             objs: List of model instances to create
             batch_size: Number of objects per batch
@@ -139,7 +167,7 @@ class MTIHandler:
             update_fields: Fields to update on conflict
             existing_record_ids: Set of id() for objects that exist in DB (from RecordClassifier)
             existing_pks_map: Dict mapping id(obj) -> pk for existing records (from RecordClassifier)
-            
+
         Returns:
             MTICreatePlan object
         """
@@ -205,9 +233,9 @@ class MTIHandler:
     ):
         """
         Build parent level objects for each level in the inheritance chain.
-        
+
         This is pure in-memory object creation - no DB operations.
-        
+
         Returns:
             List of ParentLevel objects
         """
@@ -255,15 +283,19 @@ class MTIHandler:
                 # Check if this model has a matching constraint
                 if normalized_unique and self._has_matching_constraint(model_class, normalized_unique):
                     # Filter update fields
-                    filtered_updates = [
-                        uf for uf in (update_fields or []) if uf in model_fields_by_name
-                    ]
+                    filtered_updates = [uf for uf in (update_fields or []) if uf in model_fields_by_name]
 
-                    # Enable upsert even if no fields to update at this level
-                    # This prevents unique constraint violations on parent tables
-                    level_update_conflicts = True
-                    level_unique_fields = normalized_unique
-                    level_update_fields = filtered_updates  # Can be empty list
+                    # If no fields to update at this level but we need upsert to prevent
+                    # unique constraint violations, use one of the unique fields as a dummy
+                    # update field (updating it to itself is a safe no-op)
+                    if not filtered_updates and normalized_unique:
+                        filtered_updates = [normalized_unique[0]]
+
+                    # Only enable upsert if we have fields to update (real or dummy)
+                    if filtered_updates:
+                        level_update_conflicts = True
+                        level_unique_fields = normalized_unique
+                        level_update_fields = filtered_updates
 
             # Create parent level
             parent_level = ParentLevel(
@@ -282,10 +314,8 @@ class MTIHandler:
         """Check if model has a unique constraint matching the given fields."""
         try:
             from django.db.models import UniqueConstraint
-            constraint_field_sets = [
-                tuple(c.fields) for c in model_class._meta.constraints
-                if isinstance(c, UniqueConstraint)
-            ]
+
+            constraint_field_sets = [tuple(c.fields) for c in model_class._meta.constraints if isinstance(c, UniqueConstraint)]
         except Exception:
             constraint_field_sets = []
 
@@ -313,12 +343,12 @@ class MTIHandler:
     def _create_parent_instance(self, source_obj, parent_model, current_parent):
         """
         Create a parent instance from source object (in-memory only).
-        
+
         Args:
             source_obj: Original object with data
             parent_model: Parent model class to create instance of
             current_parent: Parent instance from previous level (if any)
-            
+
         Returns:
             Parent model instance (not saved)
         """
@@ -329,8 +359,7 @@ class MTIHandler:
             if hasattr(source_obj, field.name):
                 value = getattr(source_obj, field.name, None)
                 if value is not None:
-                    if (field.is_relation and not field.many_to_many and
-                        not field.one_to_many):
+                    if field.is_relation and not field.many_to_many and not field.one_to_many:
                         # Handle FK fields
                         if hasattr(value, "pk") and value.pk is not None:
                             setattr(parent_obj, field.attname, value.pk)
@@ -342,8 +371,7 @@ class MTIHandler:
         # Link to parent if exists
         if current_parent is not None:
             for field in parent_model._meta.local_fields:
-                if (hasattr(field, "remote_field") and field.remote_field and
-                    field.remote_field.model == current_parent.__class__):
+                if hasattr(field, "remote_field") and field.remote_field and field.remote_field.model == current_parent.__class__:
                     setattr(parent_obj, field.name, current_parent)
                     break
 
@@ -367,13 +395,13 @@ class MTIHandler:
     def _create_child_instance_template(self, source_obj, child_model):
         """
         Create a child instance template (in-memory only, without parent links).
-        
+
         The executor will add parent links after creating parent objects.
-        
+
         Args:
             source_obj: Original object with data
             child_model: Child model class
-            
+
         Returns:
             Child model instance (not saved, no parent links)
         """
@@ -393,8 +421,7 @@ class MTIHandler:
             if hasattr(source_obj, field.name):
                 value = getattr(source_obj, field.name, None)
                 if value is not None:
-                    if (field.is_relation and not field.many_to_many and
-                        not field.one_to_many):
+                    if field.is_relation and not field.many_to_many and not field.one_to_many:
                         if hasattr(value, "pk") and value.pk is not None:
                             setattr(child_obj, field.attname, value.pk)
                         else:
@@ -424,14 +451,14 @@ class MTIHandler:
     def build_update_plan(self, objs, fields, batch_size=None):
         """
         Build an execution plan for bulk updating MTI model instances.
-        
+
         This method does NOT execute any database operations.
-        
+
         Args:
             objs: List of model instances to update
             fields: List of field names to update
             batch_size: Number of objects per batch
-            
+
         Returns:
             MTIUpdatePlan object
         """
@@ -491,11 +518,13 @@ class MTIHandler:
                             break
                     filter_field = parent_link.attname if parent_link else "pk"
 
-                field_groups.append(ModelFieldGroup(
-                    model_class=model,
-                    fields=model_fields,
-                    filter_field=filter_field,
-                ))
+                field_groups.append(
+                    ModelFieldGroup(
+                        model_class=model,
+                        fields=model_fields,
+                        filter_field=filter_field,
+                    )
+                )
 
         return MTIUpdatePlan(
             inheritance_chain=inheritance_chain,