Embora os índices sejam muito úteis e necessários em projetos de bancos de dados com desempenho, eles precisam de manutenção. Uma das razões para isso é a fragmentação. O Mecanismo de banco de dados do SQL Server mantém índices automaticamente sempre que ocorrem modificações de inserção, atualização ou exclusão. No entanto, com o tempo e principalmente quando ocorrem modificações pesadas nos dados, os dados do índice ficam dispersos no banco de dados e, portanto, fragmentados. Essa fragmentação afeta o desempenho do processo de busca de índice, porque esses índices não têm a ordem lógica exata com a ordem física dentro do (s) arquivo (s) de dados do banco de dados.

Uma maneira de lidar com esse problema é reconstruindo índices fragmentados. Se você fizer isso usando um Plano de Manutenção, reconstruirá todos os índices no banco de dados, em vez de reconstruir apenas os índices fragmentados (isso foi alterado no SQL Server 2016). Esta dica fornece um script T-SQL totalmente parametrizado que identifica apenas os índices fragmentados em um banco de dados ou em todos os bancos de dados em uma instância do SQL Server e gera um relatório com os comandos de desfragmentação para revisão e execução controlada ou reorganiza ou reconstrói diretamente o índices fragmentados com base nas recomendações da Microsoft . 

Solução

Antes de apresentar o script, vamos discutir um pouco sobre o processo de reconstrução de índices. Antes de tudo, nunca recrie índices que não precisam ser reconstruídos. Conforme recomendação da Microsoft, quando um índice tiver uma porcentagem média de fragmentação (use sys.dm_db_index_physical_stats para obter essas estatísticas) maior que 5% e menor ou igual a 30%, você não precisará recriar o índice. Nesse caso, você só precisa reorganizá-lo. Quando o índice tem uma porcentagem média de fragmentação acima de 30%, sim, é necessário reconstruí-lo. Nas configurações mais modernas do SQL Server, como, por exemplo, os Grupos de disponibilidade AlwaysOn, você deve fazer verificações adicionais nos scripts de manutenção de índice. Por exemplo, você deve verificar se um banco de dados é a réplica primária ou não. Se for a réplica primária, você poderá prosseguir com a manutenção do índice.

O script T-SQL apresentado nesta dica lida com todos os itens acima. Você pode executá-lo em instâncias do SQL Server em cluster, instâncias do AlwaysOn Availability Group, etc. Ele possui lógica interna que, com base nas recomendações da Microsoft, gera dinamicamente reorganizações ou reconstruções de instruções apenas para os índices fragmentados.

Abaixo o script:

----
-- Script that reorganizes or rebuilds all indexes having an average fragmentation 
-- percentage above a given threshold. It also works in the case
-- where Availability Groups are enabled as it determines if the
-- relevant databases are the primary replicas.
--
-- This script supports only SQL Server 2005 or later.
-- Also, if you execute this script in a SQL Server 2005 instance 
-- or later, any databases with compatibility level 2000 (80) or earlier
-- will be automatically excluded from the index reorganization/rebuild process.
----

--Initial check - You must be SysAdmin
DECLARE @isSysAdmin INT
SET @isSysAdmin=(SELECT IS_SRVROLEMEMBER ('sysadmin'));

--Initial check - You must be using SQL Server 2005 or later
DECLARE @SQLServerVersion INT
SET @SQLServerVersion=(SELECT CAST(LEFT(CAST(SERVERPROPERTY('ProductVersion') AS VARCHAR(50)),CHARINDEX('.',CAST(SERVERPROPERTY('ProductVersion') AS VARCHAR(50)))-1) AS INT));


IF @isSysAdmin=1 AND @SQLServerVersion >= 9
BEGIN 

--
-- Variable/parameters Declaration
--
DECLARE @dbname NVARCHAR(128);
DECLARE @ReorganizeOrRebuildCommand NVARCHAR(MAX);
DECLARE @dbid INT;
DECLARE @indexFillFactor VARCHAR(5); 
DECLARE @fragmentationThreshold VARCHAR(10);
DECLARE @indexStatisticsScanningMode VARCHAR(20);
DECLARE @verboseMode BIT;
DECLARE @reportOnly BIT;
DECLARE @sortInTempdb VARCHAR(3);
DECLARE @isHadrEnabled BIT;
DECLARE @databaseToCheck VARCHAR(250)
DECLARE @dynamic_command NVARCHAR(1024);
DECLARE @dynamic_command_get_tables NVARCHAR(MAX);

--Initializations - Do not change
SET @databaseToCheck=NULL;
SET @dynamic_command = NULL;
SET @dynamic_command_get_tables = NULL;
SET @isHadrEnabled=0;

SET NOCOUNT ON;

---------------------------------------------------------
--Set Parameter Values: You can change these (optional) -
--Note: The script has default parameters set   -
---------------------------------------------------------
--if set to 1: it will just generate a report with the index reorganization/rebuild statements
--if set to 0: it will reorganize or rebuild the fragmented indexes
SET @reportOnly = 0;

--optional: if not set (NULL), it will scann all databases
--If name is set (i.e. 'testDB') it will just scan the given database
SET @databaseToCheck = NULL;

--maintains only the indexes that have average fragmentation percentage equal or higher from the given value
SET @fragmentationThreshold = 15; 

--fill factor - the percentage of the data page to be filled up with index data
SET @indexFillFactor = 90; 

--sets the scanning mode for index statistics 
--available values: 'DEFAULT', NULL, 'LIMITED', 'SAMPLED', or 'DETAILED'
SET @indexStatisticsScanningMode='SAMPLED';

--if set to ON: sorts intermediate index results in TempDB 
--if set to OFF: sorts intermediate index results in user database's log file
SET @sortInTempdb='ON'; 

--if set to 0: Does not output additional information about the index reorganization/rebuild process
--if set to 0: Outputs additional information about the index reorganization/rebuild process
SET @verboseMode = 0; 
------------------------------
--End Parameter Values Setup -
------------------------------

-- check if given database exists and if compatibility level >= SQL 2005 (90)
IF @verboseMode=1
 PRINT 'Checking if database '+@databaseToCheck+' exists and if compatibility level equals or greater 2005 (90)';

 -- if given database does not exist, raise error with severity 20
 -- in order to terminate script's execution
IF @databaseToCheck IS NOT NULL
BEGIN
 DECLARE @checkResult INT
 SET @checkResult=(SELECT COUNT(*) FROM master.sys.databases WHERE [name]=RTRIM(@databaseToCheck));
 IF @checkResult<1
  RAISERROR('Error executing index reorganization/rebuild script: Database does not exist' , 20, 1) WITH LOG;

 DECLARE @checkResult2 INT
 SET @checkResult=(SELECT [compatibility_level] FROM master.sys.databases WHERE [name]=RTRIM(@databaseToCheck));
 IF @checkResult<90 RAISERROR('Error executing index reorganization/rebuild script: Only databases with SQL Server 2005 or later compatibility level are supported' , 20, 1) WITH LOG; END IF @verboseMode=1 PRINT 'Initial checks completed with no errors.'; -- Temporary table for storing index fragmentation details IF OBJECT_ID('tempdb..#tmpFragmentedIndexes') IS NULL BEGIN CREATE TABLE #tmpFragmentedIndexes ( [dbName] sysname, [tableName] sysname, [schemaName] sysname, [indexName] sysname, [databaseID] SMALLINT , [objectID] INT , [indexID] INT , [AvgFragmentationPercentage] FLOAT, [reorganizationOrRebuildCommand] NVARCHAR(MAX) ); END -- Initialize temporary table DELETE FROM #tmpFragmentedIndexes; -- Validate parameters/set defaults IF @sortInTempdb NOT IN ('ON','OFF') SET @sortInTempdb='ON'; -- Check if instance has AlwaysOn AGs enabled SET @isHadrEnabled=CAST((SELECT ISNULL(SERVERPROPERTY('IsHadrEnabled'),0)) AS BIT); -- if database not specified scan all databases IF @databaseToCheck IS NULL BEGIN DECLARE dbNames_cursor CURSOR FOR SELECT s.[name] AS dbName , s.database_id FROM master.sys.databases s WHERE s.state_desc = 'ONLINE' AND s.is_read_only != 1 AND s.[name] NOT IN ( 'master', 'model', 'tempdb' ) AND s.[compatibility_level]>=90
    ORDER BY s.database_id;    
END 
ELSE
-- if database specified, scan only that database
BEGIN
DECLARE dbNames_cursor CURSOR 
FOR
    SELECT  s.[name] AS dbName ,
            s.database_id
    FROM    master.sys.databases s            
    WHERE   s.state_desc = 'ONLINE'
            AND s.is_read_only != 1                        
   AND s.[name]=RTRIM(@databaseToCheck)    
END 

-- if Always On Availability Groups are enabled, check for primary databases
-- (thus exclude secondary databases)
IF @isHadrEnabled=1
BEGIN

DEALLOCATE dbNames_cursor;

-- if database not specified scan all databases
IF @databaseToCheck IS NULL
BEGIN
 DECLARE dbNames_cursor CURSOR
 FOR
  SELECT  s.[name] AS dbName ,
    s.database_id
  FROM    master.sys.databases s
    LEFT JOIN master.sys.dm_hadr_availability_replica_states r ON s.replica_id = r.replica_id
  WHERE   s.state_desc = 'ONLINE'
    AND s.is_read_only != 1
    AND UPPER(ISNULL(r.role_desc, 'NonHadrEnabled')) NOT LIKE 'SECONDARY'
    AND s.[name] NOT IN ( 'master', 'model', 'tempdb' )
    AND s.[compatibility_level]>=90 
  ORDER BY s.database_id;    
END
ELSE
-- if database specified, scan only that database
BEGIN
 DECLARE dbNames_cursor CURSOR
 FOR
  SELECT  s.[name] AS dbName ,
    s.database_id
  FROM    master.sys.databases s
    LEFT JOIN master.sys.dm_hadr_availability_replica_states r ON s.replica_id = r.replica_id
  WHERE   s.state_desc = 'ONLINE'
    AND s.is_read_only != 1
    AND UPPER(ISNULL(r.role_desc, 'NonHadrEnabled')) NOT LIKE 'SECONDARY'    
    AND s.[name]=RTRIM(@databaseToCheck);  
END 
END 


--
-- For each database included in the cursor, 
-- gather all tables that have indexes with 
-- average fragmentation percentage equal or above @fragmentationThreshold
--
OPEN dbNames_cursor;
FETCH NEXT FROM dbNames_cursor INTO @dbname, @dbid;
WHILE @@fetch_status = 0
    BEGIN   
 
 --If verbose mode is enabled, print logs
        IF @verboseMode = 1
            BEGIN
    PRINT ''
                PRINT 'Gathering index fragmentation statistics for database: ['+ @dbname + '] with id: ' + CAST(@dbid AS VARCHAR(10));    
            END;
                   
        SET @dynamic_command_get_tables = N'
 USE [' + @dbname+ N'];
 INSERT INTO #tmpFragmentedIndexes (
  [dbName],
  [tableName],
  [schemaName],
  [indexName],
  [databaseID],
  [objectID],
  [indexID],
  [AvgFragmentationPercentage],
  [reorganizationOrRebuildCommand]  
  )
  SELECT
     DB_NAME() as [dbName], 
     tbl.name as [tableName],
     SCHEMA_NAME (tbl.schema_id) as schemaName, 
     idx.Name as [indexName], 
     pst.database_id as [databaseID], 
     pst.object_id as [objectID], 
     pst.index_id as [indexID], 
     pst.avg_fragmentation_in_percent as [AvgFragmentationPercentage],
     CASE WHEN pst.avg_fragmentation_in_percent > 30 THEN 
     ''ALTER INDEX [''+idx.Name+''] ON [''+DB_NAME()+''].[''+SCHEMA_NAME (tbl.schema_id)+''].[''+tbl.name+''] REBUILD WITH (FILLFACTOR = '+@indexFillFactor+', SORT_IN_TEMPDB = '+@sortInTempdb+', STATISTICS_NORECOMPUTE = OFF);''
     WHEN pst.avg_fragmentation_in_percent > 5 AND pst.avg_fragmentation_in_percent <= 30 THEN ''ALTER INDEX [''+idx.Name+''] ON [''+DB_NAME()+''].[''+SCHEMA_NAME (tbl.schema_id)+''].[''+tbl.name+''] REORGANIZE;'' ELSE NULL END FROM sys.dm_db_index_physical_stats(DB_ID(), NULL, NULL, NULL , '''+@indexStatisticsScanningMode+''') as pst INNER JOIN sys.tables as tbl ON pst.object_id = tbl.object_id INNER JOIN sys.indexes idx ON pst.object_id = idx.object_id AND pst.index_id = idx.index_id WHERE pst.index_id != 0 AND pst.alloc_unit_type_desc IN ( N''IN_ROW_DATA'', N''ROW_OVERFLOW_DATA'') AND pst.avg_fragmentation_in_percent >= '+ @fragmentationThreshold + '';
        
  -- if verbose  mode is enabled, print logs    
  IF @verboseMode=1
   BEGIN
    PRINT 'Index fragmentation statistics script: ';    
    PRINT @dynamic_command_get_tables;
  END

  -- gather index fragmentation statistics
        EXEC (@dynamic_command_get_tables);
       
     -- bring next record from the cursor
        FETCH NEXT FROM dbNames_cursor INTO @dbname, @dbid;
    END;

CLOSE dbNames_cursor;
DEALLOCATE dbNames_cursor;

------------------------------------------------------------

-- if 'report only' mode is enabled
IF @reportOnly=1
BEGIN 
 SELECT  dbName ,
            tableName ,
            schemaName ,
            indexName ,            
            AvgFragmentationPercentage ,
            reorganizationOrRebuildCommand
 FROM    #tmpFragmentedIndexes
 ORDER BY AvgFragmentationPercentage DESC;
END
ELSE 
-- if 'report only' mode is disabled, then execute 
-- index reorganize/rebuild statements
BEGIN 
 DECLARE reorganizeOrRebuildCommands_cursor CURSOR
 FOR
    SELECT  reorganizationOrRebuildCommand
  FROM #tmpFragmentedIndexes
  WHERE reorganizationOrRebuildCommand IS NOT NULL
  ORDER BY AvgFragmentationPercentage DESC;

 OPEN reorganizeOrRebuildCommands_cursor;
 FETCH NEXT FROM reorganizeOrRebuildCommands_cursor INTO @ReorganizeOrRebuildCommand;
 WHILE @@fetch_status = 0
  BEGIN   
         
   IF @verboseMode = 1
   BEGIN
     PRINT ''
     PRINT 'Executing script:'     
     PRINT @ReorganizeOrRebuildCommand
   END
          
   EXEC (@ReorganizeOrRebuildCommand);          
   FETCH NEXT FROM reorganizeOrRebuildCommands_cursor INTO @ReorganizeOrRebuildCommand;
  END;

 CLOSE reorganizeOrRebuildCommands_cursor;
 DEALLOCATE reorganizeOrRebuildCommands_cursor;

 PRINT ''
 PRINT 'All fragmented indexes have been reorganized/rebuilt.'
 PRINT ''
END
END 
ELSE
BEGIN
 PRINT '';
 PRINT 'Error: You need to be SysAdmin and use SQL Server 2005 or later in order to use this script.';
 PRINT '';
END
--End of Script

O código desse e outros exemplos podem ser encontrados em nosso git.

Post interessantes:

Aprenda a instalar o Protheus aqui.

Retornar datas por extenso aqui.

Importancia de monitorar SQL server aqui.

Dúvidas e sugestões, entre em contato.

Obrigado e até a próxima!

O post Script para gerenciar reconstruir e reorganizar para fragmentação de índice do SQL Server apareceu primeiro em Sem Preju.

