SQL Server

GROUP BY explicado en SQL Server

Aprende a crear una fila resumen por estado, cliente o combinación de valores con GROUP BY en SQL Server.

Por JaviPublicado 13 min de lecturaPrincipiante

En la lección anterior, COUNT y SUM resumían todas las filas de entrada en una sola fila. Pero muchas preguntas necesitan más detalle: ¿cuántos pedidos hay por estado, o cuánto ha gastado cada cliente? Los agregados responden «¿cuál es el total?». GROUP BY responde «¿cuál es el total para cada grupo?». Cambia el grano del resultado: lo que representa una fila.

Una fila por estado

La base de demostración contiene ocho pedidos y cuatro estados: Complete, Pending, Shipped y Processing. Agrupemos por estado y contemos las filas:

Consulta SQL: Una fila por estadoT-SQL
SELECT
    Status,
    COUNT(*) AS OrderCount
FROM dbo.Orders
GROUP BY Status;
T-SQL5 líneasVista de solo lectura. No está conectada a ninguna base de datos.

SQL Server coloca en el mismo grupo las filas con igual Status y devuelve una fila por cada valor distinto. Complete tiene 4 pedidos, Pending tiene 2, Shipped tiene 1 y Processing tiene 1. El resultado tiene cuatro filas, no ocho: cada fila representa un grupo de estado. Si no añades ORDER BY, SQL Server no garantiza el orden mostrado.

  1. Orders: 8 filas
  2. GROUP BY Status
  3. Complete: 4
  4. Pending: 2
  5. Shipped: 1
  6. Processing: 1
GROUP BY Status crea una fila por cada valor de estado

Calcular un agregado para cada grupo

GROUP BY suele combinarse con funciones de agregado. Esta consulta calcula el valor total de los pedidos de cada estado:

Consulta SQL: Calcular un agregado para cada grupoT-SQL
SELECT
    Status,
    SUM(Amount) AS TotalSales
FROM dbo.Orders
GROUP BY Status;
T-SQL5 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Los totales conocidos son 449.49 para Complete, 335.00 para Pending, 82.75 para Shipped y NULL para Processing, cuyo ?nico Amount se desconoce. La función se calcula por separado para cada grupo. COUNT(*) cuenta sus filas y SUM(Amount) suma sus importes. Los valores proceden de las ocho filas de dbo.Orders; SUM ignora el Amount NULL del grupo Processing.

También puedes agrupar por cliente para obtener una fila por cliente con al menos un pedido:

Consulta SQL: Calcular un agregado para cada grupo (2)T-SQL
SELECT
    CustomerId,
    COUNT(*) AS OrderCount,
    SUM(Amount) AS Amount
FROM dbo.Orders
GROUP BY CustomerId;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

La consulta devuelve cuatro filas, para CustomerId 1, 2, 4 y 7. Ana (1) tiene 3 pedidos y suma 250.49; Ben (2) tiene 1 de 310.00; David (4) tiene 2 que suman 281.75; Grace (7) tiene 2 pedidos; sus importes conocidos suman 25.00. Los clientes sin pedidos no aparecen porque ninguna fila de Orders forma su grupo.

Incluir clientes sin pedidos

Para informar también de clientes sin pedidos, empieza en Customers y usa LEFT JOIN:

Consulta SQL: Incluir clientes sin pedidosT-SQL
SELECT
    c.CustomerId,
    c.FirstName,
    c.LastName,
    COUNT(o.OrderId) AS OrderCount,
    SUM(o.Amount) AS Amount
FROM dbo.Customers AS c
LEFT JOIN dbo.Orders AS o
    ON c.CustomerId = o.CustomerId
GROUP BY
    c.CustomerId,
    c.FirstName,
    c.LastName;
T-SQL13 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Las columnas del cliente aparecen en GROUP BY porque identifican la fila que queremos para cada cliente. COUNT(o.OrderId) cuenta los pedidos coincidentes y devuelve cero si no hay ninguno: OrderId queda NULL tras la unión y COUNT(columna) ignora NULL. SUM(o.Amount) devuelve NULL para ese cliente, ya que no hay importes no NULL que sumar. Si el informe debe mostrar cero, COALESCE(SUM(o.Amount), 0) sustituye ese resultado NULL por cero. COALESCE devuelve la primera expresión no NULL; no cambia los datos originales.

