Extra（5）—mysql执行计划（五十一)

最新推荐文章于 2022-06-29 10:33:55 发布
最新推荐文章于 2022-06-29 10:33:55 发布
阅读量161 收藏
点赞数
分类专栏： mysql进阶 文章标签： mysql sql 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ke1ying/article/details/120475131
版权

前面说了有type,simple表示普通查询或者连接查询，primary代表union最左边的select，union result代表union查询的临时表去重，所以union all没有去重功能，subquery代表in的子查询物化表的情况下才会出现，dependent subquery代表相关子查询，dependent union代表相关union查询，还有driverd子查询，from后面的，也需要物化，还有物化后转连接查询，这些都能看到mysql优化器是采用哪种查询方式。

Id代表select，几个select就有几个查询，如果转链接了，就只有一个id。

Type代表存储引擎查询的方式，system代表精确查询并且只有一条记录，const，唯一索引或者主键，ref，二级索引查询，ref_or_null，range，index代表联合索引但没有触发，range和ref，最后还要all。

Possible key代表可能用到的索引。

Key实际用到的索引。

Ref代表后面的过滤条件可能用到的方式，他可能是个函数，也可能是驱动表的参数。

Rows代表查询的数据，全表代表所有，索引则代表所有满足的数据。

Filtered代表数据多少满足，和rows组合可以算出去驱动表的扇出值。

key&key_len&ref&filtered（4）—mysql执行计划（五十)

Extra

顾名思义，这列就存储的是额外信息，我们可以通过额外信息准确理解mysql到底执行查询语句。

mysql> EXPLAIN SELECT 1;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra          |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------+
|  1 | SIMPLE      | NULL  | NULL       | NULL | NULL          | NULL | NULL    | NULL | NULL |     NULL | No tables used |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------+
1 row in set, 1 warning (0.00 sec)

//当我们的sql语句没有表时候，extra显示的是no tables used。

mysql> EXPLAIN SELECT * FROM s1 WHERE 1 != 1;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+------------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra            |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+------------------+
|  1 | SIMPLE      | NULL  | NULL       | NULL | NULL          | NULL | NULL    | NULL | NULL |     NULL | Impossible WHERE |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+------------------+
1 row in set, 1 warning (0.01 sec)

//当过滤条件后面永远显示false，就会出现Impossible where

mysql> EXPLAIN SELECT MIN(key1) FROM s1 WHERE key1 = 'abcdefg';
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                   |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------------------+
|  1 | SIMPLE      | NULL  | NULL       | NULL | NULL          | NULL | NULL    | NULL | NULL |     NULL | No matching min/max row |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------------------+
1 row in set, 1 warning (0.00 sec)

//当查询列表有max或者min，但没有查到数据时候，会显示：no matching min/max row


mysql> EXPLAIN SELECT key1 FROM s1 WHERE key1 = 'a';
+----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key      | key_len | ref   | rows | filtered | Extra       |
+----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------------+
|  1 | SIMPLE      | s1    | NULL       | ref  | idx_key1      | idx_key1 | 303     | const |    8 |   100.00 | Using index |
+----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)

//当我们在使用索引覆盖的情况下，当我们只需要用到索引，而不需要回表操作，则显示 using index。

SELECT * FROM s1 WHERE key1 > 'z' AND key1 LIKE '%a';

mysql> EXPLAIN SELECT * FROM s1 WHERE key1 > 'z' AND key1 LIKE '%b';
  +----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-----------------------+
  | id | select_type | table | partitions | type  | possible_keys | key      | key_len | ref  | rows | filtered | Extra                 |
  +----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-----------------------+
  |  1 | SIMPLE      | s1    | NULL       | range | idx_key1      | idx_key1 | 303     | NULL |  266 |   100.00 | Using index condition |
  +----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-----------------------+
  1 row in set, 1 warning (0.01 sec)

