MySQL之基于规则的优化特性（一）

SHOW VARIABLES LIKE 'optimizer_switch'\Gmysql> SHOW VARIABLES LIKE 'optimizer_switch'\G*************************** 1. row ***************************Variable_name: optimizer_switch        Value: index_merge=on,index_merge_union=on,index_merge_sort_union=on,index_merge_intersection=on,engine_condition_pushdown=on,index_condition_pushdown=on,mrr=on,mrr_cost_based=off,block_nested_loop=on,batched_key_access=off,materialization=on,semijoin=on,loosescan=on,firstmatch=on,duplicateweedout=on,subquery_materialization_cost_based=on,use_index_extensions=on,condition_fanout_filter=on,derived_merge=on1 row in set (0.00 sec)

索引合并（Index Merge）

MySQL把使用多个索引来完成一次查询的执行方法称之为index merge（索引合并）。

「index_merge=on（索引合并）  index_merge_union=on（Union索引合并—非聚簇索引获取到的id值取并集）  index_merge_sort_union=on（Sort-Union索引合并—非聚簇索引获取到的id值先排序-取并集）  index_merge_intersection=on（Intersection索引合并—非聚簇索引获取到的id值取交集）」

Intersection索引合并：Intersection的中文含义就是”交集“，Intersection索引合并就是对从不同索引中扫描到的记录的id值取交集，只为这些id值执行回表操作。

【触发的必要条件】：

1、二级索引是等值查询；如果是组合索引，组合索引的每一位都必须覆盖到，不能只是部分；

2、InnoDB表上的主键范围查询条件。

如果使用Intersection索引合并的方式执行查询，并且每个使用到的索引都是二级索引的话，则要求每个索引中获取到的二级索引记录都是按照主键值排序的。

①从两个有序集合中取交集比从两个无序集合中取交集要容易的多；

②如果获取到的id值是有序的，则在根据这些id值执行回表操作时就不再是进行单纯的随机I/O（这些id值有序），从而会提高效率。

执行流程：对于每一个使用到的索引进行查询，查询主键值集合，然后进行合并，求交集，也就是and运算。

求交集的算法：针对两个升序排序的数组，进行归并：逐个取出两个数组中的最小的值，如果相等，就放入结果集，否则将较小的数指针向后移动。时间复杂度O(N)。

Union索引合并：Union的中文含义就是”并集“，Union索引合并指的就是对从不同索引中扫描到的记录的id值取并集，为这些id值执行回表操作。

【触发的必要条件】：

1、二级索引是等值查询；如果是组合索引，组合索引的每一位都必须覆盖到，不能只是部分；

2、InnoBD表上的主键范围查询；

3、符合index merge intersect的条件。

如果使用Union索引合并的方式执行查询，并且每个使用到的索引都是二级索引的话，则要求每个索引中获取到的二级索引记录都是按照主键值排序的。

①从两个有序集合执行去重操作比从两个无序集合中执行去重操作容易一些；

②如果获取到的id值是有序的话，那么在根据这些id值执行回表操作时就不再是进行单纯的随机I/O（这些id值有序），从而会提高效率。

执行流程：执行流程与index merge intersect类似，依旧是查询了有序的主键集合，然后进行求并集。

MySQL没有Sort-Intersection索引合并这一说，不过在MySQL的近亲——MariaDB数据库中实现了Sort-Intersection索引合并。而Intersection索引合并针对的是”单独根据搜索条件从某个二级索引中获取的记录数太多，导致回表成本太大的使用场景“，使用Intersection索引合并后可以明显较低回表成本。如果加入Sort-Intersection索引合并，就需要大量二级索引记录按照主键值进行排序，这个成本可能比使用单个二级索引执行查询的成本都要高。

索引条件下推（Index Condition Pushdown,ICP）

MySQL 5.6+版本中的新特性，是一种在存储引擎层使用索引过滤数据的一种优化方式。（engine_condition_pushdown特性只用于NDB存储引擎，不在我们讨论之列）

「engine_condition_pushdown=on（引擎条件下推—只用于NDB引擎，开启后时按照WHERE条件过滤后的数据发送到SQL节点来处理，不开启所有数据节点的数据都发送到SQL节点来处理。）  index_condition_pushdown=on（索引条件下推—ICP）」

ICP是对联合索引进行二次过滤之后回表。用于二级索引的range、 ref、 eq_ref或ref_or_null扫描，如果部分where条件能使用索引的字段，MySQL Server会把这部分下推到引擎层，可以利用index过滤的where条件在存储引擎层进行数据过滤。 

开启ICP后的流程图：

1、只能用于二级索引（Secondary Index），其中一部分索引无法使用的时候。

2、EXPLAIN显示的执行计划中type字段值（join 类型）为range、 ref、 eq_ref或者ref_or_null，且查询需要访问表的整行数据，即不能直接通过二级索引的元组数据获得查询结果（索引覆盖，Using Index）。

3、ICP可以用于MyISAM和InnnoDB存储引擎，包括分区表InnoDB和 MyISAM表（MySQL 5.6中的分区表不支持ICP；MySQL 5.7已解决此问题。）。

4、在虚拟生成的列上创建的二级索引不支持ICP。InnoDB 支持虚拟生成的列上的二级索引。

5、引用子查询的条件不能下推。

6、涉及存储功能的条件不能下推。存储引擎无法调用存储的功能。

7、触发条件不能下推。

Join相关的优化特性

涉及Join相关的优化特性开关有以下几个：

「mrr=on（Multi-Range Read-MRR—这个优化的主要目的是尽量使用顺序读盘） mrr_cost_based=on（cost-based choice—是否计算基于使用MRR的成本计算/判断消耗） block_nested_loop=on（基于块的嵌套循环连接—BNL） batched_key_access=off（BKA—针对Index Nested-Loop Join(NLJ) 算法的优化）」

在正式介绍优化特性开关前，还是需要做一些知识补充。

之前MySQL之表连接原理文章我们学习过笛卡尔积，连接查询的结果集中包含一个表中的每一条记录与另一个表中的每一条记录相互匹配的组合，像这样的结果集就是数学中的笛卡尔积（笛卡尔乘积是指在数学中，两个集合X和Y的笛卡尔积（Cartesian product），又称直积，表示为X × Y，第一个对象是X的成员而第二个对象是Y的所有可能有序对的其中一个成员）。这个算法还有一个名称：嵌套循环连接（Simple Nested-Loop Join/Nested-Loop Join），其实就是笛卡尔积，这个算法过于“笨重”。

于是，MySQL提出了基于块的嵌套循环连接（Block Nested-Loop Join，BNL）的连接优化算法策略。先将从驱动表得到的结果集存放在执行连接查询前申请的一块固定大小的内存Join Buffer中，然后开始扫描被驱动表，每一条被驱动表的记录一次性和Join Buffer中的多条驱动表记录做匹配，因为匹配的过程都是在内存中完成的，所以这样可以显著减少被驱动表的I/O代价。之前的文章MySQL之Server层的“Buffer”和“Cache”、MySQL之表连接原理都有过详细介绍，这里不再赘述。

select * from t1 straight_join t2 on (t1.a=t2.a);（t1 是驱动表，t2 是被驱动表。被驱动表 t2 的字段 a 上有索引，join 过程用上了这个索引）

快速构造一些测试数据：

CREATE DATABASE `test_bka` DEFAULT CHARACTER SET utf8mb4;use test_bka;create table t1(id int primary key, a int,b int, index(a));create table t2 like t1;delimiter ;;create procedure idata()begin  declare i int;  set i=1;  while(i<=1000)do    insert into t1 values(i,1001-i,i);    set i=i+1;  end while;  set i=1;  while(i<=1000000)do    insert into t2 values(i,i,i);    set i=i+1;  end while;end ;;delimiter ;call idata();

