Što su QuerySets i kako su lijenji?

Question

Accepted Answer

**QuerySet** predstavlja kolekciju redaka baze podataka kao Python objekt koji možete filtrirati, sortirati i povezati. Njegova definirajuća karakteristika je **ljenpost** — QuerySet **ne** pristupa bazi podataka kada se napravi; on izvršava upit samo kada su podaci zapravo potrebni (evaluirani). Razumijevanje ovoga ključno je za pisanje učinkovitog Django koda.

## QuerySets su lijenji — bez pristupa bazi podataka dok se ne evaluiraju

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

Gradnja i povezivanje QuerySeta ne stoji ništa — Django sastavlja SQL ali odgađa izvršavanje dok zapravo ne trebate rezultate. To vam omogućava da učinkovito kompozirate složene upite u jednoj bazi podataka.

## Što okida evaluaciju (pristup bazi podataka)

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

## Zašto je ljenpost moćna

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

Ljenpost vam omogućava da uvjetno kompozirate upit kroz mnogo linija, a zatim ga izvršite **jednom** — učinkovito i čisto.

## Cachiranje QuerySeta

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

Jednom evaluiran, QuerySet cachira svoje rezultate, pa ponovno ponavljanje *istog* QuerySeta ne reexecute upita.

## Zamka ljenposte

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

## Zašto je to važno

Razumijevanje QuerySetsa i njihove ljenposte temeljno je za pisanje učinkovitog i ispravanog Django koda baze podataka — direktno utječe na performanse i objašnjava ponašanja koja zbunjuju početnike.

Ključni uvid je da QuerySeti **ne pristupaju bazi podataka dok se ne evaluiraju**, što je moćno: možete graditi, filtrirati, povezati i uvjetno kompozirate složene upite kroz mnogo linija koda bez troška baze podataka, a zatim sve izvršiti u **jednoj bazi** kada vam zapravo trebaju rezultati.

To omogućava čisto, učinkovito konstruiranje upita (npr. uvjetno dodavanje filtera na temelju korisničkog unosa, a zatim pokretanje jednog upita) što bi inače zahtijevalo neugodno SQL string-building.

Znati točno **što okida evaluaciju** (iteracija, `len()`, `list()`, `.count()`, `.exists()`, itd.) i da su rezultati **cacheirani** na evaluiranom QuerySetu bitno je za izbjegavanje čestih zamki performansi — najznačajnije slučajno pokretanje istog upita više puta (npr. pozivanje `.count()` a zatim iteriranje novog QuerySeta, pristup bazi podataka dva puta).

Ljenpost je jedan od najvažnijih pojmova za dobro korištenje Django ORM-a, odvajajući programere koji pišu učinkovit kod baze podataka od onih koji nesvjesno okidaju redundantne upite, čineći ga temeljnim znanjem koje temelji svu učinkovitu ORM upotrebu i optimizaciju performansi u Django-u.