Indexen in MySQL begrijpen:deel drie

Deze blogpost is het derde deel van de serie blogs over indexen in MySQL . In het tweede deel van de serie blogposts over MySQL-indexen hebben we indexen en opslagengines besproken en enkele PRIMAIRE BELANGRIJKE overwegingen aangehaald. De discussie omvatte hoe u een kolomvoorvoegsel kunt matchen, enkele FULLTEXT-indexoverwegingen, en hoe u B-Tree-indexen met jokertekens moet gebruiken en hoe u ClusterControl kunt gebruiken om de prestaties van uw zoekopdrachten en vervolgens indexen te controleren.

In deze blogpost gaan we dieper in op indexen in MySQL :we zullen hash-indexen, indexkardinaliteit, indexselectiviteit behandelen, we zullen u interessante details vertellen over het afdekken van indexen, en we zullen ook enkele indexeringsstrategieën doornemen. En natuurlijk gaan we in op ClusterControl. Laten we beginnen, zullen we?

Hash-indexen in MySQL

MySQL DBA's en ontwikkelaars die met MySQL te maken hebben, hebben ook nog een andere truc in petto wat betreft MySQL - hash-indexen zijn ook een optie. Hash-indexen worden vaak gebruikt in de MEMORY-engine van MySQL - zoals met vrijwel alles in MySQL, hebben dat soort indexen hun eigen voor- en nadelen. Het belangrijkste nadeel van dit soort indexen is dat ze alleen worden gebruikt voor vergelijkingen van gelijkheid die de operatoren =of <=> gebruiken, wat betekent dat ze niet echt nuttig zijn als je naar een reeks waarden wilt zoeken, maar het belangrijkste voordeel is dat lookups erg snel zijn. Nog een paar nadelen zijn het feit dat ontwikkelaars geen enkel linkse prefix van de sleutel kunnen gebruiken om rijen te vinden (als je dat wilt, gebruik dan in plaats daarvan B-Tree-indexen), het feit dat MySQL niet bij benadering kan bepalen hoeveel rijen er zijn tussen twee waarden - als hash-indexen in gebruik zijn, kan de optimizer ook geen hash-index gebruiken om ORDER BY-bewerkingen te versnellen. Houd er rekening mee dat hash-indexen niet het enige zijn dat de MEMORY-engine ondersteunt - MEMORY-engines kunnen ook B-Tree-indexen hebben.

Indexkardinaliteit in MySQL

Wat MySQL-indexen betreft, heb je misschien ook een andere term horen rondgaan - deze term wordt indexkardinaliteit genoemd. In zeer eenvoudige bewoordingen verwijst indexkardinaliteit naar de uniciteit van waarden die zijn opgeslagen in een kolom die een index gebruikt. Om de indexkardinaliteit van een specifieke index te bekijken, kunt u eenvoudig naar het tabblad Structuur van phpMyAdmin gaan en de informatie daar bekijken of u kunt ook een SHOW INDEXES-query uitvoeren:

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)

De query-uitvoer SHOW INDEXES die hierboven te zien is, heeft veel velden, waarvan er één de indexkardinaliteit weergeeft:dit veld retourneert een geschat aantal unieke waarden in de index - de hoe hoger de kardinaliteit, hoe groter de kans dat de query-optimizer de index gebruikt voor zoekopdrachten. Dat gezegd hebbende, indexkardinaliteit heeft ook een broer - zijn naam is indexselectiviteit.

Indexselectiviteit in MySQL

Een indexselectiviteit is het aantal verschillende waarden in verhouding tot het aantal records in de tabel. In eenvoudige bewoordingen definieert indexselectiviteit hoe nauw een database-index MySQL helpt bij het zoeken naar waarden. Een ideale indexselectiviteit is de waarde van 1. Een indexselectiviteit wordt berekend door de afzonderlijke waarden in een tabel te delen door het totale aantal records, bijvoorbeeld als u 1.000.000 records in uw tabel hebt, maar slechts 100.000 daarvan zijn afzonderlijke waarden , zou uw indexselectiviteit 0,1 zijn. Als u 10.000 records in uw tabel heeft en 8500 daarvan afzonderlijke waarden zijn, zou uw indexselectiviteit 0,85 zijn. Dat is veel beter. Jij krijgt het punt. Hoe hoger uw indexselectiviteit, hoe beter.

Indexen afdekken in MySQL

Een dekindex is een speciaal soort index in InnoDB. Wanneer een dekkende index in gebruik is, worden alle vereiste velden voor een zoekopdracht door de index opgenomen, of "gedekt", wat betekent dat u ook kunt profiteren van het lezen van alleen de index in plaats van de gegevens. Als niets anders helpt, kan een dekkingsindex uw ticket zijn naar betere prestaties. Enkele voordelen van het gebruik van dekkingsindexen zijn:

• Een van de belangrijkste scenario's waarin een dekkende index nuttig kan zijn, is het aanbieden van query's zonder aanvullende I/O-lezingen aan grote tafels.

• MySQL heeft ook toegang tot minder gegevens omdat indexitems kleiner zijn dan de grootte van rijen.

• De meeste opslagengines cachen indexen beter dan gegevens.

Het maken van dekkingsindexen voor een tabel is vrij eenvoudig - bedek gewoon de velden die toegankelijk zijn via de SELECT-, WHERE- en GROUP BY-clausules:

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

Houd er rekening mee dat het bij het behandelen van indexen erg belangrijk is om de juiste volgorde van kolommen in de index te kiezen. Om uw dekkingsindexen effectief te laten zijn, plaatst u de kolommen die u gebruikt met de WHERE-clausules eerst, ORDER BY en GROUP BY als laatste en de kolommen die u gebruikt met de SELECT-clausule als laatste.

Indexeringsstrategieën in MySQL

Het volgen van het advies in deze drie delen van blogposts over indexen in MySQL kan je een heel goede basis bieden, maar er zijn ook een aantal indexeringsstrategieën die je zou kunnen gebruiken als je dat wilt. maak echt gebruik van de kracht van indexen in uw MySQL-architectuur. Om ervoor te zorgen dat uw indexen voldoen aan de best practices van MySQL, kunt u het volgende overwegen:

1. Het isoleren van de kolom waarop u de index gebruikt - in het algemeen gebruikt MySQL geen indexen als de kolommen worden gebruikt, zijn niet geïsoleerd. Een dergelijke zoekopdracht zou bijvoorbeeld geen index gebruiken omdat deze niet geïsoleerd is:

   SELECT demo_column FROM demo_table WHERE demo_id + 1 = 10;

   
   Een dergelijke zoekopdracht zou echter:
    

   SELECT demo_column FROM demo_table WHERE demo_id = 10;

2. Gebruik geen indexen voor de kolommen die u indexeert. Het gebruik van een zoekopdracht als so heeft bijvoorbeeld niet veel zin, dus het is beter om dergelijke zoekopdrachten te vermijden als je kunt:
    

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

3. Als u LIKE-query's samen met geïndexeerde kolommen gebruikt, moet u het jokerteken niet aan het begin van de zoekopdracht plaatsen, omdat op die manier zal MySQL ook geen index gebruiken. Dat is in plaats van het schrijven van vragen zoals deze:

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

   
   Overweeg om ze als volgt te schrijven:

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

   
   De tweede query is beter omdat MySQL weet waar de kolom mee begint en indexen effectiever kan gebruiken. Zoals met alles kan de EXPLAIN-instructie echter een grote hulp zijn als u ervoor wilt zorgen dat uw indexen daadwerkelijk door MySQL worden gebruikt.

ClusterControl gebruiken om uw zoekopdrachten goed te houden

Als u uw MySQL-prestaties wilt verbeteren, moet u met het bovenstaande advies op de goede weg zijn. Als je echter denkt dat je meer nodig hebt, overweeg dan ClusterControl voor MySQL. Een van de dingen waarmee ClusterControl u kan helpen, is prestatiebeheer - zoals al opgemerkt in eerdere blogposts, kan ClusterControl u ook helpen om uw query's altijd zo goed mogelijk te laten presteren - dat komt omdat ClusterControl ook een query bevat monitor waarmee u de prestaties van uw zoekopdrachten kunt volgen, langzame, langlopende zoekopdrachten kunt zien en ook uitbijters kunt zien die u waarschuwen voor mogelijke knelpunten in de prestaties van uw database voordat u ze zelf kunt opmerken:

Je kunt zelfs je zoekopdrachten filteren, zodat je een aanname kunt maken als een index werd gebruikt door een individuele zoekopdracht of niet:

ClusterControl kan een geweldig hulpmiddel zijn om de prestaties van uw database te verbeteren terwijl u het onderhoud uit handen neemt. Voor meer informatie over wat ClusterControl kan doen om de prestaties van uw MySQL-instanties te verbeteren, kunt u een kijkje nemen op de pagina ClusterControl voor MySQL.

Samenvatting

Zoals je nu waarschijnlijk kunt zien, zijn indexen in MySQL een zeer complex beest. Om de beste index voor uw MySQL-instantie te kiezen, weet u wat indexen zijn en wat ze doen, kent u de typen MySQL-indexen, kent u hun voor- en nadelen, leert u hoe MySQL-indexen interageren met opslagengines, bekijkt u ook ClusterControl voor MySQL als u denkt dat het automatiseren van bepaalde taken met betrekking tot indexen in MySQL uw dag gemakkelijker kan maken.