Come creare ed eliminare database e tabelle in PostgreSQL

Introduzione

PostgreSQL e altri sistemi di gestione di database relazionali utilizzano database e tabelle strutturare e organizzare i propri dati. Possiamo rivedere rapidamente la definizione di questi due termini:

• database: separare diversi insiemi di strutture e dati l'uno dall'altro
• tabelle: definire la struttura dei dati e memorizzare i valori dei dati effettivi all'interno dei database

In PostgreSQL esiste anche un oggetto intermedio tra database e tabelle chiamato schema :

• schema: uno spazio dei nomi all'interno di un database che contiene tabelle, indici, viste e altri elementi.

Questa guida non tratterà direttamente il concetto di schema di PostgreSQL, ma è bene sapere che esiste.

Invece, ci concentreremo su come creare e distruggere database e tabelle PostgreSQL. Gli esempi utilizzeranno principalmente SQL, ma verso la fine ti mostreremo come eseguire alcune di queste attività utilizzando la riga di comando. Queste alternative utilizzano strumenti inclusi nell'installazione standard di PostgreSQL che sono disponibili se si dispone dell'accesso amministrativo all'host PostgreSQL.

Alcune delle istruzioni trattate in questa guida, in particolare il CREATE TABLE di PostgreSQL dichiarazione, hanno molte opzioni aggiuntive che erano al di fuori dell'ambito di questo articolo. Se desideri ulteriori informazioni, scopri di più consultando la documentazione ufficiale di PostgreSQL.

Prerequisiti

Per seguire questa guida, dovrai accedere a un'istanza PostgreSQL con un utente con privilegi di amministratore utilizzando psql client della riga di comando. La tua istanza PostgreSQL può essere installata in locale, in remoto o fornita da un provider.

In particolare, il tuo utente PostgreSQL avrà bisogno del CREATE DB privilegio o essere un Superuser , che puoi verificare con il \du metacomando in psql :

\du
 

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

Il postgres superuser, che viene creato automaticamente al momento dell'installazione, dispone dei privilegi richiesti, ma puoi utilizzare qualsiasi utente con Create DB privilegio.

Crea un nuovo database

Dopo esserti connesso alla tua istanza PostgreSQL usando psql o qualsiasi altro client SQL, puoi creare un database utilizzando SQL.

La sintassi di base per la creazione di un database è:

CREATE DATABASE db_name;
 

Questo creerà un database chiamato db_name sul server corrente con l'utente corrente impostato come proprietario del nuovo database utilizzando le impostazioni del database predefinite. Puoi visualizzare le proprietà del template1 predefinito modello utilizzando il seguente psql meta-comando:

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

È possibile aggiungere parametri aggiuntivi per modificare il modo in cui viene creato il database. Queste sono alcune opzioni comuni:

• CODIFICA: imposta la codifica dei caratteri per il database.
• LC_COLLATE: imposta la confronto o ordinare, ordinare per il database. Questa è un'opzione di localizzazione che determina come sono organizzati gli articoli quando vengono ordinati.
• LC_CTYPE: imposta la classificazione dei caratteri per il nuovo database. Questa è un'opzione di localizzazione che influenza quali caratteri sono considerati maiuscoli, minuscoli e cifre.

Questi possono aiutare a garantire che il database possa archiviare i dati nei formati che prevedi di supportare e con le preferenze di localizzazione del tuo progetto.

Ad esempio, per garantire che il database sia creato con il supporto Unicode e per sovrascrivere la locale del server per utilizzare la localizzazione in inglese americano (questi corrispondono tutti ai valori nel template1 mostrato sopra, quindi non si verificherà effettivamente alcuna modifica), puoi digitare:

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

Per seguire gli esempi in questa guida, crea un database chiamato school utilizzando le impostazioni locali predefinite dell'istanza e la codifica dei caratteri UTF8:

CREATE DATABASE school ENCODING 'UTF8';
 

Questo creerà il tuo nuovo database utilizzando le specifiche che hai fornito.

Elenca i database esistenti

