干货！SQL性能优化，书写高质量SQL语句

写SQL语句的时候咱们每每关注的是SQL的执行结果，可是是否真的关注了SQL的执行效率，是否注意了SQL的写法规范？

如下的干货分享是在实际开发过程当中总结的，但愿对你们有所帮助！

1. limit分页优化

当偏移量特别大时，limit效率会很是低。

SELECT id FROM A LIMIT 1000,10 很快

SELECT id FROM A LIMIT 90000,10 很慢

方案一：

select id from A order by id limit 90000,10;
复制代码

若是咱们结合order by使用。很快，0.04秒就OK。 由于使用了id主键作索引！固然，是否可以使用索引还须要根据业务逻辑来定，这里只是为了提醒你们，在分页的时候还需谨慎使用！

方案二

select id from A order by id  between 90000 and 90010;
复制代码

2.利用limit 1 、top 1 取得一行

有些业务逻辑进行查询操做时(特别是在根据某一字段DESC,取最大一笔).可使用limit 1 或者 top 1 来终止[数据库索引]继续扫描整个表或索引。

反例

SELECT id FROM A LIKE 'abc%' 
复制代码

正例

SELECT id FROM A LIKE 'abc%' limit 1
复制代码

3. 任何状况都不要用 select * from table ，用具体的字段列表替换"*"，不要返回用不到的字段,避免全盘扫描！

反例

SELECT * FROM A
复制代码

正例

SELECT id FROM A 
复制代码

4. 批量插入优化

反例

INSERT into person(name,age) values('A',24)
INSERT into person(name,age) values('B',24)
INSERT into person(name,age) values('C',24)
复制代码

正例

INSERT into person(name,age) values('A',24),('B',24),('C',24),
复制代码

sql语句的优化主要在于对索引的正确使用，而咱们在开发中常常犯的错误即是对表进行全盘扫描，一来影响性能，而来耗费时间!

5.like语句的优化

反例

SELECT id FROM A WHERE name like '%abc%'
复制代码

因为abc前面用了“%”，所以该查询必然走全表查询,除非必要(模糊查询须要包含abc)，不然不要在关键词前加%

正例

SELECT id FROM A WHERE name like 'abc%'
复制代码

实例

mysql版本：5.7.26

select nick_name from member where nick_name like '%小明%'
复制代码

like'%小明%' 并未使用索引！

select nick_name from member where nick_name like '小明%'
复制代码

like'小明%' 成功使用索引！

6.where子句使用or的优化

一般使用 union all 或 union 的方式替换“or”会获得更好的效果。where子句中使用了or关键字,索引将被放弃使用。

反例

SELECT id FROM A WHERE num = 10 or num = 20
复制代码

正例

SELECT id FROM A WHERE num = 10 union all SELECT id FROM A WHERE num=20

复制代码

7.where子句中使用 IS NULL 或 IS NOT NULL 的优化

反例

SELECT id FROM A WHERE num IS NULL
复制代码

在where子句中使用 IS NULL 或 IS NOT NULL 判断，索引将被放弃使用，会进行全表查询。

正例

优化成num上设置默认值0，确保表中num没有null值, IS NULL 的用法在实际业务场景下SQL使用率极高，咱们应注意避免全表扫描

SELECT id FROM A WHERE num=0
复制代码

8.where子句中对字段进行表达式操做的优化

不要在where子句中的“=”左边进行函数、算数运算或其余表达式运算，不然系统将可能没法正确使用索引。

• 1

SELECT id FROM A WHERE datediff(day,createdate,'2019-11-30')=0 
复制代码

优化为

SELECT id FROM A WHERE createdate>='2019-11-30' and createdate<'2019-12-1'
复制代码

• 2

SELECT id FROM A WHERE year(addate) <2020
复制代码

优化为

SELECT id FROM A where addate<'2020-01-01'
复制代码

9.排序的索引问题 

mysql查询只是用一个索引，所以若是where子句中已经使用了索引的话，那么order by中的列是不会使用索引。所以数据库默认排序能够符合要求状况下不要使用排序操做；

尽可能不要包含多个列的排序，若是须要最好给这些列建立复合索引。

10. 尽可能用 union all 替换 union

