Skip to content

7. Gebruik van SGBD en MySql

We gaan PHP-scripts schrijven met behulp van een MySQL-database:

De SGBD MySQL is opgenomen in het pakket WampServer (zie paragraaf 2.1.1). We laten zien hoe u een database en een gebruiker MySQL aanmaakt.

  • Zodra WampServer is gestart, kan het worden beheerd via het pictogram [1] rechtsonder op de taakbalk.
  • In [2] start men de beheertool van MySQL

We maken een database [dbpersonnes] aan:

Image

Maak een gebruiker [admpersonnes] aan met het wachtwoord [nobody]:

  • in [1], de gebruikersnaam
  • in [2], de computer van SGBD waarop hij rechten krijgt
  • in [3], zijn wachtwoord
  • in [4], idem
  • in [5]: aan deze gebruiker worden geen rechten toegekend
  • in [6], deze wordt aangemaakt
  • in [7], we keren terug naar de startpagina van phpMyAdmin
  • in [8], gebruik je de link [Privileges] op deze pagina om de gegevens van de gebruiker [admpersonnes] en [9] te wijzigen.

1011

Image

  • in [10] geef je aan dat je de gebruiker [admpersonnes] rechten wilt toekennen voor de database [dbpersonnes]
  • in [11] wordt de keuze bevestigd
  • met de koppeling [12] In [Tout cocher] worden aan de gebruiker [admpersonnes] alle rechten toegekend op de database [dbpersonnes] [13]
  • we bevestigen dit in [14]

Nu hebben we:

  • een database MySQL [dbpersonnes]
  • een gebruiker [admpersonnes / nobody] die alle rechten op deze database heeft

We gaan PHP-scripts schrijven om de database te gebruiken. PHP beschikt over diverse bibliotheken voor het beheer van databases. We zullen de bibliotheek PDO (PHP Data Objects) gebruiken, die fungeert als interface tussen de code PHP en SGBD:

Dankzij de bibliotheek PDO hoeft het script PHP geen rekening te houden met de exacte aard van de gebruikte SGBD. Zo kan hierboven het SGBD MySQL worden vervangen door het SGBD Postgres met minimale gevolgen voor de code van het script PHP. Deze bibliotheek is standaard niet beschikbaar. De beschikbaarheid van de bibliotheek kan als volgt worden gecontroleerd:

  • 1: via het beheerpictogram van WampServer selecteert men de optie [PHP / PHP extensions]
  • 2: je ziet de verschillende beschikbare PDO-extensies en welke actief zijn: [PHP_pdo_mysql] voor de SGBD MySQL, [PHP_pdo_sqlite] voor de SGBD SQL Lite. Om een extensie te activeren, hoeft u er alleen maar op te klikken. De interpreter PHP wordt dan opnieuw gestart met de nieuwe extensie geactiveerd.

7.1. Verbinding maken met een MySQL-database – 1 (mysql_01)

De verbinding met een SGBD wordt tot stand gebracht door een PDO-object aan te maken. De constructor accepteert verschillende parameters:

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

De betekenis van de parameters is als volgt:

$dsn
(Data Source Name) is een tekenreeks die de aard van de SGBD en de locatie ervan op het internet aangeeft. De tekenreeks
"mysql:host=localhost" geeft aan dat het gaat om een SGBD MySQL die op de lokale server draait. Deze tekenreeks
kan andere parameters bevatten, met name de luisterpoort van de SGBD en de naam van de database waarmee
men verbinding mee wil maken: "mysql:host=localhost:port=3306:dbname=dbpersonnes".
$user
gebruikers-ID van de gebruiker die inlogt
$passwd
zijn wachtwoord
$driver_options
een array met opties voor de driver van de SGBD

Alleen de eerste parameter is verplicht. Het zo gecreëerde object zal vervolgens dienen als basis voor alle bewerkingen die worden uitgevoerd op de database waarmee verbinding is gemaakt. Als het object PDO niet kon worden aangemaakt, wordt een uitzondering van het type PDOException gegenereerd.

