Çfarë janë QuerySets dhe si janë ata dembel?

Question

Accepted Answer

Një **QuerySet** përfaqëson një koleksion rreshtash të bazës së të dhënave si një objekt Python që mund të filtrohet, renditjet, dhe zinxhirohet. Karakteristika e tij përcaktuese është **dembelësia** — një QuerySet **nuk** godet bazën e të dhënave kur krijohet; ai ekzekuton vetëm pyetjen kur të dhënat janë vërtet të nevojshme (vlerësohen). Të kuptosh këtë është thelbësor për të shkruar kod Django efikas.

## QuerySets janë dembel — nuk bëhet goditja e bazës së të dhënave derisa të vlerësohen

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

Ndërtimi dhe zinxhirimi i një QuerySet nuk kushton asgjë — Django i mblodh SQL-in por shtyron ekzekutimin derisa vërtet të kesh nevojë për rezultatet. Kjo të lejon të përbërësh pyetje komplekse në mënyrë efikase në një udhëtim të vetëm në bazën e të dhënave.

## Çfarë shkakton vlerësimin (një goditje në bazën e të dhënave)

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

## Pse dembelësia është e fuqishme

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

Dembelësia të lejon të përbërësh në mënyrë kushtore një pyetje në shumë rreshta, pastaj ta ekzekutosh atë **një herë** — efikase dhe e pastër.

## Memorja e ruajtjes 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
```

Sa herë që vlerësohet, një QuerySet ruan në memorje rezultatet e tij, kështu që përsëritja e *të njëjtit* QuerySet nuk e bën pyetjen përsëri.

## Kurthja e dembelësisë

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

## Pse ka rëndësi

Të kuptosh QuerySets dhe dembelësinë e tyre është themelor për të shkruar kod Django efikas dhe të saktë në bazën e të dhënave — kjo ndikon drejtpërdrejt në performancë dhe shpjegon sjellje që ngatërrojnë fillestarët.

Ideja kryesore është që QuerySets **nuk e godasin bazën e të dhënave derisa të vlerësohen**, gjë që është e fuqishme: mund të ndërtosh, filtrosh, zinxhirosh, dhe të përbërësh në mënyrë kushtore pyetje komplekse në shumë rreshta kodi pa ndonjë kosto të bazës së të dhënave, pastaj të ekzekutosh gjithçka në një **udhëtim të vetëm** kur vërtet të kesh nevojë për rezultatet.

Kjo mundëson ndërtimin e pyetjeve të pastër dhe efikas (p.sh. shtimin në mënyrë kushtore të filtrave bazuar në hyrjen e përdoruesit, pastaj ekzekutimin e një pyetjeje) që përndryshe do të kërkonte ndërtimin e vargjeve SQL të çuditshme.

Duhet të dish saktësisht **çfarë shkakton vlerësimin** (përsëritje, `len()`, `list()`, `.count()`, `.exists()`, etj.) dhe se rezultatet janë **të ruajtura në memorje** në një QuerySet të vlerësuar është thelbësor për të shmangur kurtha të zakonshme të performancës — më e rëndësishmja është aksidentalisht ekzekutimi i të njëjtës pyetje disa herë (p.sh. thirrja e `.count()` dhe pastaj përsëritja e një QuerySet të freskët, goditja e bazës së të dhënave dy herë).

Dembelësia është një nga konceptet më të rëndësishme për përdorimin e mirë të Django ORM, duke ndarë zhvilluesit që shkruajnë kod efikas në bazën e të dhënave nga ata që padashje shkaktojnë pyetje të panevojshme, duke e bërë atë njohuri qendrore që mbështet të gjithë përdorimin efektiv të ORM dhe optimizimin e performancës në Django.