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.
Hoje: INNER JOIN, INSERT do lab, GROUP BY / HAVING e LEFT JOIN. DDL fica em 01/10.
WHERE sozinho não chega
Uma tabela parece uma planilha. Cada linha é um registro (uma venda, um livro). Cada coluna é um campo (id, título, quantidade, data).
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.
| id | id_livro | qtd | data_venda |
|---|---|---|---|
| 10 | 1 | 2 | 2026-03-05 |
| 11 | 1 | 1 | 2026-03-09 |
| 12 | 2 | 5 | 2026-03-12 |
“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.
1 livro · N vendas
| id PK |
| titulo |
| isbn, ano, preco |
| id PK |
| id_livro FK → livro.id |
| qtd |
| data_venda |
É o “RG” do livro. livro.id identifica um livro só e nunca se repete: não existem dois livros com id 1.
É 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).
id é igual ao id_livro da venda.Linha a linha
SELECT colunas FROM tabela1 INNER JOIN tabela2 ON tabela1.coluna = tabela2.coluna;
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;
v.id e v.qtd vêm da venda; l.titulo vem do livro.AS v dá um apelido (alias) curto.l.id_livro (FK) é igual a id (PK).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 diz como as tabelas se ligam (FK = PK). WHERE filtra depois que já estão juntas, por exemplo só vendas de março.
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
Python não tem venda → some
| id | titulo |
|---|---|
| 1 | SQL na Prática |
| 2 | Redes |
| 3 | Python |
| id | id_livro | qtd |
|---|---|---|
| 10 | 1 | 2 |
| 11 | 1 | 1 |
| 12 | 2 | 5 |
| venda | titulo | qtd |
|---|---|---|
| 10 | SQL na Prática | 2 |
| 11 | SQL na Prática | 1 |
| 12 | Redes | 5 |
SELECT v.id, l.titulo, v.qtd FROM venda AS v INNER JOIN livro AS l ON v.id_livro = l.id;
JOIN e INNER JOIN são a mesma coisa.Modelo mental: Coddy · SQLite INNER JOIN
A ordem não é a ordem em que escrevemos
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
| titulo | qtd |
|---|---|
| SQL na Prática | 2 |
| Redes | 5 |
Modelo mental “casar linhas e depois filtrar”: Coddy · INNER JOIN
Todas as combinações possíveis
-- 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;
| venda | id_livro | livro.id | titulo |
|---|---|---|---|
| 10 | 1 | 1 | SQL na Prática |
| 10 | 1 | 2 | Redes ✗ |
| 10 | 1 | 3 | Python ✗ |
| 11 | 1 | 1 | SQL na Prática |
| 11 | 1 | 2 | Redes ✗ |
| 11 | 1 | 3 | Python ✗ |
| 12 | 2 | 1 | SQL na Prática ✗ |
| 12 | 2 | 2 | Redes |
| 12 | 2 | 3 | Python ✗ |
ON é o que deixa só as linhas em negrito.Três operações parecidas, resultados diferentes
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.
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ó.
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.
| nome |
|---|
| Ana (BH) |
| Bruno (BH) |
| Carla (SP) |
| venda | qtd | titulo |
|---|---|---|
| 10 | 2 | SQL na Prática |
| 12 | 5 | Redes |
O banco guarda registros, não objetos
Uma linha por livro: título, ISBN, preço. Descreve o que o produto é. Muda pouco.
Uma linha por acontecimento: quem vendeu, quanto, quando. Cresce todo dia.
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.
Só leitura hoje · não vamos exercitar
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;
id_livro).id_fornecedor).Exemplo com três tabelas: DevMedia · exemplo 2 · Coddy · 3 tabelas
Só as vendas de março
| id | id_livro | qtd | data_venda |
|---|---|---|---|
| 10 | 1 | 2 | 2026-03-05 |
| 11 | 1 | 1 | 2026-03-09 |
| 12 | 2 | 5 | 2026-03-12 |
| 13 | 2 | 4 | 2026-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';
>= “maior ou igual”: entra o dia 1º de março.< “menor que” 1º de abril: entra até o último segundo de 31/03, e a venda 13 sai. AND exige as duas condições.<= '2026-03-31'? Se a data tiver hora (2026-03-31 15:00), ela é “maior” que 2026-03-31 e ficaria de fora.| titulo | qtd | data |
|---|---|---|
| SQL na Prática | 2 | 03-05 |
| SQL na Prática | 1 | 03-09 |
| Redes | 5 | 03-12 |
FK apontando para o nada
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.id | id_livro | qtd |
|---|---|---|
| 10 | 1 | 2 |
| 12 | 2 | 5 |
| 14 | 99 (não existe) | 7 |
INNER JOIN devolve só 10 e 12. As 7 unidades da venda 14 desaparecem.
No CREATE TABLE, declarar FOREIGN KEY (id_livro) REFERENCES livro(id). O banco passa a recusar venda com livro inexistente.
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
sqliteonline.com · sem instalar nada
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');
Uma frase por termo
| Termo | O que significa |
|---|---|
| Tabela | Conjunto de dados sobre um assunto (livros, vendas), organizado em linhas e colunas. |
| Registro | Uma linha da tabela: um livro, uma venda. |
| Coluna (campo) | Uma informação de cada registro: título, quantidade, data. |
| PK · chave primária | Coluna que identifica cada registro sem repetir (o “RG”). |
| FK · chave estrangeira | Coluna que guarda a PK de outra tabela e cria o relacionamento. |
| INNER JOIN | Junta duas tabelas e traz só as linhas que têm par nas duas. |
| ON | Condição que diz como as linhas casam (FK = PK). |
| Alias | Apelido curto de uma tabela na consulta (venda AS v). |
| Produto cartesiano | Junção sem condição: toda linha com toda linha. Quase sempre é erro. |
| Agregação | Resumir 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 JOIN | Como o INNER, mas mantém todas as linhas da tabela da esquerda, mesmo sem par. |
E o que fica para depois
Em dupla · no papel · 20 min
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.
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.
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”.
v. / l.), WHERE antes do GROUP BY e HAVING depois. Sintaxe perfeita não é exigida; a lógica sim.Para todos chegarem ao mesmo tipo de resposta
FROM venda, livro: ela gera produto cartesiano.SELECT → FROM → JOIN … ON → WHERE → GROUP BY → HAVING → ORDER BY. Trocar a ordem dá erro de sintaxe.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;
l; número e quantidade vêm de v.AS é opcional: venda v = venda AS v.| id | titulo | qtd |
|---|---|---|
| 10 | SQL na Prática | 2 |
| 11 | SQL na Prática | 1 |
| 12 | Redes | 5 |
| 13 | Redes | 4 |
A Questão 2 é corrigida no slide de GROUP BY e HAVING.
E por quê
FROM venda, livro sem ONProduto cartesiano: cada venda aparece com todos os livros. 4 vendas × 3 livros = 12 linhas, a maioria errada.
ON v.id = l.idLiga 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) < 5O 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.
Transformar muitas linhas em um número
| id | id_livro | qtd |
|---|---|---|
| 10 | 1 | 2 |
| 11 | 1 | 1 |
| 12 | 2 | 5 |
| Função | O que faz | Resultado |
|---|---|---|
COUNT(*) | Conta linhas (quantas vendas) | 3 |
SUM(qtd) | Soma os valores (unidades) | 8 |
AVG(qtd) | Média | 2,67 |
MIN(qtd) | Menor valor | 1 |
MAX(qtd) | Maior valor | 5 |
SELECT COUNT(*) AS vendas, SUM(qtd) AS unidades FROM venda WHERE data_venda >= '2026-03-01' AND data_venda < '2026-04-01';
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
Um total por livro · núcleo da SP3
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.| titulo | qtd |
|---|---|
| SQL na Prática | 2 |
| SQL na Prática | 1 |
| Redes | 5 |
| titulo | total |
|---|---|
| SQL na Prática | 3 |
| Redes | 5 (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;
Age antes de agrupar, linha por linha. Tira a venda de abril.
Junta as linhas do mesmo livro. Toda coluna do SELECT que não é soma precisa estar aqui.
Age depois, sobre o total do grupo. Resultado: só “SQL na Prática · 3”.
Manter linhas sem par
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;
| titulo | venda |
|---|---|
| SQL na Prática | 10 |
| SQL na Prática | 11 |
| Redes | 12 |
| Redes | 13 |
| Python | NULL |
-- 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;
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
Para quem só criou as tabelas na Aula 4
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');
INSERT INTO aluno (colunas): diz em qual tabela e em quais colunas os valores vão entrar, nessa ordem.VALUES (...): cada par de parênteses é uma linha nova. Texto vai entre aspas simples; número vai sem aspas.NULL: Bruno não informou telefone. NULL é “sem valor”, diferente de '' (texto vazio).Cod_aluno não aparece: é PK com AUTOINCREMENT, o SQLite numera sozinho (Ana = 1, Bruno = 2…).reserva_livro, (1, 3, …) quer dizer livro 1 reservado pela aluna 3 (Carla). Insira aluno e biblioteca antes da reserva.Fonte: Coddy · INSERT
exemplo.db · sqlite3 · em dupla
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.lab-sqlite e rode sqlite3 exemplo.db (ou abra o arquivo no Letos)..schema reserva_livro. Ache as duas FKs.Consulta e resultado esperado
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;
| Nome | Nome_livro |
|---|---|
| Ana Souza | Introdução a SQL |
| Carla Dias | Introdução a SQL |
| Bruno Lima | Banco de dados |
| Ana Souza | Banco de dados |
| Diego Alves | Redes de computadores |
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;
| Nome | n |
|---|---|
| Ana Souza | 2 |
| Bruno Lima | 1 |
| Carla Dias | 1 |
| Diego Alves | 1 |
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.Links também no PDF
Individual · entrega por e-mail até 01/10 (antes da Aula 6)
lab-sqlite e não precisa instalar.| No MySQL | No SQLite | Por quê |
|---|---|---|
CREATE DATABASE NOME;USE NOME; | Criar o arquivo NOME_ALUNO.db no Letos | No 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 AUTOINCREMENT | Tudo numa linha só. O número é gerado sozinho. |
varchar(100) · datetime | TEXT | SQLite guarda texto e datas como TEXT. Data no formato '2026-03-10 11:00:00'. |
Primary key(Cod_reserva) | Cod_reserva_livro | Erro do enunciado original: a coluna se chama Cod_reserva_livro. |
Letos · SQL Editor · Execute (F9)
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.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;
aluno. Tudo entre parênteses são as colunas.ADD COLUMN acrescenta a coluna telefone sem apagar nada.TEXT, não número: não fazemos conta com telefone, e ele pode começar com zero ou ter “+55”.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 );
biblioteca é o cadastro dos livros: código, nome, data de cadastro e curso.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.
INSERT · UPDATE · DELETE · SELECT
-- 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;
SET diz a coluna e o novo valor; WHERE diz qual linha.WHERE escolhe qual.Sem WHERE, o UPDATE muda todos os alunos e o DELETE apaga todas as reservas. Sempre escreva o WHERE primeiro.
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.
Até 01/10 · individual
aluno criada corretamente (PK automática + coluna telefone via ALTER).biblioteca criada corretamente.reserva_livro criada corretamente, com as duas FOREIGN KEY.SEU_NOME.db (o banco inteiro está nele).SEU_NOME.sql com todos os comandos que você rodou, na ordem. Pode ser um .txt.JOIN e GROUP ficam hoje. PDF: tecla E.