sql语句执行步骤详解

时间 2020-06-09

标签 sql 语句执行步骤详解栏目 SQL 繁體版

原文原文链接

1、准备工做

先来一段伪代码，首先你能看懂么？html

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>

继续作如下的前期准备工做：mysql

新建一个测试数据库TestDB；程序员

create database TestDB;

建立测试表table1和table2；sql

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;

插入测试数据；数据库

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);

准备工做作完之后，table1和table2看起来应该像下面这样：编程

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)

准备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查询语句来得到来自杭州，而且订单数少于2的客户。安全

2、SQL逻辑查询语句执行顺序

还记得上面给出的那一长串的SQL逻辑查询规则么？那么，到底哪一个先执行，哪一个后执行呢？如今，我先给出一个查询语句的执行顺序：服务器

(7) SELECT /* 处理SELECT列表，产生 VT7 */
	(8) DISTINCT <select_list> /* 将重复的行从 VT7 中删除，产品 VT8 */
	(1) FROM <left_table>  /* 对FROM子句中的表执行笛卡尔积(交叉联接)，生成虚拟表 VT1。 */
	(3) <join_type> JOIN <right_table> /* 若是指定了OUTER JOIN(相对于CROSS JOIN或INNER JOIN)，
	  保留表中未找到匹配的行将做为外部行添加到 VT2，生成 VT3。
	  若是FROM子句包含两个以上的表，
	  则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，
	  直处处理完全部的表位置。   */
	(2) ON <join_condition>/* 对 VT1 应用 ON 筛选器，只有那些使为真才被插入到 VT2。 */
	(4) WHERE <where_condition>/* 对 VT3 应用 WHERE 筛选器，只有使为true的行才插入VT4。 */
	(5) GROUP BY <group_by_list>   /* 按 GROUP BY子句中的列列表对 VT4 中的行进行分组，生成 VT5 */
	(6) HAVING <having_condition>  /* 对 VT5 应用 HAVING 筛选器，只有使为true的组插入到 VT6 */
	(9) ORDER BY <order_by_condition>  /* 将 VT8 中的行按 ORDER BY子句中的列列表顺序，生成一个游标(VC10)，
	  生成表TV11，并返回给调用者。 */
	(10)LIMIT <limit_number>

Oracle SQL语句执行顺序网络

(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>

以上每一个步骤都会产生一个虚拟表，该虚拟表被用做下一个步骤的输入。这些虚拟表对调用者(客户端应用程序或者外部查询)不可用。只有最后一步生成的表才会会给调用者。若是没有在查询中指定某一个子句，将跳过相应的步骤。

逻辑查询处理阶段简介:

FROM：对 FROM 子句中的前两个表执行笛卡尔积（Cartesian product)(交叉联接），生成虚拟表VT1
ON：对VT1应用ON筛选器。只有那些使<join_condition>为真的行才被插入VT2。
OUTER(JOIN)：如果指定了OUTER JOIN（相对于CROSS JOIN 或(INNER JOIN),保留表（preserved table：左外部联接把左表标记为保留表，右外部联接把右表标记为保留表，彻底外部联接把两个表都标记为保留表）中未找到匹配的行将做为外部行添加到 VT2,生成VT3.若是FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直处处理完全部的表为止。
WHERE：对VT3应用WHERE筛选器。只有使<where_condition>为true的行才被插入VT4.
GROUP BY：按GROUP BY子句中的列列表对VT4中的行分组，生成VT5.
CUBE|ROLLUP：把超组(Suppergroups)插入VT5,生成VT6.
HAVING：对VT6应用HAVING筛选器。只有使<having_condition>为 true 的组才会被插入VT7.
SELECT：处理SELECT列表，产生VT8.
DISTINCT：将重复的行从VT8中移除，产生VT9.
ORDER BY：将VT9中的行按RDER BY 子句中的列列表排序，生成游标（VC10).
TOP：从VC10的开始处选择指定数量或比例的行，生成表VT11,并返回调用者。