Regla práctica: una expresión seleccionada que no esté agregada generalmente debe formar parte de GROUP BY. SQL Server necesita saber qué valor mostrar para cada grupo. Seleccionar un nombre de cliente agrupando solo por Status sería ambiguo, pues un grupo puede contener varios clientes. Agrupa las columnas que definen la fila resumen que necesitas.

Elegir el grano antes que las columnas

Antes de escribir la consulta, expresa qué debe representar una fila. El grano del resultado, tratado también en la lección sobre filas repetidas tras JOIN, puede ser una fila por estado (GROUP BY Status), por cliente (GROUP BY CustomerId y atributos mostrados) o por cliente y estado (GROUP BY CustomerId, Status).

Agrupar por varias columnas crea grupos de combinaciones:

Consulta SQL: Elegir el grano antes que las columnasT-SQL
SELECT
    Status,
    CustomerId,
    COUNT(*) AS OrderCount
FROM dbo.Orders
GROUP BY
    Status,
    CustomerId;
T-SQL8 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Ahora cada fila representa una combinación concreta de cliente y estado. Si un cliente tiene pedidos con dos estados, puede aparecer en dos filas. Añadir una columna al agrupamiento hace más fino el grano y suele aumentar el número de grupos. Agrupar por pocas columnas puede mezclar hechos que debían quedar separados; agrupar por demasiadas puede fragmentar el resumen en muchas filas pequeñas.

GROUP BY, DISTINCT y ordenación

DISTINCT elimina combinaciones duplicadas de las columnas seleccionadas. GROUP BY forma grupos y se usa normalmente para calcular agregados por grupo. Una consulta que seleccione solo Status con DISTINCT puede enumerar los estados; una consulta agrupada con COUNT(*) también puede contar sus pedidos. Se parecen en algunos resultados sencillos, pero no son intercambiables en todos los casos.

Para ordenar un resumen, añade ORDER BY:

Consulta SQL: GROUP BY, DISTINCT y ordenaciónT-SQL
SELECT
    Status,
    SUM(Amount) AS Amount
FROM dbo.Orders
GROUP BY Status
ORDER BY Amount DESC;
T-SQL6 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Los tres totales quedan ordenados de mayor a menor. ORDER BY cambia el orden de presentación, no los grupos.

Razonar una consulta agrupada

Empieza por la pregunta, no por una lista de columnas. Define primero el grano: por ejemplo, una fila por cliente. Después identifica la clave que lo define, como CustomerId. Decide qué medidas necesitas para cada clave: cantidad de pedidos, importe total o ambas. Por último, determina si debes filtrar la entrada o conservar clientes sin pedidos. Este orden de decisiones reduce el riesgo de añadir columnas que cambien el significado de cada fila.

En un resumen por estado, Status es la clave de agrupación y cada fila representa un estado. Para totales por cliente, la clave es CustomerId. El nombre describe esa clave; si se selecciona, incluye las columnas del nombre en el agrupamiento para que SQL Server sepa qué valor mostrar por grupo. CustomerId es único en los datos de demostración, así que FirstName y LastName identifican el mismo cliente dentro de cada grupo. En otros modelos, no des por hecho que una columna está vinculada a una clave si el esquema no lo garantiza.

Puedes comprobar el resultado agrupado contra los datos originales. Las cuentas por estado deben sumar los ocho pedidos: 4 + 2 + 1 + 1 = 8. Los totales deben sumar 867.24: 449.49 + 335.00 + 82.75 = 867.24. Es una comprobación útil con este conjunto pequeño. Si no coinciden, revisa WHERE, las relaciones de JOIN y las columnas de agrupación. Que cada cifra parezca razonable no demuestra que la consulta incluyera las filas correctas.

LEFT JOIN cambia los datos disponibles para agrupar. Conserva todos los clientes y aporta NULL en las columnas del pedido cuando no hay coincidencia. COUNT(o.OrderId) cuenta identificadores de pedido reales; COUNT(*) también cuenta la fila de cliente preservada. Para un cliente sin pedidos, los resultados difieren: cero frente a uno. SUM sobre el lado de pedidos ausente devuelve NULL porque no hay importes no NULL. Usa COALESCE solo si cero es el valor de presentación apropiado. «No hay total registrado» y «el total conocido es cero» no siempre significan lo mismo.

