在 django 过滤器中使用关系时过滤器的 OR 定义

2023-12-11

我有三个模型，其简单关系如下：

模型.py

class Person(models.Model):
    first_name = models.CharField(max_length=20)
    last_name = models.CharField(max_length=20)

class PersonSession(models.Model):
    start_time = models.DateTimeField(auto_now_add=True)
    end_time = models.DateTimeField(null=True,
                                    blank=True)
    person = models.ForeignKey(Person, related_name='sessions')

class Billing(models.Model):
    DEBT = 'DE'
    BALANCED = 'BA'
    CREDIT = 'CR'

    session = models.OneToOneField(PersonSession,
                                   blank=False,
                                   null=False,
                                   related_name='billing')
    STATUS = ((BALANCED, 'Balanced'),
              (DEBT, 'Debt'),
              (CREDIT, 'Credit'))

    status = models.CharField(max_length=2,
                              choices=STATUS,
                              blank=False,
                              default=BALANCED
                              )

views.py

class PersonFilter(django_filters.FilterSet):
    start_time = django_filters.DateFromToRangeFilter(name='sessions__start_time',
                                 distinct=True)
    billing_status = django_filters.ChoiceFilter(name='sessions__billing__status',
                        choices=Billing.STATUS,
                        distinct=True)

    class Meta:
        model = Person
        fields = ('first_name', 'last_name')

class PersonList(generics.ListCreateAPIView):
    queryset = Person.objects.all()
    serializer_class = PersonSerializer
    filter_backends = (django_filters.rest_framework.DjangoFilterBackend)
    filter_class = PersonFilter

我想从个人端点获取账单DE计费状态和一段时间之间：

api/persons?start_time_0=2018-03-20&start_time_1=2018-03-23&billing_status=DE

但结果不是我想要的，这会返回所有人在该期间有一次会话，并且与DE状态，无论该账单是否在该期间内。

换句话说，似乎使用or我认为两个过滤器字段之间的操作这个帖子与此问题相关，但目前我找不到方法来获得我想要的结果。我正在使用 djang 1.10.3。

Edit

我尝试写一个example显示我需要什么以及我从 django 过滤器中得到什么。如果我在示例中得到使用以下查询的人，我只会得到两个人：

select * 
from 
test_filter_person join test_filter_personsession on test_filter_person.id=test_filter_personsession.person_id join test_filter_billing on test_filter_personsession.id=test_filter_billing.session_id 
where
start_time > '2000-02-01' and start_time < '2000-03-01' and status='DE';

这让我只得到第 1 个人和第 2 个人。但是，如果我从 url 中得到预期的类似内容，我会得到所有人的相似网址（至少有一个我期望相同的网址）如下：

http://address/persons?start_time_0=2000-02-01&start_time_1=2000-03-01&billing_status=DE

Edit2

这是我在示例中的查询所依据的数据，使用它们您可以看到我上面提到的查询中必须返回的内容：

 id | first_name | last_name | id |        start_time         |         end_time          | person_id | id | status | session_id 
----+------------+-----------+----+---------------------------+---------------------------+-----------+----+--------+------------
  0 | person     | 0         |  0 | 2000-01-01 16:32:00+03:30 | 2000-01-01 17:32:00+03:30 |         0 |  0 | DE     |          0
  0 | person     | 0         |  1 | 2000-02-01 16:32:00+03:30 | 2000-02-01 17:32:00+03:30 |         0 |  1 | BA     |          1
  0 | person     | 0         |  2 | 2000-03-01 16:32:00+03:30 | 2000-03-01 17:32:00+03:30 |         0 |  2 | DE     |          2
  1 | person     | 1         |  3 | 2000-01-01 16:32:00+03:30 | 2000-01-01 17:32:00+03:30 |         1 |  3 | BA     |          3
  1 | person     | 1         |  4 | 2000-02-01 16:32:00+03:30 | 2000-02-01 17:32:00+03:30 |         1 |  4 | DE     |          4
  1 | person     | 1         |  5 | 2000-03-01 16:32:00+03:30 | 2000-03-01 17:32:00+03:30 |         1 |  5 | DE     |          5
  2 | person     | 2         |  6 | 2000-01-01 16:32:00+03:30 | 2000-01-01 17:32:00+03:30 |         2 |  6 | DE     |          6
  2 | person     | 2         |  7 | 2000-02-01 16:32:00+03:30 | 2000-02-01 17:32:00+03:30 |         2 |  7 | DE     |          7
  2 | person     | 2         |  8 | 2000-03-01 16:32:00+03:30 | 2000-03-01 17:32:00+03:30 |         2 |  8 | BA     |          8

