QuerySet là gì và chúng lazy như thế nào?

Question

Accepted Answer

Một **QuerySet** biểu diễn một tập hợp các hàng database dưới dạng một đối tượng Python mà bạn có thể filter, sắp xếp, và nối chuỗi. Đặc tính định nghĩa của nó là **tính lazy** — một QuerySet **không** truy cập database khi được tạo; nó chỉ thực thi truy vấn khi dữ liệu thực sự cần thiết (được đánh giá). Hiểu điều này là then chốt để viết mã Django hiệu quả.

## QuerySet lazy — không truy cập database cho đến khi được đánh giá

```python
# KHÔNG cái nào trong số này chạm database — chúng chỉ dựng truy vấn
qs = Article.objects.all()                  # chưa có truy vấn
qs = qs.filter(published=True)              # vẫn chưa có truy vấn — nối chuỗi là lazy
qs = qs.exclude(views=0).order_by("-created_at")   # vẫn chưa có truy vấn

# database chỉ bị truy cập khi QuerySet được ĐÁNH GIÁ:
for article in qs:        # ← GIỜ truy vấn mới chạy
    print(article.title)
```

Dựng và nối chuỗi một QuerySet không tốn gì — Django ráp SQL nhưng hoãn việc thực thi cho đến khi bạn thực sự cần kết quả. Điều này cho phép bạn soạn các truy vấn phức tạp một cách hiệu quả trong một chuyến đi database.

## Cái gì kích hoạt đánh giá (một lần truy cập database)

```text
✓ Lặp:             for x in qs
✓ Slice với bước:  qs[::2]  (slice thường qs[:10] vẫn lazy, thêm LIMIT)
✓ len(qs), list(qs), bool(qs)
✓ Gọi một phương thức không phải QuerySet: .count(), .exists(), .first(), .get(), .aggregate()
```

## Vì sao tính lazy mạnh mẽ

```python
# dựng truy vấn theo điều kiện MÀ KHÔNG có chuyến đi database thêm
qs = Article.objects.all()
if search:
    qs = qs.filter(title__icontains=search)   # không truy cập DB
if category:
    qs = qs.filter(category=category)          # không truy cập DB
articles = qs[:20]                              # MỘT truy vấn chạy ở đây, với LIMIT 20
```

Tính lazy cho phép bạn soạn một truy vấn theo điều kiện qua nhiều dòng, rồi thực thi nó **một lần** — hiệu quả và gọn gàng.

## Caching của QuerySet

```python
qs = Article.objects.filter(published=True)
list(qs)     # truy vấn chạy, kết quả được CACHE trên QuerySet
list(qs)     # dùng CACHE — không có truy vấn thứ hai
# NHƯNG một queryset MỚI sẽ truy vấn lại:
Article.objects.filter(published=True)   # một queryset mới → truy vấn mới
```

Khi đã được đánh giá, một QuerySet cache kết quả của nó, nên lặp lại *cùng* một QuerySet không truy vấn lại.

## Cái bẫy của tính lazy

```python
# ⚠️ gọi .count() rồi lặp sẽ chạy HAI truy vấn
if Article.objects.filter(published=True).count() > 0:   # truy vấn 1
    for a in Article.objects.filter(published=True):     # truy vấn 2 (queryset mới!)
        ...
# ✅ tốt hơn — đánh giá một lần, tái sử dụng
qs = list(Article.objects.filter(published=True))
if qs: ...
```

## Tại sao điều này quan trọng

Hiểu QuerySet và tính lazy của chúng là nền tảng để viết mã database Django hiệu quả, đúng đắn — nó ảnh hưởng trực tiếp đến hiệu năng và giải thích các hành vi gây bối rối cho người mới.

Hiểu biết then chốt là QuerySet **không truy cập database cho đến khi được đánh giá**, điều này rất mạnh mẽ: bạn có thể dựng, filter, nối chuỗi, và soạn theo điều kiện các truy vấn phức tạp qua nhiều dòng mã với chi phí database bằng không, rồi thực thi mọi thứ trong **một chuyến đi duy nhất** khi bạn thực sự cần kết quả.

Điều này cho phép xây dựng truy vấn gọn gàng, hiệu quả (vd: thêm filter theo điều kiện dựa trên input người dùng, rồi chạy một truy vấn) mà nếu không sẽ đòi hỏi việc ghép chuỗi SQL vụng về.

Biết chính xác **cái gì kích hoạt đánh giá** (lặp, `len()`, `list()`, `.count()`, `.exists()`, v.v.) và rằng kết quả được **cache** trên một QuerySet đã đánh giá là thiết yếu để tránh các cái bẫy hiệu năng phổ biến — đáng chú ý nhất là vô tình chạy cùng một truy vấn nhiều lần (vd: gọi `.count()` rồi lặp một QuerySet mới, truy cập database hai lần).

Tính lazy là một trong những khái niệm quan trọng nhất để dùng tốt Django ORM, phân biệt các lập trình viên viết mã database hiệu quả với những người vô tình kích hoạt các truy vấn dư thừa, khiến nó trở thành kiến thức cốt lõi làm nền cho mọi việc sử dụng ORM hiệu quả và tối ưu hiệu năng trong Django.