Hier volgt een voorbeeld van een verbinding:


<?php

// verbinding met een database MySql
// de gebruikersidentiteit is (admpersonnes,nobody)
$ID = "admpersonnes";
$PWD = "nobody";
$HOTE = "localhost";

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

Resultaten:

Connexion réussie

Opmerkingen

  • regel 11: de verbinding met een SGBD wordt tot stand gebracht door een PDO-object aan te maken. De constructor wordt hier gebruikt met de volgende parameters:
    • een tekenreeks die de aard van de SGBD en de locatie ervan op internet aangeeft. De tekenreeks "mysql:host=localhost" geeft aan dat het gaat om een SGBD MySQL die op de lokale server draait. De poort is niet opgegeven. In dat geval wordt standaard poort 3306 gebruikt. Ook de naam van de database is niet opgegeven. Er wordt dan verbinding gemaakt met de SGBD MySQL, waarbij de selectie van een specifieke database later plaatsvindt.
    • een gebruikersnaam
    • zijn wachtwoord
  • regel 14: de verbinding wordt verbroken door het aanvankelijk aangemaakte object PDO te verwijderen.
  • regel 15: de verbinding met een SGBD kan mislukken. In dat geval wordt een uitzondering van het type PDOException gegenereerd.

7.2. Aanmaken van een tabel MySQL (mysql_02)


<?php

// verbinding met de database MySql
// de gebruikersidentiteit
$ID = "admpersonnes";
$PWD = "nobody";
// identiteit van de database
$DSN = "mysql:host=localhost;dbname=dbpersonnes";

// verbinding
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;
}

// verwijdering van de tabel ‘personen’ indien deze bestaat
$requête = "drop table personnes";
$erreur = exécuteRequête($connexion, $requête);
//is er een fout opgetreden?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// de tabel 'personen' aanmaken
$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);
//Is er een fout opgetreden?
if ($erreur)
  print "$requête : Erreur ($erreur)\n";
else
  print "$requête: Exécution réussie\n";
// verbinding verbreken en afsluiten
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // verbinding maken ($login,$pwd) met de database $dsn
  // geeft de verbindings-ID en een foutcode weer
  try {
    // verbinding
    $dbh = new PDO($dsn, $login, $pwd);
    // terugkeer zonder fout
    return array("", $dbh);
  } catch (PDOException $e) {
    // terugkeer met fout
    return array($e->getMessage(), null);
  }
}

// ---------------------------------------------------------------------------------
function déconnecte($connexion) {
  // sluit de verbinding die wordt geïdentificeerd door $connexion
  $connexion = null;
}

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // voert de aanvraag $sql uit op de verbinding $connexion
  try {
    $connexion->exec($sql);
    // keert zonder fout terug
    return "";
  } catch (PDOException $e) {
    // keert terug met een fout
    return $e->getMessage();
  }
}

Resultaten:

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 is de aanwezigheid van de tabel te zien:

 

Opmerkingen

  • regels 38-50: de functie connecte maakt een verbinding met een SGBD. Deze functie retourneert een array ($erreur, $connexion), waarbij $connexion de aangemaakte verbinding is of null als deze niet kon worden aangemaakt. In het laatste geval is $erreur een foutmelding.
  • regels 53-56: de functie déconnecte sluit een verbinding af
  • regel 59: de functie exécuteRequête maakt het mogelijk om een opdracht SQL op een verbinding uit te voeren. De verbinding is een object PDO. De methode die wordt gebruikt om een opdracht SQL uit te voeren op een object PDO is de methode exec (regel 63). Het uitvoeren van de query kan een PDOException activeren. Daarom wordt ook deze verwerkt. De functie retourneert een foutmelding in geval van een fout, anders een lege tekenreeks.

7.3. Het vullen van de tabel ‘personen’ (mysql_03)

Het volgende script voert SQL-opdrachten uit die zijn opgenomen in het volgende tekstbestand [creation.txt]:

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

