SQLite PRAGMA

La commandePRAGMAde SQLite est une commande spéciale qui peut être utilisée dans l'environnement SQLite pour contrôler diverses variables d'environnement et indicateurs d'état. Une valeur PRAGMA peut être lue et également définie selon les besoins.

Syntaxe

Pour interroger la valeur PRAGMA actuelle, il suffit de fournir le nom du pragma :

PRAGMA pragma_name;

Pour définir une nouvelle valeur du PRAGMA, la syntaxe est la suivante :

PRAGMA pragma_name = value;

Le mode de définition peut être un nom ou un entier équivalent, mais la valeur renvoyée sera toujours un entier.

Pragma auto_vacuum

auto_vacuumLe pragma obtient ou définit le mode auto-vacuum. La syntaxe est la suivante :

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

Où,modepeut être l'un des suivants :

Valeur du pragmaDescription
0 ou NONEDésactive l'auto-vacuum. Il s'agit du mode par défaut, ce qui signifie que la taille du fichier de base de données ne diminuera pas, sauf si la commande VACUUM est utilisée manuellement.
1 ou FULLActive l'auto-vacuum, qui est entièrement automatique. Dans ce mode, le fichier de base de données peut diminuer à mesure que des données sont supprimées de la base de données.
2 ou INCREMENTALActive l'auto-vacuum, mais il doit être activé manuellement. Dans ce mode, les données référencées sont maintenues, et les pages libres sont uniquement placées dans la liste des pages libres. Ces pages peuvent être utilisées à tout momentpragma incremental_vacuumpour l'écrasement.

Pragma cache_size

cache_sizeLe pragma peut obtenir ou définir temporairement la taille maximale du cache de pages en mémoire. La syntaxe est la suivante :

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

pagesLa valeur représente le nombre de pages dans le cache. La taille par défaut du cache de pages intégré est de 2,000 pages, avec une taille minimale de 10 pages.

Pragma case_sensitive_like

case_sensitive_likeLe pragma contrôle la sensibilité à la casse de l'expression LIKE intégrée. Par défaut, ce pragma est false, ce qui signifie que l'opérateur LIKE intégré ignore la casse des lettres. La syntaxe est la suivante :

PRAGMA case_sensitive_like = [true|false];

Il n'existe actuellement aucun moyen d'interroger l'état actuel de ce pragma.

Pragma count_changes

count_changesLe pragma obtient ou définit la valeur de retour des instructions de manipulation de données, telles que INSERT, UPDATE et DELETE. La syntaxe est la suivante :

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

Par défaut, ce pragma est false, et ces instructions ne renvoient rien. S'il est défini sur true, chacune des instructions mentionnées renverra une table d'une seule ligne et d'une seule colonne constituée d'une seule valeur entière représentant les lignes affectées par l'opération.

Pragma database_list

database_listLe pragma est utilisé pour lister toutes les connexions à la base de données. La syntaxe est la suivante :

PRAGMA database_list;

Ce pragma renverra une table à une ligne et trois colonnes. Chaque fois qu’une base de données est ouverte ou attachée, il donne le numéro de séquence de la base de données, son nom et le fichier associé.

encoding Pragma

encodingLe pragma contrôle la façon dont les chaînes sont encodées et stockées dans le fichier de base de données. La syntaxe est la suivante :

PRAGMA encoding;
PRAGMA encoding = format;

La valeur de format peut être l’une des suivantes : UTF-8, UTF-16le ou UTF-16be.

freelist_count Pragma

freelist_countLe pragma renvoie un entier représentant le nombre de pages de base de données actuellement marquées comme libres et disponibles. La syntaxe est la suivante :

PRAGMA [database.]freelist_count;

index_info Pragma

index_infoLe pragma renvoie des informations sur les index de base de données. La syntaxe est la suivante :

PRAGMA [database.]index_info( index_name );

Le jeu de résultats affichera une ligne pour chaque colonne contenue dans l’index donné, y compris la séquence de colonne, l’index de colonne dans la table et le nom de colonne.

index_list Pragma

index_listLe pragma liste tous les index associés à une table. La syntaxe est la suivante :

PRAGMA [database.]index_list( table_name );

Le jeu de résultats affichera une ligne pour chaque index, donnant la séquence d'index, le nom de l'index et un identifiant indiquant si l'index est unique.

Pragma journal_mode

journal_modeLe pragma obtient ou définit le mode journal qui contrôle la façon dont les fichiers journaux sont stockés et traités. La syntaxe est la suivante :

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

Cinq modes journal sont pris en charge ici :

Valeur du pragmaDescription
DELETELe mode par défaut. Dans ce mode, le fichier journal sera supprimé à la fin de la transaction.
TRUNCATELe fichier journal est tronqué à une longueur de zéro octet.
PERSISTLe fichier journal est laissé en place, mais l'en-tête est réécrit pour indiquer que le journal n'est plus valide.
MEMORYLes enregistrements du journal sont conservés en mémoire plutôt que sur disque.
OFFAucun enregistrement du journal n'est conservé.

