Sqlserver
 sql >> Datenbank >  >> RDS >> Sqlserver

3 Methoden zum Neuerstellen aller Indizes für alle Tabellen mit T-SQL in der SQL Server-Datenbank

Es gibt mehrere Methoden, um alle Indizes aller Tabellen in SQL Server neu zu erstellen, darunter:

  1. Verwenden von SQL Server-Wartungsplänen.
  2. Verwendung von T-SQL-Skript basierend auf dem Fragmentierungsprozentsatz.
  3. Mit dem Befehl ALTER INDEX.

In diesem Artikel werden wir diese Methoden untersuchen und sie mit praktischen Beispielen veranschaulichen.

1. SQL Server Rebuild Index Wartungsplan

Die erste zu überprüfende Option besteht darin, Indizes mit den Datenbankwartungsplänen neu zu erstellen. Die Wartungspläne sind im Verwaltungsordner von SQL Server Management Studio verfügbar.

Um einen Wartungsplan für die SQL-Datenbank zu erstellen, starten Sie SQL Server Management Studio > erweitern Sie die Datenbankinstanz > Verwaltung > Rechtsklick auf den Wartungsplan > Neuer Wartungsplan .

Geben Sie den Namen des Wartungsplans an. Ziehen Sie dann Aufgabe Index neu erstellen per Drag-and-Drop in den Wartungsplan-Designer. Benennen Sie die Aufgabe in Indexpflege um .

Der nächste Schritt ist die Konfiguration des Wartungsplans. Doppelklicken Sie darauf und konfigurieren Sie die Optionen im Aufgabe Index neu erstellen wie folgt:

  • Wählen Sie AdventureWorks2017 aus Datenbank aus dem Dropdown-Menü Datenbank(en).
  • Um Indizes aller Tabellen neu zu erstellen, wählen Sie Tabellen und Ansichten aus dem Objekt Dropdown-Feld.
  • Aktivieren Sie Ergebnisse in tempdb sortieren .
  • MAXDOP – 2 einstellen (zwei).
  • In unserem Fall erstellen wir Indizes nur dann neu, wenn die Fragmentierung Wert ist höher als 20%. Stellen Sie daher 20 ein im jeweiligen Feld.
  • Klicken Sie auf OK , um die Indexkonfiguration zu speichern und den Task Index neu erstellen zu schließen Fenster.

Lassen Sie uns nun den Zeitplan konfigurieren.

Klicken Sie auf den Kalender Symbol oben im Wartungsplan-Designer:

Der Neue Auftragsplanung Fenster öffnet sich. Lassen Sie uns die folgenden Einstellungen konfigurieren:

  • Führen Sie den Job jeden Tag aus. Im Zeitplantyp Menü wählen wir Wiederkehrend . Dann in der Frequenz Abschnitt wählen wir Vorkommen > Täglich .
  • Wiederholt alle > 1 (Tag).
  • Tägliche Häufigkeit > Tritt einmalig um auf > Geben Sie die genaue Uhrzeit an. In unserem Fall ist es 1 Uhr morgens.
  • Klicken Sie auf OK .

Speichern Sie danach den Wartungsplan.

Die erstellten Wartungspläne sind im SSMS Wartungsplan verfügbar Verzeichnis. Um den mit dem jeweiligen Wartungsplan verknüpften Zeitplan anzuzeigen, überprüfen Sie die Jobs Verzeichnis unter SQL Server Agent .

Um den Job zu testen, klicken Sie in den Wartungsplänen mit der rechten Maustaste auf seinen Namen Verzeichnis und wählen Sie Ausführen aus dem Menü:

Die Hinrichtung beginnt. Nach erfolgreichem Abschluss wird das folgende Dialogfeld angezeigt:

Dies war die übliche Methode zum Neuerstellen von Indizes mit Wartungsplänen. Fahren wir nun mit der nächsten Methode fort – mit den T-SQL-Skripten.

2. SQL Server ALTER INDEX Rebuild

Mit dem Befehl ALTER INDEX können alle Indizes der Tabelle neu aufgebaut werden. Die Syntax lautet wie folgt:

ALTER INDEX ALL ON [table_name] REBUILD

Hinweis:Der table_name Der Parameter gibt den Namen der Tabelle an, in der wir alle Indizes in SQL Server neu erstellen möchten.

Beispielsweise möchten wir alle Indizes von [HumanResources].[Employee] neu erstellen . Die Abfrage sollte wie folgt lauten:

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

3. SQL Server-Skript zum Neuerstellen aller Indizes für alle Tabellen basierend auf Fragmentierung

Die Indexpflege ist ressourcenintensiv. Außerdem sperrt es die Tabelle, in der es den Index neu erstellt. Um solche Komplikationen zu vermeiden, müssen wir den Index neu erstellen, wenn die SQL Server-Indexfragmentierung höher als 40 % ist.

