You are on page 1of 108

SQL SERVER

Rudson Kiyoshi Souza Carvalho


rudson.carvalho@gmail.com
PUBLICO ALVO

Estudantes da área de TI que desejam aprender a manipular informações em banco


de dados SQL Server.

PRÉ-REQUISITOS

Conhecimento em Lógica de Programação e noções básicas de banco de dados.

DURAÇÃO
Duração total de 40 horas divididas em 4,5 horas em 9 sábados.
Expectativa de início em ......... e término em .........

OBJETIVO
Inserir participantes do treinamento no aprendizado da linguagem SQL SERVER,
através da apresentação dos assuntos fundamentais para compreender os conceitos
básicos acerca do SQL, além da prática de exercícios simples para reforçar a teoria
e conhecer os principais comandos e ferramentas da linguagem.

INTRODUÇÃO

Este é o primeiro módulo de uma série de três, neste módulo iremos aprender os
conceitos básicos de banco de dados relacional, sua utilização e boa parte dos
recursos que o SQL Server nos disponibiliza para manipular as informações
armazenadas na base de dados.
SUMÁRIO

PUBLICO ALVO ..............................................................................2


PRÉ-REQUISITOS ..........................................................................2
DURAÇÃO.......................................................................................2
OBJETIVO.......................................................................................2
INTRODUÇÃO.................................................................................2
Capítulo 1 - Conceitos básicos........................................................7
Banco de dados.......................................................................................................................7
Modelos de Banco de Dados...................................................................................................7
Banco de dados relacional......................................................................................................9
Origem da linguagem SQL ....................................................................................................9
1.1.A linguagem Transact-SQL............................................................................................11
SQL Server Management Studio..........................................................................................12
Capítulo 2 - Alguns objetos do SQL Server ..................................13
Principais objetos do SQL Server.........................................................................................13
Databases 14
Tabelas 15
Criando a primeira Tabela....................................................................................................15
O comando Insert..................................................................................................................16
A instrução Select.................................................................................................................17
DROP TABLE Tb_Cliente...................................................................................................17
A segunda Tabela..................................................................................................................18
A terceira Tabela...................................................................................................................19
Capítulo 3 - DML Simples..............................................................20
INSERT 20
INSERT posicional...............................................................................................................21
INSERT declarativo..............................................................................................................22
SELECT 23
Exibindo todas as colunas.....................................................................................................23
Exibindo algumas colunas....................................................................................................23
Exibindo colunas utilizando alias.........................................................................................23
Exibindo colunas utilizando alias com espaço no nome.......................................................24
Criando uma coluna virtual com o comando SELECT........................................................25
Exibindo uma operação com comando SELECT.................................................................26
Exibindo apenas uma vez os dados repetidos – DISTINCT.................................................27
Copiando dados de uma tabela para outra tabela utilizando os comandos INSERT com
SELECT...............................................................................................................28
INSERT com SELECT quando as tabelas são iguais...........................................................28
INSERT com SELECT quando as tabelas são diferentes.....................................................29
29
3.3. UPDATE........................................................................................................................30
Alterando dados de uma coluna............................................................................................30
Alterando dados de varias colunas........................................................................................31
DELETE 31
Capítulo 4 - A cláusula WHERE.....................................................32
A cláusula WHERE com os operadores lógicos AND e OR................................................34
A cláusula WHERE com o operador IN...............................................................................35
A cláusula WHERE com os operadores NOT IN.................................................................36
4.1.A cláusula WHERE com o operador BETWEEN.........................................................37
A cláusula WHERE com os operadores NOT BETWEEN..................................................37
O Operador LIKE.................................................................................................................38
A cláusula WHERE com os operadores NOT LIKE............................................................40
Capítulo 5 - A Cláusula ORDER BY................................................41
ORDER BY..........................................................................................................................41
Ordenando por colunas.........................................................................................................41
Ordenando por uma coluna...................................................................................................41
Ordenando por varias colunas...............................................................................................41
5.1.ORDER BY ASC e DESC..............................................................................................41
A cláusula TOP.....................................................................................................................43
A cláusula TOP com Order By.............................................................................................44
A cláusula TOP WITH TIES com ORDER BY...................................................................44
Capítulo 6 - Integridade e Consistência dos Dados.......................46
Regras de Integridade e consistência....................................................................................46
Constraints............................................................................................................................48
Chaves primárias...................................................................................................................48
IDENTITY.....................................................................................49
49
Chaves primárias, secundárias ou chaves únicas..................................................................50
Chaves estrangeiras...............................................................................................................51
Regras de validação..............................................................................................................52
Valor Padrão.........................................................................................................................52
Valores nulos e não nulos.....................................................................................................52
Data types..............................................................................................................................53
Regras de Constraints...........................................................................................................54
Constraint DEFAULT.....................................................................54
Constraint UNIQUE.......................................................................54
Constraint CHECK.........................................................................54
Constraint PRIMARY KEY..............................................................54
Constraint FOREIGN KEY..............................................................54
Modelo entidade e relacionamento (MER)...........................................................................55
Relacionamento.....................................................................................................................56
Relacionamento 1:1..............................................................................................................56
Relacionamento 1:N..............................................................................................................56
Regras de relacionamento 1:N..............................................................................................57
Relacionamento N:N.............................................................................................................57
Regras de relacionamento N:N.............................................................................................58
Capítulo 7 - Associando Tabelas...................................................61
JOIN 61
INNER JOIN.........................................................................................................................63
LEFT JOIN...........................................................................................................................66
RIGHT JOIN.........................................................................................................................67
FULL JOIN...........................................................................................................................68
CROSS JOIN........................................................................................................................69
7.1.Os comandos UPDATE e DELETE...............................................................................71
UPDATE 73
DELETE 75
Capítulo 8 - Union e Subquery......................................................76
UNION, UNION ALL e EXCEPT.......................................................................................76
Subquery 82
Subquery introduzida com IN/NOT......................................................................................85
Subquery introduzida com o sinal de igual (=).....................................................................86
Update com Subqueries........................................................................................................87
Delete com Subqueries.........................................................................................................87
Capítulo 9 - Totalizando Dados.....................................................88
A cláusula GROUP BY........................................................................................................88
A cláusula HAVING com GROUP BY................................................................................94
A cláusula WITH ROLLUP com GROUP BY.....................................................................96
A cláusula CUBE com GROUP BY.....................................................................................97
A cláusula JOIN com GROUP BY.......................................................................................99
Capítulo 10 - Compute BY...........................................................101
10.1.COMPUTE BY com JOIN.........................................................................................102
Resumindo dados usando COMPUTE e COMPUTE BY..................................................104
As diferenças entre COMPUTE e GROUP BY .................................................................105
Capítulo 11 – Tabelas.................................................................106
Tabela permanente .............................................................................................................106
Tabela temporária Global...................................................................................................106
Capítulo 12 – Case......................................................................107
A cláusula CASE................................................................................................................107
BIBLIOGRAFICA BÁSICA............................................................109
Capítulo 1 - Conceitos básicos

Capítulo 1 - Conceitos básicos

Banco de dados

Um banco de dados é um conjunto de dados estruturados, normalmente


organizados em tabelas e armazenados de forma persistente, ou seja, não se perde
a informação ao desligar o computador.

Num banco de dados pode-se adicionar, atualizar e consultar informações, mas para
que tudo isso ocorra de maneira organizada é necessário um software que gerencie
todo este processo e garanta a integridade dos dados. Este software e denominado
SGBD - Sistema Gerenciador de Banco de Dados.

Atualmente existem diversos SGBDs no mercado, como por exemplo, DB2, Sybase,
Oracle, SQL Server, MySql, Firebird, PostGreSQL. A grande maioria destes SGBDs
possuem uma versão free que podem ser baixados do site de seus fabricantes.

A função do SGBD é estabelecer a interface entre o usuário e o banco de dados.


Isso quer dizer que usuário não tem acesso direto aos dados armazenados, mas
pode fazer uma solicitação ao SGBD que será responsável por acessar o banco de
dados e disponibilizar o resultado.

Fica evidente então que existe uma diferença entre banco de dados e SGBD, apesar
de ser comum o banco de dados ser chamado pelo mesmo nome do seu
gerenciador. Exemplificando, SQL Server é o nome do SGBD e não do banco de
dados, como é comum se pensar.

Modelos de Banco de Dados

Quando se fala de modelo de banco de dados é preciso entender que isso se refere
ao modelo conceitual de banco de dados. Um modelo conceitual é a representação
de estrutura do banco de dados. Pode comparar com a planta de uma casa ou um
mapa de estradas, pois estes apenas representam objetos do mundo real.

No caso de banco de dados, o modelo é uma representação da maneira com dados


serão armazenados.

Existem diversos tipos de modelos de banco de dados, entretanto a maior parte dos
SGBDs do mercado atual segue o modelo relacional. Tomando este modelo como
base nós podemos identificar três gerações de modelos:

7
Capítulo 1 - Conceitos básicos

1- Geração Pré-Relacional

• Sistemas Baseados em Arquivos – dados armazenados em arquivos autônomos e


sem nenhum relacionamento entre eles. Este modelo não existe SGBD e o usuário
manipula os dados diretamente.

• Modelo Hierárquico – os dados são igualmente armazenados em arquivos,


porém existe uma relação de hierarquia de pai-filho entre eles. O modelo tem
o formato de uma árvore que contem nós pai e filhos. Este é um dos primeiros
modelos com SGBD.

• Modelo em Rede – é a extensão do modelo hierárquico, pois mantém o


relacionamento eliminando o conceito de hierarquia para possibilitar que um
registro possua várias associações e eliminar problemas de redundância e
duplicação de dados.

2- Geração Relacional

• Modelo Relacional – não segue a evolução dos modelos anteriores, pois foi
criado baseado na teoria dos conjuntos, ramo da matemática que
simultaneamente simples e poderoso. A estrutura de dados utilizada é a
relação, ou seja, tabela. Uma tabela é constituída de colunas(atributo ou
campo) e linhas(registro, instância ou tupla).

3- Geração Pós-Relacional

• Modelo Orientado a Objetos – segue a mesma estrutura da orientação a


objetos em linguagens de programação. O objetivo é aproximar o
desenvolvimento das aplicações ao banco de dados. Permite a
implementação de herança, encapsulamento e polimorfismo.

• Modelo Objeto-Relacional – tem uma estrutura híbrida, pois consiste de um


SGBD relacional que também utiliza orientação a objetos. O objetivo é unir o
melhor do modelo relacional com o modelo orientado a objetos, um exemplo
de banco de dados orientado a objetos é o Jasmine da CA e também o
Prevayler.

8
Capítulo 1 - Conceitos básicos

Banco de dados relacional

A maioria dos bancos de dados baseia-se no modelo relacional de Edgar Frank


Codd no inicio dos anos 70. Embora esta teoria seja a base para o software de
banco de dados relacionais, muito poucos sistemas de gestão de bases de dados
seguem o modelo de forma restrita.

A disposição das informações em tabelas é uma das principais caracteristicas do


banco de dados relacional.

Uma tabela de banco de dados relacional possui os seguintes elementos:

• Atributos (campos): Respresentam as colunas

• Registros (dados): Representam as linhas (tuplas)

Em um banco de dados relacional, podemos utilizar diversas tabelas para manter as


informações. Essas tabelas que representam entidades podem ter suas informações
combinadas por meio de relacionamentos. Na verdade, as tabelas possuem chaves
primárias e secundárias ou estrangeiras, por meio das quais os relacionamentos são
estabelecidos.
Um dos pontos fortes do modelo relacional de banco de dados é a possibilidade de
definição de um conjunto de restrições de integridade. Estas definem os conjuntos
de estados e mudanças de estado consistentes do banco de dados, determinando
os valores que podem e os que não podem ser armazenados.

Origem da linguagem SQL

Structured Query Language, ou Linguagem de Consulta Estruturada ou SQL, é


uma linguagem de pesquisa declarativa para banco de dados relacional (base de
dados relacional). Muitas das características originais do SQL foram inspiradas na
álgebra relacional.

A linguagem SQL foi desenvolvida originalmente no início dos anos 70 nos


laboratórios da IBM em San Jose, dentro do projeto System R, que tinha por objetivo
demonstrar a viabilidade da implementação do modelo relacional proposto por E. F.
Codd. O nome original da linguagem era SEQUEL, acrônimo para "Structured
English Query Language" (Linguagem de Consulta Estruturada em Inglês) [1], vindo
daí o fato de, até hoje, a sigla, em inglês, ser comumente pronunciada "síquel" ao
invés de "és-kiú-él", letra a letra. No entanto, em português, a pronúncia mais
corrente é a letra a letra: "ése-quê-éle".

9
Capítulo 1 - Conceitos básicos

A linguagem SQL é um grande padrão de banco de dados. Isto decorre da sua


simplicidade e facilidade de uso. Ela se diferencia de outras linguagens de consulta
a banco de dados no sentido em que uma consulta SQL especifica a forma do
resultado e não o caminho para chegar a ele. Ela é uma linguagem declarativa em
oposição a outras linguagens procedurais. Isto reduz o ciclo de aprendizado
daqueles que se iniciam na linguagem.

Embora o SQL tenha sido originalmente criado pela IBM, rapidamente surgiram
vários "dialetos" desenvolvidos por outros produtores. Essa expansão levou à
necessidade de ser criado e adaptado um padrão para a linguagem. Esta tarefa foi
realizada pela American National Standards Institute (ANSI) em 1986 e ISO em
1987.

O SQL foi revisto em 1992 e a esta versão foi dado o nome de SQL-92. Foi revisto
novamente em 1999 e 2003 para se tornar SQL:1999 (SQL3) e SQL:2003,
respectivamente. O SQL:1999 usa expressões regulares de emparelhamento,
queries recursivas e gatilhos (triggers). Também foi feita uma adição controversa de
tipos não-escalados e algumas características de orientação a objeto. O SQL:2003
introduz características relacionadas ao XML, seqüências padronizadas e colunas
com valores de auto-generalização (inclusive colunas-identidade).

Tal como dito anteriormente, o SQL, embora padronizado pela ANSI e ISO, possui
muitas variações e extensões produzidos pelos diferentes fabricantes de sistemas
gerenciadores de bases de dados. Tipicamente a linguagem pode ser migrada de
plataforma para plataforma sem mudanças estruturais principais.

Os padrões da SQL:

Ano Nome Conhecido como Mudanças


SQL-87 Primeira publicação do padrão ANSI/ISO
1986 SQL-86 (Adotado pela ISO)
1989 SQL-89 Apenas uma pequena versão do padrão original
Maior atualização do padrão original e ainda
1992 SQL-92 SQL2
suportando os padrões originais
Atualização do padrão acrescentado em 1992 e novas
formas de selecionar os dados, e aplicada novas
1999 SQL99 SQL3
regras de integridade dos dados e a introdução da
orientação a objetos.
Introduzido suporte a XML e campos de valores auto
2003 SQL-2003
geráveis.

10
Capítulo 1 - Conceitos básicos

1.1. A linguagem Transact-SQL

A linguagem Transact-SQL é subdividida em três grupos de comandos:

Data Definition Language (DDL)

• CREATE TABLE - Criar uma nova tabela no banco de dados


• ALTER TABLE – alterar uma tabela do banco de dados
• DROP TABLE – excluir uma tabela do banco de dados
• CREATE INDEX – criar index na tabela do banco de dados
• DROP INDEX – excluir index da tabela

Data Manipulation Language (DML)

• SELECT – extrair dados do banco de dados

• UPDATE – alterar dados do banco de dados

• DELETE – apagar dados do banco de dados

• INSERT INTO – inserir novos dados no banco de dados

Data Control Language (DCL)

• GRANT – permitir privilégios aos usuários do banco de dados

• REVOKE – revogar privilégios aos usuários do banco de dados

• DENY – negar permissão de acesso aos usuários do banco de dados

Estes comandos são relativamente simples o que pode levar algumas pessoas a
acharem que é extremamente simples manipular informações em uma base de
dados, e que qualquer um pode ser um DBA, mas a história não é bem essa, estes
comandos possuem clausulas que podem tornar um comando SQL muito complexo,
maior ainda se realizado em ambientes onde aplicações acessam e alteram
informações o tempo todo, a linguagem SQL é muito poderosa, mas só com ela não
se pode construir uma aplicação completa, pois a SQL não possui instruções para
construção de programas, por este motivo a Microsoft criou a linguagem Transact-
SQL, para que funcione os comandos SQL em conjunto com uma linguagem
procedural.

11
Capítulo 1 - Conceitos básicos

SQL Server Management Studio

O SQL Server Management Studio é um ambiente de desenvolvimento integrado


para acessar, configurar, gerenciar e desenvolver todos os componentes do SQL
Server. O SQL Server Management Studio combina um amplo grupo de
ferramentas gráficas com editores de scripts sofisticados para fornecer acesso ao
SQL Server para desenvolvedores e administradores de todos os níveis de
conhecimento.

O SQL Server Management Studio combina os recursos do Enterprise Manager,


Query Analyzer e Analysis Manager, incluídos em versões anteriores do SQL
Server, em um único ambiente. Além disso, o SQL Server Management Studio
trabalha com todos os componentes do SQL Server, como Reporting Services,
Integration Services e SQL Server Compact 3.5 SP1.

O SQL Management Studio é compatível com qualquer versão do SQL Server.

Ambiente SQL Server 2005 Express

12
Capítulo 3 – DML Simples

Capítulo 2 - Alguns objetos do SQL Server

Principais objetos do SQL Server

Um banco de dados é composto de objetos, índices, tipos de dados e restrições:


Cada objeto tem uma linha correspondente na tabela sysobjects. Seu tamanho
mínimo é 1Mb.

• Database – É uma estrutura que contém todos os outros objetos. Por


padrão é formado por dois arquivos: um de dados (com extensão .MDF) e
um de log (com extensão LDF).

• Table – Todos os dados do sistema são inclusos em tabelas, formado por


linhas e colunas e estas tabelas ficam armazenadas no Database.

• Constraint, Default e Rule – Estes objetos, consistem em regras utilizadas


para manter a consistência e a integridade dos dados no Database.

• Data Type e User Defined Data Type – Os dados são armazenados no


disco sob um formato representado pelo datatype. Um datatype deverá ser
atribuído a cada coluna de uma tabela.

• View – Representa uma seleção de dados em uma ou mais tabelas.

• Index – São responsáveis pela otimização de acesso aos dados de uma


tabela utilizando a estrutura de busca B-Tree.

• Procedure – Bloco de comandos Transact-SQL, responsável por uma


determinada tarefa. Sua lógica pode ser compartilhada por varias
aplicações.

• Trigger – Bloco de comandos Transact-SQL. O objeto trigger é criado


sobre uma tabela e é ativado no momento da execução de instruções como
update, insert e delete.

• Function – Bloco de comandos Transact-SQL, responsável por uma


determinada tarefa. Sua lógica pode ser compartilhada por várias
aplicações. Vale lembrar que uma função sempre retornara um tipo de
valor.

Obs. Os objetos procedure, trigger e function são processados mais rapidamente,


pois seu código fica compilado na memória do servidor.

13
Capítulo 3 – DML Simples

Databases

Os objetos que fazem parte de um sistema de banco de dados são criados dentro de
um database, uma estrutura lógica composta por dois tipos de arquivos, um
responsável por manter a estrutura de tabelas com seus dados e outro responsável
pelo armazenamento de Transactionlog, ou seja, é armazenado todas as transações
efetuadas.

Para criarmos um banco de dados no SQL Server 2005, utilizamos à instrução:

CREATE DATABASE

Por exemplo, para criarmos uma base de dados com o nome de DB_ESTUDO,
utilizamos a seguinte instrução: CREATE DATABASE DB_ESTUDO.

CREATE DATABASE DB_ESTUDO

Quando um banco de dados é criado o mesmo encontra-se vazio, até que uma
tabela seja inserida, no entanto para criarmos uma tabela no banco de dados
precisamos ter acesso a ele, para utilizarmos um banco de dados utilizamos a
clausula use, então executaremos a seguinte instrução:

USE <NOME DO BANCO DE DADOS>

Seguindo o nosso exemplo a instrução ficaria assim: “USE DB_ESTUDO”.

14
Capítulo 3 – DML Simples

Dessa forma, quando for necessário executar alguma instrução em uma


determinada base de dados podemos alternar entre as bases utilizando o comando
“use”.

Caso seja necessário eliminar uma base de dados, devemos utilizar a instrução
drop database.

DROP DATABASE <NOME DA BASE DE DADOS>

Conforme o exemplo: “DROP DATABASE DB_ESTUDO”

Tabelas

Uma tabela é um objeto de banco de dados formada por um conjunto de linhas e


colunas, cada uma dessas colunas refere-se a um atributo associado a tabela que
também chamamos de entidade, os datatypes, ou seja o formato do dado gravado
devera ser especificado para cada coluna

Para criarmos uma tabela utilizamos a instrução:

CREATE TABLE

Criando a primeira Tabela

Neste exemplo temos uma tabela chamada Tb_Cliente.

inCod_Cli vcNome_Cli
1 Marina Farina
2 Edson Mendes
3 Aline Moda
4 Tatiana Souza
5 Cássio Adriano

Iremos criá-la em nossa base de dados DB_Estudo para isso caso você tenha
excluído a base de dados será necessário recriá-la e utilizar a instrução “use” para
acessarmos a base de dados onde iremos criar nossa primeira tabela.

15
Capítulo 3 – DML Simples

Na base de dados db_estudo executaremos a seguinte instrução:

CREATE TABLE Tb_Cliente


(
inCod_Cli int
,vcNome_Cli varchar(30)
)

CREATE TABLE Tb_Cliente

O comando Insert

Para acrescentarmos linhas em uma tabela, é necessário utilizarmos o comando


INSERT.

insert into tb_cliente values (1,'Marina Farina')


insert into tb_cliente values (2,'Edson Mendes')
insert into tb_cliente values (3,'Aline Moda')
insert into tb_cliente values (4,'Tatiane Souza')
insert into tb_cliente values (5,'Cássio Adriano')

É importante lembrar que os apóstrofos (‘) devem ser utilizados em strings e


caracteres, com exceção de dados numéricos; Os valores de cada coluna por sua
vez, devem ser separados por vírgulas.

Obs. No SQL 7 e Access é obrigatório usar a clausula “into”, a partir do SQL 2000 e
superior está clausula não é mais obrigatória.

16
Capítulo 3 – DML Simples

A instrução Select

Os dados em uma tabela podem ser lidos através da instrução SELECT.

Por exemplo, para lermos os dados da tabela Tb_Clientes que criamos utilizamos a
instrução:

SELECT * FROM Tb_Clientes

SELECT * FROM Tb_Clientes

O asterisco (*) significa que queremos trazer todas as colunas da tabela Cliente.

Caso seja necessário removermos uma tabela do banco de dados, devemos


executar a seguinte instrução:

DROP TABLE Tb_Cliente

17
Capítulo 3 – DML Simples

A segunda Tabela

Agora, devemos criar a tabela cliente com diferentes dados, com e-mail e endereço,
de modo que ela seja exibida da seguinte maneira:

incod_Cli vcNome_Cli vcEnd_Cli chFone_Cli vcEmail_Cli


1 Marina Farina R Campos, 299 3211-1563 mari@blue.com
2 Edson Mendes Av. Paulista, 277 5125-2000 emendes@tree.com
3 Aline Moda Al. Santos, 512 4116-1518 amoda@estilo.com
4 Tatiana Souza Av. Rebouças, 15 9985-0965 tsouza@comp.com
5 Cássio Adriano Av. 9 de julho, 60 5465-1358 cadriano@tetra.com

Criaremos está tabela no banco de dados DB_Estudo

use DB_Estudo
create table tb_cliente
(
inCod_cli int
,vcNome_cli varchar(30)
,vcEnd_cli varchar(30)
,chFone_cli char(11)
,vcEmail_cli varChar(30)
)

Assim que a tabela cliente é criada devemos inserir os dados apresentados


anteriormente, para isso será necessário executar as seguintes instruções:

insert tb_cliente
values(1,'Marina Farina','R Campos, 299','3211-1563','mari@blue.com')
insert tb_cliente
values(2,'Edson Mendes','Av. Paulista, 277','5125-2000','emendes@tree.com')
insert tb_cliente
values(3,'Aline Moda','Al. Santos, 512','4116-1518','amoda@estilo.com')
insert tb_cliente
values(4,'Tatiana Souza','Av. Rebouças, 15','9985-0965','tsouza@comp.com')
insert tb_cliente
values(5,'Cássio Adriano','Av. 9 de julho, 60','5465-1358','cadriano@tetra.com')

Feito isso será necessário executar o comando SELECT para visualizarmos os


dados inseridos na tabela.

Select * from tb_cliente

Finalmente podemos finalizar este script e partir para o próximo, mas antes
eliminaremos está tabela através da instrução:

DROP TABLE tb_cliente

18
Capítulo 3 – DML Simples

A terceira Tabela

Neste próximo exemplo iremos inserir dados referentes ao salário e a data que o
funcionário foi registrado, para isso, utilize o datatype decimal e o datatype datetime.

O tipo decimal necessita de dois parâmetros separados por vírgula para identificar a
parte inteira e qual será a parte decimal como (10,2),
Durante a inclusão dos dados decimais, o ponto (.) deverá ser utilizado como
separador de casas decimais.

O tipo datetime é baseado no padrão norte-americano, ou seja, os valores devem


atender ao modelo mm/dd/aaaa. O sinal de apostrofo (‘) também deve ser utilizado
para indicar o começo e o final de cada data. A barra obliqua é necessária para a
separação dos valores referentes ao mês, dia e ano.

inCod_Cli vcNome_Cli vcEnd_Cli chFone_Cli vcEmail_Cli dcSal_Cli dtData_Cli


Marina R Campos,
1 3211-1563 mari@blue.com 1800.00 04/15/2008
Farina 299
Edson Av. Paulista,
2 5125-2000 emendes@tree.com 1210.10 03/20/2007
Mendes 277
Al. Santos,
3 Aline Moda 4116-1518 amoda@estilo.com 2000.00 08/28/2006
512
Av.
Tatiana
4 Rebouças, 9985-0965 tsouza@comp.com 1500.30 05/01/2004
Souza
15
Cássio
5 Av. 9 de julho 5465-1358 cadriano@tetra.com 1945.88 24/06/2005
Adriano

use db_estudo
create table tb_cliente
(
inCod_cli int
, vcNome_cli varchar(30)
, vcEnd_cli varchar(30)
, chFone_cli char(11)
, vcEmail_cli varChar(30)
, dcSal_cli decimal(10,2)
, dtData_cli datetime
)
Depois de criada a tabela adicione os dados:

insert tb_cliente values(1,'Marina Farina','R Campos, 299','3211-


1563','mari@blue.com',1800.00,'15/04/2008')
insert tb_cliente values(2,'Edson Mendes','Av. Paulista, 277','5125-
2000','emendes@tree.com',1210.10,'20/03/2007')
insert tb_cliente values(3,'Aline Moda','Al. Santos, 512','4116-
1518','amoda@estilo.com',2000.00,'28/08/2006')
insert tb_cliente values(4,'Tatiana Souza','Av. Rebouças, 15','9985-
0965','tsouza@comp.com',1500.30,'05/01/2004')
insert tb_cliente values(5,'Cássio Adriano','Av. 9 de julho, 60','5465-
1358','cadriano@tetra.com',1945.88,'24/06/2005')

19
Capítulo 3 – DML Simples

Capítulo 3 - DML Simples

Os comandos DML (Data Manipulation Language - Linguagem de Manipulação de


Dados) é um subconjunto da linguagem usada para selecionar, inserir, atualizar e
apagar dados, por meio destes comandos, essas tarefas podem ser executadas em
vários registros ao mesmo tempo.

• INSERT é usada para somar uma fila (formalmente uma tupla) a uma tabela
existente.
• SELECT é o comumente mais usado do DML, comanda e permite ao usuário
especificar uma query como uma descrição do resultado desejado. A questão
não especifica como os resultados deveriam ser localizados.
• UPDATE para mudar os valores de dados em uma fila de tabela existente.
• DELETE permite remover filas existentes de uma tabela.

INSERT

A instrução INSERT é utilizada para adicionar registros em uma tabela de um banco


de dados.

INSERT [INTO] <NomeTabela> VALUES(<valores>)

INSERT [INTO] <NomeTabela> (coluna1, coluna2,..colunaN)


VALUES (valor1, valor2, ..., valorN)

Os valores descritos junto ao comando INSERT são transformados em uma ou mais


linhas da tabela. Os nomes das colunas nas quais os dados serão inseridos devem
ser separados por vírgulas.

As colunas que não foram declaradas no comando INSERT podem apresentar um


valor padrão caso essa definição seja configurada na tabela, ou simplesmente o
valor NULL.

Obs. No SQL 7 é obrigatório utilizar a cláusula INTO na instrução de INSERT, no


SQL SERVER 2000 ou superior, está cláusula não é mais obrigatória.

20
Capítulo 3 – DML Simples

Para compreendermos o uso do INSERT, consideremos o exemplo a seguir.

INSERT posicional

A instrução INSERT posicional deve ser utilizada quando queremos inserir


dados de acordo com a ordem física das colunas da tabela.
Exemplo:

INSERT Tb_Cliente
VALUES (1,'Marcos Evangel','Rua 1','3515-2119','mEva@free.com','4500.26','10/15/02')

INSERT Tb_Cliente
VALUES (2,'Adalberto Bacili','Rua 2','3288-1563','aBaci@free.com','5600.38','10/20/03')

INSERT Tb_Cliente
VALUES (3,'Sérgio Manoel','Rua São Bento','4545-1212','sMano@free.com','4982.74','01/25/04')

INSERT Tb_Cliente
VALUES (4,'Thiago Hawano','Rua Direta','7875-1520','tHawa@free.com','6423.12','02/14/06')

INSERT Tb_Cliente
VALUES (5,'Carina Tugues','Rua Torta ','3132-3113','cTugue@free.com','6800.98','01/13/98')

INSERT Tb_Cliente
VALUES (6,'Fabio Monte','Av. Santos','2526-1515','fMonte@free.com','4678.15','06/25/92')

21
Capítulo 3 – DML Simples

INSERT declarativo

O INSERT declarativo deve ser utilizado quando queremos incluir dados na


tabela de modo que possamos definir uma ordem em que tais valores serão
adicionados.
Exemplo:

INSERT INTO Tb_Cliente (inCod_cli, vcNome_cli, vcEnd_Cli, vcFone_cli, vcEmail_cli,


dcSal_cli, dtDAta_cli)
VALUES (1,'Marcos Evangel','Rua 1','3515-2119','mEva@free.com','4500.26','10/15/02')

INSERT INTO Tb_Cliente ( inCod_cli


, vcNome_cli
, vcEnd_Cli
, vcFone_cli
, vcEmail_cli
, dcSal_cli
, dtDAta_cli
)
VALUES (2,'Adalberto Bacili','Rua 2','3288-1563','aBaci@free.com','5600.38','10/20/03')

INSERT INTO Tb_Cliente ( inCod_cli


, vcNome_cli
, vcEnd_Cli
, vcFone_cli
, vcEmail_cli
, dcSal_cli
, dtDAta_cli
)
VALUES ( 3
, 'Sérgio Manoel'
, 'Rua São Bento'
, '4545-1212'
, 'sMano@free.com'
, '4982.74'
, '01/25/04'
)

Obs. As três estruturas estão corretas, neste exemplo apenas estruturei as instruções de
formas diferentes para ilustrar algumas maneiras de organizar a instrução, lembrando
que para executarmos uma instrução, temos de selecionar todo o comando referente a
mesma.

22
Capítulo 3 – DML Simples

SELECT

Esta sem duvidas é a instrução SQL mais importante e mais utilizada na


linguagem SQL para a realização de consultas a dados. Por meio desta instrução
podemos retornar dados para outros comandos SQL e outras aplicações.

Para compreendermos o uso do SELECT, consideremos o exemplo a seguir.

Exibindo todas as colunas

Para que todos os dados contidos dentro da tabela cliente sejam exibidos,
devemos utilizar o seguinte comando:

SELECT * FROM Tb_Cliente

Com a utilização do comando ( * ), os dados são exibidos na mesma ordem


em que foram criados na tabela Cliente.

Exibindo algumas colunas

Para exibirmos apenas os dados de algumas colunas da tabela de clientes,


devemos substituir o ( * ) pelos nomes das colunas da tabela.

SELECT vcNome_cli, vcEnd_cli, vcEmail_cli FROM Tb_Cliente

Exibindo colunas utilizando alias

Podemos substituir o nome de uma coluna por um alias (apelido), para


facilitarmos a visualização.

SELECT vcNome_cli AS Nome_Cliente


, vcEnd_cli AS Endereco_Cliente
, vcEmail_cli AS Email_Cliente
FROM Tb_Cliente

23
Capítulo 3 – DML Simples

Não é necessário utilizar à cláusula AS para colocarmos um apelido nas


colunas da tabela, mas muitos usuários, preferem manter a cláusula AS para
facilitar a identificação do apelido.

SELECT vcNome_cli Nome_Cliente


, vcEnd_cli Endereco_Cliente
, vcEmail_cli Email_Cliente
FROM Tb_Cliente

Existe também outra maneira de se utilizar os apelidos de colunas, como


mostra o exemplo a seguir:

SELECT Nome_Cliente = vcNome_cli


, Endereco_Cliente = vcEnd_cli
, Email_Cliente = vcEmail_cli
FROM Tb_Cliente

Exibindo colunas utilizando alias com espaço no nome

Para utilizarmos espaços em branco em apelidos de colunas, devemos fazer


o uso dos colchetes [Nome Cliente], vejamos alguns exemplos:

SELECT vcNome_cli AS [Nome Cliente]


, vcEnd_cli AS [Endereco Cliente]
, vcEmail_cli AS [Email Cliente]
FROM Tb_Cliente

SELECT vcNome_cli [Nome Cliente]


, vcEnd_cli [Endereco Cliente]
, vcEmail_cli [Email Cliente]
FROM Tb_Cliente

SELECT[Nome Cliente] = vcNome_cli


, [Endereco Cliente] = vcEnd_cli
, [Email Cliente] = vcEmail_cli
FROM Tb_Cliente

24
Capítulo 3 – DML Simples

Criando uma coluna virtual com o comando SELECT

Quando utilizamos uma instrução SELECT não necessariamente podemos


exibir apenas as colunas existentes em uma tabela, podemos apresentar
colunas que não existe na tabela para, por exemplo, descrever uma situação
em relação aos dados listados. No exemplo a seguir a coluna Tipo de Cliente
não faz parte do banco de dados, mas podemos incluí-la em uma consulta
para retornarmos alguma descrição sobre os dados, vejamos o exemplo

SELECT vcNome_cli AS [Nome Cliente]


, vcEnd_cli AS [Endereco Cliente]
, vcEmail_cli AS [Email Cliente]
,’Ex-aluno’ AS [Tipo de Cliente]
FROM Tb_Cliente

SELECT vcNome_cli [Nome Cliente]


, vcEnd_cli [Endereco Cliente]
, vcEmail_cli [Email Cliente]
,’Ex-aluno’ [Tipo de Cliente]
FROM Tb_Cliente

SELECT [Nome Cliente] = vcNome_cli


, [Endereco Cliente] = vcEnd_cli
, [Email Cliente] = vcEmail_cli
, [Tipo de Cliente] = ’Ex-aluno’
FROM Tb_Cliente

25
Capítulo 3 – DML Simples

Exibindo uma operação com comando SELECT

Algumas vezes necessitamos exibir alguns dados que não existem em uma
tabela, como por exemplo, se quisermos exibir um aumento de 10% no salário
de cada cliente. Desejamos exibir esta informação, mas não queremos salvar
esta informação na tabela. Vejamos o exemplo:

SELECT vcNome_cli AS [Nome Cliente]


, vcEnd_cli AS [Endereco Cliente]
, vcEmail_cli AS [Email Cliente]
,’Ex-aluno’ AS [Tipo de Cliente]
,dcSal_cli AS [Salário do Cliente]
,dcSal_cli * 1.1 AS [Salário com 10% de aumento]
FROM Tb_Cliente

SELECT vcNome_cli [Nome Cliente]


, vcEnd_cli [Endereco Cliente]
, vcEmail_cli [Email Cliente]
,’Ex-aluno’ [Tipo de Cliente]
,dcSal_cli [Salário do Cliente]
,dcSal_cli * 1.1 [Salário com 10% de aumento]
FROM Tb_Cliente

SELECT [Nome Cliente] = vcNome_cli


, [Endereco Cliente] = vcEnd_cli
, [Email Cliente] = vcEmail_cli
, [Tipo de Cliente] = ’Ex-aluno’
, [Salário do Cliente] = dcSal_cli
, [Salário com 10% de aumento] = dcSal_cli * 1.1
FROM Tb_Cliente

26
Capítulo 3 – DML Simples

Exibindo apenas uma vez os dados repetidos – DISTINCT

Conforme a tabela abaixo o cliente Fabio Monte foi adicionado duas vezes na
tabela de cadastro de cliente, mas desejamos exibir apenas uma vez cada
registro.

Ao listarmos os dados de Nome de cliente e data de Cadastro teremos o


cliente Fabio Monte aparecera duas vezes como no exemplo abaixo:

SELECT vcNome_cli, dtData_cl


FROM Tb_Cliente

Para que os registros repetidos não sejam exibidos, devemos utilizar a


cláusula DISTINCT junto como comando SELECT, como mostra a instrução
a seguir:

SELECT DISTINCT vcNome_cli, dtData_cli


FROM Tb_Cliente

27
Capítulo 3 – DML Simples

Copiando dados de uma tabela para outra tabela utilizando os comandos


INSERT com SELECT

Para copiarmos dados de uma tabela para outra, precisamos que a estrutura
das tabelas seja similar, ou se diferentes, que a tornemos similares por meio
da instrução SELECT.

INSERT com SELECT quando as tabelas são iguais

Para este exemplo, criaremos duas tabelas com estruturas idênticas, mas
representando entidades diferentes.
CREATE TABLE tb_cliente
(
inCod_cli int
, vcNome_cli varchar(30)
, vcEnd_cli varchar(30)
, chFone_cli char(11)
, vcEmail_cli varChar(30)
, dcSal_cli decimal(10,2)
, dtData_cli datetime
)

CREATE TABLE tb_funcionario


(
inCod_fun int
, vcNome_fun varchar(30)
, vcEnd_fun varchar(30)
, chFone_fun char(11)
, vcEmail_fun varChar(30)
, dcSal_fun decimal(10,2)
, dtData_fun datetime
)

Os dados já estão disponíveis na tabela de cliente, mas queremos copiá-los


para a tabela de funcionários. Como ambas possuem a mesma quantidade de
colunas e o mesmo tipo de dados em cada coluna e uma seqüência idêntica,
podemos utilizar a seguinte instrução:

INSERT INTO tb_funcionario INSERT tb_funcionario


SELECT * FROM tb_cliente SELECT * FROM tb_cliente

28
Capítulo 3 – DML Simples

INSERT com SELECT quando as tabelas são diferentes

Para este exemplo, criaremos duas tabelas com estruturas idênticas, mas
representando entidades diferentes.

CREATE TABLE tb_cliente CREATE TABLE tb_funcionario


( (
inCod_cli int inCod_fun int
, vcNome_cli varchar(30) , vcNome_fun varchar(30)
, vcEnd_cli varchar(30) , vcEnd_fun varchar(30)
, dtData_cli datetime , chFone_fun char(11)
) , vcEmail_fun varChar(30)
, dcSal_fun decimal(10,2)
, dtData_fun datetime
)

Embora a tabela de cliente contenha alguns registros, nem todas as


colunas existentes em funcionário, existem na tabela de clientes. Para
que seja possível copiar dados de cliente para funcionário, devemos
utilizar a instrução SELECT com as colunas virtuais, como no exemplo
abaixo:

INSERT INTO Tb_funcionario INSERT Tb_funcionario


SELECT inCod_cli SELECT inCod_cli
, vcNome_cli , vcNome_cli
, vcEnd_cli , vcEnd_cli
, ’0000-0000’ , ’0000-0000’
, ‘Não tem e-mail’ , ‘Não tem e-mail’
,0 ,0
,dtData_cli ,dtData_cli
FROM tb_cliente FROM tb_cliente

Dessa forma a tabela de funcionário terá os seguintes registros:

29
Capítulo 3 – DML Simples

3.3. UPDATE

Os registros de cada tabela podem ser alterados por meio do comando UPDATE,
por exemplo, por meio deste comando podemos aumentar o valor do salário de
todos os clientes em 5%.
Para utilizarmos esta instrução precisamos, especificar algumas informações.
Como o nome da tabela que será atualizada e as colunas que sofrerão a
alteração

Para compreendermos o uso do UPDATE, consideremos o exemplo a seguir.

Alterando dados de uma coluna

Para alterarmos apenas os dados da coluna dcSal_cli devemos utilizar a


seguinte instrução:

UPDATE Tb_cliente
SET dc_Sal_cli = dc_Sal_cli * 1.05

Após executarmos este comando os registros apareceram da seguinte forma:

30
Capítulo 3 – DML Simples

Alterando dados de varias colunas

Para alterarmos os dados de diferentes colunas da tabela devemos


especificar o nome das colunas separadas por vírgula.

UPDATE Tb_cliente UPDATE Tb_cliente


SET dc_Sal_cli = dc_Sal_cli * 1.05 SET dc_Sal_cli = dc_Sal_cli * 1.05
, dtData_cli = dtData_cli + 1 , dtData_cli = dtData_cli + 1
FROM Tb_cliente

Além de alterarmos o salário dos clientes, estamos somando 1 dia a mais na


data de cadastro dos clientes.

DELETE

A instrução DELETE deve ser utilizado quando desejamos eliminar dados de


uma tabela.

Por exemplo:

DELETE Tb_cliente DELETE FROM Tb_cliente

Obs. Caso alguma linha não possa ser removida da tabela, nenhum dado será
eliminado.

31
Capítulo 4 - A cláusula WHERE

Capítulo 4 - A cláusula WHERE

A cláusula WHERE é uma parte opcional da instrução SELECT, DELETE e da


instrução UPDATE. A cláusula WHERE permite selecionar linhas baseado em uma
expressão booleana. Somente as linhas para as quais a expressão é avaliada como
TRUE são retornadas no resultado, ou no caso da instrução DELETE, excluídas, ou
no caso da instrução UPDATE, atualizadas.

Utilizaremos a seguinte tabela de produtos para trabalharmos com a cláusula WHERE.

CREATE TABLE tb_Produto


( inCod_Prod int
, vcNome_Prod varchar(50)
, vcTipo_Prod varchar(50)
, inQtd_Prod int
, dcValor_Prod decimal(10,2)
)
GO
INSERT INTO tb_Produto
VALUES(1,'Teclado','Informática',100,150.00)
INSERT INTO tb_Produto
VALUES(2,'Mouse','Informática',300,45.00)
INSERT INTO tb_Produto
VALUES(3,'Filmadora Digital','Digitais',500,2500.00)
INSERT INTO tb_Produto
VALUES(4,'Celular','Telefones',1000,1500.00)
INSERT INTO tb_Produto
VALUES(5,'DVD Player','Eletrônicos',150,150.00)
INSERT INTO tb_Produto
VALUES(6,'Caixas de Som','Informática',20,80.00)
INSERT INTO tb_Produto
VALUES(7,'Televisor','Digitais',50,25000.00)
INSERT INTO tb_Produto
VALUES(8,'Régua','Escritório',180,10.00)
INSERT INTO tb_Produto
VALUES(9,'CD','Informática',320,1.50)
INSERT INTO tb_Produto
VALUES(10,'DVD','Informática',500,3.50)

32
Capítulo 4 - A cláusula WHERE

Exemplo 1: Alteração linha Exemplo 2: Seleção Exemplo 3: Apagar


linha
UPDATE tb_Produto SELECT * FROM tb_Produto DELETE FROM tb_produto
SET dcValor_Prod = dcValor_Prod *1.1 WHERE vcTipo_Prod = ‘Informática’ WHERE inCod_Prod = 8
WHERE vcTipo_Prod = 'Informática'

Exemplos:

Exemplo 1: Alteração linha

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 165.00
2 Mouse Informática 300 49.50
3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 150.00
6 Caixas de Som Informática 20 88.00
7 Televisor Digitais 50 25000.00
8 Régua Escritório 180 10.00
9 CD Informática 320 1.65
10 DVD Informática 500 3.85

Exemplo 2: Seleção

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 165.00
2 Mouse Informática 300 49.50
6 Caixas de Som Informática 20 88.00
9 CD Informática 320 1.65
10 DVD Informática 500 3.85

33
Capítulo 4 - A cláusula WHERE

Exemplo 3: Apagar linha

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 165.00
2 Mouse Informática 300 49.50
3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 150.00
6 Caixas de Som Informática 20 88.00
7 Televisor Digitais 50 25000.00
9 CD Informática 320 1.65
10 DVD Informática 500 3.85

A cláusula WHERE com os operadores lógicos AND e OR

Os operadores lógicos AND e OR são empregados na cláusula WHERE quando


necessitamos especificar mais que uma condição de comparação.

Exemplo 1: Precisamos listar todos os produtos de informática cuja quantidade


seja menor que 300.

Logo queremos os produtos “onde” Tipo= Informática “e” Quantidade menor


que 300.

Então: WHERE vcTipo_Prod = ‘Informática’ AND inQtd_Prod < 300

SELECT * FROM tb_Produto


WHERE vcTipo_Prod = 'Informática'
AND inQtd_Prod < 300

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 165.00
6 Caixas de Som Informática 20 88.00

34
Capítulo 4 - A cláusula WHERE

Exemplo 2: Precisamos aumentar o valor do produto em 10% dos produtos que


forem dos tipos Eletrônicos ou sobre o valor daqueles cujo preço é maior ou igual
a R$700,00.

Logo queremos os produtos “onde” Tipo= Eletrônicos “ou” Valor <= 700,00

Então: WHERE vcTipo_Prod = ‘Eletrônicos’ OR dcValor_Prod < = 700.00

UPDATE tb_Produto
SET dcValor_Prod = dcValor_Prod *1.1
WHERE vcTipo_Prod = 'Eletrônicos'
OR dcValor_Prod < = 700.00

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
2 Mouse Informática 300 54.45
3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 165.00
6 Caixas de Som Informática 20 96.80
7 Televisor Digitais 50 25000.00
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

A cláusula WHERE com o operador IN

O operador IN permite verificar se o valor de uma coluna está presente em uma


lista de elementos.

Considerando a tabela Produto, podemos utilizar o IN ou o operador OR para


selecionar os produtos do tipo Eletrônicos ou do tipo Informática. Vejamos os
exemplos:

• Exemplo Operador OR

SELECT * FROM tb_Produto


WHERE vcTipo_Prod = 'Eletrônicos'
OR vcTipo_Prod = 'Informática'

• Exemplo Operador IN

SELECT * FROM tb_Produto


WHERE vcTipo_Prod IN ('Eletrônicos','Informática')

35
Capítulo 4 - A cláusula WHERE

Ao executarmos ambas as instruções obtemos os mesmos resultados.

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
2 Mouse Informática 300 54.45
5 DVD Player Eletrônicos 150 165.00
6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

A cláusula WHERE com os operadores NOT IN

O operador lógico NOT IN, ao contrário de IN, permite obter resultados que não
esteja em uma determinada condição. Por exemplo, não queremos os produtos
do tipo Eletrônicos e Informática.

• Exemplo Operador NOT IN

SELECT * FROM tb_Produto


WHERE vcTipo_Prod NOT IN ('Eletrônicos','Informática')

Também é possivel utilizar o operador lógico AND em conjunto ao sinal de


comparação diferente ( <> ) ou ( != ) para obter o mesmo resultado.

SELECT * FROM tb_Produto


WHERE vcTipo_Prod <> 'Eletrônicos'
AND vcTipo_Prod <> 'Informática'

SELECT * FROM tb_Produto


WHERE vcTipo_Prod != 'Eletrônicos'
AND vcTipo_Prod != 'Informática'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
7 Televisor Digitais 50 25000.00

36
Capítulo 4 - A cláusula WHERE

4.1. A cláusula WHERE com o operador BETWEEN

O operador BETWEEN tem a finalidade de permitir a consulta de uma faixa de


valores. Dessa forma, podemos selecionar da tabela produtos os produtos que
estejam entre R$100,00 e R$500,00. Vejamos o exemplo:

SELECT * FROM tb_Produto


WHERE dcValor_Prod BETWEEN 100.00 AND 500.00

Outra forma de se obter o mesmo resultado é por meio da seguinte instrução:

SELECT * FROM tb_Produto


WHERE dcValor_Prod >= 100.00 AND dcValor_Prod <= 500.00

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
5 DVD Player Eletrônicos 150 165.00

A cláusula WHERE com os operadores NOT BETWEEN

O operador NOT BETWEEN ao contrário do anterior, permite consultar valores


que não estejam numa determinada faixa de valores.

SELECT * FROM tb_Produto


WHERE dcValor_Prod NOT BETWEEN 100.00 AND 500.00

Outra forma de se obter o mesmo resultado é por meio da seguinte instrução:

SELECT * FROM tb_Produto


WHERE dcValor_Prod < 100.00 OR dcValor_Prod > 500.00

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


2 Mouse Informática 300 54.45
3 Filmadora Eletrônicos 500 2750.00
4 Celular Eletrônicos 1000 1650.00
6 Caixas de Som Informática 20 96.80
7 Televisor Eletrônicos 50 27500.00
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

37
Capítulo 4 - A cláusula WHERE

O Operador LIKE

O operador LIKE [como] faz casamento de padrões. Um padrão é uma string


contendo caracteres que podem ser combinados com parte de outra string.
Por exemplo, o caractere % em um padrão representa qualquer quantidade de
caracteres. Por exemplo, para obter todos os produtos cujo (primeiro) nome
começa com C, use:

SELECT * FROM tb_produto


WHERE vcNome_Prod LIKE 'C%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


4 Celular Eletrônicos 1000 1650.00
6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82

Para obter todos os produtos que contenham as letras 'ad' no meio (ou no início
ou no fim), use:

SELECT * FROM tb_produto


WHERE vcNome_Prod LIKE '%ad%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
3 Filmadora Digital Digitais 500 2500.00

Também é possível usar os colchetes para combinar com uma determinada


faixa de caracteres. Por exemplo, LIKE '[CD]%' encontra os produtos que iniciam
com C ou K

SELECT * FROM tb_produto


WHERE vcNOme_Prod LIKE '[CD]%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 165.00
6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

38
Capítulo 4 - A cláusula WHERE

Também é possível trazer os produtos que começam com as letras de A até F.

SELECT * FROM tb_produto


WHERE vcNome_Prod LIKE '[A-F]%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 165.00
6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

Já o LIKE '[^T]%' encontra os produtos que não começam com T (o caractere ^


indica não).

SELECT * FROM tb_produto


WHERE vcNome_Prod LIKE '[^T]%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


2 Mouse Informática 300 54.45
3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 165.00
6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

Caso invertamos a posição da % como no exemplo abaixo, teremos o valores


que terminam com, por exemplo, R.

SELECT * FROM tb_produto


WHERE vcNome_Prod LIKE '%R'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 165.00
7 Televisor Digitais 50 25000.00

Note que as comparações feitas com LIKE dependem da ordem de classificação


[sort order] escolhida durante a instalação do SQL Server. Se for usada a ordem
"accentinsensitive", ele consegue procurar ignorando acentos. Por exemplo,
LIKE 'camara' vai encontrar também 'Câmara'.

39
Capítulo 4 - A cláusula WHERE

A cláusula WHERE com os operadores NOT LIKE

O operador NOT LIKE é utilizado de forma oposta ao operador LIKE.

Por exemplo, queremos produtos que não possuem a letra “R” no nome do
produto.

SELECT * FROM tb_produto


WHERE vcNome_Prod NOT LIKE '%R%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
2 Mouse Informática 300 54.45
6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82
10 DVD Informática 500 4.24

Ou produtos que não começam com a letra “C”.

SELECT * FROM tb_produto


WHERE vcNome_Prod NOT LIKE 'c%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
2 Mouse Informática 300 54.45
3 Filmadora Digital Digitais 500 2500.00
5 DVD Player Eletrônicos 150 165.00
7 Televisor Digitais 50 25000.00
10 DVD Informática 500 4.24

Outro caractere para usar em padrões é o sublinhado (_). Ele combina com um
único caractere. Por exemplo, se nos seus dados existem campos como, por
exemplo, nome 'Sousa' ou 'Souza', você pode usar: LIKE '%sou_a%'.

40
Capítulo 5 - A Cláusula ORDER BY

Capítulo 5 - A Cláusula ORDER BY

ORDER BY

Para ver o resultado numa ordem particular, use a cláusula ORDER BY. Se
estiver presente, deve ser a última cláusula do comando SELECT, a cláusula
ORDER BY é utilizada em conjunto com a instrução SELECT, a fim de retornar
o resultado de uma consulta em uma determinada ordem.

Ordenando por colunas

Podemos utilizar como critério de ordenação, o nome ou o numero referente a


coluna que se deseja ordenar.

Ordenando por uma coluna


SELECT * FROM tb_produto SELECT * FROM tb_produto
ORDER BY vcNome_Prod ORDER BY 2

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


6 Caixas de Som Informática 20 96.80
9 CD Informática 320 1.82
4 Celular Telefones 1000 1500.00
10 DVD Informática 500 4.24
5 DVD Player Eletrônicos 150 165.00
3 Filmadora Digital Digitais 500 2500.00
2 Mouse Informática 300 54.45
1 Teclado Informática 100 181.50
7 Televisor Digitais 50 25000.00

Ordenando por varias colunas


SELECT * FROM tb_produto SELECT * FROM tb_produto
ORDER BY vcTipo_Prod, dcValor_Prod ORDER BY 3,5

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


3 Filmadora Digital Digitais 500 2500.00
7 Televisor Digitais 50 25000.00
5 DVD Player Eletrônicos 150 165.00
9 CD Informática 320 1.82
10 DVD Informática 500 4.24
2 Mouse Informática 300 54.45
6 Caixas de Som Informática 20 96.80
1 Teclado Informática 100 181.50
4 Celular Telefones 1000 1500.00
5.1. ORDER BY ASC e DESC

41
Capítulo 5 - A Cláusula ORDER BY

Na cláusula ORDER BY pode-se adicionar mais uma instrução que indica se a


ordenação será ascendente ou descendente.

• ASC
Quando utilizamos está instrução, estamos solicitando uma ordenação
ascendente, ou seja, do menor para o maior.

SELECT vcNome_Prod, dcValor_Prod FROM tb_produto


ORDER BY dcValor_Prod ASC

vcNome_Prod dcValor_Prod
CD 1.82
DVD 4.24
Mouse 54.45
Caixas de Som 96.80
DVD Player 165.00
Teclado 181.50
Celular 1500.00
Filmadora Digital 2500.00
Televisor 25000.00

• DESC
Quando utilizamos está instrução, estamos solicitando uma ordenação
descendente, ou seja, do maior para o menor.

SELECT vcNome_Prod, dcValor_Prod FROM tb_produto


ORDER BY dcValor_Prod DESC

vcNome_Prod dcValor_Prod
Televisor 25000.00
Filmadora Digital 2500.00
Celular 1500.00
Teclado 181.50
DVD Player 165.00
Caixas de Som 96.80
Mouse 54.45
DVD 4.24
CD 1.82

42
Capítulo 5 - A Cláusula ORDER BY

• ASC e DESC

Podemos combinar as cláusulas ASC e DESC de maneira que uma coluna


fique na ordem crescente e a outra fique na ordem decrescente, por exemplo,
queremos que a primeira coluna do tipo de produto esteja na ordem
crescente, mas os preços estejam na ordem decrescente. Vejamos o
exemplo:

SELECT vcTipo_Prod, vcNome_Prod, dcValor_Prod FROM tb_produto


ORDER BY vcTipo_Prod ASC, dcValor_Prod DESC

vcTipo_Prod vcNome_Prod dcValor_Prod


Digitais Televisor 25000.00
Digitais Filmadora Digital 2500.00
Eletrônicos DVD Player 165.00
Informática Teclado 181.50
Informática Caixas de Som 96.80
Informática Mouse 54.45
Informática DVD 4.24
Informática CD 1.82
Telefones Celular 1500.00

Nota: Se não especificarmos ASC nem DESC, o default é ASC.

A cláusula TOP

A cláusula TOP permite que retornemos em uma consulta um limite máximo de


linhas estipulado na cláusula TOP.

Está cláusula é muito utilizado também para realizarmos testes para verificarmos
nomes de campos de uma determinada tabela sem precisarmos retornar todos
os registros.

SELECT TOP 5 * FROM tb_Produto

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


1 Teclado Informática 100 181.50
2 Mouse Informática 300 54.45
3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00
5 DVD Player Eletrônicos 150 165.00

43
Capítulo 5 - A Cláusula ORDER BY

A cláusula TOP com Order By

Por exemplo, queremos os três produtos mais caros de nossa loja.

SELECT TOP 3 * FROM tb_Produto


ORDER BY dcValor_Prod DESC

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


7 Televisor Digitais 50 25000.00
3 Filmadora Digital Digitais 500 2500.00
4 Celular Telefones 1000 1500.00

A cláusula TOP WITH TIES com ORDER BY

Especifica que linhas adicionais são retornadas do conjunto de resultados


base com o mesmo valor das colunas que aparecem na última das TOP n
linhas (PERCENT). TOP... WITH TIES só pode ser especificado em
instruções SELECT, e apenas se uma cláusula ORDER BY for especificada.

Para o exemplo abaixo iremos realizar mais um INSERT na tabela de


produtos.

INSERT INTO tb_Produto


VALUES(1,'Teclado Wireless','Informática',20,150.00)

Agora vamos supor que precisamos obter como resultado o produto com a
menor quantidade de unidades. Porém, é preciso considerar a existência do e
produtos com a mesma quantidade de unidades. Neste caso o comando para
retornar os produtos com menor numera de unidades:

SELECT TOP 1 WITH TIES * FROM tb_Produto


ORDER BY inQtd_Prod ASC

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


6 Caixas de Som Informática 20 96.80
1 Teclado Wireless Informática 20 150.00

A cláusula WITH TIES retorna a primeira linha da tabela, além de todas as


linhas que apresentam quantidade idêntica à quantidade do produto que a
cláusula TOP selecionou.

44
Capítulo 5 - A Cláusula ORDER BY

Vejamos mais um exemplo com a cláusula WITH TIES.

Na instrução SELECT com TOP normalmente só é retornado a quantidade


máxima que é especificada na cláusula TOP, neste caso, apenas oito
registros, mas quando utilizamos a cláusula WITH TIES a instrução retorna
também os registros onde a quantidade é igual ao ultimo registro, neste caso,
o oitavo registro.

SELECT TOP 8 WITH TIES * FROM tb_Produto


ORDER BY inQtd_Prod ASC

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod


6 Caixas de Som Informática 20 96.80
1 Teclado Wireless Informática 20 150.00
7 Televisor Digitais 50 25000.00
1 Teclado Informática 100 181.50
5 DVD Player Eletrônicos 150 165.00
2 Mouse Informática 300 54.45
9 CD Informática 320 1.82
10 DVD Informática 500 4.24
3 Filmadora Digital Digitais 500 2500.00

45
Capítulo 7 - Associando Tabelas

Capítulo 6 - Integridade e Consistência dos Dados

Quando falamos em integridade, pensamos em proteção contra hackers e ataques


do gênero, ou até mesmo backup, mas a integridade começa em um nível muito
mais baixo, começa na criação e projeto do banco de dados.

Regras de Integridade e consistência

Integridade de Domínio

A integridade de domínio nada mais é do que a integridade do campo como o


tipo de dados correto, se permite valores nulos ou não nulos, valores padrão,
verificação de valores e restrições, estes mecanismos foram criados para dar
integridade aos campos. Os tipos de dados também são caracterizados como
integridade de domínio, se o tipo de dado estiver incorreto, ou com mais posições
que o necessário, pode haver um risco que quebre a qualidade da informação.

Integridade de Entidade

A integridade de entidade nada mais é que a integridade da tabela, isto é


conseguido através das chaves primárias ou campos únicos, uma tabela sem
chave primária ou campo único é uma tabela sem integridade de entidade, é
muito comum encontrarmos base de dados com tabelas sem qualquer tipo de
restrição, alguns colocam campo auto incrementável e não se preocupam com a
chave primária ou principal, mas esquecem que o campo auto incrementável não
garante a não duplicidade dos registros.

Integridade Referencial

A integridade referencial é conhecida principalmente pelas chaves estrangeiras


ou referencias a outras tabelas, nada mais é que criarmos campos de mesmo
tipo de dados referente a uma coluna de chave primária de outra tabela, isto é
possível a partir da integridade de entidade, apenas conseguimos criar uma
chave estrangeira a partir de uma chave primária ou única.

46
Capítulo 7 - Associando Tabelas

Para que possamos compreender as regras referentes à integridade e à


consistência de dados, utilizaremos a tabela de Colaborador, descrita abaixo.

vcNome chSexo dcSalario


Luana Maia M 1980.00
André Inca M 2103.00
Suzana Silva F 2530.00
Rogério Tecca M 1752.00
André Inca M 2103.00

CREATE TABLE tb_colaborador


(
vcNome varchar(100)
,chSexo char(1)
,dcSalario decimal(10,2)
)

GO

INSERT INTO tb_colaborador values ('Luana Maia','M',1980.00)


INSERT INTO tb_colaborador values ('André Inca','M',2103.00)
INSERT INTO tb_colaborador values ('Suzana Silva','F',2530.00)
INSERT INTO tb_colaborador values ('Rogério Tecca','M',1752.00)
INSERT INTO tb_colaborador values ('André Inca','M',2103.00)

47
Capítulo 7 - Associando Tabelas

Constraints

Uma restrição [constraint] é uma propriedade de uma coluna usada para


reforçar a integridade de dados. Geralmente restrições são definidas quando a
tabela é criada, mas podem também ser definidas ou retiradas quando a tabela já
contém dados. Se um comando de alteração (INSERT ou UPDATE) não satisfaz
uma das restrições, o comando é cancelado.
Toda restrição tem um nome, que você pode informar nos comandos CREATE
TABLE e ALTER TABLE. Se você não informar um nome, o SQL gera um
automaticamente, como PK_TITLEAUTH_AU_ID_154AF3E0.

A fim de assegurar a integridade dos dados, o SQL SERVER oferece cinco tipos
de restrições diferentes, os quais estão relacionados na tabela abaixo:

Tipos de Integridade Tipos de Constraints


Chave Primária Constraint Primary Key
Chave Estrangeira Constraint Foreign Key e Constraint References
Chave Primária, Secundária ou Chave Unica Constraint Unique
Regras de validação Constaint Check
Valor Padrão Constraint Default

Chaves primárias

A chave primária de uma tabela é uma coluna ou seqüência de colunas que


identificam unicamente uma linha dentro da tabela, ou seja, seu valor não pode
ser repetido para outras linhas. Ao definir uma chave primária, automaticamente
é criado um índice clustered na tabela. Só pode existir uma chave primária na
tabela. Não se pode inserir um valor nulo em qualquer coluna chave primária
(lembrando que nulo é um valor desconhecido, diferente de 0 ou de espaço em
branco). Recomenda-se uma coluna inteira e pequena, como uma chave primária

Vejamos o exemplo da tabela colaborador, o funcionário André foi inserido duas


vezes na tabela de colaborador, para aplicarmos um aumento salarial apenas a
um dos Andrés necessitamos de um identificador que diferencie um André do
outro André, para isso precisamos incluir uma coluna de código do colaborador
que nos permita diferenciar um colaborador do outro, então criaremos uma
coluna de código do tipo inteiro que seja auto-incremento e seja única.

48
Capítulo 7 - Associando Tabelas

ALTER TABLE tb_colaborador ADD inId int IDENTITY(1,1) PRIMARY KEY

vcNome chSexo dcSalario inId


Luana Maia M 1980.00 1
André Inca M 2103.00 2
Suzana Silva F 2530.00 3
Rogério Tecca M 1752.00 4
André Inca M 2103.00 5

Ao adicionarmos uma nova coluna, a mesma sempre será gerada na ultima


coluna da tabela.

IDENTITY

Quando indicamos um campo como IDENTITY estamos dizendo que este campo
será auto incrementável, portanto não podemos especificá-lo ou adicionar um
valor ao mesmo quando realizarmos um INSERT na tabela, pois os valores deste
campo são auto geráveis.

IDENTITY [ (seed , increment) ]

SEED - Semente
Corresponde ao numero do primeiro valor que será inserido na tabela.

INCREMENT - Incremento
É o valor incremental que é acrescentado ao valor de identidade à linha anterior,
que foi carregado, é o famoso “passo”.

Caso não seja especificado o seed e o increment o padrão é (1,1)

Nota: Existem situações em que a constraint Primary Key é definida em várias


colunas. Quando isso ocorre, é possível que haja valores duplicados em uma
coluna, porém, a combinação de valores da coluna que representa a constraint
Primary Key deve ser única.

49
Capítulo 7 - Associando Tabelas

Chaves primárias, secundárias ou chaves únicas

Além das constraints Primary Key, também podemos utilizar constraints


UNIQUE, uma restrição UNIQUE em uma coluna ou grupo de colunas determina
que o seu valor deva ser único na tabela. Esse tipo de restrição é usado para
chaves alternadas, ou seja, valores que se repetem na tabela além da chave
primária. Pode haver várias restrições UNIQUE na tabela e as colunas de uma
restrição UNIQUE permitem valores nulos.

Vamos adicionar o campo Documento na tabela colaborador, o mesmo deverá


ser ÚNICO para cada colaborador, mas primeiro precisamos criar um campo
documento e inserir seus respectivos valores.

Criando o campo Documento na tabela colaborador

ALTER TABLE tb_colaborador ADD vcDocumento varchar(11)

vcNome chSexo dcSalario inId vcDocumento


Luana Maia M 1980.00 1 NULL
André Inca M 2103.00 2 NULL
Suzana Silva F 2530.00 3 NULL
Rogério Tecca M 1752.00 4 NULL
André Inca M 2103.00 5 NULL

UPDATE tb_colaborador SET vcDocumento = '22623228884'


WHERE inId = 1
UPDATE tb_colaborador SET vcDocumento = '22623228881'
WHERE inId = 2
UPDATE tb_colaborador SET vcDocumento = '22623228882'
WHERE inId = 3
UPDATE tb_colaborador SET vcDocumento = '22623228883'
WHERE inId = 4
UPDATE tb_colaborador SET vcDocumento = NULL
WHERE inId = 5

vcNome chSexo dcSalario inId vcDocumento


Luana Maia M 1980.00 1 22623228884
André Inca M 2103.00 2 22623228881
Suzana Silva F 2530.00 3 22623228882
Rogério Tecca M 1752.00 4 22623228883
André Inca M 2103.00 5 NULL

Obs. Nota quando adicionamos um novo campo a tabela, a coluna será


sempre inserida no final da tabela.

50
Capítulo 7 - Associando Tabelas

Após atualizarmos a tabela de colaborador, podemos adicionar a restrição


UNIQUE no campo documento, para garantirmos que duas pessoas não terão
o mesmo documento na tabela.

ALTER TABLE tb_colaborador ADD CONSTRAINT UQ_Documento UNIQUE(vcDocumento)

Note que colocamos um nome a constraint UNIQUE de UQ_Documento.

Nota: As constraints do tipo UNIQUE podem ser utilizadas para referenciar uma
chave estrangeira.

Chaves estrangeiras

Uma forma importante de integridade no banco de dados é a integridade


referencial, que é a verificação de integridade feita entre duas tabelas. Por
exemplo, a tabela 'Dependente' será usada para relacionar dados de
COLABORADOR e DEPENDENTES. Ela contém as colunas inIdColab e
inIdDepen. A segunda deve conter um código válido que exista na tabela
'Colaborador'.
Uma chave estrangeira Foreign Key é uma restrição de integridade referencial.
Ela consiste de uma coluna ou grupo de colunas cujo valor deve coincidir com
valores da outra tabela, embora a chave estrangeira possa conter valores nulos,
é possível que, a verificação dos valores que formam esta constraint não ocorra,
então para garantirmos a verificação da chave estrangeira, fazemos uso da
restrição NOT NULL com atribuição desta coluna.

Vejamos nas tabelas abaixo como este tipo de referencia é implementado.

• Tabela de Colaborador

inIdColab vcDocumento Chave chSexo dcSalario


Chave Primária vcNome Única Apenas M ou F valores positivos
1 Luana Maia 22623228884 M 1980.00
2 André Inca 22623228881 M 2103.00
3 Suzana Silva 22623228882 F 2530.00
4 Rogério Tecca 22623228883 M 1752.00

• Tabela de Dependente

inIdDepen chSexo
Chave Primária inIdColab vcNome dtNasc apenas M ou F vcParente
1 4 Isabella da Silva 02/13/95 F Filha
2 2 Marina Faria 01/15/82 F Esposa
3 3 Paulo Henrique 09/21/80 M Marido
4 3 Aline Faria 07/16/93 F Filha
3 1 Thiago Maia 09/21/99 M Filho

51
Capítulo 7 - Associando Tabelas

Na pagina anterior, temos duas tabelas, Colaborador e Dependente, onde podemos


verificar quais os funcionários que temos em nossa base de dados e encontrar seus
respectivos dependentes, como possuímos um código do colaborador na tabela de
dependentes, podemos encontrar facilmente quem são seus filhos, Marido ou
esposa, note que apenas criamos uma segunda coluna que permite a entrada de
valores numéricos, com isso não garantimos a integridade dos dados, pois podemos
inserir qualquer valor nesta coluna mesmo não existindo este código na tabela de
colaboradores, para resolver este tipo de problema de inconsistência, devemos
colocar uma verificação para que não possa ser atribuída uma entrada que não
exista em colaborador, para isso deve-se fazer uso da famosa chave estrangeira ou
foreign key.

Regras de validação

Devemos implementar regras de validação em nossas tabelas para que


possamos garantir a qualidade da informação que estamos trabalhando em
nosso banco de dados, está regras podem evitar confusões na inserção de
valores nas tabelas, protegendo desta forma a integridade dos dados, e
impedindo que um possível erro se propague por um tempo indeterminado em
sua base de dados.

Por exemplo, ao criarmos um campo que classifique uma pessoa como sexo
Masculino ou Feminino, poderia restringir a informação para este campo como
sendo somente Masculino e Feminino, dessa forma garantimos que ao retornar
uma consulta, não encontraremos um valor estranho como, por exemplo, o
endereço na coluna de sexo.

Valor Padrão

O valor padrão é uma regra que pode ser aplicada a inúmeras colunas de sua
tabela, quando um valor padrão é estabelecido para uma determinada coluna,
o sistema assume que ele deve ser utilizado nas situações em que o usuário,
deixa de inserir um valor a um campo da tabela.

• Tabela de Colaborador2

dcSalario
inIdColab vcNome chSexo valor padrão 1000.00
1 Luana Maia M 1000.00
2 André Inca M 1000.00
3 Suzana Silva F 2530.00
4 Rogério Tecca M 1752.00

Valores nulos e não nulos

Além dos valores padrão, podemos atribuir valores nulos e não nulos a uma
determinada coluna. Assim ao deixarmos de inserir um valor em um
determinado campo, o mesmo assumiria um valor nulo, e ao restringirmos
como não nulo, não poderemos deixar de inserir valor neste campo, ao

52
Capítulo 7 - Associando Tabelas

tentarmos deixar um campo não nulo em branco o SQL Server retornará um


erro.
Atribuir um valor nulo a uma coluna significa que ela não terá valor. Assim de
acordo com as regras de integridade e consistência dos dados, é preciso
atribuir a nulabilidade das colunas de uma tabela a fim de determinar se elas
aceitarão valores nulos (NULL) ou não (NOT NULL).

Data types

Datatypes são os tipos de dados que o SQL Server aceita. Eles existem para
que possamos definir o tipo de conteúdo de um campo de tabela ou de uma
variável ou parâmetro.

Aqui está uma lista de Data Types mais utilizados.


TIPOS NUMÉRICOS
TAMANHO MENOR MAIOR
NOME (BYTES) VALOR VALOR ARMAZENA
BIGINT 8 -263 263 - 1 INTEIRO
INT 4 -231 231 - 1 INTEIRO
SMALLINT 2 -215 215 - 1 INTEIRO
TINYINT 1 0 255 INTEIRO
DECIMAL EXATO, ONDE C INDICA NÚMERO DE POSIÇÕES E D O NÚMERO
DECIMAL(C, D) VARIÁVEL -1038 1038 - 1 DE CASAS DECIMAIS
DECIMAL EXATO, ONDE C INDICA NÚMERO DE POSIÇÕES E D O NÚMERO
NUMERIC(C, D) VARIÁVEL -1038 1038 - 1 DE CASAS DECIMAIS
MONEY 8 -263 263 - 1 MONETÁRIO - EQUIVALE A UM DECIMAL COM 4 CASAS DECIMAIS
SMALLMONEY 4 -231 231 - 1 MONETÁRIO - EQUIVALE A UM DECIMAL COM 4 CASAS DECIMAIS
PONTO FLUTUANTE, ONDE D INDICA O NÚMERO MÁXIMO DE CASAS
FLOAT(D) 4 OU 8 -1.79 X 10308 1.79 X 10308 DECIMAIS, ENTRE 0 E 53
REAL 4 -3.4 X 1038 3.4 X 1038 PONTO FLUTUANTE - EQUIVALENTE AO FLOAT(24)

TIPOS TEXTO
LIMITE TAMANHO
NOME TABELA ARMAZENA
(CARACTERES) (CARACTERES)
CARACTERES, ONDE N INDICA O TAMANHO DO
CHAR(N) ASCII 8000 EXATAMENTE N
CAMPO
CARACTERES, ONDE N INDICA O TAMANHO DO
VARCHAR(N) ASCII 8000 ATÉ N
CAMPO
UNICOD CARACTERES, ONDE N INDICA O TAMANHO DO
NCHAR(N) 4000 EXATAMENTE N
E CAMPO
NVARCHAR(N UNICOD CARACTERES, ONDE N INDICA O TAMANHO DO
4000 ATÉ N
) E CAMPO
TEXT ASCII 231 - 1 ATÉ 231 - 1 CARACTERES
UNICOD 31
NTEXT 2 -1 ATÉ 231 - 1 CARACTERES
E

TIPOS DATA HORA


TAMANHO
NOME MENOR VALOR MAIOR VALOR PRECISÃO
(BYTES)
1753-01-01 9999-12-31
DATETIME 8 3.33 ms
00:00:00.000 23:59:59.997
SMALLDATETI 1 MINUTO, SENDO QUE ATÉ 29.998ms ARREDONDA PARA
4 1/1/1900 00:00 6/6/2079 23:59
ME MENOS E ACIMA DISSO PARA O PROXIMO

53
Capítulo 7 - Associando Tabelas

Regras de Constraints

As constraints são utilizadas para limitar o tipo de informação que pode ser
inserida em uma tabela, uma constraint pode ser especificada quando uma
tabela é criada (com a declaração CREATE TABLE) ou após a tabela ser
criada (com o ALTER TABLE).

Constraint DEFAULT

Esta constraint serve para indicar um valor padrão para um campo, quando
uma declaração INSERT não especifica o valor para a coluna. Uma omissão
de um campo no INSERT pode atribuir um valor constante, o valor de um
sistema de função, ou NULL para uma coluna. Você pode usar uma
constraint Default em qualquer coluna, exceto colunas IDENTIDADE e
colunas do tipo timestamp.

Constraint UNIQUE

Esta constraint faz a validação de valores únicos em uma coluna de uma


tabela, o SQL Server utiliza um índice para garantir que uma coluna ou um
conjunto de colunas não contenha valores duplicados. Diferente da PRIMARY
KEY, podemos colocar várias constraints UNIQUE por tabela mas para cada
campo que possue uma constraint UNIQUE somente podemos inserir o valor
NULL uma vez.

Constraint CHECK

Quando criamos uma constraint do tipo CHECK o banco irá analisar os dados
quando tentarmos inserir ou modificar uma coluna. Se a expressão é avaliada
para false, o banco de dados não irá salvar a nova linha ou alteração.
Implementar uma contraint check é semelhante a construir uma cláusula
WHERE. Podemos utilizar muito dos mesmos operadores (>, <, <=,> =, <>, =)
e mais o BETWEEN, IN, LIKE, e NULL. Podemos também utilizar expressões
com os operadores AND e OR. Assim podemos restringir a entrada de valores
em um determinado campo.

Constraint PRIMARY KEY

A constraint PRIMARY KEY identifica exclusivamente cada registro em um


banco de dados/tabela, a coluna definida como Chave primária deve conter
valores exclusivos e não pode conter valores NULOS.
Cada tabela deve ter uma chave primária, e cada tabela pode ter apenas uma
chave primária.

Constraint FOREIGN KEY

A constraint FOREIGN KEY é utilizada para implementar o conceito de chave


estrangeira e serve para indicar que o conteúdo de um campo deve
referenciar a um outro campo que possua ou uma chave primária ou uma
constraint UNIQUE.

54
Capítulo 7 - Associando Tabelas

Quando o campo que está sendo referenciado residir na mesma tabela, não
precisamos uitilizar a palavra-chave FOREIGN KEY, podendo somente utilizar
REFERENCES. Esta constraint também pode ser desabilitada, para o caso
de uma grande inserção de dados na tabela.

Modelo entidade e relacionamento (MER)

O Modelo Entidade Relacionamento, foi desenvolvido pelo professor Peter Chen,


a fim de representar as estruturas de dados de uma forma mais natural e mais
próxima do mundo real dos negócios, tem seu conceito fundamentado na teoria
de modelos relacionais apresentada pelo pesquisador E.T. Codd, é um modelo
abstrato cuja finalidade é descrever, de maneira conceitual as informações que
representam um determinado sistema, segundo Paulo Cougo , descreve o
mundo como “...cheio de coisas que possuem características próprias e que se
relacionam entre si.”
Essas coisas podem ser pessoas, objetos, conceitos e eventos que possam ser
expressos como entidades.
O Modelo E-R propõem que a realidade seja visualizada sob três pontos de vista.
Assim, há três conceitos fundamentais no Modelo E-R: Entidade, Atributo e
Relacionamento.

Entidade, do latim, entitas, significa ser, existência; é algo que possui existência
distinta e separada, real ou imaginária.
Uma entidade corresponde à representação de todo e qualquer substantivo,
concreto ou abstrato, sobre o qual se precisa armazenar e/ou recuperar
informações.
Em inglês, o conceito de entidade recebe o nome que demonstra bem o seu
significado, que é “entity type”, ou seja, um tipo de entidade.
Outro aspecto importante no conceito de entidade é a possibilidade de
individualização de cada um dos objetos que compõem o padrão.

Atributo são os elementos que definem a característica de uma determinada


entidade. Uma entidade funcionário representa um tipo, no qual são classificados
todos os funcionários da Organização. No entanto, cada indivíduo possui
características próprias que devem ser diferenciadas, como por exemplo, o fato
de que cada funcionário possui um nome, um salário, um cargo, uma data de
nascimento, entre outras coisas. Essas características de mesmo tipo são
utilizadas pela Organização para contratar, administrar, pagar e desligar os
funcionários.
Esses tipos de características (ou tipos de informação) são denominados
atributos de uma entidade.
Em inglês, o conceito de atributo recebe o nome de “attribute type”, ou seja, um
tipo de atributo.

55
Capítulo 7 - Associando Tabelas

Relacionamento é a forma como os objetos que compõem a realidade se


relacionam. Quando se reduz a realidade em objetos como entidades e seus
atributos, está se trabalhando com a parte estática dos Negócios.
Todavia, na verdade, iremos encontrar situações onde Clientes solicitam
Cotações, que geram Pedidos de Vendas quando aprovadas; os Pedidos
vendem Produtos em quantidades e preços diferentes que são faturados através
da Nota Fiscal, que é paga em parcelas pelas Duplicatas e, assim por diante, em
um fluxo dinâmico.
Isto mostra que os dados se relacionam entre si, indicando a própria dinâmica
dos negócios, bem como as regras e políticas que os regem. Para representar
essa dinâmica, o Modelo E-R define o conceito de relacionamento entre as
entidades.

Relacionamento

Obviamente, o Modelo E-R, como toda representação, não é a própria realidade,


mas foi desenvolvido para estar o mais próximo dela. Por isso, além de
representar as relações de posse, envolvimento, composição e geração (entre
outras), incorporou, também, outro conceito para melhorar o conhecimento sobre
as políticas e regras dos Negócios.
Este conceito é chamado de Cardinalidade do Relacionamento. É um conceito
que melhora o conhecimento sobre as políticas e regras dos Negócios,
consistindo de números (cardinais) colocados ao lado do nome do
relacionamento.
De acordo com a cardinalidade, existem 3 (três) tipos básicos de relacionamento
entre as entidades.

Relacionamento 1:1

Relacionamento One to One, 1 para 1 ou 1:1, indica que uma única


ocorrência de uma entidade pode se relacionar com apenas uma única
ocorrência de outra entidade.

Por exemplo: em uma tabela de Convidado e outra de Conjugue, a cada um


dos convidados pode se ter apenas um conjugue, assim como cada um dos
conjugues só podem ter apenas um convidado.

Relacionamento 1:N

Para compreendermos o relacionamento de One to Many, um para muitos,


1 para N ou 1:N, consideremos duas entidades A e B. Neste tipo de
relacionamento, cada elemento da entidade A pode ter um relacionamento
com vários elementos da entidade B. Entretanto, cada um dos elementos da
entidade B pode estar relacionado a apenas um elemento da entidade A. No
mundo real, este é o tipo de relacionamento mais utilizado.

56
Capítulo 7 - Associando Tabelas

• Tabela Colaborador

inIdColab vcNome chSexo dcSalario


1 Luana Maia M 1000.00
2 André Inca M 1000.00
3 Suzana Silva F 2530.00
4 Rogério Tecca M 1752.00

• Tabela Dependente

inIdDepend inIdColab vcNomeDepen chSexo dtNascimento


1 4 Luana Maia M 03/05/2005
2 2 André Inca M 02/05/1998
3 1 Suzana Silva F 03/09/2001
4 1 Rogério Tecca M 05/06/1988

Podemos observar nestas tabelas que há funcionários com mais de um


dependente. No entanto, cada um dos dependentes está relacionado a
apenas um funcionário.

Regras de relacionamento 1:N

Para que seja estabelecido um relacionamento de One to Many, um para


muitos, 1 para N ou 1:N, devemos contar com duas tabelas, em que a
primeira, obrigatoriamente deve ter uma coluna que utilize uma chave
primaria, para que a mesma possa ser identificada e referenciada pela
outra tabela. Vale lembrar que colunas com a Constraint Primary Key não
aceitam valores nulos e nem repetidos.

Já na tabela que representa o relacionamento para muitos, deverá haver uma


coluna referente à primeira tabela, a qual deve utilizar a chave estrangeira
para garantirmos que apenas valores existentes na tabela 1 possam ser
inseridos na coluna Foreign Key da tabela 2.

Devemos estar atentos ao fato de que, colunas que utilizam a chave


estrangeira aceitam a inserção de valores repetidos.

Relacionamento N:N

Relacionamento N para N, Muitos para Muitos (Many to Many ou N:N) é


um dos tipos de relacionamentos que se podem estabelecer entre os campos
de duas tabelas. Assim, para cada valor do campo de uma tabela, pode haver
N valores no campo da outra tabela e vice-versa.

Em bancos de dados relacionais, isto normalmente é feito através de uma


tabela de ligação. Ela se liga a cada lado N, com relacionamento 1 para N em
cada lado. Cada possibilidade de ligação é registrada isoladamente, ou seja,
ao relacionar cinco informações de cada lado, são registradas 25 linhas na
tabela de ligação.

57
Capítulo 7 - Associando Tabelas

A chave primária desta tabela é criada pela junção dos campos chaves das
tabelas interligadas.

Para compreendermos este tipo de relacionamento, tomemos como exemplo


as tabelas Aluno e Curso. Com elas, temos a seguinte situação: um aluno
pode fazer diversos cursos em um curso pode haver diversos alunos.
Vejamos a contrução e o relacionamento destas tabelas:

Regras de relacionamento N:N

use db_aula

CREATE TABLE tb_aluno


(
inCodAluno int not null
, vcNomeAluno varchar(150)
, chSexoAluno char(1)
, dtCadastro datetime

, Constraint PK_Aluno Primary Key(inCodAluno)


, Constraint CK_SexoAluno Check(chSexoAluno in ('M','F'))
)
GO
Insert into tb_aluno values (1,'Fernando','M',getdate())
Insert into tb_aluno values (2,'Aline','F',getdate())
Insert into tb_aluno values (3,'Carlos','M',getdate())
Insert into tb_aluno values (4,'Rodrigo','M',getdate())
GO

• Tabela tb_aluno

inCodAluno vcNomeAluno chSexoAluno dtCadastro


1 Fernando M 03/05/2005
2 Aline M 02/05/2007
3 Carlos F 03/09/2007
4 Rodrigo M 05/06/2008

58
Capítulo 7 - Associando Tabelas

CREATE TABLE tb_curso


(
inCodCurso int not null
, vcNomeCurso varchar(150)
, chCursoAtivo char(1)
, dtCadastro datetime

, Constraint PK_Curso Primary Key(inCodCurso)


, Constraint CK_CursoAtivo Check(chCursoAtivo in ('S','N'))
)
GO
Insert into tb_curso values (1,'Matemática','S',getdate())
Insert into tb_curso values (2,'Português','S',getdate())
Insert into tb_curso values (3,'Geografia','S',getdate())
Insert into tb_curso values (4,'História','S',getdate())
Insert into tb_curso values (6,'Inglês','S',getdate())
GO

• Tabela tb_curso

inCodCurso vcNomeCurso chCursoAtivo dtCadastro


1 Matemática S 03/01/2005
2 Português S 02/01/2005
3 Geografia S 03/01/2005
4 Inglês S 05/01/2005

59
Capítulo 7 - Associando Tabelas

/*Agora construiremos a tabela de relacionamento N:N*/

Create Table tb_AlunoCurso


(
inCodAluno int not null
, inCodCurso int not null

, Constraint PK_AlunoCurso Primary Key(inCodAluno, inCodCurso)


, Constraint FK_Aluno Foreign Key(inCodAluno) references tb_aluno(inCodAluno)
, Constraint FK_Curso Foreign Key(inCodCurso) references tb_curso(inCodCurso)
)
GO
Insert into tb_alunoCurso values(1,1)
Insert into tb_alunoCurso values(1,2)
Insert into tb_alunoCurso values(2,1)
Insert into tb_alunoCurso values(2,2)
Insert into tb_alunoCurso values(2,3)
Insert into tb_alunoCurso values(3,3)
Insert into tb_alunoCurso values(1,3)
Insert into tb_alunoCurso values(1,4)

• Tabela tb_AlunoCurso

inCodAluno inCodCurso
1 1
1 2
2 1
2 2
2 3
3 3
1 3
1 4

60
Capítulo 7 - Associando Tabelas

Capítulo 7 - Associando Tabelas

JOIN

Joins são operações onde podemos retornar dados de duas ou mais tabelas, a
clausula JOIN indica como o Microsoft Sql Server deve utilizar o dado de uma
tabela, para selecionar dados de outra tabela.

Antigo Estilo VS. Novo Estilo

O T-SQL suporta dois tipos diferentes de sintaxes para joins implementado pelo
padrão ANSI, e nenhuma delas está em processo de depreciação ainda. Os
elementos do Join antigo são complementos do novo estilo, isto quer dizer que,
você poderá utilizar ambos, sem preocupação de o SQL Server não suportar a
sintaxe futuramente.

O estilo mais antigo foi introduzido no SQL ANSI em 1989, utilizando vírgulas
para separar os nomes das tabelas após a cláusula FROM, e não existiam as
cláusulas JOIN e ON.

Exemplo:

FROM tabela1, tabela2


WHERE tabela1.codigo = tabela2.codigo

O ANSI SQL: 1989 têm suporte apenas para os tipos CROSS e INNER JOIN.
Este padrão não tem suporte para OUTER JOINS (Left, Right e Full).

O estilo mais novo ANSI SQL: 1992, foi removido as vírgulas para separar as
tabelas e introduzido as cláusulas JOIN e ON.

Exemplo:

FROM tabela1 <join_type> JOIN tabela2 ON <on_filtro>


WHERE where_filtro

O ANSI SQL: 1992 implementou suporte para OUTER JOINS, e necessitou da


implementação de filtros na cláusula ON, veremos isso com mais detalhes mais a
frente.

61
Capítulo 7 - Associando Tabelas

A condição da clausula JOIN define a forma como duas tabelas devem ser
unidas em uma consulta.

• Especificando as colunas de cada tabela para serem utilizadas para


interligação das mesmas, uma interligação típica é especificando uma
chave estrangeira de uma das tabelas, e associando-a a sua chave na
outra tabela.
• Especificando um operador lógico (exemplo: =, or, <>) para ser utilizado
na comparação dos valores das colunas.

Após a cláusula FROM, devemos especificar as entidades que serão


combinadas, a seleção de linhas retornadas, será controlada por meio de uma
ação conjunta entre as condições de associação e de busca, como HAVING e
WHERE.

Utilizando novamente as tabelas:

• Tabela Colaborador

inIdColab vcNome chSexo dcSalario


1 Luana Maia M 1000.00
2 André Inca M 1000.00
3 Suzana Silva F 2530.00
4 Rogério Tecca M 1752.00

• Tabela Dependente

inIdDepend inIdColab vcNomeDepen chSexo dtNascimento


1 4 Luana Maia M 03/05/2005
2 2 André Inca M 02/05/1998
3 1 Suzana Silva F 03/09/2001
4 1 Rogério Tecca M 05/06/1988

62
Capítulo 7 - Associando Tabelas

Podemos realizar uma consulta para retornar o Colaborador com seus


respectivos dependentes, utilizando a instrução da seguinte forma:

SELECT * FROM tb_Colaborador AS C


JOIN tb_Dependente AS D
ON C.inIdColab = D.inIdColab

Observe que para os nomes de tabelas utilizamos um apelido para nos


referirmos às tabelas na cláusula ON, caso o apelido não fosse criado teríamos
de especificar os nomes da tabela por completo ao invés de utilizar apenas “C” e
“D” antes dos códigos.

INNER JOIN

Inner Join é utilizado para combinar as linhas entre duas ou mais tabelas, com
base em alguns critérios de junção.
Uma junção interior é chamada de equijoin quando as colunas são comparadas
usando o =, e as duas colunas aparecem no resultado, mostrando dados
redundantes, já que elas têm o mesmo valor. Uma junção interior é chamada
junção natural quando a coluna usada para junção aparece apenas uma vez no
resultado, vinda de uma ou outra tabela.

Para o próximo exemplo, utilizaremos duas tabelas, a tabela de cliente e a tabela


de veículos, nosso objetivo será listar todos os clientes que possuem veículos.

• Tabela de Cliente

inIdClient
vcCliente vcDocumento vcEMail dtNascimento chFlagAtivo dtCadastro
e
1 Romulo Wendell 22653229812 rWendell@trans.com.br 08/01/2000 S 06/11/2008
2 Cristina Lima 42653229812 cLima@Sunn.com.br 08/01/1985 S 06/11/2008
3 Carla Tardoche 62653229812 Ctardoche@terra.com.br 08/12/1982 S 06/11/2008
4 Wagner Sasaki 92653229812 wSasakil@tucs.com.br 05/10/2001 S 06/11/2008
5 Daniel Bo 23053229812 dBo@lumens.com.br 07/05/1985 S 06/11/2008
6 Leticia Padovani 45653229812 lePadovani@tecnet.com.br 05/07/2002 S 06/11/2008

• Tabela de Veiculo

inIdVeiculo inIdCliente vcVeiculo chPlaca vcChassi vcAnoModelo chFlagAtivo


1 3 C3 DDD6872 f4gfd2hg4f6h5dd 2008/2008 S
2 5 Golf DDX6879 f4gfd564f6h5dd 2008/2008 S
3 2 Vectra ATD6878 f4gfd2hfsd6h5d 2005/2006 S
4 6 Astra DTD6856 f4gfd2hg4ffd66d 2007/2008 S

63
Capítulo 7 - Associando Tabelas

Create Table tb_Cliente


(
inIdCliente int identity(1,1) Not Null
, vcCliente varchar(150) Not Null
, vcDocumento varchar(11) Not Null
, vcEMail varchar(150)
, dtNascimento smalldatetime
, chFlagAtivo char(1) Not Null
, dtCadastro smalldatetime default getdate()
, Constraint Pk_cliente Primary Key (inIdCliente)
, Constraint UQ_vcDocumento Unique (vcDocumento)
, Constraint CK_ClienteAtivo Check (chFlagAtivo in ('S','N'))
)
GO

Insert into tb_cliente


values('Romulo Wendell', '22653229812', 'rWendell@trans.com.br','2000/08/01','S',default)
Insert into tb_cliente
values('Cristina Lima', '42653229812', 'cLima@Sunn.com.br','1985/08/01','S',default)
Insert into tb_cliente
values('Carla Tardoche', '62653229812', 'cTardoche@terra.com.br','1982/08/12','S',default)
Insert into tb_cliente
values('Wagner Sasaki', '92653229812', 'wSasakil@tucs.com.br','2001/05/10','S',default)
Insert into tb_cliente
values('Daniel Bo', '23053229812', 'dBo@lumens.com.br','1985/07/05','S',default)
Insert into tb_cliente
values('Leticia Padovani', '45653229812', 'lePadovani@tecnet.com.br','2002/05/07','S',default)

Create Table tb_Veiculo


(
inIdVeiculo int Identity(1,1) Not Null
, inIdCliente int
, vcVeiculo varchar(100) Not Null
, chPlaca char(7)
, vcChassi varchar(20)
, vcAnoModelo char(9)
, chFlagAtivo char(1)
, dtCadastro smalldatetime default getdate()
, Constraint Pk_Veiculo Primary Key (inIdVeiculo)
, Constraint UQ_CliVeic Unique (inIdVeiculo, InIdCliente)
, Constraint UQ_vcChassi Unique (vcChassi)
, Constraint CK_VeiculoAtivo Check (chFlagAtivo in ('S','N'))
, Constraint FK_Cliente Foreign Key (inIdCliente)
References tb_Cliente(inIdCliente)
)GO

Insert into tb_Veiculo


values(3,'C3','DDD6872','f4gfd2hg4f6h5dd','2008/2008','S', default)
Insert into tb_Veiculo
values(5,'Golf','DDX6879','f4gfd564f6h5dd','2008/2008','S', default)
Insert into tb_Veiculo
values(2,'Vectra','ATD6878','f4gfd2hfsd6h5d','2005/2006','S', default)
Insert into tb_Veiculo
values(6,'Astra','DTD6856','f4gfd2hg4ffd66d','2007/2008','S', default)

64
Capítulo 7 - Associando Tabelas

Como podemos observar, nas tabelas acima, a coluna inIdCliente, aparece nas duas
tabelas, porém cada tabela tem os seus atributos, a associação entre estas tabelas,
deverá ser feita através do código comum entre as tabelas, para retornarmos todos
os clientes que possuem veiculo utilizamos a seguinte instrução:

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo


From tb_Cliente as C
INNER JOIN tb_Veiculo as V
ON C.inIdcliente = V.inIdCliente
Order By 1

OU

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo


From tb_Cliente C, tb_Veiculo V
Where C.inIdcliente = V.inIdCliente
Order By 1

Estás duas formas será aceito pelo SQL Server, e ambas retornam o mesmo
resultado.

O resultado deste SELECT é a tabela abaixo:

inIdCliente vcCliente vcVeiculo chPlaca vcAnoModelo


2 Cristina Lima Vectra ATD6878 2005/2006
3 Carla Tardoche C3 DDD6872 2008/2008
5 Daniel Bo Golf DDX6879 2008/2008
6 Leticia Padovani Astra DTD6856 2007/2008

Notem que os clientes de ID 1 e 4 não foram listados nestas tabela, isso acontece
porque a função do INNER JOIN é justamente cruzar as informações que existem
em ambas as tabelas.

65
Capítulo 7 - Associando Tabelas

LEFT JOIN

Left Join ou Left Outer Join retorna os dados referentes a duas tabelas ou mais,
mas neste caso as linhas da primeira tabela, sem correspondência na segunda
tabela são preservadas e todos os dados da primeira tabela (esquerda), serão
apresentados.

Vejamos o exemplo abaixo utilizando as mesmas tabelas anteriores:

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo


From tb_Cliente as C
Left Outer Join tb_Veiculo as V
ON C.inIdcliente = V.inIdCliente
Order By 1

inIdCliente vcCliente vcVeiculo chPlaca vcAnoModelo


1 Romulo Wendell NULL NULL NULL
2 Cristina Lima Vectra ATD6878 2005/2006
3 Carla Tardoche C3 DDD6872 2008/2008
4 Wagner Sasaki NULL NULL NULL
5 Daniel Bo Golf DDX6879 2008/2008
6 Leticia Padovani Astra DTD6856 2007/2008

Note que mesmo não existindo um veiculo associado ao cliente 1 e 4, os


mesmos foram retornados na consulta, e os campos da segunda tabela que não
possuem valor, são retornados com o valor NULL.

66
Capítulo 7 - Associando Tabelas

RIGHT JOIN

Right Join ou Right Outer Join retorna os dados referentes a duas tabelas ou
mais, mas neste caso as linhas da segunda tabela, sem correspondência na
primeira tabela são preservadas e todos os dados da segunda tabela (direita),
serão apresentados.

Para este exemplo, será necessário inserir mais alguns veículos em nossa base
de dados.

Insert into tb_Veiculo


values(null,'C4 VTR','CDX6879','f4gfd564f6h3dd','2008/2008','S', default)
Insert into tb_Veiculo
values(null,'Audi A8','FBI6878','JKfd2hfsd6h5d','2005/2006','S', default)
Insert into tb_Veiculo
values(null,'New Civic','GTD6856','f4gfdfdg4ffd66d','2007/2008','S', default)

Após a inserção dos novos veiculo, reparem que os mesmos não estão
associados a nenhum inCodCliente por enquanto.

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo


From tb_Cliente as C
Right Outer JOIN tb_Veiculo as V
ON C.inIdcliente = V.inIdCliente
Order By 1

inIdCliente vcCliente vcVeiculo chPlaca vcAnoModelo


CDX68
NULL NULL C4 VTR 79 2008/2008
FBI687
NULL NULL Audi A8 8 2005/2006
New GTD68
NULL NULL Civic 56 2007/2008
ATD68
2 Cristina Lima Vectra 78 2005/2006
DDD68
3 Carla Tardoche C3 72 2008/2008
DDX68
5 Daniel Bo Golf 79 2008/2008
Leticia DTD68
6 Padovani Astra 56 2007/2008

Note que ao contrario do Left Join a tabela conservada é a tabela de veiculo,


onde é possível se ver todos os veiculo e os que ainda não possuem donos.

67
Capítulo 7 - Associando Tabelas

FULL JOIN

Full Join ou Full Outer Join retorna todos os dados referentes a duas ou mais
tabelas, quando realizamos uma consulta utilizando a cláusula Full Outer Join,
todas a linhas das tabelas são retornadas. Caso uma linha de dado de uma
tabela não seja associado a linha de outra, os valores não encontrados na outra
tabela serão listados como nulos.

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo


From tb_Cliente as C
Full Outer JOIN tb_Veiculo as V
ON C.inIdcliente = V.inIdCliente
Order By 1

inIdClient chPlac
e vcCliente vcVeiculo a vcAnoModelo
CDX687
NULL NULL C4 VTR 9 2008/2008
NULL NULL Audi A8 FBI6878 2005/2006
GTD685
NULL NULL New Civic 6 2007/2008
Romulo
1 Wendell NULL NULL NULL
ATD687
2 Cristina Lima Vectra 8 2005/2006
DDD687
3 Carla Tardoche C3 2 2008/2008
4 Wagner Sasaki NULL NULL NULL
DDX687
5 Daniel Bo Golf 9 2008/2008
Leticia DTD685
6 Padovani Astra 6 2007/2008

Note que neste caso não é necessário se preocupar com a tabela da direita ou
esquerda, este tipo de consulta retorna todos os registros que existem nas
tabelas referenciadas.

68
Capítulo 7 - Associando Tabelas

CROSS JOIN

As consultas do tipo Cross Join geram um produto cartesiano entre os registros


de duas tabelas. Em outras palavras, o Cross Join retorna uma linha para cada
possibilidade de combinação com outra linha da outra tabela. Se a tabela da
esquerda possuir N linhas e a tabela da direita possuir M linhas. O Cross Join
retornará N x M linhas.

Em uma consulta utilizando o Cross Join, não devemos utilizar a cláusula ON,
pois como o Cross Join cruza todos registros da primeira tabela, com todos os
registros da segunda tabela, não precisamos especificar uma condição de
consulta para estás tabelas.

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo


From tb_Cliente as C
Cross JOIN tb_Veiculo as V
Order By 1

OU
Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModelo
From tb_Cliente C, tb_Veiculo V
Order By 1

69
Capítulo 7 - Associando Tabelas

Resultado do Cross Join entre as tabelas Cliente e Veiculo:

inIdClie vcVeic chPlac vcAnoMod


nte vcCliente ulo a elo
Romulo DDD68
1 Wendell C3 72 2008/2008
Romulo DDX68
1 Wendell Golf 79 2008/2008
Romulo ATD68
1 Wendell Vectra 78 2005/2006
Romulo DTD68
1 Wendell Astra 56 2007/2008
Romulo CDX68
1 Wendell C4 VTR 79 2008/2008
Romulo FBI687
1 Wendell Audi A8 8 2005/2006
Romulo New GTD68
1 Wendell Civic 56 2007/2008
DDD68
2 Cristina Lima C3 72 2008/2008
DDX68
2 Cristina Lima Golf 79 2008/2008
ATD68
2 Cristina Lima Vectra 78 2005/2006
DTD68
2 Cristina Lima Astra 56 2007/2008
CDX68
2 Cristina Lima C4 VTR 79 2008/2008
FBI687
2 Cristina Lima Audi A8 8 2005/2006
New GTD68
2 Cristina Lima Civic 56 2007/2008
Carla DDD68
3 Tardoche C3 72 2008/2008
Carla DDX68
3 Tardoche Golf 79 2008/2008
Carla ATD68
3 Tardoche Vectra 78 2005/2006
Carla DTD68
3 Tardoche Astra 56 2007/2008
Carla CDX68
3 Tardoche C4 VTR 79 2008/2008
Carla FBI687
3 Tardoche Audi A8 8 2005/2006
Carla New GTD68
3 Tardoche Civic 56 2007/2008
Wagner DDD68
4 Sasaki C3 72 2008/2008
Wagner DDX68
4 Sasaki Golf 79 2008/2008
Wagner ATD68
4 Sasaki Vectra 78 2005/2006
4 Wagner Astra DTD68 2007/2008

70
Capítulo 7 - Associando Tabelas

Sasaki 56
Wagner CDX68
4 Sasaki C4 VTR 79 2008/2008
Wagner FBI687
4 Sasaki Audi A8 8 2005/2006
Wagner New GTD68
4 Sasaki Civic 56 2007/2008
DDD68
5 Daniel Bo C3 72 2008/2008
DDX68
5 Daniel Bo Golf 79 2008/2008
ATD68
5 Daniel Bo Vectra 78 2005/2006
DTD68
5 Daniel Bo Astra 56 2007/2008
CDX68
5 Daniel Bo C4 VTR 79 2008/2008
FBI687
5 Daniel Bo Audi A8 8 2005/2006
New GTD68
5 Daniel Bo Civic 56 2007/2008
Leticia DDD68
6 Padovani C3 72 2008/2008
Leticia DDX68
6 Padovani Golf 79 2008/2008
Leticia ATD68
6 Padovani Vectra 78 2005/2006
Leticia DTD68
6 Padovani Astra 56 2007/2008
Leticia CDX68
6 Padovani C4 VTR 79 2008/2008
Leticia FBI687
6 Padovani Audi A8 8 2005/2006
Leticia New GTD68
6 Padovani Civic 56 2007/2008
7.1. Os comandos UPDATE e DELETE

Suponhamos que alguns dados da tabela de cliente serão alterados, ou até


mesmo, removidos com base nos dados da tabela Ordem Serviço, sendo que
ambas estão relacionadas. Para realizar essa tarefa, devemos utilizar os
comandos UPDATE e DELETE com a clausula JOIN.

Para este exemplo utilizaremos a tabela de Cliente e Veiculo criadas


anteriormente, e criaremos uma nova tabela, a tabela OrdemServico.

inCodOS inIdVeiculo inIdCliente vcServico dtDataServico dcValorServico


1 1 3 Troca de óleo 07/11/2008 21:29 150.00
2 1 3 Troca de escapamento 07/11/2008 21:29 250.00
3 2 5 Troca de amortecedores 07/11/2008 21:30 550.00
4 4 6 Balanceamento 07/11/2008 21:30 120.00
5 3 2 Troca de Pneus P10.000 08/11/2008 21:32 2120.00

71
Capítulo 7 - Associando Tabelas

6 3 2 Troca Pastilhas Freio 07/11/2008 21:33 250.00

Create Table tb_OrdemServico


(
inCodOS int identity not null
, inIdCliente int
, inIdVeiculo int
, vcServico varchar(100)
, dtDataServico smalldatetime not null default getdate()
, dcValorServico decimal(10,2) not null
, Constraint PK_Servico Primary Key (inCodOs)
, Constraint FK_OSCliente Foreign key (inIdCliente) References tb_cliente(inIdCliente)
, Constraint FK_OSVeiculo Foreign Key (inIdVeiculo) References tb_veiculo(inIdVeiculo)
)

Antes de realizarmos um Update ou Delete, vamos realizar uma Seleção de


Multiplas Tabelas para retornarmos apenas os dados que estão relacionados
nas três tabelas:

• Tb_Cliente
• Tb_Veiculo
• Tb_OrdemServico

72
Capítulo 7 - Associando Tabelas

Para isso podemos fazer uso da cláusula INNER JOIN que listará apenas o
cliente que tiver veiculo e ter efetuado algum tipo de serviço.

SELECT O.inCodOS
, C.vcCliente
, V.vcVeiculo
, O.vcServico
, O.dvValorServico
, O.dtDataServico
FROM tb_Cliente AS C
INNER JOIN tb_veiculo AS V
ON C.inIdcliente = V.inIdcliente
INNER JOIN tb_ordemServico AS O
ON V.inIdVeiculo = O.inIdVeiculo
AND V.inIdcliente = O.inIdcliente

Para este SELECT temos o resultado:

inCod vcVeic dcValorServ


OS vcCliente ulo vcServico ico dtDataServico
Carla
1 Tardoche C3 Troca de óleo 150.00 07/11/2008 21:29
Carla Troca de
2 Tardoche C3 escapamento 250.00 07/11/2008 21:29
Troca de
3 Daniel Bo Golf amortecedores 550.00 07/11/2008 21:30
Leticia
4 Padovan Astra Balanceamento 120.00 07/11/2008 21:30
Troca de Pneus
5 Cristina Lima Vectra P10.000 2120.00 08/11/2008 21:32
Troca Pastilhas
6 Cristina Lima Vectra Freio 250.00 07/11/2008 21:33

UPDATE

Para exemplificar o uso do comando UPDATE, suponhamos que todos os preços


cobrados pelo serviço nos veículos C3 e Vectra, tenham de ser aumentado em
10%, então em primeiro lugar devemos conseguir encontrar todos os Clientes
com seus veículos C3 e Vectra e suas ordens de serviços:

SELECT O.inCodOS
, C.vcCliente
, V.vcVeiculo
, O.vcServico
, O.dvValorServico
, O.dtDataServico
FROM tb_Cliente AS C
INNER JOIN tb_veiculo AS V
ON C.inIdcliente = V.inIdcliente
INNER JOIN tb_ordemServico AS O
ON V.inIdVeiculo = O.inIdVeiculo
AND V.inIdcliente = O.inIdcliente
WHERE V.vcVeiculo like '%C3%'
OR V.vcVeiculo like '%Vectra%'

73
Capítulo 7 - Associando Tabelas

inCod vcVeic dcValorServ


OS vcCliente ulo vcServico ico dtDataServico
Carla
1 Tardoche C3 Troca de óleo 150.00 07/11/2008 22:26
Carla Troca de
2 Tardoche C3 escapamento 250.00 07/11/2008 22:26
Troca de Pneus
5 Cristina Lima Vectra P10.000 2120.00 08/11/2008 22:26
Troca Pastilhas
6 Cristina Lima Vectra Freio 250.00 07/11/2008 22:26

Após conseguirmos selecionar os dados corretos, devemos realizar o UPDATE,


utlizando as cláusulas que nos auxiliaram a encontrar os clientes que queriamos:

UPDATE tb_OrdemServico
SET dcValorServico = dcValorServico * 1.1
FROM tb_Cliente AS C
INNER JOIN tb_veiculo AS V
ON c.inIdcliente = v.inIdcliente
INNER JOIN tb_ordemServico AS O
ON V.inIdVeiculo = O.inIdVeiculo
AND V.inIdcliente = O.inIdcliente
WHERE V.vcVeiculo like '%C3%'
OR V.vcVeiculo like '%Vectra%'

Quando executamos este código a coluna dcValorServico é atualizada em 10%.

inCod vcVeic dcValorServ


OS vcCliente ulo vcServico ico dtDataServico
Carla
1 Tardoche C3 Troca de óleo 165.00 07/11/2008 22:26
Carla Troca de
2 Tardoche C3 escapamento 275.00 07/11/2008 22:26
Troca de Pneus
5 Cristina Lima Vectra P10.000 2332.00 08/11/2008 22:26
Troca Pastilhas
6 Cristina Lima Vectra Freio 275.00 07/11/2008 22:26

74
Capítulo 7 - Associando Tabelas

DELETE

Assim como atualizamos um determinado valor de uma linha, podemos utilizar a


mesma idéia, para excluir uma ou mais linhas da nossa tabela.
Para exemplificar suponhamos que queremos excluir as Ordens de Serviço
referentes ao veiculo C3.

Selecionamos primeiramente os dados a fim de validar se os filtros e JOINs estão de


acordo.

SELECT O.inCodOS
, C.vcCliente
, V.vcVeiculo
, O.vcServico
, O.dvValorServico
, O.dtDataServico
FROM tb_Cliente AS C
INNER JOIN tb_veiculo AS V
ON C.inIdcliente = V.inIdcliente
INNER JOIN tb_ordemServico AS O
ON V.inIdVeiculo = O.inIdVeiculo
AND V.inIdcliente = O.inIdcliente
WHERE V.vcVeiculo like '%C3%'

inCod vcVeic dcValorServ


OS vcCliente ulo vcServico ico dtDataServico
Carla
1 Tardoche C3 Troca de óleo 165.00 07/11/2008 22:26
Carla Troca de
2 Tardoche C3 escapamento 275.00 07/11/2008 22:26

Após selecionarmos os dados que desejamos apagar, utilizaremos o cláusula


DELETE para realizar a exclusão dos registros.

DELETE tb_ordemServico
FROM tb_Cliente AS C
INNER JOIN tb_veiculo AS V
ON c.inIdcliente = v.inIdcliente
INNER JOIN tb_ordemServico AS O
ON V.inIdVeiculo = O.inIdVeiculo
AND V.inIdcliente = O.inIdcliente
WHERE V.vcVeiculo like '%C3%'

75
Capítulo 8 - Union e Subquery

Capítulo 8 - Union e Subquery

No SQL Server, podemos unir o resultado referente à consulta de duas


tabelas, utilizando a execução da instrução SELECT para cada tabela.
Neste mesmo capitulo estudaremos a utilização de subqueries, para refinar a
consulta dos dados.

UNION, UNION ALL e EXCEPT

• UNION quando utilizamos somente a cláusula UNION combinamos o


resultado de duas tabelas, e o resultado não retornará dados duplicados,
ou seja, está cláusula aplica também a função distinct no resultado final,
assim os dados não aparecem duplicados.

• UNION ALL quando utilizamos a cláusula UNION ALL combinamos todos


os resultados da consulta das tabelas, e serão retornadas também linhas
duplicadas, caso a informação esteja ou fique duplicada na consulta.

• EXCEPT quando utilizamos a cláusula EXCEPT conseguimos identificar


as linhas que aparecem na primeira tabela, mas que não aparece na
segunda.

Para entendermos o uso das cláusulas Union, Union All e Except utilizaremos as
tabelas abaixo:

Tb_cliente
inIdClie
nte vcCliente vcEMail dtCadastro
Romulo rWendell@trans.co 08/01/2000
1 Wendell m.br 00:00
Renata rFerreiral@sql.com. 08/01/2000
2 Ferreira br 00:00
08/01/2000
3 Marcia Rita rRita@mmc.com.br 00:00
eYuriko@two.com.b 08/01/2000
4 Erika Yuriko r 00:00
mWillians@omg.co 08/01/2000
5 Max Willians m 00:00
Renato rPereira@cathu.co 08/01/2000
6 Pereira m.br 00:00

Tb_ator
inIdAto
r vcAtor mnSalario
Romulo 3500,00
1 Wendell
2 Max Willians 4500,00
Silmara 2500,00
3 Campos
4 Juliana Paes 8500,00

76
Capítulo 8 - Union e Subquery

Suzan 23500,00
5 Sarandon

77
Capítulo 8 - Union e Subquery

Tb_Comprador
inIdCompra
dor vcComprador chSexo
1 Denise Reis F
2 Marta Cordeiro F
3 Silmara Sullan F
4 Cassio Hebeshi M
Suzan
5 Sarandon F

O código a seguir cria as três tabelas anteriores.

Create Table tb_Cliente


(
inIdCliente int identity(1,1) Not Null
, vcCliente varchar(150) Not Null
, vcEMail varchar(150)
, dtCadastro smalldatetime default getdate()
, Constraint Pk_cliente Primary Key (inIdCliente)
)
GO
Insert into tb_cliente
values('Romulo Wendell', 'rWendell@hu.com.br','2000/08/01')
Insert into tb_cliente
values('Renata Ferreira', 'rFerreiral@sql.com.br','2000/08/01')
Insert into tb_cliente
values('Marcia Rita', 'rRita@mmc.com.br','2000/08/01')
Insert into tb_cliente
values('Erika Yuriko', 'eYuriko@two.com.br','2000/08/01')
Insert into tb_cliente
values('Max Willians', 'mWillians@omg.com','2000/08/01')
Insert into tb_cliente
values('Renato Pereira', 'rPereira@cathu.com.br','2000/08/01')

Create Table tb_Ator


(
inIdAtor int identity(1,1) Not Null
, vcAtor varchar(150) Not Null
, mnSalario money
, Constraint Pk_Ator Primary Key (inIdAtor)
)
GO
Insert into tb_Ator values('Romulo Wendell', 3500.00)
Insert into tb_Ator values('Max Willians', 4500.00)
Insert into tb_Ator values('Silmara Campos', 2500.00)
Insert into tb_Ator values('Juliana Paes', 8500.00)
Insert into tb_Ator values('Suzan Sarandon', 23500.00)

78
Capítulo 8 - Union e Subquery

Create Table tb_Comprador


(
inIdComprador int identity(1,1) Not Null
, vcComprador varchar(150) Not Null
, chSexo char(1) Not Null
, Constraint Pk_Comprador Primary Key (inIdComprador)
)
GO
Insert into tb_Comprador values('Denise Reis', 'F')
Insert into tb_Comprador values('Marta Cordeiro', 'F')
Insert into tb_Comprador values('Silmara Sullan', 'F')
Insert into tb_Comprador values('Cassio Hebeshi', 'M')
Insert into tb_Comprador values('Suzan Sarandon', 'F')

Union
Selecione apenas o código e nomes dos clientes e compradores

inIdCliente vcCliente
Romulo
1 Wendell
2 Max Willians
Select inIdCliente, vcCliente 2 Renata Ferreira
From tb_cliente 3 Marcia Rita
Union Silmara
Select inIdAtor, vcAtor 3 Campos
From tb_ator
4 Erika Yuriko
4 Juliana Paes
5 Max Willians
Suzan
5 Sarandon
6 Renato Pereira

Repare que para este exemplo não houve ocorrência de dados duplicados.

Union All

Selecione apenas o código e nomes dos clientes e compradores

inIdCliente vcCliente
1 Romulo Wendell
2 Renata Ferreira
3 Marcia Rita
Select inIdCliente, vcCliente
From tb_cliente 4 Erika Yuriko
Union All 5 Max Willians
Select inIdAtor, vcAtor 6 Renato Pereira
From tb_ator
1 Romulo Wendell
2 Max Willians
3 Silmara Campos
4 Juliana Paes
5 Suzan Sarandon

79
Capítulo 8 - Union e Subquery

Repare que para este exemplo houve ocorrência de dados duplicados.


As regras básicas para este tipo de consulta devem ser:

• O nome da coluna ou alias deve ser definido no primeiro SELECT.


• A inclusão da clausula WHERE pode ser realizada em qualquer comando
SELECT.
• É necessário que todos os comandos SELECT utilizados apresentem o
mesmo numero de colunas.
• É necessário que todas as colunas implementem o mesmo tipo de dado para
cada coluna.
• Para que os dados sejam ordenados o ultimo SELECT deverá aprestar a
instrução ORDER BY

Podemos também realizar a união de mais de duas tabelas implementando a


cláusula UNION ou UNION ALL mais uma vez após o ultimo SELECT.

Veja o exemplo:

inIdCliente vcCliente
1 Denise Reis
Romulo
1 Wendell
2 Marta Cordeiro
Select inIdCliente, vcCliente 2 Max Willians
From tb_cliente 2 Renata Ferreira
Union 3 Marcia Rita
Select inIdAtor, vcAtor
Silmara
From tb_ator
Union 3 Campos
Select inIdComprador, vcComprador 3 Silmara Sullan
From tb_comprador 4 Cassio Hebeshi
Order by inIdCliente, vcCliente
4 Erika Yuriko
4 Juliana Paes
5 Max Willians
Suzan
5 Sarandon
6 Renato Pereira

Except

Selecione apenas nomes que apareçam na primeira tabela de clientes, mas não
apareçam na tabela de atores.

Nomes
Select vcCliente As Nomes
From tb_cliente2 Erika Yuriko
Except Marcia Rita
Select vcAtor Renata Ferreira
From tb_ator
Renato Pereira

80
Capítulo 8 - Union e Subquery

81
Capítulo 8 - Union e Subquery

Subquery

Subquery é uma instrução SELECT que foi "embutida" em outra instrução


SELECT, UPDATE, DELETE ou dentro de outra subquery.

A finalidade da subquery é retornar um conjunto de linhas para o SELECT


principal, também podemos ouvir o nome de consulta aninhada e o limite Maximo
para este tipo de consulta é de 32 níveis, limite que pode variar de acordo com a
complexidade das outras instruções que compõem a consulta e da quantidade de
memória disponível no servidor.

Tipicamente utilizamos subqueries na filtragem de pesquisas (=cláusula WHERE)


nas cláusulas IN(), NOT IN(), EXISTS() e NOT EXISTS(), por oferecer diversas
formas de se obter os resultados, as subqueries eliminam a necessidade de
utilizarmos cláusulas JOIN e UNION de maior complexidade.

Para explicar a utilização das subqueries, consideremos as tabelas

Tb_Cargo

inCodCar
go vcCargo
Analista de
4 Sistemas
5 Arquiteto
2 Diretor
1 Presidente
3 Supervisor

Tb_Funcionario

inCodCar dcSalari chDocument


incodfunc go vcNome o o
1 5 Mario Antonio 8500.00 21.253.587
2 5 Romeu Franklin 8500.00 1.254.457
3 3 Thomas Edison 4500.00 258.328
4 3 Bartolomeu Junior 6500.00 50.653.458
Cristovão
5 2 Colombo 7000.00 00.258.147
6 1 Amado Batista 30000.00 13.565.158

Tb_Dependente

inCodDep inCodFunc vcNomeDep


1 1 Marcelle Belati
2 1 Thais Everlast
3 1 Ruy Armany
4 2 Sabrina de Sá
5 2 Vanderlei

82
Capítulo 8 - Union e Subquery

Luxamanaus
6 5 Rocksivan de Paivo
7 5 Renato de Oliveiro

83
Capítulo 8 - Union e Subquery

Create Table tb_cargo


(
inCodCargo int not null
, vcCargo varchar(50) not null
, Constraint pk_cargo primary key(inCodCargo)
, Constraint uq_cargo unique(vcCargo)
)
go

insert tb_cargo values(1,'Presidente')


insert tb_cargo values(2,'Diretor')
insert tb_cargo values(3,'Supervisor')
insert tb_cargo values(4,'Analista de Sistemas')
insert tb_cargo values(5,'Arquiteto')

go

Create Table tb_funcionario


(
incodfunc int not null
, inCodCargo int not null
, vcNome varchar(50) not null
, dcSalario decimal(10,2) not null
, chDocumento char(15) not null
, Constraint PK_func Primary Key(incodfunc)
, Constraint FK_func Foreign Key(inCodCargo) References tb_cargo(inCodCargo)
, Constraint CH_func Check(dcSalario > 0)
, Constraint UQ_func Unique(chDocumento)
)
go

insert tb_funcionario values(1,5,'Mario Antonio',8500.00,'21.253.587')


insert tb_funcionario values(2,5,'Romeu Franklin',8500.00,'01.254.457')
insert tb_funcionario values(3,3,'Thomas Edison', 4500.00,'258.328')
insert tb_funcionario values(4,3,'Bartolomeu Junior',6500.00,'50.653.458')
insert tb_funcionario values(5,2,'Cristovão Colombo',7000.00,'00.258.147')
insert tb_funcionario values(6,1,'Amado Batista', 30000.00,'13.565.158')
go

Create Table tb_dependente


( inCodDep int not null
, inCodFunc int not null
, vcNomeDep varchar(50) not null
, Constraint PK_dep Primary Key (inCodDep)
, Constraint FK_dep Foreign Key(inCodFunc) References tb_funcionario(inCodFunc)
)
go

insert tb_dependente values(1,1,'Marcelle Belati')


insert tb_dependente values(2,1,'Thais Everlast')
insert tb_dependente values(3,1,'Ruy Armany')
insert tb_dependente values(4,2,'Sabrina de Sá')
insert tb_dependente values(5,2,'Vanderlei Luxamanaus')
insert tb_dependente values(6,5,'Rocksivan de Paivo')
insert tb_dependente values(7,5,'Renato de Oliveiro')
go

84
Capítulo 8 - Union e Subquery

Subquery introduzida com IN/NOT

Observando as tabelas cargo e funcionário, queremos descobrir quais os cargos


que estão atualmente ocupados na nossa empresa.

Para este tipo de consulta, devemos selecionar os cargos que estão na tabela de
funcionários, para isso podemos utilizar uma subquery com o operador IN:

Select * From tb_cargo


Where incodCargo IN (Select incodcargo From tb_funcionario)

inCodCargo vcCargo
1 Presidente
2 Diretor
3 Supervisor
5 Arquiteto

E para descobrirmos os cargos que não possuem funcionários podemos realizar


a mesma consulta, mas alterando a cláusula IN para NOT IN, assim podemos
saber quais os cargos que não existem na tabela de funcionários.

Select * From tb_cargo


Where incodCargo NOT IN (Select incodcargo From tb_funcionario)

inCodCargo vcCargo
Analista de
4 Sistemas

Podemos também consultar os cargos onde os funcionários não possuem


nenhum dependente.

Select * From tb_cargo


Where incodCargo IN (Select incodcargo From tb_funcionario
Where inCodFunc NOT IN (Select inCodFunc
From tb_dependente))

inCodCargo vcCargo
1 Presidente
3 Supervisor

85
Capítulo 8 - Union e Subquery

Subquery introduzida com o sinal de igual (=)

Vamos observar a tabela de funcionário:

inCodCar dcSalari chDocument


incodfunc go vcNome o o
1 5 Mario Antonio 8500.00 21.253.587
2 5 Romeu Franklin 8500.00 1.254.457
3 3 Thomas Edison 4500.00 258.328
4 3 Bartolomeu Junior 6500.00 50.653.458
Cristovão
5 2 Colombo 7000.00 00.258.147
6 1 Amado Batista 30000.00 13.565.158

É possível notar que o funcionário de código 3 possui o menor salário, e o


funcionário de código 6 possui o maior salário. Podemos obter estes dados com
a ajuda de duas funções de totalização, que indicam qual o menor valor e qual o
maior valor em um campo, os nomes destas funções são Min() e Max().

• Min(): Está função retorna o menor valor de um conjunto.


• Max(): Está função retorna o maior valor de um conjunto.

Utilizando estas funções, podemos descobrir de forma rápida qual o funcionário


da nossa empresa que possui o maior salário, e qual o funcionário da nossa
empresa que possui o menor salário.

O maior salário:

Select * From tb_funcionario


Where dcSalario IN (Select max(dcSalario) From tb_funcionario)

inCodCar dcSalari chDocumen


incodfunc go vcNome o to
Amado 30000.0
6 1 Batista 0 13.565.158

O menor salário:

Select * From tb_funcionario


Where dcSalario IN (Select min(dcSalario) From tb_funcionario)

inCodCar dcSala chDocumen


incodfunc go vcNome rio to
Thomas 4500.0
3 3 Edison 0 258.328

86
Capítulo 8 - Union e Subquery

Update com Subqueries

As subqueries também podem ser úteis para a atualização de registros. Vamos


supor que precisamos reajustar em 10% o valor do salário de todos os
funcionários que não possuem dependentes. Isso é obtido através do seguinte
código:

Update tb_funcionario
set dcSalario = dcSalario* 1.1
Where inCodfunc NOT IN (Select InCodFunc From tb_dependente)

Delete com Subqueries

Também podemos utilizar subqueries para remover dados das tabelas. Vamos
supor que precisamos remover todos os funcionários que não possuem
dependentes. Para isso utilizaremos o seguinte conjunto de instruções:

Delete From tb_funcionario


Where inCodfunc NOT IN (Select InCodFunc From tb_dependente)

87
Capítulo 9 - Totalizando Dados

Capítulo 9 - Totalizando Dados

Neste capitulo aprenderemos técnicas para gerar dados de resumo com


funções agregadas e GROUP BY.

A cláusula GROUP BY

A cláusula GROUP BY agrupa diversos registros baseado em uma ou mais


colunas de uma ou mais tabelas. Uma linha é retornada para cada grupo de
valores retornados em uma consulta.

A cláusula Group By é freqüentemente utilizada em conjunto com as


seguintes funções:

• COUNT(): Função para contar os registros.

• SUM(): Função que realiza a soma dos registros.

• MAX(): Função que retorna o maior valor de um grupo de valores.

• MIN(): Função que retorna o menor valor de um grupo de valores.

• AVG(): Função que realiza o cálculo da média dos valores.

Observemos, a seguir, a sintaxe apresentada pela documentação do books


online:

[ GROUP BY [ ALL ] group_by_expression [ ,...n ]


[ WITH { CUBE | ROLLUP } ]

• ALL: Esse recurso será removido em uma versão futura de Microsoft


SQL Server. Evite usar esse recurso em desenvolvimentos novos e
planeje modificar os aplicativos que atualmente o utilizam. Inclui todos
os grupos e conjuntos de resultados, mesmo aqueles que não têm
linhas que atendem às critério de pesquisa especificadas na cláusula
WHERE. Quando ALL é especificado, valores nulos são retornados
para as colunas de resumo de grupos que não satisfazem aos critérios
de pesquisa. Não é possível especificar ALL com os operadores CUBE
ou ROLLUP.
GROUP BY ALL não tem suporte em consultas que acessam tabelas
remotas se houver também uma cláusula WHERE na consulta.

• group_by_expression: É uma expressão na qual o agrupamento é


executado group_by_expression é também conhecido como coluna de
agrupamento. group_by_expression pode ser uma coluna ou uma
expressão de não agregação que referencia uma coluna retornada
pela cláusula FROM. Um alias de coluna que está definido na lista
SELECT não pode ser usado para especificar uma coluna de
agrupamento.
88
Capítulo 9 - Totalizando Dados

Observação: Colunas do tipo text, ntext e image não podem ser


usadas em group_by_expression.

• Para cláusulas GROUP BY que não contêm CUBE nem ROLLUP, o


número de itens de group_by_expression é limitado pelos tamanhos
da coluna GROUP BY, as colunas de agregação e os valores de
agregação envolvidos na consulta. Esse limite tem origem no limite de
8.060 bytes na tabela de trabalho intermediária que é necessária para
manter resultados de consulta intermediários. Um máximo de 12
expressões de agrupamento é permitido quando CUBE ou ROLLUP é
especificado.

Para compreendermos o uso da cláusula GROUP BY utilizaremos o


exemplo da tabela de roupas abaixo:

inCodRo vcTipoRo vcMarcaRo chTamanhoR inQtdRo dcVal


upa upa upa oupa upa or
Calça
1 Jeans Viva Eloah P 200 90.00
Calça
2 Jeans Viva Eloah M 300 90.00
Calça
3 Jeans Viva Eloah G 100 90.00
Calça 150.0
4 Jeans NOfficers P 200 0
Calça 150.0
5 Jeans NOfficers M 300 0
Calça 150.0
6 Jeans NOfficers G 100 0
Calça 120.0
7 Jeans Rellus P 80 0
Calça 120.0
8 Jeans Rellus M 100 0
Calça 120.0
9 Jeans Rellus G 50 0
10 Camiseta Viva Eloah P 100 45.00
11 Camiseta Viva Eloah M 200 45.00
12 Camiseta Viva Eloah G 250 45.00
120.0
13 Camiseta Jacarezinho P 50 0
120.0
14 Camiseta Jacarezinho M 60 0
120.0
15 Camiseta Jacarezinho G 20 0
145.0
16 Camiseta Cavalinho P 80 0
145.0
17 Camiseta Cavalinho M 120 0
18 Camiseta Cavalinho G 30 145.0

89
Capítulo 9 - Totalizando Dados

0
Calça Vila 130.0
19 Social Espartana P 20 0
Calça Vila 130.0
20 Social Espartana M 40 0
Calça Vila 130.0
21 Social Espartana G 15 0
Calça Mario
22 Social Bertolli P 60 80.00
Calça Mario
23 Social Bertolli M 30 80.00
Calça Mario
24 Social Bertolli G 20 80.00
25 Top Gasta-Gasta P 200 15.00
26 Top Gasta-Gasta M 300 15.00
27 Top Gasta-Gasta G 300 15.00

90
Capítulo 9 - Totalizando Dados

CREATE TABLE TB_Roupa(


inCodRoupa int not null identity(1,1)
, vcTipoRoupa varchar(150) not null
, vcMarcaRoupa varchar(150) not null
, chTamanhoRoupa char(22) not null
, inQtdRoupa int not null
, dcValor decimal(10,2) not null
)

GO

insert into tb_roupa values('Calça Jeans', 'Viva Eloah', 'P', 200, 90)
insert into tb_roupa values('Calça Jeans', 'Viva Eloah', 'M', 300, 90)
insert into tb_roupa values('Calça Jeans', 'Viva Eloah', 'G', 100, 90)

insert into tb_roupa values('Calça Jeans', 'NOfficers', 'P', 200, 150)


insert into tb_roupa values('Calça Jeans', 'NOfficers', 'M', 300, 150)
insert into tb_roupa values('Calça Jeans', 'NOfficers', 'G', 100, 150)

insert into tb_roupa values('Calça Jeans', 'Rellus', 'P', 80, 120)


insert into tb_roupa values('Calça Jeans', 'Rellus', 'M', 100, 120)
insert into tb_roupa values('Calça Jeans', 'Rellus', 'G', 50, 120)

insert into tb_roupa values('Camiseta', 'Viva Eloah', 'P', 100, 45)


insert into tb_roupa values('Camiseta', 'Viva Eloah', 'M', 200, 45)
insert into tb_roupa values('Camiseta', 'Viva Eloah', 'G', 250, 45)

insert into tb_roupa values('Camiseta', 'Jacarezinho', 'P', 50, 120)


insert into tb_roupa values('Camiseta', 'Jacarezinho', 'M', 60, 120)
insert into tb_roupa values('Camiseta', 'Jacarezinho', 'G', 20, 120)

insert into tb_roupa values('Camiseta', 'Cavalinho', 'P', 80, 145)


insert into tb_roupa values('Camiseta', 'Cavalinho', 'M', 120, 145)
insert into tb_roupa values('Camiseta', 'Cavalinho', 'G', 30, 145)

insert into tb_roupa values('Calça Social', 'Vila Espartana', 'P', 20 , 130 )


insert into tb_roupa values('Calça Social', 'Vila Espartana', 'M', 40, 130)
insert into tb_roupa values('Calça Social', 'Vila Espartana', 'G', 15, 130)

insert into tb_roupa values('Calça Social', 'Mario Bertolli', 'P', 60 , 80 )


insert into tb_roupa values('Calça Social', 'Mario Bertolli', 'M', 30, 80)
insert into tb_roupa values('Calça Social', 'Mario Bertolli', 'G', 20, 80)

insert into tb_roupa values('Top', 'Gasta-Gasta', 'P', 200, 15)


insert into tb_roupa values('Top', 'Gasta-Gasta', 'M', 300, 15)
insert into tb_roupa values('Top', 'Gasta-Gasta', 'G', 300, 15)

91
Capítulo 9 - Totalizando Dados

A partir da tabela de roupas, suponhamos que desejamos saber a quantidade


de registros em nossa tabela:

Select count(*) From tb_roupa

Está instrução retorna a quantidade de registros (linhas) que existe na tabela, neste
caso 27 linhas.

Mas ainda não estamos satisfeitos com esta informação, queremos saber a
quantidade de cada tipo de roupa que existe em nossa loja:

Select vcTipoRoupa, sum(inQtdRoupa) as Total


From tb_roupa
Group by vcTipoRoupa

Observe que o resultado foi agrupado pelo campo vcTipoRoupa

vcTipoRo
upa Total
Calça
Jeans 1430
Calça
Social 185
Camiseta 910
Top 800

Para mais um exemplo pratico, desejamos saber a quantidade de roupas


agrupadas pelas marcas:

Select vcMarcaRoupa, sum(inQtdRoupa) as Total


From tb_roupa
Group by vcMarcaRoupa

vcMarcaRou
pa Total
Cavalinho 230
Gasta-Gasta 800
Jacarezinho 130
Mario Bertolli 110
NOfficers 600
Rellus 230
Vila
Espartana 75
Viva Eloah 1150

92
Capítulo 9 - Totalizando Dados

Para tornar o exemplo um pouco mais interessante, vamos agrupar o total


pelo tipo de roupa e suas respectivas marcas:

Select vcTipoRoupa, vcMarcaRoupa, sum(inQtdRoupa) as Total


From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa

vcTipoRoup vcMarcaRo
a upa Total
Camiseta Cavalinho 230
Top Gasta-Gasta 800
Camiseta Jacarezinho 130
Mario
Calça Social Bertolli 110
Calça Jeans NOfficers 600
Calça Jeans Rellus 230
Vila
Calça Social Espartana 75
Calça Jeans Viva Eloah 600
Camiseta Viva Eloah 550

Também podemos apresentar como resultado o preço total das roupas,


multiplicando a quantidade total pelo seu preço:

Select vcTipoRoupa
, vcMarcaRoupa
, sum(inQtdRoupa * dcValor) as [Valor Total]
From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa

vcTipoRoup vcMarcaRo Valor


a upa Total
Camiseta Cavalinho 33350.00
Top Gasta-Gasta 12000.00
Camiseta Jacarezinho 15600.00
Mario
Calça Social Bertolli 8800.00
Calça Jeans NOfficers 90000.00
Calça Jeans Rellus 27600.00
Vila
Calça Social Espartana 9750.00
Calça Jeans Viva Eloah 54000.00
Camiseta Viva Eloah 24750.00

93
Capítulo 9 - Totalizando Dados

Para que o resultado retorne a quantidade e o valor total, será preciso o


mesmo procedimento do exemplo anterior:

Select vcTipoRoupa
, vcMarcaRoupa
, sum(inQtdRoupa) as Quantidade
, sum(inQtdRoupa* dcValor) as [Valor Total]
From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa

vcTipoRoup vcMarcaRo Quantida Valor


a upa de Total
Camiseta Cavalinho 230 33350.00
Top Gasta-Gasta 800 12000.00
Camiseta Jacarezinho 130 15600.00
Mario
Calça Social Bertolli 110 8800.00
Calça Jeans NOfficers 600 90000.00
Calça Jeans Rellus 230 27600.00
Vila
Calça Social Espartana 75 9750.00
Calça Jeans Viva Eloah 600 54000.00
Camiseta Viva Eloah 550 24750.00

A cláusula HAVING com GROUP BY

A cláusula Having, determina uma condição de busca, para selecionar quais


os grupos a que será exibido no resultado. Por exemplo, para selecionar os
tipos de roupas onde o a quantidade seja maior que 200, pode-se fazer da
seguinte maneira:
Select vcTipoRoupa, vcMarcaRoupa
, Sum(inQtdRoupa) as Quantidade
, Sum(inQtdRoupa* dcValor) as [Valor Total]
From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa
Having Sum(inQtdRoupa) > 200

vcTipoRoup vcMarcaRo Quantida Valor


a upa de Total
Camiseta Cavalinho 230 33350.00
Top Gasta-Gasta 800 12000.00
Calça Jeans NOfficers 600 90000.00
Calça Jeans Rellus 230 27600.00
Calça Jeans Viva Eloah 600 54000.00
Camiseta Viva Eloah 550 24750.00

94
Capítulo 9 - Totalizando Dados

Suponhamos, agora, que desejamos obter apenas aquelas cuja quantidade


ultrapasse as 200 unidades e cujos valores estocado é igual ou superior a
50000,00, vejamos a instrução:

Select vcTipoRoupa, vcMarcaRoupa


, Sum(inQtdRoupa) as Quantidade
, Sum(inQtdRoupa * dcValor) as [Valor Total]
From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa
Having Sum(inQtdRoupa) > 200
And Sum(inQtdRoupa * dcValor) >= 50000

vcTipoRoup vcMarcaRo Quantida Valor


a upa de Total
Calça Jeans NOfficers 600 90000.00
Calça Jeans Viva Eloah 600 54000.00

95
Capítulo 9 - Totalizando Dados

A cláusula WITH ROLLUP com GROUP BY

A cláusula WITH ROLLUP gera linhas de subtotal para cada condição exclusiva
de valores definidos EM GROUP BY. A ordem das colunas afeta os
agrupamentos de saída de ROLLUP e pode afetar o numero de linhas do
conjunto de resultado.

Para este exemplo utilizaremos a mesma tabela de roupas criada anteriormente.

Suponhamos que desejamos exibir ainda a quantidade de roupas e suas


respectivas marcas contabilizando um subtotal para cada tipo de roupa e marca,
utilizando a cláusula WITH ROLLUP objetos o seguinte resultado:

Select vcTipoRoupa, vcMarcaRoupa


, Sum(inQtdRoupa) as Quantidade
, Sum(inQtdRoupa* dcValor) as [Valor Total]
From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa
With Rollup

vcTipoRoup vcMarcaRo Quantida Valor


a upa de Total
Calça Jeans NOfficers 600 90000.00
Calça Jeans Rellus 230 27600.00
Calça Jeans Viva Eloah 600 54000.00
Calça Jeans NULL 1430 171600.00
Mario
Calça Social Bertolli 110 8800.00
Vila
Calça Social Espartana 75 9750.00
Calça Social NULL 185 18550.00
Camiseta Cavalinho 230 33350.00
Camiseta Jacarezinho 130 15600.00
Camiseta Viva Eloah 550 24750.00
Camiseta NULL 910 73700.00
Top Gasta-Gasta 800 12000.00
Top NULL 800 12000.00
NULL NULL 3325 275850.00

Cada campo NULL apresentado nesta tabela representa a linha de total referente
a cada agrupamento, sendo que a ultima linha representa o total geral.

96
Capítulo 9 - Totalizando Dados

A cláusula CUBE com GROUP BY

A cláusula CUBE gera linhas de subtotal para cada condição exclusiva de


valores definidos EM GROUP BY como ROLLUP e gera também linhas de
tabulação cruzada.

A quantidade de linhas de subtotal no conjunto de resultados é especificada de


acordo com a quantidade de colunas incluídas na cláusula GROUP BY.

Vejamos o exemplo abaixo:

Select vcTipoRoupa
, vcMarcaRoupa
, chTamanhoRoupa
, Sum(inQtdRoupa) as Quantidade
, Sum(inQtdRoupa* dcValor) as [Valor Total]
From tb_roupa
Group by vcTipoRoupa, vcMarcaRoupa, chTamanhoRoupa
With Cube

vcTipoRo vcMarcaRo chTamanhoR Quantid Valor


upa
Calça upa
NOfficers G oupa ade
100 Total
15000.0
Jeans
Calça NOfficers M 300 0
45000.0
Jeans
Calça NOfficers P 200 0
30000.0
Jeans
Calça NOfficers NULL 600 0
90000.0
Jeans
Calça Rellus G 50 0
6000.00
Jeans
Calça Rellus M 100 12000.0
Jeans
Calça Rellus P 80 0
9600.00
Jeans
Calça Rellus NULL 230 27600.0
Jeans
Calça Viva Eloah G 100 0
9000.00
Jeans
Calça Viva Eloah M 300 27000.0
Jeans
Calça Viva Eloah P 200 0
18000.0
Jeans
Calça Viva Eloah NULL 600 0
54000.0
Jeans
Calça NULL NULL 1430 0
171600.
Jeans
Calça Mario G 20 00
1600.00
Social
Calça Bertolli
Mario M 30 2400.00
Social
Calça Bertolli
Mario P 60 4800.00
Social
Calça Bertolli
Mario NULL 110 8800.00
Social
Calça Bertolli
Vila G 15 1950.00
Social
Calça Espartana
Vila M 40 5200.00
Social
Calça Espartana
Vila P 20 2600.00
Social
Calça Espartana
Vila NULL 75 9750.00
Social
Calça Espartana
NULL NULL 185 18550.0
Social
Camiseta Cavalinho G 30 0
4350.00
Camiseta Cavalinho M 120 17400.0
Camiseta Cavalinho P 80 0
11600.0
Camiseta Cavalinho NULL 230 0
33350.0
Camiseta Jacarezinho G 20 0
2400.00
Camiseta Jacarezinho M 60 7200.00
Camiseta Jacarezinho P 50 6000.00
Camiseta Jacarezinho NULL 130 15600.0
0
97
Capítulo 9 - Totalizando Dados

Camiseta Viva Eloah G 250 11250.0


Camiseta Viva Eloah M 200 0
9000.00
Camiseta Viva Eloah P 100 4500.00
Camiseta Viva Eloah NULL 550 24750.0
Camiseta NULL NULL 910 0
73700.0
Top Gasta-Gasta G 300 0
4500.00
Top Gasta-Gasta M 300 4500.00
Top Gasta-Gasta P 200 3000.00
Top Gasta-Gasta NULL 800 12000.0
Top NULL NULL 800 0
12000.0
NULL NULL NULL 3325 0
275850.
NULL Cavalinho G 30 00
4350.00
NULL Cavalinho M 120 17400.0
NULL Cavalinho P 80 0
11600.0
NULL Cavalinho NULL 230 0
33350.0
NULL Gasta-Gasta G 300 0
4500.00
NULL Gasta-Gasta M 300 4500.00
NULL Gasta-Gasta P 200 3000.00
NULL Gasta-Gasta NULL 800 12000.0
NULL Jacarezinho G 20 0
2400.00
NULL Jacarezinho M 60 7200.00
NULL Jacarezinho P 50 6000.00
NULL Jacarezinho NULL 130 15600.0
NULL Mario G 20 0
1600.00
NULL Bertolli
Mario M 30 2400.00
NULL Bertolli
Mario P 60 4800.00
NULL Bertolli
Mario NULL 110 8800.00
NULL Bertolli
NOfficers G 100 15000.0
NULL NOfficers M 300 0
45000.0
NULL NOfficers P 200 0
30000.0
NULL NOfficers NULL 600 0
90000.0
NULL Rellus G 50 0
6000.00
NULL Rellus M 100 12000.0
NULL Rellus P 80 0
9600.00
NULL Rellus NULL 230 27600.0
NULL Vila G 15 0
1950.00
NULL Espartana
Vila M 40 5200.00
NULL Espartana
Vila P 20 2600.00
NULL Espartana
Vila NULL 75 9750.00
NULL Espartana
Viva Eloah G 350 20250.0
NULL Viva Eloah M 500 0
36000.0
NULL Viva Eloah P 300 0
22500.0
NULL Viva Eloah NULL 1150 0
78750.0
Calça NULL G 250 0
30000.0
Jeans
Calça NULL G 35 0
3550.00
Social
Camiseta NULL G 300 18000.0
Top NULL G 300 0
4500.00
NULL NULL G 885 56050.0
Calça NULL M 700 0
84000.0
Jeans 0
98
Capítulo 9 - Totalizando Dados

Calça NULL M 70 7600.00


Social
Camiseta NULL M 380 33600.0
Top NULL M 300 0
4500.00
NULL NULL M 1450 129700.
Calça NULL P 480 00
57600.0
Jeans
Calça NULL P 80 0
7400.00
Social
Camiseta NULL P 230 22100.0
Top NULL P 200 0
3000.00
NULL NULL P 990 90100.0
0

A cláusula JOIN com GROUP BY

A cláusula GROUP BY também pode ser implementada com SELECT que


implemente cláusulas JOINs podem assim ser retornado dados adicionais que
estão em outra tabela.
Para implementarmos o GROUP BY em conjunto com a cláusula JOIN, vamos
criar mais uma tabela, apenas para ilustrar está outra maneira de trazer a
informação.

Aplique a alteração abaixo na tabela de roupa, para que o mesmo passe a


referenciar a nova tabela:

Alter table tb_Roupa add constraint fk_tamanho Foreign key (chTamanhoRoupa)


References tb_tamanhoRoupa(chCodTamanho)
GO
Create table tb_tamanhoRoupa(
chCodTamanho char(2)
, vcDescTamanho varchar(50)
, Constraint PK_codTamanho Primary Key (chCodTamanho)
)
GO
insert into tb_tamanhoRoupa values('P','Pequeno')
insert into tb_tamanhoRoupa values('M','Médio')
insert into tb_tamanhoRoupa values('G','Grande')

Vamos agora realizar a consulta utilizando nossa nova tabela descrição do


tamanho da roupa:

Select vcTipoRoupa, vcMarcaRoupa, chTamanhoRoupa, t.vcDescTamanho


, Sum(inQtdRoupa) as Quantidade
, Sum(inQtdRoupa* dcValor) as [Valor Total]
From tb_roupa as r
Inner join tb_tamanhoRoupa as t
on r.chTamanhoRoupa = t.chCodTamanho
Group by vcTipoRoupa, vcMarcaRoupa, chTamanhoRoupa, t.vcDescTamanho

99
Capítulo 9 - Totalizando Dados

vcTipoRoup vcMarcaRoup chTamanhoR vcDescTam Quantid Valor


a a oupa anho ade Total
Calça Jeans NOfficers G Grande 100 15000.00
Calça Jeans NOfficers M Médio 300 45000.00
Calça Jeans NOfficers P Pequeno 200 30000.00
Calça Jeans Rellus G Grande 50 6000.00
Calça Jeans Rellus M Médio 100 12000.00
Calça Jeans Rellus P Pequeno 80 9600.00
Calça Jeans Viva Eloah G Grande 100 9000.00
Calça Jeans Viva Eloah M Médio 300 27000.00
Calça Jeans Viva Eloah P Pequeno 200 18000.00
Calça Social Mario Bertolli G Grande 20 1600.00
Calça Social Mario Bertolli M Médio 30 2400.00
Calça Social Mario Bertolli P Pequeno 60 4800.00
Calça Social Vila Espartana G Grande 15 1950.00
Calça Social Vila Espartana M Médio 40 5200.00
Calça Social Vila Espartana P Pequeno 20 2600.00
Camiseta Cavalinho G Grande 30 4350.00
Camiseta Cavalinho M Médio 120 17400.00
Camiseta Cavalinho P Pequeno 80 11600.00
Camiseta Jacarezinho G Grande 20 2400.00
Camiseta Jacarezinho M Médio 60 7200.00
Camiseta Jacarezinho P Pequeno 50 6000.00
Camiseta Viva Eloah G Grande 250 11250.00
Camiseta Viva Eloah M Médio 200 9000.00
Camiseta Viva Eloah P Pequeno 100 4500.00
Top Gasta-Gasta G Grande 300 4500.00
Top Gasta-Gasta M Médio 300 4500.00
Top Gasta-Gasta P Pequeno 200 3000.00

100
Capítulo 10 - Compute BY

Capítulo 10 - Compute BY

A cláusula Compute By nos permite exibir totais como colunas de resumo


adicionais no fim do conjunto de resultados. Podemos utilizar a cláusula Compute
com ou sem o By, para obtermos dados totalizados. Quando utilizamos a cláusula
Compute By podemos visualizar totalizações de dados sem o agrupamento deles.

Utilizando a tabela de roupa do capitulo 9 podemos realizar totalizações das


quantidades de produtos da seguinte maneira:

Select vcTipoRoupa
, vcMarcaRoupa
, inQtdRoupa
From tb_roupa
order by vcTipoRoupa
Compute Sum(inQtdRoupa) By vcTipoRoupa

Para esta instrução temos um resultado com 4 tabelas, pois optamos no exemplo
anterior Computar pelo tipo de roupa, logo é criada uma tabela para cada tipo de
roupa, como nas imagens abaixo:

vcTipoRoupa vcTipoRo vcMarcaRo inQtdRou


vcMarcaR inQtdRoup upa upa pa
oupa a Calça Vila
Calça Jeans Viva Eloah 200 Social Espartana 20
Calça Vila
Calça Jeans Viva Eloah 300
Social Espartana 40
Calça Jeans Viva Eloah 100 Calça Vila
Calça Jeans NOfficers 200 Social Espartana 15
Calça Jeans NOfficers 300 Calça Mario
Social Bertolli 60
Calça Jeans NOfficers 100
Calça Mario
Calça Jeans Rellus 80 Social Bertolli 30
Calça Jeans Rellus 100 Calça Mario
Calça Jeans Rellus 50 Social Bertolli 20
SUM SUM
1430 185

vcTipoRo vcMarcaRo inQtdRou vcTipoRo vcMarcaRo inQtdRou


upa upa pa upa upa pa
Camiseta Viva Eloah 100 Top Gasta-Gasta 200
Camiseta Viva Eloah 200 Top Gasta-Gasta 300
Camiseta Viva Eloah 250 Top Gasta-Gasta 300
Camiseta Jacarezinho 50 SUM
Camiseta Jacarezinho 60 800
Camiseta Jacarezinho 20
Camiseta Cavalinho 80
Camiseta Cavalinho 120
Camiseta Cavalinho 30
SUM

101
Capítulo 10 - Compute BY

910

10.1. COMPUTE BY com JOIN

A cláusula COMPUTE BY também pode ser utilizada com a cláusula JOIN, a fim
de se ter a associação de várias tabelas.

Para o próximo exemplo devemos criar uma tabela de material que indicara o
tipo de material utilizado para se fazer a roupa e também iremos realizar algumas
alterações na tabela de roupas.

inCodMateri
al vcMaterial
1 Algodão
2 Poliéster
3 Microfibra
4 Misto

Create table tb_material(


inCodMaterial int not null identity(1,1)
, vcMaterial varchar(150) not null
, Constraint PK_Material Primary Key (inCodMaterial)
)
GO
insert into tb_material values('Algodão')
insert into tb_material values('Poliéster')
insert into tb_material values('Microfibra')
insert into tb_material values('Misto')
insert into tb_material values('Jeans')

Alter table tb_roupa add inCodMaterial int


Alter table tb_roupa add Constraint FK_Material
Foreign Key (inCodMaterial) References tb_material(inCodMaterial)

update tb_roupa
set incodMaterial = 5
where vctiporoupa = 'calça Jeans'

update tb_roupa
set incodMaterial = 4
where vctiporoupa = 'camiseta'
And incodroupa in(10,11,12)

update tb_roupa
set incodMaterial = 1
where vctiporoupa = 'camiseta'
And incodroupa not in(10,11,12)

update tb_roupa
set incodMaterial = 3
where vctiporoupa = 'Calça Social'

update tb_roupa
set incodMaterial = 2
where vctiporoupa = 'top'

102
Capítulo 10 - Compute BY

A seguir, temos um exemplo da utilização da cláusula Compute By com Join:

Select m.vcMaterial as Material


, r.vcTipoRoupa as [Tipo de Roupa]
, r.vcMarcaRoupa as Marca
, r.inQtdRoupa as Quantidade
From tb_roupa as r
Inner Join tb_material as m
On r.incodmaterial = m.incodmaterial
Order By m.vcMaterial , r.vcTipoRoupa
Compute Sum(inQtdRoupa)
By m.vcMaterial, r.vcTipoRoupa
Compute Sum(inQtdRoupa) --este Compute gera um total geral

Material
Tipo de Material Tipo de Roupa Marca Quantidade
Roupa Marca Quantidade Jeans Calça Jeans Viva Eloah 200
Algodão Camiseta Jacarezinho 50 Jeans Calça Jeans Viva Eloah 300
Algodão Camiseta Jacarezinho 60 Jeans Calça Jeans Viva Eloah 100
Algodão Camiseta Jacarezinho 20 Jeans Calça Jeans NOfficers 200
Algodão Camiseta Cavalinho 80 Jeans Calça Jeans NOfficers 300
Algodão Camiseta Cavalinho 120 Jeans Calça Jeans NOfficers 100
Algodão Camiseta Cavalinho 30 Jeans Calça Jeans Rellus 80
SUM Jeans Calça Jeans Rellus 100
360 Jeans Calça Jeans Rellus 50
SUM
1430
Material Tipo de Roupa Marca Quantidade Material Tipo de Roupa Marca Quantidade
Microfibra Calça Social Vila Espartana 20 Misto Camiseta Viva Eloah 100
Microfibra Calça Social Vila Espartana 40 Misto Camiseta Viva Eloah 200
Microfibra Calça Social Vila Espartana 15 Misto Camiseta Viva Eloah 250
Microfibra Calça Social Mario Bertolli 60 SUM
Microfibra Calça Social Mario Bertolli 30 550
Microfibra Calça Social Mario Bertolli 20 Material Tipo de Roupa Marca Quantidade
SUM Poliéster Top Gasta-Gasta 200
185 Poliéster Top Gasta-Gasta 300
Poliéster Top Gasta-Gasta 300
SUM
800
SUM
3325

103
Capítulo 10 - Compute BY

Resumindo dados usando COMPUTE e COMPUTE BY

Os valores resumidos, gerados por COMPUTE, aparecem como conjuntos de


resultados distintos nos resultados da consulta. O resultado de uma consulta que
incluem uma cláusula COMPUTE são como um relatório de control-break. Trata-
se de um relatório cujos valores de resumo são controlados pelos agrupamentos
ou quebras especificados.# Você pode produzir valores resumidos para grupos e
também calcular mais de uma função de agregação para o mesmo grupo.

Quando COMPUTE é especificada com a cláusula BY opcional, há dois


conjuntos de resultados para cada grupo qualificado para SELECT:

• O primeiro conjunto de resultados de cada grupo possui o conjunto de


linhas de detalhe que contêm as informações da lista de seleção para
aquele grupo.
• O segundo conjunto de resultados de cada grupo possui uma linha que
contém os subtotais das funções de agregação especificadas na cláusula
COMPUTE daquele grupo.

Quando COMPUTE é especificada sem a cláusula BY opcional, há dois


conjuntos de resultados para SELECT:

• O primeiro conjunto de resultados de cada grupo tem todas as linhas


de detalhe que contêm as informações da lista selecionada.
• O segundo conjunto de resultados possui uma linha que contém os
totais das funções de agregação especificadas na cláusula COMPUTE.

104
Capítulo 10 - Compute BY

As diferenças entre COMPUTE e GROUP BY

• COMPUTE produz diversos grupos de resultados. Um tipo de conjunto de


resultado contém as linhas de detalhes de cada grupo que contêm as
expressões da lista selecionada. O outro tipo de conjunto de resultados
contém o subagregado de um grupo ou o agregado total da instrução
SELECT. A lista selecionada pode conter outras expressões além das
colunas de agrupamento ou funções de agregação. As funções de agregação
são especificadas na cláusula COMPUTE; não na lista de seleção.

• GROUP BY produz um grupo de resultados único. Há uma linha para cada


grupo que contém apenas as colunas de agrupamento e funções de
agregação que mostram a subagregação daquele grupo. A lista selecionada
pode conter apenas as colunas de agrupamento e funções de agregação.

Obs. Você não poderá incluir tipos de dados ntext, text ou image em uma
cláusula COMPUTE ou COMPUTE BY.

105
Capítulo 11 – Tabelas

Capítulo 11 – Tabelas

Todas as informações do banco de dados SQL Server são armazenados em


tabelas. Geralmente, os dados são armazenados em tabelas permanentes; porém,
você também pode criar tabelas temporárias.

Tabela permanente

Podemos dizer que uma tabela é permanente quando ela continuar existindo
mesmo que seja encerrada a conexão na qual ela foi criada.
Suponhamos que desejamos criar uma nova tabela de roupa que utilizamos no
exemplo anterior no capitulo 10. Para isso, podemos criar executando a seguinte
instrução:

Select * Into tb_produto From tb_roupa

Tabela temporária Global

Tabelas temporárias são similares a tabelas permanentes, exceto por serem


armazenadas no tempdb e excluídas automaticamente quando não são mais
usadas.

Há dois tipos de tabelas temporárias: local e global. Elas diferem uma da outra
pelo nome, visibilidade e disponibilidade. As tabelas temporárias locais têm um
único sinal numérico (#) como primeiro caractere no nome; elas são visíveis
somente na conexão atual para o usuário e são excluídas quando o usuário se
desconecta da instância do SQL Server. As tabelas temporárias globais têm dois
sinais numéricos (##) como primeiros caracteres no nome; elas são visíveis a
qualquer usuário após serem criadas e são excluídas quando todos os usuários
que consultam a tabela se desconectam da instância do SQL Server.

• Exemplo de tabela temporária local

Select * Into #tb_produto From tb_roupa

• Exemplo de tabela temporária global

Select * Into ##tb_produto From tb_roupa

106
Capítulo 12 – Case

Capítulo 12 – Case

A cláusula CASE

As informações pertencentes a uma tabela podem ser testadas por meio da


cláusula CASE em conjunto com uma instrução SELECT. Está cláusula é muito
utilizada para controlarmos os resultados de uma consulta. Para exemplificar
utilizaremos a seguinte tabela de cliente:

inCod_cl chSexo
i vcNome_cli _cli
Andre
1 Mobilete M
2 Tiago Abano NULL
Monica
3 Mendes F
4 Luis Carlos M
Renata
5 França F

create table tb_cliente


(
inCod_cli int identity
, vcNome_cli varchar(30)
, chSexo_cli char(1)
)
GO
insert into tb_cliente values('Andre Mobilete', 'M')
insert into tb_cliente values('Tiago Abano', Null)
insert into tb_cliente values('Monica Mendes', 'F')
insert into tb_cliente values('Luis Carlos', 'M')
insert into tb_cliente values('Renata França', 'F')

Após criarmos a nova tabela de cliente iremos selecionar todos os campos, mas
o campo sexo deverá ser apresentado como Masculino ou Feminino.
Vejamos o exemplo do SELECT

Select inCod_cli as Codigo


, vcNome_cli as Cliente
, Sexo = Case chSexo_cli
when 'M' then 'Masculino'
when 'F' then 'Feminino'
Else 'Não Saber'
End
From tb_cliente

O resultado desta seleção é a tabela abaixo:

Codi
go Cliente Sexo
1 Andre Mobilete Masculino
2 Tiago Abano Não Saber

107
Capítulo 12 – Case

3 Monica Mendes Feminino


4 Luis Carlos Masculino
5 Renata França Feminino

108
BIBLIOGRAFICA BÁSICA

BIBLIOGRAFICA BÁSICA

Livros:
BATISTI, Julio. SQL SERVER 2005 Administração e Desenvolvimento: Curso
Completo. São Paulo, Axcel Books: 2005.

DAMAS, Luís. SQL: Structured Query Language. 6 ed. São Paulo, LTC: 2007.

Paul Wilton and John W. Colby, Beginning SQL, Published by Wiley Publishing, Inc.

Apostila SQL Server 7.

Sites:
http://www.mhavila.com.br/link/db/sql.html
http://www.devmedia.com.br/articles/viewcomp_forprint.asp?comp=4832
http://www.linhadecodigo.com.br/Artigo.aspx?id=669
http://www.50minutos.com.br/2007/05/datatypes-do-sql-server/
http://www.odetocode.com/Articles/79.aspx
http://www.shammas.eng.br/acad/materiais/mer.pdf
http://pt.wikipedia.org/wiki/Modelo_de_Entidades_e_Relacionamentos
http://msdn.microsoft.com/pt-br/library/ms190452.aspx
http://msdn.microsoft.com/pt-br/library/ms177399.aspx

109

You might also like