Annotation of embedaddon/sqlite3/test/backup.test, revision 1.1
1.1 ! misho 1: # 2009 January 30
! 2: #
! 3: # The author disclaims copyright to this source code. In place of
! 4: # a legal notice, here is a blessing:
! 5: #
! 6: # May you do good and not evil.
! 7: # May you find forgiveness for yourself and forgive others.
! 8: # May you share freely, never taking more than you give.
! 9: #
! 10: #***********************************************************************
! 11: # This file implements regression tests for SQLite library. The
! 12: # focus of this file is testing the sqlite3_backup_XXX API.
! 13: #
! 14: # $Id: backup.test,v 1.11 2009/06/05 17:09:12 drh Exp $
! 15:
! 16: set testdir [file dirname $argv0]
! 17: source $testdir/tester.tcl
! 18:
! 19: do_not_use_codec
! 20:
! 21: #---------------------------------------------------------------------
! 22: # Test organization:
! 23: #
! 24: # backup-1.*: Warm-body tests.
! 25: #
! 26: # backup-2.*: Test backup under various conditions. To and from in-memory
! 27: # databases. To and from empty/populated databases. etc.
! 28: #
! 29: # backup-3.*: Verify that the locking-page (pending byte page) is handled.
! 30: #
! 31: # backup-4.*: Test various error conditions.
! 32: #
! 33: # backup-5.*: Test the source database being modified during a backup.
! 34: #
! 35: # backup-6.*: Test the backup_remaining() and backup_pagecount() APIs.
! 36: #
! 37: # backup-7.*: Test SQLITE_BUSY and SQLITE_LOCKED errors.
! 38: #
! 39: # backup-8.*: Test multiple simultaneous backup operations.
! 40: #
! 41: # backup-9.*: Test that passing a negative argument to backup_step() is
! 42: # interpreted as "copy the whole file".
! 43: #
! 44: # backup-10.*: Test writing the source database mid backup.
! 45: #
! 46:
! 47: proc data_checksum {db file} { $db one "SELECT md5sum(a, b) FROM ${file}.t1" }
! 48: proc test_contents {name db1 file1 db2 file2} {
! 49: $db2 eval {select * from sqlite_master}
! 50: $db1 eval {select * from sqlite_master}
! 51: set checksum [data_checksum $db2 $file2]
! 52: uplevel [list do_test $name [list data_checksum $db1 $file1] $checksum]
! 53: }
! 54:
! 55: do_test backup-1.1 {
! 56: execsql {
! 57: BEGIN;
! 58: CREATE TABLE t1(a, b);
! 59: CREATE INDEX i1 ON t1(a, b);
! 60: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 61: INSERT INTO t1 VALUES(2, randstr(1000,1000));
! 62: INSERT INTO t1 VALUES(3, randstr(1000,1000));
! 63: INSERT INTO t1 VALUES(4, randstr(1000,1000));
! 64: INSERT INTO t1 VALUES(5, randstr(1000,1000));
! 65: COMMIT;
! 66: }
! 67: } {}
! 68:
! 69: # Sanity check to verify that the [test_contents] proc works.
! 70: #
! 71: test_contents backup-1.2 db main db main
! 72:
! 73: # Check that it is possible to create and finish backup operations.
! 74: #
! 75: do_test backup-1.3.1 {
! 76: delete_file test2.db
! 77: sqlite3 db2 test2.db
! 78: sqlite3_backup B db2 main db main
! 79: } {B}
! 80: do_test backup-1.3.2 {
! 81: B finish
! 82: } {SQLITE_OK}
! 83: do_test backup-1.3.3 {
! 84: info commands B
! 85: } {}
! 86:
! 87: # Simplest backup operation. Backup test.db to test2.db. test2.db is
! 88: # initially empty. test.db uses the default page size.
! 89: #
! 90: do_test backup-1.4.1 {
! 91: sqlite3_backup B db2 main db main
! 92: } {B}
! 93: do_test backup-1.4.2 {
! 94: B step 200
! 95: } {SQLITE_DONE}
! 96: do_test backup-1.4.3 {
! 97: B finish
! 98: } {SQLITE_OK}
! 99: do_test backup-1.4.4 {
! 100: info commands B
! 101: } {}
! 102: test_contents backup-1.4.5 db2 main db main
! 103: db close
! 104: db2 close
! 105: #
! 106: # End of backup-1.* tests.
! 107: #---------------------------------------------------------------------
! 108:
! 109:
! 110: #---------------------------------------------------------------------
! 111: # The following tests, backup-2.*, are based on the following procedure:
! 112: #
! 113: # 1) Populate the source database.
! 114: # 2) Populate the destination database.
! 115: # 3) Run the backup to completion. (backup-2.*.1)
! 116: # 4) Integrity check the destination db. (backup-2.*.2)
! 117: # 5) Check that the contents of the destination db is the same as that
! 118: # of the source db. (backup-2.*.3)
! 119: #
! 120: # The test is run with all possible combinations of the following
! 121: # input parameters, except that if the destination is an in-memory
! 122: # database, the only page size tested is 1024 bytes (the same as the
! 123: # source page-size).
! 124: #
! 125: # * Source database is an in-memory database, OR
! 126: # * Source database is a file-backed database.
! 127: #
! 128: # * Target database is an in-memory database, OR
! 129: # * Target database is a file-backed database.
! 130: #
! 131: # * Destination database is a main file, OR
! 132: # * Destination database is an attached file, OR
! 133: # * Destination database is a temp database.
! 134: #
! 135: # * Target database is empty (zero bytes), OR
! 136: # * Target database is larger than the source, OR
! 137: # * Target database is smaller than the source.
! 138: #
! 139: # * Target database page-size is the same as the source, OR
! 140: # * Target database page-size is larger than the source, OR
! 141: # * Target database page-size is smaller than the source.
! 142: #
! 143: # * Each call to step copies a single page, OR
! 144: # * A single call to step copies the entire source database.
! 145: #
! 146: set iTest 1
! 147: foreach zSrcFile {test.db :memory:} {
! 148: foreach zDestFile {test2.db :memory:} {
! 149: foreach zOpenScript [list {
! 150: sqlite3 db $zSrcFile
! 151: sqlite3 db2 $zSrcFile
! 152: db2 eval "ATTACH '$zDestFile' AS bak"
! 153: set db_dest db2
! 154: set file_dest bak
! 155: } {
! 156: sqlite3 db $zSrcFile
! 157: sqlite3 db2 $zDestFile
! 158: set db_dest db2
! 159: set file_dest main
! 160: } {
! 161: sqlite3 db $zSrcFile
! 162: sqlite3 db2 $zDestFile
! 163: set db_dest db2
! 164: set file_dest temp
! 165: }] {
! 166: foreach rows_dest {0 3 10} {
! 167: foreach pgsz_dest {512 1024 2048} {
! 168: foreach nPagePerStep {1 200} {
! 169:
! 170: # Open the databases.
! 171: catch { delete_file test.db }
! 172: catch { delete_file test2.db }
! 173: eval $zOpenScript
! 174:
! 175: # Set to true if copying to an in-memory destination. Copying to an
! 176: # in-memory destination is only possible if the initial destination
! 177: # page size is the same as the source page size (in this case 1024 bytes).
! 178: #
! 179: set isMemDest [expr {
! 180: $zDestFile eq ":memory:" || $file_dest eq "temp" && $TEMP_STORE>=2
! 181: }]
! 182:
! 183: if { $isMemDest==0 || $pgsz_dest == 1024 } {
! 184: if 0 {
! 185: puts -nonewline "Test $iTest: src=$zSrcFile dest=$zDestFile"
! 186: puts -nonewline " (as $db_dest.$file_dest)"
! 187: puts -nonewline " rows_dest=$rows_dest pgsz_dest=$pgsz_dest"
! 188: puts ""
! 189: }
! 190:
! 191: # Set up the content of the source database.
! 192: execsql {
! 193: PRAGMA page_size = 1024;
! 194: BEGIN;
! 195: CREATE TABLE t1(a, b);
! 196: CREATE INDEX i1 ON t1(a, b);
! 197: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 198: INSERT INTO t1 VALUES(2, randstr(1000,1000));
! 199: INSERT INTO t1 VALUES(3, randstr(1000,1000));
! 200: INSERT INTO t1 VALUES(4, randstr(1000,1000));
! 201: INSERT INTO t1 VALUES(5, randstr(1000,1000));
! 202: COMMIT;
! 203: }
! 204:
! 205:
! 206:
! 207: # Set up the content of the target database.
! 208: execsql "PRAGMA ${file_dest}.page_size = ${pgsz_dest}" $db_dest
! 209: if {$rows_dest != 0} {
! 210: execsql "
! 211: BEGIN;
! 212: CREATE TABLE ${file_dest}.t1(a, b);
! 213: CREATE INDEX ${file_dest}.i1 ON t1(a, b);
! 214: " $db_dest
! 215: for {set ii 0} {$ii < $rows_dest} {incr ii} {
! 216: execsql "
! 217: INSERT INTO ${file_dest}.t1 VALUES(1, randstr(1000,1000))
! 218: " $db_dest
! 219: }
! 220: }
! 221:
! 222: # Backup the source database.
! 223: do_test backup-2.$iTest.1 {
! 224: sqlite3_backup B $db_dest $file_dest db main
! 225: while {[B step $nPagePerStep]=="SQLITE_OK"} {}
! 226: B finish
! 227: } {SQLITE_OK}
! 228:
! 229: # Run integrity check on the backup.
! 230: do_test backup-2.$iTest.2 {
! 231: execsql "PRAGMA ${file_dest}.integrity_check" $db_dest
! 232: } {ok}
! 233:
! 234: test_contents backup-2.$iTest.3 db main $db_dest $file_dest
! 235:
! 236: }
! 237:
! 238: db close
! 239: catch {db2 close}
! 240: incr iTest
! 241:
! 242: } } } } } }
! 243: #
! 244: # End of backup-2.* tests.
! 245: #---------------------------------------------------------------------
! 246:
! 247: #---------------------------------------------------------------------
! 248: # These tests, backup-3.*, ensure that nothing goes wrong if either
! 249: # the source or destination database are large enough to include the
! 250: # the locking-page (the page that contains the range of bytes that
! 251: # the locks are applied to). These tests assume that the pending
! 252: # byte is at offset 0x00010000 (64KB offset), as set by tester.tcl,
! 253: # not at the 1GB offset as it usually is.
! 254: #
! 255: # The test procedure is as follows (same procedure as used for
! 256: # the backup-2.* tests):
! 257: #
! 258: # 1) Populate the source database.
! 259: # 2) Populate the destination database.
! 260: # 3) Run the backup to completion. (backup-3.*.1)
! 261: # 4) Integrity check the destination db. (backup-3.*.2)
! 262: # 5) Check that the contents of the destination db is the same as that
! 263: # of the source db. (backup-3.*.3)
! 264: #
! 265: # The test procedure is run with the following parameters varied:
! 266: #
! 267: # * Source database includes pending-byte page.
! 268: # * Source database does not include pending-byte page.
! 269: #
! 270: # * Target database includes pending-byte page.
! 271: # * Target database does not include pending-byte page.
! 272: #
! 273: # * Target database page-size is the same as the source, OR
! 274: # * Target database page-size is larger than the source, OR
! 275: # * Target database page-size is smaller than the source.
! 276: #
! 277: set iTest 1
! 278: foreach nSrcPg {10 64 65 66 100} {
! 279: foreach nDestRow {10 100} {
! 280: foreach nDestPgsz {512 1024 2048 4096} {
! 281:
! 282: catch { delete_file test.db }
! 283: catch { delete_file test2.db }
! 284: sqlite3 db test.db
! 285: sqlite3 db2 test2.db
! 286:
! 287: # Set up the content of the two databases.
! 288: #
! 289: execsql { PRAGMA page_size = 1024 }
! 290: execsql "PRAGMA page_size = $nDestPgsz" db2
! 291: foreach db {db db2} {
! 292: execsql {
! 293: BEGIN;
! 294: CREATE TABLE t1(a, b);
! 295: CREATE INDEX i1 ON t1(a, b);
! 296: COMMIT;
! 297: } $db
! 298: }
! 299: while {[file size test.db]/1024 < $nSrcPg} {
! 300: execsql { INSERT INTO t1 VALUES($ii, randstr(200,200)) }
! 301: }
! 302:
! 303: for {set ii 0} {$ii < $nDestRow} {incr ii} {
! 304: execsql { INSERT INTO t1 VALUES($ii, randstr(1000,1000)) } db2
! 305: }
! 306:
! 307: # Backup the source database.
! 308: do_test backup-3.$iTest.1 {
! 309: sqlite3_backup B db main db2 main
! 310: while {[B step 10]=="SQLITE_OK"} {}
! 311: B finish
! 312: } {SQLITE_OK}
! 313:
! 314: # Run integrity check on the backup.
! 315: do_test backup-3.$iTest.2 {
! 316: execsql "PRAGMA integrity_check" db2
! 317: } {ok}
! 318:
! 319: test_contents backup-3.$iTest.3 db main db2 main
! 320:
! 321: db close
! 322: db2 close
! 323: incr iTest
! 324: }
! 325: }
! 326: }
! 327:
! 328: #--------------------------------------------------------------------
! 329: do_test backup-3.$iTest.1 {
! 330: catch { forcedelete test.db }
! 331: catch { forcedelete test2.db }
! 332: sqlite3 db test.db
! 333: set iTab 1
! 334:
! 335: db eval { PRAGMA page_size = 512 }
! 336: while {[file size test.db] <= $::sqlite_pending_byte} {
! 337: db eval "CREATE TABLE t${iTab}(a, b, c)"
! 338: incr iTab
! 339: }
! 340:
! 341: sqlite3 db2 test2.db
! 342: db2 eval { PRAGMA page_size = 4096 }
! 343: while {[file size test2.db] < $::sqlite_pending_byte} {
! 344: db2 eval "CREATE TABLE t${iTab}(a, b, c)"
! 345: incr iTab
! 346: }
! 347:
! 348: sqlite3_backup B db2 main db main
! 349: B step -1
! 350: } {SQLITE_DONE}
! 351:
! 352: do_test backup-3.$iTest.2 {
! 353: B finish
! 354: } {SQLITE_OK}
! 355:
! 356: #
! 357: # End of backup-3.* tests.
! 358: #---------------------------------------------------------------------
! 359:
! 360:
! 361: #---------------------------------------------------------------------
! 362: # The following tests, backup-4.*, test various error conditions:
! 363: #
! 364: # backup-4.1.*: Test invalid database names.
! 365: #
! 366: # backup-4.2.*: Test that the source database cannot be detached while
! 367: # a backup is in progress.
! 368: #
! 369: # backup-4.3.*: Test that the source database handle cannot be closed
! 370: # while a backup is in progress.
! 371: #
! 372: # backup-4.4.*: Test an attempt to specify the same handle for the
! 373: # source and destination databases.
! 374: #
! 375: # backup-4.5.*: Test that an in-memory destination with a different
! 376: # page-size to the source database is an error.
! 377: #
! 378: sqlite3 db test.db
! 379: sqlite3 db2 test2.db
! 380:
! 381: do_test backup-4.1.1 {
! 382: catch { sqlite3_backup B db aux db2 main }
! 383: } {1}
! 384: do_test backup-4.1.2 {
! 385: sqlite3_errmsg db
! 386: } {unknown database aux}
! 387: do_test backup-4.1.3 {
! 388: catch { sqlite3_backup B db main db2 aux }
! 389: } {1}
! 390: do_test backup-4.1.4 {
! 391: sqlite3_errmsg db
! 392: } {unknown database aux}
! 393:
! 394: do_test backup-4.2.1 {
! 395: catch { forcedelete test3.db }
! 396: catch { forcedelete test4.db }
! 397: execsql {
! 398: ATTACH 'test3.db' AS aux1;
! 399: CREATE TABLE aux1.t1(a, b);
! 400: }
! 401: execsql {
! 402: ATTACH 'test4.db' AS aux2;
! 403: CREATE TABLE aux2.t2(a, b);
! 404: } db2
! 405: sqlite3_backup B db aux1 db2 aux2
! 406: } {B}
! 407: do_test backup-4.2.2 {
! 408: catchsql { DETACH aux2 } db2
! 409: } {1 {database aux2 is locked}}
! 410: do_test backup-4.2.3 {
! 411: B step 50
! 412: } {SQLITE_DONE}
! 413: do_test backup-4.2.4 {
! 414: B finish
! 415: } {SQLITE_OK}
! 416:
! 417: do_test backup-4.3.1 {
! 418: sqlite3_backup B db aux1 db2 aux2
! 419: } {B}
! 420: do_test backup-4.3.2 {
! 421: db2 cache flush
! 422: sqlite3_close db2
! 423: } {SQLITE_BUSY}
! 424: do_test backup-4.3.3 {
! 425: sqlite3_errmsg db2
! 426: } {unable to close due to unfinished backup operation}
! 427: do_test backup-4.3.4 {
! 428: B step 50
! 429: } {SQLITE_DONE}
! 430: do_test backup-4.3.5 {
! 431: B finish
! 432: } {SQLITE_OK}
! 433:
! 434: do_test backup-4.4.1 {
! 435: set rc [catch {sqlite3_backup B db main db aux1}]
! 436: list $rc [sqlite3_errcode db] [sqlite3_errmsg db]
! 437: } {1 SQLITE_ERROR {source and destination must be distinct}}
! 438: db close
! 439: db2 close
! 440:
! 441: do_test backup-4.5.1 {
! 442: catch { forcedelete test.db }
! 443: sqlite3 db test.db
! 444: sqlite3 db2 :memory:
! 445: execsql {
! 446: CREATE TABLE t1(a, b);
! 447: INSERT INTO t1 VALUES(1, 2);
! 448: }
! 449: execsql {
! 450: PRAGMA page_size = 4096;
! 451: CREATE TABLE t2(a, b);
! 452: INSERT INTO t2 VALUES(3, 4);
! 453: } db2
! 454: sqlite3_backup B db2 main db main
! 455: } {B}
! 456: do_test backup-4.5.2 {
! 457: B step 5000
! 458: } {SQLITE_READONLY}
! 459: do_test backup-4.5.3 {
! 460: B finish
! 461: } {SQLITE_READONLY}
! 462:
! 463: db close
! 464: db2 close
! 465: #
! 466: # End of backup-5.* tests.
! 467: #---------------------------------------------------------------------
! 468:
! 469: #---------------------------------------------------------------------
! 470: # The following tests, backup-5.*, test that the backup works properly
! 471: # when the source database is modified during the backup. Test cases
! 472: # are organized as follows:
! 473: #
! 474: # backup-5.x.1.*: Nothing special. Modify the database mid-backup.
! 475: #
! 476: # backup-5.x.2.*: Modify the database mid-backup so that one or more
! 477: # pages are written out due to cache stress. Then
! 478: # rollback the transaction.
! 479: #
! 480: # backup-5.x.3.*: Database is vacuumed.
! 481: #
! 482: # backup-5.x.4.*: Database is vacuumed and the page-size modified.
! 483: #
! 484: # backup-5.x.5.*: Database is shrunk via incr-vacuum.
! 485: #
! 486: # Each test is run three times, in the following configurations:
! 487: #
! 488: # 1) Backing up file-to-file. The writer writes via an external pager.
! 489: # 2) Backing up file-to-file. The writer writes via the same pager as
! 490: # is used by the backup operation.
! 491: # 3) Backing up memory-to-file.
! 492: #
! 493: set iTest 0
! 494: forcedelete bak.db-wal
! 495: foreach {writer file} {db test.db db3 test.db db :memory:} {
! 496: incr iTest
! 497: catch { delete_file bak.db }
! 498: sqlite3 db2 bak.db
! 499: catch { delete_file $file }
! 500: sqlite3 db $file
! 501: sqlite3 db3 $file
! 502:
! 503: do_test backup-5.$iTest.1.1 {
! 504: execsql {
! 505: BEGIN;
! 506: CREATE TABLE t1(a, b);
! 507: CREATE INDEX i1 ON t1(a, b);
! 508: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 509: INSERT INTO t1 VALUES(2, randstr(1000,1000));
! 510: INSERT INTO t1 VALUES(3, randstr(1000,1000));
! 511: INSERT INTO t1 VALUES(4, randstr(1000,1000));
! 512: INSERT INTO t1 VALUES(5, randstr(1000,1000));
! 513: COMMIT;
! 514: }
! 515: expr {[execsql {PRAGMA page_count}] > 10}
! 516: } {1}
! 517: do_test backup-5.$iTest.1.2 {
! 518: sqlite3_backup B db2 main db main
! 519: B step 5
! 520: } {SQLITE_OK}
! 521: do_test backup-5.$iTest.1.3 {
! 522: execsql { UPDATE t1 SET a = a + 1 } $writer
! 523: B step 50
! 524: } {SQLITE_DONE}
! 525: do_test backup-5.$iTest.1.4 {
! 526: B finish
! 527: } {SQLITE_OK}
! 528: integrity_check backup-5.$iTest.1.5 db2
! 529: test_contents backup-5.$iTest.1.6 db main db2 main
! 530:
! 531: do_test backup-5.$iTest.2.1 {
! 532: execsql {
! 533: PRAGMA cache_size = 10;
! 534: BEGIN;
! 535: INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
! 536: INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
! 537: INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
! 538: INSERT INTO t1 SELECT '', randstr(1000,1000) FROM t1;
! 539: COMMIT;
! 540: }
! 541: } {}
! 542: do_test backup-5.$iTest.2.2 {
! 543: sqlite3_backup B db2 main db main
! 544: B step 50
! 545: } {SQLITE_OK}
! 546: do_test backup-5.$iTest.2.3 {
! 547: execsql {
! 548: BEGIN;
! 549: UPDATE t1 SET a = a + 1;
! 550: ROLLBACK;
! 551: } $writer
! 552: B step 5000
! 553: } {SQLITE_DONE}
! 554: do_test backup-5.$iTest.2.4 {
! 555: B finish
! 556: } {SQLITE_OK}
! 557: integrity_check backup-5.$iTest.2.5 db2
! 558: test_contents backup-5.$iTest.2.6 db main db2 main
! 559:
! 560: do_test backup-5.$iTest.3.1 {
! 561: execsql { UPDATE t1 SET b = randstr(1000,1000) }
! 562: } {}
! 563: do_test backup-5.$iTest.3.2 {
! 564: sqlite3_backup B db2 main db main
! 565: B step 50
! 566: } {SQLITE_OK}
! 567: do_test backup-5.$iTest.3.3 {
! 568: execsql { VACUUM } $writer
! 569: B step 5000
! 570: } {SQLITE_DONE}
! 571: do_test backup-5.$iTest.3.4 {
! 572: B finish
! 573: } {SQLITE_OK}
! 574: integrity_check backup-5.$iTest.3.5 db2
! 575: test_contents backup-5.$iTest.3.6 db main db2 main
! 576:
! 577: do_test backup-5.$iTest.4.1 {
! 578: execsql { UPDATE t1 SET b = randstr(1000,1000) }
! 579: } {}
! 580: do_test backup-5.$iTest.4.2 {
! 581: sqlite3_backup B db2 main db main
! 582: B step 50
! 583: } {SQLITE_OK}
! 584: do_test backup-5.$iTest.4.3 {
! 585: execsql {
! 586: PRAGMA page_size = 2048;
! 587: VACUUM;
! 588: } $writer
! 589: B step 5000
! 590: } {SQLITE_DONE}
! 591: do_test backup-5.$iTest.4.4 {
! 592: B finish
! 593: } {SQLITE_OK}
! 594: integrity_check backup-5.$iTest.4.5 db2
! 595: test_contents backup-5.$iTest.4.6 db main db2 main
! 596:
! 597: catch {db close}
! 598: catch {db2 close}
! 599: catch {db3 close}
! 600: catch { delete_file bak.db }
! 601: sqlite3 db2 bak.db
! 602: catch { delete_file $file }
! 603: sqlite3 db $file
! 604: sqlite3 db3 $file
! 605: do_test backup-5.$iTest.5.1 {
! 606: execsql {
! 607: PRAGMA auto_vacuum = incremental;
! 608: BEGIN;
! 609: CREATE TABLE t1(a, b);
! 610: CREATE INDEX i1 ON t1(a, b);
! 611: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 612: INSERT INTO t1 VALUES(2, randstr(1000,1000));
! 613: INSERT INTO t1 VALUES(3, randstr(1000,1000));
! 614: INSERT INTO t1 VALUES(4, randstr(1000,1000));
! 615: INSERT INTO t1 VALUES(5, randstr(1000,1000));
! 616: COMMIT;
! 617: }
! 618: } {}
! 619: do_test backup-5.$iTest.5.2 {
! 620: sqlite3_backup B db2 main db main
! 621: B step 8
! 622: } {SQLITE_OK}
! 623: do_test backup-5.$iTest.5.3 {
! 624: execsql {
! 625: DELETE FROM t1;
! 626: PRAGMA incremental_vacuum;
! 627: } $writer
! 628: B step 50
! 629: } {SQLITE_DONE}
! 630: do_test backup-5.$iTest.5.4 {
! 631: B finish
! 632: } {SQLITE_OK}
! 633: integrity_check backup-5.$iTest.5.5 db2
! 634: test_contents backup-5.$iTest.5.6 db main db2 main
! 635: catch {db close}
! 636: catch {db2 close}
! 637: catch {db3 close}
! 638: }
! 639: #
! 640: # End of backup-5.* tests.
! 641: #---------------------------------------------------------------------
! 642:
! 643: #---------------------------------------------------------------------
! 644: # Test the sqlite3_backup_remaining() and backup_pagecount() APIs.
! 645: #
! 646: do_test backup-6.1 {
! 647: catch { forcedelete test.db }
! 648: catch { forcedelete test2.db }
! 649: sqlite3 db test.db
! 650: sqlite3 db2 test2.db
! 651: execsql {
! 652: BEGIN;
! 653: CREATE TABLE t1(a, b);
! 654: CREATE INDEX i1 ON t1(a, b);
! 655: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 656: INSERT INTO t1 VALUES(2, randstr(1000,1000));
! 657: INSERT INTO t1 VALUES(3, randstr(1000,1000));
! 658: INSERT INTO t1 VALUES(4, randstr(1000,1000));
! 659: INSERT INTO t1 VALUES(5, randstr(1000,1000));
! 660: COMMIT;
! 661: }
! 662: } {}
! 663: do_test backup-6.2 {
! 664: set nTotal [expr {[file size test.db]/1024}]
! 665: sqlite3_backup B db2 main db main
! 666: B step 1
! 667: } {SQLITE_OK}
! 668: do_test backup-6.3 {
! 669: B pagecount
! 670: } $nTotal
! 671: do_test backup-6.4 {
! 672: B remaining
! 673: } [expr $nTotal-1]
! 674: do_test backup-6.5 {
! 675: B step 5
! 676: list [B remaining] [B pagecount]
! 677: } [list [expr $nTotal-6] $nTotal]
! 678: do_test backup-6.6 {
! 679: execsql { CREATE TABLE t2(a PRIMARY KEY, b) }
! 680: B step 1
! 681: list [B remaining] [B pagecount]
! 682: } [list [expr $nTotal-5] [expr $nTotal+2]]
! 683:
! 684: do_test backup-6.X {
! 685: B finish
! 686: } {SQLITE_OK}
! 687:
! 688: catch {db close}
! 689: catch {db2 close}
! 690:
! 691: #---------------------------------------------------------------------
! 692: # Test cases backup-7.* test that SQLITE_BUSY and SQLITE_LOCKED errors
! 693: # are returned correctly:
! 694: #
! 695: # backup-7.1.*: Source database is externally locked (return SQLITE_BUSY).
! 696: #
! 697: # backup-7.2.*: Attempt to step the backup process while a
! 698: # write-transaction is underway on the source pager (return
! 699: # SQLITE_LOCKED).
! 700: #
! 701: # backup-7.3.*: Destination database is externally locked (return SQLITE_BUSY).
! 702: #
! 703: do_test backup-7.0 {
! 704: catch { forcedelete test.db }
! 705: catch { forcedelete test2.db }
! 706: sqlite3 db2 test2.db
! 707: sqlite3 db test.db
! 708: execsql {
! 709: CREATE TABLE t1(a, b);
! 710: CREATE INDEX i1 ON t1(a, b);
! 711: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 712: INSERT INTO t1 SELECT a+ 1, randstr(1000,1000) FROM t1;
! 713: INSERT INTO t1 SELECT a+ 2, randstr(1000,1000) FROM t1;
! 714: INSERT INTO t1 SELECT a+ 4, randstr(1000,1000) FROM t1;
! 715: INSERT INTO t1 SELECT a+ 8, randstr(1000,1000) FROM t1;
! 716: INSERT INTO t1 SELECT a+16, randstr(1000,1000) FROM t1;
! 717: INSERT INTO t1 SELECT a+32, randstr(1000,1000) FROM t1;
! 718: INSERT INTO t1 SELECT a+64, randstr(1000,1000) FROM t1;
! 719: }
! 720: } {}
! 721:
! 722: do_test backup-7.1.1 {
! 723: sqlite3_backup B db2 main db main
! 724: B step 5
! 725: } {SQLITE_OK}
! 726: do_test backup-7.1.2 {
! 727: sqlite3 db3 test.db
! 728: execsql { BEGIN EXCLUSIVE } db3
! 729: B step 5
! 730: } {SQLITE_BUSY}
! 731: do_test backup-7.1.3 {
! 732: execsql { ROLLBACK } db3
! 733: B step 5
! 734: } {SQLITE_OK}
! 735: do_test backup-7.2.1 {
! 736: execsql {
! 737: BEGIN;
! 738: INSERT INTO t1 VALUES(1, 4);
! 739: }
! 740: } {}
! 741: do_test backup-7.2.2 {
! 742: B step 5000
! 743: } {SQLITE_BUSY}
! 744: do_test backup-7.2.3 {
! 745: execsql { ROLLBACK }
! 746: B step 5000
! 747: } {SQLITE_DONE}
! 748: do_test backup-7.2.4 {
! 749: B finish
! 750: } {SQLITE_OK}
! 751: test_contents backup-7.2.5 db main db2 main
! 752: integrity_check backup-7.3.6 db2
! 753:
! 754: do_test backup-7.3.1 {
! 755: db2 close
! 756: db3 close
! 757: forcedelete test2.db
! 758: sqlite3 db2 test2.db
! 759: sqlite3 db3 test2.db
! 760:
! 761: sqlite3_backup B db2 main db main
! 762: execsql { BEGIN ; CREATE TABLE t2(a, b); } db3
! 763:
! 764: B step 5
! 765: } {SQLITE_BUSY}
! 766: do_test backup-7.3.2 {
! 767: execsql { COMMIT } db3
! 768: B step 5000
! 769: } {SQLITE_DONE}
! 770: do_test backup-7.3.3 {
! 771: B finish
! 772: } {SQLITE_OK}
! 773: test_contents backup-7.3.4 db main db2 main
! 774: integrity_check backup-7.3.5 db2
! 775: catch { db2 close }
! 776: catch { db3 close }
! 777:
! 778: #-----------------------------------------------------------------------
! 779: # The following tests, backup-8.*, test attaching multiple backup
! 780: # processes to the same source database. Also, reading from the source
! 781: # database while a read transaction is active.
! 782: #
! 783: # These tests reuse the database "test.db" left over from backup-7.*.
! 784: #
! 785: do_test backup-8.1 {
! 786: catch { forcedelete test2.db }
! 787: catch { forcedelete test3.db }
! 788: sqlite3 db2 test2.db
! 789: sqlite3 db3 test3.db
! 790:
! 791: sqlite3_backup B2 db2 main db main
! 792: sqlite3_backup B3 db3 main db main
! 793: list [B2 finish] [B3 finish]
! 794: } {SQLITE_OK SQLITE_OK}
! 795: do_test backup-8.2 {
! 796: sqlite3_backup B3 db3 main db main
! 797: sqlite3_backup B2 db2 main db main
! 798: list [B2 finish] [B3 finish]
! 799: } {SQLITE_OK SQLITE_OK}
! 800: do_test backup-8.3 {
! 801: sqlite3_backup B2 db2 main db main
! 802: sqlite3_backup B3 db3 main db main
! 803: B2 step 5
! 804: } {SQLITE_OK}
! 805: do_test backup-8.4 {
! 806: execsql {
! 807: BEGIN;
! 808: SELECT * FROM sqlite_master;
! 809: }
! 810: B3 step 5
! 811: } {SQLITE_OK}
! 812: do_test backup-8.5 {
! 813: list [B3 step 5000] [B3 finish]
! 814: } {SQLITE_DONE SQLITE_OK}
! 815: do_test backup-8.6 {
! 816: list [B2 step 5000] [B2 finish]
! 817: } {SQLITE_DONE SQLITE_OK}
! 818: test_contents backup-8.7 db main db2 main
! 819: test_contents backup-8.8 db main db3 main
! 820: do_test backup-8.9 {
! 821: execsql { PRAGMA lock_status }
! 822: } {main shared temp closed}
! 823: do_test backup-8.10 {
! 824: execsql COMMIT
! 825: } {}
! 826: catch { db2 close }
! 827: catch { db3 close }
! 828:
! 829: #-----------------------------------------------------------------------
! 830: # The following tests, backup-9.*, test that:
! 831: #
! 832: # * Passing 0 as an argument to sqlite3_backup_step() means no pages
! 833: # are backed up (backup-9.1.*), and
! 834: # * Passing a negative value as an argument to sqlite3_backup_step() means
! 835: # all pages are backed up (backup-9.2.*).
! 836: #
! 837: # These tests reuse the database "test.db" left over from backup-7.*.
! 838: #
! 839: do_test backup-9.1.1 {
! 840: sqlite3 db2 test2.db
! 841: sqlite3_backup B db2 main db main
! 842: B step 1
! 843: } {SQLITE_OK}
! 844: do_test backup-9.1.2 {
! 845: set nRemaining [B remaining]
! 846: expr {$nRemaining>100}
! 847: } {1}
! 848: do_test backup-9.1.3 {
! 849: B step 0
! 850: } {SQLITE_OK}
! 851: do_test backup-9.1.4 {
! 852: B remaining
! 853: } $nRemaining
! 854:
! 855: do_test backup-9.2.1 {
! 856: B step -1
! 857: } {SQLITE_DONE}
! 858: do_test backup-9.2.2 {
! 859: B remaining
! 860: } {0}
! 861: do_test backup-9.2.3 {
! 862: B finish
! 863: } {SQLITE_OK}
! 864: catch {db2 close}
! 865:
! 866: ifcapable memorymanage {
! 867: db close
! 868: forcedelete test.db
! 869: forcedelete bak.db
! 870:
! 871: sqlite3 db test.db
! 872: sqlite3 db2 test.db
! 873: sqlite3 db3 bak.db
! 874:
! 875: do_test backup-10.1.1 {
! 876: execsql {
! 877: BEGIN;
! 878: CREATE TABLE t1(a, b);
! 879: INSERT INTO t1 VALUES(1, randstr(1000,1000));
! 880: INSERT INTO t1 VALUES(2, randstr(1000,1000));
! 881: INSERT INTO t1 VALUES(3, randstr(1000,1000));
! 882: INSERT INTO t1 VALUES(4, randstr(1000,1000));
! 883: INSERT INTO t1 VALUES(5, randstr(1000,1000));
! 884: CREATE INDEX i1 ON t1(a, b);
! 885: COMMIT;
! 886: }
! 887: } {}
! 888: do_test backup-10.1.2 {
! 889: sqlite3_backup B db3 main db2 main
! 890: B step 5
! 891: } {SQLITE_OK}
! 892: do_test backup-10.1.3 {
! 893: execsql {
! 894: UPDATE t1 SET b = randstr(500,500);
! 895: }
! 896: } {}
! 897: sqlite3_release_memory [expr 1024*1024]
! 898: do_test backup-10.1.3 {
! 899: B step 50
! 900: } {SQLITE_DONE}
! 901: do_test backup-10.1.4 {
! 902: B finish
! 903: } {SQLITE_OK}
! 904: do_test backup-10.1.5 {
! 905: execsql { PRAGMA integrity_check } db3
! 906: } {ok}
! 907:
! 908: db2 close
! 909: db3 close
! 910: }
! 911:
! 912:
! 913: #-----------------------------------------------------------------------
! 914: # Test that if the database is written to via the same database handle being
! 915: # used as the source by a backup operation:
! 916: #
! 917: # 10.1.*: If the db is in-memory, the backup is restarted.
! 918: # 10.2.*: If the db is a file, the backup is not restarted.
! 919: #
! 920: db close
! 921: forcedelete test.db test.db-journal
! 922: foreach {tn file rc} {
! 923: 1 test.db SQLITE_DONE
! 924: 2 :memory: SQLITE_OK
! 925: } {
! 926: do_test backup-10.$tn.1 {
! 927: sqlite3 db $file
! 928: execsql {
! 929: CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB);
! 930: BEGIN;
! 931: INSERT INTO t1 VALUES(NULL, randomblob(200));
! 932: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 933: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 934: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 935: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 936: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 937: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 938: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 939: INSERT INTO t1 SELECT NULL, randomblob(200) FROM t1;
! 940: COMMIT;
! 941: SELECT count(*) FROM t1;
! 942: }
! 943: } {256}
! 944:
! 945: do_test backup-10.$tn.2 {
! 946: set pgs [execsql {pragma page_count}]
! 947: expr {$pgs > 50 && $pgs < 75}
! 948: } {1}
! 949:
! 950: do_test backup-10.$tn.3 {
! 951: forcedelete bak.db bak.db-journal
! 952: sqlite3 db2 bak.db
! 953: sqlite3_backup B db2 main db main
! 954: B step 50
! 955: } {SQLITE_OK}
! 956:
! 957: do_test backup-10.$tn.4 {
! 958: execsql { UPDATE t1 SET b = randomblob(200) WHERE a IN (1, 250) }
! 959: } {}
! 960:
! 961: do_test backup-10.$tn.5 {
! 962: B step 50
! 963: } $rc
! 964:
! 965: do_test backup-10.$tn.6 {
! 966: B finish
! 967: } {SQLITE_OK}
! 968:
! 969: db2 close
! 970: }
! 971:
! 972: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to backup.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test