SQL desde Python

Instalación de SQLite

La mayoría de las bases de datos necesitan un servidor: un programa que se instala, se configura y queda escuchando conexiones. SQLite no. Es una biblioteca que lee y escribe un solo archivo, y Python la trae incluida en el módulo estándar sqlite3. Por eso este curso puede empezar sin instalar nada. Esta lectura muestra cómo comprobarlo, cuándo vale la pena instalar herramientas adicionales, cómo maneja SQLite los tipos de datos y cómo crear la base de PyShop. Los ejemplos están en el notebook primeros-pasos-sqlite.

1. Comprobar que SQLite ya está

Si import sqlite3 funciona, ya tienes el motor completo. sqlite3.sqlite_version dice qué versión de SQLite usa tu Python (no la del módulo); apilevel indica que el módulo sigue la especificación DB-API 2.0 (PEP 249), la interfaz común de las bibliotecas de bases de datos en Python.

import sqlite3

print(sqlite3.sqlite_version)   # 3.50.4 en el entorno del curso
print(sqlite3.apilevel)         # 2.0
print(sqlite3.paramstyle)       # qmark: parámetros con ?

Los instaladores oficiales de python.org para Windows y macOS incluyen sqlite3. Si compilas Python desde el código fuente y faltan las bibliotecas de desarrollo de SQLite, el módulo no se construye y el import falla; en ese caso instala esas bibliotecas con el gestor de paquetes de tu sistema y vuelve a compilar.

2. Herramientas opcionales

Para el curso basta Python. Dos herramientas ayudan a mirar una base sin escribir código:

• La consola sqlite3: un programa de línea de comandos que se descarga de sqlite.org (en macOS ya viene instalado; en Linux suele estar en el gestor de paquetes de la distribución). Con sqlite3 pyshop.db abres el archivo y escribes SQL directamente; .tables lista las tablas y .schema muestra cómo se crearon.
• DB Browser for SQLite: una aplicación gráfica gratuita (sqlitebrowser.org) para explorar tablas, editar filas y probar consultas.

Ninguna es obligatoria. Son útiles para revisar qué guardó tu programa.

3. Una base es un archivo

sqlite3.connect("pyshop.db") abre ese archivo o lo crea si no existe. Todo vive ahí: tablas, índices y datos. La base de PyShop completa ocupa 228 KB y se copia como cualquier otro archivo. Con el nombre especial ":memory:", la base se crea en la memoria RAM y desaparece al cerrar la conexión; cada conexión a :memory: es una base distinta y vacía. Es la opción ideal para practicar y para pruebas automáticas.

Un detalle que sorprende al principio: los cambios no quedan guardados hasta llamar a commit(). En el notebook se inserta un cliente, se cierra la conexión sin confirmar y, al reabrir el archivo, siguen siendo 300 clientes.

4. Tipos de datos en SQLite

Cada valor guardado pertenece a una de cinco clases de almacenamiento: NULL, INTEGER, REAL, TEXT y BLOB (datos binarios). El tipo que declaras en una columna no es una regla estricta, sino una afinidad: una preferencia. Si el valor se puede convertir sin perder información, SQLite lo convierte; si no, lo guarda como llegó.

demo = sqlite3.connect(":memory:")
demo.execute("CREATE TABLE demo (a INTEGER, b TEXT)")
demo.execute("INSERT INTO demo VALUES ('12', 12)")
demo.execute("INSERT INTO demo VALUES ('doce', NULL)")
sql = "SELECT typeof(a), typeof(b) FROM demo"
print(demo.execute(sql).fetchall())
# [('integer', 'text'), ('text', 'null')]

El texto '12' se volvió entero y el número 12 se volvió texto, pero 'doce' entró sin error en una columna INTEGER. Por eso las restricciones son las que protegen los datos: NOT NULL, CHECK (precio > 0), UNIQUE. Desde SQLite 3.37 existen además las tablas STRICT, que rechazan valores del tipo equivocado.

SQLite no tiene un tipo fecha. PyShop guarda las fechas como texto ISO AAAA-MM-DD: así se ordenan y comparan bien como cadenas, y funciones como date('2025-03-15', '+30 days') las entienden.

5. Crear la base de PyShop

El curso usa una base con cuatro tablas relacionadas: clientes (300), productos (40), pedidos (2000 en 2025) y detalle (3477 líneas, qué productos lleva cada pedido). La constante ESQUEMA contiene sus CREATE TABLE; este es uno de ellos:

CREATE TABLE productos (
    id        INTEGER PRIMARY KEY,
    nombre    TEXT NOT NULL UNIQUE,
    categoria TEXT NOT NULL,
    precio    REAL NOT NULL CHECK (precio > 0),
    stock     INTEGER NOT NULL CHECK (stock >= 0)
);

La función crear_bd(), que está en la primera celda de cada notebook, ejecuta el esquema con executescript, activa las claves foráneas con PRAGMA foreign_keys = ON, llena las tablas con datos de semilla fija y devuelve la conexión. Para ver qué se creó:

con = crear_bd()
sql = "SELECT name FROM sqlite_master WHERE type = 'table'"
print(sorted(r[0] for r in con.execute(sql)))
# ['clientes', 'detalle', 'pedidos', 'productos']
for fila in con.execute("PRAGMA table_info(pedidos)"):
    print(fila[1], fila[2])

Trampas comunes

• Olvidar commit(). El programa parece funcionar, pero al reabrir el archivo los cambios no están.
• Confiar en el tipo de la columna. Una columna INTEGER acepta 'doce'; valida con CHECK o con tablas STRICT.
• Escribir mal el nombre del archivo. connect crea un archivo nuevo y vacío en lugar de avisar; si una consulta dice no such table, revisa la ruta.
• Asumir que :memory: se comparte. Dos conexiones a :memory: son dos bases distintas.

Antes de seguir, ejecuta las primeras celdas del notebook: comprueba tu versión de SQLite, crea la base de PyShop y revisa sus tablas con sqlite_master y PRAGMA table_info.