PHP Tutorial - Teil 3

PHP Tutorial: Datenbankprogrammierung mit PHP und MySQL
Keine Kommentare

PHP und MySQL sind ein unzertrennliches Paar, und unzählige Content-Management-Systeme und webbasierte Anwendungen setzen auf diese Kombination.

Die Programmiersprache PHP bietet bezüglich der Sprachmerkmale beste Voraussetzungen zur Kommunikation mit einer Datenbank. MySQL ist kostenfrei und läuft auf vielen Betriebssystemen. Die ideale Kombination also! Ebenso ist es recht einfach, mit PHP auch andere Datenbanken anzusprechen.

Webbasierte Anwendungen erfordern in der Regel auch eine umfassende Datenverwaltung. Das relationale Datenbankschema ist seit vielen Jahren Standard und nach wie vor für die meisten Anwendungszwecke bestens geeignet.

Im Zusammenhang mit PHP wird sehr häufig mit MySQL-Datenbanken gearbeitet. MySQL ist eine Open-Source-Datenbank, die seit Jahren zur Verfügung steht und einen hohen Verbreitungsgrad hat, wozu gute Dokumentationen, Hilfen im Web und vielfältige Werkzeuge beitragen. In zahllosen Projekten hat sich die Zusammenarbeit von PHP und MySQL über Jahre bewährt. Das ist für uns Grund genug, sich intensiv damit auseinanderzusetzen (Kasten „Artikelserie“).

Artikelserie

Wie gehen wir vor? Zunächst wird gezeigt, wie wir eine einfache Datenbank in MySQL anlegen und administrieren. Dazu sind Basiskenntnisse in der Datenbanktheorie notwendig. Im Textkasten „Basics der Datenbanktheorie“ werden die wichtigsten Begriffe zum relationalen Datenschema erklärt.

Im zweiten Schritt geht es darum, eine Verbindung zwischen dem PHP-Programm und der Datenbank herzustellen. Die Daten werden üblicherweise in einem Formular erfasst, nach der Validierung an die Datenbank übertragen und dort gespeichert. Die in der Datenbank abgelegten Daten muss man natürlich auch wieder abrufen können, um sie anzuzeigen oder weiterzuverarbeiten.

Alle Arbeiten mit der Datenbank erfolgen mithilfe von Transaktionen. Dazu dient die allgemeine Datenbanksprache SQL, auf die wir im Lauf des Artikels noch zurückkommen werden. Damit ist die Agenda für diesen Teil unserer einführenden PHP-Serie abgesteckt. Das Vorhaben ist wie immer anspruchsvoll, lassen Sie uns darum direkt starten!

Basics der Datenbanktheorie

Eine Webapplikation mit Datenbankzugriffen zu programmieren, ohne sich mit der zugrunde liegenden Datenbanktheorie zumindest rudimentär auszukennen, ist nicht möglich. Daher folgen hier ein paar Grundlagen.

Ein Datenbanksystem ist ein System zur effizienten, dauerhaften und widerspruchsfreien Speicherung von Daten. Da neben der Datenspeicherung auch Verwaltungsaufgaben wahrgenommen werden müssen, spricht man auch von einem Datenbankmanagementsystem (DBMS). Innerhalb eines solchen DBMS können prinzipiell beliebig viele Datenbanken (DB) verwaltet werden. Insgesamt ergibt sich dann die in Abbildung 1 dargestellte Struktur. Weiterhin basieren die meisten DBMS auf dem relationalen Datenbankschema, mit dem Daten innerhalb von Tabellen organisiert werden. Eine solche Tabelle besteht aus Zeilen und Spalten; jede Spalte hat dabei einen bestimmten Datentyp und steht für eine ausgewählte Komponente eines Datensatzes, jede Zeile beinhaltet genau einen Datensatz.

Um jeden Datensatz eindeutig identifizieren zu können, muss man diesen mit einem eindeutigen Schlüssel ausstatten. Üblicherweise wird ein künstlicher Schlüssel in jede Tabelle eingefügt, dessen Wert automatisiert beim Hinzufügen eines neuen Datensatzes generiert wird. Ein solcher Schlüssel kann zum Beispiel eine fortlaufende Nummer sein. Auch inhaltliche Informationen (z. B. eine Kundennummer) kann man in dem Schlüssel „verstecken“. Alternativ kann ein Schlüssel auch aus einem oder mehreren Feldern (Kombination) gebildet werden. Voraussetzung ist jedoch, dass der Schlüssel in Bezug auf den Datensatz eindeutig ist.

