Comment composer dynamiquement un filtre de requête OR dans Django?

À partir d'un exemple, vous pouvez voir un filtre de requête OR multiple:

Article.objects.filter(Q(pk=1) | Q(pk=2) | Q(pk=3))

Par exemple, cela se traduit par:

[<Article: Hello>, <Article: Goodbye>, <Article: Hello and goodbye>]

Cependant, je souhaite créer ce filtre de requête à partir d'une liste. Comment faire ça?

par exemple [1, 2, 3] -> Article.objects.filter(Q(pk=1) | Q(pk=2) | Q(pk=3))

Vous pouvez enchaîner vos requêtes comme suit:

values = [1,2,3]

# Turn list of values into list of Q objects
queries = [Q(pk=value) for value in values]

# Take one Q object from the list
query = queries.pop()

# Or the Q object with the ones remaining in the list
for item in queries:
    query |= item

# Query the model
Article.objects.filter(query)

Pour créer des requêtes plus complexes, il existe également la possibilité d'utiliser les constantes Q.OR et Q.AND de l'objet Q () intégré avec la méthode add () comme ceci:

list = [1, 2, 3]
# it gets a bit more complicated if we want to dynamically build
# OR queries with dynamic/unknown db field keys, let's say with a list
# of db fields that can change like the following
# list_with_strings = ['dbfield1', 'dbfield2', 'dbfield3']

# init our q objects variable to use .add() on it
q_objects = Q(id__in=[])

# loop trough the list and create an OR condition for each item
for item in list:
    q_objects.add(Q(pk=item), Q.OR)
    # for our list_with_strings we can do the following
    # q_objects.add(Q(**{item: 1}), Q.OR)

queryset = Article.objects.filter(q_objects)

# sometimes the following is helpful for debugging (returns the SQL statement)
# print queryset.query

Une façon plus courte d'écrire la réponse de Dave Webb en utilisant la fonction de réduction de python :

# For Python 3 only
from functools import reduce

values = [1,2,3]

# Turn list of values into one big Q objects  
query = reduce(lambda q,value: q|Q(pk=value), values, Q())  

# Query the model  
Article.objects.filter(query)  

from functools import reduce
from operator import or_
from django.db.models import Q

values = [1, 2, 3]
query = reduce(or_, (Q(pk=x) for x in values))

Il est peut-être préférable d'utiliser l'instruction SQL IN.

Article.objects.filter(id__in=[1, 2, 3])

Voir la référence de l'API queryset .

Si vous avez vraiment besoin de faire des requêtes avec une logique dynamique, vous pouvez faire quelque chose comme ça (moche + non testé):

query = Q(field=1)
for cond in (2, 3):
    query = query | Q(field=cond)
Article.objects.filter(query)

Voir la documentation :

>>> Blog.objects.in_bulk([1])
{1: <Blog: Beatles Blog>}
>>> Blog.objects.in_bulk([1, 2])
{1: <Blog: Beatles Blog>, 2: <Blog: Cheddar Talk>}
>>> Blog.objects.in_bulk([])
{}

Notez que cette méthode ne fonctionne que pour les recherches de clé primaire, mais cela semble être ce que vous essayez de faire.

Donc ce que vous voulez c'est:

Article.objects.in_bulk([1, 2, 3])

Si nous voulons définir par programme le champ de base de données que nous voulons interroger:

import operator
questions = [('question__contains', 'test'), ('question__gt', 23 )]
q_list = [Q(x) for x in questions]
Poll.objects.filter(reduce(operator.or_, q_list))

Solution qui utilise reduceet or_opérateurs pour filtrer par multi-champs.

from functools import reduce
from operator import or_
from django.db.models import Q

filters = {'field1': [1, 2], 'field2': ['value', 'other_value']}

qs = Article.objects.filter(
   reduce(or_, (Q(**{f'{k}__in': v}) for k, v in filters.items()))
)

ps fest un nouveau format littéral de chaînes. Il a été introduit dans python 3.6

Vous pouvez utiliser l'opérateur | = pour mettre à jour par programme une requête à l'aide d'objets Q.

Celui-ci est pour la liste pk dynamique:

pk_list = qs.values_list('pk', flat=True)  # i.e [] or [1, 2, 3]

if len(pk_list) == 0:
    Article.objects.none()

else:
    q = None
    for pk in pk_list:
        if q is None:
            q = Q(pk=pk)
        else:
            q = q | Q(pk=pk)

    Article.objects.filter(q)

Une autre option que je ne le savais pas jusqu'à récemment - QuerySetremplace également les &, |, ~, etc, opérateurs. Les autres réponses que les objets OR Q sont une meilleure solution à cette question, mais par souci d'intérêt / argument, vous pouvez faire:

id_list = [1, 2, 3]
q = Article.objects.filter(pk=id_list[0])
for i in id_list[1:]:
    q |= Article.objects.filter(pk=i)

str(q.query)renverra une requête avec tous les filtres de la WHEREclause.

Pour la boucle:

values = [1, 2, 3]
q = Q(pk__in=[]) # generic "always false" value
for val in values:
    q |= Q(pk=val)
Article.objects.filter(q)

Réduire:

from functools import reduce
from operator import or_

values = [1, 2, 3]
q_objects = [Q(pk=val) for val in values]
q = reduce(or_, q_objects, Q(pk__in=[]))
Article.objects.filter(q)

Les deux sont équivalents à Article.objects.filter(pk__in=values)

Il est important de considérer ce que vous voulez quand il valuesest vide. De nombreuses réponses avec Q()comme valeur de départ renverront tout . Q(pk__in=[])est une meilleure valeur de départ. C'est un objet Q toujours en échec qui est bien géré par l'optimiseur (même pour les équations complexes).

Article.objects.filter(Q(pk__in=[]))  # doesn't hit DB
Article.objects.filter(Q(pk=None))    # hits DB and returns nothing
Article.objects.none()                # doesn't hit DB
Article.objects.filter(Q())           # returns everything

Si vous voulez tout renvoyer quand il valuesest vide, vous devez ET avec ~Q(pk__in=[])pour vous assurer que le comportement:

values = []
q = Q()
for val in values:
    q |= Q(pk=val)
Article.objects.filter(q)                     # everything
Article.objects.filter(q | author="Tolkien")  # only Tolkien

q &= ~Q(pk__in=[])
Article.objects.filter(q)                     # everything
Article.objects.filter(q | author="Tolkien")  # everything

Il est important de se rappeler que ce Q()n'est rien , pas un objet Q qui se succède toujours. Toute opération l'impliquant la laissera tomber complètement.

facile ..
de django.db.models importez Q importez vous modélisez args = (Q (visibilité = 1) | (Q (visibilité = 0) & Q (utilisateur = self.user))) #Tuple parameters = {} #dic order = limite 'create_at' = 10

Models.objects.filter(*args,**parameters).order_by(order)[:limit]