Mysql_explain

合集下载

MySQL Explain详解

MySQL Explain详解在日常工作中，我们会有时会开慢查询去记录一些执行时间比较久的SQL语句，找出这些SQL语句并不意味着完事了，些时我们常常用到explain这个命令来查看一个这些SQL语句的执行计划，查看该SQL语句有没有使用上了索引，有没有做全表扫描，这都可以通过explain命令来查看。

所以我们深入了解MySQL的基于开销的优化器，还可以获得很多可能被优化器考虑到的访问策略的细节，以及当运行SQL语句时哪种策略预计会被优化器采用。

（QEP：sql生成一个执行计划query Execution plan）mysql> explain select * from servers;+----+-------------+---------+------+---------------+------+---------+------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |+----+-------------+---------+------+---------------+------+---------+------+------+-------+| 1 | SIMPLE | servers | ALL | NULL | NULL | NULL | NULL | 1 | NULL |+----+-------------+---------+------+---------------+------+---------+------+------+-------+1 row in set (0.03 sec)expain出来的信息有10列，分别是id、select_type、table、type、possible_keys、key、key_len、ref、rows、Extra,下面对这些字段出现的可能进行解释：一、id我的理解是SQL执行的顺序的标识,SQL从大到小的执行1. id相同时，执行顺序由上至下2. 如果是子查询，id的序号会递增，id值越大优先级越高，越先被执行3.id如果相同，可以认为是一组，从上往下顺序执行；在所有组中，id值越大，优先级越高，越先执行二、select_type示查询中每个select子句的类型(1) SIMPLE(简单SELECT,不使用UNION或子查询等)(2) PRIMARY(查询中若包含任何复杂的子部分,最外层的select被标记为PRIMARY)(3) UNION(UNION中的第二个或后面的SELECT语句)(4) DEPENDENT UNION(UNION中的第二个或后面的SELECT语句，取决于外面的查询)(5) UNION RESULT(UNION的结果)(6) SUBQUERY(子查询中的第一个SELECT)(7) DEPENDENT SUBQUERY(子查询中的第一个SELECT，取决于外面的查询)(8) DERIVED(派生表的SELECT, FROM子句的子查询)(9) UNCACHEABLE SUBQUERY(一个子查询的结果不能被缓存，必须重新评估外链接的第一行)三、table显示这一行的数据是关于哪张表的，有时不是真实的表名字,看到的是derivedx(x是个数字,我的理解是第几步执行的结果)mysql> explain select * from (select * from ( select * from t1 where id=2602) a) b;+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+| 1 | PRIMARY | <derived2> | system | NULL | NULL | NULL | NULL | 1 | || 2 | DERIVED | <derived3> | system | NULL | NULL | NULL | NULL | 1 | || 3 | DERIVED | t1 | const | PRIMARY,idx_t1_id | PRIMARY | 4 | | 1 | |+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+四、type表示MySQL在表中找到所需行的方式，又称“访问类型”。

mysql explain执行计划每列的简单解释

使用explain查询执行计划时，每个列的简单解释如下：
∙select_type：表示SELECT 的类型，常见的取值有SIMPLE（简单表，即不使用表连接
或者子查询）、PRIMARY（主查询，即外层的查询）、UNION（UNION 中的第二个或
者后面的查询语句）、SUBQUERY（子查询中的第一个SELECT）等。

∙table：输出结果集的表。

∙type：表示表的连接类型，性能由好到差的连接类型为system（表中仅有一行，即常量表）、const（单表中最多有一个匹配行，例如primary key 或者unique index）、eq_ref（对于前面的每一行，在此表中只查询一条记录，简单来说，就是多表连接中使用primary key或者unique index）、ref （与eq_ref 类似，区别在于不是使用primarykey 或者unique index，而是使用普通的索引）、ref_or_null（与ref 类似，区别在于条件中包含对NULL 的查询）、index_merge(索引合并优化)、unique_subquery（in的后面是一个查询主键字段的子查询）、index_subquery （与unique_subquery 类似，区别在于in 的后面是查询非唯一索引字段的子查询）、range（单表中的范围查询）、index （对于前面的每一行，都通过查询索引来得到数据）、all （对于前面的每一行，都通过全表扫描来得到数据）。

∙possible_keys：表示查询时，可能使用的索引。

∙key：表示实际使用的索引。

∙key_len：索引字段的长度。

∙rows：扫描行的数量。

∙Extra：执行情况的说明和描述。

mysql中explain用法

mysql中explain用法在MySQL中，EXPLAIN是一个非常有用的关键字，它可以帮助你理解查询是如何执行的，从而优化查询性能。

当你使用EXPLAIN关键字来查看查询的执行计划时，MySQL会返回关于如何检索数据的信息，而不是实际检索到的数据。

以下是如何使用EXPLAIN的基本步骤：1.在查询前使用EXPLAIN：2.sql复制代码EXPLAIN SELECT * FROM your_table WHERE your_column = 'some_value';1.查看输出：EXPLAIN的输出会告诉你MySQL是如何执行查询的。

其中一些关键的列包括：复制代码* `id`: 查询的标识符。

* `select_type`: 查询的类型（例如：SIMPLE, PRIMARY, SUBQUERY, DERIVED等）。

* `table`: 显示正在访问的表的名称。

* `type`: 这是连接类型，它通常是最重要的列之一。

它的值从最好到最差可以是：system、const、eq_ref、ref、fulltext、ref_or_null、index_merge、unique_subquery、index_subquery、range、index和ALL。

* `possible_keys`: 显示可能用于此表的索引。

* `key`: 实际使用的索引。

* `key_len`: 使用的索引的长度。

这可以帮助你确定是否使用了整个索引或只是索引的一部分。

* `ref`: 显示哪些列或常量被用作索引查找的条件。

* `rows`: 估计要检查的行数。

* `Extra`: 提供关于MySQL如何解析查询的其他信息，如“Using filesort”或“Using temporary”。

3. 优化查询：使用EXPLAIN的输出，你可以识别出查询的性能瓶颈。

例如，如果type列显示为ALL，那么MySQL正在进行全表扫描，这通常是非常低效的。

Mysql-explain之Usingtemporary和Usingfilesort解决方案

