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 gruppiert Zeilen nach den angegebenen Spalten und wendet Aggregatfunktionen an; HAVING filtert das gruppierte Ergebnis (WHERE filtert Zeilen vor der Gruppierung). ROLLUP erzeugt hierarchische Zwischensummen + Gesamtsumme, CUBE alle Kombinationen und GROUPING SETS die gewählten Gruppierungen. Oracle unterstützt alle drei.

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+ unterstützt ROLLUP, CUBE und GROUPING SETS standardkonform. Die Funktion GROUPING() zeigt, ob eine Spalte in einer Summenzeile steht (NULL). HAVING filtert nach der Aggregation, WHERE davor.

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 erzeugen Zwischen-/Gesamtsummen mit der Syntax GROUP BY ... WITH ROLLUP; CUBE und GROUPING SETS werden nicht unterstützt. SELECT-Aliase lassen sich in HAVING verwenden (in Oracle/SQL Server funktioniert das meist nicht). In ROLLUP-Zeilen erscheint die gruppierte Spalte als 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);

Neben GROUP BY unterstützt SQL Server ROLLUP(), CUBE() und GROUPING SETS (2008+) mit moderner Syntax; die alte Form WITH ROLLUP/WITH CUBE ist veraltet. GROUPING() und GROUPING_ID() helfen, Summenzeilen zu unterscheiden.

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

In MongoDB entspricht $group dem SQL-GROUP BY; _id legt den Gruppierungsschlüssel fest, Akkumulatoren ($sum, $avg, $max) definieren die Aggregate. Gefiltert wird nach der Gruppierung mit $match (Entsprechung zu HAVING). Mehrstufige Summen wie ROLLUP/CUBE erhältst du, indem du mit $facet mehrere Pipelines ausführst.

Redis

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

Core Redis bietet keine Gruppierung; der Befehl FT.AGGREGATE des Moduls RediSearch führt SQL-ähnliche Aggregation mit GROUPBY und REDUCE (COUNT, SUM, AVG) aus. Der Schritt FILTER filtert das gruppierte Ergebnis wie HAVING. Ohne das Modul erfolgt die Aggregation in der Anwendung.

Elasticsearch

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

In Elasticsearch erfolgt die Gruppierung mit der Bucket-Aggregation 'terms', Aggregate mit Metrik-Aggregationen (sum, avg, cardinality). Für HAVING-ähnliches Filtern nutze die Pipeline-Aggregation 'bucket_selector'. Mehrstufige Zwischensummen entstehen mit verschachtelten Aggregationen.