SQL执行效率总结

1.关于SQL查询效率，100w数据，查询只要1秒，与您分享:

机器状况 p4: 2.4 内存: 1 G os: windows 2003 数据库: ms sql server 2000 目的: 查询性能测试,比较两种查询的性能

SQL查询效率 step by step

-- setp 1. -- 建表 create table t_userinfo ( userid int identity(1,1) primary key nonclustered, nick varchar(50) not null default '', classid int not null default 0, writetime datetime not null default getdate() ) go

-- 建索引 create clustered index ix_userinfo_classid on t_userinfo(classid) go

-- step 2.

declare @i int declare @k int declare @nick varchar(10) set @i = 1 while @i<1000000 begin set @k = @i % 10 set @nick = convert(varchar,@i) insert into t_userinfo(nick,classid,writetime) values(@nick,@k,getdate()) set @i = @i + 1 end -- 耗时 08:27 ，须要耐心等待

-- step 3. select top 20 userid,nick,classid,writetime from t_userinfo where userid not in ( select top 900000 userid from t_userinfo order by userid asc )

-- 耗时 8 秒 ,够长的

-- step 4. select a.userid,b.nick,b.classid,b.writetime from ( select top 20 a.userid from ( select top 900020 userid from t_userinfo order by userid asc ) a order by a.userid desc ) a inner join t_userinfo b on a.userid = b.userid order by a.userid asc

-- 耗时 1 秒，太快了吧，不能够思议

-- step 5 where 查询 select top 20 userid,nick,classid,writetime from t_userinfo where classid = 1 and userid not in ( select top 90000 userid from t_userinfo where classid = 1 order by userid asc ) -- 耗时 2 秒

-- step 6 where 查询 select a.userid,b.nick,b.classid,b.writetime from ( select top 20 a.userid from ( select top 90000 userid from t_userinfo where classid = 1 order by userid asc ) a order by a.userid desc ) a inner join t_userinfo b on a.userid = b.userid order by a.userid asc

-- 查询分析器显示不到 1 秒.

查询效率分析： 子查询为确保消除重复值，必须为外部查询的每一个结果都处理嵌套查询。在这种状况下能够考虑用联接查询来取代。 若是要用子查询，那就用EXISTS替代IN、用NOT EXISTS替代NOT IN。由于EXISTS引入的子查询只是测试是否存在符合子查询中指定条件的行，效率较高。不管在哪一种状况下,NOT IN都是最低效的。由于它对子查询中的表执行了一个全表遍历。

创建合理的索引,避免扫描多余数据，避免表扫描！ 几百万条数据，照样几十毫秒完成查询. 2. SQL提升查询效率 2008-05-12 21:20 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=0

3.应尽可能避免在 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=20

5.in 和 not in 也要慎用，不然会致使全表扫描，如： select id from t where num in(1,2,3) 对于连续的数值，能用 between 就不要用 in 了： select id from t where num between 1 and 3

6.下面的查询也将致使全表扫描： select id from t where name like '�c%' 若要提升效率，能够考虑全文检索。

7. 若是在 where 子句中使用参数，也会致使全表扫描。由于SQL只有在运行时才会解析局部变量，但优化程序不能将访问计划的选择推迟到运行时；它必须在编译时进行选择。然 而，若是在编译时创建访问计划，变量的值仍是未知的，于是没法做为索引选择的输入项。以下面语句将进行全表扫描： select id from t where num=@num 能够改成强制查询使用索引： select id from t with(index(索引名)) where num=@num

8.应尽可能避免在 where 子句中对字段进行表达式操做，这将致使引擎放弃使用索引而进行全表扫描。如： select id from t where num/2=100 应改成: select id from t where num=100*2

9.应尽可能避免在where子句中对字段进行函数操做，这将致使引擎放弃使用索引而进行全表扫描。如： select id from t where substring(name,1,3)='abc'--name以abc开头的id select id from t where datediff(day,createdate,'2005-11-30')=0--‘2005-11-30’生成的id 应改成: select id from t where name like 'abc%' select id from t where createdate>='2005-11-30' and createdate<'2005-12-1'

10.不要在 where 子句中的“=”左边进行函数、算术运算或其余表达式运算，不然系统将可能没法正确使用索引。

11.在使用索引字段做为条件时，若是该索引是复合索引，那么必须使用到该索引中的第一个字段做为条件时才能保证系统使用该索引，不然该索引将不会被使用，而且应尽量的让字段顺序与索引顺序相一致。

