MariaDB
 sql >> Base de données >  >> RDS >> MariaDB

Comprendre les index dans MySQL :troisième partie

Cet article de blog est la troisième partie d'une série de blogs sur les index dans MySQL . Dans la deuxième partie de la série d'articles de blog sur les index MySQL , nous avons couvert les index et les moteurs de stockage et abordé certaines considérations relatives à la CLÉ PRIMAIRE. La discussion a porté sur la façon de faire correspondre un préfixe de colonne, certaines considérations d'index FULLTEXT, et comment vous devez utiliser les index B-Tree avec des caractères génériques et comment utiliser ClusterControl pour surveiller les performances de vos requêtes, par la suite, les index.

 

Dans cet article de blog, nous aborderons plus en détail les index dans MySQL :nous couvrirons les index de hachage, la cardinalité des index, la sélectivité des index, nous vous donnerons des détails intéressants sur la couverture des index, et nous passerons également en revue certaines stratégies d'indexation. Et, bien sûr, nous aborderons ClusterControl. Commençons, d'accord ?

Hash Index dans MySQL

Les administrateurs de bases de données MySQL et les développeurs traitant de MySQL ont également un autre tour dans leur sac en ce qui concerne MySQL :les index de hachage sont également une option. Les index de hachage sont fréquemment utilisés dans le moteur MEMORY de MySQL - comme avec à peu près tout dans MySQL, ces types d'index ont leurs propres avantages et inconvénients. Le principal inconvénient de ces types d'index est qu'ils ne sont utilisés que pour les comparaisons d'égalité qui utilisent les opérateurs =ou <=>, ce qui signifie qu'ils ne sont pas vraiment utiles si vous souhaitez rechercher une plage de valeurs, mais le principal avantage est que les recherches sont très rapides. Quelques autres inconvénients incluent le fait que les développeurs ne peuvent pas utiliser le préfixe le plus à gauche de la clé pour trouver des lignes (si vous voulez faire cela, utilisez plutôt les index B-Tree), le fait que MySQL ne peut pas déterminer approximativement le nombre de lignes il y a entre deux valeurs - si des index de hachage sont utilisés, l'optimiseur ne peut pas non plus utiliser un index de hachage pour accélérer les opérations ORDER BY. Gardez à l'esprit que les index de hachage ne sont pas la seule chose que le moteur MEMORY prend en charge - les moteurs MEMORY peuvent également avoir des index B-Tree.

Cardinalité d'index dans MySQL

En ce qui concerne les index MySQL, vous pouvez également entendre un autre terme circuler - ce terme est appelé index cardinalité. En termes très simples, la cardinalité d'index fait référence à l'unicité des valeurs stockées dans une colonne qui utilise un index. Pour afficher la cardinalité d'index d'un index spécifique, vous pouvez simplement vous rendre dans l'onglet Structure de phpMyAdmin et y observer les informations ou vous pouvez également exécuter une requête SHOW INDEXES :

mysql> SHOW INDEXES FROM demo_table;
+---------------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| Table         | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment | Index_comment |
+---------------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
| demo_table |          1 | demo     |            1 | demo        | A         |      494573 |     NULL | NULL   |      | BTREE      |         |               |
+---------------+------------+----------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+---------------+
1 row in set (0.00 sec)

La sortie de la requête SHOW INDEXES que vous pouvez voir ci-dessus comporte de nombreux champs, dont l'un décrit la cardinalité de l'index :ce champ renvoie une estimation du nombre de valeurs uniques dans l'index - le plus la cardinalité est élevée, plus grande est la probabilité que l'optimiseur de requête utilise l'index pour les recherches. Cela étant dit, la cardinalité d'index a aussi un frère - son nom est la sélectivité d'index.

Sélectivité d'index dans MySQL

Une sélectivité d'index est le nombre de valeurs distinctes par rapport au nombre d'enregistrements dans la table. En termes simples, la sélectivité de l'index définit la précision avec laquelle un index de base de données aide MySQL à affiner la recherche de valeurs. Une sélectivité d'index idéale est la valeur de 1. Une sélectivité d'index est calculée en divisant les valeurs distinctes d'une table par le nombre total d'enregistrements, par exemple, si vous avez 1 000 000 d'enregistrements dans votre table, mais que seuls 100 000 d'entre eux sont des valeurs distinctes , votre sélectivité d'indice serait de 0,1. Si vous avez 10 000 enregistrements dans votre table et que 8 500 d'entre eux sont des valeurs distinctes, votre sélectivité d'index serait de 0,85. C'est beaucoup mieux. Tu obtiens le point. Plus la sélectivité de votre index est élevée, mieux c'est.

Couvrir les index dans MySQL

