12. Das Datenbankmanagementsystem MySQL verwenden
Wir schreiben nun PHP-Skripte, die eine MySQL-Datenbank verwenden:

In der obigen Architektur kommuniziert das PHP-Skript [1] nicht direkt mit dem DBMS (Datenbankmanagementsystem) [3]. Es kommuniziert vielmehr mit einem Vermittler, dem sogenannten DBMS-Treiber [2]. PHP stellt für diese Treiber eine Standardschnittstelle bereit, die Schnittstelle [PDO] (PHP Data Objects). Diese Schnittstelle wird von verschiedenen, auf das jeweilige DBMS zugeschnittenen Treibern implementiert: ein Treiber für das DBMS MySQL, ein anderer für das DBMS PostgreSQL … Um zu einem anderen DBMS zu wechseln, wechselt man den Treiber:

Der PDO-Treiber isoliert das PHP-Skript [1] vom DBMS [3, 6]. Da diese Treiber eine Standardschnittstelle implementieren, kann man erwarten, dass das PHP-Skript [1] beim Wechsel vom DBMS MySQL [3] zum DBMS PostgreSQL [6] unverändert bleibt. In der Realität gibt es dieses Ideal nicht. Um mit dem DBMS zu kommunizieren, sendet das PHP-Skript nämlich SQL-Befehle (Structured Query Language). Diese Sprache wird von allen DBMS implementiert, ist aber unvollständig. Folglich haben die DBMS ihr proprietäre Befehle hinzugefügt. Das ist eine erste Hauptursache für Inkompatibilitäten zwischen DBMS. Außerdem können sich die Datentypen, die in Datenbanken verwendet werden können, von einem DBMS zum anderen unterscheiden. PostgreSQL unterstützt zum Beispiel ein viel breiteres Spektrum an Datentypen als MySQL. Das ist eine zweite Ursache für Inkompatibilitäten. Eine weitere Ursache ist der Umgang mit automatischen Primärschlüsseln (die vom DBMS erzeugt werden): Praktisch jedes DBMS hat seine eigene Vorgehensweise. Usw. … Es gibt zahlreiche Ursachen für Inkompatibilitäten.
Möchte man vermeiden, das PHP-Skript [1] beim Übergang von MySQL [3] zu PostgreSQL [6] neu schreiben zu müssen, muss man in der Regel eine neue Schicht zwischen das PHP-Skript [1] und die PDO-Treiber [2, 5] einfügen, eine Schicht, deren Aufgabe es ist, die Inkompatibilitäten zwischen den beiden DBMS aufzulösen. In den einfachen Fällen, denen wir begegnen werden, ist diese zusätzliche Schicht jedoch nicht nötig.
Wir verwenden nun das DBMS MySQL. Dessen Version 8.4 ist in dem Paket [Laragon] enthalten, das wir zu Beginn dieses Kurses installiert haben.
Wer mit den Konzepten von Datenbanken und der Sprache SQL noch nicht vertraut ist, kann das Dokument [http://sergetahe.com/cours-tutoriels-de-programmation/cours-tutoriel-sql-avec-le-sgbd-firebird/] heranziehen. Dieses Dokument verwendet das DBMS Firebird statt MySQL, behandelt aber die Grundlagen von Datenbanken und der Sprache SQL. Die Dokumentation zu MySQL 8.4 ist ebenfalls unter [https://dev.mysql.com/doc/refman/8.4/en/] verfügbar.
Die Skripte dieses Kapitels befinden sich im Ordner [scripts-console/mysql]:
12.1. Eine Datenbank erstellen
Wir zeigen Ihnen nun, wie Sie mit dem Werkzeug [Laragon] eine Datenbank und einen MySQL-Benutzer erstellen.
Nach dem Start wird [Laragon] über sein Hauptfenster und sein Menü verwaltet (Rechtsklick im Fenster oder auf sein Symbol in der Taskleiste):
- Die Schaltfläche [Start All] startet den Webserver Apache und das DBMS MySQL. Das Fenster von [Laragon] zeigt dann an, dass beide aktiv sind, zusammen mit ihrem Listening-Port: 80 für Apache, 3306 für MySQL;
- die Schaltfläche [Database] startet das Werkzeug [HeidiSQL], das in [Laragon] enthalten ist und mit dem sich MySQL-Datenbanken grafisch verwalten lassen. Sie können auch das Webwerkzeug [phpMyAdmin] installieren (Menü Tools / Quick Add), das dann über die URL [http://localhost/phpmyadmin] erreichbar ist;
- die Schaltfläche [Terminal] öffnet ein Befehlsfenster, in dem die Werkzeuge von [Laragon] (PHP, Composer, MySQL usw.) direkt verwendet werden können.
Der PHP-7-Kurs erstellte die Datenbank und ihren Benutzer mit der Maus in [phpMyAdmin]. Hier schreiben wir die entsprechenden SQL-Befehle lieber in eine Textdatei, ein sogenanntes SQL-Skript. Ein solches Skript lässt sich durchsehen, korrigieren, zusammen mit dem Anwendungscode aufbewahren und beliebig oft erneut ausführen, um die Datenbank genau so wiederherzustellen, wie sie war. Das Skript [dbpersons.sql] lautet wie folgt:
Kommentare
- Zeile 1: In SQL ist eine Zeile, die mit zwei Bindestrichen beginnt, ein Kommentar;
- Zeile 6: Erstellt die Datenbank [dbpersons], falls sie noch nicht existiert. Darin legen wir eine Tabelle von Personen an. Der Zeichensatz [utf8mb4] ermöglicht es, alle Unicode-Zeichen zu speichern (Buchstaben mit Akzent, aber auch asiatische Schriftzeichen, Emojis usw.). Dies ist der Standardzeichensatz von MySQL 8. Der im PHP-7-Kurs verwendete Name [utf8] bezeichnet einen älteren, unvollständigen Zeichensatz von MySQL (höchstens drei Bytes pro Zeichen), der inzwischen veraltet ist;
- Zeile 9: Anlegen des Benutzers [admpersons] mit dem Passwort [nobody]. Ein MySQL-Benutzer wird durch seinen Namen und den Rechner identifiziert, von dem aus er sich anmeldet – hier [localhost], der lokale Rechner. Das Passwort [nobody] ist sehr schwach (leicht zu erraten). In einer Produktionsumgebung sollten Sie ein sicheres Passwort wählen;
- Zeile 12: Der Benutzer [admpersons] erhält alle Rechte an allen Tabellen ([dbpersons.*]) der Datenbank [dbpersons], aber keine Rechte an den anderen Datenbanken.
Dieses Skript muss vom Administrator des DBMS ausgeführt werden. In der [Laragon]-Installation ist das der Benutzer [root], der kein Passwort hat. Öffnen Sie das [Laragon]-Terminal im Ordner [scripts-console/mysql] und führen Sie das Skript mit dem Kommandozeilen-Client [mysql] aus:
- Die Option [-u root] gibt den Benutzernamen an, mit dem die Anmeldung am DBMS erfolgt. Da [root] kein Passwort hat, muss keines angegeben werden (Option [-p]);
- das Zeichen [<] leitet den Inhalt der Datei [dbpersons.sql] an die Eingabe des Clients [mysql] um, der die SQL-Befehle nacheinander ausführt. Wenn alles glattgeht, wird nichts angezeigt.
Wir hätten die Datei [dbpersons.sql] genauso gut in [HeidiSQL] (Menü Datei / SQL-Datei laden) oder auf der Registerkarte [SQL] von [phpMyAdmin] öffnen und dort ausführen können. Überprüfen Sie die Rechte des Benutzers [admpersons], indem Sie sich als dieser Benutzer anmelden. Mit der Option [-e] können Sie dem Client [mysql] direkt einen SQL-Befehl übergeben; der Befehl [show grants] zeigt die Rechte des angemeldeten Benutzers an:
- Zeile 2: Der Client [mysql] weist darauf hin, dass ein auf der Kommandozeile eingegebenes Passwort ([-pnobody], ohne Leerzeichen nach [-p]) von anderen Benutzern des Rechners eingesehen werden kann. Bei Verwendung der Option [-p] allein wird das Passwort über die Tastatur eingegeben, ohne angezeigt zu werden;
- Zeile 7: Der Benutzer [admpersons] hat alle Rechte an der Datenbank [dbpersons].
Nun haben wir:
- eine MySQL-Datenbank [dbpersons];
- einen Benutzer namens [admpersons/nobody] mit vollem Zugriff auf diese Datenbank.
Wir werden PHP-Skripte für die Arbeit mit der Datenbank schreiben. PHP stellt verschiedene Bibliotheken zur Verwaltung von Datenbanken bereit. Wir verwenden die Bibliothek [PDO] (PHP Data Objects), die zwischen den PHP-Code und das DBMS geschaltet wird:

Die Bibliothek [PDO] macht das PHP-Skript unabhängig von der genauen Art des verwendeten DBMS. Wie oben dargestellt, lässt sich das DBMS MySQL somit mit minimalen Auswirkungen auf den Code des PHP-Skripts durch das DBMS PostgreSQL ersetzen. Jeder PDO-Treiber ist eine Erweiterung von PHP, die aktiviert sein muss. Das folgende Skript [pdo-drivers.php] zeigt die verfügbaren Treiber an:
- Zeile 7: Die statische Methode [getAvailableDrivers] der Klasse [PDO] gibt die Liste der verfügbaren PDO-Treiber zurück;
- Zeile 10: Die Funktion [extension_loaded] gibt an, ob eine PHP-Erweiterung geladen ist. Die PDO-Treiber für MySQL, PostgreSQL und SQLite sind die Erweiterungen [pdo_mysql], [pdo_pgsql], und [pdo_sqlite].
Ergebnisse:
In dieser Installation sind alle drei Treiber aktiv. Für dieses Kapitel wird nur der Treiber [mysql] benötigt. Fehlt ein Treiber, aktivieren Sie ihn im Menü [Laragon]: PHP / Erweiterungen, und klicken Sie dann auf die gewünschte Erweiterung, zum Beispiel [pdo_mysql]. Eine Erweiterung lässt sich auch aktivieren, indem Sie direkt die Datei [php.ini] bearbeiten, die PHP konfiguriert (Menü PHP / php.ini in [Laragon]). Eine Erweiterung wird dort durch eine Zeile im folgenden Format aktiviert:
Sie ist deaktiviert, wenn die Zeile mit einem Semikolon auskommentiert ist ([;extension=pdo_pgsql]). Nach der Änderung der Datei [php.ini] müssen Sie die [Laragon]-Dienste neu starten (Schaltfläche [Reload]), damit Apache die Änderungen übernimmt. Die Konsolenskripte lesen die Datei [php.ini] dagegen bei jeder Ausführung neu ein.
12.2. Verbindung zu einer MySQL-Datenbank herstellen
Um eine Verbindung zu einem DBMS herzustellen, müssen Sie ein [PDO]-Objekt erzeugen. Dazu können Sie den Konstruktor der Klasse [PDO] oder ab PHP 8.4 deren statische Methode [connect] verwenden. Beide akzeptieren dieselben Parameter:
Die Parameter haben folgende Bedeutung:
Parameter | Bedeutung |
[$dsn] | (Data Source Name) eine Zeichenkette, die die Art des DBMS und seinen Ort im Netzwerk angibt. Die Zeichenkette ["mysql:host=localhost"] zeigt an, dass es sich um ein MySQL-DBMS handelt, das auf dem lokalen Rechner läuft. Diese Zeichenkette kann weitere, durch Semikolons getrennte Parameter enthalten, etwa den Port, auf dem das DBMS lauscht, den Namen der Datenbank, mit der Sie sich verbinden möchten, und den für die Kommunikation verwendeten Zeichensatz: ["mysql:host=localhost;port=3306;dbname=dbpersons;charset=utf8mb4"] |
[$username] | der Benutzername des sich anmeldenden Benutzers |
[$password] | sein Passwort |
[$options] | ein Array mit Optionen für den DBMS-Treiber |
Nur der erste Parameter ist erforderlich. Das so erzeugte Objekt dient anschließend als Grundlage für alle Operationen, die auf der Datenbank ausgeführt werden, mit der Sie sich verbunden haben. Kann das Objekt nicht erzeugt werden, wird eine Ausnahme [PDOException] ausgelöst.
Hier ein Beispiel für eine Verbindung, [mysql-01.php]:
Kommentare
- Zeilen 8–10: die Verbindungsparameter;
- Zeile 14: die Verbindung zum DBMS. Hier wird die Methode [connect] mit den folgenden Parametern verwendet:
- eine Zeichenkette, die den Typ des DBMS und seinen Ort angibt. Die Zeichenkette ["mysql:host=localhost"] zeigt an, dass es sich um ein MySQL-DBMS handelt, das auf dem lokalen Rechner läuft. Der Port wurde nicht angegeben; es wird daher standardmäßig Port 3306 verwendet. Auch der Datenbankname ist nicht angegeben. Es wird dann eine Verbindung zum MySQL-DBMS aufgebaut, und eine bestimmte Datenbank kann später ausgewählt werden;
- eine Benutzerkennung;
- sein Passwort;
- Zeile 17: [$connection::class] ist der Klassenname des Objekts [$connection]. Ab PHP 8.4 hat jeder PDO-Treiber eine eigene, von der Klasse [PDO] abgeleitete Klasse: [Pdo\Mysql] für MySQL, [Pdo\Pgsql] für PostgreSQL, [Pdo\Sqlite] für SQLite. Die Methode [PDO::connect] erzeugt ein Objekt der Klasse, die dem DSN entspricht. Mit [new PDO(...)] erhielten wir ein Objekt der Klasse [PDO] selbst, das genauso funktioniert, aber keinen Zugriff auf treiberspezifische Methoden bietet. Da wir nur die allen Treibern gemeinsamen Methoden verwenden, sind beide Schreibweisen zulässig;
- Zeile 19: Die Verbindung wird geschlossen, indem die letzte Referenz auf das ursprünglich erzeugte PDO-Objekt entfernt wird. Das geschieht automatisch am Ende des Skripts;
- Zeile 20: Die Verbindung zu einem DBMS kann fehlschlagen. In diesem Fall wird eine Ausnahme [PDOException] ausgelöst. Diese Ausnahme ist von der PHP-Ausnahme [RuntimeException] abgeleitet;
- Zeile 21: Die Fehlermeldung der Ausnahme wird angezeigt;
- Zeile 22: Das Skript wird mit einem Exit-Code ungleich null beendet, der einem aufrufenden Programm den Fehlschlag signalisiert.
Ergebnisse:
Führen wir das Skript erneut aus, nachdem wir die Konstante [PWD] auf ein falsches Passwort gesetzt haben. Das Ergebnis lautet:
Die Meldung enthält drei Informationen: den Code SQLSTATE [HY000], einen standardisierten Fehlercode, der allen DBMS gemeinsam ist (HY000 = allgemeiner Fehler), den MySQL-spezifischen Fehlercode [1045] und die MySQL-Meldung.
12.3. Eine Tabelle erstellen
Das Skript [mysql-02.php] zeigt, wie eine Tabelle in einer Datenbank erstellt wird:
Kommentare
- Zeile 7: Dieses Mal verweist der DSN auf die Datenbank [dbpersons] ([dbname=dbpersons]). Der Parameter [charset=utf8mb4] teilt dem DBMS mit, dass die mit ihm ausgetauschten Zeichenketten in UTF-8 kodiert sind, der in unseren (PHP-)Skripten verwendeten Kodierung. So ist sichergestellt, dass Umlaute und andere Sonderzeichen korrekt in der Datenbank gespeichert und korrekt wieder ausgelesen werden;
- Zeile 14: Verbindung zur Datenbank herstellen. Das ist immer der erste Schritt. Das Ergebnis der Verbindung ist ein [PDO]-Objekt, über das die Datenbankoperationen ausgeführt werden;
- Zeile 16: Der SQL-Befehl [drop table] löscht die Tabelle [persons] aus der Datenbank [dbpersons]. Die Klausel [if exists] verhindert einen Fehler, wenn die Tabelle [persons] nicht existiert;
- Zeile 17: Ausführung des vorherigen SQL-Befehls auf der Datenbank [dbpersons] mit der Methode [PDO::exec]. Diese Ausführung kann eine [PDOException] auslösen, die von der Klausel [catch] abgefangen wird;
- Zeilen 19–20: Dieser SQL-Befehl erstellt eine Tabelle namens [persons]. Eine Tabelle besteht aus Zeilen und Spalten. Die Spalten bilden die sogenannte Tabellenstruktur. Die Zeilen bilden den Inhalt der Tabelle. Eine Datenbank kann eine oder mehrere Tabellen enthalten. Die Tabelle [persons] hat hier drei Spalten:
- first_name: der Vorname einer Person als Zeichenkette mit höchstens 30 Zeichen;
- last_name: der Nachname derselben Person als Zeichenkette mit höchstens 30 Zeichen;
- age: das Alter der Person als ganze Zahl;
- Das Attribut [not null] einer Spalte verlangt, dass die Spalte einen Wert hat. Wird keiner angegeben, führt das zu einem Fehler [PDOException];
- [primary key(last_name, first_name)] definiert einen Primärschlüssel für die Tabelle [persons]. Ein Primärschlüssel hat für jede Zeile der Tabelle einen eindeutigen Wert. Hier entsteht der Primärschlüssel durch Verkettung der Spalten [last_name] und [first_name] der Zeile. Diese Einschränkung stellt sicher, dass die Tabelle nicht zwei Personen mit demselben Vor- und Nachnamen enthalten kann, also zwei Personen mit demselben vollständigen Namen. Das Anlegen einer Person mit demselben Namen wie eine bereits vorhandene löst eine [PDOException] aus;
- Zeilen 23–25: Tritt eine [PDOException] auf, wird die zugehörige Fehlermeldung angezeigt;
- Zeilen 26–28: Die Klausel [finally] wird in jedem Fall ausgeführt, ob eine Ausnahme auftritt oder nicht, um die Verbindung zur Datenbank zu schließen.
Im Fehlerfall kann eine mit einem [PDO]-Objekt ausgeführte SQL-Operation entweder einen bestimmten Wert zurückgeben (oft den booleschen Wert [false]), ohne etwas zu melden, oder eine Ausnahme auslösen. Dieses Verhalten wird durch das Attribut [PDO::ATTR_ERRMODE] der Verbindung gesteuert. In PHP 7 war der Standardmodus der erste: Fehler wurden stillschweigend ignoriert, und das Vorgehen unter PHP 7 forderte den zweiten Modus mit der folgenden Anweisung an:
Seit PHP 8.0 ist der Ausnahmemodus der Standard: Jeder DBMS-Fehler löst eine [PDOException] aus. Diese Anweisung ist daher nicht mehr nötig, und wir verwenden sie nicht mehr. Deshalb haben wir auch [drop table if exists] geschrieben: In PHP 7 schlug der Befehl [drop table persons] für eine nicht vorhandene Tabelle stillschweigend fehl; in PHP 8 würde er eine Ausnahme auslösen.
Ergebnisse:
Wenn das Skript fehlerfrei läuft, können Sie die Existenz der Tabelle und ihre Struktur mit [HeidiSQL], [phpMyAdmin] oder, noch einfacher, mit dem Client [mysql] überprüfen. Der SQL-Befehl [describe] zeigt die Struktur einer Tabelle an:
- Zeilen 6–8: die drei Spalten der Tabelle samt ihren Typen (Spalte Type);
- Spalte Null: Keine der drei Spalten darf leer sein;
- Spalte Key: Die Spalten [first_name] und [last_name] sind Teil des Primärschlüssels (PRI).
Die SQL-Abfrage [show index] zeigt die Indizes der Tabelle an. Ein Index ermöglicht es, Zeilen der Tabelle mit einem bestimmten Indexwert schneller zu finden, als wenn man die Zeilen der Tabelle sequenziell durchsuchen würde. Der Primärschlüssel gehört immer zu den Indizes, ein Index muss aber kein Primärschlüssel sein:
- Der Index ist hier der Primärschlüssel (Spalte Key_name = PRIMARY);
- er besteht aus den Spalten [last_name, first_name] jeder Zeile, in dieser Reihenfolge (Spalten Seq_in_index und Column_name).
Sehen wir nun, was passiert, wenn wir Fehler beim Datenbanknamen, beim Benutzernamen und beim Passwort einbauen.
Wenn wir einen nicht vorhandenen Datenbanknamen eingeben ([dbname=dbpersons2]):
Wenn wir einen nicht vorhandenen Benutzernamen eingeben:
Wenn Sie ein falsches Passwort eingeben:
Beachten Sie, dass MySQL nicht angibt, ob der Benutzername oder das Passwort falsch ist: Das ist eine Sicherheitsmaßnahme, die jemandem, der die Zugangsdaten zu erraten versucht, keine Hinweise liefern soll. Ebenso erfährt der Benutzer [admpersons] nicht, ob die Datenbank [dbpersons2] existiert oder nicht: Er weiß nur, dass er nicht darauf zugreifen kann.
12.4. Eine Tabelle füllen
Wir schreiben ein PHP-Skript, das die SQL-Befehle ausführt, die in der folgenden Textdatei [creation.txt] stehen:
Kommentare
- Bei SQL-Befehlen unterscheidet die Sprache SQL (Structured Query Language) nicht zwischen Groß- und Kleinschreibung;
- Zeile 1: Die Tabelle [persons] löschen, falls sie existiert;
- Zeile 2: Die Tabelle [persons] mit drei Spalten (first_name, last_name, age) und dem Primärschlüssel (last_name, first_name) erstellen;
- Zeilen 3–9: 7 Zeilen in die Tabelle [persons] einfügen;
- Zeile 5: Diese insert-Anweisung sollte fehlschlagen, weil sie dieselbe Einfügung wie die vorherige Zeile versucht. Die Primärschlüssel-Einschränkung sollte diese Einfügung verhindern: Es kann nicht zwei Personen mit demselben Vor- und Nachnamen geben;
- Zeile 9: Diese insert-Anweisung sollte aus demselben Grund ebenfalls fehlschlagen;
- Zeile 7: Der Vorname [Géraldine] enthält ein Sonderzeichen mit Akzent. Die Datei [creation.txt] ist wie alle Dateien des Kurses in UTF-8 kodiert: Das ist die Standardkodierung von [VS Code], wie in dessen Statusleiste angezeigt. Im PHP-7-Kurs wurde der Datei der MySQL-spezifische Befehl hinzugefügt, der dem DBMS die Kodierung der empfangenen Zeichen mitteilte. Das ist nicht mehr nötig: Die Kodierung wird ein für alle Mal durch den Parameter [charset=utf8mb4] des DSN festgelegt.
Das PHP-Skript, das die SQL-Befehle in dieser Textdatei ausführt, lautet wie folgt: [mysql-03.php]:
Kommentare
- Die Funktion [executeCommands] (Zeilen 35–80) führt die SQL-Befehle aus, die sie in der Textdatei [$sqlFileName] (Parameter 2) findet. Dazu verwendet sie die geöffnete Verbindung [$connection] (Parameter 1) zum MySQL-Server. Der dritte Parameter, [$tracking], ist ein boolescher Wert, der die Bildschirmausgabe steuert: Ist er auf [true] gesetzt, wird der ausgeführte SQL-Befehl samt Angabe, ob er erfolgreich war oder fehlgeschlagen ist, auf dem Bildschirm angezeigt; andernfalls erfolgt die Ausführung des SQL-Befehls ohne Ausgabe. Der vierte Parameter, [$stop], steuert, was geschieht, wenn ein SQL-Befehl fehlschlägt: Bei [true] legt er fest, dass die Ausführung der SQL-Befehle abgebrochen werden muss; andernfalls wird sie fortgesetzt. Die Funktion [executeCommands] gibt ein Array mit Fehlermeldungen zurück; dieses Array ist leer, wenn keine Fehler aufgetreten sind.;
- Zeile 12: Der Pfad zur Datei [creation.txt] wird aus der Konstante [__DIR__] gebildet, dem Verzeichnis des Skripts. So ist sichergestellt, dass das Skript seine Datei unabhängig vom Verzeichnis findet, aus dem es gestartet wird;
- Zeilen 15–20: Es wird eine Verbindung zur MySQL-Datenbank [dbpersons] geöffnet. Schlägt die Verbindung fehl, wird eine Fehlermeldung angezeigt und das Skript beendet;
- Zeile 23: Die Funktion [executeCommands] wird aufgerufen, um die Datei mit den SQL-Befehlen auszuführen. Ihr wird eine geöffnete Verbindung übergeben. Die letzten beiden Argumente werden per Namen übergeben ([tracking: true, stop: false]): Es handelt sich um benannte Argumente (PHP 8.0). Der Aufruf [executeCommands($connection, SQL_COMMANDS_FILENAME, true, false)] wäre gleichwertig, aber weniger lesbar: Ohne einen Blick auf die Funktionssignatur ist unklar, was [true] und [false] bedeuten;
- Zeile 25: Die Verbindung wird geschlossen;
- Zeilen 27–30: Die von der Funktion [executeCommands] zurückgegebenen Fehler werden angezeigt;
- Zeilen 45–47: Die SQL-Befehle werden mit der Funktion [file] im Array [$queries] abgelegt. Die Option [FILE_IGNORE_NEW_LINES] entfernt das Zeilenende-Zeichen jeder gelesenen Zeile, während die Option [FILE_SKIP_EMPTY_LINES] leere Zeilen ignoriert. Beide Optionen werden durch den Operator [|] (binäres ODER) kombiniert. Ist die Datei nicht lesbar, wird [file] nicht aufgerufen – was eine Warnung auslösen würde – und [$queries] ist gleichbedeutend mit [false];
- Zeilen 49–51: Konnte die Datei mit den SQL-Befehlen nicht gelesen werden, wird ein Fehler-Array mit einer einzigen Meldung zurückgegeben;
- Zeile 53: Fehler werden im Array [$errors] gesammelt;
- Zeile 54: Wir durchlaufen alle Abfragen in einer Schleife;
- Zeile 56: Die Funktion [trim] entfernt die Leerzeichen vor und nach dem Text des SQL-Befehls. Unter „Leerzeichen“ verstehen wir das Leerzeichen, das Tabulatorzeichen \t, den Wagenrücklauf \r, den Zeilenvorschub \n usw. Eine Zeile, die nur Leerzeichen enthält, wird dadurch leer: Sie wird ignoriert (Zeile 60);
- Zeile 64: Der SQL-Befehl wird an den MySQL-Server gesendet. Die Methode [PDO::exec] löst eine Ausnahme aus, wenn die Ausführung fehlschlägt. Gelingt die Ausführung, wird der SQL-Befehl auf dem Bildschirm angezeigt, wenn der Parameter [$tracking] auf [true] gesetzt ist;
- Zeile 71: Tritt ein Fehler auf, wird die Fehlermeldung dem Fehler-Array hinzugefügt;
- Zeilen 73–75: Ist der Parameter [$stop] auf [true] gesetzt, wird die Schleife mit der Anweisung [break] verlassen;
- Zeile 79: Sobald alle SQL-Befehle ausgeführt wurden, wird das Fehler-Array [$errors] zurückgegeben.
Die Funktion [addError] (Zeilen 82–91) fügt dem Fehler-Array [$errors] einen Fehler hinzu. Sie hat 4 Parameter:
- Der Parameter [$errors] wird als Referenz übergeben ([&$errors]). Der Grund: Wir wollen das als Parameter übergebene Array ändern, nicht eine Kopie davon;
- der Parameter [$query] ist der SQL-Text des fehlgeschlagenen Befehls;
- der Parameter [$msg] ist die Fehlermeldung, die zum fehlgeschlagenen Befehl gehört;
- der boolesche Wert [$tracking] gibt an, ob die Fehlermeldung auf der Konsole angezeigt werden soll ([true]) oder nicht ([false]).
Beachten Sie, dass die Funktionen [executeCommands] und [addError] nach dem Code definiert sind, der sie verwendet. Das ist möglich, weil PHP alle Funktionen, die auf oberster Ebene eines Skripts definiert sind, erfasst, bevor es mit der Ausführung beginnt.
Bildschirmausgabe:
- Zeilen 6 und 10: Beide Einfügungen von Namensvettern sind fehlgeschlagen: Der Primärschlüssel 'Lefur-Sylvie' (bzw. 'Girond-Paulette') existiert bereits (Duplicate entry). Der Code SQLSTATE [23000] kennzeichnet die Verletzung einer Integritätsbedingung; der Code [1062] ist der MySQL-Fehlercode;
- Zeilen 12–16: die Fehlerzusammenfassung.
Die vorgenommenen Einfügungen sind mit dem Client [mysql] sichtbar:
Beachten Sie, dass die Zeilen in der Reihenfolge des Primärschlüssels (Nachname, Vorname) zurückgegeben werden, die nicht der Reihenfolge der Einfügungen entspricht. In SQL ist die Reihenfolge der von einem [select] zurückgegebenen Zeilen nur garantiert, wenn sie mit einer Klausel [order by] festgelegt wird.
12.5. Beliebige SQL-Befehle ausführen
Das folgende Skript zeigt die Ausführung von SQL-Befehlen aus der folgenden Textdatei [sql.txt]:
Unter diesen SQL-Befehlen gibt es den Befehl [select], der Ergebnisse aus der Datenbank zurückgibt; die Befehle [insert], [update], [delete], die die Datenbank ändern, ohne ein Ergebnis zurückzugeben, und schließlich fehlerhafte Befehle wie den letzten ([xselect]). Das Skript [mysql-04.php] basiert auf dem Skript [mysql-03.php], wobei der Name der Datei mit den SQL-Befehlen ([__DIR__ . "/sql.txt"]) geändert wurde. Nur die Funktion [executeCommands] wird angepasst, und eine Funktion [displayInfo] kommt hinzu:
Kommentare
- Zeilen 35–87: Die Funktion [executeCommands] wurde leicht angepasst: Der Befehl [select] wird nicht auf dieselbe Weise ausgeführt wie die übrigen SQL-Befehle. Dieser Befehl ist der einzige, der als Ergebnis eine Tabelle zurückgibt, also eine Menge von Zeilen und Spalten aus der Datenbank;
- Zeile 63: Wir isolieren das erste Wort des SQL-Befehls. Die Funktion [explode] teilt die Abfrage an den Leerzeichen in höchstens 2 Teile (3. Parameter); das erste Segment ([[0]]) ist der Befehlsname, den die Funktion [strtolower] in Kleinbuchstaben umwandelt. Der PHP-7-Kurs verwendete einen regulären Ausdruck;
- Zeilen 67–69: Ist der SQL-Befehl [select], wird die Methode [PDO::query] verwendet; andernfalls wird der SQL-Befehl mit der Methode [PDO::exec] ausgeführt. In beiden Fällen wird bei einem Fehlschlag eine Ausnahme ausgelöst und von der Klausel [catch] abgefangen. Gelingt die Ausführung, wird ihr Ergebnis von der Funktion [displayInfo] angezeigt (Zeile 75):
- Die Methode [query] gibt ein Objekt vom Typ [PDOStatement] zurück, das Zugriff auf die von [select] gelieferten Zeilen bietet. Ihr zweiter Parameter, [PDO::FETCH_NUM], legt fest, dass jede Zeile als Array mit den Spaltennummern 0, 1, 2, … als Index geliefert wird;
- die Methode [exec] gibt eine ganze Zahl zurück: die Anzahl der vom SQL-Befehl geänderten Zeilen;
- Zeilen 101–124: Die Funktion [displayInfo] zeigt Informationen zum Ergebnis der Ausführung eines SQL-Befehls an. Der Parameter [$result] hat den Typ [PDOStatement|int]: Das ist ein Union-Type (PHP 8.0), der entweder ein [PDOStatement]-Objekt oder eine ganze Zahl akzeptiert;
- Zeile 104: Der Fall [select] wird behandelt. Der Operator [instanceof] prüft den Typ des Objekts [$result];
- Zeile 107: Die Methode [PDOStatement::columnCount] gibt die Anzahl der Spalten der Ergebnistabelle von [select] zurück;
- Zeile 108: Die Methode [PDOStatement::getColumnMeta] gibt ein Array mit Informationen zur Spalte Nr. [$i] der Ergebnistabelle von [select] zurück. In diesem Array ist der dem Schlüssel 'name' zugeordnete Wert der Spaltenname. Die Spaltennamen werden im Array [$columns] gesammelt;
- Zeile 110: Die Funktion [implode] verkettet die Spaltennamen und trennt sie durch Kommas;
- Zeile 113: Mit der Funktion [str_repeat] wird eine Trennlinie erzeugt, die so lang ist wie der Titel. Die Funktion [mb_strlen] zählt die Zeichen einer UTF-8-Zeichenkette; die Funktion [strlen] zählt die Bytes, und ein Zeichen mit Akzent belegt zwei Bytes;
- Zeilen 115–117: Ein Objekt vom Typ [PDOStatement] lässt sich mit einer Schleife [foreach] durchlaufen. Bei jedem Durchlauf ist das gelieferte Element eine Zeile der Ergebnistabelle von [select] in Form eines Arrays, das die Werte der einzelnen Spalten der Zeile enthält. Diese Werte werden durch Kommas getrennt angezeigt;
- Zeilen 121–123: Das Ergebnis der Ausführung eines Befehls [insert], [update] oder [delete] ist die Anzahl der vom Befehl geänderten Zeilen. Der PHP-7-Kurs verwendete hier eine Anweisung [switch], bei der eine der Klauseln irrtümlich als [case "delete";] mit einem Semikolon statt eines Doppelpunkts geschrieben war. PHP tolerierte das; ab PHP 8.5 ist diese Syntax veraltet (deprecated).
Bildschirmausgabe:
- Zeilen 33–35: Das letzte [select] liefert keine Zeilen: Die Person [Bruneau] wurde durch den vorherigen Befehl [delete] gelöscht;
- Zeile 36: Der Befehl [xselect] existiert nicht. Der Code SQLSTATE [42000] kennzeichnet einen Syntaxfehler oder eine Zugriffsverletzung; der MySQL-Code [1064] kennzeichnet einen Syntaxfehler.
12.6. Vorbereitete SQL-Befehle verwenden
12.6.1. Beispiel 1
Betrachten wir das folgende Skript: [mysql-05.php]:
Kommentare
Hier interessieren uns die Zeilen, die Personen in die Tabelle people der Datenbank [dbpersons] einfügen.
- Zeile 16: Der SQL-Befehl [delete] ohne die Klausel [where] löscht alle Zeilen der Tabelle;
- Zeile 23: Ein parametrisierter SQL-Befehl wird „vorbereitet“. Den Parametern wird ein Doppelpunkt vorangestellt: [:last_name], [:first_name], [:age]. Um einen SQL-Befehl „vorzubereiten“, verwenden Sie die Methode [PDO::prepare]. Das Ergebnis ist ein Objekt vom Typ [PDOStatement]. Das „Vorbereiten“ ist keine Ausführung: In der Datenbank wird nichts geändert;
- Zeile 26: Ausführung der vorbereiteten Anweisung mit der Methode [PDOStatement::execute]. Dazu müssen Sie den Parametern [:last_name], [:first_name] und [:age] Werte zuweisen. Das ist auf mehrere Arten möglich. Hier verwenden wir ein assoziatives Array, dessen Schlüssel die Namen der Parameter der vorbereiteten Anweisung sind und das wir der Methode [PDOStatement::execute] übergeben;
- Zeile 27: Die Methode [PDOStatement::rowCount] gibt die Anzahl der Zeilen zurück, die bei der letzten Ausführung der vorbereiteten Anweisung geändert wurden. In der in Anführungszeichen stehenden Zeichenkette steht der Methodenaufruf in geschweiften Klammern [{...}] , damit PHP ihn auswerten kann. Dasselbe gilt für das Array-Element [{$person["first_name"]}];
- Zeilen 30–33: Eine andere Möglichkeit besteht darin, den Parametern mit der Methode [PDOStatement::bindValue] einen Wert zuzuweisen, bevor [execute] ohne Argumente aufgerufen wird. Der dritte, optionale Parameter von [bindValue] gibt den SQL-Typ des Werts an ([PDO::PARAM_INT] für eine ganze Zahl, [PDO::PARAM_STR] – der Standardwert – für eine Zeichenkette). Der Nachteil: Pro Parameter ist eine Anweisung nötig. Die Methode mit dem assoziativen Array ist oft bequemer.
Die hier zum Einfügen verwendete Methode:
- eine vorbereitete Anweisung;
- n Ausführungen der vorbereiteten Anweisung;
ist hinsichtlich der Ausführungszeit effizienter als die Ausführung von n verschiedenen SQL-Anweisungen. Vor allem hat sie einen weiteren entscheidenden Vorteil: Die Parameterwerte werden dem DBMS getrennt vom Text der SQL-Anweisung übergeben. Sie können daher die Bedeutung des Befehls nicht verändern. Würde der SQL-Befehl durch Verkettung aufgebaut – zum Beispiel ["insert into persons values ('$first_name', '$last_name', $age)"] –, würde ein Vorname mit Apostroph („Jean-Michel d'Ormesson“) einen Syntaxfehler verursachen, und ein böswilliger Benutzer könnte SQL-Befehle seiner Wahl einschleusen: Dies bezeichnet man als SQL-Injection-Angriff. Vorbereitete Abfragen sollten daher immer verwendet werden, wenn eine Abfrage Werte enthält, die von außerhalb des Skripts stammen. Sie lassen sich für die SQL-Befehle [select], [update], [delete] und [insert] verwenden. Beim SQL-Befehl [select] werden die Ergebniszeilen nach der Ausführung mit [PDOStatement::execute] mit den Methoden [PDOStatement::fetch] oder [PDOStatement::fetchAll] abgerufen.
Ergebnisse:
12.6.2. Beispiel 2
Das folgende Skript, [mysql-06.php], zeigt die Verwendung einer vorbereiteten Anweisung für die SQL-Operation [select] sowie verschiedene Möglichkeiten, die von dieser Operation gelieferten Zeilen abzurufen:
Kommentare
- Zeilen 13–23: eine Klasse namens [Person] , deren typisierte private Attribute die Namen der Spalten der Tabelle [persons] tragen;
- Zeilen 26–34: eine unveränderliche Klasse [ImmutablePerson] , deren Konstruktor Parameter hat, die nach den Spalten der Tabelle [persons] benannt sind;
- Zeile 38: Der vierte Parameter von [PDO::connect] ist ein Array mit Verbindungsoptionen. Die Option [PDO::ATTR_DEFAULT_FETCH_MODE] bestimmt, in welcher Form die gelesenen Zeilen standardmäßig geliefert werden: hier [PDO::FETCH_ASSOC], das assoziative Arrays mit den Spaltennamen als Index verwendet. Ohne diese Option ist der Standardmodus [PDO::FETCH_BOTH] (siehe unten);
- Zeilen 43–45: 10 Zeilen werden mit einer vorbereiteten Abfrage in die Tabelle [persons] eingefügt. Das Array der Werte wird direkt im Aufruf von [execute] aufgebaut;
- Zeilen 47–48: Ein SQL-Befehl [select] wird „vorbereitet“ und dann ausgeführt;
- Zeile 50: Die Methode [PDOStatement::fetch] dient dazu, die nächste Zeile aus dem Ergebnis der ausgeführten SQL-Operation [select] abzurufen – hier die erste Zeile. Die Methode [fetch] kann Zeilen auf verschiedene Weisen liefern. Das Skript zeigt einige davon. Ohne Parameter verwendet sie den Standardmodus der Verbindung, hier ein assoziatives Array. Beachten Sie, dass das Alter als ganze Zahl geliefert wird ([int(0)]). Das ist neu in PHP 8.1: Zuvor lieferte der MySQL-Treiber alle Werte als Zeichenketten ([string(1) "0"] in PHP 7). Das von [var_dump] angezeigte Ergebnis lautet:
- Zeile 53: Der Parameter [PDO::FETCH_BOTH] bewirkt, dass die gelieferte Zeile ein Array ist, das sowohl über Spaltennamen als auch über Spaltennummern indiziert ist:
- Zeile 56: Der Parameter [PDO::FETCH_OBJ] bewirkt, dass die gelieferte Zeile ein Objekt vom Typ [stdClass] ist, dessen Attribute die Namen der Spalten der Tabelle sind:
- Zeile 59: Der Lesemodus der Methode [fetch] wird mit der Methode [PDOStatement::setFetchMode] festgelegt. Dieser Modus wird dann zum Standardmodus für die Anweisung [$statement], bis er geändert wird – entweder durch ein weiteres [setFetchMode] oder indem der Methode [fetch] ein Modus als Parameter übergeben wird, wie zuvor geschehen. Die Operation [setFetchMode(PDO::FETCH_CLASS, Person::class)] legt fest, dass die gelesene Zeile in einem Objekt vom Typ [Person] abgelegt werden muss. [Person::class] ist die Zeichenkette "Person", der vollständige Name der Klasse. PDO erzeugt das Objekt und weist dann den Attributen die Werte der gleichnamigen Spalten zu, selbst wenn diese Attribute privat sind. Die folgende Zeile zeigt das Ergebnis an:
- Zeilen 63–65: Sie zeigen, wie die übrigen Zeilen von [select] nacheinander verarbeitet werden. Die Methode [fetch] gibt [false] zurück, wenn keine Zeilen mehr vorhanden sind, wodurch die Schleife endet. Die Anzeige von [$person] verwendet die Methode [__toString] der Klasse [Person]:
- Zeilen 67–68: ein parametrisiertes [select]: Wir wollen nur Personen, die mindestens 70 Jahre alt sind;
- Zeile 69: Die Methode [PDOStatement::fetchAll] gibt alle Zeilen des Ergebnisses auf einmal zurück, hier als assoziative Arrays (der Standardmodus der Verbindung). Die Funktion [array_map] wandelt jede davon in ein Objekt [ImmutablePerson] um. Der Ausdruck [new ImmutablePerson(...$row)] verwendet den Spread-Operator [...] auf einem assoziativen Array: Jeder Schlüssel wird zu einem benannten Argument (PHP 8.1). Die Zeile [["last_name" => "lastName7", "first_name" => "firstName7", "age" => 70]] führt somit zum Aufruf [new ImmutablePerson(last_name: "lastName7", first_name: "firstName7", age: 70)]. Diese Technik eignet sich für eine unveränderliche Klasse, deren Attribute vom Konstruktor initialisiert werden, während der Modus [PDO::FETCH_CLASS] – der die Werte direkt den Attributen zuweist – bei einer Klasse wie [ImmutablePerson], deren Konstruktor Argumente verlangt, fehlschlägt. Sie hat außerdem den Vorteil, dass PHP den Typ jedes Werts prüft. Das angezeigte Ergebnis lautet:
Die folgende Tabelle fasst die behandelten Lesemodi zusammen:
Modus | Eine Zeile wird geliefert als |
[PDO::FETCH_ASSOC] | ein assoziatives Array [column => value] |
[PDO::FETCH_NUM] | ein Array, das über die Spaltennummern 0, 1, 2… indiziert ist |
[PDO::FETCH_BOTH] | ein Array, das sowohl über Spaltennamen als auch über Nummern indiziert ist (Standardmodus von PDO) |
[PDO::FETCH_OBJ] | ein Objekt [stdClass] , dessen Attribute die Spaltennamen sind |
[PDO::FETCH_CLASS] | ein Objekt der angegebenen Klasse, dessen Attribute die Spaltennamen tragen |
Jeder Treiber hat außerdem eigene Optionen, die ab PHP 8.4 in seiner Klasse zusammengefasst sind. Die Option, die bei jedem Verbindungsaufbau zu MySQL einen SQL-Befehl ausführt, wird zum Beispiel als [Pdo\Mysql::ATTR_INIT_COMMAND] geschrieben. Die alten Konstanten [PDO::MYSQL_ATTR_INIT_COMMAND], die in vielen Dokumenten zu finden sind, sind seit PHP 8.5 veraltet (deprecated).
12.7. Transaktionen verwenden
Eine Transaktion ermöglicht es, eine Folge von SQL-Befehlen zu einer einzigen Ausführungseinheit zusammenzufassen: Entweder gelingen alle Befehle, oder einer davon schlägt fehl, und dann werden alle vorhergehenden SQL-Befehle rückgängig gemacht. Mit anderen Worten: Wenn Sie SQL-Befehle in einer Transaktion ausführen, befindet sich die Datenbank nach Abschluss der Transaktion in einem stabilen Zustand:
- entweder in einem neuen Zustand, der durch die erfolgreiche Ausführung aller SQL-Befehle der Transaktion entstanden ist;
- oder in dem Zustand, in dem sie sich vor Beginn der Ausführung der Transaktion befand.
Greifen wir das Beispiel der Ausführung von SQL-Befehlen aus einer Textdatei wieder auf, das im Abschnitt „Beliebige SQL-Befehle ausführen“ behandelt wurde. Wir betten diese Ausführung in eine Transaktion ein. Die SQL-Befehle stehen in der folgenden Datei [sql2.txt]:
Der fehlerhafte Befehl in Zeile 11 lässt die gesamte Transaktion fehlschlagen. Die Datenbank sollte daher in den Zustand vor der Transaktion zurückkehren. Im obigen Beispiel sollte die in Zeile 9 eingefügte Zeile nicht in der Tabelle erscheinen. Das Skript unterscheidet sich nur wenig vom Skript [mysql-04.php]. Der Name der Datei mit den SQL-Befehlen lautet nun [__DIR__ . "/sql2.txt"], und die Funktion [executeCommands] verliert ihren vierten Parameter:
Das liegt daran, dass jeder Fehler die Transaktion beendet, da die SQL-Befehle innerhalb einer Transaktion laufen. Die Funktion [executeCommands] sieht dann wie folgt aus:
Kommentare
- Zeilen 41–42: Erinnerung an die Rolle einer Transaktion;
- Zeile 54: Eine Transaktion wird mit der Methode [PDO::beginTransaction] gestartet. Ab diesem Punkt wird jeder SQL-Befehl, der in der Schleife [foreach] ausgeführt wird, innerhalb dieser Transaktion ausgeführt;
- Zeilen 82–83: Beim ersten Fehler wird die Schleife verlassen: Es hat keinen Sinn, die folgenden Befehle auszuführen, da die Transaktion zurückgerollt wird;
- Zeilen 87–95: Das Array [$errors] ist leer, wenn kein Fehler aufgetreten ist. Die Transaktion wird dann mit der Methode [PDO::commit] bestätigt: Die von den SQL-Befehlen vorgenommenen Änderungen werden dauerhaft. Andernfalls wird die Transaktion mit der Methode [PDO::rollBack] zurückgerollt: Die von den SQL-Befehlen der Transaktion vorgenommenen Änderungen werden rückgängig gemacht. Der Transaktionsfehler wird dann der Fehlerliste hinzugefügt.
Bevor das Skript [mysql-07.php] ausgeführt wird, enthält die Tabelle [persons] die zehn Zeilen, die das Skript [mysql-06.php] eingefügt hat:
Führen Sie das Skript [mysql-07.php] aus. Die Bildschirmausgaben lauten wie folgt:
- Zeilen 47–52: Die Zeile [Josette, Bruneau, 46] wurde innerhalb der Transaktion erfolgreich in die Tabelle eingefügt;
- Zeile 53: Beim Befehl [xselect] tritt ein Fehler auf;
- Zeile 54: Die Transaktion wird anschließend zurückgerollt.
Prüfen wir den Zustand der Datenbank, stellen wir fest, dass sie sich im selben Zustand befindet wie vor der Ausführung des Skripts. Insbesondere sehen wir die Zeile [Josette, Bruneau, 46] aus Zeile 52 der obigen Ergebnisse nicht:
Zusammenfassung:
- Eine Transaktion beginnt mit der Methode [PDO::beginTransaction];
- sie wird mit der Methode [PDO::commit] erfolgreich abgeschlossen;
- sie wird bei einem Fehlschlag mit der Methode [PDO::rollBack] beendet;
- die Methode [PDO::inTransaction] gibt an, ob eine Transaktion läuft.
Bei der Arbeit mit einer Datenbank empfiehlt es sich, jede SQL-Operation in eine Transaktion zu packen, um sie von anderen Benutzern der Datenbank zu isolieren (auch das ist einer ihrer Zwecke). Eine Transaktion sollte so kurz wie möglich sein. Beenden Sie sie daher unbedingt je nach Fall mit einem [commit] oder einem [rollBack], . Beachten Sie schließlich: Bei MySQL lassen sich Befehle, die die Struktur der Datenbank ändern ([create table], [drop table] usw.), nicht zurückrollen. Sie bestätigen die aktuelle Transaktion implizit. Deshalb enthält die Datei [sql2.txt] nur Befehle vom Typ [select], [insert], [update] und [delete] .