Lección 42 de 47 · Proyecto final: CRUD de tareas con SQLite✦ WebMCP implementado
Fase 1: el esquema en SQLite y las migraciones
10 min de lectura4 retos
Empieza el proyecto final: la app de tareas de verdad, con base de datos, API y despliegue. En esta primera fase montas las carpetas del proyecto, eliges SQLite (que ya viene dentro de Python) y escribes las migraciones que crean la tabla tareas.
¿De dónde vienen los nombres?
sqlite3 = SQLite = SQL + lite (ligero); el 3 es la versión del formato de fichero
El módulo de la biblioteca estándar que habla con SQLite. Es tu PDO con el driver pdo_sqlite, pero ya instalado.
execute = inglés execute (ejecutar)
Lanza una sentencia SQL. Es el $pdo->exec() y el $pdo->query() de PHP en uno solo.
commit = inglés commit (confirmar, comprometerse)
Confirma los cambios pendientes de la transacción: hasta que no haces commit, solo existen para tu conexión.
lastrowid = inglés last row id (id de la última fila)
El id que SQLite acaba de dar al último INSERT. Es el $pdo->lastInsertId() de PHP.
migración = del latín migrare (cambiar de sitio): pasar la base de datos de una versión a la siguiente
Un cambio en el esquema guardado como código, con un número para saber el orden.
En 4 ideas
1/4
El proyecto se reparte en carpetas por capa: app/domain, app/application y app/infrastructure, con el arranque en app/main.py. Es tu src/Domain, src/Application y src/Infrastructure de un PHP con DDD.
SQLite es una base de datos que vive en un solo fichero, y el módulo sqlite3 ya viene con Python: sqlite3.connect("tareas.db") es el new PDO("sqlite:tareas.db") de PHP, sin instalar nada.
SQLite no tiene BOOLEAN ni DATETIME: hecha se guarda como 0/1 y la fecha como texto. Al leer una fila hay que traducirla a la Tarea, como harías con (bool) $fila['hecha'] en PHP.
Las migraciones son cambios numerados que se aplican en orden y una sola vez, apuntados en una tabla migraciones, como las de Phinx o Laravel. Para probarlas basta una base de datos ":memory:".
1 · El plan: seis fases y una carpeta por capa
Hasta ahora has visto el lenguaje pieza a pieza. Ahora toca montar algo entero. Piensa en una casa: primero los cimientos (la base de datos), luego las paredes (el dominio), las tuberías (el repositorio), las habitaciones (los casos de uso), la puerta de la calle (la API) y por último la mudanza (el despliegue).
Fase 1: el esquema en SQLite y las migraciones (esta lección).
Fase 2: el dominio, la entidad Tarea y sus reglas.
Fase 3: el repositorio, un Protocol con dos versiones: SQLite y en memoria.
Fase 4: los casos de uso: crear, listar, completar y borrar.
Fase 5: la API con FastAPI, servida con uvicorn.
Fase 6: tests con pytest y despliegue con Docker.
Cada fase parte del código de la anterior. Así queda el proyecto cuando acabes:
tareas/
├── requirements.txt ← el composer.json
├── Dockerfile
├── app/
│ ├── main.py ← el public/index.php: crea la app
│ ├── domain/ ← Tarea, Prioridad, errores, el Protocol del repositorio
│ ├── application/ ← CrearTarea, ListarTareas, CompletarTarea, BorrarTarea
│ └── infrastructure/
│ ├── sqlite/ ← migraciones y RepositorioSqlite
│ └── api/ ← rutas, modelos pydantic y dependencias
└── tests/ ← pytest
Carpeta
Qué va dentro
En un PHP con DDD
app/main.py
Crea la aplicación y enchufa las rutas
public/index.php + el contenedor de dependencias
app/domain
La entidad Tarea, sus reglas y sus errores
src/Domain
app/application
Lo que la app sabe hacer, un caso de uso por acción
src/Application (los services o handlers)
app/infrastructure/sqlite
Cómo se guardan las tareas (SQL)
src/Infrastructure/Repository
app/infrastructure/api
Rutas, modelos de entrada y salida
src/Infrastructure/Http (controladores)
requirements.txt
Las dependencias y sus versiones
composer.json
Equivalencia POO · PHP → Python
Cada carpeta con un fichero __init__.py es un paquete (lo viste en el módulo 09). La ruta del import hace de namespace y de use a la vez.
PHP
Python
Quién lo ve
namespace App\Domain;
El fichero app/domain/tarea.py
El nombre sale de la ruta: no se declara
use App\Domain\Tarea;
from app.domain.tarea import Tarea
Cualquiera que tenga app en su ruta de búsqueda
@internal en un docblock (solo un aviso)
Un guion bajo delante: _conexion, _interno.py
Nadie lo impide: es un acuerdo entre personas
Autoload PSR-4 de Composer
sys.path y las carpetas con __init__.py
El intérprete lo resuelve al hacer import
¿Por qué? · En PHP no existe
¿Por qué tres capas y no un solo fichero? En PHP también se puede, y falla igual
Con todo en un fichero, el SQL, las reglas del negocio y las rutas se mezclan: para cambiar de SQLite a MySQL tienes que tocar también el código que decide qué es una tarea válida.
Con capas, el dominio no sabe nada de la base de datos ni de la web y puedes probarlo con un assert, sin servidor. Cada capa solo mira hacia dentro: la API conoce los casos de uso, los casos de uso conocen el dominio, y el dominio no conoce a nadie.
2 · SQLite sin instalar nada: el módulo sqlite3
SQLite es una base de datos que cabe en un fichero, por ejemplo tareas.db. No hay servidor que instalar ni usuario ni contraseña: es como una libreta en vez de una biblioteca entera. Para una app de tareas sobra. Y en Python no hay que instalar ningún driver: el módulo sqlite3 viene con el propio lenguaje.
Esta es la dinámica de siempre: conectas, ejecutas SQL y lees filas. Usamos la ruta especial ":memory:", una base de datos que vive solo mientras dura el programa: perfecta para probar, y la única que funciona en el navegador. Pulsa Ejecutar:
Pythonmain.py
import sqlite3
# En PHP: $pdo = new PDO("sqlite::memory:");
conexion = sqlite3.connect(":memory:")
conexion.execute(
"CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)"
)
# En PHP: $pdo->prepare("INSERT INTO tareas (titulo) VALUES (?)")->execute(["Comprar pan"]);
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Comprar pan",))
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Llamar al banco",))
# En PHP: foreach ($pdo->query("SELECT id, titulo FROM tareas") as $fila) { ... }for fila in conexion.execute("SELECT id, titulo FROM tareas"):
print(fila)
conexion.close()
PHP 8.5tareas.php
<?phpdeclare(strict_types=1);
$pdo = newPDO("sqlite::memory:");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$pdo->exec("CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)");
$insertar = $pdo->prepare("INSERT INTO tareas (titulo) VALUES (?)");
$insertar->execute(["Comprar pan"]);
$insertar->execute(["Llamar al banco"]);
foreach ($pdo->query("SELECT id, titulo FROM tareas") as$fila) {
echo$fila["id"] . " " . $fila["titulo"] . PHP_EOL;
}
Pythontareas.py
import sqlite3
conexion = sqlite3.connect(":memory:")
conexion.execute(
"CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)"
)
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Comprar pan",))
conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Llamar al banco",))
for id, titulo in conexion.execute("SELECT id, titulo FROM tareas"):
print(id, titulo)
sqlite3.connect(...) devuelve la conexión: es tu PDO. No hay new ni setAttribute: los errores de SQL ya llegan como excepciones (sqlite3.OperationalError), que en PDO hay que pedir con ERRMODE_EXCEPTION.
conexion.execute(sql, parametros) hace de prepare() + execute() en una línea. Los parámetros van en una tupla, por eso ("Comprar pan",) lleva coma: sin ella sería solo un texto entre paréntesis.
Un SELECT devuelve algo que se recorre con for; cada fila es una tupla que se desempaqueta directamente: for id, titulo in ....
¿Por qué? · En PHP no existe
¿Por qué los parámetros van aparte, con ?, y no dentro del texto del SQL?
Si pegas el título dentro del texto (f"... VALUES ('{titulo}')"), un título como O'Brien rompe la consulta, y uno escrito con mala idea cambia lo que hace: es la inyección SQL. Con ?, la base de datos recibe el SQL por un lado y los valores por otro, y los valores nunca se interpretan como SQL.
En PHP ya lo sabes por prepare(); en Python es igual de importante y más fácil de olvidar, porque una f-string compila y funciona en la demo. Lo veremos roto en la fase 3.
3 · El esquema: la tabla tareas
El esquema es el plano de la base de datos: qué tablas hay y qué columnas lleva cada una. La nuestra tiene una sola, tareas. Es SQL normal, el mismo que escribirías para PHP:
Pythonmain.py
CREATE_TAREAS = """CREATE TABLE tareas ( id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL, prioridad INTEGER NOT NULL DEFAULT 1, hecha INTEGER NOT NULL DEFAULT 0, creada_en TEXT NOT NULL)"""
SQLite tiene muy pocos tipos. No hay BOOLEAN ni DATETIME: un sí/no se guarda como 0 o 1, y una fecha como texto (2026-11-19T10:00:00+00:00). Es como apuntar «hecha: 1» en una libreta: el qué significa lo decide tu programa.
Columna
Tipo en SQLite
Tipo en Python al leer
En la Tarea
id
INTEGER
int
id: int | None
titulo
TEXT
str
titulo: str
prioridad
INTEGER (0, 1, 2)
int
prioridad: Prioridad (el enum del módulo 05)
hecha
INTEGER (0 o 1)
int
hecha: bool
creada_en
TEXT
str
No está: la pone el repositorio
Así que leer una fila es traducir. Primero llega una fila con números y texto, y luego la conviertes en una tarea. Con row_factory = sqlite3.Row las filas se leen por nombre de columna, como el FETCH_ASSOC de PDO. Pulsa Ejecutar:
Pythonmain.py
import sqlite3
conexion = sqlite3.connect(":memory:")
# En PHP: $pdo->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
conexion.row_factory = sqlite3.Row
conexion.execute("""CREATE TABLE tareas ( id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL, prioridad INTEGER NOT NULL DEFAULT 1, hecha INTEGER NOT NULL DEFAULT 0, creada_en TEXT NOT NULL)""")
conexion.execute(
"INSERT INTO tareas (titulo, prioridad, hecha, creada_en) VALUES (?, ?, ?, ?)",
("Comprar pan", 2, 0, "2026-11-19T10:00:00+00:00"),
)
conexion.execute(
"INSERT INTO tareas (titulo, hecha, creada_en) VALUES (?, ?, ?)",
("Llamar al banco", 1, "2026-11-19T10:05:00+00:00"),
)
for fila in conexion.execute("SELECT id, titulo, prioridad, hecha FROM tareas"):
# En PHP: $hecha = (bool) $fila['hecha'];
hecha = bool(fila["hecha"])
print(f"#{fila['id']} {fila['titulo']:<16} prioridad={fila['prioridad']} hecha={hecha}")
¿Por qué? · En PHP no existe
¿Por qué hecha es INTEGER y no BOOLEAN? En PHP con MySQL sí existe
SQLite decide el tipo por el valor que guardas, no por la columna: es de tipado flexible. Por eso no tiene tipos fijos para sí/no ni para fechas, y se guarda lo que haga falta (0/1, texto ISO).
Lo bueno: es sencillísimo. Lo malo: nada te impide meter "talvez" en hecha. Por eso la traducción bool(fila["hecha"]) se hace en un único sitio (el repositorio, fase 3) y el resto del programa solo ve un bool.
4 · Migraciones: el historial de la base de datos
Una migración es un cambio en la base de datos guardado como código, con un número delante para saber el orden. Es como el historial de obras de una casa: «1, poner los cimientos; 2, abrir una ventana». Nunca se edita una obra antigua: si hace falta algo nuevo, se añade otra.
Nuestra primera migración crea la tabla; la segunda añade las etiquetas, guardadas como texto separado por comas (casa,urgente). Para saber cuáles ya están hechas, se apuntan en una tabla migraciones. El programa aplica en orden las que falten. Lo mismo que hacen Phinx o Laravel, escrito a mano:
PHP 8.5migrar.php
<?phpdeclare(strict_types=1);
$migraciones = [
"001_crear_tareas" => "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)",
"002_etiquetas" => "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT ''",
];
$pdo = newPDO("sqlite::memory:");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$pdo->exec("CREATE TABLE IF NOT EXISTS migraciones ( nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)");
$hechas = $pdo->query("SELECT nombre FROM migraciones")->fetchAll(PDO::FETCH_COLUMN);
ksort($migraciones);
foreach ($migracionesas$nombre => $sql) {
if (in_array($nombre, $hechas, true)) {
continue;
}
$pdo->beginTransaction();
try {
$pdo->exec($sql);
$pdo->prepare("INSERT INTO migraciones VALUES (?, datetime('now'))")->execute([$nombre]);
$pdo->commit();
echo"aplicada: $nombre" . PHP_EOL;
} catch (Throwable $e) {
$pdo->rollBack();
throw$e;
}
}
Pythonmigrar.py
import sqlite3
from datetime importUTC, datetime
MIGRACIONES = {
"001_crear_tareas": "CREATE TABLE tareas (id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL)",
"002_etiquetas": "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT ''",
}
defmigrar(conexion):
conexion.execute(
"CREATE TABLE IF NOT EXISTS migraciones (nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)"
)
hechas = {fila[0] for fila in conexion.execute("SELECT nombre FROM migraciones")}
for nombre insorted(MIGRACIONES):
if nombre in hechas:
continue
conexion.execute("BEGIN")
try:
conexion.execute(MIGRACIONES[nombre])
conexion.execute(
"INSERT INTO migraciones (nombre, aplicada_en) VALUES (?, ?)",
(nombre, datetime.now(UTC).isoformat(timespec="seconds")),
)
conexion.commit()
exceptException:
conexion.rollback()
raiseprint("aplicada:", nombre)
migrar(sqlite3.connect(":memory:"))
Mira lo que ya conoces: el try / except con raise al final hace de catch + throw (módulo 07), los ? son parámetros y la receta es la de siempre: mirar qué falta, aplicarlo y apuntarlo, todo o nada. Y ahora la prueba de que es seguro repetirla:
Pythonmain.py
import sqlite3
from datetime importUTC, datetime
MIGRACIONES = {
"001_crear_tareas": """ CREATE TABLE tareas ( id INTEGER PRIMARY KEY AUTOINCREMENT, titulo TEXT NOT NULL, prioridad INTEGER NOT NULL DEFAULT 1, hecha INTEGER NOT NULL DEFAULT 0, creada_en TEXT NOT NULL ) """,
"002_etiquetas": "ALTER TABLE tareas ADD COLUMN etiquetas TEXT NOT NULL DEFAULT ''",
}
defmigrar(conexion):
"""Aplica en orden las migraciones que falten y devuelve sus nombres."""
conexion.execute(
"CREATE TABLE IF NOT EXISTS migraciones (nombre TEXT PRIMARY KEY, aplicada_en TEXT NOT NULL)"
)
hechas = {fila[0] for fila in conexion.execute("SELECT nombre FROM migraciones")}
nuevas = []
for nombre insorted(MIGRACIONES):
if nombre in hechas:
continue
conexion.execute("BEGIN")
try:
conexion.execute(MIGRACIONES[nombre])
conexion.execute(
"INSERT INTO migraciones (nombre, aplicada_en) VALUES (?, ?)",
(nombre, datetime.now(UTC).isoformat(timespec="seconds")),
)
conexion.commit()
exceptException:
conexion.rollback()
raise
nuevas.append(nombre)
return nuevas
conexion = sqlite3.connect(":memory:")
print("primera vez:", migrar(conexion))
print("segunda vez:", migrar(conexion))
columnas = [fila[1] for fila in conexion.execute("PRAGMA table_info(tareas)")]
print("columnas:", columnas)
¿Por qué? · En PHP no existe
¿Por qué BEGIN a mano? En PHP, beginTransaction() abría la transacción y ya está
El módulo sqlite3 de Python abre las transacciones solo antes de un INSERT, UPDATE o DELETE, y no antes de un CREATE TABLE o un ALTER TABLE. Si no hicieras nada, la tabla se crearía al instante y, si el INSERT en migraciones fallara, quedaría creada pero sin apuntar: la siguiente vez intentaría crearla otra vez y daría error.
Con conexion.execute("BEGIN") abres tú la transacción y el commit() o el rollback() cubren las dos sentencias a la vez: o se hace todo, o no se hace nada. SQLite sí admite cambios de esquema dentro de una transacción; es Python quien, por defecto, no la abre.
5 · Abrir la base de datos y probarlo
En la app real abrirás un fichero (tareas.db) y migrarás al arrancar, una sola vez. En los tests usarás ":memory:": una base nueva y vacía por prueba, sin ficheros que limpiar.
Pythonmain.py
import sqlite3
from app.infrastructure.sqlite.migraciones import migrar
# En PHP: $pdo = new PDO("sqlite:" . $ruta);
conexion = sqlite3.connect("tareas.db")
migrar(conexion)
Vale, pero… ¿y mis migraciones de Laravel o mi Doctrine?
En Python hay herramientas para todo, pero para empezar el SQL a mano es lo más claro: ves exactamente qué se ejecuta. Cuando el proyecto crezca, estas son las opciones más usadas:
SQLAlchemy: el ORM más usado de Python, el «Doctrine» del ecosistema.
Alembic: migraciones para SQLAlchemy, el «Phinx» de Python.
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
Tu primera fila
La tabla tareas ya está creada, pero el programa cuenta 0 filas. Inserta la tarea Comprar pan (con un ?, nunca con una f-string) para que imprima 1. Es el $pdo->prepare(...)->execute([...]) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.conexion.execute("INSERT INTO tareas (titulo) VALUES (?)", ("Comprar pan",)): los parámetros van en una tupla, y con una sola cosa la coma es obligatoria.
Reto 2 de 4 · ✓ Resuelto
Etiquetas: de lista a texto y vuelta
La columna etiquetas guarda un texto separado por comas. Escribe etiquetas_a_texto(etiquetas) (de ["casa", "urgente"] a "casa,urgente") y texto_a_etiquetas(texto) (la vuelta). Ojo: del texto vacío "" tiene que salir la lista vacía [], no [""]. Son el implode() y el explode() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.",".join(lista) junta; texto.split(",") separa, pero "".split(",") da [""]: filtra los elementos vacíos con un if etiqueta.
Reto 3 de 4 · ✓ Resuelto
¿Qué migraciones faltan?
Escribe migraciones_pendientes(todas, aplicadas): recibe un diccionario nombre → SQL y un conjunto con los nombres ya aplicados, y devuelve la lista de nombres que faltan, en orden. Es el array_diff(array_keys($todas), $aplicadas) de PHP, ordenado.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Recorre sorted(todas) (ordena las claves del diccionario) y quédate con las que no estén en aplicadas (nombre not in aplicadas).
Reto 4 de 4 · ✓ Resuelto
Tu propio migrar
Escribe migrar(conexion, migraciones): crea la tabla migraciones (nombre, aplicada_en) si no existe, aplica en orden las que falten (ejecuta su SQL y apunta el nombre) y devuelve la lista de nombres que ha aplicado. Una segunda llamada tiene que devolver []. Hazlo con commit() al final de cada migración.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Saca los nombres ya apuntados con un SELECT nombre FROM migraciones, recorre sorted(migraciones), salta los que estén y para cada uno haz execute(sql), el INSERT del apunte y conexion.commit().
Resumen
Lo que te llevas de esta lección
Una carpeta por capa dentro de app/ y el arranque en app/main.py (en PHP, src/Domain, src/Infrastructure y public/index.php).
sqlite3 viene con Python: sqlite3.connect("tareas.db") es tu new PDO("sqlite:tareas.db"), sin driver que instalar.
Los valores van aparte, con ? y en una tupla ((titulo,)): nunca pegados con una f-string (en PHP, prepare() y execute([...])).
SQLite guarda hecha como 0/1 y la fecha como texto: se traduce con bool(fila["hecha"]) (en PHP, (bool) $fila['hecha']).
Migraciones numeradas con ceros, aplicadas en orden, apuntadas en una tabla y dentro de un BEGIN explícito (en PHP, Phinx o Laravel).
Para recordarlo: «Cero, Orden, Apunta»
CCeros 001_crear_tareas
OOrden sorted(MIGRACIONES)
AApunta INSERT INTO migraciones
Las tres reglas de una migración: nombre con Ceros delante, se aplican en Orden y cada una se Apunta para no repetirla nunca.