[sql] Import reference version of SQLite 3.8.7.4.

third_party/sqlite/sqlite-src-3080704/src/test_journal.c

 /*
 ** 2008 Jan 22
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 ******************************************************************************
 **
 ** This file contains code for a VFS layer that acts as a wrapper around
 ** an existing VFS. The code in this file attempts to verify that SQLite
 ** correctly populates and syncs a journal file before writing to a
 ** corresponding database file.
-*/
-#if SQLITE_TEST          /* This file is used for testing only */
-
-#include "sqlite3.h"
-#include "sqliteInt.h"
-
-/*
+**
 ** INTERFACE
 **
 **   The public interface to this wrapper VFS is two functions:
 **
 **     jt_register()
 **     jt_unregister()
 **
 **   See header comments associated with those two functions below for 
 **   details.
 **
@@ skipping 58 matching lines @@
 **   discarded. The end of a transaction is recognized when any one 
 **   of the following occur:
 **
 **     a) A block of zeroes (or anything else that is not a valid 
 **        journal-header) is written to the start of the journal file.
 **
 **     b) A journal file is truncated to zero bytes in size using xTruncate.
 **
 **     c) The journal file is deleted using xDelete.
 */
+#if SQLITE_TEST          /* This file is used for testing only */
+
+#include "sqlite3.h"
+#include "sqliteInt.h"
 
 /*
 ** Maximum pathname length supported by the jt backend.
 */
 #define JT_MAX_PATHNAME 512
 
 /*
 ** Name used to identify this VFS.
 */
 #define JT_VFS_NAME "jt"
@@ skipping 173 matching lines @@
 **
 **   b) The file-name specified when the file was opened matches
 **      all but the final 8 characters of the journal file name.
 **
 **   c) There is currently a reserved lock on the file.
 **/
 static jt_file *locateDatabaseHandle(const char *zJournal){
   jt_file *pMain = 0;
   enterJtMutex();
   for(pMain=g.pList; pMain; pMain=pMain->pNext){
-    int nName = strlen(zJournal) - strlen("-journal");
+    int nName = (int)(strlen(zJournal) - strlen("-journal"));
     if( (pMain->flags&SQLITE_OPEN_MAIN_DB)
-     && (strlen(pMain->zName)==nName)
+     && ((int)strlen(pMain->zName)==nName)
      && 0==memcmp(pMain->zName, zJournal, nName)
      && (pMain->eLock>=SQLITE_LOCK_RESERVED)
     ){
       break;
     }
   }
   leaveJtMutex();
   return pMain;
 }
 
@@ skipping 78 matching lines @@
         u32 iPg;
         for(iPg=nDbsize+1; iPg<=pMain->nPage; iPg++){
           sqlite3BitvecSet(pMain->pWritable, iPg);
         }
       }
     }
     iTrunk = decodeUint32(&aData[32]);
     while( rc==SQLITE_OK && iTrunk>0 ){
       u32 nLeaf;
       u32 iLeaf;
-      sqlite3_int64 iOff = (iTrunk-1)*pMain->nPagesize;
+      sqlite3_int64 iOff = (i64)(iTrunk-1)*pMain->nPagesize;
       rc = sqlite3OsRead(p, aData, pMain->nPagesize, iOff);
       nLeaf = decodeUint32(&aData[4]);
       for(iLeaf=0; rc==SQLITE_OK && iLeaf<nLeaf; iLeaf++){
         u32 pgno = decodeUint32(&aData[8+4*iLeaf]);
         sqlite3BitvecSet(pMain->pWritable, pgno);
       }
       iTrunk = decodeUint32(aData);
     }
 
     /* Calculate and store a checksum for each page in the database file. */
     if( rc==SQLITE_OK ){
       int ii;
-      for(ii=0; rc==SQLITE_OK && ii<pMain->nPage; ii++){
+      for(ii=0; rc==SQLITE_OK && ii<(int)pMain->nPage; ii++){
         i64 iOff = (i64)(pMain->nPagesize) * (i64)ii;
         if( iOff==PENDING_BYTE ) continue;
         rc = sqlite3OsRead(pMain->pReal, aData, pMain->nPagesize, iOff);
         pMain->aCksum[ii] = genCksum(aData, pMain->nPagesize);
+        if( ii+1==pMain->nPage && rc==SQLITE_IOERR_SHORT_READ ) rc = SQLITE_OK;
       }
     }
 
     start_ioerr_simulation(iSave, iSave2);
   }
 
   sqlite3_free(aData);
   return rc;
 }
 
@@ skipping 36 matching lines @@
       /* A trick. There might be another journal-header immediately 
       ** following this one. In this case, 0 records means 0 records, 
       ** not "read until the end of the file". See also ticket #2565.
       */
       if( iSize>=(iOff+nSector) ){
         rc = sqlite3OsRead(pReal, zBuf, 28, iOff);
         if( rc!=SQLITE_OK || 0==decodeJournalHdr(zBuf, 0, 0, 0, 0) ){
           continue;
         }
       }
