Kapitel 7: DQL - Daten abfragen (SELECT) ⭐ Wichtigstes Kapitel!

DQL (Data Query Language) wird verwendet, um Daten aus Tabellen abzufragen. Der SELECT-Befehl ist der am häufigsten verwendete SQL-Befehl.

7.1 Basis-Abfrage (SELECT) ⭐

1. Alle Felder abfragen (SELECT *)

-- Alle Felder und alle Datensätze abfragen
SELECT * FROM users;

Ausgabe:

+---------+----------+-------------------+-----------+
| user_id | username | email             | ist_aktiv |
+---------+----------+-------------------+-----------+
|       1 | max      | max@email.de     |         1 |
|       2 | lisa     | lisa@email.de    |         1 |
|       3 | john     | john@email.de     |         0 |
+---------+----------+-------------------+-----------+

⚠️ Warnung: SELECT * ist langsam bei großen Tabellen! Besser: nur benötigte Felder abfragen.

2. Bestimmte Felder abfragen

-- Nur bestimmte Felder abfragen
SELECT username, email FROM users;

Ausgabe:

+----------+-------------------+
| username | email             |
+----------+-------------------+
| max      | max@email.de     |
| lisa     | lisa@email.de    |
| john     | john@email.de     |
+----------+-------------------+

3. Felder umbenennen (Alias mit AS)

-- Feldnamen für die Anzeige umbenennen
SELECT 
    username AS 'Benutzername',
    email AS 'E-Mail-Adresse',
    ist_aktiv AS 'Aktiv?'
FROM users;

Ausgabe:

+----------------+-------------------+---------+
| Benutzername | E-Mail-Adresse   | Aktiv? |
+----------------+-------------------+---------+
| max           | max@email.de     |       1 |
| lisa          | lisa@email.de    |       1 |
| john          | john@email.de     |       0 |
+----------------+-------------------+---------+

Tipp: AS kann weggelassen werden (nicht empfohlen):

SELECT username 'Benutzername' FROM users;  -- Funktioniert, aber schwer lesbar

7.2 Bedingte Abfrage (WHERE) ⭐

WHERE wird verwendet, um nur Datensätze abzufragen, die eine Bedingung erfüllen.

1. Vergleichsoperatoren

Operator	Bedeutung	Beispiel
=	Gleich	WHERE alter = 25
!= oder <>	Ungleich	WHERE alter != 25
>	Größer als	WHERE alter > 18
<	Kleiner als	WHERE alter < 30
>=	Größer oder gleich	WHERE alter >= 18
<=	Kleiner oder gleich	WHERE alter <= 65
BETWEEN ... AND ...	Zwischen zwei Werten	WHERE alter BETWEEN 18 AND 30

Beispiele:

-- Benutzer mit ID 1 abfragen
SELECT * FROM users WHERE user_id = 1;

-- Benutzer abfragen, die älter als 18 sind
SELECT * FROM users WHERE alter > 18;

-- Benutzer mit genau 25 Jahren
SELECT * FROM users WHERE alter = 25;

2. Logische Operatoren

Operator	Bedeutung	Beispiel
AND	Und (beide Bedingungen müssen erfüllt sein)	WHERE alter > 18 AND alter < 30
OR	Oder (mindestens eine Bedingung muss erfüllt sein)	WHERE stadt = 'Berlin' OR stadt = 'Hamburg'
NOT	Nicht (Bedingung negieren)	WHERE NOT ist_aktiv = 1

Beispiele:

-- Benutzer, die älter als 18 UND aktiv sind
SELECT * FROM users 
WHERE alter > 18 AND ist_aktiv = 1;

-- Benutzer aus Berlin ODER Hamburg
SELECT * FROM users 
WHERE stadt = 'Berlin' OR stadt = 'Hamburg';

-- Benutzer, die NICHT aktiv sind
SELECT * FROM users 
WHERE NOT ist_aktiv = 1;
-- oder einfacher:
SELECT * FROM users 
WHERE ist_aktiv != 1;

3. Wie-Suche (LIKE) - Mustersuche

LIKE wird verwendet, um nach Mustern zu suchen.

Platzhalter	Bedeutung	Beispiel
%	Beliebige Zeichen (0 bis unendlich)	WHERE name LIKE 'M%' (Namen, die mit M beginnen)
_	Genau ein Zeichen	WHERE name LIKE 'M_' (Namen mit 2 Buchstaben, die mit M beginnen)

