Databases en tabellen maken en verwijderen in PostgreSQL

Inleiding

PostgreSQL en andere relationele databasebeheersystemen gebruiken databases en tabellen om hun gegevens te structureren en te ordenen. We kunnen de definitie van die twee termen snel herzien:

• databases: verschillende sets structuren en gegevens van elkaar scheiden
• tafels: definieer de gegevensstructuur en sla de werkelijke gegevenswaarden op in databases

In PostgreSQL is er ook een intermediair object tussen databases en tabellen genaamd schema :

• schema: een naamruimte binnen een database die tabellen, indexen, views en andere items bevat.

Deze gids gaat niet rechtstreeks in op het concept van een schema van PostgreSQL, maar het is goed om te weten dat het er is.

In plaats daarvan zullen we ons concentreren op het maken en vernietigen van PostgreSQL-databases en -tabellen. De voorbeelden zullen voornamelijk SQL gebruiken, maar aan het einde zullen we u laten zien hoe u een paar van deze taken kunt uitvoeren met behulp van de opdrachtregel. Deze alternatieven gebruiken tools die zijn opgenomen in de standaard PostgreSQL-installatie die beschikbaar zijn als u beheerderstoegang tot de PostgreSQL-host heeft.

Enkele van de uitspraken die in deze handleiding worden behandeld, met name de PostgreSQL CREATE TABLE verklaring, hebben veel extra opties die buiten het bestek van dit artikel vielen. Als je meer informatie wilt, kun je meer informatie vinden in de officiële PostgreSQL-documentatie.

Vereisten

Om deze handleiding te volgen, moet u zich aanmelden bij een PostgreSQL-instantie met een gebruiker met beheerdersrechten met behulp van de psql opdrachtregelclient. Uw PostgreSQL-instantie kan lokaal, op afstand of door een provider worden geïnstalleerd.

In het bijzonder heeft uw PostgreSQL-gebruiker de CREATE DB . nodig privilege of wees een Superuser , die u kunt controleren met de \du meta-opdracht in psql :

\du
 

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

De postgres superuser, die automatisch wordt aangemaakt bij de installatie, heeft de vereiste rechten, maar u kunt elke gebruiker gebruiken met de Create DB voorrecht.

Maak een nieuwe database

Zodra u bent verbonden met uw PostgreSQL-instantie met behulp van psql of een andere SQL-client, u kunt een database maken met behulp van SQL.

De basissyntaxis voor het maken van een database is:

CREATE DATABASE db_name;
 

Hiermee wordt een database gemaakt met de naam db_name op de huidige server met de huidige gebruiker ingesteld als de eigenaar van de nieuwe database met behulp van de standaard database-instellingen. U kunt de eigenschappen van de standaard template1 . bekijken sjabloon met de volgende psql meta-commando:

\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)
 

U kunt extra parameters toevoegen om de manier waarop uw database wordt gemaakt te wijzigen. Dit zijn enkele veelvoorkomende opties:

• CODERING: stelt de tekencodering voor de database in.
• LC_COLLATE: stelt de sortering in , of sorteer, volgorde voor de database. Dit is een lokalisatieoptie die bepaalt hoe artikelen worden georganiseerd wanneer ze worden besteld.
• LC_CTYPE: stelt de karakterclassificatie in voor de nieuwe database. Dit is een lokalisatie-optie die van invloed is op welke tekens worden beschouwd als hoofdletters, kleine letters en cijfers.

Deze kunnen ervoor zorgen dat de database gegevens kan opslaan in de indelingen die u van plan bent te ondersteunen en met de lokalisatievoorkeuren van uw project.

Bijvoorbeeld om ervoor te zorgen dat uw database is gemaakt met Unicode-ondersteuning en om de eigen locale van de server te overschrijven om Amerikaans-Engelse lokalisatie te gebruiken (deze komen allemaal overeen met de waarden in de template1 zoals hierboven weergegeven, dus er zal geen verandering plaatsvinden), kunt u typen:

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

Om de voorbeelden in deze handleiding te volgen, maakt u een database met de naam school met behulp van de standaard locale-instellingen van uw instantie en de UTF8-tekencodering:

CREATE DATABASE school ENCODING 'UTF8';
 

Hiermee wordt uw nieuwe database gemaakt met behulp van de specificaties die u heeft opgegeven.

Bestaande databases weergeven

