Einführung in den EXPLAIN-Interpretationsbefehl in MySQL (mit Beispielen)-MySQL-Tutorial-php.cn

Dieser Artikel bietet Ihnen eine Einführung in den EXPLAIN-Interpretationsbefehl (mit Beispielen). Ich hoffe, er wird Ihnen als Referenz dienen.

1 EXPLAIN-Konzept

EXPLAIN liefert uns einige Informationen darüber, wie MySQL SQL ausführt:

EXPLAIN kann SELECT, DELETE, INSERT, REPLACE und UPDATE erklären und andere Anweisungen.
Wenn EXPLAIN mit interpretierbaren Anweisungen verwendet wird, zeigt MySQL einige Informationen über den SQL-Ausführungsplan vom Optimierer an. Das heißt, MySQL erklärt, wie es diese Anweisungen verarbeitet und wie die Tabellen verbunden sind. Ich würde gerne mehr Informationen darüber erhalten, wie EXPLAIN den Ausführungsplan erhält.
Wenn auf EXPLAIN eine Sitzungsverbindungs-ID anstelle einer ausführbaren Anweisung folgt, werden Sitzungsinformationen angezeigt.
Für SELECT-Anweisungen generiert EXPLAIN zusätzliche Informationen zum Ausführungsplan, die mit SHOW WARNINGS angezeigt werden können.
EXPLAIN eignet sich zum Überprüfen von Abfragen, die partitionierte Tabellen entwerfen.
Mit der Option FORMAT kann das Ausgabeformat ausgewählt werden. Wenn die Option FORMAT nicht konfiguriert ist, erfolgt die Ausgabe standardmäßig in tabellarischer Form. Mit der JSON-Option können die Informationen im JSON-Format angezeigt werden.

2 EXPLAIN-Ausgabespalteninformationen

EXPLAIN-Ausgabefeldinformationen
Erste Spalte: Spaltenname, zweite Spalte: Äquivalente Attribute, die in der Ausgabe angezeigt werden, wenn FORMAT = JSON-Name, dritte Spalte : Feldbedeutung

Column	JSON Name	Meaning
id	select_id	select标识号
select_type	None	select类型
table	table_name	这一行数据是关于哪张表的
partitions	partitions	匹配的分区，对于未分区表，该值为空
type	access_type	使用的连接类别,有无使用索引
possible_keys	possible_keys	MySQL能使用哪个索引在该表中找到行
key	key	MySQL实际决定使用的键（索引）
key_len	key_length	MySQL决定使用的键长度。如果键是NULL，长度为NULL
ref	ref	与索引关联的列
rows	rows	mysql认为执行sql时必须被校验的行数
filtered	filtered	表示此查询条件所过滤的数据的百分比
Extra	None	附加信息

2.1 id

SELECT-Bezeichner. SELECT Die Sequenznummer in der Abfrage, die leer sein kann.

2.2 select_type

SELECT-Typ, alle Typen sind in der Tabelle unten aufgeführt, EXPLAIN im JSON-Format macht den SELECT-Typ als Attribut von query_block verfügbar, es sei denn, er ist SIMPLE oder PRIMARY. Der JSON-Name (falls zutreffend, keiner) wird ebenfalls in der Tabelle angezeigt.

select_type Value	JSON Name	Meaning
SIMPLE	None	简单SELECT(不使用UNION或子查询等)
PRIMARY	None	嵌套查询时最外层的查询
UNION	None	UNION中的第二个或后面的SELECT语句
DEPENDENT UNION	dependent (true)	UNION中的第二个或以后的SELECT语句，取决于外部查询
UNION RESULT	union_result	UNION的结果
SUBQUERY	None	子查询中的第一个选择
DEPENDENT SUBQUERY	dependent (true)	子查询中的第一个选择，取决于外部查询
DERIVED	None	派生表（子查询中产生的临时表）
MATERIALIZED	materialized_from_subquery	物化子查询
UNCACHEABLE SUBQUERY	cacheable (false)	无法缓存结果的子查询，必须对外部查询的每一行进行重新计算
UNCACHEABLE UNION	cacheable (false)	UNION中属于不可缓存子查询的第二个或以后的选择(请参 UNCACHEABLE SUBQUERY)

Tabelleninformationen (zur späteren Demonstration):

