Boa Noite Pessoal,

Tenho percebido que recentemente tenho recebido alguns emails de colegas pelos quais trabalham com C# e ASP.NET, infelizmente alguns deles estão se dando com simples problemas nos quais podem ser resolvidos utilizando funções simples, todavia sabemos que o SQL Server possuí inúmeras funções das quais podem ser bastantes úteis em nosso dia a dia.

Sabemos que a cláusula TOP é frequentemente mais utilizada juntamente com a instrução SELECT, todavia uma boa dica é: definir uma variável e atribuir um valor(int) á ela ou até mesmo uma porcentagem(%) pelo qual seria o valor que estariamos atribuindo a cláusula(TOP) na instrução SELECT.

Syntax :

[
     TOP (expression) [PERCENT]
     [ WITH TIES ]
]

-- TOP - Frequentemente mais utilizado (Porcentagem)(Subquery)

SELECT TOP

(

    SELECT COUNT(ListPrice) / 7

    FROM Production.Product

 ) PERCENT

    Name,

    ModifiedDate,

    Color,

    ListPrice

FROM Production.Product

ORDER BY

      Name,

      ModifiedDate,

      Color,

      ListPrice

DDL Triggers:

Desde a versão do SQL Server 2005 os programadores T-SQL tem á habilidade de criar gatilhos DDL que por sua vez tem o objetivo de disparar quando os eventos DDL’s dos triggers ocorrem no banco de dados ou no servidor.

Os triggers DDL são úteis para evitar que ocorra mudanças inesperadas no banco de dados, mudanças essas que se referem a auditoria ou algo relacionado á isto.
Uma vez falado dos triggers DDL, podemos também utilizar o evento EVENTDATA o qual é responsável por retornar informações de tempo, conexão, nome do objeto, tipo do evento entre outros sendo assim disparados pelo triggers.

IF OBJECT_ID ('dbo.DDlActionLog') IS NOT NULL

   DROP TABLE dbo.DDlActionLog;

GO

CREATE TABLE dbo.DdlActionLog

(

EntryNum int IDENTITY(1, 1) NOT NULL PRIMARY KEY,

EventType nvarchar(200) NOT NULL,

PostTime datetime NOT NULL,

Spid int NOT NULL,

LoginName sysname NOT NULL,

UserName sysname NOT NULL,

ServerName sysname NOT NULL,

SchemaName sysname NOT NULL,

DatabaseName sysname NOT NULL,

ObjectName sysname NOT NULL,

ObjectType sysname NOT NULL,

CommandText nvarchar(max) NOT NULL

);

GO

IF OBJECT_ID ('AuditCreateTable ') IS NOT NULL

   DROP TRIGGER AuditCreateTable;
GO

CREATE TRIGGER AuditCreateTable

ON DATABASE

FOR CREATE_TABLE

AS

BEGIN

DECLARE @event_data xml;

SET @event_data = EVENTDATA();

INSERT INTO dbo.DdlActionLog

(

EventType,

PostTime,

Spid,

LoginName,

UserName,

ServerName,

SchemaName,

DatabaseName,

ObjectName,

ObjectType,

CommandText

)

SELECT

EventNode.value(N'EventType[1]', N'nvarchar(200)'),

EventNode.value(N'PostTime[1]', N'datetime'),

EventNode.value(N'SPID[1]', N'int'),

EventNode.value(N'LoginName[1]', N'sysname'),

EventNode.value(N'UserName[1]', N'sysname'),

EventNode.value(N'ServerName[1]', N'sysname'),

EventNode.value(N'SchemaName[1]', N'sysname'),

EventNode.value(N'DatabaseName[1]', N'sysname'),

EventNode.value(N'ObjectName[1]', N'sysname'),

EventNode.value(N'ObjectType[1]', N'sysname'),

EventNode.value(N'(TSQLCommand/CommandText)[1]', 'nvarchar(max)')

FROM @event_data.nodes('/EVENT_INSTANCE') EventTable(EventNode);

END;

GO

Após termos criado a tabela para coletar as operações iremos nesse momento criar uma tabela de exemplo:

CREATE TABLE dbo.TableTeste (i int);

GO

