2.0 Linguagem SQL

Banco de Dados II
Sejam bem-vindos!
Prof. Fred Lucena fred.lucena@unibratec.edu.br 1

Bibliografia Básica
 COUGO, Paulo. Modelagem conceitual e projeto de banco de dados. 3.ed. Rio
de Janeiro: F & W Publications, 1997. 284p.
 HEUSER, Carlos Alberto. Projeto de Banco de Dados. 4.ed. Rio Grande do
Sul: Editora Sagra, 1997. 205p.
 MACHADO, Felipe Nery Rodrigues; ABREU, Maurício Pereira de. Projeto de
banco de dados: uma visão prática. 16.ed. São Paulo: Érica, 2002. 320p.
 RAMAKRISHNAN, Raghu; GEHRKE, Johannes. Sistemas de Gerenciamento
de Banco de Dados. 3ed. São Paulo: Mc Graw Hill, 2008. 884p.
 SETZER, Valdemar W; SILVA, Flávio Soares Corrêa da. Bancos de dados:
Aprenda o que São, Melhore seu Conhecimento, Construa os seus. 1.ed. São
Paulo: Edgard Blucher, 2005. 390p.
 SILBERSCHATZ, Abraham; KORTH, Henry F; SUDARSHAN, S. Sistema de
banco de dados. 3.ed. São Paulo: Campus, 2006. 808p.

Linguagem SQL
Introdução

Linguagem SQL
Definição:
SQL – Structured Query Language, ou Linguagem de Consulta

Estruturada, foi desenvolvido 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
pelo matemático britânico Edgar Frank Codd (Dorset, 23 de
agosto de 1923 — 18 de abril de 2003).

Linguagem SQL
(continuação)
Embora o SQL tenha sido originalmente criado pela IBM,

rapidamente surgiram vários "dialetos" desenvolvidos por outras
empresas. 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 o
International Organization for Standardization (ISO) em 1987.

Linguagem SQL
(continuação)
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,
sequências padronizadas e colunas com valores de auto-
generalização (inclusive colunas-identidade).

