Einführung in MySQL

Allgemeines

Das Datenbanksystem MySQL arbeitet nach dem Client-Server Prinzip. Die eigentlichen Datenbanken werden vom Serverprogramm (hier der MySQL-Dämon - mysqld) verwaltet. Der Zugriff auf die Daten erfolgt von einem beliebigen Clientprogramm aus. Dazu erzeugt das Clientprogramm eine SQL-Abfrage und schickt diese an das Serverprogramm. Das Serverprogramm wertet die Anfrage aus und schickt das Ergebnis wieder an das Clientprogramm zurück. Das Clientprogramm ist dann nur noch für die Darstellung der Ergebnisse zuständig.

Das Client-Server Prinzip hat mehrere Vorteile:

Der Zugriff auf die Daten kann von verschiedenen Clientprogrammen aus erfolgen.
Mehrer Programme können gleichzeitig auf die Daten zugreifen. Das Serverprogramm koordiniert die Datenbankzugriff und verhindert somit Konflikte, die zum Beispiel durch das gleichzeige schreiben von Daten entstehen würden.
Der Zugriff auf die Daten kann über das Netz erfolgen. Das Serverprogramm läuft auf einem Rechner, das Clientprogramm auf einem anderen Rechner.
Bei einem Zugriff über das Netz vermeidet das Client-Server Prinzip unnötigen Netzwerkverkehr. Da die Auswertung der Daten vom Serverprogramm übernommen wird, werden nur die Datensätze, die dem Suchkriterium entsprechen, übertragen.
Würde das Clientprogramm die Auswertung übernehmen müssten im ungünstigsten Fall alle Datensätze zum Client übertragen werden, die dieser dann in der Regel sofort wieder verwerfen würde, da sich nicht dem Suchkriterium entsprechen.

Installation

Installation unter Windows

Auf der Homepage von MySQL kann die jeweils aktuelle Version per Download geholt werden. Nach dem Download befindet sich auf dem Rechner eine ZIP-Datei mit dem Namen mysql-xxx-win.zip. Wobei xxx für die aktuelle Verionsnummer steht z.B 3.23.53.
Nach dem entpacken der Datei kann die Installation durch einen Doppelklick auf setup.exe gestartet werden.
Die Installationsroutine verlangt nach einer Bestätigung des Destination Folder (c:\mysql) sowie des Setup Types (Typical).
Danach befinden sich alle zu MySQL gehörenden Dateien unter c:\mysql bzw. unter dem bei der Installation eingegebenen Pfad. Alle ausführbaren Programme (Binarys) befinden sich unter c:\mysql\bin und können von dort gestartet werden. Es empfiehlt sich c:\mysql\bin in den Suchpfad aufzunehmen.

Installation unter Linux

Unter SuSE 8.1 gehört MySQL nicht zur Standardinstallation. Das Paket muss nachinstalliert werden. Dazu wählt man nach dem Start von YAST2 Software und dort Software installieren oder löschen.
Nachdem der Filter für die Softwareauswahl auf Projektgruppen gestellt wurde findet sich das zu installierende Paket mysql unter Produktivity -> Databases -> Servers.
Nach der Auswahl des Paketes kann dieses Inatalliert und anschließend YAST2 beendet werden.
Wer eine neuere Version von MySQL installieren möchte sei auf die Dokumentation von MySQL verwiesen.

MySQL starten und beenden

Start unter Windows

Um unter Windows auf MySQL zugreifen zu können muss zunächst der Datenbankserver (auch der MySQL dämon) gestartet werden. Dazu genügt der Aufruf des Programms c:\mysql\bin\mysqld. Dieser kann entweder über eine Eingabeaufforderung oder über Start -> Ausführen erfolgen. Danach wird der MySQL dämon im Hintergrund ausgeführt.
Um MySQL beim Hochfahren des Rechners automatisch zu starten genügt es unter Win9x/ME diese Befehlszeile in die autoexec.bat aufzunehmen. Unter Windows NT/2000 empfiehlt es sich MySQL als sogenannten Service zu installieren der beim Hochfahren des Rechners automatisch gestartet und beim Herunterfahren wieder beendet wird.
Über die Befehlszeile c:\mysql\bin\mysqld-nt -install wird der Service installiert. Der Datenbankserver kann danach über das Kommando net start mysql gestartet und über net stop mysql wieder beendet werden.

Start unter Linux

Unter Linux kann der MySQL dämon vom Systemverwalter root durch Aufruf des Scriptes rcmysqld start gestartet werden. Analog wird mit rcmysqld stop der Datenbankserver beendet und durch rcmysqld restart beendet und neu gestartet.
LInux runlevel

Erster Test von MySQL

Das Kommando c:\mysql\bin\mysqlshow zeigt eine Liste aller Datenbanken an. Falls das Kommando erfolgreich ausgeführt wird, ist der Datenbank-Server ansprechbar.

     C:\>c:\mysql\bin\mysqlshow
     +-----------+
     | Databases |
     +-----------+
     | mysql     |
     | test      |
     +-----------+

Zu Beginn enthält MySQL nur zwei Datenbanken. Die Datenbank mysql wird zur Verwltung der Datenbanken, User und deren Zugriffsrechte benötigt. Bei test handelt es sich um eine Datenbank für Testzwecke.

MySQL beenden

Über das Kommando mysqladmin -u root -p shutdown wird der MySQL dämon beendet.

Administration von MySQL

root Passwort ändern

Die Kontrolle über die MySQL eigene Benutzerverwaltung hat der User root. Nach der Installation sollte daher als erstes ein root-Passwort vergeben werden.
Das folgende Kommando setzt das root-Passwort auf huhu.

C:\>c:\mysql\bin\mysqladmin -u root password huhu

Ein anschließender Versuch den MySQL Server zu beenden wird dann mit einer Fehlermeldung quitiert. Der zusätzlichen Parameter -p führt zu einer Abfrage des Passwortes vor der Ausführung des Kommandos.

C:\>c:\mysql\bin\mysqladmin -u root shutdown
C:\MYSQL\BIN\MYSQLA~1.EXE: connect to server at 'localhost' failed
error: 'Access denied for user: 'root@localhost' (Using password: NO)'

C:\>c:\mysql\bin\mysqladmin -u root -p shutdown
Enter password: ****

C:\>

Sollte sich der Server ohne Passwort beenden lassen, hilft es eventuell MySQL die Benuterdatenbank mit dem Kommando mysqladmin -u root reload neu einlesen zu lassen.

3. Beispieldatenbank CD-Sammlung

Die Tabellen der Beisp ieldatenbank cds

In einer Beispieldatenbank sollen Musik CD's erfasst werden. Als Beispiel dienen die folgenden drei Alben.

Dire Straits - Making movies

Tunnel of love - 8:05

Romeo and Juliet - 5:50

Skateaway - 6:15

Expresso love - 5:00

Hand in hand - 4:46

Solid rock - 3:17

Les boys - 4:06

Talk Talk - Spirit of Eden

The rainbow (Eden, Desire) - 23:11

Inheritance - 5:24

I belive in you - 6:16

Wealth - 6:35

Dire Straits - Brothers in arms

So far away - 5:12

Money for nothing - 8:26

Walk of life - 4:12

Yout latest trick - 6:33

Why worry - 8:31

Ride across the river - 6:58

The man's too strong - 4:40

One world - 3:40

Brothers in arms - 6:59

Um Redundanzen zu vermeiden ist es sinnvoll drei Tabellen anzulegen. Eine Tabelle für die Interpreten, eine für die Alben und eine für die einzelnen Titel.

Tabelle: Interpreten

id interpret

1 Dire Straits

2 Talk Talk

Tabelle: Alben

id id_interpret album

1 1 Making movies

2 2 Spirit of Eden

3 1 Brothers in arms

Tabelle: Titel

id id_album titel dauer

