Apakah QuerySet dan bagaimana ia bersifat malas (lazy)?

Question

Accepted Answer

Sebuah **QuerySet** mewakili koleksi baris pangkalan data sebagai objek Python yang boleh anda tapis, susun, dan rantaikan. Ciri yang menentukannya ialah **kemalasan (laziness)** — sebuah QuerySet **tidak** mengakses pangkalan data semasa dicipta; ia hanya melaksanakan pertanyaan apabila data benar-benar diperlukan (dinilai). Memahami ini adalah kunci untuk menulis kod Django yang cekap.

## QuerySet bersifat malas — tiada akses pangkalan data sehingga dinilai

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

Membina dan merantai sebuah QuerySet tidak menelan apa-apa kos — Django menyusun SQL tetapi menangguhkan pelaksanaan sehingga anda benar-benar memerlukan hasilnya. Ini membolehkan anda mengarang pertanyaan kompleks dengan cekap dalam satu perjalanan ke pangkalan data.

## Apa yang mencetuskan penilaian (akses pangkalan 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 berkuasa

```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 membolehkan anda mengarang pertanyaan secara bersyarat merentasi banyak baris kod, kemudian melaksanakannya **sekali** — cekap dan kemas.

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

Setelah dinilai, sebuah QuerySet menyimpan cache hasilnya, jadi mengulang iterasi QuerySet *yang sama* tidak membuat pertanyaan semula.

## Lubang perangkap 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 ia penting

Memahami QuerySet dan kemalasannya adalah asas untuk menulis kod pangkalan data Django yang cekap dan betul — ia secara langsung mempengaruhi prestasi dan menjelaskan tingkah laku yang mengelirukan pendatang baru.

Wawasan utamanya ialah QuerySet **tidak mengakses pangkalan data sehingga dinilai**, yang amat berkuasa: anda boleh membina, menapis, merantai, dan mengarang pertanyaan kompleks secara bersyarat merentasi banyak baris kod tanpa sebarang kos pangkalan data, kemudian melaksanakan semuanya dalam **satu perjalanan** apabila anda benar-benar memerlukan hasilnya.

Ini membolehkan pembinaan pertanyaan yang bersih dan cekap (cth. menambah penapis secara bersyarat berdasarkan input pengguna, kemudian menjalankan satu pertanyaan) yang sebaliknya memerlukan pembinaan rentetan SQL yang janggal.

Mengetahui dengan tepat **apa yang mencetuskan penilaian** (iterasi, `len()`, `list()`, `.count()`, `.exists()`, dll.) dan bahawa hasil **disimpan dalam cache** pada QuerySet yang telah dinilai adalah penting untuk mengelakkan lubang perangkap prestasi yang biasa — terutamanya secara tidak sengaja menjalankan pertanyaan yang sama beberapa kali (cth. memanggil `.count()` dan kemudian mengulang iterasi QuerySet baharu, mengakses pangkalan data dua kali).

Kemalasan ialah salah satu konsep paling penting untuk menggunakan Django ORM dengan baik, memisahkan pembangun yang menulis kod pangkalan data yang cekap daripada mereka yang tanpa sedar mencetuskan pertanyaan berlebihan, menjadikannya pengetahuan teras yang menyokong semua penggunaan ORM yang berkesan dan pengoptimuman prestasi dalam Django.