MySQL查询语句执行的过程

1. 背景
2. 过程概览
   1. 查询缓存query cache
   2. 查询管理器
      1. 查询解析器语法解析器和查询重写器
         1. 查询解析器语法解析器
         2. 查询重写器
      2. 查询优化器
         1. 存取路径
         2. 联接运算符
      3. 查询执行器查询执行引擎
      4. 返回结果给客户端

背景

介绍MySQL语句执行select的过程

过程概览

1. 客户端发送一条查询给服务器；
2. 服务器先会检查查询缓存，如果命中了缓存，则立即返回存储在缓存中的结果。否则进入下一阶段；
3. 服务器端进行SQL解析、预处理，再由优化器生成对应的执行计划；
4. MySQL根据优化器生成的执行计划，调用存储引擎的API来执行查询；
5. 将结果返回给客户端。 
   

查询缓存（query cache）

在解析一个查询语句之前，如果查询缓存是打开的，那么MySQL会优先检查这个查询是否命中查询缓存中的数据。这个检查是通过一个对大小写敏感的哈希查找实现的。查询和缓存中的查询即使只有一个字节不同，那也不会匹配缓存结果，这种情况查询会进入下一个阶段的处理。 
如果当前的查询恰好命中了查询缓存，那么在返回查询结果之前MySQL会检查一次用户权限。这仍然是无须解析查询SQL语句的，因为在查询缓存中已经存放了当前查询需要访问的表信息。如果权限没有问题，MySQL会跳过所有其他阶段，直接从缓存中拿到结果并返回给客户端。这种情况下，查询不会被解析，不用生成执行计划，不会被执行。 
缓存配置参数： 
 
query_cache_limit: MySQL能够缓存的最大结果,如果超出,则增加 Qcache_not_cached的值,并删除查询结果 
query_cache_min_res_unit: 分配内存块时的最小单位大小 
query_cache_size: 缓存使用的总内存空间大小,单位是字节,这个值必须是1024的整数倍,否则MySQL实际分配可能跟这个数值不同(感觉这个应该跟文件系统的blcok大小有关) 
query_cache_type: 是否打开缓存 OFF: 关闭，ON: 总是打开 
query_cache_wlock_invalidate: 如果某个数据表被锁住,是否仍然从缓存中返回数据,默认是OFF,表示仍然可以返回。

查询管理器

在缓存中没有命中到，则进入MySQL语句的查询管理器中进行处理。 
在这里查询语句可以转换成一个快速执行的代码，代码执行的结果被送到客户端管理器。这个多步骤操作过程如下： 
1. 查询首先被解析并判断是否合法 
2. 然后被重写，去除了无用的操作并且加入预优化部分 
3. 接着被优化以便提升性能，并被转换为可执行代码和数据访问计划。 
4. 然后计划被编译 
5. 最后，被执行 
这个过程涉及到如下几个组成器件： 
查询解析器（Query parser）：用于检查查询是否合法 
查询重写器（Query rewriter）：用于预优化查询 
查询优化器（Query optimizer）：用于优化查询 
查询执行器（Query executor）：用于编译和执行查询

查询解析器（语法解析器）和查询重写器

查询解析器（语法解析器）

首先，MySQL通过关键字将SQL语句进行解析，并生成一棵对应的“解析树”。MySQL解析器将使用MySQL语法规则验证和解析查询。例如，它将验证是否使用错误的关键字，或者使用关键字的顺序是否正确等，再或者它还会验证引号是否能前后正确的匹配。如果查询有错，解析器将拒绝该查询。比如，如果你写成”SLECT …” 而不是 “SELECT …”，那就没有下文了。

解析器还会检查关键字是否使用正确的顺序，比如 WHERE 写在 SELECT 之前会被拒绝。 
然后，解析器要分析查询中的表和字段，使用数据库元数据来检查： 
* 表是否存在 
* 表的字段是否存在 
* 对某类型字段的 运算 是否 可能（比如，你不能将整数和字符串进行比较，你不能对一个整数使用 substring() 函数） 
接着，解析器检查在查询中你是否有权限来读取（或写入）表。强调一下：这些权限由DBA分配。

查询重写器

在这一步，我们已经有了查询的内部表示，重写器的目标是： 
1.预优化查询 
2.避免不必要的运算 
3.帮助优化器找到合理的最佳解决方案

重写器按照一系列已知的规则对查询执行检测。如果查询匹配一种模式的规则，查询就会按照这条规则来重写。下面是（可选）规则的非详尽的列表： 
1.视图合并：如果你在查询中使用视图，视图就会转换为它的 SQL 代码。 
2.子查询扁平化：子查询是很难优化的，因此重写器会尝试移除子查询 
例如：

