Short Scripts – Setembro 2017


Muito boa tarde!!! Olá galera….

Após mais um sábado de aulas na Fatec São Roque, chegou a hora de se dedicar a comunidade de tecnologia, mais especificamente aos amantes de bancos de dados.

Como promessa é dívida e deve ser cumprida “ou melhor” paga, estou pagando a minha feita a exatos três meses no final do último post da sessão Short Scripts, hoje publicando mais um conjunto de scripts adicionados a minha biblioteca particular de códigos e exemplos nos últimos meses.

O post de hoje

Como de costume selecionei os principais scripts armazenados recentemente na minha biblioteca de códigos, que apresentam os seguintes assuntos:

  • Cálculo de Datas;
  • Comando Select;
  • Computed Column;
  • CTE Recursiva;
  • Formatação de Plano de Contas;
  • Função Format();
  • Função Parse();
  • Operador Cross Apply;
  • Operador Outer Apply;
  • Scalar User Defined Function;
  • Sequência Fibonacci; e
  • Sequência numérica de CEPs.

Chegou a hora, mãos nos teclados, a seguir apresento os códigos e exemplos selecionados para o Short Script – Setembro 2017. Vale ressaltar que todos os scripts publicados nesta sessão foram devidamente testados, 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 e melhorar cada um destes códigos.

Short Scripts

— Short Script 1  – Calculando o Ano e Mês posterior através do ano e mês  —

Declare @AnoMes int = 201712

Declare @AnoMesPosteriorDate date = DATEADD(MONTH, @AnoMes % 100, DATEADD(YEAR, @AnoMes / 100 – 1900, 0))

Declare @AnoMesPosterior int = YEAR(@AnoMesPosteriorDate) * 100 + Month(@AnoMesPosteriorDate)

Select @AnoMes, @AnoMesPosterior
Go

— Short Script 2  –  Comando Select especificando o nome da coluna e o valor através do sinal de igual —

Select ‘1/0’ = ‘Hello’, ‘2…’ = ‘teste’
Go

— Short Script 3  – Formatando a apresentação de um Plano de Contas —

DECLARE @tableDados TABLE ( Codigo VARCHAR(100) )

INSERT  INTO @tableDados
        SELECT  ‘1.0.0.0.0.00.00’
        UNION  ALL
        SELECT  ‘1.1.0.0.0.00.00’
        UNION ALL
        SELECT  ‘1.1.1.1.2.00.00’
        UNION ALL
        SELECT  ‘2.3.7.1.1.01.00’
        UNION ALL
        SELECT  ‘2.3.2.0.5.00.00’

SELECT  Codigo FROM @tableDados

SELECT TD.Codigo,  LEFT(TD.CODIGO, LEN(TD.CODIGO) – PATINDEX(‘%[1-9]%’, REVERSE(TD.CODIGO)) + 1)
FROM @tableDados AS TD
Go

— Short Script 4  –  Formatando a apresentação de dados através das funções Parse() e Format() —

Declare @Valor Varchar(10)
Set @Valor=’1,540.20′

Select @Valor As Antes, PARSE(@Valor As money Using ‘en-US’) As Depois

Select FORMAT(Cast(@Valor As Money),’C’,’pt-BR’)
Go

— Short Script 5  – Analisando as diferentes de comportamente entre os operadores Cross Apply e Outer Apply —

Declare @Tabela1 Table
(Codigo Int,
Valor Int)

Declare @Tabela2 Table
(Codigo Int,
Valor Int)

Insert Into @Tabela1 Values (1,1),(2,2),(Null, Null)
Insert Into @Tabela2 Values (1,1),(2,2),(3,3),(4,4),(5,5), (Null, Null)

— Utilizando operador Outer Apply —
Select T.Codigo,
T.Valor
From @Tabela1 T Outer Apply (Select Codigo From @Tabela2
Where Codigo = T.Codigo) As T2

— Utilizando operador Cross Apply —
Select T.Codigo,
T.Valor
From @Tabela1 T Cross Apply (Select Codigo From @Tabela2
Where Codigo = T.Codigo) As T2

— Short Script 6  – Criando a sequência Fibonacci de valores —

