SQLite para principiantes: una base de datos integrada que siempre está contigo

Imagina: estás escribiendo una aplicación y necesitas una base de datos. Por lo general, esto significa instalar MySQL o PostgreSQL, configurar el servidor, crear usuarios, configurar la seguridad... ¡Para! ¿Y si te digo que hay una base de datos que funciona sin todo esto?

Te presentamos SQLite. No es solo una alternativa ligera, es un enfoque completamente diferente para trabajar con datos. Y si eres un desarrollador novato, SQLite puede convertirse en tu mejor amigo al inicio de tu carrera.

Qué es SQLite y por qué es especial

SQLite es una base de datos relacional integrada. Pero, ¿qué significa «incorporada»? A diferencia de MySQL o PostgreSQL, que funcionan como servidores independientes, SQLite es simplemente una biblioteca que conectas a tu aplicación. Toda la base de datos se almacena en un archivo en el disco.

¿Suena fácil? Porque lo es. SQLite no requiere instalación de servidor, configuración de puertos o creación de usuarios. Simplemente crea un archivo con la extensión .db o .sqlite y tendrás una base de datos completa.

Esto es lo que hace que SQLite sea único: es la base de datos más extendida del mundo. Está integrada en todos los teléfonos inteligentes Android e iOS, en los navegadores Chrome y Firefox, en los sistemas operativos Windows y macOS. Según los desarrolladores, hay más de un billón de bases de datos SQLite activas. Sí, un billón, con doce ceros.

Dónde se utiliza SQLite

SQLite es excelente para tareas en las que no se requiere trabajo multiusuario a nivel de base de datos. Se trata de aplicaciones de escritorio, aplicaciones móviles, sistemas integrados, prototipos de aplicaciones web, almacenamiento local de datos en navegadores.

¿Ejemplos concretos?

Los mensajeros como WhatsApp usan SQLite para almacenar el historial de correspondencia en su teléfono. Los navegadores almacenan marcadores, historial y cookies en SQLite. Los juegos guardan el progreso del jugador en SQLite. Incluso Dropbox usa SQLite para sincronizar los metadatos de los archivos.

¿Cuándo no es adecuado SQLite?

Si tienes un servicio web de alta carga con miles de conexiones simultáneas, es mejor elegir PostgreSQL. Si necesitas replicar datos entre servidores, SQLite no lo hará. Si los datos se miden en terabytes, busca otras soluciones.

Instalación y primeros pasos

Buenas noticias: es posible que SQLite ya esté instalado en tu ordenador. Abre la terminal e introduce el comando sqlite3 --version. ¿Has visto la versión? Genial, puedes empezar a trabajar.

Si SQLite no está instalado, el proceso de instalación tarda un minuto. En Windows, descarga los binarios precompilados del sitio web oficial. En Linux, usa el administrador de paquetes: sudo apt install sqlite3 para Ubuntu o sudo yum install sqlite para CentOS. En macOS, SQLite suele estar preinstalado, pero se puede actualizar a través de Homebrew con el comando brew install sqlite3.

Vamos a crear la primera base de datos. Abre la terminal e introduce el comando sqlite3 myapp.db. Verás una invitación de SQLite con el prefijo sqlite>. Felicidades, acabas de crear una base de datos. Sí, fue así de fácil.

Conceptos básicos de la línea de comandos

SQLite tiene un intérprete de comandos con comandos útiles. Todos los comandos especiales comienzan con un punto. El comando .help mostrará una lista de comandos disponibles. El comando .databases mostrará las bases de datos conectadas. El comando .tables mostrará todas las tablas de la base de datos actual. El comando .schema mostrará la estructura de todas las tablas. El comando .quit o .exit finalizará el trabajo con SQLite.

Intentemos crear la primera tabla. Digamos que estamos haciendo una aplicación para el seguimiento de tareas:

CREATE TABLE tasks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    title TEXT NOT NULL,
    description TEXT,
    completed INTEGER DEFAULT 0,
    created_at TEXT DEFAULT CURRENT_TIMESTAMP
);

¿Qué está pasando aquí? Creamos una tabla con cinco columnas. La columna id es una clave primaria autoincrementable, se generará automáticamente. Columna title — texto, campo obligatorio. Columna description: texto, puede estar vacío. Columna completed — número, por defecto 0 (usado como bandera booleana). Columna created_at — texto, se rellena automáticamente con la fecha actual.

Preste atención a los tipos de datos. SQLite utiliza la tipificación dinámica y admite cinco tipos básicos de almacenamiento: NULL (sin valor), INTEGER (números enteros), REAL (números de punto flotante), TEXT (cadenas de texto) y BLOB (datos binarios). Esto es más fácil que en otras bases de datos, pero es suficiente para la mayoría de las tareas.

Operaciones básicas con datos

