MySQL实战45讲学习笔记：第十七讲

时间 2019-11-06

原文原文链接

一、引子

我在上一篇文章，为你讲解完 order by 语句的几种执行模式后，就想到了以前一个作英语学习 App 的朋友碰到过的一个性能问题。今天这篇文章，我就从这个性能问题提及，和
你说说 MySQL 中的另一种排序需求，但愿可以加深你对 MySQL 排序逻辑的理解。mysql

这个英语学习 App 首页有一个随机显示单词的功能，也就是根据每一个用户的级别有一个单词表，而后这个用户每次访问首页的时候，都会随机滚动显示三个单词。他们发现随着单
词表变大，选单词这个逻辑变得愈来愈慢，甚至影响到了首页的打开速度。算法

如今，若是让你来设计这个 SQL 语句，你会怎么写呢？sql

为了便于理解，我对这个例子进行了简化：去掉每一个级别的用户都有一个对应的单词表这个逻辑，直接就是从一个单词表中随机选出三个单词。这个表的建表语句和初始数据的命令以下：数据库

mysql> CREATE TABLE `words` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `word` varchar(64) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB;

delimiter ;;
create procedure idata()
begin
  declare i int;
  set i=0;
  while i<10000 do
    insert into words(word) values(concat(char(97+(i div 1000)), char(97+(i % 1000 div 100)), char(97+(i % 100 div 10)), char(97+(i % 10))));
    set i=i+1;
  end while;
end;;
delimiter ;

call idata();

为了便于量化说明，我在这个表里面插入了 10000 行记录。接下来，咱们就一块儿看看要随机选择 3 个单词，有什么方法实现，存在什么问题以及如何改进。数组

2、内存临时表

首先，你会想到用 order by rand() 来实现这个逻辑。bash

mysql> select word from words order by rand() limit 3;

一、临时内存表的排序来讲，它会选择哪种算法呢？

这个语句的意思很直白，随机排序取前 3 个。虽然这个 SQL 语句写法很简单，但执行流程却有点复杂的。数据结构

咱们先用 explain 命令来看看这个语句的执行状况。函数

图 1 使用 explain 命令查看语句的执行状况性能

实际测试代码以下：学习

mysql> explain select word from words order by rand() limit 3;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                           |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+
|  1 | SIMPLE      | words | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9980 |   100.00 | Using temporary; Using filesort |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+
1 row in set, 1 warning (0.00 sec)

一、Using temporary是什么意思？

Extra 字段显示 Using temporary，表示的是须要使用临时表；Using filesort，表示的是须要执行排序操做

所以这个 Extra 的意思就是，须要临时表，而且须要在临时表上排序。

这里，你能够先回顾一下上一篇文章中全字段排序和 rowid 排序的内容。我把上一篇文章的两个流程图贴过来，方便你复习。

图 2 全字段排序

图 3 rowid 排序

而后，我再问你一个问题，你以为对于临时内存表的排序来讲，它会选择哪种算法呢？回顾一下上一篇文章的一个结论：对于 InnoDB 表来讲，执行全字段排序会减小磁盘访
问，所以会被优先选择。

我强调了“InnoDB 表”，你确定想到了，对于内存表，回表过程只是简单地根据数据行的位置，直接访问内存获得数据，根本不会致使多访问磁盘。优化器没有了这一层顾虑，

那么它会优先考虑的，就是用于排序的行越小越好了，因此，MySQL 这时就会选择rowid 排序。

二、随机排序完整流程

理解了这个算法选择的逻辑，咱们再来看看语句的执行流程。同时，经过今天的这个例子，咱们来尝试分析一下语句的扫描行数。

这条语句的执行流程是这样的：

1. 建立一个临时表。这个临时表使用的是 memory 引擎，表里有两个字段，第一个字段是 double 类型，为了后面描述方便，记为字段 R，第二个字段是 varchar(64) 类型，记为字段 W。而且，这个表没有建索引。

2. 从 words 表中，按主键顺序取出全部的 word 值。对于每个 word 值，调用 rand()函数生成一个大于 0 小于 1 的随机小数，并把这个随机小数和 word 分别存入临时表的
R 和 W 字段中，到此，扫描行数是 10000。

3. 如今临时表有 10000 行数据了，接下来你要在这个没有索引的内存临时表上，按照字段 R 排序。

