🎓 Aula Master una
Orientações do professor · tecla P

Aula 5 (24/09) · JOIN + agregar. 17/09 sem aula. INNER: SELECT v.id, l.titulo, v.qtd FROM venda v INNER JOIN livro l ON v.id_livro = l.id. Núcleo SP3: SUM(qtd) WHERE março GROUP BY livro HAVING SUM(qtd) < 5. LEFT: livro sem venda (NULL). Próxima: DDL Aula 6 · 01/10.

Alimentar (lab): quem só deu CREATE na Aula 4 cola o INSERT (não projetar o bloco inteiro). Quem abre exemplo.db já tem linhas.

INSERT INTO aluno (Nome, Idade, Curso, telefone) VALUES
  ('Ana Souza', 19, 'Sistemas de Informação', '31999990001'),
  ('Bruno Lima', 21, 'Ciência da Computação', NULL),
  ('Carla Dias', 20, 'Sistemas de Informação', '31988880002'),
  ('Diego Alves', 22, 'Engenharia', '31977770003');
INSERT INTO biblioteca (Nome_livro, Data, Curso) VALUES
  ('Introdução a SQL', '2026-02-10 09:00:00', 'Sistemas de Informação'),
  ('Banco de dados', '2026-03-01 14:00:00', 'Ciência da Computação'),
  ('Redes de computadores', '2026-03-15 10:00:00', 'Engenharia');
INSERT INTO reserva_livro (Cod_biblioteca, Cod_aluno, Data) VALUES
  (1, 1, '2026-03-10 11:00:00'), (1, 3, '2026-03-11 09:30:00'),
  (2, 2, '2026-03-12 16:00:00'), (2, 1, '2026-03-18 10:00:00'),
  (3, 4, '2026-04-02 13:00:00');

Lab aluno/reserva: Letos ou exemplo.db. SELECT a.Nome, b.Nome_livro, r.Data FROM reserva_livro r INNER JOIN aluno a ON r.Cod_aluno = a.Cod_aluno INNER JOIN biblioteca b ON r.Cod_biblioteca = b.Cod_biblioteca;

Atividade por e-mail (até 01/10): assunto BD Aula 5 · Atividade SQLite · nome. Gabarito: PRAGMA foreign_keys = ON; CREATE aluno (Cod_aluno INTEGER PRIMARY KEY AUTOINCREMENT, Nome TEXT, Idade INTEGER, Curso TEXT); ALTER TABLE aluno ADD COLUMN telefone TEXT; CREATE biblioteca; CREATE reserva_livro com Cod_reserva_livro PK e duas FOREIGN KEY. Esperado após UPDATE/DELETE: Bruno com telefone 31966660004; reserva_livro com 4 linhas; INSERT com Cod_aluno 99 falha (FOREIGN KEY constraint failed).

Correção (checklist): 3 CREATE corretos (FKs na reserva), prints de validação, INSERT, DELETE e UPDATE com WHERE. Anexos: .db + .sql. Sem WHERE no UPDATE/DELETE = item não cumprido.

Grupo Ânima Educação
Aula 5 · UA3 · 24/09/2026 · Banco de Dados

JOIN e agregação
ligar e resumir

Hoje: INNER JOIN, INSERT do lab, GROUP BY / HAVING e LEFT JOIN. DDL fica em 01/10.

Prof. Ramon Pedrosa · quinta · 2h
UA3 · SQL 2/3
Problema

O título não está em VENDA

WHERE sozinho não chega

O que é uma tabela

Uma tabela parece uma planilha. Cada linha é um registro (uma venda, um livro). Cada coluna é um campo (id, título, quantidade, data).

Por que várias tabelas

O banco guarda cada informação em um lugar só. O título do livro fica em LIVRO. A venda guarda só o número do livro. Assim o título não se repete em mil vendas, e uma correção no nome vale para todas.

SELECT * FROM venda;
idid_livroqtddata_venda
10122026-03-05
11112026-03-09
12252026-03-12

A pergunta do gerente

“Qual livro vendeu em março?” A tabela VENDA só responde com números: livro 1, livro 2. O nome do livro não está aqui. O WHERE da aula passada filtra linhas, mas só dentro de uma tabela — não busca o título em outra.

Conclusão: precisamos juntar VENDA com LIVRO na mesma consulta, trocando o número pelo título. Juntar tabelas é o trabalho do JOIN.
Relacionamento

A ponte já existe no modelo

1 livro · N vendas

LIVRO

