segunda-feira, 25 de abril de 2016

Scripts: Clear Cache (buffers) SQL SERVER

O cache de memória é uma área reservada pelo SQL Server, com o objetivo de acelerar a execução de Stored Procedures, ou transações que podem estar sendo processadas com uma maior frequência de requisições; através dos comandos  DBCC (Database Console Commands) podemos realizar os seguintes procedimentos:

DBCC DropCleanBuffers   (Eliminar as páginas de buffer limpas)

DBCC FreeProcChace      (Eliminar todas as entradas do CACHE de Procedures)
DBCC FreeSystemCache  (Limpar as entradas de Cache não utilizadas)

syntax:
DBCC DROPCLEANBUFFERS           
GO
DBCC FREEPROCCACHE                  
GO
DBCC FREESYSTEMCACHE ('ALL')    
GO

returns:


DBCC execution completed. If DBCC printed error messages, contact your system administrator.

quarta-feira, 20 de abril de 2016

Scripts: Informações do tamanho das Bases SQL

O script a seguir tem como unica finalidade de retornar o tamanho atual das bases (levando em conta apenas os arquivos de dados). Uma ótima utilidade para o script é persistir essas informações em um repositório pra depois fazer outras análises (Capacity Plan, por exemplo), por isso adicionalmente, existe um campo de data na saída da variável. Segue exemplo:

DECLARE 
@DBSize AS TABLE
( DBName varchar(100), DBStatus varchar(20), Recovery_Model varchar(100), Database_Path varchar(500), File_Size float, Space_Used float, Free_Space float, File_Size_String varchar(100) NULL, Space_Used_String varchar(100) NULL, Free_Space_String varchar(100) NULL, Total_Space_MB varchar(100) NULL )
INSERT INTO 
@DBSize
(Dbname, DBStatus, Recovery_Model, Database_Path,file_Size,Space_Used, Free_Space)
EXEC SP_MSFOREACHDB 'USE [?]; SELECT DB_NAME() AS DbName, CONVERT(varchar(20),DatabasePropertyEx(''?'',''Status'')) , CONVERT(varchar(20),DatabasePropertyEx(''?'',''Recovery'')), physical_name, size*8.00 AS File_Size, FILEPROPERTY(name, ''SpaceUsed'')*8.00 as Space_Used, size*8.00 - FILEPROPERTY(name, ''SpaceUsed'')*8.00 AS Free_Space FROM 
sys.database_files where type=0'
UPDATE @DBSize SET File_Size_String = CASE WHEN (File_Size/1024) > 1023 THEN Convert(Varchar(50),Convert(decimal(20,2),(File_Size/1024/1024.00))) + ' GB' ELSE Convert(Varchar(50),Convert(decimal(20,2),(File_Size/1024.00))) + ' MB' END, Space_Used_String = CASE WHEN (Space_Used/1024) > 1023 THEN Convert(Varchar(50),Convert(decimal(20,2),(Space_Used/1024/1024.00))) + ' GB' ELSE Convert(Varchar(50),Convert(decimal(20,2),(Space_Used/1024.00))) + ' MB' END, Free_Space_String = CASE WHEN (Free_Space/1024) > 1023 THEN Convert(Varchar(50),Convert(decimal(20,2),(Free_Space/1024/1024.00))) + ' GB' ELSE Convert(Varchar(50),Convert(decimal(20,2),(Free_Space/1024.00))) + ' MB' END,
Total_Space_MB = Convert(decimal(20,2),(File_Size/1024.00)) SELECT DBName as [Database], DBStatus, Recovery_Model, File_Size_String, Space_Used_String, Free_Space_String, Total_Space_MB, Database_Path, GETDATE() AS Data FROM @DBSize ORDER BY File_Size DESC, Space_Used DESC, Free_Space DESC

Scripts: Ultimo restart do servidor SQL SERVER

Em alguns bate papos do café, foi questionado se era possível determinar a quanto tempo um servidor SQL SERVER estava operando. Se existiam algumas funções nativas, para detalhar data e hora do ultimo restart. Funções atualmente não, não que eu as conheça, mas é possivel determinar há quanto a instancia do service esta UP, podemos gerir as seguintes informações:

USE [master]
-- Verifica quando o TEMPDB foi criado (durante o startup do serviço)
DECLARE @starttime datetime
SET @starttime = (SELECT crdate FROM sysdatabases WHERE name = 'tempdb' )

--Hora atual
DECLARE @currenttime datetime
SET @currenttime = GETDATE()

-- Criação das variaveis para dias, horas e minutos
DECLARE @difference_dd int
DECLARE @difference_hh int
DECLARE @difference_mi int

--Determina quantos minutos passaram desde a criação do TEMPDB 
SET @difference_mi = (SELECT DATEDIFF(mi, @starttime, @currenttime))

--Determina quantos dias passaram desde a criação do TEMPDB
SET @difference_dd = (@difference_mi/60/24)

--Subtrai os dias dos minutos
SET @difference_mi = @difference_mi - (@difference_dd*60)*24

--Determina o número de horas que passaram desde a criação do TEMPDB
SET @difference_hh = (@difference_mi/60)

-- Subtrai as horas dos minutos
SET @difference_mi = @difference_mi - (@difference_hh*60)

--Mensagem 
PRINT 'Time since SQL Server service was started: ' +

CONVERT(varchar, @difference_dd) + ' days 'CONVERT(varchar, @difference_hh) + ' hours ' + CONVERT(varchar, @difference_mi) + ' minutes.'


Depois é só jogar tudo pra uma procedure e executar direto;
Fica mais pratico ;)

Resultado:

Scripts: Usuários Conectados LOCKS - SQL SERVER

Em certos momentos cotidianos pode ser que nos deparamos com situações aonde é necessário descobrir qual usuários estão conectados ao SQL Server ("leia-se travando o acesso a base e atrasando todo mundo") contudo muitas vezes não basta somente descobrir qual login de usuário esta conectado ou qual operação esta consumindo mais recurso dos servidores, pois diversas aplicações geralmente compartilham de um mesmo usuário para se conectar, sendo até um próximo assunto para discutindo futuramente em tópicos de segurança de dados, onde cenário ideal é cada aplicação possuir um usuário próprio tão somente para uso exclusivo da aplicação.
Para maiores detalhes do consumo podemos estar executando o script a seguir,
que lhe retorna uma grande gama de informações mais detalhadas:
SELECT 

t1.session_id,
     CONVERT(varchar(10), t1.status)  AS status,
     CONVERT(varchar(15), t1.command) AS command,
     CONVERT(varchar(10), t2.state)   AS worker_state,

w_suspended =
CASE t2.wait_started_ms_ticks
  WHEN 0 THEN 0
  ELSE t3.ms_ticks - t2.wait_started_ms_ticks
END,
w_runnable =
CASE t2.wait_resumed_ms_ticks
  WHEN 0 THEN 0
  ELSE t3.ms_ticks - t2.wait_resumed_ms_ticks
END
FROM
sys.dm_exec_requests AS t1 INNER JOIN sys.dm_os_workers AS t2
ON t2.task_address = t1.task_address

CROSS JOIN sys.dm_os_sys_info AS t3
WHERE 
t1.scheduler_id IS NOT NULL
ORDER BY 
t1.session_id DESC;
GO



Resultado:


segunda-feira, 18 de abril de 2016

Funções: String_Split() - SQL Server 2016

Microsoft SQL Server 2016 e String_Split(), agora ficou fácil dividir uma string.

