SQL Academy · Leçon

CUBE pour toutes les combinaisons

Obtenez toutes les combinaisons de regroupement en une seule fois.

CUBE pour toutes les combinaisons est une leçon SQL Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage SQL Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours SQL Academy comprend 4 leçons au total.

Qu'est-ce que CUBE ?

L'extension CUBE de SQL génère toutes les combinaisons possibles de regroupement à partir d'une liste de colonnes. Alors que ROLLUP crée une hiérarchie, CUBE produit un produit cartésien complet des sous-totaux, y compris le total général.

Considérez-la comme une façon de demander : "Donnez-moi tous les sous-totaux calculables à partir de ces colonnes."

Configuration de la table

Nous utiliserons une table sales qui suit le chiffre d'affaires par année, région et catégorie de produit. Ce type de données multidimensionnelles est idéal pour mettre CUBE en valeur.

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);

Votre première requête CUBE

La syntaxe est simple : remplacez GROUP BY par GROUP BY CUBE(...) et répertoriez les colonnes à l'intérieur. SQL générera toutes les combinaisons de ces colonnes sous forme d'ensembles de regroupement.

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

Combien de regroupements CUBE produit-il ?

Pour n colonnes, CUBE produit 2ⁿ ensembles de regroupement, un pour chaque sous-ensemble de la liste de colonnes, y compris l'ensemble vide (le total général).

Avec 3 colonnes (année, région, catégorie), cela représente 2³ = 8 ensembles de regroupement : chaque colonne seule, chaque paire, les trois colonnes ensemble et aucune colonne.

-- 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;

Les valeurs NULL indiquent la dimension agrégée

Tout comme ROLLUP, CUBE utilise NULL pour signaler qu'une colonne a fait l'objet d'une agrégation. Si region vaut NULL dans une ligne de résultat, cette ligne récapitule toutes les régions pour la combinaison des autres colonnes.

Utilisez GROUPING(col) pour distinguer une valeur NULL réelle d'un marqueur d'agrégation.

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;

Rendre les valeurs NULL lisibles avec COALESCE

Pour rendre le résultat plus lisible dans les rapports, entourez chaque colonne regroupée de COALESCE afin de remplacer le NULL d'agrégation par une étiquette descriptive comme '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 ou ROLLUP — différence essentielle

ROLLUP(a, b, c) crée uniquement des sous-totaux le long d'une hiérarchie : (a,b,c), (a,b), (a), (). Il respecte l'ordre de gauche à droite.

CUBE(a, b, c) crée tous les sous-ensembles, y compris des croisements comme (a,c) ou (b) seul, que ROLLUP ignore entièrement. Utilisez CUBE lorsque vous avez besoin d'une analyse multidimensionnelle complète, sans hiérarchie prédéfinie.

-- 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 partiel

Vous pouvez combiner des colonnes ordinaires de GROUP BY avec une sous-liste CUBE. Les colonnes répertoriées en dehors de CUBE(...) sont toujours présentes dans chaque ensemble de regroupement, tandis que seules les colonnes placées à l'intérieur font l'objet du traitement combinatoire complet.

-- 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;

Filtrer avec HAVING sur les résultats de CUBE

HAVING fonctionne sur le résultat de CUBE exactement comme avec un GROUP BY classique. Vous pouvez exclure les lignes de regroupement dont la valeur agrégée n'atteint pas un seuil — par exemple, conserver uniquement les lignes où le chiffre d'affaires total dépasse un minimum.

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;

Combiner CUBE avec des fonctions de fenêtre

Vous pouvez encapsuler une requête CUBE dans un CTE, puis appliquer des fonctions de fenêtre pour classer ou comparer les lignes du résultat. Il s'agit d'un modèle puissant pour créer des tableaux de bord destinés aux cadres dirigeants.

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;

Quand choisir CUBE

CUBE est l'outil adapté lorsque :

Vous avez besoin de toutes les combinaisons de sous-totaux pour un rapport ponctuel ou de type OLAP.
Il n'existe pas de hiérarchie naturelle entre vos colonnes de regroupement.
Vous souhaitez permettre aux analystes d'explorer les données comme ils le souhaitent.

Évitez CUBE lorsque le nombre de colonnes est élevé — 4 colonnes produisent déjà 16 ensembles de regroupement, et 5 en produisent 32. Préférez ROLLUP ou des GROUPING SETS explicites pour conserver des ensembles de résultats faciles à gérer.

Vérification rapide

Combien d'ensembles de regroupement distincts GROUP BY CUBE(a, b, c, d) produit-il ?

Récapitulatif de la leçon

Dans cette leçon, vous avez appris comment CUBE génère toutes les combinaisons possibles d'ensembles de regroupement à partir d'une liste de colonnes, ce qui le rend idéal pour les rapports multidimensionnels.

Points essentiels :

GROUP BY CUBE(a, b, c) produit 2ⁿ ensembles de regroupement.
La présence de NULL dans une colonne du résultat signifie que cette dimension a été agrégée ; utilisez GROUPING() pour le détecter.
COALESCE transforme les NULL issus de l'agrégation en libellés explicites.
Un CUBE partiel (par exemple, GROUP BY year, CUBE(region, category)) fixe certaines colonnes et applique le cube uniquement aux autres.
Utilisez CUBE pour une analyse ponctuelle complète ; préférez ROLLUP ou des GROUPING SETS explicites lorsque la hiérarchie est connue ou que le nombre de colonnes est élevé.

Questions Fréquemment Posées

La leçon « CUBE pour toutes les combinaisons » est-elle gratuite ?

Oui — le texte complet de « CUBE pour toutes les combinaisons » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours SQL Academy, passe à CoddyKit PRO. Le cours SQL Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « CUBE pour toutes les combinaisons » ?

Obtenez toutes les combinaisons de regroupement en une seule fois. Tu pratiques SQL Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer SQL Academy ?

Aucune expérience préalable n'est requise. SQL Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « CUBE pour toutes les combinaisons » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon SQL Academy ?

Oui. Chaque leçon SQL Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à SQL Academy