Vai al contenuto
code-to-code

Apro l'indice…

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

Il database nell'API5. La sessionep. 106

La sessione, esercizi spiegati

Cinque esempi, dal carrello alla rotta

  • 25 minuti di lettura

Cinque esempi, dal più semplice. I primi quattro sono file piccoli che scrivi tu e lanci dal terminale: così vedi la sessione al lavoro, senza il server in mezzo. L'ultimo è una rotta intera.

Ogni esempio ha lo stesso ritmo:

  1. Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
  2. In italiano: cosa fa il programma, a parole.
  3. Passo per passo: cosa succede, riga per riga.
  4. Cosa portiamo a casa: la cosa da ricordare.

Prima di cominciare

Ti serve lo zip della palestra, con il venv acceso e PostgreSQL acceso. Il README.md dello zip dice come si prepara. Per questi esempi serve il tuo database, con i dati della Linea Menta appena caricati:

Terminale
psql -d db_sessione -f linea_menta.sql

Ogni esempio è un file tuo dentro palestra/ (per esempio palestra/prova_a.py), che lanci dalla cartella dello zip:

Terminale
python palestra/prova_a.py

Sta in palestra/ perché lì ci sono database.py e modelli.py: Python li trova solo se sono nella stessa cartella del file che lanci.


A · La sessione in prestito

Ernesto Pozzi presta un carrello a chi lo chiede, e se lo fa restituire. Una funzione che fa lo stesso, con una sessione finta, e una rotta che la chiede con Depends:

Python
from fastapi import Depends, FastAPI
from fastapi.testclient import TestClient

app = FastAPI()


def sessione_finta():
    print("1. apro la sessione")
    yield "LA SESSIONE"
    print("3. chiudo la sessione")


@app.get("/prova")
def prova(db: str = Depends(sessione_finta)):
    print("2. la rotta usa", db)
    return {"ok": True}


client = TestClient(app)
print("--- prima richiesta")
client.get("/prova")
print("--- seconda richiesta")
client.get("/prova")
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
--- prima richiesta
1. apro la sessione
2. la rotta usa LA SESSIONE
3. chiudo la sessione
--- seconda richiesta
1. apro la sessione
2. la rotta usa LA SESSIONE
3. chiudo la sessione
  • La rotta non apre niente da sola: Depends(sessione_finta) dice a FastAPI di chiamare quella funzione prima.
  • FastAPI la fa partire e si ferma al yield: il valore dopo il yield ("LA SESSIONE") arriva alla rotta nel parametro db.
  • La rotta lavora (riga 2). Quando ha finito, FastAPI riprende la funzione da dopo il yield: ecco il «chiudo».
  • Con la seconda richiesta lo stesso giro ricomincia da capo: una sessione nuova per ogni richiesta.

In italiano. La rotta dice «per lavorare mi serve db», e non lo costruisce lei: lo chiede a sessione_finta. FastAPI la chiama, prende quello che passa per yield, lo consegna alla rotta, e quando la rotta ha finito torna a chiudere.

Il disegno.

inizio richiesta GET /prova passo sessione_finta: 1. apre passo yield consegna LA SESSIONE passo prova: 2. usa db passo sessione_finta: 3. chiude restituisci {"ok": True}richiesta GET /provasessione_finta: 1. apreyield consegna LA SESSIONEprova: 2. usa dbsessione_finta: 3. chiuderestituisci {"ok": True}
La sessione in prestito

Passo per passo.

Cosa succedeDoveCosa stampa
FastAPI chiama sessione_finta()prima della rotta1. apro la sessione
il yield consegna "LA SESSIONE"la funzione resta in pausaniente
la rotta gira con db uguale a "LA SESSIONE"dentro prova2. la rotta usa LA SESSIONE
la rotta restituisce, FastAPI riprende la funzionedopo il yield3. chiudo la sessione

get_db, in database.py, è questa stessa funzione con una sessione vera: with Session(engine) as db: apre, yield db presta, la fine del with chiude.

Cosa portiamo a casa. Depends(funzione) vuol dire «procuratelo tu»; yield vuol dire «presto e poi chiudo». Una sessione per richiesta, aperta prima della rotta e chiusa dopo.


B · Leggere con get, select e scalar

Lucia Ferri, capotreno, vuole sapere quali treni hanno fatto almeno 5000 chilometri: vanno in officina. Prima però controlla il M12, e prova a cercare un treno che non c'è.

