ORM en FastAPI
El Object-Relational Mapping (ORM) es una técnica de programación que permite interactuar con bases de datos relacionales utilizando objetos de Python en lugar de escribir consultas SQL directamente. En el contexto de FastAPI, los ORMs simplifican enormemente el trabajo con datos al proporcionar una capa de abstracción entre tu aplicación y la base de datos.
¿Qué es un ORM?
Un ORM actúa como un traductor entre el mundo orientado a objetos de Python y el mundo relacional de las bases de datos. Convierte automáticamente las filas de una tabla en objetos Python y viceversa, permitiendo que manipules datos de la base de datos como si fueran objetos normales de tu aplicación.
Los beneficios principales de usar un ORM incluyen:
- Productividad mejorada: Escribes menos código repetitivo
- Seguridad aumentada: Protección automática contra inyecciones SQL
- Mantenibilidad: Código más legible y fácil de modificar
- Portabilidad: Cambiar de base de datos requiere mínimos ajustes
SQLAlchemy: El ORM de referencia
SQLAlchemy es el ORM más popular y maduro del ecosistema Python. Se integra perfectamente con FastAPI y ofrece dos enfoques principales: el Core (más cercano a SQL) y el ORM (más orientado a objetos).
Para proyectos con FastAPI, utilizamos principalmente el enfoque ORM que nos permite definir modelos como clases Python:
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
Base = declarative_base()
class Usuario(Base):
__tablename__ = "usuarios"
id = Column(Integer, primary_key=True, index=True)
nombre = Column(String, index=True)
email = Column(String, unique=True, index=True)
Configuración de la base de datos
Guarda tu progreso
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
La configuración inicial de SQLAlchemy en FastAPI sigue un patrón estándar que separa la lógica de conexión de los modelos:
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
# URL de conexión (SQLite para desarrollo)
SQLALCHEMY_DATABASE_URL = "sqlite:///./app.db"
# Motor de base de datos
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
# Fábrica de sesiones
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Esta configuración establece los componentes fundamentales:
- Engine: Gestiona las conexiones a la base de datos
- SessionLocal: Crea sesiones individuales para cada operación
- Base: Clase base para todos los modelos
Gestión de sesiones
Las sesiones de base de datos en FastAPI se manejan típicamente mediante dependencias que garantizan el correcto cierre de conexiones:
from fastapi import Depends
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
# Uso en endpoints
@app.get("/usuarios/")
def obtener_usuarios(db: Session = Depends(get_db)):
return db.query(Usuario).all()
Operaciones CRUD básicas
El patrón CRUD (Create, Read, Update, Delete) representa las operaciones fundamentales con datos. SQLAlchemy proporciona métodos intuitivos para cada operación:
Crear registros:
def crear_usuario(db: Session, nombre: str, email: str):
usuario = Usuario(nombre=nombre, email=email)
db.add(usuario)
db.commit()
db.refresh(usuario)
return usuario
Leer registros:
def obtener_usuario(db: Session, usuario_id: int):
return db.query(Usuario).filter(Usuario.id == usuario_id).first()
def obtener_usuarios(db: Session, skip: int = 0, limit: int = 100):
return db.query(Usuario).offset(skip).limit(limit).all()
Relaciones entre modelos
Las relaciones permiten conectar diferentes tablas y acceder a datos relacionados de forma natural. SQLAlchemy soporta todos los tipos de relaciones:
from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship
class Publicacion(Base):
__tablename__ = "publicaciones"
id = Column(Integer, primary_key=True, index=True)
titulo = Column(String, index=True)
contenido = Column(String)
autor_id = Column(Integer, ForeignKey("usuarios.id"))
# Relación con Usuario
autor = relationship("Usuario", back_populates="publicaciones")
# Actualizar modelo Usuario
class Usuario(Base):
# ... campos existentes ...
publicaciones = relationship("Publicacion", back_populates="autor")
Validación con Pydantic
Pydantic complementa perfectamente a SQLAlchemy proporcionando validación automática de datos y serialización JSON. Los esquemas Pydantic definen la estructura de datos para las APIs:
from pydantic import BaseModel
class UsuarioBase(BaseModel):
nombre: str
email: str
class UsuarioCrear(UsuarioBase):
pass
class Usuario(UsuarioBase):
id: int
class Config:
from_attributes = True
La integración entre SQLAlchemy y Pydantic permite convertir automáticamente objetos de base de datos en respuestas JSON válidas, manteniendo la consistencia de tipos y validación en toda la aplicación.
Completa FastAPI y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs