php mit Adi Prinz

Beispiele für PHP Datenbanken

PHP ist eine serverseitige Skriptsprache, die weit verbreitet ist, um dynamische Webseiten und Webanwendungen zu erstellen. PHP kann nahtlos mit Datenbanken integriert werden, um Daten zu speichern, abzurufen und zu manipulieren.

• Verbindung herstellen: PHP stellt eine Verbindung zur Datenbank her.
• Abfragen ausführen: SQL-Befehle werden ausgeführt, um Daten zu erstellen, zu lesen, zu aktualisieren oder zu löschen (CRUD-Operationen).
• Ergebnisse verarbeiten: Die Ergebnisse der Abfragen werden verarbeitet und können auf der Webseite angezeigt oder weiterverarbeitet werden.
• Verbindung schließen: Die Datenbankverbindung wird geschlossen, um Ressourcen zu sparen.

Was ist CRUD?

CRUD steht für die vier grundlegenden Operationen, die auf Daten in einer Datenbank durchgeführt werden können:
CRUD ist ein Akronym für Create, Read, Update, and Delete.

Read (Lesen)

Lesen oder Abrufen von Daten aus der Datenbank. Dies wird typischerweise durch die SELECT-SQL-Anweisung erreicht.

Create (Erstellen)

Erstellen eines neuen Datensatzes in der Datenbank. Dies wird normalerweise durch die INSERT-SQL-Anweisung erreicht.

Update (Aktualisieren)

Aktualisieren bestehender Datensätze in der Datenbank. Dies erfolgt durch die UPDATE-SQL-Anweisung.

Delete (Löschen)

Löschen von Datensätzen aus der Datenbank. Dies wird durch die DELETE-SQL-Anweisung erreicht.

Grundlegende Operationen in diesem Skript

In diesem Skript lernen Sie drei Möglichkeiten für grundlegende Operationen im Umgang mit Datenbanken kennen:

1. Einfache Anweisung mit MySQLi
2. Anweisung mit MySQLi und Prepared Statements
3. Einfache Anweisung mit PDO

Unterschiede der beiden MySQLi-Varianten:

1. Sicherheit:

   • Einfache SELECT-Anweisung: Anfällig für SQL-Injections, wenn Benutzerinput direkt in die SQL-Abfrage eingebaut wird.
   • Prepared Statements: Sicherer gegen SQL-Injections, da Parameter getrennt von der SQL-Abfrage verarbeitet werden.

2. Parameterbindung:

   • Einfache SELECT-Anweisung: Parameter werden direkt in die SQL-Abfrage eingefügt.
   • Prepared Statements: Parameter werden mit bind_param gebunden und nicht direkt in die SQL-Abfrage eingefügt.

3. Performance:

   • Einfache SELECT-Anweisung: Kann bei wiederholten Abfragen langsamer sein, da die SQL-Abfrage jedes Mal neu geparst und kompiliert wird.
   • Prepared Statements: Kann bei wiederholten Abfragen schneller sein, da die Abfrage einmal geparst und kompiliert wird und dann mehrfach mit verschiedenen Parametern ausgeführt werden kann.

Verbindung mit MySQLi Prozedural

MySQLi (MySQL Improved) ist spezifisch für MySQL-Datenbanken.

$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung erstellen
$conn = mysqli_connect($servername, $username, $password, $database);

// Verbindung prüfen
if (!$conn) {
die("Verbindung fehlgeschlagen: " . mysqli_connect_error());
}
echo "Verbindung erfolgreich";

Datenbankverbindungsparameter festlegen:

$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

Verbindung mit MySQLi Objektorientiert

MySQLi (MySQL Improved) ist spezifisch für MySQL-Datenbanken.

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung erstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung prüfen
if ($conn->connect_error) {
die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}
echo "Verbindung erfolgreich";
?>

Datenbankverbindungsparameter festlegen:

$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

Diese Variablen enthalten die Informationen, die zur Verbindung mit der Datenbank erforderlich sind:

• $servername: Der Servername, auf dem die Datenbank läuft (hier localhost, was den lokalen Rechner bedeutet).
• $username: Der Benutzername, der für die Verbindung zur Datenbank verwendet wird (hier root).
• $password: Das Passwort für den angegebenen Benutzer (hier leer, was oft bei lokalen Entwicklungsumgebungen der Fall ist).
• $database: Der Name der Datenbank, mit der verbunden werden soll (hier test).

