2 Verbindungsaufbau und erste Abfragen

2.1 MySQLi und PDO im Vergleich

PHP-Programme können über verschiedene Schnittstellen auf relationale Datenbanken zugreifen. Für MySQL beziehungsweise MariaDB werden vor allem zwei PHP-Erweiterungen verwendet:

• MySQLi
• PDO

Beide Erweiterungen ermöglichen es, eine Datenbankverbindung aufzubauen, SQL-Anweisungen auszuführen und die Ergebnisse zu verarbeiten. Außerdem unterstützen beide Prepared Statements und Transaktionen.

MySQLi ist speziell für MySQL und die weitgehend kompatible Datenbank MariaDB vorgesehen. PDO stellt dagegen eine einheitliche Programmierschnittstelle für unterschiedliche Datenbanksysteme bereit.

Die Grundideen beider Techniken beschreibt die folgende Tabelle.

PDO

PDO stellt eine einheitliche Schnittstelle für den Zugriff auf unterschiedliche Datenbanksysteme bereit. Methoden wie prepare(), execute() und fetch() werden unabhängig vom eingesetzten Datenbanksystem auf ähnliche Weise verwendet.

PDO vereinheitlicht jedoch nicht die unterschiedlichen SQL-Dialekte. Wird das Datenbanksystem gewechselt, müssen daher gegebenenfalls auch SQL-Anweisungen angepasst werden.

Der Verbindungsaufbau für die Datenbank KuReAr kann folgendermaßen erfolgen:

$dsn = "mysql:host=localhost;dbname=KuReAr;charset=utf8mb4";

$pdo = new PDO($dsn,"root","",[PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);

Mit $dsn (Data Source Name) entsteht ein String, der Treiber, Datenbank und den verwendeten Zeichensatz angibt.

• $pdo verweist dank new PDO() auf ein Objekt der Klasse PDO.
• mysql: bedeutet, dass der SQL-Treiber innerhalb von PDO verwendet werden soll.
• host=localhost zeigt an, dass der Datenbankserver lokal läuft.
• dbname=KuReAr gibt die zu bearbeitende Datenbank an.
• charset=utf8mb4 gibt den Zeichensatz an.
• root gibt den MySQL-Datenbankbenutzer an.
• "" bedeutet: kein Passwort
• [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION] setzt den Fehlermodus so, dass PDO bei Problemen Exceptions wirft. Ohne diese Option würde PDO oft nur Fehlercodes liefern, die man manuell prüfen müsste. Siehe Anhang.

MySQLi

MySQLi ist eine spezielle Erweiterung nur für MySQL-Datenbanken. Der Verbindungsaufbau geschieht mit folgenden Befehlen (am Beispiel der Datenbank KuReAr):

$con = new mysqli("host", "root", "Passwort", "DB-Bezeichnung");

if ($con->connect_error) {

    die("Verbindungsfehler: " . $con->connect_error);

}

• $con ist eine PHP-Variable. Sie speichert ein Objekt der Klasse mysqli, das die Verbindung vom jeweiligen Programm zur Datenbank herstellt. Ein Objekt $con verfügt unter anderem über die Eigenschaft $con->connect_error und über Methoden wie $con->query(), $con->execute_query(), $con->close(), $con->prepare. Übrigens: "con" kommt von "connection". Die Bezeichnung dieser Variablen kann aber frei gewählt werden.
• mysqli: Die entsprechende Klasse von mySQL für den Verbindungsaufbau.
• new mysqli(): Instantiierung eines mysqli-Objekts, das den jeweiligen Verbindungsaufbau realisiert.
• Host: Gibt den MySQL-Server an. Beim Testen wird hier oft localhost vorkommen. Dies bedeutet, dass der Server auf demselben Rechner (wie die sonstigen Programme) läuft. Alternativ kann hier z.B. eine IP-Adresse stehen.
• root: MySQL-Benutzerkonto
• Passwort: für das Benutzerkonto
• DB-Bezeichnung: Bezeichnung der Datenbank.

Die folgende If-Anweisung sichert gegen ein Scheitern des Verbindungsaufbaus ab:

• $con->connect_error prüft, ob beim Verbindungsaufbau ein Fehler aufgetreten ist. Falls es so ist, startet die Funktion "die()" ("sterbe").
• die() oder exit() beendet das Skript sofort und gibt eine Fehlermeldung aus.

MySQLi unterstützt Prepared Statements, Stored Procedures und erlaubt mehrere gleichzeitige Abfragen. Außerdem kann es auch prozedural verwendet werden:

$con = mysqli_connect("localhost", "root", "", "KuReAr");

Dies ist möglich, weil PHP beide Programmierstile zulässt, den prozeduralen und den objektorientierten und weil dies mit der Klasse MySQLi auch umgesetzt wurde.

2.2 KundenAbfragenMySQLi_1.php

2.2.1 Merkmale des Programms

• Start durch Browser-Befehl
• Einfache Abfrage
• Direkter Zugriff auf die Datenbank.
• Verwendete Klasse für Verbindungsaufbau: mysqli
• HTML-Ausgabe des Ergebnisses

Das erste Programm führt eine einfache, unveränderliche SQL-Abfrage aus. Da die SQL-Anweisung keine Benutzereingaben oder anderen veränderlichen Werte enthält, ist hierfür kein Prepared Statement erforderlich. Im nachfolgenden Beispiel wird die Abfrage um einen Suchwert ergänzt und deshalb als Prepared Statement ausgeführt.

2.2.2 Das Programm

<!doctype html>

<html lang="de">

<head>

  <meta charset="utf-8">

  <title>Relation Kunden</title>

  <link rel="stylesheet" type="text/css" href="mySQL_1.css">

</head>

<body>

  <p class="text-red">

    Relation Kunden - mit Spaltenüberschriften:

  </p>

  <table border="1">

    <caption class="text-bold">Relation Kunden</caption>

    <thead>

      <tr>

      <th>Kundennummer</th>

      <th>Kundenname</th>

      <th>Kundenvorname</th>

      </tr>

    </thead>

    <tbody>

<?php

/*

Verbindung zur Datenbank aufbauen.

mysqli steht für MySQL Improved. Mit new mysqli()wird ein Objekt der Klasse mysqli erzeugt. Die Variable $con verweist auf dieses Objekt und ermöglicht den Zugriff auf seine Eigenschaften und Methoden.

*/

$con = new mysqli("localhost","root","","KuReAr");

/*

Prüfen, ob beim Aufbau der Datenbankverbindung ein Fehler aufgetreten ist. Falls ein Fehler auftritt, beendet die(), nach der Ausgabe der Meldung, sofort die weitere Ausführung des Programms.

*/

    if ($con->connect_error) {

      die("Datenbankverbindung fehlgeschlagen: "

      . $con->connect_error);

    }

// Zeichensatz für die Datenbankverbindung festlegen.

// utf8mb4 unterstützt Umlaute und andere Unicode-Zeichen.

$con->set_charset("utf8mb4");

// SQL-Anweisung festlegen. Mit AS erhalten die ausgewählten Spalten

// neue Bezeichnungen. Diese Bezeichnungen werden später als

// Schlüssel des assoziativen Arrays verwendet.

$sql = "SELECT KuNr AS Kundennummer, Name AS Kundenname,

    Vorname AS Kundenvorname FROM kunden ORDER BY KuNr";

/*

SQL-Anweisung ausführen.

execute_query() ist eine Methode der Klasse mysqli. Bei einer SELECT-Anweisung liefert sie ein Objekt der Klasse mysqli_result zurück. Die Variable $res verweist auf dieses Ergebnisobjekt.

*/

$res = $con->execute_query($sql);

// num_rows ist eine Eigenschaft des Ergebnisobjekts. Sie enthält

// die Anzahl der durch die Abfrage gefundenen Datensätze.

if ($res->num_rows === 0) {

  echo "

    <tr>

    <td colspan=\"3\">

      Keine Ergebnisse

    </td>

    </tr>

    ";

}

/*

fetch_assoc() liest jeweils einen Datensatz aus dem Ergebnisobjekt und liefert ihn als assoziatives Array. Die Spaltenbezeichnungen, beziehungsweise die mit AS vergebenen Namen bilden die Schlüssel des Arrays. Die Schleife wird ausgeführt, solange ein weiterer Datensatz vorhanden ist.

*/

while ($dsatz = $res->fetch_assoc()) {

  echo "<tr>";

  echo "<td>" . htmlspecialchars((string)$dsatz["Kundennummer"],

    ENT_QUOTES,"UTF-8") . "</td>";

  echo "<td>" . htmlspecialchars($dsatz["Kundenname"],

    ENT_QUOTES,"UTF-8") . "</td>";

  echo "<td>" . htmlspecialchars($dsatz["Kundenvorname"],

    ENT_QUOTES, "UTF-8") . "</td>";

  echo "</tr>";

}

// Ergebnisobjekt schließen und die dafür verwendeten Ressourcen

// freigeben.

$res->close();

// Datenbankverbindung schließen und die damit

// verbundenen Ressourcen freigeben.

$con->close();

?>

  </tbody>

  </table>

</body>

</html>

Die Konsolenausgabe

2.2.3 Die Stylesheets

Datei mySQL_1.css

body {margin: 10px;color: black;font-family: Arial, sans-serif;}

h1 {margin: 5px 0 10px;color: blue;font-family: Calibri, Arial,

  sans-serif;font-size: 16pt;font-weight: bold;text-align: left;}

p {margin: 10px 0;}

table {border-collapse: collapse;font-family: inherit;}

thead {font-size: 10pt;font-weight: bold;}

td,th {padding: 3px;border: 1px solid black;text-align: left;

  vertical-align: middle;}

.text-red {color: red;font-size: 14pt;}

.text-bold {font-size: 14pt;font-weight: bold;}

2.2.4 Anmerkungen

Folgende Klassen kommen hier zum Einsatz

• mysqli: Erlaubt die Einrichtung einer Verbindung zu einer MySQL-Datenbank. Jedes erzeugte Objekt, z.B. $con, verfügt über Attribute und Methoden zur Arbeit mit der Datenbank. Eine Methode von mysqli ist execute_query(). Diese führt eine SQL-Abfrage aus und liefert ein Ergebnisobjekt der Klasse mysqli_result.
• mysqli_result: Ein Objekt der Klasse mysqli_result enthält somit das Ergebnis der jeweiligen SQL-Abfrage. Zu den Attributen der Klasse gehört num_rows. Eine Methode ist fetch_assoc(). Sie liest jeweils eine Zeile aus dem Ergebnis und gibt sie als assoziatives Array zurück.

Verschmelzung

Das Programm macht deutlich, wie prozedurale und objektorientierte Programmierelemente in PHP miteinander verbunden werden können. Mit der Anweisung

$con = new mysqli("localhost", "root", "", "KuReAr");

wird ein Objekt der Klasse mysqli erzeugt. Die PHP-Variable $con verweist anschließend auf dieses Objekt. Über $con kann auf die Eigenschaften und Methoden des Objekts zugegriffen werden.

Beispielsweise:

$con->connect_error // Eigenschaft

$con->query($sql) // Methode

Zur Programmierung

• fetch_assoc() gibt die Datensätze nicht selbst aus. Die Methode liest jeweils einen Datensatz und liefert ihn als assoziatives Array zurück. Die Ausgabe erfolgt anschließend beispielsweise mit echo.
• Die aus der Datenbank gelesenen Werte werden vor ihrer Einfügung in die HTML-Ausgabe mit htmlspecialchars() behandelt (vgl. Anhang). Dadurch werden Sonderzeichen umgewandelt und nicht als Bestandteile des HTML-Codes interpretiert.
• Die Methode execute_query() steht seit PHP 8.2 zur Verfügung. Enthält die SQL-Anweisung keine Platzhalter, kann bei älteren PHP-Versionen stattdessen $con->query($sql) verwendet werden. Enthält sie Platzhalter, muss die Abfrage mit prepare(), bind_param() und execute() als Prepared Statement ausgeführt werden.

2.3 KundenAbfragenMySQLi_2.php

2.3.1 Merkmale des Programms

• Start durch Browser-Befehl
• Abfrage mit Hilfe eines Prepared Statements
• Festgelegter Suchbegriff im Programm
• Direkter Zugriff auf die Datenbank
• Genutzte Klassen: mysqli, mysqli_stmt und mysqli_result
• Formatierte Ausgabe im Browser

Das zweite Beispiel zeigt wiederum die grundsätzliche Struktur eines PHP-Programms, das mit einem Browser gestartet wird und eine Datenbank mit der Klasse mysqli abfragt. Die Abfrage erfolgt nun aber als Prepared Statement und nicht mit einer einfachen SQL-Abfrage, was aus Sicherheitsgründen sehr zu empfehlen ist.

Prepared Statement

2.3.2 Das Programm

<?php

/*

Kundennummer, nach der gesucht werden soll. In diesem Beispiel wird die Kundennummer unmittelbar im Programm festgelegt. In einer Webanwendung würde sie normalerweise aus einem Eingabeformular stammen.

*/

$id = 1002;

/*

Das HTML-Element <pre> sorgt dafür, dass Leerzeichen und Zeilenumbrüche der Eingabe bei der Ausgabe erhalten bleiben. Dadurch lässt sich das Ergebnis von print_r() übersichtlich darstellen.

*/

echo "<pre>";

echo "--- Verbindungsaufbau mit MySQLi ---\n";

echo "--- KuReAr, Relation Kunden ---\n\n";

/*

Verbindung zur Datenbank aufbauen.

Mit new mysqli() wird ein Objekt der Klasse mysqli erzeugt:

- "localhost" bezeichnet den Datenbankserver.

- "root" ist der MySQL-Benutzer.

- "" ist das hier leere Passwort.

- "KuReAr" ist die Bezeichnung der Datenbank.

Die Variable $con verweist auf das erzeugte mysqli-Verbindungsobjekt.

*/

$con = new mysqli("localhost","root","","KuReAr");

/* Prüfen, ob beim Verbindungsaufbau ein Fehler aufgetreten ist.

connect_error enthält im Fehlerfall die entsprechende Fehlermeldung. die() gibt die Meldung aus und beendet anschließend die Ausführung des Programms.

*/

if ($con->connect_error) {die(

    "MySQLi-Verbindungsfehler: ". $con->connect_error. "\n");

}

/*

Zeichensatz für die Datenbankverbindung festlegen. utf8mb4 unterstützt alle üblichen Unicode-Zeichen.

*/

$con->set_charset("utf8mb4");

/*

Prepared Statement vorbereiten.

Das Fragezeichen ist ein Platzhalter für die Kundennummer. Der konkrete Wert wird erst anschließend mit bind_param() an diesen Platzhalter gebunden. prepare() liefert ein Objekt der Klasse mysqli_stmt. Die Variable $stmt verweist auf dieses Statement-Objekt.

*/

$stmt = $con->prepare(

    "SELECT * FROM Kunden WHERE KuNr = ?");

// Prüfen, ob das Prepared Statement erfolgreich

// vorbereitet werden konnte.

if (!$stmt) {

    die("Vorbereiten der SQL-Anweisung fehlgeschlagen: "

      . $con->error . "\n");

}

/*

Im positiven Fall geht es hier weiter:

Den Wert der Variablen $id an den Platzhalter binden. Das Typkennzeichen "i" bedeutet, dass der übergebene Wert als Integer behandelt wird.

*/

$stmt->bind_param("i",$id);

/*

Prepared Statement ausführen. Erst jetzt wird die SQL-Anweisung mit der gebundenen Kundennummer an den Datenbankserver übermittelt. Zum Kontrollfluss an dieser Stelle vgl. den Exkurs unten.

*/

if (!$stmt->execute()) {

  die("Ausführen der SQL-Anweisung fehlgeschlagen: "

    . $stmt->error . "\n");

}

/*

Ergebnis der SELECT-Abfrage abrufen. get_result() liefert ein Objekt der Klasse mysqli_result. Dieses Ergebnisobjekt kann anschließend Datensatz für Datensatz gelesen werden.

*/

$result = $stmt->get_result();

// Prüfen, ob ein Datensatz mit der angegebenen

// Kundennummer gefunden wurde.

if ($result->num_rows === 0) {

    echo "Kein Kunde mit der Kundennummer " . $id . " gefunden.\n";}

/*

Ergebnis Datensatz für Datensatz durchlaufen.

fetch_assoc() liefert den jeweils nächsten Datensatz als assoziatives Array. Die Attributnamen der Relation bilden die Schlüssel und die Attributwerte die zugehörigen Werte des Arrays. Da KuNr normalerweise der Primärschlüssel ist, kann diese Abfrage höchstens einen einzigen Datensatz liefern.

*/

while ($row = $result->fetch_assoc()) {

  print_r($row);

  echo "\n";

}

// Ergebnisobjekt schließen und die dafür verwendeten

// Ressourcen freigeben.

$result->close();

// Statement-Objekt schließen und die dafür verwendeten

// Ressourcen freigeben.

$stmt->close();

// Datenbankverbindung schließen.

$con->close();

// HTML-Element für die vorformatierte Ausgabe schließen.

echo "</pre>";

?>

2.3.3 Die Konsolenausgabe

Ergebnis eines Programmlaufs, falls die Kundennummer nicht vorhanden ist

2.3.4 Exkurs

Wo ist der Kontrollfluss in folgendem Programmfragment (von oben):

if (!$stmt->execute()) {

  die("Ausführen der SQL-Anweisung fehlgeschlagen: "

      . $stmt->error . "\n");

}

Die Anweisung

$stmt->execute()

wird ausgeführt, während PHP die Bedingung der if-Anweisung auswertet. Das Ergebnis dieses Methodenaufrufs wird dann sofort geprüft. Damit werden Ausführung und Fehlerprüfung in einer if-Anweisung miteinander verbunden.

Der Ablauf im Einzelnen:

Zuerst führt PHP diese Methode aus:

$stmt->execute()

Die Methode liefert normalerweise einen booleschen Wert:

• true - die SQL-Anweisung wurde erfolgreich ausgeführt
• false - bei der Ausführung ist ein Fehler aufgetreten

Vor dem Methodenaufruf steht der logische NICHT-Operator: ! Dieser kehrt den zurückgegebenen Wahrheitswert um.

Erfolgreiche Ausführung

Liefert execute() den Wert true, ergibt sich !true. Das Ergebnis ist also false. Damit ist die if-Bedingung nicht erfüllt. Der Fehlerblock wird übersprungen:

die(...);

Das Programm wird nach der if-Anweisung fortgesetzt.

Fehlerhafte Ausführung

Liefert execute() den Wert false, ergibt sich !false. Das Ergebnis ist true. Damit ist die if-Bedingung erfüllt. Die Fehlermeldung wird ausgegeben und das Programm beendet:

die(

  "Ausführen der SQL-Anweisung fehlgeschlagen: " . $stmt->error

  . "\n");

Gleichbedeutende ausführlichere Schreibweise

Man könnte Ausführung und Prüfung auch auf zwei Anweisungen verteilen:

$erfolgreich = $stmt->execute();

if (!$erfolgreich) {

  die(

    "Ausführen der SQL-Anweisung fehlgeschlagen: "

      . $stmt->error . "\n");

}

2.3.5 Anmerkungen

Zusammenfassung der Klassen und Methoden

Die Klasse mysqli repräsentiert eine Verbindung zu einer MySQL-Datenbank. Sie ist also eine objektorientierte MySQLi-Schnittstelle mit dem Konstruktor

mysqli

new mysqli(host, user, password, database).

Sie hat das Attribut (im Programmierumfeld wird oft von Eigenschaft gesprochen)

$con->connect_error

die eine Fehlermeldung enthält, falls die Verbindung fehlgeschlagen ist und u.a. folgende Methoden

$con->prepare(string $sql), die ein Prepared Statement erstellt.

$con->close(), mit der die Verbindung zur Datenbank geschlossen wird

Insgesamt gilt:

mysqli_stmt

• Die Objekte der Klasse mysqli_stmt repräsentieren jeweils ein Prepared Statement.
• Die Methode $stmt->bind_param(string $types, mixed &$var, mixed &...$vars) bindet PHP-Variablen an die Platzhalter eines MySQLi-Prepared-Statements. Das Zeichen & vor dem Variablennamen kennzeichnet die Übergabe als Referenz. bind_param() bindet daher Variablen und nicht nur deren gegenwärtige Werte. Werden die Variablen vor einem späteren Aufruf von execute() geändert, verwendet das Statement ihre dann aktuellen Werte. Deshalb müssen Variablen und dürfen keine unmittelbar angegebenen Werte oder Ausdrücke übergeben werden.
• Die Methode $stmt->execute() führt das vorbereitete Statement aus. Dies geschieht auf dem Server.
• Die Methode $stmt->get_result() liefert ein Ergebnisobjekt (mysqli_result).
• Die Methode $stmt->close() schließt das Statement.

Beispiel für mehrere Platzhalter:

$stmt = $con->prepare(

  "select * from kunden where KuNr = ? AND Name = ?");

$stmt->bind_param("is", $id, $name);

Erster Parameter integer, zweiter Parameter string.

Die Klasse mysqli_result erfasst die Ergebnisse von SQL-Abfragen. Ihre Methode $result->fetch_assoc() liest eine Ergebniszeile als assoziatives Array. Die Schleife läuft, bis false zurückgegeben wird, also keine weitere Zeile mehr vorliegt.

mysqli_result

2.3.6 Zum Programm

• bind_param() setzt den Wert nicht durch gewöhnliche Textersetzung in die SQL-Anweisung ein. SQL-Anweisung und Parameter werden getrennt an die Datenbank übermittelt. Es entsteht daher intern nicht einfach die Zeichenkette SELECT * FROM kunden WHERE KuNr = 1002. Sinngemäß wird diese Abfrage ausgeführt, technisch bleibt der Parameter aber von der SQL-Anweisung getrennt.
• Prepared Statements (vgl. auch den Anhang) schützen vor SQL-Injection, weil ein gebundener Wert als Datenwert und nicht als Bestandteil des SQL-Codes behandelt wird. Sie sollten grundsätzlich verwendet werden, wenn Werte von außen in eine SQL-Anweisung gelangen. Dies gilt nicht nur außerhalb eines lokalen XAMPP-Systems.
• Da nach einer Kundennummer gesucht wird, die normalerweise eindeutig ist, liefert die Abfrage höchstens einen einzigen Datensatz. Die while-Schleife ist trotzdem korrekt und lässt sich später leicht für Abfragen mit mehreren Ergebnissen weiterverwenden.
• get_result() setzt bei PHP in der Regel den MySQL-Native-Driver mysqlnd voraus. Dieser ist in üblichen XAMPP-Installationen vorhanden.
• Die Ausgabe mit print_r() eignet sich vor allem zum Lernen und zur Fehlersuche. Für eine fertige Webseite sollten die Werte in einer HTML-Tabelle ausgegeben und dabei mit htmlspecialchars() (vgl. Anhang) behandelt werden.

2.4 KundenAbfragenPDO_1.php

2.4.1 Merkmale des Programms

• Verwendete Klasse für Verbindungsaufbau: PDO
• Absicherung durch Prepared Statements
• Start durch Browser-Befehl
• HTML-Ausgabe des Ergebnisses

Nun die Verbindungsaufnahme mit Hilfe der Klasse PDO. Wieder erfolgt der Zugriff auf die Relation Kunden der Datenbank KuReAr (Kunden - Rechnungen - Artikel).

2.4.2 Das Programm

<?php

/*

Kundennummer, nach der gesucht werden soll. Auch in diesem Beispiel wird der Suchwert unmittelbar im Programm festgelegt. In einer Webanwendung würde er üblicherweise aus einem Eingabeformular stammen.

*/

$id = 1002;

echo "<pre>";

echo "--- Verbindungsaufbau mit PDO ---\n";

echo "--- KuReAr, Relation kunden ---\n\n";

try {

/*

Verbindung zur Datenbank aufbauen.

PDO steht für PHP Data Objects. Die Variable $pdo verweist auf das erzeugte PDO-Objekt. Dieses Objekt stellt die Verbindung zur Datenbank dar.

Der DSN (Data Source Name) enthält:

- den verwendeten Datenbanktreiber: mysql

- den Datenbankserver: localhost

- die Bezeichnung der Datenbank: KuReAr

- den Zeichensatz: utf8mb4

"root" ist der MySQL-Benutzer. Die darauffolgenden Anführungszeichenbedeuten, dass kein Passwort verwendet wird.

PDO::ERRMODE_EXCEPTION bewirkt, dass PDO bei einem Datenbankfehler eine PDOException auslöst.

*/

$pdo = new PDO(

  "mysql:host=localhost;dbname=KuReAr;charset=utf8mb4",

    "root","",[PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);

/*

Prepared Statement vorbereiten.

:id ist ein benannter Platzhalter für die gesuchte Kundennummer.

prepare() liefert ein Objekt der Klasse PDOStatement. Die Variable $stmt verweist auf dieses Statement-Objekt.

*/

$stmt = $pdo->prepare(

  "SELECT * FROM kunden WHERE KuNr = :id");

/*

Prepared Statement ausführen.

Das assoziative Array ordnet dem Platzhalter :id den Wert der Variablen $id zu. Beim Array-Schlüssel kann der Doppelpunkt weggelassen werden. SQL-Anweisung und Parameterwert bleiben dabei voneinander getrennt.

*/

$stmt->execute(["id" => $id]);

/*

Alle gefundenen Datensätze abrufen.

fetchAll() liefert ein Array, das sämtliche Ergebnisdatensätze enthält.

PDO::FETCH_ASSOC legt fest, dass jeder Datensatz als assoziatives Array bereitgestellt wird. Die Spaltennamen der Relation bilden die Schlüssel des Arrays.

*/

$datensaetze = $stmt->fetchAll(PDO::FETCH_ASSOC);

// Prüfen, ob ein Datensatz gefunden wurde.

if (count($datensaetze) === 0) {

  echo "Kein Kunde mit der Kundennummer " . $id . " gefunden.\n";

}

/*

Die gefundenen Datensätze nacheinander ausgeben. print_r() ist eine eingebaute PHP-Funktion. Sie gibt den Inhalt und die Struktur einer Variablen, insbesondere eines Arrays, in einer für Menschen gut lesbaren Form aus.

Falls die Anzahl der Datensätze Null ist, ist $datensaetze ein leeres Array. Die foreach-Schleife wird deshalb kein einziges Mal durchlaufen. Die Schleife beendet sich, ohne dass print_r() oder echo "\n" ausgeführt werden.

*/

foreach ($datensaetze as $row) {

  print_r($row);

  echo "\n";

}

//von try (ganz oben)

} catch (PDOException $e) {

// PDO-Datenbankfehler abfangen. getMessage() liefert die zur

// Exception gehörende Fehlermeldung.

echo "PDO-Fehler: " . $e->getMessage() . "\n";

} //schließt catch

// HTML-Element für die vorformatierte Ausgabe schließen.

echo "</pre>";

?>

Die Konsolenausgabe

2.4.3 Anmerkungen

Exkurs: Was genau ist $stmt?

Betrachten wir folgende Anweisung:

$stmt = $pdo->prepare("SELECT * FROM kunden WHERE KuNr = :id");

Die Methode prepare() bereitet die SQL-Anweisung zur späteren Ausführung vor. Die Ausführung selbst erfolgt zu diesem Zeitpunkt noch nicht. Nach erfolgreicher Ausführung von prepare() verweist die Variable $stmt auf ein Objekt der Klasse PDOStatement. Dieses Statement-Objekt repräsentiert die vorbereitete SQL-Anweisung und stellt Methoden bereit, mit denen Platzhalter gebunden, die Anweisung ausgeführt und Abfrageergebnisse abgerufen werden können.

Der benannte Platzhalter :id wird zunächst noch nicht durch einen konkreten Wert ersetzt. Der Wert kann beispielsweise mit bindValue() gebunden werden:

$stmt->bindValue(":id", $id, PDO::PARAM_INT);

Anschließend wird die vorbereitete SQL-Anweisung ausgeführt: $stmt->execute(); Alternativ kann der Wert unmittelbar beim Aufruf von execute() übergeben werden:

$stmt->execute(["id" => $id]);

Wichtige Methoden des PDOStatement-Objekts sind:

• bindParam() bindet eine Variable als Referenz an einen Platzhalter
• bindValue() bindet einen Wert an einen Platzhalter
• execute() führt die vorbereitete SQL-Anweisung aus
• fetch() ruft den nächsten Ergebnisdatensatz ab
• fetchAll() ruft alle Ergebnisdatensätze ab

Zum Programm

Das Programm demonstriert, wie ein einzelner Datensatz aus der Datenbank abgefragt und ausgegeben wird. Dabei wird die PDO-Erweiterung verwendet, die eine objektorientierte und sichere Schnittstelle zur Datenbank bereitstellt.

Zu Beginn wird mit der Variablen $id ein Suchkriterium festgelegt. Es handelt sich um eine Ganzzahl, die den Schlüsselwert eines bestimmten Datensatzes repräsentiert. Dieser Wert wird später in die SQL-Abfrage eingesetzt.

Die Ausgabe erfolgt mit der Funktion echo. Durch die Verwendung des HTML-Tags <pre> wird eine formatierte Darstellung erreicht, bei der Zeilenumbrüche und Einrückungen erhalten bleiben. Dies ist besonders hilfreich für Debugging-Zwecke oder zur Veranschaulichung von Datenstrukturen.

Die eigentliche Datenbankoperation ist in einen try/catch-Block eingebettet. Dieses Konstrukt dient der strukturierten Fehlerbehandlung. Im try-Block steht der Code, der ausgeführt werden soll, während der catch-Block aufgerufen wird, falls ein Fehler auftritt. Im Unterschied zu einem einfachen Abbruch mit die() ermöglicht dieses Vorgehen eine kontrollierte Reaktion auf Fehler.

try/catch-Block

Innerhalb des try-Blocks wird zunächst eine Verbindung zur Datenbank aufgebaut, indem ein PDO-Objekt erzeugt wird. Die Verbindungsparameter werden in Form eines sogenannten DSN (Data Source Name) übergeben. Die Eingabe

PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION

stellt sicher, dass Fehler als Exceptions gemeldet werden.

Anschließend wird ein Prepared Statement vorbereitet. Die SQL-Anweisung enthält mit :id einen benannten Platzhalter. Dieser wird erst beim Ausführen der Anweisung mit einem konkreten Wert belegt. Das erhöht die Sicherheit, da es vor SQL-Injection schützt, und sorgt zugleich für eine klare Trennung von SQL-Code und Daten.

Mit der Methode execute() wird die vorbereitete Anweisung ausgeführt. Dabei wird der Platzhalter :id mit dem Wert der Variablen $id verknüpft.

Die Ergebnismenge wird anschließend mit fetchAll(PDO::FETCH_ASSOC) abgerufen. Dabei werden alle Treffer als assoziatives Array geliefert, bei dem die Spaltennamen als Schlüssel dienen. Mit einer foreach-Schleife werden die einzelnen Ergebniszeilen durchlaufen und mit print_r() lesbar ausgegeben.

Tritt während der Ausführung ein Fehler auf, wird im catch-Block eine Fehlermeldung ausgegeben. Die Methode getMessage() liefert dabei eine genauere Beschreibung des aufgetretenen Problems.

2.5 KundenAbfragenPDO_2.php

2.5.1 Merkmale des Programms

• Verwendete Klasse für Verbindungsaufbau: PDO
• Start über Maskeneingabe (Formular)
• Absicherung der Abfrage durch ein Prepared Statement
• HTML-Formular mit Posting für die Eingabe
• HTML-Ausgabe des Ergebnisses

Um das Zusammenspiel von PHP mit HTML zu demonstrieren, erweitern wir obiges Programm so, dass es über eine Eingabe per Maske gestartet wird.

So soll das Eingabeformular aussehen:

Und so das positive Ergebnis, falls 1001 eingegeben wurde:

2.5.2 Das Programm

<?php

/* Mit echo werden, wie oben ja auch schon mehrfach, die Bestandteile des HTML-Dokuments an den Browser ausgegeben. Der Browser interpretiert den erzeugten HTML-Code und stellt daraus die Webseite dar. Er führt den PHP-Code nicht aus. Dieser wird zuvor auf dem Webserver verarbeitet.

*/

echo "<!doctype html>";

echo "<html lang=\"de\">";

echo "<head>";

echo "<meta charset=\"UTF-8\">";

echo "<title>Kundensuche</title>";

echo "</head>";

echo "<body>";

echo "<h2>Abfrage Kundendaten</h2>";

/*

HTML-Formular ausgeben.

method="post" legt fest, dass die eingegebene Kundennummer mit der HTTP-Methode POST übertragen wird. Da kein action-Attribut angegeben ist, werden die Daten an dieselbe Seite gesendet, d.h. an dieselbe URL.

Zu den Schrägstrichen:

Die PHP-Anweisung echo gibt eine Zeichenkette aus, die hier HTML-Code enthält. Da sowohl die PHP-Zeichenkette als auch die HTML-Attribute doppelte Anführungszeichen verwenden, müssen die inneren Anführungszeichen durch einen vorangestellten umgekehrten Schrägstrich (backslash) \ geschützt werden. Die Zeichenfolge \" bedeutet, dass das Anführungszeichen zum Inhalt der Zeichenkette gehört und diese nicht beendet. Der Backslash wird selbst nicht ausgegeben.

Der normale Schrägstrich / in </form> oder </label> gehört dagegen zum HTML-Code und kennzeichnet das Ende eines HTML-Abschnitts.

*/

echo "<form method=\"post\">";

echo "<label for=\"id\">Kundennummer:</label> ";

echo "<input type=\"number\" id=\"id\" name=\"id\" min=\"1\"

    required> ";

echo "<input type=\"submit\" value=\"Start\">";

echo "</form>";

/*

Prüfen, ob das Formular mit der HTTP-Methode POST abgesendet wurde. Beim ersten Aufruf der Seite ist die Bedingung nicht erfüllt. Dann wird lediglich das Formular angezeigt.

*/

if ($_SERVER["REQUEST_METHOD"] === "POST") {

/*

Eingabewert aus den POST-Daten übernehmen.

Der Null-Koaleszenz-Operator ?? sorgt dafür, dass bei einem fehlenden Formularelement ersatzweise die leere Zeichenkette verwendet wird.

Die explizite Typumwandlung (int) wandelt den Wert anschließend in eine ganze Zahl um.

*/

$id = (int)($_POST["id"] ?? "");

echo "<pre>";

echo "--- Verbindungsaufbau mit PDO ---\n";

echo "--- KuReAr, Relation kunden ---\n\n";

/*

Die Typumwandlung allein ist noch keine vollständige Eingabeprüfung. Deshalb wird zusätzlich geprüft, ob die Kundennummer größer als 0 ist.

*/

if ($id <= 0) {

  echo "Bitte geben Sie eine gültige Kundennummer ein.\n";

} else {

  try {

/*

Verbindung zur Datenbank aufbauen.

Der DSN enthält den Datenbanktreiber, den Datenbankserver, die Datenbankbezeichnung und den Zeichensatz. PDO::ERRMODE_EXCEPTION bewirkt, dass PDO bei Datenbankfehlern eine PDOException auslöst.

*/

$pdo = new PDO("mysql:host=localhost;" . "dbname=KuReAr;"

  . "charset=utf8mb4", "root","",

  [PDO::ATTR_ERRMODE =>PDO::ERRMODE_EXCEPTION]);

// Prepared Statement vorbereiten.

// :id ist ein benannter Platzhalter für die gesuchte Kundennummer.

$stmt = $pdo->prepare("SELECT * FROM kunden WHERE KuNr = :id");

// Prepared Statement ausführen.

// Der Wert der Variablen $id wird dem Platzhalter :id zugeordnet.

$stmt->execute(["id" => $id]);

// Alle gefundenen Datensätze als assoziative Arrays abrufen.

$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);

// Prüfen, ob ein Kunde gefunden wurde.

if (count($rows) === 0) {

  echo "Kein Kunde mit der Kundennummer " . $id . " gefunden.\n";

} else {

// Gefundene Datensätze nacheinander ausgeben.

  foreach ($rows as $row) {

    print_r($row);

    echo "\n";

  }

  }

} catch (PDOException $e) {

// Datenbankfehler abfangen und ausgeben.

echo "PDO-Fehler: " . $e->getMessage() . "\n";

      }

  }

// HTML-Element für die vorformatierte Ausgabe schließen.

  echo "</pre>";

}

// HTML-Dokument beenden.

echo "</body>";

echo "</html>";

?>

2.5.3 Anmerkungen

• Der Browser führt die ausgegebenen HTML-Zeilen nicht als "Programmzeilen" aus. PHP wird auf dem Webserver ausgeführt; der Browser empfängt den dabei erzeugten HTML-Code, interpretiert ihn und stellt die Webseite dar.
• Das label-Element wurde mit dem Eingabefeld verbunden. Dazu gehören for="id" beim Label und id="id" beim Eingabefeld.
• min="1" verhindert im Browser die Eingabe einer Kundennummer kleiner als 1. Die serverseitige Prüfung in PHP bleibt trotzdem erforderlich.
• (int) ist eine explizite Typumwandlung, aber allein keine "sichere" oder vollständige Eingabeprüfung. Beispielsweise werden ungültige Zeichenketten zu 0 umgewandelt. Deshalb wird anschließend $id <= 0 geprüft.
• $_POST["id"] wurde durch $_POST["id"] ?? "" abgesichert. Dadurch entsteht keine Warnung, falls der Wert wider Erwarten fehlt.

3 Eintragen von Daten

In diesem Kapitel wird gezeigt, wie aus PHP-Programmen Daten in Relationale Datenbanken eingetragen werden. Zuerst am Beispiel MySQLi, dann mit PDO.

3.1 KundenEintragenMySQLi.php

3.1.1 Merkmale des Programms

• Die Kundendaten werden über ein HTML-Formular eingegeben.
• Das Formular wird mit der HTTP-Methode POST an dasselbe PHP-Programm übermittelt.
• Das PHP-Programm wird nur dann aktiv, wenn das Formular abgeschickt wurde.
• Kundennummer, Name und Vorname werden aus dem POST-Array übernommen.
• Die Eingabewerte werden auf grundlegende Plausibilität geprüft.
• Der Zugriff auf die Datenbank erfolgt mit der Klasse mysqli.
• Für das Einfügen des Datensatzes wird ein Prepared Statement verwendet.
• Die eingegebenen Werte werden mit bind_param() an die Platzhalter der SQL-Anweisung gebunden.
• Nach dem Einfügen wird eine Erfolgs- oder Fehlermeldung ausgegeben.
• Die Meldung wird vor der HTML-Ausgabe mit htmlspecialchars() behandelt.
• Das Statement und die Datenbankverbindung werden nach ihrer Verwendung geschlossen.

3.1.2 Das Programm

<?php

/*

Variable für Rückmeldungen an den Benutzer. Sie bleibt zunächst leer und wird später mit einer Erfolgs- oder Fehlermeldung beschrieben.

*/

$message = "";

// Zugangsdaten zur Datenbank.

$host = "localhost";

$user = "root";

$pass = "";

$db = "KuReAr";

/*

Prüfen, ob das Formular mit der HTTP-Methode POST abgeschickt wurde. Der PHP-Code zum Einfügen wird erst nach dem Absenden des Formulars ausgeführt.

*/

if ($_SERVER["REQUEST_METHOD"] === "POST") {

/*

Eingaben aus dem Formular übernehmen. Der Operator ?? liefert einen Standardwert, falls kein Wert übertragen wurde.

trim() entfernt Leerzeichen am Anfang und Ende.

(int) wandelt den übernommenen Wert in eine ganze Zahl um.

*/

  $kuNr = (int)($_POST["kuNr"] ?? 0);

  $name = trim($_POST["name"] ?? "");

  $vorname = trim($_POST["vorname"] ?? "");

/*

Eingaben auf Plausibilität prüfen. Die Kundennummer muss größer als 0 sein. Name und Vorname dürfen nicht leer sein.

*/

if ($kuNr <= 0 || $name === "" || $vorname === "") {

  $message = "Bitte alle Felder korrekt ausfüllen.";

} else {

// Verbindung zur Datenbank aufbauen. Die Variable $con verweist

// auf das erzeugte mysqli-Objekt.

$con = new mysqli($host, $user, $pass, $db);

// Prüfen, ob beim Verbindungsaufbau ein Fehler aufgetreten ist.

// "die()" gibt die Meldung aus und beendet das Programm.

if ($con->connect_error) {

  die("DB-Verbindung fehlgeschlagen: " . $con->connect_error);

}

// Zeichensatz für die Datenbankverbindung festlegen.

// utf8mb4 unterstützt Umlaute und andere Unicode-Zeichen.

$con->set_charset("utf8mb4");

// SQL-Anweisung vorbereiten. Die Fragezeichen dienen als

// Platzhalter für Kundennummer, Name und Vorname.

$stmt = $con->prepare(

  "INSERT INTO kunden (KuNr, Name, Vorname)

      VALUES (?, ?, ?)");

// Prüfen, ob das Prepared Statement erstellt werden konnte.

if (!$stmt) {

  $message = "Prepare fehlgeschlagen: " . $con->error;

} else {

/*

Werte an die Platzhalter binden.

"i" bezeichnet einen Integer-Wert.

"s" bezeichnet einen String-Wert.

"iss" steht daher für Integer, String, String.

*/

$stmt->bind_param("iss",$kuNr,$name,$vorname);

// Prepared Statement ausführen.

if ($stmt->execute()) {

  $message = "Datensatz wurde eingefügt.";

} else {

// Fehlermeldung des Statements übernehmen.

    $message = "Fehler beim Einfügen: " . $stmt->error;

}

// Prepared Statement schließen und die dafür verwendeten

// Ressourcen freigeben.

$stmt->close();

}

// Datenbankverbindung schließen und die damit verbundenen

// Ressourcen freigeben.

$con->close();

  }

}

?>

<!doctype html>

<html lang="de">

<head>

  <meta charset="utf-8">

  <title>Kunde eintragen mit MySQLi</title>

    <style>body {font-family: Arial, sans-serif;

    }

    </style>

</head>

<body>

<h2>Kunde eintragen (MySQLi)</h2>

<!--

Formular zur Eingabe der Kundendaten.

method="post" legt fest, dass die Formulardaten mit der HTTP-Methode POST übertragen werden.

-->

<form method="post">

    <label for="kuNr">Kundennummer:</label>

    <input type="number" id="kuNr" name="kuNr" min="1"

      required>

<br><br>

    <label for="name">Name:</label>

    <input type="text" id="name" name="name" maxlength="10"

      required>

<br><br>

    <label for="vorname">Vorname:</label>

    <input type="text" id="vorname" name="vorname"

      maxlength="10" required>

<br><br>

<!-- Schaltfläche zum Absenden des Formulars. -->

<button type="submit">Speichern</button>

</form>

<!--

Wenn eine Rückmeldung vorliegt, wird sie in Fettschrift ausgegeben.

Zu htmlspecialchars() vgl. den Anhang.

-->

<?php if ($message !== ""): ?>

<p><strong>

  <?php

    echo htmlspecialchars($message,ENT_QUOTES,"UTF-8");

  ?>

  </strong>

</p>

<?php endif; ?>

</body>

</html>

3.1.3 Programmlauf

Nach dem Programmstart erscheint eine leere Eingabemaske, die befüllt werden kann.

Nach dem Betätigen der Schaltfläche "Speichern" wird das Programm erneut aufgerufen. Wenn die Eingaben gültig sind und der Datensatz erfolgreich gespeichert wurde, erscheint wieder eine leere Eingabemaske. Unterhalb der Maske wird die Erfolgsmeldung "Datensatz wurde eingefügt." angezeigt.

Ein Blick auf die Relation kunden mit phpMyAdmin zeigt den neu eingefügten Datensatz:

3.1.4 Anmerkungen

• Die Platzhalter werden nicht durch eine gewöhnliche Textersetzung "gefüllt". bind_param() bindet die Werte getrennt an die SQL-Anweisung.
• htmlspecialchars() sorgt hier dafür, dass Zeichen wie <, > und Anführungszeichen nicht als HTML interpretiert werden. Vgl. Anhang.
• Die Attribute for und id ordnen jede Beschriftung eindeutig ihrem Eingabefeld zu.
• min="1" ergänzt die Prüfung der Kundennummer im Browser. Die serverseitige PHP-Prüfung bleibt trotzdem erforderlich.
• Existiert die angegebene Kundennummer bereits, wird das Einfügen bei einem Primärschlüssel beziehungsweise einer eindeutigen Einschränkung abgelehnt und die Datenbankfehlermeldung ausgegeben.

Das Beispiel verdeutlicht außerdem das Zusammenspiel von HTML, PHP und SQL:

• HTML stellt das Eingabeformular bereit.
• PHP übernimmt und prüft die Formulardaten und steuert den Programmablauf.
• SQL fügt den neuen Datensatz in die Relation kunden ein.
• MySQLi stellt die Verbindung zwischen dem PHP-Programm und der MySQL- beziehungsweise MariaDB-Datenbank her.

3.2 RechnungSpeichernMySQLi.php

3.2.1 Merkmale des Programms

• Speichern zusammengehöriger Daten in mehreren miteinander verknüpften Relationen
• Speichern eines Rechnungskopfes und mehrerer Rechnungspositionen
• Verwendung einer Transaktion
• Sicherung des Alles-oder-nichts-Prinzips
• Datenbankzugriff mit der Klasse mysqli
• Verwendung von Prepared Statements
• Bindung von Werten mit bind_param()
• Mehrfache Ausführung eines vorbereiteten Statements
• Speicherung der Positionsdaten in einem mehrdimensionalen Array
• Verarbeitung der Rechnungspositionen mit einer foreach-Schleife
• Beachtung von Primärschlüsseln und Fremdschlüsseln
• Fehlerbehandlung mit try, catch und finally
• Zurücksetzen der Transaktion mit rollback() im Fehlerfall
• Freigabe der verwendeten Ressourcen mit close()
• Festlegung der Rechnungsdaten unmittelbar im PHP-Programm, also ohne HTML-Formular

3.2.2 Aufgabe

Das Programm trägt eine neue Rechnung in die Datenbank KuReAr ein. Gespeichert werden der Rechnungskopf in der Relation RechKoepfe und die zugehörigen Rechnungspositionen in der Relation RechPos.

Transaktionen

Der Rechnungskopf enthält die Rechnungsnummer, die Kundennummer und das Rechnungsdatum. Die Kundennummer verweist als Fremdschlüssel auf einen bereits vorhandenen Datensatz in der Relation Kunden. Ein neuer Kundendatensatz wird durch dieses Programm nicht angelegt.

Eine Rechnung bildet mit ihren Rechnungspositionen eine fachliche Einheit. Deshalb müssen der Rechnungskopf und sämtliche Rechnungspositionen entweder vollständig oder gar nicht gespeichert werden. Dazu wird eine Transaktion verwendet.

Tritt während des Speicherns einer Position ein Fehler auf, darf auch der zuvor eingefügte Rechnungskopf nicht erhalten bleiben. In diesem Fall werden alle seit Beginn der Transaktion vorgenommenen Änderungen mit rollback() zurückgenommen. Nur wenn sämtliche Datenbankoperationen erfolgreich waren, werden die Änderungen mit commit() dauerhaft gespeichert.

Die Rechnungsdaten werden in diesem Beispiel unmittelbar im PHP-Programm festgelegt. Eine Eingabe über ein HTML-Formular findet nicht statt.

Die neue Rechnung hat die Rechnungsnummer 23012 und gehört zum Kunden mit der Kundennummer 1002. Sie enthält drei Positionen mit den Artikelnummern 100, 101 und 102.

3.2.3 Das Programm

<?php

// Daten für den Verbindungsaufbau.

$host = "localhost";

$user = "root";

$pass = "";

$db = "KuReAr";

// Daten des Rechnungskopfes.

$reNr = 23012;

$kuNr = 1002;

$reDatum = "2023-03-28";

/* Daten der Rechnungspositionen.

In diesem Beispiel werden die Daten unmittelbar im Programm festgelegt. In einer Webanwendung stammen sie üblicherweise aus einem Formular.

*/

$positionen = [

  ["posNr" => 1,"artNr" => 100,"anzahl" => 2],

  ["posNr" => 2,"artNr" => 101,"anzahl" => 1],

  ["posNr" => 3,"artNr" => 102,"anzahl" => 5]];

/*

Die Variable enthält zunächst kein Verbindungsobjekt. Nach erfolgreichem Verbindungsaufbau verweist sie auf das erzeugte mysqli-Objekt.

*/

$con = null;

try {

// Verbindung zur Datenbank aufbauen.

  $con = new mysqli($host,$user,$pass,$db);

// Prüfen, ob beim Verbindungsaufbau ein Fehler Aufgetreten ist.

// In diesem Fall wird eine Exception ausgelöst.

    if ($con->connect_error) {throw new Exception(

    "MySQLi-Verbindungsfehler: " . $con->connect_error);

}

// Zeichensatz für die Datenbankverbindung festlegen.

$con->set_charset("utf8mb4");

/*

Transaktion starten.

Der Rechnungskopf und alle Rechnungspositionen bilden eine gemeinsame Arbeitseinheit. Sie werden entweder vollständig oder gar nicht gespeichert.

*/

$con->begin_transaction();

// Prepared Statement zum Einfügen des Rechnungskopfes

// vorbereiten. Die Fragezeichen dienen als Platzhalter.

    $stmtKopf = $con->prepare("INSERT INTO rechkoepfe

      (ReNr, KuNr, ReDatum) VALUES (?, ?, ?)");

// Prüfen, ob das Prepared Statement erstellt werden konnte.

    if (!$stmtKopf) {throw new Exception(

      "Prepare fehlgeschlagen (Rechnungskopf): "

      . $con->error);

}

/*

Werte an die Platzhalter binden.

"i" bezeichnet einen Integer-Wert.

"s" bezeichnet einen String-Wert.

"iis" steht also für Integer, Integer, String.

*/

$stmtKopf->bind_param("iis",$reNr,$kuNr,$reDatum);

// Prepared Statement ausführen.

if (!$stmtKopf->execute()) {throw new Exception(

    "Execute fehlgeschlagen (Rechnungskopf): "

      . $stmtKopf->error);

}

// Statement für den Rechnungskopf schließen und die

// dafür verwendeten Ressourcen freigeben.

$stmtKopf->close();

// Prepared Statement zum Einfügen der

// Rechnungspositionen vorbereiten.

$stmtPos = $con->prepare("INSERT INTO rechpos

  (ReNr, PosNr, ArtNr, Anzahl) VALUES (?, ?, ?, ?)");

// Prüfen, ob das Prepared Statement erstellt werden konnte.

if (!$stmtPos) {throw new Exception(

    "Prepare fehlgeschlagen (Rechnungspositionen): "

      . $con->error);

}

// Variablen für die Werte einer Rechnungsposition.

// Sie werden in jedem Schleifendurchlauf neu beschrieben.

$posNr = 0;

$artNr = 0;

$anzahl = 0;

/*

Variablen an die Platzhalter binden. Alle vier Werte sind ganze Zahlen. MySQLi bindet hier die Variablen, nicht nur deren gegenwärtige Werte. Deshalb können sie innerhalb der Schleife neu beschrieben und das Statement mehrfach ausgeführt werden.

*/

$stmtPos->bind_param("iiii",$reNr,$posNr,$artNr,$anzahl);

// Die Rechnungspositionen nacheinander bearbeiten.

foreach ($positionen as $p) {

// Werte aus dem jeweiligen Array-Element übernehmen

// und in ganze Zahlen umwandeln.

  $posNr = (int)$p["posNr"];

  $artNr = (int)$p["artNr"];

  $anzahl = (int)$p["anzahl"];

// Anzahl auf Plausibilität prüfen.

  if ($anzahl <= 0) {throw new Exception(

    "Anzahl muss größer als 0 sein " . "(PosNr $posNr).");

  }

// Prepared Statement mit den Werten der aktuellen

// Rechnungsposition ausführen.

  if (!$stmtPos->execute()) {throw new Exception(

    "Execute fehlgeschlagen " . "(PosNr $posNr): "

      . $stmtPos->error);

  }

}

// Statement für die Rechnungspositionen schließen und

// die dafür verwendeten Ressourcen freigeben.

$stmtPos->close();

/*

Transaktion erfolgreich abschließen. Erst dadurch werden der Rechnungskopf und alle Rechnungspositionen dauerhaft gespeichert.

*/

$con->commit();

echo "Rechnung erfolgreich gespeichert.";

} catch (Exception $e) {

// Wenn eine Datenbankverbindung besteht, werden die seit Beginn der

// Transaktion vorgenommenen Änderungen rückgängig gemacht.

  if ($con instanceof mysqli) {

    $con->rollback();

  }

    echo "Fehler beim Speichern. " . "Alles wurde zurückgesetzt: "

    . $e->getMessage();

  } finally {

// Datenbankverbindung schließen und die damit verbundenen

// Ressourcen freigeben.

    if ($con instanceof mysqli) {$con->close();

  }

}

?>

3.2.4 Programmlauf

Nach einem erfolgreichen Programmlauf erscheint folgende Meldung:

Rechnung erfolgreich gespeichert.

Eine anschließende Kontrollabfrage zeigt den neu eingefügten Rechnungskopf und seine drei Rechnungspositionen.

Daran denken: Falls Sie das Programm mehrfach erfolgreich ausführen wollen, müssen Sie diese Rechnung (23012) löschen und dabei, wegen der Fremdschlüssel, die Rechnungspositionen zuerst.

3.3 KundenEintragenPDO.php

3.3.1 Merkmale des Programms

• Eingabe eines neuen Kundendatensatzes über ein HTML-Formular
• Übermittlung der Formulardaten mit der HTTP-Methode POST
• Verarbeitung des Formulars durch dasselbe PHP-Programm
• Übernahme und Prüfung der eingegebenen Kundendaten
• Datenbankzugriff über PDO
• Auswahl des MySQL-Treibers durch den DSN
• Verwendung eines Prepared Statements
• Verwendung benannter Platzhalter
• getrennte Übergabe der SQL-Anweisung und der einzusetzenden Werte
• Schutz vor SQL-Injection
• Fehlerbehandlung mit try und catch
• Auslösen von Ausnahmen durch PDO::ERRMODE_EXCEPTION
• sichere HTML-Ausgabe der Rückmeldung mit htmlspecialchars()
• browserseitige und serverseitige Prüfung der Eingaben
• keine Transaktion erforderlich, da nur ein einzelner Datensatz mit einer einzigen SQL-Anweisung gespeichert wird

3.3.2 Das Programm

<?php

/*

Variable für Rückmeldungen an den Benutzer. Sie bleibt zunächst leer und wird später mit einer Erfolgs- oder Fehlermeldung beschrieben.

*/

$message = "";

/*

Daten für den Verbindungsaufbau. Der DSN (Data Source Name) enthält:

- den verwendeten Datenbanktreiber: mysql

- den Datenbankserver: localhost

- die Bezeichnung der Datenbank: KuReAr

- den Zeichensatz: utf8mb4

*/

$dsn = "mysql:host=localhost;dbname=KuReAr;charset=utf8mb4";

$user = "root";

$pass = "";

/* Prüfen, ob das Formular mit der HTTP-Methode POST abgeschickt wurde. Der Code zum Einfügen wird erst nach dem Absenden des Formulars ausgeführt.

*/

if ($_SERVER["REQUEST_METHOD"] === "POST") {

/*

Eingaben aus dem Formular übernehmen. Der Operator ?? liefert einen Standardwert, falls kein entsprechender Wert übertragen wurde.

trim() entfernt Leerzeichen am Anfang und Ende.

(int) wandelt den übernommenen Wert in eine ganze Zahl um.

*/

$kuNr = (int)($_POST["kuNr"] ?? 0);

$name = trim($_POST["name"] ?? "");

$vorname = trim($_POST["vorname"] ?? "");

/*

Eingaben auf Plausibilität prüfen.

Die Kundennummer muss größer als 0 sein. Name und Vorname dürfen nicht leer sein.

/*

  if ($kuNr <= 0 || $name === "" || $vorname === "") {

    $message = "Bitte alle Felder korrekt ausfüllen.";

  } else {

try {

/*

Verbindung zur Datenbank aufbauen.

PDO steht für PHP Data Objects. Die Variable $pdo verweist auf das erzeugte PDO-Objekt.

PDO::ATTR_ERRMODE legt fest, wie PDO auf Fehler reagieren soll.

PDO::ERRMODE_EXCEPTION bewirkt, dass bei einem Datenbankfehler eine Exception ausgelöst wird.

*/

    $pdo = new PDO( $dsn, $user, $pass,

      [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION ]);

/*

Prepared Statement vorbereiten. :kuNr, :name und :vorname sind benannte Platzhalter. Die Eingabewerte werden erst beim Ausführen an diese Platzhalter gebunden.

*/

    $stmt = $pdo->prepare( "INSERT INTO kunden (KuNr, Name, Vorname)

      VALUES (:kuNr, :name, :vorname)");

/*

Prepared Statement ausführen. Das Array ordnet jedem benannten Platzhalter den zugehörigen Wert zu. Bei den Array-Schlüsseln kann der Doppelpunkt weggelassen werden.

*/

    $stmt->execute(["kuNr" => $kuNr,"name" => $name,

    "vorname" => $vorname]);

// Diese Zeile wird nur erreicht, wenn execute()

// keine Exception ausgelöst hat.

    $message = "Datensatz wurde eingefügt.";

  } catch (PDOException $e) {

// PDO-Datenbankfehler abfangen und eine entsprechende Rückmeldung

// erzeugen.

    $message = "Fehler beim Einfügen: " . $e->getMessage();

    }

  }

}

?>

<!doctype html>

<html lang="de">

<head>

  <meta charset="utf-8">

  <title>Kunde eintragen mit PDO</title>

  <style>

    body {font-family: Arial, sans-serif;}

  </style>

</head>

<body>

<h2>Kunde eintragen (PDO)</h2>

<!--

Formular zur Eingabe der Kundendaten.

method="post" legt fest, dass die Formulardaten mit der HTTP-Methode POST übertragen werden. Da kein action-Attribut angegeben ist, werden die Daten an dieselbe Adresse gesendet, unter der das Formular aufgerufen wurde. Dadurch verarbeitet dieses PHP-Programm die Formulardaten selbst.

-->

<form method="post">

    <label for="kuNr">Kundennummer:</label>

    <input type="number" id="kuNr" name="kuNr" min="1" required>

    <br><br>

    <label for="name">Name:</label>

    <input type="text" id="name" name="name" maxlength="10" required>

    <br><br>

    <label for="vorname">Vorname:</label>

    <input type="text" id="vorname" name="vorname" maxlength="10"

      required>

    <br><br>

<!-- Schaltfläche zum Absenden des Formulars. -->

    <button type="submit">Speichern</button>

  </form>

<!--

Wenn eine Rückmeldung vorliegt, wird sie in Fettschrift ausgegeben.

Zu htmlspecialchars() vgl. den Anhang.

-->

  <?php if ($message !== ""): ?>

  <p><strong>

    <?php echo htmlspecialchars($message,ENT_QUOTES,"UTF-8"); ?>

  </strong>

  </p>

<?php endif; ?>

</body>

</html>

3.3.3 Programmlauf

Zum Nachvollziehen des Programmlaufs wird zunächst mit KundenEintragenMySQLi.php ein neuer Kunde angelegt. Seine Kundennummer darf in keinem Rechnungskopf vorkommen. Z.B. so:

Nach dem Aufruf von KundenLoeschenMySQLi.php erscheint eine Eingabemaske, in die die Kundennummer des zu löschenden Kunden eingetragen wird. Z.B. so:

Nach dem Betätigen der Schaltfläche "Löschen" sind drei Ergebnisse möglich:

• Ist der Kundendatensatz vorhanden und wird seine Kundennummer von keinem Rechnungskopf verwendet, wird der Datensatz gelöscht. Es erscheint die Meldung:

Datensatz wurde gelöscht.

• Ist kein Kunde mit der angegebenen Kundennummer vorhanden, erscheint die Meldung:

Kein Datensatz mit dieser Kundennummer gefunden.

• Wird die Kundennummer noch in der Relation RechKoepfe als Fremdschlüsselwert verwendet, verhindert das Datenbanksystem das Löschen. Das Programm gibt eine entsprechende Fehlermeldung aus.

Ein anschließender Blick auf die Relation kunden mit phpMyAdmin zeigt, ob der Datensatz gelöscht wurde.

3.3.4 Anmerkungen

• PDO ist eine weitgehend einheitliche Schnittstelle für den Zugriff auf unterschiedliche Datenbanksysteme. Durch mysql: im DSN wird in diesem Programm der MySQL-Treiber ausgewählt. Für ein anderes Datenbanksystem müssten der DSN und gegebenenfalls auch die verwendeten SQL-Anweisungen angepasst werden.
• Im Unterschied zur vorherigen MySQLi-Fassung wird der Zeichensatz bereits im DSN mit charset=utf8mb4 festgelegt.
• new PDO() erzeugt ein Objekt der Klasse PDO. Die Variable $pdo verweist auf dieses Verbindungsobjekt.
• PDO verwendet hier benannte Platzhalter wie :kuNr, :name und :vorname. Dadurch ist unmittelbar erkennbar, welcher Wert zu welchem Platzhalter gehört.
• Die Platzhalter werden nicht durch eine gewöhnliche Textersetzung ersetzt. Die Werte werden getrennt von der SQL-Anweisung an execute() übergeben. Dies schützt insbesondere vor SQL-Injection.
• Bei den Schlüsseln des an execute() übergebenen Arrays kann der Doppelpunkt weggelassen werden. Der Schlüssel "kuNr" gehört somit zum Platzhalter :kuNr.
• Weil PDO::ERRMODE_EXCEPTION aktiviert ist, löst PDO bei einem Datenbankfehler eine Ausnahme der Klasse PDOException aus. Der normale Ablauf des try-Blocks wird dadurch unterbrochen und im catch-Block fortgesetzt.
• Ein ausdrückliches Schließen des Statement-Objekts und der Datenbankverbindung ist bei PDO normalerweise nicht erforderlich. Die zugehörigen Ressourcen werden spätestens am Ende der Ausführung des PHP-Programms freigegeben. Bei Bedarf können die Variablen vorher auf null gesetzt werden.
• Die HTML-Attribute required, min und maxlength prüfen die Eingaben zunächst im Browser. Browserseitige Prüfungen können jedoch umgangen werden. Deshalb bleibt eine serverseitige Prüfung mit PHP erforderlich.
• Die PHP-Prüfung kontrolliert hier, ob die Kundennummer größer als 0 ist und ob Name und Vorname nicht leer sind. Die durch maxlength="10" vorgegebene Höchstlänge wird im vorliegenden PHP-Code allerdings nicht ausdrücklich geprüft.
• Das Programm benötigt keine ausdrücklich mit beginTransaction() gestartete Transaktion, weil nur ein einzelner Datensatz mit einer einzigen INSERT-Anweisung gespeichert wird. Eine einzelne SQL-Anweisung wird von der Datenbank vollständig ausgeführt oder im Fehlerfall nicht wirksam abgeschlossen.

Das Programm zeigt erneut das Zusammenspiel verschiedener Sprachen:

• HTML stellt das Eingabeformular bereit.
• PHP übernimmt und prüft die Eingaben und steuert den Programmablauf.
• SQL fügt den neuen Datensatz in die Relation kunden ein.
• PDO stellt die Verbindung zwischen PHP und dem Datenbanksystem her.

3.4 RechnungSpeichernPDO.php

3.4.1 Merkmale des Programms:

• Speichern zusammengehöriger Datensätze in zwei miteinander verknüpften Relationen
• Speichern eines Rechnungskopfes und mehrerer Rechnungspositionen
• Datenbankzugriff über PDO
• Verwendung einer Transaktion
• Umsetzung des Alles-oder-nichts-Prinzips
• Verwendung von Prepared Statements
• Verwendung benannter Platzhalter
• mehrfache Ausführung eines vorbereiteten Statements
• Speicherung der Rechnungspositionen in einem mehrdimensionalen Array
• Verarbeitung der Rechnungspositionen mit einer foreach-Schleife
• Plausibilitätsprüfung der Artikelanzahl
• Fehlerbehandlung mit try, catch und throw
• Zurücksetzen der Transaktion mit rollBack() im Fehlerfall
• Prüfung einer laufenden Transaktion mit inTransaction()
• Aufruf des Programms über den Browser
• unmittelbare Festlegung der Rechnungsdaten im PHP-Programm, also ohne HTML-Formular
• Ausgabe einer Erfolgs- oder Fehlermeldung im Browser

3.4.2 Aufgabe

Das Programm trägt eine vollständige Rechnung in die Datenbank KuReAr ein. Gespeichert werden der Rechnungskopf in der Relation RechKoepfe und die zugehörigen Rechnungspositionen in der Relation RechPos.

Transaktionen

Der Rechnungskopf enthält die Rechnungsnummer, die Kundennummer und das Rechnungsdatum. Die Kundennummer verweist auf einen bereits vorhandenen Datensatz in der Relation Kunden. Der Kundendatensatz selbst wird durch dieses Programm nicht neu gespeichert.

Eine Rechnung bildet mit ihren Rechnungspositionen eine fachliche Einheit. Der Rechnungskopf und sämtliche Rechnungspositionen müssen daher entweder vollständig oder gar nicht gespeichert werden. Dies wird durch eine Transaktion sichergestellt. Tritt beim Speichern einer Rechnungsposition ein Fehler auf, werden auch der bereits gespeicherte Rechnungskopf und alle zuvor gespeicherten Positionen zurückgenommen. Nur wenn sämtliche Anweisungen erfolgreich ausgeführt wurden, schließt commit() die Transaktion erfolgreich ab.

Die Rechnungsdaten werden in diesem Beispiel unmittelbar im PHP-Programm festgelegt. Eine Eingabe über ein HTML-Formular findet nicht statt. Die neue Rechnung hat die Rechnungsnummer 23002. Sie gehört zum Kunden mit der Kundennummer 1010 und enthält die Artikel mit den Artikelnummern 100, 101 und 102. Nach dem erfolgten Eintrag soll folgende Abfrage möglich sein:

SELECT r.ReNr, r.KuNr, r.reDatum, p.PosNr, p.ArtNr, p.Anzahl, k.Name,

    k.Vorname FROM rechkoepfe r, rechpos p, kunden k

where r.kunr=k.kunr and r.renr=p.ReNr and r.renr=23002;

3.4.3 Das Programm

<?php

/*

Das Programm speichert einen Rechnungskopf und die zugehörigen Rechnungspositionen in einer Transaktion. Dadurch wird sichergestellt, dass die Rechnung entweder vollständig oder gar nicht in der Datenbank gespeichert wird.

Daten für den Verbindungsaufbau.

DSN bedeutet Data Source Name. Diese Zeichenkette enthält:

- den verwendeten Datenbanktreiber: mysql

- den Datenbankserver: localhost

- die Bezeichnung der Datenbank: KuReAr

- den Zeichensatz: utf8mb4

*/

$dsn = "mysql:host=localhost;dbname=KuReAr;charset=utf8mb4";

$user = "root";

$pass = "";

/*

Zentrale Daten des neuen Rechnungskopfes.

In einer Webanwendung würden diese Werte üblicherweise aus einem Formular stammen.

*/

$reNr = 23002;

$kuNr = 1010;

$reDatum = "2026-03-28";

/*

Daten der Rechnungspositionen. Das äußere Array enthält die Rechnungspositionen als Ganzes. Jedes innere Array beschreibt eine einzelne Position.

*/

$positionen = [["posNr" => 1,"artNr" => 100,"anzahl" => 2],

    ["posNr" => 2,"artNr" => 101,"anzahl" => 1],

    ["posNr" => 3,"artNr" => 102,"anzahl" => 5]];

try {

/*

Verbindung zur Datenbank aufbauen.

PDO steht für PHP Data Objects. Die Variable $pdo verweist auf das erzeugte PDO-Objekt.

PDO::ERRMODE_EXCEPTION bewirkt, dass PDO bei einem Datenbankfehler eine Exception auslöst.

*/

  $pdo = new PDO($dsn,$user,$pass,

  [PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);

/*

Transaktion starten. Alle folgenden Datenbankoperationen gehören nun zu einer gemeinsamen Arbeitseinheit. Dauerhaft gespeichert werden die Änderungen erst durch commit().

*/

  $pdo->beginTransaction();

/*

Prepared Statement für den Rechnungskopf vorbereiten.

:reNr, :kuNr und :reDatum sind benannte Platzhalter. Sie werden beim Aufruf von execute() mit konkreten Werten verbunden.

*/

  $stmtKopf = $pdo->prepare(

  "INSERT INTO rechkoepfe (ReNr, KuNr, ReDatum)

  VALUES (:reNr, :kuNr, :reDatum)");

/*

Prepared Statement für den Rechnungskopf ausführen.

Das assoziative Array ordnet jedem benannten Platzhalter den zugehörigen Wert zu.

*/

  $stmtKopf->execute(["reNr" => $reNr,"kuNr" => $kuNr,

    "reDatum" => $reDatum]);

/*

Prepared Statement für die Rechnungspositionen vorbereiten.

Das Statement wird nur einmal vorbereitet und danach für jede Rechnungsposition erneut ausgeführt.

*/

$stmtPos = $pdo->prepare("INSERT INTO rechpos

  (ReNr, PosNr, ArtNr, Anzahl) VALUES

    (:reNr, :posNr, :artNr, :anzahl)");

// Rechnungspositionen nacheinander bearbeiten.

foreach ($positionen as $p) {

// Werte der aktuellen Rechnungsposition übernehmen und in ganze

// Zahlen umwandeln.

    $posNr = (int)$p["posNr"];

    $artNr = (int)$p["artNr"];

    $anzahl = (int)$p["anzahl"];

// Einfache Plausibilitätsprüfung.

// Eine Anzahl kleiner oder gleich 0 soll nicht gespeichert werden.

    if ($anzahl <= 0) {throw new Exception(

    "Anzahl muss größer als 0 sein " . "(PosNr $posNr).");}

// Prepared Statement für die aktuelle Rechnungsposition ausführen.

  $stmtPos->execute(["reNr" => $reNr,"posNr" => $posNr,

    "artNr" => $artNr,"anzahl" => $anzahl]);

}

// Transaktion erfolgreich abschließen. Erst durch commit() werden der

//der Rechnungskopf und sämtliche Rechnungspositionen dauerhaft gespeichert.

  $pdo->commit();

  echo "Rechnung erfolgreich gespeichert.";

} catch (Exception $e) {

/*

Prüfen, ob das PDO-Objekt vorhanden und noch eine Transaktion aktiv ist. Ist dies der Fall, werden mit rollBack() sämtliche Änderungen seit beginTransaction() zurückgenommen.

*/

  if (isset($pdo) && $pdo->inTransaction()) {

    $pdo->rollBack();

  }

// Fehlermeldung ausgeben.

    echo "Fehler beim Speichern. " . "Alles wurde zurückgesetzt: "

      . $e->getMessage();

}

?>

3.4.4 Programmlauf

Nach einem erfolgreichen Programmlauf erscheint im Browser folgende Meldung:

Rechnung erfolgreich gespeichert.

Die Kontrollabfrage zeigt anschließend den neu eingefügten Rechnungskopf und seine drei Rechnungspositionen. Soll das Programm mit denselben Daten erneut erfolgreich ausgeführt werden, muss die Rechnung mit der Rechnungsnummer 23002 zuvor gelöscht werden. Wegen der Fremdschlüsselbeziehung sind zuerst die Rechnungspositionen und danach der Rechnungskopf zu löschen:

DELETE FROM RechPos

WHERE ReNr = 23002;

DELETE FROM RechKoepfe

WHERE ReNr = 23002;

3.4.5 Anmerkungen

• Die Positionsnummer, die Artikelnummer und die Anzahl werden vor der Prüfung und Speicherung ausdrücklich mit (int) in ganze Zahlen umgewandelt.
• Das Prepared Statement für die Rechnungspositionen wird nur einmal vorbereitet. Innerhalb der Schleife wird es anschließend mit jeweils anderen Werten mehrfach ausgeführt. Dadurch muss das Datenbanksystem die SQL-Anweisung nicht für jede Position erneut vorbereiten.
• Die benannten Platzhalter :reNr, :posNr, :artNr und :anzahl werden beim Aufruf von execute() mit den entsprechenden Werten verbunden. Die SQL-Anweisung und die einzusetzenden Werte werden dadurch getrennt verarbeitet.
• commit() schließt die Transaktion erfolgreich ab und übernimmt alle zu ihr gehörenden Änderungen dauerhaft. Bei einem Fehler nimmt rollBack() sowohl den Rechnungskopf als auch bereits eingefügte Rechnungspositionen zurück.
• inTransaction() prüft, ob gegenwärtig eine Transaktion aktiv ist. Dadurch wird verhindert, dass rollBack() aufgerufen wird, obwohl keine Transaktion begonnen wurde oder die Transaktion bereits abgeschlossen ist.
• Durch die Kurzschlussauswertung des UND-Operators && wird $pdo->inTransaction() nur aufgerufen, wenn die Variable $pdo vorhanden ist und nicht null enthält.
• Der Kunde mit der Kundennummer 1010 muss bereits in der Relation Kunden vorhanden sein. Ebenso müssen die Artikelnummern 100, 101 und 102 in der Relation Artikel existieren. Andernfalls verhindern die Fremdschlüssel das Speichern der Rechnung.
• Die Rechnungsnummer 23002 darf in der Relation RechKoepfe noch nicht vorhanden sein, wenn ReNr Primärschlüssel ist oder einer anderen eindeutigen Einschränkung unterliegt.
• Eine ausdrücklich mit beginTransaction() gestartete Transaktion ist hier erforderlich, weil mehrere SQL-Anweisungen zu einer gemeinsamen fachlichen Einheit gehören.

3.4.6 Programmbeschreibung

Das Programm realisiert das Eintragen einer vollständigen Rechnung mit PDO und verwendet dabei eine Transaktion. Das ist notwendig, weil eine Rechnung aus zwei zusammengehörigen Teilen besteht: aus dem Rechnungskopf in der Relation rechkoepfe und aus den Rechnungspositionen in der Relation rechpos. Beide Teile müssen vollständig gespeichert werden. Es darf also nicht vorkommen, dass zwar der Rechnungskopf eingetragen wird, einzelne Positionen aber wegen eines Fehlers fehlen.

Zu Beginn werden die Verbindungsdaten zur Datenbank in der Variablen $dsn sowie in $user und $pass festgelegt. Danach folgen die Daten des neuen Rechnungskopfes, also Rechnungsnummer, Kundennummer und Rechnungsdatum. Die zugehörigen Positionen werden in einem mehrdimensionalen Array gespeichert. Jedes innere Array steht dabei für genau eine Rechnungsposition mit Positionsnummer, Artikelnummer und Anzahl.

Anschließend beginnt ein try/catch-Block. Im try-Teil wird zunächst ein PDO-Objekt erzeugt, das die Verbindung zur Datenbank herstellt. Die Eingabe

PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION

bewirkt, dass PDO bei Fehlern Exceptions auslöst. Dadurch können Fehler zentral im catch-Teil behandelt werden.

Nach dem Verbindungsaufbau wird mit beginTransaction() eine Transaktion gestartet. Ab diesem Zeitpunkt gehören alle folgenden Änderungen zu einer gemeinsamen Arbeitseinheit. Dauerhaft in der Datenbank gespeichert werden sie erst dann, wenn am Ende commit() ausgeführt wird.

Danach wird ein Prepared Statement für den Rechnungskopf vorbereitet. In der SQL-Anweisung stehen mit :reNr, :kuNr und :reDatum sogenannte named parameter. Das sind Platzhalter, die erst beim Aufruf von execute() mit konkreten Werten belegt werden. Auf diese Weise werden SQL-Anweisung und Daten voneinander getrennt.

Im nächsten Schritt wird ein zweites Prepared Statement für die Rechnungspositionen vorbereitet. Dieses Statement wird nur einmal erzeugt und anschließend in der Schleife für jede Position erneut verwendet. Die foreach-Schleife durchläuft nacheinander alle Positionen des Arrays $positionen. Vor dem Eintragen wird hier noch ein einfacher Plausibilitätscheck durchgeführt: Die Anzahl muss größer als 0 sein. Ist das nicht der Fall, wird mit throw new Exception(...) eine Exception ausgelöst. Dadurch wird der normale Programmablauf sofort unterbrochen, und die Verarbeitung springt in den catch-Block.

Wenn dagegen alle Positionen korrekt eingetragen werden konnten, wird am Ende mit commit() die gesamte Transaktion dauerhaft gespeichert. Erst in diesem Moment werden also Rechnungskopf und Rechnungspositionen verbindlich in die Datenbank übernommen.

Tritt irgendwo im try-Block ein Fehler auf, so wird der catch-Block ausgeführt. Dort wird mit rollBack() die laufende Transaktion vollständig zurückgenommen. Damit werden alle bis dahin vorgenommenen Änderungen rückgängig gemacht. Genau das ist der entscheidende Vorteil der Transaktion: Die Rechnung wird entweder vollständig gespeichert oder gar nicht. Auf diese Weise bleiben die Daten in der Datenbank konsistent.

4 Löschen von Daten

Hier wird jeweils zuerst das Löschen in einer einzigen Relation (Kunden) und dann das Löschen in mehreren zusammenhängenden (Rechnung) gezeigt. Zuerst mit MySQLi, dann mit PDO.

4.1 KundenLoeschenMySQLi.php

4.1.1 Merkmale des Programms:

• Löschen eines Kundendatensatzes aus der Relation kunden
• Eingabe der Kundennummer über ein HTML-Formular
• Übermittlung der Kundennummer mit der HTTP-Methode POST
• Datenbankzugriff mit der Klasse mysqli
• Verwendung eines Prepared Statements
• Bindung der Kundennummer mit bind_param()
• Schutz vor SQL-Injection
• Ausführung einer DELETE-Anweisung
• Prüfung des Ergebnisses mit affected_rows
• Unterscheidung zwischen "Datensatz gelöscht" und "Datensatz nicht gefunden"
• Beachtung vorhandener Fremdschlüsselbeziehungen
• Ausgabe einer Erfolgs- oder Fehlermeldung im Browser
• sichere HTML-Ausgabe der Meldung mit htmlspecialchars()
• Schließen des Statement-Objekts und der Datenbankverbindung

Zum Nachvollziehen: Zuerst einen Kunden anlegen ohne Fremdschlüsselbeziehungen zu Rechnungsköpfen, z.B. mit dem Programm KundenEintragenMySQLi.php. Dieser "isolierte" Kundendatensatz kann anschließend mit dem Programm KundenLoeschenMySQLi.php wieder gelöscht werden.

4.1.2 Das Programm

<?php

// Variable für Rückmeldungen an den Benutzer. Sie speichert die Erfolgs-

// oder Fehlermeldungen, die später im HTML-Abschnitt ausgegeben werden.

$message = "";

// Daten für den Verbindungsaufbau.

$host = "localhost";

$user = "root";

$pass = "";

$db = "KuReAr";

// Prüfen, ob das Formular mit der HTTP-Methode POST

// abgeschickt wurde.

if ($_SERVER["REQUEST_METHOD"] === "POST") {

/*

Kundennummer aus dem Formular übernehmen. Der Operator ?? liefert 0, wenn der Formulareintrag fehlt. (int) wandelt den übernommenen Wert in eine ganze Zahl um.

*/

$kuNr = (int)($_POST["kuNr"] ?? 0);

// Eingabe prüfen. Die Kundennummer muss größer als 0 sein.

if ($kuNr <= 0) {

  $message = "Bitte eine gültige Kundennummer eingeben.";

  } else {

// Verbindung zur Datenbank aufbauen.

// Die Variable $con verweist auf das erzeugte mysqli-Objekt.

$con = new mysqli($host, $user, $pass, $db);

// Prüfen, ob beim Verbindungsaufbau ein Fehler aufgetreten ist.

// die() gibt die Meldung aus und beendet das Programm.

  if ($con->connect_error) {die("DB-Verbindung fehlgeschlagen: "

    . $con->connect_error);

}

// Zeichensatz für die Datenbankverbindung festlegen,

// damit Sonderzeichen korrekt verarbeitet werden.

$con->set_charset("utf8mb4");

// SQL-Anweisung vorbereiten.

// Das Fragezeichen dient als Platzhalter für die Kundennummer.

    $stmt = $con->prepare("DELETE FROM kunden WHERE KuNr = ?");

// Prüfen, ob das Prepared Statement erstellt werden konnte.

if (!$stmt) {

  $message = "Prepare fehlgeschlagen: " . $con->error;

} else {

// Kundennummer an den Platzhalter binden.

// "i" bezeichnet den Datentyp Integer.

$stmt->bind_param("i", $kuNr);

// Prepared Statement ausführen.

if ($stmt->execute()) {

/*

affected_rows enthält nach der Ausführung der Delete-Anweisung die Anzahl der tatsächlich gelöschten Datensätze.

Wert 1: Ein Datensatz wurde gelöscht; Wert 0: Es wurde kein Datensatz mit dieser Kundennummer gefunden. Hier sind nur 0 und 1 möglich, da KuNr Primärschlüssel ist.

*/

  if ($stmt->affected_rows > 0) {

    $message = "Datensatz wurde gelöscht.";

    } else {$message = "Kein Datensatz mit dieser "

      . "Kundennummer gefunden.";

    }

  } else {$message = "Fehler beim Löschen: "

    . $stmt->error;

  }

// Prepared Statement schließen und die dafür verwendeten Ressourcen

// freigeben.

  $stmt->close();

}

// Datenbankverbindung schließen und die damit verbundenen

// Ressourcen freigeben.

  $con->close();

  }

}

?>

<!doctype html>

<html lang="de">

<head>

<meta charset="utf-8">

<title>Kunde löschen mit MySQLi</title>

  <style>

    body {font-family: Arial, sans-serif;}

  </style>

</head>

<body>

<h2>Kunde löschen (MySQLi)</h2>

<!--

Formular zur Eingabe der Kundennummer.

method="post" legt fest, dass die Formulardaten mit der HTTP-Methode POST übertragen werden. Da kein action-Attribut angegeben ist, werden die Daten an dieselbe Adresse gesendet, unter der das Formular aufgerufen wurde. Dadurch verarbeitet dieses PHP-Programm die Formulardaten selbst.

-->

<form method="post">

<label for="kuNr">Kundennummer:</label>

    <input type="number" id="kuNr" name="kuNr" min="1" required>

<button type="submit">Löschen</button>

</form>

<!--Zu htmlspecialchars() vgl. den Anhang.-->

<?php if ($message !== ""): ?>

  <p><strong>

  <?php echo htmlspecialchars($message,ENT_QUOTES,"UTF-8");?>

  </strong>

  </p>

<?php endif; ?>

</body>

</html>

4.1.3 Programmlauf

Zum Nachvollziehen des Programmlaufs wird zunächst mit KundenEintragenMySQLi.php ein neuer Kunde angelegt. Seine Kundennummer darf in keinem Rechnungskopf vorkommen.

Nach dem Aufruf von KundenLoeschenMySQLi.php erscheint eine Eingabemaske, in die die Kundennummer des zu löschenden Kunden eingetragen wird.

Nach dem Betätigen der Schaltfläche "Löschen" sind drei Ergebnisse möglich:

• Ist der Kundendatensatz vorhanden und wird seine Kundennummer von keinem Rechnungskopf verwendet, wird der Datensatz gelöscht. Es erscheint die Meldung:

Datensatz wurde gelöscht.

• Ist kein Kunde mit der angegebenen Kundennummer vorhanden, erscheint die Meldung:

Kein Datensatz mit dieser Kundennummer gefunden.

• Wird die Kundennummer noch in der Relation RechKoepfe als Fremdschlüsselwert verwendet, verhindert das Datenbanksystem das Löschen. Das Programm gibt eine entsprechende Fehlermeldung aus.

Ein anschließender Blick auf die Relation kunden mit phpMyAdmin zeigt, ob der Datensatz gelöscht wurde.

Wichtig: Geben Sie die Kundennummer eines Kunden an, zu dem keine Rechnungsköpfe vorhanden sind. Seine Kundennummer darf also in keinem Datensatz der Relation RechKoepfe vorkommen.

4.2 RechnungLoeschenMySQLi.php

4.2.1 Merkmale des Programms

• Löschen einer vollständigen Rechnung
• Löschen zusammengehöriger Datensätze aus den Relationen RechPos und RechKoepfe
• Beachtung einer Primärschlüssel-/Fremdschlüsselbeziehung
• Datenbankzugriff mit der Klasse mysqli
• Eingabe der Rechnungsnummer über ein HTML-Formular
• Übermittlung der Rechnungsnummer mit der HTTP-Methode POST
• Verwendung einer Transaktion
• Umsetzung des Alles-oder-nichts-Prinzips
• Verwendung mehrerer Prepared Statements
• Bindung der Rechnungsnummer mit bind_param()
• Prüfung, ob die angegebene Rechnung vorhanden ist
• Ermittlung der Anzahl gelöschter Datensätze mit affected_rows
• Fehlerbehandlung mit try, catch und throw
• Zurücksetzen der Änderungen mit rollback() im Fehlerfall
• Abschluss der Transaktion mit commit()
• sichere HTML-Ausgabe der Rückmeldung mit htmlspecialchars()

4.2.2 Aufgabe

Das Programm löscht eine vollständige Rechnung aus der Datenbank KuReAr. Dazu werden zunächst die Rechnungspositionen aus der Relation RechPos und anschließend der Rechnungskopf aus der Relation RechKoepfe gelöscht.

Transaktionen

Die Rechnungspositionen müssen zuerst gelöscht werden, weil ihre Rechnungsnummer als Fremdschlüssel auf den Rechnungskopf verweist. Solange Rechnungspositionen vorhanden sind, darf der zugehörige Rechnungskopf nicht gelöscht werden, sofern die Fremdschlüsselbeziehung nicht mit ON DELETE CASCADE definiert wurde.

Zum Löschen einer Rechnung sind somit mehrere zusammengehörige SQL-Anweisungen erforderlich. Deshalb werden die Löschvorgänge innerhalb einer Transaktion ausgeführt. Entweder werden der Rechnungskopf und alle seine Positionen gelöscht oder keine der Änderungen wird dauerhaft übernommen.

Die Rechnungsnummer wird über ein HTML-Formular eingegeben. Das Programm wird daher über den Browser und nicht über die Konsole aufgerufen.

Im folgenden Beispiel wird die Rechnung 23001 des fiktiven Kunden Rudolf Hinterhof gelöscht. Die Rechnung besitzt zwei Rechnungspositionen.

SELECT r.ReNr, r.KuNr, r.ReDatum, p.PosNr, p.ArtNr, p.Anzahl, k.Name,

  k.Vorname FROM rechkoepfe r, rechpos p, kunden k

where r.kunr=k.kunr and r.renr=p.ReNr and r.renr=23001;

4.2.3 Das Programm

<?php

// Daten für den Verbindungsaufbau. Oben schon mehrfach beschrieben

$host = "localhost";

$user = "root";

$pass = "";

$db = "KuReAr";

// Variable für Rückmeldungen an den Benutzer.

$message = "";

// Verbindung zur Datenbank aufbauen.

// Die Variable $con verweist auf das erzeugte mysqli-Objekt.

$con = new mysqli($host, $user, $pass, $db);

// Prüfen, ob beim Verbindungsaufbau ein Fehler aufgetreten ist.

// die() gibt die Meldung aus und beendet das Programm.

if ($con->connect_error) {

  die("DB-Verbindung fehlgeschlagen: " . $con->connect_error);

}

// Zeichensatz für die Datenbankverbindung festlegen.

$con->set_charset("utf8mb4");

// Prüfen, ob das Formular mit der HTTP-Methode POST

// abgeschickt wurde.

if ($_SERVER["REQUEST_METHOD"] === "POST") {

/*

Rechnungsnummer aus dem Formular übernehmen.

Der Operator ?? liefert 0, wenn der Formulareintrag fehlt. (int) wandelt den übernommenen Wert in eine ganze Zahl um.

*/

$reNr = (int)($_POST["reNr"] ?? 0);

// Eingabe prüfen. Die Rechnungsnummer muss größer als 0 sein.

if ($reNr <= 0) {

  $message = "Bitte eine gültige Rechnungsnummer eingeben.";

  } else {

// Festhalten, ob gegenwärtig eine Transaktion aktiv ist.

$transaktionAktiv = false;

try {

// Transaktion starten. Alle folgenden Löschoperationen gehören