Vom Datenmodell zur ersten Tabelle

Worum es geht

Elena ist im ersten Lehrjahr bei der Zweirad Kälin AG in Einsiedeln. In der Werkstatt hängt an jedem Velo ein Papierzettel, daneben führt die Werkstattleitung eine Excel-Liste. Das geht gut, bis zwei Personen gleichzeitig in der Liste arbeiten, jemand eine Kundennummer doppelt vergibt oder ein Zettel in der Waschecke landet. Für das neue Online-Buchungstool soll Elena deshalb eine richtige Datenbank aufbauen.

Eine relationale Datenbank ist mehr als eine Excel-Tabelle auf einem Server. Sie speichert Daten in klar definierten Tabellen, lässt viele Programme und Personen gleichzeitig zugreifen und setzt Regeln durch, die niemand umgehen kann: Eine Rahmennummer gibt es nur einmal, ein Auftrag gehört immer zu einem existierenden Velo, ein Preis ist nie negativ.

In diesem Kurs baust du genau diese Werkstattdatenbank, Lektion für Lektion. Am Ende sieht das Modell so aus:

In dieser ersten Lektion legst du das Fundament: Du richtest deine Arbeitsumgebung ein, erstellst die erste Datenbank und die Tabelle kunde, fügst zwei Kundinnen ein und liest sie wieder aus. Nach rund 40 Minuten hast du eine laufende Datenbank und ein Skript, das du beliebig oft ausführen kannst.

Server, Datenbank, Client: wer macht was?

Stell dir ein Lager mit einem strengen Lageristen vor. Du darfst das Lager nicht selbst betreten. Am Schalter gibst du einen schriftlichen Auftrag ab: "Lege diese Kiste ins Regal Kunden" oder "Gib mir alle Kisten aus Einsiedeln". Der Lagerist prüft, ob der Auftrag den Regeln entspricht, führt ihn aus und meldet dir das Ergebnis. Genau so arbeitet ein Datenbanksystem:

Entscheidend ist die Trennung: Die Daten liegen auf dem Server, nicht im Client. Wenn du DBeaver schliesst, bleibt alles erhalten. Und mehrere Clients können gleichzeitig mit demselben Server sprechen: Elena mit DBeaver, das Buchungstool mit seinem eigenen Benutzer, die Werkstattleitung mit einer Auswertung.

MySQL und MariaDB sind eng verwandt: MariaDB ist 2009 als Abspaltung von MySQL entstanden. Die Befehle in diesem Kurs laufen auf beiden. Wo sie sich unterscheiden, steht es dabei.

Deine Arbeitsumgebung in 15 Minuten

Du brauchst zwei Dinge: einen Datenbankserver und einen Client. Wähle eine der zwei Varianten.

Variante A: Docker (empfohlen). Mit Docker Desktop startest du einen aktuellen MySQL-Server in einem Container. Ein Befehl im Terminal genügt (alles auf einer Zeile):

docker run -d --name werkstatt-db -e MYSQL_ROOT_PASSWORD=Werkstatt-Root-2026 -p 3306:3306 -v werkstatt-daten:/var/lib/mysql mysql:8.4

Die Teile bedeuten: -d startet den Container im Hintergrund, --name gibt ihm einen Namen, -e setzt das root-Passwort, -p 3306:3306 macht den Standardport von MySQL auf deinem Rechner erreichbar, und -v werkstatt-daten:/var/lib/mysql speichert die Daten in einem Docker-Volume. Ohne Volume wären die Daten weg, sobald du den Container löschst. Wer lieber MariaDB nutzt, ersetzt das Image durch mariadb:11.4 und die Variable durch MARIADB_ROOT_PASSWORD.

Variante B: XAMPP. Im XAMPP Control Panel startest du das Modul "MySQL". Dahinter steckt MariaDB, in den verbreiteten XAMPP-Versionen 10.4. Das reicht für diesen Kurs, hat aber eine Tücke, die du kennen musst:

Der Client. Installiere DBeaver Community (kostenlos) und lege eine neue Verbindung an: Typ MySQL (bzw. MariaDB), Host localhost, Port 3306, Benutzer root, dein Passwort. Klicke auf "Test Connection". Meldet DBeaver bei MySQL 8 "Public Key Retrieval is not allowed", setzt du in den Treibereigenschaften allowPublicKeyRetrieval auf true. Für eine lokale Übungsumgebung ist das in Ordnung.

