Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(558)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/sqlite/src/test/wal3.test

Issue 6990047: Import SQLite 3.7.6.3. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 9 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/sqlite/src/test/wal2.test ('k') | third_party/sqlite/src/test/wal4.test » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/sqlite/src/test/wal3.test
diff --git a/third_party/sqlite/src/test/wal3.test b/third_party/sqlite/src/test/wal3.test
new file mode 100644
index 0000000000000000000000000000000000000000..bd296154e0065e97280d5b62279f7cdb88612a40
--- /dev/null
+++ b/third_party/sqlite/src/test/wal3.test
@@ -0,0 +1,787 @@
+# 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.
+ #
+ file copy -force test.db test2.db
+ file copy -force test.db-wal test2.db-wal
+ file delete -force 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 {
+ file delete -force 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 {
+ file delete -force 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 {
+ file delete -force 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 {
+ file delete -force 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 {
+ file delete -force 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 35 }
+do_test wal3-9.0 {
+ file delete -force 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
+
« no previous file with comments | « third_party/sqlite/src/test/wal2.test ('k') | third_party/sqlite/src/test/wal4.test » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698