MyLearnSQL

🏛️ DDL - Data Definition Language

Comandos para definir e modificar a estrutura do banco de dados

ESTRUTURA

🏗️ CREATE TABLE: Criando tabelas

Primeiro passo: criar a estrutura da tabela com colunas, tipos de dados e constraints.

✅ Quando usar

Use quando precisar criar uma nova tabela no banco de dados pela primeira vez.

📖 Como usar

Defina o nome da tabela, as colunas com seus tipos de dados e a chave primária.

SQL

CREATE TABLE pessoas (
    id INT NOT NULL AUTO_INCREMENT,
    nome VARCHAR(30) NOT NULL,
    nascimento DATE,
    sexo ENUM('M', 'F'),
    peso DECIMAL(5, 2),
    altura DECIMAL(3, 2),
    nacionalidade VARCHAR(20) DEFAULT 'Brasil',
    PRIMARY KEY (id)
) DEFAULT CHARSET = utf8;

🔧 ALTER TABLE: Modificando estrutura

Após criar a tabela, podemos adicionar, remover ou modificar colunas.

✅ Quando usar

Use quando precisar adicionar, remover ou reposicionar colunas em uma tabela existente.

📖 Como usar

Use ADD COLUMN para adicionar, DROP COLUMN para remover, AFTER/FIRST para posicionar.

SQL

-- Adicionando uma nova coluna no final
ALTER TABLE pessoas
ADD COLUMN profissao VARCHAR(10);

-- Removendo uma coluna
ALTER TABLE pessoas
DROP COLUMN profissao;

-- Adicionando coluna em posição específica
ALTER TABLE pessoas
ADD COLUMN profissao VARCHAR(10) AFTER nome;

-- Adicionando coluna como primeira da tabela
ALTER TABLE pessoas
ADD COLUMN codigo INT FIRST;

✏️ MODIFY COLUMN: Alterando características

Modificando tipo, tamanho, NOT NULL e DEFAULT de uma coluna já existente.

SQL

ALTER TABLE pessoas
MODIFY COLUMN profissao VARCHAR(20) NOT NULL DEFAULT '';

🏷️ CHANGE COLUMN: Renomeando colunas

Alterando o nome de uma coluna (e suas características se necessário).

SQL

ALTER TABLE pessoas
CHANGE COLUMN nacionalidade nascionalidade VARCHAR(20);

🔄 RENAME TABLE: Renomeando tabelas

Alterando o nome da tabela inteira.

SQL

DESC familia;

ALTER TABLE pessoas
RENAME TO familia;

SELECT * FROM familia;

🔒 CREATE TABLE com constraints avançadas

Criando tabela com UNIQUE, UNSIGNED e adicionando chave primária depois.

SQL

CREATE TABLE IF NOT EXISTS cursos (
    nome VARCHAR(30) NOT NULL UNIQUE,
    descricao TEXT,
    carga INT UNSIGNED,
    totaulas INT UNSIGNED,
    ano YEAR DEFAULT '2026'
) DEFAULT CHARSET = utf8;

-- Adicionando coluna de ID posteriormente
ALTER TABLE cursos
ADD COLUMN idcursos INT FIRST;

-- Definindo a chave primária após a criação
ALTER TABLE cursos
ADD PRIMARY KEY (idcursos);

🗑️ DROP TABLE: Deletando tabelas

Removendo completamente uma tabela (estrutura e dados). ⚠️ Use com cuidado!

SQL

CREATE TABLE IF NOT EXISTS teste (
    id INT,
    nome VARCHAR(10),
    idade INT
);

INSERT INTO teste VALUES
('1', 'Pedro', '22'),
('2', 'Maria', '12'),
('3', 'Maricota', '77');

SELECT * FROM teste;

-- CUIDADO: DROP TABLE remove tudo permanentemente!
DROP TABLE IF EXISTS teste;

✍️ DML - Data Manipulation Language

Comandos para manipular os dados dentro das tabelas

DADOS

➕ INSERT INTO: Inserindo dados

Adicionando registros na tabela usando DEFAULT para valores automáticos.

✅ Quando usar

Use quando precisar adicionar novos registros (linhas) na tabela.

📖 Como usar

Especifique os valores na ordem das colunas. Use DEFAULT para valores automáticos.

SQL

INSERT INTO pessoas VALUES
(DEFAULT, 'Andressa', '2001-04-16', 'F', '45.5', '1.62', DEFAULT);

🔍 SELECT: Consultando dados

