Tipos de datos en modelos

Tipos básicos (String, Integer, Boolean, DateTime)

Los modelos SQLAlchemy requieren definir tipos de datos específicos para cada columna de la tabla. Estos tipos determinan cómo se almacenan los datos en la base de datos y qué validaciones se aplican automáticamente.

SQLAlchemy proporciona una amplia gama de tipos de datos, pero para aplicaciones básicas necesitarás principalmente cuatro tipos fundamentales que cubren la mayoría de casos de uso.

String para texto

El tipo String se utiliza para almacenar texto de longitud variable. Es el equivalente a VARCHAR en SQL y requiere especificar una longitud máxima para optimizar el almacenamiento en la base de datos.

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Usuario(Base):
    __tablename__ = "usuarios"
    
    id = Column(Integer, primary_key=True)
    nombre = Column(String(100))  # Máximo 100 caracteres
    email = Column(String(255))   # Máximo 255 caracteres
    telefono = Column(String(20)) # Máximo 20 caracteres

La longitud especificada entre paréntesis es obligatoria y debe ajustarse al contenido esperado. Para nombres de usuario, 50-100 caracteres suelen ser suficientes, mientras que para emails se recomienda 255 caracteres como estándar.

Integer para números enteros

El tipo Integer almacena números enteros sin decimales. Es perfecto para identificadores, contadores, edades y cualquier valor numérico que no requiera precisión decimal.

class Producto(Base):
    __tablename__ = "productos"
    
    id = Column(Integer, primary_key=True)
    precio_centimos = Column(Integer)  # Precio en centimos para evitar decimales
    stock = Column(Integer)            # Cantidad disponible
    categoria_id = Column(Integer)     # Referencia a otra tabla

Una práctica recomendada es almacenar precios en centimos como enteros en lugar de usar decimales, ya que evita problemas de precisión en cálculos monetarios.

Boolean para valores verdadero/falso

El tipo Boolean representa valores de verdadero o falso. SQLAlchemy lo traduce automáticamente al tipo booleano nativo de cada base de datos.

class Articulo(Base):
    __tablename__ = "articulos"
    
    id = Column(Integer, primary_key=True)
    titulo = Column(String(200))
    publicado = Column(Boolean)     # True si está publicado
    destacado = Column(Boolean)     # True si aparece en portada
    activo = Column(Boolean)        # True si está disponible

Los campos booleanos son especialmente útiles para estados binarios como activo/inactivo, publicado/borrador, o cualquier característica que tenga solo dos posibles valores.

DateTime para fechas y horas

El tipo DateTime almacena fechas y horas completas. SQLAlchemy lo mapea automáticamente a los objetos datetime de Python, facilitando el trabajo con fechas.

from sqlalchemy import DateTime
from datetime import datetime

class Pedido(Base):
    __tablename__ = "pedidos"
    
    id = Column(Integer, primary_key=True)
    cliente = Column(String(100))
    fecha_creacion = Column(DateTime)
    fecha_entrega = Column(DateTime)
    fecha_actualizacion = Column(DateTime)

Para trabajar con fechas en tu aplicación, puedes usar el módulo datetime de Python:

# Crear un nuevo pedido con fecha actual
nuevo_pedido = Pedido(
    cliente="Juan Pérez",
    fecha_creacion=datetime.now(),
    fecha_entrega=datetime(2024, 12, 25, 14, 30)  # 25 dic 2024, 14:30
)

Combinando tipos en un modelo completo

Un modelo real típicamente combina varios tipos de datos para representar entidades complejas del mundo real:

class EventoConferencia(Base):
    __tablename__ = "eventos"
    
    id = Column(Integer, primary_key=True)
    titulo = Column(String(200))           # Nombre del evento
    descripcion = Column(String(1000))     # Descripción detallada
    capacidad_maxima = Column(Integer)     # Número máximo de asistentes
    precio_euros = Column(Integer)         # Precio en céntimos de euro
    fecha_inicio = Column(DateTime)        # Cuándo comienza
    fecha_fin = Column(DateTime)           # Cuándo termina
    activo = Column(Boolean)               # Si acepta inscripciones
    gratuito = Column(Boolean)             # Si es sin coste

Este modelo demuestra cómo los diferentes tipos trabajan juntos para crear una representación completa de una entidad, donde cada campo tiene el tipo más apropiado según su propósito y los datos que almacenará.

Configuración de columnas (nullable, default)

Además de especificar el tipo de datos, las columnas de SQLAlchemy pueden configurarse con parámetros adicionales que controlan su comportamiento. Los dos parámetros más importantes son nullable y default, que determinan si una columna puede estar vacía y qué valor tomar cuando no se proporciona uno explícitamente.

