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:
- Prevedi: leggi il codice e scrivi su un foglio cosa stampa. Prima di aprire la risposta.
- In italiano: cosa fa il programma, a parole.
- Passo per passo: cosa succede, riga per riga.
- 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:
psql -d db_sessione -f linea_menta.sqlOgni esempio è un file tuo dentro palestra/ (per esempio palestra/prova_a.py), che lanci dalla cartella dello zip:
python palestra/prova_a.pySta 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:
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 ilyield("LA SESSIONE") arriva alla rotta nel parametrodb. - 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.
Passo per passo.
| Cosa succede | Dove | Cosa stampa |
|---|---|---|
FastAPI chiama sessione_finta() | prima della rotta | 1. apro la sessione |
il yield consegna "LA SESSIONE" | la funzione resta in pausa | niente |
la rotta gira con db uguale a "LA SESSIONE" | dentro prova | 2. la rotta usa LA SESSIONE |
| la rotta restituisce, FastAPI riprende la funzione | dopo il yield | 3. 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:
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 M24db.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%sdi 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].
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.
| Riga | Cosa fa | Cosa dà |
|---|---|---|
db.get(TrenoDB, 2) | cerca per chiave primaria | un oggetto TrenoDB |
db.get(TrenoDB, 99) | idem, ma la riga non c'è | None |
select(…).where(…).order_by(…) | scrive la domanda | una domanda, non ancora eseguita |
db.scalars(domanda).all() | esegue, tiene l'oggetto di ogni riga | una lista di TrenoDB |
db.scalar(select(…).where(codice == …)) | esegue, tiene il primo oggetto | un TrenoDB, oppure None |
db.execute(domanda).all() | esegue, tiene le righe intere | una 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:
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:
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:
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: Noneedopo add: None: finché non c'è uncommit, il treno non ha unid. L'idlo sceglie il database, e il database non sa ancora niente.- Nel terminale, tra
dopo addedopo commit, compaionoBEGIN, l'INSERT … RETURNING treni.ideCOMMIT. Il SQL parte solo alcommit, non all'add. - Il
refreshfa unSELECTper rileggere la riga: l'idè 10 (i treni erano nove). - L'ultimo
ROLLBACKè la sessione che si chiude: non ha più niente da annullare. psqlnon passa dall'API né da SQLAlchemy: guarda la tabella. Il M30 c'è. Il M31, no: non c'è nemmeno una riga con quel codice.
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.
| Riga | Il treno è… | treno.id | Nel database |
|---|---|---|---|
TrenoDB(…) | solo un oggetto Python | None | niente |
db.add(treno) | nel carrello | None | niente |
db.commit() | consegnato: INSERT e COMMIT | scelto dal database | la riga c'è |
db.refresh(treno) | riletto dal database | 10 | la riga c'è |
M31: la fine del with, senza commit | il carrello viene buttato | mai assegnato | niente |
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:
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")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
SELECTdidb.get: l'oggetto arriva dal database. - Poi un solo
UPDATE, che scrive solo le due colonne cambiate (in_servizioestazione_id), non tutto il treno. Nessuno ha scritto unUPDATE: la sessione si è accorta che due attributi erano cambiati. - Dopo il
COMMITl'oggetto è «scaduto»: per questo, prima delDELETE, c'è un secondoSELECT. La sessione lo ha ricaricato da sola, perché lo stai usando di nuovo. - Il
DELETEtoglie la riga, e ilCOMMITlo conferma.psqldice(0 righe): il M30 non c'è più.
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.
| Riga | Nella sessione | Nel database |
|---|---|---|
db.get(TrenoDB, 10) | il treno, com'è nel database | invariato |
treno.stazione_id = 2 e treno.in_servizio = True | il treno è cambiato, la sessione se ne accorge | invariato |
db.commit() | il carrello parte | UPDATE: le due colonne cambiano |
db.delete(treno) | il treno è segnato «da togliere» | invariato |
db.commit() | il carrello parte | DELETE: 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:
psql -d db_sessione -f linea_menta.sql
fastapi dev palestra/centrale_sqlalchemy.pyIl 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:
@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 trenoMarta Villa prova cinque richieste: un treno che non c'è, un codice già usato, un treno nuovo, e poi due cancellazioni.
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/10Prevedi 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/jsonGET /treni/99:db.getdàNone, la rotta decide il 404.POSTdel M12: c'è già un treno con quel codice, 409. Non è partito nessunINSERT.POSTdel M30: 201, e il treno ha l'id10, 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 ROLLBACKLeggi 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.
Passo per passo.
| Pezzo | Cosa fa | Se lo togli |
|---|---|---|
db: Session = Depends(get_db) | chiede la sessione in prestito | FastAPIError: Invalid args for response field! appena accendi il server |
db.scalar(select(…).where(codice == …)) | cerca un treno con quel codice | il M12 doppio arriva fino al database, che lo rifiuta: UniqueViolation, e il client riceve un 500 |
if gemello is not None: raise …409 | si ferma prima di scrivere | come sopra |
db.add(treno) | mette il treno nel carrello | niente da consegnare, e il refresh si ferma: InvalidRequestError, «is not persistent within this Session» |
db.commit() | consegna | il refresh si ferma con lo stesso InvalidRequestError, e il client riceve un 500 |
db.refresh(treno) | riprende l'id | di 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ì.