django-bulk-hooks 0.2.45__py3-none-any.whl → 0.2.47__py3-none-any.whl

django_bulk_hooks/operations/analyzer.py

@@ -77,14 +77,11 @@ class ModelAnalyzer:
         if not objs:
             return
 
-        invalid_types = {
-            type(obj).__name__ for obj in objs if not isinstance(obj, self.model_cls)
-        }
+        invalid_types = {type(obj).__name__ for obj in objs if not isinstance(obj, self.model_cls)}
 
         if invalid_types:
             raise TypeError(
-                f"{operation} expected instances of {self.model_cls.__name__}, "
-                f"but got {invalid_types}",
+                f"{operation} expected instances of {self.model_cls.__name__}, but got {invalid_types}",
             )
 
     def _check_has_pks(self, objs, operation="operation"):
@@ -130,7 +127,9 @@ class ModelAnalyzer:
         auto_now_fields = []
         for field in self.model_cls._meta.fields:
             if getattr(field, "auto_now", False) or getattr(
-                field, "auto_now_add", False,
+                field,
+                "auto_now_add",
+                False,
             ):
                 auto_now_fields.append(field.name)
         return auto_now_fields
@@ -142,11 +141,7 @@ class ModelAnalyzer:
         Returns:
             list: FK field names
         """
-        return [
-            field.name
-            for field in self.model_cls._meta.concrete_fields
-            if field.is_relation and not field.many_to_many
-        ]
+        return [field.name for field in self.model_cls._meta.concrete_fields if field.is_relation and not field.many_to_many]
 
     def detect_changed_fields(self, objs):
         """
@@ -210,15 +205,15 @@ class ModelAnalyzer:
     def resolve_expression(self, field_name, expression, instance):
         """
         Resolve a SQL expression to a concrete value for a specific instance.
-        
+
         This method materializes database expressions (F(), Subquery, Case, etc.)
         into concrete values by using Django's annotate() mechanism.
-        
+
         Args:
             field_name: Name of the field being updated
             expression: The expression or value to resolve
             instance: The model instance to resolve for
-            
+
         Returns:
             The resolved concrete value
         """
@@ -236,31 +231,34 @@ class ModelAnalyzer:
             instance_qs = self.model_cls.objects.filter(pk=instance.pk)
 
             # Use annotate with the expression and let Django resolve it
-            resolved_value = instance_qs.annotate(
-                _resolved_value=expression,
-            ).values_list("_resolved_value", flat=True).first()
+            resolved_value = (
+                instance_qs.annotate(
+                    _resolved_value=expression,
+                )
+                .values_list("_resolved_value", flat=True)
+                .first()
+            )
 
             return resolved_value
         except Exception as e:
             # If expression resolution fails, log and return original
             logger.warning(
-                f"Failed to resolve expression for field '{field_name}' "
-                f"on {self.model_cls.__name__}: {e}. Using original value.",
+                f"Failed to resolve expression for field '{field_name}' on {self.model_cls.__name__}: {e}. Using original value.",
             )
             return expression
 
     def apply_update_values(self, instances, update_kwargs):
         """
         Apply update_kwargs to instances, resolving any SQL expressions.
-        
+
         This method transforms queryset.update()-style kwargs (which may contain
         F() expressions, Subquery, Case, etc.) into concrete values and applies
         them to the instances.
-        
+
         Args:
             instances: List of model instances to update
             update_kwargs: Dict of {field_name: value_or_expression}
-            
+
         Returns:
             List of field names that were updated
         """
@@ -271,7 +269,7 @@ class ModelAnalyzer:
             return []
 
         fields_updated = list(update_kwargs.keys())
-        
+
         # Extract PKs
         pks = [inst.pk for inst in instances if inst.pk is not None]
         if not pks:
@@ -306,8 +304,7 @@ class ModelAnalyzer:
             except Exception as e:
                 # If expression resolution fails, log and use original
                 logger.warning(
-                    f"Failed to resolve expression for field '{field_name}' "
-                    f"on {self.model_cls.__name__}: {e}. Using original value.",
+                    f"Failed to resolve expression for field '{field_name}' on {self.model_cls.__name__}: {e}. Using original value.",
                 )
                 for instance in instances:
                     setattr(instance, field_name, value)

