Aggregatfunktionen

Aggregatfunktionen fassen mehrere Zeilen zu einem einzigen Ergebnis zusammen. Statt einzelne Datensaetze zu sehen, bekommst du Zusammenfassungen: Wie viele Kunden gibt es? Was ist der Durchschnittspreis? Wie hoch ist der Gesamtumsatz?

Die fuenf wichtigsten Aggregatfunktionen

Funktion	Bedeutung	Beispiel
COUNT()	Anzahl zaehlen	Wie viele Kunden?
SUM()	Summe berechnen	Gesamtumsatz
AVG()	Durchschnitt	Durchschnittspreis
MIN()	Kleinster Wert	Guenstigstes Produkt
MAX()	Groesster Wert	Teuerstes Produkt

COUNT - Zaehlen

COUNT(*) - Alle Zeilen zaehlen

-- Wie viele Kunden gibt es?
SELECT COUNT(*) AS anzahl_kunden
FROM kunden;

Ergebnis: 5

-- Wie viele Bestellungen gibt es?
SELECT COUNT(*) AS anzahl_bestellungen
FROM bestellungen;

Ergebnis: 5

COUNT(spalte) - Nicht-NULL Werte zaehlen

-- Wie viele Kunden haben eine E-Mail?
SELECT COUNT(email) AS mit_email
FROM kunden;

COUNT(spalte) zaehlt nur Zeilen, in denen die Spalte nicht NULL ist.

COUNT(DISTINCT spalte) - Eindeutige Werte zaehlen

-- Wie viele verschiedene Staedte?
SELECT COUNT(DISTINCT stadt) AS verschiedene_staedte
FROM kunden;

Ergebnis: 4

-- Wie viele verschiedene Kategorien?
SELECT COUNT(DISTINCT kategorie) AS verschiedene_kategorien
FROM produkte;

Ergebnis: 3

SUM - Summe berechnen

-- Gesamter Bestellwert aller Bestellungen
SELECT SUM(betrag) AS gesamtumsatz
FROM bestellungen;

Ergebnis: 499.92

-- Gesamter Lagerwert
SELECT SUM(preis * lagerbestand) AS gesamter_lagerwert
FROM produkte;

-- Gesamtmenge aller bestellten Artikel
SELECT SUM(menge) AS gesamt_artikel
FROM bestellpositionen;

AVG - Durchschnitt berechnen

-- Durchschnittlicher Bestellwert
SELECT ROUND(AVG(betrag), 2) AS durchschnittlicher_bestellwert
FROM bestellungen;

-- Durchschnittlicher Produktpreis
SELECT ROUND(AVG(preis), 2) AS durchschnittspreis
FROM produkte;

-- Durchschnittlicher Produktpreis pro Kategorie
SELECT
    kategorie,
    ROUND(AVG(preis), 2) AS durchschnittspreis
FROM produkte
GROUP BY kategorie;

Wichtig: AVG ignoriert NULL-Werte! Wenn 3 von 5 Werten NULL sind, wird der Durchschnitt nur aus den 2 vorhandenen Werten berechnet.

MIN und MAX - Extremwerte

-- Guenstigstes und teuerstes Produkt
SELECT
    MIN(preis) AS guenstigster_preis,
    MAX(preis) AS teuerster_preis
FROM produkte;

Ergebnis:

guenstigster_preis | teuerster_preis
-------------------+----------------
             14.99 |         129.99

-- Erste und letzte Bestellung
SELECT
    MIN(bestelldatum) AS erste_bestellung,
    MAX(bestelldatum) AS letzte_bestellung
FROM bestellungen;

-- Kleinste und groesste Bestellmenge
SELECT
    MIN(menge) AS kleinste_menge,
    MAX(menge) AS groesste_menge
FROM bestellpositionen;

Mehrere Aggregatfunktionen kombinieren

Du kannst mehrere Funktionen in einer Abfrage verwenden:

SELECT
    COUNT(*) AS anzahl_produkte,
    MIN(preis) AS min_preis,
    MAX(preis) AS max_preis,
    ROUND(AVG(preis), 2) AS avg_preis,
    SUM(lagerbestand) AS gesamt_lager
FROM produkte;

Ergebnis:

anzahl_produkte | min_preis | max_preis | avg_preis | gesamt_lager
----------------+-----------+-----------+-----------+-------------
              6 |     14.99 |    129.99 |     55.82 |          300

Aggregatfunktionen mit WHERE

WHERE filtert die Zeilen vor der Aggregation:

-- Durchschnittspreis nur fuer Kleidung
SELECT ROUND(AVG(preis), 2) AS avg_kleidung
FROM produkte
WHERE kategorie = 'Kleidung';

-- Anzahl der Bestellungen im Maerz 2026
SELECT COUNT(*) AS bestellungen_maerz
FROM bestellungen
WHERE bestelldatum >= '2026-03-01' AND bestelldatum < '2026-04-01';

