如何高性能地使用django的orm

         在我的上一篇文章中《关于django项目是否要使用外键》中总结过，对于小系统，是建议大家尽量地使用外键，因为它的易用性和便利性；对于大系统，最好不要使用外键，因为要考虑到系统的性能，可移植性等。同时引出了如何高性能地使用orm的问题，我下面会对小系统（使用外键）和大系统（不使用外键）的情况下如何使用orm的问题进行说明分析。

         django的orm是非常强大的，它把数据库相关的操作都隔离了开来，让我们能够像访问普通的变量一样去访问数据库的数据，所以django是非常适合新手来使用，功能足够强大。当时orm也带来很多问题，过于高度的封装，忽略了效率，导致执行效率很差，所以如何使用高效地orm也是很重要的。一般来说，我们的接口都是不外乎是一个数据表的’增删查改‘，所以我就分别对这几个操作进行例子化分。

 

先假设表 t_table1, 拥有一个外键a

1. 查: 这里可以分为  单个数据查询， 以及 列表查询

1.1 单个数据查询： 

通常的代码是  object =  t_table1.objects.filter(id=1).first()

在我们执行了这句代码之后，获取到object对象，它实际上执行的sql语句并不是一句，而是2句：

select * from table1 where id=id

select * from a where id=id

 

从sql的效果来看，这个效率很低，其实这2句sql语句可以优化为一句，利用连表的形式进行多表查询。

上面代码可以优化为这样：object =  t_table1.objects.select_related().filter(id=1).first()

加了一个select_related(),  那么实际执行的sql语句就变成了

select * from table1 

     INNER JOIN a  on a.id=table1.a_id

where id=id

执行效率会高很多，试想一下，假如这里有10个外键，那么效率提升了就非常大了

 

1.2 列表查询

通常的列表查询的代码：

objects =  t_table1.objects.all()

ret = [ model_to_dict(i) for i in objects]

它实际上执行的sql语句数量是非常庞大的，假如t_table1数据一共有100条，参考上面单个数据数据的执行方式，

它实际的执行是这样的：

for i in range(100):

     select * from table1 where id=id

     select * from a where id=id

这个就是orm的不足，按照上面ret = [ model_to_dict(i) for i in objects] 这句代码，它是每循环一次就执行一次sql语句。

等于执行了200条的sql语句。

如果t_table1 有10000条数据，有10个外键，那么就等于执行了20万条sql语句，简直是不可想象。

优化方案：

把代码改为 

ret =  t_table1.objects.select_related().all().values()

这个values() 这个方法我就不详细说，有兴趣可以查查资料 https://www.cnblogs.com/rgxx/p/10382664.html

改为这样之后，它实际上执行的sql语句是从20万条sql，变成了1条，效率优化非常明显：

select * from table1 

     INNER JOIN a  on a.id=table1.a_id

 

2. 增

新增单个数据，通常的代码是：

t_table1.objects.create(a_id=id)

或者是

object = t_table1()

object.a_id = id

object.save()

 

批量创建：在批量创建数据的时候，使用这种方式就会有效率的问题

假如要创建100个数据：

for i in range(100):

      t_table1.objects.create(a_id=id) 

这样实际上执行的sql语句就会变成了100条：

for i in range(100):

     insert into t_table1(a_id) values(id)

 

优化方案：使用 bulk_create 进行批量创建. https://www.cnblogs.com/ccorz/p/Django-model-zhong-shu-ju-pi-liang-dao-rubulkcreat.html

 

object_list=[]
for i in range(100):

     object = t_table1()

     object.a_id = id
     object_list.append(object) 
t_table1.objects.bulk_create(object_list)

优化后执行的sql语句只有一条，效率提高了不知道多少倍：

insert into t_table1(a_id) values(id1)，(id2), (id3),  (id4),  (id5), .... (id100);

    

3. 删 :

单个数据删除：  

t_table1.objects.filter(id=id).delete()  

或者是

object = t_table1.objects.filter(id=id).first()

object.delete()

 

批量删除：

这里要注意的是，假如需要删除全部数据，参考上面查询的优化项，不要进行循环删除：

