Führt diese SQL-Schreibmethode wirklich dazu, dass der Index fehlschlägt?

Vorwort

Im Internet gibt es häufig Artikel, die verschiedene Situationen zusammenfassen, in denen Indizes in MySQL nicht erreicht werden können. Eine davon ist, dass Anweisungen, die oder verwenden, den Index nicht erreichen können.

Diese Aussage ist eigentlich nicht korrekt. Die richtige Schlussfolgerung müsste sein, dass seit MySQL 5.0, wenn es unabhängige Indizes für die durch oder verbundenen Felder gibt, der Index getroffen werden kann. Hier kommt die Funktion index_merge zum Einsatz.

Vor MySQL 5.0 kann eine SQL-Anweisung nur einen Index verwenden. Wenn das Schlüsselwort oder in der SQL-Anweisung verwendet wird, wird der vorhandene Index ungültig und es wird ein vollständiger Tabellenscan durchgeführt. Denn egal, welcher Index verwendet wird, MySQL kann die Daten, die die Bedingungen erfüllen, nicht gleichzeitig finden und kann daher nur den Index aufgeben.

MySQL wurde außerdem kontinuierlich verbessert und aktualisiert, sodass nach MySQL Version 5.0 die Indexzusammenführungsfunktion index_merge hinzugefügt wurde, die auch die Verwendung mehrerer Indizes in einem SQL unterstützt.

Die Kernidee von index_merge besteht darin, zunächst einen einzelnen Index zu verwenden, um Daten zu finden, die den Anforderungen entsprechen, und diese Daten dann zusammenzuführen und zurückzugeben.
Wir können uns ein Beispiel ansehen.

Hier verwenden wir noch die Tabelle und die Testdaten, die im vorherigen Artikel erstellt wurden. 10w Testdaten werden in die Tabelle eingefügt. Die Tabellenstruktur ist wie folgt.

TABELLE ERSTELLEN `t` (
 `id` int(11) NICHT NULL,
 `a` int(11) DEFAULT NULL,
 `b` int(11) DEFAULT NULL,
 PRIMÄRSCHLÜSSEL (`id`)
)ENGINE=InnoDB;

Fügen wir zunächst einen Index zum Feld „a“ hinzu und führen dann eine Abfrageanweisung mit „oder“ aus, um zu sehen, wie es funktioniert.

mysql> Tabelle ändern t Index hinzufügen a_index(a);
Abfrage OK, 0 Zeilen betroffen (0,17 Sek.)
Datensätze: 0 Duplikate: 0 Warnungen: 0

mysql> erklären Sie „select a from t“, wobei a=100 oder b=6000;
+----+----------+-------+---------+---------------+------+---------+---------+---------+---------+-------------+
| ID | Auswahltyp | Tabelle | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | Extra |
+----+----------+-------+---------+---------------+------+---------+---------+---------+---------+-------------+
| 1 | SIMPLE | t | ALL | a_index | NULL | NULL | NULL | 100332 | Verwenden von „where“ |
+----+----------+-------+---------+---------------+------+---------+---------+---------+---------+-------------+
1 Zeile im Satz (0,00 Sek.)

Da für Feld b kein Index vorhanden ist, geht MySQL davon aus, dass ein vollständiger Tabellenscan günstiger ist, da dadurch der Tabellenrückgabeprozess vermieden werden kann.

Fügen wir dann dem Feld b einen Index hinzu und führen die SQL-Anweisung anschließend erneut aus.

mysql> Tabelle ändern t Index hinzufügen b_index(b);
Abfrage OK, 0 Zeilen betroffen (0,17 Sek.)
Datensätze: 0 Duplikate: 0 Warnungen: 0

mysql> erklären Sie „select a from t“, wobei a=100 oder b=6000;
+----+----------+----------+----------+-----------------+-----------------+---------+------+------+---------+-------------------------------------------+
| ID | Auswahltyp | Tabelle | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | Extra |
+----+----------+----------+----------+-----------------+-----------------+---------+------+------+---------+-------------------------------------------+
| 1 | SIMPLE | t | index_merge | a_index,b_index | a_index,b_index | 5,5 | NULL | 2 | Mit union(a_index,b_index); Mit where |
+----+----------+----------+----------+-----------------+-----------------+---------+------+------+---------+-------------------------------------------+
1 Zeile im Satz (0,00 Sek.)

Dieses Mal können Sie sehen, dass MySQL beide Indizes a und b verwendet und der Wert des Typfelds index_merge ist.

Sehen wir uns als Nächstes eine andere SQL-Anweisung an, um das Ergebnis zu sehen.

mysql> erklären Sie „select a from t“, wobei a>100 oder b>6000;
+----+--------------+-------+------+-----------------+------+---------+---------+---------+-------------+
| ID | Auswahltyp | Tabelle | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | Extra |
+----+--------------+-------+------+-----------------+------+---------+---------+---------+-------------+
| 1 | SIMPLE | t | ALLE | a_index,b_index | NULL | NULL | NULL | 100332 | Verwenden von where |
+----+--------------+-------+------+-----------------+------+---------+---------+---------+-------------+
1 Zeile im Satz (0,00 Sek.)

Diese SQL-Anweisung ändert einfach das Gleichheitszeichen in ein Größer-als-Zeichen, was bedeutet, dass der zurückgegebene Ergebnissatz ein Intervallsatz ist. MySQL gibt hier den Index auf und führt einen vollständigen Tabellenscan durch. Ich habe jedoch in einigen Artikeln gelesen, dass dieses Problem nach MySQL Version 5.7 optimiert wurde, d. h. index_merge wird auch in Intervallabfragen unterstützt. Meine Version ist 5.6 und ich habe diese Optimierung noch nicht überprüft. Wenn Sie interessiert sind, können Sie dies überprüfen.

Tatsächlich sind viele Dinge in MySQL nicht absolut. Verschiedene MySQL-Versionen können unterschiedliche interne Verarbeitungsmethoden für dasselbe SQL haben. Gleichzeitig können wir sehen, dass MySQL kontinuierlich optimiert und aktualisiert wurde und einige alte Wissenspunkte möglicherweise nicht mehr gelten.

Ich hoffe, der Artikel ist hilfreich für Sie. Folgen Sie mir gerne und geben Sie mir ein „Gefällt mir“, das ist für mich die beste Unterstützung. Vielen Dank.

Darüber hinaus können Sie bezüglich der zugrunde liegenden Datenstruktur von MySQL auf andere Artikel zurückgreifen, die ich zuvor geschrieben habe. Diese können Ihnen beim Verständnis dieses Artikels helfen.

Zusammenfassen

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels einen gewissen Lernwert für Ihr Studium oder Ihre Arbeit hat. Vielen Dank für Ihre Unterstützung von 123WORDPRESS.COM.