Guía completa para crear una base de datos SQLite paso a paso

El almacenamiento y la gestión eficiente de la información son pilares fundamentales a la hora de desarrollar aplicaciones modernas, especialmente cuando se busca ligereza y rapidez en su funcionamiento. En el ecosistema de las bases de datos, SQLite se ha consolidado como una solución versátil, poderosa y muy sencilla de implementar, tanto en entornos de escritorio, móviles, como embebidos. A continuación, exploraremos de manera exhaustiva y paso a paso cómo crear, gestionar y optimizar una base de datos SQLite combinando las mejores prácticas, comandos clave, ejemplos prácticos y trucos útiles para que puedas exprimir todo su potencial.

Trabajar con SQLite no solo implica saber lanzar un «CREATE TABLE», sino que abarca desde la correcta instalación del software en diferentes sistemas operativos, el uso de comandos avanzados, la comprensión de los tipos de datos admitidos, hasta operaciones complejas como la gestión de transacciones, el diseño de índices, triggers, y la exportación o importación de datos en diversos formatos.

¿Qué es SQLite y por qué usarlo?

SQLite es un sistema gestor de bases de datos relacionales de código abierto, completamente libre de derechos de autor, lo que significa que puedes usarlo para cualquier fin —comercial o educativo— sin complicaciones. A diferencia de otros sistemas como MySQL o PostgreSQL, no necesita un servidor centralizado: toda la base de datos reside en un único archivo, lo que facilita enormemente su configuración, copia, migración y respaldo.

La portabilidad y versatilidad de SQLite la hacen ideal para aplicaciones que requieren almacenar y procesar datos de forma local, como programas de escritorio, apps móviles, sistemas embebidos, dispositivos IoT, pequeños sitios web o usos con fines educativos. Además, su pequeño tamaño y el escaso consumo de recursos lo hacen hasta adecuado para insertarlo en aplicaciones que ejecutan procesos críticos en hardware limitado.

Características principales de SQLite

• Serverless: No necesitas instalar ni mantener un servidor; funcionará automáticamente con solo crear o abrir un archivo de base de datos.
• Multiplataforma: Puedes emplear tu base de datos en Linux, Windows, MacOS e ir moviéndola entre sistemas sin problemas ni pérdida de datos.
• Ligero y autocontenible: Toda la arquitectura y lógica de base de datos está dentro de una sola librería fácil de enlazar con tu aplicación.
• Zero configuration: Crear y empezar a usar una base de datos SQLite generalmente solo requiere crear un archivo. Nada más.
• Transaccionalidad asegurada: A pesar de ser sencillo, soporta transacciones reales (ACID), permitiendo trabajar con datos de forma segura.
• Escalabilidad para proyectos pequeños o medianos: Aunque no está pensado para grandes despliegues empresariales concurrentes, responde con creces en proyectos individuales, prototipos y MVPs.

Usos recomendados de SQLite

• Aplicaciones de escritorio y móviles, por su facilidad de integración y mantenimiento.
• Sistemas embebidos e IoT: Cámaras, drones, relojes inteligentes, electrodomésticos conectados, etc.
• Desarrollo educativo y prototipado, por eliminar toda complicación asociada a configuración de servidores de bases de datos.
• Sitios webs de bajo-moderado tráfico, donde no es necesario asumir la complejidad de soluciones más grandes.
• Almacenamiento temporal en memoria, para realizar pequeñas pruebas o manejar datos que no requieran persistencia prolongada.

Consulta siempre la sección «Appropriate Uses For SQLite» en la web oficial para asegurarte de que se ajusta a tu caso práctico.

Instalando SQLite

El primer paso para trabajar con SQLite es instalar la utilidad sqlite3. Disponible tanto para sistemas GNU/Linux, como para Windows y MacOS, la instalación es directa. Te mostramos cómo hacerlo en los sistemas más comunes:

En Linux (Debian/Ubuntu)

Ejecuta el siguiente comando en tu terminal:

sudo apt-get install sqlite3 libsqlite3-dev

Una vez instalado, simplemente escribe sqlite3 en tu terminal para acceder a la interfaz interactiva.

En Windows

• Descarga los binarios precompilados desde la página oficial de SQLite (SQLite Download Page).
• Descomprime el archivo ZIP y copia los ejecutables (.exe) en la carpeta C:\Windows\System32 para tenerlos disponibles desde cualquier terminal.

En Mac OS X y otros sistemas

Puedes encontrar instaladores para Mac en la web oficial o usar herramientas como Homebrew para instalarlo desde terminal:

brew install sqlite

Para dispositivos Android, Windows Phone u otros entornos menos habituales, consulta la correspondiente.

Primeros pasos con sqlite3

Tras instalar la utilidad, podemos acceder al intérprete ejecutando desde el terminal:

sqlite3

Esto abrirá una nueva sesión donde podrás ejecutar comandos de administración y sentencias SQL para crear, modificar y consultar bases de datos.

Uso general de la consola

• .exit o .quit: Salir de la consola.
• .open nombrebd.db: Crear o abrir una base de datos existente.
• .databases: Listar bases de datos abiertas en la sesión actual.
• .tables: Listar tablas y vistas de la base de datos abierta.
• .schema: Mostrar el esquema (estructura) de una tabla.
• .help: Listar todos los comandos disponibles.

Estructura de una base de datos SQLite

Un archivo de base de datos SQLite puede contener varias tablas, que son la estructura básica de almacenamiento de datos. Cada tabla está formada por filas (llamadas registros) y columnas (campos, cada uno con su tipo de dato y posibles restricciones).

Tipos de datos básicos soportados:

• NULL: Valores nulos.
• INTEGER: Números enteros.
• REAL: Números reales (coma flotante).
• TEXT: Cadenas de texto.
• BLOB: Datos binarios, como imágenes o archivos en bruto.

SQLite permite gran flexibilidad con los tipos de datos: puedes guardar, por ejemplo, un texto en un campo definido como INTEGER, a excepción de los campos INTEGER PRIMARY KEY.

Almacenando fechas y horas

No existe un tipo de dato específico para fechas y horas en SQLite. Puedes almacenarlas de varias maneras:

• Como TEXT usando el formato ISO8601 (YYYY-MM-DD HH:MM:SS.SSS).
• Como REAL empleando el formato Juliano.
• Como INTEGER usando el número de segundos desde la ‘época UNIX’.

Creando una base de datos: métodos y ejemplos

Desde la consola sqlite3

Solo necesitas ejecutar:

sqlite3 nombrebd.db

Si el archivo nombrebd.db no existe, se creará uno nuevo; si existe, lo abrirás para trabajar sobre él.

Desde otros lenguajes de programación

Puedes interactuar con SQLite directamente desde lenguajes como Python, Node.js, Java, PHP, entre muchos más, usando las librerías adecuadas. Por ejemplo, en Node.js existen paquetes como sqlite y sqlite3, ambos fáciles de instalar y usar.

import { open } from "sqlite";
import sqlite3 from "sqlite3";

const db = await open({
  filename: "./database.db",
  driver: sqlite3.Database
});

El método anterior crea el archivo «database.db» si no existe, todo listo para empezar a operar.

Comandos principales de sqlite3

Comando	Descripción
.help	Muestra la lista de todos los comandos internos.
.quit	Sale del programa sqlite3.
.show	Visualiza parte de la configuración actual.
.databases	Lista todas las bases de datos adjuntas a la sesión actual.
.tables	Muestra todas las tablas y vistas de la base de datos.
.schema	Muestra el código SQL que define la estructura de una tabla, vista o índice.
.headers	Activa o desactiva los encabezados de columna en los resultados.
.mode	Configura el formato de salida (column, csv, html, insert, etc.).
.dump	Genera los comandos SQL para recrear una o más tablas (útil para backups).

Definiendo tablas y relaciones

Creación de tablas

Se utiliza la sentencia CREATE TABLE para definir tablas nuevas. Puedes especificar el nombre de cada campo, su tipo y reglas adicionales (NOT NULL, UNIQUE, AUTOINCREMENT, PRIMARY KEY, FOREIGN KEY…).

CREATE TABLE usuarios (
  id_usu INTEGER PRIMARY KEY AUTOINCREMENT,
  cta_usu TEXT UNIQUE,
  nombre TEXT NOT NULL,
  id_dpto INTEGER,
  ecorreo TEXT NOT NULL,
  FOREIGN KEY (id_dpto) REFERENCES dptos(id_dpto)
);

CREATE TABLE dptos (
  id_dpto INTEGER PRIMARY KEY AUTOINCREMENT,
  denom TEXT NOT NULL UNIQUE
);

La clave primaria (PRIMARY KEY) sirve para identificar de manera única cada fila, mientras que la clave externa (FOREIGN KEY) mantiene la integridad referencial, asegurando que los valores de ciertos campos coinciden con datos existentes en otras tablas.

Campos autoincrementados y restricciones

• AUTOINCREMENT: Hace que el valor del campo se incremente automáticamente cuando se introduce un nuevo registro.
• NOT NULL: No permite valores nulos.
• UNIQUE: Garantiza que el valor es único en todas las filas.
• DEFAULT: Permite fijar valores por defecto.

Operaciones básicas CRUD en SQLite

Insertar registros (INSERT)