-- Percebam que vai nos trazer a tabela conforme criamos acima

SELECT * FROM DdlActionLog

Boa Tarde Pessoal,

Tenho percebido que ultimamente a Microsoft tem investido bastante no SQL Server, sendo assim alguns usuários que trabalham com essa tecnologia geralmente tem percebido que obtivemos grandes melhorias sendo elas diferenciadas por vastas categorias, os gatilhos no SQL Server não é uma novidade, todavia é um recurso fantástico o qual nos permite termos uma regra de negócio em nosso banco de dados mais confiável e inteligente.

O SQL Server 2008 implementou três tipos de gatilhos conhecidos como por exemplo:

·          Data Manipulation Language (DML)  o qual é responsavel para disparar operações insert,update,delete em tabelas;

·         Data Definition Language (DDL) o qual é responsavel por disparar operações CREATE,ALTER e DROP;

·         Logon triggers o qual é responsavel por disparar operações de eventos de LOGON.

Olá, Boa noite

Antes de chegar ao assunto conforme tem no título gostaria de lembrar á vocês que temos alguns outros novos tipos de dados conhecidos como datetime2, date, time, datetimeoffset o qual é utilizado para se trabalhar com tempo, temos no SQL Server 2008 um novo tipo de dado conhecido como hierarchyid o qual representa uma estrutura de uma hierarquia robusta através de uma tabela, sendo assim cada linha dessa tabela representa um nó da árvore.
O tipo de dados hierarchyid nos permite trabalharmos com a extensão TRANSACT-SQL (T-SQL) podendo assim invocar métodos arbitrários como, por exemplo: insert, modify e delete em algum desses pontos utilizar esses métodos pode ser muito eficiente.
Podemos também utilizar o tipo de dados hierarchyid em aplicações que envolva SQL Common Language Runtime (CLR), sendo assim em aplicações .NET é conhecido como SqlHierarchyID que está dentro do namespace Microsoft.SqlServer.Types. Este namespace está contido dentro do assembly Microsoft.SqlServer.Types.dll o qual pode ser encontrado dentro da janela a qual refere-se ao botão Add References , nesse caso o hierarchyid representa um valor armazenado como binário (binary) o qual pode suportar virtualmente ilimitados números de nó.

Definindo uma estratégia de índices.

Ao trabalharmos com o tipo de dados hierarchyid seria útil implementarmos uma estratégia de índice para assim termos um bom desempenho em nossa aplicação diariamente, temos então duas estratégias para se trabalhar com índices.
O Primeiro índice pode ser conhecido como 'depth-first', aonde as linhas de um subconjunto são armazenadas umas próximas das outras. Por exemplo: podemos ter um Administrador de Redes ou Administrador de Banco de dados e através desses dois Administradores podemos criar um nó ráiz para através dele ter um subconjunto.

 

Exemplo:

CREATE TYPE Cliente AS TABLE
(idCliente    int,
 nomeCliente  nvarchar(50),
 idadeCliente int)

DECLARE @Customer as Cliente

INSERT INTO @Customer VALUES (1,'Lucas Souza',18) SELECT idCliente, nomeCliente, idadeCliente from @Customer

Á instrução acima é um tipo de tabela definido pelo usuário com o nome Cliente á qual possui três colunas. Após termos executado essa instrução podemos agora declarar e popular através de um T-SQL, Após isto o SQL Server irá armazenar esses valores na tabela temporária (tempdb) e assim podemos até utilizar esse tipo de tabela definido pelo usuário para passar espontaneamente até por procedimentos armazenados.

 


A imagem acima localiza as tabelas definidas pelo usuário.

Neste último exemplo criei um procedimento armazenado o qual irá ter Uma TVP,Através da tabela definida pelo usuário iremos popular uma tabela baseada na TVP:

CREATE TABLE tblCliente
(
      idCliente int ,
      nomeCliente nvarchar(50),
      idadeCliente int
)

CREATE TYPE typeCliente AS TABLE
(
      idCliente int,
      nomeCliente nvarchar(50),
      idadeCliente int )
 
CREATE PROC InsertProc
(@VarProc as typeCliente READONLY)
AS