Mysql-explain之Usingtemporary和Usingfilesort解决⽅案项⽬刚刚告⼀段落，boos⼜让优化⼏个主要界⾯程序代码⽅便的优化就不讲了，主要说MySQL的优化⾸先查看explain执⾏计划，让主要查询语句使⽤索引，索引type级别最好达到ref | ref_eq级别其次将extra⼀栏的Using temporary（临时表）、Using filesort（⽂件排序）拖出去砍了⼀、第⼀条语句explainselect*from tb_wm_shop where is_delete !=1and is_authentication =1ORDER BY create_time DESC⼤家应该知道使⽤order by的字段要使⽤索引，这条语句中create_time已经创建了索引，但是计划中并没有使⽤该索引，导致出现了Using filesort⽂件排序，使其查询变慢解决⽅法如下：从where条件开始，依照顺序创建⼀个组合索引，就可以砍掉Using filesort这个令⼈讨厌的头颅了注意：必须依照顺序，在创建组合索引时，where条件的字段在orderBy的字段之前，如果orderBy是多字段，则必须依照顺序创建⼆、第⼆条语句-- 原sql语句explainselect s.*from s_menu s left join s_roles_menus p on p.menu_id = s.id where s.type !=0AND p.role_id =1order by s.id desc这条语句就⽐较讨⼈厌了，同时出现了Using temporary（临时表）、Using filesort（⽂件排序）执⾏计划结果语句执⾏结果集之前的错误语句-- 错误的sql语句，where代表的是返回结果的时候过滤，on代表了满⾜on条件的⼦结果集，再合并-- 所以，如果再where中如果过滤关联表条件，那么就只能是等关联表的结果集出来之后，再进⾏查询，那么则必然要使⽤到临时表存放关联结果集，在关联结果集上进⾏过滤-- 如果需要返回，关联的s_roles_menus表中的字段，那么这条sql语句，我暂时认为⽆法在不变更逻辑的情况下，去除对临时表的使⽤explainselect s.*from s_menu s left join s_roles_menus p on p.menu_id = s.id AND p.role_id =1where s.type !=0order by s.id desc错误的sql语句，where代表的是返回结果的时候过滤，on代表了满⾜on条件的⼦结果集，再合并所以，如果再where中如果过滤关联表条件，那么就只能是等关联表的结果集出来之后，再进⾏查询，那么则必然要使⽤到临时表存放关联结果集，在关联结果集上进⾏过滤如果需要返回，关联的s_roles_menus表中的字段，那么这条sql语句，我暂时认为⽆法在不变更逻辑的情况下，去除对临时表的使⽤如果有⼤神看到此处，还请耽误您⼏分钟时间指点指点执⾏结果集，将where后⾯的语句添加到on中，会导致逻辑变动修正后的语句按要求最后更正sql语句，采⽤⼦表过滤，在满⾜不使⽤Using temporary（临时表）、Using filesort（⽂件排序）的同时、也兼顾了语句的逻辑正确性-- 更正后的语句：考虑了下，⽬的是为了获取s_roles_menus表中id为1的数据所关联的s_menu表中的数据，其中不需要返回s_roles_menus表中相关的字段，所以按照下⾯的语句使⽤⼦查询执⾏ explainselect s.*from s_menu s where s.type !=0and exists(select1from s_roles_menus p where p.menu_id = s.id AND p.role_id =1 ) order by s.id desc最终结果集⾄于上⾯所说的 != 导致不⾛索引，⽬前没有发现什么好的⽅法解决，百度出来有⼀种⽅法是通过union函数将⼤于和⼩于连接起来但是我的语句中因为还需要排序，所以会造成另⼀个额外表，故不采⽤!如果哪位⼤神知道还有其他⽅法解决，请留⾔告知，感激不尽！。

mysql explain cost单位

mysql explain cost单位摘要：1.MySQL 中EXPLAIN 的使用2.EXPLAIN 中的Cost 单位3.理解Cost 单位的意义4.优化MySQL 查询性能的建议正文：MySQL 是一款广泛使用的开源关系型数据库管理系统，其查询优化功能在提高系统性能方面发挥着重要作用。

在MySQL 中，EXPLAIN 命令是一种非常有用的查询优化工具，它可以帮助我们分析查询语句的执行计划，从而找出性能瓶颈并进行优化。

在EXPLAIN 的输出结果中，Cost 单位是一个关键的概念，本文将对其进行详细解析。

一、MySQL 中EXPLAIN 的使用在使用EXPLAIN 命令分析查询语句时，我们需要将EXPLAIN 关键字放在查询语句之前，然后执行该语句。

例如，想要分析一个名为“select_example”的查询语句，可以使用如下命令：```EXPLAIN SELECT * FROM table_name WHERE condition;```二、EXPLAIN 中的Cost 单位在EXPLAIN 的输出结果中，每个操作（如Select、Scan、Join 等）都会对应一个Cost 值。

Cost 单位表示执行该操作所需的代价或成本。

通常情况下，Cost 值越小，表示该操作的性能越好。

需要注意的是，Cost 单位并不是一个绝对的数值，而是相对的。

它们之间的比较只能在同一查询语句中进行。

三、理解Cost 单位的意义Cost 单位可以帮助我们了解查询语句中各个操作的性能消耗，从而找出性能瓶颈。

通过对比不同执行计划的Cost 值，我们可以发现优化点，例如通过添加索引、调整查询条件、改变表的读写方式等方法来降低Cost 值，提高查询性能。

四、优化MySQL 查询性能的建议为了优化MySQL 查询性能，我们可以从以下几个方面入手：1.合理设计表结构，如使用合适的数据类型、建立索引等。

2.优化查询语句，如避免使用SELECT *、添加WHERE 条件、使用LIMIT 限制返回结果集等。

mysql 的explain的用法

mysql 的explain的用法MySQL的Explain是一种非常有用的工具，用于分析和优化数据库查询性能。

通过Explain，您能够了解MySQL服务器如何处理查询语句，并找出可能的性能瓶颈。

本文将详细介绍Explain的用法，包括其重要性、使用时机、输出结果解释以及优化建议。

一、Explain的重要性Explain报告提供了有关MySQL服务器如何处理查询语句的详细信息，这有助于开发人员、DBA（数据库管理员）和业务分析师理解查询的性能问题，从而进行针对性的优化。

二、何时使用Explain通常，在以下情况下，您可能需要使用Explain：1. 查询性能下降：当您发现数据库查询性能下降时，可以使用Explain来分析查询语句的性能。

2. 优化查询语句：通过Explain报告，您可以了解查询语句的执行计划，从而优化查询语句以提高性能。

3. 调整索引策略：当您不确定某个表的索引是否对查询性能产生影响时，可以使用Explain来进行分析。

三、Explain的输出结果解释Explain报告以表格形式呈现，包括以下列：1. id：查询的唯一标识符。

2. select_type：查询的类型，如SIMPLE、SUBQUERY、JOIN等。

3. table：涉及的表名及其类型（如系统表、临时表）。

4. partitions：涉及的分区信息。

5. type：MySQL服务器如何处理表（如全表扫描、索引扫描等）。

6. possible_keys：可能用于优化的索引。

7. key：实际使用的索引。

8. key_len：使用的索引的长度。

9. ref：哪些字段被用作索引引用。

10. rows：MySQL预计需要扫描的行数。

