Abschnitt 14 · Lektion 8
Die Liste mit Datenbank
Für die Seite allein ist es kein Problem, dass sie selbst verbindet, abfragt und Markup schreibt. Soll aber nachts ein Skript dieselben Notizen auswerten, kommt es an ihr SQL nur heran, indem du es abschreibst.
Die Notizliste vom Ende des Abschnitts 11 zieht hier aus ihrer JSON-Datei in eine Datenbank um. Neuen Stoff braucht es dafür nicht. Verbinden, Tabelle anlegen, mit Platzhalter einfügen und abfragen reichen.
Alles in einer Datei
<?php
declare(strict_types=1);
// Alles in einer Datei: Verbindung, Tabelle, Abfrage, Formular,
// Ausgabe. So faengt ein kleines Projekt oft an.
$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("CREATE TABLE IF NOT EXISTS notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL
)");
if ($_SERVER["REQUEST_METHOD"] === "POST") {
$text = trim($_POST["text"] ?? "");
if ($text !== "") {
$einfuegen = $db->prepare("INSERT INTO notizen (titel) VALUES (:titel)");
$einfuegen->execute([":titel" => $text]);
}
header("Location: /", true, 302);
exit;
}
$notizen = $db->query("SELECT id, titel FROM notizen ORDER BY id DESC")->fetchAll();
?>
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Notizen, alles in einer Datei</title>
<style>body { font-family: system-ui, sans-serif; max-width: 32rem; margin: 2rem auto; }</style>
</head>
<body>
<h1>Notizen</h1>
<p>Diese Seite macht alles selbst, vom SQL bis zum Markup.</p>
<form method="post" action="/">
<p><label>Neue Notiz: <input type="text" name="text" size="30"></label></p>
<button type="submit">Anlegen</button>
</form>
<ul>
<?php foreach ($notizen as $notiz) { ?>
<li>#<?= $notiz["id"] ?> <?= htmlspecialchars($notiz["titel"], ENT_QUOTES, "UTF-8") ?></li>
<?php } ?>
</ul>
</body>
</html> So sieht es aus, wenn man einfach anfängt, und es ist völlig in Ordnung. Die Seite läuft, im Reiter Browser kannst du Notizen anlegen, und für zwanzig Zeilen ist das die schnellste Lösung.
Allerdings steckt in dieser einen Datei eine ganze Menge. Sie kennt den Pfad zur Datenbankdatei,
die Spalten der Tabelle und zwei SQL-Anweisungen, und außerdem liest sie $_POST, schickt
Kopfzeilen und erzeugt HTML. Das sind sechs Zuständigkeiten in einer Datei.
Solange es bei der einen Datei bleibt, merkt man davon nichts. Der Ärger fängt bei der zweiten an.
Eine Seite erledigt.php, die nur die abgehakten Notizen zeigt, braucht dieselbe Verbindung und
dasselbe CREATE TABLE, also wird kopiert. Kommt beim nächsten Mal eine Spalte dazu, änderst du an
zwei Stellen. Oder nur an einer, und die zweite geht kaputt.
Dasselbe mit einer Klasse dazwischen
<?php
declare(strict_types=1);
// Legt drei Notizen hin, damit die Liste etwas zu zeigen hat. Bei
// jedem Aufruf neu aufgebaut.
$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)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel) VALUES (?)");
foreach (["Milch", "Brot", "Zahnpasta"] as $titel) {
$einfuegen->execute([$titel]);
} <?php
declare(strict_types=1);
// Alles, was mit Speichern zu tun hat, und sonst nichts. Kein Markup,
// kein $_POST, kein header(). Diese Fassung kann nur lesen.
class NotizSpeicher
{
private PDO $db;
public function __construct(string $datei)
{
$this->db = new PDO("sqlite:" . $datei, null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$this->db->exec("CREATE TABLE IF NOT EXISTS notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL
)");
}
public function alle(): array
{
return $this->db->query("SELECT id, titel FROM notizen ORDER BY id DESC")->fetchAll();
}
} <?php
declare(strict_types=1);
// Dieselbe Liste. Die Seite kennt PDO nicht mehr und kein SQL,
// vorbereiten.php legt nur die drei Notizen hin.
require __DIR__ . "/vorbereiten.php";
require __DIR__ . "/NotizSpeicher.php";
$speicher = new NotizSpeicher(__DIR__ . "/daten.db");
$notizen = $speicher->alle();
?>
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Notizen mit NotizSpeicher</title>
<style>body { font-family: system-ui, sans-serif; max-width: 32rem; margin: 2rem auto; }</style>
</head>
<body>
<h1>Notizen</h1>
<p>Dieselbe Liste, nur weiß sie nicht mehr, wo die Notizen liegen.</p>
<ul>
<?php foreach ($notizen as $notiz) { ?>
<li>#<?= $notiz["id"] ?> <?= htmlspecialchars($notiz["titel"], ENT_QUOTES, "UTF-8") ?></li>
<?php } ?>
</ul>
</body>
</html> Die Seite ist danach kürzer. Wichtiger ist aber, was nicht mehr in ihr steht. Kein PDO, kein SQL und
keine Spaltennamen. Sie ruft alle() auf, und wo die Notizen liegen, ist nicht ihr Problem. Die
drei Notizen legt hier vorbereiten.php hin, denn anlegen kann diese Fassung der Klasse noch
nichts.
Eine Klasse bündelt Daten und die Dinge, die man damit tut, wie die Notiz aus dem Abschnitt über
Funktionen, nur diesmal an etwas Echtem. Hier bündelt sie die Verbindung und alles, was mit ihr
passiert. Den Namen NotizSpeicher gab es im Abschnitt über Objekte schon einmal, dort für ein
Interface und damit nur als Zusage. Diese Klasse setzt es nicht um, die beiden begegnen sich
nirgends.
Getrennt wird nach einer einfachen Frage. Ändert sich etwas, weil die Anzeige anders wird, oder weil die Speicherung anders wird? Das Markup gehört zur Anzeige und das SQL zur Speicherung. Die beiden ändern sich zu verschiedenen Zeiten und aus verschiedenen Gründen, also kommen sie in verschiedene Dateien.
Ein Wechsel von SQLite auf MySQL ist damit eine Änderung an einer einzigen Datei. In der Fassung davor wäre es eine Suche über das ganze Projekt.
<?php
declare(strict_types=1);
// Legt drei Notizen hin, damit der Bericht etwas zu zaehlen hat. Bei
// jedem Lauf neu aufgebaut.
$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)");
$einfuegen = $db->prepare("INSERT INTO notizen (titel) VALUES (?)");
foreach (["Milch", "Brot", "Zahnpasta"] as $titel) {
$einfuegen->execute([$titel]);
} <?php
declare(strict_types=1);
// Alles, was mit Speichern zu tun hat, und sonst nichts. Kein Markup,
// kein $_POST, kein header(). Diese Fassung kann nur lesen.
class NotizSpeicher
{
private PDO $db;
public function __construct(string $datei)
{
$this->db = new PDO("sqlite:" . $datei, null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$this->db->exec("CREATE TABLE IF NOT EXISTS notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL
)");
}
public function alle(): array
{
return $this->db->query("SELECT id, titel FROM notizen ORDER BY id DESC")->fetchAll();
}
} <?php
declare(strict_types=1);
// Dieselbe Klasse, ohne Webserver. Ein Skript fuer die Kommandozeile,
// das sich um Formulare und Markup nicht kuemmert.
require __DIR__ . "/vorbereiten.php";
require __DIR__ . "/NotizSpeicher.php";
$speicher = new NotizSpeicher(__DIR__ . "/daten.db");
echo "Alle Notizen, die neueste zuerst:\n";
foreach ($speicher->alle() as $notiz) {
echo " #", $notiz["id"], " ", $notiz["titel"], "\n";
}
echo "\nInsgesamt ", count($speicher->alle()), " Stück.\n"; Am dritten Beispiel siehst du, dass die Trennung echt ist und nicht nur ordentlich aussieht.
Dasselbe NotizSpeicher.php läuft dort in einem Skript für die Kommandozeile, ohne Formular, ohne
HTML und ohne Webserver, und an der Klasse ändert sich dafür kein einziges Zeichen. So entsteht
später ein Import, eine Auswertung oder ein nächtlicher Aufräumjob.
Was diese Klasse noch nicht kann
Sie ist eine Klasse mit einer Verbindung und ein paar Methoden, und für diese Anwendung reicht das.
Mit Absicht öffnet sie bei jeder Anfrage eine neue Verbindung und ruft jedes Mal
CREATE TABLE IF NOT EXISTS auf. Bei SQLite ist das billig. Bei einem Datenbankserver ist es das
nicht mehr, dort legt man das Schema einmal an und nicht bei jedem Aufruf. Außerdem gibt sie
einfache Arrays zurück und keine Objekte. Für eine Notiz mit zwei Spalten reicht das, und ab einer
gewissen Größe wird daraus eine Klasse Notiz.
In Abschnitt 16 wird aus solchen Teilen eine ganze Anwendung.
Dem NotizSpeicher in der Aufgabe fehlt noch die Methode, mit der die Seite eine Notiz anlegt.
Zum Mitnehmen
Das SQL gehört in eine eigene Klasse und nicht in die Seite. Die Seite ruft nur noch anlegen() und alle() auf, und dieselbe Klasse läuft auch in einem Skript ohne Webserver.
Jetzt du
Basis Konto, kostenlosZu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.
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.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.