django_bulk_hooks/operations/bulk_executor.py

@@ -74,14 +74,23 @@ class BulkExecutor:
 
         # Check if this is an MTI model and route accordingly
         if self.mti_handler.is_mti_model():
-            logger.info(f"Detected MTI model {self.model_cls.__name__}, using MTI bulk create")
 
             # Use pre-classified records if provided, otherwise classify now
             if existing_record_ids is None or existing_pks_map is None:
                 existing_record_ids = set()
                 existing_pks_map = {}
                 if update_conflicts and unique_fields:
-                    existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, unique_fields)
+                    # For MTI, find which model has the unique fields and query THAT model
+                    # This handles the schema migration case where parent exists but child doesn't
+                    query_model = self.mti_handler.find_model_with_unique_fields(unique_fields)
+                    logger.info(f"MTI upsert: 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"MTI Upsert classification: {len(existing_record_ids)} existing, {len(objs) - len(existing_record_ids)} new")
+                    logger.info(f"existing_record_ids: {existing_record_ids}")
+                    logger.info(f"existing_pks_map: {existing_pks_map}")
 
             # Build execution plan with classification results
             plan = self.mti_handler.build_create_plan(
@@ -95,11 +104,11 @@ class BulkExecutor:
             )
             # Execute the plan
             result = self._execute_mti_create_plan(plan)
-            
+
             # Tag objects with upsert metadata for hook dispatching
             if update_conflicts and unique_fields:
                 self._tag_upsert_metadata(result, existing_record_ids)
-            
+
             return result
 
         # Non-MTI model - use Django's native bulk_create
@@ -112,14 +121,14 @@ class BulkExecutor:
             unique_fields,
             **kwargs,
         )
-        
+
         # Tag objects with upsert metadata for hook dispatching
         if update_conflicts and unique_fields:
             # Use pre-classified results if available, otherwise classify now
             if existing_record_ids is None:
                 existing_record_ids, _ = self.record_classifier.classify_for_upsert(objs, unique_fields)
             self._tag_upsert_metadata(result, existing_record_ids)