Multi-Range Read（MRR）：MRR在本质上是一种用空间换时间的算法。MRR 通过把「随机磁盘读」，转化为「顺序磁盘读」，从而提高了索引查询的性能。（严格意义上来说，属于非Join的优化算法。MRR是二级索引取得PK进行排序来减少随机IO达到优化目的的优化算法）

select * from t1 where a>=1 and a<=100;（a字段上有普通二级索引）

DESC select * from t1 where a>=100 and a<=200;

这回又知道了一个执行计划Extra字段输出内容"Using MRR"的含义了。

Batched Key Access（BKA）：MySQL在5.6版本后开始引入的Batched Key Access（BKA）算法，其实就是对NLJ算法的优化。

NLJ 算法执行的逻辑是：从驱动表t1，一行行地取出a的值，再到被驱动表t2去做join。对于表t2来说，每次都是匹配一个值。这时，MRR 的优势就用不上了。

那怎么才能一次性地多传些值给表t2呢？方法就是，从表t1里一次性地多拿些行出来，一起传给表t2。我们就把表t1的数据取出来一部分，先放到一个临时内存。这个临时内存不是别人，就是join_buffer。通过之前的文章，我们知道join_buffer在BNL算法里的作用，是暂存驱动表的数据。但是在NLJ算法里并没有用。那么，我们刚好就可以复用join_buffer到BKA算法中。

join_buffer中放入的数据是P1~P100，表示只取查询需要的字段。当然，如果join buffer放不下P1~P100的所有数据，就会把这100行数据分成多段执行上图的流程。如果要使用BKA优化算法的话，执行SQL前需要设置：set optimizer_switch='mrr=on,mrr_cost_based=off,batched_key_access=on';（其中，前两个参数的作用是要启用 MRR。这么做的原因是，BKA 算法的优化要依赖于 MRR。）

优化思路之Block Nested-Loop Join转Batched Key Access（BNL → BKA）：一些情况下，我们可以直接在被驱动表上建索引，这时就可以直接转成BKA算法了。但是，有时候你确实会碰到一些不适合在被驱动表上建索引的情况。

select * from t1 join t2 on (t1.b=t2.b) where t2.b>=1 and t2.b<=2000;

表t2中插入了100万行数据，但是经过where条件过滤后，需要参与join的只有2000‍‍‍‍‍‍‍‍行数据。如果这条语句同时是一个低频的SQL语句，那么再为这个语句在表t2的字段b上创建一个索引就很浪费了，不创建索引的话这个语句的等值条件要判断10亿次。其实有一个两全其美的办法，大致思路就是：

1、把表t2中满足条件的数据放在临时表tmp_t中；

2、为了让join使用BKA算法，给临时表tmp_t的字段b加上索引；

3、让表t1和tmp_t做join操作。

create temporary table temp_t(id int primary key, a int, b int, index(b))engine=innodb;insert into temp_t select * from t2 where b>=1 and b<=2000;select * from t1 join temp_t on (t1.b=temp_t.b);

这个过程的消耗：

1、执行insert语句构造temp_t表并插入数据的过程中，对表t2做了全表扫描，这里扫描行数是100万。

2、之后的join语句，扫描表t1，这里的扫描行数是1000；join比较过程中，做了1000次带索引的查询。相比于优化前的join语句需要做10亿次条件判断来说，这个优化效果还是很明显的。

所以，不论是在原表上加索引，还是用有索引的临时表，我们的思路都是让join语句能够用上被驱动表上的索引，来触发BKA算法，提升查询性能。

• 8.0.18将join buffer（BNL）转换成了hash join。
• hash join可以提高效率，但是非常耗费CPU，数据量一大也会对性能产生影响。

