1、避免使用select *
select * 不会走覆盖索引，会出现大量的回表操作，从而导致查询sql的性能很低。
--反例
select * from user where id = 1;
--正例
select name,age from user where id = 1;
2、union all 代替 union
union：去重后的数据，union all：所有数据包含重复数据
排重的过程需要遍历、排序和比较，它更耗时，更消耗cpu资源。
除非是有些特殊的场景，比如union all之后，结果集中出现了重复数据，而业务场景中是不允许产生重复数据的，这时可以使用union。
--反例
(select * from user where id = 1)
union
(select * from user where id = 2);--正例
(select * from user where id = 1)
union all
(select * from user where id = 2);3、小表驱动大表
小表驱动大表：小表的数据集驱动大表的数据集。
假如有order和user两张表，其中order表有10000条数据，而user表有100条数据。
有效的用户下过的订单列表，in关键字去实现业务需求，更加合适。
因为如果SQL语句中包含了in关键字，则它会优先执行in里面的子查询语句，然后再执行in外面的语句。如果in里面的数据量很少，作为条件查询速度更快。
如果SQL语句中包含了exists关键字，它优先执行exists左边的语句（即主查询语句）。然后把它作为条件，去跟右边的语句匹配。如果匹配上，则可以查询出数据。如果匹配不上，数据就被过滤掉了。
--IN
select * from order
where user_id in (select id from user where status=1)--exists
select * from order
where exists (select 1 from user where order.user_id = user.id and status=1)
in适用于左边大表，右边小表。
exists适用于左边小表，右边大表。
4、批量新增
下面操作需要多次请求数据库，才能完成这批数据的插入。
每次远程请求数据库，是会消耗一定性能的。而如果我们的代码需要请求多次数据库，才能完成本次业务功能，势必会消耗更多的性能。
--反例
for(Order order: list){orderMapper.insert(order):
}在循环中逐条插入
insert into order(id,code,user_id)
values(123,'001',100);批量插入只需要远程请求一次数据库，SQL性能会得到提升，数据量越多，提升越大。
但需要注意的是，不建议一次批量操作太多的数据，如果数据太多数据库响应也会很慢。批量操作需要把握一个度，建议每批数据尽量控制在500以内。如果数据多于500，则分多批次处理。
--正例
orderMapper.insertBatch(list);insert into order(id,code,user_id)
values(123,'001',100),(124,'002',100),(125,'003',101);
5、多用limit
查询数据创建时间最新的一条数据
--反例
select id,create_date
from order
where user_id=123
order by create_date asc;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;6、in中值太多
我们不做任何限制，该查询语句一次性可能会查询出非常多的数据，很容易导致接口超时。
select id,name from category
where id in (1,2,3...100000000);可以在SQL中对数据用limit做限制，不过我们更多的是要在业务代码中加限制
select id,name from category
where id in (1,2,3...100)
limit 500;如果ids超过500条记录，可以分批用多线程去查询数据。每批只查500条记录，最后把查询到的数据汇总到一起返回。
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);
}7、增量同步
远程接口查询数据，然后同步到另外一个数据库。
--反例
--数据很多的话，查询性能会非常差。
select * from user;
按ID和时间升序，每次只同步一批数据，这一批数据只有100条记录。
每次同步完成之后，保存这100条数据中最大的ID和时间，给同步下一批数据的时候用。
通过这种增量查询的方式，能够提升单次查询的效率。
select * from user
where id > #{lastId} and create_time >= #{lastCreateTime}
limit 100;全量同步：每天9点全量执行一次，目标表记录同步时间
增量同步：每15分钟定时执行任务同步数据，如果源数据表修改时间 > 目标表的同步时间 ，作为新增数据同步
8、高效的分页
列表页在查询数据时，为了避免一次性返回过多的数据影响接口性能，我们一般会对查询接口做分页处理。
select id,name,age
from user limit 10,20;如果表中数据量少，用limit关键字做分页，没啥问题。但如果表中数据量很多，用它就会出现性能问题。mysql会查到1000020条数据，然后丢弃前面的1000000条，只查后面的20条数据，这个是非常浪费资源的。
select id,name,age
from user limit 1000000,20;先找到上次分页最大的id，然后利用id上的索引查询。不过该方案，要求id是连续的，并且有序的。
select id,name,age
from user where id > 1000000 limit 20;9、用连接查询代替子查询
mysql中如果需要从两张以上的表中查询出数据的话，一般有两种实现方式：子查询 和 连接查询。
--子查询
select * from order
where user_id in (select id from user where status=1)子查询语句可以通过in关键字实现，一个查询语句的条件是在另一个select语句的查询结果中。程序先运行在嵌套在最内层的语句，再运行外层的语句。
子查询语句的优点是简单，结构化，如果涉及的表数量不多的话。
但缺点是mysql执行子查询时，需要创建临时表，查询完毕后，需要再删除这些临时表，有一些额外的性能消耗。
select o.* from order o
inner join user u on o.user_id = u.id
where u.status=110、join的表不宜过多
阿里巴巴开发者手册的规定，join表的数量不应该超过
3个。
如果join太多，mysql在选择索引的时候会非常复杂，很容易选错索引。
并且如果没有命中中，nested loop join 就是分别从两个表读一行数据进行两两对比，复杂度是 n^2。所以我们应该尽量控制join表的数量。
--反例
select a.name,b.name.c.name,d.name
from a
inner join b on a.id = b.a_id
inner join c on c.b_id = b.id
inner join d on d.c_id = c.id
inner join e on e.d_id = d.id
inner join f on f.e_id = e.id
inner join g on g.f_id = f.id如果实现业务场景中需要查询出另外几张表中的数据，可以在a、b、c表中冗余专门的字段，比如：在表a中冗余d_name字段，保存需要查询出的数据。
不过我之前也见过有些ERP系统，并发量不大，但业务比较复杂，需要join十几张表才能查询出数据。所以join表的数量要根据系统的实际情况决定，不能一概而论，尽量越少越好。
--正例
select a.name,b.name.c.name,a.d_name
from a
inner join b on a.id = b.a_id
inner join c on c.b_id = b.id11、 join时要注意
left join：求两个表的交集外加左表剩下的数据。inner join：求两个表交集的数据。
两张表使用inner join关联，mysql会自动选择两张表中的小表，去驱动大表，所以性能上不会有太大的问题。
--inner join
select o.id,o.code,u.name
from order o
inner join user u on o.user_id = u.id
where u.status=1;两张表使用left join关联，mysql会默认用left join关键字左边的表，去驱动它右边的表。如果左边的表数据很多时，就会出现性能问题。
select o.id,o.code,u.name
from order o
left join user u on o.user_id = u.id
where u.status=1;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 order
group by user_id
having user_id <= 200;这种写法性能不好，它先把所有的订单根据用户id分组之后，再去过滤用户id大于等于200的用户。分组是一个相对耗时的操作，为什么我们不先缩小数据的范围之后，再分组呢？
--正例
select user_id,user_name from order
where user_id <= 200
group by user_id使用where条件在分组前，就把多余的数据过滤掉了，这样分组时效率就会更高一些。
其实这是一种思路，不仅限于group by的优化。我们的sql语句在做一些耗时的操作之前，应尽可能缩小数据范围，这样能提升sql整体的性能。
15、索引优化
索引优化的第一步是：检查sql语句有没有走索引。
可以使用explain命令，查看mysql的执行计划。
explain select * from `order` where code='002';
通过这几列可以判断索引使用情况，执行计划包含列的含义如下图所示：
下面说说索引失效的常见原因：