-        
+
         return result
 
     def _execute_bulk_create(
@@ -205,59 +214,41 @@ class BulkExecutor:
         if not plan:
             return []
 
+
         with transaction.atomic(using=self.queryset.db, savepoint=False):
-            # Step 1: Create/Update all parent objects level by level
+            # Step 1: Upsert all parent objects level by level using Django's native upsert
             parent_instances_map = {}  # Maps original obj id() -> {model: parent_instance}
 
             for parent_level in plan.parent_levels:
-                # Separate new and existing parent objects
-                new_parents = []
-                existing_parents = []
-
-                for parent_obj in parent_level.objects:
-                    orig_obj_id = parent_level.original_object_map[id(parent_obj)]
-                    if orig_obj_id in plan.existing_record_ids:
-                        existing_parents.append(parent_obj)
-                    else:
-                        new_parents.append(parent_obj)
-
-                # Bulk create new parents
-                if new_parents:
-                    bulk_kwargs = {"batch_size": len(new_parents)}
-
-                    if parent_level.update_conflicts:
-                        bulk_kwargs["update_conflicts"] = True
-                        bulk_kwargs["unique_fields"] = parent_level.unique_fields
-                        bulk_kwargs["update_fields"] = parent_level.update_fields
-
-                    # Use base QuerySet to avoid recursion
-                    base_qs = BaseQuerySet(model=parent_level.model_class, using=self.queryset.db)
-                    created_parents = base_qs.bulk_create(new_parents, **bulk_kwargs)
-
-                    # Copy generated fields back to parent objects
-                    for created_parent, parent_obj in zip(created_parents, new_parents):
-                        for field in parent_level.model_class._meta.local_fields:
-                            created_value = getattr(created_parent, field.name, None)
-                            if created_value is not None:
-                                setattr(parent_obj, field.name, created_value)
-
-                        parent_obj._state.adding = False
-                        parent_obj._state.db = self.queryset.db
-
-                # Update existing parents
-                if existing_parents and parent_level.update_fields:
+                # Use base QuerySet to avoid recursion
+                base_qs = BaseQuerySet(model=parent_level.model_class, using=self.queryset.db)
+                
+                # Build bulk_create kwargs
+                bulk_kwargs = {"batch_size": len(parent_level.objects)}
+                
+                if parent_level.update_conflicts:
+                    # Let Django handle the upsert - it will INSERT or UPDATE as needed
+                    bulk_kwargs["update_conflicts"] = True
+                    bulk_kwargs["unique_fields"] = parent_level.unique_fields
+                    
                     # Filter update fields to only those that exist in this parent model
                     parent_model_fields = {field.name for field in parent_level.model_class._meta.local_fields}
                     filtered_update_fields = [field for field in parent_level.update_fields if field in parent_model_fields]
-
                     if filtered_update_fields:
-                        base_qs = BaseQuerySet(model=parent_level.model_class, using=self.queryset.db)
-                        base_qs.bulk_update(existing_parents, filtered_update_fields)
+                        bulk_kwargs["update_fields"] = filtered_update_fields
+
+                # Perform the upsert - Django handles INSERT vs UPDATE automatically
+                upserted_parents = base_qs.bulk_create(parent_level.objects, **bulk_kwargs)
 
-                    # Mark as not adding
-                    for parent_obj in existing_parents:
-                        parent_obj._state.adding = False
-                        parent_obj._state.db = self.queryset.db
+                # Copy generated fields back to parent objects
+                for upserted_parent, parent_obj in zip(upserted_parents, parent_level.objects):
+                    for field in parent_level.model_class._meta.local_fields:
+                        upserted_value = getattr(upserted_parent, field.name, None)
+                        if upserted_value is not None:
+                            setattr(parent_obj, field.name, upserted_value)
+
+                    parent_obj._state.adding = False
+                    parent_obj._state.db = self.queryset.db
 
                 # Map parents back to original objects
                 for parent_obj in parent_level.objects:
@@ -266,10 +257,7 @@ class BulkExecutor:
                         parent_instances_map[orig_obj_id] = {}
                     parent_instances_map[orig_obj_id][parent_level.model_class] = parent_obj
 
-            # Step 2: Add parent links to child objects and separate new/existing
-            new_child_objects = []
-            existing_child_objects = []
-
+            # Step 2: Add parent links to child objects and set PKs for existing records
             for child_obj, orig_obj in zip(plan.child_objects, plan.original_objects):
                 parent_instances = parent_instances_map.get(id(orig_obj), {})
 
@@ -279,91 +267,81 @@ class BulkExecutor:
                     if parent_link:
                         setattr(child_obj, parent_link.attname, parent_instance.pk)
                         setattr(child_obj, parent_link.name, parent_instance)
+                        # IMPORTANT: Don't set the child's PK here - it should only get PK after insertion
+                        # The parent link field (hookmodel_ptr) is NOT the same as the child's PK
+                    else:
+                        logger.warning(f"No parent link found for {parent_model} in {plan.child_model}")
 
-                # Classify as new or existing
+                # For existing records in upsert, ensure PK is set on child object
                 if id(orig_obj) in plan.existing_record_ids:
-                    # For existing records, set the PK on child object
                     pk_value = getattr(orig_obj, "pk", None)
                     if pk_value:
                         child_obj.pk = pk_value
                         child_obj.id = pk_value
-                    existing_child_objects.append(child_obj)
-                else:
-                    new_child_objects.append(child_obj)
-
-            # Step 3: Bulk create new child objects using _batched_insert (to bypass MTI check)
-            if new_child_objects:
-                base_qs = BaseQuerySet(model=plan.child_model, using=self.queryset.db)
-                base_qs._prepare_for_bulk_create(new_child_objects)
-
-                # Partition objects by PK status
-                objs_without_pk, objs_with_pk = [], []
-                for obj in new_child_objects:
-                    if obj._is_pk_set():
-                        objs_with_pk.append(obj)
                     else:
-                        objs_without_pk.append(obj)
+                        # If no PK on original object, this is a new record, don't set PK
+                        logger.info(f"New record {orig_obj} - not setting PK on child object")
 
-                # Get fields for insert
-                opts = plan.child_model._meta
-                fields = [f for f in opts.local_fields if not f.generated]
-
-                # Execute bulk insert
-                if objs_with_pk:
-                    returned_columns = base_qs._batched_insert(
-                        objs_with_pk,
-                        fields,
-                        batch_size=len(objs_with_pk),
-                    )
-                    if returned_columns:
-                        for obj, results in zip(objs_with_pk, returned_columns):
-                            if hasattr(opts, "db_returning_fields") and hasattr(opts, "pk"):
-                                for result, field in zip(results, opts.db_returning_fields):
-                                    if field != opts.pk:
-                                        setattr(obj, field.attname, result)
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
-                    else:
-                        for obj in objs_with_pk:
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
-
-                if objs_without_pk:
-                    filtered_fields = [f for f in fields if not isinstance(f, AutoField) and not f.primary_key]
-                    returned_columns = base_qs._batched_insert(
-                        objs_without_pk,
-                        filtered_fields,
-                        batch_size=len(objs_without_pk),
-                    )
-                    if returned_columns:
-                        for obj, results in zip(objs_without_pk, returned_columns):
-                            if hasattr(opts, "db_returning_fields"):
-                                for result, field in zip(results, opts.db_returning_fields):
-                                    setattr(obj, field.attname, result)
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
-                    else:
-                        for obj in objs_without_pk:
-                            obj._state.adding = False
-                            obj._state.db = self.queryset.db
+            # Step 3: Handle child objects
+            # Note: We can't use bulk_create on child MTI models, so we use _batched_insert for new records
+            # and bulk_update for existing records
+            base_qs = BaseQuerySet(model=plan.child_model, using=self.queryset.db)
+            
+            # For MTI child objects, we need to handle them differently
+            # In MTI, child objects get PKs from parent links, but we need to distinguish
+            # between truly new records and existing records for upsert operations
+            objs_without_pk, objs_with_pk = [], []
+            for child_obj, orig_obj in zip(plan.child_objects, plan.original_objects):
+                # Check if this is an existing record (for upsert operations)
+                if id(orig_obj) in plan.existing_record_ids:
+                    # Existing record - should be updated
+                    objs_with_pk.append(child_obj)
+                else:
+                    # New record - should be inserted
+                    objs_without_pk.append(child_obj)
 
-            # Step 3.5: Update existing child objects
-            if existing_child_objects and plan.update_fields:
+            # For objects with PK (existing records in upsert), use bulk_update
+            if objs_with_pk and plan.update_fields:
                 # Filter update fields to only those that exist in the child model
                 child_model_fields = {field.name for field in plan.child_model._meta.local_fields}
                 filtered_child_update_fields = [field for field in plan.update_fields if field in child_model_fields]
 
                 if filtered_child_update_fields:
-                    base_qs = BaseQuerySet(model=plan.child_model, using=self.queryset.db)
-                    base_qs.bulk_update(existing_child_objects, filtered_child_update_fields)
+                    base_qs.bulk_update(objs_with_pk, filtered_child_update_fields)
 
                 # Mark as not adding
-                for child_obj in existing_child_objects:
-                    child_obj._state.adding = False
-                    child_obj._state.db = self.queryset.db
+                for obj in objs_with_pk:
+                    obj._state.adding = False
+                    obj._state.db = self.queryset.db
 
-            # Combine all children for final processing
-            created_children = new_child_objects + existing_child_objects
+            # For objects without PK (new records), use _batched_insert
+            if objs_without_pk:
+                base_qs._prepare_for_bulk_create(objs_without_pk)
+                opts = plan.child_model._meta
+                
+                # Include all local fields except auto-generated ones
+                # For MTI, we need to include the parent link (which is the PK)
+                filtered_fields = [f for f in opts.local_fields if not f.generated]
+                
+                returned_columns = base_qs._batched_insert(
+                    objs_without_pk,
+                    filtered_fields,
+                    batch_size=len(objs_without_pk),
+                )
+                if returned_columns:
+                    for obj, results in zip(objs_without_pk, returned_columns):
+                        if hasattr(opts, "db_returning_fields"):
+                            for result, field in zip(results, opts.db_returning_fields):
+                                setattr(obj, field.attname, result)
+                        obj._state.adding = False
+                        obj._state.db = self.queryset.db
+                else:
+                    for obj in objs_without_pk:
+                        obj._state.adding = False
+                        obj._state.db = self.queryset.db
+
+            # All child objects are now created/updated
+            created_children = plan.child_objects
 
             # Step 4: Copy PKs and auto-generated fields back to original objects
             pk_field_name = plan.child_model._meta.pk.name
@@ -532,29 +510,30 @@ class BulkExecutor:
     def _tag_upsert_metadata(self, result_objects, existing_record_ids):
         """
         Tag objects with metadata indicating whether they were created or updated.
-        
+
         This metadata is used by the coordinator to determine which hooks to fire.
         The metadata is temporary and will be cleaned up after hook execution.
-        
+
         Args:
             result_objects: List of objects returned from bulk operation
             existing_record_ids: Set of id() for objects that existed before the operation
         """
         created_count = 0
         updated_count = 0
-        
+
         for obj in result_objects:
             # Tag with metadata for hook dispatching
             was_created = id(obj) not in existing_record_ids
             obj._bulk_hooks_was_created = was_created
             obj._bulk_hooks_upsert_metadata = True
-            
+
             if was_created:
                 created_count += 1
             else:
                 updated_count += 1
-        
+
         logger.info(
             f"Tagged upsert metadata: {created_count} created, {updated_count} updated "
             f"(total={len(result_objects)}, existing_ids={len(existing_record_ids)})"
         )
+

django_bulk_hooks/operations/coordinator.py

@@ -136,7 +136,15 @@ class BulkOperationCoordinator:
         existing_record_ids = set()
         existing_pks_map = {}
         if update_conflicts and unique_fields:
-            existing_record_ids, existing_pks_map = self.record_classifier.classify_for_upsert(objs, 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}")
@@ -699,7 +707,7 @@ class BulkOperationCoordinator:
 
     def _is_upsert_operation(self, result_objects):
         """
-        Check if the operation was an upsert (mixed create/update).
+        Check if the operation was an upsert (with update_conflicts=True).
 
         Args:
             result_objects: List of objects returned from the operation
@@ -725,36 +733,46 @@ class BulkOperationCoordinator:
             result_objects: List of objects returned from the operation
             models_in_chain: List of model classes in the MTI inheritance chain
         """
-        # Split objects by operation type
+        # Split objects based on metadata set by the executor
         created_objects = []
         updated_objects = []
-        missing_metadata_count = 0
-        
+
+        if not result_objects:
+            return
+
         for obj in result_objects:
-            # Check if metadata was set (it MUST be set for upsert operations)
-            if not hasattr(obj, '_bulk_hooks_upsert_metadata'):
-                # This should never happen - log and treat as created to maintain backward compat
-                missing_metadata_count += 1
-                logger.warning(
-                    f"Object {obj} (id={id(obj)}, pk={getattr(obj, 'pk', None)}) "
-                    f"missing upsert metadata - defaulting to 'created'. "
-                    f"This may indicate a bug in the upsert metadata tagging.",
-                )
-                was_created = True
-            else:
+            # 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)
+                if was_created:
+                    created_objects.append(obj)
+                else:
+                    updated_objects.append(obj)
             else:
-                updated_objects.append(obj)
-        
-        if missing_metadata_count > 0:
-            logger.error(
-                f"UPSERT METADATA BUG: {missing_metadata_count}/{len(result_objects)} objects "
-                f"missing metadata. This will cause incorrect hook firing!",
-            )
-        
+                # 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

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,12 @@ 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 +111,35 @@ 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 contains the unique fields.
+        
+        This is critical for MTI upserts: we need to query the model that has
+        the unique constraint, not necessarily the child model.
+        
+        Args:
+            unique_fields: List of field names forming the unique constraint
+        
+        Returns:
+            Model class that contains all the unique fields (closest to root)
+        """
+        if not unique_fields:
+            return self.model_cls
+        
+        inheritance_chain = self.get_inheritance_chain()
+        
+        # Start from root and find the first model that has all unique fields
+        for model_cls in inheritance_chain:
+            model_field_names = {f.name for f in model_cls._meta.local_fields}
+            
+            # Check if this model has all the unique fields
+            if all(field in model_field_names for field in unique_fields):
+                return model_cls
+        
+        # Fallback to child model (shouldn't happen if unique_fields are valid)
+        return self.model_cls
+
     # ==================== MTI BULK CREATE PLANNING ====================
 
     def build_create_plan(
@@ -127,10 +154,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 +166,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 +232,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,16 +282,14 @@ 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]
 
                     # 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
@@ -288,10 +313,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 = []
 
@@ -319,12 +342,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)
         """
@@ -335,8 +358,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)
@@ -348,8 +370,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
 
@@ -373,13 +394,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)
         """
@@ -399,8 +420,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:
@@ -430,14 +450,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
         """
@@ -497,11 +517,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,

django_bulk_hooks/operations/mti_plans.py

@@ -14,7 +14,7 @@ from typing import Any
 class ParentLevel:
     """
     Represents one level in the parent hierarchy for MTI bulk create.
-    
+
     Attributes:
         model_class: The parent model class for this level
         objects: List of parent instances to create
@@ -23,6 +23,7 @@ class ParentLevel:
         unique_fields: Fields for conflict detection (if update_conflicts=True)
         update_fields: Fields to update on conflict (if update_conflicts=True)
     """
+
     model_class: Any
     objects: list[Any]
     original_object_map: dict[int, int] = field(default_factory=dict)
@@ -35,10 +36,10 @@ class ParentLevel:
 class MTICreatePlan:
     """
     Plan for executing bulk_create on an MTI model.
-    
+
     This plan describes WHAT to create, not HOW to create it.
     The executor is responsible for executing this plan.
-    
+
     Attributes:
         inheritance_chain: List of model classes from root to child
         parent_levels: List of ParentLevel objects, one per parent model
@@ -51,6 +52,7 @@ class MTICreatePlan:
         unique_fields: Fields used for conflict detection
         update_fields: Fields to update on conflict
     """
+
     inheritance_chain: list[Any]
     parent_levels: list[ParentLevel]
     child_objects: list[Any]
@@ -67,12 +69,13 @@ class MTICreatePlan:
 class ModelFieldGroup:
     """
     Represents fields to update for one model in the inheritance chain.
-    
+
     Attributes:
         model_class: The model class
         fields: List of field names to update on this model
         filter_field: Field to use for filtering (e.g., 'pk' or parent link attname)
     """
+
     model_class: Any
     fields: list[str]
     filter_field: str = "pk"
@@ -82,15 +85,15 @@ class ModelFieldGroup:
 class MTIUpdatePlan:
     """
     Plan for executing bulk_update on an MTI model.
-    
+
     Attributes:
         inheritance_chain: List of model classes from root to child
         field_groups: List of ModelFieldGroup objects
         objects: Objects to update
         batch_size: Batch size for operations
     """
+
     inheritance_chain: list[Any]
     field_groups: list[ModelFieldGroup]
     objects: list[Any]
     batch_size: int = None
-

django_bulk_hooks/operations/record_classifier.py

@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 class RecordClassifier:
     """
     Service for classifying and fetching records via database queries.
-    
+
     This is the SINGLE point of truth for record classification queries.
     Keeps database access logic separate from business/planning logic.
     """
