So erstellen und löschen Sie Datenbanken und Tabellen in PostgreSQL

Einführung

PostgreSQL und andere Verwaltungssysteme für relationale Datenbanken verwenden Datenbanken und Tabellen ihre Daten zu strukturieren und zu organisieren. Wir können die Definition dieser beiden Begriffe schnell überprüfen:

• Datenbanken: verschiedene Sätze von Strukturen und Daten voneinander trennen
• Tabellen: Definieren Sie die Datenstruktur und speichern Sie die tatsächlichen Datenwerte in Datenbanken

In PostgreSQL gibt es auch ein Zwischenobjekt zwischen Datenbanken und Tabellen namens Schema :

• Schema: ein Namensraum innerhalb einer Datenbank, der Tabellen, Indizes, Ansichten und andere Elemente enthält.

Diese Anleitung behandelt nicht direkt das PostgreSQL-Konzept eines Schemas, aber es ist gut zu wissen, dass es da ist.

Stattdessen konzentrieren wir uns darauf, wie man PostgreSQL-Datenbanken und -Tabellen erstellt und zerstört. In den Beispielen wird hauptsächlich SQL verwendet, aber gegen Ende zeigen wir Ihnen, wie Sie einige dieser Aufgaben über die Befehlszeile ausführen. Diese Alternativen verwenden Tools, die in der standardmäßigen PostgreSQL-Installation enthalten sind und verfügbar sind, wenn Sie Administratorzugriff auf den PostgreSQL-Host haben.

Einige der in diesem Handbuch behandelten Anweisungen, insbesondere die PostgreSQL CREATE TABLE Anweisung, haben viele zusätzliche Optionen, die den Rahmen dieses Artikels sprengen würden. Weitere Informationen finden Sie in der offiziellen PostgreSQL-Dokumentation.

Voraussetzungen

Um dieser Anleitung zu folgen, müssen Sie sich bei einer PostgreSQL-Instanz mit einem Benutzer mit Administratorrechten unter Verwendung von psql anmelden Befehlszeilen-Client. Ihre PostgreSQL-Instanz kann lokal oder remote installiert oder von einem Anbieter bereitgestellt werden.

Insbesondere benötigt Ihr PostgreSQL-Benutzer die CREATE DB oder ein Superuser sein , was Sie mit \du überprüfen können meta-Befehl in psql :

\du
 

                                   List of roles Role name |                         Attributes                         | Member of-----------+------------------------------------------------------------+----------- postgres  | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
 

Das postgres Superuser, der automatisch bei der Installation erstellt wird, hat die erforderlichen Rechte, aber Sie können jeden Benutzer mit Create DB verwenden Privileg.

Neue Datenbank erstellen

Sobald Sie mit psql mit Ihrer PostgreSQL-Instanz verbunden sind oder einem anderen SQL-Client können Sie eine Datenbank mit SQL erstellen.

Die grundlegende Syntax zum Erstellen einer Datenbank lautet:

CREATE DATABASE db_name;
 

Dadurch wird eine Datenbank namens db_name erstellt auf dem aktuellen Server mit dem aktuellen Benutzer, der als Eigentümer der neuen Datenbank festgelegt ist, unter Verwendung der Standarddatenbankeinstellungen. Sie können die Eigenschaften des Standard-template1 anzeigen Vorlage mit dem folgenden psql Meta-Befehl:

\l template1
 

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

Sie können zusätzliche Parameter hinzufügen, um die Art und Weise zu ändern, wie Ihre Datenbank erstellt wird. Dies sind einige allgemeine Optionen:

• Codierung: legt die Zeichenkodierung für die Datenbank fest.
• LC_COLLATE: legt die Sortierung fest , oder sort, Reihenfolge für die Datenbank. Dies ist eine Lokalisierungsoption, die bestimmt, wie Artikel bei der Bestellung organisiert werden.
• LC_CTYPE: legt die Zeichenklassifikation für die neue Datenbank fest. Dies ist eine Lokalisierungsoption, die beeinflusst, welche Zeichen als Großbuchstaben, Kleinbuchstaben und Ziffern betrachtet werden.

Diese können dazu beitragen sicherzustellen, dass die Datenbank Daten in den Formaten speichern kann, die Sie unterstützen möchten, und mit den Lokalisierungseinstellungen Ihres Projekts.

Um beispielsweise sicherzustellen, dass Ihre Datenbank mit Unicode-Unterstützung erstellt wird, und um das eigene Gebietsschema des Servers zu überschreiben, um die Lokalisierung für amerikanisches Englisch zu verwenden (diese alle stimmen zufällig mit den Werten in template1 überein). wie oben gezeigt, sodass tatsächlich keine Änderung eintritt), könnten Sie Folgendes eingeben:

CREATE DATABASE db_name  ENCODING 'UTF8'  LC_COLLATE 'en_US.UTF-8'  LC_CTYPE 'en_US.UTF-8';
 

Um den Beispielen in diesem Handbuch zu folgen, erstellen Sie eine Datenbank mit dem Namen school unter Verwendung der standardmäßigen Gebietsschemaeinstellungen Ihrer Instanz und der UTF8-Zeichencodierung:

CREATE DATABASE school ENCODING 'UTF8';
 

Dadurch wird Ihre neue Datenbank mit den von Ihnen angegebenen Spezifikationen erstellt.

Vorhandene Datenbanken auflisten

Um festzustellen, welche Datenbanken derzeit auf Ihrem Server oder Cluster verfügbar sind, können Sie die folgende SQL-Anweisung verwenden:

SELECT datname FROM pg_database;
 

Dadurch werden alle Datenbanken aufgelistet, die derzeit in der Umgebung definiert sind:

  datname----------- _dodb template1 template0 defaultdb school(5 rows)
 

Wie bereits erwähnt, wenn Sie mit psql verbunden sind client, können Sie diese Information auch \l erhalten Meta-Befehl:

\l
 

Dies zeigt die verfügbaren Datenbanknamen zusammen mit ihren Eigentümern, Kodierungen, Gebietsschema-Einstellungen und Privilegien:

                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | 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(5 rows)
 

Die school Datenbank, die wir erstellt haben, wird unter den anderen Datenbanken auf dem System angezeigt. Dies ist eine gute Möglichkeit, sich einen Überblick über die Datenbanken in Ihrem Server oder Cluster zu verschaffen.

Erstellen Sie Tabellen in Datenbanken

Nachdem Sie eine oder mehrere Datenbanken erstellt haben, können Sie damit beginnen, Tabellen zum Speichern Ihrer Daten zu definieren. Tabellen bestehen aus einem Namen und einem definierten Schema, das die Felder und Datentypen festlegt, die jeder Datensatz enthalten muss.

PostgreSQL CREATE TABLE Syntax

Sie können Tabellen mit CREATE TABLE erstellen Erklärung. Eine vereinfachte Grundsyntax für den Befehl sieht wie folgt aus:

CREATE TABLE table_name (    column_name TYPE [column_constraint],    [table_constraint,]);
 

Die Komponenten der obigen Syntax umfassen Folgendes:

• CREATE TABLE table_name :Die grundlegende Erstellungsanweisung, die signalisiert, dass Sie eine Tabelle definieren möchten. Der table_name Platzhalter sollte durch den Namen der Tabelle ersetzt werden, die Sie verwenden möchten.
• column_name TYPE :Definiert eine grundlegende Spalte innerhalb der Tabelle. Der column_name Platzhalter sollte durch den Namen ersetzt werden, den Sie für Ihre Spalte verwenden möchten. Der TYPE gibt den PostgreSQL-Datentyp für die Spalte an. In der Tabelle gespeicherte Daten müssen der Spaltenstruktur und den Spaltendatentypen entsprechen, um akzeptiert zu werden.
• column_constraint :Spaltenbeschränkungen sind optionale Beschränkungen, um weitere Beschränkungen für die Daten hinzuzufügen, die in der Spalte gespeichert werden können. Beispielsweise können Sie verlangen, dass Einträge nicht null, eindeutig oder positive ganze Zahlen sind.
• table_constraints :Tabelleneinschränkungen ähneln Spalteneinschränkungen, beinhalten jedoch die Interaktion mehrerer Spalten. Beispielsweise könnten Sie eine Tabellenbeschränkung haben, die überprüft, ob ein DATE_OF_BIRTH ist liegt vor DATE_OF_DEATH in einer Tabelle.

Erstelle Tabellen bedingt mit dem IF NOT EXISTS Klausel

Wenn Sie versuchen, eine Tabelle in PostgreSQL zu erstellen, die bereits in der Datenbank vorhanden ist, tritt standardmäßig ein Fehler auf. Um dieses Problem in Fällen zu umgehen, in denen Sie eine Tabelle erstellen möchten, wenn sie nicht vorhanden ist, aber einfach weitermachen möchten, wenn sie bereits vorhanden ist, können Sie den IF NOT EXISTS verwenden Klausel. Der IF NOT EXISTS Optionaler Qualifizierer, der PostgreSQL anweist, die Anweisung zu ignorieren, wenn die Datenbank bereits existiert.

Um den IF NOT EXISTS zu verwenden -Klausel, fügen Sie sie nach CREATE TABLE in den Befehl ein Syntax und vor dem Tabellennamen:

CREATE TABLE IF NOT EXISTS table_name (    column_name TYPE [column_constraint],    [table_constraint,]);
 

Diese Variante versucht, die Tabelle zu erstellen. Wenn eine Tabelle mit diesem Namen bereits in der angegebenen Datenbank existiert, gibt PostgreSQL eine Warnung aus, die darauf hinweist, dass der Tabellenname bereits vergeben ist, anstatt mit einem Fehler abzubrechen.

Wie man Tabellen in PostgreSQL erstellt

Die obige Syntax reicht aus, um grundlegende Tabellen zu erstellen. Als Beispiel erstellen wir zwei Tabellen innerhalb unserer school Datenbank. Eine Tabelle wird supplies genannt und die anderen werden teachers genannt :

Im supplies Tabelle möchten wir die folgenden Felder haben:

• ID: Eine eindeutige ID für jede Art von Schulbedarf.
• Name: Der Name eines bestimmten Schulartikels.
• Beschreibung: Eine kurze Beschreibung des Artikels.
• Hersteller: Der Name des Artikelherstellers.
• Farbe: Die Farbe des Artikels.
• Inventar: Die Anzahl der Artikel, die wir für eine bestimmte Art von Schulmaterial haben. Dieser sollte nie kleiner als 0 sein.

Wir können die supplies erstellen Tabelle mit den oben genannten Qualitäten unter Verwendung des folgenden SQL.

Wechseln Sie zunächst in die school Datenbank, die Sie mit psql erstellt haben indem Sie Folgendes eingeben:

\c school
 

Dadurch wird die Datenbank geändert, auf die unsere zukünftigen Befehle abzielen. Ihre Eingabeaufforderung sollte sich ändern, um die Datenbank widerzuspiegeln.

Erstellen Sie als Nächstes die supplies Tabelle mit der folgenden Anweisung:

CREATE TABLE supplies (  id INT PRIMARY KEY,  name VARCHAR,  description VARCHAR,  manufacturer VARCHAR,  color VARCHAR,  inventory int CHECK (inventory > 0));
 

Dadurch werden die supplies erstellt Tabelle innerhalb der school Datenbank. Der PRIMARY KEY Spaltenbeschränkung ist eine spezielle Beschränkung, die verwendet wird, um Spalten anzugeben, die Datensätze in der Tabelle eindeutig identifizieren können. Daher gibt die Einschränkung an, dass die Spalte nicht null sein kann und eindeutig sein muss. PostgreSQL erstellt Indizes für Primärschlüsselspalten, um die Abfragegeschwindigkeit zu erhöhen.

Überprüfen Sie, ob die neue Tabelle vorhanden ist, indem Sie Folgendes eingeben:

\dt
 

          List of relations Schema |   Name   | Type  |  Owner  --------+----------+-------+--------- public | supplies | table | doadmin(1 row)
 

Überprüfen Sie, ob das Schema das beabsichtigte Design widerspiegelt, indem Sie Folgendes eingeben:

\d supplies
 

                      Table "public.supplies"    Column    |       Type        | Collation | Nullable | Default--------------+-------------------+-----------+----------+--------- id           | integer           |           | not null | name         | character varying |           |          | description  | character varying |           |          | manufacturer | character varying |           |          | color        | character varying |           |          | inventory    | integer           |           |          |Indexes:    "supplies_pkey" PRIMARY KEY, btree (id)Check constraints:    "supplies_inventory_check" CHECK (inventory > 0)
 

Wir können jede der Spalten und Datentypen sehen, die wir angegeben haben. Die Spaltenbeschränkung, die wir für das inventory definiert haben Spalte wird am Ende aufgelistet.

Als Nächstes erstellen wir einen teachers Tisch. In dieser Tabelle sollten die folgenden Spalten vorhanden sein:

• Mitarbeiter-ID :Eine eindeutige Mitarbeiteridentifikationsnummer.
• Vorname :Vorname des Lehrers.
• Nachname :Nachname des Lehrers.
• Betreff :Das Fach, das der Lehrer unterrichten soll.
• Klassenstufe :Die Klassenstufe der Schüler, die der Lehrer unterrichten soll.

Erstellen Sie die teachers Tabelle mit obigem Schema mit folgendem SQL:

CREATE TABLE teachers (  id INT PRIMARY KEY,  first_name VARCHAR,  last_name VARCHAR,  subject VARCHAR,  grade_level int);
 

