MySql子查询IN的执行和优化的实现

吾爱主题阅读：154 2024-04-02 08:04:22 评论：0

in为什么慢？

在应用程序中使用子查询后，sql语句的查询性能变得非常糟糕。例如：

1	`select` `driver_id` `from` `driver` `where` `driver_id` `in` `(` `select` `driver_id` `from` `driver` `where` `_create_date >` `'2016-07-25 00:00:00'` `);`

独立子查询返回了符合条件的driver_id，这个问题是解决了，但是所用的时间需要6秒，可以通过explain查看sql语句的执行计划：

可以看到上面的sql语句变成了相关子查询，通过explain extended 和 show warnings命令，可以看到如下结果：

复制代码代码如下: select `northwind`.`driver`.`driver_id` as `driver_id` from `northwind`.`driver` where <in_optimizer>(`northwind`.`driver`.`driver_id`,<exists>(select 1 from `northwind`.`driver` where ((`northwind`.`driver`.`_create_date` > '2016-07-25 00:00:00') and (<cache>(`northwind`.`driver`.`driver_id`) = `northwind`.`driver`.`driver_id`))))

可以看出mysql优化器直接把in子句转换成了exists的相关子查询。下面这条相关in子查询：

1	`select` `driver_id` `from` `driver` `where` `driver_id` `in` `(` `select` `driver_id` `from` `user` `where` `user` `.uid = driver.driver_id);`

查看sql语句的执行计划：

就是相关子查询，通过explain extended 和 show warnings命令，看到如下结果：

复制代码代码如下: select `northwind`.`driver`.`driver_id` as `driver_id` from `northwind`.`driver` where <in_optimizer>(`northwind`.`driver`.`driver_id`,<exists>(select 1 from `northwind`.`user` where ((`northwind`.`user`.`uid` = `northwind`.`driver`.`driver_id`) and (<cache>(`northwind`.`driver`.`driver_id`) = `northwind`.`driver`.`driver_id`))))

可以看出无论是独立子查询还是相关子查询，mysql 5.5之前的优化器都是将in转换成exists语句。如果子查询和外部查询分别返回m和n行，那么该子查询被扫描为o(n+n*m)，而不是o(n+m)。这也就是为什么in慢的原因。

in和exists哪个快？

网上百度到很多认为in和exists效率一样是错误的文章。

如果查询的两个表大小相当，那么用in和exists差别不大。
如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in：
例如：表a（小表），表b（大表）
1：
select * from a where cc in (select cc from b) 效率低，用到了a表上cc列的索引；
select * from a where exists(select cc from b where cc=a.cc) 效率高，用到了b表上cc列的索引。

相反的

2：
select * from b where cc in (select cc from a) 效率高，用到了b表上cc列的索引；
select * from b where exists(select cc from a where cc=b.cc) 效率低，用到了a表上cc列的索引。

总结上面的描述，个人认为其主要的原因在于对索引的使用。任何情况下，只要是大表的索引被使用，就可以使效率提高。

但是在编辑本文的时候，多次测试，却没能得到上面所总结的结果。下面是测试sql语句，先是外表为大表，内表为小表。（示例一）

1 2	`select` `count` `(driver_id)` `from` `driver` `where` `driver_id` `in` `(` `select` `uid` `from` `user` `);` `select` `count` `(driver_id)` `from` `driver` `where` `exists (` `select` `1` `from` `user` `where` `uid = driver.driver_id);`

执行结果是：

再是外表是小表，内表是大表。（示例二）

1 2	`select` `count` `(uid)` `from` `user` `where` `uid` `in` `(` `select` `driver_id` `from` `driver);` `select` `count` `(uid)` `from` `user` `where` `exists (` `select` `1` `from` `driver` `where` `driver.driver_id =` `user` `.uid);`

执行结果是：

可以发现in和exists的执行效率，在任何情况下都正好是相同的。基于此，我们继续查看示例一两条sql语句的执行计划，如下：

可以看到in和exists的执行计划是一样的，对此得出的结论两者的执行效率应该是一样的。

《mysql技术内幕：sql编程》：书中描述的确实有很多dba认为exists比in的执行效率更高，可能是当时优化器还不是很稳定和足够优秀，但是目前绝大数的情况下，in和exists都具有相同的执行计划。

如何提高效率？

上面示例二中的sql语句执行时间约8秒，因为存在m*n的原因造成慢查询，但是还是可以进行优化，注意到慢的原因就是内部每次与外部比较时，都需要遍历一次表操作，可以采用另外一个方法，在嵌套一层子查询，避免多次遍历操作，语句如下：