@@ -31,17 +31,18 @@ class RecordClassifier:
         """
         self.model_cls = model_cls
 
-    def classify_for_upsert(self, objs, unique_fields):
+    def classify_for_upsert(self, objs, unique_fields, query_model=None):
         """
         Classify records as new or existing based on unique_fields.
-        
+
         Queries the database to check which records already exist based on the
         unique_fields constraint.
-        
+
         Args:
             objs: List of model instances
             unique_fields: List of field names that form the unique constraint
-            
+            query_model: Optional model class to query (for MTI, may be different from self.model_cls)
+
         Returns:
             Tuple of (existing_record_ids, existing_pks_map)
             - existing_record_ids: Set of id() for objects that exist in DB
@@ -50,6 +51,9 @@ class RecordClassifier:
         if not unique_fields or not objs:
             return set(), {}
 
+        # Use query_model if provided (for MTI scenarios), otherwise use self.model_cls
+        query_model = query_model or self.model_cls
+
         # Build a query to find existing records
         queries = []
         obj_to_unique_values = {}
@@ -77,9 +81,12 @@ class RecordClassifier:
         for q in queries[1:]:
             combined_query |= q
 
-        existing_records = list(
-            self.model_cls.objects.filter(combined_query).values("pk", *unique_fields),
-        )
+        logger.info(f"Classifying for upsert: model={query_model.__name__}, query={combined_query}, unique_fields={unique_fields}")
+        queryset = query_model.objects.filter(combined_query)
+        logger.info(f"Queryset SQL: {queryset.query}")
+        logger.info(f"All records in table: {query_model.objects.all().count()}")
+        existing_records = list(queryset.values("pk", *unique_fields))
+        logger.info(f"Found {len(existing_records)} existing records: {existing_records}")
 
         # Map existing records back to original objects
         existing_record_ids = set()