Wie man Tabellen mit Primärschlüsseln und Fremdschlüsseln erstellt

Informationen zum Erstellen von Tabellen mit Primär- und Fremdschlüsseln finden Sie in einigen unserer anderen PostgreSQL-Leitfäden. Primärschlüssel und Fremdschlüssel sind beide Arten von Datenbankeinschränkungen in PostgreSQL.

Ein Primärschlüssel ist eine spezielle Spalte oder Spalte, die garantiert eindeutig über alle Zeilen innerhalb derselben Tabelle hinweg ist. Alle Primärschlüssel können verwendet werden, um eine bestimmte Zeile eindeutig zu identifizieren. Primärschlüssel stellen nicht nur sicher, dass jede Zeile einen eindeutigen Wert für die Primärschlüsselspalten hat, sie stellen auch sicher, dass keine Zeile NULL enthält Werte für diese Spalte. Häufig verwendet der Primärschlüssel in PostgreSQL das folgende Format, um einen automatisch zugewiesenen inkrementierenden Primärschlüssel anzugeben:id SERIAL PRIMARY KEY .

Fremdschlüssel sind eine Möglichkeit sicherzustellen, dass eine oder mehrere Spalten in einer Tabelle mit den in einer anderen Tabelle enthaltenen Werten übereinstimmen. Dies trägt dazu bei, die referenzielle Integrität zwischen Tabellen sicherzustellen.

Wie man Tabellen in PostgreSQL anzeigt

In PostgreSQL können Sie Tabellen auf verschiedene Arten auflisten, je nachdem, nach welchen Informationen Sie suchen.

Wenn Sie sehen möchten, welche Tabellen in Ihrer Datenbank verfügbar sind, können Sie den \dt verwenden Meta-Befehl, der in psql enthalten ist Client, um alle Tabellen aufzulisten, wie wir oben gezeigt haben:

\dt
 

          List of relations Schema |   Name   | Type  |  Owner--------+----------+-------+--------- public | supplies | table | doadmin public | teachers | table | doadmin(2 rows)
 

Sie können auch prüfen, ob das Schema für die Tabelle Ihren Vorgaben entspricht:

\d teachers
 

                     Table "public.teachers"   Column    |       Type        | Collation | Nullable | Default-------------+-------------------+-----------+----------+--------- id          | integer           |           | not null | first_name  | character varying |           |          | last_name   | character varying |           |          | subject     | character varying |           |          | grade_level | integer           |           |          |Indexes:    "teachers_pkey" PRIMARY KEY, btree (id)
 

Die teachers Tabelle scheint unserer Definition zu entsprechen.

Tabellen ändern

Wenn Sie das Schema einer bestehenden Tabelle in PostgreSQL ändern müssen, können Sie ALTER TABLE verwenden Befehl. Die ALTER TABLE Der Befehl ist dem CREATE TABLE sehr ähnlich Befehl, sondern arbeitet mit einer bestehenden Tabelle.

Tabellensyntax ändern

Die grundlegende Syntax zum Ändern von Tabellen in PostgreSQL sieht folgendermaßen aus:

ALTER TABLE <table_name> <change_command> <change_parameters>
 

Der <change_command> gibt die genaue Art der Änderung an, die Sie vornehmen möchten, ob es sich dabei um das Festlegen verschiedener Optionen in der Tabelle, das Hinzufügen oder Entfernen von Spalten oder das Ändern von Typen oder Einschränkungen handelt. Die <change_parameters> Ein Teil des Befehls enthält alle zusätzlichen Informationen, die PostgreSQL benötigt, um die Änderung abzuschließen.

Hinzufügen von Spalten zu Tabellen

Mit ADD COLUMN können Sie einer PostgreSQL-Tabelle eine Spalte hinzufügen Befehl ändern. Die Änderungsparameter umfassen den Spaltennamen, Typ und Optionen, genau so, wie Sie sie in CREATE TABLE angeben würden Befehl.

Zum Beispiel, um eine Spalte namens missing_column hinzuzufügen des text in eine Tabelle namens some_table eingeben , würden Sie Folgendes eingeben:

ALTER TABLE some_table ADD COLUMN missing_column text;
 

Spalten aus Tabellen entfernen

Wenn Sie stattdessen eine vorhandene Spalte entfernen möchten, können Sie DROP COLUMN verwenden stattdessen befehlen. Sie müssen den Namen der Spalte, die Sie löschen möchten, als Änderungsparameter angeben:

ALTER TABLE some_table DROP COLUMN useless_column;
 

Ändern des Datentyps einer Spalte

