🇯🇵 日本語 | 🇺🇸 English | 🇪🇸 Español | 🇵🇹 Português | 🇹🇭 ไทย | 🇨🇳 中文

Domina la Cláusula HAVING de SQL: Un Análisis Profundo para Filtrar Datos Agrupados

Una vez que te familiarizas con la cláusula GROUP BY de SQL, puedes realizar agregaciones útiles como contar productos por categoría o pedidos por cliente. Pero el verdadero análisis de datos comienza a partir de ese punto. Inevitablemente, te encontrarás con situaciones en las que querrás filtrar aún más basándote en esos resultados agregados, haciendo preguntas como: "¿Quiénes son nuestros mejores clientes con más pedidos?" o "¿Qué categorías populares tienen el precio promedio más alto?".

La solución para este "filtrado después de agrupar" es nuestro tema principal de hoy: la cláusula HAVING. Cuando se usa con GROUP BY, HAVING mejora drásticamente la precisión y profundidad de tu análisis de datos. Es la herramienta perfecta que aborda exactamente lo que necesitas.

Este artículo explicará a fondo el rol y el uso de la cláusula HAVING desde cero, centrándose en su diferencia con la cláusula WHERE, un punto común de confusión para muchos estudiantes de SQL. A través de numerosos ejemplos de "copiar, pegar y ejecutar" (¡completos con un entorno SQL en línea!), tendrás ese momento de "¡Ajá!" y experimentarás de primera mano cómo funciona, llevando tus habilidades de agregación de datos al siguiente nivel.

Preparación: Configuremos Nuestros Datos de Pedidos de Muestra

Antes de sumergirnos en la teoría, construyamos una base práctica. Usaremos una tabla orders que simula el historial de pedidos de un sitio de comercio electrónico. Contiene datos prácticos como ID de cliente, categoría de producto, precio y fecha del pedido. Puedes copiar toda la declaración SQL a continuación para ejecutarla en tu propio entorno o usarla en la sección "Patio de Recreo Interactivo" más adelante.

-- Eliminar la tabla si existe (para permitir pruebas repetidas)
DROP TABLE IF EXISTS orders;

-- Crear la tabla orders
CREATE TABLE orders (
  order_id INTEGER PRIMARY KEY,
  customer_id INTEGER NOT NULL,
  product_category TEXT NOT NULL,
  price INTEGER NOT NULL,
  order_date DATE NOT NULL
);

-- Insertar datos
INSERT INTO orders (order_id, customer_id, product_category, price, order_date) VALUES
(1, 101, 'Periféricos de PC', 15000, '2025-05-10'),
(2, 102, 'Libros', 3200, '2025-05-11'),
(3, 101, 'Periféricos de PC', 250000, '2025-05-12'),
(4, 103, 'Electrodomésticos', 88000, '2025-05-15'),
(5, 102, 'Libros', 4500, '2025-05-20'),
(6, 101, 'Electrodomésticos', 120000, '2025-06-01'),
(7, 104, 'Periféricos de PC', 8000, '2025-06-05'),
(8, 102, 'Ropa', 7800, '2025-06-08'),
(9, 103, 'Periféricos de PC', 320000, '2025-06-10'),
(10, 105, 'Libros', 2900, '2025-06-15'),
(11, 101, 'Libros', 3500, '2025-06-20'),
(12, 103, 'Electrodomésticos', 35000, '2025-06-22');

Estos datos incluyen clientes que han realizado múltiples compras (ej., IDs de cliente 101, 102, 103) y categorías compradas por múltiples clientes (ej., Periféricos de PC, Libros), lo que lo hace ideal para observar el comportamiento de GROUP BY y HAVING.

El Concepto Central: La Diferencia Definitiva Entre WHERE y HAVING

La clave más importante para entender la cláusula HAVING es comprender claramente su división de tareas con la cláusula WHERE. Aunque ambas se usan para "filtrar", el momento y el objetivo de su filtrado son completamente diferentes.

