Django-filter: [ऑर्डरिंगफ़िल्टर] प्रश्न / फ़ीचर अनुरोध: ऑर्डर करने के लिए मनमाने ढंग से Django ORM अभिव्यक्ति निर्दिष्ट करने की अनुमति दें

हाय @earshinov। रिपोर्ट के लिए धन्यवाद। बहुत ही रोचक। मुझे इसके बारे में सोचने दो। मार्च में मुझे पिंग करें अगर मैंने तब तक जवाब नहीं दिया है। मैं

एक और विचार: एक कदम आगे जाना और फ़िल्टर को एक नहीं, बल्कि कई अभिव्यक्तियों या फ़ील्ड नामों को निर्दिष्ट करने की अनुमति देना संभव है।

पहले (विकल्प 1):

class OrderOrderingFilter(ddf.OrderingFilter):

    def __init__(self):
        super().__init__(fields={
            'user': functions.Concat(
                models.F('user__first_name'),
                models.Value(' '),
                models.F('user__last_name'),
            ),
        })

के बाद (विकल्प 2):

class OrderOrderingFilter(ddf.OrderingFilter):

    def __init__(self):
        super().__init__(fields={
            'user': ('user__first_name', 'user__last_name'),
        })

दोनों ही मामलों में ordering=user पहले उपयोगकर्ता के पहले नाम से डेटा ऑर्डर करता है, उपयोगकर्ता का दूसरा नाम दूसरा, लेकिन विकल्प 2 लिखना आसान होता है, और जब डीबी प्रश्नों की बात आती है तो शायद अधिक कुशल होता है।

हैलो @carlongibson ,

आपने मुझे मैच में आपको पिंग करने के लिए कहा। यह पहले से ही मई है :)

भावों (एक या एकाधिक) द्वारा आदेश देने के अपने प्रस्ताव पर वापस लौटते हुए, मुझे वास्तव में लगता है कि यह पहेली का एक लापता हिस्सा है।

मैं चार बुनियादी तालिका संचालन देखता हूं:
ए। क्रमबद्धता
बी। ~पेजिनेशन~ (इस चर्चा के लिए अप्रासंगिक)
सी। छानने
डी। छंटाई

DRF और django-filter का उपयोग करके इन सभी को संबंधित मॉडलों के समर्थन के साथ लागू करना संभव है, छँटाई को छोड़कर :

ए। क्रमबद्धता के लिए, हमारे पास नेस्टेड धारावाहिक हैं। साथ ही, अगर हमें एक समेकित फ़ील्ड वापस करने की आवश्यकता है ( count के बारे में सोचें), तो हम क्वेरीसेट .annotate() कर सकते हैं:

from django.db.models import aggregates, functions, F, Value

class ModelViewSet(...):

    def get_queryset(self):
        qs = Model.objects.all()

        if self.action == 'list':
            qs = qs.annotate(
                author_full_name=functions.Trim(functions.Concat(
                    F('author__first_name'),
                    Value(' '),
                    F('author__last_name'),
                )),
                submodel_count=aggregates.Count('submodel'))
            )

        return qs

सी। Django अभिव्यक्तियों के साथ फ़िल्टर करने के लिए, कोई कस्टम फ़िल्टर लागू कर सकता है (नीचे एक उदाहरण देखें)। सामान्य स्केलर फ़िल्टर ( filters.NumberFilter ) का उपयोग करके एक समेकित फ़ील्ड ( submodel_count ) द्वारा फ़िल्टर करना संभव है।

from django_filters import filters
from django_filters.rest_framework import FilterSet

class ModelFilterSet(FilterSet):

    author = UserFilter(field_name='author', label='author', lookup_expr='icontains')