Linguagem SQL
(continuação)
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.
(http://pt.wikipedia.org/wiki/SQL).

Linguagem SQL
Comandos

Linguagem SQL
Comandos

Linguagem SQL
(comandos)
Os comandos em SQL podem ser agrupados em cinco categorias

como a seguir:
DDL: Data Definition Language (Linguagem de Definição de

Dados) é o conjunto de comandos utilizados para incluir,
alterar e excluir tabelas e visões.
DML: Data Manipulation Language (Linguagem de Manipulação
de Dados) é o conjunto de comandos utilizados para
incluir, alterar e excluir dados.
DCL: Data Control Language (Linguagem de Controle de Dados)
é o conjunto de comandos utilizados para controlar o nível
de acesso de usuários.
Linguagem SQL
(comandos)
Os comandos em SQL podem ser agrupados em cinco categorias

como a seguir:
DQL: Data Query Language (Linguagem de Consulta de Dados)

se resume basicamente ao comando SELECT.
DTL: Data Transaction Language (Linguagem de Transação de
Dados) é o conjunto de comandos utilizados para iniciar
uma transação.

Linguagem SQL
(comandos)
DDL:
CREATE: Cria objetos em um SGBD.
ALTER: Altera a estrutura de objetos em um SGBD.
DROP: Exclui objetos em um SGBD.

Linguagem SQL
(comandos)
DML:
INSERT: Inserir dados em uma tabela.
UPDATE: Alterar dados em uma tabela.
DELETE: Excluir dados em uma tabela.

Linguagem SQL
(comandos)
DCL:
GRANT: Concede permissões de acesso a dados.
DENY: Negar permissões de acesso a dados.
REVOKE: Remove permissões concedidas /negadas anteriormente.

Linguagem SQL
(comandos)
DQL:
SELECT: Consulta dados em uma tabela.
DTL:
BEGIN TRANSACTION : Marca o ponto inicial de uma
transação.
COMMIT TRANSACTION : Força a gravação das mudanças no
banco.
ROOLBACK TRANSACTION: Descarta as alterações desde o último
commit.

Comandos DDL

Comandos DDL
(sintaxe)
Em Banco de Dados:
CREATE DATABASE <nome_banco>
ALTER DATABASE <nome_atual> MODIFY NAME = <novo_nome>
DROP DATABASE <nome_banco>

Comandos DDL
(exercício)
Em Banco de Dados:
CREATE DATABASE BancoDados
USE BancoDados
ALTER DATABASE BancoDados MODIFY NAME = Banco_de_Dados
DROP DATABASE Banco_de_Dados
Para evitar a mensagem de erro padrão “O banco de dados

„xxx‟ já existe.”, pode-se usar o seguinte:
IF DB_ID(ꞌBancoDadosꞌ) IS NULL
CREATE DATABASE BancoDados
ELSE
PRINT(ꞌBanco existenteꞌ)
Comandos DDL
(sintaxe)
Em Tabelas:
CREATE TABLE <tabela> ( <atributo1> <tipo> [NOT NULL],

<atributon> <tipo> [NOT NULL],
[primary key (campo1,campo2,...) ,
[foreign key (campo) references nome_relação );
ALTER TABLE <tabela> ADD/DROP/ALTER COLUMN

<atributo1> <tipo> [NOT NULL],
<atributon> <tipo> [NOT NULL] ;
DROP TABLE <nome_tabela>;

Comandos DDL
(exercício)
Em Tabelas:
CREATE TABLE Dept (DepNume numeric(4),
DepNome varchar(20),
DepLoca varchar (20),
DepOrca numeric(12,2));
ALTER TABLE Dept ADD DepSala numeric(10) not null;
ALTER TABLE Dept ALTER COLUMN DepNome varchar(25) not null;
ALTER TABLE Dept DROP COLUMN DepSala;

DROP TABLE Dept;

Comandos DML

Comandos DML
(sintaxe)
INSERT INTO <tabela> (<campos>) VALUES (<valores>);
UPDATE <tabela> SET <campo> = <expressão> [WHERE <condição>];
DELETE FROM <tabela> [WHERE <condição>];

Comandos DML
(exercício)
INSERT INTO dept (depnume,depnome,deploca) VALUES (70, 'Producao', 'Recife');
UPDATE dept SET DepNome = 'Pessoal’;
DELETE FROM dept;

Comandos DML
(exercício)
INSERT INTO dept VALUES (10, 'Producao', 'Recife', 15000);

INSERT INTO dept VALUES (20, 'Pessoal' , 'Olinda', 20000);
INSERT INTO dept VALUES (30, 'Contabil', 'Olinda', 30000);
INSERT INTO dept VALUES (50, 'Contabil', 'Recife', 50000);
DELETE FROM dept WHERE deploca = 'Olinda' AND deporca >=30000;
SELECT * FROM dept;
DELETE FROM dept;

Comandos DML
(exercício)

INSERT INTO dept VALUES (20, 'Pessoal' , 'Olinda', 20000);
INSERT INTO dept VALUES (50, 'Contabil', „Recife', 50000);
DELETE FROM dept WHERE deploca = 'Recife' OR deporca >=40000;
SELECT * FROM dept;
DELETE FROM dept;

Comandos DML
(exercício)

INSERT INTO dept VALUES (20, 'Pessoal„ , 'Olinda', 20000);
INSERT INTO dept VALUES (50, 'Contabil', 'Recife', 50000);
UPDATE dept SET DepNome = 'Estoque' WHERE depnome = 'Pessoal';
SELECT * FROM dept;
DELETE FROM dept;

Exercícios

Comandos DDL
(exercício)
Crie um banco de dados com o seu nome;
Selecione o banco de dados que você acabou de criar;
Crie uma tabela com o nome cadfun e a seguinte estrutura:
CAMPO TIPO TAMANHO NÃO NULO CHAVE

CODFUN INTEIRO
NOME CARACTER 40
DEPTO CARACTER 2
FUNCAO CARACTER 20
SALARIO DECIMAL 10,2

Comandos DML
(exercício)
Insira os dados a seguir:
CODFUN NOME DEPTO FUNCAO SALARIO

1 CARLOS ALBERTO 3 VENDEDOR 1.530,00
2 MARCOS HENRIQUE 2 GERENTE 1.985,75
3 APARECIDA SILVA 3 SECRETARIA 1.200,50
4 SOLANGE PACHECO 5 SUPERVISORA 1.599,51
5 MARCELO SOUZA 3 ANALISTA 2.250,11
6 CELIA NASCIMENTO 2 SECRETARIA 1.200,50
7 WILSON DE MACEDO 3 PROGRAMADOR 1.050,00
8 AUGUSTO SOUZA 3 PROGRAMADOR 1.050,00
9 CARLOS BASTOS 5 VENDEDOR 1.530,00
10 PEDRO SILVA 3 SUPERVISOR 1.599,51
11 ANA BASTOS 5 VENDEDORA 1.530,00
12 PAULO DA SILVA 2 VENDEDOR 1.530,00

SCRIPT SQL
IF DB_ID('Fred') IS NOT NULL
BEGIN
USE Master
DROP DATABASE Fred
END
-------------------------------------------------------------------------------
CREATE DATABASE Fred
-------------------------------------------------------------------------------
USE Fred
-------------------------------------------------------------------------------
CREATE TABLE cadfun (CODFUN NUMERIC NOT NULL,
NOME VARCHAR(40) NOT NULL,
DEPTO VARCHAR(2),
FUNCAO VARCHAR(20),
SALARIO DECIMAL(10,2));
-------------------------------------------------------------------------------
INSERT INTO cadfun VALUES (1, 'CARLOS ALBERTO', '3', 'VENDEDOR' , 1530.00)
INSERT INTO cadfun VALUES (2, 'MARCOS HENRIQUE', '2', 'GERENTE' , 1985.75)
INSERT INTO cadfun VALUES (3, 'APARECIDA SILVA', '3', 'SECRETARIA' , 1200.50)
INSERT INTO cadfun VALUES (4, 'SOLANGE PACHECO', '5', 'SUPERVISORA', 1599.51)
INSERT INTO cadfun VALUES (5, 'MARCELO SOUZA', '3', 'ANALISTA' , 2250.11)
INSERT INTO cadfun VALUES (6, 'CÉLIA NASCIMENTO', '2', 'SECRETARIA' , 1200.50)
INSERT INTO cadfun VALUES (7, 'WILSON DE MACEDO', '3', 'PROGRAMADOR', 1050.00)
INSERT INTO cadfun VALUES (8, 'AUGUSTO SOUZA', '3', 'PROGRAMADOR', 1050.00)
INSERT INTO cadfun VALUES (9, 'CARLOS BASTOS', '5', 'VENDEDOR' , 1530.00)
INSERT INTO cadfun VALUES (10, 'PEDRO SILVA', '3', 'SUPERVISOR' , 1599.51)
INSERT INTO cadfun VALUES (11, 'ANA BASTOS', '5', 'VENDEDORA' , 1530.00)
INSERT INTO cadfun VALUES (12, 'PAULO DA SILVA', '2', 'VENDEDOR' , 1530.00)
-------------------------------------------------------------------------------
SELECT * FROM cadfun;

Comandos DQL

Comandos DQL
(sintaxe)
SELECT <[tipo] [campos]> FROM <tabela> [condição]

[tipo] – parâmetro opcional que determina o tipo de registro (DISTINCT ou *)
[campos] - colunas da consulta
<tabela> - Nome das tabela a ser consultada
<condição> - Permite o estabelecimento dos critérios a seguir:
WHERE - Permite criar condições para filtrar dados utilizando operadores
dos tipos:
Relacionais - (<, <=, >, >=. =, <>);
Lógicos - ([NOT] IN, [NOT] BETWEEN, [NOT] LIKE <%dado%>):
GROUP BY Agrupa dados em uma consulta.
HAVING Limita o resultado de uma consulta agrupada com GROUP BY.
ORDER BY <ASC/DESC> Especifica a coluna ou as colunas que serão ordenadas
na consulta e a forma de ordenação (ascendente ou descendente).

Exercícios

Comandos DQL
(exercício)
Faça as seguintes consultas:

1. Todos os dados da tabela.
SELECT * FROM cadfun;
2. Apenas o nome e a função de todos os funcionários.

SELECT nome, funcao FROM cadfun;
3. O nome de todos os funcionários do departamento 3.

SELECT nome FROM cadfun WHERE DEPTO = '3';
4. Nome e salário de todos os funcionários ordenados por nome.

SELECT nome, salario FROM cadfun ORDER BY nome;
5. Nome e salário de todos os funcionários ordenados na descendente por nome.

SELECT nome, salario FROM cadfun ORDER BY nome DESC;

Comandos DQL
(exercício)

6. Todos os departamentos e nomes ordenados por departamento na ascendente e
nome na descendente.
SELECT depto, nome FROM cadfun ORDER BY depto, nome DESC;
7. Todos os nomes dos funcionários do departamento 3 em ordem descendente.

SELECT nome FROM cadfun WHERE DEPTO = '3' ORDER BY nome DESC;
8. Todos os dados em que o código do funcionário seja igual a 7.

SELECT * FROM cadfun WHERE codfun = '7';
9. Atualize o salário do funcionário 7 para 2.300,56.

UPDATE cadfun SET SALARIO = 2300.56 WHERE codfun = '7';
10. Todos os dados da funcionária ANA BASTOS.

SELECT * FROM cadfun WHERE nome = 'ANA BASTOS';

Comandos DQL
(exercício)

11. Mude o departamento de ANA BASTOS para 3.
UPDATE cadfun SET depto = '3' WHERE nome = 'ANA BASTOS';
12. Aumente todos os salários em 10%.

UPDATE cadfun SET salario = salario * 1.1;
13. Selecione todos os dados dos funcionários cujo salário seja maior ou igual a R$
2.000,00.
SELECT * FROM cadfun WHERE salario>=2000;
14. Selecione todos os nomes dos funcionários que pertencem a família Silva.
SELECT * FROM cadfun WHERE nome LIKE '%SILVA%';
15. Selecione todos os nomes dos funcionários que possuem nome começando com
a letra M.
SELECT * FROM cadfun WHERE nome LIKE 'M%„;

Comandos DQL
(exercício)

16. Selecione todos os dados dos funcionários que são Programadores ou Analistas.
SELECT * FROM cadfun WHERE funcao IN ('PROGRAMADOR','ANALISTA');
17. Selecione todos os dados dos funcionários que não são Programadores nem
Analistas.
SELECT * FROM cadfun WHERE funcao NOT IN ('PROGRAMADOR', 'ANALISTA');
18. Selecione todos os dados dos funcionários cujo salário esteja entre R$ 1.500,00 e
R$ 2.000,00.
SELECT * FROM cadfun WHERE salario BETWEEN 1500 AND 2000;
19. Selecione todos os funcionários cujo salário sejam menores que R$ 1.500,00 ou
maiores que R$ 2.500,00.
SELECT * FROM cadfun WHERE salario NOT BETWEEN 1500 AND 2500;
20. Torne NULO todas as funções dos funcionários cuja função seja vendedor.
UPDATE cadfun SET funcao = NULL WHERE funcao = 'VENDEDOR';

Comandos DQL
(exercício)

21. Selecione todos os dados dos funcionários que possuem o campo função nulo.
SELECT * FROM cadfun WHERE funcao IS NULL;
22. Selecione todos os dados dos funcionários que não possuem a função nulo.
SELECT * FROM cadfun WHERE funcao IS NOT NULL;
23. Troque todos as funções cujo conteudo é nulo por digitador.

UPDATE cadfun SET funcao = 'DIGITADOR' WHERE funcao IS NULL;
24. Selecione todos os funcionários que são programadores e possuem salário maior
que R$ 2.000,00.
SELECT * FROM cadfun WHERE funcao = 'PROGRAMADOR' and SALARIO > 2000;
25. Crie uma cópia vazia da tabela cadfun com o nome morto.
SELECT * INTO morto FROM cadfun WHERE 1=2;
ALTER TABLE morto ADD CONSTRAINT CODFUN PRIMARY KEY (CODFUN);

Comandos DQL
(exercício)

26. Copie os dados do funcionário 12 na tabela cadfun para a tabela morto.
INSERT INTO morto SELECT * FROM cadfun WHERE codfun = 12;
27. Liste nome, salário dos funcionários de cadfun com salário igual ao do registro da
tabela morto.
SELECT nome,salario FROM cadfun WHERE salario IN (SELECT salario FROM morto);
28. Liste todos os dados dos funcionários de cadfun com o mesmo departamento do
registro da tabela morto.
SELECT * FROM cadfun WHERE depto IN (SELECT depto FROM morto);
29. Calcule quanto é 2 elevado ao cubo.

SELECT POWER(2,3);
30. Calcule a raiz de 256.

SELECT SQRT(256);

Comandos DQL
(exercício)

31. Apresente no formato decimal com duas casas, a média salarial dos funcionários
de cadfun.
SELECT CONVERT(decimal(10,2),AVG(SALARIO)) FROM cadfun;
32. Conte quantos funcionários possuem a função de PROGRAMADOR ou

SECRETÁRIA.
SELECT funcao,COUNT(*) FROM cadfun GROUP BY funcao HAVING funcao IN ('PROGRAMADOR',
'SECRETARIA');
33. Conte quantas funções existem em cadfun.

SELECT COUNT(*), COUNT(DISTINCT funcao) FROM cadfun;
34. Apresente o menor e o maior salário entre os funcionários de cadfun.

SELECT MIN(salario) AS 'Menor Salário' ,MAX(salario) AS 'Maior Salário' FROM cadfun;
35. Sabendo que a=3, b=4 e c=1, calcule a expressão √(B2-4ac)

SELECT SQRT(POWER(4,2)-4*3*1);

Comandos DDL
(exercício)
Crie as tabelas cliente, pedido e itenspedido segundo as estruturas abaixo:
CAMPO TIPO TAMANHO NULO CHAVE

CLI_COD INT NÃO NÃO
CLI_NOME VARCHAR 50 NÃO NÃO

PED_COD INT NÃO NÃO
PED_DATA SMALLDATETIME NÃO NÃO
PED_CLI INT NÃO NÃO

PED_COD INT NÃO NÃO
ITEN_COD INT NÃO NÃO
ITEN_QTD NUMERIC (5,2) NÃO NÃO
SCRIPT SQL
CREATE DATABASE Fred;
USE Fred;
CREATE TABLE cliente (CLI_COD INT NOT NULL,

CLI_NOME VARCHAR(50) NOT NULL);
CREATE TABLE pedido (PED_COD INT NOT NULL,

PED_DATA SMALLDATETIME NOT NULL,
PED_CLI INT NOT NULL);
CREATE TABLE itenspedido (PED_COD INT NOT NULL,

ITEN_COD INT NOT NULL,
ITEN_QTD NUMERIC(5,2) NOT NULL);

SCRIPT SQL
INSERT INTO cliente (cli_cod, cli_nome) VALUES (1001,'PEDRO')
INSERT INTO cliente (cli_cod, cli_nome) VALUES (1002,'CARLOS')
INSERT INTO cliente (cli_cod, cli_nome) VALUES (1003,'MARIA')
INSERT INTO pedido (ped_cod, ped_data, ped_cli) VALUES (101,'02/11/2010',1001)

INSERT INTO itenspedido (ped_cod, iten_cod, iten_qtd) VALUES (101,1,10)


Comandos DQL
(exercício)

36. Liste o código, nome, pedido e data dos clientes que possuem pedidos.
SELECT
CLI.cli_cod, CLI.cli_nome, PED.ped_cod, PED.ped_data
FROM
CLIENTE CLI, PEDIDO PED
WHERE
CLI.cli_cod = PED.ped_cli;
37. Liste, utilizando INNER JOIN, o código, nome, pedido e data dos clientes que
possuem pedidos.
SELECT
FROM
CLIENTE CLI INNER JOIN PEDIDO PED
ON

Comandos DQL
(exercício)

38. Liste o código do pedido, data do pedido, código do ítem e quantidade do ítem.
SELECT
FROM
WHERE
CLI.cli_cod = PED.ped_cli
39. List o código do pedido, nome do cliente, data do pedido, código e quantidade
do ítem.
SELECT
PED.PED_COD, CLI.CLI_NOME ,CONVERT(char,PED.PED_DATA,103), ITEN.ITEN_COD, ITEN.ITEN_QTD
FROM
PEDIDO PED , CLIENTE CLI, ITENSPEDIDO ITEN
WHERE
PED.PED_COD = ITEN.PED_COD AND PED.PED_CLI = CLI.CLI_COD

Comandos DQL
(exercício)

40. Liste o código e nome dos clientes, juntamente com os códigos e datas dos
pedidos (caso existam).
SELECT
FROM
WHERE

Comandos DTL

Comandos DTL
(sintaxe)
BEGIN TRANSACTION
<instruções SQL>
COMMIT TRANSACTION ou ROLLBACK TRANSACTION

Comandos DTL
(exercício)
Em Banco de Dados:
BEGIN TRANSACTION
UPDATE cadfun SET salario = 2300.56
ROLLBACK TRANSACTION
BEGIN TRANSACTION
UPDATE cadfun SET salario = 2300.56
COMMIT TRANSACTION
ROLLBACK TRANSACTION
JUNÇÕES

O que são Junções?
Segundo a língua Portuguesa:
 s. f.
 1. Ato ou efeito de juntar.
 2. Ponto onde duas ou mais coisas se juntam.
 3. Reunião.
 4. Confluência.
Segundo a álgebra relacional:
Operações utilizadas para combinar dados de duas ou mais relações (tabelas).

O que é Álgebra Relacional?
Definida por Frank Codd, é uma linguagem de consulta procedimental que consiste em um
conjunto de operações objetivando produzir uma nova relação a partir de uma ou mais
existentes. Na terminologia formal de modelo relacional:
 Uma linha é chamada de tupla
 O cabeçalho da coluna é chamado de atributo
 Tabela é chamada de relação
 Tipos de dados permitidos em cada coluna é chamado de domínio
Possui operações básicas oriundas da teoria dos conjuntos, tais como:

 Produto Cartesiano;
 União (Parcial e Total);
 Interseção;
 Diferença.
Criando base para testes
CREATE DATABASE Juncao
GO
USE Juncao
CREATE TABLE Cargo (Cd_Cargo CHAR(3) PRIMARY KEY,

Ds_Cargo VARCHAR(50))
INSERT INTO Cargo (Cd_Cargo, Ds_Cargo) VALUES ('C01', 'Presidente')

INSERT INTO Cargo (Cd_Cargo, Ds_Cargo) VALUES ('C02', 'Diretor')
INSERT INTO Cargo (Cd_Cargo, Ds_Cargo) VALUES ('C03', 'Gerente')
CREATE TABLE Empregado (Mt_Empregado CHAR(3) PRIMARY KEY,

Nm_Empregado VARCHAR(50),
Cg_Empregado CHAR(3) REFERENCES Cargo(Cd_Cargo))
INSERT INTO Empregado (Mt_Empregado, Nm_Empregado, Cg_Empregado) VALUES ('E01', 'Pedro','C01')

INSERT INTO Empregado (Mt_Empregado, Nm_Empregado, Cg_Empregado) VALUES ('E02','Paulo','C02')
CREATE TABLE Empregado2 (Mt_Empregado CHAR(3) PRIMARY KEY,

Nm_Empregado VARCHAR(50),
Cg_Empregado CHAR(3) REFERENCES Cargo(Cd_Cargo))
INSERT INTO Empregado2 (Mt_Empregado, Nm_Empregado, Cg_Empregado) VALUES ('E02', 'Paulo','C02')

INSERT INTO Empregado2 (Mt_Empregado, Nm_Empregado, Cg_Empregado) VALUES ('E03', 'Don Diego','C01')
INSERT INTO Empregado2 (Mt_Empregado, Nm_Empregado, Cg_Empregado) VALUES ('E04','Zorro','C02')
Produto Cartesiano
E01:C01
C01
E01:C02
E01
E01:C03
C02
E02:C01
E02
E02:C02
C03
E02:C03
A B AxB
Produto Cartesiano
Matricula Nome Cd_Cargo Cd_Cargo Cargo
E01 Pedro C01 C01 Presidente
E02 Paulo C02 C02 Diretor
C03 Gerente
Matricula Nome Cd_Cargo Cd_Cargo Cargo

E01 Pedro C01 C01 Presidente
E01 Pedro C01 C02 Diretor
E01 Pedro C01 C03 Gerente
E02 Paulo C02 C01 Presidente
E02 Paulo C02 C02 Diretor
E02 Paulo C02 C03 Gerente
SELECT * FROM Empregado, Cargo

União
E02
E01
E01
E02
E03
E03
E02
E04
E04
A B A B
União
Matricula Nome Cd_Cargo Matricula Nome Cd_Cargo
E01 Pedro C01 E02 Paulo C02
E02 Paulo C02 E03 Don Diego C01
E04 Zorro C02
Matricula Nome Cd_Cargo

E01 Pedro C01
E02 Paulo C02
E03 Don Diego C01
E04 Zorro C02
SELECT * FROM Empregado UNION SELECT * FROM Empregado2

União Total
E02 E01
E01 E02
E03 E02
E02 E03
E04 E04
A B A B
União Total
E04 Zorro C02

E01 Pedro C01
E02 Paulo C02
E02 Paulo C02
E03 Don Diego C01
E04 Zorro C02
SELECT * FROM Empregado UNION ALL SELECT * FROM Empregado2

Interseção
E02
E01 E03
E03 E01 E02
E02 E04
E04
A B A B
Interseção
E04 Zorro C02

E02 Paulo C02
SELECT * FROM Empregado2 WHERE Mt_Empregado IN (SELECT Mt_Empregado FROM Empregado)
SELECT * FROM Empregado2 INTERSECT SELECT * FROM Empregado

Diferença
E02
E01 E03
E03 E01 E02
E02 E04
E04
A B A B
Diferença
E04 Zorro C02

E01 Pedro C01
SELECT * FROM Empregado WHERE Mt_Empregado NOT IN (SELECT Mt_Empregado FROM Empregado2)
JOIN
(conceito)

Tipos de Junções

Tipos de Junções
(criando tabelas para testes)
create table carros (marca varchar(100),

modelo varchar(100),
ano int,
cor varchar(100))
create table marcas (marca varchar(50),

nome varchar(50))
Tipos de Junções
(alimentando a tabela para testes)
insert into marcas values('VW','Volkswagem')
insert into marcas values('Ford','Ford')
insert into marcas values('GM','General Motors')
insert into marcas values('Fiat','Fiat')
insert into marcas values('Renault','Renault')
insert into marcas values('MB','Mercedes Benz')
Tipos de Junções
(criando base para testes)
insert into carros values('VW','Fox',2005,'preto');
insert into carros values('VW','Fox',2008,'preto');
insert into carros values('Ford','Ecosport',2009,'verde');
insert into carros values('Ford','KA',2008,'prata');
insert into carros values('Fiat','Punto',2008,'branco');
insert into carros values('Fiat','Uno',2007,'preto');
insert into carros values('Fiat','Stilo',2004, 'prata');
insert into carros values('Fiat','Uno',2005,'prata');
insert into carros values('Fiat','Stilo',2008,'verde');
insert into carros values('Fiat','Uno',2009,'branco');
insert into carros values('Peugeot','207',2010,'prata');
insert into carros values('Peugeot','207',2010,'prata');
insert into carros values('Peugeot','207',2007,'azul');
insert into carros values('Chrysler','300 C',2008,'verde');
Tipos de Junções
 INNER JOIN
 OUTER JOIN
 LEFT JOIN
 RIGHT JOIN
 FULL JOIN
 CROSS JOIN
Tipos de Junções
INNER JOIN
O inner join junta todos os registros que possuam

correspondência nas tabelas relacionadas.
Ex:
select m.nome, c.modelo

from marcas as m inner join carros as c
on c.marca = m.marca
Tipos de Junções
CROSS JOIN
O cross join junta todos os registros de duas

tabelas formando um produto cartesiano. Este tipo
de junção não permite o uso da cláusula ON.
Ex: select m.nome, c.modelo

from marcas as m cross join carros as c
Tipos de Junções
LEFT JOIN
O left join junta todos os registros da primeira

tabela e na segunda, apenas aqueles que possuem
relação.
Ex:
from marcas as m left join carros as c
Tipos de Junções
RIGHT JOIN
O right join junta todos os registros da segunda

tabela e na primeira, apenas aqueles que possuem
relação.
Ex:
from marcas as m right join carros as c
Tipos de Junções
FULL OUTER JOIN
O full outer join é o equivalente ao uso do left join

e right join juntos, ou seja, mostra todos os
registros das duas tabelas, independente de
existirem correspondência.
Ex:
from marcas as m full outer join carros as c
TRIGGER

TRIGGER
(sintaxe)
CREATE TRIGGER <nome_da_trigger>

ON <tabela>
FOR INSERT, UPDATE, DELETE
AS <instruções>
GO

TRIGGER
(sintaxe)
CREATE TRIGGER controle

ON cadfun
AS PRINT 'Minha mensagem...'
GO
Listando as Triggers Existentes

SELECT name, OBJECT_NAME(parent_obj) AS tabela
FROM sysobjects
WHERE (xtype = ‘TR’)

TRIGGER
(sintaxe)
IF EXISTS (SELECT name FROM sysobjects

WHERE name = 'controle' AND type = 'TR')
DROP TRIGGER controle
GO
CREATE TRIGGER controle

ON cadfun
AS SELECT * FROM cadfun
GO

TRIGGER
(sintaxe)
INSERT INTO cadfun VALUES (99,'Teste','99','Testador',9999.99)
UPDATE cadfun SET NOME = 'Novo Teste' WHERE codfun = '99‘
DELETE FROM cadfun WHERE codfun = '99'

STORED PROCEDURE

STORED PROCEDURE
(sintaxe)
CREATE PROCEDURE <nome_do_procedimento>

<variáveis>
AS
<instruções>
GO

STORED PROCEDURE
(exemplo)
CREATE PROCEDURE sp_InserirDados

@codfun numeric(18,0),
@nome varchar(40),
@depto varchar(2),
@funcao varchar(20),
@salario decimal(10,2)
AS
INSERT INTO cadfun VALUES (@codfun, @nome, @depto, @funcao, @salario)
GO

STORED PROCEDURE
(exemplo)
@nome varchar(40),
@depto varchar(2),
AS
INSERT INTO cadfun VALUES(@codfun, @nome, @depto, @funcao, @salario)
GO
SELECT name, xtype

FROM sysobjects
WHERE (xtype = 'P')

STORED PROCEDURE
(exemplo)
EXEC sp_InserirDados
@codfun = '99999',
@nome = 'Teste de SP',
@depto = '99',
@funcao = 'Função do SP',
@salario = 999.99
GO

STORED PROCEDURE
(exemplo)
@nome varchar(40),
@depto varchar(2),
AS
GO
EXEC sp_InserirDados
@codfun = '99999',
@nome = 'Teste de SP',
@depto = '99',
@funcao = 'Função do SP',
@salario = 999.99
GO

STORED PROCEDURE
(exemplo)
IF EXISTS (SELECT name FROM sysobjects WHERE name = 'sp_InserirDados' AND type = 'P')
DROP PROCEDURE sp_InserirDados
GO
@nome varchar(40),
@depto varchar(2),
AS
IF @codfun <> 0 AND @nome <> '' AND @depto <> '' AND @funcao <> '' AND @salario <> 0
BEGIN
PRINT 'Cadastro efetuado com sucesso.'
END
ELSE
PRINT 'Todos os campos deverão ser informados.'
GO

Linguagem SQL
(Dicas)
Obs1. Para listar os nomes dos Banco de Dados existentes, digite:

SQLServer – Digite SELECT name FROM sys.databases.
Obs2. Nome do Banco de Dados em uso:

SQLServer – Digite SELECT name FROM sys.databases;
Obs3. Tornando um banco ativo:

SQLServer – use <nome_do_banco>;
Obs4. Identificando o banco de dados (SQLServer):

SELECT DB_ID('bancodados'); - ID a partir do Nome.
SELECT DB_NAME(5); - NOME a partir do id .

Linguagem SQL
(Dicas)
Obs5. Para mostrar registros em duplicidade, digite:

SELECT <campo> FROM <tabela> GROUP BY <campo> HAVING
Count(campo)>1;
Obs6. Para listar todas as triggers, digite:

SELECT name, xtype
FROM sysobjects
WHERE (xtype = ‘TR’);
Obs7. Para listar todas as procedures, digite:

SELECT name, xtype
FROM sysobjects
WHERE (xtype = 'P')

FIM

 INMON, William H. Como construir o data warehouse. Tradução Ana Maria
Netto Guz. 2.ed. Rio de Janeiro: Campus, 1997.
 KIMBALL, Ralph. Data warehouse toolkit: o guia completo para modelagem
multidimensional, CAMPUS, 2002

CONVERT(VARCHAR,<campoDataTime>,<códigoFormato>).
Os formatos possíveis são:

Código Saída
0 or 100 mon dd yyyy hh:miAM (or PM)
101 mm/dd/yy
102 yy.mm.dd
103 dd/mm/yy
104 dd.mm.yy
105 dd-mm-yy
106 dd mon yy
107 Mon dd, yy
108 hh:mm:ss
9 or 109 mon dd yyyy hh:mi:ss:mmmAM (or PM)
110 mm-dd-yy
111 yy/mm/dd
112 yymmdd
13 or 113 dd mon yyyy hh:mm:ss:mmm(24h)
114 hh:mi:ss:mmm(24h)
20 or 120 yyyy-mm-dd hh:mi:ss(24h)
21 or 121 yyyy-mm-dd hh:mi:ss.mmm(24h)
126 yyyy-mm-dd Thh:mm:ss.mmm(no spaces)
130 dd mon yyyy hh:mi:ss:mmmAM
131 dd/mm/yy hh:mi:ss:mmmAM

Linguagem SQL
(Dicas)
Obs1. Para listar os nomes dos Banco de Dados existentes, digite:

PostGreSQL – Digite \l para listar os bancos e \DB para tablespace.
SQLServer – Digite SELECT name FROM sys.databases.
Obs2. Nome do Banco de Dados em uso:

PostGreSQL – Digite \c
SQLServer – Digite SELECT name FROM sys.databases;
Ob3. Tornando um banco ativo:

PostGreSQL – \c <nome_do_banco> ;
SQLServer – use <nome_do_banco>;
Obs4. Identicando o banco de dados (SQLServer):

SELECT DB_ID('bancodados'); - ID a partir do Nome.
SELECT DB_NAME(5); - NOME a partir do id .

Linguagem SQL
(Dicas)
Obs1. Para mostrar registros em duplicidade, digite:

SELECT CEP FROM CEP GROUP BY CEP HAVING Count(CEP)>1;

Tipos de Campos
Tipo de dado Descrição
Contém até 8.000 bytes de dados binários de tamanho fixa. Tamanho fixo significa que o campo irá sempre utilizar o
Binary
espaço que você definiu.
Cria um campo true/false (verdadeiro/falso). Este tipo de dado armazena apenas os valores de 0 e 1 e não pode conter
Bit
valores nulos.
Contém até 8.000 bytes de uma string de tamanho fixo. Use este campo para dados this que irão sempre ser do mesmo
Char
tamanho.
Datetime Armazena a data e hora com precisão de milissegundos em 8 bytes.
Contém dados numéricos com um inteiro à esquerda do ponto decimal e uma parte fracionária a direita. Este campo
Decimal irá ter um número variável de bytes, baseado na escala e precisão que você especificar. Escala é o número máximo de
dígitos à direita do ponto decimal e precisão é o número total de dígitos em ambos os lados do the ponto decimal.
Um tipo de dados numérico aproximado para armazenamento de longos números em ponto-flutuante, com a precisão
Float
de até 15 dígitos em 8 bytes. O SQL Server feralmente arredonda esses números para cima.
Contém até 2.147.483.647 bytes (aproximadamente 2Gbytes) de dados binários e costuma ser utilizado para armazenar
Image grandes quantidades de dados como imagens ou arquivos de som. Campos definidos com este tipo de dado não podem
ser indexadas, pesquisadas, agrupadas ou ordenadas.
Armazena um dado numérico preciso para todo número armazenado em 4 bytes. Pode conter números de -2^1031 a
Int
2^1031.
Contém dados monetários definidos com precisão de 4 dígitos. Ele é representado como um inteiro de precisão dupla
Money e consome 8 bytes de armazenamento. Valores podem estar entre -992.337.293.685.477,5808 e
922.337.203.685.447,5807.
Contém até 4.000 caracteres Unicode. Tipo de dado de largura fixa, sendo armazenado no dobro de bytes (caracteres
Nchar
Unicode precisam de 2 bytes por caracter).
Armazena caracteres Unicode até 1.073.741.823 posições, armazenados no dobro dos bytes declarados (caracteres
Ntext
Unicode precisam de 2 bytes por caracter).

Tipos de Campos
Tipo de dado Descrição
Numeric Veja Decimal.
Contém até 4.000 caracteres Unicode. Tipo de dado de largura variável, sendo armazenado no dobro de bytes
Nvarchar
(caracteres Unicode precisam de 2 bytes por caracter).
Real Similar ao tipo de dado float, usando apenas 4 bytes de armazenamento com precisão de até 7 dígitos.
Smalldatetime Campo data menos preciso, que armazena data e hora em precisão de minutos, utilizando 4 bytes.
Armazena dados numéricos preciso até a quantidade de números armazenados em 2 bytes. Menor que o int, ele pode
Smallint
conter números de -32.768 até 32.767.
Contém dados monetários decimais precisos até o 4 dígito. Usa 4 bytes de armazenamento e pode conter valores de -
Smallmoney
214.748,3648 até 214.748,3647.
Contém uma string de caracteres não-Unicode com tamanho de até 2.147.483.647 caracteres. Similiar ao campo memo
Text encontrado em outros bancos de dados, este tipo de dado armazena grandes quantidades de texto em páginas de 2kb.
Colunas definidas com este tipo de dado não podem ser indexadas, pesquisadas, agrupadas ou ordenadas.
Um valor binário automaticamente atualizado cada vez que uma tabela com uma coluna deste tipo é alterada. Ele usa 8
Timestamp
bytes de armazenamento e é único dentro do banco de dados. Uma tabela só pode possui uma coluna deste tipo.
Tinyint O menor tipo de dado inteiro, ele consome apenas 1 byte de armazenamento e pode conter números de 0 a 255.
Um número hexadecimal de 16 bytes, também conhecido como GUID (globally unique identification number). Use a
Uniqueidentifier função do SQL Server NEWID() para gerar novos identificadores únicos para alimentar uma variável ou uma coluna
deste tipo de dado.
Similar ao tipo binário, este pode conter até 8.000 bytes de dados binários de tamanho variável. Tamanho variável
Varbinary
significa que o campo irá consumir apenas o espaço necessário para armazenar os dados contidos no mesmo.
Contém até 8.000 bytes de tamanho variável para strings. Use este tipo para colunas que irão armazenar valores nulos
Varchar
de dados que variam em tamanho.

2.0 Linguagem SQL

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

2.0 Linguagem SQL

Enviado por

Direitos autorais:

Formatos disponíveis

Banco de Dados II

Prof. Fred Lucena fred.lucena@unibratec.edu.br 1

Prof. Fred Lucena fred.lucena@unibratec.edu.br 2

Prof. Fred Lucena fred.lucena@unibratec.edu.br 3

SQL – Structured Query Language, ou Linguagem de Consulta

Prof. Fred Lucena fred.lucena@unibratec.edu.br 4

Embora o SQL tenha sido originalmente criado pela IBM,

Prof. Fred Lucena fred.lucena@unibratec.edu.br 5

O SQL foi revisto em 1992 e a esta versão foi dado o nome de

Prof. Fred Lucena fred.lucena@unibratec.edu.br 6

Tal como dito anteriormente, o SQL, embora padronizado pela

Prof. Fred Lucena fred.lucena@unibratec.edu.br 7

Prof. Fred Lucena fred.lucena@unibratec.edu.br 8

Prof. Fred Lucena fred.lucena@unibratec.edu.br 9

Os comandos em SQL podem ser agrupados em cinco categorias

DDL: Data Definition Language (Linguagem de Definição de

Os comandos em SQL podem ser agrupados em cinco categorias

DQL: Data Query Language (Linguagem de Consulta de Dados)

Prof. Fred Lucena fred.lucena@unibratec.edu.br 11

CREATE: Cria objetos em um SGBD.

ALTER: Altera a estrutura de objetos em um SGBD.

DROP: Exclui objetos em um SGBD.

Prof. Fred Lucena fred.lucena@unibratec.edu.br 12

INSERT: Inserir dados em uma tabela.

UPDATE: Alterar dados em uma tabela.

DELETE: Excluir dados em uma tabela.

Prof. Fred Lucena fred.lucena@unibratec.edu.br 13

GRANT: Concede permissões de acesso a dados.

DENY: Negar permissões de acesso a dados.

REVOKE: Remove permissões concedidas /negadas anteriormente.

Prof. Fred Lucena fred.lucena@unibratec.edu.br 14

Prof. Fred Lucena fred.lucena@unibratec.edu.br 15

Prof. Fred Lucena fred.lucena@unibratec.edu.br 16

CREATE DATABASE <nome_banco>

ALTER DATABASE <nome_atual> MODIFY NAME = <novo_nome>

DROP DATABASE <nome_banco>

Prof. Fred Lucena fred.lucena@unibratec.edu.br 17

ALTER DATABASE BancoDados MODIFY NAME = Banco_de_Dados

DROP DATABASE Banco_de_Dados

Para evitar a mensagem de erro padrão “O banco de dados

CREATE TABLE <tabela> ( <atributo1> <tipo> [NOT NULL],

ALTER TABLE <tabela> ADD/DROP/ALTER COLUMN

DROP TABLE <nome_tabela>;

Prof. Fred Lucena fred.lucena@unibratec.edu.br 19

ALTER TABLE Dept ADD DepSala numeric(10) not null;

ALTER TABLE Dept ALTER COLUMN DepNome varchar(25) not null;

ALTER TABLE Dept DROP COLUMN DepSala;

Prof. Fred Lucena fred.lucena@unibratec.edu.br 20

Prof. Fred Lucena fred.lucena@unibratec.edu.br 21

INSERT INTO <tabela> (<campos>) VALUES (<valores>);

UPDATE <tabela> SET <campo> = <expressão> [WHERE <condição>];

DELETE FROM <tabela> [WHERE <condição>];

Prof. Fred Lucena fred.lucena@unibratec.edu.br 22

INSERT INTO dept (depnume,depnome,deploca) VALUES (70, 'Producao', 'Recife');

UPDATE dept SET DepNome = 'Pessoal’;

DELETE FROM dept;

Prof. Fred Lucena fred.lucena@unibratec.edu.br 23

INSERT INTO dept VALUES (10, 'Producao', 'Recife', 15000);

DELETE FROM dept WHERE deploca = 'Olinda' AND deporca >=30000;

SELECT * FROM dept;

DELETE FROM dept;

Prof. Fred Lucena fred.lucena@unibratec.edu.br 24

INSERT INTO dept VALUES (10, 'Producao', 'Recife', 15000);

DELETE FROM dept WHERE deploca = 'Recife' OR deporca >=40000;