union和union all的差别主要是前者须要将两个（或者多个）结果集合并后再进行惟一性过滤操做，这就会涉及到排序，增长大量的cpu运算，加大资源消耗及延迟。因此当咱们能够确认不可能出现重复结果集或者不在意重复结果集的时候，尽可能使用union all而不是union

11.Inner join 和 left join、right join、子查询

• 第一：inner join内链接也叫等值链接是，left/rightjoin是外链接。

SELECT A.id,A.name,B.id,B.name FROM A LEFT JOIN B ON A.id =B.id;

SELECT A.id,A.name,B.id,B.name FROM A RIGHT JOIN ON B A.id= B.id;

SELECT A.id,A.name,B.id,B.name FROM A INNER JOIN ON A.id =B.id;
复制代码

通过来之多方面的证明 inner join性能比较快，由于inner join是等值链接，或许返回的行数比较少。可是咱们要记得有些语句隐形的用到了等值链接，如：

SELECT A.id,A.name,B.id,B.name FROM A,B WHERE A.id = B.id;

推荐：能用inner join链接尽可能使用inner join链接

• 第二：子查询的性能又比外链接性能慢，尽可能用外链接来替换子查询。

反例

mysql是先对外表A执行全表查询，而后根据uuid逐次执行子查询，若是外层表是一个很大的表，咱们能够想象查询性能会表现比这个更加糟糕。

Select* from A where exists (select * from B where id>=3000 and A.uuid=B.uuid);
复制代码

执行时间：2s左右

正例

Select* from A inner join B ON A.uuid=B.uuid where b.uuid>=3000;  这个语句执行测试不到一秒；
复制代码

执行时间：1s不到

• 第三：使用JOIN时候，应该用小的结果驱动大的结果

left join 左边表结果尽可能小，若是有条件应该放到左边先处理，right join同理反向。如：

反例

Select * from A left join B A.id=B.ref_id where  A.id>10
复制代码

正例

select * from (select * from A wehre id >10) T1 left join B on T1.id=B.ref_id;
复制代码

12.exist & in 优化

SELECT * from A WHERE id in ( SELECT id from B )
复制代码

SELECT * from A WHERE id EXISTS ( SELECT 1 from A.id= B.id )
复制代码

分析:

in 是在内存中遍历比较

exist 须要查询数据库，因此当B的数据量比较大时，exists效率优于in**

in()只执行一次，把B表中的全部id字段缓存起来，以后检查A表的id是否与B表中的id相等，若是id相等则将A表的记录加入到结果集中，直到遍历完A表的全部记录。

In 操做的流程原理如同一下代码

List resultSet={};

    Array A=(select * from A);
    Array B=(select id from B);

    for(int i=0;i<A.length;i++) {
          for(int j=0;j<B.length;j++) {
          if(A[i].id==B[j].id) {
             resultSet.add(A[i]);
             break;
          }
       }
    }
    return resultSet;
复制代码

能够看出，当B表数据较大时不适合使用in()，由于会把B表数据所有遍历一次

如：A表有10000条记录，B表有1000000条记录，那么最多有可能遍历10000*1000000次，效率不好。

再如：A表有10000条记录，B表有100条记录，那么最多有可能遍历10000*100次，遍历次数大大减小，效率大大提高。

  结论：in()适合B表比A表数据小的状况

exist()会执行A.length()次，执行过程代码以下

List resultSet={};
Array A=(select * from A);
for(int i=0;i<A.length;i++) {
    if(exists(A[i].id) {  //执行select 1 from B where B.id=A.id是否有记录返回
       resultSet.add(A[i]);
    }
}return resultSet;
复制代码

当B表比A表数据大时适合使用exists()，由于它没有那么多遍历操做，只须要再执行一次查询就行。

如：A表有10000条记录，B表有1000000条记录，那么exists()会执行10000次去判断A表中的id是否与B表中的id相等。

如：A表有10000条记录，B表有100000000条记录，那么exists()仍是执行10000次，由于它只执行A.length次，可见B表数据越多，越适合exists()发挥效果。

再如：A表有10000条记录，B表有100条记录，那么exists()仍是执行10000次，还不如使用in()遍历10000*100次，由于in()是在内存里遍历比较，而exists()须要查询数据库，

咱们都知道查询数据库所消耗的性能更高，而内存比较很快。   

结论：exists()适合B表比A表数据大的状况