id PK
titulo
isbn, ano, preco
1 FK aponta N

VENDA

id PK
id_livro FK → livro.id
qtd
data_venda

PK · chave primária

É o “RG” do livro. livro.id identifica um livro só e nunca se repete: não existem dois livros com id 1.

FK · chave estrangeira

É a anotação do RG do livro dentro da venda. venda.id_livro = 1 quer dizer “esta venda foi do livro de id 1”. Vários registros de venda podem apontar para o mesmo livro (1 livro, N vendas).

O JOIN usa essa ponte: procura, para cada venda, o livro cujo id é igual ao id_livro da venda.
Sintaxe

Como se escreve um INNER JOIN

Linha a linha

O INNER JOIN junta duas ou mais tabelas e traz só os registros que têm par nas duas. Se um registro de uma tabela não tem correspondência na outra, ele não aparece no resultado.
Forma geral
SELECT colunas
FROM tabela1
INNER JOIN tabela2
  ON tabela1.coluna = tabela2.coluna;
Nosso caso
1  SELECT v.id, l.titulo, v.qtd
2  FROM venda AS v
3  INNER JOIN livro AS l
4    ON v.id_livro = l.id;
1SELECT: escolhe as colunas do resultado. v.id e v.qtd vêm da venda; l.titulo vem do livro.
2FROM venda AS v: a consulta começa pela tabela VENDA. AS v dá um apelido (alias) curto.
3INNER JOIN livro AS l: traz a tabela LIVRO para a consulta, com apelido l.
4ON: regra da ligação. A venda casa com o livro quando id_livro (FK) é igual a id (PK).

Alias

AS v é só um apelido. Em vez de escrever venda.id_livro, escreve v.id_livro. O prefixo é obrigatório quando as duas tabelas têm uma coluna com o mesmo nome (as duas têm id).

ON x WHERE

ON diz como as tabelas se ligam (FK = PK). WHERE filtra depois que já estão juntas, por exemplo só vendas de março.

1 livro, N vendas

Se o livro 1 tem duas vendas, o título aparece em duas linhas do resultado. Isso é correto: uma linha por venda, com o título copiado. O cadastro do livro não muda.

Referências: DevMedia · SQL INNER JOIN · Coddy · SQLite INNER JOIN

INNER JOIN

Só linhas que casam

Python não tem venda → some

livro

idtitulo
1SQL na Prática
2Redes
3Python

venda

idid_livroqtd
1012
1111
1225

resultado INNER

vendatituloqtd
10SQL na Prática2
11SQL na Prática1
12Redes5
SELECT v.id, l.titulo, v.qtd
FROM venda AS v
INNER JOIN livro AS l ON v.id_livro = l.id;
Cada venda procura o livro com o mesmo id. Quem não casa (Python, ou venda órfã) fica de fora. No SQLite, JOIN e INNER JOIN são a mesma coisa.

Modelo mental: Coddy · SQLite INNER JOIN

Passo a passo

Como o banco lê o JOIN

A ordem não é a ordem em que escrevemos

Nós escrevemos o SELECT primeiro, mas o banco executa em outra ordem. Entender essa ordem ajuda a prever o resultado antes de rodar a consulta.
SELECT l.titulo, v.qtd          -- 4
FROM venda AS v                  -- 1
INNER JOIN livro AS l            -- 2
  ON v.id_livro = l.id           -- 2
WHERE v.qtd >= 2;                -- 3
1FROM: o banco pega todas as linhas de VENDA (10, 11 e 12). É o ponto de partida.
2JOIN + ON: para cada venda, procura em LIVRO a linha com o mesmo id. Venda 10 e 11 acham “SQL na Prática”; venda 12 acha “Redes”. Agora cada linha tem colunas das duas tabelas.
3WHERE: descarta linhas que não passam no filtro. A venda 11 (qtd 1) sai.
4SELECT: por último, mostra só as colunas pedidas: título e quantidade.
tituloqtd
SQL na Prática2
Redes5

Modelo mental “casar linhas e depois filtrar”: Coddy · INNER JOIN

Produto cartesiano

O erro clássico: esquecer o ON

Todas as combinações possíveis

