
Welche Funktion haben
die Module DBI und DBD? Download
von DBI und DBD mit
den Modulen DBI und DBD: eine
Tabelle in einer MySQL Datenbank einrichten eine
Tabelle in einer Oracle Datenbank einrichten
in die Tabelle einer MySQL
Datenbank Daten einlesen in
die Tabelle einer Oracle Datenbank Daten einlesen
über Select auf die Daten
einer MySQL Datenbank zugreifen über
Select auf die Daten einer Oracle Datenbank zugreifen
über die Dereferenzierung
der Arrays auf die Daten einer mysql Datenbank zugreifen
die Anzahl der Datensätze
einer MySQL Datenbanktabelle ermitteln die
Anzahl der Datensätze einer Oracle Datenbanktabelle ermitteln
herausfinden
welche und wie viele Tabellen die MySQL Datenbank enthält
die Spalten
einer MySQL Tabelle aufblenden (Name, Datentyp, Wert)
eine Tabelle in einer MySQL
Datenbank ändern eine
Tabelle in einer Oracle Datenbank ändern
eine Tabelle in einer MySQL Datenbank löschen
eine Tabelle in einer Oracle
Datenbank löschen
Welche
Funktion haben die Module DBI und DBD? |
|
Das DBI Modul ist wohl das wichtigste Perl
Modul im Internet Umfeld. Das Modul erlaubt den Zugriff auf
jede relationale Datenbank für die ein DBD Treiber existiert.
Ein solcher Treiber liegt in Perl für jede relationale
Datenbank vor.
Das Database Interface (DBI) abstrahiert von der zugrunde
liegenden Datenbank. Das heißt, es hat noch nicht genügend
Informationen, um eine konkrete Datenbank anzusprechen.
DBI weiß nicht, in welchem Format die Daten in der Datenbank
abgespeichert werden, welche SQL Syntax verwendet wird, welche
Features die Datenbank hat. Das Modul ist lediglich eine allgemeine
Schnittstelle zu allen DBD Treibern. Diese verfügen über
die oben angesprochenen Informationen.
Das Abstraktionsniveau ist aber ausgesprochen günstig,
da so ein Programm, das für eine Datenbank entwickelt
wurde, problemlos auf eine andere angewandt werden kann. Es
reicht, wenn der DBD Treiber ausgetauscht wird. (Genau genommen
ist es natürlich so, dass beide Datenbanken die gleiche
SQL Syntax verstehen müssen.)
Die folgenden Beispiele beziehen sich
auf eine mysql Datenbank. Erläutert wird darüber hinaus,
wie eine Oracle Datenbank angesprochen wird. Zuerst müssen
folgende Module eingebunden werden: DBI und DBD-mysql bzw. DBD-oracle,
wenn man mit einer Oracle Datenbank arbeiten möchte.
(DBI Download; DBD-mysql Download; DBD-oracle Download)
Wie die Module dann in Perl eingebunden werden, ist in Arbeiten
mit Modulen genau beschrieben.
mit dem DBI
Modul eine Tabelle in einer MySQL Datenbank einrichten |
|
Als erstes müssen wir jetzt eine Datenbank
generieren. Dies ist mit dem DBI Modul selbst nicht möglich.
Wir müssen also auf die Funktionen zugreifen, die uns
die Datenbank selbst zur Verfügung stellt. siehe
Kurzeinführung
in mysql.
Nachdem wir eine mysql Datenbank kreiert haben, können
wir mit dem DBI Modul eine Tabelle einrichten. Nicht vergessen,
die MySQL Datenbank vorher hochfahren!
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{create table bratkartoffel (Name char(120),Age int(3),Gewicht dec(5,2),Beschreibung blob)};
my $sth = $dbh->prepare( $sql );
$sth->execute();
$sth->finish();
$dbh->disconnect();
Diese
Syntax funktioniert immer unabhängig vom SQL Statement.
Es ist notwendig, dieses Perlscript tatsächlich auszulösen,
da alle folgenden Beispiele auf dieser Tabelle aufbauen.
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
Hier definieren wir die Werte, die wir brauchen,
um auf die Datenbank zuzugreifen.
Vorher muss mit use DBI; das DBI Modul eingebunden werden.
Mit DBI:mysql legen wir fest, auf welchen Typ von Datenbank
wir zugreifen wollen, daran wird dann die konkrete Datenbank
angehängt, auf die wir zugreifen wollen. In unserem Beispiel: DBI:mysql:kartoffel
Es folgen Username und Password für die Datenbank. Auf
unserem lokalen Rechner sind diese Werte nicht gesetzt, deshalb
erfolgt hier kein Eintrag. Bei einem Zugriff auf eine Datenbank
im Netz ist müssen Username und Password natürlich
angegeben werden.
Darauf folgt das eigentliche SQL Statement.
$dbh und $sth sind Zeiger auf Objekte. Ausgedruckt sehen sie
sehen in z.B. wie folgt aus:
$dbh =>DBI::db=HASH(0x1b87cf0)
$sth =>DBI::st=HASH(0x1b87dec)
Die Art und Weise, wie hier Objekte initialisiert
werden, ist nicht besonders transparent. Intern laufen aber
die gleichen Prozesse ab, die im Kapitel Objektorientierte
Programmierung beschrieben werden.
Mit der Subroutine prepare wird ein SQL Statement gespeichert.
Dieses Statement kann dann hinterher x-mal ausgeführt
(execute) werden.
Die Subroutine finish beendet $sth. Die Verbindung
zur Datenbank bleibt aber bestehen, das heißt, es können
weitere SQL Statements abgesetzt werden. disconnect
schließt die Verbindung zur Datenbank.
Es stellt sich die Frage:
1) Muss ich prepare auch verwenden, wenn das SQL Statement
nur einmal ausgeführt wird?
Die Frage lässt sich eindeutig mit nein beantworten.
Wenn ein SQL Statement nur einmal abgesetzt wird, kann auch
folgende Schreibweise benutzt werden.
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{create table bratkartoffel2 (Name char(120),Age int(3),Gewicht dec(5,2),Beschreibung blob)};
my $sth = $dbh->do( $sql );
$dbh->disconnect();
Diese
Schreibweise ist schon viel kürzer. do beinhaltet prepare,
execute und finish.
Hier werden die Vorteile des DBI Moduls ganz
deutlich. Das Skript, welches eine Tabelle in einer Oracle
Datenbank einrichtet, zeigt bis auf die Userdaten und die
Datentypen keine Unterschiede zu dem Skript, das eine MySQL
Datenbanktabelle anlegt.
use DBI;
$verbinden1="DBI:Oracle:kartoffel";
$verbinden2="Benutzername";
$verbinden3="Kennwort";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{create table bratkartoffel (Name varchar2(120),Age number,Gewicht varchar2(6),
Beschreibung varchar2(500))};
my $sth = $dbh->prepare( $sql );
$sth->execute();
$sth->finish();
$dbh->disconnect();
print "Jauchzet und frohlocket. Die Tabelle wurde eingerichtet";
Mit DBI:Oracle:kartoffel legen
wir den Zugriff auf die Oracle Datenbank kartoffel (Dienstname)
fest.
Wichtig ist: Oracle groß schreiben! Es folgen Benutzername
und Kennwort für die Datenbank. In diesem Zusammenhang
muss die Adresse des Hosts als zusätzliche Listening-Adresse
in die Datei LISTENER.ORA eingetragen werden.(NET80/ADMIN/LISTENER.ORA)
Das SQL Statement, prepare, execute, finish entsprechen dem
Einrichten einer Tabelle
in einer MySQL Datenbank.
in
die Tabelle einer MySQL Datenbank Daten einlesen |
|
Die schnellste Methode um Massendaten einzulesen,
zeigt folgendes Beispiel.
Hier wird das SQL Statement mit prepare abgespeichert. Anstelle
konkreter Werte stehen Platzhalter. Die Werte werden dann
innerhalb einer foreach Schleife eingelesen.
@banane=(
["Ehmann, Andres",34,72.5,"El artista siendo joven"],
["Maier, Peter",42,80.56,"La vie en rose"],
["Landivar, Enrique",23,76.5,"Mi faccio capire ?"]
);
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{insert into bratkartoffel (Name,Age,Gewicht,Beschreibung) values (?,?,?,?)};
my $sth = $dbh->prepare( $sql );
foreach $himbeere(@banane)
{
($name,$age,$gewicht,$beschreibung)=@$himbeere;
$sth->execute($name,$age,$gewicht,$beschreibung);
}
$sth->finish();
$dbh->disconnect();
Auch folgende Schreibweise ist möglich.
(ist allerdings umständlicher)
@banane=(
["Ehmann, Andres",34,72.5,"El artista siendo joven"],
["Maier, Peter",42,80.56,"La vie en rose"],
["Landivar, Enrique",23,76.5,"Mi faccio capire "]
);
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
foreach $himbeere(@banane)
{
($name,$age,$gewicht,$beschreibung)=@$himbeere;
my $sql = qq{insert into bratkartoffel (Name,Age,Gewicht,Beschreibung) values
"$name",$age,$gewicht,"$beschreibung")};
my $sth = $dbh->prepare( $sql );
$sth->execute();
$sth->finish();
}
$dbh->disconnect();
Auch hier wird deutlich, dass es bis auf die
Userdaten keine Unterschiede zu dem entsprechenden MySQL-Skript
gibt.
@banane=(
["Ehmann, Andres",34,"72.50","El artista siendo joven"],
["Maier, Peter",42,"80.56","La vie en rose"],
["Landivar, Enrique",23,"76.50","Mi faccio capire ?"]
);
use DBI;
$verbinden1="DBI:Oracle:kartoffel";
$verbinden2="Benutzername";
$verbinden3="Kennwort";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{insert into bratkartoffel (Name,Age,Gewicht,Beschreibung) values (?,?,?,?)};
my $sth = $dbh->prepare( $sql );
foreach $himbeere(@banane)
{
($name,$age,$gewicht,$beschreibung)=@$himbeere;
$sth->execute($name,$age,$gewicht,$beschreibung);
}
$sth->finish();
$dbh->disconnect();
print "Die Werte wurden in die Tabelle eingelesen";
über
Select auf die Daten einer MySQL Datenbank zugreifen |
|
Im folgenden Beispiel wird ein Select Statement
verwendet. Die Elemente der anonymen Arrays werden über
eine while Schleife ausgelesen:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select * from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$sth->execute();
while(@ergebnis=$sth->fetchrow_array)
{
print $ergebnis[0]." ".$ergebnis[1]." ".$ergebnis[2]." ".$ergebnis[3]." \n";
}
$sth->finish();
$dbh->disconnect();
Das Ergebnis sieht dann so aus:
Ehmann, Andres |
34 |
72.5 |
El artista siendo joven |
Maier, Peter |
42 |
80.56 |
la vien en rose |
Ladivar, Enrique |
42 |
76.5 |
El artista siendo joven |
über
Select auf die Daten einer Oracle Datenbank zugreifen |
|
Beschreibung und Ergebnis des Skriptes siehe
über Select auf
die Daten einer MySQL Datenbank zugreifen
use DBI;
$verbinden1="DBI:Oracle:kartoffel";
$verbinden2="Benutzername";
$verbinden3="Kennwort";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select * from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$sth->execute();
while(@ergebnis=$sth->fetchrow_array)
{
print $ergebnis[0]." ".$ergebnis[1]." ".$ergebnis[2]." ".$ergebnis[3]." \n";
}
$sth->finish();
$dbh->disconnect();
über
die Dereferenzierung der Arrays auf die Daten einer MySQL
Datenbank zugreifen |
|
Praktisch wohl nicht besonders relevant, aber
didaktisch wertvoll ist es, auf die Daten über die Dereferenzierungen
der Arrays zuzugreifen. Dies zeigt folgendes Beispiel:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select * from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$sth->execute();
$zeiger_auf_array = $sth->fetchall_arrayref;
foreach $himbeere(@$zeiger_auf_array)
{
print "Das ist der Zeiger auf den Array:".$himbeere."\n Das sind die Werte \n";
print $$himbeere[0].$$himbeere[1].$$himbeere[2].$$himbeere[3]."\n";
}
$sth->finish();
$dbh->disconnect();
Als
Ergebnis erhalten wir:
Das ist der Zeiger auf den
Array:Array<0x1ccdba0> |
Das sind die Werte |
Ehmann, Andres |
34 |
72.50 |
El artista siendo
joven |
Das ist der Zeiger auf den
Array:Array<0x1ccdbc0> |
Das sind die Werte |
Maier, Peter |
42 |
80.56 |
la vien en rose |
Das ist der Zeiger auf den
Array:Array<0x1ccdbc24> |
Das sind die Werte |
Ladivar, Enrique |
23 |
76.50 |
Mi faccio capire? |
$zeiger_auf_array = $sth->fetchall_arrayref; beschreibt
den Zeiger auf einen Array, der selber wiederum nur Zeiger
auf anonyme Arrays beinhaltet. Wenn wir diese Zeiger dereferenzieren,
erhalten wir die Werte der einzelnen Zeilen.
Jede Zeile der Datenbank (in der Tabelle dunkelgrau) wird
also in einem Array abgespeichert. $sth ist zwar auch ein
Zeiger (auf einen HASH), aber das DBI Modul lässt eine
direkte Dereferenzierung dieses Zeigers nicht zu. Das heißt,
wir müssen die Funktion nehmen, die uns das DBI Modul
zur Verfügung stellt.
Eine kürzere Schreibweise wird im folgenden Skript beschrieben:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
$statement="select * from bratkartoffel";
$zeiger = $dbh->selectall_arrayref($statement);
$dbh->disconnect;
foreach $himbeere(@$zeiger)
{
@ergebnis=@$himbeere;
print "Name: $ergebnis[0], Alter: $ergebnis[1], Gewicht:$ergebnis[2],Beschreibung:$ergebnis[3] \n";
}
hier
liefert das Auslösen des Skriptes folgendes Ergebnis:
Name: Ehmann, Andres |
Alter: 34 |
Gewicht: 72.50 |
Beschreibung:
El artista siendo joven |
Name: Maier, Peter |
Alter: 42 |
Gewicht: 80.56 |
Beschreibung:
La vie en rose |
Name: Ladivar,
Enrique |
Alter: 23 |
Gewicht: 76.50 |
Beschreibung:
Mi faccio capire? |
$zeiger = $dbh->selectall_arrayref($statement); erzeugt
den Zeiger auf einen Array, der wiederum nur Zeiger auf anonyme
Arrays enthält. Jede gefundene Zeile in der Tabelle entspricht
einem anonymen Array.
Soll zu den Werten der Zeile auch der
Spaltenname ausgelesen werden (nach dem Schema $zeile{Spaltennamme}
=> Wert an der Stelle), dann sieht das aus wie im folgenden
Skript:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select * from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$sth->execute();
while ( $ergebnis=$sth->fetchrow_hashref)
{
while (($spaltenname,$inhalt)=each(%$ergebnis))
{
print " Name der Spalte: $spaltenname, Wert: $inhalt \n";
}
print "\n";
}
$sth->finish();
$dbh->disconnect();
Name der Spalte: |
Beschreibung,
|
Wert: El aristo siendo joven |
Name der Spalte: |
Gewicht, |
Wert: 72.50 |
Name der Spalte: |
Name, |
Wert: Ehmann, Andres |
Name der Spalte: |
Age, |
Wert: 34 |
|
|
|
Name der Spalte: |
Beschreibung,
|
Wert: La vie en rose |
Name der Spalte: |
Gewicht, |
Wert: 80.56 |
Name der Spalte: |
Name, |
Wert: Maier, Peter |
Name der Spalte: |
Age, |
Wert: 42 |
|
|
|
Name der Spalte: |
Beschreibung,
|
Wert: Mi faccio capire? |
Name der Spalte: |
Gewicht, |
Wert: 76.50 |
Name der Spalte: |
Name, |
Wert: Ladivar, Enrique |
Name der Spalte: |
Age, |
Wert: 23 |
Mit $ergebnis=$sth->fetchrow_hashref erhalten
wir für jede Zeile einen Zeiger auf einen hash (die while
Schleife stoppt, wenn undef zurückgegeben wird.) Diesen
Zeiger können wir dereferenzieren und jede Spalte einer
Zeile der Datenbanktabelle in Name/Wert Paare aufspalten.
Offiziell wird dieses Verfahren bei großen Datenmengen
nicht empfohlen.
die
Anzahl der Datensätze einer MySQL Datenbank ermitteln |
|
Wie viele Datensätze enthält die
Datenbank?
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select * from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$anzahl=$sth->execute();
$sth->finish();
print $anzahl;
$dbh->disconnect();
Für unsere Datenbank liefert das Skript
als Ergebnis: 3
Die Anzahl der vorhandenen Datensätze
kann natürlich auch mit einem SQL statement ermittelt
werden:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select count(*) from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$sth->execute();
$ergebnis=$sth->fetchrow_array;
$sth->finish();
print $ergebnis;
$dbh->disconnect();
Entscheidend
ist hier die Zeile $ergebnis=$sth->fetchrow_array; .
Da wir wissen, dass nur ein einziger Wert zurückkommt,
können wir diesen auch an eine Skalare Variable übergeben.
die
Anzahl der Datensätze einer Oracle Datenbanktabelle
ermitteln |
|
Die folgenden Beispiele sind bis auf die Userdaten
identisch mit den Skripten die
Anzahl der Datensätze einer MySQL Datenbanktabelle ermitteln
$verbinden1="DBI:Oracle:kartoffel";
$verbinden2="Benutzername";
$verbinden3="Kennwort";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select * from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$anzahl=$sth->execute();
$sth->finish();
print $anzahl;
$dbh->disconnect();
Die
Anzahl der vorhandenen Datensätze kann natürlich
auch hier mit einem SQL statement ermittelt werden:
use DBI;
$verbinden1="DBI:Oracle:kartoffel";
$verbinden2="Benutzername";
$verbinden3="Kennwort";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{select count(*) from bratkartoffel};
my $sth = $dbh->prepare( $sql );
$sth->execute();
$ergebnis=$sth->fetchrow_array;
$sth->finish();
print $ergebnis;
$dbh->disconnect();
herausfinden
welche und wie viele Tabellen die MySQL Datenbank enthält |
|
Es sind viele Anwendungen denkbar, bei denen
entscheidend ist, wie viele und welche Tabellen sich in einer
Datenbank befinden:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
@alle_tabellen = $dbh->tables;
foreach $himbeere(@alle_tabellen)
{
print "$himbeere \n";
}
$dbh->disconnect();
Ergebnis!
bratkartoffel bratkartoffel2.
In der Dokumentation zum DBI Modul steht: "This method is
experimental and may change or disappear". Hoffentlich nicht!
die
Spalten einer MySQL Tabelle aufblenden (Name, Datentyp,
Wert) |
|
Beim Programmieren eines Tools, welches das
Einrichten, das Ändern und das Löschen von Tabellen
erlaubt, muss es eine Möglichkeit geben, die Spalten
der Tabelle aufzublenden:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = "show columns from bratkartoffel";
my $sth = $dbh->prepare( $sql );
$sth->execute();
$zeiger_auf_hauptarray=$sth->fetchall_arrayref;
$sth->finish;
foreach $zeiger_auf_spalten_array(@$zeiger_auf_hauptarray)
{
print "Zeiger auf die Spalte $zeiger_auf_spalten_array \n";
foreach $zeiger_auf_spalten(@$zeiger_auf_spalten_array)
{
print "Wert $zeiger_auf_spalten \n";
}
print "------------------------------------------------ \n";
}
$dbh->disconnect();
Mit $zeiger_auf_hauptarray=$sth->fetchall_arrayref; erhalten
wir einen Zeiger auf einen Array, der auf einen Array zeigt.
Dieser wiederum zeigt auf Arrays, in denen der Name der Spalte,
der Datentyp und die Werte enthalten sind. Diese beiden Arrays
dereferenzieren wir in zwei foreach Schleifen.
Das Ergebnis sieht so aus:
Zeiger auf die Spalte ARRAY(0x1b88de8)
Wert Name
Wert varchar(120) )
Wert YES)
Wert
Wert
Wert
Wert select,insert,update,references
------------------------------------------------
Zeiger auf die Spalte ARRAY(0x1b88e48)
Wert Age
Wert int(3) )
Wert YES
Wert
Wert
Wert
Wert select,insert,update,references
------------------------------------------------
Zeiger auf die Spalte ARRAY(0x1b884b4)
Wert Gewicht
Wert decimal(5,2)
Wert YES
Wert
Wert
Wert
Wert select,insert,update,references
------------------------------------------------
Zeiger auf die Spalte ARRAY(0x1b88520)
Wert Beschreibung
Wert blob
Wert YES
Wert
Wert
Wert
Wert select,insert,update,references
------------------------------------------------
Haben wir die Werte, ist es nicht schwierig,
diese in eine HTML Select Box zu schießen und als Default
aufzublenden. Dem User können jetzt auch die anderen
möglichen Optionen als auswählbare Werte angeboten
werden. Wenn diese Aufgabe ganz besonders anwenderfreundlich
gelöst wird, dann sollte der User auch die Möglichkeit
haben, alle Tabellen einer Datenbank mit deren Spalten und
Eigenschaften auf einmal zu sehen.
Wir müssen also die Routine in eine foreach Schleife
einbinden, die alle Tabellen ausliest. Das sieht dann so aus:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
use DBI;
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
@alle_tabellen = $dbh->tables;
foreach $name_der_tabelle(@alle_tabellen)
{
print "\n\n Der Name der Tabelle ist $name_der_tabelle \n";
print "############################################################## \n";
my $sql = "show columns from $name_der_tabelle";
my $sth = $dbh->prepare( $sql );
$sth->execute();
$zeiger_auf_hauptarray=$sth->fetchall_arrayref;
$sth->finish;
foreach $zeiger_auf_spalten_array(@$zeiger_auf_hauptarray)
{
print "Zeiger auf die Spalte $zeiger_auf_spalten_array \n";
foreach $zeiger_auf_spalten(@$zeiger_auf_spalten_array)
{
print "Wert $zeiger_auf_spalten \n";
}
print "------------------------------------------------ \n";
}
}
$dbh->disconnect();
eine
Tabelle in einer MySQL Datenbank ändern |
|
Eine Tabelle kann mit folgender Syntax geändert
werden:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{alter table bratkartoffel change Name Name char(200)};
my $sth = $dbh->do( $sql );
$dbh->disconnect();
print "Tabelle wurde geändert";
eine
Tabelle in einer Oracle Datenbank ändern |
|
use DBI;
$verbinden1="DBI:Oracle:orcl";
$verbinden2="system";
$verbinden3="manager";
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{alter table bratkartoffel modify Name VARCHAR2(200)};
my $sth = $dbh->do( $sql );
$dbh->disconnect();
print "Tabelle wurde geändert";
Die
Veränderung der Spaltenbreite von Name mit describe
bratkartoffel; im Worksheet überprüfen!
eine
Tabelle in einer MySQL Datenbank löschen |
|
Das Löschen einer Tabelle sieht so aus:
use DBI;
$verbinden1="DBI:mysql:kartoffel";
$verbinden2="";
$verbinden3="";
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{drop table bratkartoffel};
my $sth = $dbh->do( $sql );
$dbh->disconnect();
print "Tabelle wurde gelöscht";
Wer
das Ergebnis überprüfen will, der kann das in mysql
mit den Befehlen: show columns from bratkartoffel bzw. show
tables; kontrollieren.
eine
Tabelle in einer Oracle Datenbank löschen |
|
Das Löschen der Tabelle sieht so aus:
use DBI;
$verbinden1="DBI:Oracle:kartoffel";
$verbinden2="Benutzername";
$verbinden3="Kennwort";
my $dbh = DBI->connect( "$verbinden1","$verbinden2","$verbinden3") || die
"Database connection not made: $DBI::errstr";
my $sql = qq{drop table bratkartoffel};
my $sth = $dbh->do( $sql );
$dbh->disconnect();
print "Tabelle wurde gelöscht";
Select
* from bratkartoffel; liefert jetzt die Meldung,
dass eine Tabelle bratkartoffel nicht existiert.
|
 |