Um den Datentyp zu ändern, den PostgreSQL für eine bestimmte Spalte verwendet, können Sie ALTER COLUMN verwenden Änderungsbefehl mit dem SET DATA TYPE Spaltenbefehl. Zu den Parametern gehören der Spaltenname, sein neuer Typ und ein optionales USING -Klausel, um anzugeben, wie der alte Typ in den neuen Typ konvertiert werden soll.

Zum Beispiel, um den Wert einer id festzulegen Spalte in resident Tabelle zu einem int Mit einer expliziten Umwandlung können wir Folgendes eingeben:

ALTER TABLE resident ALTER COLUMN id SET DATA TYPE int USING id::int;
 

Andere Tabellenänderungen

Viele andere Arten von Änderungen können mit ALTER TABLE erreicht werden Befehl. Weitere Informationen zu den verfügbaren Optionen finden Sie in der offiziellen PostgreSQL-Dokumentation für ALTER TABLE .

Tabellen löschen

Wenn Sie eine Tabelle löschen möchten, können Sie DROP TABLE verwenden SQL-Anweisung. Dadurch werden die Tabelle sowie alle darin gespeicherten Daten gelöscht.

Die grundlegende Syntax sieht folgendermaßen aus:

DROP TABLE table_name;
 

Dies löscht die Tabelle, falls sie existiert, und gibt einen Fehler aus, wenn der Tabellenname nicht existiert.

Wenn Sie die Tabelle löschen möchten, falls sie existiert, und nichts tun möchten, wenn sie nicht existiert, können Sie den IF EXISTS einfügen Qualifizierer innerhalb der Anweisung:

DROP TABLE IF EXISTS table_name;
 

Tabellen, die Abhängigkeiten von anderen Tabellen oder Objekten haben, können standardmäßig nicht gelöscht werden, solange diese Abhängigkeiten bestehen. Um den Fehler zu vermeiden, können Sie optional den CASCADE einschließen -Parameter, der automatisch alle Abhängigkeiten zusammen mit der Tabelle löscht:

DROP TABLE table_name CASCADE;
 

Wenn irgendwelche Tabellen einen Fremdschlüssel haben Einschränkung, die auf die zu löschende Tabelle verweist, wird diese Einschränkung automatisch gelöscht.

Löschen Sie die supplies Tabelle, die wir zuvor erstellt haben, indem Sie Folgendes eingeben:

DROP TABLE supplies;
 

Wir behalten die teachers Datenbank, um zu demonstrieren, dass die Anweisung zum Löschen von Datenbanken auch alle untergeordneten Objekte wie Tabellen entfernt.

Datenbanken löschen

Die DROP DATABASE -Anweisung weist PostgreSQL an, die angegebene Datenbank zu löschen. Die grundlegende Syntax sieht folgendermaßen aus:

DROP DATABASE database_name;
 

Ersetzen Sie database_name Platzhalter mit dem Namen der Datenbank, die Sie entfernen möchten. Dadurch wird die Datenbank gelöscht, wenn sie gefunden wird. Wenn die Datenbank nicht gefunden werden kann, tritt ein Fehler auf:

DROP DATABASE some_database;
 

ERROR:  database "some_database" does not exist
 

Wenn Sie die Datenbank löschen möchten, falls sie existiert, und ansonsten nichts tun, fügen Sie den optionalen IF EXISTS ein Möglichkeit:

DROP DATABASE IF EXISTS some_database;
 

NOTICE:  database "some_database" does not exist, skippingDROP DATABASE
 

Dadurch wird die Datenbank entfernt oder nichts unternommen, wenn sie nicht gefunden werden kann.

Um die school zu entfernen Datenbank, die wir in diesem Handbuch verwendet haben, listen Sie die vorhandenen Datenbanken auf Ihrem System auf:

\l
 

                                  List of databases   Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges-----------+----------+----------+-------------+-------------+----------------------- _dodb     | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | defaultdb | doadmin  | UTF8     | en_US.UTF-8 | en_US.UTF-8 | school    | doadmin  | 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(5 rows)
 

Öffnen Sie eine neue Verbindung zu einer der Datenbanken, die Sie nicht löschen möchten:

\c defaultdb
 

Sobald die neue Verbindung geöffnet ist, löschen Sie die school Datenbank mit folgendem Befehl:

DROP DATABASE school;
 

Dadurch wird die school entfernt Datenbank zusammen mit den teachers Tabelle definiert in.

createdb db_name
 

createdb --encoding=UTF8 --locale=en_US db_name
 

createdb --encoding=UTF8 school
 

dropdb database_name
 

dropdb --if-exists database_name
 

dropdb school