Jak tworzyć i usuwać bazy danych i tabele w PostgreSQL

Wprowadzenie

PostgreSQL i inne systemy zarządzania relacyjnymi bazami danych korzystają z baz danych i tabele w celu ustrukturyzowania i uporządkowania swoich danych. Możemy szybko przejrzeć definicje tych dwóch terminów:

• bazy danych: oddziel różne zestawy struktur i danych od siebie
• tabele: zdefiniuj strukturę danych i przechowuj rzeczywiste wartości danych w bazach danych

W PostgreSQL istnieje również obiekt pośredniczący między bazami danych i tabelami o nazwie schema :

• schemat: przestrzeń nazw w bazie danych, która zawiera tabele, indeksy, widoki i inne elementy.

Ten przewodnik nie zajmie się bezpośrednio koncepcją schematu PostgreSQL, ale dobrze jest wiedzieć, że on tam jest.

Zamiast tego skupimy się na tworzeniu i niszczeniu baz danych i tabel PostgreSQL. W przykładach będziemy używać głównie języka SQL, ale pod koniec pokażemy, jak wykonać kilka z tych zadań za pomocą wiersza poleceń. Te alternatywy wykorzystują narzędzia zawarte w standardowej instalacji PostgreSQL, które są dostępne, jeśli masz dostęp administracyjny do hosta PostgreSQL.

Niektóre instrukcje opisane w tym przewodniku, w szczególności PostgreSQL CREATE TABLE oświadczenie, mają wiele dodatkowych opcji, które były poza zakresem tego artykułu. Jeśli potrzebujesz dodatkowych informacji, dowiedz się więcej, zapoznając się z oficjalną dokumentacją PostgreSQL.

Wymagania wstępne

Aby postępować zgodnie z tym przewodnikiem, musisz zalogować się do instancji PostgreSQL jako użytkownik z uprawnieniami administratora przy użyciu psql klient wiersza poleceń. Twoja instancja PostgreSQL może być zainstalowana lokalnie, zdalnie lub udostępniona przez dostawcę.

W szczególności, twój użytkownik PostgreSQL będzie potrzebował CREATE DB przywilej lub być Superuser , który możesz sprawdzić za pomocą \du meta-polecenie w psql :

\du
 

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

postgres superużytkownik, który jest tworzony automatycznie podczas instalacji, ma wymagane uprawnienia, ale możesz użyć dowolnego użytkownika z Create DB przywilej.

Utwórz nową bazę danych

Po połączeniu się z instancją PostgreSQL za pomocą psql lub dowolnego innego klienta SQL, możesz utworzyć bazę danych za pomocą SQL.

Podstawowa składnia tworzenia bazy danych to:

CREATE DATABASE db_name;
 

Spowoduje to utworzenie bazy danych o nazwie db_name na bieżącym serwerze z bieżącym użytkownikiem ustawionym jako właściciel nowej bazy danych przy użyciu domyślnych ustawień bazy danych. Możesz wyświetlić właściwości domyślnego template1 szablon przy użyciu następującego psql meta-polecenie:

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

Możesz dodać dodatkowe parametry, aby zmienić sposób tworzenia bazy danych. Oto kilka typowych opcji:

• KODOWANIE: ustawia kodowanie znaków dla bazy danych.
• LC_COLLATE: ustawia zestawianie lub sortuj, porządkuj dla bazy danych. Jest to opcja lokalizacji, która określa sposób organizacji elementów, gdy są zamawiane.
• LC_CTYPE: ustawia klasyfikację znaków dla nowej bazy danych. Jest to opcja lokalizacji, która wpływa na to, jakie znaki są uważane za wielkie, małe i cyfry.

Mogą one pomóc w zapewnieniu, że baza danych może przechowywać dane w formatach, które planujesz obsługiwać, oraz z preferencjami lokalizacji projektu.

Na przykład, aby upewnić się, że twoja baza danych jest tworzona z obsługą Unicode i aby nadpisać własne ustawienia regionalne serwera, aby użyć lokalizacji w amerykańskim języku angielskim (wszystkie są zgodne z wartościami w template1 pokazane powyżej, więc nie nastąpią żadne zmiany), możesz wpisać:

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

Aby podążać za przykładami w tym przewodniku, utwórz bazę danych o nazwie school przy użyciu domyślnych ustawień regionalnych instancji i kodowania znaków UTF8:

CREATE DATABASE school ENCODING 'UTF8';
 

Spowoduje to utworzenie nowej bazy danych przy użyciu podanych specyfikacji.

