Skip to content

7. Verwendung von SGBD und MySql

Wir werden PHP-Skripte unter Verwendung einer MySQL-Datenbank schreiben:

Das SGBD MySQL ist im Paket WampServer enthalten (siehe Abschnitt 2.1.1). Wir zeigen, wie man eine Datenbank sowie einen Benutzer MySQL anlegt.

  • Nach dem Start kann WampServer über das Symbol [1] verwaltet werden, das sich unten rechts in der Taskleiste befindet.
  • In [2] wird das Verwaltungstool von MySQL gestartet

Man erstellt eine Datenbank mit dem Namen [dbpersonnes]:

Image

Man legt einen Benutzer [admpersonnes] mit dem Passwort [nobody] an:

  • in [1], den Namen des Benutzers
  • in [2], der Rechner mit der ID SGBD, auf dem ihm Rechte gewährt werden
  • in [3], sein Passwort
  • in [4], ebenso
  • in [5]: Diesem Benutzer werden keine Rechte erteilt
  • in [6] wird er angelegt
  • in [7], man kehrt zur Startseite von phpMyAdmin zurück
  • In [8] wird der Link [Privileges] auf dieser Seite verwendet, um die Einträge der Benutzer [admpersonnes] und [9] zu bearbeiten.

1011

Image

  • In [10] geben wir an, dass wir dem Benutzer [admpersonnes] Rechte für die Datenbank [dbpersonnes]
  • In [11] wird die Auswahl bestätigt
  • mit dem Link [12] bestätigt. In [Tout cocher] werden dem Benutzer [admpersonnes] alle Rechte an der Datenbank [dbpersonnes] [13]
  • Wir bestätigen dies in [14]

Nun haben wir:

  • eine Datenbank MySQL [dbpersonnes]
  • einen Benutzer [admpersonnes / nobody], der über alle Rechte an dieser Datenbank verfügt

Wir werden Skripte PHP schreiben, um die Datenbank zu nutzen. PHP verfügt über verschiedene Bibliotheken zur Verwaltung von Datenbanken. Wir werden die Bibliothek PDO (PHP Data Objects) verwenden, die als Schnittstelle zwischen dem Code PHP und SGBD dient:

Die Bibliothek PDO ermöglicht es dem Skript PHP, sich von der genauen Art des verwendeten SGBD zu abstrahieren. So kann im obigen Beispiel das SGBD MySQL durch das Postgres-SGBD ersetzt werden, wobei der Code des Skripts PHP nur minimal betroffen ist. Diese Bibliothek ist standardmäßig nicht verfügbar. Die Verfügbarkeit der „ “ lässt sich wie folgt überprüfen:

  • 1: Über das Verwaltungssymbol von WampServer wählen Sie die Option [PHP / PHP extensions] aus
  • 2: Man sieht die verschiedenen verfügbaren Erweiterungen PDO und die aktiven: [PHP_pdo_mysql] für SGBD MySQL, [PHP_pdo_sqlite] für SGBD und SQL Lite. Um eine Erweiterung zu aktivieren, klicken Sie einfach darauf. Der Interpreter PHP wird dann mit der neuen, aktivierten Erweiterung neu gestartet.

7.1. Verbindung zu einer MySQL-Datenbank – 1 (mysql_01)

Die Verbindung zu einem SGBD erfolgt durch die Erstellung eines PDO-Objekts. Der Konstruktor akzeptiert verschiedene Parameter:

$dbh=new PDO($dsn,$user,$passwd,$driver_options)

Die Parameter haben folgende Bedeutung:

$dsn
(Data Source Name) ist eine Zeichenkette, die die Art des SGBD und dessen Standort im Internet angibt. Die Zeichenkette
„mysql:host=localhost“ gibt an, dass es sich um ein SGBD MySQL handelt, das auf dem lokalen Server läuft. Diese Zeichenfolge
kann weitere Parameter enthalten, insbesondere den Listening-Port des SGBD und den Namen der Datenbank, mit der
eine Verbindung hergestellt werden soll: „mysql:host=localhost:port=3306:dbname=dbpersonnes“.
$user
Benutzername des sich anmeldenden Benutzers
$passwd
sein Passwort
$driver_options
ein Optionsarray für den Treiber des SGBD

