以及当运行SQL语句时哪种策略预计会被优化器采用,  我的理解是SQL执行的顺利的标识

该文主要讲解explain命令的使用及相关参数说明,MySQL,些时我们常常用到explain这个命令来查看一个这些SQL语句的执行计划,以及当运行SQL语句时哪种策略预计会被优化器采用,SQL从大到小的执行.,就是从id=3 向上执行.,+—-+————-+———-+——-+—————+——+———+——+——+—————–,Using index |

图片 1

MySQL
EXPLAIN命令是询问品质优化不可缺点和失误的一片段,该文首要疏解explain命令的行使及连锁参数表达。

仿效资料:

mysql> explain select * from t3 where
id in (select id from t3 where id=3952602 union all select id from
t3)  ;

+—-+————-+———-+——-+—————+——+———+——+——+—————–
| id | select_type | table | type |…

EXPLAIN Output Columns

列名 说明
id 执行编号,标识select所属的行。如果在语句中没子查询或关联查询,只有唯一的select,每行都将显示1。否则,内层的select语句一般会顺序编号,对应于其在原始语句中的位置
select_type 显示本行是简单或复杂select。如果查询有任何复杂的子查询,则最外层标记为PRIMARY(DERIVED、UNION、UNION RESUlT)
table 访问引用哪个表(引用某个查询,如“derived3”)
type 数据访问/读取操作类型(ALL、index、range、ref、eq_ref、const/system、NULL)
possible_keys 揭示哪一些索引可能有利于高效的查找
key 显示mysql决定采用哪个索引来优化查询
key_len 显示mysql在索引里使用的字节数
ref 显示了之前的表在key列记录的索引中查找值所用的列或常量
rows 为了找到所需的行而需要读取的行数,估算值,不精确。通过把所有rows列值相乘,可粗略估算整个查询会检查的行数
Extra 额外信息,如using index、filesort等

 

mysql> drop index idx_t3_id on t3;
Query OK, 1000 rows affected (0.03 sec)
Records: 1000 Duplicates: 0 Warnings: 0

mysql> create index idx_t3_id on t3(id) ;
Query OK, 1000 rows affected (0.04 sec)
Records: 1000 Duplicates: 0 Warnings: 0

 使用EXPLAIN语句检查优化器操作
+—-+————-+———-+——-+—————+——+———+——+——+—————–
| id | select_type | table | type | possible_keys | key | key_len|
ref | rows | Extra
+—-+————-+———-+——-+—————+——+———+——+——+—————–
| 1 |SIMPLE | car_info | range | name | name | 768 | NULL | 9 | Using
where; Using index |
+—-+————-+———-+——-+—————+——+———+——+——+—————-
EXPLAIN输出解释
select_type 犹如下三种等级次序:
SIMPLE:未利用连接查询也许子查询的粗略select语句 explain select *
from car_info;
P奥迪Q5IMA纳瓦拉Y:最外层的select语句 explain select * from (select name from
car_info where name like ‘凯迪拉克%’) as a;
+—-+————-+————+——-+—————+——+———+——+——+————-
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+—-+————-+————+——-+—————+——+———+——+——+—————
| 1 | PRIMARY | <derived2> | ALL | NULL | NULL | NULL | NULL | 9 |
|
| 2 | DERIVED | car_info | range | name | name | 768 | NULL | 9 | Using
where; Using index |
+—-+————-+————+——-+—————+——+———+——+——+—————
UNION:union中的第二个,或前边的select语句 explain select name from
car_info where id =100 union select name from web_car_brands where id
=5;
+——+————–+—————-+——-+—————+———+———+——-+——+–
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+——+————–+—————-+——-+—————+———+———+——-+——+—
| 1 | PRIMARY | car_info | const | PRIMARY | PRIMARY | 8 | const | 1 |
| | 2 | UNION | web_car_brands | const | PRIMARY,id | PRIMARY | 4 |
const | 1 | | | NULL | UNION RESULT | <union1,2> | ALL | NULL |
NULL | NULL | NULL | NULL | |
+——+————–+—————-+——-+—————+———+———+——-+——+—

