Mysql EXPLAIN列的解释

合集下载

MySQL EXPLAIN 命令详解学习

MySQL EXPLAIN 命令详解学习
key: NULL
key_len: NULL
ref: NULL
rows: 787338
Extra: Using where
123456789101112
mysql> EXPLAIN SELECT * FROM inventory WHERE item_id = 16102176\G; ********************* 1. row *********************** id: 1 select_type: SIMPLE table: inventory type: ALL possible_keys: NULL key: NULL key_len: NULL ref: NULL rows: 787338 Extra: Using where
1234567891011
********************* 1. row *********************** id: 1 select_type: SIMPLE table: inventory type: ref possible_keys: item_id key: item_id key_len: 4 ref: const rows: 1 Extra:
这个QEP 显示没有使用任何索引(也就是全表扫描)并且处理了大量的行来满足查询。对同样一条SELECT 语句,一个优化过的QEP 如下所示:
********************* 1. row ***********************
和DELETE 命令也需要进行性能改进,当这些命令不是直接在表的主码上运行时,为了确保最优化的索引使用率,需要把它们改
写成SELECT 语句(以便对它们执行EXPLAIN 命令)。请看下面的示例:

详解 mysql 中 explain 用法

详解 mysql 中 explain 用法

EXPLAIN是MySQL 中的一个重要命令,它用于查看查询语句的执行计划。

当你对SQL 查询的性能有疑问时,可以使用EXPLAIN来分析查询的执行方式,从而找出可能的性能瓶颈并进行优化。

下面是EXPLAIN的基本用法和解释:1. 基本语法sql复制代码EXPLAIN SELECT ... FROM ... WHERE ...将你的查询语句前加上EXPLAIN关键字,然后执行该查询,MySQL 将返回查询的执行计划,而不是查询结果。

2. 返回结果EXPLAIN的返回结果包含多个列,这些列提供了关于查询执行计划的详细信息。

以下是一些常见的列:•id: 查询标识符。

•select_type: 查询的类型(例如SIMPLE, SUBQUERY, DERIVED 等)。

•table: 输出结果集的表。

•partitions: 匹配的分区。

•type: 访问类型(例如ALL, index, range, ref, eq_ref, const, system, NULL)。

•possible_keys: 可能使用的索引。

•key: 实际使用的索引。

•key_len: 使用的索引的长度。

•ref: 哪些列或常量被用作索引查找的参考。

•rows: 估计要检查的行数。

•filtered: 返回结果的百分比。

•Extra: 额外的信息。

3. 使用EXPLAIN进行性能优化•查看索引使用:通过possible_keys和key列,你可以看到查询是否使用了索引,以及使用了哪些索引。

如果key列是NULL,那么可能需要进行索引优化。

•分析访问类型:type列显示了查询的访问类型。

理想情况下,你希望看到ref、eq_ref、const或system。

如果看到ALL,表示全表扫描,可能需要优化。

•查看行数估计:rows列显示了MySQL 估计需要检查的行数。

这个数字越大,通常表示查询越慢。

•注意额外信息:Extra列可能包含一些有用的信息,例如"Using where" 表示MySQL 需要使用WHERE 子句来过滤结果,"Using filesort" 表示MySQL 需要进行额外的排序步骤,这可能会很慢。

mysql中explain用法详解

mysql中explain用法详解

mysql中explain⽤法详解如果在select语句前放上关键词explain,mysql将解释它如何处理select,提供有关表如何联接和联接的次序。

explain的每个输出⾏提供⼀个表的相关信息,并且每个⾏包括下⾯的列:1,id select识别符。

这是select的查询序列号。

2,select_type 可以为⼀下任何⼀种类型simple 简单select(不使⽤union或⼦查询)primary 最外⾯的selectunion union中的第⼆个或后⾯的select语句dependent union union中的第⼆个或后⾯的select语句,取决于外⾯的查询union result union的结果。

subquery ⼦查询中的第⼀个selectdependent subquery ⼦查询中的第⼀个select,取决于外⾯的查询derived 导出表的select(from⼦句的⼦查询)3,table 输出的⾏所引⽤的表。

4,type 联接类型。

下⾯给出各种联接类型,按照从最佳类型到最坏类型进⾏排序:system 表仅有⼀⾏(=系统表)。

这是const联接类型的⼀个特例。

const 表最多有⼀个匹配⾏,它将在查询开始时被读取。

因为仅有⼀⾏,在这⾏的列值可被优化器剩余部分认为是常数。

const表很快,因为它们只读取⼀次!eq_ref 对于每个来⾃于前⾯的表的⾏组合,从该表中读取⼀⾏。

这可能是最好的联接类型,除了const类型。

它⽤在⼀个索引的所有部分被联接使⽤并且索引是unique或primary keyref 对于每个来⾃于前⾯的表的⾏组合,所有有匹配索引值的⾏将从这张表中读取。

如果联接只使⽤键的最左边的前缀,或如果键不是unique或primary key(换句话说,如果联接不能基于关键字选择单个⾏的话),则使⽤ref。

如果使⽤的键仅仅匹配少量⾏,该联接类型是不错的。

ref可以⽤于使⽤=或<=>操作符的带索引的列。

mysql explain执行计划每列的简单解释

mysql explain执行计划每列的简单解释

使用explain查询执行计划时,每个列的简单解释如下:
∙select_type:表示SELECT 的类型,常见的取值有SIMPLE(简单表,即不使用表连接
或者子查询)、PRIMARY(主查询,即外层的查询)、UNION(UNION 中的第二个或
者后面的查询语句)、SUBQUERY(子查询中的第一个SELECT)等。

∙table:输出结果集的表。

∙type:表示表的连接类型,性能由好到差的连接类型为system(表中仅有一行,即常量表)、const(单表中最多有一个匹配行,例如primary key 或者unique index)、eq_ref(对于前面的每一行,在此表中只查询一条记录,简单来说,就是多表连接中使用primary key或者unique index)、ref (与eq_ref 类似,区别在于不是使用primarykey 或者unique index,而是使用普通的索引)、ref_or_null(与ref 类似,区别在于条件中包含对NULL 的查询)、index_merge(索引合并优化)、unique_subquery(in的后面是一个查询主键字段的子查询)、index_subquery (与unique_subquery 类似,区别在于in 的后面是查询非唯一索引字段的子查询)、range(单表中的范围查询)、index (对于前面的每一行,都通过查询索引来得到数据)、all (对于前面的每一行,都通过全表扫描来得到数据)。