Nur der erste Parameter ist obligatorisch. Das so erstellte Objekt dient anschließend als Grundlage für alle Operationen, die an der Datenbank durchgeführt werden, mit der eine Verbindung hergestellt wurde. Wenn das Objekt PDO nicht erstellt werden konnte, wird eine Ausnahme vom Typ PDOException ausgelöst.

Hier ein Beispiel für eine Verbindung:


<?php

// Verbindung zu einer Datenbank MySql
// Die Identität des Benutzers lautet (admpersonnes,nobody)
$ID = "admpersonnes";
$PWD = "nobody";
$HOTE = "localhost";

try {
  // Anmeldung
  $dbh = new PDO("mysql:host=$HOTE", $ID, $PWD);
  print "Connexion réussie\n";
  // Abmeldung
  $dbh = null;
} catch (PDOException $e) {
  print "Erreur : " . $e->getMessage() . "\n";
  exit();
}

Ergebnisse:

Connexion réussie

Anmerkungen

  • Zeile 11: Die Verbindung zu einem SGBD wird durch die Erstellung eines PDO-Objekts hergestellt. Der Konstruktor wird hier mit den folgenden Parametern verwendet:
    • Eine Zeichenfolge, die die Art des SGBD und dessen Standort im Internet angibt. Die Zeichenfolge „mysql:host=localhost“ weist darauf hin, dass es sich um einen SGBD MySQL handelt, der auf dem lokalen Server läuft. Der Port wurde nicht angegeben. Daher wird standardmäßig Port 3306 verwendet. Der Name der Datenbank wurde ebenfalls nicht angegeben. Es wird daher eine Verbindung zu SGBD MySQL hergestellt, wobei die Auswahl einer bestimmten Datenbank erst später erfolgt.
    • eine Benutzer-ID
    • sein Passwort
  • Zeile 14: Das Schließen der Verbindung erfolgt durch Löschen des ursprünglich erstellten Objekts PDO.
  • Zeile 15: Die Verbindung zu einem SGBD kann fehlschlagen. In diesem Fall wird eine Ausnahme vom Typ PDOException ausgelöst.

7.2. Erstellung einer Tabelle MySQL (mysql_02)


<?php

// Anmeldung bei der Datenbank MySql
// Benutzeridentität
$ID = "admpersonnes";
$PWD = "nobody";
// Datenbank-ID
$DSN = "mysql:host=localhost;dbname=dbpersonnes";

// Verbindung
list($erreur, $connexion) = connecte($DSN, $ID, $PWD);
if ($erreur) {
  print "Erreur lors de la connexion à la base [$DSN] sous l'identité ($ID,$PWD) : $erreur\n";
  exit;
}

// Löschen der Tabelle „Personen“, falls vorhanden
$requête = "drop table personnes";
$erreur = exécuteRequête($connexion, $requête);
//Ist ein Fehler aufgetreten?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// Erstellung der Tabelle „Personen“
$requête = "create table personnes (prenom varchar(30) NOT NULL, nom varchar(30) NOT NULL, age integer NOT NULL, primary key(nom,prenom))";
$erreur = exécuteRequête($connexion, $requête);
//Ist ein Fehler aufgetreten?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// Abmeldung und Beenden
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // Verbindung ($login,$pwd) zur Datenbank $dsn herstellen
  // gibt die Verbindungs-ID sowie einen Fehlercode zurück
  try {
    // Verbindung
    $dbh = new PDO($dsn, $login, $pwd);
    // Rückgabe ohne Fehler
    return array("", $dbh);
  } catch (PDOException $e) {
    // Rückgabe mit Fehler
    return array($e->getMessage(), null);
  }
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  // schließt die durch $connexion identifizierte Verbindung
  $connexion = null;
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // führt die Abfrage $sql über die Verbindung $connexion aus
  try {
    $connexion->exec($sql);
    // keine Fehlermeldung
    return "";
  } catch (PDOException $e) {
    // Rückgabe mit Fehler
    return $e->getMessage();
  }
}

Ergebnisse:

drop table personnes: Exécution réussie
create table personnes (prenom varchar(30) NOT NULL, nom varchar(30) NOT NULL, age integer NOT NULL, primary key(nom,prenom)): Exécution réussie

In PHPMyAdmin ist das Vorhandensein der Tabelle zu erkennen:

 

