Apostila 2 de Banco de Dados - SQL

Profª. Alessandra Cini

LINGUAGENS DE
CONSULTA .......................................................................................................................
............... 2 LINGUAGENS COMERCIAIS
–
LINGUAGEM SQL .................................................................................................. 2
I
NTRODUÇÃO
............................................................................................................................................
......................... 2 PARTE

C
OMANDOS DA
L
INGUAGEM
DDL/SQL ........................................................................................................... 2
Comando CREATE DATABASE
................................................................................................................................ 2
Comando CREATE TABLE
......................................................................................................................................... 3
Comando CREATE INDEX
......................................................................................................................................... 5
Comando DROP INDEX
............................................................................................................................................
.. 5
Comando DROP TABLE
............................................................................................................................................
.6
Comando ALTER TABLE
...........................................................................................................................................
6
P
ARTE
II

C
OMANDOS DA
L
INGUAGEM
DML/SQL ........................................................................................................... 9
Comando SELECT
............................................................................................................................................
........... 9
Inserções, Alterações e Exclusões
.............................................................................................................................. 16
Visões
............................................................................................................................................
............................. 17
CENTRO TECNOLÓGICO UNIVERSIDADE DE CAXIAS DO SUL

CETEC
CAXIAS DO SUL

Linguagens de Consulta
Uma linguagem de consulta é uma linguagem na qual um usuário requisita informações
do banco de dados. Estas linguagens são tipicamente de mais alto nível do que as
linguagens de programação padrão. A álgebra relacional é uma linguagem de consulta
procedural
. Ela consiste de um conjunto de operações que tornam uma ou duas relações como
entrada e produzem uma nova relação como resultado.

Linguagens Comerciais
–
Linguagem SQL

Introdução
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. 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. 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.

PARTE I - Comandos da Linguagem DDL/SQL

Comando CREATE DATABASE

Este comando permite a criação do banco de dados. Sintaxe: CREATE DATABASE <
nome_db >; onde: nome_db: indica o nome do Banco de Dados a ser criado. OBS: O
comando CREATE DATABASE não está disponível no SGBD Access.
3

Comando CREATE TABLE

Sintaxe (igual no Access e Oracle): CREATE TABLE < nome_tabela > (<
nome_atributo1 > < tipo > [ NOT NULL ], < nome_atributo2 > < tipo > [ NOT
NULL ], ...... < nome_atributoN > < tipo > [ NOT NULL ] ) ; onde:
nome_tabela: indica o nome da tabela a ser criada. nome_atributo: indica o nome do
campo a ser criado na tabela. tipo: indica a definição do tipo de dados do
atributo.
Tipos de dados:
Tipos de dados do banco de dados Access: Tipo de dado no SQL Tipo de dado no
modo interativo do Access Access v. 97 Access v. 2000 Binary Text( ) Text ( )
Texto Longtext Longtext Memorando Byte Byte
1
Byte Short Short ou Smallint Inteiro Long Inteiro Longo Single Single ou Real
Simples Double Double ou Float Duplo Datetime Datetime Data/Hora Currency
Currency ou Money Moeda Counter Counter Autonumeração Bit Bit Sim/Não
Longbinary Image Objeto OLE Decimal
2
Character
3

1
Era para ser Tinyint, mas não funciona.
2
É um real, com uma precisão de 18 casas decimais, mas não funciona.
3
É alfanumérico que aceita até 255 caracteres, mas não funciona.
Binary

–
Qualquer tipo de dados pode ser armazenado em um campo deste tipo. Não é feita
nenhuma conversão dos dados. O modo como os dados são inseridos em um campo
binário dita o modo como eles aparecerão como saída. Ocupa 1 byte por caracter.
Texto
- Texto ou combinações de textos e números, como endereços. Até 255 caracteres.
Memorando - Textos e números muito extensos, como anotações ou descrições. Ocupa
até 64.000 caracteres.
Número
- Dados numéricos a serem utilizados em cálculos matemáticos, exceto cálculos
envolvendo dinheiro (utilize o tipo Moeda). Configure a propriedade
TamanhoDoCampo para definir o tipo de Número específico. Ocupa 1, 2, 4 ou 8 bytes.
Data/Hora
 - Ocupa 8 bytes.
Moeda
- Precisão de 15 dígitos à esquerda do ponto decimal e quatro dígitos à direita. 8 bytes.
AutoNumeração
- Números seqüenciais inseridos automaticamente quando um registro é adicionado.
Ocupa 4 bytes. No SQL do Access 2000, o
counter
pode ser usado com os
4

parâmetros semente e incremento. Ex: counter (50,2) onde a semente (valor inicial) do
campo é 50 e o incremento é 2.
Tamanhos de Números:
Byte
- Armazena números inteiros de 0 a 255, ocupa 1 byte.
Inteiro
- Armazena números inteiros de
–
32.768 a 32.767, ocupa 2 bytes.
Inteiro Longo
(Padrão) - Armazena números inteiros de -2.147.483.648 a 2.147.483.647. Ocupa 4
bytes
Simples
- Armazena números reais de
–
3,402823E38 a
–
1,401298E
–
45 para valores negativos e de 1,401298E
–
45 a 3,402823E38 para valores positivos. Tem uma precisão de 7 casas decimais e
ocupa 4 bytes.
Duplo
- Armazena números reais de
–
1,79769313486231E308 a
–
4,94065645841247E
–
324 para valores negativos e de 1,79769313486231E308 a 4,94065645841247E
–
324 para valores positivos. Tem uma precisão de 15 casas decimais e ocupa 8 bytes.
Tipos de dados do Oracle:
Char( ) - Alfanumérico de até 255 caracteres. Os espaços não utilizados ocupam
memória. Varchar2( ) - Alfanumérico de até 2000 caracteres. Os espaços não
utilizados não ocupam memória. Number( ) - Numérico Date - Data OBS: A opção
NOT NULL somente está disponível no SGBD Access a partir da versão 97. Também
existe no Oracle. A definição da chave primária da tabela pode ser definida na última
linha do comando CREATE TABLE da seguinte forma: Sintaxe (igual no Access e
Oracle): Constraint < nome_chave_primária > primary key (< nome_atributo(s) >)
onde: <nome_chave_primária>: indica um nome qualquer usado para identificar a
chave primária. <nome_atributo(s)>: indica o nome do(s) atributo(s) que compõe a
chave. Se mais de um atributo for usado para compor a chave, estes devem ser
colocados separados por vírgula. Exemplo: CREATE TABLE PRODUTOS (códprod
short, descr text(40) not null, um text(2), preçovenda currency, constraint
pk_produtos primary key (códprod)) Também é possível criar uma chave única,
definindo-a com o tipo
unique
, da mesma forma como a definição da chave primária. Complementando o exemplo
acima: Exemplo: CREATE TABLE PRODUTOS (códprod short, descr text(40) not
null,
5

um text(2), preçovenda currency, constraint pk_produtos primary key (códprod),

constraint un_descr_produtos unique (descr))
Índices

Um
índice
é uma estrutura que permite a recuperação de linhas de uma tabela mais rapidamente.
Isto significa que quando um campo da tabela possui um índice, quando buscarmos
informações na tabela pelo campo indexado, o retorno será bem mais rápido.

Comando CREATE INDEX

O comando
create index
é usado para criar um índice. Sintaxe (igual no Access e Oracle): CREATE INDEX <
nome_índice > ON < nome_tabela > (< nome_campo > < ordenação >) onde:
nome_índice: indica um nome qualquer para fazer referência ao índice. nome_tabela:
indica o nome da tabela que contém o campo que se deseja indexar. nome_campo:
nome do(s) campo(s) que se deseja indexar. ordenação: indica a ordem de classificação
pelo campo que estamos definindo como índice, ascendente ou descendente (ASC ou
DESC). Exemplo: CREATE INDEX buscadescr ON PRODUTOS (descr ASC) No
exemplo acima está sendo criado um índice para o campo Descr da tabela Produtos. O
nome do índice é buscadescr e poderia ser qualquer outro. A opção ASC indica que
queremos indexar de maneira ascendente, de outro modo, se usarmos a opção DESC a
indexação será de forma descendente.
Comando DROP INDEX
A remoção de um índice é feita com o comando
drop index
. Sintaxe (Access): DROP INDEX < nome_índice > ON < nome_tabela > onde:
nome_índice: indica o nome do índice existente. nome_tabela: indica o nome da tabela
que contém o índice. Exemplo: DROP INDEX buscadescr ON PRODUTOS Sintaxe
(Oracle): DROP INDEX < nome_índice > onde: nome_índice: indica o nome do
índice existente.
6

Exemplo: DROP INDEX buscadescr

Comando DROP TABLE
O comando
drop table
é usado para remover uma tabela e todos os seus dados do banco de dados. Sintaxe
(igual no Access e Oracle): DROP TABLE < nome_tabela > ; Exemplo: DROP
TABLE Produtos OBS: Para que uma tabela que possui relacionamentos possa ser
removida, devemos primeiramente remover todos os seus relacionamentos.
Comando ALTER TABLE
O comando
alter table
é utilizado para mudar algum item da estrutura da tabela. Podemos utilizar o comando
alter table
para adicionar/eliminar colunas ou
constraints
em uma tabela.
Adição de campos na tabela:
Sintaxe do Access: ALTER TABLE < nome_tabela > add column < nome_campo > <
tipo > [ NOT NULL ] Sintaxe do Oracle: ALTER TABLE < nome_tabela > add <
nome_campo > < tipo > [ NOT NULL ] onde: nome_tabela: indica o nome da tabela
na qual será inserido o campo. nome_campo: nome do campo que se deseja incluir na
tabela. tipo: indica a definição do tipo de dados do campo. OBS: A opção NOT
NULL somente está disponível no SGBD Access a partir da versão 97. Exemplo: O
exemplo a seguir utiliza o comando
alter table
para acrescentar o campo QtdEstoque na tabela produtos. No Access: ALTER
TABLE PRODUTOS add column qtdestoque single No Oracle: ALTER TABLE
PRODUTOS add qtdestoque single
7

Remoção de campos da tabela:

Sintaxe (igual no Access e no Oracle): ALTER TABLE < nome_tabela > drop column
< nome_campo > onde: nome_tabela: indica o nome da tabela que contém o campo que
se deseja remover. nome_campo: nome do campo que se deseja remover da tabela.
Exemplo: O exemplo a seguir utiliza o comando
alter table
para remover o campo QtdEstoque da tabela produtos. ALTER TABLE PRODUTOS
drop column qtdestoque
Uso de chave estrangeira para definir relacionamentos:
Sintaxe (no Access): ALTER TABLE < nome_tabela_estrangeira > add constraint <
nome_chave > foreign key (< nome_campo_estrangeiro >) references <
nome_tabela_original > (< nome_campo_original >) Sintaxe (no Oracle): ALTER
TABLE < nome_tabela_estrangeira > add (constraint < nome_chave > foreign key (<
nome_campo_estrangeiro >) references < nome_tabela_original > (<
nome_campo_original >)) onde: nome_tabela_estrangeira: nome da tabela que contém
o campo que é estrangeiro. nome_chave: nome qualquer usado para indicar a chave.
nome_campo_estrangeiro: nome do campo que é estrangeiro. nome_tabela_original:
nome da tabela que contém o campo original. nome_campo_original: nome do campo
na tabela original. Exemplo (Access): ALTER TABLE vender add constraint
fk_vender_relation_produtos foreign key (códprod) references produtos (códprod)
Exemplo (Oracle): ALTER TABLE vender add (constraint
fk_vender_relation_produtos foreign key (códprod) references produtos (códprod)) No
exemplo acima está sendo adicionado uma constraint na tabela vender, estabelecendo
que o campo CódProd da tabela vender é uma chave estrangeira em relação ao campo
CódProd da tabela produtos, isto é, cria um relacionamento entre a tabela vender e a
tabela produtos. Obs: - fk_vender_relation_produtos é o nome da chave estrangeira,
poderia ser qualquer outro. - O nome dos campos nas duas tabelas não precisa ser igual.
8

Remoção de chave:
O comando ALTER TABLE também pode ser utilizado para eliminar uma constraint.
Sintaxe (igual no Access e Oracle): ALTER TABLE < nome_tabela > drop constraint
<nome_chave> onde: nome_tabela: indica o nome da tabela que contém a chave.
nome_chave: indica o nome da chave. Ex: ALTER TABLE vender drop constraint
fk_vender_relation_produtos No exemplo acima o comando
alter table
juntamente com o drop - que é um comando de remoção, é usado para remover a
constraint
de chave estrangeira da tabela vender, ou seja, o relacionamento entre vender e
produtos é eliminado.

Parte II - Comandos da Linguagem DML/SQL

Comando SELECT
O comando SELECT permite a consulta de dados de uma ou mais tabelas. Sintaxe
(igual no Access e Oracle): SELECT [ALL|DISTINCT|DISTINCTROW|TOP n] * |
nome_campo1, nome_campo2, ... FROM nome_tabela1, ... WHERE condição GROUP
BY nome_coluna1, ... HAVING condição ORDER BY nome_coluna1 ASC|DESC, ...
onde: SELECT: usado para indicar o(s) campo(s) que será(ão) exibido(s). O
“*” é usado para indicar
todos os campos. FROM: usado para indicar a(s) tabela(s) de onde provém os campos.
WHERE: usado para estabelecer tuplas individuais candidatas (não pode conter
funções de grupo). GROUP BY: usado para fixar grupos. HAVING: usado para
selecionar grupos para exibição. ORDER BY: usado para classificar as tuplas por um
ou mais campos, em ordem ascendente ou descendente. Obs: Todas as cláusulas após o
FROM são opcionais. Alguns analistas costumam afirmar em tom jocoso que SQL não
passa de "Selecione algo De algum lugar Onde se verificam tais relações" Exemplo:
SELECT * FROM Produtos ORDER BY Código ASC; O exemplo acima lista todos
os campos tabela Produtos em ordem crescente de Código.
Diferença entre ALL, DISTINCT, DISTINCTROW e TOP n:
ALL - Seleciona todos os campos das tabelas em questão. DISTINCT - Omite registros
que contêm dados duplicados nos campos selecionados. DISTINCTROW - Omite dados
baseado em registros duplicados completos, e não somente campos duplicados. TOP n -
Retorna um certo número de registros que caem no topo ou na base de um intervalo
especificado por uma cláusula ORDER BY. Suponha que você deseje obter os nomes
dos 25 melhores estudantes da classe de 1994: SELECT TOP 25 Nome, Sobrenome
FROM Estudantes WHERE AnoDeGraduação = 1994 ORDER BY MédiaDeNotas
DESC;
10

Operadores
Os seguintes operadores podem ser usados na cláusula WHERE: Sintaxe da cláusula
WHERE: WHERE <nome_campo> <operador> <valor> Operadores relacionais:

Operador Significado
= igual a <> diferente > maior que >= maior que ou igual
a< menor que <= menor que ou igual a Operadores lógicos:

Operador Significado Equivalente interativo

and analisa mais de uma expressão e or analisa uma das expressões ou not
negação negado not nome_coluna = diferente da coluna not nome_coluna > não
maior que is null é um valor nulo é nulo is not null não é um valor nulo
é negado nulo Demais operadores:
Operador Significado Equivalente interativo between ... and ... entre
dois valores ( inclusive ) entre ... e ... not between não entre dois valores informados
in ( .... ) pertencente a lista de valores em not in não existente numa dada
lista de valores like com um padrao de caracteres como not like
diferente do padrao de caracteres informado Operador IN: O operador IN testa se
determinado campo está na lista de valores definida a seguir, se estiver, exibe as tuplas
solicitadas na consulta. Exemplo: SELECT * FROM PEDIDOS WHERE
regiãoderemessa
In (“Sul”,”Nordeste”,”Norte”)
Quando um valor do tipo texto for usado em uma expressão, ele deve ser colocar entre
aspas. No caso de um valor do tipo data, ele deve ser colocado entre #. Valores
numéricos são colocados diretamente. Exemplo:
nome = “Solange”
Obs: No Access é indiferente usar aspas simples ou duplas.

11

data_nasc > #01/01/1980# idade >= 18

Alias
Um nome alternativo que você atribui a um campo ou expressão em uma instrução
SELECT, freqüentemente mais curto ou mais significativo. Você deve utilizar um alias
ao criar uma auto-associação (
auto-relacionamentos
) em uma instrução SQL. Quando você adiciona uma tabela ou consulta a uma consulta,
o Microsoft Access define automaticamente a propriedade Alias com o nome da tabela
ou consulta. Se uma segunda instância da mesma tabela ou consulta for adicionada, o
Microsoft Access definirá a propriedade Alias com o nome do objeto acrescido de um
sublinhado e um algarismo 1 ("_1"). Criar um alias não altera o nome da tabela ou
consulta, apenas especifica um outro nome que pode também ser utilizado para referir-
se à tabela ou consulta. Por exemplo, em uma consulta contendo uma auto-associação
que mostre funcionários e seus gerentes, você utilizaria duas cópias da tabela
Funcionários. O Microsoft Access chama automaticamente a tabela duplicada de
Funcionários_1. Para dar a essa tabela um nome mais significativo, você pode definir a
sua propriedade Alias como Gerentes. O próximo exemplo utiliza uma auto-associação
para mostrar funcionários e seus gerentes. Ele utiliza a cláusula AS para definir como
Gerentes a propriedade Alias da tabela Funcionários duplicada. Você digita a instrução
SQL a seguir no modo SQL da janela Consulta. SELECT funcionários.nome,
funcionários.sobrenome, funcionários.cargo, gerentes.nome, gerentes.sobrenome
FROM FUNCIONÁRIOS, FUNCIONÁRIOS AS GERENTES WHERE
funcionários.supervisor = gerentes.códigodofuncionário; O exemplo acima exibe nome,
sobrenome e cargo do funcionário, juntamente com o nome e o sobrenome de seu
gerente.
Cálculos com Informação Selecionada:
Em uma consulta de seleção é possível adicionar um campo que não pertença à tabela
original, ou seja, seja um campo calculado a partir de campos da tabela. Exemplo:
SELECT nome, (salário*1.1) as novo_salário FROM EMPREGADOS WHERE salário
<= 500
Funções Agregadas (ou de Agrupamento):

função retorno
avg(< nome_campo >) média ignorando nulos count(< nome_campo >) conta os
valores do campo para valores não nulos max(< nome_campo >) maior valor do campo
min(< nome_campo >) menor valor do campo sum(< nome_campo >) soma dos
valores do campo ignorando nulos Sintaxe: SELECT < função > (< nome_campo >)
FROM (< nome_tabela >) Exemplos:
12

SELECT AVG(salário) FROM EMPREGADOS; SELECT MIN(salário) FROM

EMPREGADOS; SELECT MAX(salário) FROM EMPREGADOS; SELECT
SUM(salário) FROM EMPREGADOS;
Agrupamentos:
As funções de grupo operam sobre grupos de tuplas (linhas). Retornam resultados
baseados em grupos de tuplas em vez de resultados de funções por tupla individual. A
claúsula "GROUP BY" do comando "SELECT" é utilizada para dividir tuplas em
grupos menores. A cláusula "GROUP BY" pode ser usada para dividir as tuplas de uma
tabela em grupos menores. As funções de grupo devolvem uma informação sumarizada
para cada grupo. Sintaxe: SELECT [< nome_campo(s) >], < função > (< nome_campo
>) FROM (< nome_tabela >) GROUP BY < nome_campo > Exemplo: SELECT
nomedepto, AVG(salário) FROM EMPREGADOS GROUP BY nomedepto; O
exemplo acima exibe a média dos salário de cada departamento. Obs: Qualquer coluna
ou expressão na lista de seleção, que não for uma função agregada, deverá constar da
claúsula "GROUP BY". Portanto é errado tentar impor uma "restrição" do tipo agregada
na cláusula WHERE.
Cláusula Having:
A cláusula "HAVING" pode ser utilizada para especificar quais grupos deverão ser
exibidos, portanto restringindo-os. Sintaxe: SELECT [< nome_campo(s) >], < função
> (< nome_campo >) FROM (< nome_tabela >) GROUP BY < nome_campo >
HAVING < expressão >
13

Exemplo: SELECT nomedepto, AVG(salário) FROM EMPREGADOS GROUP BY

nomedepto HAVING COUNT(*) > 3; O exemplo acima exibe a média dos salários
dos departamentos com mais de 10 empregados. Obs: - A claúsula "group by" deve ser
colocada antes da "having", pois os grupos são formados e as funções de grupos são
calculadas antes de se resolver a cláusula "having". - A cláusula "where" não pode ser
utilizada para restringir grupos que deverão ser exibidos. Exemplificando ERRO típico
- Restringindo Média Maior que 1000: SELECT nomedepto, AVG(salário) FROM
EMPREGADOS WHERE AVG(salário) > 1000 GROUP BY nomedepto; ( Esta
seleção está ERRADA! ) SELECT nomedepto, AVG(salário) FROM EMPREGADOS
GROUP BY nomedepto HAVING AVG(salário) > 1000; ( Seleção Adequada )
Sub-Consultas
Uma sub-consulta é um comando "select" que é aninhado dentro de outro "select" e que
devolve resultados intermediários. Exemplo 1: SELECT Nome, Cargo FROM
Empregados A WHERE 300000 IN (SELECT Orçamento FROM Departamentos
WHERE Departamentos.NumDepto = A.NumDepto); O exemplo acima exibe o nome
dos empregados e seus respectivos cargos, desde que o orçamento do departamento seja
igual a 300000. Nota: Observe que a cláusula IN torna-se verdadeira quando o atributo
indicado está presente no conjunto obtido através da subconsulta. Exemplo 2: SELECT
NomeDepto FROM Departamentos A WHERE EXISTS (SELECT *
FROM Empregados WHERE salário > 3500 AND
Empregados.NumDepto = A.NumDepto); O exemplo acima exibe todos os
departamentos que possuem empregados com remuneração maior que 3500.
14

Nota: Observe que a cláusula EXISTS indica se o resultado de uma pesquisa contém ou
não tuplas. Observe também que poderemos verificar a não existência (NOT EXISTS)
caso esta alternativa seja mais conveniente.
Recuperando Dados de Várias Tabelas (JOINS)
Quando é preciso recuperar dados de mais de uma tabela, em geral, precisamos realizar
uma junção (JOIN) entre as tabelas, a fim de extrair as informações necessárias para a
consulta formulada.
INNER JOIN
Combina registros de duas tabelas sempre que houver valores correspondentes em um
campo comum. Sintaxe: FROM tabela1 INNER JOIN tabela2 ON tabela1.campo1
opercomp tabela2.campo2 Você pode usar uma operação INNER JOIN em qualquer
cláusula FROM. Este é o tipo mais comum de associação. As associações internas
combinam registros de duas tabelas sempre que houver valores correspondentes em um
campo comum a ambas. Ex: SELECT NomeDaCategoria, NomeDoProduto FROM
Categorias INNER JOIN Produtos ON Categorias.CódigoDaCategoria =
Produtos.CódigoDaCategoria;
LEFT JOIN OU RIGHT JOIN
FROM tabela1 [ LEFT | RIGHT ] JOIN tabela2 ON tabela1.campo1 opercomp
tabela2.campo2 Utilize uma operação LEFT JOIN para criar uma associação externa
esquerda. As associações externas esquerdas incluem todos os registros da primeira
(esquerda) de duas tabelas, mesmo que não haja valores correspondentes para os
registros na segunda tabela (direita). Utilize uma operação RIGHT JOIN para criar uma
associação externa direita. As associações externas direitas incluem todos os registros
da segunda (direita) de duas tabelas, mesmo que não haja valores correspondentes para
registros na primeira (esquerda) tabela. Por exemplo, você poderia usar LEFT JOIN
com as tabelas Departamentos (esquerda) e Funcionários (direita) para selecionar todos
os departamentos, inclusive os que não tenham funcionários designados para eles. Para
selecionar todos os funcionários, inclusive os que não estão designados para um
departamento, você usaria RIGHT JOIN. O exemplo a seguir mostra como você poderia
associar as tabelas Categorias e Produtos no campo CódigoDaCategoria. A consulta
produz uma lista de todas as categorias, inclusive aquelas que não contêm produtos:
SELECT NomeDaCategoria, NomeDoProduto FROM Categorias LEFT JOIN Produtos
ON Categorias.CódigoDaCategoria = Produtos.CódigoDaCategoria;

15

Operações de Conjuntos (UNION, INTERSECT, EXCEPT):

