SQL Academy · Lección

CUBE para todas las combinaciones

Todas las combinaciones de agrupación a la vez

CUBE para todas las combinaciones es una lección gratuita de SQL Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de SQL Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de SQL Academy incluye 4 lecciones en total.

¿Qué es CUBE?

La extensión CUBE de SQL genera todas las combinaciones posibles de agrupación a partir de una lista de columnas. Mientras que ROLLUP crea una jerarquía, CUBE produce un producto cartesiano completo de subtotales, incluido el total general.

Considérelo como si respondiera: «Deme todos los subtotales que pueda calcular a partir de estas columnas».

Configuración de la tabla

Usaremos una tabla de sales que registra los ingresos por año, región y categoría de producto. Este tipo de datos multidimensionales es donde CUBE destaca.

CREATE TABLE sales (
  year     INT,
  region   VARCHAR(20),
  category VARCHAR(20),
  revenue  NUMERIC(10,2)
);

INSERT INTO sales VALUES
  (2023, 'North', 'Electronics', 12000),
  (2023, 'North', 'Clothing',     8000),
  (2023, 'South', 'Electronics',  9500),
  (2023, 'South', 'Clothing',     6000),
  (2024, 'North', 'Electronics', 14000),
  (2024, 'North', 'Clothing',     9500),
  (2024, 'South', 'Electronics', 11000),
  (2024, 'South', 'Clothing',     7200);

Su primera consulta CUBE

La sintaxis es sencilla: sustituya GROUP BY por GROUP BY CUBE(...) y enumere dentro las columnas. SQL generará todas las combinaciones de esas columnas como conjuntos de agrupación.

SELECT
  year,
  region,
  category,
  SUM(revenue) AS total_revenue
FROM sales
GROUP BY CUBE(year, region, category)
ORDER BY year, region, category;

¿Cuántas agrupaciones produce CUBE?

Para n columnas, CUBE produce 2ⁿ conjuntos de agrupación, uno por cada subconjunto de la lista de columnas, incluido el conjunto vacío (el total general).

Con 3 columnas (year, region, category), eso equivale a 2³ = 8 conjuntos de agrupación: cada columna por separado, cada par, las tres juntas y ninguna.

-- 3 columns => 8 grouping sets:
-- (year, region, category)
-- (year, region)
-- (year, category)
-- (region, category)
-- (year)
-- (region)
-- (category)
-- () <- grand total
SELECT COUNT(*) AS row_count
FROM (
  SELECT year, region, category, SUM(revenue)
  FROM sales
  GROUP BY CUBE(year, region, category)
) sub;

Los NULL marcan la dimensión resumida

Al igual que ROLLUP, CUBE utiliza NULL para indicar que se ha agregado una columna. Si region es NULL en una fila del resultado, esa fila resume todas las regiones para esa combinación de las columnas restantes.

Utilice GROUPING(col) para distinguir un valor NULL real de un marcador de agregación.

SELECT
  GROUPING(year)     AS g_year,
  GROUPING(region)   AS g_region,
  GROUPING(category) AS g_category,
  year,
  region,
  category,
  SUM(revenue) AS total_revenue
FROM sales
GROUP BY CUBE(year, region, category)
ORDER BY g_year, g_region, g_category;

Hacer legibles los NULL con COALESCE

Para que el resultado sea más legible en los informes, envuelva cada columna agrupada en COALESCE y sustituya el NULL de agregación por una etiqueta descriptiva como 'ALL'.

SELECT
  COALESCE(CAST(year AS VARCHAR), 'ALL YEARS')     AS year,
  COALESCE(region,   'ALL REGIONS')                AS region,
  COALESCE(category, 'ALL CATEGORIES')             AS category,
  SUM(revenue)                                     AS total_revenue
FROM sales
GROUP BY CUBE(year, region, category)
ORDER BY year, region, category;

CUBE frente a ROLLUP: diferencia clave

ROLLUP(a, b, c) solo crea subtotales siguiendo una jerarquía: (a,b,c), (a,b), (a), (). Respeta el orden de izquierda a derecha.

CUBE(a, b, c) crea todos los subconjuntos, incluidas combinaciones cruzadas como (a,c) o (b) por separado, que ROLLUP omite por completo. Utilice CUBE cuando necesite un análisis multidimensional completo sin una jerarquía predeterminada.

