SQL_Consultas_Avancadas_01

Prévia do material em texto

Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
1 
 
 
 
Consultas Avançadas – Parte 01 
 
 
 
Sumário 
1. TIPOS DE DADOS ............................................................................................................................................. 3 
1.1. Características e particularidades ........................................................................................................... 3 
1.2. Impactos e pontos de atenção ................................................................................................................ 5 
1.3. Tipos de dados do usuário (User-Defined Data Types) ........................................................................... 5 
1.3.1. Via wizard ........................................................................................................................................ 6 
1.3.2. Via script .......................................................................................................................................... 7 
2. TABELAS .......................................................................................................................................................... 8 
2.1. Normalização ........................................................................................................................................... 8 
2.2. Desnormalização ..................................................................................................................................... 9 
2.3. Constraints ............................................................................................................................................... 9 
2.4. Sequence ............................................................................................................................................... 18 
2.5. Trigger (gatilho) ..................................................................................................................................... 19 
2.6. Tabelas temporárias e variáveis de tipo tabela ..................................................................................... 24 
2.7. Sinônimo ................................................................................................................................................ 28 
2.8. Impactos e pontos de atenção .............................................................................................................. 29 
3. OPERADORES E CONECTORES ...................................................................................................................... 29 
3.1. Operadores ............................................................................................................................................ 29 
3.2. Conectores ............................................................................................................................................. 31 
4. PRINCIPAIS FUNÇÕES NATIVAS DO SQL ....................................................................................................... 31 
4.1. Funções simples ..................................................................................................................................... 31 
5. INSERT ........................................................................................................................................................... 35 
5.1. Insert único ............................................................................................................................................ 36 
5.2. Insert Múltiplo ....................................................................................................................................... 37 
5.3. Select Into .............................................................................................................................................. 37 
5.4. Insert via Select...................................................................................................................................... 38 
5.5. Impactos e ponto de atenção ................................................................................................................ 39 
6. SELECT............................................................................................................................................................ 39 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
2 
6.1. Ordem de interpretação do Select ........................................................................................................ 39 
6.2. Consulta simples .................................................................................................................................... 39 
6.3. Joins ....................................................................................................................................................... 44 
6.4. Pivot ....................................................................................................................................................... 50 
6.5. Subquery ................................................................................................................................................ 51 
6.6. Union ..................................................................................................................................................... 53 
6.7. Except .................................................................................................................................................... 55 
6.8. Intersect ................................................................................................................................................. 55 
6.9. Where .................................................................................................................................................... 56 
6.10. Group By (agrupamento) ................................................................................................................... 57 
6.11. Having ................................................................................................................................................ 60 
6.12. Order By ............................................................................................................................................. 60 
7. TRANSACTION ............................................................................................................................................... 62 
8. UPDATE ......................................................................................................................................................... 63 
8.1. Update simples ...................................................................................................................................... 63 
8.2. Update composto .................................................................................................................................. 64 
9. DELETE ........................................................................................................................................................... 65 
9.1. Delete simples ....................................................................................................................................... 65 
9.2. Delete composto ................................................................................................................................... 66 
10. LOOP .......................................................................................................................................................... 66 
10.1. While .................................................................................................................................................. 66 
10.2. Cursor................................................................................................................................................ 67 
11. ÍNDICES ...................................................................................................................................................... 68 
11.1. Clustered (clusterizado) ..................................................................................................................... 68 
11.2. Nonclustered (não clusterizado) ....................................................................................................... 70 
11.3. Reorganizando ................................................................................................................................... 71 
11.4. Excluindo índice ................................................................................................................................. 71 
12. OBJETOS COMO CONSULTA...................................................................................................................... 72 
12.1. View ................................................................................................................................................... 72 
12.2. Procedure .......................................................................................................................................... 72 
12.3. Function ............................................................................................................................................. 74 
13. LENDO XML ................................................................................................................................................ 75 
14. LINKED SERVER.......................................................................................................................................... 76 
15. UPGRADE ADVISOR ................................................................................................................................... 76 
 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
3 
1. TIPOS DE DADOS 
 
Cada coluna deve ter um tipo de dado [datatype] que determina a característica de qual tipo de 
informação (caracteres, números, datas/horas, etc.) pode ser armazenada nessa coluna. O tipo é 
determinado quando a tabela é criada e nem sempre pode ser alterado posteriormente. Você pode usar 
tipos de dados do sistema [system datatypes], pré-definidos, ou criar novos tipos de dados, chamados 
tipos de dados do usuário [user datatypes], baseados nos tipos do sistema. 
 
Antes, iremos criar uma base que será usada no decorrer do treinamento: 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> Anexo CA_A01_001.sql */ 
 
/* GARANTE QUE A CRIAÇÃO DA BASE_TESTE OCORRERÁ NO MASTER */ 
USE [MASTER] 
GO 
 
/* CRIANDO O BANCO DE DADOS VIA SCRIPT */ 
CREATE DATABASE [BASE_TESTE] 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
1.1. Características e particularidades 
 
Antes de vermos alguns dos impactos e pontos de atenção resultante da escolha de um tipo de 
dado, veremos os tipos mais usuais: 
 
o TINYINT: Comporta armazenar valores numéricos inteiros (sem casa decimal) variando de 0 
até 256 
o SMALLINT: Valores numéricos inteiros variando de –32.768 até 32.767 
o INT: Valores numéricos inteiros variando de -2.147.483.648 até 2.147.483.647 
o BIGINT: Valores numéricos inteiros variando de –92.23.372.036.854.775.808 até 
9.223.372.036.854.775.807 
o BIT: Somente pode assumir os valores 0 ou 1. Utilizado para armazenar valores lógicos. 
o DECIMAL(I,D) e NUMERIC(I,D): Armazenam valores numéricos com casas decimais 
utilizando precisão. “I” deve ser substituído pela quantidade de dígitos total do número e 
“D” deve ser substituído pela quantidade de dígitos da parte decimal (após a vírgula). 
DECIMAL e NUMERIC possuem a mesma funcionalidade, porém DECIMAL faz parte do 
padrão ANSI e NUMERIC é mantido por compatibilidade. Por exemplo, DECIMAL(8,2) 
armazena valores numéricos decimais variando de – 999999,99 até 999999,99 
Lembrando sempre que o SQL Server internamente armazena o separador decimal como 
ponto (.) e o separador de milhar como vírgula (,). Essas configurações INDEPENDEM de 
como o Windows está configurado no painel de controle e para DECIMAL E NUMERIC, 
somente o separador decimal (.) é armazenado 
o SMALLMONEY: Valores numéricos decimais variando de -214.748,3648 até 214.748,3647 
o MONEY: Valores numéricos decimais variando de -922.337.203.685.477,5808 até 
922.337.203.685.477,5807 
o REAL: Valores numéricos aproximados com precisão de ponto flutuante, indo de -3.40E + 
38 até 3.40E + 38 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
4 
o FLOAT: Valores numéricos aproximados com precisão de ponto flutuante, indo de -1.79E + 
308 até 1.79E + 308 
o SMALLDATETIME: Armazena hora e data variando de 1 de janeiro de 1900 até 6 de junho 
de 2079. A precisão de hora é armazenada até os segundos. 
o DATETIME: Armazena hora e data variando de 1 de janeiro de 1753 até 31 de Dezembro de 
9999. A precisão de hora é armazenada até os centésimos de segundos. 
o CHAR(N): Armazena N caracteres fixos (até 8.000) alfanuméricos. Se a quantidade de 
caracteres armazenada no campo for menor que o tamanho total especificado em N, o resto 
do campo é preenchido implicitamente com espaços em branco e ocupará o máximo de 
bytes disponível por registro. Dica: utilizar em campos que sempre armazenarão valores de 
mesmo tamanho, ex.: sigla de Estado, DDD, etc. 
o VARCHAR(N): Armazena N caracteres (até 8.000) alfanuméricos. Pode-se utilizar MAX no 
lugar de “N”, assim, determinará que a coluna pode comportar o máximo de caracteres 
possíveis para o campo. Quando utilizar MAX, o tamanho máximo de armazenamento é 2 ^ 
31-1 bytes (2 GB) e não mais se limitará aos 8.000 bytes possíveis de serem indicados. 
Diferentemente do tipo de dados CHAR, o VARCHAR não irá inserir (implicitamente) espaços 
em branco quando o valor armazenado não atingir todo o tamanho disponibilizado para o 
campo, sendo assim é mais vantajoso pois ocupará menos espaço no banco. Tanto para 
CHAR quanto para VARCHAR, cada caractere ocupa 1 byte e cada byte corresponde a 256 
combinações possíveis (2^8). Para o alfabeto latino/americano, 256 combinações é mais 
que suficiente para cada caractere. 
A quantidade MAX passou a ser disponibilizada a partir da versão 2000 do SQL Server. 
o TEXT: Armazena caracteres (até 2.147.483.647) alfanuméricos. Se a quantidade de 
caracteres armazenada no campo for menor que 2.147.483.647, o resto do campo não é 
preenchido. Procure não utilizar este tipo de dado diretamente, pois existem funções 
específicas para trabalhar com este tipo de dado. 
o NCHAR(N): Armazena N caracteres fixos (até 4.000) alfanuméricos. 
o NVARCHAR(N): Armazena N caracteres (até 4.000) no formato Unicode. NCHAR e 
NVARCHAR ocupam 2 bytes por posição, ou seja, 65536 posições (2^16). Então, cada 
caractere armazenado consome mais espaço que o uma coluna do tipo CHAR ou VARCHAR, 
mas consegue suprir a necessidade de alfabetos ou padrões alfanuméricos que possam ter 
mais de 256 combinações por caractere. 
o NTEXT: Armazena caracteres (até 1.073.741.823) no formato Unicode. Se a quantidade de 
caracteres armazenada no campo for menor que 1.073.741.823, o resto do campo não é 
preenchido. Procure não utilizar este tipo de dado diretamente, pois existem funções 
específicas para trabalhar com este tipo de dado. 
o IMAGE: Dados binários do comprimento variável de 0 a 2^31-1 (2.147.483.647) bytes. 
Utilizado com frequência para armazenar arquivos (xml, fotos, documentos, etc.). 
o UNIQUEIDENTIFIER: Armazena valores binários de 16 bytes que operam como GUIDs 
(Globally Unique Identifiers). Um GUID é um número binário exclusivo;nenhum outro 
computador no mundo gerará uma duplicata daquele valor GUID. Formato de cadeia de 
caracteres: '6F9619FF-8B86-D011-B42D-00C04FC964FF'. Esta coluna geralmente é utilizada 
em processos de replicação (merge) para identificar um registro de uma tabela, mesmo que 
essa tabela tenha uma Primary Key. 
 
 
 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
