SQLite切换日志模式优化

复制#define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */#define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */#define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */#define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */#define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */#define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */1.2.3.4.5.6.7.8.9.10.11.12.

复制cflags

: [

... "-DSQLITE_THREADSAFE=2"

,

... ],1.2.3.4.5.6.

复制static void sqliteInitialize() {

// Enable multi-threaded mode. In this mode, SQLite is safe to use by multiple

// threads as long as no two threads use the same database connection at the same

// time (which we guarantee in the SQLite database wrappers).

sqlite3_config(SQLITE_CONFIG_MULTITHREAD);<<====关键步骤======

...

// Initialize SQLite.

sqlite3_initialize();

}1.2.3.4.5.6.7.8.9.10.11.12.13.

复制private void setMaxConnectionPoolSizeLocked

() {

if (!mConfiguration.isInMemoryDb

()

&& (mConfiguration.openFlags & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0

) {

mMaxConnectionPoolSize = SQLiteGlobal.getWALConnectionPoolSize();<<=====关键步骤=== } else

{

// We dont actually need to always restrict the connection pool size to 1 // for non-WAL databases. There might be reasons to use connection pooling // with other journal modes. However, we should always keep pool size of 1 for in-memory // databases since every :memory: db is separate from another. // For now, enabling connection pooling and using WAL are the same thing in the API. mMaxConnectionPoolSize = 1

;

}

}

/** * Gets the connection pool size when in WAL mode. */ public static int getWALConnectionPoolSize

() {

int value = SystemProperties.getInt("debug.sqlite.wal.poolsize"

,

Resources.getSystem().getInteger

(

com.android.internal.R.integer.db_connection_pool_size

));

return Math.max(2, value

);

}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.

复制<!-- Maximum number of database connections opened and managed by framework layer to handle queries on each database when using Write-Ahead Logging. --> <integer name="db_connection_pool_size">4</integer>1.2.3.4.

复制private OpenHelper getDelegate

() {

// getDelegate() is lazy because we dont want to File I/O until the call to // getReadableDatabase() or getWritableDatabase(). This is better because the call to // a getReadableDatabase() or a getWritableDatabase() happens on a background thread unless // queries are allowed on the main thread. // We defer computing the path the database from the constructor to getDelegate() // because context.getNoBackupFilesDir() does File I/O 🙁 synchronized (mLock

) {

if (mDelegate == null

) {

final FrameworkSQLiteDatabase[] dbRef = new FrameworkSQLiteDatabase[1

];

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && mName != null && mUseNoBackupDirectory

) {

File file = new File(mContext.getNoBackupFilesDir(), mName

);

mDelegate = new OpenHelper(mContext, file.getAbsolutePath(), dbRef, mCallback

);

} else

{

mDelegate = new OpenHelper(mContext, mName, dbRef, mCallback

);

}

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN

) {

<<============关键步骤==================>> mDelegate.setWriteAheadLoggingEnabled(mWriteAheadLoggingEnabled

);

}

}

return mDelegate

;

}

}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.

复制public static void setWriteAheadLoggingEnabled(@NonNull SQLiteOpenHelper sQLiteOpenHelper

,

boolean enabled

) {

sQLiteOpenHelper.setWriteAheadLoggingEnabled(enabled

);

}1.2.3.4.

复制#define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */1.

复制private void setJournalMode(String newValue

) {

String value = executeForString("PRAGMA journal_mode", null, null

);

if (!value.equalsIgnoreCase(newValue

)) {

try

{

<<=======关键步骤=========>> String result = executeForString("PRAGMA journal_mode=" + newValue, null, null

);

if (result.equalsIgnoreCase(newValue

)) {

return

;

}

// PRAGMA journal_mode silently fails and returns the original journal // mode in some cases if the journal mode could not be changed. } catch (SQLiteDatabaseLockedException ex

) {

// This error (SQLITE_BUSY) occurs if one connection has the database // open in WAL mode and another tries to change it to non-WAL.

}

...

}

}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.

复制static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement

) {

int err = sqlite3_step(statement);<<======关键步骤========== if (err != SQLITE_ROW

) {

throw_sqlite3_exception(env, connection->db

);

}

return err

;

}1.2.3.4.5.6.7.

复制int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){

u8 eOld = pPager->journalMode; /* Prior journalmode */

...

if( eMode!=eOld ){

/* Change the journal mode. */

assert( pPager->eState!=PAGER_ERROR );

pPager->journalMode = (u8)eMode;

...

if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){

...

sqlite3OsClose(pPager->jfd);

if( pPager->eLock>=RESERVED_LOCK ){

sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);

}else{

int rc = SQLITE_OK;

int state = pPager->eState;

assert( state==PAGER_OPEN || state==PAGER_READER );

if( state==PAGER_OPEN ){

rc = sqlite3PagerSharedLock(pPager);<<=====关键步骤==============

}

...

assert( state==pPager->eState );

}

}else if( eMode==PAGER_JOURNALMODE_OFF ){

sqlite3OsClose(pPager->jfd);

}

}

/* Return the new journal mode */

