mitmario.dev

Verbinden und anlegen

PHP Sandbox 5 Min Lesezeit 4 BeispieleLektion 2 von 9

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.

Die Datei entsteht beim ersten Zugriff
<?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.

Dieselbe Zeile, zweimal abgeholt
<?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.

Laut oder still, dieselbe kaputte Abfrage
<?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

Zweimal dasselbe CREATE
<?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 KEY macht 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 seine id also geschenkt.
  • NOT NULL verbietet, dass in dieser Spalte gar nichts steht, und ein Versuch endet als Ausnahme. Einen leeren Text lässt NOT NULL allerdings durch, der ist ja ein Wert, und erst CHECK (titel <> '') schließt auch ihn aus.
  • DEFAULT 0 setzt einen Wert für den Fall, dass beim Einfügen keiner mitkommt. Bei erledigt heiß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, kostenlos

Zu 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.