Análise do MS SQL Server para quem o vê pela primeira vez

Que problemas consideraremos?

Primeiro de tudo

Abreviações

• SSMS é um aplicativo do Microsoft SQL Server Management Studio. A partir da versão 2016, está disponível gratuitamente no site da MS como um aplicativo independente. docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms

• Profiler é um aplicativo do “SQL Server Profiler” instalado com SSMS.
• Performance Monitor é um snap-in do painel de controle que permite monitorar os contadores de desempenho, registrar e visualizar o histórico de medições.

• executar o SSMS;
• conectar-se a um servidor necessário;
• expandir a árvore no Inspetor de Objetos:Planos de Gerenciamento\Manutenção (Planos de Serviço);
• clique com o botão direito do mouse no nó e selecione "Assistente de plano de manutenção";
• no assistente, marque as tarefas necessárias:reconstruir o índice e atualizar as estatísticas

• você pode marcar as duas tarefas de uma vez ou fazer dois planos de manutenção com uma tarefa em cada (veja as “notas importantes” abaixo);
• além disso, verificamos um banco de dados necessário (ou vários bancos de dados). Fazemos isso para cada tarefa (se forem escolhidas duas tarefas, haverá duas caixas de diálogo com a escolha de um banco de dados);
• Próximo, Próximo, Concluir.

• A atualização de estatísticas é uma operação sem bloqueio. Você pode realizá-lo em um modo de trabalho.
• A reconstrução do índice é uma operação de bloqueio. Você pode executá-lo apenas fora do horário de trabalho. Há uma exceção — a edição Enterprise do servidor permite a execução de uma “reconstrução online”. Esta opção pode ser habilitada nas configurações da tarefa. Observe que há uma marca de seleção em todas as edições, mas funciona apenas no Enterprise.
• É claro que essas tarefas devem ser realizadas regularmente. Sugiro uma maneira fácil de determinar com que frequência você faz isso:

O servidor está lento – o que você deve fazer?

Os recursos usados ​​pelo servidor

CPU Carregar

Disco Loa d

• comprimento médio da fila (operações de E/S pendentes, número);
• velocidade de leitura e gravação (em Mb/s).

• Disco físico (lógico)/tempo médio de leitura (gravação)
• Disco físico (lógico)/Comprimento médio da fila de disco
• Disco físico (lógico)/Velocidade do disco

• A fila não deve exceder 1. Intervalos curtos são permitidos se diminuirem rapidamente. As rajadas podem ser diferentes dependendo do seu sistema. Para um espelho RAID simples de dois HDDs – a fila de mais de 10-20 é um problema. Para uma biblioteca legal com supercaching, vi rajadas de até 600-800 que foram resolvidas instantaneamente sem causar atrasos.
• A taxa de câmbio normal também depende do tipo de sistema de disco. O HDD usual (desktop) transmite a 50-100 MB/s. Uma boa biblioteca de discos – a 500 MB/s e mais. Para pequenas operações aleatórias, a velocidade é menor. Este pode ser seu ponto de referência.
• Esses parâmetros devem ser considerados como um todo. Se sua biblioteca transmite 50 MB/s e uma fila de 50 operações se alinha - obviamente, algo está errado com o hardware. Se a fila se alinhar quando a transmissão estiver próxima do máximo - provavelmente, os discos não são os culpados - eles simplesmente não podem fazer mais - precisamos procurar uma maneira de reduzir a carga.
• A carga deve ser verificada separadamente nos discos (se houver vários) e comparada com a localização dos arquivos do servidor. O Gerenciador de Tarefas pode mostrar os arquivos usados ​​mais ativamente. Isso pode ser usado para garantir que a carga seja causada pelo DBMS.

• problemas com hardware

• cache queimado, desempenho caiu drasticamente;
• o sistema de disco é usado por outra coisa;

• Falta de RAM. Trocando. Сaching decaiu, desempenho caiu (veja a seção sobre RAM abaixo).
• A carga do usuário aumentou. É necessário avaliar o trabalho dos usuários (consulta problemática/nova funcionalidade/aumento do número de usuários/aumento da quantidade de dados/etc).
• Fragmentação de dados do banco de dados (veja a reconstrução do índice acima), fragmentação de arquivos do sistema.
• O sistema de disco atingiu sua capacidade máxima.

