Exercícios

Tempo sugerido para realização: 40 minutos

Agora vamos abrir o Workbench e fazer uma análise prática do banco de dados sakila, que já deve estar
instalado, caso você tenha feito a instalação do MySql Workbench de forma padrão. Caso o banco sakila
não esteja disponível, volte até a seção Restaurando o banco de dados de prática sakila e siga as
instruções listadas. Com esse banco disponível na sua instalação do Workbench, sua missão agora é
tentar finalizar os exercícios a seguir!

Exercício 1: Descubra como fazer uma pesquisa em qualquer tabela sem usar uma linha de código
usando o MySql Workbench.

Exercício 2: Descubra como é possível criar uma tabela sem usar código SQL usando o MySql Workbench.

Exercício 3: Feito isso, crie um tabela com as seguintes restrições:

Nome da tabela: Filme

Colunas:

FilmeId - primary key, tipo int, incrementa por 1 cada vez que um valor é inserido automaticamente;

Descricao - não permite nulos, tipo texto (varchar(100);

AnoLancamento - não permite nulos, tipo int;

Nota - permite nulos, tipo int;

Exercício 4: Analise a tabela city e encontre a tabela à qual a coluna country_id faz referência.
Exercício 5: Após resolver o exercício anterior, responda: qual tipo de relacionamento a tabela city faz
com a tabela country?

Exercício 6: Qual tipo de relacionamento a tabela country faz com a tabela city?

Exercício 7: Abra tabela por tabela do banco sakila e encontre no mínimo 3 exemplos de um
relacionamentos 1:N ou N:1.

Tipos de chaves: https://www.blogson.com.br/chave-primaria-estrangeira-e-composta-no-mysql

O que vamos aprender?

Bem-vindo de volta! Hoje você vai começar a juntar as peças da sua jornada que te levarão a aprender a
manipular e a transformar dados em informação, e informação em conhecimento!

Você será capaz de:

Compreender o que é uma query SQL e quais são seus tipos de comando

Gerar valores com SELECT

Selecionar colunas individualmente com SELECT

Renomear e gerar colunas em uma consulta com AS

Concatenar colunas e valores com CONCAT

Remover dados duplicados em uma consulta com DISTINCT

Contar a quantidade de resultados em uma consulta com COUNT

Limitar a quantidade de resultados em uma consulta com LIMIT

Pular resultados em uma consulta com OFFSET

Ordernar os resultados de uma consulta com ORDER BY

Por que isso é importante?

A razão pela qual uma base de dados existe é para que alguém, ou algum programa, faça pesquisas nela.
As pesquisas, principalmente o comando SELECT, são como o café da manhã para alguém que tem
costume de tomá-lo todo dia: sem ele você não vai muito longe.

Como foi dito na aula anterior, quando você se conecta a um banco de dados, você tem a opção de fazer
boa parte das suas pesquisas e manipulação de dados usando ferramentas gráficas, que estão
disponíveis para uso e download. O MySQL Workbench, visto na última aula, faz exatamente isso. No
entanto, é importante que você tenha uma base sólida do SQL para que possa entregar resultados bem
específicos e fazer pesquisas em situações em que você não disponha de uma ferramenta gráfica.

Para ser capaz que montar suas pesquisas personalizadas, você precisa saber usar o comando SELECT,
então vamos lá!

Conteúdos

Tempo sugerido para realização: 120 minutos

O que é uma query e quais são os principais tipos de queries

Inquirir, ou query, em inglês, é o nome dado aos comandos que você digita dentro de uma janela ou
linha de comando com a intenção de interagir de alguma maneira com uma base de dados. No mundo
de banco de dados, você pode tanto trazer dados quanto alterá-los, atribuir permissões de acesso e
manipulação e muito mais. Vamos dar um olhada nos principais tipos de queries a seguir:

DDL: Data Definition Language - todos os comandos que lidam com o esquema, a descrição e como os
dados devem existir em um banco de dados:

CREATE - Para criação de bancos de dados, tabelas, índices, views, procedures, functions e triggers

ALTER - Para alteração da estrutura de qualquer objeto

DROP - Permite deletar objetos

TRUNCATE - Apenas esvazia os dados dentro de uma tabela, mas a mantém no banco de dados
 DML: Data Manipulation Language - os comandos que são usados para manipular dados. São
utilizados para armazenar, modificar, buscar e excluir dados em um banco de dados. Os comando e usos
mais comuns nesta categoria são:

SELECT: Usado para buscar dados em um banco de dados

INSERT: Insere dados em uma tabela

UPDATE: Altera dados dentro de uma tabela

DELETE: Exclui dados de uma tabela

DCL: Data Control Language - Focado mais nos comandos que concedem direitos, permissões e outros
tipos de controle ao sistema de banco de dados.

GRANT - Concede acesso a um usuário

REVOKE - Remove acessos concedidos através do comando GRANT

TCL: Transactional Control Language - Lida com as transações dentro de suas pesquisas.

COMMIT - Muda suas alterações de temporárias para permanentes no seu banco de dados

ROLLBACK - Desfaz todo o impacto realizado por um comando

SAVEPOINT - Define pontos para os quais uma transação pode voltar. É uma maneira de voltar para
pontos específicos de sua query

TRANSACTION - Comandos que definem onde, como e em que escopo suas transações são
executadas

SELECT, o primeiro passo

Antes de assistir à aula a seguir, temos 2 conceitos importantes que podem ser utilizados já no início do
seu aprendizado de SQL. Esses conceitos são usar o SELECT para gerar valores e usar o AS para dar
nomes às suas colunas, como nos exemplos a seguir. Rode cada um deles em uma janela de query para
verificar os resultados:

_____________________________________________

SELECT 'Olá, bem-vindo ao SQL!';

SELECT 10;

SELECT now();

SELECT 20 * 2;

SELECT 50 / 2;

SELECT 18 AS idade;

SELECT 2019 AS ano;

SELECT 'Rafael', 'Martins', 25, 'Desenvolvedor Web';

SELECT 'Rafael' AS nome, 'Martins' AS sobrenome, 25 AS idade, 'Desenvolvedor Web' AS 'Área de

atuação';

__________________________________________________

Depois de rodar cada um desses comandos, vemos que é possível fazer algumas coisas apenas usando o
SELECT, ainda sem alterar o banco de dados.

É possível gerar e calcular valores usando apenas SELECT valor_a_ser_calculado_ou_exibido;

Perceba que a palavra-chave AS permite que você dê nome às suas colunas para que elas façam mais
sentido quando estiver lendo os resultados. Lembre-se de que, caso o nome tenha mais de uma palavra,
devemos usar aspas simples para nomear as colunas;

Note que sempre finalizamos uma query usando o ponto e vírgula (;);

Observe também que as palavras-chave (reservadas) estão em maiúsculo. Isso é uma convenção para
facilitar a leitura da query. É recomendado que faça o mesmo.

Já vamos praticar? Aham!

Monte uma query que exiba seu nome na tela;

Monte uma query que exiba seu nome, sobrenome, cidade natal e idade na tela;

Monte uma query que, além de exibir todas as informações acima, identifique cada coluna usando o
AS, que é chamado de alias na linguagem SQL (alias é como um apelido no português);

Qual é o resultado de 13 * 8 ? Descubra usando apenas o SELECT;

Monte uma query que exiba a data e hora atuais. Dê a essa coluna o nome "Data Atual".
Agora, vamos aprender um pouco mais sobre como usar o SELECT assistindo a essa aula:

(anotado)

Tranquilo, não é? Então vamos fixar isso?

Vamos agora entrar no banco de dados sakila e encontrar as seguintes informações, montando uma
query para cada uma:

Escreva uma query que selecione todas as colunas da tabela city;

Escreva uma query que exiba apenas as colunas first_name e last_name da tabela customer;

Escreva uma query que exiba todas as colunas da tabela rental;

Escreva uma query que exiba o título, a descrição e a data de lançamento dos filmes registrados na
tabela film;

Utilize o SELECT para explorar todas as tabelas do banco de dados.

Juntando duas ou mais colunas usando o CONCAT

Dê uma pesquisada agora na tabela sakila.actor usando o comando SELECT * FROM sakila.actor e veja
que temos uma coluna first_name e outra chamada last_name. Vamos imaginar que é necessário criar
um relatório com o nome completo de um ator. Como podemos fazer isso? É fácil, basta usar a função
CONCAT.

Para compreender seu uso, execute os exemplos a seguir no MySQL Workbench:

SELECT CONCAT(first_name, last_name) FROM sakila.actor;

-- Seu resultado ficou estranho? Eu também achei! Tente agora a query a seguir.
SELECT CONCAT(first_name, ' ', last_name) FROM sakila.actor;

-- Muito melhor, certo? Mas dá para melhorar? Dá!

SELECT CONCAT(first_name, ' ', last_name) AS 'Nome Completo' FROM sakila.actor;

____________________________________________

Então, como podemos ver no exemplo acima, é possível concatenar mais de uma coluna em apenas
uma. Para isso, usamos a função CONCAT, que cria novos dados e informações a partir dos dados já
existentes em uma tabela.

Vamos brincar um pouco mais com isso?

Na tabela sakila.film, monte uma query que exiba o título e o ano de lançamento dos filmes em uma
coluna e dê a ela o nome Lançamento do Filme.

Na tabela sakila.film, crie uma query que exiba o título do filme e sua classificação indicativa (PG, G,
NC-17) em apenas uma coluna. Dê a ela o nome Classificação. Não se esqueça de deixar um espaço
entre as palavras para que fiquem legíveis.

Na tabela sakila.address, monte uma query que exiba a rua e o distrito de cada registro em uma
coluna apenas, e dê a essa coluna o nome Endereço.

Espero que tenha sido tranquilo. Caso precise, veja o vídeo novamente.

Dados repetidos? Aqui Não! Como usar o DISTINCT

Perfeito! Então, depois de ter assistido ao vídeo sobre DISTINCT, dê uma olhada nesta tabela:
Para criá-la no seu banco de dados, abra uma nova janela de query no MySQL Workbench e execute o
seguinte código:

CREATE DATABASE `Escola`;

CREATE TABLE IF NOT EXISTS Escola.Alunos (

`Nome` VARCHAR(7) CHARACTER SET utf8,

`Idade` INT

);

INSERT INTO Escola.Alunos VALUES

('Rafael', 25),

('Amanda', 30),

('Roberto', 45),

('Carol', 19),

('Amanda', 25);

_________________________________________

Feito isso, você terá acesso à tabela Alunos do banco de dados Escola. Levando em conta a explicação
que você acabou de ver, como você montaria uma query para encontrar os seguintes dados?

Monte uma query para encontrar pares únicos de nomes e idades.

 Quantas linhas você encontraria na query anterior?

Monte uma query para encontrar somente os nomes únicos.

Quantas linhas você encontraria na query anterior?

Monte uma query para encontrar somente as idades únicas.

Quantas linhas você encontraria na query anterior?

Contando resultados com o COUNT

Um dos principais objetivos de se usar um banco de dados é responder a perguntas como: "Qual
quantidade de um certo tipo de dados existe na tabela?". Ou em, um caso mais próximo ao nosso:
"Quantas pessoas temos cadastradas no sistema?". Ou ainda: "Em quantos estados temos clientes?".

Vamos entender melhor isso assistindo a este vídeo: (anotado)

Essa é a tabela staff do banco de dados sakila. Como você poderia responder às seguintes questões?

Quantas senhas temos cadastradas nessa tabela?

Quantas pessoas temos em total trabalhando para nossa empresa?

Quantas fotos temos cadastradas nessa tabela?

Até agora, trabalhamos principalmente com tabelas que têm poucas linhas de resultados (média de
200), e até aí tudo bem. Porém, em muitos cenários reais, você pode se deparar com milhares ou até
centenas de milhares de resultados, e é aqui que vamos LIMITar elas!

Vamos montar o bolo com todos os ingredientes que vimos hoje

Escreva uma query que exiba todos os filmes cadastrados no banco de dados.

Escreva uma query que exiba apenas o nome dos filmes, seu ano de lançamento e sua classificação.
 Escreva uma query que exiba apenas os sobrenomes únicos cadastrados no banco sakila.

Crie queries para descobrir o seguinte:

Quantos filmes temos cadastrados?

Quantos clientes temos registrados?

Quantos sobrenomes únicos temos no banco de dados?

Quantas categorias de filmes o banco sakila possui?

Quantos países são atendidos pela sakila?

Vá até a tabela language do sakila e crie uma pesquisa que mostre os 5 idiomas cadastrados, mas não
mostre o idioma english.

Vá até a tabela film e selecione todos os dados da tabela. Pronto, fez isso?

Agora vamos tentar fazer o seguinte: Crie uma query para encontrar os 20 primeiros filmes, incluindo
o título, o ano de lançamento, a duração, a classificação indicativa e o custo de substituição. Ordene os
resultados pelos filmes com a maior duração e depois pelo menor custo de substituição.

Exercicios : https://www.w3schools.com/sql/exercise.asp?filename=exercise_select1

https://sqlbolt.com/lesson/select_queries_introduction

https://sqlzoo.net/wiki/SELECT_basics

Manual MySQL: https://dev.mysql.com/doc/refman/8.0/en/

Comandos tutorial: https://www.w3schools.in/mysql/ddl-dml-dcl/

https://www.javatpoint.com/dbms-sql-command

Banco de dados para exercicio: https://creativecommons.org/licenses/by-sa/3.0/

DROP SCHEMA IF EXISTS Scientists;

CREATE SCHEMA Scientists;

USE Scientists;
CREATE TABLE Scientists (

SSN INT,

Name CHAR(30) NOT NULL,

PRIMARY KEY (SSN)

);

CREATE TABLE Projects (

Code CHAR(4),

Name CHAR(50) NOT NULL,

Hours INT,

PRIMARY KEY (Code)

);

CREATE TABLE AssignedTo (

Scientist INT NOT NULL,

Project CHAR(4) NOT NULL,

PRIMARY KEY (Scientist, Project),

FOREIGN KEY (Scientist) REFERENCES Scientists (SSN),

FOREIGN KEY (Project) REFERENCES Projects (Code)

);

INSERT INTO Scientists(SSN,Name)

VALUES(123234877, 'Michael Rogers'),

(152934485, 'Anand Manikutty'),

(222364883, 'Carol Smith'),

 (326587417, 'Joe Stevens'),

(332154719, 'Mary-Anne Foster'),

(332569843, 'George ODonnell'),

(546523478, 'John Doe'),

(631231482, 'David Smith'),

(654873219, 'Zacary Efron'),

(745685214, 'Eric Goldsmith'),

(845657245, 'Elizabeth Doe'),

(845657246, 'Kumar Swamy');

INSERT INTO Projects (Code, Name, Hours)

VALUES ('AeH1' ,'Winds: Studying Bernoullis Principle', 156),

('AeH2', 'Aerodynamics and Bridge Design', 189),

('AeH3', 'Aerodynamics and Gas Mileage', 256),

('AeH4', 'Aerodynamics and Ice Hockey', 789),

('AeH5', 'Aerodynamics of a Football', 98),

('AeH6', 'Aerodynamics of Air Hockey', 89),

('Ast1', 'A Matter of Time', 112),

('Ast2', 'A Puzzling Parallax', 299),

('Ast3', 'Build Your Own Telescope', 6546),

('Bte1', 'Juicy: Extracting Apple Juice with Pectinase', 321),

('Bte2', 'A Magnetic Primer Designer', 9684),

('Bte3', 'Bacterial Transformation Efficiency', 321),

('Che1', 'A Silver-Cleaning Battery', 545),

('Che2', 'A Soluble Separation Solution', 778);

INSERT INTO AssignedTo (Scientist, Project)

VALUES (123234877, 'AeH1'),

(152934485, 'AeH3'),

(222364883, 'Ast3'),

(326587417, 'Ast3'),

(332154719, 'Bte1'),

(546523478, 'Che1'),

(631231482, 'Ast3'),

(654873219, 'Che1'),

(745685214, 'AeH3'),

(845657245, 'Ast1'),

(845657246, 'Ast2'),

(332569843, 'AeH4');

________________________________________________

Escreva uma query para exibir a string "This is SQL Exercise, Practice and Solution".

Escreva uma query para exibir três números em três colunas.

Escreva uma query para exibir a soma dos números 10 e 15.

Escreva uma query para exibir o resultado de uma expressão aritmética qualquer.

Escreva uma query para exibir todas as informações de todos os cientistas.

Escreva uma query para exibir o nome e as horas de cada projeto.

Escreva uma query para exibir o nome e as horas dos três projetos com a maior quantidade horas.

Escreva uma query para exibir o código de todos os projetos da tabela AssignedTo sem que haja
repetições.

Escreva uma query para exibir todos os cientistas cujos projetos são Ast3.
 Escreva uma query para exibir todas as informações dos projetos 5 projetos com a menor quantidade
de horas.

__________________

DROP SCHEMA IF EXISTS PiecesProviders;

CREATE SCHEMA PiecesProviders;

USE PiecesProviders;

CREATE TABLE Pieces (

Code INTEGER PRIMARY KEY NOT NULL,

Name TEXT NOT NULL

);

CREATE TABLE Providers (

Code VARCHAR(40) PRIMARY KEY NOT NULL,

Name TEXT NOT NULL

);

CREATE TABLE Provides (

Piece INTEGER,

FOREIGN KEY (Piece) REFERENCES Pieces (Code),

Provider VARCHAR(40),

FOREIGN KEY (Provider) REFERENCES Providers (Code),

Price INTEGER NOT NULL,

PRIMARY KEY (Piece , Provider)

);
INSERT INTO Providers(Code, Name)

VALUES ('HAL', 'Clarke Enterprises'),

('RBT', 'Susan Calvin Corp.'),

('TNBC', 'Skellington Supplies');

INSERT INTO Pieces(Code, Name)

VALUES (1, 'Sprocket'),

(2, 'Screw'),

(3, 'Nut'),

(4, 'Bolt');

INSERT INTO Provides(Piece, Provider, Price)

VALUES (1, 'HAL', 10),

(1, 'RBT', 15),

(2, 'HAL', 20),

(2, 'RBT', 25),

(2, 'TNBC', 14),

(3, 'RBT', 50),

(3, 'TNBC', 45),

(4, 'HAL', 5),

(4, 'RBT', 7);

link: https://creativecommons.org/licenses/by-sa/3.0/

___________________________________________________________

Escreva uma query para exibir a peça e o preço de tudo que é provido pela empresa RBT.
 Escreve uma query para exibir todas as informações dos 5 peças com os maiores preços.

Escreva uma query para exibir o nome das empresas, sem repetições, que proveem as peças com os 4
maiores preços.

Escreva uma query para exibir todas as informações das peças que são providos pela empresa HAL.
Ordene o resultado pelos preços dos peças de forma decrescente.

Escreva uma query para exibir por quantas empresas a peça 1 é provida.

Segunda pagina
Filtrando dados de forma específica

O que vamos aprender?

Olá, pessoal, bem-vindos e bem-vindas de volta! Na última aula, você teve a oportunidade de dar os
primeiros passos com um banco de dados, aprendendo a filtrar e ordenar os seus resultados, além de
limitar a quantidade de dados que são exibidos. Hoje você vai expandir ainda mais seu conhecimento de
SQL, o que te permitirá criar consultas mais refinadas, complexas e precisas.

Você será capaz de:

Filtrar resultados de consultas com o WHERE.

Utilizar operadores booleanos e relacionais em consultas.

Criar consultas mais dinâmicas e maleáveis com LIKE.

Fazer consultas que englobam uma faixa de resultados com IN e BETWEEN.

Encontrar e separar resultados que incluem datas.

Por que isso é importante?

Um profissional de fotografia começa tirando fotos apenas no automático. Porém, à medida que
experimenta mais o equipamento, descobre novos recursos e aprende novas funções, ele vai
encontrando novas maneiras de tirar fotos cada vez melhores, entregando mais valor para seu cliente.

Você já deve estar conseguindo montar pesquisas básicas com certa segurança. A aula de hoje vai te dar
ainda mais recursos para montar pesquisas mais elaboradas. Assim como o fotógrafo, com novos
recursos, você vai conseguir entregar ainda mais valor através do seu trabalho. LET'S GO!

Photo by Fujifilm North America from Pexels

Conteúdos

Tempo sugerido para realização: 120 minutos

Entregando resultados mais exatos através do WHERE

Sakila mode ON! Vamos abrir nosso banco de dados sakila e aprender a lidar com o WHERE e com os
principais comparadores lógicos:
Sendo assim, quando se faz a seguinte query:

SELECT * FROM sakila.payment

WHERE amount = 0.99 OR amount = 2.99 AND staff_id = 2;

Como o operador AND tem preferência sobre o operador OR, ele é avaliado primeiro. Então os registros
buscados são aqueles nos quais amount = 2.99 e staff_id = 2. Na sequência, são buscados os registros
nos quais amount = 0.99, independente do valor de staff_id. Os valores retornados serão os resultados
dessas duas buscas. Ou seja, a query é executada como se tivesse os seguintes parênteses: amount =
0.99 OR (amount = 2.99 AND staff_id = 2).

Agora, quando executar a seguinte query:

SELECT * FROM sakila.payment

WHERE (amount = 0.99 OR amount = 2.99) AND staff_id = 2;

Primeiramente, a expressão dentro dos parênteses é avaliada, e todos os resultados que satisfazem a
condição amount = 0.99 OR amount = 2.99 são retornados. Na sequência, a expressão do lado direito do
AND é avaliada, e todos os resultados que satisfazem a condição staff = 2 são retornados. O AND então
compara o resultado de ambos os lados e faz com que somente os resultados que satisfazem ambas as
condições sejam retornados.

Alavancando o poder dos principais operadores boleanos e relacionais

Como foi exibido no vídeo acima, de forma geral, temos os seguintes operadores:

-- OPERADOR - DESCRIÇÃO

= IGUAL

> MAIOR QUE

< MENOR QUE

>= MAIOR QUE OU IGUAL

<= MENOR QUE OU IGUAL

<> DIFERENTE DE

AND OPERADOR LÓGICO E

OR OPERADOR LÓGICO OU

NOT NEGAÇÃO

IS COMPARA COM VALORES BOOLEANOS (TRUE, FALSE, NULL)

Depois de ter assistido ao vídeo acima, você já deve ter agora uma noção do que pode ser feito com os
operadores do SQL e de como é possível combiná-los para trazer relatórios ainda mais granulares. Vamos
buscar algumas informações no nosso banco de dados para consolidar esse aprendizado.

Dica final: Sempre se atente a essa ordem de precedência para que consiga montar suas queries de
acordo com o que precisa. Na dúvida, use parênteses.
A tabela a seguir é um guia de como a classificação indicativa é usada no banco de dados sakila.
Consulte-a ao fazer os desafios propostos.

G = permitido para todos

PG = permitido para crianças menores de 13 anos

PG-13 = permitido para pessoas com mais de 13 anos

R = permitido para pessoas com mais de 17 anos

NC-17 = permitido apenas para adultos

Entre no banco de dados sakila e siga as instruções (e guarde as queries para conferir posteriormente):

Precisamos identificar o cliente com o e-mail [email protected].

Precisamos de um relatório dos nomes, em ordem alfabética, dos clientes que não estão mais ativos
no nosso sistema e pertencem à loja com o id 2. Porém, não inclua o cliente KENNETH no resultado.

O setor financeiro quer saber nome, descrição, ano de lançamento e quais são os 100 filmes com o
maior custo de substituição, do valor mais alto ao mais baixo, entre os filmes feitos para menores de
idade e que têm o custo mínimo de substituição de $18,00 dólares.

Quantos clientes estão ativos e na loja 1?

Mostre todos os detalhes dos clientes que não estão ativos na loja 1.

Precisamos descobrir quais são os 50 filmes feitos para maiores de 17 anos e adultos com a menor
taxa de aluguel, para que possamos fazer uma divulgação melhor desses filmes.

Você vai se deparar também com casos em que você só tem parte de uma informação, ou em que
precisa criar queries mais dinâmicas. Para esses casos, temos o LIKE. Como assim? É o que veremos a
seguir.

Como criar pesquisas mais dinâmicas e maleáveis usando o LIKE

Você está tentando se lembrar do nome de um filme a que já assistiu, mas só se lembra que ele
terminava com don no nome. Como seria possível usar o LIKE para te ajudar a encontrá-lo?

SELECT * FROM sakila.film

WHERE title LIKE '%don';

Resultado da pesquisa. Encontramos! O filme é 'METAL ARMAGEDDON'

O LIKE é usado para buscar por meio de uma sequência específica de caracteres, como no exemplo
acima. Alem disso, 2 "curingas", ou modificadores, são normalmente usados com o LIKE:

% - O sinal de percentual, que pode representar zero, um, ou múltiplos caracteres

_ - O underscore (às vezes chamado de underline, no Brasil), que representa um único caractere

Vamos ver abaixo como usá-los (todos podem ser verificados no banco sakila)

-- Encontra qualquer resultado finalizando com "don"

WHERE title LIKE '%don';

-- Encontra qualquer resultado iniciando com "plu"

WHERE title LIKE 'plu%';

-- Encontra qualquer resultado que contém "plu"

WHERE title LIKE '%plu%';

-- Encontra qualquer resultado que inicia com "p" e finaliza com "r"
WHERE title LIKE 'p%r';

-- Encontra qualquer resultado em que o segundo caractere da frase é "C"

WHERE title LIKE '_C%';

-- Encontra qualquer resultado em que o título possui exatamente 8 caracteres

WHERE title LIKE '________';

-- Encontra todas as palavras com no mínimo 3 caracteres e que iniciam com E

WHERE title LIKE '%E__';

Para consolidar esse conhecimento, brinque com os resultados que serão encontrados usando os
comandos acima e tente criar suas próprias condições. Depois de ter praticado um pouco com eles,
tente encontrar as seguintes informações:

Encontre todos os detalhes dos filmes que contêm a palavra "ace" no nome.

Encontre todos os detalhes dos filmes cujas descrições finalizam com "china".

Encontre todos os detalhes dos 2 filmes cujas descrições contêm a palavra "girl" e o título finaliza com
a palavra "lord".

Encontre os dois casos em que, a partir do 4° caractere no título do filme, tem-se a palavra "gon".

Encontre os dois casos em que, a partir do 4° caractere no título do filme, tem-se a palavra "gon" e a
descrição contém a palavra "Documentary".

Encontre os 2 filmes cujos títulos ou finalizam com "academy" ou inciam com "mosquito".
 Encontre os 6 filmes que contêm as palavras "monkey" e "sumo" em suas descrições.

A seguir, vamos entender como trazer resultados que englobam uma faixa de valores usando os
operadores IN e BETWEEN.

Englobando uma faixa de resultados com IN e BETWEEN

Operador IN

Como você viu no início do dia hoje, é possível juntar várias condições nas suas queries usando os
operadores AND e OR. No entanto, você ainda terá que digitar cada condição separadamente, como no
exemplo a seguir:

SELECT * FROM sakila.actor

WHERE first_name = 'PENELOPE'

OR first_name = 'NICK'

OR first_name = 'ED'

OR first_name = 'JENNIFER';

Uma forma melhor de fazer essa mesma pesquisa seria usando o IN:

SELECT * FROM sakila.actor

WHERE first_name IN ('PENELOPE','NICK','ED','JENNIFER');

Você poderia fazer esse mesmo processo para números também:

SELECT * FROM sakila.customer

WHERE customer_id in (1, 2, 3, 4, 5);

Então, para que você faça pesquisas utilizando o IN, a sintaxe que deve ser usada é a seguinte:

SELECT * FROM banco_de_dados

WHERE coluna IN (valor1, valor2, valor3, valor4, ..., valorN);

-- ou também

SELECT * FROM banco_de_dados

WHERE coluna IN (expressão);

 Como você faria, então, para encontrar, usando o IN, todos os detalhes sobre o aluguel dos clientes
com os seguintes ids: 269, 239, 126, 399, 142?

Como encontraria todas as informações sobre os endereços que estão registrados nos distritos de
QLD, Nagasaki, California, Attika, Mandalay, Nantou e Texas?

Operador BETWEEN

Uma outra opção quando queremos trabalhar com faixas de resultados é o BETWEEN, que torna possível
fazer pesquisas dentro de uma faixa inicial e final.

expressão BETWEEN valor1 AND valor2;

-- a expressão é a sua query

-- e valor1 e valor2 delimitam o resultado

Então, quando você faz uma query como essa, você terá o resultado da imagem a seguir:

-- Note que o MySQL inclui o valor inicial e o final nos resultados

SELECT title, length FROM sakila.film

WHERE length BETWEEN 50 AND 120;

Usando o BETWEEN com strings

Para encontrar uma faixa de valores em que os valores são strings, podemos digitar a palavra por
completo para encontrar os valores. Exemplo:

SELECT * FROM sakila.language

WHERE name BETWEEN 'Italian' AND 'Mandarin'

ORDER BY name;

Usando o BETWEEN com datas

Para usar o BETWEEN com datas, basta que você digite o valor no formato padrão da data, que é YYYY-
MM-DD HH:MM:SS, sendo os valores de horas, minutos e segundos opcionais. No exemplo abaixo,
estamos filtrando os resultados para exibir o rental_id e rental_date apenas entre o mês 05 e o mês 07:

SELECT rental_id, rental_date FROM sakila.rental

WHERE rental_date

BETWEEN '2005-05-27' AND '2005-07-17';

Como decidir qual usar?

Lembre-se de que, no caso do IN, você precisa especificar os valores que devem ser incluídos no
resultado e, no caso do BETWEEN, você não precisa incluir os valores que estão entre o valor inicial e
final. Então, vale a pena analisar essa diferença e ver qual te atenderá melhor.

Qual tem a melhor performance?

A melhor forma de responder a essa pergunta é: depende.

Não é o que você esperava? Então vai aqui uma resposta melhor: isso vai depender do tipo e quantidade
de dados com os quais você está trabalhando. A melhor forma de você não chutar é clicar no botão
Execution Plan no MySQL Workbench e verificar o tempo de execução para tomar a decisão de qual tem
o menor custo de execução - o que significa que a query finalizará mais rápido.

Há outras ferramentas inteiras só para mensurar performance. Considere o Execution Plan apenas uma
introdução ao tema.

Fazendo um pequeno teste, temos os seguintes resultados (que podem sofrer alterações, dependendo
da quantidade de dados com os quais se está trabalhando):

No final
das contas, depois de analisar questões como performance, você poderá tomar sua decisão sobre qual
usar com mais segurança!

Consolidando o conhecimento

Encontre o nome, sobrenome e e-mail dos clientes com os seguintes sobrenomes: hicks, crawford,
henry, boyd, mason, morales e kennedy, ordenados por nome em ordem alfabética.
 Encontre o e-mail dos clientes com os address_id 172, 173, 174, 175 e 176, ordenados em ordem
alfabética.

Descubra quantos pagamentos foram feitos entre 01/05/2005 e 01/08/2005. Lembre-se de que, no
banco de dados, as datas estão armazenadas no formato ano/mês/dia, diferente do formato brasileiro,
que é dia/mês/ano.

Encontre o título, ano de lançamento e duração do empréstimo de todos os filmes com a duração de
empréstimo de 3 a 6. Os resultados devem ser classificados em filmes com maior duração de
empréstimo primeiro.

Monte um relatório que exiba o título e classificação dos 500 primeiros filmes direcionados para
menores de idade. Os resultados devem estar ordenados por classificação mais abrangente primeiro.

P.S. As classificações podem ser verificadas acima, na seção "Alavancando o poder dos principais
comparadores lógicos".

Encontrando e separando resultados que incluem datas

No MySQL, o tipo DATE faz parte dos tipos de dados temporais, os quais vamos ver com mais detalhes no
decorrer do curso. O MySQL, por padrão, usa o formato YYYY-MM-DD (ano/mês/dia) ao armazenar os
valores de uma data. Você é obrigado, pelo banco de dados, a salvar nesse formato, e não é possível
alterá-lo. Temos também o tipo DATETIME, que inclui informações de tempo. Vamos ver 2 tipos comuns
a seguir:

DATE - Possui apenas data, no formato YYYY-MM-DD na faixa de 1001-01-01 até 9999-12-31

DATETIME - Possui data e tempo, no formato YYYY-MM-DD HH:MM:SS com a faixa de 1000-01-01
00:00:00 até 9999-12-31 23:59:59.

Se você pesquisar agora no banco sakila usando a seguinte query:

SELECT * FROM sakila.payment;

É possível confirmar que a coluna payment_date é exibida no formato YYYY-MM-DD HH:MM:SS. Assim,
para fazer pesquisas e filtrar dados baseados em datas, temos que ter sempre isso em mente: quando
você pensar no dia de 25 de dezembro de 2020, para o banco dados, esse dia será 2020-12-25.

Maneiras de encontrar dados por data

Vamos dizer que queremos encontrar pagamentos realizados na data 2005-07-31 na tabela
sakila.payment. Há várias formas de fazer isso.

Usando a função DATE(coluna_do_tipo_date):

-- Encontra todos os pagamentos deste dia, ignorando horas, minutos e segundos

SELECT * FROM sakila.payment

WHERE DATE(payment_date) = '2005-07-31';

Usando LIKE para valores aproximados:

-- Encontra todos pagamentos deste dia, ignorando horas, minutos e segundos

SELECT * FROM sakila.payment

WHERE payment_date LIKE '2005-07-31%';

-- Encontra um pagamento com dia e hora exatos

SELECT * FROM sakila.payment

WHERE payment_date LIKE '2005-08-20 00:30:52';

Usando BETWEEN:
-- Encontra pagamentos especificando um valor mínimo e um valor máximo para a data

SELECT *

FROM sakila.payment

WHERE payment_date BETWEEN '2005-05-26 00:00:00' AND '2005-05-27 23:59:59';

Qual é mais performática? Use o Execution Plan para determinar isso.

Selecionando apenas partes de uma data

Às vezes você está interessado em apenas uma parte de uma data, como o ano ou as horas. MySQL
possui funções que retornam partes específicas de uma data ou hora.

-- Teste cada um dos comandos a seguir:

SELECT DATE(payment_date) FROM sakila.payment; -- YYYY-MM-DD

SELECT YEAR(payment_date) FROM sakila.payment; -- Ano

SELECT MONTH(payment_date) FROM sakila.payment; -- Mês

SELECT DAY(payment_date) FROM sakila.payment; -- Dia

SELECT HOUR(payment_date) FROM sakila.payment; -- Hora

SELECT MINUTE(payment_date) FROM sakila.payment; -- Minuto

SELECT SECOND(payment_date) FROM sakila.payment; -- Segundo

Treinando consultas com datas

Você já tem as ferramentas em mãos, então quero ver os dedos se mexendo. Let's GO!!!

Quantos aluguéis temos com a data de retorno 2005-08-29? Há múltiplas maneiras possíveis de
encontrar a resposta.
 Quantos filmes foram alugados entre 01/07/2005 e 22/08/2005?

Usando a tabela rental, extraia a data, ano, mês, dia, hora, minuto e segundo dos registros com
rental_id = 10330.

Monte uma query que encontre o id e a data de aluguel do filme que foi alugado no dia 18/08/2005 às
00:14:03.

Exercicios

https://sqlzoo.net/wiki/SELECT_names

https://sqlzoo.net/wiki/SELECT_from_WORLD_Tutorial

https://sqlzoo.net/wiki/SELECT_from_Nobel_Tutorial

https://sqlzoo.net/wiki/SELECT_Quiz

https://sqlzoo.net/wiki/BBC_QUIZ

Bonus

https://sqlzoo.net/wiki/Nobel_Quiz

https://www.hackerrank.com/domains/sql?filters%5Bsubdomains%5D%5B%5D=select

Exercício 8: Usando o banco de dados Scientists restaurado no dia anterior realize os exercícios a seguir.
Caso ainda não tenha restaurado o banco utilize o código abaixo para fazê-lo.

DROP SCHEMA IF EXISTS Scientists;

CREATE SCHEMA Scientists;

USE Scientists;

CREATE TABLE Scientists (

SSN INT,

Name CHAR(30) NOT NULL,

PRIMARY KEY (SSN)

);
CREATE TABLE Projects (

Code CHAR(4),

Name CHAR(50) NOT NULL,

Hours INT,

PRIMARY KEY (Code)

);

CREATE TABLE AssignedTo (

Scientist INT NOT NULL,

Project CHAR(4) NOT NULL,

PRIMARY KEY (Scientist, Project),

FOREIGN KEY (Scientist) REFERENCES Scientists (SSN),

FOREIGN KEY (Project) REFERENCES Projects (Code)

);

INSERT INTO Scientists(SSN,Name)

VALUES(123234877, 'Michael Rogers'),

(152934485, 'Anand Manikutty'),

(222364883, 'Carol Smith'),

(326587417, 'Joe Stevens'),

(332154719, 'Mary-Anne Foster'),

(332569843, 'George ODonnell'),

(546523478, 'John Doe'),

(631231482, 'David Smith'),

(654873219, 'Zacary Efron'),

(745685214, 'Eric Goldsmith'),

(845657245, 'Elizabeth Doe'),

 (845657246, 'Kumar Swamy');

INSERT INTO Projects (Code, Name, Hours)

VALUES ('AeH1' ,'Winds: Studying Bernoullis Principle', 156),

('AeH2', 'Aerodynamics and Bridge Design', 189),

('AeH3', 'Aerodynamics and Gas Mileage', 256),

('AeH4', 'Aerodynamics and Ice Hockey', 789),

('AeH5', 'Aerodynamics of a Football', 98),

('AeH6', 'Aerodynamics of Air Hockey', 89),

('Ast1', 'A Matter of Time', 112),

('Ast2', 'A Puzzling Parallax', 299),

('Ast3', 'Build Your Own Telescope', 6546),

('Bte1', 'Juicy: Extracting Apple Juice with Pectinase', 321),

('Bte2', 'A Magnetic Primer Designer', 9684),

('Bte3', 'Bacterial Transformation Efficiency', 321),

('Che1', 'A Silver-Cleaning Battery', 545),

('Che2', 'A Soluble Separation Solution', 778);

INSERT INTO AssignedTo (Scientist, Project)

VALUES (123234877, 'AeH1'),

(152934485, 'AeH3'),

(222364883, 'Ast3'),

(326587417, 'Ast3'),

(332154719, 'Bte1'),

(546523478, 'Che1'),

(631231482, 'Ast3'),

(654873219, 'Che1'),

(745685214, 'AeH3'),
 (845657245, 'Ast1'),

(845657246, 'Ast2'),

(332569843, 'AeH4');

link: https://creativecommons.org/licenses/by-sa/3.0/

Escreva uma query para exibir todas as informações de todos os cientistas que possuam a letra e em
seu nome.

Escreva uma query para exibir o nome de todos os projetos cujo o código inicie com a letra A. Ordene
o resulto em ordem alfabética.

Escreva uma query para exibir o código e nome de todos os projetos que possuam em seu código o
número 3. Ordene o resulto em ordem alfabética.

Escreva uma query para exibir todos os cientistas cujos projetos sejam AeH3, Ast3 ou Che1.

Escreva uma query para exibir todas as informações de todos os projetos com mais de 500 horas.

Escreva uma query para exibir todas as informações de todos os projetos cujas horas sejam maiores
que 250 e menores 800.

Escreva uma query para exibir o nome e o código de todos os projetos cujo o nome NÃO inicie com a
A.

Escreva uma query para exibir o nome de todos os projetos cujo o código contenha a letra H.

https://popsql.com/learn-sql/mysql/how-to-query-date-and-time-in-mysql

Segunda Parte

Nayane Gomes Agaipos

Gabaritos

Agenda

Aulas ao Vivo

Trybe Talks
 Glossário

Logout

avatar image

TRYBE

Manipulando tabelas

Manipulando tabelas

O que vamos aprender?

Por que isso é importante?

Conteúdos:

Vamos fazer juntos!

Exercícios

Bônus

Recursos adicionais (opcional)

Próximo

O que vamos aprender?

Nos últimos dias temos visto principalmente como fazer queries para encontrar e filtrar dados em um
banco usando os diversos comandos do SQL. Porém, hoje será um pouco diferente. Vamos focar em
aprender a fazer a inserção, alteração e exclusão de dados nas tabelas de um banco de dados. Em uma
futura aula não tão distante, aprenderemos também a criar tabelas (No Spoilers!!!).

Você será capaz de:

Inserir dados em tabelas com INSERT

Atualizar dados em tabelas com UPDATE

Apagar dados em tabelas com DELETE

Por que isso é importante?

O acrônimo CRUD (Create, Read, Update, Delete) faz parte da sopa de letrinhas que todas as pessoas
desenvolvedoras devem saber. Em função das rotinas recorrentes utilizadas dentro do desenvolvimento,
todo software, independente da plataforma ou tecnologia utilizada, terá que, em algum ponto da sua
existência, lidar com a criação, leitura, alteração ou exclusão de dados

Conteúdos:

Tempo sugerido para realização: 120 minutos

Apagou informação que não devia ou terminou todos exercícios do dia?

Como agora você começará a mexer na estrutura do banco de dados sakila, você deve saber recriar o
banco de dados quantas vezes for necessário, em caso de alterações acidentais ou por alguma outra
necessidade. Os passos para recriar o banco podem ser lidos a seguir.

Como apagar (dropar) o banco sakila e recriá-lo do zero:

Abra o MySQL Workbench e se conecte a ele.

Selecione o banco sakila na lista de bancos de dados com o botão direito e clique em "Drop Schema".

Selecione "Drop Now".

Clique com o botão direito neste link e salve como arquivo .sql.

Selecione todo o conteúdo do arquivo (CTRL + A) e cole-o dentro de uma janela de nova query no
MySQL Workbench.

Clique em executar para restaurar o banco de dados.

Restaurando o banco `sakila`

That's IT! Está pronto para quebrar brincar com ele de novo!

Tabela vazia? Vamos resolver isso ae! INSERT na prática

Informação importante sobre os tipos de aspas

Backticks ou crase (``): São usadas para identificar nome de tabelas e colunas. São necessárias apenas
quando o identificador for uma palavra reservada do MySQL, ou quando o nome da tabela ou coluna
contiver espaços em branco.

Aspas simples (''): Devem ser usadas em valores do tipo string. Aspas simples são aceitas na maioria dos
sistemas de gerenciamento de banco de dados. Sendo assim, é preferível usar aspas simples no lugar das
aspas duplas.

Só usaremos os backticks aqui nos exemplos caso sejam absolutamente necessários. Caso contrário, eles
serão omitidos.

Vamos começar a dar vida ao banco sakila. Uma pesquisa rápida na tabela sakila.staff nos informa que a
empresa possui apenas 2 funcionários. Acho que ela pode contar com nossa ajuda para melhorar isso. A
sintaxe para inserir dados em uma tabela é a seguinte:

INSERT INTO nome_da_tabela (coluna1, coluna2)

VALUES ('valor_coluna1', 'valor_coluna2');

Isso vai inserir na coluna nome_da_tabela os valores em suas colunas correspondentes. Apesar de ser
possível inserir novos valores sem especificar os nomes das colunas, é uma boa prática sempre
especificá-los porque:

Caso a estrutura da tabela tenha mudado enquanto se escreve a query, você será alertado.

Melhora a compreensão para quem estiver lendo sua query futuramente.

Inserindo várias linhas de uma vez

É possível inserir múltiplas linhas em uma tabela com uma única query:

INSERT INTO nome_da_tabela (coluna1, coluna2) VALUES

('valor_1','valor_2'),

('valor_3','valor_4'),

('valor_5','valor_6');

Dessa maneira, podemos ganhar muito tempo, tanto em tecladas como em performance de inserção.
Em média, 100 linhas inseridas dessa maneira podem ser até 10 vezes mais rápidas que fazendo
inserções de forma individual.

Ignorando linhas existentes

Quando for importar uma quantidade grande de dados, pode ser preferível, em alguns cenários, que
você simplesmente ignore os erros e pule os dados problemáticos, que normalmente interromperiam a
query em função de alguma restrição imposta na tabela. Ex: duplicidade de primary keys. Podemos
ignorar os erros durante a inserção usando o INSERT IGNORE.

Considere a tabela e a query a seguir:

Tabela `pessoas`

INSERT IGNORE INTO pessoas (id, name) VALUES

(4,'Gloria'), -- Sem o IGNORE, essa linha geraria um erro e o INSERT não continuaria.

(5,'Amanda');

-- Pesquisando agora, você verá que a informação duplicada não foi inserida.

-- Porém os dados corretos foram inseridos com sucesso.

SELECT * FROM pessoas;

Tabela <strong>pessoas</strong>

O importante aqui é lembrar que o INSERT IGNORE vai pular os outros erros silenciosamente também.

Inserindo valores em colunas com auto_increment

Primeiramente, é preciso saber que o auto_increment é uma funcionalidade que todos os bancos de
dados possuem. Ela permite que valores sejam gerados automaticamente cada vez que uma nova linha é
inserida em uma tabela que tem essa restrição ativa. Ao inserir um novo ator na tabela sakila.actor, caso
outros atores ainda não tenham sido inseridos desde que o banco foi restaurado, o próximo valor que
será gerado para actor_id será o valor do último id registrado acrescido de um (201 + 1).

Tabela `sakila.actor` com restrição <strong>auto_increment</strong>

Com isso em mente, a coluna que possui auto_increment é omitida no INSERT, uma vez que o valor já é
gerado automaticamente:

INSERT INTO sakila.actor (first_name, last_name)

VALUES('Marcelo','Santos');

Resultado do `INSERT` em `sakila.actor`

INSERT SELECT (Inserindo dados de uma outra tabela)

É possível inserir dados a partir de outra tabela usando INSERT INTO SELECT:

INSERT INTO tabelaA (coluna1, coluna2)

SELECT tabelaB.coluna1, tabelaB.coluna2

FROM tabelaB
 WHERE tabelaB.nome_da_coluna <> 'algumValor'

ORDER BY tabelaB.coluna_de_ordenacao;

Assim, estaríamos extraindo a colunaA e a colunaB da tabelaB e as inserindo na tabelaA, de acordo com
a condição que for passada no WHERE.

É possível usar também SELECT * FROM e copiar todos os dados de todas as colunas de uma tabela para
outra, mas nessa situação a tabelaA e a tabelaB precisam obrigatoriamente possuir a mesma quantidade
de colunas, e os tipos de dados das colunas correspondentes devem ser iguais.

Com essa funcionalidade, é fácil criar tabelas temporárias para testes ou por necessidade. Por exemplo,
para trazer os dados da tabela sakila.staff para a tabela sakila.actor, poderíamos fazer:

INSERT INTO sakila.actor (first_name, last_name)

SELECT first_name, last_name FROM sakila.staff;

Resultado do `INSERT` em `sakila.actor` a partir de `sekila.staff`

Um grande filósofo uma vez disse: "Practice Makes Perfect". Não sabemos quem ele é, mas ele tem
razão! Vamos praticar!

Insira um novo funcionário na tabela sakila.staff.

Para saber quais campos são obrigatórios, clique com o botão direito na tabela sakila.staff e selecione
"Table Inspector". Clique na aba "columns" e verifique quais campos aceitam nulos para te guiar.
Lembre-se de que valores que são gerados automaticamente não precisam ser inseridos manualmente.
Boa explorada!

Feito o exercício anterior, vamos agora para o nível 2. Insira 2 funcionários novos em apenas uma
query.
 Selecione os 5 primeiros nomes e sobrenomes da tabela sakila.customer e cadastre essas pessoas
como atores na tabela sakila.actor.

Cadastre 3 categorias de uma vez só na tabela sakila.category.

Cadastre 1 nova loja na tabela sakila.store.

Digitou algo errado? De boa, vamos dar um UPDATE

Você avisou na recepção que seu nome é Rannveig, mas, quando foi ver em seu documento, foi
registrado como Ravein! "Poxa, será que meu nome é tão difícil assim de se escrever?" Sua sorte é que o
UPDATE te permite alterar valores de uma tabela com base em alguma condição. Vamos resolver isso!

Tabela `sakila.staff` com `first_name` errado

UPDATE sakila.staff

SET first_name = 'Rannveig'

WHERE first_name = 'Ravein';

Tabela `sakila.staff` com `first_name` correto

Como foi exibido no código acima, a sintaxe geral para fazer um update é:

UPDATE nome_da_tabela

SET propriedade_a_ser_alterada = 'novo valor para coluna'

WHERE alguma_condicao; -- importantíssimo aplicar o WHERE para não alterar a tabela inteira!

Uma curiosidade sobre o UPDATE e o DELETE no MySQL Server é que, por padrão, existe uma
configuração chamada safe updates mode que só vai te permitir executá-los caso eles incluam quais IDs
devem ser modificados. Então, caso você tente fazer a query abaixo, ela não funcionaria por não incluir o
ID.

UPDATE sakila.staff

SET first_name = 'Rannveig'

WHERE first_name = 'Ravein';

Para evitar essa restrição, rode o seguinte comando em uma janela de query dentro do MySQL
Workbench sempre que abri-lo para desabilitar essa funcionalidade, antes de executar seus comandos
de UPDATE ou DELETE:

SET SQL_SAFE_UPDATES = 0;

Alterando mais de uma coluna ao mesmo tempo

UPDATE sakila.staff

SET first_name = 'Rannveig', last_name = 'Jordan'

WHERE staff_id = 4;

UPDATE em massa

Por questões de performance, para que apenas uma solicitação de query seja enviada ao servidor,
podemos fazer uma atualização em massa.

-- Opção 1 - Incluindo a lista de condições fixas

UPDATE sakila.actor

SET first_name = 'JOE'

WHERE actor_id IN (1,2,3);

-- Opção 2 - Especificando como cada entrada será alterada individualmente

UPDATE sakila.actor

SET first_name = (

CASE actor_id WHEN 1 THEN 'JOE' -- se actor_id = 1, alterar first_name para 'JOE'

WHEN 2 THEN 'DAVIS' -- se actor_id = 2, alterar first_name para 'DAVIS'

WHEN 3 THEN 'CAROLINE' -- se actor_id = 3, alterar first_name para 'CAROLINE'

END);

Você pode ver mais informações sobre como usar o CASEneste link.

Fazendo um UPDATE de forma sequencial

Se o comando ORDER BY for usado juntamente com o UPDATE, os resultados serão alterados na ordem
em que forem encontrados.

Se o comando LIMIT for usado em conjunto com o UPDATE, um limite será imposto na quantidade de
resultados que podem ser alterados. Caso contrário, todos os resultados que satisfizerem a condição
serão atualizados.

Veja a sintaxe abaixo. Lembre-se de que os valores entre colchetes ([]) são opcionais:

UPDATE nome_da_tabela

SET coluna1 = valor1, coluna2 = valor2

[WHERE condições]

[ORDER BY expressao [ ASC | DESC ]]

[LIMIT quantidade_resultados];

-- Exemplo:

UPDATE sakila.staff

SET password = 'FavorResetarSuaSenha123'

WHERE active = 1
ORDER BY last_update

LIMIT 2;

Essas são as maneiras mais comuns que o UPDATE pode ser utilizado no dia a dia. Agora está na hora de
praticar!

Dê um UPDATE em seus conhecimentos com esses desafios

P.S. Como dito anteriormente, o safe updates mode é habilitado por padrão no MySQL Workbench. Ele
exige que você inclua os IDs dos itens a serem atualizados ou apagados para poder executar o UPDATE
ou o DELETE. Essa camada de segurança é importante em bancos reais executando em ambientes de
produção, mas torna-se inconveniente em ambientes de aprendizado, como é o caso aqui. Como o
banco pode ser apagado e recriado infinitamente, vamos desabilitá-lo nos exercícios. Além disso, esse
modo pode ser habilitado novamente quando necessário.

Erro devido ao <strong>Safe Updates Mode</strong> estar habilitado

Rode o seguinte comando em uma janela de query dentro do MySQL Workbench sempre que abri-lo
para desabilitar essa funcionalidade, antes de executar seus comandos UPDATE ou DELETE:

SET SQL_SAFE_UPDATES = 0;

Atualize o primeiro nome de todas as pessoas da tabela sakila.actor que possuem o primeiro nome
"JULIA" para "JULES".

Foi exigido que a categoria "Sci-Fi" seja alterada para "Science Fiction".

Atualize o valor do aluguel para $25 de todos os filmes com duração maior que 100 minutos e que
possuem a classificações "G", "PG" ou "PG-13" e um custo de substituição maior que $20.

Foi determinado pelo setor financeiro que haverá um reajuste em todos os preços dos filmes, com
base em sua duração. Para todos os filmes com duração entre 0 e 100, o valor do aluguel passará a ser
$10,00, e o aluguel dos filmes com duração acima de 100 passará a ser de $20,00.
Como assim, alguém te cadastrou sem você deixar? Vamos dar um DELETE nisso!

Antes de aprender a excluir dados de uma tabela, é importante entender que nem sempre que você
clicar em excluir, em um sistema ou em um site, a informação terá sido de fato excluída do banco de
dados. Em muitos casos, a funcionalidade de "excluir" apenas marcará a informação como inativa ou
excluída, ou algum campo equivalente.

Isso ocorre pela necessidade de seguir normas ou regulamentos sobre disponibilidade e segurança de
dados. Relatórios podem necessitar de informações que já foram "excluídas" ou pode ser necessário
manter logs de uso (históricos de acontecimentos no sistema) de seu software.

Excluindo dados de uma tabela

Para excluir dados de forma básica, temos a seguinte sintaxe:

DELETE FROM banco_de_dados.tabela

WHERE coluna = 'valor'

-- O WHERE é opcional. Porém, sem ele, todas as linhas da tabela seriam excluídas.

Exemplo no banco sakila:

DELETE FROM sakila.film_text

WHERE title = 'ACADEMY DINOSAUR';

P.S. Novamente, caso o safe update mode esteja habilitado, os comandos DELETE só funcionariam se os
IDs fossem incluídos em suas queries. Para fins de prática, vamos desabilitá-lo.

Rode o seguinte comando em uma janela de query, dentro do MySQL Workbench, sempre que abri-lo,
para desabilitar essa funcionalidade antes de executar seus comandos DELETE:

SET SQL_SAFE_UPDATES = 0;
Meu DELETE não foi permitido...

Caso haja relações entre as tabelas (primary key e foreign keys) e existam restrições aplicadas a elas, ao
executar o DELETE ocorrerá uma ação de acordo com a restrição que tiver sido imposta na criação da
foreign key. Essas restrições podem ser as seguintes:

-- Rejeita o comando DELETE.

ON DELETE NO ACTION

-- Rejeita o comando DELETE.

ON DELETE RESTRICT

-- Permite a exclusão dos registros da tabela pai, e seta para NULL os registros da tabela filho.

ON DELETE SET NULL

-- Exclui a informação da tabela pai e registros relacionados.

ON DELETE CASCADE

Vamos analisar um exemplo prático:

DELETE FROM sakila.actor

WHERE first_name = 'GRACE';

Se tentar rodar essa query, você vai se deparar com o erro exibido na imagem abaixo:

Erro <strong>ON DELETE RESTRICT</strong>

O banco de dados não vai permitir que você delete o ator chamado "GRACE". Isso acontece porque a
coluna actor_id da tabela film_actor é uma chave estrangeira (foreign key) que aponta para a coluna
actor_id na tabela actor, e essa chave estrangeira possui a restrição ON DELETE RESTRICT. Se essa
restrição não existisse, o ator seria deletado, deixando nosso banco de dados em um estado
inconsistente, pois haveria linhas na tabela film_actor com um actor_id que não mais existiria!

Para conseguir excluir este ator em actors, precisamos primeiro excluir todas as referências a ele na
tabela sakila.film_actor:

DELETE FROM sakila.film_actor

WHERE actor_id = 7; -- actor_id = 7 é o Id de GRACE

Após excluir as referências, podemos excluir o ator com o nome "GRACE":

DELETE FROM sakila.actor

WHERE first_name = 'GRACE';

Antes de excluir dados que possuem restrições de chave estrangeira, como o exemplo que acabamos de
ver, analise se você realmente deve excluir essa informação do banco de dados e depois, caso precise,
faça de acordo com as restrições que foram impostas durante a criação da tabela. Elas são colocadas lá
para garantir a integridade de seus dados. Se existem restrições, normalmente não faria sentido
simplesmente ignorá-las.

DELETE VS TRUNCATE

Se tem certeza absoluta de que quer excluir os registros de uma tabela de uma maneira mais rápida,
para efeitos de testes ou necessidade, o TRUNCATE é mais rápido que o DELETE. A função principal e
única do TRUNCATE é de limpar (excluir todos os registros) de uma tabela, não sendo possível especificar
o WHERE. Por isso, o TRUNCATE só pode ser usado nesse cenário.

TRUNCATE banco_de_dados.tabela;

Caso precise excluir condicionalmente, usando regras e especificações, use sempre o comando DELETE
juntamente com o WHERE.
Vamos praticar o DELETE

Exclua do banco de dados o ator com o nome de "KARL".

Exclua do banco de dados os atores com o nome de "MATTHEW".

Exclua da tabela film_text todos os registros que possuem a palavra "saga" em suas descrições.

Apague da maneira mais performática possível todos os registros das tabelas film_actor e
film_category.

Inspecione todas as tabelas do banco de dados sakila e analise quais restrições ON DELETE foram
impostas em cada uma. Use o Table Inspector para fazer isso (aba DDL).

Exclua o banco de dados e o recrie (use as instruções no início desta aula).

Vamos fazer juntos!

Tempo sugerido para realização: 80 minutos

Vamos bater um papo sobre SQL? Hora da aula ao vivo! Vamos para o Slack, onde o link estará
disponível.

Exercícios

Tempo sugerido para realização: 40 minutos

Os exercícios propostos possuem níveis variáveis de dificuldade. Tente fazer o máximo que conseguir.

Exercício 1: Faça o exercício sobre INSERTdeste link.

Exercício 2: Faça o exerício sobre UPDATEdeste link

Crie uma conta no Vertabelo Academy para conseguir fazer os próximos exercícios.

Exercício 3: Faça este exercício sobre INSERT.

Exercício 4: Faça este exercício sobre UPDATE.

Exercício 5: Faça este exercício sobre DELETE.

Bônus

Para fazer os exercícios a seguir, restaure o backup do banco de dados HR, disponível clicando neste link
com botão direito e escolhendo a opção "Salvar como".

Execute o conteúdo deste arquivo .sql em seu banco de dados local.

Leia o enunciado do exercício.

Monte uma query em seu banco local, que você acabou de restaurar, e veja se seu resultado resolve o
desafio.

Caso não consiga resolver os exercícios, consulte as respostas clicando em "Click me to see the
solution" na página do desafio.

Exercício 6: Faça os exercícios sobre INSERTdeste link.

Exercício 7: Faça os exercícios sobre UPDATEdeste link.

Recursos adicionais (opcional)

Tutorial sobre INSERT do Guru99

Tutorial sobre INSERT do MySQL Tutorial

 Tutorial sobre UPDATE do MySQL Tutorial

Tutorial sobre DELETE e UPDATE do Guru99

Tutorial sobre DELETE do MySQL Tutorial

Tutorial sobre DELETE do Tech On The Net

Documentação sobre restrições de chaves estrangeiras no MySQL

Próximo

Manual da Pessoa Estudante

Sempre que achar necessário, consulte seu Manual para ter mais informações sobre o curso!

Tutoriais

Como usar bem o Slack

Como usar bem o Zoom

Este conteúdo está em constante desenvolvimento.

Envie seu feedback (com o link da página) para nós via Slack para nos ajudar a construir juntos o melhor
conteúdo para o seu aprendizado!

#VQV

© Trybe 2020
https://sqlbolt.com/lesson/inserting_rows

https://sqlbolt.com/lesson/updating_rows

https://academy.vertabelo.com/

https://academy.vertabelo.com/course/operating-on-data-in-sql/insert/insert/insert

https://academy.vertabelo.com/course/operating-on-data-in-sql/update/update/update

https://academy.vertabelo.com/course/operating-on-data-in-sql/delete/delete/delete

https://course.betrybe.com/back-end/HR_database_backup.sql

"https://www.guru99.com/insert-into.html" class="external-link" rel="noreferrer noopener"

target="_blank">Tutorial sobre <code class="inline">INSERT</code> do Guru99</a></p>

</li>

<li><p><a href=" https://www.mysqltutorial.org/mysql-insert-statement.aspx" class="external-link"

rel="noreferrer noopener" target="_blank">Tutorial sobre <code class="inline">INSERT</code> do
MySQL Tutorial</a></p>

</li>

<li><p><a href=" https://www.mysqltutorial.org/mysql-update-data.aspx" class="external-link"

rel="noreferrer noopener" target="_blank">Tutorial sobre <code class="inline">UPDATE</code> do
MySQL Tutorial</a></p>

</li>

<li><p><a href=" https://www.guru99.com/delete-and-update.html" class="external-link"

rel="noreferrer noopener" target="_blank">Tutorial sobre <code class="inline">DELETE</code> e <code
class="inline">UPDATE</code> do Guru99</a></p>

</li>

<li><p><a href=" https://www.mysqltutorial.org/mysql-delete-statement.aspx" class="external-link"

rel="noreferrer noopener" target="_blank">Tutorial sobre <code class="inline">DELETE</code> do
MySQL Tutorial</a></p>

</li>

<li><p><a href=" https://www.techonthenet.com/mysql/delete.php" class="external-link"

rel="noreferrer noopener" target="_blank">Tutorial sobre <code class="inline">DELETE</code> do Tech
On The Net</a></p>
</li>

<li><p><a href=" https://dev.mysql.com/doc/refman/5.7/en/create-table-foreign-keys.html"

class="external-link" rel="noreferrer noopener" target="_blank">Documentação sobre restrições de
chaves estrangeiras no MySQL</a></p>

</li>

Terceira Parte

O que vamos aprender?

Hoje você vai aprender como facilitar MUITO sua vida através das principais funções que lidam com
números, strings, datas e agregação de dados no MySQL.

Você será capaz de:

Criar condicionais no SQL usando IF e CASE;

Manipular strings no SQL;

Usar as diversas funções matemáticas do MySQL;

Extrair informações específicas sobre datas de uma tabela;

Utilizar as funções de agregação AVG, MIN, MAX, SUM e COUNT;

Exibir e filtrar dados de forma agrupada com GROUP BY e HAVING.

Por que isso é importante?

Isso é importante porque os comandos e funcionalidades que você vai ver hoje te permitirão encontrar
informações estatísticas e temporais sobre seus dados. Além disso, ao saber controlar o fluxo de uma
query utilizando condicionais, você será capaz de tratar diferentes cenários em uma única consulta.

Conteúdos:

Tempo sugerido para realização: 120 minutos

Manipulação de strings

Uma das responsabilidades das pessoas que lidam com o registro de informações em um banco de
dados é se certificar que estes dados estão coerentes, normalizados e cadastrados no formato correto. O
MySQL possui algumas funções de manipulação de string que facilitam essas tarefas.

As principais podem ser vistas a seguir:

-- Converte o texto da string para CAIXA ALTA

SELECT UCASE('Oi, eu sou uma string');

-- Converte o texto da string para caixa baixa

SELECT LCASE('Oi, eu sou uma string');

-- Substitui as ocorrências de uma substring em uma string

SELECT REPLACE('Oi, eu sou uma string', 'string', 'cadeia de caracteres');

-- Retorna a parte da esquerda de uma string de acordo com o

-- número de caracteres especificado

SELECT LEFT('Oi, eu sou uma string', 3);

-- Retorna a parte da direita de uma string de acordo com o

-- número de caracteres especificado

SELECT RIGHT('Oi, eu sou um string', 6);

-- Exibe o tamanho, em caracteres, da string

SELECT LENGTH('Oi, eu sou uma string');

-- Extrai parte de uma string de acordo com o índice de um caractere inicial

-- e a quantidade de caracteres a extrair

SELECT SUBSTRING('Oi, eu sou uma string', 5, 2);

-- Se a quantidade de caracteres a extrair não for definida,

-- então a string será extraída do índice inicial definido, até o seu final

SELECT SUBSTRING('Oi, eu sou uma string', 5);

Para fixar melhor, que tal explorar na prática o que cada comando faz? Rode cada um deles no MySQL
Workbench e veja os resultados.

Observe que, apesar de ter usado strings temporárias nos exemplos acima, também é possível fazer
essas operações diretamente nas colunas de uma tabela. Para testar, execute o código abaixo no seu
ambiente local, brinque com as linhas a seguir e depois volte aqui.

SELECT UCASE(title) FROM sakila.film LIMIT 10;

SELECT LCASE(title) FROM sakila.film LIMIT 10;

SELECT REPLACE(title, 'ACADEMY', 'FOO') FROM sakila.film WHERE film_id = 1;

SELECT LEFT(title, 7) FROM sakila.film WHERE film_id = 1;

SELECT RIGHT(title, 8) FROM sakila.film WHERE film_id = 1;

SELECT LENGTH(title) FROM sakila.film WHERE film_id = 1;

SELECT SUBSTRING(title, 5, 2) FROM sakila.film WHERE film_id = 1;

SELECT SUBSTRING(title, 5) FROM sakila.film WHERE film_id = 1;

Algo importante a se notar sobre strings em SQL é que, diferente de várias linguagens de programação,
no SQL strings são indexadas a partir do índice 1 e não no índice 0. Caso tenha resultados inesperados,
essa pode ser uma das razões.
Agora, vamos fixar os aprendizados com alguns desafios:

Faça uma query que exiba a palavra 'trybe' em CAIXA ALTA.

Faça uma query que transforme a frase 'Você já ouviu falar do DuckDuckGo?' em 'Você já ouviu falar
do Google?'.

Utilizando uma query, encontre quantos caracteres temos em 'Uma frase qualquer'.

Extraia e retorne a palavra "JavaScript" da frase 'A linguagem JavaScript está entre as mais usadas'.

Por fim, padronize a string 'RUA NORTE 1500, SÃO PAULO, BRASIL' para que suas informações estejam
todas em caixa baixa.

Condicionais

Em linguagens de alto nível como Python, JavaScript e outras, as condicionais são a base para a criação
de algorítimos dinâmicos que se adaptam de acordo com a necessidade do programa. O SQL não fica
para trás nesse quesito, sendo possível nele também usar os principais comandos de controle de fluxo,
como o IF e o CASE.

Para entender como isso pode ser feito, veja os exemplos abaixo:

-- Sintaxe:

SELECT IF(condicao, valor_se_verdadeiro, valor_se_falso);

SELECT IF(idade >= 18, 'Maior de idade', 'Menor de Idade')

FROM pessoas;
SELECT IF(aberto = true, 'Entrada permitida', 'Entrada não permitida')

FROM estabelecimentos;

-- Exemplo utilizando o banco sakila:

SELECT first_name, IF(active = true, 'Cliente Ativo', 'Cliente Inativo') AS status

FROM sakila.customer

LIMIT 20;

Em situações em que é preciso comparar mais de uma condição, é preferível utilizar o CASE.

-- Sintaxe:

SELECT CASE

WHEN condicao THEN valor

ELSE valor padrao

END;

SELECT

nome,

nivel_acesso,

CASE

WHEN nivel_acesso = 1 THEN 'Nível de acesso 1'

WHEN nivel_acesso = 2 THEN 'Nível de acesso 2'

WHEN nivel_acesso = 3 THEN 'Nível de acesso 3'

ELSE 'Usuário sem acesso'

END AS nivel_acesso

FROM permissoes_usuario;

-- Exemplo utilizando a tabela sakila.film:

SELECT

first_name,

email,

CASE

WHEN email = '[email protected]' THEN 'Cliente de baixo valor'

WHEN email = '[email protected]' THEN 'Cliente de médio valor'

WHEN email = '[email protected]' THEN 'Cliente de alto valor'

ELSE 'não classificado'

END AS valor

FROM sakila.customer

LIMIT 10;

Esse tema é melhor aprendido quebrando a cabeça praticando, então vamos fazer isso.

Usando o IF na tabela sakila.film, exiba o id do filme, o título e uma coluna extra chamada 'conheço o
filme?', em que deve-se avaliar se o nome do filme é 'ACE GOLDFINGER'. Caso seja, exiba "Já assisti esse
filme". Caso contrário, exiba "Não conheço o filme". Não esqueça de usar um alias para renomear a
coluna da condicional.

Usando o CASE na tabela sakila.film, exiba o título, a classificação indicativa (rating) e uma coluna extra
que vamos chamar de 'público alvo', em que classificaremos o filme de acordo com as seguintes siglas:

G: "Livre para todos";

PG: "Não recomendado para menores de 10 anos";

PG-13: "Não recomendado para menores de 13 anos";

R: "Não recomendado para menores de 17 anos";

Se não cair em nenhuma das classificações anteriores: "Proibido para menores de idade".

Funções matemáticas do MySQL

Até o momento focamos em como buscar e exibir informações já existentes em uma tabela. Agora,
vamos ver como podemos utilizar essa informação para calcular e gerar novos dados com as principais
funções matemáticas disponíveis no MySQL.

Adição, Subtração, Multiplicação e Divisão

Para as operações matemáticas mais comuns, podemos usar os operadores matemáticos usuais. Vamos
testar cada um deles?

Execute os seguintes comandos dentro do Workbench:

SELECT 5 + 5;

SELECT 5 - 5;

SELECT 5 * 5;

SELECT 5 / 5;

Podemos, também, usar as colunas diretamente como base para os cálculos, caso necessário.

SELECT rental_duration + rental_rate FROM sakila.film LIMIT 10;

SELECT rental_duration - rental_rate FROM sakila.film LIMIT 10;

SELECT rental_duration / rental_rate FROM sakila.film LIMIT 10;

SELECT rental_duration * rental_rate FROM sakila.film LIMIT 10;

Divisão de inteiros com DIV e como encontrar seus restos com o MOD

O DIV retorna o resultado inteiro de uma divisão, ignorando as casas decimais de um número. Veja os
exemplos abaixo:

SELECT 10 DIV 3; -- 3

SELECT 10 DIV 2; -- 5
SELECT 14 DIV 3; -- 4

SELECT 13 DIV 2; -- 6

Já o operador MOD retorna o resto de uma divisão como resultado. Por exemplo:

SELECT 10 MOD 3; -- 1

SELECT 10 MOD 2; -- 0

SELECT 14 MOD 3; -- 2

SELECT 13 MOD 2; -- 1

SELECT 10.5 MOD 2; -- 0.5, ou seja, 2 + 2 + 2 + 2 + 2 = 10, restando 0.5

Desafios com DIV e MOD

Dica: Números pares são aqueles que podem ser divididos em duas partes iguais. Ou seja, são aqueles
cuja divisão por 2 retorna resto 0.

Monte uma query usando o MOD juntamente com o IF para descobrir se o valor 15 é par ou ímpar.
Chame essa coluna de 'Par ou Ímpar', onde ela pode dizer 'Par' ou 'Impar'.

Temos uma sala de cinema que comporta 220 pessoas. Quantos grupos completos de 12 pessoas
podemos levar ao cinema sem que ninguém fique de fora?

Utilizando o resultado anterior, responda à seguinte pergunta: Temos lugares sobrando? Se sim,
quantos?

Arredondando Valores

Ter a capacidade de encontrar aproximações de valores é algo extremamente valioso na criação de

relatórios e gráficos, que são utilizados por softwares de todos os tipos. O MySQL tem algumas funções
que te ajudam a resolver isso. Vamos conhecê-las agora.
O ROUND arredonda os números de acordo com sua parte decimal. Se for maior ou igual a 0.5, o
resultado é um arredondmanto para cima. Caso contrário, ocorre um arredondamento para baixo. Veja
os exemplos abaixo:

-- Podemos omitir ou especificar quantas casas decimais queremos

SELECT ROUND(10.4925); -- 10

SELECT ROUND(10.5136); -- 11

SELECT ROUND(-10.5136); -- -11

SELECT ROUND(10.4925, 2); -- 10.49

SELECT ROUND(10.4925, 3); -- 10.493

O arredondamento sempre para cima pode ser feito com o CEIL:

SELECT CEIL(10.51); -- 11

SELECT CEIL(10.49); -- 11

SELECT CEIL(10.2); -- 11

O arredondamento sempre para baixo pode ser feito com o FLOOR:

SELECT FLOOR(10.51); -- 10

SELECT FLOOR(10.49); -- 10

SELECT FLOOR(10.2); -- 10

Exponenciação e Raiz Quadrada

Para calcular a exponenciação e a raiz quadradas, podemos utilizar as funções POW e SQRT,
respectivamente.
Elevando um número X à potência Y usando a função POW:

SELECT POW(2, 2); -- 4

SELECT POW(2, 4); -- 16

Encontrando a raiz quadrada de um valor usando SQRT:

SELECT SQRT(9); -- 3

SELECT SQRT(16); -- 4

Gerando valores aleatórios

Para situações em que se faz necessário gerar valores aleatórios, podemos usar a função RAND, em
conjunto com as funções anteriores.

-- Para gerar um valor aleatório entre 0 e 1:

SELECT RAND();

-- Para gerar um valor entre 7 e 13:

SELECT FLOOR(7 + (RAND() * 6));

-- O cálculo que é feito é o seguinte: (7 + (0.0 a 1.0 * 6))

Consolidando seu conhecimento

Monte uma query que gere um valor entre 15 e 20.

Monte uma query que exiba o valor arredondado de 15.75 com uma precisão de 5 casas decimais.
 Estamos com uma média de 39.494 de vendas de camisas por mês. Qual é o valor aproximado para
baixo dessa média?

Temos uma taxa de inscrição de 85.234% no curso de fotografia para iniciantes. Qual é o valor
aproximado para cima dessa média?

Trabalhando com datas

Podemos consultar a data e hora atuais usando as seguintes funções:

SELECT CURRENT_DATE(); -- YYYY-MM-DD

SELECT NOW(); -- YYYY-MM-DD HH:MM:SS

Podemos descobrir a diferença em dias entre duas datas usando o DATEDIFF e, a diferença de tempo
entre dois horários usando o TIMEDIFF. Em ambos os casos, o segundo valor é subtraído do primeiro
para calcular o resultado.

-- 30, ou seja, a primeira data é 30 dias depois da segunda

SELECT DATEDIFF('2020-01-31', '2020-01-01');

-- -30, ou seja, a primeira data é 30 dias antes da segunda

SELECT DATEDIFF('2020-01-01', '2020-01-31');

-- -01:00:00, ou seja, há 1 hora de diferença entre os horários

SELECT TIMEDIFF('08:30:10', '09:30:10');

E por fim, podemos extrair qualquer parte de uma data de uma coluna:
SELECT DATE(data_cadastro); -- YYYY-MM-DD

SELECT YEAR(data_cadastro); -- Ano

SELECT MONTH(data_cadastro); -- Mês

SELECT DAY(data_cadastro); -- Dia

SELECT HOUR(data_cadastro); -- Hora

SELECT MINUTE(data_cadastro); -- Minuto

SELECT SECOND(data_cadastro); -- Segundo

Também podemos usar CURRENT_DATE() e NOW() em conjunto com os comandos acima para encontrar
resultados dinâmicos da seguinte maneira:

SELECT YEAR(CURRENT_DATE()); -- retorna o ano atual

SELECT HOUR(NOW()); -- retorna a hora atual

Para fixar, responda como seria possível encontrar as seguintes informações:

Monte uma query que exiba a diferença de dias entre '2030-01-20' e hoje.

Monte uma query exiba a diferença de horas entre '10:25:45' e '11:00:00'.

Utilizando as funções de agregação AVG, MIN, MAX, SUM e COUNT

Existem certos tipos de cálculos que são usados muito frequentemente e não devem ser feitos
manualmente toda vez. Por isso temos as seguintes funções que analisam todos os registros de uma
determinada coluna e retornam um valor depois de comparar e avaliar todos os registros.

-- Usando a coluna replacement_cost (valor de substituição) vamos encontrar:

SELECT AVG(replacement_cost) FROM sakila.film; -- 19.984000 (Média entre todos registros)

SELECT MIN(replacement_cost) FROM sakila.film; -- 9.99 (Menor valor encontrado)

SELECT MAX(replacement_cost) FROM sakila.film; -- 29.99 (Maior valor encontrado)

SELECT SUM(replacement_cost) FROM sakila.film; -- 19984.00 (Soma de todos registros)

SELECT COUNT(replacement_cost) FROM sakila.film; -- 1000 registros encontrados (Quantidade)

Para praticar, vamos encontrar algumas informações sobre os filmes cadastrados em nossa base de
dados.

Monte um query que exiba:

A média de duração dos filmes e dê o nome da coluna de 'Média de Duração';

A duração mínima dos filmes como 'Duração Mínima';

A duração máxima dos filmes como 'Duração Máxima';

A soma de todas as durações como 'Tempo de Exibição Total';

E finalmente, a quantidade total de filmes cadastrados na tabela sakila.film como 'Filmes

Registrados'.

Exibindo e filtrando dados de forma agrupada com GROUP BY e HAVING

Os resultados de uma query podem ser agrupados por uma ou mais colunas usando o GROUP BY, o que
faz com que todos registros que têm o mesmo valor para tais colunas sejam exibidos juntos. O GROUP BY
também pode ser usado em conjunto com as funções de agregação que vimos anteriormente.

O GROUP BY pode ser construido da seguinte forma:

SELECT coluna(s) FROM tabela

GROUP BY coluna(s);

Uma das formas como podemos utilizar o GROUP BY é agrupar os registros pelo valor de uma coluna,
exibindo apenas um registro de cada valor, como é feito com a coluna first_name a seguir.

SELECT first_name FROM sakila.actor

GROUP BY first_name;

Tendo visto isso, agora vamos explorar como utilizar o GROUP BY em conjunto com as diversas funções
de agregação que foram estudadas até aqui, através alguns exemplos feitos com o nosso banco de dados
sakila.

-- Média de duração de filmes agrupados por classificação indicativa

SELECT rating, AVG(length)

FROM sakila.film

GROUP BY rating;

-- Valor mínimo de substituição dos filmes agrupados por classificação indicativa

SELECT rating, MIN(replacement_cost)

FROM sakila.film

GROUP BY rating;

-- Valor máximo de substituição dos filmes agrupados por classificação indicativa

SELECT rating, MAX(replacement_cost)

FROM sakila.film

GROUP BY rating;

-- Custo total de substituição de filmes agrupados por classificação indicativa

SELECT rating, SUM(replacement_cost)

FROM sakila.film

GROUP by rating;

Vamos praticar

Monte uma query que exiba a quantidade de clientes cadastrados na tabela sakila.customer que estão
ativos e a quantidade que estão inativos.
 Monte uma query para a tabela sakila.customer que exiba a quantidade de clientes ativos e inativos
por loja. Os resultados devem conter o ID da loja, o status dos clientes (ativos ou inativos) e a quantidade
de clientes por status.

Monte uma query que exiba a média de duração por classificação indicativa (rating) dos filmes
cadastrados na tabela sakila.film. Os resultados devem ser agrupados pela classificação indicativa e
ordenados da maior média para a menor.

Monte uma query para a tabela sakila.address que exiba o nome do distrito e a quantidade de
endereços registrados nele. Os resultados devem ser ordenados da maior quantidade para a menor.

Filtrando Resultados do GROUP BY com HAVING

Podemos usar o HAVING para filtrar resultados agrupados, assim como usamos o SELECT...WHERE para
filtrar resultados individuais.

A query a seguir busca o nome e quantidade de nomes cadastrados na tabela sakila.actor e os agrupa
por quantidade. Por fim, filtramos os resultados agrupados usando o HAVING, para que somente os
nomes que estão cadastrados duas ou mais vezes sejam exibidos.

SELECT first_name, COUNT(*)

FROM sakila.actor

GROUP BY first_name

HAVING COUNT(*) > 2;

-- Ou melhor ainda, usando o AS para dar nomes às colunas de agregação,

-- melhorando a leitura do resultado

SELECT first_name, COUNT(*) AS nomes_cadastrados

FROM sakila.actor

GROUP BY first_name
HAVING nomes_cadastrados > 2;

-- Observação: o alias não funciona com strings para o HAVING,

-- então use o underline ("_") para separar palavras

-- Ou seja, o exemplo abaixo não vai funcionar

SELECT first_name, COUNT(*) AS 'nomes cadastrados'

FROM sakila.actor

GROUP BY first_name

HAVING 'nomes cadastrados' > 2;

É importante entender que quando usamos o HAVING estamos filtrando somente os resultados gerados
após o GROUP BY ter sido executado.

Então vamos brincar um pouco com ele:

Usando a query a seguir, exiba apenas as durações médias que estão entre 115.0 a 121.50. Além disso,
dê um alias (apelido) à coluna gerada por AVG(length), de forma que deixe a query mais legível. Finalize
ordenando os resultados de forma decrescente.

SELECT rating, AVG(length)

FROM sakila.film

GROUP BY rating;

Usando a query a seguir, exiba apenas os valores de total de substituição de custo que estão acima de
$3950.50. Dê um alias que faça sentido para SUM(replacement_cost), de forma que deixe a query mais
legível. Finalize ordenando os resultados de forma crescente.

SELECT rating, SUM(replacement_cost)

FROM sakila.film

GROUP by rating;
Vamos fazer juntos!

Tempo sugerido para realização: 80 minutos

Woohoo é isso ae, parabéns por ter finalizado o conteúdo de hoje! Vamos bater um papo agora na aula
ao vivo. O link estará disponível no Slack.

You win the internet by Giphy

Exercícios

Tempo sugerido para realização: 40 minutos

Exercício 1: Exercícios sobre funções de agregação neste link.

Exercício 2: Exercícios sobre funções de agregação parte 2 neste link.

Restaure o banco de dados abaixo antes de continuar:

O banco de dados usado como base para os próximos exercícios pode ser restaurado usando este
arquivo SQL.

Baixe o conteúdo do arquivo .sql linkado acima;

Copie todo o código SQL;

Abra o MySQL Workbench e abra uma nova janela de query;

Copie todo o código para dentro dessa janela;

Selecione todo o código usando Ctrl + a;

Execute o código teclando Ctrl + ENTER.

Instruções de como fazer os exercícios a seguir

Clique no link do exercício;

Leia o exercício;

Desenvolva a solução eu seu banco de dados local (banco de dados HR);

Verifique a solução voltando no link do exercício e clicando em no link "Click me to see the solution"
do exercício que está fazendo.

Exercício 3: Exercícios sobre funções de agregação parte 3 neste link.

https://www.w3resource.com/mysql-exercises/aggregate-function-exercises/

Exercício 4: Exercícios sobre manipulação de strings neste link. https://www.w3resource.com/mysql-

exercises/string-exercises/

Exercício 5: Exercícios sobre datas e tempo neste link.

https://www.w3resource.com/mysql-exercises/date-time-exercises/

O que vamos aprender?

Bem vindo de volta! Hoje você vai aprender a utilizar os diferentes tipos de JOIN para juntar dados
relacionados em um banco de dados. Similarmente, vai entender como unir resultados de duas ou mais
queries em apenas uma, através do UNION.

Você será capaz de:

Utilizar INNER JOIN para combinar dados de duas ou mais tabelas

Utilizar LEFT JOIN e RIGHT JOIN para combinar dados de duas ou mais tabelas

Utilizar SELF JOIN para fazer join de uma tabela com ela própria

Unir resultados com UNION e UNION ALL

Por que isso é importante?

A ideia do JOIN é permitir combinar registros de duas ou mais tabelas, através do relacionamento que
uma tabela tem com a outra. Já o UNION permite acrescentar os resultados de uma query à outra.

Todas essas funcionalidades podem ser usadas para diferentes propósitos no seu dia a dia de trabalho,
como a criação de relatórios, criação de novas maneiras de exibir uma informação já cadastrada em uma
tabela e adicionar detalhes a tabelas existentes, entre outras possibilidades.

Conteúdos

Tempo sugerido para realização: 80 minutos

O que é um JOIN?

Até o momento, você já criou consultas para filtrar, ordenar, selecionar, alterar, agrupar, inserir e apagar
dados armazenados nas tabelas dos seus bancos de dados. Cada consulta, no entanto, sempre acessava
apenas uma tabela.

Em alguns casos, uma tabela pode não possuir toda a informação necessária. Em função disso, existe a
opção de usar os diversos tipos de JOIN para combinar em um mesmo resultado registros de duas ou
mais tabelas. Esses tipos são: INNER JOIN, LEFT JOIN e RIGHT JOIN, para combinar duas ou mais tabelas e
SELF JOIN, quando uma tabela precisa ser combinada consigo mesma. Você verá detalhes de cada um
desses tipos de JOIN a seguir.

O que o banco pensa quando você diz `JOIN`

Como utilizar o INNER JOIN

Assista ao vídeo a seguir para entender como usar o INNER JOIN.

Como foi visto no vídeo, o INNER JOIN permite retornar todos os resultados em que a condição da
cláusula ON for satisfeita. A sintaxe de um INNER JOIN é a seguinte:

SELECT t1.coluna, t2.coluna

FROM tabela1 AS t1
INNER JOIN tabela2 AS t2

ON t1.coluna_em_comum = t2.coluna_em_comum;

Veja uma representação visual do INNER JOIN abaixo:

INNER JOIN. Fonte: Wikipedia

Por que usamos o alias (AS)?

O alias AS é usado para apelidar qualquer parte da sua query. Isso ajuda o sistema de banco de dados a
identificar a qual coluna estamos nos referindo, evitando erros de ambiguidade de nome de colunas,
além de tornar suas queries mais concisas e legíveis.

Por exemplo, observe as queries a seguir:

**Código sem** `alias`

```language-sql SELECT sakila.actor.first_name, actor_id, sakila.film_actor.actor_id FROM sakila.actor

INNER join film_actor ON sakila.actor.actor_id = sakila.film_actor.actor_id; ``` O código acima, além de
ser muito extenso, não permite que o banco de dados descubra de qual tabela deve trazer o `actor_id`,
uma vez que ambas as tabelas `actor` e `filme_actor` possuem uma coluna `actor_id`. O seguinte erro
será gerado ao tentar executar essa query:

**Código com** `alias`

Podemos tornar a query mais legível com um *alias*, além de evitar o erro de ambiquidade de coluna:
```language-sql SELECT a.first_name, a.actor_id, f.actor_id FROM sakila.actor AS a INNER JOIN film_actor
AS f ON a.actor_id = f.actor_id; ``` **OBS.:** A palavra chave `AS` pode ser omitida. Nesse caso, o *alias*
é passado diretamente, após o nome da tabela: ```language-sql SELECT a.first_name, a.actor_id,
f.actor_id FROM sakila.actor a INNER JOIN film_actor f ON a.actor_id = f.actor_id; ```

Dicas sobre como escolher o tamanho do alias

Sua query é composta de poucas linhas? Então use apenas letras ou a primeira sílaba para representar a
coluna. Por exemplo, "actor" se tornaria "A" ou "act".

Caso esteja montando JOINS com muitas linhas, é recomendado usar um alias mais descritivo para
tornar a leitura e interpretação da query mais simples.
Ok, Linus, it's coding time!

Vamos ver agora alguns desafios para consolidar esse conhecimento sobre o INNER JOIN, utilizando o
banco de dados sakila. Antes de começar a escrever suas queries, identifique quais tabelas contêm as
informações de que você precisa e como elas estão relacionadas.

Monte uma query que exiba o id do ator, nome do ator e id do filme em que ele já atuou usando as
tabelas actor e film_actor.

Use o JOIN para exibir o nome, sobrenome e endereço de cada um dos funcionários do banco. Use as
tabelas staff e address.

Exiba o id do cliente, nome e email dos primeiros 100 clientes, ordenados pelo nome em ordem
decrescente, juntamente com o id do endereço e o nome da rua onde o cliente mora. Essas informações
podem ser encontradas nas tabelas customer e address.

Exiba o nome, email, id do endereço, endereço e distrito dos clientes que moram no distrito da
California e que contêm "rene" em seus nomes. As informações podem ser encontradas nas tabelas
address e customer.

Exiba o nome e a quantidade de endereços dos clientes cadastrados. Ordene seus resultados por
nomes de forma decrescente. Exiba somente os clientes ativos. As informações podem ser encontradas
na tabela address e customer.

Monte uma query que exiba o nome, sobrenome e a média de valor (amount) paga aos funcionários
no ano de 2006. Use as tabelas payment e staff. Os resultados devem estar agrupados pelo nome e
sobrenome do funcionário.

Monte uma query que exiba o id do ator, nome, id do filme e titulo do filme, usando as tabelas actor,
film_actor e film. Dica: você precisará fazer mais de um JOIN na mesma query.

Até o momento, temos produzido resultados apenas quando temos valores correspondentes em ambas
as colunas de referência. Porém, o que devemos fazer quando possivelmente apenas uma das tabelas
possui um valor correspondente existente? É possível que você tenha que usar o LEFT JOIN ou RIGHT
JOIN nessas situações.

Como utilizar o LEFT JOIN e o RIGHT JOIN

Você precisa encontrar um conjunto de registros, mas não tem certeza se uma das colunas de referência
envolvidas possui ou não essa informação. Para que você encontre registros nessa situação, podemos
usar o LEFT JOIN ou RIGHT JOIN. Vamos entender melhor com o vídeo a seguir:

O conceito de JOIN pode levar um certo tempo para ser compreendido. Sendo assim, vá no seu ritmo,
reveja o conteúdo deste dia quantas vezes forem necessárias para compreender bem este conceito.
Pense em perguntas que você gostaria de responder sobre algum de seus bancos de dados que utilizem
dados de mais de uma tabela. Abra o Workbench e tente fazer uma query que as responda.

3 queries e 1 pergunta

Vamos visualizar a diferença entre os 3 joins já vistos até o momento. Rode e analise cada uma das 3
queries a seguir. Busque notar a diferença entre as colunas da direita e da esquerda e a quantidade de
dados retornados em cada query, como foi mostrado no vídeo. Gaste de 2 a 5 minutos aqui e depois
continue.

LEFT JOIN

SELECT

c.customer_id,

c.first_name,

c.last_name,

a.actor_id,

a.first_name,

a.last_name

FROM customer c

LEFT JOIN actor a

ON c.last_name = a.last_name
ORDER BY c.last_name;

RIGHT JOIN

SELECT

c.customer_id,

c.first_name,

c.last_name,

a.actor_id,

a.first_name,

a.last_name

FROM customer c

RIGHT JOIN actor a

ON c.last_name = a.last_name

ORDER BY c.last_name;

INNER JOIN

SELECT

c.customer_id,

c.first_name,

c.last_name,

a.actor_id,

a.first_name,

a.last_name

FROM customer c

INNER JOIN actor a

ON c.last_name = a.last_name
ORDER BY c.last_name;

Notando as diferenças

Depois de ter analisado as queries acima, note que de fato a única diferença entre os 3 joins é a questão
do foco. Vamos explorar essa ideia abaixo.

Quando utilizamos o LEFT JOIN, focamos na tabela da esquerda. São retornados todos os registros da
tabela esquerda e valores correspondentes da tabela da direita, caso existam. Valores que não possuem
correspondentes são exibidos como nulos.

Veja uma representação visual do LEFT JOIN abaixo:

LEFT JOIN. Fonte: Wikipedia

Veja um pouco mais sobre o LEFT JOIN no W3Schools e no MySQLTutorial.

Quando utilizamos o RIGHT JOIN, focamos na tabela da direita. São retornados todos os registros da
tabela direita e valores correspondentes da tabela da esquerda, caso existam. Valores que não possuem
correspondentes são exibidos como nulos.

Veja uma representação visual do RIGHT JOIN abaixo:

RIGHT JOIN. Fonte: Wikipedia

Você pode ver mais exemplos sobre RIGHT JOIN no W3Schools e no MySQLTutorial.

Finalmente, temos o INNER JOIN, que foca em trazer somente os registros que possuem valores
correspondentes em ambas tabelas.
Novamente, você pode ver uma representação visual do INNER JOIN abaixo:

INNER JOIN. Fonte: Wikipedia

Até o momento, temos usado mais de uma tabela para analisar dados e gerar informação. No entanto, a
informação a ser analisada pode estar concentrada em apenas uma tabela. Neste cenário, o SELF JOIN
pode ser usado para criar resultado relevantes.

O que é SELF JOIN e quando utilizá-lo

Há certos cenários nos quais faz sentido pesquisar e tirar alguma conclusão analisando apenas uma
única tabela. Os tipos de JOIN que você viu até agora precisam necessariamente que mais de uma tabela
seja incluída em uma query para que um resultado possa ser gerado. O SELF JOIN não possui esse
requisito. Vamos ver a seguir algumas das aplicações do SELF JOIN.

Como foi visto no vídeo acima, podemos fazer pesquisas e comparações dentro da própria tabela através
do SELF JOIN. Lembre-se dessa opção sempre que a informação que você precisa filtrar ou comparar
para encontrar algo estiver em uma única tabela.

Leia mais sobre SELF JOIN no W3Schools e no W3Resource.

Note que um SELF JOIN não é um tipo diferente de JOIN. É apenas um caso em que uma tabela faz join
consigo mesma. Você pode utilzar qualquer dos tipos de JOIN vistos ao realizar um SELF JOIN.

Para fixar estes conceitos, tente encontrar as seguintes informações:

Queremos saber os ids e custos de substituição dos filmes que possuem o mesmo custo de
substituição.

Exiba o titulo e a duração de empréstimo dos filmes que possuem a mesma duração. Exiba apenas os
filmes com a duração de empréstimo entre 2 a 4 dias.

Lembre-se de usar o SELF JOIN em situações em que as informações que estiver buscando estejam
armazenadas em apenas uma tabela.

A seguir, veremos como é possível combinar os resultados de uma query com outra por meio do UNION.

Como unir resultados com o UNION e o UNION ALL

Imagine que temos duas tabelas, morning_events e night_events, e que essas tabelas possuem os
nomes das pessoas que compareceram a esses dois tipos diferentes de eventos. Porém, queremos uma
lista agregada de todas as pessoas que estão cadastradas, independente do tipo de evento em que
compareceram.

Essa situação é um dos cenários que podem ser resolvidos através do UNION. O UNION nos permite unir
os registros de uma tabela com outra, desde que usemos a mesma quantidade de colunas. Vamos
explorar outras possibilidades no vídeo a seguir:

Como foi visto no vídeo, podemos utilizar este comando de duas maneiras: UNION e UNION ALL.

O UNION remove os dados duplicados, enquanto o UNION ALL os mantém. Observe que para usar o
comando corretamente, a mesma quantidade de colunas deve ser utilizada.

Vamos trabalhar agora com alguns desafios sobre o UNION:

Todos os funcionários foram promovidos a atores. Monte uma query que exiba a união da tabela staff
com a tabela actor, exibindo apenas o nome e o sobrenome. Seu resultado não deve excluir nenhum
funcionário ao unir as tabelas.

Monte uma query que una os resultados das tabelas customer e actor, exibindo os nomes que contém
a palavra "tracy" na tabela customer e os que contém "je" na tabela actor. Exiba apenas os resultados
únicos.

Monte uma query que exiba a união dos 5 últimos nomes da tabela actor, o primeiro nome da tabela
staff e 5 nomes a partir da 15ª posição da tabela customer. Não permita que dados repetidos sejam
exibidos. Ordene os resultados em ordem alfabética.
 Você quer exibir uma lista paginada com os nomes e sobrenomes de todos os clientes e atores do
banco de dados, em ordem alfabética. Considere que a paginação está sendo feita de 15 em 15
resultados e que você está na 4ª página. Monte uma query que simule esse cenário.

Hoje você teve o seu primeiro contato com o mundo dos JOINS e UNIONS. Por ser um tema extenso e
muito utilizado no dia a dia de desenvolvimento de software, é recomendado que você pratique o
máximo possível.

Revise e pratique os conceitos de UNION através destes exercícios.

Vamos fazer juntos!

Tempo sugerido para realização: 80 minutos

Vamos bater um papo sobre SQL? Hora da aula ao vivo! Vamos para o Slack, onde o link estará
disponível.

Exercícios

Tempo sugerido para realização: 80 minutos

Antes de começar: versionando seu código

Para versionar seu código, utilize o seu repositório de exercícios. 😉

Caso você ainda não tenha um, crie um repositório com o nome Trybe ou algo similar.

Abaixo você vai ver exemplos de como organizar cada exercício em uma branch, com arquivos e commits
específicos para cada exercício. Você deve seguir este padrão para realizar os exercícios a seguir.

Crie uma branch com o nome exercises/21.2 (bloco 21, dia 2)

$ git checkout -b exercises/21.2

Crie um diretório exercises e, dentro dele, um diretório 21_2. O caminho completo para o diretório a
partir da raiz do projeto deverá ser exercises/21_2.

$ mkdir -p exercises/21_2

$ cd exercises/21_2

$ pwd

<path_to_your_repo>/exercises/21_2

Crie um arquivo com um nome descritivo para cada exercício. Os arquivos devem estar dentro da pasta
exercises/21_2, mas lembre-se de fazer os commits a partir da pasta raiz do seu projeto!

$ git status

On branch exercises/21.2

Changes not staged for commit:

(use "git add <file>..." to update what will be committed)

(use "git checkout -- <file>..." to discard changes in working directory)

modified: exercise_1.html

Faça commits organizados durante o processo de resolução de cada um de seus exercícios. As

mensagens dos commits devem ser breves e explicativas.

$ git log

commit 100c5ca0d64e2b8649f48edf3be13588a77b8fa4 (HEAD -> exercises/21.2)

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 17:48:01 2019 -0300

Exercicio 2 - mudando o evento de click para mouseover, tirei o alert e coloquei pra quando clicar
aparecer uma imagem do lado direito da tela
commit c0701d91274c2ac8a29b9a7fbe4302accacf3c78

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 16:47:21 2019 -0300

Exercicio 2 - adicionando um alert, usando função e o evento click

commit 6835287c44e9ac9cdd459003a7a6b1b1a7700157

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 15:46:32 2019 -0300

Resolvendo o exercício 1 usando eventListener

Lembre-se que na primeira vez que você for enviar o código para o repositório remoto a branch
exercises/21.2 não vai existir lá.

Então você precisa configurar o remote utilizando a opção --set-upstream (ou -u, que é a forma
abreviada).

$ git push -u origin exercises/21.2

Lembre-se de enviar os commits para o repositório do GitHub de vez em sempre.

$ git push origin exercises/21.2

Quando terminar os exercícios, seus códigos devem estar todos commitados na branch exercises/21.2,
e disponíveis no repositório remoto do GitHub.

Pra finalizar, crie um Pull Request , adicione uma descrição bem bacana, e envie para a monitoria e/ou
colegas revisarem! 🤜🏼🤛🏼
Agora a prática

Exercício 1: Praticando INNER JOIN. Faça os exercícios deste link.

Exercício 2: Praticando OUTER JOIN. Faça os exercícios deste link.

Exercício 3: Siga os passos a seguir.

Acesse este link.

Considere a estrutura da imagem a seguir:

Baixe o script chamado 1_build_schema.sql. Copie seu conteúdo, cole-o em uma janela de query
dentro do MySQL Workbench e acrescente as seguintes linhas no início do código:

CREATE database IF NOT EXISTS praticando;

USE praticando;

Selecione todo o código e execute-o.

Agora que você restaurou o banco de dados praticando, faça os exercícios 1.10 a 1.14.

Exercício 4: Siga os passos a seguir.

Acesse este link.

Considere a estrutura da imagem a seguir:

 Baixe o script chamado 2_build_schema.sql. Copie seu conteúdo, cole-o em uma janela de query
dentro do MySQL Workbench e acrescente as seguintes linhas no início do código:

CREATE database IF NOT EXISTS praticando;

USE praticando;

Selecione todo o código e execute-o.

Agora que você restaurou o banco de dados praticando, faça os exercícios 2.10, 2.11, 2.12 2.14.

Exercício 5: Siga os passos a seguir.

Acesse este link.

Considere a estrutura da imagem a seguir:

Baixe o script chamado 3_build_schema.sql. Copie seu conteúdo, cole-o em uma janela de query
dentro do MySQL Workbench e acrescente as seguintes linhas no início do código:

CREATE database IF NOT EXISTS praticando;

USE praticando;

Selecione todo o código e execute-o.

Agora que você restaurou o banco de dados praticando, faça os exercícios 3.7 a 3.10.

Exercício 6: Siga os passos a seguir.

 Acesse este link.

Considere a estrutura da imagem a seguir:

Baixe o script chamado 4_build_schema.sql. Copie seu conteúdo, cole-o em uma janela de query
dentro do MySQL Workbench e acrescente as seguintes linhas no início do código:

CREATE database IF NOT EXISTS praticando;

USE praticando;

Selecione todo o código e execute-o.

Agora que você restaurou o banco de dados praticando, faça os exercícios 4.5 a 4.7.

Exercício 7:

Caso encontre exercícios sobre o NATURAL JOIN, consulte este link para aprender como utilizá-lo.

Para fazer os exercícios da página abaixo, restaure o back-up do banco de dados HR que está disponível
clicando neste link. Em seguida, siga estes passos:

Execute o conteúdo deste arquivo .sql em seu banco de dados local.

Acesse os exercícios deste link

Leia o enúnciado do exercício.

Monte uma query em seu banco local, que você acabou de restaurar, e veja se seu resultado resolve o
desafio.

Caso não consiga resolver os exercícios, consulte as respostas clicando em "Click me to see the
solution" na página do desafio.
Exercício 8:

Usando o banco de dados sakila, pratique o JOIN com os exercícios 6a a 6b deste link. As respostas
podem ser conferidas neste link.

Bônus

Exercício 9:

Para uma lista completa de exercícios, do básico ao avançado, siga as instruções abaixo acessando este
link. Siga os passos descritos nos exercícios 3, 4, 5 e 6 para criar e restaurar o banco de dados.

Recursos adicionais (opcional)

Como utilizar INNER JOIN, LEFT LEFT e RIGHT JOIN, por Dev Media
https://www.devmedia.com.br/clausulas-inner-join-left-join-e-right-join-no-sql-server/18930

Entenda mais sobre o INNER JOIN no MySQLTutorial e no W3Schools

https://www.mysqltutorial.org/mysql-inner-join.aspx
https://www.w3schools.com/sql/sql_join_inner.asp

Aprenda SQL JOINS na prática com o SQL Bolt https://sqlbolt.com/lesson/select_queries_with_joins

Explicação detalhada sobre UNION no Macoratti http://www.macoratti.net/13/05/sql_uni1.htm

UNION desconstruido com exemplos no SQLServerTutorial.net https://www.sqlservertutorial.net/sql-

server-basics/sql-server-union/

JOIN vs SUBQUERY Medium Gustavo Gois Cardoso https://medium.com/@gugoiscardoso/subquery-

vs-inner-join-c1e62c4d7bf4

Próximo
 Parte
O que vamos aprender?

Olá, bem vindo de volta! Hoje veremos como montar uma query dentro de outra, através de uma
SUBQUERY. Na sequência, vamos verificar se o resultado de uma query existe ou não através do EXISTS.
Por fim, veremos como criar blocos de código reutilizáveis, através da criação de STORED PROCEDURES e
STORED FUNCTIONS.

Você será capaz de:

Utilizar SUBQUERIES

Criar queries mais eficientes através do EXISTS

Montar blocos de código SQL reutilizáveis com STORED PROCEDURES e STORED FUNCTIONS

Por que isso é importante?

Os conceitos de EXISTS e SUBQUERY são altamente importantes para criar queries cada vez mais
eficientes e dinâmicas.

As STORED PROCEDURES e STORED FUNCTIONS podem te ajudar a seguir um conceito de programação

chamado DRY, que preza pela redução de código repetido, quando possível.

Isso é viabilizado pelo fato de que esses comandos te permitirem criar blocos de código SQL reutilizáveis,
que podem se comunicar com outros frameworks e linguagens de programação, como NodeJS, C#,
Python, Java e PHP, entre outras.

Conteúdos

Tempo sugerido para realização: 120 minutos

Como utilizar uma SUBQUERY

Caso não tenha percebido, estamos usando subqueries há algumas aulas.

Uma SUBQUERY é uma query aninhada que é avaliada dentro de um par de parênteses. Ela pode conter
expressões simples, como adições e subtrações, mas não se limita a apenas isso, uma vez que podemos
utilizar praticamente todos os comandos já vistos até o momento dentro de uma SUBQUERY.

Algo a se lembrar é que a subquery não é a única maneira de encontrar resultados de tabelas
relacionadas. Quando se trata de SQL, os JOINs podem ser usados para encontrar os mesmos resultados.

É recomendado tomar a decisão sobre qual opção utilizar (subquery ou JOIN) baseando-se na
performance da sua query.

Diferentes maneiras de utilizar uma SUBQUERY

Usando uma SUBQUERY como fonte de dados para o FROM.

SELECT f.title, f.rating

FROM (

SELECT *

FROM sakila.film

WHERE rating = 'R'

) AS f;

Resultado da subquery usada no `FROM`

 Preenchendo uma coluna de um SELECT por meio de uma SUBQUERY.

SELECT

address,

district,

SELECT city

FROM sakila.city

WHERE city.city_id = sakila.address.city_id

) AS city

FROM sakila.address;

Resultado da subquery como uma coluna do `SELECT`

Filtrando resultados com WHERE usando como base os dados retornados de uma SUBQUERY.

SELECT address, district

FROM sakila.address

WHERE city_id in (

SELECT city_id

FROM sakila.city

WHERE city in ('Sasebo', 'San Bernardino', 'Athenai', 'Myingyan')

);

Resultado da subquery com o `WHERE`

Usando uma tabela externa, de fora da SUBQUERY, dentro dela.

SELECT

first_name,

SELECT address

FROM sakila.address

WHERE address.address_id = tabela_externa.address_id

) AS address

FROM sakila.customer AS tabela_externa;

Resultado da subquery usando tabela externa

SUBQUERY ou JOIN

Talvez você esteja se perguntando se seria possível resolver as queries anteriores através de um JOIN. De
fato podemos, como é exemplificado a seguir.

Usando SUBQUERY

SELECT

first_name,

SELECT address

FROM sakila.address

WHERE address.address_id = tabela_externa.address_id

) AS address

FROM sakila.customer AS tabela_externa;

Usando INNER JOIN

SELECT c.first_name, ad.address

FROM sakila.customer c

INNER JOIN sakila.address ad ON c.address_id = ad.address_id;

Sabendo disso, como decidir entre as duas abordagens? Decida qual usar através de testes de
performance e, em seguida, por afinidade.

Uma maneira simples de mensurar a performance e decidir sobre qual abordagem utilizar (Execution
Plan)
Diferente da maioria dos problemas que as pessoas desenvolvedoras resolvem, é possível decidir por
queries melhores que outras através da medição do seu custo de execução.

Existem diversas maneiras para mensurar a performance e otimizar queries no MySQL Server. Temos
carreiras inteiras baseadas nisso. Nesta aula, iremos abordar apenas uma delas: o execution plan.

Ele mensura o custo de uma query e exibe o tipo de scan efetuado em cada tabela incluída na query e
seu custo total. Seu uso na prática pode ser visto da seguinte forma:

Tomando como exemplo as duas últimas queries desta página, crie dois novos arquivos SQL no seu
MySQl Workbench. Em um deles, cole a query que utilizamos a solução que se utilizou de SUBQUERY e,
no outro, a que se utilizou de INNER JOIN.

Em seguida, execute uma das queries e depois clique em Execution Plan, como na imagem abaixo, e
observe o valor de "Query Cost". Quanto menor o valor, em comparação com outra versão da query,
melhor a performance. Assim você pode simplesmente escolher a query que tem o menor custo.

Como acessar o execution plan

Execute os comandos acima e verifique o custo de cada query. Ficou claro que, nesse caso específico, a
SUBQUERY tem uma performance melhor que o JOIN, em razão de ter o custo de query mais baixo.

Criando queries mais dinâmicas através do EXISTS

Antes de iniciar essa seção:

Os bancos de dados utilizados no vídeo podem ser acessados nos links a seguir.

Banco de dados praticando: link.

Banco de dados hotel: link.

Para usá-los em seu computador, copie o código disponilizado em cada link e restaure cada um
utilizando o MySQL Workbench, selecionando todo código e clicando no botão de raio para executar o
script de restauração.

Restaurando um banco de dados a partir de um script

Vamos entender melhor como utilizar o EXISTS no vídeo a seguir:

Após ter assistido à explicação acima, é bom enfatizar aqui que o intuito principal do EXISTS é:

Retornar os registros da tabela A que possuem um relacionamento com os registros da tabela B.

Para mais exemplos sobre como utilizar o EXISTS, recomendamos a seguinte leitura.

Vamos Praticar um pouco mais sobre o exists

Use o banco de dados hotel para realizar os desafios a seguir:

Usando o EXISTS na tabela books_lent e books, exiba o id e título dos livros que ainda não foram
emprestados.

Usando o EXISTS na tabela books_lent e books, exiba o id e título dos livros estão atualmente
emprestados e que contem a palavra "lost" no título.

Usando a tabela carsales e customers, exiba apenas o nome dos clientes que ainda não compraram
um carro.

Usando o comando EXISTS em conjunto com JOIN e as tabelas cars, customers e carsales, exiba o
nome do cliente e o modelo do carro de todos os clientes que fizeram compras de carros.
Montando blocos de código SQL reutilizáveis com stored procedures e stored functions

Temos duas maneiras de armazenar blocos de códigos (queries) para serem usados posteriormente no
MySQL:

Stored procedure;

Stored function.

A palavra stored significa armazenado. Como o próprio nome já dá uma dica, o código fica armazenado
no servidor de banco de dados para que possa ser utilizado sem a necessidade de reescrever uma
funcionalidade.

Dica sobre como nomear suas procedures e functions

Para tornar a leitura do seu código mais fácil e sua manutenção mais simples, siga o seguinte padrão ao
nomear suas procedures e functions:

-- Verbo + Resultado

ObterTotalDeVendas

ExibirRankMaximo

ObterClienteMaisAtivo

CalcularNivelEngajamento

MontarNomeCompleto

Stored Procedures

Caso queira uma breve introdução, sugerimos assitir o vídeo abaixo. Caso não goste desse tipo de mídia
e/ou queira uma explicação mais detalhada, prossiga com a leitura.

Pontos fortes quanto ao uso de Stored Procedures

 Centralizar o código SQL em um servidor de banco de dados, o que possibilita que a manutenção das