Se você junta duas tabelas sem dizer como elas se ligam, o banco combina cada linha de uma com cada linha da outra. Isso se chama produto cartesiano (ou CROSS JOIN). Com 3 vendas e 3 livros saem 3 × 3 = 9 linhas, e só 3 fazem sentido.
-- ERRADO: vírgula sem ON
SELECT v.id, v.id_livro, l.id, l.titulo
FROM venda v, livro l;
-- CERTO: com a regra de ligação
SELECT v.id, l.titulo
FROM venda v
INNER JOIN livro l ON v.id_livro = l.id;
vendaid_livrolivro.idtitulo
1011SQL na Prática
1012Redes ✗
1013Python ✗
1111SQL na Prática
1112Redes ✗
1113Python ✗
1221SQL na Prática ✗
1222Redes
1223Python ✗
As linhas com ✗ são lixo: a venda não é daquele livro. Numa loja real, 100 000 vendas × 5 000 livros = 500 milhões de linhas. A consulta trava e o relatório sai errado. O ON é o que deixa só as linhas em negrito.
O que JOIN não é

Nem PROCV nem UNION

Três operações parecidas, resultados diferentes

PROCV (Excel)

Busca um valor em outra planilha e devolve uma célula. Se houver dois resultados, pega só o primeiro. Funciona célula por célula.

UNION (SQL)

Empilha linhas: coloca o resultado de uma consulta embaixo do de outra. As colunas precisam ser do mesmo tipo. Ex.: clientes de BH + clientes de SP numa lista só.

JOIN (SQL)

Põe lado a lado: cada linha do resultado junta colunas de duas tabelas. Trabalha com conjuntos inteiros e traz todas as combinações que casam, não só a primeira.

UNION: empilha (mais linhas)
nome
Ana (BH)
Bruno (BH)
Carla (SP)
JOIN: lado a lado (mais colunas)
vendaqtdtitulo
102SQL na Prática
125Redes
Dica para lembrar: UNION cresce para baixo; JOIN cresce para o lado. E o LEFT JOIN, que veremos adiante, é um JOIN que mantém até as linhas sem par.
Mundo real

Estoque físico vs cadastro

O banco guarda registros, não objetos

Depósito com prateleiras e paletes

Cadastro (tabela LIVRO)

Uma linha por livro: título, ISBN, preço. Descreve o que o produto é. Muda pouco.

Documento (tabela VENDA)

Uma linha por acontecimento: quem vendeu, quanto, quando. Cresce todo dia.

O JOIN

Liga o documento ao cadastro para o relatório ficar legível. Ele não conta caixas na prateleira: só cruza o que foi registrado no sistema.

Foto: Wikimedia Commons (depósito, licença CC). Se o estoque físico e o sistema não batem, o problema é de registro, não do JOIN.

Três tabelas

Encadear mais um JOIN

Só leitura hoje · não vamos exercitar

A SP3 pergunta também pelo fornecedor. O fornecedor não está em VENDA nem direto no título: LIVRO guarda id_fornecedor, que aponta para FORNECEDOR. Para chegar lá, basta acrescentar outro INNER JOIN ... ON .... Cada JOIN liga o resultado parcial a mais uma tabela.
1  SELECT v.id, l.titulo, f.nome
2  FROM venda AS v
3  INNER JOIN livro AS l
4    ON v.id_livro = l.id
5  INNER JOIN fornecedor AS f
6    ON l.id_fornecedor = f.id;
2Começa por VENDA.
3-4Liga cada venda ao seu livro (FK id_livro).
5-6Liga cada livro ao seu fornecedor (FK id_fornecedor).
1Mostra colunas das três tabelas: número da venda, título e nome do fornecedor.
Leia de cima para baixo: venda → livro → fornecedor. A regra do INNER vale em cada etapa: se o livro não tiver fornecedor cadastrado, a venda some do resultado.

Exemplo com três tabelas: DevMedia · exemplo 2 · Coddy · 3 tabelas

Filtro depois

WHERE depois do JOIN

Só as vendas de março

ON diz como as tabelas se ligam. WHERE filtra o resultado já ligado. Cada um tem seu papel: ligação no ON, filtro de linha no WHERE. Agora a tabela VENDA tem uma venda de abril (13) que não deve entrar no relatório de março.
idid_livroqtddata_venda
10122026-03-05
11112026-03-09
12252026-03-12
13242026-04-02
1  SELECT l.titulo, v.qtd, v.data_venda
2  FROM venda v
3  INNER JOIN livro l ON v.id_livro = l.id
4  WHERE v.data_venda >= '2026-03-01'
5    AND v.data_venda <  '2026-04-01';
3Liga venda e livro (4 linhas).
4>= “maior ou igual”: entra o dia 1º de março.
5< “menor que” 1º de abril: entra até o último segundo de 31/03, e a venda 13 sai. AND exige as duas condições.
!Por que não <= '2026-03-31'? Se a data tiver hora (2026-03-31 15:00), ela é “maior” que 2026-03-31 e ficaria de fora.
tituloqtddata
SQL na Prática203-05
SQL na Prática103-09
Redes503-12
Qualidade

