MySQL之儲存引擎及SQL優化

阿新 • • 發佈：2020-11-26

6、Mysql的體系結構概念

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-ngOJt76c-1606377489290)(/Users/mac/Documents/mysql筆記/mysql的體系結構.png)]

整個MySQL Server由以下組成

Connection Pool：連線元件（接受客戶端請求，進行認證授權後處理）
Management Services & Utilltles：管理服務和工具元件（備份、恢復，sql語句的封裝優化快取處理）
SQL interface：SQL介面元件
Parser：查詢分析器元件
Caches & Buffers：緩衝池元件

Pluggable Storage Engines：儲存引擎
File System：檔案系統

連線層

最上層是一些客戶端和連結服務，包含本地sock 通訊和大多數基於客戶端/服務端工具實現的類似於 TCP/IP的通信。主要完成一些類似於連線處理、授權認證、及相關的安全方案。在該層上引入了執行緒池的概念，為通過認證安全接入的客戶端提供執行緒。同樣在該層上可以實現基於SSL的安全連結。伺服器也會為安全接入的每個客戶端驗證它所具有的操作許可權。

服務層

第二層架構主要完成大多數的核心服務功能，如SQL介面，並完成快取的查詢，SQL的分析和優化，部分內建函式的執行。所有跨儲存引擎的功能也在這一層實現，如過程、函式等。在該層，伺服器會解析查詢並建立相應的內部解析樹，並對其完成相應的優化如確定表的查詢的順序，是否利用索引等，最後生成相應的執行操作。如果是 select語句，伺服器還會查詢內部的快取，如果快取空間足夠大，這樣在解決大量讀操作的環境中能夠很好的提升系統的效能。

引擎層

 儲存引擎層， 儲存引擎真正的負責了MySQL中資料的儲存和提取，伺服器通過API和儲存引擎進行通訊。不同的存

儲引擎具有不同的功能，這樣我們可以根據自己的需要，來選取合適的儲存引擎。 4)儲存層
資料儲存層，主要是將資料儲存在檔案系統之上，並完成與儲存引擎的互動。

和其他資料庫相比，MySQL有點與眾不同，它的架構可以在多種不同場景中應用併發揮良好作用。主要體現在儲存引擎上，外掛式的儲存引擎架構，將查詢處理和其他的系統任務以及資料的儲存提取分離。這種架構可以根據業務的需求和實際需要選擇合適的儲存引擎

7、儲存引擎

7.1 儲存引擎概述

和大多數的資料庫不同, MySQL中有一個儲存引擎的概念, 針對不同的儲存需求可以選擇最優的儲存引擎。儲存引擎就是儲存資料，建立索引，更新查詢資料等等技術的實現方式。儲存引擎是基於表的，而不是基於庫的。

所以儲存引擎也可被稱為表型別。

Oracle，SqlServer等資料庫只有一種儲存引擎。MySQL提供了外掛式的儲存引擎架構。所以MySQL存在多種儲存引擎，可以根據需要使用相應引擎，或者編寫儲存引擎。

MySQL5.0支援的儲存引擎包含 : InnoDB 、MyISAM 、BDB、MEMORY、MERGE、EXAMPLE、NDB Cluster、 ARCHIVE、CSV、BLACKHOLE、FEDERATED等，其中InnoDB和BDB提供事務安全表，其他儲存引擎是非事務安全表。

可以通過指定 show engines ，來查詢當前資料庫支援的儲存引擎 :

-- 查詢當前資料庫支援的儲存引擎
mysql> show engines;
-- 檢視預設的儲存引擎
mysql> show variables like '%storage_engine%';
+----------------------------------+--------+
| Variable_name                    | Value  |
+----------------------------------+--------+
| default_storage_engine           | InnoDB |
| default_tmp_storage_engine       | InnoDB |
| disabled_storage_engines         |        |
| internal_tmp_disk_storage_engine | InnoDB |
+----------------------------------+--------+

7.2 各種儲存引擎特徵

下面重點介紹幾種常用的儲存引擎，並對比各個儲存引擎之間的區別，如下表所示 :

特點	InnoDB	MyISAM	MEMORY	MERGE	NDB
儲存限制	64TB	有	有	沒有	有
事務安全	支援
鎖機制	行鎖（適合高併發）	表鎖	表鎖	表鎖	行鎖
B樹索引	支援	支援	支援	支援	支援
雜湊索引			支援
全文索引	支援（5.6版本後）	支援
叢集索引	支援
資料索引	支援
索引快取	支援	支援	支援	支援	支援
資料可壓縮		支援
空間使用	高	低	N/A	低	低
記憶體使用	低	低	中等	低	高
批量插入速度	低	高	高	高	高
支援外來鍵	支援

下面我們將重點介紹最長使用的兩種儲存引擎: InnoDB、MyISAM ，另外兩種 MEMORY、MERGE ，瞭解即
可。

7.2.1 InnoDB

InnoDB儲存引擎是Mysql的預設儲存引擎。InnoDB儲存引擎提供了具有提交、回滾、崩潰恢復能力的事務安全。

但是對比MyISAM的儲存引擎，InnoDB寫的處理效率差一些，並且會佔用更多的磁碟空間以保留資料和索引。

InnoDB儲存引擎不同於其他儲存引擎的特點 :

事務控制：

create table goods_innodb(
	id int NOT NULL AUTO_INCREMENT, 
  name varchar(20) NOT NULL, 
  primary key(id)
)ENGINE=innodb DEFAULT CHARSET=utf8;

-- 會話一
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into goods_innodb(id,name)values(null,'Meta20');
Query OK, 1 row affected (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.00 sec)
-- 會話二
mysql> select * from goods_innodb;
Empty set (0.01 sec)

mysql> select * from goods_innodb;
+----+--------+
| id | name   |
+----+--------+
|  1 | Meta20 |
+----+--------+
1 row in set (0.00 sec)

-- 總結
-- 當會話一的事務提交後，會話二才能查詢出會話一insert進去的資料

外來鍵約束

MySQL支援外來鍵的儲存引擎只有InnoDB ，在建立外來鍵的時候，要求父表必須有對應的索引，子表在建立外來鍵的時候，也會自動的建立對應的索引。