• Não misture arquivos do SO com arquivos de dados de banco de dados. Armazene-os em diferentes mídias físicas para que o sistema não concorra com o DBMS para E/S.
• O banco de dados consiste em dois tipos de arquivo:dados (*.mdf, *.ndf) e logs (*.ldf).
  Os arquivos de dados, via de regra, são usados ​​principalmente para leitura. Os logs servem para escrita (em que a escrita é consecutiva). Recomenda-se, portanto, armazenar logs e dados em diferentes mídias físicas para que o log não interrompa a leitura dos dados (como regra, a operação de gravação tem precedência sobre a leitura).
• O MS SQL pode usar “tabelas temporárias” para processamento de consultas. Eles são armazenados no banco de dados do sistema tempdb. Se você tiver uma carga alta de arquivos desse banco de dados, tente renderizá-lo em uma mídia fisicamente separada.

1. Tarefas de análise de uma solicitação específica.
2. Tarefas de análise de carga do aplicativo em condições específicas (por exemplo, quando um usuário clica em um botão em um aplicativo de terceiros compatível com o banco de dados).
3. Tarefas de análise da situação atual.

Aviso

Analisar um P articular R equest

• Você pode obter o plano de consulta clicando nos botões "Exibir plano de execução estimado" e "Incluir plano de execução real". A diferença entre eles é que o plano de estimativa é construído sem uma execução de consulta. Assim, serão estimadas as informações sobre o número de linhas processadas. No plano real, haverá dados estimados e reais. Fortes discrepâncias desses valores indicam que as estatísticas não são relevantes. No entanto, a análise do plano é assunto para outro artigo – até agora, não nos aprofundaremos.
• Podemos obter medições dos custos do processador e das operações de disco do servidor. Para isso, é necessário habilitar a opção SET. Você pode fazer isso na caixa de diálogo "Opções de consulta" assim:

      SET STATISTICS IO ON
      SET STATISTICS TIME ON
      SELECT * FROM Production.Product p
      JOIN Production.ProductDocument pd ON p.ProductID = pd.ProductID
      JOIN Production.ProductProductPhoto ppp ON p.ProductID = ppp.ProductID

Time of SQL Server parsing and compilation:
CPU time = 16 ms, elapsed time = 89 ms.
 
SQL Server performance time:
CPU time = 0 ms, time spent = 0 ms.
 
SQL Server performance time:
CPU time = 0 ms, time spent = 0 ms.
(32 row(s) affected)
The «ProductProductPhoto» table. The number of views is 32, logic reads – 96, physical reads 5, read-ahead reads 0, lob of logical reads 0, lob of physical reads 0, lob of read-ahead reads 0.
The ‘Product’ table. The number of views is 0, logic reads – 64, physical reads – 0, read-ahead reads – 0, lob of logical reads – 0, lob of physical reads – 0, lob of readahead reads – 0.
The «ProductDocument» table. The number of views is 1, logical reads – 3, physical reads – 1, read-ahead reads -, lob of logical reads – 0, lob of physical reads – 0, lob of readahead reads – 0.
Time of SQL activity:
CPU time = 15 ms, spent time = 35 ms.

• O botão «Incluir estatísticas do cliente» exibe as informações sobre a troca de rede, a quantidade de operações executadas e o tempo total de execução, incluindo os custos de troca de rede e processamento por um cliente. O exemplo mostra que leva mais tempo para executar a consulta pela primeira vez:

• No SSMS 2016, existe o botão «Incluir estatísticas de consulta ao vivo». Ele exibe a imagem como no caso do plano de consulta, mas contém os dígitos não aleatórios das linhas processadas, que mudam na tela durante a execução da consulta. A imagem é muito clara - setas piscando e números em execução, você pode ver imediatamente onde o tempo é desperdiçado. O botão também funciona para SQL Server 2014 e posterior.

• Verifique os custos de CPU usando SET STATISTICS TIME ON.
• Operações de disco:SET STATISTICS IO ON. Não esqueça que a leitura lógica é uma operação de leitura concluída no cache de disco sem acessar fisicamente o sistema de disco. A “leitura física” leva muito mais tempo.
• Avalie o volume de tráfego de rede usando «Incluir estatísticas do cliente».
• Analise o algoritmo de execução da consulta pelo plano de execução usando «Incluir Plano de Execução Real» e «Incluir Estatísticas de Consulta ao Vivo».

Analise a carga do aplicativo

• Procedimentos armazenados \ RPC:Concluído
• TSQL\SQL:BatchCompleted

• Procedimentos armazenados \ RPC:Iniciando
• TSQL \ SQL:BatchStarting

