PRAGMA SQLite

La commande PRAGMA SQLite est une commande spéciale utilisée pour contrôler diverses variables d'environnement et indicateurs d'état dans l'environnement SQLite. Les valeurs PRAGMA peuvent être lues et peuvent également être définies selon les besoins.

Syntaxe

Pour obtenir la valeur actuelle de PRAGMA, fournissez simplement le nom de l'indication de compilation.

PRAGMA pragma_name;

Pour définir une nouvelle valeur pour PRAGMA, utilisez la syntaxe suivante.

PRAGMA pragma_name = value;

Le mode peut être un nom ou un entier équivalent, mais la valeur retournée est toujours un entier.

Pragma auto_vacuum

auto_vacuum PRAGMA obtenir ou définir le mode auto-vacuum. Voici une syntaxe simple.

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

Où est le suivantmodePeut être-

Pragma cache_size

cache_sizeLa compilation peut obtenir ou définir temporairement la taille maximale du cache de pages en mémoire. Voici une syntaxe simple.

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 intégré est2, avec une taille minimale de10pages.

case_sensitive_like Pragma

case_sensitive_like Pragma contrôle la sensibilité à la casse des expressions LIKE intégrées. Par défaut, ce pragma est défini sur false, ce qui signifie que l'opérateur LIKE intégré ignore la casse des lettres. Voici une syntaxe simple.

PRAGMA case_sensitive_like = [true|false];

Il est impossible de consulter l'état actuel de cette instruction de compilation.

count_changes Pragma

count_changes Pragma récupère ou configure la valeur de retour des instructions d'opérations de données (par exemple INSERT, UPDATE et DELETE). Voici une syntaxe simple.

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

Par défaut, cette instruction de compilation est définie sur false et ces instructions ne renvoient rien. Si elle est définie sur true, chaque instruction mentionnée renvoie un tableau à une colonne et une ligne, composé d'une valeur entière indiquant le nombre de lignes affectées par cette opération.

database_list Pragma

database_listCe programme est utilisé pour lister toutes les bases de données supplémentaires. Voici une syntaxe simple.

PRAGMA database_list;

Ce programme renvoie un tableau à trois colonnes, avec une ligne pour chaque base de données ouverte ou connectée, indiquant le numéro de séquence de la base de données, son nom et le fichier associé.

encoding Pragma

encoding Pragma contrôle comment les chaînes de contrôle sont codées et stockées dans les fichiers de base de données. Voici une syntaxe simple.

PRAGMA encoding;
PRAGMA encoding = format;

La valeur du format peut êtreUTF-8, UTF-16leouUTF-16êtrel'un des

freelist_count Pragma

freelist_count Pragma renvoie un entier, indiquant comment de nombreuses pages de base de données sont actuellement marquées comme disponibles et libres. Voici une syntaxe simple.

PRAGMA [database.]freelist_count;

La valeur du format peut êtreUTF-8, UTF-16ouUTF-16êtrel'un des

index_info Pragma

index_info Pragma renvoie des informations sur les indexes de la base de données. Voici une syntaxe simple

PRAGMA [database.]index_info(index_name);

Le jeu de résultats contiendra une ligne pour chaque colonne incluse dans l'index, fournissant ainsi l'ordre des colonnes, l'index des colonnes dans la table et le nom de la colonne.

index_list Pragma

index_list Pragma liste tous les indexes associés à la table. Voici une syntaxe simple

PRAGMA [database.]index_list(table_name);

Le jeu de résultats contiendra une ligne pour chaque index, fournissant ainsi la séquence de l'index, le nom de l'index et un indicateur indiquant si l'index est unique.

journal_mode Pragma

journal_mode Pragma récupère ou définit le mode de journal qui contrôle la manière dont les fichiers de journal sont stockés et traités. Voici une syntaxe simple

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

Le tableau suivant liste les cinq modes de journal pris en charge.

max_page_count PRAGMA

max_page_count PRAGMA récupère ou définit le nombre maximum de pages autorisé pour la base de données. Voici une syntaxe simple

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

