21. 用EXISTS替换DISTINCT
当提交一个包含一对多表信息(比如部门表和雇员表)的查询时,避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换
例如:
低效:
SELECT DISTINCT DEPT_NO,DEPT_NAME
FROM DEPT D,EMP E
WHERE D.DEPT_NO = E.DEPT_NO
高效:
SELECT DEPT_NO,DEPT_NAME
FROM DEPT D
WHERE EXISTS ( SELECT ‘X’
FROM EMP E
WHERE E.DEPT_NO = D.DEPT_NO);
EXISTS 使查询更为迅速,因为RDBMS核心模块将在子查询的条件一旦满足后,立刻返回结果.
22. 识别’低效执行’的SQL语句
用下列SQL工具找出低效SQL:
SELECT EXECUTIONS , DISK_READS, BUFFER_GETS,
ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_radio,
ROUND(DISK_READS/EXECUTIONS,2) Reads_per_run,
SQL_TEXT
FROM V$SQLAREA
WHERE EXECUTIONS>0
AND BUFFER_GETS > 0
AND (BUFFER_GETS-DISK_READS)/BUFFER_GETS < 0.8
ORDER BY 4 DESC;
(译者按: 虽然目前各种关于SQL优化的图形化工具层出不穷,但是写出自己的SQL工具来解决问题始终是一个最好的方法)
23. 使用TKPROF 工具来查询SQL性能状态
SQL trace 工具收集正在执行的SQL的性能状态数据并记录到一个跟踪文件中. 这个跟踪文件提供了许多有用的信息,例如解析次数.执行次数,CPU使用时间等.这些数据将可以用来优化你的系统.
设置SQL TRACE在会话级别: 有效
ALTER SESSION SET SQL_TRACE TRUE
设置SQL TRACE 在整个数据库有效仿, 你必须将SQL_TRACE参数在init.ora中设为TRUE, USER_DUMP_DEST参数说明了生成跟踪文件的目录
(译者按: 这一节中,作者并没有提到TKPROF的用法, 对SQL TRACE的用法也不够准确, 设置SQL TRACE首先要在init.ora中设定TIMED_STATISTICS, 这样才能得到那些重要的时间状态. 生成的trace文件是不可读的,所以要用TKPROF工具对其进行转换,TKPROF有许多执行参数. 大家可以参考ORACLE手册来了解具体的配置. )
24. 用EXPLAIN PLAN 分析SQL语句
EXPLAIN PLAN 是一个很好的分析SQL语句的工具,它甚至可以在不执行SQL的情况下分析语句. 通过分析,我们就可以知道ORACLE是怎么样连接表,使用什么方式扫描表(索引扫描或全表扫描)以及使用到的索引名称.
你需要按照从里到外,从上到下的次序解读分析的结果. EXPLAIN PLAN分析的结果是用缩进的格式排列的, 最内部的操作将被最先解读, 如果两个操作处于同一层中,带有最小操作号的将被首先执行.
NESTED LOOP是少数不按照上述规则处理的操作, 正确的执行路径是检查对NESTED LOOP提供数据的操作,其中操作号最小的将被最先处理.
译者按:
通过实践, 感到还是用SQLPLUS中的SET TRACE 功能比较方便.
举例:
SQL> list
1 SELECT *
2 FROM dept, emp
3* WHERE emp.deptno = dept.deptno
SQL> set autotrace traceonly /*traceonly 可以不显示执行结果*/
SQL> /
14 rows selected.
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 NESTED LOOPS
2 1 TABLE ACCESS (FULL) OF 'EMP'
3 1 TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'
4 3 INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)
Statistics
----------------------------------------------------------
0 recursive calls
2 db block gets
30 consistent gets
0 physical reads
0 redo size
2598 bytes sent via SQL*Net to client
503 bytes received via SQL*Net from client
2 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
14 rows processed
通过以上分析,可以得出实际的执行步骤是:
1. TABLE ACCESS (FULL) OF 'EMP'
2. INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)
3. TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'
4. NESTED LOOPS (JOINING 1 AND 3)
注: 目前许多第三方的工具如TOAD和ORACLE本身提供的工具如OMS的SQL Analyze都提供了极其方便的EXPLAIN PLAN工具.也许喜欢图形化界面的朋友们可以选用它们.
25. 用索引提高效率
索引是表的一个概念部分 , 用来提高检索数据的效率 . 实际上 ,ORACLE 使用了一个复杂的自平衡 B-tree 结构 . 通常 , 通过索引查询数据比全表扫描要快 . 当 ORACLE 找出执行查询和 Update 语句的最佳路径时 , ORACLE 优化器将使用索引 . 同样在联结多个表时使用索引也可以提高效率 . 另一个使用索引的好处是 , 它提供了主键 (primary key) 的唯一性验证 .
除了那些 LONG 或 LONG RAW 数据类型 , 你可以索引几乎所有的列 . 通常 , 在大型表中使用索引特别有效 . 当然 , 你也会发现 , 在扫描小表时 , 使用索引同样能提高效率 .
虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来
存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢.
译者按:
定期的重构索引是有必要的.
ALTER INDEX <INDEXNAME> REBUILD <TABLESPACENAME>
26. 索引的操作
ORACLE 对索引有两种访问模式 .
索引唯一扫描 ( INDEX UNIQUE SCAN)
大多数情况下 , 优化器通过 WHERE 子句访问 INDEX.
例如 :
表 LODGING 有两个索引 : 建立在 LODGING 列上的唯一性索引 LODGING_PK 和建立在 MANAGER 列上的非唯一性索引 LODGING$MANAGER.
SELECT *
FROM LODGING
WHERE LODGING = ‘ROSE HILL’;
在内部 , 上述 SQL 将被分成两步执行 , 首先 , LODGING_PK 索引将通过索引唯一扫描的方式被访问 , 获得相对应的 ROWID, 通过 ROWID 访问表的方式 执行下一步检索 .
如果被检索返回的列包括在 INDEX 列中 ,ORACLE 将不执行第二步的处理 ( 通过 ROWID 访问表 ). 因为检索数据保存在索引中 , 单单访问索引就可以完全满足查询结果 .
下面 SQL 只需要 INDEX UNIQUE SCAN 操作 .
SELECT LODGING
FROM LODGING
WHERE LODGING = ‘ROSE HILL’;
索引范围查询 (INDEX RANGE SCAN)
适用于两种情况 :
1. 基于一个范围的检索
2. 基于非唯一性索引的检索
例 1:
SELECT LODGING
FROM LODGING
WHERE LODGING LIKE ‘M%’;
WHERE 子句条件包括一系列值 , ORACLE 将通过索引范围查询的方式查询 LODGING_PK . 由于索引范围查询将返回一组值 , 它的效率就要比索引唯一扫描
低一些 .
例 2:
SELECT LODGING
FROM LODGING
WHERE MANAGER = ‘BILL GATES’;
这个 SQL 的执行分两步 , LODGING$MANAGER 的索引范围查询 ( 得到所有符合条件记录的 ROWID) 和下一步同过 ROWID 访问表得到 LODGING 列的值 . 由于 LODGING$MANAGER 是一个非唯一性的索引 , 数据库不能对它执行索引唯一扫描 .
由于 SQL 返回 LODGING 列 , 而它并不存在于 LODGING$MANAGER 索引中 , 所以在索引范围查询后会执行一个通过 ROWID 访问表的操作 .
WHERE子句中, 如果索引列所对应的值的第一个字符由通配符(WILDCARD)开始, 索引将不被采用.在这种情况下，ORACLE将使用全表扫描.
SELECT LODGING
FROM LODGING
WHERE MANAGER LIKE ‘ ％ HANMAN’;
27. 基础表的选择
基础表 (Driving Table) 是指被最先访问的表 ( 通常以全表扫描的方式被访问 ). 根据优化器的不同 , SQL 语句中基础表的选择是不一样的 .
如果你使用的是CBO (COST BASED OPTIMIZER),优化器会检查SQL语句中的每个表的物理大小,索引的状态,然后选用花费最低的执行路径.
如果你用RBO (RULE BASED OPTIMIZER) , 并且所有的连接条件都有索引对应, 在这种情况下, 基础表就是FROM 子句中列在最后的那个表.
举例 :
SELECT A.NAME , B.MANAGER
FROM WORKER A,
LODGING B
WHERE A.LODGING = B.LODING;
由于 LODGING 表的 LODING 列上有一个索引 , 而且 WORKER 表中没有相比较的索引 , WORKER 表将被作为查询中的基础表 .
28. 多个平等的索引
当 SQL 语句的执行路径可以使用分布在多个表上的多个索引时 , ORACLE 会同时使用多个索引并在运行时对它们的记录进行合并 , 检索出仅对全部索引有效的记录 .
在ORACLE选择执行路径时,唯一性索引的等级高于非唯一性索引. 然而这个规则只有
当WHERE子句中索引列和常量比较才有效.如果索引列和其他表的索引类相比较. 这种子句在优化器中的等级是非常低的.
如果不同表中两个想同等级的索引将被引用, FROM子句中表的顺序将决定哪个会被率先使用. FROM子句中最后的表的索引将有最高的优先级.
如果相同表中两个想同等级的索引将被引用, WHERE子句中最先被引用的索引将有最高的优先级.
举例 :
DEPTNO 上有一个非唯一性索引 ,EMP_CAT 也有一个非唯一性索引 .
SELECT ENAME,
FROM EMP
WHERE DEPT_NO = 20
AND EMP_CAT = ‘A’;
这里 ,DEPTNO 索引将被最先检索 , 然后同 EMP_CAT 索引检索出的记录进行合并 . 执行路径如下 :
TABLE ACCESS BY ROWID ON EMP
AND-EQUAL
INDEX RANGE SCAN ON DEPT_IDX
INDEX RANGE SCAN ON CAT_IDX
29. 等式比较和范围比较
当 WHERE 子句中有索引列 , ORACLE 不能合并它们 ,ORACLE 将用范围比较 .
举例 :
DEPTNO 上有一个非唯一性索引 ,EMP_CAT 也有一个非唯一性索引 .
SELECT ENAME
FROM EMP
WHERE DEPTNO > 20
AND EMP_CAT = ‘A’;
这里只有 EMP_CAT 索引被用到 , 然后所有的记录将逐条与 DEPTNO 条件进行比较 . 执行路径如下 :
TABLE ACCESS BY ROWID ON EMP
INDEX RANGE SCAN ON CAT_IDX
30. 不明确的索引等级
当ORACLE无法判断索引的等级高低差别,优化器将只使用一个索引,它就是在WHERE子句中被列在最前面的.
举例 :
DEPTNO 上有一个非唯一性索引 ,EMP_CAT 也有一个非唯一性索引 .
SELECT ENAME
FROM EMP
WHERE DEPTNO > 20
AND EMP_CAT > ‘A’;
这里 , ORACLE 只用到了 DEPT_NO 索引 . 执行路径如下 :
TABLE ACCESS BY ROWID ON EMP
INDEX RANGE SCAN ON DEPT_IDX
译者按:
我们来试一下以下这种情况:
SQL> select index_name, uniqueness from user_indexes where table_name = 'EMP';
INDEX_NAME UNIQUENES
------------------------------ ---------
EMPNO UNIQUE
EMPTYPE NONUNIQUE
SQL> select * from emp where empno >= 2 and emp_type = 'A' ;
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS (BY INDEX ROWID) OF 'EMP'
2 1 INDEX (RANGE SCAN) OF 'EMPTYPE' (NON-UNIQUE)
虽然EMPNO是唯一性索引,但是由于它所做的是范围比较, 等级要比非唯一性索引的等式比较低!
31. 强制索引失效
如果两个或以上索引具有相同的等级 , 你可以强制命令 ORACLE 优化器使用其中的一个 ( 通过它 , 检索出的记录数量少 ) .
举例 :
SELECT ENAME
FROM EMP
WHERE EMPNO = 7935
AND DEPTNO + 0 = 10 /*DEPTNO上的索引将失效*/
AND EMP_TYPE || ‘’ = ‘A’ /*EMP_TYPE上的索引将失效*/
这是一种相当直接的提高查询效率的办法 . 但是你必须谨慎考虑这种策略 , 一般来说 , 只有在你希望单独优化几个 SQL 时才能采用它 .
这里有一个例子关于何时采用这种策略 ,
假设在 EMP 表的 EMP_TYPE 列上有一个非唯一性的索引而 EMP_CLASS 上没有索引 .
SELECT ENAME
FROM EMP
WHERE EMP_TYPE = ‘A’
AND EMP_CLASS = ‘X’;
优化器会注意到 EMP_TYPE 上的索引并使用它 . 这是目前唯一的选择 . 如果 , 一段时间以后 , 另一个非唯一性建立在 EMP_CLASS 上 , 优化器必须对两个索引进行选择 , 在通常情况下 , 优化器将使用两个索引并在他们的结果集合上执行排序及合并 . 然而 , 如果其中一个索引（ EMP_TYPE ）接近于唯一性而另一个索引（ EMP_CLASS ）上有几千个重复的值 . 排序及合并就会成为一种不必要的负担 . 在这种情况下 , 你希望使优化器屏蔽掉 EMP_CLASS 索引 .
用下面的方案就可以解决问题 .
SELECT ENAME
FROM EMP
WHERE EMP_TYPE = ‘A’
AND EMP_CLASS ||’’ = ‘X’;
32. 避免在索引列上使用计算．
WHERE子句中，如果索引列是函数的一部分．优化器将不使用索引而使用全表扫描．
举例 :
低效：
SELECT …
FROM DEPT
WHERE SAL * 12 > 25000;
高效 :
SELECT …
FROM DEPT
WHERE SAL > 25000/12;
译者按:
这是一个非常实用的规则，请务必牢记
33. 自动选择索引
如果表中有两个以上（包括两个）索引，其中有一个唯一性索引，而其他是非唯一性．
在这种情况下，ORACLE将使用唯一性索引而完全忽略非唯一性索引．
举例 :
SELECT ENAME
FROM EMP
WHERE EMPNO = 2326
AND DEPTNO = 20 ;
这里，只有 EMPNO 上的索引是唯一性的，所以 EMPNO 索引将用来检索记录．
TABLE ACCESS BY ROWID ON EMP
INDEX UNIQUE SCAN ON EMP_NO_IDX
34. 避免在索引列上使用NOT
通常，我们要避免在索引列上使用 NOT, NOT 会产生在和在索引列上使用函数相同的
影响 . 当 ORACLE” 遇到 ”NOT, 他就会停止使用索引转而执行全表扫描 .
举例 :
低效 : ( 这里 , 不使用索引 )
SELECT …
FROM DEPT
WHERE DEPT_CODE NOT = 0;
高效 : ( 这里 , 使用了索引 )
SELECT …
FROM DEPT
WHERE DEPT_CODE > 0;
需要注意的是,在某些时候, ORACLE优化器会自动将NOT转化成相对应的关系操作符 .
NOT > to <=
NOT >= to <
NOT < to >=
NOT <= to >
译者按:
在这个例子中,作者犯了一些错误. 例子中的低效率SQL是不能被执行的.
我做了一些测试:
SQL> select * from emp where NOT empno > 1;
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS (BY INDEX ROWID) OF 'EMP'
2 1 INDEX (RANGE SCAN) OF 'EMPNO' (UNIQUE)
SQL> select * from emp where empno <= 1;
no rows selected
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS (BY INDEX ROWID) OF 'EMP'
2 1 INDEX (RANGE SCAN) OF 'EMPNO' (UNIQUE)
两者的效率完全一样，也许这符合作者关于” 在某些时候, ORACLE优化器会自动将NOT转化成相对应的关系操作符” 的观点．
35. 用>=替代>
如果 DEPTNO 上有一个索引 ,
高效 :
SELECT *
FROM EMP
WHERE DEPTNO >=4
低效 :
SELECT *
FROM EMP
WHERE DEPTNO >3
两者的区别在于 , 前者 DBMS 将直接跳到第一个 DEPT 等于 4 的记录而后者将首先定位到 DEPTNO=3 的记录并且向前扫描到第一个 DEPT 大于 3 的记录 .
36. 用UNION替换OR (适用于索引列)
通常情况下 , 用 UNION 替换 WHERE 子句中的 OR 将会起到较好的效果 . 对索引列使用OR将造成全表扫描.注意, 以上规则只针对多个索引列有效. 如果有column没有被索引, 查询效率可能会因为你没有选择OR而降低.
在下面的例子中 , LOC_ID 和 REGION 上 都建有索引 .
高效 :
SELECT LOC_ID , LOC_DESC , REGION
FROM LOCATION
WHERE LOC_ID = 10
UNION
SELECT LOC_ID , LOC_DESC , REGION
FROM LOCATION
WHERE REGION = “MELBOURNE”
低效 :
SELECT LOC_ID , LOC_DESC , REGION
FROM LOCATION
WHERE LOC_ID = 10 OR REGION = “MELBOURNE”
如果你坚持要用 OR, 那就需要返回记录最少的索引列写在最前面 .
注意 :
WHERE KEY1 = 10 ( 返回最少记录 )
OR KEY2 = 20 ( 返回最多记录 )
ORACLE 内部将以上转换为
WHERE KEY1 = 10 AND
((NOT KEY1 = 10) AND KEY2 = 20)
译者按:
下面的测试数据仅供参考: (a = 1003 返回一条记录 , b = 1 返回1003条记录)
SQL> select * from unionvsor /*1st test*/
2 where a = 1003 or b = 1;
1003 rows selected.
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 CONCATENATION
2 1 TABLE ACCESS (BY INDEX ROWID) OF 'UNIONVSOR'
3 2 INDEX (RANGE SCAN) OF 'UB' (NON-UNIQUE)
4 1 TABLE ACCESS (BY INDEX ROWID) OF 'UNIONVSOR'
5 4 INDEX (RANGE SCAN) OF 'UA' (NON-UNIQUE)
Statistics
----------------------------------------------------------
0 recursive calls
0 db block gets
144 consistent gets
0 physical reads
0 redo size
63749 bytes sent via SQL*Net to client
7751 bytes received via SQL*Net from client
68 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1003 rows processed
SQL> select * from unionvsor /*2nd test*/
2 where b = 1 or a = 1003 ;
1003 rows selected.
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 CONCATENATION
2 1 TABLE ACCESS (BY INDEX ROWID) OF 'UNIONVSOR'
3 2 INDEX (RANGE SCAN) OF 'UA' (NON-UNIQUE)
4 1 TABLE ACCESS (BY INDEX ROWID) OF 'UNIONVSOR'
5 4 INDEX (RANGE SCAN) OF 'UB' (NON-UNIQUE)
Statistics
----------------------------------------------------------
0 recursive calls
0 db block gets
143 consistent gets
0 physical reads
0 redo size
63749 bytes sent via SQL*Net to client
7751 bytes received via SQL*Net from client
68 SQL*Net roundtrips to/from client
0 sorts (memory)
0 sorts (disk)
1003 rows processed
SQL> select * from unionvsor /*3rd test*/
2 where a = 1003
3 union
4 select * from unionvsor
5 where b = 1;
1003 rows selected.
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 SORT (UNIQUE)
2 1 UNION-ALL
3 2 TABLE ACCESS (BY INDEX ROWID) OF 'UNIONVSOR'
4 3 INDEX (RANGE SCAN) OF 'UA' (NON-UNIQUE)
5 2 TABLE ACCESS (BY INDEX ROWID) OF 'UNIONVSOR'
6 5 INDEX (RANGE SCAN) OF 'UB' (NON-UNIQUE)
Statistics
----------------------------------------------------------
0 recursive calls
0 db block gets
10 consistent gets
0 physical reads
0 redo size
63735 bytes sent via SQL*Net to client
7751 bytes received via SQL*Net from client
68 SQL*Net roundtrips to/from client
1 sorts (memory)
0 sorts (disk)
1003 rows processed
用UNION的效果可以从consistent gets和 SQL*NET的数据交换量的减少看出
37. 用IN来替换OR
下面的查询可以被更有效率的语句替换 :
低效 :
SELECT….
FROM LOCATION
WHERE LOC_ID = 10
OR LOC_ID = 20
OR LOC_ID = 30
高效
SELECT…
FROM LOCATION
WHERE LOC_IN IN (10,20,30);
译者按:
这是一条简单易记的规则，但是实际的执行效果还须检验，在ORACLE8i下，两者的执行路径似乎是相同的．
38. 避免在索引列上使用IS NULL和IS NOT NULL
避免在索引中使用任何可以为空的列， ORACLE 将无法使用该索引 ．对于单列索引，如果列包含空值，索引中将不存在此记录 . 对于复合索引，如果每个列都为空，索引中同样不存在此记录 . 如果至少有一个列不为空，则记录存在于索引中．
举例 :
如果唯一性索引建立在表的 A 列和 B 列上 , 并且表中存在一条记录的 A,B 值为 (123,null) , ORACLE 将不接受下一条具有相同 A,B 值（ 123,null ）的记录 ( 插入 ). 然而如果
所有的索引列都为空， ORACLE 将认为整个键值为空而空不等于空 . 因此你可以插入 1000
条具有相同键值的记录 , 当然它们都是空 !
因为空值不存在于索引列中 , 所以 WHERE 子句中对索引列进行空值比较将使 ORACLE 停用该索引 .
举例 :
低效 : ( 索引失效 )
SELECT …
FROM DEPARTMENT
WHERE DEPT_CODE IS NOT NULL;
高效 : ( 索引有效 )
SELECT …
FROM DEPARTMENT
WHERE DEPT_CODE >=0;
39. 总是使用索引的第一个列
如果索引是建立在多个列上 , 只有在它的第一个列 (leading column) 被 where 子句引用时 , 优化器才会选择使用该索引 .
译者按:
这也是一条简单而重要的规则. 见以下实例.
SQL> create table multiindexusage ( inda number , indb number , descr varchar2(10));
Table created.
SQL> create index multindex on multiindexusage(inda,indb);
Index created.
SQL> set autotrace traceonly
SQL> select * from multiindexusage where inda = 1;
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS (BY INDEX ROWID) OF 'MULTIINDEXUSAGE'
2 1 INDEX (RANGE SCAN) OF 'MULTINDEX' (NON-UNIQUE)
SQL> select * from multiindexusage where indb = 1;
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS (FULL) OF 'MULTIINDEXUSAGE'
很明显, 当仅引用索引的第二个列时,优化器使用了全表扫描而忽略了索引
40. ORACLE内部操作
当执行查询时 ,ORACLE 采用了内部的操作 . 下表显示了几种重要的内部操作 .
|
ORACLE Clause
|
内部操作
|
|
ORDER BY
|
SORT ORDER BY
|
|
UNION
|
UNION-ALL
|
|
MINUS
|
MINUS
|
|
INTERSECT
|
INTERSECT
|
|
DISTINCT,MINUS,INTERSECT,UNION
|
SORT UNIQUE
|
|
MIN,MAX,COUNT
|
SORT AGGREGATE
|
|
GROUP BY
|
SORT GROUP BY
|
|
ROWNUM
|
COUNT or COUNT STOPKEY
|
|
Queries involving Joins
|
SORT JOIN,MERGE JOIN,NESTED LOOPS
|
|
CONNECT BY
|
CONNECT BY
|
41. 用UNION-ALL 替换UNION ( 如果有可能的话)
当 SQL 语句需要 UNION 两个查询结果集合时 , 这两个结果集合会以 UNION-ALL 的方式被合并 , 然后在输出最终结果前进行排序 .
如果用 UNION ALL 替代 UNION, 这样排序就不是必要了 . 效率就会因此得到提高 .
举例 :
低效：
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = ’31-DEC-95’
UNION
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = ’31-DEC-95’
高效 :
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = ’31-DEC-95’
UNION ALL
SELECT ACCT_NUM, BALANCE_AMT
FROM DEBIT_TRANSACTIONS
WHERE TRAN_DATE = ’31-DEC-95’
译者按:
需要注意的是，UNION ALL 将重复输出两个结果集合中相同记录. 因此各位还是
要从业务需求分析使用UNION ALL的可行性.
UNION 将对结果集合排序,这个操作会使用到SORT_AREA_SIZE这块内存. 对于这
块内存的优化也是相当重要的. 下面的SQL可以用来查询排序的消耗量
Select substr(name,1,25) "Sort Area Name",
substr(value,1,15) "Value"
from v$sysstat
where name like 'sort%'
42. 使用提示(Hints)
对于表的访问 , 可以使用两种 Hints.
FULL 和 ROWID
FULL hint 告诉 ORACLE 使用全表扫描的方式访问指定表 .
例如 :
SELECT /*+ FULL(EMP) */ *
FROM EMP
WHERE EMPNO = 7893;
ROWID hint 告诉 ORACLE 使用 TABLE ACCESS BY ROWID 的操作访问表 .
通常 , 你需要采用 TABLE ACCESS BY ROWID 的方式特别是当访问大表的时候 , 使用这种方式 , 你需要知道 ROIWD 的值或者使用索引 .
如果一个大表没有被设定为缓存 (CACHED) 表而你希望它的数据在查询结束是仍然停留
在 SGA 中 , 你就可以使用 CACHE hint 来告诉优化器把数据保留在 SGA 中 . 通常 CACHE hint 和 FULL hint 一起使用 .
例如 :
SELECT /*+ FULL(WORKER) CACHE(WORKER)*/ *
FROM WORK;
索引 hint 告诉 ORACLE 使用基于索引的扫描方式 . 你不必说明具体的索引名称
例如 :
SELECT /*+ INDEX(LODGING) */ LODGING
FROM LODGING
WHERE MANAGER = ‘BILL GATES’;
在不使用 hint 的情况下 , 以上的查询应该也会使用索引 , 然而 , 如果该索引的重复值过多而你的优化器是 CBO, 优化器就可能忽略索引 . 在这种情况下 , 你可以用 INDEX hint 强制 ORACLE 使用该索引 .
ORACLE hints 还包括 ALL_ROWS, FIRST_ROWS, RULE,USE_NL, USE_MERGE, USE_HASH 等等 .
译者按:
使用hint , 表示我们对ORACLE优化器缺省的执行路径不满意,需要手工修改.
这是一个很有技巧性的工作. 我建议只针对特定的,少数的SQL进行hint的优化.
对ORACLE的优化器还是要有信心(特别是CBO)
43. 用WHERE替代ORDER BY
ORDER BY 子句只在两种严格的条件下使用索引 .
ORDER BY中所有的列必须包含在相同的索引中并保持在索引中的排列顺序.
ORDER BY中所有的列必须定义为非空.
WHERE子句使用的索引和ORDER BY子句中所使用的索引不能并列.
例如 :
表 DEPT 包含以下列 :
DEPT_CODE PK NOT NULL
DEPT_DESC NOT NULL
DEPT_TYPE NULL
非唯一性的索引 (DEPT_TYPE)
低效 : ( 索引不被使用 )
SELECT DEPT_CODE
FROM DEPT
ORDER BY DEPT_TYPE
EXPLAIN PLAN:
SORT ORDER BY
TABLE ACCESS FULL
高效 : ( 使用索引 )
SELECT DEPT_CODE
FROM DEPT
WHERE DEPT_TYPE > 0
EXPLAIN PLAN:
TABLE ACCESS BY ROWID ON EMP
INDEX RANGE SCAN ON DEPT_IDX
译者按:
ORDER BY 也能使用索引! 这的确是个容易被忽视的知识点. 我们来验证一下:
SQL> select * from emp order by empno;
Execution Plan
----------------------------------------------------------
0 SELECT STATEMENT Optimizer=CHOOSE
1 0 TABLE ACCESS (BY INDEX ROWID) OF 'EMP'
2 1 INDEX (FULL SCAN) OF 'EMPNO' (UNIQUE)
44. 避免改变索引列的类型.
当比较不同数据类型的数据时 , ORACLE 自动对列进行简单的类型转换 .
假设 EMPNO 是一个数值类型的索引列 .
SELECT …
FROM EMP
WHERE EMPNO = ‘123’
实际上 , 经过 ORACLE 类型转换 , 语句转化为 :
SELECT …
FROM EMP
WHERE EMPNO = TO_NUMBER(‘123’)
幸运的是 , 类型转换没有发生在索引列上 , 索引的用途没有被改变 .
现在 , 假设 EMP_TYPE 是一个字符类型的索引列 .
SELECT …
FROM EMP
WHERE EMP_TYPE = 123
这个语句被 ORACLE 转换为 :
SELECT …
FROM EMP
WHERE TO_NUMBER(EMP_TYPE)=123
因为内部发生的类型转换, 这个索引将不会被用到!
译者按:
为了避免ORACLE对你的SQL进行隐式的类型转换, 最好把类型转换用显式表现出来. 注意当字符和数值比较时, ORACLE会优先转换数值类型到字符类型.
45. 需要当心的WHERE子句
某些 SELECT 语句中的 WHERE 子句不使用索引 . 这里有一些例子 .
在下面的例子里 , ‘!=’ 将不使用索引 . 记住 , 索引只能告诉你什么存在于表中, 而不能告诉你什么不存在于表中.
不使用索引 :
SELECT ACCOUNT_NAME
FROM TRANSACTION
WHERE AMOUNT !=0;
使用索引 :
SELECT ACCOUNT_NAME
FROM TRANSACTION
WHERE AMOUNT >0;
下面的例子中 , ‘||’ 是字符连接函数 . 就象其他函数那样 , 停用了索引 .
不使用索引 :
SELECT ACCOUNT_NAME,AMOUNT
FROM TRANSACTION
WHERE ACCOUNT_NAME||ACCOUNT_TYPE=’AMEXA’;
使用索引 :
SELECT ACCOUNT_NAME,AMOUNT
FROM TRANSACTION
WHERE ACCOUNT_NAME = ‘AMEX’
AND ACCOUNT_TYPE=’ A’;
下面的例子中 , ‘+’ 是数学函数 . 就象其他数学函数那样 , 停用了索引 .
不使用索引 :
SELECT ACCOUNT_NAME, AMOUNT
FROM TRANSACTION
WHERE AMOUNT + 3000 >5000;
使用索引 :
SELECT ACCOUNT_NAME, AMOUNT
FROM TRANSACTION
WHERE AMOUNT > 2000 ;
下面的例子中 , 相同的索引列不能互相比较 , 这将会启用全表扫描 .
不使用索引 :
SELECT ACCOUNT_NAME, AMOUNT
FROM TRANSACTION
WHERE ACCOUNT_NAME = NVL(:ACC_NAME,ACCOUNT_NAME);
使用索引 :
SELECT ACCOUNT_NAME, AMOUNT
FROM TRANSACTION
WHERE ACCOUNT_NAME LIKE NVL(:ACC_NAME,’%’);
译者按:
如果一定要对使用函数的列启用索引, ORACLE新的功能: 基于函数的索引(Function-Based Index) 也许是一个较好的方案.
CREATE INDEX EMP_I ON EMP (UPPER(ename)); /*建立基于函数的索引*/
SELECT * FROM emp WHERE UPPER(ename) = ‘BLACKSNAIL’; /*将使用索引*/
46. 连接多个扫描
如果你对一个列和一组有限的值进行比较 , 优化器可能执行多次扫描并对结果进行合并连接 .
举例 :
SELECT *
FROM LODGING
WHERE MANAGER IN (‘BILL GATES’,’KEN MULLER’);
优化器可能将它转换成以下形式
SELECT *
FROM LODGING
WHERE MANAGER = ‘BILL GATES’
OR MANAGER = ’KEN MULLER’;
当选择执行路径时 , 优化器可能对每个条件采用 LODGING$MANAGER 上的索引范围扫描 . 返回的 ROWID 用来访问 LODGING 表的记录 ( 通过 TABLE ACCESS BY ROWID 的方式 ). 最后两组记录以连接 (CONCATENATION) 的形式被组合成一个单一的集合 .
Explain Plan :
SELECT STATEMENT Optimizer=CHOOSE
CONCATENATION
TABLE ACCESS (BY INDEX ROWID) OF LODGING
INDEX (RANGE SCAN ) OF LODGING$MANAGER (NON-UNIQUE)
TABLE ACCESS (BY INDEX ROWID) OF LODGING
INDEX (RANGE SCAN ) OF LODGING$MANAGER (NON-UNIQUE)
译者按:
本节和第37节似乎有矛盾之处.
47. CBO下使用更具选择性的索引
基于成本的优化器 (CBO, Cost-Based Optimizer) 对索引的选择性进行判断来决定索引的使用是否能提高效率 .
如果索引有很高的选择性 , 那就是说对于每个不重复的索引键值 , 只对应数量很少的记录 .
比如 , 表中共有 100 条记录而其中有 80 个不重复的索引键值 . 这个索引的选择性就是 80/100 = 0.8 . 选择性越高 , 通过索引键值检索出的记录就越少 .
如果索引的选择性很低 , 检索数据就需要大量的索引范围查询操作和 ROWID 访问表的
操作 . 也许会比全表扫描的效率更低 .
译者按:
下列经验请参阅:
a. 如果检索数据量超过30%的表中记录数.使用索引将没有显著的效率提高.
b. 在特定情况下, 使用索引也许会比全表扫描慢, 但这是同一个数量级上的
区别. 而通常情况下,使用索引比全表扫描要快几倍乃至几千倍!
48. 避免使用耗费资源的操作
带有 DISTINCT,UNION,MINUS,INTERSECT,ORDER BY 的 SQL 语句会启动 SQL 引擎
执行耗费资源的排序 (SORT) 功能 . DISTINCT需要一次排序操作, 而其他的至少需要执行两次排序.
例如 , 一个 UNION 查询 , 其中每个查询都带有 GROUP BY 子句 , GROUP BY 会触发嵌入排序 (NESTED SORT) ; 这样 , 每个查询需要执行一次排序 , 然后在执行 UNION 时 , 又一个唯一排序 (SORT UNIQUE) 操作被执行而且它只能在前面的嵌入排序结束后才能开始执行 . 嵌入的排序的深度会大大影响查询的效率 .
通常 , 带有 UNION, MINUS , INTERSECT 的 SQL 语句都可以用其他方式重写 .
译者按:
如果你的数据库的SORT_AREA_SIZE调配得好, 使用UNION , MINUS, INTERSECT也是可以考虑的, 毕竟它们的可读性很强
49. 优化GROUP BY
提高GROUP BY 语句的效率, 可以通过将不需要的记录在GROUP BY 之前过滤掉. 下面两个查询返回相同结果但第二个明显就快了许多 .
低效 :
SELECT JOB , AVG(SAL)
FROM EMP
GROUP by JOB
HAVING JOB = ‘PRESIDENT’
OR JOB = ‘MANAGER’
高效 :
SELECT JOB , AVG(SAL)
FROM EMP
WHERE JOB = ‘PRESIDENT’
OR JOB = ‘MANAGER’
GROUP by JOB
译者按:
本节和14节相同. 可略过.
50. 使用日期
当使用日期是,需要注意如果有超过5位小数加到日期上, 这个日期会进到下一天!
例如 :
1.
SELECT TO_DATE(‘01-JAN-93’+.99999)
FROM DUAL;
Returns:
’01-JAN-93 23:59:59’
2.
SELECT TO_DATE(‘01-JAN-93’+.999999)
FROM DUAL;
Returns:
’02-JAN-93 00:00:00’
译者按:
虽然本节和SQL性能优化没有关系, 但是作者的功力可见一斑
51. 使用显式的游标(CURSORs)
使用隐式的游标 , 将会执行两次操作 . 第一次检索记录 , 第二次检查 TOO MANY ROWS 这个 exception . 而显式游标不执行第二次操作 .
52. 优化EXPORT和IMPORT
使用较大的BUFFER(比如10MB , 10,240,000)可以提高EXPORT和IMPORT的速度.
ORACLE将尽可能地获取你所指定的内存大小,即使在内存不满足,也不会报错.这个值至少要和表中最大的列相当,否则列值会被截断.
译者按:
可以肯定的是, 增加BUFFER会大大提高EXPORT , IMPORT的效率. (曾经碰到过一个CASE, 增加BUFFER后,IMPORT/EXPORT快了10倍!)
作者可能犯了一个错误: “这个值至少要和表中最大的列相当,否则列值会被截断. “
其中最大的列也许是指最大的记录大小.
关于EXPORT/IMPORT的优化,CSDN论坛中有一些总结性的贴子,比如关于BUFFER参数, COMMIT参数等等, 详情请查.
53. 分离表和索引
总是将你的表和索引建立在不同的表空间内 (TABLESPACES). 决不要将不属于ORACLE内部系统的对象存放到SYSTEM表空间里. 同时,确保数据表空间和索引表空间置于不同的硬盘上.
译者按:
“同时,确保数据表空间和索引表空间置与不同的硬盘上.”可能改为如下更为准确 “同时,确保数据表空间和索引表空间置与不同的硬盘控制卡控制的硬盘上.”