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 PRAGMA | Descripción |
|---|---|
| 0 o NONE | Deshabilita 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 FULL | Habilita 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 INCREMENTAL | Habilita 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 PRAGMA | Descripción |
|---|---|
| DELETE | Modo predeterminado. En este modo, el archivo de registro se eliminará al final de la transacción. |
| TRUNCATE | El archivo de registro se trunca a una longitud de cero bytes. |
| PERSIST | El archivo de registro se deja en su lugar, pero el encabezado se reescribe, indicando que el registro ya no es válido. |
| MEMORY | Los registros se mantienen en memoria, no en disco. |
| OFF | No 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 PRAGMA | Descripción |
|---|---|
| 0 o OFF | No se realiza sincronización. |
| 1 o NORMAL | Sincroniza después de cada secuencia de operaciones de disco críticas. |
| 2 o FULL | Sincroniza 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 PRAGMA | Descripción |
|---|---|
| 0 o DEFAULT | Se usa el modo de tiempo de compilación de forma predeterminada. Normalmente es FILE. |
| 1 o FILE | Usa almacenamiento basado en archivos. |
| 2 o MEMORY | Usa 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