1 1 Tunnel of love 8:05

2 1 Romeo and Juliet 5:50

3 1 Skateaway 6:15

4 1 Expresso love 5:00

5 1 Hand in hand 4:46

6 1 Solid rock 3:17

7 1 Les boys 4:06

8 2 The rainbow (Eden, Desire) 23:11

9 2 Inheritance 5:24

10 2 I belive in you 6:16

11 2 Wealth 6:35

12 3 So far away 5:12

13 3 Money for nothing 8:26

14 3 Walk of life 4:12

15 3 Yout latest trick 6:33

16 3 Why worry 8:31

17 3 Ride across the river 6:58

18 3 The man's too strong 4:40

19 3 One world 3:40

20 3 Brothers in arms 6:59

Datenbank anlegen

Zum Anlegen einer Datenbank kann das MySQL Adminsitrationstool mysqladmin eingesetzt werden.
Mit dem Kommando:

mysqladmin -u root -p create cds

wird die Datenbank cds angelegt. Kontrollieren Sie das Ergebnis der Aktion mal mit mysqlshow -u root -p.
Analog kann über das Kommando drop anstelle von create eine Datenbank gelöscht werden.

User anlegen / Zugriffsrechte erteilen

MySQL bietet die Möglichkeit sehr differenzierte Zugriffsrechte auf Datenbanken und ihre einzelnen Bestandteile festzulegen. An dieser Stelle soll es genügen der Userin trillian die vollen Zugriffsrechte auf die neu angelegte Datenbank cds zu geben.
Dazu startet man zunächst als Administrator root den Datenbankclient mysql und erlaubt mit der GRANT Anweisung der Userin trillian den Vollzugriff auf alle Tabellen der Datenbank cds.

mysql -u root -p
Enter password: ******
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 3 to server version: 3.23.47-nt
/
Type ´help;´ or ´\h´for help. Type ´\c´to clear butter.

mysql> GRANT all ON cds.* to trillian@localhost IDENTIFIED BY "dent";
Query OK, 0 rows affected (0.38 sec)

mysql> quit;
Bye

Im dargestellten Beispiel wird der Userin trillian das Passwort dent zugeteilt. Die Zugriffsrechte werden von MySQL in der zu MySQL gehörenden Datenbank mysql verwaltet.
Mit dem Kommando quit wird der MySQL Client beendet.

Tabellen anlegen

Nachdem nun die Userin trillian angelegt wurde, starten Sie den MySQL Client erneut und melden sich jetzt als trillian an. Nach der Eingabe des Passworts erscheint wie gewohnt der MySQL Eingabepromt. Mit dem Kommando use cds wird dann die Datenbank CD-Sammlung ausgewählt. Alle Datenbankkommandos beziehen sich von jetzt an auf diese Datenbank.

mysql -u trillian -p
Enter password: ******
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 3 to server version: 3.23.47-nt

Type ´help;´ or ´\h´for help. Type ´\c´to clear butter.

mysql> use cds;
Database changed
mysql>

Zum Anlegen der Tabellen dient das Kommando create. Mit dem nachfolgend dargestellten Kommando wird die Tabelle interpreten angelegt. Lange SQL Befehle können über mehrer Zeilen hinweg eingegeben werden. Erst nach Eingabe des abschließenden ; wird das Kommando ausgeführt.
Ob die Tabelle tatsächlich erfolgreich angelegt wurde kann mit einem nachfolgenden show tables überprüft werden. Mit explain interpreten wird der Aufbau der Tabelle interpreten ausführlich erläutert.
    mysql> CREATE TABLE INTERPRETEN (
        -> id INTEGER NOT NULL AUTO_INCREMENT,
        -> interpret char(30),
        -> PRIMARY KEY (id));
    Query OK, 0 rows affected (0.00 sec)

    mysql> show tables;
    +---------------+
    |Tables_in_cds  |
    +---------------+
    |interpreten    |
    +---------------+
    1 row in set (0.01 sec)

    mysql> explain interpreten;
+-----------+----------+------+-----+---------+----------------+
| Field     | Type     | Null | Key | Default | Extra          |
+-----------+----------+------+-----+---------+----------------+
| id        | int(11)  |      | PRI | NULL    | auto_increment |
| interpret | char(30) | YES  |     | NULL    |                |
+-----------+----------+------+-----+---------+----------------+
2 rows in set (0.00 sec)

mysql>
Das Datenfeld id vom Datentyp integer erhält noch zusätzliche Angaben. NOT NULL erzwingt die Eingabe von Werten. AUTO_INCREMENT sorgt dafür, dass der erste Datensatz den Wert 1 erhält. Für jeden weiteren Datensatz der eingefügt wird, erhöht sich der Wert um eins.
Ein AUTO_INCREMENT Feld muss vom Datentyp Integer sein, als Index oder Primärschlüssel definiert und NOT NULL sein. Die Festlegung des Datenfeldes id als Primärschlüssel erfolgt in der letzten Zeile der Tabellendefinition.

Auf die gleiche Art und Weise werden die beiden weiteren Tabellen angelegt.
mysql> create table alben (
    -> id integer not null auto_increment,
    -> id_interpret integer,
    -> album char(40),
    -> primary key (id));
Query OK, 0 rows affected (0.00 sec)

mysql> create table titel (
    -> id integer not null auto_increment,
    -> id_album integer,
    -> titel char (40),
    -> dauer time,
    -> primary key (id));
Query OK, 0 rows affected (0.01 sec)

mysql> show tables;
+---------------+
| Tables_in_cds |
+---------------+
| alben         |
| interpreten   |
| titel         |
+---------------+
3 rows in set (0.00 sec)

mysql> explain alben;
+--------------+----------+------+-----+---------+----------------+
| Field        | Type     | Null | Key | Default | Extra          |
+--------------+----------+------+-----+---------+----------------+
| id           | int(11)  |      | PRI | NULL    | auto_increment |
| id_interpret | int(11)  | YES  |     | NULL    |                |
| album        | char(40) | YES  |     | NULL    |                |
+--------------+----------+------+-----+---------+----------------+
3 rows in set (0.00 sec)

mysql> explain titel;
+----------+----------+------+-----+---------+----------------+
| Field    | Type     | Null | Key | Default | Extra          |
+----------+----------+------+-----+---------+----------------+
| id       | int(11)  |      | PRI | NULL    | auto_increment |
| id_album | int(11)  | YES  |     | NULL    |                |
| titel    | char(40) | YES  |     | NULL    |                |
| dauer    | time     | YES  |     | NULL    |                |
+----------+----------+------+-----+---------+----------------+
4 rows in set (0.01 sec)

mysql>
   
Tabellenstruktur ändern

Gelegentlich soll es vorkommen, dass eine einmal definierte Datenstruktur einer Änderung bedarf. Dazu dient das Kommando alter.
Nachfolgend einige Beispiele:
Die Beispiele dienen nur zur Erklärung und müssen für das Übungsbeispiel nicht durchgeführt werden.

mysql> ALTER TABLE alben RENAME platten;
Der Name der Tabelle alben wird in platten geändert.

mysql> ALTER TABLE titel ADD kommentar CHAR(50);
Der Tabelle titel wird das Datenfeld kommentar vom Datentyp CHAR eigefügt.

mysql> ALTER TABLE titel DROP kommentar;
In der Tabelle titel wird das Datenfeld kommentar wieder gelöscht.

mysql> ALTER TABLE titel CHANGE titel song char(50);
In der Tabelle titel wird das Datenfeld titel in das Datenfeld song umbenannt. Der neue Datentyp ist jetzt CHAR mit einer länge von 50 Zeichen.
Mit dem Kommando explain kann die Änderung der Tabellenstruktur überprüft werden.

Datensätze eingeben