Verbindung zur Datenbank herstellen:

$conn = new mysqli($servername, $username, $password, $database);
    

Hier wird ein neues MySQLi-Objekt erstellt, das die Verbindung zur Datenbank herstellt. Die MySQLi-Konstruktorfunktion benötigt die zuvor definierten Verbindungsparameter.

Verbindung prüfen:

if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}
    

Diese Bedingung überprüft, ob ein Verbindungsfehler aufgetreten ist. Wenn ja, wird das Skript mit einer Fehlermeldung beendet. connect_error enthält die Beschreibung des Fehlers, falls die Verbindung fehlschlägt.

Erfolgreiche Verbindung melden:

echo "Verbindung erfolgreich";
    

Wenn die Verbindung erfolgreich hergestellt wurde, wird diese Nachricht ausgegeben.

Zusammengefasst

• Der Code stellt eine Verbindung zu einer MySQL-Datenbank her.
• Er verwendet die MySQLi-Erweiterung, um die Verbindung zu verwalten.
• Verbindungsparameter (Servername, Benutzername, Passwort und Datenbankname) werden festgelegt.
• Der Code prüft, ob die Verbindung erfolgreich war und gibt entweder eine Fehlermeldung oder eine Bestätigung der erfolgreichen Verbindung aus.

php.net/mysqli

Verbindung mit PDO

PDO (PHP Data Objects) ist eine Erweiterung von PHP, die eine einheitliche Schnittstelle zur Arbeit mit verschiedenen Datenbanken bietet. Hier sind die Hauptgründe und Szenarien, wann und warum Sie PDO verwenden sollten:

PDO unterstützt viele verschiedene Datenbanken (MySQL, PostgreSQL, SQLite, MSSQL, Oracle, etc.). Wenn Sie planen, Ihre Anwendung auf verschiedene Datenbanktypen zu portieren oder die Flexibilität zu haben, die Datenbank zu wechseln, erleichtert PDO diesen Prozess erheblich, da Sie denselben Code mit minimalen Änderungen verwenden können.

Sicherere Abfragen:

PDO unterstützt vorbereitete Anweisungen (prepared statements), die helfen, SQL-Injections zu verhindern. Dies ist ein entscheidender Vorteil gegenüber der Verwendung von Roh-SQL-Abfragen, die anfälliger für solche Angriffe sind.

Fehlerbehandlung:

PDO bietet eine flexible Fehlerbehandlung durch die Verwendung von Ausnahmen (Exceptions). Dies ermöglicht es Ihnen, Fehler auf eine einheitliche und kontrollierte Weise zu handhaben.

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

try {
    $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
    // Set the PDO error mode to exception
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Verbindung erfolgreich";
} catch(PDOException $e) {
    echo "Verbindung fehlgeschlagen: " . $e->getMessage();
}
?>

Grundstruktur

SELECT id, username, email
FROM users
WHERE active = 1
ORDER BY username ASC
LIMIT 10;

Auswahl der Spalten

Sie können spezifische Spalten auswählen, indem Sie ihre Namen angeben: SELECT Spalte1, Spalte2. Wenn Sie alle Spalten auswählen möchten, verwenden Sie SELECT *.

Angabe der Tabelle

Die Datenquelle wird durch die FROM-Klausel angegeben: FROM Tabelle.

Filtern der Ergebnisse

Die WHERE-Klausel wird verwendet, um nur die Datensätze auszuwählen, die bestimmte Bedingungen erfüllen: WHERE Bedingung.

Sortieren der Ergebnisse

Sie können die Ergebnisse mit ORDER BY sortieren: ORDER BY Spalte ASC|DESC.

Limitieren der Ergebnisse

Mit LIMIT können Sie die Anzahl der zurückgegebenen Datensätze begrenzen: LIMIT Anzahl.

Einfache SELECT-Anweisung mit MySQLi

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung herstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung prüfen
if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}

// SQL-Abfrage
$sql = "SELECT id, username, email FROM users";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
    // Ausgabe der Daten jeder Zeile
    while($row = $result->fetch_assoc()) {
        echo "id: " . $row["id"]. " - Name: " . $row["username"]. " - Email: " . $row["email"]. "
";
    }
} else {
    echo "0 Ergebnisse";
}