// verbinding met de database MySql
// de identiteit van de gebruiker
$ID = "admpersonnes";
$PWD = "nobody";
// identiteit van de database
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// identiteit van het tekstbestand met uit te voeren SQL-opdrachten
$TEXTE = "creation.txt";

// verbinding
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;
}

// aanmaken en vullen van de tabel
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//weergave van het aantal fouten
print "il y a eu $erreurs[0] erreurs\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";

// verbinding verbreken en afsluiten
déconnecte($connexion);
exit;

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

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

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // voert de query $sql uit op de verbinding $connexion
  // geeft 1 foutmelding terug bij een fout, anders de lege tekenreeks
  ...
}

// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // gebruikt de verbinding $connexion
  // voert de SQL-opdrachten uit die in het tekstbestand $SQL staan
  // dit bestand is een opdrachtbestand SQL dat per regel moet worden uitgevoerd
  // als $suivi=1, dan wordt bij elke uitvoering van een opdracht SQL een melding weergegeven die aangeeft of deze is geslaagd of mislukt
  // als $arrêt=1, stopt de functie bij de eerste fout die wordt aangetroffen; anders voert ze alle SQL-opdrachten uit
  // de functie retourneert een array (aantal fouten, fout1, fout2, ...)
  
  // er wordt gecontroleerd of het bestand $SQL aanwezig is
  if (! file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");

  // de query's SQL die in $SQL staan, worden uitgevoerd
  // deze worden in een array geplaatst
  $requêtes = file($SQL);
  // ze worden uitgevoerd – in eerste instantie geen fouten
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //is er een leeg verzoek?
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // uitvoering van de query $i
    $erreur = exécuteRequête($connexion, $requêtes[$i]);
    //is er een fout opgetreden?
    if ($erreur) {
      // nog een fout
      $erreurs[0]++;
      // foutmelding
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // scherm volgen of niet?
      if ($suivi)
        print "$msg\n";
      // stoppen we?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi)
      print "$requêtes[$i] : Exécution réussie\n";
  }//voor
  // terug
  return $erreurs;
}

De schermresultaten:

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

De aangebrachte invoegingen zijn zichtbaar met PhpMyAdmin:

 

Opmerkingen

De nieuwigheid zit in de functie exécuterCommandes in de regels 48-90. Deze functie voert op de verbinding $connexion de opdrachten SQL uit die zijn aangetroffen in het tekstbestand met de naam $SQL. De functie retourneert een array met fouten ($nbErreurs, $msg1, $msg2, …) waarbij $nbErreurs het aantal fouten is, $msgi de foutmelding nr. i.. Als er geen fouten zijn, is de geretourneerde tabel de tabel array(0).

7.4. Uitvoering van willekeurige SQL-query's (mysql_04)

Het volgende script toont de uitvoering van de opdrachten SQL uit het volgende tekstbestand [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'

Onder deze commando's SQL bevinden zich het SELECT-commando, dat resultaten uit de database ophaalt, de INSERT-, UPDATE- en DELETE-commando's, die de database wijzigen zonder resultaten op te halen, en ten slotte foutieve commando's zoals het laatste (xselect).


<?php

// verbinding met de database MySql
// de identiteit van de gebruiker
$ID = "admpersonnes";
$PWD = "nobody";
// database-identiteit
$DSN = "mysql:host=localhost;dbname=dbpersonnes";
// identiteit van het tekstbestand met uit te voeren SQL-opdrachten
$TEXTE = "sql.txt";

// verbinding
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;
}

// uitvoering van de opdrachten SQL
$erreurs = exécuterCommandes($connexion, $TEXTE, 1, 0);
//weergave van het aantal fouten
print "il y a eu $erreurs[0] erreur(s)\n";
for ($i = 1; $i < count($erreurs); $i++)
  print "$erreurs[$i]\n";

// verbinding verbreken en afsluiten
déconnecte($connexion);
exit;

// ---------------------------------------------------------------------------------
function connecte($dsn, $login, $pwd) {
  // maakt verbinding ($login,$pwd) met de database $dsn
  // geeft de ID van de verbinding en een foutmelding weer
  ...
}

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

