SQL Server Completa

SQL SERVER Rudson Kiyoshi Souza Carvalho

[email protected]

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...........................................................................2PRÉ-REQUISITOS........................................................................2DURAÇÃO...................................................................................2OBJETIVO...................................................................................2INTRODUÇÃO.............................................................................3Capítulo 1 - Conceitos básicos.....................................................7

1.1. Banco de dados....................................................................................................71.2. Modelos de Banco de Dados.............................................................................71.3. Banco de dados relacional.................................................................................91.4. Origem da linguagem SQL.................................................................................91.5. A linguagem Transact-SQL..............................................................................111.6. SQL Server Management Studio.....................................................................12

Capítulo 2 - Alguns objetos do SQL Server.................................132.1. Principais objetos do SQL Server....................................................................132.2. Databases...........................................................................................................142.3. Tabelas................................................................................................................152.4. Criando a primeira Tabela................................................................................152.5. O comando Insert...............................................................................................162.6. A instrução Select..............................................................................................172.7. A segunda Tabela..............................................................................................182.8. A terceira Tabela................................................................................................19

Capítulo 3 - DML Simples..........................................................203.1. INSERT................................................................................................................201.1.1. INSERT posicional.............................................................................................211.1.2. INSERT declarativo...........................................................................................223.2. SELECT...............................................................................................................231.1.3. Exibir todas as colunas.....................................................................................231.1.4. Exibir algumas colunas.....................................................................................231.1.5. Exibir algumas colunas utilizando alias..........................................................231.1.6. Exibir algumas colunas utilizando alias com espaço no nome...................241.1.7. Criando uma coluna virtual com o comando SELECT.................................251.1.8. Exibindo um cálculo com comando SELECT................................................261.1.9. Exibindo apenas uma vez os dados repetidos – DISTINCT.......................271.1.10. Copiando dados de uma tabela para outra tabela utilizando os comandos

INSERT com SELECT......................................................................................281.1.10.1. INSERT com SELECT quando as tabelas são iguais..................................281.1.10.2. INSERT com SELECT quando as tabelas são diferentes..........................293.3. UPDATE..............................................................................................................301.3.1. Alterando dados de uma coluna......................................................................301.3.2. Alterando dados de varias colunas.................................................................313.4. DELETE...............................................................................................................31

Capítulo 4 - A cláusula WHERE..................................................324.1. A cláusula WHERE com os operadores lógicos AND e OR.......................344.2. A cláusula WHERE com o operador IN..........................................................354.3. A cláusula WHERE com os operadores NOT IN..........................................364.4. A cláusula WHERE com o operador BETWEEN.........................................374.5. A cláusula WHERE com os operadores NOT BETWEEN..........................374.6. O Operador LIKE................................................................................................38

4.7. A cláusula WHERE com os operadores NOT LIKE.....................................40Capítulo 5 - A Cláusula ORDER BY..............................................41

5.1. ORDER BY..........................................................................................................415.2. Ordenando por colunas.....................................................................................411.2.1. Ordenando por uma coluna..............................................................................411.2.2. Ordenando por varias colunas.........................................................................415.3. ORDER BY ASC e DESC.................................................................................425.4. A cláusula TOP...................................................................................................435.5. A cláusula TOP com Order By.........................................................................445.6. A cláusula TOP WITH TIES com ORDER BY...............................................44

Capítulo 6 - Integridade e Consistência dos Dados.....................466.1. Regras de Integridade e consistência............................................................466.2. Constraints..........................................................................................................486.3. Chaves primárias...............................................................................................486.4. Chaves primárias, secundárias ou chaves únicas........................................506.5. Chaves estrangeiras..........................................................................................516.6. Regras de validação..........................................................................................521.6.1. Valor Padrão.......................................................................................................521.6.2. Valores nulos e não nulos................................................................................521.6.3. Data types...........................................................................................................531.6.4. Regras de Constraints.......................................................................................54

Constraint DEFAULT.................................................................54Constraint UNIQUE...................................................................54Constraint CHECK.....................................................................54Constraint PRIMARY KEY...........................................................54Constraint FOREIGN KEY...........................................................54

6.7. Modelo entidade e relacionamento (MER)....................................................556.8. Relacionamento..................................................................................................561.8.1. Relacionamento 1:1...........................................................................................561.8.2. Relacionamento 1:N..........................................................................................561.8.2.1. Regras de relacionamento 1:N........................................................................571.8.3. Relacionamento N:N..........................................................................................571.8.4. Regras de relacionamento N:N........................................................................58

Capítulo 7 - Associando Tabelas................................................617.1. JOIN.....................................................................................................................617.2. INNER JOIN........................................................................................................637.3. LEFT JOIN...........................................................................................................667.4. RIGHT JOIN........................................................................................................677.5. FULL JOIN...........................................................................................................687.6. CROSS JOIN......................................................................................................697.7. Os comandos UPDATE e DELETE.................................................................717.8. UPDATE..............................................................................................................727.9. DELETE...............................................................................................................74

Capítulo 8 - Union e Subquery...................................................758.1. UNION, UNION ALL e EXCEPT......................................................................758.2. Subquery.............................................................................................................798.3. Subquery introduzida com IN/NOT.................................................................818.4. Subquery introduzida com o sinal de igual (=)..............................................828.5. Update com Subqueries....................................................................................838.6. Delete com Subqueries.....................................................................................83

Capítulo 9 - Totalizando Dados..................................................849.1. A cláusula GROUP BY......................................................................................849.2. A cláusula HAVING com GROUP BY.............................................................899.3. A cláusula WITH ROLLUP com GROUP BY.................................................919.4. A cláusula CUBE com GROUP BY.................................................................929.5. A cláusula JOIN com GROUP BY...................................................................94

Capítulo 10 - Compute BY.........................................................9610.1. COMPUTE BY com JOIN.................................................................................9710.2. Resumindo dados usando COMPUTE e COMPUTE BY............................9910.3. As diferenças entre COMPUTE e GROUP BY...........................................100

Capítulo 11 – Tabelas..............................................................10111.1. Tabela permanente..........................................................................................10111.2. Tabela temporária Global...............................................................................101

Capítulo 12 – Case..................................................................10212.1. A cláusula CASE..............................................................................................102

BIBLIOGRAFICA BÁSICA............................................................................103

Capítulo 1 - Conceitos básicos


1.1. 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.

1.2. 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


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


1.3. 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.

1.4. 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


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

1986 SQL-86 SQL-87(Adotado pela ISO)

Primeira publicação do padrão ANSI/ISO

1989 SQL-89 Apenas uma pequena versão do padrão original

1992 SQL-92 SQL2Maior atualização do padrão original e ainda suportando os padrões originais

1999 SQL99 SQL3

Atualização do padrão acrescentado em 1992 e novas formas de selecionar os dados, e aplicada novas regras de integridade dos dados e a introdução da orientação a objetos.

2003 SQL-2003Introduzido suporte a XML e campos de valores auto geráveis.

10


1.5. 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


1.6. 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

2.1. 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

http://www.50minutos.com.br/2007/05/objetos-do-sql-server/


2.2. 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


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”

2.3. 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

2.4. Criando a primeira Tabela

Neste exemplo temos uma tabela chamada Tb_Cliente.

inCod_Cli vcNome_Cli1 Marina Farina2 Edson Mendes3 Aline Moda4 Tatiana Souza5 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


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

2.5. 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


2.6. 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


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_Cli1 Marina Farina R Campos, 299 3211-1563 [email protected] Edson Mendes Av. Paulista, 277 5125-2000 [email protected] Aline Moda Al. Santos, 512 4116-1518 [email protected] Tatiana Souza Av. Rebouças, 15 9985-0965 [email protected] Cássio Adriano Av. 9 de julho, 60 5465-1358 [email protected]

Criaremos está tabela no banco de dados DB_Estudo

use DB_Estudocreate 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_clientevalues(1,'Marina Farina','R Campos, 299','3211-1563','[email protected]')insert tb_cliente values(2,'Edson Mendes','Av. Paulista, 277','5125-2000','[email protected]')insert tb_cliente values(3,'Aline Moda','Al. Santos, 512','4116-1518','[email protected]')insert tb_cliente values(4,'Tatiana Souza','Av. Rebouças, 15','9985-0965','[email protected]')insert tb_cliente values(5,'Cássio Adriano','Av. 9 de julho, 60','5465-1358','[email protected]')

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

mailto:[email protected]






2.7. 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

1Marina Farina

R Campos, 299

3211-1563 [email protected] 1800.00 04/15/2008

2Edson Mendes

Av. Paulista, 277

5125-2000 [email protected] 1210.10 03/20/2007

3 Aline ModaAl. Santos, 512

4116-1518 [email protected] 2000.00 08/28/2006

4Tatiana Souza

Av. Rebouças, 15

9985-0965 [email protected] 1500.30 05/01/2004

5Cássio Adriano

Av. 9 de julho 5465-1358 [email protected] 1945.88 24/06/2005

use db_estudocreate 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','[email protected]',1800.00,'15/04/2008')insert tb_cliente values(2,'Edson Mendes','Av. Paulista, 277','5125-2000','[email protected]',1210.10,'20/03/2007')insert tb_cliente values(3,'Aline Moda','Al. Santos, 512','4116-1518','[email protected]',2000.00,'28/08/2006')insert tb_cliente values(4,'Tatiana Souza','Av. Rebouças, 15','9985-0965','[email protected]',1500.30,'05/01/2004')insert tb_cliente values(5,'Cássio Adriano','Av. 9 de julho, 60','5465-1358','[email protected]',1945.88,'24/06/2005')

19







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.

3.1. 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


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

1.1.1. 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','[email protected]','4500.26','10/15/02')

INSERT Tb_ClienteVALUES (2,'Adalberto Bacili','Rua 2','3288-1563','[email protected]','5600.38','10/20/03')

INSERT Tb_Cliente VALUES (3,'Sérgio Manoel','Rua São Bento','4545-1212','[email protected]','4982.74','01/25/04')

INSERT Tb_Cliente VALUES (4,'Thiago Hawano','Rua Direta','7875-1520','[email protected]','6423.12','02/14/06')

INSERT Tb_Cliente VALUES (5,'Carina Tugues','Rua Torta ','3132-3113','[email protected]','6800.98','01/13/98')

INSERT Tb_Cliente VALUES (6,'Fabio Monte','Av. Santos','2526-1515','[email protected]','4678.15','06/25/92')

21


1.1.2. 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','[email protected]','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','[email protected]','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', '[email protected]', '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


3.2. 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.

1.1.3. 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.

1.1.4. 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

1.1.5. 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


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

1.1.6. 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


1.1.7. 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


1.1.8. 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


1.1.9. 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_clFROM 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


1.1.10. 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.

1.1.10.1. 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 SELECT * FROM tb_cliente

INSERT tb_funcionarioSELECT * FROM tb_cliente

28


1.1.10.2. 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(

inCod_cli int , vcNome_cli varchar(30), vcEnd_cli varchar(30) , 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

)

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_funcionarioSELECT inCod_cli

, vcNome_cli, vcEnd_cli, ’0000-0000’, ‘Não tem e-mail’, 0,dtData_cli

FROM tb_cliente

INSERT Tb_funcionarioSELECT inCod_cli

, vcNome_cli, vcEnd_cli, ’0000-0000’, ‘Não tem e-mail’, 0,dtData_cli

FROM tb_cliente

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

29


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.

1.3.1. 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


1.3.2. Alterando dados de varias colunas

Para alterarmos os dados de diferentes colunas da tabela devemos especificar o nome das colunas separadas por vírgula.


, dtData_cli = dtData_cli + 1


, dtData_cli = dtData_cli + 1FROM Tb_cliente

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

3.4. 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


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)

)GOINSERT 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


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

UPDATE tb_ProdutoSET dcValor_Prod = dcValor_Prod *1.1WHERE vcTipo_Prod = 'Informática'

SELECT * FROM tb_ProdutoWHERE vcTipo_Prod = ‘Informática’

DELETE FROM tb_produtoWHERE inCod_Prod = 8

Exemplos :

Exemplo 1: Alteração linha

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 165.002 Mouse Informática 300 49.503 Filmadora Digital Digitais 500 2500.004 Celular Telefones 1000 1500.005 DVD Player Eletrônicos 150 150.006 Caixas de Som Informática 20 88.007 Televisor Digitais 50 25000.008 Régua Escritório 180 10.009 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_Prod1 Teclado Informática 100 165.002 Mouse Informática 300 49.506 Caixas de Som Informática 20 88.009 CD Informática 320 1.65


33


Exemplo 3: Apagar linha

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 165.002 Mouse Informática 300 49.503 Filmadora Digital Digitais 500 2500.004 Celular Telefones 1000 1500.005 DVD Player Eletrônicos 150 150.006 Caixas de Som Informática 20 88.007 Televisor Digitais 50 25000.009 CD Informática 320 1.65


4.1. 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_ProdutoWHERE vcTipo_Prod = 'Informática'AND inQtd_Prod < 300

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 165.006 Caixas de Som Informática 20 88.00

34


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_ProdutoSET dcValor_Prod = dcValor_Prod *1.1WHERE vcTipo_Prod = 'Eletrônicos'

OR dcValor_Prod < = 700.00

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 181.502 Mouse Informática 300 54.453 Filmadora Digital Digitais 500 2500.004 Celular Telefones 1000 1500.005 DVD Player Eletrônicos 150 165.006 Caixas de Som Informática 20 96.807 Televisor Digitais 50 25000.009 CD Informática 320 1.82


4.2. 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_ProdutoWHERE vcTipo_Prod = 'Eletrônicos'OR vcTipo_Prod = 'Informática'

Exemplo Operador IN

SELECT * FROM tb_ProdutoWHERE vcTipo_Prod IN ('Eletrônicos','Informática')

35


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

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 181.502 Mouse Informática 300 54.455 DVD Player Eletrônicos 150 165.006 Caixas de Som Informática 20 96.809 CD Informática 320 1.82


4.3. 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_ProdutoWHERE 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_ProdutoWHERE vcTipo_Prod <> 'Eletrônicos'AND vcTipo_Prod <> 'Informática'

SELECT * FROM tb_ProdutoWHERE vcTipo_Prod != 'Eletrônicos'AND vcTipo_Prod != 'Informática'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod3 Filmadora Digital Digitais 500 2500.004 Celular Telefones 1000 1500.007 Televisor Digitais 50 25000.00

36


4.4. 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_ProdutoWHERE 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_ProdutoWHERE dcValor_Prod >= 100.00 AND dcValor_Prod <= 500.00

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 181.505 DVD Player Eletrônicos 150 165.00

4.5. 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_ProdutoWHERE 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_ProdutoWHERE dcValor_Prod < 100.00 OR dcValor_Prod > 500.00

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod2 Mouse Informática 300 54.453 Filmadora Eletrônicos 500 2750.004 Celular Eletrônicos 1000 1650.006 Caixas de Som Informática 20 96.807 Televisor Eletrônicos 50 27500.009 CD Informática 320 1.82


37


4.6. 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_produtoWHERE vcNome_Prod LIKE 'C%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod4 Celular Eletrônicos 1000 1650.006 Caixas de Som Informática 20 96.809 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_produtoWHERE vcNome_Prod LIKE '%ad%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 181.503 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_produtoWHERE vcNOme_Prod LIKE '[CD]%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod4 Celular Telefones 1000 1500.005 DVD Player Eletrônicos 150 165.006 Caixas de Som Informática 20 96.809 CD Informática 320 1.82


38


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

SELECT * FROM tb_produtoWHERE 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


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

SELECT * FROM tb_produtoWHERE vcNome_Prod LIKE '[^T]%'


2 Mouse Informática 300 54.45







Caso invertamos a posição da % como no exemplo abaixo, teremos o valores que terminam com, por exemplo, R.

SELECT * FROM tb_produtoWHERE vcNome_Prod LIKE '%R'




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


4.7. 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_produtoWHERE vcNome_Prod NOT LIKE '%R%'

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod1 Teclado Informática 100 181.502 Mouse Informática 300 54.456 Caixas de Som Informática 20 96.809 CD Informática 320 1.82


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

SELECT * FROM tb_produtoWHERE vcNome_Prod NOT LIKE 'c%'


1 Teclado Informática 100 181.50






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


5.1. 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.

5.2. Ordenando por colunas

Podemos utilizar como critério de ordenação, o nome ou o numero referente a coluna que se deseja ordenar.

1.2.1. Ordenando por uma coluna

SELECT * FROM tb_produtoORDER BY vcNome_Prod

SELECT * FROM tb_produtoORDER BY 2











1.2.2. Ordenando por varias colunas

SELECT * FROM tb_produtoORDER BY vcTipo_Prod, dcValor_Prod

SELECT * FROM tb_produtoORDER BY 3,5










4 Celular Telefones 1000 1500.005.3. ORDER BY ASC e DESC

41


Na cláusula ORDER BY pode-se adicionar mais uma instrução que indica se a ordenação será ascendente ou descendente.

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

SELECT vcNome_Prod, dcValor_Prod FROM tb_produtoORDER BY dcValor_Prod ASC

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

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

SELECT vcNome_Prod, dcValor_Prod FROM tb_produtoORDER BY dcValor_Prod DESC

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

42


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_produtoORDER BY vcTipo_Prod ASC, dcValor_Prod DESC

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

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

5.4. 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_Prod1 Teclado Informática 100 181.502 Mouse Informática 300 54.453 Filmadora Digital Digitais 500 2500.004 Celular Telefones 1000 1500.005 DVD Player Eletrônicos 150 165.00

43


5.5. A cláusula TOP com Order By

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

SELECT TOP 3 * FROM tb_ProdutoORDER BY dcValor_Prod DESC

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod7 Televisor Digitais 50 25000.003 Filmadora Digital Digitais 500 2500.004 Celular Telefones 1000 1500.00

5.6. 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_ProdutoORDER BY inQtd_Prod ASC

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod6 Caixas de Som Informática 20 96.801 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


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_ProdutoORDER BY inQtd_Prod ASC

inCod_Prod vcNome_Prod vcTipo_Prod inQtd_Prod dcValor_Prod6 Caixas de Som Informática 20 96.801 Teclado Wireless Informática 20 150.007 Televisor Digitais 50 25000.001 Teclado Informática 100 181.505 DVD Player Eletrônicos 150 165.002 Mouse Informática 300 54.459 CD Informática 320 1.82

10 DVD Informática 500 4.243 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.

6.1. 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


Para que possamos compreender as regras referentes à integridade e à consistência de dados, utilizaremos a tabela de Colaborador, descrita abaixo.

vcNome chSexo dcSalarioLuana Maia M 1980.00André Inca M 2103.00Suzana Silva F 2530.00Rogério Tecca M 1752.00André 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


6.2. 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 ConstraintsChave Primária Constraint Primary KeyChave Estrangeira Constraint Foreign Key e Constraint

ReferencesChave Primária, Secundária ou Chave Unica Constraint UniqueRegras de validação Constaint CheckValor Padrão Constraint Default

6.3. 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


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

vcNome chSexo dcSalario inIdLuana Maia M 1980.00 1André Inca M 2103.00 2Suzana Silva F 2530.00 3Rogério Tecca M 1752.00 4André 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 - SementeCorresponde 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


6.4. 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 vcDocumentoLuana Maia M 1980.00 1 NULLAndré Inca M 2103.00 2 NULLSuzana Silva F 2530.00 3 NULLRogério Tecca M 1752.00 4 NULLAndré Inca M 2103.00 5 NULL

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

vcNome chSexo dcSalario inId vcDocumentoLuana Maia M 1980.00 1 22623228884André Inca M 2103.00 2 22623228881Suzana Silva F 2530.00 3 22623228882Rogério Tecca M 1752.00 4 22623228883André 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


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.

6.5. 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 Chave Primária vcNome

vcDocumento Chave Única

chSexo Apenas M ou F

dcSalario valores positivos

1 Luana Maia 22623228884 M 1980.002 André Inca 22623228881 M 2103.003 Suzana Silva 22623228882 F 2530.004 Rogério Tecca 22623228883 M 1752.00

Tabela de Dependente

inIdDepen Chave Primária inIdColab vcNome dtNasc

chSexo apenas M ou F vcParente

1 4 Isabella da Silva 02/13/95 F Filha2 2 Marina Faria 01/15/82 F Esposa3 3 Paulo Henrique 09/21/80 M Marido4 3 Aline Faria 07/16/93 F Filha3 1 Thiago Maia 09/21/99 M Filho

51


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.

6.6. 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.

1.6.1. 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

inIdColab vcNome chSexo dcSalario

valor padrão 1000.00

1 Luana Maia M 1000.00

2 André Inca M 1000.00

3 Suzana Silva F 2530.004 Rogério Tecca M 1752.00

1.6.2. 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


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).

1.6.3. 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

NOMETAMANHO (BYTES)

MENOR VALOR

MAIOR VALOR ARMAZENA

BIGINT 8 -263 263 - 1 INTEIROINT 4 -231 231 - 1 INTEIROSMALLINT 2 -215 215 - 1 INTEIROTINYINT 1 0 255 INTEIRO

DECIMAL(C, D) VARIÁVEL -1038 1038 - 1DECIMAL EXATO, ONDE C INDICA NÚMERO DE POSIÇÕES E D O NÚMERO DE CASAS DECIMAIS

NUMERIC(C, D) VARIÁVEL -1038 1038 - 1DECIMAL EXATO, ONDE C INDICA NÚMERO DE POSIÇÕES E D O NÚMERO DE CASAS DECIMAIS

MONEY 8 -263 263 - 1 MONETÁRIO - EQUIVALE A UM DECIMAL COM 4 CASAS DECIMAISSMALLMONEY 4 -231 231 - 1 MONETÁRIO - EQUIVALE A UM DECIMAL COM 4 CASAS DECIMAIS

FLOAT(D) 4 OU 8 -1.79 X 10308 1.79 X 10308PONTO FLUTUANTE, ONDE D INDICA O NÚMERO MÁXIMO DE CASAS DECIMAIS, ENTRE 0 E 53

REAL 4 -3.4 X 1038 3.4 X 1038 PONTO FLUTUANTE - EQUIVALENTE AO FLOAT(24)

TIPOS TEXTO

NOME TABELALIMITE (CARACTERES)

TAMANHO (CARACTERES)

ARMAZENA

CHAR(N) ASCII 8000 EXATAMENTE NCARACTERES, ONDE N INDICA O TAMANHO DO CAMPO

VARCHAR(N) ASCII 8000 ATÉ NCARACTERES, ONDE N INDICA O TAMANHO DO CAMPO

NCHAR(N)UNICODE

4000 EXATAMENTE NCARACTERES, ONDE N INDICA O TAMANHO DO CAMPO

NVARCHAR(N)

UNICODE

4000 ATÉ NCARACTERES, ONDE N INDICA O TAMANHO DO CAMPO

TEXT ASCII 231 - 1 ATÉ 231 - 1 CARACTERES

NTEXTUNICODE

231 - 1 ATÉ 231 - 1 CARACTERES

TIPOS DATA HORA

NOMETAMANHO (BYTES)

MENOR VALOR MAIOR VALOR PRECISÃO

DATETIME 81753-01-01 00:00:00.000

9999-12-31 23:59:59.997

3.33 ms

SMALLDATETIME

4 1/1/1900 00:00 6/6/2079 23:591 MINUTO, SENDO QUE ATÉ 29.998ms ARREDONDA PARA MENOS E ACIMA DISSO PARA O PROXIMO

53


1.6.4. 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

54


referenciar a um outro campo que possua ou uma chave primária ou uma constraint UNIQUE.

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.

6.7. 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


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.

6.8. 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.

1.8.1. 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.

1.8.2. 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


Tabela Colaborador





Tabela Dependente

inIdDepend inIdColab vcNomeDepen chSexo dtNascimento

1 4 Luana Maia M 03/05/20052 2 André Inca M 02/05/19983 1 Suzana Silva F 03/09/20014 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.

1.8.2.1. 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.

1.8.3. 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


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:

1.8.4. 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'))

)GOInsert 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/20052 Aline M 02/05/20073 Carlos F 03/09/20074 Rodrigo M 05/06/2008

58


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'))

)GOInsert 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/20052 Português S 02/01/20053 Geografia S 03/01/20054 Inglês S 05/01/2005

59


