# 2010 April 13 # # 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 operation of the library in # "PRAGMA journal_mode=WAL" mode. # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/wal_common.tcl source $testdir/malloc_common.tcl ifcapable !wal {finish_test ; return } set a_string_counter 1 proc a_string {n} { global a_string_counter incr a_string_counter string range [string repeat "${a_string_counter}." $n] 1 $n } db func a_string a_string #------------------------------------------------------------------------- # When a rollback or savepoint rollback occurs, the client may remove # elements from one of the hash tables in the wal-index. This block # of test cases tests that nothing appears to go wrong when this is # done. # do_test wal3-1.0 { execsql { PRAGMA cache_size = 2000; PRAGMA page_size = 1024; PRAGMA auto_vacuum = off; PRAGMA synchronous = normal; PRAGMA journal_mode = WAL; PRAGMA wal_autocheckpoint = 0; BEGIN; CREATE TABLE t1(x); INSERT INTO t1 VALUES( a_string(800) ); /* 1 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 4 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 8 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 16 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 32 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 64 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 128*/ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 256 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 512 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 1024 */ INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2048 */ INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 1970; /* 4018 */ COMMIT; PRAGMA cache_size = 10; } wal_frame_count test.db-wal 1024 } 4056 for {set i 1} {$i < 50} {incr i} { do_test wal3-1.$i.1 { set str [a_string 800] execsql { UPDATE t1 SET x = $str WHERE rowid = $i } lappend L [wal_frame_count test.db-wal 1024] execsql { BEGIN; INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 100; ROLLBACK; PRAGMA integrity_check; } } {ok} # Check that everything looks OK from the point of view of an # external connection. # sqlite3 db2 test.db do_test wal3-1.$i.2 { execsql { SELECT count(*) FROM t1 } db2 } 4018 do_test wal3-1.$i.3 { execsql { SELECT x FROM t1 WHERE rowid = $i } } $str do_test wal3-1.$i.4 { execsql { PRAGMA integrity_check } db2 } {ok} db2 close # Check that the file-system in its current state can be recovered. # forcecopy test.db test2.db forcecopy test.db-wal test2.db-wal forcedelete test2.db-journal sqlite3 db2 test2.db do_test wal3-1.$i.5 { execsql { SELECT count(*) FROM t1 } db2 } 4018 do_test wal3-1.$i.6 { execsql { SELECT x FROM t1 WHERE rowid = $i } } $str do_test wal3-1.$i.7 { execsql { PRAGMA integrity_check } db2 } {ok} db2 close } proc byte_is_zero {file offset} { if {[file size test.db] <= $offset} { return 1 } expr { [hexio_read $file $offset 1] == "00" } } do_multiclient_test i { set testname(1) multiproc set testname(2) singleproc set tn $testname($i) do_test wal3-2.$tn.1 { sql1 { PRAGMA page_size = 1024; PRAGMA journal_mode = WAL; } sql1 { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 'one'); BEGIN; SELECT * FROM t1; } } {1 one} do_test wal3-2.$tn.2 { sql2 { CREATE TABLE t2(a, b); INSERT INTO t2 VALUES(2, 'two'); BEGIN; SELECT * FROM t2; } } {2 two} do_test wal3-2.$tn.3 { sql3 { CREATE TABLE t3(a, b); INSERT INTO t3 VALUES(3, 'three'); BEGIN; SELECT * FROM t3; } } {3 three} # Try to checkpoint the database using [db]. It should be possible to # checkpoint everything except the table added by [db3] (checkpointing # these frames would clobber the snapshot currently being used by [db2]). # # After [db2] has committed, a checkpoint can copy the entire log to the # database file. Checkpointing after [db3] has committed is therefore a # no-op, as the entire log has already been backfilled. # do_test wal3-2.$tn.4 { sql1 { COMMIT; PRAGMA wal_checkpoint; } byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024] } {1} do_test wal3-2.$tn.5 { sql2 { COMMIT; PRAGMA wal_checkpoint; } list [byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]] \ [byte_is_zero test.db [expr $AUTOVACUUM ? 5*1024 : 4*1024]] } {0 1} do_test wal3-2.$tn.6 { sql3 { COMMIT; PRAGMA wal_checkpoint; } list [byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]] \ [byte_is_zero test.db [expr $AUTOVACUUM ? 5*1024 : 4*1024]] } {0 1} } catch {db close} #------------------------------------------------------------------------- # Test that that for the simple test: # # CREATE TABLE x(y); # INSERT INTO x VALUES('z'); # PRAGMA wal_checkpoint; # # in WAL mode the xSync method is invoked as expected for each of # synchronous=off, synchronous=normal and synchronous=full. # foreach {tn syncmode synccount} { 1 off {} 2 normal {test.db-wal normal test.db normal} 3 full {test.db-wal normal test.db-wal normal test.db-wal normal test.db normal} } { proc sync_counter {args} { foreach {method filename id flags} $args break lappend ::syncs [file tail $filename] $flags } do_test wal3-3.$tn { forcedelete test.db test.db-wal test.db-journal testvfs T T filter {} T script sync_counter sqlite3 db test.db -vfs T execsql "PRAGMA synchronous = $syncmode" execsql { PRAGMA journal_mode = WAL } set ::syncs [list] T filter xSync execsql { CREATE TABLE x(y); INSERT INTO x VALUES('z'); PRAGMA wal_checkpoint; } T filter {} set ::syncs } $synccount db close T delete } #------------------------------------------------------------------------- # When recovering the contents of a WAL file, a process obtains the WRITER # lock, then locks all other bytes before commencing recovery. If it fails # to lock all other bytes (because some other process is holding a read # lock) it should retry up to 100 times. Then return SQLITE_PROTOCOL to the # caller. Test this (test case wal3-4.3). # # Also test the effect of hitting an SQLITE_BUSY while attempting to obtain # the WRITER lock (should be the same). Test case wal3-4.4. # proc lock_callback {method filename handle lock} { lappend ::locks $lock } do_test wal3-4.1 { testvfs T T filter xShmLock T script lock_callback set ::locks [list] sqlite3 db test.db -vfs T execsql { SELECT * FROM x } lrange $::locks 0 3 } [list {0 1 lock exclusive} {1 7 lock exclusive} \ {1 7 unlock exclusive} {0 1 unlock exclusive} \ ] do_test wal3-4.2 { db close set ::locks [list] sqlite3 db test.db -vfs T execsql { SELECT * FROM x } lrange $::locks 0 3 } [list {0 1 lock exclusive} {1 7 lock exclusive} \ {1 7 unlock exclusive} {0 1 unlock exclusive} \ ] proc lock_callback {method filename handle lock} { if {$lock == "1 7 lock exclusive"} { return SQLITE_BUSY } return SQLITE_OK } puts " Warning: This next test case causes SQLite to call xSleep(1) 100 times." puts " Normally this equates to a 100ms delay, but if SQLite is built on unix" puts " without HAVE_USLEEP defined, it may be 100 seconds." do_test wal3-4.3 { db close set ::locks [list] sqlite3 db test.db -vfs T catchsql { SELECT * FROM x } } {1 {locking protocol}} puts " Warning: Same again!" proc lock_callback {method filename handle lock} { if {$lock == "0 1 lock exclusive"} { return SQLITE_BUSY } return SQLITE_OK } do_test wal3-4.4 { db close set ::locks [list] sqlite3 db test.db -vfs T catchsql { SELECT * FROM x } } {1 {locking protocol}} db close T delete #------------------------------------------------------------------------- # Only one client may run recovery at a time. Test this mechanism. # # When client-2 tries to open a read transaction while client-1 is # running recovery, it fails to obtain a lock on an aReadMark[] slot # (because they are all locked by recovery). It then tries to obtain # a shared lock on the RECOVER lock to see if there really is a # recovery running or not. # # This block of tests checks the effect of an SQLITE_BUSY or SQLITE_IOERR # being returned when client-2 attempts a shared lock on the RECOVER byte. # # An SQLITE_BUSY should be converted to an SQLITE_BUSY_RECOVERY. An # SQLITE_IOERR should be returned to the caller. # do_test wal3-5.1 { faultsim_delete_and_reopen execsql { PRAGMA journal_mode = WAL; CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 2); INSERT INTO t1 VALUES(3, 4); } faultsim_save_and_close } {} testvfs T -default 1 T script method_callback proc method_callback {method args} { if {$method == "xShmBarrier"} { incr ::barrier_count if {$::barrier_count == 2} { # This code is executed within the xShmBarrier() callback invoked # by the client running recovery as part of writing the recovered # wal-index header. If a second client attempts to access the # database now, it reads a corrupt (partially written) wal-index # header. But it cannot even get that far, as the first client # is still holding all the locks (recovery takes an exclusive lock # on *all* db locks, preventing access by any other client). # # If global variable ::wal3_do_lockfailure is non-zero, then set # things up so that an IO error occurs within an xShmLock() callback # made by the second client (aka [db2]). # sqlite3 db2 test.db if { $::wal3_do_lockfailure } { T filter xShmLock } set ::testrc [ catch { db2 eval "SELECT * FROM t1" } ::testmsg ] T filter {} db2 close } } if {$method == "xShmLock"} { foreach {file handle spec} $args break if { $spec == "2 1 lock shared" } { return SQLITE_IOERR } } return SQLITE_OK } # Test a normal SQLITE_BUSY return. # T filter xShmBarrier set testrc "" set testmsg "" set barrier_count 0 set wal3_do_lockfailure 0 do_test wal3-5.2 { faultsim_restore_and_reopen execsql { SELECT * FROM t1 } } {1 2 3 4} do_test wal3-5.3 { list $::testrc $::testmsg } {1 {database is locked}} db close # Test an SQLITE_IOERR return. # T filter xShmBarrier set barrier_count 0 set wal3_do_lockfailure 1 set testrc "" set testmsg "" do_test wal3-5.4 { faultsim_restore_and_reopen execsql { SELECT * FROM t1 } } {1 2 3 4} do_test wal3-5.5 { list $::testrc $::testmsg } {1 {disk I/O error}} db close T delete #------------------------------------------------------------------------- # When opening a read-transaction on a database, if the entire log has # already been copied to the database file, the reader grabs a special # kind of read lock (on aReadMark[0]). This set of test cases tests the # outcome of the following: # # + The reader discovering that between the time when it determined # that the log had been completely backfilled and the lock is obtained # that a writer has written to the log. In this case the reader should # acquire a different read-lock (not aReadMark[0]) and read the new # snapshot. # # + The attempt to obtain the lock on aReadMark[0] fails with SQLITE_BUSY. # This can happen if a checkpoint is ongoing. In this case also simply # obtain a different read-lock. # catch {db close} testvfs T -default 1 do_test wal3-6.1.1 { forcedelete test.db test.db-journal test.db wal sqlite3 db test.db execsql { PRAGMA auto_vacuum = off } execsql { PRAGMA journal_mode = WAL } execsql { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES('o', 't'); INSERT INTO t1 VALUES('t', 'f'); } } {} do_test wal3-6.1.2 { sqlite3 db2 test.db sqlite3 db3 test.db execsql { BEGIN ; SELECT * FROM t1 } db3 } {o t t f} do_test wal3-6.1.3 { execsql { PRAGMA wal_checkpoint } db2 } {0 7 7} # At this point the log file has been fully checkpointed. However, # connection [db3] holds a lock that prevents the log from being wrapped. # Test case 3.6.1.4 has [db] attempt a read-lock on aReadMark[0]. But # as it is obtaining the lock, [db2] appends to the log file. # T filter xShmLock T script lock_callback proc lock_callback {method file handle spec} { if {$spec == "3 1 lock shared"} { # This is the callback for [db] to obtain the read lock on aReadMark[0]. # Disable future callbacks using [T filter {}] and write to the log # file using [db2]. [db3] is preventing [db2] from wrapping the log # here, so this is an append. T filter {} db2 eval { INSERT INTO t1 VALUES('f', 's') } } return SQLITE_OK } do_test wal3-6.1.4 { execsql { BEGIN; SELECT * FROM t1; } } {o t t f f s} # [db] should be left holding a read-lock on some slot other than # aReadMark[0]. Test this by demonstrating that the read-lock is preventing # the log from being wrapped. # do_test wal3-6.1.5 { db3 eval COMMIT db2 eval { PRAGMA wal_checkpoint } set sz1 [file size test.db-wal] db2 eval { INSERT INTO t1 VALUES('s', 'e') } set sz2 [file size test.db-wal] expr {$sz2>$sz1} } {1} # Test that if [db2] had not interfered when [db] was trying to grab # aReadMark[0], it would have been possible to wrap the log in 3.6.1.5. # do_test wal3-6.1.6 { execsql { COMMIT } execsql { PRAGMA wal_checkpoint } db2 execsql { BEGIN; SELECT * FROM t1; } } {o t t f f s s e} do_test wal3-6.1.7 { db2 eval { PRAGMA wal_checkpoint } set sz1 [file size test.db-wal] db2 eval { INSERT INTO t1 VALUES('n', 't') } set sz2 [file size test.db-wal] expr {$sz2==$sz1} } {1} db3 close db2 close db close do_test wal3-6.2.1 { forcedelete test.db test.db-journal test.db wal sqlite3 db test.db sqlite3 db2 test.db execsql { PRAGMA auto_vacuum = off } execsql { PRAGMA journal_mode = WAL } execsql { CREATE TABLE t1(a, b); INSERT INTO t1 VALUES('h', 'h'); INSERT INTO t1 VALUES('l', 'b'); } } {} T filter xShmLock T script lock_callback proc lock_callback {method file handle spec} { if {$spec == "3 1 unlock exclusive"} { T filter {} set ::R [db2 eval { BEGIN; SELECT * FROM t1; }] } } do_test wal3-6.2.2 { execsql { PRAGMA wal_checkpoint } } {0 7 7} do_test wal3-6.2.3 { set ::R } {h h l b} do_test wal3-6.2.4 { set sz1 [file size test.db-wal] execsql { INSERT INTO t1 VALUES('b', 'c'); } set sz2 [file size test.db-wal] expr {$sz2 > $sz1} } {1} do_test wal3-6.2.5 { db2 eval { COMMIT } execsql { PRAGMA wal_checkpoint } set sz1 [file size test.db-wal] execsql { INSERT INTO t1 VALUES('n', 'o'); } set sz2 [file size test.db-wal] expr {$sz2 == $sz1} } {1} db2 close db close T delete #------------------------------------------------------------------------- # When opening a read-transaction on a database, if the entire log has # not yet been copied to the database file, the reader grabs a read # lock on aReadMark[x], where x>0. The following test cases experiment # with the outcome of the following: # # + The reader discovering that between the time when it read the # wal-index header and the lock was obtained that a writer has # written to the log. In this case the reader should re-read the # wal-index header and lock a snapshot corresponding to the new # header. # # + The value in the aReadMark[x] slot has been modified since it was # read. # catch {db close} testvfs T -default 1 do_test wal3-7.1.1 { forcedelete test.db test.db-journal test.db wal sqlite3 db test.db execsql { PRAGMA journal_mode = WAL; CREATE TABLE blue(red PRIMARY KEY, green); } } {wal} T script method_callback T filter xOpen proc method_callback {method args} { if {$method == "xOpen"} { return "reader" } } do_test wal3-7.1.2 { sqlite3 db2 test.db execsql { SELECT * FROM blue } db2 } {} T filter xShmLock set ::locks [list] proc method_callback {method file handle spec} { if {$handle != "reader" } { return } if {$method == "xShmLock"} { catch { execsql { INSERT INTO blue VALUES(1, 2) } } catch { execsql { INSERT INTO blue VALUES(3, 4) } } } lappend ::locks $spec } do_test wal3-7.1.3 { execsql { SELECT * FROM blue } db2 } {1 2 3 4} do_test wal3-7.1.4 { set ::locks } {{4 1 lock shared} {4 1 unlock shared} {5 1 lock shared} {5 1 unlock shared}} set ::locks [list] proc method_callback {method file handle spec} { if {$handle != "reader" } { return } if {$method == "xShmLock"} { catch { execsql { INSERT INTO blue VALUES(5, 6) } } } lappend ::locks $spec } do_test wal3-7.2.1 { execsql { SELECT * FROM blue } db2 } {1 2 3 4 5 6} do_test wal3-7.2.2 { set ::locks } {{5 1 lock shared} {5 1 unlock shared} {4 1 lock shared} {4 1 unlock shared}} db close db2 close T delete #------------------------------------------------------------------------- # do_test wal3-8.1 { forcedelete test.db test.db-journal test.db wal sqlite3 db test.db sqlite3 db2 test.db execsql { PRAGMA auto_vacuum = off; PRAGMA journal_mode = WAL; CREATE TABLE b(c); INSERT INTO b VALUES('Tehran'); INSERT INTO b VALUES('Qom'); INSERT INTO b VALUES('Markazi'); PRAGMA wal_checkpoint; } } {wal 0 9 9} do_test wal3-8.2 { execsql { SELECT * FROM b } } {Tehran Qom Markazi} do_test wal3-8.3 { db eval { SELECT * FROM b } { db eval { INSERT INTO b VALUES('Qazvin') } set r [db2 eval { SELECT * FROM b }] break } set r } {Tehran Qom Markazi Qazvin} do_test wal3-8.4 { execsql { INSERT INTO b VALUES('Gilan'); INSERT INTO b VALUES('Ardabil'); } } {} db2 close faultsim_save_and_close testvfs T -default 1 faultsim_restore_and_reopen T filter xShmLock T script lock_callback proc lock_callback {method file handle spec} { if {$spec == "4 1 unlock exclusive"} { T filter {} set ::r [catchsql { SELECT * FROM b } db2] } } sqlite3 db test.db sqlite3 db2 test.db do_test wal3-8.5 { execsql { SELECT * FROM b } } {Tehran Qom Markazi Qazvin Gilan Ardabil} do_test wal3-8.6 { set ::r } {1 {locking protocol}} db close db2 close faultsim_restore_and_reopen sqlite3 db2 test.db T filter xShmLock T script lock_callback proc lock_callback {method file handle spec} { if {$spec == "1 7 unlock exclusive"} { T filter {} set ::r [catchsql { SELECT * FROM b } db2] } } unset ::r do_test wal3-8.5 { execsql { SELECT * FROM b } } {Tehran Qom Markazi Qazvin Gilan Ardabil} do_test wal3-8.6 { set ::r } {1 {locking protocol}} db close db2 close T delete #------------------------------------------------------------------------- # When a connection opens a read-lock on the database, it searches for # an aReadMark[] slot that is already set to the mxFrame value for the # new transaction. If it cannot find one, it attempts to obtain an # exclusive lock on an aReadMark[] slot for the purposes of modifying # the value, then drops back to a shared-lock for the duration of the # transaction. # # This test case verifies that if an exclusive lock cannot be obtained # on any aReadMark[] slot (because there are already several readers), # the client takes a shared-lock on a slot without modifying the value # and continues. # set nConn 50 if { [string match *BSD $tcl_platform(os)] } { set nConn 25 } do_test wal3-9.0 { forcedelete test.db test.db-journal test.db wal sqlite3 db test.db execsql { PRAGMA page_size = 1024; PRAGMA journal_mode = WAL; CREATE TABLE whoami(x); INSERT INTO whoami VALUES('nobody'); } } {wal} for {set i 0} {$i < $nConn} {incr i} { set c db$i do_test wal3-9.1.$i { sqlite3 $c test.db execsql { UPDATE whoami SET x = $c } execsql { BEGIN; SELECT * FROM whoami } $c } $c } for {set i 0} {$i < $nConn} {incr i} { set c db$i do_test wal3-9.2.$i { execsql { SELECT * FROM whoami } $c } $c } set sz [expr 1024 * (2+$AUTOVACUUM)] do_test wal3-9.3 { for {set i 0} {$i < ($nConn-1)} {incr i} { db$i close } execsql { PRAGMA wal_checkpoint } byte_is_zero test.db [expr $sz-1024] } {1} do_test wal3-9.4 { db[expr $nConn-1] close execsql { PRAGMA wal_checkpoint } set sz2 [file size test.db] byte_is_zero test.db [expr $sz-1024] } {0} do_multiclient_test tn { do_test wal3-10.$tn.1 { sql1 { PRAGMA page_size = 1024; CREATE TABLE t1(x); PRAGMA journal_mode = WAL; PRAGMA wal_autocheckpoint = 100000; BEGIN; INSERT INTO t1 VALUES(randomblob(800)); INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 2 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 4 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 8 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 16 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 32 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 64 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 128 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 256 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 512 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 1024 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 2048 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 4096 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 8192 COMMIT; CREATE INDEX i1 ON t1(x); } expr {[file size test.db-wal] > [expr 1032*9000]} } 1 do_test wal3-10.$tn.2 { sql2 {PRAGMA integrity_check} } {ok} } finish_test