1	`select` `count` `(driver_id)` `from` `driver` `where` `exists (` `select` `uid` `from` `(` `select` `uid` `from` `user` `)` `as` `b` `where` `b.uid = driver.driver_id);`

执行效果如图：

可以发现优化减少了6s多的执行时间，下面是sql的执行计划：

同样的还是相关子查询，但是减少了内部遍历查询的操作。所以可以通过预查询来减少遍历操作，而提高效率。

其实在实际编程中，很多开发人员选择不使用连接表查询，而是自己先把数据从一张表中取出，再到另一张表中执行wherein操作，这原理和上面sql语句实现的是一样的。

mysql5.6对子查询的优化？

semi join策略

优化器会识别出需要子查询的in语句以便从区域表返回每个区域键的一个实例。这就导致了mysql会以半连接的方式执行select语句，所以全局表中每个区域只会有一个实例与记录相匹配。

半连接和常规连接之间存在两个非常重要的区别：

在半连接中，内表不会导致重复的结果。
此操作不会有内表中的字段添加到结果中去。

因此，半连接的结果常常是来自外表记录的一个子集。从有效性上看，半连接的优化在于有效的消除了来自内表的重复项，mysql应用了四个不同的半连接执行策略用来去重。

table pullout优化

convert the subquery to a join, or use table pullout and run the query as an inner join between subquery tables and outer tables. table pullout pulls a table out from the subquery to the outer query.将子查询转变为一个连接，或是利用table pullout并将查询作为子查询表和外表之间的一个内连接来执行。table pullout会为外部查询从子查询抽取出一个表。

有些时候，一个子查询可以被重写为join，例如：

1	`select` `orderid` `from` `orders` `where` `employeeid` `in` `(` `select` `employeeid` `from` `employees` `where` `employeeid > 3);`

如果知道orderid是唯一的，即主键或者唯一索引，那么sql语句会被重写为join形式。

1	`select` `orderid` `from` `orders` `join` `employees` `where` `orders.employeeid = employees.employeeid` `and` `employees.employeeid > 3;`

table pullout的作用就是根据唯一索引将子查询重写为join语句，在mysql 5.5中，上述的sql语句执行计划：

如果通过explain extended 和 show warnings命令，可以看到如下结果：

复制代码代码如下: select `northwind`.`orders`.`orderid` as `orderid` from `northwind`.`orders` where <in_optimizer>(`northwind`.`orders`.`employeeid`,<exists>(<primary_index_lookup>(<cache>(`northwind`.`orders`.`employeeid`) in employees on primary where ((`northwind`.`employees`.`employeeid` > 3) and (<cache>(`northwind`.`orders`.`employeeid`) = `northwind`.`employees`.`employeeid`)))))

正是上面说的in为什么慢？

在mysql 5.6中，优化器会对sql语句重写，得到的执行计划：

在mysql 5.6中，优化器没有将独立子查询重写为相关子查询，通过explain extended 和 show warnings命令，得到优化器的执行方式为：

复制代码代码如下: /* select#1 */ select `northwind`.`orders`.`orderid` as `orderid` from `northwind`.`employees` join `northwind`.`orders` where ((`northwind`.`orders`.`employeeid` = `northwind`.`employees`.`employeeid`) and (`northwind`.`employees`.`employeeid` > 3))

很显然，优化器将上述子查询重写为join语句，这就是table pullout优化。

duplicate weedout优化

run the semi-join as if it was a join and remove duplicate records using a temporary table.执行半连接，就如同它是一个连接并利用临时表移除了重复的记录。

上面内部表查出的列是唯一的，因此优化器会将子查询重写为join语句，以提高sql执行的效率。duplicate weedout优化是指外部查询条件是列是唯一的，mysql优化器会先将子查询查出的结果进行去重。比如下面这条sql语句：

1	`select` `contactname` `from` `customers` `where` `customerid` `in` `(` `select` `customerid` `from` `orders` `where` `orderid > 10000` `and` `customers.country = orders.shipcountry);`

因为customerid是主键，所以应该对子查询得到的结果进行去重。在mysql 5.6中的执行计划：

extra选项提示的start temporary表示创建一张去重的临时表，end temporary表示删除该临时表。而通过explain extended 和 show warnings命令，得到优化器的执行方式为：

复制代码代码如下: /* select#1 */ select `northwind`.`customers`.`contactname` as `contactname` from `northwind`.`customers` semi join (`northwind`.`orders`) where ((`northwind`.`customers`.`customerid` = `northwind`.`orders`.`customerid`) and (`northwind`.`customers`.`country` = `northwind`.`orders`.`shipcountry`) and (`northwind`.`orders`.`orderid` > 10000))

