Banco de Dados

Query - Consulta de Dados

Algebra Relacional x Structured Query Language (SQL)

Banco de Dados....................................................................................................................................1
Query - Consulta de Dados...................................................................................................................1
Algebra Relacional x Structured Query Language (SQL)....................................................................1
1 ALGEBRA RELACIONAL..............................................................................................................2
1.1 Consultas Fundamentais e Especificas para BD........................................................................3
Operador Selecionar (SELECT).................................................................................................3
Operador Projetar (PROJECT)...................................................................................................3
1.2 Sequencia de Operações............................................................................................................4
1.3 Operações Fundamentais da Teoria dos Conjuntos...................................................................5
Produto Cartesiano (CARTESIAN PRODUCT)........................................................................5
União (UNION)..........................................................................................................................5
Diferença (DIFFERENC ou EXCEPT)......................................................................................6
1.4 Operações Não Fundamentais...................................................................................................7
Intersecção (INTERSECTION)..................................................................................................7
Ligação Natural (JOIN)..............................................................................................................7
1.5 Atividade Exemplo:...................................................................................................................9
1.6 Atividade de Fixação:..............................................................................................................11
2 A LINGUAGEM SQL.....................................................................................................................12
2.1 Estrutura Básica.......................................................................................................................12
2.2 Estrutura Completa..................................................................................................................13
Linhas duplicadas......................................................................................................................13
2.3 Predicados e Ligações usando WHERE..................................................................................14
Ligação Natural.........................................................................................................................14
Comparações com Strings.........................................................................................................14
Membros de conjuntos..............................................................................................................15
Comparação de conjuntos.........................................................................................................15
Testando relações vazias...........................................................................................................16
2.4 Operações de Conjunto............................................................................................................16
2.5 Renomeação.............................................................................................................................16
2.6 ORDER BY - Ordenando a exibição de tuplas........................................................................17
2.7 GROUP BY – Funções Agregadas..........................................................................................17
2.8 HAVING – Condições a nível de Grupos................................................................................18
2.9 Atividade Exemplo..................................................................................................................19
2.10 Atividade de Fixação.............................................................................................................22
1 ALGEBRA RELACIONAL
A álgebra relacional é uma linguagem de consulta procedural. Ela consiste em um conjunto de
operações que tomam uma ou duas relações (tabelas) como entrada e produzem uma nova relação
como resultado. Inclui um conjunto de operações, classificadas como fundamentais e não
fundamentais.
As operações da álgebra relacional são normalmente divididas em dois grupos, um que diz respeito
a teoria dos conjuntos (UNION, DIFFERENCE e CARTESIAN PRODUCT, entre outras) e
outro desenvolvido especificamente para base de dados relacionais (SELECT, PROJECT, entre
outras).
As operações fundamentais da álgebra relacional estão destacadas acima: selecionar, projetar
(unárias) - produto cartesiano, união e diferença de conjuntos (binárias), com elas é possível realizar
quaisquer consultas. Além das operações fundamentais existem outras operações não fundamentais,
que podem ser utilizadas para simplificar consultas. A Figura de forma gráfica, cada uma das
operações da álgebra.

2/23
1.1 Consultas Fundamentais e Especificas para BD
Operador Selecionar (SELECT)
A operação selecionar seleciona tuplas (linhas) que satisfazem a um dado predicado. Usamos a letra
minúscula grega sigma (σ) para representar a seleção. O predicado aparece subscrito em σ. A
relação argumento (entrada) aparece entre parênteses, seguindo o σ. A Figura abaixo representa
graficamente essa operação

Exemplos:
Selecionar as tuplas da relação empréstimos em que o código da agência é 0662, escreve-se:

σ codigoAg=0662 (Emprestimos)
Podemos encontrar todas as tuplas em que a quantia emprestada seja maior que 1200:

σ codigoAg>1200 (Emprestimos)
As quantias comparações são utilizados os padrões ( =, >, < , >=, <= e <>) e os conectivos e (^) e
ou (v).

Operador Projetar (PROJECT)

A operação projetar é uma operação unária que retorna sua relação argumento, com certas colunas
deixadas de fora. A projeção é representada pela letra grega pi (π). A Figura abaixo representa
graficamente essa operação.

Suponha que desejemos uma relação mostrando os clientes e as agências nas quais eles tomaram
empréstimos, mas não nos importamos com a quantia e o número do empréstimo:

π CodigoAg,CodigoCli(Emprestimos)
1.2 Sequencia de Operações
Em geral, existe a necessidade de se aplicar várias operações da álgebra relacional uma após a
outra. Pode-se escrever essas operações em apenas uma única expressão da álgebra relacional ou
aplicar uma única operação por vez e criar relações intermediárias. Por exemplo, deseja-se
recuperar o primeiro nome, o último nome e o salário de todos os empregados que trabalham no
departamento 5. Isto pode ser feito aplicando-se os operadores SELECT e PROJECT:

π pNome, sNome, Salário (σ nDep=5 (Empregado))

Alternativamente, explicitando a sequência de operações e dando nome para cada relação
intermediária temos:

DEP5_EMPS ← σ nDep=5 (Empregado)

RESULT ← π pNome, sNome, Salário (DEP5_EMPS)

É importante mencionar que as operações da álgebra relacional atuam sobre uma ou duas relações,
sendo classificadas como unárias ou binárias, assim, caso seja necessário usar mais de duas tabelas
em uma consulta, operações podem ser usadas de forma encadeada, tal como demonstrado acima,
ou seja o resultado de uma consulta é uma nova relação e esta pode ser usada como entrada para a
próxima operação.
1.3 Operações Fundamentais da Teoria dos Conjuntos

Produto Cartesiano (CARTESIAN PRODUCT)

O produto cartesiano, representada por (X) é capaz de combinar informações a partir de diversas
relações. Trata-se de uma operação binária. Essa operação nos mostra todos os atributos das
relações envolvidas. A Figura abaixo representa graficamente essa operação.

Para selecionarmos todos os nomes dos clientes que possuam empréstimo na agência cujo código é
0662, escrevemos:

π Nome (σ CodigoAg=0662 ^ Emprestimo.CodigoCli = Clientes.CodigoCli (Emprestimos X Clientes))

União (UNION)
A operação união de conjuntos, representada por (U), permite-nos encontrar tuplas que estão em
uma das relações envolvidas. A Figura abaixo representa graficamente essa operação.
Vamos supor que quiséssemos conhecer todas as pessoas que possuam Depósitos, Empréstimos, ou
ambos, numa determinada agência. Com os recursos que temos até agora, não seria possível
conseguirmos tal informação. Nessa situação, deveríamos fazer a união de todos que possuam
depósitos com todos que possuam empréstimos nessa agência. Como veremos no exemplo a seguir:
Ex: Informe todos os nomes de clientes que possuam depósitos, empréstimos, ou ambos, na agência
051.

Dep51 ← π Nome(σCodigoAg=”051” ^ depositos. CodigoCli = Clientes. CodigoCli (Depositos X Clientes))

Em51← πNome(σCodigoAg=”051” ^ emprestimos.CodigoCli= Clientes.CodigoCli(EmprestimosXClientes))
R ← Dep51 U Em51

Uma vez que as relações são conjuntos, as linhas duplicadas são eliminadas.

Diferença (DIFFERENC ou EXCEPT)

A operação diferença de conjuntos, representada por (-), é uma operação binária e nos permite
encontrar tuplas que estão em uma relação e não em outra. A expressão r - s resulta em uma relação
que contém todas as tuplas que estão em r e não em s. A Figura abaixo representa graficamente essa
operação.

Ex. Encontrar todos os clientes que possuam um depósito, mas não possuem um empréstimo na
agência 051.

πNome (σ CodigoAg=”051” ^ depositos. CodigoCli = Clientes. CodigoCli (Depositos X Clientes))

-
πNome (σ CodigoAg=”051” ^ emprestimos. CodigoCli = Clientes. CodigoCli(Emprestimos X Clientes))

6/23
1.4 Operações Não Fundamentais
Utilizando as operações fundamentais da álgebra relacional podemos expressar qualquer consulta
da álgebra relacional. Entretanto, algumas consultas são longas ou complexas demais para serem
expressas. Nesse caso, o uso das operações não fundamentais pode reduzir o tamanho e a
complexidade dessas consultas.

Intersecção (INTERSECTION)
A operação Intersecção de conjuntos, representada por (∩), é uma operação binária e nos permite
encontrar tuplas que estão nas duas relações envolvidas na consulta. Pode ser expressa em função
das operações fundamentais da seguinte forma: r ∩ s = r – (r – s). A Figura abaixo representa
graficamente essa operação

Suponha que desejemos encontrar todos os clientes que tenha empréstimo e depósitos na agência
“051”.

πNome (σ CodigoAg=”051” ^ depositos. CodigoCli = Clientes. CodigoCli (Depositos X Clientes))

∩
πNome (σ CodigoAg=”051” ^ emprestimos. CodigoCli = Clientes. CodigoCli(Emprestimos X Clientes))

Ligação Natural (JOIN)

A ligação natural, representada pelo símbolo (|X|) é uma operação binária que permite combinar
certas seleções e um produto cartesiano em uma operação. A operação ligação natural forma um
produto cartesiano de seus dois argumentos e faz uma seleção, forçando uma equidade sobre os
atributos que aparecem em ambos os esquemas relação. A Figura abaixo representa graficamente
essa operação.

7/23
Ex1: Encontre todos os clientes que têm empréstimos exibindo também a cidade em que vivem.

π Nome, cidade (Emprestimos |X| Clientes)

Ex2: Encontre todos os clientes que têm empréstimos e que moram em “Vitória”:

