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

准备

定义如下模型

 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是相同的。