12.不要写一些没有意义的查询，如须要生成一个空表结构： select col1,col2 into #t from t where 1=0 这类代码不会返回任何结果集，可是会消耗系统资源的，应改为这样： create table #t(...)

13.不少时候用 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=a.num)

14.并非全部索引对查询都有效，SQL是根据表中数据来进行查询优化的，当索引列有大量数据重复时，SQL查询可能不会去利用索引，如一表中有字段sex，male、female几乎各一半，那么即便在sex上建了索引也对查询效率起不了做用。

15. 索引并非越多越好，索引当然能够提升相应的 select 的效率，但同时也下降了 insert 及 update 的效率，由于 insert 或 update 时有可能会重建索引，因此怎样建索引须要慎重考虑，视具体状况而定。一个表的索引数最好不要超过6个，若太多则应考虑一些不常使用到的列上建的索引是否有 必要。

16.应尽量的避免更新 clustered 索引数据列，由于 clustered 索引数据列的顺序就是表记录的物理存储顺序，一旦该列值改变将致使整个表记录的顺序的调整，会耗费至关大的资源。若应用系统须要频繁更新 clustered 索引数据列，那么须要考虑是否应将该索引建为 clustered 索引。

17.尽可能使用数字型字段，若只含数值信息的字段尽可能不要设计为字符型，这会下降查询和链接的性能，并会增长存储开销。这是由于引擎在处理查询和链接时会逐个比较字符串中每个字符，而对于数字型而言只须要比较一次就够了。

18.尽量的使用 varchar/nvarchar 代替 char/nchar ，由于首先变长字段存储空间小，能够节省存储空间，其次对于查询来讲，在一个相对较小的字段内搜索效率显然要高些。

19.任何地方都不要使用 select * from t ，用具体的字段列表代替“*”，不要返回用不到的任何字段。

20.尽可能使用表变量来代替临时表。若是表变量包含大量数据，请注意索引很是有限（只有主键索引）。

21.避免频繁建立和删除临时表，以减小系统表资源的消耗。

22.临时表并非不可以使用，适当地使用它们可使某些例程更有效，例如，当须要重复引用大型表或经常使用表中的某个数据集时。可是，对于一次性事件，最好使用导出表。

23.在新建临时表时，若是一次性插入数据量很大，那么可使用 select into 代替 create table，避免形成大量 log ，以提升速度；若是数据量不大，为了缓和系统表的资源，应先create table，而后insert。

24.若是使用到了临时表，在存储过程的最后务必将全部的临时表显式删除，先 truncate table ，而后 drop table ，这样能够避免系统表的较长时间锁定。

25.尽可能避免使用游标，由于游标的效率较差，若是游标操做的数据超过1万行，那么就应该考虑改写。

26.使用基于游标的方法或临时表方法以前，应先寻找基于集的解决方案来解决问题，基于集的方法一般更有效。

27. 与临时表同样，游标并非不可以使用。对小型数据集使用 FAST_FORWARD 游标一般要优于其余逐行处理方法，尤为是在必须引用几个表才能得到所需的数据时。在结果集中包括“合计”的例程一般要比使用游标执行的速度快。若是开发时 间容许，基于游标的方法和基于集的方法均可以尝试一下，看哪种方法的效果更好。

28.在全部的存储过程和触发器的开始处设置 SET NOCOUNT ON ，在结束时设置 SET NOCOUNT OFF 。无需在执行存储过程和触发器的每一个语句后向客户端发送 DONE_IN_PROC 消息。

29.尽可能避免大事务操做，提升系统并发能力。

