Quelles sont les connaissances de base sur la mise en cache des requêtes dans MySQL ?

Qu'est-ce que le cache de requêtes ?

Le cache de requêtes MySQL, bien que obsolète dans MySQL 5.7 (et supprimé dans 8.0), stocke les instructions précédemment exécutées en mémoire : en d'autres termes, le cache de requêtes stocke généralement les instructions SELECT dans la mémoire de la base de données. Ainsi, si nous exécutons une requête, puis réexécutons exactement la même requête quelque temps plus tard, les résultats seront renvoyés plus rapidement car ils seront récupérés de la mémoire plutôt que du disque.

Le cache de requêtes met en cache les requêtes et les ensembles de résultats. Ainsi, lorsque nous exécutons la même requête, les résultats de la requête mis en cache sont renvoyés immédiatement. La taille du cache de requêtes peut être contrôlée en définissant la variable système query_cache_size, mais voici une mise en garde : si vous souhaitez que les requêtes utilisent le cache de requêtes, elles doivent être identiques, octet par octet. Cela signifie que même si vous pensez que ces deux requêtes doivent être mises en cache exactement de la même manière :

SELECT * FROM demo_table WHERE column = 'Demo'; SELECT * FROM demo_table WHERE column = 'Demo'; 
select * from demo_table where column = 'Demo';

事实上，他们不是。如果 MySQL 查询缓存要求所有查询必须完全相同，那么即使只有一个字节不同，也不会返回任何结果。

所以，总结一下，当 MySQL 执行语句时，它做的第一件事就是检查是否启用了查询缓存（如果需要复习，请回到我们上一篇关于慢速 MySQL 查询的博客文章。）如果查询缓存启用后，MySQL 将首先检查与该查询的任何相关匹配项；如果没有匹配项，MySQL 将继续下一步。若匹配项存在重复，MySQL会从查询缓存中返回结果。

MySQL内部的查询缓存

在此之前返回比赛，MySQL的查询缓存要求MySQL的确认：d OES该用户有必要的权限才能完成这样的动作？我应该拒绝执行查询吗？

以下是 MySQL 检查的权限列表：

Donc, pour résumer, lorsque MySQL exécute une instruction, la première chose qu'il fait est de vérifier si le cache des requêtes est activé (si vous avez besoin d'un rappel, revenez à notre article de blog précédent sur les requêtes MySQL lentes.) Si Quand la mise en cache des requêtes est activée, MySQL vérifiera d'abord toutes les correspondances pertinentes avec la requête ; s'il n'y a pas de correspondance, MySQL passera à l'étape suivante. S'il y a des correspondances en double, MySQL renverra les résultats du cache de requêtes.

特权	简要说明
ALL	赋予特定 MySQL 用户所有权限。
SELECT	授予特定 MySQL 用户从指定数据库中选择行的权限。
UPDATE	授予特定 MySQL 用户更新指定表中现有行的权限。
SHOW DATABASES	使特定 MySQL 用户能够获取存在于一个特定 MySQL 实例中的所有 MySQL 数据库的列表。
USAGEselect * from demo_table Where column = ' Démo';	En fait, ils ne le sont pas. Si le cache de requêtes MySQL exige que toutes les requêtes soient identiques, aucun résultat ne sera renvoyé même s'ils diffèrent d'un seul octet.

Cache de requêtes interne MySQL

Avant de revenir au match, le cache de requêtes de MySQL nécessite une confirmation de MySQL : d OES Cet utilisateur dispose-t-il des autorisations nécessaires pour effectuer une telle action ? Dois-je refuser d’exécuter la requête ?

Voici la liste des autorisations vérifiées par MySQL : PrivilègesTOUSAccorde à des utilisateurs MySQL spécifiques l'autorisation de sélectionner des lignes dans la base de données spécifiée. USAGE a plus de privilèges, mais vous voyez l'idée. MySQL stocke les informations relatives aux tables ainsi que les requêtes mises en cache, les autorisations sont donc essentielles pour la mise en cache des requêtes. Les autorisations sont également importantes car elles constituent l'une des premières étapes du processus de vérification des résultats MySQL. Voici comment tout cela fonctionne : Explication

	Brève description
Donne toutes les autorisations à un utilisateur MySQL spécifique.		SELECT
	UPDATE	Accorde l'autorisation à un utilisateur MySQL spécifique de mettre à jour les lignes existantes dans la table spécifiée.
AFFICHER LES BASES DE DONNÉES	Permet à un utilisateur MySQL spécifique d'obtenir une liste de toutes les bases de données MySQL qui existent dans une instance MySQL spécifique.
Donne à l'utilisateur le pouvoir d'utiliser MySQL uniquement, ce qui signifie que l'utilisateur ne peut y exécuter aucune requête. Essentiellement synonyme d’aucun privilège.
		Identification prioritaire