Ahora añadamos algunas tareas a nuestra tabla:

INSERT INTO tasks (title, description) 
VALUES ('Learn SQLite', 'Read the article and try the examples');

INSERT INTO tasks (title, description) 
VALUES ('Write code', 'Create a simple application with SQLite');

INSERT INTO tasks (title) 
VALUES ('Mark task as completed');

Veamos qué ha pasado:

SELECT * FROM tasks;

Verás tres entradas con ID generados automáticamente y fechas de creación. Tenga en cuenta que en la tercera entrada, el campo description será NULL, no lo hemos especificado.

Marquemos la primera tarea como completada:

UPDATE tasks 
SET completed = 1 
WHERE id = 1;

Ahora seleccionemos solo las tareas pendientes:

SELECT id, title, completed 
FROM tasks 
WHERE completed = 0;

Y si necesitas eliminar una tarea:

DELETE FROM tasks 
WHERE id = 3;

Estas cuatro operaciones - SELECT, INSERT, UPDATE, DELETE - forman la base para trabajar con cualquier base de datos relacional. La sintaxis de SQLite es casi idéntica a la de SQL estándar, por lo que el conocimiento se transfiere fácilmente a otros SGBD.

Trabajar con SQLite desde Python

La mejor parte de SQLite es que el soporte está integrado directamente en la biblioteca estándar de Python. No es necesario instalar paquetes adicionales: el módulo sqlite3 ya está disponible.

Aquí tienes un ejemplo mínimo de trabajo:

import sqlite3

# Conectando a la base de datos (el archivo se creará automáticamente)
conn = sqlite3.connect('myapp.db')
cursor = conn.cursor()

# Crear una tabla
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        username TEXT NOT NULL UNIQUE,
        email TEXT NOT NULL,
        created_at TEXT DEFAULT CURRENT_TIMESTAMP
    )