//有些虽然用了索引列，但不能使用到索引
//其中key1>'z'可以使用到索引，但后面的like不可以使用索引，
//传统访问应该先索引在索引b+树查询满足z的条件，然后数据回表查询过滤满足like '%a'的数据。
//但其实可以在索引b+树查询满足z的条件后，继续在b+树过滤索引满足key1 like '%a'的索引，因为key1
//也在索引b+树，这样就减少回表的开销。而且因为回表是随机I/O,这边是顺序I/O，效率也会快很多。
//mysql吧这种就称呼 索引条件下推，using index condition

mysql> EXPLAIN SELECT * FROM s1 WHERE common_field = 'a';
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra       |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9688 |    10.00 | Using where |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.01 sec)

//当我们全表扫描的时候，显示的是using where

mysql> EXPLAIN SELECT * FROM s1 WHERE key1 = 'a' AND common_field = 'a';
+----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key      | key_len | ref   | rows | filtered | Extra       |
+----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------------+
|  1 | SIMPLE      | s1    | NULL       | ref  | idx_key1      | idx_key1 | 303     | const |    8 |    10.00 | Using where |
+----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)

//当我们使用索引访问，但还有其他搜索条件还有common_Filed所以还是显示suing where

mysql> EXPLAIN SELECT * FROM s1 INNER JOIN s2 ON s1.common_field = s2.common_field;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------------------------------------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                                              |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------------------------------------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9688 |   100.00 | NULL                                               |
|  1 | SIMPLE      | s2    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9954 |    10.00 | Using where; Using join buffer (Block Nested Loop) |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------------------------------------------+
2 rows in set, 1 warning (0.03 sec)

//前面说过基于块的嵌套法，当被驱动表不能通过索引访问，这时候会有一个join buffer，来加快查询的速度，因为这个太多的话
//内存里不够存放足够多的数据，只能不断通过驱动表查询的结果，一条条从磁盘访问驱动表，
//这时候就把被驱动表的数据放在join buffer里，直接在内存中处理是否满足，就不需要每次都从磁盘查询数据。
//所以上面可以看到，因为不能使用索引扫描，所以退而求其次，用join buffer，
//又因为s2.common_field = 常数，所以这里又有一个using where

mysql> EXPLAIN SELECT * FROM s1 LEFT JOIN s2 ON s1.key1 = s2.key1 WHERE s2.id IS NULL;
+----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+-------------------------+
| id | select_type | table | partitions | type | possible_keys | key      | key_len | ref               | rows | filtered | Extra                   |
+----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+-------------------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL     | NULL    | NULL              | 9688 |   100.00 | NULL                    |
|  1 | SIMPLE      | s2    | NULL       | ref  | idx_key1      | idx_key1 | 303     | xiaohaizi.s1.key1 |    1 |    10.00 | Using where; Not exists |
+----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+-------------------------+
2 rows in set, 1 warning (0.00 sec)

//当我们在外连接，如果where条件包含被驱动表某个列等于null，但当前列有不允许为null，这时候就会显示not exists

mysql> EXPLAIN SELECT * FROM s1 WHERE key1 = 'a' AND key3 = 'a';
+----+-------------+-------+------------+-------------+-------------------+-------------------+---------+------+------+----------+-------------------------------------------------+
| id | select_type | table | partitions | type        | possible_keys     | key               | key_len | ref  | rows | filtered | Extra                                           |
+----+-------------+-------+------------+-------------+-------------------+-------------------+---------+------+------+----------+-------------------------------------------------+
|  1 | SIMPLE      | s1    | NULL       | index_merge | idx_key1,idx_key3 | idx_key3,idx_key1 | 303,303 | NULL |    1 |   100.00 | Using intersect(idx_key3,idx_key1); Using where |
+----+-------------+-------+------------+-------------+-------------------+-------------------+---------+------+------+----------+-------------------------------------------------+
1 row in set, 1 warning (0.01 sec)

//前面说过如果单独的索引，会使用合并索引，上面就显示用的using_intersect(idx_key3,idx_key1)
//如果是union则就用的是using_union合并

mysql> EXPLAIN SELECT * FROM s1 LIMIT 0;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra      |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+------------+
|  1 | SIMPLE      | NULL  | NULL       | NULL | NULL          | NULL | NULL    | NULL | NULL |     NULL | Zero limit |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+------------+
1 row in set, 1 warning (0.00 sec)