INSERT tblCliente (idCliente,nomeCliente,idadeCliente)
SELECT idCliente,nomeCliente,idadeCliente
         FROM @VarProc

DECLARE @Var1 as TypeCliente

INSERT INTO @Var1 (idCliente,nomeCliente,idadeCliente) values (1,'lucas',15)

EXEC InsertProc @Var1
SELECT * FROM @Var1

Limitações:

Algumas limitações termos que ter em mente, uma delas seria: as TVPS são apenas read-only, depois que á iniciamos devemos popular e passar-las, não se pode usar para retornar dados. Neste caso a cláusula READONLY precisa ser aplicada para TVPs em procedimentos armazenados ou então não irá ser compilado, semelhantemente ao comando OUTPUT a qual não pode ser usado desta forma, lembrando também que não se pode atualizar, inserir ou deletar a coluna com os valores das linhas das TVPs.


[]’s


Lucas Souza
http://www.souzalucas.spaces.live.com

SQL SERVER 2008: MERGE

A Microsoft recentemente introduziu uma nova instrução t-sql conhecida como MERGE (DML), a qual é fácil de utilizar e também pode nos trazer um bom desempenho a se comparar com grandes instruções que envolva operações T-SQL. Esse comando pode substituir inúmeras instruções do tipo INSERT, UPDATE, DELETE entre outras  se resumindo em apenas uma instrução. Podemos aplicar a cláusula MERGE em uma tabela, view ou uma consulta, irei citar abaixo algumas das situações nas quais é mais utilizada. 

* Sincronização de dados;
* Validação de dados;
* Transformação de dados (DTS - extract, transform, load);
* Quando executamos instruções do tipo INSERT, UPDATE ou DELETE da tabela fonte para a  tabela alvo.

A instrução MERGE é composta por algumas instruções tais como: MERGE, USING, ON, WHEN MATCHED, WHEN NOT MATCHED, WHENT NOT MATCHED BY SOURCE.

MERGE: A cláusula MERGE é responsável por especificar a tabela ou uma view a qual é o alvo das operações utilizadas pelas instruções INSERT, UPDATE, DELETE.

USING: A cláusula USING é responsável por especificar a tabela ou a view a qual estará sendo a fonte dos dados de origem para.

ON: A cláusula ON é responsável por especificar as condições que serão determinadas quando a tabela fonte e a tabela alvo forem especificadas na instrução MERGE.

WHEN MATCHED:
Esta cláusula é utilizada para trabalhar com Instruções executadas UPDATE ou DELETE que está entre a tabela fonte e a tabela alvo, quando executamos a cláusula UPDATE a condição precisa retornar apenas uma linha da tabela fonte porque a instrução MERGE não pode executar as mesmas operações DML em uma única linha dentro da tabela alvo mais de uma vez. Se a condição WHEN MATCHED retornar mais de uma linha utilizando a instrução UPDATE será retornado um ERRO. Abaixo coloquei algumas regras á qual deve ser considerada antes de utilizar-la:

·         As duas instruções precisam ser processadas.

·         Uma das instruções precisa ATUALIZAR e a outra precisa DELETAR (esta ordem não é importante nem obrigatório)

·         Segunda cláusula WHEN MATCH é checada apenas se a primeira não for satisfeita.

WHEN NOT MATCHED [BY TARGET]:
Quando utilizamos WHEN NOT MATCHED BY TARGET (BY TARGET é opcional, além disso, uma sugestão é que seja explicito e utilize) é utilizado para determinar se a linha na tabela fonte não existe na tabela alvo. É utilizado para achar as linhas que precisam ser inseridos na tabela alvo vindo da fonte.

·         Esta segunda cláusula WHEN MATCH é checada apenas se a primeira não for satisfeita.

·         Adicione está opção ao seu critério.

WHEN NOT MATCHED BY SOURCE:
Esta cláusula é utilizada para descobrir quais são as linhas da tabela alvo que não existe na tabela fonte. Aqui algumas regras devem obedecer usando WHEN NOT MATCHED BY SOURCE.

·         As duas instruções precisam ser processadas;

·         Uma das instruções precisa ATUALIZAR e a outra precisa DELETAR (esta ordem não é importante nem obrigatório);

·         A segunda cláusula é checada apenas se a primeira não for satisfeita;