SELECT PERSON.*FROM PERSONWHERE PERSON.person_key IN(SELECT MAILS.person_keyFROM MAILSWHERE MAILS.mail LIKE 'christophe%');
1
2
3
4
5
6
1
2
3
4
5
6

会转为：

SELECT PERSON.*FROM PERSON, MAILSWHERE PERSON.person_key = MAILS.person_keyand MAILS.mail LIKE 'christophe%';
1
2
3
4
1
2
3
4

3.去除不必要的运算符：比如，如果你用了 DISTINCT，而其实你有 UNIQUE 约束（这本身就防止了数据出现重复），那么 DISTINCT 关键字就被去掉了。 
4.排除冗余的联接：如果相同的 JOIN 条件出现两次，比如隐藏在视图中的 JOIN 条件，或者由于传递性产生的无用 JOIN，都会被消除。 
5.常数计算赋值：如果你的查询需要计算，那么在重写过程中计算会执行一次。比如 WHERE AGE > 10+2 会转换为 WHERE AGE > 12 ， TODATE(“日期字符串”) 会转换为 datetime 格式的日期值。 
6.（高级）分区裁剪（Partition Pruning）：如果你用了分区表，重写器能够找到需要使用的分区。 
7.（高级）物化视图重写（Materialized view rewrite）：如果你有个物化视图匹配查询谓词的一个子集，重写器将检查视图是否最新并修改查询，令查询使用物化视图而不是原始表。 
8.（高级）自定义规则：如果你有自定义规则来修改查询（就像 Oracle policy），重写器就会执行这些规则。 
9.（高级）OLAP转换：分析/加窗 函数，星形联接，ROLLUP 函数……都会发生转换（但我不确定这是由重写器还是优化器来完成，因为两个进程联系很紧，必须看是什么数据库）。 
重写后的查询接着送到优化器。

查询优化器

现在语法树被认为合法的了，并且由优化器将其转化为执行计划。一条查询可以由很多种执行方式，最后都返回相同的结果。优化器的作用就是找到这其中最好的执行计划。

MySQL使用的是“选取-投影-联接”策略进行查询。用一个例子就可以理解： select uid,name from user where gender = 1; 
1：这个select 查询先根据where 语句进行选取，而不是先将表全部查询出来以后再进行gender过滤 
2：这个select查询先根据uid和name进行属性投影，而不是将属性全部取出以后再进行过滤 
3：将这两个查询条件联接起来生成最终查询结果.

MySQL使用基于成本（CBO）的优化器，它将尝试预测一个查询使用某种执行计划的成本，并选择其中成本最小的一个。最早的时候，成本的最小单位是随机读取一个4K数据页的成本，后来成本计算公式变得更加复杂，并且引入了一些“因子”来估算某些操作的代价，如当执行一次where条件比较的成本。可以通过查询当前会话的last_query_cost的值来得知MySQL计算的当前查询的成本。

举个例子，这里将给出联接 2 个表的 3 个方法，我们很快就能看到即便一个简单的联接查询对于优化器来说都是个噩梦。之后，我们会了解真正的优化器是怎么做的。 
对于这些联接操作，我会专注于它们的时间复杂度，但是，数据库优化器计算的是它们的 CPU 成本、磁盘 I/O 成本、和内存需求。时间复杂度和 CPU 成本的区别是，时间成本是个近似值。而 CPU 成本，这里包括了所有的运算，比如：加法、条件判断、乘法、迭代……还有： 
1：每一个高级代码运算都要特定数量的低级 CPU 运算。 
2：对于 Intel Core i7、Intel Pentium 4、AMD Opteron…等，（就 CPU 周期而言）CPU 的运算成本是不同的，也就是说它取决于 CPU 的架构。

大多数时候瓶颈在于磁盘 I/O 而不是 CPU 使用。在应用联接运算符（join operators）之前，首先需要获得数据。以下就是获得数据的方法。

存取路径

1：全扫描： 
如果你读过执行计划，一定看到过『全扫描』（或只是『扫描』）一词。简单的说全扫描就是数据库完整的读一个表或索引。就磁盘 I/O 而言，很明显全表扫描的成本比索引全扫描要高昂。

2：范围扫描 
其他类型的扫描有索引范围扫描，比如使用谓词 ” WHERE AGE > 20 AND AGE < 40 ” 的时候它就会发生。 
当然，你需要在 AGE 字段上有索引才能用到索引范围扫描。 
范围查询的时间成本大约是 log(N)+M，这里 N 是索引的数据量，M 是范围内估测的行数。另外范围扫描时，你不需要读取整个索引，因此在磁盘 I/O 方面没有全扫描那么昂贵。 
3：唯一扫描 
如果你只需要从索引中取一个值你可以用唯一扫描。 
4：根据 ROW ID 存取 
多数情况下，如果数据库使用索引，它就必须查找与索引相关的行，这样就会用到根据 ROW ID 存取的方式。 
例如，假如运行：

