我們要做到不但會寫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)
（10） 盡量多使用COMMIT：
只要有可能,在程序中盡量多使用COMMIT, 這樣程序的性能得到提高,需求也會因

為COMMIT所釋放的資源而減少:
COMMIT所釋放的資源:
a. 回滾段上用于恢復數據的信息.
b. 被程序語句獲得的鎖
c. redo log buffer 中的空間
d. ORACLE為管理上述3種資源中的內部花費
（11） 用Where子句替換HAVING子句：
避免使用HAVING子句, HAVING 只會在檢索出所有記錄之后才對結果集進行過濾.

這個處理需要排序,總計等操作. 如果能通過WHERE子句限制記錄的數目,那就能

減少這方面的開銷. (非oracle中)on、where、having這三個都可以加條件的子

句中，on是最先執行，where次之，having最后，因為on是先把不 符合條件的記

錄過濾后才進行統計，它就可以減少中間運算要處理的數據，按理說應該速度是

最快的，where也應該比having快點的，因為它過濾數據后 才進行sum，在兩個

表聯接時才用on的，所以在一個表的時候，就剩下where跟having比較了。在這

單表查詢統計的情況下，如果要過濾的條件沒有涉及到要計算字段，那它們的結

果是一樣的，只是where可以使用rushmore技術，而having就不能，在速度上后

者要慢如果要涉及到計算的字 段，就表示在沒計算之前，這個字段的值是不確

定的，根據上篇寫的工作流程，where的作用時間是在計算之前就完成的，而

having就是在計算后才起作 用的，所以在這種情況下，兩者的結果會不同。在

多表聯接查詢時，on比where更早起作用。系統首先根據各個表之間的聯接條件

，把多個表合成一個臨時表 后，再由where進行過濾，然后再計算，計算完后再

由having進行過濾。由此可見，要想過濾條件起到正確的作用，首先要明白這個

條件應該在什么時候起作用，然后再決定放在那里
（12） 減少對表的查詢：
在含有子查詢的SQL語句中,要特別注意減少對表的查詢.例子：
??? SELECT? TAB_NAME FROM TABLES WHERE (TAB_NAME,DB_VER) = ( SELECT
TAB_NAME,DB_VER FROM? TAB_COLUMNS? WHERE? VERSION = 604)
（13） 通過內部函數提高SQL效率.：
復雜的SQL往往犧牲了執行效率. 能夠掌握上面的運用函數解決問題的方法在實

際工作中是非常有意義的
（14） 使用表的別名(Alias)：
當在SQL語句中連接多個表時, 請使用表的別名并把別名前綴于每個Column上.這

樣一來,就可以減少解析的時間并減少那些由Column歧義引起的語法錯誤.
（15） 用EXISTS替代IN、用NOT EXISTS替代NOT IN：
在許多基于基礎表的查詢中,為了滿足一個條件,往往需要對另一個表進行聯接.

在這種情況下, 使用EXISTS(或NOT EXISTS)通常將提高查詢的效率. 在子查詢中

,NOT IN子句將執行一個內部的排序和合并. 無論在哪種情況下,NOT IN都是最低

效的 (因為它對子查詢中的表執行了一個全表遍歷). 為了避免使用NOT IN ,我

們可以把它改寫成外連接(Outer Joins)或NOT EXISTS.
例子：
（高效）SELECT * FROM? EMP (基礎表)? WHERE? EMPNO > 0? AND? EXISTS

(SELECT ‘X'? FROM DEPT? WHERE? DEPT.DEPTNO = EMP.DEPTNO? AND? LOC =

‘MELB')
(低效)SELECT? * FROM? EMP (基礎表)? WHERE? EMPNO > 0? AND? DEPTNO IN

(SELECT DEPTNO? FROM? DEPT? WHERE? LOC = ‘MELB')
（16） 識別'低效執行'的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;

（17） 用索引提高效率：
索引是表的一個概念部分,用來提高檢索數據的效率，ORACLE使用了一個復雜的

自平衡B-tree結構. 通常,通過索引查詢數據比全表掃描要快. 當ORACLE找出執

行查詢和Update語句的最佳路徑時, ORACLE優化器將使用索引. 同樣在聯結多個

表時使用索引也可以提高效率. 另一個使用索引的好處是,它提供了主鍵

(primary key)的唯一性驗證.。那些LONG或LONG RAW數據類型, 你可以索引幾乎

所有的列. 通常, 在大型表中使用索引特別有效. 當然,你也會發現, 在掃描小

表時,使用索引同樣能提高效率. 雖然使用索引能得到查詢效率的提高,但是我們

也必須注意到它的代價. 索引需要空間來存儲,也需要定期維護, 每當有記錄在

表中增減或索引列被修改時, 索引本身也會被修改. 這意味著每條記錄的INSERT

, DELETE , UPDATE將為此多付出4 , 5 次的磁盤I/O . 因為索引需要額外的存

儲空間和處理,那些不必要的索引反而會使查詢反應時間變慢.。定期的重構索引

是有必要的.：
ALTER? INDEX <INDEXNAME> REBUILD <TABLESPACENAME>
18） 用EXISTS替換DISTINCT：
當提交一個包含一對多表信息(比如部門表和雇員表)的查詢時,避免在SELECT子

句中使用DISTINCT. 一般可以考慮用EXIST替換, EXISTS 使查詢更為迅速,因為

RDBMS核心模塊將在子查詢的條件一旦滿足后,立刻返回結果. 例子：
????? (低效):
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);
（19） sql語句用大寫的；因為oracle總是先解析sql語句，把小寫的字母轉換

成大寫的再執行
（20） 在java代碼中盡量少用連接符“＋”連接字符串！
（21） 避免在索引列上使用NOT 通常，
我們要避免在索引列上使用NOT, NOT會產生在和在索引列上使用函數相同的影響

. 當ORACLE”遇到”NOT,他就會停止使用索引轉而執行全表掃描.
（22） 避免在索引列上使用計算．
WHERE子句中，如果索引列是函數的一部分．優化器將不使用索引而使用全表掃

描．
舉例:
低效：
SELECT … FROM? DEPT? WHERE SAL * 12 > 25000;
高效:
SELECT … FROM DEPT WHERE SAL > 25000/12;
（23） 用>=替代>
高效:
SELECT * FROM? EMP? WHERE? DEPTNO >=4
低效:
SELECT * FROM EMP WHERE DEPTNO >3
兩者的區別在于, 前者DBMS將直接跳到第一個DEPT等于4的記錄而后者將首先定

位到DEPTNO=3的記錄并且向前掃描到第一個DEPT大于3的記錄.
（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, 那就需要返回記錄最少的索引列寫在最前面.
（25） 用IN來替換OR?
這是一條簡單易記的規則，但是實際的執行效果還須檢驗，在ORACLE8i下，兩者

的執行路徑似乎是相同的．
低效:
SELECT…. FROM LOCATION WHERE LOC_ID = 10 OR LOC_ID = 20 OR LOC_ID =

30
高效
SELECT… FROM LOCATION WHERE LOC_IN? IN (10,20,30);
（26） 避免在索引列上使用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;
（27） 總是使用索引的第一個列：
如果索引是建立在多個列上, 只有在它的第一個列(leading column)被where子

句引用時,優化器才會選擇使用該索引. 這也是一條簡單而重要的規則，當僅引

用索引的第二個列時,優化器使用了全表掃描而忽略了索引
28） 用UNION-ALL 替換UNION ( 如果有可能的話)：
當SQL 語句需要UNION兩個查詢結果集合時,這兩個結果集合會以UNION-ALL的方

式被合并, 然后在輸出最終結果前進行排序. 如果用UNION ALL替代UNION, 這樣

排序就不是必要了. 效率就會因此得到提高. 需要注意的是，UNION ALL 將重復

輸出兩個結果集合中相同記錄. 因此各位還是要從業務需求分析使用UNION ALL

的可行性. UNION 將對結果集合排序,這個操作會使用到SORT_AREA_SIZE這塊內

存. 對于這塊內存的優化也是相當重要的. 下面的SQL可以用來查詢排序的消耗

量
低效：
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'
（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
低效: (索引不被使用)
SELECT DEPT_CODE FROM? DEPT? ORDER BY? DEPT_TYPE
高效: (使用索引)
SELECT DEPT_CODE? FROM? DEPT? WHERE? DEPT_TYPE > 0
（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? WHERETO_NUMBER(EMP_TYPE)=123
因為內部發生的類型轉換, 這個索引將不會被用到! 為了避免ORACLE對你的SQL

進行隱式的類型轉換, 最好把類型轉換用顯式表現出來. 注意當字符和數值比較

時, ORACLE會優先轉換數值類型到字符類型
（31） 需要當心的WHERE子句:
某些SELECT 語句中的WHERE子句不使用索引. 這里有一些例子.
在下面的例子里, (1)‘!=' 將不使用索引. 記住, 索引只能告訴你什么存在于

表中, 而不能告訴你什么不存在于表中. (2) ‘ | |'是字符連接函數. 就象其

他函數那樣, 停用了索引. (3) ‘+'是數學函數. 就象其他數學函數那樣, 停用

了索引. (4)相同的索引列不能互相比較,這將會啟用全表掃描.
（32） a. 如果檢索數據量超過30%的表中記錄數.使用索引將沒有顯著的效率提

高.
b. 在特定情況下, 使用索引也許會比全表掃描慢, 但這是同一個數量級上的區

別. 而通常情況下,使用索引比全表掃描要塊幾倍乃至幾千倍!
（33） 避免使用耗費資源的操作:
帶有DISTINCT,UNION,MINUS,INTERSECT,ORDER BY的SQL語句會啟動SQL引擎
執行耗費資源的排序(SORT)功能. DISTINCT需要一次排序操作, 而其他的至少需

要執行兩次排序. 通常, 帶有UNION, MINUS , INTERSECT的SQL語句都可以用其

他方式重寫. 如果你的數據庫的SORT_AREA_SIZE調配得好, 使用UNION , MINUS,

INTERSECT也是可以考慮的, 畢竟它們的可讀性很強
（34） 優化GROUP BY:
提高GROUP BY 語句的效率, 可以通過將不需要的記錄在GROUP BY 之前過濾掉.

下面兩個查詢返回相同結果但第二個明顯就快了許多.
低效:
SELECT JOB , AVG(SAL)
FROM EMP
GROUP by JOB
HAVING JOB = ‘PRESIDENT'
OR JOB = ‘MANAGER'
高效:
SELECT JOB , AVG(SAL)
FROM EMP
WHERE JOB = ‘PRESIDENT'
OR JOB = ‘MANAGER'
GROUP by JOB

====================================
====================================
如果你正在負責一個基于SQL Server的項目，或者你剛剛接觸SQL Server，你都

有可能要面臨一些數據庫性能的問題，這篇文章會為你提供一些有用的指導（其

中大多數也可以用于其它的DBMS）。
在這里，我不打算介紹使用SQL Server的竅門，也不能提供一個包治百病的方案

，我所做的是總結一些經驗----關于如何形成一個好的設計。這些經驗來自我過

去幾年中經受的教訓，一直來，我看到許多同樣的設計錯誤被一次又一次的重復

。
一、了解你用的工具
不要輕視這一點，這是我在這篇文章中講述的最關鍵的一條。也許你也看到有很

多的SQL Server程序員沒有掌握全部的T-SQL命令和SQL Server提供的那些有用

的工具。
“什么？我要浪費一個月的時間來學習那些我永遠也不會用到的SQL命令？？？

”，你也許會這樣說。對的，你不需要這樣做。但是你應該用一個周末瀏覽所有

的 T-SQL命令。在這里，你的任務是了解，將來，當你設計一個查詢時，你會記

起來：“對了，這里有一個命令可以完全實現我需要的功能”，于是，到MSDN

查看這個命令的確切語法。
二、不要使用游標
讓我再重復一遍：不要使用游標。如果你想破壞整個系統的性能的話，它們倒是

你最有效的首選辦法。大多數的初學者都使用游標，而沒有意識到它們對性能造

成的影響。它們占用內存，還用它們那些不可思議的方式鎖定表，另外，它們簡

直就像蝸牛。而最糟糕的是，它們可以使你的DBA所能做的一切性能優化等于沒

做。不 知你是否知道每執行一次FETCH就等于執行一次SELECT命令？這意味著如

果你的游標有10000條記錄，它將執行10000次SELECT！如果你 使用一組SELECT

、UPDATE或者DELETE來完成相應的工作，那將有效率的多。
初學者一般認為使用游標是一種比較熟悉和舒適的編程方式，可很不幸，這會導

致糟糕的性能。顯然，SQL的總體目的是你要實現什么，而不是怎樣實現。
我曾經用T-SQL重寫了一個基于游標的存儲過程，那個表只有100,000條記錄，原

來的存儲過程用了40分鐘才執行完畢，而新的存儲過程只用了10秒鐘。在這里，

我想你應該可以看到一個不稱職的程序員究竟在干了什么！！！
我們可以寫一個小程序來取得和處理數據并且更新數據庫，這樣做有時會更有效

。記住：對于循環，T-SQL無能為力。
我再重新提醒一下：使用游標沒有好處。除了DBA的工作外，我從來沒有看到過

使用游標可以有效的完成任何工作。
三、規范化你的數據表
為什么不規范化數據庫？大概有兩個借口：出于性能的考慮和純粹因為懶惰。至

于第二點，你遲早得為此付出代價。而關于性能的問題，你不需要優化根本就不

慢的東西。我經常看到一些程序員“反規范化”數據庫，他們的理由是“原來的

設計太慢了”，可結果卻常常是他們讓系統更慢了。DBMS被設計用來處理規范數

據庫 的，因此，記住：按照規范化的要求設計數據庫。
四、不要使用SELECT *
這點不太容易做到，我太了解了，因為我自己就經常這樣干。可是，如果在

SELECT中指定你所需要的列，那將會帶來以下的好處：
1 減少內存耗費和網絡的帶寬
2 你可以得到更安全的設計
3 給查詢優化器機會從索引讀取所有需要的列
五、了解你將要對數據進行的操作
為你的數據庫創建一個健壯的索引，那可是功德一件。可要做到這一點簡直就是

一門藝術。每當你為一個表添加一個索引，SELECT會更快了，可INSERT 和

DELETE卻大大的變慢了，因為創建了維護索引需要許多額外的工作。顯然，這里

問題的關鍵是：你要對這張表進行什么樣的操作。這個問題不太好把握，特別是

涉及DELETE和UPDATE時，因為這些語句經常在WHERE部分包含SELECT命令。
六、不要給“性別”列創建索引
首先，我們必須了解索引是如何加速對表的訪問的。你可以將索引理解為基于一

定的標準上對表進行劃分的一種方式。如果你給類似于“性別”這樣的列創建了

一個 索引，你僅僅是將表劃分為兩部分：男和女。你在處理一個有1,000,000條

記錄的表，這樣的劃分有什么意義？記住：維護索引是比較費時的。當你設計索

引時，請遵循這樣的規則：根據列可能包含不同內容的數目從多到少排列，比如

：姓名+省份+性別。
七、使用事務
請使用事務，特別是當查詢比較耗時。如果系統出現問題，這樣做會救你一命的

。一般有些經驗的程序員都有體會-----你經常會碰到一些不可預料的情況會導

致存儲過程崩潰。
八、小心死鎖
按照一定的次序來訪問你的表。如果你先鎖住表A，再鎖住表B，那么在所有的存

儲過程中都要按照這個順序來鎖定它們。如果你（不經意的）某個存儲過程中先

鎖定表B，再鎖定表A，這可能就會導致一個死鎖。如果鎖定順序沒有被預先詳細

的設計好，死鎖是不太容易被發現的。
九、不要打開大的數據集
一個經常被提出的問題是：我怎樣才能迅速的將100000條記錄添加到ComboBox中

？這是不對的，你不能也不需要這樣做。很簡單，你的用戶要瀏覽 100000條記

錄才能找到需要的記錄，他一定會詛咒你的。在這里，你需要的是一個更好的UI

，你需要為你的用戶顯示不超過100或200條記錄。
十、不要使用服務器端游標
與服務器端游標比起來，客戶端游標可以減少服務器和網絡的系統開銷，并且還

減少鎖定時間。
十一、使用參數查詢
有時，我在CSDN技術論壇看到類似這樣的問題：“SELECT * FROM a WHERE

a.id='A'B，因為單引號查詢發生異常，我該怎么辦？”，而普遍的回答是：用

兩個單引號代替單引號。這是錯誤的。這樣治標不治本，因為你還會在其他 一

些字符上遇到這樣的問題，更何況這樣會導致嚴重的bug，除此以外，這樣做還

會使SQL Server的緩沖系統無法發揮應有的作用。使用參數查詢，釜底抽薪，這

些問題統統不存在了。
十二、在程序編碼時使用大數據量的數據庫
程序員在開發中使用的測試數據庫一般數據量都不大，可經常的是最終用戶的數

據量都很大。我們通常的做法是不對的，原因很簡單：現在硬盤不是很貴，可為

什么性能問題卻要等到已經無可挽回的時候才被注意呢？
十三、不要使用INSERT導入大批的數據
請不要這樣做，除非那是必須的。使用UTS或者BCP，這樣你可以一舉而兼得靈活

性和速度。
十四、注意超時問題
查詢數據庫時，一般數據庫的缺省都比較小，比如15秒或者30秒。而有些查詢運

行時間要比這長，特別是當數據庫的數據量不斷變大時。
十五、不要忽略同時修改同一記錄的問題
有時候，兩個用戶會同時修改同一記錄，這樣，后一個修改者修改了前一個修改

者的操作，某些更新就會丟失。處理這種情況不是很難：創建一個timestamp字

段，在寫入前檢查它，如果允許，就合并修改，如果存在沖突，提示用戶。
十六、在細節表中插入紀錄時，不要在主表執行SELECT MAX(ID)
這是一個普遍的錯誤，當兩個用戶在同一時間插入數據時，這會導致錯誤。你可

以使用SCOPE_IDENTITY，IDENT_CURRENT和IDENTITY。如果可能，不要使用

IDENTITY，因為在有觸發器的情況下，它會引起一些問題（詳見這里的討論）。
十七、避免將列設為NULLable
如果可能的話，你應該避免將列設為NULLable。系統會為NULLable列的每一行分

配一個額外的字節，查詢時會帶來更多的系統開銷。另外，將列設為NULLable使

編碼變得復雜，因為每一次訪問這些列時都必須先進行檢查。
我并不是說NULLS是麻煩的根源，盡管有些人這樣認為。我認為如果你的業務規

則中允許“空數據”，那么，將列設為NULLable有時會發揮很好的作用，但是，

如果在類似下面的情況中使用NULLable，那簡直就是自討苦吃。
CustomerName1
CustomerAddress1
CustomerEmail1
CustomerName2
CustomerAddress2
CustomerEmail3
CustomerName1
CustomerAddress2
CustomerEmail3
如果出現這種情況，你需要規范化你的表了。
十八、盡量不要使用TEXT數據類型
除非你使用TEXT處理一個很大的數據，否則不要使用它。因為它不易于查詢，速

度慢，用的不好還會浪費大量的空間。一般的，VARCHAR可以更好的處理你的數

據。
十九、盡量不要使用臨時表
盡量不要使用臨時表，除非你必須這樣做。一般使用子查詢可以代替臨時表。使

用臨時表會帶來系統開銷，如果你是用COM+進行編程，它還會給你帶來很大的麻

煩，因為COM+使用數據庫連接池而臨時表卻自始至終都存在。SQL Server提供了

一些替代方案，比如Table數據類型。
二十、學會分析查詢
SQL Server查詢分析器是你的好伙伴，通過它你可以了解查詢和索引是如何影響

性能的。
二十一、使用參照完整性
定義主健、唯一性約束和外鍵，這樣做可以節約大量的時間。

from ： http://www.cnblogs.com/ziyiFly/archive/2008/12/24/1361380.html

SQL優化總結