Jak filtrować obiekty w celu zliczania komentarzy w Django?

Question

Rozważmy prostych modeli Django Event i 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) 

Łatwo jest opisywanie dalszych wydarzeń z ogólnej liczby uczestników:

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

Jak adnotacje z liczbą uczestników filtrowany przez is_paid=True?

Muszę wysłać zapytanie wszystkie zdarzenia niezależnie od liczby uczestników, np. Nie muszę filtrować według adnotowanych wyników. Jeśli są uczestnicy 0, to w porządku, po prostu potrzebuję 0 w adnotowanej wartości.

Tu nie działa example from documentation, ponieważ wyklucza obiekty z kwerendy zamiast ich adnotacji z 0.

Aktualizacja. Django 1.8 posiada nowy conditional expressions feature, więc teraz możemy zrobić tak:

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() 
    ))) 

Aktualizacja 2. Django 2.0 posiada nową funkcję Conditional aggregation zobacz the accepted answer poniżej.

Answer 1

Conditional aggregation w Django 2.0 pozwala na dalsze zmniejszenie ilości faff, które były w przeszłości. Będzie to również wykorzystywać logikę PostgreSta filter, która jest nieco szybsza niż przypadek sumy (widziałem liczby takie jak ok. 20-30%).

W każdym razie, w przypadku, patrzymy na coś tak prostego jak:

events = Event.objects.annotate(
    paid_participants=Count('participants', filter=Q(participants__is_paid=True)) 
) 

Istnieje osobny rozdział w docs około filtering on annotations. To jest to samo, co warunkowa agregacja, ale bardziej jak mój przykład powyżej. Tak czy inaczej, jest to o wiele zdrowsze niż gnarly podkwarki, które robiłem wcześniej.

Answer 2

UPDATE

Podejście sub-query której wspominam jest teraz obsługiwana w Django 1.11 poprzez subquery-expressions.

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() 
    ) 
) 

wolę to ponad agregacji (suma + case), dlatego powinna ona być szybciej i łatwiej być zoptymalizowane (z odpowiednim indeksowania).

Dla starszej wersji, to samo można osiągnąć stosując .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 3

właśnie odkrył, że Django 1.8 posiada nowy conditional expressions feature, więc teraz możemy zrobić tak:

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 4

Proponuję zamiast tego użyj metody .values zestawu zapytań .

Na krótki, co chcesz zrobić jest dana przez:

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

Kompletny przykład jest następująca:

1. utworzyć 2 Event S:

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

2. Dodaj do nich: Participant:

   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. Grupa wszystkie Participant s przez ich event polu:

   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)...']> 
   

   Tutaj odrębny wymagające:

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

   Co .values i .distinct robią tutaj jest to, że są one tworząc dwa wiadra Participant s zgrupowane według ich elementów event. Zauważ, że te wiadra zawierają Participant.

4. Następnie można opisać te segmenty, ponieważ zawierają one zestaw oryginalnych Participant. Tutaj chcemy policzyć Participant, jest to po prostu zrobić przez liczenie id S o elementach w tych wiadrach (ponieważ są to Participant):

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

5. Wreszcie chcesz tylko Participant z is_paid będąc True , można po prostu dodać filtr przed poprzedniego słowa, a to w wyniku czego otrzymano przedstawione powyżej wyrażenie:

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

Jedyną wadą jest to th na końcu musisz odzyskać Event, ponieważ masz tylko id z powyższej metody.