@@ -94,8 +101,7 @@ class RecordClassifier:
                     existing_pks_map[obj_id] = record["pk"]
 
         logger.info(
-            f"Classified {len(existing_record_ids)} existing and "
-            f"{len(objs) - len(existing_record_ids)} new records for upsert",
+            f"Classified {len(existing_record_ids)} existing and {len(objs) - len(existing_record_ids)} new records for upsert",
         )
 
         return existing_record_ids, existing_pks_map
@@ -103,12 +109,12 @@ class RecordClassifier:
     def fetch_by_pks(self, pks, select_related=None, prefetch_related=None):
         """
         Fetch records by primary keys with optional relationship loading.
-        
+
         Args:
             pks: List of primary key values
             select_related: Optional list of fields to select_related
             prefetch_related: Optional list of fields to prefetch_related
-            
+
         Returns:
             Dict[pk, instance] for O(1) lookups
         """
@@ -128,10 +134,10 @@ class RecordClassifier:
     def fetch_by_unique_constraint(self, field_values_map):
         """
         Fetch records matching a unique constraint.
-        
+
         Args:
             field_values_map: Dict of {field_name: value} for unique constraint
-            
+
         Returns:
             Model instance if found, None otherwise
         """
@@ -141,18 +147,17 @@ class RecordClassifier:
             return None
         except self.model_cls.MultipleObjectsReturned:
             logger.warning(
-                f"Multiple {self.model_cls.__name__} records found for "
-                f"unique constraint {field_values_map}",
+                f"Multiple {self.model_cls.__name__} records found for unique constraint {field_values_map}",
             )
             return self.model_cls.objects.filter(**field_values_map).first()
 
     def exists_by_pks(self, pks):
         """
         Check if records exist by primary keys without fetching them.
-        
+
         Args:
             pks: List of primary key values
-            
+
         Returns:
             Set of PKs that exist in the database
         """
@@ -168,13 +173,13 @@ class RecordClassifier:
     def count_by_unique_fields(self, objs, unique_fields):
         """
         Count how many objects already exist based on unique fields.
-        
+
         Useful for validation or reporting before upsert operations.
-        
+
         Args:
             objs: List of model instances
             unique_fields: List of field names that form the unique constraint
-            
+
         Returns:
             Tuple of (existing_count, new_count)
         """

{django_bulk_hooks-0.2.45.dist-info → django_bulk_hooks-0.2.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-bulk-hooks
-Version: 0.2.45
+Version: 0.2.47
 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.45.dist-info → django_bulk_hooks-0.2.47.dist-info}/RECORD