Create Table Sequence
(Code Int Primary Key Identity(1,1),
Number BigInt Not Null)
Go

Declare @Counter Int = 1, @String Varchar(Max)

While @Counter <=50
Begin

Insert Into Sequence (Number)
Select IsNull(Sum(Number),1) from Sequence
Where Code < @Counter -1

Set @String = (Select Concat(@String,’,’,Number) from Sequence Where Code = @Counter)

Set @Counter +=1

End

Update Sequence
Set Number = 0
Where Code = 1

Select Number ‘Number List’ From Sequence

Select ‘0’+@String As ‘Sequence Finobacci’
Go

— Short Script 7 –  Criando uma Computed Column para uso de uma Scalar User Defined Function —

— Criando a Function F_CalcularDiferencaAnos —
Create Function F_CalcularDiferencaAnos (@DataNascimento Date)
Returns Int
As
Begin
Return (Select DATEDIFF(Year, @DataNascimento, GetDate()))
End
Go

— Criando a Tabela1 para Teste —
Create Table Tabela1
(Codigo Int,
DataNascimento Date,
DiferencaComputada As (dbo.F_CalcularDiferencaAnos(DataNascimento))) — Criando uma coluna computada com a function —
Go

— Inserindo os dados —
Insert Into Tabela1 (Codigo, DataNascimento)
Values (1,’1980-04-28′), (2,’1981-01-28′)
Go

— Validando o resultado —
Select * from Tabela1
Go

— Short Script 8  –  Criando uma sequência de valores de CEPs através de uma CTE Recursiva —

Declare @Tabela table
(Codigo int, Cidade varchar(40), Inicio char(9), Fim char(9));

insert into @Tabela values (1, ‘Belo Horizonte’, ‘30000-000’, ‘35000-000’)

;With CTE_Rec as
(
Select Cidade,
            Cast(left(Fim, 5) + right(Fim, 3) as int) as Fim,
            Cast(left(Inicio, 5) + right(Inicio, 3) as int) as Cep
From @Tabela

Union all

Select Cidade, Fim, Cep + 1
from CTE_rec
where Cep < Fim
)

Select Cidade, cast(Cep / 1000 as char(5)) + ‘-‘ + right(’00’ + cast(Cep % 1000 as varchar), 3) as Cep,
(Cep / 1000) as Div,
(Cep % 1000) as Div2
from CTE_Rec
OPTION (MAXRECURSION 0)
Go

 

Ufa, conseguimos! 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, 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 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

Obrigado mais uma vez por sua visita, fico honrado com sua ilustre presença ao meu blog, desejo e espero que você possa ter encontrado algo que lhe ajudou.

Volte sempre, nos encontraremos mais uma vez na sessão Short Scripts no post do mês de dezembro.

Um forte abraço, até mais.

Short Scripts – Agosto 2015


Boa tarde, Comunidade!!!!

Tudo em paz? Mas que loucura este tempo aqui em São Roque e Sorocaba, hoje ás 6:30hrs da manhã estava 8º graus, agora ás 13hrs sensação térmica de 20º graus e subindo……

Nos últimos meses acabei deixando de publicar alguns posts relacionadas a minha sessão Short Scripts devido a correria da vida profissional e acadêmica, mas hoje vou pagar este dívida, compartilhando com vocês alguns dos meus novos short scripts.

Muitos tem me perguntado o porque acabou guardando tantos scripts ou códigos de exemplo, a resposta é bem simples e direta, sempre existirá alguém ou algo no mundo que poderá necessitar deste recurso e isso é que me mantem nesta jornada em cultivar minha biblioteca de scripts a cada dia mais atualização e completa(tarefa muito, mas muito complicada de se realizar).

Os Short Scripts apresentados hoje, estão relacionandos com os seguintes assuntos:

  • Block Process;
  • CTE;
  • Cláusula Output;
  • Comando Select;
  • Comando SET;
  • Concatenação de Valores;
  • Extended Events;
  • Índices;
  • Junção de Tabelas
  • Fatorial;
  • Funções; e
  • Tipos de Dados.

É isso galera, a seguir você vai poder encontrar os blocos de código que representam os Short Scripts, fique a vontade para copiar, compartilhar, sugerir melhorias e fazer suas críticas também.

 

