Index: third_party/sqlite/sqlite-src-3080704/test/wal3.test |
diff --git a/third_party/sqlite/sqlite-src-3080704/test/wal3.test b/third_party/sqlite/sqlite-src-3080704/test/wal3.test |
deleted file mode 100644 |
index 18e6075a4a870799821b667995b9b3f01344fb5c..0000000000000000000000000000000000000000 |
--- a/third_party/sqlite/sqlite-src-3080704/test/wal3.test |
+++ /dev/null |
@@ -1,787 +0,0 @@ |
-# 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 } |
- execsql { CREATE TABLE filler(a,b,c); } |
- |
- 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 4 4} |
- |
-# 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 4 4} |
-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 5 5} |
-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 == "1 7 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 |