Diplomarbeit Interaktiver Dialog der Skriptsprache PHP zu MySQL und Oracle 9i Datenbanken Diplomand: Rückerl Roman Matrikel-Nr.: 2040842 Semestergruppe: I8IW.W Anschrift: Vilsstrasse 9 93059 Regensburg Email: [email protected]Aufgabensteller/Betreuer: Hr. Prof. Sauer Zweitprüfer: Hr. Prof. Dr. Kopp
118
Embed
Diplomarbeit Interaktiver Dialog der Skriptsprache PHP zu ...fbim.fh-regensburg.de/~saj39122/meile/rueckerl/daten/diplomarbeit.pdf · Diplomarbeit Interaktiver Dialog der Skriptsprache
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Diplomarbeit
Interaktiver Dialog der Skriptsprache PHP zu MySQL
Werden mehr Bedingungen in einer Struktur vereint, muss elseif verwendet werden.
Dieser Befehl steht immer im Zusammenhang mit einer Bedingung.
<?php $a = 10;
31
$b = 20; if ($a > $b) { echo ("\$a ist größer als \$b."); } elseif ($a == $b) { echo("\$a ist genauso groß wie \$b."); } else { echo ("\$a ist kleiner als \$b."); } $>
Ausgabe:
$a ist kleiner als $b.
Die elseif-Anweisung kann mehrmals hintereinander angewendet werden.
2.3.3 Entscheidungen mit switch
Muss eine Variable mehrfach getestet werden, dann bietet sich in PHP der switch-Befehl
an. Mit break kann die Entscheidung abgebrochen werden.
<?php $zahl = 4 switch ($zahl) { case 1: echo ("Der Wert der Zahl ist: " . $zahl); break; case 2: echo ("Der Wert der Zahl ist: " . $zahl); break; case 3: echo ("Der Wert der Zahl ist: " . $zahl); break; case 4: echo ("Der Wert der Zahl ist: " . $zahl); break; } ?>
Ausgabe:
Der Wert der Zahl ist: 4
32
2.3.4 Schleifen mit while
Mit Hilfe von while wird ein Anweisungsblock definiert, der in Abhängigkeit von einer
Bedingung mehrfach abgearbeitet wird.
<?php $a = 10; $b = 0; while ($b < $a) { echo ("$a. Die Schleife wird 10x durchlaufen. <BR>"); } ?>
Solange der Wert der Variablen $b kleiner als 10 ist, wird der Anweisungsblock ausgeführt.
Erst wenn der logische Ausdruck die Bedingung FALSE ergibt, wird die Schleife nicht weiter
ausgeführt.
2.3.5 Die do-while-Schleife
Im Gegensatz zur while-Schleife wird hier die Austrittsbedingung erst am Ende des
Anweisungsblocks untersucht. D.h., dass die Anweisungen mindestens einmal abgearbeitet
werden.
<?php $austritt = 0; $zaehler = 0; do { echo ("$zaehler. Die Schleife wird 1x durchlaufen.<BR>"); $zaehler ++; } while ($zaehler < austritt) ?>
33
2.3.6 Die for-Schleife
Die for-Schleife wird auch als Zählschleife bezeichnet. Im normalen Verwendungsfall durch
eine Zählvariable, die die Bedingung und die Veränderung des Zählers zur Laufzeit ermittelt.
<?php for ($i = 1; $i <= 5; $i++) { echo ("Die Schleife wird zum $i. Mal durchlaufen.<BR>"); } ?>
Diese Schleife wird fünfmal durchlaufen. Der Zählvariable $i wurde der Startwert 1
zugewiesen. Sie wird durch die Bedingung überprüft. Solange die Bedingung zutrifft, wird die
Zählervariable in dem Beispiel erhöht und der Anweisungsblock ausgeführt.
2.3.7 Die foreach-Schleife
Die foreach-Schleife ist die Schleife für Arrays. Der Umgang mit Arrays erfährt durch die
Anwendung dieses Schleifentyps eine deutliche Erleichterung. Foreach arbeitet jedes
Element des Arrays nacheinander ab. Der Befehl ermittelt dabei die Anzahl der Elemente und
setzt den internen Zeiger in jedem Schleifendurchlauf um ein Element weiter. Es stehen zwei
Möglichkeiten zur Verfügung, um die Schleife aufzurufen.
In PHP wird eine Klasse mit folgender Syntax definiert:
<?php class Name extends Elternname { ... } ?>
Nach dem Namen der Klasse folgt hinter dem Schlüsselwort extends der Name der
übergeordneten Klasse. Eine Klasse muss nicht von einer übergeordneten Klasse abgeleitet
werden.
<?php class Name { ... } ?>
2.5.2 Eigenschaften und Methoden
Eigenschaften einer Klasse werden in Variablen gespeichert, die im Block der Klasse angelegt
wurden.
<?php class Name { var $fname; } ?>
41
Eine Methode wird wie eine normale Funktion definiert, nur innerhalb der Klassenstruktur.
Methoden greifen auf die Eigenschaften der Klasse zu, indem Sie den reservierten Zeiger
$this verwenden.
<?php class Name { var $fname; function xyz ($wert) { $this->fname = $wert; } function Ausgabe () { return $this->fname; } } ?>
Eine spezielle Methode der Klasse heißt Konstruktor. Er wird beim Initialisieren einer Klasse
automatisch aufgerufen und besitzt den gleichen Namen wie die Klasse.
<?php class Name { var $fname; function Name ($Anfangswert) { $this->fname = $Anfangswert; } function WertFestlegen ($wert) { $this->fname = $wert; } function Ausgabe () { return $this->fname; } } ?>
42
2.5.3 Verwenden einer Klasse
Wurde eine Klasse einmal definiert, muss das Schlüsselwort new verwendet werden um
mehrere Instanzen der Klasse zu erzeugen.
<?php include ("myclass.php"); $object1 = new Name ("Roland"); $object2 = new Name ("Katrin"); echo($object1->Ausgabe()); echo("<br>"); $object1->WertFestlegen("Dominique"); echo($object1->Ausgabe()); echo("<br>"); echo($object2->Ausgabe()); echo("<br>"); ?>
Ausgabe:
Roland
Dominique
Katrin
2.5.4 Vererbung
Nun wird eine neue Klasse Adresse angelegt, um Vor- und Zunamen zu speichern. Sie erbt
die Eigenschaften und Methoden der Klasse Name.
<?php include("myclass.php"); class Adresse extends Name { var $vname;
//Konstruktor der Klasse Adresse function Adresse ($vor, $zu)
RunServices eine Zeichenkette mit dem Namen mysqld-max und dem Pfad der Datei
MySQLD-Max.exe ein. In der Beispielinstallation war das
C:\Web\MySQL\Bin\MySQLD-Max.exe.
Testen von MySQL
Nach dem nächsten Neustart können Sie testen, ob der Eintrag zu dem gewünschten Erfolg
geführt hat. Wechseln Sie dazu in der Eingabeaufforderung in das MySQL-Verzeichnis, dann
in das Unterverzeichnis bin und geben den Befehl mysqladmin ping ein. Z.B.
c:\Web\mysql\bin\mysqladmin ping.
3.1.2 MySQL-Monitor
Um eine MySQL-Datenbank abzufragen, zu aktulaisieren oder zu erstellen, benutzen Sie das
Kommandozeilen-Programm mysql.exe unter Windows. Korrekt heißt dieses Programm
MySQL-Monitor.
(Abb.8: MySQL-Monitor)
Starten Sie MySQL-Monitor ohne weitere Parameter, versucht es zur lokalen MySQL-
Datenbank (localhost) ohne spezifizierten Benutzer und ohne Passwort zu verbinden.
Das funktioniert nur, wenn der Zugriff ohne Passwort erlaubt ist, was aber nach der
Installation ohne weiteres Eingreifen der Fall ist.
46
Mit Hilfe des MySQL-Monitors ist es möglich, eine Verbindung zu jeder beliebigen MySQL-
Datenbank auf der Welt aufzubauen. Sie benötigen lediglich die entsprechenden Rechte und
Kennwörter.
(Abb.9: Information zu MySQL-Monitor)
In die Eingabezeile des MySQL-Monmitors geben Sie verschiedene Steuerkommandos ein,
die mit „\“ beginnen, oder beliebige 4SQL-Kommandos, die MySQL unterstützt.
MySQL-Kommando Funktion
show database; Gibt alle erzeugten Datenbanken zurück. Es sollte mindestens die
Datenbank mysql angezeigt werden.
use test; Verwendet die Datenbank mit dem Namen test. Alle weiteren
SQL-Kommandos beziehen sich dann auf diese Datenbank.
show tables; Zeigt alle erzeugten Tabellen der aktuell gewählten Datenbank an.
quit oder exit Beendet MySQL-Monitor.
Das Kommandozeilen-Programm unterstützt zahlreiche Parameter, die Sie erhalten, wenn Sie
mysql –-help eintippen.
47
3.1.3 phpMyAdmin
Bei Webspace-Angeboten mit MySQL richten die Hosts die Datenbank fast immer so ein,
dass ein Zugriff nur von einer oder wenigen IP-Adressen möglich ist. Zu diesen Adressen
gehört normalerweise immer die des Webservers, aber nur selten der heimische PC. Es bleibt
daher nur die Möglichkeit, ein Programm auf dem Webserver zu installieren, das Vermittler
ist und gleichzeitig die Oberfläche zur Datenbank herstellt.
Um eine Datenbank sowie deren Tabellen komfortabel und einfach zu verwalten, gibt es von
PHP ein Programm, nämlich phpMyAdmin. PhpMyAdmin ist ein Set an PHP-Skripts, die
eine Menü- und Formulargesteuerte Verwaltung einer MySQL-Datenbank über das Internet
ermöglichen.
Damit phpMyAdmin richtig funktioniert, ist es erforderlich, dass der Webserver Dateien mit
der Erweiterung .PHP3 an die PHP-Engine weiterleitet, falls Sie keine spezielle Version von
PhpMyAdmin für PHP4 besitzen.
Sie können PHPMyAdmin im Internet unter der Adresse http://phpmyadmin.sourceforge.net/
herunterladen.
Installieren Sie phpMyAdmin in das Dokumenten-Verzeichnis des Webservers, so dass das
Verzeichnis phpmyadmin entsteht. Z.B. c:\Web\apache\htdocs\phpmyadmin.
Öffnen Sie die Datei confic.inc.php3 im Verzeichnis phpmyadmin mit einem
Texteditor, zum Beispiel WordPad. Stellen Sie wie in der unteren Abbildung die korrekten
Werte ein.
// The $cfgServers array starts with $cfgServers[1]. Do not use $cfgServers[0]. // You can disable a server config entry by setting host to ''. $cfgServers[1]['host'] = 'localhost'; // MySQL hostname $cfgServers[1]['port'] = ''; // MySQL port - leave blank for default port $cfgServers[1]['adv_auth'] = false; // Use advanced authentication? $cfgServers[1]['stduser'] = ''; // MySQL standard user (only needed with advanced auth) $cfgServers[1]['stdpass'] = ''; // MySQL standard password (only needed with advanced auth)
48
$cfgServers[1]['user'] = 'root'; // MySQL user (only needed with basic auth) $cfgServers[1]['password'] = ''; // MySQL password (only needed with basic auth) $cfgServers[1]['only_db'] = 'Verwaltung'; // If set to a db-name, only this db is accessible $cfgServers[1]['verbose'] = ''; // Verbose name for this host - leave blank to show the hostname $cfgServers[1]['bookmarkdb'] = ''; // Bookmark db - leave blank for no bookmark support $cfgServers[1]['bookmarktable'] = ''; // Bookmark table - leave blank for no bookmark support
Sie starten phpMyAdmin durch die Eingabe von http://localhost/phpMyAdmin/index.php3.
(Abb.10: PhpMyAdmin)
Nach dem Start von phpMyAdmin erscheint das Begrüssungsfenster. PhpMyAdmin besteht
aus einem Frameset. Im linken Frame wechseln Sie die aktuelle Datenbank und Tabelle, im
rechten werden Abfragen ausgeführt.
49
Um alle Tabellen einer Datenbank zu sehen, klicken Sie im linken Rahmen auf den Namen
der Datenbank. Das entspricht dem MySQL-Befehl SHOW TABLES. Natürlich benötigen Sie
die entsprechenden Zugriffsrechte.
Datenbankbezogene Aktionen, wie beispielsweise das „Anlegen von Tabellen“ oder
„Abfragen von Tabellen“ werden im linken Rahmen ausgeführt, indem Sie auf die Tabelle
klicken, auf der sich die Aktion bezieht.
Grundsätzlich kann man mit MySQL-Monitor und PhpMyAdmin die gleichen Funktionen
ausführen. Gegebenenfalls unterscheidet sich die Vorgehensweise. Die Seite mit den
Tabellenübersichten einer Datenbank enthält ein SQL-Fenster, in das Sie beliebige SQL-
Befehle eintippen können. Damit sind Sie nicht an die manchmal gewöhnungsbedürftige
Menüführung von PhpMyAdmin gebunden.
50
3.1.4 PHP und Datenbanken
3.1.4.1 Verbindung zum Datenbankserver
Um PHP mit einer MySQL-Datenbank zu verbinden, braucht man zuerst eine Verbindung
zum Datenbankserver. Diese Verbindung ist Vorraussetzung, um eine bestimmte Datenbank
auf dem Datenbankserver auszuwählen.
Es stehen zwei Funktionen für diesen Zweck zur Verfügung: mysql_connect() und
mysql_pconnect(). Der Unterschied zwischen diesen beiden Funktionen besteht darin,
dass die Verbindung, die mysql_pconnect() erstellt, auch nach Ende des Programms
bestehen bleibt und bei einem erneuten Aufruf von mysql_pconnect() wieder genutzt
werden kann. Verbindungen, die mysql_connect() erstellt, verlieren nach Ablauf ihre
Gültigkeit.
Syntax:
int mysql_connect(string host, string benutzer, string
passwort);
Der Funktion werden drei Parameter übergeben, die den Namen des Datenbankservers, den
anzumeldenden Benutzer und dessen Passwort bestimmen. Der Rückgabewert ist ein
sogenannter Link-Identifizierer, der für andere MySQL-Funktionen benötigt wird. Die Syntax
von mysql_pconnect() ist gleich. Der Rückgabewert ist FALSE, wenn keine
Verbindung zum Datenbankserver hergestellt werden konnte.
Die Paramteter sind optional, Standardwerte sind host = localhost, benutzer = Benutzer und
Passwort = keins.
51
Auswählen der Datenbank
Auf der Grundlage einer bestehenden Verbindung kann das PHP-Programm eine Datenbank
auf dem Datenbankserver auswählen. PHP bietet für diesen Zweck die Funktion
mysql_select_db().
Syntax:
int mysql_select_db(string db_name [, int linkID]);
Als Parameter werden der Name der Datenbank und der Rückgabewert der Funktion
mysql_connect() übergeben. Diese Funktion liefert FALSE zurück, wenn die Datenbank
nicht ausgewählt werden kann. Der Parameter linkID kann entfallen, PHP nutzt in diesem
Fall den zuletzt erzeugten Link. Das gilt ebenso für alle anderen Funktionen, die linkID als
optionalen Parameter enthalten.
<?php $linkID = mysql_connect("localhost", "root", ""); if (!$linkID) die("Es wurde keine Verbindung zum Datenbankserver hergestellt."); if (mysql_select_db("Personalwesen", $linkID))
echo("Die Datenbank Personalwesen wurde ausgewählt."); else
die ("Fehler beim auswählen der Personalwesen!"); ?>
3.1.4.2 Befehle an die Datenbank schicken
Wurde eine Verbindung zum Datenbankserver hergestellt und eine Datenbank auf diesem
Server ausgewählt, können SQL-Befehle an die Datenbank geschickt werden.
Für die Verwendung der Befehle INSERT, SELECT, UPDATE oder eines sonstigen SQL-
Befehles wird in PHP nur eine einzige Funktion verwendet.
Syntax:
int mysql_query(string sql [, int linkID]);
52
Der Funktion mysql_query() werden eine SQL-Zeichenfolge und die linkID der
Verbindung übergeben. Die SQL-Zeichenfolge soll aber kein abschließendes Semikolon
enthalten.
Der Rückgabewert ist eine ID, die Sie zum Abfragen der Ergebnismenge benutzen können. Ist
die SQL-Abfrage fehlerhaft oder haben Sie keinen entsprechenden Zugriff auf die
entsprechenden Tabellen, dann gibt diese Funktion den Wert FALSE zurück.
Senden des SQL-Befehls SELECT name, adresse FROM Kunden:
<?php $linkID = mysql_connect("localhost", "root", ""); if (!$linkID) die("Es wurde keine Verbindung zum Datenbankserver hergestellt."); if (mysql_select_db("Personalwesen ", $linkID))
echo("Die Datenbank Personalwesen wurde ausgewählt."); else
die ("Fehler beim auswählen der Personalwesen!"); // SELECT-Befehl $abfrage = "SELECT * FROM job"; $resID = mysql_query($abfrage, $linkID); if (!resID) die ("Es ist ein Fehler in der SQL-Anweisung azufgetreten.");
?>
3.1.4.3 Datensätze der Abfrage ermitteln
Nachdem eine Abfrage an den Datenbankserver mit mysql_query() gesendet wurde, wird eine
andere Funktion zum Erhalten der Daten vom Datenbankserver benötigt.
Diese Funktion darf jedoch nur benutzt werden, wenn die gesendete Abfrage auch eine
Ergebnismenge zurückliefert. Zum Abfragen der Daten eignet sich die Funktion
mysql_fetch_array().
Syntax:
Array mysql_fetch_array(int resID [, int ErgTyp]);
53
Mysql_fetch_array() wird mit dem Rückgabewert der Funktion mysql_query()
als erster Parameter aufgerufen. Der zweite optionale Parameter bestimmt, ob das Array ein
indiziertes Array (MYSQL_NUM), ein assoziatives Array (MYSQL_ASSOC) oder beides
(MYSQL_BOTH) ist.
Der Rückgabewert der Funktion ist ein Array, das die Zelleninhalte eines Datensatzes enthält.
Um mehrere Datensätze abzurufen, müssen die Funktionen erneut aufgerufen werden. Der
Rückgabewert der Funktion ist FALSE, wenn kein weiterer Datensatz verfügbar ist.
Bildschirmausgabe der Datensätze von SELECT name, adresse FROM Kunden.
<?php $linkID = mysql_connect("localhost", "root", ""); if (!$linkID) die("Es wurde keine Verbindung zum Datenbankserver hergestellt."); if (mysql_select_db("Personalwesen ", $linkID))
echo("Die Datenbank Personalwesen wurde ausgewählt."); else
die ("Fehler beim auswählen der Personalwesen!"); // SELECT-Befehl $abfrage = "SELECT * FROM job"; $resID = mysql_query($abfrage, $linkID); if (!resID) die ("Es ist ein Fehler in der SQL-Anweisung aufgetreten."); // Ausgabe der Datensätze while ($zeile = mysql_fetch_array ($resID, MYSQL_BOTH)) {
Auf das erste Feld der Ergebnistabelle (Name) wird mit Hilfe des Index zugegriffen, auf das
zweite Feld (Adresse) assoziativ.
3.1.4.4 PHP-Funktionen für MySQL
In diesem Kapitel werden einige wichtige PHP-Funktionen für MySQL-Datenbanken
erläutert.
54
mysql_affected_rows
int mysql_affected_rows ([int resID])
Gibt eine Anzahl der Datensätze zurück, die nach einem UPDATE-, INSERT- oder DELETE-
Befehl betroffen waren. Der Parameter bestimmt die Ergebnis-ID von mysql_query().
mysql_close
int mysql_close ([int linkID])
Schließt eine mit mysql_connect() geöffnete Verbindung. Wird die linkID
weggelassen, wird die letzte geöffnete Verbindung geschlossen.
Eine Verbindung eines PHP-Skripts wird jedoch automatisch geschlossen, wenn das Skript
beendet ist.
mysql_create_db
int mysql_create_db(string dbName, [, int linkID])
Erstellen einer Datenbank mit den Namen dbName.
mysql_data_seek
int mysql_data_seek (int resID, int znummer)
Bewegt den Datensatzzeiger der Abfrage in resID nach zNummer.
mysql_db_query
55
int mysql_db_query(string database, string abfrage [, int
linkID])
Sendet einen SQL-Befehl, ermöglicht aber im Gegensatz zu mysql_query() zusätzlich die
Angabe eines Datenbankservers.
mysql_drop_db
bool mysql_drop_db(string dbname [, int linkID])
Löscht die Datenbank dbName in der Verbindung von linkID.
mysql_errno
int mysql_errno([int linkID])
Gibt eine Fehlernummer der letzten MySQL-Operation der Verbindung linkID zurück. Der
Rückgabewert ist 0, wenn kein Fehler auftrat.
mysql_error
string mysql_error([int linkID])
Gibt eine Fehlermeldung der MySQL-Operation zurück.
mysql_escape_string
string mysql_escape_string(string sql)
Maskiert Sonderzeichen in einem SQL-Befehl.
56
mysql_fetch_assoc
Wie mysql_fetch_array, der Ergebnistyp ist aber ausschließlich ein assoziatives Array.
mysql_fetch_field
Object mysql_fetch_field(int resID [, int feldNr])
Mit mysql_fetch_field() kann man sich anhand der resID ein Objekt mit
Feldinformationen aus einem Abfrage zurückgeben lassen. Gibt man den optionalen
Parameter Feld-Offset nicht an, so werden die Informationen des nächsten Feldes geliefert,
das noch nicht mit mysql_fetch_field() ausgegeben wurde.
Eigenschaft Beschreibung
Object->table Name der Tabelle, aus der das Feld stammt
Object->max_lenght Maximale Spaltenbreite
Object->not_null Enthält 1, wenn die Spalte keine NULL-Werte annehmen kann
Object->primary_key Enthält 1, wenn die Spalte Primärschlüssel ist
Object->unique_key Enthält 1, wenn die Spalte ein eindeutiger Schlüssel ist
Eigenschaft Beschreibung
Object->multiple_key Enthält 1, wenn die Spalte ein "gewöhnlicher" Schlüssel ist
Object->numeric Enthält 1, wenn die Spalte numerisch ist
Object->blob Enthält 1, wenn die Spalte ein BLOB ist
Object->type Datentyp der Spalte
Object->unsigned Enthält 1, wenn die Spalte keine negative Zahlen speichern kann
Object->zerofill Enthält 1, wen die Spalte den Zusatz ZEROFILL hat
mysql_fetch_object
Wie mysql_fetch_array, aber der Rückgabewert besitzt eine Objektstruktur.
57
mysql_fetch_row
Wie mysql_fetch_array, aber der Rückgabewert ist ausschließlich ein indiziertes Array.
mysql_insert_id
int mysql_insert_id([int linkID])
Gibt den letzten eingefügten Autowert der Verbindung linkID zurück. Der Funktionsaufruf
muss unmittelbar nach dem INSERT-Befehl erfolgen. Er funktioniert nicht, wenn die
Autowert-Spalte den Datentyp BIGINT hat.
mysql_num_fields
int mysql_num_fields(int resID)
Gibt die Anzahl der Spalten der Abfrage resID zurück.
mysql_num_rows
int mysql_num_rows(int resID)
Gibt die Anzahl der Datensätze der Abfrage resID zurück, die eine SELECT-Abfrage war.
Setzt man vor eine der oben angegebenen Funktionen ein „@“, dann wird die Fehlerausgabe
der Funktion unterdrückt.
Beispiel:
<?php $linkID = mysql_connect("localhost", "root", ""); if (!$linkID) die("Es wurde keine Verbindung zum Datenbankserver hergestellt."); if (mysql_select_db("Personalwesen ", $linkID))
echo("Die Datenbank Personalwesen wurde ausgewählt."); else
die ("Fehler beim auswählen der Personalwesen!");
58
// SELECT-Befehl $abfrage = "SELECT * FROM job"; // verursacht mysql_query einen Fehler, dann wird die Ausgabe unterdrückt $resID = @mysql_query($abfrage, $linkID); if (!resID) die ("Es ist ein Fehler in der SQL-Anweisung azufgetreten.");
?>
3.1.4.5 Ein allgemeines Beispiel für PHP in Verbindung mit
MySQL-Datenbanken
In diesem Kapitel möchte ich ein kleines PHP-Skript vorstellen, mit dem Sie Daten aus einer
Tabelle ausgeben können. Das Skript greift auf die Datenbank „Personalwesen“ und die
Tabelle „Job“ zu und gibt den Inhalt der Tabelle in einer HTML-Tabelle aus.
<HTML><HEAD><TITLE></TITLE></HEAD> <BODY BGCOLOR="#FFFFF"> <?php // Verbidnung zu MySQL herstellen $linkID = mysql_connect("","",""); if (!$linkID) die("Es konnte keine Verbindung zu MySQL hergestellt werden."); // Datenbank "Personalwesen" auswählen if (mysql_select_db("Personalwesen", $linkID)) echo("Die Datenbank Personalwesen wurde ausgewählt."); else echo("Fehler!"); // einen SQL-Befehl an die Datenbank schicken $abfrage = "SELECT * FROM job"; $resID = mysql_query($abfrage, $linkID); if (!$resID) die ("Es ist ein Fehler in der Abfrage aufgetreten."); // Ausgabe der Datensätze in Tabellenform echo("<table border cellpadding=\"3\"><tr>"); while($field=mysql_fetch_field($resID)) echo("<th>$field->name</th>"); while ($zeile = mysql_fetch_array($resID,MYSQL_BOTH)) { echo("<tr>"); for($i=0; $i<mysql_num_fields($resID); $i++) echo("<td>".htmlentities($zeile[$i])."</td>");
Die Tabellen können auch einzeln menügesteuert angelegt werden. Unter dem Menüpunkt
Neue Tabelle erstellen in Datenbank Personalwesen kann die Tabelle
mit der Anzahl der Felder festgelegt werden.
65
(Abb.13: Auswahl einer Datenbank mit PhpMyAdmin)
Bei Aktivieren des Buttons OK wird die Seite mit der Tabellendefinition angezeigt.
(Abb.14: Erstellen von Tabellen mit PhpMyAdmin)
Wurden alle CREATE TABLE-Befehle richtig ausgeführt, dann sollte die Datenbank
folgenden Aufbau haben:
66
(Abb.15: Tabellen der Datenbank „Personalwesen“ unter PhpMyAdmin)
3.1.6.3 Hinzufügen von Datensätzen
Es wurden nun alle vier Tabellen erzeugt. Nun können die dazugehörigen Datensätze mit dem
SQL-Befehl INSERT in die Tabellen eingefügt werden. Die dazugehörige Syntax lautet:
INSERT INTO tbl_name [(Spalte1, Spalte2, ...)] VALUES (Wert1,
Wert2, ...);
Die Daten werden in die Tabelle tbl_name eingefügt. Die Spaltennamen links von VALUES
stehen mit den Werten rechts von VALUES in Beziehung. Für jeden Attributnamen auf der
linken Seite muss auf der rechten Seite ein Wert stehen.
Werden auf der linken Seite keine Attributnamen angegeben, dann muss auf der rechten Seite
für jedes Attribut ein Wert angegeben werden.
Die dazugehörigen Daten können von der Hompage von Prof. Sauer unter http://rfhs8012.fh-
regensburg.de/~saj39122/DB/ heruntergeladen werden und dann entweder über eine Datei mit
den SQL-Monitor oder mit phpMyAdmin eingefügt werden. Es besteht außerdem die
Möglichkeit, die Daten per Hand mit phpMyAdmin zu erstellen.
Als Beispiel wurden die INSERT INTO-Befehle von aus dem Vorlesungsskript
Datenbanken von Prof. Sauer (http://rfhs8012.fh-regensburg.de/~saj39122/DB/) in die Datei
INSERTS.SQL geschrieben und dann über den SQL-Monitor erstellt.
67
insert into abteilung values ('KO','Konstruktion');
insert into abteilung values ('OD','Organisation und
Datenverarbeitung');
insert into abteilung values ('PA','Personalabteilung');
insert into abteilung values ('RZ','Rechenzentrum');
insert into abteilung values ('VT','Vertrieb');
insert into job values ('KA','Kaufm. Angestellter',3000.00);
insert into job values ('TA','Techn. Angestellter',3000.00);
insert into job values ('PR','Programmierer',3000.00);
insert into job values ('SY','Systemplaner',6000.00);
insert into job values ('IN','Ingenieur',6000.00);
insert into job values ('OR','Operateur',3500.00);
insert into angestellte values
('A1','Fritz','02.01.1950','OD','SY');
insert into angestellte values
('A2','Tom','02.01.1951','KO','IN');
insert into angestellte values
('A3','Werner','23.01.1948','OD','PR');
insert into angestellte values
('A4','Gerd','03.11.1955','VT','KA');
insert into angestellte values
('A5','Emil','02.03.1960','PA','PR');
insert into angestellte value
('A6','Uwe','03.04.1952','RZ','OP');
insert into angestellte values
('A7','Erna','17.11.1955','KO','TA');
insert into angestellte values
('A8','Rita','02.12.1957','KO','TA');
insert into angestellte values
('A9','Ute','08.09.1962','OD','SY');
insert into angestellte values
('A10','Willi','07.07.1956','KO','IN');
68
insert into angestellte values
('A12','Anton','05.07.1948','OD','SY');
insert into angestellte values
('A13','Josef','02.08.1952','KO','SY');
insert into angestellte values
('A14','Maria','17.09.1964','PA','KA');
insert into qualifikation values ('A1','SY');
insert into qualifikation values ('A1','PR');
insert into qualifikation values ('A1','OP');
insert into qualifikation values ('A2','IN');
insert into qualifikation values ('A2','SY');
insert into qualifikation values ('A3','PR');
insert into qualifikation values ('A4','KA');
insert into qualifikation values ('A5','PR');
insert into qualifikation values ('A6','OP');
insert into qualifikation values ('A7','TA');
insert into qualifikation values ('A8','TA');
insert into qualifikation values ('A9','IN');
insert into qualifikation values ('A9','SY');
insert into qualifikation values ('A10','IN');
insert into qualifikation values ('A11','KA');
insert into qualifikation values ('A12','SY');
insert into qualifikation values ('A13','IN');
insert into qualifikation values ('A14','KA');
(Abb.16: Insert-Befehle unter MySQL-Monitor)
Die Daten können über den Button Einfügen mit phpMyAdmin auch eingefügt werden.
69
(Abb.17: füllen der Tabellen mit Daten unter PhpMyAdmin)
Man kann sich nun mit phpMyAdmin die Tabelleninhalte anzeigen lassen. Die Tabelle
Angestellte sollte nun die folgenden Datensätze beinhalten:
(Abb.18: anzeigen der Tabelleninhalte unter PhpMyAdmin)
70
(Abb. 19: Datensätze der Tabelle „Angestellte“)
71
3.1.7 PHP-Skripte in Anwendung mit einer MySQL-Datenbank
am Beispiel der Datenbank Personalwesen
In diesem Kapitel wird anhand einer beispielhaften Anwendung PHP mit einem MySQL-
Zugriff vorstellen. Dazu wurde ein HTML-Formular entwickelt, das an ein PHP-Skript eine
SQL-Anweisung abschickt und dann die SQL-Anweisung ausführt.
3.1.7.1 Das HTML-Formular PHP_Formular
(Abb.20: PHP-Formular)
In diesem Formular kann man anhand der Radiobuttons die SQL-Anweisung auswählen, die
von PHP verarbeitet werden soll. Wählt man den Button SELECT, kann im unteren Textfeld
72
ein Select-Befehl eingegeben werden. Durch Aktivieren des Buttons „Abschicken“ wird der
SELECT-Befehl an das PHP-Skript SQL.php3 weitergeleitet. Das PHP-Skript überprüft den
eingegebenen SELECT-Befehl auf seine Richtigkeit und gibt dann das Ergebnis in einer
Tabelle wieder aus.
Als Datenbank wurde die Datenbank Personalwesen von aus dem Vorlesungsskript
Datenbanken von Prof.. Sauer (http://rfhs8012.fh-regensburg.de/~saj39122/DB/) verwendet.
Die Anweisung SELECT * FROM JOB; bewirkt dann folgende Ausgabe:
(Abb.21: Ergebnis einer SELECT-Anweisung)
Das Feld Nr dient nur zur Übersicht für den Benutzer und ist kein Primärschlüssel der
Tabelle. Der eingegebene SQL-Befehl muss nicht mit Strichpunkt (;) beendet werden. Dieser
Strichpunkt kann auch weggelassen werden. Gross- und Kleinschribung muss auch nicht
73
beachtet werden. Es kann jeder beliebige SELECT-Befehl in das Textfeld des HTML-
Formulars PHP_Formular eingegeben werden.
Es können auch komplexere SELECT-Anweisungen an die Datenbank geschickt werden.
Jeder Befehl unterstützt, der MySQL bekannt ist, wird unterstützt.
Z.B. liefert die SELECT-Anweisung SELECT * FROM Angestellte,
Qualifikation WHERE Angestellte.ang_id = Qualifikation.ang_id
folgendes Ergebnis:
(Abb.22: Ergebnis einer komplexeren SELECT-Anweisung)
Code des Formulars
<title>PHP-Skripte in Anwendung mit einer MySQL-Datenbank</title> <body bgcolor="#fffff#"><br> <h1>PHP-Skripte in Anwendung mit einer MySQL-Datenbank</h1> <form method="post" action ="SQL.php3"> <table> <h2>Es werden folgende SQL-Anweisungen von PHP unterstützt</h2>
74
<table border="3"> <tr> <th><input type ="radio" NAME = "Auswahl" VALUE = "Select" CHECKED> SELECT </th> <th><input type ="radio" NAME = "Auswahl" VALUE = "Create" > CREATE-Table</th> </tr> <tr> <th><input type ="radio" NAME = "Auswahl" VALUE = "Update" >UPDATE<BR>  INSERT<BR>   DELETE</th> <th><input type ="radio" NAME = "Auswahl" VALUE = "Drop" >DROP-Table<BR> </tr> <tr> <th> </th> <th><input type ="radio" NAME = "Auswahl" VALUE = "Alter" > ALTER-Table</th> </tr> </table> <BR><BR>Bitte geben Sie die SQL-Anweisung ein:<BR><BR> <textarea name="Anweisung" rows="10" cols="95"></textarea><br> <input type ="submit" Value ="Abschicken" size ="25"> <input type ="reset" Value = "Eingaben löschen" size = "25"> </form></body></head>
Durch den HTML-Befehl <form method="post" action ="SQL.php3"> werden
alle Eingaben des Formulars an die Datei SQL.php3 übergeben. Jeder Elementname wird in
das globale Feld $_Post geschrieben, das von PHP zum ermitteln der übergebenen
Variablen dient. Genauso gut kann der Inhalt des Formulars auch an dieselbe Datei geschickt
werden.
In PHP wird dann mit der foreach-Schleife, der Schleife für Felder, der Inhalt des Feldes
$_Post über den Feldschlüssel $var ermittelt und in ein Feld mit den Namen $array()
geschrieben.
Danach kann über den Feldindex des beschriebenen Feldes $array() der Inhalt in die
Variablen $Anweisung und $Auswahl geschrieben werden. In $Anweisung steht dann
der SQL-Befehl und in $Auswahl der Inhalt der Radiogruppe. Die einzelnen Buttons
können dann über den String wie z.B. „Select“ in PHP überprüft werden.
Die Befehle zum ermitteln der Inhalte des Post-Befehls lauten:
$array = array();
75
// ermitteln der Inhalte des Globalen Feldes $_Post, die über das HTML-Formular geschickt // wurden foreach ($_POST as $var => $value) { $array[] = $value; } // zuweisen der Feldinhalte $Auswahl = $array[0]; $Anweisung = $array[1];
Der Befehl zum überprüfen des Inhalts der des ausgewählten Radiobuttons lautet dann:
if($Auswahl==“Select“) { // Anweisung } Tritt die If-Anweisung ein, so kann der SELECT-Befehl abgearbeitet werden. Das übernimmt
jedoch das PHP-Skript SQL.php3 und wird im nächsten Abschnitt ausführlich erklärt.
Die Inhalte der Post-Variable kann auch anders ermittelt werden. Man kann mit dem Befehl
$HTTP_POST_VARS auf den Inhalt zugreifen. $HTTP_POST_VARS ist ebenfalls ein Feld
und der Inhalt dieses Feldes kann z.B. mit $HTTP_POST_VARS[’Anweisung’]
ermittelt werden. Der Vorteil dieses Befehls ist, das die Inhalte nicht mehr durch eine Schleife
ermittelt werden müssen und diese Art der Ermittlung der Inhalte der Post-Variable ist
sicherer (siehe Diplomarbeit von Zimmermann Stefan unter der folgenden Seite:
// zuweisen der Feldinhalte $Auswahl = $HTTP_POST_VARS['Auswahl']; $Anweisung = $HTTP_POST_VARS['Anweisung'];
Der Feldinhalt muss jedoch nicht unbedingt in die Variablen geschrieben werden.
76
3.1.7.2 Das PHP-Skript der SQL-Anweisungen
Für die Implementierung der SQL-Anweisungen wurde eine Klasse mysql_db erstellt, die
folgendenen Inhalt umfasst:
- Es soll eine automatische Verbindung zur Datenbank Personalwesen von Prof.
Sauer hergestellt werden.
- Es sollen die Befehle SELECT, UPDATE, INSERT, DELETE, CREATE-TABLE,
ALTER-TABLE und DROP-TABLE ausgeführt werden.
- Die eingegebenen SQL-Anweisungen müssen auf Fehler überprüft werden.
- Bei allen Befehlen aus dem SELECT-Befehl soll der Name der betroffenen
Tabelle mit ausgegeben werden.
- Bei einem UPDATE-, INSERT- oder DELETE-Befehl soll die Tabelle komplett
ausgegeben werden.
3.1.7.2.1 Hauptprogramm und Klassenvariablen
Im Hauptprogramm der Datei SQL.php3 wird eine Instanz der Klasse mysql_db erzeugt.
Nun muss als nächstes der Inhalt des globalen Feldes $_Post, wie oben beschrieben
ermittelt werden. Danach wird anhand der Radiobuttons des Formulars die SQL-Anweiung
mit einer SWITCH-Anweisung ermittelt. Wird der Button SELECT ausgewählt, wird die
Funktion query() aufgerufen, die den SELECT-Befehl weiterverarbeitet. Bei der Auswahl
des Buttons UPDATE wird die Funktion geanderte_Dts() aufgerufen, die die SQL-
Anweisungen INSERT, UPDATE und DELETE verarbeitet usw.
Syntax:
$datenbank = new mysql_db; $array = array(); // ermitteln der Inhalte des Globalen Feldes $_Post, die über das HTML-Formular geschickt
77
// wurden foreach ($_POST as $var => $value) { $array[] = $value; } // zuweisen der Feldinhalte $Auswahl = $array[0]; $Anweisung = $array[1]; // Select-Anweisung an die Datenbank schicken switch($Auswahl) { case "Select" : if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingegeben."); else $datenbank->query($Anweisung); break;
case "Update" : if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingegeben.");
else $datenbank->geanderte_Dts($Anweisung); break; case "Create": if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingegeben."); else $datenbank->Create_Table($Anweisung); break;
case "Alter" : if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingegeben."); else $datenbank->Alter_Table($Anweisung); break; case "Drop" : if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingegeben."); else $datenbank->Drop_Table($Anweisung); break; }
Es wurden nur drei Klassenvariablen benötigt. Die Verbindung zur Datenbank mit $linkID,
der Datenbankname $db und das Ergebnis der SQL-Anweisungen werden in die Variable
$resID gespeichert. Diese Variablen sind in jeder Funktion der Klasse zugänglich.
Syntax:
class mysql_db {
var $linkID = false; var $resID = false; var $db = "Personalwesen";
.... }
78
3.1.7.2.2 Konstruktor der Klasse mysql_db
Der Konstruktor der Klasse mysql_db ruft die connect_db() Funktion auf, die die Verbindung
zur Datenbank herstellt.
Syntax:
// Konstruktor der Klasse mysql_db function mysql_db() {
$this->connect_db(); }
3.1.7.2.3 Die Funktion connect_db()
In dieser Funktion wird die Verbindung zu MySQL und zur Datenbank Personalwesen
hergestellt. Scheitert eine der beiden Anweisungen, wird eine Fehlermeldung ausgegeben, und
das Programm wird abgebrochen.
Syntax:
// Verbindung zur Datenbank function connect_db() { // Verbindung zu MySQL herstellen $this->linkID = mysql_connect("","",""); if (!$this->linkID) { die("Es konnte keine Verbindung zu MySQL hergestellt werden.<BR><BR>"); return false; } else { echo("Die Verbindung zu MySQL wurde hergestellt.<BR><BR>"); } // Datenbank Personalwesen auswählen
79
if (mysql_select_db($this->db, $this->linkID)) echo("Datenbank “ . $this->db . “ wurde ausgewählt.<BR><BR>"); else
die("Es ist ein Fehler aufgetreten. Die Datenbank “ . $this->db . “ konnte nicht ausgewählt werden. <BR><BR>");
}// Ende der Funktion connect_db
3.1.7.2.4 Die Funktion query($sql)
Zuerst werden alle Backslashes (\) in der SQL-Anweisung entfernt. Gibt man nämlich bei
einem SELECT-Befehl z.B. SELECT * FROM job WHERE job_id = ’KO’ ein, so
wird vor jedes Hochkommazeichen ein Backslash angehängt.
Der Befehl hat dann folgendes Aussehen:
SELECT * FROM job WHERE job_id = \’KO\’
Mit der STRING-Funktion stripslashes($string) werden dann automatisch alle
Backslashes entfernt.
Als nächstes wird dann überprüft, ob sich im angegebenen SELECT-Befehl auch das Wort
SELECT befindet. Das geschieht mit der STRING-Funktion stristr($string,
$suchstring). Mit dieser Funktion kann innerhalb eines Strings nach einer bestimmten
Zeichenkette gesucht werden. Wird das Wort SELECT nicht gefunden, so wird das Programm
abgebrochen.
Nun wird der übergebende String $sql ausgeführt. Dann wird mit der Funktion
echoerror() die Richtigkeit der SQL-Syntax überprüft.
Ist kein Fehler aufgetreten, so wird das Ergebnis anhand einer Tabelle ausgegeben. Zuerst
werden die Feldnamen mit der Funktion mysql_fetch_field() geholt und als
Spaltenüberschrift deklariert. Danach werden die Datensätze in einem array gespeichert und
mit der Funktion mysql_num_fields() zeilenweise ausgegeben.
80
Syntax:
function query($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); // Suche nach dem Wort SELECT $treffer = stristr($sql, "Select"); if ($treffer==false) die("Sie haben keine korrekte SELECT-Anweisung eingegeben."); $this->resID = mysql_query($sql, $this->linkID); $this->echoerror(); echo("<table border cellpadding=\"3\"><tr>"); echo("<th>Nr</th>"); while($field=mysql_fetch_field($this->resID)) echo("<th>$field->name</th>"); $index = 0; while ($zeile = mysql_fetch_array($this->resID,MYSQL_BOTH)) { $index++; echo("<tr><td>$index</td>"); for($i=0; $i<mysql_num_fields($this->resID); $i++) echo("<td>".htmlentities($zeile[$i])."</td>"); echo("</tr>\n"); } echo("</table>"); }// Ende der Funktion query
3.1.7.2.5 Die Funktion echoerror()
In dieser Funktion wird die MySQL-Funktion mysql_error() aufgerufen, die einen
englischen Fehlertext der zuvor ausgeführten Operation zurückgibt.
81
Syntax:
// Ausgabe bei einem Fehler function echoerror() { // Tritt ein Fehler in der SQL-Anweisung auf, dann bricht das Programm ab if( mysql_error()) { echo( mysql_error()."<BR><BR>"); echo("Das Programm wurde abgebrochen."); exit; } }// Ende der Funktion echoerror
3.1.7.2.6 Die Funktion geanderte_Dts($sql)
Wird ein UPDATE-, INSERT- oder DELETE-Befehl ausgeführt, dann wird die Funktion
geanderte_Dts($sql) aufgerufen. Der Funktion wird der String $sql übergeben, der
die SQL-Anweisung enthält.
Genau wie bei der Funktion query() werden zuerst alle Backslashes aus dem SQL-Befehl
entfernt und dann wird überprüft, ob sich eines der Wörter UPDATE, INSERT oder DELETE
in der SQL-Anweisung befindet.
Danach wird der SQL-Befehl an die Datenbank geschickt und es wird die Funktion
echoerror() aufgerufen. Als nächste wird die Anzahl der Datensätze, die beim Befehl
betroffen waren, zurückgegeben und es wird die Funktion get_tablename($sql,
„Update“) aufgerufen.
Syntax:
// Betroffene Datensätze bei einem UPDATE, INSERT oder DELETE ermitteln function geanderte_Dts($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); // suche nach den Worten UPDATE, INSERT, DELETE $feld = array("Update", "Insert", "Delete"); $falg = false;
82
foreach($feld as $element) { $treffer = stristr($sql, $element); if ($treffer==true) { $flag = true; break; } }
if ($flag==false)
die("Sie haben keine korrekte UPDATE-, INSERT-, oder DELETE-Anweisung eingegeben.");
$this->resID = mysql_query($sql, $this->linkID); $this->echoerror(); if (mysql_affected_rows()==1)
echo("Die SQL-Anweisung wurde durchgeführt. <BR> Es wurde ". mysql_affected_rows() . " Datensatz betroffen.");
else echo("Die SQL-Anweisung wurde durchgeführt. <BR> Es wurden ". mysql_affected_rows() . " Datensätze betroffen.");
$this->get_tablename($sql,"Update"); }// Ende der Funktion geanderteDts
3.1.7.2.7 Die Funktion get_tablename($sql, $Art)
Diese Funktion ermittelt den Tabellennamen, der bei einem UPDATE, INSERT, DELETE,
ALTER-TABLE, DROP-TABLE oder CREATE-TABLE betroffen wurde. Bei einem
UPDATE, INSERT oder DELETE wird danach die Funktion query() aufgerufen, um das
geänderte Ergebnis anzeigen zu lassen.
Zuerst wird ein dynamisches Feld angelegt, in dem später alle Tabellennamen gespeichert
werden. Alle Tabellen werden mit mysql_list_tables() aufgelistet, und danach wird
die Anzahl der Tabellen der Datenbank mit mysql_num_rows() ermittelt. Als nächstes
wird eine Schleife über die Anzahl der Tabellen durchlaufen, und jeder Tabellenname wird in
das Feld $tabellen gespeichert.
83
Für jedes Element des Feldes $tabellen wird nun überprüft, an welcher Position es im
String $sql vorkommt. Danach wird der Tabellenname ermittelt. Kommt eine der Tabellen
im String vor, dann wird diese Tabelle ausgegeben. Die Art der Ausgabe wird mit einer
SWITCH-Anweisung ermittelt.
Syntax:
function get_tablename($sql,$Art) { // dynamisches Feld für die Tabellennamen anlegen $tabellen = array(); // schreibe alle Tabellen in $result $result = mysql_list_tables($this->db,$this->linkID); $menge = mysql_num_rows($result); // hole die einzelnen Tabellennamen aus $result for($i = 0; $i < $menge; $i++) { $table_name = mysql_tablename($result,$i); // schreibe die Tabellennamen in das Feld tabellen $tabellen[] = $table_name; } foreach($tabellen as $element) { $treffer = strpos($sql,$element); if ($treffer==true) { $flag = true; $leerzeichen = strpos($sql, " ", $treffer); $div = $leerzeichen - $treffer; $tabelle = substr($sql,$treffer, $div); break; } } if ($flag == true) { switch($Art) { case "Update" : echo("<BR><BR>"); $this->query("Select * From " . $tabelle); break;
case "Create" : echo("Die Tabelle " . $tabelle. " wurde erfolgreich erstellt.");
break; case "Drop" : echo("<BR><BR>Die Tabelle wurde erfolgreich
gelöscht.");
84
break; case "Alter" : echo("<BR><BR>Die Tabelle " . $tabelle. " wurde
erfolgreich geändert.<BR>"); $this->query("Select * From " . $tabelle); break; } } }// Ende der Funktion get_tablename
3.1.7.2.8 Die Funktion Create_Table($sql)
Zu Beginn der Funktion werden die Backslashes vom übergebenen String $sql
abgeschnitten. Danach wird in der SQL-Anweisung nach dem String CREATE gesucht.
Wurde der String gefunden, dann wird der Befehl ausgeführt. Die Funktion echoerror()
wird aufgerufen und die neu erstellte Tabelle wird mit der Funktion
get_tablename($sql) ausgegeben.
Syntax:
// In dieser Funktion wird eine neue Tabelle erzeugt function Create_Table($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); $treffer = stristr($sql, "Create"); if ($treffer==false) die("Sie haben keine korrekte CREATE-Anweisung eingegeben."); $this->resID = mysql_query($sql, $this->linkID); $this->echoerror(); $this->get_tablename($sql, "Create"); }// Ende der Funktion Create_Table
85
3.1.7.2.9 Die Funktion Drop_Table($sql)
Diese Funktion ist fast identisch mit der Funktion Create_Table($sql). Der
Unterschied der beiden Funktionen besteht nur darin, dass nach dem String DROP in der SQL-
Anweisung gesucht wird.
Syntax:
// In diese Funktion wird eine Tabelle gelöscht function Drop_Table($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); $treffer = stristr($sql, "Drop"); if ($treffer==false) die("Sie haben keine korrekte DROP-Anweisung eingegeben."); $this->resID = mysql_query($sql, $this->linkID); $this->echoerror(); $this->get_tablename($sql, "Drop"); }// Ende der Funktion Drop_Table
3.1.7.2.9 Die Funktion Alter_Table($sql)
Die Funktion Alter_Table($sql) entspricht ebenfalls bis auf eine Kleinigkeit der
Funktion Create_Table($sql). Es werden auch die Backslashes des String $sql
abgeschnitten und dann wird nach dem Wort ALTER im String gesucht. Die SQL-Anweisung
wird ausgeführt, und die betroffene Tabelle wird mit get_tablename($sql) ermittelt.
86
Syntax:
// In dieser Funktion wird eine Tabelle geändert function Alter_Table($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); $treffer = stristr($sql, "Alter"); if ($treffer==false) die("Sie haben keine korrekte ALTER-Anweisung eingegeben."); $this->resID = mysql_query($sql, $this->linkID); $this->echoerror(); $this->get_tablename($sql, "Alter"); }// Ende der Funktion Alter_Table
87
3.2 Oracle
3.2.1 Verbindung zur Oracle-Datenbank auf dem Server der
Fachhochschule Regensburg herstellen
Damit man mit PHP auf eine Oracle-Datenbank zugreifen kann, ist es notwendig, einen
Oracle-Server zu installieren. Da die Installation aber recht aufwendig ist, habe wird das PHP-
Skript auf den Oracle-Server der FH-Regensburg gestellt. Der Server der FH-Regensburg ist
in der Lage, PHP-Skripte an eine Oracle-Datenbank weiterzuleiten. Allerdings ist der Zugang
zum Server der FH-Regensburg und der dort installierten Oracle-Datenbank unbedingt
erforderlich.
Die Verbindung erfolgt mittels Secure-FTP-Zugriff. Man benötigt ein Programm wie z.B.
SSH Secure Shell, das Sie im Internet unter der Seite
http://www.ssh.com/support/downloads herunterladen können. Nehmen Sie das Programm
„ssh Secure Shell for workstations“ und wählen dann den Link „Non-
commercial downloads“. Das Programm ist freeware und somit kostenlos. Installieren
Sie das Programm auf ihrer Festplatte, z.B. in das Verzeichnis C:\Programm Files\SSH
SECURE SHELL.
Nun muss die Verbindung zum FH-Server hergestellt werden. Öffnen Sie dazu das Programm
„Secure File Transfer Client.“ Klicken Sie im Menü auf „File“ und dann auf „Connect“.
88
(Abb.23: Connect mit SSH herstellen)
Tragen Sie unter „Host Name“ tabaluga.fh-regensburg.de ein. tabaluga.fh-
regensburg.de ist der Zielrechner, auf dem Sie ihre HTML-Formulare und Ihre PHP-
Skripte ablegen müssen. Unter „User Name“ ist Ihr FH-Kürzel in der Form abc12345
einzutragen und unter „Port Number“ 22. Der Server mit der Oracle-Datenbank läuft unter
dem Betriebssystem Unix. Aktivieren Sie dann den Button „Connect“. Nun werden Sie nach
ihrem Unix-Passwort gefragt. Tragen Sie ihr Passwort ein und bestätigen Sie die Eingabe mit
„OK“.
89
(Abb.24: FTP-Verbindung herstellen)
Nun haben Sie eine FTP-Verbindung zu einem Unix-File-Server der FH-Regensburg
hergestellt. Das angezeigte Fenster hat dann folgenden Aufbau:
- im linken Fenster ist Ihr aktueller Windows-Desktop
- im rechten Fenster Ihr Unix-Home-Directory
Aktivieren des Buttons „Connect“
90
(Abb.25: Secure Shell File Transfer –Fenster)
Öffnen Sie nun in der Menüleiste das Menü „Window“ und dann auf „New Terminal“. Nun
haben Sie vor sich ein Unix-Terminalfenster. Erstellen Sie nun im Terminal einen Ordner mit
dem Befehl „mkdir public_html“ und drücken die Eingabetaste. Legen Sie danach die
Lese- und Schreibrechte dieses Ordners mit den Befehlen „chmod o+x .“ und „chmod
o+x public_html“ fest.
Windows-Desktop
Unix-Home-Directory
91
(Abb.26: Lese- und Schreibrechte festlegen)
Überprüfen Sie die Eingaben, indem Sie den Befehl „ls -lod . public_html“
eintippen. Bei den Eigenschaften des Ordners public_html muss am Ende ein „x“ stehen.
(Abb.27: überprüfen der Schreibrechte)
am Ende dieser Zeichenfolge muss ein „x“ stehen
92
Schließen Sie nun das Terminal. Klicken Sie danach auf den Button Refresh im „Secure
Shell File Transfer-Fenster“. Danach muss der Ordner public_html sichtbar
sein.
(Abb.28: überprüfen des Ordners public_html)
Öffnen Sie den Ordner public_html. Suchen Sie im linken Fenster Ihre PHP-Skripte und
kopieren Sie diese mittels „drag and drop“ in den Ordner public_html.
dieser Ordner muss vorhanden sein
93
(Abb.29: kopieren der PHP-Skripte)
Nun können Sie über das Internet mit der URL
http://rfhs8012.fh-regensburg.de/~rur35679/PHP_Oracle_Formular.html auf das HTML-
Formular zugreifen und die SQL-Anweisungen ausführen.
94
(Abb.30: HTML-Formular für die Eingabe der SQL-Anweisungen)
Wenn Sie die Anweisung SELECT * FROM job eingeben, liefert das Formular die
folgende Ausgabe:
95
(Abb.31: Ausgabe eines Select-Befehls)
96
3.2.2 PHP-Funktionen für Oracle-Datenbanken
Für den Zugriff auf die Oracle-Datenbank wurden folgende Funktionen von PHP benötigt:
ora_logon
int ora_logon ([string Benutzername, string Passwort])
Es wird eine Oracle-Verbindung hergestellt.
ora_open
int ora_open (int Verbindung)
Es wird ein Oracle-Cursor geöffnet.
Beispiel für ora_logon und ora_open:
<?php //Verbindung zu Oracle herstellen $linkID = ora_logon ("rur35679@rfhs8012_ora9i”, “rur35679”); if (!$linkID) die(“Es konnte keine Verbindung zu Oracle hergestellt werden.“); else echo(“Verbindung zu Oracle wurde hergestellt“); //öffnet einen Oracle-Cursor $cursor = ora_open ($linkID); ?>
ora_parse
97
int ora_parse (int Cursor_id, string SQL-Anweisung, int
aufschieben)
Es wird eine SQL-Anweisung analysiert.
ora_exec
int ora_exec(int cursor)
Es wird eine analysierte SQL-Anweisug bei einem Cursor durchgeführt.
Beispiel für ora_parse und ora_exec:
<?php //Verbindung zu Oracle herstellen $linkID = ora_logon ("rur35679@rfhs8012_ora9i”, “rur35679”); if (!$linkID) die(“Es konnte keine Verbindung zu Oracle hergestellt werden.“); else echo(“Verbindung zu Oracle wurde hergestellt“); //öffnet einen Oracle-Cursor $cursor = ora_open ($linkID); // eine SQL-Anweisung analysieren if (!ora_parse ($cursor, “SELECT * FROM dual”)) die (“Die SQL-Anweisung konnte nicht ausgeführt werden.“); else // eine analysierte SQL-Anweisung durchführen ora_exec ($cursor); ?>
ora_close
int ora_close (int Corsor)
Es wird ein Oracle-Cursor geschlossen.
Beispiel:
<?php
98
// schließen des zuvor geöffneten Oracle-Cursors ora_close($cursor); ?>
ora_ColumnName
string ora_ColumnType (int cursor, int column)
Es wird der Typ eines Ergebnisfeldes ermittelt.
ora_numcols
int ora_numrows (int cursor_ind)
Es wird die Menge der Felder eines Ergebnisses ermittelt.
ora_getcolumn
array ora_getcolumn (int Cursor, mixed Feld)
Es werden die Daten eines Feldes geliefert.
ora_numrows
int ora_numrows (int cursor_ind)
Es wird die Menge der Datensätze eines Ergebnisses ermittelt.
99
ora_fetch
int ora_fetch_into (int Cursor)
Es wird ein Datensatz eines Oracle-Cursors abgerufen.
Beispiel für die Ausgabe eines SELECT-Befehls:
<?php // Verbindung zu Oracle herstellen, einen Cursor öffnen, SQL-Anweisung analysieren // und die analysierte Anweisung ausführen (siehe oben)
.... // Anzahl der Spalten des SELECT-Befehls ermitteln
// ausgeben der eines einzelnen Spaltennamens, “\t“ setzt nach // der Spaltenüberschrift einen Tabulator
echo($name . "\t\t"); $hilf++; } $index = 0; // ermitteln der Datensätze beim Oracle-Cursor $cursor while (ora_fetch($cursor)) { $index++; echo("<BR>$index"); for($i=0; $i < $spalten; $i++) // hier wird der Inhalt eines Datensatzes der Spalte $i ausgegeben
Setzt man vor jede der oben aufgeführten Funktionen ein „@“, dann wird die Fehlerausgabe
der Funktion unterdrückt.
Beispiel:
<?php ... // eine SQL-Anweisung analysieren; tritt ein Fehler auf, dann wird die Ausgabe
100
// unterdrückt. if (!@ora_parse ($cursor, “SELECT * FROM dual”)) die (“Die SQL-Anweisung konnte nicht ausgeführt werden.“); else // eine analysierte SQL-Anweisung durchführen ora_exec ($cursor); ?>
101
3.2.3 Erstellen der Tabellen unter Oracle
Die Tabellen unter Oracle unterscheiden sich von der Syntax zu den Tabellen unter MySQL.
Die Tabellen haben folgenden Aufbau:
create table abteilung (abt_id varchar2(2) not null,
case "Create": if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingege- ben.");
else $datenbank->Create_Table($Anweisung); break; case "Alter" : if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingege-
ben."); else $datenbank->Alter_Table($Anweisung); break; case "Drop" : if (!$Anweisung) echo("Es wurde keine SQL-Anweisung eingegeben."); else $datenbank->Drop_Table($Anweisung); break; }
Es gibt vier Klassenvariablen in der Datei Oracle.php3. Die Verbindung zur Oracle wird
in der Variablen $linkID gespeichert. Der Datenbankname wird in der Variablen $db, der
Benutzername in der Variablen $uname und das Passwort in der Variablen $passw
gespeichert. Die Variable $cursor ist für den Oracle-Cursor zuständig.
Syntax:
class oracle_db {
var $linkID = false; var $cursor = false; var $uname = "abc12345 @rfhs8012_ora9i"; var $passw = " abc12345"; ...
}
109
Bitte beachten Sie, dass Sie den Benutzernamen und das Passwort noch eingeben müssen.
3.2.6.2 Konstruktor der Klasse oracle_db
Der Konstruktor der Klasse oracle_db ruft die Funktion connect_db() auf, die die Verbindung
zu Oracle herstellt.
Syntax:
// Konstruktor der Klasse oracle_db function oracle_db() { $this->connect_db(); }
3.2.6.3 Die Funktion connect_db()
In dieser Funktion wird eine Verbindung zu Oracle hergestellt, wenn der Benutzername und
das Passwort richtig sind. Danach wird ein Oracle-Cursor geöffnet.
Syntax:
// Verbindung zur Datenbank function connect_db() { // Verbindung zu Oracle herstellen $this->linkID = @ora_logon($this->uname, $this->passw); if (!$this->linkID) { die("Es konnte keine Verbindung zu Oracle hergestellt werden.<BR><BR>"); return false; } else { echo("Die Verbindung zu Oracle wurde hergestellt.<BR><BR>"); } // öffnet einen Oracle-Cursor $this->cursor = @ora_open($this->linkID);
110
}// Ende der Funktion connect_db
3.2.6.4 Die Funktion query($sql)
Diese Funktion verarbeitet die eingegebenen SELECT-Anweisungen. Zuerst werden die
Backslashes des eingegebenen SQL-Befehls abgeschnitten und dann wird nach dem Wort
SELECT im Parameter $sql gesucht. Danach wird mit der Funktion ora_parse()
überprüft, ob es sich auch um einen korrekten SQL-Befehl handelt. Sonst wird das Programm
mit einer Fehlermeldung abgebrochen. Danach wird der SQL-Befehl mit der Funktion
ora_exec() ausgeführt.
Als nächstes werden die Feldnamen des SQL-Befehls ermittelt und es wird eine
Spaltenüberschrift erstellt. Dafür ist die Funktion ora_ColumnName() zuständig. Mit der
Funktion ora_NumCols() werden die Felder des Ergebnisses der Abfrage ermittelt.
Danach werden die Daten des Ergebnisfeldes mit der Funktion ora_getcolumn()
ermittelt und in eine Tabelle geschrieben. Zuletzt wird der Oracle Cursor geschlossen.
Syntax:
// Select-Anweisungen an die Datenbank schicken function query($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); // Suche nach dem Wort SELECT $treffer = stristr($sql, "Select"); if ($treffer==false) die("Sie haben keine korrekte SELECT-Anweisung eingegeben.<BR><BR>"); else echo($sql . "<BR><BR>"); if(!@ora_parse($this->cursor, $sql))
die ("<BR><BR>Die Select-Anweisung konnte nicht korrekt ausgeführt werden.");
Diese Funktion ermittelt die Anzahl der betroffenen Datensätze, die bei einem UPDATE-,
INSEERT- oder DELETE-Befehl betroffen sind. Dabei werden zuerst die Backslashes des
übergebenen Parameters $sql entfernt. Danach wird überprüft, ob eines der drei Worte in
der SQL-Anweisung vorhanden ist und ob die SQL-Anweisung korrekt ist. Als nächstes wird
die SQL-Anweisung ausgeführt. Mit der Funktion ora_numrows() wird die Anzahl der
betroffenen Datensätze ermittelt.
112
Syntax:
// Betroffene Datensätze bei einem UPDATE, INSERT oder DELETE ermitteln function geanderte_Dts($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); // suche nach den Worten UPDATE, INSERT, DELETE $feld = array("Update", "Insert", "Delete"); $falg = false; foreach($feld as $element) { $treffer = stristr($sql, $element); if ($treffer==true) { $flag = true; break; } } if ($flag==false)
die("Sie haben keine korrekte UPDATE-, INSERT-, oder DELETE-Anweisung eingegeben.");
if(!@ora_parse($this->cursor, $sql)) die ("Die SQL-Anweisung konnte nicht korrekt durchgeführt werden."); ora_exec($this->cursor); if (ora_numrows($this->cursor)==1)
echo("Die SQL-Anweisung wurde durchgeführt. <BR> Es wurde ". ora_numrows($this->cursor) . " Datensatz betroffen.");
else echo("Die SQL-Anweisung wurde durchgeführt. <BR> Es wurden ". ora_numrows($this->cursor) . " Datensätze betroffen.");
ora_close($this->cursor); }// Ende der Funktion geanderteDts
3.2.6.6 Die Funktionen Create_Table($sql), Alter_Table($sql)
und Drop_Table ($sql)
Diese drei Funktionen sind bis auf eine Kleinigkeit identisch. In den Funktionen werden
zuerst alle vorkommenden Backslashes des Übergabeparameters entfernt. Dann wird nach
113
dem Wort CREATE oder ALTER oder DROP gesucht und die Anweisung wird auf Fehler
überprüft. Danach wird die Anweisung ausgeführt. Die Unterscheidung betrifft eigentlich nur
die Ausgaben.
Diese drei Anweisungen werden in separate Funktionen unterteilt, damit sie leicht
veränderbar sind.
// In dieser Funktion wird eine neue Tabelle erzeugt function Create_Table($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); $treffer = stristr($sql, "Create"); if ($treffer==false) die("Sie haben keine korrekte CREATE-Anweisung eingegeben."); if(!@ora_parse($this->cursor, $sql)) die ("Die CREATE-Anweisung konnte nicht korrekt durchgeführt werden."); ora_exec($this->cursor); echo ("Die Anweisung " .$sql. " wurde korrekt durchgeführt"); ora_close($this->cursor); }// Ende der Funktion Create_Table
// In dieser Funktion wird eine Tabelle gelöscht function Drop_Table($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); $treffer = stristr($sql, "Drop"); if ($treffer==false) die("Sie haben keine korrekte DROP-Anweisung eingegeben."); if(!@ora_parse($this->cursor, $sql))
die ("Es ist ein Fehler in der DROP-Anweisung aufgetreten. Das Programm wurde abgebrochen.");
// In dieser Funktion wird eine Tabelle geändert function Alter_Table($sql) { // schneidet die Backslashes bei der Eingabe ab $sql = stripslashes($sql); $treffer = stristr($sql, "Alter"); if ($treffer==false) die("Sie haben keine korrekte ALTER-Anweisung eingegeben."); if(!@ora_parse($this->cursor, $sql))
die ("Es ist ein Fehler in der ALTER-Anweisung aufgetreten. Das Programm wurde abgebrochen.");
ora_exec($this->cursor); ora_close($this->cursor); }// Ende der Funktion Alter_Table
115
Abbildungsverzeichnis
Abb.1: Hinzufügen eines Netzwerkprotokolls 10
Abb.2: Hinzufügen des TCP/IP-Protokolls 11
Abb.3: Netzwerkumgebung 12
Abb.4: Start der Apache-Installation 13
Abb.5: Netzwerknamen für den Apache-Webserver eintragen 13
Abb.6: Überprüfen der Apache-Installation 14
Abb.7: Überprüfung der PHP-Installation 17
Abb.8: MySQL-Monitor 45
Abb.9: Information zu MySQL-Monitor 46
Abb.10: PhpMyAdmin 58
Abb.11: Erstellen einer Datenbank mit MySQL-Monitor 61
Abb.12: Erstellen der Tabellen mit MySQL-Monitor 63
Abb.13: Auswahl einer Datenbank mit PhpMyAdmin 65
Abb.14: Erstellen von Tabellen mit PhpMyAdmin 65
Abb.15: Tabellen der Datenbank „Personalwesen“ unter PhpMyAdmin 66
Abb.16: Insert-Befehle unter MySQL-Monitor 68
Abb.17: füllen der Tabellen mit Daten unter PhpMyAdmin 69
Abb.18: anzeigen der Tabelleninhalte unter PhpMyAdmin 69
Abb. 19: Datensätze der Tabelle „Angestellte“ 70
Abb.20: PHP-Formular 71
Abb.21: Ergebnis einer SELECT-Anweisung 72
Abb.22: Ergebnis einer komplexeren SELECT-Anweisung 73
Abb.23: Connect mit SSH herstellen 88
Abb.24: FTP-Verbindung herstellen 89
Abb.25: Secure Shell File Transfer-Fenster 90
Abb.26: Lese- und Schreibrechte festlegen 91
Abb.27: überprüfen der Schreibrechte 91
Abb.28: überprüfen des Ordners public_html 92
Abb.29: kopieren der PHP-Skripte 93
Abb.30: HTML-Formular für die Eingabe der SQL-Anweisungen 94
Abb. 31 Ausgabe eines SELECT-Befehls 95
116
Abb.32 PHP_Oracle_Formular 106
117
Literaturverzeichnis
- Ulrich Günther: PHP, Ein praktischer Einstieg
- Rasmus Lerdorf, Kevin Tatroe: Programmieren mit PHP
- Matt Zandstra: Jetzt lerne ich PHP4
- Sven Letzel, Robert Gacki: Jetzt lerne ich MySQL & PHP
- Thomas Demmig: MySQL lernen, Anfangen, anwenden, verstehen
- Kevin Yank: PHP and MySQL, Schritt für Schritt zur datenbankgestützten Website