2. 程式人生 > >MySql 筆記 | MySQL架構總覽->查詢執行流程->SQL解析順序

MySql 筆記 | MySQL架構總覽->查詢執行流程->SQL解析順序

阿新 • • 發佈：2018-12-11

前言：一直是想知道一條SQL語句是怎麼被執行的，它執行的順序是怎樣的，然後檢視總結各方資料，就有了下面這一篇博文了。本文將從MySQL總體架構—>查詢執行流程—>語句執行順序來探討一下其中的知識。

一、MySQL架構總覽

架構最好看圖，再配上必要的說明文字。

下圖根據參考書籍中一圖為原本，再在其上新增上了自己的理解。 在這裡插入圖片描述

從上圖中我們可以看到，整個架構分為兩層：

  • 上層是MySQLD，被稱為“SQL Layer”；
  • 下層是各種各樣對上層提供介面的儲存引擎，被稱為“Storage Engine Layer”。

其它各個模組和元件，從名字上就可以簡單瞭解到它們的作用，這裡就不再累述了。

二、查詢執行流程

下面再向前走一些，容我根據自己的認識說一下查詢執行的流程是怎樣的：

  1. 連線

    1. 客戶端發起一條Query請求，監聽客戶端的“連線管理模組”接收請求；
    2. 將請求轉發到‘連線進/執行緒模組’；
    3. 呼叫“使用者模組”來進行授權檢查；
    4. 通過檢查後，‘連線進/執行緒模組’從‘執行緒連線池’中取出空閒的被快取的連線執行緒和客戶端請求對接，如果失敗則建立一個新的連線請求。

  2. 處理

    1. 先查詢快取，檢查Query語句是否完全匹配，接著再檢查是否具有許可權，都成功則直接取資料返回；
    2. 上一步有失敗則轉交給“命令解析器”，經過詞法分析，語法分析後生成解析樹；
    3. 接下來是預處理階段，處理解析器無法解決的語義，檢查許可權等，生成新的解析樹；
    4. 再轉交給對應的模組處理；
    5. 如果是SELECT查詢還會經由‘查詢優化器’做大量的優化，生成執行計劃；
    6. 模組收到請求後，通過“訪問控制模組”檢查所連線的使用者是否有訪問目標表和目標欄位的許可權；
    7. 有則呼叫“表管理模組”，先是檢視table cache中是否存在，有則直接對應的表和獲取鎖，否則重新開啟表文件；
    8. 根據表的meta資料，獲取表的儲存引擎型別等資訊，通過介面呼叫對應的儲存引擎處理；
    9. 上述過程中產生資料變化的時候，若開啟日誌功能，則會記錄到相應二進位制日誌檔案中。

  3. 結果

    1. Query請求完成後，將結果集返回給“連線進/執行緒模組”；
    2. 返回的也可以是相應的狀態標識，如成功或失敗等；
    3. “連線進/執行緒模組”進行後續的清理工作，並繼續等待請求或斷開與客戶端的連線。

一圖小總結： 在這裡插入圖片描述

三、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>

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

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

雖然自己沒想到是這樣的，不過一看還是很自然和諧的，從哪裡獲取，不斷的過濾條件，要選擇一樣或不一樣的，排好序，那才知道要取前幾條呢。

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

1、準備工作
1.1 建立測試資料庫
create database testQuery
1.2 建立測試表
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.3 插入資料
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.4 最後想要的結果
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解析之旅吧！

2、開始SQL解析
2.1 FROM

當涉及多個表的時候，左邊表的輸出會作為右邊表的輸入，之後會生成一個虛擬表 VT1。

  • (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)
  • (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)
  • (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’的解釋圖，如若侵犯了你的權益，請勞煩告知刪除，謝謝。 在這裡插入圖片描述

2.2 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)
2.3 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)
2.4 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)
2.5 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)
2.6 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)
2.7 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的解析之旅就結束了，上圖總結一下： 在這裡插入圖片描述

參考書籍：

  • 《MySQL效能調優與架構實踐》
  • 《MySQL技術內幕：SQL程式設計》

文章來源：如需轉載，請保留AnnsShadoW和本文地址http://www.cnblogs.com/annsshadow/p/5037667.html

相關推薦

MySql 筆記 | MySQL架構總覽->查詢執行流程->SQL解析順序

前言：一直是想知道一條SQL語句是怎麼被執行的，它執行的順序是怎樣的，然後檢視總結各方資料，就有了下面這一篇博文了。本文將從MySQL總體架構—>查詢執行流程—>語句執行順序來探討一下其中的知識。 一、MySQL架構總覽 架構最好看圖，再配上

步步深入MySQL：架構->查詢執行流程->SQL解析順序！

一、前言 一直是想知道一條SQL語句是怎麼被執行的，它執行的順序是怎樣的，然後檢視總結各方資料，就有了下面這一篇博文了。 本文將從MySQL總體架構--->查詢執行流程--->語句執行順序來探討一下其中的知識。 二、MySQL架構總覽 架構最好看圖，再

步步深入MySQL：架構->查詢執行流程->SQL解析順序！

效率 線程 sele 重新 3.2 image 最好 詞條 mysqld 一、前言 本文將從MySQL總體架構--->查詢執行流程--->語句執行順序來探討一下其中的知識。 二、MySQL架構總覽 架構最好看圖，再配上必要的說明文字。 下圖根據參考書籍中一圖為原