Per determinare quali database sono attualmente disponibili sul tuo server o cluster, puoi utilizzare la seguente istruzione SQL:

SELECT datname FROM pg_database;
 

Questo elencherà ciascuno dei database attualmente definiti all'interno dell'ambiente:

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

Come accennato in precedenza, se sei connesso usando il psql client, puoi anche ottenere queste informazioni \l meta-comando:

\l
 

Questo mostrerà i nomi di database disponibili insieme ai loro proprietari, codifica, impostazioni locali e privilegi:

                                  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)
 

La school database che abbiamo creato viene visualizzato tra gli altri database sul sistema. Questo è un buon modo per avere una panoramica dei database all'interno del tuo server o cluster.

Crea tabelle all'interno di database

Dopo aver creato uno o più database, puoi iniziare a definire le tabelle in cui archiviare i tuoi dati. Le tabelle sono costituite da un nome e da uno schema definito che determina i campi e i tipi di dati che ogni record deve contenere.

PostgreSQL CREATE TABLE sintassi

Puoi creare tabelle usando CREATE TABLE dichiarazione. Una sintassi di base semplificata per il comando è simile alla seguente:

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

I componenti della sintassi precedente includono quanto segue:

• CREATE TABLE table_name :L'istruzione di creazione di base che segnala che desideri definire una tabella. Il table_name il segnaposto deve essere sostituito con il nome della tabella che desideri utilizzare.
• column_name TYPE :definisce una colonna di base all'interno della tabella. Il column_name il segnaposto deve essere sostituito con il nome che desideri utilizzare per la colonna. Il TYPE specifica il tipo di dati PostgreSQL per la colonna. I dati archiviati nella tabella devono essere conformi alla struttura della colonna e ai tipi di dati della colonna per essere accettati.
• column_constraint :i vincoli di colonna sono vincoli facoltativi per aggiungere ulteriori restrizioni ai dati che possono essere archiviati nella colonna. Ad esempio, puoi richiedere che le voci non siano numeri interi nulli, univoci o positivi.
• table_constraints :i vincoli di tabella sono simili ai vincoli di colonna ma implicano l'interazione di più colonne. Ad esempio, potresti avere un vincolo di tabella che controlla che un DATE_OF_BIRTH è precedente a DATE_OF_DEATH in una tabella.

Crea tabelle in modo condizionale con IF NOT EXISTS clausola

Per impostazione predefinita, se si tenta di creare una tabella in PostgreSQL che esiste già all'interno del database, si verificherà un errore. Per aggirare questo problema nei casi in cui desideri creare una tabella se non è presente, ma continuare se esiste già, puoi utilizzare il IF NOT EXISTS clausola. Il IF NOT EXISTS qualificatore facoltativo che dice a PostgreSQL di ignorare l'istruzione se il database esiste già.

Per utilizzare il IF NOT EXISTS clausola, inserirla nel comando dopo CREATE TABLE sintassi e prima del nome della tabella:

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

Questa variante tenterà di creare la tabella. Se esiste già una tabella con quel nome all'interno del database specificato, PostgreSQL genererà un avviso che indica che il nome della tabella è già stato preso invece di non riuscire con un errore.

Come creare tabelle in PostgreSQL

La sintassi sopra è sufficiente per creare tabelle di base. Ad esempio, creeremo due tabelle all'interno della nostra school Banca dati. Una tabella si chiamerà supplies e l'altro si chiamerà teachers :

Nelle supplies tabella, vogliamo avere i seguenti campi:

• ID: Un ID univoco per ogni tipo di materiale scolastico.
• Nome: Il nome di un elemento scolastico specifico.
• Descrizione: Una breve descrizione dell'oggetto.
• Produttore: Il nome del produttore dell'articolo.
• Colore: Il colore dell'articolo.
• Inventario: Il numero di articoli che abbiamo per un certo tipo di materiale scolastico. Questo non dovrebbe mai essere inferiore a 0.

Possiamo creare le supplies tabella con le qualità di cui sopra utilizzando il seguente SQL.

