華閱文章網怎樣優化SQL語句提高效率
我們要做到不但會寫SQL，還要做到寫出性能優良的SQL語句。
（1）選擇最有效率的表名順序（只在基于規則的優化器中有效）： Oracle的解析器按照從右到左的順序處理FROM子句中的表名，FROM子句中寫在最后的表（基礎表 driving table）將被最先處理，在FROM子句中包含多個表的情況下，您必須選擇記錄條數最少的表作為基礎表。 假如有3個以上的表連接查詢， 那就需要選擇交叉表（intersection table）作為基礎表， 交叉表是指那個被其他表所引用的表。
（2）WHERE子句中的連接順序： Oracle采用自下而上的順序解析WHERE子句，根據這個原理，表之間的連接必須寫在其他WHERE條件之前， 那些能夠過濾掉最大數量記錄的條件必須寫在WHERE子句的末尾。 （3）SELECT子句中避免使用‘*’： Oracle在解析的過程中， 會將‘*’依次轉換成任何的列名， 這個工作是通過查詢數據字典完成的， 這意味著將耗費更多的時間。
（4）減少訪問數據庫的次數： Oracle在內部執行了許多工作： 解析SQL語句， 估算索引的利用率， 綁定變量 ， 讀數據塊等。 （5）在SQL*Plus , SQL*Forms和Pro*C中重新配置ARRAYSIZE參數， 能夠增加每次數據庫訪問的檢索數據量 ，建議值為200。
(6)使用DECODE函數來減少處理時間： 使用DECODE函數能夠避免重復掃描相同記錄或重復連接相同的表。 （7）整合簡單，無關聯的數據庫訪問： 假如您有幾個簡單的數據庫查詢語句，您能夠把他們整合到一個查詢中（即使他們之間沒有關系）。
（8）刪除重復記錄： 最高效的刪除重復記錄方法 （ 因為使用了ROWID）例子： DELETE FROM EMP E WHERE E。 ROWID > (SELECT MIN(X。
ROWID) FROM EMP X WHERE X。EMP_NO = E。
EMP_NO); (9)用TRUNCATE替代DELETE： 當刪除表中的記錄時，在通常情況下， 回滾段（rollback segments ） 用來存放能夠被恢復的信息。 假如您沒有COMMIT事務，ORACLE會將數據恢復到刪除之前的狀態（準確地說是恢復到執行刪除命令之前的狀況） 而當運用TRUNCATE時， 回滾段不再存放任何可被恢復的信息。
當命令運行后，數據不能被恢復。因此很少的資源被調用，執行時間也會很短。
（TRUNCATE只在刪除全表適用，TRUNCATE是DDL不是DML）。 以上是我對于這個問題的解答，希望能夠幫到大家。
怎樣優化SQL語句的執行
環境：oracle 817 + linux + 陣列柜 swd_billdetail 表5000萬條數據 SUPER_USER 表2800條數據 連接列上都有索引，而且super_user中的一條對應于swd_billdetail表中的很多條記錄表與索引都做了分析。
實際應用的查詢為： select a。CHANNEL, B。
user_class from swd_billdetail B, SUPER_USER A where A。cn = B。
cn； 這樣在分析時導致查詢出的數據過多，不方便，所以用count(a。 CHANNEL||B。
user_class)來代替，而且count(a。CHANNEL||B。
user_class)操作本身并不占用過多的時間，所以可以接受此種替代。 利用索引查詢出SWD_BILLDETAIL表中所有記錄的方法 SQL> select count(id) from SWD_BILLDETAIL; COUNT(ID) ---------- 53923574 Elapsed: 00:02:166。
00 Execution Plan ---------------------------------------------------------- 0 SELECT STATEMENT Optimizer=CHOOSE (Cost=18051 Card=1) 1 0 SORT (AGGREGATE) 2 1 INDEX (FAST FULL SCAN) OF 'SYS_C001851' (UNIQUE) (Cost=18051 Card=54863946) Statistics ---------------------------------------------------------- 0 recursive calls 1952 db block gets 158776 consistent gets 158779 physical reads 1004 redo size 295 bytes sent via SQL*Net to client 421 bytes received via SQL*Net from client 2 SQL*Net roundtrips to/from client 1 sorts (memory) 0 sorts (disk) 1 rows processed 利用全表掃描從SWD_BILLDETAIL表中取出全部數據的方法。 SQL> select count(user_class) from swd_billdetail; COUNT(USER_CLASS) ----------------- 53923574 Elapsed: 00:11:703。
07 Execution Plan ---------------------------------------------------------- 0 SELECT STATEMENT Optimizer=CHOOSE (Cost=165412 Card=1 Bytes=2) 1 0 SORT (AGGREGATE) 2 1 TABLE ACCESS (FULL) OF 'SWD_BILLDETAIL' (Cost=165412 Card=54863946 Bytes=109727892) Statistics ---------------------------------------------------------- 0 recursive calls 8823 db block gets 1431070 consistent gets 1419520 physical reads 0 redo size 303 bytes sent via SQL*Net to client 421 bytes received via SQL*Net from client 2 SQL*Net roundtrips to/from client 1 sorts (memory) 0 sorts (disk) 1 rows processed select count(a。 CHANNEL||B。
user_class) from swd_billdetail B, SUPER_USER A where A。cn = B。
cn; EXEC_ORDER PLANLINE ---------- ----------------------------------------------------------------------------------------------------------- 6 SELECT STATEMENT OPT_MODE:CHOOSE (COST=108968,CARD=1,BYTES=21) 5 SORT (AGGREGATE) (COST=,CARD=1,BYTES=21) 4 NESTED LOOPS (COST=108968,CARD=1213745,BYTES=25488645) 1 TABLE ACCESS (FULL) OF 'SWORD。 SUPER_USER' (COST=2,CARD=2794,BYTES=27940) 3 TABLE ACCESS (BY INDEX ROWID) OF 'SWORD。
SWD_BILLDETAIL' (COST=39,CARD=54863946,BYTES=603503406) 2 INDEX (RANGE SCAN) OF 'SWORD。 IDX_DETAIL_CN' (NON-UNIQUE) (COST=3,CARD=54863946,BYTES=) 這個查詢耗費的時間很長，需要1個多小時。
運行后的信息如下： COUNT(A。CHANNEL||B。
USER_CLASS) ------------------------------ 1186387 Elapsed: 01:107:6429。 87 Execution Plan ---------------------------------------------------------- 0 SELECT STATEMENT Optimizer=CHOOSE (Cost=108968 Card=1 Bytes=21) 1 0 SORT (AGGREGATE) 2 1 NESTED LOOPS (Cost=108968 Card=1213745 Bytes=25488645) 3 2 TABLE ACCESS (FULL) OF 'SUPER_USER' (Cost=2 Card=2794Bytes=27940) 4 2 TABLE ACCESS (BY INDEX ROWID) OF 'SWD_BILLDETAIL' (Cost=39 Card=54863946 Bytes=603503406) 5 4 INDEX (RANGE SCAN) OF 'IDX_DETAIL_CN' (NON-UNIQUE) (Cost=3 Card=54863946) Statistics ---------------------------------------------------------- 0 recursive calls 4 db block gets 1196954 consistent gets 1165726 physical reads 0 redo size 316 bytes sent via SQL*Net to client 421 bytes received via SQL*Net from client 2 SQL*Net roundtrips to/from client 2 sorts (memory) 0 sorts (disk) 1 rows processed 將語句中加入hints，讓oracle的優化器使用嵌套循環，并且大表作為驅動表，生成新的執行計劃： select /*+ ORDERED USE_NL(A) */ count(a。
CHANNEL||B。user_class) from swd_billdetail B, SUPER_USER A where A。
cn = B。cn; EXEC_ORDER PLANLINE ---------- ----------------------------------------------------------------------------------------------------- 6 SELECT STATEMENT OPT_MODE:CHOOSE (COST=109893304,CARD=1,BYTES=21) 5 SORT (AGGREGATE) (COST=,CARD=1,BYTES=21) 4 NESTED LOOPS (COST=109893304,CARD=1213745,BYTES=25488645) 1 TABLE ACCESS (FULL) OF 'SWORD。
SWD_BILLDETAIL' (COST=165412,CARD=54863946,BYTES=603503406) 3 TABLE ACCESS (BY INDEX ROWID) OF 'SWORD。SUPER_USER。
如何優化sql語句
一、問題的提出 在應用系統開發初期，由于開發數據庫數據比較少，對于查詢SQL語句，復雜視圖的的編寫等體會不出SQL語句各種寫法的性能優劣，但是如果將應用系統提交實際應用后，隨著數據庫中數據的增加，系統的響應速度就成為目前系統需要解決的最主要的問題之一。
系統優化中一個很重要的方面就是SQL語句的優化。對于海量數據，劣質SQL語句和優質SQL語句之間的速度差別可以達到上百倍，可見對于一個系統不是簡單地能實現其功能就可，而是要寫出高質量的SQL語句，提高系統的可用性。
在多數情況下，Oracle使用索引來更快地遍歷表，優化器主要根據定義的索引來提高性能。但是，如果在SQL語句的where子句中寫的SQL代碼不合理，就會造成優化器刪去索引而使用全表掃描，一般就這種SQL語句就是所謂的劣質SQL語句。
在編寫SQL語句時我們應清楚優化器根據何種原則來刪除索引，這有助于寫出高性能的SQL語句。 二、SQL語句編寫注意問題 下面就某些SQL語句的where子句編寫中需要注意的問題作詳細介紹。
在這些where子句中，即使某些列存在索引，但是由于編寫了劣質的SQL，系統在運行該SQL語句時也不能使用該索引，而同樣使用全表掃描，這就造成了響應速度的極大降低。 1. IS NULL 與 IS NOT NULL 不能用null作索引，任何包含null值的列都將不會被包含在索引中。
即使索引有多列這樣的情況下，只要這些列中有一列含有null，該列就會從索引中排除。也就是說如果某列存在空值，即使對該列建索引也不會提高性能。
任何在where子句中使用is null或is not null的語句優化器是不允許使用索引的。 2. 聯接列 對于有聯接的列，即使最后的聯接值為一個靜態值，優化器是不會使用索引的。
我們一起來看一個例子，假定有一個職工表（employee），對于一個職工的姓和名分成兩列存放（FIRST_NAME和LAST_NAME），現在要查詢一個叫比爾.克林頓（Bill Cliton）的職工。 下面是一個采用聯接查詢的SQL語句， select * from employss where first_name||''||last_name ='Beill Cliton'； 上面這條語句完全可以查詢出是否有Bill Cliton這個員工，但是這里需要注意，系統優化器對基于last_name創建的索引沒有使用。
當采用下面這種SQL語句的編寫，Oracle系統就可以采用基于last_name創建的索引。 *** where first_name ='Beill' and last_name ='Cliton'； . 帶通配符（%）的like語句 同樣以上面的例子來看這種情況。
目前的需求是這樣的，要求在職工表中查詢名字中包含cliton的人。可以采用如下的查詢SQL語句： select * from employee where last_name like '%cliton%'； 這里由于通配符（%）在搜尋詞首出現，所以Oracle系統不使用last_name的索引。
在很多情況下可能無法避免這種情況，但是一定要心中有底，通配符如此使用會降低查詢速度。然而當通配符出現在字符串其他位置時，優化器就能利用索引。
在下面的查詢中索引得到了使用： select * from employee where last_name like 'c%'; 4. Order by語句 ORDER BY語句決定了Oracle如何將返回的查詢結果排序。Order by語句對要排序的列沒有什么特別的限制，也可以將函數加入列中（象聯接或者附加等）。
任何在Order by語句的非索引項或者有計算表達式都將降低查詢速度。 仔細檢查order by語句以找出非索引項或者表達式，它們會降低性能。
解決這個問題的辦法就是重寫order by語句以使用索引，也可以為所使用的列建立另外一個索引，同時應絕對避免在order by子句中使用表達式。 5. NOT 我們在查詢時經常在where子句使用一些邏輯表達式，如大于、小于、等于以及不等于等等，也可以使用and（與）、or（或）以及not（非）。
NOT可用來對任何邏輯運算符號取反。下面是一個NOT子句的例子： 。
where not (status ='VALID') 如果要使用NOT，則應在取反的短語前面加上括號，并在短語前面加上NOT運算符。NOT運算符包含在另外一個邏輯運算符中，這就是不等于（<>）運算符。
換句話說，即使不在查詢where子句中顯式地加入NOT詞，NOT仍在運算符中，見下例： 。 where status <>'INVALID'； 對這個查詢，可以改寫為不使用NOT: select * from employee where salary<3000 or salary>3000； 雖然這兩種查詢的結果一樣，但是第二種查詢方案會比第一種查詢方案更快些。
第二種查詢允許Oracle對salary列使用索引，而第一種查詢則不能使用索引。 雖然這兩種查詢的結果一樣，但是第二種查詢方案會比第一種查詢方案更快些。
第二種查詢允許Oracle對salary列使用索引，而第一種查詢則不能使用索引。
sql語句的優化
由于SQL優化起來比較復雜，并且還會受環境限制，在開發過程中，寫SQL必須必須要遵循以下幾點的原則： *采用自下而上的順序解析WHERE子句，根據這個原理，表之間的連接必須寫在其他WHERE條件之前， 那些可以過濾掉最大數量記錄的條件必須寫在WHERE子句的末尾. 例如： （低效） SELECT … FROM EMP E WHERE SAL > 50000 AND JOB = 'MANAGER' AND 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=*）； （高效） SELECT … FROM EMP E WHERE 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=*) AND SAL > 50000 AND JOB = 'MANAGER'; *子句中避免使用'*' 當在SELECT子句中列出所有的COLUMN時，使用動態SQL列引用 ‘*’ 是一個方便的方法.可是，這是一個非常低效的方法. 實際上，ORACLE在解析的過程中， 會將'*' 依次轉換成所有的列名， 這個工作是通過查詢數據字典完成的， 這意味著將耗費更多的時間. 3.使用表的別名（Alias） 當在SQL語句中連接多個表時， 請使用表的別名并把別名前綴于每個Column上.這樣一來，就可以減少解析的時間并減少那些由Column歧義引起的語法錯誤. 注：Column歧義指的是由于SQL中不同的表具有相同的Column名，當SQL語句中出現這個Column時，SQL解析器無法判斷這個Column的歸屬。
優化sql 語句的幾種方式
1.對查詢進行優化，應盡量避免全表掃描，首先應考慮在 where 及 order by 涉及的列上建立索引。
2.應盡量避免在 where 子句中對字段進行 null 值判斷，否則將導致引擎放棄使用索引而進行全表掃描，如：select id from t where num is null 可以在num上設置默認值0，確保表中num列沒有null值，然后這樣查詢：select id from t where num=03.應盡量避免在 where 子句中使用！=或操作符，否則將引擎放棄使用索引而進行全表掃描。4.應盡量避免在 where 子句中使用 or 來連接條件，否則將導致引擎放棄使用索引而進行全表掃描，如：select id from t where num=10 or num=20 可以這樣查詢：select id from t where num=10 union all select id from t where num=* 和 not in 也要慎用，否則會導致全表掃描，如：select id from t where num in(1,2,3) 對于連續的數值，能用 between 就不要用 in 了：select id from t where num between 1 and 36.下面的查詢也將導致全表掃描：select id from t where name like '%abc%'7.應盡量避免在 where 子句中對字段進行表達式操作，這將導致引擎放棄使用索引而進行全表掃描。
如：select id from t where num/2=100 應改為：select id from t where num=100*28.應盡量避免在where子句中對字段進行函數操作，這將導致引擎放棄使用索引而進行全表掃描。如：select id from t where substring(name,1,3)='abc'--name以abc開頭的id 應改為：select id from t where name like 'abc%'9.不要在 where 子句中的“=”左邊進行函數、算術運算或其他表達式運算，否則系統將可能無法正確使用索引。
10.在使用索引字段作為條件時，如果該索引是復合索引，那么必須使用到該索引中的第一個字段作為條件時才能保證系統使用該索引，否則該索引將不會被使用，并且應盡可能的讓字段順序與索引順序相一致。11.不要寫一些沒有意義的查詢，如需要生成一個空表結構：select col1,col2 into #t from t where 1=0 這類代碼不會返回任何結果集，但是會消耗系統資源的，應改成這樣：create table #t(。
)12.很多時候用 exists 代替 in 是一個好的選擇：select num from a where num in(select num from b) 用下面的語句替換：select num from a where exists(select 1 from b where num=*)13.并不是所有索引對查詢都有效，SQL是根據表中數據來進行查詢優化的，當索引列有大量數據重復時，SQL查詢可能不會去利用索引，如一表中有字段sex,male、female幾乎各一半，那么即使在sex上建了索引也對查詢效率起不了作用。14.索引并不是越多越好，索引固然可以提高相應的 select 的效率，但同時也降低了 insert 及 update 的效率，因為 insert 或 update 時有可能會重建索引，所以怎樣建索引需要慎重考慮，視具體情況而定。
一個表的索引數最好不要超過6個，若太多則應考慮一些不常使用到的列上建的索引是否有必要。15.盡量使用數字型字段，若只含數值信息的字段盡量不要設計為字符型，這會降低查詢和連接的性能，并會增加存儲開銷。
這是因為引擎在處理查詢和連接時會逐個比較字符串中每一個字符，而對于數字型而言只需要比較一次就夠了。16.盡可能的使用 varchar 代替 char ，因為首先變長字段存儲空間小，可以節省存儲空間，其次對于查詢來說，在一個相對較小的字段內搜索效率顯然要高些。
17.任何地方都不要使用 select * from t ，用具體的字段列表代替“*”，不要返回用不到的任何字段。18.避免頻繁創建和刪除臨時表，以減少系統表資源的消耗。
19.臨時表并不是不可使用，適當地使用它們可以使某些例程更有效，例如，當需要重復引用大型表或常用表中的某個數據集時。但是，對于一次性事件，最好使用導出表。
20.在新建臨時表時，如果一次性插入數據量很大，那么可以使用 select into 代替 create table，避免造成大量 log ，以提高速度；如果數據量不大，為了緩和系統表的資源，應先create table，然后insert。21.如果使用到了臨時表，在存儲過程的最后務必將所有的臨時表顯式刪除，先 truncate table ，然后 drop table ，這樣可以避免系統表的較長時間鎖定。
22.盡量避免使用游標，因為游標的效率較差，如果游標操作的數據超過1萬行，那么就應該考慮改寫。23.使用基于游標的方法或臨時表方法之前，應先尋找基于集的解決方案來解決問題，基于集的方法通常更有效。
24.與臨時表一樣，游標并不是不可使用。對小型數據集使用 FAST_FORWARD 游標通常要優于其他逐行處理方法，尤其是在必須引用幾個表才能獲得所需的數據時。
在結果集中包括“合計”的例程通常要比使用游標執行的速度快。如果開發時間允許，基于游標的方法和基于集的方法都可以嘗試一下，看哪一種方法的效果更好。
25.盡量避免大事務操作，提高系統并發能力。26.盡量避免向客戶端返回大數據量，若數據量過大，應該考慮相應需求是否合理。
怎樣進行sql數據庫的優化
通過8個方法優化Mysql數據庫：創建索引、復合索引、索引不會包含有NULL值的列、使用短索引、排序的索引問題、like語句操作、不要在列上進行運算、不使用NOT IN和操作
1、創建索引
對于查詢占主要的應用來說，索引顯得尤為重要。很多時候性能問題很簡單的就是因為我們忘了添加索引而造成的，或者說沒有添加更為有效的索引導致。如果不加索引的話，那么查找任何哪怕只是一條特定的數據都會進行一次全表掃描，如果一張表的數據量很大而符合條件的結果又很少，那么不加索引會引起致命的性能下降。但是也不是什么情況都非得建索引不可，比如性別可能就只有兩個值，建索引不僅沒什么優勢，還會影響到更新速度，這被稱為過度索引。
2、復合索引
比如有一條語句是這樣的：select * from users where area='beijing' and age=22;
如果我們是在area和age上分別創建單個索引的話，由于mysql查詢每次只能使用一個索引，所以雖然這樣已經相對不做索引時全表掃描提高了很多效率，但是如果在area、age兩列上創建復合索引的話將帶來更高的效率。如果我們創建了（area, age, salary）的復合索引，那么其實相當于創建了（area,age,salary）、（area,age）、（area）三個索引，這被稱為最佳左前綴特性。因此我們在創建復合索引時應該將最常用作限制條件的列放在最左邊，依次遞減。
3、索引不會包含有NULL值的列
只要列中包含有NULL值都將不會被包含在索引中，復合索引中只要有一列含有NULL值，那么這一列對于此復合索引就是無效的。所以我們在數據庫設計時不要讓字段的默認值為NULL。
4、使用短索引
對串列進行索引，如果可能應該指定一個前綴長度。例如，如果有一個CHAR(255)的 列，如果在前10 個或20 個字符內，多數值是惟一的，那么就不要對整個列進行索引。短索引不僅可以提高查詢速度而且可以節省磁盤空間和I/O操作。
5、排序的索引問題
mysql查詢只使用一個索引，因此如果where子句中已經使用了索引的話，那么order by中的列是不會使用索引的。因此數據庫默認排序可以符合要求的情況下不要使用排序操作；盡量不要包含多個列的排序，如果需要最好給這些列創建復合索引。
6、like語句操作
一般情況下不鼓勵使用like操作，如果非使用不可，如何使用也是一個問題。like “%aaa%” 不會使用索引而like “aaa%”可以使用索引。
7、不要在列上進行運算
select * from users where YEAR(adddate)操作
NOT IN和操作都不會使用索引將進行全表掃描。NOT IN可以NOT EXISTS代替，id3則可使用id>3 or id
oracle中如何優化sql語句的,用什么方法
2. 選擇最有效率的表名順序（只在基于規則的優化器中有效） 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 *_NO BETWEEN 1000 AND 2000 AND *_NO = *_NO AND * = * 將比下列SQL更有效率 SELECT * FROM EMP E , LOCATION L , CATEGORY C WHERE *_NO = *_NO AND * = * AND *_NO BETWEEN 1000 AND 2000 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=*）； （高效，執行時間10.6秒） SELECT … FROM EMP E WHERE 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=*) AND SAL > 50000 AND JOB = 'MANAGER'; 4. SELECT子句中避免使用 ‘ * ‘ 當你想在SELECT子句中列出所有的COLUMN時，使用動態SQL列引用 ‘*’ 是一個方便的方法.不幸的是，這是一個非常低效的方法. 實際上，ORACLE在解析的過程中， 會將'*' 依次轉換成所有的列名， 這個工作是通過查詢數據字典完成的， 這意味著將耗費更多的時間. 5. 減少訪問數據庫的次數 當執行每條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 *_NAME , * , *, *_NAME , * , * FROM EMP A,EMP B WHERE *_NO = 342 AND *_NO = 291； 注意： 在SQL*Plus , SQL*Forms和Pro*C中重新設置ARRAYSIZE參數， 可以增加每次數據庫訪問的檢索數據量 ，建議值為200. 6. 使用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子句中. 7. 用TRUNCATE替代DELETE 當刪除表中的記錄時，在通常情況下， 回滾段（rollback segments ） 用來存放可以被恢復的信息. 如果你沒有COMMIT事務，ORACLE會將數據恢復到刪除之前的狀態（準確地說是恢復到執行刪除命令之前的狀況） 而當運用TRUNCATE時， 回滾段不再存放任何可被恢復的信息.當命令運行后，數據不能被恢復.因此很少的資源被調用，執行時間也會很短. TRUNCATE只在刪除全表或分區適用，TRUNCATE是DDL不是DML8. 用Where子句替換HAVING子句 避免使用HAVING子句， HAVING 只會在檢索出所有。
