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. Iltable_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. Ilcolumn_name
il segnaposto deve essere sostituito con il nome che desideri utilizzare per la colonna. IlTYPE
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 unDATE_OF_BIRTH
è precedente aDATE_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.
Se hai seguito utilizzando SQL, puoi terminare qui o saltare alla conclusione. Se desideri sapere come creare ed eliminare database dalla riga di comando, vai alla sezione successiva.
Utilizzo degli strumenti amministrativi a riga di comando per creare ed eliminare database
Se disponi dell'accesso shell al server o al cluster in cui è installato PostgreSQL, potresti avere accesso ad alcuni strumenti aggiuntivi della riga di comando che possono aiutare a creare ed eliminare database. Il createdb
e dropdb
i comandi vengono forniti in bundle con PostgreSQL al momento dell'installazione.
Crea un nuovo database dalla riga di comando
La sintassi di base per createdb
Il comando (che dovrebbe essere eseguito da un utente di sistema con accesso come amministratore a PostgreSQL) è:
createdb db_name
Questo creerà un database chiamato db_name
all'interno di PostgreSQL utilizzando le impostazioni predefinite.
Il comando accetta anche opzioni per alterarne il comportamento, proprio come la variante SQL che hai visto in precedenza. Puoi scoprire di più su queste opzioni con man createdb
. Alcune delle opzioni più importanti sono:
--encoding=
:imposta la codifica dei caratteri per il database.--locale=
:imposta la locale per il database.
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 assicurarti che il tuo database sia creato con il supporto Unicode e per sovrascrivere la locale del server per usare la localizzazione in inglese americano, puoi digitare:
createdb --encoding=UTF8 --locale=en_US db_name
Supponendo che tu disponga delle autorizzazioni corrette, il database verrà creato in base alle tue specifiche.
Per seguire gli esempi in questa guida, puoi creare un database chiamato school
utilizzando le impostazioni internazionali predefinite e la codifica dei caratteri UTF8 digitando:
createdb --encoding=UTF8 school
Puoi quindi connetterti al database usando psql
per allestire i tuoi tavoli come al solito.
Rilascia database dalla riga di comando
Il dropdb
il comando rispecchia il DROP DATABASE
Istruzione SQL. Ha la seguente sintassi di base:
dropdb database_name
Modifica il database_name
segnaposto per fare riferimento al database che desideri eliminare.
Per impostazione predefinita, questo comando genererà un errore se non è possibile trovare il database specificato. Per evitare ciò, puoi includere l'opzione --if-exists
bandiera:
dropdb --if-exists database_name
Questo cancellerà il database specificato se esiste. Altrimenti, non farà nulla.
Per eliminare la school
database che abbiamo creato in precedenza, digita:
dropdb school
Questo rimuoverà il database e tutti gli elementi figlio, come le tabelle, all'interno.
Conclusione
Questo articolo ha trattato le nozioni di base su come creare ed eliminare database e tabelle all'interno di PostgreSQL. Questi sono alcuni dei comandi più basilari richiesti per configurare un sistema di database e definire la struttura dei tuoi dati.
Come accennato in precedenza, le istruzioni SQL trattate in questo tutorial di PostgreSQL, in particolare CREATE TABLE
istruzione, hanno molti parametri aggiuntivi che possono essere utilizzati per modificare il comportamento di PostgreSQL. Puoi saperne di più su questi controllando la documentazione ufficiale di PostgreSQL.