id

id是用来挨门挨户标志整个查询中SELELCT
语句的,在嵌套查询中id越大的语句越先实行。该值可能为NULL,假诺那豆蔻梢头行用来声明的是此外行的联手结果。

range:只检索给定范围的行,使用叁个目录来抉择行

纵然select类型,能够有以下

DE普拉多IVED:在from列表中包蕴子查询,mysql会递归的实行该子查询,并把结果放在不经常表中
explain select * from (select name from car_info where id = 100) a;
+—-+————-+————+——–+—————+———+———+——+——+-
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+—-+————-+————+——–+—————+———+———+——+——+-
| 1 | PRIMARY | <derived2> | system | NULL | NULL | NULL | NULL |
1 | | | 2 | DERIVED | car_info | const | PRIMARY | PRIMARY | 8 | | 1 |
|
+—-+————-+————+——–+—————+———+———+——+——+-
type列: MySQL
在表里找到所需行的秘籍富含如下几张(由左至右,由最差到最棒):
All–>index–>range–>ref –>eq_ref–>const,system
–>null
ALL:举行全部据表扫描
index:依据索引的程序扫描表,先读索引,然后读取具体的多少行,其实依然全表扫描,好处在于不用排序,遵照索引的依次
range:根据有个别范围读取数据行 ref:非唯风度翩翩性索引访问eq_ref:使用唯大器晚成性索引访谈(主键或许唯生龙活虎性索引)
const:最多唯有三个相称行,const常用于数值相比如 primary key
null:在优化进程中生龙活虎度赢得结果,没有必要访问表只怕索引 如:explain select
min(id) from car_info;
possible_keys列:
possible_keys列提议MySQL能应用哪个索引在该表中找到行。注意,该列完全部独用立于EXPLAIN输出所示的表的顺序。那象征在possible_keys中的某个键实际上无法按生成的表次序使用。

Extra

Extra是EXPLAIN输出中其它八个很要紧的列,该列展现MySQL在询问进程中的一些详细音讯,MySQL查询优化器试行查询的长河中对查询安排的根本补充音讯。

类型 说明
Using filesort MySQL有两种方式可以生成有序的结果,通过排序操作或者使用索引,当Extra中出现了Using filesort 说明MySQL使用了后者,但注意虽然叫filesort但并不是说明就是用了文件来进行排序,只要可能排序都是在内存里完成的。大部分情况下利用索引排序更快,所以一般这时也要考虑优化查询了。使用文件完成排序操作,这是可能是ordery by,group by语句的结果,这可能是一个CPU密集型的过程,可以通过选择合适的索引来改进性能,用索引来为查询结果排序。
Using temporary 用临时表保存中间结果,常用于GROUP BY 和 ORDER BY操作中,一般看到它说明查询需要优化了,就算避免不了临时表的使用也要尽量避免硬盘临时表的使用。
Not exists MYSQL优化了LEFT JOIN,一旦它找到了匹配LEFT JOIN标准的行, 就不再搜索了。
Using index 说明查询是覆盖了索引的,不需要读取数据文件,从索引树(索引文件)中即可获得信息。如果同时出现using where,表明索引被用来执行索引键值的查找,没有using where,表明索引用来读取数据而非执行查找动作。这是MySQL服务层完成的,但无需再回表查询记录。
Using index condition 这是MySQL 5.6出来的新特性,叫做“索引条件推送”。简单说一点就是MySQL原来在索引上是不能执行如like这样的操作的,但是现在可以了,这样减少了不必要的IO操作,但是只能用在二级索引上。
Using where 使用了WHERE从句来限制哪些行将与下一张表匹配或者是返回给用户。注意:Extra列出现Using where表示MySQL服务器将存储引擎返回服务层以后再应用WHERE条件过滤。
Using join buffer 使用了连接缓存:Block Nested Loop,连接算法是块嵌套循环连接;Batched Key Access,连接算法是批量索引连接
impossible where where子句的值总是false,不能用来获取任何元组
select tables optimized away 在没有GROUP BY子句的情况下,基于索引优化MIN/MAX操作,或者对于MyISAM存储引擎优化COUNT(*)操作,不必等到执行阶段再进行计算,查询执行计划生成的阶段即完成优化。
distinct 优化distinct操作,在找到第一匹配的元组后即停止找同样值的动作