∙possible_keys:表示查询时,可能使用的索引。

∙key:表示实际使用的索引。

∙key_len:索引字段的长度。

∙rows:扫描行的数量。

∙Extra:执行情况的说明和描述。

mysql中explain用法

mysql中explain用法

mysql中explain用法在MySQL中,EXPLAIN是一个非常有用的关键字,它可以帮助你理解查询是如何执行的,从而优化查询性能。

当你使用EXPLAIN关键字来查看查询的执行计划时,MySQL会返回关于如何检索数据的信息,而不是实际检索到的数据。

以下是如何使用EXPLAIN的基本步骤:1.在查询前使用EXPLAIN:2.sql复制代码EXPLAIN SELECT * FROM your_table WHERE your_column = 'some_value';1.查看输出:EXPLAIN的输出会告诉你MySQL是如何执行查询的。

其中一些关键的列包括:复制代码* `id`: 查询的标识符。

* `select_type`: 查询的类型(例如:SIMPLE, PRIMARY, SUBQUERY, DERIVED等)。

* `table`: 显示正在访问的表的名称。

* `type`: 这是连接类型,它通常是最重要的列之一。

它的值从最好到最差可以是:system、const、eq_ref、ref、fulltext、ref_or_null、index_merge、unique_subquery、index_subquery、range、index和ALL。

* `possible_keys`: 显示可能用于此表的索引。

* `key`: 实际使用的索引。

* `key_len`: 使用的索引的长度。

这可以帮助你确定是否使用了整个索引或只是索引的一部分。

* `ref`: 显示哪些列或常量被用作索引查找的条件。

* `rows`: 估计要检查的行数。

* `Extra`: 提供关于MySQL如何解析查询的其他信息,如“Using filesort”或“Using temporary”。

3. 优化查询:使用EXPLAIN的输出,你可以识别出查询的性能瓶颈。

例如,如果type列显示为ALL,那么MySQL正在进行全表扫描,这通常是非常低效的。

mysql explain解读

mysql explain解读

EXPLAIN是MySQL提供的一种查询分析工具,用于查看SQL查询的执行计划和优化信息。

以下是对EXPLAIN结果各列的解读:1. id:这是查询中每个SELECT子句的序列号。

id值越大,执行顺序越晚。

2. select_type:SIMPLE:简单的SELECT语句,不包含子查询或UNION。

PRIMARY:外部查询,如果查询包含任何复杂的子部分,最外层的查询标记为PRIMARY。

SUBQUERY:在SELECT列表或WHERE条件中的子查询。

3. table:输出行所引用的表。

4. type:ALL:全表扫描。

index:只使用索引树进行扫描,没有访问到表的数据行。

range:索引范围扫描,通常出现在使用BETWEEN、>, <等操作符的查询中。

ref:使用非唯一索引或者唯一索引的部分前缀进行查找。

eq_ref:对于每个索引项,表中只有一行数据与之匹配。

常见于主键或唯一索引的等值查询。

const:当查询条件可以转化为常量时,如在WHERE子句中使用主键或唯一索引进行等值比较。

5. possible_keys:可能用到的索引。

6. key:实际使用的索引。

7. key_len:表示使用到的索引长度,可以通过这个值推算出具体使用了哪些列参与了索引。

8. ref:显示哪个字段或常量与key一起被使用。

9. rows:MySQL根据表统计信息和索引选用情况,估算要找到所需记录需要扫描的行数。

10. Extra:Using index:表示使用覆盖索引,即只需要从索引中就可以获取所有需要的数据,无需回表。

Using where:表示在检索过程中使用了WHERE过滤条件。

Using temporary:表示MySQL需要创建一个临时表来存储查询结果。

Using filesort:表示MySQL无法利用索引进行排序,需要进行额外的文件排序操作。

Using join buffer:表示在连接操作中使用了连接缓冲区。

MySQL中EXPLAIN结果的参数详解

MySQL中EXPLAIN结果的参数详解

MySQL中EXPLAIN结果的参数详解explain显⽰了mysql如何使⽤索引来处理select语句以及连接表。

可以帮助选择更好的索引和写出更优化的查询语句。

使⽤⽅法,在select语句前加上explain就可以了。

如:mysql> explain select word from words order by rand() limit 3;+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+| 1 | SIMPLE | words | NULL | ALL | NULL | NULL | NULL | NULL | 9980 | 100.00 | Using temporary; Using filesort |+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+---------------------------------+EXPLAIN列的解释:select_type1) SIMPLE:简单的SELECT,不是⽤UNION或者⼦查询。

mysql 的explain的用法

mysql 的explain的用法

mysql 的explain的用法MySQL的Explain是一种非常有用的工具,用于分析和优化数据库查询性能。

通过Explain,您能够了解MySQL服务器如何处理查询语句,并找出可能的性能瓶颈。

本文将详细介绍Explain的用法,包括其重要性、使用时机、输出结果解释以及优化建议。

一、Explain的重要性Explain报告提供了有关MySQL服务器如何处理查询语句的详细信息,这有助于开发人员、DBA(数据库管理员)和业务分析师理解查询的性能问题,从而进行针对性的优化。

二、何时使用Explain通常,在以下情况下,您可能需要使用Explain:1. 查询性能下降:当您发现数据库查询性能下降时,可以使用Explain来分析查询语句的性能。

2. 优化查询语句:通过Explain报告,您可以了解查询语句的执行计划,从而优化查询语句以提高性能。

3. 调整索引策略:当您不确定某个表的索引是否对查询性能产生影响时,可以使用Explain来进行分析。

三、Explain的输出结果解释Explain报告以表格形式呈现,包括以下列:1. id:查询的唯一标识符。

2. select_type:查询的类型,如SIMPLE、SUBQUERY、JOIN等。

3. table:涉及的表名及其类型(如系统表、临时表)。