// ---------------------------------------------------------------------------------
function exécuteRequête($connexion, $sql) {
  // voert de query $sql uit op de verbinding $connexion
  // geeft een array met 2 elementen terug ($erreur,$résultat)
  
  // er wordt bepaald of het een select is of niet
  $commande = "";
  if (preg_match("/^\s*(\S+)/", $sql, $champs)) {
    $commande = $champs[0];
  }
  // de opdracht wordt uitgevoerd
  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);
      }
    }
    // terugkeer zonder fout
    return array("", $res);
  } catch (PDOException $e) {
    // terugkeer met fout
    return array($e->getMessage(), null);
  }
}

// ---------------------------------------------------------------------------------
function exécuterCommandes($connexion, $SQL, $suivi=0, $arrêt=1) {
  // gebruikt de verbinding $connexion
  // voert de opdrachten SQL uit die in het tekstbestand $SQL staan
  // dit bestand is een opdrachtbestand SQL dat per regel moet worden uitgevoerd
  // als $suivi=1, dan wordt bij elke uitvoering van een opdracht SQL een melding weergegeven die aangeeft of deze is geslaagd of mislukt
  // als $arrêt=1, stopt de functie bij de eerste fout die wordt aangetroffen; anders voert ze alle SQL-opdrachten uit
  // de functie retourneert een array (aantal fouten, fout1, fout2, ...)
  // er wordt gecontroleerd of het bestand $SQL aanwezig is
  if (!file_exists($SQL))
    return array(1, "Le fichier $SQL n'existe pas");

  // de query's SQL die in $TEXTE staan, worden uitgevoerd
  // deze worden in een array geplaatst
  $requêtes = file($SQL);
  // we voeren ze uit – in eerste instantie geen fouten
  $erreurs = array(0);
  for ($i = 0; $i < count($requêtes); $i++) {
    //is er sprake van een lege query?
    if (preg_match("/^\s*$/", $requêtes[$i]))
      continue;
    // het verzoek wordt uitgevoerd $i
    list($erreur, $res) = exécuteRequête($connexion, $requêtes[$i]);
    //is er een fout opgetreden?
    if ($erreur) {
      // nog een fout
      $erreurs[0]++;
      // foutmelding
      $msg = "$requêtes[$i] : Erreur ($erreur)\n";
      $erreurs[] = $msg;
      // scherm volgen of niet?
      if ($suivi)
        print "$msg\n";
      // stoppen we?
      if ($arrêt)
        return $erreurs;
    } else
    if ($suivi) {
      print "$requêtes[$i] : Exécution réussie\n";
      // informatie over het resultaat van de uitgevoerde aanvraag
      afficherInfos($res);
    }
  }//voor
  // terug
  return $erreurs;
}

// ---------------------------------------------------------------------------------
function afficherInfos($résultat) {
  // geeft het resultaat $résultat van een SQL-query weer
  // Was dit een SELECT-query?
  if ($résultat instanceof PDOStatement) {
    // de veldnamen worden weergegeven
    $titre = "";
    $nbColonnes = $résultat->columnCount();
    for ($i = 0; $i < $nbColonnes; $i++) {
      $infos = $résultat->getColumnMeta($i);
      $titre.=$infos['name'] . ",";
    }
    // het laatste teken wordt verwijderd,
    $titre = substr($titre, 0, strlen($titre) - 1);
    // de lijst met velden wordt weergegeven
    print "$titre\n";
    // scheidingslijn
    $séparateurs = "";
    for ($i = 0; $i < strlen($titre); $i++) {
      $séparateurs.="-";
    }
    print "$séparateurs\n";
    // gegevens
    foreach ($résultat as $ligne) {
      $data = "";
      for ($i = 0; $i < $nbColonnes; $i++) {
        $data.=$ligne[$i] . ",";
      }

      // het laatste teken wordt verwijderd,
      $data = substr($data, 0, strlen($data) - 1);
      // we geven weer
      print "$data\n";
    }
  } else {
    // dit was geen selectie
    print " $résultat lignes(s) a (ont) été modifiée(s)\n";
  }
}