-- Gesamtumsatz der abgeschlossenen Bestellungen
SELECT SUM(betrag) AS abgeschlossener_umsatz
FROM bestellungen
WHERE status = 'abgeschlossen';

Aggregatfunktionen mit JOINs

Die Kombination aus JOINs und Aggregatfunktionen ist extrem maechtig:

-- Gesamtumsatz pro Kunde
SELECT
    k.name,
    COUNT(b.id) AS anzahl_bestellungen,
    COALESCE(SUM(b.betrag), 0) AS gesamtumsatz
FROM kunden k
LEFT JOIN bestellungen b ON k.id = b.kunden_id
GROUP BY k.name
ORDER BY gesamtumsatz DESC;

-- Beliebteste Produkte (nach verkaufter Menge)
SELECT
    p.name,
    SUM(bp.menge) AS verkaufte_menge,
    SUM(bp.menge * bp.einzelpreis) AS umsatz
FROM produkte p
JOIN bestellpositionen bp ON p.id = bp.produkt_id
GROUP BY p.name
ORDER BY verkaufte_menge DESC;

Ergebnis:

name           | verkaufte_menge | umsatz
---------------+-----------------+-------
Muetze Winter  |               5 | 74.95
T-Shirt Basic  |               3 | 59.97
Jeans Classic  |               2 | 99.98
Jacke Outdoor  |               1 | 129.99
Sneaker Sport  |               1 | 79.99
Rucksack Urban |               1 | 39.99

NULL und Aggregatfunktionen

Aggregatfunktionen behandeln NULL-Werte unterschiedlich:

Funktion	NULL-Verhalten
COUNT(*)	Zaehlt alle Zeilen, inklusive NULL
COUNT(spalte)	Ignoriert NULL
SUM()	Ignoriert NULL
AVG()	Ignoriert NULL
MIN()	Ignoriert NULL
MAX()	Ignoriert NULL

-- Beispiel: NULL-Auswirkung auf AVG
-- Werte: 10, 20, NULL, 40
-- AVG = (10 + 20 + 40) / 3 = 23.33  (NICHT 70/4!)

Nutze COALESCE, wenn NULL als 0 behandelt werden soll:

-- AVG mit NULL als 0
SELECT AVG(COALESCE(betrag, 0)) AS avg_mit_nullen
FROM bestellungen;

Praxisbeispiele

Dashboard-Kennzahlen

SELECT
    (SELECT COUNT(*) FROM kunden) AS kunden_gesamt,
    (SELECT COUNT(*) FROM bestellungen) AS bestellungen_gesamt,
    (SELECT ROUND(SUM(betrag), 2) FROM bestellungen) AS umsatz_gesamt,
    (SELECT ROUND(AVG(betrag), 2) FROM bestellungen) AS avg_bestellwert,
    (SELECT COUNT(*) FROM bestellungen WHERE status = 'offen') AS offene_bestellungen;

Lagerbestandsanalyse

SELECT
    kategorie,
    COUNT(*) AS anzahl_produkte,
    SUM(lagerbestand) AS gesamt_lager,
    ROUND(AVG(preis), 2) AS avg_preis,
    SUM(preis * lagerbestand) AS lagerwert
FROM produkte
GROUP BY kategorie
ORDER BY lagerwert DESC;

Was kommt als Naechstes?

Im naechsten Tutorial lernst du GROUP BY und HAVING kennen - damit kannst du Daten gruppieren und Bedingungen auf Gruppen anwenden.

Zusammenfassung

• COUNT() zaehlt Zeilen oder eindeutige Werte
• SUM() berechnet die Summe einer Spalte
• AVG() berechnet den Durchschnitt
• MIN() und MAX() finden Extremwerte
• Aggregatfunktionen ignorieren NULL (ausser COUNT(*))
• Mit WHERE filterst du vor der Aggregation
• Die Kombination mit JOINs ermoeglicht maechtige Analysen

Uebungen

1. COUNT: Wie viele verschiedene Produkte wurden insgesamt bestellt?
2. SUM: Berechne den Gesamtwert aller Produkte im Lager.
3. AVG: Was ist der durchschnittliche Bestellwert der versendeten Bestellungen?
4. MIN/MAX: Finde das guenstigste und teuerste Produkt in der Kategorie ‘Kleidung’.
5. Kombination: Erstelle eine Uebersicht mit Gesamtumsatz, Anzahl Bestellungen, durchschnittlichem Bestellwert und der Differenz zwischen groesster und kleinster Bestellung.

-- Loesung zu Uebung 2:
SELECT SUM(preis * lagerbestand) AS gesamter_lagerwert
FROM produkte;

-- Loesung zu Uebung 4:
SELECT
    MIN(preis) AS guenstigste_kleidung,
    MAX(preis) AS teuerste_kleidung
FROM produkte
WHERE kategorie = 'Kleidung';