Kaj so QuerySet-i in kako so leni?

Question

Accepted Answer

**QuerySet** predstavlja zbirko vrstic iz baze podatkov kot Python objekt, ki ga lahko filtrirate, razvrsti te in povezujete. Njegova glavna lastnost je **lenoba** — QuerySet **ne** doseže baze podatkov, ko je ustvarjen; poizvedbo izvede le takrat, ko so podatki resnično potrebni (evalvirani). Razumevanje tega je ključno za pisanje učinkovite Django kode.

## QuerySet-i so leni — baza podatkov se doseže šele ob evaluaciji

```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 in povezovanje QuerySet-a ne staneta nič — Django sestavi SQL, vendar odloži izvajanje, dokler vam rezultati niso resnično potrebni. To vam omogoči, da učinkovito sestavite zapletene poizvedbe v enem samem obisku baze podatkov.

## Kaj sproži evalvacijo (dostop do baze podatkov)

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

## Zakaj je lenoba 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
```

Lenoba vam omogoči, da pogojno составите poizvedbo čez več vrstic, nato jo izvedete **enkrat** — učinkovito in čisto.

## Predpomnenje QuerySet-a

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

Ko je evalviran, QuerySet predpomni svoje rezultate, zato ponovljiva iteracija *istega* QuerySet-a ne sproži ponovne poizvedbe.

## Pasti lenobe

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

## Zakaj je to pomembno

Razumevanje QuerySet-ov in njihove lenobe je temeljno za pisanje učinkovite in pravilne Django kode baze podatkov — neposredno vpliva na delovanje in pojasnjuje vedenja, ki zbegajo novince.

Osrednja ideja je, da QuerySet-i **ne dosežejo baze podatkov, dokler niso evalvirani**, kar je moćno: lahko gradite, filtrirate, povezujete in pogojno komponurate zapletene poizvedbe čez veliko vrstic kode z ničelnim stroškom baze podatkov, nato pa vse izvedete v **enem samem obisku**, ko resnično potrebujete rezultate.

To omogoči čisto, učinkovito gradnjo poizvedb (npr. pogojno dodajanje filtrov na podlagi vnosa uporabnika, nato pa izvedbo ene poizvedbe), ki bi sicer zahtevala okorno gradnjo stringov SQL.

Znanje natanko **kaj sproži evalvacijo** (iteracija, `len()`, `list()`, `.count()`, `.exists()` itd.) in da se rezultati **predpomnijo** v evaluiranem QuerySet-u je bistveno za izogibanje pogostim pastmi delovanja — zlasti namernom izvajanju iste poizvedbe večkrat (npr. klicanju `.count()` in nato iteraciji novega QuerySet-a, kar doseže bazo podatkov dvakrat).

Lenoba je ena izmed najbolj pomembnih konceptov za dobro uporabo Django ORM, ki loči razvijalce, ki pišejo učinkovito kodo baze podatkov, od tistih, ki nehote sprožijo odvečne poizvedbe, zato je to temeljno znanje, ki je temelj vseega učinkovitega ORM-a in optimizacije delovanja v Django-u.