Grundlagen der Datenbankverwaltung mit PostgreSQL

Einführung

In diesem Lab lernen Sie die Grundlagen der Datenbankverwaltung mit PostgreSQL. Das Lab behandelt wesentliche Operationen zur Verwaltung von Datenbanken, einschließlich der Erstellung neuer Datenbanken, der Auflistung und Verbindung zu bestehenden Datenbanken und der Entfernung von Datenbanken, wenn diese nicht mehr benötigt werden.

Sie beginnen mit der Erstellung einer neuen Datenbank mit dem Befehl createdb und überprüfen deren Erstellung mit dem Befehl psql. Anschließend lernen Sie, wie Sie alle verfügbaren Datenbanken auflisten und sich mit einer bestimmten Datenbank verbinden. Abschließend werden Sie untersuchen, wie Sie eine Datenbank löschen (drop) und Datenbank-Metadaten anzeigen können. Dieses Lab bietet eine praktische Einführung in grundlegende Aufgaben der Datenbankadministration in PostgreSQL.

Eine neue Datenbank erstellen

In diesem Schritt lernen Sie, wie Sie eine neue Datenbank in PostgreSQL erstellen. Das Erstellen einer Datenbank ist der erste Schritt zum Organisieren und Speichern Ihrer Daten.

Bevor wir beginnen, wollen wir verstehen, was eine Datenbank ist. Eine Datenbank ist eine strukturierte Sammlung von Daten, die für einfachen Zugriff, Verwaltung und Aktualisierung organisiert ist. In PostgreSQL ist eine Datenbank ein Container für Tabellen, Views (Ansichten) und andere Datenbankobjekte.

Um eine neue Datenbank zu erstellen, verwenden Sie den Befehl createdb. Dieser Befehl ist ein Wrapper um den SQL-Befehl CREATE DATABASE.

Öffnen Sie ein Terminal: Wenn Sie noch keines geöffnet haben, starten Sie ein Terminalfenster.
Erstellen Sie eine neue Datenbank: Verwenden Sie den Befehl createdb, gefolgt von dem Namen, den Sie Ihrer Datenbank geben möchten. Um beispielsweise eine Datenbank namens mydatabase zu erstellen, führen Sie den folgenden Befehl aus:
```
createdb mydatabase
```
Dieser Befehl erstellt eine neue Datenbank namens mydatabase. Wenn der Befehl erfolgreich ist, sehen Sie keine Ausgabe.
Überprüfen Sie die Datenbankerstellung: Um zu bestätigen, dass die Datenbank erstellt wurde, können Sie alle Datenbanken mit dem Befehl psql auflisten. Stellen Sie zunächst eine Verbindung zur Standarddatenbank postgres her:
```
psql -d postgres
```
Sie werden die Eingabeaufforderung postgres=# sehen.

Datenbanken auflisten: Führen Sie an der Eingabeaufforderung postgres=# den folgenden SQL-Befehl aus, um alle Datenbanken aufzulisten:

\l

Dieser Befehl zeigt eine Liste der Datenbanken an, einschließlich der von Ihnen gerade erstellten (mydatabase). Sie sollten eine ähnliche Ausgabe wie diese sehen:

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 mydatabase| labex    | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)

Beachten Sie, dass mydatabase in der Liste enthalten ist.

psql beenden: Um die psql-Eingabeaufforderung zu verlassen, geben Sie Folgendes ein:
```
\q
```
und drücken Sie die Eingabetaste. Sie kehren zur normalen Terminaleingabeaufforderung zurück.

Sie haben nun erfolgreich eine neue Datenbank in PostgreSQL erstellt.

Datenbanken auflisten und verbinden

In diesem Schritt lernen Sie, wie Sie verfügbare Datenbanken auflisten und sich mit einer bestimmten Datenbank mithilfe des Befehlszeilentools psql verbinden.

Öffnen Sie ein Terminal: Wenn Sie noch keines geöffnet haben, starten Sie ein Terminalfenster.

Verfügbare Datenbanken auflisten: Um alle Datenbanken aufzulisten, können Sie den Befehl psql mit der Option -l (das ist ein kleines 'L') verwenden. Diese Option listet alle Datenbanken auf dem Server auf. Da Sie keine Datenbank angegeben haben, mit der Sie sich verbinden möchten, versucht psql, sich mit Ihrem aktuellen Benutzernamen zu verbinden.

psql -l

Dieser Befehl zeigt eine Liste der Datenbanken zusammen mit ihren Eigentümern, Kodierungen und anderen Informationen an. Sie sollten eine ähnliche Ausgabe wie diese sehen:

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 mydatabase| labex    | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)

Diese Ausgabe zeigt die Namen der Datenbanken, ihre Eigentümer und andere Details. Sie sollten die Datenbank mydatabase sehen, die Sie im vorherigen Schritt erstellt haben.

