Úvod
PostgreSQL a další systémy pro správu relačních databází používají databáze a tabulky strukturovat a organizovat svá data. Můžeme si rychle prohlédnout definici těchto dvou pojmů:
- databáze: oddělte od sebe různé sady struktur a dat
- tabulky: definovat datovou strukturu a ukládat skutečné hodnoty dat do databází
V PostgreSQL existuje také prostředník mezi databázemi a tabulkami nazvaný schéma :
- schéma: jmenný prostor v rámci databáze, který obsahuje tabulky, indexy, pohledy a další položky.
Tato příručka se nebude přímo zabývat konceptem schématu PostgreSQL, ale je dobré vědět, že tam je.
Místo toho se zaměříme na to, jak vytvořit a zničit PostgreSQL databáze a tabulky. Příklady budou primárně používat SQL, ale na konci vám ukážeme, jak provést několik z těchto úloh pomocí příkazového řádku. Tyto alternativy využívají nástroje zahrnuté ve standardní instalaci PostgreSQL, které jsou dostupné, pokud máte administrátorský přístup k hostiteli PostgreSQL.
Některé příkazy uvedené v této příručce, zejména CREATE TABLE PostgreSQL prohlášení, mají mnoho dalších možností, které byly mimo rozsah tohoto článku. Pokud chcete další informace, zjistěte více v oficiální dokumentaci PostgreSQL.
Předpoklady
Abyste mohli postupovat podle tohoto průvodce, budete se muset přihlásit k instanci PostgreSQL s uživatelem s administrátorskými právy pomocí psql klient příkazového řádku. Vaše instance PostgreSQL může být nainstalována lokálně, vzdáleně nebo zřízena poskytovatelem.
Konkrétně váš uživatel PostgreSQL bude potřebovat CREATE DB oprávnění nebo být Superuser , což můžete zkontrolovat pomocí \du meta-příkaz v psql :
\du
List of roles Role name | Attributes | Member of-----------+------------------------------------------------------------+----------- postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
postgres superuser, který se vytvoří automaticky při instalaci, má požadovaná oprávnění, ale můžete použít libovolného uživatele s Create DB privilegium.
Vytvořit novou databázi
Jakmile se připojíte ke své instanci PostgreSQL pomocí psql nebo jakéhokoli jiného klienta SQL, můžete vytvořit databázi pomocí SQL.
Základní syntaxe pro vytvoření databáze je:
CREATE DATABASE db_name;
Tím se vytvoří databáze s názvem db_name na aktuálním serveru s aktuálním uživatelem nastaveným jako vlastník nové databáze pomocí výchozího nastavení databáze. Můžete zobrazit vlastnosti výchozí template1 šablonu pomocí následujícího psql meta-příkaz:
\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)
Můžete přidat další parametry, abyste změnili způsob vytváření databáze. Toto jsou některé běžné možnosti:
- KÓDOVÁNÍ: nastavuje kódování znaků pro databázi.
- LC_COLLATE: nastaví třídění , nebo seřadit, seřadit pro databázi. Toto je možnost lokalizace, která určuje, jak jsou položky organizovány, když jsou objednávány.
- LC_CTYPE: nastaví klasifikaci znaků pro novou databázi. Toto je možnost lokalizace, která ovlivňuje, jaké znaky jsou považovány za velká, malá písmena a číslice.
Ty mohou pomoci zajistit, že databáze může ukládat data ve formátech, které plánujete podporovat, a s předvolbami lokalizace vašeho projektu.
Chcete-li například zajistit, aby byla vaše databáze vytvořena s podporou Unicode, a přepsat vlastní národní prostředí serveru tak, aby používala lokalizaci v americké angličtině (všechny se shodují s hodnotami v template1 výše, takže ve skutečnosti nedojde k žádné změně), můžete napsat:
CREATE DATABASE db_name ENCODING 'UTF8' LC_COLLATE 'en_US.UTF-8' LC_CTYPE 'en_US.UTF-8';
Chcete-li pokračovat podle příkladů v této příručce, vytvořte databázi s názvem school pomocí výchozího nastavení národního prostředí vaší instance a kódování znaků UTF8:
CREATE DATABASE school ENCODING 'UTF8';
Tím se vytvoří vaše nová databáze pomocí specifikací, které jste poskytli.
Seznam existujících databází
Chcete-li zjistit, jaké databáze jsou aktuálně dostupné na vašem serveru nebo clusteru, můžete použít následující příkaz SQL:
SELECT datname FROM pg_database;
Zobrazí se seznam všech databází aktuálně definovaných v prostředí:
datname----------- _dodb template1 template0 defaultdb school(5 rows)
Jak již bylo zmíněno, pokud jste připojeni pomocí psql klient, můžete také získat tyto informace \l meta-příkaz:
\l
Zobrazí se dostupné názvy databází spolu s jejich vlastníky, kódováním, nastavením národního prostředí a oprávněními:
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 databáze, kterou jsme vytvořili, se zobrazí mezi ostatními databázemi v systému. Je to dobrý způsob, jak získat přehled o databázích na vašem serveru nebo clusteru.
Vytváření tabulek v databázích
Po vytvoření jedné nebo více databází můžete začít definovat tabulky pro uložení dat. Tabulky se skládají z názvu a definovaného schématu, které určuje pole a datové typy, které musí každý záznam obsahovat.
PostgreSQL CREATE TABLE syntaxe
Tabulky můžete vytvářet pomocí CREATE TABLE prohlášení. Zjednodušená základní syntaxe příkazu vypadá takto:
CREATE TABLE table_name ( column_name TYPE [column_constraint], [table_constraint,]);
Komponenty výše uvedené syntaxe zahrnují následující:
CREATE TABLE table_name:Základní příkaz pro vytvoření, který signalizuje, že si přejete definovat tabulku.table_namezástupný symbol by měl být nahrazen názvem tabulky, kterou chcete použít.column_name TYPE:Definuje základní sloupec v tabulce.column_namezástupný symbol by měl být nahrazen názvem, který chcete pro svůj sloupec použít.TYPEurčuje datový typ PostgreSQL pro sloupec. Aby byla data uložená v tabulce přijata, musí odpovídat struktuře sloupců a datovým typům sloupců.column_constraint:Omezení sloupců jsou volitelná omezení pro přidání dalších omezení na data, která lze uložit do sloupce. Můžete například požadovat, aby položky nebyly nulové, jedinečné ani kladná celá čísla.table_constraints:Omezení tabulky jsou podobná omezením sloupců, ale zahrnují interakci více sloupců. Můžete například mít omezení tabulky, které kontroluje, zdaDATE_OF_BIRTHje předDATE_OF_DEATHv tabulce.
Vytvářejte tabulky podmíněně pomocí IF NOT EXISTS klauzule
Ve výchozím nastavení, pokud se pokusíte vytvořit tabulku v PostgreSQL, která již v databázi existuje, dojde k chybě. Chcete-li tento problém vyřešit v případech, kdy chcete vytvořit tabulku, pokud neexistuje, ale pouze pokračovat, pokud již existuje, můžete použít IF NOT EXISTS doložka. IF NOT EXISTS volitelný kvalifikátor, který říká PostgreSQL, aby ignoroval příkaz, pokud databáze již existuje.
Chcete-li použít IF NOT EXISTS klauzuli, vložte ji do příkazu za CREATE TABLE syntaxe a před názvem tabulky:
CREATE TABLE IF NOT EXISTS table_name ( column_name TYPE [column_constraint], [table_constraint,]);
Tato varianta se pokusí vytvořit tabulku. Pokud tabulka s tímto názvem již v zadané databázi existuje, PostgreSQL zobrazí varování, že název tabulky již byl obsazen, místo aby selhal s chybou.
Jak vytvářet tabulky v PostgreSQL
Výše uvedená syntaxe stačí k vytvoření základních tabulek. Jako příklad vytvoříme dvě tabulky v rámci naší school databáze. Jedna tabulka se bude jmenovat supplies a druhý se bude jmenovat teachers :
V supplies tabulky, chceme mít následující pole:
- ID: Jedinečné ID pro každý typ školních potřeb.
- Jméno: Název konkrétní školní položky.
- Popis: Krátký popis položky.
- Výrobce: Název výrobce položky.
- Barva: Barva položky.
- Inventář: Počet položek, které máme pro určitý typ školních potřeb. Ta by nikdy neměla být menší než 0.
Můžeme vytvořit supplies tabulky s výše uvedenými vlastnostmi pomocí následujícího SQL.
Nejprve přejděte na school databázi, kterou jste vytvořili pomocí psql zadáním:
\c school
Tím se změní databáze, na kterou budou cílit naše budoucí příkazy. Vaše výzva by se měla změnit, aby odrážela databázi.
Dále vytvořte supplies tabulka s následujícím příkazem:
CREATE TABLE supplies ( id INT PRIMARY KEY, name VARCHAR, description VARCHAR, manufacturer VARCHAR, color VARCHAR, inventory int CHECK (inventory > 0));
Tím vytvoříte supplies tabulky v rámci school databáze. PRIMARY KEY sloupcové omezení je speciální omezení používané k označení sloupců, které mohou jednoznačně identifikovat záznamy v tabulce. Omezení jako takové určuje, že sloupec nemůže mít hodnotu null a musí být jedinečný. PostgreSQL vytváří indexy pro sloupce primárního klíče pro zvýšení rychlosti dotazování.
Ověřte přítomnost nové tabulky zadáním:
\dt
List of relations Schema | Name | Type | Owner --------+----------+-------+--------- public | supplies | table | doadmin(1 row)
Ověřte, zda schéma odpovídá zamýšlenému návrhu zadáním:
\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)
Můžeme vidět každý ze sloupců a datových typů, které jsme zadali. Omezení sloupce, které jsme definovali pro inventory sloupec je uveden na konci.
Dále vytvoříme teachers stůl. V této tabulce by měly být přítomny následující sloupce:
- ID zaměstnance :Jedinečné identifikační číslo zaměstnance.
- Jméno :Křestní jméno učitele.
- Příjmení :Příjmení učitele.
- Předmět :Předmět, který má učitel vyučovat.
- Úroveň :Stupeň studentů, pro které je učitel najat.
Vytvořte teachers tabulka s výše uvedeným schématem s následujícím SQL:
CREATE TABLE teachers ( id INT PRIMARY KEY, first_name VARCHAR, last_name VARCHAR, subject VARCHAR, grade_level int);
Jak vytvořit tabulky s primárními klíči a cizími klíči
Informace o vytváření tabulek s primárními a cizími klíči najdete v některých z našich dalších příruček PostgreSQL. Primární klíče a cizí klíče jsou oba typy omezení databáze v PostgreSQL.
Primární klíč je speciální sloupec nebo sloupec, u kterého je zaručeno, že bude jedinečný napříč řádky ve stejné tabulce. Všechny primární klíče lze použít k jednoznačné identifikaci konkrétního řádku. Primární klíče nejen zajišťují, že každý řádek má jedinečnou hodnotu pro sloupce primárního klíče, ale také zajišťují, že žádné řádky neobsahují NULL hodnoty pro daný sloupec. Primární klíč v PostgreSQL často používá k určení automaticky přiřazeného inkrementačního primárního klíče následující formát:id SERIAL PRIMARY KEY .
Cizí klíče představují způsob, jak zajistit, aby sloupec nebo sloupce v jedné tabulce odpovídaly hodnotám obsaženým v jiné tabulce. To pomáhá zajistit referenční integritu mezi tabulkami.
Jak zobrazit tabulky v PostgreSQL
V PostgreSQL můžete vypisovat tabulky několika různými způsoby v závislosti na tom, jaké informace hledáte.
Pokud byste chtěli vidět, jaké tabulky jsou ve vaší databázi k dispozici, můžete použít \dt meta-příkaz zahrnutý v psql klienta vypsat všechny tabulky, jak jsme si ukázali výše:
\dt
List of relations Schema | Name | Type | Owner--------+----------+-------+--------- public | supplies | table | doadmin public | teachers | table | doadmin(2 rows)
Můžete také zkontrolovat, zda schéma tabulky odpovídá vašim specifikacím:
\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 Zdá se, že tabulka odpovídá naší definici.
Upravit tabulky
Pokud potřebujete změnit schéma existující tabulky v PostgreSQL, můžete použít ALTER TABLE příkaz. ALTER TABLE příkaz je velmi podobný příkazu CREATE TABLE příkaz, ale pracuje na existující tabulce.
Změnit syntaxi tabulky
Základní syntaxe pro úpravu tabulek v PostgreSQL vypadá takto:
ALTER TABLE <table_name> <change_command> <change_parameters>
<change_command> označuje přesný typ změny, kterou byste chtěli provést, ať už jde o nastavení různých možností v tabulce, přidání nebo odebrání sloupců nebo změnu typů nebo omezení. <change_parameters> část příkazu obsahuje další informace, které PostgreSQL potřebuje k dokončení změny.
Přidávání sloupců do tabulek
Sloupec můžete přidat do tabulky PostgreSQL pomocí ADD COLUMN změnit příkaz. Parametry změny budou zahrnovat název sloupce, typ a možnosti, stejně jako byste je zadali v CREATE TABLE příkaz.
Chcete-li například přidat sloupec s názvem missing_column text zadejte do tabulky s názvem some_table , napsali byste:
ALTER TABLE some_table ADD COLUMN missing_column text;
Odebrání sloupců z tabulek
Pokud místo toho chcete odstranit existující sloupec, můžete použít DROP COLUMN místo toho příkaz. Jako parametr změny musíte zadat název sloupce, který chcete vypustit:
ALTER TABLE some_table DROP COLUMN useless_column;
Změna datového typu sloupce
Chcete-li změnit typ dat, který PostgreSQL používá pro konkrétní sloupec, můžete použít ALTER COLUMN změnit příkaz pomocí SET DATA TYPE sloupcový příkaz. Mezi parametry patří název sloupce, jeho nový typ a volitelný USING klauzule určující, jak má být starý typ převeden na nový typ.
Chcete-li například nastavit hodnotu id ve sloupci resident tabulky na int pomocí explicitního přetypování můžeme zadat následující:
ALTER TABLE resident ALTER COLUMN id SET DATA TYPE int USING id::int;
Další změny v tabulce
Mnoho dalších typů změn lze dosáhnout pomocí ALTER TABLE příkaz. Další informace o dostupných možnostech naleznete v oficiální dokumentaci PostgreSQL pro ALTER TABLE .
Zrušit tabulky
Pokud si přejete smazat tabulku, můžete použít DROP TABLE SQL příkaz. Tím smažete tabulku i všechna data v ní uložená.
Základní syntaxe vypadá takto:
DROP TABLE table_name;
Toto smaže tabulku, pokud existuje, a vyvolá chybu, pokud název tabulky neexistuje.
Pokud si přejete smazat tabulku, pokud existuje, a nedělat nic, pokud neexistuje, můžete zahrnout IF EXISTS kvalifikátor v rámci příkazu:
DROP TABLE IF EXISTS table_name;
Tabulky, které mají závislosti na jiných tabulkách nebo objektech, nelze ve výchozím nastavení odstranit, dokud tyto závislosti existují. Abyste se vyhnuli chybě, můžete volitelně zahrnout CASCADE parametr, který automaticky zruší všechny závislosti spolu s tabulkou:
DROP TABLE table_name CASCADE;
Pokud mají některé tabulky cizí klíč omezení, které odkazuje na tabulku, kterou odstraňujete, bude toto omezení automaticky odstraněno.
Smažte supplies tabulku, kterou jsme vytvořili dříve zadáním:
DROP TABLE supplies;
teachers si ponecháme databáze, abyste demonstrovali, že příkaz k odstranění databází také odstraní všechny podřízené objekty, jako jsou tabulky.
Zrušit databáze
DROP DATABASE příkaz říká PostgreSQL, aby smazal zadanou databázi. Základní syntaxe vypadá takto:
DROP DATABASE database_name;
Nahraďte database_name zástupný symbol s názvem databáze, kterou chcete odstranit. To smaže databázi, pokud je nalezena. Pokud databázi nelze najít, dojde k chybě:
DROP DATABASE some_database;
ERROR: database "some_database" does not exist
Pokud si přejete smazat databázi, pokud existuje, a jinak nedělat nic, zahrňte volitelný IF EXISTS možnost:
DROP DATABASE IF EXISTS some_database;
NOTICE: database "some_database" does not exist, skippingDROP DATABASE
To odstraní databázi nebo neudělá nic, pokud ji nelze najít.
Chcete-li odebrat school databáze, kterou jsme použili v této příručce, uveďte seznam existujících databází ve vašem systému:
\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)
Otevřete nové připojení k jedné z databází, které nechcete smazat:
\c defaultdb
Po otevření nového připojení odstraňte school databázi pomocí následujícího příkazu:
DROP DATABASE school;
Tím se odstraní school databáze spolu s teachers tabulka definovaná v.
Pokud jste sledovali používání SQL, můžete zde skončit nebo přeskočit k závěru. Pokud se chcete dozvědět, jak vytvářet a mazat databáze z příkazového řádku, pokračujte další částí.
Použití administrativních nástrojů příkazového řádku k vytváření a odstraňování databází
Pokud máte shell přístup k serveru nebo clusteru, kde je nainstalován PostgreSQL, můžete mít přístup k některým dalším nástrojům příkazového řádku, které mohou pomoci vytvářet a odstraňovat databáze. createdb a dropdb příkazy jsou součástí PostgreSQL, když je nainstalován.
Vytvořit novou databázi z příkazového řádku
Základní syntaxe pro createdb příkaz (který by měl spouštět systémový uživatel s přístupem správce k PostgreSQL) je:
createdb db_name
Tím se vytvoří databáze s názvem db_name v PostgreSQL pomocí výchozího nastavení.
Příkaz také přijímá možnosti pro změnu jeho chování, podobně jako varianta SQL, kterou jste viděli dříve. Více o těchto možnostech můžete zjistit pomocí man createdb . Některé z nejdůležitějších možností jsou:
--encoding=:nastavuje kódování znaků pro databázi.--locale=:nastaví národní prostředí pro databázi.
Ty mohou pomoci zajistit, že databáze může ukládat data ve formátech, které plánujete podporovat, a s předvolbami lokalizace vašeho projektu.
Chcete-li například zajistit, aby byla vaše databáze vytvořena s podporou Unicode a přepsat vlastní národní prostředí serveru pro použití lokalizace v americké angličtině, můžete zadat:
createdb --encoding=UTF8 --locale=en_US db_name
Za předpokladu, že máte správná oprávnění, bude databáze vytvořena podle vašich specifikací.
Chcete-li pokračovat v příkladech v této příručce, můžete vytvořit databázi nazvanou school pomocí výchozího národního prostředí a kódování znaků UTF8 zadáním:
createdb --encoding=UTF8 school
Poté se můžete připojit k databázi pomocí psql pro nastavení stolů jako obvykle.
Vypustit databáze z příkazového řádku
dropdb příkaz zrcadlí DROP DATABASE SQL příkaz. Má následující základní syntaxi:
dropdb database_name
Změňte database_name zástupný symbol pro odkaz na databázi, kterou chcete odstranit.
Ve výchozím nastavení tento příkaz způsobí chybu, pokud nelze zadanou databázi nalézt. Chcete-li se tomu vyhnout, můžete zahrnout volitelný --if-exists příznak:
dropdb --if-exists database_name
Tím dojde k odstranění zadané databáze, pokud existuje. Jinak neudělá nic.
Chcete-li smazat school databáze, kterou jsme vytvořili dříve, zadejte:
dropdb school
Tím se odstraní databáze a všechny podřízené prvky, jako jsou tabulky, v rámci.
Závěr
Tento článek se zabývá základy vytváření a odstraňování databází a tabulek v PostgreSQL. Toto jsou některé z nejzákladnějších příkazů potřebných k nastavení databázového systému a definování struktury vašich dat.
Jak již bylo zmíněno dříve, SQL příkazy obsažené v tomto tutoriálu PostgreSQL, zejména CREATE TABLE příkaz, mají mnoho dalších parametrů lze použít ke změně chování PostgreSQL. Můžete se o nich dozvědět více v oficiální dokumentaci PostgreSQL.