注：步骤10，按ORDER BY子句中的列列表排序上步返回的行，返回游标VC10.这一步是第一步也是惟一一步可使用SELECT列表中的列别名的步骤。这一步不一样于其它步骤的是，它不返回有效的表，而是返回一个游标。SQL是基于集合理论的。集合不会预先对它的行排序，它只是成员的逻辑集合，成员的顺序可有可无。对表进行排序的查询能够返回一个对象，包含按特定物理顺序组织的行。ANSI把这种对象称为游标。理解这一步是正确理解SQL的基础。

由于这一步不返回表（而是返回游标），使用了ORDER BY子句的查询不能用做表表达式。表表达式包括：视图、内联表值函数、子查询、派生表和共用表达式。它的结果必须返回给指望获得物理记录的客户端应用程序。例如，下面的派生表查询无效，并产生一个错误：

select * 
	from(select orderid,customerid from orders order by orderid) as d

下面的视图也会产生错误

create view my_view
	as
	select *
	from orders
	order by orderid

在 SQL 中，表表达式中不容许使用带有 ORDER BY 子句的查询，而在T—SQL中却有一个例外（应用TOP选项）。

因此要记住，不要为表中的行假设任何特定的顺序。换句话说，除非你肯定要有序行，不然不要指定 ORDER BY 子句。排序是须要成本的，SQL Server须要执行有序索引扫描或使用排序运行符。

以上就是一条sql的执行过程，同时咱们在书写查询sql的时候应当遵照如下顺序。

SELECT XXX FROM XXX WHERE XXX GROUP BY XXX HAVING XXX ORDER BY XXX LIMIT XXX;

上面标出了各条查询规则的执行前后顺序，那么各条查询语句是如何执行的呢？

(1)执行FROM语句

在这些 SQL 语句的执行过程当中，都会产生一个虚拟表，用来保存 SQL 语句的执行结果（这是重点），我如今就来跟踪这个虚拟表的变化，获得最终的查询结果的过程，来分析整个 SQL 逻辑查询的执行顺序和过程。

第一步，执行FROM语句。咱们首先须要知道最开始从哪一个表开始的，这就是FROM告诉咱们的。如今有了 <left_table> 和 <right_table> 两个表，咱们到底从哪一个表开始，仍是从两个表进行某种联系之后再开始呢？它们之间如何产生联系呢？——笛卡尔积

关于什么是笛卡尔积，请自行 Google 补脑。通过 FROM 语句对两个表执行笛卡尔积，会获得一个虚拟表，暂且叫VT1（vitual table 1），内容以下：

+-------------+----------+----------+-------------+
| 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的记录条数 * table2的记录条数）条记录。这就是VT1的结果，接下来的操做就在VT1的基础上进行。

(2)执行ON过滤

执行完笛卡尔积之后，接着就进行ON a.customer_id = b.customer_id条件过滤，根据ON中指定的条件，去掉那些不符合条件的数据，获得VT2表，内容以下：

+-------------+----------+----------+-------------+
| 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就是通过ON条件筛选之后获得的有用数据，而接下来的操做将在VT2的基础上继续进行。

(3) JOIN 添加外部行

这一步只有在链接类型为OUTER JOIN时才发生，如LEFT OUTER JOIN、RIGHT OUTER JOIN和FULL OUTER JOIN。在大多数的时候，咱们都是会省略掉OUTER关键字的，但OUTER表示的就是外部行的概念。

下面从网上找到一张很形象的关于‘SQL JOINS'的解释图

LEFT OUTER JOIN把左表记为保留表，获得的结果为：

+-------------+----------+----------+-------------+
| 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把右表记为保留表，获得的结果为：

+-------------+----------+----------+-------------+
| 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把左右表都做为保留表，获得的结果为：

+-------------+----------+----------+-------------+
| 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表的基础上添加保留表中被过滤条件过滤掉的数据，非保留表中的数据被赋予NULL值，最后生成虚拟表VT3。

因为我在准备的测试SQL查询逻辑语句中使用的是LEFT JOIN，过滤掉了如下这条数据：

