👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Hiểu và Khắc Phục Vấn Đề N+1 Query

Hiểu và Khắc Phục Vấn Đề N+1 Query
Hiểu và Khắc Phục Vấn Đề N+1 Query
TL;DR: N+1 query là một anti-pattern ở tầng truy cập dữ liệu (data access): code chạy 1 truy vấn lấy danh sách N bản ghi, rồi lặp qua từng bản ghi bắn thêm 1 truy vấn phụ để lấy dữ liệu liên quan, thành 1 + N truy vấn thay vì gộp lại còn 1-2. Đây KHÔNG phải vấn đề riêng của Django hay Python: mọi ORM (SQLAlchemy, Hibernate, ActiveRecord, Entity Framework) và cả GraphQL đều dính. Cách chữa chung là gộp việc tải dữ liệu liên quan thành lô (batch) bằng JOIN, truy vấn IN, eager loading hoặc DataLoader.

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;
N+1: nhiều lượt đi-về Ứng dụng Database 1 + 100 = 101 truy vấn ~202ms chờ DB JOIN: một lượt Ứng dụng Database 1 truy vấn - ~2ms
Cùng lấy 100 đơn kèm tên khách: N+1 tốn 101 lượt đi-về tới database, JOIN gộp còn 1.

Đâ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")
N+1 : 101 queries JOIN: 1 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:

100 đơn -> 101 truy vấn  x  2ms  =  ~202ms chỉ riêng chờ DB (chưa tính xử lý app, mạng)

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.name trong 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:

  1. 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;
  2. 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
  3. 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.
  4. 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 JOINTruy vấn IN riêng + ghép ở Python
Quan hệFK thuận, OneToOne (single-valued)ManyToMany, FK ngược (collection)
Số truy vấnThường 1Thường 2+
Đừng nhầm: 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().
Các framework khác cũng có bộ đôi tương tự:
  • 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.

Trong môi trường bất đồng bộ (async / ASGI): N+1 không chỉ chậm mà có thể thành lỗi thẳng. Ở view 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

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét