Existem vários métodos de como reconstruir todos os índices de todas as tabelas no SQL Server, entre eles:
- Usando planos de manutenção do SQL Server.
- Usando script T-SQL com base na porcentagem de fragmentação.
- Usando o comando ALTER INDEX.
Neste artigo, vamos explorar esses métodos e ilustrá-los com exemplos práticos.
1. Plano de manutenção do índice de reconstrução do SQL Server
A primeira opção a ser revisada é reconstruir os índices com os planos de manutenção do banco de dados. Os planos de manutenção estão disponíveis na pasta de gerenciamento do SQL Server Management Studio.
Para criar o plano de manutenção do banco de dados SQL, inicie o SQL Server Management Studio > expandir a instância do banco de dados > Gerenciamento > clique com o botão direito do mouse no plano de manutenção > Novo Plano de Manutenção .
Especifique o nome do plano de manutenção. Em seguida, arraste e solte Tarefa de reconstrução de índice no designer do plano de manutenção. Renomeie a tarefa para Manutenção do índice .
A próxima etapa é configurar o plano de manutenção. Clique duas vezes nele e configure as opções na Tarefa de reconstrução de índice do seguinte modo:
- Selecione AdventureWorks2017 banco de dados no menu suspenso Banco de dados.
- Para reconstruir os índices de todas as tabelas, selecione Tabelas e exibições do Objeto caixa suspensa.
- Verifique Classificar resultados em tempdb .
- MAXDOP – definir 2 (dois).
- No nosso caso, reconstruiremos os índices somente se a Fragmentação valor é superior a 20%. Portanto, defina 20 no respectivo campo.
- Clique em OK para salvar a configuração do índice e fechar a Tarefa de reconstrução do índice janela.
Agora, vamos configurar o cronograma.
Clique no calendário ícone na parte superior do designer do plano de manutenção:
A Nova Agenda de Trabalho janela será aberta. Vamos definir as seguintes configurações:
- Execute o trabalho todos os dias. No Tipo de agendamento menu, selecionamos Recorrente . Em seguida, na Frequência seção, selecionamos Ocorre > Diariamente .
- Recorre a cada > 1 (dia).
- Frequência diária > Ocorre uma vez em > especifique a hora exata. No nosso caso, é 1h da manhã.
- Clique em OK .
Depois disso, salve o plano de manutenção.
Os planos de manutenção criados estão disponíveis no SSMS Plano de Manutenção diretório. Para visualizar a programação associada ao plano de manutenção específico, verifique os Trabalhos diretório em SQL Server Agent .
Para testar o trabalho, clique com o botão direito do mouse em seu nome nos Planos de manutenção diretório e selecione Executar do cardápio:
A execução começa. Quando ele for concluído com sucesso, você verá a seguinte caixa de diálogo:
Esse era o método comum de reconstrução de índices com planos de manutenção. Agora, vamos prosseguir para o próximo método – usando os scripts T-SQL.
2. Reconstrução do SQL Server ALTER INDEX
O comando ALTER INDEX pode ser usado para reconstruir todos os índices da tabela. A sintaxe é a seguinte:
ALTER INDEX ALL ON [table_name] REBUILDObservação:o table_name O parâmetro especifica o nome da tabela onde queremos reconstruir todos os índices no SQL Server.
Por exemplo, queremos reconstruir todos os índices de [HumanResources].[Employee] . A consulta deve ser a seguinte:
use AdventureWorks2017
go
ALTER INDEX ALL ON [HumanResources].[Employee] REBUILD
Go
3. Script do SQL Server para reconstruir todos os índices de todas as tabelas com base na fragmentação
A manutenção do índice consome muitos recursos. Além disso, ele bloqueia a tabela onde está reconstruindo o índice. Para evitar tais complicações, devemos reconstruir o índice onde a fragmentação do índice do SQL Server for superior a 40%.
Para ilustrar o caso, criei um script T-SQL que reconstrói índices com grau de fragmentação superior a 30%. Vamos explorar suas partes e funções.
Declaração de variáveis e tabela temporária
Primeiro, precisamos criar tabelas e variáveis temporárias:
- @IndexFregQuery – armazena a consulta dinâmica usada para preencher índices fragmentados.
- @IndexRebuildQuery – contém a consulta ALTER INDEX.
- @IndexName – o nome do índice que queremos reconstruir
- @TableName – o nome da tabela onde queremos reconstruir o índice.
- @SchemaName – o nome do esquema onde queremos reconstruir o índice.
- #Fregmentedindex – a tabela de 3 colunas que armazena o nome do índice, o nome da tabela e o nome do esquema.
O código a seguir declara nossas variáveis e a tabela temporária:
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))
Obter a lista de índices fragmentados
Nosso próximo passo é preencher a lista de índices com o grau de fragmentação de 30% ou superior. Devemos inserir esses índices nos #FregmentedIndexes tabela.
A consulta deve preencher o nome do esquema, o nome da tabela e o nome do índice para inseri-los na tabela temporária. Dê uma olhada nessa consulta:
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
Criar uma consulta SQL dinâmica
Finalmente, devemos construir o dinâmico ALTER INDEX comando e execute-o.
Para gerar o comando, estamos usando o loop WHILE. Ele percorre os #FregmentedIndexes table e preenche o nome do esquema, o nome da tabela e o nome do índice para salvá-los em @SchemaName , @TableName e @IndexName . Os valores dos parâmetros são anexados no comando ALTER INDEX.
O código é o seguinte:
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
Encapsulei todo o código no sp_index_maintenance procedimento armazenado criado no DBATools base de dados. O código está a seguir:
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
Assim que o procedimento estiver pronto, podemos configurar o SQL Job.
Expanda SQL Server Agent > clique com o botão direito do mouse em Trabalhos > Novo emprego .
O Novo Emprego é aberta uma janela onde você deve especificar o nome do trabalho desejado.
Para criar uma etapa de trabalho, navegue até as Etapas seção> o Novo botão:
Você chegará à Etapa de Novo Trabalho janela para configurar essa etapa.
Digite o nome da etapa desejada e digite o seguinte código na caixa de texto:
use DBATools
go
exec sp_index_maintenance_daily 'AdventureWorks2017'
Para configurar a programação, vá para Programações > clique em Novo .
Nosso trabalho deve ser executado às 1:00 da manhã. Assim, configuramos o cronograma:
- Tipo de agendamento > Recorrente .
- A Frequência seção> Ocorre > Diariamente ; Recorre a cada > 1 (um).
- A Frequência diária section> Ocorre uma vez em > 01:00:00.
- Clique em OK .
Você será transferido de volta para o Novo Emprego seção. Clique em OK lá também para criar o trabalho.
O trabalho recém-criado está disponível em Trabalhos diretório no SQL Server Agent pasta.
Precisamos agora testar o trabalho:clique com o botão direito nele e selecione Iniciar trabalho…
O trabalho é iniciado e, após a conclusão bem-sucedida, você verá a seguinte mensagem:
Se compararmos o índice clusterizado com o índice não clusterizado, veremos que a criação de um índice clusterizado exclusivo aumenta a eficiência do desempenho da consulta. As exibições indexadas no SQL Server podem ser usadas para acelerar a execução da consulta. Confira também como gerenciar índices usando o SQL Index Manager.
Resumo
O artigo atual apresentou três formas funcionais de reconstruir índices de todas as tabelas. Exploramos todos eles com diretrizes passo a passo e exemplos práticos de índice SQL para ilustrar a configuração do trabalho. A escolha da variante adequada é sua e esperamos que este artigo tenha sido útil para você.
