Vollständige MySQL-Lernhinweise

Vollständige MySQL-Lernhinweise

MyISAM und InnoDB

Kontrast MeinIsAM InnoDB
Primär- und Fremdschlüssel Wird nicht unterstützt Unterstützung
Transaktionen Wird nicht unterstützt Unterstützung
Zeilentabellensperre Tabellensperre: Auch wenn Sie nur einen Datensatz bearbeiten, wird die gesamte Tabelle gesperrt. Dies ist für Vorgänge mit hoher Parallelität nicht geeignet. Die Zeilensperre, die während des Betriebs nur eine Zeile sperrt, ohne andere Zeilen zu beeinträchtigen, eignet sich für hohe Parallelität
Cache Nur Cache-Indizes, keine anderen Daten Cache-Indizes und reale Daten erfordern viel Speicher, und die Speichergröße wirkt sich auf die Leistung aus
Tabellenbereich Klein groß
Fokus Leistung Transaktionen
Standardinstallation Y Y

Gründe für Leistungseinbußen und langsames SQL:

  • Schlecht geschriebene Abfrage
  • Indexfehler
  • Zu viele Verknüpfungen in einer verknüpften Abfrage (Designfehler oder unvermeidbare Anforderung)
  • Servertuning und diverse Parametereinstellungen (Buffer, Threadparameter)

MySQL-Ausführungsreihenfolge

  • Handschrift
  • Das maschinelle Lesen beginnt mit

SQLJoin

ein Tisch

 mysql> wähle * aus tbl_dept;
 +----+----------+--------+
 | ID | Abteilungsname | locAdd |          
 +----+----------+--------+
 | 1 | 11 |
 | 2 | HR | 12 |
 | 3 | MK | 13 |
 | 4 | MIS | 14 |
 | 5 | FD | 15 |
 +----+----------+--------+
 5 Zeilen im Satz (0,00 Sek.)

b Tisch

 +----+------+--------+
 | ID | Name | Abteilungs-ID |
 +----+------+--------+
 | 1 | z3 | 1 |
 | 2 | z4 | 1 |
 | 3 | z5 | 1 |
 | 4 | w5 | 2 |
 | 5 | w6 | 2 |
 | 6 | Staffel 7 | 3 |
 | 7 | Staffel 8 | 4 |
 | 8 | Staffel 9 | 51 |
 +----+------+--------+
8 Zeilen im Satz (0,00 Sek.)

mysql不支持全連接

使用以下方式可以實現全連接

 mysql> wähle * von tbl_dept a rechts und verbinde tbl_emp b mit a.id=b.deptId
     -> Vereinigung
     -> wähle * aus tbl_dept a links und verbinde tbl_emp b mit a.id=b.deptId;
 +------+----------+--------+------+------+--------+
 | ID | Abteilungsname | locAdd | ID | Name | Abteilungs-ID |
 +------+----------+--------+------+------+--------+
 | 1 | RD | 11 | 1 | z3 | 1 |
 | 1 | RD | 11 | 2 | z4 | 1 |
 | 1 | RD | 11 | 3 | z5 | 1 |
 | 2 | HR | 12 | 4 | w5 | 2 |
 | 2 | HR | 12 | 5 | w6 | 2 |
 | 3 | MK | 13 | 6 | s7 | 3 |
 | 4 | MIS | 14 | 7 | s8 | 4 |
 | NULL | NULL | NULL | 8 | s9 | 51 |
 | 5 | FD | 15 | NULL | NULL | NULL |
 +------+----------+--------+------+------+--------+
 9 Zeilen im Satz (0,00 Sek.)

Die Einzigartigkeit von a und die Einzigartigkeit von b

 mysql> select * from tbl_dept a left join tbl_emp b on a.id=b.deptId, wobei b.id null ist
     -> Vereinigung
     -> wähle * aus tbl_dept a und verbinde tbl_emp b mit a.id=b.deptId, wobei a.id null ist;
 +------+----------+--------+------+------+--------+
 | ID | Abteilungsname | locAdd | ID | Name | Abteilungs-ID |
 +------+----------+--------+------+------+--------+
 | 5 | FD | 15 | NULL | NULL | NULL |
 | NULL | NULL | NULL | 8 | s9 | 51 |
 +------+----------+--------+------+------+--------+
 2 Zeilen im Satz (0,01 Sek.)

Index

Definition des Index:

Ein Index ist eine Datenstruktur, die SQL dabei hilft, Daten effizient abzurufen. Das Wesentliche eines Index ist:數據結構

Es kann einfach wie folgt verstanden werden:排好序的快速查找數據結構

Neben den Daten verwaltet das Datenbanksystem auch Datenstrukturen, die bestimmten Suchalgorithmen genügen. Diese Datenstrukturen verweisen in irgendeiner Weise auf die Daten (Referenz), sodass erweiterte Suchalgorithmen auf diesen Datenstrukturen implementiert werden können. Diese Datenstruktur ist ein Index. Die folgende Abbildung ist ein Beispiel:

Im Allgemeinen sind Indizes auch sehr groß, sodass sie häufig als Indexdateien auf der Festplatte gespeichert werden.

Wenn wir von Indizes sprechen, meinen wir, sofern nicht anders angegeben, normalerweise Indizes, die in einer B-Baum-Struktur (mehrseitiger Suchbaum, nicht unbedingt binär) organisiert sind.

Unter ihnen verwenden Clustered-Index, Sekundärindex, zusammengesetzter Index, Präfixindex und eindeutiger Index standardmäßig alle den B + -Baumindex, der zusammen als Index bezeichnet wird. Natürlich gibt es neben B + -Baumindizes auch Hash-Indizes.

Vor- und Nachteile der Indizierung

1. Vorteile

Ähnlich wie die Indizierung von Buchnummern in Universitätsbibliotheken verbessert es die Effizienz des Datenabrufs und reduziert die IO-Kosten der Datenbank.

Das Sortieren von Daten nach Index reduziert den Preis der Datensortierung und verringert den CPU-Verbrauch

2. Nachteile

Tatsächlich ist der Index auch eine Tabelle, die den Primärschlüssel und die Felder mit Indizes speichert und auf die Datensätze der Entitätstabelle verweist, sodass die Indexspalte auch Speicherplatz einnimmt.

Obwohl Indizes die Abfragegeschwindigkeit erheblich verbessern, verlangsamen sie Tabellenaktualisierungen wie Aktualisierungs-, Einfüge- und Löschvorgänge. Dies liegt daran, dass MySQL beim Aktualisieren einer Tabelle nicht nur die Daten, sondern auch die Indexdatei speichern muss. Jedes Mal, wenn Sie ein Feld mit einem Index aktualisieren, werden die Indexinformationen nach den durch die Aktualisierung verursachten Schlüsselwertänderungen angepasst.

Der Index ist nur ein Faktor zur Verbesserung der Effizienz. Für eine Tabelle mit einer großen Datenmenge müssen Sie den besten Index erstellen oder hervorragende Abfrageanweisungen schreiben, anstatt nur Indizes hinzuzufügen, um die Effizienz zu verbessern.

Indexklassifizierung

  • Einzelwertindex
  • Eindeutiger Index
  • Zusammengesetzter Index
  • Grundlegende Syntax:

erstellen

Erstellen Sie einen [eindeutigen] Index IndexName auf mytable(Spaltenname(Länge));
alter mytable add [unique] index [indexName] on (columnname(length));

löschen

lösche den Index [Indexname] auf meiner Tabelle

Überprüfen

Index von Tabellenname\G anzeigen

Es gibt vier Möglichkeiten, einer Tabelle Indizes hinzuzufügen:

MySQL-Indexstruktur

  1. BTree-Index
  2. Hash-Index
  3. Volltextindex
  4. R-Baum

In welchen Fällen sollten wir Indizes erstellen?

  1. Der Primärschlüssel erstellt automatisch einen eindeutigen Index
  2. Felder, die häufig als Abfragebedingungen verwendet werden, sollten indexiert werden
  3. Felder, die sich auf andere Tabellen in der Abfrage beziehen, Fremdschlüsselbeziehungen werden indiziert
  4. Häufig aktualisierte Felder eignen sich nicht zum Erstellen von Indizes, da bei jeder Aktualisierung nicht nur der Datensatz, sondern auch der Index aktualisiert wird.
  5. Erstellen Sie keine Indizes für Felder, die nicht in der Where-Bedingung verwendet werden.
  6. Wer hat ein Problem mit der Auswahl eines einzelnen Schlüssels/Kombinationsindex? (Bei hoher Parallelität werden kombinierte Indizes empfohlen.)
  7. Die Sortierfelder in der Abfrage verbessern die Sortiergeschwindigkeit erheblich, wenn auf die Sortierfelder über Indizes zugegriffen wird
  8. Zählen oder Gruppieren von Feldern in einer Abfrage