Visualizando os dados inseridos na tabela.

SQL

SELECT * FROM pessoas;

📋 INSERT múltiplo: Vários registros de uma vez

Inserindo múltiplos registros em uma única instrução.

SQL

INSERT INTO cursos VALUES
('1',  'HTML4',         'Curso de HTML5',                     '40', '37', '2014'),
('2',  'Algoritmos',    'Lógica de Programação',              '20', '15', '2014'),
('3',  'Photoshop',     'Dicas de Photoshop CC',              '10', '8',  '2014'),
('4',  'PGP',           'Curso de PHP para iniciantes',       '40', '20', '2010'),
('5',  'Jarva',         'Introdução à Linguagem Java',        '10', '29', '2000'),
('6',  'MySQL',         'Bancos de Dados MySQL',              '30', '15', '2016'),
('7',  'Word',          'Curso completo de Word',             '40', '30', '2016'),
('8',  'Sapateado',     'Danças Rítmicas',                    '40', '30', '2018'),
('9',  'Cozinha Árabe', 'Aprenda a fazer Kibe',               '40', '30', '2018'),
('10', 'YouTuber',      'Gerar polêmica e ganhar inscritos',  '5',  '2',  '2018');

✏️ UPDATE: Modificando dados existentes

Alterando valores de registros já inseridos na tabela.

✅ Quando usar

Use quando precisar alterar dados de registros que já existem na tabela.

📖 Como usar

Use SET para definir novos valores e WHERE para especificar quais registros alterar.

SQL

-- Modificando uma única coluna
UPDATE cursos 
SET nome = 'HTML 5'
WHERE idcursos = '1';

-- Modificando múltiplas colunas ao mesmo tempo
UPDATE cursos 
SET nome = 'PHP', ano = '2015'
WHERE idcursos = '4';

-- Usando LIMIT para limitar quantas linhas serão afetadas
UPDATE cursos 
SET nome = 'Java', carga = '40', ano = '2015'
WHERE idcursos = '5'
LIMIT 1;

🗑️ DELETE: Removendo dados específicos

Deletando registros da tabela (mantém a estrutura).

SQL

-- Deletando um registro específico
DELETE FROM cursos
WHERE idcursos = '9';

-- Deletando múltiplos registros com LIMIT
DELETE FROM cursos
WHERE ano = '2018'
LIMIT 2;

🧹 TRUNCATE: Limpando todos os dados

Apagando todos os registros mas mantendo a estrutura da tabela.

SQL

TRUNCATE TABLE cursos;

🔍 DQL - Consultas Avançadas com SELECT

Filtrando, ordenando e selecionando colunas específicas

CONSULTAS

🎯 SELECT: Selecionando colunas específicas

Em vez de usar * (todas as colunas), podemos selecionar apenas as colunas que precisamos.

SQL

-- Selecionando apenas nome e nascimento
SELECT nome, nascimento 
FROM gafanhotos;

🔎 WHERE: Filtrando registros

Usando WHERE para filtrar dados com base em condições específicas.

SQL

-- Filtrando por uma condição simples
SELECT nome, nascimento 
FROM gafanhotos
WHERE nascimento > '2000-01-01';

↔️ BETWEEN: Filtrando por intervalo

BETWEEN permite filtrar valores dentro de um intervalo (inclusive os limites).

SQL

-- Selecionando registros entre duas datas
SELECT nome, nascimento 
FROM gafanhotos
WHERE nascimento BETWEEN '2000-01-01' AND '2015-12-31';

↕️ ORDER BY: Ordenando resultados

Ordenando os resultados por uma ou mais colunas (ASC = crescente, DESC = decrescente).

SQL

-- Ordenando por nascimento (crescente por padrão)
SELECT nome, nascimento 
FROM gafanhotos
ORDER BY nascimento;

-- Ordenando de forma decrescente
SELECT nome, nascimento 
FROM gafanhotos
ORDER BY nascimento DESC;

-- Ordenando por múltiplas colunas
SELECT nome, nascimento 
FROM gafanhotos
ORDER BY nascimento, nome;

🧩 Consulta Completa: Combinando tudo

Exemplo completo: selecionando colunas específicas, filtrando por intervalo e ordenando.

SQL

-- Lista com nome e nascimento de todos que nasceram entre 2000 e 2015
SELECT nome, nascimento 
FROM gafanhotos
WHERE nascimento BETWEEN '2000-01-01' AND '2015-12-31'
ORDER BY nascimento;