Om te bepalen welke databases momenteel beschikbaar zijn op uw server of cluster, kunt u de volgende SQL-instructie gebruiken:

SELECT datname FROM pg_database;
 

Dit geeft een lijst van alle databases die momenteel in de omgeving zijn gedefinieerd:

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

Zoals eerder vermeld, als u bent verbonden via de psql klant, u kunt deze informatie ook verkrijgen \l meta-commando:

\l
 

Dit toont de beschikbare databasenamen samen met hun eigenaren, codering, landinstellingen en privileges:

                                  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)
 

De school database die we hebben gemaakt, wordt weergegeven tussen de andere databases op het systeem. Dit is een goede manier om een ​​overzicht te krijgen van de databases binnen uw server of cluster.

Maak tabellen in databases

Nadat u een of meer databases hebt gemaakt, kunt u beginnen met het definiëren van tabellen om uw gegevens op te slaan. Tabellen bestaan ​​uit een naam en een gedefinieerd schema dat de velden en gegevenstypen bepaalt die elk record moet bevatten.

PostgreSQL CREATE TABLE syntaxis

U kunt tabellen maken met behulp van de CREATE TABLE uitspraak. Een vereenvoudigde basissyntaxis voor de opdracht ziet er als volgt uit:

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

De componenten van de bovenstaande syntaxis omvatten de volgende:

• CREATE TABLE table_name :De basisaanmaakverklaring die aangeeft dat u een tabel wilt definiëren. De table_name tijdelijke aanduiding moet worden vervangen door de naam van de tabel die u wilt gebruiken.
• column_name TYPE :definieert een basiskolom in de tabel. De column_name tijdelijke aanduiding moet worden vervangen door de naam die u voor uw kolom wilt gebruiken. Het TYPE specificeert het PostgreSQL-gegevenstype voor de kolom. Gegevens die in de tabel zijn opgeslagen, moeten voldoen aan de kolomstructuur en kolomgegevenstypen om te worden geaccepteerd.
• column_constraint :Kolombeperkingen zijn optionele beperkingen om verdere beperkingen toe te voegen aan de gegevens die in de kolom kunnen worden opgeslagen. U kunt bijvoorbeeld eisen dat invoeren geen null, unieke of positieve gehele getallen zijn.
• table_constraints :Tabelbeperkingen zijn vergelijkbaar met kolombeperkingen, maar omvatten de interactie van meerdere kolommen. U kunt bijvoorbeeld een tabelbeperking hebben die controleert of een DATE_OF_BIRTH is vóór DATE_OF_DEATH in een tabel.

Maak tabellen voorwaardelijk met de IF NOT EXISTS clausule

Als u probeert een tabel in PostgreSQL te maken die al in de database bestaat, treedt er standaard een fout op. Om dit probleem te omzeilen in gevallen waarin u een tabel wilt maken als deze niet aanwezig is, maar gewoon verder wilt gaan als deze al bestaat, kunt u de IF NOT EXISTS gebruiken clausule. De IF NOT EXISTS optionele kwalificatie die PostgreSQL vertelt om de instructie te negeren als de database al bestaat.

Om de IF NOT EXISTS . te gebruiken clausule, voeg het toe aan het commando na de CREATE TABLE syntaxis en voor de tabelnaam:

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

Deze variant probeert de tabel te maken. Als er al een tabel met die naam bestaat in de opgegeven database, geeft PostgreSQL een waarschuwing dat de tabelnaam al in gebruik is in plaats van een fout te veroorzaken.

Tabellen maken in PostgreSQL

De bovenstaande syntaxis is voldoende om basistabellen te maken. Als voorbeeld maken we twee tabellen binnen onze school databank. Eén tafel heet supplies en de andere zal teachers genoemd worden :

In de supplies tabel, willen we de volgende velden hebben:

• ID: Een unieke ID voor elk type schoolbenodigdheden.
• Naam: De naam van een specifiek schoolitem.
• Beschrijving: Een korte beschrijving van het item.
• Fabrikant: De naam van de fabrikant van het artikel.
• Kleur: De kleur van het item.
• Inventaris: Het aantal artikelen dat we hebben voor een bepaald type schoolspullen. Dit mag nooit minder dan 0 zijn.

We kunnen de supplies . maken tabel met de bovenstaande eigenschappen met behulp van de volgende SQL.

