SQL Operations Studio versão preview v0.29.3 liberado


A Microsoft disponibilizou para download no último dia 05/08 a nova versão preview do SQL Operations Studio denominada v0.29.3. A ferramenta está disponível para Windows, macOS e Linux.

O SQL Operations Studio é uma ferramenta gratuita para gerenciamento do SQL Server, Azure SQL Database e Azure SQL Data Warehouse.

De acordo com o changelog, a versão 0.29.3 traz correções de bugs, nova extensão Redgate SQL Search disponível no Extension Manager, suporte para mais idiomas e outras novidades. Quer saber mais sobre todas as novidades, melhorias e mudança, clique aqui.

A versão para Windows do SQL Operations Studio Preview v0.29.3 está disponível para download com instaladorou versão portátil (não requer instalação).

Para maiores informações sobre o SQL Operations Studio para Windows e demais plataformas de sistemas operacionais acessem link: https://docs.microsoft.com/en-us/sql/sql-operations-studio/download?view=sql-server-2017.

Fontes e Direitos Autorias: Microsoft.com – 05/08/2018 –  Docs | SQL | Tools | SQL Operations Studio.

Anúncios

Material de Apoio – Fevereiro 2018


Boa tarde.

Tudo bem? E ai esta curtindo o carnaval?

Espero que sim, eu estou aqui mais uma vez procurando colaborar e compartilhar com a comunidade técnica em mais um post dedicado exclusivamente ao meu blog. Fico feliz em encontrar você aqui fazendo mais uma visita ao meu blog, neste feriado, espero que tenha gostado do conteúdo aqui encontrado.

O post de hoje

 

Seja bem-vindo a mais um post da sessão Material de Apoio, sendo o primeiro do ano de 2018 e de número 155 no total desta sessão.

Para aqueles que já acompanham o meu blog a um certo tempo, os posts dedicados a sessão Material de Apoio, possuem o objetivo de compartilhar o conhecimento de recursos, funcionalidades e procedimentos que podemos realizar no Microsoft SQL Server.

Hoje não será diferente, estou trazendo alguns dos mais recentes scripts  catalogados nos últimos meses, que atualmente estão compondo a minha galeria de códigos formada ao longo dos anos de trabalho como DBA e atualmente como Professor de Banco de Dados.

Neste post você vai encontrar arquivos relacionados com os seguintes temas:

  • Armazenamento de arquivos;
  • Cláusula Values;
  • Comando Select;
    Comando Top;
  • Endereço de e-mails;
  • Excel;
  • Grant All Permissions;
  • Impactos na Ordenação de dados;
  • Índices;
  • Ordenação de Colunas;
  • Passwords;
  • Performance;
  • Random Character;
  • Tabelas;
  • User Defined Function; e
  • Validação de dados.

Espero que este conteúdo possa lhe ajudar em seus atividades profissionais e acadêmicas. Por questões de compatibilidade com a plataforma WordPress.com, todos os arquivos estão renomeados com a extensão .doc ao final do seu respectivo nome, sendo assim, após o download torna-se necessário remover esta extensão, mantendo somente a extensão padrão .sql.

Material de Apoio

A seguir apresento a relação de arquivos  selecionados:

1 – Material de Apoio – Fevereiro 2018 – Realizando a validação de endereços de e-mail.sql

2 – Material de Apoio – Fevereiro 2018 – Impacto na Ordenação de Colunas em Índice – Comandos DML.sql

3 – Material de Apoio – Fevereiro 2018 – Generating A Password in SQL Server with T-SQL from Random Characters.sql

4 – Material de Apoio – Fevereiro 2018 – Simple SQL Server Function to Generate Random 8 Character Password.sql

5 – Material de Apoio – Fevereiro 2018 – Comando Select em conjunto com comando Top e cláusula Values.sql

6 – Material de Apoio – Fevereiro 2018 – Atribuindo Grant All para todas as tabelas.sql

7 – Material de Apoio – Fevereiro 2018 – Como armazenar arquivos do Excel diretamente no SQL Server.sql

Fique a vontade para copiar, editar, compartilhar e distribuir estes arquivos com seus contatos, aproveite se possível deixe seu comentário, críticas, sugestões e observações.

Nota: Todos os arquivos disponibilizados foram obtidos ou criados com autorização de seus autores, sendo estes, passíveis de direitos autorais.

Links

Caso você queira acessar os posts anteriores da sessão, não perca tempo utilize os links listados abaixo:

https://pedrogalvaojunior.wordpress.com/2017/11/04/material-de-apoio-novembro-2017/

https://pedrogalvaojunior.wordpress.com/2017/08/08/material-de-apoio-agosto-2017/

https://pedrogalvaojunior.wordpress.com/2017/05/09/material-de-apoio-maio-2017/

Agradecimento

Quero agradecer imensamente a sua visita, ainda mais hoje neste feriadão prolongado de carnaval.

Não deixe de acessar os outros posts das demais sessões, o próximo post desta sessão será publicado no mês de abril, até lá continue curtindo sua vida e compartilhando suas experiência.

Até a próxima, sucesso….

SQL Operations Studio Preview v0.25.4 – Janeiro 2018


A Microsoft disponibilizou para download nesta semana o SQL Operations Studio Preview v0.25.4. A ferramenta está disponível para Windows, macOS e Linux.

Se você ainda não conhece esta nova ferramenta, saiba que o SQL Operations Studio é uma ferramenta gratuita para gerenciamento do SQL Server, Azure SQL Database e Azure SQL Data Warehouse.

A primeira versão Preview pública foi lançada no início de novembro de 2017. De acordo com o changelog, a versão 0.25.4 traz correções de bugs, corrige um problema com o tamanho do ícone no menu Iniciar, muda o campo Nome do servidor para Servidor na caixa de diálogo Conexão e mais.

Confira a lista completa de melhorias e correções disponíveis no changelog clicando aqui.

Microsoft SQL Operations Studio Preview v0.25.4

A versão para Windows do SQL Operations Studio Preview v0.25.4 está disponível para download aqui com instalador e aqui em versão portátil (não requer instalação). As versões para outras plataformas e as instruções de instalação podem ser encontradas aqui.

Para maiores informações acesse: https://docs.microsoft.com/en-us/sql/sql-operations-studio/what-is

Fontes e Direitos Autorais: Microsoft – 17/01/2018 – https://docs.microsoft.com/en-us/sql/sql-operations-studio/release-notes

Material de Apoio – Agosto 2017


Boa tarde pessoal!

Salve, salve amantes de banco de dados, Tudo bem?

Este é mais um post da sessão Material de Apoio, sendo o terceiro no decorrer de 2017 e de número 153 no total desta sessão.

Já passamos da metade de 2017, que loucura isso, como a rotina do dia a dia não nos deixa perceber o quanto o tempo na para de correr. Falando justamente da correria da nossas vida, a relação de arquivos compartilhadas neste post poderá justamente lhe ajudar a economizar muito do seu tempo.

O post de hoje

Para aqueles que já acompanham o meu blog a um certo tempo, os posts dedicados a sessão Material de Apoio, possuem o objetivo de compartilhar o conhecimento de recursos, funcionalidades e procedimentos que podemos realizar no Microsoft SQL Server.

Hoje não será diferente, estou trazendo alguns dos mais recentes scripts  catalogados nos últimos meses, que atualmente estão compondo a minha galeria de códigos formada ao longo dos anos de trabalho como DBA, e hoje principalmente como Professor de Banco de Dados.

Neste post você vai encontrar arquivos relacionados com os seguintes temas:

  • Cláusula Values;
  • Comando Distinct;
  • Comando Select;
  • Comando Top;
  • CTE Recursiva para geração de sequência de datas;
  • CTE Recursiva para geração de sequência numérica de CEPs;
  • Extended Events;
  • Função Format;
  • Função PARSE;
  • Funções de Ranking – Row_Number;
  • Monitoramento de senhas;
  • Operador Cross Apply;
  • Operador Outer Appy;
  • Recursos bloqueados;
  • SPDIDs de Conexões;
  • SPIDs de usuários; e
  • User Defined Function para cálculo de anos em colunas computadas.

Tenho a certeza que este conteúdo poderá lhe ajudar muito em seus atividades profissionais e acadêmicas, fique a vontade para copiar, editar, compartilhar e distribuir estes arquivos com seus contatos.

Material de Apoio

A seguir apresento a relação de scripts selecionados:

 

 

 

 

 

 

 

 

 

Por questões de compatibilidade com a plataforma WordPress.com, todos os arquivos estão renomeados com a extensão .doc ao final do seu respectivo nome, sendo assim, após o download torna-se necessário remover esta extensão, mantendo somente a extensão padrão .sql.

Nota: Todos os arquivos disponibilizados foram obtidos ou criados com autorização de seus autores, sendo estes, passíveis de direitos autorais.

Links

Caso você queira acessar os posts anteriores da sessão, não perca tempo utilize os links listados abaixo:

Agradecimento

Quero agradecer imensamente a sua visita, espero lhe encontrar muitas vezes no decorrer deste ano em meu blog.

Não deixe de acessar os outros posts das demais sessões, e o próximo post desta sessão será publicado no mês de Novembro, até lá continue curtindo sua vida e compartilhando suas experiência.

Um forte abraço.

SQL Server Management Studio 17.2 liberado para download


Você conhece o SQL Server Management Studio?

SQL Server Management Studio é um ambiente integrado para o gerenciamento de qualquer infra-estrutura SQL do SQL Server banco de dados SQL. SQL Server Management Studio fornece ferramentas para configurar, monitorar e administrar as instâncias de SQL. Use o SQL Server Management Studio para implantar, monitorar e atualizar os componentes de camada de dados usados por suas aplicações, bem como construir consultas e scripts.

Use o SQL Server Management Studio (SSMS) para consultar, projetar e gerenciar seus bancos de dados e data warehouses, onde quer que estejam – no computador local ou na nuvem.

SQL Server Management Studio é grátis!

Baixar o SQL Server Management Studio 17,2

Baixar o SQL Server Management Studio 17,2 atualizar pacote (atualizações 17 para 17,2)

A instalação de 17 SSMS não atualizar ou substituir as versões do SQL Server Management Studio 16.x ou anterior. SSMS 17 instalações lado a lado com as versões anteriores para que ambas as versões estão disponíveis para uso. Se um computador contiver instalações lado a lado de SQL Server Management Studio, verifique se que você começar a versão correta para suas necessidades específicas. A versão mais recente é rotulado como Microsoft SQL Server Management Studio 17e tem um novo ícone:

SSMS 17.x

Informações de versão

O número de versão: 17,2 o número de compilação para esta versão: 14.0.17177.0.

Novidades

SSMS 17,2 é a versão mais recente do SQL Server Management Studio. A geração de 17 do SQL Server Management Studio fornece suporte para quase todas as áreas de recurso no SQL Server 2008 através de SQL Server de 2017. Versão 17 também suporta SQL Analysis Service PaaS.

Versão 17,2 inclui:

    • Autenticação de vários fatores (AMF)
      • Autenticação de usuário múltiplo AD Azure para autenticação Universal com autenticação de vários fatores (UA com AMF)
      • Um novo campo de entrada de credencial do usuário foi adicionado para autenticação Universal com AMF para oferecer suporte à autenticação multi-usuário.
    • A caixa de diálogo de conexão agora suporta os seguintes métodos de 5 autenticação:
      • Autenticação do Windows
      • Autenticação do SQL Server
      • Active Directory – Universal, com o apoio do MFA
      • Active Directory – senha
      • Active Directory – integrado
    • Banco de dados de importação/exportação para assistente de DacFx agora pode usar autenticação Universal com AMF.
    • ADAL biblioteca gerenciada usada pela autenticação Azure AD Universal com AMF foi atualizada para versão 3.13.9.
    • Uma nova interface CLI suportando configuração de admin AD Azure para banco de dados SQL e SQL Data Warehouse.
    • Janela de saída possui entradas para consultas executadas durante a expansão de nós do pesquisador de objetos.
    • Habilitado o modo de exibição designer para bancos de dados SQL Azure
    • Mudaram-se as opções de script padrão para scripts de objetos de Object Explorer no SQL Server Management Studio:
      • Anteriormente, o padrão em uma instalação nova era ter o destino do script gerado a versão mais recente do SQL Server (atualmente SQL Server 2017).
      • No SSMS 17,2 foi adicionada uma nova opção: Configurações de Script Match a fonte. Quando definida como True, o script gerado destina-se a mesma versão, tipo do motor e do motor edition como servidor do objeto sendo roteirizado é de.
      • O valor de Configurações de Script Match a fonte é definido para True por padrão, para que novas instalações do SQL Server Management Studio automaticamente padrão serão sempre scripts de objetos para o mesmo destino que o servidor original.
      • Quando o valor de Configurações de Script Match a fonte é definido como False, as opções de destino script normal serão habilitadas e funcionam como fizeram anteriormente.
      • Além disso, todas as opções de script foram movidas para a sua própria seção – Opções de versão. Eles não estão mais sob Opções gerais de Scripting.
    • Adicionado suporte para nuvens nacional em “Restaurar a partir de URL”
    • QueryStoreUI relatórios agora suporta adicional métricas (número de linhas, DOP, CLR tempo etc.) do sys.query_store_runtime_stats.
    • IntelliSense agora é suportado por banco de dados SQL Azure.
    • Segurança: caixa de diálogo conexão será o padrão para não confiar em certificados de servidor e solicitando criptografia para conexões de banco de dados SQL Azure
    • Melhorias gerais em torno de suporte para o SQL Server no Linux:
      • Nó de correio do banco de dados está de volta
      • Abordadas algumas questões relacionadas com caminhos
      • Melhorias de estabilidade de Monitor de atividade
      • Caixa de diálogo Propriedades de Conexão exibe a plataforma correta
    • Relatório de servidor Dashboard desempenho agora disponível como um relatório padrão:
      • Pode se conectar ao SQL Server 2008 e versões mais recentes.
      • Subrelatório de índices ausentes usa Pontuação para ajudar a identificar índices mais útil.
      • Estatísticas de espera histórica sub relatam agora agregados esperas ser categoria. Ocioso e esperas de sono filtrados por padrão.
      • Novo histórico travas subrelatório.
    • Pesquisa de plano de execução nó permite buscar em Propriedades do plano. Facilmente procure qualquer propriedade de operador como nome da tabela. Para usar esta opção quando visualizar um plano:
      • Botão direito do mouse no plano e no menu de contexto clique na opção Localizar nó
      • Usar CTRL + F