La valeur par défaut est1,073,741,823Soit une page de gigaoctet, ce qui signifie que si le défaut est1 Si la taille de la page en KB est, la base de données peut croître jusqu'à1 TB.

page_count PRAGMA

page_count PRAGMA renvoie le nombre de pages actuelles de la base de données. Voici une syntaxe simple-

PRAGMA [database.]page_count;

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

page_size PRAGMA

page_size PRAGMA récupère ou définit la taille de la page de la base de données. Voici une syntaxe simple.

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

Par défaut, la taille autorisée est512、1024、2048、4096、8192、16384et32768Octets. La seule manière de changer la taille de la page d'une base de données existante est de définir la taille de la page, puis d'exécuter immédiatement VACUUM sur la base de données.

PRAGMA parser_trace

parser_trace PRAGMA indique le contrôle de l'état de débogage, car il analyse les commandes SQL. Voici une syntaxe simple.

PRAGMA parser_trace = [true|false];

Par défaut, il est réglé sur false, mais lorsqu'il est activé en le réglant sur true, l'analyseur SQL imprime son état pendant l'analyse des commandes SQL.

PRAGMA recursive_triggers

recursive_triggers PRAGMA récupère ou définit la fonction de déclencheurs récursifs. Si les déclencheurs récursifs ne sont pas activés, les opérations de déclencheur ne déclencheront pas un autre déclencheur. Voici une syntaxe simple.

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

PRAGMA schema_version

schema_version PRAGMA récupère ou définit la valeur de version de l'architecture stockée dans l'en-tête de la base de données. Voici une syntaxe simple.

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

C'est une32Un entier signé en bits utilisé pour suivre les modifications de l'architecture. Chaque fois qu'un commande de modification de modèle est exécutée (par exemple CREATE ... ou DROP ...), cette valeur est augmentée.

PRAGMA secure_delete

secure_delete PRAGMA est utilisé pour contrôler la manière dont le contenu est supprimé de la base de données. Voici une syntaxe simple.

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

La valeur par défaut du signe de suppression sécurisée est généralement off, mais elle peut être modifiée en utilisant l'option de construction SQLITE_SECURE_DELETE.

PRAGMA sql_trace

sql_trace PRAGMA est utilisé pour transférer les résultats du suivi SQL sur l'écran. Voici une syntaxe simple.

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

Il est nécessaire de compiler SQLite avec l'instruction SQLITE_DEBUG pour inclure cette indication de compilation.

PRAGMA synchronous

synchronous PRAGMA obtenir ou définir le mode de synchronisation disque actuel, contrôlant comment SQLite écrit activement les données sur le stockage physique. Voici une syntaxe simple.

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

SQLite prend en charge les modes de synchronisation suivants, comme indiqué dans le tableau suivant.

PRAGMA temp_store

temp_store PRAGMA obtenir ou définir le mode de stockage utilisé pour les fichiers de base de données temporaires. Voici une syntaxe simple.

PRAGMA temp_store;
PRAGMA temp_store = mode;

SQLite prend en charge les modes de stockage suivants.

PRAGMA temp_store_directory

temp_store_directory PRAGMA obtenir ou définir l'emplacement utilisé pour les fichiers de base de données temporaires. Voici une syntaxe simple.

PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';

PRAGMA user_version

user_versionIndication de compilation pour obtenir ou définir la valeur de version définie par l'utilisateur stockée dans l'en-tête de la base de données. Voici une syntaxe simple.

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

C'est une32La valeur entière signée, les développeurs peuvent la définir à des fins de suivi de version.

PRAGMA writable_schema

writable_schemaCompilation pour obtenir ou définir la capacité de modifier les tables système. Voici une syntaxe simple.

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

Si cet indicateur de compilation est défini, il est possible de créer et de modifier des tables commençant par sqlite_, y compris la table sqlite_master. Soyez prudent lors de l'utilisation de l'indicateur de compilation, car il peut entraîner une complète défaillance de la base de données.