5 
1.2. Impactos e pontos de atenção 
O tipo de dados atribuído à uma coluna irá interferir diretamente na performance da 
mesma, de sua respectiva tabela e, até mesmo, no desempenho do banco de dados. Outro 
ponto que será afetado diretamente é o espaço alocado em disco. Quando, por exemplo, 
uma tabela tem poucos registros, dificilmente os efeitos serão palpáveis. Porém, em uma 
tabela com milhares de registros, tais efeitos serão sentidos. 
Em uma consulta (Select) onde se deseja filtrar (Where) alguma informação da tabela, 
quanto mais bytes tiver a coluna a ser filtrada, mais tempo o SQL Server levará para localizar 
as informações, pois justamente terá que percorrer mais bytes e consumirá mais 
processamento e memória para localizar as informações desejadas. Isso também vale 
quando houver um relacionamento entre as tabelas (Join), seja em um Select, Update ou 
Delete composto. Por isso é mais usual e recomendável que as tabelas tenham chave 
primárias (PK) do tipo numérico (integer) e consequentemente suas respectivas chaves 
estrangeiras (FK). Além disso, a chave primária é a coluna responsável por identificar o 
registro dentro da tabela. Então, quanto mais bytes a PK tiver, mais demorado será o 
processo de identificação do registro. Sendo assim, deve-se evitar PK com tipo de dados 
“grandes” (char, varchar, etc.) e também chave primária composta (mais de uma coluna). 
Ainda se tratando de consulta, as colunas retornadas em um Select e sua ordenação 
(Order By) sofrem consequências diretas em decorrência do tipo de dados. O cache do 
resultado que será exibido/ordenado ficará cada vez maior e mais demorado se o retorno 
da consulta possuir várias colunas “grandes” e vários registros. Em uma requisição Cliente -
> Servidor, o resultado da consulta será trafegado pela rede, então um alto volume de 
informações terá também esse tempo de tráfego acrescido. Não será de se estranhar se, ao 
acrescentar uma coluna Image no retorno de um Select, essa consulta ficar muito mais lenta. 
Por tudo isso, um trabalho bem feito de análise antes da criação das tabelas é 
fundamental para garantir que se desperdice bytes. Saber, de fato, quais informações serão 
armazenadas, seus limites e principalmente a necessidade de cada uma delas é de suma 
importância para que não se crie colunas desnecessárias e quando cria-las usar o tipo de 
dado ideal. 
/* No anexo "CA_A01_002.sql" será criada, inicialmente, uma 
 tabela com apenas uma coluna de tipo Integer. Em seguida, 
 serão inseridos 1.000.000 de registros. O select dessas 
 informações leverá poucos segundos. Após, será criada uma 
 nova coluna do tipo Image e inserido dados nela para os 
 mesmos 1.000.000. O tempo para um novo select já com a 
 nova coluna será de alguns minutos */ 
 
 
1.3. Tipos de dados do usuário (User-Defined Data Types) 
É uma funcionalidade do SQL Server na qual permite ao usuário criar um apelido para 
os tipos de dados já existentes no próprio SQL Server, ou seja, quando o usuário for criar 
uma tabela, parâmetro, variável, etc., ao invés de usar os nomes padrão do SQL (integer, 
varchar, etc.), o usuário irá utilizar o sinônimo que ele mesmo definiu. Nesse caso, única 
diferença é que o usuário deve definir o limite do “seu” tipo de dado quando isso se fizer 
necessário. Por tanto, se ele criar um tipo de dado chamado “Nome” para substituir o tipo 
varchar, ele deverá informar o tamanho que esse “Nome” deverá conseguir armazenar. 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
6 
 
1.3.1. Via wizard 
Para criar um tipo de dados, vá até o “Object Explorer”, expanda até o nível “User-
Defined Data Types”, clique com o botão direito em cima do próprio item “User-
Defined Data Types” e, em seguida, clique em “New User-Defined Data Types”, 
conforme Imagem 1. 
 
Imagem 1 
 
Então, defina um nome (Name) e um tipo de dado (Data type) conforme mostra a 
Imagem 2. Depois, clique em OK. 
 
 
Imagem 2 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
7 
 
O seu tipo de dado estará criado, como pode ser visualizado na Imagem 3. Caso não 
apareça de imediato, basta atualizar o Object Explorer. 
 
Imagem 3 
 
1.3.2. Via script 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> Anexo CA_A01_003.sql */ 
 
/* CRIA O TIPO DE DADO CHAMADO "CODIGO" */ 
CREATE TYPE [DBO].[CODIGO] FROM [INT] NOT NULL 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
Para consumir esse novo tipo de dados, é simples. Basta visualizar e executar o script 
abaixo. 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> Anexo CA_A01_004.sql */ 
 
/* CRIA UMA TABELA UTILIZANDO O TIPO "CODIGO" 
 AO INVÉS DE INTEGER */ 
CREATE TABLE DBO.TABELA_TESTE_TIPO 
( 
 COLUNA_CODIGO CODIGO PRIMARY KEY 
) 
GO 
 
/* CRIA UMA VARÍAVEL UTILIZANDO O TIPO "CODIGO", 
 ATRIBUI-SE UM VALOR A ELA E DEPOIS EXIBE ESSE 
 VALOR EM UMA CONSULTA SIMPLES */ 
DECLARE @VARIAVEL_CODIGO CODIGO 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
8 
SET @VARIAVEL_CODIGO = 99 
SELECT @VARIAVEL_CODIGO 
GO 
 
/* CRIA UMA PROCEDURE QUE TERÁ UMA PARÂMETRO DE 
 ENTRADA UTILIZANDO O TIPO "CODIGO". ESSA 
 PROCEDURE APENAS EXIBIRÁ, ATRAVÉS DE UM 
 SELECT, O VALOR QUE LHE SERÁ ATRIBUÍDO */ 
CREATE PROCEDURE DBO.STP_PROCEDURE_TESTE @PARAMETRO_CODIGO CODIGO 
AS 
 SELECT @PARAMETRO_CODIGO 
GO 
 
/* EXECUTA A PROCEDURE CRIADA ACIMA */ 
EXECUTE DBO.STP_PROCEDURE_TESTE @PARAMETRO_CODIGO = 88 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
A utilização desse recurso ajuda o programador T-SQL no dia a dia pois o mesmo não 
terá que lembrar, por exemplo, qual é o padrão que sua empresa utiliza quando o mesmo 
tiver que criar uma nova coluna/parâmetro/variável que deverá receber a informação 
“Nome”. Por outro lado, isso poderá confundir usuários que não são acostumadas com essa 
forma de definir tipo de dados levando a uma demora na identificação dos mesmos e, até 
mesmo, por ignorância, passar a usar a definição do próprio SQL Server. Então no banco de 
dados haverão declarações de variáveis para a mesma finalidade, hora com o tipo do 
usuário, hora com o tipo do SQL Server. Outro ponto negativo é que integrações poderão 
não reconhecer o tipo de dados do usuário, até mesmo com banco de dados da própria 
Microsoft, como é o caso do SQL Data Sync que é usado para replicar dados de um servidor 
SQL Server com um servidor SQL Azure. 
 
2. TABELAS 
Tabela é o local onde as informações ficam armazenadas dentro do banco de dados, permitindo 
que essas informações sejam alteradas, excluídas e extraídas. 
2.1. Normalização 
A normalização de dados indicará o modelo estrutural que as tabelas do seu projeto de 
banco de dados. Ela é importante para mostrar como as tabelas irão se relacionar (1 registro 
para 1 registro, 1 para muitos, muitos para muitos), exercer funções de desempenho em um 
banco de dados com grande volume de I/O ou consulta (Data wharehouse – 
desnormalizada). Uma base de dados bem normalizada evita redundância de dados e 
garante a integridade das informações. Ex.: você ter uma só tabela com informações de 
endereço e, para cada registro, repetir os nomes da cidade, estado, etc. (correndo o risco 
de errar um mesmo nome em registro diferente) ou pode normalizar “quebrando” em várias 
tabelas como: país, estado,cidade, etc. e cadastrar uma vez só e associá-las em a partir de 
seus respectivos códigos relacionando PK (primary key) e FK (foreign key). 
A principal vantagem de se utilizar um SGBD (sistema de gerenciamento de banco de dados) 
como o SQL Server é para se criar uma estrutura de dados relacional, ou seja, várias tabelas 
que estão relacionadas entre si. No pré-projeto de um banco de dados, para visualizar o 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
9 
cenário de quais serão as tabelas e como elas ficarão relacionadas entre si, cria-se o DER 
(Diagrama de Entidade e Relacionamento). 
 
 
2.2. Desnormalização 
 
Nem todas as situações que o analista do banco de dados irá encontrar em um novo projeto 
exigirá um banco de dados com as tabelas normalizadas ao máximo. Informações históricas 
que, por exemplo, devem ser preservadas por um período mínimo de tempo, devem no 
mínimo replicar e manter de maneira redundante as informações de sua tabela de origem. 
Uma Nota Fiscal, por exemplo, deve manter intactas por ao menos 5 anos os dados que elas 
possuíam no instante em que a nota foi gerada. Com isso, as tabelas de Nota Fiscal deverão 
armazenar boa parte das informações que constam na tabela de clientes, produtos, 
endereço, fiscal, etc. Com isso, caso haja a necessidade de se alterar o cadastro do cliente 
ou produto, a tabela de nota fiscal permanecerá inalterada e preservará a situação dessas 
informações no momento em que a NF foi gerada. 
Outro caso em que se faz necessário desnormalizar uma tabela é para ambientes 
consultivos, ou seja, para geração de relatórios gerenciais, matriz de dados, data warehouse, 
etc. Com isso, cada tabela, terá praticamente uma finalidade e conterá apenas as colunas 
que de fato serão consumidas. Para um ambiente consultivo, isso gera economia no tempo 
de resposta e processamento, pois necessitará apenas de um “Select” simples. 
 
 
2.3. Constraints 
As constraints (restrições) permitem que seja definido o modo como o banco de dados irá 
impor, automaticamente, a integridade nos dados que serão armazenados. São as 
constraints que irão definir as regras referentes aos valores que cada coluna poderá receber. 
Quem também irá usar as definições das constraints é o otimizador de consultas do SQL 
Server que criará planos de execução para consultas de alto desempenho. 
As principais constraints são: 
o Not Null: indica que a coluna não aceitará valores nulos, ou seja, é obrigatório incluir 
alguma informação nessa coluna da tabela para poder gravar um registro; 
 
