4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
11 *************************************************************************
12 ** This file contains the implementation of the sqlite3_backup_XXX()
13 ** API functions and the related features.
15 #include "sqliteInt.h"
19 ** Structure allocated for each backup operation.
21 struct sqlite3_backup
{
22 sqlite3
* pDestDb
; /* Destination database handle */
23 Btree
*pDest
; /* Destination b-tree file */
24 u32 iDestSchema
; /* Original schema cookie in destination */
25 int bDestLocked
; /* True once a write-transaction is open on pDest */
27 Pgno iNext
; /* Page number of the next source page to copy */
28 sqlite3
* pSrcDb
; /* Source database handle */
29 Btree
*pSrc
; /* Source b-tree file */
31 int rc
; /* Backup process error code */
33 /* These two variables are set by every call to backup_step(). They are
34 ** read by calls to backup_remaining() and backup_pagecount().
36 Pgno nRemaining
; /* Number of pages left to copy */
37 Pgno nPagecount
; /* Total number of pages to copy */
39 int isAttached
; /* True once backup has been registered with pager */
40 sqlite3_backup
*pNext
; /* Next backup associated with source pager */
44 ** THREAD SAFETY NOTES:
46 ** Once it has been created using backup_init(), a single sqlite3_backup
47 ** structure may be accessed via two groups of thread-safe entry points:
49 ** * Via the sqlite3_backup_XXX() API function backup_step() and
50 ** backup_finish(). Both these functions obtain the source database
51 ** handle mutex and the mutex associated with the source BtShared
52 ** structure, in that order.
54 ** * Via the BackupUpdate() and BackupRestart() functions, which are
55 ** invoked by the pager layer to report various state changes in
56 ** the page cache associated with the source database. The mutex
57 ** associated with the source database BtShared structure will always
58 ** be held when either of these functions are invoked.
60 ** The other sqlite3_backup_XXX() API functions, backup_remaining() and
61 ** backup_pagecount() are not thread-safe functions. If they are called
62 ** while some other thread is calling backup_step() or backup_finish(),
63 ** the values returned may be invalid. There is no way for a call to
64 ** BackupUpdate() or BackupRestart() to interfere with backup_remaining()
65 ** or backup_pagecount().
67 ** Depending on the SQLite configuration, the database handles and/or
68 ** the Btree objects may have their own mutexes that require locking.
69 ** Non-sharable Btrees (in-memory databases for example), do not have
70 ** associated mutexes.
74 ** Return a pointer corresponding to database zDb (i.e. "main", "temp")
75 ** in connection handle pDb. If such a database cannot be found, return
76 ** a NULL pointer and write an error message to pErrorDb.
78 ** If the "temp" database is requested, it may need to be opened by this
79 ** function. If an error occurs while doing so, return 0 and write an
80 ** error message to pErrorDb.
82 static Btree
*findBtree(sqlite3
*pErrorDb
, sqlite3
*pDb
, const char *zDb
){
83 int i
= sqlite3FindDbName(pDb
, zDb
);
88 pParse
= sqlite3StackAllocZero(pErrorDb
, sizeof(*pParse
));
90 sqlite3ErrorWithMsg(pErrorDb
, SQLITE_NOMEM
, "out of memory");
94 if( sqlite3OpenTempDatabase(pParse
) ){
95 sqlite3ErrorWithMsg(pErrorDb
, pParse
->rc
, "%s", pParse
->zErrMsg
);
98 sqlite3DbFree(pErrorDb
, pParse
->zErrMsg
);
99 sqlite3ParserReset(pParse
);
100 sqlite3StackFree(pErrorDb
, pParse
);
108 sqlite3ErrorWithMsg(pErrorDb
, SQLITE_ERROR
, "unknown database %s", zDb
);
112 return pDb
->aDb
[i
].pBt
;
116 ** Attempt to set the page size of the destination to match the page size
119 static int setDestPgsz(sqlite3_backup
*p
){
121 rc
= sqlite3BtreeSetPageSize(p
->pDest
,sqlite3BtreeGetPageSize(p
->pSrc
),-1,0);
126 ** Check that there is no open read-transaction on the b-tree passed as the
127 ** second argument. If there is not, return SQLITE_OK. Otherwise, if there
128 ** is an open read-transaction, return SQLITE_ERROR and leave an error
129 ** message in database handle db.
131 static int checkReadTransaction(sqlite3
*db
, Btree
*p
){
132 if( sqlite3BtreeIsInReadTrans(p
) ){
133 sqlite3ErrorWithMsg(db
, SQLITE_ERROR
, "destination database is in use");
140 ** Create an sqlite3_backup process to copy the contents of zSrcDb from
141 ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
142 ** a pointer to the new sqlite3_backup object.
144 ** If an error occurs, NULL is returned and an error code and error message
145 ** stored in database handle pDestDb.
147 sqlite3_backup
*sqlite3_backup_init(
148 sqlite3
* pDestDb
, /* Database to write to */
149 const char *zDestDb
, /* Name of database within pDestDb */
150 sqlite3
* pSrcDb
, /* Database connection to read from */
151 const char *zSrcDb
/* Name of database within pSrcDb */
153 sqlite3_backup
*p
; /* Value to return */
155 #ifdef SQLITE_ENABLE_API_ARMOR
156 if( !sqlite3SafetyCheckOk(pSrcDb
)||!sqlite3SafetyCheckOk(pDestDb
) ){
157 (void)SQLITE_MISUSE_BKPT
;
162 /* Lock the source database handle. The destination database
163 ** handle is not locked in this routine, but it is locked in
164 ** sqlite3_backup_step(). The user is required to ensure that no
165 ** other thread accesses the destination handle for the duration
166 ** of the backup operation. Any attempt to use the destination
167 ** database connection while a backup is in progress may cause
168 ** a malfunction or a deadlock.
170 sqlite3_mutex_enter(pSrcDb
->mutex
);
171 sqlite3_mutex_enter(pDestDb
->mutex
);
173 if( pSrcDb
==pDestDb
){
175 pDestDb
, SQLITE_ERROR
, "source and destination must be distinct"
179 /* Allocate space for a new sqlite3_backup object...
180 ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
181 ** call to sqlite3_backup_init() and is destroyed by a call to
182 ** sqlite3_backup_finish(). */
183 p
= (sqlite3_backup
*)sqlite3MallocZero(sizeof(sqlite3_backup
));
185 sqlite3Error(pDestDb
, SQLITE_NOMEM
);
189 /* If the allocation succeeded, populate the new object. */
191 p
->pSrc
= findBtree(pDestDb
, pSrcDb
, zSrcDb
);
192 p
->pDest
= findBtree(pDestDb
, pDestDb
, zDestDb
);
193 p
->pDestDb
= pDestDb
;
198 if( 0==p
->pSrc
|| 0==p
->pDest
199 || setDestPgsz(p
)==SQLITE_NOMEM
200 || checkReadTransaction(pDestDb
, p
->pDest
)!=SQLITE_OK
202 /* One (or both) of the named databases did not exist or an OOM
203 ** error was hit. Or there is a transaction open on the destination
204 ** database. The error has already been written into the pDestDb
205 ** handle. All that is left to do here is free the sqlite3_backup
215 sqlite3_mutex_leave(pDestDb
->mutex
);
216 sqlite3_mutex_leave(pSrcDb
->mutex
);
221 ** Argument rc is an SQLite error code. Return true if this error is
222 ** considered fatal if encountered during a backup operation. All errors
223 ** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED.
225 static int isFatalError(int rc
){
226 return (rc
!=SQLITE_OK
&& rc
!=SQLITE_BUSY
&& ALWAYS(rc
!=SQLITE_LOCKED
));
230 ** Parameter zSrcData points to a buffer containing the data for
231 ** page iSrcPg from the source database. Copy this data into the
232 ** destination database.
234 static int backupOnePage(
235 sqlite3_backup
*p
, /* Backup handle */
236 Pgno iSrcPg
, /* Source database page to backup */
237 const u8
*zSrcData
, /* Source database page data */
238 int bUpdate
/* True for an update, false otherwise */
240 Pager
* const pDestPager
= sqlite3BtreePager(p
->pDest
);
241 const int nSrcPgsz
= sqlite3BtreeGetPageSize(p
->pSrc
);
242 int nDestPgsz
= sqlite3BtreeGetPageSize(p
->pDest
);
243 const int nCopy
= MIN(nSrcPgsz
, nDestPgsz
);
244 const i64 iEnd
= (i64
)iSrcPg
*(i64
)nSrcPgsz
;
245 #ifdef SQLITE_HAS_CODEC
246 /* Use BtreeGetReserveNoMutex() for the source b-tree, as although it is
247 ** guaranteed that the shared-mutex is held by this thread, handle
248 ** p->pSrc may not actually be the owner. */
249 int nSrcReserve
= sqlite3BtreeGetReserveNoMutex(p
->pSrc
);
250 int nDestReserve
= sqlite3BtreeGetReserve(p
->pDest
);
255 assert( sqlite3BtreeGetReserveNoMutex(p
->pSrc
)>=0 );
256 assert( p
->bDestLocked
);
257 assert( !isFatalError(p
->rc
) );
258 assert( iSrcPg
!=PENDING_BYTE_PAGE(p
->pSrc
->pBt
) );
261 /* Catch the case where the destination is an in-memory database and the
262 ** page sizes of the source and destination differ.
264 if( nSrcPgsz
!=nDestPgsz
&& sqlite3PagerIsMemdb(pDestPager
) ){
265 rc
= SQLITE_READONLY
;
268 #ifdef SQLITE_HAS_CODEC
269 /* Backup is not possible if the page size of the destination is changing
270 ** and a codec is in use.
272 if( nSrcPgsz
!=nDestPgsz
&& sqlite3PagerGetCodec(pDestPager
)!=0 ){
273 rc
= SQLITE_READONLY
;
276 /* Backup is not possible if the number of bytes of reserve space differ
277 ** between source and destination. If there is a difference, try to
278 ** fix the destination to agree with the source. If that is not possible,
279 ** then the backup cannot proceed.
281 if( nSrcReserve
!=nDestReserve
){
282 u32 newPgsz
= nSrcPgsz
;
283 rc
= sqlite3PagerSetPagesize(pDestPager
, &newPgsz
, nSrcReserve
);
284 if( rc
==SQLITE_OK
&& newPgsz
!=nSrcPgsz
) rc
= SQLITE_READONLY
;
288 /* This loop runs once for each destination page spanned by the source
289 ** page. For each iteration, variable iOff is set to the byte offset
290 ** of the destination page.
292 for(iOff
=iEnd
-(i64
)nSrcPgsz
; rc
==SQLITE_OK
&& iOff
<iEnd
; iOff
+=nDestPgsz
){
294 Pgno iDest
= (Pgno
)(iOff
/nDestPgsz
)+1;
295 if( iDest
==PENDING_BYTE_PAGE(p
->pDest
->pBt
) ) continue;
296 if( SQLITE_OK
==(rc
= sqlite3PagerGet(pDestPager
, iDest
, &pDestPg
))
297 && SQLITE_OK
==(rc
= sqlite3PagerWrite(pDestPg
))
299 const u8
*zIn
= &zSrcData
[iOff
%nSrcPgsz
];
300 u8
*zDestData
= sqlite3PagerGetData(pDestPg
);
301 u8
*zOut
= &zDestData
[iOff
%nDestPgsz
];
303 /* Copy the data from the source page into the destination page.
304 ** Then clear the Btree layer MemPage.isInit flag. Both this module
305 ** and the pager code use this trick (clearing the first byte
306 ** of the page 'extra' space to invalidate the Btree layers
307 ** cached parse of the page). MemPage.isInit is marked
308 ** "MUST BE FIRST" for this purpose.
310 memcpy(zOut
, zIn
, nCopy
);
311 ((u8
*)sqlite3PagerGetExtra(pDestPg
))[0] = 0;
312 if( iOff
==0 && bUpdate
==0 ){
313 sqlite3Put4byte(&zOut
[28], sqlite3BtreeLastPage(p
->pSrc
));
316 sqlite3PagerUnref(pDestPg
);
323 ** If pFile is currently larger than iSize bytes, then truncate it to
324 ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
325 ** this function is a no-op.
327 ** Return SQLITE_OK if everything is successful, or an SQLite error
328 ** code if an error occurs.
330 static int backupTruncateFile(sqlite3_file
*pFile
, i64 iSize
){
332 int rc
= sqlite3OsFileSize(pFile
, &iCurrent
);
333 if( rc
==SQLITE_OK
&& iCurrent
>iSize
){
334 rc
= sqlite3OsTruncate(pFile
, iSize
);
340 ** Register this backup object with the associated source pager for
341 ** callbacks when pages are changed or the cache invalidated.
343 static void attachBackupObject(sqlite3_backup
*p
){
345 assert( sqlite3BtreeHoldsMutex(p
->pSrc
) );
346 pp
= sqlite3PagerBackupPtr(sqlite3BtreePager(p
->pSrc
));
353 ** Copy nPage pages from the source b-tree to the destination.
355 int sqlite3_backup_step(sqlite3_backup
*p
, int nPage
){
357 int destMode
; /* Destination journal mode */
358 int pgszSrc
= 0; /* Source page size */
359 int pgszDest
= 0; /* Destination page size */
361 #ifdef SQLITE_ENABLE_API_ARMOR
362 if( p
==0 ) return SQLITE_MISUSE_BKPT
;
364 sqlite3_mutex_enter(p
->pSrcDb
->mutex
);
365 sqlite3BtreeEnter(p
->pSrc
);
367 sqlite3_mutex_enter(p
->pDestDb
->mutex
);
371 if( !isFatalError(rc
) ){
372 Pager
* const pSrcPager
= sqlite3BtreePager(p
->pSrc
); /* Source pager */
373 Pager
* const pDestPager
= sqlite3BtreePager(p
->pDest
); /* Dest pager */
374 int ii
; /* Iterator variable */
375 int nSrcPage
= -1; /* Size of source db in pages */
376 int bCloseTrans
= 0; /* True if src db requires unlocking */
378 /* If the source pager is currently in a write-transaction, return
379 ** SQLITE_BUSY immediately.
381 if( p
->pDestDb
&& p
->pSrc
->pBt
->inTransaction
==TRANS_WRITE
){
387 /* Lock the destination database, if it is not locked already. */
388 if( SQLITE_OK
==rc
&& p
->bDestLocked
==0
389 && SQLITE_OK
==(rc
= sqlite3BtreeBeginTrans(p
->pDest
, 2))
392 sqlite3BtreeGetMeta(p
->pDest
, BTREE_SCHEMA_VERSION
, &p
->iDestSchema
);
395 /* If there is no open read-transaction on the source database, open
396 ** one now. If a transaction is opened here, then it will be closed
397 ** before this function exits.
399 if( rc
==SQLITE_OK
&& 0==sqlite3BtreeIsInReadTrans(p
->pSrc
) ){
400 rc
= sqlite3BtreeBeginTrans(p
->pSrc
, 0);
404 /* Do not allow backup if the destination database is in WAL mode
405 ** and the page sizes are different between source and destination */
406 pgszSrc
= sqlite3BtreeGetPageSize(p
->pSrc
);
407 pgszDest
= sqlite3BtreeGetPageSize(p
->pDest
);
408 destMode
= sqlite3PagerGetJournalMode(sqlite3BtreePager(p
->pDest
));
409 if( SQLITE_OK
==rc
&& destMode
==PAGER_JOURNALMODE_WAL
&& pgszSrc
!=pgszDest
){
410 rc
= SQLITE_READONLY
;
413 /* Now that there is a read-lock on the source database, query the
414 ** source pager for the number of pages in the database.
416 nSrcPage
= (int)sqlite3BtreeLastPage(p
->pSrc
);
417 assert( nSrcPage
>=0 );
418 for(ii
=0; (nPage
<0 || ii
<nPage
) && p
->iNext
<=(Pgno
)nSrcPage
&& !rc
; ii
++){
419 const Pgno iSrcPg
= p
->iNext
; /* Source page number */
420 if( iSrcPg
!=PENDING_BYTE_PAGE(p
->pSrc
->pBt
) ){
421 DbPage
*pSrcPg
; /* Source page object */
422 rc
= sqlite3PagerAcquire(pSrcPager
, iSrcPg
, &pSrcPg
,
425 rc
= backupOnePage(p
, iSrcPg
, sqlite3PagerGetData(pSrcPg
), 0);
426 sqlite3PagerUnref(pSrcPg
);
432 p
->nPagecount
= nSrcPage
;
433 p
->nRemaining
= nSrcPage
+1-p
->iNext
;
434 if( p
->iNext
>(Pgno
)nSrcPage
){
436 }else if( !p
->isAttached
){
437 attachBackupObject(p
);
441 /* Update the schema version field in the destination database. This
442 ** is to make sure that the schema-version really does change in
443 ** the case where the source and destination databases have the
444 ** same schema version.
446 if( rc
==SQLITE_DONE
){
448 rc
= sqlite3BtreeNewDb(p
->pDest
);
451 if( rc
==SQLITE_OK
|| rc
==SQLITE_DONE
){
452 rc
= sqlite3BtreeUpdateMeta(p
->pDest
,1,p
->iDestSchema
+1);
456 sqlite3ResetAllSchemasOfConnection(p
->pDestDb
);
458 if( destMode
==PAGER_JOURNALMODE_WAL
){
459 rc
= sqlite3BtreeSetVersion(p
->pDest
, 2);
464 /* Set nDestTruncate to the final number of pages in the destination
465 ** database. The complication here is that the destination page
466 ** size may be different to the source page size.
468 ** If the source page size is smaller than the destination page size,
469 ** round up. In this case the call to sqlite3OsTruncate() below will
470 ** fix the size of the file. However it is important to call
471 ** sqlite3PagerTruncateImage() here so that any pages in the
472 ** destination file that lie beyond the nDestTruncate page mark are
473 ** journalled by PagerCommitPhaseOne() before they are destroyed
474 ** by the file truncation.
476 assert( pgszSrc
==sqlite3BtreeGetPageSize(p
->pSrc
) );
477 assert( pgszDest
==sqlite3BtreeGetPageSize(p
->pDest
) );
478 if( pgszSrc
<pgszDest
){
479 int ratio
= pgszDest
/pgszSrc
;
480 nDestTruncate
= (nSrcPage
+ratio
-1)/ratio
;
481 if( nDestTruncate
==(int)PENDING_BYTE_PAGE(p
->pDest
->pBt
) ){
485 nDestTruncate
= nSrcPage
* (pgszSrc
/pgszDest
);
487 assert( nDestTruncate
>0 );
489 if( pgszSrc
<pgszDest
){
490 /* If the source page-size is smaller than the destination page-size,
491 ** two extra things may need to happen:
493 ** * The destination may need to be truncated, and
495 ** * Data stored on the pages immediately following the
496 ** pending-byte page in the source database may need to be
497 ** copied into the destination database.
499 const i64 iSize
= (i64
)pgszSrc
* (i64
)nSrcPage
;
500 sqlite3_file
* const pFile
= sqlite3PagerFile(pDestPager
);
507 assert( nDestTruncate
==0
508 || (i64
)nDestTruncate
*(i64
)pgszDest
>= iSize
|| (
509 nDestTruncate
==(int)(PENDING_BYTE_PAGE(p
->pDest
->pBt
)-1)
510 && iSize
>=PENDING_BYTE
&& iSize
<=PENDING_BYTE
+pgszDest
513 /* This block ensures that all data required to recreate the original
514 ** database has been stored in the journal for pDestPager and the
515 ** journal synced to disk. So at this point we may safely modify
516 ** the database file in any way, knowing that if a power failure
517 ** occurs, the original database will be reconstructed from the
519 sqlite3PagerPagecount(pDestPager
, &nDstPage
);
520 for(iPg
=nDestTruncate
; rc
==SQLITE_OK
&& iPg
<=(Pgno
)nDstPage
; iPg
++){
521 if( iPg
!=PENDING_BYTE_PAGE(p
->pDest
->pBt
) ){
523 rc
= sqlite3PagerGet(pDestPager
, iPg
, &pPg
);
525 rc
= sqlite3PagerWrite(pPg
);
526 sqlite3PagerUnref(pPg
);
531 rc
= sqlite3PagerCommitPhaseOne(pDestPager
, 0, 1);
534 /* Write the extra pages and truncate the database file as required */
535 iEnd
= MIN(PENDING_BYTE
+ pgszDest
, iSize
);
537 iOff
=PENDING_BYTE
+pgszSrc
;
538 rc
==SQLITE_OK
&& iOff
<iEnd
;
542 const Pgno iSrcPg
= (Pgno
)((iOff
/pgszSrc
)+1);
543 rc
= sqlite3PagerGet(pSrcPager
, iSrcPg
, &pSrcPg
);
545 u8
*zData
= sqlite3PagerGetData(pSrcPg
);
546 rc
= sqlite3OsWrite(pFile
, zData
, pgszSrc
, iOff
);
548 sqlite3PagerUnref(pSrcPg
);
551 rc
= backupTruncateFile(pFile
, iSize
);
554 /* Sync the database file to disk. */
556 rc
= sqlite3PagerSync(pDestPager
, 0);
559 sqlite3PagerTruncateImage(pDestPager
, nDestTruncate
);
560 rc
= sqlite3PagerCommitPhaseOne(pDestPager
, 0, 0);
563 /* Finish committing the transaction to the destination database. */
565 && SQLITE_OK
==(rc
= sqlite3BtreeCommitPhaseTwo(p
->pDest
, 0))
572 /* If bCloseTrans is true, then this function opened a read transaction
573 ** on the source database. Close the read transaction here. There is
574 ** no need to check the return values of the btree methods here, as
575 ** "committing" a read-only transaction cannot fail.
579 TESTONLY( rc2
= ) sqlite3BtreeCommitPhaseOne(p
->pSrc
, 0);
580 TESTONLY( rc2
|= ) sqlite3BtreeCommitPhaseTwo(p
->pSrc
, 0);
581 assert( rc2
==SQLITE_OK
);
584 if( rc
==SQLITE_IOERR_NOMEM
){
590 sqlite3_mutex_leave(p
->pDestDb
->mutex
);
592 sqlite3BtreeLeave(p
->pSrc
);
593 sqlite3_mutex_leave(p
->pSrcDb
->mutex
);
598 ** Release all resources associated with an sqlite3_backup* handle.
600 int sqlite3_backup_finish(sqlite3_backup
*p
){
601 sqlite3_backup
**pp
; /* Ptr to head of pagers backup list */
602 sqlite3
*pSrcDb
; /* Source database connection */
603 int rc
; /* Value to return */
605 /* Enter the mutexes */
606 if( p
==0 ) return SQLITE_OK
;
608 sqlite3_mutex_enter(pSrcDb
->mutex
);
609 sqlite3BtreeEnter(p
->pSrc
);
611 sqlite3_mutex_enter(p
->pDestDb
->mutex
);
614 /* Detach this backup from the source pager. */
619 pp
= sqlite3PagerBackupPtr(sqlite3BtreePager(p
->pSrc
));
626 /* If a transaction is still open on the Btree, roll it back. */
627 sqlite3BtreeRollback(p
->pDest
, SQLITE_OK
, 0);
629 /* Set the error code of the destination database handle. */
630 rc
= (p
->rc
==SQLITE_DONE
) ? SQLITE_OK
: p
->rc
;
632 sqlite3Error(p
->pDestDb
, rc
);
634 /* Exit the mutexes and free the backup context structure. */
635 sqlite3LeaveMutexAndCloseZombie(p
->pDestDb
);
637 sqlite3BtreeLeave(p
->pSrc
);
639 /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
640 ** call to sqlite3_backup_init() and is destroyed by a call to
641 ** sqlite3_backup_finish(). */
644 sqlite3LeaveMutexAndCloseZombie(pSrcDb
);
649 ** Return the number of pages still to be backed up as of the most recent
650 ** call to sqlite3_backup_step().
652 int sqlite3_backup_remaining(sqlite3_backup
*p
){
653 #ifdef SQLITE_ENABLE_API_ARMOR
655 (void)SQLITE_MISUSE_BKPT
;
659 return p
->nRemaining
;
663 ** Return the total number of pages in the source database as of the most
664 ** recent call to sqlite3_backup_step().
666 int sqlite3_backup_pagecount(sqlite3_backup
*p
){
667 #ifdef SQLITE_ENABLE_API_ARMOR
669 (void)SQLITE_MISUSE_BKPT
;
673 return p
->nPagecount
;
677 ** This function is called after the contents of page iPage of the
678 ** source database have been modified. If page iPage has already been
679 ** copied into the destination database, then the data written to the
680 ** destination is now invalidated. The destination copy of iPage needs
681 ** to be updated with the new data before the backup operation is
684 ** It is assumed that the mutex associated with the BtShared object
685 ** corresponding to the source database is held when this function is
688 void sqlite3BackupUpdate(sqlite3_backup
*pBackup
, Pgno iPage
, const u8
*aData
){
689 sqlite3_backup
*p
; /* Iterator variable */
690 for(p
=pBackup
; p
; p
=p
->pNext
){
691 assert( sqlite3_mutex_held(p
->pSrc
->pBt
->mutex
) );
692 if( !isFatalError(p
->rc
) && iPage
<p
->iNext
){
693 /* The backup process p has already copied page iPage. But now it
694 ** has been modified by a transaction on the source pager. Copy
695 ** the new data into the backup.
698 assert( p
->pDestDb
);
699 sqlite3_mutex_enter(p
->pDestDb
->mutex
);
700 rc
= backupOnePage(p
, iPage
, aData
, 1);
701 sqlite3_mutex_leave(p
->pDestDb
->mutex
);
702 assert( rc
!=SQLITE_BUSY
&& rc
!=SQLITE_LOCKED
);
711 ** Restart the backup process. This is called when the pager layer
712 ** detects that the database has been modified by an external database
713 ** connection. In this case there is no way of knowing which of the
714 ** pages that have been copied into the destination database are still
715 ** valid and which are not, so the entire process needs to be restarted.
717 ** It is assumed that the mutex associated with the BtShared object
718 ** corresponding to the source database is held when this function is
721 void sqlite3BackupRestart(sqlite3_backup
*pBackup
){
722 sqlite3_backup
*p
; /* Iterator variable */
723 for(p
=pBackup
; p
; p
=p
->pNext
){
724 assert( sqlite3_mutex_held(p
->pSrc
->pBt
->mutex
) );
729 #ifndef SQLITE_OMIT_VACUUM
731 ** Copy the complete content of pBtFrom into pBtTo. A transaction
732 ** must be active for both files.
734 ** The size of file pTo may be reduced by this operation. If anything
735 ** goes wrong, the transaction on pTo is rolled back. If successful, the
736 ** transaction is committed before returning.
738 int sqlite3BtreeCopyFile(Btree
*pTo
, Btree
*pFrom
){
740 sqlite3_file
*pFd
; /* File descriptor for database pTo */
742 sqlite3BtreeEnter(pTo
);
743 sqlite3BtreeEnter(pFrom
);
745 assert( sqlite3BtreeIsInTrans(pTo
) );
746 pFd
= sqlite3PagerFile(sqlite3BtreePager(pTo
));
748 i64 nByte
= sqlite3BtreeGetPageSize(pFrom
)*(i64
)sqlite3BtreeLastPage(pFrom
);
749 rc
= sqlite3OsFileControl(pFd
, SQLITE_FCNTL_OVERWRITE
, &nByte
);
750 if( rc
==SQLITE_NOTFOUND
) rc
= SQLITE_OK
;
751 if( rc
) goto copy_finished
;
754 /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
755 ** to 0. This is used by the implementations of sqlite3_backup_step()
756 ** and sqlite3_backup_finish() to detect that they are being called
757 ** from this function, not directly by the user.
759 memset(&b
, 0, sizeof(b
));
760 b
.pSrcDb
= pFrom
->db
;
765 /* 0x7FFFFFFF is the hard limit for the number of pages in a database
766 ** file. By passing this as the number of pages to copy to
767 ** sqlite3_backup_step(), we can guarantee that the copy finishes
768 ** within a single call (unless an error occurs). The assert() statement
769 ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
772 sqlite3_backup_step(&b
, 0x7FFFFFFF);
773 assert( b
.rc
!=SQLITE_OK
);
774 rc
= sqlite3_backup_finish(&b
);
776 pTo
->pBt
->btsFlags
&= ~BTS_PAGESIZE_FIXED
;
778 sqlite3PagerClearCache(sqlite3BtreePager(b
.pDest
));
781 assert( sqlite3BtreeIsInTrans(pTo
)==0 );
783 sqlite3BtreeLeave(pFrom
);
784 sqlite3BtreeLeave(pTo
);
787 #endif /* SQLITE_OMIT_VACUUM */