MySQL 查询性能优化 - EXPLAIN 命令

最新推荐文章于 2024-04-22 23:31:26 发布
最新推荐文章于 2024-04-22 23:31:26 发布
阅读量96 收藏
点赞数
文章标签： 数据库 json
原文链接：http://www.cnblogs.com/kika/p/10851622.html
版权

查询优化的官方文档在 这里。
EXPLAIN 的输出格式 译文

1. MySQL 架构

1.1 MySQL 的简化架构

MySQL 可以简单的分为三层：连接层、服务层、存储引擎层。其中服务层包含了 MySQL 的核心组件：

用户连接层
    ↓     ↓       ↓        ↓       ↓           ↓
---------------------------------------------------------------------

+------------------+
|  MySQL 连接池     |
+------------------+


+------------------+-------------+----------+------------------+
|  Cache && Buffer |   Optimizer |  Parser  |  SQL Interface   |
+------------------+-------------+----------+------------------+

---------------------------------------------------------------------
  ↓          ↓         ↓           ↓          ↓
InnoDB      MyISAM     Memory     Archive     Cluster

存储引擎层

各个组件概述如下：

  • 连接池：维护用于用户连接的线程池，避免频繁创建销毁线程导致的开销。
  • 存储引擎层：提供标准接口，满足这个接口的存储引擎都可以用于 MySQL。
  • SQL Interface：SQL 接口层，接受 SQL 语句并返回结果
  • Parser：解析器，解析和验证 SQL 语句。
  • Cache && Buffer：缓存，由一系列小缓存组成，比如表缓存、记录缓存、key 缓存、权限缓存等。查询命中缓存时，会直接返回缓存中的数据。
  • Optimizer：优化器，执行 SQL 语句之前会进行优化

1.2 工作流程

到 MySQL 的连接建立后，执行的每一条 SQL 语句的流程如下：

  • 调用 SQL Interface，发生 SQL 语句
  • 通过 Parser 解析 SQL 语句，如果发生错误则报错并退出
  • 查询缓存。如果在缓存中发现相同的指令，则命中缓存，数据从缓存返回，不再执行后续步骤
  • 通过 Optimizer 优化 SQL 语句，最终执行的 SQL 语句可能与你发送的 SQL 语句不一样
  • 执行 SQL 语句，结果写入缓存并返回

2. EXPLAIN 概述

EXPLAIN 可以提供 MySQL 语句的执行信息

  • 可以用于 SELECT、DELETE、INSERT、REPLACE 和 UPDATE 五条语句。
  • 显示的信息来自 Optimizer 优化器。

EXPLAIN 命令输出如下：

mysql> EXPLAIN SELECT * FROM people;
+----+-------------+--------+------+---------------+------+---------+------+------+-------+
| id | select_type | table  | type | possible_keys | key  | key_len | ref  | rows | Extra |
+----+-------------+--------+------+---------------+------+---------+------+------+-------+
|  1 | SIMPLE      | people | ALL  | NULL          | NULL | NULL    | NULL |    9 |       |
+----+-------------+--------+------+---------------+------+---------+------+------+-------+
1 row in set (0.00 sec)
ColumnJSON Name说明
idselect_idSELECT 标识符
select_typeNoneSELECT 类型
tabletable_name输出行对应的表
partitionspartitions匹配的分区
typeaccess_type连接类型
possible_keyspossible_keys可供选择的索引
keykey实际使用的索引
key_lenkey_length实际使用的索引的长度
refref与索引进行比较的列，也就是关联表使用的列
rowsrows要被检查的行数（估算值）
filteredfiltered被表条件过滤的行数的百分比
ExtraNone附加信息

id

SELECT 标识符，该值为 SELECT 在查询中的顺序号，如果当前行引用的是其他行的联合查询结果，该值将被设置为 NULL。在这种情况下，表中的列将显示一个类似于

mysql> EXPLAIN SELECT * FROM (SELECT * FROM test) as a;
+----+-------------+------------+------+---------------+------+---------+------+------+-------+
| id | select_type | table      | type | possible_keys | key  | key_len | ref  | rows | Extra |
+----+-------------+------------+------+---------------+------+---------+------+------+-------+
|  1 | PRIMARY     | <derived2> | ALL  | NULL          | NULL | NULL    | NULL |    3 |       |
|  2 | DERIVED     | test       | ALL  | NULL          | NULL | NULL    | NULL |    3 |       |
+----+-------------+------------+------+---------------+------+---------+------+------+-------+
2 rows in set (0.00 sec)

