SQLite es un motor de base de datos pequeño y gratuito que guarda toda una base de datos en un solo archivo. No hay que instalar ni mantener un servidor: tu aplicación lee y escribe el archivo directamente, usando SQL estándar.
Esa sencillez es la razón por la que SQLite está en todas partes. Viene incluido en Python, Android, iOS, macOS y todos los navegadores web importantes, y sus desarrolladores calculan que hay más de un billón de bases de datos SQLite en uso. También es una de las mejores formas de aprender SQL, porque puedes empezar en segundos sin configurar nada.
Esta guía explica qué es SQLite, cómo se compara con PostgreSQL y MySQL, cuándo usarlo (y cuándo no), y te lleva paso a paso por crear una base de datos, consultarla, usarla desde Python, acelerarla con índices y respaldarla. Todos los ejemplos se probaron con SQLite 3.43.
¿Qué Es SQLite?
La mayoría de las bases de datos, como PostgreSQL y MySQL, usan un diseño cliente-servidor: un servidor de base de datos funciona en segundo plano y las aplicaciones se conectan a él por la red o por un socket.
SQLite es distinto. Es una base de datos embebida: una pequeña biblioteca que pasa a formar parte de tu aplicación. Sus características principales:
- Sin servidor. No hay nada que instalar, iniciar ni mantener en ejecución.
- Un solo archivo. Toda la base de datos (tablas, índices y datos) vive en un archivo común, como
library.db, que puedes copiar, enviar por correo o guardar en una memoria USB. - Sin configuración. No hay usuarios, contraseñas, puertos ni archivos de configuración.
- SQL de verdad. Admite tablas, joins, índices, vistas, triggers, transacciones, funciones de ventana y funciones JSON.
- Confiable. Las transacciones son ACID: un cambio se completa por entero o no se aplica, aunque se vaya la luz a mitad de la escritura.
- Gratis y de dominio público. Puedes usarlo para lo que quieras, incluidos productos comerciales, sin licencia.
Dónde Se Usa SQLite
- Apps móviles en Android e iOS guardan sus datos locales en SQLite.
- Navegadores web lo usan para el historial, los marcadores y las cookies.
- Apps de escritorio y autoalojadas, como Uptime Kuma, lo usan como base de datos predeterminada.
- Python lo incluye en su biblioteca estándar (
import sqlite3), así que es la opción predeterminada para prototipos, scripts y apps pequeñas con Flask. - Análisis de datos: es una forma práctica de consultar archivos CSV y conjuntos de datos con SQL.
- Pruebas: muchos proyectos ejecutan sus pruebas con SQLite porque arranca al instante.
SQLite vs. PostgreSQL vs. MySQL
| SQLite | PostgreSQL | MySQL | |
|---|---|---|---|
| Arquitectura | Biblioteca embebida, un solo archivo | Cliente-servidor | Cliente-servidor |
| Instalación | Ninguna | Instalar y configurar un servidor | Instalar y configurar un servidor |
| Usuarios y permisos | No (usa los permisos del archivo) | Sí | Sí |
| Escrituras simultáneas | Una a la vez | Muchas | Muchas |
| Acceso por red | No, solo archivo local | Sí | Sí |
| Ideal para | Apps, prototipos, sitios pequeños y medianos, datos locales, aprender | Apps multiusuario, consultas complejas, grandes volúmenes de datos | Apps web, sobre todo en hosting compartido |
Cuándo Usar SQLite
- Aplicaciones móviles, de escritorio y embebidas
- Prototipos, proyectos personales y herramientas propias
- Sitios web con tráfico moderado, sobre todo donde las lecturas superan por mucho a las escrituras
- Análisis de datos, scripts y herramientas de línea de comandos
- Aprender SQL y practicar consultas
- Una caché local o un formato de archivo para tu propia aplicación
Cuándo Elegir Otra Opción
- Muchos usuarios escribiendo al mismo tiempo. SQLite permite un solo escritor a la vez. Las escrituras son rápidas, así que casi nunca importa en apps pequeñas, pero los sistemas multiusuario con muchísimas escrituras funcionan mejor con PostgreSQL o MySQL.
- Varios servidores compartiendo una base de datos. SQLite es un archivo local. No lo pongas en una carpeta de red (NFS o SMB); el bloqueo de archivos por red no es confiable y puede dañar la base de datos.
- Necesitas cuentas de usuario y permisos dentro de la base de datos.
- Conjuntos de datos muy grandes con mucho análisis simultáneo. SQLite maneja archivos grandes, pero una base de datos de servidor escala mejor con muchos usuarios a la vez.
Un patrón común es empezar con SQLite y pasar a PostgreSQL si se queda corto. Bibliotecas como SQLAlchemy hacen que ese cambio sea casi solo cuestión de cambiar la cadena de conexión.
Instalar SQLite
Es posible que ya lo tengas:
- macOS: viene incluido. Abre Terminal y ejecuta
sqlite3 --version. - Linux: normalmente viene incluido, o instálalo con
sudo apt install sqlite3en Ubuntu y Debian. - Windows: descarga el paquete de “command-line tools” desde sqlite.org/download.html, descomprímelo y ejecuta
sqlite3.exe. - Python: el módulo
sqlite3viene incluido; no hay que instalar nada.
Si prefieres una herramienta gráfica, DB Browser for SQLite es gratuita y te permite explorar tablas, editar datos y ejecutar consultas.
¿Eres nuevo en la línea de comandos? La guía de la terminal de Linux cubre lo básico.
Crear tu Primera Base de Datos
Ejecuta sqlite3 con un nombre de archivo. Si el archivo no existe, SQLite lo crea:
sqlite3 library.db
Verás el prompt sqlite>. Los comandos que empiezan con un punto (como .tables) son comandos del shell; todo lo demás es SQL y debe terminar con punto y coma. Escribe .quit para salir.
Crear Tablas
Este ejemplo usa una pequeña biblioteca con autores y libros. Los nombres de tablas y columnas están en inglés para que coincidan con la salida de ejemplo. Guárdalo como setup.sql:
PRAGMA foreign_keys = ON;
CREATE TABLE authors (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
country TEXT
);
CREATE TABLE books (
id INTEGER PRIMARY KEY,
title TEXT NOT NULL,
author_id INTEGER NOT NULL REFERENCES authors(id),
year INTEGER,
price REAL CHECK (price >= 0)
);
INSERT INTO authors (name, country) VALUES
('Isabel Allende', 'Chile'),
('Gabriel García Márquez', 'Colombia'),
('Octavia E. Butler', 'United States');
INSERT INTO books (title, author_id, year, price) VALUES
('The House of the Spirits', 1, 1982, 16.99),
('One Hundred Years of Solitude', 2, 1967, 18.50),
('Love in the Time of Cholera', 2, 1985, 17.25),
('Kindred', 3, 1979, 15.00),
('Parable of the Sower', 3, 1993, 14.25);
Después cárgalo y lista las tablas:
sqlite3 library.db < setup.sql
sqlite3 library.db ".tables"
authors books
Una columna INTEGER PRIMARY KEY recibe automáticamente un número único cuando la omites en un INSERT, así que en la mayoría de los casos no necesitas AUTOINCREMENT.
Comandos Útiles del Shell
| Comando | Qué hace |
|---|---|
.tables | Lista las tablas |
.schema books | Muestra la sentencia CREATE de una tabla |
.headers on | Muestra los nombres de las columnas en los resultados |
.mode column | Alinea los resultados en columnas (también table, csv, json, markdown) |
.import --csv archivo.csv tabla | Importa un archivo CSV |
.backup archivo.db | Hace una copia segura de la base de datos |
.help | Lista todos los comandos del shell |
.quit | Sale |
Consultar Datos
Activa los encabezados y el modo de columnas, y ejecuta una consulta:
.headers on
.mode column
SELECT title, year, price FROM books WHERE price < 17 ORDER BY price;
title year price
------------------------ ---- -----
Parable of the Sower 1993 14.25
Kindred 1979 15.0
The House of the Spirits 1982 16.99
Los JOINs y las funciones de agregación funcionan como en cualquier base de datos SQL:
SELECT a.name AS author, COUNT(b.id) AS books, ROUND(AVG(b.price), 2) AS avg_price
FROM authors a
JOIN books b ON b.author_id = a.id
GROUP BY a.id
ORDER BY books DESC, author;
author books avg_price
---------------------- ----- ---------
Gabriel García Márquez 2 17.88
Octavia E. Butler 2 14.63
Isabel Allende 1 16.99
Insertar, Actualizar y Borrar
UPDATE books SET price = 13.99 WHERE title = 'Kindred';
DELETE FROM books WHERE year < 1900;
RETURNING (SQLite 3.35 y posteriores) muestra las filas que acabas de cambiar, lo que es práctico para obtener un ID nuevo:
INSERT INTO authors (name, country) VALUES ('Toni Morrison', 'United States')
RETURNING id, name;
id name
-- -------------
4 Toni Morrison
Escribe siempre una cláusula WHERE en UPDATE y DELETE. Sin ella, el cambio se aplica a todas las filas.
Importar un Archivo CSV
Supongamos que tienes new_books.csv:
title,author_id,year,price
Beloved,4,1987,16.00
Song of Solomon,4,1977,15.50
Impórtalo en una tabla temporal (la primera línea se convierte en los nombres de las columnas), copia las filas a books y después elimina la tabla temporal:
.import --csv new_books.csv books_import
INSERT INTO books (title, author_id, year, price)
SELECT title, author_id, year, price FROM books_import;
DROP TABLE books_import;
Tipos de Datos en SQLite: Qué Cambia
SQLite guarda cada valor en una de cinco clases de almacenamiento: NULL, INTEGER, REAL, TEXT o BLOB. El tipo declarado de una columna es una preferencia (llamada afinidad de tipo), no una regla estricta. De forma predeterminada, SQLite te deja guardar texto en una columna INTEGER:
CREATE TABLE loose (n INTEGER);
INSERT INTO loose VALUES ('hello');
SELECT n, typeof(n) FROM loose;
n typeof(n)
----- ---------
hello text
Si quieres el comportamiento estricto de otras bases de datos, agrega STRICT a la tabla (SQLite 3.37 y posteriores):
CREATE TABLE tight (n INTEGER) STRICT;
INSERT INTO tight VALUES ('hello');
Error: cannot store TEXT value in INTEGER column tight.n
(La redacción exacta de los mensajes de error cambia un poco entre versiones de SQLite).
Otras diferencias que conviene conocer:
- No hay tipo de fecha. Guarda las fechas como texto ISO 8601 (
'2026-11-15'o'2026-11-15 09:30:00'), que se ordena correctamente y funciona con las funcionesdate()ystrftime()de SQLite. - No hay tipo booleano. Usa
INTEGERcon0y1. - Dinero:
REALes un número de punto flotante, así que para montos exactos guarda centavos enteros comoINTEGER(1699 en lugar de 16.99).
Las Llaves Foráneas Están Desactivadas por Defecto
Esto sorprende a mucha gente. Por compatibilidad con versiones anteriores, SQLite no aplica las llaves foráneas a menos que las actives en cada conexión:
INSERT INTO books (title, author_id) VALUES ('Ghost Book', 99);
Sin la configuración, esto funciona aunque el autor 99 no exista. Con ella:
PRAGMA foreign_keys = ON;
INSERT INTO books (title, author_id) VALUES ('Ghost Book', 99);
Error: FOREIGN KEY constraint failed
Ejecuta PRAGMA foreign_keys = ON cada vez que abras una conexión, también en el código de tu aplicación. Las restricciones CHECK, en cambio, siempre se aplican: insertar un precio negativo en books falla con CHECK constraint failed: price >= 0.
Usar SQLite con Python
El módulo sqlite3 incluido en Python no necesita instalación. Guarda esto como books.py en la misma carpeta que library.db:
import sqlite3
conn = sqlite3.connect("library.db")
conn.row_factory = sqlite3.Row # access columns by name
conn.execute("PRAGMA foreign_keys = ON")
# Read: always pass values as parameters, never with f-strings
max_price = 17
rows = conn.execute(
"SELECT title, year, price FROM books WHERE price < ? ORDER BY price",
(max_price,),
).fetchall()
for row in rows:
print(f"{row['title']} ({row['year']}): ${row['price']:.2f}")
# Write: "with conn" commits on success and rolls back on error
with conn:
conn.execute(
"INSERT INTO books (title, author_id, year, price) VALUES (?, ?, ?, ?)",
("Fledgling", 3, 2005, 16.00),
)
count = conn.execute("SELECT COUNT(*) FROM books").fetchone()[0]
print(f"Books in the library: {count}")
conn.close()
Ejecútalo sobre la base de datos recién creada con setup.sql:
python3 books.py
Parable of the Sower (1993): $14.25
Kindred (1979): $15.00
The House of the Spirits (1982): $16.99
Books in the library: 6
Tres hábitos que vale la pena formar:
- Usa marcadores
?para los valores. Armar SQL con f-strings o+permite que lo que escribe el usuario cambie tu consulta, y así es como ocurre la inyección SQL. - Usa
with conn:para las escrituras. Confirma los cambios cuando el bloque termina bien y los revierte si ocurre un error. No cierra la conexión, así que igual llama aconn.close(). - Usa
executemany()para muchas filas, que es mucho más rápido que un ciclo de inserciones individuales:
new_authors = [("Toni Morrison", "United States"), ("Chimamanda Ngozi Adichie", "Nigeria")]
with conn:
conn.executemany("INSERT INTO authors (name, country) VALUES (?, ?)", new_authors)
Las Transacciones Protegen tus Datos
Si cualquier sentencia dentro de with conn: falla, todo el bloque se deshace:
import sqlite3
conn = sqlite3.connect("library.db")
conn.execute("PRAGMA foreign_keys = ON")
try:
with conn:
conn.execute("UPDATE books SET price = price * 1.10")
conn.execute("INSERT INTO books (title, author_id) VALUES (?, ?)", ("Ghost Book", 99))
except sqlite3.IntegrityError as error:
print(f"Rolled back: {error}")
print(conn.execute("SELECT price FROM books WHERE title = 'Kindred'").fetchone()[0])
conn.close()
Rolled back: FOREIGN KEY constraint failed
15.0
El aumento de precio se revirtió porque la inserción falló, así que Kindred sigue costando 15.0.
Para experimentos rápidos, sqlite3.connect(":memory:") crea una base de datos temporal en memoria que desaparece cuando termina el programa. Para cargar resultados de consultas en pandas, consulta Python para el Análisis de Datos: Cómo Acceder a Tus Datos.
Consultas Más Rápidas con Índices
Sin un índice, SQLite lee todas las filas para encontrar las coincidencias. EXPLAIN QUERY PLAN muestra lo que va a hacer:
EXPLAIN QUERY PLAN SELECT * FROM books WHERE author_id = 2;
QUERY PLAN
`--SCAN books
SCAN significa que lee la tabla completa. Agrega un índice en la columna por la que filtras:
CREATE INDEX idx_books_author ON books(author_id);
EXPLAIN QUERY PLAN SELECT * FROM books WHERE author_id = 2;
QUERY PLAN
`--SEARCH books USING INDEX idx_books_author (author_id=?)
SEARCH ... USING INDEX significa que SQLite va directo a las filas que coinciden. En una tabla con millones de filas, esa es la diferencia entre segundos y milisegundos. Crea índices en las columnas que usas seguido en WHERE, JOIN y ORDER BY, pero no en todas, porque cada índice hace un poco más lentas las escrituras. Por Qué Tu Consulta SQL Es Lenta lo explica con más detalle.
Mejor Concurrencia con el Modo WAL
De forma predeterminada, una escritura bloquea a los lectores mientras se guarda. El modo WAL (write-ahead logging) permite que los lectores sigan leyendo mientras un escritor escribe, lo que ayuda a las apps web y a todo lo que tenga tareas en segundo plano:
PRAGMA journal_mode = WAL;
wal
Esta configuración se guarda en el archivo de la base de datos, así que solo necesitas ejecutarla una vez. En modo WAL verás dos archivos extra junto a la base de datos (library.db-wal y library.db-shm); forman parte de la base de datos mientras está en uso, así que no los borres.
Respaldar una Base de Datos SQLite
Como la base de datos es un solo archivo, es tentador simplemente copiarlo. Eso solo es seguro cuando nada está escribiendo en él; copiar el archivo a mitad de una escritura (o copiarlo sin su archivo -wal) puede darte un respaldo dañado. Usa una de estas opciones:
# From the sqlite3 shell or the command line
sqlite3 library.db ".backup library-backup.db"
# Or with SQL: a compact, consistent copy
sqlite3 library.db "VACUUM INTO 'library-copy.db';"
Las dos funcionan mientras la base de datos está en uso. Revisa una copia con:
sqlite3 library-copy.db "PRAGMA integrity_check;"
ok
Desde Python, conn.backup() hace lo mismo. Como con cualquier base de datos, automatiza tus respaldos, guarda una copia fuera del equipo y prueba las restauraciones. La guía de respaldos de PostgreSQL explica la regla 3-2-1.
Errores Comunes que Debes Evitar
- Olvidar
PRAGMA foreign_keys = ON, y dejar que se cuelen referencias inválidas sin aviso. - Armar SQL con formato de cadenas en lugar de marcadores
?. - Olvidar confirmar los cambios. En Python, los cambios fuera de un bloque
with conn:no se guardan hasta que llamas aconn.commit(). - Poner la base de datos en una unidad de red o en una carpeta sincronizada en la que otros equipos escriben al mismo tiempo.
- Copiar el archivo mientras la app está escribiendo, o dejar atrás el archivo
-wal. - Guardar dinero como
REALcuando importan los montos exactos. - Esperar tipos estrictos sin usar tablas
STRICT.
Preguntas Frecuentes
¿SQLite es una base de datos de verdad?
Sí. Admite SQL estándar, transacciones, índices, restricciones, joins y funciones de ventana, y se usa en producción en miles de millones de dispositivos. Simplemente es embebida en lugar de cliente-servidor.
¿SQLite es gratis para uso comercial?
Sí. SQLite es de dominio público, así que puedes usarlo en cualquier proyecto, incluido software comercial, sin licencia ni atribución.
¿Qué tan grande puede ser una base de datos SQLite?
El límite teórico es de unos 281 terabytes. En la práctica, las bases de datos de muchos gigabytes funcionan bien; la concurrencia y los respaldos suelen preocupar antes que el tamaño.
¿Varios usuarios pueden usar SQLite al mismo tiempo?
Muchos usuarios pueden leer a la vez, pero solo una conexión puede escribir a la vez. Con el modo WAL y transacciones cortas, eso basta para la mayoría de las apps pequeñas y medianas. Para muchas escrituras simultáneas de varios usuarios, usa PostgreSQL o MySQL.
¿SQLite sirve para sitios web?
Para sitios con tráfico bajo o moderado, sobre todo los que se leen más de lo que se escriben, como blogs, sitios de pequeños negocios y herramientas internas, sí. El propio sitio web de SQLite funciona con SQLite. Para apps con mucho tráfico y muchas escrituras simultáneas, una base de datos de servidor es mejor opción.
¿SQLite es seguro?
No tiene usuarios ni contraseñas integrados; cualquiera que pueda leer el archivo puede leer los datos. Protégelo con permisos de archivo, mantenlo fuera de la carpeta pública de tu sitio web y usa cifrado de disco para los datos sensibles.
¿Cómo abro un archivo .db o .sqlite?
Ejecuta sqlite3 archivo.db en una terminal, ábrelo en DB Browser for SQLite o conéctate desde Python con sqlite3.connect("archivo.db").
Conclusión
SQLite te da una base de datos SQL completa en un solo archivo, sin nada que instalar ni administrar. Es la opción correcta para apps, prototipos, scripts, análisis de datos y sitios web pequeños y medianos, y una de las formas más fáciles de aprender SQL.
Empieza con el ejemplo de library.db: crea las tablas, ejecuta algunas consultas y luego conéctate desde Python. Recuerda los tres hábitos propios de SQLite: activa las llaves foráneas, usa marcadores ? y respalda con .backup o VACUUM INTO en lugar de copiar el archivo. Cuando tu app crezca a muchos escritores simultáneos, estarás listo para pasar a PostgreSQL con las mismas habilidades de SQL.