4. partitions:涉及的分区信息。

5. type:MySQL服务器如何处理表(如全表扫描、索引扫描等)。

6. possible_keys:可能用于优化的索引。

7. key:实际使用的索引。

8. key_len:使用的索引的长度。

9. ref:哪些字段被用作索引引用。

10. rows:MySQL预计需要扫描的行数。

11. filtered:表示估计返回的行数在结果中的百分比。

12. Extra:表示MySQL在处理查询时使用的额外选项。

通过分析这些信息,您可以了解MySQL服务器如何处理查询语句,并确定是否存在性能瓶颈。

Mysql Explain 语法详细解析

Mysql Explain 语法详细解析

EXPLAIN 的每个输出行提供一个表的相关信息,并且每个行包括下面的列:

说明
id
MySQL Query Optimizer 选定的执行计划中查
询的序列号。表示查询中执行 select 子句或
操作表的顺序,id 值越大优先级越高,越先
被执行。id 相同,执行顺序由上至下。
select_type 查询类型 SIMPLE PRIMARY UNION
1
SIMPLE
book ref
y
ref
rows
NULL
1741
class.card 18
Extra Using index
可以看到第二行的 type 变为了 ref,rows 也变成了 1741*18,优化比较明显。这是由左连 接特性决定的。
LEFT JOIN 条件用于确定如何从右表搜索行,左边一定都有,所以右边是我们的关键点,一 定需要建立索引。 删除旧索引
需求: 查询 category_id 为 1 且 comments 大于 1 的情况下,views 最多的 article_id。
先查查试试看: EXPLAIN SELECT author_id FROM `article` WHERE category_id = 1 AND comments > 1 ORDER BY views DESC LIMIT 1;
value IN (SELECT key_column FROM
single_table WHERE some_expr)
range
只检索给定范围的行,使用一个索引来选择 行。key 列显示使用了哪个索引。当使用=、 <>、>、>=、<、<=、IS NULL、<=>、BETWEEN 或者 IN 操作符,用常量比较关键字列时,可 以使用 range。

MySQL中EXPLAIN命令详细解析

MySQL中EXPLAIN命令详细解析

MySQL中EXPLAIN命令详细解析很多情况下我们需要知道某条SQL语句的性能,都会通过EXPLAIN命令来查看查询优化器是如何执行的。

如何使用使用EXPLAIN很简单,只需要在执行的SQL前面加上EXPLAIN 即可explain select s.sid sid, studentName, s.age age, className from student_class sc, student s, class c;执行结果如下:EXPLAIN中的列EXPLAIN命令中经常使用到的列有id、idid是一个编号,标识SELECT所属的行。

如果在语句当中没有子查询或联合查询,那么之后有唯一的SELECT,于是每一行在这个列中都显示1。

否则,内层的SELECT语句一般会顺序编号,对应于其在语句中的位置。

•SELECT列中子查询••FROM子句中的子查询•• UNION 查询•注意UNION 结果总是放在一个匿名临时表中,之后MySQL 将结果读取到临时表外。

临时表不在原SQL 中出现,因此它的id 列是NULLselect_typeselect_type 列显示了对应行是简单还是复杂SELECT ,具体如下: select_type描述 SIMPLE简单查询,不包含任何复杂的子查询(FROM 子句中的子查询除外) PRIMARY复杂查询 SUBQUERY复杂查询,包含在SELECT 列表中的SELECT 标记为SUBQUERY DERIVED复杂查询,包含在FROM 子句中的查询 UNION 复杂查询,在UNION 查询中的第二个和随后的SELECT 被标记为UNION UNION RESULT 复杂查询,用来从UNION 的匿名临时表检索结果的SELECT 被标记为UNION RESULTtabletable 列显示了对应行在访问哪个表。

在通常情况下,它相当明了:它就是那个表,或是该表的别名。

mysql explain注解

mysql explain注解

MySQL的EXPLAIN命令用于获取SQL查询的执行计划,它帮助开发者和DBA 理解MySQL服务器如何处理SQL语句,包括如何访问表、连接顺序、索引使用情况等关键信息,从而能够识别并优化低效查询。

下面是对EXPLAIN输出各项的详细注解:EXPLAIN输出列的解释:•id: 查询中执行的顺序号,每个id值代表一条SQL执行的一个阶段,相同id值表示该步骤可以并行执行,id值越大优先级越高,越先执行。

•select_type:o SIMPLE: 简单的SELECT查询,无子查询或UNION操作。

o PRIMARY: 最外部的查询(主查询)。

o SUBQUERY: 子查询,在SELECT列表或WHERE子句中出现的子查询。

o DERIVED: 衍生表,由FROM子句中的子查询产生,也称为临时表。

o其他如UNION、UNION RESULT等与UNION操作相关的类型。

•table: 当前正在访问哪个表(或临时表)。

•type:o ALL: 全表扫描。

o index: 索引全扫描,不读取实际的数据行,只读取索引树。

o range: 索引范围扫描,使用索引检索一部分行。

o ref: 使用非唯一索引或唯一索引的部分键进行查找。

o eq_ref: 类似ref,但使用的是唯一索引,并且对于每一行都有一个匹配的行。

o const, system: 单一行常量引用,通常出现在主键或唯一索引可以直接定位到一行的情况。

•possible_keys: 可能使用的索引。

•key: 实际上选择使用的索引。

•key_len: 用于索引的字节数,可以帮助判断索引是否完全使用。

•ref: 显示哪些列或常量被用于查找索引项。

•rows: MySQL估算的需要读取并检查的行数。

•filtered: MySQL根据统计信息估算的存储引擎返回的数据行中满足条件的比例。

•Extra:o包含很多额外的信息,比如Using index表示覆盖索引,Using temporary表示需要创建临时表,Using filesort表示需要外部排序,Using join buffer表明使用了连接缓存等。

mysql explain 字段说明

mysql explain 字段说明

mysql explain 字段说明当我们需要优化MySQL查询语句的性能时,一个非常重要的工具就是Explain。

Explain可以展示查询计划,帮助我们分析查询语句的执行情况和性能瓶颈所在。