o Check: condição que restringe à apenas alguns valores o que poderá ser inserido 
dentro de uma coluna. É uma validação booleana (true/false), deixando inserir só o 
que for verdadeiro. Exemplo: Na tabela “Cliente”, você cria uma coluna “Situacao” 
atribuindo um Check com os valores “Ativo” e “Inativo”. Se o usuário tentar incluir 
qualquer outro valor nessa coluna, o banco de dados gerará uma inconsistência e 
não permitirá o armazenamento até que se corrija para um dos dois valores pré-
definidos; 
 
o Unique: impõe que não poderá se repetir valores de uma mesma coluna. Exemplo: 
na tabela “Cliente”, você cria uma restrição Unique para a coluna “CPF”. Isso irá 
garantir que nunca haverá dois clientes com o mesmo CPF cadastrado nessa tabela. 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
10 
o Primary Key (PK): ou chave primária, restrição aplicada à uma coluna ou conjunto de 
colunas com valores que servirão para identificar o uma linha (registro) de uma 
tabela. Por consequência, a PK deverá receber valores (não admite nulos) e cada 
linha tem que ter um valor único. Exemplo: na tabela “Cliente” haverá uma coluna 
“Codigo_Cliente” com a atribuição de PK. Ou seja, para localizar o cliente “X” dentro 
dessa tabela, basta saber seu código. Ao criar uma coluna PK, também será criado 
um índice automaticamente que otimizará os mecanismos de busca nessa tabela; 
 
o Foreign Key (FK): ou chave estrangeira, restrição aplicada a determinada coluna ou 
conjunto de colunas que servirá para identificar seu registro “pai” em outra tabela, 
garantindo a integridade dos dados em uma estrutura de tabelas 
relacional/normalizada. Exemplo: na tabela “Pedidos_do_Cliente”, haverá uma 
coluna com restrição FK chamada “Codigo_do_Cliente”. Com isso, será possível saber 
quais são os pedidos de um determinado cliente e garantir, também, que só existam 
pedidos de clientes previamente cadastrados na tabela “Cliente”, 
 
 Cascade: ou cascata, propriedade que indica que, ao excluir um registro pai 
(PK), os registros filhos (FK) serão excluídos automaticamente. Ou seja, ao 
excluir um cliente na tabela “Cliente”, automaticamente serão excluídos seus 
repectivos pedidos na tabela “Pedidos_do_Cliente”. 
 
o Set Default: indica se uma coluna receberá um valor default (e qual será esse valor) 
no momento em que um registro for inserido dentro da tabela. Exemplo: ao 
cadastrar um novo cliente na tabela “Cliente” a coluna “Data_de_Cadastro” receberá 
um valor default sem a necessidade de o usuário ter que passar esse valor (pode ser 
um valor fixo ou uma função do banco que retorne dinamicamente esse valor). 
 
Abaixo veremos um script que conterá os tipos de constraints citados acima. A única 
observação é que a chave primária, por default, já cria uma constraint Unique, ou seja, a 
coluna que será PK não permitirá repetição de valores. 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> Anexo CA_A01_005.sql */ 
 
/* APONTA PARA A BASE MASTER */ 
USE MASTER 
GO 
 
/* APAGA A BASE DE TESTES */ 
DROP DATABASE BASE_TESTE 
GO 
 
/* RECRIA A BASE DE TESTES */ 
CREATE DATABASE BASE_TESTE 
GO 
 
/* APONTA PARA A BASE DE TESTES */ 
USE BASE_TESTE 
GO 
 
/* CASO O OBJETO NÃO EXISTA */ 
IF OBJECT_ID('CIDADE') IS NULL 
BEGIN -- "BEGIN" ABRE UM BLOCO COM COMANDOS QUE SERÃO EXECUTADOS DENTRO DA CONDIÇÃO LÓGICA 
"IF" 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
11 
 
 /* CRIA A TABELA CIDADE */ 
 CREATE TABLE DBO.CIDADE 
 ( 
 /* DEFINE AS COLUNAS/TIPOS DE DADOS/CONSTRAINTS QUE A TABELA TERÁ. 
 UTILIZA-SE VÍRGULA PARA SEPARAR A DEFINIÇÃO DE CADA COLUNA */ 
 ID_CIDA INT PRIMARY KEY NOT NULL , /* CÓDIGO IDENTIFICADOR DA CIDADE */ 
 NM_CIDA VARCHAR (40) /* NOME DA CIDADE */ 
 ) 
 
END -- "END" FECHA (DELIMITA) O BLOCO DE COMANDOS ABERTO QUANDO SATISFEZ A CONDIÇÃO LÓGICA 
"IF" 
 
/* CASO O OBJETO NÃO EXISTA */ 
IF OBJECT_ID('CLIENTE') IS NULL 
BEGIN 
 /* CRIA A TABELA CLIENTE */ 
 CREATE TABLE DBO.CLIENTE 
 ( 
 ID_CLIE INT PRIMARY KEY NOT NULL , /* CÓDIGO (IDENTIFICADOR) DO REGISTRO */ 
 NM_CLIE VARCHAR (40) NOT NULL , /* NOME DO CLIENTE */ 
 FL_PESSCLIE CHAR (1) CHECK(FL_PESSCLIE = 'F' OR FL_PESSCLIE = 'J'), /* CHECK: 
FLAG DO TIPO DE PESSOA: "F" CORRESPONDE À PESSOA FÍSICA E "J" À JURÍDICA */ 
 NR_CNPJCLIE VARCHAR (14) , /* NÚMERO DO CNPJ */ 
 NR_CPFCLIE VARCHAR (11) , /* NÚMERO DO CPF */ 
 DT_CADACLIE DATETIME DEFAULT GETDATE(), /* VALOR DEFAULT: DATA/HORA QUE O 
REGISTRO FOI CADASTRADO */ 
 NR_DDDCLIE VARCHAR (2) , /* NÚMERO DO DDD DO CLIENTE */ 
 NR_FONECLIE VARCHAR (9) /* NÚMERO DO TELEFONE DO CLIENTE */, 
 ID_CIDA INT /* CÓDIGO IDENTIFICADOR DA CIDADE */ 
 ) 
END 
 
/* IRÁ ALTERAR A TABELA CLIENTE E ADICIONAR O RELACIONAMENTO FK (FOREIGN KEY) 
COM A TABELA CIDADE, LIGANDO A COLUNA AS COLUNAS ID_CIDA DE AMBAS AS TABELAS*/ 
ALTER TABLE CLIENTE 
ADD CONSTRAINT FK_CLIENTE_CIDADE FOREIGN KEY (ID_CIDA) REFERENCES CIDADE (ID_CIDA) 
 
 
/* CASO O OBJETO NÃO EXISTA */ 
IF OBJECT_ID('PEDIDO') IS NULL 
BEGIN 
 /* CRIA A TABELA CLIENTE */ 
 CREATE TABLE DBO.PEDIDO 
 ( 
 ID_PEDI INT PRIMARY KEY NOT NULL , /* CÓDIGO (IDENTIFICADOR) DO REGISTRO */ 
 DT_PEDI DATETIME NOT NULL DEFAULTGETDATE(), /* DATA/HORA QUE O PEDIDO FOI 
CRIADO */ 
 ID_CLIE INT NOT NULL /* CÓDIGO (IDENTIFICADOR) DO CLIENTE */ 
 ) 
END 
 
/* CASO O OBJETO NÃO EXISTA */ 
IF OBJECT_ID('PEDIDO_ITEM') IS NULL 
BEGIN 
 /* CRIA A TABELA PEDIDO_ITEM (ITENS DE VENDA DO PEDIDO) */ 
 CREATE TABLE DBO.PEDIDO_ITEM 
 ( 
 ID_PEDIITEM INT PRIMARY KEY NOT NULL , /* CÓDIGO (IDENTIFICADOR) DO REGISTRO */ 
 ID_PEDI INT NOT NULL , /* CÓDIGO (IDENTIFICADOR) DO PEDIDO */ 
 ID_PROD INT NOT NULL , /* CÓDIGO (IDENTIFICADOR) DO PRODUTO */ 
 QN_PROD INT , /* QUANTIDADE VENDIDA */ 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
12 
 VL_PROD NUMERIC (10, 2) /* VALOR UNITÁRIO DO PRODUTO NO MOMENTO EM QUE A VENDA 
FOI FEITA */ 
 ) 
END 
 
GO -- GARANTE A EXECUÇÃO DOS SCRIPTS ATÉ ESTE PONTO 
 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
Para criar uma tabela e as constraints utilizando o Management Studio, você deverá expandir o 
“Object Explorer” nos níveis “Databases”, “Base_Teste”, “Tables”, clicar com o botão direito do 
mouse sobre “Tables” e acessar a opção “Table...”, conforme Imagem 4. 
 
Imagem 4 
 
Abrirá uma tela para inserir criar as colunas de uma tabela. Como a estrutura visual e propriedades 
disponíveis são as mesmas, iremos trabalhar, como exemplo, apenas a tabela “CLIENTE”, já que 
esta possui todos os casos a serem trabalhados. 
Para criar a chave primária, basta selecionar a coluna desejada e clicar no botão com desenho de 
chave, como na Imagem 5. 
 
 
Imagem 5 
 
Para não permitir que uma coluna receba valores nulos, é só desmarcar a opção “Allou Nulls”, 
também indicada na figura acima. 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
13 
A constraint “Check” que irá validar o tipo de pessoa inserido na coluna FL_PESSCLIE obrigando 
apenas a possibilidade de se cadastrar “F” ou “J” (para Física ou Jurídica), pode ser criada 
executando os seguintes passos: clique com o botão direito do mouse sobre FL_PESSCLIE, depois 
clique na opção “Check Constraints...”, tal como na Imagem 6. 
 
 
Imagem 6 
 
 
Então, na tela que seguirá, basta digitar a restrição “CHECK(FL_PESSCLIE = 'F' or FL_PESSCLIE = 'J')” 
na coluna “Expression” e pressionar “Close”, de acordo com a Imagem 7. 
 
 
 
Imagem 7 
 
 
O valor default, será incluído de acordo com a Imagem 8. Na prática, é selecionar a coluna 
desejada, ir na página “(General)” e inserir um valor na propriedade “Default Value or Binding”. Lá 
você pode informar um valor fixo, calculado ou função do banco de dados, lembrando sempre que 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
14 
esse valor default deve ser do mesmo tipo de dado da respectiva coluna. No exemplo a baixo, 
“GETDATE()” retornará a Data/Hora atual do servidor. 
 
 
Imagem 8 
 
 
Para salvar o que foi feito e dar nome a tabela, é só clicar no botão salvar (o que possuí ícone com 
imagem de um disquete) ou utilizar as teclas de atalho “Ctrl + S”. Em seguida, na caixa de diálogo 
que irá aparecer, basta informar o nome “CLIENTE” e salvar pressionando o botão “Ok”. A Imagem 
9 explica melhor. 
 
 
 
Imagem 9 
 
Por fim, a tabela estará criada. Para visualizar a tabela, vá até o “Object Explorer” e expanda os 
níveis “Databases” -> “Base_Teste” -> “Tables”, clique sobre “Tables” e atualize. 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
15 
Para criar uma constraint de relacionamento utilizando o Management Studio, você deverá 
expandir o “Object Explorer” nos níveis “Databases”, “Base_Teste”, “Tables”, clicar com o botão 
direito do mouse sobre a tabela “PEDIDO_ITEM” e acessar a opção “Design”, conforme Imagem 
10. No caso, a tabela “PEDIDO_ITEM” é a que será alterada para criar o relacionamento (FK) com 
as tabelas de referência “PEDIDO” e “PRODUTO”. 
 
 
Imagem 10 
Será aberta uma nova janela com opções de edição da tabela. Em seguida, deverá ir sobre a coluna 
desejada (“ID_PEDI”), clicar com o botão direito do mouse, e ir na opção “Relationships...”, como 
mostra a Imagem 11. 
 
 
Imagem 11 
 
Na janela que abrirá, deverá clicar no botão “...” da propriedade “Tables And Columns 
Specification”, orientado pela Imagem 12. 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
16 
 
 
Imagem 12 
 
Então, em “Primary key table:” você deverá escolher a tabela que será referência (“PEDIDO”) e, 
abaixo, a respectiva coluna (PK) – ID_PEDI – que será ligada. Ao lado, em “Foreign key table”, na 
própria tabela “PEDIDO_ITEM”, escolher a coluna referenciada (FK) – ID_PEDI – que irá se 
relacionar com a tabela principal, como segue o exemplo na Imagem 13. O nome do 
relacionamento pode ser dado à revelia, mas, para identificar esta restrição de integridade em 
futuras situações, recomenda-se iniciar com “FK_” e, se possível, incluir o nome das tabelas 
relacionadas. Clique em “OK” para confirmar. 
 
 
Imagem 13 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
17 
Feito os passos acima, salve as alterações no botão com ícone de disquete ou através dos atalhos 
“Ctrl+S”, indicado na Imagem 24. 
 
 
Imagem 14 
 
O resultado dessas alterações pode ser observado no subgrupo “Key” dentro da própria tabela no 
“Object Explorer”, conforme Imagem 15. Caso a chave estrangeira (FK) não apareça de imediato, 
lembre-se de atualizar o Object Explorer pressionando “F5” ou pelo próprio botão de atualizar. 
 
 
 
Imagem 15 
 
A chave primária sempre será única para a tabela. Ela é ilustrada com a figura de uma chave na 
cor dourada. A (s) chaves estrangeiras (FK) tem o mesmo tipo de ilustração da PK, mas sua cor é 
cinza e podem haver várias em uma mesma tabela. 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
18 
2.4. Sequence 
Objeto agregado ao SQL Server a partir da edição 2012, este recurso serve basicamente para 
gerar números inteiros sequenciais. Nele é possível parametrizar em qual valor a sequência 
iniciará, qual o salto (de 1 em 1, 2 em 2, etc.) e qual o valor máximo que a sequência irá 
atingir. Se o tipo de dados não for indicado, por padrão a sequence assumirá o tipo Integer. 
Senão, poderá ir do tinyint até o bigint. A principal vantagem é que o consumo da sequence 
não fica “preso” a transações, ou seja, se a geração de um novo número a partir da sequence 
estiver dentro de uma transação não será preciso encerrar a transação para que outra 
sessão utilize a mesma sequence para obter o próximo número da sequência. Veja o 
exemplo no script abaixo: 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> Anexo CA_A01_006.sql */ 
 
USE BASE_TESTE 
GO 
 
/* CASO O OBJETO NÃO EXISTA */ 
IF OBJECT_ID('TABELA_TESTE_SEQUENCE') IS NULL 
BEGIN 
 
 /* CRIA A TABELA */ 
 CREATE TABLE DBO.TABELA_TESTE_SEQUENCE 
 ( 
 CODIGO_IDENTITY INTEGER IDENTITY, 
 CODIGO_SEQUENCE INTEGER 
 ) 
 
END 
 
 
/* CRIA A SEQUENCE */ 
CREATE SEQUENCE DBO.SEQ_TESTE 
 AS INTEGER 
 START WITH 100 
 INCREMENT BY 1 
 MINVALUE 1 
 MAXVALUE 999999 
GO 
 
-- EXIBE O PRIMEIRO VALOR QUE SERÁ GERADO PELA SEQUENCE 
SELECT NEXT VALUE FOR DBO.SEQ_TESTE 
 
-- EXIBE O PRÓXIMO VALOR QUE SERÁ GERADO PELA SEQUENCE 
SELECT NEXT VALUE FOR DBO.SEQ_TESTE 
 
-- INSERE UM REGISTRO NA TABELA DE TESTES 
INSERT INTO DBO.TABELA_TESTE_SEQUENCE 
( 
 CODIGO_SEQUENCE 
) 
VALUES 
( 
 NEXT VALUE FOR DBO.SEQ_TESTE 
) 
 
-- EXIBE O REGISTRO INSERIDO NA TABELA DE TESTES 
SELECT * FROM DBO.TABELA_TESTE_SEQUENCE 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
Curso de Banco de Dados– Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
19 
 
2.5. Trigger (gatilho) 
O trigger ou gatilho é um objeto do banco de dados associado à uma tabela. Como o próprio 
nome sugere, o gatilho é disparado mediante a uma ação que a tabela sofre na manipulação 
dos seus registros. As ações podem disparar um trigger são: insert, update e/ou delete. 
Este tipo de objeto pode ser usado para tratar e validar informações que estão sendo 
inseridas/atualizadas na tabela, retornando, por exemplo, alguma mensagem de erro 
quando alguma inconsistência for encontrada não permitindo, dessa maneira, que a ação 
(insert/update) seja efetivada. Em casos de exclusão de um registro, pode-se impedir a 
deleção ou, então, gravar um log do registro que está sendo deletado. 
A estrutura básica de um trigger é: 
CREATE TRIGGER dbo.NOME_DA_TRIGGER 
ON dbo.NOME_DA_TABELA 
[FOR/AFTER/INSTEAD OF] [INSERT/UPDATE/DELETE] 
AS 
 /* SCRIPT DO TRIGGER */ 
 
GO 
 
Onde o <NOME_DA_TABELA> é o nome da tabela que receberá a ação. As próximas 
parâmetros definem em que momento o gatilho será disparado. FOR é o parâmetro que 
indica que o gatilho será disparado junto com a ação que movimentou a tabela. AFTER indica 
que o disparo ocorrerá somente após concluída a ação que o originou. INSTEAD OF executa 
o trigger ao invés da ação que o originou. INSERT, UPDATE ou DELETE indica qual ação irá 
disparar o trigger. Uma mesma tabela pode ter trigger para os 3 tipos de evento. 
Na prática, execute o script abaixo. 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_007.SQL */ 
 
/* EXEMPLO PARA UTILIZAÇÃO DE TRIGGER */ 
 
/* APONTA A BASE TESTE */ 
USE BASE_TESTE 
GO 
 
/* CRIA A TABELA QUE SERVIRÁ PARA TESTE */ 
CREATE TABLE [DBO].[TABELA_TESTE_TRIGGER] 
( 
 [CODIGO] INT PRIMARY KEY, 
 [NOME] VARCHAR(40), 
 [VALOR_UNITARIO] MONEY, 
 [QUANTIDADE] INT, 
 [VALOR_TOTAL] MONEY 
) 
GO 
 
/* CRIA TABELA AUXILIAR QUE ARMAZENARÁ AS 
 INFORMAÇÕES DE QUEM EXCLUIU REGISTRO */ 
CREATE TABLE [DBO].[TABELA_TESTE_TRIGGER_LOG]( 
 [SPID] [SMALLINT] NOT NULL, 
 [KPID] [SMALLINT] NOT NULL, 
 [BLOCKED] [SMALLINT] NOT NULL, 
 [WAITTYPE] [BINARY](2) NOT NULL, 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
20 
 [WAITTIME] [BIGINT] NOT NULL, 
 [LASTWAITTYPE] [NCHAR](32) NOT NULL, 
 [WAITRESOURCE] [NCHAR](256) NOT NULL, 
 [DBID] [SMALLINT] NOT NULL, 
 [UID] [SMALLINT] NULL, 
 [CPU] [INT] NOT NULL, 
 [PHYSICAL_IO] [BIGINT] NOT NULL, 
 [MEMUSAGE] [INT] NOT NULL, 
 [LOGIN_TIME] [DATETIME] NOT NULL, 
 [LAST_BATCH] [DATETIME] NOT NULL, 
 [ECID] [SMALLINT] NOT NULL, 
 [OPEN_TRAN] [SMALLINT] NOT NULL, 
 [STATUS] [NCHAR](30) NOT NULL, 
 [SID] [BINARY](86) NOT NULL, 
 [HOSTNAME] [NCHAR](128) NOT NULL, 
 [PROGRAM_NAME] [NCHAR](128) NOT NULL, 
 [HOSTPROCESS] [NCHAR](10) NOT NULL, 
 [CMD] [NCHAR](16) NOT NULL, 
 [NT_DOMAIN] [NCHAR](128) NOT NULL, 
 [NT_USERNAME] [NCHAR](128) NOT NULL, 
 [NET_ADDRESS] [NCHAR](12) NOT NULL, 
 [NET_LIBRARY] [NCHAR](12) NOT NULL, 
 [LOGINAME] [NCHAR](128) NOT NULL, 
 [CONTEXT_INFO] [BINARY](128) NOT NULL, 
 [DATAHORA] [DATETIME], 
 [ACAO] [VARCHAR](12), 
 [CODIGO] [INTEGER] 
) 
GO 
 
 
/* 1) CRIA A TABELA QUE SERVIRÁ PARA TESTE */ 
CREATE TABLE [DBO].[TABELA_TESTE_TRIGGER_EXCLUIDOS] 
( 
 [CODIGO] INT PRIMARY KEY, 
 [NOME] VARCHAR(40), 
 [VALOR_UNITARIO] MONEY, 
 [QUANTIDADE] INT, 
 [VALOR_TOTAL] MONEY 
) 
GO 
 
-- CRIA TRIGGER QUE SERÁ DISPARADA QUANDO UM REGISTRO FOR EXCLUÍDO 
CREATE TRIGGER [DBO].[TRD_TABELA_TESTE_TRIGGER] ON [DBO].[TABELA_TESTE_TRIGGER] FOR DELETE AS 
BEGIN 
 -- GRAVA LOG PARA RASTREAMENTO DA ORIGEM DA DELEÇÃO DOS REGISTROS DA TABELA 
TABELA_TESTE_TRIGGER 
 INSERT INTO TABELA_TESTE_TRIGGER_LOG 
 SELECT SP.SPID, 
 SP.KPID, 
 SP.BLOCKED, 
 SP.WAITTYPE, 
 SP.WAITTIME, 
 SP.LASTWAITTYPE, 
 SP.WAITRESOURCE, 
 SP.DBID, 
 SP.UID, 
 SP.CPU, 
 SP.PHYSICAL_IO, 
 SP.MEMUSAGE, 
 SP.LOGIN_TIME, 
 SP.LAST_BATCH, 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
21 
 SP.ECID, 
 SP.OPEN_TRAN, 
 SP.STATUS, 
 SP.SID, 
 SP.HOSTNAME, 
 SP.PROGRAM_NAME, 
 SP.HOSTPROCESS, 
 SP.CMD, 
 SP.NT_DOMAIN, 
 SP.NT_USERNAME, 
 SP.NET_ADDRESS, 
 SP.NET_LIBRARY, 
 SP.LOGINAME, 
 SP.CONTEXT_INFO, 
 GETDATE() AS DATAHORA, 
 'DELETE', 
 D.CODIGO 
 FROM MASTER..SYSPROCESSES SP, 
 DELETED D /* DELETED = TABELA_TESTE_TRIGGER ( 
 APENAS COM O REGISTRO EXCLUÍDO) */ 
 WHERE SP.SPID = @@SPID 
 
 INSERT INTO DBO.TABELA_TESTE_TRIGGER_EXCLUIDOS 
 ( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE, 
 VALOR_TOTAL 
 ) 
 SELECT CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE, 
 VALOR_TOTAL 
 FROM DELETED 
END 
 
GO 
 
 
/* APÓS O REGISTRO SER INSERIDO, CALCULA O VALOR TOTAL E ATUALIZA A COLUNA */ 
CREATE TRIGGER [DBO].[TRI_TABELA_TESTE_TRIGGER] ON [DBO].[TABELA_TESTE_TRIGGER] AFTER INSERT 
AS 
BEGIN 
 UPDATE DBO.TABELA_TESTE_TRIGGER 
 SET VALOR_TOTAL = VALOR_UNITARIO * QUANTIDADE 
 WHERE CODIGO IN (SELECT CODIGO FROM INSERTED) 
 
END 
GO 
 
/* APÓS O REGISTRO SER INSERIDO, CALCULA O VALOR TOTAL E ATUALIZA A COLUNA */ 
CREATE TRIGGER [DBO].[TRU_TABELA_TESTE_TRIGGER] ON [DBO].[TABELA_TESTE_TRIGGER] INSTEAD OF 
UPDATE AS 
BEGIN 
 RAISERROR('ESTA TABELA NÃO PODE SER ALTERADA!', 16, 1) 
 
END 
GO 
 
/* INSERE REGISTROS */ 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
22 
INSERT INTO DBO.TABELA_TESTE_TRIGGER 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
 -- VALOR_TOTAL (SERÁ CALCULADO POSTERIORMENTE) 
) 
VALUES 
( 
 1, 
 'NOME TESTE 1', 
 10, 
 99.99 
) 
 
/* INSERE REGISTROS */ 
INSERT INTO DBO.TABELA_TESTE_TRIGGER 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
 -- VALOR_TOTAL (SERÁ CALCULADO POSTERIORMENTE) 
) 
VALUES 
( 
 2, 
 'NOME TESTE 2', 
 5, 
 20 
) 
 
GO 
 
/* EXIBE OS REGISTROS */ 
SELECT * FROM DBO.TABELA_TESTE_TRIGGER 
GO 
 
/* TENTA ATUALIZAR O REGISTRO */ 
UPDATE DBO.TABELA_TESTE_TRIGGER 
 SET QUANTIDADE = 1 
 WHERE CODIGO = 1 
GO 
 
/* EXIBE OS REGISTROS */ 
SELECT * FROM DBO.TABELA_TESTE_TRIGGER 
GO 
 
/* EXCLUI UM REGISTRO */ 
DELETE FROM DBO.TABELA_TESTE_TRIGGER 
 WHERE CODIGO = 1 
 
/* EXIBE OS REGISTROS */ 
SELECT * FROM DBO.TABELA_TESTE_TRIGGER 
GO 
 
/* EXIBE OS REGISTROS DAS TABELAS DE LOG */ 
SELECT * FROM DBO.TABELA_TESTE_TRIGGER_LOG 
SELECT * FROM DBO.TABELA_TESTE_TRIGGER_EXCLUIDOS 
GO 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
23 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
No script acima, foram criadas três triggers: 
 TRD_TABELA_TESTE_TRIGGER: Disparada quando um registro da referida tabela for excluído. Nesse 
momento, um registro de log será inserido na tabela TABELA_TESTE_TRIGGER_LOG com as 
informações de quem excluiu (data/hora, login do SQL, software que excluiu o registro, código do 
registro excluído, etc.). Além disso, também é feito uma cópia do registro excluído em uma tabela 
de backup (TABELA_TESTE_TRIGGER_EXCLUIDOS); 
 
 TRI_TABELA_TESTE_TRIGGER: Disparada quando um registro da referida tabela for inserido. Nesse 
momento, será calculado o valor total do registro que está sendo inserido e atualiza a respectiva 
coluna na tabela TABELA_TESTE_TRIGGER, 
 
 TRU_TABELA_TESTE_TRIGGER: Disparada quando um registro da referida tabela for atualizado e 
impedi tal ação exibindo uma mensagem de erro ao invés de atualizar o registro. 
 
É importante observar a utilização dos objetos INSERTED e DELETED dentro das triggers. 
Esses objetos são tabelas temporárias que contém os dados do registro que disparou o 
trigger, ou seja, é um recurso disponível no trigger que imita a mesma estrutura da tabela 
afetada e armazena apenas o registro que foi inserido, atualizado ou excluído na tabela.Para o trigger do tipo Insert, só haverá disponível a tabela INSERTED. Para o trigger do tipo 
Update, o INSERTED estará disponível com os novos valores atualizados no registro e 
DELETED com os valores antigos que estavam no registro. Para o trigger do tipo Delete, 
apenas haverá o DELETED. 
A trigger ficará visível no Object Explorer do MS SQL Server Management Studio dentro do 
grupo das tabelas, como mostra a Imagem 16. 
 
 
Imagem 16 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
24 
 
2.6. Tabelas temporárias e variáveis de tipo tabela 
Tabela temporária é um recurso utilizado quando há a necessidade de se armazenar os 
registros temporariamente, sendo em uma query, dentro de uma procedure, etc. O objeto 
que é criado temporariamente no banco de dados de sistema TempDB. A utilização mais 
comum desse tipo de objeto é no momento em que se precisa armazenar informações de 
várias tabelas em um único local, processar tais informações e depois exibi-las. 
Podemos ter as informações armazenadas temporariamente em 3 situações: 
 Tabela temporária local: Objeto ficará ativo apenas na sessão que a criar. Com isso, se outra tabela 
temporária de mesmo nome for criada em outra sessão do banco, não haverá erro de duplicidade 
de objeto. Com isso, assim que tal sessão for finalizada, o objeto será apagado automaticamente da 
base TempDB. Para criar este objeto, basta utilizar # antes do nome a ser dado à tabela e seguir a 
estrutura normal de criação de uma tabela. Inclusive, permite-se até a criação de índice como se 
fosse uma tabela normal. Não se recomenda a utilização desse recurso para manipular número 
excessivos de registro pois não consome os mesmos recursos do plano de execução utilizado pelo 
SQL Server (estatísticas, etc.). 
 
Veja o exemplo no script abaixo: 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_008.SQL */ 
 
/* APONTA A BASE TESTE */ 
USE BASE_TESTE 
GO 
 
/* CRIA A TABELA TEMPORÁRIA QUE SERVIRÁ PARA TESTE */ 
CREATE TABLE #TABELA_TEMP 
( 
 [CODIGO] INT PRIMARY KEY, 
 [NOME] VARCHAR(40), 
 [VALOR_UNITARIO] MONEY, 
 [QUANTIDADE] INT 
) 
GO 
 
 
/* INSERE REGISTROS */ 
INSERT INTO #TABELA_TEMP 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 1, 
 'NOME TESTE 1', 
 10, 
 99.99 
) 
 
/* INSERE REGISTROS */ 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
25 
INSERT INTO #TABELA_TEMP 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 2, 
 'NOME TESTE 2', 
 5, 
 20 
) 
 
-- EXIBE OS REGISTROS INSERIDOS 
SELECT * FROM #TABELA_TEMP 
 
-- APAGA OS REGISTROS INSERIDOS 
DELETE FROM #TABELA_TEMP 
 
-- REMOVE O OBJETO TEMPORÁRIO 
DROP TABLE #TABELA_TEMP 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
 Tabela temporária global: Objeto ficará ativo para todas as sessões do banco de dados. Com isso, se 
outra tabela temporária de mesmo nome for criada em outra sessão do banco, haverá erro de 
duplicidade de objeto. Com isso, assim que tal sessão for finalizada, o objeto não será apagado 
automaticamente da base TempDB, necessitando de um comando para remover (drop) essa tabela 
ou reiniciar a instância do banco de dados. Para criar este objeto, basta utilizar ## antes do nome a 
ser dado à tabela e seguir a estrutura normal de criação de uma tabela. Inclusive, permite-se até a 
criação de índice como se fosse uma tabela normal. Não se recomenda a utilização desse recurso 
para manipular número excessivos de registro pois não consome os mesmos recursos do plano de 
execução utilizado pelo SQL Server (estatísticas, etc.). 
 
Veja o exemplo no script abaixo: 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_009.SQL */ 
 
/* APONTA A BASE TESTE */ 
USE BASE_TESTE 
GO 
 
/* CRIA A TABELA QUE SERVIRÁ PARA TESTE */ 
CREATE TABLE ##TABELA_TEMP_GLOBAL 
( 
 [CODIGO] INT PRIMARY KEY, 
 [NOME] VARCHAR(40), 
 [VALOR_UNITARIO] MONEY, 
 [QUANTIDADE] INT 
) 
GO 
 
 
/* INSERE REGISTROS */ 
INSERT INTO ##TABELA_TEMP_GLOBAL 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
26 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 1, 
 'NOME TESTE 1', 
 10, 
 99.99 
) 
 
/* INSERE REGISTROS */ 
INSERT INTO ##TABELA_TEMP_GLOBAL 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 2, 
 'NOME TESTE 2', 
 5, 
 20 
) 
 
-- EXIBE OS REGISTROS INSERIDOS 
SELECT * FROM ##TABELA_TEMP_GLOBAL 
 
-- APAGA OS REGISTROS INSERIDOS 
DELETE FROM ##TABELA_TEMP_GLOBAL 
 
-- REMOVE O OBJETO TEMPORÁRIO 
DROP TABLE ##TABELA_TEMP_GLOBAL 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
 Varável de tipo tabela: Objeto ficará ativo apenas na sessão (bloco de script) que a criar. Com isso, 
se outra variável de mesmo nome for criada em outra sessão do banco, não haverá erro de 
duplicidade de objeto. Com isso, assim que tal sessão ou bloco de script for finalizado, o objeto será 
apagado automaticamente da base que foi criado. Para criar este objeto, basta declarar uma 
variável, colocar o tipo “TABLE” e seguir a estrutura normal de criação de uma tabela. A variável 
tabela não permite a criação de índices e não se recomenda a utilização desse recurso para 
manipular número excessivos de registro pois não consome os mesmos recursos do plano de 
execução utilizado pelo SQL Server (índices, estatísticas, etc.). 
 
Veja o exemplo no script abaixo: 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_010.SQL */ 
 
/* APONTA A BASE TESTE */ 
USE BASE_TESTE 
GO 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
27 
 
/* CRIA A TABELA QUE SERVIRÁ PARA TESTE */ 
DECLARE @TABELA_VAR TABLE 
( 
 [CODIGO] INT PRIMARY KEY, 
 [NOME] VARCHAR(40), 
 [VALOR_UNITARIO] MONEY, 
 [QUANTIDADE] INT 
) 
 
 
/* INSERE REGISTROS */ 
INSERT INTO @TABELA_VAR 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 1, 
 'NOME TESTE 1', 
 10, 
 99.99 
) 
 
/* INSERE REGISTROS */ 
INSERT INTO @TABELA_VAR 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 2, 
 'NOME TESTE 2', 
 5, 
 20 
) 
 
-- EXIBE OS REGISTROS INSERIDOS 
SELECT * FROM @TABELA_VAR 
 
-- APAGA OS REGISTROS INSERIDOS 
DELETE FROM @TABELA_VAR 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
Novidade versão SQL Server 2016: É possível, durante a instalação, informar a quantidade de arquivos 
de dados que irão compor o sistema TempDB, onde também tal quantidade pode ser associada ao 
número de processadores dedicados a instância. 
 
 
 
 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
28 
2.7. Sinônimo 
Recurso utilizado para criar um nome alternativo (apelido) para uma tabela já existente no 
banco de dados. Então, ao invés de utilizar o nome próprio do objeto, pode-se utilizar o apelido 
durante um select, update, etc. Este recurso geralmente é utilizado em integrações para 
“padronizar” tabelas semelhantes, mas que possuem nomes diferentes em bases distintas. 
Veja o exemplo a baixo. 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_011.SQL */ 
 
/* APONTA A BASE TESTE */ 
USE BASE_TESTE 
GO 
 
/* CRIA A TABELA QUE SERVIRÁ PARA TESTE */ 
CREATE TABLE TABELA_ORIGINAL 
( 
 [CODIGO] INT PRIMARY KEY, 
 [NOME] VARCHAR(40), 
 [VALOR_UNITARIO] MONEY, 
 [QUANTIDADE] INT 
) 
 
 
/* INSERE REGISTROS */ 
INSERT INTO DBO.TABELA_ORIGINAL 
( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 1, 
 'NOME TESTE 1', 
 10, 
 99.99 
) 
 
-- EXIBE OS REGISTROS INSERIDOS 
SELECT * FROM DBO.TABELA_ORIGINAL 
 
-- CRIA O SINONIMO 
CREATE SYNONYM DBO.SINONIMO_TABELA_ORIGINAL 
FOR DBO.TABELA_ORIGINAL 
 
/* INSERE REGISTROS */ 
INSERT INTO DBO.SINONIMO_TABELA_ORIGINAL( 
 CODIGO, 
 NOME, 
 VALOR_UNITARIO, 
 QUANTIDADE 
) 
VALUES 
( 
 2, 
 'NOME TESTE 2', 
 5, 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
29 
 20 
) 
 
-- EXIBE OS REGISTROS INSERIDOS 
SELECT * FROM DBO.SINONIMO_TABELA_ORIGINAL 
 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
O sinônimo ficará visível no Object Explorer do MS SQL Server Management Studio dentro do 
grupo de banco de dados, como mostra a Imagem 17. 
 
 
Imagem 17 
 
2.8. Impactos e pontos de atenção 
Uma base de dados para um ambiente altamente transacional (com inúmeros, insert, 
update, delete, select, etc.) deve buscar, via de regra, a normalização ao estremo. Senão, a 
redundância de informações causará inconsistência nos dados, espaço maior de 
armazenamento em disco além de um tempo de resposta mais elevado, tanto tempo de I/O 
de disco quanto de rede, processamento e memória. Esse conceito vale não só para 
normalização, mas também para a escolha do tipo de dados que deverá poupar ao máximo 
os bytes que serão utilizados. 
Outro ponto de atenção importante é a utilização de trigger. Deve-se evitar ao máximo a 
utilização desse recurso pois a cada movimentação de registro implica na execução do que 
está dentro da trigger e isso deixa a operação mais custosa. 
 
3. OPERADORES E CONECTORES 
 
3.1. Operadores 
São símbolos utilizados na comparação lógica entre atributos (colunas, valores fixos, etc.). Eles 
podem ser utilizados nos filtros de consultas (select), atualização (update) ou deleção (delete) 
de registros para delimitar os dados que serão contemplados por essas ações. Outro local bem 
frequente da utilização dos operadores é em procedimentos estruturados onde se faz a 
verificação lógica individual dos valores (if, while, case, etc.). 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
30 
A comparação deverá ser feita sempre entre colunas/valores de mesmo tipo. Ou seja, número 
com número, texto com texto e data com data. Deve-se preservar a regra de delimitação por 
apóstrofe quando houver comparação entre uma coluna texto/data e um valor fixo. 
Os principais operadores são: 
 = (igual): garante que a comparação só admitirá valores iguais. Exemplo: “Select * 
From CLIENTE Where ID_CLIE = 1”. Neste comando, a consulta “query” retornará 
todas as colunas e respectivos valores do cliente de código igual à 1; 
 >= (maior igual): garante que a comparação só admitirá valores maiores ou iguais. 
Exemplo: “...ID_CLIE >= 2”. Neste exemplo, o comando irá contemplar apenas 
clientes com código superior ou igual à 2, ou seja 2 e 3; 
 
 <= (menor igual): garante que a comparação só admitirá valores menores ou iguais. 
Exemplo: “...ID_CLIE <= 2”. Neste exemplo, o comando irá contemplar apenas 
clientes com código inferior ou igual à 2, ou seja 1 e 2; 
 
 > (maior): garante que a comparação só admitirá valores maiores que o indicado. 
Exemplo: “...ID_CLIE > 2”. Neste exemplo, o comando irá contemplar apenas clientes 
com código superior à 2, ou seja, 3; 
 
 < (menor): garante que a comparação só admitirá valores menores que o indicado. 
Exemplo: “...ID_CLIE < 2”. Neste exemplo, o comando irá contemplar apenas clientes 
com código inferior à 2, ou seja, 1; 
 
 <> (diferente): garante que a comparação só admitirá valores diferentes do 
indicado. Exemplo: “...ID_CLIE <> 2”. Neste exemplo, o comando irá contemplar 
apenas clientes com código diferente de 2, ou seja, 1 e 3; 
 
 In (x, y, z, ...): garante que a comparação só admitirá valores aos indicados dentro 
dos parênteses. Exemplo: “...ID_CLIE IN (2,3). Neste exemplo, o comando irá 
contemplar os clientes de código (ID_CLIE) 2 ou 3. Em alguns casos, este operador 
pode representar perda de performance e deve ser substituído por EXISTS; 
 
 Like ‘% x %’: garante que a comparação só admitirá valores que contenham o texto 
indicado. Este operador só pode ser utilizado em colunas que possuam o tipo de 
dado texto. Exemplo: “...NM_CLIE Like ‘%Teste%’”. Neste exemplo, o comando irá 
contemplar os clientes que possuam a palavra “Teste” no nome. Veja que “Teste” é 
um valor do tipo texto, então é necessário o uso do delimitador (apóstrofe); 
 
 Between x and y: garante que a comparação só admitirá valores dentro dos limites 
indicados. Exemplo: “...QN_PROD Between 10 and 20”. Neste exemplo, o comando 
irá atingir apenas itens de pedidos que tenham vendido entre (inclusive) 10 e 20 
produtos; 
 
 Is (Is Not): é um operador utilizado para comparativo de valores nulos, ou seja, 
quando se quer saber se uma determinada coluna possui um valor igual a NULL, não 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
31 
se usa o perador “=” (igual), mas sim o “is”. Ex.: “...FROM CLIENTE WHERE ID_CIDA 
IS NULL” (ou “ID_CIDA IS NOT NULL” para buscar o que não é nulo), 
 
 Exists: recurso geralmente utilizado para substituir o operador IN, possui dois 
benefícios se comparado ao seu antecessor. O primeiro é que representa melhor na 
performance e o segundo é que ele permite a comparação de uma ou mais colunas 
“chave” em uma mesma comparação. Exemplo: “...FROM CLIENTE C WHERE EXISTS 
(SELECT 1 FROM CIDADE CI WHERE CI.ID_CIDA = C.ID_CIDA)”. 
 
3.2. Conectores 
São palavras que irão ligar mais de uma condição lógica de comparação. São eles: 
 AND (E): ao unir duas ou mais condições com “and”, obrigará a necessidade de se satisfazer 
todas essas condições. Exemplo: “Select * From CLIENTE Where FL_PESSCLIE = ‘F’ And 
ID_CIDA = 1”. Neste caso, a consulta “Select” retornará os dados de todos os clientes que 
obrigatoriamente sejam pessoa física e são da cidade de Blumenau (ID_CIDA = 1), 
 
 OR (Ou): ao unir duas ou mais condições com “Or”, obrigará a necessidade de se satisfazer 
qualquer uma dessas condições. Exemplo: “Select * From CLIENTE Where FL_PESSCLIE = ‘F’ 
Or ID_CIDA = 1”. Neste caso, a consulta “Select” retornará os dados de todos os clientes que 
são pessoa física ou são da cidade de Blumenau (ID_CIDA = 1). 
Para agrupar as condições, basta colocar o “grupo” dentro de parênteses. Exemplo: “Select * 
From CLIENTE Where (FL_PESSCLIE = ‘F’ AND ID_CIDA = 1”) Or (FL_PESSCLIE = ‘J’ AND ID_CIDA = 
2”). Neste caso, a consulta “Select” retornará os dados de todos os clientes da cidade de 
Blumenau (ID_CIDA = 1) que são pessoa física Ou clientes da cidade de Bauru que são pessoa 
jurídica. Restringe-se o resultado apenas a dois grupos. 
 
4. PRINCIPAIS FUNÇÕES NATIVAS DO SQL 
O banco de dados MS SQL Server disponibiliza alguns recursos facilitadores para tratativa dos registros. 
Essas funções podem ser utilizadas nas mais diversas estruturas como, por exemplo, SELECT (consulta), 
Update, Delete, procedimentos armazenados (procedures), views, novas funções, etc. 
Diante de alguma necessidade capaz de nos impor dificuldades, sempre temos que ter em mente que a 
Microsoft já pensou nessa possibilidade e provavelmente desenvolveu algum recurso que irá auxiliar na 
resolução desse “problema”. 
Aqui serão destacadas algumas das principais funções nativas do SQL Server que são muito úteis no dia 
a dia, capazes de abrir uma nova perspectiva criando um leque de opções para agilizar e facilitar o 
desenvolvimento de Scripts T-SQL (Transact Structured Query Language). 
 
4.1. Funções simples 
Os scripts de exemplos que serão descritos a seguir, poderão ser executados em uma query. 
Para isso, abra uma nova query no MS SQL Management Studio, certifique-se que está 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
32 
conectada ao banco de dados “Base_Teste”, insira o texto (script) que se encontra após 
“Exemplo:” e o execute com (F5) ou botão “!Executar”. 
As principais funções simples são: 
 ABS(<valor numérico>): transforma um dado do tipo numérico e negativo em positivo. 
 
Exemplo: /* Anexo CA_A01_012.sql – ou copiar daqui */ SELECT ABS(-10) AS 
RESULTADO /* até aqui */ 
 
Resultado (numérico): 
 
 
 GETDATE(), SYSDATETIME(), CURRENT_TIMESTAMP: retorna a data/hora do servidor onde 
está instalado à instância (banco de dados). 
 
Exemplo: /* Anexo CA_A01_013.sql – ou copiar abaixo */ 
 SELECT GETDATE() AS DATA_HORA1, 
 SYSDATETIME() AS DATA_HORA2, 
 CURRENT_TIMESTAMP AS DATA_HORA3 
Resultado (datetime): 
 
 
 
 DATEDIFF(<escala>,<data inicial>,<data final>): calcula a diferença entre duas datas, 
podendo retornar o resultado nas escalas DAY, MONTH, YEAR, SECOND, MINUTE ou HOUR 
(dia, mês, ano, segundos, minutos ou hora). 
 
Exemplo: /* Anexo CA_A01_014.sql – ou copiar abaixo */ 
SELECT DATEDIFF(DAY, '2020-01-01 13:44:59', '2020-01-21 15:48:45') AS 
RESULTADO 
 
Resultado (numérico): 
 
 
 DATEADD(<escala>, <quantidade acrescida>, <data>): adiciona um tempo em uma data, 
podendo acrescer nas escalas DAY, MONTH, YEAR, SECOND, MINUTE ou HOUR (dia, mês, 
ano, segundos, minutos ou hora). O parâmetro <quantidade acrescida> pode receber valor 
negativo caso haja necessidade decrescer algum valor. 
 
Exemplo: /* Anexo CA_A01_015.sql - Adiciona 5 dias na data de cadastro dos 
clientes - */ 
SELECT DATEADD(MONTH, 5, C.DT_CADACLIE) AS DT_CADACLIE 
 FROM CLIENTE AS C 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
33 
Resultado (datetime): 
 
 
 ROUND(<valor>, <quantidade casas decimais>, <0 arredonda; 1 trunca>): arredondará um 
valor que possui casas decimais. 
 
Exemplo 1: /* CA_A01_016.sql - Arredonda para 3 casas decimais */ 
SELECT ROUND(10.5556, 3, 0) 
 
Resultado 1 (numérico): 
 
 
 
Exemplo 2: /* CA_A01_017.sql - Trunca (corta) na 3ª casa decimal */ 
SELECT ROUND(10.5556, 3, 1) 
 
Resultado 2 (numérico): 
 
 
 SUBSTRING(<texto>,<posição inicial>, <quantidade de caracteres copiados>): copia uma 
parte de um texto. 
 
Exemplo: /* CA_A01_018.sql - A partir da posição 9, copia os próximos 
 7 caracteres do nome dos clientes */ 
SELECT SUBSTRING(C.NM_CLIE, 9, 7) AS PARTE_NOME 
 FROM CLIENTE AS C 
 
Resultado (texto): 
 
 
 TOP(<quantidade de registros>): limita o número de registros retornados na consulta à 
quantidade estipulada. 
 
Exemplo: /* CA_A01_019.sql - Retornará apenas os 2 primeiros registros da 
consulta */ 
SELECT TOP(2) C.NM_CLIE 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
34 
 FROM CLIENTE AS C 
 
Resultado (resultset): 
 
 
 LOWER(<texto>): transforma em minúsculo todos os caracteres alfabéticos de um texto. 
 
Exemplo: /* CA_A01_020.sql - transforma em minúsculo os caracteres */ 
 SELECT TOP(1) LOWER(C.NM_CLIE) AS NM_CLIE 
 FROM CLIENTE AS C 
 
Resultado (texto): 
 
 
 UPPER(<texto>): transforma em maiúsculo todos os caracteres alfabéticos de um texto. 
Anexo “CA_A01_021.sql”. 
 
Exemplo: SELECT TOP(1) UPPER(C.NM_CLIE) AS NM_CLIE 
 FROM CLIENTE AS C 
 
Resultado (texto): 
 
 
 
 LTRIM(<texto>): remove os espaços em branco que estão à esquerda do texto. Anexo 
“CA_A01_022.sql”. 
 
Exemplo: SELECT ' Teste ' AS ORIGINAL, 
 LTRIM(' Teste ') AS RESULTADO 
 
Resultado (<texto>): 
 
 
 RTRIM(<texto>): remove os espaços em branco que estão à direita do texto. Anexo 
“CA_A01_023.sql”. 
 
Exemplo: SELECT ' Teste ' AS ORIGINAL, 
 LTRIM(' Teste ') AS RESULTADO 
 
Resultado (<texto>): 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
35 
 
 
 LEN(<texto): retorna a quantidade de caracteres de um texto. Anexo “CA_A01_024.sql”. 
 
Exemplo: SELECT LEN('teste') AS RESULTADO 
 
Resultado (numérico): 
 
 
 REPLICATE(<texto>, <quantidade de vezes>): replica um texto quantas vezes se desejar. 
Anexo “CA_A01_025.sql”. 
 
Exemplo: SELECT REPLICATE('A', 5) AS RESULTADO 
Resultado (texto): 
 
 
 CHARINDEX(<texto a ser localizado>,<texto>): busca a posição de um texto dentro de outro 
texto. Anexo “CA_A01_026.sql”. 
Exemplo: SELECT CHARINDEX('C', 'ABCDEFG') AS RESULTADO 
 
Resultado (numérico): 
 
 
 
5. INSERT 
 
A estrutura simples para inserção de registros em uma tabela é: 
INSERT INTO NOME_DA_TABELA 
(COLUNA_1, 
 COLUNA_2, 
 COLUNA_N) 
VALUES 
(VALOR_1, 
 VALOR_2, 
 'VALOR3') 
 
Ou seja, “insere na tabela X (para as colunas 1, 2, 3 – separa por vírgula –) os valores (A, B, C – também 
separa por vírgula e respeitando a formatação de cada tipo de dados –)”. 
Na prática, abra uma nova query no MS SQL Management Studio, certifique-se que está conectada ao 
banco de dados “Base_Teste”, insira o script abaixo e execute (F5) ou botão “! Executar”. Lembre-se 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
36 
que o texto em verde (dentro de /* */ ou --) é comentário e não tem impacto na 
estrutura/execução. 
 
5.1. Insert único 
Para inserção de apenas um registro por vez. 
 INSERT estruturado: deve-se indicar todas as colunas e os respectivos valores no script. 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_032.SQL */ 
 
/* APONTA O BANCO ONDE SERÃO EXECUTADOS OS SCRIPTS */ 
USE BASE_TESTE 
GO 
 
/* CRIA TABELA DE EXEMPLO */ 
CREATE TABLE DBO.TABELA_TESTE_INSERT 
( CODIGO INTEGER PRIMARY KEY NOT NULL, 
 NOME VARCHAR(40) NOT NULL, 
 DATA_CADASTRO DATETIME 
) 
GO 
 
/* INSERE O REGISTRO */ 
INSERT INTO DBO.TABELA_TESTE_INSERT 
(CODIGO, 
 NOME, 
 DATA_CADASTRO 
) 
VALUES 
(1, 
 'NOME TESTE 1', 
 GETDATE() 
) 
 
/* EXIBE O REGISTRO RECÉM INSERIDO */ 
SELECT * FROM DBO.TABELA_TESTE_INSERT 
 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
 INSERT desestruturado: não se indica as colunas da tabela no script, mas apenas os valores. Não é 
recomendado esse recurso pois, se por algum motivo a ordem das colunas dentro da tabela for 
alterada ou até mesmo removidas, os valores que serão inseridos não farão mais sentido dentro 
da estrutura. 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_033.SQL */ 
 
/* APONTA O BANCO ONDE SERÃO EXECUTADOS OS SCRIPTS */ 
USE BASE_TESTE 
GO 
 
