PostgreSQL e psql, esercizi spiegati
Cinque esempi, un comando alla volta
- 20 minuti di lettura
Cinque esempi, dal più semplice. Ognuno ha lo stesso ritmo:
- Prevedi: leggi i comandi e scrivi su un foglio cosa risponde il terminale. Prima di aprire la risposta.
- In italiano: cosa succede, a parole.
- Passo per passo: chi fa cosa, riga per riga.
- Cosa portiamo a casa: la cosa da ricordare.
Puoi rifarli tutti sul tuo computer: i comandi sono quelli veri, e le risposte sono state copiate da un terminale vero (con l'utente marta, che nel tuo computer sarà il tuo).
A · Il server è acceso?
Hai aperto un terminale. Prima di fare qualsiasi cosa, una domanda sola.
pg_isreadyPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
/tmp:5432 - accepting connections/tmpè la cartella dovepg_isreadycerca il socket. Su WSL vedresti/var/run/postgresql.5432è la porta, quella standard di PostgreSQL.accepting connections: acceso e pronto.
E se pg_isready sta cercando nella cartella sbagliata? Lo costringiamo, solo per vedere (PGHOST vale solo per questo comando):
PGHOST=/var/run/postgresql pg_isreadyPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
/var/run/postgresql:5432 - no responseIl server su questo Mac è acceso, ma pg_isready bussa a una porta dove non c'è nessuno: no response.
Passo per passo.
| Cosa guardo | Cosa vuol dire |
|---|---|
accepting connections | Acceso: puoi continuare |
no response | Spento, oppure cerca nella cartella sbagliata |
| Il percorso prima dei due punti | È la cartella dove sta cercando: confrontala con quella giusta (Mac /tmp, WSL /var/run/postgresql) |
Il disegno.
Cosa portiamo a casa. no response non vuol dire sempre «spento». Prima leggi il percorso: se è quello giusto, accendi il server; se no, il problema è PGHOST.
B · Un database nuovo, e l'archivio dentro
Ernesto Pozzi ti ha dato menta.sql, l'archivio del deposito. Lo vuoi in un database tuo.
createdb banco_postgresql_e_psql
psql -d banco_postgresql_e_psql -f menta.sqlPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
createdb non scrive niente. psql -f scrive una riga per ogni comando del file:
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 8In italiano.
- Creo un database vuoto con un nome.
- Dico a
psqldi entrare in quel database e di eseguire, in ordine, i comandi del file.
Passo per passo.
| Riga | Cosa è successo |
|---|---|
SET | Un'impostazione all'inizio del file (toglie gli avvisi inutili) |
DROP TABLE | Ha cancellato le tabelle vecchie, se c'erano (qui non c'erano) |
CREATE TABLE (cinque volte) | Ha creato le cinque tabelle: stazioni, personale, treni, turni, segnalazioni |
INSERT 0 6 | Sei righe nuove in stazioni |
INSERT 0 11 | Undici righe nuove in personale |
INSERT 0 8 | Otto righe nuove in treni |
INSERT 0 14 | Quattordici righe nuove in turni |
INSERT 0 8 | Otto righe nuove in segnalazioni |
Quel 0 dopo INSERT è una vecchia abitudine di PostgreSQL: ignoralo, il numero che conta è il secondo.
Cosa portiamo a casa. Prima il database, poi il file. E le righe INSERT sono il tuo conto: se non tornano con quello che ti aspetti, qualcosa nel file è diverso.
C · Entro e mi guardo intorno
Il database è pronto. Entra e guarda come è fatta la tabella personale.
psql -d banco_postgresql_e_psqlDentro, scrivi \d personale e poi \q.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
banco_postgresql_e_psql=# \d personale
Table "public.personale"
Column | Type | Collation | Nullable | Default
------------+------+-----------+----------+---------
badge | text | | not null |
nome | text | | not null |
ruolo | text | | not null |
telefono | text | | |
assunto_il | date | | not null |
Indexes:
"personale_pkey" PRIMARY KEY, btree (badge)
Referenced by:
TABLE "segnalazioni" CONSTRAINT "segnalazioni_badge_fkey" FOREIGN KEY (badge) REFERENCES personale(badge)
TABLE "turni" CONSTRAINT "turni_badge_fkey" FOREIGN KEY (badge) REFERENCES personale(badge)
banco_postgresql_e_psql=# \qIn italiano. \d con il nome di una tabella dice com'è fatta: una riga per colonna, e sotto le regole.
Passo per passo. Leggi la tabella in alto, colonna per colonna.
| Colonna della risposta | Cosa dice |
|---|---|
Column | Il nome della colonna: badge, nome, ruolo, telefono, assunto_il |
Type | Cosa ci sta dentro: text (testo), date (una data) |
Nullable | Se è vuoto, la colonna può restare vuota. Se c'è scritto not null, deve avere un valore. Qui solo telefono può mancare |
Default | Il valore che prende da solo se non lo scrivi. In personale non ce n'è |
Le righe sotto dicono: Indexes come si trova una riga (la chiave primaria: badge, uguale per nessuno), Referenced by quali altre tabelle puntano a questa. Cosa sono le chiavi lo spiega SQL: le relazioni; qui basta saperle trovare.
Cosa portiamo a casa. \dt per sapere quali tabelle ci sono, \d nome per sapere com'è fatta una. Non serve nessuna query.
D · Una riga troppo larga
Le segnalazioni sono frasi lunghe. Guarda cosa succede con la numero 6, prima e dopo \x auto.
SELECT * FROM segnalazioni WHERE id = 6;
\x auto
SELECT * FROM segnalazioni WHERE id = 6;Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
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.In italiano. La stessa domanda, due modi di vedere la risposta. Nella prima la tabella è tanto larga quanto la frase, e il terminale la spezza. Nella seconda ogni colonna ha la sua riga: si legge dall'alto in basso.
Passo per passo.
| Riga | Cosa è successo |
|---|---|
\x auto | psql risponde Expanded display is used automatically.: da qui in poi sceglie lui |
-[ RECORD 1 ]--- | Il segno del formato verticale: «questa è la riga numero 1» |
testo e le altre righe | Ogni colonna ha il suo nome a sinistra e il suo valore a destra |
Il comando non ha il punto e virgola: comincia con la barra, è di psql, non di SQL.
Cosa portiamo a casa. Una tabella che non si legge: prova \x auto. La risposta è la stessa, cambia solo come è disegnata.
E · Ho sbagliato: cosa mi dice
Quattro piccoli errori, gli stessi in cui inciampi tutti i giorni. Ogni comando fallisce, e ogni errore dice cosa è andato storto.
psql
dropdb banco_postgresql_e_psql_bozza
createdb banco_postgresql_e_psql
psql -d banco_postgresql_e_psql -f menta.sqPrevedi Scrivi su un foglio cosa ti aspetti, poi apri.
psql: error: connection to server on socket "/tmp/.s.PGSQL.5432" failed: FATAL: database "marta" does not exist
dropdb: error: database removal failed: ERROR: database "banco_postgresql_e_psql_bozza" does not exist
createdb: error: database creation failed: ERROR: database "banco_postgresql_e_psql" already exists
psql: error: menta.sq: No such file or directory(Il primo: nel tuo computer, al posto di marta leggerai il tuo utente.)
In italiano e passo per passo.
| Il comando | Cosa leggi | Cosa è successo |
|---|---|---|
psql | database "marta" does not exist | Senza -d, psql prova ad entrare in un database con il tuo nome utente. Non c'è. Scrivi psql -d nome |
dropdb …_bozza | database "…_bozza" does not exist | Il database non c'è: già cancellato, o nome sbagliato. psql -l ti mostra quelli veri |
createdb … | already exists | Il database c'è già: non crearlo, entraci. Per ripartire da zero prima dropdb |
psql … -f menta.sq | menta.sq: No such file or directory | Il file non c'è, o non sei nella cartella giusta (o hai scritto male il nome). Controlla con ls |
Tutti e quattro sono errori tuoi, non del server, e tutti e quattro dicono nella frase cosa manca. Il segreto è leggere la frase: dopo FATAL: o ERROR: c'è il motivo.
Cosa portiamo a casa. Il messaggio di PostgreSQL è chiaro: legge l'ultima parte, quella dopo i due punti. Riscrivere lo stesso comando uguale non serve.