Wymień istniejące bazy danych

Aby określić, jakie bazy danych są obecnie dostępne na serwerze lub klastrze, możesz użyć następującej instrukcji SQL:

SELECT datname FROM pg_database;
 

Spowoduje to wyświetlenie listy wszystkich baz danych aktualnie zdefiniowanych w środowisku:

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

Jak wspomniano wcześniej, jeśli jesteś połączony za pomocą psql klienta, możesz również uzyskać te informacje \l meta-polecenie:

\l
 

Spowoduje to wyświetlenie dostępnych nazw baz danych wraz z ich właścicielami, kodowaniem, ustawieniami regionalnymi i uprawnieniami:

                                  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)
 

school utworzona przez nas baza danych jest wyświetlana wśród innych baz danych w systemie. To dobry sposób na uzyskanie przeglądu baz danych na serwerze lub klastrze.

Tworzenie tabel w bazach danych

Po utworzeniu co najmniej jednej bazy danych możesz rozpocząć definiowanie tabel do przechowywania danych. Tabele składają się z nazwy i zdefiniowanego schematu, który określa pola i typy danych, które musi zawierać każdy rekord.

PostgreSQL CREATE TABLE składnia

Możesz tworzyć tabele za pomocą CREATE TABLE oświadczenie. Uproszczona podstawowa składnia polecenia wygląda następująco:

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

Składniki powyższej składni obejmują następujące elementy:

• CREATE TABLE table_name :Podstawowa instrukcja tworzenia, która sygnalizuje, że chcesz zdefiniować tabelę. table_name symbol zastępczy należy zastąpić nazwą tabeli, której chcesz użyć.
• column_name TYPE :Definiuje podstawową kolumnę w tabeli. column_name symbol zastępczy należy zastąpić nazwą, której chcesz użyć dla swojej kolumny. TYPE określa typ danych PostgreSQL dla kolumny. Dane przechowywane w tabeli muszą być zgodne ze strukturą kolumn i typami danych kolumn, aby zostały zaakceptowane.
• column_constraint :Ograniczenia kolumn są opcjonalnymi ograniczeniami, które dodają dalsze ograniczenia dotyczące danych, które mogą być przechowywane w kolumnie. Na przykład możesz wymagać, aby wpisy nie były zerowe, niepowtarzalne ani dodatnie.
• table_constraints :ograniczenia tabeli są podobne do ograniczeń kolumn, ale obejmują interakcję wielu kolumn. Na przykład możesz mieć ograniczenie tabeli, które sprawdza, czy DATE_OF_BIRTH jest przed DATE_OF_DEATH w stole.

Twórz tabele warunkowo za pomocą IF NOT EXISTS klauzula

Domyślnie, jeśli spróbujesz utworzyć tabelę w PostgreSQL, która już istnieje w bazie danych, wystąpi błąd. Aby obejść ten problem w przypadkach, gdy chcesz utworzyć tabelę, jeśli nie istnieje, ale po prostu kontynuuj, jeśli już istnieje, możesz użyć IF NOT EXISTS klauzula. IF NOT EXISTS opcjonalny kwalifikator, który mówi PostgreSQL, aby zignorował instrukcję, jeśli baza danych już istnieje.

Aby użyć IF NOT EXISTS klauzulę, wstaw ją do polecenia po CREATE TABLE składnia i przed nazwą tabeli:

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

Ten wariant podejmie próbę stworzenia tabeli. Jeśli tabela o tej nazwie już istnieje w określonej bazie danych, PostgreSQL wyświetli ostrzeżenie wskazujące, że nazwa tabeli została już zajęta, zamiast błędu i błędu.

Jak tworzyć tabele w PostgreSQL

Powyższa składnia wystarczy do stworzenia podstawowych tabel. Jako przykład utworzymy dwie tabele w naszej school Baza danych. Jedna tabela będzie nazywać się supplies a drugi będzie nazywał się teachers :

W supplies tabeli, chcemy mieć następujące pola:

• Identyfikator: Unikalny identyfikator dla każdego rodzaju artykułów szkolnych.
• Nazwa: Nazwa konkretnego przedmiotu szkolnego.
• Opis: Krótki opis przedmiotu.
• Producent: Nazwa producenta przedmiotu.
• Kolor: Kolor przedmiotu.
• Inwentarz: Liczba przedmiotów, które posiadamy dla określonego rodzaju artykułów szkolnych. To nigdy nie powinno być mniejsze niż 0.