Fala galera, boa tarde, segunda – feira de impeachment, eita dia complicado, começo de semana é tenso, pois saber que mais um final de semana se passou . Seguindo a onda de informações, anúncios, posts, entre outras formas de divulgação sobre o Microsoft SQL Server 2016, hoje vou destacar mais um pouco sobre esta nova versão e destacar mais uma das suas novidades, estou me referindo a nova Table Value Function String_Split(). Algo que realmente era muito pedido pelos desenvolvedores e que a Microsoft demorou um pouco para reconhecer a sua importância, mas na versão 2016 ela está presente e será muito útil.
String_Split()
Pode-se dizer que é uma daquelas funções desejadas por todos os profissionais que trabalham com desenvolvimento e necessitam em algum momento realizar o chamado split de uma string. Se você não sabe ou conhece este termo, split pode ser entendido como fatiar, dividir, cortar, quebrar em pedaços.Fazendo uma analogia, a string_split() vai fazer exatamente isso com uma string, transformando a mesma em pequenas outras strings (substrings ou partes de uma string).
Funcionalidade ou capacidade considerado por muitos como algo realmente complexo se der feito por um SGBD – Sistema Gerenciador de Banco de Dados, ainda mais para o SQL Server se pensarmos que até a versão 2014 tínhamos a necessidade de customizar este tipo de necessidade. Mas que para nossa alegria a Microsoft introduziu este recurso que provavelmente e o que tudo indica a mesma vai fazer parte da versão final do SQL Server 2016.
Como utilizar a String_Split()
Criada para ser utilizada de maneira rápida e simples, a String_split é composta pode dois parâmetros string compatíveis com os tipos de dados: (nvarcharvarcharnchar ou char) para a string que desejamos supostamente dividir em conjunto com o caractere reconhecido como “divisor” ou “separador”, que também deve ser informado em um tipo de string compatível com os tipos de dados: nvarchar(1)varchar(1)nchar(1) ou char(1)).
Outra característica muito interessante desta função é a maneira que os dados são apresentados e retornados para usuário, onde podemos ter o retorno do split da string em uma coluna com diversas linhas representando os fragmentos “pedaços” ou “partes” da string, como também um valor caractere no tipo de dados nchar ou nvarchar de acordo com o tipo de dado utilizado, respeitando o tamanho do dado identificado no momento da fragmentação da string. Caso não seja reconhecido o tipo de dados original da string, o resultado da sua fragmentação será retornado com o tipo de dados varchar.
Exemplos
— Exemplo 1 – Separando de forma simples uma string –
SELECT * FROM STRING_SPLIT(‘Gustavo,Damatto,SQL,Server’,’,’)
GO
 Result:
Gustavo
Damatto
SQL 
Server
 — Exemplo 2 – Fazendo uso de variáveis como parâmetros de entrada de valores –
DECLARE @string VARCHAR(100) = ‘Microsoft,SQL Server,2016,RC0′,
@separador CHAR(1) =’,’
SELECT * FROM STRING_SPLIT(@string,@separador)
GO
 Result:
Microsoft
SQL Server
2016
RC0

— Exemplo 3 – Armazenando o resultado da divisão de uma string em uma nova tabela –
DECLARE @string VARCHAR(100) = ‘Microsoft,SQL Server,2016,RC0′,
@separador CHAR(1) =’,’
SELECT * INTO #SplitTable FROM STRING_SPLIT(@string,@separador)
GO
 — Visualizando a estrutura da tabela —
sp_columns #SplitTable
GO
 — Consultando os dados da tabela —
select * from #SplitTable
GO
 * Após executar a system stored procedure sp_columns podemos notar que o tamanho e tipo de dados da coluna value criada através do select…into foi definido como varachar() sendo este o tipo de dados padrão utilizado pela String_Split() para garantir compatibilidade no armazenamento e apresentação de dados oriundos de uma outra tabela. 
— Exemplo 4 – Apresentando a mensagem quando o separador de string for definido com mais de um caracter —
DECLARE @string VARCHAR(100) = ‘gudamatto#@gmail#@com’,
@separador CHAR(2) ='#@'
SELECT * FROM STRING_SPLIT(@string,@separador)
GO
Como pode ser observado o Microsoft SQL Server 2016 vai lançar e apresentar uma mensagem de erro com o código 214 informando que a quantidade de caracteres ou melhor dizendo que o tamanho utilizado para o parâmetro separador foi definido acima de um caractere, sendo que, este parâmetro só identifica e reconhece um único caractere.
Resul
Msg 214, Level 16, State 11, Line 3
Procedure expects parameter ‘separator’ of type ‘nchar(1)/nvarchar(1)’.

