如何在 Django 视图中组合两个或多个查询集？

将查询集连接成一个列表是最简单的方法。如果无论如何都会为所有查询集命中数据库（例如，因为需要对结果进行排序），这不会增加进一步的成本。

from itertools import chain
result_list = list(chain(page_list, article_list, post_list))

使用 itertools.chain 比循环每个列表并逐个追加元素要快，因为 itertools 是用 C 实现的。它消耗的内存也比在连接之前将每个查询集转换为列表要少。

现在可以对结果列表进行排序，例如按日期（如 hasen j 对另一个答案的评论中所要求的）。 sorted() 函数方便地接受生成器并返回一个列表：

result_list = sorted(
    chain(page_list, article_list, post_list),
    key=lambda instance: instance.date_created)

如果您使用的是 Python 2.4 或更高版本，则可以使用 attrgetter 代替 lambda。我记得读过它更快，但我没有看到一百万个项目列表的明显速度差异。

from operator import attrgetter
result_list = sorted(
    chain(page_list, article_list, post_list),
    key=attrgetter('date_created'))

---

尝试这个：

matches = pages | articles | posts

它保留了查询集的所有功能，如果您想要 order_by 或类似的，这很好。

请注意：这不适用于来自两个不同模型的查询集。

---

相关，对于来自同一模型的混合查询集，或对于来自几个模型的类似字段，开始 Django 1.11 也可以使用 QuerySet.union() method：

union() union(*other_qs, all=False) Django 1.11 中的新功能。使用 SQL 的 UNION 运算符组合两个或多个 QuerySet 的结果。例如： >>> qs1.union(qs2, qs3) UNION 运算符默认只选择不同的值。要允许重复值，请使用 all=True 参数。 union()、intersection() 和 difference() 返回第一个 QuerySet 类型的模型实例，即使参数是其他模型的 QuerySet。只要 SELECT 列表在所有 QuerySets 中都相同，传递不同的模型就可以工作（至少类型，名称无关紧要，只要类型顺序相同）。此外，生成的 QuerySet 上只允许使用 LIMIT、OFFSET 和 ORDER BY（即切片和 order_by()）。此外，数据库对组合查询中允许的操作设置了限制。例如，大多数数据库不允许在组合查询中使用 LIMIT 或 OFFSET。

---

您可以使用下面的 QuerySetChain 类。将它与 Django 的分页器一起使用时，它应该只对所有查询集的 COUNT(*) 查询和 SELECT() 查询只针对其记录显示在当前页面上的那些查询集来访问数据库。

请注意，如果使用带有通用视图的 QuerySetChain，您需要指定 template_name=，即使链接的查询集都使用相同的模型。

from itertools import islice, chain

class QuerySetChain(object):
    """
    Chains multiple subquerysets (possibly of different models) and behaves as
    one queryset.  Supports minimal methods needed for use with
    django.core.paginator.
    """

    def __init__(self, *subquerysets):
        self.querysets = subquerysets

    def count(self):
        """
        Performs a .count() for all subquerysets and returns the number of
        records as an integer.
        """
        return sum(qs.count() for qs in self.querysets)

    def _clone(self):
        "Returns a clone of this queryset chain"
        return self.__class__(*self.querysets)

    def _all(self):
        "Iterates records in all subquerysets"
        return chain(*self.querysets)

    def __getitem__(self, ndx):
        """
        Retrieves an item or slice from the chained set of results from all
        subquerysets.
        """
        if type(ndx) is slice:
            return list(islice(self._all(), ndx.start, ndx.stop, ndx.step or 1))
        else:
            return islice(self._all(), ndx, ndx+1).next()

在您的示例中，用法为：

pages = Page.objects.filter(Q(title__icontains=cleaned_search_term) |
                            Q(body__icontains=cleaned_search_term))
articles = Article.objects.filter(Q(title__icontains=cleaned_search_term) |
                                  Q(body__icontains=cleaned_search_term) |
                                  Q(tags__icontains=cleaned_search_term))
posts = Post.objects.filter(Q(title__icontains=cleaned_search_term) |
                            Q(body__icontains=cleaned_search_term) | 
                            Q(tags__icontains=cleaned_search_term))
matches = QuerySetChain(pages, articles, posts)

然后将 matches 与分页器一起使用，就像您在示例中使用的 result_list 一样。

itertools 模块是在 Python 2.3 中引入的，因此它应该在运行 Django 的所有 Python 版本中都可用。

---

如果你想链接很多查询集，试试这个：

