如何在 Django 中过滤对象以进行计数注释？

Question

考虑简单的 Django 模型 Event 和 Participant：

class Event(models.Model):
    title = models.CharField(max_length=100)

class Participant(models.Model):
    event = models.ForeignKey(Event, db_index=True)
    is_paid = models.BooleanField(default=False, db_index=True)

使用参与者总数注释事件查询很容易：

events = Event.objects.all().annotate(participants=models.Count('participant'))

如何用is_paid=True过滤的参与者数量进行注释？

无论参与者有多少，我都需要查询所有事件，例如我不需要按带注释的结果进行过滤。如果有 0 参与者，那没关系，我只需要 0 注释值。

example from documentation 在这里不起作用，因为它从查询中排除对象，而不是用 0 注释它们。

更新。 Django 1.8 有了新的conditional expressions feature，所以现在我们可以这样做：

events = Event.objects.all().annotate(paid_participants=models.Sum(
    models.Case(
        models.When(participant__is_paid=True, then=1),
        default=0,
        output_field=models.IntegerField()
    )))

更新 2。 Django 2.0 具有新的Conditional aggregation 功能，请参阅下面的the accepted answer。

更新 3。 对于 Django 3.x，请check this answer below。

Answer 1

Django 2.0 中的Conditional aggregation 允许您进一步减少过去的faff 数量。这也将使用 Postgres 的 filter 逻辑，这比 sum-case 快一些（我见过像 20-30% 这样的数字）。

无论如何，在你的情况下，我们正在研究这样简单的事情：

from django.db.models import Q, Count
events = Event.objects.annotate(
    paid_participants=Count('participants', filter=Q(participants__is_paid=True))
)

关于filtering on annotations 的文档中有一个单独的部分。它与条件聚合相同，但更像我上面的示例。无论哪种方式，这都比我之前做的那些粗糙的子查询要健康得多。

Answer 2

刚刚发现 Django 1.8 有新的conditional expressions feature，所以现在我们可以这样做：

events = Event.objects.all().annotate(paid_participants=models.Sum(
    models.Case(
        models.When(participant__is_paid=True, then=1),
        default=0, output_field=models.IntegerField()
    )))

Answer 3

更新

我提到的子查询方法现在通过subquery-expressions在 Django 1.11 中得到支持。

Event.objects.annotate(
    num_paid_participants=Subquery(
        Participant.objects.filter(
            is_paid=True,
            event=OuterRef('pk')
        ).values('event')
        .annotate(cnt=Count('pk'))
        .values('cnt'),
        output_field=models.IntegerField()
    )
)

我更喜欢这个而不是聚合(sum+case)，因为它应该更快更容易优化（使用适当的索引）。

对于旧版本，同样可以使用.extra实现

Event.objects.extra(select={'num_paid_participants': "\
    SELECT COUNT(*) \
    FROM `myapp_participant` \
    WHERE `myapp_participant`.`is_paid` = 1 AND \
            `myapp_participant`.`event_id` = `myapp_event`.`id`"
})

Answer 4

我建议改用 Participant 查询集的 .values 方法。

简而言之，你想做的事情是：

Participant.objects\
    .filter(is_paid=True)\
    .values('event')\
    .distinct()\
    .annotate(models.Count('id'))

一个完整的例子如下：

1. 创建2个Events：

   event1 = Event.objects.create(title='event1')
   event2 = Event.objects.create(title='event2')
   

2. 给他们添加Participants：

   part1l = [Participant.objects.create(event=event1, is_paid=((_%2) == 0))\
             for _ in range(10)]
   part2l = [Participant.objects.create(event=event2, is_paid=((_%2) == 0))\
             for _ in range(50)]
   

3. 按event 字段对所有Participants 进行分组：

   Participant.objects.values('event')
   > <QuerySet [{'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 1}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, {'event': 2}, '...(remaining elements truncated)...']>
   

   这里需要区分：

   Participant.objects.values('event').distinct()
   > <QuerySet [{'event': 1}, {'event': 2}]>
   

   .values 和 .distinct 在这里所做的是，他们正在创建两个按元素 event 分组的 Participants 桶。请注意，这些存储桶包含 Participant。

4. 然后您可以注释这些存储桶，因为它们包含原始Participant 的集合。这里我们要计算Participant的数量，这只是通过计算那些桶中元素的ids来完成的（因为那些是Participant）：

   Participant.objects\
       .values('event')\
       .distinct()\
       .annotate(models.Count('id'))
   > <QuerySet [{'event': 1, 'id__count': 10}, {'event': 2, 'id__count': 50}]>
   

5. 最后你只想要Participant 和is_paid 是True，你可以在前面的表达式前面添加一个过滤器，这会产生如上所示的表达式：

   Participant.objects\
       .filter(is_paid=True)\
       .values('event')\
       .distinct()\
       .annotate(models.Count('id'))
   > <QuerySet [{'event': 1, 'id__count': 5}, {'event': 2, 'id__count': 25}]>
   

唯一的缺点是您必须在之后检索Event，因为您只有上述方法中的id。

Answer 5

我在寻找什么结果：

• 已将任务添加到报表的人员（受让人）。 - 总唯一 人数
• 已将任务添加到报告中但对于任务 可计费性仅大于 0。

一般来说，我必须使用两个不同的查询：

Task.objects.filter(billable_efforts__gt=0)
Task.objects.all()

但我想要两个都在一个查询中。因此：

Task.objects.values('report__title').annotate(withMoreThanZero=Count('assignee', distinct=True, filter=Q(billable_efforts__gt=0))).annotate(totalUniqueAssignee=Count('assignee', distinct=True))

结果：

<QuerySet [{'report__title': 'TestReport', 'withMoreThanZero': 37, 'totalUniqueAssignee': 50}, {'report__title': 'Utilization_Report_April_2019', 'withMoreThanZero': 37, 'totalUniqueAssignee': 50}]>

Answer 6

对于 Django 3.x，只需在注释后编写过滤器：

User.objects.values('user_id')
            .annotate(xyz=models.Sum('likes'))
            .filter(xyz__gt=100)

在上面的 xyz 不是 User Model 中的模型字段，这里我们过滤了喜欢（或 xyz）超过 100 的用户。