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_relatedprefetch_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 性能问题,到这一步就能解决大半。