与table pullout优化不同的是，显示的是semi join而不是join，其中原因在于多了一些去重的工作，对于上述的执行计划，其扫描成本约为830+830*1=1660次。
而在mysql 5.5中的执行计划为：

可以看到，在mysql 5.5中还是将语句转化为相关子查询，扫描成本约为93+93*9=930次。

我们可以看到mysql 5.6优化以后比5.5的扫描成本反而大，其实这只是在两张表较小的的情况下的结果，如果表很大，优化的效果会非常明显。

materialization优化

materialize the subquery into a temporary table with an index and use the temporary table to perform a join. the index is used to remove duplicates. the index might also be used later for lookups when joining the temporary table with the outer tables; if not, the table is scanned.

上面的子查询是相关子查询，如果子查询是独立子查询，则优化器可以选择将独立子查询产生的结果填充到单独一张物化临时表中，如图：

根据join的顺序，materialization优化可分为：

materialization scan：join是将物化临时表和表进行关联。
materialization lookup：join是将表和物化临时表进行关联。

下面的子查询可以利用materialization来进行优化：

1	`select` `orderid` `from` `orders` `where` `orderid` `in` `(` `select` `orderid` `from` ` `order` details` `where` `unitprice < 50 );`

sql语句的执行计划：

可以看到，在进行join时（也就是id为1的步骤），先扫描的表是orders，然后是subquery2，因此这是materialization lookup的优化。对于下面的sql：

1	`select` `*` `from` `driver` `where` `driver_id` `in` `(` `select` `uid` `from` `user` `);`

sql语句的执行计划：

先扫描的是subquery2，再是driver表，这就是materialization scan的优化。

firstmacth优化

when scanning the inner tables for row combinations and there are multiple instances of a given value group, choose one rather than returning them all. this "shortcuts" scanning and eliminates production of unnecessary rows.为了对记录进行合并而在扫描内表，并且对于给定值群组有多个实例时，选择其一而不是将它们全部返回。这为表扫描提供了一个早期退出机制而且还消除了不必要记录的产生。

半连接的最先匹配(firstmatch)策略执行子查询的方式与mysql稍早版本中的in-to-exists是非常相似的。对于外表中的每条匹配记录，mysql都会在内表中进行匹配检查。当发现存在匹配时，它会从外表返回记录。只有在未发现匹配的情况下，引擎才会回退去扫描整个内表。

loosescan优化

scan a subquery table using an index that enables a single value to be chosen from each subquery's value group.利用索引来扫描一个子查询表可以从每个子查询的值群组中选出一个单一的值。

semi join变量

each of these strategies except duplicate weedout can be enabled or disabled using the optimizer_switch system variable. the semijoin flag controls whether semi-joins are used. if it is set to on, the firstmatch, loosescan, and materialization flags enable finer control over the permitted semi-join strategies. these flags are on by default.除duplicate weedout之外的每个策略可以用变量控制开关，semijoin控制semi-joins优化是否开启，如果设置开启，其他的策略也有独立的变量控制。所有的变量在5.6默认是打开的。

1 2 3 4 mysql> select @@optimizer_switch\g; *************************** 1. row *************************** @@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 1 row in set (0.00 sec)

explain查看策略

semi-joined tables show up in the outer select. explain extended plus show warnings shows the rewritten query, which displays the semi-join structure. from this you can get an idea about which tables were pulled out of the semi-join. if a subquery was converted to a semi-join, you will see that the subquery predicate is gone and its tables and where clause were merged into the outer query join list and where clause.
temporary table use for duplicate weedout is indicated by start temporary and end temporary in the extra column. tables that were not pulled out and are in the range of explain output rows covered by start temporary and end temporary will have their rowid in the temporary table.
firstmatch(tbl_name) in the extra column(列) indicates join shortcutting.
loosescan(m..n) in the extra column indicates use of the loosescan strategy. m and n are key part numbers.
as of mysql 5.6.7, temporary table use for materialization is indicated by rows with a select_type value of materialized and rows with a table value of .
before mysql 5.6.7, temporary table use for materialization is indicated in the extra column by materialize if a single table is used, or by start materialize and end materialize if multiple tables are used. if scan is present, no temporary table index is used for table reads. otherwise, an index lookup is used.

上面介绍中firstmacth优化、loosescan优化的具体效果没有很好的例子去显示出来。有机会可以交流学习。