Fach: Informatik - Jan-Gerd Tenberge

Geschwister-Scholl-Gymnasium Stadtlohn
Jan-Gerd Tenberge
Wessendorfer Str.11
48703 Stadtlohn
Fach: Informatik
Kurs: If GK
Facharbeit
Thema:
Datenbankbasierte Webprogrammierung
–
Ein Gästebuch in HTML, PHP und mySQL
Fachlehrerin: Frau Wolff
Abgabe: 08.04.2005
1

Inhalt
1. EINLEITUNG ................................................................................................. 3
1.1 Themenfindung .................................................................................................................................... 3
1.2 Grundlagen der PHP-Programmierung ............................................................................................ 4
1.3 Grundlagen mySQL ............................................................................................................................ 4
1.4 Das Projekt........................................................................................................................................... 5
2. HAUPTTEIL ................................................................................................... 5
2.1 Vorüberlegungen zur Datenbank....................................................................................................... 5
2.2 Programmierung.................................................................................................................................. 6
2.2.1 Aufteilung ...................................................................................................................................... 6
2.2.2. Verbindung zur Datenbank – Connect.php ...................................................................................7
2.2.3 Eingabe in die Datenbank – Eingabe.php ...................................................................................... 8
2.2.4 Ausgabe der Daten in lesbarer Form – Ausgabe.php................................................................... 10
2.2.5 Die Startseite – Index.php............................................................................................................ 12
3. SCHLUß....................................................................................................... 13
3.1 Fazit..................................................................................................................................................... 13
4. RECHTLICHES............................................................................................ 14
5. ANHÄNGE................................................................................................... 15
5.1.1 Ausgabe.php.................................................................................................................................... 16
5.1.2 connect.php...................................................................................................................................... 16
5.1.3 Eingabe.php..................................................................................................................................... 16
5.1.4 Eingabe.html ................................................................................................................................... 16
5.1.5 index.php ......................................................................................................................................... 17
2

1. Einleitung
1.1 Themenfindung
Ich habe mich entschieden, meine Facharbeit im Fach Informatik schreiben, aber mich
dabei weniger an den Unterrichtsinhalten orientieren als vielmehr den Versuch
unternehmen etwas eigenes zu schaffen und dann darüber zu schreiben. Da es in der
Kürze der Zeit nicht möglich war eine komplett neue Programmiersprache zu lernen
stand ich vor der Wahl, mein Projekt entweder in Delphi oder in PHP zu verwirklichen.
Ich überlegte mir also zunächst zwei Themen um mich nach Abwägung der
Umsetzbarkeit im Rahmen einer Facharbeit jedes der beiden für eines zu entscheiden.
Da sich meine ursprüngliche Idee, ein Programm zur Erstellung und Verwaltung von
Rechnungen mit Onlineanbindung in Delphi zu erstellen schnell als bei weitem zu
komplex erwies nahm ich mir vor, eine Datenbankbasierte Anwendung in PHP zu
schreiben.
Dabei dachte ich zuerst an ein Content Managing System (CMS), aber auch diese Idee
hätte den Rahmen des Umfanges der Facharbeit bei weitem gesprengt. Stattdessen
entschied ich mich für eine einfache Anwendung in Form eines Gästebuches. Anhand
dieser lassen sich grundlegende Datenbankfunktionen und die Verwendung derselbigen
gut aufzeigen und dennoch bleibt das Projekt vergleichsweise übersichtlich, so dass es
im Rahmen einer Facharbeit gut erläuterbar sein sollte.
An dieser Stelle möchte ich anmerken, dass ich mich in dieser Facharbeit vor allem auf
die Programmierung in PHP beschränken werde, die grundlegenden Funktionen der
Datenbank und Grundlagen der HTML-Programmierung werde ich an entsprechender
Stelle kurz anschneiden, sie sollen jedoch nicht Gegenstand dieser Arbeit sein, da auch
hier der recht begrenzt vorgegebene Umfang weit überschritten würde.
3

1.2 Grundlagen der PHP-Programmierung
PHP steht als rekursives Akronym für PHP Hypertext Preprocessor und am Namen lässt
sich bereits das Einsatzgebiet ablesen. PHP ist eine serverbasierte Skriptsprache, was
bedeutet, dass bei jedem Aufruf einer Seite das gesamte Skript auf dem Server
abgearbeitet wird, der das Ergebnis als HTML (Hypertext Markup Language)-Code
ausgibt, der dann im Browser angezeigt wird.
Es handelt sich bei PHP also um keine Programmiersprache im engeren Sinn, denn das
normalerweise übliche kompilieren von Programmen gibt es hier nicht. Bei jedem
Aufruf wird das gesamte Skript Zeile für Zeile abgearbeitet.
Grundsätzliche Vorteile der PHP-Programmierung gegenüber HTML ist die Dynamik
der erzeugten Seiten. So lassen sich Inhalte sowohl aus anderen Dateien als auch aus
einer der unterstützten Datenbanken (ich verwende hier mySQL, es werden aber in
ähnlicher Weise auch weitere, beispielsweise PostgreSQL unterstützt) einbinden. Diese
Möglichkeit der dynamischen Einbindung ist die Grundlage für jede Webseite mit der
der Benutzer in irgendeiner Weise interagieren kann, sei es – wie in diesem Beispiel –
ein Gästebuch, ein Forum oder ein Kommentarsystem.
1.3 Grundlagen mySQL
mySQL ist eine kostenlose, relationale Open-Source Datenbank, die zwar weniger
leistungsfähig ist als ihre kostenpflichtigen Pendants (z.B. Oracle), im Internet aber
aufgrund ihrer Lizenzfreiheit gerne genutzt wird.
Im Rahmen dieses Projektes werde ich nur sehr wenige Funktionen der Datenbank
nutzen. Diese werden an entsprechender Stelle näher erläutert, allen gemein ist aber,
dass sie entweder zum Lesen, Schreiben oder Durchsuchen der Datenbank dienen.
Daneben gibt es in mySQL viele weitere Befehle, die z.B. zum Zusammenführen,
Optimieren, Teilen, Anlegen oder Löschen einzelner Tabellen oder Datenbanken
4

dienen. Diese Möglichkeiten der Datenbank sind aber für die relativ einfache
Anwendung eines Gästebuches nicht von belang.
1.4 Das Projekt
Das im Rahmen dieser Facharbeit erstellte Gästebuch wird nur sehr rudimentäre
Funktionen besitzen, es basiert auf einer einzigen Datenbank, die ihrerseits nur eine
Tabelle enthält, in der die Beiträge der Besucher gespeichert werden.
Die Funktionen des PHP-Skriptes werden sich darauf beschränken, den vom Nutzer
eingegebenen Text samt einiger Informationen (Name, E-Mail Adresse und Homepage
des Absenders sowie das aktuelle Datum inkl. Uhrzeit) in eine Datenbank zu schreiben
und anschließend den Inhalt dieser Datenbank auszulesen und anzuzeigen.
2. Hauptteil
2.1 Vorüberlegungen zur Datenbank
Bevor die eigentliche Programmierung beginnen kann ist zu überlegen, welche
Informationen gespeichert werden sollen und wie diese am besten in einer Datenbank zu
ordnen sind.
Zunächst einmal sind natürlich die Eingaben des Nutzers zu speichern, dazu lege ich in
der Datenbank (ich gehe an dieser Stelle davon aus, dass diese bereits existiert und der
Name derselbigen vorgegeben ist) eine Tabelle mit dem Namen “Eingaben” an. Deren
erste Spalten sind selbsterklärend:
Name, EMail, Homepage, Text
Um die Beiträge später chronologisch sortieren zu können füge ich noch eine weitere
Spalte mit der Bezeichnung Datum hinzu. Diese wird später vollautomatisch mit dem
aktuellen Datum samt Uhrzeit gefüttert, dazu später mehr.
5

Nachdem diese Tabelle erstellt ist (die Erstellung als solche ist in PHP relativ komplex,
daher beschäftige ich mich damit in dieser Facharbeit nicht näher und setze die Tabellen
als existent voraus) kann die eigentliche Programmierung des Gästebuches (und damit
das eigentliche Thema dieser Arbeit) beginnen.
2.2 Programmierung
2.2.1 Aufteilung
Um nicht die gleiche Sache mehrmals programmieren (und später evtl. anpassen) zu
müssen, macht es Sinn die mehrfach verwendeten Funktionen in je eine Datei zu
schreiben und diese später an passender Stelle einzubinden. Folgende Einteilung
erscheint dabei sinnvoll:
Index.php
Diese Datei wir später beim Besuch der Seite aufgerufen, sie dient nur als ‚Container’
für die anderen Dateien, die sie allesamt lädt.
Eingabe.html
Diese Datei ist eine statische HTML-Seite und beinhaltet nur das Eingabeformular in
das der Benutzer später die Daten eingibt.
Eingabe.php
Nimmt die Daten von Eingabe.html entgegen und schreibt sie in die Datenbank.
Ausgabe.php
Hier werden die Daten aus der Datenbank ausgelesen, formatiert und ausgegeben.
Connect.php
Diese Datei stellt die Verbindung zur Datenbank her, sie liefert keinerlei Rückmeldung,
wird aber von den Dateien Ausgabe.php und Eingabe.php genutzt.
Die recht simpel gestrickte HTML-Seite soll hier nicht weiter behandelt werden, der
Quelltext findet sich im Anhang 1.1. Wichtig und Auffällig ist nur, dass in der Datei
Eingabe.html das action-Attribut des Form-Tags auf die Datei Eingabe.php verweist.
6

2.2.2. Verbindung zur Datenbank – Connect.php
Die Erstellung einer Verbindung zu einer Datenbank gliedert sich in PHP in zwei
einfache Schritte:
Zunächst wird eine Verbindung zum Server hergestellt auf dem die Datenbanksoftware
(in diesem Falle mySQL) läuft, in einem zweiten Schritt muss dann noch die zu
verwendende Datenbank ausgewählt werden. Dieser Schritt ist auch dann erforderlich,
wenn (wie in diesem Fall) nur eine Datenbank vorhanden ist.
Der (laut 1 zwar veraltete aber immer noch am häufigsten genutzte) Befehl zur
Verbindungsaufnahme mit dem Server lautet mysql_connect() und erwartet die Adresse
des Servers (entweder eine IP- oder eine Internet-Adresse) sowie Benutzername und
Passwort sofern erforderlich. Die erste Zeile der Datei connect.php lautet also
mysql_connect("www.mysqlserver.de", "UnserBenutzer", "UnserPasswort");
Wobei die Platzhalter natürlich entsprechend der (im Normalfall vom Webspace-
Anbieter zur Verfügung gestellten) Daten zu ersetzen sind. Im nächsten Schritt wählt
der Befehl mysql_select_db() die zu verwendende Datenbank aus. Diese ist im
Allgemeinen ebenfalls vom Anbieter vorgeben und sollte die Tabelle “Eingaben”
beinhalten. Der Befehl erwartet lediglich die Angabe eines Datenbanknamens. Damit
lautet Zeile zwei
mysql_select_db("UnsereDatenbank");
Weiteres zum Befehl unter 2 .
Damit ist die Programmierung der ersten Datei bereits abgeschlossen. Lädt man diese
Datei nun auf einen PHP-fähigen Webspace hoch und ruft sie auf, stellt sie automatisch
eine Verbindung zum Server her. Die Ausgabe ist jedoch lediglich eine leere Seite.
Diese Datei findet sich im Anhang als 1.2.
1 http://dev.mysql.com/doc/mysql/de/mysql-connect.html
2 http://dev.mysql.com/doc/mysql/de/mysql-select-db.html
7

2.2.3 Eingabe in die Datenbank – Eingabe.php
Die Datei Eingabe.php ist zum schreiben in die Datenbank natürlich auf eine
Verbindung zu selbiger angewiesen. Dazu binde ich per include() die eben erstellte
Datei connect.php ein. Das Skript wird nun so abgearbeitet, als stände der gesamte in
connect.php enthaltene Code auch in Eingabe.php, mehr dazu auf der offiziellen PHP-
Seite unter 3 . Die erste Zeile lautet also
Include(“connect.php”);
Jetzt müssen die vom Benutzer in der Datei Eingabe.html eingegeben Dateien in die
Datenbank geschrieben werden. Durch einen klick auf den Button Absenden in dem
Formular aus Eingabe.html ruft der Browser die Seite Eingabe.php auf und sendet ihr
alle eingegeben Daten. Diese sind nun innerhalb des Skripts als Variablen mit dem
Namen des id-Attributes des jeweiligen input-Tags verfügbar. Da die Felder in
Eingabe.html die id-Tags Text_ein, Name_ein, Mail_ein und Homepage_ein tragen
stehen nun die Variablen $Text_ein, $Name_ein, $Mail_ein und $Homepage_ein zur
Verfügung.
Um die Werte dieser Variablen (also die vom Benutzer eingegebenen Texte) in die
Datenbank einzufügen verwenden wir die mySQL-Funktion Insert Into der mit
folgendem Syntax aufgerufen wird:
INSERT INTO a (b) VALUES (c)
A ist hier die Tabelle in die die Werte geschrieben werden, b eine kommagetrennte
Liste der Spalten die mit Werten gefüllt werden sollen und c eine ebenfalls
kommagetrennte Liste der Werte, in der gleichen Reihenfolge wie bei b die Spalten
aufgezählt wurden. Eine vollständige Beschreibung des Befehls ist zu finden unter 4
Hierbei handelt es sich um eine native mySQL- und nicht um eine PHP-Funktion. Um
mySQL-Befehle auszuführen bietet PHP den Befehl mysql_query an, der den gesamten
3 http://de.php.net/include/
4 http://dev.mysql.com/doc/mysql/de/insert.html
8

an mySQL weiterzuleitenden Befehl als Parameter erwartet. Eine ausführliche
Beschreibung ist unter 5 zu finden. Der vollständige mySQL lautet in diesem Falle
INSERT INTO Eingaben (Name, EMail, Homepage, Text, Datum) VALUES
('$Name_ein', '$Mail_ein', '$Homepage_ein', '$Text_ein', '$Datum')
An dieser Stelle fällt auf, dass es in der Eingabemaske kein Feld für das Datum gibt.
Um das aktuelle Datum zu erhalten bemühe ich die PHP-Funktion time() (siehe 6 ), die
die aktuelle Uhrzeit samt Datum als PHP-Timestamp zurückliefert. Dieser Timestamp
lässt sich später mit der Funktion date() wieder in ein lesbares Format bringen, dazu an
entsprechender Stelle mehr.
Nun muss also zunächst das aktuelle Datum in der Variable $Datum gespeichert
werden, das geht in PHP vergleichsweise einfach, indem man der Variable einfach den
Wert der Funktion zuweist, ein initialisieren der Variable wie aus anderen Sprachen
bekannt ist nicht erforderlich, auch Unterscheidungen zwischen verschiedenen
Variablentypen gibt es bei PHP nicht. Die Zeile lautet dementsprechend
$Datum = time();
Jetzt, da die Variable $Datum gesetzt ist sind alle zur Ausführung des Insert Into-
Befehls nötigen Variablen vorhanden und er kann per mysql_query ausgeführt werden.
Die gesamten Zeile dazu lautet
Mysql_query(“INSERT INTO Eingaben (Name, EMail, Homepage, Text,
Datum) VALUES ('$Name_ein', '$Mail_ein', '$Homepage_ein', '$Text_ein',
'$Datum')”);
Nach ausführen dieses Befehles ist die Eintragung abgeschlossen. Dem User kann nun
also das Gästebuch samt seines frisch hinzugefügten Eintrages präsentiert werden. Dazu
wird an dieser Stelle einfach die Datei Ausgabe.php nach altbekanntem Schema
eingefügt, die die Ausgabe generiert.
5 http://de.php.net/mysql_query
6 http://de.php.net/time
9

Include(“Ausgabe.php”);
Damit ist auch dieses Skript fertig. Zu finden im Anhang unter 1.5.
2.2.4 Ausgabe der Daten in lesbarer Form – Ausgabe.php
Genau wie die Eingabe ist auch die Ausgabe auf eine Verbindung zur Datenbank
angewiesen. Dazu binde ich wie oben wieder die Datei Connect.php ein.
Include(“Connect.php”);
Jetzt können bereits die Daten aus der Datenbank ausgelesen werden. Hierzu dient der
mySQL-Befehl Select From. Der Syntax ist hierbei folgender:
SELECT a FROM b ORDER BY c [ASC|DESC]
Hierbei ist a eine Liste der zu ladenden Spalten. Da im Beispiel sämtliche Spalten
gelesen werden sollen darf hier ein Sternchen (*) gesetzt werden. B ist die Tabelle aus
der die Einträge entnommen werden sollen, hier also die Tabelle Eingaben. C
bezeichnet die Spalte nach der Sortiert werden soll, im Beispiel logischerweise nach
Datum, beginnend mit dem neuesten, also absteigend. Um anzuzeigen, dass die
Sortierung ab- oder aufsteigend erfolgen soll dient das DESC (descending – absteigend)
bzw. ASC (ascending – aufsteigend). Damit sieht der mySQL-Befehl für das Gästebuch
wie folgt aus:
SELECT * FROM guestbook ORDER BY datum DESC
Mehr zum SELECT-Befehl unter 7
Da das Ergebnis weiter benötigt wird (es soll ja noch formatiert und ausgegeben
werden) wird es zunächst in der Variable $result gespeichert. Der mysql_query-Befehl
wurde ja bereits weiter oben erläutert. Damit ergibt sich folgender Code:
7 http://dev.mysql.com/doc/mysql/de/select.html
10

$result = mysql_query("SELECT * FROM Eingaben ORDER BY datum
DESC");
Dem leichteren Umgang mit dem Ergebnis, das als mehrdimensionales Array
ausgegeben wird, dient folgender Code von 8 , der auf der Funktion mysql_fetch_assoc
basiert, dazu mehr unter 9 :
while
}
($row = mysql_fetch_assoc($result)) {
In den geschweiften Klammern kann nun die Formatierung und Ausgabe durchgeführt
werden. Die while-Schleife läuft für jeden vorhandenen Eintrag einmal ab und bietet die
folgenden Variablen, deren Inhalte aus der Datenbank geladen wurden:
$row[Name], $row[EMail], $row[Homepage], $row[Text], $row[Datum]
Da das Datum nach wie vor als Timestamp vorliegt muss es zunächst wieder in ein
lesbares Format, am besten in das in Detschland übliche DD.MM.YYYY HH:MM
gebracht werden. Hier hilft der Befehl date(), der als Parameter ein Format und einen
Timestamp erwartet. Das Format lautet für diesen Fall “d.m.Y G:i”. Nachzulesen unter
10 . Das formatierte Datum ergibt sich also mit
Date(’d.m.Y G:i’, $row[Datum]);
Damit ist es bereits möglich, den Inhalt der Datenbank wieder lesbar auszugeben. Dazu
wird folgende While-Schleife unter Verwendung des Echo-Befehls (siehe 11 ) genutzt:
while ($row = mysql_fetch_assoc($result)) {
$Datum = Date('d.m.Y G:i', $row[Datum]);
echo "Datum: $Datum";
echo "Name: $row[Name] ";
8
http://www.phpcenter.de/de-html-manual/function.mysql-fetch-assoc.html
9
http://de.php.net/mysql_fetch_assoc
10
http://de2.php.net/date
11
http://de.php.net/echo
11

}
echo "E-Mail: $row[EMail]";
echo "Homepage: $row[Homepage]";
echo "$row[Text]";
Der besseren Lesbarkeit halber habe ich durch den HTML-Tag einige
Zeilenumbrüche hinzugefügt und die E-Mail- und Homepage-Adressen mithilfe der
entsprechenden HTML-Tags in Links umgewandelt.
2.2.5 Die Startseite – Index.php
Die Gestaltung der Startseite ist denkbar einfach. Sie beinhaltet lediglich das Formular
zum Einfügen neuer Daten sowie eine Anzeige aller bereits vorhandenen Einträge. Um
dieses zu erreichen sind lediglich zwei Zeilen Code notwendig.
Include(“Eingabe.html”);
Include(“Ausgabe.php”);
Diese Seite zeigt also das Eingabeformular oberhalb aller bereits erstellten Einträge an.
Wie hieran zu erkennen ist, lassen sich per include() auch statische HTML- oder Text-
Seiten einbinden, die dann an entsprechender Stelle angezeigt werden.
12

3. Schluß
3.1 Fazit
Abschließend betrachtet zeigt sich, dass selbst ein einfaches Gästebuch, dass
letztendlich nur aus sehr wenigen Zeilen Code besteht vielleicht immer noch ein für
eine Facharbeit zu komplexes Thema ist, da der vorgegebene Platz von 8 - 12 Seiten
kaum ausreichte um die Programmierung und die einzelnen Funktionen ausführlich zu
beschreiben.
Gerne hätte ich auch noch weitere Funktionen eingebaut, beispielsweise einige
Einstellungsmöglichkeiten (wie viele Einträge pro Seite gezeigt werden beispielsweise).
Auch für ein echtes Design reichte der Platz leider nicht mehr, so dass das Resultat
meines Projektes zwar funktional aber nicht sonderlich schön geraten ist. Ich habe
außerhalb der Facharbeit noch weiter an diesem Gästebuch gearbeitet und setzte es jetzt
auf meiner Homepage ein, zu sehen unter http://janten.com/?action=guestbook, sehr
gerne hätte ich es in seiner dort zu sehenden Funktionalität und dem dortigen Umfang
dokumentiert.
Alles in allem muss ich sagen, dass mir die Erstellung dieser Facharbeit viel Spaß
gemacht hat und ich viele der Dinge die ich dabei gelernt habe auch in anderen
Projekten weiterverwenden kann.
13

4. Rechtliches
Ich erkläre, dass ich die Facharbeit ohne fremde Hilfe angefertigt und nur die im
Literaturverzeichnis angeführten Quellen und Hilfsmittel benutzt habe.
6. April 2005
14

5. Anhänge
Die Anhänge 5.1.1 bis 5.1.5 enthalten die Quelltexte der erstellten PHP- und HTML-
Seiten, des weiteren finden sie eine nicht weiter bearbeitete funktionsfähige Version
dieses Gästebuches im Internet unter http://janten.com/FA.,
Die Anlagen 5.2.1 bis 5.2.12 enthalten die in den Fußnoten erwähnten Internetseiten,
allesamt mit dem Stand vom 06.04.2005, soweit nicht anders angegeben.
15

5.1.1 Ausgabe.php
5.1.2 connect.php
5.1.3 Eingabe.php

Unbenanntes Dokument
Name:
E-Mail:
Homepage:
Text:
5.1.5 index.php
17

5.2.1
9.4.3.3. mysql_connect()
MYSQL *mysql_connect(MYSQL *mysql, const char *host, const char *user,
const char *passwd)
Beschreibung
Diese Funktion ist veraltet. Sie sollten statt dessen mysql_real_connect() benutzen.
mysql_connect() versucht, eine Verbindung zu einer MySQL-Datenbankmaschine
aufzubauen, die auf host läuft. mysql_connect() muss erfolgreich beendet werden,
bevor Sie irgend welche weiteren API-Funktionen aufrufen können, mit Ausnahme von
mysql_get_client_info().
Die Bedeutung der Parameter ist dieselbe wie die entsprechenden Parameter bei
mysql_real_connect(), mit dem Unterschied, dass die Verbindungsparameter NULL
sein dürfen. In diesem Fall weist die C-API automatisch Speicher für die
Verbindungsstruktur zu und gibt diesen frei, wenn Sie mysql_close() aufrufen. Der
Nachteil dieses Ansatzes besteht darin, dass Sie keine Fehlermeldung abrufen können,
wenn die Verbindung fehlschlägt. (Um Fehlerinformationen von mysql_errno() oder
mysql_error() abrufen zu können, müssen Sie einen gültigen MYSQL-Zeiger angeben.)
Rückgabewerte
Dieselben wie für mysql_real_connect().
Fehler
Dieselben wie für mysql_real_connect().
5.2.2
9.4.3.47. mysql_select_db()
int mysql_select_db(MYSQL *mysql, const char *db)
Beschreibung
Führt dazu, dass die Datenbank, die durch db angegeben wird, die vorgabemäßige
(aktuelle) Datenbank auf der von mysql angegebenen Verbindung wird. Bei
nachfolgenden Anfragen ist diese Datenbank die Vorgabe für Tabellenverweise, die
nicht explizit einen Datenbank-Spezifizierer enthalten.
mysql_select_db() schlägt fehl, wenn der verbundene Benutzer keine Zugriffsrechte
auf die Datenbank hat.
18

Rückgabewerte
0 bei Erfolg. Nicht-0, wenn ein Fehler auftrat.
Fehler
5.2.3
• CR_COMMANDS_OUT_OF_SYNC
Befehle wurden nicht in der korrekten Reihenfolge ausgeführt.
• CR_SERVER_GONE_ERROR
Der MySQL-Server ist weg.
• CR_SERVER_LOST
Die Verbindung zum Server ging während der Anfrage verloren.
• CR_UNKNOWN_ERROR
include()
Ein unbekannter Fehler trat auf.
Die include() Anweisung bindet die angegebene Datei ein und wertet diese aus.
Die untenstehende Dokumentation gilt ebenso für require(). Diese beiden Konstrukte
sind in jeder Hinsicht gleichwertig mit der einen Ausnahme: der Umgang mit Fehlern.
include() erzeugt ein Warning während require() in einem Fatal Error endet. Mit
anderen Worten, verwenden Sie require(), wenn Sie möchten, dass eine fehlende Datei
die Ausführung ihres Skripts beendet. include() verhält sich anders, ihr Skript wird
weiterhin ausgeführt. Stellen Sie außerdem sicher, dass Sie einen gültigen include_path
gesetzt haben. Beachten Sie, dass eine Parse Error in einer Datei, die mit require
eingebunden wurde, die Ausführung ihre Skripts nicht unterbricht.
Dateien die mit include eingebunden werden, werden zuerst im include_path relativ
zum gegenwärtigen Arbeitsverzeichnis gesucht und danach im include_path relativ zum
Verzeichnis des ausgeführten Skripts. Zur Veranschaulichung: Falls Ihr include_path .
entspricht, ist das gegenwärtige Arbeitsverzeichnis /www/. Sie haben über include
include/a.php eingebunden und in diesem Skript steht die Anweisung include
"b.php". In diesem Fall wird b.php zuerst im Verzeichnis /www/ gesucht und danach im
Verzeichnis /www/include/.
Wenn eine Datei eingebunden wird, erbt der enthaltene Code den Geltungsbereich von
Variablen der Zeile in der die Anweisung steht. Ab dieser Zeile stehen alle verfügbaren
Variablen in der aufgerufenen Datei im aufrufenden Skript zur Verfügung.
19

Beispiel 16-3. Grundlegendes include() Beispiel
vars.php
test.php
Steht include im aufrufenden Skript innerhalb einer Funktion, verhält sich der gesamte
Code der aufgerufenen Datei genau so, als ob Sie diesen Code innerhalb dieser
Funktion definiert hätten. Aus diesem Grund hat dieser Code den Geltungsbereich der
Variablen dieser Funktion.
Beispiel 16-4. Include innerhalb einer Funktion
Beim Einbinden einer Datei wechselt der Parser vom PHP-Modus zu Beginn der
Zieldatei in den HTML-Modus und kehrt am Ende der eingebunden Datei wieder in den
PHP-Modus zurück. Deshalb muss jeglicher Code innerhalb der eingebundenen Datei,
der als PHP-Code ausgeführt werden soll, von gültigen PHP-Start- und Ende-Tags
eingefaßt sein.
20

Wenn "URL fopen wrappers" in PHP aktiviert sind (in der Standardkonfiguration ist das
der Fall) können Sie als Pfad der einzubindenden Datei auch eine URL (via HTTP oder
anderen unterstützen Wrappern - eine Liste der unterstützen Protokolle finden Sie unter
Anhang L) statt einer lokalen Pfadangabe angeben. Falls der Zielserver die Zieldatei als
PHP-Code interpretiert, können Sie an die einzubindende Datei Variablen in einem
Request-String übergeben, genauso wie bei HTTP GET. Streng genommen ist das nicht
das Gleiche, wie diese Datei einzubinden und diesem den Geltungsbereich des Vater-
Skripts zu vererben; das Skript wird auf dem Remote-Server ausgeführt und danach
wird das Ergebnis in das lokale Skript eingebunden.
Warnung
PHP Versionen kleiner 4.3.0 für Windows, erlauben den Zugriff auf Remote-Dateien
mit dieser Funktion nicht, selbst wenn allow_url_fopen aktiviert ist.
Beispiel 16-5. include() über HTTP
Siehe auch Zugriff auf entfernte Dateien, fopen() und file() für verwandte
Informationen.
Da include() und require() spezielle Sprachkonstrukte sind, müssen Sie diese innerhalb
einer bedingten Anweisung in einen Anweisungsblock setzen.
Beispiel 16-6. include() und bedingte Blöcke
21

Der Umgang mit Returns: Es ist möglich eine return() -Anweisung innerhalb einer
eingebunden Datei anzugeben, um die Ausführung innerhalb dieser Datei abzubrechen
und zum aufrufenden Skript zurückzukehren. Ebenso ist die Rückgabe von Werten aus
einer eingebunden Datei möglich. Sie können den Wert eines include-Aufrufs auf die
gleiche Art und Weise nutzen, wie Sie es bei einer Funktion machen würden. Allerdings
besteht diese Möglichkeit nicht, wenn Sie entfernte Dateien mittels include einbinden
außer, wenn die Ausgabe der entfernten Datei gültige PHP Start- und Endetags
beeinhaltet (wie jede lokale Datei auch). Innerhalb dieser Tags können Sie die
benötigten Variablen deklarieren und diese werden dann an dem Punkt Ihres Skripts
eingeführt, von wo aus der Aufruf mit include erfolgt ist.
Anmerkung: In PHP 3 darf eine return-Anweisung nicht innerhalb eines Blocks
auftreten, es sei denn, es ist ein Funktionsblock. In diesem Fall gilt return() für diese
Funktion und nicht für die ganze Datei.
Beispiel 16-7. include() und die return() Anweisung
return.php
noreturn.php
testreturns.php

echo $foo; // gibt 'PHP' aus
$bar = include 'noreturn.php';
echo $bar; // gibt 1 aus
?>
$bar hat den Wert 1, weil include erfolgreich war. Beachten Sie die Unterschiede in den
obigen Beispielen. Das erste nutzt return() innerhalb der eingebundenen Datei im
Gegensatz zum zweiten Beispiel. Weitere Möglichkeiten Dateien in Variablen
"einzubinden" bieten ihnen die Funktionen fopen() und file() oder include() im
Zusammenspiel mit den Funktionen zur Ausgabesteuerung.
Anmerkung: Da dies ein Sprachkonstrukt und keine Funktion ist, deshalb können Sie
dieses nicht mit Variablenfunktionen verwenden.
Siehe auch require(), require_once(), include_once(), readfile(), virtual()und
include_path.
5.2.4
7.4.3. HANDLER-Syntax
7.4.3.1. INSERT ... SELECT-Syntax
HANDLER tabelle OPEN [ AS alias ]
HANDLER tabelle READ index { = | >= |

Die vierte Form (ohne Index-Angabe) holt eine (oder mehrere, festgelegt durch die
LIMIT-Klausel) Zeile in natürlicher Zeilenreihenfolge aus der Tabelle (wie in der Daten-
Datei gespeichert), bei der die WHERE-Bedingung erfüllt ist. Das ist schneller als
HANDLER tabelle READ index, wenn ein kompletter Tabellen-Scan erwünscht ist.
Die letzte Form schließt eine mit HANDLER ... OPEN geöffnete Tabelle.
HANDLER ist in gewisser Hinsicht ein Statement auf niedriger Ebene (Low-Level), dass
zum Beispiel keine Konsistenz gewährleistet. Das heißt, HANDLER ... OPEN nimmt
KEINEN Schnappschuss der Tabelle auf und sperrt die Tabelle NICHT. Das bedeutet,
dass nach HANDLER ... OPEN Tabellendaten verändert werden können (durch diesen
oder einen anderen Thread) und dass diese Veränderungen nur teilweise in HANDLER
... NEXT- oder HANDLER ... PREV-Scans erscheinen.
5.2.5
mysql_query
(PHP 3, PHP 4 , PHP 5)
mysql_query -- Sendet eine Anfrage an MySQL
Beschreibung
resource mysql_query ( string Anfrage [, resource Verbindungs-Kennung] )
mysql_query() sendet eine Anfrage an die zur Zeit aktiven Datenbank, die mit der
angegebenen Verbindungs-Kennung assoziiert wird. Wird die Verbindungs-Kennung
nicht angegeben, wird die zuletzt geöffnete Verbindung angenommen. Wenn keine
offene Verbindung besteht, wird versucht eine Verbindung aufzubauen, wie beim
Aufruf von mysql_connect() ohne Argumente und diese wird dann benutzt. Das
Ergebnis der Anfrage wird gepuffert.
Anmerkung: Die Anfrage sollte nicht mit einem Semikolon enden.
Nur für SELECT, EXPLAIN, SHOW oder DESCRIBE Anweisungen liefert
mysql_query() eine Ressourcen-Kennung oder FALSE, falls die Anfrage nicht korrekt
ausgeführt wurde. Für alle anderen SQL Anweisungen ist der Rückgabewert von
mysql_query() im Erfolgsfall TRUE, im Fehlerfall FALSE. Ein Rückgabewert ungleich
FALSE bedeutet, dass die Anfrage gültig war und vom Server ausgeführt werden konnte.
Das alleine sagt jedoch überhaupt nichts über die Anzahl veränderter oder gelieferter
Datensätze aus. Es ist durchaus möglich, dass eine Anfrage erfolgreich war, ohne einen
einzigen Datensatz zur verändern oder zu liefern.
Die folgende Anfrage ist syntaktisch falsch, deshalb liefert mysql_query() FALSE
zurück:
Beispiel 1. mysql_query() Beispiel
24

Die folgende Anfrage ist semantisch falsch, wenn my_col kein Feld in der Tabelle
my_tbl ist. Deshalb schlägt mysql_query() fehl und liefert FALSE:
Beispiel 2. mysql_query()
mysql_query() schlägt ebenso fehl und liefert FALSE, wenn Sie keine Berechtigung
zum Zugriff auf die verwiesene(n) Tabelle(n) haben.
Angenommen eine Anfrage ist erfolgreich, dann können Sie für eine SELECT
Anweisung mit mysql_num_rows() die Anzahl der gelieferten Datensätze
herausfinden. Falls Sie DELETE, INSERT, REPLACE, oder UPDATE benutzt haben,
können Sie die Anzahl der betroffenen Datensätze mit mysql_affected_rows()
feststellen.
Nur bei SELECT, EXPLAIN, SHOW oder DESCRIBE Anweisungen liefert
mysql_query() eine neue Ergebnis-Kennung, die Sie an die Funktion
mysql_fetch_array() und andere Funktionen, die mit Ergebnistabellen umgehen
können, übergeben können. Sind sie mit der Bearbeitung Ihrer Ergebnisse fertig,
können Sie die belegten Resourcen durch den Aufruf von mysql_free_result()
freigeben. Ist die Ausführung des Skripts abgeschlossen, wird der belegte Speicher
automatisch freigegeben.
Siehe auch: mysql_num_rows() mysql_affected_rows(), mysql_unbuffered_query(),
mysql_free_result(), mysql_fetch_array(), mysql_fetch_row(), mysql_fetch_assoc(),
mysql_result(), mysql_select_db() und mysql_connect().
5.2.6
time
(PHP 3, PHP 4 , PHP 5)
time -- Gibt den gegenwärtigen Unix-Timestamp/Zeitstempel zurück
25

Beschreibung
int time ( void )
Gibt die seit Beginn der Unix-Epoche (Januar 1 1970 00:00:00 GMT) bis jetzt
vergangenen Sekunden zurück.
Siehe auch date() und microtime().
5.2.7
7.4.1. SELECT-Syntax
7.4.1.1. JOIN-Syntax
7.4.1.2. UNION-Syntax
SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT]
[SQL_BUFFER_RESULT]
[HIGH_PRIORITY]
[DISTINCT | DISTINCTROW | ALL]
select_ausdruck,...
[INTO {OUTFILE | DUMPFILE} 'datei' export_optionen]
[FROM tabellenreferenz
[WHERE where_definition]
[GROUP BY {positive_ganzzahl | spalten_name | formel} [ASC |
DESC], ...]
[HAVING where_definition]
[ORDER BY {positive_ganzzahl | spalten_name | formel} [ASC |
DESC] ,...]
[LIMIT [offset,] zeilen]
[PROCEDURE prozedur_name]
[FOR UPDATE | LOCK IN SHARE MODE]]
SELECT wird benutzt, um ausgewählte Zeilen aus einer oder mehreren Tabellen
abzurufen. select_ausdruck gibt die Spalten an, die Sie abrufen wollen. SELECT kann
auch benutzt werden, um Zeilen ohne Bezug zu irgend einer Tabelle abzurufen.
Beispiel:
mysql> SELECT 1 + 1;
-> 2
Alle benutzten Schlüsselwörter müssen genau in der oben angegebenen Reihenfolge
genannt werden. Beispielsweise muss eine HAVING-Klausel nach jeglicher GROUP BY-
Klausel und vor jeglicher ORDER BY-Klausel kommen.
• Einem SELECT-Ausdruck kann mit AS ein Alias zugewiesen werden. Der Alias
wird als Spaltenname verwendet und kann bei ORDER BY- oder HAVING-Klauseln
benutzt werden. Beispiel:
• mysql> select concat(nachname,', ',vorname) AS voller_name
• from tabelle ORDER BY voller_name;
• The FROM tabellenreferenz-Klausel gibt die Tabellen an, aus denen Zeilen
abgerufen werden sollen. Wenn Sie mehr als eine Tabelle aufführen, führen Sie
einen Join durch. Informationen über die Join-Syntax finden Sie unter
Abschnitt 7.4.1.1, „JOIN-Syntax“.
26

• Sie können auf eine Spalte als spalten_name verweisen, als
tabelle.spalten_name oder als datenbank.tabelle.spalten_name. Sie
müssen das tabelle- oder datenbank.tabelle-Präfix für einen Spaltenverweis
in einem SELECT-Statement nicht angeben, es sei denn, der Verweis wäre
ansonsten mehrdeutig. Sie Abschnitt 7.1.2, „Datenbank-, Tabellen-, Index-,
Spalten- und Alias-Namen“; hier finden sich Beispiele von Mehrdeutigkeit, die
erfordern, dass Sie ausführlichere Spaltenverweis-Formen benutzen.
• Einem Tabellenverweis kann mit tabelle [AS] alias_name ein Tabellen-
Alias zugewiesen werden:
• mysql> select t1.name, t2.gehalt from angestellte AS t1, info
AS t2
• where t1.name = t2.name;
• mysql> select t1.name, t2.gehalt from angestellte t1, info t2
• where t1.name = t2.name;
• Auf Spalten, die für die Ausgabe ausgewählt wurden, kann in ORDER BY- und
GROUP BY-Klauseln mit Spaltennamen, Spalten-Aliasen oder Spaltenpositionen
verwiesen werden. Spaltenpositionen fangen mit 1 an:
• mysql> select hochschule, region, seed von tournament
• ORDER BY region, seed;
• mysql> select hochschule, region AS r, seed AS s from turnier
• ORDER BY r, s;
• mysql> select hochschule, region, seed from turnier
• ORDER BY 2, 3;
Um in absteigender Reihenfolge zu sortieren, fügen Sie dem Namen der Spalte
das DESC-Schlüsselwort in the ORDER BY-Klausel hinzu (descending,
absteigend), nach der Sie sortieren. Die Vorgabe ist aufsteigende Reihenfolge.
Das können Sie auch explizit angeben, indem Sie das ASC-Schlüsselwort
verwenden.
• In der WHERE-Klausel können Sie beliebige Funktionen verwenden, die MySQL
unterstützt. See Abschnitt 7.3, „Funktionen für die Benutzung in SELECT- und
WHERE-Klauseln“.
• Die HAVING-Klausel kann auf jede Spalte oder jeden Alias verweisen, die bzw.
der im select_ausdruck genannt wurde. Die Klausel wird zuletzt angewandt,
direkt bevor Ergebnisse an den Client geschickt werden, ohne jede Optimierung.
Benutzen Sie kein HAVING für Dinge, die in der WHERE-Klausel stehen sollten.
Schreiben Sie beispielsweise nicht folgendes:
• mysql> select spalten_name from tabelle HAVING spalten_name >
0;
Sondern statt dessen:
mysql> select spalten_name from tabelle WHERE spalten_name > 0;
Ab MySQL-Version 3.22.5 können Sie Anfragen auch wie folgt schreiben:
mysql> select user,max(gehalt) from benutzer
group by benutzer HAVING max(gehalt)>10;
In älteren MySQL-Versionen schreiben Sie statt dessen:
27

mysql> select benutzer,max(gehalt) AS summe from benutzer
group by benutzer HAVING summe>10;
• SQL_SMALL_RESULT, SQL_BIG_RESULT, SQL_BUFFER_RESULT, STRAIGHT_JOIN
und HIGH_PRIORITY sind MySQL Erweiterungen zu ANSI-SQL92.
• HIGH_PRIORITY gibt dem SELECT höhere Priorität als einem Statement, das eine
Tabelle aktualisiert. Sie sollten das nur für Anfragen benutzen, die sehr schnell
sind und sofort durchgeführt werden müssen. Eine SELECT HIGH_PRIORITY-
Anfrage läuft, wenn die Tabelle eine Lese-Sperre hat, selbst wenn es ein Update-
Statement gibt, das darauf wartet, dass die Tabelle freigegeben wird.
• SQL_BIG_RESULT kann bei GROUP BY oder DISTINCT benutzt werden, um dem
Optimierer mitzuteilen, dass das Ergebnis sehr viele Zeilen haben wird. In
diesem Fall benutzt MySQL bei Bedarf direkt Festplatten-basierende temporäre
Tabellen. Ausserdem bevorzugt MySQL in diesem Fall Sortieren vor dem
Anlegen einer temporären Tabelle mit einem Schlüssel auf den GROUP BY-
Elementen.
• Wenn Sie GROUP BY benutzen, werden die Ausgabe-Zeilen gemäß dem GROUP
BY sortiert, als hätten Sie ein ORDER BY für alle Felder im GROUP BY angegeben.
MySQL hat GROUP BY erweitert, so dass Sie dafür auch ASC und DESC angeben
können:
• SELECT a,COUNT(b) FROM tabelle GROUP BY a DESC
• MySQL hat die Benutzung von GROUP BY erweitert, um es Ihnen zu gestatten,
auch Felder auszuwählen, die nicht in der GROUP BY-Klausel erwähnt wurden.
Wenn Sie nicht die Ergebnisse erhalten, die Sie von Ihrer Anfrage erwarten,
lesen Sie bitte die GROUP BY-Beschreibung.
• SQL_BUFFER_RESULT erzwingt, dass das Ergebnis in eine temporäre Tabelle
geschrieben wird. Das hilft MySQL, frühzeitig Tabellensperren aufzuheben, und
hilft in Fällen, in denen es lange dauert, das Ergebnis an den Client zu senden.
• SQL_SMALL_RESULT, eine MySQL-spezifische Option, kann bei GROUP BY oder
DISTINCT benutzt werden, um dem Optimierer mitzuteilen, dass der
Ergebnissatz klein sein wird. In diesem Fall benutzt MySQL schnelle temporäre
Tabellen, um die Ergebnistabelle zu speichern, anstatt Sortieren zu benutzen. In
MySQL-Version 3.23 sollte das normalerweise nicht benötigt werden.
• STRAIGHT_JOIN zwingt den Optimierer, Tabellen in der Reihenfolge zu
verknüpfen, in der sie in der FROM-Klausel aufgelistet sind. Sie können das
benutzen, um die Geschwindigkeit einer Anfrage zu erhöhen, wenn der
Optimierer Tabellen in nicht optimaler Reihenfolge verknüpft. See
Abschnitt 6.2.1, „EXPLAIN-Syntax (Informationen über ein SELECT erhalten)“.
• Die LIMIT-Klausel wird benutzt, um die Anzahl von Zeilen, die vom SELECT-
Statement zurückgegeben werden, zu beschränken. LIMIT erwartet ein oder zwei
numerische Argumente.
Wenn zwei Argumente angegeben sind, legt das erste den Offset der ersten Zeile
fest, die zurückgegeben wird, und das zweite gibt die maximale Anzahl von
Zeilen an, die zurückgegeben werden. Der Offset der anfänglichen Zeile ist 0
(nicht 1):
mysql> select * from tabelle LIMIT 5,10; # Zeilen 6 bis 15
zurückgeben
28

Wenn ein Argument angegeben wird, stellt es die maximale Anzahl von Zeilen
dar, die zurückgegeben werden:
mysql> select * from tabelle LIMIT 5; # Die ersten 5 Zeilen
zurückgeben
Mit anderen Worten ist LIMIT n äquivalent zu LIMIT 0,n.
• Die SELECT ... INTO OUTFILE 'datei'-Form von SELECT schreibt die
ausgewählten Zeilen in eine Datei. Die Datei wird auf dem Server-Host erzeugt
und darf nicht bereits bestehen (das verhindert unter anderem, dass
Datenbanktabellen und Dateien wie /etc/passwd zerstört werden). Sie
benötigen die file-Berechtigung auf dem Server-Host, um diese Form von
SELECT auszuführen.
SELECT ... INTO OUTFILE ist hauptsächlich dafür vorgesehen, um eine
Tabelle auf der Server-Maschine schnell zu dumpen. Wenn Sie die resultierende
Datei auf einem anderen Host als dem Server-Host haben wollen, können Sie
SELECT ... INTO OUTFILE nicht benutzen. In diesem Fall sollten Sie statt
dessen ein Client-Programm wie mysqldump --tab oder mysql -e "SELECT
..." > outfile benutzen, um die Datei zu erzeugen.
SELECT ... INTO OUTFILE ist das Komplement von LOAD DATA INFILE; die
Syntax für den export_optionen-Teil des Statements besteht aus denselben
FIELDS- und LINES-Klauseln, die beim LOAD DATA INFILE-Statement benutzt
werden. See Abschnitt 7.4.9, „LOAD DATA INFILE-Syntax“.
In der resultierenden Textdatei werden nur folgende Zeichen durch das ESCAPED
BY-Zeichen escapet:
o Das ESCAPED BY-Zeichen
o Das erste Zeichen in FIELDS TERMINATED BY
o Das erste Zeichen in LINES TERMINATED BY
Zusätzlich wird ASCII 0 in ESCAPED BY, gefolgt von 0 (ASCII 48),
umgewandelt.
Der Grund hierfür ist, dass Sie jegliche FIELDS TERMINATED BY-, ESCAPED BY-
oder LINES TERMINATED BY-Zeichen escapen MÜSSEN, um die Datei
zuverlässig wieder einlesen zu können. ASCII 0 wird escapet, um das Lesen mit
einigen Pagern zu erleichtern.
Weil sich die resultierende Datei nicht nach der SQL-Syntax richten muss, muss
nicht weiter escapet werden.
Im Folgenden ein Beispiel, wie man eine Datei in einem Format erhält, das von
vielen alten Programmen benutzt wird:
SELECT a,b,a+b INTO OUTFILE "/tmp/resultat.text"
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY "\n"
FROM tabelle;
29

5.2.8
• Wenn Sie INTO DUMPFILE anstelle von INTO OUTFILE benutzen, schreibt
MySQL nur eine Zeile in die Datei, ohne jede Spalten- oder Zeilen-Begrenzer
und ohne jedes Escapen. Das ist nützlich, wenn Sie ein Blob in eine Datei
speichern wollen.
• Beachten Sie, dass jede Datei, die von INTO OUTFILE und INTO DUMPFILE
erzeugt wird, für alle Benutzer lesbar ist! Der Grund liegt darin, dass der
MySQL-Server keine Datei erzeugen kann, die jemandem anderen gehört als
dem Benutzer, unter dem er läuft (Sie sollten mysqld nie als Root laufen lassen),
daher muss die Datei für jedermann lesbar sein, damit Sie die Zeilen abrufen
können.
• Wenn Sie FOR UPDATE bei einem Tabellen-Handler mit Seiten-/Zeilen-Sperren
benutzen, werden die untersuchten Zeilen schreib-gesperrt.
mysql_fetch_assoc
(PHP 4 >= 4.0.3, PHP 5)
mysql_fetch_assoc -- Liefert einen Datensatz als assoziatives Array
Beschreibung
array mysql_fetch_assoc ( resource Ergebnis)
Liefert ein assoziatives Array, das den geholten entprechenden Datensatz enthält. Sind
keine weiteren Datensätze vorhanden gibt diese Funktion FALSE zurück.
mysql_fetch_assoc() entspricht in der Funktionsweise exakt dem Aufruf von
mysql_fetch_array() mit Angabe von MYSQL_ASSOC als optionalen zweiten
Parameter. Diese Funktion liefert Ihnen nur ein assoziatives Array. Das war das
ursprüngliche Verhalten von mysql_fetch_array(). Falls Sie sowohl numerische, als
auch assoziative Indizes benötigen, verwenden Sie mysql_fetch_array().
Falls zwei oder mehrere Felder des Ergebnisses den gleichen Feldnamen haben, dann
wird nur der Wert des letzten Felds im Array unter diesem Feldnamen abgelegt. Um
auch auf die anderen, gleichnamigen, Felder zugreifen zu können, müssen Sie entweder
numerische Indizes und damit mysql_fetch_row() benutzen, oder Aliase für Ihre Felder
anlegen. Zur Verwendung von Aliasen schauen Sie sich das Beispiel unter der
Beschreibung von mysql_fetch_array() an.
Zu betonen ist, dass der Gebrauch von mysql_fetch_assoc() nicht signifikant langsamer
ist als mysql_fetch_row(), obwohl die Funktion einen sichtlichen Mehrwert bietet.
Anmerkung: Feldnamen, die von dieser Funktion zurückgegeben werden,
unterscheiden sich in der Groß-/Kleinschreibung.
Anmerkung: Diese Funktion setzt NULL Felder auf den PHP Wert NULL.
30

Beispiel 1. Ein ausführliches Beispiel zumysql_fetch_assoc()
Siehe auch mysql_fetch_row(), mysql_fetch_array(), mysql_query() und
mysql_error()
31

5.2.9
mysql_fetch_assoc
(PHP 4 >= 4.0.3, PHP 5)
mysql_fetch_assoc -- Liefert einen Datensatz als assoziatives Array
Beschreibung
array mysql_fetch_assoc ( resource Ergebnis )
Liefert ein assoziatives Array, das den geholten entprechenden Datensatz enthält. Sind
keine weiteren Datensätze vorhanden gibt diese Funktion FALSE zurück.
mysql_fetch_assoc() entspricht in der Funktionsweise exakt dem Aufruf von
mysql_fetch_array() mit Angabe von MYSQL_ASSOC als optionalen zweiten
Parameter. Diese Funktion liefert Ihnen nur ein assoziatives Array. Das war das
ursprüngliche Verhalten von mysql_fetch_array(). Falls Sie sowohl numerische, als
auch assoziative Indizes benötigen, verwenden Sie mysql_fetch_array().
Falls zwei oder mehrere Felder des Ergebnisses den gleichen Feldnamen haben, dann
wird nur der Wert des letzten Felds im Array unter diesem Feldnamen abgelegt. Um
auch auf die anderen, gleichnamigen, Felder zugreifen zu können, müssen Sie entweder
numerische Indizes und damit mysql_fetch_row() benutzen, oder Aliase für Ihre Felder
anlegen. Zur Verwendung von Aliasen schauen Sie sich das Beispiel unter der
Beschreibung von mysql_fetch_array() an.
Zu betonen ist, dass der Gebrauch von mysql_fetch_assoc() nicht signifikant langsamer
ist als mysql_fetch_row(), obwohl die Funktion einen sichtlichen Mehrwert bietet.
Anmerkung: Feldnamen, die von dieser Funktion zurückgegeben werden,
unterscheiden sich in der Groß-/Kleinschreibung.
Anmerkung: Diese Funktion setzt NULL Felder auf den PHP Wert NULL.
Beispiel 1. Ein ausführliches Beispiel zumysql_fetch_assoc()

FROM sometable
WHERE userstatus = 1";
$result = mysql_query($sql);
if (!$result) {
echo "Anfrage ($sql) konnte nicht ausgeführt werden : " .
mysql_error();
exit;
}
if (mysql_num_rows($result) == 0) {
echo "Keine Zeilen gefunden, nichts auszugeben, daher Abbruch";
exit;
}
// Solange eine Zeile mit Daten existiert, wird dies in dem
assoziativen Array
// $row abgelegt.
// Anmerkung: Wenn Sie nur eine Zeile erwarten, brauchen Sie keine
Schleife.
// Anmerkung: Wenn Sie extract($row) innerhalb der folgenden Schleife
// verwenden, können Sie damit die Variablen
// $userid, $fullname und $userstatus erzeugen.
while ($row = mysql_fetch_assoc($result)) {
echo $row["userid"];
echo $row["fullname"];
echo $row["userstatus"];
}
mysql_free_result($result);
?>
Siehe auch mysql_fetch_row(), mysql_fetch_array(), mysql_query() und
mysql_error()
5.2.10
date
(PHP 3, PHP 4 , PHP 5)
date -- Formatiert ein(e) angegebene(s) Zeit/Datum
Beschreibung:
string date ( string Format [, int Timestamp] )
Gibt einen formatierten String anhand eines vorzugebenden Musters zurück. Dabei wird
entweder der angegebene Timestamp oder die gegenwärtige lokale Zeit berücksichtigt,
wenn kein Timestamp angegegeben wird. Mit anderen Worten ausgedrückt: der
33

Parameter Timestamp ist optional und falls dieser nicht angegeben wird, wird der Wert
der Funktion time() angenommen.
Anmerkung: Der gültige Bereich eines Timestamp liegt typischerweise zwischen Fri,
13 Dec 1901 20:45:54 GMT und Tue, 19 Jan 2038 03:14:07 GMT. (Das entspricht den
minimalen und maximalen Werten für einen vorzeichenbehafteten 32-Bit Integer).
Unter Windows-Betriebssytemen ist dieser Bereich auf 01-01-1970 bis 19-01-2038
beschränkt.
Anmerkung: Um einen Timestamp aus aus einem Datums-String zu erzeugen, können
Sie die Funktion strtotime() benutzen. Zusätzlich bieten einige Datenbanken
Funktionen, um Ihre Datumsfromate in Timestamps umzuwandeln (wie zum Beispiel
MySQL's UNIX_TIMESTAMP Funktion.
Tabelle 1. Die folgenden Zeichen werden im Parameter Formaterkannt
Format
Zeichen
a
A
Beschreibung
Kleingeschrieben: Ante meridiem und Post
meridiem
Großgeschrieben: Ante meridiem und Post
meridiem
34
Beispiel für
Rückgabewerte
am oder pm
AM oder PM
B Swatch-Internet-Zeit 000 bis 999
c ISO 8601 Datum (hinzugefügt in PHP 5)
2004-02-
12T15:19:21+00:00
d Tag des Monats, 2-stellig mit führender Null 01 bis 31
D Tag der Woche als mit drei Buchstaben Mon bis Sun
F Monat als ganzes Wort, wie January oder March January bis December
g 12-Stunden-Format, ohne führende Nullen 1 bis 12
G 24-Stunden-Format, ohne führende Nullen 0 bis 23
h 12-Stunden-Format, mit führenden Nullen 01 bis 12
H 24-Stunden-Format, mit führenden Nullen 00 bis 23
i Minuten mit führenden Nullen 00 bis 59
I (großes
i)
Fällt ein Datum in die Sommerzeit
j Tag des Monats ohne führende Nullen 1 bis 31
l (kleines
'L')
1 bei Sommerzeit,
ansonsten 0.
Ausgeschriebener Tag der Woche Sunday bis Saturday
L Schaltjahr oder nicht
m Monat als Zahl, mit führenden Nullen 01 bis 12
1 für ein Schaltjahr,
ansonsten 0.
M Monatsname mit drei Buchstaben Jan bis Dec
n Monatszahl, ohne führende Nullen 1 bis 12
O Zeitunterschied zur Greenwich time (GMT) in Beispiel: +0200

Format
Zeichen
Stunden
Beschreibung
r RFC 2822 formatiertes Datum
s Sekunden, mit führenden Nullen 00 bis 59
S
Anhang der englischen Aufzählung für einen
Monatstag, zwei Zeichen
t Anzahl der Tage des angegebenen Monats 28 bis 31
35
Beispiel für
Rückgabewerte
Beispiel: Thu, 21 Dec 2000
16:01:07 +0200
st, nd, rd oder th. Zur
Verwendung mit j
empfohlen.
T Zeitzoneneinstellung des Rechners Beispiele: EST, MDT ...
U
Sekunden seit Beginn der UNIX-Epoche
(January 1 1970 00:00:00 GMT)
w Numerischer Tag einer Woche
W
ISO-8601 Wochennummer des Jahres, die
Woche beginnt am Montag (hinzugefügt in PHP
4.1.0)
Siehe auch time()
0 (für Sonntag) bis 6 (für
Samstag)
Beispiel: 42 (die 42 Woche
im Jahr)
Y Vierstellige Jahreszahl Beispiel: 1999 oder 2003
y Jahreszahl, zweistellig Beispiele: 99 oder 03
z Der Tag eines Jahres 0 bis 365
Z
Offset der Zeitzone in Sekunden. Der Offset für
Zeitzone West nach UTC ist immer negativ und
für Zeitzone Ost nach UTC immer positiv.
-43200 bis 43200
Nicht erkannte Zeichen werden unverändert ausgegeben. Das Z Format gibt beim
Gebrauch von gmdate() immer 0 zurück.
Beispiel 1. date() Beispiel
Möchten Sie verhindern, dass ein erkanntes Zeichen im Formatstring ersetzt wird,
sollten Sie dieses Zeichen mit einem vorangestellten Backslash escapen. Ist das Zeichen
mit dem Backslash bereits eine spezielle Zeichenfolge, müssen Sie diesen Backslash
ebenso escapen.

Beispiel 2. Escaping von Zeichen in date()
// gibt etwas ähnliches aus wie 'Wednesday the 15th'
echo date("l \\t\h\e jS");
Es ist möglich, date() und mktime() gleichzeitig zu verwenden, um Datumsangaben in
der Zukunft/Vergangenheit zu bestimmen.
Beispiel 3. date() und mktime() Beispiele
Anmerkung: Dieses Vorgehen kann zu verlässlicheren Ergebnissen führen, als simples
addieren oder subtrahieren der Anzahl von Sekunden in Tagen oder Monaten zu einem
Timestamp, da Sommer- und Winterzeit berücksichtigt werden.
Es folgen einige Beispiele zur date() Formatierung. Beachten Sie, dass Sie alle anderen
Zeichen escapen sollten, da alle Zeichen, die im Augenblick eine spezielle Bedeutung
haben, unerwünschte Resultate liefern. Bei allen weiteren Zeichen kann es durchaus
möglich sein, dass diesen in zukünftigen PHP-Versionen eine Bedeutung zukommt.
Beim escapen sollten Sie darauf achten einfache Anführungszeichen zu benutzen, damit
Zeichenfolgen wie zum Beispiel \n zu keinem Zeilenumbruch führen.
Beispiel 4. date() Formatierungen
Um Datumsangaben in anderen Sprach-/Zeitzonen-Formaten auszugeben, sollten Sie
die Funktionen setlocale() und strftime() benutzen.
Siehe auch getlastmod(), gmdate(), mktime(), strftime() und time().
36

5.2.11
echo
(PHP 3, PHP 4, PHP 5 )
echo -- Gibt einen oder mehrere Strings aus
Beschreibung
echo ( string arg1 [, string argn...] )
Gibt alle als Parameter angegebenen Strings aus.
echo() ist keine Funktion, sondern ein Sprach-Konstrukt. Deshalb brauchen Sie keine
Klammern zu verwenden. Wenn Sie echo mehr als einen Parameter übergeben wollen,
dürfen Sie diese nicht mit Klammern umgeben. Es ist nicht möglich, echo() in einem
Variablen-Funktionen Kontext zu nutzen.
Beispiel 1. echo() examples

mit nur einem Strichpunkt ohne extra Leerzeichen befinden muss!
END;
// echo ist keine Funktion, weshalb der folgende Code ungültig ist.
($some_var) ? echo('true'): echo('false');
// Aber folgende Beispiele funktionieren:
($some_var) ? print('true'): print('false'); // print ist eine
Funktion
echo $some_var ? 'true': 'false'; // Das Statement herumgedreht
?>
echo() kann auch in einer Kurzform verwendet werden, indem Sie unmittelbar nach
dem öffnenden Tag ein Gleichheitszeichen setzen.
I have foo.
Anmerkung: Diese Kurzform funktioniert nur, wenn die Konfigurationsoption
short_open_tag aktiviert ist.
Siehe auch print(), printf() und flush().
38