MySQL Einführung

1.  Mit MySQL zu arbeiten beginnen

Hintergrund

MySQL ist ein populärer Datenbankserver, der in verschiedensten Anwendungengebieten verwendet wird. SQL steht für (S)tructured (Q)uery (L)anguage, welche MySQL verwendet, um mit anderen Programmen zu kommunizieren. Darüber hinaus hat MySQL eigene erweiterte SQL Funktionen, um dem Benutzer weitere Funktionalität zu bieten. In diesem Dokument werfen wir einen Blick auf die initiale MySQL-Installation, das Einrichten der Datenbanken und Tabellen und erzeugen neuer Benutzer. Lassen Sie uns mit der Installation beginnen.

Installation von MySQL

Als erstes stellen Sie sicher, dass sie MySQL auf Ihrem System installiert haben. Für den Fall, dass Sie spezielle Funktionen benötigen, stellen Sie ebenfalls sicher, dass Sie die nötigen USE-Flags aktiviert haben, da diese Ihnen bei der Feinabstimmung Ihrer Installation helfen.

(Anzeigen verfügbarer USE-Flags)
# emerge --pretend --verbose mysql
(MySQL installieren)
# emerge mysql

Nach erfolgter Installation, werden Sie folgenden Hinweis sehen:

You might want to run:
"emerge --config =dev-db/mysql-[version]"
if this is a new install.

Da dies eine neue Installation ist, führen wir den Befehl aus. Sie müssen ENTER drücken, wenn Sie während der Konfiguration der MySQL-Datenbank danach gefragt werden. Die Konfiguration richtet die Haupt-MySQL-Datenbank ein, welche administrative Informationen wie Datenbanken, Tabellen, Benutzer, Zugriffsrechte und mehr beinhaltet. Die Konfiguration empfiehlt, dass Sie Ihr root-Passwort so früh wie möglich ändern. Wir werden das definitiv tun, andernfalls könnte jemand die Gelegenheit nutzen und unsere Standardinstallation des MySQL-Servers hacken.

(Ersetzen Sie [version] mit der Versionsnummer, die sie installiert haben.)
# emerge --config =dev-db/mysql-[version]
 * MySQL DATADIR is /var/lib/mysql
 * Press ENTER to create the mysql database and set proper
 * permissions on it, or Control-C to abort now...

   Preparing db table
   Preparing host table
   Preparing user table
   Preparing func table
   Preparing tables_priv table
   Preparing columns_priv table
   Installing all prepared tables

   To start mysqld at boot time you have to copy support-files/mysql.server
   to the right place for your system

   PLEASE REMEMBER TO SET A PASSWORD FOR THE MySQL root USER !
   To do so, issue the following commands to start the server
   and change the applicable passwords:
(Beachten Sie die nächsten 3 Zeilen)
   /etc/init.d/mysql start
   /usr/bin/mysqladmin -u root -h pegasos password 'new-password'
   /usr/bin/mysqladmin -u root password 'new-password'
   Depending on your configuration, a -p option may be needed
   in the last command. See the manual for more details.

(Einige spezifische MySQL-Informationen, die nicht zum Ebuild gehören,
wurden entfernt um dieses Dokument so konsistent wie möglich zu halten)

   * For security reasons you should set your MySQL root
   * password as soon as possible.

Das Konfigurationsskript hat die Befehle, die wir ausführen müssen um das Passwort zu setzen, bereits ausgegeben, daher führen wir diese jetzt aus.

# /etc/init.d/mysql start
 * Re-caching dependency info (mtimes differ)...
 * Starting mysqld (/etc/mysql/my.cnf) ...        [ ok ]
(Ersetzen Sie new-password durch Ihr gewünschtes Passwort)
# /usr/bin/mysqladmin -u root -h localhost password 'new-password'

Sie können das erfolgreiche Setzen des root-Passworts durch das Einloggen in Ihren MySQL-Server testen:

$ mysql -u root -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Der -u Schalter setzt den Benutzer, der sich einloggen wird. Der -h Schalter setzt den Host. Das ist üblicherweise localhost solange Sie keinen Remote-Server einrichten. Schließlich sagt -p dem MySQL-Client, dass Sie ein Passwort eingeben werden, um Zugriff zu Ihren Datenbanken zu erhalten. Beachten Sie die mysql> Eingabeaufforderung. Das ist, wo Sie all Ihre Befehle eingeben. Nachdem wir als root in der MySQL-Eingabeaufforderung sind, können wir beginnen unsere Datenbanken einzurichten.

