Come filtrare gli oggetti per l'annotazione del conteggio in Django?

Question

consideri semplici modelli Django Event e 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) 

E 'facile per annotare eventi di query con il numero totale dei partecipanti:

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

Come annotare con conteggio dei partecipanti filtrata da is_paid=True?

Ho bisogno di interrogare tutti gli eventi indipendentemente dal numero di partecipanti, ad es. Non ho bisogno di filtrare per risultato annotato. Se ci sono 0 partecipanti, va bene, ho solo bisogno di 0 nel valore annotato.

Il example from documentation non funziona qui, perché esclude gli oggetti dalla query invece di annotarli con 0.

Aggiornamento . Django 1.8 dispone di nuove conditional expressions feature, così ora possiamo fare in questo modo:

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

Update 2. Django 2.0 ha una nuova funzione di Conditional aggregation, vedi the accepted answer sotto.

Answer 1

Conditional aggregation in Django 2.0 consente di ridurre ulteriormente la quantità di file in uscita nel passato. Questo userà anche la logica di Postgres filter, che è un po 'più veloce di un caso limite (ho visto numeri come il 20-30% delimitati).

In ogni caso, nel tuo caso, stiamo cercando qualcosa di semplice come:

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

C'è una sezione separata nella documentazione circa filtering on annotations. È la stessa roba dell'aggregazione condizionale, ma più simile al mio esempio sopra. In entrambi i casi, questo è molto più sano delle subquery nodose che stavo facendo prima.

Answer 2

UPDATE

L'approccio sub-query che cito è ora supportata in Django 1.11 via 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() 
    ) 
) 

Preferisco questo oltre aggregazione (somma + caso), perché dovrebbe essere più veloce e più facile da essere ottimizzati (con una corretta indicizzazione).

Per la versione più vecchia, lo stesso può essere raggiunto utilizzando .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

appena scoperto che Django 1.8 ha un nuovo conditional expressions feature, così ora possiamo fare in questo modo:

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

Vorrei suggerire a utilizzare invece il metodo .values del proprio queryset Participant.

in breve, ciò che si vuole fare è data da:

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

Un esempio completo è il seguente:

1. creare 2 Event s:

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

2. Aggiungi Participant s a loro:

   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. Gruppo tutti Participant s per la loro event campo:

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

   Qui è necessaria distinti:

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

   Cosa .values e .distinct stanno facendo qui è che stanno creando due secchi di Participant s raggruppati per il loro elemento event. Si noti che questi bucket contengono Participant.

4. È quindi possibile annotare i bucket in quanto contengono il set dell'originale Participant. Qui vogliamo contare il numero di Participant, questo è semplicemente fatto contando i id s degli elementi a quelli secchi (in quanto tali sono Participant):

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

5. Infine desideri solo Participant con un is_paid essere True , si può solo aggiungere un filtro di fronte alla precedente espressione, e questo cedere l'espressione sopra indicato:

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

l'unico inconveniente è th devi recuperare lo Event in seguito, dato che hai il solo id dal metodo sopra.