作者:高广超
链接:
來源:简书
版权表达:内容来自互连网,版权归原创者全部。除非不可能确认,大家都会标注笔者及出处,如有侵害权益烦请告知,我们会即时删除并表示歉意。谢谢。

 

笔者储存多年的干货文书档案无偿赠送,包涵前端后端和测量检验,系统架构,高并发管理,优化等

图片 1

 

(5) UNION RESULT(UNION的结果)

例如:

DEPENDENT
UNION:union中的第2个或后边的色了理念语句,决意于外面包车型地铁查询

mysql> explain select * from t3 where id in (select id from t3 where
id=3952602 union all select id from t3) ;
+—-+——————–+————+——–+——————-+———+———+——-+——+——
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+—-+——————–+————+——–+——————-+———+———+——-+——+–
| 1 | PRIMARY | t3 | ALL | NULL | NULL | NULL | NULL | 1000 | Using
where
| 2 | DEPENDENT SUBQUERY | t3 | const | PRIMARY,idx_t3_id | PRIMARY |
4 | const | 1 | Using index |
| 3 | DEPENDENT UNION | t3 | eq_ref | PRIMARY,idx_t3_id | PRIMARY | 4
| func | 1 | Using where; Using index |
|NULL | UNION RESULT | <union2,3> | ALL | NULL | NULL | NULL |
NULL | NULL | |
+—-+——————–+————+——–+——————-+———+———+——-+——+-

ref

ref列展现选用哪个列或常数与key一同从表中精选行。

