Werbung einblenden Werbung ausblenden


Home / Tutorials / mysql Handbuch / mysql mit Perl ansteuern


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.)

Download von DBI und DBD

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.

eine Tabelle in einer Oracle Datenbank einrichten

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();
in die Tabelle einer Oracle Datenbank Daten einlesen

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.

vorhergehendes Kapitel