python框架之Django(6)-查询优化之select_related&prefetch_related

准备

定义如下模型

 1 from django.db import models
 2 
 3 # 省份
 4 class Province(models.Model):
 5     name = models.CharField(max_length=10)
 6 
 7 # 城市
 8 class City(models.Model):
 9     name = models.CharField(max_length=5)
10     province = models.ForeignKey(Province)
11 
12 # 人
13 class Person(models.Model):
14     name = models.CharField(max_length=20)
15     # 去过的城市
16     visitation = models.ManyToManyField(City, related_name="visitor")
17     # 故乡
18     hometown = models.ForeignKey(City, related_name="birth")
19     # 居住地
20     living = models.ForeignKey(City, related_name="citizen")
Code
province表：

city表：

person表：
初始数据如下：

示例模型是用来记录各个人的故乡、居住地、以及到过的城市。

select_related

对于一对一字段（OneToOneField）和外键（多对一）字段（ForeignKey），可以使用select_related 来对QuerySet进行优化。

示例

  • 查询城市所属省份

    • 未优化
       1     city_list = models.City.objects.all()
 2     [print('{}=>{}'.format(city.name, city.province.name)) for city in city_list]
 3 
 4 '''
 5 result:
 6     武汉市=>湖北省
 7     孝感市=>湖北省
 8     广州市=>广东省
 9     深圳市=>广东省
10 '''
      Code
      1 (0.000) SELECT `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city`; args=()
2 (0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 1; args=(1,)
3 (0.001) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 1; args=(1,)
4 (0.001) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 2; args=(2,)
5 (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查询。

    • 已优化
       1     city_list = models.City.objects.select_related().all()
 2     [print('{}=>{}'.format(city.name, city.province.name)) for city in city_list]
 3 
 4 '''
 5 result:
 6     武汉市=>湖北省
 7     孝感市=>湖北省
 8     广州市=>广东省
 9     深圳市=>广东省
10 '''
      Code
      1 (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() 接受可变长参数，每个参数是需要获取的外键（父表的内容）的字段名，以及外键的外键的字段名、外键的外键的外键...。若要选择外键的外键需要使用两个下划线“__”来连接。例如我们要获得张三的现居省份，可以用如下方式：

    1     p = models.Person.objects.select_related('living__province').get(name='张三')
2     print(p.living.province.name)
3 
4 '''
5 result:
6     广东省
7 '''
    Code
    1 (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查询了：

    1     p = models.Person.objects.select_related('living__province').get(name='张三')
2     print(p.hometown.province.name)
3 
4 '''
5 result:
6     湖北省
7 '''
    Code
    1 (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=('张三',)
2 (0.000) SELECT `city`.`id`, `city`.`name`, `city`.`province_id` FROM `city` WHERE `city`.`id` = 2; args=(2,)
3 (0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`id` = 1; args=(1,)
    执行sql：

    如果不指定外键，就会进行两次查询。如果深度更深，查询的次数更多。

  • 无参

    select_related()也可以不加参数，这样表示要求Django尽可能深的select_related。例如：

    1     p = models.Person.objects.select_related().get(name='张三')
2     print(p.hometown.province.name)
3     print(p.living.province.name)
4 
5 '''
6 result:
7     湖北省
8     广东省
9 '''
    Code
    1 (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处理他们之间的关系。

示例

  • 获得张三所有去过的城市

    1 p = models.Person.objects.prefetch_related('visitation').get(name='张三')
2 [print(c.name) for c in p.visitation.all()]
3 '''
4 result:
5     武汉市
6     孝感市
7     广州市
8     深圳市
9 '''
    Code
    1 (0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person` WHERE `person`.`name` = '张三'; args=('张三',)
2 (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：

  • 获得湖北的所有城市名

    1 hb = models.Province.objects.prefetch_related('city_set').get(name__iexact=u"湖北省")
2 for city in hb.city_set.all():
3     print(city.name)
4 '''
5 result:
6     武汉市
7     孝感市
8 '''
    Code
    1 (0.000) SELECT `province`.`id`, `province`.`name` FROM `province` WHERE `province`.`name` LIKE '湖北省'; args=('湖北省',)
2 (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()也支持深度查询，例如要获得所有姓张的人去过的省：

     1 p_list = models.Person.objects.filter(name__iexact='张三').prefetch_related('visitation__province').all()
 2 for i in p_list:
 3     for city in i.visitation.all():
 4         print(city.province.name)
 5 '''
 6 result:
 7     湖北省
 8     湖北省
 9     广东省
10     广东省
11 '''
    Code
    1 (0.001) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person` WHERE `person`.`name` LIKE '张三'; args=('张三',)
2 (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,)
3 (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查询：

     1 plist = models.Person.objects.prefetch_related('visitation')
 2 l = [p.visitation.filter(name__icontains=u"市") for p in plist]
 3 for i in l:
 4     for j in i:
 5         print(j.name)
 6 '''
 7 result:
 8     武汉市
 9     孝感市
10     广州市
11     深圳市
12 '''
    Code
    1 (0.000) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person`; args=()
2 (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,)
3 (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中完成这部分操作：

    1 plist = models.Person.objects.prefetch_related('visitation')
2 [[print(city.name) for city in p.visitation.all() if u"市" in city.name] for p in plist]
3 '''
4 result:
5     武汉市
6     孝感市
7     广州市
8     深圳市
9 '''
    Code
    1 (0.001) SELECT `person`.`id`, `person`.`name`, `person`.`hometown_id`, `person`.`living_id` FROM `person`; args=()
2 (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是相同的。
posted @ 2018-05-15 20:34  zze  阅读(201)  评论(0)  编辑  收藏  举报