30.尽可能避免向客户端返回大数据量，若数据量过大，应该考虑相应需求是否合理 一、避免将字段设为“容许为空” 二、数据表设计要规范 三、深刻分析数据操做所要对数据库进行的操做 四、尽可能不要使用临时表 五、多多使用事务 六、尽可能不要使用游标 七、避免死锁 八、要注意读写锁的使用 九、不要打开大的数据集 十、不要使用服务器端游标 十一、在程序编码时使用大数据量的数据库 十二、不要给“性别”列建立索引 1三、注意超时问题 1四、不要使用Select * 1五、在细节表中插入纪录时，不要在主表执行Select MAX(ID) 1六、尽可能不要使用TEXT数据类型 1七、使用参数查询 1八、不要使用Insert导入大批的数据 1九、学会分析查询 20、使用参照完整性 2一、用INNER JOIN 和LEFT JOIN代替Where /////////////////////////////////////////////////////////////////////////////////////////// http://blog.sina.com.cn/s/blog_4b3d79a9010006gv.html 提升SQL查询效率（要点与技巧）： ? 技巧一： 问题类型：ACCESS数据库字段中含有日文片假名或其它不明字符时查询会提示内存溢出。 解决方法：修改查询语句 sql="select * from tablename where column like '%"&word&"%'" 改成 sql="select * from tablename" rs.filter = " column like '%"&word&"%'" =========================================================== 技巧二： 问题类型：如何用简易的办法实现相似百度的多关键词查询（多关键词用空格或其它符号间隔）。 解决方法： '//用空格分割查询字符串 ck=split(word," ") '//获得分割后的数量 sck=UBound(ck) sql="select * tablename where" 在一个字段中查询 For i = 0 To sck SQL = SQL & tempJoinWord & "(" & _ "column like '"&ck(i)&"%')" tempJoinWord = " and " Next 在二个字段中同时查询 For i = 0 To sck SQL = SQL & tempJoinWord & "(" & _ "column like '"&ck(i)&"%' or " & _ "column1 like '"&ck(i)&"%')" tempJoinWord = " and " Next =========================================================== 技巧三：大大提升查询效率的几种技巧

1. 尽可能不要使用 or，使用or会引发全表扫描，将大大下降查询效率。
2. 通过实践验证，charindex()并不比前面加%的like更能提升查询效率，而且charindex()会使索引失去做用（指sqlserver数据库）
3. column like '%"&word&"%' 会使索引不起做用
column like '"&word&"%' 会使索引发做用（去掉前面的%符号）
（指sqlserver数据库）
4. '%"&word&"%' 与'"&word&"%' 在查询时的区别：
好比你的字段内容为 一个容易受伤的女人
'%"&word&"%' ：会通配全部字符串，不论查“受伤”仍是查“一个”，都会显示结果。
'"&word&"%' ：只通配前面的字符串，例如查“受伤”是没有结果的，只有查“一个”，才会显示结果。
5. 字段提取要按照“需多少、提多少”的原则，避免“select *”，尽可能使用“select 字段1,字段2,字段3........”。实践证实：每少提取一个字段，数据的提取速度就会有相应的提高。提高的速度还要看您舍弃的字段的大小来判断。
6. order by按汇集索引列排序效率最高。一个sqlserver数据表只能创建一个汇集索引，通常默认为ID，也能够改成其它的字段。
7. 为你的表创建适当的索引，创建索引可使你的查询速度提升几十几百倍。（指sqlserver数据库）
? 如下是创建索引与不创建索引的一个查询效率分析：
Sqlserver索引与查询效率分析。
表 News
字段
Id：自动编号
Title：文章标题
Author：做者
Content：内容
Star：优先级
Addtime：时间
记录：100万条
测试机器：P4 2.8/1G内存/IDE硬盘
=======================================================
方案1：
主键Id，默认为汇集索引，不创建其它非汇集索引
select * from News where Title like '%"&word&"%' or Author like '%"&word&"%' order by Id desc
从字段Title和Author中模糊检索，按Id排序
查询时间：50秒
=======================================================
方案2：
主键Id，默认为汇集索引
在Title、Author、Star上创建非汇集索引
select * from News where Title like '"&word&"%' or Author like '"&word&"%' order by Id desc
从字段Title和Author中模糊检索，按Id排序
查询时间：2 - 2.5秒
=======================================================
方案3：
主键Id，默认为汇集索引
在Title、Author、Star上创建非汇集索引
select * from News where Title like '"&word&"%' or Author like '"&word&"%' order by Star desc
从字段Title和Author中模糊检索，按Star排序
查询时间：2 秒
=======================================================
方案4：
主键Id，默认为汇集索引
在Title、Author、Star上创建非汇集索引
select * from News where Title like '"&word&"%' or Author like '"&word&"%'
从字段Title和Author中模糊检索，不排序
查询时间：1.8 - 2 秒
=======================================================
方案5：
主键Id，默认为汇集索引
在Title、Author、Star上创建非汇集索引
select * from News where Title like '"&word&"%'
或
select * from News where Author like '"&word&"%'
从字段Title 或 Author中检索，不排序
查询时间：1秒
? 如何提升SQL语言的查询效率?
问：请问我如何才能提升SQL语言的查询效率呢？
答：这得从头提及：
   因为SQL是面向结果而不是面向过程的查询语言，因此通常支持SQL语言的大型关系型数据库都使用一个基于查询成本的优化器，为即时查询提供一个最佳的执行策略。对于优化器，输入是一条查询语句，输出是一个执行策略。
    一条SQL查询语句能够有多种执行策略，优化器将估计出所有执行方法中所需时间最少的所谓成本最低的那一种方法。全部优化都是基于用记所使用的查询语句中的where子句，优化器对where子句中的优化主要用搜索参数(Serach Argument)。
    搜索参数的核心思想就是数据库使用表中字段的索引来查询数据，而没必要直接查询记录中的数据。
    带有 =、<、<=、>、>= 等操做符的条件语句能够直接使用索引，以下列是搜索参数：
    emp_id = "10001" 或 salary > 3000 或  a =1 and c = 7
    而下列则不是搜索参数：
    salary = emp_salary 或 dep_id != 10 或 salary * 12 >= 3000 或 a=1 or c=7
    应当尽量提供一些冗余的搜索参数，使优化器有更多的选择余地。请看如下3种方法：
    第一种方法：
    select employee.emp_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (department.dep_code="01") and (employee.dep_code="01");
    它的搜索分析结果以下：
    Estimate 2 I/O operations
    Scan department using primary key
    for rows where dep_code equals "01"
    Estimate getting here 1 times
    Scan employee sequentially
    Estimate getting here 5 times
    第二种方法：
    select employee.emp_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (department.dep_code="01");
    它的搜索分析结果以下：
    Estimate 2 I/O operations
    Scan department using primary key
    for rows where dep_code equals "01"
    Estimate getting here 1 times
    Scan employee sequentially
    Estimate getting here 5 times
    第一种方法与第二种运行效率相同，但第一种方法最好，由于它为优化器提供了更多的选择机会。
    第三种方法：
    select employee.emp_name,department.dep_name from department,employee where (employee.dep_id = department.dep_id) and (employee.dep_code="01");
    这种方法最很差，由于它没法使用索引，也就是没法优化……