Un index de couverture est un type spécial d'index dans InnoDB. Lorsqu'un index de couverture est utilisé, tous les champs requis pour une requête sont inclus, ou « couverts », par l'index, ce qui signifie que vous pouvez également profiter des avantages de la lecture uniquement de l'index au lieu des données. Si rien d'autre ne vous aide, un index de couverture pourrait être votre ticket pour améliorer les performances. Certains des avantages de l'utilisation des index de couverture incluent :

  • L'un des principaux scénarios où un index de couverture peut être utile est de servir des requêtes sans lectures d'E/S supplémentaires sur de grandes tables.

  • MySQL peut également accéder à moins de données car les entrées d'index sont plus petites que la taille des lignes.

  • La plupart des moteurs de stockage mettent mieux en cache les index que les données.

Créer des index de couverture sur une table est assez simple - couvrez simplement les champs accessibles par les clauses SELECT, WHERE et GROUP BY :

ALTER TABLE demo_table ADD INDEX index_name(column_1, column_2, column_3);

Gardez à l'esprit que lorsqu'il s'agit de couvrir des index, il est très important de choisir le bon ordre des colonnes dans l'index. Pour que vos index de couverture soient efficaces, placez les colonnes que vous utilisez avec les clauses WHERE en premier, ORDER BY et GROUP BY ensuite et les colonnes utilisées avec la clause SELECT en dernier.

Stratégies d'indexation dans MySQL

Suivre les conseils couverts dans ces trois parties des articles de blog sur les index dans MySQL peut vous fournir une très bonne base, mais il existe également quelques stratégies d'indexation que vous pouvez utiliser si vous le souhaitez exploitez vraiment la puissance des index dans votre architecture MySQL. Pour que vos index respectent les bonnes pratiques de MySQL, pensez à :

  1. Isoler la colonne sur laquelle vous utilisez l'index - en général, MySQL n'utilise pas les index si les colonnes sur lesquelles ils sont utilisés sur ne sont pas isolés. Par exemple, une telle requête n'utiliserait pas d'index car elle n'est pas isolée :

    SELECT demo_column FROM demo_table WHERE demo_id + 1 = 10;


    Cependant, une telle requête :
     

    SELECT demo_column FROM demo_table WHERE demo_id = 10;

  2. N'utilisez pas d'index sur les colonnes que vous indexez. Par exemple, utiliser une requête comme celle-ci ne servirait à rien, il est donc préférable d'éviter de telles requêtes si vous le pouvez :
     

    SELECT demo_column FROM demo_table WHERE TO_DAYS(CURRENT_DATE) - TO_DAYS(column_date) <= 10;

  3. Si vous utilisez des requêtes LIKE avec des colonnes indexées, évitez de placer le caractère générique au début de la requête de recherche car de cette façon, MySQL n'utilisera pas non plus d'index. C'est au lieu d'écrire des requêtes comme ceci :

    SELECT * FROM demo_table WHERE demo_column LIKE ‘%search query%’;


    Envisagez de les écrire comme ceci :

    SELECT * FROM demo_table WHERE demo_column LIKE ‘search_query%’;


    La deuxième requête est meilleure car MySQL sait par quoi commence la colonne et peut utiliser les index plus efficacement. Comme pour tout, l'instruction EXPLAIN peut être d'une grande aide si vous voulez vous assurer que vos index sont réellement utilisés par MySQL.

Utiliser ClusterControl pour maintenir la performance de vos requêtes

Si vous souhaitez améliorer vos performances MySQL, les conseils ci-dessus devraient vous mettre sur la bonne voie. Si vous pensez avoir besoin de quelque chose de plus, pensez à ClusterControl pour MySQL. L'une des choses que ClusterControl peut vous aider à inclure la gestion des performances - comme déjà indiqué dans les articles de blog précédents, ClusterControl peut également vous aider à maintenir vos requêtes au mieux de leurs capacités tout le temps - c'est parce que ClusterControl inclut également une requête moniteur qui vous permet de surveiller les performances de vos requêtes, de voir les requêtes lentes et de longue durée et également d'interroger les valeurs aberrantes vous alertant des éventuels goulots d'étranglement dans les performances de votre base de données avant que vous ne puissiez les remarquer vous-même :

Vous pouvez même filtrer vos requêtes vous permettant de faire une hypothèse si un index a été utilisé par une requête individuelle ou non :

ClusterControl peut être un excellent outil pour améliorer les performances de votre base de données tout en vous libérant des tracas de maintenance. Pour en savoir plus sur ce que ClusterControl peut faire pour améliorer les performances de vos instances MySQL, pensez à consulter la page ClusterControl pour MySQL.

Résumé

Comme vous pouvez probablement le constater maintenant, les index dans MySQL sont une bête très complexe. Pour choisir le meilleur index pour votre instance MySQL, sachez ce que sont les index et ce qu'ils font, connaissez les types d'index MySQL, connaissez leurs avantages et leurs inconvénients, renseignez-vous sur la façon dont les index MySQL interagissent avec les moteurs de stockage, jetez également un œil à ClusterControl pour MySQL si vous pensez que l'automatisation de certaines tâches liées aux index dans MySQL pourrait vous faciliter la tâche.