| baidu       | hangzhou |     NULL | NULL        |

如今就把这条数据添加到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表上进行。

(4)执行WHERE过滤

对添加外部行获得的VT3进行WHERE过滤，只有符合<where_condition>的记录才会输出到虚拟表VT4中。当咱们执行WHERE a.city = 'hangzhou'的时候，就会获得如下内容，并存在虚拟表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子句时，须要注意如下两点：

因为数据尚未分组，所以如今还不能在WHERE过滤器中使用**where_condition=MIN(col)**这类对分组统计的过滤；因为尚未进行列的选取操做，所以在SELECT中使用列的别名也是不被容许的，如：SELECT city as c FROM t WHERE c='shanghai';是不容许出现的。

(5) 执行 GROUP BY 分组

GROU BY子句主要是对使用WHERE子句获得的虚拟表进行分组操做。咱们执行测试语句中的GROUP BY a.customer_id，就会获得如下内容：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| 163         | hangzhou |        1 | 163         |
| baidu       | hangzhou |     NULL | NULL        |
| tx          | hangzhou |        6 | tx          |
+-------------+----------+----------+-------------+

获得的内容会存入虚拟表VT5中，此时，咱们就获得了一个VT5虚拟表，接下来的操做都会在该表上完成。

(6) 执行HAVING过滤

HAVING子句主要和GROUP BY子句配合使用，对分组获得的VT5虚拟表进行条件过滤。当我执行测试语句中的HAVING count(b.order_id) < 2时，将获得如下内容：

+-------------+----------+----------+-------------+
| customer_id | city     | order_id | customer_id |
+-------------+----------+----------+-------------+
| baidu       | hangzhou |     NULL | NULL        |
| tx          | hangzhou |        6 | tx          |
+-------------+----------+----------+-------------+

这就是虚拟表VT6。

(7) SELECT列表

如今才会执行到SELECT子句，不要觉得SELECT子句被写在第一行，就是第一个被执行的。

咱们执行测试语句中的SELECT a.customer_id, COUNT(b.order_id) as total_orders，从虚拟表VT6中选择出咱们须要的内容。咱们将获得如下内容：

+-------------+--------------+
| customer_id | total_orders |
+-------------+--------------+
| baidu       |            0 |
| tx          |            1 |
+-------------+--------------+

不，尚未完，这只是虚拟表VT7。

##　(８)执行 DISTINCT 子句

若是在查询中指定了DISTINCT子句，则会建立一张内存临时表（若是内存放不下，就须要存放在硬盘了）。这张临时表的表结构和上一步产生的虚拟表 VT7 是同样的，不一样的是对进行DISTINCT操做的列增长了一个惟一索引，以此来除重复数据。

因为个人测试SQL语句中并无使用 DISTINCT，因此，在该查询中，这一步不会生成一个虚拟表。

（9）执行 ORDER BY 子句

对虚拟表中的内容按照指定的列进行排序，而后返回一个新的虚拟表，咱们执行测试SQL语句中的ORDER BY total_orders DESC，就会获得如下内容：

+-------------+--------------+
| customer_id | total_orders |
+-------------+--------------+
| tx          |            1 |
| baidu       |            0 |
+-------------+--------------+

能够看到这是对 total_orders 列进行降序排列的。上述结果会存储在VT8中。

（10）执行 LIMIT 子句

LIMIT子句从上一步获得的VT8虚拟表中选出从指定位置开始的指定行数据。对于没有应用ORDER BY的LIMIT子句，获得的结果一样是无序的，因此，不少时候，咱们都会看到LIMIT子句会和ORDER BY子句一块儿使用。

MySQL数据库的LIMIT支持以下形式的选择：

LIMIT n, m

表示从第n条记录开始选择m条记录。而不少开发人员喜欢使用该语句来解决分页问题。对于小数据，使用LIMIT子句没有任何问题，当数据量很是大的时候，使用LIMIT n, m是很是低效的。由于LIMIT的机制是每次都是从头开始扫描，若是须要从第60万行开始，读取3条数据，就须要先扫描定位到60万行，而后再进行读取，而扫描的过程是一个很是低效的过程。因此，对于大数据处理时，是很是有必要在应用层创建必定的缓存机制（貌似如今的大数据处理，都有缓存哦）。各位，请期待个人缓存方面的文章哦。