SQL優化理論基礎：MySQL架構總覽、查詢執行流程、SQL解析順序（轉載）

前言： 　　一直是想知道一條SQL語句是怎麼被執行的，它執行的順序是怎樣的，然後檢視總結各方資料，就有了下面這一篇博文了。 　　本文將從MySQL總體架構--->

MySQL筆記：數據查詢

any isp left sts 是否為空 則表達式 默認 sed post 一、基本查詢語句 WHERE：按照指定的條件進行查詢，如果沒有WHERE默認查詢所有記錄。 GROUP BY：按照指定字段進行分組，若存在HAVING則只有滿足HAVING指定的條件才能輸出。

MySQL 筆記5 -- 多表查詢

MySQL 筆記5 – 多表查詢 MySQL 系列筆記是筆者學習、實踐MySQL資料庫的筆記 一、表之間關係 1、一對一 單獨的一張表 與其它表沒有關係 2、一對多 一條資訊和其它多條

《Java編程思想》筆記 第四章 控制執行流程

ascii cas div 當前 也不會 system 包括 進入 ont 1.true和false 1.1 if--else if--else, while, do--while 都使用條件表達式的真假來決定執行路徑。 1.2 Java不允許數字作為真假判斷，C和C++可

spark筆記2之spark粗略執行流程

目錄 一、Spark粗略的執行流程 二、程式碼流程 1、建立一個SparkConf 2、建立一個上下文物件SparkContext 3、建立一個RDD 4、使用transformations類運算元進行各種各樣的資料轉換 5、使用Action類運算元觸發執行 6、關閉

關於mybatis的查詢執行流程

mapper有一個名稱空間 像這樣 <select id="findUserByEntity" resultMap="UserResultMap" parameterType="com.ojama.business.entities.admin.User">

Spark學習筆記（10）—— wordcount 執行流程分析

1 啟動叢集 啟動 HDFS start-dfs.sh 啟動 Spark 叢集 /home/hadoop/apps/spark-1.6.3-bin-hadoop2.6/sbin/start-all

高效能MYSQL筆記-mysql欄位型別和欄位設計規範

1.優先使用符合業務需要的最小的資料型別1.1 將ip用UNSIGNED INT存：內建函式INET_ATON(字串)和INTE_NTOA(整數)分別是點分十進位制字串和整數的轉換函式1.2 非負數用無符號型別（比如前面ip值對應的數字一定為正，所以用的資料型別為無符號整形

MySQL筆記-mysql使用者管理

使用者建立（create user）、修改（alter user）、分配許可權（grant）、刪除（drop user）都屬於資料庫管理語句中的使用者管理語句（Database Administration Statements——>Account Managemen

mysql 正則匹配內容查詢、拼接sql語句

-- -- 廣告評論刪除 -- SELECT count(ID) FROM t_article_comment WHERE CONTENT REGEXP "[0-9]{8}" and CONTEN

Java程式設計思想第四版讀書筆記——第四章 控制執行流程

Java程式設計思想第四版第四章讀書筆記——控制執行流程。因為有些C++和android開發基礎，所以基礎知識筆記就不寫了，記些特別的需要注意的地方。 第四章 控制執行流程 1.true和false Java不允許我們將一個數字作為布林值使用，雖然這在C和C++裡是

#Thinking in Java閱讀筆記# 第四章 控制執行流程

迭代：while/do-while/for迴圈，在迭代語句的主體部分，可用break/continue控制迴圈的流程。 break：跳出迭代，且不執行餘下部分 continue：跳出當前迭代，執行下一次迴圈 無限迴圈：while(true)/for(;;)

四、MyBatis中查詢執行流程

開發十年，就只剩下這套架構體系了！ >>>   

宜信開源|分散式任務排程平臺SIA-TASK的架構設計與執行流程

  一、分散式任務排程的背景 無論是網際網路應用或者企業級應用，都充斥著大量的批處理任務。我們常常需要一些任務排程系統來幫助解決問題。隨著微服務化架構的逐步演進，單體架構逐漸演變為分散式、微服務架構。在此背景下，很多原先的任務排程平臺已經不能滿足業務系統的需求，於是出現了一些基於分散式的任務排程

java架構之路-（原始碼）mybatis執行流程原始碼解析

　　這次我們來說說Mybatis的原始碼，這裡只說執行的流程，內部細節太多了，這裡只能授之以漁了。還是最近的那段程式碼，我們來回顧一下。 package mybatis; import mybatis.bean.StudentBean; import mybatis.dao.StudentMapper;

知識儲備：SpringBoot啟動執行流程原理解析

SpringBoot專案通過SpringApplication.run()執行，分為兩步 首先new了一個SpringApplication，之後再呼叫run()方法 ，下面我們就看看這兩步 1.建立SpringApplication 通過debug進入到Sprin

Mybatis原始碼詳解之介面方法被執行流程原始碼解析

        與上一篇Mybatis原始碼解析的部落格已經隔了好長一段時間，最近發生了一些亂七八糟糟心的事情，甚至每天加班，沒來得及寫點什麼，最近一個月的學習是亂的一塌糊塗。         接著上一篇的分析，上一篇完成了所有配置檔案的解析，將各個配置檔案都解析到一個叫C