select_type

SELECT 的类型，可用类型参考下表。如果该值为 SIMPLE 或者 PRIMARY，一个 JSON 格式的 EXPLAIN 将以一个 query_block 的属性显示 SELECT 的类型。

如果查询有任何复杂的子查询，则最外层标记为 PRIMARY，内层可以是 DERIVED、UNION、UNION RESUlT。

select_type ValueJSON Name说明
SIMPLENone简单的 SELECT (没有使用 UNION 和子查询)
PRIMARYNone使用 UNION 联合查询和子查询时，最外层的 SELECT
UNIONNone在 UNION 查询中的第二个或者之后的 SELECT 语句，如果是 UNION 位于 FROM 中则标记为 DERIVED
DEPENDENT UNIONdependent (true)在 UNION 查询中的第二个或者之后的 SELECT 语句，依赖外层的查询
UNION RESULTunion_result联合查询的结果
SUBQUERYNone在子查询中的第一个 SELECT
DEPENDENT SUBQUERYdependent (true)在 subquery 子查询中的第一个 SELECT，依赖于外层查询
DERIVEDNone派生表 SELECT(由 FROM 中的 subquery 子查询引起的临时表)
MATERIALIZEDmaterialized_from_subquery物化子查询
UNCACHEABLE SUBQUERYcacheable (false)子查询的结果不能被缓存，必须重新评估外部查询的每一行
UNCACHEABLE UNIONcacheable (false)在 UNION 联合查询中的第二个或者之后的多个 SELECT 都不可缓存的子查询

依赖通常意味着使用了相关子查询。

子查询的分类及评估：

  • 相关子查询：只重新评估一次外部上下文环境的每一组变量的不同值
  • 不可缓存的子查询：重新评估外部上下文环境的每一行数据。

子查询的缓存不同与 query cache 中查询结果的缓存：

  • 子查询缓存：发生在查询执行期间
  • query cache：用来存储查询执行完成后的结果。

table

输出的行引用了哪个表，除了真实表名外，还有临时表的表名。临时表没有任何索引。临时表的表名可以是下列值之一：

  • <union M,N>：有 UNION RESULT 的时候，表名是这个形式。该行指的是 ID 值为 M 和 N 的行的联合。
  • <derivedN>：FROM 中有 SUBQUERY 子查询的时候，表名是这个形式。N 指向子查询对应的行。
  • <subqueryN>：该行指的是一个物化子查询的结果，该结果为 ID 值为 N 的行。

type

数据访问/读取操作的类型，可用值有：ALL、index、range、ref、eq_ref、const/system、NULL。

这是重要指标，type 的结果值从好到坏依次是：

system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL

查询至少要达到 range 级别，最好能达到 ref。

All

全表扫描（速度慢，磁盘 I/O 高）。可以增加索引来避免全表扫描。

对于非索引字段，查询时触发全表扫描（尽量避免）：

mysql> EXPLAIN SELECT * FROM test WHERE value="t2";
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra       |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
|  1 | SIMPLE      | test  | ALL  | NULL          | NULL | NULL    | NULL |    3 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)
index

覆盖索引，所需数据可以直接从索引中获取。与 All 全表扫描类似，但是只扫描索引，所以速度较快。当查询的几个字段刚好都在同一个索引中时，会使用使用覆盖索引，Extra 列对应 Using index。

查询字段被索引包含及超出索引的区别：

mysql> EXPLAIN SELECT value FROM test WHERE value IS NOT NULL;
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
| id | select_type | table | type  | possible_keys | key   | key_len | ref  | rows | Extra                    |
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
|  1 | SIMPLE      | test  | index | value         | value | 43      | NULL |    4 | Using where; Using index |
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * FROM test WHERE value IS NOT NULL;
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra       |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
|  1 | SIMPLE      | test  | ALL  | value         | NULL | NULL    | NULL |    4 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)
range

