Django ORM 性能优化：select_related、prefetch_related 与查询优化
各位朋友，大家好！今天我们来聊聊 Django ORM 的性能优化，重点关注 select_related、prefetch_related 这两个利器，以及如何进行通用的查询优化。Django ORM 极大地简化了数据库操作，但如果不注意，很容易写出性能低下的代码，导致应用响应缓慢。
一、ORM 性能问题的根源
在使用 ORM 时，我们实际上是用 Python 代码来操作数据库。每次访问关联对象时，如果不进行优化，ORM 默认会发起一次新的数据库查询，这被称为 N+1 查询问题。
假设我们有以下模型：
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
def __str__(self):
return self.name
class Book(models.Model):
title = models.CharField(max_length=200)
author = models.ForeignKey(Author, on_delete=models.CASCADE)
def __str__(self):
return self.title现在我们要获取所有书籍及其作者的信息：
books = Book.objects.all()
for book in books:
print(f"{book.title} by {book.author.name}")这段代码看似简单，但如果数据库中有 100 本书，那么将会执行 101 次查询：1 次查询获取所有书籍，100 次查询分别获取每本书的作者信息。这就是典型的 N+1 问题，N 是书籍的数量，+1 是初始查询。
二、select_related：解决一对一和多对一关系的 N+1 问题
select_related 用于预先获取一对一和多对一关系的数据。它通过在一条 SQL 查询语句中使用 JOIN 来完成，避免了额外的数据库查询。
对于上面的例子，我们可以这样优化：
books = Book.objects.select_related('author').all()
for book in books:
print(f"{book.title} by {book.author.name}")现在，Django 会使用一条 SQL 查询，一次性获取所有书籍及其作者的信息。 select_related('author') 告诉 Django 在获取书籍时，同时获取关联的 Author 对象。
select_related 的使用场景：
- 一对一关系（OneToOneField）
- 多对一关系（ForeignKey）
代码示例：
假设我们有 Profile 模型，与 User 模型是一对一关系：
from django.contrib.auth.models import User
from django.db import models
class Profile(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
bio = models.TextField(blank=True)
def __str__(self):
return self.user.username获取用户及其个人资料：
users = User.objects.select_related('profile').all()
for user in users:
print(f"{user.username}: {user.profile.bio}")注意事项：
select_related只能用于一对一和多对一关系，不能用于多对多关系。- 可以使用多个
select_related来预取多个关联对象，例如select_related('author', 'category')。 - 可以链式调用
select_related来预取深层关联对象，例如select_related('author__publisher')，假设Author模型有一个publisher字段，是与Publisher模型的多对一关系。
三、prefetch_related：解决多对多和一对多关系的 N+1 问题
prefetch_related 用于预先获取多对多和一对多关系的数据。它通过执行额外的查询，然后用 Python 代码将结果连接起来。
假设我们有 Author 和 Book 模型，一个作者可以写多本书：
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
def __str__(self):
return self.name
class Book(models.Model):
title = models.CharField(max_length=200)
author = models.ForeignKey(Author, on_delete=models.CASCADE)
def __str__(self):
return self.title现在我们要获取所有作者及其书籍信息：
authors = Author.objects.prefetch_related('book_set').all()
for author in authors:
print(f"Author: {author.name}")
for book in author.book_set.all():
print(f" - {book.title}")prefetch_related('book_set') 告诉 Django 在获取作者时，同时获取每个作者关联的所有 Book 对象。Django 会执行两个查询：
- 获取所有作者。
- 获取所有与这些作者相关的书籍。
然后，Django 会在 Python 代码中将作者和书籍连接起来，避免了每个作者都执行一次额外的数据库查询。
prefetch_related 的使用场景：
- 多对多关系（ManyToManyField）
- 一对多关系 (ForeignKey 反向查询，例如上面的
book_set)
代码示例：
假设我们有 Article 和 Tag 模型，一篇文章可以有多个标签：
from django.db import models
class Article(models.Model):
title = models.CharField(max_length=200)
tags = models.ManyToManyField('Tag')
def __str__(self):
return self.title
class Tag(models.Model):
name = models.CharField(max_length=50)
def __str__(self):
return self.name获取文章及其标签：
articles = Article.objects.prefetch_related('tags').all()
for article in articles:
print(f"Article: {article.title}")
for tag in article.tags.all():
print(f" - {tag.name}")使用 Prefetch 对象进行更精细的控制：
prefetch_related 还支持使用 Prefetch 对象，可以对预取的数据进行更精细的控制，例如过滤、排序等。
from django.db.models import Prefetch
authors = Author.objects.prefetch_related(
Prefetch('book_set', queryset=Book.objects.filter(title__icontains='Django'))
).all()
for author in authors:
print(f"Author: {author.name}")
for book in author.book_set.all():
print(f" - {book.title}")上面的代码只预取了书名包含 "Django" 的书籍。
四、查询优化技巧
除了 select_related 和 prefetch_related，还有一些其他的查询优化技巧可以提升 Django ORM 的性能。
1. 只获取需要的字段：values 和 values_list
默认情况下，Django ORM 会获取模型的所有字段。如果只需要部分字段，可以使用 values 或 values_list 方法。
values返回一个字典列表，每个字典代表一个对象，包含指定的字段。values_list返回一个元组列表，每个元组代表一个对象，包含指定的字段。
# 获取所有书籍的标题和作者姓名，返回字典列表
books = Book.objects.values('title', 'author__name')
# 获取所有书籍的标题和作者姓名，返回元组列表
books = Book.objects.values_list('title', 'author__name')
# 获取所有书籍的标题，返回扁平的元组列表
books = Book.objects.values_list('title', flat=True)使用 values 和 values_list 可以减少数据库传输的数据量，提高查询效率。
2. 使用 defer 和 only 延迟加载字段
defer延迟加载指定的字段，只有在访问这些字段时才会执行额外的数据库查询。only只加载指定的字段，其他字段会被延迟加载。
# 延迟加载书籍的 description 字段
books = Book.objects.defer('description').all()
# 只加载书籍的 title 和 author 字段，延迟加载其他字段
books = Book.objects.only('title', 'author').all()defer 和 only 可以用于优化那些很少使用的字段。
3. 使用 exists 检查是否存在
如果只需要检查某个对象是否存在，可以使用 exists 方法，它比 count 方法更高效。
# 检查是否存在标题为 "Django" 的书籍
exists = Book.objects.filter(title='Django').exists()4. 使用 bulk_create 和 bulk_update 批量创建和更新
如果需要创建或更新大量对象，可以使用 bulk_create 和 bulk_update 方法，它们比循环创建或更新对象更高效。
# 批量创建书籍
books = [
Book(title='Book 1', author=author1),
Book(title='Book 2', author=author2),
]
Book.objects.bulk_create(books)
# 批量更新书籍
Book.objects.bulk_update(books, ['title'])5. 使用索引
索引可以加快数据库的查询速度。应该在经常用于过滤和排序的字段上创建索引。
在 Django 模型中，可以使用 db_index=True 来创建索引：
from django.db import models
class Book(models.Model):
title = models.CharField(max_length=200, db_index=True)
author = models.ForeignKey(Author, on_delete=models.CASCADE)
def __str__(self):
return self.title6. 分析查询：使用 Django Debug Toolbar
Django Debug Toolbar 是一个非常有用的工具，可以帮助你分析 Django 应用的性能，包括 SQL 查询的数量、执行时间等。
安装 Django Debug Toolbar：
pip install django-debug-toolbar在 settings.py 中配置 Django Debug Toolbar：
INSTALLED_APPS = [
...
'debug_toolbar',
]
MIDDLEWARE = [
...
'debug_toolbar.middleware.DebugToolbarMiddleware',
]
INTERNAL_IPS = [
'127.0.0.1',
]7. 使用数据库原生查询
在某些情况下，Django ORM 可能无法满足你的需求，或者性能不够好。这时，你可以使用数据库原生查询来执行更复杂的 SQL 语句。
from django.db import connection
def my_custom_sql(author_id):
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM myapp_book WHERE author_id = %s", [author_id])
row = cursor.fetchone()
return row五、性能测试与评估
优化之后，一定要进行性能测试，评估优化效果。可以使用 Django Debug Toolbar 或其他的性能测试工具来测量查询的执行时间。
六、常见问题与解决方案
- N+1 查询问题： 使用
select_related和prefetch_related。 - 查询的数据量过大： 使用
values和values_list只获取需要的字段。 - 查询速度慢： 使用索引，分析查询，优化 SQL 语句。
- 数据库连接过多： 确保正确关闭数据库连接，使用连接池。
七、总结与建议
| 优化方法 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
select_related |
一对一、多对一关系 | 避免 N+1 查询，性能提升显著 | 只能用于一对一和多对一关系，不能用于多对多和一对多关系 |
prefetch_related |
多对多、一对多关系 | 避免 N+1 查询，性能提升显著，支持使用 Prefetch 对象进行更精细的控制 |
需要执行额外的查询，然后用 Python 代码将结果连接起来 |
values |
只需要部分字段 | 减少数据库传输的数据量，提高查询效率 | 返回的是字典列表，而不是模型对象 |
values_list |
只需要部分字段 | 减少数据库传输的数据量，提高查询效率 | 返回的是元组列表，而不是模型对象 |
defer |
延迟加载不常用的字段 | 减少初始查询的数据量 | 访问延迟加载的字段时会执行额外的数据库查询 |
only |
只加载常用的字段 | 减少初始查询的数据量 | 访问未加载的字段时会执行额外的数据库查询 |
exists |
只需要检查对象是否存在 | 比 count 方法更高效 |
|
bulk_create |
批量创建对象 | 比循环创建对象更高效 | |
bulk_update |
批量更新对象 | 比循环更新对象更高效 | |
| 索引 | 经常用于过滤和排序的字段 | 加快查询速度 | 增加数据库的存储空间，降低写入速度 |
| 原生 SQL | ORM 无法满足需求或性能不够好的情况 | 可以执行更复杂的 SQL 语句，获得更高的性能 | 代码可读性差，维护成本高，容易出现 SQL 注入漏洞 |
| Django Debug Toolbar | 性能分析 | 帮助你分析 Django 应用的性能，包括 SQL 查询的数量、执行时间等，可以帮助你发现性能瓶颈 | 需要安装和配置 |
总结性的建议：
- 理解 ORM 的工作原理： 了解 ORM 如何将 Python 代码转换为 SQL 语句，才能更好地进行优化。
- 测试驱动优化： 在进行优化之前，先进行性能测试，确定性能瓶颈，然后针对性地进行优化。
- 选择合适的优化方法： 根据实际情况选择合适的优化方法，不要盲目追求性能。
- 持续监控： 优化之后，要持续监控应用的性能，及时发现和解决问题。
八、ORM的优化贯穿整个项目
ORM的优化并非一蹴而就，而是一个贯穿项目始终的过程。需要开发者在编写代码时时刻保持警惕，关注性能问题。
九、性能优化的关键在于理解
理解ORM的工作原理、数据库的特性，以及业务场景的需求，才能做出正确的优化决策。
十、不断学习与实践
性能优化是一个持续学习和实践的过程，需要不断学习新的技术和方法，并在实践中不断总结经验。
希望今天的分享对大家有所帮助！谢谢！