Co jsou QuerySety a jak jsou líné?

Question

Accepted Answer

**QuerySet** představuje kolekci řádků z databáze jako objekt v Pythonu, který můžete filtrovat, řadit a řetězit. Jeho charakteristickou vlastností je **lenost** — QuerySet **nespustí** databázi při vytvoření; dotaz se provede pouze v okamžiku, kdy jsou data skutečně potřebná (vyhodnocena). Pochopení tohoto principu je klíčové pro psaní efektivního kódu v Django.

## QuerySety jsou líné — bez přístupu k databázi, dokud nejsou vyhodnoceny

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

Sestrojení a řetězení QuerySetu není náročné — Django připraví SQL, ale odloží spuštění, dokud skutečně nepotřebujete výsledky. To vám umožňuje efektivně skládat složité dotazy v jednom přístupu k databázi.

## Co spustí vyhodnocení (přístup k databázi)

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

## Proč je lenost mocná

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

Lenost vám umožňuje podmíněně skládat dotaz přes mnoho řádků a poté ho spustit **jednou** — efektivně a čistě.

## Cachování QuerySetu

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

Jednou vyhodnocený QuerySet cachuje své výsledky, takže opětovná iterace *stejného* QuerySetu nezpůsobí nový dotaz.

## Léčka lnosti

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

## Proč to důležité

Pochopení QuerySetů a jejich lnosti je fundamentální pro psaní efektivního a správného kódu pro práci s databází v Django — přímo ovlivňuje výkon a vysvětluje chování, které matou začátečníky.

Klíčové poznání je, že QuerySety **nespustí databázi, dokud nejsou vyhodnoceny**, což je mocné: můžete stavět, filtrovat, řetězit a podmíněně skládat složité dotazy přes mnoho řádků kódu bez jakéhokoliv přístupu k databázi a poté spustit vše v **jednom přístupu**, když skutečně potřebujete výsledky.

To umožňuje čistou a efektivní tvorbu dotazů (např. podmíněné přidávání filtrů na základě vstupu uživatele a spuštění jednoho dotazu), která by jinak vyžadovala nepříjemné skládání SQL řetězců.

Přesné znalosti o **tom, co spustí vyhodnocení** (iterace, `len()`, `list()`, `.count()`, `.exists()` atd.) a to, že výsledky jsou **cachovány** na vyhodnoceném QuerySetu, je zásadní pro vyhnutí se běžným problémům s výkonem — nejpozoruhodněji náhodné spouštění stejného dotazu vícekrát (např. volání `.count()` a následná iterace nového QuerySetu, což spustí databázi dvakrát).

Lenost je jedním z nejdůležitějších konceptů pro dobré používání Django ORM, rozlišuje vývojáře, kteří píší efektivní kód pro databázi, od těch, kteří si nevědomě spouští redundantní dotazy, což z ní činí základní znalost podmiňující veškeré efektivní používání ORM a optimalizaci výkonu v Django.