mysql> show create table t_a;
------+
| t_a   | CREATE TABLE `t_a` (
  `id` bigint(20) NOT NULL DEFAULT '0',
  `age` int(20) DEFAULT NULL,
  `code` int(20) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_code` (`code`),
  KEY `age_key` (`age`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk |
+-------+-----------------------------------
------+
1 row in set (0.03 sec)

Nach dem Login kopieren

SIMPLE: einfaches SELECT (ohne Verwendung von UNION oder Unterabfrage usw.)

mysql> explain select * from t_a where id =1;
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | t_a   | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.03 sec)

Nach dem Login kopieren

PRIMARY: die äußerste Abfrage beim Verschachteln von Abfragen

mysql> explain select * from t_a where num >(select num from t_a where id = 3);
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra                    |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
|  1 | PRIMARY     | t_a   | NULL       | range | num_key       | num_key | 5       | NULL  |    6 |   100.00 | Using where; Using index |
|  2 | SUBQUERY    | t_a   | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL                     |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
2 rows in set, 1 warning (0.03 sec)

Nach dem Login kopieren

UNION: Die zweite oder nachfolgende SELECT-Anweisung in UNION

mysql> explain select * from t_a where id =9 union all select * from t_a;
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra       |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+
|  1 | PRIMARY     | t_a   | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL        |
|  2 | UNION       | t_a   | NULL       | index | NULL          | num_key | 5       | NULL  |    9 |   100.00 | Using index |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------------+
2 rows in set, 1 warning (0.04 sec)

Nach dem Login kopieren

DEPENDENT UNION: Die zweite oder nachfolgende SELECT-Anweisung in UNION, abhängig von der externen Abfrage

mysql> explain select * from t_a where id in (select id from t_a where id >8 union all select id from t_a where id =5);
+----+--------------------+-------+------------+--------+---------------+---------+---------+-------+------+----------+--------------------------+
| id | select_type        | table | partitions | type   | possible_keys | key     | key_len | ref   | rows | filtered | Extra                    |
+----+--------------------+-------+------------+--------+---------------+---------+---------+-------+------+----------+--------------------------+
|  1 | PRIMARY            | t_a   | NULL       | index  | NULL          | num_key | 5       | NULL  |    9 |   100.00 | Using where; Using index |
|  2 | DEPENDENT SUBQUERY | t_a   | NULL       | eq_ref | PRIMARY       | PRIMARY | 8       | func  |    1 |   100.00 | Using where; Using index |
|  3 | DEPENDENT UNION    | t_a   | NULL       | const  | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | Using index              |
+----+--------------------+-------+------------+--------+---------------+---------+---------+-------+------+----------+--------------------------+
3 rows in set, 1 warning (0.08 sec)

Nach dem Login kopieren

UNION-ERGEBNIS: Ergebnisse von UNION

mysql> explain select num from t_a where id = 3 union select num from t_a where id =4;
+----+--------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
| id | select_type  | table      | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra           |
+----+--------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
|  1 | PRIMARY      | t_a        | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL            |
|  2 | UNION        | t_a        | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL            |
| NULL | UNION RESULT | <union1,2> | NULL       | ALL   | NULL          | NULL    | NULL    | NULL  | NULL |     NULL | Using temporary |
+----+--------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+-----------------+
3 rows in set, 1 warning (0.03 sec)

Nach dem Login kopieren

UNTERABFRAGE: Erste Auswahl in der Unterabfrage

mysql> explain select * from t_a where num >(select num from t_a where id = 3);
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra                    |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
|  1 | PRIMARY     | t_a   | NULL       | range | num_key       | num_key | 5       | NULL  |    6 |   100.00 | Using where; Using index |
|  2 | SUBQUERY    | t_a   | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL                     |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
2 rows in set, 1 warning (0.03 sec)

Nach dem Login kopieren

ABHÄNGIGE UNTERABFRAGE: Die erste Auswahl in der Unterabfrage, hängt von der äußeren Abfrage ab

mysql> explain select * from t_a where num in(select num from t_a where id = 3 union select num from t_a where id =4);
+----+--------------------+------------+------------+-------+-----------------+---------+---------+-------+------+----------+--------------------------+
| id | select_type        | table      | partitions | type  | possible_keys   | key     | key_len | ref   | rows | filtered | Extra                    |
+----+--------------------+------------+------------+-------+-----------------+---------+---------+-------+------+----------+--------------------------+
|  1 | PRIMARY            | t_a        | NULL       | index | NULL            | num_key | 5       | NULL  |    9 |   100.00 | Using where; Using index |
|  2 | DEPENDENT SUBQUERY | t_a        | NULL       | const | PRIMARY,num_key | PRIMARY | 8       | const |    1 |   100.00 | NULL                     |
|  3 | DEPENDENT UNION    | t_a        | NULL       | const | PRIMARY,num_key | PRIMARY | 8       | const |    1 |   100.00 | NULL                     |
| NULL | UNION RESULT       | <union2,3> | NULL       | ALL   | NULL            | NULL    | NULL    | NULL  | NULL |     NULL | Using temporary          |
+----+--------------------+------------+------------+-------+-----------------+---------+---------+-------+------+----------+--------------------------+
4 rows in set, 1 warning (0.12 sec)

Nach dem Login kopieren

DERIVED: abgeleitete Tabelle (temporäre Tabelle, die in der Unterabfrage generiert wird)

mysql> explain select a.id from (select id from t_a where id >8 union all select id from t_a where id =5) a;
+----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
| id | select_type | table      | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra                    |
+----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
|  1 | PRIMARY     | <derived2> | NULL       | ALL   | NULL          | NULL    | NULL    | NULL  |    3 |   100.00 | NULL                     |
|  2 | DERIVED     | t_a        | NULL       | range | PRIMARY       | PRIMARY | 8       | NULL  |    1 |   100.00 | Using where; Using index |
|  3 | UNION       | t_a        | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | Using index              |
+----+-------------+------------+------------+-------+---------------+---------+---------+-------+------+----------+--------------------------+
3 rows in set, 1 warning (0.12 sec)

Nach dem Login kopieren

2.3-Tabelle

Zeigt, auf welche Tabelle sich die Daten in dieser Zeile beziehen , manchmal ist es der tatsächliche Tabellenname, manchmal können es die folgenden Ergebnisse sein

: bezieht sich auf die ID als Die Vereinigung von M- und N-Zeilenergebnissen
: Diese Zeile bezieht sich auf das abgeleitete Tabellenergebnis der Zeile mit dem ID-Wert n. Eine abgeleitete Tabelle kann beispielsweise aus einer Unterabfrage in einer from-Klausel stammen.
: Diese Zeile bezieht sich auf das Ergebnis der materialisierten Unterabfrage der Zeile mit dem ID-Wert n.

2.4 Partitionen

Die Partition, zu der der abgefragte Datensatz gehört. Bei nicht partitionierten Tabellen ist dieser Wert NULL.

2.5 Typ

Welche Kategorie wird für die Verbindung verwendet und ob ein Index verwendet wird? Häufig verwendete Typen sind: System, Const, eq_ref, Ref, Range, Index, ALL (von links nach richtig, die Leistung wird schlechter), siehe EXPLAIN-Join-Typen für Details Suche abgeschlossen

System: Diese Tabelle (kann auch die abgefragte temporäre Tabelle sein) hat nur eine Datenzeile (= Systemtabelle). Es handelt sich um einen Sonderfall von const

const : Die Tabelle hat höchstens eine passende Zeile, die zu Beginn der Abfrage gelesen wird. Da es nur eine Zeile gibt, können die Spaltenwerte in dieser Zeile vom Rest des Optimierers als Konstanten behandelt werden. const-Tabellen sind schnell, weil sie nur einmal gelesen werden! const wird für alle Teile der Abfrage verwendet, wenn die Bedingung ein PRIMARY KEY- oder UNIQUE-Index ist, und mit einem konstanten Wert verglichen.

In der folgenden Abfrage kann tbl_name für const-Tabellen verwendet werden:

SELECT * from tbl_name WHERE primary_key=1；
SELECT * from tbl_name WHERE primary_key_part1=1和 primary_key_part2=2；

--例子
mysql> explain select * from t_a where id =1;
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref   | rows | filtered | Extra |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
|  1 | SIMPLE      | t_a   | NULL       | const | PRIMARY       | PRIMARY | 8       | const |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+-------+---------------+---------+---------+-------+------+----------+-------+
1 row in set, 1 warning (0.07 sec)

Nach dem Login kopieren

eq_ref: Lesen Sie für jede Zeilenkombination in den vorherigen Tabellen eine Zeile aus dieser Tabelle. Neben system und const ist dies der beste Verbindungstyp. Es wird verwendet, wenn der Join alle Teile des Index verwendet und der Index ein Primärschlüssel oder ein eindeutiger Nicht-Null-Index ist. eq_ref kann für indizierte Spalten verwendet werden, die mit dem =-Operator verglichen werden. Der Vergleichswert kann eine Konstante oder ein Ausdruck sein, der eine Spalte aus einer Tabelle verwendet, die vor dieser Tabelle gelesen wurde. Im folgenden Beispiel kann MySQL einen eq_ref-Join verwenden, um ref_tables zu verarbeiten:

SELECT * FROM ref_table,other_table
  WHERE ref_table.key_column=other_table.column;

SELECT * FROM ref_table,other_table
  WHERE ref_table.key_column_part1=other_table.column
  AND ref_table.key_column_part2=1;

--例子（t_b为t_a的复制表，表结构相同）
mysql> explain select * from t_a,t_b where t_a.code=t_b.code;
+----+-------------+-------+------------+--------+---------------+---------+---------+---------------+------+----------+-------+
| id | select_type | table | partitions | type   | possible_keys | key     | key_len | ref           | rows | filtered | Extra |
+----+-------------+-------+------------+--------+---------------+---------+---------+---------------+------+----------+-------+
|  1 | SIMPLE      | t_a   | NULL       | ALL    | uk_code       | NULL    | NULL    | NULL          |    9 |   100.00 | NULL  |
|  1 | SIMPLE      | t_b   | NULL       | eq_ref | uk_code       | uk_code | 4       | test.t_a.code |    1 |   100.00 | NULL  |
+----+-------------+-------+------------+--------+---------------+---------+---------+---------------+------+----------+-------+
2 rows in set, 1 warning (0.03 sec)

Nach dem Login kopieren

ref Für jede Kombination von Zeilen aus der vorherigen Tabelle werden alle Zeilen mit übereinstimmenden Indexwerten aus dieser Tabelle gelesen . Verwenden Sie ref, wenn der Join nur das Präfix ganz links des Schlüssels verwendet oder wenn der Schlüssel kein EINZIGARTIGER oder PRIMÄRSCHLÜSSEL ist (mit anderen Worten, wenn der Join nicht zu einer einzelnen Zeile basierend auf der Schlüsselabfrage führen kann). Dieser Join-Typ eignet sich gut, wenn Sie Schlüssel verwenden, die nur mit einer kleinen Anzahl von Zeilen übereinstimmen. ref kann für indizierte Spalten mit den Operatoren = oder <=> verwendet werden. Im folgenden Beispiel kann MySQL Ref-Joins verwenden, um ref_tables zu verarbeiten:

SELECT * FROM ref_table WHERE key_column=expr;

SELECT * FROM ref_table,other_table
  WHERE ref_table.key_column=other_table.column;

SELECT * FROM ref_table,other_table
  WHERE ref_table.key_column_part1=other_table.column
  AND ref_table.key_column_part2=1;

--例子（t_b为t_a的复制表，表结构相同）
mysql> explain select * from t_a,t_b where t_a.age=t_b.age;
+----+-------------+-------+------------+------+---------------+---------+---------+--------------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key     | key_len | ref          | rows | filtered | Extra       |
+----+-------------+-------+------------+------+---------------+---------+---------+--------------+------+----------+-------------+
|  1 | SIMPLE      | t_a   | NULL       | ALL  | age_key       | NULL    | NULL    | NULL         |    9 |   100.00 | Using where |
|  1 | SIMPLE      | t_b   | NULL       | ref  | age_key       | age_key | 5       | test.t_a.age |    1 |   100.00 | NULL        |
+----+-------------+-------+------------+------+---------------+---------+---------+--------------+------+----------+-------------+
2 rows in set, 1 warning (0.03 sec)

Nach dem Login kopieren

fulltext: Führen Sie den Join mit einem VOLLTEXT-Index durch.

ref_or_null: Dieser Join-Typ ähnelt ref, aber MySQL-Fähigkeit hinzugefügt, gezielt nach Zeilen zu suchen, die NULL-Werte enthalten. Dieser Join-Optimierungstyp wird häufig zum Lösen von Unterabfragen verwendet.

Im folgenden Beispiel kann MySQL ref_or_null-Joins verwenden, um ref_tables zu verarbeiten:

SELECT * FROM ref_table
  WHERE key_column=expr OR key_column IS NULL;

--例子
mysql> explain select * from t_a where t_a.age =3 or t_a.age is null;
+----+-------------+-------+------------+-------------+---------------+---------+---------+-------+------+----------+-----------------------+
| id | select_type | table | partitions | type        | possible_keys | key     | key_len | ref   | rows | filtered | Extra                 |
+----+-------------+-------+------------+-------------+---------------+---------+---------+-------+------+----------+-----------------------+
|  1 | SIMPLE      | t_a   | NULL       | ref_or_null | age_key       | age_key | 5       | const |    2 |   100.00 | Using index condition |
+----+-------------+-------+------------+-------------+---------------+---------+---------+-------+------+----------+-----------------------+
1 row in set, 1 warning (0.03 sec)

Nach dem Login kopieren

index_merge: Dieser Join-Typ gibt an, dass die Methode zur Optimierung der Indexzusammenführung verwendet wird. In diesem Fall enthält die Schlüsselspalte die Liste der verwendeten Indizes und key_len enthält das längste Schlüsselelement des verwendeten Index.

SELECT * FROM ref_table
  WHERE idx1=expr1 OR idx2 =expr2;

--例子
mysql> explain select * from t_a where t_a.code =3 or t_a.age = 3;
+----+-------------+-------+------------+-------------+-----------------+-----------------+---------+------+------+----------+-------------------------------------------+
| id | select_type | table | partitions | type        | possible_keys   | key             | key_len | ref  | rows | filtered | Extra                                     |
+----+-------------+-------+------------+-------------+-----------------+-----------------+---------+------+------+----------+-------------------------------------------+
|  1 | SIMPLE      | t_a   | NULL       | index_merge | uk_code,age_key | uk_code,age_key | 4,5     | NULL |    2 |   100.00 | Using union(uk_code,age_key); Using where |
+----+-------------+-------+------------+-------------+-----------------+-----------------+---------+------+------+----------+-------------------------------------------+
1 row in set, 1 warning (0.03 sec)

Nach dem Login kopieren

unique_subquery: Dieser Typ ersetzt die Referenz der IN-Unterabfrage in der folgenden Form:

unique_subquery ist eine Indexsuchfunktion, die die Unterabfrage vollständig ersetzen kann und mehr ist effizient. value IN (SELECT primary_key FROM single_table WHERE some_expr)index_subquery: Dieser Join-Typ ähnelt unique_subquery. Die IN-Unterabfrage kann ersetzt werden, jedoch nur für nicht eindeutige Indizes in Unterabfragen der folgenden Form:

Bereich: Rufen Sie nur Zeilen in einem bestimmten Bereich ab und verwenden Sie einen Index, um die Zeilen auszuwählen . In der Schlüsselspalte wird angezeigt, welcher Index verwendet wurde. key_len enthält das längste Schlüsselelement des verwendeten Index. Die Ref-Spalte ist bei diesem Typ NULL. Wenn Sie die Operatoren =, <>, >, >=, <, <=, IS NULL, <=>, BETWEEN oder IN verwenden, um Schlüsselspalten mit Konstanten zu vergleichen, können Sie range

mysql> explain select * from t_a where id > 8;
+----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
| id | select_type | table | partitions | type  | possible_keys | key     | key_len | ref  | rows | filtered | Extra       |
+----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
|  1 | SIMPLE      | t_a   | NULL       | range | PRIMARY       | PRIMARY | 8       | NULL |    1 |   100.00 | Using where |
+----+-------------+-------+------------+-------+---------------+---------+---------+------+------+----------+-------------+
1 row in set, 1 warning (0.03 sec)

Nach dem Login kopieren

value IN (SELECT key_column FROM single_table WHERE some_expr)Index: Dieser Join-Typ ist derselbe wie ALL, außer dass nur der Indexbaum gescannt wird. Dies ist normalerweise schneller als ALL, da Indexdateien normalerweise kleiner als Datendateien sind. MySQL kann diesen Join-Typ verwenden, wenn die Abfrage nur Spalten verwendet, die Teil eines einzelnen Index sind.

ALLE: Führen Sie einen vollständigen Tabellenscan für jede Zeilenkombination aus der vorherigen Tabelle durch. Dies ist normalerweise nicht gut, wenn die Tabelle die erste ist, die nicht mit const markiert ist, und ist in diesem Fall normalerweise schlecht. Normalerweise ist es möglich, weitere Indizes hinzuzufügen, ohne ALL zu verwenden, sodass Zeilen basierend auf konstanten Werten oder Spaltenwerten in der vorherigen Tabelle abgerufen werden können.

2.6 mögliche_Schlüssel

Die Spalte „mögliche_Schlüssel“ gibt an, welchen Index MySQL verwenden kann, um Zeilen in dieser Tabelle zu finden. Beachten Sie, dass diese Spalte völlig unabhängig von der Reihenfolge der in der EXPLAIN-Ausgabe angezeigten Tabellen ist. Dies bedeutet, dass einige Schlüssel in „posable_keys“ tatsächlich nicht in der generierten Tabellenreihenfolge verwendet werden können.

Wenn die Spalte NULL ist, gibt es keinen zugehörigen Index. In diesem Fall können Sie die Leistung Ihrer Abfrage verbessern, indem Sie die WHERE-Klausel daraufhin überprüfen, ob sie sich auf bestimmte Spalten oder Spalten bezieht, die für die Indizierung geeignet sind. Wenn ja, erstellen Sie einen entsprechenden Index und überprüfen Sie die Abfrage erneut mit EXPLAIN

2.7 Schlüssel

Die Schlüsselspalte zeigt den Schlüssel (Index), den MySQL tatsächlich verwendet hat. Wenn kein Index ausgewählt ist, ist der Schlüssel NULL. Um MySQL zu zwingen, den Index für die Spalte „possible_keys“ zu verwenden oder zu ignorieren, verwenden Sie FORCE INDEX, USE INDEX oder IGNORE INDEX in der Abfrage.

2.8 key_len

Die Spalte key_len zeigt die Schlüssellänge, die MySQL verwenden möchte. Wenn der Schlüssel NULL ist, ist die Länge NULL.
Die Länge des verwendeten Index. Je kürzer die Länge, desto besser, ohne an Genauigkeit zu verlieren

2,9 ref

Die Ref-Spalte zeigt, welche Spalte oder Konstante mit der Taste zum Auswählen von Zeilen aus der Tabelle verwendet wird.

2.10 Zeilen

Die Zeilenspalte zeigt die Anzahl der Zeilen an, die MySQL bei der Ausführung der Abfrage untersuchen muss.

2.11 Extra

Diese Spalte enthält die Details, wie MySQL die Abfrage gelöst hat, siehe unten.

Eindeutig: Sobald MYSQL eine Zeile findet, die mit der Zeilenvereinigung übereinstimmt , Keine Suche mehr
Nicht vorhanden: MYSQL optimiert LEFT JOIN Sobald es eine Zeile findet, die den LEFT JOIN-Kriterien entspricht, wird nicht mehr gesucht
Bereich für jeden überprüft: Kein idealer gefundener Index, also Für jede Kombination von Zeilen aus der vorherigen Tabelle prüft MYSQL, welcher Index verwendet wurde, und verwendet ihn, um die Zeilen aus der Tabelle zurückzugeben. Dies ist eine der langsamsten Verbindungen, die einen Index verwenden.
Verwendung von Dateisortierung: Wenn Sie dies sehen, muss die Abfrage optimiert werden. MYSQL erfordert einen zusätzlichen Schritt, um herauszufinden, wie die zurückgegebenen Zeilen sortiert werden. Es sortiert alle Zeilen basierend auf dem Verbindungstyp und den Zeilenzeigern aller Zeilen, die den Sortierschlüsselwert und die Übereinstimmungsbedingungen speichern.
Verwendung des Index: Spaltendaten werden allein durch die Verwendung der Informationen im Index ermittelt, ohne die tatsächlichen Informationen zu lesen Aktion Wird von der Tabelle zurückgegeben. Dies geschieht, wenn alle angeforderten Spalten der Tabelle Teil desselben Index sind.
Temporär verwenden: Wenn Sie dies sehen, muss die Abfrage optimiert werden. Hier muss MYSQL eine temporäre Tabelle erstellen, um die Ergebnisse zu speichern. Dies geschieht normalerweise, wenn ORDER BY für verschiedene Spaltensätze anstelle von GROUP BY ausgeführt wird mit der nächsten Tabelle verglichen werden. Eine Tabelle wird abgeglichen oder an den Benutzer zurückgegeben. Dies geschieht, wenn Sie nicht alle Zeilen in der Tabelle zurückgeben möchten und der Verbindungstyp ALL oder Index ist oder ein Problem mit der Abfrage vorliegt
[Verwandte Empfehlungen:

MySQL-Video Tutorial

]

Das obige ist der detaillierte Inhalt vonEinführung in den EXPLAIN-Interpretationsbefehl in MySQL (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!