Para obter uma lista completa de alterações, consulte SQL Server Management Studio – Changelog (SSMS).

Suporte para versões

    • Esta versão do SQL Server Management Studio funciona com todas as versões suportadas do SQL Server 2008 – 2017 de SQL Server e fornece o maior nível de suporte para trabalhar com as mais recentes características de nuvem no banco de dados SQL Azure e SQL Azure Data Warehouse.
    • Não há nenhum bloco explícito para SQL Server 2000 ou SQL Server 2005, mas alguns recursos podem não funcionar corretamente.
    • Além disso, o SSMS 17 pode ser instalado lado a lado com o SQL Server Management Studio 16.x ou SQL Server 2014 SSMS e versões anteriores.

Sistemas operacionais com suporte

Esta versão do SQL Server Management Studio suporta as seguintes plataformas de 64 bits quando usado com o mais recente disponível service pack:

    • 10 Windows (64 bits)
    • Windows 8.1 (64 bits)
    • Windows 8 (64 bits)
    • Windows 7 (SP1) (64-bit)
    • Windows Server 2016 *
    • Windows Server 2012 R2 (64 bits)
    • Windows Server 2012 (64 bits)
    • Windows Server 2008 R2 (64 bits) 

* O SSMS 17 baseia-se na shell do Visual Studio 2015 isolada, que foi lançado antes de 2016 de servidor Windows. Microsoft leva a sério o compatibilidade de aplicativo e garante que já enviados com aplicações continuam a correr sobre as versões mais recentes do Windows. Para minimizar problemas na execução do SQL Server Management Studio em 2016 de servidor Windows, certifique-se de que SSMS tem todas as últimas atualizações aplicadas. Se você tiver quaisquer problemas com o SQL Server Management Studio no Windows Server 2016, contate o suporte. A equipe de suporte determina se o problema for com o SQL Server Management Studio, Visual Studio, ou com compatibilidade do Windows. A equipe de suporte roteia a questão para a equipe apropriada para maiores investigações.

Idiomas disponíveis

Esta versão do SQL Server Management Studio pode ser instalado nos seguintes idiomas:+

SQL Server Management Studio 17,2:
chinês (República Popular da China) | Chinês (Taiwan) | Inglês (Estados Unidos) | Francês | Alemão | Italiano | Japonês | Korean | Português (Brasil) | Russas | Espanhol

SQL Server Management Studio 17,2 atualizar pacote (atualizações 17 para 17,2):
chinês (República Popular da China) | Chinês (Taiwan) | Inglês (Estados Unidos) | Francês | Alemão | Italiano | Japonês | Korean | Português (Brasil) | Russas | Espanhol

Download de versões anteriores

Versões anteriores do SQL Server Management Studio

Links adicionais

Fontes e Direitos Autorais: Microsoft – 07/08/2017 – https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms

Dica do Mês – Microsoft SQL Server – Identificando as transações que estão utilizando o Transact Log


Bom dia pessoal, tudo bem?

Véspera de feriado religioso e um dos mais importantes para boa parte da população mundial! Justamente por ser véspera de feriado hoje é um daqueles dias que qualquer profissional da área de banco de dados reza para que nada ocorra de errado próximo ás 17hrs ou mais conhecido como 5 horas da tarde.

Pensando neste tipo de necessário o post de hoje dedicado a sessão Dica do Mês tem o objetivo de ajudar você profissional que esta em apuros neste momento tentando identificar o que pode estar ocorrendo em seu ambiente ou servidor Microsoft SQL Server.

Hoje vou apresentar como você pode no Microsoft SQL Server a partir da versão 2008 R2 identificar quais transações estão realizando o acesso e demandando informações para o Transact – Log, arquivo utilizado por qualquer banco de dados existente em seu servidor ou instância SQL Server para registrar dados relacionados as transações atuais ou já processadas, sendo este mais conhecido como log de transações.

Estão vamos em frente…..


Introdução

Quando se referimos ao log de transações, temos sempre aquele boa e velha definição, “o transact log é o arquivo utilizado pelo banco de dados para registrar o que esta sendo processado por nossas transações, conhecido como o dedo duro”, na verdade o transact-log é bem mais do que isso, trata-se de um dos principais componentes de qualquer banco de dados criado no Microsoft SQL Server que nos permite através do seu uso garantir a continuidade e disponibilidade de nossos dados para diversos cenários de armazenamento e principalmente recuperação de informações.

Durante o processamento de uma ou mais querys o transact-log pode apresentar comportamentos diversas de acordo com o que esta sendo processado, mas principalmente no que se relacionado aos processos de escrita e leitura do log, onde nossas querys podem gerar processos de gravação de dados no transact-log e internamente o SQL Server pode necessitar a acessar outros dados em log para atender outras possíveis demandas.

Estes processos são conhecidos como leitura ou escrita do transact-log, situações que podem impactar aleatoriamente no processamento de nossas querys.

Pensando neste tipo de possibilidade, o post de hoje visa ilustrar e apresentar como através do Management Studio ferramenta de administração e gerenciamento do Microsoft SQL Server podemos em conjunto com as DMVs – Dynamic Management Views listadas abaixo, monitorar, catalogar e identificar quais querys ou transações estão fazendo uso do Transact-Log em possíveis processos de leitura ou escrita do log.

Dynamic Management Views

Para saber mais sobre cada DMV acesse as referências apresentadas no final do post:

  • sys.dm_tran_session_transactions;
  • sys.dm_tran_active_transactions;
  • sys.dm_tran_database_transactions;
  • sys.dm_exec_sessions;
  • sys.dm_exec_requests; e
  • sys.dm_exec_sql_text.

O Cenário

Para tentar ilustrar como podemos realizar de maneira fácil este tipo de monitoramento e identificação, vamos criar um pequeno cenário através do Bloco de Código 1, onde estaremos realizando a criação de um novo banco de dados denominado UsingTransactLog para armazenar a tabela TabelaTransactionLog.

— Bloco de Código 1 —
— Criando o banco de dados —
Create Database UsingTransactLog
Go

— Acessando o banco de dados —
Use UsingTransactLog
Go
— Criando a tabela —
Create Table TabelaTransactLog
(TransactionID Int Default Current_Transaction_ID(),
TransactionUser Varchar(100) Default System_User,
TransactionDate DateTime Default Current_TimeStamp)
Go

 

Note que nosso tabela TabelaTransactLog possui um simples estrutura composto por três colunas: TransactionID, TransactionUser e TransactionDate, sendo estes elementos básicos utilizados para catalogar o ID da transação em processamento, o usuário conectado ao banco de dados e data/hora do momento da inserção da linha.

Até aqui nada de tão importante, mas importante para podemos simular o uso do log, nosso próximo passo consiste no processamento do Bloco de Código 2, onde estaremos realizando o processamento de uma transação de inserção de 50.000 mil linhas de registros, sendo a operação de insert uma das mais diversas operações que demando processos de escrita ao transact – log, sendo assim, apresento a seguir o Bloco de Código 2:

— Bloco de Código 2 —
Insert Into TabelaTransactLog Default Values
Go 50000

Observe que não estamos passando nenhum tipo de valores para nossas colunas, na verdade estou forçando o SQL Server a utilizar a criação de valores padrões durante o processamento de cada linha de registro através da instrução Default Values (valores padrões), o que vai obrigar nossa instância e ter que gerar valores durante o tempo de processamento e posteriormente registrar em log.

Muito bem, o processamento desta massa de dados, teremos a necessidade de abrir uma nova query para justamente fazer uso do Bloco de Código 3, sendo este o principalmente elemento do nosso cenário, a query que nos permiti monitorar e identificar as transações que estão em tempo real utilizando o transact-log. Então abra uma nova query e log o Bloco de Código 3 apresentado a seguir:

— Bloco de Código 3 —
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
Go

SELECT tst.session_id As ‘Sessão’,
es.original_login_name As ‘Login’,
DB_NAME(tdt.database_id) AS ‘Database’,
DATEDIFF(SECOND, tat.transaction_begin_time, GETDATE()) AS ‘Tempo decorrido’,
tdt.database_transaction_log_record_count AS ‘Espaço Utilizado’,
CASE tat.transaction_state
WHEN 0 THEN ‘A transação não foi completamente inicializada ainda…’
    WHEN 1 THEN ‘A transação foi inicializada, mas não começou…’
    WHEN 2 THEN ‘A transação esta ativa…’
    WHEN 3 THEN ‘A transação foi encerrada…’
    WHEN 4 THEN ‘Foi iniciado o processo de confirmação sobre o transação distribuída…’
    WHEN 5 THEN ‘A transação está em estado preparação e esperando resolução…’
    WHEN 6 THEN ‘A transação foi confirmada…’
    WHEN 7 THEN ‘A transação esta sendo revertida para o estado anterior…’
    WHEN 8 THEN ‘A transação foi revertida para o estado anterior…’
   ELSE ‘Estado da transação desconhecido’
   END AS ‘Estado da Transação’,
SUBSTRING(TXT.text, ( er.statement_start_offset / 2 ) + 1, ((CASE WHEN er.statement_end_offset = -1
THEN LEN(CONVERT(NVARCHAR(MAX), TXT.text)) * 2
ELSE er.statement_end_offset
END – er.statement_start_offset ) / 2 ) + 1) AS ‘Query Atual’,
TXT.text AS ‘Query relacionada’,
es.host_name As ‘Hostname’,
   CASE tat.transaction_type
    WHEN 1 THEN ‘Transação Read/Write’
    WHEN 2 THEN ‘Transação Read-Only’
    WHEN 3 THEN ‘Transação de Sistema’
                WHEN 4 THEN ‘Transação distribuída’
            ELSE ‘Tipo de Transação desconhecido’
            END AS ‘Tipo da Transação’,
tat.transaction_begin_time AS ‘Iniciado em’
FROM sys.dm_tran_session_transactions AS tst INNER JOIN sys.dm_tran_active_transactions AS tat
ON tst.transaction_id = tat.transaction_id
INNER JOIN sys.dm_tran_database_transactions AS tdt
ON tst.transaction_id = tdt.transaction_id
INNER JOIN sys.dm_exec_sessions es
ON tst.session_id = es.session_id
INNER JOIN sys.dm_exec_requests er
ON tst.session_id = er.session_id
CROSS APPLY sys.dm_exec_sql_text(er.sql_handle) TXT
ORDER BY [Tempo decorrido] DESC
Go
Pois bem, você pode estar querendo saber um pouco mais sobre o que exatamente esta acontecendo ao processar o Bloco de Código 3, pode ficar tranquilo que a seguir vou fazer um pequeno overview sobre este bloco de código, começando pelo conjunto de colunas retornadas por ele:
  • Sessão – Apresenta o ID da sessão que esta utilizando o transact-log;
  • Login – Nome da conta de login que esta conectada ao SQL Server;
  • Database – Nome do banco de dados utilizado pela query que esta acessando o transact-log;
  • Tempo decorrido – Representa o tempo de processamento que o query esta demandando para utilizar o transact-log;
  • Log Record Count– Identifica a quantidade de registros de log gerados pela query ou transações em processamento;
  • Estado da transação – Esta coluna apresenta o estado atual da query em processamento, sendo este formado por um conjunto de valores;
  • Query Atual – Apresenta as instruções que estão sendo processadas por cada query;
  • Query Relacionada– Apresenta as instruções processadas por querys que podem estar relacionadas com as atuais querys em processamento;
  • Hostname – Apresenta o nome dos hosts utilizados por cada query em processamento;
  • Tipo de Transação – Identifica se a transação em processamento esta realizando acesso de leitura ou escrita ao log, bem como, se esta query é uma query de sistema ou distribuída; e
  • Iniciado em – Apresenta o horário de início do acesso ao transact-log por parte da query em processamento.

