Begrenzung der Verwendung des Speichers in eine Große Django QuerySet

Ich habe eine Aufgabe, die ausgeführt werden muss, auf "die meisten" Objekte in meiner Datenbank einmal alle einige Zeit (einmal am Tag, einmal in der Woche, was auch immer). Im Grunde bedeutet dies, dass ich habe einige Abfragen, die wie folgt aussieht läuft in einem eigenen thread.

for model_instance in SomeModel.objects.all():
    do_something(model_instance)

(Beachten Sie, dass es tatsächlich ein filter() nicht alle (), aber none-the-less ich noch bis Ende der Auswahl eines sehr große set der Objekte).

Das problem das ich laufen in ist, dass nach der Ausführung für eine Weile den thread getötet von meinem hosting-provider, denn ich bin mit zu viel Speicher. Ich bin vorausgesetzt alle diese Speicher verwenden, geschieht, weil, obwohl die QuerySet Objekt zurückgegeben durch meine Abfrage hat zunächst einen sehr kleinen Speicher-footprint landet es wächst, wie die QuerySet Objekt-caches jeder model_instance wie ich Durchlaufen, Sie.

Meine Frage ist, "was ist der beste Weg zu Durchlaufen fast jede SomeModel in meiner Datenbank in einem Speicher effizient zu gestalten?" oder vielleicht ist meine Frage "wie kann ich " un-cache' Modell-Instanzen aus einem django queryset?"

EDIT: ich bin eigentlich mit dem Ergebnis der queryset zu bauen, eine Reihe von neuen Objekten. Als solcher habe ich nicht am Ende der Aktualisierung der abgefragt-für die Objekte überhaupt.

Du wirst einige Hinweise auf das, was du tust mit den queryset. Django hat Regeln, und eine Anzahl von Operationen erfordern das laden des gesamten QuerySet in den Speicher, wo andere Operationen lediglich Prozess die Zeilen ein-at-a-time. docs.djangoproject.com/en/1.2/topics/db/queries/.... Bitte geben Sie einige Hinweise auf, wie du mit Ihr QuerySet-Objekte.
Sorry, ich sollte angeben, dass ich die Informationen aus den QuerySet-Objekte um neue Objekte zu erstellen (eines anderen Typs). Also ich bin eigentlich nie aktualisieren der Objekte bin ich mit dem Abfragen.

InformationsquelleAutor Chris W. | 2011-01-31

Also, was ich eigentlich am Ende machen, ist, etwas zu bauen, dass Sie 'wrap' ein QuerySet in. Es funktioniert, indem Sie ein deepcopy des QuerySet, mit dem slice-syntax--z.B. some_queryset[15:45] - aber dann macht es ein anderer deepcopy des ursprünglichen QuerySet, wenn die Scheibe vollständig Durchlaufen. Dies bedeutet, dass nur die Gruppe von Objekten zurückgegeben, die in 'diesem' bestimmtes Segment im Speicher gespeichert werden.

class MemorySavingQuerysetIterator(object):

    def __init__(self,queryset,max_obj_num=1000):
        self._base_queryset = queryset
        self._generator = self._setup()
        self.max_obj_num = max_obj_num

    def _setup(self):
        for i in xrange(0,self._base_queryset.count(),self.max_obj_num):
            # By making a copy of of the queryset and using that to actually access
            # the objects we ensure that there are only `max_obj_num` objects in
            # memory at any given time
            smaller_queryset = copy.deepcopy(self._base_queryset)[i:i+self.max_obj_num]
            logger.debug('Grabbing next %s objects from DB' % self.max_obj_num)
            for obj in smaller_queryset.iterator():
                yield obj

    def __iter__(self):
        return self

    def next(self):
        return self._generator.next()

Also statt...

for obj in SomeObject.objects.filter(foo='bar'): <-- Something that returns *a lot* of Objects
    do_something(obj);

Würden Sie tun...

for obj in MemorySavingQuerysetIterator(in SomeObject.objects.filter(foo='bar')):
    do_something(obj);

Bitte beachten Sie, dass die Absicht, dies zu speichern Speicher in Ihrem Python-interpreter. Es wird im wesentlichen durch mehr - Datenbank Abfragen. In der Regel Menschen versuchen, tun das genaue Gegenteil, D. H., minimieren Datenbank-Abfragen so weit wie möglich ohne Bezug auf die Speichernutzung. Hoffentlich jemand finden diese nützlich, obwohl.

Dies nutzt LIMIT und OFFSET und wächst so extrem langsam wie offset erhöht...

InformationsquelleAutor Chris W.

12

Was ist mit django core Paginator-und Seiten-Objekte, die hier dokumentiert:

https://docs.djangoproject.com/en/dev/topics/pagination/

Etwas wie dieses:
```
from django.core.paginator import Paginator
from djangoapp.models import SomeModel

paginator = Paginator(SomeModel.objects.all(), 1000) # chunks of 1000

for page_idx in range(1, paginator.num_pages):
    for row in paginator.page(page_idx).object_list:
        # here you can do what you want with the row
    print "done processing page %s" % page_idx
```
- warum ist das nicht die akzeptierte Antwort ? da es sich um eine native django Lösung, und scheint die am wenigsten Aufwand und führt den job
- Aus Neugier, ist das nicht ähnlich iterator() ? docs.djangoproject.com/en/2.1/ref/models/querysets/#iterator In der Tat, Paginator rufen count ersten (len sonst). Nicht Sie machen etwas mehr ineffizient? Warum sollte diese option besser sein, als mit iterator?
- Sollte for page_idx in range(1, paginator.num_pages+1): oder Sie überspringen der letzten Seite
InformationsquelleAutor mpaf
11

