Tutorial MySQL: Principais Tipos de Consultas
Este tutorial apresenta os principais tipos de consultas MySQL com exemplos simples e fáceis de entender. O MySQL é um dos sistemas de gerenciamento de banco de dados mais populares do mundo, e dominar suas consultas é essencial para qualquer desenvolvedor.
Sumário
- SELECT - Consulta de dados
- INSERT - Inserção de dados
- UPDATE - Atualização de dados
- DELETE - Remoção de dados
- JOIN - Junção de tabelas
- INNER JOIN
- LEFT JOIN
- RIGHT JOIN
- CROSS JOIN
- GROUP BY - Agrupamento de dados
- HAVING - Filtragem de grupos
- ORDER BY - Ordenação de resultados
- Sub-consultas
SELECT - Consulta de dados
O comando SELECT é usado para recuperar dados de uma ou mais tabelas em um banco de dados MySQL. É o comando mais utilizado em SQL.
Sintaxe básica
SELECT coluna1, coluna2, ...
FROM nome_tabela
WHERE condição;
Exemplos simples
1. Selecionar todas as colunas de uma tabela
SELECT * FROM clientes;
Este comando retorna todas as colunas e todos os registros da tabela "clientes".
2. Selecionar colunas específicas
SELECT nome, email FROM clientes;
Este comando retorna apenas as colunas "nome" e "email" de todos os registros da tabela "clientes".
3. Selecionar com condição WHERE
SELECT * FROM clientes WHERE cidade = 'São Paulo';
Este comando retorna todos os clientes que moram em São Paulo.
4. Selecionar com múltiplas condições
SELECT * FROM produtos
WHERE preco > 100 AND categoria = 'Eletrônicos';
Este comando retorna todos os produtos da categoria "Eletrônicos" com preço maior que 100.
5. Selecionar com ordenação (ORDER BY)
SELECT * FROM clientes ORDER BY nome ASC;
Este comando retorna todos os clientes ordenados pelo nome em ordem alfabética crescente (ASC). Para ordem decrescente, use DESC.
6. Selecionar com limite de resultados (LIMIT)
SELECT * FROM produtos ORDER BY preco DESC LIMIT 5;
Este comando retorna os 5 produtos mais caros (ordenados por preço em ordem decrescente).
7. Selecionar valores distintos (DISTINCT)
SELECT DISTINCT cidade FROM clientes;
Este comando retorna uma lista de cidades únicas onde os clientes moram, sem repetições.
8. Selecionar com funções de agregação
SELECT COUNT(*) FROM clientes;
Este comando conta o número total de registros na tabela "clientes".
SELECT MAX(preco) FROM produtos;
Este comando retorna o maior preço encontrado na tabela "produtos".
SELECT categoria, AVG(preco) AS media_preco
FROM produtos
GROUP BY categoria;
Este comando calcula o preço médio dos produtos por categoria.
INSERT - Inserção de dados
O comando INSERT é usado para adicionar novos registros em uma tabela no MySQL.
Sintaxe básica
INSERT INTO nome_tabela (coluna1, coluna2, ...)
VALUES (valor1, valor2, ...);
Exemplos simples
1. Inserir um único registro com todas as colunas
INSERT INTO clientes
VALUES (1, 'João Silva', 'joao@email.com', 'São Paulo', '11999998888');
Este comando insere um novo cliente com valores para todas as colunas da tabela, na ordem em que as colunas foram definidas na tabela.
2. Inserir um registro especificando as colunas
INSERT INTO clientes (nome, email, cidade, telefone)
VALUES ('Maria Santos', 'maria@email.com', 'Rio de Janeiro', '21988887777');
Este comando insere um novo cliente especificando quais colunas receberão os valores. É útil quando você não precisa fornecer valores para todas as colunas (por exemplo, quando há colunas com valores padrão ou que permitem NULL).
3. Inserir múltiplos registros de uma vez
INSERT INTO produtos (nome, preco, categoria)
VALUES
('Smartphone', 1200.00, 'Eletrônicos'),
('Notebook', 3500.00, 'Eletrônicos'),
('Cafeteira', 150.00, 'Eletrodomésticos');
Este comando insere três produtos de uma só vez, o que é mais eficiente do que executar três comandos INSERT separados.
4. Inserir dados com base em uma consulta SELECT
INSERT INTO clientes_vip (id, nome, email)
SELECT id, nome, email
FROM clientes
WHERE total_compras > 5000;
Este comando insere na tabela "clientes_vip" os dados dos clientes da tabela "clientes" que têm total de compras superior a 5000. É uma forma poderosa de copiar dados entre tabelas com base em condições.
UPDATE - Atualização de dados
O comando UPDATE é usado para modificar registros existentes em uma tabela no MySQL.
Sintaxe básica
UPDATE nome_tabela
SET coluna1 = valor1, coluna2 = valor2, ...
WHERE condição;
Exemplos simples
1. Atualizar um único campo de um registro específico
UPDATE clientes
SET telefone = '11987654321'
WHERE id = 1;
Este comando atualiza o número de telefone do cliente com id igual a 1.
2. Atualizar múltiplos campos de um registro
UPDATE produtos
SET preco = 1299.99, estoque = 50
WHERE id = 101;
Este comando atualiza tanto o preço quanto o estoque do produto com id igual a 101.
3. Atualizar múltiplos registros com uma condição
UPDATE produtos
SET preco = preco * 1.1
WHERE categoria = 'Eletrônicos';
Este comando aumenta em 10% o preço de todos os produtos da categoria "Eletrônicos".
4. Atualizar com base em valores de outra tabela
UPDATE produtos p
SET p.preco = p.preco * 0.9
WHERE p.id IN (SELECT produto_id FROM promocoes WHERE ativa = 1);
Este comando reduz em 10% o preço de todos os produtos que estão em promoções ativas.
5. Atualizar com LIMIT
UPDATE clientes
SET nivel = 'VIP'
WHERE total_compras > 5000
LIMIT 10;
Este comando atualiza no máximo 10 clientes com total de compras superior a 5000 para o nível VIP.
IMPORTANTE: Sempre use a cláusula WHERE em comandos UPDATE para evitar atualizar todos os registros da tabela por engano. Se você omitir WHERE, todos os registros serão atualizados!
DELETE - Remoção de dados
O comando DELETE é usado para remover registros existentes de uma tabela no MySQL.
Sintaxe básica
DELETE FROM nome_tabela
WHERE condição;
Exemplos simples
1. Excluir um registro específico
DELETE FROM clientes
WHERE id = 5;
Este comando remove o cliente com id igual a 5 da tabela "clientes".
2. Excluir múltiplos registros com uma condição
DELETE FROM produtos
WHERE estoque = 0;
Este comando remove todos os produtos que estão com estoque zerado.
3. Excluir registros com base em múltiplas condições
DELETE FROM pedidos
WHERE status = 'Cancelado' AND data_pedido < '2023-01-01';
Este comando remove todos os pedidos cancelados que foram feitos antes de 2023.
4. Excluir com base em uma subconsulta
DELETE FROM carrinho_compras
WHERE usuario_id IN (
SELECT id FROM usuarios
WHERE ultimo_acesso < DATE_SUB(NOW(), INTERVAL 30 DAY)
);
Este comando remove itens do carrinho de compras de usuários que não acessaram o sistema nos últimos 30 dias.
5. Excluir com LIMIT
DELETE FROM logs_sistema
WHERE data < '2023-01-01'
ORDER BY data
LIMIT 1000;
Este comando remove no máximo 1000 registros de logs antigos, começando pelos mais antigos.
IMPORTANTE: Sempre use a cláusula WHERE em comandos DELETE para evitar excluir todos os registros da tabela por engano. Se você omitir WHERE, todos os registros serão removidos!
JOIN - Junção de tabelas
Os comandos JOIN são usados para combinar registros de duas ou mais tabelas com base em uma coluna relacionada entre elas.
Tipos de JOIN no MySQL
- INNER JOIN: Retorna registros que têm valores correspondentes em ambas as tabelas
- LEFT JOIN: Retorna todos os registros da tabela à esquerda e os registros correspondentes da tabela à direita
- RIGHT JOIN: Retorna todos os registros da tabela à direita e os registros correspondentes da tabela à esquerda
- CROSS JOIN: Retorna o produto cartesiano de ambas as tabelas (todas as combinações possíveis)
Exemplos simples
Vamos considerar duas tabelas para os exemplos:
Tabela: clientes
| id | nome | cidade |
|----|---------------|--------------|
| 1 | João Silva | São Paulo |
| 2 | Maria Santos | Rio de Janeiro |
| 3 | Pedro Almeida | Belo Horizonte |
Tabela: pedidos
| id | cliente_id | produto | valor |
|----|------------|--------------|--------|
| 101| 1 | Smartphone | 1200.00|
| 102| 1 | Fone de ouvido| 150.00|
| 103| 2 | Notebook | 3500.00|
| 104| 4 | Monitor | 800.00 |
1. INNER JOIN
SELECT c.nome, p.produto, p.valor
FROM clientes c
INNER JOIN pedidos p ON c.id = p.cliente_id;
Este comando retorna apenas os registros onde há correspondência entre as tabelas clientes e pedidos. O resultado seria:
| nome | produto | valor |
|--------------|---------------|--------|
| João Silva | Smartphone | 1200.00|
| João Silva | Fone de ouvido| 150.00 |
| Maria Santos | Notebook | 3500.00|
Observe que Pedro Almeida não aparece porque não tem pedidos, e o pedido do Monitor não aparece porque o cliente_id 4 não existe na tabela clientes.
2. LEFT JOIN
SELECT c.nome, p.produto, p.valor
FROM clientes c
LEFT JOIN pedidos p ON c.id = p.cliente_id;
Este comando retorna todos os clientes, mesmo que não tenham pedidos. O resultado seria:
| nome | produto | valor |
|---------------|---------------|--------|
| João Silva | Smartphone | 1200.00|
| João Silva | Fone de ouvido| 150.00 |
| Maria Santos | Notebook | 3500.00|
| Pedro Almeida | NULL | NULL |
3. RIGHT JOIN
SELECT c.nome, p.produto, p.valor
FROM clientes c
RIGHT JOIN pedidos p ON c.id = p.cliente_id;
Este comando retorna todos os pedidos, mesmo que não tenham clientes correspondentes. O resultado seria:
| nome | produto | valor |
|--------------|---------------|--------|
| João Silva | Smartphone | 1200.00|
| João Silva | Fone de ouvido| 150.00 |
| Maria Santos | Notebook | 3500.00|
| NULL | Monitor | 800.00 |
4. CROSS JOIN
SELECT c.nome, p.produto
FROM clientes c
CROSS JOIN pedidos p;
Este comando retorna todas as combinações possíveis entre clientes e pedidos, independentemente de haver relação entre eles. O resultado teria 12 linhas (3 clientes × 4 pedidos).
5. JOIN com múltiplas tabelas
SELECT c.nome, p.produto, e.status
FROM clientes c
INNER JOIN pedidos p ON c.id = p.cliente_id
INNER JOIN entregas e ON p.id = e.pedido_id;
Este comando combina dados de três tabelas: clientes, pedidos e entregas.
GROUP BY - Agrupamento de dados
O comando GROUP BY é usado para agrupar linhas que têm os mesmos valores em colunas específicas, geralmente para aplicar funções de agregação como COUNT, MAX, MIN, SUM ou AVG.
Sintaxe básica
SELECT coluna1, coluna2, ..., função_agregação(coluna)
FROM nome_tabela
WHERE condição
GROUP BY coluna1, coluna2, ...;
Exemplos simples
1. Contar registros por grupo
SELECT cidade, COUNT(*) AS total_clientes
FROM clientes
GROUP BY cidade;
Este comando conta quantos clientes existem em cada cidade. O resultado seria algo como:
| cidade | total_clientes |
|---------------|----------------|
| São Paulo | 25 |
| Rio de Janeiro| 18 |
| Belo Horizonte| 12 |
2. Calcular soma por grupo
SELECT categoria, SUM(preco) AS valor_total
FROM produtos
GROUP BY categoria;
Este comando calcula o valor total dos produtos em cada categoria.
3. Encontrar valores máximos e mínimos por grupo
SELECT departamento,
MAX(salario) AS maior_salario,
MIN(salario) AS menor_salario
FROM funcionarios
GROUP BY departamento;
Este comando encontra o maior e o menor salário em cada departamento.
4. Calcular média por grupo
SELECT vendedor_id, AVG(valor_venda) AS ticket_medio
FROM vendas
GROUP BY vendedor_id;
Este comando calcula o ticket médio (valor médio de venda) para cada vendedor.
5. Agrupar por múltiplas colunas
SELECT categoria, marca, COUNT(*) AS quantidade
FROM produtos
GROUP BY categoria, marca;
Este comando conta quantos produtos existem para cada combinação de categoria e marca.
6. GROUP BY com HAVING
SELECT cidade, COUNT(*) AS total_clientes
FROM clientes
GROUP BY cidade
HAVING total_clientes > 10;
Este comando lista apenas as cidades que têm mais de 10 clientes. O HAVING é usado para filtrar grupos, enquanto o WHERE filtra linhas individuais.
7. GROUP BY com ORDER BY
SELECT categoria, COUNT(*) AS total
FROM produtos
GROUP BY categoria
ORDER BY total DESC;
Este comando conta os produtos por categoria e ordena o resultado pelo total em ordem decrescente, mostrando primeiro as categorias com mais produtos.
8. GROUP BY com WITH ROLLUP
SELECT categoria, subcategoria, SUM(vendas) AS total_vendas
FROM produtos
GROUP BY categoria, subcategoria WITH ROLLUP;
Este comando calcula o total de vendas por subcategoria e categoria, incluindo subtotais para cada categoria e um total geral.
HAVING - Filtragem de grupos
A cláusula HAVING é usada para filtrar resultados de grupos criados pela cláusula GROUP BY. Enquanto o WHERE filtra linhas antes do agrupamento, o HAVING filtra grupos após o agrupamento.
Sintaxe básica
SELECT coluna1, coluna2, ..., função_agregação(coluna)
FROM nome_tabela
WHERE condição
GROUP BY coluna1, coluna2, ...
HAVING condição_de_grupo;
Exemplos simples
1. Filtrar grupos com contagem mínima
SELECT cidade, COUNT(*) AS total_clientes
FROM clientes
GROUP BY cidade
HAVING total_clientes >= 5;
Este comando lista apenas as cidades que têm 5 ou mais clientes.
2. Filtrar grupos com soma acima de um valor
SELECT categoria, SUM(valor) AS total_vendas
FROM vendas
GROUP BY categoria
HAVING total_vendas > 10000;
Este comando mostra apenas as categorias cujo total de vendas é superior a 10.000.
3. Filtrar grupos com média específica
SELECT departamento, AVG(salario) AS media_salarial
FROM funcionarios
GROUP BY departamento
HAVING media_salarial BETWEEN 3000 AND 5000;
Este comando lista apenas os departamentos cuja média salarial está entre 3.000 e 5.000.
4. Combinar HAVING com funções de agregação
SELECT vendedor_id, COUNT(*) AS total_vendas, SUM(valor) AS valor_total
FROM vendas
GROUP BY vendedor_id
HAVING total_vendas >= 10 AND valor_total > 50000;
Este comando mostra apenas os vendedores que fizeram pelo menos 10 vendas e cujo valor total de vendas é superior a 50.000.
5. Diferença entre WHERE e HAVING
-- Usando WHERE (filtra antes do agrupamento)
SELECT categoria, SUM(valor) AS total_vendas
FROM vendas
WHERE data_venda >= '2023-01-01'
GROUP BY categoria;
-- Usando HAVING (filtra após o agrupamento)
SELECT categoria, SUM(valor) AS total_vendas
FROM vendas
GROUP BY categoria
HAVING SUM(valor) > 10000;
No primeiro exemplo, o WHERE filtra as vendas realizadas a partir de 2023 antes de agrupá-las. No segundo exemplo, o HAVING filtra as categorias cujo total de vendas é superior a 10.000 após o agrupamento.
6. Combinando WHERE e HAVING
SELECT categoria, AVG(preco) AS preco_medio
FROM produtos
WHERE estoque > 0
GROUP BY categoria
HAVING preco_medio > 100;
Este comando lista as categorias cujo preço médio dos produtos é superior a 100, considerando apenas produtos em estoque.
ORDER BY - Ordenação de resultados
A cláusula ORDER BY é usada para ordenar o conjunto de resultados de uma consulta em ordem crescente ou decrescente com base em uma ou mais colunas.
Sintaxe básica
SELECT coluna1, coluna2, ...
FROM nome_tabela
ORDER BY coluna1 [ASC|DESC], coluna2 [ASC|DESC], ...;
Exemplos simples
1. Ordenação simples em ordem crescente (padrão)
SELECT nome, idade
FROM clientes
ORDER BY nome;
Este comando lista todos os clientes ordenados pelo nome em ordem alfabética crescente (A a Z).
2. Ordenação em ordem decrescente
SELECT nome, preco
FROM produtos
ORDER BY preco DESC;
Este comando lista todos os produtos ordenados pelo preço em ordem decrescente (do mais caro para o mais barato).
3. Ordenação por múltiplas colunas
SELECT nome, cidade, idade
FROM clientes
ORDER BY cidade ASC, idade DESC;
Este comando ordena os clientes primeiro pela cidade em ordem alfabética e, para clientes da mesma cidade, ordena pela idade em ordem decrescente (do mais velho para o mais novo).
4. Ordenação usando alias de coluna
SELECT nome, preco * quantidade AS valor_total
FROM vendas
ORDER BY valor_total DESC;
Este comando calcula o valor total de cada venda e ordena os resultados pelo valor total em ordem decrescente.
5. Ordenação usando posição da coluna
SELECT nome, idade, cidade
FROM clientes
ORDER BY 3, 2;
Este comando ordena os resultados pela terceira coluna (cidade) e depois pela segunda coluna (idade). Embora funcione, é recomendável usar os nomes das colunas para maior clareza.
6. Ordenação com LIMIT
SELECT nome, preco
FROM produtos
ORDER BY preco DESC
LIMIT 5;
Este comando lista os 5 produtos mais caros.
7. Ordenação com NULL
SELECT nome, data_ultima_compra
FROM clientes
ORDER BY data_ultima_compra DESC;
Por padrão, o MySQL trata valores NULL como menores que valores não-NULL em ordenação ASC, então eles aparecem primeiro. Em ordenação DESC, os valores NULL aparecem por último.
Para controlar explicitamente a posição dos valores NULL:
-- Coloca NULL por último em ordem ASC
SELECT nome, data_ultima_compra
FROM clientes
ORDER BY (data_ultima_compra IS NULL), data_ultima_compra ASC;
-- Coloca NULL primeiro em ordem DESC
SELECT nome, data_ultima_compra
FROM clientes
ORDER BY (data_ultima_compra IS NULL) DESC, data_ultima_compra DESC;
Sub-consultas
As sub-consultas são consultas SQL aninhadas dentro de outra consulta SQL. Elas podem ser usadas em várias partes de uma consulta, como nas cláusulas SELECT, FROM, WHERE, HAVING, entre outras.
Sintaxe básica
SELECT coluna1, coluna2, ...
FROM nome_tabela
WHERE coluna_x operador (SELECT coluna FROM outra_tabela WHERE condição);
Exemplos simples
1. Sub-consulta na cláusula WHERE
SELECT nome, salario
FROM funcionarios
WHERE salario > (SELECT AVG(salario) FROM funcionarios);
Este comando lista os funcionários cujo salário é maior que a média salarial de todos os funcionários.
2. Sub-consulta com IN
SELECT nome
FROM clientes
WHERE id IN (SELECT cliente_id FROM pedidos WHERE valor > 1000);
Este comando lista os nomes dos clientes que fizeram pedidos com valor superior a 1000.
3. Sub-consulta com NOT IN
SELECT nome
FROM produtos
WHERE id NOT IN (SELECT produto_id FROM vendas WHERE data_venda >= '2023-01-01');
Este comando lista os produtos que não foram vendidos desde o início de 2023.
4. Sub-consulta com EXISTS
SELECT nome
FROM fornecedores f
WHERE EXISTS (
SELECT 1 FROM produtos p
WHERE p.fornecedor_id = f.id AND p.estoque = 0
);
Este comando lista os fornecedores que têm pelo menos um produto com estoque zerado.
5. Sub-consulta com ANY/SOME
SELECT nome, preco
FROM produtos
WHERE preco > ANY (
SELECT preco FROM produtos WHERE categoria = 'Básico'
);
Este comando lista produtos cujo preço é maior que pelo menos um dos produtos da categoria 'Básico'.
6. Sub-consulta com ALL
SELECT nome, preco
FROM produtos
WHERE preco > ALL (
SELECT preco FROM produtos WHERE categoria = 'Básico'
);
Este comando lista produtos cujo preço é maior que todos os produtos da categoria 'Básico'.
7. Sub-consulta na cláusula FROM
SELECT categoria, AVG(preco_medio) AS media_geral
FROM (
SELECT categoria, AVG(preco) AS preco_medio
FROM produtos
GROUP BY categoria
) AS categorias_precos
GROUP BY categoria;
Este comando calcula a média de preço por categoria e depois calcula a média geral.
8. Sub-consulta na cláusula SELECT
SELECT
nome,
preco,
(SELECT AVG(preco) FROM produtos) AS preco_medio,
preco - (SELECT AVG(preco) FROM produtos) AS diferenca
FROM produtos;
Este comando lista cada produto com seu preço, o preço médio de todos os produtos e a diferença entre o preço do produto e a média.
9. Sub-consulta correlacionada
SELECT d.nome,
(SELECT COUNT(*) FROM funcionarios f WHERE f.departamento_id = d.id) AS total_funcionarios
FROM departamentos d;
Este comando lista cada departamento e o número de funcionários nele. A sub-consulta é correlacionada porque faz referência à tabela externa (d.id).
Conclusão
Neste tutorial, exploramos os principais tipos de consultas MySQL com exemplos práticos e fáceis de entender. Dominar esses comandos é fundamental para trabalhar eficientemente com bancos de dados MySQL.
Lembre-se de que a prática é essencial para aprimorar suas habilidades em SQL. Experimente esses exemplos em seu próprio ambiente MySQL e adapte-os às suas necessidades específicas.
Para consultas mais avançadas e otimização de desempenho, recomendamos consultar a documentação oficial do MySQL e explorar recursos como índices, procedimentos armazenados e funções.