create table country_innodb(
		country_id int NOT NULL AUTO_INCREMENT, 
  	country_name varchar(100) NOT NULL, 
		primary key(country_id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
create table city_innodb(
    city_id int NOT NULL AUTO_INCREMENT,
    city_name varchar(50) NOT NULL,
    country_id int NOT NULL,
    primary key(city_id),
    key idx_fk_country_id(country_id),
    CONSTRAINT `fk_city_country` FOREIGN KEY(country_id) REFERENCES
country_innodb(country_id) ON DELETE RESTRICT ON UPDATE CASCADE
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert into country_innodb values(null,'China'),(null,'America'),(null,'Japan');
insert into city_innodb values(null,'Xian',1),(null,'NewYork',2),(null,'BeiJing',1);


-- ON DELETE RESTRICT 刪除主表資料時，如果有關聯記錄，不刪除；
-- ON UPDATE CASCADE 更新主表時，如果子表有關聯記錄，更新子表字段

在建立表時，可以指定在刪除、更新父表時，對子表進行相應的操作，包括RESTRICT、CASCADE、SET NULL和NO ACTION

RESTRICT和NO ACTION相同，表示：限制在子表有關聯記錄的情況下，父表不能更新；（子表有關聯記錄，父表不能更新）
CASCADE表示：父表在更新或者刪除時，更新或者刪除子表對應的記錄；（父表和子表同步更新或者刪除）
SET NULL則表示：父表在更新或者刪除的時候，子表對應欄位被SET NULL

針對上面建立的倆張表，子表的外來鍵指定是ON DELETE RESTRICT ON UPDATE CASCADE

mysql> select * from city_innodb;
+---------+-----------+------------+
| city_id | city_name | country_id |
+---------+-----------+------------+
|       1 | Xian      |          1 |
|       2 | NewYork   |          2 |
|       3 | BeiJing   |          1 |
+---------+-----------+------------+
3 rows in set (0.00 sec)

mysql> select * from country_innodb;
+------------+--------------+
| country_id | country_name |
+------------+--------------+
|          1 | China        |
|          2 | America      |
|          3 | Japan        |
+------------+--------------+
3 rows in set (0.00 sec)

mysql> delect from city_innodb where country_id =1;
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'delect from city_innodb where country_id =1' at line 1

mysql> update country_innodb set country_id = 100 where country_id =1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from city_innodb;
+---------+-----------+------------+
| city_id | city_name | country_id |
+---------+-----------+------------+
|       1 | Xian      |        100 |
|       2 | NewYork   |          2 |
|       3 | BeiJing   |        100 |
+---------+-----------+------------+
3 rows in set (0.00 sec)

儲存方式

InnoDB儲存表和索引有以下倆種方式：

1、使用共享表空間儲存，這種方式建立的表的表結構儲存在.frm檔案中，資料和索引儲存在innodb_data_home_dir和innodb_data_file_path定義的表空間中，可以是多個檔案。
2、使用多表空間儲存，這種方式建立的表的表結構仍然存在.frm檔案中，但是每個表的資料和索引單獨儲存在.ibd中

7.2.2 MyISAM

MyISAM不支援事務、也不支援外來鍵，其優勢是訪問的速度快，對事務的完整性沒有要求或者以SELECT、INSERT為主的應用基礎上都可以使用這個引擎來建立表，有以下倆個比較重要的特點：

不支援事務

create table goods_myisam(
id int NOT NULL AUTO_INCREMENT, name varchar(20) NOT NULL, primary key(id)
)ENGINE=myisam DEFAULT CHARSET=utf8;

-- 會話一
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into goods_myisam(id,name) values(null,'mysql');
Query OK, 1 row affected (0.01 sec)

-- 會話二
mysql> select * from goods_myisam;
+----+-------+
| id | name  |
+----+-------+
|  1 | mysql |
+----+-------+
1 row in set (0.00 sec)

-- 會話一
mysql> rollback;
Query OK, 0 rows affected, 1 warning (0.00 sec)

-- 回話二
mysql> select * from goods_myisam;
+----+-------+
| id | name  |
+----+-------+
|  1 | mysql |
+----+-------+
1 row in set (0.00 sec)

7.2.3 MEMORY

Memory儲存引擎將表的資料存放在記憶體中。每個MEMORY表實際對應一個磁碟檔案，格式是.frm ，該檔案中只儲存表的結構，而其資料檔案，都是儲存在記憶體中，這樣有利於資料的快速處理，提高整個表的效率。MEMORY 型別的表訪問非常地快，因為他的資料是存放在記憶體中的，並且預設使用HASH索引，但是服務一旦關閉，表中的資料就會丟失。

7.2.4 MERGE

MERGE儲存引擎是一組MyISAM表的組合，這些MyISAM表必須結構完全相同，MERGE表本身並沒有儲存資料，對

MERGE型別的表可以進行查詢、更新、刪除操作，這些操作實際上是對內部的MyISAM表進行的。

對於MERGE型別表的插入操作，是通過INSERT_METHOD子句定義插入的表，可以有3個不同的值，使用FIRST 或 LAST 值使得插入操作被相應地作用在第一或者最後一個表上，不定義這個子句或者定義為NO，表示不能對這個 MERGE表執行插入操作。

可以對MERGE表進行DROP操作，但是這個操作只是刪除MERGE表的定義，對內部的表是沒有任何影響的。

7.3 儲存引擎的選擇

在選擇儲存引擎時，應該根據應用系統的特點選擇合適的儲存引擎。對於複雜的應用系統，還可以根據實際情況選擇多種儲存引擎進行組合。以下是幾種常用的儲存引擎的使用環境。

InnoDB : 是Mysql的預設儲存引擎，用於事務處理應用程式，支援外來鍵。如果應用對事務的完整性有比較高的要求，在併發條件下要求資料的一致性，資料操作除了插入和查詢意外，還包含很多的更新、刪除操作，那麼InnoDB儲存引擎是比較合適的選擇。InnoDB儲存引擎除了有效的降低由於刪除和更新導致的鎖定，還可以確保事務的完整提交和回滾，對於類似於計費系統或者財務系統等對資料準確性要求比較高的系統， InnoDB是最合適的選擇。
MyISAM : 如果應用是以讀操作和插入操作為主，只有很少的更新和刪除操作，並且對事務的完整性、併發性要求不是很高，那麼選擇這個儲存引擎是非常合適的。
MEMORY:將所有資料儲存在RAM中，在需要快速定位記錄和其他類似資料環境下，可以提供幾塊的訪問。MEMORY的缺陷就是對錶的大小有限制，太大的表無法快取在記憶體中，其次是要確保表的資料可以恢復，數據庫異常終止後表中的資料是可以恢復的。MEMORY表通常用於更新不太頻繁的小表，用以快速得到訪問結果。
MERGE:用於將一系列等同的MyISAM表以邏輯方式組合在一起，並作為一個物件引用他們。MERGE表的優點在於可以突破對單個MyISAM表的大小限制，並且通過將不同的表分佈在多個磁碟上，可以有效的改善 MERGE表的訪問效率。這對於儲存諸如資料倉儲等VLDB環境十分合適。

8、優化SQL步驟

8.1 檢視SQL執行頻率

MySQL 客戶端連線成功後，通過 show [session|global] status 命令可以提供伺服器狀態資訊。show
[session|global] status 可以根據需要加上引數“session”或者“global”來顯示 session 級(當前連線)的計結果和
global 級(自資料庫上次啟動至今)的統計結果。如果不寫，預設使用引數是“session”。

-- 查詢當前連線的狀態資訊
show status like 'Com_______';
-- 查詢全域性的狀態資訊
show global status like 'Com_______';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Com_binlog    | 0     |
| Com_commit    | 0     |
| Com_delete    | 0     |
| Com_insert    | 1     |
| Com_repair    | 0     |
| Com_revoke    | 0     |
| Com_select    | 8     |
| Com_signal    | 0     |
| Com_update    | 0     |
| Com_xa_end    | 0     |
+---------------+-------+
10 rows in set (0.01 sec)
show global status like 'innodb_rows_%';
mysql> show global status like 'innodb_rows_%';
+----------------------+-------+
| Variable_name        | Value |
+----------------------+-------+
| Innodb_rows_deleted  | 0     |
| Innodb_rows_inserted | 0     |
| Innodb_rows_read     | 8     |
| Innodb_rows_updated  | 0     |
+----------------------+-------+
4 rows in set (0.00 sec)

Com_xxx 表示每個 xxx 語句執行的次數，我們通常比較關心的是以下幾個統計引數。

引數	含義
Com_select	執行 select 操作的次數，一次查詢只累加 1。
Com_insert	執行 INSERT 操作的次數，對於批量插入的 INSERT 操作，只累加一次。
Com_update	執行 UPDATE 操作的次數。
Com_delete	執行 DELETE 操作的次數。
Innodb_rows_read	select 查詢返回的行數。
Innodb_rows_inserted	執行 INSERT 操作插入的行數。
Innodb_rows_updated	執行 UPDATE 操作更新的行數。
Innodb_rows_deleted	執行 DELETE 操作刪除的行數。
Connections	試圖連線 MySQL 伺服器的次數。
Uptime	伺服器工作時間。
Slow_queries	慢查詢的次數。

Com_*** : 這些引數對於所有儲存引擎的表操作都會進行累計。
Innodb_*** : 這幾個引數只是針對InnoDB 儲存引擎的，累加的演算法也略有不同。

8.2 定位低效率執行SQL

慢查詢日誌 : 通過慢查詢日誌定位那些執行效率較低的 SQL 語句，用–log-slow-queries[=file_name]選項啟
動時，mysqld 寫一個包含所有執行時間超過 long_query_time 秒的 SQL 語句的日誌檔案。具體可以檢視本
書第 26 章中日誌管理的相關部分。
show processlist：慢查詢日誌在查詢結束以後才紀錄，所以在應用反映執行效率出現問題的時候查詢慢查詢
日誌並不能定位問題，可以使用show processlist命令檢視當前MySQL在進行的執行緒，包括執行緒的狀態、是否
鎖表等，可以實時地檢視 SQL 的執行情況，同時對一些鎖表操作進行優化。

mysql> show processlist;
+----+------+-----------+------+---------+------+----------+------------------+
| Id | User | Host      | db   | Command | Time | State    | Info             |
+----+------+-----------+------+---------+------+----------+------------------+
|  3 | root | localhost | test | Query   |    0 | starting | show processlist |
+----+------+-----------+------+---------+------+----------+------------------+
1 row in set (0.00 sec)

-- 1）id列：使用者登陸mysql時，系統分配的"connection_id"，可以使用函式connection_id()檢視(select connection_id();)
-- 2) user列：顯示當前使用者。如果不是root，這個命令就只顯示使用者許可權範圍的sql語句
-- 3) host列，顯示這個語句是從哪個ip的哪個埠上發的，可以用來跟蹤出現問題語句的使用者
-- 4) db列，顯示這個程序目前連線的是哪個資料庫
-- 5) command列，顯示當前連線的執行的命令，一般取值為休眠(sleep)，查詢(query)，連線 (connect)等
-- 6) time列，顯示這個狀態持續的時間，單位是秒
-- 7) state列，顯示使用當前連線的sql語句的狀態，很重要的列。state描述的是語句執行中的某一個狀態。一 個sql語句，以查詢為例，可能需要經過copying to tmp table、sorting result、sending data等狀態 才可以完成
-- 8）info列，顯示這個sql語句，是判斷問題語句的一個重要依據

