SQL Server
WHERE frente a HAVING en SQL Server
Aprende cuándo usar WHERE y HAVING en SQL Server: filtra filas antes de agrupar o grupos después de agregarlas.
En este artículo
Después de aprender los agregados y a crear grupos con GROUP BY, quizá quieras conservar solo determinadas filas o grupos. SQL Server ofrece dos filtros distintos: WHERE filtra filas individuales antes de agrupar; HAVING filtra grupos después de formarlos. Esa es la diferencia central y una aplicación práctica del orden lógico de procesamiento.
WHERE elimina filas antes de agrupar
Supón que quieres contar pedidos por estado, pero solo incluir los que valen al menos 100:
SELECT
Status,
COUNT(*) AS OrderCount
FROM dbo.Orders
WHERE Amount >= 100
GROUP BY Status;WHERE revisa primero el Amount de cada pedido. Se conservan los importes 125.50, 310.00 y 199.00; las otras cinco filas, incluida la que tiene Amount NULL, se excluyen de esta consulta. Después, GROUP BY agrupa las filas restantes por Status. El resultado contiene dos pedidos Complete y uno Pending, sin grupo Shipped. La tabla original no cambia. Es el filtrado de filas que viste en la lección WHERE.
HAVING elimina grupos después de agregarlos
Para encontrar clientes con más de un pedido, primero hay que formar los grupos y luego filtrarlos:
SELECT
CustomerId,
COUNT(*) AS OrderCount
FROM dbo.Orders
GROUP BY CustomerId
HAVING COUNT(*) > 1;SQL Server agrupa los pedidos por CustomerId y calcula la cuenta de cada grupo. HAVING conserva los grupos cuyo total supera uno. En estos datos quedan los clientes 1, 4 y 7: Ana tiene 3 pedidos, David 2 y Grace 2, uno sin importe conocido. Ben tiene uno y su grupo se elimina. La consulta devuelve tres filas, una por cada grupo de cliente que cumple la condición.
- Orders
- WHERE — filtra filas individuales
- GROUP BY — crea grupos
- HAVING — filtra grupos
- SELECT — devuelve columnas
- ORDER BY — ordena el resultado
Una condición agregada como COUNT(*) > 1 normalmente no puede ir en WHERE:
-- Incorrecto: el recuento del grupo todavía no existe en WHERE
SELECT CustomerId, COUNT(*) AS OrderCount
FROM dbo.Orders
WHERE COUNT(*) > 1
GROUP BY CustomerId;WHERE evalúa las filas candidatas antes de que existan los grupos y sus cuentas. La condición corresponde al grupo, así que va en HAVING. Es una explicación lógica; los detalles de ejecución física son otro tema.
Combinar WHERE y HAVING
Una consulta puede filtrar filas de entrada, agrupar las restantes y filtrar esos grupos:
SELECT
CustomerId,
COUNT(*) AS OrderCount,
SUM(Amount) AS Amount
FROM dbo.Orders
WHERE Status = N'Complete'
GROUP BY CustomerId
HAVING SUM(Amount) >= 100
ORDER BY Amount DESC;La secuencia lógica es:
WHEREconserva los cuatro pedidosComplete.GROUP BYcrea un grupo por cliente entre esas filas.COUNTySUMcalculan las medidas de cada grupo.HAVINGconserva los grupos cuyo total completado alcanza 100.SELECTdevuelve las columnas de cliente, cuenta y total.ORDER BYordena los resultados por total descendente.
Los clientes 1 y 4 cumplen la condición: Ana tiene 3 pedidos Complete por un total de 250.49; David tiene uno de 199.00. Los pedidos completados de Ana son 125.50, 49.99 y 75.00. El otro pedido de David es Shipped, por lo que no llega a los grupos de esta consulta. WHERE cambia las filas que contribuyen a cada cuenta y suma; HAVING no elimina pedidos antes de calcular el agregado del grupo.
Regla práctica y alias
Usa WHERE para condiciones de cada fila, como Status = N'Complete' o Amount >= 100. Usa HAVING para condiciones de un grupo o agregado, como COUNT(*) > 1 o SUM(Amount) >= 100. Si una condición puede expresarse como filtro de fila, colocarla en WHERE suele comunicar mejor la intención: las filas que no interesan no entran en el agrupamiento. Es una regla práctica para elegir la cláusula, no una promesa sobre un plan de ejecución concreto.
No des por hecho que HAVING puede usar un alias creado en SELECT. En el orden lógico de la lección 5, HAVING se procesa antes de que SELECT cree sus alias. Escribe HAVING SUM(Amount) >= 100, no HAVING Amount >= 100 si Amount es el alias del agregado. ORDER BY, posterior a SELECT en este modelo lógico, sí puede usar el alias seleccionado.
SQL Server también permite HAVING en algunas consultas agregadas sin GROUP BY explícito; la entrada se trata como un solo grupo. Es un patrón menos habitual para principiantes. Por ahora, usa GROUP BY cuando necesites una fila por categoría y luego HAVING para conservar los grupos que cumplen la condición.
Leer cada condición en el nivel adecuado
Compara dos preguntas parecidas. «Conservar pedidos cuyo importe sea al menos 100» se refiere a cada pedido. Una fila cumple o no la condición, así que corresponde a WHERE. «Conservar clientes cuyo importe combinado de pedidos sea al menos 100» se refiere al total de un conjunto. Ningún pedido individual tiene que alcanzar 100; importa la suma del grupo. Por tanto, agrupa por cliente y filtra con HAVING.
Las dos preguntas pueden devolver algunos de los mismos clientes, pero no significan lo mismo. Supón que un cliente tiene dos pedidos de 60. WHERE Amount >= 100 elimina ambas filas y el cliente no aparece. Si agrupas los dos pedidos y aplicas HAVING SUM(Amount) >= 100, el cliente permanece porque el total combinado es 120. Los filtros responden preguntas de negocio distintas. Elige la cláusula según el significado, no según qué resultado parece conveniente en una prueba rápida.
WHERE admite comparaciones normales sobre columnas de entrada: una constante, un intervalo o una comprobación de NULL como IS NULL. No puede evaluar la cuenta o la suma final de un grupo porque ese resultado aún no existe. HAVING puede evaluar agregados y valores de agrupación. Al empezar, reserva HAVING para grupos y agregados. Aunque SQL Server permita algunas condiciones no agregadas ahí, trasladar un filtro corriente de fila a HAVING suele dificultar la lectura.
En el ejemplo combinado, cada agregado se calcula a partir de las filas que WHERE conserva. Si trasladaras Status = N'Complete' a HAVING, primero se agruparían todos los pedidos por cliente y luego se mantendría o eliminaría cada grupo según una condición de grupo. Eso no significa «solo los pedidos completados contribuyen». Si un cliente tiene pedidos completados y pendientes, ambos estados podrían contribuir al total, según cómo se definan los grupos y la condición. Filtrar la entrada en WHERE deja clara la población que se calcula.
La secuencia lógica también explica por qué un alias de salida no siempre está disponible en cualquier cláusula. En el modelo lógico, SELECT crea los nombres de salida después de WHERE, GROUP BY y HAVING. El alias Amount de SUM(Amount) es una etiqueta del resultado, no una columna de entrada; no permite usar el agregado en WHERE. Repite la expresión en HAVING para expresar claramente qué se comprueba. ORDER BY aparece después y sí puede usar un alias seleccionado.
Al revisar una consulta, describe en palabras la población y el sentido de cada grupo: «primero, solo pedidos Complete; después, un grupo por cliente; finalmente, conservar grupos cuyo total alcance 100». Si esa frase no coincide con las cláusulas, la consulta probablemente expresa otra pregunta. Esta lectura ayuda a detectar cambios accidentales al añadir filtros a un informe existente.
Una comprobación final consiste en comparar el detalle filtrado con el resultado agrupado. Si no está clara la población de entrada, ejecuta primero la parte WHERE como consulta de detalle y revisa qué CustomerId quedan antes de agregar. Después de añadir GROUP BY, comprueba la cuenta y la suma de un cliente conocido. Por ejemplo, los tres pedidos Complete de Ana son 125.50, 49.99 y 75.00, que suman 250.49. Esta pequeña comprobación confirma que el filtro de filas y el cálculo del grupo expresan el significado deseado. Resulta útil cuando la consulta acumula varias condiciones, porque una condición mal colocada puede producir SQL válido y aun así responder a otra pregunta.
Durante la inspección del filtro WHERE, también puedes conservar OrderId de forma temporal. Los identificadores ayudan a confirmar exactamente qué pedidos quedan antes de agrupar. Después, quítalos de la consulta resumen: mostrar OrderId y agrupar por cliente cambiaría el grano, porque cada pedido podría generar su propia fila. Las columnas de diagnóstico ayudan mientras verificas la consulta, pero el resultado final debe conservar solo el nivel de detalle que necesitas.
Errores frecuentes y práctica
No coloques condiciones agregadas en WHERE, no uses HAVING para un filtro normal de filas y no supongas que HAVING se procesa antes de GROUP BY. Recuerda que WHERE cambia las filas que alimentan cada agregado. Distingue el orden escrito del lógico y no supongas que un alias de SELECT existe antes de que se evalúe HAVING.
Practica con dbo.Orders: (1) cuenta por estado los pedidos inferiores a 100; (2) encuentra clientes con más de un pedido; (3) para Pending, muestra clientes cuyo total pendiente alcanza 100; (4) explica la diferencia entre filtrar cada Amount >= 100 en WHERE y exigir SUM(Amount) >= 100 en HAVING; (5) explica por qué WHERE COUNT(*) > 1 no es válido.
Respuestas
-- 1: Complete 2, Shipped 1, Pending 1
SELECT Status, COUNT(*) AS OrderCount FROM dbo.Orders
WHERE Amount < 100 GROUP BY Status;
-- 2: clientes 1, 4 y 7
SELECT CustomerId, COUNT(*) AS OrderCount FROM dbo.Orders
GROUP BY CustomerId HAVING COUNT(*) > 1;
-- 3: el cliente 2 suma 310.00
SELECT CustomerId, SUM(Amount) AS PendingTotal FROM dbo.Orders
WHERE Status = N'Pending' GROUP BY CustomerId
HAVING SUM(Amount) >= 100;Esta parte termina y continua con INSERT en el recorrido de cambios de datos. Consulta la hoja de ruta SQL Server Foundations para ver la siguiente etapa.
Comprueba lo que has aprendido
2 preguntas rápidas
Fundamentos de SQL Server
Lección 15 de 25
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Sigue aprendiendo
- Guía rápidaTipos de espera de SQL ServerUsa las estadísticas de espera de SQL Server para identificar en qué se está yendo el tiempo, distinguir las esperas actuales de las acumuladas y elegir la siguiente investigación de rendimiento.Abrir guía rápida
- ArtículoFunciones de agregado en SQL Server: COUNT, SUM, AVG, MIN y MAXAprende a resumir filas de SQL Server con COUNT, SUM, AVG, MIN y MAX usando Customers y Orders.Leer artículo
- Hoja de rutaSQL Server FoundationsAprende cuándo usar WHERE y HAVING en SQL Server: filtra filas antes de agrupar o grupos después de agregarlas.Ver hoja de ruta
¿Qué debería crear después?
Estoy construyendo Javi Builds alrededor de problemas reales que enfrentan los ingenieros de datos. Dime qué tema te gustaría ver después.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.