Il file palestra/prova_b.py:

Python
from sqlalchemy import select
from sqlalchemy.orm import Session

from database import engine
from modelli import TrenoDB

engine.echo = False  # per questa prova niente SQL nel terminale

with Session(engine) as db:
    m12 = db.get(TrenoDB, 2)
    print(m12.codice, m12.km)
    print(db.get(TrenoDB, 99))

    domanda = select(TrenoDB).where(TrenoDB.km >= 5000).order_by(TrenoDB.km)
    print(domanda)
    for treno in db.scalars(domanda).all():
        print(treno.codice, treno.km)

    m20 = db.scalar(select(TrenoDB).where(TrenoDB.codice == "M20"))
    print(m20.codice, m20.vagoni)
    print(db.scalar(select(TrenoDB).where(TrenoDB.codice == "M99")))

    riga = db.execute(domanda).all()[0]
    print(type(riga).__name__, len(riga), riga[0].codice)
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
$ python palestra/prova_b.py
M12 4800
None
SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.km >= :km_1 ORDER BY treni.km
M24 5000
M14 5200
M18 7100
M20 6
None
Row 1 M24
  • db.get(TrenoDB, 2) dà il M12, con i suoi chilometri. Con il 99 dà None: nessun errore, una risposta vuota.
  • print(domanda) stampa il SQL che SQLAlchemy ha scritto. Il :km_1 è il buco: il valore 5000 viaggia a parte, come il %s di psycopg. La domanda non è ancora partita.
  • db.scalars(domanda).all() la esegue e dà una lista di oggetti: i tre treni, dal meno al più chilometrato (M24 ha 5000 giusti giusti, e >= lo include).
  • db.scalar(…) con il codice M20 dà un oggetto. Con il codice M99, che non c'è, dà None.
  • L'ultima riga: db.execute(domanda).all() non dà gli oggetti ma le righe (Row), ognuna con un solo elemento dentro. L'oggetto è riga[0].
m12 = TrenoDB(id=2, codice="M12", vagoni=4, km=4800, in_servizio=True, stazione_id=5) m20 = TrenoDB(id=6, codice="M20", vagoni=6, km=0, in_servizio=False, stazione_id=None)m12m20TrenoDBid2codice"M12"vagoni4km4800in_servizioTruestazione_id5TrenoDBid6codice"M20"vagoni6km0in_servizioFalsestazione_idNone
I due treni letti dalla sessione

In italiano. Cerco il M12 dal suo id. Poi scrivo una domanda («i treni da 5000 chilometri in su, dal meno al più chilometrato»), la stampo per vedere il SQL, e la eseguo. Poi cerco un treno dal codice, che non è la chiave primaria, e uno che non c'è.

Passo per passo.

RigaCosa faCosa dà
db.get(TrenoDB, 2)cerca per chiave primariaun oggetto TrenoDB
db.get(TrenoDB, 99)idem, ma la riga non c'èNone
select(…).where(…).order_by(…)scrive la domandauna domanda, non ancora eseguita
db.scalars(domanda).all()esegue, tiene l'oggetto di ogni rigauna lista di TrenoDB
db.scalar(select(…).where(codice == …))esegue, tiene il primo oggettoun TrenoDB, oppure None
db.execute(domanda).all()esegue, tiene le righe intereuna lista di Row: l'oggetto è dentro riga[0]

Cosa portiamo a casa. get per l'id, select con where per tutto il resto. scalars(…).all() per una lista, scalar(…) per uno solo. E un None può sempre arrivare: prima di usare m20.codice chiediti se m20 esiste.


C · Scrivere: il carrello che parte, e il carrello che resta

Ernesto Pozzi registra due treni nuovi, il M30 e il M31. Per il M30 fa tutto: add, commit, refresh. Per il M31 si ferma prima. Poi controlla con psql cosa è arrivato.

Questa volta lascio acceso l'echo: vedi il SQL che parte dalla sessione. Il file palestra/prova_c.py:

Python
from sqlalchemy.orm import Session

from database import engine
from modelli import TrenoDB

with Session(engine) as db:
    treno = TrenoDB(codice="M30", vagoni=5, km=0, in_servizio=False)
    print("appena creato:", treno.id)
    db.add(treno)
    print("dopo add:", treno.id)
    db.commit()
    print("dopo commit")
    db.refresh(treno)
    print("dopo refresh:", treno.id, treno.codice)

E il file palestra/prova_c2.py, quello del M31, senza commit:

Python
from sqlalchemy.orm import Session

from database import engine
from modelli import TrenoDB

with Session(engine) as db:
    treno = TrenoDB(codice="M31", vagoni=5, km=0, in_servizio=False)
    db.add(treno)
    print("add fatto, commit no")

Li lanci uno dopo l'altro, con psql in mezzo:

Terminale
python palestra/prova_c.py
psql -d db_sessione -c "SELECT id, codice, vagoni, km, in_servizio, stazione_id FROM treni WHERE id >= 10"
python palestra/prova_c2.py
psql -d db_sessione -c "SELECT id, codice FROM treni WHERE id >= 10"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
$ python palestra/prova_c.py
appena creato: None
dopo add: None
…
2026-11-19 19:09:11,273 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:11,274 INFO sqlalchemy.engine.Engine INSERT INTO treni (codice, vagoni, km, in_servizio, stazione_id) VALUES (%(codice)s::VARCHAR, %(vagoni)s::INTEGER, %(km)s::INTEGER, %(in_servizio)s, %(stazione_id)s::INTEGER) RETURNING treni.id
2026-11-19 19:09:11,274 INFO sqlalchemy.engine.Engine [generated in 0.00006s] {'codice': 'M30', 'vagoni': 5, 'km': 0, 'in_servizio': False, 'stazione_id': None}
2026-11-19 19:09:11,275 INFO sqlalchemy.engine.Engine COMMIT
dopo commit
2026-11-19 19:09:11,275 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:11,276 INFO sqlalchemy.engine.Engine SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.id = %(pk_1)s::INTEGER
2026-11-19 19:09:11,276 INFO sqlalchemy.engine.Engine [generated in 0.00005s] {'pk_1': 10}
dopo refresh: 10 M30
2026-11-19 19:09:11,276 INFO sqlalchemy.engine.Engine ROLLBACK

$ psql -d db_sessione -c "SELECT id, codice, vagoni, km, in_servizio, stazione_id FROM treni WHERE id >= 10"
 id | codice | vagoni | km | in_servizio | stazione_id
----+--------+--------+----+-------------+-------------
 10 | M30    |      5 |  0 | f           |
(1 riga)

$ python palestra/prova_c2.py
add fatto, commit no

$ psql -d db_sessione -c "SELECT id, codice FROM treni WHERE id >= 10"
 id | codice
----+--------
 10 | M30
(1 riga)

Le tre righe select pg_catalog.version(), select current_schema() e show standard_conforming_strings, con le loro righe [raw sql], le ha tolte da qui: SQLAlchemy le scrive ogni volta che la strada si apre, e non c'entrano con il carrello. Al loro posto c'è il ….

  • appena creato: None e dopo add: None: finché non c'è un commit, il treno non ha un id. L'id lo sceglie il database, e il database non sa ancora niente.
  • Nel terminale, tra dopo add e dopo commit, compaiono BEGIN, l'INSERT … RETURNING treni.id e COMMIT. Il SQL parte solo al commit, non all'add.
  • Il refresh fa un SELECT per rileggere la riga: l'id è 10 (i treni erano nove).
  • L'ultimo ROLLBACK è la sessione che si chiude: non ha più niente da annullare.
  • psql non passa dall'API né da SQLAlchemy: guarda la tabella. Il M30 c'è. Il M31, no: non c'è nemmeno una riga con quel codice.
treno = TrenoDB(id=10, codice="M30", vagoni=5, km=0, in_servizio=False, stazione_id=None)trenoTrenoDBid10codice"M30"vagoni5km0in_servizioFalsestazione_idNone
Il M30 dopo il refresh

In italiano. Per il M30: creo l'oggetto, lo metto nel carrello, consegno il carrello, riprendo l'oggetto con il suo id. Per il M31: lo metto nel carrello e basta. La sessione si chiude, il carrello viene buttato, e nel database non arriva niente. Nessun errore, nessun avviso.

Passo per passo.

RigaIl treno è…treno.idNel database
TrenoDB(…)solo un oggetto PythonNoneniente
db.add(treno)nel carrelloNoneniente
db.commit()consegnato: INSERT e COMMITscelto dal databasela riga c'è
db.refresh(treno)riletto dal database10la riga c'è
M31: la fine del with, senza commitil carrello viene buttatomai assegnatoniente

Cosa portiamo a casa. add mette nel carrello, commit consegna. Il database scrive solo al commit, e sceglie lui l'id. Quando una scrittura sembra riuscita, la prova del nove è psql.


D · Cambiare e togliere

Il M30 è arrivato al deposito, ma serve in servizio. Ernesto lo manda a Via Variabile (la stazione 2) e lo mette in servizio. Poi si accorge che era un errore di registrazione, e lo toglie.

Il file palestra/prova_d.py:

Python
from sqlalchemy.orm import Session

from database import engine
from modelli import TrenoDB

with Session(engine) as db:
    treno = db.get(TrenoDB, 10)
    treno.stazione_id = 2
    treno.in_servizio = True
    db.commit()
    print("spostato")
    db.delete(treno)
    db.commit()
    print("tolto")
Terminale
python palestra/prova_d.py
psql -d db_sessione -c "SELECT id, codice FROM treni WHERE id >= 10"
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
$ python palestra/prova_d.py
…
2026-11-19 19:09:11,853 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:11,854 INFO sqlalchemy.engine.Engine SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.id = %(pk_1)s::INTEGER
2026-11-19 19:09:11,854 INFO sqlalchemy.engine.Engine [generated in 0.00007s] {'pk_1': 10}
2026-11-19 19:09:11,856 INFO sqlalchemy.engine.Engine UPDATE treni SET in_servizio=%(in_servizio)s, stazione_id=%(stazione_id)s::INTEGER WHERE treni.id = %(treni_id)s::INTEGER
2026-11-19 19:09:11,856 INFO sqlalchemy.engine.Engine [generated in 0.00006s] {'in_servizio': True, 'stazione_id': 2, 'treni_id': 10}
2026-11-19 19:09:11,857 INFO sqlalchemy.engine.Engine COMMIT
spostato
2026-11-19 19:09:11,858 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:11,858 INFO sqlalchemy.engine.Engine SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.id = %(pk_1)s::INTEGER
2026-11-19 19:09:11,858 INFO sqlalchemy.engine.Engine [generated in 0.00004s] {'pk_1': 10}
2026-11-19 19:09:11,860 INFO sqlalchemy.engine.Engine DELETE FROM treni WHERE treni.id = %(id)s::INTEGER
2026-11-19 19:09:11,860 INFO sqlalchemy.engine.Engine [generated in 0.00004s] {'id': 10}
2026-11-19 19:09:11,860 INFO sqlalchemy.engine.Engine COMMIT
tolto

$ psql -d db_sessione -c "SELECT id, codice FROM treni WHERE id >= 10"
 id | codice
----+--------
(0 righe)

Anche qui, le righe di avvio di SQLAlchemy sono state tolte (il …).

  • Prima il SELECT di db.get: l'oggetto arriva dal database.
  • Poi un solo UPDATE, che scrive solo le due colonne cambiate (in_servizio e stazione_id), non tutto il treno. Nessuno ha scritto un UPDATE: la sessione si è accorta che due attributi erano cambiati.
  • Dopo il COMMIT l'oggetto è «scaduto»: per questo, prima del DELETE, c'è un secondo SELECT. La sessione lo ha ricaricato da sola, perché lo stai usando di nuovo.
  • Il DELETE toglie la riga, e il COMMIT lo conferma. psql dice (0 righe): il M30 non c'è più.
treno = TrenoDB(id=10, codice="M30", vagoni=5, km=0, in_servizio=True, stazione_id=2)trenoTrenoDBid10codice"M30"vagoni5km0in_servizioTruestazione_id2
Il M30 dopo i due cambi, prima del delete

In italiano. Prendo il treno. Cambio due attributi, come con qualunque oggetto Python. Consegno. Poi lo tolgo dalla sessione con db.delete, e consegno di nuovo: senza il secondo commit, il treno resterebbe.

Passo per passo.

RigaNella sessioneNel database
db.get(TrenoDB, 10)il treno, com'è nel databaseinvariato
treno.stazione_id = 2 e treno.in_servizio = Trueil treno è cambiato, la sessione se ne accorgeinvariato
db.commit()il carrello parteUPDATE: le due colonne cambiano
db.delete(treno)il treno è segnato «da togliere»invariato
db.commit()il carrello parteDELETE: la riga sparisce

Cosa portiamo a casa. Per cambiare non c'è nessun comando: si cambia l'attributo e si fa commit. Per togliere: db.delete(oggetto) e commit. Tutte le scritture finiscono con un commit.


E · Una rotta intera, con il suo 404 e il suo 409

Ora tutto insieme, dentro una rotta vera. Nello zip c'è palestra/centrale_sqlalchemy.py, la centrale dei treni già risolta. Riporta il database come all'inizio e accendila:

Terminale
psql -d db_sessione -f linea_menta.sql
fastapi dev palestra/centrale_sqlalchemy.py

Il server occupa il terminale: i comandi curl vanno in un secondo terminale, con il venv acceso. Il terminale del server mostra, per ogni richiesta, il SQL che parte.

La rotta POST /treni:

Python
@app.post("/treni", status_code=status.HTTP_201_CREATED)
def nuovo_treno(dati: TrenoNuovo, db: Session = Depends(get_db)) -> Treno:
    gemello = db.scalar(select(TrenoDB).where(TrenoDB.codice == dati.codice))
    if gemello is not None:
        raise HTTPException(status_code=409, detail="Codice già usato da un altro treno")
    treno = TrenoDB(
        codice=dati.codice,
        vagoni=dati.vagoni,
        km=dati.km,
        in_servizio=dati.in_servizio,
        stazione_id=dati.stazione_id,
    )
    db.add(treno)
    db.commit()
    db.refresh(treno)
    return treno

Marta Villa prova cinque richieste: un treno che non c'è, un codice già usato, un treno nuovo, e poi due cancellazioni.

Terminale
curl -i http://127.0.0.1:8000/treni/99
curl -i -X POST http://127.0.0.1:8000/treni -H "Content-Type: application/json" -d '{"codice": "M12", "vagoni": 4, "km": 0, "in_servizio": true}'
curl -i -X POST http://127.0.0.1:8000/treni -H "Content-Type: application/json" -d '{"codice": "M30", "vagoni": 5, "km": 0, "in_servizio": false}'
curl -i -X DELETE http://127.0.0.1:8000/treni/2
curl -i -X DELETE http://127.0.0.1:8000/treni/10
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
$ curl -i http://127.0.0.1:8000/treni/99
HTTP/1.1 404 Not Found
date: Thu, 19 Nov 2026 18:09:24 GMT
server: uvicorn
content-length: 30
content-type: application/json

{"detail":"Treno non trovato"}

$ curl -i -X POST http://127.0.0.1:8000/treni -H "Content-Type: application/json" -d '{"codice": "M12", "vagoni": 4, "km": 0, "in_servizio": true}'
HTTP/1.1 409 Conflict
date: Thu, 19 Nov 2026 18:09:24 GMT
server: uvicorn
content-length: 48
content-type: application/json

{"detail":"Codice già usato da un altro treno"}

$ curl -i -X POST http://127.0.0.1:8000/treni -H "Content-Type: application/json" -d '{"codice": "M30", "vagoni": 5, "km": 0, "in_servizio": false}'
HTTP/1.1 201 Created
date: Thu, 19 Nov 2026 18:09:24 GMT
server: uvicorn
content-length: 81
content-type: application/json

{"codice":"M30","vagoni":5,"km":0,"in_servizio":false,"stazione_id":null,"id":10}

$ curl -i -X DELETE http://127.0.0.1:8000/treni/2
HTTP/1.1 409 Conflict
date: Thu, 19 Nov 2026 18:09:24 GMT
server: uvicorn
content-length: 43
content-type: application/json

{"detail":"Il treno ha delle segnalazioni"}

$ curl -i -X DELETE http://127.0.0.1:8000/treni/10
HTTP/1.1 204 No Content
date: Thu, 19 Nov 2026 18:09:24 GMT
server: uvicorn
content-type: application/json
  • GET /treni/99: db.get dà None, la rotta decide il 404.
  • POST del M12: c'è già un treno con quel codice, 409. Non è partito nessun INSERT.
  • POST del M30: 201, e il treno ha l'id 10, scelto dal database.
  • DELETE /treni/2: il M12 ha delle segnalazioni, la rotta lo scopre e risponde 409. Il treno resta.
  • DELETE /treni/10: il M30 non ha segnalazioni: 204, nessun corpo.

Nel terminale del server, per i due POST, compare questo (tolte le righe di avvio di SQLAlchemy):

2026-11-19 19:09:24,917 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:24,918 INFO sqlalchemy.engine.Engine SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.codice = %(codice_1)s::VARCHAR
2026-11-19 19:09:24,918 INFO sqlalchemy.engine.Engine [generated in 0.00007s] {'codice_1': 'M12'}
2026-11-19 19:09:24,918 INFO sqlalchemy.engine.Engine ROLLBACK
INFO:     127.0.0.1:63555 - "POST /treni HTTP/1.1" 409 Conflict
2026-11-19 19:09:24,931 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:24,931 INFO sqlalchemy.engine.Engine SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.codice = %(codice_1)s::VARCHAR
2026-11-19 19:09:24,931 INFO sqlalchemy.engine.Engine [cached since 0.01323s ago] {'codice_1': 'M30'}
2026-11-19 19:09:24,932 INFO sqlalchemy.engine.Engine INSERT INTO treni (codice, vagoni, km, in_servizio, stazione_id) VALUES (%(codice)s::VARCHAR, %(vagoni)s::INTEGER, %(km)s::INTEGER, %(in_servizio)s, %(stazione_id)s::INTEGER) RETURNING treni.id
2026-11-19 19:09:24,932 INFO sqlalchemy.engine.Engine [generated in 0.00006s] {'codice': 'M30', 'vagoni': 5, 'km': 0, 'in_servizio': False, 'stazione_id': None}
2026-11-19 19:09:24,932 INFO sqlalchemy.engine.Engine COMMIT
2026-11-19 19:09:24,933 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2026-11-19 19:09:24,933 INFO sqlalchemy.engine.Engine SELECT treni.id, treni.codice, treni.vagoni, treni.km, treni.in_servizio, treni.stazione_id
FROM treni
WHERE treni.id = %(pk_1)s::INTEGER
2026-11-19 19:09:24,933 INFO sqlalchemy.engine.Engine [generated in 0.00004s] {'pk_1': 10}
INFO:     127.0.0.1:63556 - "POST /treni HTTP/1.1" 201 Created
2026-11-19 19:09:24,934 INFO sqlalchemy.engine.Engine ROLLBACK

Leggi la prima richiesta (la 409): un BEGIN, un SELECT per cercare il codice, e subito ROLLBACK. Niente INSERT: il controllo ha trovato il M12 e la rotta si è fermata prima di scrivere.

La seconda (la 201): BEGIN, il SELECT di controllo (che non trova niente), l'INSERT, il COMMIT. Poi un altro BEGIN e un SELECT per id: è il db.refresh. Il ROLLBACK finale è la sessione che si chiude, senza niente da annullare.

In italiano. La rotta controlla prima, poi scrive. Il controllo è un db.scalar che cerca un treno con lo stesso codice: se lo trova, 409 e nessuna scrittura. Se non lo trova, crea l'oggetto, add, commit, refresh, e risponde 201.

Il disegno.

inizio POST /treni passo gemello = db.scalar(...codice) se gemello is not None sì: errore 409 Codice già usato passo treno = TrenoDB(...) passo db.add(treno) passo db.commit() passo db.refresh(treno) restituisci trenoPOST /trenigemello =db.scalar(...codice)gemello is not None409 Codice già usatotreno = TrenoDB(...)db.add(treno)db.commit()db.refresh(treno)restituisci trenonosì
La rotta che crea un treno

Passo per passo.

PezzoCosa faSe lo togli
db: Session = Depends(get_db)chiede la sessione in prestitoFastAPIError: Invalid args for response field! appena accendi il server
db.scalar(select(…).where(codice == …))cerca un treno con quel codiceil M12 doppio arriva fino al database, che lo rifiuta: UniqueViolation, e il client riceve un 500
if gemello is not None: raise …409si ferma prima di scriverecome sopra
db.add(treno)mette il treno nel carrelloniente da consegnare, e il refresh si ferma: InvalidRequestError, «is not persistent within this Session»
db.commit()consegnail refresh si ferma con lo stesso InvalidRequestError, e il client riceve un 500
db.refresh(treno)riprende l'iddi solito niente: l'oggetto si ricarica da solo (ma tienilo)

Cosa portiamo a casa. Una rotta con la sessione ha sempre la stessa forma: la sessione dal Depends, un controllo che dà 404 o 409, e le mosse (add, commit, refresh, oppure delete, oppure un attributo cambiato). Il server ti fa vedere il SQL di ogni mossa: quando una rotta non si comporta, il primo posto dove guardare è lì.