PHP PDO Einleitung

  • Eine kurze Einleitung in die Grundlagen von PDO. Verbinden, Abfragen & Verarbeiten ist hier das Stichwort.

    Nachdem ich schon eine Einleitung zu MySQLi geschrieben habe, nun eine Einleitung zu PDO.


    Inhaltsverzeichnis:

    1. Einleitung
    2. Verbinden
    3. Querys (SELECT, INSERT, UPDATE, DELETE)
    4. Prepared Statements
    5. Abfragen
    6. Daten verarbeiten
    7. Beispiele


    1. Einleitung

    PDO ist eine PHP-Erweiterung welche Standardmäßig mit PHP5.1 kommt, aber bei PHP5.0 als extension installiert werden kann. Wichtig zu erwähnen ist, dass PDO nicht Datenbank abhängig ist. Theoretisch kann jeder Datenbanktyp mit PDO genutzt werden, für manche Datenbanktypen benötigt man aber eine Erweiterung auf Datenbankseite.[1]

    2. Verbinden

    Die Verbindung mit einer Datenbank ist in PDO einfach. Einfach eine Variable $handlererstellen und das PDO Object initialisieren.

    PHP
    1. $handler = new PDO("mysql:host=localhost;dbname=TestDatenbank", "root", "root");

    Als erstes kommt der Verbindungs-String, welcher von Datenbank zu Datenbank unterschiedlich sein kann. In meinem Beispiel nutze ich eine MySQL Datenbank. Als zweiten Parameter geben wir die Datenbank an, welche wir benutzen wollen, gefolgt von dem Benutzer und dessen Passwort.


    Zusätzlich hat man die Möglichkeit Konfigurationsparameter als Array mit zu übergeben. Häufig genutzt wird dabei (in unserem Raum) der folgende Parameter.

    PHP
    1. $handler = new PDO("mysql:host=localhost;dbname=TestDatenbank", "root", "root", array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));

    Hier sehen wir den Array mit Konfigurationsparametern, in unserem Fall PDO::MYSQL_ATTR_INIT_COMMAND, welches uns ermöglicht beim Verbinden mit der Datenbank einen SQL-Befehl auszuführen. In dem Bespiel benutze ich SET NAMES utf8;mit dem einfachen Grund, dass diese Query dazu da ist, die Datenbank auf Umlaute und Sonderzeichen vorzubereiten (ö,ä,ü,...).


    Beim Verbinden kann man auch eine Exception catchen und zwar die PDOException, das sieht dann gefolgt aus:

    PHP
    1. try {
    2. $handler = new PDO("mysql:host=localhost;dbname=TestDatenbank", "root", "root");
    3. } catch(PDOException $e) {
    4. echo $e->getMessage();
    5. }


    3. Querys

    In PDO haben wir die Möglichkeit, wie bei MySQLi auch, eine ganz normale Query zu machen. Dazu schreiben wir einfach eine Variable $queryund führen diese mit der Funktion query()aus.

    PHP
    1. $query = $handler->query("SELECT * FROM users WHERE id=1");


    Das verarbeiten von dem Result ist hier denkbar einfach. Wir loopen einfach durch das Result. Ungefähr so:

    PHP
    1. foreach ($handler->query("SELECT * FROM users WHERE name=Bennet") as $row) {
    2. print $row['name']; // Bennet
    3. print $row['display']; // ScorpiaWeb
    4. }

    Man kann aber auch die Methoden nutzen, welche weiter unten erläutert werden.


    Wenn wir nun aber einen Wert in unsere Datenbank einfügen wollen, dann ist das auch nicht so schwer. In folgenden Beispielen werde ich keine Prepared Statements benutzen, da es etwas verwirrend sein kann.

    INSERT, UPDATE und DELETE:

    Wollen wir Werte in unsere Datenbank einfügen, updaten oder löschen, dann brauchen wir eine normale Query (oder ein Prepared Statement):

    Wenn die Query truezurück gibt, wissen wir, dass unsere Query funktioniert hat, bekommen wir allerdings ein false, dann haben wir irgendwo einen Fehler.


    4. Prepared Statements

    Ein großer Vorteil von PDO ist das einfache erstellen von Prepared Statements. Prepared Statements sind wie Vorlagen für SQL, welche es ermöglich eine Query nicht immer wieder initialisieren zu müssen. So können wir einfach mehrere (z.B. INSERT) Abfragen hintereinander machen, ohne die Query dafür anpassen zu müssen. Im Folgenden Bespiel werde ich eine Benutzertabelle nach einem Benutzer mit einer ID abfragen.

    PHP
    1. $id = 3;
    2. $stmt = $handler->prepare("SELECT * FROM users WHERE id=:id");
    3. $stmt->bindParam(':id', $id);

    So erstellen wir ein Prepared Statement. mit bindParambinden wir den Wert der Variable $idan das Objekt :id. In der finalen Query wird dann der String automatisch ersetzt.

    Hierbei gibt es aber auch die Möglichkeit die Parameter erst beim ausführen der Query als array zu übergeben. Dazu müssen wir nur einen Array mit all unseren Werten machen.

    PHP
    1. $array = array('id' => '3');


    Hier ist nun ein Bespiel, wie man mit Prepared Statements drei verschiedene Datensätze in die Datenbank schreiben kann:


    Wir können also einfach so oft wir wollen das Statement ausführen und die Variablen ändern. Das kann von großem Vorteil sein, wenn man mehrere Datensätze auf einmal abfragen möchte. (Mit Abfragen ist auch INSERT, UPDATE, DELETE... gemeint)

    Wichtig: Prepared Statements sind 3x langsamer als normale Querys!


    5. Abfrage

    Nachdem wir jetzt unser Statement vorbereitet haben, können wir es ausführen, oder auch executieren.

    Das ganze ist auch wieder ganz einfach.

    PHP
    1. $stmt->execute();

    Falls ihr eure Werte aber in einem Array habt, müssen diese als Parameter bei execute(); mit übergeben werden, dies geschieht gefolgt:

    PHP
    1. $stmt->execute($array);

    Auch ganz einfach.


    6. Daten verarbeiten

    Da wir jetzt unser Statement ausgeführt haben, können wir uns zwischen verschiedenen Methoden entscheiden, wie wir diese verarbeiten wollen.

    Erstmal das, was wir schon ein bisschen von MySQLi kennen, das ganz normale fetch().

    PHP
    1. while ($row = $stmt->fetch()) {
    2. $result[] = $row;
    3. }

    Hier bekommen wir das Ergebnis als Array zurück. Darauf zugreifen tun wir dann ganz einfach mit print_r($result['name']); name ist in diesem Fall der Spaltenname.

    Möglich ist auch die Benutzung von fetchAll(); oder [2]

    Ein Beispiel mit fetchAll();sieht dann so aus:

    PHP
    1. $result = $stmt->fetchAll();

    In diesem Fall bekommen wir das Ergebnis in der Variable $resultals Array zurück. mit print_r($result);können wir die Struktur sehen.

    Verarbeiten können wir das ganze mit einer foreach()Schleife, indem wir durch alle Objekte loopen und dann auf die Eigenschaften zugreifen. Möglich ist dies entweder über den Spaltennamen oder den Index (0,1,2...);

    PHP
    1. foreach ($result as $row) {
    2. echo $row['name']; // oder $row[0];
    3. echo $row['display']; // oder $row[1];
    4. echo '<br>';
    5. }

    Die Ausgabe dieser Schleife sieht dann so aus:


    Es gibt die Möglichkeit bei fetch()und fetchAll()einen Parameter, den sogenannten fetch_style mit zu übergeben. Hier ist eine Tabelle mit allen styles und ihrer Bedeutung.


    fetch_style Bedeutung
    PDO::FETCH_ASSOC Gibt einen Array zurück. Zugriff auf die Daten erfolgt über den Spaltennamen.
    PDO::FETCH_BOTH Standard. Gibt einen Array zurück. Zugriff auf die Daten erfolgt über den Spaltennamen oder eine Indexnummer, startend bei 0.
    PDO::FETCH_BOUND Gibt true zurück. Bindet die Ergbnise an Variablen welche vorher mit bindColumn() festgelegt wurden.
    PDO::FETCH_CLASS So ähnlich wie PDO::FETCH_BOUND, nur das die Werte dieses mal in eine neue PHP Klasse übergeben werden, welche beim Aufrufen der Funktion initialisiert wird.
    PDO::FETCH_INTO Überschreibt alte Werte einer Klasse. Funktionsweise ist so ähnlich wie PDO::FETCH_CLASS.
    PDO::FETCH_LAZY Verbindet PDO::FETCH_BOTH und PDO::FETCH_OBJ. Erstellt Variablen wenn sie gebraucht werden.
    PDO::FETCH_NAMED Im Grunde genau das gleich wie PDO::FETCH_ASSOC, nur wenn da mehrere Spalten mit dem gleichen Namen sind, enthält der Spaltenname beim Zugriff dann einen Array.
    PDO::FETCH_OBJ Gibt ein Objekt zurück welches auf die Spaltennamen reagiert.
    PDO::FETCH_PROPS_LATE Wenn man das mit PDO::FETCH_CLASS nutzt, wird der Konstruktor der Klasse aufgerufen, bevor die Werte den Varaiblen zugewiesen werden.

    Eine Liste mit allen Möglichkeiten findet sich hier: PHP Docs fetch().


    7. Beispiele

    Hier habe ich mal 2 Beispiele für euch zusammen geschrieben.

    Zusammenfassung:


    PDO ist einfach zu meistern. Auch wenn bei Prepared Statements das Benchmarking nicht allzu gut ist, sollte das nicht von der Übersichtlichkeit und Effizienz ablenken.

    PDO unterstützt momentan 12 Datentypen, während MySQLi auf MySQL beschränkt ist. Während man allerdings bei MySQLi sich aussuchen kann ob man OOP oder prozedural programmiert, muss man in PDO Objekt-Orientiert schreiben. Auch ein Plus-Punkt bieten die Namen Parameters (:name), welche die Prepared Statements noch einfacher machen. Es ist nicht so, dass MySQLi das alles nicht bietet, aber es ist ein bisschen komplizierter als in PDO.


    Ich hoffe der Beitrag hat euch geholfen! Bei weiter Fragen, stehe ich gerne zur Verfügung. Einfach eine Nachricht hier im Forum oder per E-Mail an bennet@intranetproject.net.


    // danke an sirargon_ für die Verbesserungsvorschläge :)

    Einzelnachweise
    1. http://php.net/manual/en/intro.pdo.php
    2. http://php.net/manual/en/pdostatement.fetchall.php

Teilen

Kommentare 3