Wie man eine Access-Datenbank ins Internet bringt (7)

Hier geht es zum ersten Beitrag dieses Blogs:

https://streethawk68.wordpress.com/2011/01/01/wie-man-eine-access-datenbank-ins-internet-bringt-1/

— — — — — — —

Nun also zum siebten und letzten Akt unseres Access-Datenbank-ins-Internet-Auftritts: zur change.php. Diese PHP-Datei / dieses PHP-Skript ist das dritte und letzte des Admin-Teils, also des Backends der Site. Außerdem ist sie das sechste und letzte Skript überhaupt. Zuvor hatten wir es mit den Skripten zu tun:

  1. index.html
  2. query.html
  3. query.php

für das Frontend (Bücher suchen, finden und anzeigen) und

  1. admin.php
  2. action.php

für das Backend (Bücher löschen, modifizieren, anschauen und kreieren).

Komplettiert wird das Backend jetzt mit change.php. Danach ist die ganze Präsenz/Site erklärt und dieses Blog kommt zu seinem (verdienten? 🙂 ) Ende. Wie gewohnt, liefere ich das Skript zuerst in voller Länge:

 


<?php

// No Cache
header("Cache-Control: no-cache, must-revalidate");
header("Expires: Mon, 26 Jul 1997 05:00:00 GMT");

// Zurueck zur admin.php
header('Refresh: 5; url=admin.php');

// MySQL Zugangsdaten
$database="XXXXXXX";
$host="localhost";
$user="XXXXXXX";
$password="XXXXXXX";
$table="BUECHER_GEL";

// Verbindung zur Datenbank herstellen
mysql_connect($host,$user,$password);
mysql_select_db($database) or die( "Unable to select database");

// POST Variable in eine eigene Variable ueberfuehren.
$rawdata = $_POST;

// ID herausloesen
$id      = $rawdata['id'];

// ID aus dem POST request loeschen
unset($rawdata['id']);

// update / MODIFY
if ( $id )
{
    // Vorher den Datensatzinhalt bis auf ID "loeschen"
  
    // alle Felder holen
    $query="show columns from $table";
    $result=mysql_query($query);

    // Kann eigentlich nicht schiefgegangen sein...
    if (!$result)
    {
        $message  = 'Invalid query: ' . mysql_error() . "\n";
        $message .= 'Whole query:   ' . $query;
        die($message);
    }

    // Basisquery definieren
    $basequery  = "UPDATE $table set ";
    $query      = $basequery;

    // und jetzt jedes Feld ablaufen
    while ( $row = mysql_fetch_assoc($result) )
    {

        $feldname = $row['Field'];

        // das Feld id nicht anfassen
        if ( $feldname == "id" ) continue; 

        // Query String erweitern
        $query = $query . "$feldname = NULL, " ;  
    }

    // Jetzt noch das Ende des SQL Strings fixen 
    $query = $query . "END where id ='$id'";
    $query = str_replace(', END', '' , $query);

    // Und ausfuehren
    $result=mysql_query($query);

    // Fehler?
    if (!$result)
    {
        $message  = 'Invalid query: ' . mysql_error() . "\n";
        $message .= 'Whole query:   ' . $query;
        die($message);
    }

    // Jetzt sind alle Felder im Datensatz NULL
    // Aenderungen eintragen

    // Basisquery definieren
    $basequery  = "UPDATE $table set ";
    $query      = $basequery;

    // Den POST Request "ablaufen". Es ist nur ein Array
    // Fuer jedes uebergebene(!) Element
    foreach ($rawdata as $feld => $element)
    {

        // fuehrende und abschliessende Leerzeichen entfernen
        $sauber     = trim($element);
        $element    = $sauber;

        // pruefen ob es leer ist, wenn nicht
        if ( ! empty($element) )

        // Query String erweitern
        $query = $query . "$feld = '" . $element . "', " ;
    }

    // Und jetzt natuerlich auch noch sagen welcher Datensatz aktualisiert
    // werden soll
    $query = $query . "where id = '" . $id . "'";

    // ", where" ersetzen, falls notwendig
    $query = str_replace(', where', 'where' , $query);
}
else
// insert / CREATE
// Kein Update, also Datensatz neu anlegen
{
    // Base Query definieren
    $basequery  = "INSERT into $table (";
    $query      = $basequery;

    // Beim Einfuegen brauchen wir eine Liste
    // Der Feldnamen und auch deren Inhalt
    // Also einfach das uebergebene POST Array ablaufen und sich das merken
    foreach ($rawdata as $feld => $element)
    {

        // fuehrende und abschliessende Leerzeichen entfernen
        $sauber     = trim($element);
        $element    = $sauber;

        // Nur wenn das Feld auch einen Inhalt hat
        if ( ! empty($element) )
        {
            // Im Grunde wie beim Insert, jetzt bauen wir nur
            // "parallel" zwei Array auf.
            // Das erste hat die Feldnamen
            // das zweite hat die Werte
            $felder = $felder . $feld . ",";
            $werte  = $werte . "'". $rawdata[$feld] . "',";
        };
    }

    // Query zusammenbauen
    $query = $query . "$felder) values ($werte)";

    // Ueberzaehliges , herausloesen
    $query = str_replace(',)', ')' , $query);

}

// Query ausfuehren
$result=mysql_query($query);

// Kann eigentlich nicht schiefgegangen sein...
if (!$result)
{
    $message  = 'Invalid query: ' . mysql_error() . "\n";
    $message .= 'Whole query:   ' . $query;
    die($message);
}

// HTML Ausgabe
echo '
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Buecher Admin GUI</title>
</head>
<body>
';

if ($id)
{
    echo "<p>Aenderung erfolgreich</p>";

}
else
{
    echo "<p>Neu-Eintragung erfolgreich</p>";
}

// HTML Ausgabe abschliessen
// Das ist nur etwas DEBUG, damit man den String sieht, muss nicht sein 🙂
// echo "<p>Query: $query</p>";
echo '
</body>
</html>
';

// Verbindung schliessen
mysql_close();

?>

 

Benutze bitte wieder den Quer-Scrollbalken in diesem Blog, um auch das Ende aller Zeilen einsehen zu können.

Die beiden mit „header“ beginnenden Befehle sorgen wie gewohnt dafür, dass die Seite nicht zwischengespeichert wird, indem das darin angegebene Datum in der Vergangenheit liegt.

header(‚Refresh: 5; url=admin.php‘);

bewirkt, dass das Skript admin.php fünf Sekunden nach der/einer Erfolgs-Meldung (die wir viel weiter unten besprechen) wieder aufgerufen wird.

Der Codeblock mit den MySQL-Zugangsdaten und die Verbindung mit der Datenbank dürften mittlerweile sattsam bekannt sein; hier verzichte ich auf Erläuterung. Und wieder wird, was mittels der Methode POST an dieses Skript übergeben wurde, zuerst in die Variable $rawdata überführt. Wir erinnern uns: bei zweien der vier Aktionsmöglichkeiten DELETE, MODIFY, VIEW und CREATE (nämlich bei MODIFY und CREATE) war ein Eingabeformular generiert worden. Damit kann der Backend-Nutzer entweder ein vorhandenes Buch aktualisieren/modifizieren oder ein neues Buch erzeugen/kreieren. Sendet er das Formular nun unter Verwendung der Schaltfläche „Daten absenden“ ab, ruft das Formular die change.php auf und übergibt dabei die Formularfelder und die Formularwerte an die change.php. Und diese werden dann eben jetzt hier im Skript in die Variable $rawdata überführt.

Genug der Theorie; schauen wir uns den Inhalt von $rawdata mal praktisch an:

array(13) {
[„AutorNachname“]=> string(3) „May“
[„AutorVorname“]=> string(4) „Karl“
[„Titel“]=> string(12) „Winnetou III“
[„Untertitel“]=> string(0) „“
[„Ort“]=> string(0) „“
[„Verlag“]=> string(15) „Karl-May-Verlag“
[„Jahr“]=> string(0) „“
[„Kategorie“]=> string(6) „privat“
[„Art“]=> string(5) „Roman“
[„Uebersetzungvonin“]=> string(0) „“ [„wanngelesenetwa“]=> string(4) „2001“ [„Kommentar“]=> string(34) „Das beste der drei Winnetou-Bücher“
[„id“]=> string(2) „86“
}

Die Struktur ist also sehr schön zu sehen. Wir haben es mit einem Datenfeld (im Programmflow normalerweise nicht zu sehen) aus 13 Schlüssel-Werte-Paaren zu tun. Zwölf Felder hat jedes Buch, die ID (13) identifiziert das Buch. In der nächsten Zeile (ca. 24) wird die ID aus $rawdata herausgelöst und der Variablen $id zugewiesen. Um ca. Zeile 27 wird die ID aus dem Post-Request gelöscht. Danach geht es gleich an den MODIFY-Block, den man auch update nennen kann, denn so lautet auch der entsprechende SQL-Befehl und nichts anderes, als ein Update ist es, wenn ein Buch modifiziert/aktualisiert wird. Der nachfolgende Programmcode wird nur ausgeführt, wenn id überhaupt existiert, wofür die IF-Struktur

if ( $id )

sorgt (ca. Zeile 30). Hier wird als erstes der ganze Inhalt des Datensatzes (von ID abgesehen) gelöscht. Der SQL-Befehl

show columns from $table

ist uns nun schon sehr gut bekannt; er bringt alle Spalten der Tabelle BUECHER_GEL dieses Datensatzes / dieses Buches aufs Tapet. Ausführung und Prüfsequenz, uns ebenso bekannt. Der Code

$basequery  = „UPDATE $table set „;
$query      = $basequery;

(ca. Zeile 47) definiert ein Basisquery. Nur Basis, weil an dieses Query noch Teile angefügt werden sollen. Beachte in diesem Zusammenhang das Leerzeichen zwischen dem „set“ und dem schließenden doppelten Anführungszeichen. Es folgt die altbekannte Struktur

while ( $row = mysql_fetch_assoc($result) )

welche in der Lage ist, das Objekt $result auszulesen. Du erinnerst dich, versprachlicht hieß es in unserem Block immer: „Solange, du, Parser/Codeinterpreter/Apache-Server … “ usw. Mit

$feldname = $row[‚Field‘];

wandert der Name des Feldes, man könnte auch sagen, der Schlüssel (im Gegensatz zum Schlüsselwert) in die Variable $feldname. Lautet dieser beim Ablauf gerade ‚zufällig‘ ID, wird der Schleifendurchlauf mit continue unterbrochen und die Schleife mit der nächsten Bedingung fortgesetzt. Dies geschieht, damit das Feld ID im Gegensatz zu den anderen nicht gelöscht, nicht seines Inhalts beraubt wird. Lautet das Feld also nicht ID, wird der Query-SQL-String erweitert. Das geschieht mit

$query = $query . „$feldname = NULL, “ ;

Beachte! $query wird hier nicht neu gesetzt, sondern es wird immer $feldname = NULL an das schon bestehende Query angehängt. In der Folge wird das Ende dieses langen SQL-Befehls bearbeitet:

// Jetzt noch das Ende des SQL Strings fixen
$query = $query . „END where id =’$id'“;
$query = str_replace(‚, END‘, “ , $query);

Er erhält ans Ende ein „END where id =’$id“ und ganz am Schluss wird, einem überflüssigen Wurmfortsatz gleich (du erinnerst dich an query.php?) das „END“ entfernt. In diesem Vorgehen ist ein Kunstgriff enthalten: Das letzte Komma muss entfernt werden. Sonst wäre der SQL-Befehl nicht stimmig. Wenn das Skript das

where id =’$id

anhängt, dann schreibt es gleichzeitig ein END davor. Dieses END ist kein Sprachelement und könnte genausogut Willi oder Ketchup lauten. Durch dieses END wird das letzte, zu löschende Komme identifizierbar. Denn es muss dasjenige das richtige, zu löschende Komma sein, das ein END nach sich stehen hat. Jetzt muss das Skript nur noch

, END

durch nichts ersetzen, schon sind wir das Komma los. Fertig ist der Befehl, und da wird er auch schon ausgeführt (ca. Zeile 69). Es folgt noch die obligate Prüfsequenz. Wir aber stoppen hier im Programmflow und schauen uns den Befehl erst einmal an. Er lautet im Fall Buch Winnetou III / MODIFY:

UPDATE BUECHER_GEL set
AutorNachname = NULL,
AutorVorname = NULL,
Titel = NULL,
Untertitel = NULL,
Ort = NULL,
Verlag = NULL,
Jahr = NULL,
Kategorie = NULL,
Art = NULL,
Uebersetzungvonin = NULL,
wanngelesenetwa = NULL,
Kommentar = NULL
where id =’86‘

Wir sehen sehr schön: Das Skript ist die Felder des Datensatzes/Buches Winnetou III abgelaufen und hat alles gleich NULL gesetzt, außer die identifizierende ID. Na, wenn alles so klar ist, fahren wir doch gleich fort. 🙂

Erst jetzt werden die vom Backend-Nutzer am Buch vorgenommenen Änderungen eingetragen; dazu wird wieder ein Basisquery definiert (ca. Zeile 83):

$basequery  = „UPDATE $table set „;
$query      = $basequery;

Es ist das bekannte Prinzip, den SQL-Befehl bzw. das Query beginnen zu lassen, dann wieder und wieder aufzufüllen, und dann sein Ende zu bearbeiten. Diesmal aber haben wir es mit dem SQL-Befehl UPDATE zu tun. Er wird unsere MODIFY-Absicht, besser: deine MODIFY-Absicht als Datenbank-Admin/Backend-Nutzer, in die Tat umsetzen. Die For-each-Schleife

foreach ($rawdata as $feld => $element)

musst du nicht als aktives Wissen verbuchen. Merke dir nur, dass eine solche Schleife prädestiniert ist, um ein assoziatives Array abzuklappern, zu durchlaufen. Hier in unserem Code wird bei jedem Schleifendurchlauf der Variablen $element der aktuelle Feldname des Buches zugewiesen und der Variablen $feld der aktuelle Inhalt des Feldes (ca. Zeile 88). Wie dann das UPDATE-Query gebaut wird, kennst du schon aus dem query.php-Skript. Auch das Wurmfortsatz-Abschneiden am Ende

$query = str_replace(‚, where‘, ‚where‘ , $query);

ist die schon bekannt. In ca. Zeile 109 dann bekommt die IF-Struktur ein ELSE, ein „sonst“. Wenn nämlich keine ID übergeben wurde, kann es sich nur um ein INSERT bzw. CREATE handeln. Woher auch sollte ein neu einzutragendes Buch eine ID haben, nicht wahr? Die kriegt es erst mit dem Neueintrag gleichzeitig und automatisch (man nennt das AUTO INCREMENT und es ist datenbankintern realisiert).

Ein UPDATE/MODIFY-Query würde dann folgendermaßen aussehen:

UPDATE BUECHER_GEL set AutorNachname = ‚May‘, AutorVorname = ‚Karl‘, Titel = ‚Winnetou III‘, Verlag = ‚Karl-May-Verlag‘, Kategorie = ‚privat‘, Art = ‚Roman‘, wanngelesenetwa = ‚2001‘, Kommentar = ‚Das beste der drei Winnetou-Bücher. Am Ende stirbt Winnetou rührend.’where id = ’86‘

Hier sehr schön zu sehen: Wir haben es mit Schlüssel-Werte-Paaren zu tun. Z.B. Verlag = „Karl-May-Verlag“. Am Ende des SQL-Befehls wird das Buch mit seiner ID identifiziert.

Dann wird wieder ein Basisquery gemacht, aber diesmal mit dem SQL-Befehl INSERT für: Füge ein Buch ein! Das Prinzip ist ansonsten gleich. Die vier Befehle

$felder = $felder . $feld . „,“;
$werte  = $werte . „‚“. $rawdata[$feld] . „‚,“;
// Query zusammenbauen
$query = $query . „$felder) values ($werte)“;
// Ueberzaehliges , herausloesen
$query = str_replace(‚,)‘, ‚)‘ , $query);

bauen das INSERT-Query zusammen. Nach der IF-Struktur wird dann ausgeführt, mit

$result=mysql_query($query);

also etwas uns sehr Bekanntem.

Ein INSERT/CREATE-Query würde dann so aussehen:

INSERT into BUECHER_GEL (AutorNachname,AutorVorname,Titel,Ort,Verlag,Jahr,Kategorie,Art,Uebersetzungvonin,wanngelesenetwa,Kommentar) values (‚McFadyen‘,’Cody‘,’Die Blutlinie‘,’Bergisch Gladbach‘,’Bastei Lübbe‘,’2006′,’privat‘,’Thriller‘,’Englisch – Deutsch‘,’2010′,’spannend‘)

Du siehst sehr schön – erst heißt es: Füge in BUECHER_GEL ein. Dann kommen links von values alle Felder und rechts von values alle Werte. Diese Syntax ist in SQL bindend und unser Skript hat sie auch korrekt gebaut.

Nach der üblichen Prüfsequenz folgt nur noch eine kurze HTML-Ausgabe, im Kern bestehend aus

Aenderung erfolgreich

oder

Neu-Eintragung erfolgreich

Dann schließt dieses dritte und letzte Skript noch das HTML-Dokument und die MySQL-Verbindung. Als allerletztes wird noch mit ?> das Skript geschlossen. Das Backend ist nunmehr voll einsatzfähig, Bücher können gelöscht, modifiziert, angeschaut oder (als Neueinträge) kreiert werden. Uff!

Wenn es auch etwas undramatisch und kleinlaut daherkommt, so sind wir jetzt doch am ENDE von WIE MAN EINE ACCESS-DATENBANK INS INTERNET BRINGT angekommen, denn nun ist auch das Backend mit seinen drei Skripten fertig. Täterätä! Tusch! 😉 Vielen Dank für dein Interesse und deine Aufmerksamkeit. Sicher sind noch Fragen offen geblieben. Nutze gerne die Kommentarfunktion dieses Blogs. Und natürlich immer wieder Sachen googlen und sich in Foren erkundigen. Auch kann man Bücher zu den Themen ausleihen oder kaufen. Es gibt in der IT-Welt unbegrenzte Möglichkeiten. Und nie sollten dabei der Spaß, die Fähigkeit, sich überraschen zu lassen und die Freude am Aha-Erlebnis in Vergessenheit geraten. Alles Gute, man sieht sich im Netz. Dein Streethawk68

Fine-Tuning am Blog erfolgt noch, Stand: 05.09.2015

 

Advertisements

Über streethawk68

43 years old IT-Fan
Dieser Beitrag wurde unter Uncategorized veröffentlicht. Setze ein Lesezeichen auf den Permalink.

2 Antworten zu Wie man eine Access-Datenbank ins Internet bringt (7)

  1. Alex schreibt:

    Hey Martin,
    hab es jetzt erstmal kurz überflogen. Auf jeden Fall sehr schönes Layout und gute, ausführliche Kommentare. Gefällt mir 🙂
    Über den Inhalt kann ich noch nicht viel sagen, aber ich werd mir hoffntlich mal am Wochenende die Zeit nehmen können, mal genauer zu lesen…
    LG, Alex

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s