π Nome, cidade (σ cidade=”Vitória” (Emprestimos |X| Clientes))

8/23
1.5 Atividade Exemplo:
Considere o esquema seguinte para construir expressões, da álgebra relacional para as questões que
se seguem.
agencia (cdAg, nomeAg, cidadeAg)
cliente(cdCli, nomeCli, rua, cidade)
deposito (cdAg, numCont, cdCli, saldo)
cdAg referencia agencia
cdCli referencia Cliente
emprestimo (cdAg, cdCli, nuEmp, quantia)
cdAg referencia agencia
cdCli referencia Cliente

1. Selecionar todos os clientes (nomes) que possuam depósitos.

2. Selecionar todos os clientes que possuam depósito na mesma cidade onde moram.
3. Encontrar todas as agências que possuam clientes com nome “Maria” (depósitos ou
empréstimos).

Resolução:
1. Para poder resolver a solicitação, é necessário trabalhar com duas tabelas, CLIENTE e
DEPÓSITO. Assim deve-se escolher uma das operações binárias (Fundamentais: Produto
Cartesiano, União ou Diferença) os não fundamentais seriam (JOIN ou INTERSEÇÃO).
Como neste ítem só pretendo relacionar as duas tabelas posso usar diretamente o produto
cartesiano

(1) Cliente X Deposito

No (1) é importante entender que o Produto Cartesiano não faz distinção de qual cliente
realizou cada depósito colocando todas as combinações possíveis entre cliente e depósito.
Assim para poder utiliza-lo na solução é necessário trabalhar esta relação, tal como
mostrado abaixo (2).

(2) σ cliente.cdCli = deposito.cdCli (Cliente X Deposito)

O (2) resolve a questão, pois ele possui o conjunto com todos os dados das duas tabelas
associando o cliente ao seu respectivo depósito. Uma alternativa é usando o JOIN tal como
mostrado abaixo (3)

(3) Cliente |X| Deposito

9/23
 O (3) demonstra o uso da operação não fundamental JOIN e possui o mesmo resultado que o
(2), ou seja ele simplifica a construção, apesar de muitos projetistas usarem
preferencialmente somente operadores fundamentais. Abaixo (4) ou (5) é a solução final

(4) π nomeCli (σ cliente.cdCli = deposito.cdCli (Cliente X Deposito))

(5) π nomeCli (Cliente |X| Deposito)

2. Nesta consulta tenho que trabalhar com 3 tabelas, CLIENTE, DEPOSITO e AGENCIA, pois
a cidade do depósito está na tabela agência.

(1) dc ← σ cliente.cdCli = deposito.cdCli (Cliente X Deposito))

O (1) tenho todos os depósitos de cada cliente agora basta associar este conjunto a agência

(2) π nomeCli (σ agencia.cdAge = dc.cdAge ^ dc.Cidade = agencia.cidadeAg (agencia X dc))

Repare que eu poderia usar JOIN tanto no (1) quanto no (2)….assim abaixo uma possível
alternativa (3):

(3) π nomeCli (σ dc.Cidade = agencia.cidadeAg (agencia |X| dc))

3. Nesta consulta teremos que combinar as tabelas CLIENTE, AGENCIA, DEPOSITO E

EMPRESTIMO. Na resolução desta consulta eu fiz uso do operador JOIN por uma questão
de praticidade

(1) MariaD ← σ cliente.nomeCli = “Maria” (Cliente |X| Deposito))

(2) MariaE ← σ cliente.nomeCli = “Maria” (Cliente |X| Emprestimo))

O (2) e o (3) possuem o conjunto de depósitos e empréstimo respectivamente realizado por

algum cliente com o nome de “Maria”. A solução envolve a união destes conjuntos.

(3) π nomeAg (agencia |X| (MariaD U MariaE))

10/23
1.6 Atividade de Fixação:
Considere o esquema seguinte para construir expressões, da álgebra relacional para as questões que
se seguem.
Pessoa (cdPessoa, Nome, Cidade, cdChefe) cdChefe referencia Pessoa
Empresa (cdEmpresa, Nome, Cidade)
Trabalha (cdPessoa, cdEmpresa, Salario)
cdPessoa referencia Pessoa
cdEmpresa referencia Empresa

1. Consulte o nome e a cidade de todas as pessoas cadastradas. A consulta deverá retornar o

nome das pessoas e a cidade onde moram
2. Consulte todas as pessoas que trabalham no “Ifes” (nome da empresa). A consulta deverá
retornar o nome das pessoas e a cidade onde moram.
3. Consulte o nome das empresas que possuem funcionários que ganham menos que um salário-
mínimo (considere o valor do salário de R$1000,00).
4. Consulte todas as pessoas (nomes) que trabalham em Vitória.
5. Consulte todas as pessoas (nomes) que trabalham na mesma cidade onde moram.
6. Consulte todas as pessoas (nomes) que moram na mesma cidade do chefe.
7. Consulte todas as empresas (nomes) que funcionam em cidades em que não moram Maria.
8. Consulte todas as pessoas (nomes) que não trabalham em Vitória e que ganham acima de R$
2000.
9. (desafio) - Selecione o nome do funcionário da empresa de código “01” que possui o menor
salário.

