Qué es SQLite y cómo usarlo

¿Qué es SQLite?

SQLite es una base de datos relacional embebida.

Eso significa que:

No hay un servidor que levantar ni administrar.
Toda la base de datos vive en un único archivo .sqlite o .db que se puede mover, copiar, versionar o subir a un repositorio.
La base usa el lenguaje SQL estándar, así que lo que aprendas aquí te servirá también para otros sistemas como PostgreSQL o MySQL.

Cuando ejecutas SQLite, no estás “conectándote a un servidor”, simplemente estás leyendo y escribiendo en un fichero con un motor SQL incluido dentro de tu aplicación.

Esto lo convierte en una herramienta ligera, rápida y perfecta para proyectos pequeños y medianos.

Ejemplos reales donde se usa SQLite:

Apps móviles (iOS y Android lo usan bajo el capó).
Navegadores (Chrome, Firefox guardan tu historial en SQLite).
Aplicaciones de escritorio (VSCode, Discord, Spotify, etc.).
Prototipos de APIs y proyectos personales.
Aplicaciones edge/serverless (ej: Cloudflare D1, Vercel KV+SQLite).

SQLite vs otros motores

Para entender bien qué vas a aprender, vale la pena compararlo brevemente con los sistemas más conocidos:

Característica	SQLite	PostgreSQL / MySQL
Instalación	Muy simple	Requiere instalar servidor
Arquitectura	Embebida (archivo único)	Cliente-servidor
Ideal para…	Prototipos, apps locales	Apps empresariales, multiusuario
Concurrencia	Limitada pero eficiente	Alta (múltiples conexiones)
Administración	Mínima	Completa y compleja
Rendimiento	Muy alto para lecturas	Muy alto, más escalable
Despliegue	Copiar un archivo	Configurar servidor

Importante: SQLite no es “inferior” a otros motores.

Es la herramienta adecuada para el tamaño adecuado del problema.

Instalación rápida en tu entorno local

Vamos a usar VSCode + SQLite CLI.

Instalar SQLite CLI en Windows

Descargar los Binarios de SQLite

Ve al sitio web oficial de SQLite y descarga los archivos precompilados para Windows.

Visita la página de descargas oficial: Busca la sección "Precompiled Binaries for Windows".
Descarga los archivos clave: Necesitas descargar al menos estos dos archivos ZIP (la versión de 64 bits es la más común en Windows 11):
- sqlite-dll-win-x64-...zip: Contiene la DLL necesaria para que las aplicaciones de Windows accedan a SQLite.
- sqlite-tools-win-x64-XXXXXXX.zip (o similar, la x64 indica 64 bits).

Configurar el Entorno

Para que puedas ejecutar sqlite3.exe desde cualquier parte de tu sistema, es mejor colocarlo en una carpeta sencilla y añadirla a la variable de entorno PATH.

Crear una Carpeta: Crea una carpeta simple en la raíz de tu disco C:, por ejemplo: C:\sqlite.
Descomprimir: Descomprime los contenidos de los archivos ZIP que descargaste (sqlite3.exe, sqlite3.dll y otros archivos de las herramientas) dentro de C:\sqlite.
Añadir al PATH (Opcional, pero Recomendado):
- En buscar de Windows y escribe editar variables de entorno.
- Haz clic en "Editar las variables de entorno del sistema".
- En la ventana de Propiedades del Sistema, haz clic en el botón "Variables de entorno".
- En la sección Variables de usuario o Variables del sistema, selecciona la variable Path y haz clic en "Editar".
- Haz clic en "Nuevo" y añade la ruta que creaste: C:\sqlite.
- Haz clic en "Aceptar" en todas las ventanas.

Ejecutar y Usar SQLite

Ahora puedes abrir el intérprete de SQLite desde la línea de comandos (Símbolo del Sistema o PowerShell).

Abrir la Terminal: Presiona la tecla de Windows y escribe cmd o PowerShell para abrir la terminal.mi-academia.db
Verificar la Instalación: Escribe el siguiente comando y presiona Enter:Bash

sqlite3 -version

Si ves el número de versión, la instalación fue exitosa.
Crear o Abrir una Base de Datos: Para comenzar a usar SQLite, simplemente escribe sqlite3 seguido del nombre que deseas darle a tu archivo de base de datos.Bash

sqlite3 mi_academia.db
- Si el archivo mi_academia.db no existe, SQLite lo creará.
- Si ya existe, SQLite lo abrirá.
Empezar a Programar: Ya estás dentro del intérprete de SQLite. Puedes empezar a crear tablas y hacer consultas con comandos SQL.SQL

-- Dentro del intérprete de SQLite:
CREATE TABLE Alumno (id INTEGER PRIMARY KEY, nombre TEXT);
.tables
.quit

VSCode y extensiones útiles

Abre VSCode y asegúrate de instalar estas extensiones:

SQLite Viewer (alexcvzz) → para explorar archivos .db gráficamente.
SQLTools + “SQLite driver” → si prefieres autocompletado y consultas dentro de VSCode.
(Opcional) Dracula Theme → para trabajar más cómodo.

También puedes usar la terminal integrada de VSCode para ejecutar comandos sqlite3.

Conectar SQLite con Node.js usando ES Modules

Hasta ahora has visto cómo usar SQLite desde su consola CLI, pero en los proyectos reales vas a querer acceder a la base de datos desde tu código JavaScript.

En Node.js existen actualmente tres formas principales de trabajar con SQLite:

Usando la librería clásica sqlite3
Usando la librería moderna y muy rápida better-sqlite3
Usando el nuevo módulo oficial node:sqlite (experimental)

A continuación verás cómo instalar cada una, cómo abrir una base de datos y cómo hacer una consulta mínima de prueba.

Todas las muestras están escritas en ES Modules, que es el estilo moderno:

// package.json
{
  "type": "module"
}

Antes de empezar: tu archivo .db

Asegúrate de tener un archivo SQLite, por ejemplo:

/data/mi_base.db

Si no existe, SQLite lo creará automáticamente al usarlo desde Node.

Usar la librería `sqlite3`

Esta es la librería más antigua y conocida. Funciona bien, pero usa callbacks y es menos cómoda.

Instalación

npm install sqlite3

Ejemplo básico en ES Modules

// db-sqlite3.js
// ---
// Este archivo es un ejemplo básico de cómo conectar y ejecutar una consulta simple
// en una base de datos SQLite utilizando el paquete 'sqlite3' de Node.js.

// 1. Importación del Módulo y Configuración
// ----------------------------------------

// Importamos el objeto 'sqlite3' desde el módulo instalado.
// Este objeto contiene las clases y métodos necesarios para interactuar con SQLite.
import sqlite3 from "sqlite3";

// Llamamos a la función 'verbose()' en el objeto sqlite3.
// Esto activa el modo detallado (verbose) del módulo.
// En este modo, se imprimen mensajes útiles en la consola durante las operaciones de la base de datos,
// lo que facilita la depuración y el seguimiento de lo que está sucediendo internamente.
sqlite3.verbose();

// 2. Conexión a la Base de Datos
// ------------------------------

// Abrir la base de datos (conectar).
// Creamos una nueva instancia de la clase 'Database' de sqlite3.
// El constructor toma la ruta del archivo de la base de datos como argumento.
// Si el archivo './data/mi_base.db' no existe, SQLite lo creará automáticamente.
// El objeto 'db' es ahora el manejador de la conexión a nuestra base de datos.
const db = new sqlite3.Database("./data/mi_base.db");

// 3. Ejecución de una Consulta
// -----------------------------