Kommentare

  • Zeilen 38–50: Die Funktion connecte stellt eine Verbindung zu einer SGBD her. Sie gibt ein Array zurück ($erreur, $connexion), wobei $connexion die erstellte Verbindung ist oder null, falls die Verbindung nicht erstellt werden konnte. Im letzteren Fall ist $erreur eine Fehlermeldung.
  • Zeilen 53–56: Die Funktion déconnecte schließt eine Verbindung
  • Zeile 59: Die Funktion exécuteRequête ermöglicht die Ausführung eines Befehls SQL auf einer Verbindung. Die Verbindung ist ein Objekt vom Typ PDO. Die Methode, die verwendet wird, um einen Befehl SQL auf einem Objekt PDO auszuführen, ist die Methode exec (Zeile 63). Die Ausführung der Abfrage kann einen Befehl PDOException auslösen. Daher wird auch dieser verarbeitet. Die Funktion gibt im Fehlerfall eine Fehlermeldung zurück, andernfalls eine leere Zeichenkette.

7.3. Befüllen der Personentabelle (mysql_03)

Das folgende Skript führt die Befehle SQL aus, die in der folgenden Textdatei [creation.txt] enthalten sind:

drop table personnes
create table personnes (prenom varchar(30) not null, nom varchar(30) not null, age integer not null, primary key (nom,prenom))
insert into personnes values('Paul','Langevin',48)
insert into personnes values ('Sylvie','Lefur',70)
insert into personnes values ('Pierre','Nicazou',35)
insert into personnes values ('Geraldine','Colou',26)
insert into personnes values ('Paulette','Girond',56)


<?php

// Verbindung zur Datenbank MySql
// Benutzer-ID
$ID = "admpersonnes";
$PWD = "nobody";
// Datenbank-ID
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// ID der auszuführenden Befehlstextdatei SQL
$TEXTE = "creation.txt";

// Verbindung
list($erreur, $connexion) = connecte($DSN, $ID, $PWD);
if ($erreur) {
  print "Erreur lors de la connexion à la base [$DSN] sous l'identité ($ID,$PWD) : $erreur\n";
  exit;
}

// Erstellung und Befüllung der Tabelle
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//Anzeige der Fehleranzahl
print "il y a eu $erreurs[0] erreurs\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";

// Verbindung trennen und beenden
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
...
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
 ...
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // führt die Abfrage $sql über die Verbindung $connexion aus
  // gibt im Fehlerfall eine Fehlermeldung zurück, andernfalls eine leere Zeichenkette
  ...
}

// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // verwendet die Verbindung $connexion
  // führt die in der Textdatei $SQL enthaltenen Befehle SQL aus
  // Diese Datei ist eine Befehlsdatei, in der die Befehle SQL zeilenweise ausgeführt werden
  // Wenn $suivi=1 ist, wird bei jeder Ausführung eines Befehls SQL eine Meldung angezeigt, die angibt, ob der Befehl erfolgreich war oder fehlgeschlagen ist
  // Wenn $arrêt=1 ist, bricht die Funktion beim ersten aufgetretenen Fehler ab, andernfalls führt sie alle SQL-Befehle aus
  // Die Funktion gibt ein Array zurück (Anzahl der Fehler, Fehler1, Fehler2, …)
  
  // Es wird überprüft, ob die Datei $SQL vorhanden ist
  if (! file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");

  // Ausführung der in $SQL enthaltenen Abfragen SQL
  // sie werden in ein Array gespeichert
  $requêtes = file($SQL);
  // Sie werden ausgeführt – zunächst keine Fehler
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //– gibt es eine leere Abfrage?
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // Ausführung der Abfrage $i
    $erreur = exécuteRequête($connexion, $requêtes[$i]);
    //Ist ein Fehler aufgetreten?
    if ($erreur) {
      // Ein weiterer Fehler
      $erreurs[0]++;
      // Fehlermeldung
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // Bildschirmüberwachung ja oder nein?
      if ($suivi)
        print "$msg\n";
      // Hören wir auf?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi)
      print "$requêtes[$i] : Exécution réussie\n";
  }//für
  // Zurück
  return $erreurs;
}

Die Bildschirmausgabe:

drop table personnes : Exécution réussie
create table personnes (prenom varchar(30) not null, nom varchar(30) not null, age integer not null, primary key (nom,prenom)) : Exécution réussie
insert into personnes values('Paul','Langevin',48) : Exécution réussie
insert into personnes values ('Sylvie','Lefur',70) : Exécution réussie
insert into personnes values ('Pierre','Nicazou',35) : Exécution réussie
insert into personnes values ('Geraldine','Colou',26) : Exécution réussie
insert into personnes values ('Paulette','Girond',56) : Exécution réussie
il y a eu 0 erreurs

Die vorgenommenen Einfügungen sind mit PhpMyAdmin sichtbar:

 

Anmerkungen

Die Neuerung besteht in der Funktion exécuterCommandes in den Zeilen 48–90. Diese Funktion führt auf der Verbindung $connexion die Befehle SQL aus, die in der Textdatei mit dem Namen $SQL enthalten sind. Sie gibt ein Fehlerarray zurück ($nbErreurs, $msg1, $msg2, …), wobei $nbErreurs die Anzahl der Fehler angibt, $msgi die Fehlermeldung Nr. i.. Wenn keine Fehler vorliegen, ist das zurückgegebene Array das Array array(0).

7.4. Ausführung beliebiger Abfragen SQL (mysql_04)

Das folgende Skript zeigt die Ausführung der Befehle SQL aus der folgenden Textdatei [sql.txt]:

select * from personnes
select nom,prenom from personnes order by nom asc, prenom desc
select * from personnes where age between 20 and 40 order by age desc, nom asc, prenom asc
insert into personnes values('Josette','Bruneau',46)
update personnes set age=47 where nom='Bruneau'
select * from personnes where nom='Bruneau'
delete from personnes where nom='Bruneau'
select * from personnes where nom='Bruneau'
xselect * from personnes where nom='Bruneau'

Unter diesen Befehlen (SQL) befindet sich der Befehl „select“, der Ergebnisse aus der Datenbank zurückgibt, die Befehle „insert“, „update“ und „delete“, die die Datenbank ändern, ohne Ergebnisse zurückzugeben, sowie fehlerhafte Befehle wie der letzte (xselect).


<?php

// Verbindung zur Datenbank MySql
// Benutzeridentität
$ID = "admpersonnes";
$PWD = "nobody";
// Datenbank-ID
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// ID der auszuführenden Befehlstextdatei SQL
$TEXTE = "sql.txt";

// Verbindung
list($erreur, $connexion) = connecte($DSN, $ID, $PWD);
if ($erreur) {
  print "Erreur lors de la connexion à la base [$DSN] sous l'identité ($ID,$PWD) : $erreur\n";
  exit;
}

// Ausführung der Befehle SQL
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//Anzeige der Fehleranzahl
print "il y a eu $erreurs[0] erreur(s)\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";

// Abmeldung und Beenden
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // Verbindung ($login,$pwd) zur Datenbank $dsn herstellen
  // gibt die Verbindungs-ID sowie eine Fehlermeldung zurück
  ...
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  ...
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // führt die Abfrage $sql über die Verbindung $connexion aus
  // gibt ein Array mit 2 Elementen zurück ($erreur, $résultat)
  
  // Es wird festgestellt, ob es sich um eine SELECT-Anweisung handelt oder nicht
  $commande = "";
  if (preg_match("/^\s*(\S+)/", $sql, $champs)) {
    $commande = $champs[0];
  }
  // Ausführung des Befehls
  try {
    if (strtolower($commande) == "select") {
      $res = $connexion->query($sql);
    } else {
      $res = $connexion->exec($sql);
      if($res===FALSE){
        $info=$connexion->errorInfo();
        return array($info[2],null);
      }
    }
    // Rückgabe ohne Fehler
    return array("", $res);
  } catch (PDOException $e) {
    // Rückgabe mit Fehler
    return array($e->getMessage(), null);
  }
}

// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // verwendet die Verbindung $connexion
  // führt die in der Textdatei $SQL enthaltenen Befehle SQL aus
  // Diese Datei ist eine Befehlsdatei SQL, deren Befehle zeilenweise ausgeführt werden
  // Wenn $suivi=1 ist, wird bei jeder Ausführung eines Befehls SQL eine Meldung angezeigt, die angibt, ob der Befehl erfolgreich war oder fehlgeschlagen ist
  // Wenn $arrêt=1 ist, bricht die Funktion beim ersten aufgetretenen Fehler ab, andernfalls führt sie alle SQL-Befehle aus
  // Die Funktion gibt ein Array zurück (Anzahl der Fehler, Fehler1, Fehler2, …)
  // Es wird geprüft, ob die Datei $SQL vorhanden ist
  if (!file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");

  // Ausführung der in $TEXTE enthaltenen Abfragen SQL
  // Diese werden in ein Array gespeichert
  $requêtes = file($SQL);
  // wird ausgeführt – zunächst ohne Fehler
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //– haben wir eine leere Abfrage?
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // Ausführung der Abfrage $i
    list($erreur, $res) = exécuteRequête($connexion, $requêtes[$i]);
    //Ist ein Fehler aufgetreten?
    if ($erreur) {
      // Ein weiterer Fehler
      $erreurs[0]++;
      // Fehlermeldung
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // Bildschirmüberwachung ja oder nein?
      if ($suivi)
        print "$msg\n";
      // Wird der Vorgang abgebrochen?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi) {
      print "$requêtes[$i] : Exécution réussie\n";
      // Informationen zum Ergebnis der ausgeführten Abfrage
      afficherInfos($res);
    }
  }//für
  // Rückgabe
  return $erreurs;
}

// ---------------------------------------------------------------------------------
function afficherInfos($résultat) {
  // zeigt das Ergebnis $résultat einer SQL-Abfrage an
  // Handelte es sich um eine SELECT-Anweisung?
  if ($résultat instanceof PDOStatement) {
    // Die Feldnamen werden angezeigt
    $titre = "";
    $nbColonnes = $résultat->columnCount();
    for ($i = 0; $i < $nbColonnes; $i++) {
      $infos = $résultat->getColumnMeta($i);
      $titre.=$infos['name'] . ",";
    }
    // Das letzte Zeichen wird entfernt,
    $titre = substr($titre, 0, strlen($titre) - 1);
    // die Liste der Felder wird angezeigt
    print "$titre\n";
    // Trennzeile
    $séparateurs = "";
    for ($i = 0; $i < strlen($titre); $i++) {
      $séparateurs.="-";
    }
    print "$séparateurs\n";
    // Daten
    foreach ($résultat as $ligne) {
      $data = "";
      for ($i = 0; $i < $nbColonnes; $i++) {
        $data.=$ligne[$i] . ",";
      }

      // das letzte Zeichen wird entfernt,
      $data = substr($data, 0, strlen($data) - 1);
      // wird angezeigt
      print "$data\n";
    }
  } else {
    // Es handelte sich nicht um eine Auswahl
    print " $résultat lignes(s) a (ont) été modifiée(s)\n";
  }
}

Die Bildschirmausgabe:

select * from personnes
 : Exécution réussie
prenom,nom,age
--------------
Geraldine,Colou,26
Paulette,Girond,56
Paul,Langevin,48
Sylvie,Lefur,70
Pierre,Nicazou,35
select nom,prenom from personnes order by nom asc, prenom desc : Exécution réussie
nom,prenom
----------
Colou,Geraldine
Girond,Paulette
Langevin,Paul
Lefur,Sylvie
Nicazou,Pierre
select * from personnes where age between 20 and 40 order by age desc, nom asc, prenom asc : Exécution réussie
prenom,nom,age
--------------
Pierre,Nicazou,35
Geraldine,Colou,26
insert into personnes values('Josette','Bruneau',46) : Exécution réussie
 1 lignes(s) a (ont) été modifiée(s)
update personnes set age=47 where nom='Bruneau' : Exécution réussie
 1 lignes(s) a (ont) été modifiée(s)
select * from personnes where nom='Bruneau' : Exécution réussie
prenom,nom,age
--------------
Josette,Bruneau,47
delete from personnes where nom='Bruneau' : Exécution réussie
 1 lignes(s) a (ont) été modifiée(s)
