步步深刻MySQL:架構->查詢執行流程->SQL解析順序

1、前言mysql

一直是想知道一條SQL語句是怎麼被執行的,它執行的順序是怎樣的,而後查看總結各方資料,就有了下面這一篇博文了。sql

本文將從MySQL整體架構--->查詢執行流程--->語句執行順序來探討一下其中的知識。數據庫

2、MySQL架構總覽緩存

架構最好看圖,再配上必要的說明文字。性能優化

下圖根據參考書籍中一圖爲本來,再在其上添加上了本身的理解。架構

 

 

 

從上圖中咱們能夠看到,整個架構分爲兩層,上層是MySQLD的被稱爲的‘SQL Layer’,下層是各類各樣對上提供接口的存儲引擎,被稱爲‘Storage Engine Layer’。其它各個模塊和組件,從名字上就能夠簡單瞭解到它們的做用,這裏就再也不累述了。併發

3、查詢執行流程分佈式

下面再向前走一些,容我根據本身的認識說一下查詢執行的流程是怎樣的:函數

一、鏈接微服務

1.一、客戶端發起一條Query請求,監聽客戶端的‘鏈接管理模塊’接收請求;

1.二、將請求轉發到‘鏈接進/線程模塊’;

1.三、調用‘用戶模塊’來進行受權檢查;

1.4經過檢查後,‘鏈接進/線程模塊’從‘線程鏈接池’中取出空閒的被緩存的鏈接線程和客戶端請求對接,若是失敗則建立一個新的鏈接請求;

二、處理

2.一、先查詢緩存,檢查Query語句是否徹底匹配,接着再檢查是否具備權限,都成功則直接取數據返回;

2.二、上一步有失敗則轉交給‘命令解析器’,通過詞法分析,語法分析後生成解析樹;

2.三、接下來是預處理階段,處理解析器沒法解決的語義,檢查權限等,生成新的解析樹;

2.四、再轉交給對應的模塊處理;

2.五、若是是SELECT查詢還會經由‘查詢優化器’作大量的優化,生成執行計劃;

2.六、模塊收到請求後,經過‘訪問控制模塊’檢查所鏈接的用戶是否有訪問目標表和目標字段的權限;

2.七、有則調用‘表管理模塊’,先是查看table cache中是否存在,有則直接對應的表和獲取鎖,不然從新打開表文件;

2.八、根據表的meta數據,獲取表的存儲引擎類型等信息,經過接口調用對應的存儲引擎處理;

2.九、上述過程當中產生數據變化的時候,若打開日誌功能,則會記錄到相應二進制日誌文件中;

三、結果

3.一、Query請求完成後,將結果集返回給‘鏈接進/線程模塊’;

3.二、返回的也能夠是相應的狀態標識,如成功或失敗等;

3.三、‘鏈接進/線程模塊’進行後續的清理工做,並繼續等待請求或斷開與客戶端的鏈接;

四、一圖小總結

 

4、SQL解析順序

接下來再走一步,讓咱們看看一條SQL語句的前世此生。

首先看一下示例語句:

 
SELECT DISTINCT < select_list > FROM < left_table > < join_type > JOIN < right_table > ON < join_condition > WHERE < where_condition > GROUP BY < group_by_list > HAVING < having_condition > ORDER BY < order_by_condition > LIMIT < limit_number >

然而它的執行順序是這樣的:

 

雖然本身沒想到是這樣的,不過一看仍是很天然和諧的,從哪裏獲取,不斷的過濾條件,要選擇同樣或不同的,排好序,那才知道要取前幾條呢。

既然如此了,那就讓咱們一步步來看看其中的細節吧。

一、準備工做

1.一、建立測試數據庫

 
create database testQuery

1.二、建立測試表

 
CREATE TABLE table1 ( uid VARCHAR(10) NOT NULL, name VARCHAR(10) NOT NULL, PRIMARY KEY(uid) )ENGINE=INNODB DEFAULT CHARSET=UTF8; CREATE TABLE table2 ( oid INT NOT NULL auto_increment, uid VARCHAR(10), PRIMARY KEY(oid) )ENGINE=INNODB DEFAULT CHARSET=UTF8;

1.三、插入數據

 
INSERT INTO table1(uid,name) VALUES('aaa','mike'),('bbb','jack'),('ccc','mike'),('ddd','mike'); INSERT INTO table2(uid) VALUES('aaa'),('aaa'),('bbb'),('bbb'),('bbb'),('ccc'),(NULL);

1.四、最後想要的結果

 
SELECT a.uid, count(b.oid) AS total FROM table1 AS a LEFT JOIN table2 AS b ON a.uid = b.uid WHERE a. NAME = 'mike' GROUP BY a.uid HAVING count(b.oid) < 2 ORDER BY total DESC LIMIT 1;

如今開始SQL解析之旅吧!

二、FROM

當涉及多個表的時候,左邊表的輸出會做爲右邊表的輸入,以後會生成一個虛擬表VT1。

2.一、(1-J1)笛卡爾積

計算兩個相關聯表的笛卡爾積(CROSS JOIN) ,生成虛擬表VT1-J1。

 
mysql> select * from table1,table2; +-----+------+-----+------+ | uid | name | oid | uid | +-----+------+-----+------+ | aaa | mike | 1 | aaa | | bbb | jack | 1 | aaa | | ccc | mike | 1 | aaa | | ddd | mike | 1 | aaa | | aaa | mike | 2 | aaa | | bbb | jack | 2 | aaa | | ccc | mike | 2 | aaa | | ddd | mike | 2 | aaa | | aaa | mike | 3 | bbb | | bbb | jack | 3 | bbb | | ccc | mike | 3 | bbb | | ddd | mike | 3 | bbb | | aaa | mike | 4 | bbb | | bbb | jack | 4 | bbb | | ccc | mike | 4 | bbb | | ddd | mike | 4 | bbb | | aaa | mike | 5 | bbb | | bbb | jack | 5 | bbb | | ccc | mike | 5 | bbb | | ddd | mike | 5 | bbb | | aaa | mike | 6 | ccc | | bbb | jack | 6 | ccc | | ccc | mike | 6 | ccc | | ddd | mike | 6 | ccc | | aaa | mike | 7 | NULL | | bbb | jack | 7 | NULL | | ccc | mike | 7 | NULL | | ddd | mike | 7 | NULL | +-----+------+-----+------+ 28 rows in set (0.00 sec)

2.二、(1-J2)ON過濾

基於虛擬表VT1-J1這一個虛擬表進行過濾,過濾出全部知足ON 謂詞條件的列,生成虛擬表VT1-J2。

注意:這裏由於語法限制,使用了'WHERE'代替,從中讀者也能夠感覺到二者之間微妙的關係;

 
mysql> SELECT -> * -> FROM -> table1, -> table2 -> WHERE -> table1.uid = table2.uid -> ; +-----+------+-----+------+ | uid | name | oid | uid | +-----+------+-----+------+ | aaa | mike | 1 | aaa | | aaa | mike | 2 | aaa | | bbb | jack | 3 | bbb | | bbb | jack | 4 | bbb | | bbb | jack | 5 | bbb | | ccc | mike | 6 | ccc | +-----+------+-----+------+ 6 rows in set (0.00 sec)

2.三、(1-J3)添加外部列

若是使用了外鏈接(LEFT,RIGHT,FULL),主表(保留表)中的不符合ON條件的列也會被加入到VT1-J2中,做爲外部行,生成虛擬表VT1-J3。

 
mysql> SELECT -> * -> FROM -> table1 AS a -> LEFT OUTER JOIN table2 AS b ON a.uid = b.uid; +-----+------+------+------+ | uid | name | oid | uid | +-----+------+------+------+ | aaa | mike | 1 | aaa | | aaa | mike | 2 | aaa | | bbb | jack | 3 | bbb | | bbb | jack | 4 | bbb | | bbb | jack | 5 | bbb | | ccc | mike | 6 | ccc | | ddd | mike | NULL | NULL | +-----+------+------+------+ 7 rows in set (0.00 sec)

下面從網上找到一張很形象的關於‘SQL JOINS'的解釋圖,如若侵犯了你的權益,請勞煩告知刪除,謝謝。

 

二、WHERE

對VT1過程當中生成的臨時表進行過濾,知足WHERE子句的列被插入到VT2表中。

注意:

此時由於分組,不能使用聚合運算;也不能使用SELECT中建立的別名;

與ON的區別:

若是有外部列,ON針對過濾的是關聯表,主表(保留表)會返回全部的列;

若是沒有添加外部列,二者的效果是同樣的;

應用:

對主表的過濾應該放在WHERE;

對於關聯表,先條件查詢後鏈接則用ON,先鏈接後條件查詢則用WHERE;

 
mysql> SELECT -> * -> FROM -> table1 AS a -> LEFT OUTER JOIN table2 AS b ON a.uid = b.uid -> WHERE -> a. NAME = 'mike'; +-----+------+------+------+ | uid | name | oid | uid | +-----+------+------+------+ | aaa | mike | 1 | aaa | | aaa | mike | 2 | aaa | | ccc | mike | 6 | ccc | | ddd | mike | NULL | NULL | +-----+------+------+------+ 4 rows in set (0.00 sec)

三、GROUP BY

這個子句會把VT2中生成的表按照GROUP BY中的列進行分組。生成VT3表。

注意:

其後處理過程的語句,如SELECT,HAVING,所用到的列必須包含在GROUP BY中,對於沒有出現的,得用聚合函數;

緣由:

GROUP BY改變了對錶的引用,將其轉換爲新的引用方式,可以對其進行下一級邏輯操做的列會減小;

個人理解是:

根據分組字段,將具備相同分組字段的記錄歸併成一條記錄,由於每個分組只能返回一條記錄,除非是被過濾掉了,而不在分組字段裏面的字段可能會有多個值,多個值是沒法放進一條記錄的,因此必須經過聚合函數將這些具備多值的列轉換成單值;

 
mysql> SELECT -> * -> FROM -> table1 AS a -> LEFT OUTER JOIN table2 AS b ON a.uid = b.uid -> WHERE -> a. NAME = 'mike' -> GROUP BY -> a.uid; +-----+------+------+------+ | uid | name | oid | uid | +-----+------+------+------+ | aaa | mike | 1 | aaa | | ccc | mike | 6 | ccc | | ddd | mike | NULL | NULL | +-----+------+------+------+ 3 rows in set (0.00 sec)

四、HAVING

這個子句對VT3表中的不一樣的組進行過濾,只做用於分組後的數據,知足HAVING條件的子句被加入到VT4表中。

 
mysql> SELECT -> * -> FROM -> table1 AS a -> LEFT OUTER JOIN table2 AS b ON a.uid = b.uid -> WHERE -> a. NAME = 'mike' -> GROUP BY -> a.uid -> HAVING -> count(b.oid) < 2; +-----+------+------+------+ | uid | name | oid | uid | +-----+------+------+------+ | ccc | mike | 6 | ccc | | ddd | mike | NULL | NULL | +-----+------+------+------+ 2 rows in set (0.00 sec)

五、SELECT

這個子句對SELECT子句中的元素進行處理,生成VT5表。

(5-J1)計算表達式 計算SELECT 子句中的表達式,生成VT5-J1

(5-J2)DISTINCT

尋找VT5-1中的重複列,並刪掉,生成VT5-J2

若是在查詢中指定了DISTINCT子句,則會建立一張內存臨時表(若是內存放不下,就須要存放在硬盤了)。這張臨時表的表結構和上一步產生的虛擬表VT5是同樣的,不一樣的是對進行DISTINCT操做的列增長了一個惟一索引,以此來除重複數據。

 
mysql> SELECT   -> a.uid,   -> count(b.oid) AS total   -> FROM   -> table1 AS a   -> LEFT OUTER JOIN table2 AS b ON a.uid = b.uid   -> WHERE   -> a. NAME = 'mike'   -> GROUP BY   -> a.uid   -> HAVING   -> count(b.oid) < 2;  +-----+-------+ | uid | total | +-----+-------+ | ccc | 1 | | ddd | 0 | +-----+-------+ 2 rows in set (0.00 sec)

六、ORDER BY

從VT5-J2中的表中,根據ORDER BY 子句的條件對結果進行排序,生成VT6表。

注意:

惟一可以使用SELECT中別名的地方;

 
mysql> SELECT   -> a.uid,   -> count(b.oid) AS total   -> FROM   -> table1 AS a   -> LEFT OUTER JOIN table2 AS b ON a.uid = b.uid   -> WHERE   -> a. NAME = 'mike'   -> GROUP BY   -> a.uid   -> HAVING   -> count(b.oid) < 2   -> ORDER BY   -> total DESC;  +-----+-------+ | uid | total | +-----+-------+ | ccc | 1 | | ddd | 0 | +-----+-------+ 2 rows in set (0.00 sec)

七、LIMIT

LIMIT子句從上一步獲得的VT6虛擬表中選出從指定位置開始的指定行數據。

注意:

offset和rows的正負帶來的影響;

當偏移量很大時效率是很低的,能夠這麼作:

採用子查詢的方式優化,在子查詢裏先從索引獲取到最大id,而後倒序排,再取N行結果集

採用INNER JOIN優化,JOIN子句裏也優先從索引獲取ID列表,而後直接關聯查詢得到最終結果

 
mysql> SELECT   -> a.uid,   -> count(b.oid) AS total   -> FROM   -> table1 AS a   -> LEFT JOIN table2 AS b ON a.uid = b.uid   -> WHERE   -> a. NAME = 'mike'   -> GROUP BY   -> a.uid   -> HAVING   -> count(b.oid) < 2   -> ORDER BY   -> total DESC   -> LIMIT 1;  +-----+-------+ | uid | total | +-----+-------+ | ccc | 1 | +-----+-------+ 1 row in set (0.00 sec)

至此SQL的解析之旅就結束了,上圖總結一下:

順便在此給你們推薦一個Java架構方面的交流學習羣:698581634,裏面會分享一些資深架構師錄製的視頻錄像:有Spring,MyBatis,Netty源碼分析,高併發、高性能、分佈式、微服務架構的原理,JVM性能優化這些成爲架構師必備的知識體系,主要針對Java開發人員提高本身,突破瓶頸,相信你來學習,會有提高和收穫。在這個羣裏會有你須要的內容  朋友們請抓緊時間加入進來吧。

相關文章
相關標籤/搜索