优化

 

1、    用程序中，保证在实现功能的基础上，尽量减少对数据库的访问次数；通过搜索参数，尽量减少对表的访问行数,最小化结果集，从而减轻网络负担；能够分开的操作尽量分开处理，提高每次的响应速度；在数据窗口使用SQL时，尽量把使用的索引放在选择的首列；算法的结构尽量简单；在查询时，不要过多地使用通配符如SELECT*FROMT1语句，要用到几列就选择几列如：SELECTCOL1,COL2FROMT1；在可能的情况下尽量限制尽量结果集行数如：SELECTTOP300COL1,COL2,COL3FROMT1,因为某些情况下用户是不需要那么多的数据的。不要在应用中使用数据库游标，游标是非常有用的工具，但比使用常规的、面向集的SQL语句需要更大的开销；按照特定顺序提取数据的查找。

2、   避免使用不兼容的数据类型。例如float和int、char和varchar、binary和varbinary是不兼容的。数据类型的不兼容可能使优化器无法执行一些本来可以进行的优化操作。例如:
SELECTnameFROMemployeeWHEREsalary ＞60000
在这条语句中,如salary字段是money型的,则优化器很难对其进行优化,因为60000是个整型数。我们应当在编程时将整型转化成为钱币型,而不要等到运行时转化。

3、   尽量避免在WHERE子句中对字段进行函数或表达式操作，这将导致引擎放弃使用索引而进行全表扫描。如：
SELECT*FROMT1WHEREF1/2=100
应改为:
SELECT*FROMT1WHEREF1=100*2

SELECT*FROMRECORDWHERESUBSTRING(CARD_NO,1,4)=’5378’
应改为:
SELECT*FROMRECORDWHERECARD_NOLIKE‘5378%’

SELECTmember_number, first_name, last_name FROMmembers
WHEREDATEDIFF(yy,datofbirth,GETDATE())>21
应改为:
SELECTmember_number, first_name, last_name FROMmembers
WHEREdateofbirth<DATEADD(yy,-21,GETDATE())
即：任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

4、   避免使用!=或＜＞、ISNULL或ISNOTNULL、IN，NOTIN等这样的操作符,因为这会使系统无法使用索引,而只能直接搜索表中的数据。例如:
SELECTidFROMemployeeWHEREid!='B%'
优化器将无法通过索引来确定将要命中的行数,因此需要搜索该表的所有行。

5、      尽量使用数字型字段，一部分开发人员和数据库管理人员喜欢把包含数值信息的字段
设计为字符型，这会降低查询和连接的性能，并会增加存储开销。这是因为引擎在处理查询和连接回逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。