✂️ LIMIT: Limitando resultados

Limitando a quantidade de registros retornados pela consulta.

SQL

-- Retornando apenas os 5 primeiros registros
SELECT nome, nascimento 
FROM gafanhotos
ORDER BY nascimento
LIMIT 5;

-- Pulando os 3 primeiros e retornando os próximos 5 (paginação)
SELECT nome, nascimento 
FROM gafanhotos
ORDER BY nascimento
LIMIT 3, 5;

🔤 LIKE: Buscando padrões de texto

Usando LIKE para buscar registros que correspondem a um padrão (% = qualquer sequência, _ = um caractere).

SQL

-- Nomes que começam com 'A'
SELECT nome 
FROM gafanhotos
WHERE nome LIKE 'A%';

-- Nomes que terminam com 'a'
SELECT nome 
FROM gafanhotos
WHERE nome LIKE '%a';

-- Nomes que contêm 'silva'
SELECT nome 
FROM gafanhotos
WHERE nome LIKE '%silva%';

📝 IN: Filtrando por lista de valores

Usando IN para verificar se um valor está em uma lista específica.

SQL

-- Selecionando registros de anos específicos
SELECT nome, nascimento 
FROM gafanhotos
WHERE YEAR(nascimento) IN (2000, 2005, 2010, 2015);

💡 Exercícios Práticos

Exemplos práticos de consultas combinando múltiplos conceitos.

SQL - Exercício 1

-- Selecionar nome, sexo e profissão de programadores do sexo masculino
SELECT nome, sexo, profissao 
FROM gafanhotos
WHERE profissao = 'Programador' AND sexo = 'M';

SQL - Exercício 2

-- Listar mulheres nascidas no Brasil com nome começando com 'J'
SELECT nome, nacionalidade 
FROM gafanhotos
WHERE nome LIKE 'J%' 
  AND nacionalidade = 'Brasil';

SQL - Exercício 3

-- Buscar todos entre 2000 e 2015, ordenados por nascimento
SELECT nome, nascimento 
FROM gafanhotos
WHERE nascimento BETWEEN '2000-01-01' AND '2015-12-31'
ORDER BY nascimento;

SQL - Exercício 4

-- Combinar múltiplas condições com AND e OR
SELECT nome, sexo, profissao, nacionalidade
FROM gafanhotos
WHERE (profissao = 'Programador' OR profissao = 'Desenvolvedor')
  AND nacionalidade = 'Brasil'
ORDER BY nome;

SQL - Exercício 5

-- Filtrar por múltiplas condições: sexo, nacionalidade, peso e padrão de nome
SELECT nome, nacionalidade, peso 
FROM gafanhotos
WHERE sexo = 'M' 
  AND nacionalidade != 'Brasil' 
  AND peso < 100 
  AND nome LIKE '%Silva%';

📐 Funções de Agregação e Subconsultas

Trabalhando com funções MAX, MIN, AVG, COUNT e subconsultas

AVANÇADO

⬆️ MAX(): Encontrando o maior valor

A função MAX() retorna o maior valor de uma coluna.

SQL

-- Encontrando a maior altura
SELECT MAX(altura) FROM pessoas;

-- Encontrando o maior peso
SELECT MAX(peso) FROM pessoas;

⬇️ MIN(): Encontrando o menor valor

A função MIN() retorna o menor valor de uma coluna.

SQL

-- Encontrando a menor altura
SELECT MIN(altura) FROM pessoas;

-- Encontrando o menor peso
SELECT MIN(peso) FROM pessoas;

📊 AVG(): Calculando a média

A função AVG() calcula a média dos valores de uma coluna.

SQL

-- Calculando a média de altura
SELECT AVG(altura) FROM pessoas;

-- Calculando a média de peso
SELECT AVG(peso) FROM pessoas;

🔢 COUNT(): Contando registros

A função COUNT() conta o número de registros.

SQL

-- Contando total de registros
SELECT COUNT(*) FROM pessoas;

-- Contando registros com condição
SELECT COUNT(*) FROM pessoas
WHERE sexo = 'F';

🪆 Subconsultas (Subqueries)

Usando uma consulta dentro de outra para filtrar resultados baseados em valores calculados.

SQL - Problema

-- ❌ INCORRETO: MAX() não identifica a linha inteira corretamente
SELECT nome, altura
FROM pessoas
WHERE altura = MAX(altura);

SQL - Solução com Subconsulta