·         A primeira cláusula é especificada ao seu critério. Se você tentar executar sem
especificar o critério de busca da primeira cláusula, será retornado um erro.

Após termos visto um pequeno exemplo de como funciona o operador merge e quando devemos utilizar irei criar alguns exemplos e irei explicar o funcionamento deles também.

A Sintaxe básica do comando MERGE seria essa:

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

USING <table_source>
ON <search_condition>
[WHEN MATCHED [ AND <search_condition>]
        THEN {UPDATE... | DELETE } ]
[WHEN NOT MATCHED BY TARGET [ AND <search_condition>]
        THEN INSERT... ]
[WHEN NOT MATCHED BY SOURCE [ AND <search_condition>]
        THEN {UPDATE... | DELETE} ]

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

Abaixo seria o diagrama de como funciona a instrução MERGE.

Encima dessa sintaxe irei criar alguns pequenos exemplos prático.

Exemplo 1:

USE AdventureWorks2008
GO

--tabela fonte
IF EXISTS( SELECT NAME FROM SYS.TABLES WHERE name = 'tabela_fonte')
DROP TABLE TABELA_FONTE
CREATE TABLE tabela_fonte(itemNumber int, itemDesc varchar(25));
GO

--tabela alvo
IF EXISTS( SELECT NAME FROM SYS.TABLES WHERE name = 'tabela_alvo')
DROP TABLE TABELA_ALVO
CREATE TABLE tabela_alvo(itemNumber int, itemDesc varchar(25));
GO

--inserindo dados na tabela fonte
INSERT INTO tabela_fonte VALUES(1,'Item A');
INSERT INTO tabela_fonte VALUES(2,'Item B');
INSERT INTO tabela_fonte VALUES(3,'Item C');
INSERT INTO tabela_fonte VALUES(4,'Item D');
GO

--inserindo dados na tabela alvo
INSERT INTO tabela_alvo VALUES(5,'Item need to delete');
INSERT INTO tabela_alvo VALUES(6,'Item need to delete II');
INSERT INTO tabela_alvo VALUES(2,'Item need to update');
INSERT INTO tabela_alvo VALUES(3,'Item need to update II');
GO

--Agora iremos implementar a função MERGE
--INSERT,UPDATE,DELETE

MERGE tabela_alvo AS A
USING tabela_fonte AS I
ON (A.itemNumber = I.itemNumber)
WHEN MATCHED
THEN UPDATE SET A.itemDesc = I.itemDesc
WHEN NOT MATCHED
THEN INSERT VALUES(I.itemNumber, I.itemDesc)
WHEN NOT MATCHED BY SOURCE
THEN DELETE;
GO

SELECT * FROM TABELA_ALVO
SELECT * FROM TABELA_FONTE
GO

Explicação: Observem que os valores da tabela_alvo foram alterados porque utilizamos a tabela como alvo encima da tabela_fonte, caso o itemNumber da tabela alvo for igual da tabela fonte, irá atualizar a tabela alvo baseada na tabela fonte, se caso não for igual, irá inserir os valores baseados da tabela fonte na tabela alvo ou então por último irá deletar.

Exemplo 2:

Agora iremos ter uma situação aonde você irá apenas utilizar "UPDATE, INSERT" e não irá precisar deletar as linhas caso não exista ou algo do tipo. Esta e outras instruções utilizando MERGE podem ser aplicadas baseadas na tabela que criamos acima.

-- utilizando update, insert
MERGE tabela_alvo AS A
USING tabela_fonte AS I
ON (A.itemNumber = I.itemNumber)
WHEN MATCHED
THEN UPDATE SET A.itemDesc = I.itemDesc
WHEN NOT MATCHED
THEN INSERT VALUES(I.itemNumber, I.itemDesc);
GO

SELECT * FROM TABELA_ALVO
SELECT * FROM TABELA_FONTE
GO

Exemplo 3:

--utilizando update,delete.
MERGE tabela_alvo AS A
USING tabela_fonte AS I
ON (A.itemNumber = I.itemNumber)
WHEN MATCHED
THEN UPDATE SET A.itemDesc = I.itemDesc
WHEN NOT MATCHED BY SOURCE
THEN DELETE;
GO