8.3 explain分析執行計劃

通過以上步驟查詢效率低的SQL語句後，可以通過explain或者desc命令獲取MYSQL如何執行SELECT語句的資訊，包括在SELECT語句執行過程中表如何連線和連線的順序

查詢SQL語句的執行計劃：

mysql> explain select * from city;
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
| id | select_type | table | partitions | type | possible_keys | key  | key_len | ref  | rows | filtered | Extra |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
|  1 | SIMPLE      | city  | NULL       | ALL  | NULL          | NULL | NULL    | NULL |    4 |   100.00 | NULL  |
+----+-------------+-------+------------+------+---------------+------+---------+------+------+----------+-------+
1 row in set, 1 warning (0.00 sec)

欄位	含義
ID	elect查詢的序列號，是一組數字，表示的是查詢中執行select子句或者是操作表的順序。
select_type	表示 SELECT 的型別，常見的取值有 SIMPLE(簡單表，即不使用表連線或者子查詢)、PRIMARY(主查詢，即外層的查詢)、UNION(UNION 中的第二個或者後面的查詢語句)、SUBQUERY(子查詢中的第一個 SELECT)等
table	輸出結果集的表
type	表示表的連線型別，效能由好到差的連線型別為( system —> const -----> eq_ref ------> ref-------> ref_or_null----> index_merge —> index_subquery -----> range -----> index ------>all )
possible_keys	表示查詢時，可能使用的索引
key	表示實際使用的索引
key_len	索引欄位的長度
rows	描行的數量
extra	執行情況的說明和描述

8.3.1 環境準備

