Skip to content

7. Verwendung des MySQL-DBMS

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

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

  • Nach dem Start kann WampServer über ein Symbol [1] unten rechts in der Taskleiste verwaltet werden.
  • Starten Sie unter [2] das MySQL-Verwaltungstool

Erstellen Sie eine Datenbank [dbpersonnes]:

Image

Erstellen Sie einen Benutzer [admpersonnes] mit dem Passwort [nobody]:

  • In [1] lautet der Benutzername
  • In [2] der DBMS-Server, auf dem Sie Berechtigungen erteilen
  • in [3] das Passwort
  • in [4], wie oben
  • in [5] erteilen wir diesem Benutzer keine Rechte
  • in [6], erstellen Sie den Benutzer
  • in [7] kehren Sie zur Startseite von phpMyAdmin zurück
  • in [8], verwenden Sie den Link [Berechtigungen] auf dieser Seite, um die Berechtigungen für den Benutzer [admpersonnes] zu ändern [9].

Image

  • Geben Sie in [10] an, dass Sie dem Benutzer [admpersonnes] Rechte für die Datenbank [dbpersonnes] gewähren möchten
  • Bestätigen Sie in [11] die Auswahl
  • über den Link [12] [Alle auswählen] und erteilen Sie dem Benutzer [admpersonnes] alle Rechte für die Datenbank [dbpersonnes] [13]
  • Bestätigen Sie dies unter [14]

Nun haben wir:

  • eine MySQL-Datenbank [dbpersonnes]
  • einen Benutzer [admpersonnes / nobody], der vollen Zugriff auf diese Datenbank hat

Wir werden PHP-Skripte schreiben, um mit der Datenbank zu arbeiten. PHP verfügt über verschiedene Bibliotheken zur Verwaltung von Datenbanken. Wir werden die PDO-Bibliothek (PHP Data Objects) verwenden, die als Schnittstelle zwischen dem PHP-Code und dem DBMS fungiert:

Die PDO-Bibliothek ermöglicht es dem PHP-Skript, sich von der genauen Beschaffenheit des verwendeten DBMS zu abstrahieren. So kann, wie oben gezeigt, das MySQL-DBMS durch das Postgres-DBMS ersetzt werden, ohne dass dies nennenswerte Auswirkungen auf den PHP-Skriptcode hat. Diese Bibliothek ist standardmäßig nicht verfügbar. Sie können ihre Verfügbarkeit unter wie folgt überprüfen:

  • 1: Wählen Sie über das WampServer-Verwaltungssymbol die Option [PHP / PHP-Erweiterungen]
  • 2: Sie sehen die verschiedenen verfügbaren PDO-Erweiterungen und diejenigen, die aktiv sind: [PHP_pdo_mysql] für das MySQL-DBMS, [PHP_pdo_sqlite] für das SQLite-DBMS. Um eine Erweiterung zu aktivieren, klicken Sie einfach darauf. Der PHP-Interpreter wird dann mit der neuen Erweiterung neu gestartet.

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

Die Verbindung zu einem DBMS wird durch die Erstellung eines PDO-Objekts hergestellt. 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 den Typ des DBMS und dessen Standort im Internet angibt. Die Zeichenkette
„mysql:host=localhost“ gibt an, dass es sich um ein MySQL-DBMS handelt, das auf dem lokalen Server läuft. Diese Zeichenfolge
kann weitere Parameter enthalten, wie den Listening-Port des DBMS und den Namen der Datenbank, mit der
, mit der Sie eine Verbindung herstellen möchten: „mysql:host=localhost:port=3306:dbname=dbpersonnes“.
$user
Benutzername des sich anmeldenden Benutzers
$passwd
sein Passwort
$driver_options
ein Array mit Optionen für den DBMS-Treiber

Nur der erste Parameter ist erforderlich. Das auf diese Weise erstellte Objekt dient dann als Schnittstelle für alle Operationen, die an der Datenbank durchgeführt werden, mit der Sie verbunden sind. Wenn das PDO-Objekt nicht erstellt werden konnte, wird eine PDOException ausgelöst.

Hier ist ein Beispiel für eine Verbindung:


<?php
 
// connection to a MySql database
// user identity is (admpersonnes,nobody)
$ID = "admpersonnes";
$PWD = "nobody";
$HOTE = "localhost";
 
try {
  // connection
  $dbh = new PDO("mysql:host=$HOTE", $ID, $PWD);
  print "Connexion réussie\n";
  // closure
  $dbh = null;
} catch (PDOException $e) {
  print "Erreur : " . $e->getMessage() . "\n";
  exit();
}