Agora que você já conhece um pouco sobre cada coluna que será retornada após o processamento do Bloco de Código 3, vou abordar o uso da instrução Set Transaction Isolation Level declarada no início do código, que possui a finalidade de alterar no nível de isolamento do nosso banco de dados para Read Uncommitted afim de força o SQL Server a descartar ou desconsiderar qualquer possível ocorrência de bloqueios tanto no nível de tabela e registros, mas principalmente no escopo de banco de dados.

Nota: Se você me perguntar que isso é obrigatório ser feito para conseguir identificar as querys que estão utilizando o transact-log eu vou responder NÃO, isso não é obrigatório, mas pode ser considerada uma possível solução para garantir que o Bloco de Código 3 possa ser processado e consultar as dynamic management views na busca das informações catalogadas por ela em tempo de execução.

Ufa, estamos quase lá, agora nos resta fazer a execução do mesmo e observar o retorno dos dados coletados por este bloco de código, com base, na Figura 1 apresentada abaixo:

Figura 1 – Relação de querys em execução utilizando transact-log.

Perfeito, nosso monitoramento funcionou, conseguimos coletar os dados referentes as querys que estão neste momento em processamento fazendo acesso e utilizando o transact-log criado para o banco de dados UsingTransactLog.

Isso não é sensacional, desta forma, chegamos ao final de mais um post dedicado a sessão Dica do Mês, espero que você tenha gostado.

Referências

Post anteriores

  1. https://pedrogalvaojunior.wordpress.com/2017/03/01/dica-do-mes-microsoft-sql-server-2016-sp1-novo-argumento-use-hint-disponivel-para-query-hints/
  2. https://pedrogalvaojunior.wordpress.com/2017/01/16/dica-do-mes-conhecendo-a-nova-dmf-sys-dm_exec_input_buffer-no-microsoft-sql-server-2016/

  3. https://pedrogalvaojunior.wordpress.com/2016/11/28/dica-do-mes-sql-server-2016-sp1-comando-create-or-alter/

  4. https://pedrogalvaojunior.wordpress.com/2016/10/24/dica-do-mes-sql-server-2016-obtendo-informacoes-sobre-o-cache-de-execucao-de-funcoes/

Conclusão

Administrar, gerenciar, cuidar e prover um ambiente sempre no melhor estado possível não é uma das atividades mais tranquilas e simples desempenhadas por profissionais ou administradores de banco de dados, mas também não pode ser considerada um “bicho de sete cabeças” ou uma “caixa preta” ainda mais quando este servidor de banco de dados utiliza o Microsoft SQL Server.

Neste post você pode observar que através do uso de alguns DMVs – Dynamic Management Views a Microsoft nos permite coletar, analisar e entender de forma visual e muito intuitiva como o um servidor ou instância SQL Server gerencia o que esta sendo processado por nossas aplicações, querys ou transações no que se relaciona aos seus componentes e recursos internas, algo que nos permite em diversas situações de administração ou manutenção tentar identificar o que pode estar ocorrendo, bem como, impactando em nosso ambiente.

Agradecimentos

Mais uma vez obrigado por sua visita, agradeço sua atenção, fique a vontade para enviar suas críticas, sugestões, observações e comentários.

Um forte abraço, bom feriado, espero que neste momento você não esteja no seu trabalho tentando resolver problemas do seu servidor (kkkkk).

Valeu….

Short Scripts – Março 2017


Hoje é sexta – feira, sexta – feira…

Salve, salve comunidade e amantes de bancos de dados e SQL Server, Tudo bem? Mais uma final de semana próximo após uma longa semana de muito trabalho, se eu for falar de muito trabalho, sinceramente  esta semana foi complicada, repleta de novidades e muita troca de conhecimento.

Conforme o prometido no final de 2016, estou retornando com o primeiro post da sessão Short Scripts, sessão criada a alguns anos no meu blog que lentamente esta conseguindo ajudar diversos profissionais da área de banco de dados na busca por exemplos de códigos que possam solucionar ou elucidar na resolução de um determinado problema.

O post de hoje

Como já destaquei acima, este é o primeiro post de 2017 dedicado exclusivamente a sessão Short Scripts, na relação de scritps selecionados para hoje, você vai poder encontrar códigos relacionados com os seguintes assuntos:

  • Auditoria,
  • Comando Intersect,
  • Comando OpenQuery,
  • Comando Order By,
  • Datatype Char,
  • Datatype Int,
  • DMF Sys.dm_exec_sessions,
  • DMV Sys.system_internals_partitions,
  • DMV Sys.system_internals_allocation_units,
  • Função Substring,
  • Índices,
  • Informações sobre conexão de usuário,
  • Páginas de Dados,
  • Trigger, e
  • Variáveis.

Então mãos no teclado, a seguir apresento os códigos e exemplos selecionados para o Short Script – Março 2017. Vale ressaltar que todos os scripts publicados nesta sessão são devidamente testados antes de serem publicados, mas isso não significa que você pode fazer uso dos mesmo em seu ambiente de produção, vale sim todo cuidado possível para evitar maiores problemas. Fique a vontade para compartilhar, comentar, melhorar cada um destes códigos.

Short Scripts

— Short Script 1 – Realizando Auditoria in Live —

SELECT [Spid] = session_Id
, ecid
, [Database] = DB_NAME(sp.dbid)
, [User] = nt_username
, [Status] = er.status
, [Wait] = wait_type
, [Individual Query] = SUBSTRING (qt.text,
er.statement_start_offset/2,
(CASE WHEN er.statement_end_offset = -1
THEN LEN(CONVERT(NVARCHAR(MAX), qt.text)) * 2
ELSE er.statement_end_offset END –
er.statement_start_offset)/2)
,[Parent Query] = qt.text
, Program = program_name
, Hostname
, nt_domain
, start_time
FROM sys.dm_exec_requests er
INNER JOIN sys.sysprocesses sp ON er.session_id = sp.spid
CROSS APPLY sys.dm_exec_sql_text(er.sql_handle)as qt
WHERE session_Id > 50              — Ignore system spids.
AND session_Id NOT IN (@@SPID)     — Ignore this current statement.
ORDER BY 1, 2
Go

— Short Script 2 – Utilizando comando Intersect com Datatypes Char e Int —

Create Table #A (x Char(2));
Go
Insert Into #A Values (‘1’);
Insert Into #A Values (‘6’);
Insert Into #A Values (‘2’);
Insert Into #A Values (‘3’);
Insert Into #A Values (‘5’);
Insert Into #A Values (‘5’);
Insert Into #A Values (‘6’);
Insert Into #A Values (‘9’);
Go
Create Table #B (M BigInt);
Go
Insert Into #B Values(5);
Insert Into #B Values(5);
Insert Into #B Values(6);
Insert Into #B Values(7);
Insert Into #B Values(7);
Go
— (Select #1)
SELECT x AS ‘Select #1’ FROM #A
INTERSECT SELECT M FROM #B
Go
— (Select #2)
SELECT DISTINCT(x) AS ‘Select #2’
FROM #A LEFT OUTER JOIN #B
ON #A.x = #B.M
Go
— (Select #3)
SELECT DISTINCT(x) AS ‘Select #3’
FROM #A LEFT OUTER JOIN #B
ON #A.x = #B.M
Go
— (Select #4)
SELECT DISTINCT(x) AS ‘Select #4’
FROM #A INNER JOIN #B
ON #A.x = #B.M
Go
— (Select #5)
SELECT x AS ‘Select #5’
FROM #A INNER JOIN #B
ON #A.x = #B.M
Go
— Short Script 3 – Utilizando comando OpenQuery com variáveis —
— Valores Básicos —
DECLARE @TSQL varchar(8000), @VAR char(2)
SELECT  @VAR = ‘teste’
SELECT  @TSQL = ‘SELECT * FROM OPENQUERY(MeuLinkedServer,”SELECT * FROM MinhaTabela WHERE User = ””’ + @VAR + ”””’)’
EXEC (@TSQL)
Go
— Query Complexa —
DECLARE @OPENQUERY nvarchar(4000), @TSQL nvarchar(4000), @LinkedServer nvarchar(4000)
SET @LinkedServer = ‘MyLinkedServer’
SET @OPENQUERY = ‘SELECT * FROM OPENQUERY(‘+ @LinkedServer + ‘,”’
SET @TSQL = ‘SELECT au_lname, au_id FROM pubs..authors”)’
EXEC (@OPENQUERY+@TSQL)
— Use o Sp_executesql procedimento armazenado —
DECLARE @VAR char(2)
SELECT  @VAR = ‘CA’
EXEC MyLinkedServer.master.dbo.sp_executesql
N’SELECT * FROM pubs.dbo.authors WHERE state = @state’,
N’@state char(2)’,
@VAR
Go
— Short Script 4 – Realizando order by com base na função SubString —
Declare @Tabela Table
(Codigo VarChar(15))
Insert Into @Tabela Values(‘191-XXX-003’)
Insert Into @Tabela Values(‘192-XXX-003’)
Insert Into @Tabela Values(‘193-XXX-003’)
Insert Into @Tabela Values(‘194-XXX-003’)
Insert Into @Tabela Values(‘195-XXX-003’)
Insert Into @Tabela Values(‘191-XXX-001’)
Insert Into @Tabela Values(‘192-XXX-001’)
Insert Into @Tabela Values(‘193-XXX-001’)
Insert Into @Tabela Values(‘194-XXX-001’)
Insert Into @Tabela Values(‘195-XXX-001’)
Insert Into @Tabela Values(‘191-XXX-002’)
Insert Into @Tabela Values(‘192-XXX-002’)
Insert Into @Tabela Values(‘193-XXX-002’)
Insert Into @Tabela Values(‘194-XXX-002’)
Insert Into @Tabela Values(‘195-XXX-002’)
Select * from @Tabela
Order By SubString(codigo,Len(Codigo)-2,3) Asc
Go
— Short Script 5 – Monitorando querys em execução —
SELECT
DES.SESSION_ID,
DES.CPU_TIME,
DES.READS,
DES.WRITES,
DES.LOGICAL_READS,
DES.ROW_COUNT,
DER.SESSION_ID,
DES.STATUS,
DES.HOST_NAME,
DES.PROGRAM_NAME,
DES.LOGIN_NAME,
DES.ORIGINAL_LOGIN_NAME,
DEC.CLIENT_NET_ADDRESS,
DEC.AUTH_SCHEME,
DEC.NET_TRANSPORT,
SUBSTRING(T.[TEXT], DER.[STATEMENT_START_OFFSET] / 2,
COALESCE(NULLIF(DER.[STATEMENT_END_OFFSET], – 1) / 2, 2147483647)) AS COMANDO
FROM
SYS.DM_EXEC_SESSIONS AS DES
INNER JOIN SYS.DM_EXEC_REQUESTS DER
ON DER.BLOCKING_SESSION_ID = DES.SESSION_ID
INNER JOIN SYS.DM_EXEC_CONNECTIONS DEC
ON DEC.SESSION_ID = DES.SESSION_ID
INNER JOIN SYS.DM_EXEC_REQUESTS DER2
ON DER2.SESSION_ID = DES.SESSION_ID
CROSS APPLY SYS.DM_EXEC_SQL_TEXT(DER.[SQL_HANDLE]) AS T
GO
— Short Script 6 – Identificando tabelas e suas respectivas páginas de dados —
— Exemplo 1: —
SELECT P.partition_id,
OBJECT_NAME(P.object_id) As ObjectName,
U.allocation_unit_id,
SU.First_Page,
SU.Root_Page,
SU.First_IAM_Page
From Sys.Partitions As P INNER JOIN Sys.Allocation_Units As U
ON P.hobt_id = U.container_id
Inner Join Sys.system_internals_allocation_units SU
On u.allocation_unit_id = su.allocation_unit_id
Go
— Exemplo 2: —
SELECT SIP.partition_id,
OBJECT_NAME(SIP.object_id) As ObjectName,
sip.rows,
SU.First_Page,
SU.Root_Page,
SU.First_IAM_Page
From Sys.system_internals_partitions As SIP Inner Join Sys.system_internals_allocation_units SU
On sip.partition_id = su.allocation_unit_id
Go
— Short Script 7 – Identificando índices com Escrita Excessiva —
— Quantidade de Índices com Escrita Excessiva em comparação a leitura —
SELECT  OBJECT_NAME(s.object_id),
i.name,
i.type_desc
FROM    sys.dm_db_index_usage_stats s WITH ( NOLOCK ) Inner JOIN sys.indexes i WITH (NOLOCK)
ON s.index_id = i.index_id
AND s.object_id = i.object_id
WHERE OBJECTPROPERTY(s.[object_id], ‘IsUserTable’) = 1
AND s.database_id = DB_ID()
AND s.user_updates > ( s.user_seeks + s.user_scans + s.user_lookups )
AND s.index_id > 1
Go
— Quantidade de Índices com Escrita Excessiva —
SELECT  COUNT(*)
FROM    sys.dm_db_index_usage_stats s WITH ( NOLOCK )
WHERE   OBJECTPROPERTY(s.[object_id], ‘IsUserTable’) = 1
AND s.database_id = DB_ID()
AND s.user_updates > ( s.user_seeks + s.user_scans + s.user_lookups )
AND s.index_id > 1
Go
— Short Script 8 – Identificando o espaço ocupado por conexões em uso —
SELECT A.session_id,
B.host_name, B.Login_Name ,
(user_objects_alloc_page_count + internal_objects_alloc_page_count)*1.0/128 as TotalalocadoMB,
D.Text
FROM sys.dm_db_session_space_usage A Inner JOIN sys.dm_exec_sessions B
ON A.session_id = B.session_id
Inner JOIN sys.dm_exec_connections C
ON C.session_id = B.session_id
CROSS APPLY sys.dm_exec_sql_text(C.most_recent_sql_handle) As D
WHERE A.session_id > 50
and (user_objects_alloc_page_count + internal_objects_alloc_page_count)*1.0/128 > 100 — Ocupam mais de 100 MB
ORDER BY totalalocadoMB desc
COMPUTE sum((user_objects_alloc_page_count + internal_objects_alloc_page_count)*1.0/128)
Go
— Short Script 9 – Obtendo a diferença de datas entre registro anterior e o próximo registro —
Create Table Datas
(ID Int Identity(1,1),
DataInicio Date,
DataFinal Date)
Go
Insert Into Datas Values (GETDATE(), GETDATE()+30)
Insert Into Datas Values (GETDATE()+1, GETDATE()+20)
Insert Into Datas Values (GETDATE()+2, GETDATE()+10)
Insert Into Datas Values (GETDATE(), GETDATE()+5)
Go
— Exemplo 1 —
Select I.ID, I.DataInicio, F.DataFinal,
DateDiff(D, I.DataInicio, F.DataFinal) As Intervalo
From Datas I Left Join Datas F
On I.ID = F.ID + 1

Go

— Exemplo 2 —
SELECT
[current].Id,
[current].Time CurrentValue,
[next].Time          NextValue
FROM #temp AS [current] LEFT JOIN #temp AS [next]
ON [next].Id = (SELECT MIN(Id) FROM #temp

                                 WHERE Id > [current].Id)
Go
— Short Script 10 – Criando um trigger condicional —
–Criando a Table de Novos Produtos–
Create Table NovosProdutos
(Codigo Int Identity(1,1),
Descricao VarChar(10))
–Criando a Table de Histórico Novos Produtos–
Create Table HistoricoNovosProdutos
(Codigo Int,
Descricao VarChar(10))
Go
–Inserindo valores —
Insert Into Novosprodutos Values(‘Arroz’)
Insert Into Novosprodutos Values(‘Arroz1’)
Insert Into Novosprodutos Values(‘Arroz2’)
Insert Into Novosprodutos Values(‘Arroz3’)
Go
–Criando a Trigger para controle de histórico–
Create TRIGGER T_Historico
ON NovosProdutos
for update
AS
IF (Select Descricao from Inserted) <> (Select Descricao from Deleted)
BEGIN
INSERT Into HistoricoNovosProdutos (Codigo, Descricao)
SELECT Codigo, Descricao FROM INSERTED
END
Go
–Fazendo os teste —
Update NovosProdutos
Set Descricao=’Arroz 4′
Where Codigo = 1
Go
Update NovosProdutos
Set Descricao=’Arroz1′
Where Codigo = 2
Go
Select * from NovosProdutos
Go

Muito bem, mais uma relação de short scripts acaba de ser compartilhada, mesmo sendo denominados short entre aspas “pequenos”, posso garantir que todos estes exemplos são de grande importância e apresentam um valor e conhecimento do mais alto nível.


Chegamos ao final de mais um Short Scripts, espero que este material possa lhe ajudar, ilustrando o uso de alguns recursos e funcionalidades do Microsoft SQL Server.

Acredito que você tenha observado que estes códigos são bastante conhecidos em meu blog, todos estão relacionados aos posts dedicados ao Microsoft SQL Server publicados no decorrer dos últimos anos.

Boa parte deste material é fruto de um trabalho dedicado exclusivamente a colaboração com a comunidade, visando sempre encontrar algo que possa ser a solução de um determinado problema, bem como, a demonstração de como se pode fazer uso de um determinado recurso.

Links

Caso você queira acessar os últimos posts desta sessão, não perca tempo acesse os links listados abaixo:

Agradecimento

Mais uma vez obrigado por sua visita, um forte abraço…

Nos encontramos em breve nos próximos posts desta e outras sessões do meu blog, valeu.

Short Scripts – Dezembro 2016


Buenas tardes….. Comunidade.

Hoje um dia mais que especial na minha vida e da minha família, meu pai Pedro Galvão esta completando 60 anos de vida, meu deus, como o tempo nos supreende com a sua velocidade.

Quero aproveitar este post para agradeço por este privilégio de poder conviver com uma pessoa tão integra, humilde, trabalhadora, honesta, enfim existem milhares de adjetivos para definir o que meu pai e sua excência em pessoa representa.

O post de hoje

Falando do post de hoje, este é um último post dedicado a sessão Short Scripts no ano de 2016, mas com certeza em 2017 vai estar retornando com toda a força.

Como de costume, e não poderia ser diferente, estamos no final do ano, próximos ao Natal, momento de festa e troca de presentes, lógicamente vou deixar o meu presentinho para vocês, compartilhando os últimos scripts adquiridos neste ano, relacionados aos seguintes assuntos:

  • Calendário anual de feriados;
  • Conversão de Binários para String;
  • CTE e CTE Recursiva;
  • Funções;
  • Extended Stored Procedure XP_ServiceControl;
  • MaxRecursion;
  • Union e Union All; e
  • Monitoramento de Serviços.

Short Scripts

A seguir apresento a relação de Short Scripts de hoje:

— Short Script 1 – Monitorando os serviços do SQL Server através da Extended Stored Procedure – XP_ServiceControl

Set NoCount On
CREATE TABLE #ServicesStatus
(
myid int identity(1,1),
serverName nvarchar(100) default @@serverName,
serviceName varchar(100),
Status varchar(50),
checkdatetime datetime default (getdate())
)
INSERT #ServicesStatus (Status)
EXEC xp_servicecontrol N’QUERYSTATE’,N’MSSQLServer’
update #ServicesStatus set serviceName = ‘MSSQLServer’ where myid = @@identity
INSERT #ServicesStatus (Status)
EXEC xp_servicecontrol N’QUERYSTATE’,N’SQLServerAGENT’
update #ServicesStatus set serviceName = ‘SQLServerAGENT’ where myid = @@identity
INSERT #ServicesStatus (Status)
EXEC xp_servicecontrol N’QUERYSTATE’,N’msdtc’;
update #ServicesStatus set serviceName = ‘msdtc’ where myid = @@identity;
INSERT #ServicesStatus (Status)
EXEC xp_servicecontrol N’QUERYSTATE’,N’sqlbrowser’
update #ServicesStatus set serviceName = ‘sqlbrowser’ where myid = @@identity
Select * from #ServicesStatus
— Short Script 2 – Realizando a conversão de Binário para String e String para Binário —
— Declarando uma chave legível —
DECLARE @chave  VARCHAR(MAX) =’quechavemalfeita’
— Convertendo para Binário —
DECLARE @dadosBinary VARBINARY(MAX) = CONVERT(VARBINARY(MAX),@chave,0)
SELECT @chave,@dadosBinary
— Observando as diferenças —
SELECT CONVERT(VARCHAR(MAX),@dadosBinary,0) –o Tipo 0 tranforma em texto legivelSELECT CONVERT(VARCHAR(MAX),@dadosBinary,1) — transforma o valor BINARY EM VALOR VARCHAR DEIXANDO O MESMO CONTEUDO

SELECT CONVERT(VARCHAR(MAX),@dadosBinary,2)– transforma o valor BINARY EM VALOR VARCHAR RETIRANDO O 0x NO INICIO
Go

— Short Script 3 – Criando um calendário anual para feriados —
CREATE SCHEMA Calendar
Go
CREATE FUNCTION Calendar.Computus (@Y INT)
RETURNS DATETIME
AS
BEGIN
DECLARE @a INT, @b INT, @c INT, @d INT, @e INT, @f INT, @g INT, @h INT, @i INT, @k INT, @L INT, @m INT
SET @a = @Y % 19
SET @b = @Y / 100
SET @c = @Y % 100
SET @d = @b / 4
SET @e = @b % 4
SET @f = (@b + 8) / 25
SET @g = (@b – @f + 1) / 3
SET @h = (19 * @a + @b – @d – @g + 15) % 30
SET @i = @c / 4
SET @k = @c % 4
SET @L = (32 + 2 * @e + 2 * @i – @h – @k) % 7
SET @m = (@a + 11 * @h + 22 * @L) / 451
RETURN(DATEADD(month, ((@h + @L – 7 * @m + 114) / 31)-1, cast(cast(@Y AS VARCHAR) AS Datetime)) + ((@h + @L – 7 * @m + 114) % 31))
END
GO
CREATE TABLE Calendar.[Calendar] (
[Date] datetime NOT NULL,
[Year] int NOT NULL,
[Quarter] int NOT NULL,
[Month] int NOT NULL,
[Week] int NOT NULL,
[Day] int NOT NULL,
[DayOfYear] int NOT NULL,
[Weekday] int NOT NULL,
[Fiscal_Year] int NOT NULL,
[Fiscal_Quarter] int NOT NULL,
[Fiscal_Month] int NOT NULL,
[KindOfDay] varchar(10) NOT NULL,
[Description] varchar(50) NULL,
PRIMARY KEY CLUSTERED ([Date])
)
GO
ALTER TABLE Calendar.[Calendar]
ADD CONSTRAINT [Calendar_ck] CHECK (  ([Year] > 1900)
AND ([Quarter] BETWEEN 1 AND 4)
AND ([Month] BETWEEN 1 AND 12)
AND ([Week]  BETWEEN 1 AND 53)
AND ([Day] BETWEEN 1 AND 31)
AND ([DayOfYear] BETWEEN 1 AND 366)
AND ([Weekday] BETWEEN 1 AND 7)
AND ([Fiscal_Year] > 1900)
AND ([Fiscal_Quarter] BETWEEN 1 AND 4)
AND ([Fiscal_Month] BETWEEN 1 AND 12)
AND ([KindOfDay] IN (‘HOLIDAY’, ‘SATURDAY’, ‘SUNDAY’, ‘BANKDAY’)))
GO
SET DATEFIRST 1;
WITH Dates(Date)
AS
(
SELECT cast(‘1999’ AS DateTime) Date
UNION ALL
SELECT (Date + 1) AS Date
FROM Dates
WHERE
Date < cast(‘2021’ AS DateTime) -1
),
DatesAndThursdayInWeek(Date, Thursday)
AS
(
SELECT
Date,
CASE DATEPART(weekday,Date)
WHEN 1 THEN Date + 3
WHEN 2 THEN Date + 2
WHEN 3 THEN Date + 1
WHEN 4 THEN Date
WHEN 5 THEN Date – 1
WHEN 6 THEN Date – 2
WHEN 7 THEN Date – 3
END AS Thursday
FROM Dates
),
Weeks(Week, Thursday)
AS
(
SELECT ROW_NUMBER() OVER(partition by year(Date) order by Date) Week,
Thursday
FROM DatesAndThursdayInWeek
WHERE DATEPART(weekday,Date) = 4
)
INSERT INTO Auxiliary.Calendar
SELECT
d.Date,
YEAR(d.Date) AS Year,
DATEPART(Quarter, d.Date) AS Quarter,
MONTH(d.Date) AS Month,
w.Week,
DAY(d.Date) AS Day,
DATEPART(DayOfYear, d.Date) AS DayOfYear,
DATEPART(Weekday, d.Date) AS Weekday,
YEAR(d.Date) AS Fiscal_Year,
DATEPART(Quarter, d.Date) AS Fiscal_Quarter,
MONTH(d.Date) AS Fiscal_Month,
CASE
WHEN (DATEPART(DayOfYear, d.Date) = 1)          — New Year’s Day
OR (d.Date = Auxiliary.Computus(YEAR(Date))-7)  — Palm Sunday
OR (d.Date = Auxiliary.Computus(YEAR(Date))-3)  — Maundy Thursday
OR (d.Date = Auxiliary.Computus(YEAR(Date))-2)  — Good Friday
OR (d.Date = Auxiliary.Computus(YEAR(Date)))    — Easter Sunday
OR (d.Date = Auxiliary.Computus(YEAR(Date))+39) — Ascension Day
OR (d.Date = Auxiliary.Computus(YEAR(Date))+49) — Pentecost
OR (d.Date = Auxiliary.Computus(YEAR(Date))+50) — Whitmonday
OR (MONTH(d.Date) = 5 AND DAY(d.Date) = 1)      — Labour day
OR (MONTH(d.Date) = 5 AND DAY(d.Date) = 17)     — Constitution day
OR (MONTH(d.Date) = 12 AND DAY(d.Date) = 25)    — Cristmas day
OR (MONTH(d.Date) = 12 AND DAY(d.Date) = 26)    — Boxing day
THEN ‘HOLIDAY’
WHEN DATEPART(Weekday, d.Date) = 6 THEN ‘SATURDAY’
WHEN DATEPART(Weekday, d.Date) = 7 THEN ‘SUNDAY’
ELSE ‘BANKDAY’
END KindOfDay,
CASE
WHEN (DATEPART(DayOfYear, d.Date) = 1)            THEN ‘New Year”s Day’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date))-7)  THEN ‘Palm Sunday’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date))-3)  THEN ‘Maundy Thursday’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date))-2)  THEN ‘Good Friday’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date)))    THEN ‘Easter Sunday’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date))+39) THEN ‘Ascension Day’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date))+49) THEN ‘Pentecost’
WHEN (d.Date = Auxiliary.Computus(YEAR(Date))+50) THEN ‘Whitmonday’
WHEN (MONTH(d.Date) = 5 AND DAY(d.Date) = 1)      THEN ‘Labour day’
WHEN (MONTH(d.Date) = 5 AND DAY(d.Date) = 17)     THEN ‘Constitution day’
WHEN (MONTH(d.Date) = 12 AND DAY(d.Date) = 25)    THEN ‘Cristmas day’
WHEN (MONTH(d.Date) = 12 AND DAY(d.Date) = 26)    THEN ‘Boxing day’
END Description
FROM DatesAndThursdayInWeek d
inner join Weeks w
on d.Thursday = w.Thursday
OPTION(MAXRECURSION 0)
GO
CREATE FUNCTION Auxiliary.Numbers (@AFrom INT, @ATo INT, @AIncrement INT)
RETURNS @RetNumbers TABLE
([Number] int PRIMARY KEY NOT NULL)
AS
BEGIN
WITH Numbers(n)
AS
(
SELECT @AFrom AS n
UNION ALL
SELECT (n + @AIncrement) AS n
FROM Numbers
WHERE
n < @ATo
)
INSERT @RetNumbers
SELECT n from Numbers
OPTION(MAXRECURSION 0)
RETURN;
END
GO
CREATE FUNCTION Auxiliary.iNumbers( @AFrom INT, @ATo INT, @AIncrement INT)
RETURNS TABLE
AS
RETURN( WITH Numbers(n)
AS
(SELECT @AFrom AS n
UNION ALL
SELECT (n + @AIncrement) AS n
FROM Numbers
WHERE
n < @ATo)
SELECT n AS Number from Numbers
)
GO

