psycopg, le soluzioni
Il ragionamento, il codice, le trappole
Per ogni esercizio, sempre lo stesso ordine: in italiano → il codice → le trappole. Per i più difficili, anche il passo per passo.
La tua soluzione è diversa ma i test sono verdi? Probabilmente va bene: spesso ci sono più strade giuste. Confronta il ragionamento, non le singole parole. E leggi comunque le trappole: alcune passano qualche test e si rompono su un altro.
Le soluzioni complete
La stessa cartella, con il codice al posto di pass. Aprila dopo averci provato: i test sono gli stessi.
1 · Il collega per badge
In italiano. Chiedo al database la riga del personale con quel badge. Il badge va in un buco, e il valore in una tupla di un elemento. Ritiro una riga: un dizionario, oppure None se il badge non c'è.
def persona_per_badge(badge: str) -> dict | None:
with connetti() as conn:
return conn.execute("SELECT * FROM personale WHERE badge = %s", (badge,)).fetchone()Il return dentro il with va bene: all'uscita il blocco fa comunque il commit e chiude la connessione.
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
(badge) al posto di (badge,) | TypeError: query parameters should be a sequence or a mapping, got str | tutti e quattro |
.fetchall() al posto di .fetchone() | Torna una lista di una riga: persona["stazione_id"] dà TypeError: list indices must be integers or slices, not str, e per il badge che non c'è torna [], non None | tutti e quattro |
WHERE badge = '%s', con gli apici | psycopg.errors.IndeterminateDatatype: could not determine data type of parameter $1: tra apici il buco non è più un buco | tutti e quattro |
return conn.execute(...) senza fetchone() | Torna il vassoio, non la riga: nessun confronto torna | tutti e quattro |
La prima è la più comune. La virgola è piccola, e il messaggio parla di «sequenza» e «str»: l'unica cosa che hai passato è la stringa.
2 · Le segnalazioni aperte di un treno
In italiano. Voglio le segnalazioni di quel treno che non sono risolte, in ordine di id. Sono tante, quindi fetchall(): se non ce n'è nessuna, è la lista vuota, senza errori. Il numero del treno va nel buco, risolta = false si scrive direttamente nella query: non cambia mai.
def segnalazioni_aperte(treno_id: int) -> list[dict]:
with connetti() as conn:
query = "SELECT * FROM segnalazioni WHERE treno_id = %s AND risolta = false ORDER BY id"
return conn.execute(query, (treno_id,)).fetchall()Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
.fetchone() al posto di .fetchall() | Torna una riga (un dizionario) invece di una lista, e None invece di [] quando non ce ne sono | tutti e quattro |
Senza AND risolta = false | Le segnalazioni già risolte ricompaiono: per il M12 ce ne sono tre invece di due | test_le_segnalazioni_aperte_del_m12, test_le_risolte_non_ci_sono |
AND risolta = %s con un solo valore | psycopg.ProgrammingError: the query has 2 placeholders but 1 parameters were passed: un buco in più, un valore in meno | tutti e quattro |
La seconda è la più insidiosa: niente errori, e la lista sembra a posto. Il test dei treni con solo segnalazioni risolte (il M16) la prende subito.
3 · I treni da mandare in officina
In italiano. Voglio codice e km dei treni con km uguali o oltre la soglia, dal più stanco. La soglia è un valore, quindi un buco: non la scrivo nella query. «Almeno» vuol dire >=: il M24 ha 5000 km e con soglia 5000 ci deve essere.
def treni_da_revisionare(soglia: int) -> list[dict]:
with connetti() as conn:
query = "SELECT codice, km FROM treni WHERE km >= %s ORDER BY km DESC"
return conn.execute(query, (soglia,)).fetchall()Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
km > %s | Il M24, con 5000 km giusti, resta a terra: l'errore di un'unità sul confine | test_i_treni_da_mandare_in_officina_dal_piu_stanco, test_il_confine_e_compreso |
km >= 5000 scritto nella query, e execute(query) senza valori | Con soglia 5000 funziona. Con qualunque altra soglia dà sempre la stessa lista | test_nessun_treno_sopra_la_soglia_da_lista_vuota, test_la_soglia_arriva_dal_parametro |
ORDER BY km senza DESC | Dal meno stanco al più stanco: l'ordine è rovesciato | test_i_treni_da_mandare_in_officina_dal_piu_stanco, test_la_soglia_arriva_dal_parametro |
La seconda è il tipo di errore che nessun errore mostra: una funzione con un parametro che non usa. I test che cambiano i dati con una scrittura diretta (sql(…)) e poi richiamano la funzione servono proprio a questo.
4 · Una segnalazione nuova
In italiano. Scrivo una riga con quattro valori, e chiedo al database di restituirmela com'è: con l'id, e con risolta a false, che l'ho lasciata decidere a lui. Il with fa il commit all'uscita: senza, la riga non resterebbe.
def nuova_segnalazione(treno_id: int, autore_id: int, descrizione: str, gravita: int) -> dict:
with connetti() as conn:
query = "INSERT INTO segnalazioni (treno_id, autore_id, descrizione, gravita) VALUES (%s, %s, %s, %s) RETURNING *"
return conn.execute(query, (treno_id, autore_id, descrizione, gravita)).fetchone()Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Niente RETURNING *, e poi fetchone() | psycopg.ProgrammingError: the last operation didn't produce records (command status: INSERT 0 1) | test_la_segnalazione_nuova_torna_con_il_suo_id, test_la_segnalazione_nuova_e_nel_database, test_una_descrizione_con_l_apostrofo |
conn = connetti() senza with | La funzione risponde con la riga giusta, id 10 compreso, ma nel database non c'è niente: nessun commit, e la riga sparisce | test_la_segnalazione_nuova_e_nel_database |
| Una f-string con i valori dentro | Funziona finché la descrizione non ha un apostrofo. Con Sedile dell'ultimo vagone strappato: psycopg.errors.SyntaxError: syntax error at or near "ultimo" | test_una_descrizione_con_l_apostrofo |
La seconda è la trappola del capitolo: risponde bene, e non salva. Un test che guarda solo la risposta è verde, e il bug esce in produzione. Per questo ci sono due test: uno guarda cosa risponde, l'altro guarda cosa c'è nel database.
5 · Chiudere una segnalazione
In italiano. Metto risolta = true alla riga con quell'id e chiedo la riga indietro con RETURNING *. Se nessuna riga ha quell'id, non torna niente: fetchone() dà None, ed è esattamente la risposta richiesta. Non serve nessun if.
def chiudi_segnalazione(segnalazione_id: int) -> dict | None:
with connetti() as conn:
query = "UPDATE segnalazioni SET risolta = true WHERE id = %s RETURNING *"
return conn.execute(query, (segnalazione_id,)).fetchone()Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
UPDATE senza WHERE | Tutte le segnalazioni risultano risolte. Per l'id 3 torna comunque una riga (la prima), per l'id 99 anche | test_chiude_una_segnalazione_aperta, test_una_segnalazione_che_non_c_e_da_none, test_le_altre_segnalazioni_restano_aperte |
conn = connetti() senza with | Torna la riga giusta, ma nel database la segnalazione è ancora aperta | test_la_chiusura_e_nel_database, test_le_altre_segnalazioni_restano_aperte |
.fetchall() al posto di .fetchone() | Torna una lista: [{…}] invece del dizionario, e [] invece di None | test_chiude_una_segnalazione_aperta, test_una_segnalazione_che_non_c_e_da_none |
La prima è quella che nei giornali diventa una notizia. Un UPDATE senza WHERE non dà nessun errore: fa quello che gli hai detto, su tutte le righe.
6 · Ritirare un treno
In italiano.
- Apro una connessione, un solo
with. - Metto il treno fuori servizio, e mi faccio restituire il suo id con
RETURNING id. - Se non è tornato niente (
None), quel codice non esiste: restituiscoNone. Non ho scritto niente da annullare. - Altrimenti scrivo la segnalazione con l'id del treno, e la restituisco.
- Se la
INSERTfallisce, l'errore esce dalwith: rollback, e anche il treno torna com'era.
def ritira_treno(codice: str, autore_id: int, gravita: int, descrizione: str) -> dict | None:
with connetti() as conn:
treno = conn.execute("UPDATE treni SET in_servizio = false WHERE codice = %s RETURNING id", (codice,)).fetchone()
if treno is None:
return None
query = "INSERT INTO segnalazioni (treno_id, autore_id, descrizione, gravita) VALUES (%s, %s, %s, %s) RETURNING *"
return conn.execute(query, (treno["id"], autore_id, descrizione, gravita)).fetchone()Il disegno.
Passo per passo, con ritira_treno("M10", 2, 7, "…"): la gravità 7 non è accettata dal database (le gravità vanno da 1 a 3).
| Passo | Cosa succede | Stato provvisorio |
|---|---|---|
| 1 | UPDATE … RETURNING id: il M10 è fuori servizio, torna {'id': 1} | M10 fuori servizio |
| 2 | treno non è None: si va avanti | M10 fuori servizio |
| 3 | INSERT con gravità 7: CheckViolation | — |
| 4 | L'errore esce dal blocco: il with fa il rollback | M10 di nuovo in servizio |
| 5 | L'errore arriva a chi ha chiamato la funzione | niente è stato salvato |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
Due with separati: uno per l'UPDATE, uno per l'INSERT | Il primo with finisce bene: commit. Quando il secondo salta, il treno è già fuori servizio per sempre | test_se_la_seconda_scrittura_fallisce_la_prima_si_annulla |
conn = connetti() senza with | Le due scritture ci sono nella risposta, ma nel database non c'è niente | test_ritira_treno_scrive_nel_database |
Niente if treno is None | Con il codice M99: TypeError: 'NoneType' object is not subscriptable su treno["id"] | test_un_codice_che_non_c_e_da_none_e_non_scrive_niente |
La prima è quella da ricordare: un with è una transazione. Ciò che deve riuscire insieme o fallire insieme sta nello stesso with. Il test che la prende deve fare fallire davvero la seconda scrittura (qui con una gravità impossibile) e poi guardare nel database.
7 · L'indirizzo del database, senza la password
In italiano. Leggo la password: se non c'è mi fermo con un errore che dice quale variabile manca. Gli altri pezzi hanno un valore di riserva, e li leggo con get. Alla fine metto tutto insieme in una f-string: qui è giusta, perché non è una query.
def stringa_di_connessione() -> str:
password = os.environ.get("PGPASSWORD")
if password is None:
raise RuntimeError("Manca la variabile PGPASSWORD: la password non si scrive nel codice")
utente = os.environ.get("PGUSER", "menta")
host = os.environ.get("PGHOST", "localhost")
porta = os.environ.get("PGPORT", "5432")
database = os.environ.get("MENTA_DB", "db_psycopg")
return f"postgresql://{utente}:{password}@{host}:{porta}/{database}"Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
password = "menta123" scritta nel codice | Il test con s3greta non torna, e senza variabile non si ferma nessuno. Ma soprattutto: la password è nel file, e il file finisce su GitHub | tutti e quattro |
os.environ["PGUSER"], ["PGHOST"]… senza il valore di riserva | Senza la variabile: KeyError: 'PGUSER'. I valori di riserva non servivano proprio a questo? | test_con_la_sola_password_valgono_i_valori_di_riserva, test_la_password_cambia_con_la_variabile |
os.environ["PGPASSWORD"] | Senza password si ferma, sì, ma con KeyError: 'PGPASSWORD', non con il RuntimeError che spiega cosa fare | test_senza_password_si_ferma_e_nomina_la_variabile |
os.environ["X"] si ferma se manca, os.environ.get("X") risponde None: come i dizionari, di cui è un parente stretto.
8 · Cercare per nome, senza farsi fregare
In italiano. La f-string costruisce un testo di SQL con il nome dentro: se il nome contiene un apostrofo o un pezzo di SQL, il database lo legge come SQL. Al suo posto, un buco senza apici e la tupla di un elemento. Il valore viaggia a parte, e resta un nome qualunque cosa contenga.
def persone_per_nome(nome: str) -> list[dict]:
with connetti() as conn:
query = "SELECT * FROM personale WHERE nome = %s ORDER BY id"
return conn.execute(query, (nome,)).fetchall()Cambia una riga e la chiamata a execute: il resto, il with e il fetchall(), c'era già.
Passo per passo, con tre nomi:
| Nome | Con la f-string (lo scheletro) | Con %s |
|---|---|---|
Lucia Ferri | la query va, una persona | una persona |
Gino D'Alessio | SyntaxError | B-11 |
x' OR '1'='1 | la query diventa … = 'x' OR '1'='1': tutte e 12 le persone | lista vuota |
x'; DELETE FROM segnalazioni; -- | il DELETE viene eseguito: le 9 segnalazioni spariscono | lista vuota, segnalazioni intatte |
Le trappole.
| Il codice sbagliato | Cosa succede | Il test rosso |
|---|---|---|
| Lasciare la f-string | Tutto come nello scheletro: l'apostrofo rompe la query, Bobby Tables trova tutti, il DELETE cancella | test_si_trova_anche_chi_ha_l_apostrofo, test_bobby_tables_non_trova_nessuno, test_un_nome_con_un_comando_dentro_non_cancella_niente |
nome = '%s', con gli apici | psycopg.errors.IndeterminateDatatype: could not determine data type of parameter $1: tra apici il buco non è più un buco | tutti e cinque |
Con la f-string, il test dei nomi semplici (Lucia Ferri) è verde. Per questo è il test più pericoloso da scrivere da solo: la funzione sembra giusta finché non arriva un valore strano. I test dell'apostrofo e di Bobby Tables ci sono apposta.
Tre errori che non fanno diventare rosso niente
Provati davvero contro i test dello zip: restano verdi, e il codice è comunque sbagliato.
conn.commit()scritto a mano invece delwith. Funziona, e salva. Ma devi ricordarti di farlo dopo ogni scrittura, e di chiudere la connessione, e non c'è il rollback automatico se qualcosa va storto prima. In questo libro si usa sempre ilwith.- Una f-string con i numeri.
f"... WHERE treno_id = {treno_id}"funziona, perché un numero non ha apostrofi. Ma è la stessa abitudine che con un testo ti fa male: oggi ètreno_id, domani sarànome. Con%snon devi più chiederti «questo valore è pericoloso?». - Niente
ORDER BYnelle segnalazioni aperte. Oggi PostgreSQL le restituisce nell'ordine in cui le ha scritte, e il test è verde. Ma non lo promette: se un giorno una riga viene modificata o la tabella viene riorganizzata, l'ordine può cambiare. Se un ordine ti serve, chiedilo.