使用SQL语句时应注意如下几点：
    一、避免使用不兼容的数据类型。例如，Float和Integer，Char和Varchar，Binary和Long Binary不兼容的。数据类型的不兼容可能使优化器没法执行一些本能够进行的优化操做。例如：
    select emp_name form employee where salary > 3000;
    在此语句中若salary是Float类型的，则优化器很难对其进行优化，由于3000是个整数，咱们应在编程时使用3000.0而不要等运行时让DBMS进行转化。
    二、尽可能不要使用表达式，因它在编绎时是没法获得的，因此SQL只能使用其平均密度来估计将要命中的记录数。
    三、避免对搜索参数使用其余的数学操做符。如：
       select emp_name from employee where salary * 12 > 3000;
       应改成：
       select emp_name from employee where salary  > 250;
    四、避免使用 != 或 <> 等这样的操做符，由于它会使系统没法使用索引，而只能直接搜索表中的数据。
? ORACAL中的应用
一个1600万数据表－－短信上行表TBL_SMS_MO
结构：
CREATE TABLE TBL_SMS_MO
(
 SMS_ID NUMBER,
 MO_ID VARCHAR2(50),
 MOBILE VARCHAR2(11),
 SPNUMBER VARCHAR2(20),
 MESSAGE VARCHAR2(150),
 TRADE_CODE VARCHAR2(20),
 LINK_ID VARCHAR2(50),
 GATEWAY_ID NUMBER,
 GATEWAY_PORT NUMBER,
 MO_TIME DATE DEFAULT SYSDATE
);
CREATE INDEX IDX_MO_DATE ON TBL_SMS_MO (MO_TIME)
  PCTFREE 10
  INITRANS 2
  MAXTRANS 255
  STORAGE
  (
    INITIAL 1M
    NEXT 1M
    MINEXTENTS 1
    MAXEXTENTS UNLIMITED
    PCTINCREASE 0
  );
CREATE INDEX IDX_MO_MOBILE ON TBL_SMS_MO (MOBILE)
  PCTFREE 10
  INITRANS 2
  MAXTRANS 255
  STORAGE
  (
    INITIAL 64K
    NEXT 1M
    MINEXTENTS 1
    MAXEXTENTS UNLIMITED
    PCTINCREASE 0
  );