Ergebnisse:

Connexion réussie

Kommentare

  • Zeile 11: Die Verbindung zu einem DBMS wird durch die Erstellung eines PDO-Objekts hergestellt. Der Konstruktor wird hier mit den folgenden Parametern verwendet:
    • eine Zeichenkette, die den DBMS-Typ und dessen Standort im Internet angibt. Die Zeichenkette „mysql:host=localhost“ gibt an, dass es sich um ein MySQL-DBMS handelt, das auf dem lokalen Server läuft. Der Port wurde nicht angegeben. Daher wird standardmäßig Port 3306 verwendet. Der Datenbankname ist ebenfalls nicht angegeben. Es wird dann eine Verbindung zum MySQL-DBMS hergestellt, wobei die Auswahl einer bestimmten Datenbank später erfolgt.
    • eine Benutzer-ID
    • sein Passwort
  • Zeile 14: Die Verbindung wird geschlossen, indem das ursprünglich erstellte PDO-Objekt zerstört wird.
  • Zeile 15: Die Verbindung zu einem DBMS kann fehlschlagen. In diesem Fall wird eine PDOException ausgelöst.

7.2. Erstellen einer MySQL-Tabelle (mysql_02)


<?php
 
// connection to the MySql database
// user identity
$ID = "admpersonnes";
$PWD = "nobody";
// base identity
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
 
// connection
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;
}
 
// delete the people table if it exists
$requête = "drop table personnes";
$erreur = exécuteRequête($connexion, $requête);
//was there a mistake?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// create people table
$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);
//was there a mistake?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// disconnect and exit
déconnecte($connexion);
exit;
 
// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // connects ($login,$pwd) to base $dsn
  // returns the connection id and an error code
  try {
    // connection
    $dbh = new PDO($dsn, $login, $pwd);
    // error-free return
    return array("", $dbh);
  } catch (PDOException $e) {
    // return with error
    return array($e->getMessage(), null);
  }
}
 
// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  // closes the connection identified by $connexion
  $connexion = null;
}
 
// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // executes the $sql request on the $connexion connection
  try {
    $connexion->exec($sql);
    // error-free return
    return "";
  } catch (PDOException $e) {
    // return with error
    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 können Sie sehen, dass die Tabelle existiert:

 

Kommentare

  • Zeilen 38–50: Die Funktion connect stellt eine Verbindung zu einem Datenbankmanagementsystem (DBMS) her. Sie gibt ein Array ($error, $connection*) zurück, wobei $connection* die hergestellte Verbindung ist oder null, falls die Verbindung nicht hergestellt werden konnte. Im letzteren Fall enthält $error eine Fehlermeldung.
  • Zeilen 53–56: Die Funktion *disconnect* schließt eine Verbindung
  • Zeile 59: Mit der Funktion *executeQuery* können Sie eine SQL-Anweisung über eine Verbindung ausführen. Die Verbindung ist ein PDO-Objekt. Die Methode zum Ausführen einer SQL-Anweisung auf einem PDO-Objekt ist die Methode **exec** (Zeile 63). Die Ausführung der Abfrage kann eine PDOException auslösen. Daher wird dies abgefangen. Die Funktion gibt eine Fehlermeldung zurück, wenn ein Fehler auftritt, andernfalls eine leere Zeichenkette.

7.3. Befüllen der Tabelle „people“ (mysql_03)

Das folgende Skript führt SQL-Anweisungen 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
 
// connection to the MySql database
// user identity
$ID = "admpersonnes";
$PWD = "nobody";
// base identity
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// identity of the SQL command text file to be executed
$TEXTE = "creation.txt";
 
// connection
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;
}
 
// table creation and filling
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//display number of errors
print "il y a eu $erreurs[0] erreurs\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";
 
// disconnect and exit
déconnecte($connexion);
exit;
 
// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
...
}
 
// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
 ...
}
 
// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // executes the $sql request on the $connexion connection
  // returns 1 error msg if error, empty string otherwise
  ...
}
 
// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // uses the $connexion connection
  // executes the SQL commands contained in the $SQL text file
  // this is a file of SQL commands to be executed one per line
  // if $suivi=1 then each execution of a SQL order is displayed as a success or failure
  // if $arrêt=1, the function stops on the 1st error encountered, otherwise it executes all sql commands
  // the function returns an array (nb of errors, error1, error2, ...)
 
  // check for the presence of the $SQL file
  if (! file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");
 
  // execution of SQL queries contained in $SQL
  // we put them in a table
  $requêtes = file($SQL);
  // we run them - initially no errors
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //do we have an empty query
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // execute query $i
    $erreur = exécuteRequête($connexion, $requêtes[$i]);
    //was there a mistake?
    if ($erreur) {
      // one more mistake
      $erreurs[0]++;
      // error msg
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // screen tracking or not?
      if ($suivi)
        print "$msg\n";
      // shall we stop?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi)
      print "$requêtes[$i] : Exécution réussie\n";
  }//for
  // return
  return $erreurs;
}

Anzeige der 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
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 in phpMyAdmin sichtbar:

 

Kommentare

Die neue Funktion ist die Funktion executeCommands in den Zeilen 48–90. Diese Funktion führt die SQL-Befehle aus, die in der Textdatei namens $SQL auf der Verbindung $connection enthalten sind. Sie gibt ein Fehlerarray zurück ($nbErrors, $msg1, $msg2, …), wobei $nbErrors die Anzahl der Fehler ist und $msg1 die Fehlermeldung Nummer i. Wenn keine Fehler vorliegen, ist das zurückgegebene Array array(0).

7.4. Ausführen beliebiger SQL-Abfragen (mysql_04)

Das folgende Skript demonstriert die Ausführung von SQL-Befehlen 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 SQL-Anweisungen gibt es die SELECT-Anweisung, die Ergebnisse aus der Datenbank zurückgibt; die INSERT-, UPDATE- und DELETE-Anweisungen, die die Datenbank ändern, ohne Ergebnisse zurückzugeben; und schließlich ungültige Anweisungen wie die letzte (xselect).


<?php
 
// connection to the MySql database
// user identity
$ID = "admpersonnes";
$PWD = "nobody";
// base identity
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// identity of the SQL command text file to be executed
$TEXTE = "sql.txt";
 
// connection
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;
}
 
// order execution SQL
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//display number of errors
print "il y a eu $erreurs[0] erreur(s)\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";
 
// disconnect and exit
déconnecte($connexion);
exit;
 
// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // connects ($login,$pwd) to base $dsn
  // returns the connection id and an error msg
  ...
}
 
// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  ...
}
 
// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // executes the $sql request on the $connexion connection
  // returns an array of 2 elements ($erreur,$résultat)
 
  // determine whether it's a select or not
  $commande = "";
  if (preg_match("/^\s*(\S+)/", $sql, $champs)) {
    $commande = $champs[0];
  }
  // order processing
  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);
      }
    }
    // error-free return
    return array("", $res);
  } catch (PDOException $e) {
    // return with error
    return array($e->getMessage(), null);
  }
}
 
// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // uses the $connexion connection
  // executes the SQL commands contained in the $SQL text file
  // this is a file of SQL commands to be executed one per line
  // if $suivi=1 then each execution of a SQL order is displayed as a success or failure
  // if $arrêt=1, the function stops on the 1st error encountered, otherwise it executes all sql commands
  // the function returns an array (nb of errors, error1, error2, ...)
  // check for the presence of the $SQL file
  if (!file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");
 
  // execution of SQL queries contained in $TEXTE
  // we put them in a table
  $requêtes = file($SQL);
  // we run them - initially no errors
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //do we have an empty query
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // execute query $i
    list($erreur, $res) = exécuteRequête($connexion, $requêtes[$i]);
    //was there a mistake?
    if ($erreur) {
      // one more mistake
      $erreurs[0]++;
      // error msg
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // screen tracking or not?
      if ($suivi)
        print "$msg\n";
      // shall we stop?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi) {
      print "$requêtes[$i] : Exécution réussie\n";
      // information on the result of the query
      afficherInfos($res);
    }
  }//for
  // return
  return $erreurs;
}
 
// ---------------------------------------------------------------------------------
function afficherInfos($résultat) {
  // displays the $résultat result of an sql query
  // was it a select?
  if ($résultat instanceof PDOStatement) {
    // displays field names
    $titre = "";
    $nbColonnes = $résultat->columnCount();
    for ($i = 0; $i < $nbColonnes; $i++) {
      $infos = $résultat->getColumnMeta($i);
      $titre.=$infos['name'] . ",";
    }
    // remove the last character ,
    $titre = substr($titre, 0, strlen($titre) - 1);
    // displays the list of fields
    print "$titre\n";
    // dividing line
    $séparateurs = "";
    for ($i = 0; $i < strlen($titre); $i++) {
      $séparateurs.="-";
    }
    print "$séparateurs\n";
    // data
    foreach ($résultat as $ligne) {
      $data = "";
      for ($i = 0; $i < $nbColonnes; $i++) {
        $data.=$ligne[$i] . ",";
      }
 
      // remove the last character ,
      $data = substr($data, 0, strlen($data) - 1);
      // on affiche
      print "$data\n";
    }
  } else {
    // it wasn't a select
    print " $résultat lignes(s) a (ont) été modifiée(s)\n";
  }
}