queries seja feita diretamente no servidor. Assim, mudanças são refletidas imediatamente em aplicações
que utilizam o banco de dados sem haver a necessidade de refazer o deploy;

Evita a necessidade de reescrever algo específico para cada linguagem, plataforma ou framework;

Propaga mudanças feitas em uma stored procedure imediatamente para todas as aplicações que a
usam, reduzindo a necessidade de refatorar o código em todos os ambientes que utilizam o banco de
dados.

Pontos fracos quanto ao uso de Stored Procedures

Viola um dos princípios de separation of concerns, que diz que sua regra de negócio, dados e
apresentação devem estar separados e desacoplados, uma vez que stored procedures podem conter
regras de negócio e ficam armazendas no banco de dados;

Debugar este código armazenado é mais difícil;

Não há como versionar o código de uma stored procedure tão facilmente.

Elementos das Stored Procedures:

1 - Delimiter

A palavra-chave DELIMITER é usada para definir qual símbolo representa o final da declaração da sua
procedure. Aqui estamos usando $$, porem é permitido usar outros símbolos.

O DELIMITER precisa ser usado para que o MySQL não interprete o primeiro ponto e vírgula encontrado
como o final da declaração da sua procedure.

2 - Variáveis

O MySQL possui a funcionalidade de criar e usar variáveis, assim como em outras linguagens de
programação. Essas variáveis também podem ser usadas em procedures.
Para criar variáveis e atribuir valores a elas, faça o seguinte:

SET @my_school = 'BeTrybe';

SELECT @my_school;

Resultado da query `SELECT @my_school`

3 - Tipos de dados

Existem vários tipos de dados no MySQL. Eles serão vistos mais a fundo na próxima aula. Contudo, é bom
que você corra o olho no assunto para ter uma noção básica dos tipos de dados existentes antes de
continuar aqui.

Estrutura padrão de uma stored procedure

USE banco_de_dados; -- obrigatório para criar a procedure no banco correto

DELIMITER $$ -- definindo delimitador

CREATE PROCEDURE nome_da_procedure(@parametro1, @parametro2, ..., @parametroN) --

parâmetros

BEGIN -- delimitando o início do código SQL

END $$ -- delimitando o final do código SQL

DELIMITER ; -- muda o delimitador de volta para ; - o espaço entre DELIMITER e o ';' é necessário

Procedure sem parâmetros:

Normalmente é utilizada para realizar queries mais simples.

Exemplo: Aqui estamos apenas executando uma busca na tabela actor e exibindo os resultados.

USE sakila;

DELIMITER $$

CREATE PROCEDURE ShowAllActors()

BEGIN

SELECT * FROM sakila.actor;

END $$

DELIMITER ;

-- Como usar:

CALL ShowAllActors();

Resultado da procedure ShowAllActors

Sua primeira stored Procedure

Vamos criar nossas primeiras stored procedures. Temos os seguintes tipos:

Procedure sem parâmetros;

Procedure com parâmetros de entrada (IN);

Procedure com parâmetros de saída (OUT);

Procedure com parâmetros de entrada e saída (IN-OUT).

Procedure com parâmetros de entrada (IN):