-      nRec = (iSize-iOff) / (pMain->nPagesize+8);
+      nRec = (u32)((iSize-iOff) / (pMain->nPagesize+8));
     }
 
     /* Read all the records that follow the journal-header just read. */
     for(ii=0; rc==SQLITE_OK && ii<nRec && iOff<iSize; ii++){
       u32 pgno;
       rc = sqlite3OsRead(pReal, zBuf, 4, iOff);
       if( rc==SQLITE_OK ){
         pgno = decodeUint32(zBuf);
         if( pgno>0 && pgno<=pMain->nPage ){
           if( 0==sqlite3BitvecTest(pMain->pWritable, pgno) ){
@@ skipping 51 matching lines @@
           return rc;
         }
       }
     }
     if( p->iMaxOff<(iOfst + iAmt) ){
       p->iMaxOff = iOfst + iAmt;
     }
   }
 
   if( p->flags&SQLITE_OPEN_MAIN_DB && p->pWritable ){
-    if( iAmt<p->nPagesize 
+    if( iAmt<(int)p->nPagesize 
      && p->nPagesize%iAmt==0 
      && iOfst>=(PENDING_BYTE+512) 
      && iOfst+iAmt<=PENDING_BYTE+p->nPagesize
     ){
       /* No-op. This special case is hit when the backup code is copying a
       ** to a database with a larger page-size than the source database and
       ** it needs to fill in the non-locking-region part of the original
       ** pending-byte page.
       */
     }else{
-      u32 pgno = iOfst/p->nPagesize + 1;
+      u32 pgno = (u32)(iOfst/p->nPagesize + 1);
       assert( (iAmt==1||iAmt==p->nPagesize) && ((iOfst+iAmt)%p->nPagesize)==0 );
       assert( pgno<=p->nPage || p->nSync>0 );
       assert( pgno>p->nPage || sqlite3BitvecTest(p->pWritable, pgno) );
     }
   }
 
   rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
   if( (p->flags&SQLITE_OPEN_MAIN_JOURNAL) && iAmt==12 ){
     jt_file *pMain = locateDatabaseHandle(p->zName);
     int rc2 = readJournalFile(p, pMain);
     if( rc==SQLITE_OK ) rc = rc2;
   }
   return rc;
 }
 
 /*
 ** Truncate an jt-file.
 */
 static int jtTruncate(sqlite3_file *pFile, sqlite_int64 size){
   jt_file *p = (jt_file *)pFile;
   if( p->flags&SQLITE_OPEN_MAIN_JOURNAL && size==0 ){
     /* Truncating a journal file. This is the end of a transaction. */
     jt_file *pMain = locateDatabaseHandle(p->zName);
     closeTransaction(pMain);
   }
   if( p->flags&SQLITE_OPEN_MAIN_DB && p->pWritable ){
     u32 pgno;
     u32 locking_page = (u32)(PENDING_BYTE/p->nPagesize+1);
-    for(pgno=size/p->nPagesize+1; pgno<=p->nPage; pgno++){
+    for(pgno=(u32)(size/p->nPagesize+1); pgno<=p->nPage; pgno++){
       assert( pgno==locking_page || sqlite3BitvecTest(p->pWritable, pgno) );
     }
   }
   return sqlite3OsTruncate(p->pReal, size);
 }
 
 /*
 ** Sync an jt-file.
 */
 static int jtSync(sqlite3_file *pFile, int flags){
@@ skipping 64 matching lines @@
 static int jtCheckReservedLock(sqlite3_file *pFile, int *pResOut){
   jt_file *p = (jt_file *)pFile;
   return sqlite3OsCheckReservedLock(p->pReal, pResOut);
 }
 
 /*
 ** File control method. For custom operations on an jt-file.
 */
 static int jtFileControl(sqlite3_file *pFile, int op, void *pArg){
   jt_file *p = (jt_file *)pFile;
-  return sqlite3OsFileControl(p->pReal, op, pArg);
+  return p->pReal->pMethods->xFileControl(p->pReal, op, pArg);
 }
 
 /*
 ** Return the sector-size in bytes for an jt-file.
 */
 static int jtSectorSize(sqlite3_file *pFile){
   jt_file *p = (jt_file *)pFile;
   return sqlite3OsSectorSize(p->pReal);
 }
 
@@ skipping 39 matching lines @@
   }
   return rc;
 }
 
 /*
 ** Delete the file located at zPath. If the dirSync argument is true,
 ** ensure the file-system modifications are synced to disk before
 ** returning.
 */
 static int jtDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
-  int nPath = strlen(zPath);
+  int nPath = (int)strlen(zPath);
   if( nPath>8 && 0==strcmp("-journal", &zPath[nPath-8]) ){
     /* Deleting a journal file. The end of a transaction. */
     jt_file *pMain = locateDatabaseHandle(zPath);
     if( pMain ){
       closeTransaction(pMain);
     }
   }
 
   return sqlite3OsDelete(g.pVfs, zPath, dirSync);
 }
@@ skipping 111 matching lines @@
 }
 
 /*
 ** Uninstall the jt VFS, if it is installed.
 */
 void jt_unregister(void){
   sqlite3_vfs_unregister(&jt_vfs);
 }
 
 #endif