2.  Einrichten der Datenbanken

Erzeugen einer Datenbank

Wir sind eingeloggt und eine MySQL-Eingabeaufforderung wird angezeigt. Lassen Sie uns zuerst einen Blick auf die vorhandenen Datenbanken werfen. Um das zu tun, verwenden wir den SHOW DATABASES Befehl.

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| mysql    |
| test     |
+----------+
2 rows in set (0.09 sec)

Ungeachtet der Tatsache, dass eine Testdatenbank schon existiert, werden wir unsere eigene erzeugen. Datenbanken werden mit dem CREATE DATABASE Befehl erzeugt. Wir werden eine mit dem Namen "gentoo" erzeugen.

mysql> CREATE DATABASE gentoo;
Query OK, 1 row affected (0.08 sec)

Diese Ausgabe lässt uns wissen, dass der Befehl ohne Fehler ausgeführt wurde. In diesem Fall wurde 1 Zeile modifiziert. Das ist eine Referenz zur Haupt-MySQL-Datenbank, welche eine Liste aller Datenbanken beinhaltet. Sie müssen sich über die Hintergründe nicht all zu viel Gedanken machen. Die letzte Zahl zeigt, wie schnell die Abfrage durchgeführt wurde. Wir können sichergehen, dass die Datenbank erstellt wurde, indem wir SHOW DATABASES erneut ausführen.

mysql> SHOW DATABASES;
+----------+
| Database |
+----------+
| gentoo   |
| mysql    |
| test     |
+----------+
3 rows in set (0.00 sec)

Unsere Datenbank wurde natürlich erstellt. Um Tabellen in unserer neuen gentoo Datenbank zu erstellen, müssen wir diese als unsere aktuelle Datenbank auswählen. Um das zu tun, verwenden wir den USE Befehl. Der USE Befehl nimmt als Argument den Namen der Datenbank, die Sie aktuell verwenden möchten. Eine andere Möglichkeit ist, sie auf der Kommandozeile durch Setzen nach dem -D Schalter auszuwählen. Fahren wir fort und wechseln zur gentoo Datenbank.

mysql> USE gentoo;
Database changed

Unsere derzeitige Datenbank ist nun die vorher von uns erstellte gentoo Datenbank. Nachdem wir diese jetzt benutzen, können wir damit beginnen, Tabellen zu erstellen und diese mit Informationen zu füllen.

3.  Arbeiten mit Tabellen in MySQL

Erzeugen einer Tabelle

In der Struktur von MySQL gibt es Datenbanken, Tabellen, Einträge und Felder. Datenbanken beinhalten Tabellen, Tabellen beinhalten Einträge, Einträge beinhalten Felder, welche die eigentlichen Informationen beinhalten. Diese Struktur ermöglicht Anwendern auszuwählen, wie sie auf die Informationen zugreifen möchten. Bis jetzt haben wir uns mit Datenbanken beschäftigt, lassen Sie uns nun mit Tabellen arbeiten. Zunächst können Tabellen, ähnlich wie Datenbanken, durch den SHOW TABLES Befehl angezeigt werden. Derzeit gibts es keine Tabellen in unserer gentoo Datenbank, wie uns das Ausführen des Befehls zeigen wird:

mysql> SHOW TABLES;
Empty set (0.00 sec)

Das bedeutet, wir müssen Tabellen erstellen. Um das zu tun, verwenden wir den CREATE TABLE Befehl. Allerdings unterscheidet sich dieser Befehl relativ stark von dem einfachen CREATE DATABASE Befehl. Dieser Befehl verwendet eine Liste von Argumenten. Die Form ist wie folgt:

CREATE TABLE [table_name] ([field_name] [field_data_type]([size]));