Um den Fall zu veranschaulichen, habe ich ein T-SQL-Skript erstellt, das Indizes mit einem Fragmentierungsgrad von mehr als 30 % neu erstellt. Lassen Sie uns seine Teile und Funktionen untersuchen.

Variablen und temporäre Tabellendeklaration

Zuerst müssen wir temporäre Tabellen und Variablen erstellen:

  • @IndexFregQuery – speichert die dynamische Abfrage, die zum Auffüllen fragmentierter Indizes verwendet wird.
  • @IndexRebuildQuery – enthält die ALTER INDEX-Abfrage.
  • @IndexName – der Indexname, den wir neu erstellen möchten
  • @Tabellenname – der Tabellenname, wo wir den Index neu erstellen wollen.
  • @SchemaName – der Name des Schemas, in dem wir den Index neu erstellen möchten.
  • #Fregmentedindex – die 3-Spalten-Tabelle die den Indexnamen, den Tabellennamen und den Schemanamen speichert.

Der folgende Code deklariert unsere Variablen und die temporäre Tabelle:

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))

Rufen Sie die Liste der fragmentierten Indizes auf

Unser nächster Schritt besteht darin, die Liste der Indizes mit einem Fragmentierungsgrad von 30 % oder höher zu füllen. Wir müssen diese Indizes in die #FregmentedIndexes einfügen Tabelle.

Die Abfrage muss den Schemanamen, den Tabellennamen und den Indexnamen füllen, um sie in die temporäre Tabelle einzufügen. Sehen Sie sich diese Abfrage an:

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

Erstellen Sie eine dynamische SQL-Abfrage

Schließlich müssen wir den dynamischen ALTER INDEX erstellen Befehl und führen Sie ihn aus.

Um den Befehl zu generieren, verwenden wir die WHILE-Schleife. Es durchläuft die #FregmentedIndexes Tabelle und füllt den Schemanamen, den Tabellennamen und den Indexnamen aus, um sie in @SchemaName zu speichern , @Tabellenname und @IndexName . Die Parameterwerte werden im ALTER INDEX-Befehl angehängt.

Der Code lautet wie folgt:

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

Ich habe den gesamten Code in sp_index_maintenance gekapselt gespeicherte Prozedur, die in den DBATools erstellt wurde Datenbank. Der Code lautet wie folgt:

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

Sobald die Prozedur fertig ist, können wir den SQL-Job konfigurieren.

Erweitern Sie SQL Server-Agent > Rechtsklick auf Jobs > Neuer Job .

Der Neue Stelle Es öffnet sich ein Fenster, in dem Sie den gewünschten Jobnamen angeben sollten.

Navigieren Sie zum Erstellen eines Auftragsschritts zu den Schritten Abschnitt> Neu Schaltfläche:

Sie gelangen zum Neuer Job-Schritt Fenster, um diesen Schritt zu konfigurieren.

Geben Sie den gewünschten Schrittnamen ein und geben Sie den folgenden Code in das Textfeld ein:

use DBATools
go
exec sp_index_maintenance_daily 'AdventureWorks2017'

Um den Zeitplan zu konfigurieren, gehen Sie zu Zeitpläne > klicken Sie auf Neu .

Unser Auftrag sollte um 1:00 Uhr ausgeführt werden. Dementsprechend konfigurieren wir den Zeitplan:

  • Zeitplantyp > Wiederkehrend .
  • Die Häufigkeit Abschnitt> Kommt vor > Täglich ; Wiederholt alle > 1 (eins).
  • Die Tägliche Häufigkeit section> Tritt einmalig um auf > 01:00:00.
  • Klicken Sie auf OK .

Sie werden zurück zum Neuen Job versetzt Sektion. Klicken Sie auf OK auch dort, um den Job zu erstellen.

Der neu erstellte Job ist unter Jobs verfügbar Verzeichnis unter dem SQL Server Agent Ordner.

Wir müssen den Job jetzt testen:Klicken Sie mit der rechten Maustaste darauf und wählen Sie Job starten …

Der Auftrag wird gestartet und nach erfolgreichem Abschluss wird die folgende Meldung angezeigt:

Wenn wir den Clustered-Index mit dem Non-Clustered-Index vergleichen, sehen wir, dass die Erstellung eines eindeutigen Clustered-Index die Effizienz der Abfrageleistung erhöht. Indizierte Ansichten in SQL Server können verwendet werden, um die Abfrageausführung zu beschleunigen. Sehen Sie sich auch an, wie Indizes mit SQL Index Manager verwaltet werden.

Zusammenfassung

Der aktuelle Artikel stellte drei funktionale Möglichkeiten vor, Indizes aller Tabellen neu aufzubauen. Wir haben sie alle mit Schritt-für-Schritt-Anleitungen und praktischen SQL-Indexbeispielen untersucht, um die Jobkonfiguration zu veranschaulichen. Die Wahl der passenden Variante liegt bei Ihnen und wir hoffen, dass Ihnen dieser Artikel weitergeholfen hat.