34 | 到底可不可以使用join？

最新推荐文章于 2024-07-15 22:37:47 发布

转载最新推荐文章于 2024-07-15 22:37:47 发布 · 512 阅读

1 ·

CC 4.0 BY-SA版权

原文链接：https://time.geekbang.org/column/article/79700

MySQL 专栏收录该内容

48 篇文章

订阅专栏

本文深入探讨了SQL Join语句的使用场景与优化策略，包括Index Nested-Loop Join和Block Nested-Loop Join两种算法的区别，以及如何选择合适的驱动表来提高查询效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实际生产中长会碰到两个问题：

DBA不让使用join，使用join有什么问题？
如果有两个大小不同的表做join，应该使用哪个表做驱动表呢？

示例表：

CREATE TABLE `t2` (
`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<=1000)do
insert into t2 values(i, i, i);
set i=i+1;
end while;
end;;
delimiter ;
call idata();

create table t1 like t2;
insert into t1 (select * from t2 where id<=100)

两个表都有一个主键索引id和一个索引a，字段b上无索引。t2有1000行数据，t1有100行。

Index Nested-Loop Join

这个语句：

select * from t1 straight_join t2 on t1.a=t2.a;

说明：如果直接使用join语句，MySQL优化器可能会选择表t1或者t2作为驱动表，这样影响我们分析语句的执行过程。所以为了便于分析，改用straight_join让MySQL使用固定的连接方式执行查询，这样优化器只会按照我们指定的方式去join。

这个语句里t1表是驱动表，t2表是被驱动表。

explain结果：

被驱动表t2的字段a上有索引，join过程用上了这个索引，因此这个语句的执行流程是这样的：

从表t1中读入一行数据R；
从数据行R中，取出a字段到表t2里去查找；
取出表t2中满足条件的行，跟R组成一行，作为结果集的一部分；
重复步骤1到3，直到表t1的末尾循环结束。

这个过程称之为“Index Nested-Loop Join”，简称NLJ。

在这个流程里：

对驱动表t1做了全表扫描，这个过程需要扫描100行；
而对于每一行R，根据a字段去表t2查找，走的是树搜索过程。由于我们构造的数据都是一一对应的，因此每次的搜索过程都只扫描一行，也是总共扫描100行；
所以，整个执行流程，总扫描行数是200。

开头的两个问题，先看第一个问题：能不能使用Join？

假设不使用join，那我们就只能用单表查询。上面这条语句用单标查询怎么实现。

执行select * from t1，查出表t1的所有数据，这里有100行；
循环遍历这100行数据：①从每一行R取出字段a的值$R.a；②执行select * from t2 where a=$R.a；③把返回的结果和R构成结果集的一行。

在这个查询过程中也是扫描了200行，但是总共执行了101条语句，比直接join多了100次交互。除此之外，客户端还要自己拼接SQL语句和结果。

显然，这么做还不如直接join好。

第二个问题：怎么选择驱动表？

这个join过程中，驱动表是走全表扫描，而被驱动表是走树搜索。

假设被驱动表的行数是M，每次在被驱动表查一行数据，要先搜索索引a，再搜索主键索引（回表）。每次搜索一颗树近似复杂度是以2为底的M的对数，记为log2M，所以在被驱动表上查一行的时间复杂度是2*log2M。

假设驱动表的行数是N，执行过程就要扫描驱动表N行，然后对于每一行，到被驱动表上匹配一次。

因此整个执行过程，近似的复杂度是N + N*2*log2M。

显然，N对扫描行数的影响更大，因此应该让小表来做驱动表。也可以这样理解：N扩大1000倍的话，扫描行数就会扩大1000倍；而M扩大1000倍的话，扫描行数扩大不到10倍。

前面的分析得到两个结论：

使用join语句，性能比强拆成多个单表执行SQL语句的性能要好；
如果使用join语句，需要让小表做驱动表。

但是这个前提是“可以使用被驱动表的索引”。

被驱动表用不上索引的情况。

Simple Nested-Loop Join

SQL语句改成这样：

select * from t1 straight_join t2 on t1.a=t2.b;

表t2的字段b上没有索引，每次到t2去匹配的时候，就要做一次全表扫描。

如果继续使用上面的NLJ算法的执行流程，是不是可以得到正确的结果呢？如果只看结果的话，这个算法是正确的，而且这个算法也有一个名字，叫“Simple Nested-Loop Join”。

但是这样看来，这个SQL语句就要扫描表t2多达100次，总共扫描100*1000=10万行。

如果真的是这样的话，如果表t1和t2都是10万行，就要扫描100亿行，这肯定是不行的。

所以，MySQL也没有使用这个叫做Simple Nested-Loop Join的算法，而是使用了另一个叫做“Block Nested-Loop Join”的算法，简称BNL。

Block Nested-Loop Join

这时候，被驱动表上没有可用的索引，算法流程是这样的：

把表t1的数据读入线程内存join_buffer中，由于我们这个语句中写的是select *，因此是把整个表t1放入了内存；
扫描表t2，把表t2中的每一行取出来，跟join_buffer中的数据做对比，满足条件的，作为结果集的一部分返回。

这个过程的流程如下图：

这条SQL语句explain结果如下：

在这个过程中，对表t1和t2都做了一次全表扫描，因此总的扫描行数是1100。由于join_buffer是以无序数组的方式组织的，因此对表t2中的每一行，都要做100次判断，总共需要在内存中做的判断次数是：100*1000=10万次。

前面的Simple Nested-Loop Join算法进行查询，扫描行数也是10万行。因此，从时间复杂度上来说，这两个算法是一样的。但是，Block Nested-Loop Join算法的这10万次判断是内存操作的，性能也更好。

这种情况下，应该选择哪个表做驱动表呢？

假设小表的行数是N，大表的行数是M，那么在这个算法里：

两个表都做一次全表扫描，所以总的扫描行数是M+N;
内存判断次数是M*N。

可以看出这时候，选大表还是小表做驱动表，执行耗时是一样的。

这个例子里表t1才100行，要是表t1是一个大表，join_buffer放不下怎么办呢？

join_buffer的大小是由参数join_buffer_size设定的，默认值是256k。如果放不下表t1的所有数据，策略很简单，就是分段放。

select * from t1 straight_join t2 on (t1.a=t2.a);

分段的话，执行流程就变成了：

扫描表t1，顺序读取数据行放入join_buffer中，放完第88行join_buffer就满了，继续第2步；
扫描表t2，把t2中的每一行取出来，跟join_buffer中的数据做对比，满足join条件的，作为结果集的一部分返回；
清空join_buffer；
继续扫描表t1，顺序读取最后的12行数据放入join_buffer中，继续执行第2步。

执行流程就变成这了：

这个流程才体现出这个算法的名字中“Block”的由来，表示“分块去join”。

这时候由于表t1被分成了两次放入join_buffer中，导致表t2被扫描了两次，也就是说对t2表做了两次全表扫描，虽然分成两次放入join_buffer，但是判断等值条件的次数还是不变的，依然是（88+12）*1000=10万次。

这种情况下，驱动表的选择问题：

假设，驱动表的行数是N，需要分成K段才能完成算法流程，被驱动表的行数是M。这里，K不是一个常数，N越大，K就会越大，假设N和K的关系用这个表达式表示：K=λ*N（λ肯定是0到1之间的一个小数）。

所以执行过程中：

扫描行数：N+λ*N*M； /*被分成了多少段，就要对被驱动表多少次的全表扫描*/
内存判断N*M次。

显然，内存判断次数是不受选择哪个表作为驱动表影响的。而考虑到扫描行数，在M和N大小确定的情况下，N小一些，整个算式的结果会更小。

所以，最终结论也是应该让小表做驱动表。

上面说，N越大，分段数K也越大，那么N固定的时候，什么参数会影响K的大小呢？（也就是λ的大小），答案是join_buffer_size。join_buffer_size越大，一次可以放进去的行越多，分成的段数也就越少，对被驱动表的全表扫描次数就越少。这就是为什么，可能有时候DBA会建议如果join语句很慢，就把join_buffer_size改大点。

开头的两个问题：

第一个问题：能不能使用join语句？

如果可以使用Index Nested-Loop Join算法，也就是说可以用上被驱动表上的索引，是没问题的；
如果使用Block Nested-Loop Join算法，扫描行数会过多。尤其是在大表上的join操作，这样可能要扫描被驱动表很多次，会占用大量的系统资源。所以这时候，就要多加考虑了，能不用就尽量不用。可以通过explain分析SQL语句（可以看Extra字段里有没有出现“Block Nested Loop字样”），寻找最优解决方案。

第二个问题是：如果要使用join，应该选择大表做驱动还是选择小表做驱动表？

如果是Index Nested-Loop Join算法，应该选择小表做驱动表；
如果是Block Nested-Loop Join算法：

在join_buffer_size足够大的时候，是一样的；
在join_buffer_size不够大的时候，应该选择小表做驱动表。（这种情况一般是最常见的）

所以，这个问题的结论就是，总是应该使用小表做驱动表。

最后还有问题说明一下，什么叫做“小表”。

前面的例子是没有加条件的，看下面两条语句：

select * from t1 straight_join t2 on (t1.b=t2.b) where t2.id<=50;

select * from t2 straight_join t1 on (t1.b=t2.b) where t2.id<=50;

两条语句都使用了没有索引的字段b。

但是如果用第二个语句的话，join_buffer只需要放入t2的前50行，显然是更好的。所以这里，“t2的前50行”是哪个相对小的表，也就是“小表”。

另一个例子：

select t1.b,t2.* from t1 straight_join t2 on (t1.b=t2.b) where t2.id<=100;
select t1.b,t2.* from t2 straight_join t1 on (t1.b=t2.b) where t2.id<=100;

表t1和t2都是只有100行参加join，但是这两条语句每次查询放入join_buffer中的数据是不一样的：

表t1只查字段b，因此如果把t1放到join_buffer中，则join_buffer中只需要放入b的值；
表t2需要查所有的字段，因此如果把表t2放到join_buffer中的话，就需要放入三个字段id、a和b。

这里，我们应该选择表t1作为驱动表。也就是说这个例子里，“只需要一列参与join的表t1”是那个相对小的表。

更准确的说，在决定哪个表做驱动表的时候，应该是两个表按照各自的条件过滤，过滤完成之后，计算参与join的各个字段的总数据量，数据量小的那个表，就是“小表”，应该作为驱动表。

上一篇：33 | 我查这么多数据，会不会把数据库内存打爆

下一篇：35 | join语句怎么优化