Venda órfã: o dado sujo que some

FK apontando para o nada

Uma venda órfã é uma venda cujo id_livro não existe na tabela LIVRO. Acontece quando alguém apaga um livro que já tinha venda, ou digita o código errado. O INNER JOIN não acha par e esconde a venda sem avisar: o total do relatório fica menor e ninguém percebe.
venda.idid_livroqtd
1012
1225
1499 (não existe)7

INNER JOIN devolve só 10 e 12. As 7 unidades da venda 14 desaparecem.

Como impedir (Aula 6)

No CREATE TABLE, declarar FOREIGN KEY (id_livro) REFERENCES livro(id). O banco passa a recusar venda com livro inexistente.

Detalhe do SQLite

No SQLite a checagem de FK vem desligada. É preciso rodar PRAGMA foreign_keys = ON; a cada conexão. Sem isso, a FK é só enfeite.

Fonte: SQLite · Foreign Key Support · Coddy · Chaves estrangeiras

Prática rápida

Testar o JOIN no navegador

sqliteonline.com · sem instalar nada

1Abra sqliteonline.com. Do lado esquerdo, deixe selecionado SQLite. O editor já é um banco vazio na memória do navegador.
2Cole o script abaixo e clique em Run. Ele cria as duas tabelas e coloca os dados que usamos nos slides.
CREATE TABLE livro (id INTEGER PRIMARY KEY, titulo TEXT);
CREATE TABLE venda (id INTEGER PRIMARY KEY, id_livro INTEGER, qtd INTEGER, data_venda TEXT);
INSERT INTO livro VALUES (1,'SQL na Prática'), (2,'Redes'), (3,'Python');
INSERT INTO venda VALUES (10,1,2,'2026-03-05'), (11,1,1,'2026-03-09'),
                         (12,2,5,'2026-03-12'), (13,2,4,'2026-04-02');
3Apague o script e rode o INNER JOIN do slide de sintaxe. Resultado esperado: 4 linhas, uma por venda, porque toda venda tem livro válido.
4Confira: número de linhas do JOIN = número de vendas. Se der menos, existe venda órfã. Se der muito mais, faltou o ON.
Vocabulário

Glossário da aula

Uma frase por termo

TermoO que significa
TabelaConjunto de dados sobre um assunto (livros, vendas), organizado em linhas e colunas.
RegistroUma linha da tabela: um livro, uma venda.
Coluna (campo)Uma informação de cada registro: título, quantidade, data.
PK · chave primáriaColuna que identifica cada registro sem repetir (o “RG”).
FK · chave estrangeiraColuna que guarda a PK de outra tabela e cria o relacionamento.
INNER JOINJunta duas tabelas e traz só as linhas que têm par nas duas.
ONCondição que diz como as linhas casam (FK = PK).
AliasApelido curto de uma tabela na consulta (venda AS v).
Produto cartesianoJunção sem condição: toda linha com toda linha. Quase sempre é erro.
AgregaçãoResumir várias linhas em um número: contar, somar, média.
NULL“Sem valor”. Não é zero nem texto vazio: é ausência de informação.
LEFT JOINComo o INNER, mas mantém todas as linhas da tabela da esquerda, mesmo sem par.
Objetivo

O que você sai sabendo hoje

E o que fica para depois

Entra hoje
✓INNER JOIN: juntar venda e livro para mostrar o título no lugar do código.
✓WHERE depois do JOIN: filtrar o período (março).
✓COUNT e SUM: contar vendas e somar unidades.
✓GROUP BY e HAVING: um total por livro e filtrar esses totais.
✓LEFT JOIN: achar livro que não vendeu.
✓INSERT do lab: colocar dados nas tabelas aluno, biblioteca e reserva.
Fica para depois
→CREATE TABLE, UPDATE, DELETE: aparecem só na atividade de casa (passo a passo nos slides); aprofundados na Aula 6 (01/10).
→CTE, funções de janela, normalização (3FN): fora desta disciplina por agora. Não caem na SP3.
Atividade

Venda com título

Em dupla · no papel · 20 min

Cenário

