Django: Paginator + raw-SQL-Abfrage

Bin ich mit Django Paginator überall auf meiner website und schrieb sogar einen speziellen template tag, um zu machen es bequemer. Aber jetzt habe ich zu einem Zustand, wo ich brauche, um eine komplexe custom raw-SQL-Abfrage, die ohne LIMIT zurück über 100K Datensätze.

Wie kann ich mit Django Pagintor mit benutzerdefinierten Abfrage?

Vereinfachtes Beispiel für mein problem:

Mein Modell:

class PersonManager(models.Manager):

    def complicated_list(self):

        from django.db import connection

        #Real query is much more complex        
        cursor.execute("""SELECT * FROM `myapp_person`""");  

        result_list = []

        for row in cursor.fetchall():
            result_list.append(row[0]); 

        return result_list


class Person(models.Model):
    name      = models.CharField(max_length=255);
    surname   = models.CharField(max_length=255);     
    age       = models.IntegerField(); 

    objects   = PersonManager();

Die Art, wie ich pagintation mit Django ORM:

all_objects = Person.objects.all();

paginator = Paginator(all_objects, 10);

try:
    page = int(request.GET.get('page', '1'))
except ValueError:
    page = 1

try:
    persons = paginator.page(page)
except (EmptyPage, InvalidPage):
    persons = paginator.page(paginator.num_pages)

Diese Weise, Django sehr smart und fügt LIMIT zu einer Abfrage bei der Ausführung. Aber wenn ich custom manager:

all_objects = Person.objects.complicated_list();

alle Daten ausgewählt werden, und nur dann python-Liste ist in Scheiben geschnitten, was SEHR langsam ist. Wie kann ich meine custom-manager Verhalten sich ähnlich wie die eingebauten in einem?

In Python, sollten Sie nicht verwenden Leerzeichen, wenn Sie so wollen, in Ihrer Person-Klasse.

InformationsquelleAutor Silver Light | 2010-03-28

9

Blick auf Paginator source-code, Seite () - Funktion in allem denke ich, dass es nur um die Umsetzung schneiden auf Ihrer Seite, und zu übersetzen, die zu den relevanten LIMIT-Klausel in der SQL-Abfrage. Möglicherweise müssen Sie auch hinzufügen, einige Zwischenspeichern, aber diese beginnt zu schauen, wie QuerySet, so können Sie vielleicht etwas anderes tun:
- können Sie erstellen Datenbank-ANSICHT mit CREATE VIEW myview AS [deine Abfrage];
- hinzufügen Django Modell für diese ANSICHT, mit Meta: managed=False
- verwenden Sie dieses Modell, wie jedes andere Modell, einschließlich slicing seine querysets - dies bedeutet, es ist perfekt geeignet für die Verwendung mit Paginator
(Für Ihre Informationen - ich habe mit diesem Konzept für eine lange Zeit jetzt, auch mit komplexen viele-zu-viele-Beziehungen mit Blick auf faking m2m-intermediate-Tabellen.)
- Wow, das ist cool 🙂 Danke für die Antwort, aber ich guiess ich bin auf der Suche in eine falsche Richtung. Ich habe eine weitere Frage gestellt: stackoverflow.com/questions/2532686/... Guiess custom-Manager sind nicht die beste Sache hier.
InformationsquelleAutor Tomasz Zieliński
2

Ich weiß nicht, über Django 1.1 aber wenn Sie warten können für 1.2 (das sollte nicht sein, dass schon lange nicht mehr) Sie können Gebrauch machen von objects.raw() wie beschrieben in dieser Artikel und in der Entwicklung Dokumentation.

Sonst, wenn Sie die Abfrage nicht zu Komplex, vielleicht mit extra - Klausel ist ausreichend.
- Vielen Dank für einen nützlichen Tipp. Aber ich denke, es tut nicht Hilfe in meiner situation
- Sie kann immer noch nicht zählen für ein raw-query-Ergebnissen. Es sieht aus wie Sie eigentlich zu tun haben-Liste(Objekte.raw()) für die Arbeit mit paginator. Dank stackoverflow.com/questions/2317452/django-count-rawqueryset für diese info.
InformationsquelleAutor Felix Kling