Para remediar isso, aqui está uma rápida visão de por que vale a pena fazer um esforço conjunto para monitorar servidores SQL.

Alcançando otimização

A menos que você rastreie ativamente os contadores de desempenho do servidor SQL , não saberá se existem áreas nas quais melhorias no desempenho possam ser alcançadas. Isso pode levar você a acreditar que seu servidor já está com o desempenho ideal, quando na verdade há um problema flagrante que está criando um gargalo e limitando sua eficácia como resultado.

Por exemplo, verificando quanto dos recursos da CPU estão sendo monopolizados em um determinado momento, é possível ver se o servidor tem ou não espaço suficiente para lidar com a atividade exigida pelos usuários ou se pode estar próximo para maximizar seus recursos de hardware e, assim, se comportar de maneira lenta.

Um problema semelhante pode surgir se a memória interna estiver saturada. A menos que você saiba quais processos estão ocupando os recursos do sistema, você não poderá gerenciar isso e encontrar uma solução adequada. Com as ferramentas de monitoramento corretas, você terá conhecimento e poderá tomar medidas para fins de otimização.

Tomar decisões a longo prazo

Embora os benefícios minuto a minuto do monitoramento do servidor SQL possam permitir melhorias de desempenho em tempo real, também há benefícios a serem observados se você observar a trajetória mais ampla de como o seu hardware lida com as cargas de trabalho.

Por exemplo, existem alguns problemas que só são possíveis identificar se você analisar tendências em períodos maiores. Isso é especialmente útil se você deseja mapear as atualizações necessárias mais adiante, planejando as crescentes demandas que o servidor enfrenta e estando pronto para responder a elas no futuro, em vez de permitir que esses problemas ocorram rapidamente. vocês.

Economizando dinheiro

A manutenção do servidor leva tempo e custa bastante dinheiro às empresas, e é claro que o tempo de inatividade e as interrupções não planejadas são caros por si só.

A vantagem de usar o monitoramento do servidor SQL é que você pode cortar os problemas pela raiz mais cedo ou mais tarde e também automatizar grande parte do processo para que você não precise vasculhar manualmente uma grande quantidade de dados para encontrar o ponto relevante que mostra onde uma configuração abaixo do ideal ou um componente de hardware prejudicado está.

Embora  os orçamentos de TI possam estar crescendo , faz sentido garantir que esse dinheiro seja gasto em coisas que realmente importam; portanto, se o monitoramento do servidor SQL for capaz de reduzir custos em uma área, isso significará que dinheiro é liberado para ser investido em outro lugar.

Resposta a desastres

Embora para uso no dia a dia, as ferramentas de monitoramento do SQL Server possam fornecer informações sobre os problemas pequenos, mas coletivamente significativos, que podem estar presentes, também são vitais para fornecer as habilidades e o entendimento necessários para agir no caso de um problema mais sério.

Se todos os recursos da CPU forem repentinamente consumidos sem motivo óbvio, se a velocidade de I/O for lenta para um rastreamento inesperado ou se o desempenho da rede cair drasticamente do nada, você precisará saber onde procurar para iniciar o processo de solução de problemas.

Ao monitorar seu servidor e realizar manutenção regular, você terá a capacidade de fazer tudo isso, tornando-o um ativo valioso para sua organização.

Dúvidas e sugestões, entre em contato.

Obrigado e até a próxima!

O post A importância do monitoramento do SQL Server apareceu primeiro em Sem Preju.

Continuando a instalação do Protheus, vamos realizar a instalação do  SQL Server 2017, do SQL Server Management Studio e configurar a conexão ODBC.

Não abordaremos nesse post sobre melhores praticas de configuração do SQL Server, nosso objetivo será somente a instalação default para o funcionamento do Protheus.

1. Abra o instalador do SQL Express, e selecione o tipo de instalação Personalizada.

2. Selecione o idioma desejado, o destino de instalação e cliquem em Instalar.

3. Iniciando o Setup.

