¿Por qué iterar a través de un gran QuerySet de Django consume grandes cantidades de memoria?

Podría no ser el más rápido o el más eficiente, pero como una solución lista para usar, ¿por qué no usar los objetos Paginator y Page de django core documentados aquí:

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

Algo como esto:

from django.core.paginator import Paginator
from djangoapp.models import model

paginator = Paginator(model.objects.all(), 1000) # chunks of 1000, you can 
                                                 # change this to desired chunk size

for page in range(1, paginator.num_pages + 1):
    for row in paginator.page(page).object_list:
        # here you can do whatever you want with the row
    print "done processing page %s" % page

El comportamiento predeterminado de Django es almacenar en caché el resultado completo del conjunto de consultas cuando evalúa la consulta. Puedes usar el método iterador de QuerySet para evitar este almacenamiento en caché:

for event in Event.objects.all().iterator():
    print event

Https://docs.djangoproject.com/en/dev/ref/models/querysets/#iterator

El método iterator() evalúa el queryset y luego lee los resultados directamente sin hacer caché a nivel de QuerySet. Este método se traduce en un mejor rendimiento y una reducción significativa en la memoria cuando iterar sobre un gran número de objetos a los que solo necesita acceder una vez. Tenga en cuenta que el almacenamiento en caché todavía se realiza a nivel de base de datos.

Usar iterator() reduce el uso de memoria para mí, pero sigue siendo más alto de lo que esperaba. Usando el enfoque de paginador sugerido por mpaf usa mucha menos memoria, pero es 2-3x más lento para mi caso de prueba.

from django.core.paginator import Paginator

def chunked_iterator(queryset, chunk_size=10000):
    paginator = Paginator(queryset, chunk_size)
    for page in range(1, paginator.num_pages + 1):
        for obj in paginator.page(page).object_list:
            yield obj

for event in chunked_iterator(Event.objects.all()):
    print event

Esto es de los documentos: http://docs.djangoproject.com/en/dev/ref/models/querysets /

No se produce ninguna actividad de base de datos hasta que se hace algo para evaluar el queryset.

Así que cuando se ejecuta el print event se activa la consulta (que es un análisis completo de la tabla de acuerdo con su comando.) y carga los resultados. Su pregunta por todos los objetos y no hay manera de obtener el primer objeto sin obtener todos ellos.

Pero si haces algo como:

Event.objects.all()[300:900]

Http://docs.djangoproject.com/en/dev/topics/db/queries/#limiting-querysets

Luego agregará compensaciones y límites al sql internamente.

Para grandes cantidades de registros, un cursor de base de datos funciona aún mejor. Necesitas SQL raw en Django, el Django-cursor es algo diferente a un cursur SQL.

El método de COMPENSACIÓN de LÍMITE sugerido por Nate C podría ser lo suficientemente bueno para su situación. Para grandes cantidades de datos es más lento que un cursor porque tiene que ejecutar la misma consulta una y otra vez y tiene que saltar más y más resultados.

Django no tiene una buena solución para obtener elementos grandes de la base de datos.

import gc
# Get the events in reverse order
eids = Event.objects.order_by("-id").values_list("id", flat=True)

for index, eid in enumerate(eids):
    event = Event.object.get(id=eid)
    # do necessary work with event
    if index % 100 == 0:
       gc.collect()
       print("completed 100 items")

Values_list se puede usar para obtener todos los ID de las bases de datos y luego obtener cada objeto por separado. Durante un tiempo se crearán objetos grandes en la memoria y no se recogerán basura hasta que se salga el bucle. El código anterior hace la recolección manual de basura después de que cada artículo 100 se consume.

Porque de esa manera los objetos de un conjunto de consultas completo se cargan en la memoria todos a la vez. Necesitas dividir tu queryset en trozos más pequeños digeribles. El patrón para hacer esto se llama spoonfeeding. Aquí hay una breve implementación.

def spoonfeed(qs, func, chunk=1000, start=0):
    ''' Chunk up a large queryset and run func on each item.

    Works with automatic primary key fields.

    chunk -- how many objects to take on at once
    start -- PK to start from

    >>> spoonfeed(Spam.objects.all(), nom_nom)
    '''
    while start < qs.order_by('pk').last().pk:
        for o in qs.filter(pk__gt=start, pk__lte=start+chunk):
            yeild func(o)
        start += chunk

Para usar esto, escriba una función que realice operaciones en su objeto:

def set_population_density(town):
    town.population_density = calculate_population_density(...)
    town.save()

Y luego ejecute esa función en su queryset:

spoonfeed(Town.objects.all(), set_population_density)

Esto se puede mejorar aún más con multiprocesamiento para ejecutar func en múltiples objetos en paralelo.

Aquí una solución que incluye len y count:

class GeneratorWithLen(object):
    """
    Generator that includes len and count for given queryset
    """
    def __init__(self, generator, length):
        self.generator = generator
        self.length = length

    def __len__(self):
        return self.length

    def __iter__(self):
        return self.generator

    def __getitem__(self, item):
        return self.generator.__getitem__(item)

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

    def count(self):
        return self.__len__()

def batch(queryset, batch_size=1024):
    """
    returns a generator that does not cache results on the QuerySet
    Aimed to use with expected HUGE/ENORMOUS data sets, no caching, no memory used more than batch_size

    :param batch_size: Size for the maximum chunk of data in memory
    :return: generator
    """
    total = queryset.count()

    def batch_qs(_qs, _batch_size=batch_size):
        """
        Returns a (start, end, total, queryset) tuple for each batch in the given
        queryset.
        """
        for start in range(0, total, _batch_size):
            end = min(start + _batch_size, total)
            yield (start, end, total, _qs[start:end])

    def generate_items():
        queryset.order_by()  # Clearing... ordering by id if PK autoincremental
        for start, end, total, qs in batch_qs(queryset):
            for item in qs:
                yield item

    return GeneratorWithLen(generate_items(), total)

Uso:

events = batch(Event.objects.all())
len(events) == events.count()
for event in events:
    # Do something with the Event

Normalmente uso raw MySQL raw query en lugar de Django Dj para este tipo de tareas.

MySQL admite el modo de transmisión para que podamos recorrer todos los registros de forma segura y rápida sin errores de memoria.

import MySQLdb
db_config = {}  # config your db here
connection = MySQLdb.connect(
        host=db_config['HOST'], user=db_config['USER'],
        port=int(db_config['PORT']), passwd=db_config['PASSWORD'], db=db_config['NAME'])
cursor = MySQLdb.cursors.SSCursor(connection)  # SSCursor for streaming mode
cursor.execute("SELECT * FROM event")
while True:
    record = cursor.fetchone()
    if record is None:
        break
    # Do something with record here

cursor.close()
connection.close()

Ref:

1. Recuperando millones de filas de MySQL
2. ¿Cómo funciona la transmisión de conjunto de resultados MySQL frente a la obtención de todo el conjunto de resultados JDBC a la vez