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

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 tatsächlich 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 die PHP-Variablen an die Platzhalter der SQL-Anweisung. Das Zeichen & kennzeichnet die Übergabe als Referenz. Deshalb müssen Variablen und keine unmittelbar angegebenen Werte ü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-Elements.

*/

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 in Relationale Datenbanken Daten eingetragen werden. Zuerst am Beispiel MySQLi, dann mit PDO.

3.1 KundenEintragenMySQLi

3.1.1 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() ("sterben!") 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.2 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.

3.2 RechnungSpeichernMySQLi

3.2.1 Merkmale des Programms

• Speichern in mehreren verknüpften Dateien
• Transaktionen
• Klasse MySQLi

3.2.2 Aufgabe

Es wird eine Rechnung in die Datenbank KuReAr eingetragen, konkret der Rechnungskopf mit seinen Positionen sowie die Kundennummer. Insgesamt macht das Transaktionen nötig, deren Realisierung damit hier ebenfalls gezeigt wird. Realisiert wird das mit Hilfe des Programmes RechnungSpeichernMySQLi.php, diesmal ohne Eingabe über die Webseite.

Transaktionen

Die neue Rechnung hat die Rechnungsnummer 23012, bezieht sich auf den Kunden mit der Kundennummer 1002 und eingekauft werden 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.kunr=1002

      and r.renr=23012;

Anmerkung: Um die Rechnung speichern zu können sollten die oben angeführten Einträge in kunden (Kundenummer 1002) und artikel (Artikelnummern 100, 101 und 102) in der Datenbank vorhanden sein. In rechnung darf die Rechnungsnummer 23012 noch nicht vergeben sein.

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();

  }

}

?>

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

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

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 PHP-Datei gesendet (d.h. an die, von

der der Aufruf kommt.

-->

<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 Anmerkungen

• PDO ist eine einheitliche Schnittstelle für den Zugriff auf unterschiedliche Datenbanksysteme. Hier wird durch mysql: im DSN der MySQL-Treiber ausgewählt.
• Im Unterschied zur vorherigen MySQLi-Fassung wird der Zeichensatz bereits im DSN mit charset=utf8mb4 festgelegt.
• PDO verwendet hier benannte Platzhalter wie :kuNr. Dadurch ist unmittelbar erkennbar, welcher Wert an welcher Stelle eingesetzt wird.
• Die Werte werden getrennt von der SQL-Anweisung an execute() übergeben. Das schützt insbesondere vor SQL-Injection.
• Weil PDO::ERRMODE_EXCEPTION aktiviert ist, verzweigt das Programm bei einem Datenbankfehler unmittelbar in den catch-Block.
• Ein ausdrückliches Schließen von Statement und Datenbankverbindung ist bei PDO normalerweise nicht erforderlich. Die zugehörigen Ressourcen werden spätestens am Ende der Skriptausführung freigegeben.
• required, min und maxlength prüfen Eingaben zunächst im Browser. Die Prüfung in PHP bleibt dennoch erforderlich, weil Browserprüfungen umgangen werden können.
• Das Programm benötigt keine Transaktion, weil nur ein einzelner Datensatz mit einer einzigen INSERT-Anweisung gespeichert wird. Eine einzelne SQL-Anweisung wird von der Datenbank bereits als unteilbare Operation behandelt.

3.4 RechnungSpeichernPDO.php

3.4.1 Merkmale des Programms:

• Speichern verknüpfter Relationen ("Rechnung")
• Verwendete Klasse für Verbindungsaufbau: PDO
• Transaktionen
• Absicherung durch Prepared Statements
• Start durch Browser-Befehl
• HTML-Ausgabe des Ergebnisses

3.4.2 Aufgabe

Es wird eine Rechnung in die Datenbank KuReAr eingetragen, konkret der Rechnungskopf mit seinen Positionen sowie die Kundennummer. Insgesamt macht das Transaktionen nötig, deren Realisierung damit hier ebenfalls gezeigt wird. Realisiert wird das mit Hilfe des Programmes RechnungSpeichernPDO.php, diesmal ohne Eingabe über die Webseite.

Transaktionen

Die neue Rechnung hat die Rechnungsnummer 23002, bezieht sich auf den Kunden mit der Kundennummer 1010 und eingekauft werden 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 = 23011;

$kuNr = 1004;

$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 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();

}

?>

Daran denken: Ein wiederholter Programmlauf erfordert das Löschen der obigen Rechnung.

3.4.4 Anmerkungen

• Die Positionswerte werden vor ihrer Prüfung und Speicherung ausdrücklich in int umgewandelt.
• Das Prepared Statement für die Positionen wird nur einmal vorbereitet. Innerhalb der Schleife wird es mit jeweils anderen Werten mehrfach ausgeführt.
• commit() speichert alle Änderungen der Transaktion dauerhaft. Bei einem Fehler nimmt rollBack() sowohl den Rechnungskopf als auch bereits eingefügte Rechnungspositionen zurück.
• inTransaction() verhindert, dass rollBack() aufgerufen wird, obwohl keine aktive Transaktion besteht.
• Die Kundennummer 1004 muss bereits in kunden vorhanden sein. Ebenso müssen die Artikelnummern 100, 101 und 102 in der Artikelrelation existieren. Andernfalls verhindert ein Fremdschlüssel das Speichern.
• Auch die Rechnungsnummer 23011 darf noch nicht vorhanden sein, wenn ReNr Primärschlüssel oder eindeutig ist.

