Aktualität des Blogs

Verehrte User,

die sieben aufeinanderfolgenden Beiträge „PHP Basics“ sind jetzt schon was älter. Ich hoffe dennoch, dass ihnen noch sinnvolle und weiterführende Informationen zu entnehmen sind.

LG euer Streethawk

Veröffentlicht unter Uncategorized | Kommentar hinterlassen

PHP Basics (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

 

Veröffentlicht unter Uncategorized | 2 Kommentare

PHP Basics (6)

Nun, wir haben das PHP-Skript admin.php durchgearbeitet. Verkürzt kann man sagen, es war für die Präsentation der vier Administrations-Möglichkeiten zuständig. Löschen, modifizieren/aktualisieren, angucken oder erzeugen von Büchern in der Buch-Datenbank. Nun muss es natürlich auch einen Teil bzw. ein Skript geben, das diese Aktionen auszuführen in der Lage ist. Und das gibt es auch. Das nächste zu besprechende PHP-Skript heißt action.php. Wieder gebe ich es als erstes in ganzer Länge wieder:


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

// 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;

// Keine Aktion, keine Kekse.
if (array_key_exists('action', $rawdata))
{

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


<table>
    ';

    // Was soll gemacht werden
    $action = $rawdata['action'];

    // Mit welcher ID?
    $id     = $rawdata['id'];

    // Aktion muss Kleinbuchstaben sein
    $action = strtolower($action);

    // Wenn wir eine ID haben den Datensatz holen
    if ($id)
    {
        // Mit der ID den Datensatz abfragen
        $query      = "select * from $table where id = '". $id . "'";
        $result     = mysql_query($query);

        // Und sich den Datensatz merken, wird fuer VIEW und MODIFY benoetigt
        $datensatz  = mysql_fetch_assoc($result);

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

    }

    // DELETE
    // Datensatz loeschen, das muessen wir nicht extra via HTML Form/POST
    // einem weiteren Script geben, das koennen wir hier direkt erledigen
    if ( $id and ($action == "delete") )
    {
        // Datensatz loeschen
        $query  = "delete from $table where id = '". $id . "'";
        $result = mysql_query($query);

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

        echo "

Loeschung erfolgreich";
        echo "
";
        echo '<a href="admin.php">Zurueck zur Admin-Seite</a>';
    }

    // VIEW
    // Datensatz anzeigen
    if ( $id and ( $action == "view" ) )
    {
        // Den bereits abgefragten Datensatz "ablaufen"
        foreach ($datensatz as $feld => $element)
        {
            // Alle Felder ausser dem Feld 'id' anzeigen
            // Man koennte auch die ID mitausgeben, aber viel Nutzen hat
            // diese Information nicht...
            if ($element and ($feld != "id") )
            {
                echo "

<tr>";
                echo "

<td>$feld</td>


";
                echo "

<td>$element</td>


";
                echo "</tr>


";
            }
        }
    }

    // CREATE
    // MODIFY
    //
    // CREATE und MODIFY sind an sich sehr aehnlich
    // Fuer beides braucht man eine Eingabemaske fuer Datensaetze
    // Bei MODIFY waeren die Felder vorbelegt (man will ja etwas aendern).
    // Bei CREATE sind die Felder natuerlich alle leer
    //
    // Unterscheiden laesst sich das relativ einfach
    // Wurde eine ID mit uebergeben (also ausgewaehlt)
    // ist es ein MODIFY, ansonsten ein CREATE

    if ( ($action == "create") or ($action == "modify") )
    {

        // Da beide Vorgaenge nur dadurch definiert werden ob
        // es eine ID ausgewaehlt wurde, entsprechenden Hinweis geben
        if ( ($action == "create") and $id )
        echo "Create mit einer ID ist ein Modify 🙂 
";

        // Nur hier macht ein submit Sinn
        echo "

<form action = \"change.php\" method = \"post\">";

        // Datenbank nach Tabellenkoepfen fragen
        $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);
        }

        // Noch ein bisschen HTML
        echo "

";
        echo "Bitte in die entsprechenden Felder eintragen";

        // Aus der Tabellendefinition die Eingabefelder aufbauen
        while ( $row = mysql_fetch_assoc($result) )
        {
            $feldname = $row['Field'];
            $typ      = $row['Type'];

            $inhalt = $datensatz{$feldname};
            $sauber = trim($inhalt);
            $inhalt = $sauber;
    
            // Groesse 
            $fieldsize  = ereg_replace("[^0-9]", "", $typ);
   
            // Das Feld 'id' soll ausgeblendet werden, muss
            // aber trotzdem uebergeben werden, daher wird 'id'
            // entsprechend "versteckt" uebergeben.
 
            if ( $feldname == "id" ) 
            {
                echo "<input type=\"hidden\" name=\"$feldname\" value=\"$inhalt\">"; 
                continue; 
            }            

            // Der Feldname der Tabelle
            echo "

<tr>";
            echo "

<td>$feldname</td>


";

            // varchar(1)
            if ( $fieldsize == 1 )
            {
                if    ($inhalt) { echo "

<td><input type=checkbox value=\"1\" name = \"$feldname\" checked></td>


"; }
                else            { echo "

<td><input type=checkbox value=\"1\" name = \"$feldname\"></td>


"; }
                echo "</tr>


";
            }    

            // Von vchar(2) bis vchar(199) = textinput = Eingabezeile
            if ( ($fieldsize > 1) AND ($fieldsize < 200) )
            {
                if    ($inhalt) { echo "

<td><input size=\"80\" name=\"$feldname\" value=\"$inhalt\"></td>


"; }
                else            { echo "

<td><input size=\"80\" name=\"$feldname\"></td>


"; }
                echo "</tr>


";
            }    

            // Ab vchar(200) macht eine textarea Sinn 
            if ( $fieldsize >= 200 )
            {
                if    ($inhalt) { echo "

<td><textarea cols=\"80\" rows=\"5\" name=\"$feldname\">$inhalt</textarea></td>


"; }
                else            { echo "

<td><textarea cols=\"80\" rows=\"5\" name=\"$feldname\"></textarea></td>


"; }
                echo "</tr>


";
            }    

        }
    // Und hier wieder ein Submit
    echo '


        <input type="submit"/> <input type="reset"/>
        

        </form>


    ';

    }
}

// HTML sauber wieder schliessen
echo '
</table>


</body>
</html>
';
// Verbindung schliessen
mysql_close();
?>


Und wieder kannst du hier im Blog den Quer-Scrollbalken nutzen, um bis ans Ende der Zeilen schauen zu können.

Jetzt krieg erst mal keinen Schock. Ich weiß, das ist ein langes, ein heftiges Skript. Aber wir gehen wieder, wie schon gewohnt, in kleinen und kleinsten Schritten vor. Ich werde dir jedes einzelne Code-Element erklärend darlegen. 🙂

Los geht’s! Die ersten beiden Zeilen unter „No Cache“ bewirken, wie in admin.php auch, dass der Browser die Seite nicht zwischenspeichert, da das Ablaufdatum in der Vergangenheit liegt.

Wieder muss das Skript die Zugangsdaten zur MySQL-Datenbank liefern. Sonst könnte kein Zugriff auf die Datenbank erfolgen. Fünf Elemente sind es, wie gewohnt. Das fünfte weist den Namen der betroffenen Datenbank-Tabelle der Variablen $table zu. Und wieder wird auch die Verbindung aufgebaut (mysql_connect und mysql_select_db).

Genau wie in admin.php wird jetzt der gesamte Inhalt von $_POST in die Variable $rawdata überführt. Und was ist das genau, was da überführt wird? Richtig! Das, was ein Besucher deiner Site ins Formular eingegeben hat. Welches Formular? Dasjenige, das die admin.php zuvor generiert hat. Es konnte ein Buch, verbunden mit einer Aktion, z.B. „angucken“ gewählt werden.

Vielleicht schauen wir uns mal an, was wir normalerweise nicht zu sehen kriegen im Programmflow: den Inhalt von $rawdata. Einmal angenommen, du als Datenbank-Administrator und Backend-Nutzer hättest das Buch Winnetou III und damit verbunden die Aktion „angucken“ gewählt (VIEW). In dem Fall enthielte $rawdata:

array(2) { [„id“]=> string(2) „86“ [„action“]=> string(4) „view“ }

Was bedeutet das? Es heißt: In $rawdata ist ein Array, also ein Datenfeld mit zwei Elementen. Im ersten Element ist dem Schlüssel id der Wert 86 zugeordnet, im zweiten Element ist dem Schlüssel action der Wert view zugeordnet. Beide Schlüssel sind vom Typ String, also Zeichenkette. Die erste Zeichenkette hat zwei Stellen, die zweite vier. Woher stammen die Daten? Antwort: Du als Backend-Nutzer hast dich für das Buch Winnetou III entschieden (id 86) und für die Aktion view, das Buch Winnetou III soll also angeschaut werden. Jetzt wissen wir, was in $rawdata enthalten ist.

Zur Zwischenorientierung: Wir bewegen uns derzeit im PHP-Skript action.php.

Was folgt, ist eine sehr umfassende IF-Struktur. Betrachte das Skript bei ca. Zeile 21:

if (array_key_exists(‚action‘, $rawdata))

Danach folgt eine öffnende geschweifte Klammer, welche die IF-Struktur beginnen lässt. Sie schließt sich erst wieder bei ca. Zeile 254, ist also wirklich umfassend. Und welche Bedingung wird hier formuliert und für welchen Programmablauf? Antwort: Wenn der Schlüssel action im Array $rawdata vorhanden ist, ja dann, und nur dann wird der Programmablauf zwischen den äußersten geschweiften Klammern ausgeführt. Konkret heißt das, der Backend-Nutzer muss sich für eine der vier Aktionen DELETE, MODIFY, VIEW oder CREATE entschieden haben, sonst geschieht nichts.

Na gut, wenden wir uns dem zu, was zwischen diesen äußersten geschweiften Klammern steht. Hier wird erst mal wieder ein HTML-Kopf gebaut. „echo“ erzeugt eine Ausgabe, das einfache Anführungszeichen lässt beginnen, was ausgegeben werden soll. Ignoriere hier ruhig den DOCTYPE-Teil, er ist für uns jetzt nicht so wichtig. <html> öffnet ein HTML-Dokument. <head> öffnet dessen Kopfbereich. Zwischen <title> und </title> steht, was im Browser-Tab zu sehen sein soll: „Buecher Datensatz“. </head> schließt den HTML-Kopf. <body> öffnet den Körperbereich. <table> lässt eine Tabelle beginnen. Das einfache Anführungszeichen und das Semikolon beenden den echo-Befehl. So far, so good. 🙂

$action = $rawdata[‚action‘];
$id     = $rawdata[‚id‘];

Jetzt holt das Skript (klar, wir sind immer noch bei action.php) aus dem Array $rawdata den Wert des Schlüssels action heraus und speichert ihn in der Variable $action. Sie beinhaltet jetzt eine der vier möglichen Aktionen DELETE, MODIFY, VIEW oder CREATE. Welche? Na die, die der Backend-Nutzer gewählt hat. Dann holt das Skript den Wert den Schlüssels id aus dem Array $rawdata. Welche ID? Na die, die zu dem Buch gehört, das der Backend-Nutzer gewählt hat.

Mit

$action = strtolower($action);

wird sichergestellt, dass der Action-Wert in Kleinbuchstaben vorliegt. Nun folgt eine IF-Struktur innerhalb der sehr umfassenden IF-Struktur:

if ($id)

Nur, wenn es id auch gibt, geht es überhaupt weiter. Mit dieser nun in $id gespeicherten ID wird nun eine SQL-Abfrage generiert:

select * from $table where id = ‚“. $id . „‚

Das heißt: Wähle alle Felder aus der Tabelle BUECHER_GEL, dort, wo die ID 86 lautet. Also

Autor Nachname
Autor Vorname
Titel
Untertitel
Ort
Verlag
Jahr
Kategorie
Art
Übersetzung von – in
wann gelesen etwa
Kommentar

bei ID 86.

$result = mysql_query($query);

Führe diese Abfrage aus und speichere das zurückerhaltene Objekt in der Variable $result. Wie viele Datensätze bzw. Bücher ergibt die Abfrage? Richtig, eins. Nur Buch 86. Diesen Datensatz merkt sich das Skript jetzt noch mittels

$datensatz  = mysql_fetch_assoc($result);

… also der üblichen Objekt-auslesen-Struktur. Es folgt jetzt noch kurz die obligate Prüfsequenz, sollte bei der Abfrage etwas schiefgelaufen sein. Zur Orientierung: Wir haben jetzt ca. Zeile 67 von action.php passiert.

Und es geht weiter. 🙂 Es folgt der Codeblock zum Löschen eines Buches. Dazu braucht es kein HTML-Formular. Weißt du auch warum? Genau, es werden ja dabei keine Felder modifiziert, sondern das ganze Buch mit allen seinen zwölf Feldern wird gelöscht.

if ( $id and ($action == „delete“) )

sagt: Wenn eine ID gesetzt ist und die Variable $action den Wert delete hat, nur dann führe das Folgende aus. Und dieses Folgende beginnt mit wieder mit der Zuweisung einer SQL-Abfrage:

delete from $table where id = ‚“. $id . „‚

Das heißt: Lösche alle Felder, lösche den ganzen Datensatz, lösche das ganze Buch aus der Tabelle BUECHER_GEL dort, wo die ID 86 lautet. Der edle Indianer soll nicht mehr sein, Winnetou III muss in die ewigen Jagdgründe gelangen.

$result = mysql_query($query);

führt das auch wirklich aus und speichert wie immer das Ergebnis in $result. Nachdem der Indianer seiner Datenbank-Existenz beraubt wurde, informiert uns

echo „<p>Loeschung erfolgreich“;
echo „<br />“;
echo ‚<a href=“admin.php“>Zurueck zur Admin-Seite</a>‘;

darüber und gibt einen Link aus, mit dem wir zur Admin-Seite/zum Admin-Skript admin.php zurück können. Glückwunsch! 🙂 Du hast den DELETE-Block verstanden.

Machen wir doch gleich weiter mit dem VIEW-Block.

if ( $id and ( $action == „view“ ) )

Dieser IF-Struktur-Beginn fragt wie schon üblich nach der vom Backend-Nutzer gewählten Aktion. Der nachfolgende Programmcode wird nur ausgeführt, wenn sie view lautet.

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

Die sogenannte FOR-EACH-Schleife ist prädestiniert zum Ablaufen von Datenfeldern. Sie lautet versprachlicht: Aus dem Datensatz $datensatz weise bei jedem Schleifendurchlauf der Variablen $feld den Feldnamen (Array-Schlüssel) zu und weise bei jedem Schleifendurchlauf der Variablen $element den Schlüssel-Wert zu. Das klingt dir zu schwer? Dann programmiere es einfach trotzdem. Man kann nicht verlangen, dass alles aktives Wissen wird. Merke dir nur, dass die FOR-EACH-Schleife die zwölf Felder des gewählten Buches abklappert.

if ($element and ($feld != „id“) )

heißt: Der Parser/Interpreter/Apache-Server soll alle Felder nehmen, außer ID. Das dreizehnte, normalerweise unsichtbare Feld ID wird hier nicht gebraucht. Der Block

echo „<tr>“;
echo „<td>$feld</td>“;
echo „<td>$element</td>“;
echo „</tr>“;

sorgt für die tabellarische Ausgabe des Buches. Schaltflächen zum Absenden oder Zurücksetzen werden bei view nicht gebraucht, und, wie du in Bild 6-1 siehst, auch nicht angezeigt.

keine_Schaltflaechen_notwendig-02

Bild 6-1

Du hast den VIEW-Block geschafft.

Die Blöcke CREATE und MODIFY sind an sich sehr ähnlich. Beide machen eine Eingabemaske für die Datensätze erforderlich. Bei MODIFY wären die Felder vorbelegt (denn man will ja etwas ändern), bei CREATE sind die Felder natürlich alle leer. Unterscheiden lässt sich das relativ einfach: Wurde eine ID mit übergeben (also ausgewählt), ist es ein MODIFY, ansonsten ein CREATE.

if ( ($action == „create“) or ($action == „modify“) )

Das liegt bei ca. Zeile 123. Die IF-Struktur behandelt erst mal beide Fälle. Im Falle CREATE

if ( ($action == „create“) and $id )

wird das externe PHP-Skript change.php (wechsle!) aufgerufen. Das geschieht mit:

<form action = \“change.php\“ method = \“post\“>

Wir werden dieses Skript in „Wie man eine Access-Datenbank ins Internet bringt (7)“ noch genauestens besprechen.

Jetzt aber erst mal eine erneute SQL-Abfrage:

show columns from $table

heißt: Zeige alle Spalten der Tabelle BUECHER_GEL. Das Ergebnis landet wie immer in $result. Und wieder die Prüfsequenz, also alles wie gehabt und bekannt. Vor der Schleife noch ein kurzer HTML-Teil:

echo „<p>“;
echo „Bitte in die entsprechenden Felder eintragen“;

Es folgt eine große Schleife. Sie reicht von ca. Zeile 151 bis ca. Zeile 201. Die Schleife selber lautet:

while ( $row = mysql_fetch_assoc($result) )

… also: Solange du, Parser/Interpreter/Apache-Server Datensätze bei der Spaltenausgabe finden kannst, führe den Code innerhalb der geschweiften Klammern aus. Hör damit auf, wenn du beim letzten Datensatz angelangt warst. Wir erhalten also die Tabellen-Spaltennamen aller Bücher.

$feldname = $row[‚Field‘];
$typ      = $row[‚Type‘];

Erinnert sehr an unser gutes altes query.php, nicht wahr? Der Variablen $feldname wird der Name des Feldes zugewiesen, z.B. „Verlag“. Der Variablen $typ wird der Typ des Feldes zugewiesen, z.B. „varchar(100)“, das wäre dann der Typ „variable Zeichenanzahl mit 100 Zeichen“. Der Variablen $inhalt wird der Inhalt des aktuellen Feldes zugewiesen, z.B. „Karl-May-Verlag“. Mit

$sauber = trim($inhalt);
$inhalt = $sauber;

werden Leerzeichen, die am Beginn oder am Ende von $inhalt sein könnten, entfernt. Mit

$fieldsize  = ereg_replace(„[^0-9]“, „“, $typ);

wird die Größe des Feldes ermittelt, also die Anzahl der Zeichen. Die Funktion ereg_replace entfernt hier alles, was keine Ziffer ist. Aus „varchar(100)“ wird so „100“.

Wenn die Schleife gerade bei der id vorbeikommt, der Namen des Feldes also „id“ lautet, wird das Formularelement

<input type=\“hidden\“ name=\“$feldname\“ value=\“$inhalt\“>

ausgegeben. Versteckt (hidden), weil die ID nicht zu sehen sein muss. Übergeben werden muss die ID dennoch, wie sonst sollte das letzte Skript change.php (Blog-Teil 7) seine SQL-Befehle an das richtige Buch adressieren? Und dann wird mittels „continue“ der Schleifendurchlauf an dieser Stelle unterbrochen (ID wird nicht in den echo-Ausgabe-Prozess übernommen) und die Schleife wird mit der nächsten Bedingung fortgesetzt. Danach folgt mit echo die Ausgabe des Feldnamens, z.B. „Verlag“ unter Heranziehung der eben gefüllten Variable $feldname. Die Tabellen-Tags erspare ich uns jetzt alle mal, die kennst du ja (Tabelle auf, Tabellenreihe auf, Tabellendaten auf, Tabellendaten zu, Tabellenreihe zu, Tabelle zu).

Es folgen nacheinander drei IF-Strukturen in der IF-Struktur in der umfassenden IF-Struktur, also dritte IF-Ebene. Diese drei sind für folgende Fälle:

  1. Feldgröße gleich 1
  2. Feldgröße größer 1 kleiner 200
  3. Feldgröße 200 oder größer

Abhängig davon wird

  1. ein Kontrollkästchen angelegt (checkbox)
  2. ein Eingabefeld angelegt (einfaches input)
  3. ein Textfeld angelegt (textarea)

Option 1 ist überflüssig, denn in der Tabelle BUECHER_GEL ist kein Feld nur ein Zeichen groß. Option 3 ist sinnvoll für Titel, Untertitel und Kommentar, weil diese recht lang werden können, kommt auf das Buch an. Also: abhängig von der Feldgröße wird das passende Eingabeformular-Element mit echo ausgegeben.

Wir haben es gleich! 🙂

Es folgen die Schaltflächen fürs „Absenden“ und „Zurücksetzen“ (letzteres, wenn der Backend-Nutzer sich mal vertippt hat und das auch gleich merkt). Zum Schluss wird wieder so einiges geschlossen:

  1. die Schleife
  2. der Abschnitt (Paragraph)
  3. das Formular
  4. der echo-Teil mit beendendem einfachen Anführungszeichen
  5. der PHP-Befehl mit einem Semikolon
  6. die größere IF-Struktur und die umfassende IF-Struktur
  7. die Tabelle
  8. der HTML-Körper
  9. das HTML-Dokument
  10. nochmal ein PHP-Befehl
  11. die SQL-Verbindung
  12. und dann noch das ganze Skript

Fast fertig! 🙂 Nur noch ein paar Erläuterungen: Das soeben besprochene Skript action.php leistet, dass die Feldnamen samt ihren Inhalten aufgelistet werden. Alles immer für genau ein Buch. view zeigt nur das Buch an, wie es ist. create und modify liefern Eingabefelder, denn sowohl, wenn der Backend-Nutzer ein neues Buch anlegen will, als auch wenn er ein Buch modifizieren will, braucht er natürlich Eingabefelder. Und die vierte Option delete für löschen hatten wir ja eben schon.

Das von action.php somit bereitgestellte Eingabe-Formular ruft dann zur Weiterverarbeitung das Skript change.php auf. Sofern vom Backend-Nutzer nicht view oder delete gewählt wurde. change.php besprechen wir im Blog-Teil 7 gleich im Anschluss.

Herzlich Glückwunsch! Du hast das Skript action.php geschnallt. Oder doch noch nicht so ganz? Dann bitte tüchtig googeln, in Foren fragen, dieses Blog kommentieren …

Navigiere nun bitte zum nächsten Eintrag von streethawk68: Wie man eine Access-Datenbank ins Internet bringt (7)

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , | Kommentar hinterlassen

PHP Basics (5)

Was wir bis jetzt gebaut haben, könnte man auch als rudimentäres Frontend bezeichnen. Deine Seitenbesucher klopfen vorne (Front) auf deiner Seite an und können Bücher suchen und finden. Was aber, wenn du gern in der Lage wärst, auch mal ein Buch aus der Datenbank wieder zu löschen? Oder, wenn du einen Fehler in einem Feld bemerkt hast, den Bucheintrag zu korrigieren, das heißt zu ändern? Oder, zum dritten, was, wenn ein neues Buch hinzu soll, also die Datenbank um einen Datensatz erweitert werden soll? Das sind Backend-Aufgaben und deswegen werden wir in diesem Blog-Teil (5) ein kleines Backend bauen.

Der erste Schritt für unser Backend ist, einen separaten Ordner auf dem Webspace anzulegen. Dieser Ordner soll die Backend-Dateien aufnehmen. Und weil die Backend-Arbeit quasi eine datenbank-administrative Tätigkeit ist, nennen wir den Ordner „admin“. Öffne jetzt dein FTP-Programm, verbinde dich in der beschriebenen Weise mit deinem Webspace und steuere den Unterordner „meine_datenbank“ an. Im Unterordner angekommen, machst du einen Rechtsklick und wählst „Verzeichnis erstellen“. Nenne den Unterordner (der ein Unterunterordner ist) „admin“. Hier hinein werden wir später, wenn fertig, die PHP-Skripte action.php, admin.php und change.php hochladen. Diese Dreierkombi wird leisten, was gerade besprochen wurde, z.B. wird sie neue Bücher anlegen können.

Weil aber Sicherheit immer vorgeht, beginnen wir auch damit und spendieren unserem neuen Admin-Bereich als erstes einen .htaccess-Schutz. Ja, der Punkt vor dem „h“ ist schon korrekt. Das Verfahren dazu solltest du beherrschen, denn wir haben schon den Ordner „meine_datenbank“ geschützt. Nein? 🙂 Na gut, dann wiederhole ich es für dich, wenn auch kürzer. In Schaubildern zeige ich dir erst die Ordnerstruktur, wie ich sie meine.

Sieh als erstes den Ordner „admin“ im Ordner „meine_datenbank“ Bild 5-1 Sehr schön zu sehen hier auch die .htaccess und die .htpasswd. Diese beiden schützen den Ordner „meine_datenbank“.

Ordnerstruktur01

Bild 5-1

Sieh danach in den Ordner „admin“ hinein. Bild 5-2

Ordnerstruktur03

Bild 5-2

Sehr schön ist hier zu sehen, wie auch dieser Ordner noch mal mit einer .htaccess und einer .htpasswd geschützt ist. Was ist der Sinn dahinter? Der Sinn dahinter ist, dass ein Besucher deiner Seite bis zur „index.html“ gelangt und von ihr willkommen geheißen wird. Will er zur Datenbank, braucht er schon von dir die Login-Daten. Aber nur du selber sollst ins Backend gelangen können. Um das zu tun, gibst du in die Adresszeile deiner Browsers ein:

http://www.willi-heinz.de/meine_datenbank/admin/admin.php

Wobei willi-heinz für deine Webpräsenz steht, deine gemietete Domain.

Das System soll dich dann nach einem zweiten Login fragen, der den Zugang zum Backend gewährt. Diesen Login bauen wir jetzt, das heißt, wir bringen die .htaccess und die .htpasswd in den Ordner admin.

Wie über den letzten Schaubildern versprochen, wiederhole ich jetzt noch mal kurz das Schutz-Verfahren für dich: Logge dich am Portal deines Anbieters ein. Navigiere zum von dir gemieteten Paket. Suche den Bereich, auf dem die Software für Einstellungen an deinem Webspace läuft. Bei Greatnet und Alfahosting heißt sie z.B. Confixx.

Confixx-01

Bild 5-3

In Bild 5-3 erkennst du, wie das aussehen kann. „Jetzt in Confixx einloggen“ führt zur Software, die für Einstellungen auf deinem Webspace da ist. Klicke das. Dann suche einen Bereich, der z.B. „Tools“ heißt und darin einen Bereich, der „Passwortschutz“ oder so ähnlich heißt. Navigiere durch Linkklicken zum Unterunterordner „…/meine_datenbank/admin“. Schütze den Ordner „admin“, indem du auf „schützen“ klickst. Bild 5-4

Passwortschutz_htaccess02

Bild 5-4

Vergib eine sichere Kombination aus Benutzername und Passwort. Diese sind jetzt nur für dich, denn nur du sollst Backend-Zugang haben. Logge dich aus. Warte 15 Minuten, danach hat das Portal deine Befehle sicherlich umgesetzt. Bleib in dieser Zeit auch mit deinem FTP-Programm offline. Geh dann mit deinem FTP-Programm wieder online. Im Idealfall sollte der Ordner „admin“ jetzt aussehen, wie Bild 5-2.

So, der Schutz für den Ordner „admin“ bzw. dein neues Backend wäre geschafft. Dann können wir uns jetzt ja in aller Ruhe mit den drei neuen PHP-Skripten bzw. den Dateien admin.php, action.php und change.php auseinandersetzen.

Als erstes liefere ich dir das Skript admin.php in seiner ganzen Länge und Pracht. Hab keine Angst! Wir gehen wieder in kleinen und kleinsten Schritten vor, damit du gut folgen kannst.


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

// 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;

// Abfrage aller verfuegbaren Einrichtungen
$query = "select id,Titel from $table ORDER by Titel";

// und die Abfrage starten
$result=mysql_query($query);

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

// HTML "Kopf"
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>
<form action = "action.php" method = "post">
<p>
<fieldset>
<legend>Buecher</legend>
<table>
';

// Ergebnis liefern, Ausgabe als HTML Tabelle
while ($row = mysql_fetch_assoc($result))
{
$id = $row['id'];
$Titel = $row['Titel'];

echo "<tr>";
echo "<td><input type=radio name=\"id\" value=\"$id\" /></td>";
echo "<td>$Titel</td>";
echo "</tr>";

}

// HTML sauber wieder schliessen
echo '
</table>
</fieldset>
<p>
<fieldset>
<legend>Aktion?</legend>
<label> <input type=radio name=action value="delete"> DELETE | </label>
<label> <input type=radio name=action value="modify"> MODIFY | </label>
<label> <input type=radio name=action value="view">   VIEW   | </label>
<label> <input type=radio name=action value="create"> CREATE  </label>
</fieldset>

<p><input type="submit" />
<input type="reset" />
</p>
</form>

</body>
</html>
';
// Verbindung schliessen
mysql_close();
?>

Benutze wieder den Quer-Scrollbalken, um bis ans Ende der Zeilen sehen zu können. Markiere den ganzen Code hier im Blog. Wähle „kopieren“ oder drücke STRG+C. Kreiere mit Notepad++ oder wie dein Editor heißt, eine admin.php. Füge den Code mit „einfügen“ oder STRG+V in das neue Skript ein. Speichere. Genieße die Aussicht des Syntaxhighlightings mit verschiedenfarbigen Elementen.

Kommen wir zur Erklärung des Codes. Zeile 1 beinhaltet wieder ein öffnendes

<?php

Alle PHP-Skripte beginnen so.

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

Diese Zeilen bewirken, dass der Browser die Seite nicht zwischenspeichert, da das Ablaufdatum auf jeden Fall in der Vergangenheit liegt. Anders herum könntest du so den Browser dazu bewegen, bestimmte Seiten bzw. Inhalte länger zu speichern. Das macht bei großen Portalen Sinn, die damit eine Menge Datenvolumen einsparen.

Als nächstes stehen im Skript die Zugangsdaten zur MySQL-Datenbank. Das Verfahren kennst du schon; es wurde in diesem Blog bereits erläutert. Kurze Wiederholung: Folgende Zugangsdaten benötigt der Apache-Server.

  1. Name der Datenbank
  2. Host
  3. Benutzername
  4. Passwort
  5. Tabellenname

Im Skript selber, das du hier im Blog siehst, sind anstelle der Zugangsdaten sieben Xe gepostet. Ich säubere geposteten Code immer von verräterischen Elementen. Schlag in diesem Blog weiter oben nach, wenn du dir nicht (mehr) sicher bist, was diese Zugangsdaten sind und bedeuten.

Als nächstes im Skript:

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

mysql_connect und mysql_select_db sind PHP-Funktionen, die als Parameter die Zugangsdaten erwarten und dann die Verbindung zur Datenbank herstellen.

Dann:

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

Hier wird alles, was per POST-Methode an das Skript übergeben wurde, in die Variable $rawdata überführt. Momentan allerdings ist das nichts. Dieser Code-Abschnitt ist an dieser Stelle überflüssig.

Es folgt:

// Abfrage aller verfuegbaren Einrichtungen
$query = „select id, Titel from $table ORDER by Titel“;

Hier wird die Variable $query mit einem String belegt. Dieser String enthält eine SQL-Abfrage. Über SQL (Structured Query Language) haben wir in diesem Blog schon gesprochen. Es ist dies eine extra Sprache zur Abfrage von SQL-Datenbanken. Was bedeutet dieser SQL-String bzw. -Befehl? Er bedeutet versprachlicht:

Wähle aus der Datenbank die Felder id und Titel aus der Tabelle BUECHER_GEL und ordne sie alphabetisch nach Titel. Das Skript admin.php hat die Aufgabe, alle Bücher anzuzeigen und dem Datenbank-Administrator, also dir, die Optionen

  1. Löschen (DELETE)
  2. Modifizieren/aktualisieren (MODIFY)
  3. Angucken (VIEW)
  4. Erzeugen (CREATE)

zu geben. Der oben angegebene SQL-Befehl wird dazu als erster Schritt gebraucht.

Im Skript heißt es als nächstes:

// und die Abfrage starten
$result=mysql_query($query);

// Auf Fehler pruefen
if (!$result)
{
$message  = ‚Invalid query: ‚ . mysql_error() . „\n“;
$message .= ‚Whole query:   ‚ . $query;
die($message);
}

Die Abfrage wird ausgeführt und das Ergebnis gleichzeitig in der Variablen $result gespeichert. Es folgt eine IF-Struktur, die dafür sorgt, dass, wenn hierbei etwas schiefgeht, wir teilweise erfahren, was schiefgegangen ist.

Übrigens bedeuten zwei Slashs am Anfang, dass es sich um eine Kommentarzeile handelt, die vom Parser/Interpreter/Apache-Server nicht interpretiert wird.

Als nächstes wird vom Skript (wir sind immer noch im admin.php) ein HTML-Kopf gebaut. Damit der PHP-Teil des Skripts nicht zuerst mit

?>

geschlossen werden muss, hilft man sich hier mit einem

echo ‚

also dem PHP-Ausgabebefehl und einem einfachen Anführungszeichen. Du findest es auf deiner PC-Tastatur, indem du UMSCHALT+# drückst. Der HTML-Teil kann beginnen. Dessen DOCTYPE-Unter-Teil kennst du schon zur Genüge aus diesem Blog. <html> und <head> leiten in üblicher Weise ein. Der im Browsertab anzuzeigende Titel ist „Buecher Admin GUI“. GUI steht dabei für Graphical User Interface, das heißt grafische Benutzerschnittstelle; nichts anderes ist nämlich unsere Datenbankpräsenz: Du als Datenbank-Administrator und Backend-Nutzer kann nachher schon rein optisch die Datenbank bedienen. Interessant ist die Zeile

<form action = „action.php“ method = „post“>

Was passiert hier? Antwort: Es wird ein Formular eingeleitet, in das deine Seitenbesucher später etwas eintragen können. Mit der Methode POST werden die vom Datenbank-Administrator und Backend-Nutzer, also dir, eingetragenen Daten an eine action.php gesendet. Danach werden mit

<fieldset>

die Elemente des Formulars besser gruppiert. Außerdem wird mit

<legend>

der Formularelementgruppe noch eine Überschrift verpasst: „Buecher“. Außerdem wird noch eine Tabelle gestartet <table>.

Damit du besser verstehen kannst, was hier im Code alles geschieht, zeige ich dir jetzt einen Ausschnitt dessen, was die admin.php im Browser anzeigen wird Bild 5-5:

var_dump-01

Bild 5-5

Die Kreischen sind sogenannte Radio-Buttons (runde Knöpfe). Alle 196 Bücher werden angezeigt, eins kann ausgewählt werden. Und dann noch vier Radio-Buttons für die gewünschte Aktion. Löschen? Modifizieren/aktualisieren? Angucken? Erzeugen? Eine Aktion kann in Verbindung mit dem Buch ausgewählt werden. Nie mehr, als ein Buch. Nie mehr, als eine Aktion mit diesem Buch.

Doch zurück zum Code. Der HTML-Teil wird mit

‚;

abgeschlossen. Das ist das beendende einfache Anführungszeichen und das den PHP-Befehl beendende Semikolon. So! 🙂

Du erinnerst dich? Wir haben in $result das Abfrage-Ergebnis von

select id, Titel from $table ORDER by Titel

also die Buch-ID und den Titel. Indes ist $result nicht etwa ein einfaches Array, sondern ein Objekt. Und als solches kann es auch nur mit

while ($row = mysql_fetch_assoc($result))
{
$id             = $row[‚id‘];
$Titel  = $row[‚Titel‘];

echo „<tr>“;
echo „<td><input type=radio name=\“id\“ value=\“$id\“ /></td>“;
echo „<td>$Titel</td>“;
echo „</tr>“;

}

ausgelesen werden. Du erinnerst dich wieder? Eine While-Schleife. Sie sagt versprachlicht: Solange du, Parser/Interpreter/Apache-Webserver, Zeilen aus dem Objekt herausholen kannst (fetch), gib sie aus in Verbindung mit einem Radio-Button namens id und weise dem Wert des Radio-Buttons die id zu. Dann schreibe daneben den Buchtitel des aktuellen Datensatzes bzw. der aktuellen Objektzeile. Die Schleife öffnet außerdem bei jedem Durchlauf eine Tabellenreihe <tr>. Dann wird bei jedem Durchlauf als Tabledata <td> ausgegeben: Der Radio-Button mit dem Namen id und der zur jeweiligen id gehörende Buch-Titel. Beide Tabellendaten werden an ihrem Ende wieder geschlossen </td> </td>.  Am Ende eines Schleifendurchlaufs wird auch die Tabellenreihe wieder geschlossen </tr>. Und das macht die Schleife jetzt 196 mal, nämlich für jedes Buch einmal.

Zum Ende dieses Skripts admin.php werden noch die vier Aktions-Radio-Buttons ausgegeben. Sie haben alle den Namen action (sie gehören ja auch zusammen) und die vier Werte delete, modify, view und create. Dann müssen noch Schaltflächen zum Formularabsenden und zum Zurücksetzen bei Usertippfehlern gemacht werden:

<input type=“submit“ />
<input type=“reset“ />

Dann wird so einiges geschlossen:

</p>
</form>
</body>
</html>
‚;
mysql_close();
?>

Der Absatz (Paragraph), das Formular, der HTML-Körper des HTML-Dokuments, das HTML-Dokument, der HTML-Teil, die MySQL-Verbindung und das PHP-Skript. Fertig! 🙂 Du hast admin.php begriffen. Wenn nein, wie immer: googeln, Foren, hier kommentieren.

Navigiere nun bitte zum nächsten Eintrag von streethawk68: Wie man eine Access-Datenbank ins Internet bringt (6)

 

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , | Kommentar hinterlassen

PHP Basics (4)

Drei Schätze haben wir bisher: die Datenbank, die schon auf deinem Webspace unter phpMyAdmin läuft, die query.html und die query.php. Wo sollen die letzteren beiden eigentlich hin? Erstellt hast du sie schon? Sonst tu das bitte genau jetzt. Nutze dazu, wie gesagt, einen guten Editor mit Syntaxhighlighting, z.B. Notepad++. Alternativen wären z.B. der Weaverslave (das Weberknecht-Spinnentier 🙂 ) oder PSPad. Da wir gerade darüber sprechen: in „Wie man eine Access-Datenbank ins Internet bringt (2)“ ist ja die query.html komplett abgedruckt. Allerdings steht in ihrer Zeile 12:

<form action = „XXXXXXX“ method = „post“>

Ersetze „XXXXXXX“ durch die Zeichenfolge „query.php“. Hintergrund: Das Formular der query.html soll die Formulardaten an die query.php senden. Übrigens mit der Methode POST. Die sieben Xe hatte ich sicherheitshalber eingefügt, weil ich geposteten Code immer von verräterischen Teilen säubere. Okay, du hast jetzt beide Dateien irgendwo auf deiner Festplatte. Wohin also sollen sie im weiteren Verlauf? Die Antwort lautet: das sage ich dir erst, wenn wir über FTP gesprochen haben.

Die Rolle von FTP bei unserem Vorhaben

FTP steht für File Transfer Protocol. Ähnlich dem bekannten Hyper Text Transfer Protocol (http:// bekannt aus der Browser-Adress-Zeile) leistet es Datenübertragung. Mit diesem Protokoll kannst du Daten von deiner lokalen Festplatte auf deinen angemieteten Webspace hochladen oder vom Webspace auf deine lokale Festplatte herunterladen. Alles, was du dazu brauchst, ist ein FTP-Tool, ein FTP-Programm. Ich möchte hier mal ausnahmsweise eine deutliche Empfehlung aussprechen: FileZilla. Dieses FTP-Programm ist echt okay. Es ist auch kostenlos und auf Open-Source-Basis gehalten. Alternativen wären WS_FTP oder Netdrive. Installiere dir also ein FTP-Programm.

FTP-Programm_Elemente01

Bild 4-1

So, wie versprochen sage ich dir jetzt, wohin die query.html und die query.php kommen. Sie kommen in dein html-Verzeichnis und dort in das Unterverzeichnis „meine_datenbank“. Um Bekanntschaft mit diesem html-Verzeichnis zu machen, gib im FTP-Programm unter „Server“ ein: ftp.deine-domain.de.

Bild 4-1 Pfeil 1

Das heißt, wenn deine Domain (der URL deiner Internetseite, den du ja von deinem Webspace her kennst) lautet http://www.willi-heinz.de, dann gibst du im FTP-Programm in das Feld Server „ftp.willi-heinz.de“ ein. Daneben oder darunter ist das Feld Benutzername.

Bild 4-1 Pfeil 2

Hier gibst du den von deinem Anbieter/Hoster genannten Benutzernamen ein, z.B. „web444“. Daneben oder darunter wiederum ist das Feld „Passwort“.

Bild 4-1 Pfeil 3

Hier gibst du nun aber weder das Passwort für deinen Login im Portal deines Anbieters noch das Datenbank-Passwort ein. Sondern du gibst das FTP-Passwort deines Webspaces ein. Du findest es von Anbieter zu Anbieter an unterschiedlichen Stellen.

Bsp. Alfahosting: AM PORTAL EINLOGGEN / KUNDENCENTER / MEINE VERTRÄGE / (EIGENES PRODUKT WÄHLEN) / FTP-ZUGANGSDATEN / FTP-PASSWORT. Du musst dich da ein wenig bis zum Ziel durchklicken.

Daneben oder darunter ein drittes Mal ist das vierte Feld Port.

Bild 4-1 Pfeil 4

Das kannst du im Allgemeinen freilassen, das übernimmt dein FTP-Programm für dich. Und es folgt ein heftiger Druck 🙂 auf die RETURN/ENTER-Taste und schwupps! bist du online auf dem Teil deines Webspaces, auf den du Dateien hochladen und von dem du Dateien herunterladen kannst. Natürlich kannst du statt RETURN/ENTER zu drücken auch „verbinden“ klicken.

Bild 4-1, Pfeil 5

Bevor du jetzt aber wie der Teufel die query.html und die query.php hochlädst (wie das geht, falls du es nicht schon gesehen/erahnt hast, sag ich dir gleich), sollten wir uns über das Thema Sicherheit unterhalten. Im Besonderen über das Thema .htaccess. Ja, der Punkt vor diesem Wort stimmt schon.

Du weißt ja, im Internet tummeln sich viele Scherzkekse, Scharlatane und böse Zeitgenossen. Deswegen ist es ratsam, deine schon bald voll internetfähige Datenbank mit einem .htaccess-Schutz zu versehen. Was ich dir dazu vorschlage ist, dass eine (von dir zu schreibende) index.html im Verzeichnis

DEIN WEBSPACE/html

liegt (ungeschützt, das ist okay), aber die query.html und die query.php im Verzeichnis

DEIN WEBSPACE/html/meine_datenbank

(geschützt). Folglich solltest vor dem Hochladen das hier tun: Finde den Bereich deines Webspaces im FTP-Programm. Bei FileZilla ist das der große Bereich im rechten unteren Drittel des Fensters, der offline schneeweiß bleibt. Dort sollte, wenn du FTP-online bist, das Verzeichnis „html“ zu finden sein. Klicke darauf doppelt. Wenn du die Maus so gern ignorierst, wie ich, kannst du auch mit den Pfeiltasten darauf gehen und RETURN/ENTER drücken. Jetzt befindest du dich im Verzeichnis „html“. Mache im freien, weißen Bereich einen Rechtsklick. Wähle den Menüpunkt „Verzeichnis erstellen“. Im nun erscheinenden Eingabefeld ist schon der Pfad vorgegeben:

DEIN WEBSPACE/html/

Wähle als Verzeichnisnamen „meine_datenbank“ hinter dem letzten Slash. Ohne die Anführungszeichen natürlich! Drücke RETURN/ENTER. Du hast jetzt im Verzeichnis „html“ das Unterverzeichnis „meine_datenbank“ erstellt. Achte bei solchen Webspace-Aktionen immer auf die Groß- und Kleinschreibung. Das nimmt der Apache-Server sehr genau. „meine_datenbank“ ist nicht das Gleiche wie z.B. „Meine_Datenbank“. Nachdem du das Verzeichnis erstellt hast, solltest du ihm jetzt einen .htaccess-Schutz spendieren.

Die Dateien „.htaccess“ und „.htpasswd“ werden gleich im (Unter-)Verzeichnis „meine_datenbank“ auftauchen. Wir erstellen die beiden aber nicht selber und laden sie auch nicht dorthin, sondern das übernimmt der Anbieter bzw. dessen webseitige Anbietersoftware für uns.

Ich beschreibe jetzt den Weg beim Anbieter Alfahosting. Ich mache keine Werbung, wähle den Anbieter, wie du willst, aber ich brauche eine Referenz, auf die ich meine Anleitung beziehen kann. Bei anderen Anbietern ist der Weg wahrscheinlich ähnlich. Logge dich wieder mittels Browser auf deinem Anbieterportal ein. Bild 4-2

Einloggen_auf_Webspace01

Bild 4-2

Wähle das von dir angemietete Produkt. Wähle eine Schaltfläche, die in etwa so heißt wie „Jetzt in Confixx einloggen“. Danach bist du in der Software, die in meinem Beispiel „Confixx“ heißt.

Bild 4-3 Pfeil 1

Gemeint ist die Software, mittels derer du Einstellungen an deinem Webspace vornehmen kannst. Wähle jetzt im linken Bereich den Hauptpunkt „Tools“.

Bild 4-3 Pfeil 2

Wähle dann den Unterpunkt „Passwortschutz“.

Bild 4-3 Pfeil 3

Du bist jetzt im Bereich „Passwortschutz“.

Bild 4-3 Pfeil 4

Jetzt siehst du einen (noch kleinen) Verzeichnisbaum. Nämlich deine Verzeichnisse „html“ und darin „meine_datenbank“. In meinem Bild 4-3 steht „Bereich01“, wo aber bei dir „meine_datenbank“ stehen soll. Daneben ist ein Link / eine Schaltfläche „schützen“, wähle sie. Bild 4-3 Pfeil 5

Passwortschutz_htaccess01

Bild 4-3

Wichtig ist, dass du das Unterverzeichnis „meine_datenbank“ schützt und nicht das darüber „html“. Nun denk dir einen Benutzernamen und ein starkes Passwort aus. Manche Anbieter begrenzen für beides die mögliche Länge. Klicke dann „schützen“ oder „Verzeichnis schützen“ oder „ausführen“ oder „OK“ oder etwas Ähnliches.

Notiere dir Benutzernamen und Passwort sorgfältig. Bewahre die Notiz gut auf. Gib diesen Login nur an Menschen deines Vertrauens weiter.

Nun logge dich aus „Confixx“ (oder wie bei deinem Anbieter diese Software heißt) wieder aus. Logge dich nötigenfalls auch aus dem Portal wieder aus.

Nun heißt es, 15 Minuten zu warten. Während dieser Zeit sollte auch dein FTP-Programm offline sein. Nach Ablauf dieser Zeit geh wie beschrieben mit deinem FTP-Programm online. Im Unterverzeichnis

DEIN WEBSPACE/html/meine_datenbank

sollten nun die Dateien .htaccess und .htpasswd sein. Lass sie immer unangetastet. Lade sie auch nicht herunter und überschreibe sie nicht.

Lade nun die query.html und die query.php in das Unterverzeichnis „meine_datenbank“ hoch.

htaccess-Dateien01

Bild 4-4

Wie in Bild 4-4 sollte es dann auf deinem Webspace, betrachtet mit deinem FTP-Programm, aussehen.

Was haben wir da gerade eigentlich gemacht? Wir haben dafür gesorgt, dass deine Homepage http://www.willi-heinz.de (das ist nur ein Beispiel) zwar öffentlich bleibt. Dass aber der Unterbereich http://www.willi-heinz.de/meine_datenbank passwortgeschützt ist. Das heißt, wenn jemand http://www.willi-heinz.de ansurft, sieht er deine Homepage (was genau er sieht, werden wir gleich bauen), klickt er aber den Link, um zur Bücherdatenbank zu gelangen, wird sein Browser ihn auffordern, Benutzername und Passwort (von dir wie oben beschrieben festgelegt) einzugeben. Sonst ist Essig. Sonst kommt er nicht in den Bücherdatenbank-Bereich deiner Homepage. Und woher soll er das Passwort denn haben? Antwort: Du gibst das Passwort nur an Menschen deines Vertrauens weiter: Familienmitglieder, Freunde, gute Internetbekanntschaften, deine Mitschüler/Kommilitonen, deine Lehrer/Dozenten usw.

Eine index.html bauen

Nun, bis hierher hast du es geschafft? Nein? Kommentiere diesen Blog, frag mich, frage in Foren, Google, was auch immer. Manchmal ist der Durchbruch nur ein kleines Fehlerchen entfernt. Kapitulieren ist langweilig. 🙂

Wir werden jetzt die Datei index.html erstellen. Sie ist erster Ansprechpartner des Webservers, wenn ein Nutzer deine Bücherdatenbank-Homepage http://www.willi-heinz.de (das ist nur ein Beispiel) ansurft. Ich erlaube mir, die Datei hier erst mal komplett zu zeigen:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html>
    <head>
        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
        <title>Meine B&uuml;cherdatenbank im Internet</title>
    </head>
    
    <body bgcolor="#d4cae2">
    <font size="4" face="Arial,MS Sans Serif">

<h3>Meine B&uuml;cherdatenbank im Internet</h3>

    
    Hallo Besucher! <a href="meine_datenbank/query.html">Hier</a> geht es zu meiner B&uuml;cherdatenbank.
    Viel Spa&szlig;!
    </font>
    </body>
</html>

Code 4-1 (index.html)

So sieht die „index.html“ im Browser dargestellt aus:

index_html_im_Browser01

Bild 4-5

Achte wieder darauf: Dein Windows soll die Dateinamenerweiterungen anzeigen. Bei einem Word-Dokument nicht nur beispiel, sondern eben beispiel.docx. Bei einem Bild nicht nur beispiel, sondern eben beispiel.jpg. Bei unserer index.html nicht nur index, sondern eben index.html. Du erreichst das im Windows-Explorer unter den Ordneroptionen.

Erstelle nun auf deiner Festplatte diese index.html. Es ist jetzt wieder an der Zeit für ein bisschen HTML-Theorie. Wie ist die index.html aufgebaut? Am Anfang stehen zwei Zeilen, die dir schon aus der query.html bekannt sind:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

Sie sind eine Orientierung für den Code interpretierenden Browser. Ihre genaue Bedeutung kannst du momentan getrost ignorieren. Es folgt

<html>

womit die eigentliche Datei/das eigentliche Skript beginnt. Dieses Tag (sprich: täg) sagt: Lasse HTML-Code beginnen.

<head>

sagt: Lasse den Kopf des HTML-Skripts beginnen. Es folgt die Zeile

<meta http-equiv=“content-type“ content=“text/html; charset=UTF-8″>

Sie bindet ein sogenanntes Cascading Style Sheet (CSS) ein, das für das Design verantwortlich ist. Ignoriere auch diese Zeile getrost. Aber danach wird es interessant.

<title>Meine B&uuml;cherdatenbank im Internet</title>

sorgt dafür, dass im Tab des Browsers „Meine Bücherdatenbank im Internet“ angezeigt wird. Auch in der Titelleiste des Browsers wird das später stehen, wenn der Tab angewählt ist. Du wunderst dich über das „&uuml;“ statt des „ü“? Es codiert den Umlaut, sodass er, unabhängig vom verwendeten Zeichensatz, richtig dargestellt wird. Der Kopf des HTML-Dokuments ist damit zu Ende und ein

</head>

bestätigt das (Zeile 7).

Nach einer strukturierenden Leerzeile 8 wird in Zeile 9 die Hintergrundfarbe (bg = background) festgelegt. #d4cae2 ist ein Lila. Zeile 10 bestimmt Schriftgröße und Schriftart. Zeile 12 sorgt für eine Überschrift der Klasse 3, die wie der Titel lautet: Meine B&uuml;cherdatenbank im Internet. Alsdann folgt in Zeile 15 die Begrüßung. Was dann kommt und in <a> und </a> eingeschlossen ist, ist der Link zur Datenbank selber. Das gegenwärtige Dokument steht ja noch ungeschützt im Web, wer aber nun den Link klickt, wird zur Passworteingabe aufgefordert. So, wie wir es mit .htaccess gestaltet haben. Im gegenwärtigen Dokument werden dann noch der Körper und das ganze Dokument geschlossen:

</body>
</html>

Fertig. Zeit, diese „index.html“ auf deinen Webspace hochzuladen, und zwar ins Haupt-, das heißt ins html-Verzeichnis. Öffne dein FTP-Programm, verbinde dich in der beschriebenen Weise mit deinem Webspace und lade deine frische index.html ins Hauptverzeichnis html hoch. Sie landet also eine Ebene über „meine_datenbank“. Und weißt du, was jetzt ist? Juche! Jetzt bist du erst mal fertig! Du hast es geschafft. Deine Access-Datenbank wurde ins Internet gebracht. Jeder kann hinsurfen und mit dem von dir erhaltenen Login Bücher-Suchbegriffe eingeben und sich die Ergebnisse anzeigen lassen.

Herzlichen Glückwunsch! 🙂

Pause, feiern.

Navigiere nun bitte zum nächsten Eintrag von streethawk68: Wie man eine Access-Datenbank ins Internet bringt (5)

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , | Kommentar hinterlassen

PHP Basics (3)

PHP, wir erwähnten es in „Wie man eine Access-Datenbank ins Internet bringt (1)“ steht für „Hypertext Pre-Processor“. Die Abkürzung lautet kurioserweise tatsächlich so. PHP kann etwas, das für unsere Zwecke sehr hilfreich ist, nämlich …

… HTML-Code individuell erzeugen

Es geht jetzt um ein PHP-Skript. Es ist gleichzeitig die Datei query.php. Du wirst es später selber schreiben. Du wirst es dann implementieren. Wie das geht, steht in „Wie man eine Access-Datenbank ins Internet bringt (4)“. Es leistet dann die Ausgabe der Bücher-Such-Abfrage-Ergebnisse. Schauen wir es uns als erstes mal komplett an. Es hat 84 Zeilen. Keine Angst, wir gehen in kleinen und kleinsten Schritten voran.


<link rel="stylesheet" type="text/css" href="blog01_buecher.css" />
<?php
    
    $rawdata = $_POST;

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

    // Verbindung zur Datenbank herstellen
    mysql_connect($host,$user,$password);
    mysql_select_db($database) or die( "Unable to select database");
    
    // 1/2 Abfragen Spaltennamen holen und im ersten $result speichern
    $query = "show columns from $table";
    $result = mysql_query($query);
    
    // 2/2 Abfragen Basis-Query
    $query = "select * from $table where ";
    
    // 1/2 Schleifen holt Feldname und anhand dessen Feldinhalt
    
    while ( $row = mysql_fetch_assoc($result) )
    {
        $feldname = $row['Field'];
        $feldinhalt = $rawdata[$feldname];
    
        // Query erweitern, aber nur, wenn Wert eingegeben
        if (!$feldinhalt=="")
        {
            $query = $query . "$feldname LIKE '$feldinhalt%' and ";
        
        }
    }
    // nach Schleife Ende des Query-Strings abschneiden
    $queryohneende = substr($query, 0, -4);
    $query = $queryohneende;
    $queryplusorderby = $query . " order by AutorNachname";
    $query = $queryplusorderby;
    
    // Zweites Query ausführen
    $result=mysql_query($query);

    // Abfrage überprüfen
    if (!$result)
    {
        $message  = 'Invalid query: ' . mysql_error() . "\n";
        $message .= 'Whole query:   ' . $query;
        die($message);
    }

    // Ausgabe 2/2 Schleifen
    echo "<table cellspacing = '1' cellpadding = '5'>";
    
    $zaehler = 0;
    
    while ($dsatz = mysql_fetch_assoc($result))
    {
        $zaehler = $zaehler + 1;
        echo "<tr>";
        echo "<td class='author'>" . $dsatz["AutorNachname"] . "</td>";
        echo "<td>" . $dsatz["AutorVorname"] . "</td>";
        echo "<td class='title'>" . $dsatz["Titel"] . "</td>";
        echo "<td>" . $dsatz["Untertitel"] . "</td>";
        echo "<td>" . $dsatz["Ort"] . "</td>";
        echo "<td>" . $dsatz["Verlag"] . "</td>";
        echo "<td>" . $dsatz["Jahr"] . "</td>";
        echo "<td>" . $dsatz["Kategorie"] . "</td>";
        echo "<td>" . $dsatz["Art"] . "</td>";
        echo "<td>" . $dsatz["Uebersetzungvonin"] . "</td>";
        echo "<td>" . $dsatz["wanngelesenetwa"] . "</td>";
        echo "<td>" . $dsatz["Kommentar"] . "</td>";
        echo "</tr>";
    
    }
    echo "<b>Es wurde/n " . $zaehler . " Buch/Bücher gefunden</b>";
    echo "</table>";
    
    // Verbindung schliessen
    mysql_close();
?>

Die Zeile

<link rel=“stylesheet“ type=“text/css“ href=“blog01_buecher.css“ />

bindet ein Style-Sheet ein. Ignoriere sie fürs erste.

Wie jedes PHP-Skript, beginnt der Code mit einem öffnenden <?php

Es folgt die Überführung der (aus der query.html stammenden) $_POST-Daten in die Variable $rawdata.

$rawdata = $_POST;

Sie, die Variable $rawdata, enthält nun ein sogenanntes assoziatives Array. Das ist ein Datenfeld, in dem die Feldbezeichnungen mit dem Feldinhalt verbunden/assoziiert sind. Dieses Array hat alle Daten (Benutzer-Eingaben bzw. Bücher-Such-Begriffe), die der Benutzer kurz vor dem Absenden des html-Formulars gemacht hat. Das assoziative Array sieht jetzt so aus: (Das ist ein Beispiel, je nach den eingegebenen Suchbergriffen wäre es anders)

array(12) {
[„AutorNachname“]=> string(6) „Frisch“
[„AutorVorname“]=> string(3) „Max“
[„Titel“]=> string(7) „Andorra“
[„Untertitel“]=> string(0) „“
[„Ort“]=> string(17) „Frankfurt am Main“
[„Verlag“]=> string(8) „Suhrkamp“
[„Jahr“]=> string(4) „1975“
[„Kategorie“]=> string(11) „Germanistik“
[„Art“]=> string(13) „Theaterstueck“
[„Uebersetzungvonin“]=> string(0) „“
[„wanngelesenetwa“]=> string(4) „2002“
[„Kommentar“]=> string(8) „sehr gut“
}

Der PHP-Befehl

echo $rawdata['AutorNachname'] . " " . $rawdata['AutorVorname'] . " " . $rawdata['Titel'] . " ";

gäbe also aus:

Frisch Max Andorra

Der darauf folgende Codeblock überführt die Zugangsdaten in Variablen. Dadurch werden deine Skripte wartungsfreundlicher. Willst du das Skript mal an anderem Ort laufen lassen, musst du diese Daten nur an dieser Stelle ändern und nicht an unzähligen weiteren Stellen in deinem Skript/in deinen Skripten. Die Datenbank, die auf dem von dir angemieteten Webspace beim Hoster deiner Wahl läuft, hat einen Namen. Dieser gehört hier zwischen die Anführungsstriche. Er könnte z.B. lauten: usr_web444_1. Die nächste Angabe ist die Host-Angabe, meist lautet sie „localhost“. Frage sicherheitshalber bei deinem Anbieter nach, wenn du dir nicht sicher bist. Als nächstes ist der Benutzername zu nennen, den auch dein Anbieter/Hoster für dich vergeben hat, z.B. web444. Als vorletzte Angabe hat die Datenbank noch ein Passwort, das an dieser Stelle genannt werden muss. Und als letztes solltest du den Namen der betreffenden Tabelle auch in eine Variable packen. Fertig ist der Abschnitt mit den Zugangsdaten.

Im nächsten Abschnitt wird eine Verbindung zur Datenbank hergestellt, verbunden mit einer Abbruch-Nachricht, welche erscheint, wenn der Verbindungsversuch nicht erfolgreich ist: Unable to select database.

Im wiederum nächsten Abschnitt wird eine SQL-Abfrage in der Variablen $query gespeichert. Über SQL (Structured Query Language) bzw. MySQL haben wir schon gesprochen. Auch an dieser Stelle im Skript wird also eine Abfrage, ein query, versprachlicht:

$query = „show columns from $table“;

Es lautet umgangssprachlich: Zeige die Spalten der Tabelle BUECHER_GEL. Das Ergebnis dieser Abfrage sind also die Spalten der Tabelle (wir können hier auch Felder sagen): AutorNachname, AutorVorname, Titel, Untertitel, Ort, Verlag, Jahr, Kategorie, Art, Uebersetzungvonin, wanngelesenetwa, Kommentar.

Die Abfrage ist zu diesem Zeitpunkt aber erst einmal formuliert und in der Variablen $query gespeichert. Ausgeführt wird sie mit:

$result = mysql_query($query);

Die Semikola bilden immer das Ende eines jeden PHP-Befehls.

Was passiert hier? Die Abfrage wird ausgeführt. mysql_query ist ein fester Befehl, eine Funktion, die als ihr übergebenen Parameter den Wortlaut der SQL-Abfrage benötigt. Es wird also „show columns from $table“ ausgeführt und es wird in einem Aufwasch(!) das Ergebnis in der Variablen $result gespeichert. Peng! 🙂 $result enthält jetzt die Spalten-/Feld-Namen – zur späteren Verwendung im selben Skript.

Im nächsten Skriptabschnitt wird eine weitere Abfrage formuliert:

$query = „select * from $table where „;

Heißt umgangssprachlich: Wähle alles aus der BUECHER_GEL, wo … Das Leerzeichen zwischen dem letzten e und den Anführungszeichen deutet darauf hin, dass diese Abfrage nur ein Teil einer späteren Gesamtabfrage ist. Gespeichert wird sie in der Variablen $query. Was folgt, ist eine sogenannte Schleife:

while ( $row = mysql_fetch_assoc($result) )

Schleifenformulierungen haben im Code kein beendendes Semikolon. Sie heißt umgangssprachlich: Solange du, Parser/Code-Interpreter/Web-Server, die Zeilen dessen, was in $result steckt, ablaufen kannst und immer noch eine neue Zeile findest, speichere es in $row, bis die Schleife erneut durchlaufen wird, oder bis du keine Zeilen mehr finden kannst. Noch genauer: Hole dies aus dem assoziativen Array heraus (fetch assoc). Hör auf, wenn du $result ganz durchlaufen hast.

Was geschieht innerhalb der Schleife?

$feldname = $row[‚Field‘];

Der schleifen-durchlaufs-aktuelle Inhalt von $result, jetzt in $row, es ist der Feld-Teil (Field), wird in der Variablen $feldname gespeichert. In der nächsten Zeile

$feldinhalt = $rawdata[$feldname];

wird der Teil-Inhalt von $rawdata, der sich auf diesen Feldnamen bezieht, in der Variablen $feldinhalt gespeichert. Man bedenke: Diese beiden Zeilen werden bei jedem Schleifendurchlauf ausgeführt, solange, bis die Schleife endet. Das tut sie, wenn der Inhalt von $result nichts mehr hergibt, zu Ende durchlaufen wurde. Aber ein einziger Schleifendurchlauf macht noch mehr:

if (!$feldinhalt==““)
{
$query = $query . „$feldname LIKE ‚$feldinhalt%‘ and „;
}

Heißt umgangssprachlich: Wenn (if) $feldinhalt nicht leer ist – wenn da also überhaupt was steht, d.h. wenn der Benutzer im Formular in dieses Kriterienfeld etwas eingetragen hat – dann erweitere den Abfragewortlaut ($query).

Man beachte den Punkt im zuletzt angegebenen Code. Er verkettet Zeichenfolgen und kann als „und“ gelesen werden. $query ist also immer das alte $query plus angehängt bei jedem Schleifendurchlauf (der nicht nichts findet): „$feldname LIKE ‚$feldinhalt%‘ and „. Der in $query gespeicherte Abfragewortlaut wird also länger und länger, und länger. Denn er muss ja alle ausgefüllten Formularfelder berücksichtigen.

Beispiel – jemand hat in das Formular unserer query.html als Suchbegriffe in die Felder eingegeben:

Boyne
John
Der Schiffsjunge
Bounty
Frankfurt
Fischer
2011
privat
Roman
Englisch
2012
ganz gut

Diese kombinierte Suchbegriffeingabe ergäbe die Monster-Abfrage, die man sonst gar nicht zu Gesicht bekommt (code-intern):

select * from BUECHER_GEL where AutorNachname LIKE ‚Boyne%‘ and AutorVorname LIKE ‚John%‘ and Titel LIKE ‚Der Schiffsjunge%‘ and Untertitel LIKE ‚Bounty%‘ and Ort LIKE ‚Frankfurt%‘ and Verlag LIKE ‚Fischer%‘ and Jahr LIKE ‚2011%‘ and Kategorie LIKE ‚privat%‘ and Art LIKE ‚Roman%‘ and Uebersetzungvonin LIKE ‚Englisch%‘ and wanngelesenetwa LIKE ‚2012%‘ and Kommentar LIKE ‚ganz gut%‘ and

Gebaut wurde diese Monster-Abfrage von der Schleife. In der Weise, wie oben erläutert. Die Schleife ist jetzt zu Ende, die Variable $query hat die Monster-Abfrage in sich.

Sicherlich ist dir aufgefallen, dass die Monster-Abfrage am Ende ein „and“ enthält, auf das nichts mehr folgt. Das ist konstruktionsbedingt. Einem Blinddarm/Wurmfortsatz gleich muss dieses „and“ jetzt abgeschnitten werden, denn es ist am Ende überflüssig. Das erledigen die folgenden beiden Codezeilen. Und dann muss noch

order by AutorNachname

angehängt werden (SQL-Befehl zum Sortieren nach Autoren-Nachname). Das erledigen die nächsten beiden Zeilen, also vier Zeilen:

$queryohneende = substr($query, 0, -4);
$query = $queryohneende;
$queryplusorderby = $query . “ order by AutorNachname“;
$query = $queryplusorderby;

Wie machen die vier Zeilen das? In der Variablen $queryohneende wird $query ohne die letzten vier Stellen gespeichert. Dann in $query das Ergebnis dessen. Dann wird in der Variablen $queryplusorderby die $query plus (du erinnerst dich, der Punkt) „order by AutorNachname“ gespeichert. Und dann final in der $query wieder das Ergebnis dessen. Fertig! „and“ ist abgeschnitten und „order by AutorNachname“ ist angehängt. Die Leerzeichen bei alledem sind wichtig, damit die SQL-Befehlswörter getrennt bleiben.

Na, wenn wir nun so ein schönes $query haben, wird es Zeit, es auszuführen, das macht die nächste Zeile:

$result=mysql_query($query);

Die Datenbank, im Besonderen die Tabelle BUECHER_GEL wurde abgefragt, das Ergebnis steckt jetzt in $result. Wir konnten $result ruhig überschreiben, sein alter Inhalt (Skript oben) hat ausgedient.

Nach einer Prüfsequenz (wenn was schiefgeht, erfahren wir zum Teil was schiefgegangen ist) wird nun eine Tabelle gebaut. Unser mächtiges PHP wird jetzt eine individuelle HTML-Struktur entwerfen; dieser Tabelle kann man dann das Bücher-Such-Ergebnis entnehmen. Als erstes hier:

echo „<table cellspacing = ‚1‘ cellpadding = ‚5‘>“;

Heißt – gib aus: den Beginn einer Tabelle, diese Tabelle mit Raum zwischen den Zellen 1 und Abstand des Zellinhalts zum Zellrand 5. Alsdann wird ein Zähler gleich Null gesetzt, er wird uns später sagen, wie viele Bücher diesen Suchkriterien entsprachen. Sodann kommt eine Schleife, die zwar größer ist, als die vorige, aber viel unkomplizierter.

while ($dsatz = mysql_fetch_assoc($result))

Wie gesagt, Schleifenformulierungen haben im Code kein beendendes Semikolon. Heißt: Solange $result noch Zeilen und Inhalt hat, speichere sie bei jedem Durchlauf in $dsatz. Noch genauer: Hole dies aus einem assoziativen Array heraus (fetch assoc). Hör auf, wenn du $result ganz durchlaufen hast. Erhöhe auch bei jedem Schleifendurchlauf den Zähler um eins. Alsdann beginne eine Tabellenreihe (table row):

echo „<tr>“;

Dann beginne Tabellendaten (table data) und beende sie wieder, und dazwischen gib, was der aktuelle Schleifendurchlauf in $dsatz gespeichert hat, aus:

echo „<td>“ . $dsatz[„AutorNachname“] . „</td>“;

Mach das für jedes Feld einmal, also zwölfmal. Die Schleife wird dann für das nächste gefundene Buch eine neue Tabellenzeile ins Browserfenster zaubern, denn der HTML-Code in den echo-Befehlen ist so beschaffen. Schließlich ist die Schleife zu Ende, alle gefundenen Bücher sind angezeigt. Nach der Schleife wird noch der Zähler ausgegeben, denn wir wollen ja wissen, wie viele Bücher denn nun gefunden wurden. Bei z.B. 78 gefundenen Büchern wäre manuelles Zählen arg mühsam. Abschließend folgt noch

echo „</table>“;
mysql_close();
?>

Heißt: Mach die Tabelle wieder zu. Beende auch die Verbindung zur MySQL-Datenbank (Hacker bleiben draußen) und dann beende noch das Gesamt-PHP-Skript.

Du hast es geschafft! Du hast die Kernroutine zum Abfragen der Tabelle verstanden. Oder doch noch nicht so ganz? 🙂 Im letzteren Fall kannst du weiterlesen in „Wie man eine Access-Datenbank ins Internet bringt (4)“, wo wir wiederholen und vertiefen, oder diesen Blog fragend kommentieren, oder natürlich Foren frequentieren oder googeln.

Navigiere nun bitte zum nächsten Eintrag von streethawk68: Wie man eine Access-Datenbank ins Internet bringt (4)

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , | 6 Kommentare

PHP Basics (2)

Eine Sprache hatten wir schon angesprochen: (My)SQL. Wir kommen später darauf zurück.

Jetzt geht es erstmal um HTML. HTML steht für Hypertext Markup Language. Sie ist keine Programmiersprache, sondern eine Seitenbeschreibungssprache (und insofern schon eine Computersprache). Sie stellt quasi das Futter für jeden Browser dar. Browser sind z.B. Mozilla Firefox, Microsoft Internet Explorer, Opera oder Google Chrome. Wenn du Mozilla Firefox verwendest, so mache einmal folgendes Experiment: Steuere deine Lieblings-Internet-Seite an und wähle dann EXTRAS / WEB-ENTWICKLER / SEITENQUELLTEXT ANZEIGEN. Schon siehst du jede Menge HTML-Befehle, -Tags und -Codierungen. Mit dem Internet Explorer geht es (ausnahmsweise) einfacher: Wähle ANSICHT / QUELLE. Der gleiche Effekt tritt auf. Die Menüführung des Browsers dorthin kann von Version zu Version etwas abweichen, bleibt aber mindestens ähnlich.

Erstelle nun ein HTML-Dokument. Das geht so:

Nimm den Windows-Editor, oder, viel besser, lade dir „Notepad++“ herunter und installiere ihn. Mit ihm kannst du durch sogenanntes Syntaxhighlighting deinen baldigen Quellcode viel besser sehen, weil er dann strukturiert und farbig ist. Der Vorteil gegenüber dem normalen Windows-Editor ist immens!

Starte Notepad++ und lege eine neue Datei namens query.html an. So darf die Datei nicht heißen:

query.htm

query.html.htm

query.htm.html

query.html.html

query.htm.htm

Deswegen achte darauf, dass dein Windows-Explorer die Dateinamenerweiterungen (Extensionen) anzeigt, also das, was nach dem „.“ steht. Anderenfalls gibt es später unangenehme Überraschungen. Also: query.html

Fülle die ersten beiden Zeilen deiner jungfräulichen Datei mit folgendem:

<!DOCTYPE html PUBLIC „-//W3C//DTD XHTML 1.0 Transitional//EN“
http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd“&gt;

Hierbei handelt es sich um einige Angaben für den HTML-Code interpretierenden Browser. Sie sagen etwas über die verwendete HTML- oder XHTML-Version aus. Mehr müssen wir an dieser Stelle nicht darüber wissen. Kopiere den Code am besten aus dem Block in deine query.html, so kannst du dich nicht vertippen. Wir fügen eine Leerzeile ein (bessere Übersicht) und dann in Zeile 4:

<html>

(Übrigens: Du siehst beide Codes, query.html und query.php, wie sie final sein sollen, hübsch strukturiert mit Zeilennummern und vielen element-abhängigen Farben, im späteren Blog-Verlauf; also keine Sorge, was den Überblick betrifft. 🙂 )

Das <html> ist ein öffnendes Tag (sprich: „täg“). Es lässt html-Code beginnen. Als Zeile 5 füge nun ein:

<head>

Auch dies ist ein öffnendes Tag. Es lässt den Kopf des html-Dokumentes beginnen. Hierauf füge ein (Zeile 6):

<meta http-equiv=“content-type“ content=“text/html; charset=ISO-8859-1″>

Hiermit werden erneut einige Einstellungen vereinbart, nämlich was den verwendeten Zeichensatz betrifft. Zeile 7 soll lauten:

<title>Buecher Abfrage</title>

Zwischen dieses öffnende und schließende Tag kannst du den Titel deiner Seite setzen. Er erscheint beim Aufruf durch einen Browser sowohl als Titel des Browserfensters, als auch als Text im Browser-Tab. Es folgt Zeile 8:

</head>

Der Slash („/“) zeigt an, dass dies ein schließendes Tag ist. Das Tag sagt: Der Kopf des html-Dokumentes wird hiermit beendet. Zeile 9:

<body bgcolor=“#D4ECFB“>

Hier wird der Körper des HTML-Dokuments geöffnet, verbunden gleichzeitig mit einer Zuweisung der Hintergrund (bg = background)-Farbe. #D4ECFB ist ein zartes Lila. 🙂 Zeile 10:

<h3>Willkommen auf der Suchseite für Bücher, die Karl Gustav gelesen hat!</h3>

Hiermit wird zum ersten Mal in deiner neuen query.html etwas für den Leser deiner Site ausgegeben, nämlich ein Willkommensgruß in der „Überschriftenklasse headline 3“. Natürlich ist dies nur ein Beispielsatz, den du nach Gutdünken für dich modifizieren kannst. Es folgt wieder eine strukturierende Leerzeile.

Und jetzt wird es programmtechnisch interessant! Wir fügen eine Zeile 12 ein:

<form action = „query.php“ method = „post“>

Sie sagt: die query.html soll eine query.php aufrufen und dabei Werte übergeben, die der Benutzer deiner Site zuvor in das Formular eingegeben hat. Um das zu verstehen, sollten wir uns jetzt vielleicht einmal ansehen, wie die query.html im Browserfenster aussieht, wenn sie einmal fertig ist. Dazu betrachte bitte nun Bild 2-1:

Bild 2-1

So stellt ein Browser die fertige query.html dar. Du siehst die Willkommensüberschrift, du siehst eine Schaltfläche zum „Daten absenden“ und eine zum „Zurücksetzen“ (wenn einer deiner Betrachter sich vertippt hat) und du siehst im roten Kasten … genau, die guten alten Felder unserer Datenbank. query.html ist nämlich dazu da, zu leisten: „Hallo Benutzer der Datenbank im Internet! Sag mir, auf welche Angaben es dir ankommt und ich sorge dafür, dass dir die passenden Bücher angezeigt werden.“

Mein Vorgriff war nötig für die Erläuterung der weiteren query.html-Zeilen, denn nun weißt du, was sie letztlich bewirken. Nun, dann mal gleich die nächste Zeile (14):

<table>

Zwei größer-kleiner-Zeichen, als ein Tag; kein Slash (/), also ein öffnendes Tag. Es sagt zum interpretierenden Browser: Beginne hier mit einer Tabelle. Es folgen zwölf Zeilen (eine ist so lang, dass sie umbrochen wird), die sich auf die zwölf Felder der Bücherdatenbank beziehen. Du erinnerst dich?

AutorNachname
AutorVorname
Titel
Untertitel
Ort
Verlag
Jahr
Kategorie
Art
Uebersetzungvonin
wanngelesenetwa
Kommentar

Diese zwölf Felder werden nun vom Browser anhand der query.html tabellarisch dargestellt. Aber mehr noch: Sie bekommen einen für PHP interpretierbaren Namen zugewiesen. Dieser Name ist in unserem Beispiel der Einfachheit halber schlicht gleich dem Datenbank-Feld-Namen. Das heißt konkret (z.B. Zeile 16):

Schaffe ein Eingabefeld, in das der Benutzer der Datenbank etwas eingeben kann und übergib dann, was der Benutzer eingegeben hat, unter dem Namen „AutorNachname“ an die query.php.

Und so geht es auch mit den übrigen elf Feldern der Datenbank, die der letztliche Benutzer so bestimmen kann. Nehmen wir an, er gibt bei „Nachname des Autoren“ „Fontane“ an… dann wird unser hier programmiertes System ihm zwei Ergebnisse liefern, nämlich „Irrungen, Wirrungen“ und „Effi Briest“ von Theodor Fontane. Das ist das Ziel und die Zeile

<tr><td><input name = „AutorNachname“ size=“60″ /> Nachname des Autoren</td></tr>

ist ein Element davon.

Übrigens: <tr> heißt: lasse eine Tablerow (Tabellenzeile) beginnen, und </tr> heißt: schließe sie wieder. <td> heißt: lasse Tabledata (Tabellendaten) beginnen und </td> schließe sie wieder.

Und so geht es, wie gesagt, noch elfmal, für jedes Feld gibt es eine solche Zeile in der query.html. Es folgt

</table>

und was sagt das? Genau: Schließe die Tabelle wieder.

<input type=“submit“ />
<input type=“reset“ />

fügen die Absenden-Schaltfläche und die Zurücksetzen-Schaltfläche ein (vgl. Bild 2-1).

</body>
</html>

schließen den Körperbereich und dann das ganze HTML-Dokument.

Nach all der grauen Theorie Lust auf was Praktisches? Okay, dann füge in deine junge query.html genau alle diese Zeilen ein und speichere sie ab. Wollen mal sehen, was ein Browser aus deinem Werk macht. Steuere mit deinem Windows-Explorer die Datei an und klicke doppelt auf sie; im Idealfall öffnet sich dein Standard-Browser und zeigt die Datei so an, wie es später im Netz auch der Fall sein wird:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=ISO-8859-1">
<title>Abfrage B&uuml;cher</title>
</head>
<body bgcolor="#ececec">
<h3>Willkommen auf der Suchseite f&uuml;r B&uuml;cher, die Karl Gustav gelesen hat</h3>

<form action = "query.php" method = "post">

<table>

<tr><td><input name = "AutorNachname" size="60" /> Nachname des Autoren</td></tr>
<tr><td><input name = "AutorVorname" size="60" /> Vorname des Autoren</td></tr>
<tr><td><input name = "Titel" size="60" /> Titel</td></tr>
<tr><td><input name = "Untertitel" size="60" /> Untertitel</td></tr>
<tr><td><input name = "Ort" size="60" /> Ort</td></tr>
<tr><td><input name = "Verlag" size="60" /> Verlag</td></tr>
<tr><td><input name = "Jahr" size="60" /> Jahr</td></tr>
<tr><td><input name = "Kategorie" size="60" /> Kategorie</td></tr>
<tr><td><input name = "Art" size="60" /> Art</td></tr>
<tr><td><input name = "Uebersetzungvonin" size="60" /> &Uuml;bersetzung von... in...</td></tr>
<tr><td><input name = "wanngelesenetwa" size="60" /> wann gelesen etwa?</td></tr>
<tr><td><input name = "Kommentar" size="60" /> Kommentar</td></tr>

</table>
<br />
<input type="submit" />
<input type="reset" />
<br />
</body>
</html>

Bild 2-2

Wenn du in diesem Blog die Codezeilen nicht sofort bis zu Ende lesen kannst, benutze den Quer-Scrollbalken unter dem Code. Auch kannst den Code markieren und in deinen Editor einfügen, um ihn besser sehen und selber bearbeiten zu können.

Bis hierher bist du also gekommen? Glückwunsch!

Wenn es auf diesem Weg Probleme gab, nicht kapitulieren! Du kannst das Problem googeln, du kannst es in Foren beschreiben, du kannst mit anderen Bloggern oder mit mir (Kommentarfunktion dieses Blogs) darüber diskutieren. Es wäre geradezu ungewöhnlich, wenn bis hier alles reibungslos geklappt hätte. Leider bin ich auch kein großer Didakt/Methodiker und bin, sicherlich zu deinem Leidwesen, oft gesprungen, habe Unbekanntes als bekannt vorausgesetzt und bin dem roten Faden nicht immer gefolgt. Ich hoffe aber doch, dass diese Anleitung etwas an neuem Wissen entfaltet und nicht völlig in die Verwirrung führt.

Lies nun im dritten Teil dieses Blogs, was es (wir hatten etwas SQL und HTML) mit PHP auf sich hat. Navigiere zum nächsten Eintrag von streethawk68: Wie man eine Access-Datenbank ins Internet bringt (3)

Veröffentlicht unter Uncategorized | Verschlagwortet mit , , | Kommentar hinterlassen