Resolve index fragmentation by reorganizing or rebuilding indexes

• 03/19/2020
• 21 minutes to read
• • p
  • j
  • M
  • M
  • d
  • +11

Applies to: SQL Server (alle støttede versjoner) Azure SQL Database Azure SQL Administrert Forekomst Azure Synapse Analytics parallel data warehouse

denne artikkelen beskriver hvordan indeksdefragmentering oppstår og diskuterer dens innvirkning på spørringsytelsen. Når du har bestemt hvor mye fragmentering som finnes for en indeks, kan du defragmentere en indeks ved å omorganisere en indeks eller gjenoppbygge en indeks ved å kjøre Transact-SQL-kommandoer i verktøyet du velger, eller VED Å bruke SQL Server Management Studio.

Oversikt over indeksfragmentering

hva er indeksfragmentering og hvorfor skal jeg bry meg om det:

• Fragmentering eksisterer når indekser har sider der den logiske rekkefølgen i indeksen, basert på indeksens nøkkelverdi, ikke samsvarer med den fysiske rekkefølgen på indekssidene.
• Databasemotoren endrer automatisk indekser når sette inn, oppdatere eller slette operasjoner er gjort til de underliggende dataene. Hvis du for eksempel legger til rader i en tabell, kan det føre til at eksisterende sider i rowstore-indekser deles for å gi plass til innsetting av nye nøkkelverdier. Over tid kan disse endringene føre til at informasjonen i indeksen blir spredt i databasen (fragmentert). Fragmentering eksisterer når indekser har sider der den logiske rekkefølgen, basert på nøkkelverdien, ikke samsvarer med den fysiske rekkefølgen i datafilen.
• Tungt fragmenterte indekser kan forringe spørringsytelsen fordi det kreves ekstra I / O for å finne data som indeksen peker på. Mer I / O fører til at søknaden din reagerer sakte, spesielt når skanneoperasjoner er involvert.

Oppdage mengden fragmentering

det første trinnet i å bestemme hvilken indeksdefragmenteringsmetode som skal brukes, er å analysere indeksen for å bestemme graden av fragmentering. Du oppdager fragmentering annerledes for rowstore indekser og columnstore indekser.

Oppdager fragmentering av rowstore indekser

ved hjelp av sys.dm_db_index_physical_stats, kan du oppdage fragmentering i en bestemt indeks, alle indekser på en tabell eller indeksert visning, alle indekser i en database, eller alle indekser i alle databaser. For partisjonerte indekser gir sys. dm_db_index_physical_stats også fragmenteringsinformasjon for hver partisjon.

resultatsettet returnert av sys. dm_db_index_physical_stats inneholder følgende kolonner:

Kolonne	Beskrivelse
avg_fragmentation_in_percent	prosent av logisk fragmentering (out-of-order sider i indeksen).
fragment_count	antall fragmenter (fysisk påfølgende blad sider) i indeksen.
avg_fragment_size_in_pages	Gjennomsnittlig antall sider i ett fragment i en indeks.

etter at graden av fragmentering er kjent, bruk følgende tabell for å bestemme den beste metoden for å fjerne fragmenteringen: INDEKS OMORGANISERE ELLER INDEKS.

avg_fragmentation_in_percent value	Corrective statement
> 5% and < = 30% 1	ALTER INDEX REORGANIZE
> 30% 1	ALTER INDEX REBUILD WITH (ONLINE = ON) 2

1 These values provide a rough guideline for determining the point at which you should switch between ALTER INDEX REORGANIZE og ALTER INDEX REBUILD. De faktiske verdiene kan imidlertid variere fra sak til sak. Det er viktig at du eksperimenterer for å bestemme den beste terskelen for miljøet ditt.

2 Ombygging av en indeks kan utføres online eller offline. Omorganisering av en indeks utføres alltid online. For å oppnå tilgjengelighet som ligner på omorganiser-alternativet, bør du gjenoppbygge indekser på nettet. HVIS du vil ha MER informasjon, kan DU se INDEKSERE Og Utføre Indeksoperasjoner På Nettet.