// Verbindung schließen
$conn->close();
?>
    

Verbindungsinformationen:
$servername, $username, $password, und $database enthalten die Informationen zur Datenbankverbindung.

Verbindung herstellen:
Mit new mysqli($servername, $username, $password, $database) wird eine Verbindung zur MySQL-Datenbank hergestellt. Falls die Verbindung fehlschlägt, gibt connect_error einen Fehler aus und die Verbindung wird abgebrochen.

SQL-Abfrage:
Die SQL-Abfrage wird in der Variablen $sql gespeichert: SELECT id, username, email FROM users. query($sql) führt die Abfrage aus und speichert das Ergebnis in $result.

Ergebnisse prüfen und ausgeben:
num_rows > 0 prüft, ob die Abfrage Ergebnisse liefert. Falls Ergebnisse vorhanden sind, werden diese mit fetch_assoc() Zeile für Zeile ausgelesen und die Werte der Felder id, username, und email ausgegeben. Falls keine Ergebnisse vorhanden sind, wird "0 Ergebnisse" ausgegeben.

Verbindung schließen:
close() schließt die Verbindung zur Datenbank.

Einfache SELECT-Anweisung mit MySQLi und Prepared Statements

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung erstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung prüfen
if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}

// SQL-SELECT-Abfrage vorbereiten
$sql = "SELECT id, username, email FROM users WHERE id = ?";

// Vorbereitung und Ausführung der Anweisung
if ($stmt = $conn->prepare($sql)) {
    // Parameter binden
    $stmt->bind_param("i", $id);

    // Parameter setzen und ausführen
    $id = 1;
    $stmt->execute();

    // Ergebnis binden
    $stmt->bind_result($result_id, $result_username, $result_email);

    // Ergebnisse abrufen
    while ($stmt->fetch()) {
        echo "ID: " . $result_id . " - Name: " . $result_username . " - Email: " . $result_email . "<br>";
    }

    // Statement schließen
    $stmt->close();
} else {
    echo "Fehler bei der Vorbereitung der Abfrage: " . $conn->error;
}

// Verbindung schließen
$conn->close();
?>
    

Verbindung erstellen und prüfen:
Eine Verbindung zur MySQL-Datenbank wird erstellt und auf Fehler überprüft.

SQL-SELECT-Abfrage vorbereiten:
Die SELECT-Abfrage wird mit einem Platzhalter (?) vorbereitet.

Statement vorbereiten und Parameter binden:
Die vorbereitete Anweisung wird mit prepare vorbereitet und der Parameter (id) wird mit bind_param gebunden.

Parameter setzen und Abfrage ausführen: Der Parameter wird gesetzt und die Abfrage wird mit execute ausgeführt.

Ergebnis binden:
Die Ergebnisse der Abfrage werden mit bind_result an Variablen gebunden.

Ergebnisse abrufen:
Die Ergebnisse werden mit fetch in einer Schleife abgerufen und ausgegeben.

Statement und Verbindung schließen: Das Statement und die Verbindung werden geschlossen.

Verbindungsinformationen:
$servername, $username, $password, und $database enthalten die Informationen zur Datenbankverbindung.

Einfache SELECT-Anweisung mit PDO

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

try {
    // Verbindung herstellen
    $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
    // Fehler-Modus auf Exception setzen
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    // SQL-Abfrage
    $stmt = $conn->prepare("SELECT id, username, email FROM users");
    $stmt->execute();

    // Ergebnis als assoziatives Array festlegen
    $result = $stmt->setFetchMode(PDO::FETCH_ASSOC);
    foreach ($stmt->fetchAll() as $row) {
        echo "id: " . $row["id"]. " - Name: " . $row["username"]. " - Email: " . $row["email"]. "
";
    }
} catch(PDOException $e) {
    echo "Fehler: " . $e->getMessage();
}

// Verbindung schließen
$conn = null;
?>
    

Verbindungsinformationen:
$servername, $username, $password, und $database enthalten die Informationen zur Datenbankverbindung.

