Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Commit first version of the 'backup' feature. (CVS 6241) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
663479b417fc06ba1790a544f28694f8 |
User & Date: | danielk1977 2009-02-03 16:51:25.000 |
Context
2009-02-03
| ||
18:25 | Tweaks to the backup API documentation contained in comments. No changes to code. (CVS 6242) (check-in: 6298bcca14 user: drh tags: trunk) | |
16:51 | Commit first version of the 'backup' feature. (CVS 6241) (check-in: 663479b417 user: danielk1977 tags: trunk) | |
16:25 | Fix the sqlite3_mprintf_long test command (added by check-in (6224) in order to address ticket #3621) so that it works on systems with sizeof(int)==4 and sizeof(long)==8. (CVS 6240) (check-in: 2e45c2a851 user: drh tags: trunk) | |
Changes
Changes to Makefile.in.
︙ | ︙ | |||
191 192 193 194 195 196 197 198 199 200 201 202 203 204 | # All of the source code files. # SRC = \ $(TOP)/src/alter.c \ $(TOP)/src/analyze.c \ $(TOP)/src/attach.c \ $(TOP)/src/auth.c \ $(TOP)/src/bitvec.c \ $(TOP)/src/btmutex.c \ $(TOP)/src/btree.c \ $(TOP)/src/btree.h \ $(TOP)/src/btreeInt.h \ $(TOP)/src/build.c \ $(TOP)/src/callback.c \ | > | 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 | # All of the source code files. # SRC = \ $(TOP)/src/alter.c \ $(TOP)/src/analyze.c \ $(TOP)/src/attach.c \ $(TOP)/src/auth.c \ $(TOP)/src/backup.c \ $(TOP)/src/bitvec.c \ $(TOP)/src/btmutex.c \ $(TOP)/src/btree.c \ $(TOP)/src/btree.h \ $(TOP)/src/btreeInt.h \ $(TOP)/src/build.c \ $(TOP)/src/callback.c \ |
︙ | ︙ | |||
324 325 326 327 328 329 330 331 332 333 334 335 336 337 | $(TOP)/ext/rtree/rtree.h \ $(TOP)/ext/rtree/rtree.c # Source code to the library files needed by the test fixture # TESTSRC2 = \ $(TOP)/src/attach.c \ $(TOP)/src/bitvec.c \ $(TOP)/src/btree.c \ $(TOP)/src/build.c \ $(TOP)/src/date.c \ $(TOP)/src/expr.c \ $(TOP)/src/func.c \ $(TOP)/src/insert.c \ | > | 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 | $(TOP)/ext/rtree/rtree.h \ $(TOP)/ext/rtree/rtree.c # Source code to the library files needed by the test fixture # TESTSRC2 = \ $(TOP)/src/attach.c \ $(TOP)/src/backup.c \ $(TOP)/src/bitvec.c \ $(TOP)/src/btree.c \ $(TOP)/src/build.c \ $(TOP)/src/date.c \ $(TOP)/src/expr.c \ $(TOP)/src/func.c \ $(TOP)/src/insert.c \ |
︙ | ︙ | |||
368 369 370 371 372 373 374 375 376 377 378 379 380 381 | $(TOP)/src/test5.c \ $(TOP)/src/test6.c \ $(TOP)/src/test7.c \ $(TOP)/src/test8.c \ $(TOP)/src/test9.c \ $(TOP)/src/test_autoext.c \ $(TOP)/src/test_async.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ | > | 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 | $(TOP)/src/test5.c \ $(TOP)/src/test6.c \ $(TOP)/src/test7.c \ $(TOP)/src/test8.c \ $(TOP)/src/test9.c \ $(TOP)/src/test_autoext.c \ $(TOP)/src/test_async.c \ $(TOP)/src/test_backup.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ |
︙ | ︙ |
Changes to main.mk.
︙ | ︙ | |||
46 47 48 49 50 51 52 | # TCCX = $(TCC) $(OPTS) -I. -I$(TOP)/src -I$(TOP) TCCX += -I$(TOP)/ext/rtree -I$(TOP)/ext/icu -I$(TOP)/ext/fts3 # Object files for the SQLite library. # LIBOBJ+= alter.o analyze.o attach.o auth.o \ | | | 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | # TCCX = $(TCC) $(OPTS) -I. -I$(TOP)/src -I$(TOP) TCCX += -I$(TOP)/ext/rtree -I$(TOP)/ext/icu -I$(TOP)/ext/fts3 # Object files for the SQLite library. # LIBOBJ+= alter.o analyze.o attach.o auth.o \ backup.o bitvec.o btmutex.o btree.o build.o \ callback.o complete.o date.o delete.o expr.o fault.o \ fts3.o fts3_expr.o fts3_hash.o fts3_icu.o fts3_porter.o \ fts3_tokenizer.o fts3_tokenizer1.o \ func.o global.o hash.o \ icu.o insert.o journal.o legacy.o loadext.o \ main.o malloc.o mem0.o mem1.o mem2.o mem3.o mem5.o \ memjournal.o \ |
︙ | ︙ | |||
72 73 74 75 76 77 78 79 80 81 82 83 84 85 | # All of the source code files. # SRC = \ $(TOP)/src/alter.c \ $(TOP)/src/analyze.c \ $(TOP)/src/attach.c \ $(TOP)/src/auth.c \ $(TOP)/src/bitvec.c \ $(TOP)/src/btmutex.c \ $(TOP)/src/btree.c \ $(TOP)/src/btree.h \ $(TOP)/src/btreeInt.h \ $(TOP)/src/build.c \ $(TOP)/src/callback.c \ | > | 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | # All of the source code files. # SRC = \ $(TOP)/src/alter.c \ $(TOP)/src/analyze.c \ $(TOP)/src/attach.c \ $(TOP)/src/auth.c \ $(TOP)/src/backup.c \ $(TOP)/src/bitvec.c \ $(TOP)/src/btmutex.c \ $(TOP)/src/btree.c \ $(TOP)/src/btree.h \ $(TOP)/src/btreeInt.h \ $(TOP)/src/build.c \ $(TOP)/src/callback.c \ |
︙ | ︙ | |||
216 217 218 219 220 221 222 223 224 225 226 227 228 229 | $(TOP)/src/test5.c \ $(TOP)/src/test6.c \ $(TOP)/src/test7.c \ $(TOP)/src/test8.c \ $(TOP)/src/test9.c \ $(TOP)/src/test_autoext.c \ $(TOP)/src/test_async.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ | > | 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 | $(TOP)/src/test5.c \ $(TOP)/src/test6.c \ $(TOP)/src/test7.c \ $(TOP)/src/test8.c \ $(TOP)/src/test9.c \ $(TOP)/src/test_autoext.c \ $(TOP)/src/test_async.c \ $(TOP)/src/test_backup.c \ $(TOP)/src/test_btree.c \ $(TOP)/src/test_config.c \ $(TOP)/src/test_devsym.c \ $(TOP)/src/test_func.c \ $(TOP)/src/test_hexio.c \ $(TOP)/src/test_journal.c \ $(TOP)/src/test_malloc.c \ |
︙ | ︙ | |||
238 239 240 241 242 243 244 | $(TOP)/src/test_thread.c \ $(TOP)/src/test_wsd.c \ #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c #TESTSRC += $(TOP)/ext/fts3/fts3_tokenizer.c TESTSRC2 = \ | > | | 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 | $(TOP)/src/test_thread.c \ $(TOP)/src/test_wsd.c \ #TESTSRC += $(TOP)/ext/fts2/fts2_tokenizer.c #TESTSRC += $(TOP)/ext/fts3/fts3_tokenizer.c TESTSRC2 = \ $(TOP)/src/attach.c $(TOP)/src/backup.c $(TOP)/src/btree.c \ $(TOP)/src/build.c $(TOP)/src/date.c \ $(TOP)/src/expr.c $(TOP)/src/func.c $(TOP)/src/insert.c $(TOP)/src/os.c \ $(TOP)/src/os_os2.c $(TOP)/src/os_unix.c $(TOP)/src/os_win.c \ $(TOP)/src/pager.c $(TOP)/src/pragma.c $(TOP)/src/prepare.c \ $(TOP)/src/printf.c $(TOP)/src/random.c $(TOP)/src/pcache.c \ $(TOP)/src/pcache1.c $(TOP)/src/select.c $(TOP)/src/tokenize.c \ $(TOP)/src/utf.c $(TOP)/src/util.c $(TOP)/src/vdbeapi.c $(TOP)/src/vdbeaux.c \ $(TOP)/src/vdbe.c $(TOP)/src/vdbemem.c $(TOP)/src/where.c parse.c \ |
︙ | ︙ |
Changes to src/attach.c.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2003 April 6 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains code used to implement the ATTACH and DETACH commands. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2003 April 6 ** ** The author disclaims copyright to this source code. In place of ** a legal notice, here is a blessing: ** ** May you do good and not evil. ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** This file contains code used to implement the ATTACH and DETACH commands. ** ** $Id: attach.c,v 1.82 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" #ifndef SQLITE_OMIT_ATTACH /* ** Resolve an expression that was part of an ATTACH or DETACH statement. This ** is slightly different from resolving a normal SQL expression, because simple |
︙ | ︙ | |||
261 262 263 264 265 266 267 | goto detach_error; } if( !db->autoCommit ){ sqlite3_snprintf(sizeof(zErr), zErr, "cannot DETACH database within transaction"); goto detach_error; } | | | 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 | goto detach_error; } if( !db->autoCommit ){ sqlite3_snprintf(sizeof(zErr), zErr, "cannot DETACH database within transaction"); goto detach_error; } if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){ sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName); goto detach_error; } sqlite3BtreeClose(pDb->pBt); pDb->pBt = 0; pDb->pSchema = 0; |
︙ | ︙ |
Added src/backup.c.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 | /* ** 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. ** ** $Id: backup.c,v 1.1 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" #include "btreeInt.h" /* Macro to find the minimum of two numeric values. */ #ifndef MIN # define MIN(x,y) ((x)<(y)?(x):(y)) #endif /* ** Structure allocated for each backup operation. */ struct sqlite3_backup { sqlite3* pDestDb; /* Destination database handle */ Btree *pDest; /* Destination b-tree file */ u32 iDestSchema; /* Original schema cookie in destination */ int bDestLocked; /* True once a write-transaction is open on pDest */ Pgno iNext; /* Page number of the next source page to copy */ sqlite3* pSrcDb; /* Source database handle */ Btree *pSrc; /* Source b-tree file */ int rc; /* Backup process error code */ /* These two variables are set by every call to backup_step(). They are ** read by calls to backup_remaining() and backup_pagecount(). */ Pgno nRemaining; /* Number of pages left to copy */ Pgno nPagecount; /* Total number of pages to copy */ sqlite3_backup *pNext; /* Next backup associated with source pager */ }; /* ** THREAD SAFETY NOTES: ** ** Once it has been created using backup_init(), a single sqlite3_backup ** structure may be accessed via two groups of thread-safe entry points: ** ** * Via the sqlite3_backup_XXX() API function backup_step() and ** backup_finish(). Both these functions obtain the source database ** handle mutex and the mutex associated with the source BtShared ** structure, in that order. ** ** * Via the BackupUpdate() and BackupRestart() functions, which are ** invoked by the pager layer to report various state changes in ** the page cache associated with the source database. The mutex ** associated with the source database BtShared structure will always ** be held when either of these functions are invoked. ** ** The other sqlite3_backup_XXX() API functions, backup_remaining() and ** backup_pagecount() are not thread-safe functions. If they are called ** while some other thread is calling backup_step() or backup_finish(), ** the values returned may be invalid. There is no way for a call to ** BackupUpdate() or BackupRestart() to interfere with backup_remaining() ** or backup_pagecount(). ** ** Depending on the SQLite configuration, the database handles and/or ** the Btree objects may have their own mutexes that require locking. ** Non-sharable Btrees (in-memory databases for example), do not have ** associated mutexes. */ /* ** Return a pointer corresponding to database zDb (i.e. "main", "temp") ** in connection handle pDb. If such a database cannot be found, return ** a NULL pointer and write an error message to pErrorDb. ** ** If the "temp" database is requested, it may need to be opened by this ** function. If an error occurs while doing so, return 0 and write an ** error message to pErrorDb. */ static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){ int i = sqlite3FindDbName(pDb, zDb); if( i==1 ){ Parse sParse; memset(&sParse, 0, sizeof(sParse)); sParse.db = pDb; if( sqlite3OpenTempDatabase(&sParse) ){ sqlite3ErrorClear(&sParse); sqlite3Error(pErrorDb, sParse.rc, "%s", sParse.zErrMsg); return 0; } assert( sParse.zErrMsg==0 ); } if( i<0 ){ sqlite3Error(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb); return 0; } return pDb->aDb[i].pBt; } /* ** 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. */ sqlite3_backup *sqlite3_backup_init( sqlite3* pDestDb, /* Database to write to */ const char *zDestDb, /* Name of database within pDestDb */ sqlite3* pSrcDb, /* Database connection to read from */ const char *zSrcDb /* Name of database within pSrcDb */ ){ sqlite3_backup *p; /* Value to return */ /* Lock the source database handle. The destination database ** handle is not locked. The user is required to ensure that no ** other thread accesses the destination handle for the duration ** of the backup operation. */ sqlite3_mutex_enter(pSrcDb->mutex); if( pSrcDb==pDestDb ){ sqlite3Error( pDestDb, SQLITE_ERROR, "Source and destination handles must be distinct" ); p = 0; }else { /* Allocate space for a new sqlite3_backup object */ p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup)); if( !p ){ sqlite3Error(pDestDb, SQLITE_NOMEM, 0); } } /* If the allocation succeeded, populate the new object. */ if( p ){ 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; if( 0==p->pSrc || 0==p->pDest ){ /* One (or both) of the named databases did not exist. An error has ** already been written into the pDestDb handle. All that is left ** to do here is free the sqlite3_backup structure. */ sqlite3_free(p); p = 0; } } /* If everything has gone as planned, attach the backup object to the ** source pager. The source pager calls BackupUpdate() and BackupRestart() ** to notify this module if the source file is modified mid-backup. */ if( p ){ sqlite3_backup **pp; /* Pointer to head of pagers backup list */ sqlite3BtreeEnter(p->pSrc); pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); p->pNext = *pp; *pp = p; sqlite3BtreeLeave(p->pSrc); p->pSrc->nBackup++; } sqlite3_mutex_leave(pSrcDb->mutex); return p; } /* ** 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, const u8 *zSrcData){ Pager * const pDestPager = sqlite3BtreePager(p->pDest); const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc); int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest); const int nCopy = MIN(nSrcPgsz, nDestPgsz); const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz; int rc = SQLITE_OK; i64 iOff; assert( p->bDestLocked ); assert( p->rc==SQLITE_OK ); assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ); assert( zSrcData ); /* 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-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){ DbPage *pDestPg = 0; Pgno iDest = (Pgno)(iOff/nDestPgsz)+1; if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue; if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg)) && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg)) ){ const u8 *zIn = &zSrcData[iOff%nSrcPgsz]; u8 *zDestData = sqlite3PagerGetData(pDestPg); u8 *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. */ memcpy(zOut, zIn, nCopy); ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0; } sqlite3PagerUnref(pDestPg); } return rc; } /* ** Copy nPage pages from the source b-tree to the destination. */ int sqlite3_backup_step(sqlite3_backup *p, int nPage){ int rc; sqlite3_mutex_enter(p->pSrcDb->mutex); sqlite3BtreeEnter(p->pSrc); rc = p->rc; if( rc==SQLITE_OK ){ Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */ Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */ int ii; /* Iterator variable */ int nSrcPage; /* 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_LOCKED immediately. */ if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){ rc = SQLITE_LOCKED; } /* 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; rc = sqlite3BtreeGetMeta(p->pDest, 1, &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 && 0==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, &nSrcPage); } for(ii=0; ii<nPage && p->iNext<=nSrcPage && rc==SQLITE_OK; ii++){ const Pgno iSrcPg = p->iNext; /* Source page number */ if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){ DbPage *pSrcPg; /* Source page object */ rc = sqlite3PagerGet(pSrcPager, iSrcPg, &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; } } if( rc==SQLITE_DONE ){ const int nSrcPagesize = sqlite3BtreeGetPageSize(p->pSrc); const int nDestPagesize = sqlite3BtreeGetPageSize(p->pDest); int nDestTruncate; sqlite3_file *pFile = 0; i64 iSize; /* 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. */ sqlite3BtreeUpdateMeta(p->pDest, 1, p->iDestSchema+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. */ if( nSrcPagesize<nDestPagesize ){ int ratio = nDestPagesize/nSrcPagesize; nDestTruncate = (nSrcPage+ratio-1)/ratio; }else{ nDestTruncate = 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. */ iSize = (i64)nSrcPagesize * (i64)nSrcPage; pFile = sqlite3PagerFile(pDestPager); assert( pFile ); if( SQLITE_OK==(rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1)) && SQLITE_OK==(rc = sqlite3OsTruncate(pFile, iSize)) && SQLITE_OK==(rc = sqlite3PagerSync(pDestPager)) ){ i64 iOff; i64 iEnd = MIN(PENDING_BYTE + nDestPagesize, iSize); for( iOff=PENDING_BYTE+nSrcPagesize; rc==SQLITE_OK && iOff<iEnd; iOff+=nSrcPagesize ){ PgHdr *pSrcPg = 0; const Pgno iSrcPg = (iOff/nSrcPagesize)+1; rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg); if( rc==SQLITE_OK ){ u8 *zData = sqlite3PagerGetData(pSrcPg); rc = sqlite3OsWrite(pFile, zData, nSrcPagesize, iOff); } sqlite3PagerUnref(pSrcPg); } } }else{ rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0); } /* 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 ){ TESTONLY( int rc2 ); TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0); TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc); assert( rc2==SQLITE_OK ); } if( rc!=SQLITE_LOCKED && rc!=SQLITE_BUSY ){ p->rc = rc; } } sqlite3BtreeLeave(p->pSrc); sqlite3_mutex_leave(p->pSrcDb->mutex); return rc; } /* ** Release all resources associated with an sqlite3_backup* handle. */ 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 */ sqlite3_mutex_enter(p->pSrcDb->mutex); sqlite3BtreeEnter(p->pSrc); mutex = p->pSrcDb->mutex; /* Detach this backup from the source pager. */ if( p->pDestDb ){ pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); while( *pp!=p ){ pp = &(*pp)->pNext; } *pp = p->pNext; p->pSrc->nBackup--; } /* 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. */ sqlite3BtreeLeave(p->pSrc); if( p->pDestDb ){ sqlite3_free(p); } sqlite3_mutex_leave(mutex); return rc; } /* ** Return the number of pages still to be backed up as of the most recent ** call to sqlite3_backup_step(). */ int sqlite3_backup_remaining(sqlite3_backup *p){ return p->nRemaining; } /* ** Return the total number of pages in the source database as of the most ** recent call to sqlite3_backup_step(). */ int sqlite3_backup_pagecount(sqlite3_backup *p){ return p->nPagecount; } /* ** 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. */ void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){ sqlite3_backup *p; /* Iterator variable */ for(p=pBackup; p; p=p->pNext){ assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); if( p->rc==SQLITE_OK && 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); if( rc!=SQLITE_OK ){ p->rc = rc; } } } } /* ** 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. */ void sqlite3BackupRestart(sqlite3_backup *pBackup){ sqlite3_backup *p; /* Iterator variable */ for(p=pBackup; p; p=p->pNext){ assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); p->iNext = 1; } } #ifndef SQLITE_OMIT_VACUUM /* ** 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. */ 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. */ 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 assert() statement ** checks this assumption - (p->rc) should be set to either SQLITE_DONE ** or an error code. */ sqlite3_backup_step(&b, 0x7FFFFFFF); assert( b.rc!=SQLITE_OK ); rc = sqlite3_backup_finish(&b); if( rc==SQLITE_OK ){ pTo->pBt->pageSizeFixed = 0; } sqlite3BtreeLeave(pFrom); sqlite3BtreeLeave(pTo); return rc; } #endif /* SQLITE_OMIT_VACUUM */ |
Changes to src/btree.c.
1 2 3 4 5 6 7 8 9 10 11 | /* ** 2004 April 6 ** ** 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. ** ************************************************************************* | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | /* ** 2004 April 6 ** ** 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. ** ************************************************************************* ** $Id: btree.c,v 1.564 2009/02/03 16:51:25 danielk1977 Exp $ ** ** This file implements a external (disk-based) database using BTrees. ** See the header comment on "btreeInt.h" for additional information. ** Including a description of file format and an overview of operation. */ #include "btreeInt.h" |
︙ | ︙ | |||
7235 7236 7237 7238 7239 7240 7241 | ** open so it is safe to access without the BtShared mutex. */ const char *sqlite3BtreeGetJournalname(Btree *p){ assert( p->pBt->pPager!=0 ); return sqlite3PagerJournalname(p->pBt->pPager); } | < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < | 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 | ** open so it is safe to access without the BtShared mutex. */ const char *sqlite3BtreeGetJournalname(Btree *p){ assert( p->pBt->pPager!=0 ); return sqlite3PagerJournalname(p->pBt->pPager); } /* ** Return non-zero if a transaction is active. */ int sqlite3BtreeIsInTrans(Btree *p){ assert( p==0 || sqlite3_mutex_held(p->db->mutex) ); return (p && (p->inTrans==TRANS_WRITE)); } |
︙ | ︙ | |||
7478 7479 7480 7481 7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 | ** Return non-zero if a read (or write) transaction is active. */ int sqlite3BtreeIsInReadTrans(Btree *p){ assert( p ); assert( sqlite3_mutex_held(p->db->mutex) ); return p->inTrans!=TRANS_NONE; } /* ** This function returns a pointer to a blob of memory associated with ** a single shared-btree. The memory is used by client code for its own ** purposes (for example, to store a high-level schema associated with ** the shared-btree). The btree layer manages reference counting issues. ** | > > > > > > | 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 | ** Return non-zero if a read (or write) transaction is active. */ int sqlite3BtreeIsInReadTrans(Btree *p){ assert( p ); assert( sqlite3_mutex_held(p->db->mutex) ); return p->inTrans!=TRANS_NONE; } int sqlite3BtreeIsInBackup(Btree *p){ assert( p ); assert( sqlite3_mutex_held(p->db->mutex) ); return p->nBackup!=0; } /* ** This function returns a pointer to a blob of memory associated with ** a single shared-btree. The memory is used by client code for its own ** purposes (for example, to store a high-level schema associated with ** the shared-btree). The btree layer manages reference counting issues. ** |
︙ | ︙ |
Changes to src/btree.h.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the sqlite B-Tree file ** subsystem. See comments in the source code for a detailed description ** of what each interface routine does. ** | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the sqlite B-Tree file ** subsystem. See comments in the source code for a detailed description ** of what each interface routine does. ** ** @(#) $Id: btree.h,v 1.108 2009/02/03 16:51:25 danielk1977 Exp $ */ #ifndef _BTREE_H_ #define _BTREE_H_ /* TODO: This definition is just included so other modules compile. It ** needs to be revisited. */ |
︙ | ︙ | |||
94 95 96 97 98 99 100 101 102 103 104 105 106 107 | int sqlite3BtreeBeginStmt(Btree*); int sqlite3BtreeCommitStmt(Btree*); int sqlite3BtreeRollbackStmt(Btree*); int sqlite3BtreeCreateTable(Btree*, int*, int flags); int sqlite3BtreeIsInTrans(Btree*); int sqlite3BtreeIsInStmt(Btree*); int sqlite3BtreeIsInReadTrans(Btree*); void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); int sqlite3BtreeSchemaLocked(Btree *); int sqlite3BtreeLockTable(Btree *, int, u8); int sqlite3BtreeSavepoint(Btree *, int, int); const char *sqlite3BtreeGetFilename(Btree *); const char *sqlite3BtreeGetJournalname(Btree *); | > | 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 | int sqlite3BtreeBeginStmt(Btree*); int sqlite3BtreeCommitStmt(Btree*); int sqlite3BtreeRollbackStmt(Btree*); int sqlite3BtreeCreateTable(Btree*, int*, int flags); int sqlite3BtreeIsInTrans(Btree*); int sqlite3BtreeIsInStmt(Btree*); int sqlite3BtreeIsInReadTrans(Btree*); int sqlite3BtreeIsInBackup(Btree*); void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); int sqlite3BtreeSchemaLocked(Btree *); int sqlite3BtreeLockTable(Btree *, int, u8); int sqlite3BtreeSavepoint(Btree *, int, int); const char *sqlite3BtreeGetFilename(Btree *); const char *sqlite3BtreeGetJournalname(Btree *); |
︙ | ︙ |
Changes to src/btreeInt.h.
1 2 3 4 5 6 7 8 9 10 11 | /* ** 2004 April 6 ** ** 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. ** ************************************************************************* | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | /* ** 2004 April 6 ** ** 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. ** ************************************************************************* ** $Id: btreeInt.h,v 1.42 2009/02/03 16:51:25 danielk1977 Exp $ ** ** This file implements a external (disk-based) database using BTrees. ** For a detailed discussion of BTrees, refer to ** ** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: ** "Sorting And Searching", pages 473-480. Addison-Wesley ** Publishing Company, Reading, Massachusetts. |
︙ | ︙ | |||
320 321 322 323 324 325 326 327 328 329 330 331 332 333 | struct Btree { sqlite3 *db; /* The database connection holding this btree */ BtShared *pBt; /* Sharable content of this btree */ u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ u8 sharable; /* True if we can share pBt with another db */ u8 locked; /* True if db currently has pBt locked */ int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ Btree *pNext; /* List of other sharable Btrees from the same db */ Btree *pPrev; /* Back pointer of the same list */ }; /* ** Btree.inTrans may take one of the following values. ** | > | 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 | struct Btree { sqlite3 *db; /* The database connection holding this btree */ BtShared *pBt; /* Sharable content of this btree */ u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */ u8 sharable; /* True if we can share pBt with another db */ u8 locked; /* True if db currently has pBt locked */ int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */ int nBackup; /* Number of backup operations reading this btree */ Btree *pNext; /* List of other sharable Btrees from the same db */ Btree *pPrev; /* Back pointer of the same list */ }; /* ** Btree.inTrans may take one of the following values. ** |
︙ | ︙ |
Changes to src/build.c.
︙ | ︙ | |||
18 19 20 21 22 23 24 | ** CREATE INDEX ** DROP INDEX ** creating ID lists ** BEGIN TRANSACTION ** COMMIT ** ROLLBACK ** | | | 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 | ** CREATE INDEX ** DROP INDEX ** creating ID lists ** BEGIN TRANSACTION ** COMMIT ** ROLLBACK ** ** $Id: build.c,v 1.515 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" /* ** This routine is called when a new SQL statement is beginning to ** be parsed. Initialize the pParse structure as needed. */ |
︙ | ︙ | |||
617 618 619 620 621 622 623 | Vdbe *v = sqlite3GetVdbe(p); sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb)); sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, 5);/* sqlite_master has 5 columns */ sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb); } /* | | | | | | | < < < < < > | < > > > > > > > > > > > > > > > | 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 | Vdbe *v = sqlite3GetVdbe(p); sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb)); sqlite3VdbeAddOp2(v, OP_SetNumColumns, 0, 5);/* sqlite_master has 5 columns */ sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb); } /* ** Parameter zName points to a nul-terminated buffer containing the name ** of a database ("main", "temp" or the name of an attached db). This ** function returns the index of the named database in db->aDb[], or ** -1 if the named db cannot be found. */ int sqlite3FindDbName(sqlite3 *db, const char *zName){ int i = -1; /* Database number */ if( zName ){ Db *pDb; int n = sqlite3Strlen30(zName); for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){ if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) && 0==sqlite3StrICmp(pDb->zName, zName) ){ break; } } } return i; } /* ** The token *pName contains the name of a database (either "main" or ** "temp" or the name of an attached db). This routine returns the ** index of the named database in db->aDb[], or -1 if the named db ** does not exist. */ int sqlite3FindDb(sqlite3 *db, Token *pName){ int i; /* Database number */ char *zName; /* Name we are searching for */ zName = sqlite3NameFromToken(db, pName); i = sqlite3FindDbName(db, zName); sqlite3DbFree(db, zName); return i; } /* The table or view or trigger name is passed to this routine via tokens ** pName1 and pName2. If the table name was fully qualified, for example: ** ** CREATE TABLE xxx.yyy (...); ** ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if |
︙ | ︙ |
Changes to src/main.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** Main file for the SQLite library. The routines in this file ** implement the programmer interface to the library. Routines in ** other files are for internal use by SQLite and should not be ** accessed by users of the library. ** ** $Id: main.c,v 1.525 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" #ifdef SQLITE_ENABLE_FTS3 # include "fts3.h" #endif #ifdef SQLITE_ENABLE_RTREE |
︙ | ︙ | |||
598 599 600 601 602 603 604 605 606 607 608 609 610 611 | if( db->pVdbe ){ sqlite3Error(db, SQLITE_BUSY, "Unable to close due to unfinalised statements"); sqlite3_mutex_leave(db->mutex); return SQLITE_BUSY; } assert( sqlite3SafetyCheckSickOrOk(db) ); /* Free any outstanding Savepoint structures. */ sqlite3CloseSavepoints(db); for(j=0; j<db->nDb; j++){ struct Db *pDb = &db->aDb[j]; if( pDb->pBt ){ | > > > > > > > > > > | 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 | if( db->pVdbe ){ sqlite3Error(db, SQLITE_BUSY, "Unable to close due to unfinalised statements"); sqlite3_mutex_leave(db->mutex); return SQLITE_BUSY; } assert( sqlite3SafetyCheckSickOrOk(db) ); for(j=0; j<db->nDb; j++){ Btree *pBt = db->aDb[j].pBt; if( pBt && sqlite3BtreeIsInBackup(pBt) ){ sqlite3Error(db, SQLITE_BUSY, "Unable to close due to unfinished backup operation"); sqlite3_mutex_leave(db->mutex); return SQLITE_BUSY; } } /* Free any outstanding Savepoint structures. */ sqlite3CloseSavepoints(db); for(j=0; j<db->nDb; j++){ struct Db *pDb = &db->aDb[j]; if( pDb->pBt ){ |
︙ | ︙ |
Changes to src/pager.c.
︙ | ︙ | |||
14 15 16 17 18 19 20 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** | | | 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | ** The pager is used to access a database disk file. It implements ** atomic commit and rollback through the use of a journal file that ** is separate from the database file. The pager also implements file ** locking to prevent two processes from writing the same database ** file simultaneously, or one process from reading the database while ** another is writing. ** ** @(#) $Id: pager.c,v 1.562 2009/02/03 16:51:25 danielk1977 Exp $ */ #ifndef SQLITE_OMIT_DISKIO #include "sqliteInt.h" /* ** Macros for troubleshooting. Normally turned off */ |
︙ | ︙ | |||
302 303 304 305 306 307 308 309 310 311 312 313 314 315 | #ifdef SQLITE_HAS_CODEC void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ void *pCodecArg; /* First argument to xCodec() */ #endif char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ i64 journalSizeLimit; /* Size limit for persistent journal files */ PCache *pPCache; /* Pointer to page cache object */ }; /* ** The following global variables hold counters used for ** testing purposes only. These variables do not exist in ** a non-testing build. These variables are not thread-safe. */ | > | 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 | #ifdef SQLITE_HAS_CODEC void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ void *pCodecArg; /* First argument to xCodec() */ #endif char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */ i64 journalSizeLimit; /* Size limit for persistent journal files */ PCache *pPCache; /* Pointer to page cache object */ sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */ }; /* ** The following global variables hold counters used for ** testing purposes only. These variables do not exist in ** a non-testing build. These variables are not thread-safe. */ |
︙ | ︙ | |||
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 | (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p); return p; } /* ** Unless the pager is in error-state, discard all in-memory pages. If ** the pager is in error-state, then this call is a no-op. */ static void pager_reset(Pager *pPager){ if( SQLITE_OK==pPager->errCode ){ sqlite3PcacheClear(pPager->pPCache); } } /* ** Free all structures in the Pager.aSavepoint[] array and set both ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal | > > > | 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 | (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p); return p; } /* ** Unless the pager is in error-state, discard all in-memory pages. If ** the pager is in error-state, then this call is a no-op. ** ** TODO: Why can we not reset the pager while in error state? */ static void pager_reset(Pager *pPager){ if( SQLITE_OK==pPager->errCode ){ sqlite3BackupRestart(pPager->pBackup); sqlite3PcacheClear(pPager->pPCache); } } /* ** Free all structures in the Pager.aSavepoint[] array and set both ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal |
︙ | ︙ | |||
1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 | && isOpen(pPager->fd) ){ i64 ofst = (pgno-1)*(i64)pPager->pageSize; rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, ofst); if( pgno>pPager->dbFileSize ){ pPager->dbFileSize = pgno; } }else if( !isMainJrnl && pPg==0 ){ /* If this is a rollback of a savepoint and data was not written to ** the database and the page is not in-memory, there is a potential ** problem. When the page is next fetched by the b-tree layer, it ** will be read from the database file, which may or may not be ** current. ** | > | 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 | && isOpen(pPager->fd) ){ i64 ofst = (pgno-1)*(i64)pPager->pageSize; rc = sqlite3OsWrite(pPager->fd, aData, pPager->pageSize, ofst); if( pgno>pPager->dbFileSize ){ pPager->dbFileSize = pgno; } sqlite3BackupUpdate(pPager->pBackup, pgno, aData); }else if( !isMainJrnl && pPg==0 ){ /* If this is a rollback of a savepoint and data was not written to ** the database and the page is not in-memory, there is a potential ** problem. When the page is next fetched by the b-tree layer, it ** will be read from the database file, which may or may not be ** current. ** |
︙ | ︙ | |||
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 | if( pgno==1 ){ memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); } if( pgno>pPager->dbFileSize ){ pPager->dbFileSize = pgno; } PAGERTRACE(("STORE %d page %d hash(%08x)\n", PAGERID(pPager), pgno, pager_pagehash(pList))); IOTRACE(("PGOUT %p %d\n", pPager, pgno)); PAGER_INCR(sqlite3_pager_writedb_count); PAGER_INCR(pPager->nWrite); }else{ PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno)); | > > > | 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 | if( pgno==1 ){ memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers)); } if( pgno>pPager->dbFileSize ){ pPager->dbFileSize = pgno; } /* Update any backup objects copying the contents of this pager. */ sqlite3BackupUpdate(pPager->pBackup, pgno, (u8 *)pData); PAGERTRACE(("STORE %d page %d hash(%08x)\n", PAGERID(pPager), pgno, pager_pagehash(pList))); IOTRACE(("PGOUT %p %d\n", pPager, pgno)); PAGER_INCR(sqlite3_pager_writedb_count); PAGER_INCR(pPager->nWrite); }else{ PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno)); |
︙ | ︙ | |||
3545 3546 3547 3548 3549 3550 3551 | pPager->journalHdr = 0; /* Playback and delete the journal. Drop the database write ** lock and reacquire the read lock. Purge the cache before ** playing back the hot-journal so that we don't end up with ** an inconsistent cache. */ | | | 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 | pPager->journalHdr = 0; /* Playback and delete the journal. Drop the database write ** lock and reacquire the read lock. Purge the cache before ** playing back the hot-journal so that we don't end up with ** an inconsistent cache. */ pager_reset(pPager); rc = pager_playback(pPager, 1); if( rc!=SQLITE_OK ){ rc = pager_error(pPager, rc); goto failed; } assert( (pPager->state==PAGER_SHARED) || (pPager->exclusiveMode && pPager->state>PAGER_SHARED) |
︙ | ︙ | |||
4432 4433 4434 4435 4436 4437 4438 | PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n", pPager->zFilename, zMaster, pPager->dbSize)); /* If this is an in-memory db, or no pages have been written to, or this ** function has already been called, it is a no-op. */ | | > > | 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 | PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n", pPager->zFilename, zMaster, pPager->dbSize)); /* If this is an in-memory db, or no pages have been written to, or this ** function has already been called, it is a no-op. */ if( MEMDB && pPager->dbModified ){ sqlite3BackupRestart(pPager->pBackup); }else if( pPager->state!=PAGER_SYNCED && pPager->dbModified ){ /* The following block updates the change-counter. Exactly how it ** does this depends on whether or not the atomic-update optimization ** was enabled at compile time, and if this transaction meets the ** runtime criteria to use the operation: ** ** * The file-system supports the atomic-write property for |
︙ | ︙ | |||
4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 | a[6] = pPager->nHit; a[7] = pPager->nMiss; a[8] = 0; /* Used to be pPager->nOvfl */ a[9] = pPager->nRead; a[10] = pPager->nWrite; return a; } int sqlite3PagerIsMemdb(Pager *pPager){ return MEMDB; } | > > > > > < | 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 | a[6] = pPager->nHit; a[7] = pPager->nMiss; a[8] = 0; /* Used to be pPager->nOvfl */ a[9] = pPager->nRead; a[10] = pPager->nWrite; return a; } #endif /* ** Return true if this is an in-memory pager. */ int sqlite3PagerIsMemdb(Pager *pPager){ return MEMDB; } /* ** Check that there are at least nSavepoint savepoints open. If there are ** currently less than nSavepoints open, then open one or more savepoints ** to make up the difference. If the number of savepoints is already ** equal to nSavepoint, then this function is a no-op. ** |
︙ | ︙ | |||
5147 5148 5149 5150 5151 5152 5153 5154 5155 | */ i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){ if( iLimit>=-1 ){ pPager->journalSizeLimit = iLimit; } return pPager->journalSizeLimit; } #endif /* SQLITE_OMIT_DISKIO */ | > > > > > > > > > > | 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 | */ i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){ if( iLimit>=-1 ){ pPager->journalSizeLimit = iLimit; } return pPager->journalSizeLimit; } /* ** Return a pointer to the pPager->pBackup variable. The backup module ** in backup.c maintains the content of this variable. This module ** uses it opaquely as an argument to sqlite3BackupRestart() and ** sqlite3BackupUpdate() only. */ sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){ return &pPager->pBackup; } #endif /* SQLITE_OMIT_DISKIO */ |
Changes to src/pager.h.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the sqlite page cache ** subsystem. The page cache subsystem reads and writes a file a page ** at a time and provides a journal for rollback. ** | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** This header file defines the interface that the sqlite page cache ** subsystem. The page cache subsystem reads and writes a file a page ** at a time and provides a journal for rollback. ** ** @(#) $Id: pager.h,v 1.100 2009/02/03 16:51:25 danielk1977 Exp $ */ #ifndef _PAGER_H_ #define _PAGER_H_ /* ** Default maximum size for persistent journal files. A negative |
︙ | ︙ | |||
96 97 98 99 100 101 102 103 104 105 106 107 108 109 | int sqlite3PagerSetPagesize(Pager*, u16*); int sqlite3PagerMaxPageCount(Pager*, int); void sqlite3PagerSetCachesize(Pager*, int); void sqlite3PagerSetSafetyLevel(Pager*,int,int); int sqlite3PagerLockingMode(Pager *, int); int sqlite3PagerJournalMode(Pager *, int); i64 sqlite3PagerJournalSizeLimit(Pager *, i64); /* Functions used to obtain and release page references. */ int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); #define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); void sqlite3PagerRef(DbPage*); void sqlite3PagerUnref(DbPage*); | > | 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | int sqlite3PagerSetPagesize(Pager*, u16*); int sqlite3PagerMaxPageCount(Pager*, int); void sqlite3PagerSetCachesize(Pager*, int); void sqlite3PagerSetSafetyLevel(Pager*,int,int); int sqlite3PagerLockingMode(Pager *, int); int sqlite3PagerJournalMode(Pager *, int); i64 sqlite3PagerJournalSizeLimit(Pager *, i64); sqlite3_backup **sqlite3PagerBackupPtr(Pager*); /* Functions used to obtain and release page references. */ int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag); #define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0) DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno); void sqlite3PagerRef(DbPage*); void sqlite3PagerUnref(DbPage*); |
︙ | ︙ | |||
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 | int sqlite3PagerRefcount(Pager*); const char *sqlite3PagerFilename(Pager*); const sqlite3_vfs *sqlite3PagerVfs(Pager*); sqlite3_file *sqlite3PagerFile(Pager*); const char *sqlite3PagerJournalname(Pager*); int sqlite3PagerNosync(Pager*); void *sqlite3PagerTempSpace(Pager*); /* Functions used to truncate the database file. */ void sqlite3PagerTruncateImage(Pager*,Pgno); /* Used by encryption extensions. */ #ifdef SQLITE_HAS_CODEC void sqlite3PagerSetCodec(Pager*,void*(*)(void*,void*,Pgno,int),void*); #endif /* Functions to support testing and debugging. */ #if !defined(NDEBUG) || defined(SQLITE_TEST) Pgno sqlite3PagerPagenumber(DbPage*); int sqlite3PagerIswriteable(DbPage*); #endif #ifdef SQLITE_TEST int *sqlite3PagerStats(Pager*); void sqlite3PagerRefdump(Pager*); | > < | 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | int sqlite3PagerRefcount(Pager*); const char *sqlite3PagerFilename(Pager*); const sqlite3_vfs *sqlite3PagerVfs(Pager*); sqlite3_file *sqlite3PagerFile(Pager*); const char *sqlite3PagerJournalname(Pager*); int sqlite3PagerNosync(Pager*); void *sqlite3PagerTempSpace(Pager*); int sqlite3PagerIsMemdb(Pager*); /* Functions used to truncate the database file. */ void sqlite3PagerTruncateImage(Pager*,Pgno); /* Used by encryption extensions. */ #ifdef SQLITE_HAS_CODEC void sqlite3PagerSetCodec(Pager*,void*(*)(void*,void*,Pgno,int),void*); #endif /* Functions to support testing and debugging. */ #if !defined(NDEBUG) || defined(SQLITE_TEST) Pgno sqlite3PagerPagenumber(DbPage*); int sqlite3PagerIswriteable(DbPage*); #endif #ifdef SQLITE_TEST int *sqlite3PagerStats(Pager*); void sqlite3PagerRefdump(Pager*); void disable_simulated_io_errors(void); void enable_simulated_io_errors(void); #else # define disable_simulated_io_errors() # define enable_simulated_io_errors() #endif #endif /* _PAGER_H_ */ |
Changes to src/sqlite.h.in.
︙ | ︙ | |||
26 27 28 29 30 31 32 | ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** | | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** ** @(#) $Id: sqlite.h.in,v 1.423 2009/02/03 16:51:25 danielk1977 Exp $ */ #ifndef _SQLITE3_H_ #define _SQLITE3_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. |
︙ | ︙ | |||
6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 | void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); void (*xUnpin)(sqlite3_pcache*, void*, int discard); void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); void (*xDestroy)(sqlite3_pcache*); }; /* ** Undo the hack that converts floating point types to integer for ** builds on processors without floating point support. */ #ifdef SQLITE_OMIT_FLOATING_POINT # undef double #endif #ifdef __cplusplus } /* End of the 'extern "C"' block */ #endif #endif | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744 6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 | void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag); void (*xUnpin)(sqlite3_pcache*, void*, int discard); void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey); void (*xTruncate)(sqlite3_pcache*, unsigned iLimit); void (*xDestroy)(sqlite3_pcache*); }; /* ** CAPI3REF: Online Backup API. ** EXPERIMENTAL ** ** This API is used to overwrite the contents of one database with that ** of another. It is useful either for creating backups of databases or ** for copying in-memory databases to or from persistent files. ** ** Exclusive access is required to the destination database for the ** duration of the operation. However the source database is only ** read-locked while it is actually being read, it is not locked ** continuously for the entire operation. Thus, the backup may be ** performed on a live database without preventing other users from ** writing to the database for an extended period of time. ** ** To perform a backup operation: ** <ol> ** <li>[sqlite3_backup_init()] is called once to initialize the backup, ** <li>[sqlite3_backup_step()] is called one or more times to transfer ** the data between the two databases, and finally ** <li>[sqlite3_backup_finish()] is called to release all resources ** associated with the backup operation. ** </ol> ** There should be exactly one call to sqlite3_backup_finish() for each ** successful call to sqlite3_backup_init(). ** ** <b>sqlite3_backup_init()</b> ** ** The first two arguments passed to [sqlite3_backup_init()] are the database ** handle associated with the destination database and the database name ** used to attach the destination database to the handle. The database name ** is "main" for the main database, "temp" for the temporary database, or ** the name specified as part of the ATTACH statement if the destination is ** an attached database. The third and fourth arguments passed to ** sqlite3_backup_init() identify the database handle and database name used ** to access the source database. The values passed for the source and ** destination database handle parameters must not be the same. ** ** If an error occurs within sqlite3_backup_init(), then NULL is returned ** and an error code and error message written into the database handle ** passed as the first argument. They may be retrieved using the ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16() functions. ** Otherwise, if successful, an opaque handle of type sqlite3_backup* is ** returned. This handle may be used with the sqlite3_backup_step() and ** sqlite3_backup_finish() functions to perform the specified backup ** operation. ** ** <b>sqlite3_backup_step()</b> ** ** Function [sqlite3_backup_step()] is used to copy up to nPage pages between ** the source and destination databases, where nPage is the value of the ** second parameter passed to sqlite3_backup_step(). If nPage pages are ** succesfully copied, but there are still more pages to copy before the ** backup is complete, it returns SQLITE_OK. If no error occured and there ** are no more pages to copy, then SQLITE_DONE is returned. If an error ** occurs, then an SQLite error code is returned. As well as SQLITE_OK and ** SQLITE_DONE, a call to sqlite3_backup_step() may return SQLITE_READONLY, ** SQLITE_NOMEM, SQLITE_BUSY, SQLITE_LOCKED or an SQLITE_IOERR_XXX error code. ** ** As well as the case where the destination database file was opened for ** read-only access, sqlite3_backup_step() may return SQLITE_READONLY if ** the destination is an in-memory database with a different page size ** from the source database. ** ** If sqlite3_backup_step() cannot obtain a required file-system lock, then ** the busy-handler function is invoked (if one is specified). If the ** busy-handler returns non-zero before the lock is available, then ** SQLITE_BUSY is returned to the caller. In this case the call to ** sqlite3_backup_step() can be retried later. If the source database handle ** is being used to write to the source database when sqlite3_backup_step() ** is called, then SQLITE_LOCKED is returned immediately. Again, in this ** case the call to sqlite3_backup_step() can be retried later on. If ** SQLITE_IOERR_XXX, SQLITE_NOMEM or SQLITE_READONLY is returned, then ** there is no point in retrying the call to sqlite3_backup_step(). These ** errors are considered fatal. At this point the application must accept ** that the backup operation has failed and pass the backup operation handle ** to the sqlite3_backup_finish() to release associated resources. ** ** Following the first call to sqlite3_backup_step(), an exclusive lock is ** obtained on the destination file. It is not released until either ** sqlite3_backup_finish() is called or the backup operation is complete ** and sqlite3_backup_step() returns SQLITE_DONE. Additionally, each time ** a call to sqlite3_backup_step() is made a shared lock is obtained on ** the source database file. This lock is released before the ** sqlite3_backup_step() call returns. Because the source database is not ** locked between calls to sqlite3_backup_step(), it may be modified mid-way ** through the backup procedure. If the source database is modified by an ** external process or via a database connection other than the one being ** used by the backup operation, then the backup will be transparently ** restarted by the next call to sqlite3_backup_step(). If the source ** database is modified by the using the same database connection as is used ** by the backup operation, then the backup database is transparently ** updated at the same time. ** ** <b>sqlite3_backup_finish()</b> ** ** Once sqlite3_backup_step() has returned SQLITE_DONE, or when the ** application wishes to abandon the backup operation, the sqlite3_backup* ** handle should be passed to sqlite3_backup_finish(). This releases all ** resources associated with the backup operation. If sqlite3_backup_step() ** has not yet returned SQLITE_DONE, then any active write-transaction on the ** destination database is rolled back. The sqlite3_backup* handle is invalid ** and may not be used following a call to sqlite3_backup_finish(). ** ** The value returned by sqlite3_backup_finish is SQLITE_OK if no error ** occured, regardless or whether or not sqlite3_backup_step() was called ** a sufficient number of times to complete the backup operation. Or, if ** an out-of-memory condition or IO error occured during a call to ** sqlite3_backup_step() then SQLITE_NOMEM or an SQLITE_IOERR_XXX error code ** is returned. In this case the error code and an error message are ** written to the destination database handle. ** ** A return of SQLITE_BUSY or SQLITE_LOCKED from sqlite3_backup_step() is ** not considered an error and does not affect the return value of ** sqlite3_backup_finish(). ** ** <b>sqlite3_backup_remaining(), sqlite3_backup_pagecount()</b> ** ** Each call to sqlite3_backup_step() sets two values stored internally ** by an sqlite3_backup* handle. The number of pages still to be backed ** up, which may be queried by sqlite3_backup_remaining(), and the total ** number of pages in the source database file, which may be queried by ** sqlite3_backup_pagecount(). ** ** The values returned by these functions are only updated by ** sqlite3_backup_step(). If the source database is modified during a backup ** operation, then the values are not updated to account for any extra ** pages that need to be updated or the size of the source database file ** changing. ** ** <b>Concurrent Usage of Database Handles</b> ** ** The source database handle may be used by the application for other ** purposes while a backup operation is underway or being initialized. ** If SQLite is compiled and configured to support threadsafe database ** connections, then the source database connection may be used concurrently ** from within other threads. ** ** However, the application must guarantee that the destination database ** connection handle is not passed to any other API (by any thread) after ** sqlite3_backup_init() is called and before the corresponding call to ** sqlite3_backup_finish(). Unfortunately SQLite does not currently check ** for this, if the application does use the destination database handle ** for some other purpose during a backup operation, things may appear to ** work correctly but in fact be subtly malfunctioning. ** ** Furthermore, if running in shared cache mode, the application must ** guarantee that the shared cache used by the destination database ** is not accessed while the backup is running. In practice this means ** that the application must guarantee that the file-system file being ** backed up to is not accessed by any connection within the process, ** not just the specific connection that was passed to sqlite3_backup_init(). ** ** The sqlite3_backup handle itself is partially threadsafe. Multiple ** threads may safely make multiple concurrent calls to sqlite3_backup_step(). ** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount() ** APIs are not strictly speaking threadsafe. If they are invoked at the ** same time as another thread is invoking sqlite3_backup_step() it is ** possible that they return invalid values. */ typedef struct sqlite3_backup sqlite3_backup; sqlite3_backup *sqlite3_backup_init( sqlite3 *pDest, /* Destination database handle */ const char *zDestName, /* Destination database name */ sqlite3 *pSource, /* Source database handle */ const char *zSourceName /* Source database name */ ); int sqlite3_backup_step(sqlite3_backup *p, int nPage); int sqlite3_backup_finish(sqlite3_backup *p); int sqlite3_backup_remaining(sqlite3_backup *p); int sqlite3_backup_pagecount(sqlite3_backup *p); /* ** Undo the hack that converts floating point types to integer for ** builds on processors without floating point support. */ #ifdef SQLITE_OMIT_FLOATING_POINT # undef double #endif #ifdef __cplusplus } /* End of the 'extern "C"' block */ #endif #endif |
Changes to src/sqliteInt.h.
1 2 3 4 5 6 7 8 9 10 11 12 13 | /* ** 2001 September 15 ** ** 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. ** ************************************************************************* ** Internal interface definitions for SQLite. ** | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | /* ** 2001 September 15 ** ** 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. ** ************************************************************************* ** Internal interface definitions for SQLite. ** ** @(#) $Id: sqliteInt.h,v 1.831 2009/02/03 16:51:25 danielk1977 Exp $ */ #ifndef _SQLITEINT_H_ #define _SQLITEINT_H_ /* ** Include the configuration header output by 'configure' if we're using the ** autoconf-based build |
︙ | ︙ | |||
2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 | void sqlite3AlterFinishAddColumn(Parse *, Token *); void sqlite3AlterBeginAddColumn(Parse *, SrcList *); CollSeq *sqlite3GetCollSeq(sqlite3*, CollSeq *, const char *, int); char sqlite3AffinityType(const Token*); void sqlite3Analyze(Parse*, Token*, Token*); int sqlite3InvokeBusyHandler(BusyHandler*); int sqlite3FindDb(sqlite3*, Token*); int sqlite3AnalysisLoad(sqlite3*,int iDB); void sqlite3DefaultRowEst(Index*); void sqlite3RegisterLikeFunctions(sqlite3*, int); int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*); void sqlite3MinimumFileFormat(Parse*, int, int); void sqlite3SchemaFree(void *); Schema *sqlite3SchemaGet(sqlite3 *, Btree *); | > | 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 | void sqlite3AlterFinishAddColumn(Parse *, Token *); void sqlite3AlterBeginAddColumn(Parse *, SrcList *); CollSeq *sqlite3GetCollSeq(sqlite3*, CollSeq *, const char *, int); char sqlite3AffinityType(const Token*); void sqlite3Analyze(Parse*, Token*, Token*); int sqlite3InvokeBusyHandler(BusyHandler*); int sqlite3FindDb(sqlite3*, Token*); int sqlite3FindDbName(sqlite3 *, const char *); int sqlite3AnalysisLoad(sqlite3*,int iDB); void sqlite3DefaultRowEst(Index*); void sqlite3RegisterLikeFunctions(sqlite3*, int); int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*); void sqlite3MinimumFileFormat(Parse*, int, int); void sqlite3SchemaFree(void *); Schema *sqlite3SchemaGet(sqlite3 *, Btree *); |
︙ | ︙ | |||
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 | void sqlite3StrAccumInit(StrAccum*, char*, int, int); void sqlite3StrAccumAppend(StrAccum*,const char*,int); char *sqlite3StrAccumFinish(StrAccum*); void sqlite3StrAccumReset(StrAccum*); void sqlite3SelectDestInit(SelectDest*,int,int); /* ** The interface to the LEMON-generated parser */ void *sqlite3ParserAlloc(void*(*)(size_t)); void sqlite3ParserFree(void*, void(*)(void*)); void sqlite3Parser(void*, int, Token, Parse*); #ifdef YYTRACKMAXSTACKDEPTH | > > > | 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 | void sqlite3StrAccumInit(StrAccum*, char*, int, int); void sqlite3StrAccumAppend(StrAccum*,const char*,int); char *sqlite3StrAccumFinish(StrAccum*); void sqlite3StrAccumReset(StrAccum*); void sqlite3SelectDestInit(SelectDest*,int,int); void sqlite3BackupRestart(sqlite3_backup *); void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *); /* ** The interface to the LEMON-generated parser */ void *sqlite3ParserAlloc(void*(*)(size_t)); void sqlite3ParserFree(void*, void(*)(void*)); void sqlite3Parser(void*, int, Token, Parse*); #ifdef YYTRACKMAXSTACKDEPTH |
︙ | ︙ |
Changes to src/tclsqlite.c.
︙ | ︙ | |||
8 9 10 11 12 13 14 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** A TCL Interface to SQLite. Append this file to sqlite3.c and ** compile the whole thing to build a TCL-enabled version of SQLite. ** | | | 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | ** May you find forgiveness for yourself and forgive others. ** May you share freely, never taking more than you give. ** ************************************************************************* ** A TCL Interface to SQLite. Append this file to sqlite3.c and ** compile the whole thing to build a TCL-enabled version of SQLite. ** ** $Id: tclsqlite.c,v 1.235 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "tcl.h" #include <errno.h> /* ** Some additional include files are needed if this file is not ** appended to the amalgamation. |
︙ | ︙ | |||
2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 | extern int Sqlitetest_mutex_Init(Tcl_Interp*); extern int Sqlitetestschema_Init(Tcl_Interp*); extern int Sqlitetestsse_Init(Tcl_Interp*); extern int Sqlitetesttclvar_Init(Tcl_Interp*); extern int SqlitetestThread_Init(Tcl_Interp*); extern int SqlitetestOnefile_Init(); extern int SqlitetestOsinst_Init(Tcl_Interp*); Md5_Init(interp); Sqliteconfig_Init(interp); Sqlitetest1_Init(interp); Sqlitetest2_Init(interp); Sqlitetest3_Init(interp); Sqlitetest4_Init(interp); | > | 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 | extern int Sqlitetest_mutex_Init(Tcl_Interp*); extern int Sqlitetestschema_Init(Tcl_Interp*); extern int Sqlitetestsse_Init(Tcl_Interp*); extern int Sqlitetesttclvar_Init(Tcl_Interp*); extern int SqlitetestThread_Init(Tcl_Interp*); extern int SqlitetestOnefile_Init(); extern int SqlitetestOsinst_Init(Tcl_Interp*); extern int Sqlitetestbackup_Init(Tcl_Interp*); Md5_Init(interp); Sqliteconfig_Init(interp); Sqlitetest1_Init(interp); Sqlitetest2_Init(interp); Sqlitetest3_Init(interp); Sqlitetest4_Init(interp); |
︙ | ︙ | |||
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 | Sqlitetest_malloc_Init(interp); Sqlitetest_mutex_Init(interp); Sqlitetestschema_Init(interp); Sqlitetesttclvar_Init(interp); SqlitetestThread_Init(interp); SqlitetestOnefile_Init(interp); SqlitetestOsinst_Init(interp); #ifdef SQLITE_SSE Sqlitetestsse_Init(interp); #endif } #endif if( argc>=2 || TCLSH==2 ){ | > | 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 | Sqlitetest_malloc_Init(interp); Sqlitetest_mutex_Init(interp); Sqlitetestschema_Init(interp); Sqlitetesttclvar_Init(interp); SqlitetestThread_Init(interp); SqlitetestOnefile_Init(interp); SqlitetestOsinst_Init(interp); Sqlitetestbackup_Init(interp); #ifdef SQLITE_SSE Sqlitetestsse_Init(interp); #endif } #endif if( argc>=2 || TCLSH==2 ){ |
︙ | ︙ |
Changes to src/test1.c.
︙ | ︙ | |||
9 10 11 12 13 14 15 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing all sorts of SQLite interfaces. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** | | | 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | ** May you share freely, never taking more than you give. ** ************************************************************************* ** Code for testing all sorts of SQLite interfaces. This code ** is not included in the SQLite library. It is used for automated ** testing of the SQLite library. ** ** $Id: test1.c,v 1.347 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" #include "tcl.h" #include <stdlib.h> #include <string.h> /* |
︙ | ︙ | |||
3213 3214 3215 3216 3217 3218 3219 | if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; rc = sqlite3_errcode(db); Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0); return TCL_OK; } /* | | | 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 | if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; rc = sqlite3_errcode(db); Tcl_AppendResult(interp, (char *)t1ErrorName(rc), 0); return TCL_OK; } /* ** Usage: sqlite3_errmsg DB ** ** Returns the UTF-8 representation of the error message string for the ** most recent sqlite3_* API call. */ static int test_errmsg( void * clientData, Tcl_Interp *interp, |
︙ | ︙ |
Added src/test_backup.c.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 | /* ** 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. ** ************************************************************************* ** ** $Id: test_backup.c,v 1.1 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "tcl.h" #include <sqlite3.h> #include <assert.h> /* These functions are implemented in test1.c. */ int getDbPointer(Tcl_Interp *, const char *, sqlite3 **); const char *sqlite3TestErrorName(int); static int backupTestCmd( ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const*objv ){ enum BackupSubCommandEnum { BACKUP_STEP, BACKUP_FINISH, BACKUP_REMAINING, BACKUP_PAGECOUNT }; struct BackupSubCommand { const char *zCmd; enum BackupSubCommandEnum eCmd; int nArg; const char *zArg; } aSub[] = { {"step", BACKUP_STEP , 1, "npage" }, {"finish", BACKUP_FINISH , 0, "" }, {"remaining", BACKUP_REMAINING , 0, "" }, {"pagecount", BACKUP_PAGECOUNT , 0, "" }, {0, 0, 0, 0} }; sqlite3_backup *p = (sqlite3_backup *)clientData; int iCmd; int rc; rc = Tcl_GetIndexFromObjStruct( interp, objv[1], aSub, sizeof(aSub[0]), "option", 0, &iCmd ); if( rc!=TCL_OK ){ return rc; } if( objc!=(2 + aSub[iCmd].nArg) ){ Tcl_WrongNumArgs(interp, 2, objv, aSub[iCmd].zArg); return TCL_ERROR; } switch( aSub[iCmd].eCmd ){ case BACKUP_FINISH: { Tcl_CmdInfo cmdInfo; Tcl_Command cmd = Tcl_GetCommandFromObj(interp, objv[0]); Tcl_GetCommandInfoFromToken(cmd, &cmdInfo); cmdInfo.deleteProc = 0; Tcl_SetCommandInfoFromToken(cmd, &cmdInfo); Tcl_DeleteCommandFromToken(interp, cmd); rc = sqlite3_backup_finish(p); Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC); break; } case BACKUP_STEP: { int nPage; if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &nPage) ){ return TCL_ERROR; } rc = sqlite3_backup_step(p, nPage); Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC); break; } case BACKUP_REMAINING: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_backup_remaining(p))); break; case BACKUP_PAGECOUNT: Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_backup_pagecount(p))); break; } return TCL_OK; } static void backupTestFinish(ClientData clientData){ sqlite3_backup *pBackup = (sqlite3_backup *)clientData; sqlite3_backup_finish(pBackup); } /* ** sqlite3_backup CMDNAME DESTHANDLE DESTNAME SRCHANDLE SRCNAME ** */ static int backupTestInit( ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *const*objv ){ sqlite3_backup *pBackup; sqlite3 *pDestDb; sqlite3 *pSrcDb; const char *zDestName; const char *zSrcName; const char *zCmd; if( objc!=6 ){ Tcl_WrongNumArgs( interp, 1, objv, "CMDNAME DESTHANDLE DESTNAME SRCHANDLE SRCNAME" ); return TCL_ERROR; } zCmd = Tcl_GetString(objv[1]); getDbPointer(interp, Tcl_GetString(objv[2]), &pDestDb); zDestName = Tcl_GetString(objv[3]); getDbPointer(interp, Tcl_GetString(objv[4]), &pSrcDb); zSrcName = Tcl_GetString(objv[5]); pBackup = sqlite3_backup_init(pDestDb, zDestName, pSrcDb, zSrcName); if( !pBackup ){ Tcl_AppendResult(interp, "sqlite3_backup_init() failed", 0); return TCL_ERROR; } Tcl_CreateObjCommand(interp, zCmd, backupTestCmd, pBackup, backupTestFinish); Tcl_SetObjResult(interp, objv[1]); return TCL_OK; } int Sqlitetestbackup_Init(Tcl_Interp *interp){ Tcl_CreateObjCommand(interp, "sqlite3_backup", backupTestInit, 0, 0); return TCL_OK; } |
Changes to src/vacuum.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** This file contains code used to implement the VACUUM command. ** ** Most of the code in this file may be omitted by defining the ** SQLITE_OMIT_VACUUM macro. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** This file contains code used to implement the VACUUM command. ** ** Most of the code in this file may be omitted by defining the ** SQLITE_OMIT_VACUUM macro. ** ** $Id: vacuum.c,v 1.86 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" #include "vdbeInt.h" #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) /* ** Execute zSql on database db. Return an error code. |
︙ | ︙ | |||
261 262 263 264 265 266 267 | rc = sqlite3BtreeCopyFile(pMain, pTemp); if( rc!=SQLITE_OK ) goto end_of_vacuum; rc = sqlite3BtreeCommit(pTemp); if( rc!=SQLITE_OK ) goto end_of_vacuum; #ifndef SQLITE_OMIT_AUTOVACUUM sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp)); #endif | < | 261 262 263 264 265 266 267 268 269 270 271 272 273 274 | rc = sqlite3BtreeCopyFile(pMain, pTemp); if( rc!=SQLITE_OK ) goto end_of_vacuum; rc = sqlite3BtreeCommit(pTemp); if( rc!=SQLITE_OK ) goto end_of_vacuum; #ifndef SQLITE_OMIT_AUTOVACUUM sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp)); #endif } if( rc==SQLITE_OK ){ rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes); } end_of_vacuum: |
︙ | ︙ |
Changes to src/vdbeaux.c.
︙ | ︙ | |||
10 11 12 13 14 15 16 | ** ************************************************************************* ** This file contains code used for creating, destroying, and populating ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) Prior ** to version 2.8.7, all this code was combined into the vdbe.c source file. ** But that file was getting too big so this subroutines were split out. ** | | | 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ** ************************************************************************* ** This file contains code used for creating, destroying, and populating ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) Prior ** to version 2.8.7, all this code was combined into the vdbe.c source file. ** But that file was getting too big so this subroutines were split out. ** ** $Id: vdbeaux.c,v 1.435 2009/02/03 16:51:25 danielk1977 Exp $ */ #include "sqliteInt.h" #include "vdbeInt.h" /* |
︙ | ︙ | |||
1294 1295 1296 1297 1298 1299 1300 | ** string, it means the main database is :memory: or a temp file. In ** that case we do not support atomic multi-file commits, so use the ** simple case then too. */ if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){ | | | 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 | ** string, it means the main database is :memory: or a temp file. In ** that case we do not support atomic multi-file commits, so use the ** simple case then too. */ if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){ for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ Btree *pBt = db->aDb[i].pBt; if( pBt ){ rc = sqlite3BtreeCommitPhaseOne(pBt, 0); } } /* Do the commit only if all databases successfully complete phase 1. |
︙ | ︙ |
Added test/backup.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 | # 2008 January 30 # # 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 implements regression tests for SQLite library. The # focus of this file is testing the sqlite3_backup_XXX API. # # $Id: backup.test,v 1.1 2009/02/03 16:51:25 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl #--------------------------------------------------------------------- # Test organization: # # backup-1.*: Warm-body tests. # # backup-2.*: Test backup under various conditions. To and from in-memory # databases. To and from empty/populated databases. etc. # # backup-3.*: Verify that the locking-page (pending byte page) is handled. # # backup-4.*: Test various error conditions. # # backup-5.*: Test the source database being modified during a backup. # # backup-6.*: Test the backup_remaining() and backup_pagecount() APIs. # # backup-7.*: Test SQLITE_BUSY and SQLITE_LOCKED errors. # # backup-8.*: Test multiple simultaneous backup operations. # proc data_checksum {db file} { $db one "SELECT md5sum(a, b) FROM ${file}.t1" } proc test_contents {name db1 file1 db2 file2} { $db2 eval {select * from sqlite_master} $db1 eval {select * from sqlite_master} set checksum [data_checksum $db2 $file2] uplevel [list do_test $name [list data_checksum $db1 $file1] $checksum] } do_test backup-1.1 { execsql { BEGIN; CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 VALUES(2, randstr(1000,1000)); INSERT INTO t1 VALUES(3, randstr(1000,1000)); INSERT INTO t1 VALUES(4, randstr(1000,1000)); INSERT INTO t1 VALUES(5, randstr(1000,1000)); COMMIT; } } {} # Sanity check to verify that the [test_contents] proc works. # test_contents backup-1.2 db main db main # Check that it is possible to create and finish backup operations. # do_test backup-1.3.1 { file delete test2.db sqlite3 db2 test2.db sqlite3_backup B db2 main db main } {B} do_test backup-1.3.2 { B finish } {SQLITE_OK} do_test backup-1.3.3 { info commands B } {} # Simplest backup operation. Backup test.db to test2.db. test2.db is # initially empty. test.db uses the default page size. # do_test backup-1.4.1 { sqlite3_backup B db2 main db main } {B} do_test backup-1.4.2 { B step 200 } {SQLITE_DONE} do_test backup-1.4.3 { B finish } {SQLITE_OK} do_test backup-1.4.4 { info commands B } {} test_contents backup-1.4.5 db2 main db main db close db2 close # # End of backup-1.* tests. #--------------------------------------------------------------------- #--------------------------------------------------------------------- # The following tests, backup-2.*, are based on the following procedure: # # 1) Populate the source database. # 2) Populate the destination database. # 3) Run the backup to completion. (backup-2.*.1) # 4) Integrity check the destination db. (backup-2.*.2) # 5) Check that the contents of the destination db is the same as that # of the source db. (backup-2.*.3) # # The test is run with all possible combinations of the following # input parameters, except that if the destination is an in-memory # database, the only page size tested is 1024 bytes (the same as the # source page-size). # # * Source database is an in-memory database, OR # * Source database is a file-backed database. # # * Target database is an in-memory database, OR # * Target database is a file-backed database. # # * Destination database is a main file, OR # * Destination database is an attached file, OR # * Destination database is a temp database. # # * Target database is empty (zero bytes), OR # * Target database is larger than the source, OR # * Target database is smaller than the source. # # * Target database page-size is the same as the source, OR # * Target database page-size is larger than the source, OR # * Target database page-size is smaller than the source. # # * Each call to step copies a single page, OR # * A single call to step copies the entire source database. # set iTest 1 foreach zSrcFile {test.db :memory:} { foreach zDestFile {test2.db :memory:} { foreach zOpenScript [list { sqlite3 db $zSrcFile sqlite3 db2 $zSrcFile db2 eval "ATTACH '$zDestFile' AS bak" set db_dest db2 set file_dest bak } { sqlite3 db $zSrcFile sqlite3 db2 $zDestFile set db_dest db2 set file_dest main } { sqlite3 db $zSrcFile sqlite3 db2 $zDestFile set db_dest db2 set file_dest temp }] { foreach rows_dest {0 3 10} { foreach pgsz_dest {512 1024 2048} { foreach nPagePerStep {1 200} { # Open the databases. catch { file delete test.db } catch { file delete test2.db } eval $zOpenScript if {$zDestFile ne ":memory:" || $pgsz_dest == 1024 } { if 0 { puts -nonewline "Test $iTest: src=$zSrcFile dest=$zDestFile" puts -nonewline " (as $db_dest.$file_dest)" puts -nonewline " rows_dest=$rows_dest pgsz_dest=$pgsz_dest" puts "" } # Set up the content of the source database. execsql { BEGIN; CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 VALUES(2, randstr(1000,1000)); INSERT INTO t1 VALUES(3, randstr(1000,1000)); INSERT INTO t1 VALUES(4, randstr(1000,1000)); INSERT INTO t1 VALUES(5, randstr(1000,1000)); COMMIT; } # Set up the content of the target database. execsql "PRAGMA ${file_dest}.page_size = ${pgsz_dest}" $db_dest if {$rows_dest != 0} { execsql " BEGIN; CREATE TABLE ${file_dest}.t1(a, b); CREATE INDEX ${file_dest}.i1 ON t1(a, b); " $db_dest for {set ii 0} {$ii < $rows_dest} {incr ii} { execsql " INSERT INTO ${file_dest}.t1 VALUES(1, randstr(1000,1000)) " $db_dest } } # Backup the source database. do_test backup-2.$iTest.1 { sqlite3_backup B $db_dest $file_dest db main while {[B step $nPagePerStep]=="SQLITE_OK"} {} B finish } {SQLITE_OK} # Run integrity check on the backup. do_test backup-2.$iTest.2 { execsql "PRAGMA ${file_dest}.integrity_check" $db_dest } {ok} test_contents backup-2.$iTest.3 db main $db_dest $file_dest } db close catch {db2 close} incr iTest } } } } } } # # End of backup-2.* tests. #--------------------------------------------------------------------- #--------------------------------------------------------------------- # These tests, backup-3.*, ensure that nothing goes wrong if either # the source or destination database are large enough to include the # the locking-page (the page that contains the range of bytes that # the locks are applied to). These tests assume that the pending # byte is at offset 0x00010000 (64KB offset), as set by tester.tcl, # not at the 1GB offset as it usually is. # # The test procedure is as follows (same procedure as used for # the backup-2.* tests): # # 1) Populate the source database. # 2) Populate the destination database. # 3) Run the backup to completion. (backup-3.*.1) # 4) Integrity check the destination db. (backup-3.*.2) # 5) Check that the contents of the destination db is the same as that # of the source db. (backup-3.*.3) # # The test procedure is run with the following parameters varied: # # * Source database includes pending-byte page. # * Source database does not include pending-byte page. # # * Target database includes pending-byte page. # * Target database does not include pending-byte page. # # * Target database page-size is the same as the source, OR # * Target database page-size is larger than the source, OR # * Target database page-size is smaller than the source. # set iTest 1 foreach nSrcRow {10 100} { foreach nDestRow {10 100} { foreach nDestPgsz {512 1024 2048 4096} { catch { file delete test.db } catch { file delete test2.db } sqlite3 db test.db sqlite3 db2 test2.db # Set up the content of the two databases. # foreach {db nRow} [list db $nSrcRow db2 $nDestRow] { execsql { BEGIN; CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); } $db for {set ii 0} {$ii < $nSrcRow} {incr ii} { execsql { INSERT INTO t1 VALUES($ii, randstr(1000,1000)) } $db } execsql COMMIT $db } # Backup the source database. do_test backup-3.$iTest.1 { sqlite3_backup B db main db2 main while {[B step 10]=="SQLITE_OK"} {} B finish } {SQLITE_OK} # Run integrity check on the backup. do_test backup-3.$iTest.2 { execsql "PRAGMA integrity_check" db2 } {ok} test_contents backup-3.$iTest.3 db main db2 main db close db2 close incr iTest } } } # # End of backup-3.* tests. #--------------------------------------------------------------------- #--------------------------------------------------------------------- # The following tests, backup-4.*, test various error conditions: # # backup-4.1.*: Test invalid database names. # # backup-4.2.*: Test that the source database cannot be detached while # a backup is in progress. # # backup-4.3.*: Test that the source database handle cannot be closed # while a backup is in progress. # # backup-4.4.*: Test an attempt to specify the same handle for the # source and destination databases. # # backup-4.5.*: Test that an in-memory destination with a different # page-size to the source database is an error. # sqlite3 db test.db sqlite3 db2 test2.db do_test backup-4.1.1 { catch { sqlite3_backup B db aux db2 main } } {1} do_test backup-4.1.2 { sqlite3_errmsg db } {unknown database aux} do_test backup-4.1.3 { catch { sqlite3_backup B db main db2 aux } } {1} do_test backup-4.1.4 { sqlite3_errmsg db } {unknown database aux} do_test backup-4.2.1 { execsql { ATTACH 'test3.db' AS aux1 } execsql { ATTACH 'test4.db' AS aux2 } db2 sqlite3_backup B db aux1 db2 aux2 } {B} do_test backup-4.2.2 { catchsql { DETACH aux2 } db2 } {1 {database aux2 is locked}} do_test backup-4.2.3 { B step 50 } {SQLITE_DONE} do_test backup-4.2.4 { B finish } {SQLITE_OK} do_test backup-4.3.1 { sqlite3_backup B db aux1 db2 aux2 } {B} do_test backup-4.3.2 { db2 cache flush sqlite3_close db2 } {SQLITE_BUSY} do_test backup-4.3.3 { sqlite3_errmsg db2 } {Unable to close due to unfinished backup operation} do_test backup-4.3.4 { B step 50 } {SQLITE_DONE} do_test backup-4.3.5 { B finish } {SQLITE_OK} do_test backup-4.4.1 { set rc [catch {sqlite3_backup B db main db aux1}] list $rc [sqlite3_errcode db] [sqlite3_errmsg db] } {1 SQLITE_ERROR {Source and destination handles must be distinct}} db close db2 close do_test backup-4.5.1 { catch { file delete -force test.db } sqlite3 db test.db sqlite3 db2 :memory: execsql { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 2); } execsql { PRAGMA page_size = 4096; CREATE TABLE t2(a, b); INSERT INTO t2 VALUES(3, 4); } db2 sqlite3_backup B db2 main db main } {B} do_test backup-4.5.2 { B step 5000 } {SQLITE_READONLY} do_test backup-4.5.3 { B finish } {SQLITE_READONLY} db close db2 close # # End of backup-5.* tests. #--------------------------------------------------------------------- #--------------------------------------------------------------------- # The following tests, backup-5.*, test that the backup works properly # when the source database is modified during the backup. Test cases # are organized as follows: # # backup-5.x.1.*: Nothing special. Modify the database mid-backup. # # backup-5.x.2.*: Modify the database mid-backup so that one or more # pages are written out due to cache stress. Then # rollback the transaction. # # backup-5.x.3.*: Database is vacuumed. # # backup-5.x.4.*: Database is vacuumed and the page-size modified. # # backup-5.x.5.*: Database is shrunk via incr-vacuum. # # Each test is run three times, in the following configurations: # # 1) Backing up file-to-file. The writer writes via an external pager. # 2) Backing up file-to-file. The writer writes via the same pager as # is used by the backup operation. # 3) Backing up memory-to-file. # set iTest 0 foreach {writer file} {db test.db db3 test.db db :memory:} { incr iTest catch { file delete bak.db } sqlite3 db2 bak.db catch { file delete $file } sqlite3 db $file sqlite3 db3 $file do_test backup-5.$iTest.1.1 { execsql { BEGIN; CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 VALUES(2, randstr(1000,1000)); INSERT INTO t1 VALUES(3, randstr(1000,1000)); INSERT INTO t1 VALUES(4, randstr(1000,1000)); INSERT INTO t1 VALUES(5, randstr(1000,1000)); COMMIT; } expr {[execsql {PRAGMA page_count}] > 10} } {1} do_test backup-5.$iTest.1.2 { sqlite3_backup B db2 main db main B step 5 } {SQLITE_OK} do_test backup-5.$iTest.1.3 { execsql { UPDATE t1 SET a = a + 1 } $writer B step 50 } {SQLITE_DONE} do_test backup-5.$iTest.1.4 { B finish } {SQLITE_OK} integrity_check backup-5.$iTest.1.5 db2 test_contents backup-5.$iTest.1.6 db main db2 main do_test backup-5.$iTest.2.1 { execsql { PRAGMA cache_size = 10; BEGIN; INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1; COMMIT; } } {} do_test backup-5.$iTest.2.2 { sqlite3_backup B db2 main db main B step 50 } {SQLITE_OK} do_test backup-5.$iTest.2.3 { execsql { BEGIN; UPDATE t1 SET a = a + 1; ROLLBACK; } $writer B step 5000 } {SQLITE_DONE} do_test backup-5.$iTest.2.4 { B finish } {SQLITE_OK} integrity_check backup-5.$iTest.2.5 db2 test_contents backup-5.$iTest.2.6 db main db2 main do_test backup-5.$iTest.3.1 { execsql { UPDATE t1 SET b = randstr(1000,1000) } } {} do_test backup-5.$iTest.3.2 { sqlite3_backup B db2 main db main B step 50 } {SQLITE_OK} do_test backup-5.$iTest.3.3 { execsql { VACUUM } $writer B step 5000 } {SQLITE_DONE} do_test backup-5.$iTest.3.4 { B finish } {SQLITE_OK} integrity_check backup-5.$iTest.3.5 db2 test_contents backup-5.$iTest.3.6 db main db2 main do_test backup-5.$iTest.4.1 { execsql { UPDATE t1 SET b = randstr(1000,1000) } } {} do_test backup-5.$iTest.4.2 { sqlite3_backup B db2 main db main B step 50 } {SQLITE_OK} do_test backup-5.$iTest.4.3 { execsql { PRAGMA page_size = 2048; VACUUM; } $writer B step 5000 } {SQLITE_DONE} do_test backup-5.$iTest.4.4 { B finish } {SQLITE_OK} integrity_check backup-5.$iTest.4.5 db2 test_contents backup-5.$iTest.4.6 db main db2 main catch { file delete bak.db } sqlite3 db2 bak.db catch { file delete $file } sqlite3 db $file sqlite3 db3 $file do_test backup-5.$iTest.5.1 { execsql { PRAGMA auto_vacuum = incremental; BEGIN; CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 VALUES(2, randstr(1000,1000)); INSERT INTO t1 VALUES(3, randstr(1000,1000)); INSERT INTO t1 VALUES(4, randstr(1000,1000)); INSERT INTO t1 VALUES(5, randstr(1000,1000)); COMMIT; } } {} do_test backup-5.$iTest.5.2 { sqlite3_backup B db2 main db main B step 8 } {SQLITE_OK} do_test backup-5.$iTest.5.3 { execsql { DELETE FROM t1; PRAGMA incremental_vacuum; } $writer B step 50 } {SQLITE_DONE} do_test backup-5.$iTest.5.4 { B finish } {SQLITE_OK} integrity_check backup-5.$iTest.5.5 db2 test_contents backup-5.$iTest.5.6 db main db2 main } catch {db close} catch {db2 close} catch {db3 close} # # End of backup-5.* tests. #--------------------------------------------------------------------- #--------------------------------------------------------------------- # Test the sqlite3_backup_remaining() and backup_pagecount() APIs. # do_test backup-6.1 { catch { file delete -force test.db } catch { file delete -force test2.db } sqlite3 db test.db sqlite3 db2 test2.db execsql { BEGIN; CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 VALUES(2, randstr(1000,1000)); INSERT INTO t1 VALUES(3, randstr(1000,1000)); INSERT INTO t1 VALUES(4, randstr(1000,1000)); INSERT INTO t1 VALUES(5, randstr(1000,1000)); COMMIT; } } {} do_test backup-6.2 { set nTotal [expr {[file size test.db]/1024}] sqlite3_backup B db2 main db main B step 1 } {SQLITE_OK} do_test backup-6.3 { B pagecount } $nTotal do_test backup-6.4 { B remaining } [expr $nTotal-1] do_test backup-6.5 { B step 5 list [B remaining] [B pagecount] } [list [expr $nTotal-6] $nTotal] do_test backup-6.6 { execsql { CREATE TABLE t2(a PRIMARY KEY, b) } B step 1 list [B remaining] [B pagecount] } [list [expr $nTotal-5] [expr $nTotal+2]] do_test backup-6.X { B finish } {SQLITE_OK} #--------------------------------------------------------------------- # Test cases backup-7.* test that SQLITE_BUSY and SQLITE_LOCKED errors # are returned correctly: # # backup-7.1.*: Source database is externally locked (return SQLITE_BUSY). # # backup-7.2.*: Attempt to step the backup process while a # write-transaction is underway on the source pager (return # SQLITE_LOCKED). # # backup-7.3.*: Destination database is externally locked (return SQLITE_BUSY). # do_test backup-7.0 { catch { file delete -force test.db } catch { file delete -force test2.db } sqlite3 db2 test2.db sqlite3 db test.db execsql { CREATE TABLE t1(a, b); CREATE INDEX i1 ON t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1; } } {} do_test backup-7.1.1 { sqlite3_backup B db2 main db main B step 5 } {SQLITE_OK} do_test backup-7.1.2 { sqlite3 db3 test.db execsql { BEGIN EXCLUSIVE } db3 B step 5 } {SQLITE_BUSY} do_test backup-7.1.3 { execsql { ROLLBACK } db3 B step 5 } {SQLITE_OK} do_test backup-7.2.1 { execsql { BEGIN; INSERT INTO t1 VALUES(1, 4); } } {} do_test backup-7.2.2 { B step 5000 } {SQLITE_LOCKED} do_test backup-7.2.3 { execsql { ROLLBACK } B step 5000 } {SQLITE_DONE} do_test backup-7.2.4 { B finish } {SQLITE_OK} test_contents backup-7.2.5 db main db2 main integrity_check backup-7.3.6 db2 do_test backup-7.3.1 { db2 close db3 close file delete -force test2.db sqlite3 db2 test2.db sqlite3 db3 test2.db sqlite3_backup B db2 main db main execsql { BEGIN ; CREATE TABLE t2(a, b); } db3 B step 5 } {SQLITE_BUSY} do_test backup-7.3.2 { execsql { COMMIT } db3 B step 5000 } {SQLITE_DONE} do_test backup-7.3.3 { B finish } {SQLITE_OK} test_contents backup-7.3.4 db main db2 main integrity_check backup-7.3.5 db2 catch { db2 close } catch { db3 close } #----------------------------------------------------------------------- # The following tests, backup-8.*, test attaching multiple backup # processes to the same source database. Also, reading from the source # database while a read transaction is active. # # These tests reuse the database "test.db" left over from backup-7.*. # do_test backup-8.1 { catch { file delete -force test2.db } catch { file delete -force test3.db } sqlite3 db2 test2.db sqlite3 db3 test3.db sqlite3_backup B2 db2 main db main sqlite3_backup B3 db3 main db main list [B2 finish] [B3 finish] } {SQLITE_OK SQLITE_OK} do_test backup-8.2 { sqlite3_backup B3 db3 main db main sqlite3_backup B2 db2 main db main list [B2 finish] [B3 finish] } {SQLITE_OK SQLITE_OK} do_test backup-8.3 { sqlite3_backup B2 db2 main db main sqlite3_backup B3 db3 main db main B2 step 5 } {SQLITE_OK} do_test backup-8.4 { execsql { BEGIN; SELECT * FROM sqlite_master; } B3 step 5 } {SQLITE_OK} do_test backup-8.5 { list [B3 step 5000] [B3 finish] } {SQLITE_DONE SQLITE_OK} do_test backup-8.6 { list [B2 step 5000] [B2 finish] } {SQLITE_DONE SQLITE_OK} test_contents backup-8.7 db main db2 main test_contents backup-8.8 db main db3 main do_test backup-8.9 { execsql { PRAGMA lock_status } } {main shared temp closed} do_test backup-8.10 { execsql COMMIT } {} catch { db2 close } catch { db3 close } finish_test |
Added test/backup_ioerr.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 | # 2008 January 30 # # 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 implements regression tests for SQLite library. The # focus of this file is testing the handling of IO errors by the # sqlite3_backup_XXX APIs. # # $Id: backup_ioerr.test,v 1.1 2009/02/03 16:51:25 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl proc data_checksum {db file} { $db one "SELECT md5sum(a, b) FROM ${file}.t1" } proc test_contents {name db1 file1 db2 file2} { $db2 eval {select * from sqlite_master} $db1 eval {select * from sqlite_master} set checksum [data_checksum $db2 $file2] uplevel [list do_test $name [list data_checksum $db1 $file1] $checksum] } #-------------------------------------------------------------------- # This proc creates a database of approximately 290 pages. Depending # on whether or not auto-vacuum is configured. Test cases backup_ioerr-1.* # verify nothing more than this assumption. # proc populate_database {db {xtra_large 0}} { execsql { BEGIN; CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1; CREATE INDEX i1 ON t1(b); COMMIT; } $db if {$xtra_large} { execsql { INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1 } $db } } do_test backup_ioerr-1.1 { populate_database db set nPage [expr {[file size test.db] / 1024}] expr {$nPage>140 && $nPage<150} } {1} do_test backup_ioerr-1.2 { expr {[file size test.db] > $sqlite_pending_byte} } {1} do_test backup_ioerr-1.3 { db close file delete -force test.db } {} # Turn off IO error simulation. # proc clear_ioerr_simulation {} { set ::sqlite_io_error_hit 0 set ::sqlite_io_error_hardhit 0 set ::sqlite_io_error_pending 0 set ::sqlite_io_error_persist 0 } #-------------------------------------------------------------------- # The following procedure runs with SQLite's IO error simulation # enabled. # # 1) Start with a reasonably sized database. One that includes the # pending-byte (locking) page. # # 2) Open a backup process. Set the cache-size for the destination # database to 10 pages only. # # 3) Step the backup process N times to partially backup the database # file. If an IO error is reported, then the backup process is # concluded with a call to backup_finish(). # # If an IO error occurs, verify that: # # * the call to backup_step() returns an SQLITE_IOERR_XXX error code. # # * after the failed call to backup_step() but before the call to # backup_finish() the destination database handle error code and # error message remain unchanged. # # * the call to backup_finish() returns an SQLITE_IOERR_XXX error code. # # * following the call to backup_finish(), the destination database # handle has been populated with an error code and error message. # # 4) Write to the database via the source database connection. Check # that: # # * If an IO error occurs while writing the source database, the # write operation should report an IO error. The backup should # proceed as normal. # # * If an IO error occurs while updating the backup, the write # operation should proceed normally. The error should be reported # from the next call to backup_step() (in step 5 of this test # procedure). # # 5) Step the backup process to finish the backup. If an IO error is # reported, then the backup process is concluded with a call to # backup_finish(). # # Test that if an IO error occurs, or if one occured while updating # the backup database during step 4, then the conditions listed # under step 3 are all true. # # 6) Finish the backup process. # # * If the backup succeeds (backup_finish() returns SQLITE_OK), then # the contents of the backup database should match that of the # source database. # # * If the backup fails (backup_finish() returns other than SQLITE_OK), # then the contents of the backup database should be as they were # before the operation was started. # # The following factors are varied: # # * Destination database is initially larger than the source database, OR # * Destination database is initially smaller than the source database. # # * IO errors are transient, OR # * IO errors are persistent. # # * Destination page-size is smaller than the source. # * Destination page-size is the same as the source. # * Destination page-size is larger than the source. # set iTest 1 foreach bPersist {0 1} { foreach iDestPagesize {512 1024 4096} { foreach zSetupBak [list "" {populate_database ddb 1}] { incr iTest set bStop 0 for {set iError 1} {$bStop == 0} {incr iError} { # Disable IO error simulation. clear_ioerr_simulation catch { ddb close } catch { sdb close } catch { file delete -force test.db } catch { file delete -force bak.db } # Open the source and destination databases. sqlite3 sdb test.db sqlite3 ddb bak.db # Step 1: Populate the source and destination databases. populate_database sdb ddb eval "PRAGMA page_size = $iDestPagesize" ddb eval "PRAGMA cache_size = 10" eval $zSetupBak # Step 2: Open the backup process. sqlite3_backup B ddb main sdb main # Enable IO error simulation. set ::sqlite_io_error_pending $iError set ::sqlite_io_error_persist $bPersist # Step 3: Partially backup the database. If an IO error occurs, check # a few things then skip to the next iteration of the loop. # set rc [B step 100] if {$::sqlite_io_error_hardhit} { do_test backup_ioerr-$iTest.$iError.1 { string match SQLITE_IOERR* $rc } {1} do_test backup_ioerr-$iTest.$iError.2 { list [sqlite3_errcode ddb] [sqlite3_errmsg ddb] } {SQLITE_OK {not an error}} set rc [B finish] do_test backup_ioerr-$iTest.$iError.3 { string match SQLITE_IOERR* $rc } {1} do_test backup_ioerr-$iTest.$iError.4 { sqlite3_errmsg ddb } {disk I/O error} clear_ioerr_simulation sqlite3 ddb bak.db integrity_check backup_ioerr-$iTest.$iError.5 ddb continue } # No IO error was encountered during step 3. Check that backup_step() # returned SQLITE_OK before proceding. do_test backup_ioerr-$iTest.$iError.6 { expr {$rc eq "SQLITE_OK"} } {1} # Step 4: Write to the source database. set rc [catchsql { UPDATE t1 SET b = randstr(1000,1000) WHERE a < 50 } sdb] if {[lindex $rc 0] && $::sqlite_io_error_persist==0} { # The IO error occured while updating the source database. In this # case the backup should be able to continue. set rc [B step 5000] if { $rc != "SQLITE_IOERR_UNLOCK" } { do_test backup_ioerr-$iTest.$iError.7 { list [B step 5000] [B finish] } {SQLITE_DONE SQLITE_OK} clear_ioerr_simulation test_contents backup_ioerr-$iTest.$iError.8 ddb main sdb main integrity_check backup_ioerr-$iTest.$iError.9 ddb } else { do_test backup_ioerr-$iTest.$iError.10 { B finish } {SQLITE_IOERR_UNLOCK} } clear_ioerr_simulation sqlite3 ddb bak.db integrity_check backup_ioerr-$iTest.$iError.11 ddb continue } # Step 5: Finish the backup operation. If an IO error occurs, check that # it is reported correctly and skip to the next iteration of the loop. # set rc [B step 5000] if {$rc != "SQLITE_DONE"} { do_test backup_ioerr-$iTest.$iError.12 { string match SQLITE_IOERR* $rc } {1} do_test backup_ioerr-$iTest.$iError.13 { list [sqlite3_errcode ddb] [sqlite3_errmsg ddb] } {SQLITE_OK {not an error}} set rc [B finish] do_test backup_ioerr-$iTest.$iError.14 { string match SQLITE_IOERR* $rc } {1} do_test backup_ioerr-$iTest.$iError.15 { sqlite3_errmsg ddb } {disk I/O error} clear_ioerr_simulation sqlite3 ddb bak.db integrity_check backup_ioerr-$iTest.$iError.16 ddb continue } # The backup was successfully completed. # do_test backup_ioerr-$iTest.$iError.17 { list [set rc] [B finish] } {SQLITE_DONE SQLITE_OK} clear_ioerr_simulation sqlite3 sdb test.db sqlite3 ddb bak.db test_contents backup_ioerr-$iTest.$iError.18 ddb main sdb main integrity_check backup_ioerr-$iTest.$iError.19 ddb set bStop [expr $::sqlite_io_error_pending<=0] }}}} catch { sdb close } catch { ddb close } finish_test |
Added test/backup_malloc.test.
> > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | # 2008 January 30 # # 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 implements regression tests for SQLite library. The # focus of this file is testing the handling of OOM errors by the # sqlite3_backup_XXX APIs. # # $Id: backup_malloc.test,v 1.1 2009/02/03 16:51:25 danielk1977 Exp $ set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/malloc_common.tcl do_malloc_test backup_malloc-1 -tclprep { execsql { PRAGMA cache_size = 10; BEGIN; CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, randstr(1000,1000)); INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1; INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1; CREATE INDEX i1 ON t1(b); COMMIT; } sqlite3 db2 test2.db execsql { PRAGMA cache_size = 10 } db2 } -tclbody { # Create a backup object. # set rc [catch {sqlite3_backup B db2 main db main}] if {$rc && [sqlite3_errcode db2] == "SQLITE_NOMEM"} { error "out of memory" } # Run the backup process some. # set rc [B step 50] if {$rc == "SQLITE_NOMEM" || $rc == "SQLITE_IOERR_NOMEM"} { error "out of memory" } # Update the database. # execsql { UPDATE t1 SET a = a + 1 } # Finish doing the backup. # set rc [B step 5000] if {$rc == "SQLITE_NOMEM" || $rc == "SQLITE_IOERR_NOMEM"} { error "out of memory" } # Finalize the backup. B finish } -cleanup { catch { B finish } } do_malloc_test backup_malloc-1 -tclprep { sqlite3 db2 test2.db } -tclbody { set rc [catch {sqlite3_backup B db2 temp db main}] set errcode [sqlite3_errcode db2] if {$rc && ($errcode == "SQLITE_NOMEM" || $errcode == "SQLITE_IOERR_NOMEM")} { error "out of memory" } } -cleanup { catch { B finish } db2 close } finish_test |
Changes to test/quick.test.
1 2 3 4 5 6 7 8 | # # 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 runs all tests. # | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | # # 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 runs all tests. # # $Id: quick.test,v 1.92 2009/02/03 16:51:25 danielk1977 Exp $ proc lshift {lvar} { upvar $lvar l set ret [lindex $l 0] set l [lrange $l 1 end] return $ret } |
︙ | ︙ | |||
42 43 44 45 46 47 48 49 50 51 52 53 54 55 | set ISQUICK 1 set EXCLUDE { all.test async.test async2.test async3.test corrupt.test corruptC.test crash.test crash2.test crash3.test crash4.test crash5.test | > | 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | set ISQUICK 1 set EXCLUDE { all.test async.test async2.test async3.test backup_ioerr.test corrupt.test corruptC.test crash.test crash2.test crash3.test crash4.test crash5.test |
︙ | ︙ |
Changes to test/tester.tcl.
1 2 3 4 5 6 7 8 9 10 11 12 13 | # 2001 September 15 # # 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 implements some common TCL routines used for regression # testing the SQLite library # | | | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | # 2001 September 15 # # 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 implements some common TCL routines used for regression # testing the SQLite library # # $Id: tester.tcl,v 1.137 2009/02/03 16:51:25 danielk1977 Exp $ # # What for user input before continuing. This gives an opportunity # to connect profiling tools to the process. # for {set i 0} {$i<[llength $argv]} {incr i} { if {[regexp {^-+pause$} [lindex $argv $i] all value]} { |
︙ | ︙ | |||
481 482 483 484 485 486 487 | if {[catch {file delete -force $filename}]} { exec rm -rf $filename } } # Do an integrity check of the entire database # | | < | < | 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 | if {[catch {file delete -force $filename}]} { exec rm -rf $filename } } # Do an integrity check of the entire database # proc integrity_check {name {db db}} { ifcapable integrityck { do_test $name [list execsql {PRAGMA integrity_check} $db] {ok} } } proc fix_ifcapable_expr {expr} { set ret "" set state 0 for {set i 0} {$i < [string length $expr]} {incr i} { |
︙ | ︙ |
Changes to tool/mksqlite3c.tcl.
︙ | ︙ | |||
243 244 245 246 247 248 249 250 251 252 253 254 255 256 | pcache.c pcache1.c rowset.c pager.c btmutex.c btree.c vdbemem.c vdbeaux.c vdbeapi.c vdbe.c vdbeblob.c journal.c | > | 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 | pcache.c pcache1.c rowset.c pager.c btmutex.c btree.c backup.c vdbemem.c vdbeaux.c vdbeapi.c vdbe.c vdbeblob.c journal.c |
︙ | ︙ |