Apa iku QuerySet lan kepriye sifat malas-malasan (lazy)?

Question

Accepted Answer

Sebuah **QuerySet** mewakili koleksi baris basis data minangka objek Python sing bisa difilter, diurutake, lan disambung. Karakteristik utamane yaiku **kemalasan** — QuerySet ora **tekan** basis data nalika digawe; iku mung nglakoni query nalika data pancene butuh (dievaluasi). Ngerti iki kunci kanggo nulis kode Django sing efisien.

## QuerySet malas-malasan — ora tekan basis data nganti dievaluasi

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

Bangun lan sambung QuerySet ora ana biaya — Django nglumpukake SQL nanging nggawat eksekusi nganti sampeyan pancene butuh asile. Iki ngidini sampeyan gawe query kompleks kanthi efisien ing siji perjalanan basis data.

## Apa sing ngetrigger evaluasi (tekan basis data)

```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 kemalasan kuwi kuat

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

Kemalasan ngidini sampeyan nggawe query kanthi kondisional ing luwih akeh baris, banjur nglakoni **sak siji** — efisien lan bersih.

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

Sawise dievaluasi, QuerySet cache asile, dadi iterasi ulang QuerySet **sama** ora bakal nanya maneh.

## Pitfall kemalasan

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

Ngerti QuerySet lan kemalasan-e yaiku dhasar kanggo nulis kode basis data Django sing efisien lan bener — iku langsung bangaruhi performance lan nerangake tingkah laku sing ngindhet para pendatang.

Insight utama yaiku QuerySet **ora tekan basis data nganti dievaluasi**, iki kuat: sampeyan bisa bangun, filter, sambung, lan nggawe query kompleks kanthi kondisional ing luwih akeh baris kode kanthi zero biaya basis data, banjur nglakoni kabeh-e **ing siji perjalanan** nalika sampeyan pancene butuh asile.

Iki ngidini konstruksi query bersih lan efisien (contone nambah filter kanthi kondisional adhedhasar input pangguna, banjur nglakoni siji query) sing biya-biya butuh bangun SQL string sing canggung.

Ngerti bener **apa sing ngetrigger evaluasi** (iterasi, `len()`, `list()`, `.count()`, `.exists()`, lsp.) lan asile **dicache** ing QuerySet sing dievaluasi yaiku penting kanggo nyegah pitfall performa sing umum — paling nang ngulangi query sing sama berkali-kali (contone takon `.count()` banjur iterasi QuerySet anyar, tekan basis data nang loro).

Kemalasan yaiku salah sawijining konsep paling penting kanggo nggunakake Django ORM kanthi bagus, mbedakake developer sing nulis kode basis data efisien saka sing tanpa kuwatir ngetrigger query sing redundan, dadi pengetahuan inti sing ndasari kabeh panggunaan ORM efektif lan optimasi performance ing Django.