SQLite PRAGMA

de SQLitePRAGMAEl comando es un comando especial que se puede usar dentro del entorno SQLite para controlar varias variables de entorno y indicadores de estado. Un valor PRAGMA puede ser leído, y también puede ser configurado según sea necesario.

Sintaxis

Para consultar el valor PRAGMA actual, solo proporcione el nombre de ese pragma:

PRAGMA pragma_name;

Para establecer un nuevo valor para PRAGMA, la sintaxis es la siguiente:

PRAGMA pragma_name = value;

El modo de configuración puede ser un nombre o un entero equivalente, pero el valor devuelto siempre será un entero.

auto_vacuum Pragma

auto_vacuumPRAGMA obtiene o establece el modo auto-vacuum. La sintaxis es la siguiente:

PRAGMA [database.]auto_vacuum;
PRAGMA [database.]auto_vacuum = mode;

Donde,modePuede ser cualquiera de los siguientes:

Valor PRAGMADescripción
0 o NONEDeshabilita Auto-vacuum. Este es el modo predeterminado, lo que significa que el tamaño del archivo de la base de datos no se reducirá, a menos que se use manualmente el comando VACUUM.
1 o FULLHabilita Auto-vacuum, es totalmente automático. En este modo, se permite que el archivo de la base de datos se reduzca a medida que los datos se eliminan de la base de datos.
2 o INCREMENTALHabilita Auto-vacuum, pero debe activarse manualmente. En este modo, los datos de referencia se mantienen, y las páginas libres solo se colocan en la lista libre. Estas páginas se pueden usar en cualquier momentoincremental_vacuum pragmapara sobrescribir.

cache_size Pragma

cache_sizePRAGMA puede obtener o establecer temporalmente el tamaño máximo de la caché de páginas en memoria. La sintaxis es la siguiente:

PRAGMA [database.]cache_size;
PRAGMA [database.]cache_size = pages;

pagesEl valor representa el número de páginas en la caché. El tamaño predeterminado de la caché de páginas incorporada es de 2,000 páginas, y el tamaño mínimo es de 10 páginas.

case_sensitive_like Pragma

case_sensitive_likePRAGMA controla la sensibilidad a mayúsculas y minúsculas de la expresión LIKE incorporada. De forma predeterminada, este PRAGMA es false, lo que significa que el operador LIKE incorporado ignora las mayúsculas y minúsculas de las letras. La sintaxis es la siguiente:

PRAGMA case_sensitive_like = [true|false];

Actualmente no hay forma de consultar el estado actual de este PRAGMA.

count_changes Pragma

count_changesPRAGMA obtiene o establece el valor de retorno de las sentencias de manipulación de datos, como INSERT, UPDATE y DELETE. La sintaxis es la siguiente:

PRAGMA count_changes;
PRAGMA count_changes = [true|false];

De forma predeterminada, este PRAGMA es false, y estas sentencias no devuelven nada. Si se establece en true, cada sentencia mencionada devolverá una tabla de una sola fila y una sola columna, compuesta por un único valor entero que representa las filas afectadas por la operación.

database_list Pragma

database_listPRAGMA se utiliza para enumerar todas las conexiones de base de datos. La sintaxis es la siguiente:

PRAGMA database_list;

Este PRAGMA devolverá una tabla de una sola fila y tres columnas. Cada vez que se abre o se adjunta una base de datos, se proporciona el número de secuencia, su nombre y el archivo asociado.

encoding Pragma

encodingPRAGMA controla cómo se codifican y almacenan las cadenas en el archivo de base de datos. La sintaxis es la siguiente:

PRAGMA encoding;
PRAGMA encoding = format;

El valor de formato puede ser uno de UTF-8, UTF-16le o UTF-16be.

freelist_count Pragma

freelist_countPRAGMA devuelve un entero que representa el número de páginas de base de datos actualmente marcadas como libres y disponibles. La sintaxis es la siguiente:

PRAGMA [database.]freelist_count;

index_info Pragma

index_infoPRAGMA devuelve información sobre los índices de la base de datos. La sintaxis es la siguiente:

PRAGMA [database.]index_info( index_name );

El conjunto de resultados mostrará una fila para cada columna que contenga el índice de la secuencia de columnas dada, el índice de la columna dentro de la tabla y el nombre de la columna.

index_list Pragma

index_listPRAGMA enumera todos los índices asociados con la tabla. La sintaxis es la siguiente:

PRAGMA [database.]index_list( table_name );

El conjunto de resultados mostrará una fila para cada índice que proporcione la secuencia de columnas, el nombre del índice y un indicador que muestre si el índice es único.

journal_mode Pragma

journal_modePRAGMA obtiene o establece el modo de registro que controla cómo se almacenan y procesan los archivos de registro. La sintaxis es la siguiente:

PRAGMA journal_mode;
PRAGMA journal_mode = mode;
PRAGMA database.journal_mode;
PRAGMA database.journal_mode = mode;

Aquí se admiten cinco modos de registro:

Valor PRAGMADescripción
DELETEModo predeterminado. En este modo, el archivo de registro se eliminará al final de la transacción.
TRUNCATEEl archivo de registro se trunca a una longitud de cero bytes.
PERSISTEl archivo de registro se deja en su lugar, pero el encabezado se reescribe, indicando que el registro ya no es válido.
MEMORYLos registros se mantienen en memoria, no en disco.
OFFNo se conserva ningún registro.