3.4.5 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:

• Verwendete Klasse für Verbindungsaufbau: mysqli
• Löschen in einer Relation (Kunden)
• Absicherung durch Prepared Statements
• Start durch Browser-Befehl
• HTML-Ausgabe des Ergebnisses

Zum Nachvollziehen: Zuerst einen Kunden anlegen ohne Fremdschlüsselbeziehungen zu Rechnungsköpfen, z.B. mit dem Programm KundenEintragenMySQLi.php. Der kann dann mit diesem Programm gelöscht werden.

4.1.2 Das Programm

<?php

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

// Sie speichert 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 die Anzahl der Datensätze, die durch die

// DELETE-Anweisung gelöscht wurden.

  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 sie an die sendende PHP-Datei gesendet.

-->

<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

Wichtig: Geben Sie einen Kunden an, der nicht durch Schlüssel-/Fremdschlüsselbeziehungen eingebunden ist. Also: Mit obigem Programm KundenEintragen einen "isolierten" Kunden eintragen und diesen dann hier löschen.

So sieht die Eingabemaske aus.

4.2 RechnungLoeschenMySQLi.php

4.2.1 Merkmale des Programms

• Verwendete Klasse für Verbindungsaufbau: mysqli
• Löschen in mehreren relational verknüpften Dateien der Datenbank KuReAr
• Durchführung einer Transaktion
• Absicherung durch ein Prepared Statement
• Start durch ein Formular
• HTML-Ausgabe des Ergebnisses

4.2.2 Aufgabe

Hier wird eine Rechnung in der Datenbank KuReAr gelöscht, d.h., der Rechnungskopf mit seinen Positionen. Insgesamt macht das Transaktionen nötig, deren Realisierung damit hier ebenfalls gezeigt wird. Realisiert wird das mit Hilfe des Programmes RechnungLoeschenMySQLi.php. Das Programm soll über die Konsole gestartet werden.

Transaktionen

Das folgende Beispiel wird unten verwendet, eine Rechnung des (natürlich) fiktiven Kunden Rudolf Hinterhof mit zwei Positionen.

SELECT r.ReNr, r.KuNr, r.Datum, 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;

Die Webseite für die Dateneingabe soll wie folgt sein:

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 {

// try/catch-Block zum Abfangen möglicher Fehler.

try {

// Transaktion starten. $con ist das MySQLi-Verbindungsobjekt.

// Alle folgenden Löschoperationen werden dadurch zu

// einer gemeinsamen Einheit zusammengefasst.

$con->begin_transaction();

/*

Prüfen, ob ein Rechnungskopf mit der eingegebenen Rechnungsnummer

existiert.

$stmtCheck verweist auf ein Statement-Objekt der Klasse mysqli_stmt.

Die Methode prepare() erzeugt ein Prepared Statement. Das

Fragezeichen dient als Platzhalter für die Rechnungsnummer.

*/

$stmtCheck = $con->prepare("SELECT 1 FROM rechkoepfe

  WHERE ReNr = ?");

// Prüfen, ob das Prepared Statement erstellt wurde.

    if (!$stmtCheck) {throw new Exception(

    "Prepare fehlgeschlagen (Prüfung): " . $con->error);

}

// Rechnungsnummer an den Platzhalter binden.

// "i" bezeichnet den Datentyp Integer.

$stmtCheck->bind_param("i", $reNr);

// Prepared Statement ausführen.

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

  throw new Exception("Execute fehlgeschlagen (Prüfung): "

    . $stmtCheck->error

  );

}

// Ergebnismenge zwischenspeichern, damit anschließend

// die Anzahl der gefundenen Zeilen ermittelt werden kann.

$stmtCheck->store_result();

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

if ($stmtCheck->num_rows === 0) {$stmtCheck->close();

// Es gibt nichts zu löschen. Die Transaktion wird

// ohne dauerhafte Änderungen beendet.

$con->rollback();

$message = "Keine Rechnung mit ReNr = $reNr gefunden.";

  } else {

    $stmtCheck->close();

/*

1. Die zur Rechnung gehörenden Positionen löschen.

Die Positionen müssen vor dem Rechnungskopf gelöscht werden, falls

der Fremdschlüssel nicht mit ON DELETE CASCADE definiert wurde.

*/

    $stmtPosDel = $con->prepare("DELETE FROM rechpos

      WHERE ReNr = ?");

    if (!$stmtPosDel) {throw new Exception("Prepare fehlgeschlagen "

      . "(Positionen löschen): " . $con->error);

}