¿Cuál es la diferencia entre WHERE y HAVING en SQL?

La diferencia corta: WHERE filtra filas antes de agrupar y HAVING filtra el resultado después. Todo lo demás que vas a leer sobre las dos cláusulas sale de ahí: por qué una acepta alias y la otra no, por qué solo una funciona con COUNT() o SUM(), y por qué en la práctica conviene usar WHERE siempre que puedas.
El orden de ejecución lo explica todo
SQL no se ejecuta en el orden en que lo escribes. El motor lo resuelve más o menos así:
FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT
Fíjate dónde caen las dos: WHERE actúa antes de GROUP BY y de SELECT; HAVING actúa después de agrupar. Con eso en la cabeza, el resto deja de ser una lista de reglas que memorizar.
Con datos de ejemplo
Digamos que tenemos esta tabla:
CREATE TABLE `table` (
`id` int unsigned NOT NULL AUTO_INCREMENT,
`value` int unsigned NOT NULL,
PRIMARY KEY (`id`),
KEY `value` (`value`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4Con 10 filas, donde id y value van de 1 a 10:
INSERT INTO `table`(`id`, `value`) VALUES (1, 1),(2, 2),(3, 3),(4, 4),(5, 5),(6, 6),(7, 7),(8, 8),(9, 9),(10, 10);Si ejecutamos estas dos consultas:
SELECT `value` v FROM `table` WHERE `value`>5; -- 5 filas
SELECT `value` v FROM `table` HAVING `value`>5; -- 5 filasObtenemos exactamente el mismo resultado, y de paso queda claro que HAVING funciona sin GROUP BY. En MySQL es válido, aunque casi nunca sea lo que quieres.
La primera diferencia: los alias
Si intentamos filtrar por el alias con WHERE:
SELECT `value` v FROM `table` WHERE `v`>5;Obtenemos:
Error #1054 - Unknown column 'v' in 'where clause'
Pero con HAVING sí funciona:
SELECT `value` v FROM `table` HAVING `v`>5; -- 5 filasLa razón está en el orden de arriba: cuando WHERE se ejecuta, el SELECT todavía no ha corrido, así que el alias v no existe. Que HAVING sí lo acepte es cosa de MySQL: el estándar SQL exige que HAVING solo haga referencia a columnas del GROUP BY o usadas en funciones agregadas, y MySQL añade una extensión que le permite usar las columnas de la lista del SELECT. MySQL aplica HAVING casi al final, justo antes de enviar las filas al cliente.
La segunda diferencia: agregados
HAVING existe para filtrar grupos, y ahí WHERE no puede sustituirlo.
Supongamos una tabla de pedidos y esta pregunta: qué clientes tienen más de 3 pedidos pagados.
SELECT cliente_id, COUNT(*) AS pedidos
FROM pedidos
WHERE estado = 'pagado'
GROUP BY cliente_id
HAVING pedidos > 3;Las dos cláusulas trabajan juntas y cada una hace algo distinto:
WHERE estado = 'pagado'descarta filas antes de agrupar. Los pedidos cancelados no llegan a contarse.HAVING pedidos > 3descarta grupos ya formados. Solo puede evaluarse cuando elCOUNT()existe.
Intentar meter el agregado en el WHERE falla:
SELECT cliente_id, COUNT(*) AS pedidos
FROM pedidos
WHERE COUNT(*) > 3 -- Error #1111 - Invalid use of group function
GROUP BY cliente_id;Cuando WHERE se ejecuta, los grupos no existen todavía, así que COUNT(*) no tiene nada que contar.
Y al revés: mover el filtro de estado al HAVING no da un error, da un resultado distinto, que es peor porque parece que funciona:
-- Cuenta TODOS los pedidos y luego filtra grupos. No es lo mismo.
SELECT cliente_id, COUNT(*) AS pedidos
FROM pedidos
GROUP BY cliente_id
HAVING pedidos > 3;Aquí los pedidos cancelados sí entran en el recuento. Es el error clásico de este tema: la consulta corre, devuelve filas, y los números están mal.
Rendimiento: por qué preferir WHERE
El manual de MySQL es directo con esto. En la página de SELECT dice que HAVING se aplica casi al final, justo antes de enviar las filas al cliente, sin optimización, y pide expresamente no usar HAVING para condiciones que van en el WHERE: no escribir SELECT col_name FROM tbl_name HAVING col_name > 0, sino la misma condición con WHERE.
WHERE, en cambio, actúa antes: el motor puede usar el índice para leer solo las filas que cumplen la condición, en lugar de leerlas todas y descartar al final.
Hay un matiz, y conviene conocerlo para no sacar conclusiones de un ejemplo de juguete: según la optimización de cláusulas WHERE, si no usas GROUP BY ni funciones agregadas, MySQL fusiona el HAVING con el WHERE. Por eso, en una consulta tan simple como la del principio, el plan de ejecución puede salir igual con las dos. Comprueba el tuyo con EXPLAIN en lugar de suponerlo.
Como regla práctica, si la condición se puede expresar sin agregados, va en WHERE. Deja HAVING solo para lo que no se puede filtrar antes de agrupar.
Resumen
WHERE |
HAVING |
|
|---|---|---|
| Cuándo actúa | Antes de GROUP BY |
Después de GROUP BY |
| Sobre qué filtra | Filas individuales | Grupos ya formados |
Acepta alias del SELECT |
No | Sí en MySQL (extensión) |
| Acepta funciones agregadas | No | Sí |
Necesita GROUP BY |
No | No (pero es su caso normal) |
| Aprovecha índices para reducir filas | Sí | Solo si MySQL lo fusiona con WHERE (sin GROUP BY ni agregados) |
Preguntas frecuentes
¿Puedo usar WHERE y HAVING en la misma consulta?
Sí, y es lo habitual en consultas con agregados. WHERE recorta las filas que entran al grupo y HAVING descarta los grupos que no cumplen.
¿Se puede usar HAVING sin GROUP BY?
En MySQL sí. Si tampoco hay funciones agregadas, el optimizador fusiona ese HAVING con el WHERE; aun así, el manual pide escribir esas condiciones directamente en WHERE, que es donde corresponden.
¿Por qué WHERE no acepta alias?
Porque cuando se evalúa, el SELECT todavía no se ha ejecutado y el alias no existe. En MySQL, HAVING sí puede usar los alias y las columnas del SELECT gracias a una extensión propia; el estándar SQL no lo contempla.
¿Por qué da error Invalid use of group function en el WHERE?
Porque estás usando COUNT(), SUM(), AVG() o similar en una cláusula que se ejecuta antes de que existan los grupos. Ese filtro va en HAVING.
¿Cuál es más rápido, WHERE o HAVING?
WHERE, cuando las dos pueden expresar la misma condición. Filtra antes y permite al motor usar el índice para examinar menos filas, mientras que HAVING se aplica casi al final y sin optimización, según el manual de MySQL. En consultas sin GROUP BY ni agregados el optimizador puede fusionarlos y dar el mismo plan; compruébalo con EXPLAIN.
¿Esto aplica solo a MySQL?
El orden de ejecución y la distinción entre filtrar filas y filtrar grupos son parte del estándar SQL, así que el concepto vale en PostgreSQL, SQL Server, SQLite y el resto. Lo que cambia entre motores son los detalles, como la tolerancia de MySQL a alias y columnas no agregadas en el HAVING o a columnas no agrupadas en el SELECT.
Lectura relacionada en MySQL: tamaños máximos de TEXT, TINYTEXT y MEDIUMTEXT.
Fuentes
- SELECT Statement (manual oficial de MySQL)
- Problems with Column Aliases (manual oficial de MySQL)
- WHERE Clause Optimization (manual oficial de MySQL)
- EXPLAIN Output Format (manual oficial de MySQL)
¿Tienes un proyecto en mente?
Trabajo con Laravel, WordPress, SEO técnico y servidores MCP. El primer paso es una llamada de descubrimiento, sin costo ni compromiso, donde me cuentas qué necesitas y te digo con honestidad si puedo ayudarte.