Introduktion
PostgreSQL och andra relationsdatabashanteringssystem använder databaser och tabeller att strukturera och organisera sina data. Vi kan snabbt granska definitionen av dessa två termer:
- databaser: separera olika uppsättningar av strukturer och data från varandra
- tabeller: definiera datastrukturen och lagra de faktiska datavärdena i databaser
I PostgreSQL finns det också ett mellanliggande objekt mellan databaser och tabeller som kallas schema :
- schema: ett namnutrymme i en databas som innehåller tabeller, index, vyer och andra objekt.
Den här guiden kommer inte direkt att behandla PostgreSQL:s koncept för ett schema, men det är bra att veta att det finns där.
Istället kommer vi att fokusera på hur man skapar och förstör PostgreSQL-databaser och tabeller. Exemplen kommer i första hand att använda SQL, men mot slutet kommer vi att visa dig hur du gör några av dessa uppgifter med hjälp av kommandoraden. Dessa alternativ använder verktyg som ingår i den vanliga PostgreSQL-installationen som är tillgängliga om du har administrativ åtkomst till PostgreSQL-värden.
Några av påståendena som tas upp i den här guiden, särskilt PostgreSQL CREATE TABLE uttalande, har många ytterligare alternativ som låg utanför ramen för denna artikel. Om du vill ha ytterligare information, ta reda på mer genom att kolla in den officiella PostgreSQL-dokumentationen.
Förutsättningar
För att följa med i den här guiden måste du logga in på en PostgreSQL-instans med en användare med administrativa rättigheter med psql kommandoradsklient. Din PostgreSQL-instans kan installeras lokalt, på distans eller tillhandahållas av en leverantör.
Specifikt kommer din PostgreSQL-användare att behöva CREATE DB privilegium eller vara en superanvändare , som du kan kontrollera med \du metakommando i psql :
\du
List of roles Role name | Attributes | Member of-----------+------------------------------------------------------------+----------- postgres | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
postgres superanvändare, som skapas automatiskt vid installationen, har de nödvändiga rättigheterna, men du kan använda vilken användare som helst med Skapa DB privilegium.
Skapa en ny databas
När du är ansluten till din PostgreSQL-instans med psql eller någon annan SQL-klient, kan du skapa en databas med SQL.
Den grundläggande syntaxen för att skapa en databas är:
CREATE DATABASE db_name;
Detta kommer att skapa en databas som heter db_name på den aktuella servern med den aktuella användaren inställd som den nya databasens ägare med standarddatabasinställningarna. Du kan se egenskaperna för standard mall1 mall med följande psql meta-kommando:
\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)
Du kan lägga till ytterligare parametrar för att ändra hur din databas skapas. Det här är några vanliga alternativ:
- KODNING: ställer in teckenkodningen för databasen.
- LC_COLLATE: ställer in sorteringen , eller sortera, ordning för databasen. Detta är ett lokaliseringsalternativ som avgör hur artiklar organiseras när de beställs.
- LC_CTYPE: ställer in teckenklassificeringen för den nya databasen. Detta är ett lokaliseringsalternativ som påverkar vilka tecken som anses vara versaler, gemener och siffror.
Dessa kan hjälpa till att säkerställa att databasen kan lagra data i de format du planerar att stödja och med ditt projekts lokaliseringsinställningar.
Till exempel för att säkerställa att din databas skapas med Unicode-stöd och för att åsidosätta serverns egen lokalisering för att använda amerikansk engelsk lokalisering (dessa råkar alla matcha värdena i mall1 visas ovan, så ingen förändring kommer faktiskt att ske), kan du skriva:
CREATE DATABASE db_name ENCODING 'UTF8' LC_COLLATE 'en_US.UTF-8' LC_CTYPE 'en_US.UTF-8';
För att följa exemplen i den här guiden, skapa en databas som heter skola med hjälp av din instanss standardinställningar och teckenkodningen UTF8:
CREATE DATABASE school ENCODING 'UTF8';
Detta kommer att skapa din nya databas med de specifikationer du angav.
Lista befintliga databaser
För att avgöra vilka databaser som för närvarande är tillgängliga på din server eller ditt kluster kan du använda följande SQL-sats:
SELECT datname FROM pg_database;
Detta kommer att lista var och en av de databaser som för närvarande är definierade i miljön:
datname----------- _dodb template1 template0 defaultdb school(5 rows)
Som nämnts tidigare, om du är ansluten med psql klient kan du också få denna information \l meta-kommando:
\l
Detta kommer att visa tillgängliga databasnamn tillsammans med deras ägare, kodning, språkinställningar och privilegier:
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)
skolan databasen som vi skapade visas bland de andra databaserna i systemet. Detta är ett bra sätt att få en överblick över databaserna inom din server eller kluster.
Skapa tabeller i databaser
Efter att ha skapat en eller flera databaser kan du börja definiera tabeller för att lagra dina data. Tabeller består av ett namn och ett definierat schema som bestämmer de fält och datatyper som varje post måste innehålla.
PostgreSQL SKAPA TABELL syntax
Du kan skapa tabeller med CREATE TABLE påstående. En förenklad grundläggande syntax för kommandot ser ut som följande:
CREATE TABLE table_name ( column_name TYPE [column_constraint], [table_constraint,]);
Komponenterna i ovanstående syntax inkluderar följande:
SKAPA TABELL tabellnamn:Den grundläggande skapandesatsen som signalerar att du vill definiera en tabell.tabellnamnplatshållaren ska ersättas med namnet på tabellen du vill använda.kolumnnamn TYP:Definierar en grundläggande kolumn i tabellen.column_nameplatshållaren ska ersättas med det namn du vill använda för din kolumn.TYPEanger PostgreSQL-datatypen för kolumnen. Data som lagras i tabellen måste överensstämma med kolumnstrukturen och kolumndatatyperna för att accepteras.column_constraint:Kolumnbegränsningar är valfria begränsningar för att lägga till ytterligare begränsningar för data som kan lagras i kolumnen. Du kan till exempel kräva att poster inte är null, unika eller positiva heltal.tabellbegränsningar:Tabellbegränsningar liknar kolumnbegränsningar men involverar interaktion mellan flera kolumner. Du kan till exempel ha en tabellrestriktion som kontrollerar att enDATE_OF_BIRTHär föreDATE_OF_DEATHi en tabell.
Skapa tabeller villkorligt med IF NOT EXISTS klausul
Som standard, om du försöker skapa en tabell i PostgreSQL som redan finns i databasen, kommer ett fel att uppstå. För att kringgå det här problemet i fall där du vill skapa en tabell om den inte finns, men bara fortsätta om den redan finns, kan du använda OM INTE FINNS klausul. OM INTE FINNS valfri kvalificerare som säger åt PostgreSQL att ignorera satsen om databasen redan finns.
För att använda CREATE TABLE syntax och före tabellnamnet:
CREATE TABLE IF NOT EXISTS table_name ( column_name TYPE [column_constraint], [table_constraint,]);
Denna variant kommer att försöka skapa tabellen. Om en tabell med det namnet redan finns i den angivna databasen kommer PostgreSQL att skicka en varning som indikerar att tabellnamnet redan har tagits istället för att misslyckas med ett fel.
Så skapar du tabeller i PostgreSQL
Ovanstående syntax räcker för att skapa grundläggande tabeller. Som ett exempel kommer vi att skapa två tabeller inom vår skola databas. En tabell kommer att kallas tillbehör och den andra kommer att kallas lärare :
I tillbehör tabell, vill vi ha följande fält:
- ID: Ett unikt ID för varje typ av skolmaterial.
- Namn: Namnet på ett specifikt skolobjekt.
- Beskrivning: En kort beskrivning av föremålet.
- Tillverkare: Namnet på artikeltillverkaren.
- Färg: Objektets färg.
- Annonsutrymme: Antalet artiklar vi har för en viss typ av skolutbud. Detta bör aldrig vara mindre än 0.
Vi kan skapa tillbehör tabell med ovanstående egenskaper med hjälp av följande SQL.
Byt först till skolan databas du skapade med psql genom att skriva:
\c school
Detta kommer att ändra databasen som våra framtida kommandon kommer att riktas mot. Din prompt bör ändras för att återspegla databasen.
Skapa sedan tillbehör tabell med följande påstående:
CREATE TABLE supplies ( id INT PRIMARY KEY, name VARCHAR, description VARCHAR, manufacturer VARCHAR, color VARCHAR, inventory int CHECK (inventory > 0));
Detta skapar tillbehör tabell inom skolan databas. PRIMÄRKEY kolumnbegränsning är en speciell begränsning som används för att indikera kolumner som unikt kan identifiera poster i tabellen. Som sådan anger begränsningen att kolumnen inte kan vara null och måste vara unik. PostgreSQL skapar index för primärnyckelkolumner för att öka frågehastigheten.
Kontrollera att den nya tabellen finns genom att skriva:
\dt
List of relations Schema | Name | Type | Owner --------+----------+-------+--------- public | supplies | table | doadmin(1 row)
Verifiera att schemat återspeglar den avsedda designen genom att skriva:
\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)
Vi kan se var och en av de kolumner och datatyper som vi angav. Kolumnrestriktionen som vi definierade för inventeringen kolumnen listas mot slutet.
Därefter kommer vi att skapa en lärare tabell. I den här tabellen bör följande kolumner finnas:
- Anställd-ID :Ett unikt anställds identifieringsnummer.
- Förnamn :Lärarens förnamn.
- Efternamn :Lärarens efternamn.
- Ämne :Ämnet som läraren anlitas för att undervisa i.
- Betygsnivå :Betygsnivån för elever som läraren är anställd för att undervisa.
Skapa lärarna tabell med ovanstående schema med följande SQL:
CREATE TABLE teachers ( id INT PRIMARY KEY, first_name VARCHAR, last_name VARCHAR, subject VARCHAR, grade_level int);
Så skapar du tabeller med primärnycklar och främmande nycklar
Du kan hitta information om att skapa tabeller med primära och främmande nycklar i några av våra andra PostgreSQL-guider. Primära nycklar och främmande nycklar är båda typer av databasrestriktioner inom PostgreSQL.
En primärnyckel är en speciell kolumn eller kolumn som garanterat är unik över rader i samma tabell. Alla primärnycklar kan användas för att unikt identifiera en specifik rad. Primära nycklar säkerställer inte bara att varje rad har ett unikt värde för primärnyckelkolumnerna, de säkerställer också att inga rader innehåller NULL värden för den kolumnen. Ofta använder primärnyckeln i PostgreSQL följande format för att ange en automatiskt tilldelad inkrementerande primärnyckel:id SERIAL PRIMARY KEY .
Främmande nycklar är ett sätt att säkerställa att en kolumn eller kolumner i en tabell matchar värdena i en annan tabell. Detta hjälper till att säkerställa referensintegritet mellan tabeller.
Så visar du tabeller i PostgreSQL
I PostgreSQL kan du lista tabeller på några olika sätt beroende på vilken information du letar efter.
Om du vill se vilka tabeller som finns tillgängliga i din databas kan du använda \dt metakommando som ingår i psql klient för att lista alla tabeller, som vi visade ovan:
\dt
List of relations Schema | Name | Type | Owner--------+----------+-------+--------- public | supplies | table | doadmin public | teachers | table | doadmin(2 rows)
Du kan också kontrollera att schemat för tabellen matchar dina specifikationer:
\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)
lärarna tabellen verkar matcha vår definition.
Ändra tabeller
Om du behöver ändra schemat för en befintlig tabell i PostgreSQL kan du använda ALTER TABLE kommando. ALTER TABLE kommandot är mycket likt CREATE TABLE kommando, men fungerar på en befintlig tabell.
Ändra tabellsyntax
Den grundläggande syntaxen för att ändra tabeller i PostgreSQL ser ut så här:
ALTER TABLE <table_name> <change_command> <change_parameters>
Lägga till kolumner i tabeller
Du kan lägga till en kolumn i en PostgreSQL-tabell med ADD COLUMN ändra kommando. Ändringsparametrarna inkluderar kolumnnamn, typ och alternativ, precis som du skulle ange dem i SKAPA TABELL kommando.
Till exempel för att lägga till en kolumn som heter missing_column av texten skriv till en tabell som heter some_table , skulle du skriva:
ALTER TABLE some_table ADD COLUMN missing_column text;
Ta bort kolumner från tabeller
Om du istället vill ta bort en befintlig kolumn kan du använda DROP COLUMN kommandot istället. Du måste ange namnet på den kolumn du vill ta bort som en ändringsparameter:
ALTER TABLE some_table DROP COLUMN useless_column;
Ändra datatypen för en kolumn
För att ändra datatypen som PostgreSQL använder för en specifik kolumn kan du använda ALTER COLUMN ändra kommandot med SET DATA TYPE kolumnkommando. Parametrarna inkluderar kolumnnamnet, dess nya typ och en valfri USING sats för att specificera hur den gamla typen ska konverteras till den nya typen.
Till exempel för att ställa in värdet på ett id kolumnen i resident tabell till en int med en explicit roll kan vi skriva följande:
ALTER TABLE resident ALTER COLUMN id SET DATA TYPE int USING id::int;
Andra tabelländringar
Många andra typer av ändringar kan uppnås med ALTER TABLE kommando. För mer information om tillgängliga alternativ, kolla in den officiella PostgreSQL-dokumentationen för ALTER TABLE .
Släpptabeller
Om du vill ta bort en tabell kan du använda DROP TABLE SQL-sats. Detta kommer att radera tabellen samt all data som lagras i den.
Den grundläggande syntaxen ser ut så här:
DROP TABLE table_name;
Detta kommer att radera tabellen om den finns och skapa ett fel om tabellnamnet inte finns.
Om du vill ta bort tabellen om den finns och inte göra något om den inte finns, kan du inkludera OM FINNS kvalificerare i uttalandet:
DROP TABLE IF EXISTS table_name;
Tabeller som har beroenden till andra tabeller eller objekt kan inte tas bort som standard medan dessa beroenden existerar. För att undvika felet kan du valfritt inkludera CASCADE parameter, som automatiskt tar bort alla beroenden tillsammans med tabellen:
DROP TABLE table_name CASCADE;
Om några tabeller har en främmande nyckel begränsning, som refererar till tabellen som du tar bort, kommer den begränsningen automatiskt att tas bort.
Ta bort tillbehör tabell vi skapade tidigare genom att skriva:
DROP TABLE supplies;
Vi behåller lärarna databas för att visa att satsen att ta bort databaser också tar bort alla underordnade objekt som tabeller.
Släpp databaser
DROP DATABASE uttalande säger till PostgreSQL att ta bort den angivna databasen. Den grundläggande syntaxen ser ut så här:
DROP DATABASE database_name;
Ersätt database_name platshållare med namnet på databasen du vill ta bort. Detta kommer att radera databasen om den hittas. Om databasen inte kan hittas kommer ett fel att uppstå:
DROP DATABASE some_database;
ERROR: database "some_database" does not exist
Om du vill ta bort databasen om den finns och annars inte gör något, inkludera den valfria OM FINNS alternativ:
DROP DATABASE IF EXISTS some_database;
NOTICE: database "some_database" does not exist, skippingDROP DATABASE
Detta tar bort databasen eller gör ingenting om den inte kan hittas.
För att ta bort skolan databas som vi använde i den här guiden, lista de befintliga databaserna på ditt system:
\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)
Öppna en ny anslutning till en av databaserna du inte vill ta bort:
\c defaultdb
När den nya anslutningen är öppen tar du bort skolan databas med följande kommando:
DROP DATABASE school;
Detta tar bort skolan databas tillsammans med lärarna tabell definierad inom.
Om du har följt med med SQL kan du avsluta här eller hoppa till slutsatsen. Om du vill lära dig hur du skapar och tar bort databaser från kommandoraden, fortsätt till nästa avsnitt.
Använda administrativa kommandoradsverktyg för att skapa och ta bort databaser
Om du har skalåtkomst till servern eller klustret där PostgreSQL är installerat, kan du ha tillgång till några ytterligare kommandoradsverktyg som kan hjälpa till att skapa och ta bort databaser. createdb och dropdb kommandon buntas med PostgreSQL när det är installerat.
Skapa en ny databas från kommandoraden
Den grundläggande syntaxen för createdb kommandot (som bör köras av en systemanvändare med administratörsbehörighet till PostgreSQL) är:
createdb db_name
Detta kommer att skapa en databas som heter db_name inom PostgreSQL med standardinställningarna.
Kommandot accepterar också alternativ för att ändra dess beteende, ungefär som SQL-varianten du såg tidigare. Du kan ta reda på mer om dessa alternativ med man createdb . Några av de viktigaste alternativen är:
--encoding=:ställer in teckenkodningen för databasen.--locale=:ställer in lokalen för databasen.
Dessa kan hjälpa till att säkerställa att databasen kan lagra data i de format du planerar att stödja och med ditt projekts lokaliseringsinställningar.
Till exempel, för att säkerställa att din databas skapas med Unicode-stöd och för att åsidosätta serverns egen lokalisering för att använda amerikansk engelsk lokalisering, kan du skriva:
createdb --encoding=UTF8 --locale=en_US db_name
Förutsatt att du har rätt behörigheter kommer databasen att skapas enligt dina specifikationer.
För att följa exemplen i den här guiden kan du skapa en databas som heter skola använder standardspråket och teckenkodningen UTF8 genom att skriva:
createdb --encoding=UTF8 school
Du kan sedan ansluta till databasen med psql för att ställa upp dina bord som vanligt.
Släpp databaser från kommandoraden
dropdb kommandot speglar DROP DATABASE SQL-sats. Den har följande grundläggande syntax:
dropdb database_name
Ändra database_name platshållare för att referera till databasen du vill ta bort.
Som standard kommer detta kommando att resultera i ett fel om den angivna databasen inte kan hittas. För att undvika detta kan du inkludera den valfria --om-finns flagga:
dropdb --if-exists database_name
Detta kommer att radera den angivna databasen om den finns. Annars gör det ingenting.
För att ta bort skolan databas vi skapade tidigare, skriv:
dropdb school
Detta tar bort databasen och alla underordnade element, som tabeller, inom.
Slutsats
Den här artikeln behandlade grunderna i hur man skapar och tar bort databaser och tabeller i PostgreSQL. Det här är några av de mest grundläggande kommandona som krävs för att konfigurera ett databassystem och för att definiera strukturen för dina data.
Som nämnts tidigare täcks SQL-satserna i denna PostgreSQL-handledning, särskilt CREATE TABLE uttalande, har många ytterligare parametrar kan användas för att ändra PostgreSQL:s beteende. Du kan ta reda på mer om dessa genom att kolla in den officiella PostgreSQL-dokumentationen.