• Stored Procedures \ SP:Starting (*Completed) monitora a chamada interna para o procedimento armazenado não do cliente, mas dentro da solicitação atual ou de outro procedimento.
• Stored Procedures \ SP:StmtStarting (*Completed) rastreia o início de cada instrução dentro do procedimento armazenado. Se houver um ciclo no procedimento, o número de eventos para os comandos no ciclo será igual ao número de iterações no ciclo.
• TSQL \ SQL:StmtStarting (*Completed) monitora o início de cada instrução no lote SQL. Se houver vários comandos em sua consulta, cada um deles conterá um evento. Assim, funciona para os comandos localizados na consulta.

Por C colunas

• TextData, BinaryData contém o texto da consulta.
• CPU, leituras, gravações e duração exibem dados de consumo de recursos.
• StartTime, EndTime é a hora de iniciar e terminar o processo de execução. Eles são convenientes para classificação.

O que mais precisamos do criador de perfil? Claro, o plano de execução!

E isso não é tudo

Analisando a atividade do usuário no servidor

• dm_exec_sessions fornece informações sobre sessões de usuários conectados. Dentro do nosso artigo, os campos úteis são aqueles que identificam um usuário (login_name, login_time, host_name, program_name, …) e campos com as informações sobre recursos gastos (cpu_time, reads, writes, memory_usage, …)
• dm_exec_requests fornece informações sobre as consultas executadas no momento.
• session_id é um identificador da sessão para vincular à visualização anterior.
• start_time é o tempo de execução da visualização.
• comando é um campo que contém um tipo do comando executado. Para consultas do usuário, é select/update/delete/
• sql_handle, statement_start_offset, statement_end_offset fornecem informações para recuperar o texto da consulta:handle, bem como a posição inicial e final no texto da consulta, o que significa a parte que está sendo executada no momento (para o caso em que sua consulta contém vários comandos).
• plan_handle é um identificador do plano gerado.
• blocking_session_id indica o número da sessão que causou o bloqueio se houver bloqueios que impeçam a execução da consulta
• wait_type, wait_time, wait_resource são campos com as informações sobre o motivo e a duração da espera. Para alguns tipos de espera, por exemplo, bloqueio de dados, é necessário indicar adicionalmente um código para o recurso bloqueado.
• percent_complete é a porcentagem de conclusão. Infelizmente, está disponível apenas para comandos com um progresso claramente previsível (por exemplo, backup ou restauração).
• cpu_time, reads, writes, logical_reads, grant_query_memory são custos de recursos.
• dm_exec_sql_text(sql_handle | plan_handle), sys.dm_exec_query_plan(plan_handle) são funções de obtenção do texto e do plano de execução. Abaixo, consideraremos um exemplo de seu uso.
• dm_exec_query_stats é uma estatística resumida da execução de consultas. Ele exibe a consulta, o número de execuções e o volume de recursos gastos.

Observações importantes

Como usar

1. Faça uma seleção e armazene-a em uma tabela temporária
2. Aguarde um pouco
3. Faça uma seleção pela segunda vez
4. Compare esses resultados. A diferença indicará os custos gastos na etapa 2.
5. Por conveniência, a diferença pode ser dividida pela duração da etapa 2 para obter os “custos por segundo” médios.

if object_id('tempdb..#tmp') is NULL
BEGIN
        SELECT * into #tmp from sys.dm_exec_sessions s
        PRINT 'wait for a second to collect statistics at the first run '
        -- we do not wait for the next launches, because we compare with the result of the previous launch
        WAITFOR DELAY '00:00:01';
END
if object_id('tempdb..#tmp1') is not null drop table #tmp1

declare @d datetime
declare @dd float
select @d = crdate from tempdb.dbo.sysobjects where id=object_id('tempdb..#tmp')

select * into #tmp1 from sys.dm_exec_sessions s
select @dd=datediff(ms,@d,getdate())
select @dd AS [time interval, ms]

SELECT TOP 30 s.session_id, s.host_name, db_name(s.database_id) as db, s.login_name,s.login_time,s.program_name,
       s.cpu_time-isnull(t.cpu_time,0) as cpu_Diff, convert(numeric(16,2),(s.cpu_time-isnull(t.cpu_time,0))/@dd*1000) as cpu_sec,
       s.reads+s.writes-isnull(t.reads,0)-isnull(t.writes,0) as totIO_Diff, convert(numeric(16,2),(s.reads+s.writes-isnull(t.reads,0)-isnull(t.writes,0))/@dd*1000) as totIO_sec,
       s.reads-isnull(t.reads,0) as reads_Diff, convert(numeric(16,2),(s.reads-isnull(t.reads,0))/@dd*1000) as reads_sec,
       s.writes-isnull(t.writes,0) as writes_Diff, convert(numeric(16,2),(s.writes-isnull(t.writes,0))/@dd*1000) as writes_sec,
       s.logical_reads-isnull(t.logical_reads,0) as logical_reads_Diff, convert(numeric(16,2),(s.logical_reads-isnull(t.logical_reads,0))/@dd*1000) as logical_reads_sec,
       s.memory_usage, s.memory_usage-isnull(t.memory_usage,0) as [mem_D],
      s.nt_user_name,s.nt_domain
