Las consultas SQL más inútiles (y lo que deberías hacer en su lugar)

Se ejecutan. Devuelven datos. Pero no tienen sentido. Esto es lo que no hay que escribir en SQL y lo que hay que hacer en su lugar.

Algunas consultas SQL se ejecutan perfectamente, pero eso no significa que hagan nada útil.

En este artículo, veremos ejemplos reales de consultas SQL que son válidas, de aspecto inofensivo y completamente inútiles. Malgastan recursos, ocultan información o simplemente añaden ruido. Para cada una de ellas, verás lo que está mal y cómo escribir una alternativa más inteligente en su lugar.

¿Quieres practicar cómo escribir mejores consultas ahora mismo? Pruebe la pistaEjercicio de SQL en LearnSQL.es - está construida para ayudarle a convertir la teoría en habilidad, con 12 cursos y más de 1000 ejercicios interactivos.

Limpiemos la basura y escribamos consultas que realmente hagan el trabajo.

1. Seleccionar todo sin un propósito

La consulta:

SELECT * 
FROM orders;

Por qué es inútil: extrae datos innecesarios, ralentiza las consultas y sobrecarga la base de datos.

Qué hacer en su lugar: especificar sólo las columnas necesarias para mejorar el rendimiento.

Mejor consulta:

SELECT order_id, customer_id, total_amount
FROM orders;

2. Contar todo sin filtrar

La consulta:




SELECT COUNT(*) 
FROM orders;

Por qué es inútil: a menudo devuelve información engañosa si no se filtra.

Qué hacer en su lugar: utilizar las condiciones de WHERE o GROUP BY para mejorar la precisión.

Una consulta mejor:




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

3. Ordenar por defecto cuando el orden no importa

La consulta:

SELECT total_amount 
FROM orders 
ORDER BY customer_id;

Por qué es inútil: añade tiempo de procesamiento sin beneficiar al análisis.

Qué hacer en su lugar: utilizar ORDER BY intencionadamente, por ejemplo, para informes o visuapzación.

Mejor consulta: no utilice ORDER BY a menos que sea necesario;

SELECT total_amount 
FROM orders;

4. Ordenación sin límite

Este caso es similar al anterior.

La consulta:

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

Por qué es inútil: ordenar grandes conjuntos de datos sin límites es ineficiente.

Qué hacer en su lugar: si es posible, utilice LIMIT o TOP.

Una consulta mejor:

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

5. Agrupación sin etiquetas significativas

La consulta:

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

Por qué es inútil: Los ID por sí solos no proporcionan contexto: los resultados son difíciles de interpretar y no son procesables.

Qué hacer en su lugar: asegúrese de incluir una etiqueta significativa pke nombre o correo electrónico.

Una consulta mejor:

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. Utilizar HAVING en lugar de WHERE para filtrar filas

La consulta:

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

Por qué es inútil: HAVING está pensada para filtrar agregados, no filas. Aunque técnicamente funciona, distraerá al lector de la consulta para que no entienda su intención.

Qué hacer en su lugar: utilizar WHERE antes de la agregación.

Mejor consulta:

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

7. Filtrado de columnas calculadas sin indexación

La consulta:

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

Por qué es inútil: evita el uso de índices, provocando escaneos completos de la tabla.

Qué hacer en su lugar: utilizar filtrado basado en rangos para aprovechar los índices.

Mejor consulta:

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

8. Utilizar subconsultas en lugar de uniones

La consulta:

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

Por qué es inútil: puede dar lugar a un rendimiento lento en comparación con JOINs.

Qué hacer en su lugar: utilizar una INNER JOIN o LEFT JOIN.

Mejor 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. Autounión en lugar de utilizar Funciones de ventana

La 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 qué es inútil: causa complejidad y duplicación innecesarias.

Qué hacer en su lugar: utilizar las funciones de ventana pke ROW_NUMBER(), RANK(), o LAG().

Una consulta mejor:




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

Escriba un SQL más inteligente, no sólo un SQL válido

Que una consulta se ejecute no significa que sea útil. Evitar estas trampas comunes hará que su SQL sea más rápido, más limpio y mucho más útil.

Si quieres seguir practicando la forma correcta de escribir consultas, consulta el temaEjercicio de SQL en LearnSQL.es. Está repleto de ejercicios prácticos que te ayudarán a perfeccionar tus habilidades haciendo, no sólo leyendo.