|
SQLServer2000里自动重建索引
* Y( s4 w$ m; [, XSQLServer2000里自动重建索引 ' X2 w* N4 c* T3 \2 E
--王成辉翻译整理，转贴请注明出自微软BI开拓者www.windbi.com
* ^" b% G2 Y; [7 [--原帖地址
" m6 `1 f: i. B: T) c2 _9 S9 n在所有的OLTP环境里，实质上所有的索引都将随着时间产生碎片。几乎所有的UPDATE、INSERT、DELETE活动都将引起索引比最初创建时变得更无组织。页拆分更多，大量的页上只有很少的数据，因此满足每个SELECT需要更多的I/O。数据和索引的碎片越多，应用程序就会更慢，数据花费的空间就更多。对此你能做什么呢？你可以定期的重建索引。 ( n5 C5 [$ E& d7 a' ]6 b2 u
那么什么可以立即使用呢？ - `6 |& l' \- l/ I, a3 z8 q
基本上你可以使用数据库维护向导来执行索引重建，创建维护计划来完成。如果你原意接受它固有的缺陷，这也可以使用。首先，用维护向导来配置和完成索引重建是不慎重的。它将重建每一个索引，不管它是否需要重建。如果你有一个有很多大表和大量索引的大数据库，这会出问题，因为不加区别的重建整个数据库的索引会花费很长的时间，会使你的维护窗口不可用。问题在于，要么全部重建，要么全部不重建，你根本不能以任何方式分批处理数据库的表。 6 }: _: N/ y9 j% E
! Z* N8 Q2 A$ B! c9 b 0 v/ u7 M; O& Q- y2 a0 S
那么有什么别的能做吗？你可以写一个脚本来重建选择的表的索引。这样你能对数据库分批处理以减少在重建索引时你维护窗口执行的时间。你需要将这个时间减小到最少，因为重建索引会对表执行排它锁，在重建索引期间禁止用户访问。所以你可以每周的每个工作日的晚上重建五分之一表的索引，所有的索引至少一周做一次。然而，这也是不慎重的――你将重建所有表的索引而不论数据和索引是否是有碎片。 2 v6 O2 X3 l9 Q& ]. G
这里推荐选择性的重建索引。你需要检查表的索引和数据的碎片，保留数据，据此操作，重建索引要用确定的且区别对待的方式。仅仅通过这样系统的方法，你可以仅重建那些实际需要重建的表的数据和索引。而且也只有这种方式能最小化索引重建的时间。在整个索引重建期间，如果你不想影响你的用户的话，减少索引重建的时间是至关重要的。 8 {1 a! [. q" d
那么我们怎样可以解决呢？ - q& |* j6 }' V1 ?# a, o/ \7 t
可以使用命令 , U) k, b9 I6 \8 h; [% i5 x
DBCC SHOWCONTIG() 8 L- a, D0 A, M* F1 ]! w0 ~
SQLServer2000比以前版本有一个大的改进就是这个简单而又至关重要的命令。DBCC SHOWCONTIG是SQLServer提供来检查索引碎片情况的工具。在以前的版本里（7.0和更早的版本），这个命令只输出文本，如果手工处理这个命令很好，然而，要实现自动化目的，它会带来严重的问题。那意味着你要循环执行每一个表并将结果输出到文本文件，然后为了读和解释原文的输出结果以便获得你寻找的信息，需要进行烦人的结构化处理。 4 E& y) M" i1 r, n; j1 m# p
SQLServer2000对DBCC SHOWCONTIG()命令引进了一个关键子句，名为WITH TABLERESULTS。这意味着你能运行这个命令然后将捕获的数据直接输出到表里，而不是还需要使用XP_CMDSHELL来操作的文本文件里。
" V1 } a6 `' c* S. G# a4 o在SQLServer2000里，这意味着你能结构化的循环处理表，通过在它们上面运行DBCC SHOWCONTIG命令以将捕获碎片信息插入表中。然后你能循环使用这个结果，根据碎片的情况，选择性的进行碎片整理。可以用下面的存储过程实现： u( {+ H, k* g: {: c) U+ I% j' G8 e
CREATE PROCEDURE sp_defragment_indexes @maxfrag DECIMAL 2 p% P% L0 R2 }' u+ @! K" [6 ]
AS --王成辉翻译整理，转贴请注明出处 . y2 O- p! ]$ |# ?' `9 S3 {7 a
--声明变量
0 O# ~. [0 y; a- JSET NOCOUNT ON 6 y0 C( o; y1 T
DECLARE @tablename VARCHAR (128)
k" q6 l; J; yDECLARE @execstr VARCHAR (255) ' v" p0 N1 m1 |4 K" N2 h1 P% u
DECLARE @objectid INT
. K9 f- O8 ^9 \) a) j0 }DECLARE @objectowner VARCHAR(255)
4 V( |" b( O8 i4 U5 Y2 jDECLARE @indexid INT
1 y7 w% d' ]$ C5 E& L2 iDECLARE @frag DECIMAL ; W3 z- T0 X( f k3 o& l
DECLARE @indexname CHAR(255)
3 K1 ?* A* }6 h. qDECLARE @dbname sysname
# U% J) B& N6 _DECLARE @tableid INT ; H0 b) t" D4 l& ?5 J2 ~
DECLARE @tableidchar VARCHAR(255)
/ U1 g3 M0 b# G8 \# S- C1 t1 j% C% g--检查是否在用户数据库里运行 % O- n& L& u9 d j( K; A
SELECT @dbname = db_name()
/ @! ~' y& B$ [8 {5 {6 h) @, t' sIF @dbname IN ('master', 'msdb', 'model', 'tempdb') " k; k2 e0 J, N/ J; V
BEGIN " f8 Y y( l, E! A8 S; I
PRINT 'This procedure should not be run in system databases.'
3 r" H/ H( s9 uRETURN / @ }: G* ~1 E7 H8 f+ l
END
) e3 [6 V( z3 N1 \& x--第1阶段:检测碎片 ; Z% x/ E; F9 B) t# i- \. V8 t
--声明游标
0 Z! G( E6 s1 L5 l# d- m) \. |DECLARE tables CURSOR FOR 7 V @) X E9 l# S
SELECT convert(varchar,so.id)
5 P" ]! s0 {- a8 GFROM sysobjects so
+ G6 ]4 e! k E- ~0 Y" \' WJOIN sysindexes si
% W1 u6 p9 a9 T' l' O7 }, M* a, K& SON so.id = si.id
3 D4 p$ `5 ^% f9 f" d; m* DWHERE so.type ='U' ( H+ q, J& S. a. P
AND si.indid < 2 - Q% ?: N/ h9 I8 Q! v4 B9 V
AND si.rows > 0
+ _2 Y0 ^0 n$ k-- 创建一个临时表来存储碎片信息 9 d! ?+ W" t0 S/ g; Y# m" H' Y
CREATE TABLE #fraglist (
+ x% {; O! Q2 y; _- R: ZObjectName CHAR (255), J# U' W6 S; O: A# e9 S
ObjectId INT,
9 C+ o1 O) z. O% t! A; }8 g* f$ RIndexName CHAR (255),
8 B/ J6 c+ `9 C' R' mIndexId INT, . C! ` t5 }) _, W6 }; X
Lvl INT,
. t8 x6 M" z6 i+ f v+ ACountPages INT,
- d. F' D7 R8 d: X- p6 ACountRows INT, O" e+ Z. p y+ s2 `. m5 y7 Y
MinRecSize INT, , X* i$ c, W% @, {, ?/ F
MaxRecSize INT,
2 d0 K; v" F0 k' a$ g, lAvgRecSize INT,
. X6 T8 p: o" K6 NForRecCount INT, ) x, \4 F- t$ E! g7 `
Extents INT,
3 c& b+ Z6 `+ `- i* n4 K8 ^ExtentSwitches INT, ! R$ G& L- d! \
AvgFreeBytes INT, ; i4 ?9 Y5 ^ f% Q0 u
AvgPageDensity INT, 5 ?' Y! L/ y7 x, u5 R
ScanDensity DECIMAL,
( y* t% Q! @) C6 n, o7 gBestCount INT, ) u+ q0 x( A2 n5 D( q
ActualCount INT, 4 C" d* \- e5 F8 ?1 X0 y: a
LogicalFrag DECIMAL, % B, p& H$ R% h+ V
ExtentFrag DECIMAL) ( {4 t+ e4 K1 y) [% e$ J0 X
--打开游标 + b7 P2 r. ?: W6 @) ?' L
OPEN tables
! P. O0 T5 z: [) u- e2 h" a3 F-- 对数据库的所有表循环执行dbcc showcontig命令
1 f4 x: e1 B: n# w) V) t+ ?FETCH NEXT
* v$ z: z! ^9 H- v5 D4 B" C8 oFROM tables 3 S6 M2 L# {% M5 b2 ?& C
INTO @tableidchar / @! P- h# u* G0 l
WHILE @@FETCH_STATUS = 0
0 S8 E z$ ^& l3 v" f! Y9 \BEGIN
7 _0 ]/ c: o9 c& L) p--对表的所有索引进行统计
' j; ]# w% d- ?$ K: _% y. YINSERT INTO #fraglist
& E& v! o6 x, [' s9 KEXEC ('DBCC SHOWCONTIG (' + @tableidchar + ') WITH FAST, TABLERESULTS, ALL_INDEXES, NO_INFOMSGS')
7 I6 V M4 i! \- Q; g/ D/ XFETCH NEXT
( N* k' [1 I/ d. V' G3 DFROM tables
9 _' {7 R$ h# O4 H8 q6 x J) JINTO @tableidchar
$ X# i6 R0 b, {, A+ jEND 0 ^: G: p# K, @. ~) O6 ?
-- 关闭释放游标
- e/ U8 ^/ \& o3 e4 y: MCLOSE tables 4 V% r! j: g* _
DEALLOCATE tables
: W( B% y+ X9 o7 u-- 为了检查，报告统计结果
% H9 i; |6 X: M& hSELECT * FROM #fraglist 7 m& i, c3 H6 V4 o1 M p3 ^
--第2阶段: (整理碎片) 为每一个要整理碎片的索引声明游标 2 w4 k2 T8 `2 L' C6 V
DECLARE indexes CURSOR FOR . K/ O1 l* e# d6 }
SELECT ObjectName, ObjectOwner = user_name(so.uid), ObjectId, IndexName, ScanDensity , s1 a) H5 r: z# ~! L( y4 S
FROM #fraglist f ) ^* v b; Y" z7 ^& Q) V1 C9 C
JOIN sysobjects so ON f.ObjectId=so.id
4 ^6 e# s/ O" s) \WHERE ScanDensity <= @maxfrag
, b1 B# z3 W2 h5 E1 N/ jAND INDEXPROPERTY (ObjectId, IndexName, 'IndexDepth') > 0 1 G0 k) Z' t) g/ x3 i
-- 输出开始时间
5 u/ w* ?! z4 [$ ?SELECT 'Started defragmenting indexes at ' + CONVERT(VARCHAR,GETDATE()) 8 C. ? O2 ?$ ]9 x4 N$ j" `1 Y
--打开游标
% P( Q% Y' Y; `# N+ A5 X* OOPEN indexes
$ m/ s2 p" O/ \0 L0 d8 M--循环所有的索引 / }! z) n( Y V; U0 D
FETCH NEXT 4 {4 {' g# ^" N2 x' p9 x
FROM indexes
. t i! C! M8 b& jINTO @tablename, @objectowner, @objectid, @indexname, @frag
1 t! O% b L; f' }7 S* ]+ DWHILE @@FETCH_STATUS = 0
" S. Q9 y. l. H9 ^# x8 sBEGIN
9 R% [6 b& o- P3 [" T3 GSET QUOTED_IDENTIFIER ON 1 Q; I/ b L4 p: [
SELECT @execstr = 'DBCC DBREINDEX (' + '''' +RTRIM(@objectowner) + '.' + RTRIM(@tablename) + '''' +
( D& g. F" z5 `', ' + RTRIM(@indexname) + ') WITH NO_INFOMSGS'
2 `, J2 O3 `: q! f. SSELECT 'Now executing: ' 5 }9 e) [ V. o* y z8 c/ a
SELECT(@execstr)
1 b2 C- p8 v2 [# [! {+ ^2 aEXEC (@execstr)
( c; x; b5 H8 N: W& C( VSET QUOTED_IDENTIFIER OFF
4 k" p. I* A2 D, w3 eFETCH NEXT . i* p- {( V2 O$ M! Q
FROM indexes ' X4 f* s5 o* ~8 `0 p- H' q' n
INTO @tablename, @objectowner, @objectid, @indexname, @frag ! M5 T7 z9 g0 {$ ?2 g. i$ j
END
* b: p7 M1 _; [6 C. T. }- e-- 关闭释放游标
8 F6 I1 u7 J" H0 D. O% Z/ H, mCLOSE indexes 8 \# d5 f; e- t% h p
DEALLOCATE indexes
( T6 ]4 f- E3 h5 T' \% Y-- 报告结束时间 " Q2 z( l: Y' z; [. L) p. u, J2 e
SELECT 'Finished defragmenting indexes at ' + CONVERT(VARCHAR,GETDATE())
3 T5 w) V s3 b5 G( }0 j-- 删除临时表
4 J+ _( }- C+ [. n6 {% }DROP TABLE #fraglist ! D( w$ g5 O6 r& C2 n
GO
0 Q2 z _% }% b; W8 g& k# V8 ~使用 ) t2 X7 a" j' x9 p
这个存储过程应该创建在master数据库里，以便你能在服务器上的任何用户数据库里使用。 / \" u. v! N# l- C$ C
在用户数据库里通过传递一个参数（MAXFRAG）来运行。该参数是一个百分比值。意思是任何索引的碎片扫描密度小于这个值。例如，如果你想要整理那些扫描密度小于95％的索引的碎片： 0 W2 m5 a) ?2 f4 y* ?
USE pubs : \) E h% A" ?' o+ g! e
GO
3 @$ }& {) m3 c% v( ^3 w' CEXEC sp_deframent_indexes 95.00
6 k- g F; b4 w- J2 p局限
' r& B" G; e: ]" i1 {: P, ~这个过程依赖于的标准是扫描密度，但扫描密度对于那些跨越多个文件的索引来说不是一个有效的标准。如果你的索引确实跨越多个文件，你需要用另一个标准（如Logical Frag）来更改这个存储过程。然而，这类更改超过本文的范围；如果你的索引跨越多个文件，你需要做更多的工作。 ; e1 J: ~8 S+ K) _; d
怎样做，做什么？
/ P0 b0 K, [- x6 K这个存储过程有两个独特的部分。 0 C1 b2 H: A0 Y6 C% L
第1阶段 7 s5 I3 j9 _' P
在这部分里，存储过程通过在数据库里的每个表上运行下面的命令来检查索引碎片： 0 D& [/ ^& [& d& T2 [: N& Y1 y- d
DBCC SHOWCONTIG (‘tablename') WITH FAST, TABLERESULTS, ALL_INDEXES, NO_INFOMSGS 0 d% A8 P* D' M
命令的结果存储在预先创建的临时表#fraglist里。这里就会用到DBCC SHOWCONTIG 语句的WITH TABLERESULTS的好处，仅这一点，真正的节省了太多的以前版本得到同样结果所花费的麻烦和精力。
5 P3 g' c* B8 k$ n7 f你应该注意该存储过程工作的数据库的表的拥有者是不是dbo，通常是。我发现我最初的版本不起作用，当时一个软件经销商给我们提供的新系统的数据库里就出现了拥有者不是dbo的表。当我在这个新系统上第一次运行我的碎片整理过程时，这个程序的缺点就暴露无遗了，最后彻底失败。这个问题实际上出现在碎片整理阶段（阶段2），因为表在这里要引用表名，而在阶段1，DBCC SHOWCONTIG命令引用的时表的ID即object_id。
6 _; W* p) H' l, G第2阶段
1 B) y7 F/ Z$ y" m9 @这儿使用了另一个游标来循环处理表#fraglist里的记录，这些记录是那些扫描密度低于传给存储过程参数的那个阈值的表： 3 S0 K6 g+ E h# G$ c
DBCC DBREINDEX()
6 I( ] \) U& V. d( P5 ]* Z4 I执行的结果以输出文件的形式显示在表#fraglist的内容之后，以便你能查看表和索引的碎片，正如屏幕上所显示的那样，也可以通过查看DBCC DBREINDEX()执行的结果列表来查看采取的动作。利用这些你也能推导出每个索引重建的时间。 ! W! l4 f: I1 V/ k- v: l
输出结果是什么意思？
$ `6 K2 N& J* B5 \输出示例： ' }. I9 B: m& x5 d& q& S* \
$ ?9 ^7 @7 i- E5 L. W上面是在Excel里打开的存储过程输出文本文件的一个截屏。为了简洁一些列已经删掉了。你需要用文本文件向导来打开它，选择固定列宽，打开导入从第三行起。
# R7 K" ^" e5 ]+ U这里，你能够检查你选择检查的数据库里的表的扫描密度。
7 z0 y4 w l& L: G6 I+ Z) Y在接下来的输出文件里（DBCC SHOWCONTIG输出结果的后面），你会发现正被重建索引的每个表或索引的细节，这部分的开始和结束部分都有重建索引的开始和结束时间。如下面例子显示的那样： 3 n3 g+ D! z, c" e! m) x! M5 {
" k- F0 N. B: T# [: C
为什么不使用DBCC INDEXDEFRAG()去减少阻塞？
. v, A' x% o; a$ e) z3 I2 @) ^答案是如果你想要或者需要的话就使用它。如果你需要7×24小时的在线操作，那么DBCC DBREINDEX()的排他表锁不适合你的业务，你可以使用它来代替DBCC DBREINDEX()。然而，你需要适当改变一下语法，因为它们是不相同的（谢谢，微软！）。如果你不知道它们的区别，这里有一个简单的摘要：当运行DBCC DBREINDEX()的时候，必须对表有排他锁，因为它是一个完全的，彻头彻尾的索引重建操作。而DBCC INDEXDEFRAG()就不那么完全了，在线的操作试图改善你索引的环境而不至于引起阻塞和中断OLTP（希望如此）。我必须承认我从来不用DBCC INDEXDEFRAG()，因为很幸运的是我的系统不需要严格的7×24在线且要求不阻塞，所以我不敢担保是否有效率。我已经理解它不是和DBCC DBREINDEX一样有效率。然而它的确比什么都没有强，所以如果你的数据库运行一个全球的WEB站点并且从来不能停止，这在今天这也很普遍，那么你需要使用它来代替以改变这个存储过程。
: k! |1 L8 K$ s: g+ B7 w: c5 r8 k3 G添加到调度任务里 1 D6 X8 L* R+ Z. e
对于有相当经验的DBA来说这是一个相关的微不足道的任务，所以我在这里不会提供它的代码。作为一个独立的任务或在你存在的维护作业里的一个步骤都行。你要确保作业的步骤或作业里的输出结果是一个文本文件以便你能保存和查看所有重要的输出文件。
: _. J l# C8 O9 R7 z" B3 ~/ n结论 / p# E$ p& B( Z% d, C$ [
希望这篇文章和代码能帮助你完成一个对数据库服务器维护来说更好的更精确的方法。现在的维护窗口开销很大，所以在影响用户和执行时间上保持最小的同时也提供了有效率和良好的数据库服务器维护。用调度作业实现这个过程，小心的监控它的输出结果。 | 
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
抢沙发
千斤顶
显身卡
详细信息 7 T9 j* k- D5 J9 |# r7 J
300x180 AD