Indekser med fragmentering på mindre enn 5 prosent trenger ikke å defragmenteres fordi fordelen ved å fjerne en så liten mengde fragmentering nesten alltid oppveies av CPU-kostnadene som påløper for å omorganisere eller gjenoppbygge indeksen. Også, ombygging eller omorganisering av små rowstore indekser generelt reduserer ikke selve fragmentering.OPP TIL OG med SQL Server 2014 (12.X) tildeler SQL Server-Databasemotoren plass ved hjelp av blandet omfang. Derfor lagres sider med små indekser noen ganger på blandede grader. Blandet omfang deles av opptil åtte objekter, slik at fragmenteringen i en liten indeks kanskje ikke reduseres etter omorganisering eller gjenoppbygging av den. Se Også Hensyn som er spesifikke for ombygging rowstore indekser. Hvis du vil ha mer informasjon om extents, kan Du se Arkitekturveiledningen For Sider og Extents.

Oppdager fragmentering av columnstore indekser

ved å bruke sys.dm_db_column_store_row_group_physical_stats, kan du bestemme prosentandelen av slettede rader i en indeks, som er et rimelig mål for fragmentering i en radgruppe av en columnstore-indeks. Bruk denne informasjonen til å beregne fragmenteringen i en bestemt indeks, alle indekser i en tabell, alle indekser i en database eller alle indekser i alle databaser.

resultatsettet returnert av sys.dm_db_column_store_row_group_physical_stats inneholder følgende kolonner:

Kolonne	Beskrivelse
total_rows	antall rader fysisk lagret i radgruppen. For komprimerte radgrupper inkluderer dette radene som er merket som slettet.
deleted_rows	Antall rader fysisk lagret i en komprimert radgruppe som er merket for sletting. 0 for radgrupper som er i delta-butikken.

Bruk denne informasjonen som returneres til å beregne indeksfragmentering ved hjelp av denne formelen:

100*(ISNULL(deleted_rows,0))/NULLIF(total_rows,0)

etter at graden av indeksfragmentering er kjent, bruk følgende tabell for å finne den beste metoden for å fjerne fragmenteringen: INDEX omorganisere eller indeksere.

computed fragmentation in percent value	Applies to version	Corrective statement
> = 20%	SQL Server 2012 (11.x) and SQL Server 2014 (12.x)	ALTER INDEX REBUILD
> = 20%	Starting with SQL Server 2016 (13.X)	ENDRE INDEKS OMORGANISERE

for å sjekke fragmenteringen av en rowstore-indeks ved Hjelp Av Transact-SQL

følgende eksempel finner gjennomsnittlig fragmenteringsprosent av alle indekser i HumanResources.Employee tabell i AdventureWorks2016 databasen.

SELECT a.object_id, object_name(a.object_id) AS TableName, a.index_id, name AS IndedxName, avg_fragmentation_in_percentFROM sys.dm_db_index_physical_stats (DB_ID (N'AdventureWorks2016_EXT') , OBJECT_ID(N'HumanResources.Employee') , NULL , NULL , NULL) AS aINNER JOIN sys.indexes AS b ON a.object_id = b.object_id AND a.index_id = b.index_id;GO

den forrige setningen returnerer et resultatsett som ligner på følgende.

object_id TableName index_id IndexName avg_fragmentation_in_percent----------- ------------ ----------- ----------------------------------------------------- ------------------------------1557580587 Employee 1 PK_Employee_BusinessEntityID 01557580587 Employee 2 IX_Employee_OrganizationalNode 01557580587 Employee 3 IX_Employee_OrganizationalLevel_OrganizationalNode 01557580587 Employee 5 AK_Employee_LoginID 66.66666666666671557580587 Employee 6 AK_Employee_NationalIDNumber 501557580587 Employee 7 AK_Employee_rowguid 0(6 row(s) affected)

for mer informasjon, se sys. dm_db_index_physical_stats.

for å sjekke fragmenteringen av en columnstore-indeks ved Hjelp Av Transact-SQL