　　问题：从表中查询某时间段内某手机发送的短消息，以下SQL语句：
SELECT MOBILE,MESSAGE,TRADE_CODE,MO_TIME
FROM TBL_SMS_MO
WHERE MOBILE='130XXXXXXXX'
AND MO_TIME BETWEEN TO_DATE('2006-04-01','YYYY-MM-DD HH24:MI:SS') AND TO_DATE('2006-04-07','YYYY-MM-DD HH24:MI:SS')
ORDER BY MO_TIME DESC
返回结果大约须要10分钟，应用于网页查询，简直难以忍受。
分析：
在PL/SQL Developer，点击“Explain Plan”按钮（或F5键），对SQL进行分析，发现缺省使用的索引是IDX_MO_DATE。问题可能出在这里，由于相对于总数量1600万数据来讲， 都mobile的数据是不多的，若是使用IDX_MO_MOBILE比较容易锁定数据。
以下优化：
SELECT MOBILE,MESSAGE,TRADE_CODE,MO_TIME
FROM TBL_SMS_MO
WHERE MOBILE='130XXXXXXXX'
AND MO_TIME BETWEEN TO_DATE('2006-04-01','YYYY-MM-DD HH24:MI:SS') AND TO_DATE('2006-04-07','YYYY-MM-DD HH24:MI:SS')
ORDER BY MO_TIME DESC
测试：
按F8运行这个SQL，哇～... ... 2.360s，这就是差异。
用索引提升SQL Server性能
特别说明
　　在微软的SQL Server系统中经过有效的使用索引能够提升数据库的查询性能，可是性能的提升取决于数据库的实现。在本文中将会告诉你如何实现索引并有效的提升数据库的性能。　
　　
　 　在关系型数据库中使用索引可以提升数据库性能，这一点是很是明显的。用的索引越多，从数据库系统中获得数据的速度就越快。然而，须要注意的是，用的索引 越多，向数据库系统中插入新数据所花费的时间就越多。在本文中，你将了解到微软的SQL Server数据库所支持的各类不一样类型的索引，在这里你将了解到如何使用不一样的方法来实现索引，经过这些不一样的实现方法，你在数据库的读性能方面获得的 远比在数据库的总体性能方面的损失要多得多。
　　
　　索引的定义
　　索引是数据库的工具，经过使用索引，在数据库中获取数据的时 候，就能够不用扫描数据库中的全部数据记录，这样可以提升系统获取数据的性能。使用索引能够改变数据的组织方式，使得全部的数据都是按照类似的结构来组织 的，这样就能够很容易地实现数据的检索访问。索引是按照列来建立的，这样就能够根据索引列中的值来帮助数据库找到相应的数据。
　　
　　索引的类型
　 　微软的SQL Server 支持两种类型的索引：clustered 索引和nonclustered索引。Clustered 索引在数据表中按照物理顺序存储数据。由于在表中只有一个物理顺序，因此在每一个表中只能有一个clustered索引。在查找某个范围内的数据 时，Clustered索引是一种很是有效的索引，由于这些数据在存储的时候已经按照物理顺序排好序了。
　　
　　 Nonclustered索引不会影响到下面的物理存储，可是它是由数据行指针构成的。若是已经存在一个clustered索引，在 nonclustered中的索引指针将包含clustered索引的位置参考。这些索引比数据更紧促，并且对这些索引的扫描速度比对实际的数据表扫描要 快得多。
　　
　　如何实现索引
　　数据库能够自动建立某些索引。例如，微软的SQL Server系统经过自动建立惟一索引来强制实现UNIQUE约束，这样能够确保在数据库中不会插入重复数据。也可使用CREATE INDEX语句或者经过SQL Server Enterprise Manager来建立其余索引，SQL Server Enterprise Manager还有一个索引建立模板来指导你如何建立索引。
　　
　　获得更好的性能
　　虽然索引能够带来性能上的优点，可是同时 也将带来必定的代价。虽然SQL Server系统容许你在每一个数据表中建立多达256个nonclustered索引，可是建议不要使用这么多的索引。由于索引须要在内存和物理磁盘驱动 器上使用更多的存储空间。在执行插入声明的过程当中可能会在必定程度上致使系统性能的降低，由于在插入数据的时候是须要根据索引的顺序插入，而不是在第一个 可用的位置直接插入数据，这样一来，存在的索引越多将致使插入或者更新声明所须要的时间就越多。
　　
　　在使用SQL Server系统建立索引的时候，建议参照下面的建立准则来实现：
　　
　　正确的选择数据类型
　 　在索引中使用某些数据类型能够提升数据库系统的效率，例如，Int，bigint， smallint，和tinyint等这些数据类型都很是适合于用在索引中，由于他们都占用相同大小的空间而且能够很容易地实现比较操做。其余的数据类型 如char和varchar的效率都很是低，由于这些数据类型都不适合于执行数学操做，而且执行比较操做的时间都比上面提到数据类型要长。
　　
　　确保在使用的过程当中正确的利用索引值
　 　在执行查询操做时，可能所使用的列只是clustered的一部分，这时尤为要注意的是如何使用这些数据。当用这些数据列做为参数调用函数时，这些函数 可能会使现有的排序优点失效。例如，使用日期值做为索引，而为了实现比较操做，可能须要将这个日期值转换为字符串，这样将致使在查询过程当中没法用到这个日 期索引值。
　　
　　在建立多列索引时，须要注意列的顺序
　　数据库将根据第一列索引的值来排列记录，而后进一步根据第二列的值来排序，依次排序直到最后一个索引排序完毕。哪一列惟一数据值较少，哪一列就应该为第一个索引，这样能够确保数据能够经过索引进一步交叉排序。
　　
　　在clustered索引中限制列的数量
　　在clustered索引中用到的列越多，在nonclustered索引中包含的clustered索引参考位置就越多，须要存储的数据也就越多。这样将增长包含索引的数据表的大小，而且将增长基于索引的搜索时间。
　　
　　避免频繁更新clustered索引数据列
　 　因为nonclustered 索引依赖于clustered 索引，因此若是构成clustered 索引的数据列频繁更新，将致使在nonclustered中存储的行定位器也将随之频繁更新。对于全部与这些列相关的查询来讲，若是发生记录被锁定的状况 时，这将可能致使性能成本的增长。
　　
　　分开操做（若是可能的话）
　　对于一个表来讲，若是须要进行频繁的执行插入、更新操做，同时还有大量读操做的话，在可能的状况下尝试将这个表分开操做。全部的插入和更新操做能够在一个没有索引的表中操做，而后将其复制到另一个表中，在这个表里有大量的索引能够优化读数据的能力。
　　
　　适当的重建索引
　 　Nonclustered索引包含clustered索引的指针，这样一来Nonclustered索引将从属于clustered 索引。当重建clustered索引时，首先是丢弃原来的索引，而后再使用CREATE INDEX 来建立索引，或者在使用CREATE INDEX 声明的同时将DROP_EXISTING 子句做为重建索引的一部分。将丢弃和建立分为几步将会致使屡次重建nonclustered 索引，而不象使用DROP_EXISTING 子句那样，只重建一次nonclustered 索引。
　　
　　明智的使用填充因子
　 　数据存储在那些具备固定大小的连续内存页面内。随着新的记录行的加入，数据内存页将逐渐被填满，系统就必须执行数据页的拆分工做，经过这个拆分工做将部 分数据转移到下一个新的页面当中。这样的拆分以后，将加剧系统的负担，而且会致使存储的数据支离破碎。填充因子能够维护数据之间的缺口，通常在建立索引的 时候，该索引的填充因子就已经被设置好了。这样一来，能够减小插入数据所引发的页面分裂的次数。由于只是在建立索引的时候才维护空间的大小，在增长数据或 者更新数据时不会去维护空间的大小。所以，要想可以充分的利用填充因子，就必须周期性的重建索引。由填充因子所形成的缺口将致使读性能的降低，由于随着数 据库的扩张，愈来愈多的磁盘存取工做须要读取数据。因此，在读的次数超过写的次数的时候，很重要的一点是考虑使用填充因子仍是使用缺省方式合适。
　　
　　管理层的决策
　 　经过有效的使用索引，能够在微软的SQL Server系统中实现很好的查询功能，可是使用索引的效率取决于几种不一样的实现决策。在索引的性能平衡方面，要作出正确的数据库管理决策意味着须要在良 好的性能和困境中抉择。在特定的状况下，本文给出的一些建议将有助于你作出正确的决策