Algebra Relacional

Prévia do material em texto

Bases de DadosBases de Dados
Álgebra RelacionalÁlgebra Relacional
ouou
Como manipular uma BD SQL Como manipular uma BD SQL 
P. Serendero, 2011-13P. Serendero, 2011-13
11
22
Álgebra Relacional
“Conjunto básico de operadores que tomam as relações como os seus 
operandos e devolvem uma relação como resultado” (Date) 
O output das operações com tabelas é sempre outra tabela, que pela 
sua vez pode servir de input para outras operações nelas
Esta é a propriedade de fecho (“closure”) dos sistemas relacionais.
Operações sobre uma, duas ou mais relações, frequentemente 
especificadas com alguma restrição, para obter uma nova relação
Esta propriedade faz o álgebra 'fechada': todos os objetos na álgebra 
relacional são relações. Não confundir com “fecho” nas DF
33
Álgebra Relacional
SQL (Structured Query Language) linguagem para criar, modificar e extrair 
dados desde um sistema relacional de gestão de bases de dados. Ela 
implementa a álgebra relacional. 
 NÃO É UMA LINGUAGEM DE PROGRAMAÇÃO!!
A estrutura básica duma expressão SQL consiste de 3 cláusulas:
SELECT: que corresponde a operação de projeção na álgebra relacional. 
Uma restrição para extrair colunas específicas de uma tabela num query
FROM: Corresponde a operação do produto cartesiano na álgebra 
relacional. Faz a listagem das relações exploradas na avaliação duma 
expressão
WHERE: Corresponde ao predicado de seleção da álgebra relacional. 
Consiste num predicado incluindo atributos das relações que aparecem na 
cláusula FROM. Actúa como um filtro
44
Álgebra Relacional: operadores
Operadores Unários
SELECT ( σ ) RESTRIÇÃO: selecciona um subconjunto de tuplas 
PROJECT( pi) PROJEÇÃO: selecciona apenas colunas na projeção
JOIN (theta) selecciona tuplas de conjuntos.Semelhante ao Prod.Cart.
DIVIDE 
Operadores sobre conjuntos (ligeiramente modificados para operar tabelas)
UNIÃO ( ∪ ), INTERSECÇÃO ( ∩ ), DIFERENCIA (ou MENOS, – )
PRODUTO CARTESIANO ( x )
Operadores Binários
JOIN (INNER JOIN, OUTER JOIN), … REUNIÃO, DIVISÃO
mais
RENAME (símbolo: ρ (ro))
FUNÇÕES AGREGADAS SUM, COUNT, AVG, MIN, MAX, …
8 operadores
originais de Codd
Algebra Relacional - Operadores
Estos 8 operadores originais tem sido estendidos a muitos outros
Qualquer outro operador pode ser definido para satisfazer a 
propriedade de fecho da AR.: relações como input e output
Estes operadores são genéricos: se aplicam a todas as relações
Todos eles são “read-only”. Eles leem mas não atualizam os seus 
operandos. 
 Cliente join Factura where tipo-cliente = “bom”