Das Prinzip der relationalen Datenbank besteht darin, die zu speichernden Informationen auf mehrere Tabellen aufzuteilen. Dabei sind die Informationen so in den Tabellen abzulegen, dass möglichst keine Redundanzen entstehen, d. h. eine Information sollte nach Möglichkeit nur einmal abgelegt werden.

Der Vorteil davon ist, dass man bei Änderung eines bestimmten Datums dieses nur an einer Stelle anpassen muss. Damit werden Fehler und Widersprüche im Datenbestand vermieden bzw. reduziert. Erreicht wird das durch eine Normalisierung der Datenbasis. Dieser Schritt im Datenbankentwurf wird als konzeptioneller Entwurf bezeichnet. Wenn Sie als angehender PHP-Entwickler mit Datenbanken grundsätzlich vertraut sind, werden Sie sofort wissen, was damit gemeint ist. Alle anderen müssen sich damit beschäftigen, bevor sie eine Datenbank für eine dynamische Webapplikation erstellen.

Datenbank erstellen

In diesem Schritt zeigen wir, wie man die grundlegende Struktur einer Datenbank anlegt. Unser Beispiel wird sehr minimalistisch ausfallen, d. h. die Datenbank wird nur aus einer Tabelle mit drei Spalten bestehen. Dennoch werden wir alle wichtigen Schritte daran zeigen. Zunächst ist MySQL zu starten. Wir gehen wieder davon aus, dass Sie den Server XAMPP verwenden (siehe Teil 1 unserer Serie). Starten Sie den Server und damit auch gleichzeitig die MySQL-Datenbank, indem Sie die Datei xampp_start.exe aus dem Explorer heraus ausführen. Den Erfolg dieser Maßnahme können Sie über das Control-Panel (xampp-control.exe) kontrollieren (Abb. 2). Für das Anlegen der Struktur der Datenbank gibt es zwei Varianten:

Abb. 2: Im XAMPP-Control-Panel kann man den Status vom PHP- und MySQL-Server sehen

Abb. 2: Im XAMPP-Control-Panel kann man den Status vom PHP- und MySQL-Server sehen

  1. Automatisiert: Aus dem Quellcode des Programms wird mittels PHP und den entsprechenden SQL-Befehlen die Datenbank erstellt. Das passiert immer dann, wenn die Tabellenstruktur der Datenbank bereits feststeht und automatisiert, zum Beispiel im Rahmen einer Programminstallation, auf dem Server erstellt werden soll.
  2. Manuell: Man erstellt die Struktur der Datenbank manuell. Meist bedient man sich dazu einer Bedienoberfläche. In der PHP-Welt und für den Zugriff auf MySQL-Datenbanken funktioniert das sehr gut mithilfe des kostenfreien Tools phpMyAdmin.

Wie wollen hier keine Ausnahme machen und eine erste Datenbank mithilfe von phpMyAdmin erstellen. Das Tool selbst ist auch ein PHP-Programm und läuft daher im Browser. Wechseln wir darum also in den Browser und rufen unseren lokalen Server (http://localhost) auf; phpMyAdmin erreichen wir unter http://localhost/phpmyadmin/ (Abb. 3).

Abb. 3: Einfachste Administration der MySQL-Datenbank mithilfe von phpMyAdmin

Abb. 3: Einfachste Administration der MySQL-Datenbank mithilfe von phpMyAdmin

Damit gelangen wir zur Administrationsoberfläche und können bestehende Datenbanken verwalten oder eine neue Datenbank anlegen. Wir klicken auf Neu, um eine neue Datenbank zu erstellen, für die ein aussagekräftiger Name zu vergeben ist: Für den ersten Test nennen wir sie „meineDatenbank“. Die Datenbank wird erstellt und wir gelangen zur nächsten Seite, auf der wir aufgefordert werden, eine erste Tabelle zu erstellen. Dabei muss unmittelbar die Anzahl der Spalten – also die Zahl der Datenfelder – angeben werden. Im nächsten Schritt sind für jedes Datenfeld der Datentyp (Tabelle 1) und weitere Eigenschaften zu bestimmen.

Datentyp Speichergröße Wertebereich
TINYINT 1 Byte Ganzzahlen: 0 bis 255

Mit Vorzeichen: -128 bis +127

SMALLINT 2 Bytes Ganzzahlen: 0 bis 65 535

Mit Vorzeichen: -32 768 bis +32 767

MEDIUMINT 3 Bytes Ganzzahlen: 0 bis 16 777 215

Mit Vorzeichen: -8 388 608 bis +8 388 607

INT 4 Bytes Ganzzahlen: 0 bis 4 294 967 295

Mit Vorzeichen: -2 147 483 648 bis +2 147 483 647

BIGINT 8 Bytes Ganzzahlen: 0 bis 18 446 744 073 709 551 615

Mit Vorzeichen: -9 223 372 036 854 775 808 bis +9 223 372 036 854 775 807

FLOAT 4 Bytes Fließkommazahlen

Ganzzahlen: 0 und 1,175494351^38 bis 3,402823466^38

Mit Vorzeichen: -3,402823466^38 bis +1,175494351^38

DOUBLE 8 Bytes Fließkommazahlen

Ganzzahlen: 0 und 2,225^-308 bis 1,798^308

Mit Vorzeichen: -1,798^308 bis +2,225^-308

DATE 3 Bytes Datumsbereich: von 01.01.1000 bis 31.12.9999
DATETIME 8 Bytes Datumsbereich: von 01.01.1000 – 00:00:00 bis 31.12.9999 – 23:59:59
TIMESTAMP 4 Bytes Wertebereich: von 01.01.1970 bis 2037
VARCHAR Stringlänge + 1 Byte Zeichenkette mit einer Länge von 0 bis 255 Zeichen
TEXT Stringlänge + 2 Bytes Zeichenkette mit einer maximalen Größe von 65 535 Bytes
MEDIUMTEXT Stringlänge + 3 Bytes Zeichenkette mit einer maximalen Größe von 16 777 215 Bytes
LONGTEXT Stringlänge + 4 Bytes Zeichenkette mit einer maximalen Größe von 4 294 967 295 Bytes

Tabelle 1: Wichtige Datentypen, Speicherbedarf und Einsatz der Datenbank MySQL

Bei der Auswahl der Datentypen ist aus Performancegründen darauf zu achten, dass der kleinstmögliche Datentyp gewählt wird. Wenn Tabellen miteinander verknüpft werden, sollten die betreffenden Felder vom gleichen Datentyp sein. In Abbildung 4 haben wir das bereits für die Datenfelder id (integer), vorname (varchar) und nachname (varchar) getan. Das Datenfeld id wurde dabei als Primärschlüssel definiert. Auf diese Weise können wir eine beliebige Datenbankstruktur mit mehreren Tabellen erstellen. Wichtig ist es dabei, sich im Vorfeld über die Struktur im Klaren zu sein. Sind erst Produktionsdaten in der Datenbank abgelegt, wird es sehr aufwändig, die Struktur nachträglich ohne Informationsverlust anzupassen. Auch das Transferieren der Daten in eine neue Struktur ist dann kompliziert.

Abb. 4: Anlegen der Datenbankstruktur mithilfe von phpMyAdmin

Abb. 4: Anlegen der Datenbankstruktur mithilfe von phpMyAdmin

Ebenso ist es möglich, die Tabellenstruktur der Datenbank über PHP zu erstellen. Für unsere minimale Datenbank geschieht das mithilfe von Listing 1. Dabei ist zu beachten, dass wir als Benutzer root arbeiten und zu Beginn kein Passwort definiert wurde. Diesen Zustand haben wir zum Testen so belassen. Sobald man mit einem ersten richtigen Projekt beginnt, sind die Sicherheitseinstellungen anzupassen, d. h. man muss ein Passwort für root vergeben. Zusätzlich sollte man auch einen weiteren Nutzer anlegen und diesen nur mit den minimal notwendigen Rechten ausstatten. Das kann ebenfalls innerhalb von phpMyAdmin erfolgen.

<!DOCTYPE html>
<html>
<head>
  <Title>Ein neuer Versuch</Title>
</head>
<body>
  <?PHP
    $user = 'root';
    $pass = '';
    $db = new PDO('mysql:host=localhost;dbname=meineDatenbank', $user, $pass );
    //Fehlermeldungen aktivieren
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    //Datenbank erstellen
    $sql = "CREATE TABLE tabelle(id INTEGER PRIMARY KEY NOT NULL auto_increment,vorname VARCHAR(100), nachname VARCHAR(100), age int);";
    $db ->exec($sql);
    echo 'Die Tabelle "tabelle" wurde erfolgreich erstellt!'
  ?>
</body>
</html>

Startet man das Skript aus Listing 1 und existiert eine Datenbank mit dem Namen „meineDatenbank“, so wird die Datentabelle erstellt. Den Erfolg dieser Maßnahme bekommt man im Browser angezeigt. Unsere Datenbank besteht damit aus den Feldern id, vorname, nachname und age.

👉 Hinweis: Statt des deutschen Worts alter müssen wir auf die englische Bezeichnung age ausweichen, da alter innerhalb von SQL ein Schlüsselwort ist!

Nach dem Ausführen des Skripts ist die Tabellenstruktur wie gewünscht angelegt und damit bereit, erste Datensätze aufzunehmen.

In Verbindung treten

Bei der Erstellung der Tabelle aus PHP heraus (Listing 1) haben wir bereits eine Datenbankverbindung aufgebaut, ohne dass wir das näher erläutert haben. Gemeint sind die beiden Befehlszeilen:

$db = new PDO('mysql:host=localhost;dbname=meineDatenbank', $user, $pass );
$db->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

Grundsätzlich gibt es mehrere Möglichkeiten, von PHP auf eine Datenbank zuzugreifen. Bei Verwendung einer MySQL-Datenbank wählt man üblicherweise die Schnittstelle MySQLi, die auf der ursprünglichen MySQL-Schnittstelle basiert. Das „i“ steht für improved, d. h. für verbessert. Mithilfe von MySQLi stellt sich das Vorhaben gemäß Listing 2 dar.

<?php
  /* Verbindung aufnehmen */
  $con = mysqli_connect("","root");
  /* Datenbank auswählen */
  mysqli_select_db($con, "namederdatenbank");
  /* SQL-Abfrage ausführen */
  $res = mysqli_query($con, "select * from tabellenname");
  /* Anzahl Datensätze ermitteln und ausgeben */
  $num = mysqli_num_rows($res);
  echo "$num Datensätze gefunden<br />";
  /* Datensätze aus Ergebnis ermitteln, */
  /* in Array speichern und ausgeben    */
  while ($dsatz = mysqli_fetch_assoc($res))
  {
    echo $dsatz[“feldname”]
    ...
  }
  /* Verbindung schließen */
  mysqli_close($con);
?>

Dazu sind die folgenden Erläuterungen angebracht:

  • mysqli_connect(): Öffnet eine Verbindung zum MySQL-Datenbankserver. Als Parameter werden der Hostname, der Benutzername und das Kennwort übergeben.
  • mysqli_select_db: Wählt die betreffende Datenbank aus. Als Parameter werden der Verweis auf die Verbindung und der Name der Datenbank übergeben.
  • mysqli_query(): Führt die Abfrage mithilfe einer select-Abfrage an die Datenbank durch. Das Ergebnis der Abfrage wird zurückgegeben.
  • mysqli_num_rows(): Ermittelt die Anzahl der Datensätze. Als Parameter muss man das Ergebnis eines vorher erforderlichen mysqli_query()-Statements übergeben.
  • mysqli_fetch_assoc(): Damit wird ein Datensatz aus dem Ergebnis ermittelt. Bei jedem Aufruf wird der Datensatzzeiger um eine Position verschoben. Mithilfe einer while-Schleife kann man also über alle Datensätze iterieren.
  • mysqli_close(): Die Verbindung zur Datenbank wird wieder geschlossen.

Steht also fest, dass mit dem PHP-Programm auch in der Zukunft eine MySQL-Datenbank angesprochen wird, brauchen Sie sich über weitere Schnittstellen keine Gedanken zu machen. Sofern man aber einen Wechsel der Datenbank nicht grundsätzlich ausschließen kann, hat die Festlegung einer spezifizierten Schnittstelle einige Nachteile. Wird auf ein anderes Datenbanksystem gewechselt, müssen die betreffenden Stellen im Quellcode angepasst werden, die für den Datenbankzugriff verantwortlich sind.

Um das zu vermeiden, setzt man Abstraktionsklassen ein, die dafür sorgen, dass die Programmierung des Datenbankzugriffs grundsätzlich unabhängig von der letztendlich eingesetzten Datenbank erfolgt. Ehrlicherweise muss jedoch hinzugefügt werden, dass es auch beim Einsatz einer Abstraktionsklasse notwendig sein kann, dass man beim Wechsel des Datenbanksystems Anpassungen am Quellcode vornehmen muss.

International PHP Conference 2018

Getting Started with PHPUnit

by Sebastian Bergmann (thePHP.cc)

Squash bugs with static analysis

by Dave Liddament (Lamp Bristol)

API Summit 2018

From Bad to Good – OpenID Connect/OAuth

mit Daniel Wagner (VERBUND) und Anton Kalcik (business.software.engineering)

Der Grund dafür ist, dass die verschiedenen relationalen Datenbanksysteme zwar grundsätzlich über SQL abgefragt werden, sie sich jedoch in der Verwendung unterschiedlicher SQL-Dialekte unterscheiden. Dennoch wird der Anpassungsbedarf minimiert. Ebenso sind Abstraktionsklassen stets der kleinste gemeinsame Nenner, um verschiedene Datenbanken einheitlich anzusprechen. Benötigt man also besondere Funktionen einer Datenbank, kann die Verwendung einer spezifischen Schnittstelle alternativlos sein. Für die meisten Einsatzgebiete dürfte jedoch der Einsatz einer Abstraktionsklasse möglich sein. Ab PHP Version 5.1 gehört PHP Data Objects standardmäßig zur Installation [1].

In unserem einführenden Beispiel (Listing 1) haben wir PDO bereits verwendet. PDO wird immer objektorientiert angesprochen. Auch bei der Verwendung von PDO muss im ersten Schritt eine Verbindung zur Datenbank aufgebaut werden. Dazu wird ein so genannter Data Source Name (DSN) erzeugt, der alle Informationen zur Datenbank enthält. Für eine MySQL-Datenbank mit MySQLi-Erweiterung sieht das wie folgt aus:

mysql:host=localhost;dbname=meineDatenbank

PDO verwendet also auch intern die MySQLi-Schnittstelle. Die generische Einsetzbarkeit wird also über eine weitere Schicht, die Abstraktionsebene, erreicht. Das PDO-Objekt wird mittels new instanziert, mit der Methode exec() wird das gewünschte SQL-Kommando ausgeführt.

Datenbank befüllen und Daten anzeigen

Noch ist nichts in der Datenbank. Auf welchem Wege kommen die Datensätze nun also hinein? Dazu gibt es grundsätzlich wieder mehrere Optionen:

  1. Manuelle Einzeldatenerfassung: Dieses Vorgehen ist natürlich nur zum Testen interessant. Über die phpMyAdmin-Schnittstelle kann man die Daten für einen einzelnen Datensatz erfassen. Dazu wird ein Formular angezeigt, das aus der Tabellenstruktur automatisch generiert wird.
  2. Import von Daten: Bestehende Datenbestände können in die Tabellen einer MySQL-Datenbank eingelesen werden. Das kann wiederum manuell über die Oberfläche von phpMyAdmin geschehen oder man kann ein Skript schreiben, das die Daten nach Auswahl der Datei übernimmt. Die Transformation von Daten wird immer dann interessant sein, wenn man eine Webapplikation baut, die auf bereits bestehende Datenbestände zurückgreifen und diese in die eigene Datenbank übernehmen möchte. Die Transformation von Daten ist – außer in trivialen Fällen – ein anspruchsvolles Thema. Man muss sowohl auf die passende Tabellenstruktur als auch auf die Kompatibilität der Datentypen bei den einzelnen Feldern achten. Im Übrigen ist es auch möglich, die Daten einer MySQL-Datenbank für eine weitere Verwendung/Verarbeitung zu exportieren, beispielsweise in das systemunabhängige CSV-
  3. Daten mittels PHP-Skript einspielen: Üblicherweise werden die Daten in einem Formular durch den Benutzer erfasst. Nach Validierung werden die Daten in die Datenbank übertragen. Ebenso ist es möglich, dass Daten aus Berechnungen entstehen und dann in die Datenbank übernommen werden. Mit der Datenbank wird dabei über die Abfragesprache SQL (Kasten: „Was ist SQL?“) kommuniziert.

Was ist SQL? [2]

Der Begriff SQL (eng. Structured Query Language) steht für „strukturierte Abfragesprache“ und dient in Datenbanksystemen zur Definition von Daten und zur Informationsgewinnung. SQL definiert lediglich die Sprache, die verwendet wird, um mit den Datenbankinhalten zu arbeiten und hat mit der technischen Realisierung nichts zu tun. Mathematische Ansätze aus den frühen siebziger Jahren dienen als Basis für dieses Konzept. Die Idee dahinter: Die Daten werden in tabellarischer Form gespeichert und können logisch miteinander verknüpft werden. Anhand von SQL-Ausdrücken ist das Lesen und Verändern von vorhandenen Daten sowie das Hinzufügen von neuen Daten in die Datenbank möglich.

Voraussetzung für einen effektiven Umgang mit einer SQL-Datenbank ist das Beherrschen des SQL-Befehlsvorrats. Grundsätzlich können SQL-Kommandos in zwei Kategorien unterteilt werden: Data Manipulation Language (DML) und Data Definition Language (DDL).

DML sind Befehle, die zur Datenbearbeitung eingesetzt werden. Sie können wie folgt gegliedert werden:

  • Select-Ausdrücke: Sie dienen zur Abfrage von bestehenden Daten. Einzelne oder mehrere Datensätze bzw. Felder von Datensätzen können dabei ausgegeben werden.
  • Insert-Ausdrücke: Mithilfe von diesen Ausdrücken werden neue Informationen in der Datenbank gespeichert.
  • Update-Ausdrücke: Diese werden zur Veränderung von bestehenden Daten eingesetzt.
  • Delete-Ausdrücke: Mit deren Hilfe können bestehende Daten gelöscht werden.

Anhand von DDL-Befehlen kann das Datenbankdesign definiert bzw. geändert werden. Dabei unterscheidet man folgende Kategorien:

  • Create-Ausdrücke: Sie dienen zur Erzeugung und Definition von Datenbanken und Tabellen.
  • Alter-Ausdrücke: Anhand dieser Befehle können die Eigenschaften und die Struktur von Datenbanken und Tabellen geändert werden.
  • Drop-Ausdrücke: Sie dienen zum Löschen von Datenbanken und Tabellen.

Interessanterweise können SQL-Ausdrücke wiederum in sich geschachtelt werden. Im Allgemeinen bestehen SQL-Befehle aus den folgenden Elementen:

  • Spaltenname, z. B. Nachname, PLZ, Ort etc.
  • Arithmetische Operatoren sind +, -, *, /.
  • Logische Operatoren, z. B. die Suchwörter NOT, AND und OR. Diese werden für einfache Suchfunktionen und für komplexere Suchanfragen verwendet.
  • Vergleichsoperatoren sind <, >, <=, >= und <>. Diese vergleichen zwei Werte und geben „wahr“ oder „falsch“ zurück.
  • Verknüpfungsoperatoren dienen zur Verkettung von Zeichenketten.
  • Unterabfragen werden zur Schachtelung verschiedener SQL-Ausdrücke verwendet.
  • Gespeicherte Prozeduren sind wiederverwendbare SQL-Ausdrücke, die als Metadaten gespeichert werden.

Beispielsweise gestaltet sich die Formulierung einer Datenbankabfrage nach dem folgenden allgemeinen Schema:

SELECT Spaltenname1, Spaltenname2,...
  FROM Tabellenname 
  WHERE Bedingung
  ORDER BY Sortierung;

Nachfolgend zeigen wir, wie Daten mittels PHP in die Datenbank eingetragen werden. Wir verwenden wieder die oben vorgestellte generische PDO-Abstraktionsklasse. Listing 3 zeigt die konkrete Umsetzung.

<!DOCTYPE html>
<html>
  <head>
    <Title>Ein neuer Versuch</Title>
  </head>
  <body>
    <?php
    if(isset($_POST["Submit"])){
    ?>
    <font size=\"5\">Die Person wurde erfolgreich hinzugefügt!</font> </br>

      <?php
        //Überprüfen, ob Felder ausgefüllt wurden, Strings formatieren
        $Vorname = (isset($_POST["Vorname"]) && is_string($_POST["Vorname"])) ? $_POST["Vorname"]:"";
        $Vorname = htmlspecialchars($Vorname);
        $Nachname = (isset($_POST["Nachname"]) && is_string($_POST["Nachname"])) ? $_POST["Nachname"]:"";
        $Nachname = htmlspecialchars($Nachname);
        $Age = (isset($_POST["Age"]) && is_string($_POST["Age"])) ? $_POST["Age"]:"";
        $Age = htmlspecialchars($Age);
        //in die Datenbank "einloggen"
        $user = 'root';
        $pass = '';
        $db = new PDO( 'mysql:host=localhost;dbname=meineDatenbank', $user, $pass );
        //Fehlermeldungen aktivieren
        $db->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
        //Eintrag in Tabelle machen
        $sql = "INSERT INTO tabelle (vorname,nachname,age) VALUES ( ':eins' ,':zwei',':drei');";
        $alt = array(":eins",":zwei",":drei");
        $neu = array($_POST["Vorname"],$_POST["Nachname"],$_POST["Age"]);
        // Vielleicht hier elegantere Methode als str_replace möglich?
        $sql = str_replace($alt, $neu, $sql);
        $db-> exec($sql);
        // Abfrage durchführen
        $sql = "SELECT * FROM tabelle";
        $result = $db->query( $sql );
        // Tabelle zeilenweise ausgeben
        echo "<font size=\"5\">Ausgabe der Datensätze:</font> </br></br>";
        foreach( $result as $row ){
            echo "Eintrag Nr: " . $row[ 'id' ] . "<br/>" . "Vorname: " . $row[ 'vorname' ] ."<br/>". "Nachname: " . $row[ 'nachname' ] ."<br/>" ."Alter: ". $row['age']."<br/>"."<br/><br/>";
        }
      ?>
      <?php
    }
    else{
    ?>
    <h1> Neue Personen hier eintragen: </h1>
    <form method ="post">
    Vorname <input type ="text" name ="Vorname" /> <br />
    Nachname <input type ="text" name ="Nachname" /> <br />
    Alter <input type ="text" name ="Age" /> <br />
    <input type ="submit" name="Submit" value="Person eintragen"/>
    <?php
    }
    ?>
  </body>
</html>

Was leistet dieser Codeausschnitt? Im HTML-Abschnitt wird ein Formular mit drei Feldern für die Datenerfassung erstellt. Die Formularfelder entsprechen genau den notwendigen Daten, wie sie unsere zuvor erstellte Datenbank benötigt. Der PHP-Teil enthält mehrere Abschnitte:

  1. Datenprüfung: Zunächst werden die übernommenen Daten minimal validiert. In einem Praxisprojekt muss dieser Abschnitt natürlich deutlich umfangreicher ausfallen, denn es sollen in die Datenbank nur Werte eingetragen werden, die auch syntaktisch korrekt sind. In diesen Abschnitt müssen auch inhaltliche Prüfungen der übergebenen Daten vorgenommen werden.
  2. Datenbankverbindung: Die Verbindung zur Datenbank wird mittels
    $db = new PDO( 'mysql:host=localhost;dbname=meineDatenbank', $user, $pass );
    $db->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );

    hergestellt.

  3. 3. Daten eintragen: Die Daten aus dem Formular werden in die Tabelle eingetragen. Dazu wird zuvor der notwendige SQL-Befehl „zusammengebaut“. Das hier gewählte Vorgehen ist notwendig, um in den SQL-Befehl (Zeichenkette) die konkreten Werte des Datensatzes einzufügen; dieser wird also dynamisch generiert. Mittels der Methode exec() erfolgt dann dessen Ausführung, d. h. die Daten werden in die Tabelle eingetragen.
  4. 4. Daten auslesen: Im nächsten Schritt werden mithilfe einer Abfrage der Form
    $sql = "SELECT * FROM tabelle";
    $result = $db->query( $sql );

    alle verfügbaren Datensätze aus der Tabelle abgerufen und dann mithilfe einer Schleife ausgegeben.

