Wie kombiniere ich mehrere Abfragesätze in Django?

Ich versuche, die Suche für eine von mir erstellte Django-Site zu erstellen, und bei dieser Suche suche ich in drei verschiedenen Modellen. Und um eine Paginierung in der Suchergebnisliste zu erhalten, möchte ich eine generische object_list-Ansicht verwenden, um die Ergebnisse anzuzeigen. Aber dazu muss ich drei Abfragesätze zu einem zusammenführen.

Wie kann ich das machen? Ich habe das versucht:

result_list = []
page_list = Page.objects.filter(
    Q(title__icontains=cleaned_search_term) |
    Q(body__icontains=cleaned_search_term))
article_list = Article.objects.filter(
    Q(title__icontains=cleaned_search_term) |
    Q(body__icontains=cleaned_search_term) |
    Q(tags__icontains=cleaned_search_term))
post_list = Post.objects.filter(
    Q(title__icontains=cleaned_search_term) |
    Q(body__icontains=cleaned_search_term) |
    Q(tags__icontains=cleaned_search_term))

for x in page_list:
    result_list.append(x)
for x in article_list:
    result_list.append(x)
for x in post_list:
    result_list.append(x)

return object_list(
    request,
    queryset=result_list,
    template_object_name="result",
    paginate_by=10,
    extra_context={
        'search_term': search_term},
    template_name="search/result_list.html")

Aber das funktioniert nicht. Ich erhalte eine Fehlermeldung, wenn ich versuche, diese Liste in der generischen Ansicht zu verwenden. In der Liste fehlt das Klonattribut.

Wie kann ich die drei Listen zusammenführen, page_list, article_list Und post_list?

Das Verketten der Abfragesätze zu einer Liste ist der einfachste Ansatz. Wenn die Datenbank sowieso für alle Abfragesätze getroffen wird (zB weil das Ergebnis sortiert werden muss), entstehen dadurch keine weiteren Kosten.

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

Verwenden itertools.chain ist schneller als jede Liste zu durchlaufen und Elemente einzeln anzuhängen, da itertools ist in C implementiert. Es verbraucht auch weniger Speicher als das Konvertieren jedes Abfragesatzes in eine Liste vor dem Verketten.

Jetzt ist es möglich, die resultierende Liste zB nach Datum zu sortieren (wie im Kommentar von hasen j zu einer anderen Antwort gefordert). Der sorted() Funktion akzeptiert bequem einen Generator und gibt eine Liste zurück:

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

Wenn Sie Python 2.4 oder höher verwenden, können Sie verwenden attrgetter statt Lambda. Ich erinnere mich, dass ich darüber gelesen habe, dass es schneller sei, aber ich habe keinen merklichen Geschwindigkeitsunterschied für eine Liste mit einer Million Elementen festgestellt.

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

Versuche dies:

matches = pages | articles | posts

Es behält alle Funktionen der Abfragesätze bei, was nett ist, wenn Sie möchten order_by o.ä.

Bitte beachten Sie: Dies funktioniert nicht bei Abfragesätzen aus zwei verschiedenen Modellen.

Related, zum Mischen von Abfragesätzen aus demselben Modell oder für ähnliche Felder aus einigen Modellen, beginnend mit Django 1.11 A QuerySet.union() Methode ist auch vorhanden:

union()

union(*other_qs, all=False)

Neu in Django 1.11. Verwendet den UNION-Operator von SQL, um die Ergebnisse von zwei oder mehr QuerySets zu kombinieren. Zum Beispiel:

>>> qs1.union(qs2, qs3)

Der UNION-Operator wählt standardmäßig nur eindeutige Werte aus. Um doppelte Werte zuzulassen, verwenden Sie das Argument all=True.

union(), Intersection() und difference() geben Modellinstanzen des Typs des ersten QuerySet zurück, selbst wenn die Argumente QuerySets anderer Modelle sind. Das Übergeben verschiedener Modelle funktioniert, solange die SELECT-Liste in allen QuerySets gleich ist (zumindest die Typen, die Namen spielen keine Rolle, solange die Typen in der gleichen Reihenfolge sind).

Außerdem sind im resultierenden QuerySet nur LIMIT, OFFSET und ORDER BY (dh Slicing und order_by()) zulässig. Weiter, Datenbanken beschränken, welche Operationen in den kombinierten Abfragen zulässig sind. Beispielsweise lassen die meisten Datenbanken LIMIT oder OFFSET in den kombinierten Abfragen nicht zu.

Du kannst den … benutzen QuerySetChain Klasse unten. Wenn es mit dem Paginator von Django verwendet wird, sollte es nur die Datenbank mit treffen COUNT(*) Abfragen für alle Abfragesätze und SELECT() Abfragen nur für die Abfragesätze, deren Datensätze auf der aktuellen Seite angezeigt werden.

Beachten Sie, dass Sie angeben müssen template_name= bei Verwendung von a QuerySetChain mit generischen Ansichten, auch wenn die verketteten Abfragesätze alle dasselbe Modell verwenden.

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

In Ihrem Beispiel wäre die Verwendung:

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)

Dann benutze matches mit dem paginator wie du es benutzt hast result_list in deinem beispiel.

Der itertools -Modul wurde in Python 2.3 eingeführt, daher sollte es in allen Python-Versionen verfügbar sein, auf denen Django läuft.

Falls Sie viele Abfragesätze verketten möchten, versuchen Sie Folgendes:

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

wobei: docs eine Liste von Abfragesätzen ist

Der große Nachteil Ihres derzeitigen Ansatzes ist seine Ineffizienz bei großen Suchergebnisseiten, da Sie jedes Mal die gesamte Ergebnismenge aus der Datenbank abrufen müssen, obwohl Sie nur eine Ergebnisseite anzeigen möchten.

Um nur die tatsächlich benötigten Objekte aus der Datenbank herunterzuziehen, müssen Sie die Paginierung für ein QuerySet verwenden, nicht für eine Liste. Wenn Sie dies tun, schneidet Django das QuerySet tatsächlich, bevor die Abfrage ausgeführt wird, sodass die SQL-Abfrage OFFSET und LIMIT verwendet, um nur die Datensätze abzurufen, die Sie tatsächlich anzeigen. Aber Sie können dies nicht tun, es sei denn, Sie können Ihre Suche irgendwie in eine einzige Abfrage packen.

Angesichts der Tatsache, dass alle drei Ihrer Modelle Titel- und Textfelder haben, warum nicht verwenden Modell Erbe? Lassen Sie einfach alle drei Modelle von einem gemeinsamen Vorfahren erben, der Titel und Text hat, und führen Sie die Suche als einzelne Abfrage für das Vorfahrenmodell durch.

Dies kann entweder auf zwei Wegen erreicht werden.

1. Weg, dies zu tun

Verwenden Sie den Union-Operator für den Abfragesatz | um die Vereinigung zweier Abfragesätze zu nehmen. Wenn beide Abfragesätze zum selben Modell / Einzelmodell gehören, ist es möglich, Abfragesätze mit dem Union-Operator zu kombinieren.

Für ein Beispiel

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

2. Weg, dies zu tun

Eine andere Möglichkeit, eine Kombinationsoperation zwischen zwei Abfragesätzen zu erreichen, ist die Verwendung itertools Kettenfunktion.

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