As consultas SQL mais inúteis (e o que você deve fazer em vez disso)

Elas são executadas. Retornam dados. Mas são inúteis. Veja aqui o que não escrever em SQL e o que fazer em seu lugar.

Algumas consultas SQL funcionam muito bem, mas isso não significa que estejam fazendo algo útil.

Neste artigo, examinaremos exemplos reais de consultas SQL válidas, de aparência inofensiva e completamente inúteis. Elas desperdiçam recursos, ocultam insights ou simplesmente adicionam ruído. Para cada uma delas, você verá o que está errado e como escrever uma alternativa mais inteligente.

Deseja praticar a redação de consultas melhores imediatamente? Experimente a trilhaTrilha de Práticas em SQL em LearnSQL.com.br - ela foi criada para ajudá-lo a transformar teoria em habilidade, com 12 cursos e mais de 1.000 exercícios interativos.

Vamos limpar o lixo e escrever consultas que realmente realizem o trabalho.

1. Selecionando tudo sem um propósito

A consulta:

SELECT * 
FROM orders;

Por que é inútil: extrai dados desnecessários, torna as consultas mais lentas e sobrecarrega o banco de dados.

O que fazer em vez disso: especificar somente as colunas necessárias para melhorar o desempenho.

Melhor consulta:

SELECT order_id, customer_id, total_amount
FROM orders;

2. Contando tudo sem filtragem

A consulta:




SELECT COUNT(*) 
FROM orders;

Por que é inútil: geralmente retorna insights enganosos se não for filtrada.

O que fazer em vez disso: usar as condições WHERE ou GROUP BY para obter maior precisão.

Melhor consulta:




SELECT COUNT(*) 
FROM orders 
WHERE status = 'completed';

3. Ordenar por padrão quando a ordem não é importante

A consulta:

SELECT total_amount 
FROM orders 
ORDER BY customer_id;

Por que é inútil: aumenta o tempo de processamento sem beneficiar a análise.

O que fazer em vez disso: usar ORDER BY intencionalmente, por exemplo, para relatórios ou visualização.

Melhor consulta: não use ORDER BY a menos que seja necessário;

SELECT total_amount 
FROM orders;

4. Classificação sem limite

Esta é semelhante à anterior.

A consulta:

SELECT order_id, customer_id, total_amount 
FROM orders 
ORDER BY created_at DESC;

Por que é inútil: a classificação de grandes conjuntos de dados sem restrições é ineficiente.

O que fazer em vez disso: se possível, use LIMIT ou TOP.

Melhor consulta:

SELECT order_id, customer_id, total_amount 
FROM orders 
ORDER BY created_at 
DESC LIMIT 10;

5. Agrupamento sem rótulos significativos

A consulta:

SELECT customer_id, COUNT(*) 
FROM orders 
GROUP BY customer_id;

Por que ela é inútil: Os IDs sozinhos não fornecem contexto - os resultados são difíceis de interpretar e não são acionáveis.

O que fazer em vez disso: certifique-se de incluir um rótulo significativo, como nome ou e-mail.

Melhor consulta:

SELECT o.customer_id, c.email, COUNT(*) AS total_orders 
FROM orders o 
JOIN customers c 
ON o.customer_id = c.id 
GROUP BY o.customer_id, c.email;

6. Usando HAVING em vez de WHERE para filtrar linhas

A consulta:

SELECT order_id, customer_id, total_amount 
FROM orders 
HAVING total_amount > 100;

Por que é inútil: HAVING destina-se à filtragem agregada, não à filtragem de linhas. Embora funcione tecnicamente, isso fará com que o leitor da consulta não entenda sua intenção.

O que fazer em vez disso: usar WHERE antes da agregação.

Melhor consulta:

SELECT order_id, customer_id, total_amount 
FROM orders 
WHERE total_amount > 100;

7. Filtragem em colunas computadas sem indexação

A consulta:

SELECT order_id, customer_id, total_amount 
FROM orders 
WHERE YEAR(created_at) = 2023;

Por que é inútil: impede o uso de índices, causando varreduras de tabelas completas.

O que fazer em vez disso: usar a filtragem baseada em intervalo para aproveitar os índices.

Melhor consulta:

SELECT order_id, customer_id, total_amount 
FROM orders 
WHERE created_at >= '2023-01-01' AND created_at < '2024-01-01';

8. Uso de subconsultas em vez de junções

A consulta:

SELECT order_id, customer_id, total_amount  
FROM orders  
WHERE customer_id IN (SELECT customer_id FROM blacklisted_customers);

Por que é inútil: pode levar a um desempenho lento em comparação com JOINs.

O que fazer em vez disso: usar um INNER JOIN ou LEFT JOIN.

Melhor consulta:


SELECT o.order_id, o.customer_id, o.total_amount  
FROM orders o  
JOIN blacklisted_customers b ON o.customer_id = b.customer_id;

9. Auto-união em vez de usar Funções de Janela (Window Functions) em SQL

A consulta:




SELECT
  o1.customer_id,
  o1.order_id,
COUNT(*) AS row_num  
FROM orders o1
JOIN orders o2
  ON o1.customer_id = o2.customer_id
  AND o1.order_date >= o2.order_date
GROUP BY o1.customer_id, o1.order_id;

Por que é inútil: causa complexidade e duplicação desnecessárias.

O que fazer em vez disso: usar as funções de janela pke ROW_NUMBER(), RANK(), ou LAG().

Melhor consulta:




SELECT 
  customer_id, 
  order_id,  
  ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY order_date) AS row_num  
FROM orders;

Escreva um SQL mais inteligente, não apenas um SQL válido

O fato de uma consulta ser executada não significa que ela esteja ajudando. Evitar essas armadilhas comuns tornará seu SQL mais rápido, mais limpo e muito mais útil.

Se você quiser continuar praticando a maneira correta de escrever consultas, confira a trilhaTrilha de Práticas em SQL em LearnSQL.com.br. Ela está repleta de exercícios práticos que o ajudam a aprimorar suas habilidades por meio da prática, não apenas da leitura.