CREATE TABLE `t_role` (
	`id` varchar(32) NOT NULL,
	`role_name` varchar(255) DEFAULT NULL, 
  `role_code` varchar(255) DEFAULT NULL, 
  `description` varchar(255) DEFAULT NULL, 
  PRIMARY KEY (`id`),
	UNIQUE KEY `unique_role_name` (`role_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `t_user` (
  `id` varchar(32) NOT NULL,
  `username` varchar(45) NOT NULL,
  `password` varchar(96) NOT NULL,
  `name` varchar(45) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `user_role` (
  `id` int(11) NOT NULL auto_increment ,
  `user_id` varchar(32) DEFAULT NULL,
  `role_id` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fk_ur_user_id` (`user_id`),
  KEY `fk_ur_role_id` (`role_id`),
  CONSTRAINT `fk_ur_role_id` FOREIGN KEY (`role_id`) REFERENCES `t_role` (`id`) ON
DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `fk_ur_user_id` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`) ON
DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert into `t_user` (`id`, `username`, `password`, `name`) values('1','super','$2a$10$TJ4TmCdK.X4wv/tCqHW14.w70U3CC33CeVncD3SLmyMXMknstqKRe',' 超級管理員');
insert into `t_user` (`id`, `username`, `password`, `name`) values('2','admin','$2a$10$TJ4TmCdK.X4wv/tCqHW14.w70U3CC33CeVncD3SLmyMXMknstqKRe',' 系統管理員');
insert into `t_user` (`id`, `username`, `password`, `name`) values('3','itcast','$2a$10$8qmaHgUFUAmPR5pOuWhYWOr291WJYjHelUlYn07k5ELF8ZCrW0Cui', 'test02');
insert into `t_user` (`id`, `username`, `password`, `name`) values('4','stu1','$2a$10$pLtt2KDAFpwTWLjNsmTEi.oU1yOZyIn9XkziK/y/spH5rftCpUMZa','學 生1');
insert into `t_user` (`id`, `username`, `password`, `name`) values('5','stu2','$2a$10$nxPKkYSez7uz2YQYUnwhR.z57km3yqKn3Hr/p1FR6ZKgc18u.Tvqm','學 生2');
insert into `t_user` (`id`, `username`, `password`, `name`) values('6','t1','$2a$10$TJ4TmCdK.X4wv/tCqHW14.w70U3CC33CeVncD3SLmyMXMknstqKRe','老師 1');

INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('5','學生','student','學生');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('7','老師','teacher','老師');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('8','教學管理員','teachmanager','教學管理員');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('9','管理員','admin','管理員');
INSERT INTO `t_role` (`id`, `role_name`, `role_code`, `description`) VALUES('10','超級管理員','super','超級管理員');

INSERT INTO user_role(id,user_id,role_id) VALUES(NULL, '1', '5'),(NULL, '1', '7'),
(NULL, '2', '8'),(NULL, '3', '9'),(NULL, '4', '8'),(NULL, '5', '10');

8.3.2 explain 之id

id欄位是select查詢的序列號，是一組數字，表示的是查詢中執行select子句或者是操作表的順序、id情況分三種：

1）id相同表示載入表的順序是從上到下：

mysql> explain select * from t_role r, t_user u, user_role ur where r.id = ur.role_id and u.id = ur.user_id ;

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-tVL88IM7-1606377489294)(/Users/mac/Documents/1expalin分析執行計劃之id1.png)]

2）id不同id值越大，優先順序越高，越先被執行。

EXPLAIN SELECT * FROM t_role WHERE id = (SELECT role_id FROM user_role WHERE user_id = (SELECT id FROM t_user WHERE username = 'stu1'));

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-boioCiAJ-1606377489297)(/Users/mac/Documents/1explain分析執行計劃之id2.png)]

3）id有相同，也有不同，同時存在。id相同的可以認為是一組，從上往下順序執行；在所有的組中，id的值越大，優先順序越高，越先執行。

EXPLAIN SELECT * FROM t_role r , (SELECT * FROM user_role ur WHERE ur.`user_id` = '2') a WHERE r.id = a.role_id ;

8.3.3 explain之select_type

表示select的型別，常見的取值如下：

select_type	含義
SIMPLE	簡單的select查詢，查詢中不包含子查詢或者UNION
PRIMARY	查詢中若包含任何複雜的子查詢，最外層查詢標記為該標識
SUBQUERY	在SELECT或HWERE列表中包含子查詢
DERIVED	在FROM列表中包含的子查詢，被標記為DERIVED（衍生） MYSQL會遞迴執行這些子查詢，把結果放在臨時表中（即：from後面接子查詢，子查詢結果被放入臨時表）
UNION	若第二個SELECT出現在UNION之後，則標記為UNION；若UNION包含在FROM子句的子查詢中，外層SELECT被標記為：DERIVED
UNION RESULT	從UNION表獲取結果的SELECT

從SIMPLE到UNION RESULT 效率越來越低

8.3.4 explain之table

表示查詢的資料來源於哪張表

8.3.5 explain之type

type	含義
NULL	MYSQL不妨問任何表，索引直接返回結果
system	表只有一行記錄（等於系統表），這是const型別的特例，一般不會出現
const	表示通過索引一次就找到了，const用於比較primary key或者unique索引，因為只匹配一行資料，所以很快，如將主鍵置於where列表中，mysql就能將該查詢轉換為一個常量，const於將"主鍵"或"唯一"的索引部分與常量進行比較（即：根據主鍵或者唯一索引進行查詢，且資料只有一條）
eq_ref	類似於ref，區別在於使用的是唯一索引，使用主鍵的關聯查詢，關聯查詢出的記錄只有一條，常見於主鍵或唯一索引掃描（即：多表關聯查詢，查詢結果只有一條記錄）
ref	非唯一索引掃描，返回匹配某個單獨值的所有行，本質上也是一種索引訪問，返回多個匹配某個單獨值的所有行（多個）（即：根據非唯一索引查詢得到多條記錄）
range	檢索指定範圍的行，where後面是一個範圍查詢（between、in、>、<、>=、特殊：in有時候會失效，從而轉為無索引 all）
index	index與all的區別為index型別只是遍歷了索引樹，通常比all快，all是遍歷資料檔案
all	將遍歷全表找到匹配的行

結果值從最高到最壞依次為：

null > system > const > eq_ref > ref > fulltext > ref_or_null > index_range > unique_suquery > index_subquery > range > index > all 

system > const > eq_ref >ref > range > index > all

一般來說，我們需要保證查詢至少達到range級別，最好達到ref

8.3.6 explain 之 key

possible_keys : 顯示可能應用到這張表的索引，一個或多個

key : 實際用到的索引，如果為null，則沒有使用索引

key_len ： 表示索引中使用的位元組數，該之為索引欄位最大可能長度，並非實際使用長度，在不損失精確性的前提下，長度越短越好

8.3.7 explain 之 rows

掃描行的數量

8.3.8 explain 之extra

其他額外的執行計劃資訊，在該列展示。

extra	含義
using filesort	說明mysql會對資料使用一個外部的索引排序，而不是按照表內的索引進行讀取，稱為"檔案排序"，效率低
using temporary	使用了臨時表儲存中間結果，mysql在對查詢結果排序的時候使用了臨時表，常用於order by 和group by；效率低
using index	表示相應的select操作使用了索引覆蓋，避免訪問表的資料行，效率不錯
using where	表示優化器需要通過索引回表查詢資料
using index condition	使用了索引但是需要回表查詢資料
using index；using where	查詢使用了索引，但是需要的資料都能在索引列中找到，不需要回表查詢資料。
impossible where	where子句永遠為false

using index & using where 和using index區別在於是否用了where

using filesort

create table test02(
	a1 char(3),
  a2 char(3),
  a3 char(3),
  index index_a1(a1),
  index index_a2(a2),
  index index_a3(a3),
);
-- 單索引
explain select * from test02 where a1='' order by a1;
-- 出現 using filesort
explain select * from test02 where a1='' order by a2;
-- 小結：
-- 對於單索引，如果排序和查詢是同一個欄位，則不會出現using filesort；如果排序和查詢不是同一個欄位則會出現using filesort；
-- 避免： where哪些欄位，就order by 哪些欄位

-- 複合索引：不能跨列（最佳左字首）
drop index index_a1 on test02;
drop index index_a2 on test02;
drop index index_a3 on test02;
alter table test02 add index index_a1_a2_a3(a1,a2,a3);

-- 出現 using filesort 
explain select * from test02 where a1='' order by a3;
-- 出現 using filesort
explain select * from test02 where a2='' order by a3;
-- 不出現
explain select * from test02 where a1='' order by a2;

-- 避免： where和order by按照複合索引的順序使用，不要跨列或無序使用。

using temporary

explain select a1 from test02 where a1 in('1','2','3') group by a1;
explain select a1 from test02 where a1 in('1','2','3') group by a2;
-- 避免：查詢哪些列，就用哪些列分組

8.4 show profile分析SQL

Mysql從5.0.37版本開始增加了對 show profiles 和 show profile 語句的支援。show profiles 能夠在做SQL優化時幫助我們瞭解時間都耗費到哪裡去了。

通過 have_profiling 引數，能夠看到當前MySQL是否支援profile:

mysql> select @@have_profiling;
+------------------+
| @@have_profiling |
+------------------+
| YES              |
+------------------+
1 row in set, 1 warning (0.00 sec)

預設profiling是關閉的，可以通過set語句在Session級別開啟profiling：

mysql> select @@profiling;
+-------------+
| @@profiling |
+-------------+
|           0 |
+-------------+
1 row in set, 1 warning (0.00 sec)

-- 開啟profiling
set profiling = 1;

通過profile，我們能夠更清楚地瞭解SQL執行的過程。

首先，我們可以執行一系列的操作，如下圖所示:

show databases;
mysql> use sql_optimization;
mysql> show tables;
mysql> select * from t_user;

執行完上述命令之後，再執行show profiles 指令，來檢視SQL語句執行的耗時:

mysql> show profiles;
+----------+------------+----------------------+
| Query_ID | Duration   | Query                |
+----------+------------+----------------------+
|        1 | 0.00059300 | show databases       |
|        2 | 0.00014500 | SELECT DATABASE()    |
|        3 | 0.00041800 | show tables          |
|        4 | 0.00151500 | select * from t_user |
+----------+------------+----------------------+

通過show profile for query query_id 語句可以檢視到該SQL執行過程中每個執行緒的狀態和消耗的時間:

mysql> show profile for query 4;
+----------------------+----------+
| Status               | Duration |
+----------------------+----------+
| starting             | 0.000066 |
| checking permissions | 0.000011 |
| Opening tables       | 0.000022 |
| init                 | 0.000022 |
| System lock          | 0.000011 |
| optimizing           | 0.000005 |
| statistics           | 0.001128 |
| preparing            | 0.000034 |
| executing            | 0.000005 |
| Sending data         | 0.000123 |
| end                  | 0.000009 |
| query end            | 0.000009 |
| closing tables       | 0.000012 |
| freeing items        | 0.000035 |
| cleaning up          | 0.000023 |
+----------------------+----------+

TIP:
	Sending data 狀態表示MySQL執行緒開始訪問資料行並把結果返回給客戶端，而不僅僅是返回給客戶端，由於在Sending data狀態下，MySQL執行緒往往需要做大量的磁碟讀取操作，所以經常是整個查詢中耗時最長的狀態。

在獲取到最消耗時間的執行緒狀態後，MySQL支援進一步選擇all、cpu、block io 、context switch、page faults等
明細型別類檢視MySQL在使用什麼資源上耗費了過高的時間。例如，選擇檢視CPU的耗費時間 :

mysql> show profile cpu for query 4;
+----------------------+----------+----------+------------+
| Status               | Duration | CPU_user | CPU_system |
+----------------------+----------+----------+------------+
| starting             | 0.000066 | 0.000057 |   0.000009 |
| checking permissions | 0.000011 | 0.000009 |   0.000003 |
| Opening tables       | 0.000022 | 0.000019 |   0.000001 |
| init                 | 0.000022 | 0.000021 |   0.000002 |
| System lock          | 0.000011 | 0.000009 |   0.000002 |
| optimizing           | 0.000005 | 0.000004 |   0.000001 |
| statistics           | 0.001128 | 0.000030 |   0.000222 |
| preparing            | 0.000034 | 0.000024 |   0.000009 |
| executing            | 0.000005 | 0.000002 |   0.000002 |
| Sending data         | 0.000123 | 0.000091 |   0.000017 |
| end                  | 0.000009 | 0.000004 |   0.000004 |
| query end            | 0.000009 | 0.000008 |   0.000002 |
| closing tables       | 0.000012 | 0.000011 |   0.000001 |
| freeing items        | 0.000035 | 0.000012 |   0.000022 |
| cleaning up          | 0.000023 | 0.000023 |   0.000016 |
+----------------------+----------+----------+------------+

-- status: sql語句執行的狀態
-- duration: sql執行過程中每一個步驟的耗時
-- cpu_user: 當前使用者佔有的cpu
-- cpu_system: 系統佔有的cpu

8.5 trace分析優化器執行計劃

MySQL5.6提供了對SQL的跟蹤trace, 通過trace檔案能夠進一步瞭解為什麼優化器選擇A計劃, 而不是選擇B計劃。

開啟trace ，設定格式為 JSON，並設定trace最大能夠使用的記憶體大小，避免解析過程中因為預設記憶體過小而不能
夠完整展示。

set optimizer_trace="enabled=on",end_markers_in_json=on; 
set optimizer_trace_max_mem_size=1000000;

執行SQL語句 :

select * from t_user where id <5;

最後，檢查information_schema.optimizer_trace就可以知道MySQL是如何執行SQL的 :

select * from information_schema.optimizer_trace\G;

*************************** 1. row ***************************
QUERY: select * from t_user where id <5
TRACE: {
  "steps": [
    {
      "join_preparation": {
        "select#": 1,
        "steps": [
          {
            "expanded_query": "/* select#1 */ select `t_user`.`id` AS `id`,`t_user`.`username` AS `username`,`t_user`.`password` AS `password`,`t_user`.`name` AS `name` from `t_user` where (`t_user`.`id` < 5)"
          }
        ] /* steps */
      } /* join_preparation */
    },
    {
      "join_optimization": {
        "select#": 1,
        "steps": [
          {
            "condition_processing": {
              "condition": "WHERE",
              "original_condition": "(`t_user`.`id` < 5)",
              "steps": [
                {
                  "transformation": "equality_propagation",
                  "resulting_condition": "(`t_user`.`id` < 5)"
                },
                {
                  "transformation": "constant_propagation",
                  "resulting_condition": "(`t_user`.`id` < 5)"
                },
                {
                  "transformation": "trivial_condition_removal",
                  "resulting_condition": "(`t_user`.`id` < 5)"
                }
              ] /* steps */
            } /* condition_processing */
          },
          {
            "substitute_generated_columns": {
            } /* substitute_generated_columns */
          },
          {
            "table_dependencies": [
              {
                "table": "`t_user`",
                "row_may_be_null": false,
                "map_bit": 0,
                "depends_on_map_bits": [
                ] /* depends_on_map_bits */
              }
            ] /* table_dependencies */
          },
          {
            "ref_optimizer_key_uses": [
            ] /* ref_optimizer_key_uses */
          },
          {
            "rows_estimation": [
              {
                "table": "`t_user`",
                "range_analysis": {
                  "table_scan": {
                    "rows": 6,
                    "cost": 4.3
                  } /* table_scan */,
                  "potential_range_indexes": [
                    {
                      "index": "PRIMARY",
                      "usable": true,
                      "key_parts": [
                        "id"
                      ] /* key_parts */
                    },
                    {
                      "index": "unique_user_username",
                      "usable": false,
                      "cause": "not_applicable"
                    }
                  ] /* potential_range_indexes */,
                  "setup_range_conditions": [
                  ] /* setup_range_conditions */,
                  "group_index_range": {
                    "chosen": false,
                    "cause": "not_group_by_or_distinct"
                  } /* group_index_range */
                } /* range_analysis */
              }
            ] /* rows_estimation */
          },
          {
            "considered_execution_plans": [
              {
                "plan_prefix": [
                ] /* plan_prefix */,
                "table": "`t_user`",
                "best_access_path": {
                  "considered_access_paths": [
                    {
                      "rows_to_scan": 6,
                      "access_type": "scan",
                      "resulting_rows": 6,
                      "cost": 2.2,
                      "chosen": true
                    }
                  ] /* considered_access_paths */
                } /* best_access_path */,
                "condition_filtering_pct": 100,
                "rows_for_plan": 6,
                "cost_for_plan": 2.2,
                "chosen": true
              }
            ] /* considered_execution_plans */
          },
          {
            "attaching_conditions_to_tables": {
              "original_condition": "(`t_user`.`id` < 5)",
              "attached_conditions_computation": [
              ] /* attached_conditions_computation */,
              "attached_conditions_summary": [
                {
                  "table": "`t_user`",
                  "attached": "(`t_user`.`id` < 5)"
                }
              ] /* attached_conditions_summary */
            } /* attaching_conditions_to_tables */
          },
          {
            "refine_plan": [
              {
                "table": "`t_user`"
              }
            ] /* refine_plan */
          }
        ] /* steps */
      } /* join_optimization */
    },
    {
      "join_execution": {
        "select#": 1,
        "steps": [
        ] /* steps */
      } /* join_execution */
    }
  ] /* steps */
}

9、索引的使用

索引是資料庫優化最常用也是最重要的手段之一, 通過索引通常可以幫助使用者解決大多數的MySQL的效能優化問題。

9.1索引的使用

9.1.1 準備環境

create table `tb_seller` ( `sellerid` varchar (100), `name` varchar (100), `nickname` varchar (50), `password` varchar (60), `status` varchar (1), `address` varchar (100), `createtime` datetime, primary key(`sellerid`)
)engine=innodb default charset=utf8mb4;


insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('alibaba','阿里巴巴','阿里小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('baidu','百度科技有限公司','百度小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('huawei','華為科技有限公司','華為小店','e10adc3949ba59abbe56e057f20f883e','0','北京市','2088-01-01 12:00:00');
insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('itcast','錘子科技有限公司','錘子科技','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');
insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('itheima','騰訊科技有限公司','騰訊科技','e10adc3949ba59abbe56e057f20f883e','0','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('luoji','羅技科技有限公司','羅技小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('oppo','OPPO科技有限公司','OPPO官方旗艦店','e10adc3949ba59abbe56e057f20f883e','0','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('ourpalm','掌趣科技股份有限公司','掌趣小店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('qiandu','千度科技','千度小店','e10adc3949ba59abbe56e057f20f883e','2','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('sina','新浪科技有限公司','新浪官方旗艦店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('xiaomi','小米科技','小米官方旗艦店','e10adc3949ba59abbe56e057f20f883e','1','西安市','2088-01-01 12:00:00'); insert into `tb_seller` (`sellerid`, `name`, `nickname`, `password`, `status`, `address`, `createtime`) values('yijia','宜家家居','宜家家居旗艦店','e10adc3949ba59abbe56e057f20f883e','1','北京市','2088-01-01 12:00:00');

create index idx_seller_name_sta_addr on tb_seller(name,status,address);

9.1.2 避免索引失效

1、全值匹配，對索引中所有列都指定具體值。

該情況下，索引生效，執行效率高

explain select * from tb_seller where name='小米科技' and status='1' and address='北京市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 813
          ref: const,const,const
         rows: 1
     filtered: 100.00
        Extra: NULL

2、最左字首（與where後接的條件順序無關，包含最左索引欄位，則滿足最左字首原則）

如果索引了多列，要遵守最左字首法則。指的是查詢從索引的最左前列開始，並且不跳過索引中的列。

mysql> explain select * from tb_seller where name='小米科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 403
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL
        
mysql> explain select * from tb_seller where name='小米科技' and status='1'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: const,const
         rows: 1
     filtered: 100.00
        Extra: NULL
        
mysql> explain select * from tb_seller where name='小米科技' and address='西安市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 403
          ref: const
         rows: 1
     filtered: 10.00
        Extra: Using index condition
        
 -- 最左字首與where後接的查詢條件無關，條件包含了最左字首即可      
mysql> explain select * from tb_seller where status='1' and name='小米科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: const,const
         rows: 1
     filtered: 100.00
        Extra: NULL
        
-- 需要回表查詢
mysql> explain select password from tb_seller where password ='e10adc3949ba59abbe56e057f20f883e'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 10.00
        Extra: Using where

3、範圍查詢右邊的列，不能使用索引

-- 根據key_len判斷states右邊的
mysql> explain select * from tb_seller where name='小米科技' and status>'1'  and address='西安市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: range
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: NULL
         rows: 1
     filtered: 10.00
        Extra: Using index condition
1 row in set, 1 warning (0.00 sec)


mysql> explain select * from tb_seller where name='小米科技' and status='1'  and address='西安市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 813
          ref: const,const,const
         rows: 1
     filtered: 100.00
        Extra: NULL
1 row in set, 1 warning (0.00 sec)

4、不要再索引列上進行運算操作，否則索引失效

mysql> explain select * from tb_seller where substring(name,3,2)='科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using where

5、字串不加單引號，造成索引失效

mysql> explain select * from tb_seller where name='小米科技' and status=1\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 403
          ref: const
         rows: 1
     filtered: 10.00
        Extra: Using index condition
        
mysql> explain select * from tb_seller where name='小米科技' and status='1'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: const,const
         rows: 1
     filtered: 100.00
        Extra: NULL

由於在查詢時，沒有對字串加單引號，MySQL的查詢優化器，會自動的進行型別轉換，造成索引失效。

6、儘量使用覆蓋索引，避免select *

mysql> explain select * from tb_seller where name='小米科技' and status='1'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: const,const
         rows: 1
     filtered: 100.00
        Extra: NULL

mysql> explain select name,status,address from tb_seller where name='小米科技' and status='1'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: const,const
         rows: 1
     filtered: 100.00
        Extra: Using index

如果查詢列，超出索引列，也會降低效能

mysql> explain select name,status,address,password from tb_seller where name='小米科技' and status='1'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 410
          ref: const,const
         rows: 1
     filtered: 100.00
        Extra: NULL

7、用or分割開的條件，如果or前面的列有索引，而後面的列沒有索引，那麼涉及的索引都不會被用到。

示例：name 欄位是索引列，而nickname不是索引列，中間or進行連線是不走索引的：

mysql> explain select * from tb_seller where name='小米科技' or nickname='小米官方旗艦店'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: idx_seller_name_sta_addr
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 19.00
        Extra: Using where

8、以%開頭的like模糊查詢，索引失效

如果僅尾部模糊匹配，索引不失效，如果是頭部模糊匹配，索引失效

mysql> explain select * from tb_seller where name like '%小米%'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 11.11
        Extra: Using where
        
explain select * from tb_seller where name like '%科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 11.11
        Extra: Using where
        
explain select * from tb_seller where name like '小米%'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: range
possible_keys: idx_seller_name_sta_addr
          key: idx_seller_name_sta_addr
      key_len: 403
          ref: NULL
         rows: 1
     filtered: 100.00
        Extra: Using index condition

解決辦法：

通過覆蓋索引解決

mysql> explain select name,status,address from tb_seller where name like '%科技%'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: index
possible_keys: NULL
          key: idx_seller_name_sta_addr
      key_len: 813
          ref: NULL
         rows: 12
     filtered: 11.11
        Extra: Using where; Using index

9、如果mysql評估使用索引比全表更慢，則不使用索引

mysql> create index idx_address on tb_seller(address);

mysql> explain select * from tb_seller where address='西安市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_address
          key: idx_address
      key_len: 403
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL
        
mysql> explain select * from tb_seller where address='北京市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: idx_address
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 91.67
        Extra: Using where

根據資料庫表資料有關，被索引欄位的值大部門都是一樣，則資料庫優化引擎不會使用索引，而進行全表掃描

10、is NULL 、is NOT NULL 有時索引失效（根據資料庫的資料量決定的）

和資料庫表中的資料有關

如果大部分資料為null
- is null 索引失效，資料庫會自動選擇全表掃描
- is not null 使用索引
如果大部分資料不為null
- is not null 資料庫會自動選擇全表掃描，索引失效
- is null 使用索引

11、in走索引，not in 索引失效

mysql> explain select * from tb_seller where sellerid in('xiaomi','baidu','alibaba')\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: range
possible_keys: PRIMARY
          key: PRIMARY
      key_len: 402
          ref: NULL
         rows: 3
     filtered: 100.00
        Extra: Using where
        
 
mysql> explain select * from tb_seller where sellerid not in('xiaomi','baidu','alibaba')\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: PRIMARY
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 91.67
        Extra: Using where

12、單列索引和複合索引

儘量使用複合索引，而少使用單列索引

建立複合索引

create index idx_name_status_address on tb_seller(name,status,address);

就相當於建立了三個索引：
		name
		name+status
		name+status+address

建立單列索引

create index idx_seller_name on tb_seller(name); 
create index idx_seller_status on tb_seller(status); 
create index idx_seller_address on tb_seller(address);

資料庫會選擇一個最優的索引（辨識度最高的索引）來使用，並不會使用全部索引。

-- 只用到了idx_seller_name索引（'小米科技'在表裡是唯一的，辨識度高）
mysql> explain select * from tb_seller where name='小米科技' and status='1' and address='西安市'\G；
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name,idx_seller_status,idx_seller_address
          key: idx_seller_name
      key_len: 403
          ref: const
         rows: 1
     filtered: 8.33
        Extra: Using where

-- 只用到了idx_seller_name索引（'西安市'在表中只有一條資料，辨識度高）
mysql> explain select * from tb_seller where status='0' and address='西安市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_status,idx_seller_address
          key: idx_seller_address
      key_len: 403
          ref: const
         rows: 1
     filtered: 66.67
        Extra: Using where
        
-- 只用到了idx_seller_status索引（status辨識度高）
mysql> explain select * from tb_seller where status='0' and address='北京市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_status,idx_seller_address
          key: idx_seller_status
      key_len: 7
          ref: const
         rows: 3
     filtered: 91.67
        Extra: Using where

9.2 檢視索引的使用情況

-- 當前會話
show status like 'Handler_read%';
-- 全域性
show global status like 'Handler_read%';

Handler_read_first:索引中第一條被讀的次數。如果較高，表示伺服器正執行大量全索引掃描(這個值越低 越好)。
Handler_read_key:如果索引正在工作，這個值代表一個行被索引值讀的次數，如果值越低，表示索引得到的 效能改善不高，因為索引不經常使用(這個值越高越好)。
Handler_read_next :按照鍵順序讀下一行的請求數。如果你用範圍約束或如果執行索引掃描來查詢索引列， 該值增加。
Handler_read_prev:按照鍵順序讀前一行的請求數。該讀方法主要用於優化ORDER BY ... DESC。
Handler_read_rnd :根據固定位置讀一行的請求數。如果你正執行大量查詢並需要對結果進行排序該值較高。 你可能使用了大量需要MySQL掃描整個表的查詢或你的連線沒有正確使用鍵。這個值較高，意味著執行效率低，應 該建立索引來補救。
Handler_read_rnd_next:在資料檔案中讀下一行的請求數。如果你正進行大量的表掃描，該值較高。通常說明你的表索引不正確或寫入的查詢沒有利用索引。

10 SQL優化

10.1 大批量插入資料

環境準備：

CREATE TABLE `tb_user1` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(45) NOT NULL,
`password` varchar(96) NOT NULL,
`name` varchar(45) NOT NULL,
`birthday` datetime DEFAULT NULL,
`sex` char(1) DEFAULT NULL,
`email` varchar(45) DEFAULT NULL,
`phone` varchar(45) DEFAULT NULL,
`qq` varchar(32) DEFAULT NULL,
`status` varchar(32) NOT NULL COMMENT '使用者狀態', `create_time` datetime NOT NULL,
`update_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ;

CREATE TABLE `tb_user2` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(45) NOT NULL,
`password` varchar(96) NOT NULL,
`name` varchar(45) NOT NULL,
`birthday` datetime DEFAULT NULL,
`sex` char(1) DEFAULT NULL,
`email` varchar(45) DEFAULT NULL,
`phone` varchar(45) DEFAULT NULL,
`qq` varchar(32) DEFAULT NULL,
`status` varchar(32) NOT NULL COMMENT '使用者狀態', `create_time` datetime NOT NULL,
`update_time` datetime DEFAULT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `unique_user_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ;

當使用load命令匯入資料的時候，適當的設定可以提高查詢效率

對於innoDB型別的表，有以下幾種方式可以提高匯入的效率：

1）主鍵順序插入

因為InnoDB型別的表是按照主鍵的順序儲存的，所以將匯入的資料按照主鍵的順序排列，可以有效的提高匯入資料的效率。如果InnoDB表沒有主鍵，那麼系統會自動預設建立一個內部列作為主鍵，所以如果可以給表建立一個
主鍵，將可以利用這點，來提高匯入資料的效率。

指令碼檔案介紹 :
sql1.log ----> 主鍵有序
sql2.log ----> 主鍵無序

插入ID順序排列的資料：

-- 主鍵有序插入資料
mysql> LOAD DATA LOCAL INFILE '/Users/mac/Documents/sql1.log' INTO TABLE tb_user1 FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n';
Query OK, 1000000 rows affected, 65535 warnings (17.03 sec)

-- 主鍵無序插入資料
mysql> LOAD DATA LOCAL INFILE '/Users/mac/Documents/sql2.log' INTO TABLE tb_user2 FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n';
Query OK, 1000000 rows affected, 65535 warnings (43.92 sec)

2）關閉唯一性校驗

在匯入資料前執行 SET UNIQUE_CHECKS=0，關閉唯一性校驗，在匯入結束後執行SET UNIQUE_CHECKS=1，恢復唯一性校驗。（關閉唯一性校驗，可以提高匯入的效率）

mysql> SET UNIQUE_CHECKS=0;

mysql> LOAD DATA LOCAL INFILE '/Users/mac/Documents/sql1.log' INTO TABLE tb_user1 FIELDS TERMINATED BY ',' LINES TERMINATED BY '\n';
Query OK, 1000000 rows affected, 65535 warnings (17.03 sec)

mysql> SET UNIQUE_CHECKS=1;

3）手動提交事物

如果應用使用自動提交的方式，建議在匯入前執行SET AUTOCOMMIT=0，關閉自動提交，匯入結束後在執行 SET AUTOCOMMIT=1，開啟自動提交。（手動提交事務，可以提高匯入效率）

10.2 優化insert語句

當進行資料的insert操作的時候，可以考慮採用以下幾種優化方案。

往一張表插入多行資料

示例，原始方式

insert into tb_test values(1,'Tom'); 
insert into tb_test values(2,'Cat'); 
insert into tb_test values(3,'Jerry');

優化方案：

insert into tb_test values(1,'Tom'),(2,'Cat')，(3,'Jerry');

在事務中進行資料插入

start transaction;
insert into tb_test values(1,'Tom'); 
insert into tb_test values(2,'Cat'); 
insert into tb_test values(3,'Jerry'); 
commit;

資料有序插入

insert into tb_test values(4,'Tim');
insert into tb_test values(1,'Tom'); 
insert into tb_test values(3,'Jerry'); 
insert into tb_test values(5,'Rose'); 
insert into tb_test values(2,'Cat');

優化方案：

insert into tb_test values(1,'Tom'); 
insert into tb_test values(2,'Cat'); 
insert into tb_test values(3,'Jerry'); 
insert into tb_test values(4,'Tim');
insert into tb_test values(5,'Rose');

10.3 優化order by語句

10.3.1 環境準備

CREATE TABLE `emp` (
`id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(100) NOT NULL,
`age` int(3) NOT NULL,
`salary` int(11) DEFAULT NULL, 
  PRIMARY KEY (`id`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8mb4;
insert into `emp` (`id`, `name`, `age`, `salary`) values('1','Tom','25','2300');
insert into `emp` (`id`, `name`, `age`, `salary`) values('2','Jerry','30','3500');
insert into `emp` (`id`, `name`, `age`, `salary`) values('3','Luci','25','2800');
insert into `emp` (`id`, `name`, `age`, `salary`) values('4','Jay','36','3500');
insert into `emp` (`id`, `name`, `age`, `salary`) values('5','Tom2','21','2200');
insert into `emp` (`id`, `name`, `age`, `salary`) values('6','Jerry2','31','3300');
insert into `emp` (`id`, `name`, `age`, `salary`) values('7','Luci2','26','2700');
insert into `emp` (`id`, `name`, `age`, `salary`) values('8','Jay2','33','3500');
insert into `emp` (`id`, `name`, `age`, `salary`) values('9','Tom3','23','2400');
insert into `emp` (`id`, `name`, `age`, `salary`)
values('10','Jerry3','32','3100');
insert into `emp` (`id`, `name`, `age`, `salary`) values('11','Luci3','26','2900');
insert into `emp` (`id`, `name`, `age`, `salary`) values('12','Jay3','37','4500');
create index idx_emp_age_salary on emp(age,salary);

10.3.2 倆種排序方式

1）通過對返回資料進行排序，也就是通常說的filesort排序，所有不是通過索引直接返回排序結果的排序都叫 FileSort排序

mysql> explain select * from emp order by age asc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using filesort

mysql> explain select * from emp order by age desc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using filesort

2）通過有序索引順序掃描直接返回有序資料，這種情況即為using index，不需要額外排序，操作效率高。

mysql> explain select id,age from emp order by age desc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: index
possible_keys: NULL
          key: idx_emp_age_salary
      key_len: 9
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using index
        
mysql> explain select id,age,name from emp order by age desc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using filesort

多欄位排序

mysql> explain select id,age from emp order by age desc,salary desc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: index
possible_keys: NULL
          key: idx_emp_age_salary
      key_len: 9
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using index

mysql> explain select id,age from emp order by age asc,salary desc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: index
possible_keys: NULL
          key: idx_emp_age_salary
      key_len: 9
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using index; Using filesort
1 row in set, 1 warning (0.00 sec)

mysql> explain select id,age from emp order by salary asc,age asc\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: index
possible_keys: NULL
          key: idx_emp_age_salary
      key_len: 9
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using index; Using filesort

排序優化：

儘量減少額外的排序，通過索引直接返回有序資料
where條件和order by使用相同的索引
order by 順序與索引順序相同
order by的欄位都是升序或者都是降序

10.3.3 Filesort的優化

通過建立合適的索引，能夠減少 Filesort 的出現，但是在某些情況下，條件限制不能讓Filesort消失，那就需要加

快 Filesort的排序操作。對於Filesort ， MySQL 有兩種排序演算法:

兩次掃描演算法 :MySQL4.1 之前，使用該方式排序。首先根據條件取出排序欄位和行指標資訊，然後在排序區 sort buffer 中排序，如果sort buffer不夠，則在臨時表 temporary table 中儲存排序結果。完成排序之後，再根據行指標回表讀取記錄，該操作可能會導致大量隨機I/O操作。

2)一次掃描演算法:一次性取出滿足條件的所有欄位，然後在排序區 sort buffer 中排序後直接輸出結果集。排序時記憶體開銷較大，但是排序效率比兩次掃描演算法要高。

MySQL 通過比較系統變數 max_length_for_sort_data 的大小和Query語句取出的欄位總大小，來判定是否那種排
序演算法，如果max_length_for_sort_data 更大，那麼使用第二種優化之後的演算法;否則使用
第一種。
可以適當提高 sort_buffer_size 和 max_length_for_sort_data 系統變數，來增大排序區的大小，提高排序的效率。

show variables like 'max_length_for_sort_data';
show variables like 'sort_buffer_size';

10.4 優化 group by語句

由於GROUP BY 實際上也同樣會進行排序操作，而且與ORDER BY 相比，GROUP BY 主要只是多了排序之後的分組操作。當然，如果在分組的時候還使用了其他的一些聚合函式，那麼還需要一些聚合函式的計算。所以，在GROUP BY 的實現過程中，與 ORDER BY 一樣也可以利用到索引。

如果查詢包含 group by 但是使用者想要避免排序結果的消耗，則可以執行order by null 禁止排序。如下 :

mysql> drop index idx_emp_age_salary on emp;
mysql> explain select age,count(*) from emp group by age\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using temporary; Using filesort

優化案例

mysql> explain select age,count(*) from emp group by age order by null\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using temporary

從上面的例子可以看出，第一個SQL語句需要進行"filesort"，而第二個SQL由於order by null 不需要進行"filesort"，而上文提過Filesort往往非常耗費時間。

繼續優化（建立索引）

create index idx_emp_age_salary on emp(age,salary);
mysql> explain select age,count(*) from emp group by age order by null\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: index
possible_keys: idx_emp_age_salary
          key: idx_emp_age_salary
      key_len: 9
          ref: NULL
         rows: 12
     filtered: 100.00
        Extra: Using index

10.5 優化巢狀查詢

Mysql4.1版本之後，開始支援SQL的子查詢。這個技術可以使用SELECT語句來建立一個單列的查詢結果，然後把這個結果作為過濾條件用在另一個查詢中。使用子查詢可以一次性的完成很多邏輯上需要多個步驟才能完成的SQL操作，同時也可以避免事務或者表鎖死，並且寫起來也很容易。但是，有些情況下，子查詢是可以被更高效的連線(JOIN)替代。

示例：查詢角色的所有使用者資訊：

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-5j2ImI8P-1606377489306)(/Users/mac/Documents/mysql筆記/優化巢狀查詢1.png)]