//如果分页是0，则直接会显示zero limit

mysql> EXPLAIN SELECT * FROM s1 ORDER BY key1 LIMIT 10;
+----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-------+
| id | select_type | table | partitions | type  | possible_keys | key      | key_len | ref  | rows | filtered | Extra |
+----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-------+
|  1 | SIMPLE      | s1    | NULL       | index | NULL          | idx_key1 | 303     | NULL |   10 |   100.00 | NULL  |
+----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-------+
1 row in set, 1 warning (0.03 sec

mysql> EXPLAIN SELECT * FROM s1 ORDER BY common_field LIMIT 10;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra          |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9688 |   100.00 | Using filesort |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+----------------+
1 row in set, 1 warning (0.00 sec)

//前面那个显示的null，对索引进行排序了
//但有些时候无法使用索引排序，这时候就需要从磁盘排序或者内存排序，这些都叫file sort
//如果用文件排序则就会显示using filesort

mysql> EXPLAIN SELECT DISTINCT common_field FROM s1;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-----------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra           |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-----------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9688 |   100.00 | Using temporary |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-----------------+
1 row in set, 1 warning (0.00 sec)

//有的时候mysql会使用临时表进行去重或者排序，比如我们在distinct，group by，union等子句的查询过程，
//这时候如果不能利用索引查询，这时候会建立内部临时表，这时候就会显示 Using temporary

mysql> EXPLAIN SELECT common_field, COUNT(*) AS amount FROM s1 GROUP BY common_field;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra                           |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9688 |   100.00 | Using temporary; Using filesort |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> EXPLAIN SELECT common_field, COUNT(*) AS amount FROM s1 GROUP BY common_field ORDER BY NULL;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-----------------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra           |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-----------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | NULL          | NULL | NULL    | NULL | 9688 |   100.00 | Using temporary |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-----------------+
1 row in set, 1 warning (0.00 sec)


EXPLAIN SELECT common_field, COUNT(*) AS amount FROM s1 GROUP BY common_field ORDER BY common_field;


//上面的显示不光有using temporary 还有using filesort，也就是说不光临时表，还排序了。
//这是因为mysql默认在group by之后默认会order by,不想排序必须显示写 order by null

mysql> EXPLAIN SELECT key1, COUNT(*) AS amount FROM s1 GROUP BY key1;
+----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type  | possible_keys | key      | key_len | ref  | rows | filtered | Extra       |
+----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | s1    | NULL       | index | idx_key1      | idx_key1 | 303     | NULL | 9688 |   100.00 | Using index |
+----+-------------+-------+------------+-------+---------------+----------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.00 sec)

//另外建立临时表代价很大，能用索引 就用索引，如果用到索引group by 就会显示using index，并且索引是排序好的。


mysql> EXPLAIN SELECT * FROM s1 WHERE key1 IN (SELECT key3 FROM s2 WHERE common_field = 'a');
+----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+------------------------------+
| id | select_type | table | partitions | type | possible_keys | key      | key_len | ref               | rows | filtered | Extra                        |
+----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+------------------------------+
|  1 | SIMPLE      | s2    | NULL       | ALL  | idx_key3      | NULL     | NULL    | NULL              | 9954 |    10.00 | Using where; Start temporary |
|  1 | SIMPLE      | s1    | NULL       | ref  | idx_key1      | idx_key1 | 303     | xiaohaizi.s2.key3 |    1 |   100.00 | End temporary                |
+----+-------------+-------+------------+------+---------------+----------+---------+-------------------+------+----------+------------------------------+
2 rows in set, 1 warning (0.00 sec)

//当我们查询优化器吧子查询in转为semi-join的时候，有很多执行策略，其实一种也是建立临时表实现为外层查询进去重操作
//这时候驱动表start temporary 被驱动表将会显示end temporary

