轉(zhuǎn)自：https://blog.csdn.net/freeking101/article/details/76522504
準(zhǔn)備工作
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>
繼續(xù)做以下的前期準(zhǔn)備工作：
1.新建一個(gè)測試數(shù)據(jù)庫TestDB；
create database TestDB;
2.創(chuàng)建測試表table1和table2；
CREATE TABLE table1
(
customer_id VARCHAR(10) NOT NULL,
city VARCHAR(10) NOT NULL,
PRIMARY KEY(customer_id)
)ENGINE=INNODB DEFAULT CHARSET=UTF8;
CREATE TABLE table2
(
order_id INT NOT NULL auto_increment,
customer_id VARCHAR(10),
PRIMARY KEY(order_id)
)ENGINE=INNODB DEFAULT CHARSET=UTF8;
3.插入測試數(shù)據(jù)；
INSERT INTO table1(customer_id,city) VALUES('163','hangzhou');
INSERT INTO table1(customer_id,city) VALUES('9you','shanghai');
INSERT INTO table1(customer_id,city) VALUES('tx','hangzhou');
INSERT INTO table1(customer_id,city) VALUES('baidu','hangzhou');
INSERT INTO table2(customer_id) VALUES('163');
INSERT INTO table2(customer_id) VALUES('163');
INSERT INTO table2(customer_id) VALUES('9you');
INSERT INTO table2(customer_id) VALUES('9you');
INSERT INTO table2(customer_id) VALUES('9you');
INSERT INTO table2(customer_id) VALUES('tx');
INSERT INTO table2(customer_id) VALUES(NULL);
準(zhǔn)備工作做完以后，table1和table2看起來應(yīng)該像下面這樣：
mysql> select * from table1;
+-------------+----------+
| customer_id | city |
+-------------+----------+
| 163 | hangzhou |
| 9you | shanghai |
| baidu | hangzhou |
| tx | hangzhou |
+-------------+----------+
4 rows in set (0.00 sec)
mysql> select * from table2;
+----------+-------------+
| order_id | customer_id |
+----------+-------------+
| 1 | 163 |
| 2 | 163 |
| 3 | 9you |
| 4 | 9you |
| 5 | 9you |
| 6 | tx |
| 7 | NULL |
+----------+-------------+
7 rows in set (0.00 sec)
4.準(zhǔn)備SQL邏輯查詢測試語句
SELECT a.customer_id, COUNT(b.order_id) as total_orders
FROM table1 AS a
LEFT JOIN table2 AS b
ON a.customer_id = b.customer_id
WHERE a.city = 'hangzhou'
GROUP BY a.customer_id
HAVING count(b.order_id) < 2
ORDER BY total_orders DESC;
使用上述SQL查詢語句來獲得來自杭州，并且訂單數(shù)少于2的客戶。
SQL邏輯查詢語句執(zhí)行順序
那么，到底哪個(gè)先執(zhí)行，哪個(gè)后執(zhí)行呢？現(xiàn)在，先給出一個(gè)查詢語句的執(zhí)行順序：
(7) SELECT /* 處理SELECT列表，產(chǎn)生 VT7 */
(8) DISTINCT <select_list> /* 將重復(fù)的行從 VT7 中刪除，產(chǎn)品 VT8 */
(1) FROM <left_table> /* 對FROM子句中的表執(zhí)行笛卡爾積(交叉聯(lián)接)，生成虛擬表 VT1。*/
(3) <join_type> JOIN <right_table> /* 如果指定了OUTER JOIN(相對于CROSS JOIN或INNER JOIN)，
保留表中未找到匹配的行將作為外部行添加到 VT2，生成 VT3。
如果FROM子句包含兩個(gè)以上的表，則對上一個(gè)聯(lián)接生成的結(jié)果表和下一個(gè)表重復(fù)執(zhí)行步驟1到步驟3，直到處理完所有的表位置。*/
(2) ON <join_condition> /* 對 VT1 應(yīng)用 ON 篩選器，只有那些使條件為真的行才被插入到 VT2。*/
(4) WHERE <where_condition> /* 對 VT3 應(yīng)用 WHERE 篩選器，只有使條件為真的行才插入VT4。*/
(5) GROUP BY <group_by_list> /* 按 GROUP BY子句中的列列表對 VT4 中的行進(jìn)行分組，生成 VT5。*/
(6) HAVING <having_condition> /* 對 VT5 應(yīng)用 HAVING 篩選器，只有使為true的組插入到 VT6 。*/
(9) ORDER BY <order_by_condition> /* 將 VT8 中的行按 ORDER BY子句中的列列表順序，生成一個(gè)游標(biāo)(VC9)。*/
(10) LIMIT <limit_number> /*生成表VT10，并返回給調(diào)用者。*/
Oracle SQL語句執(zhí)行順序
(8)SELECT (9)DISTINCT (11)<Top Num> <select list>
(1)FROM [left_table]
(3)<join_type> JOIN <right_table>
(2)ON <join_condition>
(4)WHERE <where_condition>
(5)GROUP BY <group_by_list>
(6)WITH <CUBE | RollUP>
(7)HAVING <having_condition>
(10)ORDER BY <order_by_list>
以上每個(gè)步驟都會產(chǎn)生一個(gè)虛擬表，該虛擬表被用作下一個(gè)步驟的輸入。這些虛擬表對調(diào)用者(客戶端應(yīng)用程序或者外部查詢)不可用。只有最后一步生成的表才會會給調(diào)用者。如果沒有在查詢中指定某一個(gè)子句，將跳過相應(yīng)的步驟。
邏輯查詢處理階段簡介
FROM：對FROM子句中的前兩個(gè)表執(zhí)行笛卡爾積（Cartesian product)(交叉聯(lián)接），生成虛擬表VT1
ON：對VT1應(yīng)用ON篩選器。只有那些使<join_condition>為真的行才被插入VT2。
OUTER(JOIN)：如 果指定了OUTER JOIN（相對于CROSS JOIN 或(INNER JOIN),保留表（preserved table：左外部聯(lián)接把左表標(biāo)記為保留表，右外部聯(lián)接把右表標(biāo)記為保留表，完全外部聯(lián)接把兩個(gè)表都標(biāo)記為保留表）中未找到匹配的行將作為外部行添加到 VT2,生成VT3.如果FROM子句包含兩個(gè)以上的表，則對上一個(gè)聯(lián)接生成的結(jié)果表和下一個(gè)表重復(fù)執(zhí)行步驟1到步驟3，直到處理完所有的表為止。
WHERE：對VT3應(yīng)用WHERE篩選器。只有使<where_condition>為true的行才被插入VT4.
GROUP BY：按GROUP BY子句中的列列表對VT4中的行分組，生成VT5.
CUBE|ROLLUP：把超組(Suppergroups)插入VT5,生成VT6.
HAVING：對VT6應(yīng)用HAVING篩選器。只有使<having_condition>為true的組才會被插入VT7.
SELECT：處理SELECT列表，產(chǎn)生VT8.
DISTINCT：將重復(fù)的行從VT8中移除，產(chǎn)生VT9.
ORDER BY：將VT9中的行按ORDER BY 子句中的列列表排序，生成游標(biāo)（VC10).
TOP：從VC10的開始處選擇指定數(shù)量或比例的行，生成表VT11,并返回調(diào)用者
注：按ORDER BY子句中的列列表排序上步返回的行，返回游標(biāo)VC10。這一步是第一步也是唯一 一步可以使用SELECT列表中的列別名的步驟。這一步不同于其它步驟的是，它不返回有效的表，而是返回一個(gè)游標(biāo)。SQL是基于集合理論的。集合不會預(yù)先對它的行排序，它只是成員的邏輯集合，成員的順序無關(guān)緊要。對表進(jìn)行排序的查詢可以返回一個(gè)對象，包含按特定物理順序組織的行。ANSI把這種對象稱為游標(biāo)。理解這一步是正確理解SQL的基礎(chǔ)。因?yàn)檫@一步不返回表（而是返回游標(biāo)），使用了ORDER BY子句的查詢不能用作表表達(dá)式。表表達(dá)式包括：視圖、內(nèi)聯(lián)表值函數(shù)、子查詢、派生表和共用表達(dá)式。它的結(jié)果必須返回給期望得到物理記錄的客戶端應(yīng)用程序。例如，下面的派生表查詢無效，并產(chǎn)生一個(gè)錯(cuò)誤：
select *
from(select orderid,customerid from orders order by orderid)
as d
下面的視圖也會產(chǎn)生錯(cuò)誤
create view my_view
as
select *
from orders
order by orderid
在SQL中，表表達(dá)式中不允許使用帶有ORDER BY子句的查詢，而在T—SQL中卻有一個(gè)例外（應(yīng)用TOP選項(xiàng)）。
所以要記住，不要為表中的行假設(shè)任何特定的順序。換句話說，除非你確定要有序行，否則不要指定ORDER BY 子句。
以上就是一條sql的執(zhí)行過程，同時(shí)我們在書寫查詢sql的時(shí)候應(yīng)當(dāng)遵守以下順序。
SELECT XXX FROM XXX WHERE XXX GROUP BY XXX HAVING XXX ORDER BY XXX LIMIT XXX;
語句執(zhí)行詳情
執(zhí)行FROM語句
在這些SQL語句的執(zhí)行過程中，都會產(chǎn)生一個(gè)虛擬表，用來保存SQL語句的執(zhí)行結(jié)果（這是重點(diǎn)），現(xiàn)在就來跟蹤這個(gè)虛擬表的變化，得到最終的查詢結(jié)果的過程，來分析整個(gè)SQL邏輯查詢的執(zhí)行順序和過程。
第一步，執(zhí)行FROM語句。我們首先需要知道最開始從哪個(gè)表開始的，這就是FROM告訴我們的。現(xiàn)在有了<left_table>和<right_table>兩個(gè)表，到底從哪個(gè)表開始，還是從兩個(gè)表進(jìn)行某種聯(lián)系以后再開始呢？它們之間如何產(chǎn)生聯(lián)系呢？——笛卡爾積
經(jīng)過FROM語句對兩個(gè)表執(zhí)行笛卡爾積，會得到一個(gè)虛擬表，暫且叫VT1（vitual table 1），內(nèi)容如下：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 9you | shanghai | 1 | 163 |
| baidu | hangzhou | 1 | 163 |
| tx | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| 9you | shanghai | 2 | 163 |
| baidu | hangzhou | 2 | 163 |
| tx | hangzhou | 2 | 163 |
| 163 | hangzhou | 3 | 9you |
| 9you | shanghai | 3 | 9you |
| baidu | hangzhou | 3 | 9you |
| tx | hangzhou | 3 | 9you |
| 163 | hangzhou | 4 | 9you |
| 9you | shanghai | 4 | 9you |
| baidu | hangzhou | 4 | 9you |
| tx | hangzhou | 4 | 9you |
| 163 | hangzhou | 5 | 9you |
| 9you | shanghai | 5 | 9you |
| baidu | hangzhou | 5 | 9you |
| tx | hangzhou | 5 | 9you |
| 163 | hangzhou | 6 | tx |
| 9you | shanghai | 6 | tx |
| baidu | hangzhou | 6 | tx |
| tx | hangzhou | 6 | tx |
| 163 | hangzhou | 7 | NULL |
| 9you | shanghai | 7 | NULL |
| baidu | hangzhou | 7 | NULL |
| tx | hangzhou | 7 | NULL |
+-------------+----------+----------+-------------+
總共有28（table1的記錄條數(shù) * table2的記錄條數(shù)）條記錄。這就是VT1的結(jié)果，接下來的操作就在VT1的基礎(chǔ)上進(jìn)行。
執(zhí)行ON過濾
執(zhí)行完笛卡爾積以后，接著就進(jìn)行ON a.customer_id = b.customer_id條件過濾，根據(jù)ON中指定的條件，去掉那些不符合條件的數(shù)據(jù)，得到VT2表，內(nèi)容如下：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| 9you | shanghai | 3 | 9you |
| 9you | shanghai | 4 | 9you |
| 9you | shanghai | 5 | 9you |
| tx | hangzhou | 6 | tx |
+-------------+----------+----------+-------------+
VT2就是經(jīng)過ON條件篩選以后得到的有用數(shù)據(jù)，而接下來的操作將在VT2的基礎(chǔ)上繼續(xù)進(jìn)行。
添加外部行
這一步只有在連接類型為OUTER JOIN時(shí)才發(fā)生，如LEFT OUTER JOIN、RIGHT OUTER JOIN和FULL OUTER JOIN。在大多數(shù)的時(shí)候，我們都是會省略掉OUTER關(guān)鍵字的，但OUTER表示的就是外部行的概念。
LEFT OUTER JOIN把左表記為保留表，得到的結(jié)果為：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| 9you | shanghai | 3 | 9you |
| 9you | shanghai | 4 | 9you |
| 9you | shanghai | 5 | 9you |
| tx | hangzhou | 6 | tx |
| baidu | hangzhou | NULL | NULL |
+-------------+----------+----------+-------------+
RIGHT OUTER JOIN把右表記為保留表，得到的結(jié)果為：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| 9you | shanghai | 3 | 9you |
| 9you | shanghai | 4 | 9you |
| 9you | shanghai | 5 | 9you |
| tx | hangzhou | 6 | tx |
| NULL | NULL | 7 | NULL |
+-------------+----------+----------+-------------+
FULL OUTER JOIN把左右表都作為保留表，得到的結(jié)果為：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| 9you | shanghai | 3 | 9you |
| 9you | shanghai | 4 | 9you |
| 9you | shanghai | 5 | 9you |
| tx | hangzhou | 6 | tx |
| baidu | hangzhou | NULL | NULL |
| NULL | NULL | 7 | NULL |
+-------------+----------+----------+-------------+
添加外部行的工作就是在VT2表的基礎(chǔ)上添加保留表中被過濾條件過濾掉的數(shù)據(jù)，非保留表中的數(shù)據(jù)被賦予NULL值，最后生成虛擬表VT3。
由于在準(zhǔn)備的測試SQL查詢邏輯語句中使用的是LEFT JOIN，過濾掉了以下這條數(shù)據(jù)：
| baidu | hangzhou | NULL | NULL |
現(xiàn)在就把這條數(shù)據(jù)添加到VT2表中，得到的VT3表如下：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| 9you | shanghai | 3 | 9you |
| 9you | shanghai | 4 | 9you |
| 9you | shanghai | 5 | 9you |
| tx | hangzhou | 6 | tx |
| baidu | hangzhou | NULL | NULL |
+-------------+----------+----------+-------------+
接下來的操作都會在該VT3表上進(jìn)行。
執(zhí)行WHERE過濾
對添加外部行得到的VT3進(jìn)行WHERE過濾，只有符合<where_condition>的記錄才會輸出到虛擬表VT4中。當(dāng)我們執(zhí)行WHERE a.city = 'hangzhou'的時(shí)候，就會得到以下內(nèi)容，并存在虛擬表VT4中：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| tx | hangzhou | 6 | tx |
| baidu | hangzhou | NULL | NULL |
+-------------+----------+----------+-------------+
但是在使用WHERE子句時(shí)，需要注意以下兩點(diǎn)：
- 由于數(shù)據(jù)還沒有分組，因此現(xiàn)在還不能在WHERE過濾器中使用where_condition=MIN(col)這類對分組統(tǒng)計(jì)的過濾；
- 由于還沒有進(jìn)行列的選取操作，因此在SELECT中使用列的別名也是不被允許的，如：SELECT city as c FROM t WHERE c='shanghai';是不允許出現(xiàn)的。
執(zhí)行GROUP BY分組
GROU BY子句主要是對使用WHERE子句得到的虛擬表進(jìn)行分組操作。我們執(zhí)行測試語句中的GROUP BY a.customer_id，就會得到以下內(nèi)容：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163 | hangzhou | 1 | 163 |
| 163 | hangzhou | 2 | 163 |
| baidu | hangzhou | NULL | NULL |
| tx | hangzhou | 6 | tx |
+-------------+----------+----------+-------------+
得到的內(nèi)容會存入虛擬表VT5中，此時(shí)，我們就得到了一個(gè)VT5虛擬表，接下來的操作都會在該表上完成。
執(zhí)行HAVING過濾
HAVING子句主要和GROUP BY子句配合使用，對分組得到的VT5虛擬表進(jìn)行條件過濾。當(dāng)我執(zhí)行測試語句中的HAVING count(b.order_id) < 2時(shí)，將得到以下內(nèi)容：
+-------------+----------+----------+-------------+
| customer_id | city | order_id | customer_id |
+-------------+----------+----------+-------------+
| baidu | hangzhou | NULL | NULL |
| tx | hangzhou | 6 | tx |
+-------------+----------+----------+-------------+
這就是虛擬表VT6。
SELECT列表
現(xiàn)在才會執(zhí)行到SELECT子句，不要以為SELECT子句被寫在第一行，就是第一個(gè)被執(zhí)行的。
我們執(zhí)行測試語句中的SELECT a.customer_id, COUNT(b.order_id) as total_orders，從虛擬表VT6中選擇出我們需要的內(nèi)容。我們將得到以下內(nèi)容：
+-------------+--------------+
| customer_id | total_orders |
+-------------+--------------+
| baidu | 0 |
| tx | 1 |
+-------------+--------------+
不，還沒有完，這只是虛擬表VT7。
執(zhí)行DISTINCT子句
如果在查詢中指定了DISTINCT子句，則會創(chuàng)建一張內(nèi)存臨時(shí)表（如果內(nèi)存放不下，就需要存放在硬盤了）。這張臨時(shí)表的表結(jié)構(gòu)和上一步產(chǎn)生的虛擬表VT7是一樣的，不同的是對進(jìn)行DISTINCT操作的列增加了一個(gè)唯一索引，以此來去除重復(fù)數(shù)據(jù)。由于測試SQL語句中并沒有使用DISTINCT，所以，在該查詢中，這一步不會生成一個(gè)虛擬表。
執(zhí)行ORDER BY子句
對虛擬表中的內(nèi)容按照指定的列進(jìn)行排序，然后返回一個(gè)新的虛擬表，我們執(zhí)行測試SQL語句中的ORDER BY total_orders DESC，就會得到以下內(nèi)容：
+-------------+--------------+
| customer_id | total_orders |
+-------------+--------------+
| tx | 1 |
| baidu | 0 |
+-------------+--------------+
可以看到這是對total_orders列進(jìn)行降序排列的。上述結(jié)果會存儲在VT8中。
執(zhí)行LIMIT子句
LIMIT子句從上一步得到的VT8虛擬表中選出從指定位置開始的指定行數(shù)據(jù)。對于沒有應(yīng)用ORDER BY的LIMIT子句，得到的結(jié)果同樣是無序的，所以，很多時(shí)候，我們都會看到LIMIT子句會和ORDER BY子句一起使用。
MySQL數(shù)據(jù)庫的LIMIT支持如下形式的選擇：
LIMIT n, m
表示從第n條記錄開始選擇m條記錄。而很多開發(fā)人員喜歡使用該語句來解決分頁問題。對于小數(shù)據(jù)，使用LIMIT子句沒有任何問題，當(dāng)數(shù)據(jù)量非常大的時(shí)候，使用LIMIT n, m是非常低效的。因?yàn)長IMIT的機(jī)制是每次都是從頭開始掃描，如果需要從第60萬行開始，讀取3條數(shù)據(jù)，就需要先掃描定位到60萬行，然后再進(jìn)行讀取，而掃描的過程是一個(gè)非常低效的過程。所以，對于大數(shù)據(jù)處理時(shí)，是非常有必要在應(yīng)用層建立一定的緩存機(jī)制。
習(xí)慣養(yǎng)成
了解了 SQL 執(zhí)行順序，那么我們就接下來進(jìn)一步養(yǎng)成日常 sql好習(xí)慣，也就是在實(shí)現(xiàn)功能同時(shí)有考慮性能的思想，數(shù)據(jù)庫是能進(jìn)行集合運(yùn)算的工具，我們應(yīng)該盡量的利用這個(gè)工具，所謂集合運(yùn)算實(shí)際就是批量運(yùn)算，就是盡量減少在客戶端進(jìn)行大數(shù)據(jù)量的循環(huán)操作，而用SQL語句或者存儲過程代替。
只返回需要的數(shù)據(jù)
返回?cái)?shù)據(jù)到客戶端至少需要數(shù)據(jù)庫提取數(shù)據(jù)、網(wǎng)絡(luò)傳輸數(shù)據(jù)、客戶端接收數(shù)據(jù)以及客戶端處理數(shù)據(jù)等環(huán)節(jié)。
如果返回不需要的數(shù)據(jù)，就會增加服務(wù)器、網(wǎng)絡(luò)和客戶端的無效勞動(dòng)，其害處是顯而易見的，避免這類事件需要注意：
- 橫向來看：
不要寫SELECT * 的語句，而是選擇你需要的字段。
當(dāng)在SQL語句中連接多個(gè)表時(shí), 請使用表的別名并把別名前綴于每個(gè)Column上。這樣一來,就可以減少解析的時(shí)間并減少那些由Column歧義引起的語法錯(cuò)誤。
如有表table1（ID,col1）和table2 （ID,col2）
Select A.ID, A.col1, B.col2
-- Select A.ID, col1, col2 –不要這么寫，不利于將來程序擴(kuò)展
from table1 A inner join table2 B on A.ID=B.ID Where …
- 縱向來看
合理寫WHERE子句，不要寫沒有WHERE的SQL語句。SELECT TOP N * --沒有WHERE條件的用此替代
盡量少做重復(fù)的工作?？刂仆徽Z句的多次執(zhí)行，特別是一些基礎(chǔ)數(shù)據(jù)的多次執(zhí)行是很多程序員很少注意的。
減少多次的數(shù)據(jù)轉(zhuǎn)換，也許需要數(shù)據(jù)轉(zhuǎn)換是設(shè)計(jì)的問題，但是減少次數(shù)是程序員可以做到的。
杜絕不必要的子查詢和連接表，子查詢在執(zhí)行計(jì)劃一般解釋成外連接，多余的連接表帶來額外的開銷。
合并對同一表同一條件的多次UPDATE，比如：
UPDATE EMPLOYEE SET FNAME='HAIWER'
WHERE EMP_ID=' VPA30890F'
UPDATE EMPLOYEE SET LNAME='YANG'
WHERE EMP_ID=' VPA30890F'
-- 這兩個(gè)語句應(yīng)該合并成以下一個(gè)語句
UPDATE EMPLOYEE SET FNAME='HAIWER',LNAME='YANG' WHERE EMP_ID=' VPA30890F'
UPDATE操作不要拆成DELETE操作+INSERT操作的形式，雖然功能相同，但是性能差別是很大的。
注意 臨時(shí)表 和 表變量 的用法
在復(fù)雜系統(tǒng)中，臨時(shí)表和表變量很難避免，關(guān)于臨時(shí)表和表變量的用法，需要注意：
- 如果語句很復(fù)雜，連接太多，可以考慮用臨時(shí)表和表變量分步完成。
- 如果需要多次用到一個(gè)大表的同一部分?jǐn)?shù)據(jù)，考慮用臨時(shí)表和表變量暫存這部分?jǐn)?shù)據(jù)。
- 如果需要綜合多個(gè)表的數(shù)據(jù)，形成一個(gè)結(jié)果，可以考慮用臨時(shí)表和表變量分步匯總這多個(gè)表的數(shù)據(jù)。
- 其他情況下，應(yīng)該控制臨時(shí)表和表變量的使用。
關(guān)于臨時(shí)表和表變量的選擇，很多說法是表變量在內(nèi)存，速度快，應(yīng)該首選表變量，但是在實(shí)際使用中發(fā)現(xiàn)，主要考慮需要放在臨時(shí)表的數(shù)據(jù)量，在數(shù)據(jù)量較多的情況下，臨時(shí)表的速度反而更快。執(zhí)行時(shí)間段與預(yù)計(jì)執(zhí)行時(shí)間(多長)。
關(guān)于臨時(shí)表產(chǎn)生使用SELECT INTO 和 CREATE TABLE + INSERT INTO 的選擇。一般情況下，SELECT INTO會比CREATE TABLE + INSERT INTO的方法快很多，但是SELECT INTO會鎖定TEMPDB的系統(tǒng)表SYSOBJECTS、SYSINDEXES、SYSCOLUMNS，
在多用戶并發(fā)環(huán)境下，容易阻塞其他進(jìn)程，
所以，在并發(fā)系統(tǒng)中，盡量使用CREATE TABLE + INSERT INTO，而大數(shù)據(jù)量的單個(gè)語句使用中，使用SELECT INTO。
子查詢的用法
子查詢是一個(gè) SELECT 查詢，它嵌套在 SELECT、INSERT、UPDATE、DELETE 語句或其它子查詢中。
任何允許使用表達(dá)式的地方都可以使用子查詢，子查詢可以使我們的編程靈活多樣，可以用來實(shí)現(xiàn)一些特殊的功能。
但是在性能上，往往一個(gè)不合適的子查詢用法會形成一個(gè)性能瓶頸。
如果子查詢的條件中使用了其外層的表的字段，這種子查詢就叫作相關(guān)子查詢。
相關(guān)子查詢可以用IN、NOT IN、EXISTS、NOT EXISTS引入。
關(guān)于相關(guān)子查詢，應(yīng)該注意：
- NOT IN、NOT EXISTS的相關(guān)子查詢可以改用LEFT JOIN代替寫法。
比如：
SELECT PUB_NAME FROM PUBLISHERS WHERE PUB_ID NOT IN (SELECT PUB_ID FROM TITLES WHERE TYPE = 'BUSINESS')
可以改寫成：
SELECT A.PUB_NAME FROM PUBLISHERS A LEFT JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID WHERE B.PUB_ID IS NULL
又比如：
SELECT TITLE FROM TITLES
WHERE NOT EXISTS
(SELECT TITLE_ID FROM SALES
WHERE TITLE_ID = TITLES.TITLE_ID)
可以改寫成：
SELECT TITLE
FROM TITLES LEFT JOIN SALES
ON SALES.TITLE_ID = TITLES.TITLE_ID
WHERE SALES.TITLE_ID IS NULL
- 如果保證子查詢沒有重復(fù) ，IN、EXISTS的相關(guān)子查詢可以用INNER JOIN 代替。
比如：
SELECT PUB_NAME
FROM PUBLISHERS
WHERE PUB_ID IN
(SELECT PUB_ID
FROM TITLES
WHERE TYPE = 'BUSINESS')
可以改寫成：
SELECT A.PUB_NAME --SELECT DISTINCT A.PUB_NAME
FROM PUBLISHERS A INNER JOIN TITLES B
ON B.TYPE = 'BUSINESS' AND
A.PUB_ID=B. PUB_ID
- IN的相關(guān)子查詢用EXISTS代替
比如
SELECT PUB_NAME FROM PUBLISHERS
WHERE PUB_ID IN
(SELECT PUB_ID FROM TITLES WHERE TYPE = 'BUSINESS')
可以用下面語句代替：
SELECT PUB_NAME FROM PUBLISHERS WHERE EXISTS
(SELECT 1 FROM TITLES WHERE TYPE = 'BUSINESS' AND
PUB_ID= PUBLISHERS.PUB_ID)
- 不要用COUNT(*)的子查詢判斷是否存在記錄，最好用LEFT JOIN或者EXISTS
比如有人寫這樣的語句：
SELECT JOB_DESC FROM JOBS
WHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)=0
應(yīng)該寫成：
SELECT JOBS.JOB_DESC FROM JOBS LEFT JOIN EMPLOYEE
ON EMPLOYEE.JOB_ID=JOBS.JOB_ID
WHERE EMPLOYEE.EMP_ID IS NULL
還有
SELECT JOB_DESC FROM JOBS
WHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)<>0
應(yīng)該寫成：
SELECT JOB_DESC FROM JOBS
WHERE EXISTS (SELECT 1 FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)
盡量使用索引
建立索引后，并不是每個(gè)查詢都會使用索引，在使用索引的情況下，索引的使用效率也會有很大的差別。只要我們在查詢語句中沒有強(qiáng)制指定索引，索引的選擇和使用方法是SQLSERVER的優(yōu)化器自動(dòng)作的選擇，而它選擇的根據(jù)是查詢語句的條件以及相關(guān)表的統(tǒng)計(jì)信息，這就要求我們在寫SQL語句的時(shí)候盡量使得優(yōu)化器可以使用索引。為了使得優(yōu)化器能高效使用索引，寫語句的時(shí)候應(yīng)該注意：
不要對索引字段進(jìn)行運(yùn)算，而要想辦法做變換
SELECT ID FROM T WHERE NUM/2=100
應(yīng)改為:
SELECT ID FROM T WHERE NUM=100*2
SELECT ID FROM T WHERE NUM/2=NUM1
如果NUM有索引應(yīng)改為:
SELECT ID FROM T WHERE NUM=NUM1*2
如果NUM1有索引則不應(yīng)該改。
發(fā)現(xiàn)過這樣的語句：
SELECT 年,月,金額 FROM 結(jié)余表 WHERE 100*年+月=2010*100+10
應(yīng)該改為：
SELECT 年,月,金額 FROM 結(jié)余表 WHERE 年=2010 AND月=10
不要對索引字段進(jìn)行格式轉(zhuǎn)換
日期字段的例子：
WHERE CONVERT(VARCHAR(10), 日期字段,120)='2010-07-15'
應(yīng)該改為
WHERE日期字段>='2010-07-15' AND 日期字段<'2010-07-16'
ISNULL轉(zhuǎn)換的例子：
WHERE ISNULL(字段,' ')<>' '應(yīng)改為:WHERE字段<>' '
WHERE ISNULL(字段,' ')=' '不應(yīng)修改
WHERE ISNULL(字段,'F') ='T'應(yīng)改為: WHERE字段='T'
WHERE ISNULL(字段,'F')<>'T'不應(yīng)修改
不要對索引字段使用函數(shù)
WHERE LEFT(NAME, 3)='ABC' 或者WHERE SUBSTRING(NAME,1, 3)='ABC'
應(yīng)改為: WHERE NAME LIKE 'ABC%'
日期查詢的例子：
WHERE DATEDIFF(DAY, 日期,'2010-06-30')=0
應(yīng)改為:WHERE 日期>='2010-06-30' AND 日期 <'2010-07-01'
WHERE DATEDIFF(DAY, 日期,'2010-06-30')>0
應(yīng)改為:WHERE 日期 <'2010-06-30'
WHERE DATEDIFF(DAY, 日期,'2010-06-30')>=0
應(yīng)改為:WHERE 日期 <'2010-07-01'
WHERE DATEDIFF(DAY, 日期,'2010-06-30')<0
應(yīng)改為:WHERE 日期>='2010-07-01'
WHERE DATEDIFF(DAY, 日期,'2010-06-30')<=0
應(yīng)改為:WHERE 日期>='2010-06-30'
不要對索引字段進(jìn)行多字段連接
比如：
WHERE FAME+ '. '+LNAME='HAIWEI.YANG'
應(yīng)改為:
WHERE FNAME='HAIWEI' AND LNAME='YANG'
多表連接的連接條件
多表連接的連接條件對索引的選擇有著重要的意義，所以我們在寫連接條件的時(shí)候需要特別注意。
多表連接的時(shí)候，連接條件必須寫全，寧可重復(fù)，不要缺漏。
連接條件盡量使用聚集索引
注意ON、WHERE和HAVING部分條件的區(qū)別
ON是最先執(zhí)行，WHERE次之，HAVING最后。因?yàn)镺N是先把不符合條件的記錄過濾后才進(jìn)行統(tǒng)計(jì)，它就可以減少中間運(yùn)算要處理的數(shù)據(jù)，按理說應(yīng)該速度是最快的，WHERE也應(yīng)該比 HAVING快點(diǎn)的，因?yàn)樗^濾數(shù)據(jù)后才進(jìn)行SUM，在兩個(gè)表聯(lián)接時(shí)才用ON的，所以在一個(gè)表的時(shí)候，就剩下WHERE跟HAVING比較了。
考慮聯(lián)接優(yōu)先順序
INNER JOIN
LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)
CROSS JOIN
其它注意和了解的地方有
在IN后面值的列表中，將出現(xiàn)最頻繁的值放在最前面，出現(xiàn)得最少的放在最后面，減少判斷的次數(shù)
注意UNION和UNION ALL的區(qū)別。--允許重復(fù)數(shù)據(jù)用UNION ALL好
注意使用DISTINCT，在沒有必要時(shí)不要用
