Django ORM 의 bulk_create 와 bulk_update에서 auto_now와 auto_now_add는 의미가 없다

updated_at = models.DateTimeField(verbose_name="수정일시", auto_now=True)

# DateTimeField class
class DateTimeField(DateField):
		...

    def pre_save(self, model_instance, add):
        if self.auto_now or (self.auto_now_add and add):
            value = datetime.date.today()
            setattr(model_instance, self.attname, value)
            return value
        else:
            return super().pre_save(model_instance, add)

# django/db/models/base.py

    def save_base(
        self,
        raw=False,
        force_insert=False,
        force_update=False,
        using=None,
        update_fields=None,
    ):
        """
        Handle the parts of saving which should be done only once per save,
        yet need to be done in raw saves, too. This includes some sanity
        checks and signal sending.

        The 'raw' argument is telling save_base not to save any parent
        models and not to do any changes to the values before save. This
        is used by fixture loading.
        """
        using = using or router.db_for_write(self.__class__, instance=self)
        assert not (force_insert and (force_update or update_fields))
        assert update_fields is None or update_fields
        cls = origin = self.__class__
        # Skip proxies, but keep the origin as the proxy model.
        if cls._meta.proxy:
            cls = cls._meta.concrete_model
        meta = cls._meta
        if not meta.auto_created:
            pre_save.send(
                sender=origin,
                instance=self,
                raw=raw,
                using=using,
                update_fields=update_fields,
            )
        # A transaction isn't needed if one query is issued.
        if meta.parents:
            context_manager = transaction.atomic(using=using, savepoint=False)
        else:
            context_manager = transaction.mark_for_rollback_on_error(using=using)
        with context_manager:
            parent_inserted = False
            if not raw:
                parent_inserted = self._save_parents(cls, using, update_fields)
            updated = self._save_table(
                raw,
                cls,
                force_insert or parent_inserted,
                force_update,
                using,
                update_fields,
            )
        # Store the database on which the object was saved
        self._state.db = using
        # Once saved, this is no longer a to-be-added instance.
        self._state.adding = False

        # Signal that the save is complete
        if not meta.auto_created:
            post_save.send(
                sender=origin,
                instance=self,
                created=(not updated),
                update_fields=update_fields,
                raw=raw,
                using=using,
            )

    def bulk_update(self, objs, fields, batch_size=None):
        """
        Update the given fields in each of the given objects in the database.
        """


        # 1. 검증

        if batch_size is not None and batch_size <= 0:
            raise ValueError("Batch size must be a positive integer.")
        if not fields:
            raise ValueError("Field names must be given to bulk_update().")
        objs = tuple(objs)
        if any(obj.pk is None for obj in objs):
            raise ValueError("All bulk_update() objects must have a primary key set.")
        fields = [self.model._meta.get_field(name) for name in fields]
        if any(not f.concrete or f.many_to_many for f in fields):
            raise ValueError("bulk_update() can only be used with concrete fields.")
        if any(f.primary_key for f in fields):
            raise ValueError("bulk_update() cannot be used with primary key fields.")

        # 2. 필드 준비
        if not objs:
            return 0
        for obj in objs:
            obj._prepare_related_fields_for_save(
                operation_name="bulk_update", fields=fields
            )

        # PK is used twice in the resulting update query, once in the filter
        # and once in the WHEN. Each field will also have one CAST.

				# 3. 배치 처리 및 쿼리 준비
        self._for_write = True
        connection = connections[self.db]
        max_batch_size = connection.ops.bulk_batch_size(["pk", "pk"] + fields, objs)
        batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size
        requires_casting = connection.features.requires_casted_case_in_updates
        batches = (objs[i : i + batch_size] for i in range(0, len(objs), batch_size))
        updates = []

        # 4. CASE 문 생성 및 UPDATE 쿼리 준비
        for batch_objs in batches:
            update_kwargs = {}
            for field in fields:
                when_statements = []
                for obj in batch_objs:
                    attr = getattr(obj, field.attname)
                    if not hasattr(attr, "resolve_expression"):
                        attr = Value(attr, output_field=field)
                    when_statements.append(When(pk=obj.pk, then=attr))
                case_statement = Case(*when_statements, output_field=field)
                if requires_casting:
                    case_statement = Cast(case_statement, output_field=field)
                update_kwargs[field.attname] = case_statement
            updates.append(([obj.pk for obj in batch_objs], update_kwargs))

        # 5. SQL UPDATE 문 실행
        rows_updated = 0
        queryset = self.using(self.db)
        with transaction.atomic(using=self.db, savepoint=False):
            for pks, update_kwargs in updates:
                rows_updated += queryset.filter(pk__in=pks).update(**update_kwargs)
        return rows_updated

UPDATE ticker
SET price = CASE id
    WHEN 1 THEN 100.0
    WHEN 2 THEN 200.0
    WHEN 3 THEN 300.0
END,
updated_at = CASE id
    WHEN 1 THEN '2024-07-07 10:00:00'
    WHEN 2 THEN '2024-07-07 10:00:00'
    WHEN 3 THEN '2024-07-07 10:00:00'
END
WHERE id IN (1, 2, 3);

from django.utils import timezone

for new_ticker in new_tickers:
    key = (new_ticker.currency, new_ticker.exchange)
    if key in existing_tickers:
        existing_ticker = existing_tickers[key]
        existing_ticker.price = new_ticker.price
        existing_ticker.updated_at = timezone.now()  # 수동으로 현재 시간 설정
        to_update.append(existing_ticker)
    else:
        to_create.append(new_ticker)

Ticker.objects.bulk_update(to_update, ["price", "updated_at"])

from django.db import models
from django.utils import timezone

class CustomManager(models.Manager):
    def bulk_update_with_auto_now(self, objs, fields, batch_size=None):
        if not objs:
            return 0  # 빈 리스트인 경우 early return

        model = objs[0].__class__
        auto_now_fields = [
            field.name for field in model._meta.fields
            if isinstance(field, (models.DateTimeField, models.DateField)) and field.auto_now
        ]

        # auto_now 필드가 없으면 일반 bulk_update 실행
        if not auto_now_fields:
            return super().bulk_update(objs, fields, batch_size)

        now = timezone.now()
        # auto_now 필드 업데이트
        for obj in objs:
            for field_name in auto_now_fields:
                setattr(obj, field_name, now)

        # fields에 auto_now 필드 추가 (중복 제거)
        fields = list(set(fields + auto_now_fields))

        # bulk_update 호출
        return super().bulk_update(objs, fields, batch_size)

class BaseModelMixin(models.Model):
    created_at = models.DateTimeField(verbose_name="생성일시", auto_now_add=True)
    updated_at = models.DateTimeField(verbose_name="수정일시", auto_now=True)

    objects = CustomManager()

    class Meta:
        abstract = True

# 사용할때 이렇게 하면 커스텀 메서드 임을 명시할 수 있지만, 실제로는 bulk_update()로 네이밍 하고 사용중입니다.
Ticker.objects.bulk_update_with_auto_now(to_update, ["price"])