— Exemplo 5 – Apresentando o comportamento da String_Split() quando um parâmetro apresenta valor nulo –
SELECT * FROM STRING_SPLIT(‘scriptsemsql,blogspot,com’,NULL)
GO
 Para este exemplo 5 o comportamento do SQL Server 2016 é exatamente o mesmo do exemplo 4, onde será apresentada uma mensagem de erro informando que o tamanho informado no parâmetro separado, foi definido acima de um caractere.
Result
Msg 214, Level 16, State 11, Line 3
Procedure expects parameter ‘separator’ of type ‘nchar(1)/nvarchar(1)’.

 — Exemplo 6 – Apresentando o comportamento da String_Split() quando o carácter do final da string é o mesmo utilizado como separador –
SELECT * FROM STRING_SPLIT(‘Conhecendo,SQL Server,2016,’,’,’)
GO
 Este é um cenário bem interessante e pode ocorrer a qualquer momento, nesta situação o SQL Server 2016 vai trabalhar da mesma forma que os outros exemplos, analisando e identificando a string e posteriormente fazendo a fragmentação com base no caractere separador, mesmo que este seja um caractere utilizado no final da string.
Note que que criada 4 linhas de registro sendo que a última não apresentará valores por será reconhecida e tratada como uma linha nula ou em branco.
Result
Conhecendo
SQL Server
2016
 Legal, legal, acredito que agora ficou ainda mais fácil de entender e compreender como a String_Split() é fácil de ser utilizado e principalmente a maneira que os dados são apresentando e retornado para usuário. Desta forma, vou encerrar mais este artigo por aqui, quero também aproveitar para disponibilizar abaixo uma relação de links sobre os principais posts referentes ao SQL Server 2016 que estou desde 2015 publicando.
* alguns dos exemplos apresentados aqui foram elaborados e executados no banco de dados de exemplo AdventureWorks2016 CTP3, caso venha tenha interesse em realizar o download desta sample database, utilize o link: https://www.microsoft.com/en-us/download/details.aspx?id=49502
Acesse também da documentação oficial Microsoft sobre a String_Split(): https://msdn.microsoft.com/en-us/library/mt684588.aspx

Conclusão
Como você pode observar uma das mais esperadas funcionalidades foi adicionada ao SQL Server, a capacidade de fragmentar, dividir, fatiar uma string em pequenas partes ou substrings. Recurso mais que necessário e importante para qualquer desenvolver ou profissional de banco de dados que necessita analisar um texto “string” e através de um caractere denominado separador delimitar como pode ser gerada fragmentos deste texto.
A cada novo build liberado pela Microsoft podemos observar e notar o grande trabalho e esforço que esta sendo feito para transformar o Microsoft SQL Server 2016 na maior e principal versão do produto desde o grande salto dado em 2005 com o lançamento naquele momento da versão 2005.
Funções similares ao String_Split() estão sendo cada vez mais disponibilidades e adicionadas ao produto como forma de fazer com que o SQL Server se torne uma plataforma única de desenvolvimento, administração, armazenamento e gestão de banco de dados, isso representa uma grande evolução e atenção das equipes de desenvolvimento e engenheiros do produto em atender e satisfazer a comunidade técnica que se dedica a estudar e conhecer cada vez mais o SQL Server.
Acredito que os exemplos apresentados aqui conseguir mostrar a simplicidade de se trabalhar com esta nova funcionalidade, ilustrando sua simplicidade no uso e forma de obter os resultados.
Mais uma vez agradeço a sua atenção, seu interesse em visitar o meu blog, espero encontra-lo em outras oportunidades. Deixe seus comentários, críticas e sugestões, até a próxima abraços.

sexta-feira, 8 de abril de 2016

Funções De Classificaçao - SQL SERVER

Classificação com as funções ROW_NUMBER, RANK, DENSE_RANK, NTILE


