O que são QuerySets e como são lazy?

Question

Accepted Answer

Um **QuerySet** representa uma coleção de linhas do banco de dados como um objeto Python que você pode filtrar, ordenar e encadear. Sua característica definidora é **laziness** — um QuerySet **não** acessa o banco de dados quando criado; ele só executa a consulta quando os dados são realmente necessários (avaliados). Entender isso é fundamental para escrever código Django eficiente.

## Por que isso importa

```python
# NONE of these touch the database — they just build up the query
qs = Article.objects.all()                  # no query yet
qs = qs.filter(published=True)              # still no query — chaining is lazy
qs = qs.exclude(views=0).order_by("-created_at")   # still no query

# the database is hit ONLY when the QuerySet is EVALUATED:
for article in qs:        # ← NOW the query runs
    print(article.title)
```

Construir e encadear um QuerySet não custa nada — Django monta o SQL mas adia a execução até que você realmente precise dos resultados. Isso permite que você componha consultas complexas de forma eficiente em uma única viagem ao banco de dados.

## O que dispara a avaliação (uma consulta ao banco de dados)

```text
✓ Iterating:        for x in qs
✓ Slicing with step: qs[::2]  (plain slicing qs[:10] stays lazy, adds LIMIT)
✓ len(qs), list(qs), bool(qs)
✓ Calling a non-QuerySet method: .count(), .exists(), .first(), .get(), .aggregate()
```

## Por que laziness é poderosa

```python
# build a query conditionally WITHOUT extra database trips
qs = Article.objects.all()
if search:
    qs = qs.filter(title__icontains=search)   # no DB hit
if category:
    qs = qs.filter(category=category)          # no DB hit
articles = qs[:20]                              # ONE query runs here, with LIMIT 20
```

Laziness permite que você componha condicionalmente uma consulta em muitas linhas, depois execute-a **uma vez** — eficiente e limpo.

## Cache de QuerySet

```python
qs = Article.objects.filter(published=True)
list(qs)     # query runs, results CACHED on the QuerySet
list(qs)     # uses the CACHE — no second query
# BUT a NEW queryset re-queries:
Article.objects.filter(published=True)   # a fresh queryset → new query
```

Uma vez avaliado, um QuerySet armazena em cache seus resultados, então reiterar o *mesmo* QuerySet não re-consulta.

## A armadilha da laziness

```python
# ⚠️ calling .count() then iterating runs TWO queries
if Article.objects.filter(published=True).count() > 0:   # query 1
    for a in Article.objects.filter(published=True):     # query 2 (new queryset!)
        ...
# ✅ better — evaluate once, reuse
qs = list(Article.objects.filter(published=True))
if qs: ...
```

## Por que isso importa

Entender QuerySets e sua laziness é fundamental para escrever código de banco de dados Django eficiente e correto — afeta diretamente o desempenho e explica comportamentos que confundem iniciantes.

O insight principal é que QuerySets **não acessam o banco de dados até serem avaliados**, o que é poderoso: você pode construir, filtrar, encadear e condicionalmente compor consultas complexas em muitas linhas de código sem custo algum de banco de dados, depois executar tudo em uma **única viagem** quando você realmente precisar dos resultados.

Isso permite construção de consultas limpa e eficiente (por exemplo, adicionando condicionalmente filtros baseado em entrada do usuário, depois executando uma consulta) que de outra forma exigiria montagem incômoda de strings SQL.

Saber precisamente **o que dispara a avaliação** (iteração, `len()`, `list()`, `.count()`, `.exists()`, etc.) e que resultados são **armazenados em cache** em um QuerySet avaliado é essencial para evitar armadilhas comuns de desempenho — mais notavelmente executar acidentalmente a mesma consulta várias vezes (por exemplo, chamando `.count()` e depois iterando um QuerySet novo, acessando o banco de dados duas vezes).

Laziness é um dos conceitos mais importantes para usar bem o Django ORM, separando desenvolvedores que escrevem código de banco de dados eficiente daqueles que inadvertidamente disparam consultas redundantes, tornando-a um conhecimento essencial que fundamenta todo o uso eficaz do ORM e otimização de desempenho em Django.