/* INSERE O REGISTRO */ 
INSERT INTO DBO.TABELA_TESTE_INSERT 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
37 
VALUES 
(2, 
 'NOME TESTE 2', 
 GETDATE() 
) 
 
/* EXIBE O REGISTRO RECÉM INSERIDO */ 
SELECT * FROM DBO.TABELA_TESTE_INSERT 
 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
 
5.2. Insert Múltiplo 
Insere vários registros a partir de apenas um comando de Insert em sua estrutura simples. 
Para isso ser possível, após colocar os valores na cláusula “Values”, basta colocar “,” (vírgula) 
e adicionar outra sessão de valores. Veja no exemplo abaixo. 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_034.SQL */ 
 
/* APONTA O BANCO ONDE SERÃO EXECUTADOS OS SCRIPTS */ 
USE BASE_TESTE 
GO 
 
/* INSERE REGISTRO A PARTIR DE SELECT */ 
INSERT INTO DBO.TABELA_TESTE_INSERT 
(CODIGO, 
 NOME, 
 DATA_CADASTRO 
) 
VALUES 
(3, 
 'NOME TESTE 3', 
 GETDATE() 
), 
(4, 
 'NOME TESTE 4', 
 GETDATE() 
), 
(5, 
 'NOME TESTE 5', 
 GETDATE() 
) 
 
/* EXIBE OS REGISTROS DA TABELA */ 
SELECT * 
 FROM DBO.TABELA_TESTE_INSERT 
 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
5.3. Select Into 
Recurso que serve para criar uma tabela a partir de um SELECT. Neste caso, a tabela será 
criada e populada com as mesmas colunas, tipos de dados dos registros que serão 
retornados em um select. É comum a utilização desse recurso para fazer um backup da 
Curso de Banco de Dados – Plataforma: MSSQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
38 
tabela de origem antes da manipulação dos seus dados. Também comum para criar uma 
tabela consultiva a partir de um select que reúne a junção de várias tabelas. 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_034.SQL */ 
 
/* APONTA O BANCO ONDE SERÃO EXECUTADOS OS SCRIPTS */ 
USE BASE_TESTE 
GO 
 
/* CRIA TABELA A PARTIR DO SELECT */ 
SELECT CODIGO, 
 NOME 
 INTO BKP_TABELA_TESTE_INSERT 
 FROM DBO.TABELA_TESTE_INSERT 
 
 
/* EXIBE OS REGISTROS DA TABELA RECÉM CRIADA */ 
SELECT * 
 FROM DBO.BKP_TABELA_TESTE_INSERT 
 
GO 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
Novidade a partir da versão 2017 do SQL Server: Dará suporte ao carregamento de uma 
tabela em um grupo de arquivos diferente do grupo de arquivos padrão do usuário usando 
a palavra-chave ON. 
 
5.4. Insert via Select 
Insert feito em uma tabela a partir do resultado de um select. Para isso, o resultado do select 
deve retornar as mesmas colunas (ordem e tipo de dados) da tabela que receberá esses 
registros. 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> ANEXO CA_A01_035.SQL */ 
 
/* APONTA O BANCO ONDE SERÃO EXECUTADOS OS SCRIPTS */ 
USE BASE_TESTE 
GO 
 
/* INSERE REGISTRO A PARTIR DE SELECT */ 
INSERT INTO DBO.TABELA_TESTE_INSERT 
(CODIGO, 
 NOME, 
 DATA_CADASTRO 
) 
SELECT 3 AS CODIGO, 
 'NOME TESTE 3' AS NOME, 
 GETDATE() AS DATA_CADASTRO 
 
/* EXIBE OS REGISTROS DA TABELA RECÉM CRIADA */ 
SELECT * 
 FROM DBO.TABELA_TESTE_INSERT 
 
GO 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
39 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
5.5. Impactos e ponto de atenção 
É sempre importante validar à pré-existência do registro que está sendo inserido para evitar 
erros de duplicidade de registro (chave primária) e também de redundância de informação, 
ou seja, não ter a mesma informação cadastrada mais de uma vez na mesma tabela. 
Outro ponto de atenção é que se deve evitar utilizar Insert via Select, pois o Select 
aumentará o log do SQL Server bem como levará um tempo para montar seu cache de 
registros. Com isso, a tabela que receberá os valores ficará “ocupada” para as demais 
sessões enquanto a inserção dos registros não for efetivada. O recomendado é inserir 
registro a registro, ficando, então, uma sequência de comandos de insert. 
 
6. SELECT 
Abaixo veremos as principais estruturas e formas de consulta do SQL Server. 
 
6.1. Ordem de interpretação do Select 
O sistema gerenciador de banco de dados do SQL Server e de outras plataformas possuem a mesma 
sequência de interpretação da estrutura de um SELECT. Entender essa sequência é importante na 
hora de criar uma consulta e também ajuda a entender a questão de performance dentre de um 
Select. 
Então, o plano de execução interpreta a consulta seguindo a sequência: 
1. FROM TABELA1 (JOIN TABELA2, etc.) 
2. WHERE CONDIÇÃO1, CONDIÇÃO2, etc. 
3. GROUP BY COLUNA1, COLUNA2, etc. 
4. SELECT COLUNA1, COLUNA2, etc. 
5. ORDER BY COLUNA1, COLUNA2, etc. 
Por isso, por exemplo, utilizar o comando Distinct é mais custoso que o Group By, uma vez que o 
agrupamento se dá antes de trazer todo o resultado do Select. Também, na clausula Where, colocar 
por primeiro as condições que tratem de tipos de dados menores (integer, etc.) pode representar 
um desempenho melhor. 
 
6.2. Consulta simples 
Trataremos a consulta simples as consultas feitas em apenas uma tabela por vez. Via de regra, a 
consulta se inicia com o comando “SELECT” (selecionar). Após o SELECT são definidas as colunas 
que serão retornadas na seleção, sendo que essas colunas serão separadas por vírgula (quando 
mais de uma). Definidas as tabelas, vem o código “FROM” (de onde) seguido das tabelas ondem 
irão se extrair os registros. Por fim, acrescenta-se a cláusula “WHERE” (onde) que é o local onde 
estará os filtros dessa consulta. 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
40 
Exemplo da estrutura básica de seleção: 
/* Define-se as colunas que serão retornadas */ 
SELECT Coluna1, 
 Coluna2, 
 Coluna3 
/* Define-se as tabelas onde estão os dados à serem extraídos */ 
 FROM Tabela1 
/* Indica quais filtros serão aplicados */ 
 WHERE Coluna1 = 10 
 
Caso queira retornar todas as colunas da tabela consultada, basta colocar “*” ao invés do nome das 
colunas, como no exemplo abaixo: 
/* Retornará todas as colunas da tabela */ 
SELECT * 
/* Define-se as tabelas onde estão os dados à serem extraídos */ 
 FROM Tabela1 
/* Indica quais filtros serão aplicados */ 
 WHERE Coluna1 = 10 
 
O procedimento acima não é indicado, principalmente na questão de performance. Quanto maior 
a quantidade de campos a serem retornados em uma consulta, mais processamento do servidor e 
tempo de execução ela levará (além de mais informações para se trafegar na rede em uma 
estrutura cliente servidor). 
A Microsoft indica (e nós utilizaremos a partir daqui) especificar diretamente nas colunas qual a 
tabela que a mesma pertence. Para isso, basta informar a seguinte ordem 
“Nome_Da_Tabela.Nome_Da_Coluna”, como no exemplo abaixo: 
/* Define-se as colunas que serão retornadas */ 
SELECT Tabela1.Coluna1, 
 Tabela1.Coluna2, 
 Tabela1.Coluna3 
/* Define-se as tabelas onde estão os dados à serem extraídos */ 
 FROM Tabela1 
/* Indica quais filtros serão aplicados */ 
 WHERE Tabela1.Coluna1 = 10 
 
Para encurtar a digitação ou até mesmo o entendimento, é possível se criar um “Alias” (apelido) 
para a tabela e colunas, bastando definir “Nome ” + “As “ + “Apelido”, ficando: 
/* Define-se as colunas que serão retornadas */ 
SELECT T1.Coluna1 As C1, 
 T1.Coluna2 As C2, 
 T1.Coluna3 As [Coluna número três] 
 FROM Tabela1 As T1 
 WHERE T1.Coluna1 = 10 
 
Na terceira coluna a ser retornada, há um recurso (colocar entre colchetes) que permite a 
definição de um nome composto para ser o nome da coluna retornada. Porém, não é 
recomendado utilizar caracteres especiais (ç, acentos, etc.) em nome de objetos, nem tampouco 
utilizar espaço em branco (neste caso, substitui o espaço em branco por “underline/linha baixa”). 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
41 
O principal motivo são potenciais erros de integração com outras ferramentas que não 
conseguirão converter ou trabalhar com esse tipo de estrutura. 
Abra uma nova query no MS SQL Management Studio, certifique-se que está conectada ao banco 
de dados “Base_Teste”, insira o script abaixo e execute (F5) ou botão “! Executar”. 
 
/* ANTES, EXECUTAR O SCRIPT ANEXO CA_A01_000_CRIA_BASE.sql */ 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) -> Anexo CA_A01_037.sql*/ 
 
/* Retornará todos registros e todas as colunas 
 existentes na tabela "CLIENTE" */ 
SELECT * 
 FROM DBO.CLIENTE AS C 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
O resultado a ser obtido é o mesmo da Imagem 18. Onde está “SELECT *”, pode ser substituído 
por “SELECT C.*”. 
 
Imagem 18 
Apague o conteúdo anterior da query e digite o script abaixo e execute novamente: 
 
/* INÍCIO DO SCRIPT (COPIAR A PARTIR DAQUI) Anexo CA_A01_038.sql */ 
 
/* Retornará apenas três colunas na tabela "CLIENTE" */ 
SELECT C.ID_CLIE, -- Código do cliente 
 C.NM_CLIE, -- Nome do cliente 
 C.ID_CIDA -- Código da cidade do cliente 
 FROM DBO.CLIENTE AS C 
 
/* FIM DO SCRIPT (COPIAR ATÉ AQUI) */ 
 
 
O resultado a ser obtido é o mesmo da Imagem 19. 
 
 
Imagem 19 
 
Curso de Banco de Dados – Plataforma: MS SQL Server 
 
 
Por: Herbert D. Perazzelli – DBA Certificado MCSA MS SQL Server 2012 
42 
O próximo passo será aplicar os conceitos de operadores e conectores. Então, apague o conteúdo 
anterior da query e digite o script abaixo e execute novamente.