11. filtered：表示估计返回的行数在结果中的百分比。

12. Extra：表示MySQL在处理查询时使用的额外选项。

通过分析这些信息，您可以了解MySQL服务器如何处理查询语句，并确定是否存在性能瓶颈。

mysql explain解读

EXPLAIN是MySQL提供的一种查询分析工具，用于查看SQL查询的执行计划和优化信息。

以下是对EXPLAIN结果各列的解读：1. id：这是查询中每个SELECT子句的序列号。

id值越大，执行顺序越晚。

2. select_type：SIMPLE：简单的SELECT语句，不包含子查询或UNION。

PRIMARY：外部查询，如果查询包含任何复杂的子部分，最外层的查询标记为PRIMARY。

SUBQUERY：在SELECT列表或WHERE条件中的子查询。

3. table：输出行所引用的表。

4. type：ALL：全表扫描。

index：只使用索引树进行扫描，没有访问到表的数据行。

range：索引范围扫描，通常出现在使用BETWEEN、>, <等操作符的查询中。

ref：使用非唯一索引或者唯一索引的部分前缀进行查找。

eq_ref：对于每个索引项，表中只有一行数据与之匹配。

常见于主键或唯一索引的等值查询。

const：当查询条件可以转化为常量时，如在WHERE子句中使用主键或唯一索引进行等值比较。

5. possible_keys：可能用到的索引。

6. key：实际使用的索引。

7. key_len：表示使用到的索引长度，可以通过这个值推算出具体使用了哪些列参与了索引。

8. ref：显示哪个字段或常量与key一起被使用。

9. rows：MySQL根据表统计信息和索引选用情况，估算要找到所需记录需要扫描的行数。

10. Extra：Using index：表示使用覆盖索引，即只需要从索引中就可以获取所有需要的数据，无需回表。

Using where：表示在检索过程中使用了WHERE过滤条件。

Using temporary：表示MySQL需要创建一个临时表来存储查询结果。

Using filesort：表示MySQL无法利用索引进行排序，需要进行额外的文件排序操作。

Using join buffer：表示在连接操作中使用了连接缓冲区。

mysql查看执行计划

mysql查看执行计划MySQL查看执行计划。

在MySQL数据库中，执行计划是指MySQL数据库系统在执行SQL语句时所选择的执行方式和顺序。

通过查看执行计划，我们可以了解MySQL是如何执行我们的SQL查询语句的，从而帮助我们优化查询性能。

本文将介绍如何在MySQL中查看执行计划，以及如何根据执行计划进行SQL查询性能优化。

1. 使用EXPLAIN语句查看执行计划。

在MySQL中，我们可以使用EXPLAIN语句来查看执行计划。

EXPLAIN语句可以用于SELECT、INSERT、UPDATE和DELETE语句，它将返回一个关于查询执行计划的结果集。

下面是一个使用EXPLAIN语句的例子：```sql。

EXPLAIN SELECT FROM users WHERE age > 18;```。

执行以上SQL语句后，MySQL将返回一个包含查询执行计划的结果集。

在执行计划结果集中，我们可以看到MySQL选择了哪些索引，以及查询的执行顺序等信息。

通过分析执行计划，我们可以发现查询语句的性能瓶颈，从而进行优化。

2. 分析执行计划结果。

在查看执行计划的结果集后，我们需要对结果进行分析，以确定是否存在性能问题，并找出可能的优化方案。

以下是一些常见的执行计划结果分析要点：type字段，表示MySQL在查询过程中使用了何种类型的连接。

常见的类型有，const（表中仅有一行满足条件）、eq_ref（使用了唯一索引进行等值连接）、ref（使用了普通索引进行等值连接）、range（使用了索引进行范围查找）、index（使用了索引扫描）、all（全表扫描）等。

一般来说，type的值越好（如const、eq_ref），性能越好。

key字段，表示MySQL在查询过程中使用了哪个索引。

如果key 为NULL，则表示MySQL没有使用索引。

通过分析key字段，我们可以确定是否需要为查询添加索引，或者调整已有索引。

rows字段，表示MySQL估计需要扫描的行数。

mysql执行计划怎么看

mysql执行计划怎么看MySQL执行计划是指MySQL数据库在执行SQL语句时所采取的执行策略和步骤，通过查看执行计划，我们可以了解MySQL是如何执行我们的SQL语句的，从而可以优化我们的SQL语句和索引设计，提高数据库的性能。

那么，接下来我们就来看一下如何查看MySQL执行计划。

首先，我们需要了解MySQL执行计划是如何生成的。

当我们执行一条SQL语句时，MySQL会根据该语句的复杂度和数据量等因素，选择最优的执行计划来执行该语句。

执行计划是由MySQL的查询优化器生成的，查询优化器会根据表的索引、表的大小、SQL语句的复杂度等因素，选择最优的执行策略。

接下来，我们就来看一下如何查看MySQL执行计划。

在MySQL 中，我们可以使用EXPLAIN关键字来查看执行计划。

例如，我们有一条SQL语句：```sql。

EXPLAIN SELECT FROM users WHERE age > 25;```。

我们可以在这条SQL语句前加上EXPLAIN关键字，然后执行这条SQL语句，MySQL就会返回这条SQL语句的执行计划。

执行计划的结果通常包括以下几个重要字段：id，每个SELECT语句都会被分配一个唯一的标识符，用来区分不同的SELECT语句。

select_type，表示MySQL在执行SELECT语句时所采用的查询类型，例如简单查询、联合查询、子查询等。

table，表示查询涉及的表。

type，表示MySQL在表中找到所需行的方式，常见的取值有，ALL、index、range、ref等。

possible_keys，表示查询涉及的字段上存在的索引。

key，表示MySQL实际选择使用的索引。

key_len，表示MySQL在使用索引的时候，使用了索引的长度。

ref，表示索引的哪一列被使用了，通常是一个常数。

rows，表示MySQL在执行SELECT语句时，需要扫描的行数。

Extra，表示MySQL在执行SELECT语句时的一些额外信息，例如是否使用了临时表、是否使用了文件排序等。

SQL中EXPLAIN命令的使用方法

SQL中EXPLAIN命令的使用方法
一、EXPLAIN命令的作用
EXPLAIN命令是MySQL中一种重要的性能分析工具，其主要功能是将一条SQL语句进行分析，并返回其执行计划，包括执行此SQL语句所需的操作、各操作的顺序、执行此SQL语句所需要的索引，以及每条操作所需要的时间等信息，因此，我们可以通过EXPLAIN命令来查看SQL语句的执行计划，从而帮助我们进行性能优化。

二、EXPLAIN命令的语法
EXPLAIN SELECT [column list] FROM [table list] [WHERE clause]该命令中SELECT、FROM、WHERE这三部分为必须的，其中SELECT部
分可以用*号代替，表示查询所有列，FROM部分可以指定要查询的表，WHERE部分可以指定要查询的条件。