Se após o download a etapa de instalação não iniciar automaticamente, devemos iniciar o setup manualmentem, para isso abre o caminho onde foi realizado a instalação, no meu caso foi em C:\SQLServer2017Media\ExpressAdv_PTB, e execute o arquivo SETUP.EXE

A tela abaixo deverá ser exibida para continuarmos a instalação.

No menu a esquerda acesse a opção “Instalação”, no menu funcional a direita selecione a opção  “Nova instalação autônoma do SQL Server”.

4. Atualiza automaticamente

Caso deseje que o Windows busque atualizações para SQL marque a opção caso não somente cliente que avançar.

5. Avance a instalação.

O instalador irá realizar algumas validações e o resultado abaixo será exibido.

Se tiver algum aviso de erro, devemos corrigir antes de continuar, na minha instalação foi identificado um aviso sobre o Firewall, nesse momento vamos seguir com a instalação clicando em Avançar.

6. Escolha a opção para a instalação de uma nova instancia do SQL Server 2017.

7. Seleção dos recursos.

Para o funcionamento do Protheus precisamos apenas no serviço de banco de dados e vamos marcar somente essa opção

8. Configuração da instancia.

Caso deseje podemos deixar com a instancia padrão do SQL, caso informe um nome para a instancia precisaremos dessa informação para conectar no futuro.

Em Designador de agrupamento, selecione a opção: Latin1_General e marque a opção Binário, conforme o print abaixo.

10. Configuração do usuário.

Configuraremos agora uma senha para o usuário padrão do SQL, para isso selecione a opção Modo Misto e informe uma senha(essa será a senha mais importante do SQL).

11. Aguarde o processamento da instalação.

Agora vamos instalar o SQL Server Management Studio, será dentro dessa ferramenta que vamos criar e realizar manutenção em nosso banco de dados.

1. Execute o instalador do SQL Server Management Studio, clique em install para iniciar a instalação.

2. O processo de instalação será iniciado.

Vamos criar o nosso banco de dados que usaremos para o Protheus, para isso devemos realizar os seguintes passos:

1. Abrir o SQL Server Management Studio, para isso busque no menu iniciar sobre o seu atalho ssms. 

2. No Nome do servidor, coloque localhost (ou substitua pelo endereço IP), coloque o usuário sa, e a senha que criamos no passo 10 na instalação do SQL Server.

15. Clique com o botão direito em Bancos de Dados(Database), e clique em Novo Banco de Dados(New Database).

16. Digite um nome para o banco de Dados, no nosso caso TOTVS_12_25.

Vamos criar a conexão entre o sistema operacional e nosso banco, essa conecção será usada pelo Top Connect (DBAccess ).

1. No menu executar digite ODBC, selecione “Fonts de Dados ODBC (64 bits).

Obs.: Caso você utilize o TOTVS | DBAccess 32 bits em sistemas operacionais 64 bits, o certo é configurar o ODBC 32 bit

2. Na aba de DSN de Sistema, clique em Adicionar.

Selecione a opção “SQL Server Native Cliente” (caso não tenha, por padrão pode ser o SQL Server) e clique em concluir.

3. Coloque o nome da conexão, usaremos o mesmo da base de dados, a descrição pode ser a mesma que o nome, e o servidor o IP\Instância, no nosso caso, localhost, clique em Avançar.

4. Coloque como autenticação do SQL Server, coloque o usuário sa, e a senha criada no passo 10 na instalação do SQL Server.

5. Cheque a opção para Alterar o Banco de Dados padrão, e escolhe o seu banco criado.

6. Ao avançar a tela abaixo sera exibida.

Clique em testar a fonte de dados

Deve aparecer a mensagem TESTE CONCLUÍDOS COM ÊXITO, agora podemos clicar em ok e confirmar a criação da ODBC.

Esse post ficou muito grande, mas conseguimos  demonstrar nele instalar nosso servidor SQL, e toda a configuração da conexão, no próximo post vamos iniciar a instalação do Protheus.

Abraços e até.

O post Como instalar o Protheus – SQL Server – Parte 2 apareceu primeiro em Sem Preju.