SELECT LASTNAME, FIRSTNAME from PERSON WHERE AGE = 28
1
1

如果 person 表的 age 列有索引，优化器会使用索引找到所有年龄为 28 的人，然后它会去表中读取相关的行，这是因为索引中只有 age 的信息而你要的是姓和名。 
但是，假如你换个做法：

SELECT TYPE_PERSON.CATEGORY from PERSON ,TYPE_PERSONWHERE PERSON.AGE = TYPE_PERSON.AGE
1
2
1
2

PERSON 表的索引会用来联接 TYPE_PERSON 表，但是 PERSON 表不会根据行ID 存取，因为你并没有要求这个表内的信息。 
虽然这个方法在少量存取时表现很好，这个运算的真正问题其实是磁盘 I/O。假如需要大量的根据行ID存取，数据库也许会选择全扫描。

联接运算符

上面介绍如何获取数据，那现在就把它们联接起来！ 
常用联接运算符有3个：合并联接（Merge join），哈希联接（Hash Join）和嵌套循环联接（Nested Loop Join）。先介绍两个新词汇：内关系和外关系（ inner relation and outer relation） ，这两个概念跟查询的“内联接（INNER JOIN） 、外联接（OUTER JOIN） ” 是不同的 。 一个关系可以是： 
1：一个表 
2：一个索引 
3：上一个运算的中间结果（比如上一个联接运算的结果）

关系型数据库会尝试上述提到的三种联接方法，优化器真正的工作是在有限时间里找到一个好的解决方案。多数时候，优化器找到的不是最佳的方案，而是一个有限时间内的局部最优方法。对于小规模的查询，采取粗暴的方式是有可能的。但是为了让中等规模的查询也能采取粗暴的方式，为避免不必要的计算，其实数据库在这个过程中采用的是动态规划。 
当优化器面对一个非常大的查询，或者为了尽快找到答案，会应用另一种算法，叫贪婪算法。原理是按照一个规则（或启发）以渐进的方式制定查询计划。在这个规则下，贪婪算法逐步寻找最佳算法，先处理一条JOIN，接着每一步按照同样规则加一条新的JOIN。

有很多种原因会导致MySQL优化器选择错误的执行计划，比如： 
1. 统计信息不准确。 
2. 执行计划中的成本估算不等同于实际的执行计划的成本。 
3. MySQL的最优可能与你想的最优不一样。 
4. MySQL从不考虑其他并发的查询，这可能会影响当前查询的速度。 
5. MySQL也不是任何时候都是基于成本的优化，有时候也会基于一些固定的规则。

查询执行器（查询执行引擎）

在解析和优化阶段，MySQL将生成查询对应的执行计划，MySQL的查询执行引擎则根据这个执行计划来完成整个查询。这里执行计划是一个数据结构，而不是和很多其他的关系型数据库那样会生成对应的字节码。 
如果有足够资源（内存，CPU），查询执行器就会执行生成的执行计划。计划中的操作符 (JOIN, SORT BY …) 可以顺序或并行执行，这取决于执行器。为了获得和写入数据，查询执行器与数据管理器交互，之后再来讨论数据管理器。

相对于查询优化阶段，查询执行阶段不是那么复杂：MySQL只是简单的根据执行计划给出的指令逐步执行。在根据执行计划逐步执行的过程中，有大量的操作需要通过调用存储引擎实现的接口来完成，这些接口就是我们称为“handler API”的接口。实际上，MySQL在优化阶段就为每个表创建了一个handler实例，优化器根据这些实例的接口可以获取表的相关信息，包括表的所有列名、索引统计信息等。

返回结果给客户端

查询执行的最后一个阶段是将结果返回给客户端。即使查询不需要返回结果给客户端，MySQL仍然会返回这个查询的一些信息，如查询影响到的行数。

如果查询可以被缓存，那么MySQL在这个阶段，会将结果存放到查询缓存中。

MySQL将结果返回客户端是一个增量、逐步返回的过程。例如，在关联表操作时，一旦服务器处理完最后一个关联表，开始生成第一条结果时，MySQL就可以开始向客户端逐步返回结果集了。

这样处理有两个好处：服务器无需存储太多的结果，也就不会因为要返回太多的结果而消耗太多的内存。另外，这样的处理也让MySQL客户端第一时间获得返回的结果。

结果集中的每一行都会以一个满足MySQL客户端/服务器通信协议的封包发送，再通过TCP协议进行传输，在TCP传输过程中，可能对MySQL的封包进行缓存然后批量传输。