QuerySets ਕੀ ਹਨ ਅਤੇ ਉਹ ਆਲਸੀ ਕਿਵੇਂ ਹਨ?

Question

Accepted Answer

ਇੱਕ **QuerySet** ਡਾਟਾਬੇਸ ਦੀਆਂ ਕਤਾਰਾਂ ਦਾ ਇੱਕ ਸੰਗ੍ਰਹ ਨੁਮਾਇੰਦਾ ਕਰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਤੁਸੀਂ Python ਆਬਜੈਕਟ ਦੇ ਤੌਰ ਤੇ ਫਿਲਟਰ, ਕ੍ਰਮ ਦਿੰਦੇ ਹੋ, ਅਤੇ ਜੋੜ ਸਕਦੇ ਹੋ। ਇਸ ਦੀ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾ **ਆਲਸੀ-ਪਣ** ਹੈ — ਇੱਕ QuerySet ਬਣਾਉਣ ਸਮੇਂ ਡਾਟਾਬੇਸ ਨੂੰ **ਨਹੀਂ** ਦੱਬਦਾ; ਇਹ ਤਦ ਹੀ ਪ੍ਰਸ਼ਨ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਜਦੋਂ ਡਾਟਾ ਅਸਲ ਵਿੱਚ ਚਾਹੀਦਾ ਹੈ (ਮੁਲਾਂਕਣ)। ਇਹ ਵਿਚਾਰ ਕੁਸ਼ਲ Django ਕੋਡ ਲਿਖਣ ਲਈ ਮੁੱਖ ਹੈ।

## QuerySets ਆਲਸੀ ਹਨ — ਮੁਲਾਂਕਣ ਤੱਕ ਡਾਟਾਬੇਸ ਨੂੰ ਨਹੀਂ ਦੱਬਦੇ

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

## ਆਲਸੀ-ਪਣ ਕਿਉਂ ਤਾਕਤਵਰ ਹੈ

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

ਆਲਸੀ-ਪਣ ਤੁਹਾਨੂੰ ਕੋਈ ਵੀ ਲਾਈਨਾਂ ਵਿੱਚੋਂ ਸ਼ਰਤ ਅਨੁਸਾਰ ਇੱਕ ਪ੍ਰਸ਼ਨ ਬਣਾਉਣ ਦਿੰਦਾ ਹੈ, ਫਿਰ ਇਸ ਨੂੰ **ਇੱਕ ਵਾਰ** ਚਲਾਉ — ਕੁਸ਼ਲ ਅਤੇ ਸਫ਼ਾ।

## 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 ਨੂੰ ਦੁਬਾਰਾ ਦੁਹਰਾਉਣਾ ਦੁਬਾਰਾ ਪ੍ਰਸ਼ਨ ਨਹੀਂ ਕਰਦਾ।

## ਆਲਸੀ-ਪਣ ਦੀ ਬੁਰਾਈ