SELECT * FROM TABELA_ALVO
SELECT * FROM TABELA_FONTE
GO

Exemplo 4:

Irei mostrar nesse último exemplo como aplicar apenas a instrução UPDATE utilizando o comando MERGE, certa vez pode ser útil utilizar essa instrução em alguns cenários, um deles seria o que irei mostrar.
Imagine que você tem duas tabelas com dados totalmente distintos e você gostaria de atualizar uma baseada na outra, por exemplo, igualar por um campo data, como você poderia fazer isto? Atualizar linha por linha? Creio que isso lhe tomará um grande tempo dependendo do volume de dados da sua tabela e, além disso, devemos está cientes que podemos até perder um pouco do desempenho do nosso banco de dados; certa vez ,quando estamos desenvolvendo uma certa aplicação sempre procuramos por um melhor desempenho e um menor trabalho, creio que, utilizando o exemplo abaixo no seu dia-dia, poderá cobrir um desses dilemas que temos freqüentemente.

MERGE tabela_alvo AS A
USING tabela_fonte AS I
ON (A.itemNumber = I.itemNumber)
WHEN MATCHED
THEN UPDATE SET A.itemDesc = I.itemDesc;
GO

SELECT * FROM tabela_alvo
SELECT * FROM tabela_fonte;
GO

Conclusão

Concluímos este artigo explicando o funcionamento da instrução MERGE sabendo que, podemos utilizá-lo combinando com certos operadores tais como: INSERT, UPDATE, DELETE e quando devemos utilizar em nosso cenário. Quem trabalha como desenvolvedor ou até mesmo DBA creio que utilizando o operador MERGE nas suas consultas irá se tornará bastante útil, pois a maioria dos bancos de dados que se tornam altamente fragmentados ou até mesmo ‘lento’ são por causa de instruções mal feitas ou algo relacionado a T-SQL. Temos sempre que está ciente qual das melhores alternativas podemos utilizar para deixar o nosso banco de dados agradável ao cliente e como ele poderá utilizar-lo da forma mais fácil.

Object Dependencies Improvement

Quem trabalha com SQL Server 2005 esse nome provavelmente não é novidade, pois foram acrescentadas mais algumas delas no SQL Server 2008. É um recurso que provê uma melhor busca entre objetos através de catálogos tanto introduzidos em view quanto em dynamic management functions. Essas dependências são sempre referenciadas por nome do Schema, referência da entidade, nome do servidor entre outras e são seguidas por: stored procedures, tables, functions,triggers, user-definied types, xml schema-collections entre outros. O SQL Server 2008 introduziu novos objetos como:

sys.sql_expression_dependencies (Catalog View)

sys.dm_sql_referenced_entities (DMF)  

sys.dm_sql_referencing_entities (DMF)

Pode-se visualizar as dependências por dois meios, um deles é usando a interface gráfica, Clique no botão direito em uma tabela e selecione: View Depedencies, como mostrado na imagem a seguir:

E o outro seria via T-SQL:

USE tempdb;
GO

IF

Seya

[]'s

Lucas Souza
http://www.souzalucas.spaces.live.com
http://www.aprendaaprogramar.com.br

Serão mostradas aqui algumas melhorias que estão presentes no SQL Server 2008 a respeito de declaração de variáveis.

SQL Server 2005:

DECLARE

SQL Server 2008:

+=
-=
*=
/=
%=
&=
^=
|=

-- Declarando primeira variável

Seya

[]'s

Lucas Souza
http://www.souzalucas.spaces.live.com
http://www.aprendaaprogramar.com.br

SQL Server 2008 introduziu excelentes melhorias para ter uma melhor produtividade tanto para "desenvolvedores" como "administradores" reduzindo tempo de  gasto utilizado para desenvolver certas aplicações utilizanto T-SQL. Uma delas é o Intellisense sem dúvida é um recurso fantástisco, essa caracteristica trabalha automáticamente com checagem de sintaxe igual ao Visual Studio 2008, como vocês podem ver na imagem abaixo o uso dela:

Lembrando que essa funcionalidade não está disponivel para SQL Server 2000 nem 2005 apenas no SQL Server 2008