Django-filter: [OrderingFilter]質問/機能リクエスト：順序付けに任意のDjangoORM式を指定できるようにする

こんにちは！ まず、このプロジェクトに感謝​​します。このプロジェクトは、アプリケーションでDjango RESTFrameworkと組み合わせて非常に役立つことが証明されました。

現在、関連モデルのフィールドごとのシリアル化、フィルタリング、および順序付けの問題に苦労しています。 この号では、注文のみに焦点を当てたいと思います。

次のモデルで私の意図を説明しましょう。

# 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}'

次に、フィルタリングと順序付けを構成せずにDRFViewSetから始めましょう。

# 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の呼び出しで集計を使用しない限り、問題はありません。これまでのところ問題ありません。 （_後で実際に集計に戻ります_）

最新のコードサンプルのもう1つの問題は、コードが反復的であり、便利に継承できる基本クラスに抽出する方がよいことです。 今のところ、私は自分のOrderingFilterクラスを作成しました。これは、django-filterによって提供されるクラスの完全な代替手段です。 その完全なソースコードは以下のとおりです。 あなたはそれが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で使用することはできません。これは、QuserySetフィルタリングと混合した結果が予測できないためです。 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よりもDjangoRESTFrameworkと関係があります。 集計式のサポートなしで、実際にdjango_filters.rest_framework.OrderingFilterで式のサポートが必要ですか？ これは、多くのメリットをもたらさずにdjango-filterユーザーを混乱させるだけかもしれません。

ご意見をお待ちしております。 消化することは多くの情報であることを私は知っています。 うまくいけば、私のテストプロジェクトが役立つかもしれません： https ：//github.com/earshinov/django_sample/tree/master/django_sample/ordering_by_expression