PostgreSQL e psql
Accendere il server, e parlargli dal terminale
- 10 minuti di lettura
Un file di testo lo apri e lo leggi. Un database no: sta dentro un programma che resta acceso e risponde alle domande che gli fai. Quel programma si chiama PostgreSQL.
Questo capitolo non insegna l'SQL (le domande da fare): quello è il libro SQL. Qui impari a accendere il programma, creargli un database e entrare a parlargli. Sono gli attrezzi che servono prima di qualsiasi query, e quelli che si rompono per primi.
Il disegno
Sono due programmi, non uno.
IL TUO TERMINALE IL SERVER
┌────────────────┐ una domanda ┌──────────────────────────┐
│ psql │ ──────────────────▶ │ PostgreSQL │
│ (il client) │ ◀────────────────── │ resta acceso, tiene i │
└───────┬────────┘ la risposta │ database: │
│ │ banco_postgresql_e_psql│
│ │ ... │
│ └──────────────────────────┘
│ ▲
└── si parlano attraverso il SOCKET ───────┘
(un file speciale, in una cartella: Mac /tmp,
WSL /var/run/postgresql)- Il server è PostgreSQL. Se è spento, non risponde nessuno.
- Il client è
psql: una finestra di terminale da cui scrivi le domande. Anche VS Code, più avanti, sarà un client. - Un server tiene tanti database, ognuno con le sue tabelle. Un database è la scatola, le tabelle sono dentro.
Accendere il server
Il server non parte da solo quando apri il terminale: va acceso, e si accende in modo diverso.
| Come lo accendi | Quanto dura | |
|---|---|---|
| Mac | brew services start postgresql@16 | Una volta sola: ripartirà da solo anche dopo aver riacceso il computer |
| WSL | sudo service postgresql start | Ogni volta che apri un terminale Ubuntu nuovo |
Come sai se è acceso? Lo chiedi a lui:
pg_isready/tmp:5432 - accepting connectionsaccepting connections vuol dire: acceso e pronto. Prima dei due punti c'è la cartella del socket (/tmp su Mac, su WSL vedrai /var/run/postgresql); dopo, la porta, 5432. Se invece leggi no response, il server è spento, oppure pg_isready sta cercando nella cartella sbagliata (ne parliamo in fondo).
Creare e cancellare un database
Due comandi, che si scrivono nel terminale (non dentro psql):
createdb banco_postgresql_e_psql
dropdb banco_postgresql_e_psqlSe va tutto bene, non scrivono niente: nel terminale, silenzio vuol dire fatto. createdb crea un database vuoto; dropdb lo butta, con tutto quello che c'è dentro.
Il nome banco_postgresql_e_psql è lungo apposta: ogni missione della palestra ha un database con un nome suo, e tutti cominciano così. Il nome di un database è come quello di una variabile: lettere minuscole, numeri e trattini bassi, niente spazi.
Entrare con psql
Per parlare con un database ci entri:
psql -d banco_postgresql_e_psql-d vuol dire «database»: dopo, il nome. Dentro psql il prompt (la riga che ti aspetta) cambia, e vale la pena leggerlo: ti dice a quale database sei collegato.
psql (16.15 (Homebrew))
Type "help" for help.
banco_postgresql_e_psql=# \dt
List of relations
Schema | Name | Type | Owner
--------+--------------+-------+-------
public | personale | table | marta
public | segnalazioni | table | marta
public | stazioni | table | marta
public | treni | table | marta
public | turni | table | marta
(5 rows)
banco_postgresql_e_psql=# \q(Qui il database è già pieno: tra poco vedi come. L'utente marta sei tu: nel tuo computer vedrai il tuo nome.)
Il prompt dice in quale database sei: banco_postgresql_e_psql=#. Il simbolo # dice che sei un utente con tutti i poteri (su Mac e su WSL lo sei quasi sempre); con un utente normale vedresti >. Sono la stessa cosa, per ora.
Un caso da riconoscere subito: il prompt che cambia in -#.
banco_postgresql_e_psql=# SELECT count(*) FROM treni
banco_postgresql_e_psql-# ;
count
-------
8
(1 row)Un comando SQL finisce con il punto e virgola. Se premi Invio senza, psql pensa che tu non abbia finito e aspetta la riga dopo: il -# è la sua faccia da «continua pure». Scrivi ; e parte.
Per uscire: \q. E la freccia in su richiama il comando di prima, per correggerlo invece di riscriverlo.
I comandi con la barra
Dentro psql ci sono due lingue. Tutto quello che comincia con la barra rovesciata (\) lo capisce psql stesso, non va chiuso con il punto e virgola, e non è SQL. Il resto è SQL, e finisce con ;.
| Comando | Cosa fa |
|---|---|
\l | Elenca i database del server (\l banco* solo quelli che cominciano per «banco») |
\c nome | Si sposta in un altro database, senza uscire |
\dt | Elenca le tabelle del database in cui sei |
\d tabella | Mostra le colonne di una tabella, le chiavi e i collegamenti |
\x auto | Se una riga è troppo larga per lo schermo, la mostra in verticale |
\conninfo | Dice dove sei collegato: database, utente, socket |
\? | L'elenco di tutti i comandi con la barra |
\q | Esce |
Per i database, ad esempio:
banco_postgresql_e_psql=# \l banco*
List of databases
Name | Owner | Encoding | Locale Provider | Collate | Ctype | ICU Locale | ICU Rules | Access privileges
-------------------------+-------+----------+-----------------+-------------+-------------+------------+-----------+-------------------
banco_postgresql_e_psql | marta | UTF8 | libc | en_US.UTF-8 | en_US.UTF-8 | | |
(1 row)È una tabella larga: della prima colonna, Name, ti basta il nome.
\x auto: quando la riga non ci sta
Una segnalazione del personale è una frase lunga. In una tabella normale, la riga esce larga quanto la frase e il terminale la spezza. Con \x auto, psql la mette in verticale, una colonna per riga:
banco_postgresql_e_psql=# SELECT * FROM segnalazioni WHERE id = 6;
id | stazione_id | badge | quando | testo
----+-------------+-------+---------------------+--------------------------------------------------------------------------------------------------------------------------------
6 | 2 | B-06 | 2026-11-18 10:30:00 | Sostituita la lampada rossa del semaforo in uscita da Via Variabile verso Largo Lista. Prova fatta con il T28, tutto regolare.
(1 row)
banco_postgresql_e_psql=# \x auto
Expanded display is used automatically.
banco_postgresql_e_psql=# SELECT * FROM segnalazioni WHERE id = 6;
-[ RECORD 1 ]-------------------------------------------------------------------------------------------------------------------------------
id | 6
stazione_id | 2
badge | B-06
quando | 2026-11-18 10:30:00
testo | Sostituita la lampada rossa del semaforo in uscita da Via Variabile verso Largo Lista. Prova fatta con il T28, tutto regolare.Accendilo una volta e psql decide da solo, query per query: righe strette in tabella, righe larghe in verticale.
Senza entrare: -c e -f
Non devi sempre aprire psql e restarci. Due modi per fare una cosa sola e tornare al terminale:
psql -d banco_postgresql_e_psql -c "SELECT count(*) FROM turni;" count
-------
14
(1 row)-c (command) fa un comando e esce. -f (file) fa tutti i comandi di un file:
psql -d banco_postgresql_e_psql -f menta.sqlSET
DROP TABLE
CREATE TABLE
CREATE TABLE
CREATE TABLE
CREATE TABLE
CREATE TABLE
INSERT 0 6
INSERT 0 11
INSERT 0 8
INSERT 0 14
INSERT 0 8Un file .sql è solo un file di testo con comandi SQL, uno dopo l'altro. psql -f li legge e li esegue in ordine, e per ognuno stampa una riga: cosa ha fatto (CREATE TABLE) e, per gli inserimenti, quante righe (INSERT 0 6: sei righe nuove).
Il file menta.sql dell'esercizio comincia con DROP TABLE IF EXISTS: cancella le sue tabelle e le rifà. Per questo si può ricaricare quante volte vuoi, e ogni volta i dati tornano com'erano. È il trucco per rimettere a posto un database rovinato (lo fai nella missione 5).
L'ordine giusto, quando parti da zero: prima il database (createdb), poi il file (psql -d … -f …). Se carichi il file senza il database, psql risponde che il database non esiste.
VS Code: l'estensione PostgreSQL
psql non è l'unico modo. Con l'estensione PostgreSQL (quella di Microsoft) VS Code diventa un secondo client: vedi l'elenco di database e tabelle come un albero, e scrivi le query in un file.
- Nella barra a sinistra, apri Extensions, cerca «PostgreSQL» (di Microsoft) e premi Install. Su Windows con WSL: Install in WSL.
- Nella barra a sinistra compare l'icona di un elefante. Aprila e premi Add Connection.
- Compila i campi come in questa tabella:
| Campo | Cosa scrivi |
|---|---|
| Server name | localhost |
| Authentication type | Password |
| User name | Il tuo utente: lo scopri da psql con SELECT current_user; |
| Password | Quella che hai scelto: vedi sotto |
| Database name | Per esempio banco_postgresql_e_psql |
| Connection name | Come vuoi, per esempio banco |
- Tasto destro sul database, poi New Query: scrivi l'SQL e lo lanci.
C'è una differenza che frega tutti: psql entra senza password, VS Code no. psql parla con il server attraverso il socket e il server si fida di te, perché sei l'utente del computer. VS Code passa dalla rete (localhost), e lì la password serve. Una volta sola, da psql:
ALTER USER il_tuo_utente PASSWORD 'scegli_una_password';(Sostituisci il_tuo_utente con il risultato di SELECT current_user;. È un database sul tuo computer, per imparare: una password semplice va bene.)
PGHOST e il socket
psql non sa dov'è il server: lo cerca nel posto dove di solito sta il suo socket. Su Mac, /tmp. Su WSL, /var/run/postgresql. Se il programma cerca in una cartella e il server ha messo il socket in un'altra, non si trovano. L'errore è questo:
psql: error: connection to server on socket "/var/run/postgresql/.s.PGSQL.5432" failed: No such file or directory
Is the server running locally and accepting connections on that socket?(Preso su Mac, dopo aver chiesto a psql la cartella di WSL: il messaggio è lo stesso a parti invertite.)
Leggi il percorso tra le virgolette: è la cartella dove psql sta cercando. Per vedere dove sei collegato quando va bene, dentro psql:
banco_postgresql_e_psql=# \conninfo
You are connected to database "banco_postgresql_e_psql" as user "marta" via socket in "/tmp" at port "5432".Per dire a psql dove cercare c'è una variabile d'ambiente, PGHOST (la stessa idea di PATH: un'etichetta che i programmi leggono). La puoi cambiare per questo terminale:
export PGHOST=/tmpMac: /tmp. WSL: /var/run/postgresql. Per non riscriverla a ogni terminale la metti nel file che il terminale legge all'avvio (~/.zshrc su Mac, ~/.bashrc su WSL):
echo 'export PGHOST=/tmp' >> ~/.zshrcRicorda
- PostgreSQL è un server: resta acceso.
psqlè il client: ci parli tu. - Mac:
brew services start postgresql@16(una volta). WSL:sudo service postgresql start(ogni volta).pg_isreadydice se risponde. createdb nomecrea,dropdb nomecancella senza cestino. Silenzio vuol dire fatto.psql -d nomeentra. Il promptnome=#dice dove sei;nome-#vuol dire che manca il punto e virgola.- Con la barra è
psql(\dt,\d,\x auto,\q), senza è SQL e finisce con;. -cfa un comando,-fesegue un file:createdbprima, poipsql -d … -f ….- Se
psqlnon trova il server, leggi il percorso del socket nell'errore: Mac/tmp, WSL/var/run/postgresql, ePGHOSTlo cambia.