რა არის QuerySets და როგორ არის ისინი lazy?

Question

Accepted Answer

**QuerySet** წარმოადგენს მონაცემთა ბაზის სტრიქონების კრებულს Python ობიექტის სახით, რომელიც შეგიძლიათ ფილტრირება, დალაგება და ჯაჭვი. მისი განმსაზღვრელი მახასიათებელი არის **laziness** — QuerySet **არ** ეწვევა მონაცემთა ბაზას შექმნისას; ის ზეწოდ აკეთებს ოპერაციას მხოლოდ მაშინ, როდესაც მონაცემები სინამდვილეში საჭიროა (შეფასებული). ამის გაგება გადამწყვეტია Django-ის ეფექტური კოდის ჩასაწერად.

## QuerySets არის lazy — მონაცემთა ბაზის გამოძახება არ ხდება სანამ არ შეფასდება

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

QuerySet-ის აგება და ჯაჭვი არაფერი უჯდება — Django აკეთებს SQL-ს, მაგრამ შესრულება გადავადებულია მანამ, სანამ თქვენ რეალურად შედეგებს გჭირდებათ. ეს საშუალებას გაძლევთ კომპლექსური ამოცანები ეფექტურად შეადგინოთ ერთი მონაცემთა ბაზის წვდომით.

## რა იწვევს შეფასებას (მონაცემთა ბაზის გამოძახება)

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

## რატომ არის laziness ძლიერი

```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 საშუალებას გაძლევთ პირობითად შეადგინოთ ამოცანა მრავალი ხაზის დასაწყისიდან, შემდეგ აკეთებთ **ერთხელ** — ეფექტური და სუფთა.

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

შეფასების შემდეგ, QuerySet ინახავს მის შედეგებს, ამიტომ იმავე QuerySet-ის ხელახლა გამეორება თავიდან არ ჰკითხავს.

## laziness-ის პაიფალი

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

## რატომ მნიშვნელოვანია

QuerySets-ისა და მათი laziness-ის გაგება ფუნდამენტალურია Django-ის მონაცემთა ბაზის ეფექტური, სწორი კოდის ჩასაწერად — ის პირდაპირ გავლენას ახდენს წარმადობაზე და ხსნის ქცევებს, რომლებიც დამწყებებს აბნევთ.

მთავარი შეხედულება არის, რომ QuerySets **არ უკითხავთ მონაცემთა ბაზას სანამ შეფასდებიან**, რაც ძლიერია: შეგიძლიათ აშენება, ფილტრირება, ჯაჭვი და პირობით შედგენა კომპლექსური ამოცანები კოდის მრავალი ხაზის გასწვრივ ნულოვანი მონაცემთა ბაზის ღირებულებით, შემდეგ ყველაფერი აკეთებთ **ერთი წვდომით** როდესაც თქვენ რეალურად გჭირდებათ შედეგები.

ეს ხელმიერი, ეფექტური ამოცანის აგების საშუალებას ხსნის (მაგ. პირობითად ფილტრების დამატება მომხმარებლის შეყვანის საფუძველზე, შემდეგ ერთი ამოცანის ჩატარება), რომელიც სხვასთან შედარებით მოითხოვდა უხერხო SQL სტრიქონ-აგების პროცესს.

ზუსტად ცოდნა **რა იწვევს შეფასებას** (გამეორება, `len()`, `list()`, `.count()`, `.exists()`, და ა.შ.) და რომ შედეგები **ინახება** შეფასებულ QuerySet-ზე აუცილებელია ჩვეულებრივი წარმადობის პაიფალების თავიდან აცილებისთვის — ყველაზე აღსანიშნავი ატმის შემთხვევা, სადაც იმავე ამოცანა მრავალჯერ გაიქცა (მაგ. `.count()`-ის გამოძახება და შემდეგ ახალი QuerySet-ის გამეორება, მონაცემთა ბაზას ორჯერ რჩეული).

Laziness არის Django ORM-ის კარგად გამოყენების ერთ-ერთი ყველაზე მნიშვნელოვანი კონცეფცია, რომელიც გამოყოფს დეველოპერებს, რომლებიც ეფექტური მონაცემთა ბაზის კოდს წერენ, მათ, რომლებიც უცოდელოდ აღვივებენ ზედმეტი ამოცანებს, რაც ის ხდის ძირეული ცოდნას, რომელიც ფუძემდებარია ყველა ეფექტური ORM გამოყენებისა და Django-ში წარმადობის ოპტიმიზაციის.