følgende eksempel finner den gjennomsnittlige fragmenteringsprosenten av alle indekser idbo.FactResellerSalesXL_CCI tabellen iAdventureWorksDW2016 databasen.

SELECT i.object_id, object_name(i.object_id) AS TableName, i.index_id, i.name AS IndexName, 100*(ISNULL(SUM(CSRowGroups.deleted_rows),0))/NULLIF(SUM(CSRowGroups.total_rows),0) AS 'Fragmentation'FROM sys.indexes AS i INNER JOIN sys.dm_db_column_store_row_group_physical_stats AS CSRowGroups ON i.object_id = CSRowGroups.object_id AND i.index_id = CSRowGroups.index_idWHERE object_name(i.object_id) = 'FactResellerSalesXL_CCI'GROUP BY i.object_id, i.index_id, i.nameORDER BY object_name(i.object_id), i.name;

den forrige setningen returnerer et resultatsett som ligner på følgende.

object_id TableName index_id IndexName Fragmentation----------- --------------------------- ----------- ------------------------------- ---------------114099447 FactResellerSalesXL_CCI 1 IndFactResellerSalesXL_CCI 0(1 row(s) affected)

Sjekk indeksfragmentering ved HJELP AV SQL Server Management Studio

1. Utvid databasen som inneholder tabellen der du vil kontrollere fragmenteringen til en indeks.
2. Utvid Tabeller-mappen.
3. Utvid tabellen der du vil sjekke fragmenteringen til en indeks.
4. Utvid Indekser-mappen.
5. Høyreklikk indeksen som du vil sjekke fragmenteringen og velg Egenskaper.
6. velg Fragmentering under Velg en side.

Følgende informasjon er tilgjengelig På Fragmenteringssiden:

eskrivelse

Verdi
sidefullhet	angir gjennomsnittlig fullhet av indekssidene, i prosent. 100% betyr at indekssidene er helt fulle. 50% betyr at hver indeksside i gjennomsnitt er halvfull.
Total fragmentering	den logiske fragmenteringsprosenten. Dette angir antall sider i en indeks som ikke er lagret i rekkefølge.
Gjennomsnittlig radstørrelse	den gjennomsnittlige størrelsen på en rad på bladnivå.
Dybde	antall nivåer i indeksen, inkludert bladnivået.
Videresendte poster	antall poster i en heap som har videresendingspekere til en annen dataplassering. (Denne tilstanden oppstår under en oppdatering, når det ikke er nok plass til å lagre den nye raden på den opprinnelige plasseringen.)
Ghost rows	antall rader som er merket som slettet, men ikke fjernet ennå. Disse radene vil bli fjernet av en oppryddingstråd når serveren ikke er opptatt. Denne verdien inkluderer ikke rader som beholdes på grunn av en utestående snapshot-isolasjonstransaksjon.
Indekstype	typen av indeks. Mulige verdier er Gruppert indeks, Ikke-Klumpet indeks og Primær XML. Tabeller kan også lagres som en heap (uten indekser), men da Denne Indeksen Egenskaper siden kan ikke åpnes.
rader På Bladnivå	antall rader på bladnivå.
Maksimal radstørrelse	maksimal radstørrelse på bladnivå.
Minste radstørrelse	minste radstørrelse på bladnivå.
Sider	totalt antall datasider.
Partisjon ID	partisjons-IDEN til b-treet som inneholder indeksen.
versjon ghost rows	antall ghost poster som beholdes på grunn av en enestående snapshot isolasjon transaksjon.

Defragmentering av indekser ved å gjenoppbygge eller omorganisere indeksen

du defragmenterer en fragmentert indeks ved hjelp av en av følgende metoder:

• index reorganization
• Index rebuild

Omorganisere en indeks

Omorganisere en indeks bruker minimale systemressurser og er en online-operasjon. Dette betyr at langsiktig blokkering av tabelllåser ikke holdes, og spørringer eller oppdateringer til den underliggende tabellen kan fortsette under ALTER INDEX REORGANIZE – transaksjonen.