''')

# Añadir usuario
cursor.execute(
    'INSERT INTO users (username, email) VALUES (?, ?)',
    ('john_doe', 'john@example.com')
)

# Guardando los cambios
conn.commit()

# Obteniendo todos los usuarios
cursor.execute('SELECT * FROM users')
users = cursor.fetchall()

for user in users:
    print(f"ID: {user[0]}, Username: {user[1]}, Email: {user[2]}")

# Cerrando la conexión
conn.close()

Preste atención a los signos de interrogación en la consulta INSERT. Estos son marcadores de posición para los parámetros, la forma correcta de pasar datos a las consultas SQL. Nunca uses cadenas f o concatenación para insertar datos en SQL, esto abre la puerta a las inyecciones SQL.

Una forma más cómoda de trabajar es utilizar el gestor contextual:

import sqlite3

with sqlite3.connect('myapp.db') as conn:
    cursor = conn.cursor()
    
    # Obtenemos resultados como diccionarios en lugar de tuplas
    conn.row_factory = sqlite3.Row
    
    cursor.execute('SELECT * FROM users WHERE username = ?', ('john_doe',))
    user = cursor.fetchone()
    
    if user:
        print(f"User found: {user['username']}, {user['email']}")

La construcción with cerrará automáticamente la conexión y guardará los cambios. Y row_factory = sqlite3.Row permite acceder a las columnas por nombre en lugar de por índice, lo que es mucho más cómodo.

Trabajar con SQLite desde JavaScript

En Node.js, la biblioteca más popular para trabajar con SQLite es better-sqlite3. Es síncrona y muy rápida.

Primero instalamos el paquete:

npm install better-sqlite3

Ahora podemos trabajar con la base:

const Database = require('better-sqlite3');
const db = new Database('myapp.db');

// Crear una tabla
db.exec(`
    CREATE TABLE IF NOT EXISTS products (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        price REAL NOT NULL,
        stock INTEGER DEFAULT 0
    )
`);

// Solicitud preparada para insertar
const insert = db.prepare(
    'INSERT INTO products (name, price, stock) VALUES (?, ?, ?)'
);

// Añadimos varios productos
const products = [
    ['Laptop', 45999.99, 5],
    ['Mouse', 599.00, 20],
    ['Keyboard', 1299.00, 15]
];

for (const product of products) {
    insert.run(product);
}

// Recibimos todos los productos
const allProducts = db.prepare('SELECT * FROM products').all();
console.log('All products:', allProducts);

// Recibimos un producto
const laptop = db.prepare('SELECT * FROM products WHERE name = ?').get('Laptop');
console.log('Product found:', laptop);

// Cerramos la base de datos
db.close();

La ventaja de better-sqlite3 es que es síncrono: no es necesario lidiar con promesas y async/await para operaciones simples. Para escenarios más complejos, el navegador utiliza Web SQL (obsoleto) o IndexedDB, que funcionan según principios diferentes.

Consejos prácticos y mejores prácticas

Primera regla: siempre use transacciones para múltiples operaciones relacionadas. Esto no solo garantiza la integridad de los datos, sino que también acelera significativamente el trabajo:

conn = sqlite3.connect('myapp.db')
cursor = conn.cursor()

try:
    cursor.execute('BEGIN TRANSACTION')
    
    # Múltiples operaciones de inserción
    for i in range(1000):
        cursor.execute('INSERT INTO logs (message) VALUES (?)', (f'Log {i}',))
    
    cursor.execute('COMMIT')
except Exception as e:
    cursor.execute('ROLLBACK')
    print(f'Error: {e}')
finally:
    conn.close()

Sin una transacción, mil inserciones pueden tardar varios segundos. Con una transacción, una fracción de segundo.

Segundo consejo: usa índices para las columnas que se solicitan con frecuencia. Si buscas usuarios por correo electrónico con frecuencia, crea un índice:

CREATE INDEX idx_users_email ON users(email);

Los índices aceleran las consultas SELECT, pero ralentizan INSERT y UPDATE. Úsalos con sensatez.

Tercer punto: utilice regularmente el comando VACUUM para optimizar la base de datos. SQLite no libera espacio automáticamente al eliminar registros:

VACUUM;

Este comando reconstruye la base de datos, liberando espacio no utilizado y optimizando la estructura del archivo.

Cuarto: haz copias de seguridad. SQLite es solo un archivo, por lo que la copia de seguridad es básica. Simplemente copie el archivo .db a un lugar seguro. Pero hazlo cuando la base de datos no esté en uso activo, o usa comandos especiales para copias de seguridad en línea.

Restricciones que debes conocer

SQLite es genial, pero tiene sus limitaciones. El tamaño de la base de datos teóricamente puede alcanzar los 281 terabytes, pero en la práctica se recomienda no exceder los pocos gigabytes. SQLite utiliza el bloqueo a nivel de toda la base de datos: al escribir, otros procesos no pueden leer. Esto es normal para aplicaciones locales, pero no para servidores de alta carga.

No hay soporte integrado para usuarios y derechos de acceso: la seguridad se proporciona a nivel del sistema de archivos. No hay replicación ni agrupación en clústeres de fábrica. Faltan algunas funciones avanzadas de SQL, como las funciones de ventana (aunque el soporte básico ha aparecido en las nuevas versiones).

Pero para el 90% de las tareas de un desarrollador novato, estas limitaciones no son críticas. SQLite es la herramienta perfecta para aprender, crear prototipos y crear aplicaciones locales.

Herramientas para trabajar con SQLite

La línea de comandos es buena, pero a veces se desea una interfaz visual. Hay muchas herramientas GUI para SQLite. DB Browser for SQLite es una herramienta multiplataforma de código abierto gratuita, ideal para principiantes. SQLiteStudio es otra opción gratuita con soporte para complementos. Para los profesionales, está DataGrip de JetBrains o extensiones para VS Code como SQLite Viewer.

Personalmente, recomiendo comenzar con DB Browser: es intuitivo, te permite crear tablas visualmente, ver datos en forma de tabla, ejecutar consultas SQL con resaltado de sintaxis y exportar datos a varios formatos.

Tarea práctica

La mejor manera de aprender es practicar. Intenta crear una aplicación sencilla para el seguimiento de gastos. La base de datos debe contener una tabla con gastos (fecha, categoría, importe, descripción) y una tabla con categorías (nombre, color para visualización). Implementa la adición de un nuevo gasto, la visualización de todos los gastos de un período determinado, la agrupación de gastos por categorías y el cálculo del importe total.

Este es un proyecto pequeño, pero cubrirá todas las operaciones principales de la base de datos y te dará experiencia práctica con SQLite.

Conclusión

SQLite no es solo una base de datos para principiantes. Es una herramienta poderosa que se utiliza en la producción de millones de aplicaciones. La facilidad de instalación y uso lo hace ideal para el aprendizaje, y la fiabilidad y el rendimiento lo convierten en una excelente opción para proyectos reales.

Comienza con SQLite, domina los conceptos básicos de las bases de datos, comprende los principios de SQL y luego la transición a PostgreSQL o MySQL será simple y natural. Después de todo, los conceptos son los mismos en todas partes, solo cambia la escala y la cantidad de funciones adicionales.

Así que instala SQLite, crea tus primeras tablas y empieza a experimentar. Es más fácil de lo que parece y más interesante de lo que se puede imaginar.

Kodik — plataforma educativa para programadores principiantes con cursos de Python, JavaScript y desarrollo web.

Únete a nuestro Comunidad de Telegram desarrolladores, donde puedes hacer preguntas, obtener ayuda con el código y encontrar personas de ideas afines para aprender juntos.