Base de datos: SQL y SQLModel

Teoría24 min20 XP

Una API que olvida todo al reiniciarse no sirve: los datos deben PERSISTIR en una base de datos. El lenguaje universal para hablar con bases de datos relacionales es SQL, y Python trae sqlite3 incluido —que corre aquí mismo, en vivo—. Para conectar esto con FastAPI de forma elegante existe SQLMODEL, que une Pydantic y la base de datos en un solo modelo. Hoy aprendes a guardar y consultar datos: el corazón de cualquier backend.

El archivador con índice

SQL en vivo con sqlite3

sqlite3 viene incluido con Python (¡y corre aquí!). Una base de datos en memoria para aprender SQL:

sqlite3.connect abre la base de datos (aquí en memoria; en tu app sería un archivo o un servidor PostgreSQL). Con SQL: CREATE TABLE define la estructura, INSERT crea registros (usa ? para los valores —NUNCA metas datos con f-strings en SQL: es la puerta a la inyección SQL, el ataque más clásico—), SELECT lee (con WHERE para filtrar, ORDER BY para ordenar, COUNT/SUM para agregar). commit() guarda los cambios. Este es el CRUD en SQL puro, corriendo de verdad. SQL es una habilidad que trasciende Python —lo usarás en cualquier lenguaje que toque una base de datos—.

UPDATE, DELETE y SQLModel

Completar el CRUD y conectar con FastAPI

Faltan actualizar y borrar, y cómo integrar todo con FastAPI de forma elegante:

Escribir SQL a mano funciona, pero es tedioso y propenso a errores en una API grande. Por eso existen los ORM (mapeadores objeto-relacional), y el moderno para FastAPI es SQLMODEL (del mismo autor), que une Pydantic y la base de datos en UN modelo:

sqlmodel_ejemplo.py

from sqlmodel import SQLModel, Field, Session, create_engine, select

# UN modelo que es a la vez validación (Pydantic) Y tabla de base de datos
class Gasto(SQLModel, table=True):
  id: int | None = Field(default=None, primary_key=True)
  nombre: str
  valor: int
  categoria: str = "otros"

engine = create_engine("sqlite:///bolsillo.db")
SQLModel.metadata.create_all(engine)     # crea las tablas

# crear un registro (¡sin escribir SQL!)
with Session(engine) as session:
  gasto = Gasto(nombre="Café", valor=4000, categoria="comida")
  session.add(gasto)
  session.commit()

  # consultar con objetos Python, no SQL crudo
  gastos = session.exec(select(Gasto).where(Gasto.categoria == "comida")).all()
  for g in gastos:
      print(g.nombre, g.valor)

Con SQLModel, defines UN modelo que sirve para tres cosas: validar datos (como Pydantic), representar la tabla, y consultarla con objetos Python en vez de SQL crudo (select(Gasto).where(...)). Se integra perfecto con FastAPI: el mismo modelo valida las peticiones Y persiste en la base de datos. Escribes menos, con menos errores, y sin mezclar strings de SQL en tu código. (SQLModel se instala con pip install sqlmodel y necesita el entorno completo; por eso va en bloque, mientras el SQL con sqlite3 corre aquí.)

¿Por qué se usan parámetros (?) en las consultas SQL en vez de insertar los valores con f-strings, y qué aporta SQLModel?

Mini-reto

Practica SQL en vivo con sqlite3: 1) crea una base en memoria y una tabla gastos (id, nombre, valor, categoria); 2) inserta cuatro gastos con executemany y parámetros ?; 3) haz un SELECT con WHERE que traiga los de una categoría ordenados por valor, y otro con SUM/COUNT para el total; 4) haz un UPDATE de un valor y un DELETE de un registro, y verifica el resultado. Recuerda commit() tras los cambios.

Qué sigue

Ya persistes datos. Falta proteger tu API: no cualquiera debe poder ver o modificar los datos. La próxima lección trae la AUTENTICACIÓN con JWT —cómo verificar quién es cada usuario y proteger endpoints—, la pieza de seguridad que toda API real necesita.