Documentación de SQLite
Referencia concisa y basada en ejemplos de SQLite. Lee el concepto, mira el código y practícalo en un recorrido de Coddy.
Inicia un recorrido guiado de SQLitePrimeros pasos
- Qué es SQLiteSQLite es una base de datos SQL sin servidor que vive en un único archivo y corre dentro de tu aplicación. Te explico qué es, en qué se diferencia de un servidor de base de datos y cuándo conviene usarla.
- SQLite vs MySQLDiferencias reales entre SQLite y MySQL: arquitectura, concurrencia, tipos de datos y para qué tipo de proyecto está pensada cada una.
- SQLite vs PostgresDiferencias reales entre SQLite y PostgreSQL: arquitectura, concurrencia, tipos de datos y qué tipo de proyecto encaja mejor con cada uno.
- Cuándo usar SQLiteGuía práctica para saber cuándo SQLite es la base de datos ideal y cuándo conviene tirar de Postgres o MySQL.
- Instalar SQLiteGuía para instalar SQLite en Windows, macOS y Linux: descargar la herramienta de línea de comandos, añadirla al PATH y comprobar que todo funciona.
- SQLite CLIAprende a usar la shell sqlite3 desde la terminal: abrir bases de datos, ejecutar consultas, dot commands e importar o exportar datos sin salir de la consola.
- Editores GUIRecorrido práctico por las herramientas gráficas para abrir, explorar y editar bases de datos SQLite: DB Browser for SQLite, SQLiteStudio y visores online.
- Crear base de datosCómo crear una base de datos SQLite: el modelo basado en archivos, el comando `sqlite3` y por qué no existe `CREATE DATABASE`.
- Base de datos en memoriaCómo funciona la base de datos en memoria de SQLite, cuándo conviene usar `:memory:` y en qué se diferencia de una base de datos guardada en un archivo.
Tablas y tipos
- CREATE TABLEAprende a crear tablas en SQLite: definición de columnas, restricciones, IF NOT EXISTS, tablas temporales y CREATE TABLE AS SELECT con ejemplos prácticos.
- Tipos de datosCómo guarda los valores SQLite: las cinco clases de almacenamiento, por qué su tipado es dinámico y los detalles que sorprenden si vienes de Postgres o MySQL.
- Type AffinityCómo funciona el sistema de type affinity de SQLite: las cinco afinidades, las reglas que eligen una a partir de la declaración de la columna y por qué una columna INTEGER puede acabar guardando un texto.
- Tablas STRICTCómo las tablas STRICT de SQLite desactivan el almacenamiento flexible de tipos, rechazan valores que no encajan y aplican la verificación de tipos que probablemente esperabas desde el principio.
- Claves primariasCómo funcionan las claves primarias en SQLite: el especial INTEGER PRIMARY KEY, las claves compuestas, AUTOINCREMENT y los detalles que pillan desprevenidos a los recién llegados.
- ROWIDQué es realmente el ROWID en SQLite, cuándo INTEGER PRIMARY KEY se convierte en tu columna y por qué existen las tablas WITHOUT ROWID.
- NOT NULL y DEFAULTCómo funcionan NOT NULL y DEFAULT en SQLite: qué obligan de verdad, el truco con CURRENT_TIMESTAMP y los problemas al añadirlos a tablas que ya existen.
- Restricciones CHECKCómo usar restricciones CHECK en SQLite para validar valores: comprobaciones de una o varias columnas, restricciones con nombre y los detalles que conviene tener en cuenta.
- Restricciones UNIQUECómo funcionan las restricciones UNIQUE en SQLite: a nivel de columna, de tabla, claves compuestas, el detalle de los NULL y qué hacer cuando fallan.
- DROP y ALTER TABLECómo borrar, renombrar y modificar tablas en SQLite: qué admite ALTER TABLE, qué no, y el truco de reconstruir la tabla para los cambios que no soporta.
Insertar y modificar datos
- INSERTCómo funciona INSERT en SQLite: filas individuales, inserciones múltiples, INSERT...SELECT, valores por defecto y los modificadores OR IGNORE y OR REPLACE.
- UPDATECómo modificar filas existentes en SQLite: sintaxis de UPDATE, la cláusula WHERE que te salva el día, actualizaciones de varias columnas y UPDATE ... FROM para cruzar tablas.
- DELETECómo funciona DELETE en SQLite: escribir un WHERE seguro, vaciar una tabla, propagar el borrado a tablas relacionadas y recuperar las filas eliminadas con RETURNING.
- UPSERTCómo funciona UPSERT en SQLite: la cláusula ON CONFLICT, la tabla excluded, DO NOTHING vs DO UPDATE y por qué conviene más que INSERT OR REPLACE.
- RETURNING en SQLiteCómo funciona la cláusula RETURNING en SQLite para recuperar las filas afectadas por un INSERT, UPDATE o DELETE sin tener que lanzar una segunda consulta.
- Importar CSVCómo importar archivos CSV a SQLite con el comando .import: cabeceras, tablas existentes, separadores personalizados y los errores más típicos al cargar datos.
- Exportar datosCómo sacar datos de SQLite: CSV con cabeceras, JSON, volcados SQL completos y copias de tablas concretas usando la shell sqlite3.
Consultar datos
- SELECT básicoCómo funciona la sentencia SELECT en SQLite: elegir columnas, calcular expresiones, poner alias con AS y el modelo mental detrás de cualquier consulta que vayas a escribir.
- Cláusula WHERECómo filtrar filas en SQLite con la cláusula WHERE: operadores de comparación, AND/OR, LIKE, IN, BETWEEN y la trampa con NULL que pilla a todo el mundo.
- Operadores y NULLCómo se comportan los operadores de SQLite frente a NULL: por qué `=` y `<>` no funcionan como esperas, y cuándo usar IS NULL, IS NOT NULL, COALESCE e IFNULL.
- ORDER BYCómo funciona ORDER BY en SQLite: ordenar de forma ascendente o descendente, desempatar con varias columnas, controlar dónde aparecen los NULL y ordenar sin distinguir mayúsculas.
- LIMIT y OFFSETCómo funcionan LIMIT y OFFSET en SQLite: limitar filas, saltarlas, paginar de forma fiable y el problema de rendimiento que conviene evitar en tablas grandes.
- DISTINCTCómo funciona SELECT DISTINCT en SQLite: una columna, varias columnas, manejo de NULL, COUNT(DISTINCT) y cuándo conviene más usar GROUP BY.
- Expresiones CASECómo funciona CASE en SQLite: forma simple y forma con búsqueda, su uso en SELECT, ORDER BY y WHERE, y cuándo conviene usar IIF en su lugar.
Funciones y agregados
- Funciones de cadenasGuía práctica de las funciones de cadenas en SQLite: concatenación con ||, SUBSTR, INSTR, REPLACE, TRIM y patrones útiles para limpiar y transformar texto en tus consultas.
- Funciones numéricasCómo hacer cálculos en SQLite con ROUND, ABS, CEIL, FLOOR, MOD, POWER, SQRT y RANDOM, y la trampa de la división entera que pilla a todo el mundo.
- Fechas y horasCómo guarda y manipula fechas SQLite: las cinco funciones de fecha, cadenas de formato, modificadores y las decisiones de almacenamiento que mantienen tus consultas rápidas.
- Funciones de agregaciónCómo las funciones de agregación de SQLite reducen muchas filas a un único valor: COUNT, SUM, AVG, MIN, MAX y GROUP_CONCAT, con DISTINCT, FILTER y el manejo de NULL.
- GROUP BY y HAVINGCómo GROUP BY agrupa filas en SQLite y cómo HAVING filtra esos grupos después de agregar, con la diferencia entre WHERE y HAVING explicada con ejemplos claros.
Relaciones y joins
- Claves foráneasCómo funcionan las claves foráneas en SQLite: declarar REFERENCES, activar la validación con PRAGMA y elegir el ON DELETE adecuado para cada caso.
- INNER JOINCómo funciona INNER JOIN en SQLite: el modelo mental, la cláusula ON, unir tres tablas y el atajo USING.
- LEFT JOINCómo funciona LEFT JOIN en SQLite: filas sin coincidencia, valores NULL, filtros seguros con ON vs WHERE y joins con varias tablas.
- Self JoinCómo funciona el SELF JOIN en SQLite: emparejar filas de la misma tabla usando alias, con ejemplos prácticos de empleado/jefe y datos jerárquicos.
- SubconsultasCómo anidar un SELECT dentro de otro en SQLite: subconsultas escalares, IN/EXISTS, tablas derivadas, subconsultas correlacionadas y cuándo conviene usar un JOIN.
- CTEsCómo funcionan las Common Table Expressions en SQLite: usar WITH para nombrar subconsultas, encadenar varias CTEs y escribir consultas que se leen de arriba a abajo.
- CTEs recursivasCómo funcionan las CTEs recursivas en SQLite: la estructura ancla/recursiva, recorrer árboles padre-hijo, generar series numéricas y evitar bucles infinitos.
Índices y rendimiento
- ÍndicesCómo funcionan los índices en SQLite, cuándo merecen la pena, cuándo estorban y cómo comprobar si el planificador los está usando de verdad.
- Índices compuestosCómo funcionan los índices multicolumna en SQLite, por qué el orden de las columnas lo cambia todo y cuándo un índice compuesto ayuda de verdad o solo ocupa espacio.
- Índices parcialesCómo funcionan los índices parciales en SQLite: indexar solo las filas que de verdad consultas y los patrones (borrado lógico, unicidad parcial, subconjuntos calientes) donde realmente compensan.
- EXPLAIN QUERY PLANAprende a usar EXPLAIN QUERY PLAN en SQLite para saber si tu consulta usa un índice, qué significan SCAN y SEARCH, y cómo interpretar los joins.
- VACUUM y ANALYZECómo `ANALYZE` y `VACUUM` mantienen tu base de datos SQLite rápida y compacta: qué hace cada uno, cuándo conviene ejecutarlos y las variantes que te interesa conocer.
Funciones avanzadas
- TransaccionesCómo funcionan las transacciones en SQLite: BEGIN, COMMIT, ROLLBACK, el modo autocommit y las diferencias entre DEFERRED, IMMEDIATE y EXCLUSIVE a la hora de bloquear.
- SavepointsCómo funcionan los savepoints en SQLite: marcadores con nombre dentro de una transacción a los que puedes volver sin tirar todo el trabajo abajo.
- VistasCómo funcionan las vistas en SQLite: guardar consultas como tablas virtuales, cuándo usar vistas temporales y por qué son de solo lectura por defecto.
- TriggersCómo funcionan los triggers en SQLite: BEFORE y AFTER, INSTEAD OF sobre vistas, las referencias OLD y NEW, y cuándo conviene usarlos de verdad.
- JSON en SQLiteCómo SQLite guarda y consulta JSON: extraer campos, actualizar valores, recorrer arrays con json_each e indexar rutas JSON para ganar velocidad.
- Búsqueda full-textCómo añadir búsqueda full-text a SQLite usando FTS5: tablas virtuales, el operador MATCH, ranking con BM25 y cómo mantener el índice sincronizado con tus datos.
- Funciones de ventanaCómo funcionan las window functions en SQLite: OVER, PARTITION BY, funciones de ranking, LAG/LEAD y frames para calcular totales acumulados.
- Columnas generadasCómo funcionan las columnas generadas en SQLite: cómo declararlas, cuándo usar VIRTUAL o STORED e indexarlas para consultas rápidas.
- ATTACH DATABASECómo usar ATTACH DATABASE para abrir varios archivos SQLite en una misma conexión, hacer JOIN entre ellos con prefijos de esquema y soltarlos con DETACH.
Seguridad e integración con aplicaciones
- Sentencias preparadasQué son las sentencias preparadas en SQLite, para qué sirven y cómo funciona el ciclo prepare/bind/step/finalize que usan todos los drivers por debajo.
- Parámetros (binding)Cómo funciona el binding de parámetros en SQLite: placeholders posicionales, parámetros con nombre y las reglas para pasar valores de forma segura desde tu aplicación.
- Inyección SQLPor qué concatenar strings es un riesgo serio, cómo funciona realmente un ataque de inyección SQL y cómo las consultas parametrizadas en SQLite lo cortan de raíz.
- Conectar a SQLiteCómo abrir y usar una base de datos SQLite desde tu aplicación: rutas de archivo, cadenas de conexión, drivers por lenguaje y los ajustes que conviene dejar bien afinados desde el primer día.
- MigracionesCómo hacer evolucionar el esquema de SQLite de forma segura usando PRAGMA user_version, scripts de migración numerados y transacciones para poder revertir cambios.
- Modo WALCómo el modo WAL de SQLite cambia las reglas de concurrencia: lectores y escritores dejan de bloquearse entre sí, y para qué sirven realmente los archivos -wal y -shm.
Producción y operaciones
- Backup y restoreCómo hacer copia de seguridad y restaurar una base de datos SQLite sin riesgos: el comando .backup, VACUUM INTO, la API de backup online y por qué copiar el fichero .db a pelo es mala idea.
- PRAGMA en SQLiteLos PRAGMA que de verdad importan — journal_mode, synchronous, foreign_keys, busy_timeout y cache_size — con los valores recomendados para producción.
- Errores comunesLos errores de SQLite que de verdad vas a encontrarte: database is locked, readonly database, disk image malformed, fallos de constraints… y cómo resolverlos.