Statut MYSQL

🎜1🎜🎜MySQL vérifie les autorisations dans le cache de requêtes. 🎜🎜Tout d'abord, MySQL vérifie si un utilisateur spécifique est autorisé à accéder à un résultat spécifique. 🎜🎜🎜🎜2🎜🎜MySQL vérifie le cache de requêtes pour la requête elle-même. 🎜🎜Ensuite, MySQL commence à vérifier si la même requête existe dans le cache de requêtes. S'il y a une correspondance, MySQL revient ; sinon, MySQL passe à l'étape suivante. 🎜🎜🎜🎜3🎜🎜MySQL marque l'entrée dans le cache de requêtes comme invalide. 🎜🎜À mesure que la table change, le cache des requêtes doit être mis à jour. Ainsi, à cette étape, MySQL décide de marquer l’entrée dans le cache de requêtes comme invalide. 🎜🎜🎜🎜4🎜🎜Envoyer les résultats. 🎜🎜MySQL envoie le résultat mis en cache et l'affiche. 🎜🎜🎜🎜5🎜🎜 Stocke les résultats dans le cache. 🎜🎜MySQL enregistre les résultats des requêtes dans le cache des requêtes. 🎜🎜🎜🎜6🎜🎜Le cache des requêtes est verrouillé. 🎜🎜Le processus de mise en cache est maintenant terminé - MySQL verrouille le cache des requêtes. 🎜🎜🎜🎜

"MySql n'a pas de cache !" : Cela dépend si le cache des requêtes est endommagé ?

Si nous utilisons une variable dans la requête, que ce soit dans l'état de fonction ou de partition, le cache de requête deviendra invalide. Par exemple, si nous traitons du Big Data et que nous utilisons SELECT ... INTO OUTFILE pour charger un grand ensemble de données dans MySQL, les résultats ne seront pas non plus mis en cache. Normalement, le cache de requêtes ne fonctionne pas lors de l'utilisation de requêtes telles que SELECT ... [LOCK | FOR INTO], et le cache de requêtes ne fonctionne pas non plus si nous vérifions la valeur AUTO_INCREMENT dans une colonne avec une valeur NULL, cela signifie que si nous Il y a une colonne d'incrémentation avec AUTO_INCREMENT, et nous exécutons une requête comme celle-ci :

SELECT * FROM demo_table WHERE increment IS NULL;

Le cache des requêtes ne prendra pas effet non plus.

Vous avez raison, toutes ces fonctionnalités peuvent donner l'impression à certaines personnes qu'elles sont inutiles. Bien que, comme les autres fonctionnalités de MySQL, le cache de requêtes ait ses propres limites et ne fonctionne donc pas toujours. En plus de ceux mentionnés ci-dessus, il refuse de fonctionner lorsque l'instruction génère des avertissements ou lorsque l'instruction est exécutée sur une table avec un moteur de stockage TEMPORAIRE et dans certains autres cas particuliers. Chaque fois que quelqu'un écrit quelque chose dans la table, le cache des requêtes est également vidé.

La fonctionnalité du cache de requêtes dépend également du paramètre query_cache_size. Plus ce paramètre est grand, mieux c'est, mais veuillez noter que ce paramètre dépend fortement de votre mémoire. Gardez à l'esprit que la structure de base du cache de requêtes nécessite au moins 40 Ko de stockage par défaut et que sa valeur par défaut peut être comprise entre 1 Mo et 16 Mo. Si votre base de données lit fréquemment des données, augmenter la valeur du paramètre peut aider à trouver la meilleure solution, mais essayez à nouveau.

Vous pouvez utiliser l'instruction "RESET QUERY CACHE" pour effacer tout le contenu du cache de requêtes. Si vous utilisez une instruction telle que FLUSH TABLES, toutes les valeurs du cache de requêtes seront également supprimées.

MySQL vous permet même de voir combien de requêtes sont stockées dans le cache de requêtes en exécutant la requête :

SHOW STATUS LIKE 'Qcache_queries_in_cache%';

Vous obtiendrez des résultats qui ressemblent à ceci :

MySQL :

+-------------------------+--------+
| Variable_name           | Value  |
+-------------------------+--------+
| Qcache_queries_in_cache | 1      |
+-------------------------+--------+

Dans ce cas, nous pouvons voir notre le cache de requête met actuellement en cache un résultat. Exécutez une instruction comme FLUSH TABLES et toutes les valeurs disparaîtront.

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!