```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 ਅਤੇ ਉਹਨਾਂ ਦੀ ਆਲਸੀ-ਤਾ ਨੂੰ ਸਮਝਣਾ ਕੁਸ਼ਲ, ਸਹੀ Django ਡਾਟਾਬੇਸ ਕੋਡ ਲਿਖਣ ਲਈ ਅਸਾਧਾਰਨ ਹੈ — ਇਹ ਸਿੱਧੇ ਤ਌ਰ ਤੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ ਅਤੇ ਅਜਿਹੇ ਵਿਵਹਾਰ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ ਜੋ ਨਵਆਂ ਆਉਣ ਵਾਲਿਆਂ ਨੂੰ ਉਲਝਾਉਂਦੇ ਹਨ।

ਮੁੱਖ ਸੂਝ ਇਹ ਹੈ ਕਿ QuerySets **ਮੁਲਾਂਕਣ ਸਮੇਂ ਤੱਕ ਡਾਟਾਬੇਸ ਨੂੰ ਨਹੀਂ ਦੱਬਦੇ**, ਜੋ ਤਾਕਤਵਰ ਹੈ: ਤੁਸੀਂ ਬਣਾ ਸਕਦੇ ਹੋ, ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ, ਜੋੜ ਸਕਦੇ ਹੋ, ਅਤੇ ਸ਼ਰਤ ਲਗਾ ਕੇ ਕੋਡ ਦੀਆਂ ਬਹੁਤ ਸਾਰੀਆਂ ਲਾਈਨਾਂ ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਪ੍ਰਸ਼ਨ ਬਣਾ ਸਕਦੇ ਹੋ ਜ਼ੀਰੋ ਡਾਟਾਬੇਸ ਖਰਚ ਨਾਲ, ਫਿਰ ਸਭ ਕੁਝ **ਇੱਕ ਟ੍ਰਿਪ ਵਿੱਚ** ਚਲਾਉ ਜਦੋਂ ਤੁਹਾਨੂੰ ਅਸਲ ਵਿੱਚ ਨਤੀਜਿਆਂ ਦੀ ਲੋੜ ਹੋਵੇ।

ਇਹ ਸਾਫ, ਕੁਸ਼ਲ ਪ੍ਰਸ਼ਨ ਨਿਰਮਾਣ (ਜਿਵੇਂ ਸ਼ਰਤ ਅਨੁਸਾਰ ਵਰਤੋਂਕਾਰ ਇਨਪੁੱਟ ਦੇ ਅਧਾਰ ਤੇ ਫਿਲਟਰ ਜੋੜਨਾ, ਫਿਰ ਇੱਕ ਪ੍ਰਸ਼ਨ ਚਲਾਉਣਾ) ਨੂੰ ਸਮਰੱਥ ਬਨਾਉਂਦਾ ਹੈ ਜਿਸਨੂੰ ਹੋਰ ਤਰ੍ਹਾਂ SQL ਸਟ੍ਰਿੰਗ-ਬਿਲਡਿੰਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੋਵੇ।

ਸਹੀ-ਸਹੀ ਜਾਨਣਾ **ਕੀ ਮੁਲਾਂਕਣ ਨੂੰ ਟ੍ਰਿਗਰ ਕਰਦਾ ਹੈ** (ਦੁਹਰਾਓ, `len()`, `list()`, `.count()`, `.exists()`, ਆਦਿ) ਅਤੇ ਇਹ ਕਿ ਨਤੀਜੇ ਇੱਕ ਮੁਲਾਂਕਣ ਕੀਤੇ QuerySet ਤੇ **ਕੈਸ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ** ਆਮ ਪ੍ਰਦਰਸ਼ਨ ਖੁੰਦਰੇ ਤੋਂ ਬਚਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ — ਖਾਸ ਕਰਕੇ ਅਣਜਾਣੇ ਵਿੱਚ ਉਸੇ ਪ੍ਰਸ਼ਨ ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਉਣਾ (ਜਿਵੇਂ `.count()` ਨੂੰ ਕਾਲ ਕਰਨਾ ਅਤੇ ਫਿਰ ਇੱਕ ਨਵੇਂ QuerySet ਦੁਵਾਰਾ ਦੁਹਰਾਉਣਾ, ਡਾਟਾਬੇਸ ਨੂੰ ਦੋ ਵਾਰ ਦੱਬਦੇ ਹੋਏ)।

ਆਲਸੀ-ਪਣ Django ORM ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਵਰਤਣ ਲਈ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਸੰਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ, ਉਹਨਾਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਵੱਖ ਕਰਦੇ ਹੋਏ ਜੋ ਕੁਸ਼ਲ ਡਾਟਾਬੇਸ ਕੋਡ ਲਿਖਦੇ ਹਨ ਅਤੇ ਉਹ ਜੋ ਅਣਜਾਣੇ ਵਿੱਚ ਬੇਮਤਲਬ ਪ੍ਰਸ਼ਨਾਂ ਨੂੰ ਟ੍ਰਿਗਰ ਕਰਦੇ ਹਨ, ਇਸ ਨੂੰ ਮੁੱਖ ਗਿਆਨ ਬਨਾਉਂਦੇ ਹੋਏ ਜੋ ਸਾਰੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ORM ਵਰਤੋਂ ਅਤੇ Django ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਨ ਅਨੁਕੂਲ ਕਰਨ ਨੂੰ ਅਧਾਰ ਦਿੰਦਾ ਹੈ।