Können Sie nicht einfach nutzen-Modell.Objekte.alle().iterator() verwenden, da es zu Holen alle die Elemente, die Sie Tabelle auf einmal. Sie können auch nicht einfach gehen mit dem Modell.Objekte.alle()[offset:offset+pagesize] Weg, denn es wird fangen Sie Ihre Ergebnisse. Alle diese übertreffen Ihre memory limit.

Ich habe versucht, mischen sich beide Lösungen und es funktionierte:
```
offset = 0
pagesize = 1000
count = Model.objects.all().count()
while offset < count:
    for m in Model.objects.all()[offset : offset + pagesize].iterator:
        do_something with m
    offset += pagesize
```
Ändern pagesize passt sich Ihren Anforderungen an, und Optional ändern Sie die [offset : offset + pagesize], um die [offset * pagesize : (offset + 1) * pagesize] idiom, wenn es Ihnen besser passt. Auch, natürlich, ersetzen Sie das Modell von Ihrem tatsächlichen Modell-name.
- Was meinst du mit "catch your results"?
- cache-ich würde davon ausgehen,
InformationsquelleAutor Marcos Dumay
8

Viele Lösungen implementieren Sie die sql OFFSET und LIMIT über schneiden den queryset. Als stefano Noten, mit größerer Datensätze, wird dies sehr ineffizient. Die richtige Art des Umgangs mit diesen ist die Verwendung von server-side-cursers zu verfolgen, die dem OFFSET.

Native server-side cursor-Unterstützung ist in den arbeiten für django. Bis es fertig ist, hier ist eine einfache Umsetzung wenn Sie mit postgres mit dem psycopg2 backend:
```
def server_cursor_query(Table):
    table_name = Table._meta.db_table

    # There must be an existing connection before creating a server-side cursor
    if connection.connection is None:
        dummy_cursor = connection.cursor()  # not a server-side cursor

    # Optionally keep track of the columns so that we can return a QuerySet. However,
    # if your table has foreign keys, you may need to rename them appropriately
    columns = [x.name for x in Table._meta.local_fields]

    cursor = connection.connection.cursor(name='gigantic_cursor')) # a server-side
                                                                   # cursor

    with transaction.atomic():
        cursor.execute('SELECT {} FROM {} WHERE id={}'.format(
            ', '.join(columns), table_name, id))

        while True:
            rows = cursor.fetchmany(1000)

                if not rows:
                    break

                for row in rows:
                    fields = dict(zip(columns, row))
                    yield Table(**fields)
```
Sehen in diesem blog-post für eine tolle Erklärung von Problemen mit dem Arbeitsspeicher von großen Anfragen in django.
- Großes +1 für die Verwendung des richtigen tools für den job. Es wäre toll, zu sehen, Unterstützung für das Django-ORM, in der Tat. By the way, wenn Sie nichts dagegen haben, Stossen Sie ein wenig durch die Interna, die Sie aufrufen können sql, params = queryset.query.get_compiler(using=queryset.db).as_sql() um die SQL-Abfrage von einem queryset. Und Sie sollten die Verwendung von Tabellen.from_db, um Sie in einem tatsächlichen Fall, auf den letzten Django-Versionen.
- sieht sehr nützlich. Allerdings würde ich brauchen, um die Feldnamen in der gleichen Reihenfolge wie die .as_sql() SELECT - Anweisung, um die Tabelle erstellen Beispiel am Ende. Gibt es eine Möglichkeit, das zu tun, ohne Analyse der .as_sql() manuell?
- Nun ja, wenn Sie nichts dagegen haben, den herumstöbern, ich habe diese hier: gist.github.com/spectras/f22d303088e4b2c498de, Wenn Sie es verwenden, würde ich empfehlen, einige tests zu erleichtern Django-upgrades. Unterstützung für select_related() Hinzugefügt werden könnten, wie auch, das wären 3 Zeilen, aber eine zusätzliche Band zu einem anderen ORM internen so...
InformationsquelleAutor drs
3

Ich bin die Fortsetzung der Forschung und es sieht irgendwie aus wie ich will, zu tun, das entspricht einer SQL-OFFSET und LIMIT, die nach Django Doc ' s auf die Begrenzung Querysets bedeutet, ich will mit dem slice-syntax, z.B. SomeModel.objects.all()[15:25]

So, ich denke jetzt ist vielleicht so etwas wie dies ist, was ich Suche:
```
# Figure out the number of objects I can safely hold in memory
# I'll just say 100 for right now
number_of_objects = 100 
count = SomeModel.objects.all().count():
for i in xrange(0,count,number_of_objects):
    smaller_queryset = SomeModel.objects.all()[i:i+number_of_objects]
    for model_instance in smaller_queryset:
        do_something(model_instance)
```
Durch meine Abrechnung dieser würde es so machen, dass smaller_queryset würde nie zu groß.

InformationsquelleAutor Chris W.
3

Gibt es eine django-snippet für diese:

http://djangosnippets.org/snippets/1949/

Es durchläuft ein queryset durch nachgeben Reihen von kleineren "Brocken" von der original-queryset. Es endet mit deutlich weniger Speicher, während so dass Sie die Feineinstellung für die Geschwindigkeit. Ich benutze es in einem meiner Projekte.

InformationsquelleAutor Nick

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.