Vai al contenuto
code-to-code

Apro l'indice…

↑ ↓ per scegliere, Invio per aprire, Esc per chiudere

Il banco di lavoro5. PostgreSQL e psqlp. 110

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 accendiQuanto dura
Macbrew services start postgresql@16Una volta sola: ripartirà da solo anche dopo aver riacceso il computer
WSLsudo service postgresql startOgni volta che apri un terminale Ubuntu nuovo

Come sai se è acceso? Lo chiedi a lui:

Terminale
pg_isready
/tmp:5432 - accepting connections

accepting 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):

Terminale
createdb banco_postgresql_e_psql
dropdb banco_postgresql_e_psql

Se 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:

Terminale
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 ;.

ComandoCosa fa
\lElenca i database del server (\l banco* solo quelli che cominciano per «banco»)
\c nomeSi sposta in un altro database, senza uscire
\dtElenca le tabelle del database in cui sei
\d tabellaMostra le colonne di una tabella, le chiavi e i collegamenti
\x autoSe una riga è troppo larga per lo schermo, la mostra in verticale
\conninfoDice dove sei collegato: database, utente, socket
\?L'elenco di tutti i comandi con la barra
\qEsce

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:

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:

Terminale
psql -d banco_postgresql_e_psql -f menta.sql
SET
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 8

Un 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.

  1. Nella barra a sinistra, apri Extensions, cerca «PostgreSQL» (di Microsoft) e premi Install. Su Windows con WSL: Install in WSL.
  2. Nella barra a sinistra compare l'icona di un elefante. Aprila e premi Add Connection.
  3. Compila i campi come in questa tabella:
CampoCosa scrivi
Server namelocalhost
Authentication typePassword
User nameIl tuo utente: lo scopri da psql con SELECT current_user;
PasswordQuella che hai scelto: vedi sotto
Database namePer esempio banco_postgresql_e_psql
Connection nameCome vuoi, per esempio banco
  1. 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:

SQL
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:

Terminale
export PGHOST=/tmp

Mac: /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):

Terminale
echo 'export PGHOST=/tmp' >> ~/.zshrc

Ricorda

  • 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_isready dice se risponde.
  • createdb nome crea, dropdb nome cancella senza cestino. Silenzio vuol dire fatto.
  • psql -d nome entra. Il prompt nome=# 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 ;.
  • -c fa un comando, -f esegue un file: createdb prima, poi psql -d … -f ….
  • Se psql non trova il server, leggi il percorso del socket nell'errore: Mac /tmp, WSL /var/run/postgresql, e PGHOST lo cambia.