優化後：

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-0uDoxKPt-1606377489309)(/Users/mac/Documents/mysql筆記/優化巢狀查詢2.png)]

連線查詢（join）查詢效率更高的原因是：mysql不需要在記憶體中建立臨時表來完成這個邏輯上需要倆步的操作

10.6 優化OR條件

對於包含OR的查詢子句，如果要利用索引，則OR之間的每個條件列都必須用到索引，而且不能使用到複合索
引; 如果沒有索引，則應該考慮增加索引。

-- type為index_merge
mysql> explain select * from emp where id = 1 or age = 30\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: index_merge
possible_keys: PRIMARY,idx_emp_age_salary
          key: idx_emp_age_salary,PRIMARY
      key_len: 4,4
          ref: NULL
         rows: 2
     filtered: 100.00
        Extra: Using sort_union(idx_emp_age_salary,PRIMARY); Using where
1 row in set, 1 warning (0.00 sec)

ERROR: 
No query specified

-- type為range
mysql> explain select * from emp where id = 1 or id = 10\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: emp
   partitions: NULL
         type: range
possible_keys: PRIMARY
          key: PRIMARY
      key_len: 4
          ref: NULL
         rows: 2
     filtered: 100.00
        Extra: Using where

建議使用 union 替換 or :

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-gA7mGdA9-1606377489312)(/Users/mac/Documents/mysql筆記/優化OR條件2.png)]

