Oracle中的一些查询语句及其执行顺序
原文地址：https://www.cnblogs.com/likeju/p/5039115.htmlhtml
查询条件：
1)LIKE：模糊查询，须要借助两个通配符，%：表示0到多个字符；_：标识单个字符。
2)IN(list)：用来取出符合列表范围中的数据。
3)NOT IN(list)： 取出不符合此列表中的数据记录。
4)BETWEEN…AND…:用来查询符合某个值域范围条件的数据，最多见的是使用在数字类型的数据范围上，但对字符类型和日期类型数据也一样适用。for example： SELECT ename, sal FROM emp WHERE sal BETWEEN 1500 AND 3000;
5)IS NULL：空值NULL是一个特殊的值，比较的时候不能使用”=”号，必须使用IS NULL，不然不能获得正确的结果。
6)IS NOT NULL：与5相反。
7) >ANY : 大于最小 <ANY：小于最大 >ALL：大于最大 <ALL：小于最小
for example: SELECT empno, ename, job, sal, deptno FROM emp WHERE sal > ANY (345,3333,123)
8)DISTINCT:过滤重复。for example： SELECT DISTINCT deptno FROM emp
9)ORDER BY：对查询出的数据按必定规则进行排序操做，ASC指定升序，DESC指定降序。
10)GROUP BY：把获得的数据按照给定的字段进行分组，例如：把整个数据表按部门划分红一个个小组。
11)HAVING：HAVING子句用来对分组后的结果进一步限制，好比按部门分组后，获得每一个部门的最高薪水，能够继续限制输出结果。必须跟在GROUP BY后面，不能单独存在。例如： SELECT deptno, MAX(sal) max_sal FROM emp GROUP BY deptno HAVING MAX(sal) >4000;
查询语句的执行顺序：
一、FROM 子句：执行顺序为从后往前、从右到左。数据量较少的表尽可能放在后面。
二、WHERE子句：执行顺序为自下而上、从右到左。将能过滤掉最大数量记录的条件写在WHERE 子句的最右。
三、GROUP BY：执行顺序从左往右分组，最好在GROUP BY前使用WHERE将不须要的记录在GROUP BY以前过滤掉。
四、HAVING 子句：消耗资源。尽可能避免使用，HAVING 会在检索出全部记录以后才对结果集进行过滤，须要排序等操做。
五、SELECT子句：少用*号，尽可能取字段名称。ORACLE 在解析的过程当中, 经过查询数据字典将*号依次转换成全部的列名, 消耗时间。
六、ORDER BY子句：执行顺序为从左到右排序，消耗资源。程序员
Select 语句执行顺序以及如何提升Oracle 基本查询效率
原文地址：https://www.cnblogs.com/likeju/p/5039128.htmlsql
今天把这几天作的练习复习了一下，不知道本身写得代码执行的效率如何以及要如何提升，因而乎上网开始研究一些材料，现整理以下：数据库
首先，要了解在Oracle中Sql语句运行的机制。如下是sql语句的执行步骤：
1）语法分析，分析语句的语法是否符合规范，衡量语句中各表达式的意义。
2）语义分析，检查语句中涉及的全部数据库对象是否存在，且用户有相应的权限。
3）视图转换，将涉及视图的查询语句转换为相应的对基表查询语句。
4）表达式转换， 将复杂的 SQL 表达式转换为较简单的等效链接表达式。
5）选择优化器，不一样的优化器通常产生不一样的“执行计划”
6）选择链接方式， ORACLE 有三种链接方式，对多表链接 ORACLE 可选择适当的链接方式。
7）选择链接顺序， 对多表链接 ORACLE 选择哪一对表先链接，选择这两表中哪一个表作为源数据表。
8）选择数据的搜索路径，根据以上条件选择合适的数据搜索路径，如是选用全表搜索仍是利用索引或是其余的方式。
9）运行“执行计划”。编程
这里不得不提的是Oracle共享原理：将执行过的SQL语句存放在内存的共享池(shared buffer pool)中，能够被全部的数据库用户共享当你执行一个SQL语句(有时被称为一个游标)时,若是它和以前的执行过的语句彻底相同, Oracle就能很快得到已经被解析的语句以及最好的 执行路径. 这个功能大大地提升了SQL的执行性能并节省了内存的使用。服务器
在了解了SQL语句的运行机制与Oracle共享原理后，咱们能够知道SQL语句的书写方式对SQL语句的执行效率有很大的影响。那么下面咱们了解一下SQL中Select语句中各个关键字执行的顺序。网络
SQL语言不一样于其余编程语言的最明显特征是处理代码的顺序。在大多数据库语言中，代码按编码顺序被处理。但在SQL语句中，第一个被处理的子句是FROM，而不是第一出现的SELECT。SQL查询处理的步骤序号：
(8) SELECT (9) DISTINCT (11) <TOP_specification> <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子句中的前两个表执行笛卡尔积(交叉联接)，生成虚拟表VT1。表名执行顺序是从后往前，因此数据较少的表尽可能放后。
二、 ON：对VT1应用ON筛选器，只有那些使为真才被插入到TV2。
三、 OUTER (JOIN):若是指定了OUTER JOIN(相对于CROSS JOIN或INNER JOIN)，保留表中未找到匹配的行将做为外部行添加到VT2，生成TV3。若是FROM子句包含两个以上的表，则对上一个联接生成的结果表和下一个表重复执行步骤1到步骤3，直处处理完全部的表位置。
四、 WHERE：对TV3应用WHERE筛选器，只有使为true的行才插入TV4。执行顺序为从前日后或者说从左到右。
五、 GROUP BY：按GROUP BY子句中的列列表对TV4中的行进行分组，生成TV5。执行顺序从左往右分组。
六、 CUTE|ROLLUP：把超组插入VT5，生成VT6。
七、 HAVING：对VT6应用HAVING筛选器，只有使为true的组插入到VT7。Having语句很耗资源，尽可能少用 八、 SELECT：处理SELECT列表，产生VT8。
九、 DISTINCT：将重复的行从VT8中删除，产品VT9。
十、ORDER BY：将VT9中的行按ORDER BY子句中的列列表顺序，生成一个游标(VC10)。执行顺序从左到右，是一个很耗资源的语句。
十一、TOP：从VC10的开始处选择指定数量或比例的行，生成表TV11，并返回给调用者。并发
看到这里，应该是清楚了整个SQL语句整个执行的过程，那么咱们就接下来进一步要坐得就是在实现功能同时有考虑性能的思想，努力提升SQL的执行效率。oracle
第1、只返回须要的数据
返回数据到客户端至少须要数据库提取数据、网络传输数据、客户端接收数据以及客户端处理数据等环节，若是返回不须要的数据，就会增长服务器、网络和客户端的无效劳动，其害处是显而易见的，避免这类事件须要注意： 编程语言
A、横向来看，
(1)不要写SELECT *的语句，而是选择你须要的字段。
(2)当在SQL语句中链接多个表时, 请使用表的别名并把别名前缀于每一个Column上.这样一来,就能够减小解析的时间并减小那些由Column歧义引发的语法错误。
B、纵向来看，
(1)合理写WHERE子句，不要写没有WHERE的SQL语句。
(2) SELECT TOP N * --没有WHERE条件的用此替代
第2、尽可能少作重复的工做
A、控制同一语句的屡次执行，特别是一些基础数据的屡次执行是不少程序员不多注意的。
B、减小屡次的数据转换，也许须要数据转换是设计的问题，可是减小次数是程序员能够作到的。
C、杜毫不必要的子查询和链接表，子查询在执行计划通常解释成外链接，多余的链接表带来额外的开销。
D、合并对同一表同一条件的屡次UPDATE。
E、UPDATE操做不要拆成DELETE操做+INSERT操做的形式，虽然功能相同，可是性能差异是很大的。
第3、注意临时表和表变量的用法
在复杂系统中，临时表和表变量很难避免，关于临时表和表变量的用法，须要注意：
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。
第4、注意子查询的用法
子查询是一个 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)
第5、尽可能使用索引,并注意对含索引列的运算
创建索引后，并非每一个查询都会使用索引，在使用索引的状况下，索引的使用效率也会有很大的差异。只要咱们在查询语句中没有强制指定索引，索引的选择和使用方法是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'
第6、注意多表链接的链接条件的选择与表示
多表链接的链接条件对索引的选择有着重要的意义，因此咱们在写链接条件条件的时候须要特别注意。
A、多表链接的时候，链接条件必须写全，宁肯重复，不要缺漏。
B、链接条件尽可能使用汇集索引
C、注意ON、WHERE和HAVING部分条件的区别： ON是最早执行， WHERE次之，HAVING最后，由于ON是先把不符合条件的记录过滤后才进行统计，它就能够减小中间运算要处理的数据，按理说应该速度是最快的，WHERE也应该比 HAVING快点的，由于它过滤数据后才进行SUM，在两个表联接时才用ON的，因此在一个表的时候，就剩下WHERE跟HAVING比较了
一、考虑联接优先顺序：
二、INNER JOIN
三、LEFT JOIN (注：RIGHT JOIN 用 LEFT JOIN 替代)
四、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
第7、有效使用Decode函数
使用Decode函数能够有效避免重复扫描相同数据或重复链接相同表。
以上就是此次的总结了，参考了不少文档，网络是个好平台，感谢你们的分享
ORACLE中where部分条件执行顺序测试
实验1：证实oracle SQL的语法分析应该是从右到左的
测试语句
--语句1 Select 'ok' From Dual Where 1 / 0 = 1 And 1 = 2; --语句2 Select 'ok' From Dual Where 1 = 2 And 1 / 0 = 1;
- --语句1
Select '测试' From Dual Where 1 / 0 = 1 And 1 = 2; - 查询结果不会报错
--语句2
Select '测试' From Dual Where 1 = 2 And 1 / 0 = 1; - 查询结果会报错
语句1不会报错，语句2报错
结果：证实了oracle SQL条件的执行是从右到左的