Wann sollte kein Index erstellt werden?

  1. Wenige Datensätze in der Tabelle
  2. Tabellen, die häufig DML-Anweisungen ausführen
  3. Die Daten in den Tabellenfeldern wiederholen sich und sind gleichmäßig verteilt, sodass nur die am häufigsten abgefragten und sortierten Datenspalten indiziert werden. Beachten Sie, dass die Indizierung einer Datenspalte, die viele wiederholte Inhalte enthält, keinen großen praktischen Effekt hat.

Leistungsanalyse

Erläutern Sie die wichtigsten Punkte

Was können Sie tun?

  1. Lesereihenfolge der Tabelle
  2. Vorgangstyp des Datenlesevorgangs
  3. Welche Indizes können verwendet werden
  4. Welche Indizes werden eigentlich verwendet?
  5. Verweise zwischen Tabellen
  6. Wie viele Zeilen jeder Tabelle werden vom Optimierer abgefragt?

Drei Situationen des Es

  1. Die ID ist dieselbe und die Ausführungsreihenfolge ist von oben nach unten
  2. Die ID ist unterschiedlich. Wenn es sich um eine Unterabfrage handelt, erhöht sich die ID-Nummer. Je größer die ID, desto höher die Priorität.
  3. Die IDs sind gleich, aber unterschiedlich und existieren gleichzeitig

Wählen Sie Typ

  1. SIMPLE Einfache Abfrage
  2. PRIMARY Hauptabfrage (äußerste Abfrage)
  3. UNTERABFRAGE
  4. DERIUED Eine temporäre Tabelle einer Unterabfrage einer Abfrage
  5. UNION
  6. UNION RESULT Union-Abfrageergebnisse

Typ::

Typ zeigt die Zugriffstypanordnung an, die ein wichtigerer Indikator ist

Vom Besten zum Schlechtesten sind dies:

system > const > eq_ref> ref > range > index > ALL ;

Generell muss sichergestellt werden, dass die Abfrage mindestens die Bereichsebene erreicht, vorzugsweise ref

----------------------------------------------Typ------------------------------------------------------

  1. system: Die Tabelle hat nur eine Datensatzzeile (entspricht der Systemtabelle). Dies ist eine spezielle Spalte vom Typ const und wird im Allgemeinen nicht angezeigt und kann ignoriert werden.
  2. const: gibt an, dass die Suche einmal über den Index durchgeführt wird. const wird zum Vergleichen von Primärschlüsseln oder eindeutigen Indizes verwendet. Da nur eine Datenzeile übereinstimmt, kann MySQL die Abfrage schnell in eine Konstante umwandeln, indem es den Primärschlüssel in die Where-Liste einfügt.
  3. eq_ref: Eindeutiger Index-Scan, es gibt nur einen Datensatz, der in der Tabelle dazu passt. Wird häufig für Primärschlüssel oder eindeutige Index-Scans verwendet (zwei Tabellen haben eine Viele-zu-eins- oder Eins-zu-eins-Beziehung. Wenn die verbundene Tabelle eine ist, lautet ihre Abfrage eq_ref).
  4. ref: nicht eindeutiger Index-Scan, gibt alle Zeilen zurück, die einem einzelnen Wert entsprechen, was im Wesentlichen ein Indexzugriff ist; es gibt alle Zeilen zurück, die einem einzelnen Wert entsprechen, es können jedoch mehrere Zeilen mit zusammengesetzten Bedingungen gefunden werden, was eine Kombination aus Suche und Scan ist
  5. Bereich: Ruft nur Zeilen in einem bestimmten Bereich ab und verwendet einen Index zum Auswählen von Zeilen. Die Schlüsselspalte zeigt, welcher Index verwendet wird. Im Allgemeinen erscheinen Abfragen wie „zwischen“, „<“, „>“ und „in“ in der Where-Anweisung. Dieser Bereichsscan-Index ist besser als ein vollständiger Tabellenscan.
  6. Index: Der Unterschied zwischen Index und ALL besteht darin, dass der Index nur den Indexbaum durchläuft und die Indexdatei normalerweise kleiner als die Datendatei ist.
  7. ALLE: Vollständiger Tabellenscan

----------------------------------------------Typ------------------------------------------------------

  • Possible_keys: Zeigt die möglichen Indizes an, die (theoretisch) angewendet werden können.
  • key: der tatsächlich verwendete Index. Wenn in der Abfrage ein überdeckender Index verwendet wird, erscheint der Index nur im key
  • key_len: gibt die Anzahl der im Index verwendeten Bytes an. Je kürzer, desto besser, ohne dass die Genauigkeit verloren geht. Der von kenlen angezeigte Wert ist die maximal mögliche Länge des Indexfelds, nicht die tatsächlich verwendete Länge. kenlen wird basierend auf der Tabellendefinition berechnet und nicht aus der Tabelle abgerufen.

key_len Länge: 13, da char(4)*utf8(3)+darf null(1)=13 sein

  • ref: Zeigt an, welche Spalte des Index verwendet wird, wenn möglich eine Konstante, und welche Spalten oder Konstanten zum Nachschlagen von Werten in der Indexspalte verwendet werden

  • Zeilen: Berechnen Sie anhand der Tabellenstatistik und der Indexauswahl ungefähr die Anzahl der Zeilen, die gelesen werden müssen, um die erforderlichen Datensätze zu finden

Wenn kein Index erstellt wird, fragen Sie die Tabelle t1 t2 ab. Die ID der Tabelle t1 entspricht der Tabelle t2. Der Wert von col1 in der Tabelle t2 muss „ac“ sein.

Für das ID-Feld ist Tabelle t1 gleichwertig mit Eins-zu-viele für Tabelle t2.

Der Typ der t1-Tabelle ist eq_ref, was eindeutigen Indexscan bedeutet. In der Tabelle gibt es nur einen Datensatz, der damit übereinstimmt. In der t2-Tabelle gibt es nur einen col-Wert, der der ID der t1-Tabelle entspricht. Gemäß der Primärschlüssel-ID-Indexabfrage der t2-Tabelle wird eine Zeile aus der t1-Tabelle und 640 Zeilen aus der t2-Tabelle gelesen.

Nach der Indizierung

t1 liest eine Zeile, t2 liest 142 Zeilen, ref nicht eindeutiger Index-Scan, gibt alle Zeilen zurück, die einem einzelnen Wert entsprechen, gibt alle Zeilen von col zurück, die der ID in t2 entsprechen, aber t1 hat nur eine Zeile von col, die der ID entspricht, also ist der Typ eq_ref

Extra

Enthält wichtige Informationen, die nicht in andere Spalten passen

\G : Sortierung vertikal anzeigen

  • Verwenden von Filesort: Dies bedeutet, dass MySQL einen externen Index zum Sortieren der Daten verwendet, anstatt sie in der Reihenfolge des Index in der Tabelle zu lesen. Der Vorgang, bei dem der Index nicht zum Abschließen der Sortierung in MySQL verwendet werden kann, wird als Dateisortierung bezeichnet. Die Abbildung, die nicht durch die Box eingerahmt ist, hat einen zusammengesetzten Index erstellt, aber die direkte Verwendung von col3 zum Sortieren führt zu Luftschlössern. MySQL hat keine andere Wahl, als Filesoft zu verwenden

  • Temporäre Tabellen verwenden: Eine temporäre Tabelle wird zum Speichern von Zwischenergebnissen verwendet. MySQL verwendet eine temporäre Tabelle zum Sortieren von Abfrageergebnissen. Wird häufig zum Sortieren nach Sortierung und Gruppieren nach Gruppierung verwendet. Der zusammengesetzte Index col1_col2 wird in der obigen Tabelle erstellt, aber die direkte Gruppierung nach col2 führt dazu, dass MySQL Filesoft ausführen und eine temporäre Tabelle erstellen muss.
  • Using index gibt an, dass in der entsprechenden Auswahloperation ein überdeckender Index verwendet wird, um den Zugriff auf die Datenzeilen der Tabelle zu vermeiden. Wenn using where gleichzeitig erscheint, bedeutet dies, dass der Index verwendet wird, um die Suche nach dem Indexschlüsselwert durchzuführen. Wenn using where nicht vorkommt, bedeutet dies, dass der Index zum Lesen von Daten verwendet wird, anstatt eine Suchaktion durchzuführen.
  • Die Verwendung von „where“ bedeutet die Verwendung von „where“-Filtern
  • Bei privater Verwendung des Join-Puffers wird der Link-Cache verwendet
  • Der Wert der Where-Klausel des unmöglichen Puffers ist immer falsch und kann nicht zum Abrufen von Tupeln verwendet werden.
  • Select-Tabellen werden wegoptimiert. Wenn keine Group-By-Klausel vorhanden ist, werden Min/Max-Operationen basierend auf Indizes optimiert oder Count(*)-Operationen auf der MyISAM-Speicher-Engine ausgeführt. Die Optimierung wird in der Phase der Generierung des Abfrageausführungsplans abgeschlossen, ohne auf die Ausführung der Ausführungsoperation zu warten.
  • distinct optimiert die Distinct-Operation und beendet die Suche nach identischen Werten sofort nach dem Auffinden des ersten passenden Tupels

