下面的演示基于mysql5.7.27版本
一、关于mysql子查询的优化策略介绍:
子查询优化策略
对于不同类型的子查询，优化器会选择不同的策略。
1. 对于 in、=any 子查询，优化器有如下策略选择：
- semijoin
- materialization
- exists
2. 对于 not in、<>all 子查询，优化器有如下策略选择：
- materialization
- exists
3. 对于 derived 派生表，优化器有如下策略选择：
derived_merge，将派生表合并到外部查询中（5.7 引入 ）；
将派生表物化为内部临时表，再用于外部查询。
注意：update 和 delete 语句中子查询不能使用 semijoin、materialization 优化策略
二、创建数据进行模拟演示
为了方便分析问题先建两张表并插入模拟数据：
create table `test02` ( `id` int(11) not null, `a` int(11) default null, `b` int(11) default null, primary key (`id`), key `a` (`a`) ) engine=innodb; drop procedure idata; delimiter ;; create procedure idata() begin declare i int; set i=1; while(i<=10000)do insert into test02 values(i, i, i); set i=i+1; end while; end;; delimiter ; call idata(); create table test01 like test02; insert into test01 (select * from test02 where id<=1000)
三、举例分析sql实例
子查询示例：
select * from test01 where test01.a in (select test02.b from test02 where id < 10)
大部分人可定会简单的认为这个 sql 会这样执行：
select test02.b from test02 where id < 10
结果:1,2,3,4,5,6,7,8,9
select * from test01 where test01.a in (1,2,3,4,5,6,7,8,9);
但实际上 mysql 并不是这样做的。mysql 会将相关的外层表压到子查询中，优化器认为这样效率更高。也就是说，优化器会将上面的 sql 改写成这样：
select * from test01 where exists(select b from test02 where id < 10 and test01.a=test02.b);
提示： 针对mysql5.5以及之前的版本
查看执行计划如下，发现这条sql对表test01进行了全表扫描1000，效率低下：
root@localhost [dbtest01]>desc select * from test01 where exists(select b from test02 where id < 10 and test01.a=test02.b); +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ | 1 | primary | test01 | null | all | null | null | null | null | 1000 | 100.00 | using where | | 2 | dependent subquery | test02 | null | range | primary | primary | 4 | null | 9 | 10.00 | using where | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ 2 rows in set, 2 warnings (0.00 sec)
但是此时实际执行下面的sql，发现也不慢啊,这不是自相矛盾嘛，别急，咱们继续往下分析:
select * from test01 where test01.a in (select test02.b from test02 where id < 10)
查看此条sql的执行计划如下：
root@localhost [dbtest01]>desc select * from test01 where test01.a in (select test02.b from test02 where id < 10); +----+--------------+-------------+------------+-------+---------------+---------+---------+---------------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------+-------------+------------+-------+---------------+---------+---------+---------------+------+----------+-------------+ | 1 | simple | <subquery2> | null | all | null | null | null | null | null | 100.00 | using where | | 1 | simple | test01 | null | ref | a | a | 5 | <subquery2>.b | 1 | 100.00 | null | | 2 | materialized | test02 | null | range | primary | primary | 4 | null | 9 | 100.00 | using where | +----+--------------+-------------+------------+-------+---------------+---------+---------+---------------+------+----------+-------------+ 3 rows in set, 1 warning (0.00 sec)
发现优化器使用到了策略materialized。于是对此策略进行了资料查询和学习。
原因是从mysql5.6版本之后包括mysql5.6版本，优化器引入了新的优化策略:materialization=[off|on],semijoin=[off|on],(off代表关闭此策略，on代表开启此策略)
可以采用show variables like ‘optimizer_switch’; 来查看mysql采用的优化器策略。当然这些策略都是可以在线进行动态修改的
set global optimizer_switch=’materialization=on,semijoin=on’;代表开启优化策略materialization和semijoin
mysql5.7.27默认的优化器策略：
root@localhost [dbtest01]>show variables like 'optimizer_switch'; +------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | variable_name | value | +------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | optimizer_switch | 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=on,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=on | +------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
所以在mysql5.6及以上版本时
执行下面的sql是不会慢的。因为mysql的优化器策略materialization和semijoin 对此sql进行了优化
select * from test01 where test01.a in (select test02.b from test02 where id < 10)
然而咱们把mysql的优化器策略materialization和semijoin 关闭掉测试，发现sql确实对test01进行了全表的扫描(1000):
set global optimizer_switch='materialization=off,semijoin=off';
执行计划如下test01表确实进行了全表扫描:
root@localhost [dbtest01]>desc select * from test01 where test01.a in (select test02.b from test02 where id < 10); +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ | 1 | primary | test01 | null | all | null | null | null | null | 1000 | 100.00 | using where | | 2 | dependent subquery | test02 | null | range | primary | primary | 4 | null | 9 | 10.00 | using where | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ 2 rows in set, 1 warning (0.00 sec)
下面咱们分析下这个执行计划:
！！！！再次提示:如果是mysql5.5以及之前的版本，或者是mysql5.6以及之后的版本关闭掉优化器策略materialization=off,semijoin=off，得到的sql执行计划和下面的是相同的
root@localhost [dbtest01]>desc select * from test01 where exists(select b from test02 where id < 10 and test01.a=test02.b); +----+--------------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+ | 1 | primary | test01 | null | all | null | null | null | null | 1000 | 100.00 | using where | | 2 | dependent subquery | test02 | null | range | primary | primary | 4 | null | 9 | 10.00 | using where | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+------+----------+-------------+ 2 rows in set, 2 warnings (0.00 sec)
不相关子查询变成了关联子查询（select_type:dependent subquery），子查询需要根据 b 来关联外表 test01，因为需要外表的 test01 字段，所以子查询是没法先执行的。执行流程为：
- 扫描 test01，从 test01 取出一行数据 r；
- 从数据行 r 中，取出字段 a 执行子查询，如果得到结果为 true，则把这行数据 r 放到结果集；
- 重复 1、2 直到结束。
总的扫描行数为 1000+1000*9=10000（这是理论值，但是实际值比10000还少，怎么来的一直没想明白，看规律是子查询结果集每多一行，总扫描行数就会少几行）。
semi-join优化器:
这样会有个问题，如果外层表是一个非常大的表，对于外层查询的每一行，子查询都得执行一次，这个查询的性能会非常差。我们很容易想到将其改写成 join 来提升效率：
select test01.* from test01 join test02 on test01.a=test02.b and test02.id<10;
# 查看此sql的执行计划:
desc select test01.* from test01 join test02 on test01.a=test02.b and test02.id<10; root@localhost [dbtest01]>explain extended select test01.* from test01 join test02 on test01.a=test02.b and test02.id<10; +----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------------+ | 1 | simple | test02 | null | range | primary | primary | 4 | null | 9 | 100.00 | using where | | 1 | simple | test01 | null | ref | a | a | 5 | dbtest01.test02.b | 1 | 100.00 | null | +----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------------+ 2 rows in set, 2 warnings (0.00 sec)
这样优化可以让 t2 表做驱动表，t1 表关联字段有索引，查找效率非常高。
但这里会有个问题，join 是有可能得到重复结果的，而 in(select …) 子查询语义则不会得到重复值。
而 semijoin 正是解决重复值问题的一种特殊联接。
在子查询中，优化器可以识别出 in 子句中每组只需要返回一个值，在这种情况下，可以使用 semijoin 来优化子查询，提升查询效率。
这是 mysql 5.6 加入的新特性，mysql 5.6 以前优化器只有 exists 一种策略来“优化”子查询。
经过 semijoin 优化后的 sql 和执行计划分为：
root@localhost [dbtest01]>desc select * from test01 where test01.a in (select test02.b from test02 where id < 10); +----+--------------+-------------+------------+-------+---------------+---------+---------+---------------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------+-------------+------------+-------+---------------+---------+---------+---------------+------+----------+-------------+ | 1 | simple | <subquery2> | null | all | null | null | null | null | null | 100.00 | using where | | 1 | simple | test01 | null | ref | a | a | 5 | <subquery2>.b | 1 | 100.00 | null | | 2 | materialized | test02 | null | range | primary | primary | 4 | null | 9 | 100.00 | using where | +----+--------------+-------------+------------+-------+---------------+---------+---------+---------------+------+----------+-------------+ 3 rows in set, 1 warning (0.00 sec)
select `test01`.`id`,`test01`.`a`,`test01`.`b` from `test01` semi join `test02` where ((`test01`.`a` = `<subquery2>`.`b`) and (`test02`.`id` < 10));
##注意这是优化器改写的sql，客户端上是不能用 semi join 语法的
semijoin 优化实现比较复杂，其中又分 firstmatch、materialize 等策略,上面的执行计划中 select_type=materialized 就是代表使用了 materialize 策略来实现的 semijoin
这里 semijoin 优化后的执行流程为：
先执行子查询，把结果保存到一个临时表中，这个临时表有个主键用来去重；
从临时表中取出一行数据 r；
从数据行 r 中，取出字段 b 到被驱动表 t1 中去查找，满足条件则放到结果集；
重复执行 2、3，直到结束。
这样一来，子查询结果有 9 行，即临时表也有 9 行（这里没有重复值），总的扫描行数为 9+9+9*1=27 行，比原来的 10000 行少了很多。
mysql 5.6 版本中加入的另一种优化特性 materialization，就是把子查询结果物化成临时表，然后代入到外查询中进行查找，来加快查询的执行速度。内存临时表包含主键（hash 索引），消除重复行，使表更小。
如果子查询结果太大，超过 tmp_table_size 大小，会退化成磁盘临时表。这样子查询只需要执行一次，而不是对于外层查询的每一行都得执行一遍。
不过要注意的是，这样外查询依旧无法通过索引快速查找到符合条件的数据，只能通过全表扫描或者全索引扫描，
semijoin 和 materialization 的开启是通过 optimizer_switch 参数中的 semijoin={on|off}、materialization={on|off} 标志来控制的。
上文中不同的执行计划就是对 semijoin 和 materialization 进行开/关产生的
总的来说对于子查询，先检查是否满足各种优化策略的条件（比如子查询中有 union 则无法使用 semijoin 优化）
然后优化器会按成本进行选择，实在没得选就会用 exists 策略来“优化”子查询，exists 策略是没有参数来开启或者关闭的。
下面举一个delete相关的子查询例子：
把上面的2张测试表分别填充350万数据和50万数据来测试delete语句
root@localhost [dbtest01]>select count(*) from test02; +----------+ | count(*) | +----------+ | 3532986 | +----------+ 1 row in set (0.64 sec) root@localhost [dbtest01]>create table test01 like test02; query ok, 0 rows affected (0.01 sec) root@localhost [dbtest01]>insert into test01 (select * from test02 where id<=500000) root@localhost [dbtest01]>select count(*) from test01; +----------+ | count(*) | +----------+ | 500000 |
执行delete删除语句执行了4s
root@localhost [dbtest01]>delete from test01 where test01.a in (select test02.b from test02 where id < 10); query ok, 9 rows affected (4.86 sec)
查看 执行计划，对test01表进行了几乎全表扫描:
root@localhost [dbtest01]>desc delete from test01 where test01.a in (select test02.b from test02 where id < 10); +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ | 1 | delete | test01 | null | all | null | null | null | null | 499343 | 100.00 | using where | | 2 | dependent subquery | test02 | null | range | primary | primary | 4 | null | 9 | 10.00 | using where | +----+--------------------+--------+------------+-------+---------------+---------+---------+------+--------+----------+-------------+ 2 rows in set (0.00 sec)
于是修改上面的delete sql语句伪join语句
root@localhost [dbtest01]>desc delete test01.* from test01 join test02 on test01.a=test02.b and test02.id<10; +----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------------+ | 1 | simple | test02 | null | range | primary | primary | 4 | null | 9 | 100.00 | using where | | 1 | delete | test01 | null | ref | a | a | 5 | dbtest01.test02.b | 1 | 100.00 | null | +----+-------------+--------+------------+-------+---------------+---------+---------+-------------------+------+----------+-------------+ 2 rows in set (0.01 sec) 执行非常的快 root@localhost [dbtest01]>delete test01.* from test01 join test02 on test01.a=test02.b and test02.id<10; query ok, 9 rows affected (0.01 sec) root@localhost [dbtest01]>select test01.* from test01 join test02 on test01.a=test02.b and test02.id<10; empty set (0.00 sec)
下面的这个表执行要全表扫描，非常慢，基本对表test01进行了全表扫描:
root@lcalhost [dbtest01]>desc delete from test01 where id in (select id from test02 where id='350000'); +----+--------------------+--------+------------+-------+---------------+---------+---------+-------+--------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+--------------------+--------+------------+-------+---------------+---------+---------+-------+--------+----------+-------------+ | 1 | delete | test01 | null | all | null | null | null | null | 499343 | 100.00 | using where | | 2 | dependent subquery | test02 | null | const | primary | primary | 4 | const | 1 | 100.00 | using index | +----+--------------------+--------+------------+-------+---------------+---------+---------+-------+--------+----------+-------------+ 2 rows in set (0.00 sec)
然而采用join的话，效率非常的高:
root@localhost [dbtest01]>desc delete test01.* from test01 inner join test02 where test01.id=test02.id and test02.id=350000 ; +----+-------------+--------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+-------------+--------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+ | 1 | delete | test01 | null | const | primary | primary | 4 | const | 1 | 100.00 | null | | 1 | simple | test02 | null | const | primary | primary | 4 | const | 1 | 100.00 | using index | +----+-------------+--------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+ 2 rows in set (0.01 sec) root@localhost [dbtest01]> desc delete test01.* from test01 join test02 on test01.a=test02.b and test02.id=350000; +----+-------------+--------+------------+-------+---------------+---------+---------+-------+------+----------+-------+ | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | extra | +----+-------------+--------+------------+-------+---------------+---------+---------+-------+------+----------+-------+ | 1 | simple | test02 | null | const | primary | primary | 4 | const | 1 | 100.00 | null | | 1 | delete | test01 | null | ref | a | a | 5 | const | 1 | 100.00 | null | +----+-------------+--------+------------+-------+---------------+---------+---------+-------+------+----------+-------+ 2 rows in set (0.00 sec)
参考文档:
到此这篇关于mysql之select in 子查询优化的实现的文章就介绍到这了,更多相关mysql select in 子查询优化内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！