Para criar procedures com funcionalidades mais elaboradas, podemos passar parâmetros de entrada. Ao
definir um parâmetro do tipo IN, podemos usá-lo e modificá-lo dentro da nossa procedure.

Exemplo: Foi criada uma procedure que recebe como parâmetro uma sílaba (syllable) e busca na tabela
actor todos atores quem contem aquela sílaba no nome.

USE sakila;

DELIMITER $$

CREATE PROCEDURE ShowActorsWithSyllable(IN syllable VARCHAR(100))

BEGIN

SELECT *

FROM sakila.actor

WHERE first_name LIKE CONCAT('%', syllable, '%');

END $$

DELIMITER ;

-- Como usar:

CALL ShowActorsWithSyllable('lope');

Resultado da procedure ShowActorsWithSyllable

Procedure com parâmetros de saida (OUT):

O parâmetro OUT é útil quando você precisa que algo seja avaliado ou encontrado dentro de uma query
e te retorne esse valor para que algo adicional possa ser feito com ele.

Exemplo: Estamos recebendo aqui o título de um filme como valor de entrada e depois buscando dentro
da procedure a duração média de um empréstimo daquele filme. Feito isso, ele é inserido em uma
variável que pode ser usada posteriormente.

USE sakila;

DELIMITER $$

CREATE PROCEDURE ShowAverageRentalDurationOfMovie(

IN film_name VARCHAR(300),

OUT media_aluguel_em_dias DOUBLE

BEGIN

SELECT AVG(rental_duration) INTO media_aluguel_em_dias

FROM sakila.film

WHERE title = film_name;

END $$

DELIMITER ;

-- Como usar:

CALL ShowAverageRentalDurationOfMovie('ACADEMY DINOSAUR', @media_de_dias);

SELECT @media_de_dias;

Resultado da procedure ShowAverageRentalDurationOfMovie

Procedure com parâmetros de entrada-saida (IN-OUT):

O IN-OUT deve ser usado quando é necessário que um parâmetro possa ser modificado tanto antes
como durante a execução de uma procedure.

Exemplo: Estamos gerando um novo nome para um filme, usando como base a variável film_name, que
deve ser criada e passada como parâmetro para a procedure. O parâmetro sofrerá alterações dentro da
procedure, podendo ser usado posteriormente com o novo nome.

USE sakila;

DELIMITER $$

CREATE PROCEDURE NameGenerator(INOUT film_name VARCHAR(300))

BEGIN

SELECT CONCAT('ULTRA ', film_name, ' THE BEST MOVIE OF THE CENTURY')

INTO film_name;

END $$

DELIMITER ;

-- Como usar:

SELECT 'ACE GOLDFINGER' INTO @movie_title;

CALL NameGenerator(@movie_title);

SELECT @movie_title;

Resultado da procedure ShowAverageRentalDurationOfMovie

Após ter visto essas 4 maneiras de como montar uma procedure, você deve ter uma noção melhor de
como elas podem te ajudar a agilizar diversos aspectos de suas consultas a um banco de dados.

Para consolidar esse conhecimento, vamos tentar resolver algumas questões.

Desafios stored procedure

Para todos os desafios abaixo, certifique-se de que a função possa ser chamada e o resultado dela seja
usado corretamente. Utilize o banco de dados sakila.

Monte uma procedure que exiba os 10 atores mais populares, baseado em sua quantidade de filmes.
Essa procedure não deve receber parâmetros de entrada ou saída e, quando chamada, deve exibir o id
do ator ou atriz e a quantidade de filmes atuados.

Monte uma procedure que receba como parâmetro de entrada o nome da categoria desejada em uma
string e que exiba o id do filme, seu titulo, o id de sua categoria e o nome da categoria selecionada. Use
as tabelas film, film_category e category para montar essa procedure.

Monte uma procedure que receba o email de um cliente como parâmetro de entrada e diga se o
cliente está ou não ativo, através de um parâmetro de saída.

Stored Functions

Na área de programação, temos uma boa prática chamada DRY (Don't Repeat Yourself) que, em resumo,
sugere que você não se repita ou reescreva o mesmo código várias vezes.

Nesse ponto, temos uma das principais ferramentas para combater este problema no SQL: as stored
functions.

Através delas, podemos encapsular nossas queries usadas mais frequentemente dentro de um bloco de
código nomeado e parametrizável.

Caso queira uma breve introdução, sugerimos assitir o vídeo abaixo. Caso não goste desse tipo de mídia
e/ou queira uma explicação mais detalhada, prossiga com a leitura.

Sua primeira stored function

Stored functions podem ser executadas com o comando SELECT. Ao criá-las, temos que definir o tipo de
retorno que sua função possui.

Tipo de retorno comuns:

DETERMINISTIC - Sempre retorna o mesmo valor ao receber os mesmos dados de entrada;

READS SQL DATA - Indica para o MySQL que sua função somente lerá dados.

Em muitas situações, sua function estará apenas lendo e retornando dados. Nesses casos, a opção
READS SQL DATA deve ser usada. No entanto, sempre avalie o tipo mais adequado a sua função.

Estrutura padrão de uma stored function

USE banco_de_dados; -- obrigatório para criar a função no banco correto

DELIMITER $$

CREATE FUNCTION nome_da_function(parametro1, parametro2, ..., parametroN)

RETURNS tipo_de_dado tipo_de_retorno

BEGIN

query_sql

RETURN resultado_a_ser_retornado;

END $$

DELIMITER ;
Exemplo: Uma stored function que exibe a quantidade de filmes que um determinado ator ou atriz
atuou:

USE sakila;

DELIMITER $$

CREATE FUNCTION MoviesWithActor(actor_id int)

RETURNS INT READS SQL DATA

BEGIN

DECLARE movie_total INT;

SELECT COUNT(*)

FROM sakila.film_actor

WHERE sakila.film_actor.actor_id = actor_id INTO movie_total;

RETURN movie_total;

END $$

DELIMITER ;

-- Como usar:

SELECT MoviesWithActor(1);

Resultado da stored function MoviesWithActor

Exemplo: Uma stored function que exibe o nome completo de um ator ou de uma atriz, dado seu id
como parâmetro:
USE sakila;

DELIMITER $$

CREATE FUNCTION GetFullName(id INT)

RETURNS VARCHAR(200) READS SQL DATA

BEGIN

DECLARE full_name VARCHAR(200);

SELECT concat(first_name, ' ', last_name)

FROM sakila.actor

WHERE actor_id = id

LIMIT 1

INTO full_name ;

RETURN full_name;

END $$

DELIMITER ;

SELECT GetFullName(51);

Resultado da function GetFullName

Assim como no caso das fuções de agregação AVG, MIN, MAX e SUM, entre outras, as stored functions
são extremamente úteis e devem ser criadas sempre que percebermos que o mesmo tipo de código está
sendo repetido em vários lugares diferentes.

Isso ajuda a reduzir a quantidade de duplicação de código em seu servidor de banco de dados e deixa
seu código mais legível e limpo, além de contribuir para uma melhor experiência para outras pessoas
desenvolvedoras que possam ter que dar manutenção no seu código.

Agora você vai desenvolver algumas functions

 Utilizando a tabela sakila.payment, monte uma function que retorna a quantidade total de
pagamentos feitos até o momento por um determinado customer_id.

Crie uma function que, dado o parâmetro de entrada inventory_id, retorna o nome do filme vinculado
ao registro de inventário com esse id.

Crie uma function que receba uma determinada categoria de filme em formato de texto (ex: 'Action',
'Horror') e retorna a quantidade total de filmes registrados nessa categoria.

Stored Functions VS Store Procedures

Vamos comparar no gráfico a seguir as principais diferenças entre functions e procedures.

Functions VS Procedures

ou seja:

Stored Procedures podem ser chamadas através do comando CALL e o retorno de um valor é opcional;

Já as Stored Functions são executadas com o comando SELECT e obrigatoriamente retornam algum
valor.

Ainda restam dúvidas com relação à diferença das duas na prática? Que tal dar uma lida na resposta
mais votada aqui?

Vamos fazer juntos!

Tempo sugerido para realização: 80 minutos

Vamos bater um papo sobre SQL?

Hora da aula ao vivo! Vamos para o Slack, onde o link estará disponível.
Exercícios

Tempo sugerido para realização: 40 minutos

Antes de começar: versionando seu código

Para versionar seu código, utilize o seu repositório de exercícios. 😉

Caso você ainda não tenha um, crie um repositório com o nome Trybe ou algo similar.

Abaixo você vai ver exemplos de como organizar cada exercício em uma branch, com arquivos e commits
específicos para cada exercício. Você deve seguir este padrão para realizar os exercícios a seguir.

Crie uma branch com o nome exercises/21.3 (bloco 21, dia 3)

$ git checkout -b exercises/21.3

Crie um diretório exercises e, dentro dele, um diretório 21_3. O caminho completo para o diretório a
partir da raiz do projeto deverá ser exercises/21_3.

$ mkdir -p exercises/21_3

$ cd exercises/21_3

$ pwd

<path_to_your_repo>/exercises/21_3

Crie um arquivo com um nome descritivo para cada exercício. Os arquivos devem estar dentro da pasta
exercises/21_3, mas lembre-se de fazer os commits a partir da pasta raiz do seu projeto!

$ git status

On branch exercises/21.3
Changes not staged for commit:

(use "git add <file>..." to update what will be committed)

(use "git checkout -- <file>..." to discard changes in working directory)

modified: exercise_1.html

Faça commits organizados durante o processo de resolução de cada um de seus exercícios. As

mensagens dos commits devem ser breves e explicativas.

$ git log

commit 100c5ca0d64e2b8649f48edf3be13588a77b8fa4 (HEAD -> exercises/21.3)

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 17:48:01 2019 -0300

Exercicio 2 - mudando o evento de click para mouseover, tirei o alert e coloquei pra quando clicar
aparecer uma imagem do lado direito da tela

commit c0701d91274c2ac8a29b9a7fbe4302accacf3c78

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 16:47:21 2019 -0300

Exercicio 2 - adicionando um alert, usando função e o evento click

commit 6835287c44e9ac9cdd459003a7a6b1b1a7700157

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 15:46:32 2019 -0300

Resolvendo o exercício 1 usando eventListener

Lembre-se que na primeira vez que você for enviar o código para o repositório remoto a branch
exercises/21.3 não vai existir lá.

Então você precisa configurar o remote utilizando a opção --set-upstream (ou -u, que é a forma
abreviada).

$ git push -u origin exercises/21.3

Lembre-se de enviar os commits para o repositório do GitHub de vez em sempre.

$ git push origin exercises/21.3

Quando terminar os exercícios, seus códigos devem estar todos commitados na branch exercises/21.3,
e disponíveis no repositório remoto do GitHub.

Pra finalizar, crie um Pull Request , adicione uma descrição bem bacana, e envie para a monitoria e/ou
colegas revisarem! 🤜🏼🤛🏼

Agora a prática

Antes de começar, para que você possa fazer os exercícios 1, 2 e 3, veja o passo a passo abaixo.

Considerando a estrutura da imagem a seguir:

Baixe o script chamado x_build_schema.sql, onde x é o número do exercício que você está acessando no
momento, copie seu conteúdo, cole em uma janela de query dentro do MySQL Workbench e acrescente
as seguintes linhas no início do código. Em seguida, selecione todo o código e execute-o.

CREATE DATABASE IF NOT EXISTS betrybe;

USE betrybe;
O que o código acima está fazendo? A primeira linha cria um banco novo chamado betrybe, caso ele
ainda não exista. Na sequência, o comando USE betrybe determina que todas as tabelas e comandos
que forem executadas a seguir devem usar o banco de dados que acabou de ser criado.

Apesar se ser opcional, caso você não inclua essas duas linhas, todas as tabelas seram inseridas no banco
de dados que estiver ativo no momento, resultando em tabelas soltas em lugares inesperados.

Ou seja, sua primeira query deve ficar da seguinte maneira:

-- LINK: https://en.wikibooks.org/wiki/SQL_Exercises/The_computer_store

CREATE DATABASE IF NOT EXISTS betrybe; -- não esqueça de inserir esta linha

USE betrybe; -- não esqueça de inserir esta linha também

CREATE TABLE Manufacturers (

Code INTEGER,

Name VARCHAR(255) NOT NULL,

PRIMARY KEY (Code)

);

-- código abreviado para melhor leitura

Agora que você já executou o passo a passo, vamos focar em revisar os conceitos passados até o
momento, através dos seguintes desafios:

Desafios de SQL - Parte 1 https://github.com/XD-DENG/SQL-exercise/tree/master/SQL_exercise_01

Desafios de SQL - Parte 2 https://github.com/XD-DENG/SQL-exercise/tree/master/SQL_exercise_02

Desafios de SQL - Parte 3 https://github.com/XD-DENG/SQL-exercise/tree/master/SQL_exercise_03

 Desafios Sakila:

Acesse as perguntas aqui

https://gist.github.com/Jhonatan-de-Souza/72e0e526f536c3c480ad21ed3ad107c6

Acesse as respostas aqui

https://github.com/joelsotelods/sakila-db-queries/blob/master/README.md

Recursos adicionais(Opcional)

Diferenças entre JOIN e SUBQUERY https://www.essentialsql.com/what-is-the-difference-between-a-

join-and-subquery

Como utilizar subqueries https://qhmit.com/mysql/examples/mysql_subquery.cfm

Como utilizar Stored Procedures https://qhmit.com/mysql/tutorial/mysql_stored_procedures.cfm

Tutorial sobre Stored Procedures do MySQL Tutorial https://www.mysqltutorial.org/getting-started-

with-mysql-stored-procedures.aspx

Vantagens e desvantagens das Stored Procedures https://www.devmedia.com.br/stored-procedures-

no-mysql/29030

Próximo

O que vamos fazer?

Aeee!!! Chegamos ao nosso segundo checkpoint, parabéns! Cada passo que você dá no seu aprendizado
te deixa cada vez mais próximo de um futuro melhor.

Nesse projeto, você vai colocar em prática os novos conceitos de SQL que foram aprendidos ao longo do
bloco 21, o que será feito em um novo banco de dados, para que você possa fixar ainda mais o
conteúdo. Então vamos lá 😀

🚧 New database has been found 🚧

Para aproveitar todo esse conhecimento que foi passado para você nos últimos dias, vamos trabalhar em
uma nova base de dados, da w3shools.

Talvez você já tenha trabalhado ou praticado neste site. Caso não tenha, fique tranquilo que logo terá a
oportunidade.

Pratique e leve o tempo que for necessário para realmente internalizar os comandos e dicas que foram
passadas até o momento.

O que você viu até aqui já cobre uma grande parte dos comandos que profissionais da área usam no dia
a dia. São também comandos comuns em entrevistas de emprego.

Então vamos com tudo para cima deste projeto!

Por que isso é importante?

Nesses últimos dias, o foco foi te passar o conhecimento necessário para que você saia do nível básico
no mundo do SQL e comece a entrar em um patamar em que, ao dominar estes conhecimentos, esteja
apto para criar soluções que atendam aos requisitos das muitas oportunidades disponíveis no mercado.

<strong>(SPOILER: veremos na próxima seção)</strong>

Para fechar o pacote conhecimento SQL, avançaremos ainda mais no próximo bloco, onde você vai
aprender como criar um banco de dados do 0.

Especificação

Tempo sugerido para realização: 1 dia

O que vamos avaliar?

 As queries que você desenvolver devem retornar exatamente a quantidade de colunas e registros
esperados, dentro do que foi pedido.

Organização do seu código. Deixe sempre as palavras-chave em CAIXA ALTA e os nomes de tabelas e
colunas em caixa baixa.

O que devo desenvolver?

Você passará pelos seguintes desafios, em que trabalhará habilidades diferentes:

Controle de fluxo com condicionais

Operações matemáticas

Lidando com datas

Manipulação de strings

Agrupamento de dados

Filtragem de dados

JOINS & UNIONS

Subqueries

Stored routines

Leia o arquivo README.md do projeto com atenção para uma explicação detalhada de como
desenvolver e entregar seu projeto.

Entregáveis

Para entregar o seu projeto, você deverá criar um Pull Request para um repositório no GitHub. Consulte
o canal do Slack da turma para obter o endereço do repositório.

Este Pull Request deverá conter a implementação das suas queries SQL, como especificado no
README.md do projeto.

Fique atento e siga as instruções no README.md do repositório! 🥺

Qualquer dúvida procure a monitoria.

Lembre-se que você pode consultar nosso conteúdo sobre Git & GitHub sempre que quiser!

Proximo

Nayane Gomes Agaipos

Gabaritos

Agenda

Aulas ao Vivo

Trybe Talks

Glossário

Logout

avatar image

TRYBE

Transformando ideias em um modelo de banco de dados

Transformando ideias em um modelo de banco de dados

O que vamos aprender?

Por que isso é importante?

Conteúdos

Vamos fazer juntos!

Exercícios
 Recursos adicionais (opcional)

Próximo

O que vamos aprender?

Hoje você estará focado em aprender da forma mais sucinta possível todo o processo de como modelar
um banco de dados. Dentro desse processo de modelagem, vamos abordar como idealizar uma
estrutura ideal, tendo em mente um problema que precisa ser resolvido. Será ensinado ainda como
identificar entidades, como montar um diagrama de entidade-relacionamento e como produzir uma
estrutura adequada a partir disso.

Você será capaz de:

Modelar um banco de dados;

Identificar entidades, atributos e relacionamentos;

Construir um diagrama entidade-relacionamento (diagrama ER);

Criar um banco de dados;

Criar e modelar tabelas com base em um diagrama ER.

Por que isso é importante?

A frequência com a qual você interage com um banco de dados está, em muitas das vezes, ligada
diretamente com a sua área de atuação. Entretanto, de que maneira as principais áreas de atuação no
mercado hoje estão ligadas com o conhecimento de banco de dados?

Desenvolvimento de Software - Onde o trabalho de criação de banco de dados e tabelas é feito com
mais frequência, nos momentos iniciais de um novo projeto. Contudo, durante o processo de
desenvolvimento, é natural estar sempre atualizando sistemas e, consequentemente, criando tabelas
para se adequar a novas funcionalidades. Em cargos como esse, o seu foco normalmente estará mais em
criar queries para realizar consultas e gerar relatórios e menos na porção de criação de tabelas e bancos
de dados;

DBA ou Database Administrator - Nessa profissão você estará trabalhando muito mais focado em
todos os aspectos que englobam a criação e manutenção de uma ou mais instâncias de bancos de
dados, sendo comum atuar com diferentes servidores, como SQL Server, PostgresSQL, MySQL, SQLite,
entre outros. Esse profissional deve possuir um conhecimento mais profundo sobre as limitações e
diferenças entre servidores, sintaxe, gerenciamento de memória, instalação de servidores, otimização de
queries e outros aspectos relacionados;

Data Scientist - São profissionais que atuam no campo de Data Science, e seu foco está centrado
principalmente em análise de dados e na capacidade de montar queries de grande complexidade, com o
intuito de extrair algo útil de dentro de uma quantidade enorme de dados, a fim de ser usado para
algum campo de estudo;

Algo comum entre todas essas profissões é a necessidade de saber transformar ideias, problemas ou
situações em um banco de dados.

Portanto, serão providas as ferramentas e o conhecimento necessários para que você possa dar o passo
inicial e, mais tarde, escolher qual área se adequa mais ao seu perfil.

Vamos lá!

Conteúdos

Tempo sugerido para realização: 120 minutos

Como transformar uma ideia em banco de dados?

Uma ideia que eventualmente será transformada em um banco de dados começa com uma história ou
problema a ser resolvido. É isso que será coberto hoje: um cenário fictício que precisa ser resolvido e
como ir da idealização para a sua solução.

O problema - Catálogo de Álbuns

Suponha que seja necessário criar um banco de dados para armazenar informações sobre um catálogo
de álbuns musicais. As informações a serem armazenadas sobre cada álbum são:
 Título;

Preço;

Estilo Musical;

Canções.

Cada álbum também terá um artista, e cada artista pode produzir vários álbuns. As canções devem ter
título e duração (em segundos).

Database Design - Como modelar um banco de dados

Existem alguns passos a serem seguidos durante a modelagem e criação de um banco de dados. Um
fluxo bastante comum nesse processo consiste em:

Identificar as entidades, atributos e relacionamentos com base na descrição do problema;

Construir um diagrama entidade-relacionamento para representar as entidades encontradas no passo

1;

Criar um banco de dados para conter suas tabelas;

Criar e modelar tabelas tendo o diagrama do passo 2 como base.

A seguir você verá como fazer cada um desses passos.

1) Identificando entidades, atributos e relacionamentos

Primeiramente você deve identificar as entidades, atributos e relacionamentos com base na descrição do
problema. Porém, antes disso é necessário entender o significado de cada um deles.

Entidades:

São uma representação de algo do mundo real dentro do banco de dados. Elas normalmente
englobam toda uma ideia e são armazenadas em formato de tabelas em um banco de dados.

Antes de expandir o código a seguir: Volte à descrição do problema acima e busque identificar quais
objetos devem se tornar entidades. Depois expanda o código abaixo para verificar.

Atributos:

Os atributos são tudo aquilo que pode ser usado para descrever algo. Por exemplo, uma entidade
pessoa pode ter nome, altura, peso e idade.

Antes de expandir o código a seguir: Considerando a história anterior sobre um catálogo de álbuns
musicais, tente deduzir quais propriedades descrevem cada uma das entidades encontradas
anteriormente.

Relacionamentos:

Os relacionamentos servem para representar como uma entidade deve estar ligada com outra(s) no
banco de dados. Há três tipos de relacionamentos possíveis em um banco de dados, que são:

Relacionamento Um para Um (1..1):

Nesse tipo de relacionamento, uma linha da Tabela A deve possuir apenas uma linha
correspondente na Tabela B e vice-versa. Veja o exemplo abaixo:

Exemplo de relacionamento um para um

 Apesar de ser possível inserir essas informações em apenas uma tabela, esse tipo de
relacionamento é usado normalmente quando se quer dividir as informações de uma tabela maior em
tabelas menores, evitando que as tabelas tenham dezenas de colunas.

Relacionamento Um para Muitos ou Muitos para Um (1..N):

Esse é um dos tipos mais comuns de relacionamento. Em cenários assim, uma linha na Tabela A
pode ter várias linhas correspondentes na Tabela B, mas uma linha da Tabela B só pode possuir uma
linha correspondente na Tabela A. Veja o exemplo abaixo:

Exemplo de relacionamento um para muitos ou muitos para um

Nesse exemplo, uma categoria pode estar ligada a vários livros, embora um livro deva possuir
apenas uma categoria.

Relacionamento Muitos para Muitos (N..N):

O relacionamento muitos para muitos acontece quando uma linha na Tabela A pode possuir muitas
linhas correspondentes na Tabela B e vice-versa. Veja o exemplo abaixo:

Exemplo de relacionamento muitos para muitos

Esse tipo de relacionamento pode ser visto também como dois relacionamentos um para muitos
ligados por uma tabela intermediária, como é o caso da tabela filme_ator. Pode-se chamar essa tabela
intermediária de tabela de junção. Ela é usada para guardar informações de como as tabelas se
relacionam entre si.

Desta maneira, quando se quer demonstrar que um filme pode possuir vários atores e também que
os atores podem atuar em vários filmes, surge a necessidade de um relacionamento muitos para muitos.

Antes de expandir o código a seguir: Volte à estrutura de tabelas do Catálogo de Álbuns e tente
identificar quais tipos de relacionamentos existem entre as tabelas. Escreva-os em algum lugar e depois
expanda abaixo para ver os relacionamentos. Praticar essa habilidade é crucial.
 `Ver Relacionamentos`

Os relacionamentos identificados foram:

2) Construindo um diagrama entidade-relacionamento

