# SQL-Grundlagen: Daten mit SELECT abfragen

> SELECT ist der wichtigste SQL-Befehl: Er liest Daten aus einer Tabelle. Mit SELECT wählst du die Spalten, mit FROM die Tabelle, mit WHERE filterst du Zeilen nach Bedingungen, mit ORDER BY sortierst du das Ergebnis und mit GROUP BY fasst du Zeilen für Auswertungen zusammen. Diese Bausteine decken den Großteil aller Abfragen ab.

**Autor:** Mr. Benjamin · **Beruf:** IT-Grundlagen
**Veröffentlicht:** 2026-09-21 · **Aktualisiert:** 2026-09-21
**Quelle:** https://yellowbluetech.de/blog/sql-grundlagen-select

---

Eine [Datenbank](/blog/was-ist-eine-datenbank) nützt wenig, wenn man ihre Daten nicht gezielt herausbekommt. Genau dafür gibt es SQL – und der mit Abstand wichtigste Befehl ist `SELECT`. Wer ihn beherrscht, kann fast jede Frage an die Daten stellen.

## Der Aufbau einer SELECT-Abfrage

Eine Abfrage liest sich fast wie ein Satz: „Wähle diese Spalten aus jener Tabelle, wo eine Bedingung gilt, sortiert nach …".

```sql
SELECT name, lehrjahr
FROM azubis
WHERE lehrjahr = 2
ORDER BY name;
```

> **Merksatz**
>
> Die feste Reihenfolge der Klauseln: **SELECT** (Spalten) → **FROM** (Tabelle) → **WHERE** (Filter) → **GROUP BY** (Gruppierung) → **ORDER BY** (Sortierung). `SELECT *` wählt alle Spalten – praktisch zum Ausprobieren, in echtem Code aber besser die Spalten benennen.

## Filtern mit WHERE

`WHERE` schränkt die Zeilen ein. Bedingungen lassen sich mit Vergleichs- und Logikoperatoren kombinieren:

| Operator | Bedeutung | Beispiel |
| --- | --- | --- |
| `=` `<>` | gleich / ungleich | `beruf = 'FIAE'` |
| `<` `>` `<=` `>=` | Vergleich | `lehrjahr >= 2` |
| `AND` `OR` | Verknüpfung | `lehrjahr = 3 AND beruf = 'FISI'` |
| `LIKE` | Textmuster | `name LIKE 'A%'` (beginnt mit A) |
| `IN` | Liste | `beruf IN ('FIAE','FISI')` |
| `IS NULL` | leerer Wert | `note IS NULL` |

## Sortieren und gruppieren

`ORDER BY spalte ASC` sortiert aufsteigend, `DESC` absteigend. `GROUP BY` fasst Zeilen mit gleichem Wert zusammen und wird mit **Aggregatfunktionen** ausgewertet:

```sql
SELECT beruf, COUNT(*) AS anzahl
FROM azubis
GROUP BY beruf;
```

Die wichtigsten Aggregatfunktionen: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`.

> **Prüfungstipp**
>
> Zwei Klassiker: Erstens der Unterschied **WHERE vs. HAVING** – `WHERE` filtert **einzelne Zeilen** vor der Gruppierung, `HAVING` filtert **Gruppen** nach dem `GROUP BY` (z. B. `HAVING COUNT(*) > 5`). Zweitens: **NULL ist nicht 0 und nicht ''** – auf NULL prüfst du mit `IS NULL`, niemals mit `= NULL`. Beides wird in Prüfungen regelmäßig abgefragt.

## Warum SELECT so mächtig ist

> **Hinweis**
>
> Mit diesen wenigen Klauseln beantwortest du fast jede Frage an die Daten: „Welche Azubis sind im dritten Lehrjahr?", „Wie viele pro Beruf?", „Wer hat die beste Note?". Sobald Daten aus **mehreren Tabellen** kommen, kombinierst du sie zusätzlich mit einem [JOIN](/blog/sql-joins) – aber das Grundgerüst bleibt immer `SELECT … FROM … WHERE`. Wichtig zu wissen: `SELECT` **liest nur**, es verändert keine Daten. Fürs Anlegen und Ändern gibt es andere Befehle (siehe [DDL und DML](/blog/ddl-dml-sql)).

## Selbstkontrolle

**Frage:** Du willst nur Gruppen anzeigen, die mehr als fünf Einträge haben. Welche Klausel nutzt du?

- [ ] WHERE COUNT(\*) > 5
- [x] HAVING COUNT(\*) > 5
- [ ] ORDER BY COUNT(\*) > 5
- [ ] FILTER BY COUNT(\*) > 5

## Häufige Fragen

### Was ist der Unterschied zwischen WHERE und HAVING?

WHERE wird vor der Gruppierung ausgewertet und filtert einzelne Zeilen, kann also nicht auf Aggregatfunktionen zugreifen. HAVING wird nach dem GROUP BY ausgewertet und filtert die entstandenen Gruppen, etwa nach ihrer Anzahl oder Summe. In einer Abfrage können beide gemeinsam vorkommen.

### Warum sollte man nicht immer SELECT * nehmen?

`SELECT *` holt alle Spalten, auch die, die du gar nicht brauchst. Das überträgt unnötig viele Daten, macht Abfragen langsamer und den Code unklarer, weil nicht ersichtlich ist, welche Felder wirklich verwendet werden. Zum schnellen Ausprobieren ist es praktisch, in produktivem Code benennt man die Spalten aber besser explizit.

### Wie prüfe ich auf leere Werte?

Mit IS NULL beziehungsweise IS NOT NULL. NULL bedeutet „kein Wert" und ist nicht dasselbe wie 0 oder ein leerer Text. Ein Vergleich wie spalte = NULL liefert deshalb nie ein sinnvolles Ergebnis; korrekt ist WHERE spalte IS NULL.

### Ist SQL bei jeder Datenbank gleich?

Der Kern – SELECT, WHERE, JOIN, GROUP BY – ist genormt und funktioniert überall sehr ähnlich. Bei Detailfunktionen, Datentypen oder String-Funktionen unterscheiden sich die Systeme (MySQL, PostgreSQL, SQL Server, Oracle) aber im Detail. Für die Ausbildung reicht der genormte Standard-Kern völlig aus.

**Weiterlesen:** [Normalisierung: Datenbanken ohne Redundanz](/blog/normalisierung) · [ER-Modell erklärt: Entity-Relationship-Modell](/blog/er-modell-datenbanken-planen) · [Datenanalyse: von Rohdaten zur Erkenntnis](/blog/datenanalyse-grundlagen)

## Das Wichtigste in Kürze

- **SELECT** liest Daten; Reihenfolge: **SELECT → FROM → WHERE → GROUP BY → ORDER BY**.
- **WHERE** filtert Zeilen; Operatoren wie `=`, `LIKE`, `IN`, `IS NULL`.
- **ORDER BY** sortiert (`ASC`/`DESC`), **GROUP BY** gruppiert für Auswertungen.
- **Aggregatfunktionen**: `COUNT`, `SUM`, `AVG`, `MIN`, `MAX`.
- **WHERE** filtert Zeilen, **HAVING** filtert Gruppen; **NULL** nur mit `IS NULL` prüfen.