QuerySets คืออะไรและทำไมจึงเป็น lazy?

Question

Accepted Answer

**QuerySet** แทนชุดของแถวใน database ในรูปของ Python object ที่คุณสามารถ filter, จัดเรียง และเชื่อมต่อกันได้ ลักษณะเด่นของมันคือ **ความ lazy** — QuerySet จะ**ไม่**เข้าถึง database เมื่อถูกสร้าง มันจะรัน query เมื่อข้อมูลถูกต้องการจริง ๆ (ถูก evaluate) การเข้าใจสิ่งนี้เป็นกุญแจสำคัญในการเขียนโค้ด Django ที่มีประสิทธิภาพ

## QuerySets เป็น lazy — ไม่เข้าถึง database จนกว่าจะถูก evaluate

```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 แต่เลื่อนการรันออกไปจนกว่าคุณต้องการผลลัพธ์จริง ๆ สิ่งนี้ช่วยให้คุณประกอบ query ที่ซับซ้อนได้อย่างมีประสิทธิภาพในการเข้าถึง database ครั้งเดียว

## อะไรที่ทำให้เกิดการ evaluate (การเข้าถึง database)

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

## ทำไมความ lazy จึงทรงพลัง

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

ความ lazy ช่วยให้คุณประกอบ query แบบมีเงื่อนไขข้ามหลายบรรทัด แล้วรันมัน**ครั้งเดียว** — มีประสิทธิภาพและสะอาด

## QuerySet caching

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

เมื่อถูก evaluate แล้ว QuerySet จะ cache ผลลัพธ์ของมัน ดังนั้นการ iterate QuerySet *ตัวเดิม* ซ้ำจะไม่ query ใหม่

## ข้อพลาดของความ lazy

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

## ทำไมจึงสำคัญ

การเข้าใจ QuerySet และความ lazy ของมันเป็นพื้นฐานในการเขียนโค้ด database ของ Django ที่มีประสิทธิภาพและถูกต้อง — มันส่งผลโดยตรงต่อประสิทธิภาพและอธิบายพฤติกรรมที่ทำให้มือใหม่สับสน

ข้อมูลเชิงลึกสำคัญคือ QuerySet **ไม่เข้าถึง database จนกว่าจะถูก evaluate** ซึ่งทรงพลัง: คุณสามารถสร้าง, filter, เชื่อมต่อ และประกอบ query ที่ซับซ้อนแบบมีเงื่อนไขข้ามโค้ดหลายบรรทัดได้โดยไม่มีค่าใช้จ่ายต่อ database แล้วรันทุกอย่างใน**การเข้าถึงครั้งเดียว**เมื่อคุณต้องการผลลัพธ์จริง ๆ

สิ่งนี้ช่วยให้สร้าง query ได้อย่างสะอาดและมีประสิทธิภาพ (เช่น เพิ่ม filter แบบมีเงื่อนไขตาม input ของผู้ใช้ แล้วรัน query เดียว) ซึ่งไม่อย่างนั้นจะต้องสร้าง SQL string อย่างเก้กัง

การรู้อย่างแม่นยำว่า**อะไรที่ทำให้เกิดการ evaluate** (การ iterate, `len()`, `list()`, `.count()`, `.exists()` ฯลฯ) และการที่ผลลัพธ์ถูก **cache** บน QuerySet ที่ถูก evaluate แล้ว จำเป็นต่อการหลีกเลี่ยงข้อพลาดด้านประสิทธิภาพที่พบบ่อย — โดยเฉพาะการรัน query เดียวกันหลายครั้งโดยไม่ได้ตั้งใจ (เช่น เรียก `.count()` แล้ว iterate QuerySet ตัวใหม่ ทำให้เข้าถึง database สองครั้ง)

ความ lazy เป็นหนึ่งในแนวคิดที่สำคัญที่สุดในการใช้ Django ORM อย่างดี ซึ่งแยกนักพัฒนาที่เขียนโค้ด database ที่มีประสิทธิภาพออกจากผู้ที่ทำให้เกิด query ซ้ำซ้อนโดยไม่รู้ตัว ทำให้มันเป็นความรู้หลักที่รองรับการใช้ ORM อย่างมีประสิทธิภาพและการ optimize ประสิทธิภาพทั้งหมดใน Django