我們來比較下重要指標，發現主要差別是 type 和 ref 這兩項
type 顯示的是訪問型別，是較為重要的一個指標，結果值從好到壞依次是:

system > const > eq_ref > ref > fulltext > ref_or_null > index_merge > unique_subquery > index_subquery > range > index > ALL

UNION 語句的 type 值為 ref，OR 語句的 type 值為 range，可以看到這是一個很明顯的差距
UNION 語句的 ref 值為 const，OR 語句的 type 值為 null，const 表示是常量值引用，非常快
這兩項的差距就說明了 UNION 要優於 OR 。

10.7 優化分頁查詢

一般分頁查詢時，通過建立覆蓋索引能夠比較好地提高效能。一個常見又非常頭疼的問題就是 limit 900000,10 ，此時需要MySQL排序前900010 記錄，僅僅返回900000 - 900010 的記錄，其他記錄丟棄，查詢排序的代價非常大。

mysql> explain select * from tb_user1 limit 500000,10\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_user1
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 991881
     filtered: 100.00
        Extra: NULL

10.7.1 優化思路一

在索引上完成排序分頁操作，最後根據主鍵關聯回原表查詢所需要的其他列內容。

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-GH3qwymc-1606377489315)(/Users/mac/Documents/mysql筆記/優化limit分頁1.png)]