Já a partir do SQL Server 2005 possuímos quatro(4) funções de ranking/classificação. Estas funções fazem com que problemas “clássicos” de SQL fiquem muito mais fáceis de se solucionarem.

As funções de Ranking retornam um valor de classificação para cada linha em uma partição. Todas as funções de Ranking são do tipo não-determinísticas, ou seja, as funções não-determinísticas podem retornar resultados diferentes cada vez que são chamadas com um conjunto específico de valores de entrada, mesmo se o estado do banco de dados que elas acessam permaneça o mesmo.

ROW_NUMBER () OVER ([ <partition_by_clause>] <order_by_clause>)
Retorna o número seqüencial de uma linha dentro de uma partição de um conjunto de resultados, começando em 1 para a primeira linha em cada partição.

RANK () OVER ([ <partition_by_clause>] <order_by_clause>) ([RANK () OVER <partition_by_clause>] <order_by_clause>)
Retorna (Rank) a posição de cada linha dentro da partição de um conjunto de resultados.

DENSE_RANK () OVER ([ <partition_by_clause>] <order_by_clause>) ([DENSE_RANK () OVER <partition_by_clause>] <order_by_clause>)
Retorna (Rank) a posição de linhas dentro da partição de um conjunto de resultados, sem quaisquer lacunas no ranking.

NTILE (integer_expression) OVER ([ <partition_by_clause>] <order_by_clause>) NTILE integer_expression () OVER ([ <partition_by_clause>] <order_by_clause>)
Distribui as linhas de uma partição ordenada em um determinado número de grupos.
Todas as definições acima e a sintaxe foram retiradas BOL.

O código abaixo explica o uso de todas as funções quatro juntos em uma consulta;
Exemplo pratico da query e seu resultado:


quinta-feira, 7 de abril de 2016

SGBD's Mais usados do mercado ..

Fala pessoal recentemente alguém deu um retweeter de um raking mensal que compartilha a popularidade dos SGBDs existentes no mercado.
Mercado este que se mantem estável e podemos considerar cada posicionamento ja bem definidos a um bom tempo. Uma grande surpresa foi notar o banco MySQL como segundo colocado e o DB2 aparecer somente em sexto colocado. Firebird e Azure SQL Database apesar de apresentar grande especulações no mercado nem posicionam as Dez primeiras posições do ranking, surgem lá em vigésimo sétimo (27), e vigésimo oitavo(28) respectivamente. 

atualizado de Abril de 2016:

RankDBMSDatabase ModelScore
Apr
2016
Mar
2016
Apr
2015
Apr
2016
Mar
2016
Apr
2015
1.1.1.Oracle            Relational DBMS1467.53-4.48+21.40
2.2.2.MySQL            Relational DBMS1370.11+22.39+85.53
3.3.3.SQL Server      Relational DBMS1135.05-1.45-14.07
4.4.4.MongoDB        Document store 312.44+7.11+33.85
5.5.5.PostgreSQL      Relational DBMS303.73+4.10+35.41
6.6.6.DB2               Relational DBMS184.08-3.85-13.56
7.7.7.Microsoft AccesRelational DBMS131.97-3.06-10.22
8.8.8.Cassandra       Wide column      129.67-0.66+24.78
9.9. 10.Redis              Key-value store  111.24+5.02+16.69
10.10. 9.SQLite            Relational DBMS 107.96+2.19+5.67

27.27. 26.Firebird                  Relational 20.10-0.78-1.24
28. 30.28.Microsoft Azure SQL Relational 19.24-0.23+3.54

Link para o site oficial: DB-ENGINES
método do cálculo se baseia em:
  • Número de menções em WebSites (exemplo nosso blog!).
  • Buscas no Google e Bing.
  • Discussões técnicas sobre o SGBD em sites e Fórums.
  • Número de vagas oferecidas onde o SGBD é mencionado.
  • Número de profissionais que mencionam o SGBD em seus profiles.

achamos interessante compartilhar essas noções do mercado com vocês $$
Grande abraços sucesso.