from itertools import chain
result = list(chain(*docs))

其中： docs 是查询集列表

---

当前方法的最大缺点是它对大型搜索结果集的效率低下，因为您每次都必须从数据库中提取整个结果集，即使您只打算显示一页结果。

为了只从数据库中提取您实际需要的对象，您必须在 QuerySet 上使用分页，而不是列表。如果这样做，Django 实际上会在执行查询之前对 QuerySet 进行切片，因此 SQL 查询将使用 OFFSET 和 LIMIT 来仅获取您将实际显示的记录。但是你不能这样做，除非你能以某种方式将你的搜索塞进一个单一的查询中。

鉴于您的所有三个模型都有标题和正文字段，为什么不使用 model inheritance？只需让所有三个模型都从具有标题和正文的共同祖先继承，并将搜索作为对祖先模型的单个查询执行。

---

这可以通过两种方式来实现。

第一种方法

对查询集 | 使用联合运算符来合并两个查询集。如果两个查询集都属于同一模型/单个模型，则可以使用联合运算符组合查询集。

举个例子

pagelist1 = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term))
pagelist2 = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) | 
    Q(body__icontains=cleaned_search_term))
combined_list = pagelist1 | pagelist2 # this would take union of two querysets

第二种方法

在两个查询集之间实现组合操作的另一种方法是使用 itertools 链函数。

from itertools import chain
combined_results = list(chain(pagelist1, pagelist2))

---

您可以使用 Union：

qs = qs1.union(qs2, qs3)

但是，如果您想在组合查询集的外部模型上应用 order_by...那么您需要以这种方式预先Select它们...否则它将无法正常工作。

例子

qs = qs1.union(qs2.select_related("foreignModel"), qs3.select_related("foreignModel"))
qs.order_by("foreignModel__prop1")

其中 prop1 是外部模型中的一个属性。

---

DATE_FIELD_MAPPING = {
    Model1: 'date',
    Model2: 'pubdate',
}

def my_key_func(obj):
    return getattr(obj, DATE_FIELD_MAPPING[type(obj)])

And then sorted(chain(Model1.objects.all(), Model2.objects.all()), key=my_key_func)

引自https://groups.google.com/forum/#!topic/django-users/6wUNuJa4jVw。见 亚历克斯·盖纳

---

要求： Django==2.0.2、django-querysetsequence==0.8

如果您想组合 querysets 并仍然得出 QuerySet，您可能需要查看 django-queryset-sequence。

但是关于它的一个注释。它只需要两个 querysets 作为参数。但是使用 python reduce，您始终可以将其应用于多个 queryset。

from functools import reduce
from queryset_sequence import QuerySetSequence

combined_queryset = reduce(QuerySetSequence, list_of_queryset)

就是这样。以下是我遇到的情况以及我如何使用 list comprehension、reduce 和 django-queryset-sequence

from functools import reduce
from django.shortcuts import render    
from queryset_sequence import QuerySetSequence

class People(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    mentor = models.ForeignKey('self', null=True, on_delete=models.SET_NULL, related_name='my_mentees')

class Book(models.Model):
    name = models.CharField(max_length=20)
    owner = models.ForeignKey(Student, on_delete=models.CASCADE)

# as a mentor, I want to see all the books owned by all my mentees in one view.
def mentee_books(request):
    template = "my_mentee_books.html"
    mentor = People.objects.get(user=request.user)
    my_mentees = mentor.my_mentees.all() # returns QuerySet of all my mentees
    mentee_books = reduce(QuerySetSequence, [each.book_set.all() for each in my_mentees])

    return render(request, template, {'mentee_books' : mentee_books})

---

这是一个想法……只需从三个结果中的每一个中提取一整页的结果，然后丢弃 20 个最不有用的结果……这消除了大型查询集，这样您只牺牲了一点性能而不是很多。

---

这将在不使用任何其他库的情况下完成工作：

result_list = page_list | article_list | post_list

---

最好的选择是使用 Django 内置方法：

# Union method
result_list = page_list.union(article_list, post_list)

这将返回这些查询集中所有对象的联合。

如果您只想获取三个查询集中的对象，您会喜欢查询集的内置方法 intersection。

# intersection method
result_list = page_list.intersection(article_list, post_list)

---

这个递归函数将一组查询集连接成一个查询集。

def merge_query(ar):
    if len(ar) ==0:
        return [ar]
    while len(ar)>1:
        tmp=ar[0] | ar[1]
        ar[0]=tmp
        ar.pop(1)
        return ar

---