from #tmp1 s
LEFT join #tmp t on s.session_id=t.session_id
order BY
cpu_Diff desc
--totIO_Diff desc
--logical_reads_Diff desc

drop table #tmp
GO
select * into #tmp from #tmp1
drop table #tmp1

• Adicionar «SET NOCOUNT ON»
• Substituir tabelas temporárias por tabelas variáveis
• O atraso durará 1 segundo. Campos com valores médios não são obrigatórios

SET NOCOUNT ON;
declare @tmp table(session_id   smallint primary key,login_time datetime,host_name nvarchar(256),program_name nvarchar(256),login_name nvarchar(256),nt_user_name       nvarchar(256),cpu_time  int,memory_usage        int,reads       bigint,writes   bigint,logical_reads    bigint,database_id      smallint)

declare @d datetime;
select @d=GETDATE()

INSERT INTO @tmp(session_id,login_time,host_name,program_name,login_name,nt_user_name,cpu_time,memory_usage,reads,writes,logical_reads,database_id)
SELECT session_id,login_time,host_name,program_name,login_name,nt_user_name,cpu_time,memory_usage,reads,writes,logical_reads,database_id
from sys.dm_exec_sessions s;

WAITFOR DELAY '00:00:01';

declare @dd float;
select @dd=datediff(ms,@d,getdate());

SELECT 
        s.session_id, s.host_name, db_name(s.database_id) as db, s.login_name,s.login_time,s.program_name,
        s.cpu_time-isnull(t.cpu_time,0) as cpu_Diff,
        s.reads+s.writes-isnull(t.reads,0)-isnull(t.writes,0) as totIO_Diff,
        s.reads-isnull(t.reads,0) as reads_Diff,
        s.writes-isnull(t.writes,0) as writes_Diff,
        s.logical_reads-isnull(t.logical_reads,0) as logical_reads_Diff,
        s.memory_usage, s.memory_usage-isnull(t.memory_usage,0) as [mem_Diff],
        s.nt_user_name,s.nt_domain
from sys.dm_exec_sessions s
left join @tmp t on s.session_id=t.session_id

DECLARE @sql_handle varbinary(64)
DECLARE @plan_handle varbinary(64)
DECLARE @sid INT
Declare @statement_start_offset int, @statement_end_offset INT, @session_id SMALLINT

-- for the information by a particular user – indicate a session number
SELECT @sid=182

-- receive state variables for further processing
IF @sid IS NOT NULL
SELECT @sql_handle=der.sql_handle, @plan_handle=der.plan_handle, @statement_start_offset=der.statement_start_offset, @statement_end_offset=der.statement_end_offset, @session_id = der.session_id
FROM sys.dm_exec_requests der WHERE [email protected]

-- print the text of the query being executed 
DECLARE @txt VARCHAR(max)
IF @sql_handle IS NOT NULL
SELECT @txt=[text] FROM sys.dm_exec_sql_text(@sql_handle)
PRINT @txt
-- output the plan of the batch/procedure being executed
IF @plan_handle IS NOT NULL
select * from sys.dm_exec_query_plan(@plan_handle)
-- and the plan of the query being executed within the batch/procedure
IF @plan_handle IS NOT NULL
SELECT dbid, objectid, number, encrypted, CAST(query_plan AS XML) AS planxml
from sys.dm_exec_text_query_plan(@plan_handle, @statement_start_offset, @statement_end_offset)

-- plan statistics 
IF @sql_handle IS NOT NULL
SELECT * FROM sys.dm_exec_query_stats QS WHERE [email protected]_handle

-- receive a list of all current queries
SELECT LEFT((SELECT [text] FROM sys.dm_exec_sql_text(der.sql_handle)),500) AS txt
--,(select top 1 1 from sys.dm_exec_query_profiles where session_id=der.session_id) as HasLiveStat
,der.blocking_session_id as blocker, DB_NAME(der.database_id) AS База, s.login_name, *
from sys.dm_exec_requests der
left join sys.dm_exec_sessions s ON s.session_id = der.session_id
WHERE der.session_id<>@@SPID
-- AND der.session_id>50

Conclusion