Fall

Indexoptimierung

Einzeltabellenoptimierung

 Tabelle erstellen, wenn „Artikel“ nicht vorhanden ist (
 ​
 `id` INT(10) UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
 `author_id` INT (10) UNSIGNED NOT NULL,
 `category_id` INT(10) UNSIGNED NOT NULL , 
 `Ansichten` INT(10) UNSIGNED NOT NULL , 
 `Kommentare` INT(10) UNSIGNED NOT NULL,
 `Titel` VARBINARY(255) NICHT NULL,
 `content` TEXT NICHT NULL
 );
 INSERT INTO `Artikel`(`Autor-ID`,`Kategorie-ID`,`Ansichten`,`Kommentare`,`Titel`,`Inhalt`)VALUES
 (1,1,1,1,'1','1'),
 (2,2,2,2,'2','2'),
 (1,1,3,3,'3','3');
 ​
 WÄHLEN SIE * AUS DEM ARTIKEL;
 mysql> wähle ID, Autor-ID aus Artikel, wo Kategorie-ID = 1 und Kommentare > 1, sortiere nach Ansichten, absteigendes Limit 1;
 +----+-----------+
 | ID | Autoren-ID |
 +----+-----------+
 | 3 | 1 |
 +----+-----------+
 1 Zeile im Satz (0,00 Sek.)
 ​
 mysql> erklären select author_id from article where category_id = 1 and comments > 1 order by views desc li
 Grenze 1;
 +----+----------+---------+------------+------+---------------+-----+---------+------+---------+------+----------+----------+-------------+-------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+---------+------------+------+---------------+-----+---------+------+---------+------+----------+----------+-------------+-------------+
 | 1 | SIMPLE | Artikel | NULL | ALL | NULL | NULL | NULL | NULL | 3 | 33.33 | Where verwenden; Filesort verwenden |
 +----+----------+---------+------------+------+---------------+-----+---------+------+---------+------+----------+----------+-------------+-------------+
 1 Zeile im Satz, 1 Warnung (0,00 Sek.)

Es ist ersichtlich, dass die Abfrage zwar abgeschlossen ist, der Typ jedoch vollständig ist und die Verwendung von Filesort in Extra angezeigt wird, was beweist, dass die Abfrageeffizienz sehr gering ist.

Muss optimiert werden

Erstellen eines Indexes

Erstellen Sie den Index idx_article_ccv für den Artikel (Kategorie-ID, Kommentare, Ansichten).

Abfrage

 mysql> erläutern Sie, wählen Sie die Autor-ID aus dem Artikel aus, in dem die Kategorie-ID = 1 und die Kommentare > 1 sind, sortieren Sie nach Ansichten, Abstiegslimit 1;
 +----+----------+---------+------------+-------+-----------------+-----------------+---------+------+------+----------+----------+---------------------------------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+---------+------------+-------+-----------------+-----------------+---------+------+------+----------+----------+---------------------------------------+
 | 1 | SIMPLE | Artikel | NULL | Bereich | inx_article_ccv | inx_article_ccv | 8 | NULL | 1 | 100,00 | Indexbedingung wird verwendet; Dateisortierung wird verwendet |
 +----+----------+---------+------------+-------+-----------------+-----------------+---------+------+------+----------+----------+---------------------------------------+
 1 Zeile im Satz, 1 Warnung (0,00 Sek.)

Hier stellen wir fest, dass sich der Typ in einen Bereich geändert hat und die Abfrage der gesamten Tabelle in eine Bereichsabfrage geändert wurde, was etwas optimiert ist.

Allerdings verwendet extra weiterhin Filesort, was beweist, dass die Indexoptimierung nicht erfolgreich ist.

Also löschen wir den Index

Index idx_article_ccv auf Artikel löschen;

Einen neuen Index erstellen und einen Bereich ausschließen

Erstellen Sie den Index idx_article_cv für den Artikel (Kategorie-ID, Ansichten).
 mysql> erläutern Sie, wählen Sie die Autor-ID aus dem Artikel aus, in dem die Kategorie-ID = 1 und die Kommentare > 1 sind, sortieren Sie nach Ansichten, absteigendes Limit 1;
 +----+----------+---------+------------+------+----------------+----------------+---------+-------+------+----------+-------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+---------+------------+------+----------------+----------------+---------+-------+------+----------+-------------+
 | 1 | SIMPLE | Artikel | NULL | ref | idx_article_cv | idx_article_cv | 4 | const | 2 | 33.33 | Verwenden von where |
 +----+----------+---------+------------+------+----------------+----------------+---------+-------+------+----------+-------------+
 1 Zeile im Satz, 1 Warnung (0,00 Sek.)
Zu diesem Zeitpunkt werden Sie feststellen, dass die Optimierung erfolgreich war. Der Typ wurde in ref geändert und extra wurde in using where geändert.

In diesem Experiment habe ich einen weiteren Test hinzugefügt und festgestellt, dass es auch möglich ist, beim Erstellen eines Indexes Kommentare am Ende einzufügen. mysql> create index idx_article_cvc on article(category_id,views,comments);
 Abfrage OK, 0 Zeilen betroffen (0,02 Sek.)
 Datensätze: 0 Duplikate: 0 Warnungen: 0
 ​
 mysql> erläutern Sie, wählen Sie die Autor-ID aus dem Artikel aus, in dem die Kategorie-ID = 1 und die Kommentare > 1 sind, sortieren Sie nach Ansichten, Abstiegslimit 1;
 +----+----------+---------+------------+------+-----------------+-----------------+---------+-----------+-------+----------+-------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+---------+------------+------+-----------------+-----------------+---------+-----------+-------+----------+-------------+
 | 1 | SIMPLE | Artikel | NULL | ref | idx_article_cvc | idx_article_cvc | 4 | const | 2 | 33.33 | Verwenden von where |
 +----+----------+---------+------------+------+-----------------+-----------------+---------+-----------+-------+----------+-------------+
 1 Zeile im Satz, 1 Warnung (0,00 Sek.)

Zu diesem Zeitpunkt werden Sie feststellen, dass die Optimierung erfolgreich war. Der Typ wurde in ref geändert und extra wurde in using where geändert.

In diesem Experiment habe ich einen weiteren Test hinzugefügt und festgestellt, dass es auch möglich ist, beim Erstellen eines Indexes am Ende Kommentare einzufügen.

Hier stellen wir fest, dass der Typ immer noch „ref“ ist und „extra“ immer noch „usingwhere“ ist, aber die Position der Indexerstellung wurde gerade geändert und das Bereichsabfragefeld wurde an das Ende verschoben!!!!

Duale Tabellenoptimierung

 Tabelle erstellen, wenn `Klasse` nicht vorhanden ist (
 `id` INT(10) UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
 `Karte` INT (10) UNSIGNED NOT NULL
 );
 Tabelle erstellen, wenn `Buch` nicht vorhanden ist (
 `bookid` INT(10) UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
 `Karte` INT (10) UNSIGNED NOT NULL
 );
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
 INSERT INTO Klasse (Karte) WERTE (FLOOR (1 + (RAND () * 20)));
  
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Buch(Karte)VALUES(FLOOR(1+(RAND()*20)));
 ​
 mysql> Index Y auf Buch (Karte) erstellen;
  Erklären Sie, wählen Sie * aus dem Buch links aus, treten Sie der Klasse bei, indem Sie auf Buch.Karte=Klasse.Karte klicken;
 +----+----------+----------+---------+-------+---------------+---------+---------+------+---------+------+------+---------+----------+----------+----------+----------------------------------------------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+---------+---------+------+---------+------+------+---------+----------+----------+----------+----------------------------------------------------+
 | 1 | SIMPLE | Buch | NULL | Index | NULL | Y | 4 | NULL | 20 | 100,00 | Index wird verwendet |
 | 1 | SIMPLE | Klasse | NULL | ALLE | NULL | NULL | NULL | NULL | 20 | 100,00 | Verwenden von „where“; Verwenden von Join-Puffern (Block Nested Loop) |
 +----+----------+----------+---------+-------+---------------+---------+---------+------+---------+------+------+---------+----------+----------+----------+----------------------------------------------------+
 2 Zeilen im Satz, 1 Warnung (0,00 Sek.)