mysql> EXPLAIN SELECT * FROM s1 WHERE key3 IN (SELECT key1 FROM s2 WHERE key1 > 'z');
+----+-------------+-------+------------+-------+---------------+----------+---------+-------------------+------+----------+-------------------------------------+
| id | select_type | table | partitions | type  | possible_keys | key      | key_len | ref               | rows | filtered | Extra                               |
+----+-------------+-------+------------+-------+---------------+----------+---------+-------------------+------+----------+-------------------------------------+
|  1 | SIMPLE      | s2    | NULL       | range | idx_key1      | idx_key1 | 303     | NULL              |  270 |   100.00 | Using where; Using index; LooseScan |
|  1 | SIMPLE      | s1    | NULL       | ref   | idx_key3      | idx_key3 | 303     | xiaohaizi.s2.key1 |    1 |   100.00 | NULL                                |
+----+-------------+-------+------------+-------+---------------+----------+---------+-------------------+------+----------+-------------------------------------+
2 rows in set, 1 warning (0.01 sec)

//内连接还会显示looseScan

mysql> EXPLAIN SELECT * FROM s1 WHERE common_field IN (SELECT key1 FROM s2 where s1.key3 = s2.key3);
+----+-------------+-------+------------+------+-------------------+----------+---------+-------------------+------+----------+-----------------------------+
| id | select_type | table | partitions | type | possible_keys     | key      | key_len | ref               | rows | filtered | Extra                       |
+----+-------------+-------+------------+------+-------------------+----------+---------+-------------------+------+----------+-----------------------------+
|  1 | SIMPLE      | s1    | NULL       | ALL  | idx_key3          | NULL     | NULL    | NULL              | 9688 |   100.00 | Using where                 |
|  1 | SIMPLE      | s2    | NULL       | ref  | idx_key1,idx_key3 | idx_key3 | 303     | xiaohaizi.s1.key3 |    1 |     4.87 | Using where; FirstMatch(s1) |
+----+-------------+-------+------------+------+-------------------+----------+---------+-------------------+------+----------+-----------------------------+
2 rows in set, 2 warnings (0.00 sec)

//内连接还会显示firstMatch