• For rowstore-indekser defragmenterer Databasemotoren bladnivået for grupperte og ikke-klyngede indekser på tabeller og visninger ved å omorganisere bladnivåsidene fysisk for å matche den logiske rekkefølgen til bladnodene (venstre til høyre). Omorganisering komprimerer også indekssidene basert på indeksens fyllfaktorverdi. Bruk sys for å vise innstillingen fyllfaktor.indeks. For syntaks eksempler, se Eksempler: Rowstore omorganisere.

• når du bruker columnstore indekser, kan delta store ende opp med flere små rowgroups etter innsetting, oppdatering og sletting av data over tid. Omorganisering av en columnstore-indeks tvinger alle radgruppene inn i columnstore, og kombinerer deretter radgruppene i færre radgrupper med flere rader. Omorganiser-operasjonen fjerner også rader som er slettet fra columnstore. Omorganisering krever i utgangspunktet EKSTRA CPU-ressurser for å komprimere dataene, noe som kan redusere den generelle systemytelsen. Men så snart dataene er komprimert, forbedrer spørringsytelsen. Hvis du vil ha syntakseksempler, kan Du se Eksempler: ColumnStore omorganisere.

Gjenoppbygge en indeks

Gjenoppbygge en indeks faller og gjenoppretter indeksen. Avhengig av hvilken type indeks – og Databasemotorversjon, kan en gjenoppbyggingsoperasjon gjøres online eller offline. HVIS du VIL HA T-SQL-syntaksen, kan DU se ENDRE INDEKS GJENOPPBYGGE

• for rowstore-indekser, fjerner gjenoppbygging fragmentering, gjenvinner diskplass ved å komprimere sidene basert på den angitte eller eksisterende fyllfaktorinnstillingen, og omorganisere indeksrader i sammenhengende sider. NårALL er spesifisert, blir alle indeksene på bordet droppet og gjenoppbygget i en enkelt transaksjon. Utenlandske nøkkelbegrensninger trenger ikke å bli droppet på forhånd. Når indekser med 128 extents eller mer er gjenoppbygd, Utsetter Databasemotoren den faktiske siden deallokeringer, og tilhørende låser, før etter transaksjonen begår. For syntaks eksempler, se Eksempler: Rowstore omorganisere.

• for columnstore indekser, ombygging fjerner fragmentering, flytter alle rader inn i columnstore, og gjenvinner diskplass ved fysisk å slette rader som er logisk slettet fra tabellen.

  Tips

  Starter MED SQL Server-2016 (13.x), gjenoppbygging av columnstore-indeksen er vanligvis ikke nødvendig siden REORGANIZE utfører det vesentlige ved en gjenoppbygging i bakgrunnen som en online-operasjon.

  for syntaks eksempler, se Eksempler: ColumnStore gjenoppbygge.

Tillatelser

Krever ALTER tillatelse på bordet eller visningen. Brukeren må være medlem av minst en av følgende roller:

• db_ddladmin databaserolle 1
• db_owner databaserolle
• sysadmin serverrolle

1db_ddladmin databaserolle er minst privilegert.

Fjern fragmentering ved HJELP AV SQL Server Management Studio

hvis du vil omorganisere eller bygge en indeks

1. I Objektutforsker, Utvider du databasen som inneholder tabellen du vil omorganisere en indeks på.
2. Utvid Tabeller-mappen.
3. Utvid tabellen der du vil omorganisere en indeks.
4. Utvid Indekser-mappen.
5. Høyreklikk indeksen du vil omorganisere, og velg Omorganiser.
6. kontroller at riktig indeks er i Indeksene som skal omorganiseres rutenett i Dialogboksen Omorganiser Indekser, og klikk OK.
7. Merk Av For Komprimer kolonnedata For store objekter for å angi at alle sider som inneholder data for store objekter (lob) også komprimeres.
8. Klikk OK.

hvis du vil omorganisere alle indekser i en tabell

1. I Objektutforsker, Utvider du databasen som inneholder tabellen du vil omorganisere indeksene på.
2. Utvid Tabeller-mappen.
3. Utvid tabellen der du vil omorganisere indeksene.
4. Høyreklikk Mappen Indekser og velg Omorganiser Alle.
5. kontroller at de riktige indeksene er i Indeksene som skal omorganiseres i Dialogboksen Omorganiser Indekser. Hvis du vil fjerne en indeks fra Indeksene som skal omorganiseres rutenett, velger du indeksen og trykker Deretter Delete-tasten.
6. Merk Av For Komprimer kolonnedata For store objekter for å angi at alle sider som inneholder data for store objekter (lob) også komprimeres.
7. Klikk OK.

hvis du vil gjenoppbygge en indeks

1. I Objektutforsker, Utvider du databasen som inneholder tabellen du vil omorganisere en indeks på.
2. Utvid Tabeller-mappen.
3. Utvid tabellen der du vil omorganisere en indeks.
4. Utvid Indekser-mappen.
5. Høyreklikk indeksen du vil omorganisere, og velg Gjenoppbygg.
6. i Dialogboksen Gjenoppbygg Indekser kontrollerer du at riktig indeks er i indeksene som skal bygges på nytt, og klikker OK.
7. Merk Av For Komprimer kolonnedata For store objekter for å angi at alle sider som inneholder data for store objekter (lob) også komprimeres.
8. Klikk OK.

Fjern fragmentering ved Hjelp Av Transact-SQL

for å omorganisere en fragmentert indeks

følgende eksempel omorganisererIX_Employee_OrganizationalLevel_OrganizationalNodeindeksen påHumanResources.Employeetabellen iAdventureWorks2016 databasen.

ALTER INDEX IX_Employee_OrganizationalLevel_OrganizationalNode ON HumanResources.Employee REORGANIZE;

følgende eksempel reorganisererIndFactResellerSalesXL_CCI columnstore indeksen pådbo.FactResellerSalesXL_CCI tabellen iAdventureWorksDW2016 databasen.

-- This command will force all CLOSED and OPEN rowgroups into the columnstore.ALTER INDEX IndFactResellerSalesXL_CCI ON FactResellerSalesXL_CCI REORGANIZE WITH (COMPRESS_ALL_ROW_GROUPS = ON);

for å omorganisere alle indekser i en tabell

følgende eksempel omorganiserer alle indekser på HumanResources.Employee tabellen i AdventureWorks2016 databasen.

ALTER INDEX ALL ON HumanResources.Employee REORGANIZE;

for å gjenoppbygge en fragmentert indeks

følgende eksempel bygger en enkelt indeks på Employee tabellen i AdventureWorks2016 databasen.

ALTER INDEX PK_Employee_BusinessEntityID ON HumanResources.EmployeeREBUILD;

for å gjenoppbygge alle indekser i en tabell

følgende eksempel gjenoppbygger alle indekser knyttet til tabellen i AdventureWorks2016 databasen ved hjelp av ALL nøkkelord. Tre alternativer er spesifisert.

ALTER INDEX ALL ON Production.ProductREBUILD WITH (FILLFACTOR = 80, SORT_IN_TEMPDB = ON, STATISTICS_NORECOMPUTE = ON);

FOR MER informasjon, se ENDRE INDEKS (Transact-SQL).

automatisk indeks-og statistikkadministrasjon

Utnytt løsninger som Adaptiv Indeksdefragmentering for automatisk å administrere indeksdefragmentering og statistikkoppdateringer for en eller flere databaser. Denne prosedyren velger automatisk om du vil gjenoppbygge eller omorganisere en indeks i henhold til fragmenteringsnivået, blant andre parametere, og oppdatere statistikk med en lineær terskel.

Betraktninger som er spesifikke for å gjenoppbygge rowstore-indekser

Gjenoppbygge en gruppert indeks automatisk gjenoppbygger alle ikke-klyngede indeks som refererer til klyngnøkkelen, hvis de fysiske eller logiske identifikatorene i ikke-klyngede indekspostene må endres.

følgende scenarier tvinge alle rowstore nonclustered indekser på en tabell som skal bygges automatisk:

• Opprette en gruppert indeks på en tabell
• Fjerne en gruppert indeks, noe som fører til at tabellen lagres som en heap
• Endre klyngetasten for å inkludere eller ekskludere kolonner

følgende scenarier krever ikke at alle rowstore-ikke-klyngede indekser automatisk gjenoppbygges på en tabell:

• Ombygging av en unik gruppert indeks
• Ombygging av en ikke-unik gruppert indeks
• Endre indeksskjemaet, for eksempel å bruke et partisjoneringsskjema til en gruppert indeks eller flytte gruppert indeks til en annen filgruppe

Viktig

en indeks kan ikke omorganiseres eller gjenoppbygges hvis filgruppen den ligger i, er frakoblet eller satt til skrivebeskyttet. Når søkeordet alt er angitt og en eller flere indekser er i en frakoblet eller skrivebeskyttet filgruppe, mislykkes setningen.

mens en indeksgjenoppbygging skjer, må det fysiske mediet ha nok plass til å lagre to kopier av indeksen. Når gjenoppbyggingen er ferdig, Sletter Databasemotoren den opprinnelige indeksen.

når ALL er spesifisert medALTER INDEX – setningen, blir relasjonsindekser, både grupperte og ikke-klyngede, OG XML-indekser på tabellen omorganisert.

Betraktninger som er spesifikke for å gjenoppbygge en columnstore-indeks

Når du gjenoppbygger en columnstore-indeks, leser Databasemotoren alle data fra den opprinnelige columnstore-indeksen, inkludert delta-butikken. Den kombinerer dataene i nye rowgroups, og komprimerer rowgroups inn i columnstore. Databasemotoren defragmenterer columnstore ved å fysisk slette rader som logisk er slettet fra tabellen. De slettede byte er gjenvunnet på disken.

Merk

Omorganisering av en columnstore-indeks ved Hjelp Av Management Studio kombinerer KOMPRIMERTE radgrupper sammen, men tvinger ikke alle radgrupper til å komprimeres til columnstore. LUKKEDE rowgroups vil bli komprimert, MEN ÅPNE rowgroups vil ikke bli komprimert til columnstore.To tving komprimere alle radgrupper, bruk Transact-SQL-eksemplet nedenfor.

Merk

STARTER MED SQL Server 2019 (15.x), tuple-mover er hjulpet av en bakgrunn flette oppgave som automatisk komprimerer mindre ÅPNE delta-radgrupper som har eksistert i noen tid som bestemmes av en intern terskel, eller fletter KOMPRIMERTE radgrupper fra der et stort antall rader er slettet. Dette forbedrer columnstore indeks kvaliteten over tid.
For mer informasjon om columnstore vilkår og begreper, se Columnstore indekser: Oversikt.

Gjenoppbygg en partisjon i stedet for hele tabellen

• Gjenoppbygging av hele tabellen tar lang tid hvis indeksen er stor, og det krever nok diskplass til å lagre en ekstra kopi av indeksen under gjenoppbyggingen. Vanligvis er det bare nødvendig å gjenoppbygge den sist brukte partisjonen.
• for partisjonerte tabeller trenger du ikke å gjenoppbygge hele columnstore-indeksen fordi fragmentering sannsynligvis vil forekomme i bare partisjonene som nylig er endret. Faktatabeller og store dimensjonstabeller er vanligvis partisjonert for å utføre backup-og administrasjonsoperasjoner på biter av bordet.

Gjenoppbygge en partisjon etter tunge dml operasjoner

Gjenoppbygge en partisjon defragmenterer partisjonen og reduserer disklagring. Ombygging sletter alle rader fra columnstore som er merket for sletting, og flytter alle rowgroups fra delta-lageret til columnstore. Det kan være flere rowgroups i delta-butikken som har mindre enn en million rader.

Gjenoppbygge en partisjon etter lasting av data

Gjenoppbygge en partisjon etter lasting dato sikrer at alle data er lagret i columnstore. Når samtidige prosesser hver last mindre enn 100 000 rader i samme partisjon samtidig, kan partisjonen ende opp med flere delta-butikker. Ombygging flytter alle delta store rader inn i columnstore.