INSERT INTO tabla1 (campo1, campo2) VALUES (dato1, dato2);
INSERT INTO tabla1 (campo1, campo2) VALUES (dato11, dato12), (dato21, dato22);
INSERT INTO tabla2 SELECT campo1, campo2 FROM tabla1;

Puedes insertar uno o varios registros a la vez, o volcar datos a partir de resultados de otras tablas.

Consultar información (SELECT)

SELECT campo1, campo2 FROM tabla1;
SELECT * FROM tabla1 WHERE campo1 = 100;
SELECT campo1 FROM tabla1 WHERE campo2 LIKE 'an%';
SELECT campo1, COUNT(campo2) FROM tabla1 GROUP BY campo3;

SELECT es la base de la consulta en SQL: permite filtrar, agrupar, ordenar, unir varias tablas, etc. Puedes emplear funciones de agregación, condicionales (CASE), y operadores (AND, OR, BETWEEN, LIKE, IN, EXISTS, etc.).

Actualizar datos (UPDATE)

UPDATE tabla1 SET campo1 = 'dato1' WHERE campo2 = 3;
UPDATE tabla1 SET campo1 = 'dato1', campo2 = 'dato2' WHERE campo3 = 3;

Permite modificar datos existentes cumpliendo ciertas condiciones. Ten precaución y utiliza siempre la cláusula WHERE para evitar cambiar todas las filas por accidente.

Borrar información (DELETE)

DELETE FROM tabla1 WHERE campo1 > 10;
DELETE FROM tabla1;

Borra filas completas o todas las filas de una tabla. Incluso puedes limitar a un número concreto de filas eliminadas con ORDER BY y LIMIT.

Reemplazar registros (REPLACE)

REPLACE INTO tabla1 (campo2, campo3) VALUES ('cadena1', 170000);

Si existe una restricción de PRIMARY KEY o UNIQUE, reemplazará el registro existente eliminándolo y creando uno nuevo.

Gestión avanzada de tablas

Claves primarias (PRIMARY KEY)

Permiten identificar unívocamente cada registro. En SQLite la columna de clave primaria suele ser INTEGER PRIMARY KEY y genera un campo rowid interno automáticamente salvo que uses WITHOUT ROWID.

Claves externas (FOREIGN KEY)

Una clave externa conecta dos tablas vinculando la columna de una con la PRIMARY KEY de otra. Esto permite aplicar integridad referencial (más información aquí).

CREATE TABLE tabla1 (
  campo1 INTEGER PRIMARY KEY AUTOINCREMENT,
  campo2 TEXT NOT NULL UNIQUE,
  campo3 INTEGER,
  FOREIGN KEY (campo3) REFERENCES tabla2(campo1)
);

Acciones disponibles: ON DELETE CASCADE, ON UPDATE NO ACTION, SET NULL, SET DEFAULT, RESTRICT o NO ACTION.

Recuerda que estas restricciones deben activarse mediante PRAGMA foreign_keys = ON; cada vez que inicies la sesión si no lo tienes configurado por defecto.

Cambiar la estructura de una tabla (ALTER TABLE)

ALTER TABLE tabla1 RENAME TO tabla1_anterior;
ALTER TABLE tabla1 ADD COLUMN campo4 INTEGER;

Puedes renombrar tablas o añadirles columnas. Asegúrate de definir valores por defecto si añades una columna NOT NULL.

Borrar tablas (DROP TABLE)

DROP TABLE tabla1;

Si hay restricciones de integridad activas y dependencias, asegúrate de desactivarlas antes si es necesario.

Operaciones avanzadas: vistas, índices y triggers

Vistas

Una vista es una consulta que se expone como si fuera una tabla, facilitando agrupación de datos complejos repetidos. Solo almacena la definición de la consulta, no los datos.

CREATE VIEW IF NOT EXISTS vista_usuarios_deptos AS
SELECT u.nombre, d.denom
FROM usuarios u
INNER JOIN dptos d ON u.id_dpto = d.id_dpto;

SELECT * FROM vista_usuarios_deptos;

Índices

Los índices aceleran las búsquedas y pueden asegurar unicidad. Está en tu mano crearlos para columnas o combinaciones de columnas según consultas habituales.

CREATE INDEX idx_usuarios_nombre ON usuarios(nombre);
CREATE UNIQUE INDEX idx_dptos_denom ON dptos(denom);

Puedes crear índices basados en expresiones, eliminar índices y comprobar su uso con EXPLAIN QUERY PLAN.

Triggers

Definen acciones que se lanzan automáticamente ante eventos como INSERT, UPDATE o DELETE. Muy útiles para verificar o auditar datos automáticamente.

CREATE TRIGGER validar_correo BEFORE INSERT ON usuarios
BEGIN
  SELECT CASE WHEN NEW.ecorreo NOT LIKE '%_@__%.__%' THEN RAISE (ABORT,'Correo incorrecto') END;
