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. 字符級的比較:

當前被執行的語句和共享池中的語句必須完全相同.

例如:

select * from emp;

和下列每一個都不同

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

(譯者按: having 中的條件一般用于對一些集合函數的比較,如count() 等等. 除此而外,一般的條件應該寫在where子句中)

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’);

20. 用表連接替換exists

通常來說 , 采用表連接的方式比exists更有效率

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 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)開始, 索引將不被采用.

select lodging

from lodging

where manager like ‘％hanman’;

在這種情況下，oracle將使用全表掃描.

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是唯一性索引,但是由于它所做的是范圍比較, 等級要比非唯一性索引的等式比較低

最大的網站源碼資源下載站，