-- ✅ CORRETO: Usando subconsulta para encontrar a pessoa mais alta
SELECT nome, altura
FROM pessoas
WHERE altura = (SELECT MAX(altura) FROM pessoas);

SQL - Mais Exemplos

-- Pessoa com menor peso
SELECT nome, peso
FROM pessoas
WHERE peso = (SELECT MIN(peso) FROM pessoas);

-- Pessoas com altura acima da média
SELECT nome, altura
FROM pessoas
WHERE altura > (SELECT AVG(altura) FROM pessoas);

💡 Dicas de Programador

Boas práticas e observações importantes sobre consultas.

⚠️ Atenção com MAX() e MIN()

Problema: MAX() encontra o maior valor, mas não identifica corretamente a linha inteira sem subconsulta.

Solução: Use subconsultas para garantir que você obtenha o registro completo correto.

✅ Dica: ORDER BY DESC LIMIT 1

Alternativa: Para pegar a pessoa mais alta, você também pode usar:


                            SELECT nome, altura FROM pessoas ORDER BY altura DESC LIMIT 1;

Isso normalmente funciona para pegar a pessoa mais alta, mas subconsultas garantem todos os empates.

🗂️ GROUP BY e HAVING - Agrupamento de Dados

Agrupando registros e filtrando grupos com condições

AGRUPAMENTO

🗂️ GROUP BY: Agrupando dados

GROUP BY agrupa registros que têm valores iguais em colunas específicas, permitindo usar funções de agregação por grupo.

✅ Quando usar

Use quando quiser contar, somar ou calcular médias por categoria (ex: contar pessoas por profissão).

📖 Como usar

Combine com funções como COUNT(), SUM(), AVG(). Agrupe pela coluna que define as categorias.

SQL

-- Contando quantas pessoas existem por profissão
SELECT profissao, COUNT(*) 
FROM gafanhotos
GROUP BY profissao
ORDER BY COUNT(profissao);

-- Contando pessoas por sexo (nascidas após 2005)
SELECT sexo, COUNT(*) 
FROM gafanhotos
WHERE nascimento > '2005-01-01'
GROUP BY sexo;

🧲 HAVING: Filtrando grupos

HAVING filtra grupos após o agrupamento (diferente de WHERE que filtra antes). Use HAVING para condições com funções de agregação.

SQL

-- Contando cursos por ano, apenas anos após 2013, ordenado por quantidade decrescente
SELECT ano, COUNT(*) 
FROM cursos
WHERE totaulas > 30
GROUP BY ano
HAVING ano > 2013
ORDER BY COUNT(*) DESC;

🔵 ROUND(): Arredondando valores

ROUND() arredonda números decimais para um número específico de casas decimais.

SQL

-- Calculando a média de carga arredondada
SELECT ROUND(AVG(carga)) FROM cursos;

-- Arredondando para 2 casas decimais
SELECT ROUND(AVG(carga), 2) FROM cursos;

🔗 GROUP BY + HAVING + Subconsulta

Combinando agrupamento com subconsultas para filtros mais complexos.

SQL

-- Cursos agrupados por carga, apenas cargas acima da média
SELECT carga, COUNT(*) 
FROM cursos
WHERE ano > 2015
GROUP BY carga
HAVING carga > (SELECT ROUND(AVG(carga)) FROM cursos);

💡 Exercícios com GROUP BY e HAVING

Exemplos práticos de agrupamento e filtragem de grupos.

SQL - Exercício 1

-- Nacionalidades com mais de 3 pessoas (exceto Brasil)
SELECT nome, nacionalidade, COUNT(*) 
FROM gafanhotos
WHERE nacionalidade != 'Brasil'
GROUP BY nacionalidade
HAVING COUNT(*) > 3;

SQL - Exercício 2

-- Alturas de pessoas com peso > 100, apenas alturas acima da média geral
SELECT altura, COUNT(*) 
FROM gafanhotos
WHERE peso > 100
GROUP BY altura
HAVING altura > (SELECT AVG(altura) FROM gafanhotos);

⚖️ WHERE vs HAVING: Qual usar?

Entendendo a diferença entre WHERE e HAVING.

📋 Ordem de Execução SQL

FROM - Define a tabela
WHERE - Filtra registros individuais
GROUP BY - Agrupa os registros
HAVING - Filtra grupos
SELECT - Seleciona as colunas
ORDER BY - Ordena o resultado
LIMIT - Limita a quantidade

WHERE