11/23
2 A LINGUAGEM SQL
A linguagem SQL é um padrão de linguagem de consulta comercial que usa uma combinação de
construtores da Álgebra e Cálculo Relacional. O Foco deste material é o uso da DQL (Data Query
Language) com o qual o usuário pode requisitar ao Sistema de Gerência de Banco de Dados
(SGBD) informações armazenadas no Banco de Dados (BD)
A maioria dos sistemas gerenciadores de bancos de dados comerciais implementa suporte ao padrão
SQL. Além disso, incorporam uma série de funções adicionais, visando facilitar o trabalho dos
desenvolvedores. Essas facilidades precisam ser usadas com cautela, pois, se apenas o padrão for
utilizado, garante-se a portabilidade, caso haja a necessidade de troca de SGBD.
Conceitualmente a relação resultante de uma consulta SQL não em verdade um conjunto pois é
possível a existência de duas ou mais tuplas idênticas, haja vista que um conjunto não permite
elementos idênticos. Podemos dizer então que o SQL gera relações multi-conjunto (algumas vezes
chamado de bag) de tuplas

2.1 Estrutura Básica

A estrutura básica de uma expressão SQL consiste em três cláusulas: select, from e where.

• SELECT: A cláusula select corresponde à operação projeção (π ) da álgebra relacional. É

usada para listar os atributos desejados no resultado de uma consulta. É o retorno da
expressão SQL, isto é, uma relação que pode ter duplicidades de tuplas. Quando desejamos
eliminar as duplicidades podemos inserir o termo DISTINCT depois do select.
Quando desejamos exibir todos os atributos da relação resultante utilizamos “*”

• FROM: A cláusula from permite informar a tabela que será examinada e caso seja
informado mais de uma tabela corresponde à operação produto cartesiano (X) da álgebra
relacional;

• WHERE: A cláusula where corresponde a seleção (σ ) da álgebra relacional. Consiste em

um predicado envolvendo atributos de relações que aparecem na cláusula from. A cláusula
where pode conter expressões aritméticas envolvendo os operadores de comparação (>, <,
>=, <= e <>) e conectores lógicos AND, OR ou NOT
Uma consulta típica em SQL tem a forma:
• SELECT A1, A2, ..., An FROM r1,r2,...,rn [WHERE P ]
Os quadros abaixo apresenta três estruturas de montagem SQL fazendo um paralelo com a Álgebra
Relacional:

(SQL): SELECT A1, A2, ..., An FROM r1

(1)
(AR): π A1, A2, ..., An (r1)

12/23
 (SQL): SELECT * FROM r1 WHERE P
(2) (AR): σ P (r1)

(SQL) SELECT r1.*,r2.A1 FROM r1,r2 WHERE P

(3)
(AR) π r1.A1, r1.A2,….r1.An, r2.A1 (σ P (r1 X r2))

2.2 Estrutura Completa

Uma consulta completa SQL pode ter as cláusulas abaixo, sendo que apenas as cláusulas SELECT
e FROM são obrigatórias. O número que segue a cada linha sugere a ordem de execução
SELECT A1, A2, ..., An 6
FROM r1, r2, ..., rn 1
[WHERE P] 2
[GROUP BY A1, A2, ..., An] 3
[HAVING Condição] 4
[ORDER BY A1, A2, ..., An] 5

Uma consulta simples no nosso esquema de exemplo seria:

SELECT nmCl
FROM cliente

Para além desta consulta simples, as opções serão exploradas a seguir, utilizando o esquema
exemplo apresentado no capítulo anterior (Algebra Relacional), transcrito abaixo..
Schema Exemplo – Utilizado nas Explicaçoes
agencia (cdAg, nmAg, cidadeAg)
cliente(cdCl, nmCl, rua, cidade)
deposito (cdAg, nuCont, cdCl, saldo)
cdAg referencia agencia
cdCl referencia Cliente
emprestimo (cdAg, cdCl, nuEmp, quantia)
cdAg referencia agencia
cdCl referencia Cliente

Linhas duplicadas
Neste exemplo simples, é possível perceber que a relação resultante poderia ter clientes que
possuam o mesmo nome. Se desejar eliminar as duplicações utiliza a clausua DISTINCT (e a
relação resultante passaria a ser considerada conceitualmente um conjunto):
SELECT DISTINCT nmCl
FROM cliente

13/23
2.3 Predicados e Ligações usando WHERE
A seguir são apresentadas as extensões de opções usando where

