Django-filter: [OrderingFilter] 질문/기능 요청: 주문을 위한 임의의 Django ORM 표현식 지정 허용

여보세요! 우선, 우리 애플리케이션에서 Django REST Framework와 함께 매우 유용한 것으로 판명된 이 프로젝트에 대해 감사를 표하고 싶습니다.

현재 관련 모델의 필드별로 직렬화, 필터링 및 정렬 문제로 어려움을 겪고 있습니다. 이번 호에서는 주문에만 집중하고 싶습니다.

다음 모델로 내 의도를 설명하겠습니다.

# models.py

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


class Order(models.Model):
    user = models.ForeignKey(User, on_delete=models.PROTECT, null=False, blank=False)
    created = models.DateTimeField(null=False, blank=False, auto_now_add=True)
    submitted = models.DateTimeField(null=True, blank=True)

    def __str__(self):
        return f'Order #{self.id}'


class Product(models.Model):
    name = models.CharField(null=False, blank=False, max_length=256)
    price = models.DecimalField(null=False, blank=False, decimal_places=2, max_digits=12)

    def __str__(self):
        return self.name


class OrderLine(models.Model):
    product = models.ForeignKey(Product, on_delete=models.PROTECT, null=False, blank=False, related_name='order_lines')
    quantity = models.IntegerField(null=False, blank=False)
    product_price = models.DecimalField(null=False, blank=False, decimal_places=2, max_digits=12)
    total_price = models.DecimalField(null=False, blank=False, decimal_places=2, max_digits=12)
    order = models.ForeignKey(Order, on_delete=models.CASCADE, null=False, blank=False, related_name='order_lines')

    def __str__(self):
        return f'{self.order}: {self.product.name} x{self.quantity}'

그런 다음 필터링 및 순서가 구성되지 않은 DRF ViewSet으로 시작하겠습니다.

# views.py

from rest_framework import viewsets
from django_filters.rest_framework import DjangoFilterBackend, FilterSet, OrderingFilter
from .models import Order

class OrderFilterSet(FilterSet):
    pass


class OrderViewSet(viewsets.ModelViewSet):
    queryset = Order.objects.all()
    serializer_class = OrderSerializer  # the definition of OrderSerializer is irrelevant and not shown here
    filter_backends = (DjangoFilterBackend, OrderingFilter)
    filterset_class = OrderFilterSet
    ordering_fields = ()

    class Meta:
        model = Order

이 문제의 범위에서 내 목표는 클라이언트가 다음 필드를 기준으로 요청된 주문 목록을 주문할 수 있도록 하는 것입니다.

1. ordering=[-]created - 주문 생성 날짜별 주문( [-] 은 주문 설명에 대한 선택적 - 를 나타냅니다.)
2. ordering=[-]user - 주문한 사용자의 전체 이름으로 주문
3. ordering=[-]total_quantity - 주문한 제품의 총 수량으로 주문

$ ViewSet #$에 구성된 ordering_fields 의 기본 접근 방식은 모델 필드를 기반으로 한 주문만 허용합니다(p.1). 다행히도 https://django-filter.readthedocs.io/en/master/ref/filters.html#orderingfilter 에 설명된 대로 filters.OrderingFilter 를 하위 분류하는 고급 방법을 사용할 수 있습니다.

# views.py

from rest_framework import viewsets
from django_filters.rest_framework import DjangoFilterBackend, FilterSet, OrderingFilter
from .models import Order


class OrderOrderingFilter(OrderingFilter):

    def __init__(self):
        super().__init__(fields={
            # example: model field
            # Order by order creation date
            'created': 'created',

            # example: expression on related model
            # Order by user full name
            'user': '',  # ???

            # example: aggregate expression
            'total_quantity': ''  # ???
        })


class OrderFilterSet(FilterSet):
    ordering = OrderOrderingFilter()


class OrderViewSet(viewsets.ModelViewSet):
    queryset = Order.objects.all()
    serializer_class = OrderSerializer  # the definition of OrderSerializer is irrelevant and not shown here
    filter_backends = (DjangoFilterBackend,)
    filterset_class = OrderFilterSet

    class Meta:
        model = Order

그러나 이 고급 방법을 사용하더라도 django-filter에는 필드 이름이 필요한 것 같습니다. 이 문제를 우회하는 유일한 방법은 필터링된 QuerySet을 annotate '하는 것입니다.

# ... the rest is omitted to brevity ...
class OrderOrderingFilter(OrderingFilter):

    def __init__(self):
        super().__init__(fields={
            # ... the rest is omitted to brevity ...
            'user_order': 'user',
        })

    def filter(self, qs, value):
        if value:
            qs = self._annotate(qs)
        return super().filter(qs, value)

    def _annotate(self, qs, value):
        if 'user' in value or '-user' in value:
            qs = qs.annotate(user_order=functions.Concat(
                models.F('user__first_name'),
                models.Value(' '),
                models.F('user__last_name'),
            ))
        return qs

어떤 사람들은 https://docs.djangoproject.com/en/2.1 에 설명된 대로 .annotate 와 .filter 를 안정적으로 혼합할 수 없기 때문에 여기서 .annotate 를 사용하는 것은 끔찍한 생각이라고 말할 수 있습니다. /topics/db/aggregation/#order -of-annotate-and-filter-clauses. 그러나 .annotate 호출에서 집계를 사용하지 않는 한 괜찮으므로 지금까지는 괜찮습니다. (_나는 실제로 나중에 집계로 돌아갈 것입니다_)

