4.一些实例

如果我们想要获得所有家乡是湖北的人，最无脑的做法是先获得湖北省，再获得湖北的所有城市，最后获得故乡是这个城市的人。就像这样：
1
2
3
4
5
>>> hb = Province.objects.get(name__iexact=u"湖北省")
>>> people = []
>>> for city in hb.city_set.all():
...   people.extend(city.birth.all())
...

显然这不是一个明智的选择，因为这样做会导致1+（湖北省城市数）次SQL查询。反正是个反例，导致的查询和获得掉结果就不列出来了。
prefetch_related() 或许是一个好的解决方法，让我们来看看。
1
2
3
4
5
>>> hb = Province.objects.prefetch_related("city_set__birth").objects.get(name__iexact=u"湖北省")
>>> people = []
>>> for city in hb.city_set.all():
...   people.extend(city.birth.all())
...

因为是一个深度为2的prefetch，所以会导致3次SQL查询：
1
2
3
4
5
6
7
8
9
10
11
12
SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name`
FROM `QSOptimize_province`
WHERE `QSOptimize_province`.`name` LIKE '湖北省' ;
SELECT `QSOptimize_city`.`id`, `QSOptimize_city`.`name`, `QSOptimize_city`.`province_id`
FROM `QSOptimize_city`
WHERE `QSOptimize_city`.`province_id` IN (1);
SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, `QSOptimize_person`.`lastname`,
`QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id`
FROM `QSOptimize_person`
WHERE `QSOptimize_person`.`hometown_id` IN (1, 3);

嗯…看上去不错，但是3次查询么？倒过来查询可能会更简单？
1
>>> people = list(Person.objects.select_related("hometown__province").filter(hometown__province__name__iexact=u"湖北省"))
1
2
3
4
5
6
7
SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, `QSOptimize_person`.`lastname`,
`QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id`, `QSOptimize_city`.`id`,
`QSOptimize_city`.`name`, `QSOptimize_city`.`province_id`, `QSOptimize_province`.`id`, `QSOptimize_province`.`name`
FROM `QSOptimize_person`
INNER JOIN `QSOptimize_city` ON (`QSOptimize_person`.`hometown_id` = `QSOptimize_city`.`id`)
INNER JOIN `QSOptimize_province` ON (`QSOptimize_city`.`province_id` = `QSOptimize_province`.`id`)
WHERE `QSOptimize_province`.`name` LIKE '湖北省';

1
2
3
4
5
6
7
8
+----+-----------+----------+-------------+-----------+----+--------+-------------+----+--------+
| id | firstname | lastname | hometown_id | living_id | id | name   | province_id | id | name   |
+----+-----------+----------+-------------+-----------+----+--------+-------------+----+--------+
|  1 | 张        | 三       |           3 |         1 |  3 | 十堰市 |           1 |  1 | 湖北省 |
|  2 | 李        | 四       |           1 |         3 |  1 | 武汉市 |           1 |  1 | 湖北省 |
|  3 | 王        | 麻子     |           3 |         2 |  3 | 十堰市 |           1 |  1 | 湖北省 |
+----+-----------+----------+-------------+-----------+----+--------+-------------+----+--------+
3 rows in set (0.00 sec)

完全没问题。不仅SQL查询的数量减少了，python程序上也精简了。
select_related()的效率要高于prefetch_related()。因此，最好在能用select_related()的地方尽量使用它，也就是说，对于ForeignKey字段，避免使用prefetch_related()。

联用

对于同一个QuerySet，你可以同时使用这两个函数。
在我们一直使用的例子上加一个model：Order （订单）
1
2
3
4
5
6
class Order(models.Model):
    customer   = models.ForeignKey(Person)
    orderinfo  = models.CharField(max_length=50)
    time       = models.DateTimeField(auto_now_add = True)
    def __unicode__(self):
        return self.orderinfo

如果我们拿到了一个订单的id 我们要知道这个订单的客户去过的省份。因为有ManyToManyField显然必须要用prefetch_related()。如果只用prefetch_related()会怎样呢？
1
2
3
4
>>> plist = Order.objects.prefetch_related('customer__visitation__province').get(id=1)
>>> for city in plist.customer.visitation.all():
...   print city.province.name
...

显然，关系到了4个表：Order、Person、City、Province，根据prefetch_related()的特性就得有4次SQL查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
SELECT `QSOptimize_order`.`id`, `QSOptimize_order`.`customer_id`, `QSOptimize_order`.`orderinfo`, `QSOptimize_order`.`time`
FROM `QSOptimize_order`
WHERE `QSOptimize_order`.`id` = 1 ;
SELECT `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, `QSOptimize_person`.`lastname`, `QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id`
FROM `QSOptimize_person`
WHERE `QSOptimize_person`.`id` IN (1);
SELECT (`QSOptimize_person_visitation`.`person_id`) AS `_prefetch_related_val`, `QSOptimize_city`.`id`,
`QSOptimize_city`.`name`, `QSOptimize_city`.`province_id`
FROM `QSOptimize_city`
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`)
WHERE `QSOptimize_person_visitation`.`person_id` IN (1);
SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name`
FROM `QSOptimize_province`
WHERE `QSOptimize_province`.`id` IN (1, 2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
+----+-------------+---------------+---------------------+
| id | customer_id | orderinfo     | time                |
+----+-------------+---------------+---------------------+
|  1 |           1 | Info of Order | 2014-08-10 17:05:48 |
+----+-------------+---------------+---------------------+
1 row in set (0.00 sec)
+----+-----------+----------+-------------+-----------+
| id | firstname | lastname | hometown_id | living_id |
+----+-----------+----------+-------------+-----------+
|  1 | 张        | 三       |           3 |         1 |
+----+-----------+----------+-------------+-----------+
1 row in set (0.00 sec)
+-----------------------+----+--------+-------------+
| _prefetch_related_val | id | name   | province_id |
+-----------------------+----+--------+-------------+
|                     1 |  1 | 武汉市 |           1 |
|                     1 |  2 | 广州市 |           2 |
|                     1 |  3 | 十堰市 |           1 |
+-----------------------+----+--------+-------------+
3 rows in set (0.00 sec)
+----+--------+
| id | name   |
+----+--------+
|  1 | 湖北省 |
|  2 | 广东省 |
+----+--------+
2 rows in set (0.00 sec)

更好的办法是先调用一次select_related()再调用prefetch_related()，最后再select_related()后面的表

1
2
3
4
>>> plist = Order.objects.select_related('customer').prefetch_related('customer__visitation__province').get(id=1)
>>> for city in plist.customer.visitation.all():
...   print city.province.name
...

这样只会有3次SQL查询，Django会先做select_related，之后prefetch_related的时候会利用之前缓存的数据，从而避免了1次额外的SQL查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
SELECT `QSOptimize_order`.`id`, `QSOptimize_order`.`customer_id`, `QSOptimize_order`.`orderinfo`, 
`QSOptimize_order`.`time`, `QSOptimize_person`.`id`, `QSOptimize_person`.`firstname`, 
`QSOptimize_person`.`lastname`, `QSOptimize_person`.`hometown_id`, `QSOptimize_person`.`living_id` 
FROM `QSOptimize_order` 
INNER JOIN `QSOptimize_person` ON (`QSOptimize_order`.`customer_id` = `QSOptimize_person`.`id`) 
WHERE `QSOptimize_order`.`id` = 1 ;
SELECT (`QSOptimize_person_visitation`.`person_id`) AS `_prefetch_related_val`, `QSOptimize_city`.`id`, 
`QSOptimize_city`.`name`, `QSOptimize_city`.`province_id` 
FROM `QSOptimize_city` 
INNER JOIN `QSOptimize_person_visitation` ON (`QSOptimize_city`.`id` = `QSOptimize_person_visitation`.`city_id`) 
WHERE `QSOptimize_person_visitation`.`person_id` IN (1);
SELECT `QSOptimize_province`.`id`, `QSOptimize_province`.`name` 
FROM `QSOptimize_province` 
WHERE `QSOptimize_province`.`id` IN (1, 2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
+----+-------------+---------------+---------------------+----+-----------+----------+-------------+-----------+
| id | customer_id | orderinfo     | time                | id | firstname | lastname | hometown_id | living_id |
+----+-------------+---------------+---------------------+----+-----------+----------+-------------+-----------+
|  1 |           1 | Info of Order | 2014-08-10 17:05:48 |  1 | 张        | 三       |           3 |         1 |
+----+-------------+---------------+---------------------+----+-----------+----------+-------------+-----------+
1 row in set (0.00 sec)
+-----------------------+----+--------+-------------+
| _prefetch_related_val | id | name   | province_id |
+-----------------------+----+--------+-------------+
|                     1 |  1 | 武汉市 |           1 |
|                     1 |  2 | 广州市 |           2 |
|                     1 |  3 | 十堰市 |           1 |
+-----------------------+----+--------+-------------+
3 rows in set (0.00 sec)
+----+--------+
| id | name   |
+----+--------+
|  1 | 湖北省 |
|  2 | 广东省 |
+----+--------+
2 rows in set (0.00 sec)

值得注意的是，可以在调用prefetch_related之前调用select_related，并且Django会按照你想的去做：先select_related，然后利用缓存到的数据prefetch_related。然而一旦prefetch_related已经调用，select_related将不起作用。

小结

  1. 因为select_related()总是在单次SQL查询中解决问题，而prefetch_related()会对每个相关表进行SQL查询，因此select_related()的效率通常比后者高。
  2. 鉴于第一条，尽可能的用select_related()解决问题。只有在select_related()不能解决问题的时候再去想prefetch_related()。
  3. 你可以在一个QuerySet中同时使用select_related()和prefetch_related()，从而减少SQL查询的次数。
  4. 只有prefetch_related()之前的select_related()是有效的，之后的将会被无视掉。

转载于:https://www.cnblogs.com/Edifier-7/p/5381639.html

Django的 select_related 和 prefetch_related 函数对 QuerySet 查询的优化（三）相关推荐

  1. Django的 select_related 和 prefetch_related 函数对 QuerySet 查询的优化（二）

    3. prefetch_related() 对于多对多字段(ManyToManyField)和一对多字段,可以使用prefetch_related()来进行优化.或许你会说,没有一个叫OneToMan ...

  2. 实例具体解释Django的 select_related 和 prefetch_related 函数对 QuerySet 查询的优化（二）...

    这是本系列的第二篇,内容是 prefetch_related() 函数的用途.实现途径.以及用法. 本系列的第一篇在这里 第三篇在这里 3. prefetch_related() 对于多对多字段(Ma ...

  3. Django ORM相关操作 select_related和prefetch_related函数对 QuerySet 查询的优化

    在数据库存在外键的其情况下,使用select_related()和prefetch_related()很大程度上减少对数据库的请求次数以提高性能 主要思想就是 '当我们在表中查找一个数据项的时候,我们 ...

  4. Python-Django框架的select_related 和 prefetch_related函数对 QuerySet 查询的优化

    概念: select_related()当执行它的查询时它沿着外键关系查询关联的对象数据.它会生成一个复杂的查询并引起性能的消耗,但是在以后使用外键关系时将不需要数据库查询. prefetch_rel ...

  5. select_related与prefetch_related django ORM查询速度优化

    深入select_related与prefetch_related函数 原文:https://www.cnblogs.com/tuifeideyouran/p/4232028.html 在数据库有外键 ...

  6. Django中的prefetch_related()函数优化

    对于多对多字段(ManyToManyField)和一对多字段, 可以使用prefetch_related()来进行优化 prefetch_related()和select_related()的设计目的 ...

  7. Django中prefetch_related()函数优化实战指南

    对于多对多字段(ManyToManyField)和一对多字段, 可以使用prefetch_related()来进行优化 prefetch_related()和select_related()的设计目的 ...

  8. python---django中orm的使用（5）数据库的基本操作(性能相关：select_related,和prefetch_related重点)（以及事务操作）...

    ################################################################## # PUBLIC METHODS THAT ALTER ATTRI ...

  9. union和union all有什么区别_Django基础(29)：select_related和prefetch_related的用法与区别...

    在前面教程中小编我已经介绍了Django的Queryset特性及高级使用技巧以及Queryset的aggregate和annotate方法.这些技巧和方法都是为了减少对数据库的访问次数和对内存的占用, ...

最新文章

  1. Ⅶ：教你一招利用zookeeper作为服务的配置中心
  2. HTML-通知公告Tips
  3. html去除分页符,Word如何取消分页符
  4. cocos2d-x游戏开发 跑酷(四) 关联与物理世界
  5. app inventor离线版_百度要哭了！今日头条出了搜索引擎了，还做了APP
  6. php mysql 查询数据出现连接重置_php使用mysql和mysqli连接查询数据
  7. n进制快速转化成10进制
  8. python编程入门电子书-Python编程基础 PDF 原书高质量版
  9. Android平台开发职位招聘要求总结
  10. not optimal php,PHP错误提示It is not safe to rely on the system……的解决方法
  11. 企业便携计算机，丢失、被盗如何远程将设备还原为出厂默认设置删除所有数据
  12. 58子站安居，经纪人营销管理平台登录接口加密逆向
  13. android studio闹钟小程序,闹钟应用程序Android Studio
  14. CF 1606E Arena
  15. 如何将图片上的文字识别成可修改的文本
  16. “直接基于成本法”与“模拟权益法”两种合并报表模式比较与分析：响应新准则
  17. PWN入门（3）覆盖堆栈上的变量
  18. java丐帮_java多线程学习笔记（三）
  19. ctf.showCMS(web477-web478)
  20. 素描滤镜_素描fu依次导出画板

热门文章

  1. yuv420(planer) to bgr24 to bmp
  2. html设置json请求头,当我想在zf2客户端代码中使用“application/json”时，接受请求标头是“text/html，application/xhtm ...（etc）”...
  3. 理解有参构造器和无参构造器的作用
  4. signature=fa342ee2b7c3e3e9cba3f194df2d59ca,Date of Signature
  5. html表单中按钮添加超链接,JS 实现点击按钮实现超链接功能
  6. 静态属性、类方法、静态方法
  7. css 奇淫技巧 行内快 父级padding 子级margin 抵消
  8. JavaScript学习---JavaScript基础知识
  9. iPad开发（Universal Applications）
  10. 个人看法---团队合作