Ilustremos esta diferencia usando la analogía de la cocina de un restaurante.

El Orden de Operaciones de SQL: Una Analogía de Restaurante

  1. Uniones de Tablas (FROM, JOIN): Primero, todos los ingredientes (datos) se reúnen en la cocina.
  2. La Cláusula WHERE: Llega el Chef. Antes de empezar a cocinar, el chef inspecciona los ingredientes individuales y descarta los que no cumplen los criterios, diciendo: "No puedo usar este pescado para el carpaccio de hoy".
  3. La Cláusula GROUP BY: El chef usa los ingredientes aprobados para crear varios platos (grupos), como ensaladas, pastas y platos de carne.
  4. La Cláusula HAVING: Llega el Crítico Gastronómico. Con los platos terminados (grupos) dispuestos en la mesa, el crítico decide cuáles evaluar, diciendo: "Solo probaré los platos que cuesten más de 20€".

Como muestra esta analogía, los dos puntos más importantes son:

Debido a esto, las condiciones que usan funciones de agregación como COUNT() o SUM() solo tienen sentido para grupos y, por lo tanto, solo se pueden usar en la cláusula HAVING. No puedes escribir algo como WHERE COUNT(*) > 10.

En la Práctica: Filtrando Resultados Agregados con la Cláusula HAVING

Ahora, veamos el poder de la cláusula HAVING en acción con código real. Primero, usaremos GROUP BY para agregar el "número de pedidos por cliente". Este será nuestro resultado base antes de aplicar la cláusula HAVING.

-- Primero, sin HAVING, contemos los pedidos por cliente
SELECT
  customer_id,
  COUNT(order_id) AS order_count
FROM
  orders
GROUP BY
  customer_id;

Resultado:

customer_id | order_count
------------|-------------
101         | 4
102         | 3
103         | 3
104         | 1
105         | 1

A partir de este resultado, supongamos que queremos "extraer solo nuestros mejores clientes que tienen 3 o más pedidos". Aquí es donde entra en juego la cláusula HAVING. Aplicamos una condición al resultado agregado, `order_count` (que es COUNT(order_id)).

-- 【HAVING + COUNT】Filtrar por clientes con 3 o más pedidos
SELECT
  customer_id,
  COUNT(order_id) AS order_count
FROM
  orders
GROUP BY
  customer_id
HAVING
  COUNT(order_id) >= 3;

Resultado:

customer_id | order_count
------------|-------------
101         | 4
102         | 3
103         | 3

¡Perfecto! Solo se filtraron los clientes con 3 o más pedidos (HAVING COUNT(order_id) >= 3). Este es el uso fundamental de la cláusula HAVING.

Ejemplos Avanzados: Condiciones con `SUM` y `AVG`

La cláusula HAVING no se limita a COUNT. Por supuesto, se puede combinar con otras funciones de agregación como SUM (total) y AVG (promedio). Esto permite un análisis de datos más sofisticado.

【HAVING + SUM】Filtrando categorías con ventas totales superiores a 100,000

Para averiguar "¿qué categorías contribuyen más a nuestros ingresos?", calculemos las ventas totales por categoría y luego veamos solo aquellas categorías que superen los 100,000.

-- 【HAVING + SUM】Filtrar por categorías con ventas totales superiores a 100,000
SELECT
  product_category,
  SUM(price) AS total_sales
FROM
  orders
GROUP BY
  product_category
HAVING
  SUM(price) > 100000;

Resultado:

product_category   | total_sales
--------------------|-------------
Periféricos de PC  | 593000
Electrodomésticos  | 243000

Este resultado deja en claro que "Periféricos de PC" y "Electrodomésticos" son los principales impulsores de ingresos.

【HAVING + AVG】Filtrando categorías con un precio promedio superior a 50,000