O gerente da livraria quer dois relatórios. Use só as tabelas venda (id, id_livro, qtd, data_venda) e livro (id, titulo). Escreva o SQL à mão, como se fosse rodar no SQLite.

Questão 1 · INNER JOIN

Liste cada venda com: número da venda, título do livro e quantidade. Dica: comece por FROM venda, ligue com livro e use a FK no ON.

Questão 2 · Núcleo SP3

Mostre os livros que venderam menos de 5 unidades em março. Dica: WHERE para o período, SUM para somar, GROUP BY para um total por livro, HAVING para o “menos de 5”.

Entregar: folha com os nomes da dupla e as duas consultas. Critério: ON com FK = PK, colunas com prefixo (v. / l.), WHERE antes do GROUP BY e HAVING depois. Sintaxe perfeita não é exigida; a lógica sim.
Atividade · regras

O que pode e o que não pode

Para todos chegarem ao mesmo tipo de resposta

1Só duas tabelas (venda e livro). Fornecedor fica de fora nesta atividade.
2Use INNER JOIN com ON. Não vale a vírgula FROM venda, livro: ela gera produto cartesiano.
3Período no WHERE: o filtro de março atua nas linhas, antes de agrupar.
4Total no HAVING: “menos de 5” é sobre a soma, que só existe depois do GROUP BY.
5Sem CTE nem subconsulta: não é preciso, e ainda não vimos.
Ordem das cláusulas que o SQL exige: SELECT → FROM → JOIN … ON → WHERE → GROUP BY → HAVING → ORDER BY. Trocar a ordem dá erro de sintaxe.
Debrief

Correção da Questão 1

O que o quadro marca

1  SELECT v.id, l.titulo, v.qtd
2  FROM venda v
3  INNER JOIN livro l
4    ON v.id_livro = l.id;
1Três colunas pedidas. O título vem de l; número e quantidade vêm de v.
2-3Duas tabelas com apelido. AS é opcional: venda v = venda AS v.
4O ponto que mais vale: a FK da venda igual à PK do livro.
idtituloqtd
10SQL na Prática2
11SQL na Prática1
12Redes5
13Redes4

A Questão 2 é corrigida no slide de GROUP BY e HAVING.

Erros de sala

Respostas que não valem

E por quê

FROM venda, livro sem ON

Produto cartesiano: cada venda aparece com todos os livros. 4 vendas × 3 livros = 12 linhas, a maioria errada.

ON v.id = l.id

Liga a PK da venda com a PK do livro. A venda 10 procuraria o livro 10, que não existe. A ligação correta usa a FK: v.id_livro = l.id.

SELECT id, titulo ...

Coluna ambígua: as duas tabelas têm id. O SQLite responde “ambiguous column name”. Use o prefixo v.id.

WHERE SUM(v.qtd) < 5

O WHERE roda antes de agrupar, quando a soma ainda não existe. O SQLite dá erro “misuse of aggregate”. Filtro sobre soma vai no HAVING.

Agregação

Funções de agregação

Transformar muitas linhas em um número

Uma função de agregação olha várias linhas e devolve um só valor. É como a barra de status do Excel mostrando soma e média do que está selecionado. Exemplo: as 3 vendas de março.
idid_livroqtd
1012
1111
1225
FunçãoO que fazResultado
COUNT(*)Conta linhas (quantas vendas)3
SUM(qtd)Soma os valores (unidades)8
AVG(qtd)Média2,67
MIN(qtd)Menor valor1
MAX(qtd)Maior valor5
SELECT COUNT(*) AS vendas, SUM(qtd) AS unidades
FROM venda
WHERE data_venda >= '2026-03-01' AND data_venda < '2026-04-01';
COUNT x SUM: COUNT diz quantas vendas houve (3). SUM diz quantos livros saíram (8). A SP3 pergunta por unidades, então usa SUM. AS vendas dá nome à coluna do resultado. COUNT, SUM e AVG ignoram valores NULL.

Fonte: Coddy · Funções de agregação · W3Schools · COUNT, AVG, SUM

Agregação

GROUP BY e HAVING

Um total por livro · núcleo da SP3

Sozinho, SUM(qtd) dá um total geral (8). GROUP BY separa as linhas em grupos, um por livro, e calcula a soma de cada grupo. HAVING filtra esses grupos depois que a soma está pronta.
Antes: linhas de março após o JOIN
tituloqtd
SQL na Prática2
SQL na Prática1
Redes5
Depois do GROUP BY
titulototal
SQL na Prática3
Redes5 (sai no HAVING)
1  SELECT l.titulo, SUM(v.qtd) AS total
2  FROM venda v
3  INNER JOIN livro l ON v.id_livro = l.id
4  WHERE v.data_venda >= '2026-03-01'
5    AND v.data_venda <  '2026-04-01'
6  GROUP BY l.id, l.titulo
7  HAVING SUM(v.qtd) < 5;