6、      合理使用EXISTS,NOTEXISTS子句。如下所示：
1.SELECTSUM(T1.C1)FROMT1WHERE(
(SELECTCOUNT(*)FROMT2WHERET2.C2=T1.C2>0)
2.SELECTSUM(T1.C1)FROMT1WHEREEXISTS(
 SELECT*FROMT2WHERET2.C2=T1.C2)
两者产生相同的结果，但是后者的效率显然要高于前者。因为后者不会产生大量锁定的表扫描或是索引扫描。
如果你想校验表里是否存在某条纪录，不要用count(*)那样效率很低，而且浪费服务器资源。可以用EXISTS代替。如：
IF(SELECTCOUNT(*)FROMtable_nameWHEREcolumn_name='xxx')
可以写成：
IFEXISTS(SELECT*FROMtable_nameWHEREcolumn_name='xxx')

经常需要写一个T_SQL语句比较一个父结果集和子结果集，从而找到是否存在在父结果集中有而在子结果集中没有的记录，如：
1.SELECTa.hdr_key FROMhdr_tbl a---- tbl a 表示tbl用别名a代替
WHERENOTEXISTS(SELECT*FROMdtl_tbl bWHEREa.hdr_key=b.hdr_key)

2.SELECTa.hdr_key FROMhdr_tbl a
LEFTJOINdtl_tbl bONa.hdr_key=b.hdr_key WHEREb.hdr_keyISNULL

3.SELECThdr_key FROMhdr_tbl
WHEREhdr_keyNOTIN(SELECThdr_keyFROMdtl_tbl)
      三种写法都可以得到同样正确的结果，但是效率依次降低。

7、      尽量避免在索引过的字符数据中，使用非打头字母搜索。这也使得引擎无法利用索引。 
见如下例子：
SELECT*FROMT1WHERENAMELIKE‘%L%’
SELECT*FROMT1WHERESUBSTING(NAME,2,1)=’L’
SELECT*FROMT1WHERENAMELIKE‘L%’
即使NAME字段建有索引，前两个查询依然无法利用索引完成加快操作，引擎不得不对全表所有数据逐条操作来完成任务。而第三个查询能够使用索引来加快操作。

8、      分利用连接条件，在某种情况下，两个表之间可能不只一个的连接条件，这时在 WHERE子句中将连接条件完整的写上，有可能大大提高查询速度。
例：
SELECTSUM(A.AMOUNT)FROMACCOUNT A,CARD BWHEREA.CARD_NO=B.CARD_NO
SELECTSUM(A.AMOUNT)FROMACCOUNT A,CARD BWHEREA.CARD_NO=B.CARD_NO ANDA.ACCOUNT_NO=B.ACCOUNT_NO
第二句将比第一句执行快得多。

9、       消除对大型表行数据的顺序存取
      尽管在所有的检查列上都有索引，但某些形式的WHERE子句强迫优化器使用顺序存取。如：
SELECT*FROMordersWHERE(customer_num=104 ANDorder_num>1001)OR
order_num=1008
解决办法可以使用并集来避免顺序存取：
SELECT＊FROMordersWHEREcustomer_num=104ANDorder_num>1001
UNION
SELECT＊FROMordersWHEREorder_num=1008
这样就能利用索引路径处理查询。

10、    避免困难的正规表达式
      LIKE关键字支持通配符匹配，技术上叫正规表达式。但这种匹配特别耗费时间。例如：SELECT*FROMcustomerWHEREzipcodeLIKE“98_ _ _”
即使在zipcode字段上建立了索引，在这种情况下也还是采用顺序扫描的方式。如
果把语句改为SELECT ＊FROMcustomerWHEREzipcode>“98000”，在执行查询
时就会利用索引来查询，显然会大大提高速度。
11、    使用视图加速查询
把表的一个子集进行排序并创建视图，有时能加速查询。它有助于避免多重排序
操作，而且在其他方面还能简化优化器的工作。例如：
SELECTcust.name，rcvbles.balance，……other columns
FROMcust，rcvbles
WHEREcust.customer_id=rcvlbes.customer_id
ANDrcvblls.balance>0
ANDcust.postcode>“98000”
ORDERBYcust.name
如果这个查询要被执行多次而不止一次，可以把所有未付款的客户找出来放在一个
视图中，并按客户的名字进行排序：
CREATEVIEWDBO.V_CUST_RCVLBES
AS
SELECTcust.name，rcvbles.balance，……other columns
FROMcust，rcvbles
WHEREcust.customer_id=rcvlbes.customer_id
ANDrcvblls.balance>0
ORDERBYcust.name

然后以下面的方式在视图中查询：
SELECT＊FROM  V_CUST_RCVLBES
WHEREpostcode>“98000”
视图中的行要比主表中的行少，而且物理顺序就是所要求的顺序，减少了磁盘
I/O，所以查询工作量可以得到大幅减少。

12、    能够用BETWEEN的就不要用IN
SELECT*FROMT1WHEREIDIN(10,11,12,13,14)
改成：
SELECT*FROMT1WHEREIDBETWEEN10AND14
因为IN会使系统无法使用索引,而只能直接搜索表中的数据。

13、    DISTINCT的就不用GROUPBY
     SELECTOrderID FROMDetailsWHEREUnitPrice>10GROUPBYOrderID
      可改为：
     SELECTDISTINCTOrderIDFROMDetailsWHEREUnitPrice>10
     

14、      部分利用索引
     1.SELECTemployeeID, firstname, lastname
FROMnames
WHEREdept='prod'orcity='Orlando'ordivision='food'

     2.SELECTemployeeID, firstname, lastnameFROMnamesWHEREdept='prod'
UNIONALL
SELECTemployeeID, firstname, lastnameFROMnamesWHEREcity='Orlando'
UNIONALL
SELECTemployeeID, firstname, lastnameFROMnamesWHEREdivision='food'
如果dept 列建有索引则查询2可以部分利用索引，查询1则不能。


15、      能用UNION  ALL就不要用UNION
UNION  ALL不执行SELECT DISTINCT函数，这样就会减少很多不必要的资源

16、      不要写一些不做任何事的查询
如：SELECTCOL1FROMT1WHERE1=0
   SELECTCOL1FROMT1WHERECOL1=1ANDCOL1=2
这类死码不会返回任何结果集，但是会消耗系统资源。

17、     尽量不要用SELECT INTO语句。
SELECTINOT 语句会导致表锁定，阻止其他用户访问该表。

18、 必要时强制查询优化器使用某个索引
    SELECT*FROMT1WHEREnextprocess=1ANDprocessidIN(8,32,45)
改成：
SELECT*FROMT1 (INDEX=IX_ProcessID)WHEREnextprocess=1ANDprocessidIN(8,32,45)
则查询优化器将会强行利用索引IX_ProcessID 执行查询。
    
19、     虽然UPDATE、DELETE语句的写法基本固定，但是还是对UPDATE语句给点建议：
a)    尽量不要修改主键字段。
b)    当修改VARCHAR型字段时，尽量使用相同长度内容的值代替。
c)    尽量最小化对于含有UPDATE触发器的表的UPDATE操作。
d)    避免UPDATE将要复制到其他数据库的列。
e)    避免UPDATE建有很多索引的列。
f)    避免UPDATE在WHERE子句条件中的列。

上面我们提到的是一些基本的提高查询速度的注意事项,但是在更多的情况下,往往需要反复试验比较不同的语句以得到最佳方案。最好的方法当然是测试，看实现相同功能的SQL语句哪个执行时间最少，但是数据库中如果数据量很少，是比较不出来的，这时可以用查看执行计划，即：把实现相同功能的多条SQL语句考到查询分析器，按CTRL+L看查所利用的索引，表扫描次数（这两个对性能影响最大），总体上看询成本百分比即可。
简单的存储过程可以用向导自动生成：在企业管理器工具栏点击运行向导图标，点击”数据库”、”创建存储过程向导”。复杂存储过程的调试：在查询分析器左边的对象浏览器（没有？按F8）选择要调试的存储过程,点右键，点调试，输入参数执行，出现一个浮动工具条，上面有单步执行，断点设置等。

一、不合理的索引设计
----例：表record有620000行，试看在不同的索引下，下面几个 SQL的运行情况：
---- 1.在date上建有一非个群集索引
selectcount(*)fromrecordwheredate>
'19991201'anddate<'19991214'andamount>
2000(25秒)
selectdate,sum(amount)fromrecordgroupbydate
(55秒)
selectcount(*)fromrecordwheredate>
'19990901'andplacein('BJ','SH') (27秒)
---- 分析：
----date上有大量的重复值，在非群集索引下，数据在物理上随机存放在数据页上，在
范围查找时，必须执行一次表扫描才能找到这一范围内的全部行。
---- 2.在date上的一个群集索引
selectcount(*)fromrecordwheredate>
'19991201'anddate<'19991214'andamount>
2000（14秒）
selectdate,sum(amount)fromrecordgroupbydate
（28秒）
selectcount(*)fromrecordwheredate>
'19990901'andplacein('BJ','SH')（14秒）
---- 分析：
---- 在群集索引下，数据在物理上按顺序在数据页上，重复值也排列在一起，因而在范
围查找时，可以先找到这个范围的起末点，且只在这个范围内扫描数据页，避免了大范
围扫描，提高了查询速度。
---- 3.在place，date，amount上的组合索引
selectcount(*)fromrecordwheredate>
'19991201'anddate<'19991214'andamount>
2000（26秒）
selectdate,sum(amount)fromrecordgroupbydate
（27秒）
selectcount(*)fromrecordwheredate>
'19990901'andplacein('BJ,'SH')（ < 1秒）
---- 分析：
---- 这是一个不很合理的组合索引，因为它的前导列是place，第一和第二条SQL没有引
用place，因此也没有利用上索引；第三个SQL使用了place，且引用的所有列都包含在组
合索引中，形成了索引覆盖，所以它的速度是非常快的。
---- 4.在date，place，amount上的组合索引
select count(*) from record where date >
'19991201'and date <'19991214'and amount >
2000( < 1秒)
select date,sum(amount) from record group by date
（11秒）
select count(*) from record where date >
'19990901'and place in ('BJ','SH')（ < 1秒）
---- 分析：
---- 这是一个合理的组合索引。它将date作为前导列，使每个SQL都可以利用索引，并
且在第一和第三个SQL中形成了索引覆盖，因而性能达到了最优。
---- 5.总结：
---- 缺省情况下建立的索引是非群集索引，但有时它并不是最佳的；合理的索引设计要
建立在对各种查询的分析和预测上。一般来说：
---- ①.有大量重复值、且经常有范围查询
（between, >, < ，>=, < =）和order by
、group by发生的列，可考虑建立群集索引；
---- ②.经常同时存取多列，且每列都含有重复值可考虑建立组合索引；
---- ③.组合索引要尽量使关键查询形成索引覆盖，其前导列一定是使用最频繁的列。

二、不充份的连接条件：
---- 例：表card有7896行，在card_no上有一个非聚集索引，表account有191122行，在
account_no上有一个非聚集索引，试看在不同的表连接条件下，两个SQL的执行情况：

select sum(a.amount) from account a,
card b where a.card_no = b.card_no（20秒）
---- 将SQL改为：
select sum(a.amount) from account a,
card b where a.card_no = b.card_no and a.
account_no=b.account_no（ < 1秒）
---- 分析：
---- 在第一个连接条件下，最佳查询方案是将account作外层表，card作内层表，利用
card上的索引，其I/O次数可由以下公式估算为：
---- 外层表account上的22541页+（外层表account的191122行*内层表card上对应外层
表第一行所要查找的3页）=595907次I/O
---- 在第二个连接条件下，最佳查询方案是将card作外层表，account作内层表，利用
account上的索引，其I/O次数可由以下公式估算为：
---- 外层表card上的1944页+（外层表card的7896行*内层表account上对应外层表每一
行所要查找的4页）= 33528次I/O
---- 可见，只有充份的连接条件，真正的最佳方案才会被执行。
---- 总结：
---- 1.多表操作在被实际执行前，查询优化器会根据连接条件，列出几组可能的连接方
案并从中找出系统开销最小的最佳方案。连接条件要充份考虑带有索引的表、行数多的
表；内外表的选择可由公式：外层表中的匹配行数*内层表中每一次查找的次数确定，乘
积最小为最佳方案。
---- 2.查看执行方案的方法-- 用set showplanon，打开showplan选项，就可以看到连
接顺序、使用何种索引的信息；想看更详细的信息，需用sa角色执行dbcc(3604,310,30
2)。
三、不可优化的where子句
---- 1.例：下列SQL条件语句中的列都建有恰当的索引，但执行速度却非常慢：
select * from record where
substring(card_no,1,4)='5378'(13秒)
select * from record where
amount/30 < 1000（11秒）
select * from record where
convert(char(10),date,112)='19991201'（10秒）
---- 分析：
---- where子句中对列的任何操作结果都是在SQL运行时逐列计算得到的，因此它不得不
进行表搜索，而没有使用该列上面的索引；如果这些结果在查询编译时就能得到，那么
就可以被SQL优化器优化，使用索引，避免表搜索，因此将SQL重写成下面这样：
select * from record where card_no like
'5378%'（ < 1秒）
select * from record where amount
< 1000*30（ < 1秒）
select * from record where date='1999/12/01'
（ < 1秒）
---- 你会发现SQL明显快起来！
---- 2.例：表stuff有200000行，id_no上有非群集索引，请看下面这个SQL：
select count(*) from stuff where id_no in('0','1')
（23秒）
---- 分析：
---- where条件中的'in'在逻辑上相当于'or'，所以语法分析器会将in ('0','1')转化
为id_no ='0'or id_no='1'来执行。我们期望它会根据每个or子句分别查找，再将结果
相加，这样可以利用id_no上的索引；但实际上（根据showplan）,它却采用了"OR策略"
，即先取出满足每个or子句的行，存入临时数据库的工作表中，再建立唯一索引以去掉
重复行，最后从这个临时表中计算结果。因此，实际过程没有利用id_no上索引，并且完
成时间还要受tempdb数据库性能的影响。
---- 实践证明，表的行数越多，工作表的性能就越差，当stuff有620000行时，执行时
间竟达到220秒！还不如将or子句分开：
select count(*) from stuff where id_no='0'
select count(*) from stuff where id_no='1'
---- 得到两个结果，再作一次加法合算。因为每句都使用了索引，执行时间只有3秒，
在620000行下，时间也只有4秒。或者，用更好的方法，写一个简单的存储过程：
create proc count_stuff as
declare @a int
declare @b int
declare @c int
declare @d char(10)
begin
select @a=count(*) from stuff where id_no='0'
select @b=count(*) from stuff where id_no='1'
end
select @c=@a+@b
select @d=convert(char(10),@c)
print @d
---- 直接算出结果，执行时间同上面一样快！
---- 总结：
---- 可见，所谓优化即where子句利用了索引，不可优化即发生了表扫描或额外开销。

---- 1.任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时
要尽可能将操作移至等号右边。
---- 2.in、or子句常会使用工作表，使索引失效；如果不产生大量重复值，可以考虑把
子句拆开；拆开的子句中应该包含索引。
---- 3.要善于使用存储过程，它使SQL变得更加灵活和高效。
---- 从以上这些例子可以看出，SQL优化的实质就是在结果正确的前提下，用优化器可
以识别的语句，充份利用索引，减少表扫描的I/O次数，尽量避免表搜索的发生。其实S
QL的性能优化是一个复杂的过程，上述这些只是在应用层次的一种体现，深入研究还会
涉及数据库层的资源配置、网络层的流量控制以及操作系统层的总体设计。

1、要合理使用索引
索引是数据库一个重要的构成部分，很多人都会忽略它，其实索引的根本目的就是
为了提高查询效率。
使用原则如下：
在经常进行连接，但是没有指定为外键的列上建立索引，而不经常连接的字段则
由优化器自动生成索引。

在频繁进行排序或分组（即进行group by或order by操作）的列上建立索引。

在条件表达式中经常用到的不同值较多的列上建立检索，在不同值少的列上不要
建立索引。比如在雇员表的“性别”列上只有“男”与“女”两个不同值，因此就
无必要建立索引。如果建立索引不但不会提高查询效率，反而会严重降低更新速度
。
如果待排序的列有多个，可以在这些列上建立复合索引（compound index）。

在写sql语句时就必须注意有些写法是会使得数据库无法使用索引的，比如IS NULL
ISNOTNULL，IN，NOTIN等。。。

2．避免或简化排序
应当简化或避免对大型表进行重复的排序。当能够利用索引自动以适当的次序产生
输出时，优化器就避免了排序的步骤。以下是一些影响因素：
●索引中不包括一个或几个待排序的列；
●group by或order by子句中列的次序与索引的次序不一样；
●排序的列来自不同的表。
为了避免不必要的排序，就要正确地增建索引，合理地合并数据库表（尽管有时可
能影响表的规范化，但相对于效率的提高是值得的）。如果排序不可避免，那么应
当试图简化它，如缩小排序的列的范围等。

3．消除对大型表行数据的顺序存取
在嵌套查询中，对表的顺序存取对查询效率可能产生致命的影响。比如采用顺序存
取策略，一个嵌套3层的查询，如果每层都查询1000行，那么这个查询就要查询10
亿行数据。避免这种情况的主要方法就是对连接的列进行索引。例如，两个表：学
生表（学号、姓名、年龄……）和选课表（学号、课程号、成绩）。如果两个表要
做连接，就要在“学号”这个连接字段上建立索引。
还可以使用并集来避免顺序存取。尽管在所有的检查列上都有索引，但某些形式的
where子句强迫优化器使用顺序存取。下面的查询将强迫对orders表执行顺序操作
：
SELECT ＊ FROM orders WHERE (customer_num=104ANDorder_num>1001)OR
order_num=1008
虽然在customer_num和order_num上建有索引，但是在上面的语句中优化器还是使
用顺序存取路径扫描整个表。因为这个语句要检索的是分离的行的集合，所以应该
改为如下语句：
SELECT ＊ FROM orders WHERE customer_num=104ANDorder_num>1001
UNION
SELECT ＊ FROM orders WHERE order_num=1008
这样就能利用索引路径处理查询。

4．避免相关子查询
一个列的标签同时在主查询和where子句中的查询中出现，那么很可能当主查询中
的列值改变之后，子查询必须重新查询一次。查询嵌套层次越多，效率越低，因此
应当尽量避免子查询。如果子查询不可避免，那么要在子查询中过滤掉尽可能多的
行。

5．避免困难的正规表达式
MATCHES和LIKE关键字支持通配符匹配，技术上叫正规表达式。但这种匹配特别耗
费时间。例如：SELECT ＊ FROM customer WHERE zipcode LIKE “98_ _ _”
即使在zipcode字段上建立了索引，在这种情况下也还是采用顺序扫描的方式。如
果把语句改为SELECT ＊ FROM customer WHERE zipcode >“98000”，在执行查询
时就会利用索引来查询，显然会大大提高速度。
另外，还要避免非开始的子串。例如语句：SELECT ＊ FROM customer WHERE
zipcode[2，3] >“80”，在where子句中采用了非开始子串，因而这个语句也不会
使用索引。

6．使用临时表加速查询,SQL2000中还可以使用表变量来代替临时表
把表的一个子集进行排序并创建临时表，有时能加速查询。它有助于避免多重排序
操作，而且在其他方面还能简化优化器的工作。例如：
SELECT cust.name，rcvbles.balance，……other columns
FROM cust，rcvbles
WHERE cust.customer_id = rcvlbes.customer_id
ANDrcvblls.balance>0
ANDcust.postcode>“98000”
ORDER BY cust.name
如果这个查询要被执行多次而不止一次，可以把所有未付款的客户找出来放在一个
临时文件中，并按客户的名字进行排序：
SELECT cust.name，rcvbles.balance，……other columns
FROM cust，rcvbles
WHERE cust.customer_id = rcvlbes.customer_id
ANDrcvblls.balance>0
ORDER BY cust.name
INTOTEMP cust_with_balance
然后以下面的方式在临时表中查询：
SELECT ＊ FROM cust_with_balance
WHERE postcode>“98000”
临时表中的行要比主表中的行少，而且物理顺序就是所要求的顺序，减少了磁盘
I/O，所以查询工作量可以得到大幅减少。
注意：临时表创建后不会反映主表的修改。在主表中数据频繁修改的情况下，注意
不要丢失数据。

7．用排序来取代非顺序存取
非顺序磁盘存取是最慢的操作，表现在磁盘存取臂的来回移动。SQL语句隐藏了这
一情况，使得我们在写应用程序时很容易写出要求存取大量非顺序页的查询。
有些时候，用数据库的排序能力来替代非顺序的存取能改进查询。

如果你不太明白SQL语句的执行过的话.

记住这样的原则.
1.
对字段的计算会引起全表扫描.
所以,能用:
select * from 表 where 字段=1
就不要用:
select * from 表 where 字段-1=0

2.
必要的索引对提高数据处理速度很重要.因此,对于经常要排序,进行条件比较的字段,要建立索引.(注意区分复合索引和单独索引)
3.
善于利用存储过程/视图,化繁为简
4.
对于不能确定效率的查询分析语句,将它复制到查询分析器中.按Ctrl+L进行分析.
看看它的执行要经过那些步骤.
每个步骤的执行时间大慨需要占用的时间百分比.
在进行表扫描的步骤中,是否利用上了你创建的索引.
如果还有其他查询方法,再分析其他查询方法,通过比较确定最优的查询方法.

查询优化建议
有些查询天生就消耗大量资源。这与基本的数据库和索引问题有关。这些查询的效率并不低，因为查询优化器会以最有效的可能方式实现这些查询。然而，它们确实消耗大量资源，而且 Transact-SQL 面向集合的性质使这些查询看起来效率很低。查询优化器的智能水平无法消除这些构造的固有资源成本。与不复杂的查询相比，这些查询的固有成本十分昂贵。虽然 Microsoft? SQL Server?2000使用最佳的访问计划，但受到基础构造可能性的限制。例如，下列类型的查询可能占用大量资源：
返回大结果集的查询

高度不唯一的 WHERE 子句
不过有一些针对优化查询和提高查询性能的建议，其中包括：
添加更多的内存（尤其是如果服务器运行许多复杂查询而且其中几个查询执行很慢）

在有多个处理器的计算机上运行 SQL Server。多个处理器使 SQL Server 得以利用并行查询。有关更多信息，请参见并行查询处理。
考虑重新编写查询。
如果查询使用游标，则确定如果使用效率更高的游标类型（如快速只进游标）或单纯查询能否更有效地编写游标查询。单纯查询的性能一般优于游标操作。一组游标语句通常是一个外循环操作，在此操作中，一旦使用内部语句便开始处理外循环内的每行，因此可考虑使用 GROUP BY 或 CASE 语句或改为使用子查询。
如果应用程序使用循环，可考虑在查询内放入循环。应用程序常包含带参数化查询的循环，该循环执行许多次并要求运行应用程序的计算机与 SQL Server 之间有网络往返。可改为使用临时表创建一个更复杂的查询。只需提供一个网络往返，查询优化器即会更好地优化这个查询。
不要对同一查询内的单个表使用多个别名以模拟索引交叉。模拟索引交叉已没有必要，因为 SQL Server 会自动考虑索引交叉并且可以在同一查询内的相同表上使用多个索引。

只在必要时才使用查询提示。若查询使用