select * from personnes where nom='Bruneau' : Exécution réussie
prenom,nom,age
--------------
xselect * from personnes where nom='Bruneau' : Erreur (You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xselect * from personnes where nom='Bruneau'' at line 1)

il y a eu 1 erreur(s)
xselect * from personnes where nom='Bruneau' : Erreur (You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'xselect * from personnes where nom='Bruneau'' at line 1)

Kommentare

Jeder Befehl in der Textdatei [sql.txt] wird von der Funktion exécuteRequête in Zeile 43 ausgeführt.

  • Zeile 43: Die beiden Parameter der Funktion sind die Verbindung ($connexion), auf der die Befehle SQL ausgeführt werden sollen, und der auszuführende SQL-Befehl ($sql). Die Funktion gibt ein Array mit zwei Werten zurück ($erreur, $résultat), wobei
    • $erreur eine Fehlermeldung ist, die gegebenenfalls leer ist, wenn kein Fehler aufgetreten ist
    • $résultat: das Ergebnis der Ausführung des Befehls SQL. Dieses Ergebnis ist unterschiedlich, je nachdem, ob es sich bei dem Befehl um einen Befehl vom Typ select oder um einen Befehl vom Typ insert, update oder delete handelt.
  • Zeilen 48–51: Das erste Element des Auftrags SQL wird abgerufen, um festzustellen, ob es sich um einen Auftrag select oder um einen Auftrag insert, update oder delete.
  • Zeile 55: Im Falle eines Befehls select wird dieser mit der Methode [PDO]->query("Befehl select") ausgeführt. Das zurückgegebene Ergebnis ist ein Objekt vom Typ PDOStatement.
  • Zeile 57: Bei einem INSERT-, UPDATE- oder DELETE-Befehl wird dieser mit der Methode [PDO]->exec("Befehl SQL") ausgeführt. Das zurückgegebene Ergebnis ist die Anzahl der durch den Befehl SQL geänderten Zeilen. Wenn also ein Befehl SQL delete zwei Zeilen löscht, ist das zurückgegebene Ergebnis die ganze Zahl 2. Tritt bei der Ausführung ein Fehler auf, ist das zurückgegebene Ergebnis der Boolesche Wert false. In diesem Fall liefert die Methode [PDO]->errorinfo() Informationen zum Fehler in Form eines Arrays von Werten. Das Element mit dem Index 2 dieses Arrays ist die Fehlermeldung.
  • Zeilen 58–60: Behandlung eines möglichen Fehlers bei der Operation [PDO]->exec("Befehl SQL").
  • Zeilen 65–68: Behandlung einer möglichen Ausnahme
  • Zeile 72: Die Funktion exécuterCommandes führt auf der Verbindung $connexion die Befehle SQL aus, die in der Textdatei $SQL gespeichert sind. Dies ist ein Code, den wir bereits kennengelernt haben, bis auf ein kleines Detail: Zeile 111.
  • Zeile 111: Die Funktion exécuteRequête hat ein Array zurückgegeben ($erreur, $résultat) oder $résultat ist das Ergebnis der Ausführung eines Befehls SQL. Dieses Ergebnis unterscheidet sich je nachdem, ob der Befehl SQL ein Befehl select oder ein Befehl insert, update, delete war. Die Funktion afficherInfos zeigt Informationen zu diesem Ergebnis an.
  • Zeile 122: Wenn der Befehl SQL ein Befehl select war, ist das Ergebnis vom Typ PDOStatement. Dieser Typ stellt eine Tabelle aus Zeilen und Spalten dar.
  • Zeile 125: Die Methode [PDOStatement]->getColumnCount() gibt die Anzahl der Spalten der Ergebnistabelle von select zurück.
  • Zeile 127: Die Methode [PDOStatement]->getMeta(i) gibt ein Dictionary mit Informationen zur Spalte Nr. i der Ergebnistabelle von select. zurück. In diesem Dictionary ist der Wert, der dem Schlüssel „name“ zugeordnet ist, der Name der Spalte.
  • Zeilen 127–129: Die Spaltennamen der Ergebnistabelle von select werden zu einer Zeichenkette verkettet.
  • Zeilen 141–145: Ein Objekt vom Typ PDOStatement kann mit einer Schleife vom Typ foreach durchlaufen werden. Bei jeder Iteration ist das erhaltene Element eine Zeile der Ergebnistabelle von select in Form eines Wert-Arrays, das die Werte der verschiedenen Spalten der Zeile darstellt. Alle diese Werte werden mit einer Schleife vom Typ for angezeigt.
  • Zeile 154: Das Ergebnis der Ausführung eines Befehls insert, update, delete ist die Anzahl der durch den Befehl geänderten Zeilen.
https://stahe.github.io
Dieses Tutorial, verfasst von Serge Tahé, wird der Öffentlichkeit unter den Bedingungen der Creative Commons Namensnennung – Nicht kommerziell – ShareAlike 3.0 Unported.