Inhalt
Als PHP 5 vor über 3 Jahre eingeführt wurde, brachte es eine ganze Reihe Neuerungen mit sich. Richtig durchgesetzt haben sich nur wenige, obwohl die meisten dieser Neuerungen das Programmiererleben erleichtern und/oder mächtigere Werkzeuge sind als sie es noch in den Vorgängerversionen waren. Ein Grund, der wichtigste Grund mag sein, dass viele Provider den Umstieg auf PHP 5 scheuten, weil dadurch viele Scripts der Kunden ihren Dienst versagten.
Zum Glück haben sich die Zeiten geändert und PHP 5 ist mittlerweile bei den meisten Providern, zumindest auf Nachfrage, verfügbar. Spätestens ab August 2008 wird PHP 4 nach und nach verschwinden, weil PHP.net den Support bereits zum Ende des Jahres 2007 eingeläutet hat. Es wird also höchste Zeit sich einige der wichtigsten Neuerungen von PHP 5 anzuschauen, wenn man nicht den Anschluss verpassen möchte. Eine dieser neuen Errungenschaften ist MySQLi.
Das i in MySQLi steht für improved, was übersetzt verbessert bedeutet. Das die neue MySQLi Erweiterung tatsächlich diverse Vorteile mit sich bringt sollte nach diesem kleinen Einführungstutorial offensichtlich werden.
Im Internet und in Büchern findet man schon diverse Tutorials zu diesem Thema, aber leider findet man Informationen nur häppchenweise auf zig Quellen verteilt. Deshalb versuche ich mit diesem Tutorial die wichtigsten Funktionen und die Handhabung zu bündeln, damit man sich nicht alles wie ein Eichhörnchen zusammen suchen muss. 😉
Um diesem Tutorial folgen zu können sind einige Voraussetzungen zu erfüllen:
Die MySQL Erweiterung von PHP war bisher ein Sammelsurium loser Funktionen, die nur eine prozedurale Programmierung ermöglichte. Dies zwang Programmierer dazu sich eigene Klassen für das DB Handling zu schreiben. Durch PHP 5 ist es nun aber möglich auch objektorientiert mit der DB zu kommunizieren, weil die MySQLi Erweiterung als Klasse (oder besser gesagt als Klassen-Paket) daher kommt und einheitliche Voraussetzungen für alle schafft. Um den Umstieg von MySQL nach MySQLi zu erleichtern, ist es aber immer noch möglich prozedural auf die Erweiterung zuzugreifen. Das widerspricht allerdings etwas dem "PHP 5 Spirit" der, nicht zuletzt durch die SPL und MySQLi, immer mehr in Richtung OOP geht. Aus diesem Grund werden die Beispiele in diesem Tutorial in guter OOP Manier präsentiert.
Werfen wir mal einen Blick auf einige Vorteile von MySQLi gegenüber MySQL.
Dies sind nur einige der Gründe, die im übrigen sowohl aus dem Internet, der Online Doku aber auch aus PHP 5 Bücher stammen, die einen Umstieg auf MySQLi rechtfertigen. Die MySQLi Erweiterung bietet aber auch wesentlich mehr Funktionen als die "klassische" MySQL Erweiterung. Das erkennt man schon daran, dass für MySQL knapp 50 prozedurale Funktionen zur Verfügung stehen, während die 3 wichtigsten MySQLi Klassen es bereits auf knapp 80 Methoden bringen.
Neben den reinen Fakten, macht MySQLi durch die OOP Schnittstelle aber auch mehr Spaß und wie wir weiter unten noch sehen werden, kann man effektiver und zeitsparender damit arbeiten.
MySQLi wurde entwickelt damit es sich in das objektorientierte Umfeld von PHP 5 einreiht. Die prozeduralen Funktionen wurden aus Gründen der Kompatibilität und eines einfachen Umstiegs für notorische Fortschrittsverweigerer beibehalten. Deswegen ist der OOP Weg dem prozeduralen Weg klar vorzuziehen.
Bevor wir endlich zum Code-Teil kommen, schauen wir uns kurz die Unterschiede zwischen MySQL, MySQLi prozedural und MySQLi objektorientiert an.
Für Umsteiger von MySQL
Der Umstieg ist denkbar einfach, denn alles das sich mehr oder weniger ändert ist, dass aus dem Präfix mysql_ ein mysqli_ wird. Hier einige Beispiele:
// Links der MySQL Befehl, rechts das MySQLi Gegenstueck. Der Pfeil bedeutet "wird zu" mysql_connect() -> mysqli_connect() mysql_query() -> mysqli_query() mysql_fetch_array() -> mysqli_fetch_array() // und so weiter
Die Methoden beim OOP sind (meistens) ebenso eindeutig. So wird aus dem Präfix mysqli_ der Objektname mit dem -> Operator. Beispiel:
// Angenommen unser Objekt traegt den Name $objekt dann sehen die Methoden wie folgt aus mysqli_query() -> $objekt->query() mysqli_fetch_array() -> $objekt->fetch_array() // und so weiter
Nichts desto Trotz gibt es aber einige Besonderheiten bzw Unterschiede bei der prozeduralen und OOP Schreibweise. Einige prozedurale Funktionen haben nämlich keine OOP Methode, sondern stehen beim OOP als Eigenschaft zu Verfügung! Schauen wir uns das mal an...
MySQLi Unterschiede der prozeduralen und OOP Schreibweise
Funktionen die einen Zähl-Wert zurück liefern stehen beim OOP als Eigenschaft zur Verfügung. Das sieht wie folgt aus:
// Liefert die Anzahl der gefundenen Datensaetze mysqli_num_rows() -> $objekt->num_rows // Liefert die Anzahl der betroffenen Datensaetze mysqli_affected_rows() -> $objekt->affected_rows
Dem affected_rows fällt eine besondere Rolle zu. So kann man es bei MySQLi jetzt auch als Ersatz für num_rows verwenden. Benutzt man in einem Query INSERT, UPDATE, REPLACE oder DELETE, liefert affected_rows die Anzahl der betroffenen Datensätze. Benutzt man in einem Query SELECT, liefert affected_rows die Anzahl der gefundenen Datensätze.
Insgesamt sind die Funktions-/Methodennamen bei MySQLi so gewählt, dass jeder halbwegs erfahrene PHP Programmierer problemlos umsteigen kann, da sich die Namen an die altbekannten MySQL Funktionen anlehnen. Es kamen aber auch neue Funktionen hinzu, von denen wir uns im weiteren Verlauf des Tutorial einige anschauen wollen.
Ohne eine Verbindung zur Datenbank wird es schwer Daten auszulesen bzw. einzutragen. Deswegen kümmern wir uns erst einmal um einen Connect.
<?php // Neues Datenbank-Objekt erzeugen $db = @new mysqli( 'localhost', 'root', '', 'tutorials' ); // Pruefen ob die Datenbankverbindung hergestellt werden konnte if (mysqli_connect_errno() == 0) { /* * Hier wird Code ausgefuehrt, wenn die Datenbankverbindung * fehlerfrei hergestellt werden konnte. */ } else { // Es konnte keine Datenbankverbindung aufgebaut werden echo 'Die Datenbank konnte nicht erreicht werden. Folgender Fehler trat auf: <span class="hinweis">' .mysqli_connect_errno(). ' : ' .mysqli_connect_error(). '</span>'; } // Datenbankverbindung schliessen $db->close(); ?>
Es ist nicht schwer zu erkennen was hier geschieht. Wie erzeugen ein Datenbankobjekt, wodurch automatisch eine Verbindung zur DB geöffnet wird, und prüfen ob dies fehlerfrei geschehen ist. Falls nicht, lassen wir uns den Fehlercode mit Fehlermeldung ausgeben. Am Ende des Script schließen wir die Verbindung wieder.
Aber der Reihe nach. Direkt in der ersten Zeile kommt schon etwas neues.
$db = @new mysqli( 'localhost', 'root', '', 'tutorials' );
Das "new mysqli()" entspricht dem "mysqli_connect()" der prozeduralen Schreibweise. Dieser Connect erwartet 3 Pflicht-Parameter, nämlich Serveradresse, Benutzername, Benutzerpasswort. Optional kann man aber auch noch direkt den Datenbankname angeben! Es ist also nicht nötig erst ein mysqli_select_db() auszuführen. Weitere optionale Parameter beim Connect sind Port und Sockel.
Mit mysqli_connect_errno() prüfen wir ob ein Fehler auftrat. Der Fehlercode 0 (Null) bedeutet das alles okay ist. Falls ein Fehler aufgetreten ist lassen wir uns diesen, zusammen mit dem Fehlercode, im else-Block ausgeben.
MySQLi kommt auch mit einer eigenen Exception Klasse (mysqli_sql_exception), die man natürlich erweitern kann um entsprechend auf Fehler zu reagieren.
Jetzt da wir wissen wie man eine Verbindung herstellt, schauen wir uns ein Beispiel an wie man Daten ausliest. Zu diesem Zweck benutze ich eine Mini-Tabelle mit einigen TP-Mod Namen und deren Zuständigkeitsbereich. Den Dump dieser Tabelle, sowie die Dateien zu diesem Tutorial gibt's weiter unten als Download.
Beim auslesen von Datensätze hat sich nicht viel geändert; zumindest nicht, wenn man den gewohnten Weg geht. Hier das Script mit dem wir unsere Mod-Liste auslesen können.
<?php // Neues Datenbank-Objekt erzeugen $db = @new mysqli( 'localhost', 'root', '', 'tutorials' ); // Pruefen ob die Datenbankverbindung hergestellt werden konnte if (mysqli_connect_errno() == 0) { // Query vorbereiten und an die DB schicken $sql = 'SELECT `name`, `bereich` FROM `moderatoren`'; $ergebnis = $db->query( $sql ); // Anzahl gefunde Datensaetze ausgeben echo "<p>Es wurden " .$ergebnis->num_rows. " Einträge gefunden.</p>"; // Ergebnisse ausgeben while ($zeile = $ergebnis->fetch_object()) { echo $zeile->name. " ist zuständig für " .$zeile->bereich. "<br />"; } // Resourcen freigeben $ergebnis->close(); } else { // Es konnte keine Datenbankverbindung aufgebaut werden echo 'Die Datenbank konnte nicht erreicht werden. Folgender Fehler trat auf: <span class="hinweis">' .mysqli_connect_errno(). ' : ' .mysqli_connect_error(). '</span>'; } // Datenbankverbindung schliessen $db->close(); ?>
Zuerst wird unsere Statement formuliert, das wir in $sql ablegen. In der Zeile ...
$ergebnis = $db->query( $sql );
... senden wir die Anfrage (Query) mit dem Statement ($sql) an die Datenbank und erhalten ein Ergebnis zurück das wir in $ergebnis ablegen, das dadurch zu einem Objekt wird. In der nächsten Zeile geben wir aus wie viele Datensätze gefunden wurden. Die Anzahl steckt, wie oben erwähnt, in der Eigenschaft num_rows unseres $ergebnis Objekts.
Die eigentlichen Datensätze werden in der while-Schleife ausgegeben. Dadurch das wir die Treffer-Zeilen als Objekt fetchen, erhalten wir Zugriff auf die Felder in Form von Objekt Eigenschaften. Selbstverständlich könnten wir das Ergebnis auch mit $ergebnis->fetch_array() ausgeben. In dem Fall würden wir auf die Zeilen als Array zugreifen: $zeile['name'] und $zeile['bereich']
Jetzt schauen wir uns einen alternativen MySQLi Weg an, wie wir an die Ergebnisse kommen können.
Neu in MySQLi ist, dass man Anweisungen an die Datenbank vorbereiten kann. Dadurch teilt man der DB mit welche Daten gesendet werden und wie damit zu verfahren ist. Es wird also nicht direkt eine Query an die DB geschickt, sondern erst eine Art Vorbote mit Informationen über die eigentliche Anweisung. Die Anweisung kann man zu einem beliebigen Zeitpunkt, beliebig oft an die DB senden.
Man bereitet also eine Anweisung ein mal vor und kann diese dann beliebig oft senden - das ist, besonders beim Eintragen in die DB, wesentlich schneller, übersichtlicher, flexibler und sicherer! Zunächst schauen wir uns aber an wie man Prepared Statements (Vorbereitete Anweisung) beim Auslesen verwendet.
<?php // Neues Datenbank-Objekt erzeugen $db = @new mysqli( 'localhost', 'root', '', 'tutorials' ); // Pruefen ob die Datenbankverbindung hergestellt werden konnte if (mysqli_connect_errno() == 0) { $sql = 'SELECT `name`, `bereich` FROM `moderatoren` ORDER BY `name`'; // Statement vorbereiten $ergebnis = $db->prepare( $sql ); // an die DB schicken $ergebnis->execute(); // Ergebnis an Variablen binden $ergebnis->bind_result( $name, $bereich ); // Ergebnisse ausgeben while ($ergebnis->fetch()) { echo $name. " ist zuständig für " .$bereich. "<br />"; } } else { // Es konnte keine Datenbankverbindung aufgebaut werden echo 'Die Datenbank konnte nicht erreicht werden. Folgender Fehler trat auf: <span class="hinweis">' .mysqli_connect_errno(). ' : ' .mysqli_connect_error(). '</span>'; } // Datenbankverbindung schliessen $db->close(); ?>
Das Zusammenstellen der Abfrage ist identisch zum vorherigen Beispiel. Diesmal wird $sql allerdings nicht direkt per $ergebnis = $db->query( $sql ); an die DB gesendet, sondern wir teilen der DB mit einem ...
$ergebnis = $db->prepare( $sql );
... mit was wir von der Abfrage erwarten. Wir bereiten (prepare) also die eigentliche Anweisung vor. Ausgeführt wird die Anweisung dann mit ...
$ergebnis->execute();
Dieses execute() kann man unendlich oft an die DB senden und es wird immer die zuletzt festgelegte Anweisung ausgeführt. Das hört sich momentan nach "na und?" an, ist aber beim befüllen der DB von großem Vorteil, wie wir weiter unten noch sehen werden. Das Abfrageergebnis steht jetzt zur Verfügung. Statt es direkt in einer Schleife auszugeben, binden wir die Felder der einzelnen Zeilen unseres Ergebnis an selbst definierte Variablen.
$ergebnis->bind_result( $name, $bereich );
Die Anzahl der Parameter (Variablen) muß identisch mit der Anzahl der Felder unserer Abfrage sein. Ausgegeben wird das Ergebnis dann in einer while-Schleife ...
while ($ergebnis->fetch()) { echo $name. " ist zuständig für " .$bereich. "<br />"; }
... bei der mittels $ergebnis->fetch() Zeile für Zeile auf unser Ergebnis zugegriffen wird. Die Variablen $name und $bereich werden bei jedem Durchlauf mit den neuen Werten gefüllt.
Diese Art des Ergebnis binden kann wesentlich übersichtlicher sein als ein Zugriff auf Objekt Eigenschaften oder assoziative Arrays. Desweiteren kann man sich auf diese Art teilweise das hantieren mit Aliases in der DB sparen.
Man kann aber nicht nur Abfrageergebnisse an Variablen binden, sondern auch Variablen an Anweisungen. Das, zusammen mit der Fähigkeit Anweisungen vorzubereiten, ermöglicht es uns sehr komfortabel und sicher Daten in die DB zu schreiben.
Zuerst basteln wir uns ein ganz schlichtes Formular, damit wir auch etwas zum schreiben in die Datenbank bekommen.
<form method="post" action="mysqli_schreiben.php"> Name: <input type="text" name="name" /><br /> Bereich <input type="text" name="bereich" /><br /> <input type="submit" name="submit" value="Eintragen" /> </form>
Zur Demonstration reichen die beiden Felder aus. Die übermittelten Daten werden von unserem Script entgegengenommen und verarbeitet. Werfen wir zuerst einen Blick auf das vollständige Script und gehen dann die neuen Zeilen durch.
<?php if (isset( $_POST['submit'] )) { // Maskierende Slashes aus POST Array entfernen if (get_magic_quotes_gpc()) { $_POST = array_map( 'stripslashes', $_POST ); } $name = $_POST['name']; $bereich = $_POST['bereich']; // Neues Datenbank-Objekt erzeugen $db = @new mysqli( 'localhost', 'root', '', 'tutorials' ); // Pruefen ob die Datenbankverbindung hergestellt werden konnte if (mysqli_connect_errno() == 0) { $sql = 'INSERT INTO `moderatoren` (`name`, `bereich`) VALUES (?, ?)'; $eintrag = $db->prepare( $sql ); $eintrag->bind_param( 'ss', $name, $bereich ); $eintrag->execute(); // Pruefen ob der Eintrag efolgreich war if ($eintrag->affected_rows == 1) { echo 'Der neue Eintrage wurde hinzugefügt.'; } else { echo 'Der Eintrag konnte nicht hinzugefügt werden.'; } } else { // Es konnte keine Datenbankverbindung aufgebaut werden echo 'Die Datenbank konnte nicht erreicht werden. Folgender Fehler trat auf: <span class="hinweis">' .mysqli_connect_errno(). ' : ' .mysqli_connect_error(). '</span>'; } // Datenbankverbindung schliessen $db->close(); } ?>
Der obere Teil sollte klar sein. Erst wird geprüft ob das Formular abgeschickt wurde, dann werden maskierende Slashes entfernt, die Variablen umgeladen, eine DB-Verbindung hergestellt und dann geht es los.
Wir stellen wieder unsere Anweisung zusammen und legen diese in $sql ab. Aber diesmal sehen wir sofort etwas besonderes.
$sql = 'INSERT INTO `moderatoren` (`name`, `bereich`) VALUES (?, ?)';
Im VALUES() Abschnitt werden keine Variablen eingegeben, sondern wir setzen hier Platzhalter ein. Für jedes Feld das wir hinzufügen möchten (hier name und bereich) muss ein Value respektive Platzhalter angegeben werden.
Der Platzhalter muß ein Fragezeichen sein und darf nicht von Quotes oder Double Quotes eingeschlossen sein!
Anschließend senden wir das vorbereitete Statement an die DB, damit diese weiß was zu tun ist. Nun kommen wir zum Kern des Ganzen:
$eintrag->bind_param( 'ss', $name, $bereich );
Hier binden wir Variablen an das Statement das wir zuvor an die DB geschickt haben. Der erste Parameter, hier 'ss', teilt der Datenbank mit um welche Daten es sich handeln wird, die in die DB geschrieben werden sollen. Anhand dessen wird die DB eigenständig das escapen (unschädlich machen von Benutzereingaben) übernehmen - dieser Parameter stellt also eine Typbezeichnung dar. Es gibt 4 Typen:
Die weiteren Parameter sind die eigentlichen Daten, die in die DB geschrieben werden sollen.
Wichtig: Jeder Platzhalter im Prepared Statement muss einen korrespondierenden Wert in bind_param() haben. Jeder Wert in bind_param() muss eine Typbestimmung haben!
Die Anzahl von Platzhalter, Typ-Bezeichner und Werte muss identisch sein, sonst kommt es zu Fehler!Ergänzendes Beispiel:
$sql = 'INSERT INTO `tabelle` (`id`, `kategorie`, `produktname`, `preis`) VALUES (?, ?, ?, ?)'; // uebergeben wird: Integer, String, String, Double $eintrag->bind_param( 'issd', 27, 'Werkzeug', 'Schraubenzieher', '39.99' );
Der Rest des Scripts ist selbsterklärend. Das execute() haben wir schon kennengelernt. Durch die Eigenschaft $eintrag->affected_rows ermitteln wir, ob der Eintrag erfolgreich war.
Hinweis zu bind_param() und execute()
Wenn einmal Variablen an ein Prepared Statement gebunden sind, können diese Variablen beliebig im Script geändert und anschließend mit execute() an die DB geschickt werden. Um mehrere Einträge zu schreiben ändert man also nur den Wert der Variablen und schickt diese an die DB - dies kann z.B. in einer Schleife geschehen. Beispiel:
$sql = 'INSERT INTO `tabelle` (`vorname`, `nachname`) VALUES (?, ?)'; $eintrag = $db->prepare( $sql ); // Variablen an die Anweisung binden $eintrag->bind_param( 'ss', $vorname, $nachname ); // Erster Eintrag $vorname = 'Max'; $nachname = 'Mustermann'; $eintrag->execute(); // Zweiter Eintrag $vorname = 'Fritz'; $nachname = 'Fischer'; $eintrag->execute(); // Dritter Eintrag $vorname = 'Susi'; $nachname = 'Sauer'; $eintrag->execute(); // usw
Jetzt kommen wir zu meinem neuen Lieblingsspielzeug bei MySQLi. 🙂 Jeder PHP Programmierer, vom Anfänger bis zum Vollprofi, stolpert früher oder später einmal über die Frage "Wie zum Geier kann ich in mehrere Tabellen gleichzeitig etwas eintragen oder updaten?". Dieser harmlosen Frage folgen dann in der Regel mehrere Stunden grübeln, Haare raufen und Verzweiflung. Bei MySQLi gibt es darauf eine ganz einfache Antwort: Multi Query!
Es ist nun endlich möglich mehrere Anweisungen mit nur einer Query an die Datenbank zu senden. Dabei können das mehrere lesende Zugriffe, mehrere schreibende Zugriffe oder auch gemischte Zugriffe (lesen und schreiben) sein. Man kann sogar z.B. schreibende Aktionen durchführen und beruhend auf dem Ergebnis eine lesende Aktion ausführen.
Als erstes möchte ich zeigen wie man eine Mehrfach-Abfrage durchführt und anschließend schreiben wir etwas in die Datenbank um gleichzeitig, quasi auf dem Rückweg, den neu hinzugefügten Datensatz wieder auszulesen.
<?php // Neues Datenbank-Objekt erzeugen $db = @new mysqli( 'localhost', 'root', '', 'tutorials' ); // Pruefen ob die Datenbankverbindung hergestellt werden konnte if (mysqli_connect_errno() == 0) { $sql = 'SELECT `name`, `bereich` FROM `moderatoren` WHERE `id` IN (1,2);'; $sql .= 'SELECT `name`, `bereich` FROM `moderatoren` WHERE `id` > 2 ORDER BY `name`;'; if ($db->multi_query( $sql )) { do { // Erstes Abfrageergebnis ausgeben if ($ergebnis = $db->store_result()) { echo $ergebnis->num_rows. " Ergebnisse gefunden<br />"; // Abfrageergebnis ausgeben while ($zeile = $ergebnis->fetch_object()) { echo $zeile->name. " ist zuständig für " .$zeile->bereich. "<br />"; } $ergebnis->close(); } // Trenner fuer Zweites Abfrageergebnis if ($db->more_results()) { echo "<hr />"; } } while ($db->next_result()); } } else { // Es konnte keine Datenbankverbindung aufgebaut werden echo 'Die Datenbank konnte nicht erreicht werden. Folgender Fehler trat auf: <span class="hinweis">' .mysqli_connect_errno(). ' : ' .mysqli_connect_error(). '</span>'; } // Datenbankverbindung schliessen $db->close(); ?>
Beim arbeiten mit Multi Query sind einige Dinge zu beachten. Das wichtigste ist, dass einzelne Anweisungen mit einem Semikolon voneinander getrennt werden müssen! Bei Multi Query kann man keine Prepared Statements, wie wir sie oben kennen gelernt haben, verwenden. Man muss sich also selbst um das escapen kümmern. (Das erkläre ich im nächsten Beispiel) Kommen wir zur Erklärung des Beispiels.
Zuerst stellen wir die Anweisungen zusammen. Wie wir sehen wollen wir 2 Abfragen an die Datenbank schicken. In der ersten Abfrage möchten wir die Datensätzen mit der ID 1 und 2 auslesen, in der zweiten Abfrage alle Datensätze deren ID höher als 2 ist.
Mit ...
if ($db->multi_query( $sql ))
... prüfen wir ob wir eine gültige Multi Query Resource haben. Ist das der Fall, kommt eine seltener benutzte do...while-Schleife zum Einsatz um die einzelnen Abfrageergebnisse abzuarbeiten. An das erste Abfrageergebnis kommen wir mit ...
if ($ergebnis = $db->store_result())
Hier wird also die Rückgabe von der DB in $ergebnis abgelegt, ähnlich wie das bei query() der Fall ist. Dieses Ergebnis können wir mit den ganz normalen, uns bestens bekannten Funktionen verarbeiten.
Ganz wichtig:
Auch wenn es bei einfachen Abfragen nicht zwingend erforderlich ist die Resourcen/Speicher unmittelbar nach der Verarbeitung wieder frei zu geben, so ist das bei Multi Query Pflicht! Versäumt man das Freimachen der Resourcen, kann es zu unerwartete Probleme kommen. In unserem Beispiel übernimmt das die Methode $ergebnis->close();
Hat man das erste Abfrageergebnis verarbeitet, wird mit ...
if ($db->more_results())
... geprüft ob weitere Resultate vorhanden sind. In diesem IF-Block kann man dann Anpassungen vornehmen um auf die neue Abfrage zu reagieren. So könnte es z.B. sein das die Erste und Zweite Abfrage eine unterschiedliche Anzahl Felder zurück liefert und die Ausgabeoptionen nicht mehr passen. In unserem Fall lassen wir nur eine Trennlinie ausgeben, damit wir sehen ob unser Script auch korrekt arbeitet. In der letzten Zeile der Schleife steht die while()...
while ($db->next_result());
... die das nächste Resultat an die innere Schleife übergibt.
Wenn man sich das ganze Konstrukt und die Methodennamen etwas näher anschaut wird man feststellen, dass sie große Ähnlichkeit mit denen der Iteratoren Klassen der SPL haben. Ein weiteres Indiz dafür, dass MySQLi eigentlich ausschließlich OOP und nicht prozedural angewendet werden sollte.
Kommen wir nun zum letzten Beispiel in diesem Tutorial. Ich hoffe das die Äuglein noch offen sind und noch niemand ins Koma gelangweilt wurde. 😉
Richtig interessant wird es, wenn man verschiedene Aufgaben mit nur einer Query erledigen kann. Wir werden nun einen Datensatz in die Datenbank schreiben und direkt im Anschluss den neuen Datensatz wieder auslesen. Damit wir auch den richtigen Datensatz auslesen, bedienen wir uns dabei einer MySQL-internen Methode. Zunächst der Quelltext des Scripts:
<?php // Neues Datenbank-Objekt erzeugen $db = @new mysqli( 'localhost', 'root', '', 'tutorials' ); // Pruefen ob die Datenbankverbindung hergestellt werden konnte if (mysqli_connect_errno() == 0) { $modname = $db->real_escape_string( 'Thomas' ); $modbereich = $db->real_escape_string( 'Webdesign & Co.' ); // Multi-Query zusammenstellen $sql = sprintf( "INSERT INTO `moderatoren` (`name`, `bereich`) VALUES ('%s', '%s');", $modname, $modbereich ); $sql .= 'SELECT `name`, `bereich` FROM `moderatoren` WHERE `id` = LAST_INSERT_ID();'; if ($db->multi_query( $sql )) { do { // Erstes Abfrageergebnis ausgeben if ($ergebnis = $db->store_result()) { echo $ergebnis->num_rows. " Ergebnisse gefunden<br />"; // Abfrageergebnis ausgeben while ($zeile = $ergebnis->fetch_object()) { echo $zeile->name. " ist zuständig für " .$zeile->bereich. "<br />"; } $ergebnis->close(); } } while ($db->next_result()); } } else { // Es konnte keine Datenbankverbindung aufgebaut werden echo 'Die Datenbank konnte nicht erreicht werden. Folgender Fehler trat auf: <span class="hinweis">' .mysqli_connect_errno(). ' : ' .mysqli_connect_error(). '</span>'; } // Datenbankverbindung schliessen $db->close(); ?>
In diesem Beispiel wurde Thomas dazu auserkoren als Versuchskaninchen, bzw. Anschauungsobjekt zu fungieren.
Da bei Multi Query keine Prepared Statements benutzt werden können, müssen wir uns selbst um das escapen kümmern. Dazu kennt MySQLi die Methode real_escape_string(). Jeder der vorher schon sauber programmiert hat kennt das bereits, da der name von MySQL übernommen wurde. Nachdem wir Thomas unschädlich gemacht haben (:D) stellen wir wieder unsere Anweisungen zusammen. Dazu benutze ich hier sprintf(), dass, genau wie bind_param(), mit Platzhalter arbeitet.
Die erste Anweisung schreibt also einen neuen Datensatz in unsere Tabelle, der eine neue auto_increment ID erhält. Diese ID wird von MySQL standardmässig in LAST_INSERT_ID() abgelegt und ist für die aktive Verbindung verfügbar. Die zweite Anweisung ...
$sql .= 'SELECT `name`, `bereich` FROM `moderatoren` WHERE `id` = LAST_INSERT_ID();';
... liest also einen Datensatz aus, dessen `id` den Wert der zuletzt eingefügten ID hat. Der Rest des Script wurde bereits weiter oben erklärt. Der einzige Unterschied hier ist, dass eine schreibende Aktion keinen Rückgabewert hat (abgesehen von affected_rows) und multi_query() deshalb direkt zur zweiten, lesenden Abfrage springt und diese ausgibt.
Auf diese Art kann man auch in mehrere Tabellen schreiben um Datensätze anzulegen oder zu aktualisieren. Man muß sich also keinen Knoten mehr in's Gehirn überlegen, wie denn der JOIN jetzt aussehen muß damit man über mehrere Tabellen hinweg einen Eintrag aktualisieren kann.
Dem Multi Query kann man quasi unbegrenzt Anweisungen mitgeben, die mit einer einzigen Anfrage abgearbeitet werden. Das ist wesentlich performanter als mehrere kleine Anweisungen an die DB zu schicken.
Damit sind wir am Ende des Tutorial. Ich hoffe es war nicht allzu lang und halbwegs verständlich geschrieben. Das Thema ist natürlich sehr komplex und MySQLi bietet noch viel viel mehr als das hier gezeigte. Dieses Tutorial soll lediglich einen ersten Einstieg/Umstieg erleichtern und vielleicht konnte ich damit ja dazu beitragen, dass der ein oder andere jetzt auf den MySQLi-Geschmack gekommen ist. Ich für meinen Teil bin es auf jeden Fall und werde vermutlich nur noch MySQLi Anwendungen schreiben, weil es einfach, schnell, komfortabel und sicher ist.
Wer sich noch weiter mit den PHP 5 Neuerungen befassen möchte, dem lege ich als Einstieg noch mein SPL Tutorial nahe.
Vielen Dank für's Lesen und viel Spaß mit MySQLi! 🙂
Hier gibt es noch die Dateien zum Tutorial, damit man das Tutorial besser nachvollziehen kann und natürlich Links zur Online Doku von PHP.net von den verwendeten Funktionen.