Concatenare più filtri () in Django, è un bug?

Ho sempre pensato che concatenare più chiamate filter () in Django fosse sempre lo stesso che raccoglierle in una singola chiamata.

# Equivalent
Model.objects.filter(foo=1).filter(bar=2)
Model.objects.filter(foo=1,bar=2)

ma mi sono imbattuto in un complesso di query nel mio codice in cui questo non è il caso

class Inventory(models.Model):
    book = models.ForeignKey(Book)

class Profile(models.Model):
    user = models.OneToOneField(auth.models.User)
    vacation = models.BooleanField()
    country = models.CharField(max_length=30)

# Not Equivalent!
Book.objects.filter(inventory__user__profile__vacation=False).filter(inventory__user__profile__country='BR')
Book.objects.filter(inventory__user__profile__vacation=False, inventory__user__profile__country='BR')

L'SQL generato è

SELECT "library_book"."id", "library_book"."asin", "library_book"."added", "library_book"."updated" FROM "library_book" INNER JOIN "library_inventory" ON ("library_book"."id" = "library_inventory"."book_id") INNER JOIN "auth_user" ON ("library_inventory"."user_id" = "auth_user"."id") INNER JOIN "library_profile" ON ("auth_user"."id" = "library_profile"."user_id") INNER JOIN "library_inventory" T5 ON ("library_book"."id" = T5."book_id") INNER JOIN "auth_user" T6 ON (T5."user_id" = T6."id") INNER JOIN "library_profile" T7 ON (T6."id" = T7."user_id") WHERE ("library_profile"."vacation" = False  AND T7."country" = BR )
SELECT "library_book"."id", "library_book"."asin", "library_book"."added", "library_book"."updated" FROM "library_book" INNER JOIN "library_inventory" ON ("library_book"."id" = "library_inventory"."book_id") INNER JOIN "auth_user" ON ("library_inventory"."user_id" = "auth_user"."id") INNER JOIN "library_profile" ON ("auth_user"."id" = "library_profile"."user_id") WHERE ("library_profile"."vacation" = False  AND "library_profile"."country" = BR )

Il primo set di query con le filter()chiamate concatenate si unisce al modello Inventory due volte creando effettivamente un OR tra le due condizioni, mentre il secondo set di query esegue insieme AND le due condizioni. Mi aspettavo che la prima query avrebbe anche E le due condizioni. È questo il comportamento previsto o è un bug in Django?

La risposta a una domanda correlata C'è uno svantaggio nell'usare ".filter (). Filter (). Filter () ..." in Django? sembra indicare che i due set di query dovrebbero essere equivalenti.

Per come la intendo io è che sono sottilmente diversi in base alla progettazione (e sono certamente disponibile per la correzione): filter(A, B)prima filtreranno secondo A e poi subfilteranno secondo B, mentre filter(A).filter(B)restituiranno una riga che corrisponde ad A 'e' potenzialmente diversa riga che corrisponde a B.

Guarda l'esempio qui:

https://docs.djangoproject.com/en/dev/topics/db/queries/#spanning-multi-valued-relationships

in particolar modo:

Tutto all'interno di una singola chiamata filter () viene applicato simultaneamente per filtrare gli elementi che soddisfano tutti quei requisiti. Le successive chiamate filter () restringono ulteriormente l'insieme di oggetti

...

In questo secondo esempio (filter (A) .filter (B)), il primo filtro ha limitato il set di query a (A). Il secondo filtro ha limitato ulteriormente il set di blog a quelli che sono anche (B). Le voci selezionate dal secondo filtro possono o non possono essere le stesse delle voci nel primo filtro. »

Questi due stili di filtro sono equivalenti nella maggior parte dei casi, ma quando si esegue una query su oggetti in base a ForeignKey o ManyToManyField, sono leggermente diversi.

Esempi dalla documentazione .

Il modello
Blog to Entry è una relazione uno-a-molti.

from django.db import models

