# 3.4 SQL-Abfragen

## JOINs - Tabellen verknüpfen

JOINs verbinden Daten aus mehreren Tabellen.

### Arten von JOINs

```
JOIN-Typen
├── INNER JOIN
├── LEFT OUTER JOIN
├── RIGHT OUTER JOIN
├── FULL OUTER JOIN
└── CROSS JOIN
```

### INNER JOIN

Gibt nur übereinstimmende Zeilen zurück.

```sql
-- Syntax
SELECT spalten
FROM tabelle1
INNER JOIN tabelle2 ON tabelle1.spalte = tabelle2.spalte;

-- Beispiel: Kunden mit Bestellungen
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
INNER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;

-- Kurzschreibweise (impliziter Join)
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde, Bestellung
WHERE Kunde.Kunden_ID = Bestellung.Kunden_ID;
```

### LEFT OUTER JOIN

Gibt alle Zeilen der linken Tabelle zurück.

```sql
-- Alle Kunden, auch ohne Bestellung
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
LEFT OUTER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
```

### RIGHT OUTER JOIN

Gibt alle Zeilen der rechten Tabelle zurück.

```sql
-- Alle Bestellungen, auch ohne Kunden
SELECT Kunde.Name, Bestellung.Datum
FROM Kunde
RIGHT OUTER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID;
```

### Mehrere JOINs

```sql
SELECT
    Kunde.Name,
    Bestellung.Datum,
    Produkt.Name AS Produkt
FROM Kunde
INNER JOIN Bestellung ON Kunde.Kunden_ID = Bestellung.Kunden_ID
INNER JOIN BestellPosition ON Bestellung.Bestell_ID = BestellPosition.Bestell_ID
INNER JOIN Produkt ON BestellPosition.Produkt_ID = Produkt.Produkt_ID;
```

---

## Aggregatfunktionen

Aggregatfunktionen fassen mehrere Zeilen zu einem Ergebnis zusammen.

| Funktion | Beschreibung | Beispiel |
|----------|-------------|----------|
| COUNT() | Anzahl der Zeilen | COUNT(*) |
| SUM() | Summe | SUM(Preis) |
| AVG() | Durchschnitt | AVG(Preis) |
| MIN() | Minimum | MIN(Preis) |
| MAX() | Maximum | MAX(Preis) |

### Beispiele

```sql
-- Anzahl der Kunden
SELECT COUNT(*) AS AnzahlKunden FROM Kunde;

-- Summe aller Bestellungen
SELECT SUM(Gesamtbetrag) AS Gesamtumsatz FROM Bestellung;

-- Durchschnittspreis
SELECT AVG(Preis) AS Durchschnittspreis FROM Produkt;

-- Minimale/Maximale Bestellung
SELECT MIN(Gesamtbetrag) AS KleinsteBestellung,
       MAX(Gesamtbetrag) AS GrößteBestellung
FROM Bestellung;
```

---

## GROUP BY - Gruppierung

Gruppiert Ergebnisse nach bestimmten Kriterien.

```sql
-- Umsatz pro Kunde
SELECT Kunden_ID, SUM(Gesamtbetrag) AS Umsatz
FROM Bestellung
GROUP BY Kunden_ID;

-- Anzahl Bestellungen pro Kunde
SELECT Kunden_ID, COUNT(*) AS AnzahlBestellungen
FROM Bestellung
GROUP BY Kunden_ID;

-- Umsatz pro Kategorie
SELECT Kategorie, SUM(Preis) AS Gesamtumsatz
FROM Produkt
GROUP BY Kategorie;
```

### HAVING - Filter nach Aggregation

```sql
-- Kunden mit mehr als 3 Bestellungen
SELECT Kunden_ID, COUNT(*) AS Anzahl
FROM Bestellung
GROUP BY Kunden_ID
HAVING COUNT(*) > 3;
```

---

## Unterabfragen (Subqueries)

Unterabfragen sind verschachtelte SELECT-Anweisungen.

### Skalar-Unterabfrage

Gibt einen einzelnen Wert zurück.

```sql
-- Alle Produkte, die teurer als der Durchschnitt sind
SELECT Name, Preis
FROM Produkt
WHERE Preis > (SELECT AVG(Preis) FROM Produkt);
```

### Unterabfrage mit IN

```sql
-- Kunden, die mindestens eine Bestellung haben
SELECT Name
FROM Kunde
WHERE Kunden_ID IN (SELECT Kunden_ID FROM Bestellung);
```

### Korrelierte Unterabfrage

Referenziert Spalten der äußeren Abfrage.

```sql
-- Produkte mit dem höchsten Preis pro Kategorie
SELECT Name, Preis, Kategorie
FROM Produkt p1
WHERE Preis = (
    SELECT MAX(Preis)
    FROM Produkt p2
    WHERE p1.Kategorie = p2.Kategorie
);
```

---

## ORDER BY - Sortierung

```sql
-- Aufsteigend (Standard)
SELECT * FROM Produkt ORDER BY Preis;

-- Absteigend
SELECT * FROM Produkt ORDER BY Preis DESC;

-- Mehrere Sortierspalten
SELECT * FROM Bestellung
ORDER BY Datum DESC, Gesamtbetrag DESC;
```

---

## LIMIT / TOP - Ergebnismenge begrenzen

```sql
-- MySQL/MariaDB
SELECT * FROM Produkt ORDER BY Preis DESC LIMIT 10;

-- SQL Server
SELECT TOP 10 * FROM Produkt ORDER BY Preis DESC;

-- PostgreSQL
SELECT * FROM Produkt ORDER BY Preis DESC LIMIT 10;
```

---

## Übung: Komplexe Abfragen

### Ausgangsdaten

```sql
-- Kunden (ID, Name, Stadt)
-- Bestellungen (ID, Kunden_ID, Datum, Gesamtbetrag)
-- BestellPositionen (Bestell_ID, Produkt_ID, Menge, Preis)
```

### Aufgaben

1. Finde die 5 umsatzstärksten Kunden
2. Liste alle Bestellungen mit Kundenname
3. Zeige den durchschnittlichen Bestellwert pro Stadt

### Lösungen

```sql
-- 1. Top 5 Kunden
SELECT K.Name, SUM(B.Gesamtbetrag) AS Umsatz
FROM Kunde K
JOIN Bestellung B ON K.Kunden_ID = B.Kunden_ID
GROUP BY K.Kunden_ID, K.Name
ORDER BY Umsatz DESC
LIMIT 5;

-- 2. Bestellungen mit Kundenname
SELECT B.Bestell_ID, K.Name, B.Datum, B.Gesamtbetrag
FROM Bestellung B
JOIN Kunde K ON B.Kunden_ID = K.Kunden_ID
ORDER BY B.Datum DESC;

-- 3. Durchschnittsbestellwert pro Stadt
SELECT K.Stadt, AVG(B.Gesamtbetrag) AS Durchschnitt
FROM Kunde K
JOIN Bestellung B ON K.Kunden_ID = B.Kunden_ID
GROUP BY K.Stadt;
```

---

## Querverweise

- [[LF3-03-SQL-Grundlagen|Zurück: SQL-Grundlagen]]
- [[LF3-05-Datenbankmanagement|Nächstes Thema: Datenbankmanagement]]
- [[LF5-03-Programmierung|Programmierung]]

---

*Stand: 2024*