A continuación, para investigar "¿qué categorías venden artículos de alto valor?", calculemos el precio promedio por categoría y extraigamos solo aquellas donde el promedio exceda los 50,000.

-- 【HAVING + AVG】Filtrar por categorías con un precio promedio superior a 50,000
SELECT
  product_category,
  AVG(price) AS average_price
FROM
  orders
GROUP BY
  product_category
HAVING
  AVG(price) > 50000;

Resultado:

product_category   | average_price
--------------------|---------------
Periféricos de PC  | 148250
Electrodomésticos  | 81000

Como puedes ver, podemos evaluar las categorías desde diferentes perspectivas, no solo las ventas totales sino también el precio promedio.

La Combinación Definitiva: Usando WHERE y HAVING Juntos

WHERE y HAVING no son adversarios; son socios que trabajan juntos para lograr un filtrado más complejo. Usar ambos en una sola consulta permite un análisis increíblemente poderoso.

Nuestra pregunta analítica: "Considerando solo los pedidos desde junio de 2025 en adelante, ¿quiénes son los clientes cuyo monto total de compra excede los 100,000?"

Si desglosamos esta solicitud, vemos que hay dos pasos de filtrado:

  1. Filtro previo a la agrupación: Limitar los registros a pedidos a partir del 1 de junio de 2025. → Esta es una condición sobre registros individuales, por lo que es un trabajo para la cláusula WHERE.
  2. Filtro posterior a la agrupación: Limitar los grupos a clientes cuyo monto total de compra agregado sea mayor a 100,000. → Esta es una condición sobre los grupos, por lo que es un trabajo para la cláusula HAVING.

Aquí está el SQL correspondiente:

-- 【WHERE + HAVING】Clientes con compras totales > 100k desde junio en adelante
SELECT
  customer_id,
  SUM(price) AS total_spent_in_june_onwards
FROM
  orders
WHERE
  order_date >= '2025-06-01'
GROUP BY
  customer_id
HAVING
  SUM(price) > 100000;

Resultado:

customer_id | total_spent_in_june_onwards
------------|-----------------------------
101         | 123500
103         | 355000

El flujo de procesamiento de esta consulta coincide perfectamente con nuestra analogía del restaurante:

  1. Primero, WHERE order_date >= '2025-06-01' selecciona solo los registros de pedidos de junio en adelante.
  2. A continuación, estos registros seleccionados se agrupan por cliente usando GROUP BY customer_id.
  3. Finalmente, HAVING SUM(price) > 100000 filtra estos grupos, manteniendo solo aquellos donde el monto total de la compra excede los 100,000.

Esta colaboración entre WHERE y HAVING es posiblemente donde SQL brilla más en el análisis de datos.

【Patio de Recreo Interactivo】SQL Fiddle: ¡Prueba la Cláusula HAVING en tu Navegador!

¡Ahora es el momento de convertir el conocimiento en una habilidad sólida! Con el "Entorno SQL en Línea" a continuación, puedes experimentar libremente con SQL directamente en tu navegador. La tabla orders de este artículo ya está cargada para ti.