• 嵌套循环连接（Simple Nested-Loop Join/Nested-Loop Join）：笛卡尔积；
• 基于块的嵌套循环连接（Block Nested-Loop Join，BNL）：先将驱动表得到的结果集存放在Join Buffer内存中，再和被驱动表进行匹配查询；
• 基于索引的嵌套循环连接（Index Nested-Loop Join，NLJ）：对驱动表一行一行地取值，每次传递一个值给被驱动表，且可以通过关联字段的索引查找对应数据；
• Multi-Range Read（MRR）：严格意义上说属于非Join的优化算法，对于辅助索引上的范围查询进行优化，收集辅助索引对应主键id，进行排序后再回表，每次传递一组排好序的主键id值给被驱动表，随机IO转换成顺序IO；
• Batched Key Access（BKA）：BKA算法结合了NLJ、BNL、MRR算法的特性。即用到了NLJ的被驱动表关联字段索引减少关联匹配的次数；又使用到了BNL的Join Buffer，用以暂存驱动表连接数据减少访问驱动表；还用到了MRR的收集辅助索引主键id后排序再回表查询，随机IO转换成顺序IO等优化特性集一身，可以把BKA看做是NLJ算法的加强版。即一次性将驱动表存放在Join Buffer中查询所需的一组字段值经过MRR接口将对应主键ID值排好序后再与被驱动表的连接字段（有索引）进行Join操作。

索引扩展（Index Extension）

「use_index_extensions=on（使用索引扩展）」

条件过滤（Condition Filter）

「condition_fanout_filter=on（条件(扇出)过滤）」

• 索引合并（Index Merge）：MySQL把使用多个索引来完成一次查询的执行方法称之为index merge（索引合并）。将把从多个辅助索引获得的主键ID值取Intersection交集、Union并集、Sort-Union排序并集后再统一回表，以减少回表次数（随机IO）。
• 索引条件下推（Index Condition Pushdown,ICP）：ICP是一种在存储引擎层使用索引过滤数据的一种优化方式。是对联合索引进行二次过滤之后回表。用于二级索引的range、 ref、 eq_ref或ref_or_null扫描，如果部分where条件能使用索引的字段，MySQL Server会把这部分下推到引擎层，可以利用index过滤的where条件在存储引擎层进行数据过滤。
• 基于块的嵌套循环连接（Block Nested-Loop Join，BNL）：先将驱动表得到的结果集存放在Join Buffer内存结构中，再和被驱动表进行匹配查询。减少被驱动表的I/O代价。
• Multi-Range Read（MRR）：MRR在本质上是一种用空间换时间的算法。MRR 通过把「随机磁盘读」，转化为「顺序磁盘读」，从而提高了索引查询的性能。严格意义上说属于非Join的优化算法，对于辅助索引上的范围查询进行优化，收集辅助索引对应主键id，进行排序后再回表，每次传递一组排好序的主键id值给被驱动表，随机IO转换成顺序IO。
• Batched Key Access（BKA）：BKA算法结合了NLJ、BNL、MRR算法的特性。即用到了NLJ的被驱动表关联字段索引减少关联匹配的次数；又使用到了BNL的Join Buffer，用以暂存驱动表连接数据减少访问驱动表；还用到了MRR的收集辅助索引主键id后排序再回表查询，随机IO转换成顺序IO等优化特性集一身，可以把BKA看做是NLJ算法的加强版。即一次性将驱动表存放在Join Buffer中查询所需的一组字段值经过MRR接口将对应主键ID值排好序后再与被驱动表的连接字段（有索引）进行Join操作。
• 嵌套循环连接（Simple Nested-Loop Join/Nested-Loop Join）：笛卡尔积。
• 基于索引的嵌套循环连接（Index Nested-Loop Join，NLJ）：进行Join查询时，可以用上被驱动表的索引。
  

好啦，今天就到这里了。站在巨人的肩膀上，每天进步一点点。

end