Edit3

我尝试使用prefetch_related连接表并获得我预期的结果，因为我认为额外的连接会导致这个问题，但这不起作用，我仍然得到相同的结果，并且没有任何影响。

Edit4

This issue有同样的问题。

我还没有解决办法；但我认为对问题的简洁总结会比我在工作中激发更多更好的思想！

据我了解；您的核心问题是两个先决条件的结果：

事实上，您在相关模型上定义了两个离散滤波器；导致过滤器跨越多值关系
The way FilterSet实现过滤

让我们更详细地看看这些：

过滤器跨越多值关系

这是一个很好的资源，可以帮助您更好地理解问题先决条件#1：https://docs.djangoproject.com/en/2.0/topics/db/queries/#spanning-multi-valued-relationships

本质上，start_time过滤器添加了一个.filter(sessions__start_time=value)到你的查询集，以及billing_status过滤器添加了一个.filter(sessions_billing_status=value)到过滤器。这会导致上述“跨越多值关系”问题，这意味着它将产生OR在这些过滤器之间而不是AND正如你所要求的那样。

这让我开始思考，为什么我们在start_time筛选;但这里的技巧是它被定义为DateFromToRangeFilter;它在内部使用单个过滤器查询__range=构造。如果相反的话sessions__start_time__gt= and sessions__start_time__lt=，我们在这里也会遇到同样的问题。

The way `FilterSet`实现过滤

空谈是廉价的；显示代码

@property
def qs(self):
    if not hasattr(self, '_qs'):
        if not self.is_bound:
            self._qs = self.queryset.all()
            return self._qs

        if not self.form.is_valid():
            if self.strict == STRICTNESS.RAISE_VALIDATION_ERROR:
                raise forms.ValidationError(self.form.errors)
            elif self.strict == STRICTNESS.RETURN_NO_RESULTS:
                self._qs = self.queryset.none()
                return self._qs
            # else STRICTNESS.IGNORE...  ignoring

        # start with all the results and filter from there
        qs = self.queryset.all()
        for name, filter_ in six.iteritems(self.filters):
            value = self.form.cleaned_data.get(name)

            if value is not None:  # valid & clean data
                qs = filter_.filter(qs, value)

        self._qs = qs

    return self._qs

如您所见，qs属性是通过迭代列表来解决的Filter对象，将初始 q 依次传递给每个对象并返回结果。看qs = filter_.filter(qs, value)

Each Filter这里的对象定义了一个具体的def filter操作，基本上采用查询集，然后添加连续的.filter to it.

这是一个来自BaseFilter class

   def filter(self, qs, value):
        if isinstance(value, Lookup):
            lookup = six.text_type(value.lookup_type)
            value = value.value
        else:
            lookup = self.lookup_expr
        if value in EMPTY_VALUES:
            return qs
        if self.distinct:
            qs = qs.distinct()
        qs = self.get_method(qs)(**{'%s__%s' % (self.name, lookup): value})
        return qs

重要的代码行是：qs = self.get_method(qs)(**{'%s__%s' % (self.name, lookup): value})

所以这两个先决条件为这个问题创造了完美的风暴。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)