QuerySets क्या हैं र यो कसरी आलस्य (lazy) हो?

Question

Accepted Answer

एक **QuerySet** डेटाबेस पङ्क्तिहरूको संग्रहको प्रतिनिधित्व गर्छ जसलाई तपाई Python वस्तुको रूपमा फिल्टर, अर्डर, र चेन गर्न सक्नुहुन्छ। यसको मुख्य विशेषता **आलस्य (laziness)** हो — एक QuerySet सृष्टि गरेर डेटाबेस हिट गर्दैन; यो केवल तब क्वेरी कार्यान्वयन गर्छ जब डेटा वास्तवमा आवश्यक हुन्छ (मूल्यांकन गरिन्छ)। यो बुझ्न efficient 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
```

आलस्यले तपाईलाई सर्तमा आधारित क्वेरी कम्पोज गर्न अनुमति दिन्छ धेरै लाइनहरुमा, त्यसपछि यो कार्यान्वयन गर्नुहोस् **एक पटक** — efficient र स्वच्छ।

## 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 र तिनको आलस्य बुझ्न efficient, सही Django डेटाबेस कोड लेख्न मौलिक छ — यो कार्यप्रवाह र व्यवहार सीधै प्रभावित गर्छ जो नए आएकाहरुलाई भ्रमित गर्छ।

मुख्य अन्तर्दृष्टि यो हो कि QuerySets **मूल्यांकन नभएसम्म डेटाबेस हिट गर्दैन**, जो शक्तिशाली छ: तपाई बिना कुनै डेटाबेस खर्च को साथ कोडको धेरै लाइनहरुमा जटिल क्वेरीहरु बनाउन, फिल्टर गर्न, चेन गर्न, र सर्तमा आधारित कम्पोज गर्न सक्नुहुन्छ, त्यसपछी परिणामहरु साँच्चै आवश्यक हुँदा **एकल यात्रा** मा सबै कार्यान्वयन गर्नुहोस्।

यो स्वच्छ, efficient क्वेरी निर्माण सक्षम गर्छ (उदाहरणका लागि, प्रयोगकर्ता इनपुटको आधारमा सर्तमा आधारित फिल्टरहरु थप्न, त्यसपछी एक क्वेरी चलाउन) जो अन्यथा अप्ठ्यारो SQL स्ट्रिङ-निर्माण आवश्यक गर्छ।

सटीक रूपमा जान्दै **कुन मूल्यांकन ट्रिगर गर्छ** (पुनरावृत्ति, `len()`, `list()`, `.count()`, `.exists()`, आदि) र यो **क्यास गरिन्छ** एक मूल्यांकन गरिएको QuerySet मा सामान्य कार्यप्रवाह पतन बचाउन आवश्यक छ — सबैभन्दा उल्लेखनीय रूपमा प्रति दुर्घटनावश एक समान क्वेरी कई पटक चलाउन (उदाहरणका लागि `.count()` को कल गरि त्यसपछि एक तांलो QuerySet पुनरावृत्ति, डेटाबेस दुई पटक हिट गरि)।

आलस्य Django ORM राम्रोसँग प्रयोग गर्न सबैभन्दा महत्वपूर्ण अवधारणा हो, developers लाई अलग गर्दै जो efficient डेटाबेस कोड लेख्छन् ती बाट जसले अनजान रूपमा अप्रयोगी क्वेरीहरु ट्रिगर गर्छन्, यो मुख्य ज्ञान बनाउदै जो सबै प्रभावी ORM प्रयोग र Django मा कार्यप्रवाह अनुकूलन को आधार हो।