有关 sql server 查询的逻辑执行顺序，供大家学习参考。

FROM < left_table>
ON < join_condition>
< join_type> JOIN < right_table>
WHERE < where_condition>
GROUP BY < group_by_list>
WITH {cube | rollup}
HAVING < having_condition>
SELECT
DISTINCT
ORDER BY < order_by_list>
< top_specification> < select_list>

标准的SQL 的解析顺序为:
1）FROM 子句 组装来自不同数据源的数据
2）WHERE 子句 基于指定的条件对记录进行筛选
3）GROUP BY 子句 将数据划分为多个分组
4）使用聚合函数进行计算
5）使用HAVING子句筛选分组
6）计算所有的表达式
7）使用ORDER BY对结果集进行排序

执行顺序
FROM：对FROM子句中前两个表执行笛卡尔积生成虚拟表vt1
ON:对vt1表应用ON筛选器只有满足< join_condition> 为真的行才被插入vt2
OUTER(join)：如果指定了 OUTER JOIN保留表(preserved table)中未找到的行将行作为外部行添加到vt2 生成t3如果from包含两个以上表则对上一个联结生成的结果表和下一个表重复执行步骤和步骤直接结束
WHERE：对vt3应用 WHERE 筛选器只有使< where_condition> 为true的行才被插入vt4
GROUP BY：按GROUP BY子句中的列列表对vt4中的行分组生成vt5
CUBE|ROLLUP：把超组(supergroups)插入vt6 生成vt6
HAVING：对vt6应用HAVING筛选器只有使< having_condition> 为true的组才插入vt7
SELECT：处理select列表产生vt8
DISTINCT：将重复的行从vt8中去除产生vt9
ORDER BY：将vt9的行按order by子句中的列列表排序生成一个游标vc10
TOP：从vc10的开始处选择指定数量或比例的行生成vt11 并返回调用者

看到这里，那么用过linqtosql的语法有点相似啊？如果我们我们了解了sqlserver执行顺序，那么我们就接下来进一步养成日常sql好 习惯，也就是在实现功能同时有考虑性能的思想，数据库是能进行集合运算的工具，我们应该尽量的利用这个工具，所谓集合运算实际就是批量运算，就是尽量减少 在客户端进行大数据量的循环操作，而用SQL语句或者存储过程代替。
只返回需要的数据

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

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操作的形式，虽然功能相同，但是性能差别是很大的。
注意临时表和表变量的用法

在复杂系统中，临时表和表变量很难避免，关于临时表和表变量的用法，需要注意：
如果语句很复杂，连接太多，可以考虑用临时表和表变量分步完成。
如果需要多次用到一个大表的同一部分数据，考虑用临时表和表变量暂存这部分数据。
如果需要综合多个表的数据，形成一个结果，可以考虑用临时表和表变量分步汇总这多个表的数据。
其他情况下，应该控制临时表和表变量的使用。
关于临时表和表变量的选择，很多说法是表变量在内存，速度快，应该首选表变量，但是在实际使用中发现，主要考虑需要放在临时表的数据量，在数据量较多的情况下，临时表的速度反而更快。执行时间段与预计执行时间(多长)。
关于临时表产生使用SELECT INTO和CREATE TABLE + INSERT INTO的选择，一般情况下，SELECT INTO会比CREATE TABLE + INSERT INTO的方法快很多，但是SELECT INTO会锁定TEMPDB的系统表SYSOBJECTS、SYSINDEXES、SYSCOLUMNS，在多用户并发环境下，容易阻塞其他进程，所以我 的建议是，在并发系统中，尽量使用CREATE TABLE + INSERT INTO，而大数据量的单个语句使用中，使用SELECT INTO。
子查询的用法

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

1. NOT IN、NOT EXISTS的相关子查询可以改用LEFT JOIN代替写法。
比如：
1SELECT 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  

select T.* ,M.* from table1 T
left  join mytable M on T.a=M.myname and myhome='456'
--以上代码形成一张笛卡尔乘积的表table2，mytable表中myhome='456'的字段有值，其余为空值
WHERE  M.myhome is null
--在table2中找到M.myhome 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
ONB.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)

尽量使用索引

建立索引后，并不是每个查询都会使用索引，在使用索引的情况下，索引的使用效率也会有很大的差别。只要我们在查询语句中没有强制指定索引，索 引的选择和使用方法是SQLSERVER的优化器自动作的选择，而它选择的根据是查询语句的条件以及相关表的统计信息，这就要求我们在写SQL。

语句的时候尽量使得优化器可以使用索引。为了使得优化器能高效使用索引，写语句的时候应该注意：

A、不要对索引字段进行运算，而要想办法做变换，比如
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

B、 不要对索引字段进行格式转换
日期字段的例子：
WHERE CONVERT(VARCHAR(10), 日期字段,120)='2010-07-15'
应该改为
WHERE日期字段〉='2010-07-15'   AND   日期字段='2010-06-30' AND 日期 0
应改为:WHERE 日期 =0
应改为:WHERE 日期 0 )
BEGIN  
--回滚操作
ROLLBACK TRANSACTION  
RAISERROR('删除工作报告错误', 16, 3)  
RETURN
END
--结束事务
COMMIT TRANSACTION

您可能感兴趣的文章: