sql >> Databasteknik >  >> RDS >> Sqlserver

3 metoder för att bygga om alla index för alla tabeller med T-SQL i SQL Server Database

Det finns flera metoder för att bygga om alla index för alla tabeller i SQL Server, bland annat:

  1. Använda underhållsplaner för SQL Server.
  2. Använder T-SQL-skript baserat på fragmenteringsprocenten.
  3. Använder kommandot ALTER INDEX.

I den här artikeln kommer vi att utforska dessa metoder och illustrera dem med praktiska exempel.

1. SQL Server Rebuild Index Maintenance Plan

Det första alternativet att granska är att bygga om index med databasens underhållsplaner. Underhållsplanerna finns tillgängliga under administrationsmappen i SQL Server Management Studio.

För att skapa underhållsplan för SQL-databas, starta SQL Server Management Studio > expandera databasinstansen > Management > högerklicka på underhållsplanen > Ny underhållsplan .

Ange namnet på underhållsplanen. Dra och släpp sedan Rebuild Index Task in i underhållsplanens designer. Byt namn på uppgiften till Indexunderhåll .

Nästa steg är att konfigurera underhållsplanen. Dubbelklicka på den och konfigurera alternativen i Återskapa indexuppgiften enligt följande:

  • Välj AdventureWorks2017 databas från rullgardinsmenyn Databas(er).
  • Om du vill bygga om index för alla tabeller väljer du Tabeller och vyer från Objektet rullgardinsmenyn.
  • Markera Sortera resultat i tempdb .
  • MAXDOP – ställ in 2 (två).
  • I vårt fall bygger vi bara om index om Fragmentering värdet är högre än 20 %. Ställ därför in 20 i respektive fält.
  • Klicka på OK för att spara indexkonfigurationen och stänga Rebuild Index Task fönster.

Låt oss nu konfigurera schemat.

Klicka på kalendern ikonen ovanpå underhållsplanens designer:

Nytt jobbschema fönstret öppnas. Låt oss konfigurera följande inställningar:

  • Kör jobbet varje dag. I Schematyp menyn väljer vi Återkommande . Sedan, i Frekvens avsnitt väljer vi Förekommer > Dagligen .
  • Återkommande varje > 1 (dag).
  • Daglig frekvens > Förekommer en gång på > ange den exakta tiden. I vårt fall är klockan 01.00.
  • Klicka på OK .

Spara sedan underhållsplanen.

De skapade underhållsplanerna finns tillgängliga i SSMS Underhållsplan katalog. För att se schemat som är kopplat till den specifika underhållsplanen, kolla Jobb katalogen under SQL Server Agent .

För att testa jobbet högerklickar du på dess namn i Underhållsplaner katalogen och välj Kör från menyn:

Utförandet börjar. När den är klar visas följande dialogruta:

Detta var den vanliga metoden att bygga om index med underhållsplaner. Låt oss nu gå vidare till nästa metod – med hjälp av T-SQL-skripten.

2. SQL Server ALTER INDEX Rebuild

Kommandot ALTER INDEX kan användas för att bygga om alla index i tabellen. Syntaxen är följande:

ALTER INDEX ALL ON [table_name] REBUILD

Obs:tabellnamn parameter anger namnet på tabellen där vi vill bygga om alla index i SQL Server.

Till exempel vill vi bygga om alla index för [HumanResources].[Anställd] . Frågan ska vara följande:

use AdventureWorks2017
go
ALTER INDEX ALL ON [HumanResources].[Employee] REBUILD
Go

3. SQL Server-skript för att bygga om alla index för alla tabeller baserat på fragmentering

Indexhållningen är resurskrävande. Dessutom låser den tabellen där den bygger om indexet. För att undvika sådana komplikationer måste vi bygga om indexet där SQL Server-indexfragmenteringen är högre än 40 %.

För att illustrera fallet har jag skapat ett T-SQL-skript som bygger om index med en fragmenteringsgrad högre än 30%. Låt oss utforska dess delar och funktioner.

Variabler och temptabelldeklaration

Först måste vi skapa temporära tabeller och variabler:

  • @IndexFregQuery – lagrar den dynamiska fråga som används för att fylla i fragmenterade index.
  • @IndexRebuildQuery – innehåller ALTER INDEX-frågan.
  • @IndexName – indexnamnet vi vill bygga om
  • @Tabellnamn – tabellnamnet där vi vill bygga om indexet.
  • @SchemaName – schemanamnet där vi vill bygga om indexet.
  • #Fregmentedindex – tabellen med 3 kolumner som lagrar indexnamnet, tabellnamnet och schemanamnet.

Följande kod deklarerar våra variabler och temptabellen:

declare @i int=0
declare @IndexCount int
declare @IndexFregQuery nvarchar(max)
declare @IndexRebuildQuery nvarchar(max)
declare @IndexName varchar(500)
declare @TableName varchar(500)
declare @SchemaName varchar(500)
create table #Fregmentedindex(Index_name varchar(max),table_name varchar(max),schema_name varchar(max))

Hämta listan över fragmenterade index

Vårt nästa steg är att fylla i listan med index med en fragmenteringsgrad på 30 % eller högre. Vi måste infoga dessa index i #FregmentedIndex bord.

Frågan måste fylla i schemanamnet, tabellnamnet och indexnamnet för att infoga dem i den tillfälliga tabellen. Ta en titt på den frågan:

set @IndexFregQuery='SELECT i.[name],o.name,sch.name
	FROM   [' + @DatabaseName + '].sys.dm_db_index_physical_stats (DB_ID('''+ @DatabaseName +'''), NULL, NULL, NULL, NULL) AS s
	INNER JOIN [' + @DatabaseName + '].sys.indexes AS i ON s.object_id = i.object_id AND s.index_id = i.index_id
	INNER JOIN [' + @DatabaseName + '].sys.objects AS o ON i.object_id = o.object_id
	INNER JOIN [' + @DatabaseName + '].sys.schemas AS sch ON o.schema_id=sch.schema_id
	WHERE (s.avg_fragmentation_in_percent > 30 ) and i.name is not null'
insert into #Fregmentedindex(Index_name,table_name,schema_name) exec sp_executesql @IndexFregQuery

Skapa en dynamisk SQL-fråga

Slutligen måste vi bygga det dynamiska ALTER INDEX kommandot och kör det.

För att generera kommandot använder vi WHILE-loopen. Det itererar genom #FregmentedIndex tabell och fyller i schemanamnet, tabellnamnet och indexnamnet för att spara dem i @SchemaName , @TableName och @IndexName . Parametrarnas värden läggs till i kommandot ALTER INDEX.

Koden är följande:

set @IndexCount=(select count(1) from #Fregmentedindex)
While (@IndexCount>@i)
begin 
(select top 1 @TableName=table_name, @IndexName=Index_name,@SchemaName= schema_name from #Fregmentedindex)
Set @IndexRebuildQuery ='Alter index [' + @IndexName +'] on ['[email protected] +'].['[email protected]+'].[' + @TableName +'] rebuild'
exec sp_executesql @IndexRebuildQuery 
set @[email protected]+1
delete from #Fregmentedindex where [email protected] and [email protected]
End

Jag har kapslat in hela koden i sp_index_maintenance lagrad procedur skapad i DBATools databas. Koden är följande:

use DBATools
go
Create procedure sp_index_maintenance_daily
@DatabaseName varchar(50)
as
begin
declare @i int=0
declare @IndexCount int
declare @IndexFregQuery nvarchar(max)
declare @IndexRebuildQuery nvarchar(max)
declare @IndexName varchar(500)
declare @TableName varchar(500)
declare @SchemaName varchar(500)
create table #Fregmentedindex(Index_name varchar(max),table_name varchar(max),schema_name varchar(max))
set @IndexFregQuery='SELECT i.[name],o.name,sch.name
	FROM   [' + @DatabaseName + '].sys.dm_db_index_physical_stats (DB_ID('''+ @DatabaseName +'''), NULL, NULL, NULL, NULL) AS s
	INNER JOIN [' + @DatabaseName + '].sys.indexes AS i ON s.object_id = i.object_id AND s.index_id = i.index_id
	INNER JOIN [' + @DatabaseName + '].sys.objects AS o ON i.object_id = o.object_id
	INNER JOIN [' + @DatabaseName + '].sys.schemas AS sch ON o.schema_id=sch.schema_id
	WHERE (s.avg_fragmentation_in_percent > 30 ) and i.name is not null'
insert into #Fregmentedindex(Index_name,table_name,schema_name) exec sp_executesql @IndexFregQuery
set @IndexCount=(select count(1) from #Fregmentedindex)
While (@IndexCount>@i)
begin 
(select top 1 @TableName=table_name, @IndexName=Index_name,@SchemaName= schema_name from #Fregmentedindex)
Set @IndexRebuildQuery ='Alter index [' + @IndexName +'] on ['[email protected] +'].['[email protected]+'].[' + @TableName +'] rebuild'
exec sp_executesql @IndexRebuildQuery 
set @[email protected]+1
delete from #Fregmentedindex where [email protected] and [email protected]
End
End

När proceduren är klar kan vi konfigurera SQL Job.

Expandera SQL Server Agent > högerklicka på Jobb > Nytt jobb .

Det Nya jobbet fönster öppnas där du ska ange önskat jobbnamn.

För att skapa ett jobbsteg, navigera till stegen avsnittet> den Nya knapp:

Du kommer till steget Nytt jobb fönster för att konfigurera det steget.

Ange önskat stegnamn och skriv in följande kod i textrutan:

use DBATools
go
exec sp_index_maintenance_daily 'AdventureWorks2017'

För att konfigurera schemat, gå till Schema > klicka på Ny .

Vårt jobb bör utföras klockan 01:00. Följaktligen konfigurerar vi schemat:

  • Schematyp > Återkommande .
  • Frekvensen avsnitt> Förekommer > Dagligen ; Återkommande varje > 1 (en).
  • Den Dagliga frekvensen avsnitt> Förekommer en gång på > 01:00:00.
  • Klicka på OK .

Du kommer att flyttas tillbaka till Nya jobbet sektion. Klicka på OK där också för att skapa jobbet.

Det nyskapade jobbet är tillgängligt i Jobb katalogen under SQL Server Agent mapp.

Vi måste nu testa jobbet:högerklicka på det och välj Starta jobb …

Jobbet startar och efter framgångsrikt slutförande kommer du att se följande meddelande:

Om vi ​​jämför klustrade index vs icke-klustrade index, ser vi att skapande av ett unikt klustrat index ökar effektiviteten för frågeprestanda. Indexerade vyer i SQL Server kan användas för att påskynda exekveringen av frågor. Kolla också in hur du hanterar index med SQL Index Manager.

Sammanfattning

Den aktuella artikeln presenterade tre funktionella sätt att bygga om index för alla tabeller. Vi har utforskat dem alla med steg-för-steg-riktlinjer och praktiska SQL-indexexempel för att illustrera jobbkonfigurationen. Valet av lämplig variant är ditt, och vi hoppas att den här artikeln var till hjälp för dig.


  1. Android SQLite LIKE escape jokertecken

  2. Skillnaden mellan multi-statement tabell-värderade funktioner och inline tabell-värderade funktioner i SQL Server

  3. pgmemcache vs Infinite Cache

  4. MariaDB ROUND() vs FLOOR()