— Short Script 1 –  Uitlizando cláusula Output em Delete com Inner Join + Select —

DECLARE @t TABLE

(nDex INT IDENTITY(1,1),

valu VARCHAR(9),

keey UNIQUEIDENTIFIER)

INSERT @t

VALUES (‘a’,NEWID()) , (‘b’,NEWID()),

(‘c’,NEWID()) , (‘d’,NEWID()),

(‘e’,NEWID()) , (‘f’,NEWID()),

(‘g’,NEWID()) , (‘h’,NEWID()),

(‘i’,NEWID()) , (‘j’,NEWID()),

(‘k’,NEWID())

DELETE t

OUTPUT DELETED.*

FROM @t AS t INNER JOIN (SELECT TOP 9 nDex FROM @t ORDER BY NEWID()) AS b

ON b.ndex = t.nDex

GO

 

 

— Short Script 2 – Uitilizando – CTE para separar palavras —

DECLARE @s VARCHAR(8000), @d VARCHAR(10)

SET @s = ‘separar por espaço em branco’

SET @d = ‘ ‘

;WITH split(i,j) AS

(

SELECT i = 1, j = CHARINDEX(@d, @s + @d)

UNION ALL

SELECT i = j + 1, j = CHARINDEX(@d, @s + @d, j + 1) FROM split

WHERE CHARINDEX(@d, @s + @d, j + 1) <> 0

)

SELECT SUBSTRING(@s,i,ji)

FROM split

 

— Short Script 3 – Simulando – Cenários de utilização de índices —

USE TempDB;

— Criando a Tabela Funcionário —

CREATE TABLE Funcionario

(ID int primary key,

NomeFunc varchar(200),

DataNasc date,

DataADM date);

Go

— Consulta 1 – Fazendo uso do Operador Clustered Index Scan —

SELECT * from Funcionario

Where DataADM between Convert(date, ‘1/1/2012’, 103) and Convert(date, ’31/1/2012′, 103)

Go

— Criando um novo índice chamado Ind_NC_Funcionario_DataADM —

CREATE Nonclustered Index Ind_NC_Funcionario_DataADM On Funcionario (DataADM);

Go

— Consulta 2 – Fazendo uso do Operador Clustered Index Scan —

SELECT * from Funcionario

Where DataADM between Convert(date, ‘1/1/2012’, 103) and Convert(date, ’31/1/2012′, 103)

Go

— Consulta 3 – Forçando o uso do índice IND_NC_Funcionario_DataADM, gerando Index Seek, Key Lookup e Nested Loops —

SELECT * from Funcionario with (index=Ind_NC_Funcionario_DataADM)

Where DataADM between Convert(date, ‘1/1/2012’, 103) and Convert(date, ’31/1/2012′, 103)

Go

— Consulta 4 – Utilizando realmente o índice IND_NC_Funcionario_DataADM —

SELECT ID, DataADM

From Funcionario

Where DataADM between Convert(date, ‘1/1/2012’, 103) and Convert(date, ’31/1/2012′, 103)

Go

 

— Short Script 4 – Função – Concatenar valores em ordem decrescente —

CREATE FUNCTION dbo.ConcatenaValores (@C1 int, @C2 int, @C3 int, @C4 int, @C5 int)

returns int as

begin

declare @Concatenado varchar(5);

set @Concatenado= space(0);

SELECT @Concatenado+= Cast(N as char(1))

from (values (@C1), (@C2), (@C3), (@C4), (@C5)) as Numeros(N)

order by N desc;

return Cast(@Concatenado as int);

end;

go

Select Valor= dbo.ConcatenaValores(1, 2, 3, 4, 5);

 

— Short Script 5 – Criando tipo de dados NotNull mas Null sobrepondo Not Null —

CREATE TYPE NotNullType FROM VARCHAR(10) NOT NULL;

GO

— table create

CREATE TABLE Test(TestId INT, NullTest NotNullType NULL);

GO

— insert

INSERT INTO Test(TestId) VALUES(1);

SELECT NullTest FROM Test;

 

— Short Script 6 – Comparando comportamento entre os comandos SET e Select —

DECLARE @a INT= 0;

DECLARE @b INT= 0;

 