Możemy stworzyć supplies tabela z powyższymi cechami przy użyciu następującego SQL.

Najpierw przejdź do school baza danych, którą utworzyłeś za pomocą psql wpisując:

\c school
 

Zmieni to bazę danych, do której będą kierowane nasze przyszłe polecenia. Twój monit powinien się zmienić, aby odzwierciedlić bazę danych.

Następnie utwórz supplies tabela z następującym stwierdzeniem:

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

Spowoduje to utworzenie supplies tabela w school Baza danych. PRIMARY KEY Ograniczenie kolumn to specjalne ograniczenie używane do wskazywania kolumn, które mogą jednoznacznie identyfikować rekordy w tabeli. W związku z tym ograniczenie określa, że ​​kolumna nie może mieć wartości NULL i musi być unikatowa. PostgreSQL tworzy indeksy dla kolumn klucza głównego, aby zwiększyć szybkość zapytań.

Sprawdź, czy nowa tabela jest obecna, wpisując:

\dt
 

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

Sprawdź, czy schemat odzwierciedla zamierzony projekt, wpisując:

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

Widzimy każdą z określonych przez nas kolumn i typów danych. Ograniczenie kolumny, które zdefiniowaliśmy dla inventory kolumna jest wymieniona na końcu.

Następnie utworzymy teachers stół. W tej tabeli powinny znajdować się następujące kolumny:

• Identyfikator pracownika :Unikalny numer identyfikacyjny pracownika.
• Imię :Imię nauczyciela.
• Nazwisko :Nazwisko nauczyciela.
• Temat :Przedmiot, do którego nauczania zatrudniony jest nauczyciel.
• Poziom oceny :Poziom uczniów, do których nauczania zatrudniono nauczyciela.

Utwórz teachers tabela z powyższym schematem z następującym SQL:

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

Jak tworzyć tabele z kluczami podstawowymi i obcymi

Informacje o tworzeniu tabel z kluczami podstawowymi i obcymi znajdziesz w innych naszych przewodnikach po PostgreSQL. Klucze podstawowe i klucze obce to oba rodzaje ograniczeń bazy danych w PostgreSQL.

Klucz podstawowy to specjalna kolumna lub kolumna, która na pewno będzie unikatowa w wierszach tej samej tabeli. Wszystkie klucze podstawowe mogą służyć do jednoznacznej identyfikacji określonego wiersza. Klucze podstawowe nie tylko zapewniają, że każdy wiersz ma unikalną wartość dla kolumn klucza podstawowego, ale także zapewniają, że żaden wiersz nie zawiera NULL wartości dla tej kolumny. Często klucz podstawowy w PostgreSQL używa następującego formatu, aby określić automatycznie przypisywany inkrementacyjny klucz podstawowy:id SERIAL PRIMARY KEY .

Klucze obce to sposób na zapewnienie, że kolumna lub kolumny w jednej tabeli odpowiadają wartościom zawartym w innej tabeli. Pomaga to zapewnić integralność referencyjną między tabelami.

Jak przeglądać tabele w PostgreSQL

W PostgreSQL możesz wyświetlić tabele na kilka różnych sposobów, w zależności od tego, jakich informacji szukasz.

Jeśli chcesz zobaczyć, jakie tabele są dostępne w Twojej bazie danych, możesz użyć \dt meta-polecenie dołączone do psql klienta, aby wyświetlić listę wszystkich tabel, jak pokazaliśmy powyżej:

\dt
 

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

Możesz również sprawdzić, czy schemat tabeli odpowiada Twoim specyfikacjom:

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

teachers tabela wydaje się pasować do naszej definicji.

Zmień tabele

Jeśli potrzebujesz zmienić schemat istniejącej tabeli w PostgreSQL, możesz użyć ALTER TABLE Komenda. ALTER TABLE polecenie jest bardzo podobne do polecenia CREATE TABLE polecenie, ale działa na istniejącej tabeli.

Zmień składnię tabeli

Podstawowa składnia modyfikacji tabel w PostgreSQL wygląda tak:

ALTER TABLE <table_name> <change_command> <change_parameters>
 

<change_command> wskazuje dokładny typ zmiany, którą chcesz wprowadzić, niezależnie od tego, czy dotyczy to ustawiania różnych opcji w tabeli, dodawania lub usuwania kolumn, czy też zmiany typów lub ograniczeń. <change_parameters> część polecenia zawiera wszelkie dodatkowe informacje, których PostgreSQL potrzebuje do dokończenia zmiany.