objects = t_table1.objects.all()

for i in objects:

    objects.delete()

如果执行这样的代码，会造成执行了非常多的sql语句，假如这样有100条数据，等于执行下面的sql语句

for i in range(100):

     select * from table1 where id=id

     select * from a where id=id

     delete from table1 where id=id

等于执行了300条的sql语句，好恐怖

优化方案：

    t_table1.objects.all().delete 即可， 这样就只是会执行一句的sql语句：

delete from table1 where id=id

 

4. 改：

单个数据修改：  

t_table1.objects.filter(id=id).update(a_id=id)  

或者是

object = t_table1.objects.filter(id=id).first()

object.a_id=id

object.save()

 

批量修改：

这里要注意的是，假如需要批量修改或者修改全部数据，参考上面查询的优化项，不要进行循环修改：

objects = t_table1.objects.all()

for i in objects:

    i.a_id=id

    objects.save()

如果执行这样的代码，会造成执行了非常多的sql语句，假如这样有100条数据，等于执行下面的sql语句

for i in range(100):

     select * from table1 where id=id

     select * from a where id=id

     update table1 set a_id=id where id=id

等于执行了300条的sql语句

优化方案：

    直接使用 t_table1.objects.all().update(a_id=id)  

上面的4个总结是在使用orm的时候比较通用的经验，无论是小系统（有外键）和大系统（无外键）都适用。

 

5. 复杂的查询条件：

对于一个比较成熟的系统来说，肯定会遇到需要非常复杂的搜索条件的需求，例如bug系统中，会有很多筛选项，状态，处理人，创建时间等等。查询条件是一个非常复杂的一个组成。

 

对于拥有外键的小系统来说，这些复杂的条件都可以使用 Q 这个对象来构造查询条件，这里有参考资料：

https://blog.csdn.net/u013009576/article/details/100579056

例如需要查询id > 5 或者是 a的id > 2 的数据;

t_table1.objects.select_related().filter(Q(id>5 | Q(a__id>2))

这里变换为sql语句就是：

select * from table1 

     INNER JOIN a  on a.id=table1.a_id

where id>5 and a.id>2

 

但是对于没有外键的大系统来说，是没法使用Q来构造条件的，因为Q有一种语法是 “__” ，这种是专门用于外键的。

举个例子，上面这句代码

t_table1.objects.select_related().filter(Q(id>5 | Q(a__id>2))，a 这个字段是t_table1的外键，它能够通过 a__xxx,  来访问a对应的表的属性;

比如a, 有一个叫name的字符串的属性，我想筛选t_table1 中 的a 的name等于‘hello’的数据，那么可以这么写：

t_table1.objects.select_related().filter(Q(a__name='hello')

 

但是假如没有外键，我们是不能这么做的，想想假如我们不用外键，会怎么定义t_table1表就明白了，我们会把表定义为：

class t_table1:

      a_id=models.IntegerField()

 

那么这时候我们应该怎么做，想要实现这么复杂的查询，我们只能借助于编写原始sql语句。

https://blog.csdn.net/haeasringnar/article/details/82080476

使用sql语句有两种方式：

1、Manager.raw(raw_query, params=None, translations=None)

刚刚的筛选语句可以改为：
t_table1.objects.raw('

     select * from table1 

            INNER JOIN a  on a.id=table1.a_id

     where id>5 and a.id>2

'):

2. 使用 Executing custom SQL directly

from django.db import connection

def my_custom_sql(self):
    with connection.cursor() as cursor:
    #执行sql语句
        cursor.execute(‘

         select * from table1 

                 INNER JOIN a  on a.id=table1.a_id

         where id>5 and a.id>2

         ’)
    #查出一条数据
        row = cursor.fetchone()
    #查出所有数据
        #row = cursor.fetchall()
    return row

 

所以对于不含外键的大系统，原生的sql语句是没法绕开的一道坎，必须要使用的。

至于含有外键的小系统，只用orm已经足够。

现如今我做的所有大系统都是orm和sql并用的。

我的原则是： 简单查询使用orm，因为足够方便。复杂查询使用sql语句，因为足够强大。