|
| Hiểu và Khắc Phục Vấn Đề N+1 Query |
Nếu bạn từng thấy một trang tự nhiên chậm hẳn dù dữ liệu chẳng bao nhiêu, thủ phạm rất hay gặp là N+1 query. Trong bài này tôi sẽ giải thích N+1 từ gốc ở tầng cơ sở dữ liệu (không khoá vào framework nào), vì sao nó nguy hiểm hơn vẻ ngoài, các chiến lược khắc phục chung, rồi mới lấy Django làm ví dụ minh hoạ cụ thể.
N+1 Query là gì?
Định nghĩa gọn, không nhắc ngôn ngữ nào: bạn chạy 1 truy vấn chính để lấy một danh sách N bản ghi, sau đó với mỗi bản ghi lại bắn thêm 1 truy vấn phụ để lấy dữ liệu liên quan. Tổng cộng 1 + N truy vấn, trong khi đáng lẽ gộp được còn 1 (JOIN) hoặc 2 (batch).
Hình dung một API lấy 100 đơn hàng kèm tên khách. Nếu code truy cập quan hệ "khách của đơn" trong vòng lặp mà chưa tải sẵn, ở tầng SQL nó thành:
-- 1 truy vấn chính
SELECT id, user_id, total FROM orders;
-- rồi N truy vấn phụ, mỗi đơn một câu
SELECT name FROM users WHERE id = 1;
SELECT name FROM users WHERE id = 2;
SELECT name FROM users WHERE id = 3;
-- ... tới id = 100
Còn cách gộp bằng JOIN chỉ tốn một truy vấn:
SELECT o.id, o.total, u.name
FROM orders o
JOIN users u ON o.user_id = u.id;
Đây là ví dụ chạy được bằng sqlite3 (có sẵn trong Python, không cần cài gì) để đếm số truy vấn thực tế:
import sqlite3
con = sqlite3.connect(":memory:")
n = [0]
def q(sql, args=()):
n[0] += 1
return con.execute(sql, args)
con.execute("CREATE TABLE users(id INTEGER PRIMARY KEY, name TEXT)")
con.execute("CREATE TABLE orders(id INTEGER PRIMARY KEY, user_id INT, total INT)")
for i in range(1, 21):
con.execute("INSERT INTO users VALUES(?,?)", (i, f"User{i}"))
for i in range(1, 101):
con.execute("INSERT INTO orders VALUES(?,?,?)", (i, (i % 20) + 1, i * 10))
# Cách N+1
n[0] = 0
orders = q("SELECT id, user_id, total FROM orders").fetchall()
for o in orders:
q("SELECT name FROM users WHERE id=?", (o[1],)).fetchone()
print("N+1 :", n[0], "queries")
# Cách JOIN
n[0] = 0
q("SELECT o.id, o.total, u.name FROM orders o JOIN users u ON o.user_id=u.id").fetchall()
print("JOIN:", n[0], "query")
Ví von ngắn: bạn có 100 khách hàng. Thay vì hỏi một câu "đưa tôi danh sách 100 khách kèm email của họ", bạn lại hỏi "cho tôi khách #1", "email của #1?", "cho tôi khách #2", "email của #2?"... 200 lượt hỏi qua lại cho việc đáng lẽ một câu là xong.
Vì sao N+1 nguy hiểm hơn vẻ ngoài?
Nhiều người nghĩ "101 truy vấn thì chậm hơn 1 chút thôi". Sai lầm ở chỗ: chi phí thật không nằm ở việc chạy câu SQL, mà ở mỗi lần đi-về (round trip) giữa ứng dụng và database.
Để ý demo trên chạy sqlite3 in-memory nên gần như 0ms - vì database nằm ngay trong tiến trình, không có mạng. Nhưng database thật (PostgreSQL, MySQL) ở một máy khác, mỗi truy vấn kéo theo:
- Một round trip qua mạng (network latency).
- Mượn một kết nối từ connection pool.
- DB parse + lập kế hoạch (planning) cho câu truy vấn.
- CPU của DB, và có thể tranh chấp khoá (lock contention).
Giả sử độ trễ mỗi truy vấn chỉ 2ms:
Cách JOIN: 1 truy vấn x 2ms = 2ms. Tệ hơn nữa, dưới tải cao, 101 truy vấn mỗi request nhân với hàng nghìn request có thể làm cạn connection pool và kéo sập cả hệ thống, chứ không chỉ chậm.
N+1 hay nấp ở đâu?
N+1 hiếm khi lộ liễu. Nó thường nấp sau một dòng trông vô hại truy cập quan hệ trong vòng lặp:
- ORM lazy loading:
order.customer.nametrong vòng lặp - phổ biến nhất. - Serializer / API layer: serializer đọc trường quan hệ khi dựng JSON (rất hay gặp, nói kỹ ở dưới).
- Template rendering: vòng lặp trong template gọi thuộc tính quan hệ.
- GraphQL resolver: mỗi node con gọi resolver riêng, bắn một query - đây là lý do GraphQL sinh ra DataLoader.
- Vòng lặp gọi repository/service: gọi hàm lấy dữ liệu bên trong
for.
# Không cần biết framework nào - mẫu này luôn đáng ngờ:
for order in orders:
print(order.customer.name) # truy cập quan hệ trong vòng lặp
Các chiến lược khắc phục (chung mọi framework)
Dù dùng ngôn ngữ hay ORM gì, cách chữa quy về "gom việc tải dữ liệu liên quan thành lô". Có 4 chiến lược:
- JOIN: lấy dữ liệu chính và liên quan trong một truy vấn. Tốt cho quan hệ single-valued (mỗi đơn có đúng một khách).
SELECT orders.*, users.name FROM orders JOIN users ON orders.user_id = users.id; - Batch loading (truy vấn IN): lấy danh sách chính trước, gom hết ID liên quan, rồi một truy vấn
IN (...)lấy toàn bộ, cuối cùng ghép lại ở tầng ứng dụng. Tốt cho quan hệ collection (một khách nhiều đơn).SELECT * FROM orders; -- lấy đơn SELECT * FROM users WHERE id IN (1,2,3,...); -- gom 1 lần - Eager loading: ORM tự làm JOIN hoặc batch giúp bạn khi bạn khai báo trước quan hệ cần tải.
- DataLoader / batching: gom các yêu cầu lẻ trong một "tick" rồi bắn một truy vấn - cực hữu ích cho GraphQL resolver.
Case study: N+1 trong Django ORM
Django là ví dụ minh hoạ tốt vì nó có sẵn hai công cụ ứng với JOIN và batch.
# models.py
class Author(models.Model):
name = models.CharField(max_length=100)
class Post(models.Model):
title = models.CharField(max_length=200)
author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name="posts")
Đoạn dính N+1: mỗi lần chạm post.author.name lại bắn thêm một truy vấn.
posts = Post.objects.all() # 1 truy vấn lấy posts
for post in posts:
print(post.author.name) # +1 truy vấn mỗi post -> N+1
select_related() gộp bằng JOIN (dùng cho quan hệ single-valued: khoá ngoại thuận và một-một):
posts = Post.objects.select_related("author").all() # 1 truy vấn có JOIN
# SQL: SELECT post.*, author.* FROM post JOIN author ON post.author_id = author.id
prefetch_related() dùng truy vấn IN riêng rồi ghép ở Python (dùng cho quan hệ collection: nhiều-nhiều và khoá ngoại ngược như author.posts):
authors = Author.objects.prefetch_related("posts").all() # 2 truy vấn
# SQL: SELECT * FROM author; rồi SELECT * FROM post WHERE author_id IN (...)
select_related() | prefetch_related() | |
|---|---|---|
| Cơ chế | SQL JOIN | Truy vấn IN riêng + ghép ở Python |
| Quan hệ | FK thuận, OneToOne (single-valued) | ManyToMany, FK ngược (collection) |
| Số truy vấn | Thường 1 | Thường 2+ |
select_related() chỉ đi theo quan hệ single-valued (mỗi bản ghi ứng đúng một object). Nó KHÔNG đi theo quan hệ ngược dạng collection như author.posts - chỗ đó phải dùng prefetch_related().- SQLAlchemy:
joinedload()(JOIN) /selectinload()(IN batch) - Hibernate, JPA:
JOIN FETCH/@EntityGraph - Entity Framework:
Include()/ThenInclude() - Rails ActiveRecord:
includes()/preload()/eager_load() - GraphQL: DataLoader để gom query theo lô
Thủ phạm hay bị bỏ sót: serializer / REST API
Đây là nguồn N+1 rất phổ biến mà nhìn code view thường không thấy. Query nằm sẵn ở view, nhưng truy vấn phụ lại bị kích hoạt bên trong serializer khi nó dựng JSON:
# Django REST Framework
class PostSerializer(serializers.ModelSerializer):
author_name = serializers.CharField(source="author.name") # chạm author -> query
class Meta:
model = Post
fields = ["id", "title", "author_name"]
# View: Post.objects.all() -> serializer chạm post.author.name cho MỖI post -> N+1
# Sửa: Post.objects.select_related("author")
Người viết view nhìn Post.objects.all() tưởng vô hại, không nhận ra chuỗi View -> Serializer -> quan hệ -> DB đang bắn N truy vấn.
async def của Django, chạm một quan hệ lazy như post.author.name ngay trong context async sẽ ném SynchronousOnlyOperation, vì ORM đồng bộ không được gọi trực tiếp từ event loop. Cách xử lý: tải sẵn quan hệ bằng select_related()/prefetch_related() trước (đằng nào cũng nên làm để tránh N+1), dùng API async của ORM (aget(), async for), hoặc bọc trong sync_to_async.N+1 không phải lúc nào cũng xấu
Đừng biến "N+1 = luôn sai" thành luật tuyệt đối. N+1 là một dấu hiệu (performance smell), không tự động là bug.
- Lấy 5 bản ghi rồi lặp 5 lần (5 truy vấn nhỏ) trên trang admin ít traffic: gần như chẳng đáng lo.
- Ngược lại,
select_related()ôm quá nhiều quan hệ sâu tạo ra JOIN khổng lồ, kéo về đống dữ liệu trùng lặp - có khi còn chậm hơn.
Nên đo, đừng đoán. Cân nhắc: bao nhiêu truy vấn? mỗi truy vấn nặng cỡ nào? kéo về bao nhiêu dữ liệu? độ trễ ra sao? tần suất (workload)? Tối ưu chỗ thật sự nóng, không tối ưu bừa.
Phát hiện và phòng ngừa
Phát hiện (detect): bật log truy vấn ở môi trường dev; dùng công cụ như Django Debug Toolbar hoặc Django Silk để đếm số query mỗi request; ở production thì dựa vào APM / DB monitoring.
pip install django-debug-toolbar django-silk # thêm vào INSTALLED_APPS
Phòng ngừa tái phát (prevent): phát hiện rồi sửa là chưa đủ - cần chặn N+1 quay lại bằng test đếm số truy vấn. Trong Django là assertNumQueries:
from django.test import TestCase
class PostListTest(TestCase):
def test_list_posts_khong_bi_n_plus_1(self):
with self.assertNumQueries(2): # mong đợi đúng 2 truy vấn
self.client.get("/posts/")
Chuỗi đúng là: Detect -> Optimize -> Prevent. Debug Toolbar giúp phát hiện; test đếm query giúp N+1 không quay lại khi ai đó sửa code sau này.
Tóm tắt
- N+1 là anti-pattern data access: 1 truy vấn chính + N truy vấn phụ khi lặp qua danh sách và chạm quan hệ chưa tải sẵn. Không riêng Django.
- Nguy hiểm nằm ở round trip / độ trễ / connection pool, không chỉ ở việc "nhiều câu SQL".
- Chữa bằng: JOIN (single-valued), batch IN (collection), eager loading, hoặc DataLoader (GraphQL).
- Django:
select_related()(JOIN) vàprefetch_related()(IN batch). Các ORM khác đều có cặp tương tự. - Coi chừng N+1 nấp trong serializer. N+1 là smell cần đo, không phải lúc nào cũng xấu.
- Phát hiện bằng Debug Toolbar/Silk/APM; phòng tái phát bằng test đếm query (
assertNumQueries).
Nguồn tham khảo
- Django docs - select_related(), prefetch_related(), assertNumQueries
- SQLAlchemy - Relationship Loading Techniques (joinedload / selectinload)
- GraphQL DataLoader - gom query theo lô
- Django Debug Toolbar, Django Silk
- Kai