后端从入门到精通
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MySQL，通过explain分析低效SQL的执行计划。
12-14
目录 结果列说明： select_type：SELECT、SIMPLE（简单表，即不使用表连接和子查询）、PRIMARY（主查询，即外层的查询）、UNION（union...Extra：执行情况的说明和描述。  执行SQL： EXPLAIN select * from bs_demo
Mysql 查询优化 - Explain 详解（下）
半夏_2021的博客
06-29 360
Mysql查询优化-Explain详解
Mysql专题六：Mysql常见的优化手段和Explain关键字
严老板的技术梦想博客
01-17 840
explain select * from t1 join t2; 一、性能按type排序 system > const > eq_ref > ref > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL 二、性能按Ext...
Mysql查询优化 -Explain 详解（上）
半夏_2021的博客
06-29 190
Mysql查询优化 -Explain 详解（上）
MySQL Explain 执行计划详细信息
011eH
02-10 723
15 Explain 表结构 -- auto-generated definition create table single_table ( id int auto_increment primary key, key1 varchar(100) null, key2 int null, key3 varchar(100) null, key_part1 varchar(10
mysql子查询从句_MySQL的子查询及相关优化学习教程
weixin_35801828的博客
01-28 186
一、子查询1、where型子查询(把内层查询结果当作外层查询的比较条件)#不用order by 来查询最新的商品select goods_id,goods_name from goods where goods_id = (select max(goods_id) from goods);#取出每个栏目下最新的产品(goods_id唯一)select cat_id,goods_id,goods_n...
#+Mysql执行计划-Extra列解析.pdf
03-10
#+Mysql执行计划-Extra列解析.pdf
Django执行源生mysql语句实现过程解析
01-19
　解释：结果集修改器，一种提供额外查询参数的机制 　说明：依赖model模型 使用方式： 　用在where后: 　Book.objects.filter(publisher_id=1).extra(where=[title='python\u5b66\u4e601'])　 　用在select后　 　...
Mysql Explain 详细介绍
01-21
Mysql Explain 这里做一个资料的全面整理。 一.语法 explain 例如: explain select * from t3 where id=3952602; 二.explain输出解释 +—-+————-+——-+——-+——————-+———+———+——-+——+——...
Mysql覆盖索引详解
12-16
使用explain，可以通过输出的extra列来判断，对于一个索引覆盖查询，显示为using index,MySQL查询优化器在执行查询前会决定是否有索引覆盖查询 注意 1、覆盖索引也并不适用于任意的索引类型，索引必须存储列的值 2...
庖丁解牛｜图解 MySQL 8.0 优化器查询转换篇
阿里云技术
10-20 301
一 背景和架构 在《庖丁解牛-图解MySQL 8.0优化器查询解析篇》一文中我们重点介绍了MySQL最新版本8.0.25关于SQL基本元素表、列、函数、聚合、分组、排序等元素的解析、设置和转换过程，本篇我们继续来介绍更为复杂的子查询、分区表和JOIN的复杂转换过程，大纲如下： Transformation remove_redundant_subquery_clause :Permanently remove redundant parts from the query if 1) This is a
MySQL中explain执行计划中额外信息字段(Extra)详解
热门推荐
poxiaonie的博客
08-31 6万+
SQL执行计划是经过优化器决策，产生的SQL在数据库内部执行的访问路径计划； 由如下语法得到：explain select col1,col2 from t1..; desc select col1,col2 from t1..;理解输出各个列的含义 id:每个select子句的标识id select_type:select语句的类型 table:当前表名 显示查询将访问的分区，如果你的查询是基于
四、MySql中explain的时候出现Using where； Using index； Using temporary； Using filesort
IT蜗牛的专栏
03-11 1万+
通过explain查看sql的执行计划时，Extra字段的值往往会看到Using where; Using index; Using temporary; Using filesort 一、using filesort 在使用order by关键字的时候，如果待排序的内容不能由所使用的索引直接完成排序的话，那么mysql有可能就要进行文件排序。 【这个 filesort 并不是说通过磁盘文件进行排序，而只是告诉我们进行了一个排序操作而已】。 此时，可以进行的优化： ...
mysql查询优化--临时表和文件排序（Using temporary; Using filesort问题解决）
shandalue的专栏
06-13 2万+
先看一段sql： SELECT * FROM rank_user AS rankUser LEFT JOIN rank_user_level AS userLevel ON rankUser.id = userLevel.user_id LEFT JOIN rank_product AS product ON userLevel.new_level = product.leve
Mysql 优化
wang1518037965的专栏
06-18 3664
8.优化 8.优化 8.1 优化概述 8.2 优化SQL语句 8.2.1 优化SELECT语句 8.2.1.1 SELECT语句的速度 8.2.1.2 WHERE子句优化 8.2.1.3 Range优化 8.2.1.4 索引合并(Index Merge)优化 8.2.1.5 引擎Pushdown条件优化 8.2.1.6 索引条件Pushdown优化 8.2.1.7 使用索引扩
MySQL查询优化器--逻辑查询优化技术（二）--子查询优化（四）
那海蓝蓝的博客
03-13 834
5 MySQL支持的子查询可优化类型   从句式的形式看，子查询分为特殊格式子查询和非特殊格式子查询，特殊格式的子查询中又包括IN、ALL、ANY、SOME、EXISTS等类型的子查询，对于有的类型的子查询，MySQL有的支持优化，有的不支持，具体情况如下。   示例一，MySQL不支持对EXISTS类型的子查询的优化： EXISTS类型的相关子查询，查询执行计划如下： mysql
using_where, Using temporary ,using_filesort 分享
大鹏
03-19 1万+
Using filsort文档中的解释： Mysql需要额外的一次传递，以找出如何按排序顺序检索行，通过根据联接类型浏览所有行并为所有匹配where子句的行保存排序关键字和行的指针来完成排序，然后关键字被排序，并按排序顺序检索行。额外的传递是指什么？ Mysql> show create table test_filesort\G; ***************************
mysql 执行计划
最新发布
12-26
MySQL执行计划是MySQL数据库查询优化的重要工具，它可以帮助我们分析查询语句的执行情况，包括索引使用情况、扫描的行数等，从而优化查询效率。下面是一个示例： ```sql EXPLAIN SELECT * FROM users WHERE age > ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

后端从入门到精通

你的鼓励是我最大的动力~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值