Links

Caso você queira acessar os últimos posts desta sessão, não perca tempo acesse os links listados abaixo:

Agradecimento

Mais uma vez obrigado por sua visita, um forte abraço…

Feliz Natal com muita saúde, paz, alegria e esperança. Que 2017 você possa brilhar ainda mais e estar junto com a comunidade.

Dica do Mês – SQL Server 2016 SP1 – Comando Create Or Alter


Muito bom dia…..

Olá pessoal, mais uma semana começando. Estou retornando com mais um post dedicado a sessão Dica do Mês, este é o post de número 11 dedicado de forma exclusiva a esta sessão.

Como você já deve ter observado desde o mês de outubro todos os posts das sessões: Dicas do Mês, Para que Serve, Short Scripts e Material de Apoio estão apresentado o mesmo layout, sendo esta uma das sugestões que os meus seguidores solicitaram, e hoje não será diferente.

A dica de hoje é bastante simples e esta totalmente relacionada a uma novidade apresentanda com o lançamento do Service Pack 1 do Microsoft SQL Server 2016.

E ai você já esta se informando sobre este novo service pack? Já realizou o download? Posso lhe dizer que diversas melhorias foram implementas, bem como, muitas mas muitas mudanças identificadas pela equipe de desenvolvimento da Microsoft foram realizadas.

Se quiser saber mais sobre este novo conjunto de atualizações e melhorias dedicadas para o Microsoft SQL Server 2016, acesses os links abaixo:

 

Voltando ao post de hoje, vamos em frente, seja bem vindo a mais um Dica do Mês!!!


Introdução

A cada nova versão do Microsoft SQL Server que a Microsoft libera ou até mesmo após um service pack ou cummulative pack disponibilizados para download, sempre fazemos aquelas perguntas:

  • O que será que melhorou?
  • Quais correções foram definitivamente corrigidas?
  • Será que alguma solicitação do Connection foram atendidas?

Enfim sempre estamos querendo descobrir o que realmente o tipo de engenheiros e desenvolvedores voltados para o SQL Server estão pensando em melhorar e corrigir no produto.

Para esta versão não foi diferente como de costume desde a versão 2012 a Microsoft esta liberando em doses homeopáticas pequenas novidades voltadas para a linguagem Transact-SQL e isso se manteve no SP1 da versão 2016 com a introdução do comando Create or Alter na mesma instrução.

Isso mesmo você pode estar se perguntando ou até mesmo pensando, mas somente agora na versão 2016 este tipo de instrução foi adicionada? A resposta é sim, somente agora pois, algo que para muitos parecia ser simples se comparado com outras ferramentas de banco de dados como Oracle ou MySQL, mas como diz aquele velho ditado: “Nem tudo o que parece é” e isso também se justifica ao Microsoft SQL Server.

Problema

Você saberia me dizer quantas vezes teve que realizar a criação de um recurso programável em um servidor ou instância SQL Server? Algo do tipo Stored Procedure, Function, Trigger ou Views?

E realizar uma ou várias alterações na estrutura de codificação de algum tipo destes recursos? Com certeza é algo bastante comum de ser realizado principalmente quando estamos criando nossos ambientes.

Por muitos anos este tipo de atividade a ser realizada na linguagem Transact-SQL deveria ser feita de forma separada. Onde devemos basicamente seguir uma regra de criar um destes tipos de objetos através do comando Create e caso tenhamos a necessidade de realizar algum tipo de alteração utilizar o comando Alter.

Então, e se agora com o lançamento do service pack 1 para o SQL Server 2016 eu te dizer que isso já pode ser realizado de uma única vez, você acredita?

Eu posso te dizer que acredito pois é verdade…..

Solução

Dizer que demorou um pouco para a equipe de desenvolvimento entender o quanto esta melhoria seria útil e importante não é verdade, ao meu ver demorou bastante, eu posso dizer isso pois trabalho com SQL Server desde a versão 7, isso já se vão 18 anos.

Mas enfim dizer do passado muitas vezes não ajuda em nada, o que vale e deve ser destacado é que agora temos esta pequena mas importante melhoria implementada no Microsoft SQL Server 2016 SP1 que nos permite ao mesmo tempo que declaramos o comando Create adicionar na mesma linha o comando Alter, mas a princípio somente para os objetos programáveis dentre eles:

  • Function;
  • Stored Procedure;
  • Triggers; e
  • Views.

O Create or Alter voltado para tabelas ainda não esta presente neste momento, e sinceramente falando acredito que vai demorar mais um pouco para ser adicionado ao produto.

Legal, mesmo assim já tivemos um grande avanço com a liberação deste nova capacidade adicionada a linguagem Transact-SQL.

Exemplos

Pois bem, seguindo em frente e dando seta para direita afim de realizar uma ultrapassagem na atual versão do SQL Server 2016 mudando para nova versão SQL Server 2016 SP1 ou se preferir versão 13.0.4001 número que identifica e evolução do kernel para o SP1.

Acelarando um pouco mais, vamos trabalhar com alguns exemplos de código que ilustram como podemos fazer uso do comando Create or Alter, para tal torna-se necessário realizar o download do SP1, caso você ainda não tenha feito, utilize o link apresentado a seguir:

Dando continuidade vamos executar o primeiro bloco de código, denominado Bloco de Código 1 apresentado abaixo:

— Bloco de Código 1 —

create-alter-procedure-1
Podemos observar que a forma de uso desta instrução é bastante simples, não necessitando de algum tipo de alteração na sintaxe tanto do comando Create como também do Alter.

Observe que realizamos a criação de um simples Stored Procedure denonimado P_Teste e após a execução do create/alter realizar a apresentação do código fonte da mesma através do system stored procedure SP_HelpText.

Um detalhe importante que vale a pena ser destacado, se relacionado a apresentação do código fonte da nosso stored procedure, note que o SQL Server não adiciona a palava chave Alter na apresentação do código, você pode pensar, mas é claro nós acabamos de criar o objeto. Eu também pensei assim, mas isso não altera caso você realize qualquer tipo de alteração no código fonte, mesmo após realizar alguma mudança na codificação do seu objeto o Database Engine não reconhece a execução do comando Alter ele mais uma vez adiciona o comando ou palavra chave create antes do nome do objeto.

Isso me faz pensar que todas as vezes que utilizarmos este tipo de implementação o Database Engine vai na verdade realizar o processo de drop físico do objeto e posteriormente a criação deste objeto.

Vamos agora trabalhar da mesma forma para criação/alteração de uma function, para isso vamos utilizar o Bloco de código 2 apresentado a seguir:

— Bloco de Código 2 —

create-alter-function-1

Legal, legal, muito bem, simples, fácil, rápido e por quê não dizer que é prático! Ao mesmo tempo que criamos um objeto programável já podemos realizar a alteração. Isso não é algo que realmente estava faltando para o SQL Server?

Acredito que sim, e fazendo um comparativo era a mesma coisa que faltava quando se referiamos a existência de tipos de dados para armazenar somente data ou hora, algo que também foi implementada após um longo tempo a partir da versão 2008 do SQL Server, ou os comandos IIF ou Choice que já existiam na linguagem C#, mas não estavam presentes no Microsoft SQL Server até a versão 2012.

Bom vou deixar para que praticar o uso deste comando na criação de Triggers e Views, com certeza não terá problemas.

Referências

Conclusão

Como de costume a cada nova versão ou atualização a Microsft esta apresentando diversas inovações e melhorias no Microsoft SQL Server.

Desta forma, em um novo service pack lançado novas melhorias ou mudanças de comportamento do produto são esperadas, algo que a partir do service pack o SQL Server 2016 também vai apresentar.

O que a partir do momento que este conjunto de melhorias for instalada em seu ambiente, será possível dentre elas fazer uso da nova sintaxe combinado dos comandos Create e Alter utilizados de maneira simultânea formando o Create or Alter.

Agradecimentos

Mais uma vez obrigado por sua visita, agradeço sua atenção, fique a vontade para enviar suas críticas, sugestões, observações e comentários.

Até mais.

Material de Apoio – Novembro 2016


Bom dia, bom dia, bom dia…..

Olá comunidade, amantes de bancos de dados e profissionais de tecnologia, estou chegando com mais um post dedicado a sessão Material de Apoio, sendo este o último desta sessão no ano de 2016.

Mesmo sendo o último desta sessão, este post é o primeiro com o nome layout que eu decidi adotar desde o final de Outubro para as novas publicações compartilhadas com você no meu blog, espero que vocês estejam gostando.

O post de hoje

Para aqueles que já acompanham o meu blog a um certo tempo, os posts dedicados a sessão Material de Apoio, possuem o objetivo de compartilhar o conhecimento de recursos, funcionalidades e procedimentos que podemos realizar no Microsoft SQL Server.

Hoje não será diferente, como diria naquele filme vou “compartilhagram” os meus scripts catalogados ao longo dos anos de trabalho como DBA e hoje principalmente como Professor de Banco de Dados.

Neste post você vai encontrar arquivos relacionados com os seguintes temas:

  • Funções de Conversão de dados;
  • Funções Temporáis e Lógicas;
  • Funções Textuais;
  • Funções de Ranking;
  • Páginação de Dados;
  • Objeto Sequence;
  • Windows Function First e Last Value;
  • Windows Function Lad e Lead;
  • Windows Function Percent_Rank e Cume_Dist; e
  • Windows Function Range e Row_Number.

Como de costume gosto de destacar que todos estes arquivos são fruto do trabalho realizado como DBA desde 2000, bem como, a pesquisa e coleta de informações através da internet, onde grande parte do conhecimento aqui compartilhado também é obtido através da  colaboração de seus autores, grande profissionais nacionais e internacionais como reconhecidos especialistas nas áreas de:

  • Modelagem de Dados;
  • Engenharia de Banco de Dados;
  • Engenharia de Softwares e Processos;
  • Banco de Dados;
  • Servidores;
  • Alta Disponibilidade;
  • Desenvolvimento; e
  • Migração e Contingência de Dados.

Obseravação: Toda e qualquer informação, código, exemplo e lógica utilizada nestes scripts foi aplicada em um determinado cenário, situação ou necessidade, o que em muitos casos talvez não se aplica a sua necessidade mas pode ser útil como material de consulta ou aprendizado.

Além disso, todos os arquivos estão renomeados tendo ao final do seu nome a extensão .doc acrescido, isto se torna necessário para garantir a compatibilidade com a plataforma do WordPress.com.

Vale ressaltar que após o seu download será necessário remover esta extensão mantendo a extensão .sql padrão para arquivos do script do SQL Server.

Material de Apoio

A seguir apresento a relação de scripts selecionados:

Exemplo – 1 – Funcoes-de-conversao-sql

Exemplo – 2 – Funcoes-tempororais-e-logicas-sql

Exemplo – 3 – Funcoes-textuais-sql

Exemplo – 4 – Utilizando-paging-sql

Exemplo – 5 – Utilizando-sequence-rank-function-sql

Exemplo – 6 – Windows-function-first-e-last-value-sql

Exemplo – 7 – Windows-function-lad-e-lead-sql

Exemplo – 8 – Windows-function-percent_rank-e-cume_dist-sql

Exemplo – 9 – Windows-function-range-e-row-sql

Bom pessoal, chegamos ao final de mais um Material de Apoio, espero que estes arquivos possam lhe ajudar e ilustrar como podemos fazer dos recursos aqui compartilhados.

Acredito que você tenha observado que estes códigos já são bastante conhecidos no meu blog, todos estão relacionados aos posts dedicados ao Microsoft SQL Server 2012, publicados anteriormente.

Links

Caso você queira acessar os posts anteriores da sessão, não perca tempo acesse os links listados abaixo:

 

Agradecimento

Mais uma vez obrigado por sua visita, um forte abraço, nos encontramos em breve.

Short Scripts – Junho 2016


Salve, salve minha gente, boa tarde!!!

Mais uma segunda – feira começando e mais uma semana se iniciando, já passamos da metade do mês de Junho tão aguardado devido ao lançamento do novo Microsoft SQL Server 2016. Caso você tenha perdido alguma informação sobre este lançamento, aproveito para compartilhar aqui um dos diversos posts publicados no meu blog sobre esta nova versão:

Voltando a falar sobre o Short Scripts, esta é uma das sessões mas visitadas do meu blog, onde o objetivo  é compartilhar os scripts existentes em minha biblioteca de códigos  dedicados exclusivamente para o SQL Server. Muitos destes scripts são resultado de pesquisas, posts publicados nos fóruns MSDN e também de respostas encontradas em outros websites de profissionais, administradores de banco de dados, professores e comunidades.

Boa parte deste material é fruto de um trabalho dedicado exclusivamente a colaboração com a comunidade, visando sempre encontrar algo que possa ser a solução de um determinado problema, bem como, a demonstração de como se pode fazer uso de um determinado recurso. Todos os scripts publicados nesta sessão são devidamente testados antes de serem publicados, mas isso não significa que você pode fazer uso dos mesmo em seu ambiente de produção, vale sim todo cuidado possível para evitar maiores problemas.

Caso você não tenha acessado os últimos posts, não perca tempo, utilize os links publicados a seguir:

https://pedrogalvaojunior.wordpress.com/2016/03/22/short-scripts-marco-2016/

https://pedrogalvaojunior.wordpress.com/2015/12/14/short-script-dezembro-2015/

https://pedrogalvaojunior.wordpress.com/2015/10/21/short-scripts-outubro-2015/

https://pedrogalvaojunior.wordpress.com/2015/08/26/short-scripts-agosto-2015/

https://pedrogalvaojunior.wordpress.com/2015/06/03/short-script-junho-2015/

Para esta relação você vai encontrar scripts relacionados aos seguintes assuntos, conceitos, recursos ou funcionalidades:

  • Acesso a banco de dados;
  • Collation;
  • Comando Exec;
  • Comando Union;
  • Comando Union All;
  • Comando Create Table;
  • Comando Alter Table;
  • Common Table Expression;
  • DBCC CheckPrimaryFile;
  • DMV sys.dm_db_index_usage_stats;
  • DMV sys.dm_os_buffer_descriptors;
  • Índices Clustered e NonClustered;
  • Option MaxRecursion;
  • Plano de Execução;
  • Querys consideradas pesadas;
  • Tabela de sistema sys.allocation_units;
  • Tabela de sistema sys.partitions;
  • Tabela de sistema sys.indexes;
  • Tabela e caracteres Unicode; e
  • Recursividade.
A seguir, apresento a relação de short scripts:

— Short Script 1 – DBCC CheckPrimaryFile Verificando se o arquivo realmente é um Primary File —
DBCC CheckPrimaryFile (‘C:\Bancos\Laboratorio.MDF’,0)
Go

 

— Short Script 2 – DBCC CheckPrimaryFile – Retornando o conjunto completo de informações associados ao Primary File que formam a estrutura do respectivo Banco de Dados —
DBCC CheckPrimaryFile (‘C:\Bancos\Laboratorio.MDF’,1)
Go

 

— Short Script 3 – DBCC CheckPrimaryFile – Retornando o nome do banco de dados, versão e collation relacionados ao Primary File —
DBCC CheckPrimaryFile (‘C:\Bancos\Laboratorio.MDF’,2)
Go

— Short Script 4 – DBCC CheckPrimaryFile – Retornando o status, fileid, name e filename associados ao Primary File que formam a estrutura do respectivo Banco de Dados —
DBCC CheckPrimaryFile (‘C:\Bancos\Laboratorio.MDF’,3)
Go
— Short Script 5 – Informações sobre acesso ao Banco de Dados —
WITH agg AS
(SELECT last_user_seek,
                  last_user_scan,
                  last_user_lookup,
last_user_update
FROM sys.dm_db_index_usage_stats
WHERE database_id = DB_ID()
)
SELECT last_read = MAX(last_read),
                 last_write = MAX(last_write)
FROM
(SELECT last_user_seek, NULL FROM agg
UNION ALL
SELECT last_user_scan, NULL FROM agg
UNION ALL
SELECT last_user_lookup, NULL FROM agg
UNION ALL
SELECT NULL, last_user_update FROM agg
) AS x (last_read, last_write);
Go

 

— Short Script 6 – Observando a mudança de comportamento após a troca de Collation —

CREATE TABLE [dbo].[Authors]
([id] [INT] NULL,
   [author] [VARCHAR](50) COLLATE SQL_Latin1_General_CP1_CI_AS NULL,
   [dateposted] [DATE] NULL) ON [PRIMARY]
GO
INSERT Authors  VALUES (1, ‘Steve’, ‘20160101’),
                                                   (2, ‘STEVE’, ‘20160201’),
                                                   (3, ‘Andy’, ‘20160301’),
                                                   (4, ‘andy’, ‘20160401’)
GO
CREATE PROCEDURE GetAuthors @author VARCHAR(50)
AS
BEGIN
SELECT a.id, a.author FROM dbo.Authors a
WHERE a.author = @author
END
GO
— If I run the procedure with a parameter of ‘Steve’, it returns two rows. I then run this code:
Exec GetAuthors ‘Steve’
Go
ALTER TABLE dbo.Authors
ALTER COLUMN author VARCHAR(50) COLLATE SQL_Latin1_General_CP437_BIN2 NULL
— If I were to execute the stored procedure, what would happen?
Exec GetAuthors ‘Steve’
Go

 

— Short Script 7 – Descobrindo o código Unicode de um caracter ou String —

— Exemplo 1 —
DECLARE @n CHAR(10);
SET @n = N’Abc’;
SELECT UNICODE(@n);
Go
— Exemplo 2 —
DECLARE @n NCHAR(10);
SET @n = N’??????????’;
SELECT UNICODE(@n);
Go

 

— Short Script 8 – Criando CTEs —

— Exemplo 1 – Criando uma simples CTE —
;With Exemplo1(Valor, Nome)
As
(
Select 1, ‘Pedro Galvão’ As Nome
)
Select * from Exemplo1
Go
— Exemplo 2 – Criando uma CTE com Union de Selects —
;With Exemplo2(Valor)
As
( Select 10
Union
Select 50
Union
Select 8
Union
Select 10 + 2
)
Select Valor = (Select Max(valor) From Exemplo2) + (Select Sum(Valor) From Exemplo2)
Go
– Short Script 9 – Criando CTEs com Recursividade —
— Exemplo – Criando uma nova CTE Recursiva concatenando dados —
;With ConcatenarNomes(nome)
AS
( SELECT Nome = CONVERT(Varchar(4000),’Pedro Antonio’)
UNION ALL
SELECT CONVERT(Varchar(4000),nome + ‘ Galvão Junior’) FROM ConcatenarNomes
WHERE LEN(nome) < 30
)
SELECT Nome FROM ConcatenarNomes
Go
— Exemplo 2 – Criando uma CTE com Union + Recursividade – Simulando uma sequência de números pares —
;With CTENumerosPares(Numero)
As
( Select 0 As Numero
Union All
Select Numero + 2 As Numero From CTENumerosPares
Where Numero < 100
)
Select Numero From CTENumerosPares
Go
— Exemplo 3 – Criando uma CTE com Union + Recursividade – Simulando uma sequência de números —
;With CTENumerosSequenciais(Numero)
AS
(   SELECT 1 AS Numero
UNION ALL
SELECT Numero + 1 AS num FROM CTENumerosSequenciais
WHERE Numero < 1000
)
SELECT * FROM CTENumerosSequenciais
OPTION (MAXRECURSION 0)
Go
— Short Script 10 – Obtendo o tamanho de índices Clustered e NonClustered —
SELECT COUNT(*) AS cached_pages_count,
COUNT(*)/128.0000 MB,
name AS BaseTableName,
IndexName,
IndexTypeDesc
FROM sys.dm_os_buffer_descriptors AS bd
INNER JOIN (SELECT s_obj.name,
s_obj.index_id,
s_obj.allocation_unit_id,
s_obj.OBJECT_ID,
i.name IndexName,
i.type_desc IndexTypeDesc
FROM
(SELECT OBJECT_NAME(OBJECT_ID) AS name,
index_id,
allocation_unit_id,
OBJECT_ID
FROM sys.allocation_units AS au INNER JOIN sys.partitions AS p
ON au.container_id = p.hobt_id
AND (au.TYPE = 1 OR au.TYPE = 3)
UNION ALL
SELECT OBJECT_NAME(OBJECT_ID) AS name,
index_id,
allocation_unit_id,
OBJECT_ID
FROM sys.allocation_units AS au INNER JOIN sys.partitions AS p
ON au.container_id = p.partition_id
AND au.TYPE = 2
) AS s_obj LEFT JOIN sys.indexes i
ON i.index_id = s_obj.index_id
AND i.OBJECT_ID = s_obj.OBJECT_ID
) AS obj ON bd.allocation_unit_id = obj.allocation_unit_id
WHERE database_id = DB_ID()
and name not like ‘sys%’
and IndexName <> ‘null’
GROUP BY name, index_id, IndexName, IndexTypeDesc
ORDER BY cached_pages_count DESC;
Muito bem, mais uma relação de short scripts acaba de ser compartilhada, mesmo sendo denominados short entre aspas “pequenos”, posso garantir que todos estes exemplos são de grande importância e apresentam um valor e conhecimento do mais alto nível.

Chegamos ao final de mais um post, fique a vontade para compartilhar este conteúdo com seus contatos e redes sociais, contribua também enviando dicas, sugestões, dúvidas, críticas, enfim participe e ajude a melhorar cada vez mais esta sessão.

Mais uma vez obrigado por sua visita, nos encontramos em breve em mais um post da sessão Short Scripts.

Uma ótima semana, abraços.

#05 – Para que serve


Hello everybody, Good Afternoon, Buenas Tardes e Buon pomeriggio!!!!

Domingão chuvoso aqui em São Roque, olha esta chuvinha já esta dando o que falar e causando alguns estranhos na região, poxa vida eu gosto de chuva mas acho que já deu na hora de parar(kkkkk), desse jeito vamos ficar todos embolorados(kkkkkk)….

Comentários e brincadeirasa parte, aproveitando este tempinho para ficar em casa se preparando para mais uma semana de muito trabalho no FIT e na FATEC, falando de FATEC já estamos chegando ao final do semestre.

Pois bem, estava pensando e decidi compartilhar com vocês na sessão Para que serve, mais dois comandos DBCCs (Database Command Console) não documentadas que recentimente acabei me deparando em uma necessidade na empresa e por incrível que pareça uma das QoD (Question of Day) no portal SQLServerCentral.com, alias eu sou suspeito a falar deste portal, sou fã de carterinha desta plataforma que emana conhecimento especializado e dedicado ao Microsoft SQL Server.

Seguindo em frente, estou me referindo a DBCC Freeze_IODBCC Thaw_IO! Por acaso você já teve a necessidade de utilizar ou já ouvi falar destes commandos?

Ficou surpreso em saber da existência destes recursos, eu também, mas tenho a certeza que você vai ficar mais supreso quando fazer uso deles, algo que realmente pode ajudar em muito a entender o comportamento do SQL Server durante o procedimento de leitura e escrita de uma transação.

Bom vamos conhecer um pouco mais sobre estas duas DBCCs não documentadas, tendo como base um tradicional ambiente de testes que normalmente utilizo para este tipo de necessidade, e como de costume, vamos vais uma vez resaltar que este tipo de procedimento deve ser realizado sempre em ambientes ou cenários de teste e desenvolvimento, pois são comandos que podem alterar o comportamento do seu servidor ou instância SQL Server, proporcionando algum tipo de perda de informação ou impactos nos seus dados. Mesmo assim acredito que vale a pena conhece-los.


Começa aqui o #05 – Para que serve, boa viagem meu amigo.