// Consulta de prueba: Seleccionar la versión de SQLite para verificar la conexión.
// Usamos el método 'db.all()' para ejecutar una consulta SELECT.
// El método 'all' está diseñado para recuperar TODAS las filas que cumplan con la consulta.
// 
// Primer argumento: La sentencia SQL a ejecutar.
// Segundo argumento (callback): Una función que se llama cuando la consulta termina.
//   - El primer parámetro 'err' contendrá un objeto de error si la consulta falla.
//   - El segundo parámetro 'rows' es un array de objetos JavaScript que representan las filas del resultado.
db.all("SELECT sqlite_version() AS version", (err, rows) => {
    // 
    // Manejo de errores:
    // Si 'err' no es null, significa que algo salió mal al ejecutar la consulta (por ejemplo, error de sintaxis SQL).
    if (err) {
        console.error("Error al ejecutar la consulta:", err);
        // Devolvemos (return) para detener la ejecución en caso de error.
        return;
    }
    
    // 
    // Procesamiento de resultados:
    // Si no hay errores, 'rows' es un array. Para esta consulta, solo hay una fila, 
    // y esa fila tiene una columna llamada 'version'.
    // Accedemos a la primera (y única) fila (rows[0]) y a su propiedad 'version'.
    console.log("Versión de SQLite conectada:", rows[0].version);
});

// 4. Cierre de la Conexión
// -------------------------

// Cerrar la base de datos.
// Llamamos al método 'db.close()' para finalizar la conexión a la base de datos.
// Es crucial cerrar la base de datos para liberar los recursos del sistema
// y asegurar que todas las operaciones pendientes (como COMMITs) se completen correctamente.
// Nota: La consulta 'db.all()' es asíncrona. El módulo 'sqlite3' está diseñado para 
// esperar a que todas las consultas en cola se completen antes de cerrar la conexión 
// de forma segura al llamar a 'db.close()'.
db.close();

// Fin del script.

Pros y contras breves

Pros: Muy usada, funciona en todas partes.
Contras: Sintaxis con callbacks; menos intuitiva para código moderno.

Usar la librería `better-sqlite3`

Es la librería más rápida y sencilla para proyectos pequeños y medianos.

Funciona en modo síncrono, pero es muy eficiente y perfecta para un backend sin framework.

Instalación

npm install better-sqlite3

Ejemplo básico en ES Modules

// db-better.js
// ---
// Este archivo demuestra cómo conectar y ejecutar una consulta simple
// utilizando el paquete 'better-sqlite3', que ofrece una API síncrona y simplificada.

// 1. Importación del Módulo
// -------------------------

// Importamos la clase 'Database' del módulo 'better-sqlite3'.
// Nótese que se importa directamente la clase principal, no el objeto global como en 'sqlite3'.
import Database from "better-sqlite3";

// 2. Conexión a la Base de Datos
// ------------------------------

// Abrir la base de datos (conectar).
// Creamos una nueva instancia de 'Database'. Esta operación es SÍNCRONA, 
// lo que significa que el código se detiene aquí hasta que la conexión se establece.
// Esto simplifica el flujo de control, ya que no se necesita una función callback.
// Si el archivo './data/mi_base.db' no existe, 'better-sqlite3' lo crea automáticamente.
const db = new Database("./data/mi_base.db");

// 3. Preparación de la Consulta
// ------------------------------

// Preparamos la sentencia SQL.
// El método 'db.prepare()' compila la sentencia SQL una sola vez. Esto es más eficiente,
// especialmente si la consulta se va a ejecutar varias veces.
// La sentencia preparada (objeto 'Statement') se almacena en la variable 'stmt' (aunque aquí se usa 'row' directamente).
const stmt = db.prepare("SELECT sqlite_version() AS version");

// 4. Ejecución de la Consulta
// ---------------------------

// Ejecutamos la sentencia preparada para obtener una única fila.
// El método '.get()' en una sentencia preparada ejecuta la consulta y devuelve
// la PRIMERA fila del resultado como un objeto JavaScript. Si no hay resultados, devuelve 'undefined'.
// Esta llamada también es SÍNCRONA, por lo que el resultado (la fila) está disponible inmediatamente.
const row = stmt.get();
// Para hacerlo más conciso, como en tu código original, se puede encadenar:
// const row = db.prepare("SELECT sqlite_version() AS version").get();