4. 初始化 sort_buffer。sort_buffer 中有两个字段，一个是 double 类型，另外一个是整型。
5. 从内存临时表中一行一行地取出 R 值和位置信息（我后面会和你解释这里为何是“位置信息”），分别存入 sort_buffer 中的两个字段里。这个过程要对内存临时表作全表
扫描，此时扫描行数增长 10000，变成了 20000。
6. 在 sort_buffer 中根据 R 的值进行排序。注意，这个过程没有涉及到表操做，因此不会增长扫描行数。
7. 排序完成后，取出前三个结果的位置信息，依次到内存临时表中取出 word 值，返回给客户端。

一、推荐一个学习方法

这个过程当中，访问了表的三行数据，总扫描行数变成了 20003。

接下来，咱们经过慢查询日志（slow log）来验证一下咱们分析获得的扫描行数是否正确。

# Query_time: 0.900376  Lock_time: 0.000347 Rows_sent: 3 Rows_examined: 20003
SET timestamp=1541402277;
select word from words order by rand() limit 3;

实际测试效果截图

其中，Rows_examined：20003 就表示这个语句执行过程当中扫描了 20003 行，也就验证了咱们分析得出的结论。

这里插一句题外话，在平时学习概念的过程当中，你能够常常这样作，先经过原理分析算出扫描行数，而后再经过查看慢查询日志，来验证本身的结论。我本身就是常常这么作，这
个过程颇有趣，分析对了开心，分析错了可是弄清楚了也很开心。

三、随机排序完整流程图

如今，我来把完整的排序执行流程图画出来。

图 4 随机排序完整流程图 1

图中的 pos 就是位置信息，你可能会以为奇怪，这里的“位置信息”是个什么概念？在上一篇文章中，咱们对 InnoDB 表排序的时候，明明用的仍是 ID 字段。

四、MySQL 的表是用什么方法来定位“一行数据”的。

这时候，咱们就要回到一个基本概念：MySQL 的表是用什么方法来定位“一行数据”的。

在前面第 4和第 5篇介绍索引的文章中，有几位同窗问到，若是把一个 InnoDB 表的主键删掉，是否是就没有主键，就没办法回表了？

其实不是的。如果你建立的表没有主键，或者把一个表的主键删掉了，那么 InnoDB 会本身生成一个长度为 6 字节的 rowid 来做为主键。

这也就是排序模式里面，rowid 名字的来历。实际上它表示的是：每一个引擎用来惟一标识数据行的信息。

对于有主键的 InnoDB 表来讲，这个 rowid 就是主键 ID；
对于没有主键的 InnoDB 表来讲，这个 rowid 就是由系统生成的；
MEMORY 引擎不是索引组织表。在这个例子里面，你能够认为它就是一个数组。所以，这个 rowid 其实就是数组的下标。

到这里，我来稍微小结一下：order by rand() 使用了内存临时表，内存临时表排序的时候使用了 rowid 排序方法。

3、磁盘临时表

一、那么，是否是全部的临时表都是内存表呢？

其实不是的。tmp_table_size 这个配置限制了内存临时表的大小，默认值是 16M。若是临时表大小超过了 tmp_table_size，那么内存临时表就会转成磁盘临时表。
磁盘临时表使用的引擎默认是 InnoDB，是由参数 internal_tmp_disk_storage_engine控制的。

当使用磁盘临时表的时候，对应的就是一个没有显式索引的 InnoDB 表的排序过程。为了复现这个过程，我把 tmp_table_size 设置成 1024，把 sort_buffer_size 设置成
32768, 把 max_length_for_sort_data 设置成 16。

set tmp_table_size=1024;
set sort_buffer_size=32768;
set max_length_for_sort_data=16;
/* 打开 optimizer_trace，只对本线程有效 */
SET optimizer_trace='enabled=on'; 

/* 执行语句 */
select word from words order by rand() limit 3;

/* 查看 OPTIMIZER_TRACE 输出 */
SELECT * FROM `information_schema`.`OPTIMIZER_TRACE`\G

图 5 OPTIMIZER_TRACE 部分结果

实际测试代码以下：

测试代码

mysql> set tmp_table_size=1024;
Query OK, 0 rows affected (0.01 sec)

