Capítulo 3 SQL – STRUCTURED QUERY LANGUAGE

Quando os Bancos de Dados Relacionais estavam sendo desenvolvidos, foram criadas linguagens
destinadas à sua manipulação. O Departamento de Pesquisas da IBM, desenvolveu a SQL como
forma de interface para o sistema de BD relacional denominado SYSTEM R, início dos anos 70. Em
1986 o American National Standard Institute (ANSI), publicou um padrão SQL. A SQL estabeleceu-se
como linguagem padrão de Banco de Dados Relacional.
SQL apresenta uma série de comandos que permitem a definição dos dados, chamada de DDL
(Data Definition Language), composta entre outros pelos comandos Create, que é destinado a
criação do Banco de Dados, das Tabelas que o compõe, além das relações existentes entre as
tabelas. Como exemplo de comandos da classe DDL temos os comandos Create, Alter e Drop.
Os comandos da série DML (Data Manipulation Language), destinados a consultas, inserções,
exclusões e alterações em um ou mais registros de uma ou mais tabelas de maneira simultânea.
Como exemplo de comandos da classe DML temos os comandos Select, Insert, Update e Delete.
Uma subclasse de comandos DML, a DCL (Data Control Language), dispõe de comandos de
controle como Grant e Revoke.
A Linguagem SQL tem como grandes virtudes sua capacidade de gerenciar índices, sem a
necessidade de controle individualizado de índice corrente, algo muito comum nas linguagens de
manipulação de dados do tipo registro a registro (dos modelos Hierárquico e Redes). Outra
característica muito importante disponível em SQL é sua capacidade de construção de visões, que
são formas de visualizarmos os dados na forma de listagens independente das tabelas e organização
lógica dos dados.
Outra característica interessante na linguagem SQL é a capacidade que dispomos de cancelar uma
série de atualizações ou de as gravarmos, depois de iniciarmos uma seqüência de atualizações. Os
comandos Commit e Rollback são responsáveis por estas facilidades.
Existem inúmeras versões de SQL. A versão original foi desenvolvida no Laboratório de Pesquisa da
IBM. Esta linguagem, originalmente chamada Sequel foi implementada como parte do projeto
System R no início dos anos 70. A linguagem evoluiu desde então, e seu nome foi mudado para SQL
(Structured Query Language).
Em 1986, o Americam National Standard Institute (ANSI) publicou um padrão SQL. A IBM publicou o
seu próprio SQL standard, o Systems Aplication Arquitecture Database Interface (SAA-SQL) em
1987.
Em 1989, tanto ANSI quanto ISO publicaram padrões substitutos (ANSI X3.135-1989 e ISO/IEC
9075:1989) que aumentaram a linguagem e acrescentaram uma capacidade opcional de integridade
referencial, permitindo que projetistas de bancos de dados pudessem criar relacionamentos entre
dados em diferentes partes do banco de dados. A versão em uso do padrão ANSI / ISSO SQL é o
padrão SQL-92 (ANSI X3.135-1992) mas algumas aplicações atuais dão suporte apenas ao padrão
SQL-89.
Desde 1993 há um trabalhos sendo desenvolvidos para atualizar o padrão de modo que este atenda
às características das últimas versões de bancos de dados relacionais lançadas no mercado. A
principal inovação da nova versão (chamada provisoriamente de SQL3) é o suporte à orientação a
objetos.
Algumas das características da linguagem SQL são:
Ø Permite trabalhar com várias tabelas;
Ø Permite utilizar o resultado de uma instrução SQL em outra instrução SQL (sub-queries);
Ø Não necessita especificar o método de acesso ao dado;
Ø É uma linguagem para vários usuários como:
Ø Administrador do sistema;

Bancos de Dados 20 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Ø Administrador do banco de dados (DBA);
Ø Programadores de aplicações;
Ø Pessoal da agência e tomada de decisão;
Ø É de fácil aprendizado;
Ø Permite a utilização dentro de uma linguagem procedural como C, COBOL, FORTRAN, Pascal e
PL/I - SQL embutida.

3.1 A ESTRUTURA BÁSICA DE UMA EXPRESSÃO SQL

A estrutura básica de uma expressão SQL consiste em três cláusulas: select, from e where.
Ø A cláusula select corresponde à operação projeção da álgebra relacional. É usada para listar os
atributos desejados no resultado de uma consulta.
Ø A cláusula from corresponde à operação produto cartesiano da álgebra relacional. Ela lista as
relações a serem examinadas na avaliação da expressão.
Ø A cláusula where corresponde ao predicado de seleção da álgebra relacional. Consiste em um
predicado envolvendo atributos de relações que aparecem na cláusula from.
Uma típica consulta SQL segue a seguinte ordem:
select a1, a2, ..., an ß 3ª
from T1, T2, ..., Tm ß 1ª
where P ß 2ª

Cada ai representa um atributo e cada Ti é uma relação e P é um predicado. Esta consulta é

equivalente à expressão da álgebra relacional

π a1, a2, ..., an σP (T1 x T2 x ...x Tm))

(σ

A SQL forma o produto cartesiano das relações chamadas na cláusula from, executa uma seleção da
álgebra relacional usando o predicado da cláusula where e, então, projeta o resultado para os
atributos da cláusula select. Na prática, a SQL pode converter esta expressão em uma forma
equivalente que pode ser processada mais eficientemente.
Exemplo
No esquema BANCO, encontre os nomes de todos os clientes de ‘Vitória’.
select cliente_nome
from CLIENTE
where cidade = ‘Vitória’
Encontre os nomes de todos os clientes.
select cliente_nome
from CLIENTE
Exemplo
No esquema EMPRESA, selecionar o nome e o RG dos funcionários que trabalham no departamento
número 2 na tabela EMPREGADO
select nome, rg
from EMPREGADOS
where depto = 2;

Bancos de Dados 21 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
obteremos então o seguinte resultado:

Nome RG
Fernando 20202020
Ricardo 30303030
Jorge 40404040

A consulta acima é originária da seguinte função em álgebra relacional:

πnome, rg (σdepto = 2 (EMPREGADOS));

Em SQL também é permitido o uso de condições múltiplas. Veja o exemplo a seguir:

select nome, rg, salario
from EMPREGADOS
where depto = 2 AND salario > 2500.00;

que fornece o seguinte resultado:

Nome RG Salário
Jorge 40404040 4.200,00

e que é originária da seguinte função em álgebra relacional:

πnome, rg, salario (σdepto = 2 .and. salario > 3500.00(EMPREGADOS));

O operador * dentro do especificador select seleciona todos os atributos de uma tabela, enquanto
que a exclusão do especificador where faz com que todas as tuplas de uma tabela sejam
selecionadas. Desta forma, a expressão:
select *
from empregado;

gera o seguinte resultado:

Nome RG CPF Depto RG Supervisor Salário
João Luiz 10101010 11111111 1 NULO 3.000,00
Fernando 20202020 22222222 2 10101010 2.500,00
Ricardo 30303030 33333333 2 10101010 2.300,00
Jorge 40404040 44444444 2 20202020 4.200,00
Renato 50505050 55555555 3 20202020 1.300,00

3.1.1 Cláusulas Distinct e All

Diferente de álgebra relacional, a operação select em SQL permite a geração de tuplas duplicadas
como resultado de uma expressão. Para evitar isto, devemos utilizar o cláusula distinct.

Bancos de Dados 22 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Sejam as seguintes consultas no esquema EMPRESA.
select depto select distinct depto
from EMPREGADO; from EMPREGADO;
que geram respectivamente os seguintes resultados:
Depto Depto
1 1
2 2
2 3
2
3

A cláusula All é o default para o select ou seja: Select All indica para obter todas as tuplas. Logo,
esta cláusula não precisa ser colocado (a não ser, talvez por motivos de documentação).

3.1.2 Predicados e ligações

A SQL não têm uma representação da operação ligação natural. No entanto, uma vez que a ligação
natural é definida em termos de um produto cartesiano, uma seleção e uma projeção, é
relativamente simples escrever uma expressão SQL para uma ligação natural.
Exemplo

Encontre os nomes e cidades de clientes que possuam empréstimos em alguma agência.

Select distinct cliente_nome, cidade
From Cliente, Emprestimo
Where Cliente.cliente_cod=Emprestimo.cliente_cod

A SQL inclui os conectores and, or e not; caracteres especiais: (, ), ., :, _, %<, >, <= , >= , = , <>, +,
- ,* e /; operador para comparação: between, como mostra o exemplo a seguir.
Exemplo
Selecionar todas as contas que possuam saldo entre 10000 e 20000.
Select conta_numero
From CONTA
Where saldo >= 10000 and saldo <= 20000

Que equivale à consulta

Select conta_numero
From CONTA
Where saldo between 10000 and 20000

A SQL inclui também um operador para comparações de cadeias de caracteres, o like. Ele é usado
em conjunto com dois caracteres especiais:
Ø Por cento (%). Substitui qualquer subcadeia de caracteres.
Ø Sublinhado ( _ ). Substitui qualquer caractere.
Exemplo
Encontre os nomes de todos os clientes cujas ruas incluem a subcadeia ‘na’
Select distinct cliente_nome
From CLIENTE
Where rua like ‘%na%’

Bancos de Dados 23 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Encontre os nomes de todos os clientes cujas ruas finalizem com a subcadeia ‘na’, seguido de um
caractere.
Select distinct cliente_nome
From CLIENTE
Where rua like ‘%na_’

Para que o padrão possa incluir os caracteres especiais ( isto é, % , _ , etc...), a SQL permite a
especificação de um caractere de escape. O caractere de escape é usado imediatamente antes de
um caractere especial para indicar que o caractere especial deverá ser tratado como um caractere
normal. Definimos o caractere de escape para uma comparação like usando a palavra-chave
escape. Para ilustrar, considere os padrões seguintes que utilizam uma barra invertida como
caractere de escape.
Ø Like ‘ ab\%cd%’ escape ‘\’ substitui todas as cadeias começando com ‘ ab%cd’;
Ø Like ‘ ab\_cd%’ escape ‘\’ substitui todas as cadeias começando com ‘ ab_cd’.

A procura por não-substituições em vez de substituições dá-se através do operador not like.

3.2 VARIÁVEIS TUPLAS (RENOMEAÇÃO)

Exemplo
No esquema EMPRESA, selecione o número do departamento que controla projetos localizados em
Rio Claro;
select t1.numero_depto
from departamento_projeto as t1, projeto as t2
where t1.numero_projeto = t2.numero;

Na expressão SQL acima, t1 e t2 são chamados “alias” (apelidos) e representam a mesma tabela a
qual estão referenciando. Um “alias” é muito importante quando há redundância nos nomes das
colunas de duas ou mais tabelas que estão envolvidas em uma expressão. Ao invés de utilizar o
“alias”, é possível utilizar o nome da tabela, mas isto pode ficar cansativo em consultas muito
complexas além do que, impossibilitaria a utilização da mesma tabela mais que uma vez em uma
expressão SQL. A palavra chave as é opcional.
Exemplo
No esquema EMPRESA, selecione selecione o nome e o RG de todos os funcionários que são
supervisores.
select e1.nome as “Nome do Supervisor”, e1.rg as “RG do Supervisor”
from empregado e1, empregado e2
where e1.rg = e2.rg_supervisor;
que gera o seguinte resultado:
Nome do Supervisor RG do Supervisor
João Luiz 10101010
Fernando 20202020

Observação: A consulta acima é decorrente da seguinte expressão em álgebra relacional:

πnome, rg (EMPREGADOS |X| tg_t1 = rg_supervisor_t2 EMPREGADOS)

Bancos de Dados 24 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Encontre o nome e a cidade de todos os clientes com uma conta em qualquer agência.

Select distinct C.cliente_nome, C.cidade

from CLIENTE C, CONTA S
where C.cliente_cod = S.cliente_cod

3.3 OPERAÇÕES DE CONJUNTOS

A SQL inclui as operações de conjunto union, intersect e minus que operam em relações e
correspondem às operações ∪ , ∩ e – da álgebra relacional.
Uma vez que as relações são conjuntos, na união destas, as linhas duplicadas são eliminadas. Para
que uma operação R ∪ S, R ∩ S ou R - S seja válida, necessitamos que duas condições sejam
cumpridas:
Ø As relações R e S devem ter o mesmo número de atributos;
Ø Os domínios do i-ésimo atributo de R e do i-ésimo atributo de S devem ser os mesmos.
Observação: Nem todos os interpretadores SQL suportam todas as operações de conjunto. Embora a
operação union seja relativamente comum, são raros os que suportam intersect ou minus.
Exemplo
Mostrar o nome dos clientes que possuem conta, empréstimo ou ambos na agência de código ‘ 051’:
Empréstimo na agência ‘ 051’:
Select distinct cliente_nome
From CLIENTE, EMPRESTIMO
Where CLIENTE.cliente_cod= EMPRESTIMO.cliente_cod and
agencia_cod = ‘051’
Conta na agência ‘ 051’:
Select distinct cliente_nome
From CLIENTE, CONTA
Where CLIENTE.cliente_cod= CONTA.cliente_cod and
CONTA.agencia_cod = ‘051’
Fazendo a união dos dois:
(Select distinct cliente_nome
From CLIENTE, EMPRESTIMO
Where CLIENTE.cliente_cod= EMPRESTIMO.cliente_cod and
agencia_cod = ‘051’ )
Union
(Select distinct cliente_nome
From CLIENTE, CONTA
Where CLIENTE.cliente_cod= CONTA.cliente_cod and
CONTA.agencia_cod = ‘051’ )
Exemplo
Achar todos os clientes que possuam uma conta e um empréstimo na agência de código ‘ 051’.
(Select distinct cliente_nome
From CLIENTE, EMPRESTIMO
Where CLIENTE.cliente_cod= EMPRESTIMO.cliente_cod and
agencia_cod = ‘051’ )
intersect
(Select distinct cliente_nome
From CLIENTE, CONTA
Where CLIENTE.cliente_cod= CONTA.cliente_cod and
CONTA.agencia_cod = ‘051’ )

Bancos de Dados 25 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Achar todos os clientes que possuem uma conta mas não possuem um empréstimo na agência de
código ‘ 051’.

(Select distinct cliente_nome

From CLIENTE, EMPRESTIMO
Where CLIENTE.cliente_cod=Emprestimos.cliente_cod and
EMPRESTIMO.agencia_cod = ‘051’ )
minus
(Select distinct cliente_nome
From CLIENTE, CONTA
Where CLIENTE.cliente_cod= CONTA.cliente_cod and
CONTA.agencia_cod = ‘051’ )

3.4 EXERCÍCIOS
Baseado no esquema EMPRESA, faça as seguintes consultas SQL.
1. Selecione todos os empregados com salário maior ou igual a 2000,00.
2. Selecione todos os empregados cujo nome começa com ‘J’.
3. Mostre todos os empregados que têm ‘Luiz’ ou ‘Luis’ no nome.
4. Mostre todos os empregados do departamento de ‘Engenharia Civil’.
5. Mostre todos os nomes dos departamentos envolvidos com o projeto ‘Motor 3’.
6. Liste o nome dos empregados envolvidos com o projeto ‘Financeiro 1’.
7. Mostre os funcionários cujo supervisor ganha entre 2000 e 2500.

Baseado no esquema BANCO, faça as seguintes consultas SQL.

8. Liste todas as cidades onde há agências.
9. Liste todas as agências existentes em ‘Vitória’.
10. Liste todas as agências que possuem conta com saldo maior que 100.000,00.
11. Mostre os dados de todos os clientes da agência ‘Centro’ da cidade de ‘Vitória’ que têm saldo
negativo.
12. Liste os dados dos clientes que possuem conta mas não possuem empréstimo na agência de
código ‘005’.

Bancos de Dados 26 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
3.5 ORDENANDO A EXIBIÇÃO DE TUPLAS (ORDER BY)
A cláusula order by ocasiona o aparecimento de tuplas no resultado de uma consulta em uma
ordem determinada. Para listar em ordem alfabética todos os clientes do banco, fazemos:

Select distinct cliente_nome

From CLIENTE
Order by cliente_nome

Como padrão, SQL lista tuplas na ordem ascendente. Para especificar a ordem de classificação,
podemos especificar asc para ordem ascendente e desc para descendente. Podemos ordenar uma
relação por mais de um elemento. Como se segue:

Select *
From EMPRESTIMO
Order by quantia desc, agencia_cod asc

Para colocar as tuplas (linhas) em ordem é realizada uma operação de sort. Esta operação é
relativamente custosa e portanto só deve ser usada quando realmente necessário.

3.6 MEMBROS DE CONJUNTOS

O conectivo in testa os membros de conjunto, onde o conjunto é uma coleção de valores produzidos
por uma cláusula select. Da mesma forma, pode ser usada a expressão not in.
Exemplo
Selecione todas as agências com código 1, 2 ou 3.
select *
from agencia
where agencia_cod in (1,2,3)

Exemplo
Selecione o nome de todos os funcionários que trabalham em projetos localizados em
Rio Claro.
select e1.nome, e1.rg, e1.depto
from empregado e1, empregado_projeto e2
where e1.rg = e2.rg_empregado and
e2.numero_projeto in
(select numero
from projeto
where localizacao = ‘Rio Claro’);

Bancos de Dados 27 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Encontre todos os clientes que possuem uma conta e um empréstimo na agência ‘Princesa Isabel’.

Select distinct cliente_nome

From CLIENTE
Where CLIENTE.cliente_cod in

(select cliente_cod
from CONTA, AGENCIA
where CONTA.agencia_cod = AGENCIA.agencia_cod and
agencia_nome = ‘Princesa Isabel’)

and CLIENTE.cliente_cod in

(select cliente_cod
from EMPRESTIMO, AGENCIA
where EMPRESTIMO.agencia_cod= AGENCIA.agencia_cod and
agencia_nome = ‘Princesa Isabel’)

Exemplo
Encontre todas as agências que possuem ativos maiores que alguma agência de Vitória.

select distinct t.agencia_nome

from AGENCIA t, AGENCIA s
where t.ativos > s.ativos and s.cidade = ‘Vitória’

Observação: Uma vez que isto é uma comparação “maior que”, não podemos escrever a
expressão usando a construção in.
A SQL oferece o operador some (equivalente ao operador any), usado para construir a consulta
anterior. São aceitos pela linguagem: >some, <some, >=some, <=some, =some
select agencia_nome
from AGENCIA
where ativos > some
(select ativos
from AGENCIA
where agencia_cidade = ‘Vitória’)

Como o operador some, o operador all pode ser usado como: >all, <all, >=all, <=all, =all e <>all. A
construção > all corresponde a frase “maior que todos”.

Bancos de Dados 28 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Encontrar as agências que possuem ativos maiores do que todas as agências de Vitória.
select agencia_nome
from AGENCIA
where ativos > all
(select ativos
from AGENCIA
where agencia_cidade = ‘Vitória’)

A SQL possui um recurso para testar se uma subconsulta tem alguma tupla em seus resultados. A
construção exists retorna true se o argumento subconsulta está não-vazio. Podemos usar também a
expressão not exists.
Exemplo
No esquema EMPRESA, lise o nome dos gerentes que têm ao menos um dependente.
Select nome
from EMPREGADO
where exists
(select *
from DEPENDENTES
where DEPENDENTES.rg_responsavel = EMPREGADO.rg)
and exists
(select *
from DEPARTAMENTO
where DEPARTAMENTO.rg_gerente = EMPREGADO.rg)
Exemplo
Usando a construção exists, encontre todos os clientes que possuem uma conta e um empréstimo
na agência ‘Princesa Isabel’.
Select cliente_nome
from CLIENTE
where exists
(select *
from CONTA, AGENCIA
where CONTA.cliente_cod= CLIENTE.cliente_cod and
AGENCIA.agencia_cod = CONTA.agencia_cod and
agencia_nome = ‘Princesa Isabel’)
and exists
(select *
from EMPRESTIMO, AGENCIA
where EMPRESTIMO.cliente_cod= CLIENTE.cliente_cod and
AGENCIA.agencia_cod = EMPRESTIMO.agencia_cod and
agencia_nome = ‘Princesa Isabel’)

Bancos de Dados 29 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
3.7 FUNÇÕES AGREGADAS
A SQL oferece a habilidade para computar funções em grupos de tuplas usando a cláusula group
by. O(s) atributo(s) dados na cláusula group by são usados para formar grupos. Tuplas com o
mesmo valor em todos os atributos na cláusula group by são colocados em um grupo. A SQL inclui
funções para computar:
Média: avg Mínimo: min Máximo: max Soma: sum Contar: count
Exemplo
Encontre o saldo médio de conta em cada agência.
Select agencia_nome, avg(saldo)
From CONTA, AGENCIA
where CONTA.agencia_cod = AGENCIA.agencia_cod
Group by agencia_nome
Exemplo
Encontre o número de depositantes de cada agência.
Select agencia_nome, count(distinct cliente_nome)
From CONTA, AGENCIA
where CONTA.agencia_cod = AGENCIA.agencia_cod
Group by agencia_nome

Observação: Note que nesta última consulta é importante a existência da cláusula distinct pois um
cliente pode Ter mais de uma conta em uma agência, e deverá ser contado uma
única vez.
Exemplo
Encontre o maior saldo de cada agência.
Select agencia_nome, max(saldo)
From CONTA, AGENCIA
Where CONTA.agencia_cod= AGENCIA.agencias_cod
Group by agencia_nome

Ás vezes, é útil definir uma condição que se aplique a grupos em vez de tuplas. Por exemplo,
poderíamos estar interessados apenas em agências nas quais a média dos saldos é maior que 1200.
Esta condição será aplicada a cada grupo e não à tuplas simples e é definida através da cláusula
having. Expressamos esta consulta em SQL assim:
Select agencia_nome, avg(saldo)
From CONTA, AGENCIA
Where CONTA.agencia_cod= AGENCIA.agencias_cod
Group by agencia_nome Having avg(saldo)>1200

Às vezes, desejamos tratar a relação inteira como um grupo simples. Nesses casos, não usamos a
cláusula group by.
Exemplo
Encontre a média de saldos de todas as contas.
Select avg(saldo)
From CONTA

Bancos de Dados 30 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
3.8 MODIFICANDO O BANCO DE DADOS
3.8.1 Remoção
Podemos remover somente tuplas inteiras, não podemos remover valores apenas em atributos
particulares.
Sintaxe:
Delete R
Where P
onde R representa uma relação e P um predicado.
Note que o comando delete opera em apenas uma relação. O predicado da cláusula where pode ser
tão complexo como o predicado where do comando select.
Exemplo
Remover todas as tuplas de empréstimo.
delete EMPRESTIMO
Exemplo
Remover todos os registros da conta de ‘João’.
delete CONTA
where cliente_cod in
(select cliente_cod
from CLIENTE
where cliente_nome = ‘João’)
Exemplo
Remover todos os empréstimos com números entre 1300 e 1500.
delete EMPRESTIMO
where emprestimo_numero between 1300 and 1500
Exemplo
Remova todas as contas de agências localizadas em ‘Vitória’.
Delete CONTA
where agencia_cod in
(select agencia_cod
from AGENCIA
where agencia_cidade=‘Vitoria’)

3.8.2 Inserção
Para inserir um dado em uma relação, ou especificamos uma tupla para ser inserida escrevemos
uma consulta cujo resultado seja um conjunto de tuplas a serem inseridas. Os valores dos atributos
para tuplas inseridas precisam necessariamente ser membros do mesmo domínio do atributo.
Exemplo
Inserir uma nova conta para João (código = 1), número 9000, na agência de código=2 cujo valor
seja 1200.
insert into CONTA
values (2,9000,1,1200)

Bancos de Dados 31 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Na inserção acima é considerando a ordem na qual os atributos correspondentes estão listados no
esquema relação. Caso o usuário não se lembre da ordem destes atributos, pode fazer o mesmo
comando da seguinte forma:
insert into CONTA (agencia_cod, conta_numero, cliente_cod, saldo)
values (2,9000,1,1200)

Podemos querer também inserir tuplas baseadas no resultado de uma consulta.

Exemplo
Inserir todos os clientes que possuam empréstimos na agência ‘Princesa Isabel’ na relação CONTA
com um saldo de 200. O número da nova conta é o número do empréstimo * 10000.
insert into CONTA (agencia_cod, conta_numero, cliente_cod, saldo)
select AGENCIA.agencia_cod, emprestimo_numero*10000, cliente_cod, 200
from EMPRESTIMO, AGENCIA
where EMPRESTIMO.agencia_cod= AGENCIA.agencia_cod and
agencia_nome = 'Princesa Isabel'

3.8.3 Atualizações
Em certas situações, podemos desejar mudar um valor em uma tupla sem mudar todos os valores na
tupla. Para isso, o comando update pode ser usado.
Suponha que esteja sendo feito o pagamento de juros, e que em todos saldos sejam acrescentados
em 5%. Escrevemos
update CONTA
set saldo = saldo * 1,05

Suponha que todas as contas com saldo superiores a 10000 recebam aumento de 6% e as demais
de 5%.
Update CONTA
set saldo = saldo * 1,06
where saldo >10000

Update CONTA
set saldo = saldo * 1,05
where saldo<=10000

A cláusula where pode conter uma série de comandos select aninhados. Considere, por exemplo,
que todas as contas de pessoas que possuem empréstimos no banco terão acréscimo de 1%.
Update CONTA
set saldo = saldo * 1,01
where cliente_cod in
(select cliente_cod
from EMPRESTIMO )

Exemplo
No esquema EMPRESA, atualize o salário de todos os empregados que trabalham no departamento
2 para R$ 3.000,00.
update empregado
set salario = 3000
where depto = 2;

Exemplo
No esquema BANCO, atualize o valor dos ativos. Os ativos são os valores dos saldos das contas da
agência.

Bancos de Dados 32 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
 update agencia
set ativos =
(select sum(saldo)
from conta
where conta.agencia_cod = agencia.agencia_cod)

3.8.4 Valores Nulos

É possível dar valores a apenas alguns atributos do esquema para tuplas inseridas em uma dada
relação. Os atributos restantes são designados como nulos. Considere a requisição:
insert into CLIENTE (cliente_cod, cliente_nome, rua, cidade)
values (123,'Andrea',null,null)
A palavra chave null pode ser usada em um predicado para testar se um valor é nulo. Assim, para
achar todos os clientes que possuem valores nulos para rua, escrevemos:
select distinct cliente_nome
from CLIENTE
where rua is null

O predicado is not null testa a ausência de um valor nulo.

3.9 DEFINIÇÃO DE DADOS

O conjunto de relações de um Banco de Dados precisa ser especificado ao sistema por meio de uma
linguagem de definição de dados - DDL. A SQL DDL permite a especificação não apenas de um
conjunto de relações, mas também de informações sobre cada relação, incluindo:
Ø Esquema para cada relação;
Ø Domínio de valores associados a cada atributo;
Ø Conjunto de índices a ser mantido para cada relação;
Ø Restrições de integridade;
Ø A estrutura física de armazenamento de cada relação no disco.
Uma relação SQL é definida usando o comando create table. A forma geral do comando create
table então é:
create table <nome_tabela> (
<nome_coluna1> <tipo_coluna1> <NOT NULL>,
<nome_coluna2> <tipo_coluna2> <NOT NULL>,
...
<nome_colunan> <tipo_colunan> <NOT NULL>);

A restrição not null indica que o atributo deve ser obrigatoriamente preenchido; se não for
especificado, então o default é que o atributo possa assumir o valor nulo.
Exemplo
Criar a tabela EMPREGADO do esquema EMPRESA, teríamos o seguinte comando:
create table EMPREGADO
(nome char (30) NOT NULL,
rg integer NOT NULL,
cic integer,
depto integer NOT NULL,
rg_supervisor integer,
salario, decimal (7,2)NOT NULL)

O comando create table inclui opções para especificar certas restrições de integridade, conforme
veremos.

Bancos de Dados 33 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
A relação criada acima está inicialmente vazia. O comando insert poderá ser usado para carregar os
dados para uma relação.
Para remover uma tabela de banco de dados SQL, usamos o comando drop table. O comando drop
table remove todas as informações sobre a relação retirada do banco de dados. A forma geral para o
comando drop table é:
drop table <nome_tabela>;

Exemplo
Eliminar a tabela EMPREGADO do esquema EMPRESA, teríamos o seguinte comando:
drop table EMPREGADOS;

Observe que neste caso, a chave da tabela EMPREGADOS, (rg) é utilizada como chave estrangeira
ou como chave primária composta em diversos tabelas que devem ser devidamente corrigidas. Este
processo não é assim tão simples pois, como vemos neste caso, a exclusão da tabela EMPREGADO
implica na alteração do projeto físico de diversas tabelas. Isto acaba implicando na construção de
uma nova base de dados.

O comando alter table é usado para alterar a estrutura de uma relação existente. Permite que o
usuário faça a inclusão de novos atributos em uma tabela. A forma geral para o comando alter table
é a seguinte:
alter table <tabela> <add,drop,modify> <coluna> <tipo_coluna>;

onde add, adiciona uma coluna; drop, remove uma coluna; e modify, modifica algo em uma tabela.
No caso do comando alter table, a restrição NOT NULL não é permitida pois assim que se insere um
novo atributo na tabela, o valor para o mesmo em todas as tuplas da tabela receberão o valor NULL.
Não é permitido eliminar algum atributo de uma relação já definida. Assim caso você desejar
eliminar uma chave primária devidamente referenciada em outra tabela como chave estrangeira, ao
invés de obter a eliminação do campo, obterá apenas um erro.

3.10 VISÕES (VIEWS)

Uma view em SQL é uma tabela que é derivada de outras tabelas ou de outras views. Uma view não
necessariamente existe em forma física; é considerada uma tabela virtual (em contraste com as
tabelas cujas tuplas são efetivamente armazenadas no banco de dados).
Uma view é definida usando o comando create view. Para definir uma visão, precisamos dar a ela
um nome e definir a consulta que a processa.
A forma geral é:
create view <nomevisao> as <expressão de consulta>

onde, <expressão de consulta> é qualquer consulta SQL válida. Como exemplo, considere a visão
consistindo em nomes de agências e de clientes.
Create view TOTOS_CLIENTES as
(select agencia_nome,cliente_nome
from CLIENTE, CONTA, AGENCIA
where CLIENTE.cliente_cod = CONTA.cliente_cod and
CONTA.agencia_cod = AGENCIA.agencia_cod)
union
(select agencia_nome,cliente_nome
from CLIENTE, EMPRESTIMO, AGENCIA
where CLIENTE.cliente_cod = EMPRESTIMO.cliente_cod and
EMPRESTIMO.agencia_cod = AGENCIA.agencia_cod)

Bancos de Dados 34 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Nomes de visões podem aparecer em qualquer lugar onde nome de relação (tabela) possa aparecer.
Usando a visão TOTOS_CLIENTES, podemos achar todos os clientes da agência ‘Princesa Isabel’,
escrevendo:
select cliente_nome
from TOTOS_CLIENTES
where agencia_nome = ‘Princesa Isabel’
Uma modificação é permitida através de uma visão apenas se a visão em questão está definida em
termos de uma relação do atual banco de dados relacional.
Exemplo
Selecionando tuplas de empréstimos.
Create view emprestimo_info as
(select agencia_cod, emprestimo_numero, cliente_cod
from EMPRESTIMO)

Uma vez que a SQL permite a um nome de visão aparecer em qualquer lugar em que um nome de
ralação aparece, podemos escrever:
insert into emprestimo_info
values (1,40,7)

Esta inserção é representada por uma inserção na relação EMPRESTIMO, uma vez que é a relação
a partir do qual a visão emprestimo_info foi construída. Devemos, entretanto, ter algum valor para
quantia. Este valor é um valor nulo. Assim, o insert acima resulta na inserção da tupla: (1,40,7,null)
na relação EMPRESTIMO.
Da mesma forma, poderíamos usar os comandos update, e delete.
Para apagar uma visão, usamos o comando
drop view <nomevisão>

Exemplo
Apagar a visão emprestimo_info.
drop view emprestimo_info

3.11 RESTRIÇÕES DE INTEGRIDADE

As restrições de integridade fornecem meios para assegurar que mudanças feitas no banco de dados
por usuários autorizados não resultem na inconsistência dos dados.
Há vários tipos de restrições de integridade que seriam cabíveis a bancos de dados. Entretanto as
regras de integridade são limitadas às que podem ser verificadas com um mínimo de tempo de
processamento.

3.11.1 Restrições de domínios

Um valor de domínio pode ser associado a qualquer atributo. Restrições de domínio são as mais
elementares formas de restrições de integridade. Elas são facilmente verificadas pelo sistema
sempre que um novo item de dado é incorporado ao banco de dados.
O princípio que está por traz do domínio de atributos é similar aos dos tipos em linguagem de
programação. De fato é possível criar domínios em SQL através do comando create domain.
A forma geral é:
CREATE DOMAIN nome_do_domínio tipo_original
[ [ NOT ] NULL ]
[ DEFAULT valor_default ]
[ CHECK ( condições ) ]

Bancos de Dados 35 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Cria o tipo_codigo como um número de 3 algarismos com valores permitidos de 100 a 800.
create domain tipo_codigo numeric(3)
not null
check ((tipo_codigo >= 100) and (tipo_codigo <= 800))

A cláusula check da SQL-92 permite modos poderosos de restrições de domínio. Ela pode ser usada
também no momento de criação da tabela.
Exemplo
create table dept
(deptno integer(2) not null,
dname char(12),
loc char(12),
check (dptono >= 100))

3.11.2 Restrições de integridade referencial

Muitas vezes, desejamos assegurar que um valor que aparece em uma relação para um dado
conjunto de atributos, apareça também para um certo conjunto de atributos em outra relação. Isto é
chamado de Integridade Referencial.
Neste relacionamento, considerando K1 como
sendo chave primária de E1 e Kn como sendo
chave primária de En, temos em R tuplas que
serão identificadas inclusive por K1 e Kn (na
forma de chaves estrangeiras). Desta forma não
poderá existir um elemento K1 em R que não faça parte de E1, tão pouco um Kn em R que não faça
parte de En.
As modificações no banco de dados podem causar violações de integridade referencial.
Considerações devem ser feitas ao inserir, remover e atualizar tuplas.

Considerar: πα(R2) ⊆ πk(R1)

Ø Inserir. Se uma tupla t2 é inserida em R2, o sistema precisa assegurar que existe uma tupla t1
em R1 tal que t1[k] = t2[α]. Isto é, t2[α] ε πk(R1)
Ø Remover. Se uma tupla t2 é removida de R2, o sistema precisa computar o conjunto de tuplas
em R2que referencia t1:

σ α (R1)= t1[k](R2)
Se este conjunto não for vazio, o comando remover é rejeitado como um erro, ou as tuplas que
se referem a t1 precisam elas mesmas ser removidas. A última solução pode levar a uma
remoção em cascata, uma vez que as tuplas precisam referir-se a tuplas que se referem a t1 e
assim por diante.
Ø Atualizar. Precisamos considerar dois casos para atualização: a atualização da relação
referenciadora (filha - R2) e atualização da relação referenciada (pai - R1).
Se a tupla t2 é atualizada na relação R2 e a atualização modifica valores para a chave
estrangeira α, então é feito um teste similar para o caso de inserção. Digamos que t2 denote o
novo valor da tupla t2’. O sistema precisa assegurar que:

t2’ [α]∈ πk (R1)

Se a tupla t1 é atualizada em R1, e a atualização modifica valores para a chave primária (K),
então é feito um teste similar ao caso remover. O sistema precisa computar

σ α (R1)= t1[k](R2)

Bancos de Dados 36 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
A SQL permite a especificação de chaves primárias, candidatas e estrangeiras como parte da
instrução create table.
Ø A cláusula primary key da instrução create table inclui uma lista de atributos que compreende a
chave primária;
Ø A cláusula unique key da instrução create table inclui uma lista de atributos que compreende a
chave candidata;
Ø A cláusula foreign key da instrução create table inclui uma lista de atributos que compreende a
chave estrangeira e o nome da relação referida pela chave estrangeira.
Exemplo
Criar as relações cliente, agencia e conta para o esquema do banco.

Create table CLIENTE

(cliente_cod integer not null,
cliente_nome char(30),
rua char(30),
cidade char(30),
primary key (cliente_cod))

Create table AGENCIA

(agencia_cod integer not null,
agencia_nome char(30),
agencia_cidade char(30),
fundos decimal (7,2),
primary key (agencia_cod),
check (fundos >= 0))

Create table CONTA

(agencia_cod int,
conta_numero char(10) not null,
cliente_cod int not null,
saldo decimal (7,2),
primary key (cliente_cod,conta_numero),
foreign key (cliente_cod) references clientes,
foreign key (agencia_cod) references agencias,
check (fundos >= 0))

Notem que os atributos chaves precisam ter a especificação de not null.

Quando uma regra de integridade referencial é violada, o procedimento normal é rejeitar a ação que
ocasionou essa violação. Entretanto é possível criar ações para modificação das tabelas associadas
onde houve (ou haveria) a quebra de integridade referencial.
Isto é feito através das cláusulas on delete cascade e on update cascade associadas à clausula
foreign key.

Bancos de Dados 37 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Exemplo
Create table CONTA
(...

foreign key (agencia_cod) references agencia)

on delete cascade on update cascade,

...)
Neste exemplo, se a remoção de uma tupla da tabela agência resultar na violação da regra de
integridade, o problema é resolvido removendo as tuplas associadas com esta agência da tabela
conta. De forma semelhante, se o código de uma agência for alterado, as contas desta agência serão
também alteradas.

3.11.3 Asserções
Uma asserção (afirmação) é um predicado expressando uma condição que desejamos que o banco
de dados sempre satisfaça. Quando uma assertiva é criada, o sistema testa sua validade. Se a
afirmação é válida, então qualquer modificação posterior no banco de dados será permitida apenas
quando a asserção não for violada.
Restrições de domínio e regras de integridade referencial são formas especiais de asserções.
O alto custo de testar e manter afirmações tem levado a maioria de desenvolvedores de sistemas a
omitir o suporte para afirmações gerais. A proposta geral para a linguagem SQL inclui uma
construção de proposta geral chamada instrução create assertion para a expressão de restrição de
integridade. Uma afirmação pertencente a uma única relação toma a forma:
create assertion <nome da asserção> check <predicado>
Exemplo
Definir uma restrição de integridade que não permita saldos negativos.
create assert saldo_restricao
check (not exists (select * from CONTA where saldo < 0) )
Exemplo
Só permitir a inserção de saldos maiores que quantias emprestadas para aquele cliente.
create assert saldo_restricao2
check (not exists
(select *
from conta
where saldo <
(select max(quantia)
from EMPRESTIMO
where EMPRESTIMO.cliente_cod = CONTA.cliente_cod)))

Bancos de Dados 38 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
3.12 EXECÍCIOS
Observação. Os seguintes exercícios, bem como a maior parte do texto destas notas de aula, foram tirados
das notas de aula de Bancos de Dados 98/01 da Professora Claudinete Vicente Borges.
Considerando o esquema:
Pessoas = (CodPessoa, NomePessoa, Cidade, Chefe)
Empresas = (CodEmpresa, NomeEmpresa, Cidade)
Trabalha = (CodPessoa, CodEmpresa, Salario)

1. Consulte todas as pessoas que trabalham em Vitória.

Select Pessoas.NomePessoa
from Pessoas
where Cidade = ‘Vitória’

2. Consulte todas as pessoas que trabalham na mesma cidade onde moram.

Select Pessoas.NomePessoa
from Pessoas, Trabalha, Empresas
where Pessoas.CodPessoa = Trabalha.CodPessoa and
Trabalha.CodEmpresa = Empresas.CodEmpresa and
Pessoa.Cidade = Empresas.Cidade

3. Consulte todas as pessoas que moram na mesma cidade do chefe.

Select Pessoas.NomePessoa
from Pessoas, Pessoas Chefes
where Pessoas.Chefe = Chefes.CodPessoa and
Pessoa.Cidade = Chefes.Cidade

4. Consulte todas as empresas que funcionam em cidades que não moram pessoas cujo
primeiro nome seja Maria (usar operações de conjunto).
Select Empresas.NomeEmpresa
from Empresas
Where Empresas.Cidade not in
(select Cidade
from Pessoas
Where Pessoas.NomePessoa like ‘Maria%’)

5. Consulte todas as pessoas que não trabalham em Vitória e que ganham acima de 2000 em
ordem decrescente da cidade onde moram.
Select Pessoas.NomePessoa
from Pessoas, Trabalha, Empresas
where Pessoas.CodPessoa = Trabalha.CodPessoa and
Trabalha.CodEmpresa = Empresas.CodEmpresa and
Empresas.Cidade < > ‘Vitória’ and Salario > 2000
order by pessoas.cidade desc

6. Consulte todas as pessoas que não trabalham na empresa que comece com ‘inf_’ em
ordem alfabética.
Select Pessoas.NomePessoa
from Pessoas, Trabalha, Empresas
where Pessoas.CodPessoa = Trabalha.CodPessoa and
Trabalha.CodEmpresa = Empresas.CodEmpresa and
Empresas.nomeEmpresa not like ‘inf&_%’ scape ‘&’
order by nomeEmpresa

Bancos de Dados 39 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
Considere o esquema seguinte para as questões que se seguem.
Fabricante =(codf, nomef)
Automovel =(coda, nomea, preço, codf)
Pessoa =(codp, nomep)
Venda =(codp, coda, valor, cor, data)

7. Quem comprou ‘Ford’? (fazer duas consultas).

select Pessoa.NomeP
from Pessoa, venda
where Pessoa.codp = Venda.codp and
venda.coda in
(select coda
from Automovel, Fabricante
where Automovel.codf = Fabricante.codf
and Fabricante.Nomef = ‘Ford’)
Outra resposta:
select Pessoa.NomeP
from Pessoa, venda, Automovel, Fabricante
where Pessoa.codp = Venda.codp and
venda.coda = Automovel.coda and
Automovel.codf = Fabricante.codf and
Fabricante.Nomef = ‘Ford’

8. Quem não comprou ‘Ford’?

select Pessoa.NomeP
from Pessoa, venda
where Pessoa.codp = Venda.codp and
venda.coda not in
(select coda
from Automovel, Fabricante
where Automovel.codf = Fabricante.codf and
Fabricante.Nomef = ‘Ford’)

9. Quem comprou carro com ágio?

select Pessoa.NomeP
from Pessoa, venda, Automovel
where Pessoa.codp = Venda.codp and
venda.coda = Automovel.coda and
venda.valor > Automovel.preço

10. Quem comprou ‘Ford’ e não comprou ‘Volks’?

select Pessoa.NomeP
from Pessoa, venda
where Pessoa.codp = Venda.codp

and venda.coda in

(select coda
from Automovel, Fabricante
where Automovel.codf = Fabricante.codf
and Fabricante.Nomef = ‘Ford’)

and venda.coda not in

(select coda
from Automovel, Fabricante
where Automovel.codf = Fabricante.codf
and Fabricante.Nomef = ‘Volks’)

Bancos de Dados 40 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
11. Quem comprou carro entre 01/01/97 e 01/01/98?
select Pessoa.NomeP
from Pessoa, venda
where Pessoa.codp = Venda.codp and
venda.data between ‘01/01/97’ and ‘01/01/98’

Considere o esquema BANCO, reproduzido abaixo.

Agencias = (agencia_cod, agencia_nome, agencia_cidade, ativos)
Clientes = (cliente_cod, cliente_nome, rua, cidade)
Depositos = (agencia_cod, conta_numero, cliente_cod, saldo)
Emprestimos = (agencia_cod, cliente_cod, emprestimo_numero, quantia)

12. Selecione todos os clientes que possuem contas em agencia(s) que possui(m) o maior
ativo.
Select cliente_nome
from clientes, depositos
where clientes.cliente_cod = depositos.cliente_cod and
depositos.agencia_cod in
(select agencia_cod
from agencias
where ativos >= all
(select ativos
from agencias)

13. Selecione o total de agencias por cidade, classificado por cidade.

Select cidade, count(agencia_cod) as total_agencias
from agencias
group by cidade
order by cidade

14. Selecione, por agências, o(s) cliente(s) com o maior saldo.

Select agencia_nome, cliente_nome, saldo
from clientes, depositos, agencias
where clientes.cliente_cod = depositos.cliente_cod and
depositos.agencia_cod = agencia.agencia_cod and
<agencia_cod, saldo> in
(Select agencia_cod, max(saldo) as maior_saldo
from depositos
group by agencia_cod)

15. Selecione o valor médio de empréstimos efetuados por cada agência em ordem crescente
das cidades onde estas agências se situam.
Select agencia_nome, avg(quantia) as valor_medio
from emprestimos, agencias
where emprestimos.agencia_cod = agencias.agencia_cod
group by agencia_nome
order by cidade

16. Selecione a(s) agência(s) que possui(m) a maior média de quantia emprestada.
Select agencia_nome
from agencias, emprestimos
where emprestimos.agencia_cod = agencias.agencia_cod
group by agencia_nome
having agv(quantia) >= all
(select avg(quantia)
from emprestimos
group by agencia_cod)

Bancos de Dados 41 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
17. Selecione todas as agências situadas fora de Vitória que possuem a média de depósitos
maior do que alguma agência localizada em Vitória.
Select agencia_nome
from agencias, depositos
where depositos.agencia_cod = agencias.agencia_cod and
agencia.cidade <> ‘Vitória’
group by agencia_nome
having agv(saldo) > some
(select avg(saldo)
from depositos, empresas
where depositos.codEmpresa = empresas.codEmpresa and
empresas.cidade=‘Vitória’
group by agencia_cod)

18. Selecione o menor saldo de clientes, por agências.

Select agencia_nome, min(saldo) as menor_saldo
from depositos, agencias
where depositos.agencia_cod = agencias.agencia_cod
group by agencia_cod

19. Selecione o saldo de cada cliente, caso ele possua mais de uma conta no banco.
Select cliente_nome, sum(saldo)
from clientes, depositos
where clientes.cliente_cod = depositos.cliente_cod
group by cliente_nome
having count(agencia_cod) >1

Considere o esquema abaixo para as questões que se seguem

Pessoas = (CodPessoa, NomePessoa, Cidade, Chefe)
Empresas = (codEmpresa, NomeEmpresa, Cidade)
Trabalha = (CodPessoa, CodEmpresa, Salario)

20. Excluir todas as pessoas que possuem salario = 1000.

Delete pessoas where CodPessoa in
(select cod_pessoa from trabalha where salario = 1000)

21. Excluir todas as pessoas que trabalham em empresas situadas em Vitória.

Delete pessoas where CodPessoa in
(select cod_pessoa from trabalha, Empresas
where trabalha.CodEmpresa=Empresas.CodEmpresa and cidade=‘Vitoria’)

22. Incluir na empresa de código ‘01’ todos os moradores de Vitória com um salário=100.
Insert into trabalha (codPessoa, codEmpresa, Salario)
Select codpessoa, ‘01’, 100 from pessoas where cidade = ‘Vitória’

23. Uma determinada empresa de código ‘x’ vai contratar todos os funcionários da empresa
de código ‘y’ que ganham acima de 1000, dando um aumento de salário de 10%. Faça
comando(s) SQL para que tal transação seja efetuada.
Insert into trabalha (codPessoa, codEmpresa, Salario)
Select codpessoa, ‘x’, salario*1.1
from trabalha
where codempresa=‘y’ and salario >1000

Delete trabalha where codempresa = ‘y’ and salario >1000

Bancos de Dados 42 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
24. Uma determinada empresa de código ‘xyz’ quer contratar todos que moram em Vitória e
estão desempregados. Serão contratados com salário = 200. Faça comando(s) SQL para
fazer tal transação.
Insert into trabalha (codPessoa, codEmpresa, Salario)
Select codp, ‘xyx’, 200
from pessoas
where cidade = ‘Vitória’ and codpessoa
not in (select codpessoa from trabalha)

25. Fazer um comando SQL para ajustar o salário de todos os funcionários da empresa
‘Campana’ em 5%.
Update trabalha
Set salario = salario * 1.05
Where codEmpresa in
(select codEmpresa
from empresas
where nomeEmpresa = ‘Campana’)

26. Todas as pessoas que moram em Colatina e trabalham na empresa ‘Campana’ deverão
mudar para Vitória, devido aos requisitos do diretor da empresa. Faça comando(s) SQL
para fazer esta atualização da cidade.
Update Pessoas
Set cidade = ‘Vitória’
Where codPessoa in
(select codPessoa
from Pessoas, Trabalha, empresas
where Pessoas.codPessoa = Trabalha.CodPessoa and
Pessoas.cidade = ‘Colatina’ and
Trabalha.CodEmpresa = Empresas.codEmpresa and
nomeEmpresa = ‘Campana’)

Bancos de Dados 43 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
3.13 O ESQUEMA BANCO
AGENCIA = (agencia_cod, agencia_nome, agencia_cidade, ativos)
CLIENTE = (cliente_cod, cliente_nome, rua, cidade)
CONTA = (agencia_cod, conta_numero, cliente_cod, saldo)
EMPRESTIMO = (agencia_cod, cliente_cod, emprestimo_numero, quantia)

De uma forma visual:

AGENCIA
agencia_cidade agencia_nome agencia_cod ativos

CONTA
cliente_cod agencia_cod conta_numero saldo

EMPRESTIMO
cliente_cod, emprestimo_numero quantia agencia_cod

CLIENTE
cliente_cod cliente_nome rua cidade

Bancos de Dados 44 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]
3.14 O ESQUEMA EMPRESA

Tabela EMPREGADO

Nome RG CPF Depto RG Supervisor Salario

João Luiz 10101010 11111111 1 NULO 3.000,00

Fernando 20202020 22222222 2 10101010 2.500,00

Ricardo 30303030 33333333 2 10101010 2.300,00

Jorge 40404040 44444444 2 20202020 4.200,00

Renato 50505050 55555555 3 20202020 1.300,00

Tabela DEPARTAMENTO Tabela PROJETO

Nome Numero RG Gerente Nome Numero Localizacao

Contabilidade 1 10101010 Financeiro 1 5 São Paulo

Engenharia Civil 2 30303030 Motor 3 10 Rio Claro

Engenharia 3 20202020 Prédio Central 20 Campinas

Mecânica

Tabela DEPENDENTES

RG Nome Nascimento Relacao Sexo

Responsavel Dependente

10101010 Jorge 27/12/86 Filho Masculino

10101010 Luiz 18/11/79 Filho Masculino

20202020 Fernanda 14/02/69 Cônjuge Feminino

20202020 Ângelo 10/02/95 Filho Masculino

30303030 Adreia 01/05/90 Filho Feminino

Tabela DEPARTAMENTO_PROJETO Tabela EMPREGADO_PROJETO

Numero Depto. Numero Projeto RGEmpregado Numero Projeto Horas

2 5 20202020 5 10

3 10 20202020 10 25

2 20 30303030 5 35

40404040 20 50

50505050 20 35

Bancos de Dados 45 Francisco Rapchan

www.geocities.com/chicorapchan [email protected]