Linhas 4-5 · WHERE

Age antes de agrupar, linha por linha. Tira a venda de abril.

Linha 6 · GROUP BY

Junta as linhas do mesmo livro. Toda coluna do SELECT que não é soma precisa estar aqui.

Linha 7 · HAVING

Age depois, sobre o total do grupo. Resultado: só “SQL na Prática · 3”.

Fonte: Coddy · GROUP BY e HAVING · W3Schools · GROUP BY

LEFT JOIN

Achar o livro que não vendeu

Manter linhas sem par

O INNER JOIN esconde quem não tem par, por isso o livro “Python” nunca aparece. O LEFT JOIN mantém todas as linhas da tabela da esquerda (a que vem no FROM). Quando não há par na direita, as colunas da direita vêm NULL (vazio).
1  SELECT l.titulo, v.id AS venda
2  FROM livro l
3  LEFT JOIN venda v
4    ON v.id_livro = l.id;
2Agora começamos por LIVRO: ele é a tabela “da esquerda”, e todos os livros ficam.
3-4Traz as vendas de cada livro, se houver.
titulovenda
SQL na Prática10
SQL na Prática11
Redes12
Redes13
PythonNULL
-- Só os livros parados:
SELECT l.titulo FROM livro l
LEFT JOIN venda v ON v.id_livro = l.id
WHERE v.id IS NULL;
Para testar vazio use IS NULL. = NULL nunca é verdadeiro, porque NULL não é igual a nada, nem a outro NULL. Uso real: estoque de BH sem movimento, cliente que nunca comprou.

Fonte: Coddy · LEFT JOIN · W3Schools · LEFT JOIN

Lab · INSERT

Alimentar as três tabelas

Para quem só criou as tabelas na Aula 4

Tabela criada com CREATE está vazia. Sem linhas, qualquer JOIN devolve nada. O comando INSERT INTO coloca registros na tabela. Se você abriu o exemplo.db, os dados já estão lá: pule este slide.
1  INSERT INTO aluno (Nome, Idade, Curso, telefone) VALUES
2    ('Ana Souza', 19, 'Sistemas de Informação', '31999990001'),
3    ('Bruno Lima', 21, 'Ciência da Computação', NULL),
4    ('Carla Dias', 20, 'Sistemas de Informação', '31988880002'),
5    ('Diego Alves', 22, 'Engenharia', '31977770003');

INSERT INTO biblioteca (Nome_livro, Data, Curso) VALUES
  ('Introdução a SQL', '2026-02-10 09:00:00', 'Sistemas de Informação'),
  ('Banco de dados', '2026-03-01 14:00:00', 'Ciência da Computação'),
  ('Redes de computadores', '2026-03-15 10:00:00', 'Engenharia');

INSERT INTO reserva_livro (Cod_biblioteca, Cod_aluno, Data) VALUES
  (1, 1, '2026-03-10 11:00:00'), (1, 3, '2026-03-11 09:30:00'),
  (2, 2, '2026-03-12 16:00:00'), (2, 1, '2026-03-18 10:00:00'),
  (3, 4, '2026-04-02 13:00:00');
1INSERT INTO aluno (colunas): diz em qual tabela e em quais colunas os valores vão entrar, nessa ordem.
2VALUES (...): cada par de parênteses é uma linha nova. Texto vai entre aspas simples; número vai sem aspas.
3NULL: Bruno não informou telefone. NULL é “sem valor”, diferente de '' (texto vazio).
PKCod_aluno não aparece: é PK com AUTOINCREMENT, o SQLite numera sozinho (Ana = 1, Bruno = 2…).
FKEm reserva_livro, (1, 3, …) quer dizer livro 1 reservado pela aluna 3 (Carla). Insira aluno e biblioteca antes da reserva.

Fonte: Coddy · INSERT

Lab complementar

Quem reservou qual livro

exemplo.db · sqlite3 · em dupla

