100 Días de Código en Python — Día 63: Bases de datos con SQLite y SQLAlchemy — la biblioteca virtual

📝 Contenido original del curso#

¿Has querido llevar un registro de los libros que has leído y calificarlos? Hay empresas dedicadas a eso (por ejemplo, LibraryThing). Para hacerlo necesitamos una base de datos. Al final del día sabrás crear una base de datos SQLite y crear, leer, actualizar y borrar datos en ella (CRUD), y conectarla con una aplicación Flask.

Prerequisitos: Flask con formularios y POST (Días 60 y 61), clases (Días 16 a 21), listas de diccionarios (Día 9), url_for y rutas con variables (Días 55 a 57).

📖 ¿Por qué no seguir con CSV? (adaptación)#

En el Día 62 guardaste datos en un CSV. Funciona, pero:

📝 Ejercicio original del curso#

Descarga el proyecto de inicio (plantillas para Jinja), crea el entorno virtual e instala requirements.txt (como en los Días 61 y 62). Luego, cinco retos en main.py, index.html y add.html:

1. En la ruta /, un <h1> "My Library" y un enlace "Add New Book".
2. En /add, un formulario con título, autor y calificación, y un botón "Add Book".
3. Al enviar el formulario, el libro se agrega como diccionario a la lista all_books:

   all_books = [
       {
           "title": "Harry Potter",
           "author": "J. K. Rowling",
           "rating": 9,
       }
   ]

4. La portada muestra cada libro como <li> dentro de un <ul>.
5. Si no hay libros (all_books = []), la portada muestra <p>Library is empty.</p>; el enlace "Add New Book" lleva a /add.

🔍 Antes de programar#

• ¿Qué ruta necesita aceptar POST?
• ¿Cómo sabe la plantilla si la lista está vacía? (Pista: {% if all_books %} o {% for %}…{% else %}, Día 57.)
• Después de agregar un libro, ¿muestras la portada con render_template o rediriges con redirect(url_for("home"))? (Día 60: POST/Redirect/GET.)

📝 Contenido original del curso#

Agrega algunos libros; aparecen en la portada. Ahora detén el servidor y vuelve a ejecutarlo. Recarga la portada: ¿qué pasó con tus libros?

Desaparecieron. Estaban en la lista all_books, una variable que se crea de nuevo cada vez que se ejecuta main.py. "Si esto le pasara a los datos de nuestros usuarios, no confiarían mucho en nuestro sitio". Hace falta persistencia de datos: guardarlos en una base de datos.

📖 Memoria contra almacenamiento (adaptación)#

Con el modo de depuración, basta con guardar main.py para que el servidor se reinicie y la lista se vacíe: lo notarás muy rápido.

🎯 Objetivo de aprendizaje#

Crear una base de datos SQLite, una tabla con restricciones y un registro, usando SQL desde Python.

📝 Contenido original del curso#

SQLite es la base de datos más usada del mundo y viene incluida en Python. En un proyecto aparte:

import sqlite3

db = sqlite3.connect("books-collection.db")   # si no existe, la crea
cursor = db.cursor()

• Al ejecutarlo aparece el archivo books-collection.db (no intentes abrirlo en PyCharm).
• El cursor es como el puntero del ratón en una hoja de cálculo: lo que agrega, edita o borra datos.

Crear una tabla. Un archivo de Excel puede tener varias hojas; una base de datos puede tener varias tablas:

cursor.execute("CREATE TABLE books (id INTEGER PRIMARY KEY, title varchar(250) NOT NULL UNIQUE, author varchar(250) NOT NULL, rating FLOAT NOT NULL)")

Ver la base de datos: instala DB Browser for SQLite (sqlitebrowser.org; en Windows, el instalador estándar), pulsa Open Database y abre el archivo .db: verás la tabla books con sus 4 campos.

Insertar un registro:

cursor.execute("INSERT INTO books VALUES(1, 'Harry Potter', 'J. K. Rowling', '9.3')")
db.commit()

commit() guarda los cambios. Antes de volver a ejecutar, comenta la línea CREATE TABLE (si no: sqlite3.OperationalError: table books already exists) y cierra la base de datos en DB Browser (si no: aviso de database locked).

SQL es muy sensible a errores de escritura: con VALUE en lugar de VALUES, "no funciona en absoluto (¿puedes ver la diferencia?)". Por suerte hay una forma mejor: SQLAlchemy.

📖 Los errores del curso, verificados#

Una curiosidad: el curso inserta la calificación como texto ('9.3'), pero SQLite la guarda como número (real) porque la columna es FLOAT (verificado). SQLite es flexible con los tipos; otras bases de datos no lo son. Mejor escribir 9.3 sin comillas.

CREATE TABLE IF NOT EXISTS books (...) evita tener que comentar la línea.

📖 🔒 Inyección SQL: nunca armes SQL con f-strings (adaptación)#

Si el título lo escribe un usuario y armas la consulta así:

cursor.execute(f"INSERT INTO books (title, author, rating) VALUES ('{titulo}', '{autor}', {nota})")

alguien podría escribir un "título" que cierre tu texto y agregue instrucciones SQL propias (por ejemplo, borrar la tabla). Es la inyección SQL, uno de los ataques más conocidos. La defensa: parámetros con ?, y sqlite3 se encarga del resto (verificado con "El túnel"):

cursor.execute("INSERT INTO books (title, author, rating) VALUES (?, ?, ?)", (titulo, autor, nota))

SQLAlchemy (sección 4) usa parámetros automáticamente.

⚠️ Errores frecuentes#

🎯 Objetivo de aprendizaje#

Definir una tabla como una clase (modelo) de SQLAlchemy y crearla desde Flask.

📝 Contenido original del curso#

Escribir SQL es complicado y propenso a errores; sería mejor escribir Python y que el editor nos ayude a ver los errores. Para eso existe SQLAlchemy, una biblioteca ORM (Object Relational Mapping): las tablas se vuelven clases, los campos se vuelven atributos y cada fila es un objeto.

1. Comenta el código de sqlite3.
2. Instala flask, SQLAlchemy y flask_sqlalchemy desde requirements.txt.
3. Importa:

   from flask import Flask
   from flask_sqlalchemy import SQLAlchemy
   from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
   from sqlalchemy import Integer, String, Float

4. Reto, con la documentación de Flask-SQLAlchemy 3.1:

   • una base de datos SQLite new-books-collection.db (inicializa la aplicación);
   • una tabla books con id, title, author y rating, con las mismas restricciones que antes;
   • con el "contexto de la aplicación", crear el esquema;
   • con el contexto, crear un registro con: id: 1, author: "J. K. Rowling", review: 9.3.

   Pistas: la URL de la base de datos es "sqlite:///new-books-collection.db"; puedes revisarla con DB Browser.

📖 La solución (lección 449, verificada)#

app = Flask(__name__)


class Base(DeclarativeBase):
    pass


app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///new-books-collection.db"
db = SQLAlchemy(model_class=Base)
db.init_app(app)


class Book(db.Model):
    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    title: Mapped[str] = mapped_column(String(250), unique=True, nullable=False)
    author: Mapped[str] = mapped_column(String(250), nullable=False)
    rating: Mapped[float] = mapped_column(Float, nullable=False)


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

• Desde Flask-SQLAlchemy 3.1 se pasa una subclase de DeclarativeBase al crear SQLAlchemy.
• Los dos puntos (id: Mapped[int]) son anotaciones de tipo: le dicen a SQLAlchemy (y al editor) qué tipo de dato guarda cada campo.
• app.app_context(): fuera de una solicitud web, Flask-SQLAlchemy necesita saber a qué aplicación pertenece la base de datos. Dentro de una ruta ya hay contexto; en el código suelto, hay que abrirlo con with.

🛠️ Nota técnica (verificado): el reto tiene tres detalles que no coinciden:

1. Los datos del registro no incluyen title, que es NOT NULL: al guardarlo aparece IntegrityError: NOT NULL constraint failed: book.title. Agrega title="Harry Potter".
2. Dice review: 9.3, pero el campo se llama rating: Book(review=9.3) lanza TypeError: 'review' is an invalid keyword argument for Book.
3. Pide una tabla llamada books, pero SQLAlchemy la llama como la clase en minúsculas: book. Si necesitas el nombre exacto, agrega __tablename__ = "books" a la clase.

🛠️ Nota técnica (verificado): en Flask-SQLAlchemy 3.x, una ruta relativa como sqlite:///new-books-collection.db crea la base de datos en la carpeta instance del proyecto, no junto a main.py. La propia extensión crea esa carpeta al inicializarse. Si abres en DB Browser "otra" base vacía, probablemente estás mirando el archivo equivocado.

🎯 Objetivo de aprendizaje#

Crear, leer, actualizar y borrar registros con SQLAlchemy 2.

📝 Contenido original del curso#

"Lo más importante al aprender cualquier tecnología de bases de datos es saber hacer CRUD": Create, Read, Update, Delete.

# CREATE
with app.app_context():
    new_book = Book(title="Harry Potter", author="J. K. Rowling", rating=9.3)   # el id se genera solo
    db.session.add(new_book)
    db.session.commit()

# READ: todos
with app.app_context():
    result = db.session.execute(db.select(Book).order_by(Book.title))
    all_books = result.scalars()

# READ: uno, por una condición
with app.app_context():
    book = db.session.execute(db.select(Book).where(Book.title == "Harry Potter")).scalar()

# UPDATE: por una condición
with app.app_context():
    book_to_update = db.session.execute(db.select(Book).where(Book.title == "Harry Potter")).scalar()
    book_to_update.title = "Harry Potter and the Chamber of Secrets"
    db.session.commit()

# UPDATE: por clave primaria
book_id = 1
with app.app_context():
    book_to_update = db.get_or_404(Book, book_id)
    book_to_update.title = "Harry Potter and the Goblet of Fire"
    db.session.commit()

# DELETE: por clave primaria
with app.app_context():
    book_to_delete = db.get_or_404(Book, book_id)
    db.session.delete(book_to_delete)
    db.session.commit()

• Una consulta (db.select(...)) se ejecuta en una sesión y devuelve filas (un Result); scalars() da los objetos, scalar() da uno.
• Desde Flask-SQLAlchemy 3.0, métodos antiguos como Book.query.get() están obsoletos. Verás mucho código viejo en Internet que los usa.

📖 Detalles verificados (adaptación)#

La sesión es como un "carrito de compras": add, cambios en atributos y delete se acumulan, y commit() los paga todos juntos. Si algo falla, rollback() vacía el carrito.

⚠️ Errores frecuentes#

Retos adicionales (creados para esta adaptación)#

• 🟢 Reto 1 — Aplicación: agrega tres libros y léelos ordenados por calificación, de mayor a menor (order_by(Book.rating.desc())).
• 🟡 Reto 2 — Ampliación: busca los libros de un autor con where(Book.author == ...) y los que tienen calificación mayor a 8 (Book.rating > 8).
• 🟠 Reto 3 — Desafío: intenta guardar un título repetido, atrapa IntegrityError, haz rollback() y muestra un mensaje claro.
• 🔴 Reto 4 — Pensamiento computacional: escribe la misma consulta en SQL directo (SELECT ... WHERE ... ORDER BY ...) y con SQLAlchemy. Ejecuta print(db.select(Book).where(Book.rating > 8)) y compara el SQL que genera SQLAlchemy con el tuyo.

📝 Ejercicio original del curso#

Integra la base de datos SQLite en el sitio del inicio del día, para que los libros se guarden y para aprovechar todo el CRUD:

• Agregar libros en /add; al guardarlos con éxito, redirigir a la portada.
• La portada muestra todos los libros de la base de datos.
• Un enlace "Edit Rating" en cada <li> lleva a una página para cambiar la calificación; al pulsar "Change Rating", vuelve a la portada con la calificación nueva. Pista: piensa en cómo pasar el id del libro en la solicitud GET que muestra la página de edición (construcción de URL, o parámetros con nombre en la URL).
• Un enlace "Delete" en cada <li> borra el libro y vuelve a la portada.

Problema y contexto#

Quieres un registro de tus lecturas que no se borre cada vez que apagas el computador.

🔍 Antes de programar#

• ¿Cómo sabe la página de edición qué libro editar? Dos opciones: /edit/<int:id> o /edit?id=3 (request.args). ¿Cuál prefieres y por qué?
• Después de editar o borrar, ¿por qué redirigir y no renderizar?
• ¿Qué pasa si alguien visita /edit/999?

Requisitos funcionales#

1. Modelo Book con id, title (único, obligatorio), author y rating.
2. Portada con todos los libros o "Library is empty.".
3. /add (GET y POST) que guarda y redirige.
4. Edición de la calificación por id.
5. Borrado por id.

Restricciones técnicas#

• CRUD con SQLAlchemy 2 (db.select, get_or_404), sin Book.query.
• url_for en todos los enlaces.
• Títulos repetidos: mensaje claro, no error 500.

Planificación#

