Fach: Informatik - Jan-Gerd Tenberge
Fach: Informatik - Jan-Gerd Tenberge
Fach: Informatik - Jan-Gerd Tenberge
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
Geschwister-Scholl-Gymnasium Stadtlohn<br />
<strong>Jan</strong>-<strong>Gerd</strong> <strong>Tenberge</strong><br />
Wessendorfer Str.11<br />
48703 Stadtlohn<br />
<strong>Fach</strong>: <strong>Informatik</strong><br />
Kurs: If GK<br />
<strong>Fach</strong>arbeit<br />
Thema:<br />
Datenbankbasierte Webprogrammierung<br />
–<br />
Ein Gästebuch in HTML, PHP und mySQL<br />
<strong>Fach</strong>lehrerin: Frau Wolff<br />
Abgabe: 08.04.2005<br />
1
Inhalt<br />
1. EINLEITUNG ................................................................................................. 3<br />
1.1 Themenfindung .................................................................................................................................... 3<br />
1.2 Grundlagen der PHP-Programmierung ............................................................................................ 4<br />
1.3 Grundlagen mySQL ............................................................................................................................ 4<br />
1.4 Das Projekt........................................................................................................................................... 5<br />
2. HAUPTTEIL ................................................................................................... 5<br />
2.1 Vorüberlegungen zur Datenbank....................................................................................................... 5<br />
2.2 Programmierung.................................................................................................................................. 6<br />
2.2.1 Aufteilung ...................................................................................................................................... 6<br />
2.2.2. Verbindung zur Datenbank – Connect.php ...................................................................................7<br />
2.2.3 Eingabe in die Datenbank – Eingabe.php ...................................................................................... 8<br />
2.2.4 Ausgabe der Daten in lesbarer Form – Ausgabe.php................................................................... 10<br />
2.2.5 Die Startseite – Index.php............................................................................................................ 12<br />
3. SCHLUß....................................................................................................... 13<br />
3.1 Fazit..................................................................................................................................................... 13<br />
4. RECHTLICHES............................................................................................ 14<br />
5. ANHÄNGE................................................................................................... 15<br />
5.1.1 Ausgabe.php.................................................................................................................................... 16<br />
5.1.2 connect.php...................................................................................................................................... 16<br />
5.1.3 Eingabe.php..................................................................................................................................... 16<br />
5.1.4 Eingabe.html ................................................................................................................................... 16<br />
5.1.5 index.php ......................................................................................................................................... 17<br />
2
1. Einleitung<br />
1.1 Themenfindung<br />
Ich habe mich entschieden, meine <strong>Fach</strong>arbeit im <strong>Fach</strong> <strong>Informatik</strong> schreiben, aber mich<br />
dabei weniger an den Unterrichtsinhalten orientieren als vielmehr den Versuch<br />
unternehmen etwas eigenes zu schaffen und dann darüber zu schreiben. Da es in der<br />
Kürze der Zeit nicht möglich war eine komplett neue Programmiersprache zu lernen<br />
stand ich vor der Wahl, mein Projekt entweder in Delphi oder in PHP zu verwirklichen.<br />
Ich überlegte mir also zunächst zwei Themen um mich nach Abwägung der<br />
Umsetzbarkeit im Rahmen einer <strong>Fach</strong>arbeit jedes der beiden für eines zu entscheiden.<br />
Da sich meine ursprüngliche Idee, ein Programm zur Erstellung und Verwaltung von<br />
Rechnungen mit Onlineanbindung in Delphi zu erstellen schnell als bei weitem zu<br />
komplex erwies nahm ich mir vor, eine Datenbankbasierte Anwendung in PHP zu<br />
schreiben.<br />
Dabei dachte ich zuerst an ein Content Managing System (CMS), aber auch diese Idee<br />
hätte den Rahmen des Umfanges der <strong>Fach</strong>arbeit bei weitem gesprengt. Stattdessen<br />
entschied ich mich für eine einfache Anwendung in Form eines Gästebuches. Anhand<br />
dieser lassen sich grundlegende Datenbankfunktionen und die Verwendung derselbigen<br />
gut aufzeigen und dennoch bleibt das Projekt vergleichsweise übersichtlich, so dass es<br />
im Rahmen einer <strong>Fach</strong>arbeit gut erläuterbar sein sollte.<br />
An dieser Stelle möchte ich anmerken, dass ich mich in dieser <strong>Fach</strong>arbeit vor allem auf<br />
die Programmierung in PHP beschränken werde, die grundlegenden Funktionen der<br />
Datenbank und Grundlagen der HTML-Programmierung werde ich an entsprechender<br />
Stelle kurz anschneiden, sie sollen jedoch nicht Gegenstand dieser Arbeit sein, da auch<br />
hier der recht begrenzt vorgegebene Umfang weit überschritten würde.<br />
3
1.2 Grundlagen der PHP-Programmierung<br />
PHP steht als rekursives Akronym für PHP Hypertext Preprocessor und am Namen lässt<br />
sich bereits das Einsatzgebiet ablesen. PHP ist eine serverbasierte Skriptsprache, was<br />
bedeutet, dass bei jedem Aufruf einer Seite das gesamte Skript auf dem Server<br />
abgearbeitet wird, der das Ergebnis als HTML (Hypertext Markup Language)-Code<br />
ausgibt, der dann im Browser angezeigt wird.<br />
Es handelt sich bei PHP also um keine Programmiersprache im engeren Sinn, denn das<br />
normalerweise übliche kompilieren von Programmen gibt es hier nicht. Bei jedem<br />
Aufruf wird das gesamte Skript Zeile für Zeile abgearbeitet.<br />
Grundsätzliche Vorteile der PHP-Programmierung gegenüber HTML ist die Dynamik<br />
der erzeugten Seiten. So lassen sich Inhalte sowohl aus anderen Dateien als auch aus<br />
einer der unterstützten Datenbanken (ich verwende hier mySQL, es werden aber in<br />
ähnlicher Weise auch weitere, beispielsweise PostgreSQL unterstützt) einbinden. Diese<br />
Möglichkeit der dynamischen Einbindung ist die Grundlage für jede Webseite mit der<br />
der Benutzer in irgendeiner Weise interagieren kann, sei es – wie in diesem Beispiel –<br />
ein Gästebuch, ein Forum oder ein Kommentarsystem.<br />
1.3 Grundlagen mySQL<br />
mySQL ist eine kostenlose, relationale Open-Source Datenbank, die zwar weniger<br />
leistungsfähig ist als ihre kostenpflichtigen Pendants (z.B. Oracle), im Internet aber<br />
aufgrund ihrer Lizenzfreiheit gerne genutzt wird.<br />
Im Rahmen dieses Projektes werde ich nur sehr wenige Funktionen der Datenbank<br />
nutzen. Diese werden an entsprechender Stelle näher erläutert, allen gemein ist aber,<br />
dass sie entweder zum Lesen, Schreiben oder Durchsuchen der Datenbank dienen.<br />
Daneben gibt es in mySQL viele weitere Befehle, die z.B. zum Zusammenführen,<br />
Optimieren, Teilen, Anlegen oder Löschen einzelner Tabellen oder Datenbanken<br />
4
dienen. Diese Möglichkeiten der Datenbank sind aber für die relativ einfache<br />
Anwendung eines Gästebuches nicht von belang.<br />
1.4 Das Projekt<br />
Das im Rahmen dieser <strong>Fach</strong>arbeit erstellte Gästebuch wird nur sehr rudimentäre<br />
Funktionen besitzen, es basiert auf einer einzigen Datenbank, die ihrerseits nur eine<br />
Tabelle enthält, in der die Beiträge der Besucher gespeichert werden.<br />
Die Funktionen des PHP-Skriptes werden sich darauf beschränken, den vom Nutzer<br />
eingegebenen Text samt einiger Informationen (Name, E-Mail Adresse und Homepage<br />
des Absenders sowie das aktuelle Datum inkl. Uhrzeit) in eine Datenbank zu schreiben<br />
und anschließend den Inhalt dieser Datenbank auszulesen und anzuzeigen.<br />
2. Hauptteil<br />
2.1 Vorüberlegungen zur Datenbank<br />
Bevor die eigentliche Programmierung beginnen kann ist zu überlegen, welche<br />
Informationen gespeichert werden sollen und wie diese am besten in einer Datenbank zu<br />
ordnen sind.<br />
Zunächst einmal sind natürlich die Eingaben des Nutzers zu speichern, dazu lege ich in<br />
der Datenbank (ich gehe an dieser Stelle davon aus, dass diese bereits existiert und der<br />
Name derselbigen vorgegeben ist) eine Tabelle mit dem Namen “Eingaben” an. Deren<br />
erste Spalten sind selbsterklärend:<br />
Name, EMail, Homepage, Text<br />
Um die Beiträge später chronologisch sortieren zu können füge ich noch eine weitere<br />
Spalte mit der Bezeichnung Datum hinzu. Diese wird später vollautomatisch mit dem<br />
aktuellen Datum samt Uhrzeit gefüttert, dazu später mehr.<br />
5
Nachdem diese Tabelle erstellt ist (die Erstellung als solche ist in PHP relativ komplex,<br />
daher beschäftige ich mich damit in dieser <strong>Fach</strong>arbeit nicht näher und setze die Tabellen<br />
als existent voraus) kann die eigentliche Programmierung des Gästebuches (und damit<br />
das eigentliche Thema dieser Arbeit) beginnen.<br />
2.2 Programmierung<br />
2.2.1 Aufteilung<br />
Um nicht die gleiche Sache mehrmals programmieren (und später evtl. anpassen) zu<br />
müssen, macht es Sinn die mehrfach verwendeten Funktionen in je eine Datei zu<br />
schreiben und diese später an passender Stelle einzubinden. Folgende Einteilung<br />
erscheint dabei sinnvoll:<br />
Index.php<br />
Diese Datei wir später beim Besuch der Seite aufgerufen, sie dient nur als ‚Container’<br />
für die anderen Dateien, die sie allesamt lädt.<br />
Eingabe.html<br />
Diese Datei ist eine statische HTML-Seite und beinhaltet nur das Eingabeformular in<br />
das der Benutzer später die Daten eingibt.<br />
Eingabe.php<br />
Nimmt die Daten von Eingabe.html entgegen und schreibt sie in die Datenbank.<br />
Ausgabe.php<br />
Hier werden die Daten aus der Datenbank ausgelesen, formatiert und ausgegeben.<br />
Connect.php<br />
Diese Datei stellt die Verbindung zur Datenbank her, sie liefert keinerlei Rückmeldung,<br />
wird aber von den Dateien Ausgabe.php und Eingabe.php genutzt.<br />
Die recht simpel gestrickte HTML-Seite soll hier nicht weiter behandelt werden, der<br />
Quelltext findet sich im Anhang 1.1. Wichtig und Auffällig ist nur, dass in der Datei<br />
Eingabe.html das action-Attribut des Form-Tags auf die Datei Eingabe.php verweist.<br />
6
2.2.2. Verbindung zur Datenbank – Connect.php<br />
Die Erstellung einer Verbindung zu einer Datenbank gliedert sich in PHP in zwei<br />
einfache Schritte:<br />
Zunächst wird eine Verbindung zum Server hergestellt auf dem die Datenbanksoftware<br />
(in diesem Falle mySQL) läuft, in einem zweiten Schritt muss dann noch die zu<br />
verwendende Datenbank ausgewählt werden. Dieser Schritt ist auch dann erforderlich,<br />
wenn (wie in diesem Fall) nur eine Datenbank vorhanden ist.<br />
Der (laut 1 zwar veraltete aber immer noch am häufigsten genutzte) Befehl zur<br />
Verbindungsaufnahme mit dem Server lautet mysql_connect() und erwartet die Adresse<br />
des Servers (entweder eine IP- oder eine Internet-Adresse) sowie Benutzername und<br />
Passwort sofern erforderlich. Die erste Zeile der Datei connect.php lautet also<br />
mysql_connect("www.mysqlserver.de", "UnserBenutzer", "UnserPasswort");<br />
Wobei die Platzhalter natürlich entsprechend der (im Normalfall vom Webspace-<br />
Anbieter zur Verfügung gestellten) Daten zu ersetzen sind. Im nächsten Schritt wählt<br />
der Befehl mysql_select_db() die zu verwendende Datenbank aus. Diese ist im<br />
Allgemeinen ebenfalls vom Anbieter vorgeben und sollte die Tabelle “Eingaben”<br />
beinhalten. Der Befehl erwartet lediglich die Angabe eines Datenbanknamens. Damit<br />
lautet Zeile zwei<br />
mysql_select_db("UnsereDatenbank");<br />
Weiteres zum Befehl unter 2 .<br />
Damit ist die Programmierung der ersten Datei bereits abgeschlossen. Lädt man diese<br />
Datei nun auf einen PHP-fähigen Webspace hoch und ruft sie auf, stellt sie automatisch<br />
eine Verbindung zum Server her. Die Ausgabe ist jedoch lediglich eine leere Seite.<br />
Diese Datei findet sich im Anhang als 1.2.<br />
1 http://dev.mysql.com/doc/mysql/de/mysql-connect.html<br />
2 http://dev.mysql.com/doc/mysql/de/mysql-select-db.html<br />
7
2.2.3 Eingabe in die Datenbank – Eingabe.php<br />
Die Datei Eingabe.php ist zum schreiben in die Datenbank natürlich auf eine<br />
Verbindung zu selbiger angewiesen. Dazu binde ich per include() die eben erstellte<br />
Datei connect.php ein. Das Skript wird nun so abgearbeitet, als stände der gesamte in<br />
connect.php enthaltene Code auch in Eingabe.php, mehr dazu auf der offiziellen PHP-<br />
Seite unter 3 . Die erste Zeile lautet also<br />
Include(“connect.php”);<br />
Jetzt müssen die vom Benutzer in der Datei Eingabe.html eingegeben Dateien in die<br />
Datenbank geschrieben werden. Durch einen klick auf den Button Absenden in dem<br />
Formular aus Eingabe.html ruft der Browser die Seite Eingabe.php auf und sendet ihr<br />
alle eingegeben Daten. Diese sind nun innerhalb des Skripts als Variablen mit dem<br />
Namen des id-Attributes des jeweiligen input-Tags verfügbar. Da die Felder in<br />
Eingabe.html die id-Tags Text_ein, Name_ein, Mail_ein und Homepage_ein tragen<br />
stehen nun die Variablen $Text_ein, $Name_ein, $Mail_ein und $Homepage_ein zur<br />
Verfügung.<br />
Um die Werte dieser Variablen (also die vom Benutzer eingegebenen Texte) in die<br />
Datenbank einzufügen verwenden wir die mySQL-Funktion Insert Into der mit<br />
folgendem Syntax aufgerufen wird:<br />
INSERT INTO a (b) VALUES (c)<br />
A ist hier die Tabelle in die die Werte geschrieben werden, b eine kommagetrennte<br />
Liste der Spalten die mit Werten gefüllt werden sollen und c eine ebenfalls<br />
kommagetrennte Liste der Werte, in der gleichen Reihenfolge wie bei b die Spalten<br />
aufgezählt wurden. Eine vollständige Beschreibung des Befehls ist zu finden unter 4<br />
Hierbei handelt es sich um eine native mySQL- und nicht um eine PHP-Funktion. Um<br />
mySQL-Befehle auszuführen bietet PHP den Befehl mysql_query an, der den gesamten<br />
3 http://de.php.net/include/<br />
4 http://dev.mysql.com/doc/mysql/de/insert.html<br />
8
an mySQL weiterzuleitenden Befehl als Parameter erwartet. Eine ausführliche<br />
Beschreibung ist unter 5 zu finden. Der vollständige mySQL lautet in diesem Falle<br />
INSERT INTO Eingaben (Name, EMail, Homepage, Text, Datum) VALUES<br />
('$Name_ein', '$Mail_ein', '$Homepage_ein', '$Text_ein', '$Datum')<br />
An dieser Stelle fällt auf, dass es in der Eingabemaske kein Feld für das Datum gibt.<br />
Um das aktuelle Datum zu erhalten bemühe ich die PHP-Funktion time() (siehe 6 ), die<br />
die aktuelle Uhrzeit samt Datum als PHP-Timestamp zurückliefert. Dieser Timestamp<br />
lässt sich später mit der Funktion date() wieder in ein lesbares Format bringen, dazu an<br />
entsprechender Stelle mehr.<br />
Nun muss also zunächst das aktuelle Datum in der Variable $Datum gespeichert<br />
werden, das geht in PHP vergleichsweise einfach, indem man der Variable einfach den<br />
Wert der Funktion zuweist, ein initialisieren der Variable wie aus anderen Sprachen<br />
bekannt ist nicht erforderlich, auch Unterscheidungen zwischen verschiedenen<br />
Variablentypen gibt es bei PHP nicht. Die Zeile lautet dementsprechend<br />
$Datum = time();<br />
Jetzt, da die Variable $Datum gesetzt ist sind alle zur Ausführung des Insert Into-<br />
Befehls nötigen Variablen vorhanden und er kann per mysql_query ausgeführt werden.<br />
Die gesamten Zeile dazu lautet<br />
Mysql_query(“INSERT INTO Eingaben (Name, EMail, Homepage, Text,<br />
Datum) VALUES ('$Name_ein', '$Mail_ein', '$Homepage_ein', '$Text_ein',<br />
'$Datum')”);<br />
Nach ausführen dieses Befehles ist die Eintragung abgeschlossen. Dem User kann nun<br />
also das Gästebuch samt seines frisch hinzugefügten Eintrages präsentiert werden. Dazu<br />
wird an dieser Stelle einfach die Datei Ausgabe.php nach altbekanntem Schema<br />
eingefügt, die die Ausgabe generiert.<br />
5 http://de.php.net/mysql_query<br />
6 http://de.php.net/time<br />
9
Include(“Ausgabe.php”);<br />
Damit ist auch dieses Skript fertig. Zu finden im Anhang unter 1.5.<br />
2.2.4 Ausgabe der Daten in lesbarer Form – Ausgabe.php<br />
Genau wie die Eingabe ist auch die Ausgabe auf eine Verbindung zur Datenbank<br />
angewiesen. Dazu binde ich wie oben wieder die Datei Connect.php ein.<br />
Include(“Connect.php”);<br />
Jetzt können bereits die Daten aus der Datenbank ausgelesen werden. Hierzu dient der<br />
mySQL-Befehl Select From. Der Syntax ist hierbei folgender:<br />
SELECT a FROM b ORDER BY c [ASC|DESC]<br />
Hierbei ist a eine Liste der zu ladenden Spalten. Da im Beispiel sämtliche Spalten<br />
gelesen werden sollen darf hier ein Sternchen (*) gesetzt werden. B ist die Tabelle aus<br />
der die Einträge entnommen werden sollen, hier also die Tabelle Eingaben. C<br />
bezeichnet die Spalte nach der Sortiert werden soll, im Beispiel logischerweise nach<br />
Datum, beginnend mit dem neuesten, also absteigend. Um anzuzeigen, dass die<br />
Sortierung ab- oder aufsteigend erfolgen soll dient das DESC (descending – absteigend)<br />
bzw. ASC (ascending – aufsteigend). Damit sieht der mySQL-Befehl für das Gästebuch<br />
wie folgt aus:<br />
SELECT * FROM guestbook ORDER BY datum DESC<br />
Mehr zum SELECT-Befehl unter 7<br />
Da das Ergebnis weiter benötigt wird (es soll ja noch formatiert und ausgegeben<br />
werden) wird es zunächst in der Variable $result gespeichert. Der mysql_query-Befehl<br />
wurde ja bereits weiter oben erläutert. Damit ergibt sich folgender Code:<br />
7 http://dev.mysql.com/doc/mysql/de/select.html<br />
10
$result = mysql_query("SELECT * FROM Eingaben ORDER BY datum<br />
DESC");<br />
Dem leichteren Umgang mit dem Ergebnis, das als mehrdimensionales Array<br />
ausgegeben wird, dient folgender Code von 8 , der auf der Funktion mysql_fetch_assoc<br />
basiert, dazu mehr unter 9 :<br />
while<br />
}<br />
($row = mysql_fetch_assoc($result)) {<br />
In den geschweiften Klammern kann nun die Formatierung und Ausgabe durchgeführt<br />
werden. Die while-Schleife läuft für jeden vorhandenen Eintrag einmal ab und bietet die<br />
folgenden Variablen, deren Inhalte aus der Datenbank geladen wurden:<br />
$row[Name], $row[EMail], $row[Homepage], $row[Text], $row[Datum]<br />
Da das Datum nach wie vor als Timestamp vorliegt muss es zunächst wieder in ein<br />
lesbares Format, am besten in das in Detschland übliche DD.MM.YYYY HH:MM<br />
gebracht werden. Hier hilft der Befehl date(), der als Parameter ein Format und einen<br />
Timestamp erwartet. Das Format lautet für diesen Fall “d.m.Y G:i”. Nachzulesen unter<br />
10 . Das formatierte Datum ergibt sich also mit<br />
Date(’d.m.Y G:i’, $row[Datum]);<br />
Damit ist es bereits möglich, den Inhalt der Datenbank wieder lesbar auszugeben. Dazu<br />
wird folgende While-Schleife unter Verwendung des Echo-Befehls (siehe 11 ) genutzt:<br />
while ($row = mysql_fetch_assoc($result)) {<br />
$Datum = Date('d.m.Y G:i', $row[Datum]);<br />
echo "Datum: $Datum";<br />
echo "Name: $row[Name] ";<br />
8<br />
http://www.phpcenter.de/de-html-manual/function.mysql-fetch-assoc.html<br />
9<br />
http://de.php.net/mysql_fetch_assoc<br />
10<br />
http://de2.php.net/date<br />
11<br />
http://de.php.net/echo<br />
11
}<br />
echo "E-Mail: $row[EMail]";<br />
echo "Homepage: $row[Homepage]";<br />
echo "$row[Text]";<br />
Der besseren Lesbarkeit halber habe ich durch den HTML-Tag einige<br />
Zeilenumbrüche hinzugefügt und die E-Mail- und Homepage-Adressen mithilfe der<br />
entsprechenden HTML-Tags in Links umgewandelt.<br />
2.2.5 Die Startseite – Index.php<br />
Die Gestaltung der Startseite ist denkbar einfach. Sie beinhaltet lediglich das Formular<br />
zum Einfügen neuer Daten sowie eine Anzeige aller bereits vorhandenen Einträge. Um<br />
dieses zu erreichen sind lediglich zwei Zeilen Code notwendig.<br />
Include(“Eingabe.html”);<br />
Include(“Ausgabe.php”);<br />
Diese Seite zeigt also das Eingabeformular oberhalb aller bereits erstellten Einträge an.<br />
Wie hieran zu erkennen ist, lassen sich per include() auch statische HTML- oder Text-<br />
Seiten einbinden, die dann an entsprechender Stelle angezeigt werden.<br />
12
3. Schluß<br />
3.1 Fazit<br />
Abschließend betrachtet zeigt sich, dass selbst ein einfaches Gästebuch, dass<br />
letztendlich nur aus sehr wenigen Zeilen Code besteht vielleicht immer noch ein für<br />
eine <strong>Fach</strong>arbeit zu komplexes Thema ist, da der vorgegebene Platz von 8 - 12 Seiten<br />
kaum ausreichte um die Programmierung und die einzelnen Funktionen ausführlich zu<br />
beschreiben.<br />
Gerne hätte ich auch noch weitere Funktionen eingebaut, beispielsweise einige<br />
Einstellungsmöglichkeiten (wie viele Einträge pro Seite gezeigt werden beispielsweise).<br />
Auch für ein echtes Design reichte der Platz leider nicht mehr, so dass das Resultat<br />
meines Projektes zwar funktional aber nicht sonderlich schön geraten ist. Ich habe<br />
außerhalb der <strong>Fach</strong>arbeit noch weiter an diesem Gästebuch gearbeitet und setzte es jetzt<br />
auf meiner Homepage ein, zu sehen unter http://janten.com/?action=guestbook, sehr<br />
gerne hätte ich es in seiner dort zu sehenden Funktionalität und dem dortigen Umfang<br />
dokumentiert.<br />
Alles in allem muss ich sagen, dass mir die Erstellung dieser <strong>Fach</strong>arbeit viel Spaß<br />
gemacht hat und ich viele der Dinge die ich dabei gelernt habe auch in anderen<br />
Projekten weiterverwenden kann.<br />
13
4. Rechtliches<br />
Ich erkläre, dass ich die <strong>Fach</strong>arbeit ohne fremde Hilfe angefertigt und nur die im<br />
Literaturverzeichnis angeführten Quellen und Hilfsmittel benutzt habe.<br />
6. April 2005<br />
14
5. Anhänge<br />
Die Anhänge 5.1.1 bis 5.1.5 enthalten die Quelltexte der erstellten PHP- und HTML-<br />
Seiten, des weiteren finden sie eine nicht weiter bearbeitete funktionsfähige Version<br />
dieses Gästebuches im Internet unter http://janten.com/FA.,<br />
Die Anlagen 5.2.1 bis 5.2.12 enthalten die in den Fußnoten erwähnten Internetseiten,<br />
allesamt mit dem Stand vom 06.04.2005, soweit nicht anders angegeben.<br />
15
5.1.1 Ausgabe.php<br />
<br />
5.1.2 connect.php<br />
<br />
5.1.3 Eingabe.php<br />
<br />
<br />
Unbenanntes Dokument<br />
<br />
<br />
<br />
<br />
Name:<br />
<br />
<br />
E-Mail:<br />
<br />
<br />
Homepage:<br />
<br />
<br />
Text:<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
<br />
5.1.5 index.php<br />
<br />
17
5.2.1<br />
9.4.3.3. mysql_connect()<br />
MYSQL *mysql_connect(MYSQL *mysql, const char *host, const char *user,<br />
const char *passwd)<br />
Beschreibung<br />
Diese Funktion ist veraltet. Sie sollten statt dessen mysql_real_connect() benutzen.<br />
mysql_connect() versucht, eine Verbindung zu einer MySQL-Datenbankmaschine<br />
aufzubauen, die auf host läuft. mysql_connect() muss erfolgreich beendet werden,<br />
bevor Sie irgend welche weiteren API-Funktionen aufrufen können, mit Ausnahme von<br />
mysql_get_client_info().<br />
Die Bedeutung der Parameter ist dieselbe wie die entsprechenden Parameter bei<br />
mysql_real_connect(), mit dem Unterschied, dass die Verbindungsparameter NULL<br />
sein dürfen. In diesem Fall weist die C-API automatisch Speicher für die<br />
Verbindungsstruktur zu und gibt diesen frei, wenn Sie mysql_close() aufrufen. Der<br />
Nachteil dieses Ansatzes besteht darin, dass Sie keine Fehlermeldung abrufen können,<br />
wenn die Verbindung fehlschlägt. (Um Fehlerinformationen von mysql_errno() oder<br />
mysql_error() abrufen zu können, müssen Sie einen gültigen MYSQL-Zeiger angeben.)<br />
Rückgabewerte<br />
Dieselben wie für mysql_real_connect().<br />
Fehler<br />
Dieselben wie für mysql_real_connect().<br />
5.2.2<br />
9.4.3.47. mysql_select_db()<br />
int mysql_select_db(MYSQL *mysql, const char *db)<br />
Beschreibung<br />
Führt dazu, dass die Datenbank, die durch db angegeben wird, die vorgabemäßige<br />
(aktuelle) Datenbank auf der von mysql angegebenen Verbindung wird. Bei<br />
nachfolgenden Anfragen ist diese Datenbank die Vorgabe für Tabellenverweise, die<br />
nicht explizit einen Datenbank-Spezifizierer enthalten.<br />
mysql_select_db() schlägt fehl, wenn der verbundene Benutzer keine Zugriffsrechte<br />
auf die Datenbank hat.<br />
18
Rückgabewerte<br />
0 bei Erfolg. Nicht-0, wenn ein Fehler auftrat.<br />
Fehler<br />
5.2.3<br />
• CR_COMMANDS_OUT_OF_SYNC<br />
Befehle wurden nicht in der korrekten Reihenfolge ausgeführt.<br />
• CR_SERVER_GONE_ERROR<br />
Der MySQL-Server ist weg.<br />
• CR_SERVER_LOST<br />
Die Verbindung zum Server ging während der Anfrage verloren.<br />
• CR_UNKNOWN_ERROR<br />
include()<br />
Ein unbekannter Fehler trat auf.<br />
Die include() Anweisung bindet die angegebene Datei ein und wertet diese aus.<br />
Die untenstehende Dokumentation gilt ebenso für require(). Diese beiden Konstrukte<br />
sind in jeder Hinsicht gleichwertig mit der einen Ausnahme: der Umgang mit Fehlern.<br />
include() erzeugt ein Warning während require() in einem Fatal Error endet. Mit<br />
anderen Worten, verwenden Sie require(), wenn Sie möchten, dass eine fehlende Datei<br />
die Ausführung ihres Skripts beendet. include() verhält sich anders, ihr Skript wird<br />
weiterhin ausgeführt. Stellen Sie außerdem sicher, dass Sie einen gültigen include_path<br />
gesetzt haben. Beachten Sie, dass eine Parse Error in einer Datei, die mit require<br />
eingebunden wurde, die Ausführung ihre Skripts nicht unterbricht.<br />
Dateien die mit include eingebunden werden, werden zuerst im include_path relativ<br />
zum gegenwärtigen Arbeitsverzeichnis gesucht und danach im include_path relativ zum<br />
Verzeichnis des ausgeführten Skripts. Zur Veranschaulichung: Falls Ihr include_path .<br />
entspricht, ist das gegenwärtige Arbeitsverzeichnis /www/. Sie haben über include<br />
include/a.php eingebunden und in diesem Skript steht die Anweisung include<br />
"b.php". In diesem Fall wird b.php zuerst im Verzeichnis /www/ gesucht und danach im<br />
Verzeichnis /www/include/.<br />
Wenn eine Datei eingebunden wird, erbt der enthaltene Code den Geltungsbereich von<br />
Variablen der Zeile in der die Anweisung steht. Ab dieser Zeile stehen alle verfügbaren<br />
Variablen in der aufgerufenen Datei im aufrufenden Skript zur Verfügung.<br />
19
Beispiel 16-3. Grundlegendes include() Beispiel<br />
vars.php<br />
<br />
test.php<br />
<br />
Steht include im aufrufenden Skript innerhalb einer Funktion, verhält sich der gesamte<br />
Code der aufgerufenen Datei genau so, als ob Sie diesen Code innerhalb dieser<br />
Funktion definiert hätten. Aus diesem Grund hat dieser Code den Geltungsbereich der<br />
Variablen dieser Funktion.<br />
Beispiel 16-4. Include innerhalb einer Funktion<br />
<br />
Beim Einbinden einer Datei wechselt der Parser vom PHP-Modus zu Beginn der<br />
Zieldatei in den HTML-Modus und kehrt am Ende der eingebunden Datei wieder in den<br />
PHP-Modus zurück. Deshalb muss jeglicher Code innerhalb der eingebundenen Datei,<br />
der als PHP-Code ausgeführt werden soll, von gültigen PHP-Start- und Ende-Tags<br />
eingefaßt sein.<br />
20
Wenn "URL fopen wrappers" in PHP aktiviert sind (in der Standardkonfiguration ist das<br />
der Fall) können Sie als Pfad der einzubindenden Datei auch eine URL (via HTTP oder<br />
anderen unterstützen Wrappern - eine Liste der unterstützen Protokolle finden Sie unter<br />
Anhang L) statt einer lokalen Pfadangabe angeben. Falls der Zielserver die Zieldatei als<br />
PHP-Code interpretiert, können Sie an die einzubindende Datei Variablen in einem<br />
Request-String übergeben, genauso wie bei HTTP GET. Streng genommen ist das nicht<br />
das Gleiche, wie diese Datei einzubinden und diesem den Geltungsbereich des Vater-<br />
Skripts zu vererben; das Skript wird auf dem Remote-Server ausgeführt und danach<br />
wird das Ergebnis in das lokale Skript eingebunden.<br />
Warnung<br />
PHP Versionen kleiner 4.3.0 für Windows, erlauben den Zugriff auf Remote-Dateien<br />
mit dieser Funktion nicht, selbst wenn allow_url_fopen aktiviert ist.<br />
Beispiel 16-5. include() über HTTP<br />
<br />
Siehe auch Zugriff auf entfernte Dateien, fopen() und file() für verwandte<br />
Informationen.<br />
Da include() und require() spezielle Sprachkonstrukte sind, müssen Sie diese innerhalb<br />
einer bedingten Anweisung in einen Anweisungsblock setzen.<br />
Beispiel 16-6. include() und bedingte Blöcke<br />
21
Der Umgang mit Returns: Es ist möglich eine return() -Anweisung innerhalb einer<br />
eingebunden Datei anzugeben, um die Ausführung innerhalb dieser Datei abzubrechen<br />
und zum aufrufenden Skript zurückzukehren. Ebenso ist die Rückgabe von Werten aus<br />
einer eingebunden Datei möglich. Sie können den Wert eines include-Aufrufs auf die<br />
gleiche Art und Weise nutzen, wie Sie es bei einer Funktion machen würden. Allerdings<br />
besteht diese Möglichkeit nicht, wenn Sie entfernte Dateien mittels include einbinden<br />
außer, wenn die Ausgabe der entfernten Datei gültige PHP Start- und Endetags<br />
beeinhaltet (wie jede lokale Datei auch). Innerhalb dieser Tags können Sie die<br />
benötigten Variablen deklarieren und diese werden dann an dem Punkt Ihres Skripts<br />
eingeführt, von wo aus der Aufruf mit include erfolgt ist.<br />
Anmerkung: In PHP 3 darf eine return-Anweisung nicht innerhalb eines Blocks<br />
auftreten, es sei denn, es ist ein Funktionsblock. In diesem Fall gilt return() für diese<br />
Funktion und nicht für die ganze Datei.<br />
Beispiel 16-7. include() und die return() Anweisung<br />
return.php<br />
<br />
noreturn.php<br />
<br />
testreturns.php<br />
echo $foo; // gibt 'PHP' aus<br />
$bar = include 'noreturn.php';<br />
echo $bar; // gibt 1 aus<br />
?><br />
$bar hat den Wert 1, weil include erfolgreich war. Beachten Sie die Unterschiede in den<br />
obigen Beispielen. Das erste nutzt return() innerhalb der eingebundenen Datei im<br />
Gegensatz zum zweiten Beispiel. Weitere Möglichkeiten Dateien in Variablen<br />
"einzubinden" bieten ihnen die Funktionen fopen() und file() oder include() im<br />
Zusammenspiel mit den Funktionen zur Ausgabesteuerung.<br />
Anmerkung: Da dies ein Sprachkonstrukt und keine Funktion ist, deshalb können Sie<br />
dieses nicht mit Variablenfunktionen verwenden.<br />
Siehe auch require(), require_once(), include_once(), readfile(), virtual()und<br />
include_path.<br />
5.2.4<br />
7.4.3. HANDLER-Syntax<br />
7.4.3.1. INSERT ... SELECT-Syntax<br />
HANDLER tabelle OPEN [ AS alias ]<br />
HANDLER tabelle READ index { = | >= |
Die vierte Form (ohne Index-Angabe) holt eine (oder mehrere, festgelegt durch die<br />
LIMIT-Klausel) Zeile in natürlicher Zeilenreihenfolge aus der Tabelle (wie in der Daten-<br />
Datei gespeichert), bei der die WHERE-Bedingung erfüllt ist. Das ist schneller als<br />
HANDLER tabelle READ index, wenn ein kompletter Tabellen-Scan erwünscht ist.<br />
Die letzte Form schließt eine mit HANDLER ... OPEN geöffnete Tabelle.<br />
HANDLER ist in gewisser Hinsicht ein Statement auf niedriger Ebene (Low-Level), dass<br />
zum Beispiel keine Konsistenz gewährleistet. Das heißt, HANDLER ... OPEN nimmt<br />
KEINEN Schnappschuss der Tabelle auf und sperrt die Tabelle NICHT. Das bedeutet,<br />
dass nach HANDLER ... OPEN Tabellendaten verändert werden können (durch diesen<br />
oder einen anderen Thread) und dass diese Veränderungen nur teilweise in HANDLER<br />
... NEXT- oder HANDLER ... PREV-Scans erscheinen.<br />
5.2.5<br />
mysql_query<br />
(PHP 3, PHP 4 , PHP 5)<br />
mysql_query -- Sendet eine Anfrage an MySQL<br />
Beschreibung<br />
resource mysql_query ( string Anfrage [, resource Verbindungs-Kennung] )<br />
mysql_query() sendet eine Anfrage an die zur Zeit aktiven Datenbank, die mit der<br />
angegebenen Verbindungs-Kennung assoziiert wird. Wird die Verbindungs-Kennung<br />
nicht angegeben, wird die zuletzt geöffnete Verbindung angenommen. Wenn keine<br />
offene Verbindung besteht, wird versucht eine Verbindung aufzubauen, wie beim<br />
Aufruf von mysql_connect() ohne Argumente und diese wird dann benutzt. Das<br />
Ergebnis der Anfrage wird gepuffert.<br />
Anmerkung: Die Anfrage sollte nicht mit einem Semikolon enden.<br />
Nur für SELECT, EXPLAIN, SHOW oder DESCRIBE Anweisungen liefert<br />
mysql_query() eine Ressourcen-Kennung oder FALSE, falls die Anfrage nicht korrekt<br />
ausgeführt wurde. Für alle anderen SQL Anweisungen ist der Rückgabewert von<br />
mysql_query() im Erfolgsfall TRUE, im Fehlerfall FALSE. Ein Rückgabewert ungleich<br />
FALSE bedeutet, dass die Anfrage gültig war und vom Server ausgeführt werden konnte.<br />
Das alleine sagt jedoch überhaupt nichts über die Anzahl veränderter oder gelieferter<br />
Datensätze aus. Es ist durchaus möglich, dass eine Anfrage erfolgreich war, ohne einen<br />
einzigen Datensatz zur verändern oder zu liefern.<br />
Die folgende Anfrage ist syntaktisch falsch, deshalb liefert mysql_query() FALSE<br />
zurück:<br />
Beispiel 1. mysql_query() Beispiel<br />
24
Die folgende Anfrage ist semantisch falsch, wenn my_col kein Feld in der Tabelle<br />
my_tbl ist. Deshalb schlägt mysql_query() fehl und liefert FALSE:<br />
Beispiel 2. mysql_query()<br />
<br />
mysql_query() schlägt ebenso fehl und liefert FALSE, wenn Sie keine Berechtigung<br />
zum Zugriff auf die verwiesene(n) Tabelle(n) haben.<br />
Angenommen eine Anfrage ist erfolgreich, dann können Sie für eine SELECT<br />
Anweisung mit mysql_num_rows() die Anzahl der gelieferten Datensätze<br />
herausfinden. Falls Sie DELETE, INSERT, REPLACE, oder UPDATE benutzt haben,<br />
können Sie die Anzahl der betroffenen Datensätze mit mysql_affected_rows()<br />
feststellen.<br />
Nur bei SELECT, EXPLAIN, SHOW oder DESCRIBE Anweisungen liefert<br />
mysql_query() eine neue Ergebnis-Kennung, die Sie an die Funktion<br />
mysql_fetch_array() und andere Funktionen, die mit Ergebnistabellen umgehen<br />
können, übergeben können. Sind sie mit der Bearbeitung Ihrer Ergebnisse fertig,<br />
können Sie die belegten Resourcen durch den Aufruf von mysql_free_result()<br />
freigeben. Ist die Ausführung des Skripts abgeschlossen, wird der belegte Speicher<br />
automatisch freigegeben.<br />
Siehe auch: mysql_num_rows() mysql_affected_rows(), mysql_unbuffered_query(),<br />
mysql_free_result(), mysql_fetch_array(), mysql_fetch_row(), mysql_fetch_assoc(),<br />
mysql_result(), mysql_select_db() und mysql_connect().<br />
5.2.6<br />
time<br />
(PHP 3, PHP 4 , PHP 5)<br />
time -- Gibt den gegenwärtigen Unix-Timestamp/Zeitstempel zurück<br />
25
Beschreibung<br />
int time ( void )<br />
Gibt die seit Beginn der Unix-Epoche (<strong>Jan</strong>uar 1 1970 00:00:00 GMT) bis jetzt<br />
vergangenen Sekunden zurück.<br />
Siehe auch date() und microtime().<br />
5.2.7<br />
7.4.1. SELECT-Syntax<br />
7.4.1.1. JOIN-Syntax<br />
7.4.1.2. UNION-Syntax<br />
SELECT [STRAIGHT_JOIN] [SQL_SMALL_RESULT] [SQL_BIG_RESULT]<br />
[SQL_BUFFER_RESULT]<br />
[HIGH_PRIORITY]<br />
[DISTINCT | DISTINCTROW | ALL]<br />
select_ausdruck,...<br />
[INTO {OUTFILE | DUMPFILE} 'datei' export_optionen]<br />
[FROM tabellenreferenz<br />
[WHERE where_definition]<br />
[GROUP BY {positive_ganzzahl | spalten_name | formel} [ASC |<br />
DESC], ...]<br />
[HAVING where_definition]<br />
[ORDER BY {positive_ganzzahl | spalten_name | formel} [ASC |<br />
DESC] ,...]<br />
[LIMIT [offset,] zeilen]<br />
[PROCEDURE prozedur_name]<br />
[FOR UPDATE | LOCK IN SHARE MODE]]<br />
SELECT wird benutzt, um ausgewählte Zeilen aus einer oder mehreren Tabellen<br />
abzurufen. select_ausdruck gibt die Spalten an, die Sie abrufen wollen. SELECT kann<br />
auch benutzt werden, um Zeilen ohne Bezug zu irgend einer Tabelle abzurufen.<br />
Beispiel:<br />
mysql> SELECT 1 + 1;<br />
-> 2<br />
Alle benutzten Schlüsselwörter müssen genau in der oben angegebenen Reihenfolge<br />
genannt werden. Beispielsweise muss eine HAVING-Klausel nach jeglicher GROUP BY-<br />
Klausel und vor jeglicher ORDER BY-Klausel kommen.<br />
• Einem SELECT-Ausdruck kann mit AS ein Alias zugewiesen werden. Der Alias<br />
wird als Spaltenname verwendet und kann bei ORDER BY- oder HAVING-Klauseln<br />
benutzt werden. Beispiel:<br />
• mysql> select concat(nachname,', ',vorname) AS voller_name<br />
• from tabelle ORDER BY voller_name;<br />
• The FROM tabellenreferenz-Klausel gibt die Tabellen an, aus denen Zeilen<br />
abgerufen werden sollen. Wenn Sie mehr als eine Tabelle aufführen, führen Sie<br />
einen Join durch. Informationen über die Join-Syntax finden Sie unter<br />
Abschnitt 7.4.1.1, „JOIN-Syntax“.<br />
26
• Sie können auf eine Spalte als spalten_name verweisen, als<br />
tabelle.spalten_name oder als datenbank.tabelle.spalten_name. Sie<br />
müssen das tabelle- oder datenbank.tabelle-Präfix für einen Spaltenverweis<br />
in einem SELECT-Statement nicht angeben, es sei denn, der Verweis wäre<br />
ansonsten mehrdeutig. Sie Abschnitt 7.1.2, „Datenbank-, Tabellen-, Index-,<br />
Spalten- und Alias-Namen“; hier finden sich Beispiele von Mehrdeutigkeit, die<br />
erfordern, dass Sie ausführlichere Spaltenverweis-Formen benutzen.<br />
• Einem Tabellenverweis kann mit tabelle [AS] alias_name ein Tabellen-<br />
Alias zugewiesen werden:<br />
• mysql> select t1.name, t2.gehalt from angestellte AS t1, info<br />
AS t2<br />
• where t1.name = t2.name;<br />
• mysql> select t1.name, t2.gehalt from angestellte t1, info t2<br />
• where t1.name = t2.name;<br />
• Auf Spalten, die für die Ausgabe ausgewählt wurden, kann in ORDER BY- und<br />
GROUP BY-Klauseln mit Spaltennamen, Spalten-Aliasen oder Spaltenpositionen<br />
verwiesen werden. Spaltenpositionen fangen mit 1 an:<br />
• mysql> select hochschule, region, seed von tournament<br />
• ORDER BY region, seed;<br />
• mysql> select hochschule, region AS r, seed AS s from turnier<br />
• ORDER BY r, s;<br />
• mysql> select hochschule, region, seed from turnier<br />
• ORDER BY 2, 3;<br />
Um in absteigender Reihenfolge zu sortieren, fügen Sie dem Namen der Spalte<br />
das DESC-Schlüsselwort in the ORDER BY-Klausel hinzu (descending,<br />
absteigend), nach der Sie sortieren. Die Vorgabe ist aufsteigende Reihenfolge.<br />
Das können Sie auch explizit angeben, indem Sie das ASC-Schlüsselwort<br />
verwenden.<br />
• In der WHERE-Klausel können Sie beliebige Funktionen verwenden, die MySQL<br />
unterstützt. See Abschnitt 7.3, „Funktionen für die Benutzung in SELECT- und<br />
WHERE-Klauseln“.<br />
• Die HAVING-Klausel kann auf jede Spalte oder jeden Alias verweisen, die bzw.<br />
der im select_ausdruck genannt wurde. Die Klausel wird zuletzt angewandt,<br />
direkt bevor Ergebnisse an den Client geschickt werden, ohne jede Optimierung.<br />
Benutzen Sie kein HAVING für Dinge, die in der WHERE-Klausel stehen sollten.<br />
Schreiben Sie beispielsweise nicht folgendes:<br />
• mysql> select spalten_name from tabelle HAVING spalten_name ><br />
0;<br />
Sondern statt dessen:<br />
mysql> select spalten_name from tabelle WHERE spalten_name > 0;<br />
Ab MySQL-Version 3.22.5 können Sie Anfragen auch wie folgt schreiben:<br />
mysql> select user,max(gehalt) from benutzer<br />
group by benutzer HAVING max(gehalt)>10;<br />
In älteren MySQL-Versionen schreiben Sie statt dessen:<br />
27
mysql> select benutzer,max(gehalt) AS summe from benutzer<br />
group by benutzer HAVING summe>10;<br />
• SQL_SMALL_RESULT, SQL_BIG_RESULT, SQL_BUFFER_RESULT, STRAIGHT_JOIN<br />
und HIGH_PRIORITY sind MySQL Erweiterungen zu ANSI-SQL92.<br />
• HIGH_PRIORITY gibt dem SELECT höhere Priorität als einem Statement, das eine<br />
Tabelle aktualisiert. Sie sollten das nur für Anfragen benutzen, die sehr schnell<br />
sind und sofort durchgeführt werden müssen. Eine SELECT HIGH_PRIORITY-<br />
Anfrage läuft, wenn die Tabelle eine Lese-Sperre hat, selbst wenn es ein Update-<br />
Statement gibt, das darauf wartet, dass die Tabelle freigegeben wird.<br />
• SQL_BIG_RESULT kann bei GROUP BY oder DISTINCT benutzt werden, um dem<br />
Optimierer mitzuteilen, dass das Ergebnis sehr viele Zeilen haben wird. In<br />
diesem Fall benutzt MySQL bei Bedarf direkt Festplatten-basierende temporäre<br />
Tabellen. Ausserdem bevorzugt MySQL in diesem Fall Sortieren vor dem<br />
Anlegen einer temporären Tabelle mit einem Schlüssel auf den GROUP BY-<br />
Elementen.<br />
• Wenn Sie GROUP BY benutzen, werden die Ausgabe-Zeilen gemäß dem GROUP<br />
BY sortiert, als hätten Sie ein ORDER BY für alle Felder im GROUP BY angegeben.<br />
MySQL hat GROUP BY erweitert, so dass Sie dafür auch ASC und DESC angeben<br />
können:<br />
• SELECT a,COUNT(b) FROM tabelle GROUP BY a DESC<br />
• MySQL hat die Benutzung von GROUP BY erweitert, um es Ihnen zu gestatten,<br />
auch Felder auszuwählen, die nicht in der GROUP BY-Klausel erwähnt wurden.<br />
Wenn Sie nicht die Ergebnisse erhalten, die Sie von Ihrer Anfrage erwarten,<br />
lesen Sie bitte die GROUP BY-Beschreibung.<br />
• SQL_BUFFER_RESULT erzwingt, dass das Ergebnis in eine temporäre Tabelle<br />
geschrieben wird. Das hilft MySQL, frühzeitig Tabellensperren aufzuheben, und<br />
hilft in Fällen, in denen es lange dauert, das Ergebnis an den Client zu senden.<br />
• SQL_SMALL_RESULT, eine MySQL-spezifische Option, kann bei GROUP BY oder<br />
DISTINCT benutzt werden, um dem Optimierer mitzuteilen, dass der<br />
Ergebnissatz klein sein wird. In diesem Fall benutzt MySQL schnelle temporäre<br />
Tabellen, um die Ergebnistabelle zu speichern, anstatt Sortieren zu benutzen. In<br />
MySQL-Version 3.23 sollte das normalerweise nicht benötigt werden.<br />
• STRAIGHT_JOIN zwingt den Optimierer, Tabellen in der Reihenfolge zu<br />
verknüpfen, in der sie in der FROM-Klausel aufgelistet sind. Sie können das<br />
benutzen, um die Geschwindigkeit einer Anfrage zu erhöhen, wenn der<br />
Optimierer Tabellen in nicht optimaler Reihenfolge verknüpft. See<br />
Abschnitt 6.2.1, „EXPLAIN-Syntax (Informationen über ein SELECT erhalten)“.<br />
• Die LIMIT-Klausel wird benutzt, um die Anzahl von Zeilen, die vom SELECT-<br />
Statement zurückgegeben werden, zu beschränken. LIMIT erwartet ein oder zwei<br />
numerische Argumente.<br />
Wenn zwei Argumente angegeben sind, legt das erste den Offset der ersten Zeile<br />
fest, die zurückgegeben wird, und das zweite gibt die maximale Anzahl von<br />
Zeilen an, die zurückgegeben werden. Der Offset der anfänglichen Zeile ist 0<br />
(nicht 1):<br />
mysql> select * from tabelle LIMIT 5,10; # Zeilen 6 bis 15<br />
zurückgeben<br />
28
Wenn ein Argument angegeben wird, stellt es die maximale Anzahl von Zeilen<br />
dar, die zurückgegeben werden:<br />
mysql> select * from tabelle LIMIT 5; # Die ersten 5 Zeilen<br />
zurückgeben<br />
Mit anderen Worten ist LIMIT n äquivalent zu LIMIT 0,n.<br />
• Die SELECT ... INTO OUTFILE 'datei'-Form von SELECT schreibt die<br />
ausgewählten Zeilen in eine Datei. Die Datei wird auf dem Server-Host erzeugt<br />
und darf nicht bereits bestehen (das verhindert unter anderem, dass<br />
Datenbanktabellen und Dateien wie /etc/passwd zerstört werden). Sie<br />
benötigen die file-Berechtigung auf dem Server-Host, um diese Form von<br />
SELECT auszuführen.<br />
SELECT ... INTO OUTFILE ist hauptsächlich dafür vorgesehen, um eine<br />
Tabelle auf der Server-Maschine schnell zu dumpen. Wenn Sie die resultierende<br />
Datei auf einem anderen Host als dem Server-Host haben wollen, können Sie<br />
SELECT ... INTO OUTFILE nicht benutzen. In diesem Fall sollten Sie statt<br />
dessen ein Client-Programm wie mysqldump --tab oder mysql -e "SELECT<br />
..." > outfile benutzen, um die Datei zu erzeugen.<br />
SELECT ... INTO OUTFILE ist das Komplement von LOAD DATA INFILE; die<br />
Syntax für den export_optionen-Teil des Statements besteht aus denselben<br />
FIELDS- und LINES-Klauseln, die beim LOAD DATA INFILE-Statement benutzt<br />
werden. See Abschnitt 7.4.9, „LOAD DATA INFILE-Syntax“.<br />
In der resultierenden Textdatei werden nur folgende Zeichen durch das ESCAPED<br />
BY-Zeichen escapet:<br />
o Das ESCAPED BY-Zeichen<br />
o Das erste Zeichen in FIELDS TERMINATED BY<br />
o Das erste Zeichen in LINES TERMINATED BY<br />
Zusätzlich wird ASCII 0 in ESCAPED BY, gefolgt von 0 (ASCII 48),<br />
umgewandelt.<br />
Der Grund hierfür ist, dass Sie jegliche FIELDS TERMINATED BY-, ESCAPED BY-<br />
oder LINES TERMINATED BY-Zeichen escapen MÜSSEN, um die Datei<br />
zuverlässig wieder einlesen zu können. ASCII 0 wird escapet, um das Lesen mit<br />
einigen Pagern zu erleichtern.<br />
Weil sich die resultierende Datei nicht nach der SQL-Syntax richten muss, muss<br />
nicht weiter escapet werden.<br />
Im Folgenden ein Beispiel, wie man eine Datei in einem Format erhält, das von<br />
vielen alten Programmen benutzt wird:<br />
SELECT a,b,a+b INTO OUTFILE "/tmp/resultat.text"<br />
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'<br />
LINES TERMINATED BY "\n"<br />
FROM tabelle;<br />
29
5.2.8<br />
• Wenn Sie INTO DUMPFILE anstelle von INTO OUTFILE benutzen, schreibt<br />
MySQL nur eine Zeile in die Datei, ohne jede Spalten- oder Zeilen-Begrenzer<br />
und ohne jedes Escapen. Das ist nützlich, wenn Sie ein Blob in eine Datei<br />
speichern wollen.<br />
• Beachten Sie, dass jede Datei, die von INTO OUTFILE und INTO DUMPFILE<br />
erzeugt wird, für alle Benutzer lesbar ist! Der Grund liegt darin, dass der<br />
MySQL-Server keine Datei erzeugen kann, die jemandem anderen gehört als<br />
dem Benutzer, unter dem er läuft (Sie sollten mysqld nie als Root laufen lassen),<br />
daher muss die Datei für jedermann lesbar sein, damit Sie die Zeilen abrufen<br />
können.<br />
• Wenn Sie FOR UPDATE bei einem Tabellen-Handler mit Seiten-/Zeilen-Sperren<br />
benutzen, werden die untersuchten Zeilen schreib-gesperrt.<br />
mysql_fetch_assoc<br />
(PHP 4 >= 4.0.3, PHP 5)<br />
mysql_fetch_assoc -- Liefert einen Datensatz als assoziatives Array<br />
Beschreibung<br />
array mysql_fetch_assoc ( resource Ergebnis)<br />
Liefert ein assoziatives Array, das den geholten entprechenden Datensatz enthält. Sind<br />
keine weiteren Datensätze vorhanden gibt diese Funktion FALSE zurück.<br />
mysql_fetch_assoc() entspricht in der Funktionsweise exakt dem Aufruf von<br />
mysql_fetch_array() mit Angabe von MYSQL_ASSOC als optionalen zweiten<br />
Parameter. Diese Funktion liefert Ihnen nur ein assoziatives Array. Das war das<br />
ursprüngliche Verhalten von mysql_fetch_array(). Falls Sie sowohl numerische, als<br />
auch assoziative Indizes benötigen, verwenden Sie mysql_fetch_array().<br />
Falls zwei oder mehrere Felder des Ergebnisses den gleichen Feldnamen haben, dann<br />
wird nur der Wert des letzten Felds im Array unter diesem Feldnamen abgelegt. Um<br />
auch auf die anderen, gleichnamigen, Felder zugreifen zu können, müssen Sie entweder<br />
numerische Indizes und damit mysql_fetch_row() benutzen, oder Aliase für Ihre Felder<br />
anlegen. Zur Verwendung von Aliasen schauen Sie sich das Beispiel unter der<br />
Beschreibung von mysql_fetch_array() an.<br />
Zu betonen ist, dass der Gebrauch von mysql_fetch_assoc() nicht signifikant langsamer<br />
ist als mysql_fetch_row(), obwohl die Funktion einen sichtlichen Mehrwert bietet.<br />
Anmerkung: Feldnamen, die von dieser Funktion zurückgegeben werden,<br />
unterscheiden sich in der Groß-/Kleinschreibung.<br />
Anmerkung: Diese Funktion setzt NULL Felder auf den PHP Wert NULL.<br />
30
Beispiel 1. Ein ausführliches Beispiel zumysql_fetch_assoc()<br />
<br />
Siehe auch mysql_fetch_row(), mysql_fetch_array(), mysql_query() und<br />
mysql_error()<br />
31
5.2.9<br />
mysql_fetch_assoc<br />
(PHP 4 >= 4.0.3, PHP 5)<br />
mysql_fetch_assoc -- Liefert einen Datensatz als assoziatives Array<br />
Beschreibung<br />
array mysql_fetch_assoc ( resource Ergebnis )<br />
Liefert ein assoziatives Array, das den geholten entprechenden Datensatz enthält. Sind<br />
keine weiteren Datensätze vorhanden gibt diese Funktion FALSE zurück.<br />
mysql_fetch_assoc() entspricht in der Funktionsweise exakt dem Aufruf von<br />
mysql_fetch_array() mit Angabe von MYSQL_ASSOC als optionalen zweiten<br />
Parameter. Diese Funktion liefert Ihnen nur ein assoziatives Array. Das war das<br />
ursprüngliche Verhalten von mysql_fetch_array(). Falls Sie sowohl numerische, als<br />
auch assoziative Indizes benötigen, verwenden Sie mysql_fetch_array().<br />
Falls zwei oder mehrere Felder des Ergebnisses den gleichen Feldnamen haben, dann<br />
wird nur der Wert des letzten Felds im Array unter diesem Feldnamen abgelegt. Um<br />
auch auf die anderen, gleichnamigen, Felder zugreifen zu können, müssen Sie entweder<br />
numerische Indizes und damit mysql_fetch_row() benutzen, oder Aliase für Ihre Felder<br />
anlegen. Zur Verwendung von Aliasen schauen Sie sich das Beispiel unter der<br />
Beschreibung von mysql_fetch_array() an.<br />
Zu betonen ist, dass der Gebrauch von mysql_fetch_assoc() nicht signifikant langsamer<br />
ist als mysql_fetch_row(), obwohl die Funktion einen sichtlichen Mehrwert bietet.<br />
Anmerkung: Feldnamen, die von dieser Funktion zurückgegeben werden,<br />
unterscheiden sich in der Groß-/Kleinschreibung.<br />
Anmerkung: Diese Funktion setzt NULL Felder auf den PHP Wert NULL.<br />
Beispiel 1. Ein ausführliches Beispiel zumysql_fetch_assoc()<br />
FROM sometable<br />
WHERE userstatus = 1";<br />
$result = mysql_query($sql);<br />
if (!$result) {<br />
echo "Anfrage ($sql) konnte nicht ausgeführt werden : " .<br />
mysql_error();<br />
exit;<br />
}<br />
if (mysql_num_rows($result) == 0) {<br />
echo "Keine Zeilen gefunden, nichts auszugeben, daher Abbruch";<br />
exit;<br />
}<br />
// Solange eine Zeile mit Daten existiert, wird dies in dem<br />
assoziativen Array<br />
// $row abgelegt.<br />
// Anmerkung: Wenn Sie nur eine Zeile erwarten, brauchen Sie keine<br />
Schleife.<br />
// Anmerkung: Wenn Sie extract($row) innerhalb der folgenden Schleife<br />
// verwenden, können Sie damit die Variablen<br />
// $userid, $fullname und $userstatus erzeugen.<br />
while ($row = mysql_fetch_assoc($result)) {<br />
echo $row["userid"];<br />
echo $row["fullname"];<br />
echo $row["userstatus"];<br />
}<br />
mysql_free_result($result);<br />
?><br />
Siehe auch mysql_fetch_row(), mysql_fetch_array(), mysql_query() und<br />
mysql_error()<br />
5.2.10<br />
date<br />
(PHP 3, PHP 4 , PHP 5)<br />
date -- Formatiert ein(e) angegebene(s) Zeit/Datum<br />
Beschreibung:<br />
string date ( string Format [, int Timestamp] )<br />
Gibt einen formatierten String anhand eines vorzugebenden Musters zurück. Dabei wird<br />
entweder der angegebene Timestamp oder die gegenwärtige lokale Zeit berücksichtigt,<br />
wenn kein Timestamp angegegeben wird. Mit anderen Worten ausgedrückt: der<br />
33
Parameter Timestamp ist optional und falls dieser nicht angegeben wird, wird der Wert<br />
der Funktion time() angenommen.<br />
Anmerkung: Der gültige Bereich eines Timestamp liegt typischerweise zwischen Fri,<br />
13 Dec 1901 20:45:54 GMT und Tue, 19 <strong>Jan</strong> 2038 03:14:07 GMT. (Das entspricht den<br />
minimalen und maximalen Werten für einen vorzeichenbehafteten 32-Bit Integer).<br />
Unter Windows-Betriebssytemen ist dieser Bereich auf 01-01-1970 bis 19-01-2038<br />
beschränkt.<br />
Anmerkung: Um einen Timestamp aus aus einem Datums-String zu erzeugen, können<br />
Sie die Funktion strtotime() benutzen. Zusätzlich bieten einige Datenbanken<br />
Funktionen, um Ihre Datumsfromate in Timestamps umzuwandeln (wie zum Beispiel<br />
MySQL's UNIX_TIMESTAMP Funktion.<br />
Tabelle 1. Die folgenden Zeichen werden im Parameter Formaterkannt<br />
Format<br />
Zeichen<br />
a<br />
A<br />
Beschreibung<br />
Kleingeschrieben: Ante meridiem und Post<br />
meridiem<br />
Großgeschrieben: Ante meridiem und Post<br />
meridiem<br />
34<br />
Beispiel für<br />
Rückgabewerte<br />
am oder pm<br />
AM oder PM<br />
B Swatch-Internet-Zeit 000 bis 999<br />
c ISO 8601 Datum (hinzugefügt in PHP 5)<br />
2004-02-<br />
12T15:19:21+00:00<br />
d Tag des Monats, 2-stellig mit führender Null 01 bis 31<br />
D Tag der Woche als mit drei Buchstaben Mon bis Sun<br />
F Monat als ganzes Wort, wie <strong>Jan</strong>uary oder March <strong>Jan</strong>uary bis December<br />
g 12-Stunden-Format, ohne führende Nullen 1 bis 12<br />
G 24-Stunden-Format, ohne führende Nullen 0 bis 23<br />
h 12-Stunden-Format, mit führenden Nullen 01 bis 12<br />
H 24-Stunden-Format, mit führenden Nullen 00 bis 23<br />
i Minuten mit führenden Nullen 00 bis 59<br />
I (großes<br />
i)<br />
Fällt ein Datum in die Sommerzeit<br />
j Tag des Monats ohne führende Nullen 1 bis 31<br />
l (kleines<br />
'L')<br />
1 bei Sommerzeit,<br />
ansonsten 0.<br />
Ausgeschriebener Tag der Woche Sunday bis Saturday<br />
L Schaltjahr oder nicht<br />
m Monat als Zahl, mit führenden Nullen 01 bis 12<br />
1 für ein Schaltjahr,<br />
ansonsten 0.<br />
M Monatsname mit drei Buchstaben <strong>Jan</strong> bis Dec<br />
n Monatszahl, ohne führende Nullen 1 bis 12<br />
O Zeitunterschied zur Greenwich time (GMT) in Beispiel: +0200
Format<br />
Zeichen<br />
Stunden<br />
Beschreibung<br />
r RFC 2822 formatiertes Datum<br />
s Sekunden, mit führenden Nullen 00 bis 59<br />
S<br />
Anhang der englischen Aufzählung für einen<br />
Monatstag, zwei Zeichen<br />
t Anzahl der Tage des angegebenen Monats 28 bis 31<br />
35<br />
Beispiel für<br />
Rückgabewerte<br />
Beispiel: Thu, 21 Dec 2000<br />
16:01:07 +0200<br />
st, nd, rd oder th. Zur<br />
Verwendung mit j<br />
empfohlen.<br />
T Zeitzoneneinstellung des Rechners Beispiele: EST, MDT ...<br />
U<br />
Sekunden seit Beginn der UNIX-Epoche<br />
(<strong>Jan</strong>uary 1 1970 00:00:00 GMT)<br />
w Numerischer Tag einer Woche<br />
W<br />
ISO-8601 Wochennummer des Jahres, die<br />
Woche beginnt am Montag (hinzugefügt in PHP<br />
4.1.0)<br />
Siehe auch time()<br />
0 (für Sonntag) bis 6 (für<br />
Samstag)<br />
Beispiel: 42 (die 42 Woche<br />
im Jahr)<br />
Y Vierstellige Jahreszahl Beispiel: 1999 oder 2003<br />
y Jahreszahl, zweistellig Beispiele: 99 oder 03<br />
z Der Tag eines Jahres 0 bis 365<br />
Z<br />
Offset der Zeitzone in Sekunden. Der Offset für<br />
Zeitzone West nach UTC ist immer negativ und<br />
für Zeitzone Ost nach UTC immer positiv.<br />
-43200 bis 43200<br />
Nicht erkannte Zeichen werden unverändert ausgegeben. Das Z Format gibt beim<br />
Gebrauch von gmdate() immer 0 zurück.<br />
Beispiel 1. date() Beispiel<br />
<br />
Möchten Sie verhindern, dass ein erkanntes Zeichen im Formatstring ersetzt wird,<br />
sollten Sie dieses Zeichen mit einem vorangestellten Backslash escapen. Ist das Zeichen<br />
mit dem Backslash bereits eine spezielle Zeichenfolge, müssen Sie diesen Backslash<br />
ebenso escapen.
Beispiel 2. Escaping von Zeichen in date()<br />
// gibt etwas ähnliches aus wie 'Wednesday the 15th'<br />
echo date("l \\t\h\e jS");<br />
Es ist möglich, date() und mktime() gleichzeitig zu verwenden, um Datumsangaben in<br />
der Zukunft/Vergangenheit zu bestimmen.<br />
Beispiel 3. date() und mktime() Beispiele<br />
<br />
Anmerkung: Dieses Vorgehen kann zu verlässlicheren Ergebnissen führen, als simples<br />
addieren oder subtrahieren der Anzahl von Sekunden in Tagen oder Monaten zu einem<br />
Timestamp, da Sommer- und Winterzeit berücksichtigt werden.<br />
Es folgen einige Beispiele zur date() Formatierung. Beachten Sie, dass Sie alle anderen<br />
Zeichen escapen sollten, da alle Zeichen, die im Augenblick eine spezielle Bedeutung<br />
haben, unerwünschte Resultate liefern. Bei allen weiteren Zeichen kann es durchaus<br />
möglich sein, dass diesen in zukünftigen PHP-Versionen eine Bedeutung zukommt.<br />
Beim escapen sollten Sie darauf achten einfache Anführungszeichen zu benutzen, damit<br />
Zeichenfolgen wie zum Beispiel \n zu keinem Zeilenumbruch führen.<br />
Beispiel 4. date() Formatierungen<br />
<br />
Um Datumsangaben in anderen Sprach-/Zeitzonen-Formaten auszugeben, sollten Sie<br />
die Funktionen setlocale() und strftime() benutzen.<br />
Siehe auch getlastmod(), gmdate(), mktime(), strftime() und time().<br />
36
5.2.11<br />
echo<br />
(PHP 3, PHP 4, PHP 5 )<br />
echo -- Gibt einen oder mehrere Strings aus<br />
Beschreibung<br />
echo ( string arg1 [, string argn...] )<br />
Gibt alle als Parameter angegebenen Strings aus.<br />
echo() ist keine Funktion, sondern ein Sprach-Konstrukt. Deshalb brauchen Sie keine<br />
Klammern zu verwenden. Wenn Sie echo mehr als einen Parameter übergeben wollen,<br />
dürfen Sie diese nicht mit Klammern umgeben. Es ist nicht möglich, echo() in einem<br />
Variablen-Funktionen Kontext zu nutzen.<br />
Beispiel 1. echo() examples<br />
mit nur einem Strichpunkt ohne extra Leerzeichen befinden muss!<br />
END;<br />
// echo ist keine Funktion, weshalb der folgende Code ungültig ist.<br />
($some_var) ? echo('true'): echo('false');<br />
// Aber folgende Beispiele funktionieren:<br />
($some_var) ? print('true'): print('false'); // print ist eine<br />
Funktion<br />
echo $some_var ? 'true': 'false'; // Das Statement herumgedreht<br />
?><br />
echo() kann auch in einer Kurzform verwendet werden, indem Sie unmittelbar nach<br />
dem öffnenden Tag ein Gleichheitszeichen setzen.<br />
I have foo.<br />
Anmerkung: Diese Kurzform funktioniert nur, wenn die Konfigurationsoption<br />
short_open_tag aktiviert ist.<br />
Siehe auch print(), printf() und flush().<br />
38