Filtra antes do agrupamento
Trabalha com registros individuais
Não pode usar funções de agregação
Exemplo: WHERE peso > 100

HAVING

Filtra depois do agrupamento
Trabalha com grupos
Pode usar funções de agregação
Exemplo: HAVING COUNT(*) > 3

🔗 Relacionamentos e JOINs

Conectando tabelas através de chaves estrangeiras e consultas relacionadas

RELACIONAMENTOS

🔑 FOREIGN KEY: Criando relacionamentos

Chaves estrangeiras (Foreign Keys) criam relacionamentos entre tabelas, garantindo integridade referencial.

✅ Quando usar

Use quando uma tabela precisa referenciar dados de outra tabela (ex: aluno referenciando um curso).

📖 Como usar

Adicione uma coluna e crie a foreign key referenciando a chave primária da outra tabela.

SQL - Passo 1: Adicionar coluna

-- Adicionando uma coluna para armazenar o curso preferido
ALTER TABLE gafanhotos 
ADD cursopreferido INT;

-- Verificando a estrutura da tabela
DESC gafanhotos;

SQL - Passo 2: Criar Foreign Key

-- Criando a chave estrangeira que referencia a tabela cursos
ALTER TABLE gafanhotos
ADD FOREIGN KEY (cursopreferido)
REFERENCES cursos(idcurso);

🔗 O que é Foreign Key?

Uma Foreign Key (chave estrangeira) é uma coluna que faz referência à chave primária de outra tabela.

Benefícios:

Garante integridade referencial (não permite valores inválidos)
Impede exclusão de registros que estão sendo referenciados
Documenta o relacionamento entre tabelas

📥 Populando dados relacionados

Após criar o relacionamento, podemos atualizar os registros com valores válidos da tabela referenciada.

SQL

-- Consultando cursos disponíveis
SELECT * FROM cursos;

-- Consultando gafanhotos
SELECT * FROM gafanhotos;

-- Atualizando o curso preferido do gafanhoto com id 1
UPDATE gafanhotos 
SET cursopreferido = '6' 
WHERE id = '1';

🛡️ Integridade Referencial

Foreign Keys impedem a exclusão de registros que estão sendo referenciados por outras tabelas.

SQL

-- ❌ Tentando deletar um curso que está sendo referenciado
-- Isso vai FALHAR se algum gafanhoto tiver este curso como preferido
DELETE FROM cursos 
WHERE idcurso = '28';

⚠️ Erro de Integridade

Se você tentar deletar um curso que está sendo usado como "cursopreferido" por algum gafanhoto, o MySQL retornará um erro:


                            ERROR 1451: Cannot delete or update a parent row: a foreign key constraint fails

Isso é bom! Protege seus dados de inconsistências.

🤝 INNER JOIN: Combinando tabelas

JOIN permite combinar dados de múltiplas tabelas baseado em uma condição de relacionamento.

SQL - Consultas Separadas (Problema)

-- Consultando apenas nomes e IDs dos cursos preferidos
-- Problema: só vemos números, não sabemos qual é o curso!
SELECT nome, cursopreferido 
FROM gafanhotos;

-- Resultado: João | 6 (o que é o curso 6?)

SQL - Usando INNER JOIN (Solução)

-- Combinando as duas tabelas para mostrar nomes legíveis
SELECT gafanhotos.nome, cursos.nome
FROM gafanhotos JOIN cursos
ON cursos.idcurso = gafanhotos.cursopreferido
ORDER BY gafanhotos.nome;

-- Resultado: João | MySQL (muito melhor!)

💡 Como o INNER JOIN funciona

Passo a passo:

O MySQL pega cada registro da tabela gafanhotos
Para cada gafanhoto, busca na tabela cursos onde idcurso = cursopreferido
Se encontrar correspondência, combina as informações das duas tabelas
Se NÃO encontrar correspondência, o registro é ignorado

Importante: INNER JOIN só retorna registros que existem em AMBAS as tabelas.

📋 Sintaxe do JOIN


                            SELECT tabela1.coluna, tabela2.coluna

                            FROM tabela1 JOIN tabela2

                            ON tabela1.chave_estrangeira = tabela2.chave_primaria

Nota: Precisamos especificar tabela.coluna quando as duas tabelas têm colunas com o mesmo nome (como "nome" neste caso).

🪪 Alias: Simplificando consultas

Alias (apelidos) tornam as consultas mais legíveis e menos verbosas, especialmente com JOINs.

SQL - Sem Alias (Verboso)