O tipo de dados do atributo “tipo-cliente” deve ser conhecido pelo 
sistema. O output produzido deve ser de um tipo bem definido com 
um nome de atributo bem definido. Neste contexto utilizamos o 
operador RENAME
Álgebra Relacional - Operadores
Uma propriedade muito importante desta álgebra ser fechada,
Significa que podemos escrever expressões relacionais aninhadas
Isto é, expressões relacionais nas quais os operandos são eles 
próprios representados por outras expressões relacionais de 
complexidade arbitrária
77
Álgebra Relacional
● RestriçãoRestrição ● Extrai tuplos especificadas duma dada relaçãoExtrai tuplos especificadas duma dada relação
● ProjeçãoProjeção ● Extrair os atributos especificados numa relação Extrair os atributos especificados numa relação 
dadadada
● ProduçãoProdução ● Dadas 2 relações, constrói uma R contendo todas as Dadas 2 relações, constrói uma R contendo todas as 
combinações possíveis de tuplos, uma de cada uma das combinações possíveis de tuplos, uma de cada uma das 
relações originaisrelações originais
● UniãoUnião ● Constrói uma relação formada por todas as tuplos que Constrói uma relação formada por todas as tuplos que 
aparecem em qualquer das duas relações especificadasaparecem em qualquer das duas relações especificadas
● IntersecçãoIntersecção ● Constrói uma relação formada apenas pelas tuplos que Constrói uma relação formada apenas pelas tuplos que 
aparecerem nas duas relações aparecerem nas duas relações 
● DiferenciaDiferencia ● Constrói uma relação formada por todas as tuplos da 1ª R Constrói uma relação formada por todas as tuplos da 1ª R 
que não aparecem na 2ª relaçãoque não aparecem na 2ª relação
● ReuniãoReunião ● Dadas 2 relações constrói uma r com todas as Dadas 2 relações constrói uma r com todas as 
combinações possíveis de tuplos, uma de cada relação, tal combinações possíveis de tuplos, uma de cada relação, tal 
que os dois tuplos participantes satisfazerem alguma que os dois tuplos participantes satisfazerem alguma 
condição especificadacondição especificada
● DivisãoDivisão ● Dada uma R1 binária e uma R2 unária, constrói uma R Dada uma R1 binária e uma R2 unária, constrói uma R 
formada por todos os valores dum atributo da R1 que formada por todos os valores dum atributo da R1 que 
concordam no outro atributo com todos os valores da R2concordam no outro atributo com todos os valores da R2
88
restrição projeção
aa
bb
cc
aa xx
aa yy
bb xx
bb yy
cc xx
cc yy
xx
yy
produto (cartesiano)
união intersecção diferencia
a1
a2
a3
b1
b1
b2
b1
b2
b3
c1
c2
c3
a1
a2
a3
b1
b1
b2
c1
c1
c2
Reunião (natural)
a
a
a
b
c
x
z
ax
y
z
x
y
divisão
Panorama geral dos 8 operadores originais (Date)
Operadores unários: SELECT
A operação SELECT (sigma A operação SELECT (sigma σσ ) seleciona um subconjunto de tuplos ) seleciona um subconjunto de tuplos 
baseado numa condição de seleçãobaseado numa condição de seleção
Esta restrição está representada na cláusula WHERE, que actua Esta restrição está representada na cláusula WHERE, que actua 
como filtrocomo filtro
Só guarda as tuplos que satisfazem a condição de qualificaçãoSó guarda as tuplos que satisfazem a condição de qualificação
SELECTSELECT * FROM embarcação* FROM embarcação WHEREWHERE matricula = ‘VNC-34’matricula = ‘VNC-34’
SELECTSELECT nome FROM embarcaçãonome FROM embarcação WHEREWHERE boca > 2 AND boca < 3boca > 2 AND boca < 3
99
Operadores unários: SELECT
Atenção: Atenção: 
SelectSelect na Álgebra relacional corresponde aona Álgebra relacional corresponde ao WHEREWHERE no SQLno SQL
projeçãoprojeção na Álgebra relacional corresponde aona Álgebra relacional corresponde ao SELECTSELECT no SQLno SQL
SELECT nome FROM embarcação SELECT nome FROM embarcação WHEREWHERE matricula= ‘AVG-175’ matricula= ‘AVG-175’
O SGBD procede assim:O SGBD procede assim:
1.1. Vai ler desde o FROM, ou seja ler a tabela embarcação, Vai ler desde o FROM, ou seja ler a tabela embarcação, 
2.2. Aplica o operador Aplica o operador σσ para o WHERE . Esta é a para o WHERE . Esta é a selecçãoselecção na álgebra na álgebra 
relacionalrelacional
3.3. Logo aplica o operador Logo aplica o operador pipi no SELECT. Esta é a no SELECT. Esta é a projeção projeção na A.R.na A.R.
1010
Operadores unários: SELECT
Em SQL a operação SELECT é muito poderosa:Em SQL a operação SELECT é muito poderosa:
SELECTSELECT produto, preço * quantidade FROM itensproduto, preço * quantidade FROM itens
 (preço e quantidade devem ser de tipo numérico)(preço e quantidade devem ser de tipo numérico)
SELECT random()SELECT random()
SELECT 2 * 2.141516SELECT 2 * 2.141516
SELECT COUNT(*) FROM Facturas; SELECT COUNT(*) FROM Facturas; 
1111
COUNT
 259
Operadores unários: SELECT
Um select com uma função na linguagem php em acçãoUm select com uma função na linguagem php em acção::
//---------------------------------------------------------------------------//---------------------------------------------------------------------------
function verifica_existencia_utilizador($db, $novo_usuario)function verifica_existencia_utilizador($db,$novo_usuario)
{ { 
 $query =$query = "SELECT * FROM utilizador WHERE usuario = '$novo_usuario' ";"SELECT * FROM utilizador WHERE usuario = '$novo_usuario' "; 
 $resultado = pg_query($db, $query);$resultado = pg_query($db, $query);
 $r = pg_fetch_array($resultado);$r = pg_fetch_array($resultado);
 
 if ($r['usuario'] == $novo_usuario) // ou if ($r) if ($r['usuario'] == $novo_usuario) // ou if ($r) 
 return 1; // else return 0;return 1; // else return 0;
} } 
//------------------------------------------------------------------------//------------------------------------------------------------------------
 // definir uma variável em Php: $nome-var = 45; or $nome-var = ‘natacha’;// definir uma variável em Php: $nome-var = 45; or $nome-var = ‘natacha’;
1212
Operadores unários: SELECT
 Repare que este SELECT se expressa assim na 
álgebra relacional:)
 σ usuario = novo-usuario (utilizador)
 σ salario > 30,000 (EMPREGADO)
O símbolo sigma (σ) expressa a operação SELECT
Uma operação condicional booleana nos atributos 
da Relação: verdadeiro ou falso 
tuplos verdadeiros são selecionadas e aparecem 
na nova relação. tuplos falsos são filtrados e 
eliminados
1313
Operadores unários: SELECT
 A operação SELECT produz uma R com o mesmo esquema (a 
mesma estrutura de atributos e os seus tipos) que a R original 
O número de tuplos como resultado do SELECT é menor ou 
igual ao número de tuplos na R original
Pode-se indicar uma condição ou várias juntas
 σ <condition1>(σ < condition2> (R)) = 
 σ <condition2> (σ < condition1> (R))
 O SELECT é comutativo, as condições podem aparecer em 
qualquer ordem. As condições podem ser outros SELECT
1414
Expressões no SELECT
No SELECT podem-se utilizar expressões como elementos 
Ex.
 SELECT nome, hora/60 AS ‘segundos’ FROM corredor;
A condição WHERE pode fazer comparações aproximadas 
entre uma string e um padrão
 <atributo> LIKE <padrão>
 <atributo> NOT LIKE <padrão>
padrão: uma string onde % significa “0 ou + caracteres iguais” 
e onde – significa apenas 1 char
1515
Expressões no SELECT: LIKE
SELECT nome FROM embarcações WHERE nome LIKE SELECT nome FROM embarcações WHERE nome LIKE 
%azul%%azul%
 Nome
Gaivota azul
O azul da Ria
1616
SELECT e clausula FROM
A clausula FROM permite mais que uma tabela na sua lista
nome cidade
L.Martins Olhão
M. Soares Faro
P.Mendes Loulé
nome salário
L.Martins 22.000
M. Soares 33.000
P.Mendes 45.000
SELECT r1.nome, salário, cidade FROM r1 , r2 
WHERE r1. nome = r2. nome (repare a qualificação do atrib.)
r1 r2
nome salário cidade
L.Martins 22.000 Olhão
M. Soares 33.000 Faro
P.Mendes 45.000 Loulé
1717
Operadores unários: PROJECT
Indicado com a letra pi (pi) PROJECT projeta a relação original, 
selecionando algumas colunas (atributos) e eliminando outras.
Cria portanto uma partição (projeção) vertical (ver desenho anterior)
Ex.:
pi numero, nome, boca (EMBARCAÇÃO)
SQL:
SELECT numero, nome, boca FROM EMBARCAÇÃO;
Esta operação remove qualquer tuplo duplicada. 
A projeção matemática não permite duplicados. 
A operação deve produzir um conjunto de tuplos.
Ainda
SELECT * FROM EMBARCAÇÃO; = procurar todos os atributos
1818
Operadores unários: PROJECT
Cláusula FROM: deriva a relação desde 2 ou mais 
tabelas 
O número de novas tuplos é sempre igual ou menor que a R 
original
Se existe uma chave nos atributos indicados na projeção, então 
o número de tuplos obtido nela é igual ao número de tuplos na 
R original
PROJEÇÃO não é comutativa. A ordem dos elementos 
indicados será mantida na nova R 
1919
mysql> SELECT id, total_horas, (preço-hora/3) AS valor FROM salarios;
id total-horas preço-hora
1 30 50
2 40 50
3 30 80
4 34 90
id total-horas valor
1 30 50
2 40 50
3 30 80
4 34 90
mysql> SELECT * FROM salarios;
R(salarios)
Operadores unários: RENAME
Podemos renomear os atributos ou os nomes das relações 
(tabelas). Expressada com a letra ρ (ro)
Pode ser prático quando temos muitos queries . Serve para 
minimizar os caracteres a escrever
Ex: calculando vendas totais para cada produto
SELECT id_produto, p.nome, (sum (v.qtd) * p.preço) AS vendas 
 FROM produtos p LEFT JOIN vendas v USING (id_produto)
GROUP BY id_produto, p.nome, p.preço;
Tabela produtos, cognomen é p
Tabela vendas, congnome é v Na nova R estes são os nomes
 de cada coluna da tabela
 (o cabeçalho)
GROUP BY? LEFT JOIN?
2121
Operações sobre Operações sobre conjuntosconjuntos
UNIÃOUNIÃO ( ( ∪∪ ) ) T1 T1 UNIONUNION T2 T2
INTERSECÇÃOINTERSECÇÃO ( ( ∩ ∩ ) ) T1 T1 INTERSECTINTERSECT T2 T2
DIFERENCIADIFERENCIA (ou MENOS, – ) (ou MENOS, – ) T1 T1 MINUSMINUS T2 T2
PRODUTOPRODUTO CARTESIANOCARTESIANO ( x ) ( x ) T1 T1 TIMESTIMES T2 T2
2222
num nome status cidade
c-023 Sousa 20 Porto
c-035 Santos 10 Faro
num nome status cidade
c-023 Sousa 20 Porto
c-012 Mendes 10 Olhão
A B
num nome status cidade
c-023 Sousa 20 Porto
c-012 Mendes 10 Olhão
C-035 Santos 10 Faro
A UNION B
num nome status cidade
c-035 Santos 10 Faro
A INTERSECT B num nome status cidade
c-023 Sousa 20 Porto
num nome status cidade
c-012 Mendes 10 Olhão
A MINUS B
B MINUS A
Operadores
devem ser
do mesmo
tipo
Operações sobre conjuntos: Operações sobre conjuntos: UNIÃOUNIÃO
UNIÃOUNIÃO ( ( ∪∪ ) )
Unir as relações (A Unir as relações (A ∪∪ B) cria uma nova R que inclui B) cria uma nova R que inclui 
todos os tuplos que estão seja em A, seja em B, ou todos os tuplos que estão seja em A, seja em B, ou 
seja em ambas duas A e Bseja em ambas duas A e B
A e B devem ser compatíveis:A e B devem ser compatíveis:
- A e B devem ter o mesmo número de atributos e- A e B devem ter o mesmo número de atributos e
- Os pares correspondentes de atributos i (A.a- Os pares correspondentes de atributos i (A.a ii e B.a e B.aii) ) 
devem ter o mesmo tipodevem ter o mesmo tipo
Os tuplos repetidos são eliminados na nova ROs tuplos repetidos são eliminados na nova R
2424
UNIÃO em PostgreSQL
Formato geral da cláusula união:
select_statement UNION [ ALL | DISTINCT ] select_statement
O operador union computa o conjunto de tuplos devolvidos pelo 
select
A R resultante elimina todos as tuplos duplicados de não ser que 
seja utilizado a opção ALL que impede isto acontecer
CREATE VIEW tenistas AS
 SELECT * FROM tenistas_femeninas 
UNION ALL
 SELECT * FROM tenistas-masculinos
Em geral: query1 UNION [ALL] query2;
2525
UNIÃO: resolução em PostgreSQL
 1. Se todos os inputs são do mesmo tipo, e este é conhecido,1. Se todos os inputs são do mesmo tipo, e este é conhecido,
 substituir por aquele tipo. Caso contrário, resolver qualquer tipo substituir por aquele tipo. Caso contrário, resolver qualquer tipo 
desconhecido com o tipo base: desconhecido com o tipo base: texttext normalmente normalmente
2. Se todos os tipos são desconhecidos, resolver como 2. Se todos os tipos são desconhecidos, resolver como texttext
 Se não fazer, ignorar o inputSe não fazer, ignorar o input
3. Caso os tipos não conhecido não sejam da mesma categoria do 3. Caso os tipos não conhecido não sejam da mesma categoria do 
tipo, a união falhatipo, a união falha
4. Escolher o primeiro tipo não conhecido que seja favorito numa 4. Escolher o primeiro tipo não conhecido que seja favorito numa 
categoria (ex. categoria (ex. texttext é favorito na categoria é favorito na categoria stringsstrings) ) 
5. Casocontrário, escolher um que permita todos os outros não 5. Caso contrário, escolher um que permita todos os outros não 
conhecidosconhecidos
6. Converter todos os inputs no tipo seleccionado. Se a conversão 6. Converter todos os inputs no tipo seleccionado. Se a conversão 
não é possível, a operação falharnão é possível, a operação falhar
2626
UNIÃO
Exemplo:Exemplo:
SELECT text ’a’ AS "texto"SELECT text ’a’ AS "texto" UNIONUNION SELECT ’b’;SELECT ’b’;
texto
a
b
Neste caso, o tipo desconhecido do atributo b e resolvido como texto
2727
UNIÃO
Exemplo:Exemplo:
 SELECT 1 AS "real" UNION SELECT CAST(’2.2’ AS REAL);SELECT 1 AS "real" UNION SELECT CAST(’2.2’ AS REAL);
real
1
2.2
Neste caso, real não pode ser convertido (cast) para integer, mas o 
contrário sim. Portanto a união resolve-se com o tipo real
2828
UNIÃO
Exemplo: Exemplo: 
Imagine as seguintes tabelas na sua BD representadas aqui Imagine as seguintes tabelas na sua BD representadas aqui 
como relações do modelo relacional:como relações do modelo relacional:
capitais (nome, população, altitude, pais, localização)capitais (nome, população, altitude, pais, localização)
não-capitais (nome, população, altitude, pais)não-capitais (nome, população, altitude, pais)
Pretendemos fazer uma lista de todas as cidades, capitais ou não:Pretendemos fazer uma lista de todas as cidades, capitais ou não:
CREATE VIEW cidades ASCREATE VIEW cidades AS
SELECT nome, população, altitude FROM capitaisSELECT nome, população, altitude FROM capitais
UNIONUNION
SELECT nome, população, altitude FROM não-capitais;SELECT nome, população, altitude FROM não-capitais;
2929
(herança em PostgreSQL)
Uma melhor alternativa para evitar problemas de actualizações Uma melhor alternativa para evitar problemas de actualizações 
seria:seria:
CREATE TABLECREATE TABLE cidadescidades (nome text, população real, altitude (nome text, população real, altitude 
integer, pais text);integer, pais text);
CREATE TABLE CREATE TABLE capitaiscapitais ( (localização text); INHERITS localização text); INHERITS 
(cidades);(cidades);
A tabela capitais herda todos os atributos e tipos de cidades. A tabela capitais herda todos os atributos e tipos de cidades. 
Agora podemos interrogar assim:Agora podemos interrogar assim:
SELECT SELECT nome, altitudenome, altitude
FROM FROM cidades cidades (lista todas as cidades + capitais)(lista todas as cidades + capitais)
WHERE WHERE altitudealtitude > 20; > 20;
3030
(herança em PostgreSQL)
INHERITS INHERITS (não é SQL 2008)(não é SQL 2008)
 e também podíamos interrogar:e também podíamos interrogar:
SELECT * FROM SELECT * FROM capitais capitais (lista todas as capitais(lista todas as capitais
WHERE WHERE altitudealtitude > 20; > 20; (com todos os 5 campos)(com todos os 5 campos)
Cláusula opcional INHERITS especifica uma lista de tabelas das quais a Cláusula opcional INHERITS especifica uma lista de tabelas das quais a 
nova tabela vai herdar automaticamente todas as suas colunasnova tabela vai herdar automaticamente todas as suas colunas
INHERITS cria uma relação persistente entre a nova tabela filha e aINHERITS cria uma relação persistente entre a nova tabela filha e a
 sua(s) mãe (mãessua(s) mãe (mães) ) 
Se se modificar o esquema na mãe normalmente se propaga aos filhos. Se se modificar o esquema na mãe normalmente se propaga aos filhos. 
Também os dados por defeito são herdados. Uma lista na tabela mãe Também os dados por defeito são herdados. Uma lista na tabela mãe 
vai incluir os dados na tabela filhavai incluir os dados na tabela filha
3131
Operações sobre conjuntos: Operações sobre conjuntos: 
INTERSECÇÃOINTERSECÇÃO ( ( ∩∩ ) ) 
Formato geral em SQL:
Select_<declaração> INTERSECT [ ALL | DISTINCT ]
O operador INTERSECT computa o conjunto de intersecção das 
filas devolvidas pelos SELECT.
Um tuplo está na intersecção de dois conjuntos de resultados 
se aparece em ambos os dois conjuntos de resultados
Aqui o SELECT é qualquer SELECT mas não pode ter as 
claúsulas ORDER BY, LIMIT, FOR UPDATE, or FOR SHARE
3232
Operações sobre conjuntos: Operações sobre conjuntos: 
INTERSECÇÃOINTERSECÇÃO ( ( ∩∩ ) ) 
CREATE VIEW tenistas AS
 SELECT * FROM campeões-tenis 
INTERSECT
 SELECT * FROM tenistas-masculinos
A Relação resultante será neste caso a lista de todos os tenistas 
masculinos que se encontram também na lista de campeões de 
ténis
CREATE VIEW: o query “tenistas” não é preciso repetir mais.
Fica armazenado no esquema como uma outra tabela que 
podemos interrogar- (insert, update, delete proibidos por defeito)
3333
Operações sobre conjuntos: Operações sobre conjuntos: 
INTERSECÇÃOINTERSECÇÃO ( ( ∩∩ ) ) 
3434
código nome
AVX-325 D.Dias
765-Fuseta F. Santos
2100-TA S. Sousa
código nome
432- Olhão M.Leite
765-Fuseta F. Santos
3243-TA T. Pires
código nome
765-Fuseta F. Santos
SQL: embarcação-motor INTERSECT embarcação-vela
R1: embarcação-motor R2: embarcação-vela
Operações sobre conjuntos: Operações sobre conjuntos: 
DIFERENCIA (-)DIFERENCIA (-) 
3535
código nome
AVX-325 D.Dias
765-Fuseta F. Santos
2100-TA S. Sousa
código nome
AVX-325 D.Dias
765-Fuseta F. Santos
3243-TA T. Pires
código nome
2100-TA S. Sousa
 embarcação-motor MINUS embarcação-vela
SQL: embarcação-motor EXCEPT [ALL] embarcação-vela
R1: embarcação-activa R2: embarcação-inactiva
Diferencia: uma relação com estrutura igual as R originais e cujo 
corpo formado por todos os tuplos pertencentes a R1 mas não a R2
R3
Álgebra relacionalÁlgebra relacional
Para se poder calcular as operaçõesPara se poder calcular as operações
uniãounião, , intersecçãointersecção ou ou diferenciadiferencia ( (exceptexcept) de dois) de dois
interrogações, as duas operações devem serinterrogações, as duas operações devem ser
compatíveis com a operação união.compatíveis com a operação união.
Isto é, devem devolver o mesmo número de colunasIsto é, devem devolver o mesmo número de colunas
e as colunas (atributos) correspondentes devem tere as colunas (atributos) correspondentes devem ter
tipos de dados compatíveistipos de dados compatíveis
3636
Operações sobre conjuntos: Operações sobre conjuntos: JUNÇÃOJUNÇÃO
Equivale a produto cartesiano + seleção: Equivale a produto cartesiano + seleção: ⋈⋈
Em SQL corresponde a Em SQL corresponde a JOINJOIN. Vários tipos diferentes. Vários tipos diferentes
 Ex.: R (natural) Ex.: R (natural) JOIN JOIN SS
R S, a junção natural das relações R e S: o conjunto de todas as ⋈R S, a junção natural das relações R e S: o conjunto de todas as ⋈
combinações de tuplos em R e S que são iguais no seu atributos combinações de tuplos em R e S que são iguais no seu atributos 
com nome igualcom nome igual
Se as tabelas tem Se as tabelas tem nn e e mm tuplos, a tabela resultante terá tuplos, a tabela resultante terá n*mn*m
tuplostuplos
FROM T1 CROSS FROM T1 CROSS JOINJOIN T2 T2 é equivalente aé equivalente a
FROM T1 , T2FROM T1 , T2. também é equivalente a. também é equivalente a
FROM T1 FROM T1 INNER JOININNER JOIN T2 T2 ONON TRUE TRUE (+ na 2ª parte)(+ na 2ª parte) 
3737
Operações sobre conjuntos: Operações sobre conjuntos: divisãodivisão
A mais dificil das operações. Utiliza 3 operadores: x, A mais dificil das operações. Utiliza 3 operadores: x, pi, −pi, −
(produto cruzado, projecção, e diferença de conjuntos) para (produto cruzado, projecção, e diferença de conjuntos) para 
alem de se efectuar 6 operaçõesalem de se efectuar 6 operações
O número de atributos em R1 é maior que R2 (divisor)O número de atributos em R1 é maior que R2 (divisor)
 
 
A divisão encontra os valores dos atributos numa relação queestão pareados com TODOS os valores da otra relação
Tal como a multiplicação é a divisão em aritmética, 
A divisão é ao produto cartesiano na álgebra relacional: 
O seu inverso
If X, Y and Z (como união dos anteriores) então:
 X DIVIDEDBY Y PER Z 
3838
Operações sobre conjuntos: Operações sobre conjuntos: divisãodivisão
3939
 A
 2
6
B
7
5
8
A B
2 7
2 5
2 8
6 7
6 5
6 8
 J K Produto Cartesiano
 C 
Imagine que temos C = J x K (o produto cartesiano)
A divisão é o oposto: C / J = K, C/K = J
Ex. SELECT 5 / 275;
SELECT 5 DIV 2; ~ floor();
Operações sobre conjuntos: Operações sobre conjuntos: divisãodivisão
4040
 pessoa
luis
linda
 conta
k1
k2
k3
 R(A) R(B) R(A/B)
/ =
Divisão: uma pesquisa do tipo:
Que pessoas tem conta nos bancos k1,k2 e k3?
x y
k1 luis
k2 luis
k3 luis
k4 luis
k1 sofia
k3 sofia
k2 pedro
k3 pedro
k4 pedro
k1 linda
k2 linda
k3 linda
Operações sobre conjuntos: Operações sobre conjuntos: divisãodivisão
4141
 y
luis
linda
 y
k1
k2
k3
x y
k1 luis
k2 luis
k3 luis
k4 luis
k1 sofia
k3 sofia
k2 pedro
k3 pedro
k4 pedro
k1 linda
k2 linda
k3 linda
 A B A/B
/ =
R(A) = {conta, pessoa}; R(B) = {conta}
Formalmente a divisão:
A/B = { x | Ǝ x,y A y B}⟨ ⟩ ⟨ ⟩ ∈ ∀ ⟨ ⟩ ∈
A/B contem todos os tuplos x tais que para 
cada tuplo y em B, existe um tuplo xy em A
Álgebra RelacionalÁlgebra Relacional
Fim primeira parteFim primeira parte
4242