至此SQL的解析之旅就结束了，上图总结一下：

3、SQL书写习惯

了解了 SQL 执行顺序，那么咱们就接下来进一步养成平常 sql好习惯，也就是在实现功能同时有考虑性能的思想，数据库是能进行集合运算的工具，咱们应该尽可能的利用这个工具，所谓集合运算实际就是批量运算，就是尽可能减小在客户端进行大数据量的循环操做，而用SQL语句或者存储过程代替。

1.只返回须要的数据

返回数据到客户端至少须要数据库提取数据、网络传输数据、客户端接收数据以及客户端处理数据等环节。若是返回不须要的数据，就会增长服务器、网络和客户端的无效劳动，其害处是显而易见的，避免这类事件须要注意：

（1）横向来看：

不要写SELECT * 的语句，而是选择你须要的字段。

当在SQL语句中链接多个表时, 请使用表的别名并把别名前缀于每一个Column上。这样一来,就能够减小解析的时间并减小那些由Column歧义引发的语法错误。

若有表table1（ID,col1）和table2 （ID,col2）
Select A.ID, A.col1, B.col2
-- Select A.ID, col1, col2     –不要这么写，不利于未来程序扩展
from table1 A inner join table2 B on A.ID=B.ID Where …

（2）纵向来看

合理写 WHERE 子句，不要写没有 WHERE 的 SQL 语句。SELECT TOP N * --没有WHERE条件的用此替代尽可能少作重复的工做。控制同一语句的屡次执行，特别是一些基础数据的屡次执行是不少程序员不多注意的。减小屡次的数据转换，也许须要数据转换是设计的问题，可是减小次数是程序员能够作到的。杜毫不必要的子查询和链接表，子查询在执行计划通常解释成外链接，多余的链接表带来额外的开销。合并对同一表同一条件的屡次 UPDATE，好比：

UPDATE EMPLOYEE SET FNAME='HAIWER'
WHERE EMP_ID=' VPA30890F' UPDATE EMPLOYEE SET LNAME='YANG'
WHERE EMP_ID=' VPA30890F'
-- 这两个语句应该合并成如下一个语句
UPDATE EMPLOYEE SET FNAME='HAIWER',LNAME='YANG'  WHERE EMP_ID=' VPA30890F'
UPDATE操做不要拆成DELETE操做+INSERT操做的形式，虽然功能相同，可是性能差异是很大的。

2.注意 `临时表` 和 `表变量` 的用法

在复杂系统中，临时表和表变量很难避免，关于临时表和表变量的用法，须要注意：

若是语句很复杂，链接太多，能够考虑用临时表和表变量分步完成。

若是须要屡次用到一个大表的同一部分数据，考虑用临时表和表变量暂存这部分数据。

若是须要综合多个表的数据，造成一个结果，能够考虑用临时表和表变量分步汇总这多个表的数据。

其余状况下，应该控制临时表和表变量的使用。

关于临时表和表变量的选择，不少说法是表变量在内存，速度快，应该首选表变量，

可是在实际使用中发现，主要考虑须要放在临时表的数据量，在数据量较多的状况下，临时表的速度反而更快。执行时间段与预计执行时间(多长)。

关于临时表产生使用SELECT INTO 和 CREATE TABLE + INSERT INTO 的选择。

通常状况下，SELECT INTO会比CREATE TABLE + INSERT INTO的方法快不少，可是SELECT INTO会锁定TEMPDB的系统表SYSOBJECTS、SYSINDEXES、SYSCOLUMNS，在多用户并发环境下，容易阻塞其余进程，因此个人建议是，在并发系统中，尽可能使用CREATE TABLE + INSERT INTO，而大数据量的单个语句使用中，使用SELECT INTO。

3.子查询的用法

子查询是一个 SELECT 查询，它嵌套在 SELECT、INSERT、UPDATE、DELETE 语句或其它子查询中。任何容许使用表达式的地方均可以使用子查询，子查询可使咱们的编程灵活多样，能够用来实现一些特殊的功能。可是在性能上，每每一个不合适的子查询用法会造成一个性能瓶颈。若是子查询的条件中使用了其外层的表的字段，这种子查询就叫做相关子查询。相关子查询能够用IN、NOT IN、EXISTS、NOT EXISTS引入。关于相关子查询，应该注意：

1. NOT IN、NOT EXISTS的相关子查询能够改用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

2. 若是保证子查询没有重复 ，IN、EXISTS的相关子查询能够用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

3. IN的相关子查询用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)

4. 不要用COUNT(*)的子查询判断是否存在记录，最好用LEFT JOIN或者EXISTS

好比有人写这样的语句：
    SELECT JOB_DESC FROM JOBS
    WHERE (SELECT COUNT(*) FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)=0
应该写成：
    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
应该写成：
    SELECT JOB_DESC FROM JOBS
    WHERE EXISTS (SELECT 1 FROM EMPLOYEE WHERE JOB_ID=JOBS.JOB_ID)

4.尽可能使用索引

创建索引后，并非每一个查询都会使用索引，在使用索引的状况下，索引的使用效率也会有很大的差异。只要咱们在查询语句中没有强制指定索引，索引的选择和使用方法是SQLSERVER的优化器自动做的选择，而它选择的根据是查询语句的条件以及相关表的统计信息，这就要求咱们在写SQL语句的时候尽可能使得优化器可使用索引。为了使得优化器能高效使用索引，写语句的时候应该注意：

不要对索引字段进行运算，而要想办法作变换

SELECT ID FROM T WHERE NUM/2=100
    应改成:
    SELECT ID FROM T WHERE NUM=100*2
    SELECT ID FROM T WHERE NUM/2=NUM1
    若是NUM有索引应改成:
    SELECT ID FROM T WHERE NUM=NUM1*2
    若是NUM1有索引则不该该改。
    发现过这样的语句：
    SELECT 年,月,金额 FROM 结余表  WHERE 100*年+月=2010*100+10
    应该改成：
    SELECT 年,月,金额 FROM 结余表 WHERE 年=2010 AND月=10

不要对索引字段进行格式转换

日期字段的例子：
    WHERE CONVERT(VARCHAR(10), 日期字段,120)='2010-07-15'
    应该改成
    WHERE日期字段〉='2010-07-15'   AND   日期字段<'2010-07-16'
    ISNULL转换的例子：
    WHERE ISNULL(字段,'')<>''应改成:WHERE字段<>''
    WHERE ISNULL(字段,'')=''不该修改
    WHERE ISNULL(字段,'F') ='T'应改成: WHERE字段='T'
    WHERE ISNULL(字段,'F')<>'T'不该修改

不要对索引字段使用函数

WHERE LEFT(NAME, 3)='ABC' 或者WHERE SUBSTRING(NAME,1, 3)='ABC'
    应改成: WHERE NAME LIKE 'ABC%'
    日期查询的例子：
    WHERE DATEDIFF(DAY, 日期,'2010-06-30')=0
    应改成:WHERE 日期>='2010-06-30' AND 日期 <'2010-07-01'
    WHERE DATEDIFF(DAY, 日期,'2010-06-30')>0
    应改成:WHERE 日期 <'2010-06-30'
    WHERE DATEDIFF(DAY, 日期,'2010-06-30')>=0
    应改成:WHERE 日期 <'2010-07-01'
    WHERE DATEDIFF(DAY, 日期,'2010-06-30')<0
    应改成:WHERE 日期>='2010-07-01'
    WHERE DATEDIFF(DAY, 日期,'2010-06-30')<=0
    应改成:WHERE 日期>='2010-06-30'

不要对索引字段进行多字段链接

