美文网首页
MySQL order by 需要注意什么

MySQL order by 需要注意什么

作者: 灰气球 | 来源:发表于2019-12-10 23:38 被阅读0次

    原文《MySQL实战45讲》

    前言

    ​ 程序开发,你一定会碰到需要排序的需求,这时order by 就派上用场了。以市民表为例,假设你要查询城市是“杭州”的所有人名字,并且按照姓名排序返回前 1000 个人的姓名、年龄。

    CREATE TABLE `t` (
      `id` int(11) NOT NULL,
      `city` varchar(16) NOT NULL,
      `name` varchar(16) NOT NULL,
      `age` int(11) NOT NULL,
      `addr` varchar(128) DEFAULT NULL,
      PRIMARY KEY (`id`),
      KEY `city` (`city`)
    ) ENGINE=InnoDB;
    

    ​ 假设查询SQL如下 :

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

    ​ 现在的问题是,对于这个SQL,你了解它是怎么执行的吗? 有哪些参数会影响执行的行为呢?

    全字段排序

    ​ 执行上面查询SQL的执行计划。

    使用 explain 命令查看语句的执行情况

    ​ Extra 这个字段中的 Using filesort 表示该SQL需要排序,MySQL会给每个线程分配一块内存用于排序,称为 sort_buffer。

    ​ 为了说明这个 SQL 查询语句的执行过程,我们先来看一下 city 这个索引的示意图。

    city 字段的索引示意图

    ​ 从图中可以看到,满足 city='杭州’条件的行,是从 ID_X 到 ID_(X+N) 的这些记录。

    ​ 通常情况下,这个语句执行流程如下所示 :

    1. 初始化 sort_buffer,确定放入 name、city、age 这三个字段;
    
    1. 从索引 city 找到第一个满足 city='杭州’条件的主键 id,也就是图中的 ID_X;
    2. 到主键 id 索引取出整行,取 name、city、age 三个字段的值,存入 sort_buffer 中;
    3. 从索引 city 取下一个记录的主键 id;
    4. 重复步骤 3、4 直到 city 的值不满足查询条件为止,对应的主键 id 也就是图中的 ID_Y;
    5. 对 sort_buffer 中的数据按照字段 name 做快速排序;
    6. 按照排序结果取前 1000 行返回给客户端。
    全字段排序执行流程的示意图

    ​ 图中“按 name 排序”这个动作,可能在内存中完成,也可能需要使用外部排序,这取决于排序所需的内存和参数 sort_buffer_size。

    ​ sort_buffer_size,就是 MySQL 为排序开辟的内存(sort_buffer)的大小。如果要排序的数据量小于 sort_buffer_size,排序就在内存中完成。但如果排序数据量太大,内存放不下,则不得不利用磁盘临时文件辅助排序。

    rowid排序

    ​ 在上面这个算法过程里面,只对原表的数据读了一遍,剩下的操作都是在 sort_buffer 和临时文件中执行的。但这个算法有一个问题,就是如果查询要返回的字段很多的话,那么 sort_buffer 里面要放的字段数太多,这样内存里能够同时放下的行数很少,要分成很多个临时文件,排序的性能会很差。

    ​ 所以如果单行很大,这个方法效率不够好。那么,如果 MySQL 认为排序的单行长度太大会怎么做呢?

    ​ 接下来,我来修改一个参数,让 MySQL 采用rowid排序算法。

    SET max_length_for_sort_data = 16;
    

    ​ max_length_for_sort_data,是 MySQL 中专门控制用于排序的行数据的长度的一个参数。它的意思是,如果单行的长度超过这个值,MySQL 就认为单行太大,要换一个算法。

    ​ city、name、age 这三个字段的定义总长度是 36,我把 max_length_for_sort_data 设置为 16,我们再来看看计算过程有什么改变。

    ​ 新的算法放入 sort_buffer 的字段,只有要排序的列(即 name 字段)和主键 id。但这时,排序的结果就因为少了 city 和 age 字段的值,不能直接返回了,整个执行流程就变成如下所示的样子:

    1. 初始化 sort_buffer,确定放入两个字段,即 name 和 id;

    2. 从索引 city 找到第一个满足 city='杭州’条件的主键 id,也就是图中的 ID_X;

    3. 到主键 id 索引取出整行,取 name、id 这两个字段,存入 sort_buffer 中;

    4. 从索引 city 取下一个记录的主键 id;

    5. 重复步骤 3、4 直到不满足 city='杭州’条件为止,也就是图中的 ID_Y;

    6. 对 sort_buffer 中的数据按照字段 name 进行排序;

    7. 遍历排序结果,取前 1000 行,并按照 id 的值回到原表中取出 city、name 和 age 三个字段返回给客户端。

    rowid排序执行流程示意图

    优化

    全字段排序 VS rowid排序

    ​ 如果 MySQL 实在是担心排序内存太小,会影响排序效率,才会采用 rowid 排序算法,这样排序过程中一次可以排序更多行,但是需要再回到原表去取数据。

    ​ 如果 MySQL 认为内存足够大,会优先选择全字段排序,把需要的字段都放到 sort_buffer 中,这样排序后就会直接从内存里面返回查询结果了,不用再回到原表去取数据。

    ​ 这也就体现了 MySQL 的一个设计思想:如果内存够,就要多利用内存,尽量减少磁盘访问。对于 InnoDB 表来说,rowid 排序会要求回表多造成磁盘读,因此不会被优先选择。

    让MySQL不用执行排序行为

    ​ MySQL 做排序是一个成本比较高的操作。那么你会问,是不是所有的 order by 都需要排序操作呢?如果不排序就能得到正确的结果,那对系统的消耗会小很多,语句的执行时间也会变得更短。

    ​ 其实,并不是所有的 order by 语句,都需要排序操作的。从上面分析的执行过程,我们可以看到,MySQL 之所以需要生成临时表,并且在临时表上做排序操作,其原因是原来的数据都是无序的。

    ​ 你可以设想下,如果能够保证从 city 这个索引上取出来的行,天然就是按照 name 递增排序的话,是不是就可以不用再排序了呢?所以,我们可以在这个市民表上创建一个 city 和 name 的联合索引,对应的 SQL 语句是:

    alter table t add index city_user(city, name);
    
    city_user索引示意图

    ​ 在这个索引里面,我们依然可以用树搜索的方式定位到第一个满足 city='杭州’的记录,并且额外确保了,接下来按顺序取“下一条记录”的遍历过程中,只要 city 的值是杭州,name 的值就一定是有序的。

    ​ 这样整个查询过程的流程就变成了:

    1. 从索引 (city,name) 找到第一个满足 city='杭州’条件的主键 id;
    
    1. 到主键 id 索引取出整行,取 name、city、age 三个字段的值,作为结果集的一部分直接返回;
    2. 从索引 (city,name) 取下一个记录主键 id;
    3. 重复步骤 2、3,直到查到第 1000 条记录,或者是不满足 city='杭州’条件时循环结束。
    引入 (city,name) 联合索引后,查询语句的示意图 引入 (city,name) 联合索引后,查询语句的执行计划

    ​ 从图中可以看到,Extra 字段中没有 Using filesort 了,也就是不需要排序了。而且由于 (city,name) 这个联合索引本身有序,所以这个查询也不用把 4000 行全都读一遍,只要找到满足条件的前 1000 条记录就可以退出了。也就是说,在我们这个例子里,只需要扫描 1000 次。

    覆盖索引

    ​ 覆盖索引是指,索引上的信息足够满足查询请求,不需要再回到主键索引上去取数据。

    ​ 按照覆盖索引的概念,我们可以再优化一下这个查询语句的执行流程。针对这个查询,我们可以创建一个 city、name 和 age 的联合索引,对应的 SQL 语句就是:

    alter table t add index city_user_age(city, name, age);
    

    ​ 这时,对于 city 字段的值相同的行来说,还是按照 name 字段的值递增排序的,此时的查询语句也就不再需要排序了。这样整个查询语句的执行流程就变成了:

    1. 从索引 (city,name,age) 找到第一个满足 city='杭州’条件的记录,取出其中的 city、name 和 age 这三个字段的值,作为结果集的一部分直接返回;
    2. 从索引 (city,name,age) 取下一个记录,同样取出这三个字段的值,作为结果集的一部分直接返回;
    3. 重复执行步骤 2,直到查到第 1000 条记录,或者是不满足 city='杭州’条件时循环结束。
    引入 (city,name,age) 联合索引后,查询语句的执行示意图
    引入 (city,name,age) 联合索引后,查询语句的执行计划

    ​ 可以看到,Extra 字段里面多了“Using index”,表示的就是使用了覆盖索引,性能上会快很多。

    ​ 当然,这里并不是说要为了每个查询能用上覆盖索引,就要把语句中涉及的字段都建上联合索引,毕竟索引还是有维护代价的。这是一个需要权衡的决定。

    问题思考

    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 到数据库中去查出所有记录。

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

    相关文章

      网友评论

          本文标题:MySQL order by 需要注意什么

          本文链接:https://www.haomeiwen.com/subject/joewgctx.html