END;

Transacciones: seguridad y robustez

Realizar varias operaciones en bloque bajo una transacción garantiza que los cambios se aplican en conjunto o ninguno. Fundamental para la integridad:

BEGIN TRANSACTION;
UPDATE usuarios SET nombre = 'Ana' WHERE id_usu = 1;
INSERT INTO usuarios (cta_usu, nombre, ecorreo, id_dpto) VALUES ('jdoe', 'John Doe', '[email protected]', 2);
COMMIT;

-- Si algo falla, puedes hacer:
ROLLBACK;

Importar, exportar y respaldar tu base de datos

Exportar datos a CSV y otros formatos

.output usuarios.csv
.mode csv
.headers on
SELECT * FROM usuarios;

Puedes usar .mode column, .mode html y otros formatos para exportar los resultados a archivos compatibles o fácilmente convertibles.

Importar datos CSV

.mode csv
.import usuarios.csv usuarios

Recuerda limpiar previamente la tabla si quieres reimportar, para evitar duplicados (DELETE FROM usuarios;).

Backups y restauración completa

• Volcar tablas o toda la base de datos: .dump

.output backup.sql
.dump

• Restaurar una base de datos desde dump:

  sqlite3 nuevabasedatos.db < backup.sql
  

Optimización, mantenimiento y fiabilidad

Vaciar espacio libre y optimizar (VACUUM)

VACUUM;

Reorganiza la base de datos liberando bloques no utilizados, mejora la velocidad y reduce tamaño.

Optimización automática: PRAGMA auto_vacuum

PRAGMA auto_vacuum = FULL;
PRAGMA auto_vacuum = INCREMENTAL;
PRAGMA auto_vacuum = NONE;

Herramientas gráficas recomendadas

• DB Browser for SQLite: Multiplataforma, abierto y muy fácil de usar.
• SQLiteStudio: Otra gran opción multiplataforma.
• DBeaver: Soporta otras bases de datos además de SQLite.

También encontrarás extensiones para Visual Studio Code como SQLite Viewer para visualizar, consultar y gestionar tu base de datos de forma muy intuitiva.

Caso práctico completo: gestión de una base de datos de contactos

Vamos a ver el proceso real de crear, poblar y consultar una base de datos de contactos y grupos, con claves primarias y externas, vistas y comprobando la acción ON DELETE CASCADE.

1. Abrimos el gestor y creamos la base:

   sqlite3.open contactos.db

2. Definimos las tablas:

   CREATE TABLE contactos (
     contacto_id integer PRIMARY KEY,
     nombre text NOT NULL,
     apellido text NOT NULL,
     email text NOT NULL UNIQUE,
     movil text NOT NULL UNIQUE
   );
   CREATE TABLE grupos (
     grupo_id integer PRIMARY KEY,
     nombre text NOT NULL
   );
   CREATE TABLE contactos_grupos (
     contacto_id integer,
     grupo_id integer,
     PRIMARY KEY (contacto_id, grupo_id),
     FOREIGN KEY (contacto_id) REFERENCES contactos (contacto_id) ON DELETE CASCADE ON UPDATE NO ACTION,
     FOREIGN KEY (grupo_id) REFERENCES grupos (grupo_id) ON DELETE CASCADE ON UPDATE NO ACTION
   );
   

3. Insertamos registros de prueba:

   INSERT INTO grupos (grupo_id, nombre) VALUES (1, "amigos"), (2, "trabajo"), (3, "asociacion");
   INSERT INTO contactos (contacto_id, nombre, apellido, email, movil) VALUES (1, "Luis", "Carranza", "[email protected]","123234345");
   INSERT INTO contactos (contacto_id, nombre, apellido, email, movil) VALUES (2, "Clara", "Campoamor", "[email protected]","455555655");
   INSERT INTO contactos (contacto_id, nombre, apellido, email, movil) VALUES (3, "Dolores", "Fuertes", "[email protected]","155155155");
   INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (1, 1), (2, 1), (1, 3), (3, 3), (1, 2), (2, 2), (3, 2);
   

4. Eliminamos un grupo y observamos la "cascada":

   DELETE FROM grupos WHERE grupo_id = 3;

5. Consultamos todos los registros vinculados con vistas:

   CREATE VIEW vista_contactos AS
   SELECT contactos.nombre AS nombrec, apellido, email, grupos.nombre AS nombreg
   FROM contactos
   INNER JOIN contactos_grupos ON contactos.contacto_id = contactos_grupos.contacto_id
   INNER JOIN grupos ON grupos.grupo_id = contactos_grupos.grupo_id;
   SELECT * FROM vista_contactos;
   

[relacionado url="https://www.polimetro.com/como-crear-un-usuario-en-google-scholar/"]