/*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)

)GOInsert 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 11 22 12 22 33 31 31 4

60



7.1. 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, tabela2WHERE 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


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





Tabela Dependente

inIdDepend inIdColab vcNomeDepen chSexo dtNascimento

1 4 Luana Maia M 03/05/20052 2 André Inca M 02/05/19983 1 Suzana Silva F 03/09/20014 1 Rogério Tecca M 05/06/1988

62


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 DON 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.

7.2. 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

inIdCliente vcCliente vcDocumento vcEMail dtNascimento chFlagAtivo dtCadastro

1 Romulo Wendell 22653229812 [email protected] 08/01/2000 S 06/11/2008

2 Cristina Lima 42653229812 [email protected] 08/01/1985 S 06/11/2008

3 Carla Tardoche 62653229812 [email protected] 08/12/1982 S 06/11/2008

4 Wagner Sasaki 92653229812 [email protected] 05/10/2001 S 06/11/2008

5 Daniel Bo 23053229812 [email protected] 07/05/1985 S 06/11/2008

6 Leticia Padovani 45653229812 [email protected] 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


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', '[email protected]','2000/08/01','S',default)Insert into tb_cliente values('Cristina Lima', '42653229812', '[email protected]','1985/08/01','S',default)Insert into tb_cliente values('Carla Tardoche', '62653229812', '[email protected]','1982/08/12','S',default)Insert into tb_cliente values('Wagner Sasaki', '92653229812', '[email protected]','2001/05/10','S',default)Insert into tb_cliente values('Daniel Bo', '23053229812', '[email protected]','1985/07/05','S',default)Insert into tb_cliente values('Leticia Padovani', '45653229812', '[email protected]','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_Veiculovalues(3,'C3','DDD6872','f4gfd2hg4f6h5dd','2008/2008','S', default)Insert into tb_Veiculovalues(5,'Golf','DDX6879','f4gfd564f6h5dd','2008/2008','S', default)Insert into tb_Veiculovalues(2,'Vectra','ATD6878','f4gfd2hfsd6h5d','2005/2006','S', default)Insert into tb_Veiculovalues(6,'Astra','DTD6856','f4gfd2hg4ffd66d','2007/2008','S', default)

64


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.vcAnoModeloFrom tb_Cliente as CINNER JOIN tb_Veiculo as VON C.inIdcliente = V.inIdClienteOrder By 1

OU

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModeloFrom tb_Cliente C, tb_Veiculo VWhere C.inIdcliente = V.inIdClienteOrder 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


7.3. 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.vcAnoModeloFrom tb_Cliente as CLeft Outer Join tb_Veiculo as VON C.inIdcliente = V.inIdClienteOrder By 1


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


7.4. 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_Veiculovalues(null,'C4 VTR','CDX6879','f4gfd564f6h3dd','2008/2008','S', default)Insert into tb_Veiculovalues(null,'Audi A8','FBI6878','JKfd2hfsd6h5d','2005/2006','S', default)Insert into tb_Veiculovalues(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.vcAnoModeloFrom tb_Cliente as CRight Outer JOIN tb_Veiculo as VON C.inIdcliente = V.inIdClienteOrder By 1


NULL NULL C4 VTR CDX6879 2008/2008NULL NULL Audi A8 FBI6878 2005/2006NULL NULL New Civic GTD6856 2007/2008

2 Cristina Lima Vectra ATD6878 2005/20063 Carla Tardoche C3 DDD6872 2008/20085 Daniel Bo Golf DDX6879 2008/20086 Leticia Padovani Astra DTD6856 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


7.5. 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.vcAnoModeloFrom tb_Cliente as CFull Outer JOIN tb_Veiculo as VON C.inIdcliente = V.inIdClienteOrder By 1

inIdCliente vcCliente vcVeiculo chPlaca vcAnoModeloNULL NULL C4 VTR CDX6879 2008/2008NULL NULL Audi A8 FBI6878 2005/2006NULL NULL New Civic GTD6856 2007/2008

1 Romulo Wendell NULL NULL NULL2 Cristina Lima Vectra ATD6878 2005/20063 Carla Tardoche C3 DDD6872 2008/20084 Wagner Sasaki NULL NULL NULL5 Daniel Bo Golf DDX6879 2008/20086 Leticia Padovani Astra DTD6856 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


7.6. 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.vcAnoModeloFrom tb_Cliente as CCross JOIN tb_Veiculo as VOrder By 1

OU

Select C.inIdCliente, C.vcCliente, V.vcVeiculo, V.chPlaca, V.vcAnoModeloFrom tb_Cliente C, tb_Veiculo VOrder By 1

69


Resultado do Cross Join entre as tabelas Cliente e Veiculo:

inIdCliente vcCliente vcVeiculo chPlaca vcAnoModelo1 Romulo Wendell C3 DDD6872 2008/20081 Romulo Wendell Golf DDX6879 2008/20081 Romulo Wendell Vectra ATD6878 2005/20061 Romulo Wendell Astra DTD6856 2007/20081 Romulo Wendell C4 VTR CDX6879 2008/20081 Romulo Wendell Audi A8 FBI6878 2005/20061 Romulo Wendell New Civic GTD6856 2007/20082 Cristina Lima C3 DDD6872 2008/20082 Cristina Lima Golf DDX6879 2008/20082 Cristina Lima Vectra ATD6878 2005/20062 Cristina Lima Astra DTD6856 2007/20082 Cristina Lima C4 VTR CDX6879 2008/20082 Cristina Lima Audi A8 FBI6878 2005/20062 Cristina Lima New Civic GTD6856 2007/20083 Carla Tardoche C3 DDD6872 2008/20083 Carla Tardoche Golf DDX6879 2008/20083 Carla Tardoche Vectra ATD6878 2005/20063 Carla Tardoche Astra DTD6856 2007/20083 Carla Tardoche C4 VTR CDX6879 2008/20083 Carla Tardoche Audi A8 FBI6878 2005/20063 Carla Tardoche New Civic GTD6856 2007/20084 Wagner Sasaki C3 DDD6872 2008/20084 Wagner Sasaki Golf DDX6879 2008/20084 Wagner Sasaki Vectra ATD6878 2005/20064 Wagner Sasaki Astra DTD6856 2007/20084 Wagner Sasaki C4 VTR CDX6879 2008/20084 Wagner Sasaki Audi A8 FBI6878 2005/20064 Wagner Sasaki New Civic GTD6856 2007/20085 Daniel Bo C3 DDD6872 2008/20085 Daniel Bo Golf DDX6879 2008/20085 Daniel Bo Vectra ATD6878 2005/20065 Daniel Bo Astra DTD6856 2007/20085 Daniel Bo C4 VTR CDX6879 2008/20085 Daniel Bo Audi A8 FBI6878 2005/20065 Daniel Bo New Civic GTD6856 2007/20086 Leticia Padovani C3 DDD6872 2008/20086 Leticia Padovani Golf DDX6879 2008/20086 Leticia Padovani Vectra ATD6878 2005/20066 Leticia Padovani Astra DTD6856 2007/20086 Leticia Padovani C4 VTR CDX6879 2008/20086 Leticia Padovani Audi A8 FBI6878 2005/20066 Leticia Padovani New Civic GTD6856 2007/2008

7.7. Os comandos UPDATE e DELETE

70


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

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

71


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 CINNER JOIN tb_veiculo AS VON C.inIdcliente = V.inIdclienteINNER JOIN tb_ordemServico AS OON V.inIdVeiculo = O.inIdVeiculoAND V.inIdcliente = O.inIdcliente

Para este SELECT temos o resultado:

inCodOS vcCliente vcVeiculo vcServico dcValorServico dtDataServico1 Carla Tardoche C3 Troca de óleo 150.00 07/11/2008 21:292 Carla Tardoche C3 Troca de escapamento 250.00 07/11/2008 21:293 Daniel Bo Golf Troca de amortecedores 550.00 07/11/2008 21:304 Leticia Padovan Astra Balanceamento 120.00 07/11/2008 21:305 Cristina Lima Vectra Troca de Pneus P10.000 2120.00 08/11/2008 21:326 Cristina Lima Vectra Troca Pastilhas Freio 250.00 07/11/2008 21:33

7.8. 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:


FROM tb_Cliente AS CINNER JOIN tb_veiculo AS VON C.inIdcliente = V.inIdclienteINNER JOIN tb_ordemServico AS OON V.inIdVeiculo = O.inIdVeiculoAND V.inIdcliente = O.inIdclienteWHERE V.vcVeiculo like '%C3%'OR V.vcVeiculo like '%Vectra%'

72


inCodOS vcCliente vcVeiculo vcServico dcValorServico dtDataServico1 Carla Tardoche C3 Troca de óleo 150.00 07/11/2008 22:262 Carla Tardoche C3 Troca de escapamento 250.00 07/11/2008 22:265 Cristina Lima Vectra Troca de Pneus P10.000 2120.00 08/11/2008 22:266 Cristina Lima Vectra Troca Pastilhas 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_OrdemServicoSET dcValorServico = dcValorServico * 1.1FROM tb_Cliente AS CINNER JOIN tb_veiculo AS VON c.inIdcliente = v.inIdclienteINNER JOIN tb_ordemServico AS OON V.inIdVeiculo = O.inIdVeiculoAND V.inIdcliente = O.inIdclienteWHERE V.vcVeiculo like '%C3%'OR V.vcVeiculo like '%Vectra%'

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

inCodOS vcCliente vcVeiculo vcServico dcValorServico dtDataServico1 Carla Tardoche C3 Troca de óleo 165.00 07/11/2008 22:262 Carla Tardoche C3 Troca de escapamento 275.00 07/11/2008 22:265 Cristina Lima Vectra Troca de Pneus P10.000 2332.00 08/11/2008 22:266 Cristina Lima Vectra Troca Pastilhas Freio 275.00 07/11/2008 22:26

73


7.9. 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.


FROM tb_Cliente AS CINNER JOIN tb_veiculo AS VON C.inIdcliente = V.inIdclienteINNER JOIN tb_ordemServico AS OON V.inIdVeiculo = O.inIdVeiculoAND V.inIdcliente = O.inIdclienteWHERE V.vcVeiculo like '%C3%'

inCodOS vcCliente vcVeiculo vcServico dcValorServico dtDataServico1 Carla Tardoche C3 Troca de óleo 165.00 07/11/2008 22:262 Carla Tardoche C3 Troca de 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_ordemServicoFROM tb_Cliente AS CINNER JOIN tb_veiculo AS VON c.inIdcliente = v.inIdclienteINNER JOIN tb_ordemServico AS OON V.inIdVeiculo = O.inIdVeiculoAND V.inIdcliente = O.inIdclienteWHERE V.vcVeiculo like '%C3%'

74

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.

8.1. 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_clienteinIdCliente vcCliente vcEMail dtCadastro

1 Romulo Wendell [email protected] 08/01/2000 00:002 Renata Ferreira [email protected] 08/01/2000 00:003 Marcia Rita [email protected] 08/01/2000 00:004 Erika Yuriko [email protected] 08/01/2000 00:005 Max Willians [email protected] 08/01/2000 00:006 Renato Pereira [email protected] 08/01/2000 00:00

Tb_atorinIdAtor vcAtor mnSalario

1 Romulo Wendell 3500,002 Max Willians 4500,003 Silmara Campos 2500,004 Juliana Paes 8500,005 Suzan Sarandon 23500,00

75


Tb_CompradorinIdComprador vcComprador chSexo

1 Denise Reis F2 Marta Cordeiro F3 Silmara Sullan F4 Cassio Hebeshi M5 Suzan 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)

)GOInsert into tb_clientevalues('Romulo Wendell', '[email protected]','2000/08/01')Insert into tb_cliente values('Renata Ferreira', '[email protected]','2000/08/01')Insert into tb_cliente values('Marcia Rita', '[email protected]','2000/08/01')Insert into tb_cliente values('Erika Yuriko', '[email protected]','2000/08/01')Insert into tb_cliente values('Max Willians', '[email protected]','2000/08/01')Insert into tb_cliente values('Renato Pereira', '[email protected]','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)

)GOInsert 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)

76


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)

)GOInsert 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

Select inIdCliente, vcClienteFrom tb_clienteUnionSelect inIdAtor, vcAtorFrom tb_ator

inIdCliente vcCliente1 Romulo Wendell2 Max Willians2 Renata Ferreira3 Marcia Rita3 Silmara Campos4 Erika Yuriko4 Juliana Paes5 Max Willians5 Suzan Sarandon6 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

Select inIdCliente, vcClienteFrom tb_clienteUnion AllSelect inIdAtor, vcAtorFrom tb_ator

inIdCliente vcCliente1 Romulo Wendell2 Renata Ferreira3 Marcia Rita4 Erika Yuriko5 Max Willians6 Renato Pereira1 Romulo Wendell2 Max Willians3 Silmara Campos4 Juliana Paes5 Suzan Sarandon

Repare que para este exemplo houve ocorrência de dados duplicados.As regras básicas para este tipo de consulta devem ser:

77


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:

Select inIdCliente, vcClienteFrom tb_clienteUnionSelect inIdAtor, vcAtorFrom tb_atorUnionSelect inIdComprador, vcCompradorFrom tb_compradorOrder by inIdCliente, vcCliente

inIdCliente vcCliente1 Denise Reis1 Romulo Wendell2 Marta Cordeiro2 Max Willians2 Renata Ferreira3 Marcia Rita3 Silmara Campos3 Silmara Sullan4 Cassio Hebeshi4 Erika Yuriko4 Juliana Paes5 Max Willians5 Suzan Sarandon6 Renato Pereira

Except

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

Select vcCliente As NomesFrom tb_cliente2ExceptSelect vcAtorFrom tb_ator

NomesErika YurikoMarcia RitaRenata FerreiraRenato Pereira

78


8.2. 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

inCodCargo vcCargo4 Analista de Sistemas5 Arquiteto2 Diretor1 Presidente3 Supervisor

Tb_Funcionario

incodfunc inCodCargo vcNome dcSalario chDocumento1 5 Mario Antonio 8500.00 21.253.5872 5 Romeu Franklin 8500.00 1.254.4573 3 Thomas Edison 4500.00 258.3284 3 Bartolomeu Junior 6500.00 50.653.4585 2 Cristovão Colombo 7000.00 00.258.147 6 1 Amado Batista 30000.00 13.565.158

Tb_Dependente

inCodDep inCodFunc vcNomeDep1 1 Marcelle Belati2 1 Thais Everlast3 1 Ruy Armany4 2 Sabrina de Sá5 2 Vanderlei Luxamanaus6 5 Rocksivan de Paivo7 5 Renato de Oliveiro

79


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

80


8.3. 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 vcCargo1 Presidente2 Diretor3 Supervisor5 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 vcCargo4 Analista de 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 vcCargo1 Presidente3 Supervisor

81


8.4. Subquery introduzida com o sinal de igual (=)

Vamos observar a tabela de funcionário:

incodfunc inCodCargo vcNome dcSalario chDocumento1 5 Mario Antonio 8500.00 21.253.5872 5 Romeu Franklin 8500.00 1.254.4573 3 Thomas Edison 4500.00 258.3284 3 Bartolomeu Junior 6500.00 50.653.4585 2 Cristovão 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)

incodfunc inCodCargo vcNome dcSalario chDocumento6 1 Amado Batista 30000.00 13.565.158

O menor salário:

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

incodfunc inCodCargo vcNome dcSalario chDocumento3 3 Thomas Edison 4500.00 258.328

82


8.5. 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_funcionarioset dcSalario = dcSalario* 1.1Where inCodfunc NOT IN (Select InCodFunc From tb_dependente)

8.6. 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_funcionarioWhere inCodfunc NOT IN (Select InCodFunc From tb_dependente)

83

Capítulo 9 - Totalizando Dados


Neste capitulo aprenderemos técnicas para gerar dados de resumo com funções agregadas e GROUP BY.

9.1. 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.

84


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:

inCodRoupa vcTipoRoupa vcMarcaRoupa chTamanhoRoupa inQtdRoupa dcValor1 Calça Jeans Viva Eloah P 200 90.002 Calça Jeans Viva Eloah M 300 90.003 Calça Jeans Viva Eloah G 100 90.004 Calça Jeans NOfficers P 200 150.005 Calça Jeans NOfficers M 300 150.006 Calça Jeans NOfficers G 100 150.007 Calça Jeans Rellus P 80 120.008 Calça Jeans Rellus M 100 120.009 Calça Jeans Rellus G 50 120.00

10 Camiseta Viva Eloah P 100 45.0011 Camiseta Viva Eloah M 200 45.0012 Camiseta Viva Eloah G 250 45.0013 Camiseta Jacarezinho P 50 120.0014 Camiseta Jacarezinho M 60 120.0015 Camiseta Jacarezinho G 20 120.0016 Camiseta Cavalinho P 80 145.0017 Camiseta Cavalinho M 120 145.0018 Camiseta Cavalinho G 30 145.0019 Calça Social Vila Espartana P 20 130.0020 Calça Social Vila Espartana M 40 130.0021 Calça Social Vila Espartana G 15 130.0022 Calça Social Mario Bertolli P 60 80.0023 Calça Social Mario Bertolli M 30 80.0024 Calça Social Mario Bertolli G 20 80.0025 Top Gasta-Gasta P 200 15.0026 Top Gasta-Gasta M 300 15.0027 Top Gasta-Gasta G 300 15.00

85


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)

86


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 TotalFrom tb_roupa Group by vcTipoRoupa

Observe que o resultado foi agrupado pelo campo vcTipoRoupa

vcTipoRoupa TotalCalça Jeans 1430Calça Social 185Camiseta 910Top 800

Para mais um exemplo pratico, desejamos saber a quantidade de roupas agrupadas pelas marcas:

Select vcMarcaRoupa, sum(inQtdRoupa) as TotalFrom tb_roupa Group by vcMarcaRoupa

vcMarcaRoupa TotalCavalinho 230Gasta-Gasta 800Jacarezinho 130Mario Bertolli 110NOfficers 600Rellus 230Vila Espartana 75Viva Eloah 1150

87


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 TotalFrom tb_roupa Group by vcTipoRoupa, vcMarcaRoupa

vcTipoRoupa vcMarcaRoupa TotalCamiseta Cavalinho 230Top Gasta-Gasta 800Camiseta Jacarezinho 130Calça Social Mario Bertolli 110Calça Jeans NOfficers 600Calça Jeans Rellus 230Calça Social Vila Espartana 75Calça Jeans Viva Eloah 600Camiseta 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

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

88


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

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

9.2. 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, vcMarcaRoupaHaving Sum(inQtdRoupa) > 200

vcTipoRoupa vcMarcaRoupa Quantidade Valor TotalCamiseta Cavalinho 230 33350.00Top Gasta-Gasta 800 12000.00Calça Jeans NOfficers 600 90000.00Calça Jeans Rellus 230 27600.00Calça Jeans Viva Eloah 600 54000.00Camiseta Viva Eloah 550 24750.00

89


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, vcMarcaRoupaHaving Sum(inQtdRoupa) > 200And Sum(inQtdRoupa * dcValor) >= 50000

vcTipoRoupa vcMarcaRoupa Quantidade Valor TotalCalça Jeans NOfficers 600 90000.00Calça Jeans Viva Eloah 600 54000.00

90


9.3. 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, vcMarcaRoupaWith Rollup

vcTipoRoupa vcMarcaRoupa Quantidade Valor TotalCalça Jeans NOfficers 600 90000.00Calça Jeans Rellus 230 27600.00Calça Jeans Viva Eloah 600 54000.00Calça Jeans NULL 1430 171600.00Calça Social Mario Bertolli 110 8800.00Calça Social Vila Espartana 75 9750.00Calça Social NULL 185 18550.00Camiseta Cavalinho 230 33350.00Camiseta Jacarezinho 130 15600.00Camiseta Viva Eloah 550 24750.00Camiseta NULL 910 73700.00Top Gasta-Gasta 800 12000.00Top NULL 800 12000.00NULL 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.

91


9.4. 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, chTamanhoRoupaWith Cube

vcTipoRoupa vcMarcaRoupa chTamanhoRoupa Quantidade Valor TotalCalça Jeans NOfficers G 100 15000.00Calça Jeans NOfficers M 300 45000.00Calça Jeans NOfficers P 200 30000.00Calça Jeans NOfficers NULL 600 90000.00Calça Jeans Rellus G 50 6000.00Calça Jeans Rellus M 100 12000.00Calça Jeans Rellus P 80 9600.00Calça Jeans Rellus NULL 230 27600.00Calça Jeans Viva Eloah G 100 9000.00Calça Jeans Viva Eloah M 300 27000.00Calça Jeans Viva Eloah P 200 18000.00Calça Jeans Viva Eloah NULL 600 54000.00Calça Jeans NULL NULL 1430 171600.00Calça Social Mario Bertolli G 20 1600.00Calça Social Mario Bertolli M 30 2400.00Calça Social Mario Bertolli P 60 4800.00Calça Social Mario Bertolli NULL 110 8800.00Calça Social Vila Espartana G 15 1950.00Calça Social Vila Espartana M 40 5200.00Calça Social Vila Espartana P 20 2600.00Calça Social Vila Espartana NULL 75 9750.00Calça Social NULL NULL 185 18550.00Camiseta Cavalinho G 30 4350.00Camiseta Cavalinho M 120 17400.00Camiseta Cavalinho P 80 11600.00Camiseta Cavalinho NULL 230 33350.00Camiseta Jacarezinho G 20 2400.00Camiseta Jacarezinho M 60 7200.00Camiseta Jacarezinho P 50 6000.00Camiseta Jacarezinho NULL 130 15600.00

92


Camiseta Viva Eloah G 250 11250.00Camiseta Viva Eloah M 200 9000.00Camiseta Viva Eloah P 100 4500.00Camiseta Viva Eloah NULL 550 24750.00Camiseta NULL NULL 910 73700.00Top Gasta-Gasta G 300 4500.00Top Gasta-Gasta M 300 4500.00Top Gasta-Gasta P 200 3000.00Top Gasta-Gasta NULL 800 12000.00Top NULL NULL 800 12000.00NULL NULL NULL 3325 275850.00NULL Cavalinho G 30 4350.00NULL Cavalinho M 120 17400.00NULL Cavalinho P 80 11600.00NULL Cavalinho NULL 230 33350.00NULL Gasta-Gasta G 300 4500.00NULL Gasta-Gasta M 300 4500.00NULL Gasta-Gasta P 200 3000.00NULL Gasta-Gasta NULL 800 12000.00NULL Jacarezinho G 20 2400.00NULL Jacarezinho M 60 7200.00NULL Jacarezinho P 50 6000.00NULL Jacarezinho NULL 130 15600.00NULL Mario Bertolli G 20 1600.00NULL Mario Bertolli M 30 2400.00NULL Mario Bertolli P 60 4800.00NULL Mario Bertolli NULL 110 8800.00NULL NOfficers G 100 15000.00NULL NOfficers M 300 45000.00NULL NOfficers P 200 30000.00NULL NOfficers NULL 600 90000.00NULL Rellus G 50 6000.00NULL Rellus M 100 12000.00NULL Rellus P 80 9600.00NULL Rellus NULL 230 27600.00NULL Vila Espartana G 15 1950.00NULL Vila Espartana M 40 5200.00NULL Vila Espartana P 20 2600.00NULL Vila Espartana NULL 75 9750.00NULL Viva Eloah G 350 20250.00NULL Viva Eloah M 500 36000.00NULL Viva Eloah P 300 22500.00NULL Viva Eloah NULL 1150 78750.00Calça Jeans NULL G 250 30000.00Calça Social NULL G 35 3550.00Camiseta NULL G 300 18000.00Top NULL G 300 4500.00NULL NULL G 885 56050.00Calça Jeans NULL M 700 84000.00

93


Calça Social NULL M 70 7600.00Camiseta NULL M 380 33600.00Top NULL M 300 4500.00NULL NULL M 1450 129700.00Calça Jeans NULL P 480 57600.00Calça Social NULL P 80 7400.00Camiseta NULL P 230 22100.00Top NULL P 200 3000.00NULL NULL P 990 90100.00

9.5. 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)GOCreate table tb_tamanhoRoupa(

chCodTamanho char(2), vcDescTamanho varchar(50), Constraint PK_codTamanho Primary Key (chCodTamanho)

)GOinsert 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 rInner join tb_tamanhoRoupa as ton r.chTamanhoRoupa = t.chCodTamanhoGroup by vcTipoRoupa, vcMarcaRoupa, chTamanhoRoupa, t.vcDescTamanho

94


vcTipoRoupa vcMarcaRoupa chTamanhoRoupavcDescTamanh

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

95

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_roupaorder by vcTipoRoupaCompute 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:

vcTipoRoupavcMarcaRoupa inQtdRoupaCalça Jeans Viva Eloah 200Calça Jeans Viva Eloah 300Calça Jeans Viva Eloah 100Calça Jeans NOfficers 200Calça Jeans NOfficers 300Calça Jeans NOfficers 100Calça Jeans Rellus 80Calça Jeans Rellus 100Calça Jeans Rellus 50

SUM1430

vcTipoRoupa vcMarcaRoupa inQtdRoupaCalça Social Vila Espartana 20Calça Social Vila Espartana 40Calça Social Vila Espartana 15Calça Social Mario Bertolli 60Calça Social Mario Bertolli 30Calça Social Mario Bertolli 20

SUM185

vcTipoRoupa vcMarcaRoupa inQtdRoupaCamiseta Viva Eloah 100Camiseta Viva Eloah 200Camiseta Viva Eloah 250Camiseta Jacarezinho 50Camiseta Jacarezinho 60Camiseta Jacarezinho 20Camiseta Cavalinho 80Camiseta Cavalinho 120Camiseta Cavalinho 30

SUM910

vcTipoRoupa vcMarcaRoupa inQtdRoupaTop Gasta-Gasta 200Top Gasta-Gasta 300Top Gasta-Gasta 300

SUM800

96


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.

inCodMaterial vcMaterial1 Algodão2 Poliéster3 Microfibra4 Misto

Create table tb_material( inCodMaterial int not null identity(1,1), vcMaterial varchar(150) not null, Constraint PK_Material Primary Key (inCodMaterial)

)GOinsert 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 intAlter table tb_roupa add Constraint FK_Material Foreign Key (inCodMaterial) References tb_material(inCodMaterial)

update tb_roupaset incodMaterial = 5where vctiporoupa = 'calça Jeans'

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

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

update tb_roupaset incodMaterial = 3where vctiporoupa = 'Calça Social'

update tb_roupaset incodMaterial = 2where vctiporoupa = 'top'

97


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 rInner Join tb_material as mOn r.incodmaterial = m.incodmaterialOrder By m.vcMaterial , r.vcTipoRoupaCompute Sum(inQtdRoupa) By m.vcMaterial, r.vcTipoRoupaCompute Sum(inQtdRoupa) --este Compute gera um total geral

MaterialTipo de Roupa Marca Quantidade

Algodão Camiseta Jacarezinho 50



Algodão Camiseta Cavalinho 80



SUM

360

Material Tipo de Roupa Marca Quantidade

Jeans Calça Jeans Viva Eloah 200



Jeans Calça Jeans NOfficers 200



Jeans Calça Jeans Rellus 80



SUM

1430


Microfibra Calça Social Vila Espartana 20



Microfibra Calça Social Mario Bertolli 60



SUM

185


Misto Camiseta Viva Eloah 100



SUM

550

Material Tipo de Roupa MarcaQuantidad

e

Poliéster Top Gasta-Gasta 200



SUM

800

SUM

3325

98


10.2. 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.

99


10.3. 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.

100

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.

11.1. 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

11.2. 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

101

Capítulo 12 – Case

Capítulo 12 – Case

12.1. 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_cli vcNome_cli chSexo_cli1 Andre Mobilete M2 Tiago Abano NULL3 Monica Mendes F4 Luis Carlos M5 Renata França F

create table tb_cliente(

inCod_cli int identity, vcNome_cli varchar(30), chSexo_cli char(1)

)GOinsert 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'

EndFrom tb_cliente

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

Codigo Cliente Sexo1 Andre Mobilete Masculino2 Tiago Abano Não Saber3 Monica Mendes Feminino4 Luis Carlos Masculino5 Renata França Feminino

102

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.htmlhttp://www.devmedia.com.br/articles/viewcomp_forprint.asp?comp=4832http://www.linhadecodigo.com.br/Artigo.aspx?id=669http://www.50minutos.com.br/2007/05/datatypes-do-sql-server/http://www.odetocode.com/Articles/79.aspxhttp://www.shammas.eng.br/acad/materiais/mer.pdfhttp://pt.wikipedia.org/wiki/Modelo_de_Entidades_e_Relacionamentoshttp://msdn.microsoft.com/pt-br/library/ms190452.aspxhttp://msdn.microsoft.com/pt-br/library/ms177399.aspx

103

http://msdn.microsoft.com/pt-br/library/ms177399.aspx

http://msdn.microsoft.com/pt-br/library/ms190452.aspx

http://pt.wikipedia.org/wiki/Modelo_de_Entidades_e_Relacionamentos

http://www.shammas.eng.br/acad/materiais/mer.pdf

http://www.odetocode.com/Articles/79.aspx

http://www.50minutos.com.br/2007/05/datatypes-do-sql-server/

http://www.linhadecodigo.com.br/Artigo.aspx?id=669

http://www.devmedia.com.br/articles/viewcomp_forprint.asp?comp=4832

http://www.mhavila.com.br/link/db/sql.html

Documents

SQL Server Completa