前言
面试材料、经验总结，开发技巧，更多干货内容在：https://github.com/dvsusan/susanSayJava
sql优化是一个大家都比拟关注的热门话题，无论你在面试，还是工作中，都很有可能会遇到。
如果某天你负责的某个线上接口，呈现了性能问题，须要做优化。那么你首先想到的很有可能是优化sql语句，因为它的革新老本绝对于代码来说也要小得多。
那么，如何优化sql语句呢？
这篇文章从15个方面，分享了sql优化的一些小技巧，心愿对你有所帮忙。
1 防止应用select *
很多时候，咱们写sql语句时，为了不便，喜爱间接应用select *，一次性查出表中所有列的数据。
反例：
select * from user where id=1;在理论业务场景中，可能咱们真正须要应用的只有其中一两列。查了很多数据，然而不必，白白浪费了数据库资源，比方：内存或者cpu。
此外，多查出来的数据，通过网络IO传输的过程中，也会减少数据传输的工夫。
还有一个最重要的问题是：select *不会走笼罩索引，会呈现大量的回表操作，而从导致查问sql的性能很低。
那么，如何优化呢？
正例：
select name,age from user where id=1;sql语句查问时，只查须要用到的列，多余的列基本无需查出来。
2 用union all代替union
咱们都晓得sql语句应用union关键字后，能够获取排重后的数据。
而如果应用union all关键字，能够获取所有数据，蕴含反复的数据。
反例：
(select * from user where id=1) union (select * from user where id=2);排重的过程须要遍历、排序和比拟，它更耗时，更耗费cpu资源。
所以如果能用union all的时候，尽量不必union。
正例：
(select * from user where id=1) union all(select * from user where id=2);除非是有些非凡的场景，比方union all之后，后果集中呈现了反复数据，而业务场景中是不容许产生反复数据的，这时能够应用union。
3 小表驱动大表
小表驱动大表，也就是说用小表的数据集驱动大表的数据集。
如果有order和user两张表，其中order表有10000条数据，而user表有100条数据。
这时如果想查一下，所有无效的用户下过的订单列表。
能够应用in关键字实现：
select * from orderwhere user_id in (select id from user where status=1)也能够应用exists关键字实现：
select * from orderwhere exists (select 1 from user where order.user_id = user.id and status=1)后面提到的这种业务场景，应用in关键字去实现业务需要，更加适合。
为什么呢？
因为如果sql语句中蕴含了in关键字，则它会优先执行in外面的子查问语句，而后再执行in里面的语句。如果in外面的数据量很少，作为条件查问速度更快。
而如果sql语句中蕴含了exists关键字，它优先执行exists右边的语句（即主查问语句）。而后把它作为条件，去跟左边的语句匹配。如果匹配上，则能够查问出数据。如果匹配不上，数据就被过滤掉了。
这个需要中，order表有10000条数据，而user表有100条数据。order表是大表，user表是小表。如果order表在右边，则用in关键字性能更好。
总结一下：
in实用于右边大表，左边小表。exists实用于右边小表，左边大表。
不论是用in，还是exists关键字，其核心思想都是用小表驱动大表。
4 批量操作
如果你有一批数据通过业务解决之后，须要插入数据，该怎么办？
反例：
for(Order order: list){ orderMapper.insert(order):}在循环中逐条插入数据。
insert into order(id,code,user_id) values(123,'001',100);该操作须要屡次申请数据库，能力实现这批数据的插入。
但家喻户晓，咱们在代码中，每次近程申请数据库，是会耗费肯定性能的。而如果咱们的代码须要申请屡次数据库，能力实现本次业务性能，势必会耗费更多的性能。
那么如何优化呢？
正例：
orderMapper.insertBatch(list):提供一个批量插入数据的办法。
insert into order(id,code,user_id) values(123,'001',100),(124,'002',100),(125,'003',101);这样只须要近程申请一次数据库，sql性能会失去晋升，数据量越多，晋升越大。
但须要留神的是，不倡议一次批量操作太多的数据，如果数据太多数据库响应也会很慢。批量操作须要把握一个度，倡议每批数据尽量管制在500以内。如果数据多于500，则分多批次解决。
5 多用limit
有时候，咱们须要查问某些数据中的第一条，比方：查问某个用户下的第一个订单，想看看他第一次的首单工夫。
反例：
select id, create_date from order where user_id=123 order by create_date asc;依据用户id查问订单，按下单工夫排序，先查出该用户所有的订单数据，失去一个订单汇合。 而后在代码中，获取第一个元素的数据，即首单的数据，就能获取首单工夫。
List<Order> list = orderMapper.getOrderList();Order order = list.get(0);虽说这种做法在性能上没有问题，但它的效率十分不高，须要先查问出所有的数据，有点浪费资源。
那么，如何优化呢？
正例：
select id, create_date from order where user_id=123 order by create_date asc limit 1;应用limit 1，只返回该用户下单工夫最小的那一条数据即可。
此外，在删除或者批改数据时，为了避免误操作，导致删除或批改了不相干的数据，也能够在sql语句最初加上limit。
例如：
update order set status=0,edit_time=now(3) where id>=100 and id<200 limit 100;这样即便误操作，比方把id搞错了，也不会对太多的数据造成影响。
6 in中值太多
对于批量查问接口，咱们通常会应用in关键字过滤出数据。比方：想通过指定的一些id，批量查问出用户信息。
sql语句如下：
select id,name from categorywhere id in (1,2,3...100000000);如果咱们不做任何限度，该查问语句一次性可能会查问出十分多的数据，很容易导致接口超时。
这时该怎么办呢？
select id,name from categorywhere id in (1,2,3...100)limit 500;能够在sql中对数据用limit做限度。
不过咱们更多的是要在业务代码中加限度，伪代码如下：
public List<Category> getCategory(List<Long> ids) { if(CollectionUtils.isEmpty(ids)) { return null; } if(ids.size() > 500) { throw new BusinessException("一次最多容许查问500条记录") } return mapper.getCategoryList(ids);}还有一个计划就是：如果ids超过500条记录，能够分批用多线程去查问数据。每批只查500条记录，最初把查问到的数据汇总到一起返回。
不过这只是一个长期计划，不适宜于ids切实太多的场景。因为ids太多，即便能疾速查出数据，但如果返回的数据量太大了，网络传输也是十分耗费性能的，接口性能始终好不到哪里去。
7 增量查问
有时候，咱们须要通过近程接口查问数据，而后同步到另外一个数据库。
反例：
select * from user;如果间接获取所有的数据，而后同步过来。这样虽说十分不便，然而带来了一个十分大的问题，就是如果数据很多的话，查问性能会十分差。
这时该怎么办呢？
正例：
select * from user where id>#{lastId} and create_time >= #{lastCreateTime} limit 100;按id和工夫升序，每次只同步一批数据，这一批数据只有100条记录。每次同步实现之后，保留这100条数据中最大的id和工夫，给同步下一批数据的时候用。
通过这种增量查问的形式，可能晋升单次查问的效率。
8 高效的分页
有时候，列表页在查问数据时，为了防止一次性返回过多的数据影响接口性能，咱们个别会对查问接口做分页解决。
在mysql中分页个别用的limit关键字：
select id,name,age from user limit 10,20;如果表中数据量少，用limit关键字做分页，没啥问题。但如果表中数据量很多，用它就会呈现性能问题。
比方当初分页参数变成了：
select id,name,age from user limit 1000000,20;mysql会查到1000020条数据，而后抛弃后面的1000000条，只查前面的20条数据，这个是十分浪费资源的。
那么，这种海量数据该怎么分页呢？
优化sql：
select id,name,age from user where id > 1000000 limit 20;先找到上次分页最大的id，而后利用id上的索引查问。不过该计划，要求id是间断的，并且有序的。
还能应用between优化分页。
select id,name,age from user where id between 1000000 and 1000020;须要留神的是between要在惟一索引上分页，不然会呈现每页大小不统一的问题。
9 用连贯查问代替子查问
mysql中如果须要从两张以上的表中查问出数据的话，个别有两种实现形式：子查问 和 连贯查问。
子查问的例子如下：
select * from orderwhere user_id in (select id from user where status=1)子查问语句能够通过in关键字实现，一个查问语句的条件落在另一个select语句的查问后果中。程序先运行在嵌套在最内层的语句，再运行外层的语句。
子查问语句的长处是简略，结构化，如果波及的表数量不多的话。
但毛病是mysql执行子查问时，须要创立长期表，查问结束后，须要再删除这些长期表，有一些额定的性能耗费。
这时能够改成连贯查问。 具体例子如下：
select o.* from order oinner join user u on o.user_id = u.idwhere u.status=110 join的表不宜过多
依据阿里巴巴开发者手册的规定，join表的数量不应该超过3个。
反例：
select a.name,b.name.c.name,d.namefrom a inner join b on a.id = b.a_idinner join c on c.b_id = b.idinner join d on d.c_id = c.idinner join e on e.d_id = d.idinner join f on f.e_id = e.idinner join g on g.f_id = f.id如果join太多，mysql在抉择索引的时候会非常复杂，很容易选错索引。
并且如果没有命中中，nested loop join 就是别离从两个表读一行数据进行两两比照，复杂度是 n^2。
所以咱们应该尽量管制join表的数量。
正例：
select a.name,b.name.c.name,a.d_name from a inner join b on a.id = b.a_idinner join c on c.b_id = b.id如果实现业务场景中须要查问出另外几张表中的数据，能够在a、b、c表中冗余专门的字段，比方：在表a中冗余d_name字段，保留须要查问出的数据。
不过我之前也见过有些ERP零碎，并发量不大，但业务比较复杂，须要join十几张表能力查问出数据。
所以join表的数量要依据零碎的理论状况决定，不能一概而论，尽量越少越好。
11 join时要留神
咱们在波及到多张表联结查问的时候，个别会应用join关键字。
而join应用最多的是left join和inner join。
left join：求两个表的交加外加左表剩下的数据。inner join：求两个表交加的数据。
应用inner join的示例如下：
select o.id,o.code,u.name from order o inner join user u on o.user_id = u.idwhere u.status=1;如果两张表应用inner join关联，mysql会主动抉择两张表中的小表，去驱动大表，所以性能上不会有太大的问题。
应用left join的示例如下：
select o.id,o.code,u.name from order o left join user u on o.user_id = u.idwhere u.status=1;如果两张表应用left join关联，mysql会默认用left join关键字右边的表，去驱动它左边的表。如果右边的表数据很多时，就会呈现性能问题。
要特地留神的是在用left join关联查问时，右边要用小表，左边能够用大表。如果能用inner join的中央，尽量少用left join。
12 管制索引的数量
家喻户晓，索引可能显著的晋升查问sql的性能，但索引数量并非越多越好。
因为表中新增数据时，须要同时为它创立索引，而索引是须要额定的存储空间的，而且还会有肯定的性能耗费。
阿里巴巴的开发者手册中规定，单表的索引数量应该尽量管制在5个以内，并且单个索引中的字段数不超过5个。
mysql应用的B+树的构造来保留索引的，在insert、update和delete操作时，须要更新B+树索引。如果索引过多，会耗费很多额定的性能。
那么，问题来了，如果表中的索引太多，超过了5个该怎么办？
这个问题要辩证的看，如果你的零碎并发量不高，表中的数据量也不多，其实超过5个也能够，只有不要超过太多就行。
但对于一些高并发的零碎，请务必恪守单表索引数量不要超过5的限度。
那么，高并发零碎如何优化索引数量？
可能建联结索引，就别建单个索引，能够删除无用的单个索引。
将局部查问性能迁徙到其余类型的数据库中，比方：Elastic Seach、HBase等，在业务表中只须要建几个要害索引即可。
13 抉择正当的字段类型
char示意固定字符串类型，该类型的字段存储空间的固定的，会节约存储空间。
alter table order add column code char(20) NOT NULL;varchar示意变长字符串类型，该类型的字段存储空间会依据理论数据的长度调整，不会节约存储空间。
alter table order add column code varchar(20) NOT NULL;如果是长度固定的字段，比方用户手机号，个别都是11位的，能够定义成char类型，长度是11字节。
但如果是企业名称字段，如果定义成char类型，就有问题了。
如果长度定义得太长，比方定义成了200字节，而理论企业长度只有50字节，则会节约150字节的存储空间。
如果长度定义得太短，比方定义成了50字节，但理论企业名称有100字节，就会存储不下，而抛出异样。
所以倡议将企业名称改成varchar类型，变长字段存储空间小，能够节俭存储空间，而且对于查问来说，在一个绝对较小的字段内搜寻效率显然要高些。
咱们在抉择字段类型时，应该遵循这样的准则：
- 能用数字类型，就不必字符串，因为字符的解决往往比数字要慢。
- 尽可能应用小的类型，比方：用bit存布尔值，用tinyint存枚举值等。
- 长度固定的字符串字段，用char类型。
- 长度可变的字符串字段，用varchar类型。
- 金额字段用decimal，防止精度失落问题。
还有很多准则，这里就不一一列举了。
14 晋升group by的效率
咱们有很多业务场景须要应用group by关键字，它次要的性能是去重和分组。
通常它会跟having一起配合应用，示意分组后再依据肯定的条件过滤数据。
反例：
select user_id,user_name from ordergroup by user_idhaving user_id <= 200;这种写法性能不好，它先把所有的订单依据用户id分组之后，再去过滤用户id大于等于200的用户。
分组是一个绝对耗时的操作，为什么咱们不先放大数据的范畴之后，再分组呢？
正例：
select user_id,user_name from orderwhere user_id <= 200group by user_id应用where条件在分组前，就把多余的数据过滤掉了，这样分组时效率就会更高一些。
其实这是一种思路，不仅限于group by的优化。咱们的sql语句在做一些耗时的操作之前，应尽可能放大数据范畴，这样能晋升sql整体的性能。
15 索引优化
sql优化当中，有一个十分重要的内容就是：索引优化。
很多时候sql语句，走了索引，和没有走索引，执行效率差异很大。所以索引优化被作为sql优化的首选。
索引优化的第一步是：查看sql语句有没有走索引。
那么，如何查看sql走了索引没？
能够应用explain命令，查看mysql的执行打算。
例如：
explain select * from `order` where code='002';后果：
通过这几列能够判断索引应用状况，执行打算蕴含列的含意如下图所示：
如果你想进一步理解explain的具体用法，能够看看我的另一篇文章《explain | 索引优化的这把绝世好剑，你真的会用吗？》
说实话，sql语句没有走索引，排除没有建索引之外，最大的可能性是索引生效了。
上面说说索引生效的常见起因：
如果不是下面的这些起因，则须要再进一步排查一下其余起因。
此外，你有没有遇到过这样一种状况：明明是同一条sql，只有入参不同而已。有的时候走的索引a，有的时候却走的索引b？
没错，有时候mysql会选错索引。
必要时能够应用force index来强制查问sql走某个索引。
至于为什么mysql会选错索引，前面有专门的文章介绍的，这里先留点悬念。
最初说一句(求关注，别白嫖我)
如果这篇文章对您有所帮忙，或者有所启发的话，帮忙扫描下发二维码关注一下，您的反对是我保持写作最大的能源。
求一键三连：点赞、转发、在看。
关注公众号：【苏三说技术】，在公众号中回复：面试、代码神器、开发手册、工夫治理有超赞的粉丝福利，另外回复：加群，能够跟很多BAT大厂的前辈交换和学习。