Funciones GROUP BY y Agregadas: Una visión completa

Las funciones GROUP BY y aggregate de SQL son esenciales para la agregación de datos, así como para el análisis de datos y la creación de informes. Explorémoslas juntos.

En SQL, GROUP BY y las funciones de agregación son una de las características más populares del lenguaje. La agregación de datos es fundamental para el análisis de datos y la creación de informes; para dar sentido a todos los datos de un conjunto de datos, a menudo es necesario agregarlos.

Pero, ¿qué es la agregación de datos? En pocas palabras, es cuando se agrupan datos basándose en valores comunes y se realiza un cálculo para cada grupo de datos. Por ejemplo, puede agrupar una lista de perros por su raza y, a continuación, utilizar un cálculo para averiguar la altura media de cada raza. Esta tarea es posible gracias a la cláusula GROUP BY y a la función de agregado AVG().

Si necesita refrescar sus conocimientos sobre GROUP BY, nuestro SQL para principiantes curso es ideal. Tiene 129 ejercicios interactivos que puedes terminar en unas 10 horas. Cubre temas como el filtrado de datos, el uso de operadores lógicos, la unión y el uso de operadores de conjunto.

La Sintaxis Básica de GROUP BY con Agregados

GROUP BY es una cláusula en SQL que ordena datos con los mismos valores en grupos. La agrupación se realiza por columna(s), donde todas las filas con el mismo valor en esa columna pertenecen a un grupo. A continuación, puede realizar cálculos de resumen (como contar, sumar o promediar valores) para cada grupo. Por ejemplo, puede utilizar GROUP BY para calcular el número de empleados de un departamento, el salario total o el salario medio por departamento, etc.

La sintaxis de GROUP BY con una función de agregado es:

SELECT column1, 
        column2, 
        ..., 
        aggregate_function(column_name)
FROM table_name
WHERE filtering_condition
GROUP BY column1, column2, …
HAVING filtering_condition;

La función agregada se escribe en la sentencia SELECT, y el resultado de la función se mostrará como una columna adicional.

La cláusula GROUP BY contiene las columnas por las que desea que se agrupe la salida. Esta cláusula se utiliza a menudo con las cláusulas WHERE y HAVING para filtrar. En la sintaxis, WHERE va antes que GROUP BY, mientras que HAVING va después. (Explicaré más sobre estas dos cláusulas más adelante.) Además, tus datos a veces contendrán NULLs, por lo que te interesará aprender cómo GROUP BY trata los NULLs.

En el siguiente GIF se muestra un ejemplo de GROUP BY en acción.

Este ejemplo básico agrupa los datos por director de cine y muestra el número de películas que ha hecho cada uno.

Funciones Agregadas de SQL

Las funciones agregadas de SQL se utilizan cuando se desea realizar cálculos sobre datos y devolver un único valor.

Las funciones agregadas más comunes en SQL son:

• COUNT() - Cuenta las filas de la columna indicada.
• SUM () - Devuelve la suma de todos los valores.
• AVG () - Calcula la media de un grupo de valores.
• MIN() - Devuelve el mínimo (el más bajo) de los valores dados.
• MAX() - Devuelve el máximo (el más alto) de los valores dados.

Consulte nuestras guías sobre cómo utilizar estas funciones para calcular agregados para toda la tabla:

• Cómo contar el número de filas de una tabla en SQL
• Cómo Contar Valores Distintos en SQL
• Cómo Sumar Valores de una Columna en SQL
• Cómo Encontrar la Media de una Columna Numérica en SQL
• Cómo Encontrar el Valor Máximo de una Columna en SQL
• Cómo Encontrar el Valor Mínimo de una Columna en SQL

Es importante notar que la función COUNT() tiene diferentes variaciones de uso:

• COUNT(*) cuenta todas las filas en un conjunto de resultados, incluyendo valores NULL y duplicados.
• COUNT(expression) cuenta los valores no NULL en un conjunto de resultados.
• COUNT(DISTINCT) cuenta los valores distintos e ignora los duplicados.

Hay más detalles en nuestra guía ¿Cuál es la diferencia entre COUNT(*), COUNT(1), COUNT(column) y COUNT(DISTINCT)?

Uso de GROUP BY con Funciones Agregadas SQL

Utilizaré la tabla albums para mostrar como las funciones agregadas y GROUP BY trabajan juntas. El script para crear la tabla está aquí.

Esta tabla contiene datos sobre álbumes musicales. Aquí tienes una captura:

id	artist	album	release_year	length	label
1	Grant Green	The Latin Bit	1963	0:38:56	Blue Note Records
2	AC/DC	High Voltage	1976	0:44:23	Atlantic Records
3	Brother Jack McDuff	To Seek a New Home	1970	0:33:12	Blue Note Records
4	Grant Green	Green Is Beautiful	1970	0:37:33	Blue Note Records
5	Wayne Shorter	Moto Grosso Feio	1974	0:42:22	Blue Note Records

Ejemplo 1: COUNT() con GROUP BY

He aquí un código de ejemplo que cuenta el número de álbumes por etiqueta:

SELECT label,
	 COUNT(*) AS number_of_albums
FROM albums
GROUP BY label; 

Selecciono la etiqueta y uso COUNT(*) para encontrar el número de álbumes. El asterisco (*) es una abreviatura para contar todas las filas. Cuando agrupe la salida por etiqueta, COUNT() mostrará el número de álbumes por etiqueta.

Este es el resultado:

label	number_of_albums
Atlantic Records	13
Blue Note Records	12
Stax Records	14

Lectura adicional:

• Guía detallada de la función COUNT() de SQL
• Explicación de la función SQL Count con 7 ejemplos
• Cómo contar el Número de Filas de una Tabla en SQL.
• ¿Cuál es la Diferencia entre COUNT(*), COUNT(1), COUNT(column) y COUNT(DISTINCT)?
• Cómo Contar Valores Distintos en SQL.

Ejemplo 2: SUM() con GROUP BY

El siguiente código suma las longitudes de los álbumes para mostrar el total de música disponible por artista:

SELECT artist,
	 SUM(length) AS total_music_available
FROM albums
GROUP BY artist;

La función SUM() se aplica a la columna length, y el resultado se agrupa por artista.

Este es el resultado del código:

artist	total_music_available
Isaac Hayes	6:30:02
Otis Redding	1:34:09
Brother Jack McDuff	1:58:11
Aretha Franklin	1:47:07
Grant Green	3:10:11
John Prine	1:21:57
Led Zeppelin	3:32:07
Wayne Shorter	2:38:02
Albert King	3:08:28
AC/DC	2:05:23

Más información:

• Explicación de la función SQL SUM() con 5 ejemplos prácticos
• Cómo Sumar Valores de una Columna en SQL

Ejemplo 3: AVG() con GROUP BY

Este código calcula la duración media de los álbumes de cada artista:

SELECT artist,
	 AVG(length) AS average_album_length
FROM albums
GROUP BY artist; 

Para obtener el resultado deseado, necesitas usar AVG() en la columna length y agrupar la salida por artist.

A continuación se muestra el resultado:

artist	average_album_length
Isaac Hayes	1:05:00
Otis Redding	0:31:23
Brother Jack McDuff	0:39:24
Aretha Franklin	0:35:42
Grant Green	0:38:02
John Prine	0:40:59
Led Zeppelin	0:42:25
Wayne Shorter	0:39:31
Albert King	0:37:42
AC/DC	0:41:48

Lectura adicional:

• La función SQL AVG() explicada con ejemplos
• Cómo hallar la media de una columna numérica en SQL

Ejemplo 4: MIN() y MAX() con GROUP BY

Vamos a encontrar la longitud más corta y más larga del álbum para cada año:

SELECT release_year,
	 MIN(length) AS minimum_album_length,
	 MAX(length) AS maximum_album_length
FROM albums
GROUP BY release_year
ORDER BY release_year; 

Como en ejemplos anteriores, las funciones agregadas se utilizan en la columna length; MIN() para el álbum más corto y MAX() para el más largo.

El resultado se agrupa por año de publicación.

También añadí la cláusula ORDER BY para ordenar la salida desde el año más antiguo al más reciente para que fuera más legible.

Este es el resultado del código:

release_year	minimum_album_length	maximum_album_length
1962	0:34:49	0:34:49
1963	0:38:56	0:38:56
1964	0:30:17	0:30:17
1965	0:32:22	0:42:45
1967	0:32:51	0:41:08
1968	0:29:30	0:29:30
1969	0:31:30	0:46:00
1970	0:33:12	0:43:04
1971	0:42:37	1:33:38
1972	0:37:50	0:44:46
1973	0:40:57	1:43:10
1974	0:42:22	0:46:00
1976	0:39:59	0:44:23
1977	0:41:01	0:41:01

Lectura adicional:

• Explicación de las funciones MIN y MAX de SQL en 6 ejemplos
• Cómo Encontrar el Valor Máximo de una Columna Numérica en SQL
• Cómo Encontrar el Valor Mínimo de una Columna en SQL

Técnicas Avanzadas de GROUP BY

La sección anterior trató los fundamentos del uso de las funciones agregadas de SQL y GROUP BY. Con estas bases establecidas, ahora podemos explorar algunas técnicas avanzadas de GROUP BY.

Filtrado de Resultados Agregados con HAVING

Para filtrar resultados agregados, es necesario utilizar la cláusula HAVING. Su sintaxis se muestra aquí:

SELECT column1, 
       column2, 
       ..., 
       aggregate_function(column_name)
FROM table_name
GROUP BY column1, column2, …
HAVING filtering_condition;

HAVING HAVING compara los valores agregados con la condición de filtrado y devuelve sólo los valores que satisfacen dicha condición. Puedes obtener más información en nuestro artículo sobre la cláusula HAVING.

Le mostraré un ejemplo. El siguiente código calcula la duración media de los álbumes por artista, pero sólo muestra aquellos cuya duración media es inferior a 40 minutos.

SELECT artist,
	 AVG(length) AS average_album_length
FROM albums
GROUP BY artist
HAVING AVG(length) < '00:40:00';

He utilizado la función AVG() igual que antes. La cláusula HAVING es nueva. Para filtrar los datos de la forma requerida, escribí en HAVING el mismo cálculo de la media que aparece en SELECT. A continuación, utilizo el operador de comparación 'less than' (<) para comparar cada resultado agrupado con un valor (en este caso, 40 minutos). Este valor va entre comillas simples (''). El valor entre comillas debe escribirse en el formato HH:MM:SS (horas:minutos:segundos) porque los valores de la columna length son del tipo de datos INTERVAL.

Este es el resultado:

artist	average_album_length
Otis Redding	0:31:23
Brother Jack McDuff	0:39:24
Aretha Franklin	0:35:42
Grant Green	0:38:02
Wayne Shorter	0:39:31
Albert King	0:37:42

El principio es el mismo independientemente de la función de agregado que utilices, pero aquí tienes los libros de recetas para ayudarte con algunas otras funciones:

• Cómo filtrar registros con la función agregada COUNT
• Cómo Filtrar Registros con la Función Agregada SUM
• Cómo filtrar registros con la función agregada AVG

Agrupación por Múltiples Columnas

Hasta ahora, he agrupado datos por una columna. Sin embargo, también es posible agrupar por dos o más columnas.

No es complicado: Sólo tienes que listar todas las columnas de agrupación en GROUP BY y separarlas con comas.

De este modo, agrupas por los valores de las columnas, pero también por la combinación de valores de todas las columnas de agrupación. Si tienes el valor A en la columna_1 y el valor B en la columna_2, esto es un grupo. Si, por ejemplo, hay valores A en la columna_1 con valor C en la columna_2, se formará otro grupo, a pesar de que los valores de la columna_1 sean los mismos que en el ejemplo anterior.

Ejemplo

El siguiente código muestra el número de álbumes del artista y el año de publicación:

SELECT artist,
	 release_year,
	 COUNT(*) AS number_of_albums
FROM albums
GROUP BY artist, release_year
ORDER BY artist, release_year;

Estoy utilizando COUNT(*) para encontrar el número de álbumes. La salida está agrupada por artista y año de lanzamiento. Como puede ver, esas son exactamente las columnas de GROUP BY y están separadas por una coma.

Para que la salida sea más legible, he ordenado los datos por artista alfabéticamente y desde el año de lanzamiento más antiguo al más reciente.

Este es el resultado:

artist	release_year	number_of_albums
AC/DC	1976	2
AC/DC	1977	1
Albert King	1962	1
Albert King	1967	1
Albert King	1969	1
Albert King	1972	1
Albert King	1974	1
Aretha Franklin	1967	1
Aretha Franklin	1968	1
Aretha Franklin	1972	1
Brother Jack McDuff	1969	2
Brother Jack McDuff	1970	1

Dos funciones agregadas en una consulta

También es posible escribir una consulta que tenga dos funciones agregadas. No, no es lo que piensas: no escribes una función agregada dentro de otra. Eso no es posible en SQL.

Dos funciones agregadas en una consulta pueden significar dos cosas:

1. Un planteamiento sencillo: Usar dos funciones agregadas en dos columnas del mismo SELECT.
2. Enfoque avanzado: Usar el resultado de una función agregada en otra función agregada.

Una Consulta, Dos Funciones Agregadas: Enfoque simple

El enfoque simple es cuando se tienen dos funciones agregadas en dos columnas agregadas diferentes en un mismo SELECT. Pueden ser la misma función aplicada en diferentes columnas, diferentes funciones usadas en la misma columna, o diferentes funciones usadas en diferentes columnas. Realmente no importa; el punto es que tienes dos agregaciones en una consulta. Estas agregaciones no se "comunican", es decir, no dependen la una de la otra en modo alguno.

Ejemplo

En el ejemplo, utilizaré la tabla package_deliveries con el script enlazado aquí.

La tabla muestra información sobre el número de paquetes entregados diariamente en varias ciudades.

Aquí están las seis primeras filas de la tabla:

id	date_of_delivery	number_of_packages	city_of_delivery	country_of_delivery
1	2024-03-01	49	Krakow	Poland
2	2024-03-01	528	Warsaw	Poland
3	2024-03-01	158	Gdansk	Poland
4	2024-03-01	28	Rijeka	Croatia
5	2024-03-01	97	Split	Croatia
6	2024-03-01	64	Zagreb	Croatia

El código siguiente calcula el número total y medio de paquetes por ciudad.

SELECT city_of_delivery,
	 SUM(number_of_packages) AS total_number_of_packages,
	 AVG(number_of_packages) AS average_number_of_packages
FROM package_deliveries
GROUP BY city_of_delivery;

Puedes ver que la consulta tiene dos agregados: uno con SUM() y otro con AVG(). Realmente no importa cuántas funciones agregadas escribas en la consulta. Lo único importante es que cada agregación se trate como una línea de código o columna de salida independiente.

He aquí el resultado:

city_of_delivery	total_number_of_packages	average_number_of_packages
Split	531	177.00
Izmir	5,936	1,978.67
Ankara	9,139	3,046.33
Gdansk	712	237.33
Rijeka	627	209.00
Zagreb	930	310.00
Istanbul	13,857	4,619.00
Krakow	673	224.33
Warsaw	2,358	786.00

Una consulta, dos funciones agregadas: El enfoque avanzado

La versión avanzada es cuando las agregaciones 'se comunican', lo que significa que primero necesita encontrar un valor agregado y luego usarlo para calcular otro valor agregado. Típicamente, esto se logra a través de subconsultas o Expresiones de Tabla Comunes (CTEs).

Le mostraré el uso de subconsultas en el siguiente ejemplo. Nuestra guía sobre la combinación de dos funciones agregadas en GROUP BY cubre ambos enfoques.

Ejemplo

El siguiente código devuelve el número medio diario de paquetes entregados en cada país:

SELECT country_of_delivery,
	 AVG(pd.daily_number_of_packages) AS average_daily_number_of_packages
FROM (SELECT date_of_delivery, 
	       country_of_delivery,
	 	 SUM(number_of_packages) AS daily_number_of_packages
	FROM package_deliveries
	GROUP BY date_of_delivery, country_of_delivery) AS pd
GROUP BY country_of_delivery;

Primero necesito encontrar el número de paquetes entregados diariamente en cada país, que es la primera agregación. La segunda agregación utiliza este resultado y calcula la media diaria por país.

La primera agregación se escribe en la subconsulta. Utiliza la función SUM() y lista las columnas date_of_delivery y country_of_delivery en SELECT. El resultado se agrupa por las mismas columnas.

Ahora puedo escribir la consulta principal, haciendo referencia en AVG() a la columna daily_number_of_packages de la subconsulta. Agrupo la salida por país y obtengo el número medio diario de paquetes entregados para cada país.

country_of_delivery	average_daily_number_of_packages
Turkey	9,644.00
Croatia	696.00
Poland	1,247.67

GROUP BY con agregados condicionales

La sentencia CASE o CASE WHEN etiqueta los datos en función de sus valores. Esta sentencia también se puede utilizar con GROUP BY.

Agrupar datos mediante agregados condicionales significa utilizar CASE WHEN con GROUP BY. Sin embargo -y esto es importante- el CASE WHEN que escriba en SELECT también tiene que aparecer en GROUP BY.

Ejemplo

Utilizando la tabla del ejemplo anterior, puedo escribir un código que clasifique los países en países de la UE y países no pertenecientes a la UE y muestre el número total de paquetes entregados para cada categoría:

SELECT
  CASE 
   WHEN country_of_delivery = 'Turkey' THEN 'Non-EU'
   ELSE 'EU'
  END,
  SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY CASE 
   WHEN country_of_delivery = 'Turkey' THEN 'Non-EU'
   ELSE 'EU'
  END;

La condición CASE dice que Turquía debe categorizarse como país no perteneciente a la UE. Esta condición se indica en WHEN. La categoría para todos los demás países es UE, que se escribe en ELSE.

La sentencia CASE comienza con CASE (de ahí su nombre) y termina con la palabra clave END.

Utilizo la función SUM() para calcular el número total de paquetes. Para mostrar este valor por categoría, simplemente copio toda la sentencia CASE WHEN en GROUP BY.

Este es el resultado:

case	total_number_of_packages
Non-EU	28,932
EU	5,831

Si necesita más ejemplos para entender esto completamente, lea una de nuestras guías:

• Como Usar CASE WHEN con SUM() en SQL
• Cómo usar CASE WHEN en GROUP BY

Extensiones de GROUP BY: ROLLUP, CUBO, AGRUPAR CONJUNTOS

Las tres extensiones de SQL GROUP BY son:

• ROLLUP - Crea una fila resumen para los grupos listados en GROUP BY.
• CUBE - Crea subtotales para todas las combinaciones de los grupos en GROUP BY.
• GROUPING SETS - Agrega la salida en múltiples niveles.

En el ejemplo, le mostraré cómo funciona GROUPING SETS. Puede aprender cómo funcionan las otras dos extensiones en nuestra guía de extensiones GROUP BY.

Ejemplo

El siguiente código devuelve el número de paquetes entregados por país y por fecha:

SELECT country_of_delivery,
	 date_of_delivery,
	 SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY GROUPING SETS(country_of_delivery, date_of_delivery)
ORDER BY country_of_delivery, date_of_delivery;

Empiezo utilizando SUM() para calcular el número de paquetes.

En GROUP BY, escribo GROUPING SETS con todos los niveles de agregación dentro de los paréntesis.

El resultado muestra el número de paquetes entregados por país y por fecha de entrega:

country_of_delivery	date_of_delivery	total_number_of_packages
Croatia	NULL	2,088
Poland	NULL	3,743
Turkey	NULL	28,932
NULL	2024-03-01	2,730
NULL	2024-03-02	11,208
NULL	2024-03-03	20,825

Puede ser útil pensar en los conjuntos de agrupación como dos consultas separadas. La primera consulta agrupa por país ...

SELECT country_of_delivery,
       NULL AS date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery
ORDER BY country_of_delivery;

... y devuelve las tres primeras filas del resultado anterior:

country_of_delivery	date_of_delivery	total_number_of_packages
Croatia	NULL	2,088
Poland	NULL	3,743
Turkey	NULL	28,932

La segunda consulta agrupa por fecha de entrega ...

SELECT NULL AS country_of_delivery,
       date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY date_of_delivery
ORDER BY date_of_delivery;

... y devuelve las otras tres filas del resultado original:

country_of_delivery	date_of_delivery	total_number_of_packages
NULL	2024-03-01	2,730
NULL	2024-03-02	11,208
NULL	2024-03-03	20,825

En otras palabras, si combina estas dos consultas de agrupación por separado utilizando UNION...

SELECT country_of_delivery,
       NULL AS date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery

UNION 

SELECT NULL AS country_of_delivery,
       date_of_delivery,
       SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY date_of_delivery
ORDER BY country_of_delivery, date_of_delivery;

... se obtiene exactamente el mismo resultado que con GROUPING SETS.

country_of_delivery	date_of_delivery	total_number_of_packages
Croatia	NULL	2,088
Poland	NULL	3,743
Turkey	NULL	28,932
NULL	2024-03-01	2,730
NULL	2024-03-02	11,208
NULL	2024-03-03	20,825

Errores comunes al utilizar GROUP BY

Confundir ORDER BY y GROUP BY

A menudo se trata de una cuestión de desconocimiento de lo que hace GROUP BY.

Permítame demostrárselo con un ejemplo.

Digamos que desea encontrar el número total de paquetes por país de entrega.

Si no está familiarizado con GROUP BY, podría escribir una solución ingenua utilizando ORDER BY.

SELECT date_of_delivery,
	 city_of_delivery,
	 country_of_delivery
FROM package_deliveries
ORDER BY country_of_delivery;

Ahora que tienes los datos ordenados por país, como se muestra en la siguiente imagen, decides sumar manualmente los valores para obtener el resultado por país.

date_of_delivery	city_of_delivery	country_of_delivery
2024-03-01	Rijeka	Croatia
2024-03-01	Split	Croatia
2024-03-01	Zagreb	Croatia
2024-03-02	Rijeka	Croatia
2024-03-02	Split	Croatia
2024-03-02	Zagreb	Croatia
2024-03-03	Zagreb	Croatia
2024-03-03	Split	Croatia
2024-03-03	Rijeka	Croatia
2024-03-01	Krakow	Poland
2024-03-01	Warsaw	Poland

Pero, ¿por qué hacer manualmente algo que GROUP BY hace automáticamente? En lugar de ordenar los datos por país, deberías agruparlos por él y utilizar SUM() para sumar los datos:

SELECT country_of_delivery,
	 SUM(number_of_packages) AS total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery
ORDER BY country_of_delivery;

Obtendrás inmediatamente el resultado que necesitas:

country_of_delivery	total_number_of_packages
Croatia	2,088
Poland	3,743
Turkey	28,932

Lee más sobre las diferencias entre GROUP BY y ORDER BY y cómo usar GROUP BY y ORDER BY juntos.

Confundir WHERE y HAVING

Otro error común es tratar de filtrar valores agregados usando WHERE. Eso no es posible - WHERE se utiliza para filtrar filas individuales antes de la agregación. En cambio, HAVING sirve para filtrar grupos de filas después de la agregación.

Ejemplo

Si desea obtener el número medio de paquetes entregados diariamente por ciudad y mostrar sólo aquellos con más de 500 paquetes, puede decidir escribir esta consulta:

SELECT city_of_delivery,
	 AVG(number_of_packages) AS average_number_of_packages
FROM package_deliveries
WHERE AVG(number_of_packages) > 500
GROUP BY city_of_delivery;

Devolverá un error porque WHERE no acepta una función de agre gación como argumento. (Esto no significa que nunca pueda utilizar WHERE con GROUP BY; puede hacerlo, pero no para filtrar grupos).

En este caso, debe utilizar HAVING:

SELECT city_of_delivery,
	 AVG(number_of_packages) AS average_number_of_packages