Columnas nullable

El parámetro nullable controla si una columna puede contener valores NULL en la base de datos. Por defecto, todas las columnas permiten valores nulos excepto las claves primarias.

from sqlalchemy import Column, Integer, String, Boolean, DateTime

class Usuario(Base):
    __tablename__ = "usuarios"
    
    id = Column(Integer, primary_key=True)
    nombre = Column(String(100), nullable=False)    # Obligatorio
    email = Column(String(255), nullable=False)     # Obligatorio
    telefono = Column(String(20), nullable=True)    # Opcional
    biografia = Column(String(500))                 # Opcional por defecto

Cuando estableces nullable=False, la base de datos rechazará cualquier intento de insertar un registro sin proporcionar un valor para esa columna. Esto es especialmente útil para campos esenciales como nombres de usuario o direcciones de email.

Valores por defecto con default

El parámetro default especifica qué valor debe asignarse automáticamente a una columna cuando no se proporciona uno durante la inserción. Esto es fundamental para campos que deben tener siempre un valor inicial.

from datetime import datetime

class Articulo(Base):
    __tablename__ = "articulos"
    
    id = Column(Integer, primary_key=True)
    titulo = Column(String(200), nullable=False)
    publicado = Column(Boolean, default=False)           # Por defecto no publicado
    visitas = Column(Integer, default=0)                 # Contador inicia en cero
    fecha_creacion = Column(DateTime, default=datetime.now)  # Fecha actual

Es importante notar que para datetime.now no incluimos los paréntesis (). Esto hace que SQLAlchemy ejecute la función cada vez que se crea un registro, obteniendo la fecha y hora actual en ese momento.

Combinando nullable y default

La combinación de nullable y default ofrece un control preciso sobre el comportamiento de las columnas:

class Producto(Base):
    __tablename__ = "productos"
    
    id = Column(Integer, primary_key=True)
    nombre = Column(String(100), nullable=False)                    # Obligatorio
    precio = Column(Integer, nullable=False, default=0)             # Obligatorio con valor inicial
    descripcion = Column(String(1000), nullable=True, default="")  # Opcional con texto vacío
    activo = Column(Boolean, nullable=False, default=True)          # Obligatorio, activo por defecto
    stock = Column(Integer, default=0)                              # Opcional, inicia en cero

En este ejemplo, el campo precio nunca puede ser nulo pero tendrá valor cero si no se especifica, mientras que descripcion puede ser nulo pero por defecto será una cadena vacía.

Valores por defecto dinámicos

Para casos más complejos, puedes usar funciones como valores por defecto que se ejecutan cada vez que se crea un registro:

import uuid
from datetime import datetime, timedelta

def generar_codigo_unico():
    return f"PROD-{uuid.uuid4().hex[:8].upper()}"

def fecha_vencimiento():
    return datetime.now() + timedelta(days=30)

class ProductoTemporal(Base):
    __tablename__ = "productos_temporales"
    
    id = Column(Integer, primary_key=True)
    codigo = Column(String(50), default=generar_codigo_unico)  # Código único automático
    nombre = Column(String(100), nullable=False)
    fecha_vencimiento = Column(DateTime, default=fecha_vencimiento)  # 30 días desde creación
    activo = Column(Boolean, default=True)

Ejemplo práctico completo

Un modelo de usuario típico que aprovecha estas configuraciones podría verse así:

class PerfilUsuario(Base):
    __tablename__ = "perfiles_usuario"
    
    id = Column(Integer, primary_key=True)
    username = Column(String(50), nullable=False)               # Nombre único obligatorio
    email = Column(String(255), nullable=False)                 # Email obligatorio
    nombre_completo = Column(String(200), nullable=True)        # Nombre real opcional
    fecha_registro = Column(DateTime, default=datetime.now)     # Automático al registrarse
    ultimo_acceso = Column(DateTime, nullable=True)             # Se actualiza en cada login
    activo = Column(Boolean, default=True, nullable=False)      # Activo por defecto
    intentos_login = Column(Integer, default=0)                 # Contador de intentos fallidos
    es_admin = Column(Boolean, default=False, nullable=False)   # Usuario normal por defecto

Al crear un nuevo usuario, solo necesitarías proporcionar los campos obligatorios:

nuevo_usuario = PerfilUsuario(
    username="juan_dev",
    email="juan@ejemplo.com"
)
# Los demás campos tomarán sus valores por defecto automáticamente

Esta configuración garantiza que todos los registros tengan datos consistentes desde el momento de su creación, reduciendo errores y simplificando la lógica de la aplicación.