10.7.2 優化思路二

該方案適用於主鍵自增的表，可以把Limit 查詢轉換成某個位置的查詢。

若ID出現斷層，此方案無效

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片儲存下來直接上傳(img-OVPgORae-1606377489318)(/Users/mac/Documents/mysql筆記/優化limit分頁2.png)]

10.8 使用SQL提示

SQL提示，是優化資料庫的一個重要手段，簡單來說，就是在SQL語句中加入一些人為的提示來達到優化操作的目

的。

10.8.1 USE INDEX

在查詢語句表名的後面，新增use index 來提供希望mysql去參考的索引列表，就可以讓mysql不在考慮其他的索引。

mysql> create index tb_seller_name_sta_addr on tb_seller(name,status,address);
-- mysql引擎預設選擇的索引：idx_seller_name
mysql> mysql> explain select * from tb_seller where name='小米科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name,tb_seller_name_sta_addr
          key: idx_seller_name
      key_len: 403
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL

-- 希望mysql去參考的索引：tb_seller_name_sta_addr
mysql> explain select * from tb_seller use index(tb_seller_name_sta_addr) where name='小米科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: tb_seller_name_sta_addr
          key: tb_seller_name_sta_addr
      key_len: 403
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL

10.8.2 IGNORE INDEX

如果使用者只是單純的想讓MySQL忽略一個或者多個索引，則可以使用 ignore index

