Scrivere
Creare tabelle, aggiungere, cambiare e togliere righe
- 14 minuti di lettura
Al deposito è arrivato un tram nuovo, il T33. Ivo Brambati, il manutentore, vuole metterlo nell'elenco dei treni. Fin qui hai solo letto il database. Ora lo cambi:
INSERT INTO treni (codice, tipo, vagoni, in_servizio_dal)
VALUES ('T33', 'tram', 3, '2026-11-20');INSERT 0 1PostgreSQL non mostra righe: dice solo cosa ha fatto. INSERT 0 1 vuol dire «ho inserito una riga» (lo zero è un residuo storico che non conta più). Per vedere il risultato, rileggi:
SELECT codice, tipo, vagoni, in_servizio_dal, ultima_revisione
FROM treni
WHERE codice = 'T33'; codice | tipo | vagoni | in_servizio_dal | ultima_revisione
--------+------+--------+-----------------+------------------
T33 | tram | 3 | 2026-11-20 |
(1 row)La casella ultima_revisione è vuota: nessuno l'ha scritta, quindi è NULL. In questo capitolo impari i quattro comandi che scrivono, e le regole con cui una tabella si difende dai dati sbagliati. Per provarli serve il database della Linea Menta: se non l'hai ancora caricato, i comandi sono in Tabelle, tipi e psql.
Il disegno: quattro comandi, e uno è definitivo
CREATE TABLE una tabella nuova, vuota
(nessuna riga) ─▶ la tabella esiste
INSERT una riga in più
M14 M12 T28 ... ─▶ M14 M12 T28 ... T33
UPDATE la stessa riga, un valore diverso
M20 | (vuoto) ─▶ M20 | 2026-11-18
DELETE una riga in meno
M14 M12 T28 ... T33 ─▶ M14 M12 T28 ...In psql ogni comando è definitivo: non c'è «annulla» e non c'è un cestino. Quello che cancelli è cancellato, quello che cambi è cambiato. Per questo la regola d'oro di tutto il capitolo è una sola: prima guarda, poi scrivi. Una SELECT con lo stesso WHERE, poi il comando.
Se hai già visto come una lista di dizionari si cambia in Python (l'append, l'assegnazione, il remove), è la stessa idea:
| In Python | In SQL |
|---|---|
treni.append(nuovo) | INSERT INTO treni … |
treno["vagoni"] = 3 | UPDATE treni SET vagoni = 3 WHERE … |
treni.remove(treno) | DELETE FROM treni WHERE … |
La differenza: in Python lavori su un elemento che hai in mano. In SQL dici quali righe con un WHERE, e il comando le cambia tutte insieme. Se il WHERE sbaglia, sbagliano tutte.
CREATE TABLE: la tabella e le sue regole
Una tabella nuova si crea una volta sola. Ivo vuole un registro dei guasti dei treni:
DROP TABLE IF EXISTS guasti;
CREATE TABLE guasti (
id SERIAL PRIMARY KEY,
treno_id INTEGER NOT NULL REFERENCES treni(id),
descrizione TEXT NOT NULL,
gravita INTEGER NOT NULL DEFAULT 1 CHECK (gravita BETWEEN 1 AND 3),
segnalato_il DATE NOT NULL DEFAULT CURRENT_DATE
);Si legge una riga per colonna: nome, tipo (quelli del capitolo Tabelle, tipi e psql: INTEGER, TEXT, DATE, NUMERIC(5, 2), BOOLEAN, e SERIAL per un numero che si dà da solo), poi le regole della colonna, nell'ordine che vuoi.
DROP TABLE IF EXISTS guasti; in testa serve per poter rilanciare il file: se la tabella c'è, la butta (con tutte le sue righe!); se non c'è, non fa niente. Senza, il secondo lancio dice relation "guasti" already exists.
Le regole si chiamano vincoli. Ognuno è una promessa che PostgreSQL mantiene per te, su ogni riga che entra, da qualunque parte arrivi:
| Vincolo | Promette | Cosa leggi se lo violi |
|---|---|---|
PRIMARY KEY | la colonna è unica e mai vuota: serve a chiamare una riga per nome | duplicate key value violates unique constraint |
NOT NULL | la casella non può restare vuota | null value in column "codice" … violates not-null constraint |
UNIQUE | nessun doppione in quella colonna | duplicate key value violates unique constraint |
CHECK (condizione) | la riga rispetta la condizione | new row for relation "tariffe" violates check constraint |
REFERENCES altra(id) | il valore è l'id di una riga che esiste davvero | violates foreign key constraint |
DEFAULT valore | non è un divieto: se non scrivi niente, ci pensa lui | (nessun errore) |
Li vedi lavorare nella Linea Menta, tutti con un comando sbagliato. Un treno senza codice (codice è NOT NULL):
INSERT INTO treni (tipo, vagoni, in_servizio_dal) VALUES ('tram', 3, '2026-11-20');ERROR: null value in column "codice" of relation "treni" violates not-null constraint
DETAIL: Failing row contains (9, null, tram, 3, 2026-11-20, null).Un codice che c'è già (UNIQUE), un biglietto che costa zero (CHECK (prezzo > 0)), una corsa con un treno che non esiste (REFERENCES):
ERROR: duplicate key value violates unique constraint "treni_codice_key"
DETAIL: Key (codice)=(T28) already exists.ERROR: new row for relation "tariffe" violates check constraint "tariffe_prezzo_check"
DETAIL: Failing row contains (5, gratis, 0.00).ERROR: insert or update on table "corse" violates foreign key constraint "corse_treno_id_fkey"
DETAIL: Key (treno_id)=(99) is not present in table "treni".Un errore qui non è un guaio: è la tabella che fa il suo mestiere. Il guaio è l'opposto, il vincolo dimenticato: una tabella senza CHECK accetta una gravità di 7 senza fiatare, e il dato sbagliato resta lì per mesi.
DEFAULT lavora in silenzio. Un guasto scritto senza gravità e senza data:
INSERT INTO guasti (treno_id, descrizione) VALUES (3, 'Porta che non si chiude');
SELECT * FROM guasti; id | treno_id | descrizione | gravita | segnalato_il
----+----------+-------------------------+---------+--------------
1 | 3 | Porta che non si chiude | 1 | 2026-11-19
(1 row)L'id l'ha dato SERIAL, la gravità è 1 per DEFAULT, la data è quella del giorno in cui lanci il comando (CURRENT_DATE).
Due vincoli possono guardare più colonne insieme, e allora si scrivono in fondo, dopo le colonne: UNIQUE (treno_id, fatta_il) («la coppia non si ripete») oppure CHECK (al >= dal) («la fine non viene prima dell'inizio»). Li usi nella pagina degli esercizi spiegati.
INSERT: aggiungere righe
INSERT INTO tabella (colonna1, colonna2, …)
VALUES (valore1, valore2, …);Tre regole.
1. Scrivi sempre l'elenco delle colonne. I valori vanno nello stesso ordine delle colonne: il primo valore nella prima colonna, il secondo nella seconda. Se i numeri non tornano, PostgreSQL lo dice:
ERROR: INSERT has more target columns than expressions
LINE 1: INSERT INTO treni (codice, tipo, vagoni, in_servizio_dal) VA...
^Se i numeri tornano ma il tipo no, anche:
ERROR: invalid input syntax for type integer: "tre"Se invece i numeri e i tipi tornano ma l'ordine è sbagliato, nessun errore: il codice finisce nel tipo e il tipo nel codice.
INSERT INTO treni (codice, tipo, vagoni, in_servizio_dal)
VALUES ('tram', 'T34', 3, '2026-11-21'); id | codice | tipo
----+--------+------
10 | T33 | tram
11 | tram | T34
(2 rows)Il treno 11 ha codice tram e tipo T34. Dopo un INSERT, rileggi sempre la riga.
2. Le colonne con un valore di partenza le lasci fuori. L'id (SERIAL) non si scrive mai: si dà da solo. Nemmeno le colonne con DEFAULT, se il valore giusto è quello. Una colonna che può essere vuota e che non scrivi resta NULL, come ultima_revisione del T33.
3. Tante righe, un comando. Dopo VALUES metti più parentesi separate da virgole:
INSERT INTO treni (codice, tipo, vagoni, in_servizio_dal)
VALUES ('T36', 'tram', 2, '2026-11-21'),
('T37', 'tram', 2, '2026-11-21');INSERT 0 2I testi vogliono gli apici singoli, e un apostrofo dentro si raddoppia: 'Sessant''anni'. Le date sono testi nel formato anno-mese-giorno.
UPDATE: cambiare righe che ci sono
UPDATE tabella
SET colonna = nuovo_valore
WHERE condizione;Il WHERE è quello che già conosci: dice quali righe. Il SET dice cosa mettere. Più colonne si separano con la virgola, e a destra dell'uguale puoi usare il valore di adesso: vagoni = vagoni + 1 vuol dire «quanti ne ha, più uno».
SELECT codice, vagoni FROM treni WHERE codice = 'T28';
UPDATE treni SET vagoni = vagoni + 1, ultima_revisione = '2026-11-19' WHERE codice = 'T28';
SELECT codice, vagoni, ultima_revisione FROM treni WHERE codice = 'T28'; codice | vagoni
--------+--------
T28 | 2
(1 row)
UPDATE 1
codice | vagoni | ultima_revisione
--------+--------+------------------
T28 | 3 | 2026-11-19
(1 row)UPDATE 1 è la tua prova: una riga cambiata. Leggi sempre quel numero. Se ti aspettavi una riga e leggi UPDATE 0, il WHERE non ha trovato niente (una lettera sbagliata, oppure = NULL al posto di IS NULL). Se leggi UPDATE 8, hai cambiato otto righe.
Il WHERE dimenticato
L'errore più caro di tutto il libro. Ivo vuole segnare la revisione del M20 e scrive:
UPDATE treni SET ultima_revisione = '2026-11-18';UPDATE 8Nessun errore, nessun avviso: PostgreSQL ha fatto quello che hai chiesto. Tutti e otto i treni risultano revisionati il 18 novembre, anche il T31 che non ha mai visto l'officina. Si vede da due cose: il numero (UPDATE 8 invece di UPDATE 1) e, se rileggi, la colonna tutta uguale.
Le difese sono due:
- Il
WHEREsi scrive per primo, prima delSET, o si controlla con unaSELECT:SELECT codice FROM treni WHERE codice = 'M20';Quante righe escono? Sono le righe che cambierà l'UPDATE. - Dopo, si guarda il numero:
UPDATE 1.
DELETE: togliere righe
DELETE FROM tabella
WHERE condizione;Il guanto di lana è stato registrato due volte (id 6 e id 10). Si cancella la copia, dopo averla guardata:
SELECT id, descrizione FROM oggetti_smarriti WHERE id = 10;
DELETE FROM oggetti_smarriti WHERE id = 10; id | descrizione
----+----------------
10 | Guanto di lana
(1 row)
DELETE 1Senza WHERE, DELETE svuota la tabella:
DELETE FROM oggetti_smarriti;DELETE 15Quindici righe perse in un colpo (le 16 di partenza, meno quella già cancellata). La tabella resta, vuota. Con DELETE valgono le stesse due difese dell'UPDATE.
C'è anche una difesa che non scrivi tu: la chiave esterna. La stazione di Vecchia Fiera ha ancora una persona assegnata, e PostgreSQL non la lascia sparire:
DELETE FROM stazioni WHERE id = 6;ERROR: update or delete on table "stazioni" violates foreign key constraint "personale_stazione_id_fkey" on table "personale"
DETAIL: Key (id)=(6) is still referenced from table "personale".Una riga a cui altre righe puntano non si cancella. Prima si tolgono (o si spostano) quelle che puntano, poi la riga.
RETURNING: farsi dire cosa è successo
INSERT, UPDATE e DELETE accettano RETURNING in fondo, con l'elenco delle colonne, e mostrano le righe toccate come una SELECT:
UPDATE treni SET vagoni = vagoni + 1 WHERE codice = 'T28' RETURNING codice, vagoni; codice | vagoni
--------+--------
T28 | 3
(1 row)Per un INSERT è il modo di scoprire l'id appena nato (RETURNING id). Per un DELETE è la lista di cosa se n'è andato:
DELETE FROM oggetti_smarriti WHERE trovato_il < '2026-07-01' RETURNING id, descrizione, trovato_il; id | descrizione | trovato_il
----+---------------+------------
14 | Valigia rossa | 2026-06-01
(1 row)
DELETE 1Rimettere a posto
Hai pasticciato i dati mentre provi? Ricarica il file del capitolo: butta le tabelle e le rifà da capo, con gli stessi dati.
psql -d sql_scrivere -f linea_menta.sqlI test dello zip non toccano il tuo database: ne creano uno di prova e lo cancellano.
Gli schemi che tornano
| Domanda | Come si scrive |
|---|---|
| «Metti una riga nuova» | INSERT INTO t (colonne) VALUES (valori) |
| «Metti queste tre righe» | un solo INSERT, più parentesi dopo VALUES |
| «Cambia quella riga» | UPDATE t SET c = v WHERE …, poi leggi UPDATE 1 |
| «Aumenta di uno» | SET c = c + 1 |
| «Togli quella riga» | DELETE FROM t WHERE …, poi leggi DELETE 1 |
| «Dimmi cosa hai toccato» | RETURNING colonne in fondo |
| «Voglio una tabella nuova» | DROP TABLE IF EXISTS, poi CREATE TABLE |
| «Questo dato non può essere sbagliato» | NOT NULL, UNIQUE, CHECK, REFERENCES |
| «Se non lo scrivo, vale…» | DEFAULT |
| «Ho rovinato tutto» | psql -d sql_scrivere -f linea_menta.sql |
Cosa viene dopo
Qui scrivi un comando alla volta, a mano. Più avanti sono i programmi a scriverli: un INSERT dentro Python lo vedi in psycopg. E quando devi decidere quali tabelle servono e quali colonne mettere dentro, il lavoro è di Disegnare un database.
Ricorda
- Quattro comandi:
CREATE TABLEcostruisce,INSERTaggiunge,UPDATEcambia,DELETEtoglie. Ogni comando è definitivo. - Un vincolo (
NOT NULL,UNIQUE,CHECK,REFERENCES) è una promessa della tabella: se un dato la rompe, l'errore è un aiuto. Quello pericoloso è il vincolo dimenticato.DEFAULTriempie da solo quello che non scrivi. INSERT: elenco delle colonne sempre, valori nello stesso ordine,idmai a mano. Dopo, rileggi.UPDATEeDELETEsenzaWHEREtoccano tutte le righe, senza avvisare. Prima unaSELECTcon lo stessoWHERE, poi il comando, poi il numero (UPDATE 1).- Una riga a cui altre righe puntano non si cancella (chiave esterna).
RETURNINGmostra le righe toccate.linea_menta.sqlrimette tutto a posto.