Per prima cosa, passa alla school database che hai creato con psql digitando:

\c school
 

Ciò cambierà il database a cui verranno indirizzati i nostri comandi futuri. La tua richiesta dovrebbe cambiare per riflettere il database.

Quindi, crea i supplies tabella con la seguente affermazione:

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

Questo creerà i supplies tabella all'interno della school Banca dati. La PRIMARY KEY il vincolo di colonna è un vincolo speciale utilizzato per indicare le colonne che possono identificare in modo univoco i record all'interno della tabella. In quanto tale, il vincolo specifica che la colonna non può essere nulla e deve essere univoca. PostgreSQL crea indici per le colonne della chiave primaria per aumentare la velocità di query.

Verifica che la nuova tabella sia presente digitando:

\dt
 

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

Verifica che lo schema rifletta il design previsto digitando:

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

Possiamo vedere ciascuna delle colonne e dei tipi di dati che abbiamo specificato. Il vincolo di colonna che abbiamo definito per l'inventory la colonna è elencata verso la fine.

Successivamente, creeremo un teachers tavolo. In questa tabella dovrebbero essere presenti le seguenti colonne:

• ID dipendente :un numero di identificazione univoco del dipendente.
• Nome :il nome dell'insegnante.
• Cognome :il cognome dell'insegnante.
• Oggetto :la materia per la quale l'insegnante viene assunto per insegnare.
• Livello di classe :il livello di classe degli studenti per i quali l'insegnamento viene assunto per insegnare.

Crea i teachers tabella con lo schema sopra con il seguente SQL:

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

Come creare tabelle con chiavi primarie e chiavi esterne

Puoi trovare informazioni sulla creazione di tabelle con chiavi primarie ed esterne in alcune delle nostre altre guide PostgreSQL. Le chiavi primarie e le chiavi esterne sono entrambi tipi di vincoli di database all'interno di PostgreSQL.

Una chiave primaria è una colonna o una colonna speciale che è garantita per essere univoca tra le righe all'interno della stessa tabella. Tutte le chiavi primarie possono essere utilizzate per identificare in modo univoco una riga specifica. Le chiavi primarie non solo assicurano che ogni riga abbia un valore univoco per le colonne della chiave primaria, ma assicurano anche che nessuna riga contenga NULL valori per quella colonna. Spesso, la chiave primaria in PostgreSQL utilizza il seguente formato per specificare una chiave primaria incrementale assegnata automaticamente:id SERIAL PRIMARY KEY .

Le chiavi esterne sono un modo per garantire che una o più colonne in una tabella corrispondano ai valori contenuti in un'altra tabella. Questo aiuta a garantire l'integrità referenziale tra le tabelle.

Come visualizzare le tabelle in PostgreSQL

In PostgreSQL puoi elencare le tabelle in diversi modi a seconda delle informazioni che stai cercando.

Se desideri vedere quali tabelle sono disponibili nel tuo database, puoi utilizzare il \dt metacomando incluso con psql client per elencare tutte le tabelle, come mostrato sopra:

\dt
 

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

Puoi anche verificare che lo schema per la tabella corrisponda alle tue specifiche:

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

Gli teachers la tabella sembra corrispondere alla nostra definizione.

Alter tabelle

Se hai bisogno di cambiare lo schema di una tabella esistente in PostgreSQL, puoi usare ALTER TABLE comando. Il ALTER TABLE il comando è molto simile al CREATE TABLE comando, ma opera su una tabella esistente.

Modifica la sintassi della tabella

La sintassi di base per modificare le tabelle in PostgreSQL è simile alla seguente:

ALTER TABLE <table_name> <change_command> <change_parameters>
 

Il <change_command> indica il tipo esatto di modifica che si desidera apportare, sia che si tratti di impostare opzioni diverse sulla tabella, aggiungere o rimuovere colonne o modificare tipi o vincoli. Il <change_parameters> parte del comando contiene tutte le informazioni aggiuntive di cui PostgreSQL ha bisogno per completare la modifica.

Aggiunta di colonne alle tabelle

Puoi aggiungere una colonna a una tabella PostgreSQL con ADD COLUMN cambia comando. I parametri di modifica includeranno il nome della colonna, il tipo e le opzioni, proprio come li specificheresti in CREATE TABLE comando.

Ad esempio, per aggiungere una colonna chiamata missing_column del text digita in una tabella chiamata some_table , dovresti digitare:

ALTER TABLE some_table ADD COLUMN missing_column text;
 

Rimozione di colonne dalle tabelle

Se, invece, desideri rimuovere una colonna esistente, puoi utilizzare il DROP COLUMN comando invece. Devi specificare il nome della colonna che desideri eliminare come parametro di modifica:

ALTER TABLE some_table DROP COLUMN useless_column;
 

Modifica del tipo di dati di una colonna

Per modificare il tipo di dati utilizzato da PostgreSQL per una colonna specifica, puoi utilizzare ALTER COLUMN cambia comando con il SET DATA TYPE comando di colonna. I parametri includono il nome della colonna, il suo nuovo tipo e un USING facoltativo clausola per specificare come convertire il vecchio tipo nel nuovo tipo.

Ad esempio, per impostare il valore di un id nella colonna resident tabella a un int utilizzando un cast esplicito, possiamo digitare quanto segue:

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

Altre modifiche alla tabella

Molti altri tipi di modifiche possono essere ottenuti con ALTER TABLE comando. Per ulteriori informazioni sulle opzioni disponibili, consulta la documentazione ufficiale di PostgreSQL per ALTER TABLE .

Tabelle drop

Se desideri eliminare una tabella, puoi utilizzare il DROP TABLE Istruzione SQL. Questo cancellerà la tabella così come tutti i dati memorizzati al suo interno.

La sintassi di base è simile alla seguente:

DROP TABLE table_name;
 

Questo cancellerà la tabella se esiste e genererà un errore se il nome della tabella non esiste.

Se desideri eliminare la tabella se esiste e non fare nulla se non esiste, puoi includere il IF EXISTS qualificatore all'interno della dichiarazione:

DROP TABLE IF EXISTS table_name;
 

Le tabelle che hanno dipendenze da altre tabelle o oggetti non possono essere eliminate per impostazione predefinita mentre esistono tali dipendenze. Per evitare l'errore, puoi opzionalmente includere il CASCADE parametro, che elimina automaticamente tutte le dipendenze insieme alla tabella:

DROP TABLE table_name CASCADE;
 

Se alcune tabelle hanno una chiave esterna vincolo, che fa riferimento alla tabella che stai eliminando, tale vincolo verrà automaticamente eliminato.

Elimina le supplies tabella che abbiamo creato in precedenza digitando:

DROP TABLE supplies;
 

Conserveremo i teachers database per dimostrare che l'istruzione per eliminare i database rimuove anche tutti gli oggetti figlio come le tabelle.

Database di rilascio

Il DROP DATABASE istruzione dice a PostgreSQL di eliminare il database specificato. La sintassi di base è simile alla seguente:

DROP DATABASE database_name;
 

Sostituisci il database_name segnaposto con il nome del database che si desidera rimuovere. Questo cancellerà il database se viene trovato. Se non è possibile trovare il database, si verificherà un errore:

DROP DATABASE some_database;
 

ERROR:  database "some_database" does not exist
 

Se desideri eliminare il database se esiste e altrimenti non fare nulla, includi l'opzione IF EXISTS opzione:

DROP DATABASE IF EXISTS some_database;
 

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

Questo rimuoverà il database o non farà nulla se non può essere trovato.

Per rimuovere la school database che abbiamo utilizzato in questa guida, elenca i database esistenti sul tuo sistema:

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

Apri una nuova connessione a uno dei database che non desideri eliminare:

\c defaultdb
 

Una volta aperta la nuova connessione, elimina la school database con il seguente comando:

DROP DATABASE school;
 

Questo rimuoverà la school database insieme ai teachers tabella definita all'interno.

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