Oracle语句优化30个规则详解

Sql代码  

1. 　select tab_name  
2. from tables  
3. where(tab_name,db_ver)  
4. =(select tab_name,db_ver)  
5. from tab_columns  
6. where version=604)  

 1. 选用适合的Oracle优化器

　　Oracle的优化器共有3种：

　　a. RULE (基于规则)

　　b. COST (基于成本)

　　c. CHOOSE (选择性)

　　设置缺省的优化器，可以通过对init.ora文件中OPTIMIZER_MODE参数的各种声明，如RULE，COST，CHOOSE，ALL_ROWS，FIRST_ROWS . 你当然也在SQL句级或是会话(session)级对其进行覆盖。

　　为了使用基于成本的优化器(CBO， Cost-Based Optimizer) ， 你必须经常运行analyze 命令，以增加数据库中的对象统计信息(object statistics)的准确性。

　　如果数据库的优化器模式设置为选择性(CHOOSE)，那么实际的优化器模式将和是否运行过analyze命令有关。 如果table已经被analyze过， 优化器模式将自动成为CBO ， 反之，数据库将采用RULE形式的优化器。

　　在缺省情况下，ORACLE采用CHOOSE优化器，为了避免那些不必要的全表扫描(full table scan) ， 你必须尽量避免使用CHOOSE优化器，而直接采用基于规则或者基于成本的优化器。

　　2. 访问Table的方式Oracle 采用两种访问表中记录的方式：

　　a. 全表扫描

　　全表扫描就是顺序地访问表中每条记录。 ORACLE采用一次读入多个数据块(database block)的方式优化全表扫描。

　　b. 通过ROWID访问表

　　你可以采用基于ROWID的访问方式情况，提高访问表的效率， ROWID包含了表中记录的物理位置信息……ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系。通常索引提供了快速访问ROWID的方法，因此那些基于索引列的查询就可以得到性能上的提高。

　　3. 共享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. 字符级的比较：

　　当前被执行的语句和共享池中的语句必须完全相同。

　　例如：

 

Sql代码  

1. SELECT*FROMEMP;  

 

 

 

　　和下列每一个都不同

 

Sql代码  

1. SELECT * from EMP;  
2. Select * From Emp;  
3. SELECT * FROM EMP;  

 

 

 

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

　　例如：

　　用户 对象名 如何访问

 

Sql代码  

1. Jacksal_limitprivatesynonym  
2. Work_citypublicsynonym  
3. Plant_detailpublicsynonym  
4. Jillsal_limitprivatesynonym  
5. Work_citypublicsynonym  
6. Plant_detailtableowner  

 

 

 

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

　　SQL 能否共享 原因

Sql代码  

1. select max(sal_cap) from sal_limit;  

 

　 不能 每个用户都有一个private synonym - sal_limit , 它们是不同的对象

Sql代码  