A tabela reserva_livro é igual à VENDA dos slides: só guarda códigos (Cod_aluno, Cod_biblioteca). Para ler nomes, é preciso ligar com aluno e biblioteca: são dois JOINs, como no slide de três tabelas.
1Abra o terminal na pasta lab-sqlite e rode sqlite3 exemplo.db (ou abra o arquivo no Letos).
2Veja as colunas com .schema reserva_livro. Ache as duas FKs.
3Tarefa A: liste nome do aluno, nome do livro e data de cada reserva (INNER JOIN com duas tabelas).
4Tarefa B (se der tempo): quantas reservas cada aluno fez (COUNT + GROUP BY no aluno).
Confira: a Tarefa A deve voltar 5 linhas, uma por reserva. Na B, a soma das contagens também tem que dar 5.
Debrief lab

Gabarito do lab

Consulta e resultado esperado

Tarefa A
SELECT a.Nome, b.Nome_livro, r.Data
FROM reserva_livro r
INNER JOIN aluno a ON r.Cod_aluno = a.Cod_aluno
INNER JOIN biblioteca b ON r.Cod_biblioteca = b.Cod_biblioteca;
NomeNome_livro
Ana SouzaIntrodução a SQL
Carla DiasIntrodução a SQL
Bruno LimaBanco de dados
Ana SouzaBanco de dados
Diego AlvesRedes de computadores
Tarefa B
SELECT a.Nome, COUNT(*) AS n
FROM reserva_livro r
INNER JOIN aluno a ON r.Cod_aluno = a.Cod_aluno
GROUP BY a.Cod_aluno, a.Nome;
Nomen
Ana Souza2
Bruno Lima1
Carla Dias1
Diego Alves1
Agrupar por Cod_aluno (a PK) evita juntar dois alunos com o mesmo nome. Aluno sem reserva não aparece: para mostrá-lo com 0, seria um LEFT JOIN partindo de aluno.
Complemento

Para estudar em casa

Links também no PDF

Atividade para entregar

Montar o seu banco no SQLite

Individual · entrega por e-mail até 01/10 (antes da Aula 6)

Você vai criar um banco com o seu nome, três tabelas ligadas entre si (aluno, biblioteca e reserva_livro), colocar dados, alterar um dado e apagar outro. A atividade original era para MySQL Workbench. Aqui usamos o Letos (ou DB Browser for SQLite), que já está na pasta lab-sqlite e não precisa instalar.
O que muda do MySQL para o SQLite
No MySQLNo SQLitePor quê
CREATE DATABASE NOME;
USE NOME;
Criar o arquivo NOME_ALUNO.db no LetosNo SQLite o banco é um arquivo. Criar o arquivo já conecta nele.
(FK sempre ativa)PRAGMA foreign_keys = ON;O SQLite só confere as chaves estrangeiras se você ligar a checagem.
int not null auto_increment + Primary key(...)INTEGER PRIMARY KEY AUTOINCREMENTTudo numa linha só. O número é gerado sozinho.
varchar(100) · datetimeTEXTSQLite guarda texto e datas como TEXT. Data no formato '2026-03-10 11:00:00'.
Primary key(Cod_reserva)Cod_reserva_livroErro do enunciado original: a coluna se chama Cod_reserva_livro.
Atividade · passos 1 e 2

Criar o banco e a tabela aluno

Letos · SQL Editor · Execute (F9)

1Criar o banco: abra letos-win\Letos\letos.exe → menu Database → Add a database → clique no + (criar novo) → salve como SEU_NOME.db (ex.: ANA_SOUZA.db) → OK. Esse arquivo é o seu banco.
2Criar a tabela: selecione o banco, abra Tools → Open SQL editor, cole o código e execute.
1  PRAGMA foreign_keys = ON;
2  CREATE TABLE aluno (
3    Cod_aluno INTEGER PRIMARY KEY AUTOINCREMENT,
4    Nome      TEXT,
5    Idade     INTEGER,
6    Curso     TEXT
7  );
8  ALTER TABLE aluno ADD COLUMN telefone TEXT;
1Liga a checagem de chave estrangeira nesta conexão.
2Cria a tabela aluno. Tudo entre parênteses são as colunas.
3Chave primária: número único de cada aluno, gerado automaticamente (1, 2, 3…).
4-6Nome e curso são texto; idade é número inteiro.
8ALTER TABLE muda uma tabela que já existe. ADD COLUMN acrescenta a coluna telefone sem apagar nada.
Telefone é TEXT, não número: não fazemos conta com telefone, e ele pode começar com zero ou ter “+55”.
Atividade · passo 3

Tabelas biblioteca e reserva_livro

A reserva liga aluno e livro