Mit einer bestimmten Datenbank verbinden: Um sich mit einer bestimmten Datenbank zu verbinden, verwenden Sie den Befehl psql mit der Option -d, gefolgt vom Namen der Datenbank. Um sich beispielsweise mit der Datenbank mydatabase zu verbinden, führen Sie den folgenden Befehl aus:
```
psql -d mydatabase
```
Wenn die Verbindung erfolgreich ist, wird die Eingabeaufforderung mydatabase=# angezeigt. Dies zeigt an, dass Sie jetzt mit der Datenbank mydatabase verbunden sind.

Verbindung überprüfen: Um zu überprüfen, ob Sie mit der richtigen Datenbank verbunden sind, können Sie einen einfachen SQL-Befehl ausführen, z. B.:

SELECT version();

Dieser Befehl zeigt die Version des PostgreSQL-Servers an, mit dem Sie verbunden sind. Die Ausgabe sieht ungefähr so aus:

                                                 version
----------------------------------------------------------------------------------------------------------------
 PostgreSQL 14.7 (Debian 14.7-1.pgdg110+1) on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
(1 row)

psql beenden: Um die psql-Eingabeaufforderung zu verlassen, geben Sie Folgendes ein:
```
\q
```
und drücken Sie die Eingabetaste. Sie kehren zur normalen Terminaleingabeaufforderung zurück.

Sie haben nun erfolgreich die verfügbaren Datenbanken aufgelistet und sich mit psql mit einer bestimmten Datenbank verbunden.

Eine Datenbank löschen

In diesem Schritt lernen Sie, wie Sie eine Datenbank in PostgreSQL löschen (engl. drop). Das Löschen einer Datenbank ist eine dauerhafte Aktion, daher ist es wichtig, bei der Verwendung dieses Befehls vorsichtig zu sein. Alle Daten innerhalb der Datenbank gehen verloren.

Öffnen Sie ein Terminal: Wenn Sie noch keines geöffnet haben, starten Sie ein Terminalfenster.
Datenbank löschen: Verwenden Sie den Befehl dropdb, gefolgt vom Namen der Datenbank, die Sie löschen möchten. Um beispielsweise die Datenbank mydatabase zu löschen, führen Sie den folgenden Befehl aus:
```
dropdb mydatabase
```
Dieser Befehl löscht die Datenbank mydatabase. Wenn der Befehl erfolgreich ist, sehen Sie keine Ausgabe.

Wichtig: Bevor Sie eine Datenbank löschen, stellen Sie sicher, dass niemand damit verbunden ist. Wenn aktive Verbindungen bestehen, kann der Befehl dropdb fehlschlagen.
Überprüfen Sie die Datenbanklöschung: Um zu bestätigen, dass die Datenbank gelöscht wurde, können Sie alle Datenbanken mit dem Befehl psql auflisten. Stellen Sie zunächst eine Verbindung zur Standarddatenbank postgres her:
```
psql -d postgres
```
Sie werden die Eingabeaufforderung postgres=# sehen.

Datenbanken auflisten: Führen Sie an der Eingabeaufforderung postgres=# den folgenden SQL-Befehl aus, um alle Datenbanken aufzulisten:

\l

Dieser Befehl zeigt eine Liste der Datenbanken an. Überprüfen Sie, ob mydatabase nicht mehr in der Liste enthalten ist.

                                 List of databases
   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges
-----------+----------+----------+-------------+-------------+-----------------------
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 |
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(3 rows)

Wenn mydatabase nicht aufgeführt ist, wurde sie erfolgreich gelöscht.

psql beenden: Um die psql-Eingabeaufforderung zu verlassen, geben Sie Folgendes ein:
```
\q
```
und drücken Sie die Eingabetaste. Sie kehren zur normalen Terminaleingabeaufforderung zurück.

Sie haben nun erfolgreich eine Datenbank in PostgreSQL gelöscht. Denken Sie daran, beim Löschen von Datenbanken Vorsicht walten zu lassen, da diese Aktion irreversibel ist.

Datenbank-Metadaten anzeigen

In diesem Schritt lernen Sie, wie Sie Datenbank-Metadaten in PostgreSQL anzeigen. Metadaten sind "Daten über Daten". Im Kontext einer Datenbank beschreiben Metadaten die Struktur und die Eigenschaften der Datenbank selbst, einschließlich Informationen über Tabellen, Spalten, Datentypen und Constraints (Einschränkungen).

Öffnen Sie ein Terminal: Wenn Sie noch keines geöffnet haben, starten Sie ein Terminalfenster.
Verbinden Sie sich mit der postgres-Datenbank: Da wir mydatabase im vorherigen Schritt gelöscht haben, verbinden wir uns mit der Standarddatenbank postgres, um Metadaten zu untersuchen.
```
psql -d postgres
```
Sie werden die Eingabeaufforderung postgres=# sehen.

Tabellen auflisten: Um alle Tabellen in der aktuell verbundenen Datenbank aufzulisten, können Sie den Befehl \dt verwenden.

\dt

Da wir noch keine Tabellen erstellt haben, sollte die Ausgabe leer sein oder Systemtabellen anzeigen. Es könnte so aussehen:

Did not find any relations.

oder

             List of relations
 Schema |         Name          | Type  |  Owner
--------+-----------------------+-------+----------
 pg_catalog | pg_aggregate          | table | postgres
 pg_catalog | pg_am               | table | postgres
 pg_catalog | pg_amop             | table | postgres
...

Die Ausgabe zeigt das Schema, den Namen, den Typ und den Eigentümer jeder Tabelle.

Eine Tabelle beschreiben: Um detaillierte Informationen zu einer bestimmten Tabelle anzuzeigen, können Sie den Befehl \d gefolgt vom Tabellennamen verwenden. Da wir keine benutzererstellte Tabelle haben, untersuchen wir eine Systemtabelle, beispielsweise pg_class.

\d pg_class

Dieser Befehl zeigt die Struktur der Tabelle pg_class an, einschließlich Spaltennamen, Datentypen und aller Constraints. Die Ausgabe ist recht umfangreich, bietet aber einen umfassenden Überblick über die Tabellendefinition.

                                     Table "pg_catalog.pg_class"
      Column       |   Type    | Collation | Nullable | Default | Storage  | Stats target | Description
-------------------+-----------+-----------+----------+---------+----------+--------------+-------------
 oid               | oid       |           | not null |         | plain    |              |
 relname           | name      |           | not null |         | plain    |              |
 relnamespace      | oid       |           | not null |         | plain    |              |
 reltype           | oid       |           | not null |         | plain    |              |
 reloftype         | oid       |           | not null |         | plain    |              |
 relowner          | oid       |           | not null |         | plain    |              |
 relam             | oid       |           | not null |         | plain    |              |
 relfilenode       | oid       |           | not null |         | plain    |              |
 reltablespace     | oid       |           | not null |         | plain    |              |
 relpages          | integer   |           | not null |         | plain    |              |
 reltuples         | real      |           | not null |         | plain    |              |
 relallvisible     | boolean   |           | not null |         | plain    |              |
 reltoastrelid     | oid       |           | not null |         | plain    |              |
 relhasindex       | boolean   |           | not null |         | plain    |              |
 relhasrules       | boolean   |           | not null |         | plain    |              |
 relhastriggers    | boolean   |           | not null |         | plain    |              |
 relhassubclass    | boolean   |           | not null |         | plain    |              |
 relrowsecurity    | boolean   |           | not null |         | plain    |              |
 relforcerowsecurity| boolean   |           | not null |         | plain    |              |
 relispopulated    | boolean   |           | not null |         | plain    |              |
 relreplident      | character |           | not null |         | plain    |              |
 relispartition    | boolean   |           | not null |         | plain    |              |
 relrewrite        | oid       |           | not null |         | plain    |              |
 relacl            | aclitem[] |           |          |         | plain    |              |
 reloptions        | text[]    |           |          |         | plain    |              |
 relpartbound      | pg_node_tree |           |          |         | extended |              |
Indexes:
    "pg_class_oid_index" UNIQUE, btree (oid)
    "pg_class_relname_nsp_index" UNIQUE, btree (relname, relnamespace)
Foreign-key constraints:
    "pg_class_relam_fkey" FOREIGN KEY (relam) REFERENCES pg_am(oid)
    "pg_class_relnamespace_fkey" FOREIGN KEY (relnamespace) REFERENCES pg_namespace(oid)
    "pg_class_relowner_fkey" FOREIGN KEY (relowner) REFERENCES pg_authid(oid)
    "pg_class_reltoastrelid_fkey" FOREIGN KEY (reltoastrelid) REFERENCES pg_class(oid)
Referenced by:
    TABLE "pg_statistic_ext" CONSTRAINT "pg_statistic_ext_relid_fkey" FOREIGN KEY (relid) REFERENCES pg_class(oid)
    TABLE "pg_rewrite" CONSTRAINT "pg_rewrite_ev_class_fkey" FOREIGN KEY (ev_class) REFERENCES pg_class(oid)
    TABLE "pg_trigger" CONSTRAINT "pg_trigger_tgrelid_fkey" FOREIGN KEY (tgrelid) REFERENCES pg_class(oid)

psql beenden: Um die psql-Eingabeaufforderung zu verlassen, geben Sie Folgendes ein:
```
\q
```
und drücken Sie die Eingabetaste. Sie kehren zur normalen Terminaleingabeaufforderung zurück.

Sie haben nun erfolgreich Datenbank-Metadaten in PostgreSQL mit psql angezeigt. Dies ermöglicht es Ihnen, die Struktur und die Eigenschaften Ihrer Datenbanken und Tabellen zu verstehen.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen der Datenbankverwaltung in PostgreSQL kennengelernt, beginnend mit dem Erstellen einer neuen Datenbank. Der Prozess umfasst die Verwendung des Befehls createdb, gefolgt vom gewünschten Datenbanknamen im Terminal. Eine erfolgreiche Ausführung erstellt die Datenbank ohne Ausgabe.

Um die Erstellung zu überprüfen, verbinden Sie sich mit der Standarddatenbank postgres mit psql -d postgres und verwenden dann den Befehl \l, um alle verfügbaren Datenbanken aufzulisten und zu bestätigen, dass die neu erstellte Datenbank vorhanden ist.