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。 幸运的是，我们可以使用更高级的方法对filters.OrderingFilter进行子类化，如https://django-filter.readthedocs.io/en/master/ref/filters.html#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 似乎也需要一个字段名。 绕过这个问题的唯一方法是通过annotate 'ing 过滤的 QuerySet：

# ... 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

有人会说在这里使用.annotate是一个糟糕的主意，因为无法可靠地将.annotate与.filter混合，如https://docs.djangoproject.com/en/2.1中所述.annotate调用中使用聚合就可以了，所以到目前为止我们做得很好。 （_我实际上稍后会返回聚合_）

最新代码示例的另一个问题是代码是重复的，最好将其提取到可以方便地继承的基类中。 目前，我已经编写了自己的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 REST 框架的关系比 django-filters 更多。 在没有聚合表达式支持的情况下，我们真的需要django_filters.rest_framework.OrderingFilter中的表达式支持吗？ 这可能只会让 django-filter 用户感到困惑，而不会带来太多好处。

我期待听到您的意见。 我知道有很多信息需要消化。 希望我的测试项目可能会有所帮助： https ://github.com/earshinov/django_sample/tree/master/django_sample/ordering_by_expression