Escolar Documentos
Profissional Documentos
Cultura Documentos
Sumrio
1 Objetivos do curso 1
1.1 O que realmente importante? 1
1.2 Sobre os exerccios 1
1.3 Tirando dvidas e indo alm 2
2 Meu problema 3
2.1 Criando o nosso banco de dados 5
2.2 Comeando um caderno novo: criando o banco 5
2.3 O padro utilizado neste curso 6
2.4 A tabela de compras 6
2.5 Conferindo a existncia de uma tabela 8
2.6 Inserindo registros no banco de dados 9
2.7 Seleco simples 10
2.8 A formatao de nmeros decimais 10
2.9 A chave primria 11
2.10 Recriando a tabela do zero 13
2.11 Consultas com filtros 14
2.12 Modelando tabelas 19
2.13 Resumindo 21
2.14 Exerccios 21
11 Sub-queries 94
11.1 Resumindo 101
Verso: 19.4.23
CAPTULO 1
OBJETIVOS DO CURSO
que o aluno saia apto a utilizar qualquer sistema de banco de dados relacional (exemplos:
MySQL, Oracle, PostgreSQL, SQL Server). Para isso usamos sempre que possvel o padro
SQL que todos eles aceitam. Para acompanhar a apostila sugerimos o MySQL, para que passe
pelos mesmos desafios e solues que encontramos nesse curso. Aps aprender a base a todos
eles, estudar detalhes especficos de cada banco passa a ser bem mais simples.
Neste curso, separamos essas informaes em quadros especiais, j que so informaes extras. Ou
ento, apenas citamos num exerccio e deixamos para o leitor procurar informaes se for de seu
interesse.
Por fim, falta mencionar algo sobre a prtica, que deve ser tratada seriamente: todos os exerccios so
muito importantes.
O curso
Para aqueles que esto fazendo o curso online no www.alura.com.br, recomendamos estudarem em
casa aquilo que foi visto durante a aula, tentando resolver os exerccios e desafios apresentados.
1 OBJETIVOS DO CURSO 1
Os exerccios do curso variam de prticos at pesquisas na Internet, ou mesmo consultas sobre
assuntos avanados em determinados tpicos para incitar a curiosidade do aprendiz na tecnologia.
Quando terminar essa aventura espero encontr-lo no Alura, onde poder continuar com diversos
outros cursos na rea de desenvolvimento e tecnologia.
http://www.alura.com.br/
Se o que voc est buscando so livros de apoio, sugerimos conhecer a editora Casa do Cdigo:
http://www.casadocodigo.com.br
Como desenvolvedor passei mais de 15 anos procurando exemplos reais de ensino para poder ajudar
meus colegas desenvolvedores que estagiavam na minha equipe, e junto da equipe de instrutores do
Alura, agrupei esses exemplos nesse curso.
Nosso foco aqui mostrar o que um banco de dados relacional, como pensar a modelagem de
nossos dados e como criar, inserir, atualizar e pesquisar informaes em uma base de dados. Tudo isso
usando exemplos do mundo real, nada de abstraes genricas que nos levam a questionar o uso real da
tecnologia no dia a dia.
Como usamos o MySQL como software de banco de dados neste curso, voc poder executar todos
os exemplos na sua mquina em casa mesmo.
MEU PROBLEMA
Chegou o fim do ms e no sei direito onde meu dinheiro foi parar, no meu bolso no est. Nem na
conta bancria. um problema comum, e como podemos fazer para controlar os gastos?
A maneira mais simples de entender onde o dinheiro est indo anotar todos os nossos gastos,
sendo uma das mais tradicionais e antigas escrev-los em um caderninho. Por exemplo dia 05/01/2016
gastei R$ 20 em uma Lanchonete, escrevo isso bonitinho em uma linha.
R$20 05/01/2016 Lanchonete
Tive um outro gasto de lanchonete no dia 06/01/2016 no valor de R$ 15, vou e anoto novamente:
R$20 05/01/2016 Lanchonete
R$15 06/01/2016 Lanchonete
Por fim, minha esposa comprou um guarda-roupa pro quarto e ele ainda no chegou, ento anotei:
R$20 05/01/2016 Lanchonete
R$15 06/01/2016 Lanchonete
R$915,5 06/01/2016 Guarda-roupa (no recebi)
Repara que do jeito que anotei, as linhas acabam se assemelhando a uma tabelinha:
+---------+------------+--------------+--------------+
+ R$20 + 05/01/2016 + Lanchonete + recebida +
+ R$15 + 06/01/2016 + Lanchonete + recebida +
+ R$915,5 + 06/01/2016 + Guarda-roupa + no recebida +
+---------+------------+--------------+--------------+
Mas o que significa a primeira coluna dessa tabela mesmo? O valor gasto? Ok. E a segunda? a data
da compra? E a terceira, o lugar que comprei ou so anotaes relativas aos gastos? Repara que sem dar
nome as colunas, minhas compras ficam confusas, a tabela fica estranha, e posso cada vez preencher com
algo que acho que devo, ao invs de ter certeza do que cada campo significa. Como identificar cada um
deles? Vamos dar um nome aos trs campos que compem a minha tabela: o valor, a data e as
observaes:
+---------+------------+--------------+--------------+
+ valor + data + observacoes + recebida +
+---------+------------+--------------+--------------+
+ R$20 + 05/01/2016 + Lanchonete + recebida +
+ R$15 + 06/01/2016 + Lanchonete + recebida +
+ R$915,5 + 06/01/2016 + Guarda-roupa + no recebida +
+---------+------------+--------------+--------------+
2 MEU PROBLEMA 3
Posso tambm simplificar os dados da coluna recebida somente indicando se ela foi recebida (sim)
ou no (no):
+---------+------------+--------------+--------------+
+ valor + data + observacoes + recebida +
+---------+------------+--------------+--------------+
+ R$20 + 05/01/2016 + Lanchonete + sim +
+ R$15 + 06/01/2016 + Lanchonete + sim +
+ R$915,5 + 06/01/2016 + Guarda-roupa + no +
+---------+------------+--------------+--------------+
Para montar essa tabela em um caderno eu tenho que ser capaz de traar linhas bonitinhas e eu,
pessoalmente, sou horrvel para isso. No mundo tecnolgico de hoje em dia, anotaramos essa tabela em
uma planilha eletrnica como o Excel:
Para facilitar o nosso trabalho, existem softwares para armazenar, guardar os dados. Esses bancos de
dados so sistemas que gerenciam desde a forma de armazenar a informao como tambm como
consult-la de maneira eficiente.
Os chamados Sistema de Gerenciamento de Banco de Dados (SGBD), nos permitem realizar todas
essas tarefas sem nos preocuparmos com o caderninho ou a caneta. Claro que se vamos nos comunicar
com algum que vai gerenciar nossos dados precisamos falar uma lngua comum, conversar em uma
linguagem padro que vrios bancos utilizem.
Um padro que surgiu para acessarmos e pesquisarmos dados armazenados e estruturados de uma
forma especfica uma linguagem de consultas estruturadas, Structured Query Language, ou
simplesmente SQL. Para conseguirmos utilizar essa linguagem, precisamos instalar um SGBD que ser o
nosso servidor de banco de dados, como por exemplo o MySQL, Oracle ou SQLServer.
4 2 MEU PROBLEMA
Neste curso utilizaremos o MySQL, um SGBD gratuito que pode ser instalado seguindo as maneiras
tradicionais de cada sistema operacional. Por exemplo, no Windows, o processo realizado atravs do
download de um arquivo .msi, enquanto no Linux (verses baseadas em Debian), pode ser feito atravs
de um simples comando apt-get, e no MacOS pode ser instalado com um pacote .dmg. Baixe o seu
instalador em http://dev.mysql.com/downloads/mysql/
Abra o terminal do seu sistema operacional. No Windows, digite cmd no Executar. No Mac e Linux,
abra o terminal. Nele, vamos entrar no MySQL usando o usurio root:
mysql -uroot -p
O -u indica o usurio root , e o -p porque digitaremos a senha. Use a senha que definiu
durante a instalao do MySQL, note que por padro a senha pode ser em branco e, nesse caso, basta
pressionar enter.
Acontece que em geral precisamos notificar o MySQL que o comando que desejamos j foi digitado
por completo. Para fazer isso usamos o caractere ponto e vrgula (;):
Da mesma maneira que criamos esse banco, no uma regra, mas comum ter um banco de dados
para cada projeto. Por exemplo:
mysql> CREATE DATABASE caelum
-> ;
Query OK, 1 row affected (0.01 sec)
Agora que tenho diversos bancos, como posso dizer ao MySQL que queremos usar aquele primeiro
de todos? Quero dizer para ele, por favor, use o banco chamado ControleDeGastos. Usar em ingls,
USE, portanto:
mysql> USE ControleDeGastos;
Database changed
Ok. Quero colocar a minha primeira anotao no banco. Mas se o banco o caderno... como que o
Ento vamos fazer a mesma coisa com o banco. Vamos dizer a ele que queremos ter uma tabela:
descrevemos a estrutura dela atravs de um comando SQL. Nesse comando devemos dizer quais so os
campos (valor, data e observaes) que sero utilizados, para que ele separe o espao especfico para cada
um deles toda vez que inserimos uma nova compra, toda vez que registramos um novo dado (um
registro novo).
Para criar uma tabela, novamente falamos ingls, por favor senhor MySQL, crie uma tabela ( CREATE
TABLE ) chamada compras:
Como assim erro 1113? Logo aps o cdigo do erro, o banco nos informou que toda tabela deve
conter pelo menos uma coluna. Verdade, no falei as colunas que queria criar. Vamos olhar novamente
nossas informaes:
+---------+------------+--------------+--------------+
+ valor + data + observacoes + recebida +
+---------+------------+--------------+--------------+
+ R$20 + 05/01/2016 + Lanchonete + sim +
+ R$15 + 06/01/2016 + Lanchonete + sim +
+ R$915,5 + 06/01/2016 + Guarda-roupa + no +
+ ... + ... + ... + ... +
+---------+------------+--------------+--------------+
A estrutura da tabela bem clara: so 4 campos distintos, valor que um nmero com ponto
decimal, data uma data, observaes que um texto livre e recebida que ou sim ou no.
Portanto vamos dizer ao banco que queremos esses 4 campos na nossa tabela, com uma nica
ressalva, que para evitar problemas de encoding usamos sempre nomes que usam caracteres simples,
nada de acento para os nomes de nossas tabelas e colunas:
mysql> CREATE TABLE compras(
valor,
data,
observacoes,
recebida);
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your M
ySQL server version for the right syntax to use near '
data,
observacoes,
recebida)' at line 2
Ainda no foi dessa vez. Repara que o erro 1064 indica um erro de sintaxe no comando CREATE
TABLE. Na verdade o banco de dados est interessado em saber qual o tipo de cada campo e justamente
por isso devemos explicar campo a campo qual o tipo de cada coluna nossa. A coluna, campo, valor
recebe um valor com possveis casas decimais. Para isso podemos usar um tipo que representa nmeros
valor DECIMAL(18,2),
A coluna observaes um texto livre, que costuma ser chamado por um conjunto varivel de
caracteres, por isso VARCHAR. Assim como no caso do nmero decimal, devemos falar o tamanho
mximo dessa coluna. No nosso caso sero at 255 caracteres:
observacoes VARCHAR(255),
Por fim chegamos a coluna recebida, que deve ser representada com valores do tipo verdadeiro ou
falso, algo como sim ou no. No padro de banco relacionais no existe um campo que aceite os valores
verdadeiro e falso, um campo booleano. O que fazemos ento utilizar um campo numrico com os
valores 0 para representar o negativo e 1 para o caso positivo. Uma coluna com um numerozinho, um
TINYINT:
recebida TINYINT
+---------+------------+--------------+----------+
+ valor + data + observacoes + recebida +
+---------+------------+--------------+----------+
+ R$20 + 05/01/2016 + Lanchonete + 1 +
+ R$15 + 06/01/2016 + Lanchonete + 1 +
+ R$915,5 + 06/01/2016 + Guarda-roupa + 0 +
+ ... + ... + ... + ... +
+---------+------------+--------------+----------+
Agora que j sabemos como declarar cada campo, vamos a nova tentativa de criar nossa tabela:
mysql> CREATE TABLE compras(
valor DECIMAL(18,2),
data DATE,
observacoes VARCHAR(255),
recebida TINYINT);
Query OK, 0 rows affected (0.04 sec)
E a est nossa tabela de compras. Ela possui 4 colunas, que so chamados de campos (fields). Cada
campo de um tipo diferente (decimal, date, varchar e tinyint) e possui at mesmo informaes extras
que utilizaremos no decorrer do curso!
No vamos cometer o mesmo erro da ltima vez. Se desejamos fazer algo com os 4 campos da tabela,
temos que falar os valores que desejamos adicionar. Por exemplo, vamos pegar as informaes da
primeira linha da planilha:
Ento ns temos uma compra com valor 20, observao Lanchonete, data 05/01/2016, e que foi
recebida com sucesso (1):
mysql> INSERT INTO compras VALUES (20, 'Lanchonete', '05/01/2016', 1);
ERROR 1292 (22007): Incorrect date value: 'Lanchonete' for column 'data' at row 1
Parece que nosso sistema pirou. Ele achou que a Lanchonete era a data. Lanchonete era o campo
observacoes. Mas... como ele poderia saber isso? Eu no mencionei para ele a ordem dos dados, ento ele
assumiu uma ordem determinada, uma ordem que eu no prestei ateno, mas foi fornecida quando
executamos o DESC compras :
| valor | decimal(18,2) | YES | | NULL | |
| data | date | YES | | NULL | |
| observacoes | varchar(255) | YES | | NULL | |
| recebida | tinyint(4) | YES | | NULL | |
Outro erro? Agora ele est dizendo que o valor para data est incorreto, porm, aqui no Brasil,
usamos esse formato para datas... O que faremos agora? Que tal tentarmos utilizar o formato que j vem
Vamos tentar mais uma vez, porm, dessa vez, com a data '2016-01-05':
mysql> INSERT INTO compras VALUES (20, '2016-01-05', 'Lanchonete', 1);
Query OK, 1 row affected (0.01 sec)
Agora sim os dados foram inseridos com sucesso. Temos um novo registro em nossa tabela. Mas
porque ser que o MySQL adotou o formato ano-ms-dia ao invs de dia/ms/ano ? O formato
ano-ms-dia utilizado pelo padro SQL, ou seja, por questes de padronizao, ele o formato mais
adequado para que funcione para todos.
Perfeito! Registro inserido e selecionado com sucesso. Hora de revisar um errinho que deixamos
para trs.
E a segunda linha:
mysql> INSERT INTO compras VALUES (915,5, '2016-01-06', 'Guarda-roupa', 0);
ERROR 1136 (21S01): Column count doesn't match value count at row 1
A vrgula apareceu 4 vezes, portanto teramos 5 campos diferentes! Repare que o valor 915,5 est
formatado no estilo portugus do Brasil, diferente do estilo ingls americano, que usa ponto para definir
o valor decimal, como em 915.5 . Alteramos e executamos:
mysql> INSERT INTO compras VALUES (915.5, '2016-01-06', 'Guarda-roupa', 0);
Query OK, 1 row affected (0.00 sec)
Podemos conferir os 3 registros que inserimos atravs do SELECT que fizemos antes:
Mas e se eu quisesse inserir os dados em uma ordem diferente? Por exemplo, primeiro informar a
data , depois as observacoes , valor , e por fim se foi recebida ou no? Ser que podemos fazer
isso? Quando estamos fazendo um INSERT , podemos informar o que estamos querendo inserir por
meio de parnteses:
Note que agora estamos informando explicitamente a ordem dos valores que informaremos aps a
instruo VALUES :
A nossa compra foi inserida corretamente, porm com uma ordem diferente da estrutura da tabela.
Fica difcil falar sobre um registro se eu no tenho nada identificando ele de maneira nica. Por
exemplo, como voc sabe que eu sou o Guilherme, e no o Paulo? Pois meu CPF um identificador
nico, (por exemplo) 222.222.222-22. S eu tenho esse CPF e ele me identifica. O Paulo tem o dele,
333.333.333-33.
O mesmo vale para computadores de uma marca, por exemplo, o meu tem nmero de srie
16X000015, e o computador que est ao lado do meu tem o nmero de srie 16X000016. A nica
maneira de identificar unicamente uma coisa tendo uma chave importantssima, uma chave que to
importante, que primria aos brasileiros, aos computadores... e as minhas compras.
Mas como definir esses nmeros nicos? Devo usar o ano de fabricao como no caso do
computador que comea com 16 (ano 2016)? Ou sequencias com nmeros diferentes como no caso do
CPF?
Existem diversas maneiras de gerar esses nmeros nicos, mas a mais simples de todas : comea
com 1. A primeira compra a compra 1. A segunda compra a 2. A terceira a 3. Uma sequencia
natural, que incrementada automaticamente a cada nova compra, a cada novo registro.
isso que queremos, um campo que seja nossa chave primria ( PRIMARY KEY ), que um nmero
inteiro ( INT ), e que seja automaticamente incrementado ( AUTO_INCREMENT ). S falta definir o nome
dele, que como identifica nossa compra, usamos a abreviao id . Esse um padro amplamente
utilizado. Portanto queremos um campo id INT AUTO_INCREMENT PRIMARY KEY .
Para fazer isso vamos alterar nossa tabela ( ALTER_TABLE ) e adicionar uma coluna nova
( ADD_COLUMN ):
mysql> ALTER TABLE compras ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY;
Query OK, 0 rows affected (0.07 sec)
Records: 0 Duplicates: 0 Warnings: 0
Opa, como a tabela j existe no faz sentido recri-la. Primeiro vamos jogar ela fora ( DROP ),
inclusive com todos os dados que temos:
DROP TABLE compras;
timo! Conseguimos limpar a nossa tabela, agora podemos reenserir nossos dados novamente:
Ops, agora a nossa tabela no tem apenas 4 colunas como antes, inclumos o id tambm, vejamos
a descrio da tabela compras :
mysql> desc compras;
+-------------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+---------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| valor | decimal(18,2) | YES | | NULL | |
| data | date | YES | | NULL | |
| observacoes | varchar(255) | YES | | NULL | |
| recebida | tinyint(4) | YES | | NULL | |
+-------------+---------------+------+-----+---------+----------------+
5 rows in set (0,00 sec)
Agora sim a nossa compra foi cadastrada! Porm, tem algo um pouco estranho, e o id ? Ser que foi
inserido tambm? Vejamos:
mysql> SELECT * FROM compras;
+----+-------+------------+-------------+----------+
| id | valor | data | observacoes | recebida |
+----+-------+------------+-------------+----------+
| 1 | 20.00 | 2016-01-05 | Lanchonete | 1 |
+----+-------+------------+-------------+----------+
1 row in set (0,00 sec)
Ele foi inserido automaticamente! Mas como isso aconteceu? Lembra que definimos o id como
AUTO_INCREMENT ? Aquela propriedade que incrementa automaticamente a cada insero. Ento,
exatamente ela que incrementou o id pra ns! Agora basta apenas inserir as demais compras e verificar
o resultado:
mysql> INSERT INTO compras (valor, data, observacoes, recebida)
VALUES (15, '2016-01-06', 'Lanchonete', 1);
Query OK, 1 row affected (0,00 sec)
Agora todas as compras foram registradas no nosso banco de dados! Vamos consultar todas as
compras novamente:
mysql> SELECT * FROM compras;
+----+----------+------------+------------------------------+----------+
| id | valor | data | observacoes | recebida |
+----+----------+------------+------------------------------+----------+
| 1 | 20.00 | 2016-01-05 | Lanchonete | 1 |
| 2 | 15.00 | 2016-01-06 | Lanchonete | 1 |
| 3 | 915.50 | 2016-01-06 | Guarda-roupa | 0 |
| 4 | 949.99 | 2016-01-10 | Smartphone | 0 |
| 5 | 200.00 | 2012-02-19 | Material escolar | 1 |
| 6 | 3500.00 | 2012-05-21 | Televisao | 0 |
| 7 | 1576.40 | 2012-04-30 | Material de construcao | 1 |
| 8 | 163.45 | 2012-12-15 | Pizza pra familia | 1 |
| 9 | 4780.00 | 2013-01-23 | Sala de estar | 1 |
| 10 | 392.15 | 2013-03-03 | Quartos | 1 |
| 11 | 1203.00 | 2013-03-18 | Quartos | 1 |
| 12 | 402.90 | 2013-03-21 | Copa | 1 |
| 13 | 54.98 | 2013-04-12 | Lanchonete | 0 |
| 14 | 12.34 | 2013-05-23 | Lanchonete | 0 |
| 15 | 78.65 | 2013-12-04 | Lanchonete | 0 |
| 16 | 12.39 | 2013-01-06 | Sorvete no parque | 0 |
| 17 | 98.12 | 2013-07-09 | Hopi Hari | 1 |
| 18 | 2498.00 | 2013-01-12 | Compras de janeiro | 1 |
| 19 | 3212.40 | 2013-11-13 | Compras do mes | 1 |
| 20 | 223.09 | 2013-12-17 | Compras de natal | 1 |
| 21 | 768.90 | 2013-01-16 | Festa | 1 |
| 22 | 827.50 | 2014-01-09 | Festa | 1 |
| 23 | 12.00 | 2014-02-19 | Salgado no aeroporto | 1 |
| 24 | 678.43 | 2014-05-21 | Passagem pra Bahia | 1 |
| 25 | 10937.12 | 2014-04-30 | Carnaval em Cancun | 1 |
| 26 | 1501.00 | 2014-06-22 | Presente da sogra | 0 |
| 27 | 1709.00 | 2014-08-25 | Parcela da casa | 0 |
| 28 | 567.09 | 2014-09-25 | Parcela do carro | 0 |
| 29 | 631.53 | 2014-10-12 | IPTU | 1 |
| 30 | 909.11 | 2014-02-11 | IPVA | 1 |
| 31 | 768.18 | 2014-04-10 | Gasolina viagem Porto Alegre | 1 |
| 32 | 434.00 | 2014-04-01 | Rodeio interior de Sao Paulo | 0 |
| 33 | 115.90 | 2014-06-12 | Dia dos namorados | 0 |
| 34 | 98.00 | 2014-10-12 | Dia das crianas | 0 |
| 35 | 253.70 | 2014-12-20 | Natal - presentes | 0 |
| 36 | 370.15 | 2014-12-25 | Compras de natal | 0 |
| 37 | 32.09 | 2015-07-02 | Lanchonete | 1 |
| 38 | 954.12 | 2015-11-03 | Show da Ivete Sangalo | 1 |
| 39 | 98.70 | 2015-02-07 | Lanchonete | 1 |
| 40 | 213.50 | 2015-09-25 | Roupas | 0 |
| 41 | 1245.20 | 2015-10-17 | Roupas | 0 |
| 42 | 23.78 | 2015-12-18 | Lanchonete do Z | 1 |
| 43 | 576.12 | 2015-09-13 | Sapatos | 1 |
| 44 | 12.34 | 2015-07-19 | Canetas | 0 |
| 45 | 87.43 | 2015-05-10 | Gravata | 0 |
| 46 | 887.66 | 2015-02-02 | Presente para o filhao | 1 |
+----+----------+------------+------------------------------+----------+
46 rows in set (0,00 sec)
A nossa consulta devolveu todas as nossas compras, mas eu quero saber a data de todas as compras
Verificamos as compras mais baratas, mas e para verificar as compras mais caras? Por exemplo, com
valor acima de 1500? Usamos o WHERE novamente indicando que agora queremos valores acima de
1500:
mysql> SELECT * FROM compras WHERE valor > 1500;
+----+----------+------------+------------------------+----------+
| id | valor | data | observacoes | recebida |
+----+----------+------------+------------------------+----------+
| 6 | 3500.00 | 2012-05-21 | Televisao | 0 |
| 7 | 1576.40 | 2012-04-30 | Material de construcao | 1 |
| 9 | 4780.00 | 2013-01-23 | Sala de estar | 1 |
| 18 | 2498.00 | 2013-01-12 | Compras de janeiro | 1 |
| 19 | 3212.40 | 2013-11-13 | Compras do mes | 1 |
| 25 | 10937.12 | 2014-04-30 | Carnaval em Cancun | 1 |
| 26 | 1501.00 | 2014-06-22 | Presente da sogra | 0 |
| 27 | 1709.00 | 2014-08-25 | Parcela da casa | 0 |
+----+----------+------------+------------------------+----------+
8 rows in set (0,00 sec)
Sabemos todas as compras mais caras, porm eu s quero saber todas compras mais caras e que no
foram entregues ao mesmo tempo. Para isso precisamos adicionar mais um filtro, ou seja, filtrar por
compras acima de 1500 e tambm que no foram entregues:
mysql> SELECT * FROM compras WHERE valor > 1500 AND recebida = 0;
+----+---------+------------+-------------------+----------+
Agora que podemos utilizar mais de um filtro vamos verificar todas as compras mais baratas (abaixo
de 500) e mais caras (acima de 1500):
mysql> SELECT * FROM compras WHERE valor < 500 AND valor > 1500;
Empty set (0,00 sec)
Parece que no funcionou adicionar mais de um filtro para a mesma coluna... Vamos analisar um
pouco a nossa query, ser que realmente est fazendo sentido esse nosso filtro? Observe que estamos
tentando pegar compras que tenham o valor abaixo de 500 e ao mesmo tempo tenha um valor acima de
1500. Se o valor for 300 abaixo de 500, porm no acima de 1500, se o valor for 1800 acima de 1500,
porm no abaixo de 500, ou seja, impossvel que esse filtro seja vlido. Podemos fazer um pequeno
ajuste nesse filtro, podemos indicar que queremos valores que sejam menores que 500 ou maiores que
1500:
mysql> SELECT * FROM compras WHERE valor < 500 OR valor > 1500;
+----+----------+------------+------------------------------+----------+
| id | valor | data | observacoes | recebida |
+----+----------+------------+------------------------------+----------+
| 1 | 20.00 | 2016-01-05 | Lanchonete | 1 |
| 2 | 15.00 | 2016-01-06 | Lanchonete | 1 |
| 5 | 200.00 | 2012-02-19 | Material escolar | 1 |
| 6 | 3500.00 | 2012-05-21 | Televisao | 0 |
| 7 | 1576.40 | 2012-04-30 | Material de construcao | 1 |
| 8 | 163.45 | 2012-12-15 | Pizza pra familia | 1 |
| 9 | 4780.00 | 2013-01-23 | Sala de estar | 1 |
| 10 | 392.15 | 2013-03-03 | Quartos | 1 |
| 12 | 402.90 | 2013-03-21 | Copa | 1 |
| 13 | 54.98 | 2013-04-12 | Lanchonete | 0 |
| 14 | 12.34 | 2013-05-23 | Lanchonete | 0 |
| 15 | 78.65 | 2013-12-04 | Lanchonete | 0 |
| 16 | 12.39 | 2013-01-06 | Sorvete no parque | 0 |
| 17 | 98.12 | 2013-07-09 | Hopi Hari | 1 |
| 18 | 2498.00 | 2013-01-12 | Compras de janeiro | 1 |
| 19 | 3212.40 | 2013-11-13 | Compras do mes | 1 |
| 20 | 223.09 | 2013-12-17 | Compras de natal | 1 |
| 23 | 12.00 | 2014-02-19 | Salgado no aeroporto | 1 |
| 25 | 10937.12 | 2014-04-30 | Carnaval em Cancun | 1 |
| 26 | 1501.00 | 2014-06-22 | Presente da sogra | 0 |
| 27 | 1709.00 | 2014-08-25 | Parcela da casa | 0 |
| 32 | 434.00 | 2014-04-01 | Rodeio interior de Sao Paulo | 0 |
| 33 | 115.90 | 2014-06-12 | Dia dos namorados | 0 |
| 34 | 98.00 | 2014-10-12 | Dia das crianas | 0 |
| 35 | 253.70 | 2014-12-20 | Natal - presentes | 0 |
| 36 | 370.15 | 2014-12-25 | Compras de natal | 0 |
| 37 | 32.09 | 2015-07-02 | Lanchonete | 1 |
| 39 | 98.70 | 2015-02-07 | Lanchonete | 1 |
| 40 | 213.50 | 2015-09-25 | Roupas | 0 |
| 42 | 23.78 | 2015-12-18 | Lanchonete do Z | 1 |
| 44 | 12.34 | 2015-07-19 | Canetas | 0 |
| 45 | 87.43 | 2015-05-10 | Gravata | 0 |
Perceba que agora temos todas as compras que possuem valores abaixo de 500 e acima de 1500.
Suponhamos que fizemos uma compra com um valor especfico, por exemplo 3500, e queremos saber
apenas as compras que tiveram esse valor. O filtro que queremos utilizar o igual ao valor desejado:
mysql> SELECT * FROM compras WHERE valor = 3500;
+----+---------+------------+-------------+----------+
| id | valor | data | observacoes | recebida |
+----+---------+------------+-------------+----------+
| 6 | 3500.00 | 2012-05-21 | Televisao | 0 |
+----+---------+------------+-------------+----------+
1 row in set (0,00 sec)
Conseguimos realizar vrias queries com muitos filtros, porm, eu quero saber dentre as compras
realizadas, quais foram em Lanchonete. Ento vamos verificar todas as observaes que sejam iguais a
Lanchonete:
mysql> SELECT * FROM compras WHERE observacoes = 'Lanchonete';
+----+-------+------------+-------------+----------+
| id | valor | data | observacoes | recebida |
+----+-------+------------+-------------+----------+
| 1 | 20.00 | 2016-01-05 | Lanchonete | 1 |
| 2 | 15.00 | 2016-01-06 | Lanchonete | 1 |
| 13 | 54.98 | 2013-04-12 | Lanchonete | 0 |
| 14 | 12.34 | 2013-05-23 | Lanchonete | 0 |
| 15 | 78.65 | 2013-12-04 | Lanchonete | 0 |
| 37 | 32.09 | 2015-07-02 | Lanchonete | 1 |
| 39 | 98.70 | 2015-02-07 | Lanchonete | 1 |
+----+-------+------------+-------------+----------+
7 rows in set (0,00 sec)
Agora preciso saber todas as minhas compras que foram Parcelas. Ento novamente eu usarei o
mesmo filtro, porm para Parcelas:
Que estranho eu lembro de ter algum registro de parcela... Sim, existem registros de parcelas, porm
no existe apenas uma observao "Parcela" e sim "Parcela do carro" ou "Parcela da casa", ou seja,
precisamos filtrar as observaes verificando se existe um pedao do texto que queremos na coluna
desejada. Para verificar um pedao do texto utilizamos o argumento LIKE :
mysql> SELECT * FROM compras WHERE observacoes LIKE 'Parcela%';
+----+---------+------------+------------------+----------+
| id | valor | data | observacoes | recebida |
+----+---------+------------+------------------+----------+
| 27 | 1709.00 | 2014-08-25 | Parcela da casa | 0 |
| 28 | 567.09 | 2014-09-25 | Parcela do carro | 0 |
+----+---------+------------+------------------+----------+
2 rows in set (0,00 sec)
Perceba que utilizamos o "%". Quando adicionamos o "%" durante um filtro utilizando o LIKE
significa que queremos todos os registros que iniciem com Parcela e que tenha qualquer tipo de
Veja que agora foram devolvidas todas as compras que possuem um "DE" na coluna observacoes
independente de onde esteja.
Compra
==> tem um valor, com casas decimais
==> tem uma data
==> tem uma observao, texto
==> pode ter sido recebida ou no
E existem diversas maneiras de representar tal modelo atravs de diagramas. Nosso foco maior aqui
ser em pensarmos o modelo e como trabalharmos com o SQL, por isso no nos preocuparemos tanto
com criar centenas de diagramas.
Aps definirmos os campos importantes para nosso negcio, nossa empresa (o business),
percebemos que era necessrio identificar cada compra de maneira nica, e para isso definimos uma
chave primria, o id.
Tenho um novo cliente em minha empresa de desenvolvimento de software e este cliente uma
escola primria. Ela tem alunos bem novos e precisa manter um banco com as informaes deles para
Pronto, apresento o modelo do meu banco para o cliente e ele reclama muito. A diretora comenta
que quando tem que se comunicar a respeito do aluno no o telefone ou email dele que ela precisa. Ela
precisa conversar com os pais e por isso necessrio os campos de contato dos pais. Alteramos ento
nosso modelo:
Aluno
- id
- nome
- serie
- sala
- email
- telefone
- endereco
- nomeDoPai
- nomeDaMae
- telefoneDoPai
- telefoneDaMae
Um outro detalhe que sumiu a questo da vacinao. A diretora gosta de conversar com os pais
para indicar quando poca de vacinao. Ela sabe da importncia do efeito de vacinao em grupo
(todos devem ser vacinados, se um no , existe chance de infectar muitos). Por isso ela sempre envia
cartas (campo endereco) para os pais (campo nomeDoPai e nomeDaMae). Mas... como saber qual
vacina ele precisa tomar? Depende da idade, sugerimos ento armazenar a data de nascimento do aluno:
Aluno
- id
- nascimento
- nome
- serie
- sala
- email
- telefone
- endereco
- nomeDoPai
- nomeDaMae
- telefoneDoPai
- telefoneDaMae
Alm disso, ela comenta que este ano o aluno est na terceira srie, mas ano que vem estar na
quarta srie! Tanto a srie quanto a sala so valores que mudam anualmente, e precisamos atualiz-los
sempre, quase que todos os alunos tem sua srie e sala atualizadas de uma vez s (algumas escolas
permitem a troca de salas no meio do ano letivo). Para deixar isso claro, alteramos nossos campos,
Esse nosso processo de criar, de moldar, de modelar uma tabela o que chamamos de modelagem de
dados. Na verdade estamos modelando a estrutura que ser capaz de receber os dados. E no existem
regras 100% fixas nesse processo, por isso mesmo importantssimo levantarmos as necessidades, os
requisitos dos nossos clientes junto a eles. Conversando com eles, vendo o trabalho deles no dia a dia,
entendemos o que eles precisam e como modelar essas informaes no banco. E mesmo tendo modelado
uma vez, pode ser que daqui um ano temos que evoluir nosso modelo.
2.13 RESUMINDO
Ns aprendemos a criar um banco de dados, criar tabelas como as planilhas do Excel e agora estamos
aprendendo a manipular informaes fazendo filtro com WHERE , AND , OR e LIKE . Vamos para os
exerccios?
2.14 EXERCCIOS
1. Instale o servidor do MySQL em sua mquina. Qual o sistema operacional em que voc fez sua
instalao? Sentiu que algo podia ser simplificado no processo de instalao? Lembre-se que voc
pode realizar o download de ambos em http://MySQL.com/downloads/MySQL.
mysql -uroot -p
CREATE DATABASE ControleDeGastos;
USE ControleDeGastos;
Agora vamos criar a tabela. Ela precisa ter os seguintes campos: id inteiro, valor nmero com
vrgula, data , observacoes e um booleano para marcar se a compra foi recebida . A tabela deve-se
chamar "compras".
2.13 RESUMINDO 21
mysql -u root -p ControleDeGastos < compras.sql
Em seguida, execute o SELECT para garantir que todas as informaoes foram adicionadas:
SELECT * FROM compras;
DICA: Salve o arquivo compras.sql em uma pasta de fcil acesso na linha de comando. Alm
disso, o arquivo deve estar no mesmo lugar onde voc executar o comando.
1. Selecione valor e observacoes de todas as compras cuja data seja maior-ou-igual que
15/12/2012.
2. Qual o comando SQL para juntar duas condies diferentes? Por exemplo, SELECT * FROM
TABELA WHERE campo > 1000 campo < 5000. Faa o teste e veja o resultado.
3. Vimos que todo texto passado atravs de aspas simples ('). Posso passar aspas duplas (") no lugar?
4. Selecione todas as compras cuja data seja maior-ou-igual que 15/12/2012 e menor do que
15/12/2014.
5. Selecione todas as compras cujo valor esteja entre R$15,00 e R$35,00 e a observao comece com a
palavra 'Lanchonete'.
8. Vimos que para guardar o valor VERDADEIRO para a coluna recebida , devemos passar o valor 1.
Para FALSO, devemos passar o valor 0. E quanto as palavras j conhecidas para verdadeiro e falso:
TRUE e FALSE . Elas funcionam? Ou seja:
INSERT INTO compras (valor, data, observacoes, recebida) VALUES (100.0, '2015-09-08', 'COMIDA', TRUE)
;
1. Selecione todas as compras com valor maior que 5.000,00 ou que j foram recebidas.
2. Selecione todas as compras que o valor esteja entre 1.000,00 e 3.000,00 ou seja maior que 5.000,00.
22 2.14 EXERCCIOS
CAPTULO 3
Cadastramos todas as nossas compras no banco de dados, porm, no meu rascunho onde eu coloco
todas as minhas compras alguns valores no esto batendo. Vamos selecionar o valor e a observao de
todas as compras com valores entre 1000 e 2000:
mysql> SELECT valor, observacoes FROM compras
WHERE valor >= 1000 AND valor <= 2000;
+---------+------------------------+
| valor | observacoes |
+---------+------------------------+
| 1576.40 | Material de construcao |
| 1203.00 | Quartos |
| 1501.00 | Presente da sogra |
| 1709.00 | Parcela da casa |
| 1245.20 | Roupas |
+---------+------------------------+
5 rows in set (0,00 sec)
Fizemos um filtro para um intervalo de valor, ou seja, entre 1000 e 2000. Em SQL, quando queremos
filtrar um intervalo, podemos utilizar o operador BETWEEN :
O resultado o mesmo que a nossa query anterior, porm agora est mais clara e intuitura.
No meu rascunho informa que a compra foi no ano de 2013, porm no foi feito esse filtro. Ento
vamos adicionar mais um filtro pegando o intervalo de 01/01/2013 e 31/12/2013:
mysql> SELECT valor, observacoes FROM compras
WHERE valor BETWEEN 1000 AND 2000
AND data BETWEEN '2013-01-01' AND '2013-12-31';
+---------+-------------+
| valor | observacoes |
+---------+-------------+
| 1203.00 | Quartos |
+---------+-------------+
1 row in set (0,00 sec)
Agora precisamos adicionar o que queremos alterar por meio da instruo SET :
Precisamos sempre tomar cuidado com a instruo UPDATE , pois o exemplo acima executa
normalmente, porm o que ele vai atualizar? No informamos em momento algum qual compra precisa
ser atualizar, ou seja, ele iria atualizar TODAS as compras e no isso que queremos. Antes de executar
o UPDATE , precisamos verificar o id da compra que queremos alterar:
Agora que sabemos qual o id da compra, basta inform-lo por meio da instruo WHERE :
mysql> UPDATE compras SET valor = 1500 WHERE id = 11;
Query OK, 1 row affected (0,01 sec)
Rows matched: 1 Changed: 1 Warnings: 0
Analisando melhor essa compra eu sei que se refere aos mveis do quarto, mas uma observao
como "Quartos" que dizer o que? No clara o suficiente, pode ser que daqui a 6 meses, 1 ano ou mais
tempo eu nem saiba mais o que se refere essa observao e vou acabar pensando: "Ser que eu comprei
mveis ou comprei um quarto todo?". Um tanto confuso... Ento vamos alterar tambm as observaes e
deixar algo mais claro, como por exemplo: "Reforma de quartos".
UPDATE compra SET observacoes = 'Reforma de quartos' WHERE id = 11;
E o resultado:
mysql> SELECT valor, observacoes FROM compras WHERE id = 11;
+---------+-------------------------+
| valor | observacoes |
+---------+-------------------------+
| 1500.00 | Reforma de quartos cara |
+---------+-------------------------+
1 row in set (0,00 sec)
Muito cuidado aqui! Diferentemente do WHERE , no caso do SET no utilize o operador AND para
atribuir valores, como no exemplo a seguir, que NO o que queremos:
errado: UPDATE compras SET valor = 1500 AND observacoes = 'Reforma de quartos novos' WHERE id = 8;
certo: UPDATE compras SET valor = 1500, observacoes = 'Reforma de quartos novos' WHERE id = 8;
Descobri o valor atual, agora multiplico por 1.1 para aumentar 10% : 1500 * 1.1 so 1650
reais. Ento atualizo agora manualmente:
UPDATE compras SET valor = 1650 AND observacoes = 'Reforma de quartos novos' WHERE id = 11;
mysql> SELECT valor FROM compras WHERE id > 11 AND id <= 14;
+--------+
| valor |
+--------+
| 402.90 |
| 54.98 |
| 12.34 |
+--------+
3 rows in set (0,00 sec)
E agora? Vou ter que calcular na mo cada um dos casos, com 10% a mais, e fazer uma linha de
UPDATE para cada um? A soluo fazer um nico UPDATE em que digo que quero alterar o valor para
o valor dele mesmo, vezes os meus 1.1 que j queria antes:
UPDATE compras SET valor = valor * 1.1
WHERE id >= 11 AND id <= 14;
Nessa query fica claro que eu posso usar o valor de um campo (qualquer) para atualizar um campo
da mesma linha. No nosso caso usamos o valor original para calcular o novo valor. Mas estou livre para
usar outros campos da mesma linha, desde que faa sentido para o meu problema, claro. Por exemplo, se
eu tenho uma tabela de produtos com os campos precoLiquido eu posso atualizar o precoBruto
quando o imposto mudar para 15%:
UPDATE produtos SET precoBruto = precoLiquido * 1.15;
O DELETE tem o comportamento similar ao UPDATE , ou seja, precisamos sempre tomar cuidado
quando queremos excluir algum registro da tabela. Da mesma forma que fizemos com o UPDATE ,
precisamos adicionar a instruo WHERE para informa o que queremos excluir, justamente para
evitamos a excluso de todos os dados:
3.6 RESUMINDO
Nesse captulo aprendemos como fazer queries por meio de intervalos utilizando o BETWEEN e como
alterar/excluir os dados da nossa tabela utilizando o DELETE e o UPDATE . Vamos para os exerccios?
EXERCCIOS
1. Altere as compras, colocando a observao 'preparando o natal' para todas as que foram efetuadas no
dia 20/12/2014.
2. Altere o VALOR das compras feitas antes de 01/06/2013. Some R$10,00 ao valor atual.
3. Atualize todas as compras feitas entre 01/07/2013 e 01/07/2014 para que elas tenham a observao
'entregue antes de 2014' e a coluna recebida com o valor TRUE.
4. Em um comando WHERE possvel especificar um intervalo de valores. Para tanto, preciso dizer
qual o valor mnimo e o valor mximo que define o intervalo. Qual o operador que usado para
isso?
5. Qual operador voc usa para remover linhas de compras de sua tabela?
7. Existe um operador lgico chamado NOT . Esse operador pode ser usado para negar qualquer
condio. Por exemplo, para selecionar qualquer registro com data diferente de 03/11/2014, pode ser
construdo o seguinte WHERE :
Use o operador NOT e monte um SELECT que retorna todas as compras com valor diferente de R$
108,00.
28 3.6 RESUMINDO
CAPTULO 4
ALTERANDO E RESTRINGINDO O
FORMATO DE NOSSAS TABELAS
Muitas vezes que inserimos dados em um banco de dados, precisamos saber quais so os tipos de dados
de cada coluna da tabela que queremos popular. Vamos dar uma olhada novamente na estrutura da
nossa tabela por meio da instruo DESC :
mysql> DESC compras;
+-------------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+---------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| valor | decimal(18,2) | YES | | NULL | |
| data | date | YES | | NULL | |
| observacoes | varchar(255) | YES | | NULL | |
| recebida | tinyint(4) | YES | | NULL | |
+-------------+---------------+------+-----+---------+----------------+
5 rows in set (0,00 sec)
Como j vimos, o MySQL demonstra algumas caractersticas das colunas da nossa tabela. Vamos
verificar a coluna Null , o que ser que ela significa? Ser que est dizendo que nossas colunas aceitam
valores vazios? Ento vamos tentar inserir uma compra com observacoes vazia, ou seja, nula, com o
valor null:
O nosso banco de dados permitiu o registro de uma compra sem observao. Mas em qual momento
informamos ao MySQL que querimos valores nulos? Em nenhum momento! Porm, quando criamos
uma tabela no MySQL e no informamos se queremos ou no valores nulos para uma determinada
coluna, por padro, o MySQL aceita os valores nulos.
Note que um texto vazio diferente de no ter nada! diferente de um texto vazio como ''. Nulo
Porm, a tabela j existe! E no uma boa prtica excluir a tabela e cria-la novamente, pois podemos
perder registros! Para fazer alteraes na estrutura da tabela, podemos utilizar a instruo ALTER
TABLE que vimos antes:
Precisamos especificar o que queremos fazer na tabela, nesse caso modificar uma coluna e adicionar
uma Constraints:
mysql> ALTER TABLE compras MODIFY COLUMN observacoes VARCHAR(255) NOT NULL;
Query OK, 45 rows affected (0,04 sec)
Records: 45 Duplicates: 0 Warnings: 0
Observe que foram alteradas todas as 45 linhas existentes no nosso banco de dados. Se verificarmos a
estrutura da nossa tabela novamente:
Na coluna Null e na linha das observacoes est informando que no mais permitido valores
nulos. Vamos testar:
mysql> INSERT INTO compras (valor, data, recebida, observacoes)
VALUES (150, '2016-01-04', 1, NULL);
ERROR 1048 (23000): Column 'observacoes' cannot be null
Se quisemos informar que o valor padro deveria ser entregue, bastaria utilizar o mesmo comando,
porm modificando o 0 para 1.
Alm disso, depois de um ano descobrimos um bug no sistema. Alguns alunos sairam do mesmo,
como representar que no existe mais srie atual e nem sala atual para esses alunos? Podemos escolher
trs abordagens:
Repare que o primeiro e o ltimo parecem ser simples de implementar, claramente mais simples que
implementar os dois ao mesmo tempo (item 2). Mas cada um deles implica em um problema de
modelagem diferente.
Se assumimos (1) e colocamos campos serieAtual e salaAtual como NULL, toda vez que queremos
saber quem est inativo temos uma query bem estranha, que no parece fazer isso:
Srio mesmo? Isso significa que o aluno est inativo? Dois nulos? Alm disso, se eu permito nulos, eu
posso ter um caso muito estranho como o aluno a seguir:
Guilherme Silveira, seriaAtual 8, salaAtual null
Como assim? um aluno novo que algum/o sistema esqueceu de colocar a sala? Ou um aluno
antigo que algum/o sistema esqueceu de remover a srie?
Por outro lado, na terceira abordagem, a do campo ativo, solto, gera um possvel aluno como:
Como assim, o Guilherme est inativo mas est na 8B ao mesmo tempo? Ou ele est na 8B ou no
est, no tem as duas coisas ao mesmo tempo. Modelo estranho.
Poderamos usar recursos bem mais avanados para tentar nos proteger de alguns desses casos, mas
esses recursos so, em geral, especficos de um banco determinado. Por exemplo, funcionam no Oracle
mas no no MySQL. Ou no MySQL mas no no PostgreSQL. Nesse curso focamos em padres do SQL
que conseguimos aplicar, em geral, para todos eles.
E agora? Trs modelagens diferentes, todas resolvem o problema e todas geram outros problemas
tcnicos. Modelar bancos tomar decises que apresentam vantagens e desvantagens. No h regra em
qual das trs solues devemos escolher, escolha a que voc julgar melhor e mais justa para sua
empresa/sistema/ocasio. O mais importante tentar prever os possveis pontos de erro como os
mencionados aqui. Conhecer as falhas em nosso desenho de modelagem (design) de antemo permite
que no tenhamos uma surpresa desagradvel quando descobrirmos elas de uma maneira infeliz no
futuro.
4.5 RESUMINDO
Vimos que alm de criar as tabelas em nosso banco de dados precisamos verificar se alguma coluna
pode receber valores nulos ou no, podemos determinar essas regras por meio de Constraints no
momento da criao da tabela ou utilizando a instruo ALTER TABLE se caso a tabela exista e
queremos modificar sua estrutura. Tambm vimos que em alguns casos os valores de cada INSERT
pode se repetir muito e por isso podemos definir valores padres com a instruo DEFAULT .
EXERCCIOS
1. Configure o valor padro para a coluna recebida .
3. No nosso modelo atual, qual campo voc deixaria com valores DEFAULT e quais no? Justifique sua
deciso. Note que como estamos falando de modelagem, no existe uma regra absoluta, existe
vantagens e desvantagens na deciso que tomar, tente cit-las.
4. NOT NULL e DEFAULT podem ser usados tambm no CREATE TABLE ? Crie uma tabela nova e
adicione Constraints e valores DAFAULT .
4.5 RESUMINDO 33
5. Reescreva o CREATE TABLE do comeo do curso, marcando observacoes como nulo e valor
padro do recebida como 1.
34 4.5 RESUMINDO
CAPTULO 5
J adicionamos muitos dados em nosso banco de dados e seria mais interessante fazermos queries mais
robustas, como por exemplo, saber o total que j gastei. O MySQL fornece a funo SUM() que soma
todos dos valores de uma coluna:
mysql> SELECT SUM(valor) FROM compras;
+------------+
| SUM(valor) |
+------------+
| 43967.91 |
+------------+
1 row in set (0,00 sec)
Podemos tambm, contar quantas compras foram recebidas por meio da funo COUNT() :
SELECT COUNT(*) FROM compras WHERE recebida = 1;
+----------+
| COUNT(*) |
+----------+
| 26 |
+----------+
Agora vamos fazer com que seja retornado a soma de todas as compras recebidas e no recebidas,
porm retornaremos a coluna recebida, ou seja, em uma linha estar as compras recebidas e a sua soma e
em outra as no recebidas e sua soma:
Observe que o resultado no saiu conforme o esperado... Mas por que ser que isso aconteceu?
Quando utilizamos a funo SUM() do MySQL ela soma todos os valores da coluna e retorna apenas
uma nica linha, pois uma funo de agregrao! Para resolvermos esse problema, podemos utilizar a
instruo GROUP BY que indica como a soma precisa ser agrupada, ou seja, some todas as compras
recebidas e agrupe em uma linha, some todas as compras no recebidas e agrupe em outra linha:
mysql> SELECT recebida, SUM(valor) FROM compras GROUP BY recebida;
+----------+------------+
| recebida | SUM(valor) |
+----------+------------+
| 0 | 12281.16 |
| 1 | 31686.75 |
+----------+------------+
2 rows in set (0,00 sec)
O resultado foi conforme o esperado, porm note que o nome da coluna para a soma est um pouco
estranho, pois estamos aplicando uma funo ao invs de retornar uma coluna, seria melhor se o nome
retornado fosse apenas "soma". Podemos nomear as colunas por meio da instruo AS :
mysql> SELECT recebida, SUM(valor) AS soma FROM compras
GROUP BY recebida;
+----------+----------+
| recebida | soma |
+----------+----------+
| 0 | 12281.16 |
| 1 | 31686.75 |
+----------+----------+
2 rows in set (0,00 sec)
Suponhamos uma query mais robusta, onde podemos verificar em qual ms e ano a compra foi
entregue ou no e o valor da soma. Podemos retornar a informao de ano utilizando a funo YEAR()
e a informao de ms utilizando a funo MONTH() :
mysql> SELECT MONTH(data) as mes, YEAR(data) as ano, recebida,
SUM(valor) AS soma FROM compras
GROUP BY recebida;
Lembre-se que estamos lidando com uma funo de agregao! Por isso precisamos informar todas
as colunas que queremos agrupar, ou seja, a coluna de ms e de ano:
mysql> SELECT MONTH(data) as mes, YEAR(data) as ano, recebida,
SUM(valor) AS soma FROM compras
GROUP BY recebida, mes, ano;
+------+------+----------+----------+
| mes | ano | recebida | soma |
+------+------+----------+----------+
| 1 | 2013 | 0 | 12.39 |
| 1 | 2016 | 0 | 2015.49 |
| 4 | 2013 | 0 | 54.98 |
| 4 | 2014 | 0 | 434.00 |
| 5 | 2012 | 0 | 3500.00 |
| 5 | 2013 | 0 | 12.34 |
| 5 | 2015 | 0 | 87.43 |
| 6 | 2014 | 0 | 1616.90 |
| 7 | 2015 | 0 | 12.34 |
| 8 | 2014 | 0 | 1709.00 |
| 9 | 2014 | 0 | 567.09 |
| 9 | 2015 | 0 | 213.50 |
| 10 | 2014 | 0 | 98.00 |
| 10 | 2015 | 0 | 1245.20 |
| 12 | 2013 | 0 | 78.65 |
| 12 | 2014 | 0 | 623.85 |
| 1 | 2013 | 1 | 8046.90 |
| 1 | 2014 | 1 | 827.50 |
| 1 | 2016 | 1 | 35.00 |
| 2 | 2012 | 1 | 200.00 |
| 2 | 2014 | 1 | 921.11 |
| 2 | 2015 | 1 | 986.36 |
| 3 | 2013 | 1 | 795.05 |
| 4 | 2012 | 1 | 1576.40 |
| 4 | 2014 | 1 | 11705.30 |
| 5 | 2014 | 1 | 678.43 |
| 7 | 2013 | 1 | 98.12 |
| 7 | 2015 | 1 | 32.09 |
| 9 | 2015 | 1 | 576.12 |
| 10 | 2014 | 1 | 631.53 |
| 11 | 2013 | 1 | 3212.40 |
| 11 | 2015 | 1 | 954.12 |
| 12 | 2012 | 1 | 163.45 |
| 12 | 2013 | 1 | 223.09 |
| 12 | 2015 | 1 | 23.78 |
+------+------+----------+----------+
35 rows in set (0,00 sec)
Ficou mais fcil de visualizar, s que ainda no conseguimos verificar de uma forma clara a soma de
cada ms durante um ano. Perceba que a instruo ORDER BY prioriza as colunas pela ordem em que
so informadadas, ou seja, quando fizemos:
Informamos que queremos que d prioridade ordenao da coluna ms e as demais colunas sejam
ordenadas de acordo com o ms! Isso significa que para ordenarmos o ano e depois o ms basta apenas
colocar o ano no incio do ORDER BY :
mysql> SELECT MONTH(data) as mes, YEAR(data) as ano, recebida,
SUM(valor) AS soma FROM compras
GROUP BY recebida, mes, ano
ORDER BY ano, mes;
+------+------+----------+----------+
| mes | ano | recebida | soma |
+------+------+----------+----------+
| 2 | 2012 | 1 | 200.00 |
| 4 | 2012 | 1 | 1576.40 |
| 5 | 2012 | 0 | 3500.00 |
| 12 | 2012 | 1 | 163.45 |
| 1 | 2013 | 1 | 8046.90 |
| 1 | 2013 | 0 | 12.39 |
| 3 | 2013 | 1 | 795.05 |
| 4 | 2013 | 0 | 54.98 |
Agora conseguimos verificar de uma forma clara a soma dos meses em cada ano. Alm da soma
podemos tambm utilizar outras funes de agragao como por exemplo, a AVG() que retorna a
mdia de uma coluna:
mysql> SELECT MONTH(data) as mes, YEAR(data) as ano, recebida,
AVG(valor) AS soma FROM compras
GROUP BY recebida, mes, ano
ORDER BY ano, mes;
+------+------+----------+-------------+
| mes | ano | recebida | soma |
+------+------+----------+-------------+
| 2 | 2012 | 1 | 200.000000 |
| 4 | 2012 | 1 | 1576.400000 |
| 5 | 2012 | 0 | 3500.000000 |
| 12 | 2012 | 1 | 163.450000 |
| 1 | 2013 | 0 | 12.390000 |
| 1 | 2013 | 1 | 2682.300000 |
| 3 | 2013 | 1 | 397.525000 |
| 4 | 2013 | 0 | 54.980000 |
| 5 | 2013 | 0 | 12.340000 |
| 7 | 2013 | 1 | 98.120000 |
| 11 | 2013 | 1 | 3212.400000 |
| 12 | 2013 | 1 | 223.090000 |
| 12 | 2013 | 0 | 78.650000 |
| 1 | 2014 | 1 | 827.500000 |
| 2 | 2014 | 1 | 460.555000 |
| 4 | 2014 | 0 | 434.000000 |
| 4 | 2014 | 1 | 5852.650000 |
| 5 | 2014 | 1 | 678.430000 |
| 6 | 2014 | 0 | 808.450000 |
| 8 | 2014 | 0 | 1709.000000 |
5.2 RESUMINDO
Vimos como podemos fazer queries mais robustas e inteligentes utilizando funes de agregao,
como por exemplo, a SUM() para somar e a AVG() para tirar a mdia. Vimos tambm que quando
queremos retornar outras colunas ao utilizar funes de agregao, precisamos utilizar a instruo
GROUP BY para determinar quais sero as colunas que queremos que seja feita o agrupamento e que
nem sempre o resultado vem organizado e por isso, em determinados casos, precisamos utilizar a
instruo ORDER BY para ordenar a nossa query por meio de uma coluna.
EXERCCIOS
1. Calcule a mdia de todas as compras com datas inferiores a 12/05/2013.
2. Calcule a quantidade de compras com datas inferiores a 12/05/2013 e que j foram recebidas.
5.2 RESUMINDO 41
CAPTULO 6
A nossa tabela de compras est bem populada, com muitas informaes das compras realizadas, porm
est faltando uma informao muito importante, que so os compradores. Por vezes foi eu quem
comprou algo, mas tambm o meu irmo pode ter comprado ou at mesmo o meu primo... Como
podemos fazer para identificar o comprador de uma compra? De acordo com o que vimos at agora
podemos adicionar uma nova coluna chamada comprador com o tipo varchar(200) :
timo! Agora podemos adicionar os compradores de cada compra! Mas, antes de adicionarmos
precisamos verificar novamente verificar as informaes das compras e identificar quem foi que
comprou:
mysql> SELECT id, valor, observacoes, data FROM compras;
+----+----------+------------------------------+------------+
| id | valor | observacoes | data |
+----+----------+------------------------------+------------+
| 1 | 20.00 | Lanchonete | 2016-01-05 |
| 2 | 15.00 | Lanchonete | 2016-01-06 |
| 3 | 915.50 | Guarda-roupa | 2016-01-06 |
| 4 | 949.99 | Smartphone | 2016-01-10 |
| 5 | 200.00 | Material escolar | 2012-02-19 |
| 6 | 3500.00 | Televisao | 2012-05-21 |
| 7 | 1576.40 | Material de construcao | 2012-04-30 |
| 8 | 163.45 | Pizza pra familia | 2012-12-15 |
| 9 | 4780.00 | Sala de estar | 2013-01-23 |
| 10 | 392.15 | Quartos | 2013-03-03 |
| 12 | 402.90 | Copa | 2013-03-21 |
| 13 | 54.98 | Lanchonete | 2013-04-12 |
| 14 | 12.34 | Lanchonete | 2013-05-23 |
Agora que j sei as informaes das compras posso adicionar os seus compradores. Comearemos
pelas 5 primeiras compras:
De acordo com as informaes do meu rascunho, a primeira compra fui eu mesmo que comprei:
mysql> UPDATE compras SET comprador = 'Alex Felipe' WHERE id = 1;
Query OK, 1 row affected (0,00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
Vejamos o resultado:
Pensando bem, no foi o meu tio Joo da Silva que comprou Material escolar e sim o meu tio Joo
Vieira, eu devo ter anotado errado... Ento vamos alterar:
mysql> UPDATE compras SET comprador = 'Joo vieira' WHERE comprador = 'Joo da Silva';
Query OK, 2 rows affected (0,01 sec)
Rows matched: 2 Changed: 2 Warnings: 0
Opa! Espera a! O meu tio Joo da Silva sumiu!? E o meu tio Joo Vieira foi inserido com o
sobrenome minsculo... Vamos alterar novamente... Primeiro o nome do Joo Vieira:
mysql> UPDATE compras SET comprador = 'Joo Vieira' WHERE comprador = 'Joo vieira';
Query OK, 2 rows affected (0,01 sec)
Rows matched: 2 Changed: 2 Warnings: 0
Agora vamos reenserir o meu tio Joo da Silva para a compra do guarda-roupa:
Nossa, que trabalheira! Por causa de um errinho eu tive que alterar tudo novamente! Se eu no ficar
atento, com certeza acontecer uma caca gigante no meu banco. Alm disso, eu preciso tambm
adicionar o telefone do comprador para um dia, se for necessrio, entrar em contato! Ento, novamente,
iremos adicionar um coluna nova com o nome telefone e tipo VARCHAR(15) :
mysql> UPDATE compras SET telefone = '5571-2751' WHERE comprador = 'Alex Felipe';
Query OK, 2 rows affected (0,01 sec)
Rows matched: 2 Changed: 2 Warnings: 0
mysql> UPDATE compras SET telefone = '2220-4156' WHERE comprador = 'Joo da Silva';
Query OK, 1 row affected (0,00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
mysql> UPDATE compras SET telefone = '2297-0033' WHERE comprador = 'Joo Vieira';
Query OK, 1 row affected (0,00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
Certo, agora nossos compradores possuem telefone tambm. Ainda faltam mais compras sem
comprador, ento continuaremos adicionando os compradores. A prxima compra foi o meu primo
Alex Vieira que comprou. Vamos inseri-lo novamente:
mysql> UPDATE compras SET comprador = 'Alex Vieira' WHERE id = 6;
Query OK, 1 row affected (0,00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
Poxa vida... Percebi que ao invs de colocar o telefone do meu primo acabei colocando o meu...
Quanto sofrimento por causa de 2 colunas novas! Alm de ter que me preocupar se os nomes dos
compradores esto sendo exatamente iguais, agora eu preciso me preocupar se os telefones tambm
esto corretos e mais, todas as vezes que eu preciso inserir um comprador eu preciso lembrar de inserir o
seu telefone... E se agora eu precisasse adicionar o endereo, e-mail ou quaisquer informaes do
Veja o quo problemtico est sendo manter as informaes de um comprador em uma tabela de
compras. Alm de trabalhosa, a insero bem problemtica, pois h um grande risco de falhas no meu
banco de dados como por exemplo: informaes redundantes (que se repetem) ou ento informaes
incoerentes (o mesmo comprador com alguma informao diferente). Com toda certeza no uma boa
soluo para a nossa necessidade! Ser que no existe uma forma diferente de resolver isso?
No nosso caso queremos que cada comprador seja representado pelo seu nome, endereo e telefone.
Como j pensamos em modelagem antes, aqui fica o nosso modelo de tabela para representar os
compradores:
Agora que criamos a nossa tabela, vamos inserir alguns compradores, no meu caso, as compras
foram feitas apenas por mim e pelo meu tio Joo da Silva, ento adicionaremos apenas 2 compradores:
mysql> INSERT INTO compradores (nome, endereco, telefone) VALUES
('Alex Felipe', 'Rua Vergueiro, 3185', '5571-2751');
Query OK, 1 row affected (0,01 sec)
Criamos agora duas tabelas diferentes na nossa base de dados, a tabela compras e a tabela
compradores . Ento no precisamos mais das infores dos compradores na tabela compras , ou seja,
vamos excluir as colunas comprador e telefone , mas como podemos excluir uma coluna?
Precisamos alterar a estrutura da tabela, ento comearemos pelo ALTER TABLE :
ALTER TABLE compras
Se para adicionar uma coluna utilizamos a instruo ADD COLUMN , logo, para excluir uma tabela,
utilizaremos a instruo DROP COLUMN :
mysql> ALTER TABLE compras DROP COLUMN comprador;
Query OK, 0 rows affected (0,06 sec)
Records: 0 Duplicates: 0 Warnings: 0
A coluna comprador foi excluda com sucesso! Por fim, excluiremos a coluna telefone:
mysql> ALTER TABLE compras DROP COLUMN telefone;
Query OK, 0 rows affected (0,03 sec)
Records: 0 Duplicates: 0 Warnings: 0
Agora que exclumos todas as colunas relacionadas aos compradores da tabela compras ,
precisamos de alguma forma associar uma compra com um comprador. Ento vamos criar uma nova
coluna na tabela compras e adicionar o id do comprador nessa coluna:
Por que o id dos compradores precisa ficar na tabela compras e no o id da tabela compras na
tabela compradores ? Precisamos pensar seguinte forma: uma compra s pode ser de 1 nico
comprador e o comprador pode ter 1 ou mais compras, como podemos garantir que 1 compra pertea
Temos a nossa nova coluna para associar o comprador com a sua compra, ento vamos fazer
UPDATE na tabela compras inserindo o comprador de id 1 para a primeira metade das compras e
inserindo a segunda metade para o comprador de id 2. Primeiro vamos verificar quantas compras ns
temos usando a funo COUNT() ;
mysql> SELECT count(*) FROM compras;
+----------+
| count(*) |
+----------+
| 46 |
+----------+
1 row in set (0,00 sec)
No... No era isso que eu queria, eu quero que, em apenas uma query, nesse caso um SELECT ,
retorne tanto as informaes da tabela compras e da tabela compradores . Ser que podemos fazer
isso? Sim, podemos! Lembra da instruo FROM que indica qual a tabela que estamos buscando as
informaes? Alm de buscar por uma nica tabela, podemos indicar que queremos buscar por mais de
1 tabela separando as tabelas por ",":
SELECT * FROM compras, compradores, tabela3, tabela4, ...;
A instruo JOIN espera uma tabela que precisa ser juntada: FROM compras JOIN compradores .
Nesse caso estamos juntando a tabela compras com a tabela compradores. Para passarmos o critrio de
juno, utilizamos a instruo ON : ON compras.id_compradores = compradores.id . Nesse
momento estamos informando a FOREIGN KEY da tabela compras (compras.id_compradores) e qual
a chave (compradores.id) da tabela compradores que referencia essa FOREIGN KEY.
Agora a nossa query retornou os nossos registros corretamente. Porm, ainda existe um problema na
Note que no existe o comprador com id 100, mas, mesmo assim, conseguimos adicion-lo na
nossa tabela de compras . Precisamos garantir a integridade dos nossos dados, informando ao MySQL
que a coluna id_compradores da tabela compras uma FOREIGN KEY da tabela compradores, ou seja,
s poderemos adicionar um id apenas se estiver registrado na tabela compradores. Antes de
adicionarmos a FOREIGN KEY, precisamos excluir o registro com o id_compradores = 100, pois no
possvel adicionar uma FOREIGN KEY com dados que no exista na tabela que iremos referenciar.
mysql> DELETE FROM compras WHERE id_compradores = 100;
Query OK, 1 row affected (0,01 sec)
Quando adicionamos uma FOREIGN KEY em uma tabela, estamos adicionando uma Constraints,
ento precisaremos alterar a estrutura da tabela compras utilizando a instruo ALTER TABLE :
mysql> ALTER TABLE compras ADD CONSTRAINT fk_compradores FOREIGN KEY (id_compradores)
REFERENCES compradores (id);
Query OK, 46 rows affected (0,04 sec)
Records: 46 Duplicates: 0 Warnings: 0
Agora o nosso banco de dados no permite a insero de registros com compradores inexistentes! Se
tentarmos adicionar essa mesma compra com um comprador existente:
INSERT INTO compras (valor, data, observacoes, id_compradores)
VALUES (1500, '2016-01-05', 'Playstation 4', 1);
Query OK, 1 row affected (0,00 sec)
Mas e se tentarmos adicionar uma nova compra, porm com a forma de pagamento em dinheiro?
mysql> INSERT INTO compras (valor, data, observacoes, id_compradores, forma_pagto)
VALUES (80, '2016-01-07', 'Bola de futebol', 2, 'DINHEIRO');
Query OK, 1 row affected, 1 warning (0,00 sec)
Se quisermos verificar se o modo foi modificado podemos retornar esse valor por meio da instruo
SELECT :
Agora que configuramos o SQL mode do MySQL para impedir a insero de valores invlidos, vamos
apagar o ltimo registro que foi inserido com valor invlido e tentar adicion-lo novamente:
Perceba que agora o MySQL impediu que a linha fosse inserida, pois o valor no vlido para a
coluna forma_pagto .
O SQL mode uma configurao do servidor e ns alteramos apenas a sesso que estvamos logado, o
que aconteceria se caso samos da sesso que configuramos e entrssemos em uma nova? O MySQL
adotaria o SQL mode padro j configurado! Ou seja, terimos que alterar novamente para o strict mode.
Mas alm da sesso, podemos fazer a configurao global do SQL mode.
mysql> SET GLOBAL sql_mode = 'STRICT_ALL_TABLES';
Query OK, 0 rows affected (0,00 sec)
Agora, todas as vezes que entrarmos no MySQL, ser adotado o strict mode.
O ENUM uma boa soluo quando queremos restringir valores especficos e j esperados em um
coluna, porm no faz parte do padro ANSI que o padro para a escrita de instrues SQL , ou seja,
um recurso exclusivo do MySQL e cada banco de dados possui a sua prpria implementao para essa
mesma funcionadalidade.
6.6 RESUMINDO
Nesse captulo aprendemos a fazer uma relao entre duas tabelas utilizando FOREIGN KEYS.
Vimos tambm que para fazermos queries com duas tabelas diferentes utilizamos as chaves estrangeiras
por meio da instruo JOIN que informa ao MySQL quais sero os critrios para associar as tabelas
distintas. E sempre precisamos lembrar que, quando estamos lidando com FOREIGN KEY, precisamos
criar uma Constraint para garantir que todas as chaves estrangeiras precisa existir na tabela que fazemos
referncia. Alm disso, vimos tambm que quando queremos adicionar uma coluna nova para que aceite
apenas determinados valores j esperado por ns, como o caso da forma de pagamento, podemos
utilizar o ENUM do MySQL como um soluo, porm importante lembrar que uma soluo que no
faz parte do padro ANSI, ou seja, cada banco de dados possui sua prpria implementao. Vamos para
os exerccios?
EXERCCIOS
1. Crie a tabela compradores com id , nome , endereco e telefone .
7. Exiba todas as compras (mas sem os dados do comprador), cujo comprador tenha nome que comea
com 'GUILHERME'.
60 6.6 RESUMINDO
8. Exiba o nome do comprador e a soma de todas as suas compras.
9. A tabela compras foi alterada para conter uma FOREIGN KEY referenciando a coluna id da
tabela compradores . O objetivo deixar claro para o banco de dados que
compras.id_compradores est de alguma forma relacionado com a tabela compradores atravs
da coluna compradores.id . Mesmo sem criar a FOREIGN KEY possvel relacionar tabelas atravs
do comando JOIN.
11. Crie uma coluna chamada "forma_pagto" do tipo ENUM e defina os valores: 'BOLETO' e 'CREDITO'.
12. Ative o strict mode na sesso que est utilizando para impossibilitar valores invlidos. Utilize o modo
"STRICT_ALL_TABLES". E verifique se o SQL mode foi alterado fazendo um SELECT na sesso.
13. Tente inserir uma compra com forma de pagamento diferente de 'BOLETO' ou 'CREDITO', por
exemplo, 'DINHEIRO' e verifique se o MySQL recusa a insero.
14. Adicione as formas de pagamento para todas as compras por meio da instruo UPDATE .
15. Faa a configurao global do MySQL para que ele sempre entre no strict mode.
6.6 RESUMINDO 61
CAPTULO 7
Para a segunda parte de nosso curso utilizaremos um conjunto de dados de um sistema de ensino online
como exemplo. No se preocupe, pois disponilizaremos o arquivo para que voc baixe e execute o script
com todas as tabelas.
Continuaremos usando o terminal do MySQL durante o curso, porm, se voc prefere uma outra
interface, como por exemplo o MySQL Workbench, fique a vontade e usar o que for melhor para voc.
Abra o terminal do MySQL com o comando mysql -uroot -p e crie a base de dados escola.
Agora que criamos a nossa base de dados, podemos importar o arquivo .sql j existente. Saia do
terminal e execute o arquivo na base de dados escola.
mysql -u root -p escola < escola.sql
Com o arquivo importado, podemos abrir novamente o MySQL, porm selecione a base de dados
escoola.
Para verificar todas as tabelas da nossa base de dados podemos utilizar o instruo SHOW TABLES do
MySQL:
SHOW TABLES;
+------------------+
| Tables_in_escola |
+------------------+
| aluno |
| curso |
| exercicio |
| matricula |
| nota |
| resposta |
| secao |
+------------------+
7 rows in set (0,00 sec)
Sabemos quais so as tabelas, porm precisamos saber mais sobre a estrutura dessas tabelas, ento
vamos utilizar a instruo DESC . Vamos verificar primeiro a tabela aluno:
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| nome | varchar(255) | NO | | | |
| email | varchar(255) | NO | | | |
+-------+--------------+------+-----+---------+----------------+
Perceba que uma tabela bem simples, onde sero armazenadas apenas as informaes dos alunos.
Vamos verificar a tabela curso:
DESC curso;
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| nome | varchar(255) | NO | | | |
+-------+--------------+------+-----+---------+----------------+
Da mesma forma que a tabela aluno , a tabela curso armazenada apenas as informaes dos
cursos. Agora vamos verificar a tabela matricula:
DESC matricula;
+----------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| aluno_id | int(11) | NO | | NULL | |
| curso_id | int(11) | NO | | NULL | |
| data | datetime | NO | | NULL | |
| tipo | varchar(20) | NO | | | |
+----------+-------------+------+-----+---------+----------------+
Conseguimos achar a primeira associao das tabelas, ou seja, a coluna aluno_id referencia a
tabela aluno e a coluna curso_id referencia a tabela curso . Ento vamos verificar quais so todos
os cursos de um aluno. Para uma melhor compreenso de como o resultado esperado dessa query, veja
a planilha a seguir:
Como podemos ver, ns temos a lista de alunos e seus respectivos cursos. Ento vamos comear a
retornar todos os alunos que possuem uma matrcula, ou seja, vamos fazer um JOIN entre a tabela
aluno e matricula :
+-----------------+
| nome |
+-----------------+
| Joo da Silva |
| Frederico Jos |
| Alberto Santos |
| Renata Alonso |
| Paulo Jos |
| Manoel Santos |
| Renata Ferreira |
| Paula Soares |
| Renata Alonso |
| Manoel Santos |
| Joo da Silva |
| Frederico Jos |
| Alberto Santos |
| Frederico Jos |
+-----------------+
Perceba que utilizamos a.nome , m.aluno_id e a.id , afinal, o que significa? Quando escrevemos
aluno a , significa que estamos "apelidando" a tabela aluno , ou seja, todas as vezes que utilizarmos
a.alguma_coisa , estaremos pegando alguma coluna da tabela aluno ! Em SQL, esses "apelidos" so
conhecidos como Alias.
Os alunos foram retornados. Ento agora vamos juntar a tabela curso e aluno com a tabela
matricula ao mesmo tempo, porm, dessa vez vamos retornar o nome do aluno e o nome do curso:
+-----------------+------------------------------------+
| nome | nome |
+-----------------+------------------------------------+
| Joo da Silva | SQL e banco de dados |
| Frederico Jos | SQL e banco de dados |
| Alberto Santos | Scrum e mtodos geis |
| Renata Alonso | C# e orientao a objetos |
| Paulo Jos | SQL e banco de dados |
| Manoel Santos | Scrum e mtodos geis |
| Renata Ferreira | Desenvolvimento web com VRaptor |
| Paula Soares | Desenvolvimento mobile com Android |
| Renata Alonso | Desenvolvimento mobile com Android |
| Manoel Santos | SQL e banco de dados |
| Joo da Silva | C# e orientao a objetos |
| Frederico Jos | C# e orientao a objetos |
| Alberto Santos | C# e orientao a objetos |
| Frederico Jos | Desenvolvimento web com VRaptor |
+-----------------+-------------------|-----------------+
+----------+
| COUNT(*) |
7.1 SUBQUERIES
Observe que foram retornadas 14 linhas quando buscamos todos os alunos e seus cursos, ou seja,
existem alunos que no tem matrcula! Como podemos verificar quais so os alunos que no esto
matriculados? No MySQL, podemos utilizar a funo EXISTS() para verificar se existe algum registro
de acordo com uma determinada query:
SELECT a.nome FROM aluno a
WHERE EXISTS (SELECT m.id FROM matricula m WHERE m.aluno_id = a.id);
+-----------------+
| nome |
+-----------------+
| Joo da Silva |
| Frederico Jos |
| Alberto Santos |
| Renata Alonso |
| Paulo Jos |
| Manoel Santos |
| Renata Ferreira |
| Paula Soares |
+-----------------+
Repare que escrevemos uma query dentro de uma funo, quando fazemos esse tipo de query
chamamos de subquery. Mas o que aconteceu exatamente nessa query? Quando utilizamos o EXISTS()
indicamos que queremos o retorno de todos os alunos nomes dos alunos ( a.nome ) que esto na tabela
aluno , porm, queremos apenas se existir uma matrcula para esse aluno EXISTS(SELECT m.id FROM
matricula m WHERE m.aluno_id = a.id) .
Perceba que novamente estamos retornando os alunos matriculados sendo que precisamos dos
alunos que no esto matriculados. Nesse caso, podemos utilizar a instruo NOT para fazer a negao,
ou seja, para retornar os alunos que no possuem matrcula:
SELECT a.nome FROM aluno a
WHERE NOT EXISTS (SELECT m.id FROM matricula m WHERE m.aluno_id = a.id);
+------------------+
| nome |
+------------------+
| Paulo da Silva |
| Carlos Cunha |
| Jose da Silva |
| Danilo Cunha |
| Zilmira Jos |
| Cristaldo Santos |
| Osmir Ferreira |
| Claudio Soares |
+------------------+
Conseguimos achar todos alunos que fazem parte do sistema e que no possuem uma matrcula, algo
7.1 SUBQUERIES 65
que no esperado... Provavelmente esses alunos haviam cancelado a matrcula mas ainda sim, existia o
cadastro deles, sabendo dessas informaes temos a capacidade de criar relatrios com informaes
relevantes para, por exemplo, o setor comercial dessa instituio entrar em contato com os alunos no
matriculados e tentar efetuar uma venda.
A instituio subiu alguns exerccios e precisa saber quais desses exerccios no foram respondidos.
Vamos novamente observar o resultado que se espera utilizando uma planilha como exemplo:
Como havamos visto anteriormente, existem as tabelas, exercicio e resposta , vamos uma
olhada na tabela exercicio :
DESC exercicio;
+------------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| secao_id | int(11) | NO | | NULL | |
| pergunta | varchar(255) | NO | | NULL | |
| resposta_oficial | varchar(255) | NO | | NULL | |
+------------------+--------------+------+-----+---------+----------------+
+---------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+---------------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| exercicio_id | int(11) | YES | | NULL | |
| aluno_id | int(11) | YES | | NULL | |
| resposta_dada | varchar(255) | YES | | NULL | |
+---------------+--------------+------+-----+---------+----------------+
Novamente encontramos uma outra associao, porm agora entre exercicio e resposta. Ento
vamos pegar todos os exerccios que no foram respondidos utilizando novamente o NOT EXISTS :
SELECT * FROM exercicio e
WHERE NOT EXISTS (SELECT r.id FROM resposta r WHERE r.exercicio_id = e.id);
+----+----------+------------------------------+-----------------------------------------------------
-+
| id | secao_id | pergunta | resposta_oficial
|
+----+----------+------------------------------+-----------------------------------------------------
-+
| 8 | 4 | como funciona? | insert into (coluna1, coluna2) values (v1, v2)
|
66 7.1 SUBQUERIES
| 9 | 5 | Como funciona a web? | requisicao e resposta
|
| 10 | 5 | Que linguagens posso ajudar? | varias, java, php, c#, etc
|
| 11 | 6 | O que eh MVC? | model view controller
|
| 12 | 6 | Frameworks que usam? | vraptor, spring mvc, struts, etc
|
| 14 | 8 | O que um interceptor? | eh como se fosse um filtro que eh executado antes
|
| 15 | 8 | quando usar? | tratamento de excecoes, conexao com o banco de dados
|
+----+----------+------------------------------+-----------------------------------------------------
-+
Se quisermos retornar da mesma forma que fizemos no exemplo da planilha, basta informar os
campos desejados:
SELECT e.id, e.pergunta FROM exercicio e
WHERE NOT EXISTS (SELECT r.id FROM resposta r WHERE r.exercicio_id = e.id);
+----+------------------------------+
| id | pergunta |
+----+------------------------------+
| 8 | como funciona? |
| 9 | Como funciona a web? |
| 10 | Que linguagens posso ajudar? |
| 11 | O que eh MVC? |
| 12 | Frameworks que usam? |
| 14 | O que um interceptor? |
| 15 | quando usar? |
+----+------------------------------+
O pessoal do comercial da instituio, informou que existem alguns cursos que no tem nenhuma
matrcula. Vamos verificar como esperado desse resultado pela nossa planilha:
Da mesma forma que retornamos todos os exerccios que no tinha respostas, podemos retornar
todos os cursos que no possuem matrcula:
SELECT c.nome FROM curso c
WHERE NOT EXISTS(SELECT m.id FROM matricula m WHERE m.curso_id = c.id);
+--------------------------------+
| nome |
+--------------------------------+
| Java e orientao a objetos |
| Desenvolvimento mobile com iOS |
| Ruby on Rails |
| PHP e MySql |
+--------------------------------+
7.1 SUBQUERIES 67
Veja que queries muito parecidas podem resolver problemas diferentes!
A instituio informou que tiveram vrios exerccios que no foram respondidos pelos alunos nos
cursos que foram realizados recentemente. Vamos verificar quem foram esses alunos, para verificarmos
o motivo de no ter respondido, se foi um problema no sistema ou na base de dados... Novamente
vamos verificar o que se espera desse resultado numa planilha:
Vamos tentar fazer essa query. Comearemos retornando o aluno juntando a tabela aluno com a
tabela matricula .
+-----------------+------------------------------------+
| nome | nome |
+-----------------+------------------------------------+
| Joo da Silva | SQL e banco de dados |
| Frederico Jos | SQL e banco de dados |
| Alberto Santos | Scrum e mtodos geis |
| Renata Alonso | C# e orientao a objetos |
| Paulo Jos | SQL e banco de dados |
| Manoel Santos | Scrum e mtodos geis |
| Renata Ferreira | Desenvolvimento web com VRaptor |
| Paula Soares | Desenvolvimento mobile com Android |
| Renata Alonso | Desenvolvimento mobile com Android |
| Manoel Santos | SQL e banco de dados |
| Joo da Silva | C# e orientao a objetos |
| Frederico Jos | C# e orientao a objetos |
| Alberto Santos | C# e orientao a objetos |
| Frederico Jos | Desenvolvimento web com VRaptor |
+-----------------+------------------------------------+
Aparentemente est tudo certo, porm ainda precisamos informar que queremos apenas os alunos
que no responderam os exerccios desses de algum desses cursos. Ento adicionaremos agora o NOT
EXISTS() :
68 7.1 SUBQUERIES
WHERE NOT EXISTS(SELECT r.aluno_id
FROM resposta r WHERE r.aluno_id = a.id);
+-----------------+------------------------------------+
| nome | nome |
+-----------------+------------------------------------+
| Paulo Jos | SQL e banco de dados |
| Manoel Santos | Scrum e mtodos geis |
| Renata Ferreira | Desenvolvimento web com VRaptor |
| Paula Soares | Desenvolvimento mobile com Android |
| Manoel Santos | SQL e banco de dados |
+-----------------+------------------------------------+
H uma regra no sistema em que no pode permitir que alunos que no estejam matriculados
resposdam os exerccios, ou seja, no pode existir uma resposta na tabela resposta com um id de um
aluno ( aluno_id ) que no esteja matriculado. Vamos primeiro verificar todos os alunos matriculados
que responderam os exerccios:
SELECT r.id, a.nome FROM aluno a
JOIN resposta r ON r.aluno_id = a.id
WHERE EXISTS(SELECT m.aluno_id FROM matricula m
WHERE m.aluno_id = a.id);
+----+-----------------+
| id | nome |
+----+-----------------+
| 1 | Joo da Silva |
| 2 | Joo da Silva |
| 3 | Joo da Silva |
| 4 | Joo da Silva |
| 5 | Joo da Silva |
| 6 | Joo da Silva |
| 7 | Joo da Silva |
| 8 | Frederico Jos |
| 9 | Frederico Jos |
| 10 | Frederico Jos |
| 11 | Frederico Jos |
| 12 | Alberto Santos |
| 13 | Alberto Santos |
| 14 | Alberto Santos |
| 15 | Alberto Santos |
| 16 | Alberto Santos |
| 17 | Alberto Santos |
| 18 | Alberto Santos |
| 19 | Alberto Santos |
| 20 | Alberto Santos |
| 21 | Renata Alonso |
| 22 | Renata Alonso |
| 23 | Renata Alonso |
| 24 | Renata Alonso |
| 25 | Renata Alonso |
| 26 | Renata Alonso |
| 27 | Renata Alonso |
+----+-----------------+
Observe que repetiu alguns alunos, pois um aluno respondeu mais de uma questo. Vamos verificar
agora os que responderam, poem no esto matriculados:
7.1 SUBQUERIES 69
WHERE NOT EXISTS(SELECT m.aluno_id FROM matricula m
WHERE m.aluno_id = a.id);
O resultado saiu conforme o esperado, isso significa, que no existem respostas de alunos que no
possuem matrcula!
7.2 RESUMINDO
Nesse captulo aprendemos a criar queries capazes de retornar valores caso exista, ou no, uma
associao entre duas tabelas, como por exemplo, se um aluno est matriculado ou se um aluno
respondeu algum exerccio por meio da funo EXISTS() . Aprendemos tambm o que so subqueries
como no exemplo em que passamos uma query como parmetro para a funo EXISTS() resolver
diversos problemas, alm disso, analisamos que vrias queries "similadres" tem a capacidade de resolver
problemas distintos utilizando o EXISTS() . Vamos para os exerccios?
EXERCCIOS
1. Baixe o schema do banco de dados aqui
DICA: Salve o arquivo escola.sql em um lugar de fcil acesso pelo terminal. Voc deve rodar o
comando para importar o schema no mesmo lugar onde estar o aquivo escola.sql . Por exemplo,
salve o arquivo SQL na pasta \alura-mysql . Depois abra um terminal e entre nessa pasta:
cd \aula-mysql
mysql -u root -p escola < escola.sql
No Windows voc pode usar o comando dir para listar os arquivos da pasta atual na linha de
comando. Ou seja, ao executar dir na pasta aula-mysql voc deve encontrar o arquivo
escola.sql .
2. Busque todos os alunos que no tiveram nenhuma matrcula nos ltimos 45 dias, usando a instruo
EXISTS .
70 7.2 RESUMINDO
3. possvel fazer a mesma consulta sem usar EXISTS ? Quais so?
7.2 RESUMINDO 71
CAPTULO 8
A instuio solicitou a mdia de todos os cursos para fazer uma comparao de notas para verificar se
todos os cursos possuem a mesma mdia, quais cursos tem menores notas e quais possuem as maiores
notas. Vamos verificar a estrutura de algumas tabelas da nossa base de dados, comearemos pela tabela
curso :
DESC curso;
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| nome | varchar(255) | NO | | | |
+-------+--------------+------+-----+---------+----------------+
DESC secao;
+------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| curso_id | int(11) | NO | | NULL | |
| titulo | varchar(255) | NO | | | |
| explicacao | varchar(255) | NO | | NULL | |
| numero | int(11) | NO | | NULL | |
+------------+--------------+------+-----+---------+----------------+
J podemos perceber que existe uma relao entre curso de secao . Vamos tambm dar uma
olhada na tabela exercicio :
DESC exercicio;
+------------------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+------------------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| secao_id | int(11) | NO | | NULL | |
| pergunta | varchar(255) | NO | | NULL | |
| resposta_oficial | varchar(255) | NO | | NULL | |
+------------------+--------------+------+-----+---------+----------------+
Observe que na tabela exercicio temos uma associao com a tabela secao . Agora vamos
verificar a tabela resposta :
DESC resposta
Podemos verificar que a tabela resposta est associada com a tabela exerccio . Por fim, vamos
verificar a tabela nota :
DESC nota;
+-------------+---------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+---------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| resposta_id | int(11) | YES | | NULL | |
| nota | decimal(18,2) | YES | | NULL | |
+-------------+---------------+------+-----+---------+----------------+
Note que tambm a tabela nota possui uma associao, nesse caso com a tabela resposta .
Como vimos, existem muitas tabelas que podemos selecionar em nossa query, ento vamos montar a
nossa query por partes. Comearemos pela tabela nota :
SELECT n.nota FROM nota n;
+-------+
| nota |
+-------+
| 8.00 |
| 0.00 |
| 7.00 |
| 6.00 |
| 9.00 |
| 10.00 |
| 4.00 |
| 4.00 |
| 7.00 |
| 8.00 |
| 6.00 |
| 7.00 |
| 4.00 |
| 9.00 |
| 3.00 |
| 5.00 |
| 5.00 |
| 5.00 |
| 6.00 |
| 8.00 |
| 8.00 |
| 9.00 |
| 10.00 |
| 2.00 |
| 0.00 |
| 1.00 |
| 4.00 |
Conseguimos pegar todas as notas, agora precisamos resolver a nossa primeira associao, nesse
caso, juntar a tabela resposta com a tabela nota :
SELECT n.nota FROM nota n
JOIN resposta r ON n.resposta_id = r.id;
+-------+
| nota |
+-------+
| 8.00 |
| 0.00 |
| 7.00 |
| 6.00 |
| 9.00 |
| 10.00 |
| 4.00 |
| 4.00 |
| 7.00 |
| 8.00 |
| 6.00 |
| 7.00 |
| 4.00 |
| 9.00 |
| 3.00 |
| 5.00 |
| 5.00 |
| 5.00 |
| 6.00 |
| 8.00 |
| 8.00 |
| 9.00 |
| 10.00 |
| 2.00 |
| 0.00 |
| 1.00 |
| 4.00 |
+-------+
Devolvemos todas as notas associadas com a tabela resposta . Agora vamos para o prximo JOIN
entre a tabela resposta e a tabela exercicio :
SELECT n.nota FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id;
+-------+
| nota |
+-------+
| 8.00 |
| 0.00 |
| 7.00 |
| 6.00 |
| 9.00 |
| 10.00 |
| 4.00 |
| 4.00 |
| 7.00 |
| 8.00 |
| 6.00 |
+-------+
| nota |
+-------+
| 8.00 |
| 0.00 |
| 7.00 |
| 6.00 |
| 9.00 |
| 10.00 |
| 4.00 |
| 4.00 |
| 7.00 |
| 8.00 |
| 6.00 |
| 7.00 |
| 4.00 |
| 9.00 |
| 3.00 |
| 5.00 |
| 5.00 |
| 5.00 |
| 6.00 |
| 8.00 |
| 8.00 |
| 9.00 |
| 10.00 |
| 2.00 |
| 0.00 |
| 1.00 |
| 4.00 |
+-------+
Por fim, faremos a ltima associao entre a tabela secao e a tabela curso .
SELECT n.nota FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
+-------+
| nota |
+-------+
| 8.00 |
| 0.00 |
| 7.00 |
| 6.00 |
| 9.00 |
| 10.00 |
| 4.00 |
| 4.00 |
| 7.00 |
| 8.00 |
| 6.00 |
| 7.00 |
| 4.00 |
| 9.00 |
| 3.00 |
| 5.00 |
| 5.00 |
| 5.00 |
| 6.00 |
| 8.00 |
| 8.00 |
| 9.00 |
| 10.00 |
| 2.00 |
| 0.00 |
| 1.00 |
| 4.00 |
+-------+
Fizemos todas associaes que precisvamos, porm repare que ainda est retornando a nota de
todos os alunos por curso uma a uma, porm ns precisamos da mdia por curso! No MySQL, podemos
utilizar a funo AVG() para tirar a mdia:
+-------------+
| AVG(n.nota) |
+-------------+
| 5.740741 |
+-------------+
Observe que foi retornado apenas um valor, ser que essa mdia igual para todos os cursos? Vamos
tentar retornar os cursos e verificarmos:
SELECT c.nome, AVG(n.nota) FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id;
Apenas 1 curso? No era esse o resultado que espervamos! Quando utilizamos a funo AVG() ela
calcula todos os valores existentes da query e retorna a mdia, porm em apenas uma linha! Para que a
funo AVG() calcule a mdia de cada curso, precisamos informar que queremos agrupar a mdia para
uma determinada coluna, nesse caso, a coluna c.nome , ou seja, para cada curso diferente queremos que
calcule a mdia. Para agruparmos uma coluna utilizamos a instruo GROUP BY , informando a coluna
que queremos agrupar:
SELECT c.nome, AVG(n.nota) FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id
GROUP BY c.nome;
+---------------------------------+-------------+
| nome | AVG(n.nota) |
+---------------------------------+-------------+
| C# e orientao a objetos | 4.857143 |
| Desenvolvimento web com VRaptor | 8.000000 |
| Scrum e mtodos geis | 5.777778 |
| SQL e banco de dados | 6.100000 |
+---------------------------------+-------------+
O pessoal do comercial da instituio informou que alguns alunos esto reclamando pela quantidade
de exerccios nos cursos. Ento vamos verificar quantos exerccios existem para cada curso. Primeiro
vamos verificar quantos exerccios existem no banco usando a funo COUNT() :
SELECT COUNT(*) FROM exercicio;
+----------+
| COUNT(*) |
+----------+
| 31 |
+----------+
Retormos a quantidade de todos os exerccios, porm ns precisamos saber o total de exerccios para
cada curso, ou seja, precisamos juntar a tabela curso . Porm, para juntar a tabela curso , teremos que
juntar a tabela secao :
SELECT COUNT(*) FROM exercicio e
JOIN secao s ON e.secao_id = s.id
+----------------------+----------+
| nome | COUNT(*) |
Perceba que o resultado foi similar ao que aconteceu quando tentamos tirar a mdia sem agrupar!
Ento precisamos tambm informar que queremos agrupar a contagem pelo nome do curso. Ento
vamos adicionar o GROUP BY :
SELECT c.nome, COUNT(*) FROM exercicio e
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id
GROUP BY c.nome;
+---------------------------------+----------+
| nome | COUNT(*) |
+---------------------------------+----------+
| C# e orientao a objetos | 7 |
| Desenvolvimento web com VRaptor | 7 |
| Scrum e mtodos geis | 9 |
| SQL e banco de dados | 8 |
+---------------------------------+----------+
Note que o nome da coluna que conta todos os exerccios est um pouco estranha, vamos adicionar
um alias para melhorar o resultado:
SELECT c.nome, COUNT(*) AS contagem FROM exercicio e
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id
GROUP BY c.nome;
+---------------------------------+----------+
| nome | contagem |
+---------------------------------+----------+
| C# e orientao a objetos | 7 |
| Desenvolvimento web com VRaptor | 7 |
| Scrum e mtodos geis | 9 |
| SQL e banco de dados | 8 |
+---------------------------------+----------+
Todo final de semestre ns precisamos enviar um relatrio para o MEC informando quantos alunos
esto matriculados em cada curso da instituio. Faremos novamente a nossa query por partes, vamos
retornar primeiro todos os cursos:
SELECT c.nome FROM curso c
+----------------------+------------+
| nome | quantidade |
+----------------------+------------+
| SQL e banco de dados | 14 |
+----------------------+------------+
+------------------------------------+------------+
| nome | quantidade |
+------------------------------------+------------+
| C# e orientao a objetos | 4 |
| Desenvolvimento mobile com Android | 2 |
| Desenvolvimento web com VRaptor | 2 |
| Scrum e mtodos geis | 2 |
| SQL e banco de dados | 4 |
+------------------------------------+------------+
8.1 RESUMINDO
Vimos nesse captulo como podemos gerar relatrios utilizando funes como AVG() e COUNT() .
Vimos tambm que, se precisamos retornar as colunas para verificar qual o valor de cada linha, como
por exemplo, a mdia de cada curso, precisamos agrupar essas colunas por meio do GROUP BY . Vamos
para os exerccios?
EXERCCIOS
1. Exiba a mdia das notas por curso.
2. Devolva o curso e as mdias de notas, levando em conta somente alunos que tenham "Silva" ou
"Santos" no sobrenome.
4. Voc pode ordenar pelo COUNT tambm. Basta colocar ORDER BY COUNT(coluna).
Pegue a resposta do exerccio anterior, e ordene por nmero de respostas, em ordem decrescente.
1. Podemos agrupar por mais de um campo de uma s vez. Por exemplo, se quisermos a mdia de
8.1 RESUMINDO 79
notas por aluno por curso, podemos fazer GROUP BY aluno.id, curso.id.
80 8.1 RESUMINDO
CAPTULO 9
Todo o fim de semestre, a instituio de ensino precisa montar os boletins dos alunos. Ento vamos
montar a query que retornar todas as informaes para montar o boletim. Comearemos retornando
todas as notas dos alunos:
SELECT n.nota FROM nota n
Verificando o resultado:
+-------+
| nota |
+-------+
| 8.00 |
Observe que estamos fazendo queries grandes, aconselhamos que, no momento que precisar fazer
uma query complexa, faa queries menores e testes seus resultados, pois se existir alguma instruo
errada, mais fcil de identificar o problema.
Agora que associamos todas as nossas tabelas necessrias, vamos tirar a mdia com a funo de
agregao AVG() que capaz de tirar mdias, conforme visto durante o curso:
SELECT AVG(n.nota) FROM nota n
JOIN resposta r ON r.id = n.resposta_id
JOIN exercicio e ON e.id = r.exercicio_id
JOIN secao s ON s.id = e.secao_id
JOIN curso c ON c.id = s.curso_id
JOIN aluno a ON a.id = r.aluno_id;
+-------------+
| AVG(n.nota) |
+-------------+
| 5.740741 |
+-------------+
Retornou a mdia, porm no queremos apenas a mdia! Precisamos tambm dos alunos e dos
cursos. Ento vamos adicion-los:
SELECT a.nome, c.nome, AVG(n.nota) FROM nota n
JOIN resposta r ON r.id = n.resposta_id
JOIN exercicio e ON e.id = r.exercicio_id
JOIN secao s ON s.id = e.secao_id
JOIN curso c ON c.id = s.curso_id
JOIN aluno a ON a.id = r.aluno_id;
+----------------+----------------------+-------------+
Lembre-se que estamos lidando com uma funo de agregao, ou seja, se no informarmos a forma
que ela precisa agrupar as colunas, ela retornar apenas uma linha! Porm, precisamos sempre pensar
em qual tipo de agrupamento necessrio, nesse caso queremos que mostre a mdia de acada aluno,
ento agruparemos pelos alunos, porm tambm que queremos que a cada curso que o alunos fez mostre
a sua :
+-----------------+---------------------------------+-------------+
| nome | nome | AVG(n.nota) |
+-----------------+---------------------------------+-------------+
| Alberto Santos | Scrum e mtodos geis | 5.777778 |
| Frederico Jos | Desenvolvimento web com VRaptor | 8.000000 |
| Frederico Jos | SQL e banco de dados | 5.666667 |
| Joo da Silva | SQL e banco de dados | 6.285714 |
| Renata Alonso | C# e orientao a objetos | 4.857143 |
+-----------------+---------------------------------+-------------+
Nesse caso, estamos tentando adicionar condies para uma funo de agregao, porm, quando
queremos adicionar condies para funes de agregao precisamos utilizar o HAVING ao invs de
WHERE :
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your M
ySQL server version for the right syntax to use near 'GROUP BY a.nome, c.nome' at line 8
Alm de utilizarmos o HAVING existe um pequeno detalhe, precisamos sempre agrupar antes as
colunas pelo GROUP BY para depois utilizarmos o HAVING :
+---------------+-----------------------------+-------------+
| nome | nome | AVG(n.nota) |
+---------------+-----------------------------+-------------+
| Renata Alonso | C# e orientao a objetos | 4.857143 |
+---------------+-----------------------------+-------------+
Agora conseguimos retornar o aluno que teve a mdia abaixo de 5. E se quisssemos pegar todos os
alunos que aprovaram? simples, bastaria alterar o sinal para >= :
SELECT a.nome, c.nome, AVG(n.nota) FROM nota n
JOIN resposta r ON r.id = n.resposta_id
JOIN exercicio e ON e.id = r.exercicio_id
JOIN secao s ON s.id = e.secao_id
JOIN curso c ON c.id = s.curso_id
JOIN aluno a ON a.id = r.aluno_id
GROUP BY a.nome, c.nome
HAVING AVG(n.nota) >= 5;
+-----------------+---------------------------------+-------------+
| nome | nome | AVG(n.nota) |
+-----------------+---------------------------------+-------------+
| Alberto Santos | Scrum e mtodos geis | 5.777778 |
| Frederico Jos | Desenvolvimento web com VRaptor | 8.000000 |
| Frederico Jos | SQL e banco de dados | 5.666667 |
| Joo da Silva | SQL e banco de dados | 6.285714 |
+-----------------+---------------------------------+-------------+
A instuio enviou mais uma solicitao de um relatrio informando quais cursos tem poucos
alunos para tomar uma deciso se vai manter os cursos ou se ir cancel-los. Ento vamos novamente
fazer a nossa query por passos, primeiro vamos comear selecionando os cursos:
Agora vamos juntar o curso com a matrcula e a matrcula com o aluno e verificar o resultado:
SELECT c.nome FROM curso c
JOIN matricula m ON m.curso_id = c.id
JOIN aluno a ON m.aluno_id = a.id;
+------------------------------------+
Nossa query est funcionando, ento vamos contar a quantidade de alunos com a funo COUNT() :
H um detalhe nessa query, pois queremos contar todos os alunos de cada curso, ou seja, precisamos
agrupar os cursos!
SELECT c.nome, COUNT(a.id) FROM curso c
JOIN matricula m ON m.curso_id = c.id
JOIN aluno a ON m.aluno_id = a.id
GROUP BY c.nome;
+------------------------------------+-------------+
| nome | COUNT(a.id) |
+------------------------------------+-------------+
| C# e orientao a objetos | 4 |
| Desenvolvimento mobile com Android | 2 |
| Desenvolvimento web com VRaptor | 2 |
| Scrum e mtodos geis | 2 |
| SQL e banco de dados | 4 |
+------------------------------------+-------------+
A query funcionou, porm precisamos saber apenas os cursos que tem poucos alunos, nesse caso,
cursos que tenham menos de 10 alunos:
+------------------------------------+-------------+
| nome | COUNT(a.id) |
+------------------------------------+-------------+
| C# e orientao a objetos | 4 |
| Desenvolvimento mobile com Android | 2 |
| Desenvolvimento web com VRaptor | 2 |
| Scrum e mtodos geis | 2 |
| SQL e banco de dados | 4 |
+------------------------------------+-------------+
9.2 RESUMINDO
Sabemos que para adicionarmos filtros apenas para colunas utilizamos a instruo WHERE e
indicamos todas as peculiaridades necessrias, porm quando precisamos adicionar filtros para funes
de agregao, como por exemplo o AVG() , precisamos utilizar a instruo HAVING . Alm disso,
sempre bom lembrar que, quando estamos desenvolvendo queries grandes, recomendado que faa
passa-a-passo queries menores, ou seja, resolva os menores problemas juntando cada tabela por vez e
teste para verificar se est funcionando, pois isso ajuda a verificar aonde est o problema da query.
Vamos para os exerccios?
EXERCCIOS
1. Qual a principal diferena entre as instrues having e where do sql?
2. Devolva todos os alunos, cursos e a mdia de suas notas. Lembre-se de agrupar por aluno e por
curso. Filtre tambm pela nota: s mostre alunos com nota mdia menor do que 5.
3. Exiba todos os cursos e a sua quantidade de matrculas. Mas, exiba somente cursos que tenham mais
de 1 matrcula.
4. Exiba o nome do curso e a quantidade de sees que existe nele. Mostre s cursos com mais de 3
sees.
86 9.2 RESUMINDO
CAPTULO 10
O setor de financeiro dessa instituio, solicitou um relatrio informando todas as formas de pagamento
cadastradas no banco de dados para verificar se est de acordo com o que eles trabalham. Na base de
dados, se verificarmos a tabela matricula :
DESC matricula;
+----------+-------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+----------+-------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | NULL | auto_increment |
| aluno_id | int(11) | NO | | NULL | |
| curso_id | int(11) | NO | | NULL | |
| data | datetime | NO | | NULL | |
| tipo | varchar(20) | NO | | | |
+----------+-------------+------+-----+---------+----------------+
Observe que existe a coluna tipo que representa qual a forma de pagamento. E precisamos pegar
um relatrio da seguinte maneira:
+-------------+
| tipo |
+-------------+
| PAGA_PF |
| PAGA_PJ |
| PAGA_PF |
| PAGA_CHEQUE |
| PAGA_BOLETO |
| PAGA_PJ |
| PAGA_PF |
| PAGA_PJ |
| PAGA_PJ |
| PAGA_CHEQUE |
| PAGA_BOLETO |
| PAGA_PJ |
Veja que foram retornados tipos de pagamento iguais, porm precisamos enviar um relatrio apenas
com os tipos de pagamento distintos. Para retornamos os valores distintos de uma coluna podemos
utilizar a instruo DISTINCT :
SELECT DISTINCT m.tipo FROM matricula m;
+-------------+
| tipo |
+-------------+
| PAGA_PF |
| PAGA_PJ |
| PAGA_CHEQUE |
| PAGA_BOLETO |
+-------------+
Conseguimos retornar o relatrio das formas de pagamento, porm o setor financeiro ainda precisa
saber de mais informaes. Agora foi solicitado que enviasse um relatrio com os cursos e a quantidade
de alunos que possuem o tipo de pagamento PJ. Vamos verificar o exemplo em uma planilha:
Sabemos que o relatrio sobre a quantidade de matrculas que foram pagas como PJ, precisamos
contar, ou seja, usaremos a funo COUNT() . Vamos comear a contar a quantidade de matrculas:
SELECT COUNT(m.id) FROM matricula m;
+-------------+
| COUNT(m.id) |
+-------------+
| 14 |
+-------------+
+----------------------+-------------+
| nome | COUNT(m.id) |
+----------------------+-------------+
| SQL e banco de dados | 14 |
+----------------------+-------------+
Observe que foi retornado apenas uma linha! Isso significa que a funo COUNT() tambm uma
funo de agregao, ou seja, se queremos adicionar mais colunas na nossa query, precisamos agrup-las.
Ento vamos agrupar o nome do curso:
+------------------------------------+-------------+
| nome | COUNT(m.id) |
+------------------------------------+-------------+
| C# e orientao a objetos | 4 |
| Desenvolvimento mobile com Android | 2 |
| Desenvolvimento web com VRaptor | 2 |
| Scrum e mtodos geis | 2 |
| SQL e banco de dados | 4 |
+------------------------------------+-------------+
Conseguimos retornar todas os cursos e a quantidade de matrculas, porm precisamos filtrar por
tipo de pagamento PJ. Ento vamos adicionar um WHERE :
+------------------------------------+-------------+
| nome | COUNT(m.id) |
+------------------------------------+-------------+
| C# e orientao a objetos | 1 |
| Desenvolvimento mobile com Android | 2 |
| Desenvolvimento web com VRaptor | 1 |
| Scrum e mtodos geis | 1 |
| SQL e banco de dados | 1 |
+------------------------------------+-------------+
FILTROS UTILIZANDO O IN
O setor financeiro da instituio precisa de mais detalhes sobre os tipos de pagamento de cada curso,
eles precisam de um relatrio similar ao que fizemos, porm para todos que sejam pagamento PJ e PF.
Para diferenciar o tipo de pagamento, precisaremos adicionar a coluna do m.tipo :
SELECT c.nome, COUNT(m.id), m.tipo
FROM matricula m
JOIN curso c ON m.curso_id = c.id
WHERE m.tipo = 'PAGA_PJ'
OR m.tipo = 'PAGA_PF'
GROUP BY c.nome, m.tipo;
+------------------------------------+-------------+---------+
| nome | COUNT(m.id) | tipo |
+------------------------------------+-------------+---------+
| C# e orientao a objetos | 1 | PAGA_PF |
| C# e orientao a objetos | 1 | PAGA_PJ |
| Desenvolvimento mobile com Android | 2 | PAGA_PJ |
| Desenvolvimento web com VRaptor | 1 | PAGA_PF |
| Desenvolvimento web com VRaptor | 1 | PAGA_PJ |
| Scrum e mtodos geis | 1 | PAGA_PF |
| Scrum e mtodos geis | 1 | PAGA_PJ |
| SQL e banco de dados | 1 | PAGA_PF |
| SQL e banco de dados | 1 | PAGA_PJ |
+------------------------------------+-------------+---------+
Resolveria, mas perceba que a nossa query a cada novo tipo de pagamento a nossa query tende a
crescer, dificultando a leitura... Em SQL, existe a instruo IN que permite especificarmos mais de um
valor que precisamos filtrar ao mesmo tempo para uma determinada coluna:
SELECT c.nome, COUNT(m.id), m.tipo
FROM matricula m
JOIN curso c ON m.curso_id = c.id
WHERE m.tipo IN ('PAGA_PJ', 'PAGA_PF', 'PAGA_CHEQUE', 'PAGA_BOLETO')
GROUP BY c.nome, m.tipo;
+------------------------------------+-------------+-------------+
| nome | COUNT(m.id) | tipo |
+------------------------------------+-------------+-------------+
| C# e orientao a objetos | 1 | PAGA_BOLETO |
| C# e orientao a objetos | 1 | PAGA_CHEQUE |
| C# e orientao a objetos | 1 | PAGA_PF |
| C# e orientao a objetos | 1 | PAGA_PJ |
| Desenvolvimento mobile com Android | 2 | PAGA_PJ |
| Desenvolvimento web com VRaptor | 1 | PAGA_PF |
| Desenvolvimento web com VRaptor | 1 | PAGA_PJ |
| Scrum e mtodos geis | 1 | PAGA_PF |
| Scrum e mtodos geis | 1 | PAGA_PJ |
| SQL e banco de dados | 1 | PAGA_BOLETO |
| SQL e banco de dados | 1 | PAGA_CHEQUE |
| SQL e banco de dados | 1 | PAGA_PF |
| SQL e banco de dados | 1 | PAGA_PJ |
+------------------------------------+-------------+-------------+
Se um novo tipo de pagamento for adicionado, basta adicionarmos dentro do IN e a nossa query
funcionar corretamente.
A instituio nomeou 3 alunos como os mais destacados nos ltimos cursos realizamos e gostaria de
saber quais foram todos os cursos que eles fizeram. Os 3 alunos que se destacaram foram: Joo da Silva,
Alberto Santos e a Renata Alonso. Vamos verificar quais so os id s desses alunos:
SELECT * FROM aluno;
+----+------------------+----------------------+
| id | nome | email |
+----+------------------+----------------------+
| 1 | Joo da Silva | joao@dasilva.com |
| 2 | Frederico Jos | fred@jose.com |
| 3 | Alberto Santos | alberto@santos.com |
| 4 | Renata Alonso | renata@alonso.com |
O aluno Joo da Silva 1, Alberto Santos 3 e Renata Alonso 4. Agora que sabemos os id s podemos
verificar os seus cursos. Ento vamos comear a nossa query retornando todos os cursos:
Por fim, vamos juntar a matricula com o aluno e retornar o nome do aluno:
Fizemos todas as junes, agora s precisamos do filtro. Precisamos retornar os cursos dos 3 alunos
ao mesmo tempo, podemos utilizar a instruo IN :
SELECT a.nome, c.nome FROM curso c
JOIN matricula m ON m.curso_id = c.id
JOIN aluno a ON m.aluno_id = a.id
WHERE a.id IN (1,3,4);
+----------------+------------------------------------+
| nome | nome |
+----------------+------------------------------------+
| Joo da Silva | SQL e banco de dados |
| Alberto Santos | Scrum e mtodos geis |
| Renata Alonso | C# e orientao a objetos |
| Renata Alonso | Desenvolvimento mobile com Android |
| Joo da Silva | C# e orientao a objetos |
| Alberto Santos | C# e orientao a objetos |
+----------------+------------------------------------+
Retornamos todos os cursos dos 3 alunos, porm ainda t um pouco desorganizado, ento vamos
ordenar pelo nome dos alunos utilizando o ORDER BY :
+----------------+------------------------------------+
Na instituio, sero lanados alguns cursos novos de .NET e o pessoal do comercial precisa divulgar
esses cursos para os ex-alunos, porm apenas para os ex-alunos que j fizeram os cursos de C# e de SQL.
Inicialmente vamos verificar os id s desses cursos:
+----+------------------------------------+
| id | nome |
+----+------------------------------------+
| 1 | SQL e banco de dados |
| 2 | Desenvolvimento web com VRaptor |
| 3 | Scrum e mtodos geis |
| 4 | C# e orientao a objetos |
| 5 | Java e orientao a objetos |
| 6 | Desenvolvimento mobile com iOS |
| 7 | Desenvolvimento mobile com Android |
| 8 | Ruby on Rails |
| 9 | PHP e MySql |
+----+------------------------------------+
Ento juntamos com a matricula e o curso e vamos retornar quais foram os cursos realizados:
Agora utilizaremos o filtro para retornar tanto o curso de SQL(1), quanto o curso de C#(4):
SELECT a.nome, c.nome FROM aluno a
JOIN matricula m ON m.aluno_id = a.id
JOIN curso c ON m.curso_id = c.id
WHERE c.id IN (1, 4);
+-----------------+-----------------------------+
| nome | nome |
+-----------------+-----------------------------+
| Joo da Silva | SQL e banco de dados |
| Frederico Jos | SQL e banco de dados |
| Renata Alonso | C# e orientao a objetos |
| Paulo Jos | SQL e banco de dados |
| Manoel Santos | SQL e banco de dados |
| Joo da Silva | C# e orientao a objetos |
| Frederico Jos | C# e orientao a objetos |
| Alberto Santos | C# e orientao a objetos |
+-----------------+-----------------------------+
+-----------------+-----------------------------+
| nome | nome |
+-----------------+-----------------------------+
| Alberto Santos | C# e orientao a objetos |
| Frederico Jos | SQL e banco de dados |
| Frederico Jos | C# e orientao a objetos |
| Joo da Silva | SQL e banco de dados |
| Joo da Silva | C# e orientao a objetos |
| Manoel Santos | SQL e banco de dados |
| Paulo Jos | SQL e banco de dados |
| Renata Alonso | C# e orientao a objetos |
+-----------------+-----------------------------+
Agora sabemos que apenas os alunos Frederico Jos e Joo da Silva, so os ex-alunos aptos para
realizar os novos cursos de .NET.
10.1 RESUMINDO
Nesse captulo vimos que quando precisamos saber todos os valores de uma determinada coluna
podemos utilizar a instruo DISTINCT para retornar todos os valores distintos, ou seja, sem nenhuma
repetio. Vimos tambm que quando precisamos realizar vrios filtros para uma mesma coluna,
podemos utilizar a instruo IN passando por parmetro todos os valores que esperamos que seja
retornado, ao invs de ficar preenchendo a nossa query com vrios OR s. Vamos para os exerccios?
EXERCCIOS
1. Exiba todos os tipos de matrcula que existem na tabela. Use DISTINCT para que no haja repetio.
2. Exiba todos os cursos e a sua quantidade de matrculas. Mas filtre por matrculas dos tipos PF ou PJ.
3. Traga todas as perguntas e a quantidade de respostas de cada uma. Mas dessa vez, somente dos
cursos com ID 1 e 3.
10.1 RESUMINDO 93
CAPTULO 11
SUB-QUERIES
A instituio precisa de um relatrio mais robusto, com as seguintes informaes: Precisa do nome do
aluno e curso, a mdia do aluno em relao ao curso e a diferena entre a mdia do aluno e a mdia geral
do curso. Demonstrando em uma planilha, o resultado que se espera o seguinte:
Observe que o aluno Alex fez o curso de Java tirou 6 de mdia e a diferena entre a mdia dele e a
mdia geral para o curso de Java foi -1, isso significa que a mdia geral do curso de Java 7, ou seja, 6 - 7.
Vamos analisar o aluno Guilherme, veja que ele tirou 6 de mdia e a diferena foi 0, pois a mdia geral
do curso de SQL 6, ou seja, 6 - 6. Por fim, a aluna Renata tirou mdia 7 no curso de C#, porm a
diferena foi 1, isso significa que a mdia geral 6, ou seja, 7 - 6.
Como voc montaria essa query? Aparentemente um pouco complexa... Ento vamos comear por
partes da mesma forma que fizemos anteriormente. Comearemos pela tabela nota :
+-------+
| nota |
+-------+
| 8.00 |
| 0.00 |
| 7.00 |
| 6.00 |
| 9.00 |
| 10.00 |
| 4.00 |
| 4.00 |
| 7.00 |
| 8.00 |
| 6.00 |
| 7.00 |
94 11 SUB-QUERIES
| 4.00 |
| 9.00 |
| 3.00 |
| 5.00 |
| 5.00 |
| 5.00 |
| 6.00 |
| 8.00 |
| 8.00 |
| 9.00 |
| 10.00 |
| 2.00 |
| 0.00 |
| 1.00 |
| 4.00 |
+-------+
A nossa query est funcionando. Vamos adicionar as tabelas de secao e curso , porm, dessa vez
vamos adicionar o nome do curso:
SELECT c.nome, n.nota FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id;
+---------------------------------+-------+
| nome | nota |
+---------------------------------+-------+
| SQL e banco de dados | 8.00 |
| SQL e banco de dados | 0.00 |
| SQL e banco de dados | 7.00 |
| SQL e banco de dados | 6.00 |
| SQL e banco de dados | 9.00 |
| SQL e banco de dados | 10.00 |
| SQL e banco de dados | 4.00 |
| SQL e banco de dados | 4.00 |
| SQL e banco de dados | 7.00 |
| Desenvolvimento web com VRaptor | 8.00 |
| SQL e banco de dados | 6.00 |
| Scrum e mtodos geis | 7.00 |
| Scrum e mtodos geis | 4.00 |
| Scrum e mtodos geis | 9.00 |
| Scrum e mtodos geis | 3.00 |
| Scrum e mtodos geis | 5.00 |
| Scrum e mtodos geis | 5.00 |
| Scrum e mtodos geis | 5.00 |
| Scrum e mtodos geis | 6.00 |
| Scrum e mtodos geis | 8.00 |
| C# e orientao a objetos | 8.00 |
| C# e orientao a objetos | 9.00 |
| C# e orientao a objetos | 10.00 |
| C# e orientao a objetos | 2.00 |
| C# e orientao a objetos | 0.00 |
| C# e orientao a objetos | 1.00 |
| C# e orientao a objetos | 4.00 |
+---------------------------------+-------+
Por fim, juntaremos a tabela aluno com a tabela resposta e retornaremos o nome do aluno:
11 SUB-QUERIES 95
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id
JOIN aluno a ON r.aluno_id = a.id;
+-----------------+---------------------------------+-------+
| nome | nome | nota |
+-----------------+---------------------------------+-------+
| Joo da Silva | SQL e banco de dados | 8.00 |
| Joo da Silva | SQL e banco de dados | 0.00 |
| Joo da Silva | SQL e banco de dados | 7.00 |
| Joo da Silva | SQL e banco de dados | 6.00 |
| Joo da Silva | SQL e banco de dados | 9.00 |
| Joo da Silva | SQL e banco de dados | 10.00 |
| Joo da Silva | SQL e banco de dados | 4.00 |
| Frederico Jos | SQL e banco de dados | 4.00 |
| Frederico Jos | SQL e banco de dados | 7.00 |
| Frederico Jos | Desenvolvimento web com VRaptor | 8.00 |
| Frederico Jos | SQL e banco de dados | 6.00 |
| Alberto Santos | Scrum e mtodos geis | 7.00 |
| Alberto Santos | Scrum e mtodos geis | 4.00 |
| Alberto Santos | Scrum e mtodos geis | 9.00 |
| Alberto Santos | Scrum e mtodos geis | 3.00 |
| Alberto Santos | Scrum e mtodos geis | 5.00 |
| Alberto Santos | Scrum e mtodos geis | 5.00 |
| Alberto Santos | Scrum e mtodos geis | 5.00 |
| Alberto Santos | Scrum e mtodos geis | 6.00 |
| Alberto Santos | Scrum e mtodos geis | 8.00 |
| Renata Alonso | C# e orientao a objetos | 8.00 |
| Renata Alonso | C# e orientao a objetos | 9.00 |
| Renata Alonso | C# e orientao a objetos | 10.00 |
| Renata Alonso | C# e orientao a objetos | 2.00 |
| Renata Alonso | C# e orientao a objetos | 0.00 |
| Renata Alonso | C# e orientao a objetos | 1.00 |
| Renata Alonso | C# e orientao a objetos | 4.00 |
+-----------------+---------------------------------+-------+
Conseguimos retornar todas as notas do aluno e os cursos, porm ns precisamos das mdias e no
de todas as notas. Ento vamos utilizar a funo AVG() para retornar a mdia do aluno. Lembre-se que
a funo AVG() uma funo de agregao, ou seja, precisamos agrupar o aluno e o curso tambm:
+-----------------+---------------------------------+-------------+
| nome | nome | AVG(n.nota) |
+-----------------+---------------------------------+-------------+
| Alberto Santos | Scrum e mtodos geis | 5.777778 |
| Frederico Jos | Desenvolvimento web com VRaptor | 8.000000 |
| Frederico Jos | SQL e banco de dados | 5.666667 |
| Joo da Silva | SQL e banco de dados | 6.285714 |
| Renata Alonso | C# e orientao a objetos | 4.857143 |
+-----------------+---------------------------------+-------------+
Agora ns temos a mdia do aluno e seu respectivo curso, mas ainda falta a coluna da diferena que
96 11 SUB-QUERIES
calcula a diferena entre a mdia do aluno em um determinado curso e subtrai pela mdia geral. Porm
ainda no temos a mdia geral, ento como podemos pegar a mdia geral? Vamos verificar a tabela
nota :
+----+-------------+-------+
| id | resposta_id | nota |
+----+-------------+-------+
| 1 | 1 | 8.00 |
| 2 | 2 | 0.00 |
| 3 | 3 | 7.00 |
| 4 | 4 | 6.00 |
| 5 | 5 | 9.00 |
| 6 | 6 | 10.00 |
| 7 | 7 | 4.00 |
| 8 | 8 | 4.00 |
| 9 | 9 | 7.00 |
| 10 | 10 | 8.00 |
| 11 | 11 | 6.00 |
| 12 | 12 | 7.00 |
| 13 | 13 | 4.00 |
| 14 | 14 | 9.00 |
| 15 | 15 | 3.00 |
| 16 | 16 | 5.00 |
| 17 | 17 | 5.00 |
| 18 | 18 | 5.00 |
| 19 | 19 | 6.00 |
| 20 | 20 | 8.00 |
| 21 | 21 | 8.00 |
| 22 | 22 | 9.00 |
| 23 | 23 | 10.00 |
| 24 | 24 | 2.00 |
| 25 | 25 | 0.00 |
| 26 | 26 | 1.00 |
| 27 | 27 | 4.00 |
+----+-------------+-------+
Perceba que temos todas as notas, teoricamente as notas de todos os cursos, ou seja, para pegarmos a
mdia geral usaremos o AVG() :
SELECT AVG(n.nota) FROM nota n;
+-------------+
| AVG(n.nota) |
+-------------+
| 5.740741 |
+-------------+
Conseguimos a mdia geral, agora vamos adicionar a coluna diferena. Antes de comear a fazer a
coluna diferena vamos nomear a coluna de mdia do aluno para melhorar a visualizao:
SELECT a.nome, c.nome, AVG(n.nota) as media_aluno FROM nota
...
11 SUB-QUERIES 97
subquery:
SELECT a.nome, c.nome, AVG(n.nota) as media_aluno,
AVG(n.nota) - (SELECT AVG(n.nota) FROM nota n) as diferenca
FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id
JOIN aluno a ON r.aluno_id = a.id
GROUP BY a.nome, c.nome;
+-----------------+---------------------------------+-------------+-----------+
| nome | nome | media_aluno | diferenca |
+-----------------+---------------------------------+-------------+-----------+
| Alberto Santos | Scrum e mtodos geis | 5.777778 | 0.037037 |
| Frederico Jos | Desenvolvimento web com VRaptor | 8.000000 | 2.259259 |
| Frederico Jos | SQL e banco de dados | 5.666667 | -0.074074 |
| Joo da Silva | SQL e banco de dados | 6.285714 | 0.544974 |
| Renata Alonso | C# e orientao a objetos | 4.857143 | -0.883598 |
+-----------------+---------------------------------+-------------+-----------+
Observe que agora retornamos a diferena, mas ser que essas informaes batem? Que tal
retornamos a mdia geral tambm?
SELECT a.nome, c.nome, AVG(n.nota) as media_aluno,
(SELECT AVG(n.nota) FROM nota n) as media_geral,
AVG(n.nota) - (SELECT AVG(n.nota) FROM nota n) as diferenca
FROM nota n
JOIN resposta r ON n.resposta_id = r.id
JOIN exercicio e ON r.exercicio_id = e.id
JOIN secao s ON e.secao_id = s.id
JOIN curso c ON s.curso_id = c.id
JOIN aluno a ON r.aluno_id = a.id
GROUP BY a.nome, c.nome;
+-----------------+---------------------------------+-------------+-------------+-----------+
| nome | nome | media_aluno | media_geral | diferenca |
+-----------------+---------------------------------+-------------+-------------+-----------+
| Alberto Santos | Scrum e mtodos geis | 5.777778 | 5.740741 | 0.037037 |
| Frederico Jos | Desenvolvimento web com VRaptor | 8.000000 | 5.740741 | 2.259259 |
| Frederico Jos | SQL e banco de dados | 5.666667 | 5.740741 | -0.074074 |
| Joo da Silva | SQL e banco de dados | 6.285714 | 5.740741 | 0.544974 |
| Renata Alonso | C# e orientao a objetos | 4.857143 | 5.740741 | -0.883598 |
+-----------------+---------------------------------+-------------+-------------+-----------+
Conseguimos exibir o relatrio como esperado, porm existe um pequeno detalhe. Note que o
resultado da subquery (SELECT AVG(n.nota) FROM nota n) foi de apenas uma linha e justamente por
esse motivo que conseguimos efetuar operaes aritmticas como, nesse caso, a subtrao. Se o resultado
fosse mais de uma linha, no seria possvel realizar operaes.
A instituio precisa de um relatrio do aproveitamento dos alunos nos cursos, ou seja, precisamos
saber se eles esto respondendo todos os exerccios, ento iremos buscar o nmero de respostas que cada
respondeu aluno individualmente. Vamos verificar o que esperado do resultado em uma planilha:
98 11 SUB-QUERIES
Figura 11.2: Planilha exemplo
+-------------+
| COUNT(r.id) |
+-------------+
| 27 |
+-------------+
Sabemos a query que conta as respostas e sabemos a query que retornam os alunos, ento vamos
adicionar a query que conta as respostas dentro da que retorna os alunos, ou seja, vamos fazer
novamente uma subquery!
SELECT a.nome, (SELECT COUNT(r.id) FROM resposta r) AS quantidade_respostas FROM aluno a;
+------------------+----------------------+
| nome | quantidade_respostas |
+------------------+----------------------+
| Joo da Silva | 27 |
| Frederico Jos | 27 |
| Alberto Santos | 27 |
| Renata Alonso | 27 |
| Paulo da Silva | 27 |
| Carlos Cunha | 27 |
| Paulo Jos | 27 |
| Manoel Santos | 27 |
| Renata Ferreira | 27 |
| Paula Soares | 27 |
| Jose da Silva | 27 |
| Danilo Cunha | 27 |
| Zilmira Jos | 27 |
| Cristaldo Santos | 27 |
| Osmir Ferreira | 27 |
| Claudio Soares | 27 |
+------------------+----------------------+
Observe que os resultados da quantidade de respostas foram iguais para todos os alunos, pois no
adicionamos nenhum filtro na subquery. Para resolver o problema, basta adicionar um WHERE
indicando o que precisa ser filtrado, nesse caso, o id dos alunos retornados na query principal:
SELECT a.nome, (SELECT COUNT(r.id) FROM resposta r WHERE r.aluno_id = a.id) AS quantidade_respostas F
ROM aluno a;
+------------------+----------------------+
11 SUB-QUERIES 99
| nome | quantidade_respostas |
+------------------+----------------------+
| Joo da Silva | 7 |
| Frederico Jos | 4 |
| Alberto Santos | 9 |
| Renata Alonso | 7 |
| Paulo da Silva | 0 |
| Carlos Cunha | 0 |
| Paulo Jos | 0 |
| Manoel Santos | 0 |
| Renata Ferreira | 0 |
| Paula Soares | 0 |
| Jose da Silva | 0 |
| Danilo Cunha | 0 |
| Zilmira Jos | 0 |
| Cristaldo Santos | 0 |
| Osmir Ferreira | 0 |
| Claudio Soares | 0 |
+------------------+----------------------+
A instituio precisa de uma relatrio muito parecido com a query que acabamos de fazer, ela precisa
saber quantas matrculas um aluno tem, ou seja, ao nves de resposta, informaremos as matrculas. Ento
vamos apenas substituir as informaes das respostas pelas informaes da matrcula:
SELECT a.nome, (SELECT COUNT(m.id) FROM matricula m WHERE m.aluno_id = a.id) AS quantidade_matricula
FROM aluno a;
+------------------+----------------------+
| nome | quantidade_matricula |
+------------------+----------------------+
| Joo da Silva | 2 |
| Frederico Jos | 3 |
| Alberto Santos | 2 |
| Renata Alonso | 2 |
| Paulo da Silva | 0 |
| Carlos Cunha | 0 |
| Paulo Jos | 1 |
| Manoel Santos | 2 |
| Renata Ferreira | 1 |
| Paula Soares | 1 |
| Jose da Silva | 0 |
| Danilo Cunha | 0 |
| Zilmira Jos | 0 |
| Cristaldo Santos | 0 |
| Osmir Ferreira | 0 |
| Claudio Soares | 0 |
+------------------+----------------------+
100 11 SUB-QUERIES
E ento vamos pegar a quantidade de matriculas:
Temos todos os SELECT s que resolvem um determinado problema, ou seja, agora precisamos juntar
todos eles para resolver a nova necessidade. Ento vamos adicionar as duas queries que contam as
matrculas e as respostas dentro da query principal, ou seja, a que retorna os alunos:
SELECT a.nome,
(SELECT COUNT(m.id) FROM matricula m WHERE m.aluno_id = a.id) AS quantidade_matricula,
(SELECT COUNT(r.id) FROM resposta r WHERE r.aluno_id = a.id) AS quantidade_respostas
FROM aluno a;
+------------------+----------------------+----------------------+
| nome | quantidade_matricula | quantidade_respostas |
+------------------+----------------------+----------------------+
| Joo da Silva | 2 | 7 |
| Frederico Jos | 3 | 4 |
| Alberto Santos | 2 | 9 |
| Renata Alonso | 2 | 7 |
| Paulo da Silva | 0 | 0 |
| Carlos Cunha | 0 | 0 |
| Paulo Jos | 1 | 0 |
| Manoel Santos | 2 | 0 |
| Renata Ferreira | 1 | 0 |
| Paula Soares | 1 | 0 |
| Jose da Silva | 0 | 0 |
| Danilo Cunha | 0 | 0 |
| Zilmira Jos | 0 | 0 |
| Cristaldo Santos | 0 | 0 |
| Osmir Ferreira | 0 | 0 |
| Claudio Soares | 0 | 0 |
+------------------+----------------------+----------------------+
11.1 RESUMINDO
Vimos que nesse captulo aprendemos a utilizar subqueries para resolver diversos problemas, como
por exemplo contar a quantidade de matriculas ou de respostas de um aluno. Tambm vimos que
podemos aplicar operaes aritmticas utilizando subqueries, porm sempre importante lembrar que
s podemos realizar esse tipo de operaes desde que a subquerie retorne uma nica linha. Ento vamos
para os exerccios?
EXERCCIOS
1. Exiba a mdia das notas por aluno, alm de uma coluna com a diferena entre a mdia do aluno e a
mdia geral. Use sub-queries para isso.
3. Exiba a quantidade de matrculas por curso. Alm disso, exiba a diviso entre matrculas naquele
curso e matrculas totais.
Os instrutores da instituio pediram um relatrio com os alunos que so mais participativos na sala de
aula, ou seja, queremos retornar os alunos que responderam mais exerccios. Consequentemente
encontraremos tambm os alunos que no esto participando muito, ento j aproveitamos e
conversamos com eles para entender o que est acontecendo. Ento comearemos retornando o aluno:
SELECT a.nome FROM aluno n;
Agora vamos contar a quantidade de respostas por meio da funo COUNT() e agrupando pelo
nome do aluno:
SELECT a.nome, COUNT(r.id) AS respostas
FROM aluno a
JOIN resposta r ON r.aluno_id = a.id
GROUP BY a.nome;
+-----------------+-----------+
| nome | respostas |
+-----------------+-----------+
| Alberto Santos | 9 |
| Frederico Jos | 4 |
| Joo da Silva | 7 |
| Renata Alonso | 7 |
+-----------------+-----------+
Mas onde esto todos os meus alunos? Fugiram? Aparentemente essa query no est trazendo
exatamente o que a gente esperava... Vamos contar a quantidade de alunos existentes:
SELECT COUNT(a.id) FROM aluno a;
+-------------+
| COUNT(a.id) |
+-------------+
| 16 |
+-------------+
Observe que existe 16 alunos no banco de dados, porm s foram retornados 4 alunos e suas
respostas. Provavelmente no est sendo retornando os alunos que no possuem respostas! Vamos
verificar o que est acontecendo exatamente. Vamos pegar um aluno que no foi retornado, como o de
id 5. Quantas respostas ele tem?
+------------------+
| id |
+------------------+
Tudo bem, ele no respondeu, mas como ele foi desaparecer daquela query nossa? Vamos pegar
outro aluno que desapareceu, o de id 6:
SELECT r.id FROM resposta r WHERE r.aluno_id = 6;
+------------------+
| id |
+------------------+
| 0 |
+------------------+
+------------------+
| id |
+------------------+
| 0 |
+------------------+
Sim, encontramos um padro. Ser que verdadeiro essa teoria que est surgindo na minha cabea?
Alunos sem resposta desapareceram? Vamos procurar todos os alunos que no possuem nenhuma
resposta. Isto selecionar os alunos que no existe, resposta deste aluno:
SELECT a.nome FROM aluno a WHERE NOT EXISTS (SELECT r.id FROM resposta r WHERE r.aluno_id = a.id);
+------------------+
| nome |
+------------------+
| Paulo da Silva |
| Carlos Cunha |
| Paulo Jos |
| Manoel Santos |
| Renata Ferreira |
| Paula Soares |
| Jose da Silva |
| Danilo Cunha |
| Zilmira Jos |
| Cristaldo Santos |
| Osmir Ferreira |
| Claudio Soares |
+------------------+
Se verificarmos os nomes, realmente, todos os alunos que no tem respostas no esto sendo
retornados naquela primeira query. Porm ns queremos tambm que retorne os alunos sem respostas...
Vamos tentar de uma outra maneira, vamos retornar o nome do aluno e a resposta que ele respondeu:
SELECT a.nome, r.resposta_dada FROM aluno a
JOIN resposta r ON r.aluno_id = a.id;
+-----------------+----------------------------------------------------------------------------------
-+
| nome | resposta_dada
|
+----+-----------------+----------+------------------------------------------------------------------
-----------------+
| id | nome | aluno_id | resposta_dada
|
+----+-----------------+----------+------------------------------------------------------------------
-----------------+
| 1 | Joo da Silva | 1 | uma selecao
|
| 1 | Joo da Silva | 1 | ixi, nao sei
|
| 1 | Joo da Silva | 1 | alterar dados
|
| 1 | Joo da Silva | 1 | eskecer o where e alterar tudo
|
| 1 | Joo da Silva | 1 | apagar coisas
|
| 1 | Joo da Silva | 1 | tb nao pode eskecer o where
|
| 1 | Joo da Silva | 1 | inserir dados
|
| 2 | Frederico Jos | 2 | buscar dados
|
| 2 | Frederico Jos | 2 | select campos from tabela
|
| 2 | Frederico Jos | 2 | alterar coisas
|
| 2 | Frederico Jos | 2 | ixi, nao sei
|
| 3 | Alberto Santos | 3 | tempo pra fazer algo
|
| 3 | Alberto Santos | 3 | 1 a 4 semanas
|
| 3 | Alberto Santos | 3 | melhoria do processo
|
| 3 | Alberto Santos | 3 | todo dia
|
| 3 | Alberto Santos | 3 | reuniao de status
|
| 3 | Alberto Santos | 3 | todo dia
|
| 3 | Alberto Santos | 3 | o quadro branco
|
| 3 | Alberto Santos | 3 | um metodo agil
|
| 3 | Alberto Santos | 3 | tem varios outros
|
| 4 | Renata Alonso | 4 | eh a internet
|
| 4 | Renata Alonso | 4 | browser faz requisicao, servidor manda resposta
|
| 4 | Renata Alonso | 4 | eh o servidor que lida com http
|
| 4 | Renata Alonso | 4 | nao sei
|
| 4 | Renata Alonso | 4 | banco de dados!
|
| 4 | Renata Alonso | 4 | eh colocar a app na internet
|
| 4 | Renata Alonso | 4 | depende da tecnologia, mas geralmente eh levar pra um servidor qu
e ta na internet |
+----+-----------------+----------+------------------------------------------------------------------
Perceba que separamos as informaes dos alunos de um lado e a das respostas do outro lado.
Analisando esses dados podemos verificar que quando fizemos o JOIN entre a tabela aluno e
resposta estamos trazendo apenas todos os registros que possuem o id da tabela aluno e o
aluno_id da tabela resposta .
O que o SQL faz tambm que todos os alunos cujo o id no esteja na coluna aluno_id no
sero retornados! Isto , ele s trar para ns algum que o JOIN tenha valor igual nas duas tabelas. Se
s est presente em uma das tabelas, ele ignora.
Em SQL, existe um JOIN diferente que permite o retorno de alunos que tambm no possuam o
id
na tabela que est sendo associada. Queremos pegar todo mundo da tabela da esquerda,
independentemente de existir ou no um valor na tabela da direita. um tal de join de esquerda, o LEFT
JOIN , ou seja, ele trar todos os registros da tabela da esquerda mesmo que no exista uma associao
na tabela da direita:
SELECT a.id, a.nome, r.aluno_id, r.resposta_dada FROM aluno a
LEFT JOIN resposta r ON r.aluno_id = a.id;
+----+------------------+----------+-----------------------------------------------------------------
------------------+
| id | nome | aluno_id | resposta_dada
|
+----+------------------+----------+-----------------------------------------------------------------
------------------+
| 1 | Joo da Silva | 1 | uma selecao
|
| 1 | Joo da Silva | 1 | ixi, nao sei
|
| 1 | Joo da Silva | 1 | alterar dados
|
| 1 | Joo da Silva | 1 | eskecer o where e alterar tudo
|
| 1 | Joo da Silva | 1 | apagar coisas
|
| 1 | Joo da Silva | 1 | tb nao pode eskecer o where
|
| 1 | Joo da Silva | 1 | inserir dados
|
| 2 | Frederico Jos | 2 | buscar dados
|
| 2 | Frederico Jos | 2 | select campos from tabela
|
| 2 | Frederico Jos | 2 | alterar coisas
|
| 2 | Frederico Jos | 2 | ixi, nao sei
|
| 3 | Alberto Santos | 3 | tempo pra fazer algo
|
| 3 | Alberto Santos | 3 | 1 a 4 semanas
|
| 3 | Alberto Santos | 3 | melhoria do processo
|
| 3 | Alberto Santos | 3 | todo dia
|
Conseguimos retornar todos os registros. Ento agora vamos tentar contar novamentes as respostas,
agrupando pelo nome:
SELECT a.nome, COUNT(r.id) AS respostas
FROM aluno a
LEFT JOIN resposta r ON r.aluno_id = a.id
GROUP BY a.nome;
+------------------+-----------+
| nome | respostas |
+------------------+-----------+
Agora conseguimos retornar todos os alunos e a quantidade de respostas, mesmo que o aluno no
tenha respondido pelo menos uma resposta.
No existe exerccio sem resposta, ento vamos inserir uma resposta sem associar a um aluno:
Se verificarmos novamente se existe uma resposta que no foi respondida por um aluno:
SELECT r.id FROM resposta r
WHERE r.aluno_id IS NULL;
+----+
| id |
+----+
| 28 |
+----+
Agora existe uma resposta que no foi associada a um aluno. Da mesma forma que utilizamos um
JOIN diferente para pegar todos os dados da tabela da esquerda (LEFT) mesmo que no tenha
associao com a tabela que est sendo juntada, existe tambm o JOIN que far o procedimento, porm
para a tabela da direita (RIGHT), que o tal do RIGHT JOIN :
+-----------------+----------------------------------------------------------------------------------
-+
| nome | resposta_dada
|
+-----------------+----------------------------------------------------------------------------------
-+
| Joo da Silva | uma selecao
|
| Joo da Silva | ixi, nao sei
|
| Joo da Silva | alterar dados
|
| Joo da Silva | eskecer o where e alterar tudo
|
| Joo da Silva | apagar coisas
|
| Joo da Silva | tb nao pode eskecer o where
|
| Joo da Silva | inserir dados
|
| Frederico Jos | buscar dados
|
| Frederico Jos | select campos from tabela
|
| Frederico Jos | alterar coisas
|
| Frederico Jos | ixi, nao sei
|
| Alberto Santos | tempo pra fazer algo
|
| Alberto Santos | 1 a 4 semanas
|
| Alberto Santos | melhoria do processo
|
| Alberto Santos | todo dia
|
| Alberto Santos | reuniao de status
|
| Alberto Santos | todo dia
|
| Alberto Santos | o quadro branco
|
| Alberto Santos | um metodo agil
|
| Alberto Santos | tem varios outros
|
| Renata Alonso | eh a internet
|
| Renata Alonso | browser faz requisicao, servidor manda resposta
|
| Renata Alonso | eh o servidor que lida com http
|
| Renata Alonso | nao sei
|
| Renata Alonso | banco de dados!
|
| Renata Alonso | eh colocar a app na internet
|
| Renata Alonso | depende da tecnologia, mas geralmente eh levar pra um servidor que ta na internet
Observe que foi retornada a resposta em que no foi respondida por um aluno.
Quando utilizamos apenas o JOIN significa que queremos retornar todos os registros que tenham
uma associao, ou seja, que exista tanto na tabela da esquerda quanto na tabela da direita, esse JOIN
tambm conhecido como INNER JOIN . Vamos verificar o resultado utilizando o INNER JOIN :
SELECT a.nome, COUNT(r.id) AS respostas
FROM aluno a
INNER JOIN resposta r ON r.aluno_id = a.id
GROUP BY a.nome;
+-----------------+-----------+
| nome | respostas |
+-----------------+-----------+
| Alberto Santos | 9 |
| Frederico Jos | 4 |
| Joo da Silva | 7 |
| Renata Alonso | 7 |
+-----------------+-----------+
Ele trouxe apenas os alunos que possuem ao menos uma resposta, ou seja, que exista a associao
entre a tabela da esquerda ( aluno ) e a tabela da direita ( resposta ).
+-----------------+---------------+
| nome | qtd_matricula |
+-----------------+---------------+
| Alberto Santos | 2 |
| Frederico Jos | 3 |
| Joo da Silva | 2 |
| Manoel Santos | 2 |
| Paula Soares | 1 |
| Paulo Jos | 1 |
| Renata Alonso | 2 |
| Renata Ferreira | 1 |
+-----------------+---------------+
+------------------+---------------+
| nome | qtd_matricula |
+------------------+---------------+
| Alberto Santos | 2 |
| Carlos Cunha | 0 |
| Claudio Soares | 0 |
| Cristaldo Santos | 0 |
| Danilo Cunha | 0 |
| Frederico Jos | 3 |
| Joo da Silva | 2 |
| Jose da Silva | 0 |
| Manoel Santos | 2 |
| Osmir Ferreira | 0 |
| Paula Soares | 1 |
| Paulo da Silva | 0 |
| Paulo Jos | 1 |
| Renata Alonso | 2 |
| Renata Ferreira | 1 |
| Zilmira Jos | 0 |
+------------------+---------------+
Da mesma forma que conseguimos pegar todos os alunos e a quantidade de respostas mesmo que o
aluno no tenha respondido nenhuma resposta utilizando o LEFT JOIN poderamos tambm resolver
utilizando uma subquery parecida com qual retornava todos os alunos e a quantidade de matrculas:
SELECT a.nome,
(SELECT COUNT(r.id) FROM resposta r WHERE r.aluno_id = a.id) AS respostas
FROM aluno a;
+------------------+-----------+
| nome | respostas |
+------------------+-----------+
| Joo da Silva | 7 |
| Frederico Jos | 4 |
| Alberto Santos | 9 |
| Renata Alonso | 7 |
| Paulo da Silva | 0 |
| Carlos Cunha | 0 |
| Paulo Jos | 0 |
| Manoel Santos | 0 |
| Renata Ferreira | 0 |
| Paula Soares | 0 |
| Jose da Silva | 0 |
| Danilo Cunha | 0 |
| Zilmira Jos | 0 |
| Cristaldo Santos | 0 |
| Osmir Ferreira | 0 |
| Claudio Soares | 0 |
+------------------+-----------+
Vamos tentar juntar as queries que fizemos agora pouco, porm em uma nica query. Veja o
exemplo em uma planilha.
Primeiro vamos fazer com subqueries. Ento comearemos retornando o nome do aluno:
SELECT a.nome FROM aluno a;
+------------------+---------------+
| nome | qtd_respostas |
+------------------+---------------+
| Joo da Silva | 7 |
| Frederico Jos | 4 |
| Alberto Santos | 9 |
| Renata Alonso | 7 |
| Paulo da Silva | 0 |
| Carlos Cunha | 0 |
| Paulo Jos | 0 |
| Manoel Santos | 0 |
| Renata Ferreira | 0 |
| Paula Soares | 0 |
| Jose da Silva | 0 |
| Danilo Cunha | 0 |
| Zilmira Jos | 0 |
| Cristaldo Santos | 0 |
| Osmir Ferreira | 0 |
| Claudio Soares | 0 |
+------------------+---------------+
SELECT a.nome,
(SELECT COUNT(r.id) FROM resposta r WHERE r.aluno_id = a.id) AS qtd_respostas,
(SELECT COUNT(m.id) FROM matricula m WHERE m.aluno_id = a.id) AS qtd_matriculas
FROM aluno a;
+------------------+---------------+----------------+
| nome | qtd_respostas | qtd_matriculas |
+------------------+---------------+----------------+
| Joo da Silva | 7 | 2 |
| Frederico Jos | 4 | 3 |
| Alberto Santos | 9 | 2 |
| Renata Alonso | 7 | 2 |
Conseguimos o resultado esperado utilizando as subqueries, vamos tentar com o LEFT JOIN ? Da
mesma forma que fizemos anteriormente, comearemos retornando os alunos:
+------------------+---------------+----------------+
| nome | qtd_respostas | qtd_matriculas |
+------------------+---------------+----------------+
| Joo da Silva | 1 | 1 |
| Joo da Silva | 2 | 1 |
| Joo da Silva | 3 | 1 |
| Joo da Silva | 4 | 1 |
| Joo da Silva | 5 | 1 |
| Joo da Silva | 6 | 1 |
| Joo da Silva | 7 | 1 |
| Frederico Jos | 8 | 2 |
| Frederico Jos | 9 | 2 |
| Frederico Jos | 10 | 2 |
| Frederico Jos | 11 | 2 |
| Alberto Santos | 12 | 3 |
| Alberto Santos | 13 | 3 |
| Alberto Santos | 14 | 3 |
| Alberto Santos | 15 | 3 |
| Alberto Santos | 16 | 3 |
| Alberto Santos | 17 | 3 |
| Alberto Santos | 18 | 3 |
| Alberto Santos | 19 | 3 |
| Alberto Santos | 20 | 3 |
| Renata Alonso | 21 | 4 |
| Renata Alonso | 22 | 4 |
| Renata Alonso | 23 | 4 |
| Renata Alonso | 24 | 4 |
| Renata Alonso | 25 | 4 |
| Renata Alonso | 26 | 4 |
| Renata Alonso | 27 | 4 |
| Renata Alonso | 21 | 9 |
| Renata Alonso | 22 | 9 |
| Renata Alonso | 23 | 9 |
| Renata Alonso | 24 | 9 |
+----+
| id |
+----+
| 1 |
+----+
+----+
| id |
+----+
| 1 |
| 11 |
+----+
Foram retornados 2 registros. Se analisarmos um pouco esses trs resultados chegamos aos seguintes
nmeros:
Vamos executar novamente a nossa query que retorna o aluno e a contagem de respostas e
matrculas:
SELECT a.nome, r.id AS qtd_respostas,
m.id AS qtd_matriculas
FROM aluno a
LEFT JOIN resposta r ON r.aluno_id = a.id
LEFT JOIN matricula m ON m.aluno_id = a.id;
+------------------+---------------+----------------+
| nome | qtd_respostas | qtd_matriculas |
+------------------+---------------+----------------+
| Joo da Silva | 1 | 1 |
| Joo da Silva | 2 | 1 |
| Joo da Silva | 3 | 1 |
| Joo da Silva | 4 | 1 |
| Joo da Silva | 5 | 1 |
| Joo da Silva | 6 | 1 |
| Joo da Silva | 7 | 1 |
| Frederico Jos | 8 | 2 |
| Frederico Jos | 9 | 2 |
| Frederico Jos | 10 | 2 |
| Frederico Jos | 11 | 2 |
| Alberto Santos | 12 | 3 |
| Alberto Santos | 13 | 3 |
| Alberto Santos | 14 | 3 |
| Alberto Santos | 15 | 3 |
| Alberto Santos | 16 | 3 |
| Alberto Santos | 17 | 3 |
| Alberto Santos | 18 | 3 |
| Alberto Santos | 19 | 3 |
Repare que a nossa query associando um aluno 1, com a resposta 1 e matrcula 1, o mesmo aluno 1,
com resposta 1 e matrcula 11 e assim sucessivamente... Isso significa que essa query est multiplicando o
aluno(1) x respostas(7) x matrculas(2)... Com certeza essa contagem no funcionar! Precisamos de
resultados distintos, ou seja, iremos utilizar o DISTINCT para evitar esse problema. Agora podemos
contar as respostas e as matrculas:
+------------------+---------------+----------------+
| nome | qtd_respostas | qtd_matriculas |
+------------------+---------------+----------------+
| Alberto Santos | 9 | 2 |
| Carlos Cunha | 0 | 0 |
| Claudio Soares | 0 | 0 |
| Cristaldo Santos | 0 | 0 |
| Danilo Cunha | 0 | 0 |
| Frederico Jos | 4 | 3 |
| Joo da Silva | 7 | 2 |
| Jose da Silva | 0 | 0 |
| Manoel Santos | 0 | 2 |
| Osmir Ferreira | 0 | 0 |
| Paula Soares | 0 | 1 |
| Paulo da Silva | 0 | 0 |
| Paulo Jos | 0 | 1 |
| Renata Alonso | 7 | 2 |
| Renata Ferreira | 0 | 1 |
| Zilmira Jos | 0 | 0 |
+------------------+---------------+----------------+
+------------------+---------------+----------------+
| nome | qtd_respostas | qtd_matriculas |
+------------------+---------------+----------------+
| Alberto Santos | 18 | 18 |
| Carlos Cunha | 0 | 0 |
| Claudio Soares | 0 | 0 |
| Cristaldo Santos | 0 | 0 |
| Danilo Cunha | 0 | 0 |
| Frederico Jos | 12 | 12 |
| Joo da Silva | 14 | 14 |
| Jose da Silva | 0 | 0 |
| Manoel Santos | 0 | 2 |
| Osmir Ferreira | 0 | 0 |
| Paula Soares | 0 | 1 |
| Paulo da Silva | 0 | 0 |
| Paulo Jos | 0 | 1 |
| Renata Alonso | 14 | 14 |
| Renata Ferreira | 0 | 1 |
| Zilmira Jos | 0 | 0 |
+------------------+---------------+----------------+
O resultado alm de ser bem maior que o esperado, repete nas duas colunas , pois est acontecendo
aquele problema da multiplicao das linhas! Perceba que s conseguimos verificar de uma forma rpida
o problema que aconteceu, pois fizemos a query passo-a-passo, verificando cada resultado e, ao mesmo
12.3 RESUMINDO
Neste captulo aprendemos como utilizar os diferentes tipos de JOIN s, como por exemplo o LEFT
JOIN que retorna os registros da tabela a esquerda e o RIGHT JOIN que retorna os da direita mesmo
que no tenham associaes. Vimos tambm que o JOIN tambm conhecido como INNER JOIN que
retorna apenas os registros que esto associados. Alm disso, vimos que algumas queries podem ser
resolvidas utilizando subqueries ou LEFT/RIGHT JOIN , porm importante lembrar que os SGBDs
sempre tero melhor desempenho com o os JOIN s, por isso recomendado que utilize os JOIN s.
Vamos para os exerccios?
EXERCCIOS
1. Exiba todos os alunos e suas possveis respostas. Exiba todos os alunos, mesmo que eles no tenham
respondido nenhuma pergunta.
2. Exiba agora todos os alunos e suas possveis respostas para o exerccio com ID = 1. Exiba todos os
alunos mesmo que ele no tenha respondido o exerccio.
1. Qual a diferena entre o JOIN convencional (muitas vezes chamado tambm de INNER JOIN) para
o LEFT JOIN?
Precisamos de um relatrio que retorne todos os alunos, algo como selecionar o nome de todos eles, com
um SELECT simples:
SELECT a.nome FROM aluno a;
+------------------+
| nome |
+------------------+
| Joo da Silva |
| Frederico Jos |
| Alberto Santos |
| Renata Alonso |
| Paulo da Silva |
| Carlos Cunha |
| Paulo Jos |
| Manoel Santos |
| Renata Ferreira |
| Paula Soares |
| Jose da Silva |
| Danilo Cunha |
| Zilmira Jos |
| Cristaldo Santos |
| Osmir Ferreira |
| Claudio Soares |
+------------------+
Para melhorar o resultado podemos ordernar a query por ordem alfabtica do nome:
+------------------+
| nome |
+------------------+
| Alberto Santos |
| Carlos Cunha |
| Claudio Soares |
| Cristaldo Santos |
| Danilo Cunha |
| Frederico Jos |
| Joo da Silva |
| Jose da Silva |
| Manoel Santos |
| Osmir Ferreira |
| Paula Soares |
| Paulo da Silva |
| Paulo Jos |
| Renata Alonso |
| Renata Ferreira |
| Zilmira Jos |
+----------+
| count(*) |
+----------+
| 16 |
+----------+
Como podemos ver, uma quantidade relativamente baixa, pois quando estamos trabalhando em
uma aplicao real, geralmente o volume de informaes muito maior.
No facebook, por exemplo, quantos amigos voc tem? Quando voc entra no facebook, aparece todas
as atualizaes dos seus amigos de uma vez? Todas as milhares de atualizaes de uma nica vez?
Imagine a loucura que trazer milhares de dados de uma nica vez para voc ver apenas 5, 10
notificaes. Provavelmente vai aparecendo aos poucos, certo? Ento que tal mostrarmos os alunos aos
poucos tambm? Ou seja, fazermos uma paginao no nosso relatrio, algo como 5 alunos "por pgina".
Mas como podemos fazer isso? No MySQL, podemos limitar em 5 a quantidade de registros que
desejamos retornar:
+------------------+
| nome |
+------------------+
| Alberto Santos |
| Carlos Cunha |
| Claudio Soares |
| Cristaldo Santos |
| Danilo Cunha |
+------------------+
Nesse caso retornamos os primeiros 5 alunos em ordem alfabtica. O ato de limitar extremamente
importante a medida que os dados crescem. Se voc tem mil mensagens antigas, no vai querer ver as
mil de uma vez s, traga somente as 10 primeiras e, se tiver interesse, mais 10, mais 10 etc.
+-----------------+
| nome |
LIMIT 5 ? LIMIT 5,5 ? Parece um pouco estranho, o que ser que isso significa? Quando
utilizamos o LIMIT
funciona da seguinte maneira: LIMIT
linha_inicial,qtd_de_linhas_para_avanar , ou seja, quando fizemos LIMIT 5 , informamos ao
MySQL que avane 5 linhas apenas, pois por padro ele iniciar pela primeira linha, chamada de linha
0 . Se fizssemos LIMIT 0,5 , por exemplo:
+------------------+
| nome |
+------------------+
| Alberto Santos |
| Carlos Cunha |
| Claudio Soares |
| Cristaldo Santos |
| Danilo Cunha |
+------------------+
Perceba que o resultado o mesmo que LIMIT 5 ! Se pedimos LIMIT 5,10 o que ele nos trs?
SELECT a.nome FROM aluno a
ORDER BY a.nome
LIMIT 5,10;
+-----------------+
| nome |
+-----------------+
| Frederico Jos |
| Joo da Silva |
| Jose da Silva |
| Manoel Santos |
| Osmir Ferreira |
| Paula Soares |
| Paulo da Silva |
| Paulo Jos |
| Renata Alonso |
| Renata Ferreira |
+-----------------+
O resultado iniciar aps a linha 5, ou seja, linha 6 e avanar 10 linhas. Vamos demonstrar os
exemplos todos de uma nica vez:
Todos os alunos:
+------------------+
| nome |
Pegando os 5 primeiros:
+------------------+
| nome |
+------------------+
| Alberto Santos |
| Carlos Cunha |
| Claudio Soares |
| Cristaldo Santos |
| Danilo Cunha |
+------------------+
+-----------------+
| nome |
+-----------------+
| Frederico Jos |
| Joo da Silva |
| Jose da Silva |
| Manoel Santos |
| Osmir Ferreira |
+-----------------+
13.2 RESUMINDO
Nesse captulo vimos como nem sempre retornar todos os registros das tabelas so necessrios,
algumas vezes, precisamos filtrar a quantidade de linhas, pois em uma aplicao real, podemos lidar com
uma quantidade bem grande de dados. Justamente por esse caso, podemos limitar as nossas queries
utilizando a instruo LIMIT . Vamos para os exerccios?
2. Escreva uma SQL que devolva os 3 primeiros alunos que o e-mail termine com o domnio ".com".
3. Devolva os 2 primeiros alunos que o e-mail termine com ".com", ordenando por nome.
4. Devolva todos os alunos que tenham Silva em algum lugar no seu nome.