Einführung
In diesem Lab erkunden wir die grundlegenden Konzepte der Datenbankverwaltung mit MySQL. Wir behandeln das Erstellen und Löschen von Datenbanken, das Auswählen von Datenbanken sowie das Abrufen von Metadaten. Diese Fähigkeiten sind für jeden, der mit Datenbanken arbeitet, unerlässlich – vom Anfänger bis zum erfahrenen Entwickler. Am Ende dieses Labs verfügen Sie über ein solides Fundament in den grundlegenden MySQL-Datenbankoperationen.
Lernziele
Nach Abschluss dieses Labs sind Sie in der Lage:
- Datenbanken mit verschiedenen Methoden zu erstellen und zu löschen
- Datenbanken auszuwählen und zwischen ihnen zu wechseln
- Wichtige Metadaten über Ihren MySQL-Server und Ihre Datenbanken abzurufen
- Die Groß-/Kleinschreibung von Datenbanknamen in MySQL zu verstehen
Datenbanken erstellen und auflisten
In diesem Schritt lernen wir, wie man Datenbanken erstellt und vorhandene Datenbanken über den MySQL-Befehlszeilen-Client auflistet. Dies ist eine grundlegende Fähigkeit für jeden Datenbankadministrator oder Entwickler.
Öffnen wir zunächst ein Terminalfenster. In der LabEx-Umgebung verwenden Sie ein Ubuntu-Linux-System. Das Terminal sollte bereits geöffnet sein; falls nicht, können Sie es durch Klicken auf das Terminal-Symbol öffnen.
Starten wir nun den MySQL-Client:
sudo mysql -u root
In der LabEx-VM müssen Sie für den Root-Benutzer kein Passwort eingeben.
Sobald Sie sich im MySQL-Client befinden, sehen Sie eine Eingabeaufforderung wie diese: MariaDB [(none)]>. Dies zeigt an, dass Sie mit dem MariaDB-Server (einem Fork von MySQL) verbunden sind, aber noch keine spezifische Datenbank ausgewählt haben.
Verfügbare Datenbanken auflisten
Beginnen wir damit, die verfügbaren Datenbanken auf Ihrem MySQL-Server aufzulisten:
SHOW DATABASES;
Sie sollten eine Ausgabe sehen, die der folgenden ähnelt:
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
4 rows in set (0.000 sec)
Dieser Befehl listet alle derzeit auf dem Server verfügbaren Datenbanken auf. Hier ist eine kurze Erläuterung dieser Standarddatenbanken:
information_schema: Eine Datenbank, die Zugriff auf Datenbank-Metadaten bietet.mysql: Die Systemdatenbank, die Informationen zu Benutzerkonten und Berechtigungen enthält.performance_schema: Eine Datenbank zur Überwachung der Ausführung des MySQL-Servers auf niedriger Ebene.sys: Eine Datenbank, die eine Reihe von Objekten bereitstellt, um die vom Performance Schema gesammelten Daten zu interpretieren.
Eine Datenbank erstellen
Erstellen wir nun eine neue Datenbank namens 'Hello_World'. In MySQL verwenden wir dafür den Befehl CREATE DATABASE:
CREATE DATABASE Hello_World;
Nach der Ausführung dieses Befehls antwortet MySQL mit:
Query OK, 1 row affected (0.000 sec)
Dies bedeutet, dass die Datenbank erfolgreich erstellt wurde. Zur Bestätigung listen wir die Datenbanken erneut auf:
SHOW DATABASES;
Sie sollten nun 'Hello_World' in der Liste sehen:
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| Hello_World |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 rows in set (0.000 sec)
Großartig! Sie haben gerade Ihre erste Datenbank erstellt.
Groß-/Kleinschreibung bei Datenbanknamen
Ein wichtiges Konzept in MySQL ist, dass Datenbanknamen zwischen Groß- und Kleinschreibung unterscheiden. Das bedeutet, dass 'Hello_World' und 'hello_world' als zwei verschiedene Datenbanken behandelt werden. Lassen Sie uns dies demonstrieren:
CREATE DATABASE hello_world;
SHOW DATABASES;
Sie sollten nun sowohl 'Hello_World' als auch 'hello_world' in der Liste sehen:
MariaDB [(none)]> CREATE DATABASE hello_world;
Query OK, 1 row affected (0.000 sec)
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| Hello_World |
| hello_world |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
6 rows in set (0.000 sec)
Dies zeigt, dass 'Hello_World' und 'hello_world' als zwei unterschiedliche Datenbanken behandelt werden. Bei Ihren Datenbankentwürfen ist es generell eine gute Praxis, konsistente Namenskonventionen zu verwenden, um Verwirrung zu vermeiden. Viele Entwickler bevorzugen die Verwendung von ausschließlich Kleinbuchstaben für Datenbanknamen, um potenzielle Probleme mit der Groß-/Kleinschreibung zu vermeiden.
Datenbanken mit mysqladmin erstellen
In diesem Schritt erkunden wir eine alternative Methode zum Erstellen von Datenbanken mit dem Tool mysqladmin. Dieses Tool ist ein Befehlszeilen-Dienstprogramm, mit dem Sie einige administrative Vorgänge durchführen können, ohne die MySQL-Eingabeaufforderung aufzurufen.
Beenden wir zunächst den MySQL-Client. Sie können dies tun, indem Sie exit oder quit eingeben und die Eingabetaste drücken:
exit
Nachdem wir nun wieder an der regulären Befehlszeile sind, verwenden wir mysqladmin, um eine neue Datenbank zu erstellen:
sudo mysqladmin -u root create hello_world2
In dieser LabEx-VM verwenden Sie sudo mit mysqladmin, da das Root-Datenbankkonto die lokale Socket-Authentifizierung verwendet.
Der Befehl, den wir gerade verwendet haben, gliedert sich wie folgt:
sudo: Führt den Befehl mit den erforderlichen Systemrechten aus.-u root: Gibt an, dass wir uns als Root-Datenbankbenutzer verbinden.create: Dies ist der Vorgang, den wir ausführen.hello_world2: Dies ist der Name der Datenbank, die wir erstellen.
Melden wir uns nun wieder beim MySQL-Client an, um zu überprüfen, ob unsere neue Datenbank erstellt wurde:
sudo mysql -u root
Sobald Sie sich im MySQL-Client befinden, listen Sie die Datenbanken auf:
SHOW DATABASES;
Sie sollten 'hello_world2' in der Liste sehen:
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| Hello_World |
| hello_world |
| hello_world2 |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
7 rows in set (0.000 sec)
Das Tool mysqladmin bietet eine schnelle Möglichkeit, Datenbanken direkt über die Befehlszeile zu erstellen, was für Skripterstellung und Automatisierungsaufgaben nützlich sein kann. Es ist besonders praktisch, wenn Sie Datenbanken als Teil eines größeren Skripts oder automatisierten Prozesses erstellen müssen.
Datenbanken löschen
Nachdem wir nun mehrere Datenbanken erstellt haben, lernen wir, wie man sie entfernt. In der Datenbankverwaltung ist es genauso wichtig zu wissen, wie man Datenbanken entfernt, wie sie zu erstellen. Wir behalten nur die Datenbank 'Hello_World' und entfernen die anderen.
Eine Datenbank mit dem MySQL-Client löschen
Melden Sie sich beim MySQL-Client an, falls Sie dies noch nicht getan haben:
sudo mysql -u root
Löschen wir nun die Datenbank 'hello_world':
DROP DATABASE hello_world;
SHOW DATABASES;
Sie sollten sehen, dass 'hello_world' nicht mehr in der Liste enthalten ist:
MariaDB [(none)]> DROP DATABASE hello_world;
Query OK, 0 rows affected (0.002 sec)
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| Hello_World |
| hello_world2 |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
6 rows in set (0.000 sec)
Hinweis: Seien Sie äußerst vorsichtig bei der Verwendung des Befehls DROP DATABASE. Er löscht die Datenbank und ihren gesamten Inhalt dauerhaft, ohne um Bestätigung zu bitten. In einer Produktionsumgebung sollten Sie normalerweise Sicherheitsvorkehrungen und Backups haben, bevor Sie solche Vorgänge durchführen.
Eine Datenbank mit mysqladmin löschen
Verwenden wir nun mysqladmin, um die Datenbank 'hello_world2' zu löschen. Diese Methode gilt als sicherer, da sie vor dem Löschen der Datenbank um eine Bestätigung bittet.
Beenden Sie den MySQL-Client durch Eingabe von exit oder quit und führen Sie dann den folgenden Befehl in Ihrem Terminal aus:
sudo mysqladmin -u root drop hello_world2
Sie werden aufgefordert, die Aktion zu bestätigen:
Dropping the database is potentially a very bad thing to do.
Any data stored in the database will be destroyed.
Do you really want to drop the 'hello_world2' database [y/N] y
Database "hello_world2" dropped
Geben Sie 'y' ein und drücken Sie die Eingabetaste zur Bestätigung. Dieser zusätzliche Bestätigungsschritt kann helfen, versehentliche Datenbanklöschungen zu verhindern.
Melden Sie sich nun wieder beim MySQL-Client an und überprüfen Sie, ob 'hello_world2' entfernt wurde:
SHOW DATABASES;
Sie sollten sehen:
MariaDB [(none)]> SHOW DATABASES;
+--------------------+
| Database |
+--------------------+
| Hello_World |
| information_schema |
| mysql |
| performance_schema |
| sys |
+--------------------+
5 rows in set (0.000 sec)
Wir haben unsere zusätzlichen Datenbanken erfolgreich bereinigt und nur die behalten, die wir benötigen.
Datenbanken auswählen und verwenden
Nachdem wir nun Datenbanken erstellt und gelöscht haben, lernen wir, wie man eine bestimmte Datenbank auswählt und verwendet. Dies ist eine entscheidende Fähigkeit, da sich die meiste Arbeit in MySQL innerhalb einer bestimmten Datenbank abspielt.
Eine Datenbank auswählen
Um eine Datenbank auszuwählen, mit der Sie arbeiten möchten, verwenden Sie den Befehl USE gefolgt vom Datenbanknamen:
USE Hello_World;
Sie sollten sehen:
Database changed
Dies zeigt an, dass Sie nun innerhalb der Datenbank 'Hello_World' arbeiten. Alle nachfolgenden Befehle, die Sie ausführen, werden im Kontext dieser Datenbank ausgeführt, sofern Sie nichts anderes angeben.
Tabellen in einer Datenbank auflisten
Um die Tabellen in der aktuellen Datenbank zu sehen, verwenden Sie den Befehl SHOW TABLES;:
SHOW TABLES;
Da wir in unserer 'Hello_World'-Datenbank noch keine Tabellen erstellt haben, sehen Sie:
Empty set (0.00 sec)
Dies ist bei einer neuen Datenbank normal. Sobald Sie Tabellen erstellen, erscheinen diese in dieser Liste.
Wechseln wir zu einer anderen Datenbank und listen deren Tabellen auf, um zu sehen, wie dies bei einer gefüllten Datenbank funktioniert:
USE mysql;
SHOW TABLES;
Sie sehen eine Liste der Tabellen in der Systemdatenbank 'mysql':
MariaDB [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
MariaDB [mysql]> SHOW TABLES;
+---------------------------+
| Tables_in_mysql |
+---------------------------+
| column_stats |
| columns_priv |
| db |
| event |
| func |
| general_log |
| global_priv |
| gtid_slave_pos |
| help_category |
| help_keyword |
| help_relation |
| help_topic |
| index_stats |
| innodb_index_stats |
| innodb_table_stats |
| plugin |
| proc |
| procs_priv |
| proxies_priv |
| roles_mapping |
| servers |
| slow_log |
| table_stats |
| tables_priv |
| time_zone |
| time_zone_leap_second |
| time_zone_name |
| time_zone_transition |
| time_zone_transition_type |
| transaction_registry |
| user |
+---------------------------+
31 rows in set (0.001 sec)
Dies zeigt, wie man zwischen Datenbanken wechselt und deren Inhalte anzeigt. Die Datenbank 'mysql' enthält Systemtabellen, die MySQL zur Verwaltung von Berechtigungen, Benutzerkonten und anderen internen Daten verwendet. In Ihren eigenen Anwendungen erstellen und verwalten Sie Ihre eigenen Tabellen innerhalb Ihrer benutzerdefinierten Datenbanken.
MySQL-Metadaten abrufen
In diesem letzten Schritt untersuchen wir, wie man verschiedene Arten von Metadaten aus MySQL abruft. Metadaten sind "Daten über Daten" – sie liefern Informationen über das Datenbanksystem selbst, anstatt über die darin gespeicherten Daten. Diese Informationen können entscheidend sein, um Ihre MySQL-Umgebung zu verstehen und zu verwalten.
Server-Version
Um die MySQL-Serverversion zu erhalten, verwenden Sie:
SELECT VERSION();
Sie sehen eine Ausgabe ähnlich dieser:
MariaDB [mysql]> SELECT VERSION();
+----------------------------------+
| VERSION() |
+----------------------------------+
| 10.6.12-MariaDB-0ubuntu0.22.04.1 |
+----------------------------------+
1 row in set (0.000 sec)
Diese Information ist nützlich, wenn Sie wissen müssen, welche Funktionen in Ihrer aktuellen MySQL-Version verfügbar sind, oder bei der Fehlersuche bei versionsspezifischen Problemen.
Aktuelle Datenbank
Um zu sehen, welche Datenbank Sie gerade verwenden:
SELECT DATABASE();
Die Ausgabe zeigt den aktuellen Datenbanknamen oder NULL, wenn keine Datenbank ausgewählt ist:
MariaDB [mysql]> SELECT DATABASE();
+------------+
| DATABASE() |
+------------+
| mysql |
+------------+
1 row in set (0.000 sec)
Dies kann hilfreich sein, wenn Sie mit mehreren Datenbanken arbeiten und bestätigen müssen, in welcher Sie gerade operieren.
Aktueller Benutzer
Um den aktuellen Benutzer zu sehen:
SELECT USER();
Sie sehen eine Ausgabe wie:
MariaDB [mysql]> SELECT USER();
+----------------+
| USER() |
+----------------+
| root@localhost |
+----------------+
1 row in set (0.000 sec)
Dies zeigt den MySQL-Benutzer, als der Sie angemeldet sind, und den Host, von dem aus Sie eine Verbindung herstellen. Es ist nützlich, um Ihre aktuellen Berechtigungen und Verbindungsdetails zu überprüfen.
Serverstatus und Variablen
Um alle Serverstatusindikatoren anzuzeigen:
SHOW STATUS;
Dieser Befehl liefert eine Fülle von Informationen über den aktuellen Zustand des MySQL-Servers, einschließlich verschiedener Zähler und Statistiken.
Um alle Serverkonfigurationsvariablen anzuzeigen:
SHOW VARIABLES;
Dieser Befehl zeigt Ihnen, wie Ihr MySQL-Server konfiguriert ist, einschließlich Einstellungen für Speichernutzung, Verbindungslimits und viele andere Parameter.
Beide Befehle erzeugen eine umfangreiche Ausgabe. Sie können im Terminal durch sie blättern oder nach spezifischen Informationen filtern. Um beispielsweise Variablen im Zusammenhang mit dem Puffer-Pool zu sehen:
SHOW VARIABLES LIKE '%buffer%';
Diese Befehle liefern umfassende Informationen über die Konfiguration und den aktuellen Zustand Ihres MySQL-Servers. Das Verständnis dieser Metadaten kann entscheidend für die Optimierung der Leistung, die Fehlersuche und die Sicherstellung sein, dass Ihr Server korrekt für Ihre Anforderungen konfiguriert ist.
Sie könnten beispielsweise SHOW STATUS verwenden, um die Anzahl der ausgeführten Abfragen zu überprüfen:
SHOW STATUS LIKE 'Questions';
Dies könnte Ihnen eine Ausgabe wie diese liefern:
MariaDB [mysql]> SHOW STATUS LIKE 'Questions';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Questions | 15 |
+---------------+-------+
1 row in set (0.001 sec)
Dies sagt Ihnen, wie viele Anweisungen vom Server seit seinem Start ausgeführt wurden.
Ebenso könnten Sie SHOW VARIABLES verwenden, um wichtige Konfigurationseinstellungen wie die maximal zulässige Paketgröße zu überprüfen:
SHOW VARIABLES LIKE 'max_allowed_packet';
Was eine Ausgabe wie diese ergeben könnte:
MariaDB [mysql]> SHOW VARIABLES LIKE 'max_allowed_packet';
+--------------------+----------+
| Variable_name | Value |
+--------------------+----------+
| max_allowed_packet | 16777216 |
+--------------------+----------+
1 row in set (0.001 sec)
Dies zeigt die maximale Größe eines Pakets oder einer generierten/zwischengeschalteten Zeichenfolge, was bei der Arbeit mit großen Datenmengen wichtig sein kann.
Das Verständnis, wie man diese Metadaten abruft und interpretiert, ist eine wertvolle Fähigkeit für jeden Datenbankadministrator oder Entwickler. Es ermöglicht Ihnen, Einblicke in das Verhalten und die Leistung Ihres Datenbanksystems zu gewinnen, was für Optimierung und Fehlersuche entscheidend sein kann.
Zusammenfassung
In diesem Lab haben wir grundlegende Aspekte der Datenbankverwaltung in MySQL behandelt:
- Erstellen von Datenbanken sowohl mit dem MySQL-Client als auch mit dem Tool mysqladmin
- Auflisten vorhandener Datenbanken und Verständnis ihrer Zwecke
- Verständnis der Groß-/Kleinschreibung von Datenbanknamen in MySQL
- Sicheres Löschen von Datenbanken und die Bedeutung von Vorsicht dabei
- Auswählen und Wechseln zwischen Datenbanken
- Abrufen wichtiger Metadaten über den MySQL-Server und die Datenbanken
Diese Fähigkeiten bilden die Grundlage für die Arbeit mit MySQL-Datenbanken. Während Sie auf Ihrer Datenbankreise voranschreiten, werden Sie auf diesen Grundlagen aufbauen, um komplexere Datenbankoperationen und Verwaltungsaufgaben durchzuführen.