部分索引扫描。key 列显示使用的索引。当指定了索引且对索引使用 =、 <>、>、>=、<、<=、IS NULL、<=>、BETWEEN AND 或 IN (a, b)范围限定操作符时，会使用 range。

对于主键 id 使用范围限定操作符，只读取 id 字段时，触发 range 部分索引扫描：

mysql> EXPLAIN SELECT * FROM test WHERE id BETWEEN 0 AND 2;
+----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref  | rows | Extra       |
+----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
|  1 | SIMPLE      | test  | range | PRIMARY       | PRIMARY | 4       | NULL |    2 | Using where |
+----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
1 row in set (0.02 sec)

对于主键 id 使用范围限定操作符，读取索引之外的字段时，触发 range 部分索引扫描。如果只读取索引之内的字段，则触发 index 覆盖索引：

mysql> EXPLAIN SELECT * FROM test WHERE id BETWEEN 0 AND 2;
+----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref  | rows | Extra       |
+----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
|  1 | SIMPLE      | test  | range | PRIMARY       | PRIMARY | 4       | NULL |    2 | Using where |
+----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT id FROM test WHERE id BETWEEN 0 AND 2;
+----+-------------+-------+-------+---------------+---------+---------+------+------+--------------------------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref  | rows | Extra                    |
+----+-------------+-------+-------+---------------+---------+---------+------+------+--------------------------+
|  1 | SIMPLE      | test  | index | PRIMARY       | PRIMARY | 4       | NULL |    4 | Using where; Using index |
+----+-------------+-------+-------+---------------+---------+---------+------+------+--------------------------+
1 row in set (0.00 sec)
ref

通过索引访问数据。只有当使用非唯一性索引（PRIMARY 和 UNIQUE 之外的索引）或唯一性索引的非唯一性前缀时才会发生。

这个类型跟 eq_ref 不同的是，它用在关联操作只使用了索引的最左前缀，或者索引不是 UNIQUE 和 PRIMARY KEY。ref 可以用于使用 = 或 <=> 操作符的带索引的列。对于每个来自于前面的表的行组合，所有有匹配索引值的行将从这张表中读取。如果联接只使用键的最左边的前缀，或如果键不是UNIQUE或PRIMARY KEY（换句话说，如果联接不能基于关键字选择单个行的话），则使用ref。如果使用的键仅仅匹配少量行，该联接类型是不错的。ref可以用于使用=或<=>操作符的带索引的列。

将 WHERE 用的字段添加到索引后，触发 ref 索引访问：

mysql> EXPLAIN SELECT * FROM test WHERE value="t2";
+----+-------------+-------+------+---------------+-------+---------+-------+------+-------------+
| id | select_type | table | type | possible_keys | key   | key_len | ref   | rows | Extra       |
+----+-------------+-------+------+---------------+-------+---------+-------+------+-------------+
|  1 | SIMPLE      | test  | ref  | value         | value | 43      | const |    1 | Using where |
+----+-------------+-------+------+---------------+-------+---------+-------+------+-------------+
1 row in set (0.00 sec)
eq_ref

最多只返回一条符合条件的记录。使用唯一性索引或主键查找时会发生。对于每个来自于前面的表的行组合，从该表中读取一行。这可能是最好的联接类型，除了const类型。它用在一个索引的所有部分被联接使用并且索引是UNIQUE或PRIMARY KEY。eq_ref可以用于使用= 操作符比较的带索引的列。比较值可以为常量或一个使用在该表前面所读取的表的列的表达式。

const

确定最多只有一行匹配时，MySQL 优化器会在查询开始时将这一行数据读入内存（只读一次），这一行的所有字段值被优化器剩余部分当做常量处理。const 用于用常数值比较 PRIMARY KEY 或 UNIQUE 索引的所有部分时。

对于 PRIMARY KEY 主键或 UNIQUE 索引字段，因为其唯一性，查询效率特别高：

mysql> EXPLAIN SELECT * FROM test WHERE id=1;
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
|  1 | SIMPLE      | test  | const | PRIMARY       | PRIMARY | 4       | const |    1 |       |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
1 row in set (0.00 sec)

注意，匹配到 const 表后，不能在这个表上再次进行匹配了：