Ga eerst naar de school database die u hebt gemaakt met psql door te typen:

\c school
 

Dit zal de database veranderen waarop onze toekomstige commando's zich zullen richten. Uw prompt zou moeten veranderen om de database weer te geven.

Maak vervolgens de supplies tabel met de volgende verklaring:

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

Hiermee worden de supplies . gemaakt tabel binnen de school databank. De PRIMARY KEY kolombeperking is een speciale beperking die wordt gebruikt om kolommen aan te geven die op unieke wijze records in de tabel kunnen identificeren. Als zodanig geeft de beperking aan dat de kolom niet null kan zijn en uniek moet zijn. PostgreSQL maakt indexen voor kolommen met primaire sleutels om de querysnelheid te verhogen.

Controleer of de nieuwe tabel aanwezig is door te typen:

\dt
 

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

Controleer of het schema het beoogde ontwerp weerspiegelt door te typen:

\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)
 

We kunnen elk van de kolommen en gegevenstypen zien die we hebben opgegeven. De kolombeperking die we hebben gedefinieerd voor de inventory kolom wordt aan het einde weergegeven.

Vervolgens maken we een teachers tafel. In deze tabel moeten de volgende kolommen aanwezig zijn:

• Werknemers-ID :Een uniek werknemersidentificatienummer.
• Voornaam :De voornaam van de leraar.
• Achternaam :De achternaam van de leraar.
• Onderwerp :Het vak waarvoor de leraar wordt ingehuurd om les te geven.
• Cijferniveau :Het niveau van de studenten waarvoor de docent is ingehuurd om les te geven.

Maak de teachers tabel met het bovenstaande schema met de volgende SQL:

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

Tabellen maken met primaire sleutels en externe sleutels

U kunt informatie vinden over het maken van tabellen met primaire en externe sleutels in enkele van onze andere PostgreSQL-handleidingen. Primaire sleutels en externe sleutels zijn beide typen databasebeperkingen binnen PostgreSQL.

Een primaire sleutel is een speciale kolom of kolom die gegarandeerd uniek is voor alle rijen binnen dezelfde tabel. Alle primaire sleutels kunnen worden gebruikt om een ​​specifieke rij uniek te identificeren. Primaire sleutels zorgen er niet alleen voor dat elke rij een unieke waarde heeft voor de primaire sleutelkolommen, ze zorgen er ook voor dat geen rijen NULL bevatten waarden voor die kolom. Vaak gebruikt de primaire sleutel in PostgreSQL het volgende formaat om een ​​automatisch toegewezen oplopende primaire sleutel op te geven:id SERIAL PRIMARY KEY .

Vreemde sleutels zijn een manier om ervoor te zorgen dat een kolom of kolommen in de ene tabel overeenkomen met de waarden in een andere tabel. Dit helpt om de referentiële integriteit tussen tabellen te waarborgen.

Tabellen bekijken in PostgreSQL

In PostgreSQL kun je tabellen op verschillende manieren weergeven, afhankelijk van de informatie die je zoekt.

Als u wilt zien welke tabellen beschikbaar zijn in uw database, kunt u de \dt gebruiken meta-opdracht meegeleverd met de psql client om alle tabellen weer te geven, zoals we hierboven hebben aangetoond:

\dt
 

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

U kunt ook controleren of het schema voor de tabel overeenkomt met uw specificaties:

\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)
 

De teachers tabel lijkt overeen te komen met onze definitie.

Tabels wijzigen

Als u het schema van een bestaande tabel in PostgreSQL moet wijzigen, kunt u de ALTER TABLE gebruiken opdracht. De ALTER TABLE commando lijkt erg op het CREATE TABLE commando, maar werkt op een bestaande tafel.

Tabelsyntaxis wijzigen

De basissyntaxis voor het wijzigen van tabellen in PostgreSQL ziet er als volgt uit:

ALTER TABLE <table_name> <change_command> <change_parameters>
 

De <change_command> geeft het exacte type wijziging aan dat u wilt aanbrengen, of het nu gaat om het instellen van verschillende opties op de tabel, het toevoegen of verwijderen van kolommen of het wijzigen van typen of beperkingen. De <change_parameters> een deel van de opdracht bevat aanvullende informatie die PostgreSQL nodig heeft om de wijziging te voltooien.

Kolommen aan tabellen toevoegen