三、EXPLAIN命令的分析结果
当我们执行EXPLAIN命令时，MySQL会返回一个表格，表格中包含了执行SQL语句时的计划，列的名称如下：
id：表示第几个表
select_type：表示查询操作的类型，如SIMPLE、PRIMARY、UNION等table：表示表或视图的名称
type：表示查询时使用的访问类型，如ALL、range等
possible_keys：表示使用的可能索引
key：表示实际使用的索引
key_len：表示索引长度
ref：表示使用的索引列
rows：表示预计查询多少行数据
Extra：表示有关执行计划的额外信息
四、EXPLAIN命令的优化方法
在优化SQL语句的执行计划时，需要根据EXPLAIN的分析结果，结合特定情况，采取适当的优化措施。

具体优化方法如下：。

SQL中EXPLAIN命令的使用方法

SQL中EXPLAIN命令的使用方法
一、EXPLAIN命令
EXPLAIN（分析）是MySQL中的一个指令，是MySQL中查看查询计划的一种工具，可以查看一条select语句内部执行过程的一个估计信息，从而可以对条SQL语句进行优化，提高SQL语句的执行效率，节省资源的一种指令，用来查看select语句的查询计划，常用于查看一个语句的查询执行次序以及估计查询数据量、时间等信息，从而改进SQL语句的性能和结构。

1、EXPLAIN查看查询计划
在MySQL中，我们可以使用EXPLAIN命令来查看查询计划，即一条SQL查询语句在运行过程中的优化模式。

例如，可以使用下面的语句来查看查询计划:
EXPLAIN SELECT * FROM EMPLOYEE WHERE id = 10;
在执行上述查询命令之后，MySQL会返回一个结果集，其中包含了查询语句的信息，如查询的次数、查询的类型、每个表的操作类型、查询所消耗的时间等。

通过这些数据，可以更有效地优化SQL查询语句，提高MySQL服务器的性能。

2、EXPLAIN查看优化器等信息
此外，在MySQL中，还可以使用EXPLAIN命令查看优化器等信息，以提高MySQL系统的执行效率。

例如，可以使用下面的语句来查看优化器等信息：
EXPLAIN EXTENDED SELECT * FROM EMPLOYEE WHERE id = 10;
在执行上述查询命令后，MySQL会返回一个结果集，其中包含了优化器的一些信息，如引擎的类型、优化器模式、制定的计划等。

mysql中explain用法详解

mysql中explain⽤法详解如果在select语句前放上关键词explain，mysql将解释它如何处理select，提供有关表如何联接和联接的次序。

explain的每个输出⾏提供⼀个表的相关信息，并且每个⾏包括下⾯的列：1，id select识别符。

这是select的查询序列号。

2，select_type 可以为⼀下任何⼀种类型simple 简单select(不使⽤union或⼦查询)primary 最外⾯的selectunion union中的第⼆个或后⾯的select语句dependent union union中的第⼆个或后⾯的select语句，取决于外⾯的查询union result union的结果。

subquery ⼦查询中的第⼀个selectdependent subquery ⼦查询中的第⼀个select，取决于外⾯的查询derived 导出表的select(from⼦句的⼦查询)3，table 输出的⾏所引⽤的表。

4，type 联接类型。

下⾯给出各种联接类型，按照从最佳类型到最坏类型进⾏排序：system 表仅有⼀⾏(=系统表)。

这是const联接类型的⼀个特例。

const 表最多有⼀个匹配⾏，它将在查询开始时被读取。

因为仅有⼀⾏，在这⾏的列值可被优化器剩余部分认为是常数。

const表很快，因为它们只读取⼀次！eq_ref 对于每个来⾃于前⾯的表的⾏组合，从该表中读取⼀⾏。

这可能是最好的联接类型，除了const类型。

它⽤在⼀个索引的所有部分被联接使⽤并且索引是unique或primary keyref 对于每个来⾃于前⾯的表的⾏组合，所有有匹配索引值的⾏将从这张表中读取。

如果联接只使⽤键的最左边的前缀，或如果键不是unique或primary key（换句话说，如果联接不能基于关键字选择单个⾏的话），则使⽤ref。

如果使⽤的键仅仅匹配少量⾏，该联接类型是不错的。

ref可以⽤于使⽤=或<=>操作符的带索引的列。

MySQL执行计划Explain参数详解

MySQL执⾏计划Explain参数详解1 数据初始化使⽤Oralce 测试表转换成MySQL。

