Hvad er QuerySets, og hvordan er de lazy?

Question

Accepted Answer

Et **QuerySet** repræsenterer en samling af databaserækker som et Python-objekt, du kan filtrere, ordne og kæde sammen. Dets definierende karakteristik er **laziness** — et QuerySet rammer **ikke** databasen, når det oprettes; det udfører kun forespørgslen, når dataene faktisk er nødvendige (evalueret). At forstå dette er nøglen til at skrive effektiv Django-kode.

## QuerySets er lazy — ingen databaseforbindelse før evaluering

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

At bygge og kæde et QuerySet koster ingenting — Django samler SQL'en, men udsætter udførelsen, indtil du faktisk har brug for resultaterne. Dette giver dig mulighed for at sammensætte komplekse forespørgsler effektivt i en enkelt databasetur.

## Hvad udløser evaluering (en databaseforbindelse)

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

## Hvorfor laziness er kraftfuldt

```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 giver dig mulighed for betinget at sammensætte en forespørgsel på tværs af mange linjer, og derefter udføre den **én gang** — effektivt og rent.

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

Når det er evalueret, gemmer et QuerySet dets resultater i cache, så genlæsning af det *samme* QuerySet ikke genkøres forespørgslen.

## Laziness-fælden

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

## Hvorfor det betyder noget

At forstå QuerySets og deres laziness er grundlæggende for at skrive effektiv, korrekt Django-databasekode — det påvirker direkte ydeevnen og forklarer adfærd, som forvirrer nybegyndere.

Indsigten er, at QuerySets **ikke rammer databasen før evaluering**, hvilket er kraftfuldt: du kan bygge, filtrere, kæde og betinget sammensætte komplekse forespørgsler på tværs af mange kodlinjer med nul databaseomkostninger, og derefter udføre alt i en **enkelt tur**, når du faktisk har brug for resultaterne.

Dette giver mulighed for rent, effektivt spørgsmålkonstruktion (f.eks. betinget tilføjelse af filtre baseret på brugerinput, og derefter kørsel af én forespørgsel), som ellers ville kræve besværlig SQL-strengbygning.

At vide præcist, **hvad der udløser evaluering** (iteration, `len()`, `list()`, `.count()`, `.exists()` osv.) og at resultater bliver **cachelagret** på et evalueret QuerySet er vigtigt for at undgå almindelige ydelsesfaldgruber — især ved uheld at køre samme forespørgsel flere gange (f.eks. når du kalder `.count()` og derefter itererer et frisk QuerySet, hvilket rammer databasen to gange).

Laziness er et af de vigtigste begreber for at bruge Django ORM godt, hvilket adskiller udviklere, der skriver effektiv databasekode, fra dem, der utilsigtet udløser redundante forespørgsler, hvilket gør det til kerneviden, der understøtter al effektiv ORM-brug og ydelseoptimering i Django.