Beispiele:

-- Alle Benutzer, deren Name mit 'M' beginnt
SELECT * FROM users 
WHERE username LIKE 'M%';

-- Alle Benutzer, deren E-Mail '@gmail.com' enthält
SELECT * FROM users 
WHERE email LIKE '%@gmail.com';

-- Alle Benutzer, deren Name 5 Buchstaben hat und mit 'a' endet
SELECT * FROM users 
WHERE username LIKE '____a';  -- 4x _ + a = 5 Buchstaben

4. NULL-Werte abfragen (IS NULL, IS NOT NULL)

Wichtig: NULL ist kein Wert! Man kann nicht = NULL verwenden!

-- Benutzer abfragen, deren E-Mail-Adresse NICHT angegeben wurde (NULL)
SELECT * FROM users 
WHERE email IS NULL;

-- Benutzer abfragen, deren E-Mail-Adresse angegeben wurde
SELECT * FROM users 
WHERE email IS NOT NULL;

7.3 Sortierte Abfrage (ORDER BY)

ORDER BY sortiert die Ergebnisse.

1. Aufsteigend sortieren (ASC - Standard)

-- Nach Alter aufsteigend sortieren (1, 2, 3...)
SELECT * FROM users 
ORDER BY alter ASC;

-- ASC kann weggelassen werden (Standard)
SELECT * FROM users 
ORDER BY alter;

2. Absteigend sortieren (DESC)

-- Nach Alter absteigend sortieren (3, 2, 1...)
SELECT * FROM users 
ORDER BY alter DESC;

3. Mehrere Felder sortieren

-- Zuerst nach Stadt aufsteigend, dann nach Alter absteigend
SELECT * FROM users 
ORDER BY stadt ASC, alter DESC;

7.4 Begrenzte Abfrage (LIMIT) - Paginierung

LIMIT schränkt die Anzahl der Ergebnisse ein. Sehr wichtig für Paginierung (Seitenweise Anzeige)!

1. Basis-Syntax

-- Die ersten 10 Datensätze abfragen
SELECT * FROM users 
LIMIT 10;

2. Paginierung (Seitenweise Anzeige)

-- Syntax: LIMIT start_index, anzahl
-- ACHTUNG: Der Startindex beginnt bei 0!

-- Seite 1: Datensätze 1-10 (Index 0-9)
SELECT * FROM users 
LIMIT 0, 10;

-- Seite 2: Datensätze 11-20 (Index 10-19)
SELECT * FROM users 
LIMIT 10, 10;

-- Seite 3: Datensätze 21-30 (Index 20-29)
SELECT * FROM users 
LIMIT 20, 10;

Formel für Paginierung:

LIMIT (seite - 1) * eintrage_pro_seite, eintrage_pro_seite

Beispiel: Seite 3, 10 Einträge pro Seite
LIMIT (3-1) * 10, 10  →  LIMIT 20, 10

7.5 Duplikate entfernen (DISTINCT)

DISTINCT entfernt doppelte Zeilen aus dem Ergebnis.

-- Alle Städte abfragen (ohne Duplikate)
SELECT DISTINCT stadt FROM users;

-- Anzahl der verschiedenen Städte zählen
SELECT COUNT(DISTINCT stadt) FROM users;

Beispiel:

-- Ohne DISTINCT (Duplikate werden angezeigt)
SELECT stadt FROM users;
/*
| stadt    |
|----------|
| Berlin   |
| Hamburg  |
| Berlin   |
| München  |
| Berlin   |
*/

-- Mit DISTINCT (Duplikate werden entfernt)
SELECT DISTINCT stadt FROM users;
/*
| stadt    |
|----------|
| Berlin   |
| Hamburg  |
| München  |
*/

7.6 Praxisbeispiel: Komplexe Abfragen

Szenario: Eine Online-Shop-Datenbank.

Schritt 1: Testdaten erstellen

CREATE DATABASE IF NOT EXISTS shop_db;
USE shop_db;