Explain的执行结果中包含了很多字段,下面我们对这些字段进行详细的解析。

1. id查询的标识符,每个查询都有一个唯一的标识符,可以用来区分不同的查询。

2. select_type查询类型,表示查询的种类或者说操作类型,常见的查询类型包括:- SIMPLE:简单的SELECT查询,不包含子查询或者UNION操作。

- PRIMARY:外层的SELECT查询,包含子查询或者UNION操作。

- SUBQUERY:子查询中的第一个查询,该查询会在外层查询执行之前被执行。

- DERIVED:派生表查询,该查询是从FROM子句中的子查询中获取数据的查询。

- UNION:UNION操作的第二个及以上的查询。

- UNION RESULT:UNION操作的结果集,也就是最终的查询结果。

3. table查询涉及的表,如果是子查询,则会显示一个虚拟的表名。

4. partitions查询涉及的分区,如果表没有分区,则该字段为空。

5. type访问类型,表示MySQL在执行查询时所采用的访问方式,常见的访问类型包括:- ALL:全表扫描,MySQL需要扫描整个表以找到匹配的行。

- index:使用索引扫描,MySQL会扫描索引树来找到匹配的行。

- range:范围扫描,MySQL会在索引树中查找一个范围来匹配查询条件。

- ref:使用非唯一索引或者唯一索引的前缀来匹配查询条件。

- eq_ref:使用唯一索引来匹配查询条件。

- const/system:使用常量或者系统表来匹配查询条件,是最快的一种查询方式。

6. possible_keys表示MySQL可以使用哪些索引来执行查询,如果该字段为NULL,则表示没有可用的索引。

mysql explain 级别

mysql explain 级别

mysql explain 级别MySQL是目前最为广泛使用的开源关系型数据库,而"EXPLAIN"是MySQL中最为基础的一个命令。

它提供了数据库询问优化器的执行过程,并返回一行合集。

目的是为了帮助用户了解SQL查询的执行过程和效率,以便对SQL查询进行分析与优化。

而EXPLAIN在MySQL中有多种级别,本文就将详细讲述MySQL中各个级别的作用及使用方法。

一、EXPLAIN命令EXPLAIN命令是MySQL数据库中优化语句的最基本体现。

该命令可以用于输出优化器对查询的执行计划。

查询执行计划是一个关于查询执行的结果集合的重要信息。

当一个查询存在性能问题时,使用EXPLAIN排查问题会非常方便。

使用方法非常简单。

只需要在要优化的SQL语句前添加一个“EXPLAIN”关键字,数据库引擎将会输出查询的执行计划。

例如,我们要优化一条查询语句:SELECT * FROM `user` WHERE `username` = 'xxxx';只需要在前面加上EXPLAIN命令即可:EXPLAIN SELECT * FROM `user` WHERE `username` = 'xxxx';系统会输出以下信息:id select_type table type possible_keys keykey_len ref rows Extra1 SIMPLE user ref idx_username idx_username 103 const 1 Using index二、EXPLAIN语句解释在输出的查询执行计划中,文件头中的每个字段的意义如下:特别是其中的type字段,用来表示优化器选取了哪种访问方式来访问表。

各种访问方式的效率从差到好为:system > const > eq_ref > ref > range > index > all三、EXPLAIN级别MySQL中有多种EXPLAIN级别可供选择,分别适用于不同的场景。

mysqlexplain中的type列含义和extra列的含义

mysqlexplain中的type列含义和extra列的含义

mysqlexplain中的type列含义和extra列的含义很多朋友在⽤mysql进⾏调优的时候都肯定会⽤到explain来看select语句的执⾏情况,这⾥简单介绍结果中两个列的含义。

1 type列官⽅的说法,说这列表⽰的是“访问类型”,更通俗⼀点就是:mysql找到需要的数据⾏的⽅式。

⼀下就是从效率最差到最好顺序分别介绍下:All 这个就是所谓的全表扫描,没有⽤到任何的index,mysql就是从头到尾把整个表遍历⼀边,找到所需要的数据⾏。

效率是最差的。

如下图,这个表中的usertype不是索引,这个查询中没有⽤到任何索引,所以就出现了全表扫描的结果。

index type列中出现了index,含义仅仅是局限在扫描全表的顺序是按照索引顺序扫描的,仅仅是按索引顺序去扫描的。

它的有点是避免了排序,因为索引就是已经排序好的,缺点就是要承担按照索引次序读取整张表的开销。

如下,这个查询中order by id,id是这个表的索引,但是因为没有在where中出现任何的索引列,所以它也只是索引顺去扫描了全表。

(这⾥强调⼀下,你的查询语句中where条件中没有索引,只是order by 的时候⽤了index,⽽且没有⽤limit限制,type这⾥显⽰的是all,也就是这种情况下没有limit,还是扫⾯全表的)range 这个⼀般就是在你的where语句中出现了between或者“>”这种符号的时候会出现这个。

这种范围扫描索引扫描⽐全表扫描要好,因为它只需要开始于索引的某⼀点,⽽结束语另⼀点,不⽤扫描全部索引。

ref 这也是⼀种索引访问,它返回所有匹配某个单独值的⾏,然⽽,它可能会找到多个符合条件的⾏,所以他应该属于查找和扫描的混合体。

const,system 当mysql能对查询的部分就⾏优化,并且转换成⼀个常量的时候,它就会使⽤这种访问类型了。

⽐如你把⼀⾏的主键当做where条件放进去,那mysql就可以把它转换成⼀个常量,然后查询。

MySQL查询执行计划详解——EXPLAIN

MySQL查询执行计划详解——EXPLAIN

MySQL查询执⾏计划详解——EXPLAINMySQL查询执⾏计划详解——explain⼀、前⾔本⽂来⾃explain⽤于解释优化器在执⾏select、update、delete、insert、replace语句时的执⾏计划,即它解释了MySQL如何处理SQL语句,包括表如何连接、表的连接顺序、⽤了哪些索引等。

