1.1、         尽量多的共享SQL语句‏

SQL语句,在第一次解析之后, ORACLE将SQL语句存放在内存中.这块位于系统全局区域SGA(system global area)的共享池(shared buffer pool)中的内存可以被所有的数据库用户共享. 因此,当你执行一个SQL语句(有时被称为一个游标)时,如果它和之前的执行过的语句完全相同, ORACLE就能很快获得已经被解析的语句以及最好的执行路径. ORACLE的这个功能大大地提高了SQL的执行性能并节省了内存的使用.‏

ORACLE只对简单的表提供高速缓冲(cache buffering) ,这个功能并不适用于多表连接查询.‏

init.ora中为这个区域设置合适的参数,当这个内存区域越大,就可以保留更多的语句,当然被共享的可能性也就越大了.‏

ORACLE 提交一个SQL语句,ORACLE会首先在这块内存中查找相同的语句.‏

,ORACLE对两者采取的是一种严格匹配,要达成共享,SQL语句必须　　完全相同(包括空格,换行等).‏

‏共享的语句必须满足三个条件:‏

A.:‏

.‏

:‏

SELECT * FROM EMP;‏

‏

SELECT * from EMP;‏

Select * From Emp;‏

SELECT　　　*　　 FROM EMP;‏

B.:‏

:‏

‏

SQL语句能否在这两个用户之间共享.‏

‏

C.　　　两个SQL语句中必须使用相同的名字的绑定变量(bind variables)

‏

SQL语句是相同的(可以共享),而第二组中的两个语句是不同的(即使在运行时,赋于不同的绑定变量相同的值)‏

a.‏

select pin , name from people where pin = :blk1.pin;‏

select pin , name from people where pin = :blk1.pin;‏

b.‏

select pin , name from people where pin = :blk1.ot_ind;‏

select pin , name from people where pin = :blk1.ov_ind;‏

1.2、         选择基于CBO的优化策略‏

ORACLE在10G以前的版本提供了CBO，RBO,CHOOSE三种优化策略，从应用效率出发，应选择基于CBO的优化策略。

1.3、         WHERE子句中的连接顺序．‏

ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.‏

:‏

(低效,执行时间156.3秒)‏

SELECT * FROM EMP E‏

WHERE SAL > 50000‏

  AND JOB = ‘MANAGER’‏

  AND 25 < (SELECT COUNT(*) FROM EMP‏

            WHERE MGR=E.EMPNO);‏

(高效,执行时间10.6秒)‏

SELECT * ‏

  FROM EMP E‏

WHERE 25 < (SELECT COUNT(*) FROM EMP‏

             WHERE MGR=E.EMPNO)‏

   AND SAL > 50000‏

AND JOB = ‘MANAGER’;‏

1.4、         减少访问数据库的次数‏

SQL语句时, ORACLE在内部执行了许多工作: 解析SQL语句, 估算索引的利用率, 绑定变量 , 读数据块等等. 由此可见, 减少访问数据库的次数 , 就能实际上减少ORACLE的工作量.‏

,‏

0342或0291的职员.‏

1 (最低效)‏

SELECT EMP_NAME , SALARY , GRADE‏

FROM EMP ‏

WHERE EMP_NO = 342;‏

SELECT EMP_NAME , SALARY , GRADE‏

FROM EMP ‏

WHERE EMP_NO = 291;‏

2 (次低效)‏

    DECLARE ‏

CURSOR C1 (E_NO NUMBER) IS ‏

  SELECT EMP_NAME,SALARY,GRADE‏

   FROM EMP ‏

WHERE EMP_NO = E_NO;‏

BEGIN ‏

OPEN C1(342);‏

FETCH C1 INTO …,..,.. ;‏

…..‏

OPEN C1(291);‏

FETCH C1 INTO …,..,.. ;‏

CLOSE C1;‏

END;‏

3 (高效)‏

SELECT A.EMP_NAME , A.SALARY , A.GRADE,‏

FROM EMP A

WHERE A.EMP_NO  EXISTS  ( 342‏, 291);

1.5、         使用DECODE函数来减少处理时间‏

DECODE函数可以避免重复扫描相同记录或重复连接相同的表.‏

:‏

SELECT COUNT(*)，SUM(SAL)‏

FROM　EMP‏

WHERE DEPT_NO = 0020‏

  AND ENAME LIKE　‘SMITH%’;‏

SELECT COUNT(*)，SUM(SAL)‏

  FROM　EMP‏

WHERE DEPT_NO = 0030‏

  AND ENAME LIKE　‘SMITH%’;‏

DECODE函数高效地得到相同结果‏

SELECT COUNT(DECODE(DEPT_NO,0020,’X’,NULL)) D0020_COUNT,‏

       COUNT(DECODE(DEPT_NO,0030,’X’,NULL)) D0030_COUNT,‏

       SUM(DECODE(DEPT_NO,0020,SAL,NULL)) D0020_SAL,‏

       SUM(DECODE(DEPT_NO,0030,SAL,NULL)) D0030_SAL‏

FROM EMP WHERE ENAME LIKE ‘SMITH%’;‏

类似的,DECODE函数也可以运用于GROUP BY 和ORDER BY子句中.‏

1.6、         用TRUNCATE替代DELETE‏

,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是‏恢复到执行删除命令之前的状况)

而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短.‏

1.7、         尽量多使用COMMIT‏

,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:‏

‏COMMIT所释放的资源:‏

‏a. 回滚段上用于恢复数据的信息.

b. 被程序语句获得的锁‏

c. redo log buffer 中的空间‏

d. ORACLE为管理上述3种资源中的内部花费‏

‏

1.8、         用Where子句替换HAVING子句‏

HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销.‏

:

低效:‏

SELECT REGION，AVG(LOG_SIZE)‏

FROM LOCATION‏

GROUP BY REGION‏

HAVING REGION REGION != ‘SYDNEY’‏

    AND REGION != ‘PERTH’‏

‏

‏

SELECT REGION，AVG(LOG_SIZE)‏

FROM LOCATION‏

WHERE REGION REGION != ‘SYDNEY’‏

   AND REGION != ‘PERTH’‏

GROUP BY REGION‏

‏‏

1.9、         减少对表的查询‏

‏在含有子查询的SQL语句中,要特别注意减少对表的查询.‏

: ‏

‏

‏SELECT TAB_NAME‏

FROM TABLES‏

WHERE TAB_NAME = ( SELECT TAB_NAME ‏

                     FROM TAB_COLUMNS‏

                   WHERE VERSION = 604)‏

  AND DB_VER= ( SELECT DB_VER ‏

                 FROM TAB_COLUMNS‏

                 WHERE VERSION = 604)‏;

‏

‏

SELECT TAB_NAME‏

FROM TABLES‏

WHERE (TAB_NAME,DB_VER)‏

     = ( SELECT TAB_NAME,DB_VER ‏

         FROM TAB_COLUMNS‏

        WHERE VERSION = 604)‏;

‏

Update 多个Column 例子:‏

:‏

‏UPDATE EMP‏

    SET EMP_CAT = (SELECT MAX(CATEGORY) FROM EMP_CATEGORIES),‏

    SAL_RANGE = (SELECT MAX(SAL_RANGE) FROM EMP_CATEGORIES)‏

WHERE EMP_DEPT = 0020;‏

‏

:‏

UPDATE EMP‏

    SET (EMP_CAT, SAL_RANGE)‏

        = (SELECT MAX(CATEGORY) , MAX(SAL_RANGE)‏

            FROM EMP_CATEGORIES)‏

WHERE EMP_DEPT = 0020;‏

1.10、    通过内部函数提高SQL效率.‏

SELECT H.EMPNO,E.ENAME,H.HIST_TYPE,T.TYPE_DESC,COUNT(*)‏

  FROM HISTORY_TYPE T,EMP E,EMP_HISTORY H‏

WHERE H.EMPNO = E.EMPNO‏

AND H.HIST_TYPE = T.HIST_TYPE‏

GROUP BY H.EMPNO,E.ENAME,H.HIST_TYPE,T.TYPE_DESC;‏

‏

.‏

‏FUNCTION LOOKUP_HIST_TYPE(TYP IN NUMBER) RETURN VARCHAR2‏

AS‏

TDESC VARCHAR2(30);‏

CURSOR C1 IS ‏

SELECT TYPE_DESC ‏

FROM HISTORY_TYPE‏

WHERE HIST_TYPE = TYP;‏

BEGIN ‏

OPEN C1;‏

FETCH C1 INTO TDESC;‏

CLOSE C1;‏

RETURN (NVL(TDESC,’?’));‏

END;‏

‏

FUNCTION LOOKUP_EMP(EMP IN NUMBER) RETURN VARCHAR2‏

AS‏

ENAME VARCHAR2(30);‏

CURSOR C1 IS ‏

SELECT ENAME‏

FROM EMP‏

WHERE EMPNO=EMP;‏

‏

BEGIN ‏

OPEN C1;‏

FETCH C1 INTO ENAME;‏

CLOSE C1;‏

RETURN (NVL(ENAME,’?’));‏

END;‏

‏

SELECT H.EMPNO,LOOKUP_EMP(H.EMPNO),‏

       H.HIST_TYPE,LOOKUP_HIST_TYPE(H.HIST_TYPE),COUNT(*)‏

FROM EMP_HISTORY H‏

GROUP BY H.EMPNO , H.HIST_TYPE;‏

‏

1.11、    使用表的别名(Alias)‏

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

‏

1.12、    用EXISTS替代IN‏

,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率.‏

‏

:‏

SELECT * ‏

FROM EMP (基础表)‏

WHERE EMPNO > 0‏

   AND DEPTNO IN (SELECT DEPTNO ‏

                     FROM DEPT ‏

                    WHERE LOC = ‘MELB’)‏;

:‏

SELECT * ‏

FROM EMP ‏

WHERE EMPNO > 0‏

   AND EXISTS (SELECT ‘X’ ‏

                 FROM DEPT ‏

                WHERE DEPT.DEPTNO = EMP.DEPTNO‏

                   AND LOC = ‘MELB’)‏;

1.13、    用NOT EXISTS替代NOT IN‏

‏在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以使用NOT EXISTS.‏

:‏

SELECT …‏

FROM EMP‏

WHERE DEPT_NO NOT IN (SELECT DEPT_NO ‏FROM DEPT ‏

                         WHERE DEPT_CAT=’A’);‏

.改写为:‏

SELECT ….‏

FROM EMP E‏

WHERE DEPT_NO NOT EXISTS (SELECT ‘X’ ‏ FROM DEPT D‏

                              WHERE D.DEPT_NO = E.DEPT_NO‏

AND DEPT_CAT = ‘A’);

1.14、    用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核心模块将在子查询的条件一旦满足后,立刻返回结果.‏

‏

1.15、    用索引提高效率‏

索引是表的一个概念部分,用来提高检索数据的效率. 实际上,ORACLE使用了一个复杂的自平衡B-tree结构. 通常,通过索引查询数据比全表扫描要快. 当ORACLE找出执行查询和Update语句的最佳路径时, ORACLE优化器将使用索引. 同样在联结多个表时使用索引也可以提高效率. 另一个使用索引的好处是,它提供了主键(primary key)的唯一性验证. ‏

除了那些LONG或LONG RAW数据类型, 你可以索引几乎所有的列. 通常, 在大型表中使用索引特别有效. 当然,你也会发现, 在扫描小表时,使用索引同样能提高效率. ‏

虽然使用索引能得到查询效率的提高,但是我们也必须注意到它的代价. 索引需要空间来存储,也需要定期维护, 每当有记录在表中增减或索引列被修改时, 索引本身也会被修改. 这意味着每条记录的INSERT , DELETE , UPDATE将为此多付出4 , 5 次的磁盘I/O . 因为索引需要额外的存储空间和处理,那些不必要的索引反而会使查询反应时间变慢. ‏

‏

1.16、    索引的操作‏

‏ORACLE对索引有两种访问模式. ‏

1．索引唯一扫描 ( 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'; ‏

‏2.索引范围查询(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)开始, 索引将不被采用. ‏

SELECT LODGING ‏

‏  FROM LODGING ‏

‏WHERE MANAGER LIKE ‘％HANMAN'; ‏

‏在这种情况下，ORACLE将使用全表扫描.

‏

1.17、    多个平等的索引 ‏

‏       当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 ‏

‏

1.18、    等式比较和范围比较 ‏

当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 ‏

‏

1.19、    不明确的索引等级 ‏

‏       当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是唯一性索引,但是由于它所做的是范围比较, 等级要比非唯一性索引的等式比较低!

1.20、    强制索引失效 ‏

‏       如果两个或以上索引具有相同的等级,你可以强制命令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'; ‏

1.21、    避免在索引列上使用计算． ‏

WHERE子句中，如果索引列是函数的一部分．优化器将不使用索引而使用全表扫描。

‏举例:

低效： ‏

SELECT … ‏

FROM DEPT ‏

WHERE SAL * 12 > 25000; ‏

‏

高效: ‏

SELECT … ‏

FROM DEPT ‏

WHERE SAL > 25000/12; ‏

‏

‏

1.22、    自动选择索引 ‏

如果表中有两个以上（包括两个）索引，其中有一个唯一性索引，而其他是非唯一性．在这种情况下，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 ‏

1.23、    用>=替代> ‏

如果DEPTNO上有一个索引, ‏

‏

高效: ‏

SELECT * ‏

FROM EMP ‏

WHERE DEPTNO >=4 ‏

低效: ‏

SELECT * ‏

FROM EMP ‏

WHERE DEPTNO >3 ‏

两者的区别在于, 前者DBMS将直接跳到第一个DEPT等于4的记录而后者将首先定位到DEPTNO=3的记录并且向前扫描到第一个DEPT大于3的记录。

1.24、    用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) ‏

