昨天我们聊到了索引失效的常见场景,今天我们接着深入探讨如何优化SQL中的关联查询,特别是左外连接、内连接以及JOIN语句的优化技巧。
我们会结合实际代码,带你更直观地理解JOIN的原理,并介绍几种不同的连接方式,比如简单嵌套循环连接、索引嵌套循环连接和块嵌套循环连接。掌握这些技巧后,你会发现优化多表查询的性能变得更加得心应手。
除此之外,我们还会讨论哈希连接和子查询优化,帮助你全面提升SQL查询的效率,让你对SQL优化有更清晰的认识。
1. 关联查询优化
1.1 数据准备
# 学生表
CREATE TABLE IF NOT EXISTS `student` (
`student_id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, -- 学生ID
`class_num` INT(10) UNSIGNED NOT NULL, -- -- 班级号码
PRIMARY KEY (`student_id`)
);
# 班级表
CREATE TABLE IF NOT EXISTS `class` (
`id` INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, -- 班级ID 主键
`class_num` INT(10) UNSIGNED NOT NULL, -- 班级号码
PRIMARY KEY (`id`)
);
留意一下这里没有使用主键进行关联。因为会走索引,下面会解释。
使用储存过程向向这两张表中插入50条数据
#向分类表中添加20条记录
INSERT INTO student (class_num) VALUES (FLOOR(1 +(RAND() * 20)));
#向图书表中添加20条记录
INSERT INTO class(class_num) VALUES (FLOOR(1 +(RAND() * 20)) );
1.2 首先是左外连接
在navicat上面进行EXPLAIN 分析
EXPLAIN SELECT SQL_NO_CACHE * FROM `student` LEFT JOIN class ON student.class_num = class.class_num;
从图中可以发现这两张表的type
都是ALL。说明都进行了全表扫描性能是很差的 添加索引优化
# 添加索引
ALTER TABLE class ADD INDEX Y(class_num); #【被驱动表】,可以避免全表扫描
# 继续执行
EXPLAIN SELECT SQL_NO_CACHE * FROM `student` LEFT JOIN class ON student.class_num = class.class_num;
可以看到第二行的 type 变为了 ref,rows 也变成了优化比较明显。这是由左连接特性决定的。LEFT JOIN条件用于确定如何从右表搜索行,左边一定都有,所以 右边是我们的关键点,一定需要建立索引 。
如果只能添加一边的索引,,那就给
被驱动表
添加上索引。
ALTER TABLE `type` ADD INDEX X (card); #【驱动表】,无法避免全表扫描
EXPLAIN SELECT SQL_NO_CACHE * FROM `type` LEFT JOIN book ON type.card = book.card;
由于navciat的背景颜色是白色不便于观看所以以下操作都在MySQL里面执行
接着:
DROP INDEX Y ON class;# 去掉被驱动表的索引
EXPLAIN SELECT SQL_NO_CACHE * FROM `type` LEFT JOIN book ON type.card = book.card;
去掉被驱动索引,又变成了 join buffer
1.3 采用内连接
首先我们要知道
驱动表是在第一行,被驱动表是在第二行
删除之前建立的索引
drop index Y on class;
drop index X on student;
换成 inner join(MySQL自动选择驱动表)
EXPLAIN SELECT SQL_NO_CACHE * FROM `student` inner join class ON student.class_num = class.class_num;
在没有索引的情况下
添加索引优化 ,此时两个表数据相同
ALTER TABLE class ADD INDEX Y (class_num);
EXPLAIN SELECT SQL_NO_CACHE * FROM `student` inner join class ON student.class_num = class.class_num;
# type 加索引
ALTER TABLE student ADD INDEX X (class_num);
# 观察执行情况
EXPLAIN SELECT SQL_NO_CACHE * FROM `student` inner join class ON student.class_num = class.class_num;
这里刚给student加了索引后,驱动表和被驱动表还是原来的样子。class在上,student在下
给student 继续加了一些数据后
优化器会判断,哪个数据比较少。就作为驱动表
结论:
-
内连接
主被驱动表是由优化器决定的。优化器认为哪个成本比较小,就采用哪种作为驱动表。 -
如果两张表只有一个有索引,那有索引的表作为
被驱动表
。- 原因:驱动表要全查出来。有没有索引你都得全查出来。
-
两个索引都存在的情况下, 数据量大的 作为
被驱动表
(小表驱动大表)- 原因:驱动表要全部查出来,而大表可以通过索引加快查找
1.4 join语句原理
join方式连接多个表,本质就是各个表之间数据的循环匹配。MySQL5.5欣本之前,MySQL只文持一种表间关联方式,就是嵌套循环(Nested Loop Join
)。如果关联表的数据量很大,则join关联的执行时间会非常长。在MySQL5.5以后的版本中,MySQL通过引入BNLJ
算法来优化嵌套执行。
1.驱动表和被驱动表
驱动表就是主表,被驱动表就是从表、非驱动表。
-
对于内连接来说:
SELECT * FROM A JOIN B ON ...
A一定是驱动表吗?不一定,优化器会根据你查询语句做优化,决定先查哪张表。先查询的那张表就是驱动表,反之就是被驱动表。通过explain关键字可以查看。
-
对于外连接来说:
SELECT * FROM A LEFT JOIN B ON ... #或 SELECT *FROM B RIGHT JOIN A ON ...
通常,大家会认为A就是驱动表,B就是被驱动表。但也未必。测试如下:
CREATE TABLE a(f1 INT,f2 INT,INDEX(f1))ENGINE=INNODB; CREATE TABLE b(f1 INT,f2 INT)ENGINE=INNODB; INSERT INTO a VALUES(1,1),(2,2),(3,3),(4,4),(5,5),(6,6); INSERT INTO b VALUES (3,3),(4,4),(5,5),(6,6),(7,7),(8,8); #测试1 EXPLAIN SELECT* FROM a LEFT JOIN b ON (a.f1=b.f1)WHERE (a.f2=b.f2); #测试2 EXPLAIN SELECT * FROM a LEFT JOIN b oN (a.f1=b.f1) AND (a.f2=b.f2);
测试1结果:
得出这种结论太不可思议了,跟上一个show warnings 看看:
测试2结果:
继续show warnings \G
2.Simple Nested-Loop Join(简单嵌套循环连接)
算法相当简单,从表A中取出一条数据1,遍历表B,将匹配到的数据放到result..以此类推,驱动表A中的每一条记录与被驱动表B的记录进行判断:
这个例子是在没有索引的情况,做了全表扫描
可以看到这种方式效率是非常低的,以上述表A数据100条,表B数据1000条计算,则A*B=10万次。开销统计如下:
当然mysql肯定不会这么粗暴的去进行表的连接,所以就出现了后面的两种对Nested-Loop Join优化算法。
3.Index Nested-Loop Join(索引嵌套循环连接)
Index Nested-Loop Join其优化的思路主要是为了减少内层表数据的匹配次数
,所以要求被驱动表上必须有索引
才行。通过外层表匹配条件直接与内层表索引进行匹配,避免和内层表的每条记录去进行比较,这样极大的减少了对内层表的匹配次数。
驱动表中的每条记录通过被驱动表的索引进行访问,因为索引查询的成本是比较固定的,故mysql优化器都倾向于使用记录数少的表作为驱动表(外表)。
如果被驱动表加索引,效率是非常高的,但如果索引不是主键索引,所以还得进行一次回表查询。相比,被驱动表的索引是主键索引,效率会更高。
4.Block Nested-Loop Join(块嵌套循环连接)
如果存在索引,那么会使用index的方式进行join,如果join的列没有索引,被驱动表要扫描的次数太多了。每次访问被驱动表,其表中的记录都会被加载到内存中,然后再从驱动表中取一条与其匹配,匹配结束后清除内存,然后再从驱动表中加载一条记录,然后把被驱动表的记录在加载到内存匹配这样周而复始,大大增加了I0的次 数。为了减少被驱动表的Io次数,就出现了Block Nested-Loop Join的方式。
不再是逐条获取驱动表的数据,而是一块一块的获取,引入了join buffer缓冲区
,将驱动表join
相关的部分数据列(大小受join buffer的限制)缓存到join buffer中,然后全表扫描被驱动表被驱动表的每—条记录—次性和join buffer中的所有驱动表记录进行匹配(内存中操作
),将简单嵌套循环中的多次比较合并成一次,降低了被驱动 表的访问频率。
注意:
这里缓存的不只是关联表的列, select后面的列也会缓存起来。 (存的是驱动表)
在一个有N个join关联的sql中会分配N-1个join buffer。所以查询的时候尽量减少不必要的字段,可以让joinbuffer中可以存放更多的列。
可能解释一下为什么A表中可以一次性插入join Buffer,而去匹配B表则需要分块
统一规范 A表为驱动表,B表为被驱动表
对于BNLJ 开销的解释
外表A扫描次数:1
因为受join buffer大小的限制,A表的内容可能不能一次性加载到join buffer。所以将A表分块一块一块得到加载到join buffer缓存中。也就是说A表中的每一条记录都会被一次性读取,然后逐块放入到join buffer中。所以对A表只扫描了一次
内表B扫描次数: A * used_column_size / join_buffer_size + 1
次
- Join Buffer 的大小为
join_buffer_size
。 - A 表的数据总大小为
A* used_column_siz
于是,驱动表 A 被分成 A * used_column_size / join_buffer_size
个块(假设整除的情况下)。加上 +1
是为了考虑最后一块可能不满缓冲区的情况
每次加载一个 A 表的分块后,B 表都需要扫描一次,即 A * used_column_size / join_buffer_size + 1
读取记录数: **A + B * (A * used_column_size / join_buffer_size) 整除情况下**
驱动表 A 的记录数为 A(全部读取一遍),内表 B 会随着每块 A 的数据被扫描一次,因此读取记录数是 B * (A * used_column_size / join_buffer_size)
。
join 比较次数:A * B
因为A表中的数据要于B表中的数据每个都比对一次
参数设置:
-
block_nested_loop
通过
show variables like '%optimizer_switch%'
查看block_nested_loop
状态。默认是开启的。. - - -
join_buffer_size
驱动表能不能一次加载完,要看join buffer能不能存储所有的数据,默认情况下
join_buffer_size=256k
。mysql> show variables like '%join_buffer%'; +------------------+--------+ | Variable_name | Value | +------------------+--------+ | join_buffer_size | 262144 | +------------------+--------+ 1 row in set (0.00 sec)
join_buffer_size的最大值在32位系统可以电请4G,而在64位操做系统下可以申请大于4G的Join Buffer空间(64位Windows除外,其大值会被截断为4GB并发出警告)。
5.Join小结
1、整体效率比较:INLJ > BNLJ > SNLJ
2、永远用小结果集驱动大结果集(其本质就是减少外层循环的数据数量)(小的度量单位指的是表行数*每行大小)
# straight_join 不然优化器优化谁是驱动表 驱动表 straight_join 被驱动表
# 这个例子是说t2 的列比较多,,相同的join buffer 加的会比较少。所以不适合用t2 作为 !!!驱动表
select t1.b,t2.* from t1 straight_join t2 on (t1.b=t2.b) where t2.id<=180;#推荐
select t1.b,t2.* from t2 straight_join t1 on (t1.b=t2.b) where t2.id<=100;#不推荐
3、为被驱动表匹配的条件增加索引(减少内层表的循环匹配次数)
4、增大join buffer size的大小(一次缓存的数据越多,那么内层包的扫表次数就越少)
5、减少驱动表
不必要的字段查询(字段越少,join buffer 所缓存的数据就越多)
6、在决定哪个表做驱动表的时候,应该是两个表按照各自的条件过滤,过滤完成之后,计算参与join的各个字段的总数据量,数据量小的那个表,就是“小表”,应该作为驱动表。
1.5 小结
- 保证被驱动表的JOIN字段已经创建了索引
- 需要JOIN 的字段,数据类型保持绝对一致。
- LEFT JOIN 时,选择小表作为驱动表,
大表作为被驱动表
。减少外层循环的次数。 - INNER JOIN 时,MySQL会自动将
小结果集的表选为驱动表
。选择相信MySQL优化策略。 - 能够直接多表关联的尽量直接关联,不用子查询。(减少查询的趟数)
- 不建议使用子查询,建议将子查询SQL拆开结合程序多次查询,或使用 JOIN 来代替子查询。
- 衍生表建不了索引
1.6.Hash Join
从MySQL的8.0.20版本开始将废弃BNLJ,因为从MySQL8.0.18版本开始就加入了hash join默认都会使用hash join
-
Nested Loop: 对于被连接的数据子集较小的情况,Nested Loop是个较好的选择。
-
Hash Join是做
大数据集连接
时的常用方式,优化器使用两个表中较小(相对较小)的表利用Join Key在内存中建立散列表
,然后扫描较大的表并探测散列表,找出与Hash表匹配的行。- 这种方式适用于较小的表完全可以放于内存中的情况,这样总成本就是访问两个表的成本之和。
- 在表很大的情况下并不能完全放入内存,这时优化器会将它分割成
若干不同的分区
,不能放入内存的部分就把该分区写入磁盘的临时段,此时要求有较大的临时段从而尽量提高I/O的性能。 - 它能够很好的工作于没有索引的大表和并行查询的环境中,并提供最好的性能。大多数人都说它是Join的重型升降机。Hash Join只能应用于等值连接(如WHERE A.COL1=B.COL2),这是由Hash的特点决定的。
2.子查询优化
MySQL从4.1版本开始支持子查询,使用子查询可以进行SELECT语句的嵌套查询,即一个SELECT查询的结果作为另一个SELECT语句的条件。子查询可以一次性完成很多逻辑上需要多个步骤才能完成的SQL操作
。
子查询是MySQL的一项重要的功能,可以帮助我们通过一个SQL语句实现比较复杂的查询。但是,子查询的执行效率不高。 原因:
①执行子查询时MySQL需要为内层查询语句的查询结果建立一个临时表
,然后外层查询语句从临时表中查询记录。查询完毕后,再撤销这些临时表
。这样会消耗过多的CPU和IO资源,产生大量的慢查询。
②子查询的结果集存储的临时表,不论是内存临时表还是磁盘临时表都不会存在索引
,所以查询性能会受到一定的影响。
③对于返回结果集比较大的子查询,其对查询性能的影响也就越大。
在MySQL中,可以使用连接(JOIN)查询来替代子查询。连接查询不需要建立临时表
,其速度比子查询要快
,如果查询中使用索引的话,性能就会更好。
举例1:查询学生表中是班长的学生信息
-
使用子查询
#创建班级表中班长的索引 CREATE INDEX idx_monitor ON class ( monitor ) ; EXPLAIN SELECT *FROM student stu1 WHERE stu1 . 'stuno`IN( SELECT monitor FROM class c WHERE monitor IS NOT NULL);
-
推荐:使用多表查询
EXPLAIN SELECT stu1.* FROM student stu1 JOIN class c ON stu1 . 'stuno` = c. 'monitor' WHERE c. 'monitor` IS NOT NULL;
举例2:取所有不为班长的同学·不推荐
-
子查询
EXPLAIN SELECT SQL_NO_CACHE a.* FROM student a WHERE a.stuno NOT IN ( SELECT monitor FROM class bWHERE monitor IS NOT NULL);
-
修改成多表查询
EXPLAIN SELECT SQL_NO_CACHE a.* FROM student a LEFT OUTER JOIN class b ON a. stuno =b.monitor WHERE b.monitor IS NULL;
结论: 尽量不要使用NOT IN或者NOT EXISTS,用LEFT JOIN Xxx ON xx WHERE xx IS NULL替代
在接下来的文章中,我们将继续优化SQL查询,着重分析排序优化、GROUP BY优化以及如何提升分页查询的效率。你还将学到如何通过覆盖索引和索引下推技术,进一步加速查询性能,帮助你应对复杂的SQL优化。敬请期待吧!
交流学习
最后,如果这篇文章对你有所启发,请帮忙转发给更多的朋友,让更多人受益!如果你有任何疑问或想法,欢迎随时留言与我讨论,我们一起学习、共同进步。别忘了关注我,我将持续分享更多有趣且实用的技术文章,期待与你的交流!