No segundo passo, será construído um diagrama entidade-relacionamento para representar as entidades

encontradas no passo 1.

Existem diversas ferramentas para modelar os relacionamentos em um banco de dados. Hoje será usada
a draw.io para criar os modelos. Você pode aprender como utilizar essa ferramenta assistindo a este
vídeo.

Agora é preciso montar um diagrama de relacionamento básico que demonstra como uma entidade é
relacionada com a outra, usando o modelo EntidadeA + verbo + EntidadeB.

Considerando as entidades Álbum, Artista, Estilo Musical e Canção, foi construído o seguinte diagrama:

Relacionamento entre as entidades `Álbum`, `Artista`, `Estilo Musical` e `Canção`

O que você deve fazer quando estiver construindo seu próprio banco de dados é entender quantas vezes
uma entidade pode se relacionar com uma outra, para, a partir disso, você poder criar esse primeiro
diagrama, como o do exemplo acima, que mostra como as entidades estão relacionadas entre si.

Montando um diagrama mais detalhado

Para diagramas ER mais detalhados, deve-se incluir o nome das tabelas, suas chaves primárias e
estrangeiras, suas colunas e seus relacionamentos.

Curiosidade: Por questão de convenções e boas práticas na criação de tabelas, não serão usados acentos
ou espaços entre os nomes das tabelas.

Lembre-se: Existem várias maneiras de se modelar um banco de dados. Então, caso pense diferente do
modelo abaixo, entenda que existem diversas formas de se resolver um mesmo problema.

Relacionamento detalhado entre as tabelas `Artista`, `Album`, `EstiloMusical` e `Cancao`

Relacionamentos presentes entre as tabelas acima:

Tabelas Artista e Album:

As tabelas Artista e Album possuem um relacionamento de um para muitos (1..N), em que um artista
pode possuir um ou mais álbuns.

Tabelas `Artista` e `Album`

Tabelas Album e Cancao:

A tabela Album possui um relacionamento de um para muitos com a tabela Cancao, uma vez que um
álbum pode conter várias canções.

Tabelas `Album` e `Cancao`

Tabelas Album e EstiloMusical:

A tabela EstiloMusical também possui um relacionamento de um para muitos com a tabela Album,
uma vez que um estilo musical pode estar contido em vários álbuns.

Tabelas `Album` e `EstiloMusical`

Ponto importante sobre diagramas ER

A ideia de um diagrama ER é prover uma representação gráfica para a estrutura de seu banco de dados,
descrevendo suas entidades com seus atributos e como elas se relacionam. Essa visualização pode te
ajudar tanto a criar e modelar seu banco de dados quanto a entender se sua modelagem precisa ser
alterada ou se houve algum erro ao pensar na organização de suas entidades. Com esse diagrama você
consegue pensar um pouco mais antes de começar a escrever as queries para criar as tabelas.

Hora de voltar ao MySQL Workbench e criar um banco de dados!

3) Criando um banco de dados para conter suas tabelas

Agora que você já tem um diagrama que representa as tabelas que precisam ser criadas, você já pode
botar a mão no código.

Ao lidar com a criação e gerenciamento de um banco de dados, você encontrará os seguintes comandos:

-- Cria um banco de dados com o nome especificado.

CREATE DATABASE nome_do_banco_de_dados;

-- Sinônimo de CREATE DATABASE, também cria um banco de dados.

CREATE SCHEMA nome_do_banco_de_dados;

-- Verifica se o banco de dados ainda não existe.

-- Essa verificação é comumente utilizada junto ao CREATE DATABASE para evitar

-- a tentativa de criar um banco de dados duplicado, o que ocasionaria um erro.

IF NOT EXISTS nome_do_banco_de_dados;

-- Lista todos os bancos de dados existentes.

SHOW DATABASES;
-- Define o banco de dados escolhido como ativo.

USE nome_do_banco_de_dados;

Os comandos CREATE DATABASE ou CREATE SCHEMA fazem a mesma coisa, no entanto eles
normalmente são utilizados em conjunto com o comando IF NOT EXISTS. Essa verificação é feita para
evitar a tentativa de criar um banco de dados duplicado, o que ocasionaria um erro.

Considerando o problema que precisa ser resolvido, hora de nomear o banco de dados de albuns.

CREATE DATABASE IF NOT EXISTS albuns;

Banco de dados `albuns` criado com sucesso

Como definir um banco como ativo

Talvez você já tenha notado que, até agora, todas as queries têm sido prefixadas ou precedidas do nome
do banco de dados, como, por exemplo:

SELECT * FROM sakila.actor;

No entanto, pode-se usar também o comando USE nome_do_do_banco_de_dados, que define um

banco de dados como ativo. Com ele, é eliminada a necessidade de utilizar nome do banco de dados
como prefixo nas queries. Veja o exemplo a seguir:

USE sakila;

SELECT * FROM actor;

Com o banco de dados albuns criado, resta apenas o quarto passo, pelo qual serão criadas as tabelas.

4) Criando e modelando tabelas de acordo com um diagrama ER

O objetivo para essa seção é criar as seguintes tabelas:

Relacionamento detalhado entre tabelas `Artista`, `Album`, `EstiloMusical` e `Cancao`

E para isso é necessário entender:

Quais são os principais tipos de dados no MySQL

Hora de assistir ao vídeo abaixo, para escolher melhor o tipo de dados durante a criação de uma
tabela.

O que é uma primary e foreign key

No vídeo abaixo você vai entender, em menos de 8 minutos, o que são primary key e foreign key.

Como criar uma tabela no MySQL

Hora de aprender como criar tabelas enquanto são montadas as quatro tabelas do banco de dados
albuns neste vídeo.

Resumão

Hoje você teve a oportunidade de vivenciar as seguintes etapas, necessárias para dar vida a um banco de
dados:

Como modelar um banco de dados do zero;

Identificar entidades, atributos e relacionamentos;

 Construir um diagrama entidade-relacionamento;

Criar um banco de dados;

Criar e modelar tabelas com base em um diagrama ER.

Hora de mexer os dedos

Após ter visto todo o processo de como sair de um problema e chegar até a criação de um banco de
dados, é preciso um certo tempo para internalizar esse conteúdo. Com isso em mente, segue a proposta:

Com o intuito de te dar mais tempo para absorver o material de hoje, tente refazer o banco de dados
albuns, caso já o tenha criado no decorrer da aula de hoje. Então, apague o banco de dados e recarregue
a página para que as respostas sobre como criar o banco de dados e tabelas não estejam visíveis e
expandidas.

Tente, com a ajuda do material de hoje, criar o diagrama e o banco novamente por conta própria, sem
olhar as respostas, que estão encapsuladas.

Blocos de respostas

É crucial que você tente chegar às suas próprias conclusões após assistir a este conteúdo. Somente assim
você terá uma chance melhor de absorver esse material.

Vamos fazer juntos!

Tempo sugerido para realização: 80 minutos

Vamos bater um papo sobre SQL? Hora da aula ao vivo! Vamos para o Slack, onde o link estará
disponível.

Exercícios

Tempo sugerido para realização: 40 minutos

Antes de começar: versionando seu código

Para versionar seu código, utilize o seu repositório de exercícios. 😉

Caso você ainda não tenha um, crie um repositório com o nome Trybe ou algo similar.

Abaixo você vai ver exemplos de como organizar cada exercício em uma branch, com arquivos e commits
específicos para cada exercício. Você deve seguir este padrão para realizar os exercícios a seguir.

Crie uma branch com o nome exercises/22.1 (bloco 22, dia 1)

$ git checkout -b exercises/22.1

Crie um diretório exercises e, dentro dele, um diretório 22_1. O caminho completo para o diretório a
partir da raiz do projeto deverá ser exercises/22_1.

$ mkdir -p exercises/22_1

$ cd exercises/22_1

$ pwd

<path_to_your_repo>/exercises/22_1

Crie um arquivo com um nome descritivo para cada exercício. Os arquivos devem estar dentro da pasta
exercises/22_1, mas lembre-se de fazer os commits a partir da pasta raiz do seu projeto!

$ git status

On branch exercises/22.1

Changes not staged for commit:

(use "git add <file>..." to update what will be committed)

 (use "git checkout -- <file>..." to discard changes in working directory)

modified: exercise_1.html

Faça commits organizados durante o processo de resolução de cada um de seus exercícios. As

mensagens dos commits devem ser breves e explicativas.

$ git log

commit 100c5ca0d64e2b8649f48edf3be13588a77b8fa4 (HEAD -> exercises/22.1)

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 17:48:01 2019 -0300

Exercicio 2 - mudando o evento de click para mouseover, tirei o alert e coloquei pra quando clicar
aparecer uma imagem do lado direito da tela

commit c0701d91274c2ac8a29b9a7fbe4302accacf3c78

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 16:47:21 2019 -0300

Exercicio 2 - adicionando um alert, usando função e o evento click

commit 6835287c44e9ac9cdd459003a7a6b1b1a7700157

Author: Tryber Bot <[email protected]>

Date: Fry Sep 27 15:46:32 2019 -0300

Resolvendo o exercício 1 usando eventListener

Lembre-se que na primeira vez que você for enviar o código para o repositório remoto a branch
exercises/22.1 não vai existir lá.
Então você precisa configurar o remote utilizando a opção --set-upstream (ou -u, que é a forma
abreviada).

$ git push -u origin exercises/22.1

Lembre-se de enviar os commits para o repositório do GitHub de vez em sempre.

$ git push origin exercises/22.1

Quando terminar os exercícios, seus códigos devem estar todos commitados na branch exercises/22.1,
e disponíveis no repositório remoto do GitHub.

Pra finalizar, crie um Pull Request , adicione uma descrição bem bacana, e envie para a monitoria e/ou
colegas revisarem! 🤜🏼🤛🏼

Agora, a prática:

Caso não tenha feito ainda, refaça o banco de dados albuns por conta própria, como está descrito na
seção "Hora de mexer os dedos".

Faça este quiz sobre tipos de dados no MySQL.

Faça este quiz sobre como escolher tipos de dados no MySQL.

Um zoológico precisa de um banco de dados para armazenar informações sobre os seus animais. As
informações a serem armazenadas sobre cada animal são:

Nome;

Espécie;
 Sexo;

Idade;

Localização.

Cada animal também possui um cuidador, e cada cuidador pode ser responsável por mais de um
animal. Além disso cada cuidador possui um gerente, sendo que cada gerente pode ser responsável por
mais de um cuidador.

Siga os passos aprendidos no dia de hoje para modelar essa base de dados.

Recursos adicionais (opcional)

Modelo ER e Diagrama ER

Como modelar um banco de dados gratuitamente através do draw.io

SQL Data Types

MySQL Data Types

MySQL Schema Best Practices

Próximo

Manual da Pessoa Estudante

Sempre que achar necessário, consulte seu Manual para ter mais informações sobre o curso!

Tutoriais

Como usar bem o Slack

Como usar bem o Zoom

Este conteúdo está em constante desenvolvimento.

Envie seu feedback (com o link da página) para nós via Slack para nos ajudar a construir juntos o melhor
conteúdo para o seu aprendizado!

#VQV

© Trybe 2020

https://www.sanfoundry.com/sql-mcqs-mysql-datatypes-1/

https://www.sanfoundry.com/sql-mcqs-mysql-datatypes-2/

https://www.devmedia.com.br/modelo-entidade-relacionamento-mer-e-diagrama-entidade-
relacionamento-der/14332

https://drawio-app.com/entity-relationship-diagram-erd/

https://www.w3schools.com/sql/sql_datatypes.asp

https://www.mysqltutorial.org/mysql-data-types.aspx

https://www.percona.com/live/17/sites/default/files/slides/michael-benshoof-schema%20best-
practices.pdf

Normalização

https://medium.com/@diegobmachado/normaliza%C3%A7%C3%A3o-em-banco-de-dados-
5647cdf84a12
https://www.luis.blog.br/normalizacao-de-dados-e-as-formas-normais.html

Transformando Parte 2

https://www.w3resource.com/mysql/creating-table-advance/create-index.php

https://www.w3resource.com/mysql/mysql-views.php

https://pt.wikipedia.org/wiki/Integridade_referencial

Projeto - One For All

O que vamos fazer?

Vamos iniciar hoje o projeto final dentro do nosso curso do SQL.

Esperamos que você tenha se divertido, quebrado muito a cabeça e, o mais importante, aprendido
bastante sobre a importância e o impacto que o conhecimento de SQL tem na carreira de uma pessoa na
nossa área.

Você receberá um clone simplificado do banco de dados da Spotify. Porém ele não estará normalizado, e
sua missão será de normalizar a estrutura que lhe for passada.

Por que isso é importante?

O processo de normalização é algo que ajuda a dar mais credibilidade a um profissional que atua com
estruturas de banco de dados diariamente. Estruturas normalizadas reduzem erros, diminuem a
redundância e nos permitem garantir uma maior integridade de dados.

Então, vamos ao projeto!

Especificação

Tempo sugerido para realização: 1 dia

O que vamos avaliar?

<strong>1ª, 2ª e 3ª Formas Normais procurando um banco fora das normas no servidor da frança para
enquadrar</strong>

A sua capacidade de normalizar um banco desnormalizado;

As queries que você desenvolver devem retornar exatamente a quantidade de colunas e registros
esperados, dentro do que foi pedido;

Organização do seu código. Deixe sempre as palavras-chave em CAIXA ALTA e os nomes de tabelas e
colunas em caixa baixa.

O que devo desenvolver?

Você passará pelos seguintes desafios, que trabalharão habilidades diferentes:

Analisar se duas tabelas não normalizadas.

Identificar modificações necessárias para que suas tabelas estejam adequadamente na 1ª, 2ª e 3ª
Forma Normais.

Criar um banco de dados a partir de uma planilha que contém tabelas e dados.

Criar e modelar tabelas.

Queries que passam pelos principais comandos SQL vistos até o momento.

Leia o arquivo README.md do projeto com atenção para uma explicação detalhada de como
desenvolver e entregar seu projeto.

Entregáveis
Para entregar o seu projeto, você deverá criar um Pull Request para um repositório no GitHub. Consulte
o canal do Slack da turma para obter o endereço do repositório.

Este Pull Request deverá conter a implementação das suas queries SQL, como especificado no
README.md do projeto.

Fique atento e siga as instruções no README.md do repositório! 🥺

Qualquer dúvida, procure a monitoria.

Lembre-se: você pode consultar nosso conteúdo sobre Git & GitHub sempre que quiser!