Betraktninger som er spesifikke for å omorganisere en columnstore-indeks

Når du omorganiserer en columnstore-indeks, komprimerer Databasemotoren hver LUKKET delta-radgruppe i columnstore som en komprimert radgruppe. STARTER MED SQL Server 2016 (13.x) Og I Azure SQL Database utfører kommandoen REORGANIZE følgende ekstra defragmenteringsoptimaliseringer på nettet:

• fjerner fysisk rader Fra en radgruppe Når 10% eller flere av radene er logisk slettet. De slettede byte er gjenvunnet på det fysiske mediet. HVIS for eksempel en komprimert radgruppe på 1 million rader har 100k-rader slettet, FJERNER SQL Server de slettede radene og komprimerer radgruppen på nytt med 900k-rader. Det sparer på lagring ved å fjerne slettede rader.

• Kombinerer en eller flere komprimerte radgrupper for å øke rader per radgruppe opp til maksimalt 1 048 576 rader. Hvis du for eksempel masseimporterer 5 grupper på 102 400 rader, får du 5 komprimerte radgrupper. Hvis du kjører OMORGANISERE, blir disse radgruppene slått sammen til 1 komprimert radgruppe med størrelse 512 000 rader. Dette forutsetter at det ikke var noen ordboksstørrelse eller minnebegrensninger.

• For rowgroups der 10% eller flere av radene er logisk slettet, Prøver Databasemotoren å kombinere denne rowgroup med en eller flere rowgroups. For eksempel komprimeres rowgroup 1 med 500 000 rader, og rowgroup 21 komprimeres med maksimalt 1 048 576 rader. Rowgroup 21 har 60% av radene slettet som etterlater 409 830 rader. Databasemotoren favoriserer å kombinere disse to radgruppene for å komprimere en ny radgruppe som har 909 830 rader.

etter å ha utført data laster, kan du ha flere små rowgroups i delta store. Du kan bruke ALTER INDEX REORGANIZE for å tvinge alle rowgroups inn i columnstore, og deretter kombinere rowgroups inn færre rowgroups med flere rader. Omorganisere operasjonen vil også fjerne rader som er slettet fra columnstore.

Begrensninger og begrensninger

Rowstore indekser med mer enn 128 extents er ombygd i to separate faser: logisk og fysisk. I den logiske fasen er de eksisterende tildelingsenhetene som brukes av indeksen merket for deallokering, dataradene kopieres og sorteres, og flyttes deretter til nye tildelingsenheter som er opprettet for å lagre den gjenoppbygde indeksen. I den fysiske fasen slippes tildelingsenhetene som tidligere er merket for deallokering, fysisk i korte transaksjoner som skjer i bakgrunnen, og krever ikke mange låser. Hvis du vil ha mer informasjon om extents, kan Du se Pages And Extents Architecture Guide.

ALTER INDEX REORGANIZE – setningen krever at datafilen som inneholder indeksen, har ledig plass, fordi operasjonen bare kan tildele midlertidige arbeidssider på samme fil, ikke i en annen fil i filgruppen. Så selv om filgruppen kan ha gratis sider tilgjengelig, kan brukeren fortsatt støte på feil 1105:Could not allocate space for object '###' in database '###' because the '###' filegroup is full. Create disk space by deleting unneeded files, dropping objects in the filegroup, adding additional files to the filegroup, or setting autogrowth on for existing files in the filegroup.

Advarsel

Opprette og gjenoppbygge nonaligned indekser på et bord med mer enn 1000 partisjoner er mulig, men støttes ikke. Dette kan føre til redusert ytelse eller overdreven minneforbruk under disse operasjonene. Microsoft anbefaler at du bare bruker justerte indekser når antall partisjoner overstiger 1000.

en indeks kan ikke omorganiseres eller gjenoppbygges hvis filgruppen den ligger i, er frakoblet eller satt til skrivebeskyttet. Når nøkkelordet ALL er angitt og en eller flere indekser er i en frakoblet eller skrivebeskyttet filgruppe, mislykkes setningen.

Statistikk:

• når en indeks opprettes eller gjenoppbygges, opprettes eller oppdateres statistikk ved å skanne alle radene i tabellen. MEN starter MED SQL Server 2012 (11.x), blir ikke statistikk opprettet eller oppdatert ved å skanne alle radene i tabellen når en partisjonert indeks opprettes eller gjenoppbygges. I stedet Bruker Spørringsoptimereren standard utvalgsalgoritmen til å generere denne statistikken. For å få statistikk over partisjonerte indekser ved å skanne alle radene i tabellen, bruk OPPRETT STATISTIKK eller OPPDATER STATISTIKK med FULLSCAN – klausulen.

• når en indeks er omorganisert, blir statistikken ikke oppdatert.

en indeks kan ikke omorganiseres når ALLOW_PAGE_LOCKS er satt TIL AV.

OPP TIL SQL Server-2017 (14.x), ombygging av en gruppert columnstore-indeks er en frakoblet operasjon. Databasemotoren må skaffe seg en eksklusiv lås på bordet eller partisjonen mens gjenoppbyggingen skjer. Dataene er frakoblet og utilgjengelige under gjenoppbyggingen, selv når du bruker NOLOCK, Read-committed Snapshot Isolation (RCSI) eller Snapshot Isolation.STARTER MED SQL Server 2019 (15.x), kan en gruppert columnstore indeks bygges ved hjelp av ONLINE = ON alternativet.

For En Azure Synapse Analytics-tabell (tidligere Azure Synapse Analytics) med en ordnet gruppert columnstore-indeks, vilALTER INDEX REBUILD sortere dataene på Nytt Ved Hjelp Av TempDB. Overvåke TempDB under gjenoppbygge operasjoner. Hvis Du trenger Mer TempDB plass, skalere opp datalageret. Skalere ned igjen når indeksen gjenoppbygge er fullført.

for En Azure Synapse Analytics-tabell (tidligere Azure Synapse Analytics) med en ordnet gruppert columnstore-indeks sorterer ikke ALTER INDEX REORGANIZE dataene på nytt. For å ty til dataene, bruk ALTER INDEX REBUILD.

BRUKE INDEKSGJENOPPBYGGING til å gjenopprette fra maskinvarefeil

i tidligere versjoner AV SQL Server kan du noen ganger bygge en rowstore nonclustered indeks på nytt for å korrigere inkonsekvenser forårsaket av maskinvarefeil.STARTER MED SQL Server 2008, kan du fortsatt være i stand til å reparere slike uoverensstemmelser mellom indeksen og gruppert indeksen ved å gjenoppbygge en ikke-gruppert indeks frakoblet. Du kan imidlertid ikke reparere nonclustered indeks uoverensstemmelser ved å gjenoppbygge indeksen online, fordi online gjenoppbygge mekanismen bruker eksisterende nonclustered indeksen som grunnlag for gjenoppbyggingen og dermed vedvarer inkonsekvensen. Gjenoppbygging av indeksen offline kan noen ganger tvinge en skanning av gruppert indeksen (eller heap) og så fjerne inkonsekvens. For å sikre en gjenoppbygging fra gruppert indeksen, slipp og gjenskape nonclustered indeksen. Som med tidligere versjoner anbefaler vi at du gjenoppretter fra inkonsekvenser ved å gjenopprette de berørte dataene fra en sikkerhetskopi.du kan imidlertid kanskje reparere indeks-inkonsekvensene ved å gjenoppbygge den ikke-klyngede indeksen frakoblet. Hvis DU vil ha mer informasjon, kan DU se Dbcc CHECKDB (Transact-SQL).

Se også

• Utfør Indeksoperasjoner Online
• ALTER INDEX (Transact-SQL)
• Adaptiv Indeks Defrag
• OPPRETT STATISTIKK (Transact-SQL)
• OPPDATER STATISTIKK (Transact-SQL)
• Columnstore Indekser Spørringsytelse
• Kom i gang Med Columnstore for real-tid operasjonell analyse
• columnstore indekser for datavarehus
• Columnstore indekser og flette Policy For Rowgroups