sql语句的执行步骤：

1）语法分析，分析语句的语法是否符合规范，衡量语句中各表达式的意义。

2）语义分析，检查语句中涉及的所有数据库对象是否存在，且用户有相应的权限

3）视图转换，将涉及视图的查询语句转换为相应的对基表查询语句。

4）表达式转换， 将复杂的 SQL 表达式转换为较简单的等效连接表达式。

5）选择优化器，不同的优化器一般产生不同的“执行计划”

6）选择连接方式， ORACLE 有三种连接方式，对多表连接 ORACLE 可选择适当的连接方式。

7）选择连接顺序， 对多表连接 ORACLE 选择哪一对表先连接，选择这两表中哪个表做为源数据表。

8）选择数据的搜索路径，根据以上条件选择合适的数据搜索路径，如是选用全表搜索还是利用索引或是其他的方式。

9）运行“执行计划”。

Oracle共享原理：将执行过的SQL语句存放在内存的共享池(shared buffer pool)中，可以被所有的数据库用户共享当你执行一个SQL语句(有时被称为一个游标)时,如果它和之前的执行过的语句完全相同, Oracle就能很快获得已经被解析的语句以及最好的 执行路径. 这个功能大大地提高了SQL的执行性能并节省了内存的使用。

SQL查询处理的步骤序号：

(8) SELECT (9) DISTINCT (11)  

(1) FROM  

(3) JOIN  

(2) ON  

(4) WHERE  

(5) GROUP BY  

(6) WITH {CUBE | ROLLUP} 

(7) HAVING  

(10) ORDER BY  

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

逻辑查询处理阶段简介：

1、 FROM：对FROM子句中的前两个表执行笛卡尔积(交叉联接)，生成虚拟表VT1。表名执行顺序是从后往前，所以数据较少的表尽量放后。

2、 ON：对VT1应用ON筛选器，只有那些使为真才被插入到TV2。

3、 OUTER (JOIN):如果指定了OUTER JOIN(相对于CROSS JOIN或INNER JOIN)，保留表中未找到匹配的行将作为外部行添加到VT2，生成TV3。如果FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直到处理完所有的表位置。

4、 WHERE：对TV3应用WHERE筛选器，只有使为true的行才插入TV4。执行顺序为从前往后或者说从左到右。

5、 GROUP BY：按GROUP BY子句中的列列表对TV4中的行进行分组，生成TV5。执行顺序从左往右分组。

6、 CUTE|ROLLUP：把超组插入VT5，生成VT6。

7、 HAVING：对VT6应用HAVING筛选器，只有使为true的组插入到VT7。Having语句很耗资源，尽量少用

8、 SELECT：处理SELECT列表，产生VT8。

9、 DISTINCT：将重复的行从VT8中删除，产品VT9。

10、ORDER BY：将VT9中的行按ORDER BY子句中的列列表顺序，生成一个游标(VC10)。执行顺序从左到右，是一个很耗资源的语句。

11、TOP：从VC10的开始处选择指定数量或比例的行，生成表TV11，并返回给调用者

 提高SQL的执行效率

第一、只返回需要的数据

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

A、横向来看，

(1)不要写SELECT *的语句，而是选择你需要的字段。

(2)当在SQL语句中连接多个表时, 请使用表的别名并把别名前缀于每个Column上.这样一来,就可以减少解析的时间并减少那些由Column歧义引起的语法错误。

B、纵向来看，

(1)合理写WHERE子句，不要写没有WHERE的SQL语句。

(2) SELECT TOP N * --没有WHERE条件的用此替代

  第二、尽量少做重复的工作

A、控制同一语句的多次执行，特别是一些基础数据的多次执行是很多程序员很少注意的。

B、减少多次的数据转换，也许需要数据转换是设计的问题，但是减少次数是程序员可以做到的。

C、杜绝不必要的子查询和连接表，子查询在执行计划一般解释成外连接，多余的连接表带来额外的开销。

D、合并对同一表同一条件的多次UPDATE。

E、UPDATE操作不要拆成DELETE操作+INSERT操作的形式，虽然功能相同，但是性能差别是很大的。

第三、注意临时表和表变量的用法

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

