GROUP BY, HAVING, ROLLUP/CUBE/GROUPING SETS

Oracle

-- Basic grouping + HAVING
SELECT city, COUNT(*) AS n
FROM customer
GROUP BY city
HAVING COUNT(*) > 5;

-- Subtotals and grand total with ROLLUP
SELECT city, district, SUM(balance)
FROM customer
GROUP BY ROLLUP(city, district);

GROUP BY regroupe les lignes selon les colonnes données et applique des fonctions d'agrégat ; HAVING filtre le résultat regroupé (WHERE filtre les lignes avant le regroupement). ROLLUP produit des sous-totaux hiérarchiques + un total général, CUBE toutes les combinaisons, et GROUPING SETS les regroupements choisis. Oracle prend en charge les trois.

PostgreSQL

SELECT city, district, SUM(balance)
FROM customer
GROUP BY GROUPING SETS ((city, district), (city), ());

-- CUBE produces all subset combinations
SELECT city, district, SUM(balance)
FROM customer
GROUP BY CUBE(city, district);

PostgreSQL 9.5+ prend en charge ROLLUP, CUBE et GROUPING SETS de façon conforme au standard. La fonction GROUPING() indique si une colonne figure dans une ligne de total (NULL). HAVING filtre après l'agrégation, WHERE avant.

MySQL

SELECT city, COUNT(*) AS n
FROM customer
GROUP BY city
HAVING n > 5;

-- ROLLUP in MySQL:
SELECT city, district, SUM(balance)
FROM customer
GROUP BY city, district WITH ROLLUP;

MySQL/MariaDB produisent des sous-totaux/totaux généraux avec la syntaxe GROUP BY ... WITH ROLLUP ; CUBE et GROUPING SETS ne sont pas pris en charge. Les alias du SELECT peuvent être utilisés dans HAVING (ce qui ne fonctionne généralement pas dans Oracle/SQL Server). Dans les lignes ROLLUP, la colonne regroupée apparaît à NULL.

SQL Server

SELECT city, COUNT(*) AS n
FROM customer
GROUP BY city
HAVING COUNT(*) > 5;

-- ROLLUP / CUBE / GROUPING SETS
SELECT city, district, SUM(balance)
FROM customer
GROUP BY ROLLUP(city, district);

Outre GROUP BY, SQL Server prend en charge ROLLUP(), CUBE() et GROUPING SETS (2008+) avec une syntaxe moderne ; l'ancienne forme WITH ROLLUP/WITH CUBE est dépréciée. GROUPING() et GROUPING_ID() aident à distinguer les lignes de total.

MongoDB

// Closest equivalent: $group + $sum
db.customer.aggregate([
  { $group: { _id: "$city", n: { $sum: 1 } } },
  { $match: { n: { $gt: 5 } } }
])
// $facet is used for ROLLUP-like multi-level totals

Dans MongoDB, $group est l'équivalent du GROUP BY SQL ; _id définit la clé de regroupement et les accumulateurs ($sum, $avg, $max) définissent les agrégats. Le filtrage après regroupement se fait avec $match (l'équivalent de HAVING). Les totaux multiniveaux de type ROLLUP/CUBE s'obtiennent en exécutant plusieurs pipelines avec $facet.

Redis

# Not applicable: core Redis has no GROUP BY.
# Aggregation with RediSearch:
FT.AGGREGATE customer_idx "*" GROUPBY 1 @city REDUCE COUNT 0 AS n

Redis de base n'offre pas de regroupement ; la commande FT.AGGREGATE du module RediSearch effectue une agrégation de type SQL avec GROUPBY et REDUCE (COUNT, SUM, AVG). L'étape FILTER filtre le résultat regroupé comme HAVING. Sans le module, l'agrégation se fait dans l'application.

Elasticsearch

GET customer/_search
{
  "size": 0,
  "aggs": {
    "by_city": { "terms": { "field": "city" },
      "aggs": { "total": { "sum": { "field": "balance" } } } }
  }
}

Dans Elasticsearch, le regroupement se fait avec l'agrégation de buckets 'terms' et les agrégats avec des metric aggregations (sum, avg, cardinality). Pour un filtrage de type HAVING, utilisez la pipeline aggregation 'bucket_selector'. Les sous-totaux multiniveaux se construisent avec des agrégations imbriquées.