准备
定义如下模型
from django.db import models # 省份
class Province(models.Model):
name = models.CharField(max_length=10) # 城市
class City(models.Model):
name = models.CharField(max_length=5)
province = models.ForeignKey(Province) # 人
class Person(models.Model):
name = models.CharField(max_length=20)
# 去过的城市
visitation = models.ManyToManyField(City, related_name="visitor")
# 故乡
hometown = models.ForeignKey(City, related_name="birth")
# 居住地
living = models.ForeignKey(City, related_name="citizen")
Code
province表：
city表：
person表：
初始数据如下：
示例模型是用来记录各个人的故乡、居住地、以及到过的城市。
select_related
对于一对一字段（OneToOneField）和外键（多对一）字段（ForeignKey），可以使用select_related 来对QuerySet进行优化。
示例
查询城市所属省份
未优化
city_list = models.City.objects.all()
[print('{}=>{}'.format(city.name, city.province.name)) for city in city_list] '''
result:
武汉市=>湖北省
孝感市=>湖北省
广州市=>广东省
深圳市=>广东省
'''Code
(0.000) SELECT `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city`; args=()
(0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 1; args=(1,)
(0.001) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 1; args=(1,)
(0.001) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 2; args=(2,)
(0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 2; args=(2,)执行sql：
这样会导致线性的SQL查询，如果对象数量n太多，每个对象中有k个外键字段的话，就会导致n*k+1次SQL查询。在本例中，因为有4个city对象就导致了5次SQL查询。
已优化
city_list = models.City.objects.select_related().all()
[print('{}=>{}'.format(city.name, city.province.name)) for city in city_list] '''
result:
武汉市=>湖北省
孝感市=>湖北省
广州市=>广东省
深圳市=>广东省
'''Code
(0.001) SELECT `city`.`id`, `city`.`name`, `city`.`province_id`, `province`.`id`, `province`.`name` FROM `city` INNER JOIN `province` ON (`city`.`province_id` = `province`.`id`); args=()
执行sql：
在对QuerySet使用select_related()函数后，Django会一次性获取相应外键对应的对象，从而在之后需要的时候不必再查询数据库了。这里我们可以看到，Django使用了INNER JOIN来获得省份的信息。
参数说明
*filed
select_related() 接受可变长参数，每个参数是需要获取的外键（父表的内容）的字段名，以及外键的外键的字段名、外键的外键的外键...。若要选择外键的外键需要使用两个下划线“__”来连接。例如我们要获得张三的现居省份，可以用如下方式：
p = models.Person.objects.select_related('living__province').get(name='张三')
print(p.living.province.name) '''
result:
广东省
'''Code
(0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id`, `city`.`id`, `city`.`name`, `city`.`province_id`, `province`.`id`, `province`.`name` FROM `person` INNER JOIN `city` ON (`person`.`living_id` = `city`.`id`) INNER JOIN `province` ON (`city`.`province_id` = `province`.`id`) WHERE `person`.`name` = '张三'; args=('张三',)执行sql：
可以看到，Django使用了2次 INNER JOIN 来完成请求，获得了city表和province表的内容并添加到结果表的相应列，这样在调用p.living的时候也不必再次进行SQL查询。
然而，未指定的外键则不会被添加到结果中。这时候如果需要获取张三的故乡就会进行SQL查询了：
p = models.Person.objects.select_related('living__province').get(name='张三')
print(p.hometown.province.name) '''
result:
湖北省
'''Code
(0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id`, `city`.`id`, `city`.`name`, `city`.`province_id`, `province`.`id`, `province`.`name` FROM `person` INNER JOIN `city` ON (`person`.`living_id` = `city`.`id`) INNER JOIN `province` ON (`city`.`province_id` = `province`.`id`) WHERE `person`.`name` = '张三'; args=('张三',)
(0.000) SELECT `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` WHERE `city`.`id` = 2; args=(2,)
(0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 1; args=(1,)执行sql：
如果不指定外键，就会进行两次查询。如果深度更深，查询的次数更多。
无参
select_related()也可以不加参数，这样表示要求Django尽可能深的select_related。例如：
p = models.Person.objects.select_related().get(name='张三')
print(p.hometown.province.name)
print(p.living.province.name) '''
result:
湖北省
广东省
'''Code
(0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id`, `city`.`id`, `city`.`name`, `city`.`province_id`, `province`.`id`, `province`.`name`, T4.`id`, T4.`name`, T4.`province_id`, T5.`id`, T5.`name` FROM `person` INNER JOIN `city` ON (`person`.`hometown_id` = `city`.`id`) INNER JOIN `province` ON (`city`.`province_id` = `province`.`id`) INNER JOIN `city` T4 ON (`person`.`living_id` = T4.`id`) INNER JOIN `province` T5 ON (T4.`province_id` = T5.`id`) WHERE `person`.`name` = '张三'; args=('张三',)执行sql
注意：
Django本身内置一个上限，对于特别复杂的表关系，Django可能在你不知道的某处跳出递归，从而与你想的做法不一样。
Django并不知道你实际要用的字段有哪些，所以会把所有的字段都抓进来，从而会造成不必要的浪费而影响性能。
小结
- select_related主要针一对一和多对一关系进行优化。
- select_related使用SQL的JOIN语句进行优化，通过减少SQL查询的次数来进行优化、提高性能。
- 可以通过可变长参数指定需要select_related的字段名。也可以通过使用双下划线“__”连接字段名来实现指定的递归查询。没有指定的字段不会缓存，如果要访问的话Django会再次进行SQL查询。
- 也接受无参数的调用，Django会尽可能深的递归查询所有的字段。但注意有Django递归的限制和性能的浪费。
prefetch_related
对于多对多字段（ManyToManyField）和一对多字段，可以使用prefetch_related()来进行优化。或许你会说，没有一个叫OneToManyField的东西啊。实际上，使用ForeignKey的字段就是一个多对一的字段，而被ForeignKey关联的字段就是一对多字段了。prefetch_related()和select_related()的设计目的很相似，都是为了减少SQL查询的数量，但是实现的方式不一样。后者是通过JOIN语句，在SQL查询内解决问题。但是对于多对多关系，使用SQL语句解决就显得有些不太明智，因为JOIN得到的表将会很长，会导致SQL语句运行时间的增加和内存占用的增加。prefetch_related()的解决方法是，分别查询每个表，然后用Python处理他们之间的关系。
示例
获得张三所有去过的城市
p = models.Person.objects.prefetch_related('visitation').get(name='张三')
[print(c.name) for c in p.visitation.all()]
'''
result:
武汉市
孝感市
广州市
深圳市
'''Code
(0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person` WHERE `person`.`name` = '张三'; args=('张三',)
(0.000) SELECT (`person_visitation`.`person_id`) AS `_prefetch_related_val_person_id`, `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` INNER JOIN `person_visitation` ON (`city`.`id` = `person_visitation`.`city_id`) WHERE `person_visitation`.`person_id` IN (1); args=(1,)执行sql：
获得湖北的所有城市名
hb = models.Province.objects.prefetch_related('city_set').get(name__iexact=u"湖北省")
for city in hb.city_set.all():
print(city.name)
'''
result:
武汉市
孝感市
'''Code
(0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`name` LIKE '湖北省'; args=('湖北省',)
(0.001) SELECT `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` WHERE `city`.`province_id` IN (1); args=(1,)执行sql：
参数说明
*lookups
和select_related()一样，prefetch_related()也支持深度查询，例如要获得所有姓张的人去过的省：
p_list = models.Person.objects.filter(name__iexact='张三').prefetch_related('visitation__province').all()
for i in p_list:
for city in i.visitation.all():
print(city.province.name)
'''
result:
湖北省
湖北省
广东省
广东省
'''Code
(0.001) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person` WHERE `person`.`name` LIKE '张三'; args=('张三',)
(0.000) SELECT (`person_visitation`.`person_id`) AS `_prefetch_related_val_person_id`, `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` INNER JOIN `person_visitation` ON (`city`.`id` = `person_visitation`.`city_id`) WHERE `person_visitation`.`person_id` IN (1); args=(1,)
(0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` IN (1, 2); args=(1, 2)执行sql：
要注意的是，在使用QuerySet的时候，一旦在链式操作中改变了数据库请求，之前用prefetch_related缓存的数据将会被忽略掉。这会导致Django重新请求数据库来获得相应的数据，从而造成性能问题。这里提到的改变数据库请求指各种filter()、exclude()等等最终会改变SQL代码的操作。而all()并不会改变最终的数据库请求，因此是不会导致重新请求数据库的。举个例子，要获取所有人访问过的城市中带有“市”字的城市，这样做会导致大量的SQL查询：
plist = models.Person.objects.prefetch_related('visitation')
l = [p.visitation.filter(name__icontains=u"市") for p in plist]
for i in l:
for j in i:
print(j.name)
'''
result:
武汉市
孝感市
广州市
深圳市
'''Code
(0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person`; args=()
(0.001) SELECT (`person_visitation`.`person_id`) AS `_prefetch_related_val_person_id`, `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` INNER JOIN `person_visitation` ON (`city`.`id` = `person_visitation`.`city_id`) WHERE `person_visitation`.`person_id` IN (1); args=(1,)
(0.000) SELECT `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` INNER JOIN `person_visitation` ON (`city`.`id` = `person_visitation`.`city_id`) WHERE (`person_visitation`.`person_id` = 1 AND `city`.`name` LIKE '%市%'); args=(1, '%市%')执行sql：
因为数据库中有1人，导致了2+1次SQL查询。详细分析一下这些请求事件。众所周知，QuerySet是lazy的，要用的时候才会去访问数据库。运行到第二行Python代码时，for循环将plist看做iterator，这会触发数据库查询。最初的两次SQL查询就是prefetch_related导致的。虽然已经查询结果中包含所有所需的city的信息，但因为在循环体中对Person.visitation进行了filter操作，这显然改变了数据库请求。因此这些操作会忽略掉之前缓存到的数据，重新进行SQL查询。但是如果有这样的需求了应该怎么办呢？可以在Python中完成这部分操作：
plist = models.Person.objects.prefetch_related('visitation')
[[print(city.name) for city in p.visitation.all() if u"市" in city.name] for p in plist]
'''
result:
武汉市
孝感市
广州市
深圳市
'''Code
(0.001) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person`; args=()
(0.001) SELECT (`person_visitation`.`person_id`) AS `_prefetch_related_val_person_id`, `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` INNER JOIN `person_visitation` ON (`city`.`id` = `person_visitation`.`city_id`) WHERE `person_visitation`.`person_id` IN (1); args=(1,)执行sql：
小结
- prefetch_related主要针一对多和多对多关系进行优化。
- prefetch_related通过分别获取各个表的内容，然后用Python处理他们之间的关系来进行优化。
- 可以通过可变长参数指定需要prefetch_related的字段名。指定方式和特征与select_related是相同的。