Os operadores UNION, INTERSECT e EXCEPT operam relações e correspondem às
relações de união, intersecção e diferença da álgebra. Assim como na álgebra, as
relações participantes das relações precisam ser compatíveis, isto é, elas precisam ter o
mesmo conjuntos de atributos.
Operação UNION
Podemos eventualmente unir as tuplas de duas tabelas ou consultas simplesmente
utilizando a palavra reservada UNION. A operação UNION não exibe tuplas
duplicadas. Exemplo: (Select * From Alfa3 Where idade > 16) UNION (Select *
From Beta3 Where idade > 16); O exemplo acima exibe todos os dados dos alunos
que tem mais de 16 anos das turmas alfa3 e beta3. Se desejarmos exibir todas as tuplas,
mesmo as repetidas, precisamos usar a operação UNION ALL.
Operação UNION ALL
Exemplo: (Select * From Alfa3 Where idade > 16) UNION (Select * From
Beta3 Where idade > 16); ** As operações a seguir (intersect, intersect all, except e
except all) não estão disponíveis no SGBD Access.
Operação INTERSECT
Para exibir as tuplas que são comuns a duas tabelas ou consultas precisamos utilizar a
palavra reservada INTERSECT. A operação INTERSECT automaticamente elimina
todas as repetições. Exemplo: (Select nome From Basquete) INTERSECT (Select
nome From Futebol); O exemplo acima exibe o nome dos alunos que participam
tanto da escolinha de Basquete quanto da de Futebol.
16

Se desejarmos exibir todas as tuplas, mesmo as repetidas, precisamos usar a operação

INTERSECT ALL.
Operação INTERSECT
Exemplo: (Select nome From Basquete) INTERSECT ALL (Select nome From
Futebol);
Operação EXCEPT
Para exibir todas as tuplas que estejam em uma tabela ou consulta e não estejam em
outra. A operação EXCEPT automaticamente elimina todas as repetições. Exemplo:
(Select nome From Gama3) EXCEPT (Select nome From Futebol); O exemplo
acima exibe o nome dos alunos da turma Gama3 que não estejam na escolinha de
Futebol. Se quisermos manter as tuplas repetidas devemos utilizar a operação EXCEPT
ALL.
Operação EXCEPT ALL
Exemplo: (Select nome From Gama3) EXCEPT ALL (Select nome From
Futebol);
Inserções, Alterações e Exclusões
Comando INSERT
Sintaxe: INSERT INTO <tabela> [<campos>] [VALUES <valores>] Exemplos:
INSERT INTO Departamento; Possibilita a inserção de registros de forma
interativa. INSERT INTO
Departamento (NumDepto, NomeDepto, LocalDepto) VALUES (70,"Produção","Rio
de Janeiro");
Possibilita a inserção de registros em tabelas sem digitação dos dados.
17

Comando UPDATE
Sintaxe: UPDATE <tabela> SET <campo> = <expressão> [WHERE <condição>];
Exemplo: UPDATE Empregados SET salário = salário * 1.2 WHERE salário < 1000;
Comando DELETE
Sintaxe: DELETE FROM <tabela> [WHERE <condição>]; Exemplo: DELETE
FROM Empregados WHERE salário > 5000;

Visões
As tabelas criadas em um banco de dados relacional existem fisicamente no sistema
computacional. Se desejarmos criar tabelas que não ocupem espaço físico, mas que
possam ser utilizadas como tabelas normais, devemos criar visões (VIEWS) que são
tabelas virtuais. OBS: O SGBD Access não dispõe do recurso de criação de visões.
Sintaxe: CREATE VIEW < nome_da_VIEW > (< nome_campo(s) >) AS SELECT <
nome_campo(s) > FROM < nome_tabela > WHERE < expressão_condição >; As
visões são utilizadas para se ter uma visão particular de uma ou mais tabelas, para que
não seja necessária a utilização do conjunto como um todo. Devemos observar que: 1-
Uma visão definida sobre uma única tabela somente será atualizável se os atributos da
tal visão contiverem a chave primária de tal tabela. 2- Visões sobre várias tabelas não
são passíveis de atualizações. 3- Visões que se utilizam de funções de agrupamentos,
também não poderão ser atualizadas.