CREATE TABLE products (
    produkt_id INT PRIMARY KEY AUTO_INCREMENT,
    produkt_name VARCHAR(200),
    kategorie VARCHAR(50),
    preis DECIMAL(10,2),
    bestand INT,
    erstellt_am DATETIME DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO products (produkt_name, kategorie, preis, bestand)
VALUES 
    ('T-Shirt Basic', 'Kleidung', 19.99, 100),
    ('T-Shirt Premium', 'Kleidung', 29.99, 50),
    ('Jeans', 'Kleidung', 59.99, 30),
    ('Sneaker', 'Schuhe', 89.99, 20),
    ('Rucksack', 'Accessoires', 39.99, 15),
    ('Kappe', 'Accessoires', 14.99, 200),
    ('Socke 3er Pack', 'Kleidung', 9.99, 500);

Schritt 2: Verschiedene Abfragen üben

-- 1. Alle Produkte abfragen
SELECT * FROM products;

-- 2. Nur Namen und Preise abfragen
SELECT produkt_name, preis FROM products;

-- 3. Produkte unter 30 Euro abfragen
SELECT * FROM products 
WHERE preis < 30;

-- 4. Produkte der Kategorie "Kleidung" abfragen
SELECT * FROM products 
WHERE kategorie = 'Kleidung';

-- 5. Produkte mit Bestand unter 20 abfragen (Nachfüllen!)
SELECT * FROM products 
WHERE bestand < 20;

-- 6. Produkte nach Preis aufsteigend sortieren
SELECT * FROM products 
ORDER BY preis ASC;

-- 7. Die 3 teuersten Produkte abfragen
SELECT * FROM products 
ORDER BY preis DESC 
LIMIT 3;

-- 8. Produkte suchen, deren Name "T-Shirt" enthält
SELECT * FROM products 
WHERE produkt_name LIKE '%T-Shirt%';

-- 9. Alle Kategorien anzeigen (ohne Duplikate)
SELECT DISTINCT kategorie FROM products;

Häufige Fehler für Einsteiger

Fehler 1: WHERE falsch verwendet

-- ❌ Falsch: NULL mit = vergleichen
SELECT * FROM users WHERE email = NULL;

-- ✅ Richtig
SELECT * FROM users WHERE email IS NULL;

Fehler 2: LIMIT-Index vergessen

-- ❌ Falsch: Denkt, Seite 2 beginnt bei Index 1
SELECT * FROM users LIMIT 1, 10;  -- Zeigt Datensätze 2-11 an!

-- ✅ Richtig: Seite 2 beginnt bei Index 0 (0-9)
SELECT * FROM users LIMIT 0, 10;  -- Seite 1
SELECT * FROM users LIMIT 10, 10; -- Seite 2

Fehler 3: LIKE ohne Platzhalter

-- ❌ Falsch: LIKE ohne % ist wie =
SELECT * FROM users WHERE username LIKE 'max';  -- Funktioniert, aber Sinn von LIKE nicht genutzt

-- ✅ Richtig: Mit % für Mustersuche
SELECT * FROM users WHERE username LIKE 'm%';  -- Alle Namen, die mit 'm' beginnen

Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Daten mit SELECT abzufragen
• ✅ Bestimmte Felder auszuwählen
• ✅ Felder umzubenennen (AS)
• ✅ Bedingungen mit WHERE zu verwenden
• ✅ Vergleichs- und logische Operatoren
• ✅ Mustersuche mit LIKE
• ✅ NULL-Werte abzufragen
• ✅ Ergebnisse zu sortieren (ORDER BY)
• ✅ Ergebnisse zu begrenzen (LIMIT) - wichtig für Paginierung!
• ✅ Duplikate zu entfernen (DISTINCT)

Übungen

1. Praxis: Erstelle eine Tabelle employees mit Feldern id, name, abteilung, gehalt
2. SELECT: Frage alle Mitarbeiter der Abteilung "IT" ab
3. WHERE: Frage Mitarbeiter ab, deren Gehalt über 50000 liegt
4. ORDER BY: Sortiere Mitarbeiter nach Gehalt absteigend
5. LIMIT: Zeige die 5 am besten bezahlten Mitarbeiter an
6. LIKE: Suche Mitarbeiter, deren Name "Müller" enthält

Nächstes Kapitel

Im nächsten Kapitel lernen wir Aggregatfunktionen und Gruppenabfragen (GROUP BY, HAVING) - sehr wichtig für Statistiken und Berichte!