Abschnitt 14 · Lektion 2
Verbinden und anlegen
Für MySQL, PostgreSQL und SQLite bringt PHP je eigene Funktionen mit. Benutzt du die, änderst du beim Umstieg jeden Aufruf im Projekt. Dazwischen sitzt deshalb eine Schicht namens PDO, kurz für PHP Data Objects. Mit PDO sieht der Code, mit dem du abfragst, einfügst und änderst, bei SQLite genauso aus wie bei MySQL oder PostgreSQL. Nur die allererste Codezeile ist eine andere.
Was im DSN steht
In dieser ersten Codezeile steht das Ziel, der Data Source Name, kurz DSN. Bei SQLite besteht er aus
dem Wort sqlite, einem Doppelpunkt und einem Dateipfad, also sqlite:/pfad/zu/daten.db.
Rechnername, Nutzername und Passwort fallen weg. Bei MySQL stünde dort
mysql:host=localhost;dbname=notizen, und Nutzername und Passwort kämen als zweites und drittes
Argument dazu.
Ich nehme den Pfad immer absolut, also mit __DIR__ davor. Ein relativer Pfad zeigt auf das
Arbeitsverzeichnis des Prozesses, und das ist nicht immer der Ordner, in dem deine Datei liegt. Bei
einem Webserver kann es ein ganz anderer sein. Dann legt PHP dort eine zweite, leere Datenbank an,
statt sich zu beschweren.
<?php
declare(strict_types=1);
// Wann taucht die Datei auf, und wann waechst sie?
$datei = __DIR__ . "/daten.db";
echo "Vor der Verbindung da: ", file_exists($datei) ? "ja" : "nein", "\n";
$db = new PDO("sqlite:" . $datei, null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
clearstatcache();
echo "Nach der Verbindung da: ", file_exists($datei) ? "ja" : "nein";
echo ", ", filesize($datei), " Bytes\n";
$db->exec("CREATE TABLE IF NOT EXISTS notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0
)");
clearstatcache();
echo "Nach der Tabelle: ", filesize($datei), " Bytes\n";
$db->exec("INSERT INTO notizen (titel) VALUES ('Milch')");
clearstatcache();
echo "Nach der ersten Notiz: ", filesize($datei), " Bytes\n"; Vor der Verbindung gibt es nichts, danach eine Datei mit 0 Bytes. Erst mit der ersten Tabelle wird sie 8192 Bytes groß, und mit der ersten Notiz wächst sie nicht weiter. SQLite teilt die Datei in Blöcke zu 4096 Bytes. Im ersten steht die Liste der Tabellen. Jede Tabelle bekommt beim Anlegen einen eigenen, und in dem ist für die erste Notiz noch Platz.
ls -la zeigt die Datei danach mit ihren 8192 Bytes, head -c 16 daten.db ihren Anfang,
SQLite format 3. Beim zweiten php index.php steht in der ersten Zeile ja. Die Datei bleibt
bei 8192 Bytes, obwohl eine zweite Notiz dazukommt.
Die zwei Optionen, die ich setze
Das vierte Argument von new PDO ist ein Array mit Optionen. Zwei davon stehen in jeder Datei
dieses Kurses, die eine Datenbank öffnet. Ausgenommen sind nur die beiden Beispiele hier, denn an
denen siehst du, was ohne sie passiert.
<?php
declare(strict_types=1);
// Eine Notiz, zwei Abholarten, und die Schluessel sind verschieden.
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
]);
$db->exec("CREATE TABLE IF NOT EXISTS notizen (
id INTEGER PRIMARY KEY,
titel TEXT NOT NULL,
erledigt INTEGER NOT NULL DEFAULT 0
)");
$db->exec("INSERT INTO notizen (titel) VALUES ('Milch')");
echo "Ohne die Option, also FETCH_BOTH:\n";
print_r($db->query("SELECT * FROM notizen")->fetch());
$db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
echo "\nMit PDO::FETCH_ASSOC:\n";
print_r($db->query("SELECT * FROM notizen")->fetch()); PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC ist die wichtigere, weil ihr Standardwert
wirklich stört. Ohne sie liefert PDO jede Zeile doppelt, einmal unter dem Spaltennamen und einmal
unter einer Nummer. Im Beispiel sind das sechs Einträge für drei Spalten. Kaputt ist daran nichts,
es ist nur die doppelte Menge Daten. Ein foreach über so eine Zeile läuft aber zweimal durch
dieselben Werte. Ausgegeben wird die Zeile mit print_r(), das ein Array knapper zeigt als
var_dump, nur mit Schlüsseln und Werten und ohne Typen.
<?php
declare(strict_types=1);
// Dieselbe Abfrage auf eine Tabelle, die es nicht gibt. Zweimal.
// Der einzige Unterschied ist eine Option.
$dsn = "sqlite:" . __DIR__ . "/daten.db";
$laut = new PDO($dsn, null, null, [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);
try {
$laut->query("SELECT * FROM gibtesnicht");
echo "Laut: hier kommt niemand an\n";
} catch (PDOException $fehler) {
echo "Laut: ", $fehler->getMessage(), "\n";
}
$still = new PDO($dsn, null, null, [PDO::ATTR_ERRMODE => PDO::ERRMODE_SILENT]);
$ergebnis = $still->query("SELECT * FROM gibtesnicht");
echo "Still: query() liefert ";
var_dump($ergebnis);
echo "Still: und der Grund steht nur hier: ", implode(" ", $still->errorInfo()), "\n";
echo "\nUnd das ist der Standardwert, wenn du gar nichts angibst:\n";
$standard = new PDO($dsn);
echo " ATTR_ERRMODE: ", $standard->getAttribute(PDO::ATTR_ERRMODE);
echo " (SILENT=", PDO::ERRMODE_SILENT, ", WARNING=", PDO::ERRMODE_WARNING;
echo ", EXCEPTION=", PDO::ERRMODE_EXCEPTION, ")\n"; PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION legt fest, was bei einem Fehler passieren soll. Im
lauten Modus fliegt eine PDOException. Die lässt sich wie jede andere Ausnahme fangen, sonst
bricht das Programm ab. Im stillen Modus gibt query() schlicht false zurück, und der Grund
liegt in errorInfo(), bis jemand nachfragt. Fragt niemand, arbeitet dein Programm mit false
weiter, und der Fehler taucht drei Funktionen später als etwas ganz anderes auf.
Seit PHP 8.0 ist der laute Modus der Standardwert. In der letzten Zeile der Ausgabe steht
ATTR_ERRMODE auf 2, und 2 ist EXCEPTION. Streng genommen braucht es die Option also nicht mehr.
Sie steht trotzdem da, denn in Codeschnipseln aus der Zeit vor PHP 8 war sie wirklich nötig. Da
lohnt es sich zu wissen, was sie tut, statt sie nur mitzukopieren. Außerdem sieht man so, worauf
sich der Code verlässt.
Eine dritte Option, PDO::ATTR_EMULATE_PREPARES => false, gehört zu MySQL. Dort baut PDO
vorbereitete Anweisungen sonst selbst nach, statt sie der Datenbank zu geben. Der Treiber für SQLite
kennt sie nicht einmal, und in diesem Kurs steht sie nirgends.
Die Tabelle anlegen
<?php
declare(strict_types=1);
// Erst dreimal dieselbe Tabelle, dann ein Blick auf die Spaltentypen.
$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)");
echo "Erster Aufruf mit IF NOT EXISTS: durchgelaufen\n";
$db->exec("CREATE TABLE IF NOT EXISTS notizen (id INTEGER PRIMARY KEY, titel TEXT NOT NULL)");
echo "Zweiter Aufruf mit IF NOT EXISTS: durchgelaufen\n";
try {
$db->exec("CREATE TABLE notizen (id INTEGER PRIMARY KEY, titel TEXT NOT NULL)");
echo "Ohne IF NOT EXISTS: durchgelaufen\n";
} catch (PDOException $fehler) {
echo "Ohne IF NOT EXISTS: ", $fehler->getMessage(), "\n";
}
echo "\nSQLite kennt fünf Typen von Werten, NULL und vier weitere. Hier steht überall derselbe\n";
echo "Text '42' drin, und die Spalte entscheidet, was daraus wird:\n\n";
$db->exec("DROP TABLE IF EXISTS probe");
$db->exec("CREATE TABLE probe (ganz INTEGER, text TEXT, komma REAL, egal BLOB)");
$db->exec("INSERT INTO probe (ganz, text, komma, egal) VALUES ('42', '42', '42', '42')");
$typen = $db->query("SELECT typeof(ganz) AS ganz, typeof(text) AS text,
typeof(komma) AS komma, typeof(egal) AS egal FROM probe")->fetch();
foreach ($typen as $spalte => $typ) {
echo " ", str_pad($spalte, 10), $typ, "\n";
} CREATE TABLE notizen (...) legt eine Tabelle an und beschwert sich, wenn es sie schon gibt. Beim
zweiten Aufruf des Skripts wäre das ein Abbruch. Deshalb steht dort fast immer
CREATE TABLE IF NOT EXISTS. Damit darf das Skript beliebig oft laufen. Beim ersten Mal entsteht
die Tabelle, danach passiert nichts. Weiter unten im Beispiel steht ein CREATE TABLE probe ohne
IF NOT EXISTS, und ohne das DROP TABLE IF EXISTS probe davor käme ein zweites php index.php
dort nicht mehr durch.
IF NOT EXISTS prüft allerdings nur den Namen. Ändert sich später eine Spalte im CREATE TABLE,
merkt SQLite davon nichts, die Tabelle ist ja da. Für eine geänderte Tabelle gibt es ALTER TABLE,
und das kommt in diesem Kurs nur am Rand vor.
SQLite kennt fünf Typen von Werten, NULL für keinen Wert, INTEGER für ganze Zahlen, REAL für
Kommazahlen, TEXT für Texte und BLOB für Bytes, die so bleiben, wie sie kommen. Der Typ in der
Klammer hinter einer Spalte ist dabei eher eine Absichtserklärung. SQLite schaut sich das Wort
an und wandelt einen Wert in den passenden Typ um, wenn es geht. So wird aus dem Text '42' in
einer INTEGER-Spalte die Zahl 42 und in einer TEXT-Spalte der Text 42. In einer BLOB-Spalte
bleibt er, wie er ist.
Drei Zusätze kommen in diesem Abschnitt immer wieder vor:
INTEGER PRIMARY KEYmacht die Spalte zum Primärschlüssel. Bei SQLite vergibt die Tabelle damit selbst eine Nummer, wenn beim Einfügen keine dabei ist, und zwar die höchste bisherige plus eins.INSERT INTO notizen (titel) VALUES ('Milch')bekommt seineidalso geschenkt.NOT NULLverbietet, dass in dieser Spalte gar nichts steht, und ein Versuch endet als Ausnahme. Einen leeren Text lässtNOT NULLallerdings durch, der ist ja ein Wert, und erstCHECK (titel <> '')schließt auch ihn aus.DEFAULT 0setzt einen Wert für den Fall, dass beim Einfügen keiner mitkommt. Beierledigtheißt das, eine neue Notiz ist offen.
Wahrheitswerte gibt es nicht
erledigt ist eine Zahl und kein Wahrheitswert, denn SQLite hat keinen eigenen Typ für wahr und
falsch. Üblich ist INTEGER mit 0 für nein und 1 für ja, und so kommt es auch wieder heraus. Seit
PHP 8.1 liefert PDO dort die Zahl 1 und kein true. In älteren Anleitungen siehst du an derselben
Stelle noch den Text "1".
if ($notiz["erledigt"]) funktioniert, weil 0 unwahr ist und 1 wahr. Aber
if ($notiz["erledigt"] === true) ist nie erfüllt. In den Abfragen dieses Kurses steht deshalb
WHERE erledigt = 0. SQLite versteht zwar auch false, aber nur als andere Schreibweise für die 0,
und PostgreSQL lehnt den Vergleich einer Zahl mit false ab.
In der Aufgabe entsteht die Tabelle für einen Einkauf, samt drei Waren darin.
Zum Mitnehmen
new PDO mit einem DSN, der mit sqlite: anfängt, öffnet die Datenbank und legt die Datei beim ersten Mal an. FETCH_ASSOC liefert jede Zeile einmal statt doppelt, und CREATE TABLE IF NOT EXISTS darf beliebig oft laufen.
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 4 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.