mysql> set sort_buffer_size=32768;
Query OK, 0 rows affected (0.00 sec)

mysql> set max_length_for_sort_data=16;
Query OK, 0 rows affected (0.00 sec)

mysql> SET optimizer_trace='enabled=on'; 
Query OK, 0 rows affected (0.01 sec)

mysql> select word from words order by rand() limit 3;
+------+
| word |
+------+
| cbgj |
| gdcg |
| iagj |
+------+
3 rows in set (0.07 sec)

关键测试结果代码以下：

mysql> SELECT * FROM `information_schema`.`OPTIMIZER_TRACE`\G
*************************** 1. row ***************************
                            QUERY: select word from words order by rand() limit 3
                            TRACE: {
  "steps": [
    {
      "join_preparation": {
......
            ],
            "filesort_priority_queue_optimization": {
              "limit": 3,
              "rows_estimate": 1213,
              "row_size": 14,
              "memory_available": 32768,
              "chosen": true
            },
            "filesort_execution": [
            ],
            "filesort_summary": {
              "rows": 4,
              "examined_rows": 10000,
              "number_of_tmp_files": 0,
              "sort_buffer_size": 88,
              "sort_mode": "<sort_key, rowid>"
            }
          }
        ]
      }
    }
  ]
}
MISSING_BYTES_BEYOND_MAX_MEM_SIZE: 0
          INSUFFICIENT_PRIVILEGES: 0
1 row in set (0.02 sec)

而后，咱们来看一下此次 OPTIMIZER_TRACE 的结果。

由于将 max_length_for_sort_data 设置成 16，小于 word 字段的长度定义，因此咱们看到 sort_mode 里面显示的是 rowid 排序，这个是符合预期的，参与排序的是随机值 R 字
段和 rowid 字段组成的行。

这时候你可能心算了一下，发现不对。R 字段存放的随机值就 8 个字节，rowid 是 6 个字节（至于为何是 6 字节，就留给你课后思考吧），数据总行数是 10000，这样算出来就
有 140000 字节，超过了 sort_buffer_size 定义的 32768 字节了。可是，number_of_tmp_files 的值竟然是 0，难道不须要用临时文件吗？

二、优先队列排序算法

这个 SQL 语句的排序确实没有用到临时文件，采用是 MySQL 5.6 版本引入的一个新的排序算法，即：优先队列排序算法。接下来，咱们就看看为何没有使用临时文件的算法，
也就是归并排序算法，而是采用了优先队列排序算法。

其实，咱们如今的 SQL 语句，只须要取 R 值最小的 3 个 rowid。可是，若是使用归并排序算法的话，虽然最终也能获得前 3 个值，可是这个算法结束后，已经将 10000 行数据
都排好序了。

也就是说，后面的 9997 行也是有序的了。但，咱们的查询并不须要这些数据是有序的。因此，想一下就明白了，这浪费了很是多的计算量。

而优先队列算法，就能够精确地只获得三个最小值，执行流程以下：

1. 对于这 10000 个准备排序的 (R,rowid)，先取前三行，构形成一个堆；（对数据结构印象模糊的同窗，能够先设想成这是一个由三个元素组成的数组）1. 取下一个行 (R’,rowid’)，

跟当前堆里面最大的 R 比较，若是 R’小于 R，把这个(R,rowid) 从堆中去掉，换成 (R’,rowid’)；

2. 重复第 2 步，直到第 10000 个 (R’,rowid’) 完成比较。

这里我简单画了一个优先队列排序过程的示意图。

三、优先队列排序过程示意图

图 6 优先队列排序算法示例

图 6 是模拟 6 个 (R,rowid) 行，经过优先队列排序找到最小的三个 R 值的行的过程。整个排序过程当中，为了最快地拿到当前堆的最大值，老是保持最大值在堆顶，所以这是一个最大堆。

图 5 的 OPTIMIZER_TRACE 结果中，filesort_priority_queue_optimization 这个部分的chosen=true，就表示使用了优先队列排序算法，这个过程不须要临时文件，所以对应的
number_of_tmp_files 是 0。

这个流程结束后，咱们构造的堆里面，就是这个 10000 行里面 R 值最小的三行。而后，依次把它们的 rowid 取出来，去临时表里面拿到 word 字段，这个过程就跟上一篇文章的
rowid 排序的过程同样了。