class UserFilter(filters.Filter):
    """A django_filters filter that implements filtering by user's full name.

    def filter(self, qs: QuerySet, value: str) -> QuerySet:
        # first_name <lookup_expr> <value> OR last_name <lookup_expr> <value>
        return qs if not value else qs.filter(
            Q(**{f'{self.field_name}__first_name__{self.lookup_expr}': value}) |
            Q(**{f'{self.field_name}__last_name__{self.lookup_expr}': value})
        )

डी। छँटाई का कोई समाधान नहीं है :-(

यहां हमारे कस्टम OrderingFilter का पूर्ण कार्यान्वयन है, जिसका हम अब तक उपयोग कर रहे हैं:

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

    Usage example:

    .. code-block:: python

      from django.db import models
      from django.db.models import aggregates, expressions, fields

      import ddl

      class OrderOrderingFilter(ddl.OrderingFilter):
        def __init__(self):
          super().__init__(fields={

            # a model field
            'created': 'created'

            # an expression
            'submitted': expressions.ExpressionWrapper(
                models.Q(submitted_date__isnull=False),
                output_field=fields.BooleanField()
            ),

            # multiple fields or expressions
            'user': ('user__first_name', 'user__last_name'),

            # a complete field descriptor with custom field label
            'products': {
              'label': 'Total number of items in the order',
              # if not specified, `desc_label` would be derived from 'label' anyway
              'desc_label': 'Total number of items in the order (descending)',
              'expr': aggregates.Sum('order_lines__quantity'),
              # it is also possible to filter by multiple fields or expressions here
              #'exprs': (...)
            },
          })

    For more information about expressions, see the official Django documentation at
    https://docs.djangoproject.com/en/dev/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="7">@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(*(itertools.chain(*(self.__get_ordering_exprs(param) for param in value))))

    def __get_ordering_exprs(self, param) -> typing.Union[None, typing.List[expressions.Expression]]:
        descending = param.startswith('-')
        param = param[1:] if descending else param
        field_descriptor = self._fields.get(param)
        return () if field_descriptor is None else \
            field_descriptor.exprs if not descending else \
            (expr.desc() for expr in field_descriptor.exprs)



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

def normalize_exprs(exprs: typing.Union[
        typing.Union[str, expressions.Expression],
        typing.List[typing.Union[str, expressions.Expression]]
    ]) -> typing.List[expressions.Expression]:
    # `exprs` is either a single expression or a Sequence of expressions
    exprs = exprs if isinstance(exprs, collections.Sequence) and not isinstance(exprs, str) else (exprs,)
    return [normalize_expr(expr) for expr in exprs]

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


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


class FieldDescriptor:
    exprs: typing.List[models.Expression]

    def __init__(self, param_name: str, data: typing.Mapping[str, typing.Any]):
        exprs = data.get('exprs') or data.get('expr')
        if not exprs:
            raise ValueError("Expected 'exprs' or 'expr'")
        self.exprs = normalize_exprs(exprs)
        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

_Update_: normalize_fields और अन्य सहायक विधियों का कार्यान्वयन शामिल है।

अच्छा। मैं

पिंग के लिए धन्यवाद।

टीबीएच मेरे पास इस बारे में सोचने के लिए एक पल भी नहीं है।

आपके सभी महान विचारों में क्या आपके पास एक छोटे से बदलाव के लिए कोई सुझाव है जो हम कर सकते हैं? (शायद पीआर के साथ आगे बढ़ना आसान है)।

हाँ, यह तुरंत स्पष्ट नहीं है कि ऐसे परिवर्तनों को पिछड़े संगत कैसे बनाया जाए, मुझे इस पर विचार करना होगा। जल्द ही एक पीआर की उम्मीद न करें (उन जगहों पर छुट्टी होगी जहां इंटरनेट दुर्लभ है)।

कोई बात नहीं। मैं

यहां कोई जल्दी नहीं है। बेहतर होगा कि हम विचार करें, यदि बिल्कुल।

@carltongibson , ठीक है, हमने थोड़ा विचार किया, लेकिन OrderingFilter के पुराने और नए कार्यान्वयन के संयोजन का एक स्वीकार्य तरीका नहीं मिला।

अगर हम सब कुछ एक वर्ग में रखने जा रहे हैं, तो सबसे बड़ी समस्या यह है कि पुराने कार्यान्वयन में फ़ील्ड model_field - parameter_name जोड़े को स्टोर करते हैं, जबकि नए कार्यान्वयन में यह विपरीत parameter_name है। model_field (यह होना चाहिए, क्योंकि model_field के बजाय एक अभिव्यक्ति पारित की जा सकती है, जिसे केवल एक मूल्य में संग्रहीत किया जा सकता है, लेकिन एक शब्दकोश में एक कुंजी में नहीं) .

तकनीकी रूप से, "पुराने तरीके से" शब्दकोश की व्याख्या करके इस समस्या को दूर करना संभव है यदि इसमें केवल तार हों, और "नए तरीके से" अन्यथा। इस मामले में अभिव्यक्ति द्वारा आदेश देने की आवश्यकता उत्पन्न होने पर उपयोगकर्ता को शब्दकोश प्रविष्टियों को "फ्लिप" करना होगा। और शब्दकोश प्रविष्टियों को वापस "फ्लिप" करने के लिए सावधान रहें, क्या ऑर्डरिंग अभिव्यक्ति को हटा दिया जाना चाहिए ... यह मेरे लिए एक भयानक उपयोगकर्ता अनुभव की तरह लगता है। यह कार्यान्वयन को भी जटिल बना देगा।

क्या आपको लगता है कि ExpressionOrderingFilter जैसे किसी भिन्न नाम से पुराने के साथ नया ऑर्डरिंगफ़िल्टर पेश करना संभव है?

यह बहुत अच्छा है, ठीक इस समय मुझे इसकी आवश्यकता थी! धन्यवाद @earshinov!

मैं कुछ ऐसा कैसे करूंगा:

MyModel.objects.all().order_by(F('price').desc(nulls_last=True))

आपके ऑर्डरिंग फ़िल्टर के साथ?

    o = ExpressionOrderingFilter(

        fields={
                'price': F('price').desc(nulls_last=True)
        }

    )

बहुत अच्छा काम करने लगता है!
अब केवल एक चीज बची है, यह पता लगाना है कि एकाधिक फिल्टर को कैसे संयोजित किया जाए, एके। 'कीमत' और 'स्टॉक' एक में।

अच - इस पर प्रतिक्रिया देना शुरू कर दिया लेकिन मेरा कंप्यूटर खराब हो गया।

मुझे लगता है कि यहां प्रस्तावित परिवर्तन समझदार हैं। model_field - parameter_name जोड़ी उस समय समझ में आई क्योंकि हम आम तौर पर मॉडल से उजागर पैरा/फॉर्म/आदि प्राप्त करते हैं, लेकिन ऐसा कोई कारण नहीं है कि यह आवश्यक क्यों है। मैपिंग की अदला-बदली करना समझ में आता है, और हमें अधिक जटिल अभिव्यक्तियों का लाभ उठाने की अनुमति देता है।

साथ ही, मुझे नहीं लगता कि बहिष्करण प्रक्रिया बेहद कठिन होगी, और मुझे इसमें मदद करने में खुशी होगी। मूल रूप से, fields और field_labels params और param_labels में परिवर्तित हो जाएंगे। पश्च संगतता बनाए रखते हुए, और पुराने तर्कों का उपयोग करने वाले उपयोगकर्ताओं के लिए बहिष्करण नोटिस जारी करते हुए, एक से दूसरे में कनवर्ट करना काफी आसान है।

अवरोही मामले ( param बनाम -param ) के लिए जटिल अभिव्यक्तियों का स्वचालित रूपांतरण विचार करने वाली एक बात है। उदाहरण के लिए, यदि आरोही .asc(nulls_last=True) है, तो क्या इसका व्युत्क्रम .desc(nulls_first=True) होना चाहिए, या नल को क्रम की दिशा की परवाह किए बिना अंतिम रहना चाहिए?

ठीक है, सुपर @rpkilby।

हमें यहां आगे बढ़ते हुए देखकर खुशी हुई। मेरी मुख्य चिंता यह है कि हम जो कर रहे हैं उसका सही तरीके से दस्तावेजीकरण करें। उपयोगकर्ता पहले से ही df डॉक्स को थोड़ा _terse_ ढूंढते हैं, क्या हम कहेंगे 🙂 - एपीआई जोड़ने में खुशी है लेकिन हमें यह सुनिश्चित करने की आवश्यकता है कि यह स्पष्ट है।

ऐसी चीज के लिए एक व्यक्ति का प्रयास होना जरूरी नहीं है।

@rpkilby , @carltongibson , अगर आपको परियोजना में मेरे परिवर्तनों को एकीकृत करने में मेरी मदद की ज़रूरत है, तो मुझे लगता है कि मैं कुछ समय लगा सकता हूं। लेकिन मुझे दिशा-निर्देश चाहिए। मैं कहां और कैसे शुरू करूं?

हाय @earshinov। मैं दस्तावेज़ों का मसौदा तैयार करके शुरू करूंगा। हम क्या कहानी सुनाते हैं? वहां से कोड बदल जाता है। एक जनसंपर्क, भले ही सिर्फ एक मसौदा हमें बात करने के लिए कुछ देता है।

इसके अलावा, यदि आपके पास मामले हैं तो परीक्षण करें। अंतिम परिवर्तनों से मेल खाने के लिए उन्हें समायोजित करने की आवश्यकता हो सकती है, लेकिन विभिन्न मामलों पर विचार करना बहुत मददगार होगा (उदाहरण के लिए, .asc को .desc में परिवर्तित करना, nulls_fist / nulls_last को संभालना