sql优化相干-2

sql优化相关-2

SELECT?*?from?EMP;
Select?*?From?Emp;
SELECT?*?FROM?EMP;?

?

B.两个语句所指的对象必须完全相同：

例如：

用户对象名如何访问

?

Jack?sal_limit?private?synonym
Work_city?public?synonym
Plant_detail?public?synonym
Jill?sal_limit?private?synonym
Work_city?public?synonym
Plant_detail?table?owner?

?

考虑一下下列SQL语句能否在这两个用户之间共享。

SQL能否共享原因

select max(sal_cap) from sal_limit；不能每个用户都有一个private synonym - sal_limit，它们是不同的对象

select count(*0 from work_city where sdesc like 'NEW%'；能两个用户访问相同的对象public synonym - work_city

select a.sdesc，b.location from work_city a，plant_detail b where a.city_id = b.city_id不能用户jack通过private synonym访问plant_detail而jill是表的所有者，对象不同。

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;?

?

　　4.选择最有效率的表名顺序(只在基于规则的优化器中有效)

Oracle的解析器按照从右到左的顺序处理FROM子句中的表名，因此FROM子句中写在最后的表(基础表 driving table)将被最先处理。在FROM子句中包含多个表的情况下，你必须选择记录条数最少的表作为基础表。当Oracle处理多个表时，会运用排序及合并的方式连接它们。首先，扫描第一个表(FROM子句中最后的那个表)并对记录进行派序，然后扫描第二个表(FROM子句中最后第二个表)，最后将所有从第二个表中检索出的记录与第一个表中合适记录进行合并。

例如：

表TAB1 16，384 条记录

表TAB2 1条记录

选择TAB2作为基础表(最好的方法)

select count(*) from tab1，tab2 执行时间0.96秒

选择TAB2作为基础表(不佳的方法)　

select count(*) from tab2，tab1 执行时间26.09秒

如果有3个以上的表连接查询，那就需要选择交叉表(intersection table)作为基础表，交叉表是指那个被其他表所引用的表。

例如：EMP表描述了LOCATION表和CATEGORY表的交集。

?

SELECT?*
FROM?LOCATION?L?，
CATEGORY?C，
EMP?E
WHERE?E.EMP_NO?BETWEEN?1000?AND?2000
AND?E.CAT_NO?=?C.CAT_NO
AND?E.LOCN?=?L.LOCN?

?

　　将比下列SQL更有效率

?

SELECT?*
FROM?EMP?E?，
LOCATION?L?，
CATEGORY?C
WHERE?E.CAT_NO?=?C.CAT_NO
AND?E.LOCN?=?L.LOCN
AND?E.EMP_NO?BETWEEN?1000?AND?2000

?

5. 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’;?

?

6.SELECT子句中避免使用‘ * ’

当你想在SELECT子句中列出所有的COLUMN时，使用动态SQL列引用‘*’是一个方便的方法。不幸的是，这是一个非常低效的方法。实际上，Oracle在解析的过程中，会将‘*’依次转换成所有的列名，这个工作是通过查询数据字典完成的，这意味着将耗费更多的时间。

7.减少访问数据库的次数

当执行每条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，
B.EMP_NAME，?B.SALARY，?B.GRADE
FROM?EMP?A，EMP?B
WHERE?A.EMP_NO?=?342
AND?B.EMP_NO?=?291;?

?

注意：

在SQL*Plus，SQL*Forms和Pro*C中重新设置ARRAYSIZE参数，可以增加每次数据库访问的检索数据量，建议值为200。

8.使用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子句中。

9.整合简单，无关联的数据库访问

如果你有几个简单的数据库查询语句，你可以把它们整合到一个查询中(即使它们之间没有关系)

例如：

?

SELECT?NAME
FROM?EMP
WHERE?EMP_NO?=?1234;
SELECT?NAME
FROM?DPT
WHERE?DPT_NO?=?10?;
SELECT?NAME
FROM?CAT
WHERE?CAT_TYPE?=‘RD’;?

?

上面的3个查询可以被合并成一个：

?

SELECT?E.NAME?，?D.NAME?，?C.NAME
FROM?CAT?C?，?DPT?D?，?EMP?E，DUAL?X
WHERE?NVL(‘X’，X.DUMMY)?=?NVL(‘X’，E.ROWID(+))
AND?NVL(‘X’，X.DUMMY)?=?NVL(‘X’，D.ROWID(+))
AND?NVL(‘X’，X.DUMMY)?=?NVL(‘X’，C.ROWID(+))
AND?E.EMP_NO(+)?=?1234
AND?D.DEPT_NO(+)?=?10
AND?C.CAT_TYPE(+)?=?‘RD’;?

?

10.删除重复记录

最高效的删除重复记录方法(因为使用了ROWID)

?

DELETE?FROM?EMP?E
WHERE?E.ROWID?>?(SELECT?MIN(X.ROWID)
FROM?EMP?X
WHERE?X.EMP_NO?=?E.EMP_NO);?

?

11.用TRUNCATE替代DELETE

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

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

(译者按：TRUNCATE只在删除全表适用，TRUNCATE是DDL不是DML)

12.尽量多使用COMMIT

只要有可能，在程序中尽量多使用COMMIT，这样程序的性能得到提高，需求也会因为COMMIT所释放的资源而减少：COMMIT所释放的资源：

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

b.被程序语句获得的锁

c.redo log buffer中的空间

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

(译者按：在使用COMMIT时必须要注意到事务的完整性，现实中效率和事务完整性往往是鱼和熊掌不可得兼)

13.计算记录条数

和一般的观点相反，count(*) 比count(1)稍快，当然如果可以通过索引检索，对索引列的计数仍旧是最快的。例如 COUNT(EMPNO)

(译者按：在CSDN论坛中，曾经对此有过相当热烈的讨论，作者的观点并不十分准确，通过实际的测试，上述三种方法并没有显著的性能差别)

14.用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

?

15.减少对表的查询

在含有子查询的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;?

?

16.通过内部函数提高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;?

?

(译者按：经常在论坛中看到如‘能不能用一个SQL写出…。’的贴子，殊不知复杂的SQL往往牺牲了执行效率。能够掌握上面的运用函数解决问题的方法在实际工作中是非常有意义的)

17.使用表的别名(Alias)

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

(译者注：Column歧义指的是由于SQL中不同的表具有相同的Column名，当SQL语句中出现这个Column时，SQL解析器无法判断这个Column的归属)

18.用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’)?

