Flask: Modelos y migraciones

Usar Flask en conjunto con SQLAlchemy permite desarrollar aplicaciones basadas en una base de datos relacional sin complicaciones. Con este enfoque, se aprovechan los beneficios de un microframework y un ORM, lo que facilita la definición de modelos y la ejecución de consultas.

Instalación de Flask y SQLAlchemy

Para comenzar, es indispensable contar con Python instalado. En un entorno virtual previamente activado, se instala Flask y la librería SQLAlchemy (o, de forma más común, Flask-SQLAlchemy, que simplifica la configuración):

pip install flask flask-sqlalchemy

De esta manera, se prepara el proyecto para manejar la persistencia de datos bajo un enfoque que abstrae el uso de SQL a través de un ORM.

Configuración de la base de datos

En Flask, la configuración se declara habitualmente en un archivo app.py o en un fichero de configuración independiente. Un ejemplo mínimo:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///mi_base_datos.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

En este fragmento, se define la variable SQLALCHEMY_DATABASE_URI con la ruta de la base de datos. Usar SQLite resulta muy práctico en entornos de desarrollo, pero es posible indicar otros gestores como PostgreSQL o MySQL con una URI distinta.

Definición de modelos

Con Flask-SQLAlchemy, los modelos se crean como clases que heredan de db.Model. Cada clase corresponde a una tabla de la base de datos. A continuación, se presenta un ejemplo de la tabla Usuario:

class Usuario(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    nombre = db.Column(db.String(50), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    edad = db.Column(db.Integer)

    def __repr__(self):
        return f'<Usuario {self.nombre}>'

Los atributos de la clase definen las columnas y sus restricciones, aprovechando la sintaxis de SQLAlchemy para gestionar la persistencia.

Creación y migración de la base de datos

Para inicializar la base de datos, se ejecuta el método db.create_all() en un contexto de aplicación. Un ejemplo rápido sería:

with app.app_context():
    db.create_all()

Esto genera las tablas correspondientes a los modelos definidos. Sin embargo, en proyectos más grandes, se suelen utilizar herramientas de migración (por ejemplo, Flask-Migrate) para realizar cambios graduales y controlados sobre la estructura de la base de datos.

Operaciones CRUD básicas

El siguiente paso consiste en crear, leer, actualizar y eliminar registros utilizando los métodos del ORM:

• Crear un usuario:

  nuevo_usuario = Usuario(nombre='Carlos', email='carlos@ejemplo.com', edad=30)
  db.session.add(nuevo_usuario)
  db.session.commit()
  

• Leer registros:

  todos_usuarios = Usuario.query.all()
  uno_usuario = Usuario.query.filter_by(nombre='Carlos').first()
  

• Actualizar un registro:

  uno_usuario.edad = 31
  db.session.commit()
  

• Eliminar un registro:

  db.session.delete(uno_usuario)
  db.session.commit()
  

Estas operaciones ilustran la facilidad con que SQLAlchemy gestiona las transacciones y sin tener que trabajar con sentencias SQL puras.

Relaciones entre modelos

En muchos casos, se establece una relación uno a muchos, muchos a muchos o uno a uno entre modelos. Un ejemplo de relación uno a muchos es un modelo Post que pertenece a un Usuario. Se utiliza la clave foránea:

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    titulo = db.Column(db.String(100))
    contenido = db.Column(db.Text)
    usuario_id = db.Column(db.Integer, db.ForeignKey('usuario.id'))
    usuario = db.relationship('Usuario', backref='posts')

De este modo, se asocian las entidades a través de la columna usuario_id. Gracias a db.relationship, se obtiene acceso directo a los posts relacionados con un usuario y viceversa.

Integración con vistas y rutas

Cuando se implementa un proyecto con Flask, las rutas definen la lógica de negocio y devuelven respuestas al usuario final. La capa de persistencia con SQLAlchemy facilita el intercambio de datos entre las vistas y la base de datos. Un ejemplo de ruta para crear un nuevo usuario podría ser:

from flask import request, jsonify

@app.route('/crear_usuario', methods=['POST'])
def crear_usuario():
    datos = request.get_json()
    nuevo_usuario = Usuario(nombre=datos['nombre'], email=datos['email'], edad=datos['edad'])
    db.session.add(nuevo_usuario)
    db.session.commit()
    return jsonify({'mensaje': 'Usuario creado con éxito'}), 201

Al aprovechar la persistencia, cada vez que se ejecute esta ruta, el ORM garantizará la inserción de la información en la base de datos.

Buenas prácticas de persistencia

• Dividir el proyecto en módulos coherentes, separando los modelos de la lógica de rutas.
• Habilitar migraciones con Flask-Migrate para administrar los cambios en la estructura de las tablas.
• Implementar validaciones de datos antes de insertar o actualizar registros, ya sea mediante validadores personalizados o integraciones con librerías de validación.
• Proteger las credenciales de acceso a la base de datos empleando variables de entorno y evitando exponerlas en repositorios públicos.
• Definir índices y restricciones en tus columnas para optimizar las consultas y reforzar la integridad de los datos.

En conjunto, la configuración de Flask con SQLAlchemy ofrece una experiencia fluida para manejar operaciones CRUD y favorecer la persistencia de la información. Con estos fundamentos, es posible escalar la aplicación, añadir nuevos modelos y aprovechar la versatilidad del ecosistema Python en cualquier proyecto web.