max_page_count Pragma

max_page_countPRAGMA obtiene o establece el número máximo de páginas permitido para la base de datos. La sintaxis es la siguiente:

PRAGMA [database.]max_page_count;
PRAGMA [database.]max_page_count = max_page;

El valor predeterminado es 1,073,741,823, que es una página de un gigabyte; es decir, si el tamaño de página predeterminado es de 1 KB, entonces la base de datos puede crecer hasta un terabyte.

page_count Pragma

page_countPRAGMA devuelve el número de páginas en la base de datos actual. La sintaxis es la siguiente:

PRAGMA [database.]page_count;

El tamaño del archivo de la base de datos debería ser page_count * page_size.

page_size Pragma

page_sizePRAGMA obtiene o establece el tamaño de la página de la base de datos. La sintaxis es la siguiente:

PRAGMA [database.]page_size;
PRAGMA [database.]page_size = bytes;

De forma predeterminada, los tamaños permitidos son 512, 1024, 2048, 4096, 8192, 16384, 32768 bytes. La única forma de cambiar el tamaño de página de una base de datos existente es establecer el tamaño de página y luego ejecutar VACUUM inmediatamente en esa base de datos.

parser_trace Pragma

parser_tracePRAGMA controla el estado de depuración impreso a medida que analiza comandos SQL. La sintaxis es la siguiente:

PRAGMA parser_trace = [true|false];

De forma predeterminada, se establece en false, pero cuando se establece en true se habilita, momento en el que el analizador SQL imprime su estado a medida que analiza los comandos SQL.

recursive_triggers Pragma

recursive_triggersPRAGMA obtiene o establece la funcionalidad de disparadores recursivos. Si los disparadores recursivos no están habilitados, una acción de disparador no activará otro disparador. La sintaxis es la siguiente:

PRAGMA recursive_triggers;
PRAGMA recursive_triggers = [true|false];

schema_version Pragma

schema_versionPRAGMA obtiene o establece el valor de versión de esquema almacenado en el encabezado de la base de datos. La sintaxis es la siguiente:

PRAGMA [database.]schema_version;
PRAGMA [database.]schema_version = number;

Este es un valor entero con signo de 32 bits que se utiliza para rastrear los cambios de esquema. Cada vez que se ejecuta un comando de cambio de esquema (como CREATE... o DROP...), este valor se incrementa.

secure_delete Pragma

secure_deletePRAGMA se usa para controlar cómo se elimina el contenido de la base de datos. La sintaxis es la siguiente:

PRAGMA secure_delete;
PRAGMA secure_delete = [true|false];
PRAGMA database.secure_delete;
PRAGMA database.secure_delete = [true|false];

El valor predeterminado del indicador de borrado seguro suele estar desactivado, pero esto se puede cambiar mediante la opción de compilación SQLITE_SECURE_DELETE.

sql_trace Pragma

sql_tracePRAGMA se usa para volcar los resultados del rastreo SQL en la pantalla. La sintaxis es la siguiente:

PRAGMA sql_trace;
PRAGMA sql_trace = [true|false];

SQLite debe compilarse con la directiva SQLITE_DEBUG para poder hacer referencia a este PRAGMA.

synchronous Pragma

synchronousPRAGMA obtiene o establece el modo de sincronización del disco actual, que controla cuán agresivamente SQLite escribe los datos en el almacenamiento físico. La sintaxis es la siguiente:

PRAGMA [database.]synchronous;
PRAGMA [database.]synchronous = mode;

SQLite admite los siguientes modos de sincronización:

Valor PRAGMADescripción
0 o OFFNo se realiza sincronización.
1 o NORMALSincroniza después de cada secuencia de operaciones de disco críticas.
2 o FULLSincroniza después de cada operación de disco crítica.

temp_store Pragma

temp_storePRAGMA obtiene o establece el modo de almacenamiento utilizado por los archivos de base de datos temporales. La sintaxis es la siguiente:

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite admite los siguientes modos de almacenamiento:

Valor PRAGMADescripción
0 o DEFAULTSe usa el modo de tiempo de compilación de forma predeterminada. Normalmente es FILE.
1 o FILEUsa almacenamiento basado en archivos.
2 o MEMORYUsa almacenamiento basado en memoria.

temp_store_directory Pragma

temp_store_directoryPRAGMA obtiene o establece la ubicación utilizada para los archivos de base de datos temporales. La sintaxis es la siguiente:

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

user_version Pragma

user_versionPRAGMA obtiene o establece el valor de versión definido por el usuario almacenado en el encabezado de la base de datos. La sintaxis es la siguiente:

PRAGMA [database.]user_version;
PRAGMA [database.]user_version = number;

Este es un valor entero con signo de 32 bits que puede ser establecido por el desarrollador para fines de seguimiento de versiones.

writable_schema Pragma

writable_schemaPRAGMA obtiene o establece si se pueden modificar las tablas del sistema. La sintaxis es la siguiente:

PRAGMA writable_schema;
PRAGMA writable_schema = [true|false];

Si se establece este PRAGMA, las tablas que comienzan con sqlite_ pueden crearse y modificarse, incluyendo la tabla sqlite_master. Se debe tener cuidado al usar este PRAGMA, ya que puede provocar daños en toda la base de datos.

Otras extensiones