Einführung in die MySQLi-Erweiterung von PHP 5

Vorwort

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

Voraussetzungen

Um diesem Tutorial folgen zu können sind einige Voraussetzungen zu erfüllen:

• PHP 5 (optimalerweise PHP 5.2.5 oder höher)
• Aktivierte MySQLi Unterstützung (erfährt man über phpinfo)
• MySQL 4.1 oder höher (optimal 5.x oder höher)
• Zumindest Grundlagenwissen im Umgang mit PHP und MySQL
• Kenntnisse über objektorientierte Programmierung in PHP erleichtern das Verstehen dieses Tutorials
• ... und natürlich Lernbereitschaft

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.

MySQL vs MySQLi

Werfen wir mal einen Blick auf einige Vorteile von MySQLi gegenüber MySQL.

• Der OOP Zugriff ist einheitlich, wodurch arbeiten im Team oder an Fremdprojekten vereinfacht wird
• Größere Geschwindigkeit - Laut Hersteller kann ein vielfaches an Geschwindigkeit erreicht werden.
• Verbesserte Sicherheit - Für die PHP-MySQL Verbindung wird eine SSH-ähnliche Authentifizierung benutzt
• Das neue Binärprotokoll von MySQL wird verwendet. Dadurch stehen mehr Funktionen zur Verfügung und die Verarbeitung ist schneller und effizienter
• Keine Standardverbindung und Prepared Statements erzwingen eine saubere und somit sicherere Programmierung
• Verbesserte Trace- und Debug-Funktionen
• Multi-Queries werden unterstützt

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.

Prozedural oder objektorientiert?

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.

Datenbankverbindung öffnen/schließen

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.

Datensätze auslesen (Query Methode)

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&auml;ge gefunden.</p>";
    // Ergebnisse ausgeben
    while ($zeile = $ergebnis->fetch_object())
    {
        echo $zeile->name. " ist zust&auml;ndig f&uuml;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.

Datensätze auslesen (Prepare Methode)

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&auml;ndig f&uuml;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&auml;ndig f&uuml;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.

Datensätze schreiben mit Prepared Statements

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&uuml;gt.';
        }
        else
        {
            echo 'Der Eintrag konnte nicht hinzugef&uuml;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:

• s = String
• i = Integer (Ganzzahl)
• d = Double (Gleitkommazahl)
• b = BLOB (Binary Large Object - also eine binäre Datei)

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

Mehrfach-Statements - Multi Query

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&auml;ndig f&uuml;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&auml;ndig f&uuml;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.

Fazit

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! 🙂

Lesestoff

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.

• Die MySQLi Referenz auf PHP.net
• mysqli_affected_rows
• mysqli_connect_errno
• mysqli_connect_error
• mysqli_fetch_array
• mysqli_fetch_object
• mysqli_more_results
• mysqli_multi_query
• mysqli_next_result
• mysqli_num_rows
• mysqli_prepare
• mysqli_real_escape_string
• mysqli_stmt_bind_param
• mysqli_stmt_bind_result
• mysqli_stmt_close
• mysqli_stmt_execute
• mysqli_stmt_fetch
• mysqli_stmt_store_result
• sprintf