FROM package_deliveries
GROUP BY city_of_delivery
HAVING AVG(number_of_packages) > 500;

Es la misma consulta con AVG() y GROUP BY. La única diferencia es HAVING, donde se compara el cálculo de AVG() con 500.

El resultado muestra sólo las ciudades cuya media diaria es superior a 500.

city_of_delivery	average_number_of_packages
Izmir	1,978.67
Ankara	3,046.33
Istanbul	4,619.00
Warsaw	786.00

Obtenga más información sobre este tema en el artículo sobre HAVING vs. WHERE.

Listado de columnas no agregadas en SELECT pero no en WHERE

La regla simple que debe recordar es que cualquier columna no agregada que escriba en SELECT también debe incluirse en GROUP BY. Si no lo hace, la base de datos no sabrá qué valor mostrar si hay varios valores diferentes dentro del mismo grupo.

Ejemplo

Por ejemplo, usted escribe la consulta que debe calcular el número total de envases por país y por ciudad.

SELECT country_of_delivery,
       city_of_delivery,
	 SUM(number_of_packages) total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery;

Claro, tienes el país y la ciudad en SELECT, pero olvidaste poner la ciudad en GROUP BY. Esta consulta no se ejecutará. Devolverá un error. Aunque los mensajes están redactados de forma diferente en PostgreSQL, Oracle y otras bases de datos, su mensaje es el mismo: la columna city_of_delivery debe aparecer en GROUP BY.

Incluso si se ejecutara, la base de datos se confundiría. Pensaría algo así: "¿Quieres mostrar ciudades pero no quieres agrupar por ciudades? ¿Cómo voy a saber qué ciudad mostrar en la salida cuando cada país tiene tres? Por favor, pon las ciudades en GROUP BY para que pueda mostrar cada ciudad como un grupo separado".

Entonces, lo ayudas incluyendo la ciudad de entrega en GROUP BY:

SELECT country_of_delivery,
       city_of_delivery,
	 SUM(number_of_packages) total_number_of_packages
FROM package_deliveries
GROUP BY country_of_delivery, city_of_delivery;

Sí, se trata de agrupar por dos columnas y ya has aprendido a hacerlo. Aquí tienes la salida de la consulta:

country_of_delivery	city_of_delivery	total_number_of_packages
Croatia	Zagreb	930
Croatia	Rijeka	627
Croatia	Split	531
Turkey	Istanbul	13,857
Poland	Warsaw	2,358
Poland	Krakow	673
Turkey	Ankara	9,139
Poland	Gdansk	712
Turkey	Izmir	5,936

Otros errores

También hay otros errores, como olvidar GROUP BY con funciones agregadas o no agrupar por una clave única. Estos y otros más están cubiertos en este artículo sobre errores comunes de GROUP BY.

Otros Recursos SQL GROUP BY

Después de leer este resumen de la cláusula SQL GROUP BY, deberías tener una idea de sus usos y desafíos. Pero si quieres dominar GROUP BY, necesitarás entrar en más detalles.

La mejor forma de hacerlo es consultando algunos de nuestros cursos y libros de recetas. Éstas son algunas de mis sugerencias para seguir aprendiendo:

• Cómo crear informes básicos con SQL - Este curso de nivel intermedio se centra en los matices del uso de GROUP BY - agrupación por varias columnas, uso de HAVING, combinación de GROUP BY con CASE WHEN, diferencia entre COUNT(*) y COUNT(id), etc.

• Modificadores de GROUP BY en SQL - Este curso cubre CUBE, ROLLUP, y GROUPING SETS.

• Ejercicio de SQL - Los cursos de este track tienen secciones dedicadas a diferentes temas de SQL, incluyendo bastante práctica de GROUP BY.

Y no te olvides de nuestros artículos con ejemplos de GROUP BY. Dos de mis favoritos son Ejercicio de SQL: 10 Ejercicios Prácticos GROUP BY con Soluciones Detalladas y Top 9 Preguntas de Entrevista SQL GROUP BY.

Además de eso, hay una hoja de trucos de SQL para análisis de datos, que tiene una sección dedicada a GROUP BY.

¡Feliz aprendizaje!