Öffne danach einen SQL-Editor und führe deinen ersten Befehl aus:

SELECT VERSION();

Erscheint eine Versionsnummer wie 8.4.6 oder 10.4.32-MariaDB, läuft alles.

Zwei Sorten von SQL-Befehlen

SQL-Befehle lassen sich in Gruppen einteilen. Für dieses Modul brauchst du vor allem die ersten beiden:

SELECT wird je nach Lehrmittel zur DML gezählt oder als eigene Gruppe (DQL) geführt. Wichtig ist der Unterschied: DDL baut das Regal, DML legt Kisten hinein oder nimmt sie heraus.

Schritt für Schritt: die erste Tabelle der Werkstatt

Elena beginnt mit der Tabelle kunde. Mach es ihr nach.

Schritt 1: Skriptdatei anlegen. Erstelle einen Ordner werkstatt-db und darin die Datei 01_schema.sql. Öffne sie in DBeaver oder VS Code. Alles, was du ab jetzt schreibst, kommt in diese Datei und nicht direkt in eine Konsole. So kannst du die Datenbank jederzeit neu aufbauen.

Schritt 2: Datenbank anlegen.

-- 01_schema.sql: Werkstattdatenbank der Zweirad Kälin AG
-- Achtung: löscht die Datenbank! Nur in der Entwicklungsumgebung verwenden.
DROP DATABASE IF EXISTS zweirad;

CREATE DATABASE zweirad
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;

USE zweirad;

DROP DATABASE IF EXISTS löscht eine allfällige alte Version, damit das Skript bei jedem Lauf vom gleichen Stand ausgeht. CHARACTER SET utf8mb4 sorgt dafür, dass alle Zeichen gespeichert werden können, vom "ä" bis zum Emoji. Die Collation utf8mb4_unicode_ci legt fest, wie verglichen und sortiert wird; ci heisst "case insensitive", Gross- und Kleinschreibung zählt beim Vergleichen also nicht. USE zweirad wählt die Datenbank aus, in der die folgenden Befehle wirken.

Schritt 3: Tabelle anlegen.

CREATE TABLE kunde (
  kunde_id  INT UNSIGNED NOT NULL AUTO_INCREMENT,
  vorname   VARCHAR(50)  NOT NULL,
  nachname  VARCHAR(50)  NOT NULL,
  ort       VARCHAR(50)  NULL,
  PRIMARY KEY (kunde_id)
);

Zeile für Zeile: kunde_id ist eine ganze Zahl ohne Vorzeichen (INT UNSIGNED), die der Server bei jedem neuen Datensatz selbst hochzählt (AUTO_INCREMENT). PRIMARY KEY (kunde_id) macht sie zum Primärschlüssel: Jede Kundin ist darüber eindeutig erkennbar. VARCHAR(50) ist Text mit höchstens 50 Zeichen. NOT NULL heisst, das Feld muss ausgefüllt sein. Beim Ort ist NULL erlaubt, weil er bei einer Telefonbuchung vielleicht noch fehlt. Datentypen und Regeln vertiefst du in den Lektionen 2 und 3.

Schritt 4: Struktur prüfen.

DESCRIBE kunde;

+----------+--------------+------+-----+---------+----------------+
| Field    | Type         | Null | Key | Default | Extra          |
+----------+--------------+------+-----+---------+----------------+
| kunde_id | int unsigned | NO   | PRI | NULL    | auto_increment |
| vorname  | varchar(50)  | NO   |     | NULL    |                |
| nachname | varchar(50)  | NO   |     | NULL    |                |
| ort      | varchar(50)  | YES  |     | NULL    |                |
+----------+--------------+------+-----+---------+----------------+

MariaDB zeigt int(10) unsigned. Die Zahl in Klammern ist nur eine Anzeigebreite und keine Grösse.

Schritt 5: Zwei Kundinnen einfügen.

INSERT INTO kunde (vorname, nachname, ort)
VALUES ('Martina', 'Kälin', 'Einsiedeln'),
       ('Sandra', 'Bürgi', 'Unteriberg');