class Blog(models.Model):
    ...

class Entry(models.Model):
    blog = models.ForeignKey(Blog)
    headline = models.CharField(max_length=255)
    pub_date = models.DateField()
    ...

oggetti
Supponendo che ci siano alcuni oggetti blog e voce qui.

interrogazioni

Blog.objects.filter(entry__headline_contains='Lennon', 
    entry__pub_date__year=2008)
Blog.objects.filter(entry__headline_contains='Lennon').filter(
    entry__pub_date__year=2008)  

Per la prima query (filtro singolo), corrisponde solo a blog1.

Per la seconda query (uno dei filtri concatenati), filtra blog1 e blog2.
Il primo filtro limita il set di query a blog1, blog2 e blog5; il secondo filtro restringe ulteriormente il set di blog a blog1 e blog2.

E dovresti rendertene conto

Stiamo filtrando gli elementi del blog con ciascuna istruzione di filtro, non gli elementi della voce.

Quindi, non è la stessa cosa, perché Blog e Entry sono relazioni multivalore.

Riferimento: https://docs.djangoproject.com/en/1.8/topics/db/queries/#spanning-multi-valued-relationships
Se c'è qualcosa che non va, correggimi.

Modifica: modificato dalla v1.6 alla v1.8 poiché i collegamenti 1.6 non sono più disponibili.

Come puoi vedere nelle istruzioni SQL generate, la differenza non è l '"OR" come alcuni potrebbero sospettare. È così che vengono posizionati WHERE e JOIN.

Esempio1 (stessa tabella unita):

(esempio da https://docs.djangoproject.com/en/dev/topics/db/queries/#spanning-multi-valued-relationships )

Blog.objects.filter(entry__headline__contains='Lennon', entry__pub_date__year=2008)

Questo ti darà tutti i blog che hanno una voce con entrambi (entry_ headline _contains = 'Lennon') E (entry__pub_date__year = 2008), che è quello che ti aspetteresti da questa query. Risultato: libro con {entry.headline: "Life of Lennon", entry.pub_date: "2008"}

Esempio 2 (concatenato)

Blog.objects.filter(entry__headline__contains='Lennon').filter(entry__pub_date__year=2008)

Questo coprirà tutti i risultati dell'esempio 1, ma genererà un risultato leggermente superiore. Perché prima filtra tutti i blog con (entry_ headline _contains = 'Lennon') e poi dai filtri dei risultati (entry__pub_date__year = 2008).

La differenza è che ti darà anche risultati come: Book with {entry.headline: ' Lennon ', entry.pub_date: 2000}, {entry.headline: 'Bill', entry.pub_date: 2008 }

Nel tuo caso

Penso che sia questo di cui hai bisogno:

Book.objects.filter(inventory__user__profile__vacation=False, inventory__user__profile__country='BR')

E se vuoi usare OR leggi: https://docs.djangoproject.com/en/dev/topics/db/queries/#complex-lookups-with-q-objects

A volte non vuoi unire più filtri insieme in questo modo:

def your_dynamic_query_generator(self, event: Event):
    qs \
    .filter(shiftregistrations__event=event) \
    .filter(shiftregistrations__shifts=False)

E il codice seguente in realtà non restituirebbe la cosa corretta.

def your_dynamic_query_generator(self, event: Event):
    return Q(shiftregistrations__event=event) & Q(shiftregistrations__shifts=False)

Quello che puoi fare ora è utilizzare un filtro per il conteggio delle annotazioni.

In questo caso contiamo tutti i turni che appartengono a un determinato evento.

qs: EventQuerySet = qs.annotate(
    num_shifts=Count('shiftregistrations__shifts', filter=Q(shiftregistrations__event=event))
)

Successivamente puoi filtrare per annotazione.

def your_dynamic_query_generator(self):
    return Q(num_shifts=0)

Questa soluzione è anche più economica su set di query di grandi dimensioni.

Spero che questo ti aiuti.