Abschnitt 14 · Lektion 1
Warum eine Datenbank
Eine Notizliste in einer JSON-Datei geht gut, solange sie klein bleibt und nur einer daran schreibt. Bei zwanzigtausend Notizen liest jede Suche alle zwanzigtausend ein. Und schreiben zwei gleichzeitig, ist eine Notiz weg.
Auch dieser Abschnitt läuft auf der Kommandozeile, also steht die Ausgabe im Terminal. Im Reiter Browser ist erst gegen Ende wieder etwas zu sehen, eine Tabelle in der Lektion über zwei Tabellen und danach die Notizliste als Seite.
Zwei, die gleichzeitig schreiben
Der Fall stand schon in der Liste am Ende von Abschnitt 11. Zwei Anfragen kommen fast gleichzeitig an. Beide lesen dieselbe Datei, beide hängen ihre Notiz an das gelesene Array an, und beide schreiben zurück. Wer zuletzt schreibt, gewinnt. Die Notiz des anderen fehlt danach ganz, und niemand bekommt eine Fehlermeldung.
Auf deinem Rechner passiert das nie, du bist ja allein. Auf einem Server mit vielen Besuchern
passiert es früher oder später. Mit flock() lässt sich die Datei sperren, solange einer liest und
zurückschreibt, und damit hast du schon ein erstes Stück von dem gebaut, was eine Datenbank ohnehin
tut.
Suchen
[
{ "titel": "Milch", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-24" },
{ "titel": "Brot", "verfasser": "Ben", "erledigt": false, "angelegt": "2026-08-23" },
{ "titel": "Kaffee", "verfasser": "Mia", "erledigt": true, "angelegt": "2026-08-22" },
{ "titel": "Zahnpasta", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-21" },
{ "titel": "Batterien", "verfasser": "Ben", "erledigt": true, "angelegt": "2026-08-20" },
{ "titel": "Kerzen", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-19" },
{ "titel": "Seife", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-18" },
{ "titel": "Tee", "verfasser": "Ben", "erledigt": false, "angelegt": "2026-08-17" }
] <?php
declare(strict_types=1);
// Die Aufgabe: die drei neuesten offenen Notizen von Mia.
// Mit einer Datei musst du jeden Schritt selbst machen.
$notizen = json_decode(file_get_contents(__DIR__ . "/notizen.json"), true);
$treffer = [];
foreach ($notizen as $notiz) {
if ($notiz["verfasser"] === "Mia" && $notiz["erledigt"] === false) {
$treffer[] = $notiz;
}
}
usort($treffer, fn(array $a, array $b) => strcmp($b["angelegt"], $a["angelegt"]));
$treffer = array_slice($treffer, 0, 3);
foreach ($treffer as $notiz) {
echo $notiz["angelegt"], " ", $notiz["titel"], "\n";
} Gesucht sind die drei neuesten offenen Notizen von Mia. Eine harmlose Frage. Für die Antwort wird
erst die ganze Datei gelesen und in ein Array verwandelt, dann wird gefiltert, sortiert und
abgeschnitten. Jeder dieser Schritte steht als eigener Code da, für das Filtern eine ganze Schleife
und für das Sortieren eine Vergleichsfunktion. Im Reiter Debug wächst treffer dabei auf vier
Einträge, und erst array_slice macht drei daraus.
Bei acht Notizen merkt man davon nichts. Bei zwanzigtausend merkt man es bei jedem einzelnen Seitenaufruf.
[
{ "titel": "Milch", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-24" },
{ "titel": "Brot", "verfasser": "Ben", "erledigt": false, "angelegt": "2026-08-23" },
{ "titel": "Kaffee", "verfasser": "Mia", "erledigt": true, "angelegt": "2026-08-22" },
{ "titel": "Zahnpasta", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-21" },
{ "titel": "Batterien", "verfasser": "Ben", "erledigt": true, "angelegt": "2026-08-20" },
{ "titel": "Kerzen", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-19" },
{ "titel": "Seife", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-18" },
{ "titel": "Tee", "verfasser": "Ben", "erledigt": false, "angelegt": "2026-08-17" }
] <?php
declare(strict_types=1);
// Diese Datei baut die Datenbank aus notizen.json auf, damit nebenan
// etwas zum Abfragen da ist. Wie das geht, steht in Lektion 14.2.
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("DROP TABLE IF EXISTS notizen");
$db->exec("CREATE TABLE notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
verfasser TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0,
angelegt TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel, verfasser, erledigt, angelegt)
VALUES (:titel, :verfasser, :erledigt, :angelegt)");
foreach (json_decode(file_get_contents(__DIR__ . "/notizen.json"), true) as $notiz) {
$einfuegen->execute([
":titel" => $notiz["titel"],
":verfasser" => $notiz["verfasser"],
":erledigt" => $notiz["erledigt"] ? 1 : 0,
":angelegt" => $notiz["angelegt"],
]);
} <?php
declare(strict_types=1);
// Dieselbe Aufgabe, dieselben acht Notizen: die drei neuesten offenen
// von Mia. Diesmal steht die Frage in der Abfrage.
require __DIR__ . "/vorbereiten.php";
$zeilen = $db->query("SELECT angelegt, titel
FROM notizen
WHERE verfasser = 'Mia' AND erledigt = 0
ORDER BY angelegt DESC
LIMIT 3")->fetchAll();
foreach ($zeilen as $zeile) {
echo $zeile["angelegt"], " ", $zeile["titel"], "\n";
} Dasselbe Ergebnis aus denselben acht Notizen. In der Mitte steht statt vier Schritten eine Frage, und zwar in einer eigenen Sprache. Sie heißt SQL. Ein Stück SQL heißt Anweisung (englisch statement), und eine, die etwas liest, heißt Abfrage (englisch query). Diese hier kannst du schon jetzt lesen, obwohl du noch keine geschrieben hast.
SELECT angelegt, titel sagt, welche Spalten du willst, FROM notizen, aus welcher Tabelle.
WHERE ist die Bedingung, ORDER BY ... DESC die Sortierung und LIMIT 3 die Begrenzung. Das sind
die vier Schritte von oben. Nur steht in der Abfrage, was du haben willst, und nicht, wie man es
findet.
Das Wie entscheidet die Datenbank selbst, und deshalb kann sie es gut machen. Sie kann sich eine sortierte Übersicht anlegen, einen sogenannten Index. Dann sind die drei Treffer auch unter zwanzigtausend Notizen sofort da, ohne dass sich an der Abfrage ein Zeichen ändert.
Dinge, die zusammengehören
In der JSON-Datei steht bei jeder Notiz ein verfasser, und fünf der acht Einträge nennen dort Mia.
Heiratet Mia und heißt danach anders, sind fünf Stellen zu ändern. Wird eine vergessen, gibt es zwei
Mias, und keine Suche findet mehr beide.
Der Ausweg ist, Verfasser und Notizen getrennt zu führen und in der Notiz nur noch die Nummer des
Verfassers abzulegen. Mit Dateien hieße das, bei jeder Anzeige zwei Dateien zu lesen und die
passenden Einträge selbst zusammenzusuchen. Eine Datenbank erledigt das mit einem Wort, JOIN. Wie
das geht, kommt in der Lektion über zwei Tabellen.
Was eine Datenbank stattdessen tut
Eine Datenbank ist ein Programm, das deine Daten verwaltet. Dabei übernimmt sie drei Dinge, die eine Datei nicht kann. Sie ordnet gleichzeitige Zugriffe, und niemandem geht etwas verloren. Sie beantwortet Fragen selbst, statt dir alles hinzustellen. Und sie achtet auf Regeln, die du einmal festlegst, etwa dass jede Notiz einen Titel haben muss.
Der Preis dafür ist eine zweite Sprache im Programm. SQL sieht anfangs fremd aus. Trotzdem kommst du mit einer Handvoll Wörter weit, und die kommen alle in diesem Abschnitt vor.
SQLite und MySQL
SQLite ist eine Datei. Deine Datenbank liegt als daten.db neben deinem Programm, es läuft kein
zweites Programm daneben, und PHP bringt alles mit, was es dafür braucht. Kopieren, sichern und
weitergeben lässt sie sich wie jede andere Datei.
MySQL und PostgreSQL sind Dienste. Dort läuft ein eigener Serverprozess, und dein Programm meldet sich mit Adresse, Nutzername und Passwort an. Dafür können mehrere Programme auf mehreren Rechnern gleichzeitig darauf zugreifen. Das ist mehr Aufwand und lohnt sich irgendwann.
Ich fange in diesem Kurs mit SQLite an, denn ein Umstieg später kostet wenig. Im PHP-Code ändert sich die Zeile, in der du dich verbindest, und bei MySQL kommt eine Option dazu. Am SQL ändert sich mehr, als man denkt. Bei PostgreSQL vergibt eine Tabelle wie die in diesem Abschnitt ihre Nummern zum Beispiel nicht von selbst. Wo etwas nur für SQLite gilt, steht das an der Stelle dabei.
Vier Wörter, die du ab jetzt brauchst
[
{ "titel": "Milch", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-24" },
{ "titel": "Brot", "verfasser": "Ben", "erledigt": false, "angelegt": "2026-08-23" },
{ "titel": "Kaffee", "verfasser": "Mia", "erledigt": true, "angelegt": "2026-08-22" },
{ "titel": "Zahnpasta", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-21" },
{ "titel": "Batterien", "verfasser": "Ben", "erledigt": true, "angelegt": "2026-08-20" },
{ "titel": "Kerzen", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-19" },
{ "titel": "Seife", "verfasser": "Mia", "erledigt": false, "angelegt": "2026-08-18" },
{ "titel": "Tee", "verfasser": "Ben", "erledigt": false, "angelegt": "2026-08-17" }
] <?php
declare(strict_types=1);
// Dieselbe Vorbereitung wie im Beispiel davor.
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("DROP TABLE IF EXISTS notizen");
$db->exec("CREATE TABLE notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
verfasser TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0,
angelegt TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel, verfasser, erledigt, angelegt)
VALUES (:titel, :verfasser, :erledigt, :angelegt)");
foreach (json_decode(file_get_contents(__DIR__ . "/notizen.json"), true) as $notiz) {
$einfuegen->execute([
":titel" => $notiz["titel"],
":verfasser" => $notiz["verfasser"],
":erledigt" => $notiz["erledigt"] ? 1 : 0,
":angelegt" => $notiz["angelegt"],
]);
} <?php
declare(strict_types=1);
// Vier Woerter, an einer echten Tabelle.
require __DIR__ . "/vorbereiten.php";
$spalten = $db->query("PRAGMA table_info(notizen)")->fetchAll();
echo "Die Tabelle heißt notizen und hat ", count($spalten), " Spalten:\n";
foreach ($spalten as $spalte) {
echo " ", str_pad($spalte["name"], 12), $spalte["type"];
echo $spalte["pk"] ? " <- Primärschlüssel" : "";
echo "\n";
}
echo "\nUnd das sind die ersten drei Zeilen:\n";
foreach ($db->query("SELECT * FROM notizen ORDER BY id LIMIT 3") as $zeile) {
echo " ", implode(" | ", $zeile), "\n";
}
echo "\nZwei Zeilen dürfen denselben Titel haben:\n";
$db->exec("INSERT INTO notizen (titel, verfasser, erledigt, angelegt)
VALUES ('Milch', 'Ben', 0, '2026-08-25')");
echo " Notizen mit dem Titel Milch: ";
echo $db->query("SELECT count(*) FROM notizen WHERE titel = 'Milch'")->fetchColumn(), "\n";
echo "\nDieselbe Nummer zweimal geht dagegen nicht:\n";
try {
$db->exec("INSERT INTO notizen (id, titel, verfasser, erledigt, angelegt)
VALUES (1, 'Noch mehr Milch', 'Ben', 0, '2026-08-25')");
echo " angenommen\n";
} catch (PDOException $fehler) {
echo " ", $fehler->getMessage(), "\n";
} Eine Tabelle (englisch table) ist das, was in der JSON-Datei die Liste war, alle Notizen zusammen.
Eine Zeile (row) ist eine einzelne Notiz. Eine Spalte (column) ist eine Eigenschaft, die jede Notiz
hat, also titel oder erledigt.
Anders als beim Array liegt vorher fest, welche Spalten es gibt und was für Werte hineindürfen, und
mit PRAGMA table_info(notizen) kannst du dir das jederzeit ansehen. PRAGMA ist bei SQLite das
Wort für Informationen und Einstellungen, die es nur dort gibt.
Das vierte Wort ist das wichtigste. Der Primärschlüssel (englisch primary key) ist die Spalte,
die eine Zeile eindeutig macht, hier id. Zwei Notizen dürfen denselben Titel tragen. Im Beispiel
gibt es eine zweite Milch, und niemand beschwert sich. Dieselbe Nummer zweimal geht dagegen nicht,
und die letzte Zeile der Ausgabe meldet dazu UNIQUE constraint failed: notizen.id.
In der JSON-Datei war eine Notiz „die dritte von oben“, und sobald jemand die zweite löscht, ist sie
die zweite. Hat sie eine Nummer, die fest zu ihr gehört, kannst du sie ansprechen, ändern und
löschen, ohne mitzuzählen. Bei SQLite gilt das mit einer Einschränkung. Wird die Notiz mit der
höchsten Nummer gelöscht, bekommt die nächste neue dieselbe Nummer wieder. Erst AUTOINCREMENT
hinter dem Schlüssel verhindert das.
Zum Mitnehmen
Eine JSON-Datei verliert Einträge, wenn zwei gleichzeitig schreiben, liest für jede Suche alles ein und kennt keine Beziehungen. Eine Datenbank übernimmt alle drei Aufgaben, und SQLite ist dabei eine einzige Datei neben dem Programm.
Jetzt du
Basis Konto, kostenlosIm Editor änderst du die Beispiele dieser Lektion und lässt sie gleich laufen. So merkst du am schnellsten, ob es sitzt.
Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.
In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.
Was in dieser Lektion steckt
-
Artikel mit 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.