Prueba diferentes condiciones. Simplemente cambiar números, o intercambiar >= con <, te mostrará cómo cambian los resultados y profundizará dramáticamente tu comprensión.

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Entorno en Línea para la Cláusula HAVING de SQL</title>
  <style>
    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; line-height: 1.7; color: #333; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
    h1 { color: #2c3e50; }
    textarea { width: 100%; height: 200px; font-family: "SF Mono", "Consolas", monospace; font-size: 16px; padding: 12px; border: 1px solid #ccc; border-radius: 6px; box-sizing: border-box; margin-bottom: 1rem; }
    button { background-color: #8e44ad; color: white; border: none; padding: 12px 22px; font-size: 16px; border-radius: 6px; cursor: pointer; transition: background-color 0.2s; }
    button:hover { background-color: #70368b; }
    button:disabled { background-color: #bdc3c7; cursor: not-allowed; }
    #result-container { margin-top: 2rem; border: 1px solid #ddd; padding: 1rem; border-radius: 6px; background: #fdfdfd; min-height: 50px; overflow-x: auto;}
    #error-message { color: #e74c3c; font-weight: bold; }
    table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
    th, td { border: 1px solid #ddd; padding: 10px; text-align: left; white-space: nowrap; }
    th { background-color: #f2f2f2; }
    tr:nth-child(even) { background-color: #f9f9f9; }
  </style>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>

  <h1>¡Prueba SQL!</h1>
  <p>Ingresa tu consulta SQL en el área de texto a continuación y haz clic en el botón "Ejecutar". ¡Siéntete libre de probar todas las diferentes consultas del artículo!</p>

  <textarea id="sql-input">-- ¡Siéntete libre de experimentar!
-- Ejemplo: Filtrar por la categoría 'Periféricos de PC' (WHERE),
--          luego calcular el gasto total por cliente (GROUP BY),
--          y finalmente, mostrar solo los clientes que gastaron más de 200,000 (HAVING).
SELECT
  customer_id,
  SUM(price) AS total_spent_on_pc
FROM
  orders
WHERE
  product_category = 'Periféricos de PC'
GROUP BY
  customer_id
HAVING
  SUM(price) > 200000;</textarea>
  
  <button id="execute-btn">Ejecutar</button>
  
  <div id="result-container">
    <p id="error-message"></p>
    <div id="result-output"></div>
  </div>

  <script>
    const sqlInput = document.getElementById('sql-input');
    const executeBtn = document.getElementById('execute-btn');
    const errorMsg = document.getElementById('error-message');
    const resultOutput = document.getElementById('result-output');

    let db;

    async function initDb() {
      executeBtn.disabled = true;
      executeBtn.textContent = 'Inicializando BD...';
      try {
        const SQL = await initSqlJs({
          locateFile: file => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${file}`
        });
        db = new SQL.Database();
        
        const setupSql = `
          DROP TABLE IF EXISTS orders;
          CREATE TABLE orders (
            order_id INTEGER PRIMARY KEY,
            customer_id INTEGER NOT NULL,
            product_category TEXT NOT NULL,
            price INTEGER NOT NULL,
            order_date DATE NOT NULL
          );
          INSERT INTO orders (order_id, customer_id, product_category, price, order_date) VALUES
          (1, 101, 'Periféricos de PC', 15000, '2025-05-10'), (2, 102, 'Libros', 3200, '2025-05-11'),
          (3, 101, 'Periféricos de PC', 250000, '2025-05-12'), (4, 103, 'Electrodomésticos', 88000, '2025-05-15'),
          (5, 102, 'Libros', 4500, '2025-05-20'), (6, 101, 'Electrodomésticos', 120000, '2025-06-01'),
          (7, 104, 'Periféricos de PC', 8000, '2025-06-05'), (8, 102, 'Ropa', 7800, '2025-06-08'),
          (9, 103, 'Periféricos de PC', 320000, '2025-06-10'), (10, 105, 'Libros', 2900, '2025-06-15'),
          (11, 101, 'Libros', 3500, '2025-06-20'), (12, 103, 'Electrodomésticos', 35000, '2025-06-22');
        `;
        db.run(setupSql);
        
        executeBtn.disabled = false;
        executeBtn.textContent = 'Ejecutar';
        resultOutput.innerHTML = '<p>¡Listo! Siéntete libre de experimentar con tus propias consultas SQL.</p>';

      } catch (err) {
        errorMsg.textContent = 'Falló la inicialización de la base de datos: ' + err.message;
        console.error(err);
      }
    }

    function executeSql() {
      if (!db) return;
      const sql = sqlInput.value;
      errorMsg.textContent = '';
      resultOutput.innerHTML = '';
      try {
        const results = db.exec(sql);
        if (results.length === 0) {
          resultOutput.innerHTML = '<p>Consulta ejecutada con éxito, pero no se devolvió ningún conjunto de resultados (ej., para INSERT, UPDATE, etc.).</p>';
          return;
        }
        results.forEach(result => {
          const table = document.createElement('table');
          const thead = document.createElement('thead');
          const tbody = document.createElement('tbody');
          const headerRow = document.createElement('tr');
          result.columns.forEach(colName => {
            const th = document.createElement('th');
            th.textContent = colName;
            headerRow.appendChild(th);
          });
          thead.appendChild(headerRow);
          result.values.forEach(row => {
            const bodyRow = document.createElement('tr');
            row.forEach(cellValue => {
              const td = document.createElement('td');
              td.textContent = cellValue === null ? 'NULL' : (typeof cellValue === 'number' ? cellValue.toLocaleString() : cellValue);
              bodyRow.appendChild(td);
            });
            tbody.appendChild(bodyRow);
          });
          table.appendChild(thead);
          table.appendChild(tbody);
          resultOutput.appendChild(table);
        });
      } catch (err) {
        errorMsg.textContent = 'Error de SQL: ' + err.message;
        console.error(err);
      }
    }
    executeBtn.addEventListener('click', executeSql);
    initDb();
  </script>
</body>
</html>

Dentro del Motor de SQL: El Orden Lógico de Ejecución de Consultas

Para profundizar aún más en tu comprensión de la diferencia entre WHERE y HAVING, es increíblemente útil saber el "orden de procesamiento lógico" de cómo SQL maneja una consulta internamente. El orden en que escribimos nuestro código (SELECT, FROM, WHERE...) es diferente del orden en que SQL lo interpreta y ejecuta.

Orden de Ejecución Lógico de SQL:

  1. FROM: Primero, determina de qué tabla recuperar los datos.
  2. WHERE: A continuación, filtra las filas individuales según una condición.
  3. GROUP BY: Agrupa las filas filtradas en grupos.
  4. HAVING: Filtra los resultados agrupados según una condición.
  5. SELECT: Finalmente, decide qué columnas mostrar.
  6. ORDER BY: Ordena el conjunto de resultados en un orden específico.
  7. LIMIT: Restringe el número de filas a mostrar.

Al observar este orden, puedes ver claramente que WHERE viene antes de GROUP BY, y HAVING viene justo después. Esta es la razón principal por la que las funciones de agregación no se pueden usar en WHERE pero sí en `HAVING`.

Este orden también explica por qué generalmente no puedes usar un alias definido en la cláusula SELECT (ej., SUM(price) AS total_sales) en las cláusulas WHERE o HAVING (con algunas excepciones de bases de datos). Es porque la cláusula SELECT se evalúa más tarde. (A menudo puedes usar alias en la cláusula ORDER BY, porque ORDER BY se evalúa después de SELECT.)

Conclusión: Domina la Cláusula HAVING y Lleva tu Análisis de Datos al Siguiente Nivel

En este análisis profundo, exploramos la poderosa cláusula HAVING, una herramienta para filtrar los resultados de una agregación GROUP BY.

Repasemos los puntos clave una última vez:

La cláusula HAVING puede parecer una característica menor a primera vista. Sin embargo, si puedes dominarla o no, marcará una gran diferencia en la calidad y profundidad de los conocimientos que puedes extraer de tus datos. Te permite responder preguntas más agudas y críticas para el negocio con SQL, como: "Entre nuestras categorías más vendidas, ¿cuáles son las más rentables?" o "Dentro de nuestra base de usuarios activos, ¿cuál es el perfil de nuestros usuarios que más gastan?".

Por favor, juega extensamente en el patio de recreo en línea de este artículo y familiarízate con la cláusula HAVING. Te garantizo que tus habilidades de utilización de datos como creador web mejorarán a pasos agigantados.

Plantillas Relacionadas