Apa itu QuerySet dan bagaimana mereka bersifat lazy?

Question

Accepted Answer

Sebuah **QuerySet** merepresentasikan koleksi baris database sebagai objek Python yang dapat Anda filter, urutkan, dan chain. Karakteristik utamanya adalah **laziness** — sebuah QuerySet **tidak** mengenai database saat dibuat; QuerySet hanya mengeksekusi query saat data benar-benar dibutuhkan (dievaluasi). Memahami ini adalah kunci untuk menulis kode Django yang efisien.

## Mengapa ini penting

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

Membangun dan melakukan chaining pada QuerySet tidak memerlukan biaya apa pun — Django menyusun SQL tetapi menunda eksekusi hingga Anda benar-benar membutuhkan hasilnya. Ini memungkinkan Anda menyusun query kompleks secara efisien dalam satu perjalanan database.

## Apa yang memicu evaluasi (database hit)

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

## Mengapa laziness itu powerful

```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 memungkinkan Anda menyusun query secara kondisional di banyak baris, lalu mengeksekusinya **sekali** — efisien dan bersih.

## QuerySet caching

```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
```

Setelah dievaluasi, QuerySet mem-cache hasilnya, jadi mengiterasi ulang QuerySet yang *sama* tidak akan menjalankan query lagi.

## Jebakan 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: ...
```

## Mengapa ini penting

Memahami QuerySet dan laziness mereka adalah fundamental untuk menulis kode database Django yang efisien dan benar — hal ini langsung mempengaruhi performa dan menjelaskan perilaku yang membingungkan pemula.

Insight utamanya adalah bahwa QuerySet **tidak mengenai database sampai dievaluasi**, yang powerful: Anda dapat membangun, filter, chain, dan secara kondisional menyusun query kompleks di banyak baris kode tanpa biaya database sama sekali, lalu mengeksekusi semuanya dalam **satu perjalanan** saat Anda benar-benar membutuhkan hasilnya.

Ini memungkinkan konstruksi query yang bersih dan efisien (misalnya kondisional menambah filter berdasarkan input pengguna, lalu menjalankan satu query) yang sebaliknya memerlukan pembuatan string SQL yang canggung.

Mengetahui dengan tepat **apa yang memicu evaluasi** (iterasi, `len()`, `list()`, `.count()`, `.exists()`, dll.) dan bahwa hasil adalah **di-cache** pada QuerySet yang dievaluasi sangat penting untuk menghindari jebakan performa umum — terutama secara tidak sengaja menjalankan query yang sama beberapa kali (misalnya memanggil `.count()` lalu mengiterasi QuerySet baru, mengenai database dua kali).

Laziness adalah salah satu konsep paling penting untuk menggunakan Django ORM dengan baik, membedakan developer yang menulis kode database efisien dari mereka yang tanpa disadari memicu query redundan, menjadikannya pengetahuan inti yang mendasari semua penggunaan ORM yang efektif dan optimasi performa di Django.