/trunk/test/wal5.test |
@@ -0,0 +1,353 @@ |
# 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 "blocking-checkpoint" |
# operations. |
# |
|
set testdir [file dirname $argv0] |
source $testdir/tester.tcl |
source $testdir/lock_common.tcl |
source $testdir/wal_common.tcl |
ifcapable !wal {finish_test ; return } |
|
set testprefix wal5 |
|
proc db_page_count {{file test.db}} { expr [file size $file] / 1024 } |
proc wal_page_count {{file test.db}} { wal_frame_count ${file}-wal 1024 } |
|
|
# A checkpoint may be requested either using the C API or by executing |
# an SQL PRAGMA command. To test both methods, all tests in this file are |
# run twice - once using each method to request checkpoints. |
# |
foreach {testprefix do_wal_checkpoint} { |
|
wal5-pragma { |
proc do_wal_checkpoint { dbhandle args } { |
array set a $args |
foreach key [array names a] { |
if {[lsearch {-mode -db} $key]<0} { error "unknown switch: $key" } |
} |
|
set sql "PRAGMA " |
if {[info exists a(-db)]} { append sql "$a(-db)." } |
append sql "wal_checkpoint" |
if {[info exists a(-mode)]} { append sql " = $a(-mode)" } |
|
uplevel [list $dbhandle eval $sql] |
} |
} |
|
wal5-capi { |
proc do_wal_checkpoint { dbhandle args } { |
set a(-mode) passive |
array set a $args |
foreach key [array names a] { |
if {[lsearch {-mode -db} $key]<0} { error "unknown switch: $key" } |
} |
|
if {$a(-mode)!="restart" && $a(-mode)!="full"} { set a(-mode) passive } |
|
set cmd [list sqlite3_wal_checkpoint_v2 $dbhandle $a(-mode)] |
if {[info exists a(-db)]} { lappend sql $a(-db) } |
|
uplevel $cmd |
} |
} |
} { |
|
eval $do_wal_checkpoint |
|
do_multiclient_test tn { |
|
set ::nBusyHandler 0 |
set ::busy_handler_script "" |
proc busyhandler {n} { |
incr ::nBusyHandler |
eval $::busy_handler_script |
return 0 |
} |
|
proc reopen_all {} { |
code1 {db close} |
code2 {db2 close} |
code3 {db3 close} |
|
code1 {sqlite3 db test.db} |
code2 {sqlite3 db2 test.db} |
code3 {sqlite3 db3 test.db} |
|
sql1 { PRAGMA synchronous = NORMAL } |
code1 { db busy busyhandler } |
} |
|
do_test 1.$tn.1 { |
reopen_all |
sql1 { |
PRAGMA page_size = 1024; |
PRAGMA auto_vacuum = 0; |
CREATE TABLE t1(x, y); |
PRAGMA journal_mode = WAL; |
INSERT INTO t1 VALUES(1, zeroblob(1200)); |
INSERT INTO t1 VALUES(2, zeroblob(1200)); |
INSERT INTO t1 VALUES(3, zeroblob(1200)); |
} |
expr [file size test.db] / 1024 |
} {2} |
|
# Have connection 2 grab a read-lock on the current snapshot. |
do_test 1.$tn.2 { sql2 { BEGIN; SELECT x FROM t1 } } {1 2 3} |
|
# Attempt a checkpoint. |
do_test 1.$tn.3 { |
code1 { do_wal_checkpoint db } |
list [db_page_count] [wal_page_count] |
} {5 9} |
|
# Write to the db again. The log cannot wrap because of the lock still |
# held by connection 2. The busy-handler has not yet been invoked. |
do_test 1.$tn.4 { |
sql1 { INSERT INTO t1 VALUES(4, zeroblob(1200)) } |
list [db_page_count] [wal_page_count] $::nBusyHandler |
} {5 12 0} |
|
# Now do a blocking-checkpoint. Set the busy-handler up so that connection |
# 2 releases its lock on the 6th invocation. The checkpointer should then |
# proceed to checkpoint the entire log file. Next write should go to the |
# start of the log file. |
# |
set ::busy_handler_script { if {$n==5} { sql2 COMMIT } } |
do_test 1.$tn.5 { |
code1 { do_wal_checkpoint db -mode restart } |
list [db_page_count] [wal_page_count] $::nBusyHandler |
} {6 12 6} |
do_test 1.$tn.6 { |
set ::nBusyHandler 0 |
sql1 { INSERT INTO t1 VALUES(5, zeroblob(1200)) } |
list [db_page_count] [wal_page_count] $::nBusyHandler |
} {6 12 0} |
|
do_test 1.$tn.7 { |
reopen_all |
list [db_page_count] [wal_page_count] $::nBusyHandler |
} {7 0 0} |
|
do_test 1.$tn.8 { sql2 { BEGIN ; SELECT x FROM t1 } } {1 2 3 4 5} |
do_test 1.$tn.9 { |
sql1 { INSERT INTO t1 VALUES(6, zeroblob(1200)) } |
list [db_page_count] [wal_page_count] $::nBusyHandler |
} {7 5 0} |
do_test 1.$tn.10 { sql3 { BEGIN ; SELECT x FROM t1 } } {1 2 3 4 5 6} |
|
set ::busy_handler_script { |
if {$n==5} { sql2 COMMIT } |
if {$n==6} { set ::db_file_size [db_page_count] } |
if {$n==7} { sql3 COMMIT } |
} |
do_test 1.$tn.11 { |
code1 { do_wal_checkpoint db -mode restart } |
list [db_page_count] [wal_page_count] $::nBusyHandler |
} {10 5 8} |
do_test 1.$tn.12 { set ::db_file_size } 10 |
} |
|
#------------------------------------------------------------------------- |
# This block of tests explores checkpoint operations on more than one |
# database file. |
# |
proc setup_and_attach_aux {} { |
sql1 { ATTACH 'test.db2' AS aux } |
sql2 { ATTACH 'test.db2' AS aux } |
sql3 { ATTACH 'test.db2' AS aux } |
sql1 { |
PRAGMA aux.auto_vacuum = 0; |
PRAGMA main.auto_vacuum = 0; |
PRAGMA main.page_size=1024; PRAGMA main.journal_mode=WAL; |
PRAGMA aux.page_size=1024; PRAGMA aux.journal_mode=WAL; |
} |
} |
|
proc file_page_counts {} { |
list [db_page_count test.db ] \ |
[wal_page_count test.db ] \ |
[db_page_count test.db2] \ |
[wal_page_count test.db2] |
} |
|
# Test that executing "PRAGMA wal_checkpoint" checkpoints all attached |
# databases, not just the main db. In capi mode, check that this is |
# true if a NULL pointer is passed to wal_checkpoint_v2() in place of a |
# database name. |
do_multiclient_test tn { |
setup_and_attach_aux |
do_test 2.1.$tn.1 { |
sql1 { |
CREATE TABLE t1(a, b); |
INSERT INTO t1 VALUES(1, 2); |
CREATE TABLE aux.t2(a, b); |
INSERT INTO t2 VALUES(1, 2); |
} |
} {} |
do_test 2.2.$tn.2 { file_page_counts } {1 5 1 5} |
do_test 2.1.$tn.3 { code1 { do_wal_checkpoint db } } {0 5 5} |
do_test 2.1.$tn.4 { file_page_counts } {2 5 2 5} |
} |
|
do_multiclient_test tn { |
setup_and_attach_aux |
do_test 2.2.$tn.1 { |
execsql { |
CREATE TABLE t1(a, b); |
INSERT INTO t1 VALUES(1, 2); |
CREATE TABLE aux.t2(a, b); |
INSERT INTO t2 VALUES(1, 2); |
INSERT INTO t2 VALUES(3, 4); |
} |
} {} |
do_test 2.2.$tn.2 { file_page_counts } {1 5 1 7} |
do_test 2.2.$tn.3 { sql2 { BEGIN; SELECT * FROM t1 } } {1 2} |
do_test 2.2.$tn.4 { code1 { do_wal_checkpoint db -mode restart } } {1 5 5} |
do_test 2.2.$tn.5 { file_page_counts } {2 5 2 7} |
} |
|
do_multiclient_test tn { |
setup_and_attach_aux |
do_test 2.3.$tn.1 { |
execsql { |
CREATE TABLE t1(a, b); |
INSERT INTO t1 VALUES(1, 2); |
CREATE TABLE aux.t2(a, b); |
INSERT INTO t2 VALUES(1, 2); |
} |
} {} |
do_test 2.3.$tn.2 { file_page_counts } {1 5 1 5} |
do_test 2.3.$tn.3 { sql2 { BEGIN; SELECT * FROM t1 } } {1 2} |
do_test 2.3.$tn.4 { sql1 { INSERT INTO t1 VALUES(3, 4) } } {} |
do_test 2.3.$tn.5 { sql1 { INSERT INTO t2 VALUES(3, 4) } } {} |
do_test 2.3.$tn.6 { file_page_counts } {1 7 1 7} |
do_test 2.3.$tn.7 { code1 { do_wal_checkpoint db -mode full } } {1 7 5} |
if {$tcl_platform(platform) == "windows"} { |
# on unix, the size_hint is a no-op if no chunk size is set. |
# the windows implementation does not have a similar check, |
# and because of this, the db file size has an extra page. |
do_test 2.3.$tn.8 { file_page_counts } {2 7 2 7} |
} { |
do_test 2.3.$tn.8 { file_page_counts } {1 7 2 7} |
} |
} |
|
# Check that checkpoints block on the correct locks. And respond correctly |
# if they cannot obtain those locks. There are three locks that a checkpoint |
# may block on (in the following order): |
# |
# 1. The writer lock: FULL and RESTART checkpoints block until any writer |
# process releases its lock. |
# |
# 2. Readers using part of the log file. FULL and RESTART checkpoints block |
# until readers using part (but not all) of the log file have finished. |
# |
# 3. Readers using any of the log file. After copying data into the |
# database file, RESTART checkpoints block until readers using any part |
# of the log file have finished. |
# |
# This test case involves running a checkpoint while there exist other |
# processes holding all three types of locks. |
# |
foreach {tn1 checkpoint busy_on ckpt_expected expected} { |
1 PASSIVE - {0 5 5} - |
2 TYPO - {0 5 5} - |
|
3 FULL - {0 7 7} 2 |
4 FULL 1 {1 5 5} 1 |
5 FULL 2 {1 7 5} 2 |
6 FULL 3 {0 7 7} 2 |
|
7 RESTART - {0 7 7} 3 |
8 RESTART 1 {1 5 5} 1 |
9 RESTART 2 {1 7 5} 2 |
10 RESTART 3 {1 7 7} 3 |
|
} { |
do_multiclient_test tn { |
setup_and_attach_aux |
|
proc busyhandler {x} { |
set ::max_busyhandler $x |
if {$::busy_on!="-" && $x==$::busy_on} { return 1 } |
switch -- $x { |
1 { sql2 "COMMIT ; BEGIN ; SELECT * FROM t1" } |
2 { sql3 "COMMIT" } |
3 { sql2 "COMMIT" } |
} |
return 0 |
} |
set ::max_busyhandler - |
|
do_test 2.4.$tn1.$tn.1 { |
sql1 { |
CREATE TABLE t1(a, b); |
INSERT INTO t1 VALUES(1, 2); |
} |
sql2 { BEGIN; INSERT INTO t1 VALUES(3, 4) } |
sql3 { BEGIN; SELECT * FROM t1 } |
} {1 2} |
|
do_test 2.4.$tn1.$tn.2 { |
code1 { db busy busyhandler } |
code1 { do_wal_checkpoint db -mode [string tolower $checkpoint] } |
} $ckpt_expected |
do_test 2.4.$tn1.$tn.3 { set ::max_busyhandler } $expected |
} |
} |
|
|
do_multiclient_test tn { |
|
code1 $do_wal_checkpoint |
code2 $do_wal_checkpoint |
code3 $do_wal_checkpoint |
|
do_test 3.$tn.1 { |
sql1 { |
PRAGMA auto_vacuum = 0; |
PRAGMA journal_mode = WAL; |
PRAGMA synchronous = normal; |
CREATE TABLE t1(x, y); |
} |
|
sql2 { PRAGMA journal_mode } |
sql3 { PRAGMA journal_mode } |
} {wal} |
|
do_test 3.$tn.2 { code2 { do_wal_checkpoint db2 } } {0 2 2} |
|
do_test 3.$tn.3 { code2 { do_wal_checkpoint db2 } } {0 2 2} |
|
do_test 3.$tn.4 { code3 { do_wal_checkpoint db3 } } {0 2 2} |
|
code1 {db close} |
code2 {db2 close} |
code3 {db3 close} |
|
code1 {sqlite3 db test.db} |
code2 {sqlite3 db2 test.db} |
code3 {sqlite3 db3 test.db} |
|
do_test 3.$tn.5 { sql3 { PRAGMA journal_mode } } {wal} |
|
do_test 3.$tn.6 { code3 { do_wal_checkpoint db3 } } {0 0 0} |
} |
} |
|
|
finish_test |
|