De schermresultaten:

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)

Opmerkingen

Elk commando in het tekstbestand [sql.txt] wordt uitgevoerd door de functie exécuteRequête op regel 43.

  • regel 43: de twee parameters van de functie zijn de verbinding ($connexion) waarop de opdrachten SQL moeten worden uitgevoerd en de uit te voeren SQL-opdracht ($sql). De functie retourneert een array met twee waarden ($erreur,$résultat), waarbij
    • $erreur een foutmelding is, die eventueel leeg is als er geen fout is opgetreden
    • $résultat: het resultaat van de uitvoering van de opdracht SQL. Dit resultaat verschilt naargelang de opdracht een opdracht select is of een opdracht insert, update, delete.
  • regels 48-51: we halen het eerste element van de bestelling SQL op om te bepalen of het gaat om een bestelling select of om een bestelling insert, update, delete.
  • regel 55: in het geval van een opdracht select wordt deze uitgevoerd met de methode [PDO]->query("select-opdracht"). Het geretourneerde resultaat is een object van het type PDOStatement.
  • regel 57: in het geval van een insert-, update- of delete-opdracht wordt deze uitgevoerd met de methode [PDO]->exec("opdracht SQL"). Het geretourneerde resultaat is het aantal rijen dat door de opdracht SQL is gewijzigd. Als een opdracht SQL delete dus twee regels verwijdert, is het geretourneerde resultaat het gehele getal 2. Als er een fout optreedt tijdens de uitvoering, is het geretourneerde resultaat de booleaanse waarde false. In dat geval geeft de methode [PDO]->errorinfo() informatie over de fout in de vorm van een array met waarden. Het element met index 2 van deze array is de foutmelding.
  • regels 58-60: afhandeling van een eventuele fout bij de bewerking [PDO]->exec("opdracht SQL").
  • regels 65-68: afhandeling van een eventuele uitzondering
  • regel 72: de functie exécuterCommandes voert op de verbinding $connexion de opdrachten SQL uit die zijn opgeslagen in het tekstbestand $SQL. Dit is code die we al eens zijn tegengekomen, op één detail na: regel 111.
  • regel 111: de functie exécuteRequête heeft een array geretourneerd ($erreur,$résultat) of $résultat is het resultaat van de uitvoering van een opdracht SQL. Dit resultaat verschilt naargelang de opdracht SQL een opdracht select was of een opdracht insert, update, delete. De functie afficherInfos geeft informatie weer over dit resultaat.
  • regel 122: als de opdracht SQL een opdracht select was, is het resultaat van het type PDOStatement. Dit type vertegenwoordigt een tabel die bestaat uit rijen en kolommen.
  • regel 125: de methode [PDOStatement]->getColumnCount() retourneert het aantal kolommen van de resultatentabel van select
  • regel 127: de methode [PDOStatement]->getMeta(i) retourneert een woordenboek met informatie over kolom nr. i van de resultatentabel van select.. In dit woordenboek is de waarde die bij de sleutel 'name' hoort de naam van de kolom.
  • regels 127-129: de kolomnamen van de resultatentabel van select worden samengevoegd tot een tekenreeks.
  • regels 141-145: een object van het type PDOStatement kan worden doorlopen met een foreach-lus. Bij elke iteratie is het verkregen element een rij uit de resultatentabel van select in de vorm van een array met waarden die de waarden van de verschillende kolommen van de rij vertegenwoordigen. Al deze waarden worden weergegeven met een for-lus.
  • regel 154: het resultaat van de uitvoering van een opdracht insert, update, delete is het aantal rijen dat door de opdracht is gewijzigd.
https://stahe.github.io
Deze cursus-tutorial, geschreven door Serge Tahé, wordt ter beschikking gesteld aan het publiek volgens de voorwaarden van de Creative Commons Naamsvermelding – Geen commercieel gebruik – Gedeeld onder dezelfde voorwaarden 3.0 ongewijzigd.