Sie werden feststellen, dass es keinen großen Unterschied gibt und es sich immer noch um eine vollständige Tabellenabfrage handelt. Dies liegt daran, dass die beiden Tabellen linksverknüpft abgefragt werden. Die linke Tabelle muss vollständig abgefragt werden. Zu diesem Zeitpunkt ist es nur sinnvoll, einen Index für die rechte Tabelle zu erstellen.

Umgekehrt muss der rechte Link in der linken Tabelle indiziert sein, um nützlich zu sein

Erstellen Sie einen Index für die richtige Tabelle

 Erstelle den Index Y für die Klasse.
 Erklären Sie, wählen Sie * aus dem Buch links aus, treten Sie der Klasse bei, indem Sie auf Buch.Karte=Klasse.Karte klicken;
 +----+----------+----------+---------+-------+---------------+-----------+---------+----------------+------+----------+-------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+-----------+---------+----------------+------+----------+-------------+
 | 1 | SIMPLE | Buch | NULL | Index | NULL | Y | 4 | NULL | 20 | 100,00 | Index wird verwendet |
 | 1 | SIMPLE | Klasse | NULL | ref | Y | Y | 4 | db01.book.card | 1 | 100,00 | Index wird verwendet |
 +----+----------+----------+---------+-------+---------------+-----------+---------+----------------+------+----------+-------------+
 2 Zeilen im Satz, 1 Warnung (0,00 Sek.)

Sie werden feststellen, dass die richtige Tabelle nur einmal abgefragt wird. . Typ ist ref

Drei-Tabellen-Optimierung

 Tabelle erstellen, wenn „Telefon“ nicht vorhanden ist (
 `phoneid` INT(10) UNSIGNED NOT NULL PRIMARY KEY AUTO_INCREMENT,
 `Karte` INT (10) UNSIGNED NOT NULL
 )ENGINE = INNODB;
 ​
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));
 INSERT INTO Telefon(Karte)VALUES(FLOOR(1+(RAND()*20)));

Löschen Sie zuerst alle Indizes

 Index Y auf Buch löschen;
 Index Y auf Klasse löschen;
 Erklären Sie, dass Sie * aus der Klasse ausgewählt haben. Links schließen sich Buch an auf Klasse.Karte=Buch.Karte. Links schließen sich Telefon an auf Buch.Karte=Telefon.Karte.
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+----------------------------------------------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+----------------------------------------------------+
 | 1 | SIMPLE | Klasse | NULL | ALLE | NULL | NULL | NULL | NULL | 20 | 100,00 | NULL |
 | 1 | SIMPLE | Buch | NULL | ALL | NULL | NULL | NULL | NULL | 20 | 100,00 | Verwenden von „where“; Verwenden von Join-Puffern (Block Nested Loop) |
 | 1 | SIMPLE | Telefon | NULL | ALLE | NULL | NULL | NULL | NULL | 20 | 100,00 | Verwenden von „where“; Verwenden von Join-Puffern (Block Nested Loop) |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+----------------------------------------------------+
 3 Zeilen im Satz, 1 Warnung (0,00 Sek.)

Erstellen eines Indexes

 Erstelle den Index y auf dem Buch (der Karte).
 ​
 Erstellen Sie den Index z auf dem Telefon (der Karte).
 Erklären Sie, dass Sie * aus der Klasse ausgewählt haben. Links schließen sich Buch an auf Klasse.Karte=Buch.Karte. Links schließen sich Telefon an auf Buch.Karte=Telefon.Karte.
 +----+----------+----------+---------+------+---------------+------+---------+----------------+------+----------+-------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+------+---------------+------+---------+----------------+------+----------+-------------+
 | 1 | SIMPLE | Klasse | NULL | ALLE | NULL | NULL | NULL | NULL | 20 | 100,00 | NULL |
 | 1 | SIMPLE | Buch | NULL | ref | y | y | 4 | db01.class.card | 1 | 100,00 | Index wird verwendet |
 | 1 | SIMPLE | Telefon | NULL | ref | z | z | 4 | db01.book.card | 1 | 100,00 | Index wird verwendet |
 +----+----------+----------+---------+------+---------------+------+---------+----------------+------+----------+-------------+
 3 Zeilen im Satz, 1 Warnung (0,00 Sek.)

Sie werden feststellen, dass der Index erfolgreich erstellt wurde. . Allerdings left join 最左表必須全部查詢.

 Erstelle Index x auf Klasse (Karte);
 Erklären Sie, dass Sie * aus der Klasse ausgewählt haben. Links schließen sich Buch an auf Klasse.Karte=Buch.Karte. Links schließen sich Telefon an auf Buch.Karte=Telefon.Karte.
 +----+----------+----------+---------+-------+---------------+------+---------+----------------+------+----------+-------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+------+---------+----------------+------+----------+-------------+
 | 1 | SIMPLE | Klasse | NULL | Index | NULL | x | 4 | NULL | 20 | 100,00 | Index wird verwendet |
 | 1 | SIMPLE | Buch | NULL | ref | y | y | 4 | db01.class.card | 1 | 100,00 | Index wird verwendet |
 | 1 | SIMPLE | Telefon | NULL | ref | z | z | 4 | db01.book.card | 1 | 100,00 | Index wird verwendet |
 +----+----------+----------+---------+-------+---------------+------+---------+----------------+------+----------+-------------+
 3 Zeilen im Satz, 1 Warnung (0,00 Sek.)

Das Ergebnis ist immer noch das gleiche

Tabelle erstellen

 CREATE TABLE-Mitarbeiter (
 Ich würde INT PRIMARY KEY AUTO_INCREMENT,
 `name` VARCHAR(24)NOT NULL DEFAULT'' KOMMENTAR'Name',
 `Alter` INT NICHT NULL STANDARD 0 KOMMENTAR'Alter',
 `pos` VARCHAR(20) NOT NULL DEFAULT'' KOMMENTAR'Position',
 `add_time` TIMESTAMP NICHT NULL STANDARD CURRENT_TIMESTAMP KOMMENTAR „Job-Eintrittszeit“
 )CHARSET utf8 COMMENT'Mitarbeiterdatensatztabelle';
 INSERT INTO staffs(`name`,`alter`,`pos`,`add_time`) VALUES('z3',22,'manager',NOW());
 INSERT INTO staffs(`name`,`alter`,`pos`,`add_time`) VALUES('Juli',23,'dev',NOW());
 INSERT INTO staffs(`name`,`alter`,`pos`,`add_time`) VALUES('2000',23,'dev',NOW());
Erstellen Sie einen Index ALTER TABLE staffs ADD INDEX index_staffs_nameAgePos(`name`,`age`,`pos`);

Index-Tipps

  • 1. Der führende Index kann nicht verloren gehen und der mittlere Index kann nicht unterbrochen werden: Wenn Sie einen zusammengesetzten Index erstellen, müssen Sie den führenden Index einschließen. Sie können den mittleren Index nicht überspringen und die folgenden Indizes direkt verwenden. Um die folgenden Indizes zu verwenden, müssen Sie den mittleren Index hinzufügen (Sie können zuerst den folgenden Index und dann den mittleren Index verwenden, aber Sie können den folgenden Index nicht direkt verwenden und den mittleren Index überspringen) (für wo)

Aus der obigen Abbildung ist ersichtlich, dass der Index nicht verwendet werden kann, wenn der Name übersprungen wird

 mysql> erläutern Sie „select * from staffs where name='july';“
 +----+----------+--------+------------+------+-------------------------+-------------------------+----------+----------+-------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+--------+------------+------+-------------------------+-------------------------+----------+----------+-------+------+------+------+
 | 1 | EINFACH | Mitarbeiter | NULL | ref | index_staffs_nameAgePos | index_staffs_nameAgePos | 74 | const | 1 | 100,00 | NULL |
 +----+----------+--------+------------+------+-------------------------+-------------------------+----------+----------+-------+------+------+------+
 1 Zeile im Satz, 1 Warnung (0,00 Sek.)
 ​
 mysql> erläutern Sie „select * from staffs“, wobei Name='Juli' und Pos='dev';
 +----+----------+--------+------------+------+-------------------------+-------------------------+----------+----------+----------+----------+----------+----------+---------------------------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+--------+------------+------+-------------------------+-------------------------+----------+----------+----------+----------+----------+----------+---------------------------+
 | 1 | SIMPLE | staffs | NULL | ref | index_staffs_nameAgePos | index_staffs_nameAgePos | 74 | const | 1 | 33.33 | Indexbedingung wird verwendet |
 +----+----------+--------+------------+------+-------------------------+-------------------------+----------+----------+----------+----------+----------+----------+---------------------------+
 1 Zeile im Satz, 1 Warnung (0,00 Sek.)

Aus der Anweisung ist ersichtlich, dass key_len nach dem Überspringen des mittleren Index unverändert bleibt, was beweist, dass der Index pos nicht verwendet wird.

  • 2. Es können keine Operationen (Berechnungen, Typkonvertierungen usw.) an Indexspalten durchgeführt werden
  • 3. Die Speicher-Engine kann die Spalten rechts von der Bereichsbedingung nicht im Index verwenden (weniger Berechnungen in der Indexspalte)
  • 4. Versuchen Sie, abdeckende Indizes zu verwenden, dh Abfragen, die nur auf den Index zugreifen, um die Verwendung von select * zu reduzieren
  • 5. Verwenden Sie weniger (!=, <>, <, >) ist nicht null, ist null;
  • 6. Like beginnt mit „%“, was dazu führt, dass der Index fehlschlägt (verwenden Sie einen überdeckenden Index, um Indexfehler zu vermeiden). Überdeckender Index: (die Reihenfolge des erstellten Index sollte mit der Reihenfolge der abgefragten Felder übereinstimmen).
  • 7. Wenn die Zeichenfolge nicht in einfache Anführungszeichen eingeschlossen ist, ist der Index ungültig (MySQL erzwingt die Konvertierung des Zeichenfolgentyps, wodurch der Index ungültig wird).
  • 8. Verwenden Sie oder weniger, da sonst die Verbindung fehlschlägt

Indexfall

Angenommener Index (a, b, c)

Y bedeutet, dass alle Indizes verwendet werden, N bedeutet, dass keiner davon verwendet wird

where-Anweisung Wird der Index verwendet?
wobei a = 3 und c = 5 (b ist in der Mitte unterbrochen) a wird verwendet, aber c wird nicht verwendet
wobei a=3 und b=4 und c=5 Y
wobei a=3 und c=5 und b=4 Hier optimiert MySQL automatisch die Sortierung der Anweisungen
wobei a=3 und b>4 und c=5 a,b wird verwendet
wobei a=3 und b wie 'k%' und c=5 Y beginnt wie alle Konstanten mit dem Index
wobei b=3 und c=4 N
wobei a=3 und c>5 und b=4 Y: MySQL optimiert automatisch den Anweisungssortierbereich C, bevor der Index ungültig wird
wobei b = 3 und c = 4 und a = 2 Y: MySQL optimiert automatisch die Reihenfolge der Aussagen
wobei c = 5 und b = 4 und a = 3 Y: MySQL optimiert automatisch die Reihenfolge der Aussagen