Las columnas de agrupación deben coincidir con el nivel de detalle de la pregunta. Si añades OrderDate a un resumen por cliente, se crea un grupo por cliente y fecha y deja de ser una fila por cliente. FirstName suele ser redundante si CustomerId identifica al cliente, pero debe aparecer en GROUP BY si se selecciona. No agrupes por una medida como Amount solo porque aparece en la salida: separarías en grupos distintos los pedidos con importes diferentes de un mismo cliente.

DISTINCT y GROUP BY pueden producir una lista de estados únicos en consultas sencillas, pero considera el uso posterior. Si solo necesitas etiquetas únicas, DISTINCT expresa la intención directamente. Si necesitas cuentas o totales por etiqueta, GROUP BY define los grupos sobre los que se calculan. Ninguna opción corrige una clave de JOIN errónea ni un grano confuso. Define primero qué significa cada fila y luego elige la operación que lo expresa.

Una costumbre útil es redactar una frase antes de la consulta: «una fila por cliente, con la cantidad y el total de sus pedidos». Tras ejecutarla, compara esa intención con las columnas obtenidas y revisa un caso conocido en las tablas. Ana debe tener tres pedidos por un total de 250.49. Si aparece en varias filas cuando el informe prometía una por cliente, quizá añadiste una columna que afinó el grano. Si no aparece, comprueba si la consulta parte de Customers cuando también deben conservarse los clientes sin pedidos.

Errores frecuentes y práctica

Evita seleccionar una columna no agregada que no aparezca en GROUP BY, agrupar por demasiadas o muy pocas columnas y perder de vista el grano. No uses GROUP BY solo para ocultar valores repetidos de una unión: decide primero si necesitas detalle o resumen. Con LEFT JOIN, cuenta una clave opcional del lado derecho, por ejemplo COUNT(o.OrderId), y no COUNT(*): la fila del cliente se conserva aunque no tenga pedido. La suma será NULL salvo que uses COALESCE. Consulta el comportamiento de LEFT JOIN para elegir qué lado conservar.

Practica con los datos: (1) cuenta pedidos por estado; (2) suma ventas por estado; (3) cuenta y suma por cliente; (4) muestra todos los clientes, incluso los que no tienen pedidos, con su cuenta; (5) describe el grano de una consulta agrupada por Status y CustomerId.

Respuestas

Consulta SQL: RespuestasT-SQL
-- 1: Complete 4, Pending 2, Shipped 1, Processing 1
SELECT Status, COUNT(*) AS OrderCount FROM dbo.Orders GROUP BY Status;
-- 2: Complete 449.49, Pending 335.00, Shipped 82.75, Processing NULL
SELECT Status, SUM(Amount) AS Sales FROM dbo.Orders GROUP BY Status;
-- 3: una fila por cliente con pedidos
SELECT CustomerId, COUNT(*) AS OrderCount, SUM(Amount) AS Amount
FROM dbo.Orders GROUP BY CustomerId;
-- 4: diez filas, incluidos seis clientes sin pedidos
SELECT c.CustomerId, COUNT(o.OrderId) AS OrderCount
FROM dbo.Customers AS c LEFT JOIN dbo.Orders AS o ON c.CustomerId = o.CustomerId
GROUP BY c.CustomerId;
T-SQL11 líneasVista de solo lectura. No está conectada a ninguna base de datos.

Una vez que existen los grupos, surge la pregunta de cómo filtrarlos. Continúa con WHERE frente a HAVING para distinguir entre filtrar filas de entrada y filtrar grupos.

La hoja de ruta Foundations muestra el recorrido completo para principiantes y las lecciones disponibles.

Comprueba lo que has aprendido

2 preguntas rápidas

Pregunta 1 de 2¿Qué hace GROUP BY con las filas?
Pregunta 2 de 2¿Qué suele incluirse en SELECT al agrupar por una columna?

Fundamentos de SQL Server

Lección 14 de 25

Continuar a la siguiente lección

WHERE frente a HAVING en SQL Server

Continuar a la lección 15

Etiquetas

  • SQL Server
  • Fundamentos de SQL
  • SSMS
  • T-SQL