咱们再看一下上面一篇文章的 SQL 查询语句：

select city,name,age from t where city='杭州' order by name limit 1000  ;

MySQL 的表是用什么方法来定位“一行数据”的。

你可能会问，这里也用到了 limit，为何没用优先队列排序算法呢？缘由是，这条 SQL语句是 limit 1000，若是使用优先队列算法的话，须要维护的堆的大小就是 1000 行的
(name,rowid)，超过了我设置的 sort_buffer_size 大小，因此只能使用归并排序算法。

总之，不管是使用哪一种类型的临时表，order by rand() 这种写法都会让计算过程很是复杂，须要大量的扫描行数，所以排序过程的资源消耗也会很大。
再回到咱们文章开头的问题，怎么正确地随机排序呢？

4、随机排序方法

一、随机算法 1

咱们先把问题简化一下，若是只随机选择 1 个 word 值，能够怎么作呢？思路上是这样的：

1. 取得这个表的主键 id 的最大值 M 和最小值 N;
2. 用随机函数生成一个最大值到最小值之间的数 X = (M-N)*rand() + N;
3. 取不小于 X 的第一个 ID 的行。

咱们把这个算法，暂时称做随机算法 1。这里，我直接给你贴一下执行语句的序列:

mysql> select max(id),min(id) into @M,@N from t ;
set @X= floor((@M-@N+1)*rand() + @N);
select * from t where id >= @X limit 1;

这个方法效率很高，由于取 max(id) 和 min(id) 都是不须要扫描索引的，而第三步的select 也能够用索引快速定位，能够认为就只扫描了 3 行。但实际上，这个算法自己并不
严格知足题目的随机要求，由于 ID 中间可能有空洞，所以选择不一样行的几率不同，不是真正的随机。

好比你有 4 个 id，分别是一、二、四、5，若是按照上面的方法，那么取到 id=4 的这一行的几率是取得其余行几率的两倍。

若是这四行的 id 分别是一、二、40000、40001 呢？这个算法基本就能当 bug 来看待了。

二、随机算法 2

因此，为了获得严格随机的结果，你能够用下面这个流程:

1. 取得整个表的行数，并记为 C。
2. 取得 Y = floor(C * rand())。 floor 函数在这里的做用，就是取整数部分。
3. 再用 limit Y,1 取得一行。

咱们把这个算法，称为随机算法 2。下面这段代码，就是上面流程的执行语句的序列。

因为 limit 后面的参数不能直接跟变量，因此我在上面的代码中使用了 prepare+execute的方法。你也能够把拼接 SQL 语句的方法写在应用程序中，会更简单些。

这个随机算法 2，解决了算法 1 里面明显的几率不均匀问题。

mysql> select count(*) into @C from t;
set @Y = floor(@C * rand());
set @sql = concat("select * from t limit ", @Y, ",1");
prepare stmt from @sql;
execute stmt;
DEALLOCATE prepare stmt;

MySQL 处理 limit Y,1 的作法就是按顺序一个一个地读出来，丢掉前 Y 个，而后把下一个记录做为返回结果，所以这一步须要扫描 Y+1 行。再加上，第一步扫描的 C 行，总共需
要扫描 C+Y+1 行，执行代价比随机算法 1 的代价要高。

固然，随机算法 2 跟直接 order by rand() 比起来，执行代价仍是小不少的。

你可能问了，若是按照这个表有 10000 行来计算的话，C=10000，要是随机到比较大的Y 值，那扫描行数也跟 20000 差很少了，接近 order by rand() 的扫描行数，为何说随
机算法 2 的代价要小不少呢？我就把这个问题留给你去课后思考吧。

三、称做随机算法 3

如今，咱们再看看，若是咱们按照随机算法 2 的思路，要随机取 3 个 word 值呢？你能够这么作：

1. 取得整个表的行数，记为 C；
2. 根据相同的随机方法获得 Y一、Y二、Y3；
3. 再执行三个 limit Y, 1 语句获得三行数据。

咱们把这个算法，称做随机算法 3。下面这段代码，就是上面流程的执行语句的序列。

