Grundlagen des Datenbankmanagements mit MySQL

Einführung

In diesem Lab werden wir die grundlegenden Konzepte des Datenbankmanagements mit MySQL erkunden. Wir werden das Erstellen und Löschen von Datenbanken, das Auswählen von Datenbanken und das Abrufen von Metadaten behandeln. Diese Fähigkeiten sind für alle, die mit Datenbanken arbeiten, von Anfängern bis hin zu erfahrenen Entwicklern, unerlässlich. Am Ende dieses Labs werden Sie über eine solide Grundlage in den grundlegenden MySQL-Datenbankoperationen verfügen.

Lernziele

Durch die Absolvierung dieses Labs werden Sie in der Lage sein:

• 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ß- und Kleinschreibungssensitivität von Datenbanknamen in MySQL zu verstehen

Skills Graph

Erstellen und Auflisten von Datenbanken

In diesem Schritt werden wir lernen, wie man Datenbanken erstellt und vorhandene auflistet, indem man den MySQL-Befehlszeilenclient verwendet. Dies ist eine grundlegende Fähigkeit für jeden Datenbankadministrator oder Entwickler.

Zunächst öffnen wir ein Terminalfenster. In der LabEx-Umgebung verwenden Sie ein Ubuntu Linux-System. Das Terminal sollte bereits geöffnet sein, wenn nicht, können Sie es durch Klicken auf das Terminal-Symbol öffnen.

Jetzt starten wir den MySQL-Client:

sudo mysql -u root

In der LabEx-VM müssen Sie kein Passwort für den root-Benutzer eingeben.

Sobald Sie im MySQL-Client sind, 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 bestimmte Datenbank ausgewählt haben.

Auflisten der verfügbaren Datenbanken

Beginnen wir damit, die verfügbaren Datenbanken auf Ihrem MySQL-Server aufzulisten:

SHOW DATABASES;

Sie sollten eine Ausgabe ähnlich dieser sehen:

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. Schauen wir uns an, was diese Standarddatenbanken sind:

• information_schema: Eine Datenbank, die Zugang zu Datenbankmetadaten bietet.
• mysql: Die Systemdatenbank, die Benutzerkonto- und Berechtigungsinformationen enthält.
• performance_schema: Eine Datenbank zur Überwachung der MySQL-Server-Ausführung auf niedriger Ebene.
• sys: Eine Datenbank, die eine Reihe von Objekten bietet, um die von der Performance Schema gesammelten Daten zu interpretieren.

Erstellen einer Datenbank

Jetzt erstellen wir eine neue Datenbank namens 'Hello_World'. In MySQL verwenden wir dazu den Befehl CREATE DATABASE:

CREATE DATABASE Hello_World;

Nach der Ausführung dieses Befehls wird MySQL mit folgender Antwort reagieren:

Query OK, 1 row affected (0.000 sec)

Das bedeutet, dass die Datenbank erfolgreich erstellt wurde. Um dies zu bestätigen, listen wir die Datenbanken erneut auf:

SHOW DATABASES;

Sie sollten jetzt '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)

Toll! Sie haben gerade Ihre erste Datenbank erstellt.

Groß- und Kleinschreibungssensitivität von Datenbanknamen

Ein wichtiges Konzept, das man in MySQL verstehen muss, ist, dass Datenbanknamen groß- und kleinschreibungsempfindlich sind. 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 jetzt 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 verschiedene Datenbanken behandelt werden. Bei der Datenbankgestaltung ist es im Allgemeinen eine gute Praxis, konsistente Benennungskonventionen zu verwenden, um Verwirrungen zu vermeiden. Viele Entwickler bevorzugen es, für Datenbanknamen ausschließlich Kleinbuchstaben zu verwenden, um potenzielle Probleme mit der Groß- und Kleinschreibungssensitivität zu vermeiden.

Erstellen von Datenbanken mit mysqladmin

In diesem Schritt werden wir eine alternative Methode zur Erstellung von Datenbanken mithilfe des mysqladmin-Tools untersuchen. Dieses Tool ist ein Befehlszeilenprogramm, das es Ihnen ermöglicht, einige administrative Operationen auszuführen, ohne den MySQL-Eingabeaufforderung zu nutzen.

Zunächst beenden wir den MySQL-Client. Sie können dies tun, indem Sie exit oder quit eingeben und die Eingabetaste drücken:

exit

Jetzt, da wir wieder an der normalen Befehlseingabeaufforderung sind, verwenden wir mysqladmin, um eine neue Datenbank zu erstellen:

mysqladmin -u root -p create hello_world2

Wenn Sie zur Eingabe eines Passworts aufgefordert werden, drücken Sie einfach die Eingabetaste (denken Sie daran, dass im LabEx-VM für den root-MySQL-Benutzer kein Passwort festgelegt ist).

Der mysqladmin-Befehl, den wir gerade verwendet haben, lässt sich wie folgt aufschlüsseln:

• -u root: Dies gibt an, dass wir uns als root-Benutzer verbinden.
• -p: Dies teilt mysqladmin mit, nach einem Passwort zu fragen.
• create: Dies ist die Operation, die wir ausführen.
• hello_world2: Dies ist der Name der Datenbank, die wir erstellen.

Jetzt melden wir uns erneut beim MySQL-Client an, um zu überprüfen, ob unsere neue Datenbank erstellt wurde:

sudo mysql -u root

Sobald Sie im MySQL-Client sind, 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 mysqladmin-Tool bietet eine schnelle Möglichkeit, Datenbanken direkt von der Befehlszeile aus zu erstellen, was für Skripting- und Automatisierungsaufgaben nützlich sein kann. Es ist besonders praktisch, wenn Sie Datenbanken als Teil eines größeren Skripts oder eines automatisierten Prozesses erstellen müssen.

Löschen von Datenbanken

Nachdem wir mehrere Datenbanken erstellt haben, lernen wir nun, wie wir sie entfernen können. Im Datenbankmanagement ist es genauso wichtig zu wissen, wie man Datenbanken löscht, wie wie man sie erstellt. Wir behalten nur die Datenbank 'Hello_World' und entfernen die anderen.

Löschen einer Datenbank mit dem MySQL-Client

Melden Sie sich an, wenn Sie noch nicht im MySQL-Client sind:

sudo mysql -u root

Jetzt löschen wir die Datenbank 'hello_world':

DROP DATABASE hello_world;
SHOW DATABASES;

Sie sollten feststellen, dass 'hello_world' nicht mehr in der Liste 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, wenn Sie den Befehl DROP DATABASE verwenden. Dieser löscht die Datenbank und alle ihre Inhalte dauerhaft, ohne nach einer Bestätigung zu fragen. In einer Produktionsumgebung sollten Sie in der Regel Sicherheitsmaßnahmen und Backups einrichten, bevor Sie solche Operationen durchführen.

Löschen einer Datenbank mit mysqladmin

Jetzt verwenden wir 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 fragt.

Beenden Sie den MySQL-Client, indem Sie exit oder quit eingeben, und führen Sie dann den folgenden Befehl in Ihrem Terminal aus:

mysqladmin -u root -p drop hello_world2

Sie werden aufgefordert, die Aktion zu bestätigen:

Enter password:
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, um die Bestätigung zu geben. Dieser zusätzliche Bestätigungsschritt kann helfen, versehentliche Datenbanklöschungen zu vermeiden.

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 erfolgreich die zusätzlichen Datenbanken bereinigt und nur die benötigten behalten.

Auswählen und Verwenden von Datenbanken

Nachdem wir Datenbanken erstellt und gelöscht haben, lernen wir nun, wie man eine bestimmte Datenbank auswählt und verwendet. Dies ist eine entscheidende Fähigkeit, da der Großteil Ihrer Arbeit in MySQL das Arbeiten innerhalb einer bestimmten Datenbank beinhaltet.

Auswählen einer Datenbank

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, es sei denn, Sie geben etwas anderes an.

Auflisten der Tabellen in einer Datenbank

Um die Tabellen in der aktuellen Datenbank anzuzeigen, verwenden Sie den Befehl SHOW TABLES;:

SHOW TABLES;

Da wir in unserer 'Hello_World'-Datenbank noch keine Tabellen erstellt haben, werden Sie sehen:

Empty set (0.00 sec)

Dies ist normal für eine neue Datenbank. Wenn Sie Tabellen erstellen, werden sie in dieser Liste erscheinen.

Lassen Sie uns zu einer anderen Datenbank wechseln und deren Tabellen auflisten, um zu sehen, wie dies mit einer gefüllten Datenbank funktioniert:

USE mysql;
SHOW TABLES;

Sie werden eine Liste der Tabellen in der Systemdatenbank 'mysql' sehen:

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 werden Sie Ihre eigenen Tabellen in Ihren benutzerdefinierten Datenbanken erstellen und verwalten.

Abrufen von MySQL-Metadaten

In diesem letzten Schritt werden wir untersuchen, wie man verschiedene Arten von Metadaten aus MySQL abruft. Metadaten sind "Daten über Daten" – sie liefern Informationen über das Datenbanksystem selbst, nicht über die darin gespeicherten Daten. Diese Informationen können für das Verständnis und die Verwaltung Ihrer MySQL-Umgebung von entscheidender Bedeutung sein.

Serverversion

Um die MySQL-Serverversion zu erhalten, verwenden Sie:

SELECT VERSION();

Sie werden eine Ausgabe ähnlich der folgenden sehen:

MariaDB [mysql]> SELECT VERSION();
+----------------------------------+
| VERSION()                        |
+----------------------------------+
| 10.6.12-MariaDB-0ubuntu0.22.04.1 |
+----------------------------------+
1 row in set (0.000 sec)

Diese Informationen sind nützlich, wenn Sie wissen müssen, welche Funktionen in Ihrer aktuellen MySQL-Version verfügbar sind, oder wenn Sie versionsspezifische Probleme beheben müssen.

Aktuelle Datenbank

Um zu sehen, welche Datenbank Sie derzeit verwenden:

SELECT DATABASE();

Die Ausgabe zeigt den Namen der aktuellen Datenbank 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 derzeit arbeiten.

Aktueller Benutzer

Um den aktuellen Benutzer anzuzeigen:

SELECT USER();

Sie werden eine Ausgabe wie die folgende sehen:

MariaDB [mysql]> SELECT USER();
+----------------+
| USER()         |
+----------------+
| root@localhost |
+----------------+
1 row in set (0.000 sec)

Dies zeigt den MySQL-Benutzer, mit dem Sie sich angemeldet haben, und den Host, von dem aus Sie sich verbinden. 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 den Speichergebrauch, die Verbindungslimits und viele andere Parameter.

Beide Befehle erzeugen eine umfangreiche Ausgabe. Sie können sie im Terminal durchscrollen oder nach bestimmten Informationen filtern. Beispielsweise können Sie Variablen anzeigen, die sich auf den Pufferpool beziehen:

SHOW VARIABLES LIKE '%buffer%';

Diese Befehle liefern umfangreiche Informationen über die Konfiguration und den aktuellen Zustand Ihres MySQL-Servers. Das Verständnis dieser Metadaten kann für die Optimierung der Leistung, die Behebung von Problemen und die Sicherstellung, dass Ihr Server für Ihre Bedürfnisse korrekt konfiguriert ist, von entscheidender Bedeutung sein.

Beispielsweise können Sie SHOW STATUS verwenden, um die Anzahl der ausgeführten Abfragen zu überprüfen:

SHOW STATUS LIKE 'Questions';

Dies könnte eine Ausgabe wie die folgende 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 seit dem Start des Servers ausgeführt wurden.

In ähnlicher Weise können Sie SHOW VARIABLES verwenden, um wichtige Konfigurationseinstellungen wie die maximale zulässige Paketgröße zu überprüfen:

SHOW VARIABLES LIKE 'max_allowed_packet';

Dies könnte eine Ausgabe wie die folgende liefern:

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/zwischengespeicherten Zeichenfolge an, was wichtig sein kann, wenn Sie mit großen Datenmengen arbeiten.

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 die Optimierung und die Behebung von Problemen von entscheidender Bedeutung sein kann.

Zusammenfassung

In diesem Lab haben wir grundlegende Aspekte des Datenbankmanagements in MySQL behandelt:

1. Das Erstellen von Datenbanken sowohl mit dem MySQL-Client als auch mit dem mysqladmin-Tool
2. Das Auflisten vorhandener Datenbanken und das Verständnis ihrer Zwecke
3. Das Verständnis der Groß- und Kleinschreibung von Datenbanknamen in MySQL
4. Das sichere Löschen von Datenbanken und die Wichtigkeit der Vorsicht bei diesem Vorgang
5. Das Auswählen und Wechseln zwischen Datenbanken
6. Das Abrufen wichtiger Metadaten über den MySQL-Server und die Datenbanken

Diese Fähigkeiten bilden die Grundlage für die Arbeit mit MySQL-Datenbanken. Wenn Sie in Ihrer Datenbankreise voranschreiten, werden Sie auf diesen Grundlagen aufbauen, um komplexere Datenbankoperationen und Verwaltungsaufgaben auszuführen.