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

Considera semplici modelli Django Evente 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)

È facile annotare la query sugli eventi con il numero totale di partecipanti:

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

Come annotare con il conteggio dei partecipanti filtrati per is_paid=True ?

Ho bisogno di interrogare tutti gli eventi indipendentemente dal numero di partecipanti, ad esempio non ho bisogno di filtrare per risultato annotato. Se ci sono0 partecipanti, va bene, ho solo bisogno 0di un valore annotato.

L' esempio della documentazione non funziona qui, perché esclude gli oggetti dalla query invece di annotarli con 0.

Aggiornare. Django 1.8 ha una nuova funzionalità per le espressioni condizionali , quindi 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()
    )))

Aggiornamento 2. Django 2.0 ha una nuova funzionalità di aggregazione condizionale , vedere la risposta accettata di seguito.

L'aggregazione condizionale in Django 2.0 ti consente di ridurre ulteriormente la quantità di faff che è stata in passato. Questo utilizzerà anche la filterlogica di Postgres , che è un po 'più veloce di un sum-case (ho visto numeri come il 20-30% banditi).

Ad ogni modo, nel tuo caso, stiamo guardando qualcosa di semplice come:

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

C'è una sezione separata nei documenti sul filtraggio delle annotazioni . È la stessa cosa dell'aggregazione condizionale ma più simile al mio esempio sopra. In ogni caso, questo è molto più sano delle sottoquery nodose che stavo facendo prima.

Ho appena scoperto che Django 1.8 ha una nuova funzionalità di espressioni condizionali , quindi 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()
    )))

AGGIORNARE

L'approccio di sottoquery che ho citato è ora supportato in Django 1.11 tramite espressioni di sottoquery .

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

Lo preferisco all'aggregazione (somma + maiuscole / minuscole) , perché dovrebbe essere più veloce e più facile da ottimizzare (con una corretta indicizzazione) .

Per la versione precedente, lo stesso può essere ottenuto 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`"
})

Suggerirei di utilizzare il .valuesmetodo del tuoParticipant set query.

In breve, quello che vuoi fare è dato da:

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

Un esempio completo è il seguente:

1. Crea 2 Events:

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

2. Aggiungi Participants 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. Raggruppa tutti Participanti messaggi in base al loro eventcampo:

   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 è necessario distinto:

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

   Quello .valuesche .distinctstanno facendo qui è che stanno creando due secchi di messaggi Participantraggruppati in base al loro elemento event. Nota che quei secchi contengono Participant.

4. È quindi possibile annotare quei bucket poiché contengono il set di originali Participant. Qui vogliamo contare il numero di Participant, questo viene semplicemente fatto contando le ids degli elementi in quei bucket (poiché quelli sono Participant):

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

5. Infine vuoi solo Participantcon un is_paidessere True, puoi semplicemente aggiungere un filtro davanti all'espressione precedente, e questo produce l'espressione mostrata sopra:

   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 è che devi recuperare il Eventdopo poiché hai solo idil metodo sopra.

Quale risultato sto cercando:

• Persone (assegnatario) a cui sono state aggiunte attività a un report. - Conteggio unico totale di persone
• Persone che hanno attività aggiunte a un report ma, solo per attività la cui fatturabilità è maggiore di 0.

In generale, dovrei utilizzare due query diverse:

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

Ma voglio entrambi in una query. Quindi:

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

Risultato:

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