likes
comments
collection
share

MYSQL系列-SQL查询之JOIN

作者站长头像
站长
· 阅读数 19

前文学习了SQL查询，重点学习如何建索引，如何避免索引失效和慢查询优化建议。本文重点学习下JOIN相关语法

相关概念

各种JOIN

MYSQL系列-SQL查询之JOIN 连接分为三类：内连接、外连接、全连接

内连接

JOIN INNER JOIN

外连接

LEFT JOIN RIGHT JOIN

全连接

FULL JOIN MYSQL不支持，可以用UNION代替

SELECT * FROM t1
LEFT JOIN t2 ON t1.id = t2.id
UNION
SELECT * FROM t1
RIGHT JOIN t2 ON t1.id = t2.id

驱动表与被驱动表

概念解释

驱动表在SQL语句执行的过程中，总是先读取。而被驱动表在SQL语句执行的过程中，总是后读取。

如何区分驱动表和被驱动表

可以使用explain命令查看一下SQL语句的执行计划。在输出的执行计划中，排在第一行的表是驱动表，排在第二行的表是被驱动表。

left join

左表示驱动表，右表示被驱动表。 select * from A as a left join B as b on a.id = b.id; 上述A left join B

right join

右表示驱动表，左表示被驱动表。 select * from A as a right join B as b on a.id = b.id; 上述A right join B

inner join

对于inner join 而言，MySQL 会选择小表 作为驱动表，大表 作为被驱动表。

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

straight_join

用 straight_join 让 MySQL 使用固定的连接方式执行查询，这样优化器只会按照我们指定的方式去 join 左表驱动右表

JOIN执行相关概念

构造数据

mysql> CREATE TABLE `t7` (
    ->   `id` int(11) NOT NULL,
    ->   `a` int(11) DEFAULT NULL,
    ->   `b` int(11) DEFAULT NULL,
    ->   PRIMARY KEY (`id`),
    ->   KEY `a` (`a`)
    -> ) ENGINE=InnoDB;
Query OK, 0 rows affected (0.05 sec)
mysql> delimiter ;;
mysql> create procedure idata()
    -> begin
    ->   declare i int;
    ->   set i=1;
    ->   while(i<=1000)do
    ->     insert into t7 values(i, i, i);
    ->     set i=i+1;
    ->   end while;
    -> end;;
Query OK, 0 rows affected (0.00 sec)

mysql> delimiter ;
mysql> call idata();
Query OK, 1 row affected (4.43 sec)

mysql> create table t6 like t7;
Query OK, 0 rows affected (0.03 sec)

mysql> insert into t6 (select * from t7 where id<=100);
Query OK, 100 rows affected (0.01 sec)
Records: 100  Duplicates: 0  Warnings: 0

Index Nested-Loop Join

mysql> explain select * from t6 straight_join t7 on (t6.a=t7.a);
+----+-------------+-------+------------+------+---------------+------+---------+-----------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref       | rows | filtered | Extra       |
+----+-------------+-------+------------+------+---------------+------+---------+-----------+------+----------+-------------+
|  1 | SIMPLE      | t6    | NULL       | ALL  | a             | NULL | NULL    | NULL      |  100 |   100.00 | Using where |
|  1 | SIMPLE      | t7    | NULL       | ref  | a             | a    | 5       | toby.t6.a |    1 |   100.00 | NULL        |
+----+-------------+-------+------------+------+---------------+------+---------+-----------+------+----------+-------------+
2 rows in set, 1 warning (0.00 sec)

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

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

这个过程是先遍历表 t6，然后根据从表 t6 中取出的每行数据中的 a 值，去表 t7 中查找满足条件的记录。在形式上，这个过程就跟我们写程序时的嵌套查询类似，并且可以用上被驱动表的索引，所以我们称之为“Index Nested-Loop Join”，简称 NLJ。

在这个流程里：

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

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

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

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

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

显然，N 对扫描行数的影响更大，因此应该让小表来做驱动表。

如果你没觉得这个影响有那么“显然”， 可以这么理解：N 扩大 1000 倍的话，扫描行数就会扩大 1000 倍；而 M 扩大 1000 倍，扫描行数扩大不到 10 倍。

到这里小结一下，通过上面的分析我们得到了两个结论：

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

Simple Nested-Loop Join

如果被驱动表用不上索引 select * from t6 straight_join t7 on (t6.a=t7.b); t7没有索引，走的全表扫描，总共扫描100*1000=10万行

Block Nested-Loop Join

MySQL 也没有使用这个 Simple Nested-Loop Join 算法，而是使用了另一个叫作“Block Nested-Loop Join”的算法

mysql> explain select * from t6 straight_join t7 on (t6.a=t7.b);
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------------------------------------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                                              |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------------------------------------------+
|  1 | SIMPLE      | t6    | NULL       | ALL  | a             | NULL | NULL    | NULL |  100 |   100.00 | NULL                                               |
|  1 | SIMPLE      | t7    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 1000 |    10.00 | Using where; Using join buffer (Block Nested Loop) |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------------------------------------------+
2 rows in set, 1 warning (0.00 sec)

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

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

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

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

接下来，我们来看一下，在这种情况下，应该选择哪个表做驱动表。

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

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

可以看到，调换这两个算式中的 M 和 N 没差别，因此这时候选择大表还是小表做驱动表，执行耗时是一样的。

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

因此，算法归纳如下：

驱动表的数据行数是 N，需要分 K 段才能完成算法流程，被驱动表的数据行数是 M。

注意，这里的 K 不是常数，N 越大 K 就会越大，因此把 K 表示为λ*N，显然λ的取值范围是 (0,1)。

所以，在这个算法的执行过程中：

  1. 扫描行数是 N+λNM；
  2. 内存判断 N*M 次。

在 N+λNM 这个式子里，λ才是影响扫描行数的关键因素，这个值越小越好。λ受join_buffer_size影响

Multi-Range Read 优化


mysql> create table t8(id int primary key, a int, b int, index(a));
Query OK, 0 rows affected (0.03 sec)

mysql> create table t9 like t8;
Query OK, 0 rows affected (0.03 sec)


mysql> drop procedure idata1;
ERROR 1305 (42000): PROCEDURE toby.idata1 does not exist
mysql> delimiter ;;
mysql> create procedure idata1()
    -> begin
    ->   declare i int;
    ->   set i=1;
    ->   while(i<=1000)do
    ->     insert into t8 values(i, 1001-i, i);
    ->     set i=i+1;
    ->   end while;
    ->
    ->   set i=1;
    ->   while(i<=1000000)do
    ->     insert into t9 values(i, i, i);
    ->     set i=i+1;
    ->   end while;
    ->
    -> end;;
Query OK, 0 rows affected (0.01 sec)

mysql> delimiter ;
mysql>
mysql>
mysql>
mysql> call idata1();

MRR优化的主要目的是尽量使用顺序读盘

如下SQL，普通索引查询会有回表过程 select * from t8 where a>=1 and a<=100;

MYSQL系列-SQL查询之JOIN 如果随着 a 的值递增顺序查询的话，id 的值就变成随机的，那么就会出现随机访问，性能相对较差。虽然“按行查”这个机制不能改，但是调整查询的顺序，还是能够加速的。

因为大多数的数据都是按照主键递增顺序插入得到的，所以我们可以认为，如果按照主键的递增顺序查询的话，对磁盘的读比较接近顺序读，能够提升读性能。

就是 MRR 优化的设计思路。此时，语句的执行流程变成了这样：

  1. 根据索引 a，定位到满足条件的记录，将 id 值放入 read_rnd_buffer 中 ;
  2. 将 read_rnd_buffer 中的 id 进行递增排序；
  3. 排序后的 id 数组，依次到主键 id 索引中查记录，并作为结果返回。

这里，read_rnd_buffer 的大小是由 read_rnd_buffer_size 参数控制的。如果步骤 1 中，read_rnd_buffer 放满了，就会先执行完步骤 2 和 3，然后清空 read_rnd_buffer。之后继续找索引 a 的下个记录，并继续循环。

设置完MRR执行计划如下：

mysql> explain select * from t8 where a>=1 and a<=100;
+----+-------------+-------+------------+-------+---------------+------+---------+------+------+----------+-----------------------+
| id | select_type | table | partitions | type  | possible_keys | key  | key_len | ref  | rows | filtered | Extra                 |
+----+-------------+-------+------------+-------+---------------+------+---------+------+------+----------+-----------------------+
|  1 | SIMPLE      | t8    | NULL       | range | a             | a    | 5       | NULL |  100 |   100.00 | Using index condition |
+----+-------------+-------+------------+-------+---------------+------+---------+------+------+----------+-----------------------+
1 row in set, 1 warning (0.00 sec)

mysql> set optimizer_switch='mrr=on,mrr_cost_based=off,batched_key_access=on';
Query OK, 0 rows affected (0.00 sec)

mysql> explain select * from t8 where a>=1 and a<=100;
+----+-------------+-------+------------+-------+---------------+------+---------+------+------+----------+----------------------------------+
| id | select_type | table | partitions | type  | possible_keys | key  | key_len | ref  | rows | filtered | Extra                            |
+----+-------------+-------+------------+-------+---------------+------+---------+------+------+----------+----------------------------------+
|  1 | SIMPLE      | t8    | NULL       | range | a             | a    | 5       | NULL |  100 |   100.00 | Using index condition; Using MRR |
+----+-------------+-------+------------+-------+---------------+------+---------+------+------+----------+----------------------------------+
1 row in set, 1 warning (0.00 sec)

Batched Key Access

理解了 MRR 性能提升的原理，我们就能理解 MySQL 在 5.6 版本后开始引入的 Batched Key Access(BKA) 算法了。这个 BKA 算法，其实就是对 NLJ 算法的优化。

在Batched Key Access中，MySQL会将多个Join操作中的关键字列值进行排序，并将它们存储在内存中。然后，MySQL会一次性读取这些值，并使用它们来获取Join操作所需的所有数据。这可以减少磁盘访问次数，加快查询速度。

如果要使用 BKA 优化算法的话，你需要在执行 SQL 语句之前，先设置 set optimizer_switch='mrr=on,mrr_cost_based=off,batched_key_access=on';

优化总结

  1. 在使用 join 的时候，应该让小表做驱动表
  2. 不能使用被驱动表的索引，只能使用 Block Nested-Loop Join 算法，这样的语句就尽量不要使用
  3. BNL 算法效率低，建议你都尽量转成 BKA 算法。优化的方向就是给被驱动表的关联字段加上索引
  4. 某些被驱动表不适合加索引或者代价太大，可以基于临时表的改进方案，对于能够提前过滤出小数据的 join 语句来说
  5. MySQL 目前的版本还不支持 hash join，但你可以配合应用端自己模拟出来

优化案例

案例1：基于临时表的改进方案，对于能够提前过滤出小数据

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

t9 中插入了 100 万行数据，但是经过 where 条件过滤后，需要参与 join 的只有 2000 行数据。如果这条语句同时是一个低频的 SQL 语句，那么再为这个语句在表 t9 的字段 b 上创建一个索引就很浪费了。

但是，如果使用 BNL 算法来 join 的话，这个语句的执行流程是这样的：

  1. 把表 t8 的所有字段取出来，存入 join_buffer 中。这个表只有 1000 行，join_buffer_size 默认值是 256k，可以完全存入。

  2. 扫描表 t9，取出每一行数据跟 join_buffer 中的数据进行对比，

    • 如果不满足 t8.b=t9.b，则跳过；
    • 如果满足 t8.b=t9.b, 再判断其他条件，也就是是否满足 t2.b 处于 [1,2000] 的条件，如果是，就作为结果集的一部分返回，否则跳过。