Abbildung 5 zeigt das Ergebnis dieses Vorgangs. In unseren Fall wurde das Formular also bereits dreimal aufgerufen, denn es sind drei Datensätze in der Tabelle vorhanden. Damit haben wir alle wichtigen Schritte der Arbeit mit der Datenbank aus PHP präsentiert: Wir haben eine Datenbank mit einer Tabelle angelegt, Datensätze eingetragen und diese auch wieder abgerufen. In umfassenden Webapplikationen sind die einzelnen Vorgänge natürlich zu trennen und auf Klassen und Dateien zu verteilen. Das Prinzip bleibt jedoch erhalten.

Abb. 5: Datensätze wurden mithilfe des Formulars erfolgreich in die Datenbank eingetragen

Abb. 5: Datensätze wurden mithilfe des Formulars erfolgreich in die Datenbank eingetragen

Fazit und Ausblick

In diesem Artikel haben wir die absoluten Basics der Arbeit mit MySQL-Datenbanken gezeigt. Erfreulicherweise gestaltet sich die Arbeit mit der Datenbank aus PHP heraus als angenehm und wenig kompliziert. Dabei gibt es mehrere Optionen, auf welche Art und Weise die Kommunikation zwischen PHP und der MySQL-Datenbank abläuft. Neben der üblichen Art, über die MySQLi-Schnittstelle die Verbindung herzustellen, gibt es seit PHP 5.1 auch die generische Schnittstelle PDO. Deren Verwendung bietet zwei entscheidende Vorteile:

  1. Objektorientiert: PDO ist konsequent objektorientiert und nur so zu verwenden. Wir hatten bereits im zweiten Teil dieser Artikelreihe ausgeführt, dass PHP ab Version 5 auch die objektorientierte Programmierung im vernünftigen Maß unterstützt. Für größere Vorhaben ist dieses Vorgehen auch klar dem prozeduralen Ansatz vorzuziehen, damit man eine vernünftige und übersichtliche Programmstruktur aufbauen kann. PDO ist damit die logische Konsequenz. Zwar kann auch die MySQLi-Schnittstelle objektorientiert verwendet werden, aber eben auch prozedural. Ein Mischen ist auf keinen Fall sinnvoll.
  2. Systemunabhängig: Dieses scheint ein ebenso wichtiges Argument. PHP unterstützt zwar die MySQL-Datenbank bestens, aber die Interaktion klappt auch sehr gut mit anderen Datenbanken. Die MySQLi-Schnittstelle funktioniert nur mit MySQL. Mit PDO wählt man dagegen eine generische Abstraktionsschicht, d. h. bei einem Wechsel der Datenbank ist es nicht notwendig, die Programmteile, die für die Verbindung zwischen Applikation und Datenbank sorgen, anzupassen.

Beide Punkte sprechen klar für den Einsatz von PDO. Existiert natürlich bereits Quellcode mit MySQLi muss man diesen nicht ändern, sofern man bei MySQL bleibt. Auch wenn zwingend ältere PHP-Versionen unterstützt werden müssen, d. h. man beispielsweise keinen Einfluss auf ein Update auf dem Server hat, ist PDO keine Option. Das dürfte jedoch die Ausnahme sein.

Wie geht es weiter? Nach drei Teilen Grundlagen wollen wir viele der vorgestellten theoretischen Inhalte in einem etwas umfassenderen Beispiel im Zusammenhang darstellen. In Teil 4 werden wir eine kleine datenbankbasierte Anwendung mit PHP realisieren.

Literatur

  • [1] Wenz, Christian / Hauser, Tobias: „PHP 5.6 und MySQL. Das umfassende Handbuch“, Rheinwerk Verlag, 2015
  • [2] Throll, Marcus / Bartosch, Oliver: „Einstieg in SQL“, Galileo Press, 2010

Entwickler Magazin

Entwickler Magazin abonnierenDieser Artikel ist im Entwickler Magazin erschienen.

Natürlich können Sie das Entwickler Magazin über den entwickler.kiosk auch digital im Browser oder auf Ihren Android- und iOS-Devices lesen. In unserem Shop ist das Entwickler Magazin ferner im Abonnement oder als Einzelheft erhältlich.

Unsere Redaktion empfiehlt:

Relevante Beiträge

Hinterlasse einen Kommentar

Hinterlasse den ersten Kommentar!

avatar
400
  Subscribe  
Benachrichtige mich zu:
X
- Gib Deinen Standort ein -
- or -