return (int)pPager->journalMode;

}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.

复制int sqlite3PagerSharedLock(Pager *pPager){

int rc = SQLITE_OK; /* Return code */

/* This routine is only called from b-tree and only when there are no

** outstanding pages. This implies that the pager state should either

** be OPEN or READER. READER is only possible if the pager is or was in

** exclusive access mode. */

assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );

assert( assert_pager_state(pPager) );

assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );

assert( pPager->errCode==SQLITE_OK );

if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){

int bHotJournal = 1; /* True if there exists a hot journal-file */

assert( !MEMDB );

assert( pPager->tempFile==0 || pPager->eLock==EXCLUSIVE_LOCK );

rc = pager_wait_on_lock(pPager, SHARED_LOCK);

if( rc!=SQLITE_OK ){

assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );

goto failed;

}

/* If a journal file exists, and there is no RESERVED lock on the

** database file, then it either needs to be played back or deleted.

*/

if( pPager->eLock<=SHARED_LOCK ){

rc = hasHotJournal(pPager, &bHotJournal);<<=========关键步骤=============

}

if( rc!=SQLITE_OK ){

goto failed;

}

if( bHotJournal ){

if( pPager->readOnly ){

rc = SQLITE_READONLY_ROLLBACK;

goto failed;

}

/* Get an EXCLUSIVE lock on the database file. At this point it is

** important that a RESERVED lock is not obtained on the way to the

** EXCLUSIVE lock. If it were, another process might open the

** database file, detect the RESERVED lock, and conclude that the

** database is safe to read while this process is still rolling the

** hot-journal back.*/

...

if( isOpen(pPager->jfd) ){

assert( rc==SQLITE_OK );

rc = pagerSyncHotJournal(pPager); <<============关键步骤==============

if( rc==SQLITE_OK ){

rc = pager_playback(pPager, !pPager->tempFile);

pPager->eState = PAGER_OPEN;

}

}else if( !pPager->exclusiveMode ){1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.

复制static int hasHotJournal(Pager *pPager, int *pExists){

sqlite3_vfs * const pVfs = pPager->pVfs;

int rc = SQLITE_OK; /* Return code */

int exists = 1; /* True if a journal file is present */

int jrnlOpen = !!isOpen(pPager->jfd);

assert( pPager->useJournal );

assert( isOpen(pPager->fd) );

assert( pPager->eState==PAGER_OPEN );

assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &

SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN

));

*pExists = 0;

if( !jrnlOpen ){

rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);

}

if( rc==SQLITE_OK && exists ){

int locked = 0; /* True if some process holds a RESERVED lock */

/* Race condition here: Another process might have been holding the

** the RESERVED lock and have a journal open at the sqlite3OsAccess()

** call above, but then delete the journal and drop the lock before

** we get to the following sqlite3OsCheckReservedLock() call. If that

** is the case, this routine might think there is a hot journal when

** in fact there is none. This results in a false-positive which will

** be dealt with by the playback routine. Ticket #3883.

*/

rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);

if( rc==SQLITE_OK && !locked ){

Pgno nPage; /* Number of pages in database file */

assert( pPager->tempFile==0 );

rc = pagerPagecount(pPager, &nPage);

if( rc==SQLITE_OK ){

/* If the database is zero pages in size, that means that either (1) the

** journal is a remnant from a prior database with the same name where

** the database file but not the journal was deleted, or (2) the initial

** transaction that populates a new database is being rolled back.

** In either case, the journal file can be deleted. However, take care

** not to delete the journal file if it is already open due to

** journal_mode=PERSIST.

*/

if( nPage==0 && !jrnlOpen ){

sqlite3BeginBenignMalloc();

if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){

sqlite3OsDelete(pVfs, pPager->zJournal, 0);

if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);

}

sqlite3EndBenignMalloc();

}else{

/* The journal file exists and no other connection has a reserved

** or greater lock on the database file. Now check that there is

** at least one non-zero bytes at the start of the journal file.

** If there is, then we consider this journal to be hot. If not,

** it can be ignored.

*/

if( !jrnlOpen ){

int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;

rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);

}

if( rc==SQLITE_OK ){

u8 first = 0;

rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);

if( rc==SQLITE_IOERR_SHORT_READ ){

rc = SQLITE_OK;

}

if( !jrnlOpen ){

sqlite3OsClose(pPager->jfd);

}

*pExists = (first!=0);

}else if( rc==SQLITE_CANTOPEN ){

/* If we cannot open the rollback journal file in order to see if

** it has a zero header, that might be due to an I/O error, or

** it might be due to the race condition described above and in

** ticket #3883. Either way, assume that the journal is hot.

** This might be a false positive. But if it is, then the

** automatic journal playback and recovery mechanism will deal

** with it under an EXCLUSIVE lock where we do not need to

** worry so much with race conditions.

*/

*pExists = 1;

rc = SQLITE_OK;

}

}

}

}

}

return rc;

}1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.61.62.63.64.65.66.67.68.69.70.71.72.73.74.75.76.77.78.79.80.81.82.83.84.85.86.87.88.89.90.91.92.