mysql> EXPLAIN SELECT * FROM test WHERE id=1 and value="t2";
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------------------------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra                                               |
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------------------------------+
|  1 | SIMPLE      | NULL  | NULL | NULL          | NULL | NULL    | NULL | NULL | Impossible WHERE noticed after reading const tables |
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------------------------------+
1 row in set (0.00 sec)
system

要匹配的表仅有一行数据。这是 const 连接类型的一种特例，

例如下面的子查询，对于内层查询，通过 PRIMARY KEY 主键返回唯一一条数据，对于外层查询，type 就是 system 类型：

mysql> EXPLAIN SELECT * FROM (SELECT * FROM test WHERE id=1) as 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     | test       | const  | PRIMARY       | PRIMARY | 4       |      |    1 |       |
+----+-------------+------------+--------+---------------+---------+---------+------+------+-------+
2 rows in set (0.00 sec)
NULL

mysql 在优化 SQL 语句后，分解的某个查询语句命中缓存或使用临时表，不需要访问数据或索引。

possible_keys

possible_keys 中列出本次查询覆盖的所有索引，这些都可能被 MySQL 选择使用。
如果该列的值是 NULL，说明查询语句没有覆盖到索引列，通常会发生全表扫描。可以检查 WHERE 子句是否引用了包含索引的列。

可能有多个可用索引，但可能 MySQL 一个都不会用：

mysql> EXPLAIN SELECT * FROM test WHERE id=1 OR value="t2";
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra       |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
|  1 | SIMPLE      | test  | ALL  | PRIMARY,value | NULL | NULL    | NULL |    4 | Using where |
+----+-------------+-------+------+---------------+------+---------+------+------+-------------+
1 row in set (0.00 sec)

使用 SHOW INDEX FROM tbl_name 查看表中已有的索引：

mysql> SHOW INDEX FROM test;
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| test  |          0 | PRIMARY  |            1 | id          | A         |           4 |     NULL | NULL   |      | BTREE      |         |               |
| test  |          0 | unique   |            1 | v_unique    | A         |        NULL |     NULL | NULL   | YES  | BTREE      |         |               |
| test  |          1 | value    |            1 | value       | A         |        NULL |     NULL | NULL   | YES  | BTREE      |         |               |
+-------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
3 rows in set (0.00 sec)

key

MySQL 实际使用的索引。如果 key 值为 NULL，表明 MySQL 没有找到执行高效查询的索引。MySQL 一般会通过 possible_keys 中的某个索引查找行，并将那个索引列在 key 列中；但是也可以使用不包含在 possible_keys 列中的索引。

可以在查询语句中使用 FORCE INDEX、USE INDEX、IGNORE INDEX，强制 MySQL 使用或者忽略 possible_keys 列中的索引。

key_len

MySQL 决定使用的 key 的长度。key_len 值能够使你判定 MySQL 实际使用了 multiple-part key 中的多少个 part。如果 key 列的值为 NULL，则 key_len 列值也为 NULL。在不损失精确性的情况下，长度越短越好。

ref

ref 列显示列或常量，这些列或者常量与 key 列中的索引进行比较，以便从表中选择行。 

mysql> EXPLAIN SELECT * FROM test WHERE id=1;
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
|  1 | SIMPLE      | test  | const | PRIMARY       | PRIMARY | 4       | const |    1 |       |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
1 row in set (0.00 sec)

rows

rows 是 MySQL 预估的在执行查询时必须扫描的行数。把所有 rows 列值相乘，可粗略估算整个查询会检查的行数。

对于 InnoDB 类型的表，这个数字只是一个估计，并不总是精确的。

Extra

额外信息，是查询过程的重要补充信息。有几十种可能的输出，完整资料参考 官网 的 EXPLAIN Extra Information 部分。

Using filesort

MySQL 有两种方式生成有序结果：

  • 通过排序操作（ORDER BY 或 GROUP BY）。此时 Extra 中出现“Using filesort”，文件排序。
  • 按索引顺序扫描，通常速度更快。如果 EXPLAIN 出来的 type 列的值为“index”，则说明 MySQL 使用了索引扫描来排序。不要和 Extra 列的“Using index”（覆盖索引，只访问索引即可返回所查询的数据）搞混。

扫描索引本身是很快的，只需要从一条索引记录移动到紧接着的下一条记录。但如果索引不能覆盖查询所需的全部列，就不得不每扫描一条索引记录就回表查询一次对应的行，这基本上都是随机 I/O。按索引顺序读数据通常比顺序地全表扫描速度慢，尤其是 I/O 密集型工作负载。

例如，对于 MySQL 的 示例数据库 Sakila，rental 表中的 rental_date 字段是有索引的，return_date 字段是没有索引的，这两个字段区别如下：

mysql> EXPLAIN SELECT * FROM rental WHERE rental_date='2005-05-25' ORDER BY inventory_id, customer_id;
+----+-------------+--------+------+---------------+-------------+---------+-------+------+-------------+
| id | select_type | table  | type | possible_keys | key         | key_len | ref   | rows | Extra       |
+----+-------------+--------+------+---------------+-------------+---------+-------+------+-------------+
|  1 | SIMPLE      | rental | ref  | rental_date   | rental_date | 8       | const |    1 | Using where |
+----+-------------+--------+------+---------------+-------------+---------+-------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * FROM rental WHERE return_date='2005-05-25' ORDER BY inventory_id, customer_id;
+----+-------------+--------+------+---------------+------+---------+------+-------+-----------------------------+
| id | select_type | table  | type | possible_keys | key  | key_len | ref  | rows  | Extra                       |
+----+-------------+--------+------+---------------+------+---------+------+-------+-----------------------------+
|  1 | SIMPLE      | rental | ALL  | NULL          | NULL | NULL    | NULL | 16305 | Using where; Using filesort |
+----+-------------+--------+------+---------------+------+---------+------+-------+-----------------------------+
1 row in set (0.00 sec)
Using temporary

用临时表保存中间结果，常用于 GROUP BY 和 ORDER BY 操作中。尽量避免硬盘临时表的使用。

Not exists

MySQL 能够对查询执行 LEFT JOIN 优化，并且在找到与 LEFT JOIN 条件相匹配的一行后，不会在该表中检查更多行。以下是可以用这种方式进行优化的查询类型的示例：

SELECT * FROM t1 LEFT JOIN t2 ON t1.id=t2.id WHERE t2.id IS NULL;
Using index

发生覆盖索引，查询的字段完全落入索引，从索引文件中即可获得所需信息，不需要读数据文件。

mysql> EXPLAIN SELECT rental_date FROM rental WHERE rental_date='2005-05-25' ORDER BY inventory_id, customer_id;
+----+-------------+--------+------+---------------+-------------+---------+-------+------+--------------------------+
| id | select_type | table  | type | possible_keys | key         | key_len | ref   | rows | Extra                    |
+----+-------------+--------+------+---------------+-------------+---------+-------+------+--------------------------+
|  1 | SIMPLE      | rental | ref  | rental_date   | rental_date | 8       | const |    1 | Using where; Using index |
+----+-------------+--------+------+---------------+-------------+---------+-------+------+--------------------------+
1 row in set (0.00 sec)
Using where

Extra 列出现“Using where”表示 MySQL 服务器在存储引擎返回行后再应用 WHERE 过滤条件。对于带 WHERE 的 SQL 语句，可能会在存储引擎返回行之前或之后应用 WHERE 过滤条件。

mysql> EXPLAIN SELECT * FROM sakila.actor WHERE last_name="CHASE";
+----+-------------+-------+------+---------------------+---------------------+---------+-------+------+-------------+
| id | select_type | table | type | possible_keys       | key                 | key_len | ref   | rows | Extra       |
+----+-------------+-------+------+---------------------+---------------------+---------+-------+------+-------------+
|  1 | SIMPLE      | actor | ref  | idx_actor_last_name | idx_actor_last_name | 137     | const |    2 | Using where |
+----+-------------+-------+------+---------------------+---------------------+---------+-------+------+-------------+
1 row in set (0.00 sec)

mysql> EXPLAIN SELECT * FROM sakila.actor WHERE actor_id = 1;
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
| id | select_type | table | type  | possible_keys | key     | key_len | ref   | rows | Extra |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
|  1 | SIMPLE      | actor | const | PRIMARY       | PRIMARY | 2       | const |    1 |       |
+----+-------------+-------+-------+---------------+---------+---------+-------+------+-------+
1 row in set (0.00 sec)
Impossible where