Anzeige der Ergebnisse:

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), über die die SQL-Befehle ausgeführt werden sollen, und der auszuführende SQL-Befehl ($sql). Die Funktion gibt ein Array mit zwei Werten ($erreur, $résultat) zurück, wobei
    • $error eine Fehlermeldung ist, die leer sein kann, wenn kein Fehler aufgetreten ist
    • $result: das durch die Ausführung der SQL-Anweisung zurückgegebene Ergebnis. Dieses Ergebnis variiert je nachdem, ob es sich bei der Anweisung um eine SELECT-Anweisung oder um eine INSERT-, UPDATE- oder DELETE-Anweisung handelt.
  • Zeilen 48–51: Wir rufen das erste Element der SQL-Anweisung ab, um festzustellen, ob es sich um eine SELECT-Anweisung oder eine INSERT-, UPDATE- oder DELETE-Anweisung handelt.
  • Zeile 55: Im Falle einer SELECT-Anweisung wird diese mit der Methode [PDO]->query("SELECT-Anweisung") ausgeführt. Das zurückgegebene Ergebnis ist ein PDOStatement-Objekt.
  • Zeile 57: Bei einer INSERT-, UPDATE- oder DELETE-Anweisung wird diese mit der Methode [PDO]->exec("SQL-Anweisung") ausgeführt. Als Ergebnis wird die Anzahl der durch die SQL-Anweisung geänderten Zeilen zurückgegeben. Wenn also eine DELETE-SQL-Anweisung zwei Zeilen löscht, ist das zurückgegebene Ergebnis die Ganzzahl 2. Tritt während 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 an Index 2 dieses Arrays ist die Fehlermeldung.
  • Zeilen 58–60: Behandlung von Fehlern aus der Operation [PDO]->exec("SQL-Anweisung").
  • Zeilen 65–68: Behandlung von Ausnahmen
  • Zeile 72: Die Funktion executeCommands führt die in der Textdatei *$SQL* gespeicherten SQL-Befehle auf der Verbindung *$connection* aus. Dies ist Code, den wir bereits gesehen haben, mit einem kleinen Unterschied: Zeile 111.
  • Zeile 111: Die Funktion executeQuery gab ein Array (*$error*, *$result*) zurück, wobei $result* das Ergebnis der Ausführung eines SQL-Befehls ist. Dieses Ergebnis variiert je nachdem, ob es sich bei dem SQL-Befehl um eine SELECT*-Anweisung oder um eine INSERT*-, UPDATE*- oder DELETE*-Anweisung handelte. Die Funktion displayInfo* zeigt Informationen zu diesem Ergebnis an.
  • Zeile 122: Wenn es sich bei der SQL-Anweisung um eine SELECT-Anweisung handelte, ist das Ergebnis vom Typ PDOStatement. Dieser Typ repräsentiert eine Tabelle, die aus Zeilen und Spalten besteht.
  • Zeile 125: Die Methode [PDOStatement]->getColumnCount() gibt die Anzahl der Spalten in der aus der SELECT-Anweisung resultierenden Tabelle zurück
  • Zeile 127: Die Methode [PDOStatement]->getMeta(i) gibt ein Wörterbuch mit Informationen über Spalte i der SELECT-Ergebnistabelle zurück. In diesem Wörterbuch ist der Wert, der dem Schlüssel „name“ zugeordnet ist, der Spaltenname.
  • Zeilen 127–129: Die Spaltennamen aus der SELECT-Ergebnistabelle werden zu einer Zeichenkette verkettet.
  • Zeilen 141–145: Ein PDOStatement-Objekt kann mit einer foreach-Schleife durchlaufen werden. Bei jeder Iteration ist das zurückgegebene Element eine Zeile aus der SELECT-Ergebnistabelle in Form eines Arrays von Werten, die die Werte der verschiedenen Spalten der Zeile darstellen. Wir zeigen alle diese Werte mit einer for-Schleife an.
  • Zeile 154: Das Ergebnis der Ausführung einer INSERT-, UPDATE- oder DELETE-Anweisung ist die Anzahl der durch die Anweisung 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.