-- Escrevendo o nome completo das tabelas toda vez
SELECT gafanhotos.nome, cursos.nome, cursos.ano
FROM gafanhotos JOIN cursos
ON cursos.idcurso = gafanhotos.cursopreferido
ORDER BY gafanhotos.nome;

SQL - Com Alias (Simplificado)

-- Usando alias "g" para gafanhotos e "c" para cursos
SELECT g.nome AS gafanhoto, c.nome AS curso, c.ano
FROM gafanhotos AS g JOIN cursos AS c
ON c.idcurso = g.cursopreferido
ORDER BY g.nome;

-- Versão ainda mais curta (AS é opcional)
SELECT g.nome gafanhoto, c.nome curso, c.ano
FROM gafanhotos g JOIN cursos c
ON c.idcurso = g.cursopreferido
ORDER BY g.nome;

💡 Vantagens do Alias

Menos digitação: "g.nome" em vez de "gafanhotos.nome"
Mais legível: Código mais limpo e fácil de entender
Renomeia colunas: "nome AS gafanhoto" muda o nome da coluna no resultado
Obrigatório em alguns casos: Quando você faz JOIN da mesma tabela consigo mesma

Dica: Use alias curtos e significativos (g, c, p) para tabelas e nomes descritivos para colunas.

📊 Tipos de JOIN

Existem diferentes tipos de JOIN para diferentes necessidades.

INNER JOIN

Retorna apenas registros que têm correspondência em ambas as tabelas.

LEFT JOIN

Retorna todos os registros da tabela esquerda, mesmo sem correspondência na direita.

RIGHT JOIN

Retorna todos os registros da tabela direita, mesmo sem correspondência na esquerda.

SQL - INNER JOIN

-- INNER JOIN: apenas gafanhotos que têm curso preferido cadastrado
SELECT gafanhotos.nome, cursos.nome
FROM gafanhotos JOIN cursos
ON cursos.idcurso = gafanhotos.cursopreferido
ORDER BY gafanhotos.nome;

📌 INNER JOIN - O que retorna?

Mostra: Apenas gafanhotos que escolheram um curso preferido E esse curso existe na tabela cursos.

Não mostra:

Gafanhotos sem curso preferido (cursopreferido = NULL)
Cursos que ninguém escolheu como preferido

Use quando: Você quer apenas dados completos, sem valores NULL.

SQL - LEFT OUTER JOIN

-- LEFT OUTER JOIN: todos os gafanhotos, mesmo sem curso preferido
SELECT gafanhotos.nome, cursos.nome
FROM gafanhotos LEFT OUTER JOIN cursos
ON cursos.idcurso = gafanhotos.cursopreferido
ORDER BY gafanhotos.nome;

📌 LEFT OUTER JOIN - O que retorna?

Mostra: TODOS os gafanhotos, independente de terem curso preferido ou não.

Comportamento:

Gafanhotos com curso: mostra o nome do curso normalmente
Gafanhotos sem curso: mostra NULL na coluna do curso

Use quando: A tabela da esquerda (gafanhotos) é a principal e você quer ver todos os seus registros.

Exemplo prático: "Quero ver todos os alunos, incluindo os que ainda não escolheram um curso."

SQL - RIGHT OUTER JOIN

-- RIGHT OUTER JOIN: todos os cursos, mesmo sem gafanhotos preferindo
SELECT gafanhotos.nome, cursos.nome
FROM gafanhotos RIGHT OUTER JOIN cursos
ON cursos.idcurso = gafanhotos.cursopreferido
ORDER BY gafanhotos.nome;

📌 RIGHT OUTER JOIN - O que retorna?

Mostra: TODOS os cursos, independente de terem sido escolhidos ou não.

Comportamento:

Cursos escolhidos: mostra o nome do gafanhoto que escolheu
Cursos não escolhidos: mostra NULL na coluna do gafanhoto

Use quando: A tabela da direita (cursos) é a principal e você quer ver todos os seus registros.

Exemplo prático: "Quero ver todos os cursos disponíveis, incluindo os que ninguém se interessou."

🔍 Comparação: Qual JOIN usar?

Entenda quando usar cada tipo de JOIN com exemplos práticos.

📊 Cenário de Exemplo

Tabela: gafanhotos

Ana (curso: MySQL)
Bruno (curso: Java)
Carlos (curso: NULL)

Tabela: cursos

MySQL
Java
Python

Resultados de cada JOIN:

INNER JOIN: Ana-MySQL, Bruno-Java
(Carlos não aparece pois não tem curso, Python não aparece pois ninguém escolheu)

LEFT JOIN: Ana-MySQL, Bruno-Java, Carlos-NULL
(Todos os gafanhotos aparecem, Carlos com NULL no curso)

RIGHT JOIN: Ana-MySQL, Bruno-Java, NULL-Python
(Todos os cursos aparecem, Python com NULL no gafanhoto)

💡 Dica Prática

Use INNER JOIN quando quiser apenas dados completos (sem NULLs)
Use LEFT JOIN quando a tabela da esquerda é a principal e você quer todos os seus registros
Use RIGHT JOIN quando a tabela da direita é a principal e você quer todos os seus registros

Nota: OUTER é opcional. "LEFT JOIN" e "LEFT OUTER JOIN" são equivalentes.

📚 Resumo dos Comandos SQL

DDL - Estrutura

CREATE, ALTER, DROP, RENAME, MODIFY, CHANGE

DML - Dados

INSERT, SELECT, UPDATE, DELETE, TRUNCATE

DQL - Consultas

SELECT, WHERE, BETWEEN, ORDER BY, LIMIT, LIKE, IN

Funções de Agregação

MAX, MIN, AVG, COUNT, Subconsultas

Agrupamento

GROUP BY, HAVING, ROUND

Relacionamentos

FOREIGN KEY, INNER JOIN, LEFT JOIN, RIGHT JOIN

🎯

🎯 Quiz - Teste seus conhecimentos

Responda aos exercícios práticos e verifique seu aprendizado

PRÁTICA

📝 Questão 1: Criar uma tabela

Você precisa criar uma tabela chamada "produtos" com as seguintes colunas:
- id (número inteiro, auto incremento, chave primária)
- nome (texto até 50 caracteres, obrigatório)
- preco (decimal com 2 casas decimais)
- estoque (número inteiro)

CREATE TABLE produtos (id INT, nome VARCHAR(50), preco DECIMAL, estoque INT); CREATE TABLE produtos (id INT AUTO_INCREMENT PRIMARY KEY, nome VARCHAR(50) NOT NULL, preco DECIMAL(10,2), estoque INT); INSERT TABLE produtos (id, nome, preco, estoque);

📝 Questão 2: Consulta com filtro

Você tem uma tabela "alunos" e precisa selecionar apenas os alunos que nasceram entre 2000 e 2010, ordenados por nome. Qual comando usar?

SELECT * FROM alunos WHERE nascimento BETWEEN '2000-01-01' AND '2010-12-31' ORDER BY nome; SELECT * FROM alunos WHERE nascimento > 2000 AND nascimento < 2010; GET alunos WHERE nascimento = 2000 TO 2010 ORDER nome;

📝 Questão 3: Agrupamento e contagem

Você precisa contar quantos funcionários existem em cada departamento, mostrando apenas departamentos com mais de 5 funcionários. Qual comando usar?

SELECT departamento, COUNT(*) FROM funcionarios WHERE COUNT(*) > 5; SELECT departamento, COUNT(*) FROM funcionarios GROUP BY departamento HAVING COUNT(*) > 5; SELECT departamento FROM funcionarios GROUP BY departamento LIMIT 5;

📝 Questão 4: JOIN entre tabelas

Você tem duas tabelas: "clientes" e "pedidos". Precisa mostrar o nome de todos os clientes e seus pedidos (se tiverem). Qual JOIN usar?

SELECT clientes.nome, pedidos.numero FROM clientes INNER JOIN pedidos ON clientes.id = pedidos.cliente_id; SELECT clientes.nome, pedidos.numero FROM clientes LEFT JOIN pedidos ON clientes.id = pedidos.cliente_id; SELECT clientes.nome, pedidos.numero FROM clientes, pedidos WHERE clientes.id = pedidos.cliente_id;

📝 Questão 5: Conceitos DCL, DDL e DML

Considerando os conceitos de Banco de Dados, relacione os parênteses vazios aos seus conceitos, depois assinale a alternativa que apresenta a sequência correta.

1 - DCL

2 - DDL

3 - DML

( ) permite conceder, retirar e controlar permissões de uso

( ) voltado à manipulação de dados

( ) voltado à definição de dados

1 - 2 - 3 1 - 3 - 2 2 - 1 - 3 3 - 2 - 1

📝 Questão 6: Consulta com JOIN e COUNT

