图片 1

key_len

key_len列显示MySQL决定选用的键长度。如果键是NULL,则长度为NULL。使用的目录的尺寸。在不损失精确性的图景下,长度越短越好

八、ref

eq_ref能够用于采用=
操作符相比的带索引的列。比较值可感到常量或二个利用在该表前边所读取的表的列的表明式。

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一样

     小编的接头是SQL实行的大器晚成风流洒脱的标志,SQL从大到小的实行

mysql> explain select * from t3,t4
where t3.id=t4.accountid;

type

type展现的是寻访类型,是较为首要的八个指标,结果值从好到坏依次是:
system > const > eq_ref > ref > fulltext > ref_or_null
> index_merge > unique_subquery > index_subquery > range
> index > ALL
,平日的话,得保证查询起码到达range等第,最棒能到达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能在优化阶段分解查询语句,在执行阶段甚至用不到访问表或索引(高效)
相关文章:

MySQL高性能表设计规范:http://www.jianshu.com/p/f797bbe11d76
MySQL EXPLAIN详解:http://www.jianshu.com/p/ea3fc71fdc45
MySQL 锁机制 常用知识点:http://www.jianshu.com/p/0d5b7cd592f9

mysql> explain select * from t4 where
id=3952602 or accountid=31754306 ;

key