mysql> select count(*) into @C from t;
set @Y1 = floor(@C * rand());
set @Y2 = floor(@C * rand());
set @Y3 = floor(@C * rand());
select * from t limit @Y1，1； // 在应用代码里面取 Y一、Y二、Y3 值，拼出 SQL 后执行
select * from t limit @Y2，1；
select * from t limit @Y3，1；

四、记录慢查询

一、查看是否开启慢查询：
show variables like 'slow_query_log';

二、开始慢查询
set global log_queries_not_using_indexes=on;

三、确认log_queries_not_using_indexes 是不开启
show variables like '%log%'; 
log_queries_not_using_indexes              | ON  

四、查询慢查询日志位置
mysql> show variables like 'slow%';
+---------------------+--------------------------------------+
| Variable_name       | Value                                |
+---------------------+--------------------------------------+
| slow_launch_time    | 2                                    |
| slow_query_log      | ON                                   |
| slow_query_log_file | /var/lib/mysql/0c94d4cac265-slow.log |
+---------------------+--------------------------------------+
3 rows in set (0.00 sec)

5、小结

今天这篇文章，我是借着随机排序的需求，跟你介绍了 MySQL 对临时表排序的执行过程。查询的执行代价每每是比较大的。因此，在设计的时候你要量避开这种写法。

若是你直接使用 order by rand()，这个语句须要 Using temporary 和 Using filesort，

今天的例子里面，咱们不是仅仅在数据库内部解决问题，还会让应用代码配合拼接 SQL 语句。在实际应用的过程当中，比较规范的用法就是：尽可能将业务逻辑写在业务代码中，让数
据库只作“读写数据”的事情。所以，这类方法的应用仍是比较普遍的。

最后，我给你留下一个思考题吧。

上面的随机算法 3 的总扫描行数是 C+(Y1+1)+(Y2+1)+(Y3+1)，实际上它仍是能够继续优化，来进一步减小扫描行数的。

个人问题是，若是你是这个需求的开发人员，你会怎么作，来减小扫描行数呢？说说你的方案，并说明你的方案须要的扫描行数。

你能够把你的设计和结论写在留言区里，我会在下一篇文章的末尾和你讨论这个问题。感谢你的收听，也欢迎你把这篇文章分享给更多的朋友一块儿阅读。

6、上期问题时间

我在上一篇文章最后留给你的问题是，select * from t where city in (“杭州”," 苏州 ")order by name limit 100; 这个 SQL 语句是否须要排序？有什么方案能够避免排序？

虽然有 (city,name) 联合索引，对于单个 city 内部，name 是递增的。可是因为这条 SQL语句不是要单独地查一个 city 的值，而是同时查了"杭州"和" 苏州 "两个城市，所以全部满
足条件的 name 就不是递增的了。也就是说，这条 SQL 语句须要排序。那怎么避免排序呢？

这里，咱们要用到 (city,name) 联合索引的特性，把这一条语句拆成两条语句，执行流程以下：

1. 执行 select * from t where city=“杭州” order by name limit 100; 这个语句是不须要排序的，客户端用一个长度为 100 的内存数组 A 保存结果。
2. 执行 select * from t where city=“苏州” order by name limit 100; 用相同的方法，假设结果被存进了内存数组 B。
3. 如今 A 和 B 是两个有序数组，而后你能够用归并排序的思想，获得 name 最小的前100 值，就是咱们须要的结果了。

若是把这条 SQL 语句里“limit 100”改为“limit 10000,100”的话，处理方式其实也差很少，即：要把上面的两条语句改为写：

select * from t where city=" 杭州 " order by name limit 10100;

和

 select * from t where city=" 苏州 " order by name limit 10100。

这时候数据量较大，能够同时起两个链接一行行读结果，用归并排序算法拿到这两个结果集里，按顺序取第 10001~10100 的 name 值，就是须要的结果了。

固然这个方案有一个明显的损失，就是从数据库返回给客户端的数据量变大了。

因此，若是数据的单行比较大的话，能够考虑把这两条 SQL 语句改为下面这种写法：

select id,name from t where city=" 杭州 " order by name limit 10100;

和

select id,name from t where city=" 苏州 " order by name limit 10100。

而后，再用归并排序的方法取得按 name 顺序第 10001~10100 的 name、id 的值，而后拿着这 100 个 id 到数据库中去查出全部记录。

上面这些方法，须要你根据性能需求和开发的复杂度作出权衡。