Zum Eingeben der Datensätze dient das Kommando insert into, wie nachfolgend dargestellt. Mit der select Anweisung kann der Inhalt der Tabelle angezeigt werden.
mysql> insert into interpreten (interpret)
    -> values
    -> ("Dire Straits"),
    -> ("Talk Talk");
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

mysql> select * from interpreten;
+----+--------------+
| id | interpret    |
+----+--------------+
|  1 | Dire Straits |
|  2 | Talk Talk    |
+----+--------------+
2 rows in set (0.36 sec)

mysql>
   
Analog werden die Daten in die Tabelle Alben eingegeben.
mysql> insert into alben (id_interpret, album)
    -> values
    -> (1, "Making movies"),
    -> (2, "Spirit of Eden"),
    -> (3, "Brothers in arms");
Query OK, 3 rows affected (0.01 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> select * from alben;
+----+--------------+------------------+
| id | id_interpret | album            |
+----+--------------+------------------+
|  1 |            1 | Making movies    |
|  2 |            2 | Spirit of Eden   |
|  3 |            3 | Brothers in arms |
+----+--------------+------------------+
3 rows in set (0.00 sec)

mysql>
   
Leider wurde die id_interpret beim dritten Album falsch eingegeben. Hier muss der Wert 1 und nicht 3 lauten.
Datensätze können mit dem UPDATE Kommando verändert werden.
mysql> update alben
    -> set id_interpret = 1
    -> where album = "Brothers in arms";
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> select * from alben;
+----+--------------+------------------+
| id | id_interpret | album            |
+----+--------------+------------------+
|  1 |            1 | Making movies    |
|  2 |            2 | Spirit of Eden   |
|  3 |            1 | Brothers in arms |
+----+--------------+------------------+
3 rows in set (0.00 sec)

mysql>
   
Der Versuch die Datensätze in die Tabelle titel von "Hand" einzugeben wird sich etwas mühsam gestalten. Etwas leichter gestaltet sich die Aufgabe, wenn die Datensätze aus einer Textdatei eingelesen werden können. Erstellen Sie zu diesem Zweck die Textdatei titel.txt mit folgendem Inhalt. (Als Trennzeichen zwischen den Einträgen dient der Tabulatorsprung. Achten Sie daruf, dass der von Ihnen verwendete Edior beim drücken der Tabulator Taste nicht nur einfach ein paar Leerzeichen erzeugt.)
1        1        Tunnel of love                00:08:05
2        1        Romeo and Juliet              00:05:50
3        1        Skateaway                     00:06:15
4        1        Expresso love                 00:05:00
5        1        Hand in hand                  00:04:46
6        1        Solid rock                    00:03:17
7        1        Les boys                      00:04:06
8        2        The rainbow (Eden, Desire)    00:23:11
9        2        Inheritance                   00:05:24
10       2        I belive in you               00:06:16
11       2        Wealth                        00:06:35
12       3        So far away                   00:05:12
13       3        Money for nothing             00:08:26
14       3        Walk of life                  00:04:12
15       3        Yout latest trick             00:06:33
16       3        Why worry                     00:08:31
17       3        Ride across the river         00:06:58
18       3        The man's too strong          00:04:40
19       3        One world                     00:03:40
20       3        Brothers in arms              00:06:59
   
Mit den folgenden Anweisungen lässt sich dann die Datentabelle dann einlesen.
mysql> load data local infile "titel.txt"
    -> into table titel;
Query OK, 21 rows affected (0.00 sec)
Records: 21  Deleted: 0  Skipped: 0  Warnings: 4

mysql> select * from titel;
+----+----------+----------------------------+----------+
| id | id_album | titel                      | dauer    |
+----+----------+----------------------------+----------+
|  1 |        1 | Tunnel of love             | 00:08:05 |
|  2 |        1 | Romeo and Juliet           | 00:05:50 |
|  3 |        1 | Skateaway                  | 00:06:15 |
|  4 |        1 | Expresso love              | 00:05:00 |
|  5 |        1 | Hand in hand               | 00:04:46 |
|  6 |        1 | Solid rock                 | 00:03:17 |
|  7 |        1 | Les boys                   | 00:04:06 |
|  8 |        2 | The rainbow (Eden, Desire) | 00:23:11 |
|  9 |        2 | Inheritance                | 00:05:24 |
| 10 |        2 | I belive in you            | 00:06:16 |
| 11 |        2 | Wealth                     | 00:06:35 |
| 12 |        3 | So far away                | 00:05:12 |
| 13 |        3 | Money for nothing          | 00:08:26 |
| 14 |        3 | Walk of life               | 00:04:12 |
| 15 |        3 | Yout latest trick          | 00:06:33 |
| 16 |        3 | Why worry                  | 00:08:31 |
| 17 |        3 | Ride across the river      | 00:06:58 |
| 18 |        3 | The man's too strong       | 00:04:40 |
| 19 |        3 | One world                  | 00:03:40 |
| 20 |        3 | Brothers in arms           | 00:06:59 |
| 21 |     NULL | NULL                       | NULL     |
+----+----------+----------------------------+----------+
21 rows in set (0.01 sec)

mysql>
   
Sollte etwas nicht funktionieren kann die der Inhalt einer Tabelle mit dem folgenden Kommando gelöscht werden.
mysql> delete from titel;
Query OK, 0 rows affected (0.01 sec)

mysql> select * from titel;
Empty set (0.00 sec)

mysql>
   

id	interpret
1	Dire Straits
2	Talk Talk

id	id_interpret	album
1	1	Making movies
2	2	Spirit of Eden
3	1	Brothers in arms

id	id_album	titel	dauer
1	1	Tunnel of love	8:05
2	1	Romeo and Juliet	5:50
3	1	Skateaway	6:15
4	1	Expresso love	5:00
5	1	Hand in hand	4:46
6	1	Solid rock	3:17
7	1	Les boys	4:06
8	2	The rainbow (Eden, Desire)	23:11
9	2	Inheritance	5:24
10	2	I belive in you	6:16
11	2	Wealth	6:35
12	3	So far away	5:12
13	3	Money for nothing	8:26
14	3	Walk of life	4:12
15	3	Yout latest trick	6:33
16	3	Why worry	8:31
17	3	Ride across the river	6:58
18	3	The man's too strong	4:40
19	3	One world	3:40
20	3	Brothers in arms	6:59

6. Datenbankabfragen

Zur Datenbankabfrage dient die select-Anweisung.

mysql> select * from alben;
+----+--------------+------------------+
| id | id_interpret | album            |
+----+--------------+------------------+
|  1 |            1 | Making movies    |
|  2 |            2 | Spirit of Eden   |
|  3 |            1 | Brothers in arms |
+----+--------------+------------------+
3 rows in set (0.44 sec)

mysql> select * from interpreten;
+----+--------------+
| id | interpret    |
+----+--------------+
|  1 | Dire Straits |
|  2 | Talk Talk    |
+----+--------------+
2 rows in set (0.07 sec)

mysql> select * from titel;
+----+----------+----------------------------+----------+
| id | id_album | titel                      | dauer    |
+----+----------+----------------------------+----------+
|  1 |        1 | Tunnel of love             | 00:08:05 |
|  2 |        1 | Romeo and Juliet           | 00:05:50 |
|  3 |        1 | Skateaway                  | 00:06:15 |
|  4 |        1 | Expresso love              | 00:05:00 |
|  5 |        1 | Hand in hand               | 00:04:46 |
|  6 |        1 | Solid rock                 | 00:03:17 |
|  7 |        1 | Les boys                   | 00:04:06 |
|  8 |        2 | The rainbow (Eden, Desire) | 00:23:11 |
|  9 |        2 | Inheritance                | 00:05:24 |
| 10 |        2 | I belive in you            | 00:06:16 |
| 11 |        2 | Wealth                     | 00:06:35 |
| 12 |        3 | So far away                | 00:05:12 |
| 13 |        3 | Money for nothing          | 00:08:26 |
| 14 |        3 | Walk of life               | 00:04:12 |
| 15 |        3 | Yout latest trick          | 00:06:33 |
| 16 |        3 | Why worry                  | 00:08:31 |
| 17 |        3 | Ride across the river      | 00:06:58 |
| 18 |        3 | The man's too strong       | 00:04:40 |
| 19 |        3 | One world                  | 00:03:40 |
| 20 |        3 | Brothers in arms           | 00:06:59 |
| 21 |     NULL | NULL                       | NULL     |
+----+----------+----------------------------+----------+
21 rows in set (0.12 sec)

mysql>

Testen Sie einfach die nachfolgenden SQL-Anweisungen und notieren Sie sich Ihre Funktion:

select titel, dauer from titel;
select dauer, titel from titel;
select * from titel where id_album = 1;
select * from titel where titel = "tunnel of love";
select * from titel where titel <> "tunnel of love";
select titel, dauer from titel where dauer > 600;
select titel, dauer from titel where dauer < 600;

Über die order by-Klausel können die Datensätze sortiert werden. Sehen Sie sich dazu die folgenden Beispiel an:

select * from titel where id_album = 1 order by titel;
select * from titel where id_album = 1 order by titel asc;
select * from titel where id_album = 1 order by titel desc;
select * from titel where id_album = 1 order by dauer desc;
select titel from titel where id_album = 1 order by dauer desc;

Die Syntax von MySQL kennt auch einige numerische Ausdrücke. Mit +, -, * und / lassen sich bei der Ausgabe einfache Berechnungen durchführen. Über die folgenden Ausdrücke lasse sich dann noch weiterführende Aufgaben lösen.
AVG ermittelt den arithmetischen Mittelwert einer Tabellenspalte.
MAX ermittelt den größten Wert einer Tabellenspalte.
MIN ermittelt den kleinsten Wert einer Tabellenspalte.
SUM ermitteln die Summe der Werte einer Tabellenspalte.
COUNT ermittelt die Anzahl von Datensätzen einer Tabelle.
Hierzu einige Beispiele:

select titel, dauer * 2 from titel;

Dei dieser Anweisung werden die Sekunden eines Titels mit 2 multipliziert und ausgegeben. Diese Trick wird oft dazu eingesetzt durch die Multiplikation mit 1,16 den Netto Preis einer bestimmten ware zu errechnen.

mysql> select max(dauer) from titel;
+------------+
| max(dauer) |
+------------+
| 00:23:11   |
+------------+
1 row in set (0.00 sec)

mysql> select count(*) from titel;
+----------+
| count(*) |
+----------+
|       21 |
+----------+
1 row in set (0.00 sec)

mysql> select count(*) from titel where id_album = 1;
+----------+
| count(*) |
+----------+
|        7 |
+----------+
1 row in set (0.00 sec)

mysql> select sum(dauer) from titel where id_album = 1;
+------------+
| sum(dauer) |
+------------+
|       3639 |
+------------+
1 row in set (0.00 sec)

mysql>

Die erste Anweisung ermittelt den Titel mit der längsten Spielzeit. Die zweite Anweisung ermittelt die Anzahl aller Datensätze in der Tabelle titel. Die dritte zählt die Titel des ersten Albums. Die vierte und letzte Anweisung schließlich ermittelt die Gesamtspielzeit aller Titel des Albums mit der ID 1.

Datenbankabfragen bieten auch die Möglichkeit mehrere Bedingungen logisch miteinander zu verknüpfen. Betrachten Sie bitte dazu die folgenden Beispiele:

select titel, dauer from titel where (dauer > 200) and (dauer < 400);

Dieses Kommando zeigt alle Musiktitel der Datenbank an, deren Spieldauer zwischen 2 und 4 Minuten liegt.

select titel, dauer from titel where (dauer < 400) or (dauer > 800);

Mit dieser Anweisung werden auf dem Bildschirm alle Titel unter 4 Minuten und über 8 Minuten Spiellänge angezeigt.

Interessant für die tägliche Arbeit sind auch die Operatoren IN, LIKE und BETWEEN. Auch diese werden an kleinen Beispielen erklärt:

mysql> select titel, dauer from titel where titel in ("Solid rock", "Why worry");
+------------+----------+
| titel      | dauer    |
+------------+----------+
| Solid rock | 00:03:17 |
| Why worry  | 00:08:31 |
+------------+----------+
2 rows in set (0.00 sec)

Diese Anweisung entspricht einer einfachen ODER-Verknüpfung. Es die Datensätze angzeigt, der Titel Solid rock oder Why worry ist.

mysql> select titel, dauer from titel where dauer between 400 and 800;
+-----------------------+----------+
| titel                 | dauer    |
+-----------------------+----------+
| Romeo and Juliet      | 00:05:50 |
| Skateaway             | 00:06:15 |
| Expresso love         | 00:05:00 |
| Hand in hand          | 00:04:46 |
| Les boys              | 00:04:06 |
| Inheritance           | 00:05:24 |
| I belive in you       | 00:06:16 |
| Wealth                | 00:06:35 |
| So far away           | 00:05:12 |
| Walk of life          | 00:04:12 |
| Yout latest trick     | 00:06:33 |
| Ride across the river | 00:06:58 |
| The man's too strong  | 00:04:40 |
| Brothers in arms      | 00:06:59 |
+-----------------------+----------+
14 rows in set (0.00 sec)

mysql>

Es werden alle Titel angezeigt, deren Spieldauer zwischen 4 und 8 Minuten liegt.

mysql> select titel, dauer from titel where titel like "T%";
+----------------------------+----------+
| titel                      | dauer    |
+----------------------------+----------+
| Tunnel of love             | 00:08:05 |
| The rainbow (Eden, Desire) | 00:23:11 |
| The man's too strong       | 00:04:40 |
+----------------------------+----------+
3 rows in set (0.00 sec)

mysql>

Die dargestellte Anweisung sucht aus der Tabelle titel alle Musiktitel heraus, deren Titel mit einem T beginnt. Das Platzhalter-Zeichen % steht für keines, eines oder mehrere beliebige Zeichen.

mysql> select titel.titel, titel.dauer, alben.album from titel, alben where titel.id_album = alben.id;
+----------------------------+----------+------------------+
| titel                      | dauer    | album            |
+----------------------------+----------+------------------+
| Tunnel of love             | 00:08:05 | Making movies    |
| Romeo and Juliet           | 00:05:50 | Making movies    |
| Skateaway                  | 00:06:15 | Making movies    |
| Expresso love              | 00:05:00 | Making movies    |
| Hand in hand               | 00:04:46 | Making movies    |
| Solid rock                 | 00:03:17 | Making movies    |
| Les boys                   | 00:04:06 | Making movies    |
| The rainbow (Eden, Desire) | 00:23:11 | Spirit of Eden   |
| Inheritance                | 00:05:24 | Spirit of Eden   |
| I belive in you            | 00:06:16 | Spirit of Eden   |
| Wealth                     | 00:06:35 | Spirit of Eden   |
| So far away                | 00:05:12 | Brothers in arms |
| Money for nothing          | 00:08:26 | Brothers in arms |
| Walk of life               | 00:04:12 | Brothers in arms |
| Yout latest trick          | 00:06:33 | Brothers in arms |
| Why worry                  | 00:08:31 | Brothers in arms |
| Ride across the river      | 00:06:58 | Brothers in arms |
| The man's too strong       | 00:04:40 | Brothers in arms |
| One world                  | 00:03:40 | Brothers in arms |
| Brothers in arms           | 00:06:59 | Brothers in arms |
+----------------------------+----------+------------------+
20 rows in set (0.01 sec)

mysql> select titel.titel, titel.dauer, alben.album, interpreten.interpret from titel, alben, interpreten where titel.
_album = alben.id;

mysql>

Im ersten Beipiel wird eine Tabelle aus zwei Tabellen erzeugt. Der Titel, sowie die Dauer des jeweiligen Titels werden aus der Tabelle titel ausgelesen. Der Name des jeweiligen Albums kommt aus der Tabelle alben.
Im zweiten nicht ausgeführten Beispiel wird zusätzlich noch der Interpret angezeigt.

7. Datenbankbackup

Mit dem Prgramm mysqldump können komplette Datenbanken in eine einfache ASCII-Datei gespeichert werden. mysqldump erzeugt dazu aus einer bestehende Datenbank SQL-Code, mit deren Hilfe später wieder die gleiche Datenbank angelegt werden kann. Zu diesem Zweck wird die Ausgabe von mysqldump in eine Datei umgeleitet. Der Inhalt dieser Datei wird dann später als Eingabe an das Programm mysql übergeben.


Der folgende Befehl gibt den Inhalt der Datenbank cds auf dem Bildschirm aus.

   
    C:\mysql\bin>mysqldump -u trillian -p cds
Enter password: ****
# MySQL dump 8.16
#
# Host: localhost    Database: cds
#------------------------------------------------------
# Server version        3.23.47-nt

#
# Table structure for table 'alben'
#

CREATE TABLE alben (
  id int(11) NOT NULL auto_increment,
  id_interpret int(11) default NULL,
  album char(40) default NULL,
  PRIMARY KEY  (id)
) TYPE=MyISAM;

#
# Dumping data for table 'alben'
#

INSERT INTO alben VALUES (1,1,'Making movies');
INSERT INTO alben VALUES (2,2,'Spirit of Eden');
...
   
   
   

Die Sache hat allerdings noch zwei Schönheitsfehler. Zum Einen muss wie
bereits erwähnt die Bildschirmausgabe in eine Datei umgeleitet werde. Dies
erfolgt wie gewohnt mit > dateiname.

Zum Anderen stört die durch die Option -p verursachte Anforderung
des Passwortes. Der dadurch erzeugte Text  Enter password: ****
wird in die Backupdatei mit aufgenommen. Der Text kann dort vor einem zurückspielen
der Datenbank manuell gelöscht werden. Eleganter ist es aber dem Programm
mysqldump das Passwort gleich beim Kommandozeilenaufruf mitzugeben.
Leider geht das nur im Klartext.


   
    mysqldump -u trillian --password=dent cds > cds.bak
   
   
   


Das Ergebnis sieht wie folgt aus:

   
    # MySQL dump 8.16
#
# Host: localhost    Database: cds
#--------------------------------------------------------
# Server version        3.23.47-nt

#
# Table structure for table 'alben'
#

CREATE TABLE alben (
  id int(11) NOT NULL auto_increment,
  id_interpret int(11) default NULL,
  album char(40) default NULL,
  PRIMARY KEY  (id)
) TYPE=MyISAM;

#
# Dumping data for table 'alben'
#

INSERT INTO alben VALUES (1,1,'Making movies');
INSERT INTO alben VALUES (2,2,'Spirit of Eden');
INSERT INTO alben VALUES (3,1,'Brothers in arms');

#
# Table structure for table 'interpreten'
#

CREATE TABLE interpreten (
  id int(11) NOT NULL auto_increment,
  interpret char(30) default NULL,
  PRIMARY KEY  (id)
) TYPE=MyISAM;

#
# Dumping data for table 'interpreten'
#

INSERT INTO interpreten VALUES (1,'Dire Straits');
INSERT INTO interpreten VALUES (2,'Talk Talk');

#
# Table structure for table 'titel'
#

CREATE TABLE titel (
  id int(11) NOT NULL auto_increment,
  id_album int(11) default NULL,
  titel char(40) default NULL,
  dauer time default NULL,
  PRIMARY KEY  (id)
) TYPE=MyISAM;

#
# Dumping data for table 'titel'
#

INSERT INTO titel VALUES (1,1,'Tunnel of love','00:08:05');
INSERT INTO titel VALUES (2,1,'Romeo and Juliet','00:05:50');
INSERT INTO titel VALUES (3,1,'Skateaway','00:06:15');
INSERT INTO titel VALUES (4,1,'Expresso love','00:05:00');
INSERT INTO titel VALUES (5,1,'Hand in hand','00:04:46');
INSERT INTO titel VALUES (6,1,'Solid rock','00:03:17');
INSERT INTO titel VALUES (7,1,'Les boys','00:04:06');
INSERT INTO titel VALUES (8,2,'The rainbow (Eden, Desire)','00:23:11');
INSERT INTO titel VALUES (9,2,'Inheritance','00:05:24');
INSERT INTO titel VALUES (10,2,'I belive in you','00:06:16');
INSERT INTO titel VALUES (11,2,'Wealth','00:06:35');
INSERT INTO titel VALUES (12,3,'So far away','00:05:12');
INSERT INTO titel VALUES (13,3,'Money for nothing','00:08:26');
INSERT INTO titel VALUES (14,3,'Walk of life','00:04:12');
INSERT INTO titel VALUES (15,3,'Yout latest trick','00:06:33');
INSERT INTO titel VALUES (16,3,'Why worry','00:08:31');
INSERT INTO titel VALUES (17,3,'Ride across the river','00:06:58');
INSERT INTO titel VALUES (18,3,'The man\'s too strong','00:04:40');
INSERT INTO titel VALUES (19,3,'One world','00:03:40');
INSERT INTO titel VALUES (20,3,'Brothers in arms','00:06:59');
INSERT INTO titel VALUES (21,NULL,NULL,NULL);
   
   
   


Das Einlesen der ASCII-Datei cds.bak in die Datenbank cds erfolgt durch folgendes Kommando.


   
    C:\mysql\bin>mysql -u trillian -p cds < cds.bak
Enter password: ****

C:\mysql\bin>
   
   
   


8. Zugriff über ODBC
8.1 Prinzip

Im Folgenden wollen wir auf unsere MySQL Datenbank von MS Access aus zugreifen.
Dazu muss unter Windows zunächst eine sogenannte ODBC Datenquelle für unsere MySQL
Datenbank eingerichtet werden.

Da prinzipell jeder im Netz verfügbare Rechner als Datenbankserver dienen kann werden
Sie zwei ODBC Datenquellen einrichten. Zunächst eine auf Ihre cds Datenbank Ihres lokalen
Systems. Anschließend richten Sie eine ODBC Datenquelle auf eine MySQL Datenbank ein, die
von Spaetzle als Datenbankserver verwaltet wird. Der Namen der Datenbank ist ebenfalls cds.


Die folgende Grafik verdeutlicht noch einmal die Zusammenhänge.






8.2 ODBC Treiber für MySQL installieren

Um eine ODBC Datenquelle einrichten zu können muss zunächst ein Treiber für
die zugehörige Datenbank installiert werden.

Den Treiber für MySQL genannt MyODBC finden Sie auf der Homepage von MySQL
(www.mysql.com). Der Treiber wird nach dem Entpacken
wie unter Windows üblich installiert. Unter Windows NT/2000/XP müssen Sie dazu über
Administrationsrechte verfügen.

8.3 ODBC-Datenquelle einrichten

Das Einrichten der ODBC Datenquelle wird am Beipsiel eines Windows 2000
Systems gezeigt. Das Programm zum Einrichten von ODBC Datenquellen kann
unter Windows 2000 über
Start -> Systemsteuerung -> Verwaltung erreicht werden. Bei allen anderen Windows
Versionen finden Sie es sicherlich nach einigem Suchen irgendwo in der Systemsteuerung.





Nach einem Doppelklick auf Datenquellen (ODBC) öffnet sich der ODBC Datenquelleneditor,
der alle bereits installierten ODBC Datenquellen anzeigt.





Nach einem Klick auf Hinzufügen erhalten Sie die Möglichkeit eine neue
ODBC Datenquelle einzurichten.





Wählen Sie als Treiber den zuvor installieren MySQL ODBC Treiber aus und klicken
dann auf Fertig stellen. Danach erscheint der folgende Dialog, in dem Sie
alle Eintragungen für Ihre Datenbank vornehmen können.





Die folgende Abbildung zeigt die Eintragungen, die für den Zugriff auf
Ihre cds Datenbank Ihres lokal installierten MySQL Servers nötig sind.







Data Source Name: Ist der Name mit dem unter Windows auf die ODBC Datenquelle
zugegriffen werden kann.


Host/Server Name(or IP): Hier wird der Name oder die IP Adresse des Rechners eingetragen
auf dem der MySQL Server läuft. Für Ihren lokal installierten MySQL Server ist das localhost.


Database Name: Der Name der Datenbank. In Ihrem Fall cds.


User: Hier tragen Sie den Namen des Users ein, unter dessen Account der Zugriff
erfolgen soll.


Password: An dieser Stelle wird das Passwort für den zuvor eingetragenen User ein.
Aber Achtung: Jetzt kann jeder über die ODBC Quelle mit den Rechten des hier eingetragenen
Users auf die Datenbank zugreifen - auch ohne das zugehörige Passwort. Tipp: Wenn Sie kein
Passwort hier eintragen, wird dieses beim Datenbankzugriff von Ihnen erfragt.








Für den Zugriff auf die cds Datenbank, die durch den MySQL Server auf Spätzle zur Verfügung
gestellt wird muss lediglich der Host-Eintrag in spaetzle geändert werden. Datbenbankname,
User und Passwort wurden identisch angelegt. Geben Sie der Datenquellen einen Namen wie zum Beispiel
cdsspaetzle.


Bevor Sie mit einem Klick auf OK die Datenquelle speichern können Sie den Zugriff auf die
Datenbank mit einem Klick auf Test Data Source testen.

Die folgenden Abbildungen zeigen einen erfolgreichen und einen weniger erfolgreichen Test.









Nach einem Klick auf OK gelangen Sie wieder zur Übersicht der ODBC Datenquellen. Hier müssten nun
die beiden eingerichteten Datenquellen erscheinen.






8.4 Zugriff über MS Access

Nach dem Start von MS Access legen Sie eine neue leere Datenbank an. Da
Access alle Informationen in einer einzigen Datei ablegt, entspricht
dieser Vorgang im Grunde dem Anlegen einer Datenbankdatei - z.B.
c:\temp\huhu.mdb.

Lassen Sie sich im Datenbankfenser die Tabellen der Datenbank anzeigen.
Da die Datenbank neu angelegt wurde gibt es natürlich noch keine Tabellen.
Klicken Sie jetzt mit der rechten Maustaste in die freie Fensterfläche und
wählen Sie Tabellen verknüpfen.





Im Dialog Verknüpfen stellen Sie bei Dateityp ODBC Databases
ein.





Im nun erscheinenden Dialog Datenquellen auswählen werden nach
Auswahl des Reiters Computerdatenquellen alle auf Ihrem PC zur
Verfügung stehenden ODBC Datenquellen angezeigt. Hoffentlich auch die von
Ihnen zuvor angelegten ;-) .

Wählen Sie die gewünschte Datenquelle aus und klicken Sie dann auf OK.





Im folgenden Dialog werden Ihnen nun alle Tabellen der MySQL Datenbank angezeigt.
Wählen Sie alle aus und bestätigen Sie Ihre Wahl durch einen Klick auf OK.




Jetzt sind alle Tabellen verknüpft. Access kennzeichnet verknüpfte Tabellen durch das
Symbol einer Weltkugel. Durch einen Doppelklick können die Tabellen geöffnet und anschließen
bearbeitet werden.





Im folgenden Beispiel sehen Sie den Inhalt der Tabelle alben der MySQL Datenbank cds.





Eine Änderung der Daten - hier wird der Name des Albums Making movies in
Making my movies geändert - wird  erst nach dem Schließen der Tabelle an
den MySQL Server weitergeleitet.





Die folgenden beiden select Kommandos wurden in der MySQL Shell beide nach dem Ändern
des Album Titels ausgeführt. Einmal vor und einmal nach dem Schließen der Tabellenansicht
in MS Access.



   
    mysql> select * from alben;
+----+--------------+------------------+
| id | id_interpret | album            |
+----+--------------+------------------+
|  1 |            1 | Making movies    |
|  2 |            2 | Spirit of Eden   |
|  3 |            1 | Brothers in arms |
+----+--------------+------------------+
3 rows in set (0.00 sec)

mysql> select * from alben;
+----+--------------+------------------+
| id | id_interpret | album            |
+----+--------------+------------------+
|  1 |            1 | Making my movies |
|  2 |            2 | Spirit of Eden   |
|  3 |            1 | Brothers in arms |
+----+--------------+------------------+
3 rows in set (0.00 sec)

mysql>
   
   
   



MS Access speichert normalerweise alle Bestandteile der Datenbank wie Tabellen, Formulare, Bereichte usw. in der zugehörigen mdb-Datei (mdb = Microsoft Data Base). Werden verknüpfte Tabellen verwendet, enthält die mdb-Datei nur noch die Verknüfpung zu den Tabellen sowie die damit erstellten Formulare, Berichte usw.


Die auf dem Computer angelegten ODBC Datenquellen können auch von anderen Anwendungen genutzt werden. So kann zum Beispiel MS Word beim Erstellen von Serienbriefen auf die Daten einer MySQL Datbenbank zugreifen.

9 Zugriff über Perl

Mein sehr geschätzter Kollege Andreas Grupp
hat eine sehr schöne Einführung zu diesem Thema unter dem Titel:
 Erstellung dynamischer HTML-Seiten unter
Verwendung einer MySQL-Datenbank verfasst.

Versuchen Sie mit Hilfe dieser Seiten eine Verbindung zur cds Datenbank auf Spätzle aufzubauen und
ein paar SQL Kommandos abzusetzen.

9.1 Ein einfaches Konsolen Perl Script

Zur Hilfe gebe ich Ihnen noch das folgende Beispielscript an die
Hand, mit dem Sie auf der Konsolen (also Putty) mit Perl die cds Datenbank auf spaetzle abfragen können.



   
    #!/usr/bin/perl -w
#
# -w -> Warnungen ausgeben
#
# cdsabfrage.pl - Harald Bäurle
# Letzte Aenderung: 30.11.2004

# Compilerpragma strict um keine Fehler zu machen :-)
use strict;

# Perl Modul DBI wird für Zugriff auf Datenbank verwendet.
use DBI;

# Es wird versucht mit connect eine Datenbankverbindung aufzubauen.
# Es gilt: dbi:DriverName:database_name;host_name
# $dbh -> Database Handle
my $dbh = DBI->connect('dbi:mysql:cds;spaetzle','trillian','dent') ||
     die "Kann keine Verbindung zum MySQL-Server aufbauen: $DBI::errstr\n";

# SQL-Kommando wird vorbereitet
# $sth -> Statement-Handle
my $sth = $dbh->prepare('SELECT * FROM alben') ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

# Vorbereitetes Kommando wird abgesetzt.
$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

# Das Abfrageergenis wird als Array zurückgegeben und entsprechend weiterverarbeitet.
while (my @ergebnis = $sth->fetchrow_array ) {
     print $ergebnis[0] . " " .$ergebnis[1] . " " . $ergebnis[2] . "\n";
}


# Und alles wieder schoen aufraeumen.
$sth->finish;
$dbh->disconnect;
exit;
   
   
   



Das Scipt führt auf der Konsole zu folgender Ausgabe.



   
    baeurle@pasta:~/public_html/bkik/komt> ./cdsabfrage.pl
1 1 Making my movies
2 2 Spirit of Eden
3 1 Brothers in arms
baeurle@pasta:~/public_html/bkik/komt>
   
   
   



Erzeugen Sie aus der Datenbankafrage eine dynamische HTML-Seite.

9.2 Suchen nach einem Titel
Das Script


   
    #!/usr/bin/perl -w
#
# -w -> Warnungen ausgeben
#
# suchen.pl - Harald Bäurle
# Letzte Aenderung: 08.12.2005

# Compilerpragma strict um keine Fehler zu machen :-)
use strict;

# Perl Modul um elegant auf die per CGI übermittelten Daten zuzugreifen.
use CGI;

# Perl Modul DBI wird für Zugriff auf Datenbank verwendet.
use DBI;
my $dbh;
my $sql;
my $sth;

# In der Variable $lookat wird der Suchtext eingetragen.
my $form = new CGI;
my $lookat = $form->param('suchtext');

# Kopf der HTML Seite ausgeben.
print "Content-type: text/html\n\n";
print "<html><head><title>CD Suche</title></head><body>\n";

# Formular zum Eingeben des Suchtextes ausgeben
print "<form action=\"suchen.pl\" method=\"get\">";
print "Suchbegriff: <input type=\"text\" size=30 name=\"suchtext\"></input>";
print "<input type=\"submit\" value=\"Suchen\"></input></form>";


# Nur wenn ein Suchtext uebergeben wurde erfolgt die Datenbankabfrage
# und die Ausgabe des Ergebnisses
if ($lookat){

# Es wird versucht mit connect eine Datenbankverbindung aufzubauen.
# Es gilt: dbi:DriverName:database_name;host_name
# $dbh -> Database Handle
$dbh = DBI->connect('dbi:mysql:cds;localhost','trillian','dent') ||
     die "Kann keine Verbindung zum MySQL-Server aufbauen: $DBI::errstr\n";

$sql = "select
             titel.titel, titel.dauer, alben.album, interpreten.interpret
           from
             titel, alben, interpreten
           where
             titel like \"%$lookat%\"
             and
             titel.id_album = alben.id
             and
             alben.id_interpret = interpreten.id;";

# SQL-Kommando wird vorbereitet
# $sth -> Statement-Handle
$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

# Vorbereitetes Kommando wird abgesetzt.
$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

# Ab hier wird das Ergebnis der Datenbankabfrage als Tabelle ausgegeben
print "<b>Suchergebnis:</b><table border=1>\n";
print "<tr><th>Titel:</th><th>Dauer:</th><th>Album:</th><th>Interpret:</th></tr>";

while (my @ergebnis = $sth->fetchrow_array ) {
     print "<tr>";
     print "<td>" . $ergebnis[0] . "</td>";
     print "<td>" . $ergebnis[1] . "</td>";
     print "<td>" . $ergebnis[2] . "</td>";
     print "<td>" . $ergebnis[3] . "</td>";
     print "</tr>\n";
}

print "</table>";

} # Ende der Ausgabe der Treffer der Datenbankabfrage

# Linkliste fuer die anderen Perl-Scripte
print "<br><br>Links:\n";
print "<a href=\"suchen.pl\">SUCHEN</a>\n";
print "<a href=\"interpreten.pl\">INTERPRETEN</a>\n";
print "<a href=\"alben.pl\">ALBEN</a>\n";
print "<a href=\"titel.pl\">TITEL</a>\n";

# Ende der HTML Seite ausgeben
print "</body></html>";

# Und alles wieder schoen aufraeumen.
$sth->finish;
$dbh->disconnect;

# Wichtig nicht vergessen!
exit;   
   
   


Das Ergebnis im Browser



9.3 Neuen Interpreten einfügen
Das Script


   
    #!/usr/bin/perl -w
#
# -w -> Warnungen ausgeben
#
# interpreten.pl - Harald Bäurle
# Letzte Aenderung: 08.12.2005

# Compilerpragma strict um keine Fehler zu machen :-)
use strict;

# Perl Modul um elegant auf die per CGI übermittelten Daten zuzugreifen.
use CGI;

# Perl Modul DBI wird für Zugriff auf Datenbank verwendet.
use DBI;
my $sql;
my $sth;

# In der Variablen $newinterpret wird der neu anzulegende Interpet gespeichert.
# Soll ein Interpret geloescht werden, erhaelt $delid die id des Interpreten.
my $form = new CGI;
my $newinterpret = $form->param('interpret');
my $delid = $form->param('delinterpret');

# HTML Kopf ausgeben
print "Content-type: text/html\n\n";
print "<html><head><title>Interpreten</title></head><body>\n";


# Es wird versucht mit connect eine Datenbankverbindung aufzubauen.
# Es gilt: dbi:DriverName:database_name;host_name
# $dbh -> Database Handle
my $dbh = DBI->connect('dbi:mysql:cds;localhost','trillian','dent') ||
     die "Kann keine Verbindung zum MySQL-Server aufbauen: $DBI::errstr\n";

# Soll ein neuer Interpret angelegt werden?
if($newinterpret){

$sql = "insert into interpreten
                         (interpret)
                       values
                         (\"$newinterpret\")";

$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

}

# Soll ein Interpret geloescht werden?
if($delid){

$sql = "delete from interpreten where id=\"$delid\"";

$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

}

# SQL Kommando zur Ermittlung aller in der DB enthaltenen Interpreten
$sql = "select
          interpret, id
        from
          interpreten
        ";

$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";


# Liste der Interpreten ausgeben
print "<b>Interpreten:</b><table border=1>\n";
print "<tr><th>Interpret:</th></tr>\n";

# Das Abfrageergenis wird als Array zurückgegeben und entsprechend weiterverarbeitet.
while (my @ergebnis = $sth->fetchrow_array ) {
     print "<tr>";
     print "<td>" . $ergebnis[0] . "</td>";
     print "<td><a href=interpreten.pl?delinterpret=" . $ergebnis[1] . ">loeschen</a></td>";
     print "</tr>\n";
}

print "</table>";

# Formular zum Anlegen neuer Interpreten ausgeben
print "<br><br><b>Neuen Interpreten anlegen?</b>\n";
print "<form action=\"interpreten.pl\" method=\"get\">";
print "Name: <input type=\"text\" size=30 name=\"interpret\"></input>";
print "<input type=\"submit\" value=\"Anlegen\"></input></form>";

# Linkliste fuer die anderen Perl-Scripte
print "<br><br>Links:\n";
print "<a href=\"suchen.pl\">SUCHEN</a>\n";
print "<a href=\"interpreten.pl\">INTERPRETEN</a>\n";
print "<a href=\"alben.pl\">ALBEN</a>\n";
print "<a href=\"titel.pl\">TITEL</a>\n";

# Ende der HTML-Seite ausgeben
print "</body></html>";

# Und alles wieder schoen aufraeumen.
$sth->finish;
$dbh->disconnect;

# Wichtig nicht vergessen!
exit;  
   
   


Das Ergebnis im Browser




9.4 Neues Album einfügen
Das Script


   
    #!/usr/bin/perl -w
#
# -w -> Warnungen ausgeben
#
# alben.pl - Harald Bäurle
# Letzte Aenderung: 08.12.2005

# Compilerpragma strict um keine Fehler zu machen :-)
use strict;

# Perl Modul um elegant auf die per CGI übermittelten Daten zuzugreifen.
use CGI;

# Perl Modul DBI wird für Zugriff auf Datenbank verwendet.
use DBI;
my $sql;
my $sth;

# In der Variablen $newalbum wird der Name des neu anzulegnden Albums gespeichert.
# In der Variablen $id_interpret wird die zugehoerige ID des Interpreten abgelegt.
# Soll ein Album geloescht werden, erhlaelt $delid die id des Albums.
my $form = new CGI;
my $newalbum = $form->param('album');
my $id_interpret = $form->param('interpret');
my $delid = $form->param('delalbum');

# HTML Kopf ausgeben
print "Content-type: text/html\n\n";
print "<html><head><title>Alben</title></head><body>\n";

# Es wird versucht mit connect eine Datenbankverbindung aufzubauen.
# Es gilt: dbi:DriverName:database_name;host_name
# $dbh -> Database Handle
my $dbh = DBI->connect('dbi:mysql:cds;localhost','trillian','dent') ||
     die "Kann keine Verbindung zum MySQL-Server aufbauen: $DBI::errstr\n";

# Soll ein neues Album angelegt werden?
if($newalbum){

$sql = "insert into alben
           (album, id_interpret)
        values
           (\"$newalbum\", \"$id_interpret\")";

$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";
}

# Soll ein Album geloescht werden?
if($delid){
  $sql = "delete from alben where id=\"$delid\"";

  $sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

  $sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";
}

# SQL Kommando zur Ermittlung aller in der DB enthaltenen Alben.
$sql = "select
          alben.album, interpreten.interpret, alben.id
        from
          alben, interpreten
        where
          alben.id_interpret=interpreten.id;";

$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";

$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

# Liste der Alben ausgeben
print "<b>Alben:</b><table border=1>\n";
print "<tr><th>Album:</th><th>Interpret:</th></tr>\n";

# Das Abfrageergenis wird als Array zurückgegeben und entsprechend weiterverarbeitet.
while (my @ergebnis = $sth->fetchrow_array ) {
     print "<tr>";
     print "<td>" . $ergebnis[0] . "</td>";
     print "<td>" . $ergebnis[1] . "</td>";
     print "<td><a href=alben.pl?delalbum=" . $ergebnis[2] . ">loeschen</a></td>";
     print "</tr>\n";
}
print "</table>";

# Formular zum Anlegen neuer Alben ausgeben.
print "<br><br><b>Neues Album anlegen?</b>\n";
print "<form action=\"alben.pl\" method=\"get\">";
print "Name: <input type=\"text\" size=30 name=\"album\"></input>";
print "Interpret: <select name=\"interpret\" size=\"1\">";

$sql = "select id, interpret from interpreten";
$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";
$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";
while (my @ergebnis = $sth->fetchrow_array ){
  print "<option value=\"". $ergebnis[0] . "\">" . $ergebnis[1] . "</option>\n";
}
print "</select>\n";
print "<input type=\"submit\" value=\"Anlegen\"></input></form>";

# Linkliste für die anderen Perl-Scripte
print "<br><br>Links:\n";
print "<a href=\"suchen.pl\">SUCHEN</a>\n";
print "<a href=\"interpreten.pl\">INTERPRETEN</a>\n";
print "<a href=\"alben.pl\">ALBEN</a>\n";
print "<a href=\"titel.pl\">TITEL</a>\n";

# Ende der HTML-Seite ausgeben
print "</body></html>";

# Und alles wieder schoen aufraeumen.
$sth->finish;
$dbh->disconnect;

# Wichtig nicht vergessen!
exit;   
   
   



Das Ergebnis im Browser



9.5 Neuen Titel einfügen
Das Script


   
    #!/usr/bin/perl -w
#
# -w -> Warnungen ausgeben
#
# titel.pl - Harald Bäurle
# Letzte Aenderung: 08.12.2005

# Compilerpragma strict um keine Fehler zu machen :-)
use strict;

# Perl Modul um elegant auf die per CGI übermittelten Daten zuzugreifen.
use CGI;

# Perl Modul DBI wird für Zugriff auf Datenbank verwendet.
use DBI;
my $sql;
my $sth;

# In $titel steht der Titelname und in $newdauer die Dauer des neu
# anzulegenden Titels. $id_album erhaelt die ID des zugeoerigen Albums.
# Soll ein Titel geloescht werden, enthaelt $delid die ID des Titels.
my $form = new CGI;
my $newtitel = $form->param('titel');
my $newdauer = $form->param('dauer');
my $id_album = $form->param('album');
my $delid = $form->param('deltitel');

# HTML Kopf ausgeben
print "Content-type: text/html\n\n";
print "<html><head><title>Titel</title></head><body>\n";

# Es wird versucht mit connect eine Datenbankverbindung aufzubauen.
# Es gilt: dbi:DriverName:database_name;host_name
# $dbh -> Database Handle
my $dbh = DBI->connect('dbi:mysql:cds;localhost','trillian','dent') ||
     die "Kann keine Verbindung zum MySQL-Server aufbauen: $DBI::errstr\n";

# Soll ein neuer Titel angelegt werden?
if($newtitel){
  $sql = "insert into titel
             (titel, dauer, id_album)
           values
             (\"$newtitel\", \"$newdauer\", \"$id_album\")";
$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";
$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";
}

# Soll ein Titel geloescht werden?
if($delid){
  $sql = "delete from titel where id=\"$delid\"";
  $sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";
  $sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";
}

# SQL Kommando zur Ermittlung aller in der DB enthaltenen Titel
$sql = "select
          titel.titel, titel.dauer, alben.album, interpreten.interpret, titel.id
        from
          titel, alben, interpreten
        where
          titel.id_album = alben.id and alben.id_interpret = interpreten.id;";

$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";
$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

# Liste der Titel ausgeben
print "<b>Titel:</b><table border=1>\n";
print "<tr><th>Titel:</th><th>Dauer:</th><th>Album:</th><th>Interpret</th></tr>\n";

# Das Abfrageergenis wird als Array zurueckgegeben und entsprechend weiterverarbeitet.
while (my @ergebnis = $sth->fetchrow_array ) {
     print "<tr>";
     print "<td>" . $ergebnis[0] . "</td>";
     print "<td>" . $ergebnis[1] . "</td>";
     print "<td>" . $ergebnis[2] . "</td>";
     print "<td>" . $ergebnis[3] . "</td>";
     print "<td><a href=titel.pl?deltitel=" . $ergebnis[4] . ">loeschen</a></td>";
     print "</tr>\n";
}
print "</table>";

# Formular zum Anlegen neuer Titel ausgeben
print "<br><br><b>Neuen Titel anlegen?</b>\n";
print "<form action=\"titel.pl\" method=\"get\">";
print "Name: <input type=\"text\" size=30 name=\"titel\"></input>";
print "Dauer (HH:MM:SS): <input type=\"text\" size=10 name=\"dauer\"</input>";
print "Album: <select name=\"album\" size=\"1\">";

$sql = "select id, album from alben";
$sth = $dbh->prepare($sql) ||
     die "Kann Statement nicht vorbereiten: $DBI::errstr\n";
$sth->execute ||
     die "Kann Abfrage nicht ausfuehren: $DBI::errstr\n";

while (my @ergebnis = $sth->fetchrow_array ){
  print "<option value=\"". $ergebnis[0] . "\">" . $ergebnis[1] . "</option>\n";
}
print "</select>\n";
print "<input type=\"submit\" value=\"Anlegen\"></input></form>";

# Linkliste fuer die anderen Perl-Scripte
print "<br><br>Links:\n";
print "<a href=\"suchen.pl\">SUCHEN</a>\n";
print "<a href=\"interpreten.pl\">INTERPRETEN</a>\n";
print "<a href=\"alben.pl\">ALBEN</a>\n";
print "<a href=\"titel.pl\">TITEL</a>\n";

# Ende der HTML-Seite ausgeben.
print "</body></html>";

# Und alles wieder schoen aufraeumen.
$sth->finish;
$dbh->disconnect;

# Wichtig nicht vergessen!
exit;   
   
   



Das Ergebnis im Browser






Letzte Änderung: 08.12.2005 - (c) Dipl.-Gwl., Dipl.-Ing.
(FH) H. Bäurle - Elektronikschule Tettnang-