?

(译者按：相对来说，用NOT EXISTS替换NOT IN将更显著地提高效率，下一节中将指出)

19.用NOT EXISTS替代NOT IN

在子查询中，NOT IN子句将执行一个内部的排序和合并。无论在哪种情况下，NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历)。为了避免使用NOT IN，我们可以把它改写成外连接(Outer Joins)或NOT EXISTS。

例如：

?

SELECT?…
FROM?EMP
WHERE?DEPT_NO?NOT?IN?(SELECT?DEPT_NO
FROM?DEPT
WHERE?DEPT_CAT=’A’);?

?

为了提高效率。改写为：

(方法一：高效)

?

SELECT?….
FROM?EMP?A，DEPT?B
WHERE?A.DEPT_NO?=?B.DEPT(+)
AND?B.DEPT_NO?IS?NULL
AND?B.DEPT_CAT(+)?=?‘A’

?

(方法二：最高效)

?

SELECT?….
FROM?EMP?E
WHERE?NOT?EXISTS?(SELECT?‘X’
FROM?DEPT?D
WHERE?D.DEPT_NO?=?E.DEPT_NO
AND?DEPT_CAT?=?‘A’);?

?

SELECT?ENAME
FROM?EMP?E
WHERE?EXISTS?(SELECT?‘X’
FROM?DEPT
WHERE?DEPT_NO?=?E.DEPT_NO
AND?DEPT_CAT?=?‘A’);?

?

(更高效)

?

SELECT?ENAME
FROM?DEPT?D，EMP?E
WHERE?E.DEPT_NO?=?D.DEPT_NO
AND?DEPT_CAT?=?‘A’?;?

?

(译者按：在RBO的情况下，前者的执行路径包括FILTER，后者使用NESTED LOOP)

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?ptimizer=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工具。也许喜欢图形化界面的朋友们可以选用它们。

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 子句中列在最后的那个表。blog

举例：

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?ptimizer=CHOOSE
1?0?TABLE?ACCESS?(BY?INDEX?ROWID)?OF?'EMP'
2?1?INDEX?(RANGE?SCAN)?OF?'EMPTYPE'?(NON-UNIQUE)?

?

虽然EMPNO是唯一性索引，但是由于它所做的是范围比较，等级要比非唯一性索引的等式比较低!