A、如果语句很复杂，连接太多，可以考虑用临时表和表变量分步完成。

B、如果需要多次用到一个大表的同一部分数据，考虑用临时表和表变量暂存这部分数据。

C、如果需要综合多个表的数据，形成一个结果，可以考虑用临时表和表变量分步汇总这多个表的数据。

D、其他情况下，应该控制临时表和表变量的使用。

E、关于临时表和表变量的选择，很多说法是表变量在内存，速度快，应该首选表变量，但是在实际使用中发现，(1)主要考虑需要放在临时表的数据量，在数据量较多的情况下，临时表的速度反而更快。(2)执行时间段与预计执行时间(多长)

F、关于临时表产生使用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)

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

(2)

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

B、 如果保证子查询没有重复 ，IN、EXISTS的相关子查询可以用INNER JOIN 代替。

比如：

SELECT PUB_NAME

FROM PUBLISHERS

WHERE PUB_ID IN (SELECT PUB_ID FROM TITLES

WHERE TYPE = 'BUSINESS')

可以改写成：

SELECT DISTINCT A.PUB_NAME

FROM PUBLISHERS A INNER JOIN TITLES B ON B.TYPE = 'BUSINESS' AND A.PUB_ID=B. PUB_ID

C、 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) D、不要用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-07-16' IS NULL

转换的例子：

WHERE ISNULL(字段,'')<>''应改为:WHERE字段<>'

WHERE ISNULL(字段,'')=''不应修改

WHERE ISNULL(字段,'F') ='T'应改为: WHERE字段='T'

WHERE ISNULL(字段,'F')<>'T'不应修改

C、 不要对索引字段使用函数

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'

D、不要对索引字段进行多字段连接

比如：

WHERE FAME+ '. '+LNAME='HAIWEI.YANG'

应改为:

WHERE FNAME='HAIWEI' AND LNAME='YANG'

第六、注意多表连接的连接条件的选择与表示

多表连接的连接条件对索引的选择有着重要的意义，所以我们在写连接条件条件的时候需要特别注意。

A、多表连接的时候，连接条件必须写全，宁可重复，不要缺漏。

B、连接条件尽量使用聚集索引

C、注意ON、WHERE和HAVING部分条件的区别： ON是最先执行， WHERE次之，HAVING最后，因为ON是先把不符合条件的记录过滤后才进行统计，它就可以减少中间运算要处理的数据，按理说应该速度是最快的，WHERE也应该比 HAVING快点的，因为它过滤数据后才进行SUM，在两个表联接时才用ON的，所以在一个表的时候，就剩下WHERE跟HAVING比较了

1、考虑联接优先顺序：

2、INNER JOIN

3、LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)

4、CROSS JOIN

其它注意和了解的地方有：

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

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

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

D、TRUNCATE TABLE 与 DELETE 区别

E、减少访问数据库的次数

还有就是我们写存储过程，如果比较长的话，最后用标记符标开，因为这样可读性很好，即使语句写的不怎么样但是语句工整。如：

           --startof 查询在职人数

               sql语句

           --end of

       正式机器上我们一般不能随便调试程序，但是很多时候程序在我们本机上没问题，但是进正式系统就有问题，但是我们又不能随便在正式机器上操作，那么怎么办呢?我们可以用回滚来调试我们的存储过程或者是sql语句，从而排错。

        BEGIN TRAN

            UPDATE a SET 字段='  '

        ROLLBACK

作业存储过程可以加上下面这段，这样检查错误可以放在存储过程，如果执行错误回滚操作，但是如果程序里面已经有了事务回滚，那么存储过程就不要写事务了，这样会导致事务回滚嵌套降低执行效率，但是我们很多时候可以把检查放在存储过程里，这样有利于我们解读这个存储过程，和排错。

BEGIN TRANSACTION

        --事务回滚开始

              --检查报错

              IF ( @@ERROR > 0 )

                  BEGIN

                     --回滚操作

                     ROLLBACK TRANSACTION

                     RAISERROR('删除工作报告错误', 16, 3)

                  RETURN

                  END

         --结束事务

         COMMIT TRANSACTION 

第七、有效使用Decode函数

             使用Decode函数可以有效避免重复扫描相同数据或重复连接相同表。