Ligação Natural
A ligação natural pode ser 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 natura
Ex.: Encontre os nomes e cidades de clientes que possuam empréstimos em alguma agência:
SELECT distinct nmCl, cidade
FROM cliente, emprestimo
WHERE cliente.cdCl=emprestimos.cdCl

A maioria das soluções de consultas são encontradas fazendo varias ligações naturais e predicados
de comparação >, >, >= , <= e <> , not, and e or. A seguir vamos apresentar algumas
especializações, cobrindo todas as possibilidades desde consultas simples até consultas complexas

Comparações com Strings

As operações em strings mais usadas são as checagens para verificação de coincidências de pares,
utilizando o operador LIKE. Esses pares são identificados por meio do uso de dois caracteres
especiais:
• Porcentagem ( % ): compara qualquer string;
• Sublinhado ( _ ): compara qualquer caracter.
Ou seja
• “_ _ _ _%” corresponde a qualquer string com pelo menos quatro caracteres.
• “Uni%” corresponde a qualquer string que comece com “Uni”, como, “universo”,
“universal”, “universidade”.
Utilizando NOT LIKE pode-se pesquisar diferenças, em vez de coincidências.

Ex.: Encontre os nomes de todos os clientes cujas ruas incluem a subcadeia “na”
SELECT distinct nmCl
FROM cliente
WHERE rua LIKE “%na%”

Ou também

Ex.: Encontre os nomes de todos os clientes cujas ruas finalizem com a subcadeia “na”
SELECT distinct nmCl
FROM cliente
WHERE rua LIKE “%na”

14/23
Membros de conjuntos
O conectivo IN e NOT IN testa os membros de conjunto, em que o conjunto é uma coleção de
valores produzidos por uma cláusula select.
Para ilustrar, considere a consulta “Encontre todos os clientes que possuem uma conta e não
possuem empréstimo na agência “Princesa Isabel”. A consulta SQL pode ser escrita da seguinte
forma: (repare que esta estrutura se assimila a Diferença da Algebra Relacional)
SELECT distinct nmCl
FROM cliente
WHERE cliente.cdCl IN
(SELECT cdCl
FROM deposito, agencia
WHERE deposito.cdAg = agencia.cdAg AND nmAg = “Princesa Isabel”)
AND cliente.cdCl NOT IN
(SELECT cdCl
FROM emprestimo, agencia
WHERE emprestimo.cdAg = agencia.cdAg AND nmAg = “Princesa Isabel”)

Comparação de conjuntos
Permite usar comparações do tipo > any (maior que ao menos uma), <= any, = any, etc... ou > all
(maior que todas), >= all, etc.
O mySql aceita também o uso da palavra reservada some (algum) e tem o mesmo efeito que
any(qualquer)
Ex. Considere a consulta “encontre todos os clientes que possuem saldo maiores que alguma
agência de Vitória”. Uma vez que é uma comparação “maior que”, não podemos escrever a
expressão usando a construção in. Assim a consulta pode ser escrita da seguinte forma:
SELECT nmCl
FROM cliente,deposito
WHERE cliente.cdCl=deposito.cdCl AND deposito.saldo > any
(SELECT deposito.saldo
FROM agencia,deposito
WHERE agencia.cdAg=deposito.cdAg AND and cidadeAg = “Vitória”)

Suponha que agora deseje encontrar todas as agências que possuem saldo maiores do que todas as
agências de Vitória.
A construção > all corresponde à frase “maior que todos”. A consulta fica como se segue:
SELECT distinct nmAg
FROM agencia,deposito
WHERE agencia.cdAg=deposito.cdAg AND deposito.saldo > all
(SELECT deposito.saldo
FROM agencia,deposito
WHERE agencia.cdAge=deposito.cdAg and cidadeAg = “Vitória”)

15/23
Testando relações vazias
A SQL possui um recurso para testar se uma subconsulta retorna alguma tupla. A construção
EXISTS retorna true se a subconsulta retornar alguma tupla.
Para ilustrar, vamos escrever a consulta Encontre todos os clientes que possuem depósito e não
possuem empréstimo na agência “Princesa Isabel”.
SELECT nmCli
FROM cliente
WHERE EXISTS (
SELECT *
FROM deposito, agencia
WHERE deposito.cdCl= cliente.cdCl AND agencia.cdAg = depositos.cdAg AND
nmAg = “Princesa Isabel”)
AND NOT EXISTS
(SELECT *
FROM emprestimo, agencia
WHERE emprestimo.cdCl= cliente.cdCl AND agencia.cdAg = emprestimo.cdAg AND
nmAg = “Princesa Isabel”)

2.4 Operações de Conjunto