key列展现MySQL实际调整选用的键(索引卡塔尔国

mysql> explain select * from (select *
from t3 where id=3952602) a ;

UNION RESULT:union的结果 explain select name from car_info where
id =100 union select name from web_car_brands where id =5;
+——+————–+—————-+——-+—————+———+———+——-+——+—–
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+——+————–+—————-+——-+—————+———+———+——-+——+–
| 1 | PRIMARY | car_info | const | PRIMARY | PRIMARY | 8 | const | 1 |
| | 2 | UNION | web_car_brands | const | PRIMARY,id | PRIMARY | 4 |
const | 1 | | | NULL | UNION RESULT | <union1,2> | ALL | NULL |
NULL | NULL | NULL | NULL | |
+——+————–+—————-+——-+—————+———+———+——-+——+—-
SUBQUERubiconY:子查询中的第二个SELECT语句 explain select name from
car_info where id = (select id from web_car_series where id = 5);
+—-+————-+—————-+——-+—————+———+———+——-+——+—–
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+—-+————-+—————-+——-+—————+———+———+——-+——+——
| 1 | PRIMARY | car_info | const | PRIMARY | PRIMARY | 8 | const | 1 |
| | 2 | SUBQUERY | web_car_series | const | PRIMARY | PRIMARY | 4 | |
1 | Using index |
+—-+————-+—————-+——-+—————+———+———+——-+——+—–

rows

rows列呈现MySQL以为它实施查询时必需检查的行数。注意那是一个预价值评估。

key_len

key_len列展现MySQL决定运用的键长度。假若键是NULL,则长度为NULL。使用的目录的长度。在不损失正确性的情状下,长度越短越好

(4).Using filesort

DEPENDENT SUBQUE哈弗Y:子查询中的第叁个SELECT,决意于外面包车型客车询问
explain select name from car_info where id in (select id from
web_car_series where id = 5);
+—-+——————–+—————-+——-+—————+———+———+——-+——+-
| id | select_type | table | type | possible_keys | key | key_len |
ref | rows | Extra |
+—-+——————–+—————-+——-+—————+———+———+——-+——+
| 1 | PRIMARY | car_info | index | NULL | name | 768 | NULL | 145 |
Using where; Using index | | 2 | DEPENDENT SUBQUERY | web_car_series |
const | PRIMARY | PRIMARY | 4 | const | 1 | Using index |
+—-+——————–+—————-+——-+—————+———+———+——-+—–

key

key列呈现MySQL实际调节运用的键(索引卡塔尔。若无选拔索引,键是NULL。要想强制MySQL使用或不经意possible_keys列中的索引,在查询中应用FORCE
INDEX、USE INDEX也许IGNORE INDEX。

NULL:
MySQL在优化进程中解释语句,推行时居然毫无访谈表或索引,举例从一个索引列里采用最小值能够通过单独索引查找完结。

(6).  DEPENDENT SUBQUERY

设若该列是NULL,则尚未相关的目录。在这里种景色下,可以通过检查WHERE子句看是或不是它引用有些列或符合索引的列来进步你的询问品质。假若是这样,创立二个适度的目录並且再度用EXPLAIN检查查询
key列
key列突显MySQL实际调整采纳的键(索引)。要想强制MySQL使用或大意possible_keys列中的索引,在询问中央银行使FORCE
INDEX、USE INDEX只怕IGNORE INDEX。
key_len列
key_len列呈现MySQL决定动用的键长度。使用的目录的长度,在不损失准确性的场合下,长度越短越好
rows列 rows列显示MySQL以为它推行查询时必得检查的行数
 mysql相关优化手艺
尽只怕采用数据类型近似的多少列进行比较
使带索引的数据列在可比表达式中独立现身
毫无在like格局的伊始地方运用通配符,那个时候目录无效
尽或者利用数值操作,少使用字符串操作
数据类型合理选拔,尽量”小”,选拔适用于积攒引擎的数目格式
全心全意将数据列注解为NOT NULL
,因为MYSQL不要求在查询管理时期检查数据列值是还是不是为NULL
捏造选取ENUM数据列,ENUM在MYSQL内部被代表为风流倜傥多种数值,管理速度快
使用Procedure analyse()语句
该语句可以将数据列中还行ENUM格局字段列出,procedure
analyse(16,256)语句表示数据列中差别取值抢先15个的可能长度当先257个字节的,不建议ENUM类型的提出
对轻便发生碎片化的数据表举行整合治理,对于可变长度的数据列,随着数据的大气改造大概去除极易产生碎片,因而要求按期optimize
table
尽量制止对BLOB或TEXT值实行索引

possible_keys

显示查询利用了何等索引,表示该索引能够展开火速地查找,不过列出来的目录对于三番五回优化进程也许是平昔不用的

该列完全部独用立于EXPLAIN输出所示的表的程序。那象征在possible_keys中的某个键实际上无法按生成的表次序使用。
假定该列是NULL,则并未有有关的目录。在此种情景下,能够经过检查WHERE子句看是还是不是它引用有个别列或相符索引的列来升高你的询问品质。假使是这么,创立五个老少咸宜的目录况兼再一次用EXPLAIN检查查询

SELECT * FROM ref_table WHERE key_column=expr;

SELECT * FROM ref_table,other_table
 WHERE ref_table.key_column=other_table.column;

SELECT * FROM ref_table,other_table
 WHERE ref_table.key_column_part1=other_table.column
  AND ref_table.key_column_part2=1;

select_type

代表查询的档案的次序

类型 说明
simple 简单子查询,不包含子查询和union
primary 包含union或者子查询,最外层的部分标记为primary
subquery 一般子查询中的子查询被标记为subquery,也就是位于select列表中的查询
derived 派生表——该临时表是从子查询派生出来的,位于form中的子查询
union 位于union中第二个及其以后的子查询被标记为union,第一个就被标记为primary如果是union位于from中则标记为derived
union result 用来从匿名临时表里检索结果的select被标记为union result
dependent union 顾名思义,首先需要满足UNION的条件,及UNION中第二个以及后面的SELECT语句,同时该语句依赖外部的查询
subquery 子查询中第一个SELECT语句
dependent subquery 和DEPENDENT UNION相对UNION一样

(1) SIMPLE(简单SELECT,不应用UNION或子查询等)

+—-+————-+——-+————-+—————————-+—————————-+———+——+——+——————————————————+
| id | select_type | table | type        | possible_keys          
   | key                        | key_len | ref  | rows | Extra       
                                        |
+—-+————-+——-+————-+—————————-+—————————-+———+——+——+——————————————————+
|  1 | SIMPLE      | t4    | index_merge |
idx_t4_id,idx_t4_accountid | idx_t4_id,idx_t4_accountid | 4,4 
   | NULL |    2 | Using union(idx_t4_id,idx_t4_accountid); Using
where |
+—-+————-+——-+————-+—————————-+—————————-+———+——+——+——————————————————+

key_len

key_len列展现MySQL决定接收的键长度。借使键是NULL,则长度为NULL。使用的目录的长短。在不损失正确性的动静下,长度越短越好

三、table

那是const联接类型的三个特例。表唯有一行满足条件.如下(t3表上的id是
primary key)

table

对应行正在访谈哪四个表,表名大概小名

  • 涉嫌优化器会为查询选用事关顺序,左边深度优先
  • 当from中有子查询的时候,表名是derivedN的花样,N指向子查询,也正是explain结果中的下一列
  • 当有union result的时候,表名是union
    1,2等的样式,1,2象征涉足union的query id

瞩目:MySQL对待那几个表和普通表同样,不过那些“偶尔表”是绝非其它索引的。

possible_keys

列出能够运用什么索引来查询,最后会选择三个最优的。假若该列为NULL,则表示从未相关的目录。

const用于用常数值比较PWranglerIMAGL450Y
KEY或UNIQUE索引的具备片段时。在上面包车型客车询问中,tbl_name能够用于const表:

type

type显示的是拜谒类型,是相当重大的贰个目标,结果值从好到坏依次是:
system > const > eq_ref > ref > fulltext > ref_or_null
> index_merge > unique_subquery > index_subquery > range
> index > ALL
,日常的话,得保险查询最少达到range等级,最佳能(CANON卡塔尔落得ref。

类型 说明
All 最坏的情况,全表扫描
index 和全表扫描一样。只是扫描表的时候按照索引次序进行而不是行。主要优点就是避免了排序, 但是开销仍然非常大。如在Extra列看到Using index,说明正在使用覆盖索引,只扫描索引的数据,它比按索引次序全表扫描的开销要小很多
range 范围扫描,一个有限制的索引扫描。key 列显示使用了哪个索引。当使用=、 <>、>、>=、<、<=、IS NULL、<=>、BETWEEN 或者 IN 操作符,用常量比较关键字列时,可以使用 range
ref 一种索引访问,它返回所有匹配某个单个值的行。此类索引访问只有当使用非唯一性索引或唯一性索引非唯一性前缀时才会发生。这个类型跟eq_ref不同的是,它用在关联操作只使用了索引的最左前缀,或者索引不是UNIQUE和PRIMARY KEY。ref可以用于使用=或<=>操作符的带索引的列。
eq_ref 最多只返回一条符合条件的记录。使用唯一性索引或主键查找时会发生 (高效)
const 当确定最多只会有一行匹配的时候,MySQL优化器会在查询前读取它而且只读取一次,因此非常快。当主键放入where子句时,mysql把这个查询转为一个常量(高效)
system 这是const连接类型的一种特例,表仅有一行满足条件。
Null 意味说mysql能在优化阶段分解查询语句,在执行阶段甚至用不到访问表或索引(高效)

table

询问利用到的表名,有三种相当情况:

  • <unionM,N> The row refers to the union of the rows with id
    values of M and N.
  • <derivedN> The row refers to the derived table result for the
    row with an id value of N. A derived table may result, for example,
    from a subquery in the FROM clause.
  • <subqueryN> The row refers to the result of a materialized
    subquery for the row with an id value of N

1.id

Extra

列出了MySQL查询的详细新闻,有很各个音信,如下

  • const row not found
  • Deleting all rows
  • Distinct
  • FirstMatch(tbl_name)
  • Full scan on NULL key
  • Impossible HAVING
  • Impossible WHERE
  • Impossible WHERE noticed after reading const tables
  • Using filesort
  • Using index
  • Using index condition
  • Using index for group-by
  • Using temporary
  • Using where
  • Zero limit

那列很要紧,显示了连接使用了哪连串型,有无使用索引.

 

(10).index

possible_keys

来得查询利用了什么样索引,表示该索引能够开展高效地搜寻,可是列出来的目录对于继续优化进程大概是未曾用的

一.语法

MySQL
EXPLAIN命令是询问质量优化不可缺点和失误的少年老成有的,该文首要疏解explain命令的利用及有关参数表达。

value IN (SELECT key_column FROM
single_table WHERE some_expr)

图片 2

(4).UNION RESULT

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)

该项目替换了上边情势的IN子查询的ref:

原文:

子查询中的第贰个SELECT,决意于外面包车型客车询问

rows

rows列显示MySQL感觉它实践查询时必得检查的行数。注意那是叁个预估价。

在底下的事例中,MySQL能够行使ref_or_null联接来管理ref_tables:

一、 id

mysql> explain select * from (select *
from ( select * from t3 where id=3952602) a) b;

 表示MySQL依照表总括新闻及索引选择意况,估算的找到所需的记录所急需读取的行数

eq_ref能够用来选用=
操作符相比较的带索引的列。相比较值可感觉常量或三个应用在该表后面所读取的表的列的表明式。

      示查询中每一种select子句的连串**

  1. Extra

Using filesort:MySQL中不恐怕接收索引完结的排序操作称为“文件排序”

(6). index_merge

(3) UNION(UNION中的第叁个或后边的SELECT语句)

例如: explain select * from t3 where id=3952602;

select_type

可以清楚为select查询类型,对于索引优化未有主要的意思,简介一下,有以下结果:

Value 含义 Meaning
SIMPLE 简单的查询(没有使用Union 或 子查询) Simple SELECT (not using UNION or subqueries)
PRIMARY 最外层的查询 Outermost SELECT
UNION Union查询中的地二个,或第三、第四… Second or later SELECT statement in a UNION
DEPENDENT UNION Union的结果被外层查询依赖 Second or later SELECT statement in a UNION, dependent on outer query
UNION RESULT 合并结果 Result of a UNION.
SUBQUERY 子查询 First SELECT in subquery
DEPENDENT SUBQUERY 子查询的结果被外层查询依赖 First SELECT in subquery, dependent on outer query
DERIVED   Derived table SELECT (subquery in FROM clause)
MATERIALIZED   Materialized subquery
UNCACHEABLE SUBQUERY   A subquery for which the result cannot be cached and must be re-evaluated for each row of the outer query
UNCACHEABLE UNION   The second or later select in a UNION that belongs to an uncacheable subquery (see UNCACHEABLE SUBQUERY)
  • SIMPLE 简单的询问,未有使用Union或子查询,比如:
    1. mysql> explain select * from index_test where id=1;
    2. +----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    5. | 1 | SIMPLE | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    6. +----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
  • PRIMARY Union查询中的最外层的查询,举例:

    1. mysql> explain select * from index_test where id=1 union select * from index_test where id=2;
    2. +----+--------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+--------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
    5. | 1 | PRIMARY | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    6. | 2 | UNION | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    7. | NULL | UNION RESULT | <union1,2> | NULL | ALL | NULL | NULL | NULL | NULL | NULL | NULL | Using temporary |
    8. +----+--------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
  • UNION Union查询中的第二个或之后的查询,举个例子:

    1. mysql> explain select * from index_test where id=1 union select * from index_test where id=2 union select * from index_test where id=2;
    2. +----+--------------+--------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+--------------+--------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
    5. | 1 | PRIMARY | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    6. | 2 | UNION | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    7. | 3 | UNION | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    8. | NULL | UNION RESULT | <union1,2,3> | NULL | ALL | NULL | NULL | NULL | NULL | NULL | NULL | Using temporary |
    9. +----+--------------+--------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
  • DEPENDENT UNION 相像于UNION,只是它的结果被外层查询依赖,举例:

    1. mysql> explain select * from index_test where id in (select aid from index_relation where id=1 union select aid from index_relation where id=2);
    2. +----+--------------------+----------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+--------------------+----------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
    5. | 1 | PRIMARY | index_test | NULL | ALL | NULL | NULL | NULL | NULL | 5 | 100.00 | Using where |
    6. | 2 | DEPENDENT SUBQUERY | index_relation | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    7. | 3 | DEPENDENT UNION | index_relation | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    8. | NULL | UNION RESULT | <union2,3> | NULL | ALL | NULL | NULL | NULL | NULL | NULL | NULL | Using temporary |
    9. +----+--------------------+----------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
  • UNION RESULT 合併多行的结果,举例 UNION 中的例子。
  • SUBQUERY 子查询,例如:

    1. mysql> explain select * from index_test where id = (select aid from index_relation where id=(select 1));
    2. +----+-------------+----------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+----------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
    5. | 1 | PRIMARY | index_test | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    6. | 2 | SUBQUERY | index_relation | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL |
    7. +----+-------------+----------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
  • DEPENDENT
    SUBQUERY
     不相同于SUBQUE福特ExplorerY的是,查询结果被外层信任。举个例子DEPENDENT
    UNION中的例子。

  • DERIVED 子查询的结果作为外层查询的源头,比方:
    1. mysql> explain select * from (select 1) as a;
    2. +----+-------------+------------+------------+--------+---------------+------+---------+------+------+----------+----------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+--------+---------------+------+---------+------+------+----------+----------------+
    5. | 1 | PRIMARY | <derived2> | NULL | system | NULL | NULL | NULL | NULL | 1 | 100.00 | NULL |
    6. | 2 | DERIVED | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | No tables used |
    7. +----+-------------+------------+------------+--------+---------------+------+---------+------+------+----------+----------------+

从最好到最差的连接类型为const、eq_reg、ref、range、indexhe和ALL

七、key_len

例如:

来得那大器晚成行的数目是关于哪张表的,一时不是真性的表名字,看见的是derivedx(x是个数字,作者的明白是第几步实施的结果)

4.type

六、Key

mysql> explain select * from t3 where
id=3952602 union all select * from t3 ;

EXPLAIN 语法

  1. {EXPLAIN | DESCRIBE | DESC}
  2. tbl_name [col_name | wild]
  3. {EXPLAIN | DESCRIBE | DESC}
  4. [explain_type]
  5. {explainable_stmt | FOR CONNECTION connection_id}
  6. explain_type: {
  7. EXTENDED
  8. | PARTITIONS
  9. | FORMAT = format_name
  10. }
  11. format_name: {
  12. TRADITIONAL
  13. | JSON
  14. }
  15. explainable_stmt: {
  16. SELECT statement
  17. | DELETE statement
  18. | INSERT statement
  19. | REPLACE statement
  20. | UPDATE statement
  21. }

UNION的结果。

                

mysql> explain select * from (select * from ( select * from t3
where id=3952602) 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     | t3         | const  | PRIMARY,idx_t3_id | PRIMARY
| 4       |      |    1 |       |
+—-+————-+————+——–+——————-+———+———+——+——+——-+

图片 3

value IN (SELECT primary_key FROM
single_table WHERE some_expr)

key

列出决定利用的目录,倘诺为NULL表示从没采纳索引,能够使用FORCE INDEX、USE
INDEX大概IGNORE INDEX
强制MySQL使用或忽视possible_keys列出的目录,在查。

见状那个的时候,查询就须要优化了。MYSQL须要张开额外的步调来开掘怎么对回到的行排序。它依照连年类型以至存款和储蓄排序键值和相配原则的上上下下行的行指针来排序全体行

(4) DEPENDENT UNION(UNION中的第三个或前面的SELECT语句,决意于外面包车型大巴询问)

1 row in set (0.02 sec)

id

id是用来挨门逐户标志整个查询中SELELCT
语句的,在嵌套查询中id越大的言语越先施行。该值或许为NULL,要是这生机勃勃行用来证明的是别的行的协同结果。

(5).  ref_or_null

(6) SUBQUEKoleosY(子查询中的第三个SELECT)

2 rows in set (0.00 sec)