max_page_count Pragma

max_page_countLe pragma obtient ou définit le nombre maximum de pages autorisées pour la base de données. La syntaxe est la suivante :

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

La valeur par défaut est 1,073,741,823, soit un gigaoctet de pages. Autrement dit, avec la taille de page par défaut de 1 KB, la base de données peut atteindre un téraoctet.

page_count Pragma

page_countLe pragma renvoie le nombre de pages dans la base de données actuelle. La syntaxe est la suivante :

PRAGMA [database.]page_count;

La taille du fichier de base de données doit être page_count * page_size.

page_size Pragma

page_sizeLe pragma obtient ou définit la taille des pages de la base de données. La syntaxe est la suivante :

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

Par défaut, les tailles autorisées sont 512, 1024, 2048, 4096, 8192, 16384 et 32768 octets. La seule façon de modifier la taille de page d'une base de données existante est de définir la taille de page puis d'exécuter immédiatement VACUUM sur la base de données.

parser_trace Pragma

parser_traceLe pragma contrôle l'impression de l'état de débogage lors de l'analyse des commandes SQL. La syntaxe est la suivante :

PRAGMA parser_trace = [true|false];

Par défaut, il est défini sur false, mais il est activé lorsqu'il est défini sur true. Dans ce cas, l'analyseur SQL imprimera son état lors de l'analyse des commandes SQL.

Pragma recursive_triggers

recursive_triggersLe pragma permet d'obtenir ou de définir la fonctionnalité de déclencheurs récursifs. Si les déclencheurs récursifs ne sont pas activés, l'action d'un déclencheur ne déclenchera pas un autre déclencheur. La syntaxe est la suivante :

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

Pragma schema_version

schema_versionLe pragma permet d'obtenir ou de définir la valeur de version du schéma stockée dans l'en-tête de la base de données. La syntaxe est la suivante :

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

Il s'agit d'une valeur entière signée de 32 bits utilisée pour suivre les modifications du schéma. Chaque fois qu'une commande modifiant le schéma est exécutée (comme CREATE... ou DROP...), cette valeur est incrémentée.

Pragma secure_delete

secure_deleteLe pragma est utilisé pour contrôler la manière dont le contenu est supprimé de la base de données. La syntaxe est la suivante :

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

La valeur par défaut de l'indicateur de suppression sécurisée est généralement désactivée, mais cela peut être modifié via l'option de compilation SQLITE_SECURE_DELETE.

Pragma sql_trace

sql_traceLe pragma est utilisé pour afficher les résultats de trace SQL à l'écran. La syntaxe est la suivante :

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

SQLite doit être compilé avec la directive SQLITE_DEBUG afin de pouvoir utiliser ce pragma.

Pragma synchronous

synchronousLe pragma permet d'obtenir ou de définir le mode actuel de synchronisation du disque, qui contrôle le degré d'agressivité avec lequel SQLite écrit les données sur le stockage physique. La syntaxe est la suivante :

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

SQLite prend en charge les modes de synchronisation suivants :

Valeur du pragmaDescription
0 ou OFFAucune synchronisation n'est effectuée.
1 ou NORMALSynchroniser après chaque séquence d'opérations critiques sur le disque.
2 ou FULLSynchroniser après chaque opération critique sur le disque.

Pragma temp_store

temp_storeLe pragma permet d'obtenir ou de définir le mode de stockage utilisé pour les fichiers de base de données temporaires. La syntaxe est la suivante :

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite prend en charge les modes de stockage suivants :

Valeur du pragmaDescription
0 ou DEFAULTUtilise par défaut le mode défini à la compilation. Habituellement FILE.
1 ou FILEUtilise un stockage basé sur des fichiers.
2 ou MEMORYUtilise un stockage basé sur la mémoire.

Pragma temp_store_directory

temp_store_directoryLe pragma obtient ou définit l'emplacement utilisé pour les fichiers de base de données temporaires. La syntaxe est la suivante :

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

Pragma user_version

user_versionLe pragma obtient ou définit la valeur de version définie par l'utilisateur stockée dans l'en-tête de la base de données. La syntaxe est la suivante :

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

Il s'agit d'une valeur entière signée de 32 bits qui peut être définie par les développeurs à des fins de suivi de version.

Pragma writable_schema

writable_schemaLe pragma obtient ou définit si les tables système peuvent être modifiées. La syntaxe est la suivante :

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

Si ce pragma est défini, les tables commençant par sqlite_ peuvent être créées et modifiées, y compris la table sqlite_master. Utilisez ce pragma avec prudence, car il peut entraîner la corruption de toute la base de données.

Autres extensions