SQL possui as operações de união (union), interseção (intersect) e Diferença/Exceto (except), que
correspondem às operações ∪, ∩ e − da álgebra relacional. Contudo, existem várias restrições para
o uso destes operadores e certos produtos não oferecem suporte. O MySql só fornece suporte para
operação UNION. Por se tratar de um operador de conjunto não pode ter linhas duplicadas
Ex: Para achar todos os clientes que possuam um depósito, um empréstimo, ou ambos, na agência
de código “051”, fazemos:
SELECT distinct nmCl
FROM cliente, deposito
WHERE cliente.cdCl=deposito.cdCl AND deposito.cdAg = “051”
UNION
SELECT distinct nomCl
FROM cliente, emprestimo
WHERE cliente.cdCli=emprestimo.cdCli AND emprestimo.cdAg = “051”

2.5 Renomeação
A renomeação sempre é necessária quando temos necessidade de usar a mesma tabela mais de uma
vez na mesma consulta. Muitas vezes usamos este recurso com o objetivo de reduzir o tamanho das
expressões SQL. A renomeação é feita usando a palavra reservada “AS”, após o nome da tabela na
cláusula FROM. Também é possível renomear os atributos do select de forma a melhorar a
visualização de relação resultante, como mostra o exemplo a seguir.

16/23
Ex: encontre o nome e a cidade de todos os clientes que possuem depósito em qualquer agência
SELECT distinct C.nmCl AS Nome_Cliente, C.cidade AS Cidade_Cliente
FROM cliente AS C, deposito AS D
WHERE C.cdCl = D.cdCl

Uma vez que as relações Cliente e Deposito foram renomeadas para C e D, quaisquer referências a
essas tabelas, na consulta, devem ser feitas a C e D.
No caso do MySql o termo “AS” opcionalmente pode ser omitido.

2.6 ORDER BY - Ordenando a exibição de tuplas

A cláusula order by organiza o resultado de uma consulta em uma ordem determinada. É importante
mencionar que para completar uma solicitação de ORDER BY o SQL realiza uma intercalação que
dependendo da relação pode ser custosa, portanto, só usar quando necessária.
Para listarmos uma relação em ordem ascendente usamos order by nome do campo [asc]. Em
ordem descendente, usamos order by nome do campo desc. Por default, a relação dos itens é
efetuada em ordem ascendente, ou seja, mesmo se não for informado o termo asc, será exibido a
relação em ordem ascendente.
Ex.: Para listar em ordem alfabética todos os clientes do banco, fazemos:
SELECT distinct nmCl
FROM Clientes
ORDER BY nmCl

Também é possível ordenar uma relação usando mais de um elemento. Como se segue:
SELECT *
FROM emprestimo
ORDER BY quantia DESC, cdAg ASC

2.7 GROUP BY – Funções Agregadas

Usando a cláusula GROUP BY é possível computar funções em grupos de tuplas. Tuplas com o
mesmo valor em todos os atributos da cláusula group by são colocados em um grupo, para
utilização de funções agregadas:
• Média: AVG
• Mínimo: MIN
• Máximo: MAX
• Soma: SUM
• Contar: COUNT

17/23
A entrada para SUM e AVG precisa, obrigatoriamente, ser um conjunto de números, as demais
operações não impõem esta restrição.
Para ilustrar, considere as consultas
1) Encontre o saldo médio das contas em cada agência:
SELECT nmAg, AVG(deposito.saldo) AS Saldo_Medio
FROM deposito,agencia
WHERE deposito.cdAg = agencia.cdAg
GROUP BY nmAg

2) Encontre a quantidade de depositantes de cada agência:

SELECT nmAg, COUNT(distinct nmCli) AS Qtd_Clientes
FROM deposito, agencia
WHERE deposito.cdAg = agencia.cdAg
GROUP BY nmAg

3) Encontre o maior saldo de cada agência:

SELECT nmAg, MAX(deposito.saldo) AS Maior_Saldo
FROM deposito, agencia
WHERE deposito.cdAg= agencia.cdAg
GROUP BY nmAg

2.8 HAVING – Condições a nível de Grupos

A cláusula HAVING faz restrições ao nível dos grupos. Este comportamento o torna diferente do
WHERE que define restrições em nível de tuplas.
Por exemplo, poderíamos estar interessados apenas em agências em que a média dos saldos seja
maior que R$1200,00. Essa condição será aplicada a cada grupo e não a tuplas e é definida pela
cláusula having. Podemos escrever essa expressão SQL assim:
SELECT nmAg, AVG(deposito.saldo) AS Saldo_Medio
FROM deposito, agencia
WHERE deposito.cdAg= agencia.cdAg
GROUP BY cdAg
HAVING AVG(saldo)>1200

