/*
** Dummy page reinitializer
*/
static void pager_test_reiniter( DbPage pNotUsed )
{
return;
}
/*
** Move the page pPg to location pgno in the file.
**
** There must be no references to the page previously located at
** pgno (which we call pPgOld) though that page is allowed to be
** in cache. If the page previously located at pgno is not already
** in the rollback journal, it is not put there by by this routine.
**
** References to the page pPg remain valid. Updating any
** meta-data associated with pPg (i.e. data stored in the nExtra bytes
** allocated along with the page) is the responsibility of the caller.
**
** A transaction must be active when this routine is called. It used to be
** required that a statement transaction was not active, but this restriction
** has been removed (CREATE INDEX needs to move a page when a statement
** transaction is active).
**
** If the fourth argument, isCommit, is non-zero, then this page is being
** moved as part of a database reorganization just before the transaction
** is being committed. In this case, it is guaranteed that the database page
** pPg refers to will not be written to again within this transaction.
**
** This function may return SQLITE_NOMEM or an IO error code if an error
** occurs. Otherwise, it returns SQLITE_OK.
*/
static int sqlite3PagerMovepage( Pager pPager, DbPage pPg, u32 pgno, int isCommit )
{
PgHdr pPgOld; /* The page being overwritten. */
u32 needSyncPgno = 0; /* Old value of pPg.pgno, if sync is required */
int rc; /* Return code */
Pgno origPgno; /* The original page number */
Debug.Assert( pPg.nRef > 0 );
Debug.Assert( pPager.eState == PAGER_WRITER_CACHEMOD
|| pPager.eState == PAGER_WRITER_DBMOD
);
Debug.Assert( assert_pager_state( pPager ) );
/* In order to be able to rollback, an in-memory database must journal
** the page we are moving from.
*/
if (
#if SQLITE_OMIT_MEMORYDB
1==MEMDB
#else
pPager.memDb != 0
#endif
)
{
rc = sqlite3PagerWrite( pPg );
if ( rc != 0 )
return rc;
}
/* If the page being moved is dirty and has not been saved by the latest
** savepoint, then save the current contents of the page into the
** sub-journal now. This is required to handle the following scenario:
**
** BEGIN;
** <journal page X, then modify it in memory>
** SAVEPOINT one;
** <Move page X to location Y>
** ROLLBACK TO one;
**
** If page X were not written to the sub-journal here, it would not
** be possible to restore its contents when the "ROLLBACK TO one"
** statement were is processed.
**
** subjournalPage() may need to allocate space to store pPg.pgno into
** one or more savepoint bitvecs. This is the reason this function
** may return SQLITE_NOMEM.
*/
if ( ( pPg.flags & PGHDR_DIRTY ) != 0
&& subjRequiresPage( pPg )
&& SQLITE_OK != ( rc = subjournalPage( pPg ) )
)
{
return rc;
}
PAGERTRACE( "MOVE %d page %d (needSync=%d) moves to %d\n",
PAGERID( pPager ), pPg.pgno, ( pPg.flags & PGHDR_NEED_SYNC ) != 0 ? 1 : 0, pgno );
IOTRACE( "MOVE %p %d %d\n", pPager, pPg.pgno, pgno );
/* If the journal needs to be sync()ed before page pPg.pgno can
** be written to, store pPg.pgno in local variable needSyncPgno.
**
** If the isCommit flag is set, there is no need to remember that
** the journal needs to be sync()ed before database page pPg.pgno
** can be written to. The caller has already promised not to write to it.
*/
if ( ( ( pPg.flags & PGHDR_NEED_SYNC ) != 0 ) && 0 == isCommit )
{
needSyncPgno = pPg.pgno;
Debug.Assert( pageInJournal( pPg ) || pPg.pgno > pPager.dbOrigSize );
Debug.Assert( ( pPg.flags & PGHDR_DIRTY ) != 0 );
}
/* If the cache contains a page with page-number pgno, remove it
** from its hash chain. Also, if the PGHDR_NEED_SYNC was set for
** page pgno before the 'move' operation, it needs to be retained
** for the page moved there.
*/
pPg.flags &= ~PGHDR_NEED_SYNC;
pPgOld = pager_lookup( pPager, pgno );
Debug.Assert( null == pPgOld || pPgOld.nRef == 1 );
if ( pPgOld != null )
{
pPg.flags |= ( pPgOld.flags & PGHDR_NEED_SYNC );
if (
#if SQLITE_OMIT_MEMORYDB
1==MEMDB
#else
pPager.memDb != 0
#endif
)
{
/* Do not discard pages from an in-memory database since we might
** need to rollback later. Just move the page out of the way. */
sqlite3PcacheMove( pPgOld, pPager.dbSize + 1 );
}
else
{
sqlite3PcacheDrop( pPgOld );
}
}
origPgno = pPg.pgno;
sqlite3PcacheMove( pPg, pgno );
sqlite3PcacheMakeDirty( pPg );
/* For an in-memory database, make sure the original page continues
** to exist, in case the transaction needs to roll back. Use pPgOld
** as the original page since it has already been allocated.
*/
if (
#if SQLITE_OMIT_MEMORYDB
0!=MEMDB
#else
0 != pPager.memDb
#endif
)
{
Debug.Assert( pPgOld );
sqlite3PcacheMove( pPgOld, origPgno );
sqlite3PagerUnref( pPgOld );
}
if ( needSyncPgno != 0 )
{
/* If needSyncPgno is non-zero, then the journal file needs to be
** sync()ed before any data is written to database file page needSyncPgno.
** Currently, no such page exists in the page-cache and the
** "is journaled" bitvec flag has been set. This needs to be remedied by
** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
** flag.
**
** If the attempt to load the page into the page-cache fails, (due
** to a malloc() or IO failure), clear the bit in the pInJournal[]
** array. Otherwise, if the page is loaded and written again in
** this transaction, it may be written to the database file before
** it is synced into the journal file. This way, it may end up in
** the journal file twice, but that is not a problem.
*/
PgHdr pPgHdr = null;
rc = sqlite3PagerGet( pPager, needSyncPgno, ref pPgHdr );
if ( rc != SQLITE_OK )
{
if ( needSyncPgno <= pPager.dbOrigSize )
{
Debug.Assert( pPager.pTmpSpace != null );
u32[] pTemp = new u32[pPager.pTmpSpace.Length];
sqlite3BitvecClear( pPager.pInJournal, needSyncPgno, pTemp );//pPager.pTmpSpace );
}
return rc;
}
pPgHdr.flags |= PGHDR_NEED_SYNC;
sqlite3PcacheMakeDirty( pPgHdr );
sqlite3PagerUnref( pPgHdr );
}
return SQLITE_OK;
}
/*
** Dummy page reinitializer
*/
static void pager_test_reiniter(DbPage pNotUsed)
{
return;
}
/*
** Release a page reference.
**
** If the number of references to the page drop to zero, then the
** page is added to the LRU list. When all references to all pages
** are released, a rollback occurs and the lock on the database is
** removed.
*/
static void sqlite3PagerUnref( DbPage pPg )
{
if ( pPg != null )
{
Pager pPager = pPg.pPager;
sqlite3PcacheRelease( pPg );
pagerUnlockIfUnused( pPager );
}
}
/*
** Mark a data page as writeable. This routine must be called before
** making changes to a page. The caller must check the return value
** of this function and be careful not to change any page data unless
** this routine returns SQLITE_OK.
**
** The difference between this function and pager_write() is that this
** function also deals with the special case where 2 or more pages
** fit on a single disk sector. In this case all co-resident pages
** must have been written to the journal file before returning.
**
** If an error occurs, SQLITE_NOMEM or an IO error code is returned
** as appropriate. Otherwise, SQLITE_OK.
*/
static int sqlite3PagerWrite( DbPage pDbPage )
{
int rc = SQLITE_OK;
PgHdr pPg = pDbPage;
Pager pPager = pPg.pPager;
u32 nPagePerSector = (u32)( pPager.sectorSize / pPager.pageSize );
Debug.Assert( pPager.eState >= PAGER_WRITER_LOCKED );
Debug.Assert( pPager.eState != PAGER_ERROR );
Debug.Assert( assert_pager_state( pPager ) );
if ( nPagePerSector > 1 )
{
Pgno nPageCount = 0; /* Total number of pages in database file */
Pgno pg1; /* First page of the sector pPg is located on. */
Pgno nPage = 0; /* Number of pages starting at pg1 to journal */
int ii; /* Loop counter */
bool needSync = false; /* True if any page has PGHDR_NEED_SYNC */
/* Set the doNotSyncSpill flag to 1. This is because we cannot allow
** a journal header to be written between the pages journaled by
** this function.
*/
Debug.Assert(
#if SQLITE_OMIT_MEMORYDB
0==MEMDB
#else
0 == pPager.memDb
#endif
);
Debug.Assert( pPager.doNotSyncSpill == 0 );
pPager.doNotSyncSpill++;
/* This trick assumes that both the page-size and sector-size are
** an integer power of 2. It sets variable pg1 to the identifier
** of the first page of the sector pPg is located on.
*/
pg1 = (u32)( ( pPg.pgno - 1 ) & ~( nPagePerSector - 1 ) ) + 1;
nPageCount = pPager.dbSize;
if ( pPg.pgno > nPageCount )
{
nPage = ( pPg.pgno - pg1 ) + 1;
}
else if ( ( pg1 + nPagePerSector - 1 ) > nPageCount )
{
nPage = nPageCount + 1 - pg1;
}
else
{
nPage = nPagePerSector;
}
Debug.Assert( nPage > 0 );
Debug.Assert( pg1 <= pPg.pgno );
Debug.Assert( ( pg1 + nPage ) > pPg.pgno );
for ( ii = 0; ii < nPage && rc == SQLITE_OK; ii++ )
{
u32 pg = (u32)( pg1 + ii );
PgHdr pPage = new PgHdr();
if ( pg == pPg.pgno || sqlite3BitvecTest( pPager.pInJournal, pg ) == 0 )
{
if ( pg != ( ( PENDING_BYTE / ( pPager.pageSize ) ) + 1 ) ) //PAGER_MJ_PGNO(pPager))
{
rc = sqlite3PagerGet( pPager, pg, ref pPage );
if ( rc == SQLITE_OK )
{
rc = pager_write( pPage );
if ( ( pPage.flags & PGHDR_NEED_SYNC ) != 0 )
{
needSync = true;
}
sqlite3PagerUnref( pPage );
}
}
}
else if ( ( pPage = pager_lookup( pPager, pg ) ) != null )
{
if ( ( pPage.flags & PGHDR_NEED_SYNC ) != 0 )
{
needSync = true;
}
sqlite3PagerUnref( pPage );
}
}
/* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
** starting at pg1, then it needs to be set for all of them. Because
** writing to any of these nPage pages may damage the others, the
** journal file must contain sync()ed copies of all of them
** before any of them can be written out to the database file.
*/
if ( rc == SQLITE_OK && needSync )
{
Debug.Assert(
#if SQLITE_OMIT_MEMORYDB
0==MEMDB
#else
0 == pPager.memDb
#endif
);
for ( ii = 0; ii < nPage; ii++ )
{
PgHdr pPage = pager_lookup( pPager, (u32)( pg1 + ii ) );
if ( pPage != null )
{
pPage.flags |= PGHDR_NEED_SYNC;
sqlite3PagerUnref( pPage );
}
}
}
Debug.Assert( pPager.doNotSyncSpill == 1 );
pPager.doNotSyncSpill--;
}
else
{
rc = pager_write( pDbPage );
}
return rc;
}
/*
** Increment the reference count for page pPg.
*/
static void sqlite3PagerRef( DbPage pPg )
{
sqlite3PcacheRef( pPg );
}
static Pgno sqlite3PagerPagenumber( DbPage pPg )
{
return pPg.pgno;
}
/*
** Return a pointer to the Pager.nExtra bytes of "extra" space
** allocated along with the specified page.
*/
static MemPage sqlite3PagerGetExtra( DbPage pPg )
{
return pPg.pExtra;
}
/*
** Return the number of references to the specified page.
*/
static int sqlite3PagerPageRefcount( DbPage pPage )
{
return sqlite3PcachePageRefcount( pPage );
}
/*
** Return a pointer to the data for the specified page.
*/
static byte[] sqlite3PagerGetData( DbPage pPg )
{
Debug.Assert( pPg.nRef > 0 || pPg.pPager.memDb != 0 );
return pPg.pData;
}
/*
** Acquire a reference to page number pgno in pager pPager (a page
** reference has type DbPage*). If the requested reference is
** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
**
** If the requested page is already in the cache, it is returned.
** Otherwise, a new page object is allocated and populated with data
** read from the database file. In some cases, the pcache module may
** choose not to allocate a new page object and may reuse an existing
** object with no outstanding references.
**
** The extra data appended to a page is always initialized to zeros the
** first time a page is loaded into memory. If the page requested is
** already in the cache when this function is called, then the extra
** data is left as it was when the page object was last used.
**
** If the database image is smaller than the requested page or if a
** non-zero value is passed as the noContent parameter and the
** requested page is not already stored in the cache, then no
** actual disk read occurs. In this case the memory image of the
** page is initialized to all zeros.
**
** If noContent is true, it means that we do not care about the contents
** of the page. This occurs in two seperate scenarios:
**
** a) When reading a free-list leaf page from the database, and
**
** b) When a savepoint is being rolled back and we need to load
** a new page into the cache to be filled with the data read
** from the savepoint journal.
**
** If noContent is true, then the data returned is zeroed instead of
** being read from the database. Additionally, the bits corresponding
** to pgno in Pager.pInJournal (bitvec of pages already written to the
** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
** savepoints are set. This means if the page is made writable at any
** point in the future, using a call to sqlite3PagerWrite(), its contents
** will not be journaled. This saves IO.
**
** The acquisition might fail for several reasons. In all cases,
** an appropriate error code is returned and *ppPage is set to NULL.
**
** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
** to find a page in the in-memory cache first. If the page is not already
** in memory, this routine goes to disk to read it in whereas Lookup()
** just returns 0. This routine acquires a read-lock the first time it
** has to go to disk, and could also playback an old journal if necessary.
** Since Lookup() never goes to disk, it never has to deal with locks
** or journal files.
*/
// Under C# from the header file
//#define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0)
static int sqlite3PagerGet(
Pager pPager, /* The pager open on the database file */
u32 pgno, /* Page number to fetch */
ref DbPage ppPage /* Write a pointer to the page here */
)
{
return sqlite3PagerAcquire( pPager, pgno, ref ppPage, 0 );
}
static int sqlite3PagerAcquire(
Pager pPager, /* The pager open on the database file */
u32 pgno, /* Page number to fetch */
ref DbPage ppPage, /* Write a pointer to the page here */
u8 noContent /* Do not bother reading content from disk if true */
)
{
int rc;
PgHdr pPg = null;
Debug.Assert( pPager.eState >= PAGER_READER );
Debug.Assert( assert_pager_state( pPager ) );
if ( pgno == 0 )
{
return SQLITE_CORRUPT_BKPT();
}
/* If the pager is in the error state, return an error immediately.
** Otherwise, request the page from the PCache layer. */
if ( pPager.errCode != SQLITE_OK )
{
rc = pPager.errCode;
}
else
{
rc = sqlite3PcacheFetch( pPager.pPCache, pgno, 1, ref ppPage );
}
if ( rc != SQLITE_OK )
{
/* Either the call to sqlite3PcacheFetch() returned an error or the
** pager was already in the error-state when this function was called.
** Set pPg to 0 and jump to the exception handler. */
pPg = null;
goto pager_acquire_err;
}
Debug.Assert( ( ppPage ).pgno == pgno );
Debug.Assert( ( ppPage ).pPager == pPager || ( ppPage ).pPager == null );
if ( ( ppPage ).pPager != null && 0 == noContent )
{
/* In this case the pcache already contains an initialized copy of
** the page. Return without further ado. */
Debug.Assert( pgno <= PAGER_MAX_PGNO && pgno != PAGER_MJ_PGNO( pPager ) );
PAGER_INCR( ref pPager.nHit );
return SQLITE_OK;
}
else
{
/* The pager cache has created a new page. Its content needs to
** be initialized. */
#if SQLITE_TEST
PAGER_INCR( ref pPager.nMiss );
#endif
pPg = ppPage;
pPg.pPager = pPager;
pPg.pExtra = new MemPage();//memset(pPg.pExtra, 0, pPager.nExtra);
/* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
** number greater than this, or the unused locking-page, is requested. */
if ( pgno > PAGER_MAX_PGNO || pgno == PAGER_MJ_PGNO( pPager ) )
{
rc = SQLITE_CORRUPT_BKPT();
goto pager_acquire_err;
}
if (
#if SQLITE_OMIT_MEMORYDB
1==MEMDB
#else
pPager.memDb != 0
#endif
|| pPager.dbSize < pgno || noContent != 0 || !isOpen( pPager.fd ) )
{
if ( pgno > pPager.mxPgno )
{
rc = SQLITE_FULL;
goto pager_acquire_err;
}
if ( noContent != 0 )
{
/* Failure to set the bits in the InJournal bit-vectors is benign.
** It merely means that we might do some extra work to journal a
** page that does not need to be journaled. Nevertheless, be sure
** to test the case where a malloc error occurs while trying to set
** a bit in a bit vector.
*/
sqlite3BeginBenignMalloc();
if ( pgno <= pPager.dbOrigSize )
{
#if !NDEBUG || SQLITE_COVERAGE_TEST
rc = sqlite3BitvecSet( pPager.pInJournal, pgno ); //TESTONLY( rc = ) sqlite3BitvecSet(pPager.pInJournal, pgno);
#else
sqlite3BitvecSet(pPager.pInJournal, pgno);
#endif
testcase( rc == SQLITE_NOMEM );
}
#if !NDEBUG || SQLITE_COVERAGE_TEST
rc = addToSavepointBitvecs( pPager, pgno ); //TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
#else
addToSavepointBitvecs(pPager, pgno);
#endif
testcase( rc == SQLITE_NOMEM );
sqlite3EndBenignMalloc();
}
//memset(pPg.pData, 0, pPager.pageSize);
Array.Clear( pPg.pData, 0, pPager.pageSize );
IOTRACE( "ZERO %p %d\n", pPager, pgno );
}
else
{
Debug.Assert( pPg.pPager == pPager );
rc = readDbPage( pPg );
if ( rc != SQLITE_OK )
{
goto pager_acquire_err;
}
}
pager_set_pagehash( pPg );
}
return SQLITE_OK;
pager_acquire_err:
Debug.Assert( rc != SQLITE_OK );
if ( pPg != null )
{
sqlite3PcacheDrop( pPg );
}
pagerUnlockIfUnused( pPager );
ppPage = null;
return rc;
}
static bool sqlite3PagerIswriteable( DbPage pPg )
{
return true;
}
/*
** Return TRUE if the page given in the argument was previously passed
** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
** to change the content of the page.
*/
static bool sqlite3PagerIswriteable( DbPage pPg )
{
return ( pPg.flags & PGHDR_DIRTY ) != 0;
}