// Imprimimos el resultado. Accedemos directamente a la propiedad 'version' de la fila obtenida.
console.log("Versión de SQLite:", row.version);

// 5. Cierre de la Conexión
// -------------------------

// Cerrar la base de datos.
// Llamamos al método 'db.close()' para finalizar la conexión.
// Al igual que la conexión, este método es SÍNCRONO.
// Es importante llamar a 'close()' para liberar el recurso de archivo.
db.close();

// Fin del script.

Pros y contras breves

Pros: Muy fácil de usar, muy rápida, sintaxis limpia.
Contras: No apta si necesitas operaciones totalmente asíncronas con miles de hilos (no es tu caso).

Recomendación para empezar: esta es la mejor opción.

3. Usar el módulo oficial `node:sqlite`

(experimental, Node 22+)

Node está introduciendo un módulo propio llamado node:sqlite.

Todavía es experimental, pero representa el futuro del acceso a SQLite en Node.

No necesitas instalar nada.

Ejemplo básico en ES Modules

// db-node-sqlite.js
// ---
// Este script utiliza el módulo 'node:sqlite' (del paquete @sqlite/sqlite3)
// que envuelve al driver 'sqlite3' para proporcionar una API moderna basada en Promesas.
// Esto permite usar la sintaxis 'async/await' para manejar operaciones asíncronas de manera secuencial y legible.

// 1. Importación de Módulos
// -------------------------

// Importamos la función 'open' desde 'node:sqlite'.
// Esta función es una utilidad clave que maneja la apertura de la base de datos de forma asíncrona.
import { open } from "node:sqlite";

// Importamos el driver base, 'sqlite3'.
// 'node:sqlite' necesita saber qué driver subyacente usar para la comunicación real con la DB.
import sqlite3 from "sqlite3";

// 2. Conexión a la Base de Datos (Asíncrona)
// ------------------------------------------

// Abrimos la base de datos usando 'await'.
// La función 'open' devuelve una Promesa que resuelve en el objeto de conexión 'db'.
// El objeto de configuración indica:
//   - filename: La ruta al archivo de la base de datos.
//   - driver: La clase del driver que se debe usar (sqlite3.Database).
// Como esta operación es asíncrona, usamos 'await' para pausar la ejecución hasta que la conexión esté lista.
const db = await open({
    filename: "./data/mi_base.db",
    driver: sqlite3.Database
});

// 3. Ejecución de la Consulta (Asíncrona)
// ---------------------------------------

// Ejecutamos una consulta para obtener una única fila.
// El método 'db.get()' es el equivalente basado en Promesas del 'db.get()' con callback del driver original.
// Al usar 'await', el código espera de forma no bloqueante a que la base de datos
// devuelva la fila resultante y la almacena en la variable 'row'.
const row = await db.get("SELECT sqlite_version() AS version");

// Imprimimos el resultado.
// Si la consulta fue exitosa, 'row' contendrá el objeto { version: <número> }.
console.log("Versión de SQLite:", row.version);

// 4. Cierre de la Conexión (Asíncrono)
// ------------------------------------

// Cerramos la conexión a la base de datos.
// 'db.close()' es también una función asíncrona y debe ser precedida por 'await'
// para asegurar que el cierre se complete antes de que el script finalice.
await db.close();

// Fin del script.

Pros y contras breves

Pros: API moderna basada en Promises.
Contras: Es experimental y puede cambiar; no recomendable en producción todavía.

¿Cuál deberías usar como principiante?

La opción más sencilla, moderna y estable hoy es better-sqlite3.

No necesita callbacks
Sintaxis clara
Muy rápida
Perfecta para proyectos personales o primeras APIs

Herramientas Gráficas Populares para SQLite

Estas aplicaciones te permiten ver esquemas, crear/modificar tablas, ejecutar consultas SQL y ver los datos de forma visual.

1. DB Browser for SQLite (Recomendado)

Es la herramienta más popular, gratuita, de código abierto y fácil de usar para principiantes.