Verbindung herstellen:
new PDO("mysql:host=$servername;dbname=$database", $username, $password) stellt eine Verbindung zur MySQL-Datenbank her. setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION) aktiviert die Fehlerbehandlung, sodass Fehler als Ausnahmen geworfen werden.

SQL-Abfrage vorbereiten:
Die SQL-Abfrage wird mit prepare vorbereitet: SELECT id, username, email FROM users WHERE active = :active. :active ist ein benannter Platzhalter für einen Parameter.

Parameter binden:
bindParam(':active', $active) bindet den Parameter :active an die Variable $active.

Parameter-Wert festlegen:
$active = 1 setzt den Wert des Parameters auf 1.

Abfrage ausführen:
execute() führt die vorbereitete Abfrage aus.

Ergebnisse holen:
fetchAll(PDO::FETCH_ASSOC) holt alle Ergebnisse als assoziatives Array.

Ergebnisse ausgeben:
Eine foreach-Schleife gibt die Ergebnisse Zeile für Zeile aus.

Fehlerbehandlung:
Ein try-catch-Block fängt mögliche Ausnahmen und gibt eine Fehlermeldung aus.

Verbindung schließen:
conn = null schließt die Datenbankverbindung.

Grundstruktur

UPDATE users
SET username = 'new_username', email = 'new_email@example.com'
WHERE id = 1;

Auswahl der Tabelle

Die Tabelle, die aktualisiert werden soll, wird durch die UPDATE-Klausel angegeben: UPDATE Tabelle.

Festlegen der neuen Werte

Die SET-Klausel wird verwendet, um die Spalten und ihre neuen Werte anzugeben: SET Spalte1 = Wert1, Spalte2 = Wert2.

Filtern der Datensätze

Die WHERE-Klausel wird verwendet, um sicherzustellen, dass nur bestimmte Datensätze aktualisiert werden: WHERE Bedingung.

Einfache UPDATE-Anweisung mit MySQLi

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung zur Datenbank herstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung prüfen
if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}

// SQL-UPDATE-Abfrage
$sql = "UPDATE users SET email='newemail@example.com' WHERE id=1";

// Abfrage ausführen
if ($conn->query($sql) === TRUE) {
    if ($conn->affected_rows > 0) {
        echo "Datensatz erfolgreich aktualisiert.";
    } else {
        echo "Keine Änderungen vorgenommen.";
    }
} else {
    echo "Fehler beim Aktualisieren des Datensatzes: " . $conn->error;
}

// Verbindung schließen
$conn->close();
?>

Verbindung herstellen und prüfen:
Eine Verbindung zur MySQL-Datenbank wird mit MySQLi erstellt und auf Fehler überprüft.

SQL-UPDATE-Abfrage:
Die UPDATE-Abfrage wird definiert, um die E-Mail-Adresse des Benutzers mit der id=1 zu aktualisieren.

Abfrage ausführen:
Die Abfrage wird mit query ausgeführt und das Ergebnis wird überprüft.

Ergebnis überprüfen:
Überprüfen, ob die Abfrage erfolgreich war, anhand der Anzahl der betroffenen Zeilen (affected_rows).

Verbindung schließen:
Die Verbindung wird geschlossen.

UPDATE-Anweisung mit MySQLi und Prepared Statements

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung zur Datenbank herstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung prüfen
if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}

// SQL-UPDATE-Abfrage vorbereiten
$sql = "UPDATE users SET email=? WHERE id=?";

// Vorbereitung und Ausführung der Anweisung
$stmt = $conn->prepare($sql);
if ($stmt === false) {
    die("Fehler bei der Vorbereitung der Anweisung: " . $conn->error);
}

// Parameter binden
$stmt->bind_param("si", $email, $id);

// Parameter setzen und ausführen
$email = "newemail@example.com";
$id = 1;
$stmt->execute();

// Überprüfen, ob die Aktualisierung erfolgreich war
if ($stmt->affected_rows > 0) {
    echo "Datensatz erfolgreich aktualisiert.";
} else {
    echo "Keine Änderungen vorgenommen.";
}

// Statement und Verbindung schließen
$stmt->close();
$conn->close();
?>

Verbindung herstellen und prüfen:
Eine Verbindung zur MySQL-Datenbank wird mit MySQLi erstellt und auf Fehler überprüft.