table_name ist der Name der Tabelle, die wir erstellen möchten. In diesem Fall erstellen wir eine Tabelle genannt developers. Diese Tabelle wird den Namen, E-Mail und Beruf beinhalten. field_name beinhaltet den Namen des Feldes. In diesem Fall haben wir 3 benötigte Namen: name, email und job. Der field_data_type gibt an, welche Art von Informationen darin gespeichert werden. Die verschiedenen verfügbaren Formate sind auf der MySQL-Spaltentypen Seite zu finden. Für unsere Zwecke verwenden wir den VARCHAR Datentyp für alle Felder. VARCHAR ist einer der einfachsten Datentypen beim Arbeiten mit Strings. size ist wieviel Daten ein einzelnes Feld speichern kann. In diesem Fall verwenden wir 128. Das bedeutet, dass das Feld 128 Bytes VARCHAR Daten beinhalten kann. Sie können das als 128 Zeichen sehen, eine technischere Erklärung stellt die oben genannte Seite zur Verfügung. Nachdem wir jetzt wissen, wie man eine Tabelle erstellt, werden wir das auch tun.

mysql> CREATE TABLE developers ( name VARCHAR(128), email VARCHAR(128), job VARCHAR(128));
Query OK, 0 rows affected (0.11 sec)

Sieht so aus, als ob unsere Tabelle erfolgreich erstellt wurde. Lassen Sie uns das mit dem SHOW TABLES Befehl überprüfen:

mysql> SHOW TABLES;
+------------------+
| Tables_in_gentoo |
+------------------+
| developers       |
+------------------+
1 row in set (0.00 sec)

Ja, da ist unsere Tabelle. Allerdings sieht es so aus, als ob diese keine Informationen über die Art der Felder hat, die wir eingerichtet haben. Dafür verwenden wir den DESCRIBE Befehl (oder kurz DESC), welches den Tabellennamen als Argument verwendet. Sehen wir nach, was uns das für die developer Tabelle ausgibt.

mysql> DESCRIBE developers;
+-------+--------------+------+-----+---------+-------+
| Field | Type         | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+-------+
| name  | varchar(128) | YES  |     | NULL    |       |
| email | varchar(128) | YES  |     | NULL    |       |
| job   | varchar(128) | YES  |     | NULL    |       |
+-------+--------------+------+-----+---------+-------+
3 rows in set (0.00 sec)

Das zeigt die verschiedenen Felder und deren Typ. Es zeigt auch einige weitere Attribute, welche über das Ziel dieses Howtos hinausgehen. Für mehr Informationen besuchen Sie das MySQL-Referenzhandbuch. Wir haben eine Tabelle mit der wir arbeiten können, lassen Sie uns fortfahren und diese füllen.

Befüllen unserer MySQL Datenbank

Wir befüllen eine Tabelle (oder fügen Daten hinzu) mit dem INSERT Befehl. Wie der CREATE TABLE Befehl, hat es ebenfalls ein spezifisches Format:

INSERT INTO table (col1, col2, ...) VALUES('value1', 'value2', ...);

Dieser Befehl wird verwendet, um Einträge in eine Tabelle zu schreiben. table beinhaltet die MySQL-Tabelle, in die wir die Informationen einfügen möchten. Dem Tabellennamen folgt eventuell eine Liste der Spalten, in die Daten eingefügt werden sollten, und VALUES() beinhaltet die in die Felder einzufügenden Daten. Sie können die Liste der Spalten weglassen, wenn Sie in jedes Feld etwas einfügen und wenn Sie die Daten in der gleichen Reihenfolge eintragen, wie Sie in der Tabelle definiert sind. In diesem Fall, wollen wir Daten in die developers Tabelle einfügen. Lassen Sie uns einige Beispieleinträge einfügen:

mysql> INSERT INTO developers VALUES('Joe Smith', 'joesmith@gentoo.org', 'toolchain');
Query OK, 1 row affected (0.06 sec)
(Falls Sie die Reihenfolge der Spalten nicht wissen, oder einen unvollständigen Eintrag machen möchten)
mysql> INSERT INTO developers (job, name) VALUES('outsourced', 'Jane Doe');
Query OK, 1 row affected (0.01 sec)

Entsprechend unsere Ausgabe, sieht es so aus, dass die Einträge korrekt eingefügt wurden. Was ist, wenn wir mehr Informationen als nur einen Eintrag einfügen möchten? Das ist der Moment, wo der LOAD DATA Befehl ins Spiel kommt. Das lädt Daten aus einer Tab getrennten Datei. Probieren wir das durch Editieren einer Datei in unserem Homeverzeichnis mit Einträgen. Wir nennen diese Datei records.txt. Hier ist ein Beispiel:

John Doe  johndoe@gentoo.org  portage
Chris White  chriswhite@gentoo.org  documentation
Sam Smith  samsmith@gentoo.org  amd64

Jetzt hat der LOAD DATA Befehl eine längere Definition, wir verwenden hier aber die einfachste Form.

LOAD DATA LOCAL INFILE '/path/to/filename' INTO TABLE table;

/path/to/filename ist das zu verwendete Verzeichnis und der Dateiname, table ist der Name unserer Tabelle. In diesem Fall ist ~/records.txt die Datei und die Tabelle ist developers.

mysql> LOAD DATA LOCAL INFILE '~/records.txt' INTO TABLE developers;
Query OK, 3 rows affected (0.00 sec)
Records: 3  Deleted: 0  Skipped: 0  Warnings: 0

Das hat gut funktioniert. Wie auch immer, das fügt einfach nur Einträge ein, aber gibt Ihnen keine Kontrolle über MySQL. Viele Web-Anwendungen verwenden SQL-Skripte um MySQL schnell und einfach einzurichten. Falls Sie ein scr-Skript verwenden möchten, müssen Sie MySQL im Batch-Modus starten oder die Datei sourcen. Hier ist ein Beispiel um MySQL im Batch-Modus laufen zu lassen:

$ mysql -u root -h localhost -p < sqlfile

Wie beim LOAD DATA Befehl sollten Sie sicherstellen, dass Sie wissen was sqlfile tut. Das nicht zu tun, kann Ihre Datenbank gefährden! Ein anderer Weg das zu tun, ist den source Befehl zu verwenden. Dieser Befehl startet MySQL-Befehle aus einer SQL-Datei aus dem interaktiven Modus. Hier sehen Sie, wie Sie eine SQL-Datei sourcen:

mysql> source sqlfile;

Falls Sie eine Web-Anwendung haben, die möchte, dass Sie eine SQL-Datei ausführen, können die beiden oben genannten Befehle verwendet werden, um das zu erledigen. Wir haben unsere Tabellen eingerichtet, wie überprüfen wir jetzt unsere Felder? Wir tun das, indem wir in unseren Tabellen mit Abfragen suchen.

Durchsuchen von MySQL Tabellen mit Abfragen

Abfragen sind eine der Hauptfunktionen von SQL-Datenbanken. Sie helfen uns, die Daten in unseren Tabellen in etwas Brauchbares zu verwandeln. Die meisten Abfragen werden mit dem SELECT Befehl ausgeführt. Der SELECT Befehl ist recht komplex, daher werden wir uns in diesem Dokument nur die drei Hauptformen ansehen.

(Auswählen aller Einträge in einer Tabelle)
SELECT * FROM table;
(Auswählen spezieller Einträge in einer Tabelle)
SELECT * FROM table WHERE field=value;
(Auswählen spezieller Felder)
SELECT field1,field2,field3 FROM table [WHERE field=value];

Werfen wir einen kurzen Blick auf die erste Form. Diese ist recht einfach und gibt ihnen einen Überblick über Ihre Tabelle. Wir machen weiter und führen es aus, um zu sehen, welche Daten wir bis jetzt haben.

mysql> SELECT * FROM developers;
+-------------+-----------------------+----------------+
| name        | email                 | job            |
+-------------+-----------------------+----------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain      |
| John Doe    | johndoe@gentoo.org    | portage        |
| Chris White | chriswhite@gentoo.org | documentation  |
| Sam Smith   | samsmith@gentoo.org   | amd64          |
| Jane Doe    | NULL                  | Outsourced job |
+-------------+-----------------------+----------------+
5 rows in set (0.00 sec)

Wir sehen die Daten, die wir mit INSERT und jene, die wir mit LOAD DATA eingefügt haben. Jetzt sagen wir, wir möchten nur den Eintrag für Chris White ansehen. Das können wir mit der zweiten Form von select wie unten gezeigt erreichen.

mysql> SELECT * FROM developers WHERE name = 'Chris White';
+-------------+-----------------------+---------------+
| name        | email                 | job           |
+-------------+-----------------------+---------------+
| Chris White | chriswhite@gentoo.org | documentation |
+-------------+-----------------------+---------------+
1 row in set (0.08 sec)

Wie vermutet, wurde der spezielle Eintrag nach dem wir suchen ausgewählt. Jetzt sagen wir, wir möchten nur den Beruf und die E-Mail-Adresse, nicht aber den Namen der Person wissen. Wir können das mit der dritten Form des SELECT Befehls erreichen, wie hier gezeigt wird.

mysql> SELECT email,job FROM developers WHERE name = 'Chris White';
+-----------------------+---------------+
| email                 | job           |
+-----------------------+---------------+
| chriswhite@gentoo.org | documentation |
+-----------------------+---------------+
1 row in set (0.04 sec)

Diese Methode der Auswahl ist viel einfacher zu handhaben, speziell mit größeren Datenmengen, wie wir später noch sehen werden. Als root Benutzer haben wir mit uneingeschränkten Rechten die Möglichkeit, alles mit der MySQL-Datenbank zu tun, was wir möchten. In einem Serverumfeld, kann ein Benutzer mit solchen Rechten sehr problematisch sein. Um zu kontrollieren, wer was mit der Datenbank tut, richten wir Zugriffsrechte ein.

4.  MySQL-Zugriffsrechte

Zugriffsrechte gewähren mit GRANT

Zugriffsrechte legen fest, welche Art von Zugriff Benutzer auf die Datenbanken, Tabellen oder einfach alles haben. Im Moment hat nur der root Account durch seine Berechtigung Zugriff auf die gentoo Datenbank. Lassen Sie uns jetzt zwei gewöhnliche Benutzer erstellen, guest und admin, die die gentoo Datenbank betreten und damit arbeiten dürfen. Der guest Account wird ein eingeschränkter Account sein. Alles was er tun kann, ist Informationen abzufagen und nicht mehr. admin wird die selbe Kontrolle wie root haben, allerdings nur für die gentoo Datenbank (nicht für die Haupt-MySQL-Datenbank). Bevor wir damit weitermachen, lassen Sie uns einen Blick auf eine einfache Form des GRANT Befehls werfen.

GRANT [privileges] ON database.* TO '[user]'@'[host]' IDENTIFIED BY '[password]';

Zuerst haben wir die Rechte, die wir vergeben möchten. Mit dem was wir bis jetzt gelernt haben, hier sind einige Rechte, die Sie setzen können:

• ALL - gibt alle Rechte für die Datenbank
• CREATE - erlaubt Benutzern, Tabellen zu erzeugen
• SELECT - erlaubt Benutzern, Tabellen zu durchsuchen
• INSERT - erlaubt Benutzern, Daten in eine Tabelle einzufügen
• SHOW DATABASES - erlaubt Benutzern, eine Liste der Datenbanken anzuzeigen
• USAGE - Benutzer hat keine Rechte
• GRANT OPTION - erlaubt Benutzern, Rechte zu vergeben

Für unseren admin Benutzer, verwenden wir ALL. Für den guest Benutzer reicht SELECT für den Nur-Lese-Zugriff. database ist die Datenbank, für die wir die Rechte des Benutzers festlegen möchten. In diesem Beispiel ist gentoo die Datenbank. Das .* steht für alle Tabellen. Falls Sie wünschen, können Sie auch tabellenspezifische Rechte vergeben. user ist der Name des Benutzers und host ist der Hostname, von dem aus der Benutzer auf die Datenbank zugreift. In den meisten Fällen wird das localhost sein. password ist das Passwort des Benutzers. Lassen Sie uns fortfahren und anhand dieser Informationen unsere Benutzer erstellen.

(admin)
mysql> GRANT ALL ON gentoo.* TO 'admin'@'localhost' IDENTIFIED BY 'password';
(guest)
mysql> GRANT SELECT ON gentoo.* TO 'guest'@'localhost' IDENTIFIED BY 'password';

Nachdem wir unsere Benutzer eingerichtet haben, lassen Sie sie uns ausprobieren. Zuerst beenden wir MySQL durch Eingabe von quit in der Eingabeaufforderung:

mysql> quit

Wir sind jetzt zurück in der Konsole. Nachdem wir unsere Benutzer eingerichtet haben, lassen Sie uns fortfahren und sehen, was diese tun dürfen.

Benutzerrechte ausprobieren

Wir versuchen uns jetzt als guest Benutzer einzuloggen. Der guest Benutzer hat nur SELECT Rechte. Das bedeutet, nur Suchen und sonst nichts zu können. Fahren Sie fort und loggen Sie sich mit dem guest Benutzer ein.

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 6 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Jetzt sollten wir die Rechte unseres Benutzers überprüfen. Wechseln wir zur gentoo Datenbank:

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed

Lassen Sie uns versuchen, etwas zu tun, dass wir nicht dürfen. Wir versuchen, eine Tabelle zu erzeugen.

mysql> CREATE TABLE test (test VARCHAR(20), foobar VARCHAR(2));
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

Wie Sie sehen können, funktioniert das nicht, da unser Benutzer nicht die erforderlichen Rechte hat. Wir haben aber Zugriff auf die SELECT Anweisung. Fahren wir fort und probieren das aus:

mysql> SELECT * FROM developers;
+-------------+-----------------------+----------------+
| name        | email                 | job            |
+-------------+-----------------------+----------------+
| Joe Smith   | joesmith@gentoo.org   | toolchain      |
| John Doe    | johndoe@gentoo.org    | portage        |
| Chris White | chriswhite@gentoo.org | documentation  |
| Sam Smith   | samsmith@gentoo.org   | amd64          |
| Jane Doe    | NULL                  | Outsourced job |
+-------------+-----------------------+----------------+
5 rows in set (0.00 sec)

Der Befehl war erfolgreich und wir haben einen flüchtigen Blick darauf erhalten, was Benutzerrechte tun können. Wir haben aber auch einen admin Account erzeugt. Das war um zu zeigen, dass auch Benutzer mit ALL Zugriffsrechten Einschränkungen haben können. Fahren Sie fort, schließen Sie MySQL und loggen Sie sich anschließend als admin ein.

mysql> quit
Bye
$ mysql -u admin -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 7 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Zu Beginn versuchen wir, eine neue Datenbank mit unserem admin Benutzer zu erstellen. Dieser admin hat den gleichen Zugriff wie der root Benutzer und kann jegliche Änderungen in der gentoo Datenbank durchführen, die er möchte. Das wird den Zugriff auf die Haupt-MySQL-Datenbank testen. Erinnern Sie sich daran, dass wir früher nur Zugriff auf eine spezielle Datenbank erlaubt haben.

mysql> CREATE DATABASE gentoo2;
ERROR 1044: Access denied for user: 'admin@localhost' to database 'gentoo2'

Natürlich kann der admin Benutzer keine Datenbank erzeugen, trotz seiner Rechte in der gentoo Datenbank. Wie auch immer, wir können nach wie vor den admin Account dazu benutzen, um die gentoo Datenbank zu modifizieren, wie durch das folgende beispielhafte Einfügen von Daten gezeigt wird.

mysql> USE gentoo;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> INSERT INTO developers VALUES('Bob Simmons', 'bobsimmons@gentoo.org', 'python');
Query OK, 1 row affected (0.08 sec)

Der admin Benutzer kann auf die Datenbank zugreifen, wie es ihm gefällt. Manchmal möchten wir auch Benutzerrechte entziehen. Das kann alles, angefangen von einem problematischen Benutzer bis zu einem pensionierten Angestellen sein. Werfen wir einen Blick darauf, wie man Benutzerrechte mit dem REVOKE Befehl deaktiviert.

Sperren eines Benutzerzugriffs mit dem REVOKE Befehl

Der REVOKE Befehl lässt uns den Zugriff eines Benutzers verweigern. Wir können den gesamten oder nur speziellen Zugriff verweigern. Tatsächlich ist das Format sehr ähnlich zu dem von GRANT.

REVOKE [privileges] ON database.* FROM '[user]'@'[host]';

Die Optionen sind in dem GRANT Abschnitt erklärt. In diesem Abschnitt werden wir jeden Zugriff eines Benutzers verweigern. Sagen wir, wir haben herausgefunden, dass der guest Account in irgendeiner Weise Sicherheitsprobleme hervorruft. Wir entscheiden uns dazu, alle Rechte zu widerrufen. Wir melden uns als root an und tun das Nötige.

mysql> REVOKE ALL ON gentoo.* FROM 'guest'@'localhost';
Query OK, 0 rows affected (0.00 sec)

Beenden wir jetzt und versuchen uns als guest Benutzer einzuloggen.

$ mysql -u guest -h localhost -p
Enter password:
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 9 to server version: 4.0.25

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql>

Wir können uns zwar einloggen, allerdings haben wir keinen Zugriff mehr zur gentoo Datenbank.

mysql> USE gentoo;
ERROR 1044: Access denied for user: 'guest@localhost' to database 'gentoo'

Unser problematischer Benutzer kann auf die gentoo Datenbank nicht länger zugreifen. Bitte beachten Sie, dass sich der Benutzer noch immer einloggen kann. Dies ist so, da er nach wie vor in der Haupt-MySQL-Datenbank vorhanden ist. Werfen wir einen Blick darauf, wie man einen Account komplett mit dem DELETE und der MySQL Benutzertabelle löscht.

Löschen von Accounts mit DELETE

Die MySQL Benutzertabelle ist eine Liste mit allen Benutzer und Informationen über diese. Stellen Sie sicher, dass Sie als root eingeloggt sind. Danach fahren Sie fort und verwenden die Haupt-MySQL-Datenbank.

mysql> USE mysql;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql>

Lassen Sie uns jetzt nachsehen, welche Tabellen die mysql Datenbank hat.

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mysql |
+-----------------+
| columns_priv    |
| db              |
| func            |
| host            |
| tables_priv     |
| user            |
+-----------------+
6 rows in set (0.00 sec)

Die user Tabelle ist die Tabelle, die wir suchen. Diese Tabelle beinhaltet 30 verschieden Felder, was das Lesen etwas erschwert. Um die Dinge zum Lesen zu vereinfachen, werden wir die dritte Version der SELECT Anweisung verwenden. Die Felder, die wir suchen, sind Host und User.

mysql> SELECT Host,User FROM user WHERE User = 'guest';
+-----------+-------+
| Host      | User  |
+-----------+-------+
| localhost | guest |
+-----------+-------+
1 row in set (0.00 sec)

Nachdem wir unsere Informationen haben, können wir unseren guest Benutzer loswerden. Das wird durch den DELETE Befehl erledigt, die Syntax wird unten gezeigt.

DELETE FROM table WHERE field='value';

Sie werden feststellen, dass DELETE der SELECT Anweisung recht ähnlich ist. In diesem Fall ist das Feld User und der Wert guest. Das wird den Eintrag, wo der Benutzer guest ist, erfolgreich aus der Benutzertabelle löschen. Fahren wir fort und erledigen das:

mysql> DELETE FROM user WHERE User='guest';
Query OK, 1 row affected (0.07 sec)
(FLUSH PRIVILEGES wird benötigt um die Benutzerrechte zu aktualisieren)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

Es sieht so aus, als ob es funktioniert hat. Lassen Sie uns das testen, indem wir uns ausloggen und versuchen uns als guest Benutzer wieder einzuloggen.

mysql> quit
Bye
$ mysql -u guest -h localhost -p
Enter password:
ERROR 1045: Access denied for user: 'guest@localhost' (Using password: YES)

Unser Benutzer ist jetzt erfolgreich gelöscht!

Abschluss

Während sich diese Anleitung auf das Einrichten von MySQL über die Kommandozeile spezialisiert, gibt es einige Alternativen in GUI Form:

• phpMyAdmin - populäres PHP-basiertes Administrationstool.
• mysqlnavigator - QT-Frontend für MySQL.
• gmyclient - Ein GNOME-basierter MySQL-Client.
• knoda - Ein KDE-MySQL-Client.

Das beendet die einführende MySQL-Anleitung. Ich hoffe, das gibt Ihnen ein besseres Verständnis der Grundlagen hinter MySQL und dem Einrichten einer Datenbank. Bitte mailen Sie mir an Chris White falls Sie irgendwelche Kommentare dazu haben.

Die Inhalte dieses Dokuments sind, sofern nicht explizit anders genannt, unter der Creative Commons - Namensnennung / Weitergabe Lizenz lizenziert. Die Gentoo Name and Logo Usage Guidelines treffen zu.