Optimierungsanalyse der Limit-Abfrage in MySQL-Optimierungstechniken

Optimierungsanalyse der Limit-Abfrage in MySQL-Optimierungstechniken

Vorwort

Im realen Geschäftsleben ist Paging eine gängige Geschäftsanforderung. Dann wird die Limit-Abfrage verwendet. Wenn wir die Limit-Abfrage verwenden, ist die Effizienz sehr hoch, wenn die Daten relativ klein sind oder nur der erste Teil der Daten abgefragt wird. Bei großen Datenmengen oder großen Abfrage-Offsets (beispielsweise bei einem Grenzwert von 100.000,20) ist die Effizienz jedoch häufig unbefriedigend. Eine gängige Methode ist die Verwendung von Limit in Verbindung mit order by. Wenn order by einen Index für den Benutzer hat, ist die Effizienz normalerweise recht gut.

In diesem Fall besteht die einfachste Abfrage darin, einen überdeckenden Index zu verwenden, um bestimmte erforderliche Spalten abzufragen. Dieser Effekt ist sehr gut

Wie unten gezeigt

mysql> AUSWÄHLEN * VON student LIMIT 1000000,1;
+---------+------------+------------+------------+-----------+---------------------+
| ID | Vorname | Nachname | erstellt am | Punktzahl | aktualisiert am |
+---------+------------+------------+------------+-----------+---------------------+
| 1000001 | kF9DxBgnUi | yLXnPSHJpH | 11.07.2019 | 97 | 11.07.2019 14:29:59 | |
+---------+------------+------------+------------+-----------+---------------------+
1 Zeile im Satz (0,31 Sek.)

Sie können die Zeit sehen

mysql> EXPLAIN SELECT Punktzahl,Vorname FROM Student ORDER BY erstellt am LIMIT 1000000,20 \G
*************************** 1. Reihe ***************************
   ID: 1
 select_type: EINFACH
  Tabelle: Student
 Partitionen: NULL
   Typ: Index
mögliche Schlüssel: NULL
   Schlüssel: time_source_name
  Schlüssellänge: 69
   Ref: NULL
   Zeilen: 1000001
  gefiltert: 100,00
  Extra: Index verwenden
1 Zeile im Satz, 1 Warnung (0,00 Sek.)

MySQL>

Auf diese Weise verwenden die abgefragten Spalten den abdeckenden Index, und die Anzahl der gescannten Zeilen wird erheblich reduziert, der Effekt ist jedoch nicht sehr zufriedenstellend. Wenn andere Abfragen vorhanden sind, werden solche Abfragen sehr langsam.

Beispielsweise fügen wir die Spalte „Nachname“ hinzu.

wie folgt

mysql> SELECT Punktzahl, Vorname, Nachname FROM Student ORDER BY erstellt am LIMIT 1000000,1;
+-------+------------+---------+
| Punktzahl | Vorname | Nachname |
+-------+------------+---------+
| 86 | knKsV2g2fY | WB5qJeLZuk |
+-------+------------+---------+
1 Reihe im Satz (4,81 Sek.)

MySQL>

Die Ausführung dieser Abfrage dauert etwas mehr als 4 Sekunden. Durch Analyse können wir sehen, dass diese Abfrage den Index nicht verwenden kann

mysql> erklären SELECT Punktzahl, Vorname, Nachname FROM Student ORDER BY erstellt am LIMIT 1000000,1\G
*************************** 1. Reihe ***************************
   ID: 1
 select_type: EINFACH
  Tabelle: Student
 Partitionen: NULL
   Typ: ALLE
mögliche Schlüssel: NULL
   Schlüssel: NULL
  key_len: NULL
   Ref: NULL
   Reihen: 6489221
  gefiltert: 100,00
  Extra: Filesort verwenden
1 Zeile im Satz, 1 Warnung (0,00 Sek.)

MySQL>

Nun modifizieren wir die Abfrage wie folgt