@@ -12,15 +12,15 @@ django_bulk_hooks/helpers.py,sha256=Nw8eXryLUUquW7AgiuKp0PQT3Pq6HAHsdP-xAtqhmjA,
 django_bulk_hooks/manager.py,sha256=3mFzB0ZzHHeXWdKGObZD_H0NlskHJc8uYBF69KKdAXU,4068
 django_bulk_hooks/models.py,sha256=4Vvi2LiGP0g4j08a5liqBROfsO8Wd_ermBoyjKwfrPU,2512
 django_bulk_hooks/operations/__init__.py,sha256=BtJYjmRhe_sScivLsniDaZmBkm0ZLvcmzXFKL7QY2Xg,550
-django_bulk_hooks/operations/analyzer.py,sha256=dXcgk99Q9Zv7r2PMNIQE9f-hkPW3rGKXnDw28r3C7IE,10782
-django_bulk_hooks/operations/bulk_executor.py,sha256=KQ8GL9JRNqu4e8RjuMHLWncoBRR1_Scf2UrdqRDrSPY,23664
-django_bulk_hooks/operations/coordinator.py,sha256=CqyFd3GWH5K6NdK_JLSTnuugOvWKIvsI2C0utm3qhdQ,29776
-django_bulk_hooks/operations/mti_handler.py,sha256=xKEz9hgdFnA6mX5RQ8Pa1MJFluzeJBJ6EqFJxXTyedM,19664
-django_bulk_hooks/operations/mti_plans.py,sha256=YP7LcV9Z8UqNS_x74OswF9_5swqruRTdAu6z-J_R6C0,3377
-django_bulk_hooks/operations/record_classifier.py,sha256=KzUoAhfoqzFVrOabNZAby9Akb54h-fAQZmb8O-fIx_0,6221
+django_bulk_hooks/operations/analyzer.py,sha256=wAG8sAG9NwfwNqG9z81VfGR7AANDzRmMGE_o82MWji4,10689
+django_bulk_hooks/operations/bulk_executor.py,sha256=nS8oRxMTPesJnwsqR4KdbJU6Sj0iD7ZWU2z9RJgtxao,23170
+django_bulk_hooks/operations/coordinator.py,sha256=iGavJLqe3eYRqFay8cMn6muwyRYzQo-HFGphsS5hL6g,30799
+django_bulk_hooks/operations/mti_handler.py,sha256=GIpTzzoo_hx1iI5osx2COk3cVQgqTsD-o41d9S7aiqo,20748
+django_bulk_hooks/operations/mti_plans.py,sha256=7STQ2oA2ZT8cEG3-t-6xciRAdf7OeSf0gRLXR_BRG-Q,3363
+django_bulk_hooks/operations/record_classifier.py,sha256=vNi0WSNiPAVb8pTZZJ26b81oX59snk7LIxWMzyenDCk,6694
 django_bulk_hooks/queryset.py,sha256=aQitlbexcVnmeAdc0jtO3hci39p4QEu4srQPEzozy5s,5546
 django_bulk_hooks/registry.py,sha256=uum5jhGI3TPaoiXuA1MdBdu4gbE3rQGGwQ5YDjiMcjk,7949
-django_bulk_hooks-0.2.45.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
-django_bulk_hooks-0.2.45.dist-info/METADATA,sha256=MYKwKda7pa7tdrQJ6Ceeyavgga6tiu_S5NH8Bvhg2Pk,9265
-django_bulk_hooks-0.2.45.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-django_bulk_hooks-0.2.45.dist-info/RECORD,,
+django_bulk_hooks-0.2.47.dist-info/LICENSE,sha256=dguKIcbDGeZD-vXWdLyErPUALYOvtX_fO4Zjhq481uk,1088
+django_bulk_hooks-0.2.47.dist-info/METADATA,sha256=Dp_OKvGqoa7j0zax8Cc-j5uH-acwsaCd1o0y-nw30U0,9265
+django_bulk_hooks-0.2.47.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+django_bulk_hooks-0.2.47.dist-info/RECORD,,