1  CREATE TABLE biblioteca (
2    Cod_biblioteca INTEGER PRIMARY KEY AUTOINCREMENT,
3    Nome_livro TEXT,
4    Data       TEXT,
5    Curso      TEXT
6  );
7
8  CREATE TABLE reserva_livro (
9    Cod_reserva_livro INTEGER PRIMARY KEY AUTOINCREMENT,
10   Cod_biblioteca INTEGER,
11   Cod_aluno      INTEGER,
12   Data           TEXT,
13   FOREIGN KEY (Cod_biblioteca)
14     REFERENCES biblioteca (Cod_biblioteca),
15   FOREIGN KEY (Cod_aluno)
16     REFERENCES aluno (Cod_aluno)
17 );
1-6biblioteca é o cadastro dos livros: código, nome, data de cadastro e curso.
9Cada reserva tem seu próprio número.
10-11Guardam o código do livro e o código do aluno. São as futuras FKs.
13-14FOREIGN KEY … REFERENCES: “este código tem que existir em biblioteca”.
15-16O mesmo para aluno. Assim não existe reserva de aluno fantasma.
Ordem importa: reserva_livro é criada por último, porque aponta para aluno e biblioteca. Não dá para referenciar uma tabela que ainda não existe.

Confira no painel esquerdo do Letos: devem aparecer aluno, biblioteca e reserva_livro.

Atividade · passos 4 a 6

Alimentar, alterar, remover e validar

INSERT · UPDATE · DELETE · SELECT

4Alimentar: rode os três INSERT do slide “Alimentar as três tabelas” (4 alunos, 3 livros, 5 reservas). Pode trocar os nomes pelos de colegas.
-- 5. Alterar: Bruno informou o telefone
UPDATE aluno
SET telefone = '31966660004'
WHERE Cod_aluno = 2;

-- 6. Remover: a reserva 5 foi cancelada
DELETE FROM reserva_livro
WHERE Cod_reserva_livro = 5;
5UPDATE muda valores de linhas que já existem. SET diz a coluna e o novo valor; WHERE diz qual linha.
6DELETE apaga linhas. WHERE escolhe qual.

Cuidado

Sem WHERE, o UPDATE muda todos os alunos e o DELETE apaga todas as reservas. Sempre escreva o WHERE primeiro.

Validar (tirar print de cada resultado)
SELECT * FROM aluno;            -- 4 alunos; Bruno agora com telefone
SELECT * FROM biblioteca;       -- 3 livros
SELECT * FROM reserva_livro;    -- 4 reservas (a 5 foi apagada)
SELECT a.Nome, b.Nome_livro, r.Data
FROM reserva_livro r
INNER JOIN aluno a      ON r.Cod_aluno = a.Cod_aluno
INNER JOIN biblioteca b ON r.Cod_biblioteca = b.Cod_biblioteca;
-- Teste da FK: TEM que dar erro "FOREIGN KEY constraint failed"
INSERT INTO reserva_livro (Cod_biblioteca, Cod_aluno, Data) VALUES (1, 99, '2026-03-20 10:00:00');

Se o último INSERT funcionar sem erro, faltou o PRAGMA foreign_keys = ON; nesta conexão. UPDATE e DELETE serão aprofundados na Aula 6.

Atividade · entrega

Checklist e envio por e-mail

Até 01/10 · individual

Checklist (o que será corrigido)
☐Tabela aluno criada corretamente (PK automática + coluna telefone via ALTER).
☐Tabela biblioteca criada corretamente.
☐Tabela reserva_livro criada corretamente, com as duas FOREIGN KEY.
☐Validação das informações no banco (prints dos SELECT e do erro da FK).
☐Tabelas alimentadas (INSERT) e informação removida (DELETE com WHERE).
☐Informação alterada (UPDATE com WHERE).
Como entregar
1Anexe o arquivo SEU_NOME.db (o banco inteiro está nele).
2Anexe um arquivo SEU_NOME.sql com todos os comandos que você rodou, na ordem. Pode ser um .txt.
3Cole no corpo do e-mail ou anexe os prints da validação.
Enviar para ramon.pedrosa@ulife.com.br
Assunto: BD Aula 5 · Atividade SQLite · SEU NOME
Abrir e-mail

Próxima quinta:
DDL e DML (01/10)

JOIN e GROUP ficam hoje. PDF: tecla E.

🎓 Aula Master Voltar à master Professor Ramon Pedrosa
← → · A− A+ · PDF · F · P