CREATE TABLE #tmpPrice ( Value INT );

SET @a = ( SELECT Value FROM #tmpPrice);

SELECT @b = Value FROM #tmpPrice;

SELECT @a AS, @b AS b

 

— Short Script 7 – Função para Calcular Fatorial com CTE encapsulada —

CREATE FUNCTION fatorial

(

@n INT

)

RETURNS INT

AS

BEGIN

DECLARE @val INT;

WITH fat(f, n) AS

(

SELECT CAST (1 as bigint) as f, 0 as n

UNION ALL

SELECT CAST (1 as bigint) as f, 1 as n

UNION ALL

SELECT f * (n + 1), n +1

FROM fat

WHERE n < 20 AND n <> 0

)

SELECT @val = f

FROM fat

WHERE n = @n

RETURN @val

END

GO

— Testando a função

SELECT dbo.fatorial(3);

SELECT dbo.fatorial(4);

SELECT dbo.fatorial(7);

 

— Short Script 8 –  CTE – Calculando fatorial —

WITH fat(f, n) AS

(

SELECT CAST (1 as bigint) as f, 0 as n — fat de 0 é 1

UNION ALL

SELECT CAST (1 as bigint) as f, 1 as n — fat de 1 é 1

UNION ALL

SELECT f * (n + 1), n +1

FROM fat

WHERE n < 20 AND n <> 0

— 20 é o limite neste caso, pois o fatorial de 21

— não cabe em um tipo bigint. O <> 0 é para cortar a recursão

— do primeiro âncora, senão repetiria tudo, faça o teste.

)

SELECT f

FROM fat

WHERE n = 12

 

— Short Script 9 – Capturar Blocked Process com Extended Events —

CREATE EVENT SESSION [Blocked] ON SERVER

ADD EVENT sqlserver.blocked_process_report

ADD TARGET package0.event_file

(SET filename=N’C:\xel\blocked.xel’)

GO

ALTER EVENT SESSION [Blocked]

ON SERVER

STATE = start;

GO

 

–Agora precisamos ler os arquivos .XEL gerados pela sessão e extrair os dados do XML para identificarmos as causas dos blocked process:

select theNodes.event_data.value(‘(//blocked-process/process)[1]/@spid’,‘int’) as blocking_process,

theNodes.event_data.value(‘(//blocked-process/process/inputbuf)[1]’,‘varchar(max)’) as blocking_text,

theNodes.event_data.value(‘(//blocked-process/process)[1]/@clientapp’,‘varchar(100)’) as blocking_app,

theNodes.event_data.value(‘(//blocked-process/process)[1]/@loginname’,‘varchar(50)’) as blocking_login,

theNodes.event_data.value(‘(//blocked-process/process)[1]/@isolationlevel’,‘varchar(50)’) as blocking_isolation,

theNodes.event_data.value(‘(//blocked-process/process)[1]/@hostname’,‘varchar(50)’) as blocking_host,

theNodes.event_data.value(‘(//blocking-process/process)[1]/@spid’,‘int’) as blocked_process,

theNodes.event_data.value(‘(//blocking-process/process/inputbuf)[1]’,‘varchar(max)’) as blocked_text,

theNodes.event_data.value(‘(//blocking-process/process)[1]/@clientapp’,‘varchar(100)’) as blocked_app,

theNodes.event_data.value(‘(//blocking-process/process)[1]/@loginname’,‘varchar(50)’) as blocked_login,

theNodes.event_data.value(‘(//blocked-process/process)[1]/@isolationlevel’,‘varchar(50)’) as blocked_isolation,

theNodes.event_data.value(‘(//blocking-process/process)[1]/@hostname’,‘varchar(50)’) as blocked_host

from

(select convert(xml,event_data) event_data

from

sys.fn_xe_file_target_read_file(‘c:\xel\blocked*.xel’, NULL, NULL, NULL)) theData

cross apply theData.event_data.nodes(‘//event’) theNodes(event_data)

 

Chegamos ao fim de mais um Short Scripts, espero que você tenha gostado destes códigos!!!

Nos encontramos em breve.

Até a próxima…..

Trabalhando com Transações Implícitas


Pessoal, bom dia.
Ontem publiquei no meu blog um pequeno post sobre Transações Explícitas, pois bem, para dar continuidade neste assunto, hoje vou publicar mais informações sobre transações, neste caso, vou destacar como podemos utilizar e trabalhar com Transações Implícitas.
— Transações Implícitas —
• Quando uma conexão trabalha em modo de transação implícita, a instância do Mecanismo de banco de dados do SQL Server iniciará automaticamente uma nova transação depois que a transação atual for confirmada ou revertida.
• Você não faz nada para determinar o início de uma transação; apenas confirma ou reverte cada uma das transações. O modo de transação implícita gera uma cadeia contínua de transações.
• A transação permanecerá em vigor até que você emita uma instrução COMMIT ou ROLLBACK. Após a confirmação ou reversão da primeira transação, a instância do Mecanismo de Banco de Dados iniciará automaticamente uma nova transação da próxima vez que qualquer instrução for executada pela conexão.
• A instância continuará a gerar a cadeia de transações implícitas até que modo de transação implícita seja desativado. O modo de transação implícita é definido tanto pelo uso da instrução SET da Linguagem Transact-SQL como por meio de funções e métodos API de banco de dados.
Observação: O modo de transação implícita no SQL Server inicia uma transação se nenhuma já tiver sido inicializada, mas o COMMIT ou o ROLLBACK deve ser definido pelo desenvolvedor.
Para ilustrar e demonstrar como podemos trabalhar com Transações Implícitas, disponibilizo o código de exemplo a seguir:
— Alterando o Modo de Transação para Implícita —
SET IMPLICIT_TRANSACTIONS ON;
— Contando a quantidade de transações em processamento —
SELECT @@TRANCOUNT;
— Criando uma tabela para teste e contando quantas transações estão sendo processadas —
CREATE TABLE Tabela1 (Codigo Int Primary Key Identity(1,1));
SELECT @@Trancout;
Ao realizar o @@Trancount, obtemos como resultado o valor 1, isso nos indica que nossa transação foi iniciada. Agora podemos realizar um simples comando Insert sobre esta mesma trabalha, posteriormente realizarmos uma nova contagem de transações em processamento.
Insert Into Tabela1 Default Valeus
SELECT * FROM Tabela1;
Após executar este pequeno bloco de comandos, qual será o resultado que recebemos ao contar quantas transações estão em processamento ou inicializadas? Vamos então executar o @@Trancount, novamente e obter a resposta.
SELECT @@Trancount;
Podemos observar que a instrução insert foi executada, mas continuamos trabalhando com uma única transação. Neste caso, vamos encaminhar para o SQL Server a instrução Rollback, e verificarmos qual será o comportamento:
RollBack TRAN;
Vamos novamente contar nossas transações:
SELECT @@Trancount;
Ok!!! O SQL Server realizar o reversão da última transação executada antes do comando Rollback. Ao terminar confirmar se esta transação foi revertida, podemos realizar um Select sobre a Tabela1, lógicamente como a transação foi desfeita, esta tabela não deverá mais esta presente em nosso banco de Dados. Então, vamos lá:
Select * from Tabela1;
O SQL Server nos retornará uma mensagem de erro informando que a tabela não existe!!! O que nos confirma que a instrução ROLLBACK desfez por completa a criação da tabela, e posteriormente os dados, fazendo o chamado processamento reversível. Onde, cada linha processada, foi sendo desfeita, até a primeira linha executada dentro desta transação.

• Para finalizar, vamos desativar as transações implícitas:
SET IMPLICIT_TRANSACTIONS OFF;

Bom, espero que este código, possa ter demonstrado de forma simples, como as Transações Implícitas são processadas e reconhecidas pelo SQL Server.
Vale ressaltar, que após a configuração do modo de transação implícita em uma conexão, a instância do Mecanismo de Banco de Dados iniciará automaticamente a transação ao executar pela primeira vez cada uma destas instruções:
ALTER TABLE INSERT
CREATE OPEN
DELETE REVOKE
DROP SELECT
FETCH TRUNCATE TABLE
GRANT UPDATE
Agradeço a sua visita, acredito que este pequeno post poderá ser valioso em seu trabalho.
Até mais, nos encontramos nas próximas dicas.