U kunt een kolom toevoegen aan een PostgreSQL-tabel met de ADD COLUMN opdracht wijzigen. De wijzigingsparameters bevatten de kolomnaam, het type en de opties, net zoals u ze zou specificeren in de CREATE TABLE commando.

Om bijvoorbeeld een kolom toe te voegen met de naam missing_column van de text typ naar een tabel met de naam some_table , typ je:

ALTER TABLE some_table ADD COLUMN missing_column text;
 

Kolommen uit tabellen verwijderen

Als u in plaats daarvan een bestaande kolom wilt verwijderen, kunt u de DROP COLUMN gebruiken commando in plaats daarvan. U moet de naam opgeven van de kolom die u wilt verwijderen als wijzigingsparameter:

ALTER TABLE some_table DROP COLUMN useless_column;
 

Het gegevenstype van een kolom wijzigen

Als u het gegevenstype wilt wijzigen dat PostgreSQL voor een specifieke kolom gebruikt, kunt u ALTER COLUMN gebruiken verander commando met het SET DATA TYPE kolom commando. De parameters omvatten de kolomnaam, het nieuwe type en een optionele USING clausule om aan te geven hoe het oude type moet worden geconverteerd naar het nieuwe type.

Om bijvoorbeeld de waarde van een id . in te stellen kolom in de resident tabel naar een int met een expliciete cast kunnen we het volgende typen:

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

Andere tabelwijzigingen

Veel andere soorten wijzigingen kunnen worden bereikt met de ALTER TABLE opdracht. Voor meer informatie over de beschikbare opties, bekijk de officiële PostgreSQL-documentatie voor ALTER TABLE .

Drop tabellen

Als u een tabel wilt verwijderen, kunt u de DROP TABLE . gebruiken SQL-instructie. Hiermee worden de tabel en alle daarin opgeslagen gegevens verwijderd.

De basissyntaxis ziet er als volgt uit:

DROP TABLE table_name;
 

Dit zal de tabel verwijderen als deze bestaat en een foutmelding geven als de tabelnaam niet bestaat.

Als u de tabel wilt verwijderen als deze bestaat en niets wilt doen als deze niet bestaat, kunt u de IF EXISTS opnemen kwalificatie in de instructie:

DROP TABLE IF EXISTS table_name;
 

Tabellen die afhankelijkheden hebben van andere tabellen of objecten kunnen niet standaard worden verwijderd zolang die afhankelijkheden bestaan. Om de fout te voorkomen, kunt u optioneel de CASCADE . opnemen parameter, die automatisch alle afhankelijkheden samen met de tabel laat vallen:

DROP TABLE table_name CASCADE;
 

Als er tabellen zijn met een buitenlandse sleutel beperking, die verwijst naar de tabel die u verwijdert, wordt die beperking automatisch verwijderd.

Verwijder de supplies tabel die we eerder hebben gemaakt door te typen:

DROP TABLE supplies;
 

We behouden de teachers database om aan te tonen dat de instructie om databases te verwijderen ook alle onderliggende objecten zoals tabellen verwijdert.

Drop databases

De DROP DATABASE instructie vertelt PostgreSQL om de opgegeven database te verwijderen. De basissyntaxis ziet er als volgt uit:

DROP DATABASE database_name;
 

Vervang de database_name tijdelijke aanduiding met de naam van de database die u wilt verwijderen. Hiermee wordt de database verwijderd als deze wordt gevonden. Als de database niet kan worden gevonden, treedt er een fout op:

DROP DATABASE some_database;
 

ERROR:  database "some_database" does not exist
 

Als u de database wilt verwijderen als deze bestaat en verder niets doet, voeg dan de optionele IF EXISTS toe optie:

DROP DATABASE IF EXISTS some_database;
 

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

Hiermee wordt de database verwijderd of wordt er niets gedaan als deze niet kan worden gevonden.

Om de school te verwijderen database die we in deze handleiding hebben gebruikt, vermeldt u de bestaande databases op uw systeem:

\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)
 

Open een nieuwe verbinding met een van de databases die u niet wilt verwijderen:

\c defaultdb
 

Zodra de nieuwe verbinding is geopend, verwijdert u de school database met het volgende commando:

DROP DATABASE school;
 

Hiermee wordt de school . verwijderd database samen met de teachers tabel gedefinieerd binnen.

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