Annehmen Index (a, b, c, d)

 table test03 erstellen (
 ID int Primärschlüssel nicht null auto_increment,
 ein int (10),
 B int (10),
 c int (10),
 D int (10),
 ​
 Einfügen in test03 (a, b, c, d) Werte (3,4,5,6);
 Einfügen in test03 (a, b, c, d) Werte (3,4,5,6);
 Einfügen in test03 (a, b, c, d) Werte (3,4,5,6);
 Einfügen in test03 (a, b, c, d) Werte (3,4,5,6);
 ​
 erstellen index idx_test03_abcd auf test03 (a, b, c, d);

###

wobei a = 3 und b> 4 und c = 5 Wenn A und B verwendet werden, werden alle Indizes nach B ungültig.
wobei a = 3 und b = 4 und d = 6 bestellen durch c A und B werden verwendet.
wobei a = 3 und b = 4 bestellen durch c A und B werden verwendet.
wobei a = 3 und b = 4 Ordnung durch d Wenn Sie A und B verwenden, führt das Überspringen von C hier zur Verwendung von Dateienort
wobei a = 3 und d = 6 bestellen by b, c A wird verwendet und die Sortierung verwendet die Indizes B und c.
wobei a = 3 und d = 6 bestellen durch c, b Die Verwendung von A wird mit Dateiort generiert, da b übersprungen wird, um c zu sortieren.
wobei a = 3 und b = 4 Ordnung durch b, c Ich benutze alle
wobei a = 3 und b = 4 und d & ## 61; 6 bestellt von c, b Die Verwendung von A und B erzeugt nicht mit Filesort, da B vor dem Sortieren von C und B abfragt wird.

Gruppe ist schwerwiegender.

Reihenfolge nach Indexoptimierung

Auftragsbedingung Extra
wo a> 4 bestellen von a Verwenden Sie die Verwaltung des Index
wo a> 4 bestellen von a, b Verwenden Sie die Verwaltung des Index
wo a> 4 bestellen von b Verwenden Sie die Verwenden von Index mithilfe von DateiSort (der Anführer hinter der Reihenfolge von ist nicht da)
wo a> 4 bestellen by b, a Verwenden Sie bei Verwenden von Index mithilfe von DateiSort (bestellen nach der Bestellung).
wobei a = const order von b, c Wenn das Präfix des links des Index, der in Wo als Konstante definiert ist, verwendet wird, kann die Reihenfolge durch den Index verwenden
wobei a = const und b = const order durch c Wenn das Präfix des Index links als Konstante definiert ist, kann die Bestellung durch den Index verwendet werden
wobei a = const und b> 3 bestellen von bc Verwenden Sie die Verwaltung des Index
Ordnung durch einen ASC, b Desc, c dessen Sortieren inkonsistente Aufzüge

Exsites

 Wählen Sie a.* Aus A A, wo existiert (wählen Sie 1 aus B b, wo a.id = b.id)
 Die obige Abfrage verwendet die existierende Aussage.
 LISTE ERGEBNISSETE = [];
 für (int i = 0; i <A.Length; i ++) {if (existiert (a [i] .id) {// Auswählen 1 aus b b, wobei b.id = a.id feststellt, ob es ein Datensatz gibt. Rückgabeergebnis.
 ​
 Wenn die Daten in Tabelle B größer als die in Tabelle A sind, ist es geeignet, zu verwenden (), da sie nicht so viele Durchfahrten benötigt und die Abfrage nur erneut ausführen muss. 10.000 Mal, da es nur die A.Length -Zeiten in Tabelle B ausführt, ist es für ein weiteres Beispiel für die Arbeit von 10.000 Datensätzen. Das Erstellen der Datenbank verbraucht eine höhere Leistung, und der Speichervergleich ist sehr schnell.

MySQL Slow Query Log -Befehl

Zeigen Sie Variablen wie '%Slow_query_log%';

Zeigt an, ob MySQL Slow Query -Protokoll aktiviert werden soll

Setzen Sie Global Slow_query_log = 0;

Schalten Sie MySQL langsames Query -Protokoll aus

Setzen Sie Global Slow_query_log = 1;

Aktivieren Sie MySQL langsames Abfrageprotokoll

Zeigen Sie Variablen wie '%long_query_time%';

Zeigt an, wie lange eine langsame Frage dauert

Setzen Sie global long_quert_time = 10;

Ändern Sie die langsame Abfragezeit auf 10 Sekunden.

Zeigen Sie den globalen Status wie '%Slow_queries%';

Zeigt insgesamt mehrere langsame Anweisungen an

[root@IZ0JLH1ZN42CGFTMRF6P6SZ-Daten]# Cat MySQL-Slow.log

Linux Abfrage langsam SQL

Funktionsbetriebs -Batch -Daten einfügen Daten

 Tischabteilung erstellen (
    ID int nicht signiert Primärschlüssel Auto_increment,
    DEPTNO MEDEILTINT STRAGEND NICHT NULL DEFAULT 0,
    dname varchar (20) nicht null Standard '',
    loc varchar (13) nicht null Standard '' ''
 ) Motor = innoDB Standard charSet = gbk;
 Table emp erstellen (
    ID int nicht signiert Primärschlüssel Auto_increment,
    Empno Medium in nicht signiertes Null -Standard 0, #Number Enname Varchar (20) Null Standard '', #Name Job Varchar (9) Null -Standard ', #job mgr Mediumint in nicht signiert nicht null Standard 0 #Departmentnummer) Engine = innoDB Standard charSet = gbk; 

 Variablen wie 'log_bin_trust_function_creators' anzeigen;
 Setzen Sie global log_bin_trust_function_creators = 1;

創建函數：隨機產生部門編號隨機產生字符串

DELIMITER $$ ist, dass SQL alle mit der Funktionserstellung endet.

// Funktion 1 definieren 1

 Abgrenzer $$
 Funktion erstellen rand_string (n int) gibt varchar (255) zurück
 BEGINNEN
    Declare chars_set varchar (100) Standard 'abcdefgHigklMnopqrstuvwxyzabcdefgHigklMnopqrstuvwxyz';
    Deklary return_str varchar (255) Standard '';
    Declare I int Standard 0;
    Während ich es tue
       Return_str = concat (return_str, substring (chars_set, floor (1 + rand ()*52), 1)) festlegen;
       Set i = i + 1;
    Ende während;
    Return return_str;
 Ende $$
// Funktion 2 definieren

 Abgrenzer $$
 Funktion erstellen rand_num () gibt int (5) zurück
 BEGINNEN
    Declare I int Standard 0;
    Set I = Boden (100 + Rand ()*10);
    Kehre I zurück;
 Ende $$
// gespeichertes Verfahren definieren 1

 Abgrenzer $$
 Procedure CREFORTURE Insert_emp erstellen (in start int (10) in max_num int (10)))
 BEGINNEN
    Declare I int Standard 0;
    Setzen Sie AutoCommit = 0;
    WIEDERHOLEN
    Set i = i + 1;
    In EMP (EMPNO, ENNAME, HOB, MGR, MIEBER, SAL, COMM, DEPTNO) VERWEISUNGEN ((START + I), RAND_STRING (6), 'Verkäufer', 0001, Curdate (), 2000.400, Rand_num ());
    Bis ich = max_num  
    Ende Wiederholung;
    BEGEHEN;
 Ende $$
// gespeichertes Verfahren definieren 2

 Abgrenzer $$
 Procedure erstellen insert_dept (in start int (10) in max_num int (10)))
 BEGINNEN
    Declare I int Standard 0;
    Setzen Sie AutoCommit = 0;
    WIEDERHOLEN
    Set i = i + 1;
    In die Abteilung (Deptno, Dname, Loc) einfügen ((Start + i), Rand_String (10), Rand_String (8));
    Bis ich = max_num  
    Ende Wiederholung;
    BEGEHEN;
 Ende $$
// Einfügen von Datenbegrenzung;
 CALL Insert_dept (100,10);
 CALL Insert_emp (100001.500000);

Profilanalyse SQL anzeigen

 MySQL> Variablen wie 'Profiling' anzeigen;
 +---------------+-------+
 |
 +---------------+-------+
 |
 +---------------+-------+
 1 Zeile im Satz (0,00 Sek.)
 ​
 MySQL> Set Profiling = on;
 Abfrage OK, 0 Zeilen betroffen, 1 Warnung (0,00 Sek.)
 ​
 MySQL> Variablen wie 'Profiling' anzeigen;
 +---------------+-------+
 |
 +---------------+-------+
 |
 +---------------+-------+
 1 Zeile in Set (0,01 Sek.)

Schreiben Sie zufällig ein paar Einfügenanweisungen '

Zeigt die Geschwindigkeit der Anweisungen für Abfragebetriebe an

 MySQL> Showprofile;
 +----------+------------+--------------------------------------------------------+
 |
 +----------+------------+--------------------------------------------------------+
 |.
 |.
 |.
 |
 |.
 |.
 |.
 |.
 |.
 |.
 |.
 |.
 +----------+------------+--------------------------------------------------------+
 12 Zeilen im Set, 1 Warnung (0,00 Sekunden)

Anmelden Abfrageprozess SQL Lebenszyklus anzeigen

 MySQL> Profil CPU anzeigen, blockieren Sie IO für Abfrage 3;
 +----------------------+----------+----------+------------+--------------+---------------+
 |
 +----------------------+----------+----------+------------+--------------+---------------+
 |
 |
 |
 |
 |
 |
 |
 |
 +----------------------+----------+----------+------------+--------------+---------------+
 8 Zeilen im Set, 1 Warnung (0,00 Sekunden)
 ​
 MySQL> Profil CPU anzeigen, blockieren Sie IO für Abfrage 12;
 +----------------------+----------+----------+------------+--------------+---------------+
 |
 +----------------------+----------+----------+------------+--------------+---------------+
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 |
 +----------------------+----------+----------+------------+--------------+---------------+
 20 Zeilen im Set, 1 Warnung (0,00 Sekunden)

Wenn eines der oben genannten vier auftritt, muss die Anweisung der Abfrage optimiert werden

Globales Query -Protokoll

  Setzen Sie Global General_log = 1;
 Setzen Sie global log_output = 'table';

Danach werden die SQL -Anweisungen, die Sie schreiben

 Wählen Sie * aus mySQL.AGERERAL_LOG;
 MySQL> SELECT * von MySQL.AGERERAL_LOG;
 +----------------------------+-----------------------+-----------+-----------+--------------+--------------------------+
 |
 +----------------------------+-----------------------+-----------+-----------+--------------+--------------------------+
 |.
 +----------------------------+-----------------------+-----------+-----------+--------------+--------------------------+
 1 Zeile im Satz (0,00 Sek.)

Mysql Lock

  • Lesen Sie Lock (Shared Lock): Mehrere Lesevorgänge können gleichzeitig mit denselben Daten ausgeführt werden, ohne sich gegenseitig zu beeinflussen.
  • Schreibschloss (exklusive Sperre): Wenn der aktuelle Schreibvorgang nicht abgeschlossen ist, blockiert sie andere Schreibschlösser und lesen Sperren
  • Reihenverriegelung: InnoDB -Motor bevorzugt mit hohem Overhead, langsamer Verriegelung und Deadlock: Hat die kleinste Verriegelungskörnung, die niedrigste Wahrscheinlichkeit von Lock -Konflikten und hohe Zuschauer
  • Tischschloss: Zuletzt den MyISAM -Motor mit niedrigem Overhead und schneller Verriegelung;

Testen Sie die Tabellenschloss unten

 Verwenden Sie Big_data;
 ​
 Tisch mylock erstellen (
 ID int nicht null primäre Schlüssel auto_increment,
 Nennen Sie Varchar (20) Standard '' '
 ) Motor myisam;
 ​
 Einfügen in MyLock (Name) -Werte ('a');
 Einfügen in MyLock (Name) -Werte ('B');
 In MyLock (Name) -Werte einfügen ('C');
 In MyLock (Name) -Werte einfügen ('D');
 In MyLock (Name) -Werte einfügen ('e');
 ​
 Wählen Sie * aus mylock;

Befehl sperren

 Sperre Table Mylock lesen, Buch schreiben; ## Lesen Sperren Mylock Schreiben Sie Schlossbuch
 Zeigen Sie offene Tische; ## zeigen, welche Tische entsperrt sind.

Tischschloss: Lesen Sie das Schloss

 ## Nach dem Hinzufügen einer Lesesperrung kann es nicht modifiziert werden
 Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
 ​
 mysql> aus mylock; ## 1 auswählen
 +----+------+
 |
 +----+------+
 |
 |
 |
 |
 |
 +----+------+
 5 Zeilen im Satz (0,00 Sek.)
 ​
 MySQL> Aktualisieren Sie mylock set name = 'a2' wobei ID = 1;
 Fehler 1099 (HY000): Tabelle 'Mylock' wurde mit einer Lesesperrung gesperrt und kann nicht aktualisiert werden
 ## kann die derzeit durch Lesesperrung gesperrte Tabelle nicht ändern. ## kann andere Tabellen nicht lesen
 Fehler 1100 (HY000): Tabelle 'Buch' war nicht mit Sperrtabellen gesperrt

Um die beiden Befehle zu unterscheiden, behandeln Sie 1 die Operation am ursprünglichen MySQL -Befehlsterminal und 2 als neu erstellte MySQL -Terminal.

Erstellen Sie einen neuen Befehlsvorgang von MySQL Terminal

 ## Erstellen Sie eine neue MySQL -Terminal -OperationMysql> Aktualisieren Sie MyLock set name = 'a3' wobei ID = 1;

Blockiervorgänge werden gefunden

Stornieren Sie die Sperre am ursprünglichen MySQL -Befehlsterminal

 Tische entsperren; ## 1
 Abfrage OK, 1 Zeile betroffen (2 min 1,46 Sek.) ## 2
 Zeilen übereinstimmend: 1 geändert: 1 Warnungen: 0 ## 2

Sie werden feststellen, dass es mehr als zwei Minuten blockiert wurde.

Zusammenfassung: Nach dem Lesen und Sperren der Tabelle MyLock: 1. Abfragebetrieb: Der aktuelle Client (Terminalbefehl Operation 1) kann die Tabelle MyLock abfragen

Andere Clients (Terminalbefehlsoperation 2) können auch die Tabelle Mylock 2. DML -Operationen (hinzufügen, löschen und ändern) im aktuellen Client fehlschlagen und einen Fehlerfehler 1099 (HY000): Tabelle 'MyLock' wurde mit einer Lesesperrung gesperrt und kann nicht aktualisiert werden.

Tischschloss: Schreiben Sie Schloss

 MySQL> Sperrtabelle Mylock schreiben;
 Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
Fügen Sie der aktuellen Sitzung MyLock Tabelle mySQL> MyLock Set name = 'a4'where id = 1 hinzu.
 Abfrage OK, 1 Zeile betroffen (0,00 Sekunden)
 Zeilen übereinstimmen: 1 geändert: 1 Warnungen: 0
 ​
 MySQL> SELECT * aus MyLock;
 +----+------+
 |
 +----+------+
 |
 |
 |
 |
 |
 +----+------+
 MySQL> Ausgewählte * aus Buch;
 Fehler 1100 (HY000): Tabelle 'Buch' war nicht mit Sperrtabellen gesperrt

Sie werden feststellen, dass Sie andere Tabellen nicht bedienen können, aber die gesperrte Tabelle bedienen können.

Öffnen Sie einen neuen Client, um den gesperrten Tisch zu testen

 MySQL> SELECT * aus MyLock;
 ​
 5 Zeilen in Set (2 min 30,92 Sek.)

Es wurde festgestellt, dass die durch die Schreibschlosse gesperrte Tabelle blockiert wird, wenn der neue Client arbeitet (hinzufügen, löschen, ändern und abfragen).

Tun

Analyse Tabelle Lock

 MySQL> Status wie 'Tabelle%' anzeigen;
 +----------------------------+-------+
 |
 +----------------------------+-------+
 |
 |
 |
 |
 |
 +----------------------------+-------+
 5 Zeilen im Satz (0,00 Sek.)

Reihenschloss

InnoDB Row Lock -Modus

InnoDB implementiert die folgenden zwei Arten von Zeilenschlössern.

  • Shared Sperle (en): Kurz gesagt, auch als Leserschloss oder S -Sperre bezeichnet.
  • Exklusive Sperre (X): Auch als Schreibschloss oder Kurzschluss X Lock.

Für Aktualisierung, Löschen und Einfügen von Anweisungen fügt InnoDB dem Datensatz automatisch eine exklusive Sperre (x) hinzu.

Für normale Auswahlanweisungen fügt InnoDB keine Sperren hinzu.

Sie können die folgende Anweisung verwenden, um dem Datensatzsatz explizit eine gemeinsam genutzte Sperre oder eine exklusive Sperre hinzuzufügen.

 Shared Sperle (en): Wählen Sie * aus table_name wobei ... Sperren im Freigabemodus
 ​
 Exklusive Sperre (x): Wählen Sie * aus table_name WHERE ... FÜR UPDATE

Da Zeilenverriegelungen Transaktionen unterstützen, überprüfen wir sie hier hier

Transaktionen

Eine Transaktion ist eine logische Verarbeitungseinheit, die aus einer Gruppe von SQL -Anweisungen besteht.

  • Atomizität: Eine Transaktion ist eine Atombetriebseinheit, und ihre Vorgänge für Daten werden entweder alle ausgeführt oder überhaupt nicht ausgeführt.
  • Konsistenz: Die Daten müssen in einem konsistenten Zustand bleiben, wenn eine Transaktion beginnt und abgeschlossen wird. Dies bedeutet, dass alle relevanten Daten auf die Änderungen der Transaktion angewendet werden müssen, um die Datenintegrität aufrechtzuerhalten.
  • Isolierung: Die Datenbank bietet einen bestimmten Isolationsmechanismus, um sicherzustellen, dass Transaktionen in einer "unabhängigen" Umgebung ausgeführt werden, die nicht von externen gleichzeitigen Operationen beeinflusst wird. Dies bedeutet, dass die Zwischenzustände des Transaktionsprozesses für die Außenwelt nicht sichtbar sind und umgekehrt.
  • Langlebig: Nach Abschluss der Transaktion ist der Betrieb mit den Daten dauerhaft und kann auch dann beibehalten werden, wenn ein Systemfehler auftritt.

Probleme, die durch gleichzeitige Transaktionen verursacht werden:

Verlorene Updates, schmutzige Lesevorgänge, nicht wiederholbare Lesevorgänge, liest Phantom

Säureeigenschaften Bedeutung
Atomizität Eine Transaktion ist eine Atombetriebseinheit, und ihre Änderungen an Daten sind entweder alle erfolgreich oder alle fehlgeschlagen.
Konsistent Die Daten müssen in einem konsistenten Zustand sowohl zu Beginn einer Transaktion als auch nach Abschluss sein.
Isolierung Das Datenbanksystem bietet einen bestimmten Isolationsmechanismus, um sicherzustellen, dass Transaktionen in einer "unabhängigen" Umgebung ausgeführt werden, die nicht von externen gleichzeitigen Vorgängen beeinflusst wird.
Dauerhaft Nach Abschluss der Transaktion sind die Änderungen an den Daten dauerhaft.

Probleme mit der gleichzeitigen Transaktionsverarbeitung

Frage Bedeutung
Verlorenes Update Wenn zwei oder mehr Transaktionen dieselbe Zeile auswählen, wird der durch die anfängliche Transaktion modifizierte Wert durch den durch die nachfolgenden Transaktion modifizierten Wert überschrieben.
Dirty liest Wenn eine Transaktion auf Daten zugreift und die Daten geändert hat, die Änderung jedoch noch nicht in die Datenbank verpflichtet wurde, greift eine andere Transaktion auch auf die Daten zu und verwendet sie.
Nicht wiederholbare Lesevorgänge Irgendwann nach einer Transaktion wird bestimmte Daten gelesen, die zuvor gelesenen Daten erneut gelesen und stellt fest, dass die Daten mit den zuvor gelesenen Daten nicht übereinstimmen.
Phantom liest Eine Transaktion löst zuvor Daten nach denselben Abfragebedingungen erneut aus, stellt jedoch fest, dass andere Transaktionen neue Daten eingefügt haben, die den Abfragebedingungen erfüllen.

Transaktions -Isolationsstufe

Um das oben erwähnte Transaktionsproblem zu lösen, bietet die Datenbank einen bestimmten Transaktions -Isolierungsmechanismus, um dieses Problem zu lösen. Je strenger die Transaktions -Isolierung der Datenbank ist, desto kleiner die Nebenwirkungen der Parallelität, desto größer ist der gezahlte Preis, da die Transaktionsisolation im Wesentlichen die Verwendung von Transaktionen in gewissem Maße "serialisieren" ist, was offensichtlich der "Parallelität" widersprüchlich ist.

Es gibt vier Isolationsstufen für die Datenbank, von niedrig bis hoch: Lesen Sie nicht übereinstimmende, wiederholbare Lektüre und serialisierbar.

Isolationsniveau Verlorene Updates Schmutzige Lektüre Nicht wiederholbar lesen Phantom lesen
Lesen Sie unbekannt × √ √ √
Lesen Sie engagiert × × √ √
Wiederholbares Lesen (Standard) × × × √
Serialisierbar × × × ×

Hinweis: √ 代表可能出現， × 代表不會出現.

Die Standard -Isolationsstufe der MySQL -Datenbank ist wiederholbar.

 Zeigen Sie Variablen wie 'TX_ISolation';

Erstellung von Zeilensperrungstabellen, Fallvorbereitung

 table test_innodb_lock erstellen (
    id int (11),
    Nennen Sie Varchar (16),
    Geschlechtsvarchar (1)
 ) Engine = InnoDB Standard charSet = utf8;
 ​
 In test_innodb_lock -Werte einfügen (1, '100', '1');
 In test_innodb_lock -Werte einfügen (3, '3', '1');
 In test_innodb_lock -Werte einfügen (4, '400', '0');
 In test_innodb_lock -Werte einfügen (5, '500', '1');
 In test_innodb_lock -Werte einfügen (6, '600', '0');
 Einfügen in test_innodb_lock -Werte (7, '700', '0');
 In test_innodb_lock -Werte einfügen (8, '800', '1');
 In test_innodb_lock -Werte einfügen (9, '900', '1');
 In test_innodb_lock -Werte einfügen (1, '200', '0');
 ​
 erstellen index idx_test_innodb_lock_id auf test_innodb_lock (id);
 erstellen index idx_test_innodb_lock_name unter test_innodb_lock (name);

Zeilenverriegelungstest

Oder zwei Terminals zum Testen öffnen und die automatische Transaktionsabgabe deaktivieren, da die automatische Übermittlung der Transaktion die Sperre automatisch sperrt und loslässt.

 MySQL> Setzen Sie autocommit = 0;

 MySQL> Setzen Sie autocommit = 0;

Sie werden feststellen, dass die Abfrage keinen Einfluss hat

Aktualisieren Sie die linke Seite

 MySQL> Aktualisieren Sie test_innodb_lock set name = '100' wobei id = 3;
 Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
 Zeilen übereinstimmen: 1 geändert: 0 Warnungen: 0

Aktualisieren Sie die linke Seite

Stoppen Sie den Vorgang, nachdem Sie die rechte Seite aktualisiert haben

 MySQL> aktualisieren test_innodb_lock set name = '340' wobei id = 3;
 Fehler 1205 (HY000): Die Wartezeitsperrung überschritten;

Sie werden feststellen, dass es blockiert ist, bis das Schloss freigegeben oder die Transaktion begangen wird.

對于innodb引擎來說，對某一行數據進行DML（增刪改）操作會對操作的那行添加排它鎖

Andere Transaktionen können diese Anweisung nicht ausführen, sondern können Daten in anderen Zeilen ausführen.

無索引行鎖會升級成表鎖：如果不通過索引條件檢索數據，那么innodb會對表中所有記錄加鎖，實際效果和表鎖一樣

Denken Sie daran, bei der Durchführung von Operationen Indizes zu verwenden: Wenn der InnoDB -Engine -Index ausfällt

 MySQL> Aktualisieren Sie test_innodb_lock sex = '2' wobei Name = 400;
 Abfrage OK, 0 Zeilen betroffen (0,00 Sek.)
 Zeilen übereinstimmen: 2 geändert: 0 Warnungen: 0

Beachten Sie, dass der Index ungültig ist, wenn der Name nicht in einzelnen Zitate eingeschlossen ist

 MySQL> Aktualisieren Sie test_innodb_lock sex = '3' wobei ID = 3;
 Abfrage OK, 1 Zeile betroffen (23,20 Sek.)
 Zeilen übereinstimmen: 1 geändert: 1 Warnungen: 0

Es wurde festgestellt, dass die Operationen auf anderen Zeilen ebenfalls blockiert wurden.

Ursprünglich wurde nur eine Datenzeile gesperrt, aber da ich vergessen habe, dem Feld des Namens ein einzelnes Zitate hinzuzufügen, wurde der Index ungültig und die gesamte Tabelle wurde gesperrt.

Gap Lock

Wenn wir eine Reichweite anstelle einer Wartezeit verwenden, um Daten abzurufen und eine gemeinsame oder exklusive Sperre anzufordern, wird in dieser Reichweite eine nicht existierende Aufzeichnung vorliegt, die als Lücke bezeichnet wird.

 MySQL> SELECT * aus test_innodb_lock;
 +------+------+------+
 |
 +------+------+------+
 |
 |
 |
 |
 |
 |
 |
 |
 |
 +------+------+------+
 Es gibt keine Daten mit ID 2

Überprüfen Sie den Status der Zeilensperrungsanforderung an

 MySQL> Status wie 'innoDB_ROW_LOCK%';
 +---------------------------+--------+
 |
 +---------------------------+--------+
 |
 |
 |
 |
 |
 +---------------------------+--------+
 5 Zeilen im Satz (0,00 Sek.)
 INNODB_ROW_LOCK_CURRENT_WAITS: Die Anzahl der Zeilen, die derzeit auf Schlösser warten.
 INNODB_ROW_LOCK_TIME: Die Gesamtdauer von Systemstart bis jetzt.
 INNODB_ROW_LOCK_TIME_AVG: Durchschnittliche Zeit, die jedes Mal gewartet hat
 INNODB_ROW_LOCK_TIME_MAX: Die längste Wartezeit vom Systemstart bis jetzt.
 INNODB_ROW_LOCK_WAITS: Die Gesamtzahl der Waiten seit Beginn des Systems

Zeilensperre Zusammenfassung

Die InnoDB Storage Engine implementiert die Verriegelung auf Reihenebene. Wenn das System der Systeme hoch ist, hat die Gesamtleistung von InnoDB einen klaren Vorteil gegenüber MyISAM.

InnoDbs Zeilenebene haben jedoch auch ihre zerbrechliche Seite.

Optimierungsvorschläge:

  • Wenn möglich, sollten alle Datenabrufe über Indizes durchgeführt werden, um zu verhindern, dass Nicht-Index-Zeilenschlösser auf Tabellenverriegelungen aktualisiert werden.
  • Entwurfsindizes vernünftigerweise, um den Umfang von Schlössern zu minimieren
  • Minimieren Sie die Indexbedingungen und Indexbereiche, um Lückensperrungen zu vermeiden
  • Versuchen Sie, die Transaktionsgröße zu kontrollieren und die Menge an gesperrten Ressourcen und die Zeitdauer zu verringern
  • Verwenden Sie nach Möglichkeit eine Transaktions-Isolation mit niedriger Ebene (das Unternehmen muss jedoch erfüllt sein)

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.

Das könnte Sie auch interessieren:
  • Detaillierte Erläuterung der Transaktions -Isolationsniveaus in MySQL -Studiennotizen
  • MySQL Learning Notes helfen Dokumentieren
  • MySQL Learning Notes: Data Engine
  • Grundkenntnisse über MySQL -Lernnotizen
  • MySQL Learning Notes: So fügen Sie Daten hinzu, löschen und ändern Sie
  • MySQL Learning Notes: Erstellen, Löschen und Ändern von Tabellen
  • Zusammenfassung von MySQL -Lernnotizen
  • Eine Zusammenfassung der MySQL -Studiennotizen von 1.000 Zeilen
  • MySQL Learning Notes 5: Tabelle ändern (Alter Tabelle)
  • MySQL Learning Notes 4: Integritätsbeschränkungs -Beschränkungsfelder
  • MySQL Learning Notes 1: Installation und Anmeldung (mehrere Methoden)

<<:  Lösen Sie das Problem der automatischen HTML-Formatierung nach dem Speichern in vscode

>>:  Wettersymbol-Animationseffekt implementiert durch CSS3

Artikel empfehlen

JavaScript zur Implementierung der umfassendsten Codeanalyse eines einfachen Einkaufswagens (ES6 objektorientiert)

In diesem Artikel wird der spezifische JavaScript...

Schritte zur Erstellung einer React Fiber-Struktur

Inhaltsverzeichnis React-Fasererstellung 1. Bevor...

Codeblock-Hervorhebung kann kopiert und angezeigt werden js Plugin highlight.js + clipboard.js Integration

Vor allem aus zwei Gründen: 1. Hervorhebung/Zeile...

Probleme und Lösungen beim Verbinden des Knotens mit der MySQL-Datenbank

Ich habe heute eine neue Version von MySQL (8.0.2...

Ist MySQL eine relationale Datenbank?

MySQL ist ein relationales Datenbankverwaltungssy...

Analyse und Meinungen zum Design der Produktdetailseite auf der Taobao-Website (Bild)

...

Detaillierter Prozess der Installation und Bereitstellung von OnlyOffice in Docker

0. Systemanforderungen CPU I5-10400F oder höher S...

Implementierung von Linux-Dateisystemvorgängen

In dieser Lesenotiz werden hauptsächlich die Vorg...

MySQL Serie 8 MySQL Server-Variablen

Tutorial-Reihe MySQL-Reihe: Grundlegende Konzepte...

Lösung für das Problem, dass MySQL zwar bei der Installation in WAMP gestartet werden kann, nach dem Neustart jedoch nicht mehr

Nach der ersten Installation von Wamp können alle...

V-Bind in Vue verstehen

Inhaltsverzeichnis 1. Analyse des wichtigsten Que...

So ändern Sie das MySQL-Passwort unter Centos

1. MySQL-Anmeldeeinstellungen ändern: # vim /etc/...

JavaScript implementiert den Div-Maus-Drag-Effekt

In diesem Artikel wird der spezifische Code für J...

Detailliertes Tutorial zur Installation von MariaDB auf CentOS 8

Das Datenbankverwaltungssystem MariaDB ist ein Zw...

Installieren Sie mehrere PHP-Versionen für Nginx unter Linux

Wenn wir die LNPM-Serverumgebung installieren und...