【SQL】IN和EXISTS谁的效率更高

【SQL】IN和EXISTS谁的效率更高

总结：
索引设置好的情况下
子查询数据量大的，用exists
子查询数据量小的，用in

原文连接：https://zhuanlan.zhihu.com/p/400553948

IN和EXISTS被频繁使用在SQL中，虽然作用是一样的，但是在使用效率谁更高这点上众说纷纭。下面我们就通过一组测试来看，在不同场景下，使用哪个效率更高。

测试数据：

B表: 大表，大约300000行数据

CREATE TABLE `B` (
  `id` int NOT NULL AUTO_INCREMENT,
  `B_id` int NOT NULL,
  `value` varchar(20) NOT NULL,
  `flag` int not null,
   PRIMARY KEY (`id`),
   KEY `idx_b_flag` (`flag`),
   KEY `idx_b_id` (`B_id`)
)


A表: 小表，20000行数据

CREATE TABLE `A` (
  `id` int NOT NULL AUTO_INCREMENT,
  `flag` int NOT NULL,
  `value` varchar(20) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `idx_a_flag` (`flag`)
)

测试1：

子查询 select flag from B where B_id<100 结果集99条

select * from A where flag in (select flag from B where B_id<100 );
198 rows in set (0.00 sec)
select * from A where exists (select * from B where B_id<100 and A.flag=B.flag);
198 rows in set (0.10 sec)

可以看到IN效率高于EXISTS。

IN的执行计划：

（1）执行A表的查询，查询条件是A.flag在结果集B里面，可以使用到A表的索引flag。

（2）执行B表的子查询，得到结果集B，可以使用到B表的索引B_id；

EXISTS的执行计划：

（1）先将A表所有记录取到。

（2）逐行针对A表的记录，去关联B表，判断B表的子查询是否有返回数据，5.5之后的版本使用Block Nested Loop(Block 嵌套循环)。

（3）如果子查询有返回数据，则将A当前记录返回到结果集。

A相当于取全表数据遍历，B可以使用到索引。

测试2：
子查询 select flag from B where B_id>100 结果集 299899条

select * from A where flag in (select flag from B where B_id>100 );
19798 rows in set (0.09 sec)
select * from A where exists (select * from B where B_id>100 and A.flag=B.flag);
19798 rows in set (0.06 sec)

可以看到EXISTS效率这次比IN高。

两者的索引使用情况跟第一次实验是一致的，当子查询结果集很大，而外部表较小的时候，EXISTS的Block Nested Loop(Block 嵌套循环)的作用开始显现，查询效率会优于IN。

从两次测试来看，并不能说哪个效率高于哪个，而应该具体情况具体分析

首先先来看IN和EXISTS的执行原理：

IN是做外表和内表通过hash 连接，先查询子表，再查询主表，不管子查询是否有数据，都对子查询进行全部匹配。

EXISTS是外表做loop循环，先主查询，再子查询，然后去子查询中匹配，如果匹配到就退出子查询返回true，将结果放到结果集。

IN原理：

在in()的执行中，是先执行内表得到结果集，再执行外表，外表会对所有的内表结果集匹配，也就是如果外表有100，内表有10000，就会执行100*10000次，所以在内表比较大的时候，不合适用in()方法，效率比较低。

select * from 外表 a where id i n(select 相关id from 内表) in的执行类似如下：

List resultSet=[];
  Array A=(select * from A);
  Array B=(select id from B);
   
  for(int i=0;i<A.length;i++) {
     for(int j=0;j<B.length;j++) {
        if(A[i].id==B[j].id) {
           resultSet.add(A[i]);
           break;
        }
     }
  }
  return resultSet;
  

EXISTS原理：

exists()的执行过程中，并没有对每一条内表的数据都进行查询，而是存在该条数据的时候会将结果集存起来，到最后的时候同一输出结果集。
select a.* from 外表 a where exists(select 1 from 内表 b where a.id=b.id) 的EXISTS的执行语句如下：

List resultSet=[];
Array A=(select * from 外表 A)
 
for(int i=0;i<A.length;i++) {
   if(exists(A[i].id) {    //执行select 1 from 内表 b where b.id=a.id是否有记录返回
       resultSet.add(A[i]);
   }
}
return resultSet;

设:外表A，内表B。

A表有10000条记录,B表有1000000条记录, 那么exists()会执行10000次去判断A表中的id是否与B表中的id相等。
A表有10000条记录,B表有100000000条记录,那么exists()还是执行10000次,因为它只执行A.length次,可见B表数据越多,越适合exists()发挥效果。

再如:......

总结：
......

子查询结果集越大用EXISTS，子查询结果集越小，使用IN的索引优化效果更佳。