我在上一篇文章中说过，对于表 t2 的每一行，判断 join 是否满足的时候，都需要遍历 join_buffer 中的所有行。因此判断等值条件的次数是 1000*100 万 =10 亿次，这个判断的工作量很大。

可以改成基于临时表的方案

案例2：应用端过滤

上述案例1，可以自己实现在业务端。实现流程大致如下：

  1. select * from t8;取得表 t8 的全部 1000 行数据，在业务端存入一个 hash 结构
  2. select * from t9 where b>=1 and b<=2000; 获取表 t9 中满足条件的 2000 行数据。
  3. 把这 2000 行数据，一行一行地取到业务端，到 hash 结构的数据表中寻找匹配的数据。满足匹配的条件的这行数据，就作为结果集的一行。

理论上，这个过程会比临时表方案的执行速度还要快一些。

案例3：复杂SQL加索引

SQL如下 select * from t1 join t2 on(t1.a=t2.a) join t3 on (t2.b=t3.b) where t1.c>=X and t2.c>=Y and t3.c>=Z;

第一原则是要尽量使用 BKA 算法。需要注意的是，使用 BKA 算法的时候，并不是“先计算两个表 join 的结果，再跟第三个表 join”，而是直接嵌套查询的。

具体实现是：在 t1.c>=X、t2.c>=Y、t3.c>=Z 这三个条件里，选择一个经过过滤以后，数据最少的那个表，作为第一个驱动表。此时，可能会出现如下两种情况。

第一种情况，如果选出来是表 t1 或者 t3，那剩下的部分就固定了。

  1. 如果驱动表是 t1，则连接顺序是 t1->t2->t3，要在被驱动表字段创建上索引，也就是 t2.a 和 t3.b 上创建索引；
  2. 如果驱动表是 t3，则连接顺序是 t3->t2->t1，需要在 t2.b 和 t1.a 上创建索引。

同时，我们还需要在第一个驱动表的字段 c 上创建索引。

第二种情况是，如果选出来的第一个驱动表是表 t2 的话，则需要评估另外两个条件的过滤效果。

总之，整体的思路就是，尽量让每一次参与 join 的驱动表的数据集，越小越好，因为这样我们的驱动表就会越小。

延伸

延伸1：使用 Block Nested-Loop Join 算法，可能会因为 join_buffer 不够大，需要对被驱动表做多次全表扫描，会产生哪些问题？

如果这个被驱动表是一个大的冷数据表，除了会导致 IO 压力大以外，还会对系统有什么影响呢？

由于 InnoDB 对 Bufffer Pool 的 LRU 算法做了优化，即：第一次从磁盘读入内存的数据页，会先放在 old 区域。如果 1 秒之后这个数据页不再被访问了，就不会被移动到 LRU 链表头部，这样对 Buffer Pool 的命中率影响就不大。

但是，如果一个使用 BNL 算法的 join 语句，多次扫描一个冷表，而且这个语句执行时间超过 1 秒，就会在再次扫描冷表的时候，把冷表的数据页移到 LRU 链表头部。

这种情况对应的，是冷表的数据量小于整个 Buffer Pool 的 3/8，能够完全放入 old 区域的情况。

如果这个冷表很大，就会出现另外一种情况：业务正常访问的数据页，没有机会进入 young 区域。

大表 join 操作虽然对 IO 有影响，但是在语句执行结束后，对 IO 的影响也就结束了。但是，对 Buffer Pool 的影响就是持续性的，需要依靠后续的查询请求慢慢恢复内存命中率。

BNL 算法对系统的影响主要包括三个方面：

  1. 可能会多次扫描被驱动表，占用磁盘 IO 资源；
  2. 判断 join 条件需要执行 M*N 次对比（M、N 分别是两张表的行数），如果是大表就会占用非常多的 CPU 资源；
  3. 可能会导致 Buffer Pool 的热数据被淘汰，影响内存命中率。

参考： 1.MySQL中的各种join 2.MySQL中的驱动表和被驱动表的解读 3.MYSQL实战45讲

转载自:https://juejin.cn/post/7253391363453599802
评论
请登录