Praxis mit MySQL

Praxis mit MySQL

Nun wollen wir den MySQL Datenbank Server auch praktisch einsetzen. Um den MySQL Datenbank Server im Alltag anzusprechen, müssen wir die standardisierte Datenbanksprache "SQL" einsetzen. An dessen Handhabung muß man sich erst gewöhnen. Dazu haben wir ein Beispiel ausgearbeitet, welches SQL in der Praxis zeigt.

Basics

MySQL stellt eine Reihe von Klientprogrammen zur Verfügung. Wir benötigen hier nur das SQL-Interpreter. Dieses Programm setzt einzelne SQL-Kommandos an den MySQLDatenbankserver ab. Damit wir uns um keine Benutzerrechte kümmern brauchen, arbeiten wir als root-Benutzer. Dies ist zwar nicht elegant, aber als Beispiel zweckmäßig. Zuerst benötigen wir mal eine Datenbank. Unsere Datenbank hat die Aufgabe die Daten der aktuellen Hotel-Kunden zu verwalten. Gewöhnlich mietet jeder Kunde ein bestimmtes Zimmer für einen gewissen Zeitraum. Zur Absicherung läßt man sich überlicherweise den kompletten Namen und seine Telefon-Nummer geben. Diese Daten werden dann in der Datenbank abgelegt. Also erzeugen wir jetzt solch eine MySQL Datenbank.

MySQL-Datenbanken anlegen

Eine relationale Datenbank ist einfach zu erzeugen. Mittels des Kommandos CREATE DATABASE der SQL-Datenbanksprache kann man eine Datenbank anlegen. Dabei muß der Datenbankname als Parameter mit angegeben werden. Sollte diese Datenbank bereits existieren, gibt der SQL-Interpreter eine Fehlermeldung zurück. Nun legen wir mit CREATE DATABASE DB_HOTEL die Datenbank »db_hotel« an. Welche Datenbanken auf dem MySQLDatenbankserver bereitstehen, kann über das SQL-Statement SHOW DATABASES erfragt werden. Dort sollte jetzt auch unsere Datenbank vorzufinden sein. Im Detail sind das Ganze dann so aus:

Die Datenbanken »mysql« und »test« legt MySQL standardmäßig an. Während in derDatenbank mysql die Benutzerrechte hinterlegt sind, ist die Datenbank »test« leer. Konnte die Datenbank erfolgreich angelegt werden, ist dies an der Meldung »Query OK« zu erkennen. Allerdings haben wir hiermit noch keinen Zugriff auf diese Datenbank. Maß muß die betreffende Datenbank zuerst auswählen. Mittels des SQL-Statements USE DB_HOTEL ist dies schnell erledigt. Jetzt wollen wir natürlich auch Daten ablegen. Dazu muß bei jeder Datenbank eine konkrete interne Tabellenstruktur definiert werden. Darüber gibt man an, wie die Datenbank intern aufgebaut ist. Innerhalb solch einer Tabelle werden abgrenzbare Einheiten (Entitäten) abgelegt. In unserem Beispiel entspricht jeder Hotelkunde einer konkreten Entität oder Einheit. Zu jedem Hotelkunden gehören sein Name, die Telefonnummer, die Zeitspanne und sein Zimmertyp. Laut der Datenbanktheorie muß jede Tabelle standardmäßig über einen Primärschlüssel verfügen. Darüber wird intern die Verwaltung ermöglicht. Jeder Primärschlüssel entspricht einer einwandfrei identifizierbaren Kennung, welche nur einmal vorkommt. In jeder Tabelle kann es maximal ein einzigen Primärschlüssel geben. Mit Hilfe des Attributes PRIMARY KEY wird der eindeutiger Primärschlüssel festgelegt. Für den Primärschlüssel legen wir das separate Datenfeld ID an. Also legen wir die Datenbanktabelle »db_hotel_daten« an. Diese Tabelle enthält die Datenbankfelder Nachname, Vorname, Telefon-Nummer, Aufenthaltsdauer und den Zimmertyp Als Datentyp für die einzelnen Felder wird der Typ CHAR verwendet. So läßt sich auch die Länge des Datenfeldes konkret bestimmen. Über die Datenbanksprache SQL lässt sich über CREATE TABLE so eine Tabelle erzeugen. Hier die detailiertere Vorgehensweise:

mysql> use db_hotel;
Database changed
mysql> create table db_hotel_daten (
id char(3) not null,
nachname char(20),
vorname char(20),
telnr char(20),
zimmer char(20),
dauer char(3),
primary key (id));
Query OK, 0 rows affected (0.00 sec)

Ob die Tabelle erfolgreich angelegt werden konnte, ist an der Meldung »Query OK« zu erkennen. Alle Tabellen die in einer bestimmten Datenbank enthalten sind, lassen sich in SQL über SHOW TABLES auflisten. Dort sollte unsere neue Tabelle jetzt auftauchen.

mysql> show tables;
+---------------------+
| Tables in db_hotel |
+---------------------+
| db_hotel_daten |
+---------------------+
1 row in set (0.00 sec)

Der Datenbank-Tabellenaufbau

Jetzt ist natürlich ebenso wichtig, ob die Tabellenstruktur von MySQL auch korrekt angelegt

werden konnte. Dies kann über das SQL-Statement DESCRIBE DB_HOTEL_DATEN in

Erfahrung bringen. Dadurch wird der konkrete Aufbau der Tabelle angezeigt. Dort sind die

einzelnen Tabellenfelder mit ihren Datentypen aufgelistet. Ebenso ist dort angegeben,

welches Datenfeld als Verwaltungsschlüssel dient und ob ein Datenfeld zwigend einen Inhalt

besitzen muß. Zusätzlich gibt es Beschreibungstext für jedes Datenfeld.

mysql> describe db_hotel_daten;

+----------+----------+------+-----+---------+-------+

+----------+----------+------+-----+---------+-------+

| id | char(3) | | PRI | | |

+----------+----------+------+-----+---------+-------+

6 rows in set (0.00 sec)

Datenbank-Tabellen anpassen

Sollte die Datenbanktabelle fehlerhaft sein oder doch anders aussehen, kann dies

nachträglich geändert werden. Über die Datenbanksprache SQL läßt sich über ALTER TABLE

die Tabellenstruktur noch entsprechend anpassen. Hierüber läßt sich der Tabellenname noch

abändern. Ebenso kann ein hierüber geändert oder sogar gelöscht werden. Angenommen

man will den Tabellenname geändern haben. Über ALTER TABLE DB_HOTEL_DATEN

RENAME DB_HOTEL ist dies eine Leichtigkeit. Ebenso lassen sich einzelne Tabellenfelder

auch wieder löschen. Um das Tabellenfeld »vorname« zu löschen, hilft folgende

Kommandoanweisung ALTER TABLE DB_HOTEL DROP VORNAME. Genauso läßt sich der

Name eines Tabellenfeldes abändern. Dies geht über das Kommando ALTER DB_HOTEL

CHANGE ZIMMER AS ZIMMERTYP. Im Detail sieht das dann so aus:

mysql> alter table db_hotel_daten rename db_hotel;

Query OK, 0 rows affected (0.01 sec)

mysql> alter table db_hotel drop vorname;

Query OK, 0 rows affected (0.00 sec)

Records: 0 Duplicates: 0 Warnings: 0

mysql> alter table db_hotel change zimmer zimmertyp char(20);

Query OK, 0 rows affected (0.01 sec)

Records: 0 Duplicates: 0 Warnings: 0

mysql> describe db_hotel;

+-----------+----------+------+-----+---------+-------+

+-----------+----------+------+-----+---------+-------+

| id | char(3) | | PRI | | |

+-----------+----------+------+-----+---------+-------+

5 rows in set (0.00 sec)

Tabelle mit Daten bestücken

Nun sollte die Datenbanktabelle noch mit entsprechenden Daten gefüllt werden. Diese

Datenbasis kann mit Hilfe von SQL-Statements dann konkret analysiert werden. So kann

man verschiedene Sichten auf eine Datenbank aufbauen. Je nach Anwendungsbereich kann

man sich die Daten flexibel anzeigen lassen. Einzelne Datensätze lassen sich mit Hilfe des

SQL-Kommandos INSERT INTO in eine bestimmte Tabelle einfügen. Als Parameter muß der

Tabellenname dabei angegeben werden. Mit Hilfe des Attributes VALUES wird der Datensatz

konkret definiert. Dies ist die einfachste Variante. Es ist aber auch möglich über

INSERT...SELECT zu gehen. Hierbei werden die Informationen des Datensatzes über eine

Unterabfrage erzeugt und in die Tabelle geschrieben. Mittels des Kommandos SET läßt sich

angeben, in welche Tabellenfelder die Daten hineingeschrieben werden sollen. Wir legen

hier die Daten nach der einfachen Variante an. Dies sieht im Detail dann so aus:

mysql> insert into db_hotel values ("1","Peters","022854321","Doppel-

Deluxe","2Wochen");

Query OK, 1 row affected (0.00 sec)

mysql> insert into db_hotel values ("2","Frenkens","022889653","Einzel-

Einfach","1Wochen");

Query OK, 1 row affected (0.00 sec)

mysql> insert into db_hotel values ("3","Schnitzer","022856842","Einzel-

Einfach","1Tag");

Query OK, 1 row affected (0.00 sec)

mysql> insert into db_hotel values ("4","Altermann","022848765","Doppel-

Deluxe","5Tag");

Query OK, 1 row affected (0.00 sec)

Konnten die einzelnen Datensätze angelegt werden, ist dies an der Erfolgsmeldung »Query

OK« ersichtlich. Hiermit verrfügt unsere MySQL-Datenbank über vier Datensätze. Allerdings

ist es ziemlich umständlich alle SQL-Statements eingeben zu müssen. Es geht auch

einfacher.

Die Aufgaben einfacher machen

Der MySQL Interpreter kann aber auch Textdateien verarbeiten. Es ist kein Problem eine

bestimmte Textdatei in die Datenbank hineinzuladen. Hiermit läßt sich eine Menge Arbeit

komfortabel einsparen. Dazu steht das Kommando LOAD DATA INFILE bereit. Damit dies

auch funktioniert, muß die Textdatei einen bestimmten Aufbau besitzen. Hierfür sind die

einzelnen Dateninformationen für einen Datensatz durch ein Komma voneinander zu

trennen. Zusätzlich muß jedes Zeilenende überall mit einem Carried Return (\n)

abgeschlossen sein. Durch das Schlüsselwort LOCAL wird angegeben, daß sich die Datei im

lokalen Dateisystem befindet. Hierüber läßt sich ein konkretes Verzeichnis angeben. Eine

entsprechende Textdatei für unsere Tabelle »db_hotel«"könnte so aussehen:

Datei: db_hotel.txt

Peters,022854321,Doppel-Deluxe,2Wochen

Frenkens,022889653,Einzel-Einfach,1Wochen

Schnitzer,022856842,Einzel-Einfach,1Tag

Altermann,022848765,Doppel-Deluxe,5Tag

Mit dem folgenden SQL-Kommando ist es kein Problem die Textdatei »db_hotel.txt« mit

ihren Datensätzen in unsere Datenbanktabelle »db_hotel« reinzuladen. In welche

Tabellenfelder die Daten übernommen werden, wird über das Schlüsselwort FIELDS

TERMINATED BY angegeben. Das komplette Kommando hierzu sieht so aus:

mysql> load data local infile "/root/tmp/db_hotel.txt" into table db_hotel

fields terminated by","(nachname,telnr,zimmertyp,dauer);

Query OK, 4 rows affected (0.00 sec)

Records: 4 Deleted: 0 Skipped: 0 Warnings: 0

Datenbank-Abfragen definieren

Der Hauptnutzen einer Datenbank ist aber , daß man konkrete Abfragen definieren kann

und so verschiedene Sichten des Datenbestandes als Ergebnis erhält. Die Abfragen

definieren einen konkrete Fragestellung in einen bestimmten Kontext. Beispielsweise:

Wieviel Kunden haben ein Hotelzimmer laut der Tabelle »db_hotel« bestellt. Mittels einer

Abfrage in SQL läßt sich leicht eine Antwort hierauf finden. Über das Kommando SELECT *

FROM db_hotel werden uns alle Datensätze der Datenbanktabelle aufgelistet. Hieran sehen

wir, daß unsere eingegebenen Datensätze auch auf dem MySQL-Datenbankserver abgelegt

worden sind.

mysql> select * from db_hotel;

+----+-----------+-----------+----------------+-------+

+----+-----------+-----------+----------------+-------+

| 1 | Peters | 022854321 | Doppel-Deluxe | 2Wo |

| 2 | Frenkens | 022889653 | Einzel-Einfach | 1Wo |

| 3 | Schnitzer | 022856842 | Einzel-Einfach | 1Ta |

| 4 | Altermann | 022848765 | Doppel-Deluxe | 5Ta |

+----+-----------+-----------+----------------+-------+

4 rows in set (0.00 sec)

Komplexe SQL-Abfragen definieren

Je nach Situation lassen sich noch komplexere SQL-Abfragen definieren. Dies ist in der

Praxis häufig notwendig. Oft wird als Ergebnismenge eine Reihe von Datensätzen oder

Entitäten zurückgeliefert.

In unserer Tabelle db_hotel haben zwei Personen den Zimmertyp Doppel-Deluxe vorbestellt.

Wenn jedoch nicht genug Zimmer frei sind, kann dies zu Problemen führen. Also muß man

im Praxisalltag nachfragen, wieviel Personen einen bestimmten Zimmertyp bestellt haben.

Über die SQL Datenbanksprache ist dies einfach formuliert. Das folgende SQL-Statement

führt dies aus:

SELECT * FROM db_hotel WHERE zimmertyp = »Doppel-Deluxe«;

Die Anzahl der Ergebniszeilen gibt an, wieviel Personen diesen Zimmertyp bestellt haben.

Die Ausgabe der Ergebnismenge läßt sich dabei gezielt steuern. Beispielsweise kann man

angeben, daß die Ergebnismenge nach Nachnamen sortiert ausgegeben werden soll. Dies ist

nützlich, wenn die Ergebnismenge sehr groß ist und es nicht möglich ist den Überblick zu

wahren. Bei größeren Datenbanken kann schnell zu Ergebnismenge über 100

Datensatzeinträgen kommen. Beispielsweise können in einer Versicherungsdatenbank leicht

einige Einträge mit dem Famliennamen Müller zusammenkommen. So sehen die

entsprechenden SQL-Statements hierzu aus:

mysql> select * from db_hotel where zimmertyp = "Doppel-Deluxe";

+----+-----------+-----------+---------------+-------+

+----+-----------+-----------+---------------+-------+

| 1 | Peters | 022854321 | Doppel-Deluxe | 2Wo |

| 4 | Altermann | 022848765 | Doppel-Deluxe | 5Ta |

+----+-----------+-----------+---------------+-------+

2 rows in set (0.00 sec)

mysql> select * from db_hotel where zimmertyp = "Doppel-Deluxe" order by

nachname;

+----+-----------+-----------+---------------+-------+

+----+-----------+-----------+---------------+-------+

| 4 | Altermann | 022848765 | Doppel-Deluxe | 5Ta |

| 1 | Peters | 022854321 | Doppel-Deluxe | 2Wo |

+----+-----------+-----------+---------------+-------+

2 rows in set (0.00 sec)

Die Abfrage sieht zuerst sehr komplex aus, ist aber insgesamt leicht zu verstehen. Auch

sogenannte Wildcards lassen sich in SQL-Abfragen verwenden. Somit stellt es kein Problem

dar nachzufragen, welche Personen mit einem »M« im Nachnamen anfangen. Die

betreffende SQL Abfrage hierzu sieht so aus: SELECT * FROM db_hotel WHERE NACHNAME

= »P%«; Als Wildcard kommt hier das Zeichen »%« vor, womit alle Zeichen nach dem

Anfangsbuchstaben »M« akzeptiert werden. Hierüber lassen sich wirklich flexible Abfragen

sehr einfach realisieren. Bis jetzt waren die Abfrage-Definitionen leicht. Schwieriger wird es,

wenn Verknüpfungen innerhalb von SQL-Abfragen vorkommen. Beispielsweise wenn die

Datensätze gesucht werden sollen, wo eine Person den Namen »Peters« trägt und

gleichzeitig den Zimmertyp »Doppel-Deluxe« bestellt hat. Hierzu wird der UND-Operator

(&&) in der SQL-Abfrage verwendet. Die Abfrage dafür dürfte dann so aussehen: SELECT *

FROM db_hotel WHERE (nachname = »Peters«) && where (zimmertyp = »Doppel-Deluxe«).

Im Detail sehen die einzelnen Abfrageergebnisse dann so aus:

mysql> select * from db_hotel where (nachname like "P%");

+----+----------+-----------+---------------+-------+

+----+----------+-----------+---------------+-------+

| 1 | Peters | 022854321 | Doppel-Deluxe | 2Wo |

+----+----------+-----------+---------------+-------+

1 row in set (0.00 sec)

select * from db_hotel where (nachname="Peters") && (zimmertyp="Doppel-

Deluxe");

+----+----------+-----------+---------------+-------+

+----+----------+-----------+---------------+-------+

| 1 | Peters | 022854321 | Doppel-Deluxe | 2Wo

+----+----------+-----------+---------------+-------+

1 row in set (0.00 sec)

Mit SQL einfacher arbeiten

Die Arbeit braucht man aber nicht unbedingt über den mysql Client abzuwickeln. Denn dies

ist ziemlich umständlich und zeitraubend, da alle SQL-Kommandos am Prompt einzutippen

sind. Viel eleganter ist es über das Datenbankwerkzeug phpMyAdmin zu gehen. Über eine

grafische Oberfläche geht halt alles komfortabler. Dieses erlaubt einzelne SQL-Kommandos

innerhalb einer Textdatei abzulegen. So lassen sich komplette Vorgänge in Form von

einzelnen Abfragen zusammen an den MySQL-Datenbankserver übermitteln. Diese

einzelnen Kommandos werden dann zeilenweise vom MySQL Datenbankserver abgearbeitet.

Die MySQL-Befehle:

Mysql Dies ist der MySQL-Klient. Mit diesem können alle Adminstrationsaufgaben erledig

Mysql.server Dies ist das Start/Stop Skript. Hiermit wird der Server gestartet

Mysql_install_db Dies ist das Skript, welches zu Beginn die MySQL-Datenbank installiert

Mysql_set_permissio

Dies ist ein Perl-Skript, welche auf einfache Art die Rechte der MySQL-Datenbank

Mysqlshow Dies zeigt alle installierten Datenbanken des MySQL-Servers an

Mysql_access Dies ist ein Werkzeug, um die Rechte innerhalb von MySQL zu vergeben

Mysqdump Dies ist ein Werkzeug, um die Datenbankdaten oder auch einzelne Tabellen auf de

sichern

Mysqlimport Dies ist ein Werzeug, um ASCII Dateninhalte in eine Tabelle hineinzulesen