Características:
- Navegación de Datos: Permite ver, editar y añadir datos directamente en las celdas, como una hoja de cálculo.
- Diseño de Tablas: Ofrece una interfaz visual para crear y modificar tablas, índices y vistas.
- Ejecución de SQL: Tiene una pestaña dedicada para escribir y ejecutar consultas SQL complejas.
- Descarga la versión app para windows si no quieres instalar y cambiar el registro.

2. SQLiteStudio

Otra aplicación de código abierto y multiplataforma muy completa y popular.

Características: Es muy fácil de usar y soporta funcionalidades avanzadas como la importación/exportación de datos y la visualización de relaciones entre tablas.

3. Extensiones de VS Code

Si utilizas VS Code para tu desarrollo, puedes gestionar bases de datos SQLite directamente dentro del entorno sin cambiar de aplicación.

SQLite Viewer / SQLite Explorer: Son extensiones muy populares que te permiten explorar, consultar y modificar archivos .db de SQLite directamente en la barra lateral del editor.

Buenas prácticas iniciales

Guarda tus archivos .db fuera de las carpetas temporales.
Haz copias de seguridad (un simple cp o Ctrl+C + Ctrl+V es suficiente).
No uses SQLite si tu app necesita miles de usuarios escribiendo a la vez.
No abras el mismo .db en varias herramientas en modo escritura simultánea.
Usa un naming claro para tus archivos .db (ej. ventas_2025.db).

Errores comunes (y cómo evitarlos)

“no such table” → te faltó crear la tabla antes de insertar.
“database is locked” → estás intentando escribir desde varias sesiones a la vez.
“UNIQUE constraint failed” → intentaste insertar un dato duplicado en una columna única.
“syntax error” → SQLite es estricto con comas y paréntesis; revisa bien tu SQL.

Conclusión

En este punto ya:

Sabes qué es SQLite y por qué es tan usado.
Lo tienes instalado y corriendo en tu máquina.
Has creado y consultado tu primera base.
Entiendes su naturaleza embebida y sus límites.

¿Qué es SQLite?​

SQLite vs otros motores​

Instalación rápida en tu entorno local​

Instalar SQLite CLI en Windows​

Descargar los Binarios de SQLite​

Configurar el Entorno​

Ejecutar y Usar SQLite​

VSCode y extensiones útiles​

Conectar SQLite con Node.js usando ES Modules​

Antes de empezar: tu archivo .db​

Usar la librería sqlite3​

Instalación​

Ejemplo básico en ES Modules​

Pros y contras breves​

Usar la librería better-sqlite3​

Instalación​

Ejemplo básico en ES Modules​

Pros y contras breves​

3. Usar el módulo oficial node:sqlite​

Ejemplo básico en ES Modules​

Pros y contras breves​

¿Cuál deberías usar como principiante?​

Herramientas Gráficas Populares para SQLite​

1. DB Browser for SQLite (Recomendado)​

2. SQLiteStudio​

3. Extensiones de VS Code​

Buenas prácticas iniciales​

Errores comunes (y cómo evitarlos)​

Conclusión​

¿Qué es SQLite?

SQLite vs otros motores

Instalación rápida en tu entorno local

Instalar SQLite CLI en Windows

Descargar los Binarios de SQLite

Configurar el Entorno

Ejecutar y Usar SQLite

VSCode y extensiones útiles

Conectar SQLite con Node.js usando ES Modules

Antes de empezar: tu archivo .db

Usar la librería `sqlite3`

Instalación

Ejemplo básico en ES Modules

Pros y contras breves

Usar la librería `better-sqlite3`

Instalación

Ejemplo básico en ES Modules

Pros y contras breves

3. Usar el módulo oficial `node:sqlite`

Ejemplo básico en ES Modules

Pros y contras breves

¿Cuál deberías usar como principiante?

Herramientas Gráficas Populares para SQLite

1. DB Browser for SQLite (Recomendado)

2. SQLiteStudio

3. Extensiones de VS Code

Buenas prácticas iniciales

Errores comunes (y cómo evitarlos)

Conclusión