18/23
2.9 Atividade Exemplo
Utilizando a atividade de Fixação de Álgebra Relacional e a solução desenvolvida, é demonstrado a
seguir a transcrição da Álgebra Relacional para SQL realizei apenas algumas modificações nas
questões (especificamente para incrementar no SQL e facilitar testes – destacados em vermelho.
Schema utilizado na Atividade de Exemplo
Pessoa (cdPessoa, Nome, Cidade, cdChefe) cdChefe referencia Pessoa
Empresa (cdEmpresa, Nome, Cidade)
Trabalha (cdPessoa, cdEmpresa, Salario)
cdPessoa referencia Pessoa
cdEmpresa referencia Empresa

P ← Pessoa , E← Empresa , T← Trabalha

1. Consulte o nome e a cidade de todas as pessoas cadastradas. A consulta deverá retornar o
nome das pessoas e a cidade onde moram [ordene em relação a cidade e nome]

π nome,cidade (P)

SELECT nome, cidade FROM pessoa ORDER BY cidade, nome

2. Consulte todas as pessoas que trabalham no “Campus Guarapari” (nome da empresa). A
consulta deverá retornar o nome das pessoas e a cidade onde moram [Ordenado por nome -
alfabeticamente].

πP.nome, P.cidade(σP.cdPessoa=T.cdPessoa (P X (σ E.cdEmpresa=T.cdEmpresa ^ E.nome=“Ifes” (E X T)))

SELECT P.nome, P.cidade
FROM pessoa P, empresa E, Trabalha T
WHERE E.cdEmpresa = T.cdEmpresa AND T.cdPessoa = P.cdPessoa AND E.nome = “Ifes”
ORDER BY nome
3. Consulte o nome das empresas que possuem funcionários que ganham menos que um salário-
mínimo (considere o valor do salário de R$1500,00).

π E.nome (σ E.cdEmpresa = T.cdEmpresa ^ T.Salario < 1500 (E X T))

SELECT distinct E.nome

FROM empresa E, trabalha T
WHERE E.cdEmpresa = T.cdEmpresa AND T.salario <1500
4. Consulte todas as pessoas (nomes) que trabalham em Vitória[, informe a Empresa]

π P.nome(σ P.cdPessoa = T.cdPessoa(P X (σ E.cdEmpresa = T.cdEmpresa ^ E.cidade = “Vitória” (E X T)))

SELECT P.nome, E.nome as Empresa

FROM empresa E, trabalha T, pessoa P
WHERE E.cdEmpresa=T.cdEmpresa AND P.cdPessoa=T.cdPessoa AND E.cidade=“Vitória”

19/23
5. Consulte todas as pessoas (nomes) que trabalham na mesma cidade onde moram, [, informe a
Empresa, a cidade onde moram e cidiade onde trabalha] .

π P.nome(σ P.cdPessoa = T.cdPessoa ^ P.cidade = E.cidade (P X (σ E.cdEmpresa = T.cdEmpresa (E X T)))

SELECT P.nome,E.nome as Empresa, P.cidade Mora_Cidade, E.cidade Trabalha_Cidade

FROM empresa E, pessoa P, trabalha T
WHERE E.cdEmpresa=T.cdEmpresa AND T.cdPessoa=P.cdPessoa AND P.cidade = E.cidade
6. Consulte todas as pessoas (nomes) que moram na mesma cidade do chefe [,exiba também o
nome do chefe, a cidade da pessoa, e a cidade do chefe].
PS ← Pessoa PC ← Pessoa (Pessoa Subordinada e Pessoa Chefe)

π PS.nome(σ PS.cdChefe = PC.cdPessoa ^ PS.cidade = PC.cidade (PS X PC)

SELECT PS.nome, PC.nome chefe, PS.cidade CidadeFuncionario, PC.cidade CidadeChefe

FROM pessoa PS, pessoa PC
WHERE PS.cdChefe = PC.cdPessoa AND PS.cidade = PC.cidade
7. Consulte todas as empresas (nomes) que funcionam em cidades em que não moram qualquer
pessoa que tenha “Carla” no nome

C← π Cidade(σ nome = “Maria” (P)

π E.nome (σ E.Cidade <> C.Cidade (E X C)

SELECT E.nome
FROM empresa E, (SELECT cidade FROM pessoa WHERE nome LIKE “%Carla%)
WHERE E.cidade <> C.cidade
8. Consulte todas as pessoas (nomes) que não trabalham em Vitória e que ganham acima de R$
2000.

πP.nome(P |X| (σ E.cdEmpresa = T.cdEmpresa ^ E.Cidade <> “Vitória” ^ T.Salario > 2000 (E X T)))
SELECT P.nome
FROM pessoa P, empresa E, trabalha T
WHERE E.cdEmpresa=T.cdEmpresa AND P.cdPessoa=T.cdPessoa AND
E.cidade <> “Vitória AND T.salario > 2000
9. (desafio) - Selecione o nome do funcionário da empresa de código “03” que possui o menor
salário.

S1 e S2← σ t.cdEmpresa = 3 (T)

Maiores ←π S1.cdPessoa(σ S1.Salario > S.Salario (S1 X S2)

20/23
 Menor← π cdPessoa (S1 - Maiores)

Result ← π p.nome( σ p.cdPpessoa = menor.cdPessoa (P X Menor)

Na solução do exercício 9 a transcrição não é direta, pois o operador de DIFERENÇA da
Álgebra Relacional não é suportado pelo MySql, assim para este item em específico pode ser
utilizado algum dos artifícios do WHERE para comparação de conjuntos (ALL, ANY ou SOME)
ou a verificação de membros de conjunto (IN ou NOT IN), inclusive no exemplo da explicação do
in ou not in foi demonstrado justamente a maneira que de implementá-lo para se comportar tal
como o operador de DIFERENÇA, mas claramente o conectivo in não se limita apenas a isso.
SELECT P.nome
FROM pessoa P, trabalha T
WHERE P.cdPessoa = T.cdPessoa AND T.cdEmpresa=3 AND P.cdPessoa NOT IN (
SELECT S1.cdPessoa
FROM trabalha S1, trabalha S2
WHERE S1.cdEmpresa=3 AND S2.cdEmpresa=3 AND S1.salario > S2.salario
)
A transcrição acima apesar de não ser direta é perfeita em relação a solução em Álgebra
Relacional, mas é preciso reconhecer que a solução, tanto na Álgebra Relacional como no SQL não
são “tão” intuitivas. Agora, com o estudo de todas as possibilidades de consultas SQL é possível
desenvolver uma solução bem “mais” intuitiva, conforme mostrado abaixo:
SELECT P.nome
FROM pessoa P, trabalha T
WHERE P.cdPessoa = T.cdPessoa AND T.cdEmpresa=3 AND T.SALARIO <= ALL (
SELECT salario
FROM trabalha
WHERE cdEmpresa = 3
)
Esta consulta resolve o problema de forma “elegante” pois ela verifica quem tem o salário
menor ou igual a todos (<= ALL) os trabalhadores da empresa 3 ; Uma outra forma, talvez não tão
eficiente, mas intuitivamente melhor é usando função agregada, tal como mostrado abaixo:
SELECT P.nome
FROM pessoa P, trabalha T
WHERE T.cdPessoa = P.cdPessoa AND T.cdEmpresa = 3 AND T.salario = (
SELECT MIN(T1.salario)
FROM Trabalha T1
WHERE T1.cdEmpresa = 3
)

21/23
 REVENDO A QUESTÃO 7
7. Consulte todas as empresas (nomes) que funcionam em cidades em que não moram
“Maria”
Apesar de já termos dado uma boa solução, é fácil observar que é possível uma solução usando
verificação de conjuntos, então a título de exemplificação coloco uma outra possível solução, agora
desconectado da Álgebra Relacional e demonstrando melhor a potencialidade do conectivo IN,
conforme abaixo:
SELECT E.nome
FROM empresa E
WHERE E.cidade NOT IN (
SELECT cidade
FROM pessoa
WHERE nome LIKE "%Carla%"
)

2.10 Atividade de Fixação

Explorando o mesmo schema da atividade exemplo anterior, desenvolva as seguintes
consultas usando os recursos do SQL
1. Retorne as pessoas que possuam seu nome as letras “T” ou “Y”, a consulta deve
exibir o nome e o salário e o nome da empresa que trabalham, ordene a resposta
por nome
2. Retorne quais empresas se localizam na mesma cidade aonde mora o “Gibson”
3. Retorne o nome da Empresa que possua o trabalhador com o maior salário no
Banco de Dados, exibindo também o valor deste salário.
4. Refaça a questão 1 retornando as pessoas que possuam seu nome as letras “T” ou
“Y”, retornando o nome e caso algum deles trabalhe em mais de uma empresa
deve ser exibido somente o nome empresa principal (a qual ele possua o maior
salário), com seu respectivo salário.
5. Qual a pessoa que possui o maior salário do Banco de Dados, informe o nome da
pessoa e o valor do salário em questão e qual o nome da empresa.
6. Retorne o Maior Salário o Menor Salário e a Média de Salários para cada empresa
ordene o resultado pelo Maior Salário para o Menor Salário. Formate a média para
que tenha somente 2 casas decimais*.
*Verifique as funções matemáticas do mysql: https://dev.mysql.com/doc/refman/8.0/en/mathematical-functions.html

7. Quais os nomes dos funcionários (nome das pessoas) que são subordinadas ao
Jonathan (chefe)
8. Mostre quantos subordinados cada chefia possui, a consulta deverá exibir o nome
do Chefe e a quantidade de pessoas subordinadas (Count)

22/23
9. Verifique o total de funcionários por empresa, a consulta deverá retornar o nome da
empresa e o total de funcionários ordene o resultado pelo Total de Funcionários do
menor para o maior.
10. Qual empresa possui a maior quantidade de funcionários, a consulta deverá exibir
o nome da empresa e o total de funcionários que a mesma possua.
11. Quais pessoas trabalham em mais de uma empresa, a consulta deve informar o
nome da pessoa o salário total (soma dos salários das empresas em que trabalha)
e a quantidades empresas que ele trabalha, ordene o resultado por nome.

23/23