1. select count(*0 from work_city where sdesc like 'NEW%';  

 

 能 两个用户访问相同的对象public synonym - work_city

Sql代码  

1. 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.　

Sql代码  

1. select pin，name from people where pin=：blk1.pin;  
2. select pin，namefrom people where pin=：blk1.pin;  

 

　　b.

Sql代码  

1. select pin，name from people where pin=：blk1.ot_ind;  
2. 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作为基础表 (最好的方法)

 

Sql代码  

1. select count(*) from tab1，tab2  

 

 

 

执行时间0.96秒

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

Sql代码  

1. select count(*) from tab2，tab1  

 

执行时间26.09秒

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

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

 

Sql代码  

1. SELECT * FROM LOCATIONL,CATEGORYC,EMPE where E.EMP_NOBET WEEN  1000 AND 2000  
2. AND E.CAT_NO=C.CAT_NO  
3. AND E.LOCN=L.LOCN  

 

 

 

将比下列SQL更有效率

Sql代码  

1. <code><code>select * from empe,locationl, categoryc wheree.cat_no=c.cat_no  
2. ande.locn=l.locn  
3. ande.emp_no between 1000 and 2000  
4.   
5. </code></code>  

　　5. WHERE子句中的连接顺序。

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

　　例如：

　　（低效，执行时间156.3秒）

 

Java代码  

　select *   from empe   where sal>50000   and job=‘manager’   and 25<(select count(*) from emp   where mgr=e.empno);      

 

 

　　　(高效,执行时间10.6秒)

 

 

Sql代码  

1. select *  
2. from empe  
3. where 25<(select count(*) from emp  
4. where mgr=e.empno)  
5. and sal>50000  
6. and job=‘manager’;  

 

 

 

 

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

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

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

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

　　例如，以下有三种方法可以检索出雇员号等于0342或0291的职员。

　　方法1 (最低效)

 

Sql代码  

1. select emp_name,salary,grade  
2. from emp  
3. where emp_no=342;  
4. select emp_name,salary,grade  
5. from emp  
6. where emp_no=291;  

 

 

 

 

　　方法2 (次低效)

 

Sql代码  

1. 　declare  
2. cursor c1 (e_nonumber) is  
3. select emp_name,salary,grade  
4. from emp  
5. where emp_no=e_no;  
6. begin  
7. open c1(342);  
8. fetch c1 into…,..,..;  
9. open c1 (291);  
10. fetch c1 into…,..,..;  
11. close c1; end;   
12.     

　　　方法3 (高效)

 

Sql代码  

1. 　select a.emp_name,a.salary,a.grade,  
2. b.emp_name,b.salary,b.grade  
3. from empa,empb  
4. where a.emp_no=342  
5. and b.emp_no=291;  
6.  　　  

 

 

　　注意：

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

　　8. 使用DECODE函数来减少处理时间

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

　　例如：

 

Sql代码  

1.  select count(*)，sum(sal)  
2. from　emp  
3. where dept_no=0020  
4. and ename like　‘smith%’;  
5. select count(*)，sum(sal)  
6. from　emp  
7. where dept_no=0030  
8. and ename like　‘smith%’;  

 

 

 

 

　　　你可以用DECODE函数高效地得到相同结果

 

Sql代码  

1. select count(decode(dept_no,0020,’x’,null)) d0020_count,  
2. count(decode(dept_no,0030,’x’,null)) d0030_count,  
3. sum(decode(dept_no,0020,sal,null)) d0020_sal,  
4. sum(decode(dept_no,0030,sal,null)) d0030_sal  
5. from emp where ename like ‘smith%’;  

 

 

 

 

　　类似的，DECODE函数也可以运用于GROUP BY 和ORDER BY子句中。

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

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

　例如：

　　

 

Sql代码  

1. select name  
2. from emp  
3. where emp_no=1234;  
4. select name  
5. from dpt  
6. where dpt_no=10;  
7. select name  
8. from cat  
9. where cat_type=‘rd’;  

 

 

 

 

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

 

Sql代码  

1.  select e.name,d.name,c.name  
2. from catc,dptd,empe,dualx  
3. where nvl(‘x’,x.dummy)=nvl(‘x’,e.rowid(+))  
4. and nvl(‘x’,x.dummy)=nvl(‘x’,d.rowid(+))  
5. and nvl(‘x’,x.dummy)=nvl(‘x’,c.rowid(+))  
6. and e.emp_no(+)=1234  
7. and d.dept_no(+)=10  
8. and c.cat_type(+)=‘rd’;  

 

 

 

 

　　　10. 删除重复记录

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

 

Sql代码  

1. delete from empe  
2. where e.rowid>(select min(x.rowid)  
3. from empx  
4. 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子句限制记录的数目，那就能减少这方面的开销。

　　例如：

　　低效：

 

Sql代码  

1. select region，avg(log_size)  
2. from location  
3. group by region  
4. having region region!=‘sydney’  
5. and region!=‘perth’  

 

 

 

 

　　　高效：

 

Sql代码  

1. select region，avg(log_size)  
2. from location  
3. where region region!=‘sydney’  
4. and region!=‘perth’  
5. group by region  

 

 

 

 

　　　15. 减少对表的查询

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

　　例如：

　　低效

 

Sql代码  

1. select tab_name  
2. from tables  
3. where tab_name=(selecttab_name  
4. from tab_columns  
5. where version=604)  
6. and　db_ver=(selectdb_ver  
7. from tab_columns  
8. where version=604)  

 

 

 

 

　　　高效

 

 

 

 

　Update多个Column例子：

<!-- 分页 -->

　低效：

 

Sql代码  

1. UPDATEEMP  
2. SETEMP_CAT=(SELECTMAX(CATEGORY)FROMEMP_CATEGORIES),  
3. SAL_RANGE=(SELECTMAX(SAL_RANGE)FROMEMP_CATEGORIES)  
4. WHEREEMP_DEPT=0020;  

 

　　　高效：

Java代码  

UPDATE EMP   SET(EMP_CAT,SAL_RANGE)   =(SELECT MAX(CATEGORY),MAX(SAL_RANGE)   FROM EMP_CATEGORIES)   WHERE EMP_DEPT=0020;  

 

　　16. 通过内部函数提高SQL效率。

　　　

Sql代码  

SELECT H.EMPNO,E.ENAME,H.HIST_TYPE,T.TYPE_DESC,COUNT(*)   FROM HISTORY_TYPET,EMPE,EMP_HISTORYH   WHEREH.EMPNO=E.EMPNO   AND H.HIST_TYPE=T.HIST_TYPE   GROUP BY H.EMPNO,E.ENAME,H.HIST_TYPE,T.TYPE_DESC;  

 

　　通过调用下面的函数可以提高效率。

　　

Sql代码  

function lookup_hist_type(typin 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(empin number) return varchar2   as   ename varchar2(30);   cursor c1 is   selecte name   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_historyh   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)通常将提高查询的效率。

　　低效：

Sql代码  

select*   from emp(基础表)   where empno>0   and deptno in(select deptno   from dept   where loc=‘melb’)  

 

　　高效：

Sql代码  

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.

　　例如：

Sql代码  

 select *   from emp   where dept_nonotin(select dept_no   from dept   where dept_cat=’a’);  

 

　　为了提高效率。改写为：

　　(方法一： 高效)

Sql代码  

　select *   frome mpa,deptb   where a.dept_no=b.dept(+)   and b.dept_no is null   and b.dept_cat(+)=‘a’  

 

(方法二： 最高效)

Sql代码  

　select *   from empe   where not exists(select ‘x’   from deptd   where d.dept_no=e.dept_no   and dept_cat=‘a’);  

 

　　20. 用表连接替换EXISTS

　　通常来说 ， 采用表连接的方式比EXISTS更有效率

Sql代码  

select ename   from empe   where exists(select ‘x’   from dept   where dept_no=e.dept_no   and dept_cat=‘a’);  

 

　　(更高效)

Sql代码  

select ename   from deptd,empe   where e.dept_no=d.dept_no   and dept_cat=‘a’;  

 

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

　　21. 用EXISTS替换DISTINCT

　　当提交一个包含一对多表信息(比如部门表和雇员表)的查询时，避免在SELECT子句中使用DISTINCT. 一般可以考虑用EXIST替换

　　例如：

　　低效：

Sql代码  

select distinct dept_no,dept_name   from deptd,empe   where d.dept_no=e.dept_no  

 

　　高效：

Sql代码  

select dept_no,dept_name   from deptd   where exists(select ‘x’   from empe   where e.dept_no=d.dept_no);  

 

　　EXISTS 使查询更为迅速，因为RDBMS核心模块将在子查询的条件一旦满足后，立刻返回结果。

　　22. 识别‘低效执行’的SQL语句

　　用下列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代码  

sql>list   1 select *   2 from dept,emp   3*where emp.deptno=dept.deptno   sql>setautotracetraceonly/*traceonly可以不显示执行结果*/   sql>/   14rows selected.  

 

ExecutionPlan
----------------------------------------------------------


Sql代码  

0SELECTSTATEMENTptimizer=CHOOSE   10NESTEDLOOPS   21TABLEACCESS(FULL)OF'EMP'   31TABLEACCESS(BYINDEXROWID)OF'DEPT'   43INDEX(UNIQUESCAN)OF'PK_DEPT'(UNIQUE)   Statistics   ----------------------------------------------------------   0recursivecalls   2dbblockgets   30consistentgets   0physicalreads   0redosize   2598bytessentviaSQL*Nettoclient   503bytesreceivedviaSQL*Netfromclient   2SQL*Netroundtripsto/fromclient   0sorts(memory)   0sorts(disk)   14rowsprocessed  

 

　　通过以上分析，可以得出实际的执行步骤是：

　 　1.TABLEACCESS(FULL)OF'EMP'
2.INDEX(UNIQUESCAN)OF'PK_DEPT'(UNIQUE)
3.TABLEACCESS(BYINDEXROWID)OF'DEPT'
4.NESTEDLOOPS(JOINING1AND3)

　　注： 目前许多第三方的工具如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 REBUILD

　　26. 索引的操作

　　ORACLE对索引有两种访问模式。

　　索引唯一扫描 ( INDEX UNIQUE SCAN)

　　大多数情况下， 优化器通过WHERE子句访问INDEX.

　　例如：

　　表LODGING有两个索引 ： 建立在LODGING列上的唯一性索引LODGING_PK和建立在MANAGER列上的非唯一性索引LODGING$MANAGER.

　　　SELECT*
FROMLODGING
WHERELODGING=‘ROSEHILL’;

　　在内部 ， 上述SQL将被分成两步执行， 首先 ， LODGING_PK 索引将通过索引唯一扫描的方式被访问 ， 获得相对应的ROWID， 通过ROWID访问表的方式执行下一步检索。

　　如果被检索返回的列包括在INDEX列中，ORACLE将不执行第二步的处理(通过ROWID访问表)。 因为检索数据保存在索引中， 单单访问索引就可以完全满足查询结果。

　　下面SQL只需要INDEX UNIQUE SCAN 操作。

　　SELECTLODGING
FROMLODGING
WHERELODGING=‘ROSEHILL’;

　　索引范围查询(INDEX RANGE SCAN)

　　适用于两种情况：

1. 基于一个范围的检索

　　2. 基于非唯一性索引的检索

　　例1：

Sql代码  

select lodging from lodging where lodging like ‘m%’;  

 

　　WHERE子句条件包括一系列值， ORACLE将通过索引范围查询的方式查询LODGING_PK . 由于索引范围查询将返回一组值， 它的效率就要比索引唯一扫描低一些。

　　例2：　

　　

Sql代码  

 select lodging   from lodging   where manager=‘billgates’;  

 

　　这个SQL的执行分两步， LODGING$MANAGER的索引范围查询(得到所有符合条件记录的ROWID)和下一步同过ROWID访问表得到LODGING列的值。 由于LODGING$MANAGER是一个非唯一性的索引，数据库不能对它执行索引唯一扫描。

　　由于SQL返回LODGING列，而它并不存在于LODGING$MANAGER索引中， 所以在索引范围查询后会执行一个通过ROWID访问表的操作。

　　WHERE子句中， 如果索引列所对应的值的第一个字符由通配符(WILDCARD)开始， 索引将不被采用。在这种情况下，ORACLE将使用全表扫描。

Sql代码  

select lodging   from lodging   where manager like ‘%hanman’;  

 

　　27. 基础表的选择

　　基础表(Driving Table)是指被最先访问的表(通常以全表扫描的方式被访问)。 根据优化器的不同， SQL语句中基础表的选择是不一样的。

　　如果你使用的是CBO (COST BASED OPTIMIZER)，优化器会检查SQL语句中的每个表的物理大小，索引的状态，然后选用花费最低的执行路径。

　　如果你用RBO (RULE BASED OPTIMIZER) ， 并且所有的连接条件都有索引对应， 在这种情况下， 基础表就是FROM 子句中列在最后的那个表。blog

　　举例：

Sql代码  

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也有一个非唯一性索引。

Sql代码  

 select ename，   from emp   where dept_no=20   and emp_cat=‘a’;  

 

　　这里，DEPTNO索引将被最先检索，然后同EMP_CAT索引检索出的记录进行合并。 执行路径如下：　

　　 TABLEACCESSBYROWIDONEMP
AND-EQUAL
INDEXRANGESCANONDEPT_IDX
INDEXRANGESCANONCAT_IDX

　　29. 等式比较和范围比较

　　当WHERE子句中有索引列， ORACLE不能合并它们，ORACLE将用范围比较。

　　举例：

　　DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引：

Sql代码  

　select ename   from emp   where deptno>20   and emp_cat=‘a’;  

 

　　这里只有EMP_CAT索引被用到，然后所有的记录将逐条与DEPTNO条件进行比较。 执行路径如下：　　

 

　　 TABLEACCESSBYROWIDONEMP
INDEXRANGESCANONCAT_IDX

　　30. 不明确的索引等级

　　当ORACLE无法判断索引的等级高低差别，优化器将只使用一个索引，它就是在WHERE子句中被列在最前面的。

　　举例：

　　DEPTNO上有一个非唯一性索引，EMP_CAT也有一个非唯一性索引。

Sql代码  

　select ename   from emp   where deptno>20   and emp_cat>‘a’;  

 

　　这里， ORACLE只用到了DEPT_NO索引。 执行路径如下：

　　　TABLEACCESSBYROWIDONEMP
INDEXRANGESCANONDEPT_IDX

　　译者按：我们来试一下以下这种情况：

Sql代码  

　sql>select index_name，unique ness from user_indexes where table_name='emp';   index_name uniquenes   ---------------------------------------   empno unique   emptype non unique   sql>select * from emp where empno>=2 and emp_type='a';   no rows selected   execution plan   ----------------------------------------------------------   0 select statement ptimizer=choose   10 table access(by index rowid) of 'emp'   21 index(range scan) of 'emptype'(non-unique)