Django의 Annotate쿼리를 활용한 DRF와의 연계, Queryset의 중요성

from django.db import models
from django.contrib.auth import get_user_model

User = get_user_model()

# Create your models here.

class Tag(models.Model):
  name = models.CharField(max_length=128, unique=True)
  
  def __str__(self):
    return self.name

class Stock(models.Model):
  code = models.CharField(max_length=24, unique=True)
  name = models.CharField(max_length=128)
  price = models.DecimalField(max_digits=10, decimal_places=2)
  active = models.BooleanField(default=True)
  dividend_rate = models.DecimalField(decimal_places=2, max_digits=4)
  tags = models.ManyToManyField(Tag)
  
  def __str__(self):
    return self.name

class StockSet(models.Model):
  code = models.ForeignKey(Stock, related_name='stock_set', on_delete=models.CASCADE, to_field='code')
  quantity = models.IntegerField()
  purchase_date = models.DateField(auto_now_add=True)
  owner = models.ForeignKey(User, on_delete=models.CASCADE, related_name='stock_set', to_field='wallet')
  
  def __str__(self):
    return f'{self.owner} - {self.code}'

# views.py

class TagListView(ListAPIView):
  queryset = Tag.objects.all()
  serializer_class = TagSerializer

# serializers.py

class TagSerializer(serializers.ModelSerializer):
  
  tag_cnt = serializers.SerializerMethodField()
  
  def get_tag_cnt(self, obj):
    stock_count = Stock.objects.filter(Q(tags__in=[obj.id]) & Q(active=True)).count()
    return stock_count
  
  class Meta:
    model = Tag
    fields = ('name', 'tag_cnt',)

class TagListView(ListAPIView):
  queryset = Tag.objects.all()
  serializer_class = TagSerializer
  
  def get(self, request, *args, **kwargs):
    response = super().get(request, *args, **kwargs)
    response.data = sorted(response.data, key=lambda x:-x["tag_cnt"])
    return response

from rest_framework.filters import OrderingFilter

class TagListView(ListAPIView):
  queryset = Tag.objects.all()
  serializer_class = TagSerializer
  filter_backends = [OrderingFilter]
  ordering_fields = ['tag_cnt']
  
  def get(self, request, *args, **kwargs):
    response = super().get(request, *args, **kwargs)
    response.data = sorted(response.data, key=lambda x:-x["tag_cnt"])
    return response

class OrderingFilter(BaseFilterBackend):
    ...
    def filter_queryset(self, request, queryset, view):
        ordering = self.get_ordering(request, queryset, view)
        if ordering:
            return queryset.order_by(*ordering)

        return queryset

SELECT t.id, t.name, 
COUNT(CASE WHEN st.active = True THEN sst.stock_id END) AS tag_cnt 
FROM stock_tag t 
JOIN stock_stock_tags sst ON (t.id = sst.tag_id) 
JOIN stock_stock st ON (sst.stock_id = st.id) GROUP BY t.id;

class TagListView(ListAPIView):
  queryset = Tag.objects.all().annotate(tag_cnt=Count("stock", filter=Q(stock__active=True)))
  ...
  

class TagSerializer(serializers.ModelSerializer):
  
  tag_cnt = serializers.IntegerField()
  
  class Meta:
    model = Tag
    fields = ('name', 'tag_cnt',)

class ListModelMixin:
    """
    List a queryset.
    """
    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())

        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

class GenericAPIView(views.APIView):
    ...
    def get_serializer(self, *args, **kwargs):
        """
        Return the serializer instance that should be used for validating and
        deserializing input, and for serializing output.
        """
        serializer_class = self.get_serializer_class()
        kwargs.setdefault('context', self.get_serializer_context())
        return serializer_class(*args, **kwargs)

    def get_serializer_class(self):
        """
        Return the class to use for the serializer.
        Defaults to using `self.serializer_class`.

        You may want to override this if you need to provide different
        serializations depending on the incoming request.

        (Eg. admins get full serialization, others get basic serialization)
        """
        assert self.serializer_class is not None, (
            "'%s' should either include a `serializer_class` attribute, "
            "or override the `get_serializer_class()` method."
            % self.__class__.__name__
        )

        return self.serializer_class

class SerializerMetaclass(type):
   ...
   def to_representation(self, instance):
        """
        Object instance -> Dict of primitive datatypes.
        """
        ret = {}
        fields = self._readable_fields
        for field in fields:
            try:
                attribute = field.get_attribute(instance)
            except SkipField:
                continue

            # We skip `to_representation` for `None` values so that fields do
            # not have to explicitly deal with that case.
            #
            # For related fields with `use_pk_only_optimization` we need to
            # resolve the pk value.
            check_for_none = attribute.pk if isinstance(attribute, PKOnlyObject) else attribute
            if check_for_none is None:
                ret[field.field_name] = None
            else:
                ret[field.field_name] = field.to_representation(attribute)
        return ret

def get_attribute(instance, attrs):
    """
    Similar to Python's built in `getattr(instance, attr)`,
    but takes a list of nested attributes, instead of a single attribute.

    Also accepts either attribute lookup on objects or dictionary lookups.
    """
    for attr in attrs:
        try:
            if isinstance(instance, Mapping):
                instance = instance[attr]
            else:
                instance = getattr(instance, attr)
        except ObjectDoesNotExist:
            return None
        if is_simple_callable(instance):
            try:
                instance = instance()
            except (AttributeError, KeyError) as exc:
                # If we raised an Attribute or KeyError here it'd get treated
                # as an omitted field in `Field.get_attribute()`. Instead we
                # raise a ValueError to ensure the exception is not masked.
                raise ValueError('Exception raised in callable attribute "{}"; original exception was: {}'.format(attr, exc))

    return instance

class TagListView(ListAPIView):
  # queryset = Tag.objects.all().annotate(tag_cnt=Count("stock", filter=Q(stock__active=True)))
  queryset = Tag.objects.all()
  serializer_class = TagSerializer
  filter_backends = [OrderingFilter]
  ordering_fields = ['tag_cnt']