Basicamente estas duas DBCCs não documentadas estão presentes na relação de comandos não oficiais e não reconhecidos pela documentação Microsoft á algum tempo, nas pesquisas que realizei para obter mais exemplos e informações encontrei posts publicados em alguns blogs americas, russos e europeus datados de meados do ano de 2011, sendo assim deduzido que ambas as funcionalidades podem ser utilizadas de uma maneira mais “segura” nas versões 2008 R2, 2012 e 2014.

Para nosso ambiente de testes vou utilizar o Microsoft SQL Server 2014 Express SP1, também realizei testes no Microsoft SQL Server 2012 Express SP3, não observei nenhum tipo de mudança de comportamento ou processamento em relação a cada versão, tanto na sua forma de execução como também na maneira de processamento o resultado obtive foi o mesmo, sendo assim, fique a vontade para escolher a versão que você deseja utilizar. Então vamos conhecer um pouco sobre cada comando DBCC, começando pela DBCC Freeze_IO.

DBCC Freeze_IO

Como seu próprio nome segure, esta dbcc tem a função de congelar de forma temporária do processo de leitura e escrita realizada para um banco de dados, quando eu me referi a congelar estou fazendo referência a possibilidade de suspender todo processo de IO(Input – Output) para gravação de dados no banco de dados que você encontra conectado.

Quando o DBCC Freeze_IO é executado todas as atividades realizadas pelo SQL Server que envolvam processos de IO que estejam vinculadas a operação de escrita serão suspensas, não estou dizendo que estas atividades vão receber uma instrução de encerramento ou finalização, nada disso todas serão congeladas até que o comando DBCC Thaw_IO seja executado.
Uma vez que o IO é congelado, você pode tratar o banco de dados como um banco de dados somente leitura. Qualquer atividade de escrita não retornará nenhum tipo de informação, pois este banco de dados terá naquele exato momento o comportamento de um banco somente leitura. 
Você pode estar se pergunta, cara isso é muito perigo? Sim a resposta é sim, ainda mais se você fizer uso deste tipo de implementação em um ambiente que sofre uma carga enorma de leitura e escritas em pouco espaço de tempo.
DBCC Thaw_IO
Como destacado anteriormente este comando DBCC tem a finalidade de descongelar ou remover o status de suspensão nos processos de leitura e escrita marcados pela DBCC Freeze_IO. Quando executado o DBCC Thaw_IO envia para o Database Engine uma instrução que permite reverter o estado do banco de dados de somente leitura para leitura e escrita, desta forma, o SQL Server entende que a partir daquele momento o banco de dados envolvimento na execução da DBCC Freeze_IO não necessita mais ser impedido de receber novos dados, como também, esta livre para retornar qualquer tipo de informação solicitado pelo usuário e suas aplicações.
Ufa, parece ser bastante assustador fazer uso destes dois comandos, mas não é bem assim, e para mostrar que nem tudo o que parece realmente é tão perigoso, vamos fazer uma pequena prática para ilustrar o comportamento do SQL Server durante a execução de cada DBCC, para isso iremos utilizar uma pequena tabela chamada Estudantes, chegou então a hora de colocar a mão na massa ou melhor no código (kkkkk)….

Colocando a mão no código #05 – Para que serve – DBCC Freeze_IO e DBCC Thaw_IO

Para nosso ambiente de testes, vamos criar um novo banco de dados chamado DBFreeze e como destacado anteriormente será criada uma tabela chamada Estudantes que receberá alguns linhas de registros, conforme apresenta o bloco de Código 1 a seguir:
— Código 1 —

— Criando o Banco de Dados DBFreeze —

Create Database DBFreeze

Go

 

— Acessando o Banco de Dados —

Use DBFreeze

Go

 

— Criando a Tabela Estudantes —

Create Table Estudantes

(Id Int Primary Key Identity(1,1),

Nome Varchar(20) Not Null,

Classificacao TinyInt Not Null,

Curso Varchar(20) Not Null)

Go

 

— Inserindo os dados —

Insert Into Estudantes (Nome, Classificacao, Curso)

Values (‘Kim’, 99, ‘Inglês’),

(‘Thomas’, 95, ‘Inglês’),

(‘Jonh’, 92, ‘Inglês’),

(‘Mag’, 97, ‘Espanhol’),

(‘Sussy’, 90, ‘Espanhol’),

(‘Boby’, 91,‘Português’),

(‘Darth’, 89, ‘Português’)

Go 100000

 

Ótimo, nosso ambiente este criado, agora podemos fazer uma simples simulação do congelamento do banco de dados DBFreeze, para isso vamos utilizar o bloco de código 2, note que iremos executar um simples select com algumas funções de ranking na tabela Estudantes, conforme apresento abaixo:

 

— Código 2 —

Begin Transaction

Select Id, Nome, Classificacao, Curso,

ROW_NUMBER() Over (Order By Curso) As ‘Row Number’,

Rank() Over (Order By Curso) As ‘Rank’,

Dense_Rank() Over (Order By Curso) As ‘Dense Rank’,

NTile(4) Over (Order By Curso) As ‘NTile’

From Estudantes

Go

Observe que para garantir e evitar qualquer tipo de impacto em outras transações, realizei a abertura de uma nova transação para que o comando select e suas respectivas funções de ranking fossem executadas, neste momento esta transação esta sendo executado, vamos então forçar o congelamento do banco de dados, para isso abra uma nova query em seu management studio e execute o bloco de código 3:

— Código 3 —

DBCC Freeze_IO(DBFreeze)
Go

A partir deste momento nosso banco de dados DBFreeze acaba de receber a instrução de Freeze IO, onde o mesmo vai ser obrigado a interromper qualquer processo de atividades que envolvam leitura e escrita de dados, se você decidir voltar a sessão anterior, será possível observar que a mesma continua em execução mas os dados não são retornados em tela, para ter certeza de qual é o atual status desta sessão, podemos fazer uso da system stored procedure sp_lock para obter a lista de recursos e objetos atualmente em lock em nosso SQL Server.

Vamos voltar nosso banco de dados para o estado original, possibilitando que todas as leituras e escritam possam ser executadas normalmente retornando os dados solicitados, para isso utilizaremos o bloco código 4 apresentado a seguir. Para sua execução recomendo utilizar a mesma query criada para execução do código 3:

 

— Código 4 —

DBCC Thaw_IO(9)

Go

Após alguns segundos o Database Engine entende que o nosso banco de dados DBFreeze deve ter o estado de somente leitura alterado para leitura e gravação, sendo assim, o processamento da nossa primeira query será executado e encerrado normalmente, onde teremos todos os nossos dados apresentados conforme a estrutura do comando select executada no bloco de código 2, ilustrado anteriormente.

Observações:

  1. Gostaria de salientar que este tipo de funcionalidade não será muito aplicável ou utilizável em suas atividades diárias, mas poderá ser bastante útil quando você desejar de alguma forma simular uma possível “imagem ou snapshot” do seu banco de dados em um espaço de tempo ou situação; e
  2. O uso do DBCC Freeze_IO, DBCC Thaw_IO e qualquer outro comando DBCC não reconhecido ou documentado pela Microsoft e seus times de Engenheiros e desenvolvedores deve ser utilizado com muita cautela e sempre em ambientes de testes e desenvolvimento. Em algumas situações a adoção de estratégias de backup de bancos de dados ou até mesmo de um snapshot de seu ambiente virtualizado devem ser adotados como forma de garantir a recuperação dos seus recursos.

Então chegamos ao final de mais um post, estamos vivos e salvos e principalmente nosso banco de dados sobreviveu.


É isso ai galera, muito legal este post da sessão Para que serve!

Espero que você tenha gostado, que as informações compartilhadas aqui possam lhe ajudar a se tornar cada vez um profisisonal de banco de dados mais reconhecido e valorizado, algo que atualmente as empresas estão deixando muito de reconhecer o verdadeiro papel de um DBA que muitas vezes passa despercebido, mas é de grande e extremo valor para qual instituição, empresa ou corporação.

Caso deseje acessar os posts anteriores desta sessão, utilize os links postados abaixo:

Mais uma vez obrigado por sua visita, tenha uma ótima semana, nos encontramos em breve.

Até mais.

Dica do Mês – Identificando as Top 10 querys mais pesadas e seus respectivos planos de execução


Olá, boa tarde, salve, salve….. tudo bem?

Por um instante até pensei que estava ouvindo aquela conhecida música “Alô, alô realengo aquele abraço……”, mas não era isso não, estou cá com meus botões pensando como começar mais este post, sinceramente esta faltando muita criatividade para tentar fazer algo diferente, mesmo assim, vou tentando quem sabe um dia eu consigo.

Seguindo em frente, falando sério, seja bem vindo a mais um post do meu blog dedicado a sessão “Dica do Mês“, que alias vem recebendo nos últimos dias diversos feedback sobre os atuais posts, bem como, sugestões para novos, mais uma vez obrigado pela participação.

Como a voz do povo é a voz de deus, e se o povo esta pedindo temos que tentar agradar, vou publicar na dica deste mês, um script que eu particularmente uso muito, mas muito mesmo, principalmente quando eu escuto a seguinte frase:  “Nossa como o servidor de banco de dados esta lento….” ou esta outra “O sistema esta lento, muito lento, não consigo fazer nada…..” ao ouvir uma destas frases sinceramente eu fico louco e feliz ao mesmo tempo(kkkkk), louco por muitas vezes o usuário, desenvolvedor, gestor enfim a pessoa que falou não tem noção do que esta dizendo, e feliz porque vou mergulhar de cabeça no lado interno do SQL Server, como eu costumo dizer para meus alunos na lado sobrio e quente de  um servidor ou instância SQL Server, conhecido por muitos como SQL Server Internals.

Alias se conhecer e trabalhar com este lado do SQL Server, posso dizer que não é coisa de outro mundo mas requer muito calma, cuidado e conhecimento, principalmente no que se relaciona as camadas do Database Engine, Storage Engine, Buffer Cache, Query Processor, Query Optimizer, entre outros.

Antigamente poderíamos dizer que esta seria uma tarefa não muito amigável, algo que mudou muito nos últimos anos com a avanço das novas versões do SQL Server e principalmente pela possibilidade de contato com os maiores profissionais do mundo relacionados a banco de dados e SQL Server, dentre os quais destaco: Paul S. Randal, Kalen Delaney, Kimberly L. Tripp, sem se esquecer dos nossos brasileiros Fabricio Catae, Fabiano Amorin, Luciano Moreira, peço desculpas aos outros não citados, mas todos sabem do meu respeito e admiração.

Continuando nossa viagem, e se você que neste momento acabou de se deparar com esta mesma situação que eu relatei anteriormente, por algum motivo de uma hora para outro seu servidor de banco de dados ou até mesmo um determinado sistema começou a apresentar uma possível lentidão, nossa é uma situação bastante difícil e em muitos momento complexa para se decidir em pouco tempo ou tomar alguma possível ação.

É justamente nestes momentos que devemos tentar estabelecer uma linha de raciocínio, uma baseline para darmos início a nossa frente de combate, procurando definir uma forma de análise, mapeando os possíveis riscos e impactos, impactos que normalmente você já conhece e terá que conviver com ele até encontrar a possível causa raiz deste cenário que esta se apresentando.

Causa raiz que por diversas situações ou condições esta se apresentando em seu servidor ou instância SQL Server oriunda da execução de uma ou mais querys consideradas, as quais podem estar gerando um custo de processamento altíssimo para o Database Engine ou Storage Engine em seus componentes que a transforma em uma possível query candidata a participar da lista de querys pesadas.

Você pode estar estranhando isso, mas é exatamente desta forma que o SQL Server nos permite identificar e categorizar nossas querys, onde através de uma análise da complexidade do seu plano de execução, em conjunto com indicadores internos como:

  • Execution Count;
  • Logical Reads;
  • Logical Writes; e
  • Total Elapsed.

Podemos dizer que esta ou outra query esta presente na lista de querys impactantes ao processamento do nosso servidor, ou até mesmo dizer que é uma query pesada e precisa ser analisada e revista toda sua lógica e complexidade de execução.

Há dica de hoje, vai justamente nos ajudar a obter esta lista das top 10 querys consideradas com a maior carga de processamento e permitir apresentar seu plano de execução. E ai isso não é legal, vale a verdade não é uma grande dica que poderá lhe ajudar muito, particularmente falando eu acho uma dica fantástica.

Vamos então conhecer a dica deste mês apresentada abaixo:

— Dica do Mês – Top 10 querys mais pesadas e seus respectivos planos de execução —

SELECT TOP 10

SUBSTRING(qt.TEXT,(qs.statement_start_offset / 2) + 1,((CASE qs.statement_end_offset WHEN 1 THEN DATALENGTH(qt.TEXT) ELSE qs.statement_end_offset END qs.statement_start_offset) / 2) + 1) As ‘Query’,

qs.execution_count As ‘Execution Count’,

qs.total_logical_reads As ‘Total Logical Reads’,

qs.last_logical_reads As ‘Last Logical Reads’,

qs.total_logical_writes As ‘Total Logical Writes’,

qs.last_logical_writes As ‘Last Logical Writes’,

qs.total_worker_time As ‘Total Worker Time’,

