SQLiteDatabase.EnableWriteAheadLogging Méthode

[Android.Runtime.Register("enableWriteAheadLogging", "()Z", "GetEnableWriteAheadLoggingHandler")]
public virtual bool EnableWriteAheadLogging();

[<Android.Runtime.Register("enableWriteAheadLogging", "()Z", "GetEnableWriteAheadLoggingHandler")>]
abstract member EnableWriteAheadLogging : unit -> bool
override this.EnableWriteAheadLogging : unit -> bool

Retours

True si la journalisation en écriture anticipée est activée.

Attributs

RegisterAttribute

Exceptions

Remarques

La journalisation en écriture anticipée permet l’exécution parallèle de requêtes à partir de plusieurs threads sur la même base de données et réduit la probabilité de blocage sur les synchronisations du système de fichiers. La journalisation en écriture anticipée est beaucoup plus rapide dans la plupart des scénarios.

<Avantages et bonnes pratiques< h3>/h3>

La journalisation en écriture anticipée n’est pas activée par défaut. Toutefois, il est généralement recommandé aux applications d’activer la journalisation en écriture anticipée, sauf si l’application utilise des fonctionnalités SQLite qui ne sont pas compatibles avec la journalisation en écriture anticipée.

Lorsque la journalisation en écriture anticipée est activée, les opérations d’écriture se produisent dans un fichier journal distinct, ce qui permet aux lectures dans d’autres threads de continuer simultanément. Pendant qu’une écriture est en cours, les lecteurs d’autres threads perçoivent l’état de la base de données tel qu’il était avant le début de l’écriture. Une fois l’écriture terminée, les lecteurs d’autres threads perçoivent ensuite le nouvel état de la base de données.

Un autre avantage de la journalisation en écriture anticipée est qu’elle réduit le nombre d’appels au système de fsync fichiers sous-jacent. L’appel fsync peut bloquer les verrous système et a une faible latence de queue sur les appareils avec des systèmes de fichiers lents.

La façon la plus efficace d’activer la journalisation en écriture anticipée consiste à passer l’indicateur #ENABLE_WRITE_AHEAD_LOGGING à #openDatabase. Cela est plus efficace que l’appel #enableWriteAheadLogging. <pre> SQLiteDatabase db = SQLiteDatabase.openDatabase("db_filename", cursorFactory, SQLiteDatabase.CREATE_IF_NECESSARY | SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING, myDatabaseErrorHandler); </pre> <h3>Désactivation de la journalisation< en écriture anticipée/h3>

Si la base de données a des bases de données jointes, l’exécution de requêtes en parallèle n’est pas possible. De même, la journalisation en écriture anticipée n’est pas prise en charge pour les bases de données en lecture seule ou les bases de données mémoire. Dans ce cas, #enableWriteAheadLogging() retourne false.

Lorsque la journalisation en écriture anticipée n’est pas activée (la valeur par défaut ou après l’appel #disableWriteAheadLogging), il n’est pas possible de lire et d’écrire sur la base de données en même temps. Avant de modifier la base de données, l’enregistreur acquiert implicitement un verrou exclusif sur la base de données qui empêche les lecteurs d’accéder à la base de données jusqu’à ce que l’écriture soit terminée.

La journalisation en écriture anticipée augmente légèrement l’utilisation de la mémoire par SQLite. Vous pouvez mesurer l’impact sur la mémoire à l’aide d’outils tels que meminfo.

<Utilisation< h3>/h3>

Après avoir ouvert une base de données avec l’indicateur #ENABLE_WRITE_AHEAD_LOGGING ou en appelant cette méthode, l’exécution de requêtes en parallèle est activée tant que la base de données reste ouverte. Pour désactiver l’exécution de requêtes en parallèle, appelez #disableWriteAheadLogging ou fermez la base de données et rouvrez-la.

L’exécution parallèle des requêtes est effectuée en ouvrant plusieurs connexions à la base de données et en utilisant une connexion de base de données différente pour chaque requête. Le mode journal de base de données est également modifié pour permettre aux écritures de continuer simultanément avec les lectures. Le nombre maximal de connexions utilisées pour exécuter des requêtes en parallèle dépend de la mémoire de l’appareil et éventuellement d’autres propriétés.

Si une requête fait partie d’une transaction, elle est exécutée sur le même handle de base de données que celle-ci a été démarrée.

Les enregistreurs doivent utiliser #beginTransactionNonExclusive() ou #beginTransactionWithListenerNonExclusive(SQLiteTransactionListener) démarrer une transaction. Le mode non exclusif permet au fichier de base de données d’être lisible par d’autres threads exécutant des requêtes.

Si la base de données a des bases de données jointes, l’exécution de requêtes en parallèle n’est pas possible. De même, la journalisation en écriture anticipée n’est pas prise en charge pour les bases de données en lecture seule ou les bases de données mémoire. Dans ce cas, #enableWriteAheadLogging retourne false.

Consultez également SQLite Write-Ahead Journalisation pour plus d’informations sur le fonctionnement de la journalisation en écriture anticipée.

Java documentation pour android.database.sqlite.SQLiteDatabase.enableWriteAheadLogging().

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.

Voir aussi

• DisableWriteAheadLogging()