1.25、    避免在索引列上使用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;

1.26、    总是使用索引的第一个列 ‏

‏       如果索引是建立在多个列上, 只有在它的第一个列(leading column)被where子句引用时,优化器才会选择使用该索引。

‏‏

1.27、    用UNION-ALL 替换UNION ( 如果有可能的话) ‏

‏       SQL语句需要UNION两个查询结果集合时,这两个结果集会以UNIONALL的方式被合并, 然后在输出最终结果前进行排序. ‏如果用UNIONALL替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' ‏

‏

1.28、    使用提示(Hints) ‏

‏对于表的访问,可以使用两种Hints. ：‏FULL 和 ROWID ‏。

‏1、FULL hint 告诉ORACLE使用全表扫描的方式访问指定表. ‏

例如:

SELECT /*+ FULL(EMP) */ * ‏

‏  FROM EMP ‏

‏WHERE EMPNO = 7893; ‏

‏

2、ROWID hint 告诉ORACLE使用TABLE ACCESS BY ROWID操作访问表. ‏      通常, 你需要采用TABLE ACCESS BY ROWID的方式特别是当访问大表的时候, 使用这种方式, 你需要知道ROWID的值或者使用索引。如果一个大表没有被设定为缓存(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 等等. ‏‏

1.29、    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 ‏

1.30、    避免改变索引列的类型. ‏

‏当比较不同数据类型的数据时, 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 ‏

因为内部发生的类型转换, 这个索引将不会被用到! ‏

1.31、    需要当心的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'; /*将使用索引*/

1.32、    CBO下使用更具选择性的索引 ‏

‏       基于成本的优化器(CBO, Cost-Based Optimizer)对索引的选择性进行判断来决定索引的使用是否能提高效率. 如果索引有很高的选择性, 那就是说对于每个不重复的索引键值,只对应数量很少的记录. 比如, 表中共有100条记录而其中有80个不重复的索引键值. 这个索引的选择性就是80/100 = 0.8 . 选择性越高, 通过索引键值检索出的记录就越少. 如果索引的选择性很低, 检索数据就需要大量的索引范围查询操作和ROWID 访问表的操作. 也许会比全表扫描的效率更低，可以参阅下面的经验：

‏a. 如果检索数据量超过30%的表中记录数.使用索引将没有显著的效率提高。

b. 在特定情况下, 使用索引也许会比全表扫描慢, 但这是同一个数量级上的区别. 而通常情况下,使用索引比全表扫描要块几倍乃至几千倍。

1.33、    避免使用耗费资源的操作 ‏

‏       带有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也是可以考虑的, 毕竟它们的可读性很强。‏

1.34、    分离表和索引 ‏

‏    总是将你的表和索引建立在不同的表空间内(TABLESPACES). 决不要将不属于ORACLE内部系统的对象存放到SYSTEM表空间里. 同时,确保数据表空间和索引表空间置于不同的硬盘上。

1.35、    尽量建好和使用好索引

建索引也是有讲究的，在建索引时，也不是索引越多越好，当一个表的索引达到4个以上时，ORACLE的性能可能还是改善不了，因为OLTP系统每表超过5个索引即会降低性能，而且在一个sql 中， Oracle 从不能使用超过 5个索引；当我们用到GROUP BY和ORDER BY时,ORACLE就会自动对数据进行排序,而ORACLE在INIT.ORA中决定了sort_area_size区的大小,当排序不能在我们给定的排序区完成时,ORACLE就会在磁盘中进行排序,也就是我们讲的临时表空间中排序, 过多的磁盘排序将会令 free buffer waits 的值变高,而这个区间并不只是用于排序的,对于开发人员我提出如下忠告:

1)、select,update,delete 语句中的子查询应当有规律地查找少于20%的表行.如果一个语句查找的行数超过总行数的20%,它将不能通过使用索引获得性能上的提高.

2）、索引可能产生碎片,因为记录从表中删除时,相应也从表的索引中删除.表释放的空间可以再用,而索引释放的空间却不能再用.频繁进行删除操作的被索引的表,应当阶段性地重建索引,以避免在索引中造成空间碎片,影响性能.在许可的条件下,也可以阶段性地truncate表,truncate命令删除表中所有记录,也删除索引碎片.

3）、在使用索引时一定要按索引对应字段的顺序进行引用。

4）、用（+）比用NOT IN更有效率。