Annotation of embedaddon/sqlite3/test/wal3.test, revision 1.1
1.1 ! misho 1: # 2010 April 13
! 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 operation of the library in
! 13: # "PRAGMA journal_mode=WAL" mode.
! 14: #
! 15:
! 16: set testdir [file dirname $argv0]
! 17: source $testdir/tester.tcl
! 18: source $testdir/lock_common.tcl
! 19: source $testdir/wal_common.tcl
! 20: source $testdir/malloc_common.tcl
! 21: ifcapable !wal {finish_test ; return }
! 22:
! 23: set a_string_counter 1
! 24: proc a_string {n} {
! 25: global a_string_counter
! 26: incr a_string_counter
! 27: string range [string repeat "${a_string_counter}." $n] 1 $n
! 28: }
! 29: db func a_string a_string
! 30:
! 31: #-------------------------------------------------------------------------
! 32: # When a rollback or savepoint rollback occurs, the client may remove
! 33: # elements from one of the hash tables in the wal-index. This block
! 34: # of test cases tests that nothing appears to go wrong when this is
! 35: # done.
! 36: #
! 37: do_test wal3-1.0 {
! 38: execsql {
! 39: PRAGMA cache_size = 2000;
! 40: PRAGMA page_size = 1024;
! 41: PRAGMA auto_vacuum = off;
! 42: PRAGMA synchronous = normal;
! 43: PRAGMA journal_mode = WAL;
! 44: PRAGMA wal_autocheckpoint = 0;
! 45: BEGIN;
! 46: CREATE TABLE t1(x);
! 47: INSERT INTO t1 VALUES( a_string(800) ); /* 1 */
! 48: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2 */
! 49: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 4 */
! 50: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 8 */
! 51: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 16 */
! 52: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 32 */
! 53: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 64 */
! 54: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 128*/
! 55: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 256 */
! 56: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 512 */
! 57: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 1024 */
! 58: INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2048 */
! 59: INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 1970; /* 4018 */
! 60: COMMIT;
! 61: PRAGMA cache_size = 10;
! 62: }
! 63: wal_frame_count test.db-wal 1024
! 64: } 4056
! 65:
! 66: for {set i 1} {$i < 50} {incr i} {
! 67:
! 68: do_test wal3-1.$i.1 {
! 69: set str [a_string 800]
! 70: execsql { UPDATE t1 SET x = $str WHERE rowid = $i }
! 71: lappend L [wal_frame_count test.db-wal 1024]
! 72: execsql {
! 73: BEGIN;
! 74: INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 100;
! 75: ROLLBACK;
! 76: PRAGMA integrity_check;
! 77: }
! 78: } {ok}
! 79:
! 80: # Check that everything looks OK from the point of view of an
! 81: # external connection.
! 82: #
! 83: sqlite3 db2 test.db
! 84: do_test wal3-1.$i.2 {
! 85: execsql { SELECT count(*) FROM t1 } db2
! 86: } 4018
! 87: do_test wal3-1.$i.3 {
! 88: execsql { SELECT x FROM t1 WHERE rowid = $i }
! 89: } $str
! 90: do_test wal3-1.$i.4 {
! 91: execsql { PRAGMA integrity_check } db2
! 92: } {ok}
! 93: db2 close
! 94:
! 95: # Check that the file-system in its current state can be recovered.
! 96: #
! 97: forcecopy test.db test2.db
! 98: forcecopy test.db-wal test2.db-wal
! 99: forcedelete test2.db-journal
! 100: sqlite3 db2 test2.db
! 101: do_test wal3-1.$i.5 {
! 102: execsql { SELECT count(*) FROM t1 } db2
! 103: } 4018
! 104: do_test wal3-1.$i.6 {
! 105: execsql { SELECT x FROM t1 WHERE rowid = $i }
! 106: } $str
! 107: do_test wal3-1.$i.7 {
! 108: execsql { PRAGMA integrity_check } db2
! 109: } {ok}
! 110: db2 close
! 111: }
! 112:
! 113: proc byte_is_zero {file offset} {
! 114: if {[file size test.db] <= $offset} { return 1 }
! 115: expr { [hexio_read $file $offset 1] == "00" }
! 116: }
! 117:
! 118: do_multiclient_test i {
! 119:
! 120: set testname(1) multiproc
! 121: set testname(2) singleproc
! 122: set tn $testname($i)
! 123:
! 124: do_test wal3-2.$tn.1 {
! 125: sql1 {
! 126: PRAGMA page_size = 1024;
! 127: PRAGMA journal_mode = WAL;
! 128: }
! 129: sql1 {
! 130: CREATE TABLE t1(a, b);
! 131: INSERT INTO t1 VALUES(1, 'one');
! 132: BEGIN;
! 133: SELECT * FROM t1;
! 134: }
! 135: } {1 one}
! 136: do_test wal3-2.$tn.2 {
! 137: sql2 {
! 138: CREATE TABLE t2(a, b);
! 139: INSERT INTO t2 VALUES(2, 'two');
! 140: BEGIN;
! 141: SELECT * FROM t2;
! 142: }
! 143: } {2 two}
! 144: do_test wal3-2.$tn.3 {
! 145: sql3 {
! 146: CREATE TABLE t3(a, b);
! 147: INSERT INTO t3 VALUES(3, 'three');
! 148: BEGIN;
! 149: SELECT * FROM t3;
! 150: }
! 151: } {3 three}
! 152:
! 153: # Try to checkpoint the database using [db]. It should be possible to
! 154: # checkpoint everything except the table added by [db3] (checkpointing
! 155: # these frames would clobber the snapshot currently being used by [db2]).
! 156: #
! 157: # After [db2] has committed, a checkpoint can copy the entire log to the
! 158: # database file. Checkpointing after [db3] has committed is therefore a
! 159: # no-op, as the entire log has already been backfilled.
! 160: #
! 161: do_test wal3-2.$tn.4 {
! 162: sql1 {
! 163: COMMIT;
! 164: PRAGMA wal_checkpoint;
! 165: }
! 166: byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]
! 167: } {1}
! 168: do_test wal3-2.$tn.5 {
! 169: sql2 {
! 170: COMMIT;
! 171: PRAGMA wal_checkpoint;
! 172: }
! 173: list [byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]] \
! 174: [byte_is_zero test.db [expr $AUTOVACUUM ? 5*1024 : 4*1024]]
! 175: } {0 1}
! 176: do_test wal3-2.$tn.6 {
! 177: sql3 {
! 178: COMMIT;
! 179: PRAGMA wal_checkpoint;
! 180: }
! 181: list [byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]] \
! 182: [byte_is_zero test.db [expr $AUTOVACUUM ? 5*1024 : 4*1024]]
! 183: } {0 1}
! 184: }
! 185: catch {db close}
! 186:
! 187: #-------------------------------------------------------------------------
! 188: # Test that that for the simple test:
! 189: #
! 190: # CREATE TABLE x(y);
! 191: # INSERT INTO x VALUES('z');
! 192: # PRAGMA wal_checkpoint;
! 193: #
! 194: # in WAL mode the xSync method is invoked as expected for each of
! 195: # synchronous=off, synchronous=normal and synchronous=full.
! 196: #
! 197: foreach {tn syncmode synccount} {
! 198: 1 off
! 199: {}
! 200: 2 normal
! 201: {test.db-wal normal test.db normal}
! 202: 3 full
! 203: {test.db-wal normal test.db-wal normal test.db-wal normal test.db normal}
! 204: } {
! 205:
! 206: proc sync_counter {args} {
! 207: foreach {method filename id flags} $args break
! 208: lappend ::syncs [file tail $filename] $flags
! 209: }
! 210: do_test wal3-3.$tn {
! 211: forcedelete test.db test.db-wal test.db-journal
! 212:
! 213: testvfs T
! 214: T filter {}
! 215: T script sync_counter
! 216: sqlite3 db test.db -vfs T
! 217:
! 218: execsql "PRAGMA synchronous = $syncmode"
! 219: execsql { PRAGMA journal_mode = WAL }
! 220: execsql { CREATE TABLE filler(a,b,c); }
! 221:
! 222: set ::syncs [list]
! 223: T filter xSync
! 224: execsql {
! 225: CREATE TABLE x(y);
! 226: INSERT INTO x VALUES('z');
! 227: PRAGMA wal_checkpoint;
! 228: }
! 229: T filter {}
! 230: set ::syncs
! 231: } $synccount
! 232:
! 233: db close
! 234: T delete
! 235: }
! 236:
! 237: #-------------------------------------------------------------------------
! 238: # When recovering the contents of a WAL file, a process obtains the WRITER
! 239: # lock, then locks all other bytes before commencing recovery. If it fails
! 240: # to lock all other bytes (because some other process is holding a read
! 241: # lock) it should retry up to 100 times. Then return SQLITE_PROTOCOL to the
! 242: # caller. Test this (test case wal3-4.3).
! 243: #
! 244: # Also test the effect of hitting an SQLITE_BUSY while attempting to obtain
! 245: # the WRITER lock (should be the same). Test case wal3-4.4.
! 246: #
! 247: proc lock_callback {method filename handle lock} {
! 248: lappend ::locks $lock
! 249: }
! 250: do_test wal3-4.1 {
! 251: testvfs T
! 252: T filter xShmLock
! 253: T script lock_callback
! 254: set ::locks [list]
! 255: sqlite3 db test.db -vfs T
! 256: execsql { SELECT * FROM x }
! 257: lrange $::locks 0 3
! 258: } [list {0 1 lock exclusive} {1 7 lock exclusive} \
! 259: {1 7 unlock exclusive} {0 1 unlock exclusive} \
! 260: ]
! 261: do_test wal3-4.2 {
! 262: db close
! 263: set ::locks [list]
! 264: sqlite3 db test.db -vfs T
! 265: execsql { SELECT * FROM x }
! 266: lrange $::locks 0 3
! 267: } [list {0 1 lock exclusive} {1 7 lock exclusive} \
! 268: {1 7 unlock exclusive} {0 1 unlock exclusive} \
! 269: ]
! 270: proc lock_callback {method filename handle lock} {
! 271: if {$lock == "1 7 lock exclusive"} { return SQLITE_BUSY }
! 272: return SQLITE_OK
! 273: }
! 274: puts " Warning: This next test case causes SQLite to call xSleep(1) 100 times."
! 275: puts " Normally this equates to a 100ms delay, but if SQLite is built on unix"
! 276: puts " without HAVE_USLEEP defined, it may be 100 seconds."
! 277: do_test wal3-4.3 {
! 278: db close
! 279: set ::locks [list]
! 280: sqlite3 db test.db -vfs T
! 281: catchsql { SELECT * FROM x }
! 282: } {1 {locking protocol}}
! 283:
! 284: puts " Warning: Same again!"
! 285: proc lock_callback {method filename handle lock} {
! 286: if {$lock == "0 1 lock exclusive"} { return SQLITE_BUSY }
! 287: return SQLITE_OK
! 288: }
! 289: do_test wal3-4.4 {
! 290: db close
! 291: set ::locks [list]
! 292: sqlite3 db test.db -vfs T
! 293: catchsql { SELECT * FROM x }
! 294: } {1 {locking protocol}}
! 295: db close
! 296: T delete
! 297:
! 298:
! 299: #-------------------------------------------------------------------------
! 300: # Only one client may run recovery at a time. Test this mechanism.
! 301: #
! 302: # When client-2 tries to open a read transaction while client-1 is
! 303: # running recovery, it fails to obtain a lock on an aReadMark[] slot
! 304: # (because they are all locked by recovery). It then tries to obtain
! 305: # a shared lock on the RECOVER lock to see if there really is a
! 306: # recovery running or not.
! 307: #
! 308: # This block of tests checks the effect of an SQLITE_BUSY or SQLITE_IOERR
! 309: # being returned when client-2 attempts a shared lock on the RECOVER byte.
! 310: #
! 311: # An SQLITE_BUSY should be converted to an SQLITE_BUSY_RECOVERY. An
! 312: # SQLITE_IOERR should be returned to the caller.
! 313: #
! 314: do_test wal3-5.1 {
! 315: faultsim_delete_and_reopen
! 316: execsql {
! 317: PRAGMA journal_mode = WAL;
! 318: CREATE TABLE t1(a, b);
! 319: INSERT INTO t1 VALUES(1, 2);
! 320: INSERT INTO t1 VALUES(3, 4);
! 321: }
! 322: faultsim_save_and_close
! 323: } {}
! 324:
! 325: testvfs T -default 1
! 326: T script method_callback
! 327:
! 328: proc method_callback {method args} {
! 329: if {$method == "xShmBarrier"} {
! 330: incr ::barrier_count
! 331: if {$::barrier_count == 2} {
! 332: # This code is executed within the xShmBarrier() callback invoked
! 333: # by the client running recovery as part of writing the recovered
! 334: # wal-index header. If a second client attempts to access the
! 335: # database now, it reads a corrupt (partially written) wal-index
! 336: # header. But it cannot even get that far, as the first client
! 337: # is still holding all the locks (recovery takes an exclusive lock
! 338: # on *all* db locks, preventing access by any other client).
! 339: #
! 340: # If global variable ::wal3_do_lockfailure is non-zero, then set
! 341: # things up so that an IO error occurs within an xShmLock() callback
! 342: # made by the second client (aka [db2]).
! 343: #
! 344: sqlite3 db2 test.db
! 345: if { $::wal3_do_lockfailure } { T filter xShmLock }
! 346: set ::testrc [ catch { db2 eval "SELECT * FROM t1" } ::testmsg ]
! 347: T filter {}
! 348: db2 close
! 349: }
! 350: }
! 351:
! 352: if {$method == "xShmLock"} {
! 353: foreach {file handle spec} $args break
! 354: if { $spec == "2 1 lock shared" } {
! 355: return SQLITE_IOERR
! 356: }
! 357: }
! 358:
! 359: return SQLITE_OK
! 360: }
! 361:
! 362: # Test a normal SQLITE_BUSY return.
! 363: #
! 364: T filter xShmBarrier
! 365: set testrc ""
! 366: set testmsg ""
! 367: set barrier_count 0
! 368: set wal3_do_lockfailure 0
! 369: do_test wal3-5.2 {
! 370: faultsim_restore_and_reopen
! 371: execsql { SELECT * FROM t1 }
! 372: } {1 2 3 4}
! 373: do_test wal3-5.3 {
! 374: list $::testrc $::testmsg
! 375: } {1 {database is locked}}
! 376: db close
! 377:
! 378: # Test an SQLITE_IOERR return.
! 379: #
! 380: T filter xShmBarrier
! 381: set barrier_count 0
! 382: set wal3_do_lockfailure 1
! 383: set testrc ""
! 384: set testmsg ""
! 385: do_test wal3-5.4 {
! 386: faultsim_restore_and_reopen
! 387: execsql { SELECT * FROM t1 }
! 388: } {1 2 3 4}
! 389: do_test wal3-5.5 {
! 390: list $::testrc $::testmsg
! 391: } {1 {disk I/O error}}
! 392:
! 393: db close
! 394: T delete
! 395:
! 396: #-------------------------------------------------------------------------
! 397: # When opening a read-transaction on a database, if the entire log has
! 398: # already been copied to the database file, the reader grabs a special
! 399: # kind of read lock (on aReadMark[0]). This set of test cases tests the
! 400: # outcome of the following:
! 401: #
! 402: # + The reader discovering that between the time when it determined
! 403: # that the log had been completely backfilled and the lock is obtained
! 404: # that a writer has written to the log. In this case the reader should
! 405: # acquire a different read-lock (not aReadMark[0]) and read the new
! 406: # snapshot.
! 407: #
! 408: # + The attempt to obtain the lock on aReadMark[0] fails with SQLITE_BUSY.
! 409: # This can happen if a checkpoint is ongoing. In this case also simply
! 410: # obtain a different read-lock.
! 411: #
! 412: catch {db close}
! 413: testvfs T -default 1
! 414: do_test wal3-6.1.1 {
! 415: forcedelete test.db test.db-journal test.db wal
! 416: sqlite3 db test.db
! 417: execsql { PRAGMA auto_vacuum = off }
! 418: execsql { PRAGMA journal_mode = WAL }
! 419: execsql {
! 420: CREATE TABLE t1(a, b);
! 421: INSERT INTO t1 VALUES('o', 't');
! 422: INSERT INTO t1 VALUES('t', 'f');
! 423: }
! 424: } {}
! 425: do_test wal3-6.1.2 {
! 426: sqlite3 db2 test.db
! 427: sqlite3 db3 test.db
! 428: execsql { BEGIN ; SELECT * FROM t1 } db3
! 429: } {o t t f}
! 430: do_test wal3-6.1.3 {
! 431: execsql { PRAGMA wal_checkpoint } db2
! 432: } {0 4 4}
! 433:
! 434: # At this point the log file has been fully checkpointed. However,
! 435: # connection [db3] holds a lock that prevents the log from being wrapped.
! 436: # Test case 3.6.1.4 has [db] attempt a read-lock on aReadMark[0]. But
! 437: # as it is obtaining the lock, [db2] appends to the log file.
! 438: #
! 439: T filter xShmLock
! 440: T script lock_callback
! 441: proc lock_callback {method file handle spec} {
! 442: if {$spec == "3 1 lock shared"} {
! 443: # This is the callback for [db] to obtain the read lock on aReadMark[0].
! 444: # Disable future callbacks using [T filter {}] and write to the log
! 445: # file using [db2]. [db3] is preventing [db2] from wrapping the log
! 446: # here, so this is an append.
! 447: T filter {}
! 448: db2 eval { INSERT INTO t1 VALUES('f', 's') }
! 449: }
! 450: return SQLITE_OK
! 451: }
! 452: do_test wal3-6.1.4 {
! 453: execsql {
! 454: BEGIN;
! 455: SELECT * FROM t1;
! 456: }
! 457: } {o t t f f s}
! 458:
! 459: # [db] should be left holding a read-lock on some slot other than
! 460: # aReadMark[0]. Test this by demonstrating that the read-lock is preventing
! 461: # the log from being wrapped.
! 462: #
! 463: do_test wal3-6.1.5 {
! 464: db3 eval COMMIT
! 465: db2 eval { PRAGMA wal_checkpoint }
! 466: set sz1 [file size test.db-wal]
! 467: db2 eval { INSERT INTO t1 VALUES('s', 'e') }
! 468: set sz2 [file size test.db-wal]
! 469: expr {$sz2>$sz1}
! 470: } {1}
! 471:
! 472: # Test that if [db2] had not interfered when [db] was trying to grab
! 473: # aReadMark[0], it would have been possible to wrap the log in 3.6.1.5.
! 474: #
! 475: do_test wal3-6.1.6 {
! 476: execsql { COMMIT }
! 477: execsql { PRAGMA wal_checkpoint } db2
! 478: execsql {
! 479: BEGIN;
! 480: SELECT * FROM t1;
! 481: }
! 482: } {o t t f f s s e}
! 483: do_test wal3-6.1.7 {
! 484: db2 eval { PRAGMA wal_checkpoint }
! 485: set sz1 [file size test.db-wal]
! 486: db2 eval { INSERT INTO t1 VALUES('n', 't') }
! 487: set sz2 [file size test.db-wal]
! 488: expr {$sz2==$sz1}
! 489: } {1}
! 490:
! 491: db3 close
! 492: db2 close
! 493: db close
! 494:
! 495: do_test wal3-6.2.1 {
! 496: forcedelete test.db test.db-journal test.db wal
! 497: sqlite3 db test.db
! 498: sqlite3 db2 test.db
! 499: execsql { PRAGMA auto_vacuum = off }
! 500: execsql { PRAGMA journal_mode = WAL }
! 501: execsql {
! 502: CREATE TABLE t1(a, b);
! 503: INSERT INTO t1 VALUES('h', 'h');
! 504: INSERT INTO t1 VALUES('l', 'b');
! 505: }
! 506: } {}
! 507:
! 508: T filter xShmLock
! 509: T script lock_callback
! 510: proc lock_callback {method file handle spec} {
! 511: if {$spec == "3 1 unlock exclusive"} {
! 512: T filter {}
! 513: set ::R [db2 eval {
! 514: BEGIN;
! 515: SELECT * FROM t1;
! 516: }]
! 517: }
! 518: }
! 519: do_test wal3-6.2.2 {
! 520: execsql { PRAGMA wal_checkpoint }
! 521: } {0 4 4}
! 522: do_test wal3-6.2.3 {
! 523: set ::R
! 524: } {h h l b}
! 525: do_test wal3-6.2.4 {
! 526: set sz1 [file size test.db-wal]
! 527: execsql { INSERT INTO t1 VALUES('b', 'c'); }
! 528: set sz2 [file size test.db-wal]
! 529: expr {$sz2 > $sz1}
! 530: } {1}
! 531: do_test wal3-6.2.5 {
! 532: db2 eval { COMMIT }
! 533: execsql { PRAGMA wal_checkpoint }
! 534: set sz1 [file size test.db-wal]
! 535: execsql { INSERT INTO t1 VALUES('n', 'o'); }
! 536: set sz2 [file size test.db-wal]
! 537: expr {$sz2 == $sz1}
! 538: } {1}
! 539:
! 540: db2 close
! 541: db close
! 542: T delete
! 543:
! 544: #-------------------------------------------------------------------------
! 545: # When opening a read-transaction on a database, if the entire log has
! 546: # not yet been copied to the database file, the reader grabs a read
! 547: # lock on aReadMark[x], where x>0. The following test cases experiment
! 548: # with the outcome of the following:
! 549: #
! 550: # + The reader discovering that between the time when it read the
! 551: # wal-index header and the lock was obtained that a writer has
! 552: # written to the log. In this case the reader should re-read the
! 553: # wal-index header and lock a snapshot corresponding to the new
! 554: # header.
! 555: #
! 556: # + The value in the aReadMark[x] slot has been modified since it was
! 557: # read.
! 558: #
! 559: catch {db close}
! 560: testvfs T -default 1
! 561: do_test wal3-7.1.1 {
! 562: forcedelete test.db test.db-journal test.db wal
! 563: sqlite3 db test.db
! 564: execsql {
! 565: PRAGMA journal_mode = WAL;
! 566: CREATE TABLE blue(red PRIMARY KEY, green);
! 567: }
! 568: } {wal}
! 569:
! 570: T script method_callback
! 571: T filter xOpen
! 572: proc method_callback {method args} {
! 573: if {$method == "xOpen"} { return "reader" }
! 574: }
! 575: do_test wal3-7.1.2 {
! 576: sqlite3 db2 test.db
! 577: execsql { SELECT * FROM blue } db2
! 578: } {}
! 579:
! 580: T filter xShmLock
! 581: set ::locks [list]
! 582: proc method_callback {method file handle spec} {
! 583: if {$handle != "reader" } { return }
! 584: if {$method == "xShmLock"} {
! 585: catch { execsql { INSERT INTO blue VALUES(1, 2) } }
! 586: catch { execsql { INSERT INTO blue VALUES(3, 4) } }
! 587: }
! 588: lappend ::locks $spec
! 589: }
! 590: do_test wal3-7.1.3 {
! 591: execsql { SELECT * FROM blue } db2
! 592: } {1 2 3 4}
! 593: do_test wal3-7.1.4 {
! 594: set ::locks
! 595: } {{4 1 lock shared} {4 1 unlock shared} {5 1 lock shared} {5 1 unlock shared}}
! 596:
! 597: set ::locks [list]
! 598: proc method_callback {method file handle spec} {
! 599: if {$handle != "reader" } { return }
! 600: if {$method == "xShmLock"} {
! 601: catch { execsql { INSERT INTO blue VALUES(5, 6) } }
! 602: }
! 603: lappend ::locks $spec
! 604: }
! 605: do_test wal3-7.2.1 {
! 606: execsql { SELECT * FROM blue } db2
! 607: } {1 2 3 4 5 6}
! 608: do_test wal3-7.2.2 {
! 609: set ::locks
! 610: } {{5 1 lock shared} {5 1 unlock shared} {4 1 lock shared} {4 1 unlock shared}}
! 611:
! 612: db close
! 613: db2 close
! 614: T delete
! 615:
! 616: #-------------------------------------------------------------------------
! 617: #
! 618: do_test wal3-8.1 {
! 619: forcedelete test.db test.db-journal test.db wal
! 620: sqlite3 db test.db
! 621: sqlite3 db2 test.db
! 622: execsql {
! 623: PRAGMA auto_vacuum = off;
! 624: PRAGMA journal_mode = WAL;
! 625: CREATE TABLE b(c);
! 626: INSERT INTO b VALUES('Tehran');
! 627: INSERT INTO b VALUES('Qom');
! 628: INSERT INTO b VALUES('Markazi');
! 629: PRAGMA wal_checkpoint;
! 630: }
! 631: } {wal 0 5 5}
! 632: do_test wal3-8.2 {
! 633: execsql { SELECT * FROM b }
! 634: } {Tehran Qom Markazi}
! 635: do_test wal3-8.3 {
! 636: db eval { SELECT * FROM b } {
! 637: db eval { INSERT INTO b VALUES('Qazvin') }
! 638: set r [db2 eval { SELECT * FROM b }]
! 639: break
! 640: }
! 641: set r
! 642: } {Tehran Qom Markazi Qazvin}
! 643: do_test wal3-8.4 {
! 644: execsql {
! 645: INSERT INTO b VALUES('Gilan');
! 646: INSERT INTO b VALUES('Ardabil');
! 647: }
! 648: } {}
! 649: db2 close
! 650:
! 651: faultsim_save_and_close
! 652: testvfs T -default 1
! 653: faultsim_restore_and_reopen
! 654: T filter xShmLock
! 655: T script lock_callback
! 656:
! 657: proc lock_callback {method file handle spec} {
! 658: if {$spec == "4 1 unlock exclusive"} {
! 659: T filter {}
! 660: set ::r [catchsql { SELECT * FROM b } db2]
! 661: }
! 662: }
! 663: sqlite3 db test.db
! 664: sqlite3 db2 test.db
! 665: do_test wal3-8.5 {
! 666: execsql { SELECT * FROM b }
! 667: } {Tehran Qom Markazi Qazvin Gilan Ardabil}
! 668: do_test wal3-8.6 {
! 669: set ::r
! 670: } {1 {locking protocol}}
! 671:
! 672: db close
! 673: db2 close
! 674:
! 675: faultsim_restore_and_reopen
! 676: sqlite3 db2 test.db
! 677: T filter xShmLock
! 678: T script lock_callback
! 679: proc lock_callback {method file handle spec} {
! 680: if {$spec == "1 7 unlock exclusive"} {
! 681: T filter {}
! 682: set ::r [catchsql { SELECT * FROM b } db2]
! 683: }
! 684: }
! 685: unset ::r
! 686: do_test wal3-8.5 {
! 687: execsql { SELECT * FROM b }
! 688: } {Tehran Qom Markazi Qazvin Gilan Ardabil}
! 689: do_test wal3-8.6 {
! 690: set ::r
! 691: } {1 {locking protocol}}
! 692:
! 693: db close
! 694: db2 close
! 695: T delete
! 696:
! 697: #-------------------------------------------------------------------------
! 698: # When a connection opens a read-lock on the database, it searches for
! 699: # an aReadMark[] slot that is already set to the mxFrame value for the
! 700: # new transaction. If it cannot find one, it attempts to obtain an
! 701: # exclusive lock on an aReadMark[] slot for the purposes of modifying
! 702: # the value, then drops back to a shared-lock for the duration of the
! 703: # transaction.
! 704: #
! 705: # This test case verifies that if an exclusive lock cannot be obtained
! 706: # on any aReadMark[] slot (because there are already several readers),
! 707: # the client takes a shared-lock on a slot without modifying the value
! 708: # and continues.
! 709: #
! 710: set nConn 50
! 711: if { [string match *BSD $tcl_platform(os)] } { set nConn 25 }
! 712: do_test wal3-9.0 {
! 713: forcedelete test.db test.db-journal test.db wal
! 714: sqlite3 db test.db
! 715: execsql {
! 716: PRAGMA page_size = 1024;
! 717: PRAGMA journal_mode = WAL;
! 718: CREATE TABLE whoami(x);
! 719: INSERT INTO whoami VALUES('nobody');
! 720: }
! 721: } {wal}
! 722: for {set i 0} {$i < $nConn} {incr i} {
! 723: set c db$i
! 724: do_test wal3-9.1.$i {
! 725: sqlite3 $c test.db
! 726: execsql { UPDATE whoami SET x = $c }
! 727: execsql {
! 728: BEGIN;
! 729: SELECT * FROM whoami
! 730: } $c
! 731: } $c
! 732: }
! 733: for {set i 0} {$i < $nConn} {incr i} {
! 734: set c db$i
! 735: do_test wal3-9.2.$i {
! 736: execsql { SELECT * FROM whoami } $c
! 737: } $c
! 738: }
! 739:
! 740: set sz [expr 1024 * (2+$AUTOVACUUM)]
! 741: do_test wal3-9.3 {
! 742: for {set i 0} {$i < ($nConn-1)} {incr i} { db$i close }
! 743: execsql { PRAGMA wal_checkpoint }
! 744: byte_is_zero test.db [expr $sz-1024]
! 745: } {1}
! 746: do_test wal3-9.4 {
! 747: db[expr $nConn-1] close
! 748: execsql { PRAGMA wal_checkpoint }
! 749: set sz2 [file size test.db]
! 750: byte_is_zero test.db [expr $sz-1024]
! 751: } {0}
! 752:
! 753: do_multiclient_test tn {
! 754: do_test wal3-10.$tn.1 {
! 755: sql1 {
! 756: PRAGMA page_size = 1024;
! 757: CREATE TABLE t1(x);
! 758: PRAGMA journal_mode = WAL;
! 759: PRAGMA wal_autocheckpoint = 100000;
! 760: BEGIN;
! 761: INSERT INTO t1 VALUES(randomblob(800));
! 762: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 2
! 763: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 4
! 764: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 8
! 765: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 16
! 766: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 32
! 767: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 64
! 768: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 128
! 769: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 256
! 770: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 512
! 771: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 1024
! 772: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 2048
! 773: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 4096
! 774: INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 8192
! 775: COMMIT;
! 776: CREATE INDEX i1 ON t1(x);
! 777: }
! 778:
! 779: expr {[file size test.db-wal] > [expr 1032*9000]}
! 780: } 1
! 781:
! 782: do_test wal3-10.$tn.2 {
! 783: sql2 {PRAGMA integrity_check}
! 784: } {ok}
! 785: }
! 786:
! 787: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to wal3.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