/*
** 2009 January 28
**
** 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 the implementation of the sqlite3_backup_XXX()
** API functions and the related features.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-01-28 17:03:50 ed759d5a9edb3bba5f48f243df47be29e3fe8cd7
**
*************************************************************************
*/
//#include "sqliteInt.h"
//#include "btreeInt.h"
/* Macro to find the minimum of two numeric values.
*/
//# define MIN(x,y) ((x)<(y)?(x):(y))
#endif
#region Methods
/*
** Release all resources associated with an sqlite3_backup* handle.
*/
public static int sqlite3_backup_finish( sqlite3_backup p )
{
sqlite3_backup pp; /* Ptr to head of pagers backup list */
sqlite3_mutex mutex; /* Mutex to protect source database */
int rc; /* Value to return */
/* Enter the mutexes */
if ( p == null )
return SQLITE_OK;
sqlite3_mutex_enter( p.pSrcDb.mutex );
sqlite3BtreeEnter( p.pSrc );
mutex = p.pSrcDb.mutex;
if ( p.pDestDb != null )
{
sqlite3_mutex_enter( p.pDestDb.mutex );
}
/* Detach this backup from the source pager. */
if ( p.pDestDb != null )
{
p.pSrc.nBackup--;
}
if ( p.isAttached != 0 )
{
pp = sqlite3PagerBackupPtr( sqlite3BtreePager( p.pSrc ) );
while ( pp != p )
{
pp = ( pp ).pNext;
}
sqlite3BtreePager( p.pSrc ).pBackup = p.pNext;
}
/* If a transaction is still open on the Btree, roll it back. */
sqlite3BtreeRollback( p.pDest );
/* Set the error code of the destination database handle. */
rc = ( p.rc == SQLITE_DONE ) ? SQLITE_OK : p.rc;
sqlite3Error( p.pDestDb, rc, 0 );
/* Exit the mutexes and free the backup context structure. */
if ( p.pDestDb != null )
{
sqlite3_mutex_leave( p.pDestDb.mutex );
}
sqlite3BtreeLeave( p.pSrc );
if ( p.pDestDb != null )
{
/* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
** call to sqlite3_backup_init() and is destroyed by a call to
** sqlite3_backup_finish(). */
//sqlite3_free( ref p );
}
sqlite3_mutex_leave( mutex );
return rc;
}
static int backupTestCmd(
ClientData clientData,
Tcl_Interp interp,
int objc,
Tcl_Obj[] objv
)
{
BackupSubCommand[] aSub = new BackupSubCommand[] {
new BackupSubCommand("step", BackupSubCommandEnum.BACKUP_STEP, 1, "npage"),
new BackupSubCommand("finish", BackupSubCommandEnum.BACKUP_FINISH, 0, ""),
new BackupSubCommand("remaining", BackupSubCommandEnum.BACKUP_REMAINING, 0, ""),
new BackupSubCommand("pagecount", BackupSubCommandEnum.BACKUP_PAGECOUNT, 0, ""),
new BackupSubCommand(null, 0, 0, null)
};
sqlite3_backup p = (sqlite3_backup)clientData;
int iCmd = 0;
int rc;
rc = Tcl_GetIndexFromObjStruct(
interp, objv[1], aSub, aSub.Length, "option", 0, ref iCmd
);
if (rc != TCL.TCL_OK)
{
return(rc);
}
if (objc != (2 + aSub[iCmd].nArg))
{
TCL.Tcl_WrongNumArgs(interp, 2, objv, aSub[iCmd].zArg);
return(TCL.TCL_ERROR);
}
switch (aSub[iCmd].eCmd)
{
case BackupSubCommandEnum.BACKUP_FINISH:
{
string zCmdName;
WrappedCommand cmdInfo = null;
zCmdName = TCL.Tcl_GetString(objv[0]);
TCL.Tcl_GetCommandInfo(interp, zCmdName, ref cmdInfo);
cmdInfo.deleteProc = null;
TCL.Tcl_SetCommandInfo(interp, zCmdName, cmdInfo);
TCL.Tcl_DeleteCommand(interp, zCmdName);
rc = sqlite3_backup_finish(p);
TCL.Tcl_SetResult(interp, sqlite3TestErrorName(rc), TCL.TCL_STATIC);
break;
}
case BackupSubCommandEnum.BACKUP_STEP:
{
int nPage = 0;
if (TCL.Tcl_GetIntFromObj(interp, objv[2], ref nPage))
{
return(TCL.TCL_ERROR);
}
rc = sqlite3_backup_step(p, nPage);
TCL.Tcl_SetResult(interp, sqlite3TestErrorName(rc), TCL.TCL_STATIC);
break;
}
case BackupSubCommandEnum.BACKUP_REMAINING:
TCL.Tcl_SetObjResult(interp, TCL.Tcl_NewIntObj(sqlite3_backup_remaining(p)));
break;
case BackupSubCommandEnum.BACKUP_PAGECOUNT:
TCL.Tcl_SetObjResult(interp, TCL.Tcl_NewIntObj(sqlite3_backup_pagecount(p)));
break;
}
return(TCL.TCL_OK);
}
/*
** Copy nPage pages from the source b-tree to the destination.
*/
static public int sqlite3_backup_step(sqlite3_backup p, int nPage)
{
int rc;
int destMode; /* Destination journal mode */
int pgszSrc = 0; /* Source page size */
int pgszDest = 0; /* Destination page size */
sqlite3_mutex_enter(p.pSrcDb.mutex);
sqlite3BtreeEnter(p.pSrc);
if (p.pDestDb != null)
{
sqlite3_mutex_enter(p.pDestDb.mutex);
}
rc = p.rc;
if (!isFatalError(rc))
{
Pager pSrcPager = sqlite3BtreePager(p.pSrc); /* Source pager */
Pager pDestPager = sqlite3BtreePager(p.pDest); /* Dest pager */
int ii; /* Iterator variable */
Pgno nSrcPage = 0; /* Size of source db in pages */
int bCloseTrans = 0; /* True if src db requires unlocking */
/* If the source pager is currently in a write-transaction, return
** SQLITE_BUSY immediately.
*/
if (p.pDestDb != null && p.pSrc.pBt.inTransaction == TRANS_WRITE)
{
rc = SQLITE_BUSY;
}
else
{
rc = SQLITE_OK;
}
/* Lock the destination database, if it is not locked already. */
if (SQLITE_OK == rc && p.bDestLocked == 0 &&
SQLITE_OK == (rc = sqlite3BtreeBeginTrans(p.pDest, 2))
)
{
p.bDestLocked = 1;
sqlite3BtreeGetMeta(p.pDest, BTREE_SCHEMA_VERSION, ref p.iDestSchema);
}
/* If there is no open read-transaction on the source database, open
** one now. If a transaction is opened here, then it will be closed
** before this function exits.
*/
if (rc == SQLITE_OK && !sqlite3BtreeIsInReadTrans(p.pSrc))
{
rc = sqlite3BtreeBeginTrans(p.pSrc, 0);
bCloseTrans = 1;
}
/* Do not allow backup if the destination database is in WAL mode
** and the page sizes are different between source and destination */
pgszSrc = sqlite3BtreeGetPageSize(p.pSrc);
pgszDest = sqlite3BtreeGetPageSize(p.pDest);
destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p.pDest));
if (SQLITE_OK == rc && destMode == PAGER_JOURNALMODE_WAL && pgszSrc != pgszDest)
{
rc = SQLITE_READONLY;
}
/* Now that there is a read-lock on the source database, query the
** source pager for the number of pages in the database.
*/
nSrcPage = sqlite3BtreeLastPage(p.pSrc);
Debug.Assert(nSrcPage >= 0);
for (ii = 0; (nPage < 0 || ii < nPage) && p.iNext <= nSrcPage && 0 == rc; ii++)
{
Pgno iSrcPg = p.iNext; /* Source page number */
if (iSrcPg != PENDING_BYTE_PAGE(p.pSrc.pBt))
{
DbPage pSrcPg = null; /* Source page object */
rc = sqlite3PagerGet(pSrcPager, (u32)iSrcPg, ref pSrcPg);
if (rc == SQLITE_OK)
{
rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg));
sqlite3PagerUnref(pSrcPg);
}
}
p.iNext++;
}
if (rc == SQLITE_OK)
{
p.nPagecount = nSrcPage;
p.nRemaining = (nSrcPage + 1 - p.iNext);
if (p.iNext > nSrcPage)
{
rc = SQLITE_DONE;
}
else if (0 == p.isAttached)
{
attachBackupObject(p);
}
}
/* Update the schema version field in the destination database. This
** is to make sure that the schema-version really does change in
** the case where the source and destination databases have the
** same schema version.
*/
if (rc == SQLITE_DONE &&
(rc = sqlite3BtreeUpdateMeta(p.pDest, 1, p.iDestSchema + 1)) == SQLITE_OK
)
{
Pgno nDestTruncate;
if (p.pDestDb != null)
{
sqlite3ResetInternalSchema(p.pDestDb, -1);
}
/* Set nDestTruncate to the final number of pages in the destination
** database. The complication here is that the destination page
** size may be different to the source page size.
**
** If the source page size is smaller than the destination page size,
** round up. In this case the call to sqlite3OsTruncate() below will
** fix the size of the file. However it is important to call
** sqlite3PagerTruncateImage() here so that any pages in the
** destination file that lie beyond the nDestTruncate page mark are
** journalled by PagerCommitPhaseOne() before they are destroyed
** by the file truncation.
*/
Debug.Assert(pgszSrc == sqlite3BtreeGetPageSize(p.pSrc));
Debug.Assert(pgszDest == sqlite3BtreeGetPageSize(p.pDest));
if (pgszSrc < pgszDest)
{
int ratio = pgszDest / pgszSrc;
nDestTruncate = (Pgno)((nSrcPage + ratio - 1) / ratio);
if (nDestTruncate == (int)PENDING_BYTE_PAGE(p.pDest.pBt))
{
nDestTruncate--;
}
}
else
{
nDestTruncate = (Pgno)(nSrcPage * (pgszSrc / pgszDest));
}
sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
if (pgszSrc < pgszDest)
{
/* If the source page-size is smaller than the destination page-size,
** two extra things may need to happen:
**
** * The destination may need to be truncated, and
**
** * Data stored on the pages immediately following the
** pending-byte page in the source database may need to be
** copied into the destination database.
*/
int iSize = (int)(pgszSrc * nSrcPage);
sqlite3_file pFile = sqlite3PagerFile(pDestPager);
i64 iOff;
i64 iEnd;
Debug.Assert(pFile != null);
Debug.Assert((i64)nDestTruncate * (i64)pgszDest >= iSize || (
nDestTruncate == (int)(PENDING_BYTE_PAGE(p.pDest.pBt) - 1) &&
iSize >= PENDING_BYTE && iSize <= PENDING_BYTE + pgszDest
));
/* This call ensures that all data required to recreate the original
** database has been stored in the journal for pDestPager and the
** journal synced to disk. So at this point we may safely modify
** the database file in any way, knowing that if a power failure
** occurs, the original database will be reconstructed from the
** journal file. */
rc = sqlite3PagerCommitPhaseOne(pDestPager, null, true);
/* Write the extra pages and truncate the database file as required. */
iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
for (
iOff = PENDING_BYTE + pgszSrc;
rc == SQLITE_OK && iOff < iEnd;
iOff += pgszSrc
)
{
PgHdr pSrcPg = null;
u32 iSrcPg = (u32)((iOff / pgszSrc) + 1);
rc = sqlite3PagerGet(pSrcPager, iSrcPg, ref pSrcPg);
if (rc == SQLITE_OK)
{
byte[] zData = sqlite3PagerGetData(pSrcPg);
rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
}
sqlite3PagerUnref(pSrcPg);
}
if (rc == SQLITE_OK)
{
rc = backupTruncateFile(pFile, (int)iSize);
}
/* Sync the database file to disk. */
if (rc == SQLITE_OK)
{
rc = sqlite3PagerSync(pDestPager);
}
}
else
{
rc = sqlite3PagerCommitPhaseOne(pDestPager, null, false);
}
/* Finish committing the transaction to the destination database. */
if (SQLITE_OK == rc &&
SQLITE_OK == (rc = sqlite3BtreeCommitPhaseTwo(p.pDest, 0))
)
{
rc = SQLITE_DONE;
}
}
/* If bCloseTrans is true, then this function opened a read transaction
** on the source database. Close the read transaction here. There is
** no need to check the return values of the btree methods here, as
** "committing" a read-only transaction cannot fail.
*/
if (bCloseTrans != 0)
{
#if !NDEBUG || SQLITE_COVERAGE_TEST
//TESTONLY( int rc2 );
//TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p.pSrc, 0);
//TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p.pSrc);
int rc2;
rc2 = sqlite3BtreeCommitPhaseOne(p.pSrc, "");
rc2 |= sqlite3BtreeCommitPhaseTwo(p.pSrc, 0);
Debug.Assert(rc2 == SQLITE_OK);
#else
sqlite3BtreeCommitPhaseOne(p.pSrc, null);
sqlite3BtreeCommitPhaseTwo(p.pSrc, 0);
#endif
}
if (rc == SQLITE_IOERR_NOMEM)
{
rc = SQLITE_NOMEM;
}
p.rc = rc;
}
if (p.pDestDb != null)
{
sqlite3_mutex_leave(p.pDestDb.mutex);
}
sqlite3BtreeLeave(p.pSrc);
sqlite3_mutex_leave(p.pSrcDb.mutex);
return(rc);
}
/*
** Return the total number of pages in the source database as of the most
** recent call to sqlite3_backup_step().
*/
static int sqlite3_backup_pagecount( sqlite3_backup p )
{
return (int)p.nPagecount;
}
/*
** Restart the backup process. This is called when the pager layer
** detects that the database has been modified by an external database
** connection. In this case there is no way of knowing which of the
** pages that have been copied into the destination database are still
** valid and which are not, so the entire process needs to be restarted.
**
** It is assumed that the mutex associated with the BtShared object
** corresponding to the source database is held when this function is
** called.
*/
static void sqlite3BackupRestart( sqlite3_backup pBackup )
{
sqlite3_backup p; /* Iterator variable */
for ( p = pBackup; p != null; p = p.pNext )
{
Debug.Assert( sqlite3_mutex_held( p.pSrc.pBt.mutex ) );
p.iNext = 1;
}
}
/*
** Parameter zSrcData points to a buffer containing the data for
** page iSrcPg from the source database. Copy this data into the
** destination database.
*/
static int backupOnePage( sqlite3_backup p, Pgno iSrcPg, byte[] zSrcData )
{
Pager pDestPager = sqlite3BtreePager( p.pDest );
int nSrcPgsz = sqlite3BtreeGetPageSize( p.pSrc );
int nDestPgsz = sqlite3BtreeGetPageSize( p.pDest );
int nCopy = MIN( nSrcPgsz, nDestPgsz );
i64 iEnd = (i64)iSrcPg * (i64)nSrcPgsz;
int rc = SQLITE_OK;
i64 iOff;
Debug.Assert( p.bDestLocked != 0 );
Debug.Assert( !isFatalError( p.rc ) );
Debug.Assert( iSrcPg != PENDING_BYTE_PAGE( p.pSrc.pBt ) );
Debug.Assert( zSrcData != null );
/* Catch the case where the destination is an in-memory database and the
** page sizes of the source and destination differ.
*/
if ( nSrcPgsz != nDestPgsz && sqlite3PagerIsMemdb( pDestPager ) )
{
rc = SQLITE_READONLY;
}
#if SQLITE_HAS_CODEC
/* Backup is not possible if the page size of the destination is changing
** a a codec is in use.
*/
if ( nSrcPgsz != nDestPgsz && sqlite3PagerGetCodec( pDestPager ) != null )
{
rc = SQLITE_READONLY;
}
#endif
/* This loop runs once for each destination page spanned by the source
** page. For each iteration, variable iOff is set to the byte offset
** of the destination page.
*/
for ( iOff = iEnd - (i64)nSrcPgsz; rc == SQLITE_OK && iOff < iEnd; iOff += nDestPgsz )
{
DbPage pDestPg = null;
u32 iDest = (u32)( iOff / nDestPgsz ) + 1;
if ( iDest == PENDING_BYTE_PAGE( p.pDest.pBt ) )
continue;
if ( SQLITE_OK == ( rc = sqlite3PagerGet( pDestPager, iDest, ref pDestPg ) )
&& SQLITE_OK == ( rc = sqlite3PagerWrite( pDestPg ) )
)
{
//string zIn = &zSrcData[iOff%nSrcPgsz];
byte[] zDestData = sqlite3PagerGetData( pDestPg );
//string zOut = &zDestData[iOff % nDestPgsz];
/* Copy the data from the source page into the destination page.
** Then clear the Btree layer MemPage.isInit flag. Both this module
** and the pager code use this trick (clearing the first byte
** of the page 'extra' space to invalidate the Btree layers
** cached parse of the page). MemPage.isInit is marked
** "MUST BE FIRST" for this purpose.
*/
Buffer.BlockCopy( zSrcData, (int)( iOff % nSrcPgsz ), zDestData, (int)( iOff % nDestPgsz ), nCopy );// memcpy( zOut, zIn, nCopy );
sqlite3PagerGetExtra( pDestPg ).isInit = 0;// ( sqlite3PagerGetExtra( pDestPg ) )[0] = 0;
}
sqlite3PagerUnref( pDestPg );
}
return rc;
}
/*
** Copy nPage pages from the source b-tree to the destination.
*/
static public int sqlite3_backup_step( sqlite3_backup p, int nPage )
{
int rc;
int destMode; /* Destination journal mode */
int pgszSrc = 0; /* Source page size */
int pgszDest = 0; /* Destination page size */
sqlite3_mutex_enter( p.pSrcDb.mutex );
sqlite3BtreeEnter( p.pSrc );
if ( p.pDestDb != null )
{
sqlite3_mutex_enter( p.pDestDb.mutex );
}
rc = p.rc;
if ( !isFatalError( rc ) )
{
Pager pSrcPager = sqlite3BtreePager( p.pSrc ); /* Source pager */
Pager pDestPager = sqlite3BtreePager( p.pDest ); /* Dest pager */
int ii; /* Iterator variable */
Pgno nSrcPage = 0; /* Size of source db in pages */
int bCloseTrans = 0; /* True if src db requires unlocking */
/* If the source pager is currently in a write-transaction, return
** SQLITE_BUSY immediately.
*/
if ( p.pDestDb != null && p.pSrc.pBt.inTransaction == TRANS_WRITE )
{
rc = SQLITE_BUSY;
}
else
{
rc = SQLITE_OK;
}
/* Lock the destination database, if it is not locked already. */
if ( SQLITE_OK == rc && p.bDestLocked == 0
&& SQLITE_OK == ( rc = sqlite3BtreeBeginTrans( p.pDest, 2 ) )
)
{
p.bDestLocked = 1;
sqlite3BtreeGetMeta( p.pDest, BTREE_SCHEMA_VERSION, ref p.iDestSchema );
}
/* If there is no open read-transaction on the source database, open
** one now. If a transaction is opened here, then it will be closed
** before this function exits.
*/
if ( rc == SQLITE_OK && !sqlite3BtreeIsInReadTrans( p.pSrc ) )
{
rc = sqlite3BtreeBeginTrans( p.pSrc, 0 );
bCloseTrans = 1;
}
/* Do not allow backup if the destination database is in WAL mode
** and the page sizes are different between source and destination */
pgszSrc = sqlite3BtreeGetPageSize( p.pSrc );
pgszDest = sqlite3BtreeGetPageSize( p.pDest );
destMode = sqlite3PagerGetJournalMode( sqlite3BtreePager( p.pDest ) );
if ( SQLITE_OK == rc && destMode == PAGER_JOURNALMODE_WAL && pgszSrc != pgszDest )
{
rc = SQLITE_READONLY;
}
/* Now that there is a read-lock on the source database, query the
** source pager for the number of pages in the database.
*/
nSrcPage = sqlite3BtreeLastPage( p.pSrc );
Debug.Assert( nSrcPage >= 0 );
for ( ii = 0; ( nPage < 0 || ii < nPage ) && p.iNext <= nSrcPage && 0 == rc; ii++ )
{
Pgno iSrcPg = p.iNext; /* Source page number */
if ( iSrcPg != PENDING_BYTE_PAGE( p.pSrc.pBt ) )
{
DbPage pSrcPg = null; /* Source page object */
rc = sqlite3PagerGet( pSrcPager, (u32)iSrcPg, ref pSrcPg );
if ( rc == SQLITE_OK )
{
rc = backupOnePage( p, iSrcPg, sqlite3PagerGetData( pSrcPg ) );
sqlite3PagerUnref( pSrcPg );
}
}
p.iNext++;
}
if ( rc == SQLITE_OK )
{
p.nPagecount = nSrcPage;
p.nRemaining = ( nSrcPage + 1 - p.iNext );
if ( p.iNext > nSrcPage )
{
rc = SQLITE_DONE;
}
else if ( 0 == p.isAttached )
{
attachBackupObject( p );
}
}
/* Update the schema version field in the destination database. This
** is to make sure that the schema-version really does change in
** the case where the source and destination databases have the
** same schema version.
*/
if ( rc == SQLITE_DONE
&& ( rc = sqlite3BtreeUpdateMeta( p.pDest, 1, p.iDestSchema + 1 ) ) == SQLITE_OK
)
{
Pgno nDestTruncate;
if ( p.pDestDb != null )
{
sqlite3ResetInternalSchema( p.pDestDb, 0 );
}
/* Set nDestTruncate to the final number of pages in the destination
** database. The complication here is that the destination page
** size may be different to the source page size.
**
** If the source page size is smaller than the destination page size,
** round up. In this case the call to sqlite3OsTruncate() below will
** fix the size of the file. However it is important to call
** sqlite3PagerTruncateImage() here so that any pages in the
** destination file that lie beyond the nDestTruncate page mark are
** journalled by PagerCommitPhaseOne() before they are destroyed
** by the file truncation.
*/
Debug.Assert( pgszSrc == sqlite3BtreeGetPageSize( p.pSrc ) );
Debug.Assert( pgszDest == sqlite3BtreeGetPageSize( p.pDest ) );
if ( pgszSrc < pgszDest )
{
int ratio = pgszDest / pgszSrc;
nDestTruncate = (Pgno)( ( nSrcPage + ratio - 1 ) / ratio );
if ( nDestTruncate == (int)PENDING_BYTE_PAGE( p.pDest.pBt ) )
{
nDestTruncate--;
}
}
else
{
nDestTruncate = (Pgno)( nSrcPage * ( pgszSrc / pgszDest ) );
}
sqlite3PagerTruncateImage( pDestPager, nDestTruncate );
if ( pgszSrc < pgszDest )
{
/* If the source page-size is smaller than the destination page-size,
** two extra things may need to happen:
**
** * The destination may need to be truncated, and
**
** * Data stored on the pages immediately following the
** pending-byte page in the source database may need to be
** copied into the destination database.
*/
int iSize = (int)( pgszSrc * nSrcPage );
sqlite3_file pFile = sqlite3PagerFile( pDestPager );
i64 iOff;
i64 iEnd;
Debug.Assert( pFile != null );
Debug.Assert( (i64)nDestTruncate * (i64)pgszDest >= iSize || (
nDestTruncate == (int)( PENDING_BYTE_PAGE( p.pDest.pBt ) - 1 )
&& iSize >= PENDING_BYTE && iSize <= PENDING_BYTE + pgszDest
) );
/* This call ensures that all data required to recreate the original
** database has been stored in the journal for pDestPager and the
** journal synced to disk. So at this point we may safely modify
** the database file in any way, knowing that if a power failure
** occurs, the original database will be reconstructed from the
** journal file. */
rc = sqlite3PagerCommitPhaseOne( pDestPager, null, true );
/* Write the extra pages and truncate the database file as required. */
iEnd = MIN( PENDING_BYTE + pgszDest, iSize );
for (
iOff = PENDING_BYTE + pgszSrc;
rc == SQLITE_OK && iOff < iEnd;
iOff += pgszSrc
)
{
PgHdr pSrcPg = null;
u32 iSrcPg = (u32)( ( iOff / pgszSrc ) + 1 );
rc = sqlite3PagerGet( pSrcPager, iSrcPg, ref pSrcPg );
if ( rc == SQLITE_OK )
{
byte[] zData = sqlite3PagerGetData( pSrcPg );
rc = sqlite3OsWrite( pFile, zData, pgszSrc, iOff );
}
sqlite3PagerUnref( pSrcPg );
}
if ( rc == SQLITE_OK )
{
rc = backupTruncateFile( pFile, (int)iSize );
}
/* Sync the database file to disk. */
if ( rc == SQLITE_OK )
{
rc = sqlite3PagerSync( pDestPager );
}
}
else
{
rc = sqlite3PagerCommitPhaseOne( pDestPager, null, false );
}
/* Finish committing the transaction to the destination database. */
if ( SQLITE_OK == rc
&& SQLITE_OK == ( rc = sqlite3BtreeCommitPhaseTwo( p.pDest ) )
)
{
rc = SQLITE_DONE;
}
}
/* If bCloseTrans is true, then this function opened a read transaction
** on the source database. Close the read transaction here. There is
** no need to check the return values of the btree methods here, as
** "committing" a read-only transaction cannot fail.
*/
if ( bCloseTrans != 0 )
{
#if !NDEBUG || SQLITE_COVERAGE_TEST
//TESTONLY( int rc2 );
//TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p.pSrc, 0);
//TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p.pSrc);
int rc2;
rc2 = sqlite3BtreeCommitPhaseOne( p.pSrc, "" );
rc2 |= sqlite3BtreeCommitPhaseTwo( p.pSrc );
Debug.Assert( rc2 == SQLITE_OK );
#else
sqlite3BtreeCommitPhaseOne(p.pSrc, null);
sqlite3BtreeCommitPhaseTwo(p.pSrc);
#endif
}
if ( rc == SQLITE_IOERR_NOMEM )
{
rc = SQLITE_NOMEM;
}
p.rc = rc;
}
if ( p.pDestDb != null )
{
sqlite3_mutex_leave( p.pDestDb.mutex );
}
sqlite3BtreeLeave( p.pSrc );
sqlite3_mutex_leave( p.pSrcDb.mutex );
return rc;
}
/*
** Copy nPage pages from the source b-tree to the destination.
*/
public static int sqlite3_backup_step(sqlite3_backup p, int nPage)
{
int rc;
sqlite3_mutex_enter(p.pSrcDb.mutex);
sqlite3BtreeEnter(p.pSrc);
if (p.pDestDb != null)
{
sqlite3_mutex_enter(p.pDestDb.mutex);
}
rc = p.rc;
if (!isFatalError(rc))
{
var pSrcPager = sqlite3BtreePager(p.pSrc); /* Source pager */
var pDestPager = sqlite3BtreePager(p.pDest); /* Dest pager */
int ii; /* Iterator variable */
uint nSrcPage = 0; /* Size of source db in pages */
var bCloseTrans = 0; /* True if src db requires unlocking */
/* If the source pager is currently in a write-transaction, return
** SQLITE_BUSY immediately.
*/
if (p.pDestDb != null && p.pSrc.pBt.inTransaction == TRANS_WRITE)
{
rc = SQLITE_BUSY;
}
else
{
rc = SQLITE_OK;
}
/* Lock the destination database, if it is not locked already. */
if (SQLITE_OK == rc && p.bDestLocked == 0 &&
SQLITE_OK == (rc = sqlite3BtreeBeginTrans(p.pDest, 2))
)
{
p.bDestLocked = 1;
sqlite3BtreeGetMeta(p.pDest, BTREE_SCHEMA_VERSION, ref p.iDestSchema);
}
/* If there is no open read-transaction on the source database, open
** one now. If a transaction is opened here, then it will be closed
** before this function exits.
*/
if (rc == SQLITE_OK && !sqlite3BtreeIsInReadTrans(p.pSrc))
{
rc = sqlite3BtreeBeginTrans(p.pSrc, 0);
bCloseTrans = 1;
}
/* Now that there is a read-lock on the source database, query the
** source pager for the number of pages in the database.
*/
if (rc == SQLITE_OK)
{
rc = sqlite3PagerPagecount(pSrcPager, ref nSrcPage);
}
for (ii = 0; (nPage < 0 || ii < nPage) && p.iNext <= nSrcPage && 0 == rc; ii++)
{
var iSrcPg = p.iNext; /* Source page number */
if (iSrcPg != PENDING_BYTE_PAGE(p.pSrc.pBt))
{
DbPage pSrcPg = null; /* Source page object */
rc = sqlite3PagerGet(pSrcPager, iSrcPg, ref pSrcPg);
if (rc == SQLITE_OK)
{
rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg));
sqlite3PagerUnref(pSrcPg);
}
}
p.iNext++;
}
if (rc == SQLITE_OK)
{
p.nPagecount = nSrcPage;
p.nRemaining = nSrcPage + 1 - p.iNext;
if (p.iNext > nSrcPage)
{
rc = SQLITE_DONE;
}
else if (0 == p.isAttached)
{
attachBackupObject(p);
}
}
/* Update the schema version field in the destination database. This
** is to make sure that the schema-version really does change in
** the case where the source and destination databases have the
** same schema version.
*/
if (rc == SQLITE_DONE &&
(rc = sqlite3BtreeUpdateMeta(p.pDest, 1, p.iDestSchema + 1)) == SQLITE_OK
)
{
var nSrcPagesize = sqlite3BtreeGetPageSize(p.pSrc);
var nDestPagesize = sqlite3BtreeGetPageSize(p.pDest);
uint nDestTruncate;
if (p.pDestDb != null)
{
sqlite3ResetInternalSchema(p.pDestDb, 0);
}
/* Set nDestTruncate to the final number of pages in the destination
** database. The complication here is that the destination page
** size may be different to the source page size.
**
** If the source page size is smaller than the destination page size,
** round up. In this case the call to sqlite3OsTruncate() below will
** fix the size of the file. However it is important to call
** sqlite3PagerTruncateImage() here so that any pages in the
** destination file that lie beyond the nDestTruncate page mark are
** journalled by PagerCommitPhaseOne() before they are destroyed
** by the file truncation.
*/
if (nSrcPagesize < nDestPagesize)
{
var ratio = nDestPagesize / nSrcPagesize;
nDestTruncate = (uint)((nSrcPage + ratio - 1) / ratio);
if (nDestTruncate == (int)PENDING_BYTE_PAGE(p.pDest.pBt))
{
nDestTruncate--;
}
}
else
{
nDestTruncate = (uint)(nSrcPage * (nSrcPagesize / nDestPagesize));
}
sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
if (nSrcPagesize < nDestPagesize)
{
/* If the source page-size is smaller than the destination page-size,
** two extra things may need to happen:
**
** * The destination may need to be truncated, and
**
** * Data stored on the pages immediately following the
** pending-byte page in the source database may need to be
** copied into the destination database.
*/
var iSize = (uint)nSrcPagesize * nSrcPage;
var pFile = sqlite3PagerFile(pDestPager);
Debug.Assert(pFile != null);
Debug.Assert(nDestTruncate * nDestPagesize >= iSize ||
nDestTruncate == (int)(PENDING_BYTE_PAGE(p.pDest.pBt) - 1) &&
iSize >= PENDING_BYTE && iSize <= PENDING_BYTE + nDestPagesize);
if (SQLITE_OK == (rc = sqlite3PagerCommitPhaseOne(pDestPager, null, true)) &&
SQLITE_OK == (rc = backupTruncateFile(pFile, (int)iSize)) &&
SQLITE_OK == (rc = sqlite3PagerSync(pDestPager))
)
{
long iOff;
long iEnd = MIN(PENDING_BYTE + nDestPagesize, iSize);
for (
iOff = PENDING_BYTE + nSrcPagesize;
rc == SQLITE_OK && iOff < iEnd;
iOff += nSrcPagesize
)
{
PgHdr pSrcPg = null;
var iSrcPg = (uint)(iOff / nSrcPagesize + 1);
rc = sqlite3PagerGet(pSrcPager, iSrcPg, ref pSrcPg);
if (rc == SQLITE_OK)
{
var zData = sqlite3PagerGetData(pSrcPg);
rc = sqlite3OsWrite(pFile, zData, nSrcPagesize, iOff);
}
sqlite3PagerUnref(pSrcPg);
}
}
}
else
{
rc = sqlite3PagerCommitPhaseOne(pDestPager, null, false);
}
/* Finish committing the transaction to the destination database. */
if (SQLITE_OK == rc &&
SQLITE_OK == (rc = sqlite3BtreeCommitPhaseTwo(p.pDest))
)
{
rc = SQLITE_DONE;
}
}
/* If bCloseTrans is true, then this function opened a read transaction
** on the source database. Close the read transaction here. There is
** no need to check the return values of the btree methods here, as
** "committing" a read-only transaction cannot fail.
*/
if (bCloseTrans != 0)
{
#if !NDEBUG || SQLITE_COVERAGE_TEST
//TESTONLY( int rc2 );
//TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p.pSrc, 0);
//TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p.pSrc);
int rc2;
rc2 = sqlite3BtreeCommitPhaseOne(p.pSrc, "");
rc2 |= sqlite3BtreeCommitPhaseTwo(p.pSrc);
Debug.Assert(rc2 == SQLITE_OK);
#else
sqlite3BtreeCommitPhaseOne(p.pSrc, null);
sqlite3BtreeCommitPhaseTwo(p.pSrc);
#endif
}
p.rc = rc;
}
if (p.pDestDb != null)
{
sqlite3_mutex_leave(p.pDestDb.mutex);
}
sqlite3BtreeLeave(p.pSrc);
sqlite3_mutex_leave(p.pSrcDb.mutex);
return(rc);
}
/*
** Return the number of pages still to be backed up as of the most recent
** call to sqlite3_backup_step().
*/
static int sqlite3_backup_remaining(sqlite3_backup p)
{
return((int)p.nRemaining);
}
public static int pagecount(this sqlite3_backup backup)
{
return(raw.sqlite3_backup_pagecount(backup));
}
/*
** Parameter zSrcData points to a buffer containing the data for
** page iSrcPg from the source database. Copy this data into the
** destination database.
*/
private static int backupOnePage(sqlite3_backup p, uint iSrcPg, byte[] zSrcData)
{
var pDestPager = sqlite3BtreePager(p.pDest);
var nSrcPgsz = sqlite3BtreeGetPageSize(p.pSrc);
var nDestPgsz = sqlite3BtreeGetPageSize(p.pDest);
var nCopy = MIN(nSrcPgsz, nDestPgsz);
var iEnd = iSrcPg * nSrcPgsz;
var rc = SQLITE_OK;
long iOff;
Debug.Assert(p.bDestLocked != 0);
Debug.Assert(!isFatalError(p.rc));
Debug.Assert(iSrcPg != PENDING_BYTE_PAGE(p.pSrc.pBt));
Debug.Assert(zSrcData != null);
/* Catch the case where the destination is an in-memory database and the
** page sizes of the source and destination differ.
*/
if (nSrcPgsz != nDestPgsz && sqlite3PagerIsMemdb(sqlite3BtreePager(p.pDest)))
{
rc = SQLITE_READONLY;
}
/* This loop runs once for each destination page spanned by the source
** page. For each iteration, variable iOff is set to the byte offset
** of the destination page.
*/
for (iOff = iEnd - (long)nSrcPgsz; rc == SQLITE_OK && iOff < iEnd; iOff += nDestPgsz)
{
DbPage pDestPg = null;
var iDest = (uint)(iOff / nDestPgsz) + 1;
if (iDest == PENDING_BYTE_PAGE(p.pDest.pBt))
{
continue;
}
if (SQLITE_OK == (rc = sqlite3PagerGet(pDestPager, iDest, ref pDestPg)) &&
SQLITE_OK == (rc = sqlite3PagerWrite(pDestPg))
)
{
//string zIn = &zSrcData[iOff%nSrcPgsz];
var zDestData = sqlite3PagerGetData(pDestPg);
//string zOut = &zDestData[iOff % nDestPgsz];
/* Copy the data from the source page into the destination page.
** Then clear the Btree layer MemPage.isInit flag. Both this module
** and the pager code use this trick (clearing the first byte
** of the page 'extra' space to invalidate the Btree layers
** cached parse of the page). MemPage.isInit is marked
** "MUST BE FIRST" for this purpose.
*/
Buffer.BlockCopy(zSrcData, (int)(iOff % nSrcPgsz), zDestData, (int)(iOff % nDestPgsz),
nCopy); // memcpy( zOut, zIn, nCopy );
sqlite3PagerGetExtra(pDestPg).isInit = 0; // ( sqlite3PagerGetExtra( pDestPg ) )[0] = 0;
}
sqlite3PagerUnref(pDestPg);
}
return(rc);
}
public static int remaining(this sqlite3_backup backup)
{
return(raw.sqlite3_backup_remaining(backup));
}
public static int finish(this sqlite3_backup backup)
{
return(raw.sqlite3_backup_finish(backup));
}
public static int step(this sqlite3_backup backup, int nPage)
{
return(raw.sqlite3_backup_step(backup, nPage));
}
/*
** Attempt to set the page size of the destination to match the page size
** of the source.
*/
static int setDestPgsz( sqlite3_backup p )
{
int rc;
rc = sqlite3BtreeSetPageSize( p.pDest, sqlite3BtreeGetPageSize( p.pSrc ), -1, 0 );
return rc;
}
/*
** Return the total number of pages in the source database as of the most
** recent call to sqlite3_backup_step().
*/
static int sqlite3_backup_pagecount(sqlite3_backup p)
{
return((int)p.nPagecount);
}
/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
*/
static public sqlite3_backup sqlite3_backup_init(
sqlite3 pDestDb, /* Database to write to */
string zDestDb, /* Name of database within pDestDb */
sqlite3 pSrcDb, /* Database connection to read from */
string zSrcDb /* Name of database within pSrcDb */
)
{
sqlite3_backup p; /* Value to return */
/* Lock the source database handle. The destination database
** handle is not locked in this routine, but it is locked in
** sqlite3_backup_step(). The user is required to ensure that no
** other thread accesses the destination handle for the duration
** of the backup operation. Any attempt to use the destination
** database connection while a backup is in progress may cause
** a malfunction or a deadlock.
*/
sqlite3_mutex_enter( pSrcDb.mutex );
sqlite3_mutex_enter( pDestDb.mutex );
if ( pSrcDb == pDestDb )
{
sqlite3Error(
pDestDb, SQLITE_ERROR, "source and destination must be distinct"
);
p = null;
}
else
{
/* Allocate space for a new sqlite3_backup object...
** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
** call to sqlite3_backup_init() and is destroyed by a call to
** sqlite3_backup_finish(). */
p = new sqlite3_backup();// (sqlite3_backup)sqlite3_malloc( sizeof( sqlite3_backup ) );
//if ( null == p )
//{
// sqlite3Error( pDestDb, SQLITE_NOMEM, 0 );
//}
}
/* If the allocation succeeded, populate the new object. */
if ( p != null )
{
// memset( p, 0, sizeof( sqlite3_backup ) );
p.pSrc = findBtree( pDestDb, pSrcDb, zSrcDb );
p.pDest = findBtree( pDestDb, pDestDb, zDestDb );
p.pDestDb = pDestDb;
p.pSrcDb = pSrcDb;
p.iNext = 1;
p.isAttached = 0;
if ( null == p.pSrc || null == p.pDest || setDestPgsz( p ) == SQLITE_NOMEM )
{
/* One (or both) of the named databases did not exist or an OOM
** error was hit. The error has already been written into the
** pDestDb handle. All that is left to do here is free the
** sqlite3_backup structure.
*/
//sqlite3_free( ref p );
p = null;
}
}
if ( p != null )
{
p.pSrc.nBackup++;
}
sqlite3_mutex_leave( pDestDb.mutex );
sqlite3_mutex_leave( pSrcDb.mutex );
return p;
}
public static Result BackupStep(sqlite3_backup backup, int numPages)
{
return((Result)raw.sqlite3_backup_step(backup, numPages));
}
/*
** Register this backup object with the associated source pager for
** callbacks when pages are changed or the cache invalidated.
*/
static void attachBackupObject( sqlite3_backup p )
{
sqlite3_backup pp;
Debug.Assert( sqlite3BtreeHoldsMutex( p.pSrc ) );
pp = sqlite3PagerBackupPtr( sqlite3BtreePager( p.pSrc ) );
p.pNext = pp;
sqlite3BtreePager( p.pSrc ).pBackup = p; //*pp = p;
p.isAttached = 1;
}
public static Result BackupFinish(sqlite3_backup backup)
{
return((Result)raw.sqlite3_backup_finish(backup));
}
/*
** Return the number of pages still to be backed up as of the most recent
** call to sqlite3_backup_step().
*/
static int sqlite3_backup_remaining( sqlite3_backup p )
{
return (int)p.nRemaining;
}
/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
*/
static public sqlite3_backup sqlite3_backup_init(
sqlite3 pDestDb, /* Database to write to */
string zDestDb, /* Name of database within pDestDb */
sqlite3 pSrcDb, /* Database connection to read from */
string zSrcDb /* Name of database within pSrcDb */
)
{
sqlite3_backup p; /* Value to return */
/* Lock the source database handle. The destination database
** handle is not locked in this routine, but it is locked in
** sqlite3_backup_step(). The user is required to ensure that no
** other thread accesses the destination handle for the duration
** of the backup operation. Any attempt to use the destination
** database connection while a backup is in progress may cause
** a malfunction or a deadlock.
*/
sqlite3_mutex_enter(pSrcDb.mutex);
sqlite3_mutex_enter(pDestDb.mutex);
if (pSrcDb == pDestDb)
{
sqlite3Error(
pDestDb, SQLITE_ERROR, "source and destination must be distinct"
);
p = null;
}
else
{
/* Allocate space for a new sqlite3_backup object...
** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
** call to sqlite3_backup_init() and is destroyed by a call to
** sqlite3_backup_finish(). */
p = new sqlite3_backup();// (sqlite3_backup)sqlite3_malloc( sizeof( sqlite3_backup ) );
//if ( null == p )
//{
// sqlite3Error( pDestDb, SQLITE_NOMEM, 0 );
//}
}
/* If the allocation succeeded, populate the new object. */
if (p != null)
{
// memset( p, 0, sizeof( sqlite3_backup ) );
p.pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
p.pDest = findBtree(pDestDb, pDestDb, zDestDb);
p.pDestDb = pDestDb;
p.pSrcDb = pSrcDb;
p.iNext = 1;
p.isAttached = 0;
if (null == p.pSrc || null == p.pDest || setDestPgsz(p) == SQLITE_NOMEM)
{
/* One (or both) of the named databases did not exist or an OOM
** error was hit. The error has already been written into the
** pDestDb handle. All that is left to do here is free the
** sqlite3_backup structure.
*/
//sqlite3_free( ref p );
p = null;
}
}
if (p != null)
{
p.pSrc.nBackup++;
}
sqlite3_mutex_leave(pDestDb.mutex);
sqlite3_mutex_leave(pSrcDb.mutex);
return(p);
}
/*
** This function is called after the contents of page iPage of the
** source database have been modified. If page iPage has already been
** copied into the destination database, then the data written to the
** destination is now invalidated. The destination copy of iPage needs
** to be updated with the new data before the backup operation is
** complete.
**
** It is assumed that the mutex associated with the BtShared object
** corresponding to the source database is held when this function is
** called.
*/
static void sqlite3BackupUpdate( sqlite3_backup pBackup, Pgno iPage, byte[] aData )
{
sqlite3_backup p; /* Iterator variable */
for ( p = pBackup; p != null; p = p.pNext )
{
Debug.Assert( sqlite3_mutex_held( p.pSrc.pBt.mutex ) );
if ( !isFatalError( p.rc ) && iPage < p.iNext )
{
/* The backup process p has already copied page iPage. But now it
** has been modified by a transaction on the source pager. Copy
** the new data into the backup.
*/
int rc = backupOnePage( p, iPage, aData );
Debug.Assert( rc != SQLITE_BUSY && rc != SQLITE_LOCKED );
if ( rc != SQLITE_OK )
{
p.rc = rc;
}
}
}
}
/*
** Parameter zSrcData points to a buffer containing the data for
** page iSrcPg from the source database. Copy this data into the
** destination database.
*/
static int backupOnePage(sqlite3_backup p, Pgno iSrcPg, byte[] zSrcData)
{
Pager pDestPager = sqlite3BtreePager(p.pDest);
int nSrcPgsz = sqlite3BtreeGetPageSize(p.pSrc);
int nDestPgsz = sqlite3BtreeGetPageSize(p.pDest);
int nCopy = MIN(nSrcPgsz, nDestPgsz);
i64 iEnd = (i64)iSrcPg * (i64)nSrcPgsz;
#if SQLITE_HAS_CODEC
int nSrcReserve = sqlite3BtreeGetReserve(p.pSrc);
int nDestReserve = sqlite3BtreeGetReserve(p.pDest);
#endif
int rc = SQLITE_OK;
i64 iOff;
Debug.Assert(p.bDestLocked != 0);
Debug.Assert(!isFatalError(p.rc));
Debug.Assert(iSrcPg != PENDING_BYTE_PAGE(p.pSrc.pBt));
Debug.Assert(zSrcData != null);
/* Catch the case where the destination is an in-memory database and the
** page sizes of the source and destination differ.
*/
if (nSrcPgsz != nDestPgsz && sqlite3PagerIsMemdb(pDestPager))
{
rc = SQLITE_READONLY;
}
#if SQLITE_HAS_CODEC
/* Backup is not possible if the page size of the destination is changing
** and a codec is in use.
*/
if (nSrcPgsz != nDestPgsz && sqlite3PagerGetCodec(pDestPager) != null)
{
rc = SQLITE_READONLY;
}
/* Backup is not possible if the number of bytes of reserve space differ
** between source and destination. If there is a difference, try to
** fix the destination to agree with the source. If that is not possible,
** then the backup cannot proceed.
*/
if (nSrcReserve != nDestReserve)
{
u32 newPgsz = (u32)nSrcPgsz;
rc = sqlite3PagerSetPagesize(pDestPager, ref newPgsz, nSrcReserve);
if (rc == SQLITE_OK && newPgsz != nSrcPgsz)
{
rc = SQLITE_READONLY;
}
}
#endif
/* This loop runs once for each destination page spanned by the source
** page. For each iteration, variable iOff is set to the byte offset
** of the destination page.
*/
for (iOff = iEnd - (i64)nSrcPgsz; rc == SQLITE_OK && iOff < iEnd; iOff += nDestPgsz)
{
DbPage pDestPg = null;
u32 iDest = (u32)(iOff / nDestPgsz) + 1;
if (iDest == PENDING_BYTE_PAGE(p.pDest.pBt))
{
continue;
}
if (SQLITE_OK == (rc = sqlite3PagerGet(pDestPager, iDest, ref pDestPg)) &&
SQLITE_OK == (rc = sqlite3PagerWrite(pDestPg))
)
{
//string zIn = &zSrcData[iOff%nSrcPgsz];
byte[] zDestData = sqlite3PagerGetData(pDestPg);
//string zOut = &zDestData[iOff % nDestPgsz];
/* Copy the data from the source page into the destination page.
** Then clear the Btree layer MemPage.isInit flag. Both this module
** and the pager code use this trick (clearing the first byte
** of the page 'extra' space to invalidate the Btree layers
** cached parse of the page). MemPage.isInit is marked
** "MUST BE FIRST" for this purpose.
*/
Buffer.BlockCopy(zSrcData, (int)(iOff % nSrcPgsz), zDestData, (int)(iOff % nDestPgsz), nCopy); // memcpy( zOut, zIn, nCopy );
sqlite3PagerGetExtra(pDestPg).isInit = 0; // ( sqlite3PagerGetExtra( pDestPg ) )[0] = 0;
}
sqlite3PagerUnref(pDestPg);
}
return(rc);
}
/*
** Copy the complete content of pBtFrom into pBtTo. A transaction
** must be active for both files.
**
** The size of file pTo may be reduced by this operation. If anything
** goes wrong, the transaction on pTo is rolled back. If successful, the
** transaction is committed before returning.
*/
static int sqlite3BtreeCopyFile( Btree pTo, Btree pFrom )
{
int rc;
sqlite3_backup b;
sqlite3BtreeEnter( pTo );
sqlite3BtreeEnter( pFrom );
/* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
** to 0. This is used by the implementations of sqlite3_backup_step()
** and sqlite3_backup_finish() to detect that they are being called
** from this function, not directly by the user.
*/
b = new sqlite3_backup();// memset( &b, 0, sizeof( b ) );
b.pSrcDb = pFrom.db;
b.pSrc = pFrom;
b.pDest = pTo;
b.iNext = 1;
/* 0x7FFFFFFF is the hard limit for the number of pages in a database
** file. By passing this as the number of pages to copy to
** sqlite3_backup_step(), we can guarantee that the copy finishes
** within a single call (unless an error occurs). The Debug.Assert() statement
** checks this assumption - (p.rc) should be set to either SQLITE_DONE
** or an error code.
*/
sqlite3_backup_step( b, 0x7FFFFFFF );
Debug.Assert( b.rc != SQLITE_OK );
rc = sqlite3_backup_finish( b );
if ( rc == SQLITE_OK )
{
pTo.pBt.pageSizeFixed = false;
}
sqlite3BtreeLeave( pFrom );
sqlite3BtreeLeave( pTo );
return rc;
}
static void backupTestFinish(ref ClientData clientData)
{
sqlite3_backup pBackup = (sqlite3_backup)clientData;
sqlite3_backup_finish(pBackup);
}