key列呈现MySQL实际决定使用的键(索引卡塔尔国。若无接纳索引,键是NULL。要想强制MySQL使用或忽略possible_keys列中的索引,在询问中应用FORCE
INDEX、USE INDEX大概IGNORE INDEX。

六、Key

行使了WHERE从句来节制哪些行将与下一张表匹配恐怕是回到给客商。若是不想重返表中的后生可畏体行,况兼连接类型ALL或index,那就能时有发生,只怕是询问有标题

possible_keys

展现查询利用了怎么着索引,表示该索引能够拓宽高效地搜索,不过列出来的目录对于继续优化过程只怕是未曾用的

range:只检索给定范围的行,使用一个索引来选拔行

观察那些的时候,查询需求优化了。这里,MYSQL供给创设一个不时表来囤积结果,那日常发生在对不相同的列集实行OPRADODER
BY上,实际不是GROUP BY上

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

 

来得那黄金年代行的数码是有关哪张表的,有的时候不是真性的表名字,见到的是derivedx(x是个数字,笔者的了然是第几步奉行的结果)

(4).Using filesort

rows

rows列展现MySQL感觉它实行查询时必需检查的行数。注意那是一个预评估价值。

type

链接类型,从最佳到最差的总是类型为system、const、eq_ref、ref、range、indexhe和ALL

  • system 那是const联接类型的二个特例,比很少现身,比如 DERubiconIVED
    中的例子。
  • const 表最多有叁个相配行,用于主键大概独一索引字段的查询,速度一点也不慢,比方:

    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. +----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
  • eq_ref 作者清楚是八个表联接,联接的字段在五个表都以头一无二的,即主键或独一索引,比方:

    1. mysql> explain select index_test.a from index_test,index_one where index_one.id=index_test.id;
    2. +----+-------------+------------+------------+--------+---------------+---------+---------+-------------------------+------+----------+-------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+--------+---------------+---------+---------+-------------------------+------+----------+-------------+
    5. | 1 | SIMPLE | index_one | NULL | index | PRIMARY | PRIMARY | 4 | NULL | 1 | 100.00 | Using index |
    6. | 1 | SIMPLE | index_test | NULL | eq_ref | PRIMARY | PRIMARY | 4 | index_test.index_one.id | 1 | 100.00 | NULL |
    7. +----+-------------+------------+------------+--------+---------------+---------+---------+-------------------------+------+----------+-------------+
  • ref 和eq_ref不一致的是相称多行,使用最多的门类,举例:

    1. mysql> explain select * from index_test,index_relation where index_relation.aid=index_test.id;
    2. +----+-------------+----------------+------------+------+---------------+-----------+---------+--------------------------+------+----------+-------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+----------------+------------+------+---------------+-----------+---------+--------------------------+------+----------+-------------+
    5. | 1 | SIMPLE | index_test | NULL | ALL | PRIMARY | NULL | NULL | NULL | 5 | 100.00 | NULL |
    6. | 1 | SIMPLE | index_relation | NULL | ref | index_aid | index_aid | 5 | index_test.index_test.id | 5 | 100.00 | Using index |
    7. +----+-------------+----------------+------------+------+---------------+-----------+---------+--------------------------+------+----------+-------------+
  • fulltext 全文索引

  • ref_or_null 和ref不相同的是,sql中满含 O奔驰M级 key_column IS NULL。

    1. mysql> explain select index_test.a from index_test where a='abc' or a is null;
    2. +----+-------------+------------+------------+-------------+---------------+-------------+---------+-------+------+----------+--------------------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+-------------+---------------+-------------+---------+-------+------+----------+--------------------------+
    5. | 1 | SIMPLE | index_test | NULL | ref_or_null | Index_a_b_c | Index_a_b_c | 195 | const | 2 | 100.00 | Using where; Using index |
    6. +----+-------------+------------+------------+-------------+---------------+-------------+---------+-------+------+----------+--------------------------+
  • index_merge 表示使用了目录归并优化措施,key列富含了动用的目录的清单,举例:

    1. mysql> explain select * from index_test where a='abc' or 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 | index_merge | PRIMARY,Index_a_b_c | Index_a_b_c,PRIMARY | 195,4 | NULL | 2 | 100.00 | Using sort_union(Index_a_b_c,PRIMARY); Using where |
    6. +----+-------------+------------+------------+-------------+---------------------+---------------------+---------+------+------+----------+----------------------------------------------------+
  • unique_subquery
  • index_subquery
  • range 只检索给定范围的行,key列展现采取了哪个索引,当使用=、<>、>、>=、<、<=、IS
    NULL、<=>、BETWEEN只怕IN操作符,用常量相比较主要字列时,可以行使range

    1. mysql> explain select * from index_test where id > 5;
    2. +----+-------------+------------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
    5. | 1 | SIMPLE | index_test | NULL | range | PRIMARY | PRIMARY | 4 | NULL | 1 | 100.00 | Using where |
    6. +----+-------------+------------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
  • index 遇ALL区别的是,它只扫描了索引树。因为索引文件平时比数据文件小。所以比ALL快。举个例子:
    1. mysql> explain select a from index_test where c = 'abc';
    2. +----+-------------+------------+------------+-------+---------------+-------------+---------+------+------+----------+--------------------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+-------+---------------+-------------+---------+------+------+----------+--------------------------+
    5. | 1 | SIMPLE | index_test | NULL | index | NULL | Index_a_b_c | 588 | NULL | 6 | 16.67 | Using where; Using index |
    6. +----+-------------+------------+------------+-------+---------------+-------------+---------+------+------+----------+--------------------------+
  • ALL 全表扫描
    1. mysql> explain select e from index_test where c = 'abc';
    2. +----+-------------+------------+------------+------+---------------+------+---------+------+------+----------+-------------+
    3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
    4. +----+-------------+------------+------------+------+---------------+------+---------+------+------+----------+-------------+
    5. | 1 | SIMPLE | index_test | NULL | ALL | NULL | NULL | NULL | NULL | 6 | 16.67 | Using where |
    6. +----+-------------+------------+------------+------+---------------+------+---------+------+------+----------+-------------+

(6). index_merge

ref

ref列呈现选用哪个列或常数与key一齐从表中甄选行。

图片 2

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

MySQL
EXPLAIN命令是询问质量优化不可缺点和失误的豆蔻梢头有个别,该文主要讲授explain命令的运用及有关参数表明。

只要未有选取索引,键是NULL。要想强制MySQL使用或忽视possible_keys列中的索引,在查询中央银行使FORCE
INDEX、USE INDEX恐怕IGNORE INDEX。

possible_keys列提议MySQL能使用哪个索引在该表中找到行。注意,该列完全部独用立于EXPLAIN输出所示的表的程序。这表示在possible_keys中的有个别键实际上不能按生成的表次序使用。

table

对应行正在访谈哪多少个表,表名或然别称

  • 涉嫌优化器会为查询接受涉及顺序,左边深度优先
  • 当from中有子查询的时候,表名是derivedN的款型,N指向子查询,也正是explain结果中的下一列
  • 当有union result的时候,表名是union
    1,2等的款型,1,2意味着涉足union的query id

注意:MySQL看待那几个表和普通表同样,不过那些“不时表”是不曾经担负何索引的。

三、table

(3).Range checked for each

id

id是用来挨门逐户标志整个查询中SELELCT
语句的,在嵌套查询中id越大的说话越西施行。该值也许为NULL,要是那生龙活虎行用来证实的是别的行的同台结果。

代表上述表的连接相称原则,即什么列或常量被用于查找索引列上的值

感激阅读,希望能协助到大家,谢谢我们对本站的支撑!

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等

(5) UNION RESULT(UNION的结果)

就不再找寻了

         

差不离SELECT(不采纳UNION或子查询等) 比如:

(1) SIMPLE(轻巧SELECT,不选拔UNION或子查询等)

(1).Distinct

 

(6).Using temporary

id

query中select查询的队列号,即便为union查询的话,最后后生可畏行Union结果的id为null。其余还被用来
table 字段中意味合併行的上马三保终结行的id,举例table =
<unionM,N>,表示归拢id从M到N行的结果。

  1. mysql> explain select * from index_test where a='asf' union select * from index_test where a='dfe';
  2. +----+--------------+------------+------------+------+---------------+-------------+---------+-------+------+----------+-----------------+
  3. | id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
  4. +----+--------------+------------+------------+------+---------------+-------------+---------+-------+------+----------+-----------------+
  5. | 1 | PRIMARY | index_test | NULL | ref | Index_a_b_c | Index_a_b_c | 195 | const | 1 | 100.00 | NULL |
  6. | 2 | UNION | index_test | NULL | ref | Index_a_b_c | Index_a_b_c | 195 | const | 1 | 100.00 | NULL |
  7. | NULL | UNION RESULT | <union1,2> | NULL | ALL | NULL | NULL | NULL | NULL | NULL | NULL | Using temporary |
  8. +----+--------------+------------+------------+------+---------------+-------------+---------+-------+------+----------+-----------------+
  9. 3 rows in set, 1 warning (0.01 sec)

(2).Not exists

          

  1. ref

id

id是用来挨门挨户标记整个查询中SELELCT
语句的,在嵌套查询中id越大的说话越西施行。该值只怕为NULL,假若那后生可畏行用来评释的是其余行的同步结果。

+—-+————-+——-+——-+——————-+———+———+——-+——+————-+
| id | select_type | table | type  | possible_keys     | key     |
key_len | ref   | rows | Extra       |
+—-+————-+——-+——-+——————-+———+———+——-+——+————-+
|  1 | PRIMARY     | t3    | const | PRIMARY,idx_t3_id | PRIMARY | 4 
     | const |    1 |             |
|  2 | SUBQUERY    | t3    | const | PRIMARY,idx_t3_id | PRIMARY | 4 
     |       |    1 | Using index |
+—-+————-+——-+——-+——————-+———+———+——-+——+————-+

七、key_len

+—-+————–+————+——-+——————-+———+———+——-+——+——-+
| id | select_type  | table      | type  | possible_keys     | key 
   | key_len | ref   | rows | Extra |
+—-+————–+————+——-+——————-+———+———+——-+——+——-+
|  1 | PRIMARY      | t3         | const | PRIMARY,idx_t3_id | PRIMARY
| 4       | const |    1 |       |
|  2 | UNION        | t3         | ALL   | NULL              | NULL    |
NULL    | NULL  | 1000 |       |
|NULL | UNION RESULT | <union1,2> | ALL   | NULL              |
NULL    | NULL    | NULL  | NULL |       |
+—-+————–+————+——-+——————-+———+———+——-+——+——-+

 

MYSQL优化了LEFT JOIN,生机勃勃旦它找到了相配LEFT JOIN典型的行,

提议MySQL能运用哪个索引在表中找到记录,查询涉及到的字段上若存在索引,则该索引将被列出,但不必然被询问利用

该类型替换了下边格局的IN子查询的ref:

(4) DEPENDENT UNION(UNION中的首个或前面包车型客车SELECT语句,决计于外面包车型客车查询)

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

 

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

该列完全部独用立于EXPLAIN输出所示的表的主次。那象征在possible_keys中的有些键实际上不能够按生成的表次序使用。
假使该列是NULL,则从未有关的目录。在此种情形下,能够透过检查WHERE子句看是还是不是它援引有个别列或切合索引的列来升高你的查询质量。假诺是这么,创设一个合适的目录而且再一次用EXPLAIN检查查询

value IN (SELECT primary_key FROM
single_table WHERE some_expr)

四、type

(7). unique_subquery

(7) DEPENDENT SUBQUEENCOREY(子查询中的第一个SELECT,决议于外面的查询)

+—-+————–+————+——-+——————-+———+———+——-+——+——-+
| id | select_type  | table      | type  | possible_keys     | key 
   | key_len | ref   | rows | Extra |
+—-+————–+————+——-+——————-+———+———+——-+——+——-+
|  1 | PRIMARY      | t3         | const | PRIMARY,idx_t3_id | PRIMARY
| 4       | const |    1 |       |
|  2 | UNION        | t3         | ALL   | NULL              | NULL    |
NULL    | NULL  | 1000 |       |
|NULL | UNION RESULT | <union1,2> | ALL   | NULL              |
NULL    | NULL    | NULL  | NULL |       |
+—-+————–+————+——-+——————-+———+———+——-+——+——-+

3.id大器晚成旦生机勃勃致,能够感到是风姿洒脱组,从上往下各种实施;在有着组中,id值越大,优先级越高,越先实施

+—-+————-+——-+——+——————-+———–+———+———————-+——+——-+
| id | select_type | table | type | possible_keys     | key       |
key_len | ref                  | rows | Extra |
+—-+————-+——-+——+——————-+———–+———+———————-+——+——-+
|  1 | SIMPLE      | t4    | ALL  | NULL              | NULL      |
NULL    | NULL                 | 1000 |       |
|  1 | SIMPLE      | t3    | ref  | PRIMARY,idx_t3_id | idx_t3_id |
4       | dbatest.t4.accountid |    1 |       |
+—-+————-+——-+——+——————-+———–+———+———————-+——+——-+

在寻常职业中,大家会有的时候会开慢查询去记录一些试行时间比较久的SQL语句,找出这几个SQL语句并不意味完事了,些时大家平常用到explain那一个命令来查看叁个这一个SQL语句的实践安排,查看该SQL语句有未有选择上了目录,有未有做全表扫描,那都足以通过explain命令来查阅。所以我们深入精通MySQL的依照费用的优化器,还可以够获得众多可能被优化器构思到的拜候计谋的内部情形,以致当运转SQL语句时哪一类政策臆度会被优化器选用。(QEP:sql生成三个实施布署query
Execution plan卡塔尔国

key列展现MySQL实际决定选拔的键(索引卡塔 尔(英语:State of Qatar)。若无选取索引,键是NULL。要想强制MySQL使用或忽视possible_keys列中的索引,在询问中应用FORCE
INDEX、USE INDEX或许IGNORE INDEX。

总结:

EXPLAIN不会告知您至于触发器、存款和储蓄进程的消息或客商自定义函数对查询的影响事态
• EXPLAIN不思虑各类Cache
• EXPLAIN不可能显示MySQL在进行查询时所作的优化办事
• 部分总结音信是推断的,并不是正确值
• EXPALIN只可以表达SELECT操作,别的操作要重写为SELECT后翻看施行布置。

+—-+——————–+————+——–+——————-+———+———+——-+——+————————–+
| 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 |                          |
+—-+——————–+————+——–+——————-+———+———+——-+——+————————–+

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询问中的第4个或今后的查询,举例:

    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
     不相同于SUBQUERubiconY的是,查询结果被外层看重。比如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. +----+-------------+------------+------------+--------+---------------+------+---------+------+------+----------+----------------+

(2). PRIMARY

key列呈现MySQL实际决定选拔的键(索引卡塔尔

该联接类型相同于unique_subquery。能够替换IN子查询,但只相符下列方式的子查询中的非独一索引:

Using
where:列数据是从仅仅使用了目录中的新闻而并未读取实际的行动的表重临的,这产生在对表的满贯的央求列都以同二个目录的部分的时候,表示mysql服务器就要仓库储存引擎检索行后再展开过滤

1 row in set (0.02 sec)

(2) P途观IMAMuranoY(查询中若包蕴其余目迷五色的子部分,最外层的select被标志为P君越IMACRUISERY)

表最多有一个相配行,它就要询问开首时被读取。因为只有意气风发行,在此行的列值可被优化器剩余部分认为是常数。const表相当的慢,因为它们只读取二遍!

rows

MySQL感觉必需检查的用来回到央浼数据的行数,约小越快;InnoDB
存款和储蓄引擎这一个值是一个差不离值。

例如:

 

unique_subquery是几个目录查找函数,能够完全替换子查询,效用更加高。

 

例如

图片 3

+—-+————-+——-+——-+——————-+———+———+——-+——+——-+
| id | select_type | table | type  | possible_keys     | key     |
key_len | ref   | rows | Extra |
+—-+————-+——-+——-+——————-+———+———+——-+——+——-+
|  1 | SIMPLE      | t3    | const | PRIMARY,idx_t3_id | PRIMARY | 4 
     | const |    1 |       |
+—-+————-+——-+——-+——————-+———+———+——-+——+——-+

MySQL
EXPLAIN命令是询问质量优化不可缺点和失误的黄金年代某个,该文重要批注explain命令的行使及连锁参数表达。

有的时候不是忠实的表名字,见到的是derivedx(x是个数字,作者的精晓是第几步推行的结果)

 

一.语法

Impossible where:这么些值重申了where语句会导致未有相符条件的行。

+—-+————-+——-+————-+—————————-+—————————-+———+——+——+——————————————————+
| 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 |
+—-+————-+——-+————-+—————————-+—————————-+———+——+——+——————————————————+

图片 4

(4).DEPENDENT UNION

key

列出决定使用的目录,如果为NULL表示并没有行使索引,能够行使FORCE INDEX、USE
INDEX可能IGNORE INDEX
强制MySQL使用或忽视possible_keys列出的目录,在查。

二.explain输出解释

index: Full Index Scan,index与ALL差别为index类型只遍历索引树

UNION中的第一个或前边的SELECT语句,决议于外面包车型客车询问

不损失准确性的情景下,长度越短越好 

观察这几个的时候,查询就需求优化了。MYSQL必要举办额外的步子来开采什么对回到的行排序。它依照连年类型以至存款和储蓄排序键值和相配原则的整个行的行指针来排序全体行

 

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 |       |
+—-+————-+————+——–+——————-+———+———+——+——+——-+

图片 5

UNION的结果。

key

key列突显MySQL实际调控选取的键(索引卡塔 尔(英语:State of Qatar)。如果未有接纳索引,键是NULL。要想强制MySQL使用或忽视possible_keys列中的索引,在询问中动用FORCE
INDEX、USE INDEX恐怕IGNORE INDEX。

(5).SUBQUERY

admin

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注