![[Top bar]](../../common/images/Topbar-en.gif){kind=small}
![[Bottom bar]](../../common/images/Bottombar-en.gif){kind=small}
![[Photo of the Author]](../../common/images/Who.gif)
by Jose M. Fernández Content: |
![[Illustration]](../../common/images/illustration21.jpg)
Abstract:
MySQL ist ein SQL (Structured Query Language) Datenbank Server, der von zahlreichen Plattformen, einschließlich Linux, unterstützt wird. Seine Linuxversion ist mit dem Ziel einer schnellen Performance entworfen worden.
MySQL ist ein SQL (Structured Query Language) Datenbank Server. Es ist eine Client-Server Applikation, die aus einem Server und zahlreichen Clients besteht.
Eine SQL Datenbank zu diskutieren ist sehr komplex, da man dazu zu den Anfängen von relationalen Datenbanksystemen gehen müßte, aber die Absicht dieses Artikels ist nicht so hochgesteckt, sondern wir versuchen einfach, eine spezifische Implementation eines SQL Servers zu beschreiben und zu demonstrieren.
Als eine historische Erinnerung laßt uns erwähnen, daß IBM 1981 damit begann, SQL zu vermarkten, und daß dieses Produkt seitdem eine grundlegende Rolle in der Entwicklung von relationalen Datenbanken gespielt hat. IBM schlug dem American National Standards Institute (ANSI) eine Version von SQL vor (die später akzeptiert wurde) und seitdem wird SQL allgemein bei relationalen Datenbanken benutzt. DB2, im Moment die beliebteste Datenbank dieses Typs, wurde 1983 entwickelt und wird zumeist in Mainframeumgebungen eingesetzt.
In der GNU Welt ist MySQL die Datenbank, die am häufigsten im Kontext von relationalen Datenbanken unter Linux genannt wird. Diese Applikation ist in keiner der Linuxdistributionen erhalten, weil es keine per se GNU Lizenz hat. Die kommerzielle Nutzung von MySQL oder einer Applikation, die sie verwendet, erfordert den Kauf einer Lizenz.
Dieser Datenbankserver wird (das ist sogar explizit in der Dokumentation erwähnt) als der schnellste und robusteste Datenbankserver für große und kleine Datenvolumen angesehen (natürlich muß man MySQL mit Servern der gleichen Kategorie vergleichen). Wie wir später diskutieren werden, wird die hohe Geschwindigkeit bei der Verarbeitung auf Kosten von einer Anzahl nicht implementierter Features des SQL Standards erreicht.
MySQL ist verfügbar (Sources und Binary) für: Linux 2.0+, SCO, Solaris 2.5, 2.6, SUNOS 4.x, BSDI 2.x, 3.0, SGI IRIX 6.x, AIX 4.x, DEC UNIX 4.x, HPUX 10.20, Windows 95 (verzeih mir)
Die freie Version wurde von Michael Windenis geschrieben, und die kommerzielle Version wird von TCX Datakonsulter AB vertrieben.
Natürlich ist es vor dem Installieren der Datenbank notwendig, die Quellen vom Web runterzuladen:
http://www.tcx.seZuerst müssen wir uns entscheiden, ob wir die Quell- oder die Binär- Distribution herunterladen wollen. Die letzte Option ist am leichtesten zu installieren, aber sie muß für unsere Zielplattform verfügbar sein (sie ist allerdings für die meisten beliebten Plattformen vorhanden).
Nach dem Herunterladen der Datei:
mysql-Version.tar.gzmußt du sie auspacken. Dies kann auf viele verschiedene Arten gemacht werden, ich persönlich bevorzuge:
ich lasse den tar Befehl von dem Verzeichnis /usr/local aus laufen,
weshalb die herausgezogenen Dateien unter
/usr/local/mysql-3.20.32a-pc-linux-gnu-i586
gefunden werden können
Dies ist kein sehr praktischer Name, weshalb empfohlen wird (das wird auch im Installationshandbuch erwähnt), einen symbolischen Link darauf zu setzen
> ln -s mysql-3.20.32a-pc-linux-gnu-i586/bin mysqlDas mysql Verzeichnis enthält das folgende:
Unser Softlink auf mysql-3.20.32a-pc-linux-gnu-i586 heißt mysql. Durch
cd /usr/local/mysql
gelangen wir in das binäre Verzeichnis von MySQL.
Wenn alles gut gegangen ist, dann bist du jetzt startklar, um den
Datenbankserver zu starten.
Dekomprimiere die Quellen und packe sie aus wie im vorigen Abschnitt vorgeschlagen.
Die Quell- Installation kommt mit einer großen Menge an Dokumentation zum Installationsprozeß. Es gibt Informationen über bekannte Bugs, plattformspezifische Anmerkungen sowie Vorschläge für verschiedene Betriebssysteme, Beschreibungen der Parameter für einige Konfigurationen und sogar eine FAQ-Sammlung. Wenn der Installationsprozeß beim ersten Mal geklappt hat, (und das wäre das erste Mal, daß so etwas vorkäme), wäre das Ergebnis ein binäres Verzeichnis, wie das unter binärer Installation beschriebene.
Eine Source-Installation ist nur Benutzern mit großer Erfahrung in der Installation und Kompilation von Programmen zu empfehlen, die genug Zeit und Geduld haben, die zahlreichen Probleme anzugehen, die zweifelslos während des Prozesses entstehen..
Nach der Installation auf dem Server in deinem System nach einer der beiden beschriebenen Methoden sollte das Verzeichnis :
/usr/local/mysql-3.20.32a-pc-linux-gnu-i586diese Dateien und Verzeichnisse enthalten:
Für weitere Informationen über die Installation auf dem Server schau in die Dateien README, TODO, INSTALL, mysql-faq, etc., die sehr vollständig und gut sind (ein Teil dieses Artikels basiert auf ihnen).
Das Verzeichnis /data bekommt alle Datenbanken, die du auf deinem System erzeugst, sie werden in verschiedenen Unterverzeichnissen gespeichert. Die anfängliche Installation erzeugt per default die Archive, die die Sicherheitsfeatures im Server unterstützen, diese Datenbank ist “mysql”.
In /bench gibt es einige SQL Beispiele. Beachte, daß die Installationen vom Quellcode eine größere Menge an Beispielen enthalten als die binären Installationen.
Jetzt enthält das Verzeichnis /share die Fehlermeldungen für den Server in allen verfügbaren Sprachen.
/include und /lib enthalten die header Dateien und die Bibliotheken der Distributionen.
Wie erwartet, enthält /bin alle ausführbaren Programme, die wichtigsten darunter sind:
Eine SQL Shell (mit GNU Lesezeile). Es kann interaktiv genutzt werden, muß es aber nicht.
Administrationswerkzeuge. Create (Erzeuge)/Delete (Lösche) Datenbanken. Informationen über Prozesse und die Version.
SQL “deamon” .Es muß immer laufen.
Zeigt Informationen über Datenbanken, Tabellen und Felder.
startet “mysqld”.
Script, um die Privilegien einer Kombination aus Host, Benutzer und Datenbank zu prüfen.
wird benutzt, um über mögliche Bugs, die auf dem Server gefunden wurden, zu berichten.
Erzeugt riesige Tabellen mit default Privilegien, man läßt es normalerweise nach der ersten Installation eines neuen Systems laufen.
Überprüft, optimiert und repariert Tabellen.
Das Sicherheitssystem von MySQL garantiert, daß jeder Benutzer nur streng autorisierte Aufgaben ausführen kann (nicht mehr und nicht weniger).
Das System wählt die Privilegien für eine Transaktion nach dem Muster “WELCHER BENUTZER” von “WELCHEM HOST” ist verbunden mit einer “GEGEBENEN DATENBANK”. Das Erlaubnissystem basiert auf den Inhalten von drei Tabellen, “USER”, “HOST” und “DB” der Datenbank “mysql”.
Die Spalten dieser drei Tabellen sind:
| Tables |
|---|
| db |
| host |
| user |
| Field | Type | Null | Key | Default | Extra |
| Host | char(60) | PRI | |||
| Db | char(32) | PRI | |||
| User | char(16) | PRI | |||
| Select_priv | char(1) | N | |||
| Insert_priv | char(1) | N | |||
| Update_priv | char(1) | N | |||
| Delete_priv | char(1) | N | |||
| Create_priv | char(1) | N | |||
| Drop_priv | char(1) | N |
| Field | Type | Null | Key | Default | Extra |
| Host | char(60) | PRI | |||
| Db | char(32) | PRI | |||
| Select_priv | char(1) | N | |||
| Insert_priv | char(1) | N | |||
| Update_priv | char(1) | N | |||
| Delete_priv | char(1) | N | |||
| Create_priv | char(1) | N | |||
| Drop_priv | char(1) | N |
| Field | Type | Null | Key | Default | Extra |
| Host | char(60) | PRI | |||
| User | char(16) | PRI | |||
| Password | char(16) | ||||
| Select_priv | char(1) | N | |||
| Insert_priv | char(1) | N | |||
| Update_priv | char(1) | N | |||
| Delete_priv | char(1) | N | |||
| Create_priv | char(1) | N | |||
| Drop_priv | char(1) | N | |||
| Reload_priv | char(1) | N | |||
| Shutdown_priv | char(1) | N | |||
| Process_priv | char(1) | N | |||
| File_priv | char(1) | N |
Es kann entschieden werden, ob ein Benutzer zum Benutzen von den Befehlen SELECT, INSERT, UPDATE, und DELETE von Dateien in einer Tabelle autorisiert werden soll.
Es ist auch möglich, das Erzeugen (CREATE) oder Löschen (DROP) von Tabellen oder Datenbanken zu erlauben.
Interessant ist auch, daß Rechte für administrative Befehle wie “shutdown”, “reload”, “process”, etc... vergeben werden können.
Was für die Benutzer aktuell erlaubt ist, kann mit dem Script “mysqlaccess” inspiziert werden.
Ein HOST muß immer ein “local host ”, eine IP Nummer oder ein SQL Ausdruck sein. Wenn in der Tabelle “db” die host Spalte leer ist, bedeutet das jeder host in der Tabelle von “host”. Wenn dagegen in der Tabelle “host” oder “user” die Spalte host leer ist, dann heißt das, daß jeder HOST eine TCP Verbindung mit unserem Server aufbauen kann.
Db ist der Name der Datenbank.
Eine leere “USER” Spalte bedeutet irgendein Benutzername.
Der schnellste Weg, den Server zu starten, ist der folgende Befehl:
mysql.server startDieselben Operationen können auch mit dem Script safe_mysql ausgeführt werden, wie im Installationshandbuch beschrieben, aber der eine wie der andere Weg führt dazu, daß die Datei den deamon “mysqld” ausführt.
Wie leicht verstanden werden kann, ist es notwendig, den Server zu starten, um irgendeine Operation mit der Datenbank durchzuführen; mit dem laufenden Server können wir Operationen wie “mysqladmin” laufen lassen, deren Syntax wie folgt ist:
mysqladmin [OPTIONEN] Befehl Befehl …wobei OPTIONEN das folgende sein kann:
wobei Befehl eines oder mehreres der folgenden sein kann:
Wenn du z.B. den folgenden Befehl laufen läßt,:
mysqladmin create newdatabasewird eine neue Datenbank mit dem Namen "newdatabase" erzeugt
Wir können die auf dem Server laufenden Prozesse mit dem folgenden Befehl sehen
mysqladmin processlistEin weiterer wichtiger Befehl ist mysqlshow, der uns die verfügbaren Datenbanken sehen läßt. Z.B. ergibt die Ausführung dieses Befehls ohne Optionen:
> mysqlshow+-----------+ | Databases | +-----------+ | mysql | | people | | test | +-----------+
In der Einleitung haben wir schon erwähnt, daß dieser Server als einer der schnellsten innerhalb seiner Klasse für große und kleine Datenmengen betrachtet wird und wir erwähnten auch, daß diese Performance auf Kosten der Nichtimplementierung einer Reihe von SQL- Features ging, die meiner Meinung nach wichtig sind. Zwei wichtige Features, die fehlen, sind Trigger und die transaktionale Logik.
Trigger sind nichts weiter als ein kleiner Codeteil, der "ausgelöst wird" --ausgeführt wird-- , wenn eine bestimmte Operation auf der Datenbank ausgeführt wurde (update, löschen, etc..). Offensichtlich verschlingt der Test für die Triggerbedingung sowie ihre Verwaltung Resourcen des Systems und das ist der einzige Grund, warum sie nicht implementiert wurden.
Die Konsistenz zwischen Tabellen in einer relationalen Datenbank ist sehr wichtig. SQL bietet daher ein mehr oder weniger einfaches Werkzeug an, um für diese Konsistenz zu sorgen: "Transaktionale Logik". Es ist der Server, der die Mechanismen zum Blocken von Dateien bereitstellen sollte sowie für die Konsolidierung und das Zurückkommen von Operationen in der Datenbank. Nun gut, MySQL unterstützt diese Transaktionen nicht, um die Geschwindigkeit des Servers zu verbessern (zumindest steht es so in der Dokumentation), die einzige Hilfe, die wir haben, sind die Befehle LOCK Tabellen / UNLOCK Tabellen, die das Blockieren von Tabellen anderer Benutzer erlauben, es aber nicht ermöglichen, Operationen, die schon auf den Daten ausgeführt worden sind, wieder zu entfernen.
Unter Einbeziehung der Beschränkungen des Servers werden wir uns als nächstes ein paar SQL Befehle anschauen, und zwar nicht mit dem Ziel, SQL Befehle per se zu analysieren, sondern, um uns anzusehen, wie dieser Server sie implementiert hat.
Nachdem wir den Server gestartet haben, sind wir bereit, um Anweisungen zu senden. Laßt uns z.B. eine Datenbank namens "people" erzeugen, die aus den drei Tabellen "clients", "states", "counties" besteht. Es ist ein sehr einfaches und nicht sehr nützliches Beispiel, aber es zeigt uns die Idee, wie man Daten in einem wirklichen Fall verändert. Zuerst muß gesagt werden, daß diese Operationen auf verschiedenen Wegen ausgeführt werden können: durch ein API in C, C++ JAVA oder durch ein ODBC, wenn wir unter Windows95 arbeiten (Verzeih mir noch einmal), wir können auch die von der Distribution bereitgestellte Shell benutzen. Ich werde mich für die letzte Methode entscheiden, da es für unseren Zweck ausreichend ist und wir dadurch vermeiden, die Spezifikationen anderer Programmiersprachen beschreiben zu müssen.
Die Mysql Shell kann durch den folgenden Ausdruck gestartet werden:
mysql databasenameNachdem das Shellprompt erscheint, können wir damit beginnen, Befehle an den Server zu senden.
Es ist auch möglich, die Shell im batch mode zu benutzen, durch Laufenlassen von:
mysql -e (“SQL command …… “)databasenamedies sendet einen SQL Befehl an den Server.
Um die Datenbank "people" aus unserem Beispiel zu erzeugen, führen wir den folgenden Befehl aus:
mysqladmin create peopleLaß die Shell dann so laufen:
mysql peoplejetzt können wir damit beginnen, von der Shell aus Befehle an den Server zu senden, z.B. um die Tabellen anzuschauen, die innerhalb der Datenbank verfügbar sind:
> show tables /gDas System antwortet:
+-------------+ | Tables | +-------------+ | clients | | counties | | states | +-------------+
Alle Befehle, die von der Shell zu dem Server geschickt werden, enden mit /g, was das Ende des Befehls angibt und sie an den Server zur Bearbeitung weitergibt.
Natürlich ist der einzige Weg, wie wir die obige Antwort erhalten konnten, die entsprechenden Tabellen vorher mit dem Befehl CREATE zu erzeugen. Ein typischer CREATE Befehl hat das folgende Aussehen:
CREATE TABLE clients
CREATE TABLE states
CREATE TABLE counties
(Cod_state INT(2) NOT NULL,
Cod_county INT(3) NOT NULL,
Description_c CHAR(30) NOT NULL,
PRIMARY KEY(Cod_state,Cod_county)) /g
Wenn wir als nächstes das folgende laufen ließen,
> show colums from clients from people /gwürden wir das folgende erhalten:
Database: people Table: clients Rows: 4 +--------------+----------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +--------------+----------+------+-----+---------+-------+ | NIF | char(9) | |PRI | | | | Name | char(15) | YES | | | | | Family_name | char(35) | | | | | | Address | char(50) | | | | | | City | int(5) | | | 0 | | | State | int(2) | | | 0 | | | Phone | int(9) | YES | | | | | Date | date | YES | | | | +--------------+----------+------+-----+---------+-------+
Database: people Table: states Rows: 3 +-----------------+----------+------+-----+---------+-------+ | Field | Type | Null | Key| Default | Extra | +-----------------+----------+------+-----+---------+-------+ | Cod_state | int(2) | | PRI | 0 | | | Descripcion_s | char(30) | | | | | +-----------------+----------+------+-----+---------+-------+
Database: people Table: counties Rows: 9 +------------------+----------+------+-----+---------+-------+ | Field | Type | Null | Key| Default | Extra | +------------------+----------+------+-----+---------+-------+ | Cod_state | int(2) | | PRI | 0 | | | Cod_county | int(3) | | PRI | 0 | | | Descripcion_c | char(30) | | | | | +------------------+----------+------+-----+---------+-------+
Anschließend könnten wir dazu übergehen, Daten in jede der Tabellen einzufügen. Laßt uns den SQL Befehl INSERT benutzen, ohne dafür andere Programmiersprachen oder API Routinen heranzuziehen:
Um einen Record in die clients, counties und states Tabellen einzufügen, mach das folgende:
Um unseren Ausflug in die SQL Befehle abzuschließen, werden wir die Reihen, die in die Tabellen unserer laufenden Datenbank eingefügt wurden, auswählen. Laßt uns records aus der clients Tabelle auswählen und dabei die Auswahlbedingung variieren und zuerst aus der counties Tabelle auswählen:
> SELECT ALL Cod_state, Cod_county, Description_c from counties where Cod_state = 28 /gCod_state Cod_county Description_c 28 1 Fuenlabrada 28 2 Pozuelo 28 3 Madrid> SELECT ALL NIF,Name,Family_name,Address from clientes where City = 28001
NIF Name Family_name Address 23198623N JUAN ANDRES RUIZ MORALES C/ CATEDRAL 12 2B 5316828K PEDRO ROMERO DIAZ C/ HOLA 9 52312844J LUIS ALBERTO LISTO JIMENEZ C/ ROSA DE LOS VIENTOS 129 3I
Wir begannen diesen Artikel damit, zu sagen, daß die Absicht dieses Artikels war, die grundlegenden Eigenschaften eines spezifischen SQL Servers zu zeigen und wir wollten diesen Artikel nicht zu einer Liste von Rezepten und Befehlen, um MySQL benutzen zu können, werden lassen, sondern wollten stattdessen die Möglichkeiten und Grenzen dieser Software studieren; nur wenn wir eine Anwendung wie diese genau kennen, können wir wirklich den größten Nutzen, den sie zu bieten hat, daraus ziehen. MySQL läßt die Implementation von Triggern und transaktionaler Logik aus und macht dadurch die Verwaltung von Daten (Einfügen, Verändern, Löschen von records) von Mehrbenutzerapplikationen und von miteinander in Beziehung stehenden Tabellen sehr komplex. Trotzdem empfehle ich diesen Server für Anwendungen, die einen sehr schnellen Zugriff auf große Datenmengen erfordern.
Abschließend möchte ich erwähnen, daß ich die meisten Informationen für diesen Artikel aus der Dokumentation von MySQL erhalten habe, die bei der Distribution dabei war, sowie aus mehreren Artikeln in technischen Zeitschriften und einem schon gelblichen IBM Handbuch über SQL.
|
Webpages maintained by the LinuxFocus Editor team
© Jose M. Fernández LinuxFocus 1999 |
Translation information:
|
1999-10-01, generated by lfparser version 0.7