최신 코드 샘플의 또 다른 문제는 코드가 반복적이며 편리하게 상속될 수 있는 기본 클래스로 추출하는 것이 더 낫다는 것입니다. 지금은 django-filter에서 제공하는 완전한 대안인 OrderingFilter 클래스를 직접 작성했습니다. 전체 소스 코드는 다음과 같습니다. django-filter에서 많은 것을 차용한다는 것을 알 수 있습니다.

import typing

from django.db import models
from django.db.models import expressions
from django.forms.utils import pretty_name
from django.utils.translation import ugettext_lazy as _

from django_filters import filters
from django_filters.constants import EMPTY_VALUES

__all__ = ('OrderingFilter',)


class OrderingFilter(filters.BaseCSVFilter, filters.ChoiceFilter):
    """
    An alternative to django_filters.filter.OrderingFilter that allows to specify any Django ORM "expression" for ordering.

    Usage examples:

      class MyOrderingFilter(ddf.OrderingFilter):
        def __init__(self):
          super().__init__(fields={

            # a model field
            'id': 'id'

            # an expression
            'published_by':
              functions.Concat(
                expressions.F(f'published_user__first_name'),
                expressions.Value(' '),
                expressions.F(f'published_user__last_name')
              ),

            # a complete field descriptor with custom field label
            'reported_by': {
              'label': 'Reporter',
              'desc_label': 'Reporter (descending)',  # optional, would be derived from 'label' anyway
              'expr': functions.Concat(
                expressions.F(f'reported_user__first_name'),
                expressions.Value(' '),
                expressions.F(f'reported_user__last_name')
              ),
            }
          })

    For more information about expressions, please see the official Django documentation at
    https://docs.djangoproject.com/en/2.1/ref/models/expressions/
    """

    _fields: typing.Mapping[str, 'FieldDescriptor']

    def __init__(self, fields: typing.Mapping[str, typing.Any]):
        self._fields = normalize_fields(fields)
        super().__init__(choices=build_choices(self._fields))

    # <strong i="15">@override</strong>
    def filter(self, qs: models.QuerySet, value: typing.Union[typing.List[str], None]):
        return qs if value in EMPTY_VALUES else qs.order_by(*(expr for expr in map(self.get_ordering_expr, value)))

    def get_ordering_expr(self, param) -> expressions.Expression:
        descending = param.startswith('-')
        param = param[1:] if descending else param
        field_descriptor = self._fields.get(param)
        return None if field_descriptor is None else \
            field_descriptor.expr if not descending else field_descriptor.expr.desc()


def normalize_fields(fields: typing.Mapping[str, typing.Any]) -> typing.Mapping[str, 'FieldDescriptor']:
    return dict((
        param_name,
        FieldDescriptor(param_name, {'expr': normalize_expr(field)} if isinstance(field, (str, expressions.Expression)) else field)
    ) for param_name, field in fields.items())


def normalize_expr(expr: typing.Union[str, expressions.Expression]):
    return models.F(expr) if isinstance(expr, str) else expr


descending_fmt = _('%s (descending)')


class FieldDescriptor:
    expr: models.Expression

    def __init__(self, param_name: str, data: typing.Mapping[str, typing.Any]):
        self.expr = normalize_expr(data['expr'])
        self.label = data.get('label', _(pretty_name(param_name)))
        self.desc_label = data.get('desc_label', descending_fmt.format(self.label))


def build_choices(fields: typing.Mapping[str, 'FieldDescriptor']):
    choices = []
    for param_name, field_descriptor in fields.items():
        choices.append((param_name, field_descriptor.label))
        choices.append((f'-{param_name}', field_descriptor.desc_label))
    return choices

이 클래스를 사용하면 OrdersOrderingFilter 가 멋지고 간결해집니다.

# ... the rest is omitted to brevity ...
class OrderOrderingFilter(ddf.OrderingFilter):

    def __init__(self):
        super().__init__(fields={
            # ... the rest is omitted to brevity ...
            'user': functions.Concat(
                models.F('user__first_name'),
                models.Value(' '),
                models.F('user__last_name'),
            ),
        })

이것은 내가 여기에 온 질문을 제기합니다.

_ django_filters.rest_framework.OrderingFilter 에서 Django ORM 표현식으로 순서를 지정하는 기능을 제공하는 것에 대해 어떻게 생각하십니까?_

그러나 대답하기 전에 우리는 1, 2페이지만 풀었다는 것을 상기시켜 드리겠습니다. p.3을 해결하려면 집계 표현식이 필요합니다.

aggregates.Sum(models.F('order_lines__quantity'))

.annotate 에서는 이 표현식을 사용할 수 없습니다. QuerySet 필터링과 혼합한 결과를 예측할 수 없기 때문입니다. Query.order(...) 호출에서도 이 표현식을 직접 사용할 수 없습니다.

django.core.exceptions.FieldError: Using an aggregate in order_by() without also including it in annotate() is not allowed: Sum(F(order_lines__quantity))

따라서 p.3은 도달할 수 없으므로 ViewSet부터 시작하여 모든 것을 관통하는 솔루션이 필요합니다. Django-filters보다 Django REST Framework와 더 관련이 있습니다. 집계 표현식 지원 없이 django_filters.rest_framework.OrderingFilter 에서 표현식 지원이 실제로 필요합니까? 이것은 많은 이점을 가져오지 않고 django-filter 사용자를 혼란스럽게 할 수 있습니다.

귀하의 의견을 기다리겠습니다. 소화할 정보가 많다는 것을 압니다. 내 테스트 프로젝트가 도움이 되기를 바랍니다. https://github.com/earshinov/django_sample/tree/master/django_sample/ordering_by_expression