Die kunde_id gibst du nicht an, die vergibt AUTO_INCREMENT. Texte stehen in einfachen Anführungszeichen.

Schritt 6: Ergebnis kontrollieren.

SELECT kunde_id, vorname, nachname, ort FROM kunde;

+----------+---------+----------+------------+
| kunde_id | vorname | nachname | ort        |
+----------+---------+----------+------------+
|        1 | Martina | Kälin    | Einsiedeln |
|        2 | Sandra  | Bürgi    | Unteriberg |
+----------+---------+----------+------------+

Schritt 7: Wiederholbarkeit beweisen. Führe das ganze Skript mit Alt+X ein zweites Mal aus. Es läuft wieder fehlerfrei durch, und du hast wieder genau zwei Kundinnen mit den IDs 1 und 2. Genau das ist das Ziel: ein Skript, das immer zum gleichen Ergebnis führt.

Jetzt bist du dran. Im Labor läuft SQLite direkt im Browser, damit du sofort üben kannst. Ein Unterschied zu MySQL: Eine automatisch hochzählende ID schreibst du dort als INTEGER PRIMARY KEY.

PRAGMA foreign_keys = ON;
-- Leere Datenbank: Du legst alles selbst an.

Und gleich noch einmal, diesmal in eine Tabelle, die es schon gibt:

PRAGMA foreign_keys = ON;
CREATE TABLE servicepaket (
  servicepaket_id INTEGER PRIMARY KEY,
  bezeichnung     VARCHAR(60)  NOT NULL UNIQUE,
  preis           DECIMAL(8,2) NOT NULL,
  dauer_min       INTEGER      NOT NULL,
  aktiv           BOOLEAN      NOT NULL DEFAULT 1
);
INSERT INTO servicepaket (bezeichnung, preis, dauer_min) VALUES
  ('Frühlingsservice', 89.00, 60),
  ('E-Bike-Check', 129.00, 90),
  ('Platten flicken', 25.00, 20);

Typische Fehler

1. "No database selected" (Fehler 1046). Du hast CREATE TABLE ausgeführt, ohne vorher USE zweirad; laufen zu lassen. Lösung: USE gehört an den Anfang des Skripts, oder du schreibst den Tabellennamen mit Datenbank: zweirad.kunde.
2. Nur eine Zeile ausgeführt. Mit Ctrl+Enter läuft in DBeaver nur die aktuelle Anweisung. Erscheint danach "Table doesn't exist", war die CREATE TABLE-Anweisung nie dran. Lösung: ganzes Skript mit Alt+X.
3. Typografische Anführungszeichen. Wer SQL aus Word, Teams oder einem PDF kopiert, erhält oft schräge Zeichen wie ’ statt '. Der Server meldet dann einen Syntaxfehler (1064). Lösung: SQL im Editor schreiben und Anführungszeichen ersetzen.
4. "Table 'kunde' already exists" (Fehler 1050). Das Skript lief ein zweites Mal, ohne die alte Tabelle zu entfernen. Lösung: DROP DATABASE IF EXISTS am Skriptanfang (nur in der Entwicklung) oder CREATE TABLE IF NOT EXISTS.
5. Zeichensatz vergessen. Ohne CHARACTER SET utf8mb4 nimmt der Server seine Voreinstellung, bei älteren MariaDB-Versionen ist das latin1. Emojis und viele Namen aus anderen Sprachen lassen sich dann nicht speichern. Lösung: Zeichensatz immer ausdrücklich angeben.

Zusammenfassung

• Der Datenbankserver speichert die Daten, der Client (DBeaver, Workbench, deine App) schickt SQL und zeigt Ergebnisse.
• Eine Datenbank fasst zusammengehörige Tabellen zusammen. Tabellen bestehen aus Spalten mit festem Datentyp und aus Zeilen (Datensätzen).
• DDL (CREATE, ALTER, DROP) definiert die Struktur, DML (INSERT, UPDATE, DELETE) bearbeitet die Daten, SELECT liest sie.
• Lege Datenbanken immer mit CHARACTER SET utf8mb4 an und wähle sie mit USE aus.
• Schreibe alles in eine Skriptdatei, die du beliebig oft von vorne ausführen kannst.
• Prüfe jeden Schritt sofort mit DESCRIBE oder SELECT, nicht erst am Schluss.