具体表信息如下（存在组件需按顺序执⾏）dept 部门表字段含义deptno部门编号dname部门名称loc地点DROP TABLE IF EXISTS `dept`;CREATE TABLE `dept` (`DEPTNO` int(2) NOT NULL,`DNAME` varchar(14) DEFAULT NULL,`LOC` varchar(13) DEFAULT NULL,PRIMARY KEY (`DEPTNO`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- ------------------------------ Records of dept-- ----------------------------INSERT INTO `dept` VALUES ('10', 'ACCOUNTING', 'NEW YORK');INSERT INTO `dept` VALUES ('20', 'RESEARCH', 'DALLAS');INSERT INTO `dept` VALUES ('30', 'SALES', 'CHICAGO');INSERT INTO `dept` VALUES ('40', 'OPERATIONS', 'BOSTON');emp 员⼯表字段含义empno员⼯号ename员⼯姓名job⼯作mgr上级编号hiredate受雇⽇期sal薪⾦comm佣⾦deptno部门编号DROP TABLE IF EXISTS `emp`;CREATE TABLE `emp` (`EMPNO` int(4) NOT NULL,`ENAME` varchar(10) DEFAULT NULL,`JOB` varchar(9) DEFAULT NULL,`MGR` int(4) DEFAULT NULL,`HIREDATE` date DEFAULT NULL,`SAL` int(7) DEFAULT NULL,`COMM` int(7) DEFAULT NULL,`DEPTNO` int(2) DEFAULT NULL,PRIMARY KEY (`EMPNO`),KEY `FK_DEPTNO` (`DEPTNO`),CONSTRAINT `FK_DEPTNO` FOREIGN KEY (`DEPTNO`) REFERENCES `dept` (`DEPTNO`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- ------------------------------ Records of emp-- ----------------------------INSERT INTO `emp` VALUES ('7369', 'SMITH', 'CLERK', '7902', '1980-12-17', '800', null, '20');INSERT INTO `emp` VALUES ('7499', 'ALLEN', 'SALESMAN', '7698', '1981-02-20', '1600', '300', '30');INSERT INTO `emp` VALUES ('7521', 'WARD', 'SALESMAN', '7698', '1981-02-22', '1250', '500', '30');INSERT INTO `emp` VALUES ('7566', 'JONES', 'MANAGER', '7839', '1981-04-02', '2975', null, '20');INSERT INTO `emp` VALUES ('7654', 'MARTIN', 'SALESMAN', '7698', '1981-09-28', '1250', '1400', '30');INSERT INTO `emp` VALUES ('7698', 'BLAKE', 'MANAGER', '7839', '1981-05-01', '2850', null, '30');INSERT INTO `emp` VALUES ('7782', 'CLARK', 'MANAGER', '7839', '1981-06-09', '2450', null, '10');INSERT INTO `emp` VALUES ('7788', 'SCOTT', 'ANALYST', '7566', '1987-04-19', '3000', null, '20');INSERT INTO `emp` VALUES ('7839', 'KING', 'PRESIDENT', null, '1981-11-17', '5000', null, '10');INSERT INTO `emp` VALUES ('7844', 'TURNER', 'SALESMAN', '7698', '1981-09-08', '1500', '0', '30');INSERT INTO `emp` VALUES ('7876', 'ADAMS', 'CLERK', '7788', '1987-05-23', '1100', null, '20');INSERT INTO `emp` VALUES ('7900', 'JAMES', 'CLERK', '7698', '1981-12-03', '950', null, '30');INSERT INTO `emp` VALUES ('7902', 'FORD', 'ANALYST', '7566', '1981-12-03', '3000', null, '20');INSERT INTO `emp` VALUES ('7934', 'MILLER', 'CLERK', '7782', '1982-01-23', '1300', null, '10');salgrade表DROP TABLE IF EXISTS `salgrade`;CREATE TABLE `salgrade` (`grade` int(11) NOT NULL DEFAULT '0',`losal` int(11) DEFAULT NULL,`hisal` int(11) DEFAULT NULL,PRIMARY KEY (`grade`)) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- ------------------------------ Records of salgrade-- ----------------------------INSERT INTO `salgrade` VALUES ('1', '700', '1200');INSERT INTO `salgrade` VALUES ('2', '1201', '1400');INSERT INTO `salgrade` VALUES ('3', '1401', '2000');INSERT INTO `salgrade` VALUES ('4', '2001', '3000');INSERT INTO `salgrade` VALUES ('5', '3001', '9999');2 执⾏计划中包含的信息Column Meaningid The SELECT identifier select_type The SELECT typetable The table for the output rowpartitions The matching partitionstype The join typepossible_keys The possible indexes to choose key The index actually chosenkey_len The length of the chosen keyref The columns compared to the indexrows Estimate of rows to be examinedfiltered Percentage of rows filtered by table conditionextra Additional informationidselect查询的序列号，包含⼀组数字，表⽰查询中执⾏select⼦句或者操作表的顺序id号分为三种情况：如果id相同，那么执⾏顺序从上到下EXPLAIN SELECT*FROMemp eJOIN dept d ON e.deptno = d.deptnoJOIN salgrade sg ON e.sal BETWEEN sg.losalAND sg.hisal;如果id不同，如果是⼦查询，id的序号会递增，id值越⼤优先级越⾼，越先被执⾏EXPLAIN SELECT*FROMemp e WHEREe.deptno IN ( SELECT d.deptno FROM dept d WHERE d.dname = 'SALES' );id 相同和不同的，同时存在：相同的可以认为是⼀组，从上往下顺序执⾏，在所有组中，id 值越⼤，优先级越⾼，越先执⾏EXPLAIN SELECT *FROM emp eJOIN dept d ON e.deptno = d.deptnoJOIN salgrade sg ON e.sal BETWEEN sg.losal AND sg.hisal WHEREe.deptno IN ( SELECT d.deptno FROM dept d WHERE d.dname = 'SALES' );select_type主要⽤来分辨查询的类型，是普通查询还是联合查询还是⼦查询sample ：简单的查询，不包含⼦查询和unionEXPLAIN SELECT *FROM emp;primary ：查询中若包含任何复杂的⼦查询，最外层查询则被标记为PrimaryEXPLAIN SELECT staname,ename supname FROM( SELECT ename staname, mgr FROM emp ) t JOIN emp ON t.mgr = emp.empno;union ：若第⼆个select 出现在union 之后，则被标记为unionEXPLAIN SELECT *FROM emp WHEREdeptno = 10 UNION SELECT *FROM emp WHERE sal > 2000;dependent union ：跟union 类似，此处的depentent 表⽰union 或union all 联合⽽成的结果会受外部表影响EXPLAIN SELECTselect_type ValueMeaningSIMPLE Simple SELECT (not using UNION or subqueries)PRIMARY Outermost SELECTUNIONSecond or later SELECT statement in a UNIONDEPENDENT UNION Second or later SELECT statement in a UNION, dependent on outer queryUNION RESULT Result of a UNION.SUBQUERYFirst SELECT in subqueryDEPENDENT SUBQUERYFirst SELECT in subquery, dependent on outer queryDERIVED Derived tableUNCACHEABLE SUBQUERY A subquery for which the result cannot be cached and must be re-evaluated for each row of the outer query UNCACHEABLE UNIONThe second or later select in a UNION that belongs to an uncacheable subquery (see UNCACHEABLESUBQUERY)*FROMemp eWHEREe.empno IN (SELECTempnoFROMempWHEREdeptno = 10 UNIONSELECTempnoFROMempWHEREsal > 2000)union result：从union表获取结果的selectEXPLAIN SELECT*FROMempWHEREdeptno = 10 UNIONSELECT*FROMempWHEREsal > 2000;subquery：在select或者where列表中包含⼦查询EXPLAIN SELECT*FROMempWHEREsal > ( SELECT avg( sal ) FROM emp );dependent subquery:subquery的⼦查询要受到外部表查询的影响EXPLAIN SELECT*FROMemp eWHEREe.deptno IN ( SELECT DISTINCT deptno FROM dept );DERIVED: from⼦句中出现的⼦查询，也叫做派⽣类，EXPLAIN SELECTstaname,ename supnameFROM( SELECT ename staname, mgr FROM emp ) tJOIN emp ON t.mgr = emp.empno;UNCACHEABLE SUBQUERY：表⽰使⽤⼦查询的结果不能被缓存EXPLAIN SELECT*FROMempWHEREempno = ( SELECT empno FROM emp WHERE deptno = @@sort_buffer_size );uncacheable union:表⽰union的查询结果不能被缓存：sql语句未验证table对应⾏正在访问哪⼀个表，表名或者别名，可能是临时表或者union合并结果集。

MySQL中EXPLAIN结果的参数详解

MySQL中EXPLAIN结果的参数详解explain显⽰了mysql如何使⽤索引来处理select语句以及连接表。

可以帮助选择更好的索引和写出更优化的查询语句。

使⽤⽅法，在select语句前加上explain就可以了。

MySQL索引优化，explain详细讲解

MySQL索引优化，explain详细讲解前⾔：这篇⽂章主要讲 explain 如何使⽤，还有 explain 各种参数概念，之后会讲优化⼀、Explain ⽤法模拟Mysql优化器是如何执⾏SQL查询语句的，从⽽知道Mysql是如何处理你的SQL语句的。

分析你的查询语句或是表结构的性能瓶颈。

语法：Explain + SQL 语句;如：Explain select * from user; 会⽣成如下 SQL 分析结果，下⾯详细对每个字段进⾏详解⼆、id是⼀组数字，代表多个表之间的查询顺序，或者包含⼦句查询语句中的顺序，id 总共分为三种情况，依次详解id 相同，执⾏顺序由上⾄下id 不同，如果是⼦查询，id 号会递增，id 值越⼤优先级越⾼，越先被执⾏id 相同和不同的情况同时存在三、select_typeselect_type 包含以下⼏种值simpleprimarysubqueryderivedunionunion resultsimple简单的 select 查询，查询中不包含⼦查询或者 union 查询primary如果 SQL 语句中包含任何⼦查询，那么⼦查询的最外层会被标记为 primarysubquery在 select 或者 where ⾥包含了⼦查询，那么⼦查询就会被标记为 subQquery，同三.⼆同时出现derived在 from 中包含的⼦查询，会被标记为衍⽣查询，会把查询结果放到⼀个临时表中union / union result如果有两个 select 查询语句，他们之间⽤ union 连起来查询，那么第⼆个 select 会被标记为 union，union 的结果被标记为 union result。

它的 id 是为 null 的四、table表⽰这⼀⾏的数据是哪张表的数据五、typetype 是代表 MySQL 使⽤了哪种索引类型，不同的索引类型的查询效率也是不⼀样的，type ⼤致有以下种类systemconsteq_refrefrangeindexallsystem表中只有⼀⾏记录，system 是 const 的特例，⼏乎不会出现这种情况，可以忽略不计const将主键索引或者唯⼀索引放到 where 条件中查询，MySQL 可以将查询条件转变成⼀个常量，只匹配⼀⾏数据，索引⼀次就找到数据了eq_ref在多表查询中，如 T1 和 T2，T1 中的⼀⾏记录，在 T2 中也只能找到唯⼀的⼀⾏，说⽩了就是 T1 和 T2 关联查询的条件都是主键索引或者唯⼀索引，这样才能保证 T1 每⼀⾏记录只对应 T2 的⼀⾏记录举个不太恰当的例⼦，EXPLAIN SELECT * from t1 , t2 where t1.id = t2.idref不是主键索引，也不是唯⼀索引，就是普通的索引，可能会返回多个符合条件的⾏。

MySQL中EXPLAIN解释命令查看索引是否生效

MySQL中EXPLAIN解释命令查看索引是否⽣效explain显⽰了mysql如何使⽤索引来处理select语句以及连接表。

可以帮助选择更好的索引和写出更优化的查询语句。

使⽤⽅法，在select语句前加上explain就可以了：如：1. explain select surname,first_name form a,b where a.id=b.idEXPLAIN列的解释：table：显⽰这⼀⾏的数据是关于哪张表的type：这是重要的列，显⽰连接使⽤了何种类型。

从最好到最差的连接类型为const、eq_reg、ref、range、indexhe和ALLpossible_keys：显⽰可能应⽤在这张表中的索引。

如果为空，没有可能的索引。

可以为相关的域从WHERE语句中选择⼀个合适的语句key：实际使⽤的索引。

如果为NULL，则没有使⽤索引。

很少的情况下，MYSQL会选择优化不⾜的索引。

这种情况下，可以在SELECT语句中使⽤USE INDEX（indexname）来强制使⽤⼀个索引或者⽤IGNORE INDEX（indexname）来强制MYSQL忽略索引key_len：使⽤的索引的长度。

在不损失精确性的情况下，长度越短越好ref：显⽰索引的哪⼀列被使⽤了，如果可能的话，是⼀个常数rows：MYSQL认为必须检查的⽤来返回请求数据的⾏数Extra：关于MYSQL如何解析查询的额外信息。

将在表4.3中讨论，但这⾥可以看到的坏的例⼦是Using temporary和Using filesort，意思MYSQL根本不能使⽤索引，结果是检索会很慢extra列返回的描述的意义Distinct:⼀旦MYSQL找到了与⾏相联合匹配的⾏，就不再搜索了Not exists: MYSQL优化了LEFT JOIN，⼀旦它找到了匹配LEFT JOIN标准的⾏，就不再搜索了Range checked for each Record（index map:#）:没有找到理想的索引，因此对于从前⾯表中来的每⼀个⾏组合，MYSQL检查使⽤哪个索引，并⽤它来从表中返回⾏。

详解 mysql 中 explain 用法

EXPLAIN是MySQL 中的一个重要命令，它用于查看查询语句的执行计划。

当你对SQL 查询的性能有疑问时，可以使用EXPLAIN来分析查询的执行方式，从而找出可能的性能瓶颈并进行优化。

下面是EXPLAIN的基本用法和解释：1. 基本语法sql复制代码EXPLAIN SELECT ... FROM ... WHERE ...将你的查询语句前加上EXPLAIN关键字，然后执行该查询，MySQL 将返回查询的执行计划，而不是查询结果。

2. 返回结果EXPLAIN的返回结果包含多个列，这些列提供了关于查询执行计划的详细信息。

以下是一些常见的列：•id: 查询标识符。

•select_type: 查询的类型（例如SIMPLE, SUBQUERY, DERIVED 等）。

•table: 输出结果集的表。

•partitions: 匹配的分区。

•type: 访问类型（例如ALL, index, range, ref, eq_ref, const, system, NULL）。

•possible_keys: 可能使用的索引。

•key: 实际使用的索引。

•key_len: 使用的索引的长度。

•ref: 哪些列或常量被用作索引查找的参考。

•rows: 估计要检查的行数。

•filtered: 返回结果的百分比。

•Extra: 额外的信息。

3. 使用EXPLAIN进行性能优化•查看索引使用：通过possible_keys和key列，你可以看到查询是否使用了索引，以及使用了哪些索引。

如果key列是NULL，那么可能需要进行索引优化。

•分析访问类型：type列显示了查询的访问类型。

理想情况下，你希望看到ref、eq_ref、const或system。

如果看到ALL，表示全表扫描，可能需要优化。

•查看行数估计：rows列显示了MySQL 估计需要检查的行数。

这个数字越大，通常表示查询越慢。

•注意额外信息：Extra列可能包含一些有用的信息，例如"Using where" 表示MySQL 需要使用WHERE 子句来过滤结果，"Using filesort" 表示MySQL 需要进行额外的排序步骤，这可能会很慢。

mysql explain extra字段含义

在MySQL的EXPLAIN语句中，`extra`字段提供了关于查询执行计划的额外信息。

以下是`extra`字段中可能出现的常见值的含义：1. `Using filesort`：表示在执行查询时使用了文件排序来对结果进行排序，而不是使用索引进行排序。

这通常发生在查询中没有合适的索引可供使用，或者查询需要按照某个未包含在索引中的列进行排序时。

2. `Using index`：表示在执行查询时使用了索引来获取结果。

这通常表示查询使用了覆盖索引（即索引包含了所有需要查询的数据），或者查询使用了部分索引（即索引只覆盖了查询的一部分数据）。

3. `Using temporary`：表示在执行查询时使用了临时表来存储中间结果。

这通常发生在查询涉及到复杂的连接或者分组操作时。

4. `Using more key fileds than key parts`：表示查询使用了比实际索引部分更多的列。

这通常发生在查询使用了覆盖索引，但是覆盖索引的列数少于查询中使用的列数。

5. `Full scan on NULL key`：表示在执行查询时对某个索引进行了全扫描，因为索引中的某个列的所有值都是NULL。

6. `Range checked for each record (index map: N)`：表示在执行查询时对每个记录都进行了范围检查。

这通常发生在查询使用了部分索引，但是查询条件不满足索引的最左前缀原则。

7. `Not exists`：表示在执行查询时进行了子查询的优化，将子查询替换为查找是否存在满足条件的记录。

8. `Impossible WHERE noticed after reading const tables`：表示在执行查询时遇到了不可能满足的WHERE条件，这个条件是在读取常量表后发现的。

9. `Using where with pushed condition`：表示在执行查询时将WHERE条件与推开的条件一起使用。

mysql explain cost单位

mysql explain cost单位MySQL的EXPLAIN语句用于分析查询语句的执行计划，并返回相关的优化信息。

其中，EXPLAIN结果中的"cost"列显示了查询执行的成本估计，是一个衡量查询效率的重要指标。

本文将介绍MySQL中EXPLAIN语句的cost单位以及一些相关的参考内容。

在MySQL中，EXPLAIN语句的cost单位是“row”，表示查询执行过程中所处理的行数。

具体来说，cost表示执行查询所需的总行数。

可以将cost看作是查询语句执行的代价，值越大表示执行代价越高，值越小表示执行代价越低。

在EXPLAIN结果中，每个操作（如索引扫描、全表扫描、连接等）都会有一个对应的cost值。

这些cost值可以帮助我们评估查询语句的性能，并且可以与不同的优化方式进行比较，以找到执行效果最好的方案。

除了cost值，EXPLAIN结果还提供了一些其他有用的信息，包括访问表的类型、访问类型、使用的索引、访问的行数等。

这些信息可以帮助我们理解查询语句的执行过程，并且可以根据需要进行索引优化或重构查询语句，以提高查询性能。

在分析查询语句时，可以根据cost值的大小来判断查询语句的性能。

一般来说，较小的cost值表示查询语句执行效率较高，而较大的cost值表示查询语句执行效率较低。

但需要注意的是，cost值只是一个估计值，并不一定准确反映实际性能。

在实际情况中，有时较大的cost值的查询语句可能比较快，而较小的cost值的查询语句可能比较慢，因为cost值只是根据统计信息进行估算的，并不能考虑到具体的查询场景和硬件资源。

在使用EXPLAIN语句分析查询性能时，还需要考虑一些其他因素。

首先，要注意查看是否有合适的索引被使用，因为索引的使用对于查询性能至关重要。

其次，要注意查询语句的写法是否合理，是否有不必要的操作或重复操作。

此外，还需要了解数据库的统计信息是否准确，因为统计信息对于优化查询计划也非常重要。

mysql explain cost单位

mysql explain cost单位在MySQL中，`Explain`语句是用于分析查询语句的执行计划，通过展示查询语句的各个步骤以及各个步骤的执行成本来帮助优化查询性能。

其中，成本是通过一个表示查询执行代价的单位来进行衡量的。

在MySQL的`Explain`结果中，有一个重要的字段是`cost`，它表示了执行某个查询步骤的代价。

在解释`cost`单位之前，我们需要了解一些相关的概念。

首先，MySQL使用的是基于代价的优化器（cost-based optimizer），通过评估各种执行计划的代价来选择最优的执行计划。

代价评估的目标是选择一个执行计划，使得查询的总执行时间最小。

在MySQL中，`cost`单位是“单元”，它表示了执行某一步骤所需的估计成本。

`cost`是一个相对值，不是绝对的执行时间或者资源消耗。

通过比较不同执行计划的`cost`值，MySQL的优化器可以选择成本最低的执行计划。

具体来说，MySQL中的`cost`单位是由多个因素组成的。

以下是一些可能会影响`cost`值的因素：1. 访问单元数：`cost`值与查询访问的单元数量成正比。

例如，如果查询需要扫描一个表的所有行，`cost`值可能会比只扫描一小部分行的查询高。

2. IO成本：查询中涉及到磁盘IO的操作（如磁盘读取和写入）会增加`cost`值。

磁盘IO通常比内存访问更加耗时，因此需要分配更多的代价。

3. 排序成本：如果查询需要进行排序操作，那么排序的成本也会增加`cost`值。

排序操作通常需要对数据进行多次读写，因此它的成本相对较高。

4. 连接成本：如果查询需要进行连接操作（如`join`），那么连接的成本也会增加`cost`值。

连接操作涉及到对不同表的数据进行匹配，可能需要对大量的数据进行比对和合并，因此它的成本相对较高。

需要注意的是，`cost`值是一个相对的指标，不同的查询执行计划的`cost`值无法直接进行比较。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

对mysql explain讲的比较清楚的在explain的帮助下，您就知道什么时候该给表添加索引，以使用索引来查找记录从而让select运行更快。

如果由于不恰当使用索引而引起一些问题的话，可以运行analyze table来更新该表的统计信息，例如键的基数，它能帮您在优化方面做出更好的选择。

explain返回了一行记录，它包括了select语句中用到的各个表的信息。

这些表在结果中按照mysql即将执行的查询中读取的顺序列出来。

mysql用一次扫描多次连接（single-sweep,multi-join）的方法来解决连接。

这意味着mysql从第一个表中读取一条记录，然后在第二个表中查找到对应的记录，然后在第三个表中查找，依次类推。

当所有的表都扫描完了，它输出选择的字段并且回溯所有的表，直到找不到为止，因为有的表中可能有多条匹配的记录下一条记录将从该表读取，再从下一个表开始继续处理。

在mysql version4.1中，explain输出的结果格式改变了，使得它更适合例如union语句、子查询以及派生表的结构。

更令人注意的是，它新增了2个字段：id和select_type。

当你使用早于mysql4.1的版本就看不到这些字段了。

explain结果的每行记录显示了每个表的相关信息，每行记录都包含以下几个字段：id本次select的标识符。

在查询中每个select都有一个顺序的数值。

select_typeselect的类型，可能会有以下几种：simple:简单的select（没有使用union或子查询）primary:最外层的select。

union:第二层，在select之后使用了union。

dependent union:union语句中的第二个select，依赖于外部子查询subquery:子查询中的第一个selectdependent subquery:子查询中的第一个subquery依赖于外部的子查询derived:派生表select（from子句中的子查询）table记录查询引用的表。

type表连接类型。

以下列出了各种不同类型的表连接，依次是从最好的到最差的：system:表只有一行记录（等于系统表）。

这是const表连接类型的一个特例。

const:表中最多只有一行匹配的记录，它在查询一开始的时候就会被读取出来。

由于只有一行记录，在余下的优化程序里该行记录的字段值可以被当作是一个恒定值。

const表查询起来非常快，因为只要读取一次！const用于在和primary key或unique索引中有固定值比较的情形。

下面的几个查询中，tbl_name就是c表了：select*from tbl_name where primary_key=1;select*from tbl_namewhere primary_key_part1=1 and primary_key_part2=2;eq_ref:从该表中会有一行记录被读取出来以和从前一个表中读取出来的记录做联合。

与const类型不同的是，这是最好的连接类型。

它用在索引所有部分都用于做连接并且这个索引是一个primary key或unique类型。

eq_ref可以用于在进行"="做比较时检索字段。

比较的值可以是固定值或者是表达式，表达示中可以使用表里的字段，它们在读表之前已经准备好了。

以下的几个例子中，mysql使用了eq_ref连接来处理ref_table：select*from ref_table,other_table whereref_table.key_column=other_table.column;select* fromref_table,other_table whereref_table.key_column_part1=other_table.column andref_table.key_column_part2=1;ref:该表中所有符合检索值的记录都会被取出来和从上一个表中取出来的记录作联合。

ref 用于连接程序使用键的最左前缀或者是该键不是primary key或unique索引（换句话说，就是连接程序无法根据键值只取得一条记录）的情况。

当根据键值只查询到少数几条匹配的记录时，这就是一个不错的连接类型。

ref还可以用于检索字段使用=操作符来比较的时候。

以下的几个例子中，mysql将使用ref来处理ref_table：select*from ref_table where key_column=expr;select*fromref_table,other_table whereref_table.key_column=other_table.column;select*fromref_table,other_table whereref_table.key_column_part1=other_table.column andref_table.key_column_part2=1;ref_or_null:这种连接类型类似ref，不同的是mysql会在检索的时候额外的搜索包含null值的记录。

这种连接类型的优化是从mysql4.1.1开始的，它经常用于子查询。

在以下的例子中，mysql使用ref_or_null类型来处理ref_table：select*from ref_table where key_column=expr or key_column is null;unique_subquery:这种类型用例如一下形式的in子查询来替换ref：value in(select primary_key from single_table where some_expr)unique_subquery:只是用来完全替换子查询的索引查找函数效率更高了。

index_subquery:这种连接类型类似unique_subquery。

它用子查询来代替in，不过它用于在子查询中没有唯一索引的情况下，例如以下形式：value in(select key_column from single_table where some_expr)range:只有在给定范围的记录才会被取出来，利用索引来取得一条记录。

key字段表示使用了哪个索引。

key_len字段包括了使用的键的最长部分。

这种类型时ref字段值是null。

range用于将某个字段和一个定植用以下任何操作符比较时=,<>,>,>=,<,<=,is null,<=>, between,或in：select*from tbl_name where key_column=10;select*fromtbl_name where key_column between10and20;select*from tbl_namewhere key_column in(10,20,30);select*from tbl_name wherekey_part1=10and key_part2in(10,20,30);index:连接类型跟all一样，不同的是它只扫描索引树。

它通常会比all快点，因为索引文件通常比数据文件小。

mysql在查询的字段知识单独的索引的一部分的情况下使用这种连接类型。

all:将对该表做全部扫描以和从前一个表中取得的记录作联合。

这时候如果第一个表没有被标识为const的话就不大好了，在其他情况下通常是非常糟糕的。

正常地，可以通过增加索引使得能从表中更快的取得记录以避免all。

possible_keyspossible_keys字段是指mysql在搜索表记录时可能使用哪个索引。

注意，这个字段完全独立于explain显示的表顺序。

这就意味着possible_keys里面所包含的索引可能在实际的使用中没用到。

如果这个字段的值是null，就表示没有索引被用到。

这种情况下，就可以检查where子句中哪些字段那些字段适合增加索引以提高查询的性能。

就这样，创建一下索引，然后再用explain检查一下。

详细的查看章节"14.2.2alter tablesyntax"。

想看表都有什么索引，可以通过show index from tbl_name来看。

keykey字段显示了mysql实际上要用的索引。

当没有任何索引被用到的时候，这个字段的值就是null。

想要让mysql强行使用或者忽略在possible_keys字段中的索引列表，可以在查询语句中使用关键字force index,use index,或ignore index。

如果是myisam和bdb类型表，可以使用analyzetable来帮助分析使用使用哪个索引更好。

如果是myisam类型表，运行命令myisamchk--analyze也是一样的效果。

详细的可以查看章节"14.5.2.1analyze tablesyntax"和"5.7.2table maintenance and crash recovery"。

key_lenkey_len字段显示了mysql使用索引的长度。

当key字段的值为null时，索引的长度就是null。

注意，key_len的值可以告诉你在联合索引中mysql会真正使用了哪些索引。

refref字段显示了哪些字段或者常量被用来和key配合从表中查询记录出来。

rowsrows字段显示了mysql认为在查询中应该检索的记录数。

extra本字段显示了查询中mysql的附加信息。

以下是这个字段的几个不同值的解释：distinct:mysql当找到当前记录的匹配联合结果的第一条记录之后，就不再搜索其他记录了。

not exists:mysql在查询时做一个left join优化时，当它在当前表中找到了和前一条记录符合left join条件后，就不再搜索更多的记录了。

下面是一个这种类型的查询例子：select*from t1left join t2on t1.id=t2.id where t2.id isnull;假使t2.id定义为not null。

这种情况下，mysql将会扫描表t1并且用t1.id的值在t2中查找记录。

当在t2中找到一条匹配的记录时，这就意味着t2.id肯定不会都是null，就不会再在t2中查找相同id值的其他记录了。

也可以这么说，对于t1中的每个记录，mysql 只需要在t2中做一次查找，而不管在t2中实际有多少匹配的记录。

range checked for each record(index map:#)mysql没找到合适的可用的索引。