Oracle Verbindung zur Oracle-Datenbank auf dem Server der

Oracle
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 PHPSkript 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 „Noncommercial 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“.
(Abb.23: Connect mit SSH herstellen)
Tragen Sie unter „Host Name“ tabaluga.fh-regensburg.de ein. tabaluga.fhregensburg.de ist der Zielrechner, auf dem Sie ihre HTML-Formulare und Ihre PHPSkripte 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“.
Aktivieren des
Buttons
„Connect“
(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
Windows-Desktop
Unix-Home-Directory
(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.
(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.
am Ende dieser
Zeichenfolge muss
ein „x“ stehen
(Abb.27: überprüfen der Schreibrechte)
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.
dieser Ordner muss
vorhanden 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.
(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
Formular zugreifen und die SQL-Anweisungen ausführen.
auf
das
HTML-
(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:
(Abb.31: Ausgabe eines Select-Befehls)
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
int
ora_parse
(int
Cursor_id,
string
SQL-Anweisung,
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
// schließen des zuvor geöffneten Oracle-Cursors
int
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.
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
$spalten = ora_numcols($cursor);
$hilf = 0;
while($hilf <> $spalten)
{
// Spaltenüberschriften ermitteln
$name = ora_ColumnName($cursor, $hilf);
// 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
echo(("\t\t" . ora_getcolumn($cursor, $i)));
}
echo("<BR>");
?>
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
// 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);
?>
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,
bezeichnung varchar2(40));
create table job(job_id varchar2(2) not null,
titel varchar2(30), gehalt number(8,2));
create table qualifikation(ang_id varchar2(3), job_id
varchar2(2));
create table angestellte(ang_id varchar2(3) not null, name
varchar2(10), gebdatum date, abt_id varchar2(2), job_id
varchar2(2));
Hinzufügen von Datensätzen unter Oracle
Die Insert-Befehle der Datenbank „Personalwesen“ haben unter Oracle folgenden Aufbau:
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-JAN50','OD','SY');
insert into angestellte values('A2','Tom','02-MAR51','KO','IN');
insert into angestellte values('A3','Werner','23-JAN48','OD','PR');
insert into angestellte values('A4','Gerd','03-NOV55','VT','KA');
insert into angestellte values('A5','Emil','02-MAR60','PA','PR');
insert into angestellte values('A6','Uwe','03-APR52','RZ','OP');
insert into angestellte values('A7','Erna','17-NOV55','KO','TA');
insert into angestellte values('A8','Rita','02-DEC57','KO','TA');
insert into angestellte values('A9','Ute','08-SEP62','OD','SY');
insert into angestellte values('A10','Willi','07-JUL56','KO','IN');
insert into angestellte values('A12','Anton','05-JUL48','OD','SY');
insert into angestellte values('A13','Josef','02-AUG52','KO','SY');
insert into angestellte values('A14','Maria','17-SEP64','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');
Ein allgemeines Beispiel für PHP in Verbindung mit OracleDatenbanken
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 Oracle herstellen; Benutzernamen und Passwort eintragen
$linkID = ora_logon("abc12345@rfhs8012_ora9i", " abc12345");
if (!$linkID)
die("Es konnte keine Verbindung zu Oracle hersgestellt werden.");
// öffnet einen Oracle-Cursor
$cursor = ora_open($linkID);
// einen SQL-Befehl an die Datenbank schicken
$abfrage = "SELECT * FROM job";
$resID = @ora_parse($cursor, $abfrage);
if (!$resID)
die ("Es ist ein Fehler in der Abfrage aufgetreten.");
ora_exec($cursor);
// Ausgabe der Datensätze in Tabellenform
echo("<table border cellpadding=\"3\"><tr>");
$spalten = ora_numcols($cursor);
$hilf = 0;
while($hilf <> $spalten)
{
$name = ora_ColumnName($cursor, $hilf);
echo("<th>$name</th>");
$hilf++;
}
while (ora_fetch($cursor))
{
$ spalten = ora_numcols($cursor);
echo("<tr>");
for($i=0; $i < $ spalten; $i++)
echo("<td>".htmlentities(ora_getcolumn($cursor, $i))."</td>");
echo("</tr>\n");
}
echo("</table>");
?>
</BODY></HTML>
PHP-Skripte in Anwendung mit einer Oracle-Datenbank
Für die Eingabe der SQL-Befehle wurde dasselbe HTML-Formular verwendet wie für den
Zugriff auf eine MySQL-Datenbank.
Es können die Befehle SELECT, INSERT, DELETE, UPDATE, CREATE-Table, ALTERTable und DROP-Table ausgeführt werden. Es darf jedoch nicht wie bei einer MySQLDatenbank ein Strichpunkt am Ende der SQL-Anweisung stehen.
(Abb.32: PHP_Oracle_Formular)
Durch Aktivieren des Buttons „Abschicken“ wird dann die SQL-Anweisung an das PHPSkript Oracle.php3 über den Server an die Oracle-Datenbank geschickt.
Hauptprogramm und Klassenvariablen
Im Hauptprogramm der Datei Oracle.php3 wird eine Instanz der Klasse oracle_db
erzeugt. Als nächstes wird über die globale Variable $_POST der Inhalt des HTMLFormulars PHP_Oracle_Formular.html ermittelt. Dazu wird ein dynamische Feld mit
den Namen $array erzeugt und mit der foreach-Schleife der Inhalt des Feldes $_POST
ausgelesen. Der ausgelesene Inhalt wird dem Feld $array angehängt. Zuletzt wird der
ausgelesene Inhalt den Variablen $Auswahl und $Anweisung zugewiesen. Danach wird
mit einer SWITCH-Anweisung ermittelt, welcher Radiobutton im HTML-Formular
ausgewählt wurde. Der dafür benötigte String steht in der Variablen $Auswahl.
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.
Syntax:
$datenbank = new oracle_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 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";
...
}
Bitte beachten Sie, dass Sie den Benutzernamen und das Passwort noch eingeben müssen.
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();
}
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);
}// Ende der Funktion connect_db
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.");
ora_exec($this->cursor);
echo("<table border cellpadding=\"3\"><tr>");
echo("<th>Nr</th>");
$spalten = ora_numcols($this->cursor);
$hilf = 0;
while($hilf <> $spalten)
{
$name = ora_ColumnName($this->cursor, $hilf);
echo("<th>$name</th>");
$hilf++;
}
$index = 0;
while (ora_fetch($this->cursor))
{
$index++;
$ spalten = ora_numcols($this->cursor);
echo("<tr><td>$index</td>");
for($i=0; $i < $ spalten; $i++)
echo("<td>".htmlentities(ora_getcolumn($this->cursor, $i))."</td>");
echo("</tr>\n");
}
echo("</table>");
ora_close($this->cursor);
}// Ende der Funktion query
Die Funktion geanderte_Dts($sql)
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.
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
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
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.");
ora_exec($this->cursor);
echo ("Die Anweisung " .$sql. " wurde korrekt durchgeführt");
ora_close($this->cursor);
}// Ende der Funktion Drop_Table
// 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