SQL-UPDATE-Abfrage vorbereiten:
Die UPDATE-Abfrage wird mit Platzhaltern (?) vorbereitet.

Anweisung vorbereiten und prüfen:
Die vorbereitete Anweisung wird mit prepare vorbereitet und auf Fehler überprüft.

Parameter binden:
Die Parameter (email und id) werden mit bind_param gebunden.

Parameter setzen und Abfrage ausführen:
Die Parameter werden gesetzt und die Abfrage wird mit execute ausgeführt.

Ergebnis überprüfen:
Überprüfen, ob die Abfrage erfolgreich war, anhand der Anzahl der betroffenen Zeilen (affected_rows).

Statement und Verbindung schließen:
Das Statement und die Verbindung werden geschlossen.

Einfache UPDATE-Anweisung mit PDO

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

try {
    // Verbindung zur Datenbank herstellen
    $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
    // Fehlerbehandlung aktivieren
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    // SQL-UPDATE-Abfrage vorbereiten
    $sql = "UPDATE users SET email = :email WHERE id = :id";

    // Vorbereitung und Ausführung der Anweisung
    $stmt = $conn->prepare($sql);

    // Parameter binden
    $stmt->bindParam(':email', $email);
    $stmt->bindParam(':id', $id);

    // Parameter setzen und ausführen
    $email = "newemail@example.com";
    $id = 1;
    $stmt->execute();

    // Überprüfen, ob die Aktualisierung erfolgreich war
    if ($stmt->rowCount() > 0) {
        echo "Datensatz erfolgreich aktualisiert.";
    } else {
        echo "Keine Änderungen vorgenommen.";
    }
} catch(PDOException $e) {
    echo "Fehler: " . $e->getMessage();
}

// Verbindung schließen
$conn = null;
?>
    

Verbindung herstellen und Fehlerbehandlung aktivieren:
Eine Verbindung zur MySQL-Datenbank wird mit PDO erstellt und die Fehlerbehandlung wird aktiviert.

SQL-UPDATE-Abfrage vorbereiten:
Die UPDATE-Abfrage wird mit benannten Platzhaltern (:email und :id) vorbereitet.

Anweisung vorbereiten und Parameter binden:
Die vorbereitete Anweisung wird mit prepare vorbereitet und die Parameter (email und id) werden mit bindParam gebunden.

Parameter setzen und Abfrage ausführen:
Die Parameter werden gesetzt und die Abfrage wird mit execute ausgeführt.

Ergebnis überprüfen:
Überprüfen, ob die Abfrage erfolgreich war, anhand der Anzahl der betroffenen Zeilen (rowCount).

Verbindung schließen:
Die Verbindung wird geschlossen.

Grundstruktur

DELETE FROM users
WHERE id = 1;

Auswahl der Tabelle

Die Tabelle, aus der die Datensätze gelöscht werden sollen, wird durch die DELETE FROM-Klausel angegeben: DELETE FROM Tabelle.

Filtern der Datensätze

Die WHERE-Klausel wird verwendet, um sicherzustellen, dass nur bestimmte Datensätze gelöscht werden: WHERE Bedingung. Ohne eine WHERE-Klausel werden alle Datensätze in der Tabelle gelöscht.

Einfache DELETE-Anweisung mit MySQLi

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung zur Datenbank herstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung überprüfen
if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}

// SQL-DELETE-Abfrage erstellen
$sql = "DELETE FROM users WHERE id = 1";

// Abfrage ausführen
if ($conn->query($sql) === TRUE) {
    echo "Datensatz erfolgreich gelöscht.";
} else {
    echo "Fehler beim Löschen: " . $conn->error;
}

// Verbindung schließen
$conn->close();
?>
    

Verbindungsinformationen:
$servername, $username, $password, und $database enthalten die Informationen zur Datenbankverbindung.

Verbindung zur Datenbank herstellen:
Eine Verbindung zur MySQL-Datenbank wird mit MySQLi erstellt.

Verbindung überprüfen:
Überprüfen, ob die Verbindung erfolgreich hergestellt wurde.

SQL-DELETE-Abfrage erstellen:
Die DELETE-Abfrage wird direkt als String erstellt.

Abfrage ausführen:
Die Abfrage wird mit query ausgeführt.

Ergebnis überprüfen:
Überprüfen, ob die Abfrage erfolgreich war, indem die Rückgabe von query überprüft wird.

