python框架之Django(6)-查詢優化之select_related&prefetch_related

時間 2019-11-07

標籤 python 框架 django 查詢優化 select related&prefetch related prefetch 欄目 Python 简体版

原文原文鏈接

準備

定義以下模型

 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表：

初始數據以下：

示例模型是用來記錄各我的的故鄉、居住地、以及到過的城市。sql

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查詢。django

已優化

 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() 接受可變長參數，每一個參數是須要獲取的外鍵（父表的內容）的字段名，以及外鍵的外鍵的字段名、外鍵的外鍵的外鍵...。若要選擇外鍵的外鍵須要使用兩個下劃線「__」來鏈接。例如咱們要得到張三的現居省份，能夠用以下方式：ide

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：

若是不指定外鍵，就會進行兩次查詢。若是深度更深，查詢的次數更多。fetch

無參

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

注意：spa

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,)