En plus des index, quels autres facteurs ralentissent les requêtes MySQL ?

Je maîtrise l'utilisation de ctrl c et ctrl v pour développer du code caillé depuis de nombreuses années.

Pourquoi les requêtes MySQL sont-elles lentes ? Ce problème est souvent rencontré dans le développement réel, et c'est également une question fréquemment posée dans les entretiens.

Quand on rencontre ce genre de problème, on pense généralement que c'est à cause de l'index.

En plus des index, quels autres facteurs peuvent ralentir les requêtes de base de données ?

Quelles opérations peuvent améliorer les capacités de requête de MySQL ?

Dans l'article d'aujourd'hui, nous parlerons des scénarios qui peuvent entraîner un ralentissement des requêtes de base de données, et donnerons les raisons et les solutions.

Processus de requête de base de données

Jetons d'abord un coup d'œil aux processus par lesquels une instruction de requête passera.

Par exemple, nous avons une table de base de données

CREATE TABLE `user` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(100) NOT NULL DEFAULT '' COMMENT '名字',
  `age` int(11) NOT NULL DEFAULT '0' COMMENT '年龄',
  `gender` int(8) NOT NULL DEFAULT '0' COMMENT '性别',
  PRIMARY KEY (`id`),
  KEY `idx_age` (`age`),
  KEY `idx_gender` (`gender`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Le code d'application que nous écrivons habituellement (go ou C++, etc.) s'appelle client à ce moment.

La couche inférieure du client prendra le mot de passe du compte et tentera d'établir un lien long TCP vers MySQL.

le module de gestion des connexions de mysql gérera cette connexion.

Après avoir établi la connexion, le client exécute une instruction SQL de requête. Par exemple :

select * from user where gender = 1 and age = 100;

Le client connectera l'instruction SQL à MySQL via le réseau.

Une fois que mysql a reçu l'instruction sql, il déterminera d'abord s'il y a des erreurs grammaticales dans l'instruction SQL dans le analyzer, comme select S'il y a un l de moins, il sera écrit. en slect, une erreur Vous avez une erreur dans votre syntaxe SQL ; sera signalée. On peut dire que ce rapport d'erreur est très familier à une personne handicapée comme moi. l，写成slect，则会报错You have an error in your SQL syntax;。这个报错对于我这样的手残党来说可以说是很熟悉了。

接下来是优化器，在这里会根据一定的规则选择该用什么索引。

之后，才是通过执行器去调用存储引擎的接口函数。

存储引擎类似于一个个组件，它们才是mysql真正获取一行行数据并返回数据的地方，存储引擎是可以替换更改的，既可以用不支持事务的MyISAM，也可以替换成支持事务的Innodb。这个可以在建表的时候指定。比如

CREATE TABLE `user` (
  ...
) ENGINE=InnoDB;

现在最常用的是InnoDB。

我们就重点说这个。

InnoDB中，因为直接操作磁盘会比较慢，所以加了一层内存提提速，叫buffer pool，这里面，放了很多内存页，每一页16KB，有些内存页放的是数据库表里看到的那种一行行的数据，有些则是放的索引信息。

查询SQL到了InnoDB中。会根据前面优化器里计算得到的索引，去查询相应的索引页，如果不在buffer pool里则从磁盘里加载索引页。再通过索引页加速查询，得到数据页的具体位置。如果这些数据页不在buffer pool中，则从磁盘里加载进来。

这样我们就得到了我们想要的一行行数据。

最后将得到的数据结果返回给客户端。

慢查询分析

如果上面的流程比较慢的话，我们可以通过开启profiling看到流程慢在哪。

mysql> set profiling=ON;
Query OK, 0 rows affected, 1 warning (0.00 sec)

mysql> show variables like 'profiling';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| profiling     | ON    |
+---------------+-------+
1 row in set (0.00 sec)

然后正常执行sql语句。

这些SQL语句的执行时间都会被记录下来，此时你想查看有哪些语句被记录下来了，可以执行 show profiles;

mysql> show profiles;
+----------+------------+---------------------------------------------------+
| Query_ID | Duration   | Query                                             |
+----------+------------+---------------------------------------------------+
|        1 | 0.06811025 | select * from user where age>=60                  |
|        2 | 0.00151375 | select * from user where gender = 2 and age = 80  |
|        3 | 0.00230425 | select * from user where gender = 2 and age = 60  |
|        4 | 0.00070400 | select * from user where gender = 2 and age = 100 |
|        5 | 0.07797650 | select * from user where age!=60                  |
+----------+------------+---------------------------------------------------+
5 rows in set, 1 warning (0.00 sec)

关注下上面的query_id，比如select * from user where age>=60对应的query_id是1，如果你想查看这条SQL语句的具体耗时，那么可以执行以下的命令。

mysql> show profile for query 1;
+----------------------+----------+
| Status               | Duration |
+----------------------+----------+
| starting             | 0.000074 |
| checking permissions | 0.000010 |
| Opening tables       | 0.000034 |
| init                 | 0.000032 |
| System lock          | 0.000027 |
| optimizing           | 0.000020 |
| statistics           | 0.000058 |
| preparing            | 0.000018 |
| executing            | 0.000013 |
| Sending data         | 0.067701 |
| end                  | 0.000021 |
| query end            | 0.000015 |
| closing tables       | 0.000014 |
| freeing items        | 0.000047 |
| cleaning up          | 0.000027 |
+----------------------+----------+
15 rows in set, 1 warning (0.00 sec)

通过上面的各个项，大家就可以看到具体耗时在哪。比如从上面可以看出Sending data的耗时最大，这个是指执行器开始查询数据并将数据发送给客户端的耗时，因为我的这张表符合条件的数据有好几万条，所以这块耗时最大，也符合预期。

一般情况下，我们开发过程中，耗时大部分时候都在Sending data

La prochaine étape est l'🎜optimiseur🎜, où il 🎜sélectionnera l'index à utiliser en fonction de certaines règles🎜. 🎜🎜Après cela, la fonction d'interface du 🎜moteur de stockage🎜 est appelée via l'🎜exécuteur🎜. 🎜🎜🎜🎜🎜Les moteurs de stockage🎜 sont similaires aux composants. C'est là que MySQL obtient réellement des lignes de données et renvoie des données. Le moteur de stockage peut être remplacé et modifié par MyISAM, qui ne prend pas en charge les transactions, ou par Innodb, qui prend en charge les transactions. Cela peut être spécifié lors de la création de la table. Par exemple, 🎜

mysql> set global max_connections= 500;
Query OK, 0 rows affected (0.00 sec)

mysql> show variables like 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 500   |
+-----------------+-------+
1 row in set (0.00 sec)

🎜le plus couramment utilisé actuellement est 🎜InnoDB🎜. 🎜🎜Concentrons-nous là-dessus. 🎜🎜Dans InnoDB, parce que le fonctionnement direct du disque sera lent, une couche de mémoire est ajoutée pour accélérer, appelée 🎜buffer pool🎜. Il contient de nombreuses pages mémoire, chaque page fait 16 Ko. Certaines pages mémoire contiennent des tables de base de données. Le type de données ligne par ligne que vous voyez dans , et certaines d'entre elles contiennent des informations d'index. 🎜🎜🎜🎜Requête SQL vers InnoDB. Sur la base de l'index calculé dans l'optimiseur précédent, la page d'index correspondante sera interrogée. Si elle ne se trouve pas dans le pool de tampons, la page d'index sera chargée à partir du disque. 🎜Accélérez ensuite la requête via la page d'index et obtenez l'emplacement spécifique de la page de données🎜. Si ces pages de données ne se trouvent pas dans le pool de mémoire tampon, elles sont chargées à partir du disque. 🎜🎜De cette façon, nous obtenons les lignes de données que nous souhaitons. 🎜🎜🎜🎜Enfin, les résultats des données obtenues sont renvoyés au client. 🎜

🎜Analyse lente des requêtes🎜🎜🎜Si le processus ci-dessus est lent, nous pouvons voir où le processus est lent en activant le profilage. 🎜

func Init() {
  db, err := gorm.Open(mysql.Open(conn), config)
  sqlDB, err := db.DB()
  // SetMaxIdleConns 设置空闲连接池中连接的最大数量
  sqlDB.SetMaxIdleConns(200)
  // SetMaxOpenConns 设置打开数据库连接的最大数量
  sqlDB.SetMaxOpenConns(1000)
}

🎜Ensuite, exécutez l'instruction SQL normalement. 🎜🎜Le temps d'exécution de ces instructions SQL sera enregistré. À ce moment, si vous souhaitez voir quelles instructions ont été enregistrées, vous pouvez exécuter show profiles ;🎜

mysql> show global variables like 'innodb_buffer_pool_size';
+-------------------------+-----------+
| Variable_name           | Value     |
+-------------------------+-----------+
| innodb_buffer_pool_size | 134217728 |
+-------------------------+-----------+
1 row in set (0.01 sec)

🎜Faites attention à ce qui précède query_id, par exemple, le query_id correspondant à select * from user où age>=60 est 1. Si vous souhaitez vérifier la consommation de temps spécifique de cette instruction SQL, vous pouvez exécutez la commande suivante. 🎜

mysql> set global innodb_buffer_pool_size = 536870912;
Query OK, 0 rows affected (0.01 sec)

mysql> show global variables like 'innodb_buffer_pool_size';
+-------------------------+-----------+
| Variable_name           | Value     |
+-------------------------+-----------+
| innodb_buffer_pool_size | 536870912 |
+-------------------------+-----------+
1 row in set (0.01 sec)

🎜Grâce aux éléments ci-dessus, vous pouvez voir où le temps spécifique est passé. Par exemple, on peut voir ci-dessus que l'envoi de données prend le plus de temps. Cela fait référence au temps qu'il faut à l'exécuteur pour commencer à interroger les données et à envoyer les données au client, car ma table contient des dizaines de milliers de qualifications. data , c'est donc cette partie qui prend le plus de temps et est conforme aux attentes. 🎜🎜Généralement, au cours de notre processus de développement, la plupart du temps est passé à l'étape Envoi des données Si elle est lente à ce stade, la raison la plus probable à laquelle il faut penser est celle liée à l'index. 🎜

Raisons liées à l'index

Les problèmes liés à l'index peuvent généralement être analysés à l'aide de la commande expliquer. Grâce à lui, vous pouvez voir quels index sont utilisés, et probablement combien de lignes seront analysées ainsi que d'autres informations.

mysql examinera quel index choisir dans la phase d'optimisation, et la vitesse de requête sera plus rapide.

Généralement, plusieurs facteurs sont principalement pris en compte, tels que :

• Combien de lignes (lignes) doivent être analysées pour sélectionner cet index Afin d'extraire ces lignes, combien de pages de 16 Ko doivent être lues
• Utilisation ? un retour de table d'index normal est requis, mais l'index de clé primaire ne l'est pas Combien coûte le retour de la table ?
• Retour à l'instruction SQL mentionnée dans le profil d'émission, nous utilisons explain select * from user Where age>=60 pour l'analyser.

L'instruction ci-dessus utilise type comme ALL, ce qui signifie explain select * from user where age>=60 分析一下。

上面的这条语句，使用的type为ALL，意味着是全表扫描，possible_keys是指可能用得到的索引，这里可能使用到的索引是为age建的普通索引，但实际上数据库使用的索引是在key那一列，是NULL。也就是说这句sql不走索引，全表扫描。

这个是因为数据表里，符合条件的数据行数（rows）太多，如果使用age索引，那么需要将它们从age索引中读出来，并且age索引是普通索引，还需要回表找到对应的主键才能找到对应的数据页。算下来还不如直接走主键划算。于是最终选择了全表扫描。

当然上面只是举了个例子，实际上，mysql执行sql时，不用索引或者用的索引不符合我们预期这件事经常发生，索引失效的场景有很多，比如用了不等号，隐式转换等，这个相信大家背八股文的时候也背过不少了，我也不再赘述。

聊两个生产中容易遇到的问题吧。

索引不符合预期

实际开发中有些情况比较特殊，比如有些数据库表一开始数据量小，索引少，执行sql时，确实使用了符合你预期的索引。但随时时间边长，开发的人变多了，数据量也变大了，甚至还可能会加入一些其他重复多余的索引，就有可能出现用着用着，用到了不符合你预期的其他索引了。从而导致查询突然变慢。

这种问题，也好解决，可以通过force index指定索引。比如

通过explain可以看出，加了force index之后，sql就选用了idx_age这个索引了。

走了索引还是很慢

有些sql，用explainScan complet de la table

, possible_keys fait référence aux

index éventuellement utilisés. Les index qui peuvent être utilisés ici sont des index ordinaires construits pour l'âge, mais en fait l'index utilisé par la base de données est dans la colonne keyThe code>. est NULL. En d'autres termes, ce sql n'utilise pas l'index, mais analyse la table entière. Cela est dû au fait qu'il y a trop de lignes de données qualifiées (rows) dans le tableau de données. Si vous utilisez l'index d'âge, vous devez les lire à partir de l'index d'âge, et l'index d'âge est. Index normal

, vous devez également

revenir au tableau pour trouver la

clé primaire

correspondante pour trouver la page de données correspondante. Après tout, ce n’est pas aussi rentable que d’utiliser directement la clé primaire. J'ai donc finalement choisi une analyse de table complète.

Bien sûr, ce qui précède n'est qu'un exemple. En fait, lorsque MySQL exécute SQL, aucun index n'est utilisé ou l'index utilisé ne répond pas à nos attentesCela arrive souvent dans lequel l'index échoue, comme par exemple. en utilisant le

signe inégal, en masquant la conversion de formule

, etc. Je pense que vous l'avez beaucoup mémorisé lors de la mémorisation d'essais en huit parties, je n'entrerai donc pas dans les détails.

🎜Parlons de deux problèmes que l’on rencontre facilement en production. 🎜

🎜L'index ne répond pas aux attentes🎜

🎜Dans le développement réel, certaines situations sont particulières. Par exemple, certaines tables de base de données ont un petit volume de données et peu d'index au niveau. au début. Lors de l'exécution de SQL, utilisez effectivement l'index que vous attendiez. Mais au fil du temps, de plus en plus de personnes se développent, la quantité de données devient plus importante et d'autres index répétitifs et redondants peuvent même être ajoutés. Il peut arriver que d'autres index qui ne répondent pas à vos attentes soient utilisés. Cela provoque un ralentissement soudain des requêtes. 🎜🎜Ce type de problème peut être facilement résolu en spécifiant l'index via force index🎜. Par exemple 🎜🎜🎜🎜On peut voir à partir de explain qu'après avoir ajouté l'index de force, sql. utilisera L'index idx_age est ajouté. 🎜

🎜C'est toujours très lent même après indexation🎜

🎜Pour certains SQL, si vous utilisez la commande explain, c'est évidemment indexé, mais c'est encore très lent. Il existe généralement deux situations : 🎜🎜La première est que la distinction d'index est trop faible. Par exemple, le chemin complet du lien URL de la page web est utilisé pour l'indexation. En un coup d'œil, ce sont tous le même nom de domaine. . Si la longueur de l'🎜index du préfixe🎜 n'est pas assez longue, alors l'indexation est similaire à l'analyse de la table complète🎜. L'approche correcte est d'essayer d'augmenter la 🎜différenciation 🎜 de l'index. Par exemple, supprimez le nom de domaine et utilisez uniquement la partie URI suivante pour l'indexation. 🎜🎜🎜🎜🎜La seconde est que les données correspondantes dans l'index sont trop volumineuses, ce à quoi il faut prêter attention, c'est le champ 🎜rows🎜 dans l'explication. 🎜🎜Il est utilisé pour 🎜estimer🎜le nombre de lignes qui doivent être vérifiées pour cette instruction de requête. Cela n'est peut-être pas complètement précis, mais cela peut refléter une ampleur approximative. 🎜🎜Lorsqu'il est très important, les situations suivantes sont généralement courantes. 🎜

• 如果这个字段具有唯一的属性，比如电话号码等，一般是不应该有大量重复的，那可能是你代码逻辑出现了大量重复插入的操作，你需要检查下代码逻辑，或者需要加个唯一索引限制下。
• 如果这个字段下的数据就是会很大，是否需要全部拿？如果不需要，加个limit限制下。如果确实要拿全部，那也不能一次性全拿，今天你数据量小，可能一次取一两万都没啥压力，万一哪天涨到了十万级别，那一次性取就有点吃不消了。你可能需要分批次取，具体操作是先用order by id排序一下，拿到一批数据后取最大id作为下次取数据的起始位置。

连接数过小

索引相关的原因我们聊完了，我们来聊聊，除了索引之外，还有哪些因素会限制我们的查询速度的。

我们可以看到，mysql的server层里有个连接管理，它的作用是管理客户端和mysql之间的长连接。

正常情况下，客户端与server层如果只有一条连接，那么在执行sql查询之后，只能阻塞等待结果返回，如果有大量查询同时并发请求，那么后面的请求都需要等待前面的请求执行完成后，才能开始执行。

因此很多时候我们的应用程序，比如go或java这些，会打印出sql执行了几分钟的日志，但实际上你把这条语句单独拎出来执行，却又是毫秒级别的。 这都是因为这些sql语句在等待前面的sql执行完成。

怎么解决呢？

如果我们能多建几条连接，那么请求就可以并发执行，后面的连接就不用等那么久了。

而连接数过小的问题，受数据库和客户端两侧同时限制。

数据库连接数过小

mysql的最大连接数默认是100, 最大可以达到16384。

可以通过设置mysql的max_connections参数，更改数据库的最大连接数。

mysql> set global max_connections= 500;
Query OK, 0 rows affected (0.00 sec)

mysql> show variables like 'max_connections';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 500   |
+-----------------+-------+
1 row in set (0.00 sec)

上面的操作，就把最大连接数改成了500。

应用侧连接数过小

数据库连接大小是调整过了，但貌似问题还是没有变化？还是有很多sql执行达到了几分钟，甚至超时？

那有可能是因为你应用侧（go，java写的应用，也就是mysql的客户端）的连接数也过小。

应用侧与mysql底层的连接，是基于TCP协议的长链接，而TCP协议，需要经过三次握手和四次挥手来实现建连和释放。如果我每次执行sql都重新建立一个新的连接的话，那就要不断握手和挥手，这很耗时。所以一般会建立一个长连接池，连接用完之后，塞到连接池里，下次要执行sql的时候，再从里面捞一条连接出来用，非常环保。

我们一般写代码的时候，都会通过第三方的orm库来对数据库进行操作，而成熟的orm库，百分之一千万都会有个连接池。

而这个连接池，一般会有个大小。这个大小就控制了你的连接数最大值，如果说你的连接池太小，都还没有数据库的大，那调了数据库的最大连接数也没啥作用。

一般情况下，可以翻下你使用的orm库的文档，看下怎么设置这个连接池的大小，就几行代码的事情，改改就好。比如go语言里的gorm里是这么设置的

func Init() {
  db, err := gorm.Open(mysql.Open(conn), config)
  sqlDB, err := db.DB()
  // SetMaxIdleConns 设置空闲连接池中连接的最大数量
  sqlDB.SetMaxIdleConns(200)
  // SetMaxOpenConns 设置打开数据库连接的最大数量
  sqlDB.SetMaxOpenConns(1000)
}

buffer pool太小

连接数是上去了，速度也提升了。

曾经遇到过面试官会追问，有没有其他办法可以让速度更快呢？

那必须要眉头紧锁，假装思考，然后说：有的。

我们在前面的数据库查询流程里，提到了进了innodb之后，会有一层内存buffer pool，用于将磁盘数据页加载到内存页中，只要查询到buffer pool里有，就可以直接返回，否则就要走磁盘IO，那就慢了。

也就是说，如果我的buffer pool 越大，那我们能放的数据页就越多，相应的，sql查询时就更可能命中buffer pool，那查询速度自然就更快了。

可以通过下面的命令查询到buffer pool的大小，单位是Byte。

mysql> show global variables like 'innodb_buffer_pool_size';
+-------------------------+-----------+
| Variable_name           | Value     |
+-------------------------+-----------+
| innodb_buffer_pool_size | 134217728 |
+-------------------------+-----------+
1 row in set (0.01 sec)

也就是128Mb。

如果想要调大一点。可以执行

mysql> set global innodb_buffer_pool_size = 536870912;
Query OK, 0 rows affected (0.01 sec)

mysql> show global variables like 'innodb_buffer_pool_size';
+-------------------------+-----------+
| Variable_name           | Value     |
+-------------------------+-----------+
| innodb_buffer_pool_size | 536870912 |
+-------------------------+-----------+
1 row in set (0.01 sec)

这样就把buffer pool增大到512Mb了。

但是吧，如果buffer pool大小正常，只是别的原因导致的查询变慢，那改buffer pool毫无意义。

但问题又来了。

怎么知道buffer pool是不是太小了？

这个我们可以看buffer pool的缓存命中率。

通过 show status like 'Innodb_buffer_pool_%';可以看到跟buffer pool有关的一些信息。

Innodb_buffer_pool_read_requests表示读请求的次数。

Innodb_buffer_pool_reads 表示从物理磁盘中读取数据的请求次数。

所以buffer pool的命中率就可以这样得到：

buffer pool 命中率 = 1 - (Innodb_buffer_pool_reads/Innodb_buffer_pool_read_requests) * 100%

比如我上面截图里的就是，1 - (405/2278354) = 99.98%。可以说命中率非常高了。

一般情况下buffer pool命中率都在99%以上，如果低于这个值，才需要考虑加大innodb buffer pool的大小。

当然，还可以把这个命中率做到监控里，这样半夜sql变慢了，早上上班还能定位到原因，就很舒服。

还有哪些骚操作？

前面提到的是在存储引擎层里加入了buffer pool用于缓存内存页，这样可以加速查询。

那同样的道理，server层也可以加个缓存，直接将第一次查询的结果缓存下来，这样下次查询就能立刻返回，听着挺美的。

按道理，如果命中缓存的话，确实是能为查询加速的。但这个功能限制很大，其中最大的问题是只要数据库表被更新过，表里面的所有缓存都会失效，数据表频繁的更新，就会带来频繁的缓存失效。所以这个功能只适合用于那些不怎么更新的数据表。

另外，这个功能在8.0版本之后，就被干掉了。所以这功能用来聊聊天可以，没必要真的在生产中使用啊。

总结

• 数据查询过慢一般是索引问题，可能是因为选错索引，也可能是因为查询的行数太多。
• 客户端和数据库连接数过小，会限制sql的查询并发数，增大连接数可以提升速度。
• innodb里会有一层内存buffer pool用于提升查询速度，命中率一般>99%，如果低于这个值，可以考虑增大buffer pool的大小，这样也可以提升速度。
• 查询缓存（query cache）确实能为查询提速，但一般不建议打开，因为限制比较大，并且8.0以后的mysql里已经将这个功能干掉了。

最后

最近原创更文的阅读量稳步下跌，思前想后，夜里辗转反侧。

我有个不成熟的请求。

离开广东好长时间了，好久没人叫我靓仔了。

大家可以在评论区里，叫我一靓仔吗？

我这么善良质朴的愿望，能被满足吗？

如果实在叫不出口的话，能帮我点下右下角的点赞和在看吗？

【相关推荐：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!