mysql> SELECT student.score,student.first_name FROM student INNER JOIN (SELECT id FROM student ORDER BY erstellt_at LIMIT 1000000,1 ) AS temp USING(id);
+-------+------------+
| Punktzahl | Vorname |
+-------+------------+
| 15 | 2QWZ |
+-------+------------+
1 Zeile im Satz (0,18 Sek.)
mysql> EXPLAIN SELECT student.score,student.first_name,last_name FROM student INNER JOIN (SELECT id FROM student ORDER BY created_at LIMIT 1000000,1 ) AS temp USING(id);
+----+-------------+------------+------------+--------+---------------+-----------------+--------+---------+---------+----------+-------------+
| ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
+----+-------------+------------+------------+--------+---------------+-----------------+--------+---------+---------+----------+-------------+
| 1 | PRIMARY | <derived2> | NULL | ALLE | NULL | NULL | NULL | NULL | 1000001 | 100,00 | NULL |
| 1 | PRIMARY | student | NULL | eq_ref | PRIMARY | PRIMARY | 4 | temp.id | 1 | 100,00 | NULL |
| 2 | ABGELEITET | Student | NULL | Index | NULL | Zeitquellenname | 69 | NULL | 1000001 | 100,00 | Index wird verwendet |
+----+----------+------------+------------+--------+---------------+-----------------+--------+---------+---------+----------+-------------+-------------+
3 Zeilen im Satz, 1 Warnung (0,00 Sek.)

Aus den Analyseergebnissen ist ersichtlich, dass zu diesem Zeitpunkt lediglich 1.000.001 Datensätze abgefragt wurden. Warum gibt es diese Veränderung? Dies wird als verzögerter Join bezeichnet. Dabei wird zunächst der erforderliche Primärschlüssel mithilfe der abdeckenden Indexabfrage zurückgegeben. Anschließend wird die ursprüngliche Tabelle basierend auf dem Primärschlüssel verknüpft, um die erforderlichen Daten zu erhalten. Dadurch wird die Anzahl der zu scannenden Zeilen so weit wie möglich reduziert.

In einigen speziellen Situationen gibt es tatsächlich eine andere Optimierungslösung. Beispielsweise um die letzten eingefügten Datensätze abzurufen. Dann können wir die Primärschlüssel-ID (last_id) des letzten Datensatzes in der letzten Abfrage aufzeichnen.
Dann kann die Abfrage geändert werden in

SELECT Punktzahl, Vorname, Nachname, ID FROM Student WHERE ID>=Nachname ORDER BY ID ASC LIMIT 1

Wenn beispielsweise last_id=1000000 ist, beginnt die Abfrage bei 1000000. In einem solchen Szenario ist die Leistung unabhängig vom Datenversatz sehr gut.

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.

Das könnte Sie auch interessieren:
  • 5 Möglichkeiten zur Optimierung von MySQL-Limitabfrageanweisungen
  • Optimierungsmethode für MySQL-Paging-Grenzgeschwindigkeit ist zu langsam
  • MySQL begrenzt die gemeinsame Nutzung von Paging-Optimierungsmethoden
  • Optimieren Sie das MySQL-Limit, verweisen Sie auf den zusammengesetzten Index der schnellen Paging von einer Million auf zehn Millionen und wenden Sie ihn auf ein leichtes Framework an
  • MySQL-Abfrageoptimierung: LIMIT 1 vermeidet vollständigen Tabellenscan und verbessert die Abfrageeffizienz
  • Beispiel für die Optimierung des MySQL-Limit-Offsets
  • MySQL-Abfrageoptimierung: Einführung in das Sortierlimit für Join-Abfragen (Join-, Order-by- und Limit-Anweisung)
  • Optimierung des MySQL-Limits unter PHP
  • Analyse der MySQL-Limit-Abfrageoptimierung
  • So verwenden Sie den Limit-Parameter zur Optimierung von MySQL-Abfragen

<<:  Detaillierter Code zur Implementierung einer 3D-Tag-Cloud in Vue

>>:  So verwenden Sie Docker buildx, um plattformübergreifende Images zu erstellen und sie in private Repositories zu übertragen

Artikel empfehlen

So betten Sie mithilfe von Iframe andere Webseiten in eine Webseite ein

So verwenden Sie Iframe: Code kopieren Der Code l...

So ändern Sie die inländische Quelle von Ubuntu 20.04 apt

UPD 2020.2.26 Derzeit ist Ubuntu 20.04 LTS noch n...

Detaillierte Analyse des binlog_format-Modus und der Konfiguration in MySQL

Es gibt drei Hauptmethoden der MySQL-Replikation:...

MySQL-Ansichtsprinzipien und grundlegende Bedienungsbeispiele

Dieser Artikel veranschaulicht anhand von Beispie...

Lösungen für das Problem der Erstellung von XHTML- und CSS-Webseiten

Die Lösungen für die Probleme, die bei der Erstell...

Implementierung von React-Loop-Daten (Liste)

Lassen Sie uns zunächst die Daten simulieren, die...

Implementierungsprozess des Nginx-Hochverfügbarkeitsclusters

Dieser Artikel stellt hauptsächlich den Implement...

Ubuntu 20.04 – Bestes Konfigurationshandbuch (unverzichtbar für Anfänger)

1. Systemkonfiguration 1. Deaktivieren Sie das Su...