La colonne Base de données MySQL d'aujourd'hui présente les plans d'exécution associés.
Le troisième blog de la série MySQL, le contenu principal est l'analyse du plan d'exécution Explain dans MySQL Si vous savez déjà comment analyser le plan d'exécution. , alors pour SQL, le réglage est simple.
En regardant les exigences professionnelles de nombreux fabricants de premier et deuxième rang, ceux qui conçoivent des bases de données auront certainement besoin d'une expérience dans le réglage SQL. C'est presque devenu une question d'entretien « à développement en huit parties » à égalité avec Spring. .
Pour effectuer le réglage SQL, vous devez d'abord connaître l'état d'exécution de SQL. Le sentiment le plus intuitif est bien sûr le temps d'exécution de l'instruction SQL. Cependant, en plus, nous pouvons également analyser l'instruction SQL. le plan d'exécution pour effectuer le réglage.
L'instruction Explain peut voir comment MySQL exécute cette instruction SQL, y compris l'utilisation des index, le nombre de lignes analysées, etc. Ces informations sont très utiles pour le réglage SQL. . C’est important, vous devez donc d’abord comprendre le plan d’exécution.
mysql> explain select * from user where name='one'; +----+-------------+-------+------------+------+---------------+------+---------+-------+------+----------+-------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+---------------+------+---------+-------+------+----------+-------------+| 1 | SIMPLE | user | NULL | ref | a | a | 13 | const | 1 | 100.00 | Using index | +----+-------------+-------+------------+------+---------------+------+---------+-------+------+----------+-------------+1 row in set, 1 warning (0.00 sec)复制代码
Ce qui précède est le plan d'exécution d'une simple instruction de requête. Ce tableau comporte un total de 12 champs, chacun représentant des significations différentes. Ils sont décrits un par un ci-dessous.
id : Indique l'ordre d'exécution de SQL. Plus la valeur est grande, plus la priorité est élevée. Si les valeurs sont les mêmes, l'ordre d'exécution est déterminé par l'optimiseur. select_type : Indique le type d'instruction de requête de sélection table : Le nom de la table (ou l'alias de la table) interrogé par l'instruction SQL, ou il peut s'agir d'un nom non- table existante telle qu'une table temporaire partitions : les informations de partition impliquées dans l'instruction de requête type : le type d'association (type d'accès) détermine la manière dont MySQL recherche les lignes dans le tableau. La performance du pire au meilleur est ALL, index, range, index_merge, ref, eq_ref, const, system, NULL
possible_keys : Affiche tous les index pouvant être utilisés par l'instruction de requête key : Affiche le nom de l'index décidé par l'optimiseur key_len : Affiche la longueur de l'index utilisée par MySQL Number de sections ref : Colonne ou constante utilisée pour retrouver une valeur dans l'index de l'key enregistrement de colonne rows : Estimation du nombre de lignes à parcourir filtered : Le pourcentage du nombre de lignes qui satisfont finalement l'instruction de requête par rapport au nombre total de lignes renvoyées par le moteur de stockageExtra : Autres informations d'exécutionCe qui précède concerne uniquement chaque champ de l'explication du nom du tableau du plan d'exécution, je vais ensuite utiliser des exemples pratiques pour aider tout le monde (moi-même) à mieux comprendre ces champs importants select_type, type, key_len, rows, Extra.
Présentez d'abord l'exemple de structure de table et les lignes de données qui seront utilisées dans cet article :
CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键', `name` varchar(36) DEFAULT NULL COMMENT '姓名', `age` int(11) NULL DEFAULT NULL COMMENT '年龄', `email` varchar(36) DEFAULT NULL COMMENT '邮箱', PRIMARY KEY (`id`) USING BTREE, INDEX `idx_age_name`(`age`, `name`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 1;复制代码
Insérez 1 000 000 de données de test dans le tableau via une fonction.
CREATE DEFINER=`root`@`localhost` PROCEDURE `idata`()begin
declare i int;
set i=1;
while(i<=1000000)do
insert into user(id,name,age,email) values(i, CONCAT('name',i), i % 50, concat(i,'name@email.cn')); set i=i+1;
end while;end复制代码Le champ select_type dans le plan d'exécution représente le type d'instruction de requête de sélection. Les types courants sont :
SIMPLE. : instruction de requête simple, excluant les sous-requêtes et les associations, telles que : mysql> explain select * from user where id=1; +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+| 1 | SIMPLE | user | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL | +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+1 row in set, 1 warning (0.00 sec)复制代码
Si l'instruction de requête contient des sous-parties complexes, alors la partie la plus externe sera marquée comme PRIMARY, tel que :
mysql> explain select * from user where id=(select id from user where id=1); +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+| 1 | PRIMARY | user | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL | | 2 | SUBQUERY | user | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | Using index | +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+2 rows in set, 1 warning (0.00 sec)复制代码
Dans le plan d'exécution de cette instruction SQL, le premier SQL exécuté, c'est-à-dire select * from yser where id = (...), est marqué comme PRIMARY
La sous-requête contenue dans le contenu select ou Where sera marquée comme SUBQUERY Par exemple, la deuxième instruction du plan d'exécution de l'exemple SQL précédent, c'est-à-dire le select id from user where id=1 de sera marqué select_type. SUBQUERY
, le résultat sera stocké dans une table temporaire, telle que : DERIVED
mysql> explain select * from (select id,name,count(*) from user where id=1) as user_1 where id=1; +----+-------------+------------+------------+--------+---------------+---------+---------+-------+------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+------------+------------+--------+---------------+---------+---------+-------+------+----------+-------+| 1 | PRIMARY | <derived2> | NULL | system | NULL | NULL | NULL | NULL | 1 | 100.00 | NULL | | 2 | DERIVED | user | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL | +----+-------------+------------+------------+--------+---------------+---------+---------+-------+------+----------+-------+2 rows in set, 1 warning (0.00 sec)复制代码
est select id,name,count(*) from user where id=1 . DERIVED
2.3 tapez ExplainIl existe 12 types de requêtes au total Pour des explications spécifiques, veuillez consulter le document officiel - expliquer_select_type
select_type
champ C'est une base très importante pour mesurer SQL dans le plan d'exécution. Il montre le type d'association (type d'accès) de l'instruction SQL et détermine comment MySQL recherche les lignes dans la table. type
type 字段的值性能从最差到最优依次是 ALL, index, range, index_merge, ref, eq_ref, const, system。
为了能更好地理解各个类型的含义，我对上述每一种类型都举出了相应的示例。
并未全部列出，完整的解释可以看官方文档-EXPLAIN Join Types
ALL 表示全表扫描，意味着存储引擎查找记录时未走索引，所以它是性能最差的一种访问类型，如
mysql> explain select * from user where age+2=20; +----+-------------+-------+------------+------+---------------+------+---------+------+---------+----------+-------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+---------------+------+---------+------+---------+----------+-------------+| 1 | SIMPLE | user | NULL | ALL | NULL | NULL | NULL | NULL | 1002301 | 100.00 | Using where | +----+-------------+-------+------------+------+---------------+------+---------+------+---------+----------+-------------+1 row in set, 1 warning (0.00 sec)复制代码
可以看到 rows 行的值为1002301，即扫描了全表的所有数据（扫描行数的值实际为估算），如果在生产环境有这样的 SQL，绝对是要优化的。
我们知道在 where 查询条件中，不应该对查询字段使用函数或表达式（应该写在等号不等号右侧），不了解此内容的可以看看我的上一篇博客 —— 我所理解的MySQL(二)索引。
这条查询语句在优化后应该是: select * from user where age=18，去掉等号左侧的表达式，优化后的执行计划如下:
mysql> explain select * from user where age=18; +----+-------------+-------+------------+------+---------------+--------------+---------+-------+-------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+---------------+--------------+---------+-------+-------+----------+-------+| 1 | SIMPLE | user | NULL | ref | idx_age_name | idx_age_name | 5 | const | 39360 | 100.00 | NULL | +----+-------------+-------+------------+------+---------------+--------------+---------+-------+-------+----------+-------+1 row in set, 1 warning (0.00 sec)复制代码
index 表示全索引树扫描，由于扫描的是索引树，所以比 ALL 形式的全表扫描性能要好。
同时，由于索引树本身就是有序的，可以避免排序。
mysql> explain select id,age from user where name='name1'; +----+-------------+-------+------------+-------+---------------+--------------+---------+------+---------+----------+--------------------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------+---------------+--------------+---------+------+---------+----------+--------------------------+| 1 | SIMPLE | user | NULL | index | NULL | idx_age_name | 116 | NULL | 1002301 | 10.00 | Using where; Using index | +----+-------------+-------+------------+-------+---------------+--------------+---------+------+---------+----------+--------------------------+1 row in set, 1 warning (0.00 sec)复制代码
示例查询语句如上所述，当查询条件存在于联合索引 idx_age_name 中，但又无法直接使用该索引（由于最左前缀原则），同时查询列 id,age 也存在于联合索引中，无须通过回表来获取时，执行计划中的访问类型 type 列就会是 index。
range 表示范围扫描，准确的说是基于索引树的范围扫描，扫描的是部分索引树，所以性能比 index 稍好。
需要注意的是，若使用 in 或者 or 时，也可以使用范围扫描。
mysql> explain select * from user where age>18 and age<20; +----+-------------+-------+------------+-------+---------------+--------------+---------+------+-------+----------+-----------------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------+---------------+--------------+---------+------+-------+----------+-----------------------+| 1 | SIMPLE | user | NULL | range | idx_age_name | idx_age_name | 5 | NULL | 36690 | 100.00 | Using index condition | +----+-------------+-------+------------+-------+---------------+--------------+---------+------+-------+----------+-----------------------+1 row in set, 1 warning (0.01 sec) mysql> explain select * from user where age=18 or age=20; +----+-------------+-------+------------+-------+---------------+--------------+---------+------+-------+----------+-----------------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------+---------------+--------------+---------+------+-------+----------+-----------------------+| 1 | SIMPLE | user | NULL | range | idx_age_name | idx_age_name | 5 | NULL | 78720 | 100.00 | Using index condition | +----+-------------+-------+------------+-------+---------------+--------------+---------+------+-------+----------+-----------------------+1 row in set, 1 warning (0.00 sec)复制代码
index_merge 即索引合并，它表示在查询时 MySQL 会使用多个索引。
MySQL 在 where 语句中存在多个查询条件，并且其中存在多个字段可以分别使用到多个不同的索引，在这种情况下 MySQL 可以对多个索引树同时进行扫描，最后将它们的结果进行合并，如：
mysql> explain select * from user where id=1 or age=18; +----+-------------+-------+------------+-------------+----------------------+----------------------+---------+------+-------+----------+-----------------------------------------------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------------+----------------------+----------------------+---------+------+-------+----------+-----------------------------------------------------+| 1 | SIMPLE | user | NULL | index_merge | PRIMARY,idx_age_name | idx_age_name,PRIMARY | 5,4 | NULL | 39361 | 100.00 | Using sort_union(idx_age_name,PRIMARY); Using where | +----+-------------+-------+------------+-------------+----------------------+----------------------+---------+------+-------+----------+-----------------------------------------------------+1 row in set, 1 warning (0.00 sec)复制代码
上面这条查询语句中的 id=1 和 age=18 分别使用到了 PRIMARY 主键索引和 idx_age_name 联合索引，最后再将满足这两个条件的记录进行合并。
ref 表示索引访问（索引查找），这种访问类型会出现在查询条件中以非聚簇索引列的常量值进行查询的情况。
比如在介绍全表扫描中优化后 SQL 的访问类型就是 ref。
eq_ref 这种访问类型会出现在连接查询时，通过聚簇索引进行连接的情况，此类型最多只返回一条符合条件的记录。若表的聚簇索引为联合索引，所有的索引列必须是等值查询，如：
mysql> explain select * from user user1 inner join user user2 where user1.id=user2.id limit 10; +----+-------------+-------+------------+--------+---------------+---------+---------+---------------------+---------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+--------+---------------+---------+---------+---------------------+---------+----------+-------+| 1 | SIMPLE | user1 | NULL | ALL | PRIMARY | NULL | NULL | NULL | 1002301 | 100.00 | NULL | | 1 | SIMPLE | user2 | NULL | eq_ref | PRIMARY | PRIMARY | 4 | all_in_one.user1.id | 1 | 100.00 | NULL | +----+-------------+-------+------------+--------+---------------+---------+---------+---------------------+---------+----------+-------+2 rows in set, 1 warning (0.00 sec)复制代码
const 这种访问类型会出现在通过聚簇索引进行常量等值查询的情况，如：
mysql> explain select * from user where id=1; +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+| 1 | SIMPLE | user | NULL | const | PRIMARY | PRIMARY | 4 | const | 1 | 100.00 | NULL | +----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+1 row in set, 1 warning (0.00 sec)复制代码
在上一篇博客 —— 我所理解的MySQL(二)索引 中 5.2 部分字段匹配 中已经提到过关于索引长度的计算方式，这里再来总结一下。
字符类型的字段若作为索引列，它的索引长度 = 字段定义长度 字符长度 + 是否默认NULL + 是否是变长字段*，其中：
字段定义长度 就是定义表结构时跟在字段类型后括号中的数字字符长度 是常数，utf8=3, gbk=2, latin1=1
是否默认NULL 也是常数，若字段默认值为 NULL，该值为1，因为 NULL 需要额外的一个字节来表示；否则该值为0是否是变长字段 也是常数，若该字段为变长字段，该值为2；否则该值为0所谓的变长字段就是 varchar，它所占用的就是字段实际内容的长度而非定义字段时的长度。而定长字段，也就是 char 类型，它所占用的空间就是自定字段时的长度，若超过会被截取。
举个例子，为上述实例表中添加一个字符类型字段的索引。
alter table user add index idx_name(`name`);复制代码
然后通过 name 字段去做查询，查看执行计划。
mysql> explain select * from user where name='name1'; +----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------+| 1 | SIMPLE | user | NULL | ref | idx_name | idx_name | 111 | const | 2 | 100.00 | NULL | +----+-------------+-------+------------+------+---------------+----------+---------+-------+------+----------+-------+1 row in set, 1 warning (0.01 sec)复制代码
可以看到，执行计划中 key_len 一列的值为 111。
根据上述索引长度的计算公式，name 列字段定义长度为36，字符集类型为默认的 utf8，该字段默认允许 NULL，同时该字段是可变长字段 varchar。
所以 idx_name 索引的索引长度=36*3+1+2=111，恰如执行计划中显示的值。
对于定长类型的字段，其索引长度与它的数据类型长度是一致的。
| 数据类型 | 长度 |
|---|---|
| int | 4 |
| bigint | 8 |
| date | 3 |
| datetime | 8 |
| timestamp | 4 |
| float | 4 |
| double | 8 |
需要注意的是，若该字段允许默认值为 NULL，与字符类型一样，其索引长度也需要加上1。
mysql> explain select * from user where age=1; +----+-------------+-------+------------+------+---------------+--------------+---------+-------+-------+----------+-------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra | +----+-------------+-------+------------+------+---------------+--------------+---------+-------+-------+----------+-------+| 1 | SIMPLE | user | NULL | ref | idx_age_name | idx_age_name | 5 | const | 39366 | 100.00 | NULL | +----+-------------+-------+------------+------+---------------+--------------+---------+-------+-------+----------+-------+1 row in set, 1 warning (0.00 sec)复制代码
如上面这个示例（本示例中索引只用到了 age 字段），age 字段为 int 类型，其索引长度本应为 4，但由于 age 字段默认允许为 NULL，所以它的索引长度就变成了5。
扫描行数在执行计划中其实是一个估值，MySQL 会选择 N 个不同的索引数据页，计算平均值得到单页索引基数，然后再乘以索引页面数，就得到了扫描行数的估值。
扫描行数就是优化器考量索引执行效率的因素之一，一般而言扫描行数越少，执行效率越高。
执行计划中 Extra 字段的常见类型有：
Using index: 使用了覆盖索引，以避免回表Using index condition: 使用了索引下推，具体可以看我的上一篇博客 —— 我所理解的MySQL(二)索引Using where: 表示MySQL 会通过 where 条件过滤记录Using temporary: MySQL 在对查询结果排序时会使用临时表
Using filesort: 对结果进行外部索引排序（文件排序），排序不走索引相关免费学习推荐：mysql数据库(视频)
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
mysql modifier le nom de la table de données
MySQL crée une procédure stockée
La différence entre MongoDB et MySQL
Comment vérifier si le mot de passe MySQL est oublié
mysql créer une base de données
niveau d'isolement des transactions par défaut de MySQL
La différence entre sqlserver et mysql
mysqlmot de passe oublié
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