好比：
    WHERE FAME+ '. '+LNAME='HAIWEI.YANG'
    应改成:
    WHERE FNAME='HAIWEI' AND LNAME='YANG'

5.多表链接的链接条件

多表链接的链接条件对索引的选择有着重要的意义，因此咱们在写链接条件的时候须要特别注意。

多表链接的时候，链接条件必须写全，宁肯重复，不要缺漏。

链接条件尽可能使用汇集索引

注意ON、WHERE和HAVING部分条件的区别

ON是最早执行，WHERE次之，HAVING最后。由于ON是先把不符合条件的记录过滤后才进行统计，它就能够减小中间运算要处理的数据，按理说应该速度是最快的，

WHERE也应该比 HAVING快点的，由于它过滤数据后才进行SUM，在两个表联接时才用ON的，因此在一个表的时候，就剩下WHERE跟HAVING比较了

6.考虑联接优先顺序

INNER JOIN LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代) CROSS JOIN

其它注意和了解的地方有

在IN后面值的列表中，将出现最频繁的值放在最前面，出现得最少的放在最后面，减小判断的次数

注意UNION和UNION ALL的区别。--容许重复数据用UNION ALL好

注意使用DISTINCT，在没有必要时不要用

7.truncate table与 delete 区别

相同点：

1.truncate和不带where子句的delete、以及drop都会删除表内的数据。
2.drop、truncate都是DDL语句(数据定义语言),执行后会自动提交。

不一样点：

1. truncate 和 delete 只删除数据不删除表的结构(定义)
drop 语句将删除表的结构被依赖的约束(constrain)、触发器(trigger)、索引(index)；依赖于该表的存储过程/函数将保留,可是变为 invalid 状态。

2. delete 语句是数据库操做语言(dml)，这个操做会放到 rollback segement 中，事务提交以后才生效；若是有相应的 trigger，执行的时候将被触发。
truncate、drop 是数据库定义语言(ddl)，操做当即生效，原数据不放到 rollback segment 中，不能回滚，操做不触发 trigger。

3.delete 语句不影响表所占用的 extent，高水线(high watermark)保持原位置不动
drop 语句将表所占用的空间所有释放。
truncate 语句缺省状况下见空间释放到 minextents个 extent，除非使用reuse storage；truncate 会将高水线复位(回到最开始)。

4.速度，通常来讲: drop> truncate > delete

5.安全性：当心使用 drop 和 truncate，尤为没有备份的时候.不然哭都来不及
使用上,想删除部分数据行用 delete，注意带上where子句. 回滚段要足够大.
想删除表,固然用 drop
想保留表而将全部数据删除，若是和事务无关，用truncate便可。若是和事务有关,或者想触发trigger,仍是用delete。
若是是整理表内部的碎片，能够用truncate跟上reuse stroage，再从新导入/插入数据。

6.delete是DML语句,不会自动提交。drop/truncate都是DDL语句,执行后会自动提交。

七、TRUNCATE   TABLE   在功能上与不带   WHERE   子句的   DELETE   
语句相同：两者均删除表中的所有行。但   TRUNCATE   TABLE   比   DELETE   速度快，且使用的系统和事务日志资源少。
DELETE   语句每次删除一行，并在事务日志中为所删除的每行记录一项。
TRUNCATE   TABLE   经过释放存储表数据所用的数据页来删除数据，而且只在事务日志中记录页的释放。 

八、TRUNCATE   TABLE   删除表中的全部行，但表结构及其列、约束、索引等保持不变。新行标识所用的计数值重置为该列的种子。若是想保留标识计数值，请改用   DELETE。若是要删除表定义及其数据，请使用   DROP   TABLE   语句。  
    
九、对于由   FOREIGN   KEY   约束引用的表，不能使用   TRUNCATE   TABLE，而应使用不带   WHERE   子句的   DELETE   语句。因为 TRUNCATE TABLE 不记录在日志中，因此它不能激活触发器。    

十、TRUNCATE   TABLE   不能用于参与了索引视图的表。

原文出处：https://www.cnblogs.com/tester-ggf/p/11963243.html