-- 忽略tb_seller_name_sta_addr索引
mysql> explain select * from tb_seller ignore index(tb_seller_name_sta_addr) where name='小米科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_name
          key: idx_seller_name
      key_len: 403
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL
-- 忽略idx_seller_name索引
mysql> explain select * from tb_seller ignore index(idx_seller_name) where name='小米科技'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: tb_seller_name_sta_addr
          key: tb_seller_name_sta_addr
      key_len: 403
          ref: const
         rows: 1
     filtered: 100.00
        Extra: NULL

10.8.3 FORCE INDEX

為強制MySQL使用一個特定的索引，可在查詢中使用 force index。

上文提到當where後面的檢索欄位的在表中的資料大部分與條件一樣時，則索引不生效，轉為全表掃描

即：在資料庫中address欄位的值，大部分為’北京市’時，則資料庫引擎會選擇全表掃描

-- 資料庫引擎選擇全表掃描，索引不生效（use index提供的參考，資料庫不採納）
mysql> explain select * from tb_seller use index(idx_seller_address) where address='北京市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 12
     filtered: 10.00
        Extra: Using where

mysql> explain select * from tb_seller force index(idx_seller_address) where address='北京市'\G;
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: tb_seller
   partitions: NULL
         type: ref
possible_keys: idx_seller_address
          key: idx_seller_address
      key_len: 403
          ref: const
         rows: 11
     filtered: 100.00
        Extra: NULL