Verbindung schließen:
Die Verbindung wird geschlossen.

DELETE-Anweisung mit MySQLi und Prepared Statements

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

// Verbindung zur Datenbank herstellen
$conn = new mysqli($servername, $username, $password, $database);

// Verbindung überprüfen
if ($conn->connect_error) {
    die("Verbindung fehlgeschlagen: " . $conn->connect_error);
}

// SQL-DELETE-Abfrage vorbereiten
$sql = "DELETE FROM users WHERE id = ?";

// Vorbereitung und Ausführung der Anweisung
$stmt = $conn->prepare($sql);

// Parameter binden
$id = 1;
$stmt->bind_param("i", $id);

// Abfrage ausführen
$stmt->execute();

// Überprüfen, ob die Abfrage erfolgreich war
if ($stmt->affected_rows > 0) {
    echo "Datensatz erfolgreich gelöscht.";
} else {
    echo "Kein Datensatz gefunden oder Fehler beim Löschen.";
}

// Statement und Verbindung schließen
$stmt->close();
$conn->close();
?>
    

Verbindungsinformationen:
$servername, $username, $password, und $database enthalten die Informationen zur Datenbankverbindung.

Verbindung zur Datenbank herstellen:
Eine Verbindung zur MySQL-Datenbank wird mit MySQLi erstellt.

Verbindung überprüfen:
Überprüfen, ob die Verbindung erfolgreich hergestellt wurde.

SQL-DELETE-Abfrage vorbereiten:
Die DELETE-Abfrage wird mit einem Platzhalter (?) vorbereitet.

Anweisung vorbereiten und Parameter binden:
Die vorbereitete Anweisung wird mit prepare vorbereitet und der Parameter (id) wird mit bind_param gebunden.

Abfrage ausführen:
Die Abfrage wird mit execute ausgeführt.

Ergebnis überprüfen:
Überprüfen, ob die Abfrage erfolgreich war, anhand der Anzahl der betroffenen Zeilen (affected_rows).

Statement und Verbindung schließen:
Das Statement und die Verbindung werden geschlossen.

Einfache DELETE-Anweisung mit PDO

<?php
$servername = "localhost";
$username = "root";
$password = "";
$database = "test";

try {
    // Verbindung zur Datenbank herstellen
    $conn = new PDO("mysql:host=$servername;dbname=$database", $username, $password);
    // Fehlerbehandlung aktivieren
    $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    // SQL-DELETE-Abfrage vorbereiten
    $sql = "DELETE FROM users WHERE id = :id";

    // Vorbereitung und Ausführung der Anweisung
    $stmt = $conn->prepare($sql);

    // Parameter binden
    $stmt->bindParam(':id', $id);

    // Parameter setzen und ausführen
    $id = 1;
    $stmt->execute();

    // Überprüfen, ob die Löschung erfolgreich war
    if ($stmt->rowCount() > 0) {
        echo "Datensatz erfolgreich gelöscht.";
    } else {
        echo "Keine Datensätze gelöscht.";
    }
} catch(PDOException $e) {
    echo "Fehler: " . $e->getMessage();
}

// Verbindung schließen
$conn = null;
?>
    

Verbindungsinformationen:
$servername, $username, $password, und $database enthalten die Informationen zur Datenbankverbindung.

Verbindung zur Datenbank herstellen:
Eine Verbindung zur MySQL-Datenbank wird mit PDO erstellt.

Fehlerbehandlung aktivieren:
Die Fehlerbehandlung wird aktiviert, um Ausnahmen zu handhaben.

SQL-DELETE-Abfrage vorbereiten:
Die DELETE-Abfrage wird mit einem benannten Platzhalter (:id) vorbereitet.

Anweisung vorbereiten und Parameter binden:
Die vorbereitete Anweisung wird mit prepare vorbereitet und der Parameter (id) wird mit bindParam gebunden.

Parameter setzen und Abfrage ausführen:
Der Parameter wird gesetzt und die Abfrage wird mit execute ausgeführt.

Ergebnis überprüfen:
Überprüfen, ob die Abfrage erfolgreich war, anhand der Anzahl der betroffenen Zeilen (rowCount).

Verbindung schließen:
Die Verbindung wird geschlossen.