1. Comprender. 2. Entradas: formularios e ids. 3. Procesos: C, R, U, D. 4. Salidas: portada y formularios. 5. Dividir: una ruta por operación. 6. Diseñar las URL. 7. Implementar. 8. Probar. 9. Corregir. 10. Mejorar.

Construcción paso a paso#

• Versión 1: retos 1 a 5 de la lección 445 con la lista all_books.
• Versión 2: modelo y create_all().
• Versión 3: /add guarda en la base de datos; la portada lee de ella.
• Versión 4: edición de la calificación.
• Versión final: borrado y manejo de errores.

Pruebas#

📖 🔒 Borrar con un enlace: funciona, pero es mala idea (adaptación)#

El curso pide un enlace (<a href="/delete?id=3">) para borrar. Funciona, pero un enlace hace una solicitud GET, y GET debería servir solo para ver (Día 60): los navegadores y algunas extensiones precargan enlaces, un buscador podría seguirlos, y otra página podría borrarte libros con un simple <img src="tu-sitio/delete?id=1">. La práctica correcta es borrar con un formulario POST (o con el método DELETE, que verás en el Día 66):

<form action="{{ url_for('delete', book_id=book.id) }}" method="post" style="display:inline">
    <button type="submit">Delete</button>
</form>

Haz primero la versión del curso y luego conviértela (Reto 2 del proyecto).

🧪 Prueba y depuración#

@app.route("/edit/<id>", methods=["GET", "POST"])
def edit(id):
    book = db.session.execute(db.select(Book).where(Book.id == id)).scalar()
    if request.method == "POST":
        book.rating = request.form["rating"]
        return render_template("index.html")
    return render_template("edit.html", book=book)

Encuentra cuatro problemas: falta int: en la ruta; si el id no existe, book es None (mejor get_or_404); falta db.session.commit(); y después de guardar se debería redirigir a la portada (además, index.html se renderiza sin la lista de libros).

⭐ Extensión del proyecto#

• Reto 1: ordena la portada por calificación y muestra el promedio de tus libros.
• Reto 2: borra con un formulario POST en lugar de un enlace.
• Reto 3: agrega la fecha en que terminaste cada libro (Mapped[date]) y muestra los leídos este año.

Situación#

En los descansos, el área de educación física presta balones, cuerdas y conos. Hoy lo anota en un cuaderno y siempre se pierde algo.

Requisitos#

1. Dos modelos: Implemento (id, nombre, tipo, estado: disponible/prestado/dañado) y Prestamo (id, id del implemento, curso, nombre del estudiante responsable, hora de salida, hora de devolución que puede quedar vacía).
2. / muestra los implementos con su estado y un botón "Prestar" (solo si está disponible).
3. Prestar crea un Prestamo y cambia el estado del implemento; "Devolver" registra la hora y lo deja disponible.
4. /pendientes muestra los préstamos sin devolver, del más antiguo al más reciente.
5. Todas las acciones que modifican datos se hacen con POST.

Decisiones que debes tomar (y justificar)#

• ¿Qué pasa si dos personas intentan prestar el mismo balón a la vez?
• ¿Guardas el nombre completo del estudiante o solo el curso? ¿Por cuánto tiempo?

Casos de prueba#

• Prestar un balón ya prestado → mensaje de error.
• Devolver → el implemento vuelve a "disponible" y el préstamo tiene hora de devolución.
• Reiniciar el servidor → los préstamos siguen ahí.

Conceptuales#

1. ¿Por qué desaparecieron los libros al reiniciar el servidor?
2. ¿Qué es una clave primaria? ¿Qué hacen NOT NULL y UNIQUE?
3. ¿Qué es un ORM? ¿Qué se convierte en qué?
4. ¿Qué significan las letras de CRUD?
5. ¿Qué es la inyección SQL y cómo se evita?

Análisis de código#

libros = db.session.execute(db.select(Book)).scalars()
print(len(list(libros)))
return render_template("index.html", books=libros)

¿Qué verá el usuario en la portada? ¿Por qué?

Predicción#

with app.app_context():
    b = db.session.execute(db.select(Book).where(Book.title == "No existe")).scalar()
    print(b)
    print(b.title)

Depuración#

"Agregué un libro, lo veo en la página, pero en DB Browser la tabla está vacía". Da dos causas posibles.

Modificación#

Cambia /edit para que también permita cambiar el autor.

Creación#

Escribe un modelo Estudiante (id, nombre, curso, promedio) y un script que cree 5 estudiantes y muestre los que tienen promedio mayor a 4.0, ordenados de mayor a menor.