MySQL Voraussetzung und Installation einer MySQL Datenbank

MySQL
Voraussetzung und Installation einer MySQL Datenbank
MySQL ist genau wie PHP plattformunabhängig. D.h. Sie können MySQL unter einer
gängigen Windows-Version wie z.B. WindowsMe oder unter Linux oder UnixBetriebssystemen installieren. Die Installation unterscheidet sich aber von der Installation
unter Windows. Sonst werden keine Vorraussetzungen für MySQL benötigt.
Die neueste Version von MySQL können Sie aus dem Internet unter http://www.mysql.com/
herunterladen. Um MySQL zu starten, führen Sie das Setup-Programm (SETUP.EXE) aus
und installieren MySQL in ein beliebiges Verzeichnis. Im Beispiel wurde die MySQLInstallation in das Verzeichnis C:\Web\MySQL installiert.
Nachdem die Installation abgeschlossen ist, öffnen Sie mit einem Texteditor (WordPad) die
Datei My-Example.cnf in Ihrem MySQL-Verzeichnis und entfernen das
Kommentarzeichen # in der Zeile mit der Anweisung basedir. In der Beispielinstallation
ist die Datei unter C:\Web\MySQL\My-Example.cnf zu finden. Tragen Sie als
Verzeichnis hier Ihr MySQL-Verzeichnis ein (z.B. C:\Web\MySQL). Speichern Sie die
Datei als C:\My.cnf.
Sie können den Start von MySQL unter WindowsME mit Hilfe des Registry-Editors
automatisieren. Fügen Sie dazu unter
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\
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.
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 MySQLDatenbank (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.
Mit Hilfe des MySQL-Monitors ist es möglich, eine Verbindung zu jeder beliebigen MySQLDatenbank 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.
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)
$cfgServers[1]['user'] = 'root';
$cfgServers[1]['password'] = '';
auth)
$cfgServers[1]['only_db'] = 'Verwaltung';
$cfgServers[1]['verbose'] = '';
show the hostname
$cfgServers[1]['bookmarkdb'] = '';
support
$cfgServers[1]['bookmarktable'] = '';
support
// MySQL user (only needed with basic auth)
// MySQL password (only needed with basic
// If set to a db-name, only this db is accessible
// Verbose name for this host - leave blank to
// Bookmark db - leave blank for no bookmark
// Bookmark table - leave blank for no bookmark
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.
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 SQLBefehle eintippen können. Damit sind Sie nicht an die manchmal gewöhnungsbedürftige
Menüführung von PhpMyAdmin gebunden.
PHP und Datenbanken
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.
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!");
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 SQLBefehles wird in PHP nur eine einzige Funktion verwendet.
Syntax:
int mysql_query(string sql [, int linkID]);
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.");
?>
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]);
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))
{
echo ("Name: " .$zeile[0]);
echo (" - Adresse: " $zeile["adresse"] . "<br>\n");
Auf das erste Feld der Ergebnistabelle (Name) wird mit Hilfe des Index zugegriffen, auf das
zweite Feld (Adresse) assoziativ.
PHP-Funktionen für MySQL
In diesem Kapitel werden einige wichtige PHP-Funktionen für MySQL-Datenbanken
erläutert.
mysql_affected_rows
int mysql_affected_rows ([int resID])
Gibt eine Anzahl der Datensätze zurück, die nach einem UPDATE-, INSERT- oder DELETEBefehl 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
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.
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.
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!");
// 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.");
?>
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>");
echo("</tr>\n");
}
echo("</table>");
?>
</BODY></HTML>
Anlegen einer Datenbank unter MySQL
Bevor Tabellen angelegt werden, ist es erforderlich eine Datenbank anzulegen.
Der dazugehörige Befehl in MySQL lautet:
CREATE DATABASE [IF NOT EXISTS] db_name;
IF NOT EXISTS dient zum Überprüfen, ob die Datenbank bereits existiert oder nicht.
Das Anlegen einer Datenbank in MySQL hat zur Folge, dass im Datenverzeichnis von
MySQL z.B. C:\WEB\MYSQL\DATA ein Unterverzeichnis mit dem Namen der Datenbank
erzeugt wird.
(Abb.11: Erstellen einer Datenbank mit MySQL-Monitor)
Datenbankbezogene SQL-Befehle in MySQL
Befehl
Funktion
DROP DATABASE db_name;
Dieser Befehl löscht die Datenbank db_name und alle darin
enthaltenen Tabellen.
USE db_name;
Wählt db_name als aktuelle Datenbank aus.
SHOW DATABASES;
Listet alle verfügbaren Datenbanken auf.
Für diese Diplomarbeit wurde die Datenbank Personalwesen aus dem Vorlesungsskript
Datenbanken von Prof. Sauer als beispielhafte Anwendung benutzt (http://rfhs8012.fh-
regensburg.de/~saj39122/DB/). Dazu muss zuerst die Datenbank mit dem CREATE
DATABASE Befehl erzeugt werden, wir die untere Abbildung zeigt.
Erstellen und Verwalten von Tabellen
Als nächstes müssen die Tabellen der Datenbank Personalwesen erzeugt werden.
Die Syntax dazu lautet:
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(TABELLENDEFINITION, …)}
[TABELLENOPTIONEN]
[SELECT-Befehl]
Das reservierte Wort TEMPORARY erzeugt eine flüchtige Tabelle, die nur solange besteht wie
die Verbindung zur Datenbank. Der Befehl wurde jedoch beim Erstellen der Tabellen nicht
benötigt.
Durch die Angabe von IF NOT EXISTS wird keine Fehlermeldung ausgegeben, wenn die
Tabelle bereits existiert. Allerdings werden die Strukturen von alter und neuer Tabelle nicht
überprüft.
Tabellen mit MySQL-Monitor anlegen
Die zu erzeugenden Tabellen wurden mit einem Texteditor geschrieben und dann unter dem
Dateinamen C:\EIGENE DATEIEN\DB\TABLES.SQL gespeichert.
Die Tabellen haben folgenden Aufbau:
CREATE TABLE abteilung (abt_id VARCHAR(2) NOT NULL PRIMARY KEY
bezeichnung VARCHAR(40));
CREATE TABLE job (job_id VARCHAR(2) NOT NULL PRIMARY KEY,
titel VARCHAR (30), gehalt DOUBLE(8,2));
CREATE TABLE angestellte (ang_id VARCHAR (3) NOT NULL PRIMARY
KEY, name VARCHAR (10), gebdatum DATE, abt_id VARCHAR (2),
CONSTRAINT FKabt_id FOREIGN KEY(abt_id)
REFRENCES abteilung(abt_id) ON DELETE CASCADE,
job_id VARCHAR(2), CONSTRAINT FKjob_id1 FOREIGN KEY(job_id)
REFERENCES job(job_id) ON DELETE CASCADE);
CREATE TABLE qualifikation(ang_id VARCHAR(3) NOT NULL, FOREIGN
KEY(ang_id) REFERENCES angestellte(ang_id) ON DELETE CASCADE,
job_id VARCHAR(2) NOT NULL, CONSTRAINT FKjob_id2 FOREIGN
KEY(job_id) REFERENCES job(job_id) ON DELETE CASCADE,
CONSTRAINT PKquali PRIMARY KEY(ang_id,job_id));
Um die Tabellen anzulegen, wechseln Sie in das MySQL-Verzeichnis in meiner Installation
war das C:\WEB\MYSQL\BIN.
Die Tabellen werden mit dem MySQL-Monitor in einer Kommandozeile wie folgt angelegt:
\. C:\EIGENE~1\DB\TABLES.SQL
(Abb.12: Erstellen der Tabellen mit MySQL-Monitor)
Tabellen mit phpMyAdmin anlegen
PhpMyAdmin bietet drei gängige Möglichkeiten, Tabellen anzulegen. Zuerst muss
phpMyAdmin mit der URL http://localhost/phpmyadmin/index.php3 gestartet werden. Als
nächstes muss die Datenbank Personalwesen ausgewählt werden.
Variante 1
Eingeben eines SQL-Befehls in das SQL-Eingabefeld.
Variante 2
Durch klicken auf den Button Durchsuchen kann eine Datei ausgewählt werden, die SQLBefehle enthält (z.B. C:\EIGENE DATEIEN\DB\TABLES.SQL).
Variante 3
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.
(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:
(Abb.15: Tabellen der Datenbank „Personalwesen“ unter PhpMyAdmin)
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.fhregensburg.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.
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');
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.
(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)
(Abb. 19: Datensätze der Tabelle „Angestellte“)
PHP-Skripte in Anwendung mit einer MySQL-Datenbank am
Beispiel der Datenbank Personalwesen
In diesem Kapitel wird anhand einer beispielhaften Anwendung PHP mit einem MySQLZugriff vorstellen. Dazu wurde ein HTML-Formular entwickelt, das an ein PHP-Skript eine
SQL-Anweisung abschickt und dann die SQL-Anweisung ausführt.
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
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
beachtet werden. Es kann jeder beliebige SELECT-Befehl in das Textfeld des HTMLFormulars 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>
<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>&nbsp
INSERT<BR> &nbsp DELETE</th>
<th><input type ="radio" NAME = "Auswahl" VALUE = "Drop" >DROP-Table<BR>
</tr>
<tr>
<th>&nbsp</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();
// 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:
http://rfhs8012.fh-regensburg.de/~saj39122/Meile.html).
Die Befehle haben dann folgendes aussehen:
// zuweisen der Feldinhalte
$Auswahl = $HTTP_POST_VARS['Auswahl'];
$Anweisung = $HTTP_POST_VARS['Anweisung'];
Der Feldinhalt muss jedoch nicht unbedingt in die Variablen geschrieben werden.
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.
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 SQLAnweisungen 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
// 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";
....
}
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();
}
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
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
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.
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
Die Funktion echoerror()
In dieser Funktion wird die MySQL-Funktion mysql_error() aufgerufen, die einen
englischen Fehlertext der zuvor ausgeführten Operation zurückgibt.
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
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;
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
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.
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.");
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
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
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
Funktion
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 SQLAnweisung 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
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.
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