FastAPI: ORM

FastAPI
FastAPI
Actualizado: 01/07/2025

¡Desbloquea el curso completo!

IA
Ejercicios
Certificado
Entrar

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.

Progreso guardado
Asistente IA
Ejercicios
Iniciar sesión gratis

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

⭐⭐⭐⭐⭐
4.9/5 valoración