mirrors/sqlite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c3a20c19a8
sqlite/test/wal2.test
dan 69aedc8db4 Fix various problems in test scripts preventing "make test" from passing on 
F2FS file-systems with the "atomic-write" feature.

FossilOrigin-Name: 56d93d070d6b92d8a5a3fec1b09aae8911116c73d072fc5022f0b51668ed996b
2018-01-13 13:07:49 +00:00

1336 lines
36 KiB
Plaintext
Raw Blame History

# 2010 May 5
#
# 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/malloc_common.tcl
source $testdir/wal_common.tcl
set testprefix wal2
ifcapable !wal {finish_test ; return }
set sqlite_sync_count 0
proc cond_incr_sync_count {adj} {
global sqlite_sync_count
if {$::tcl_platform(platform) == "windows"} {
incr sqlite_sync_count $adj
} {
ifcapable !dirsync {
incr sqlite_sync_count $adj
}
}
}
proc set_tvfs_hdr {file args} {
# Set $nHdr to the number of bytes in the wal-index header:
set nHdr 48
set nInt [expr {$nHdr/4}]
if {[llength $args]>2} {
error {wrong # args: should be "set_tvfs_hdr fileName ?val1? ?val2?"}
}
set blob [tvfs shm $file]
if {$::tcl_platform(byteOrder)=="bigEndian"} {set fmt I} {set fmt i}
if {[llength $args]} {
set ia [lindex $args 0]
set ib $ia
if {[llength $args]==2} {
set ib [lindex $args 1]
}
binary scan $blob a[expr $nHdr*2]a* dummy tail
set blob [binary format ${fmt}${nInt}${fmt}${nInt}a* $ia $ib $tail]
tvfs shm $file $blob
}
binary scan $blob ${fmt}${nInt} ints
return $ints
}
proc incr_tvfs_hdr {file idx incrval} {
set ints [set_tvfs_hdr $file]
set v [lindex $ints $idx]
incr v $incrval
lset ints $idx $v
set_tvfs_hdr $file $ints
}
#-------------------------------------------------------------------------
# Test case wal2-1.*:
#
# Set up a small database containing a single table. The database is not
# checkpointed during the test - all content resides in the log file.
#
# Two connections are established to the database file - a writer ([db])
# and a reader ([db2]). For each of the 8 integer fields in the wal-index
# header (6 fields and 2 checksum values), do the following:
#
# 1. Modify the database using the writer.
#
# 2. Attempt to read the database using the reader. Before the reader
# has a chance to snapshot the wal-index header, increment one
# of the integer fields (so that the reader ends up with a corrupted
# header).
#
# 3. Check that the reader recovers the wal-index and reads the correct
# database content.
#
do_test wal2-1.0 {
proc tvfs_cb {method filename args} {
set ::filename $filename
return SQLITE_OK
}
testvfs tvfs
tvfs script tvfs_cb
tvfs filter xShmOpen
sqlite3 db test.db -vfs tvfs
sqlite3 db2 test.db -vfs tvfs
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a);
} db2
execsql {
INSERT INTO t1 VALUES(1);
INSERT INTO t1 VALUES(2);
INSERT INTO t1 VALUES(3);
INSERT INTO t1 VALUES(4);
SELECT count(a), sum(a) FROM t1;
}
} {4 10}
do_test wal2-1.1 {
execsql { SELECT count(a), sum(a) FROM t1 } db2
} {4 10}
set RECOVER [list \
{0 1 lock exclusive} {1 2 lock exclusive} {4 4 lock exclusive} \
{1 2 unlock exclusive} {4 4 unlock exclusive} {0 1 unlock exclusive} \
]
set READ [list \
{4 1 lock shared} {4 1 unlock shared} \
]
set INITSLOT [list \
{4 1 lock exclusive} {4 1 unlock exclusive} \
]
foreach {tn iInsert res wal_index_hdr_mod wal_locks} "
2 5 {5 15} 0 {$RECOVER $READ}
3 6 {6 21} 1 {$RECOVER $READ}
4 7 {7 28} 2 {$RECOVER $READ}
5 8 {8 36} 3 {$RECOVER $READ}
6 9 {9 45} 4 {$RECOVER $READ}
7 10 {10 55} 5 {$RECOVER $READ}
8 11 {11 66} 6 {$RECOVER $READ}
9 12 {12 78} 7 {$RECOVER $READ}
10 13 {13 91} 8 {$RECOVER $READ}
11 14 {14 105} 9 {$RECOVER $READ}
12 15 {15 120} -1 {$INITSLOT $READ}
" {
do_test wal2-1.$tn.1 {
execsql { INSERT INTO t1 VALUES($iInsert) }
set ::locks [list]
proc tvfs_cb {method args} {
lappend ::locks [lindex $args 2]
return SQLITE_OK
}
tvfs filter xShmLock
if {$::wal_index_hdr_mod >= 0} {
incr_tvfs_hdr $::filename $::wal_index_hdr_mod 1
}
execsql { SELECT count(a), sum(a) FROM t1 } db2
} $res
do_test wal2-1.$tn.2 {
set ::locks
} $wal_locks
}
db close
db2 close
tvfs delete
forcedelete test.db test.db-wal test.db-journal
#-------------------------------------------------------------------------
# This test case is very similar to the previous one, except, after
# the reader reads the corrupt wal-index header, but before it has
# a chance to re-read it under the cover of the RECOVER lock, the
# wal-index header is replaced with a valid, but out-of-date, header.
#
# Because the header checksum looks Ok, the reader does not run recovery,
# it simply drops back to a READ lock and proceeds. But because the
# header is out-of-date, the reader reads the out-of-date snapshot.
#
# After this, the header is corrupted again and the reader is allowed
# to run recovery. This time, it sees an up-to-date snapshot of the
# database file.
#
set WRITER [list 0 1 lock exclusive]
set LOCKS [list \
{0 1 lock exclusive} {0 1 unlock exclusive} \
{4 1 lock exclusive} {4 1 unlock exclusive} \
{4 1 lock shared} {4 1 unlock shared} \
]
do_test wal2-2.0 {
testvfs tvfs
tvfs script tvfs_cb
tvfs filter xShmOpen
proc tvfs_cb {method args} {
set ::filename [lindex $args 0]
return SQLITE_OK
}
sqlite3 db test.db -vfs tvfs
sqlite3 db2 test.db -vfs tvfs
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a);
} db2
execsql {
INSERT INTO t1 VALUES(1);
INSERT INTO t1 VALUES(2);
INSERT INTO t1 VALUES(3);
INSERT INTO t1 VALUES(4);
SELECT count(a), sum(a) FROM t1;
}
} {4 10}
do_test wal2-2.1 {
execsql { SELECT count(a), sum(a) FROM t1 } db2
} {4 10}
foreach {tn iInsert res0 res1 wal_index_hdr_mod} {
2 5 {4 10} {5 15} 0
3 6 {5 15} {6 21} 1
4 7 {6 21} {7 28} 2
5 8 {7 28} {8 36} 3
6 9 {8 36} {9 45} 4
7 10 {9 45} {10 55} 5
8 11 {10 55} {11 66} 6
9 12 {11 66} {12 78} 7
} {
tvfs filter xShmLock
do_test wal2-2.$tn.1 {
set oldhdr [set_tvfs_hdr $::filename]
execsql { INSERT INTO t1 VALUES($iInsert) }
execsql { SELECT count(a), sum(a) FROM t1 }
} $res1
do_test wal2-2.$tn.2 {
set ::locks [list]
proc tvfs_cb {method args} {
set lock [lindex $args 2]
lappend ::locks $lock
if {$lock == $::WRITER} {
set_tvfs_hdr $::filename $::oldhdr
}
return SQLITE_OK
}
if {$::wal_index_hdr_mod >= 0} {
incr_tvfs_hdr $::filename $::wal_index_hdr_mod 1
}
execsql { SELECT count(a), sum(a) FROM t1 } db2
} $res0
do_test wal2-2.$tn.3 {
set ::locks
} $LOCKS
do_test wal2-2.$tn.4 {
set ::locks [list]
proc tvfs_cb {method args} {
set lock [lindex $args 2]
lappend ::locks $lock
return SQLITE_OK
}
if {$::wal_index_hdr_mod >= 0} {
incr_tvfs_hdr $::filename $::wal_index_hdr_mod 1
}
execsql { SELECT count(a), sum(a) FROM t1 } db2
} $res1
}
db close
db2 close
tvfs delete
forcedelete test.db test.db-wal test.db-journal
if 0 {
#-------------------------------------------------------------------------
# This test case - wal2-3.* - tests the response of the library to an
# SQLITE_BUSY when attempting to obtain a READ or RECOVER lock.
#
# wal2-3.0 - 2: SQLITE_BUSY when obtaining a READ lock
# wal2-3.3 - 6: SQLITE_BUSY when obtaining a RECOVER lock
#
do_test wal2-3.0 {
proc tvfs_cb {method args} {
if {$method == "xShmLock"} {
if {[info exists ::locked]} { return SQLITE_BUSY }
}
return SQLITE_OK
}
proc busyhandler x {
if {$x>3} { unset -nocomplain ::locked }
return 0
}
testvfs tvfs
tvfs script tvfs_cb
sqlite3 db test.db -vfs tvfs
db busy busyhandler
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a);
INSERT INTO t1 VALUES(1);
INSERT INTO t1 VALUES(2);
INSERT INTO t1 VALUES(3);
INSERT INTO t1 VALUES(4);
}
set ::locked 1
info exists ::locked
} {1}
do_test wal2-3.1 {
execsql { SELECT count(a), sum(a) FROM t1 }
} {4 10}
do_test wal2-3.2 {
info exists ::locked
} {0}
do_test wal2-3.3 {
proc tvfs_cb {method args} {
if {$method == "xShmLock"} {
if {[info exists ::sabotage]} {
unset -nocomplain ::sabotage
incr_tvfs_hdr [lindex $args 0] 1 1
}
if {[info exists ::locked] && [lindex $args 2] == "RECOVER"} {
return SQLITE_BUSY
}
}
return SQLITE_OK
}
set ::sabotage 1
set ::locked 1
list [info exists ::sabotage] [info exists ::locked]
} {1 1}
do_test wal2-3.4 {
execsql { SELECT count(a), sum(a) FROM t1 }
} {4 10}
do_test wal2-3.5 {
list [info exists ::sabotage] [info exists ::locked]
} {0 0}
db close
tvfs delete
forcedelete test.db test.db-wal test.db-journal
}
#-------------------------------------------------------------------------
# Test that a database connection using a VFS that does not support the
# xShmXXX interfaces cannot open a WAL database.
#
do_test wal2-4.1 {
sqlite3 db test.db
execsql {
PRAGMA auto_vacuum = 0;
PRAGMA journal_mode = WAL;
CREATE TABLE data(x);
INSERT INTO data VALUES('need xShmOpen to see this');
PRAGMA wal_checkpoint;
}
# Three pages in the WAL file at this point: One copy of page 1 and two
# of the root page for table "data".
} {wal 0 3 3}
do_test wal2-4.2 {
db close
testvfs tvfs -noshm 1
sqlite3 db test.db -vfs tvfs
catchsql { SELECT * FROM data }
} {1 {unable to open database file}}
do_test wal2-4.3 {
db close
testvfs tvfs
sqlite3 db test.db -vfs tvfs
catchsql { SELECT * FROM data }
} {0 {{need xShmOpen to see this}}}
db close
tvfs delete
#-------------------------------------------------------------------------
# Test that if a database connection is forced to run recovery before it
# can perform a checkpoint, it does not transition into RECOVER state.
#
# UPDATE: This has now changed. When running a checkpoint, if recovery is
# required the client grabs all exclusive locks (just as it would for a
# recovery performed as a pre-cursor to a normal database transaction).
#
set expected_locks [list]
lappend expected_locks {1 1 lock exclusive} ;# Lock checkpoint
lappend expected_locks {0 1 lock exclusive} ;# Lock writer
lappend expected_locks {2 1 lock exclusive} ;# Lock recovery
lappend expected_locks {4 4 lock exclusive} ;# Lock all aReadMark[]
lappend expected_locks {2 1 unlock exclusive} ;# Unlock recovery
lappend expected_locks {4 4 unlock exclusive} ;# Unlock all aReadMark[]
lappend expected_locks {0 1 unlock exclusive} ;# Unlock writer
lappend expected_locks {3 1 lock exclusive} ;# Lock aReadMark[0]
lappend expected_locks {3 1 unlock exclusive} ;# Unlock aReadMark[0]
lappend expected_locks {1 1 unlock exclusive} ;# Unlock checkpoint
do_test wal2-5.1 {
proc tvfs_cb {method args} {
set ::shm_file [lindex $args 0]
if {$method == "xShmLock"} { lappend ::locks [lindex $args 2] }
return $::tvfs_cb_return
}
set tvfs_cb_return SQLITE_OK
testvfs tvfs
tvfs script tvfs_cb
sqlite3 db test.db -vfs tvfs
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE x(y);
INSERT INTO x VALUES(1);
}
incr_tvfs_hdr $::shm_file 1 1
set ::locks [list]
execsql { PRAGMA wal_checkpoint }
set ::locks
} $expected_locks
db close
tvfs delete
#-------------------------------------------------------------------------
# This block, test cases wal2-6.*, tests the operation of WAL with
# "PRAGMA locking_mode=EXCLUSIVE" set.
#
# wal2-6.1.*: Changing to WAL mode before setting locking_mode=exclusive.
#
# wal2-6.2.*: Changing to WAL mode after setting locking_mode=exclusive.
#
# wal2-6.3.*: Changing back to rollback mode from WAL mode after setting
# locking_mode=exclusive.
#
# wal2-6.4.*: Check that xShmLock calls are omitted in exclusive locking
# mode.
#
# wal2-6.5.*:
#
# wal2-6.6.*: Check that if the xShmLock() to reaquire a WAL read-lock when
# exiting exclusive mode fails (i.e. SQLITE_IOERR), then the
# connection silently remains in exclusive mode.
#
do_test wal2-6.1.1 {
forcedelete test.db test.db-wal test.db-journal
sqlite3 db test.db
execsql {
Pragma Journal_Mode = Wal;
}
} {wal}
do_test wal2-6.1.2 {
execsql { PRAGMA lock_status }
} {main unlocked temp closed}
do_test wal2-6.1.3 {
execsql {
SELECT * FROM sqlite_master;
Pragma Locking_Mode = Exclusive;
}
execsql {
BEGIN;
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
COMMIT;
PRAGMA lock_status;
}
} {main exclusive temp closed}
do_test wal2-6.1.4 {
execsql {
PRAGMA locking_mode = normal;
PRAGMA lock_status;
}
} {normal main exclusive temp closed}
do_test wal2-6.1.5 {
execsql {
SELECT * FROM t1;
PRAGMA lock_status;
}
} {1 2 main shared temp closed}
do_test wal2-6.1.6 {
execsql {
INSERT INTO t1 VALUES(3, 4);
PRAGMA lock_status;
}
} {main shared temp closed}
db close
do_test wal2-6.2.1 {
forcedelete test.db test.db-wal test.db-journal
sqlite3 db test.db
execsql {
Pragma Locking_Mode = Exclusive;
Pragma Journal_Mode = Wal;
Pragma Lock_Status;
}
} {exclusive wal main exclusive temp closed}
do_test wal2-6.2.2 {
execsql {
BEGIN;
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
COMMIT;
Pragma loCK_STATus;
}
} {main exclusive temp closed}
do_test wal2-6.2.3 {
db close
sqlite3 db test.db
execsql { SELECT * FROM sqlite_master }
execsql { PRAGMA LOCKING_MODE = EXCLUSIVE }
} {exclusive}
do_test wal2-6.2.4 {
execsql {
SELECT * FROM t1;
pragma lock_status;
}
} {1 2 main shared temp closed}
do_test wal2-6.2.5 {
execsql {
INSERT INTO t1 VALUES(3, 4);
pragma lock_status;
}
} {main exclusive temp closed}
do_test wal2-6.2.6 {
execsql {
PRAGMA locking_mode = NORMAL;
pragma lock_status;
}
} {normal main exclusive temp closed}
do_test wal2-6.2.7 {
execsql {
BEGIN IMMEDIATE; COMMIT;
pragma lock_status;
}
} {main shared temp closed}
do_test wal2-6.2.8 {
execsql {
PRAGMA locking_mode = EXCLUSIVE;
BEGIN IMMEDIATE; COMMIT;
PRAGMA locking_mode = NORMAL;
}
execsql {
SELECT * FROM t1;
pragma lock_status;
}
} {1 2 3 4 main shared temp closed}
do_test wal2-6.2.9 {
execsql {
INSERT INTO t1 VALUES(5, 6);
SELECT * FROM t1;
pragma lock_status;
}
} {1 2 3 4 5 6 main shared temp closed}
db close
do_test wal2-6.3.1 {
forcedelete test.db test.db-wal test.db-journal
sqlite3 db test.db
execsql {
PRAGMA journal_mode = WAL;
PRAGMA locking_mode = exclusive;
BEGIN;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES('Chico');
INSERT INTO t1 VALUES('Harpo');
COMMIT;
}
list [file exists test.db-wal] [file exists test.db-journal]
} {1 0}
do_test wal2-6.3.2 {
execsql { PRAGMA journal_mode = DELETE }
file exists test.db-wal
} {0}
do_test wal2-6.3.3 {
execsql { PRAGMA lock_status }
} {main exclusive temp closed}
do_test wal2-6.3.4 {
execsql {
BEGIN;
INSERT INTO t1 VALUES('Groucho');
}
} {}
if {[atomic_batch_write test.db]==0} {
do_test wal2-6.3.4.1 {
list [file exists test.db-wal] [file exists test.db-journal]
} {0 1}
}
do_test wal2-6.3.5 {
execsql { PRAGMA lock_status }
} {main exclusive temp closed}
do_test wal2-6.3.6 {
execsql { COMMIT }
} {}
if {[atomic_batch_write test.db]==0} {
do_test wal2-6.3.6.1 {
list [file exists test.db-wal] [file exists test.db-journal]
} {0 1}
}
do_test wal2-6.3.7 {
execsql { PRAGMA lock_status }
} {main exclusive temp closed}
db close
# This test - wal2-6.4.* - uses a single database connection and the
# [testvfs] instrumentation to test that xShmLock() is being called
# as expected when a WAL database is used with locking_mode=exclusive.
#
do_test wal2-6.4.1 {
forcedelete test.db test.db-wal test.db-journal
proc tvfs_cb {method args} {
set ::shm_file [lindex $args 0]
if {$method == "xShmLock"} { lappend ::locks [lindex $args 2] }
return "SQLITE_OK"
}
testvfs tvfs
tvfs script tvfs_cb
sqlite3 db test.db -vfs tvfs
set {} {}
} {}
set RECOVERY {
{0 1 lock exclusive} {1 2 lock exclusive} {4 4 lock exclusive}
{1 2 unlock exclusive} {4 4 unlock exclusive} {0 1 unlock exclusive}
}
set READMARK0_READ {
{3 1 lock shared} {3 1 unlock shared}
}
set READMARK0_WRITE {
{3 1 lock shared}
{0 1 lock exclusive} {3 1 unlock shared}
{4 1 lock exclusive} {4 1 unlock exclusive} {4 1 lock shared}
{0 1 unlock exclusive} {4 1 unlock shared}
}
set READMARK1_SET {
{4 1 lock exclusive} {4 1 unlock exclusive}
}
set READMARK1_READ {
{4 1 lock shared} {4 1 unlock shared}
}
set READMARK1_WRITE {
{4 1 lock shared}
{0 1 lock exclusive} {0 1 unlock exclusive}
{4 1 unlock shared}
}
foreach {tn sql res expected_locks} {
2 {
PRAGMA auto_vacuum = 0;
PRAGMA journal_mode = WAL;
BEGIN;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES('Leonard');
INSERT INTO t1 VALUES('Arthur');
COMMIT;
} {wal} {
$RECOVERY
$READMARK0_WRITE
}
3 {
# This test should do the READMARK1_SET locking to populate the
# aReadMark[1] slot with the current mxFrame value. Followed by
# READMARK1_READ to read the database.
#
SELECT * FROM t1
} {Leonard Arthur} {
$READMARK1_SET
$READMARK1_READ
}
4 {
# aReadMark[1] is already set to mxFrame. So just READMARK1_READ
# this time, not READMARK1_SET.
#
SELECT * FROM t1 ORDER BY x
} {Arthur Leonard} {
$READMARK1_READ
}
5 {
PRAGMA locking_mode = exclusive
} {exclusive} { }
6 {
INSERT INTO t1 VALUES('Julius Henry');
SELECT * FROM t1;
} {Leonard Arthur {Julius Henry}} {
$READMARK1_READ
}
7 {
INSERT INTO t1 VALUES('Karl');
SELECT * FROM t1;
} {Leonard Arthur {Julius Henry} Karl} { }
8 {
PRAGMA locking_mode = normal
} {normal} { }
9 {
SELECT * FROM t1 ORDER BY x
} {Arthur {Julius Henry} Karl Leonard} $READMARK1_READ
10 { DELETE FROM t1 } {} $READMARK1_WRITE
11 {
SELECT * FROM t1
} {} {
$READMARK1_SET
$READMARK1_READ
}
} {
set L [list]
foreach el [subst $expected_locks] { lappend L $el }
set S ""
foreach sq [split $sql "\n"] {
set sq [string trim $sq]
if {[string match {#*} $sq]==0} {append S "$sq\n"}
}
set ::locks [list]
do_test wal2-6.4.$tn.1 { execsql $S } $res
do_test wal2-6.4.$tn.2 { set ::locks } $L
}
db close
tvfs delete
do_test wal2-6.5.1 {
sqlite3 db test.db
execsql {
PRAGMA auto_vacuum = 0;
PRAGMA journal_mode = wal;
PRAGMA locking_mode = exclusive;
CREATE TABLE t2(a, b);
PRAGMA wal_checkpoint;
INSERT INTO t2 VALUES('I', 'II');
PRAGMA journal_mode;
}
} {wal exclusive 0 2 2 wal}
do_test wal2-6.5.2 {
execsql {
PRAGMA locking_mode = normal;
INSERT INTO t2 VALUES('III', 'IV');
PRAGMA locking_mode = exclusive;
SELECT * FROM t2;
}
} {normal exclusive I II III IV}
do_test wal2-6.5.3 {
execsql { PRAGMA wal_checkpoint }
} {0 2 2}
db close
proc lock_control {method filename handle spec} {
foreach {start n op type} $spec break
if {$op == "lock"} { return SQLITE_IOERR }
return SQLITE_OK
}
do_test wal2-6.6.1 {
testvfs T
T script lock_control
T filter {}
sqlite3 db test.db -vfs T
execsql { SELECT * FROM sqlite_master }
execsql { PRAGMA locking_mode = exclusive }
execsql { INSERT INTO t2 VALUES('V', 'VI') }
} {}
do_test wal2-6.6.2 {
execsql { PRAGMA locking_mode = normal }
T filter xShmLock
execsql { INSERT INTO t2 VALUES('VII', 'VIII') }
} {}
do_test wal2-6.6.3 {
# At this point the connection should still be in exclusive-mode, even
# though it tried to exit exclusive-mode when committing the INSERT
# statement above. To exit exclusive mode, SQLite has to take a read-lock
# on the WAL file using xShmLock(). Since that call failed, it remains
# in exclusive mode.
#
sqlite3 db2 test.db -vfs T
catchsql { SELECT * FROM t2 } db2
} {1 {database is locked}}
do_test wal2-6.6.2 {
db2 close
T filter {}
execsql { INSERT INTO t2 VALUES('IX', 'X') }
} {}
do_test wal2-6.6.4 {
# This time, we have successfully exited exclusive mode. So the second
# connection can read the database.
sqlite3 db2 test.db -vfs T
catchsql { SELECT * FROM t2 } db2
} {0 {I II III IV V VI VII VIII IX X}}
db close
db2 close
T delete
#-------------------------------------------------------------------------
# Test a theory about the checksum algorithm. Theory was false and this
# test did not provoke a bug.
#
forcedelete test.db test.db-wal test.db-journal
do_test wal2-7.1.1 {
sqlite3 db test.db
execsql {
PRAGMA page_size = 4096;
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a, b);
}
file size test.db
} {4096}
do_test wal2-7.1.2 {
forcecopy test.db test2.db
forcecopy test.db-wal test2.db-wal
# The first 32 bytes of the WAL file contain the WAL header. Offset 48
# is the first byte of the checksum for the first frame in the WAL.
# The following three lines replaces the contents of that byte with
# a different value.
set newval FF
if {$newval == [hexio_read test2.db-wal 48 1]} { set newval 00 }
hexio_write test2.db-wal 48 $newval
} {1}
do_test wal2-7.1.3 {
sqlite3 db2 test2.db
execsql { PRAGMA wal_checkpoint } db2
execsql { SELECT * FROM sqlite_master } db2
} {}
db close
db2 close
forcedelete test.db test.db-wal test.db-journal
do_test wal2-8.1.2 {
sqlite3 db test.db
execsql {
PRAGMA auto_vacuum=OFF;
PRAGMA page_size = 1024;
PRAGMA journal_mode = WAL;
CREATE TABLE t1(x);
INSERT INTO t1 VALUES(zeroblob(8188*1020));
CREATE TABLE t2(y);
PRAGMA wal_checkpoint;
}
execsql {
SELECT rootpage>=8192 FROM sqlite_master WHERE tbl_name = 't2';
}
} {1}
do_test wal2-8.1.3 {
execsql {
PRAGMA cache_size = 10;
CREATE TABLE t3(z);
BEGIN;
INSERT INTO t3 VALUES(randomblob(900));
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t2 VALUES('hello');
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t3 SELECT randomblob(900) FROM t3;
ROLLBACK;
}
execsql {
INSERT INTO t2 VALUES('goodbye');
INSERT INTO t3 SELECT randomblob(900) FROM t3;
INSERT INTO t3 SELECT randomblob(900) FROM t3;
}
} {}
do_test wal2-8.1.4 {
sqlite3 db2 test.db
execsql { SELECT * FROM t2 }
} {goodbye}
db2 close
db close
#-------------------------------------------------------------------------
# Test that even if the checksums for both are valid, if the two copies
# of the wal-index header in the wal-index do not match, the client
# runs (or at least tries to run) database recovery.
#
#
proc get_name {method args} { set ::filename [lindex $args 0] ; tvfs filter {} }
testvfs tvfs
tvfs script get_name
tvfs filter xShmOpen
forcedelete test.db test.db-wal test.db-journal
do_test wal2-9.1 {
sqlite3 db test.db -vfs tvfs
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE x(y);
INSERT INTO x VALUES('Barton');
INSERT INTO x VALUES('Deakin');
}
# Set $wih(1) to the contents of the wal-index header after
# the frames associated with the first two rows in table 'x' have
# been inserted. Then insert one more row and set $wih(2)
# to the new value of the wal-index header.
#
# If the $wih(1) is written into the wal-index before running
# a read operation, the client will see only the first two rows. If
# $wih(2) is written into the wal-index, the client will see
# three rows. If an invalid header is written into the wal-index, then
# the client will run recovery and see three rows.
#
set wih(1) [set_tvfs_hdr $::filename]
execsql { INSERT INTO x VALUES('Watson') }
set wih(2) [set_tvfs_hdr $::filename]
sqlite3 db2 test.db -vfs tvfs
execsql { SELECT * FROM x } db2
} {Barton Deakin Watson}
foreach {tn hdr1 hdr2 res} [list \
3 $wih(1) $wih(1) {Barton Deakin} \
4 $wih(1) $wih(2) {Barton Deakin Watson} \
5 $wih(2) $wih(1) {Barton Deakin Watson} \
6 $wih(2) $wih(2) {Barton Deakin Watson} \
7 $wih(1) $wih(1) {Barton Deakin} \
8 {0 0 0 0 0 0 0 0 0 0 0 0} {0 0 0 0 0 0 0 0 0 0 0 0} {Barton Deakin Watson}
] {
do_test wal2-9.$tn {
set_tvfs_hdr $::filename $hdr1 $hdr2
execsql { SELECT * FROM x } db2
} $res
}
db2 close
db close
#-------------------------------------------------------------------------
# This block of tests - wal2-10.* - focus on the libraries response to
# new versions of the wal or wal-index formats.
#
# wal2-10.1.*: Test that the library refuses to "recover" a new WAL
# format.
#
# wal2-10.2.*: Test that the library refuses to read or write a database
# if the wal-index version is newer than it understands.
#
# At time of writing, the only versions of the wal and wal-index formats
# that exist are versions 3007000 (corresponding to SQLite version 3.7.0,
# the first version of SQLite to feature wal mode).
#
do_test wal2-10.1.1 {
faultsim_delete_and_reopen
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a, b);
PRAGMA wal_checkpoint;
INSERT INTO t1 VALUES(1, 2);
INSERT INTO t1 VALUES(3, 4);
}
faultsim_save_and_close
} {}
do_test wal2-10.1.2 {
faultsim_restore_and_reopen
execsql { SELECT * FROM t1 }
} {1 2 3 4}
do_test wal2-10.1.3 {
faultsim_restore_and_reopen
set hdr [wal_set_walhdr test.db-wal]
lindex $hdr 1
} {3007000}
do_test wal2-10.1.4 {
lset hdr 1 3007001
wal_set_walhdr test.db-wal $hdr
catchsql { SELECT * FROM t1 }
} {1 {unable to open database file}}
testvfs tvfs -default 1
do_test wal2-10.2.1 {
faultsim_restore_and_reopen
execsql { SELECT * FROM t1 }
} {1 2 3 4}
do_test wal2-10.2.2 {
set hdr [set_tvfs_hdr $::filename]
lindex $hdr 0
} {3007000}
do_test wal2-10.2.3 {
lset hdr 0 3007001
wal_fix_walindex_cksum hdr
set_tvfs_hdr $::filename $hdr
catchsql { SELECT * FROM t1 }
} {1 {unable to open database file}}
db close
tvfs delete
#-------------------------------------------------------------------------
# This block of tests - wal2-11.* - tests that it is not possible to put
# the library into an infinite loop by presenting it with a corrupt
# hash table (one that appears to contain a single chain of infinite
# length).
#
# wal2-11.1.*: While reading the hash-table.
#
# wal2-11.2.*: While writing the hash-table.
#
testvfs tvfs -default 1
do_test wal2-11.0 {
faultsim_delete_and_reopen
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a, b, c);
INSERT INTO t1 VALUES(1, 2, 3);
INSERT INTO t1 VALUES(4, 5, 6);
INSERT INTO t1 VALUES(7, 8, 9);
SELECT * FROM t1;
}
} {wal 1 2 3 4 5 6 7 8 9}
do_test wal2-11.1.1 {
sqlite3 db2 test.db
execsql { SELECT name FROM sqlite_master } db2
} {t1}
if {$::tcl_version>=8.5} {
# Set all zeroed slots in the first hash table to invalid values.
#
set blob [string range [tvfs shm $::filename] 0 16383]
set I [string range [tvfs shm $::filename] 16384 end]
binary scan $I t* L
set I [list]
foreach p $L {
lappend I [expr $p ? $p : 400]
}
append blob [binary format t* $I]
tvfs shm $::filename $blob
do_test wal2-11.2 {
catchsql { INSERT INTO t1 VALUES(10, 11, 12) }
} {1 {database disk image is malformed}}
# Fill up the hash table on the first page of shared memory with 0x55 bytes.
#
set blob [string range [tvfs shm $::filename] 0 16383]
append blob [string repeat [binary format c 55] 16384]
tvfs shm $::filename $blob
do_test wal2-11.3 {
catchsql { SELECT * FROM t1 } db2
} {1 {database disk image is malformed}}
}
db close
db2 close
tvfs delete
#-------------------------------------------------------------------------
# If a connection is required to create a WAL or SHM file, it creates
# the new files with the same file-system permissions as the database
# file itself. Test this.
#
if {$::tcl_platform(platform) == "unix"} {
faultsim_delete_and_reopen
# Changed on 2012-02-13: umask is deliberately ignored for -wal files.
#set umask [exec /bin/sh -c umask]
set umask 0
do_test wal2-12.1 {
sqlite3 db test.db
execsql {
CREATE TABLE tx(y, z);
PRAGMA journal_mode = WAL;
}
db close
list [file exists test.db-wal] [file exists test.db-shm]
} {0 0}
foreach {tn permissions} {
1 00644
2 00666
3 00600
4 00755
} {
set effective [format %.5o [expr $permissions & ~$umask]]
do_test wal2-12.2.$tn.1 {
file attributes test.db -permissions $permissions
file attributes test.db -permissions
} $permissions
do_test wal2-12.2.$tn.2 {
list [file exists test.db-wal] [file exists test.db-shm]
} {0 0}
do_test wal2-12.2.$tn.3 {
sqlite3 db test.db
execsql { INSERT INTO tx DEFAULT VALUES }
list [file exists test.db-wal] [file exists test.db-shm]
} {1 1}
do_test wal2-12.2.$tn.4 {
list [file attr test.db-wal -perm] [file attr test.db-shm -perm]
} [list $effective $effective]
do_test wal2-12.2.$tn.5 {
db close
list [file exists test.db-wal] [file exists test.db-shm]
} {0 0}
}
}
#-------------------------------------------------------------------------
# Test the libraries response to discovering that one or more of the
# database, wal or shm files cannot be opened, or can only be opened
# read-only.
#
if {$::tcl_platform(platform) == "unix"} {
proc perm {} {
set L [list]
foreach f {test.db test.db-wal test.db-shm} {
if {[file exists $f]} {
lappend L [file attr $f -perm]
} else {
lappend L {}
}
}
set L
}
faultsim_delete_and_reopen
execsql {
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a, b);
PRAGMA wal_checkpoint;
INSERT INTO t1 VALUES('3.14', '2.72');
}
do_test wal2-13.1.1 {
list [file exists test.db-shm] [file exists test.db-wal]
} {1 1}
faultsim_save_and_close
foreach {tn db_perm wal_perm shm_perm can_open can_read can_write} {
2 00644 00644 00644 1 1 1
3 00644 00400 00644 1 1 0
4 00644 00644 00400 1 1 0
5 00400 00644 00644 1 1 0
7 00644 00000 00644 1 0 0
8 00644 00644 00000 1 0 0
9 00000 00644 00644 0 0 0
} {
faultsim_restore
do_test wal2-13.$tn.1 {
file attr test.db -perm $db_perm
file attr test.db-wal -perm $wal_perm
file attr test.db-shm -perm $shm_perm
set L [file attr test.db -perm]
lappend L [file attr test.db-wal -perm]
lappend L [file attr test.db-shm -perm]
} [list $db_perm $wal_perm $shm_perm]
# If $can_open is true, then it should be possible to open a database
# handle. Otherwise, if $can_open is 0, attempting to open the db
# handle throws an "unable to open database file" exception.
#
set r(1) {0 ok}
set r(0) {1 {unable to open database file}}
do_test wal2-13.$tn.2 {
list [catch {sqlite3 db test.db ; set {} ok} msg] $msg
} $r($can_open)
if {$can_open} {
# If $can_read is true, then the client should be able to read from
# the database file. If $can_read is false, attempting to read should
# throw the "unable to open database file" exception.
#
set a(0) {1 {unable to open database file}}
set a(1) {0 {3.14 2.72}}
do_test wal2-13.$tn.3 {
catchsql { SELECT * FROM t1 }
} $a($can_read)
# Now try to write to the db file. If the client can read but not
# write, then it should throw the familiar "unable to open db file"
# exception. If it can read but not write, the exception should
# be "attempt to write a read only database".
#
# If the client can read and write, the operation should succeed.
#
set b(0,0) {1 {unable to open database file}}
set b(1,0) {1 {attempt to write a readonly database}}
set b(1,1) {0 {}}
do_test wal2-13.$tn.4 {
catchsql { INSERT INTO t1 DEFAULT VALUES }
} $b($can_read,$can_write)
}
catch { db close }
}
}
#-------------------------------------------------------------------------
# Test that "PRAGMA checkpoint_fullsync" appears to be working.
#
foreach {tn sql reslist} {
1 { } {10 0 4 0 6 0}
2 { PRAGMA checkpoint_fullfsync = 1 } {10 6 4 3 6 3}
3 { PRAGMA checkpoint_fullfsync = 0 } {10 0 4 0 6 0}
} {
ifcapable default_ckptfullfsync {
if {[string trim $sql]==""} continue
}
faultsim_delete_and_reopen
execsql {PRAGMA auto_vacuum = 0; PRAGMA synchronous = FULL;}
execsql $sql
do_execsql_test wal2-14.$tn.0 { PRAGMA page_size = 4096 } {}
do_execsql_test wal2-14.$tn.1 { PRAGMA journal_mode = WAL } {wal}
set sqlite_sync_count 0
set sqlite_fullsync_count 0
do_execsql_test wal2-14.$tn.2 {
PRAGMA wal_autocheckpoint = 10;
CREATE TABLE t1(a, b); -- 2 wal syncs
INSERT INTO t1 VALUES(1, 2); -- 2 wal sync
PRAGMA wal_checkpoint; -- 1 wal sync, 1 db sync
BEGIN;
INSERT INTO t1 VALUES(3, 4);
INSERT INTO t1 VALUES(5, 6);
COMMIT; -- 2 wal sync
PRAGMA wal_checkpoint; -- 1 wal sync, 1 db sync
} {10 0 3 3 0 1 1}
do_test wal2-14.$tn.3 {
cond_incr_sync_count 1
list $sqlite_sync_count $sqlite_fullsync_count
} [lrange $reslist 0 1]
set sqlite_sync_count 0
set sqlite_fullsync_count 0
do_test wal2-14.$tn.4 {
execsql { INSERT INTO t1 VALUES(7, zeroblob(12*4096)) }
list $sqlite_sync_count $sqlite_fullsync_count
} [lrange $reslist 2 3]
set sqlite_sync_count 0
set sqlite_fullsync_count 0
do_test wal2-14.$tn.5 {
execsql { PRAGMA wal_autocheckpoint = 1000 }
execsql { INSERT INTO t1 VALUES(9, 10) }
execsql { INSERT INTO t1 VALUES(11, 12) }
execsql { INSERT INTO t1 VALUES(13, 14) }
db close
list $sqlite_sync_count $sqlite_fullsync_count
} [lrange $reslist 4 5]
}
catch { db close }
# PRAGMA checkpoint_fullsync
# PRAGMA fullfsync
# PRAGMA synchronous
#
foreach {tn settings restart_sync commit_sync ckpt_sync} {
1 {0 0 off} {0 0} {0 0} {0 0}
2 {0 0 normal} {1 0} {0 0} {2 0}
3 {0 0 full} {2 0} {1 0} {2 0}
4 {0 1 off} {0 0} {0 0} {0 0}
5 {0 1 normal} {0 1} {0 0} {0 2}
6 {0 1 full} {0 2} {0 1} {0 2}
7 {1 0 off} {0 0} {0 0} {0 0}
8 {1 0 normal} {0 1} {0 0} {0 2}
9 {1 0 full} {1 1} {1 0} {0 2}
10 {1 1 off} {0 0} {0 0} {0 0}
11 {1 1 normal} {0 1} {0 0} {0 2}
12 {1 1 full} {0 2} {0 1} {0 2}
} {
forcedelete test.db
testvfs tvfs -default 1
tvfs filter xSync
tvfs script xSyncCb
proc xSyncCb {method file fileid flags} {
incr ::sync($flags)
}
sqlite3 db test.db
do_execsql_test 15.$tn.1 "
PRAGMA page_size = 4096;
CREATE TABLE t1(x);
PRAGMA wal_autocheckpoint = OFF;
PRAGMA journal_mode = WAL;
PRAGMA checkpoint_fullfsync = [lindex $settings 0];
PRAGMA fullfsync = [lindex $settings 1];
PRAGMA synchronous = [lindex $settings 2];
" {0 wal}
do_test 15.$tn.2 {
set sync(normal) 0
set sync(full) 0
execsql { INSERT INTO t1 VALUES('abc') }
list $::sync(normal) $::sync(full)
} $restart_sync
do_test 15.$tn.3 {
set sync(normal) 0
set sync(full) 0
execsql { INSERT INTO t1 VALUES('abc') }
list $::sync(normal) $::sync(full)
} $commit_sync
do_test 15.$tn.4 {
set sync(normal) 0
set sync(full) 0
execsql { INSERT INTO t1 VALUES('def') }
list $::sync(normal) $::sync(full)
} $commit_sync
do_test 15.$tn.5 {
set sync(normal) 0
set sync(full) 0
execsql { PRAGMA wal_checkpoint }
list $::sync(normal) $::sync(full)
} $ckpt_sync
db close
tvfs delete
}
finish_test
Reference in New Issue View Git Blame Copy Permalink