Annotation of embedaddon/sqlite3/src/backup.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2009 January 28
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 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.
! 10: **
! 11: *************************************************************************
! 12: ** This file contains the implementation of the sqlite3_backup_XXX()
! 13: ** API functions and the related features.
! 14: */
! 15: #include "sqliteInt.h"
! 16: #include "btreeInt.h"
! 17:
! 18: /* Macro to find the minimum of two numeric values.
! 19: */
! 20: #ifndef MIN
! 21: # define MIN(x,y) ((x)<(y)?(x):(y))
! 22: #endif
! 23:
! 24: /*
! 25: ** Structure allocated for each backup operation.
! 26: */
! 27: struct sqlite3_backup {
! 28: sqlite3* pDestDb; /* Destination database handle */
! 29: Btree *pDest; /* Destination b-tree file */
! 30: u32 iDestSchema; /* Original schema cookie in destination */
! 31: int bDestLocked; /* True once a write-transaction is open on pDest */
! 32:
! 33: Pgno iNext; /* Page number of the next source page to copy */
! 34: sqlite3* pSrcDb; /* Source database handle */
! 35: Btree *pSrc; /* Source b-tree file */
! 36:
! 37: int rc; /* Backup process error code */
! 38:
! 39: /* These two variables are set by every call to backup_step(). They are
! 40: ** read by calls to backup_remaining() and backup_pagecount().
! 41: */
! 42: Pgno nRemaining; /* Number of pages left to copy */
! 43: Pgno nPagecount; /* Total number of pages to copy */
! 44:
! 45: int isAttached; /* True once backup has been registered with pager */
! 46: sqlite3_backup *pNext; /* Next backup associated with source pager */
! 47: };
! 48:
! 49: /*
! 50: ** THREAD SAFETY NOTES:
! 51: **
! 52: ** Once it has been created using backup_init(), a single sqlite3_backup
! 53: ** structure may be accessed via two groups of thread-safe entry points:
! 54: **
! 55: ** * Via the sqlite3_backup_XXX() API function backup_step() and
! 56: ** backup_finish(). Both these functions obtain the source database
! 57: ** handle mutex and the mutex associated with the source BtShared
! 58: ** structure, in that order.
! 59: **
! 60: ** * Via the BackupUpdate() and BackupRestart() functions, which are
! 61: ** invoked by the pager layer to report various state changes in
! 62: ** the page cache associated with the source database. The mutex
! 63: ** associated with the source database BtShared structure will always
! 64: ** be held when either of these functions are invoked.
! 65: **
! 66: ** The other sqlite3_backup_XXX() API functions, backup_remaining() and
! 67: ** backup_pagecount() are not thread-safe functions. If they are called
! 68: ** while some other thread is calling backup_step() or backup_finish(),
! 69: ** the values returned may be invalid. There is no way for a call to
! 70: ** BackupUpdate() or BackupRestart() to interfere with backup_remaining()
! 71: ** or backup_pagecount().
! 72: **
! 73: ** Depending on the SQLite configuration, the database handles and/or
! 74: ** the Btree objects may have their own mutexes that require locking.
! 75: ** Non-sharable Btrees (in-memory databases for example), do not have
! 76: ** associated mutexes.
! 77: */
! 78:
! 79: /*
! 80: ** Return a pointer corresponding to database zDb (i.e. "main", "temp")
! 81: ** in connection handle pDb. If such a database cannot be found, return
! 82: ** a NULL pointer and write an error message to pErrorDb.
! 83: **
! 84: ** If the "temp" database is requested, it may need to be opened by this
! 85: ** function. If an error occurs while doing so, return 0 and write an
! 86: ** error message to pErrorDb.
! 87: */
! 88: static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
! 89: int i = sqlite3FindDbName(pDb, zDb);
! 90:
! 91: if( i==1 ){
! 92: Parse *pParse;
! 93: int rc = 0;
! 94: pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
! 95: if( pParse==0 ){
! 96: sqlite3Error(pErrorDb, SQLITE_NOMEM, "out of memory");
! 97: rc = SQLITE_NOMEM;
! 98: }else{
! 99: pParse->db = pDb;
! 100: if( sqlite3OpenTempDatabase(pParse) ){
! 101: sqlite3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
! 102: rc = SQLITE_ERROR;
! 103: }
! 104: sqlite3DbFree(pErrorDb, pParse->zErrMsg);
! 105: sqlite3StackFree(pErrorDb, pParse);
! 106: }
! 107: if( rc ){
! 108: return 0;
! 109: }
! 110: }
! 111:
! 112: if( i<0 ){
! 113: sqlite3Error(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
! 114: return 0;
! 115: }
! 116:
! 117: return pDb->aDb[i].pBt;
! 118: }
! 119:
! 120: /*
! 121: ** Attempt to set the page size of the destination to match the page size
! 122: ** of the source.
! 123: */
! 124: static int setDestPgsz(sqlite3_backup *p){
! 125: int rc;
! 126: rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),-1,0);
! 127: return rc;
! 128: }
! 129:
! 130: /*
! 131: ** Create an sqlite3_backup process to copy the contents of zSrcDb from
! 132: ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
! 133: ** a pointer to the new sqlite3_backup object.
! 134: **
! 135: ** If an error occurs, NULL is returned and an error code and error message
! 136: ** stored in database handle pDestDb.
! 137: */
! 138: sqlite3_backup *sqlite3_backup_init(
! 139: sqlite3* pDestDb, /* Database to write to */
! 140: const char *zDestDb, /* Name of database within pDestDb */
! 141: sqlite3* pSrcDb, /* Database connection to read from */
! 142: const char *zSrcDb /* Name of database within pSrcDb */
! 143: ){
! 144: sqlite3_backup *p; /* Value to return */
! 145:
! 146: /* Lock the source database handle. The destination database
! 147: ** handle is not locked in this routine, but it is locked in
! 148: ** sqlite3_backup_step(). The user is required to ensure that no
! 149: ** other thread accesses the destination handle for the duration
! 150: ** of the backup operation. Any attempt to use the destination
! 151: ** database connection while a backup is in progress may cause
! 152: ** a malfunction or a deadlock.
! 153: */
! 154: sqlite3_mutex_enter(pSrcDb->mutex);
! 155: sqlite3_mutex_enter(pDestDb->mutex);
! 156:
! 157: if( pSrcDb==pDestDb ){
! 158: sqlite3Error(
! 159: pDestDb, SQLITE_ERROR, "source and destination must be distinct"
! 160: );
! 161: p = 0;
! 162: }else {
! 163: /* Allocate space for a new sqlite3_backup object...
! 164: ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
! 165: ** call to sqlite3_backup_init() and is destroyed by a call to
! 166: ** sqlite3_backup_finish(). */
! 167: p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup));
! 168: if( !p ){
! 169: sqlite3Error(pDestDb, SQLITE_NOMEM, 0);
! 170: }
! 171: }
! 172:
! 173: /* If the allocation succeeded, populate the new object. */
! 174: if( p ){
! 175: memset(p, 0, sizeof(sqlite3_backup));
! 176: p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
! 177: p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
! 178: p->pDestDb = pDestDb;
! 179: p->pSrcDb = pSrcDb;
! 180: p->iNext = 1;
! 181: p->isAttached = 0;
! 182:
! 183: if( 0==p->pSrc || 0==p->pDest || setDestPgsz(p)==SQLITE_NOMEM ){
! 184: /* One (or both) of the named databases did not exist or an OOM
! 185: ** error was hit. The error has already been written into the
! 186: ** pDestDb handle. All that is left to do here is free the
! 187: ** sqlite3_backup structure.
! 188: */
! 189: sqlite3_free(p);
! 190: p = 0;
! 191: }
! 192: }
! 193: if( p ){
! 194: p->pSrc->nBackup++;
! 195: }
! 196:
! 197: sqlite3_mutex_leave(pDestDb->mutex);
! 198: sqlite3_mutex_leave(pSrcDb->mutex);
! 199: return p;
! 200: }
! 201:
! 202: /*
! 203: ** Argument rc is an SQLite error code. Return true if this error is
! 204: ** considered fatal if encountered during a backup operation. All errors
! 205: ** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED.
! 206: */
! 207: static int isFatalError(int rc){
! 208: return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
! 209: }
! 210:
! 211: /*
! 212: ** Parameter zSrcData points to a buffer containing the data for
! 213: ** page iSrcPg from the source database. Copy this data into the
! 214: ** destination database.
! 215: */
! 216: static int backupOnePage(sqlite3_backup *p, Pgno iSrcPg, const u8 *zSrcData){
! 217: Pager * const pDestPager = sqlite3BtreePager(p->pDest);
! 218: const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc);
! 219: int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest);
! 220: const int nCopy = MIN(nSrcPgsz, nDestPgsz);
! 221: const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz;
! 222: #ifdef SQLITE_HAS_CODEC
! 223: int nSrcReserve = sqlite3BtreeGetReserve(p->pSrc);
! 224: int nDestReserve = sqlite3BtreeGetReserve(p->pDest);
! 225: #endif
! 226:
! 227: int rc = SQLITE_OK;
! 228: i64 iOff;
! 229:
! 230: assert( p->bDestLocked );
! 231: assert( !isFatalError(p->rc) );
! 232: assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
! 233: assert( zSrcData );
! 234:
! 235: /* Catch the case where the destination is an in-memory database and the
! 236: ** page sizes of the source and destination differ.
! 237: */
! 238: if( nSrcPgsz!=nDestPgsz && sqlite3PagerIsMemdb(pDestPager) ){
! 239: rc = SQLITE_READONLY;
! 240: }
! 241:
! 242: #ifdef SQLITE_HAS_CODEC
! 243: /* Backup is not possible if the page size of the destination is changing
! 244: ** and a codec is in use.
! 245: */
! 246: if( nSrcPgsz!=nDestPgsz && sqlite3PagerGetCodec(pDestPager)!=0 ){
! 247: rc = SQLITE_READONLY;
! 248: }
! 249:
! 250: /* Backup is not possible if the number of bytes of reserve space differ
! 251: ** between source and destination. If there is a difference, try to
! 252: ** fix the destination to agree with the source. If that is not possible,
! 253: ** then the backup cannot proceed.
! 254: */
! 255: if( nSrcReserve!=nDestReserve ){
! 256: u32 newPgsz = nSrcPgsz;
! 257: rc = sqlite3PagerSetPagesize(pDestPager, &newPgsz, nSrcReserve);
! 258: if( rc==SQLITE_OK && newPgsz!=nSrcPgsz ) rc = SQLITE_READONLY;
! 259: }
! 260: #endif
! 261:
! 262: /* This loop runs once for each destination page spanned by the source
! 263: ** page. For each iteration, variable iOff is set to the byte offset
! 264: ** of the destination page.
! 265: */
! 266: for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
! 267: DbPage *pDestPg = 0;
! 268: Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
! 269: if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
! 270: if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg))
! 271: && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
! 272: ){
! 273: const u8 *zIn = &zSrcData[iOff%nSrcPgsz];
! 274: u8 *zDestData = sqlite3PagerGetData(pDestPg);
! 275: u8 *zOut = &zDestData[iOff%nDestPgsz];
! 276:
! 277: /* Copy the data from the source page into the destination page.
! 278: ** Then clear the Btree layer MemPage.isInit flag. Both this module
! 279: ** and the pager code use this trick (clearing the first byte
! 280: ** of the page 'extra' space to invalidate the Btree layers
! 281: ** cached parse of the page). MemPage.isInit is marked
! 282: ** "MUST BE FIRST" for this purpose.
! 283: */
! 284: memcpy(zOut, zIn, nCopy);
! 285: ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0;
! 286: }
! 287: sqlite3PagerUnref(pDestPg);
! 288: }
! 289:
! 290: return rc;
! 291: }
! 292:
! 293: /*
! 294: ** If pFile is currently larger than iSize bytes, then truncate it to
! 295: ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
! 296: ** this function is a no-op.
! 297: **
! 298: ** Return SQLITE_OK if everything is successful, or an SQLite error
! 299: ** code if an error occurs.
! 300: */
! 301: static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
! 302: i64 iCurrent;
! 303: int rc = sqlite3OsFileSize(pFile, &iCurrent);
! 304: if( rc==SQLITE_OK && iCurrent>iSize ){
! 305: rc = sqlite3OsTruncate(pFile, iSize);
! 306: }
! 307: return rc;
! 308: }
! 309:
! 310: /*
! 311: ** Register this backup object with the associated source pager for
! 312: ** callbacks when pages are changed or the cache invalidated.
! 313: */
! 314: static void attachBackupObject(sqlite3_backup *p){
! 315: sqlite3_backup **pp;
! 316: assert( sqlite3BtreeHoldsMutex(p->pSrc) );
! 317: pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
! 318: p->pNext = *pp;
! 319: *pp = p;
! 320: p->isAttached = 1;
! 321: }
! 322:
! 323: /*
! 324: ** Copy nPage pages from the source b-tree to the destination.
! 325: */
! 326: int sqlite3_backup_step(sqlite3_backup *p, int nPage){
! 327: int rc;
! 328: int destMode; /* Destination journal mode */
! 329: int pgszSrc = 0; /* Source page size */
! 330: int pgszDest = 0; /* Destination page size */
! 331:
! 332: sqlite3_mutex_enter(p->pSrcDb->mutex);
! 333: sqlite3BtreeEnter(p->pSrc);
! 334: if( p->pDestDb ){
! 335: sqlite3_mutex_enter(p->pDestDb->mutex);
! 336: }
! 337:
! 338: rc = p->rc;
! 339: if( !isFatalError(rc) ){
! 340: Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */
! 341: Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */
! 342: int ii; /* Iterator variable */
! 343: int nSrcPage = -1; /* Size of source db in pages */
! 344: int bCloseTrans = 0; /* True if src db requires unlocking */
! 345:
! 346: /* If the source pager is currently in a write-transaction, return
! 347: ** SQLITE_BUSY immediately.
! 348: */
! 349: if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
! 350: rc = SQLITE_BUSY;
! 351: }else{
! 352: rc = SQLITE_OK;
! 353: }
! 354:
! 355: /* Lock the destination database, if it is not locked already. */
! 356: if( SQLITE_OK==rc && p->bDestLocked==0
! 357: && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))
! 358: ){
! 359: p->bDestLocked = 1;
! 360: sqlite3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema);
! 361: }
! 362:
! 363: /* If there is no open read-transaction on the source database, open
! 364: ** one now. If a transaction is opened here, then it will be closed
! 365: ** before this function exits.
! 366: */
! 367: if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
! 368: rc = sqlite3BtreeBeginTrans(p->pSrc, 0);
! 369: bCloseTrans = 1;
! 370: }
! 371:
! 372: /* Do not allow backup if the destination database is in WAL mode
! 373: ** and the page sizes are different between source and destination */
! 374: pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
! 375: pgszDest = sqlite3BtreeGetPageSize(p->pDest);
! 376: destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
! 377: if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
! 378: rc = SQLITE_READONLY;
! 379: }
! 380:
! 381: /* Now that there is a read-lock on the source database, query the
! 382: ** source pager for the number of pages in the database.
! 383: */
! 384: nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
! 385: assert( nSrcPage>=0 );
! 386: for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
! 387: const Pgno iSrcPg = p->iNext; /* Source page number */
! 388: if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
! 389: DbPage *pSrcPg; /* Source page object */
! 390: rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
! 391: if( rc==SQLITE_OK ){
! 392: rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg));
! 393: sqlite3PagerUnref(pSrcPg);
! 394: }
! 395: }
! 396: p->iNext++;
! 397: }
! 398: if( rc==SQLITE_OK ){
! 399: p->nPagecount = nSrcPage;
! 400: p->nRemaining = nSrcPage+1-p->iNext;
! 401: if( p->iNext>(Pgno)nSrcPage ){
! 402: rc = SQLITE_DONE;
! 403: }else if( !p->isAttached ){
! 404: attachBackupObject(p);
! 405: }
! 406: }
! 407:
! 408: /* Update the schema version field in the destination database. This
! 409: ** is to make sure that the schema-version really does change in
! 410: ** the case where the source and destination databases have the
! 411: ** same schema version.
! 412: */
! 413: if( rc==SQLITE_DONE ){
! 414: rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
! 415: if( rc==SQLITE_OK ){
! 416: if( p->pDestDb ){
! 417: sqlite3ResetInternalSchema(p->pDestDb, -1);
! 418: }
! 419: if( destMode==PAGER_JOURNALMODE_WAL ){
! 420: rc = sqlite3BtreeSetVersion(p->pDest, 2);
! 421: }
! 422: }
! 423: if( rc==SQLITE_OK ){
! 424: int nDestTruncate;
! 425: /* Set nDestTruncate to the final number of pages in the destination
! 426: ** database. The complication here is that the destination page
! 427: ** size may be different to the source page size.
! 428: **
! 429: ** If the source page size is smaller than the destination page size,
! 430: ** round up. In this case the call to sqlite3OsTruncate() below will
! 431: ** fix the size of the file. However it is important to call
! 432: ** sqlite3PagerTruncateImage() here so that any pages in the
! 433: ** destination file that lie beyond the nDestTruncate page mark are
! 434: ** journalled by PagerCommitPhaseOne() before they are destroyed
! 435: ** by the file truncation.
! 436: */
! 437: assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
! 438: assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
! 439: if( pgszSrc<pgszDest ){
! 440: int ratio = pgszDest/pgszSrc;
! 441: nDestTruncate = (nSrcPage+ratio-1)/ratio;
! 442: if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
! 443: nDestTruncate--;
! 444: }
! 445: }else{
! 446: nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
! 447: }
! 448: sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
! 449:
! 450: if( pgszSrc<pgszDest ){
! 451: /* If the source page-size is smaller than the destination page-size,
! 452: ** two extra things may need to happen:
! 453: **
! 454: ** * The destination may need to be truncated, and
! 455: **
! 456: ** * Data stored on the pages immediately following the
! 457: ** pending-byte page in the source database may need to be
! 458: ** copied into the destination database.
! 459: */
! 460: const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
! 461: sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
! 462: i64 iOff;
! 463: i64 iEnd;
! 464:
! 465: assert( pFile );
! 466: assert( (i64)nDestTruncate*(i64)pgszDest >= iSize || (
! 467: nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
! 468: && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
! 469: ));
! 470:
! 471: /* This call ensures that all data required to recreate the original
! 472: ** database has been stored in the journal for pDestPager and the
! 473: ** journal synced to disk. So at this point we may safely modify
! 474: ** the database file in any way, knowing that if a power failure
! 475: ** occurs, the original database will be reconstructed from the
! 476: ** journal file. */
! 477: rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1);
! 478:
! 479: /* Write the extra pages and truncate the database file as required */
! 480: iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
! 481: for(
! 482: iOff=PENDING_BYTE+pgszSrc;
! 483: rc==SQLITE_OK && iOff<iEnd;
! 484: iOff+=pgszSrc
! 485: ){
! 486: PgHdr *pSrcPg = 0;
! 487: const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
! 488: rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
! 489: if( rc==SQLITE_OK ){
! 490: u8 *zData = sqlite3PagerGetData(pSrcPg);
! 491: rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
! 492: }
! 493: sqlite3PagerUnref(pSrcPg);
! 494: }
! 495: if( rc==SQLITE_OK ){
! 496: rc = backupTruncateFile(pFile, iSize);
! 497: }
! 498:
! 499: /* Sync the database file to disk. */
! 500: if( rc==SQLITE_OK ){
! 501: rc = sqlite3PagerSync(pDestPager);
! 502: }
! 503: }else{
! 504: rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0);
! 505: }
! 506:
! 507: /* Finish committing the transaction to the destination database. */
! 508: if( SQLITE_OK==rc
! 509: && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
! 510: ){
! 511: rc = SQLITE_DONE;
! 512: }
! 513: }
! 514: }
! 515:
! 516: /* If bCloseTrans is true, then this function opened a read transaction
! 517: ** on the source database. Close the read transaction here. There is
! 518: ** no need to check the return values of the btree methods here, as
! 519: ** "committing" a read-only transaction cannot fail.
! 520: */
! 521: if( bCloseTrans ){
! 522: TESTONLY( int rc2 );
! 523: TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
! 524: TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
! 525: assert( rc2==SQLITE_OK );
! 526: }
! 527:
! 528: if( rc==SQLITE_IOERR_NOMEM ){
! 529: rc = SQLITE_NOMEM;
! 530: }
! 531: p->rc = rc;
! 532: }
! 533: if( p->pDestDb ){
! 534: sqlite3_mutex_leave(p->pDestDb->mutex);
! 535: }
! 536: sqlite3BtreeLeave(p->pSrc);
! 537: sqlite3_mutex_leave(p->pSrcDb->mutex);
! 538: return rc;
! 539: }
! 540:
! 541: /*
! 542: ** Release all resources associated with an sqlite3_backup* handle.
! 543: */
! 544: int sqlite3_backup_finish(sqlite3_backup *p){
! 545: sqlite3_backup **pp; /* Ptr to head of pagers backup list */
! 546: MUTEX_LOGIC( sqlite3_mutex *mutex; ) /* Mutex to protect source database */
! 547: int rc; /* Value to return */
! 548:
! 549: /* Enter the mutexes */
! 550: if( p==0 ) return SQLITE_OK;
! 551: sqlite3_mutex_enter(p->pSrcDb->mutex);
! 552: sqlite3BtreeEnter(p->pSrc);
! 553: MUTEX_LOGIC( mutex = p->pSrcDb->mutex; )
! 554: if( p->pDestDb ){
! 555: sqlite3_mutex_enter(p->pDestDb->mutex);
! 556: }
! 557:
! 558: /* Detach this backup from the source pager. */
! 559: if( p->pDestDb ){
! 560: p->pSrc->nBackup--;
! 561: }
! 562: if( p->isAttached ){
! 563: pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
! 564: while( *pp!=p ){
! 565: pp = &(*pp)->pNext;
! 566: }
! 567: *pp = p->pNext;
! 568: }
! 569:
! 570: /* If a transaction is still open on the Btree, roll it back. */
! 571: sqlite3BtreeRollback(p->pDest);
! 572:
! 573: /* Set the error code of the destination database handle. */
! 574: rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
! 575: sqlite3Error(p->pDestDb, rc, 0);
! 576:
! 577: /* Exit the mutexes and free the backup context structure. */
! 578: if( p->pDestDb ){
! 579: sqlite3_mutex_leave(p->pDestDb->mutex);
! 580: }
! 581: sqlite3BtreeLeave(p->pSrc);
! 582: if( p->pDestDb ){
! 583: /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
! 584: ** call to sqlite3_backup_init() and is destroyed by a call to
! 585: ** sqlite3_backup_finish(). */
! 586: sqlite3_free(p);
! 587: }
! 588: sqlite3_mutex_leave(mutex);
! 589: return rc;
! 590: }
! 591:
! 592: /*
! 593: ** Return the number of pages still to be backed up as of the most recent
! 594: ** call to sqlite3_backup_step().
! 595: */
! 596: int sqlite3_backup_remaining(sqlite3_backup *p){
! 597: return p->nRemaining;
! 598: }
! 599:
! 600: /*
! 601: ** Return the total number of pages in the source database as of the most
! 602: ** recent call to sqlite3_backup_step().
! 603: */
! 604: int sqlite3_backup_pagecount(sqlite3_backup *p){
! 605: return p->nPagecount;
! 606: }
! 607:
! 608: /*
! 609: ** This function is called after the contents of page iPage of the
! 610: ** source database have been modified. If page iPage has already been
! 611: ** copied into the destination database, then the data written to the
! 612: ** destination is now invalidated. The destination copy of iPage needs
! 613: ** to be updated with the new data before the backup operation is
! 614: ** complete.
! 615: **
! 616: ** It is assumed that the mutex associated with the BtShared object
! 617: ** corresponding to the source database is held when this function is
! 618: ** called.
! 619: */
! 620: void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
! 621: sqlite3_backup *p; /* Iterator variable */
! 622: for(p=pBackup; p; p=p->pNext){
! 623: assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
! 624: if( !isFatalError(p->rc) && iPage<p->iNext ){
! 625: /* The backup process p has already copied page iPage. But now it
! 626: ** has been modified by a transaction on the source pager. Copy
! 627: ** the new data into the backup.
! 628: */
! 629: int rc;
! 630: assert( p->pDestDb );
! 631: sqlite3_mutex_enter(p->pDestDb->mutex);
! 632: rc = backupOnePage(p, iPage, aData);
! 633: sqlite3_mutex_leave(p->pDestDb->mutex);
! 634: assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );
! 635: if( rc!=SQLITE_OK ){
! 636: p->rc = rc;
! 637: }
! 638: }
! 639: }
! 640: }
! 641:
! 642: /*
! 643: ** Restart the backup process. This is called when the pager layer
! 644: ** detects that the database has been modified by an external database
! 645: ** connection. In this case there is no way of knowing which of the
! 646: ** pages that have been copied into the destination database are still
! 647: ** valid and which are not, so the entire process needs to be restarted.
! 648: **
! 649: ** It is assumed that the mutex associated with the BtShared object
! 650: ** corresponding to the source database is held when this function is
! 651: ** called.
! 652: */
! 653: void sqlite3BackupRestart(sqlite3_backup *pBackup){
! 654: sqlite3_backup *p; /* Iterator variable */
! 655: for(p=pBackup; p; p=p->pNext){
! 656: assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
! 657: p->iNext = 1;
! 658: }
! 659: }
! 660:
! 661: #ifndef SQLITE_OMIT_VACUUM
! 662: /*
! 663: ** Copy the complete content of pBtFrom into pBtTo. A transaction
! 664: ** must be active for both files.
! 665: **
! 666: ** The size of file pTo may be reduced by this operation. If anything
! 667: ** goes wrong, the transaction on pTo is rolled back. If successful, the
! 668: ** transaction is committed before returning.
! 669: */
! 670: int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
! 671: int rc;
! 672: sqlite3_file *pFd; /* File descriptor for database pTo */
! 673: sqlite3_backup b;
! 674: sqlite3BtreeEnter(pTo);
! 675: sqlite3BtreeEnter(pFrom);
! 676:
! 677: assert( sqlite3BtreeIsInTrans(pTo) );
! 678: pFd = sqlite3PagerFile(sqlite3BtreePager(pTo));
! 679: if( pFd->pMethods ){
! 680: i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
! 681: rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte);
! 682: if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
! 683: if( rc ) goto copy_finished;
! 684: }
! 685:
! 686: /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
! 687: ** to 0. This is used by the implementations of sqlite3_backup_step()
! 688: ** and sqlite3_backup_finish() to detect that they are being called
! 689: ** from this function, not directly by the user.
! 690: */
! 691: memset(&b, 0, sizeof(b));
! 692: b.pSrcDb = pFrom->db;
! 693: b.pSrc = pFrom;
! 694: b.pDest = pTo;
! 695: b.iNext = 1;
! 696:
! 697: /* 0x7FFFFFFF is the hard limit for the number of pages in a database
! 698: ** file. By passing this as the number of pages to copy to
! 699: ** sqlite3_backup_step(), we can guarantee that the copy finishes
! 700: ** within a single call (unless an error occurs). The assert() statement
! 701: ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
! 702: ** or an error code.
! 703: */
! 704: sqlite3_backup_step(&b, 0x7FFFFFFF);
! 705: assert( b.rc!=SQLITE_OK );
! 706: rc = sqlite3_backup_finish(&b);
! 707: if( rc==SQLITE_OK ){
! 708: pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
! 709: }else{
! 710: sqlite3PagerClearCache(sqlite3BtreePager(b.pDest));
! 711: }
! 712:
! 713: assert( sqlite3BtreeIsInTrans(pTo)==0 );
! 714: copy_finished:
! 715: sqlite3BtreeLeave(pFrom);
! 716: sqlite3BtreeLeave(pTo);
! 717: return rc;
! 718: }
! 719: #endif /* SQLITE_OMIT_VACUUM */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to backup.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src