Pequeña.

 Rápido.  De confianza.
Elige cualquiera de los tres.

 Hogar
 Sobre
 Documentación
 Descargar
 Licencia
 Apoyo
 Compra
 Búsqueda

Shell de línea de comandos para SQLite

► Tabla de contenido

1. Primeros pasos

El proyecto SQLite proporciona un programa de línea de comandos simple

llamado sqlite3 (o sqlite3.exe en Windows) que permite al usuario ingresar y ejecutar
instrucciones SQL manualmente en una base de datos SQLite o en un archivo ZIP . Este
documento proporciona una breve introducción sobre cómo usar el programa sqlite3 .

Inicie el programa sqlite3 escribiendo "sqlite3" en el símbolo del sistema, seguido opcionalmente

por el nombre del archivo que contiene la base de datos SQLite (o archivo ZIP ). Si el archivo
nombrado no existe, se creará automáticamente un nuevo archivo de base de datos con el nombre
dado. Si no se especifica ningún archivo de base de datos en la línea de comandos, se crea una
base de datos temporal y se elimina automáticamente cuando se cierra el programa "sqlite3".

Al iniciarse, el programa sqlite3 mostrará un breve mensaje de banner y luego le pedirá que

ingrese SQL. Escriba sentencias SQL (terminadas por un punto y coma), presione "Enter" y se
ejecutará el SQL.

Por ejemplo, para crear una nueva base de datos SQLite llamada "ex1" con una sola tabla llamada
"tbl1", podría hacer lo siguiente:

$ sqlite3 ex1
SQLite versión 3.36.0 2021-06-18 18:36:39
Ingrese ".help" para obtener sugerencias de uso.
sqlite> crear tabla tbl1 (un texto, dos int);
sqlite> insertar en valores tbl1 ('¡hola!', 10);
sqlite> insertar en valores tbl1 ('adiós', 20);
sqlite> seleccione * de tbl1;
hola!|10
adiós|20
sqlite>
 Finalice el programa sqlite3 escribiendo el carácter de fin de archivo de su sistema (generalmente
Control-D). Use el carácter de interrupción (generalmente Control-C) para detener una
instrucción SQL de ejecución prolongada.

¡Asegúrese de escribir un punto y coma al final de cada comando SQL! El programa sqlite3 busca
un punto y coma para saber cuándo se completa su comando SQL. Si omite el punto y coma,
sqlite3 le dará un aviso de continuación y esperará a que ingrese más texto para completar el
comando SQL. Esta característica le permite ingresar comandos SQL que abarcan varias
líneas. Por ejemplo:

sqlite> CREAR TABLA tbl2 (

...> f1 varchar(30) clave principal,
...> f2 texto,
...> f3 real
...> );
sqlite>

2. Haga doble clic en Inicio en Windows

Los usuarios de Windows pueden hacer doble clic en el icono sqlite3.exe para hacer que el shell
de la línea de comandos muestre una ventana de terminal que ejecuta SQLite. Sin embargo,
debido a que al hacer doble clic se inicia sqlite3.exe sin argumentos de la línea de comandos, no
se habrá especificado ningún archivo de base de datos, por lo que SQLite utilizará una base de
datos temporal que se eliminará cuando finalice la sesión. Para usar un archivo de disco
persistente como base de datos, ingrese el comando ".open" inmediatamente después de que se
inicie la ventana del terminal:

SQLite versión 3.36.0 2021-06-18 18:36:39

Ingrese ".help" para obtener sugerencias de uso.
Conectado a una base de datos transitoria en memoria.
Utilice ".open FILENAME" para volver a abrir en una base de datos persistente.
sqlite> .abrir ex1.db
sqlite>

El ejemplo anterior hace que se abra y utilice el archivo de base de datos llamado "ex1.db". El
archivo "ex1.db" se crea si no existe previamente. Es posible que desee utilizar un nombre de ruta
completo para asegurarse de que el archivo se encuentra en el directorio en el que cree que se
encuentra. Utilice barras diagonales como carácter separador de directorio. En otras palabras,
utilice "c:/work/ex1.db", no "c:\work\ex1.db".

Alternativamente, puede crear una nueva base de datos usando el almacenamiento temporal
predeterminado y luego guardar esa base de datos en un archivo de disco usando el comando
".save":

SQLite versión 3.36.0 2021-06-18 18:36:39

Ingrese ".help" para obtener sugerencias de uso.
Conectado a una base de datos transitoria en memoria.
Utilice ".open FILENAME" para volver a abrir en una base de datos persistente.
sqlite> ... muchos comandos SQL omitidos ...
sqlite> .save ex1.db
sqlite>
 Tenga cuidado al usar el comando ".save", ya que sobrescribirá cualquier archivo de base de
datos preexistente que tenga el mismo nombre sin solicitar confirmación. Al igual que con el
comando ".open", es posible que desee utilizar un nombre de ruta completo con separadores de
directorio de barra diagonal para evitar la ambigüedad.

3. Comandos especiales para sqlite3 (punto-comandos)

La mayoría de las veces, sqlite3 solo lee líneas de entrada y las pasa a la biblioteca SQLite para
su ejecución. Pero las líneas de entrada que comienzan con un punto (".") son interceptadas e
interpretadas por el propio programa sqlite3. Estos "comandos de puntos" se utilizan
normalmente para cambiar el formato de salida de las consultas o para ejecutar ciertas
declaraciones de consulta preempaquetadas. Originalmente, solo había unos pocos comandos de
puntos, pero a lo largo de los años se han acumulado muchas funciones nuevas, de modo que hoy
en día hay más de 60.

Para obtener una lista de los comandos de puntos disponibles, puede ingresar ".help" sin
argumentos. O ingrese ".help TOPIC" para obtener información detallada sobre TOPIC. La lista
de comandos de puntos disponibles es la siguiente:

sqlite> .ayuda
.archive ... Administrar archivos SQL
.auth ON|OFF Mostrar devoluciones de llamada del autorizador
.backup ?BD? ARCHIVO Base de datos de respaldo (por defecto "principal") a ARCHIVO
.bail on|off Detener después de encontrar un error. DESACTIVADO por defecto
.binary on|off Activa o desactiva la salida binaria. DESACTIVADO por defecto
.cd DIRECTORIO Cambia el directorio de trabajo a DIRECTORIO
.changes on|off Muestra el número de filas cambiadas por SQL
.check GLOB falla si la salida desde .testcase no coincide
.clone NEWDB Clonar datos en NEWDB desde la base de datos existente
.conexión [cerrar] [#] Abre o cierra una conexión de base de datos auxiliar
.databases Lista nombres y archivos de bases de datos adjuntas
.dbconfig ?op? ?val? Listar o cambiar las opciones de sqlite3_db_config()
.dbinfo ?DB? Mostrar información de estado sobre la base de datos
.dump ?OBJETOS? Renderizar el contenido de la base de datos como SQL
.echo on|off Activa o desactiva el comando echo
.eqp on|off|full|... Activar o desactivar automático EXPLICAR CONSULTA PLAN
.excel Muestra el resultado del siguiente comando en la hoja de cálculo
.salir ?CÓDIGO? Salga de este programa con el código de retorno CÓDIGO
.experto EXPERIMENTAL. Sugerir índices para consultas
.explicar ?on|off|auto? Cambia el modo de formato EXPLAIN. Predeterminado: automático
.filectrl CMD ... Ejecutar varias operaciones sqlite3_file_control()
.fullschema ?--guión? Mostrar el esquema y el contenido de las tablas sqlite_stat
.headers on|off Activa o desactiva la visualización de encabezados
.¿ayudar a todos? ?¿PATRÓN? Mostrar texto de ayuda para PATRÓN
.importar ARCHIVO TABLA Importar datos de ARCHIVO a TABLA
.imposter ÍNDICE TABLA Crear tabla impostor TABLA en el índice ÍNDICE
.indexes ?TABLA? Mostrar nombres de índices
.límite ?LÍMITE? ?VAL? Mostrar o cambiar el valor de un SQLITE_LIMIT
.lint OPCIONES Informar posibles problemas de esquema.
.load ARCHIVO ?ENTRADA? Cargar una biblioteca de extensiones
.log FILE|off Activa o desactiva el inicio de sesión. El ARCHIVO puede ser stderr/stdout
.mode MODO ?TABLA? Establecer el modo de salida
.nonce STRING Desactiva el modo seguro para un comando si el nonce coincide
.nullvalue STRING Usa STRING en lugar de valores NULL
.once ?OPCIONES? ?¿EXPEDIENTE? Salida para el siguiente comando SQL solo para ARCHIVO
.abrir ?OPCIONES? ?¿EXPEDIENTE? Cierre la base de datos existente y vuelva a abrir ARCHIVO
.¿archivo de salida? Enviar salida a ARCHIVO o salida estándar si se omite ARCHIVO
.parameter CMD ... Administrar enlaces de parámetros SQL
.print STRING... Imprime STRING literal
.progress N Invocar el controlador de progreso después de cada N opcodes
.prompt PRINCIPAL CONTINUAR Reemplazar las indicaciones estándar
.quit Salir de este programa
.leer ARCHIVO Leer entrada de ARCHIVO
.recover Recupere tantos datos como sea posible de una base de datos corrupta.
.restaurar ?DB? ARCHIVO Restaurar el contenido de la base de datos (predeterminado "principal") desde
ARCHIVO
.save ARCHIVO Escribe la base de datos en memoria en ARCHIVO
.scanstats on|off Activa o desactiva las métricas de sqlite3_stmt_scanstatus()
.schema ?PATRÓN? Muestre las declaraciones CREATE que coincidan con PATTERN
.selftest ?OPCIONES? Ejecutar pruebas definidas en la tabla SELFTEST
.separador COL ?FILA? Cambiar los separadores de columnas y filas
.sesión ?NOMBRE? CMD... Crear o controlar sesiones
.sha3sum ... Calcula un hash SHA3 del contenido de la base de datos
.shell CMD ARGS... Ejecute CMD ARGS... en un shell del sistema
.show Muestra los valores actuales para varias configuraciones
.estadísticas ?ARG? Mostrar estadísticas o activar o desactivar estadísticas
.system CMD ARGS... Ejecute CMD ARGS... en un shell del sistema
.tablas ?TABLA? Listar nombres de tablas que coincidan con el patrón LIKE TABLE
.testcase NOMBRE Comience a redirigir la salida a 'testcase-out.txt'
.testctrl CMD ... Ejecutar varias operaciones sqlite3_test_control()
.timeout MS Intente abrir tablas bloqueadas por MS milisegundos
.timer on|off Activa o desactiva el temporizador SQL
.trace ?OPCIONES? Salida de cada instrucción SQL a medida que se ejecuta
.vfsinfo ?AUX? Información sobre el VFS de nivel superior
.vfslist Lista todos los VFS disponibles
.vfsnombre ?AUX? Imprime el nombre de la pila VFS
.width NUM1 NUM2 ... Establecer anchos de columna mínimos para la salida en columnas
sqlite>

4. Reglas para "comandos de punto", SQL y más

4.1. Estructura de línea

La entrada de la CLI se analiza en una secuencia que consta de:

 sentencias SQL;
 comandos de puntos; o
 Comentarios de CLI

Las declaraciones SQL son de forma libre y se pueden distribuir en varias líneas, con espacios en
blanco o comentarios SQL incrustados en cualquier lugar. Terminan con un ';' carácter al final de
una línea de entrada, o un carácter '/' o la palabra "ir" en una línea por sí misma. Cuando no está
al final de una línea de entrada, el ';' los actos de carácter para separar sentencias SQL. Los
espacios en blanco finales se ignoran a efectos de terminación.
 Un comando de punto tiene una estructura más restrictiva:

 Debe comenzar con su "." en el margen izquierdo sin espacios en blanco anteriores.
 Debe estar completamente contenido en una sola línea de entrada.
 No puede ocurrir en medio de una instrucción SQL ordinaria. En otras palabras, no puede
ocurrir en un indicador de continuación.
 No hay sintaxis de comentarios para los comandos de punto.

La CLI también acepta comentarios de línea completa que comienzan con un carácter '#' y se
extienden hasta el final de la línea. No puede haber ningún espacio en blanco antes del '#'.

4.2. Argumentos de comando de punto

Los argumentos pasados a los comandos de punto se analizan desde la cola del comando, según
estas reglas:

1. La nueva línea final y cualquier otro espacio en blanco final se descarta;

2. Se descartan los espacios en blanco que siguen inmediatamente al nombre del comando de
punto o cualquier límite de entrada del argumento;
3. Una entrada de argumento comienza con cualquier carácter que no sea un espacio en
blanco;
4. Una entrada de argumento termina con un carácter que depende de su carácter principal,
por lo tanto:
o para una comilla simple inicial ('), una comilla simple actúa como
delimitador final;
o para una comilla doble inicial ("), una comilla doble sin escape actúa
como delimitador final;
o para cualquier otro carácter inicial, el delimitador final es cualquier
espacio en blanco; y
o el extremo final del comando actúa como delimitador final para
cualquier argumento;
5. Dentro de una entrada de argumento entre comillas dobles, una comilla doble con barra
invertida es parte del argumento en lugar de su comilla final;
6. Dentro de un argumento entre comillas dobles, se realiza la traducción tradicional de
secuencia de escape de barra invertida literal C-string; y
7. Los delimitadores de entrada de argumentos (las comillas delimitadoras o los espacios en
blanco) se descartan para generar el argumento pasado.

4.3. Ejecución de comando de punto

Los comandos de puntos son interpretados por el programa de línea de comandos sqlite3.exe, no
por SQLite mismo. Por lo tanto, ninguno de los comandos de punto funcionará como argumento
para las interfaces de SQLite como sqlite3_prepare() o sqlite3_exec() .

5. Cambio de formatos de salida

El programa sqlite3 puede mostrar los resultados de una consulta en 14 formatos de salida
diferentes:

 ascii
 caja
 CSV
  columna
 html
 insertar
 json
 línea
 lista
 reducción
 cotizar
 mesa
 pestañas
 tcl

Puede usar el comando de punto ".mode" para cambiar entre estos formatos de salida. El modo de
salida predeterminado es "lista". En el modo de lista, cada fila del resultado de una consulta se
escribe en una línea de salida y cada columna dentro de esa fila está separada por una cadena de
separación específica. El separador predeterminado es un símbolo de tubería ("|"). El modo de
lista es especialmente útil cuando va a enviar el resultado de una consulta a otro programa (como
AWK) para un procesamiento adicional.

sqlite> .mode list

sqlite> select * from tbl1;
hola!|10
adiós|20
sqlite>

Escriba ".mode" sin argumentos para mostrar el modo actual:

sqlite> .modo
modo de salida actual: lista
sqlite>

Use el comando de punto ".separator" para cambiar el separador. Por ejemplo, para cambiar el
separador a una coma y un espacio, podría hacer esto:

sqlite> .separator ", "

sqlite> select * from tbl1;
hola!, 10
adiós, 20
sqlite>

El siguiente comando ".mode" podría restablecer el ".separador" a algún valor predeterminado

(dependiendo de sus argumentos). Por lo tanto, es probable que deba repetir el comando
".separator" cada vez que cambie de modo si desea continuar usando un separador no estándar.

En el modo "comilla", la salida se formatea como literales SQL. Las cadenas se encierran entre
comillas simples y las comillas simples internas se escapan mediante la duplicación. Los blobs se
muestran en notación literal de blob hexadecimal (por ejemplo: x'abcd'). Los números se
muestran como texto ASCII y los valores NULL se muestran como "NULL". Todas las columnas
están separadas entre sí por una coma (o cualquier carácter alternativo que se seleccione usando
".separador").

sqlite> .mode citar

sqlite> seleccionar * de tbl1;
'¡hola!',10
'adiós', 20
sqlite>

En el modo "línea", cada columna en una fila de la base de datos se muestra en una línea por sí
misma. Cada línea consta del nombre de la columna, un signo igual y los datos de la
columna. Los registros sucesivos están separados por una línea en blanco. Aquí hay un ejemplo
de salida de modo de línea:

sqlite> .mode line

sqlite> select * from tbl1;
uno = hola!
dos = 10

uno = adiós
dos = 20
sqlite>

En el modo de columna, cada registro se muestra en una línea separada con los datos alineados en
columnas. Por ejemplo:

sqlite> .mode columna

sqlite> select * from tbl1;
uno dos
-------- ---
¡hola! 10
adiós 20
sqlite>

En el modo "columna" (y también en los modos "cuadro", "tabla" y "rebaja"), el ancho de las
columnas se ajusta automáticamente. Pero puede anular esto, proporcionando un ancho
especificado para cada columna usando el comando ".width". Los argumentos de ".width" son
números enteros que son el número de caracteres que se dedican a cada columna. Los números
negativos significan justificación a la derecha. De este modo:

sqlite> .width 12 -6
sqlite> seleccionar * de tbl1;
uno dos
------------ ------
¡hola! 10
adiós 20
sqlite>

Un ancho de 0 significa que el ancho de la columna se elige automáticamente. Los anchos de

columna no especificados se convierten en cero. Por lo tanto, el comando ".width" sin argumentos
restablece todos los anchos de columna a cero y, por lo tanto, hace que todos los anchos de
columna se determinen automáticamente.

El modo "columna" es un formato de salida tabular. Otros formatos de salida tabulares son "box",
"markdown" y "table":

sqlite> .width
sqlite> .mode markdown
sqlite> select * from tbl1;
| uno | dos |
|---------|-----|
| ¡hola! | 10 |
| adiós | 20 |
sqlite> .mode table
sqlite> select * from tbl1;
+---------+------+
| uno | dos |
+---------+------+
| ¡hola! | 10 |
| adiós | 20 |
+---------+------+
sqlite> .mode box
sqlite> select * from tbl1;
┌─────────┬─────┐
│ uno │ dos │
├─────────┼─────┤
│ hola! │ 10 │
│ adiós │ 20 │
└─────────┴─────┘
sqlite>

Los modos columnares aceptan algunas opciones adicionales para controlar el formato. La opción
"--wrap N " (donde N es un número entero) hace que las columnas ajusten el texto que tiene más
de N caracteres. El ajuste está deshabilitado si N es cero.

sqlite> insert into tbl1 valores('El veloz zorro salta sobre un perezoso perro marrón.',99);
sqlite> .mode box --wrap 30
sqlite> select * from tbl1 donde dos>50;
┌────────────────────────────────┬─────┐
│ uno │ dos │
├────────────────────────────────┼─── ─
│ El veloz zorro salta sobre un laz │ 90 │
│ y perro marrón. │ │
└────────────────────────────────┴─────┘
sqlite>

El ajuste ocurre exactamente después de N caracteres, que pueden estar en medio de una
palabra. Para ajustar en un límite de palabra, agregue la opción "--wordwrap on" (o simplemente
"-ww" para abreviar):

sqlite> .mode box --wrap 30 -ww

sqlite> select * from tbl1 donde dos>50;
┌─────────────────────────────┬─────┐
│ uno │ dos │
├─────────────────────────────┼─────┤
│ El veloz zorro salta sobre un │ 90 │
│ perro marrón perezoso. │ │
└─────────────────────────────┴─────┘
sqlite>
 La opción "--quote" hace que los resultados de cada columna se cite como un literal SQL, como
en el modo "quote". Consulte la ayuda en línea para obtener opciones adicionales.

El comando ".mode box --wrap 60 --quote" es tan útil para consultas de base de datos de
propósito general que se le asigna su propio alias. En lugar de escribir todo ese comando de 27
caracteres, puede simplemente decir ".mode qbox".

Otro modo de salida útil es "insertar". En el modo de inserción, la salida se formatea para
parecerse a las instrucciones SQL INSERT. Use el modo de inserción para generar texto que
luego se puede usar para ingresar datos en una base de datos diferente.

Al especificar el modo de inserción, debe proporcionar un argumento adicional que es el nombre

de la tabla en la que se insertará. Por ejemplo:

sqlite> .mode insert new_table

sqlite> select * from tbl1 where two<50;
INSERTAR EN VALORES "nueva_tabla" ('hola', 10);
INSERTAR EN VALORES "nueva_tabla" ('adiós', 20);
sqlite>

Otros modos de salida incluyen "csv", "json" y "tcl". Pruébelos usted mismo para ver lo que
hacen.

6. Consultando el esquema de la base de datos

El programa sqlite3 proporciona varios comandos convenientes que son útiles para ver el
esquema de la base de datos. No hay nada que estos comandos hagan que no se pueda hacer por
otros medios. Estos comandos se proporcionan únicamente como acceso directo.

Por ejemplo, para ver una lista de las tablas en la base de datos, puede ingresar ".tables".

sqlite> .tablas
tbl1 tbl2
sqlite>

El comando ".tables" es similar a configurar el modo de lista y luego ejecutar la siguiente

consulta:

SELECCIONE el nombre DE sqlite_schema

DONDE escriba IN ('tabla', 'vista') Y nombre NO COMO 'sqlite_%'
ORDEN POR 1

Pero el comando ".tables" hace más. Consulta la tabla sqlite_schema para todas las bases de

datos adjuntas , no solo la base de datos principal. Y organiza su salida en columnas ordenadas.

El comando ".indexes" funciona de manera similar para enumerar todos los índices. Si al
comando ".indexes" se le da un argumento que es el nombre de una tabla, entonces solo muestra
índices en esa tabla.

El comando ".schema" muestra el esquema completo de la base de datos o de una sola tabla si se
proporciona un argumento de nombre de tabla opcional:

sqlite> .schema
crear tabla tbl1 (un varchar (10), dos smallint)
CREAR TABLA tbl2 (
f1 varchar(30) clave principal,
texto f2,
f3 real
);
sqlite> .schema tbl2
CREAR TABLA tbl2 (
f1 varchar(30) clave principal,
texto f2,
f3 real
);
sqlite>

El comando ".schema" es más o menos lo mismo que configurar el modo de lista y luego ingresar
la siguiente consulta:

SELECCIONE sql DESDE sqlite_schema

ORDENAR POR tbl_name, tipo DESC, nombre

Al igual que con ".tables", el comando ".schema" muestra el esquema de todas las bases de
datos adjuntas . Si solo desea ver el esquema para una sola base de datos (quizás "principal"),
puede agregar un argumento a ".schema" para restringir su salida:

sqlite> .schema principal.*

El comando ".schema" se puede complementar con la opción "--indent", en cuyo caso intenta
reformatear las diversas declaraciones CREATE del esquema para que sean más fáciles de leer
para los humanos.

El comando ".databases" muestra una lista de todas las bases de datos abiertas en la conexión
actual. Siempre habrá al menos 2. El primero es "principal", la base de datos original abierta. La
segunda es "temp", la base de datos utilizada para las tablas temporales. Puede haber bases de
datos adicionales enumeradas para las bases de datos adjuntas mediante la instrucción
ATTACH. La primera columna de resultados es el nombre con el que se adjunta la base de datos
y la segunda columna de resultados es el nombre del archivo externo. Puede haber una tercera
columna de resultados que será "'r/o'" o "'r/w'" dependiendo de si el archivo de la base de datos es
de solo lectura o de lectura y escritura. Y podría haber una cuarta columna de resultados que
muestre el resultado de sqlite3_txn_state() para ese archivo de base de datos.

sqlite> .bases de datos

El comando de punto ".fullschema" funciona como el comando ".schema" en el sentido de que

muestra el esquema completo de la base de datos. Pero ".fullschema" también incluye volcados
de las tablas de estadísticas "sqlite_stat1", "sqlite_stat3" y "sqlite_stat4", si existen. El comando
".fullschema" normalmente proporciona toda la información necesaria para recrear exactamente
un plan de consulta para una consulta específica. Al informar problemas sospechosos con el
planificador de consultas de SQLite al equipo de desarrollo de SQLite, se solicita a los
desarrolladores que proporcionen el resultado completo ".fullschema" como parte del informe de
problemas. Tenga en cuenta que las tablas sqlite_stat3 y sqlite_stat4 contienen muestras de
entradas de índice y, por lo tanto, pueden contener datos confidenciales, así que no envíe el
".fullschema"

7. Apertura de archivos de base de datos

 El comando ".open" abre una nueva conexión de base de datos, después de cerrar primero el
comando de base de datos abierto anteriormente. En su forma más simple, el comando ".open"
simplemente invoca sqlite3_open() en el archivo nombrado como su argumento. Utilice el
nombre ":memory:" para abrir una nueva base de datos en memoria que desaparece cuando se
cierra la CLI o cuando se vuelve a ejecutar el comando ".open".

Si la opción --new se incluye con ".open", la base de datos se restablece antes de abrirse. Todos
los datos anteriores se destruyen. Esta es una sobrescritura destructiva de los datos anteriores y no
se solicita confirmación, así que use esta opción con cuidado.

La opción --readonly abre la base de datos en modo de solo lectura. Se prohibirá escribir.

La opción --deserialize hace que todo el contenido del archivo en disco se lea en la memoria y
luego se abra como una base de datos en memoria mediante
la interfaz sqlite3_deserialize() . Esto, por supuesto, requerirá mucha memoria si tiene una base
de datos grande. Además, los cambios que realice en la base de datos no se guardarán en el disco
a menos que los guarde explícitamente con los comandos ".save" o ".backup".

La opción --append hace que la base de datos SQLite se agregue a un archivo existente en lugar
de funcionar como un archivo independiente. Consulte la extensión appendvfs para obtener más
información.

La opción --zip hace que el archivo de entrada especificado se interprete como un archivo ZIP en
lugar de como un archivo de base de datos SQLite.

La opción --hexdb hace que el contenido de la base de datos se lea desde líneas de entrada
subsiguientes en formato hexadecimal, en lugar de desde un archivo separado en el disco. La
herramienta de línea de comandos "dbtotxt" se puede utilizar para generar el texto apropiado para
una base de datos. La opción --hexdb está diseñada para que la usen los desarrolladores de SQLite
con fines de prueba. No conocemos ningún caso de uso para esta opción fuera de las pruebas y el
desarrollo internos de SQLite.

8. Redirección de E/S

8.1. Escribir resultados en un archivo

De forma predeterminada, sqlite3 envía los resultados de la consulta a la salida estándar. Puede

cambiar esto usando los comandos ".output" y ".once". Simplemente coloque el nombre de un
archivo de salida como argumento para .output y todos los resultados de la consulta posterior se
escribirán en ese archivo. O use el comando .once en lugar de .output y la salida solo se redirigirá
para el siguiente comando único antes de volver a la consola. Use .output sin argumentos para
comenzar a escribir en la salida estándar nuevamente. Por ejemplo:

sqlite> .mode lista

sqlite> .separador |
sqlite> .output test_file_1.txt
sqlite> select * from tbl1;
sqlite> .exit
$ cat test_file_1.txt
hola|10
adiós|20
ps
 Si el primer carácter del nombre de archivo ".output" o ".once" es un símbolo de tubería ("|"), los
caracteres restantes se tratan como un comando y la salida se envía a ese comando. Esto facilita
canalizar los resultados de una consulta a algún otro proceso. Por ejemplo, el comando "abrir -f"
en una Mac abre un editor de texto para mostrar el contenido que lee desde la entrada
estándar. Entonces, para ver los resultados de una consulta en un editor de texto, uno podría
escribir:

sqlite> .once | open -f

sqlite> SELECCIONAR * DESDE bigTable;

Si los comandos ".output" o ".once" tienen un argumento de "-e", la salida se recopila en un

archivo temporal y se invoca el editor de texto del sistema en ese archivo de texto. Por lo tanto, el
comando ".once -e" logra el mismo resultado que ".once '|open -f'" pero con la ventaja de ser
portátil en todos los sistemas.

Si los comandos ".output" o ".once" tienen un argumento "-x", eso hace que acumulen la salida
como valores separados por comas (CSV) en un archivo temporal, luego invoque la utilidad del
sistema predeterminada para ver archivos CSV (generalmente un programa de hoja de cálculo) en
el resultado. Esta es una forma rápida de enviar el resultado de una consulta a una hoja de cálculo
para una fácil visualización:

sqlite> .once -x
sqlite> SELECT * FROM bigTable;

El comando ".excel" es un alias para ".once -x". Hace exactamente lo mismo.

8.2. Leer SQL desde un archivo

En el modo interactivo, sqlite3 lee el texto de entrada (ya sean instrucciones SQL o comandos de
puntos ) desde el teclado. También puede redirigir la entrada de un archivo cuando inicia sqlite3,
por supuesto, pero entonces no tiene la capacidad de interactuar con el programa. A veces es útil
ejecutar un script SQL contenido en un archivo ingresando otros comandos desde la línea de
comandos. Para esto, se proporciona el comando de punto ".read".

El comando ".read" toma un solo argumento que (generalmente) es el nombre de un archivo

desde el cual leer el texto de entrada.

sqlite> .leer myscript.sql

El comando ".read" deja de leer temporalmente desde el teclado y en su lugar toma su entrada del
archivo nombrado. Al llegar al final del archivo, la entrada vuelve al teclado. El archivo de
secuencia de comandos puede contener comandos de punto, al igual que la entrada interactiva
ordinaria.

Si el argumento de ".read" comienza con "|" entonces, en lugar de abrir el argumento como un

archivo, ejecuta el argumento (sin el "|") inicial como un comando, luego usa la salida de ese
comando como su entrada. Por lo tanto, si tiene un script que genera SQL, puede ejecutar ese
SQL directamente usando un comando similar al siguiente:

sqlite> .leer |miscript.bat

8.3. Funciones de E/S de archivo

 El shell de la línea de comandos agrega dos funciones SQL definidas por la aplicación que
facilitan la lectura del contenido de un archivo en una columna de la tabla y la escritura del
contenido de una columna en un archivo, respectivamente.

La función SQL readfile(X) lee todo el contenido del archivo llamado X y devuelve ese contenido
como un BLOB. Esto se puede usar para cargar contenido en una tabla. Por ejemplo:

sqlite> CREAR TABLA imágenes (nombre TEXTO, tipo TEXTO, img BLOB);
sqlite> INSERTAR EN imágenes (nombre, tipo, img )
...> VALORES('icono','jpeg',readfile('icono.jpg'));

La función SQL writefile(X,Y) escribe el blob Y en el archivo llamado X y devuelve el número

de bytes escritos. Utilice esta función para extraer el contenido de una sola columna de tabla en
un archivo. Por ejemplo:

sqlite> SELECT writefile('icon.jpg',img) DESDE imágenes DONDE nombre='icono';

Tenga en cuenta que las funciones readfile(X) y writefile(X,Y) son funciones de extensión y no
están integradas en la biblioteca central de SQLite. Estas rutinas están disponibles como
una extensión cargable en el archivo fuente ext/misc/fileio.c en los repositorios de código fuente
de SQLite .

8.4. La función SQL editar ()

La CLI tiene otra función SQL integrada llamada edit(). Edit() toma uno o dos argumentos. El
primer argumento es un valor, a menudo una cadena grande de varias líneas para editar. El
segundo argumento es la invocación de un editor de texto. (Puede incluir opciones para afectar el
comportamiento del editor). Si se omite el segundo argumento, se usa la variable de entorno
VISUAL. La función editar () escribe su primer argumento en un archivo temporal, invoca al
editor en el archivo temporal, vuelve a leer el archivo en la memoria después de que el editor
haya terminado y luego devuelve el texto editado.

La función edit() se puede utilizar para realizar cambios en valores de texto grandes. Por ejemplo:

sqlite> UPDATE docs SET body=edit(body) WHERE name='report-15';

En este ejemplo, el contenido del campo docs.body para la entrada donde docs.name es "informe-
15" se enviará al editor. Después de que regrese el editor, el resultado se volverá a escribir en el
campo docs.body.

La operación predeterminada de edit() es invocar un editor de texto. Pero al usar un programa de

edición alternativo en el segundo argumento, también puede hacer que edite imágenes u otros
recursos que no sean de texto. Por ejemplo, si desea modificar una imagen JPEG que está
almacenada en un campo de una tabla, puede ejecutar:

sqlite> ACTUALIZAR pics SET img=edit(img,'gimp') WHERE id='pic-1542';

El programa de edición también se puede utilizar como visor, simplemente ignorando el valor de
retorno. Por ejemplo, para simplemente mirar la imagen de arriba, puede ejecutar:

sqlite> SELECT longitud(editar(img,'gimp')) WHERE id='pic-1542';

8.5. Importación de archivos como CSV u otros formatos

 Use el comando ".importar" para importar CSV (valores separados por comas) o datos
delimitados de manera similar en una tabla de SQLite. El comando ".importar" toma dos
argumentos que son la fuente desde la cual se leerán los datos y el nombre de la tabla SQLite en
la que se insertarán los datos. El argumento fuente es el nombre de un archivo que se va a leer o,
si comienza con "|" carácter, especifica un comando que se ejecutará para producir los datos de
entrada.

Tenga en cuenta que puede ser importante establecer el "modo" antes de ejecutar el comando
".importar". Esto es prudente para evitar que el shell de la línea de comandos intente interpretar el
texto del archivo de entrada como un formato diferente al de la estructura del archivo. Si se usan
las opciones --csv o --ascii, controlan los delimitadores de entrada de importación. De lo
contrario, los delimitadores son los que están vigentes para el modo de salida actual.

Para importar a una tabla que no está en el esquema "principal", se puede usar la opción --schema
para especificar que la tabla está en algún otro esquema. Esto puede ser útil para bases de datos
ATTACH'ed o para importar a una tabla TEMP.

Cuando se ejecuta .import, su tratamiento de la primera fila de entrada depende de si la tabla de

destino ya existe. Si no existe, la tabla se crea automáticamente y el contenido de la primera fila
de entrada se usa para establecer el nombre de todas las columnas de la tabla. En este caso, el
contenido de datos de la tabla se toma de la segunda y posteriores filas de entrada. Si la tabla de
destino ya existe, cada fila de la entrada, incluida la primera, se toma como contenido de datos
real. Si el archivo de entrada contiene una fila inicial de etiquetas de columna, puede hacer que el
comando .import omita esa fila inicial usando la opción "--skip 1".

Aquí hay un ejemplo de uso, cargando una tabla temporal preexistente desde un archivo CSV que
tiene nombres de columna en su primera fila:

sqlite> .import --csv --skip 1 --schema temp C:/work/somedata.csv tab1

8.6. Exportar a CSV

Para exportar una tabla SQLite (o parte de una tabla) como CSV, simplemente configure el
"modo" en "csv" y luego ejecute una consulta para extraer las filas deseadas de la tabla.

sqlite> .headers en
sqlite> .mode csv
sqlite> .once c:/work/dataout.csv
sqlite> SELECT * FROM tab1;
sqlite> .sistema c:/trabajo/dataout.csv

En el ejemplo anterior, la línea ".headers on" hace que las etiquetas de las columnas se impriman
como la primera fila de la salida. Esto significa que la primera fila del archivo CSV resultante
contendrá etiquetas de columna. Si no se desean etiquetas de columna, configure ".headers off" en
su lugar. (La configuración ".headers off" es la predeterminada y se puede omitir si los
encabezados no se han activado previamente).

La línea ".once FILENAME " hace que todos los resultados de la consulta vayan al archivo
indicado en lugar de imprimirse en la consola. En el ejemplo anterior, esa línea hace que el
contenido CSV se escriba en un archivo llamado "C:/work/dataout.csv".
 La línea final del ejemplo (el ".system c:/work/dataout.csv") tiene el mismo efecto que hacer
doble clic en el archivo c:/work/dataout.csv en Windows. Esto generalmente abrirá un programa
de hoja de cálculo para mostrar el archivo CSV.

Ese comando solo funciona como está escrito en Windows. La línea equivalente en una Mac
sería:

sqlite> .sistema abierto dataout.csv

En Linux y otros sistemas Unix, deberá ingresar algo como:

sqlite> .system xdg-open dataout.csv

8.6.1. Exportar a Excel

Para simplificar la exportación a una hoja de cálculo, la CLI proporciona el comando ".excel" que
captura el resultado de una sola consulta y lo envía al programa de hoja de cálculo
predeterminado en la computadora host. Úsalo así:

sqlite> .excel
sqlite> SELECT * FROM tab;

El comando anterior escribe el resultado de la consulta como CSV en un archivo temporal, invoca
el controlador predeterminado para archivos CSV (generalmente el programa de hoja de cálculo
preferido, como Excel o LibreOffice), luego elimina el archivo temporal. Este es esencialmente
un método abreviado para ejecutar la secuencia de comandos ".csv", ".once" y ".system" descrita
anteriormente.

El comando ".excel" es en realidad un alias de ".once -x". La opción -x para .once hace que
escriba los resultados como CSV en un archivo temporal que se nombra con el sufijo ".csv",
luego invoca el controlador predeterminado del sistema para los archivos CSV.

También hay un comando ".once -e" que funciona de manera similar, excepto que nombra el
archivo temporal con un sufijo ".txt" para que se invoque el editor de texto predeterminado para
el sistema, en lugar de la hoja de cálculo predeterminada.

9. Acceso a archivos ZIP como archivos de base de datos

Además de leer y escribir archivos de base de datos SQLite, el programa sqlite3 también leerá y

escribirá archivos ZIP. Simplemente especifique un nombre de archivo ZIP en lugar de un
nombre de archivo de base de datos SQLite en la línea de comando inicial, o en el comando
".open", y sqlite3 detectará automáticamente que el archivo es un archivo ZIP en lugar de una
base de datos SQLite y lo abrirá como tal. Esto funciona independientemente del sufijo del
archivo. Por lo tanto, puede abrir archivos JAR, DOCX y ODP y cualquier otro formato de
archivo que sea realmente un archivo ZIP y SQLite lo leerá por usted.

Un archivo ZIP parece ser una base de datos que contiene una sola tabla con el siguiente
esquema:

CREAR TABLA zip(

nombre, // Nombre del archivo
mode, // permisos de archivos al estilo Unix
mtime, // Marca de tiempo, segundos desde 1970
sz, // Tamaño del archivo después de la descompresión
 rawdata, // Datos del archivo comprimido sin procesar
datos, // contenido del archivo sin comprimir
método // código del método de compresión ZIP
);

Entonces, por ejemplo, si quisiera ver la eficiencia de compresión (expresada como el tamaño del
contenido comprimido en relación con el tamaño del archivo original sin comprimir) para todos
los archivos en el archivo ZIP, ordenados desde el más comprimido hasta el menos comprimido,
podría ejecutar un consulta como esta:

sqlite> SELECCIONE nombre, (100.0*longitud(datos sin procesar))/sz DESDE zip ORDEN POR 2;

O usando las funciones de E/S de archivos , puede extraer elementos del archivo ZIP:

sqlite> SELECCIONE el archivo de escritura (nombre, contenido) DESDE zip

...> DONDE nombre LIKE 'docProps/%';

9.1. Cómo se implementa el acceso al archivo ZIP

El shell de la línea de comandos utiliza la tabla virtual Zipfile para acceder a los archivos
ZIP. Puede ver esto ejecutando el comando ".schema" cuando un archivo ZIP está abierto:

sqlite> .schema
CREAR TABLA VIRTUAL zip USANDO zipfile('document.docx')
/* zip(nombre,modo,mtime,sz,datos sin procesar,datos,método) */;

Al abrir un archivo, si el cliente de la línea de comandos descubre que el archivo es un archivo

ZIP en lugar de una base de datos SQLite, en realidad abre una base de datos en memoria y luego
en esa base de datos en memoria crea una instancia de la tabla virtual Zipfile que se adjunta al
archivo ZIP.

El procesamiento especial para abrir archivos ZIP es un truco del shell de línea de comandos, no
de la biblioteca central de SQLite. Entonces, si desea abrir un archivo ZIP como una base de
datos en su aplicación, deberá activar el módulo de tabla virtual Zipfile y luego ejecutar una
instrucción CREATE VIRTUAL TABLE adecuada .

10. Convertir una base de datos completa en un archivo de texto

Utilice el comando ".dump" para convertir todo el contenido de una base de datos en un único
archivo de texto UTF-8. Este archivo se puede volver a convertir en una base de datos al
canalizarlo nuevamente a sqlite3 .

Una buena manera de hacer una copia de archivo de una base de datos es esta:

$ sqlite3 ex1 .volcado | gzip -c >ex1.dump.gz

Esto genera un archivo llamado ex1.dump.gz que contiene todo lo que necesita para reconstruir
la base de datos en un momento posterior o en otra máquina. Para reconstruir la base de datos,
simplemente escriba:

$ zcat ex1.dump.gz | sqlite3 ex2

El formato de texto es SQL puro, por lo que también puede usar el comando .dump para exportar
una base de datos SQLite a otros motores de bases de datos SQL populares. Como esto:
$ createdb ex2
$ sqlite3 ex1 .volcado | psql ex2

11. Recuperar datos de una base de datos corrupta

Al igual que el comando ".dump", ".recover" intenta convertir todo el contenido de un archivo de
base de datos en texto. La diferencia es que, en lugar de leer los datos mediante la interfaz normal
de la base de datos SQL, ".recover" intenta volver a ensamblar la base de datos en función de los
datos extraídos directamente de tantas páginas de bases de datos como sea posible. Si la base de
datos está dañada, ".recover" generalmente puede recuperar datos de todas las partes no dañadas
de la base de datos, mientras que ".dump" se detiene cuando se encuentra el primer signo de
corrupción.

Si el comando ".recover" recupera una o más filas que no puede atribuir a ninguna tabla de la
base de datos, el script de salida crea una tabla "lost_and_found" para almacenar las filas
huérfanas. El esquema de la tabla lost_and_found es el siguiente:

CREAR TABLA perdidos_y_encontrados(

rootpgno INTEGER, -- la página raíz del árbol pgno es parte de
pgno INTEGER, -- se encontró la fila del número de página en
nfield INTEGER, -- número de campos en fila
id INTEGER, -- valor del campo rowid, o NULL
c0, c1, c2, c3... -- columnas para campos de fila
);

La tabla "lost_and_found" contiene una fila por cada fila huérfana recuperada de la base de
datos. Además, hay una fila para cada entrada de índice recuperada que no se puede atribuir a
ningún índice SQL. Esto se debe a que, en una base de datos SQLite, se usa el mismo formato
para almacenar entradas de índice SQL y SIN entradas de tabla ROWID.

Columna Contenido

rootpgno Aunque no sea posible atribuir la fila a una tabla de base de datos específica, puede ser parte de u
esa estructura de árbol se almacena en esta columna. O bien, si la página en la que se encontró la
"pgno": el número de página de la página en la que se encontró la fila. En muchos casos, aunque
columna pertenecen a la misma tabla.

pgno El número de página de la página en la que se encontró esta fila.

campo El número de campos en esta fila.

identificación Si la fila proviene de una tabla SIN ROWID, esta columna contiene NULL. De lo contrario, cont

c0, c1, c2... Los valores de cada columna de la fila se almacenan en estas columnas. El comando ".recover" c
 Si el esquema de la base de datos recuperada ya contiene una tabla denominada
"lost_and_found", el comando ".recover" usa el nombre "lost_and_found0". Si el nombre
"lost_and_found0" también está en uso, "lost_and_found1", y así sucesivamente. El nombre
predeterminado "lost_and_found" se puede anular invocando ".recover" con el modificador --lost-
and-found. Por ejemplo, para que el script de salida llame a la tabla "orphaned_rows":

sqlite> .recover --filas_huérfanas perdidas y encontradas

12. Extensiones de carga

Puede agregar nuevas funciones SQL personalizadas definidas por la aplicación , secuencias de

clasificación , tablas virtuales y VFS al shell de la línea de comandos en tiempo de ejecución
mediante el comando ".load". Primero, cree la extensión como una DLL o biblioteca compartida
(como se describe en el documento Extensiones cargables en tiempo de ejecución ) y luego
escriba:

sqlite> .load /ruta/a/mi_extensión

Tenga en cuenta que SQLite agrega automáticamente el sufijo de extensión apropiado (".dll" en
Windows, ".dylib" en Mac, ".so" en la mayoría de los otros Unixes) al nombre del archivo de
extensión. Por lo general, es una buena idea especificar la ruta completa de la extensión.

SQLite calcula el punto de entrada para la extensión en función del nombre del archivo de la
extensión. Para anular esta opción, simplemente agregue el nombre de la extensión como segundo
argumento al comando ".load".

El código fuente de varias extensiones útiles se puede encontrar en el subdirectorio ext/misc del

árbol fuente de SQLite. Puede usar estas extensiones tal cual o como base para crear sus propias
extensiones personalizadas para abordar sus necesidades particulares.

13. Hashes criptográficos del contenido de la base de datos

El comando de punto ".sha3sum" calcula un hash SHA3 del contenido de la base de datos. Para

ser claros, el hash se calcula sobre el contenido de la base de datos, no sobre su representación en
el disco. Esto significa, por ejemplo, que un VACUUM o una transformación de conservación de
datos similar no cambia el hash.

El comando ".sha3sum" admite las opciones "--sha3-224", "--sha3-256", "--sha3-384" y "--sha3-

512" para definir qué variedad de SHA3 usar para el picadillo. El valor predeterminado es SHA3-
256.

El esquema de la base de datos (en la tabla sqlite_schema ) normalmente no se incluye en el hash,

pero se puede agregar mediante la opción "--schema".

El comando ".sha3sum" toma un solo argumento opcional que es un patrón LIKE . Si esta opción
está presente, solo las tablas cuyos nombres coincidan con el patrón LIKE serán codificadas.

El comando ".sha3sum" se implementa con la ayuda de la función de extensión

"sha3_query()" que se incluye con el shell de línea de comandos.

14. Autoevaluación del contenido de la base de datos

 El comando ".selftest" intenta verificar que una base de datos esté intacta y no esté dañada. El
comando .selftest busca una tabla en el esquema denominada "selftest" y definida de la siguiente
manera:

CREAR TABLA autodiagnóstico (

tno INTEGER PRIMARY KEY, -- Número de prueba
op TEXTO, -- 'ejecutar' o 'memorándum'
cmd TEXT, -- comando SQL para ejecutar, o texto de "memo"
ans TEXT -- Resultado esperado del comando SQL
);

El comando .selftest lee las filas de la tabla de autocomprobación en orden selftest.tno. Para cada
fila de 'memo', escribe el texto en 'cmd' en la salida. Para cada fila 'ejecutar', ejecuta el texto 'cmd'
como SQL y compara el resultado con el valor en 'ans', y muestra un mensaje de error si los
resultados difieren.

Si no hay una tabla de autocomprobación, el comando ".selftest"

ejecuta PRAGMA Integrity_check .

El comando ".selftest --init" crea la tabla de autocomprobación si aún no existe, luego agrega
entradas que verifican el hash SHA3 del contenido de todas las tablas. Las ejecuciones posteriores
de ".selftest" verificarán que la base de datos no haya cambiado de ninguna manera. Para generar
pruebas para verificar que un subconjunto de las tablas no ha cambiado, simplemente ejecute
".selftest --init" y luego ELIMINE las filas de autoprueba que se refieren a tablas que no son
constantes.

15. Compatibilidad con archivos SQLite

El comando de punto ".archive" y la opción de línea de comando "-A" brindan soporte integrado
para el formato SQLite Archive . La interfaz es similar a la del comando "tar" en los sistemas
Unix. Cada invocación del comando ".ar" debe especificar una sola opción de comando. Los
siguientes comandos están disponibles para ".archive":

Opción Opción larga Objetivo

-C --crear Cree un nuevo archivo que contenga los archivos especificados.

-X --extracto Extraiga los archivos especificados del archivo.

-i --insertar Agregar archivos al archivo existente.

-r --retirar Eliminar archivos del archivo.

-t --lista Enumere los archivos en el archivo.

 -tu --actualizar Agregue archivos al archivo existente si han cambiado.

Además de la opción de comando, cada invocación de ".ar" puede especificar una o más opciones
de modificador. Algunas opciones de modificador requieren un argumento, otras no. Las
siguientes opciones de modificador están disponibles:

Opción Opción larga Objetivo

-v --verboso Enumere cada archivo a medida que se procesa.

-f ARCHIVO --archivo ARCHIVO Si se especifica, utilice el archivo ARCHIVO como archivo. De lo contra

-un archivo --añadir ARCHIVO Al igual que --file, use file FILE como el archivo, pero abra el archivo us

-C DIR --directorio DIR Si se especifica, interpreta todas las rutas relativas como relativas a DIR,

-gramo --globo Use glob( Y , X ) para hacer coincidir los argumentos con los nombres en

-norte --dryrun Muestre el SQL que se ejecutaría para llevar a cabo la operación de archi

-- -- Todas las palabras de línea de comando subsiguientes son argumentos de

Para el uso de la línea de comandos, agregue las opciones de línea de comandos de estilo
abreviado inmediatamente después de "-A", sin un espacio intermedio. Todos los argumentos
posteriores se consideran parte del comando .archive. Por ejemplo, los siguientes comandos son
equivalentes:

sqlite3 nuevo_archivo.db -Acv archivo1 archivo2 archivo3

sqlite3 nuevo_archivo.db ".ar -cv archivo1 archivo2 archivo3"

Las opciones de estilo largo y corto se pueden mezclar. Por ejemplo, los siguientes son
equivalentes:

-- Dos formas de crear un nuevo archivo llamado "nuevo_archivo.db" que contiene

-- los archivos "archivo1", "archivo2" y "archivo3".
.ar -c --file nuevo_archivo.db archivo1 archivo2 archivo3
.ar -f nuevo_archivo.db --crear archivo1 archivo2 archivo3

Alternativamente, el primer argumento que sigue a ".ar" puede ser la concatenación de la forma
abreviada de todas las opciones requeridas (sin los caracteres "-"). En este caso, los argumentos
 de las opciones que los requieren se leen a continuación desde la línea de comando y las palabras
restantes se consideran argumentos de comando. Por ejemplo:

-- Cree un nuevo archivo "nuevo_archivo.db" que contenga los archivos "archivo1" y

-- "archivo2" del directorio "dir1".
.ar cCf dir1 nuevo_archivo.db archivo1 archivo2 archivo3

15.1. Comando de creación de archivo SQLite

Cree un nuevo archivo, sobrescribiendo cualquier archivo existente (ya sea en la base de datos
"principal" actual o en el archivo especificado por una opción --file). Cada argumento que sigue a
las opciones es un archivo para agregar al archivo. Los directorios se importan
recursivamente. Véase más arriba para ver ejemplos.

15.2. Comando de extracción de archivo SQLite

Extraiga archivos del archivo (ya sea al directorio de trabajo actual o al directorio especificado
por una opción --directory). Se extraen los archivos o directorios cuyos nombres coinciden con
los argumentos, según se vean afectados por la opción --glob. O, si no hay argumentos después de
las opciones, se extraen todos los archivos y directorios. Los directorios especificados se extraen
recursivamente. Es un error si los nombres especificados o los patrones de coincidencia no se
pueden encontrar en el archivo.

-- Extraiga todos los archivos del archivo en la base de datos "principal" actual al
-- directorio de trabajo actual. Muestra los archivos a medida que se extraen.
.ar --extraer --verbose

-- Extraiga el archivo "file1" del archivo "ar.db" al directorio "dir1".

.ar fCx ar.db dir1 archivo1

-- Extraer archivos con extensión ".h" al directorio "headers".

.ar -gCx encabezados *.h

15.3. Comando de lista de archivos SQLite

Enumere el contenido del archivo. Si no se especifican argumentos, se enumeran todos los

archivos. De lo contrario, solo se enumeran aquellos que coinciden con los argumentos, según se
vean afectados por la opción --glob. Actualmente, la opción --verbose no cambia el
comportamiento de este comando. Eso puede cambiar en el futuro.

-- Muestra el contenido del archivo en la base de datos "principal" actual. .

.ar --lista

15.4. Comandos de inserción y actualización de archivos SQLite

Los comandos --update y --insert funcionan como --create, excepto que no eliminan el archivo
actual antes de comenzar. Las nuevas versiones de los archivos reemplazan silenciosamente los
archivos existentes con los mismos nombres, pero por lo demás, el contenido inicial del archivo
(si lo hay) permanece intacto.

Para el comando --insert, todos los archivos enumerados se insertan en el archivo

comprimido. Para el comando --update, los archivos solo se insertan si no existen previamente en
el archivo, o si su "mtime" o "modo" es diferente de lo que está actualmente en el archivo.
 Nodo de compatibilidad: antes de SQLite versión 3.28.0 (2019-04-16), solo se admitía la opción
--update, pero esa opción funcionaba como --insert en el sentido de que siempre reinsertaba todos
los archivos independientemente de si habían cambiado o no.

15.5. Comando de eliminación de archivo SQLite

El comando --remove elimina archivos y directorios que coincidan con los argumentos
proporcionados (si los hay) afectados por la opción --glob. Es un error proporcionar argumentos
que no coincidan con nada en el archivo.

15.6. Operaciones en archivos ZIP

Si FILE es un archivo ZIP en lugar de un archivo SQLite, el comando ".archive" y la opción de

línea de comandos "-A" seguirán funcionando. Esto se logra usando la extensión zipfile . Por lo
tanto, los siguientes comandos son aproximadamente equivalentes y difieren solo en el formato
de salida:

Comando Tradicional Comando sql

descomprimir archivo.zip sqlite3 -archiv

descomprimir -l archivo.zip sqlite3 -Atvf a

zip -r archive2.zip directorio sqlite3 -Acf ar

15.7. SQL utilizado para implementar operaciones de archivo de SQLite

Los diversos comandos de SQLite Archive Archive se implementan mediante sentencias

SQL. Los desarrolladores de aplicaciones pueden agregar fácilmente soporte de lectura y escritura
de SQLite Archive Archive a sus propios proyectos ejecutando el SQL apropiado.

Para ver qué instrucciones SQL se utilizan para implementar una operación de archivo SQLite,
agregue la opción --dryrun o -n. Esto hace que se muestre el SQL pero inhibe la ejecución del
SQL.

Las instrucciones SQL utilizadas para implementar las operaciones de SQLite Archive hacen uso
de varias extensiones cargables . Todas estas extensiones están disponibles en el árbol fuente de
SQLite en la subcarpeta ext/misc/ . Las extensiones necesarias para el soporte completo de
SQLite Archive incluyen:

1. fileio.c : esta extensión agrega funciones SQL readfile() y writefile() para leer y escribir
contenido de archivos en el disco. La extensión fileio.c también incluye la función con
valores de tabla fsdir() para enumerar el contenido de un directorio y la función lsmode()
para convertir enteros numéricos st_mode de la llamada al sistema stat() en cadenas
legibles por humanos al estilo de " comando ls -l".
 2. sqlar.c : esta extensión agrega las funciones sqlar_compress() y sqlar_uncompress() que
son necesarias para comprimir y descomprimir el contenido del archivo a medida que se
inserta y extrae de un archivo SQLite.

3. zipfile.c : esta extensión implementa la función con valores de tabla "zipfile(FILE)" que
se utiliza para leer archivos ZIP. Esta extensión solo es necesaria cuando se leen archivos
ZIP en lugar de archivos SQLite.

4. appendvfs.c : esta extensión implementa un nuevo VFS que permite agregar una base de

datos SQLite a algún otro archivo, como un ejecutable. Esta extensión solo es necesaria si
se usa la opción --append al comando .archive.

16. Parámetros SQL

SQLite permite que los parámetros vinculados aparezcan en una instrucción SQL en cualquier

lugar donde se permita un valor literal. Los valores de estos parámetros se establecen mediante
la familia de API sqlite3_bind_...() .

Los parámetros pueden ser con nombre o sin nombre. Un parámetro sin nombre es un solo signo
de interrogación ("?"). Los parámetros con nombre son un "?" seguido inmediatamente por un
número (ej: "?15" o "?123") o uno de los caracteres "$", ":" o "@" seguido de un nombre
alfanumérico (ej: "$var1", ": xyz", "@bingo").

Este shell de línea de comandos deja los parámetros sin nombre sin vincular, lo que significa que
tendrán un valor de SQL NULL, pero a los parámetros con nombre se les pueden asignar
valores. Si existe una tabla TEMP llamada "sqlite_parameters" con un esquema como este:

CREAR TABLA TEMPORAL sqlite_parameters(

clave TEXTO CLAVE PRINCIPAL,
valor
) SIN ROWID;

Y si hay una entrada en esa tabla donde la columna clave coincide exactamente con el nombre del
parámetro (incluido el carácter inicial "?", "$", ":" o "@"), entonces al parámetro se le asigna el
valor del columna de valor Si no existe ninguna entrada, el parámetro predeterminado es NULL.

El comando ".parameter" existe para simplificar la gestión de esta tabla. El comando ".parameter
init" (a menudo abreviado simplemente como ".param init") crea la tabla temp.sqlite_parameters
si aún no existe. El comando ".param list" muestra todas las entradas en la tabla
temp.sqlite_parameters. El comando ".param clear" elimina la tabla temp.sqlite_parameters. Los
comandos ".param set KEY VALUE" y ".param unset KEY" crean o eliminan entradas de la tabla
temp.sqlite_parameters.

El VALOR pasado a ".param set KEY VALUE" puede ser un literal SQL o cualquier otra
expresión o consulta SQL que pueda evaluarse para generar un valor. Esto permite establecer
valores de diferentes tipos. Si dicha evaluación falla, el VALOR proporcionado se cita y se
inserta como texto. Debido a que dicha evaluación inicial puede fallar o no según el valor del
contenido de VALUE, la forma confiable de obtener un valor de texto es incluirlo entre comillas
simples protegidas del análisis de cola de comando descrito anteriormente. Por ejemplo, (a menos
que se pretenda un valor de -1365):

.iniciar parámetro
.parameter set @phoneNumber "'202-456-1111'"
 Tenga en cuenta que las comillas dobles sirven para proteger las comillas simples y garantizar
que el texto citado se analice como un argumento.

La tabla temp.sqlite_parameters solo proporciona valores para los parámetros en el shell de la

línea de comandos. La tabla temp.sqlite_parameter no tiene efecto en las consultas que se
ejecutan directamente mediante la API del lenguaje C de SQLite. Se espera que las aplicaciones
individuales implementen su propio enlace de parámetros. Puede buscar "sqlite_parameters" en
el código fuente del shell de la línea de comandos para ver cómo el shell de la línea de comandos
enlaza parámetros y utilizarlo como una pista sobre cómo implementarlo usted mismo.

17. Recomendaciones de índice (experto en SQLite)

Nota: Este comando es experimental. Es posible que se elimine o que la interfaz se

modifique de manera incompatible en algún momento en el futuro.

Para la mayoría de las bases de datos SQL no triviales, la clave del rendimiento es crear los
índices SQL correctos. En este contexto, "los índices SQL correctos" significa aquellos que hacen
que las consultas que una aplicación necesita para optimizar se ejecuten rápidamente. El comando
".expert" puede ayudar con esto proponiendo índices que podrían ayudar con consultas
específicas, si estuvieran presentes en la base de datos.

Primero se emite el comando ".expert", seguido de la consulta SQL en una línea separada. Por
ejemplo, considere la siguiente sesión:

sqlite> CREAR TABLA x1(a, b, c); -- Crear tabla en la base de datos

sqlite> .experto
sqlite> SELECCIONE * DESDE x1 DONDE a=? Yb>?; -- Analizar este SELECCIONAR
CREAR ÍNDICE x1_idx_000123a7 EN x1(a, b);

0|0|0|TABLA DE BÚSQUEDA x1 UTILIZANDO EL ÍNDICE x1_idx_000123a7 (a=? Y b>?)

sqlite> CREAR ÍNDICE x1ab EN x1(a, b); -- Crear el índice recomendado

sqlite> .experto
sqlite> SELECCIONE * DESDE x1 DONDE a=? Yb>?; -- Vuelva a analizar el mismo SELECT
(sin índices nuevos)

0|0|0|TABLA DE BÚSQUEDA x1 UTILIZANDO EL ÍNDICE x1ab (a=? Y b>?)

En lo anterior, el usuario crea el esquema de la base de datos (una sola tabla - "x1") y luego usa el
comando ".expert" para analizar una consulta, en este caso "SELECT * FROM x1 WHERE a=?
AND b>? ". La herramienta de shell recomienda que el usuario cree un nuevo índice (índice
"x1_idx_000123a7") y genera el plan que usaría la consulta en formato EXPLAIN QUERY
PLAN . Luego, el usuario crea un índice con un esquema equivalente y vuelve a ejecutar el
análisis en la misma consulta. Esta vez, la herramienta de shell no recomienda ningún índice
nuevo y genera el plan que SQLite usará para la consulta dados los índices existentes.

El comando ".expert" acepta las siguientes opciones:

Opción Objetivo

--verboso Si está presente, genera un informe más detallado para cada consulta analizada.
 --muestra El valor predeterminado de este parámetro es 0, lo que hace que el comando ".expert" recom
PORCENTAJE forma en que el planificador de consultas SQLite selecciona índices para consultas si el usu
de datos.

Si a esta opción se le pasa un argumento distinto de cero, el comando ".expert" genera estad
PORCENTAJE de las filas actualmente almacenadas en cada tabla de la base de datos. Para
de índices, especialmente si la aplicación pretende ejecutar ANALYZE.

Para bases de datos pequeñas y CPU modernas, generalmente no hay razón para no pasar "-
tablas de bases de datos grandes. Si la operación es demasiado lenta, intente pasar un valor m

La funcionalidad descrita en esta sección se puede integrar en otras aplicaciones o herramientas

utilizando el código de extensión experto de SQLite .

Un esquema de base de datos que incorpore funciones personalizadas de SQL disponibles a través
del mecanismo de carga de extensión puede necesitar una disposición especial para trabajar con la
función .expert. Debido a que la función usa conexiones adicionales para implementar su
funcionalidad, esas funciones personalizadas deben estar disponibles para esas conexiones
adicionales. Esto se puede hacer por medio de las opciones de carga/uso de extensión descritas
en Cargar automáticamente extensiones vinculadas estáticamente y extensiones cargables
persistentes .

18. Trabajar con múltiples conexiones de base de datos

A partir de la versión 3.37.0 (2021-11-27), la CLI tiene la capacidad de mantener abiertas

varias conexiones de base de datos a la vez. Solo una conexión de base de datos está activa a la
vez. Las conexiones inactivas todavía están abiertas pero están inactivas.

Utilice el comando de punto ".conexión" (a menudo abreviado simplemente como ".conn") para
ver una lista de conexiones de bases de datos y una indicación de cuál está actualmente
activa. Cada conexión de base de datos se identifica con un número entero entre 0 y 9. (Puede
haber como máximo 10 conexiones abiertas simultáneamente). Cambie a otra conexión de base
de datos, creándola si aún no existe, escribiendo el comando ".conn" seguido de su número Cierre
una conexión a la base de datos escribiendo ".conn close N", donde N es el número de conexión.

Aunque las conexiones de la base de datos SQLite subyacentes son completamente

independientes entre sí, muchas de las configuraciones de la CLI, como el formato de salida, se
comparten entre todas las conexiones de la base de datos. Por lo tanto, cambiar el modo de
salida en una conexión lo cambiará en todas. Por otro lado, algunos comandos de
punto como .open solo afectan la conexión actual.

19. Otros comandos de puntos

Hay muchos otros comandos de puntos disponibles en el shell de línea de comandos. Consulte el

comando ".help" para obtener una lista completa de cualquier versión y compilación de SQLite en
particular.

20. Usar sqlite3 en un script de shell

 Una forma de usar sqlite3 en un script de shell es usar "echo" o "cat" para generar una secuencia
de comandos en un archivo, luego invocar sqlite3 mientras redirige la entrada desde el archivo de
comando generado. Esto funciona bien y es apropiado en muchas circunstancias. Pero como una
comodidad adicional, sqlite3 permite ingresar un solo comando SQL en la línea de comando
como segundo argumento después del nombre de la base de datos. Cuando se inicia el programa
sqlite3 con dos argumentos, el segundo argumento se pasa a la biblioteca SQLite para su
procesamiento, los resultados de la consulta se imprimen en la salida estándar en modo de lista y
el programa finaliza. Este mecanismo está diseñado para hacer que sqlite3 sea fácil de usar junto
con programas como "awk". Por ejemplo:

$ sqlite3 ex1 'seleccionar * de tbl1' \

> | awk '{printf "<tr><td>%s<td>%s\n",$1,$2 }'
<tr><td>hola<td>10
<tr><td>adiós<td>20
ps

21. Marcar el final de una instrucción SQL

Los comandos de SQLite normalmente terminan con un punto y coma. En la CLI, también puede
usar la palabra "GO" (sin distinción entre mayúsculas y minúsculas) o un carácter de barra
inclinada "/" en una sola línea para finalizar un comando. Estos son utilizados por SQL Server y
Oracle, respectivamente, y son compatibles con la CLI de SQLite para compatibilidad. Estos no
funcionarán en sqlite3_exec() , porque la CLI traduce estas entradas a un punto y coma antes de
pasarlas al núcleo de SQLite.

22. Opciones de línea de comandos

Hay muchas opciones de línea de comandos disponibles para la CLI. Utilice la opción de línea de
comandos --help para ver una lista:

$ sqlite3 --ayuda
Uso: ./sqlite3 [OPCIONES] NOMBRE DE ARCHIVO [SQL]
FILENAME es el nombre de una base de datos SQLite. Se crea una nueva base de datos.
si el archivo no existe previamente.
Las OPCIONES incluyen:
-A ARGS... ejecuta ".archive ARGS" y sal
-append agrega la base de datos al final del archivo
-ascii establece el modo de salida en 'ascii'
-bail stop después de golpear un error
-batch forzar E/S por lotes
-box establece el modo de salida en 'box'
-columna establece el modo de salida en 'columna'
-cmd COMMAND ejecutar "COMMAND" antes de leer stdin
-csv establece el modo de salida en 'csv'
-deserializar abre la base de datos usando sqlite3_deserialize()
-echo de comandos de impresión antes de la ejecución
-init NOMBRE DE ARCHIVO leer/procesar archivo con nombre
-[no]header activa o desactiva los encabezados
-ayuda mostrar este mensaje
-html establece el modo de salida en HTML
-E/S interactiva de fuerza interactiva
-json establece el modo de salida en 'json'
 -línea establece el modo de salida en 'línea'
-list establece el modo de salida en 'lista'
-lookaside SIZE N usa N entradas de SZ bytes para la memoria lookaside
-markdown establece el modo de salida en 'markdown'
-maxsize N tamaño máximo para una base de datos --deserialize
-memtrace rastrea todas las asignaciones y desasignaciones de memoria
-mmap N tamaño predeterminado de mmap establecido en N
-Separador de fila de salida de conjunto de SEP de nueva línea. Valor predeterminado: '\n'
-nofollow se niega a abrir enlaces simbólicos a archivos de base de datos
-nonce STRING establece el nonce de escape en modo seguro
-nullvalue TEXT establece una cadena de texto para valores NULL. Defecto ''
-pagecache SIZE N usa N ranuras de SZ bytes cada una para la memoria caché de página
-quote establece el modo de salida en 'quote'
-readonly abre la base de datos de solo lectura
-seguro habilitar modo seguro
-separador SEP establece el separador de columna de salida. Valor predeterminado: '|'
-stats imprime estadísticas de memoria antes de cada finalización
-tabla establece el modo de salida en 'tabla'
-tabs establece el modo de salida en 'tabs'
-versión muestra la versión de SQLite
-vfs NOMBRE use NOMBRE como el VFS predeterminado
-zip abre el archivo como un archivo ZIP

La CLI es flexible con respecto al formato de opciones de la línea de comandos. Se permiten uno
o dos caracteres "-" iniciales. Por lo tanto, "-box" y "--box" significan lo mismo. Las opciones de
la línea de comandos se procesan de izquierda a derecha. Por lo tanto, una opción "--box" anulará
una opción anterior "--quote".

La mayoría de las opciones de la línea de comandos se explican por sí mismas, pero algunas
merecen una discusión adicional a continuación.

22.1. La opción de línea de comandos --safe

La opción de línea de comandos --safe intenta deshabilitar todas las funciones de la CLI que
podrían causar cambios en la computadora host que no sean cambios en el archivo de base de
datos específico mencionado en la línea de comandos. La idea es que si recibe una secuencia de
comandos SQL grande de una fuente desconocida o que no es de confianza, puede ejecutar esa
secuencia de comandos para ver lo que hace sin correr el riesgo de una explotación utilizando la
opción --safe. La opción --safe desactiva (entre otras cosas):

 El comando .open , a menos que se use la opción --hexdb o el nombre del archivo sea
":memory:". Esto evita que el script lea o escriba cualquier archivo de base de datos que
no esté nombrado en la línea de comandos original.
 El comando ADJUNTAR SQL.
 Funciones SQL que tienen efectos secundarios potencialmente dañinos, como edit(),
fts3_tokenizer(), load_extension(), readfile() y writefile().
 El comando .archive .
 Los comandos .backup y .save.
 El comando .importar .
 El comando .load .
 El comando .log.
 Los comandos .shell y .system.
  Los comandos .excel, .once y .output.
 Otros comandos que pueden tener efectos secundarios nocivos.

Básicamente, cualquier función de la CLI que lea o escriba desde un archivo en el disco que no
sea el archivo de la base de datos principal está deshabilitada.

22.1.1. Omitiendo --restricciones seguras para comandos específicos

Si la opción "--nonce NONCE" también se incluye en la línea de comandos, para una cadena
NONCE grande y arbitraria, entonces el comando ".nonce NONCE" (con la misma cadena nonce
grande) permitirá la siguiente instrucción SQL o punto -comando para eludir las restricciones --
safe.

Suponga que desea ejecutar una secuencia de comandos sospechosa y la secuencia de comandos
requiere una o dos de las funciones que --safe normalmente desactiva. Por ejemplo, suponga que
necesita ADJUNTAR una base de datos adicional. O suponga que el script necesita cargar una
extensión específica. Esto se puede lograr precediendo la instrucción ATTACH (cuidadosamente
auditada) o el comando ".load" con un comando ".nonce" apropiado y proporcionando el mismo
valor nonce usando la opción de línea de comando "--nonce". Esos comandos específicos podrán
ejecutarse normalmente, pero todos los demás comandos inseguros seguirán estando restringidos.

El uso de ".nonce" es peligroso en el sentido de que un error puede permitir que un script hostil
dañe su sistema. Por lo tanto, use ".nonce" con cuidado, con moderación y como último recurso
cuando no haya otras formas de hacer que un script se ejecute en modo --safe.

23. Compilando el programa sqlite3 desde fuentes

Para compilar el shell de la línea de comandos en sistemas Unix y en Windows con MinGW,
funciona el comando habitual configure-make:

sh configurar; hacer

El configure-make funciona ya sea que esté construyendo a partir de las fuentes canónicas del
árbol de fuentes o de un paquete combinado. Hay pocas dependencias. Cuando se construye a
partir de fuentes canónicas, se requiere un tclsh de trabajo . Si usa un paquete de amalgamación,
todo el trabajo de preprocesamiento que normalmente realiza tclsh ya se habrá llevado a cabo y
solo se requieren las herramientas de compilación normales.

Se necesita una biblioteca de compresión zlib en funcionamiento para que funcione

el comando .archive .

En Windows con MSVC, use nmake con Makefile.msc:

nmake /f Makefile.msc

Para una operación correcta del comando .archive , haga una copia del código fuente de zlib en el
subdirectorio compat/zlib del árbol fuente y compile de esta manera:

nmake /f Makefile.msc USE_ZLIB=1

23.1. Construcciones de bricolaje
 El código fuente de la interfaz de línea de comandos de sqlite3 se encuentra en un solo archivo
llamado "shell.c". El archivo fuente shell.c se genera a partir de otras fuentes, pero la mayor parte
del código para shell.c se puede encontrar en src/shell.c.in . (Regenere shell.c escribiendo "make
shell.c" del árbol de fuentes canónicas). Compile el archivo shell.c (junto con el código fuente de
la biblioteca sqlite3 ) para generar el ejecutable. Por ejemplo:

gcc -o sqlite3 shell.c sqlite3.c -ldl -lpthread -lz -lm

Se recomiendan las siguientes opciones adicionales de tiempo de compilación para proporcionar

un shell de línea de comandos con todas las funciones:

 -DSQLITE_THREADSAFE=0
 -DSQLITE_ENABLE_EXPLAIN_COMMENTS
 -DSQLITE_HAVE_ZLIB
 -DSQLITE_INTROSPECTION_PRAGMAS
 -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
 -DSQLITE_ENABLE_STMTVTAB
 -DSQLITE_ENABLE_DBPAGE_VTAB
 -DSQLITE_ENABLE_DBSTAT_VTAB
 -DSQLITE_ENABLE_OFFSET_SQL_FUNC
 -DSQLITE_ENABLE_JSON1
 -DSQLITE_ENABLE_RTREE
 -DSQLITE_ENABLE_FTS4
 -DSQLITE_ENABLE_FTS5