(replace是MySQL对于标准SQL语句的扩展,其他数据库可能没有,replace的使⽤见)本⽂使⽤的表结构和数据如下:CREATE DATABASE test;CREATE TABLE trb1 (id int auto_increment primary key,name varchar(50),purchased date)PARTITION BY RANGE (ID) (PARTITION p0 VALUES LESS THAN (3),PARTITION P1 VALUES LESS THAN (7),PARTITION P2 VALUES LESS THAN (9),PARTITION P3 VALUES LESS THAN (11));INSERT INTO trb1 VALUES(1, 'desk organiser', '2003-10-15'),(2, 'CD player', '1993-11-05'),(3, 'TV set', '1996-03-10'),(4, 'bookcase', '1982-01-10'),(5, 'exercise bike', '2004-05-09'),(6, 'sofa', '1987-06-05'),(7, 'popcorn maker', '2001-11-22'),(8, 'aquarium', '1992-08-04'),(9, 'study desk', '1984-09-16'),(10, 'lava lamp', '1998-12-25');create table trb2(id2 int auto_increment primary key,id int);insert into trb2(id) values(3), (3), (4);create table trb3(id3 int,name varchar(50),purchased date,primary key(id3, name),index trb3_index1(name, purchased));insert into trb3 values(1, 'desk organiser', '2003-10-15'),(2, 'CD player', '1993-11-05'),(3, 'TV set', '1996-03-10'),(4, 'bookcase', '1982-01-10'),(5, 'exercise bike', '2004-05-09'),(6, 'sofa', '1987-06-05'),(7, 'popcorn maker', '2001-11-22'),(8, 'aquarium', '1992-08-04'),(9, 'study desk', '1984-09-16'),(10, 'lava lamp', '1998-12-25');⽂章⽬录:⽬录⼆、explain输出格式解释EXPLAIN为SELECT语句中使⽤的每个表返回⼀⾏信息,按照MySQL在处理语句时读取它们的顺序列⽰。

mysqlexplain用法和结果的含义

mysqlexplain用法和结果的含义

mysqlexplain⽤法和结果的含义(转载只是为了以后更⽅便的查看)explain显⽰了mysql如何使⽤索引来处理select语句以及连接表。

可以帮助选择更好的索引和写出更优化的查询语句。

使⽤⽅法,在select语句前加上explain就可以了:如:1. explain select surname,first_name form a,b where a.id=b.idEXPLAIN列的解释:table:显⽰这⼀⾏的数据是关于哪张表的type:这是重要的列,显⽰连接使⽤了何种类型。

从最好到最差的连接类型为const、eq_reg、ref、range、index和ALLtype显⽰的是访问类型,是较为重要的⼀个指标,结果值从好到坏依次是:system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL⼀般来说,得保证查询⾄少达到range级别,最好能达到ref。

possible_keys:显⽰可能应⽤在这张表中的索引。

如果为空,没有可能的索引。

可以为相关的域从WHERE语句中选择⼀个合适的语句key:实际使⽤的索引。

如果为NULL,则没有使⽤索引。

很少的情况下,MYSQL会选择优化不⾜的索引。

这种情况下,可以在SELECT语句中使⽤USEINDEX(indexname)来强制使⽤⼀个索引或者⽤IGNORE INDEX(indexname)来强制MYSQL忽略索引key_len:使⽤的索引的长度。

在不损失精确性的情况下,长度越短越好ref:显⽰索引的哪⼀列被使⽤了,如果可能的话,是⼀个常数rows:MYSQL认为必须检查的⽤来返回请求数据的⾏数Extra:关于MYSQL如何解析查询的额外信息。

Mysql Explain 详解

Mysql Explain 详解

Mysql Explain 详解写在前面:1.explain 是用于查看SQL执行计划的命令,注意这个命令只能搭配select类型语句使用,如果你想查看update,delete类型语句中的索引效果,也不是太难的事情,只要保持条件不变,把类型转换成select就行了。

2.EXPLAIN [EXTENDED] SELECT select_options如果使用了extended,那么在执行完explain语句后,可以使用show warnings语句查询相应的优化信息。

3.使用explain,要保证数据库的数据量有足够大,否则会影响优化器的执行策略4.如果索引出现问题,应运行ANALYZE TABLE更新表的统计(例如关键字集的势),这样会影响优化器进行的选择。

对于MyISAM和BDB表,运行ANALYZE TABLE可以帮助优化器选择更好的索引。

对于MyISAM表,可以使用myisamchk --analyze。

参见13.5.2.1节,“5.部分信息参考/viewthread.php?tid=1034410&extra=&page=1/huliang82/archive/2009/02/27/3943950.aspx感谢原作者的分享一.语法explain < table_name >例如: explain select * from t3 where id=3952602;二.explain输出解释+----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |+----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+1.id我的理解是SQL执行的顺利的标识,SQL从大到小的执行.例如:mysql> explain select * from (select * from ( select * from t3 where id=3952602) a) b;+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra || 1 | PRIMARY | <derived2> | system | NULL | NULL | NULL | NULL | 1 | || 2 | DERIVED | <derived3> | system | NULL | NULL | NULL | NULL | 1 | || 3 | DERIVED | t3 | const | PRIMARY,idx_t3_id | PRIMARY | 4 | | 1 | |+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+很显然这条SQL是从里向外的执行,就是从id=3 向上执行.2. select_type就是select类型,可以有以下几种(1) SIMPLE简单SELECT(不使用UNION或子查询等) 例如:mysql> explain select * from t3 where id=3952602;+----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |+----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+| 1 | SIMPLE | t3 | const | PRIMARY,idx_t3_id | PRIMARY | 4 | const | 1 | | +----+-------------+-------+-------+-------------------+---------+---------+-------+------+-------+(2). PRIMARY我的理解是最外层的select.例如:mysql> explain select * from (select * from t3 where id=3952602) a ;+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra | +----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+| 1 | PRIMARY | <derived2> | system | NULL | NULL | NULL | NULL | 1 | || 2 | DERIVED | t3 | const | PRIMARY,idx_t3_id | PRIMARY | 4 | | 1 | |+----+-------------+------------+--------+-------------------+---------+---------+------+------+-------+(3).UNIONUNION中的第二个或后面的SELECT语句.例如mysql> explain select * from t3 where id=3952602 union all select * from t3 ;+----+--------------+------------+-------+-------------------+---------+---------+-------+------+-------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra || 1 | PRIMARY | t3 | const | PRIMARY,idx_t3_id | PRIMARY | 4 | const | 1 | || 2 | UNION | t3 | ALL | NULL | NULL | NULL | NULL | 1000 | ||NULL | UNION RESULT | <union1,2> | ALL | NULL | NULL | NULL | NULL | NULL | |+----+--------------+------------+-------+-------------------+---------+---------+-------+------+-------+(4).DEPENDENT UNIONUNION中的第二个或后面的SELECT语句,取决于外面的查询mysql> explain select * from t3 where id in (select id from t3 where id=3952602 union all select id from t3) ;+----+--------------------+------------+--------+-------------------+---------+---------+-------+------+--------------------------+| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |+----+--------------------+------------+--------+-------------------+---------+---------+-------+------+--------------------------+| 1 | PRIMARY | t3 | ALL | NULL | NULL | NULL | NULL | 1000 | Using where || 2 | DEPENDENT SUBQUERY | t3 | const | PRIMARY,idx_t3_id | PRIMARY | 4 | const | 1 | Using index || 3 | DEPENDENT UNION | t3 | eq_ref | PRIMARY,idx_t3_id | PRIMARY | 4 | func | 1 | Using where; Using index ||NULL | UNION RESULT | <union2,3> | ALL | NULL | NULL | NULL | NULL | NULL | |+----+--------------------+------------+--------+-------------------+---------+---------+-------+------+--------------------------+(4).UNION RESULTUNION的结果。

MySQLexplain详解

MySQLexplain详解

MySQLexplain详解在⽇常⼯作中, 我们会记录⼀些执⾏时间⽐较久的SQL语句, 找出这些SQL语句并不意味着完事了, 我们常常⽤到explain这个命令来查看⼀个这些SQL语句的执⾏计划, 查看该SQL语句有没有使⽤上了索引, 有没有做全表扫描, 所以我们需要深⼊了解MySQL基于开销的优化器.explain select * from t_member where member_id = 1;在执⾏explain命令之后, 显⽰的信息⼀共有12列, 分别是:id: 选择标识符select_type: 查询类型table: 输出结果集的表partitions: 匹配的分区type: 表的连接类型possible_keys: 查询时可能使⽤的索引key: 实际使⽤的索引key_len: 索引字段的长度ref: 列与索引的⽐较rows: 扫描出的⾏数filtered: 按表条件过滤的⾏百分⽐extra: 执⾏情况描述和说明1. idselect标识符, 可以理解为SQL执⾏的顺序, 从⼤到⼩执⾏.id相同时执⾏顺序从上到下, 在所有组中, id值越⼤, 优先级越⾼, 越先执⾏2. select_type查询中每个select⼦句的类型.1. simple: 简单的select, 不适⽤union或⼦查询等. 例如: SELECT * from t_member where member_id = 1;2. primary: ⼦查询中最外层查询, 查询中若包含任何复杂的⼦部分, 最外层的select被标记为primary. 例如: SELECT member_id from t_memberwhere member_id = 3 UNION all SELECT member_id from t_member3. union: union中的第⼆个或后⾯的select语句. 例如: SELECT member_id from t_member where member_id = 3 UNION all SELECT member_id fromt_member4. dependent union: union中第⼆个或后⾯的select, 取决于外层的查询. 例如SELECT tm.* from t_member as tm where member_id in (SELECTmember_id from t_member where member_id = 3 UNION all SELECT member_id from t_member)5. union result: union的结果集6. subquery: ⼦查询中的第⼀个select. 例如: SELECT * from t_member where member_id = (SELECT member_id from t_member where member_id = 5)7. dependent subquery: ⼦查询中的第⼀个select, 取决于外⾯的select. 例如: SELECT tm.* from t_member as tm where member_id in (SELECTmember_id from t_member where member_id = 3 UNION all SELECT member_id from t_member)8. derived: 派⽣表的select(from⼦句的⼦查询). 例如: SELECT * from (SELECT * from t_member where member_id = 1) tbl3. table显⽰这⼀步所访问数据库中表名称. 有时候不是真实的表明, 可能是简称.4. partitions官⽅定义为The matching partitions(匹配的分区),该字段看table所在的分区, 值为NULL表⽰表未被分区.5. type对表访问⽅式, 表⽰MySQL在表中找到所需⾏的⽅式, ⼜称“访问类型”. 常⽤的类型有: all、index、range、 ref、eq_ref、const、system(从左到右, 性能从差到好), ⼀般来说, 需要保证查询⾄少达到range级别, 最好能达到ref级别.all: Full Table Scan, 全表扫描.index: Full Index Scan, 全索引扫描. index与all区别为index只遍历索引树, 通常⽐all快, 因为索引⽂件通常⽐数据⽂件⼩.range: 只检索给定范围的⾏, 使⽤⼀个索引来检索⾏, 可以在key列中查看使⽤的索引, ⼀般出现在where条件中, ⽐如使⽤between, <, >, in等查询. 这种索引的范围扫描⽐全表扫描要好, 因为索引的开始点和结束点都固定, 不⽤扫描全索引.ref: ⾮唯⼀性索引扫描, 返回匹配某个单独值的所有⾏. 本质上也是⼀种索引访问, 返回匹配某值(某条件)的多⾏数据, 属于查找和扫描的混合体.eq_ref: 类似ref, 区别在于使⽤的索引是唯⼀索引, 对于每个索引键值, 表中只有⼀条记录匹配, 常见于主键或唯⼀索引扫描.const、system: 表⽰通过⼀次索引就找到了结果, 常见于primary key或unique索引, 因为只匹配⼀⾏数据, 所以查询⾮常快. 如将主键置于where列表中, MySQL就能将该查询转换为⼀个常量. system是const类型的特例, 当查询的表只有⼀⾏的情况下, 使⽤system.6. possible_keys显⽰可能应⽤在表中的索引, 可能⼀个或多个. 查询涉及到的字段若存在索引, 则该索引将被列出, 但不⼀定被查询实际使⽤.7. key实际中使⽤的索引, 如为NULL, 则表⽰未使⽤索引. 要想强制MySQL使⽤或忽视possible_keys列中的索引, 在查询中使⽤FORCE INDEX、USE INDEX或者IGNORE INDEX.8. key_len表⽰索引中所使⽤的字节数, 可通过该列计算查询中使⽤的索引长度. 在不损失精确性的情况下, 长度越短越好. key_len显⽰的值为索引字段的最⼤可能长度, 并⾮实际使⽤长度, 即key_len是根据表定义计算⽽得, 并不是通过表内检索出的.9. ref显⽰关联的字段. 如果使⽤常数等值查询, 则显⽰const, 如果是连接查询, 则会显⽰关联的字段.10. rows根据表统计信息及索引选⽤情况⼤致估算出找到所需记录所要读取的⾏数. 当然该值越⼩越好.11. filtered百分⽐值, 表⽰存储引擎返回的数据经过滤后, 剩下多少满⾜查询条件记录数量的⽐例.12. extra显⽰⼗分重要的额外信息. 其取值有以下⼏个:using filesort: 表明mysql会对数据使⽤⼀个外部的索引排序, ⽽不是按照表内的索引顺序进⾏读取. 在mysql中, ⽆法利⽤索引完成的排序操作称为"⽂件排序". 当出现using filesort时就⾮常危险了, 在数据量⾮常⼤的时候⼏乎"九死⼀⽣". 出现using filesort尽快优化sql语句.using temporary: 使⽤了临时表保存中间结果, 常见于排序order by和分组查询group by. ⾮常危险, “⼗死⽆⽣”, 急需优化.using index: 表明相应的select操作中使⽤了覆盖索引, 避免访问表的额外数据⾏, 效率不错. 如果同时出现了using where, 表明索引被⽤来执⾏索引键值的查找. 如果没有同时出现using where, 表明索引⽤来读取数据⽽⾮执⾏查找动作.using where: 不⽤读取表中所有信息, 仅通过索引就可以获取所需数据, 这发⽣在对表的全部的请求列都是同⼀个索引的部分的时候, 表⽰mysql服务器将在存储引擎检索⾏后再进⾏过滤.总结explain包含的信息⼗分的丰富, 主要关注以下⼏个字段信息.1. id: select⼦句或表执⾏顺序, id相同, 从上到下执⾏, id不同, id值越⼤, 执⾏优先级越⾼.2. type: type主要取值及其表⽰sql的好坏程度(由好到差排序):system > const > eq_ref > ref > range > index > ALL. 保证range, 最好到ref.3. key: 实际被使⽤的索引列.4. ref: 关联的字段, 常量等值查询, 显⽰为const, 如果为连接查询, 显⽰关联的字段.5. Extra: 额外信息, 使⽤优先级using index > using filesort > using temporary.。

MySQL-EXPLAIN执行计划字段解释

MySQL-EXPLAIN执行计划字段解释

类型含义SIMPLE不带UNION 或⼦查询部分的SELECT ⼦句PRIMARY最外层或最左侧的SELECT 语句UNIONUNION ⾥的第⼆条或最后的SELECT ⼦句DEPENDENT UNION和UNION 相似,但需要依赖于某个外层查询UNION RESULTUNION 的结果SUBQUERY⼦查询中的第⼀个SELECT ⼦句DEPENDENT SUBQUERY和SUBQUERY 相似,但需要依赖于某个外层查询DERIVEDFROM ⼦句⾥的⼦查询UNCASHEABLE SUBQUERY ⽆法缓存的⼦查询结果UNCASHEABLE UNION⽆法缓存的⼦查询UNION 的第⼆条或随后的SELECT ⼦句MySQL-EXPLAIN 执⾏计划字段解释做 MySQL 查询优化遇到明明建了索引查询仍然很慢,看这个 SQL 的执⾏计划,看它到底有没有⽤到索引,执⾏的具体情况。

我们可以⽤ EXPLAIN 命令查看SQL 的执⾏计划,SQL 优化的重要性和执⾏计划密切相关。

EXPLAIN 能够让我们了解到MySQL 将如何执⾏出现在 EXPLAIN 之后的那条 SQL 语句,例如:EXPLAIN SELECT score.* FROM score INNER JOIN grade_eventON score.event_id = grade.event_id AND grad_event.event_id = 14;在MySQL 5.6.3之前,该语句必须为SELECT 。

⾃MySQL5.6.3起,该语句可以为 SELECT 、DELETE 、INSERT 或UPDATE 。

在 EXPLAIN 关键字之后,可以指定⼀个可选的指⽰器,指明要产⽣的输出类型:例如:会输出如图内容,这些字段的意思都是啥,是今天这篇⽂章的重点。

EXTENDED选项将使 EXPLAIN 语句⽣成更多的执⾏计划信息。

在 EXPLAIN 语句执⾏完毕之后⽴刻执⾏ SHOW WARNINGS 语句可以查看这些信息。

Mysql系列(九)——性能分析explain执行计划

Mysql系列(九)——性能分析explain执行计划

Mysql系列(九)——性能分析explain执⾏计划explain是mysql中sql优化的⼀个重要⼿段。

顾名思义,explain就是解释sql,⽤于表⽰sql是怎样执⾏的信息,即sql执⾏计划!语法explain statementstatement包括select/insert/delete/update语句。

explain会对select语句使⽤到每张表都会返回⼀⾏信息。

在输出列出的表是按照mysql处理sql时读他们的顺序排序的。

mysql使⽤嵌套循环联结⽅式处理sql中的表联结。

即mysql会从第⼀张表读取⼀⾏,然后与第⼆张表,第三张等等进⾏匹配处理。

然后在读取下⼀⾏,知道全部处理完。

从以上信息可以看出,explain的输出信息中可以获取到mysql读取表的顺序。

输出格式id:select的唯⼀标识select_type:select类型simple:表⽰不需要union操作或者不包含⼦查询的简单select查询。

有连接查询时,外层的查询为simple,且只有⼀个primary:⼀个需要union操作或者含有⼦查询的select,位于最外层的单位查询的select_type即为primary。

且只有⼀个union:union连接的两个select查询,第⼀个查询是dervied派⽣表,除了第⼀个表外,第⼆个以后的表select_type都是uniondependent union:与union⼀样,出现在union 或union all语句中,但是这个查询要受到外部查询的影响union result:包含union的结果集,在union和union all语句中,因为它不需要参与查询,所以id字段为nullsubquery:除了from字句中包含的⼦查询外,其他地⽅出现的⼦查询都可能是subquerydependent subquery:与dependent union类似,表⽰这个subquery的查询要受到外部表查询的影响derived:from字句中出现的⼦查询,也叫做派⽣表,其他数据库中可能叫做内联视图或嵌套selecttable:查询的表partitions:匹配的分区type:join类型依次从好到差:system,const,eq_ref,ref,fulltext,ref_or_null,unique_subquery,index_subquery,range,index_merge,index,ALL,除了all之外,其他的type都可以使⽤到索引,除了index_merge之外,其他的type只可以⽤到⼀个索引system:表中只有⼀⾏数据或者是空表,且只能⽤于myisam和memory表。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------------+---------+---------+-------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+--------------------+-------+-----------------+---------------+---------+---------+------+------+--------------------------+
| 1 | SIMPLE | A | ref | PRIMARY,i_studentId | PRIMARY | 35 | const | 1 | Using where |
+----+-------------+-------+------+---------------------+---------+---------+-------+------+-----的表的行组合,所有有匹配索引值的行将从这张表中读取。如果联接只使用键的最左边的前缀,或如果键不是UNIQUE或PRIMARY KEY(换句话说,如果联接不能基于关键字选择单个行的话),则使用ref。如果使用的键仅仅匹配少量行,该联接类型是不错的。ref可以用于使用=或<=>操作符的带索引的列。
index_subquery: 该联接类型类似于unique_subquery。可以替换IN子查询,但只适合下列形式的子查询中的非唯一索引:
mysql> EXPLAIN SELECT * FROM student A WHERE A.studentId IN (SELECT B.studentId FROM student_class B WHERE B.classId = 1);
+----+-------------+-------+------+--------------------+--------------------+---------+-------+------+-------------+
2 rows in set (0.00 sec)
unique_subquery: 该类型替换了下面形式的IN子查询的ref:
eq_ref: 对于每个来自于前面的表的行组合,从该表中读取一行。这可能是最好的联接类型,除了const类型。它用在一个索引的所有部分被联接使用并且索引是UNIQUE或PRIMARY KEY。
ref 这个连接类型只有在查询使用了不是惟一或主键的键或者是这些类型的部分(比如,利用最左边前缀)时发生。对于之前的表的每一个行联合,全部记录都将从表中读出。这个类型严重依赖于根据索引匹配的记录多少—越少越好
+----+--------------------+-------+----------------+---------------------------------+--------------+---------+------+------+--------------------------+
+----+--------------------+-------+-----------------+---------------+---------+---------+------+------+--------------------------+
2 rows in set (0.00 sec)
key 实际使用的索引。如果为NULL,则没有使用索引。很少的情况下,MYSQL会选择优化不足的索引。这种情况下,可以在SELECT语句中使用USE INDEX(indexname)来强制使用一个索引或者用IGNORE INDEX(indexname)来强制MYSQL忽略索引
key_len 使用的索引的长度。在不损失精确性的情况下,长度越短越好
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+--------------------+--------------------+---------+-------+------+-------------+
mysql> EXPLAIN SELECT * FROM student_class A WHERE A.classId IN (SELECT B.id FROM class B WHERE = "04");
+----+--------------------+-------+-----------------+---------------+---------+---------+------+------+--------------------------+
mysql> EXPLAIN SELECT * FROM student A WHERE studentId = "100001";
+----+-------------+-------+------+---------------------+---------+---------+-------+------+-------------+
EXPLAIN列的解释:
MYSQL 5.1 用户手册 7.2.1. EXPLAIN语法(获取SELECT相关信息)
有详细的诠释
id: SELECT识别符。这是SELECT的查询序列号。
select_type: 可以为以下任何一种
SIMPLE: 简单SELECT(不使用UNION或子查询)
Using index for group-by: 类似于访问表的Using index方式,Using index for group-by表示MySQL发现了一个索引,可以用来查询GROUP BY或DISTINCT查询的所有列,而不要额外搜索硬盘访问实际的表。并且,按最有效的方式使用索引,以便对于每个组,只读取少量索引条目
ref 显示索引的哪一列被使用了,如果可能的话,是一个常数
rows MYSQL认为必须检查的用来返回请求数据的行数
Extra 关于MYSQL如何解析查询的额外信息。将在表4.3中讨论,但这里可以看到的坏的例子是Using temporary和Using filesort,意思MYSQL根本不能使用索引,结果是检索会很慢
| 1 | SIMPLE | A | ref | fk_teacher_classId | fk_teacher_classId | 5 | const | 1 | Using where |
| 1 | SIMPLE | B | ref | fk_student_classId | fk_student_classId | 5 | const | 1 | Using where |
PRIMARY: 最外面的SELECT
UNION: UNION中的第二个或后面的SELECT语句
DEPENDENT UNION: 子查询中的第一个SELECT,取决于外面的查询
DERIVED: 导出表的SELECT(FROM子句的子查询)
table 显示这一行的数据是关于哪张表的
如果想要使查询尽可能快,应找出Using filesort 和Using temporary的Extra值
Using sort_union(...), Using union(...), Using intersect(...): 这些函数说明如何为index_merge联接类型合并索引扫描。
extra 该列包含MySQL解决查询的详细信息。
Distinct: 一旦MYSQL找到了与行相联合匹配的行,就不再搜索了
Not exists: MYSQL优化了LEFT JOIN,一旦它找到了匹配LEFT JOIN标准的行,就不再搜索了
Range checked for each: Record(index map:#)没有找到理想的索引,因此对于从前面表中来的每一 个行组合,MYSQL检查使用哪个索引,并用它来从表中返回行。这是使用索引的最慢的连接之一
1 row in set (0.00 sec)
mysql> EXPLAIN SELECT * FROM teacher_class A, student_class B where A.classId = B.classId AND B.classId = 2;
相关文档
最新文档