qs.last_worker_time As ‘Last Worker Time’,

qs.total_elapsed_time / 1000000 As ‘Total Elapsed Time in seconds’,

qs.last_elapsed_time / 1000000 As ‘Last Elapsed Time in seconds’,

qs.last_execution_time As ‘Last Execution Time’,

qp.query_plan As ‘Query Execution Plan’

FROM sys.dm_exec_query_stats qs CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) qt

CROSS APPLY sys.dm_exec_query_plan(qs.plan_handle) qp

ORDER BY qs.total_logical_reads DESC

Dicadomesabril1
Figura 1 – Resultado da execução da dica do mês.

 


 

 

Note que os indicadores listados anteriormente são justamente colunas existentes na DMV sys.dm_exec_query_stats, sendo esta uma das principais dynamic management view introduzidas no SQL Server a partir da versão 2008, que nos permite obter todos estes dados referentes ao custo, tempo e esforço de processamento realizado pelo SQL Server. Para saber mais sobre esta DMV acesse: https://msdn.microsoft.com/en-us/library/ms189741.aspx

Para que esta mágica funcione também utilizamos uma outra importante e conhecida DMV sys.dm_exec_text, que possui a finalidade de possibilitar obter exatamente a instrução processada por cada query através do handle “identificador” contido na coluna sql_handle, como também, e o plano de execução desta mesma query com base no seu “identificador” armazenado na coluna plan_handle. Sendo esta dmv um élo de ligação entre a sys.dm_exec_query_stats e a sys.dm_exec_query_plan. Para saber mais sobre esta DMV acesse: https://msdn.microsoft.com/en-us/library/ms181929.aspx

Além disso, outro fator muito importante esta relacionado a capacidade de apresentar de forma gráfica o plano de execução pertencente a cada query, fazendo uso da DMV sys.dm_exec_query_plan, outra fundamental e excencial capacidade adicionada ao SQL Server 2008. Para saber mais sobre esta DMV acesse: https://msdn.microsoft.com/en-us/library/ms189747.aspx

 


Muito bem, chegamos ao final de mais uma dica do mês, tenho a certeza que você gostou deste post, mais uma vez agradeço sua visita, comentários, sugestões, enfim sua participação e interesse.

Caso você ainda não tenha acessado os posts anteriores desta sessão, não se preocupe utilize os links listados abaixo e bom divertimento:

Um grande, meu muito obrigado, nos encontramos no próximo mês com mais uma dica do mês.

Até lá.

Técnicas para verificação e análise de consultas consideradas lentas no Microsoft SQL Server


Olá galera, comunidade, amigos e seguidores.

Meu deus que dificuldade para encontrar um tema ou conteúdo diferente do que venho postando e trabalhando recentemente que fosse útil e ao mesmo tempo didático para vocês.

Sinceramente não sei se escolhi algo interessante, mas penso que poderá ser importante, quando vocês se depararem com o mesmo cenário que eu me deparei há alguns dias, mais precisamente entre os meses de Abril e Maio.

Estou me referindo a uma das maiores discussões que qualquer profissional de banco de dados sempre é questionado ou se depara, a chamada Lentidão para Consulta ou Manipulação de Dados.

Introdução

As chamadas lentidões no processamento de consultas ou manipulações de dados, comumente ocorrem no dia a dia das empresas. Identificar o que pode estar acontecendo é uma tarefa das mais árduas, chatas, demoradas e estressantes para qualquer Profissional de Suporte, Infraestrutura e principalmente Banco de Dados.

Este é o tipo da situação que o usuário se considera ao mesmo tempo o mais prejudicado e conhecer do assunto, pois ele sempre tem aquela frase: “O Sistema esta lento, o Sistema esta travando, alguém precisa fazer algo.”

É justamente este algo que aparentemente é simples, que se torna o maior dos monstros, pois as variáveis que podem existir são inúmeras, o que possibilitam ocorrer das maneiras mais incerteza e diversas possíveis.

Sempre digo para os meus alunos: “Consultas com execução lenta podem ser causadas por problemas de desempenho relacionados à sua rede ou ao computador onde o SQL Server está sendo executado. Como também, podem ser causadas por problemas com seu projeto de banco de dados físico ou lógico”.

Quando uma consulta ou atualização leva muito mais tempo do que o esperado, faça as seguintes perguntas a si mesmo, que remetem aos motivos para a execução lenta das consultas relacionadas na seção anterior:

Então, como podemos tentar realmente identificar se nosso Ambiente, Sistema, Servidor ou Banco de Dados esta lento? Para responder esta pergunta, eu pesquisei durante muito tempo e nunca encontrei nada tão específico, padronizado ou até mesmo correto, pois cada cenário é um cenário, cada projeto é um projeto, cada situação é uma situação totalmente diferente da outra.

Com base, em grandes especialistas e estudiosos, cheguei à seguinte conclusão, procurar identificar a causa origem da lentidão, pode ser dividida em quatro camadas, onde a camada que representa o Sistema Gerenciador de Banco de Dados ou Sistema Banco de Dados pode ser considerada a última camada em uma Arquitetura Computacional.

Neste caso, uma Arquitetura Computacional básica pode ser estrutura da seguinte forma:

  1. Camada de Rede;
  2. Camada de Hardware;
  3. Camada do Sistema Operacional; e
  4. Camada de Software / Aplicativos e Sistema Gerenciador de Banco de Dados.


 

Pensando fora da caixa

Muito bem, dentro deste cenário complexo, repleto de considerações, ponderações, estudos, variações e com certeza muitas dúvidas, eu defini ao longo dos anos como uma pequena metodologia de trabalho, que consiste inicialmente utilizar um simples questionário, composto por algumas perguntas que podem ajudar a encontrar o ponto chave da geração dos problemas ou causas da possível lentidão.

Este questionário esta organizado em duas partes, com objetivo responder questões ou identificar dúvidas, para inúmeros motivos comuns em qualquer ambiente, dentre eles destaco:

  • Consumo e configuração de Hardware:
  • Estrutura e Topologia de Rede;
  • Estrutura física do banco de dados;
  • Armazenamento centralizado ou particionamento de dados ou banco de dados;
  • Recursos como Índices, Estatísticas, Triggers e Visões Indexadas.
  • Conjuntos de Disco(s) Rígidos;
  • Memória;
  • Processador (ES); e
  • Placa(s) de Rede.

 


 

Questionário – Parte 1 – Infraestrutura.

  1. Qual é o consumo de processador e memória demandados por seu servidor no momento ou período de lentidão?

 

  1. A lentidão esta ocorrendo em consultas ou funcionalidades específicas da sua aplicação ou ambientes?
  2. Existem algum tipo de conector ou middleware utilizado para realizar a conexão entre a aplicação e o Banco de Dados?
  3. Qual são a versão e edição do seu Sistema Operacional?
  4. Qual são a versão e edição do seu Microsoft SQL Server?
  5. Todas as atualizações de Sistema Operacional e SQL Server forma aplicadas?
  6. Qual é a configuração ou arranjo de disco que você esta utilizando?
  7. A lentidão que esta sendo apresentada é generalizada ou ocorre somente nos recursos que fazem uso do Banco de Dados?
  8. Você realizou ou esta realizando algum tipo de monitoramento através da Ferramenta Monitor de Sistema do Windows?
  9. Alguma alteração nas configurações do seu Servidor, Rede, Banco de Dados ou aplicação foi realizada?
  10. Suas aplicações encerram suas conexões após o processamento?


 

Questionário – Parte 2 – Microsoft SQL Server e Banco de Dados

  1. Você realizou ou esta realizando algum tipo de monitoramento através das Ferramenta Microsoft SQL Server Profiler?
    1. Caso o problema de lentidão esteja relacionado a consultas, qual consulta ou conjunto de consultas que podem estar envolvidas ou relacionadas com esta situação?
    2. Esta lentidão ou suposta lentidão esta ocorrendo a partir de qual data ou situação?
    3. Ao encontrar um possível consulta com execução lenta, como podemos fazer sua análise?
    4. Existe algum procedimento de atualização de Estatísticas de Dados e Tabelas de Sistema?
    • Recomenda-se utilizar estas ou alguma outra ferramenta para procurar identificar e obter informações sobre estas possíveis consultas lentas. A partir do Microsoft SQL Server 2005 foram introduzidos alguns relatórios padrões que podem ajudar nesta análise.
    • A partir do Microsoft SQL Server 2008, utilize as exibições de gerenciamento dinâmico sys. dm_exec_query_stats e sys.dm_exec_requests para encontrar consultas similares que podem estar consumindo muitos recursos.
    • Depois de identificar a consulta lenta, você pode analisar o desempenho da consulta mais profundamente criando o chamado Plano de Execução, que pode ser um texto, XML ou representação gráfica do plano de execução de consulta que o otimizador de consulta gera.
  • O otimizador de consultas existe no SQL Server utiliza estatísticas para criar planos de consulta que melhoram o desempenho. Na grande a maioria das consultas, o otimizador já gera as estatísticas necessárias para um plano de consulta de alta qualidade, existem casos, que você poderá ou deverá criar estatísticas adicionais visando obter uma melhora no processamento destas consultas.
  1. As opções AUTO_CREATE_STATISTICS e AUTO_UPDATE_STATISTICS estão habilitadas?
  • Auto_create_statistics: Ao fazer uso desta opção de estatísticas em todo o banco de dados. Podemos nos deparar com situações em que os planos de consulta poderão ter uma qualidade inferior e o seu desempenho pode vir a ser prejudicado, por outro lado em alguns casos, você pode melhorar os planos de consulta criando estatísticas adicionais com a instrução CREATE STATISTICS. Essas estatísticas adicionais podem capturar correlações estatísticas que o otimizador de consulta não conseguiu identificar ao criar estatísticas para seus índices ou colunas.
  • Auto_update_statistics: Em alguns casos, ao deixar esta opção desativada, podemos melhorar o plano de consulta e, portanto, o desempenho das consultas atualizando estatísticas mais freqüentemente do que quando a opção AUTO_UPDATE_STATISTICS está ativada. Neste ponto, eu costumo por padrão para uso dos comando Update_statistics ou Sp_updatestats para realizar o processo de atualização das Estatísticas de Tabelas de Sistema existente no banco de dados.
  1. Você já verificou se sua consulta ou conjunto de consultas utiliza algum tipo de recurso ou funcionalidade como, por exemplo: variáveis locais, tabelas temporárias, cursores, linked-server, etc.
  2. Existe alguma análise de fragmentação de dados? Todos os índices existentes em seu banco de dados estão sendo utilizados? Qual é o valor definido para o fill factor de seus índices?
  3. Processos como reorganização ou reconstrução de índices foram realizados?

 

  1. Existe algum tipo de particionamento de dados, tanto no nível de banco de dados, como também, em relação a discos rígidos, arquivos ou grupos de arquivos?

 

  1. O banco de dados TEMPDB está armazenado na mesma unidade de disco dos demais bancos de dados?

 

  1. Existe algum monitoramento ou análise do Buffer Cache que as transações requisitam para o SQL Server?

 

Pois bem, estas e muitas outras questões podem ser utilizadas, tenho em mente que as informações reunidas por questionário poderá ajudar a determinar como uma consulta é executada, identificando todos os elementos físicos e lógicos que podem estar envolvidos, desde otimizador de consulta existe no SQL Server, como em paralelo os elementos de Hardware e Software que podem estar sendo processados.

 

Conclusão

 

Usando essas informações, você poderá determinar se podem ser feitas melhorias de desempenho, após algum tipo de alteração em sua Infraestrutura, Aplicação ou Banco de Dados, o que poderá obrigar o processo de mudanças em suas consultas, índices nas tabelas ou talvez modificando o projeto de banco de dados.

 

Mais uma vez obrigado por sua visita, espero que você tenha gostado deste post, com certeza totalmente diferente do que venho compartilhamento nos últimos meses.

 

Encontramos-nos em breve.

 

Até mais.

Março – 2013 – Material de Apoio


Salve Galera, boa tarde.

Semana corrida com diversas atividades e hoje mais um dia de eventos!!!

Muito bem, estou de volta para disponibilizar mais uma relação de Scripts e Códigos de Exemplo, como de costume, dentre eles destaco:

  • Criação de Type Table em conjunto com Functions e Arrays;
  • Criação de Estrutura XML baseada em Functions;
  • Função FormatMessage e Stored Procedure SP_AddMessage;
  • Identificando escrita excessiva em índices;
  • Objetos e Páginas de Dados;
  • OpenQuery e Transações Remotas; e
  • Utilizando Função DateDiff Formatada, entre outros.

No total esta relação apresenta 13 Scripts, fiquem a vontade para distribuir e compartilhar com seus contatos, amigos, etc.

Segue abaixo a relação de Scripts e Códigos de Exemplo:

Espero que este material possa ser útil em suas atividades, acadêmicas e profissionais, todos os exemplos estão compatíveis como Microsoft SQL Server 2008, Microsoft Server 2008 R2 e Microsoft SQL Server 2012.

Alguns podem ser utilizados também no Microsoft SQL Server 2000 e 2005.

Agradeço a sua visita, nos encontramos em breve.

Até mais.