-- ROLLUP: 4 grouping sets
SELECT year, region, SUM(revenue)
FROM sales
GROUP BY ROLLUP(year, region);

-- CUBE: 4 grouping sets for 2 columns (same count here)
-- but adds the (region) subtotal that ROLLUP omits
SELECT year, region, SUM(revenue)
FROM sales
GROUP BY CUBE(year, region);

CUBE parcial

Puede combinar columnas normales de GROUP BY con una sublista de CUBE. Las columnas indicadas fuera de CUBE(...) siempre están presentes en cada conjunto de agrupación, mientras que solo las columnas incluidas reciben el tratamiento de todas las combinaciones.

-- year is fixed; CUBE only over region and category
SELECT
  year,
  COALESCE(region,   'ALL REGIONS')    AS region,
  COALESCE(category, 'ALL CATEGORIES') AS category,
  SUM(revenue) AS total_revenue
FROM sales
GROUP BY year, CUBE(region, category)
ORDER BY year, region, category;

Filtrado con HAVING en resultados de CUBE

HAVING funciona con el resultado de CUBE exactamente igual que con un GROUP BY normal. Puede filtrar las filas de agrupación cuyo valor agregado no alcance un umbral; por ejemplo, conservar solo las filas donde los ingresos totales superen un mínimo.

SELECT
  COALESCE(region,   'ALL REGIONS')    AS region,
  COALESCE(category, 'ALL CATEGORIES') AS category,
  SUM(revenue) AS total_revenue
FROM sales
GROUP BY CUBE(region, category)
HAVING SUM(revenue) > 15000
ORDER BY total_revenue DESC;

Combinación de CUBE con funciones de ventana

Puede encapsular una consulta con CUBE en una CTE y, después, aplicar funciones de ventana para ordenar o comparar las filas del resultado. Este es un patrón muy eficaz para crear paneles ejecutivos.

WITH cube_result AS (
  SELECT
    COALESCE(region,   'ALL') AS region,
    COALESCE(category, 'ALL') AS category,
    SUM(revenue) AS total_revenue
  FROM sales
  GROUP BY CUBE(region, category)
)
SELECT
  region,
  category,
  total_revenue,
  RANK() OVER (ORDER BY total_revenue DESC) AS revenue_rank
FROM cube_result
ORDER BY revenue_rank;

Cuándo elegir CUBE

CUBE es la herramienta adecuada cuando:

Necesita todas las combinaciones de subtotales para un informe ad hoc o de estilo OLAP.
No existe una jerarquía natural entre las columnas de agrupación.
Desea permitir que los analistas desglosen los datos de la forma que prefieran.

Evite CUBE cuando el número de columnas sea grande: 4 columnas ya generan 16 conjuntos de agrupación, y 5 generan 32. Prefiera ROLLUP o GROUPING SETS explícitos para mantener manejables los conjuntos de resultados.

Comprobación rápida

¿Cuántos conjuntos de agrupación distintos produce GROUP BY CUBE(a, b, c, d)?

Resumen de la lección

En esta lección aprendió cómo CUBE genera todas las combinaciones posibles de conjuntos de agrupación a partir de una lista de columnas, lo que lo hace ideal para informes multidimensionales.

Conclusiones principales:

GROUP BY CUBE(a, b, c) produce 2ⁿ conjuntos de agrupación.
NULL en una columna del resultado significa que se realizó la agregación sobre esa dimensión; use GROUPING() para detectarlo.
COALESCE convierte los valores NULL de la agregación en etiquetas significativas.
Un CUBE parcial (por ejemplo, GROUP BY year, CUBE(region, category)) fija algunas columnas y aplica CUBE únicamente al resto.
Use CUBE para análisis ad hoc completos; prefiera ROLLUP o GROUPING SETS explícitos cuando conozca la jerarquía o el número de columnas sea grande.

Preguntas frecuentes

¿La lección «CUBE para todas las combinaciones» es gratis?

Sí — el texto completo de «CUBE para todas las combinaciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de SQL Academy, actualiza a CoddyKit PRO. El curso de SQL Academy incluye 4 lecciones en total.

¿Qué aprenderé en «CUBE para todas las combinaciones»?

Todas las combinaciones de agrupación a la vez Practicas SQL Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar SQL Academy?

No se requiere experiencia previa. SQL Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «CUBE para todas las combinaciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de SQL Academy?

Sí. Cada lección de SQL Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a SQL Academy