ORM 让写查询变得像写 Python 一样自然,代价是很容易在不知不觉中产生大量重复查询。 页面在本地只有十几条数据时看不出问题,上线后数据量一上来,接口就慢得明显。 这篇记录我最常遇到的那类问题以及对应的解决办法。
先准备两个模型
为了方便演示,假设有一个简单的图书系统:
# models.py
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=50)
def __str__(self):
return self.name
class Tag(models.Model):
name = models.CharField(max_length=30)
class Book(models.Model):
title = models.CharField(max_length=120)
author = models.ForeignKey(Author, related_name="books", on_delete=models.CASCADE)
tags = models.ManyToManyField(Tag, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
N+1 查询是怎么来的
在模板或接口里这样写,看起来没有任何问题:
books = Book.objects.all()
for book in books:
print(book.title, book.author.name)
实际执行的 SQL 是:
SELECT ... FROM book; -- 1 次
SELECT ... FROM author WHERE id = 1; -- 第 1 本书
SELECT ... FROM author WHERE id = 2; -- 第 2 本书
SELECT ... FROM author WHERE id = 3; -- 第 3 本书
...
第一条语句取出 N 本书,然后每访问一次外键就再查一次数据库, 总共 1 + N 条。这就是所谓的 N+1 问题。数据量 100 条时就是 101 次往返, 每次哪怕只有 1 毫秒,累计起来也很可观。
select_related:用 JOIN 一次取回
select_related 适用于外键和一对一关系。
它在 SQL 层生成 JOIN,把关联对象的数据一起查出来:
books = Book.objects.select_related("author").all()
for book in books:
print(book.title, book.author.name) # 只执行 1 条 SQL
需要多层关联时,用双下划线继续往下写:
Book.objects.select_related("author__profile")
注意,如果外键允许为空,Django 会使用 LEFT OUTER JOIN,
这是正确行为,不是性能问题。真正需要留意的是不要滥用:一次 JOIN 太多表,
结果集会被放大,反而更慢。
prefetch_related:分两次查,在 Python 里拼装
多对多和“反向外键”没法用 JOIN 简单解决(会导致行数膨胀),
这时用 prefetch_related:先查主表,再用 IN (...)
查关联表,最后在内存里完成匹配。
books = Book.objects.prefetch_related("tags").all()
for book in books:
print(book.title, [t.name for t in book.tags.all()])
无论有多少本书,都只会执行 2 条 SQL:
SELECT ... FROM book;
SELECT ... FROM tag INNER JOIN book_tags ON ... WHERE book_tags.book_id IN (1, 2, 3, ...);
反向外键同理,比如查作者及其全部作品:
authors = Author.objects.prefetch_related("books")
for author in authors:
print(author.name, author.books.count())
两者怎么选
| 维度 | select_related | prefetch_related |
|---|---|---|
| 适用关系 | 外键、一对一 | 多对多、反向关系、外键 |
| 实现方式 | SQL JOIN,1 条查询 | 额外查询 + 内存匹配,2 条起 |
| 结果行数 | 可能因 JOIN 变多 | 不放大主表行数 |
| 典型场景 | 文章 → 作者 | 文章 → 标签列表 |
两者可以链式组合,各管各的关系:
Book.objects.select_related("author").prefetch_related("tags")
只预取需要的数据
默认的 prefetch_related 会把关联表的全部字段都取回来。
如果只需要最近几条、或者只要部分字段,可以用 Prefetch 对象定制:
from django.db.models import Prefetch
authors = Author.objects.prefetch_related(
Prefetch(
"books",
queryset=Book.objects.filter(created_at__year=2026).order_by("-created_at"),
to_attr="recent_books",
)
)
for author in authors:
for book in author.recent_books: # 注意:这里不再需要 .all()
print(book.title)
使用 to_attr 后,结果会存进一个普通的 list 属性,
不会覆盖原来的管理器,语义更清晰,也避免了误触发新查询。
其他几个常用手段
only / defer
表字段很多、列表页又只用其中几列时,可以限制查询字段:
# 只取 id、title 两列
books = Book.objects.only("id", "title")
# 排除正文字段
books = Book.objects.defer("body")
但要小心:访问未加载的字段会再触发一次查询, 这和 N+1 一样隐蔽。
values / values_list
如果只是把数据序列化返回,不需要模型实例,直接用字典或元组更省内存:
Book.objects.values("id", "title", "author__name")
Book.objects.values_list("id", flat=True)
exists 与 count
判断是否存在,用 exists() 而不是 if queryset: 之后再去取数据;
只关心数量时用 count(),不要 len(queryset)——
后者会把所有行都加载到内存里。
if Book.objects.filter(author=author).exists():
...
total = Book.objects.filter(author=author).count()
批量操作
循环里逐条 save() 会产生大量 SQL。
插入用 bulk_create,更新用 bulk_update:
Book.objects.bulk_create([
Book(title=f"第 {i} 本", author=author) for i in range(100)
])
怎么发现查询变多了
开发阶段最直接的办法是打开 DEBUG = True,用
connection.queries 看当前请求执行了哪些 SQL:
from django.db import connection
print(len(connection.queries))
for q in connection.queries:
print(q["sql"][:120])
更省事的是安装 django-debug-toolbar,
它会在页面侧边栏直接显示 SQL 条数和每条语句的耗时。
线上环境不方便装工具,可以借助数据库的慢查询日志,或者用
queryset.explain() 查看执行计划。
小结
记住一条经验法则:凡是会在循环里访问关联对象的地方,先想想需不需要预加载。
外键和一对一用 select_related,多对多和反向关系用
prefetch_related,再用 Prefetch 把数据范围收窄。
大多数 ORM 性能问题,到这一步就能解决大半。