Dodawanie kolumn do tabel

Możesz dodać kolumnę do tabeli PostgreSQL za pomocą ADD COLUMN Zmień polecenie. Parametry zmiany będą zawierać nazwę kolumny, typ i opcje, tak jak określisz je w CREATE TABLE polecenie.

Na przykład, aby dodać kolumnę o nazwie missing_column text wpisz do tabeli o nazwie some_table , należy wpisać:

ALTER TABLE some_table ADD COLUMN missing_column text;
 

Usuwanie kolumn z tabel

Jeśli zamiast tego chcesz usunąć istniejącą kolumnę, możesz użyć DROP COLUMN zamiast tego polecenie. Musisz określić nazwę kolumny, którą chcesz usunąć jako parametr zmiany:

ALTER TABLE some_table DROP COLUMN useless_column;
 

Zmiana typu danych kolumny

Aby zmienić typ danych, który PostgreSQL używa dla określonej kolumny, możesz użyć ALTER COLUMN zmień polecenie za pomocą SET DATA TYPE polecenie kolumny. Parametry obejmują nazwę kolumny, jej nowy typ i opcjonalny USING klauzula określająca, w jaki sposób stary typ powinien zostać przekonwertowany na nowy typ.

Na przykład, aby ustawić wartość id kolumna w resident tabeli do int używając rzutowania jawnego, możemy wpisać:

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

Inne zmiany w tabeli

Wiele innych typów zmian można osiągnąć za pomocą ALTER TABLE Komenda. Aby uzyskać więcej informacji o dostępnych opcjach, zapoznaj się z oficjalną dokumentacją PostgreSQL dla ALTER TABLE .

Upuść tabele

Jeśli chcesz usunąć tabelę, możesz użyć DROP TABLE Instrukcja SQL. Spowoduje to usunięcie tabeli oraz wszelkich przechowywanych w niej danych.

Podstawowa składnia wygląda tak:

DROP TABLE table_name;
 

Spowoduje to usunięcie tabeli, jeśli istnieje i wyrzuci błąd, jeśli nazwa tabeli nie istnieje.

Jeśli chcesz usunąć tabelę, jeśli istnieje i nic nie robić, jeśli nie istnieje, możesz dołączyć IF EXISTS kwalifikator w oświadczeniu:

DROP TABLE IF EXISTS table_name;
 

Tabele, które mają zależności od innych tabel lub obiektów, nie mogą być domyślnie usuwane, gdy istnieją te zależności. Aby uniknąć błędu, możesz opcjonalnie dołączyć CASCADE parametr, który automatycznie usuwa wszelkie zależności wraz z tabelą:

DROP TABLE table_name CASCADE;
 

Jeśli jakieś tabele mają klucz obcy ograniczenie, które odwołuje się do usuwanej tabeli, to ograniczenie zostanie automatycznie usunięte.

Usuń supplies tabela, którą utworzyliśmy wcześniej, wpisując:

DROP TABLE supplies;
 

Zatrzymamy teachers bazy danych, aby zademonstrować, że instrukcja usuwania baz danych usuwa również wszystkie obiekty podrzędne, takie jak tabele.

Upuść bazy danych

DROP DATABASE instrukcja mówi PostgreSQL, aby usunąć określoną bazę danych. Podstawowa składnia wygląda tak:

DROP DATABASE database_name;
 

Zastąp database_name symbol zastępczy z nazwą bazy danych, którą chcesz usunąć. Spowoduje to usunięcie bazy danych, jeśli zostanie znaleziona. Jeśli nie można znaleźć bazy danych, wystąpi błąd:

DROP DATABASE some_database;
 

ERROR:  database "some_database" does not exist
 

Jeśli chcesz usunąć bazę danych, jeśli istnieje, i nie robić nic w inny sposób, dołącz opcjonalny IF EXISTS opcja:

DROP DATABASE IF EXISTS some_database;
 

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

Spowoduje to usunięcie bazy danych lub nic nie zrobi, jeśli nie można jej znaleźć.

Aby usunąć school bazy danych, której używaliśmy w tym przewodniku, wymień istniejące bazy danych w twoim systemie:

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

Otwórz nowe połączenie z jedną z baz danych, której nie chcesz usuwać:

\c defaultdb
 

Po otwarciu nowego połączenia usuń school bazy danych za pomocą następującego polecenia:

DROP DATABASE school;
 

Spowoduje to usunięcie school baza danych wraz z teachers tabela zdefiniowana wewnątrz.

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