表示 WHERE 条件总是 FALSE，不能用来获取任何数据。

mysql> EXPLAIN SELECT * FROM test WHERE id=1 AND value="t2";
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------------------------------+
| id | select_type | table | type | possible_keys | key  | key_len | ref  | rows | Extra                                               |
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------------------------------+
|  1 | SIMPLE      | NULL  | NULL | NULL          | NULL | NULL    | NULL | NULL | Impossible WHERE noticed after reading const tables |
+----+-------------+-------+------+---------------+------+---------+------+------+-----------------------------------------------------+
1 row in set (0.00 sec)

转载于:https://www.cnblogs.com/kika/p/10851622.html

weixin_30379531
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据库查询优化使用explain分析sql语句执行效率
Bertram的博客
11-13 540
Explain命令在解决数据库性能上是第一推荐使用命令，大部分的性能问题可以通过此命令来简单的解决，Explain可以用来查看SQL语句的执行效果，可以帮助选择更好的索引和优化查询语句，写出更好的优化语句。 用法 explain的用法相当简洁，直接在sql语句前加上EXPLAIN 即可： 例如：默认查询，未使用索引 explain select * from BrandR where chinese='MICHAEL KORS'; rows= 8103 查询所有行 以下是各个属性解释..
MySQL性能优化详解.docx
03-26
使用EXPLAIN分析查询：通过在查询语句前加上EXPLAIN关键字，可以了解MySQL是如何处理该语句的，从而识别出潜在的性能瓶颈。 优化表的关联顺序：在多表关联查询时，MySQL的查询优化器会自动决定表的连接顺序，但有时...
MySQL中的JSON类型
uteundilse的博客
03-17 1833
MySQL中的JSON类型是一种数据类型，用于存储和处理JSON（JavaScript Object Notation）格式的数据。JSON是一种轻量级的数据交换格式，它以简洁的格式表示复杂的数据结构，包括数组和对象等。
30种MySQL查询语句优化方法分享
技术专家
06-16 2444
30种MySQL查询语句优化方法分享，对于MySQL查询语句来说效率是最重要的能用一分钟搞定的绝不能花费两分钟。今天整理了30种MySQL查询语句优化方法，供大家学习使用。
MySQL全文索引、联合索引、like查询、json查询速度大比拼
资料免费分享，点击名片
02-28 436
查询背景 有一个表tmp_test_course大概有10万条记录，然后有个json字段叫outline，存了一对多关系(保存了多个编码，例如jy1577683381775) 我们需要在这10万条数据中检索特定类型的数据，目标总数据量：2931条 SELECT COUNT(*) FROM tmp_test_course WHERE `type`=5 AND del=2 AND is...
MySQL查询优化
qq_28014809的博客
04-28 5227
索引是什么 索引是数据库存储引擎用于快速找到记录的一种数据结构。索引对于良好的性能非常关键，尤其当表中的数据量越来越大时。 MySQL索引数据结构
MySQL性能优化神器Explain的基本使用分析
01-19
MySQL 提供了一个 EXPLAIN 命令, 它可以对 SELECT 语句进行分析, 并输出 SELECT 执行的详细信息, 以供开发人员针对性优化. EXPLAIN 命令用法十分简单, 在 SELECT 语句前加上 Explain 就可以了, 例如: EXPLAIN ...
Mysql Explain命令的使用与分析
12-15
mysql explain命令用于显示mysql如何使用索引来处理select语句以及连接表。通过该命令可以分析出查询语句或是表结构的性能瓶颈，从而写出性能更好的SQL语句，通过 expalin 命令我们可以得到： 1. 表的读取顺序 2. ...
MySQL查询优化之索引的应用详解
12-15
如同其它学科，优化查询性能很大程度上决定于开发者的直觉。幸运的是，像MySQL这样的数据库自带有一些协助工具。本文简要讨论诸多工具之三种：使用索引，使用EXPLAIN分析查询以及调整MySQL的内部配置。 MySQL允许对...
mysql explain用法
08-13
Explain命令在解决数据库性能上是第一推荐使用命令，大部分的性能问题可以通过此命令来简单的解决，Explain可以用来查看SQL语句的执行效 果，可以帮助选择更好的索引和优化查询语句，写出更好的优化语句。
MySQL全文索引、联合索引、like查询、json查询速度哪个快
09-08
主要介绍了MySQL全文索引、联合索引、like查询、json查询速度大比拼，通过实例代码截图的形式给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
mysql5.7存储json_简单谈谈MySQL5.7 JSON格式检索
weixin_39713686的博客
01-17 278
MySQL5.7版本开始支持JSON格式，在创建表时，可以指定列表的数据类型为JSON，但是如何在JSON格式上创建索引呢？？本人做了一个简单测试。第一步：建立一个包含JSON类型的表：CREATE TABLE json_test` (id` int (8) NOT NULL AUTO_INCREMENT,content` json NOT NULL ,PRIMARY KEY (`id`)) EN...
mysql json性能测试
qingfeng2556的博客
09-23 4892
总条数100-150万，2核4线程4g内存 参考https://www.cnblogs.com/amerkor/p/13646581.html https://blog.csdn.net/ai_xao/article/details/100711808 ---------未加索引测试--------------------------------------------------------------------------------------- 1、未加索引,id主键，count对比,json明.
MySQL5.7 JSON字段性能测试
Zero的博客
08-27 2433
MySQL5.7 JSON字段性能测试 表结构 JSON字段表 CREATE TABLE `invt_bin_dim_test` ( ​ `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT, ​ `dim` json DEFAULT NULL, ​ PRIMARY KEY (`id`) ​ ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4; 传统表 CREATE TABLE `invt_bi
提升MySQL查询效率及查询速度优化的4个方法
drhrht的博客
08-31 7863
现在对这连个表执行关联查询，其查询的效率如何呢首先需要确定的一点是，虽然他们两个是不同类型的字符型数据，不过是相互兼容的。现在再对这两个表进行关联查询，得到的结果是否相同呢我们测试的结果是，查询的结果是相同的，但是其所花费的时间是不同的。从这里可以知道，虽然这两个查询语句是等价的，但是其查询的效率不同。如上图所示，我们可以给这条Select语句进行如下的优化：在表中设置关键字或者索引，来提高查询的效率。但是这条语句执行的效率如何是否还有优化的余地这些内容是无法从上面这个简单的查询语句中获得的。...
MYSQL-性能优化-关于JSON字段取值未剔除引号导致查询时间延长
yes_is_ok的博客
01-15 1797
问题描述：查询出来的json格式的字段值被in()使用的时候，如果你没有对字段值的引号做去除操作，mysql也会对它做处理，但是这样会加长mysql查询的时间，数据量超过万级，耗时就会是很长很长。必须要对json取出来的值做引号剔除。 举个例子： mysql版本是5.7.x 表名为： student id person 2 {"name":"wahaha","sex":"...
mysql json数据格式的查询性能测试
热门推荐
我与风来
09-10 1万+
环境准备 数据库环境：mysql 5.7.20 数据准备： 1 . test_json表，存储10万行数据，每行数据的json列值为10个元素的json数组 test_varchar_index表，存储100万条数据，不包含json列，并且不针对列建立索引 test_varchar_noindex 表，存储100万条数据，不包含json 列，但建立索引 数据脚本如下： delimiter $...
【kettle001】访问国产达梦数据库并处理数据至execl文件
最新发布
kngines
04-22 366
一直以来想写下基于kettle的系列文章，作为较火的数据ETL工具，也是日常项目开发中常用的一款工具，最近刚好挤时间梳理、总结下这块儿的知识体系。熟悉、梳理、总结下达梦（DM）关系型数据库相关知识体系。
mysql和Nosql到底有什么区别，分别应用与什么场景？
m0_60388871的博客
04-20 664
MySQL 和 NoSQL 是两种不同类型的数据库技术，它们各有其特点和适用场景。了解它们之间的区别和应用场景可以帮助选择合适的技术来支持特定的应用需求。
mysql 分析命令_【MySql】性能优化之分析命令
06-09
其中，EXPLAIN命令可以用来分析查询语句并输出查询执行计划，SHOW PROFILE命令可以用来查看查询语句的执行过程中各个阶段的耗时情况，SHOW STATUS命令可以用来查看MySQL服务器的各种状态信息。 除了使用分析命令外...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值