Ueb15 - oth
Werbung
Datenbanken
15. Übung
1. PHP-Grundlagen1
PHP ist eine serverseitige, in HTML eingebettete Skriptsprache. PHP-Skripte werden auf dem Server
ausgeführt, im Gegensatz z.B. zu JavaScript. Der Programmcode wird in eine HTML-Datei
geschrieben, z.B.:
<HTML>
<HEAD>
<TITLE> Mein erster Versuch mit PHP </TITLE>
</HEAD>
<BODY>
<?php
echo(“Hello world!“);
?>
</BODY>
</HTML>
Elementare Befehle
PHP wird einfach in den HTML-Quellcode geschrieben. Damit der Server weiß, in welcher Datei er
nach PHP-Skripten suchen soll, müssen die Dateien die richtige Endung (Extension) haben. Bei PHP3
waren „php3“ und „phtml“ üblich, bei PHP4 ist dagegen „php“ gebräuchlicher. Man kann natürlich den
Webserver so konfigurieren, daß er jede beliebige Endung als PHP-Skript identifiziert. Damit der
Server darüber hinaus noch weiß, welche Ausdrücke er in der Datei interpretieren soll, müssen jeweils
der Anfang und das Ende des PHP-Teils gekennzeichnet werden. Dafür gibt es drei Möglichkeiten:
1. <? echo "Hello world!"; ?>
2. <?php echo "Hello world!"; ?>
3. <script language="php">
echo "Hello world!";
</script>
Die erste Möglichkeit ist die kürzeste. Sie ist allerdings nicht XML-konform, so daß später Probleme
auf den Programmierer zukommen können, wenn man sie benutzt.
Die Sprache PHP ist hauptsächlich von C, aber auch von Java und Perl (die ihrerseits von C
beeinflußt wurden) beeinflußt.
Eine Anweisung wird immer mit einem „;“ abgeschlossen.
Der echo-Befehl
Den wichtigsten Befehl wurde oben schon verwendet: der echo-Befehl, der Strings ausgibt. Im obigen
Beispiel wird jeweils „Hello world!“ ausgegeben. Der Text, der ausgegeben werden soll, muß natürlich
in Anführungsstrichen stehen, da der Server sonst versucht, ihn als PHP-Befehl zu interpretieren. Bei
den Anführungsstrichen gibt es zwei verschiedene: einmal das einfache „ ‘ “ und das doppelte „ " “ .
Es gibt auch einen Unterschied zwischen den beiden. Bei den doppelten Anführungsstrichen versucht
der Server den Text zu interpretieren, bei den einfachen gibt er ihn dagegen einfach aus, z.B.:
$var = 123;
echo 'Die Variable $var hat den Wert 123!\n';
echo "Die Variable $var hat den Wert 123!\n";
1
Datenbanken
Das erste echo gibt “Die Variable $var hat den Wert 123!\n“ aus, das zweite hingegen
“Die Variable 123 hat den Wert 123!“ mit Zeilenumbruch. Gemeint war wohl “Die
Variable $var hat den Wert 123!“, das wird erreicht durch das Setzen eines „\“ vor das
Sonderzeichen:
echo "Die Variable \$var hat den Wert 123!\n";
Der folgende Ausdruck ist dann ebenfalls korrekt
echo "Say \"Hello World\" my friend"; // Gibt aus: „Say "Hello World!" my friend“
Wie man sieht, müssen doppelte Anführungsstriche anders geschrieben werden. Dieses Vorgehen
nennt man Quoten oder Quoting. Es ist insbesondere für das Ausgeben von HTML-Quelltext in
Verbindung mit echo und print nötig und kann u.U. zu Problemen führen, wenn man vergißt, in allen
Teilstrings zu quoten.
Buchstaben mit einem vorangestellten BackSlash werden als „escaped characters“ bezeichnet.
\n
\r
\t
\\
\$
\“
line feed, neue Zeile
carriage return
horizontaler Tabulator
BackSlash
Dollar-zeichen
Doppeltes Anführungszeichen
Der print-Befehl
Neben dem echo- gibt es auch den print-Befehl. Im Endeffekt leisten sie dasselbe: Sie geben Text
aus. echo ist ein internes Sprachkonstrukt, während hingegen print eine Ausdruck (Expression) ist.
echo kann mehrere Argumente haben, die nicht in Klammern stehen dürfen. print kann nur genau
ein Argument haben.
Alle folgenden Anweisungen sind zulässig und geben dasselbe aus:
$var1 = "Hallo";
$var2 = "Welt!";
echo $var1," ",$var2;
echo $var1." ".$var2;
print ($var1." ".$var2);
$res = print ($var1." ".$var2);
Kommentare
Es gibt zwei Möglichkeiten der Schreibweise
echo “Noch kein Kommentar!“;
/* Dies ist ein Kommentar,
der über mehrere Zeilen gehen kann */
// Die ist wieder ein Kommentar, der bis zum Zeilenende geht
echo “Kein Kommentar mehr!“
Konstanten
Konstanten werden mit define() bestimmt, z.B.:
<? php
define(“Bearbeiter“,“Hans Mustermann“);
echo“Ihr aktueller Sachbearbeiter ist “ . Bearbeiter);
?>
2
Datenbanken
Blöcke und Kontrolstrukturen
Blöcke werden durch „{ ... }“ begrenzt.PHP-Skripte werden durch Kontrollstrukturen (Schleifen und
Bedingungen) gesteuert.
IF
Syntax: if (expr) statement
„expr“ ist Platzhalter für die Bedingung und „statement“ für den Befehl, der bei erfüllter Bedingung
ausgeführt werden soll.
Bsp.:
if($a>$b)
print “a ist groesser als b“;
Falls mehr als ein Befehl vorliegt, muß man die Befehle in geschweiften Klammern einschliessen.
ELSE
Bsp.:
if($a>$b)
print “a ist groesser als b“;
else
print “a ist nicht groesser als b“;
ELSEIF
Bsp.:
if($a>$b)
{
print “a ist
}
elseif ($a ==
{
print “a ist
}
else
{
print “a ist
}
groesser als b“;
$b)
gleich b“;
kleiner als b“;
Alternative Syntax für IF: IF(): ...ENDIF;
Bsp.:
<?php if ($a<$b): ?>
<h1> A ist kleiner als B</h1>
<?php endif; ?>
Der HTML-Text wird nur ausgegeben, wenn die Bedingung „A kleiner B“ erfüllt ist.
Alterantive Syntax für IF: (?:)
Bedingung ? Rückgabewert wenn true:Rückgabewert wenn false)
Bsp.:
<?php
echo ($a < $b ? “A ist kleiner als B“:““);
?>
WHILE
Grundform: WHILE (expr) statement
Alterantive Syntax: WHILE (expr) : statement ... ENDWHILE
1. Bsp.:
$i=1;
while ($i<=10)
3
Datenbanken
{
print $i++; // $i wird erst ausgegeben und dann inkrementiert
}
2. Bsp.:
$i=1;
while ($i<=10):
print $i;
$i++;
endwhile;
DO ...WHILE
Bsp.:
$i = 0;
do {
print $i;
} while ($i > 0); // $i wird genau einmal ausgegeben
FOR
Syntax ist identisch mit der in C: FOR (expr1; expr2; expr3) statement
1. Bsp.:
for ($i=1; $i < 10; $i++)
{
print $i
}
2. Bsp.:
for ($i=1;;$i++)
{
if ($i > 10)
{
break;
}
print $i
}
Mit break wird die aktuelle Schleife verlassen.
SWITCH
Variable
Alle Variablen werden durch ein vorangestelltes „$“ gekennnzeichnet. Die Variablen müssen nicht
vorher definiert werden. PHP verwendet den Typ, den es für richtig hält. Der Variablentyp kann auch
bei der ersten Benutzung festgelegt werden, indem er in Klammern angegeben wird.
int, integer
real, double, float
boolean
string
array
object
Integer
Double
Boolean
String
Array
Object
Ein String ist im Prinzip ein Array von Zeichen, z.B. wird mit $string[n] auf das n-te zeichen im String
zugegriffen.
Bsp.:
$a = 1234; // $a ist ein Integer
$b = (double) $a; // $b ist ein Double mit dem Wert 1234
$a = O123; // Oktalzahl
$a = 0xbad; // Hexadezimalzahl
echo floor((0,1+0.7)*10); // Ausgabe ist 7
4
Datenbanken
Mit dem Schlüsselwort global können Variable strukturübergreifend benutzt werden, z.B.
<?php
$a = 100;
function show()
{
global $a;
echo(“Der Wert der Variablen \$a ist: “ .$a);
}
show();
?>
Normalerweise verlieren Variable nach Verlassen eines Strukturblocks, z.B. einer Funktion oder einer
Schleife, ihren im Block neu berechneten Wert. Ist dies nicht erwünscht, muß die Variable mit static
deklariert werden.
<?php
function show()
{
static $var = 100;
$var += $var;
echo(“Der Wert der Variablen \$var ist:<BR>“ .$var);
}
show();
show();
?>
Ausgabe.
Der Wer der Variablen $var ist: 200
Der Wer der Variablen $var ist: 200
<BR> entspricht dem „new Line“-Zeichen.
Dynamische Erzeugung von Variablen. PHP bietet die Möglichkeit eine Variable in einer anderen zu
speichern, z.B.
<?php
$a = “name“;
$$a = “lernen“;
echo($name);
?>
Ausgabe. lernen
Im vorliegenden Beispiel wird zuerst der Variablen $a der Wert “name“ zugewiesen. Danach wird eine
neue Variable dynamisch erzeugt, indem zwei $-Zeichen ($$) verwendet werden. Der neuen Variablen
wird der Wert „lernen“ zugewiesen. Der Variablenname der erzeugten Variablen hat den wert der
Variablen $a angenommen, d.h. Die dynamische Variable heißt jetzt $name.
Zuweisungen
Wenn man der Variablen $a den Wert der Variablen $b zuweisen will, muß man dies mit Hilfe des
Gleichheitszeichens machen, z.B.
$a = $b;
Operatoren
Man muß zwischen den arithmetischen- (Zahlen), String- (Text), Bit-, logischen (bool'schen)- und
Vergleichs-Operatoren unterscheiden.
Arithmetische Operatoren
Beispiel
Name
Ergebnis
5
Datenbanken
$a + $b
$a - $b
$a * $b
$a / $b
$a % $b
Addition
Subtraktion
Multiplikation
Division
Modulo
Summe von $a und $b
Differenz von $a und $b
Produkt von $a und $b
$a geteilt durch $b
Rest der Division von $a und $b
String-Operatoren
Es gibt nur den Verbindungsoperator „.“.
Bsp.:
$a = “Hello “;
$b = $a . “World!“; // $b = “Hello World!“
Bit-Operatoren
Bit-Operatoren ermöglichen das Setzen bestimmter Bits in einer Integervariablen.
Beispiel
$a & $b
$a | $b
~$a
Name
UND
ODER
NICHT
Ergebnis
Bits, die in $a und $b gesetzt sind, werden gesetzt
Bits, die in $a oder $b gesetzt sind, werden gesetzt
Bits, die in $a gesetzt sind, werden nicht gesetzt, und umgekehrt
Logische Operatoren
Logische Operatoren bzw. bool’sche Operatoren dienen zum Verknüpfen von mehreren Vergleichen
bei einer Bedingung. „true“ ist der Wahrheitswert, seine Verneinung ist „false“.
Beispiel
$a and $b
$a or $b
$a xor $b
!$a
$a && $b
$a || $b
Name
UND
ODER
Exclusiv-ODER
NICHT
UND
ODER
Ergebnis
true, wenn $a und $b true sind
true, wenn mind. $a oder $b true sind
true, wenn genau einer $a oder $b true sind
true, wenn $a false ist
true, wenn $a und $b true sind
true, wenn mind. $a oder $b true sind
Vergleichsoperatoren
==
!=
>
<
>=
<=
Gleich
Ungleich
Größer
Kleiner
Größer gleich
Kleiner gleich
Array
Ein Array ist ein n-dimensionale Liste, z.B.:
$monat[1] = “Januar“;
$monat[2] = “Februar“;
$monat[3] = “Maerz“;
$monat[4] = “April“;
$monat[5] = “Mai“;
$monat[6] = “Juni“;
$monat[7] = “Juli“;
$monat[8] = “August“;
$monat[9] = “September“;
$monat[10] = “Oktober“;
$monat[11] = “November“;
$monat[12] = “Dezember“;
6
Datenbanken
Falls man neben den Monatsnamen auch die Anzahl der Tage im jeweiligen Monat abspeichern will,
braucht man eine zweidimensionale Tabelle:
Name
Januar
Februar
Maerz
April
Mai
Juni
Juli
August
September
Oktober
November
Dezember
Tage
31
28
31
30
31
30
31
31
30
31
30
31
In PHP nimmt die Tabelle folgende Gestalt an:
$$monat[1][“Name“]
$$monat[2][“Name“]
$$monat[3][“Name“]
$$monat[4][“Name“]
$$monat[5][“Name“]
$$monat[6][“Name“]
...
=
=
=
=
=
=
“Januar“;
“Februar“;
“Maerz“;
“April“;
“Mai“;
“Juni“;
$monat[1][“Tage“]
$monat[2][“Tage“]
$monat[3][“Tage“]
$monat[4][“Tage“]
$monat[5][“Tage“]
$monat[6][“Tage“]
=
=
=
=
=
=
31;
28;
31;
30;
31;
30;
Zwei wichtige Eigenschaften besitzen Arrays in PHP:
Zum einem werden bei mehreren Dimensionen die Indizes einzeln in eckigen Klammern hinter dem
Array-Namen angegeben. Zum anderen kann man für Indizes Werte beliebiger Datentypen
verwenden. Dadurch werden sog. assoziative Arrays möglich.
foreach-Schleife. foreach arbeitet jedes Element des Arrays nacheinander ab. Der Befehl ermittelt die
Anzahl der Elemente des Array und setzt einen internen Zeiger bei jedem Schleifendurchlauf um ein
Element weiter. Es stehen zwei Möglichkeiten für den Aufruf der Schleife zur Verfügung:
1. Bsp.
<?php
$array = array(“1“,“2“,“3“);
foreach($array as $element)
{
$element .= “0“;
echo(“$element, “);
}
?>
Ausgabe: 10, 20, 30,
2. Bsp.
<?php
$array = array(“1“,“2“,“3“);
foreach($array as $key=>$element)
{
$element .= “0“;
$key .= “x“;
echo(“Schluessel: $key, Element: $element<BR>“);
}
?>
Ausgabe. Schluessel: 0x, Element: 10
Schluessel: 1x, Element: 20
Schluessel: 2x, Element: 30
7
Datenbanken
include
Der Befehl include(“dateiname“); fügt an der angegebenen Stelle den Inhalt der Datei
„dateiname“ ein. Die Datei, die eingefügt wird, wird als HTML-Code interpretiert, deshalb muß, wenn
in der Datei PHP-Code steht, dies mit <?php anfangen und mit ?> aufhören.
Funktionen
Funktionen dienen dem Zusammenfassen mehrerer Befehlen zu einem Aufruf. Die Syntax lautet wie
folgt:
function foo($arg_1, $arg_2, ..., $arg_n) {
echo "Example function.\n";
return $retval;
}
Die Funktion bekommt die Argumente `Arg_1` bis `Arg_n` übergeben und gibt den Wert der Variablen
`retval` zurück. Wird kein `return` in der Funktion benutzt, hat man dasselbe Verhalten wie bei einer
Prozedur in Pascal. Rückgabewerte müssen nicht abgefragt werden.
Ein kleines Beispiel:
function my_sqr($num) {
return $num * $num;
}
echo my_sqr(4);
my_sqr(4);
// liefert das Quadrat von $num zurück
// gibt 16 aus
// ruft die Funktion auf, es passiert aber nichts
Variablenparameter
Normalerweise werden in PHP Werteparameter übergeben. Will man jedoch die Änderungen der
Parameter in der Funktion auch in der aufrufenden Funktion haben, muß man mit
Variablenparametern bzw. Referenzparameternarbeiten.
Variablenparameter werden mit einem `&` im Funktionskopf gekennzeichnet.
Ein kleines Beispiel:
function foo1 ($st) {
$st .= 'und etwas mehr.';
mehr.';
}
// gleichbedeutend mit $st = $st.'und etwas
function foo2 (&$st) {
$st .= 'und etwas mehr.';
}
$str
echo
foo1
echo
foo2
echo
= 'Dies ist ein String, ';
$str;
// Ausgabe: 'Dies ist ein String, ';
($str);
$str;
// Ausgabe: 'Dies ist ein String, ';
($str);
$str;
// Ausgabe: 'Dies ist ein String, und etwas mehr.';
Klassen
Syntax: <? php
class Name extends Elternname
{
...
}
?>
8
Datenbanken
Nach dem Namen der Klasse folgt, falls die Klasse von einer übergeordneten Klasse abgeleitet ist,
das Schlüsselwort extends mit dem Namen der übergeordneten Klasse. Eine Klasse muß aber nicht
von einer übergeordneten Klasse abgeleitet sein.
Eigenschaften und Methoden. Eigenschaften einer Klasse werden in Variablen gespeichert, die im
Block der Klasse angelegt wurden, z.B.:
<?php
class Name
{
var $vname;
}
?>
Eine Methode wird wie eine normale Funktion innerhalb der Klassenstruktur definiert. Methoden
greifen auf die Eigenschaften der Klasse zu, indem sie den reservierten Zeiger $this verwenden, z.B.:
<?php
class Name
{
var $vname;
function xyz($wert)
{
$this->vname = $wert;
}
function ausgabe()
{
return $this->vname;
}
}
?>
Eine spezielle Methode der Klasse ist der Konstruktor, der beim initialisieren der Klasse automatisch
aufgerufen wird und den gleichen Namen wie die Klasse besitzt, z.B.:
<?php
class Name
{
var $vname;
function Name($anfangswert)
{
$this->vname = $anfangswert;
}
function wertfestlegen($wert)
{
$this->vname = $wert;
}
function ausgabe()
{
return $this->vname;
}
}
?>
Verwenden der Klasse. Instanzen der Klasse werden mit dem Schlüsselwort new erzeugt:
<?php
include (“myclass.php“);
$objekt1 = new Name(“Juergen“);
$objekt2 = new Name(“Liesel“);
?>
Vererbung.
Bsp.: Die Klasse VorZuName erbt Eigenschaften und Methoden der Klasse Name.
9
Datenbanken
<?php
class VorZuName extend Name
{
var $vorname;
function VorZuName($vor,$zu)
{
Name::Name($zu);
$this->vorname = $vor;
}
function wertefestlegen($vor, $zu)
{
Name::wertefestlegen($zu);
$this->vname = $vor;
}
function ausgabe()
{
$hilf = Name::ausgabe();
return “$this->vorname $hilf“;
}
}
$meinName = new VorZuName(“Juergen“,“Sauer“);
echo($meinName->ausgabe());
?>
PHP und Oracle
PHP-Zugriff zur Oracle-DB des Labors DB / KI an der F.H. Regensburg
Der Server des Labors DB / KI kann PHP-Skripte an eine Oracle-Datenbank weiterleiten.
PHP-Funktionen für Oracle-Datenbanken
int ora_bind(int cursor, string PHP_variablenname, string SQL_parametername, int laenge, int typ)
gibt nach erfolgreichen Binden true, andernfalls false zurück. Einzelheiten über den Fehler zeigen
die Funktionen ora_error() und ora_errorcode().
Diese Funktion bindet die PHP-Variable an einen SQL-Parameter. Der SQL-Parameter muß von der
Form „:name“ sein.
ora_bind() muß nach ora_parse() und ora_exe() aufgerufen werden.
int ora_close(int cursor)
gibt nach erfolgreichen Schließen true, andernfalls false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion schließt den über ora_open() geöffneten Daten_Cursor.
string ora_columnName(int cursor, int feld)
gibt den Namen des Feldes feld vom Cursor cursor zurück (d.h. liefert den Namen eines OracleErgebnisfelds). Der zurückgegebene Name ist komplett in Großbuchstaben.
string ora_columnsize(int cursor, int feld)
gibt den Größe des Feld feld des Cursor cursor zurück.
string ora_columntype(int cursor, int column)
gibt den Namen des Felds feld vom Cursor cursor zurück. Der zurückgegebene Typ ist eine der
folgenden: varchar2, varchar, char, number, long, long raw, rowid, date, cursor.
int ora_commit(int conn)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion bestätigt eine Oracle-Transaktion. Eine Transaktion ist definiert als Gesamtheit aller
Änderungen, seit der letzten Bestätigung, dem letzten Rollback, seit die letzte automatische
Bestätigung abgeschaltet wurde oder seit die Verbindung besteht.
10
Datenbanken
int ora_commitoff(int conn)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion schaltet die automatische Bestätigung nach jedem Aufruf von ora_exec() ab.
int ora_commiton(int conn)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion schaltet die automatische Bestätigung nach jedem Aufruf von ora_exec() über die
angegebenen Verbindung ein.
int ora_do(int conn, string abfrage)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion ist eine schnelle Kombination von ora_parse(), ora_exec() und ora_fetch().
Sie analysiert eine Anweisung, führt sie aus und ruft dann den ersten Datensatz des Ergebnisses ab.
string ora_error(int cursor_oder_verbindung)
gibt eine Fehlermeldung der Form XXX-NNNNN zurück. XXX gibt an, wo der Fehler auftritt, NNNNN
identifiziert die Fehlermeldung.
int ora_errorcode(int cursor_oder_verbindung)
gibt den numerischen Fehlercode der zuletzt ausgeführten Anweisung des angegebenen Cursor bzw.
der angegebenen Verbindung zuück.
int ora_exec(int cursor)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
int ora_fetch(int cursor)
gibt true (Datensatz wurde abgerufen) oder false (keine weiteren Datensätze oder Auftreten eines
Fehlers) zurück. Beim Auftreten eines Fehlers sind Einzelheiten mit der Funktion ora_error() ind
ora_errorcode() bestimmbar. Wenn es keine Fehler gab, gibt ora_errorcode() 0 zurück.
int ora_fetch_into(int cursor, array ergebnis [, int flags])
Mit dieser Funktion kann eine Datensatz in ein Array abgerufen werden
mixed ora_getcolumn(int cursor, mixed feld)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode(). Die „false“-Überprüfung kann wahr
ergeben, wenn gar kein Fehler auftritt (Ergebis NULL, leere Zeichenkette, die Zahl 0, die Zeichenkette
“0“).
int ora_logoff(int verbindung)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion meldet den Benutzer ab und trennt die Verbindung zum Server.
int ora_login(string benutzername, string passwort)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Die Funktion baut mit benutzername und passwort eine Verbindung zwischen PHP und einer
Oracle Datenbank auf. Verbindungen können unter Verwendung von SQL*NET durch Eingabe des
TNS-Namens zu benutzername fogendermaßen aufgebaut werden
$conn = ora_logon(“benutzername@TNSNAME“,“passwort“);
int ora_plogon(string benutzername, string passwort)
11
Datenbanken
Diese Funktion baut mit benutzername und passwort eine persistente Verbindung zwischen PHP
und einer Oracle Datenbank auf.
int ora_numcols(int cursor_ind)
gibt die Anzahl der Felder eines Ergebnisses zurück.
int ora_numrows(int cursor_ind)
gibt die Anzahl der Datensätze eines Ergebnisses zurück
int ora_open(int verbindung)
gibt bei Erfolg einen Cursor-Index oder bei Auftreten eines Fehlers false zurück.
Diese Funktion öffnet einen Oracle-Cursor, der mit verbindung verknüpft ist.
int ora_parse(int cursor_ind, string SQLanweisung, int aufschieben)
gibt bei Erfolg 0 oder bei Auftreten eines Fehlers
Die Funktion analysiert eine SQL-Anweisung oder einen PL/SQL-Block und verknüpft diese(n) mit
dem angegebenen Cursor.
int ora_rollback(int verbindung)
gibt bei Erfolg true und bei Auftreten eines Fehlers false zurück. Einzelheiten über den Fehler
zeigen die Funktionen ora_error() und ora_errorcode().
Diese Funktion macht eine Oracle-Transaktion rückgängig.
2. Anwendung
http://fbim.fh-regensburg.de/~saj39122/php/PHP_Oracle_Formular.html
http://fbim.fh-regensburg.de/~saj39122/meile/rueckerl/index.html
http://fbim.fh-regensburg.de/~saj39122/php/grafik/
12
Datenbanken
1. Aufgabe
Es soll eine Funktion geschrieben werden, die das Ergebnis einer SQL-Abfrage tabellarisch darstellt.
Die Ausgabe soll im Prinzip die Tabelle, die man beim Aufruf der Abfrage „select * from
angestellte;“ am SQL*PLUS-Prompt bekommt, in HTML umsetzen (inkl. Spaltenname).
Lösungsrahmen:
<?php
$db_host
$db_user
$db_pass
$datab
=
=
=
=
"localhost";
"cr";
"123";
"cr";
function print_result_table($result){
// hier das Richtige schreiben
}
// Hauptprogramm
/* Verbindung zur Datenbank aufbauen */
$db = @mysql_connect($db_host,$db_user,$db_pass) or die(mysql_error());
@mysql_select_db($datab,$db) or die(mysql_error());
/* HTML-Startcode ausgeben */
echo "<html>\n<body>\n";
/* SQL-Abfrage */
$result = @mysql_query("SELECT * FROM angestellte");
print_result_table($result);
/* HTML-Endcode ausgeben */
echo "</body>\n</html>\n";
?>
Die Aufgabe soll in mehreren Schritten gelöst werden:
1. Nur in der 1. Zeile die 1. Spalte ausgeben.
2. Mit einer Schleife für alle Zeilen die 1. Spalte ausgeben.
3. Mit einer 2. Schleife alle Spalten ausgeben (vorher in der Dokumentation nachsehen, mit welcher
Funktion man die Spaltenanzahl abfragen kann).
4. Als letztes noch die Spaltennamen ausgeben.
Lösung
1. Teilschritt
Verwendet wurde bei der Lösung mysql_fetch_row(), weil es einfacher ist, mit einer Schleife einen
numerischen Index durchzugehen. Das wird im 3. Teilschritt deutlich.
function print_result_table($result){
// Tabellenanfang
echo "<table>\n";
// Tabellenzeilen-Anfang
echo " <tr>\n";
// Zeile aus DB-Anfrage holen
$row = mysql_fetch_row($result);
// erstes Feld der Zeile ausgeben
13
Datenbanken
echo "
<td>$row[0]</td>\n";
// Tabellenzeilen-Ende
echo " </tr>\n";
// Tabellenende
echo "</table>\n";
}
2. Teilschritt
function print_result_table($result){
// Tabellenanfang
echo "<table>\n";
// Alle Ergebniszeilen durchgehen
while ($row = mysql_fetch_row($result)){
// Tabellenzeilen-Anfang
echo " <tr>\n";
// erstes Feld der Zeile ausgeben
echo "
<td>$row[0]</td>\n";
// Tabellenzeilen-Ende
echo " </tr>\n";
}
// Tabellenende
echo "</table>\n";
}
3. Teilschritt
Mit int mysql_num_fields(int result) kann man abfragen, wie viele Spalten bei der Abfrage
zurückgegeben wurden. Mit einer for-Schleife werden einfach alle Felder ausgegeben.
function print_result_table($result){
// Tabellenanfang
echo "<table>\n";
// 1. Tabellenzeile Anfang
echo " <tr>\n";
for ($i = 0; $i < mysql_num_fields($result); $i++){
echo "
<th>".mysql_field_name($result,$i)."</th>\n";
}
// 1. Tabellenzeile Ende
echo " </tr>\n";
// Alle Ergebniszeilen durchgehen
while ($row = mysql_fetch_row($result)){
// Tabellenzeilen-Anfang
echo " <tr>\n";
// Alle Spalten durchgehen
for ($i = 0; $i < mysql_num_fields($result); $i++){
echo "
<td>$row[$i]</td>\n";
}
// Tabellenzeilen-Ende
echo " </tr>\n";
}
// Tabellenende
14
Datenbanken
echo "</table>\n";
}
4. Teilschritt
Zuletzt muß festgestellt werden, wie die Spalten heißen. Das macht die Funktion string
mysql_field_name(int result, int field_index).
function print_result_table($result){
// Tabellenanfang
echo "<table>\n";
// 1. Tabellenzeile Anfang
echo " <tr>\n";
for ($i = 0; $i < mysql_num_fields($result); $i++){
echo "
<th>".mysql_field_name($result,$i)."</th>\n";
}
// 1. Tabellenzeile Ende
echo " </tr>\n";
// Alle Ergebniszeilen durchgehen
while ($row = mysql_fetch_row($result)){
// Tabellenzeilen-Anfang
echo " <tr>\n";
// Alle Spalten durchgehen
for ($i = 0; $i < mysql_num_fields($result); $i++){
echo "
<td>$row[$i]</td>\n";
}
// Tabellenzeilen-Ende
echo " </tr>\n";
}
// Tabellenende
echo "</table>\n";
}
15