Examine as tabelas Empregado e Pagamento do banco de dados a seguir e a instrução SQL, e assinale a opção correta.

Empregado

id	nome	idade
1	João	20
2	Maria	30
3	José	22
4	Joaquim	26
5	Manoel	21

Pagamento

empregado_id	data	valor
1	02-jul-08	1000
2	02-jul-08	2000
3	02-jul-08	1400
4	02-jul-08	1200
5	02-jul-08	5000

SELECT count(*)
FROM Empregado, Pagamento
WHERE Empregado.id = Pagamento.empregado_id
AND Empregado.idade < 25 AND Pagamento.valor > 1500

O resultado da consulta SQL é:

0 1 2 3

📝 Questão 7: Propriedades de Transação (ACID)

Uma transação representa uma interação entre a aplicação e o sistema de banco de dados tratada de forma única e independente. De acordo com as propriedades da transação, relacione as colunas e, a seguir, assinale a alternativa com a sequência correta.

1 - Atomicidade

2 - Consistência

3 - Isolamento

4 - Durabilidade

( ) Garante que o banco de dados esteja em um estado íntegro depois de a transação ser realizada.

( ) Garante que todas as tarefas da transação sejam cumpridas, ou a mesma seja cancelada como um todo.

( ) Garante que o resultado de uma transação só seja visível para outras transações no momento em que ela é finalizada com sucesso.

( ) Garante que a transação seja persistida assim que finalizada, ou seja, não será desfeita ou perdida mesmo na ocorrência de falhas do sistema.

1 - 2 - 3 - 4 2 - 1 - 3 - 4 3 - 4 - 1 - 2 4 - 3 - 2 - 1

💻

💻 Desafio de Código - Pratique SQL

Escreva código SQL real e execute para verificar se está correto

CÓDIGO

📋 Cenário do Desafio

Você foi contratado para criar um sistema de gerenciamento de uma biblioteca. Siga as instruções abaixo e escreva o código SQL necessário.

Importante: Execute cada comando na ordem correta. O sistema verificará se sua solução está correta!

Exercícios Totais

DDL

CREATE, ALTER (3)

DML

INSERT, UPDATE, DELETE (4)

DQL

SELECT, WHERE, LIKE, BETWEEN (5)

Agregação

GROUP BY, HAVING (2)

🎯 Tarefa 1: Criar a tabela de livros

Crie uma tabela chamada livros com as seguintes colunas:

id: número inteiro, auto incremento, chave primária
titulo: texto até 100 caracteres, obrigatório
autor: texto até 80 caracteres, obrigatório
ano: número inteiro
preco: decimal com 2 casas decimais

🎯 Tarefa 2: Inserir livros

Insira os seguintes livros na tabela (use DEFAULT para o id):

'Dom Casmurro', 'Machado de Assis', 1899, 35.90
'1984', 'George Orwell', 1949, 42.50
'O Senhor dos Anéis', 'J.R.R. Tolkien', 1954, 89.90

🎯 Tarefa 3: Consultar livros caros

Selecione o titulo e preco de todos os livros com preço maior que 40.00, ordenados por preço decrescente.

🎯 Tarefa 4: Atualizar preço

Aumente em 10% o preço de todos os livros publicados antes de 1950.

🎯 Tarefa 5: Adicionar coluna editora

Adicione uma nova coluna chamada editora do tipo VARCHAR(50) na tabela livros.

🎯 Tarefa 6: Remover coluna editora

Remova a coluna editora da tabela livros.

🎯 Tarefa 7: Deletar livros antigos

Delete todos os livros publicados antes de 1900.

🎯 Tarefa 8: Deletar por título

Delete todos os livros cujo título começa com a letra 'O'.

🎯 Tarefa 9: Consultar por período

Selecione titulo e ano dos livros publicados entre 1940 e 1960.

🎯 Tarefa 10: Buscar por autor

Selecione todos os campos dos livros cujo autor contém 'Machado' no nome.

🎯 Tarefa 11: Limitar resultados

Selecione titulo e preco dos 2 livros mais caros (ordenados por preço decrescente).

🎯 Tarefa 12: Filtrar por lista

Selecione titulo e ano dos livros publicados nos anos 1949, 1954 ou 1960.

🎯 Tarefa 13: Contar livros por década

Conte quantos livros existem agrupados por ano, ordenando por ano.

🎯 Tarefa 14: Média de preços

Calcule a média de preço dos livros agrupados por ano, mostrando apenas anos com média acima de 40.