Hier ist ein RawPaginator Klasse, ich habe das überschreibt Paginator arbeiten mit raw-Abfragen. Es braucht ein zusätzliches argument, count, die die Gesamtzahl Ihrer Abfrage. Es muss nicht schneiden Sie die object_list da müssen Sie den Umbruch in Ihrem raw-query über OFFSET und LIMIT.

from django.core.paginator import Paginator

class RawPaginator(Paginator):
    def __init__(self, object_list, per_page, count, **kwargs):
        super().__init__(object_list, per_page, **kwargs)
        self.raw_count = count

    def _get_count(self):
        return self.raw_count
    count = property(_get_count)

    def page(self, number):
        number = self.validate_number(number)
        return self._get_page(self.object_list, number, self)

Sehr schöne Lösung. Danke.
Beim Aufruf der neuen Paginator Klasse, was Wert count nehmen, wenn als argument mitgegeben?

InformationsquelleAutor Jonathan Potter

Wollte ich auch Stecker a PaginatedRawQuerySet was ich geschrieben habe (bitte betrachten Sie dies als eine alpha-version). Dieses fügt dem slicing-Fähigkeit, eine raw-queryset. Bitte diese Antwort – das schrieb ich für eine andere Frage mit einer ähnlichen Anforderung – um zu verstehen, wie es funktioniert (vor allem die "Achtung" - Abschnitt am Ende).

from django.db import models
from django.db.models import sql
from django.db.models.query import RawQuerySet


class PaginatedRawQuerySet(RawQuerySet):
    def __init__(self, raw_query, **kwargs):
        super(PaginatedRawQuerySet, self).__init__(raw_query, **kwargs)
        self.original_raw_query = raw_query
        self._result_cache = None

    def __getitem__(self, k):
        """
        Retrieves an item or slice from the set of results.
        """
        if not isinstance(k, (slice, int,)):
            raise TypeError
        assert ((not isinstance(k, slice) and (k >= 0)) or
                (isinstance(k, slice) and (k.start is None or k.start >= 0) and
                 (k.stop is None or k.stop >= 0))), \
            "Negative indexing is not supported."

        if self._result_cache is not None:
            return self._result_cache[k]

        if isinstance(k, slice):
            qs = self._clone()
            if k.start is not None:
                start = int(k.start)
            else:
                start = None
            if k.stop is not None:
                stop = int(k.stop)
            else:
                stop = None
            qs.set_limits(start, stop)
            return qs

        qs = self._clone()
        qs.set_limits(k, k + 1)
        return list(qs)[0]

    def __iter__(self):
        self._fetch_all()
        return iter(self._result_cache)

    def count(self):
        if self._result_cache is not None:
            return len(self._result_cache)

        return self.model.objects.count()

    def set_limits(self, start, stop):
        limit_offset = ''

        new_params = tuple()
        if start is None:
            start = 0
        elif start > 0:
            new_params += (start,)
            limit_offset = ' OFFSET %s'
        if stop is not None:
            new_params = (stop - start,) + new_params
            limit_offset = 'LIMIT %s' + limit_offset

        self.params = self.params + new_params
        self.raw_query = self.original_raw_query + limit_offset
        self.query = sql.RawQuery(sql=self.raw_query, using=self.db, params=self.params)

    def _fetch_all(self):
        if self._result_cache is None:
            self._result_cache = list(super().__iter__())

    def __repr__(self):
        return '<%s: %s>' % (self.__class__.__name__, self.model.__name__)

    def __len__(self):
        self._fetch_all()
        return len(self._result_cache)

    def _clone(self):
        clone = self.__class__(raw_query=self.raw_query, model=self.model, using=self._db, hints=self._hints,
                               query=self.query, params=self.params, translations=self.translations)
        return clone

InformationsquelleAutor TGO

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.