-C Test\sthat\sthe\scorrect\snumber\sof\spadding\sframes\sare\sappended\sto\sthe\slog\sfile\safter\scommitting\sa\stransaction\sin\ssynchronous=FULL\smode.
-D 2010-05-04T10:36:21
+C Fix\sa\stypo\sin\swalfault.test.
+D 2010-05-04T11:06:03
F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0
F Makefile.in d83a0ffef3dcbfb08b410a6c6dd6c009ec9167fb
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
F src/vdbemem.c 2a82f455f6ca6f78b59fb312f96054c04ae0ead1
F src/vdbetrace.c 864cef96919323482ebd9986f2132435115e9cc2
F src/vtab.c a0f8a40274e4261696ef57aa806de2776ab72cda
-F src/wal.c fcd2c4ce4a7d44928763966c2199e0de800fae89
+F src/wal.c 1d0abe01ae9836f207ecfe2d3f1ece97b744fc3e
F src/wal.h d6d4a6809151e30bed5b01dd05cf27858f5a7bc8
F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
F src/where.c 75fee9e255b62f773fcadd1d1f25b6f63ac7a356
F test/fts2r.test b154c30b63061d8725e320fba1a39e2201cadd5e
F test/fts2token.test d8070b241a15ff13592a9ae4a8b7c171af6f445a
F test/fts3.test ae0433b09b12def08105640e57693726c4949338
-F test/fts3_common.tcl 1d887ded06dac9b993cfb175618df7f70c796de2
+F test/fts3_common.tcl 4d8eec9db565fed9098f45c378f28e1657802011
F test/fts3aa.test 5327d4c1d9b6c61021696746cc9a6cdc5bf159c0
F test/fts3ab.test 09aeaa162aee6513d9ff336b6932211008b9d1f9
F test/fts3ac.test 636ed7486043055d4f126a0e385f2d5a82ebbf63
F test/fts3expr2.test 18da930352e5693eaa163a3eacf96233b7290d1a
F test/fts3malloc.test 059592c4f37ccd30138bbf8e3e5b7982cb5c8f2e
F test/fts3near.test 2e318ee434d32babd27c167142e2b94ddbab4844
-F test/fts3query.test 1acb21b58d6aa7504e990f0f589be85e9a133969
-F test/fts3rnd.test 2f5761db9dd92f6fe09d08976ac658ef521846ed
+F test/fts3query.test 2468caf7938dbc3be2e049524320ce4faf2227b3
+F test/fts3rnd.test 707533ce943f490443ce5e696236bb1675a37635
F test/fts3snippet.test 9f9a4a7e396c5d8ce2898be65ebabc429555430f
F test/fts4aa.test eadf85621c0a113d4c7ad3ccbf8441130e007b8f
F test/func.test 6c5ce11e3a0021ca3c0649234e2d4454c89110ca
F test/mallocI.test e3ea401904d010cb7c1e4b2ee8803f4a9f5b999d
F test/mallocJ.test b5d1839da331d96223e5f458856f8ffe1366f62e
F test/mallocK.test d79968641d1b70d88f6c01bdb9a7eb4a55582cc9
-F test/malloc_common.tcl 206a1694c0d30cb8b8cbdda68ab8e1f232fd1ab9
+F test/malloc_common.tcl f95c4d3459877e64c2d856b8a9c39210f9968ddf
F test/manydb.test b3d3bc4c25657e7f68d157f031eb4db7b3df0d3c
F test/memdb.test 0825155b2290e900264daaaf0334b6dfe69ea498
F test/memleak.test d2d2a1ff7105d32dc3fdf691458cf6cba58c7217
F test/wal.test 511c630993d5adc170f56e581909b6eb580b0f53
F test/walbak.test a0e45187c7d8928df035dfea29b99b016b21ca3c
F test/walcrash.test 63edc6a9e05f645b54d649186a5818fc82953e2e
-F test/walfault.test cdd1a27ed89bcb14596005ab2477b3724dd5f805
+F test/walfault.test 2504c5c50d8f9a9e48969de381eb98e2a8b89195
F test/walhook.test 5f18e0fc8787f1f8889d7a9971af18f334f83786
F test/walmode.test bac6f06544a8554588a1543def996bbe2fc41792
F test/walslow.test d21625e2e99e11c032ce949e8a94661576548933
F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P 49bef00e5cda600ceb964148bf745de4aff1ab62
-R 44e8b17dd54df12e28ab0c945b738027
+P a60104aa7e38e7d9f2ff2eae02687dc9c5dd5d77
+R 9692cfa3edc87873be9342b2b7fc3777
U dan
-Z dab97771a4b803a69cb81f43590ea234
+Z 6f47b056126e5089750d5cf38e878789
-a60104aa7e38e7d9f2ff2eae02687dc9c5dd5d77
\ No newline at end of file
+232dbe8ecec16485be5c5995fdf7a0ed951c2097
\ No newline at end of file
** client from unlinking the log or wal-index file. If another process
** were to do this just after this client opened one of these files, the
** system would be badly broken.
+**
+** If the log file is successfully opened, SQLITE_OK is returned and
+** *ppWal is set to point to a new WAL handle. If an error occurs,
+** an SQLite error code is returned and *ppWal is left unmodified.
*/
int sqlite3WalOpen(
sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */
const char *zDb, /* Name of database file */
Wal **ppWal /* OUT: Allocated Wal handle */
){
- int rc = SQLITE_OK; /* Return Code */
+ int rc; /* Return Code */
Wal *pRet; /* Object to allocate and return */
int flags; /* Flags passed to OsOpen() */
- char *zWal = 0; /* Path to WAL file */
+ char *zWal; /* Path to WAL file */
int nWal; /* Length of zWal in bytes */
assert( zDb );
}
if( rc!=SQLITE_OK ){
- if( pRet ){
- pVfs->xShmClose(pVfs, pRet->pWIndex, 0);
- sqlite3OsClose(pRet->pFd);
- sqlite3_free(pRet);
- }
- pRet = 0;
+ pVfs->xShmClose(pVfs, pRet->pWIndex, 0);
+ sqlite3OsClose(pRet->pFd);
+ sqlite3_free(pRet);
+ }else{
+ *ppWal = pRet;
}
- *ppWal = pRet;
return rc;
}
##########################################################################
-#-------------------------------------------------------------------------
-# This proc is used to test a single SELECT statement. Parameter $name is
-# passed a name for the test case (i.e. "fts3_malloc-1.4.1") and parameter
-# $sql is passed the text of the SELECT statement. Parameter $result is
-# set to the expected output if the SELECT statement is successfully
-# executed using [db eval].
-#
-# Example:
-#
-# do_select_test testcase-1.1 "SELECT 1+1, 1+2" {1 2}
-#
-# If global variable DO_MALLOC_TEST is set to a non-zero value, or if
-# it is not defined at all, then OOM testing is performed on the SELECT
-# statement. Each OOM test case is said to pass if either (a) executing
-# the SELECT statement succeeds and the results match those specified
-# by parameter $result, or (b) TCL throws an "out of memory" error.
-#
-# If DO_MALLOC_TEST is defined and set to zero, then the SELECT statement
-# is executed just once. In this case the test case passes if the results
-# match the expected results passed via parameter $result.
-#
-proc do_select_test {name sql result} {
- uplevel [list doPassiveTest 0 $name $sql [list 0 $result]]
-}
-
-proc do_restart_select_test {name sql result} {
- uplevel [list doPassiveTest 1 $name $sql [list 0 $result]]
-}
-
-proc do_error_test {name sql error} {
- uplevel [list doPassiveTest 0 $name $sql [list 1 $error]]
-}
-
-proc doPassiveTest {isRestart name sql catchres} {
- if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
-
- switch $::DO_MALLOC_TEST {
- 0 { # No malloc failures.
- do_test $name [list set {} [uplevel [list catchsql $sql]]] $catchres
- return
- }
- 1 { # Simulate transient failures.
- set nRepeat 1
- set zName "transient"
- set nStartLimit 100000
- set nBackup 1
- }
- 2 { # Simulate persistent failures.
- set nRepeat 1
- set zName "persistent"
- set nStartLimit 100000
- set nBackup 1
- }
- 3 { # Simulate transient failures with extra brute force.
- set nRepeat 100000
- set zName "ridiculous"
- set nStartLimit 1
- set nBackup 10
- }
- }
-
- # The set of acceptable results from running [catchsql $sql].
- #
- set answers [list {1 {out of memory}} $catchres]
- set str [join $answers " OR "]
-
- set nFail 1
- for {set iLimit $nStartLimit} {$nFail} {incr iLimit} {
- for {set iFail 1} {$nFail && $iFail<=$iLimit} {incr iFail} {
- for {set iTest 0} {$iTest<$nBackup && ($iFail-$iTest)>0} {incr iTest} {
-
- if {$isRestart} { sqlite3 db test.db }
-
- sqlite3_memdebug_fail [expr $iFail-$iTest] -repeat $nRepeat
- set res [uplevel [list catchsql $sql]]
- if {[lsearch -exact $answers $res]>=0} { set res $str }
- set testname "$name.$zName.$iFail"
- do_test "$name.$zName.$iLimit.$iFail" [list set {} $res] $str
-
- set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
- }
- }
- }
-}
-
-
-#-------------------------------------------------------------------------
-# Test a single write to the database. In this case a "write" is a
-# DELETE, UPDATE or INSERT statement.
-#
-# If OOM testing is performed, there are several acceptable outcomes:
-#
-# 1) The write succeeds. No error is returned.
-#
-# 2) An "out of memory" exception is thrown and:
-#
-# a) The statement has no effect, OR
-# b) The current transaction is rolled back, OR
-# c) The statement succeeds. This can only happen if the connection
-# is in auto-commit mode (after the statement is executed, so this
-# includes COMMIT statements).
-#
-# If the write operation eventually succeeds, zero is returned. If a
-# transaction is rolled back, non-zero is returned.
-#
-# Parameter $name is the name to use for the test case (or test cases).
-# The second parameter, $tbl, should be the name of the database table
-# being modified. Parameter $sql contains the SQL statement to test.
-#
-proc do_write_test {name tbl sql} {
- if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
-
- # Figure out an statement to get a checksum for table $tbl.
- db eval "SELECT * FROM $tbl" V break
- set cksumsql "SELECT md5sum([join [concat rowid $V(*)] ,]) FROM $tbl"
-
- # Calculate the initial table checksum.
- set cksum1 [db one $cksumsql]
-
- if {$::DO_MALLOC_TEST } {
- set answers [list {1 {out of memory}} {0 {}}]
- if {$::DO_MALLOC_TEST==1} {
- set modes {100000 transient}
- } else {
- set modes {1 persistent}
- }
- } else {
- set answers [list {0 {}}]
- set modes [list 0 nofail]
- }
- set str [join $answers " OR "]
-
- foreach {nRepeat zName} $modes {
- for {set iFail 1} 1 {incr iFail} {
- if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}
-
- set res [uplevel [list catchsql $sql]]
- set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
- if {$nFail==0} {
- do_test $name.$zName.$iFail [list set {} $res] {0 {}}
- return
- } else {
- if {[lsearch $answers $res]>=0} {
- set res $str
- }
- do_test $name.$zName.$iFail [list set {} $res] $str
- set cksum2 [db one $cksumsql]
- if {$cksum1 != $cksum2} return
- }
- }
- }
-}
# If this build does not include FTS3, skip the tests in this file.
#
ifcapable !fts3 { finish_test ; return }
+source $testdir/malloc_common.tcl
source $testdir/fts3_common.tcl
set DO_MALLOC_TEST 0
#
ifcapable !fts3 { finish_test ; return }
source $testdir/fts3_common.tcl
+source $testdir/malloc_common.tcl
set G(nVocab) 100
unset ::mallocopts
sqlite3_memdebug_fail -1
}
+
+
+#-------------------------------------------------------------------------
+# This proc is used to test a single SELECT statement. Parameter $name is
+# passed a name for the test case (i.e. "fts3_malloc-1.4.1") and parameter
+# $sql is passed the text of the SELECT statement. Parameter $result is
+# set to the expected output if the SELECT statement is successfully
+# executed using [db eval].
+#
+# Example:
+#
+# do_select_test testcase-1.1 "SELECT 1+1, 1+2" {1 2}
+#
+# If global variable DO_MALLOC_TEST is set to a non-zero value, or if
+# it is not defined at all, then OOM testing is performed on the SELECT
+# statement. Each OOM test case is said to pass if either (a) executing
+# the SELECT statement succeeds and the results match those specified
+# by parameter $result, or (b) TCL throws an "out of memory" error.
+#
+# If DO_MALLOC_TEST is defined and set to zero, then the SELECT statement
+# is executed just once. In this case the test case passes if the results
+# match the expected results passed via parameter $result.
+#
+proc do_select_test {name sql result} {
+ uplevel [list doPassiveTest 0 $name $sql [list 0 $result]]
+}
+
+proc do_restart_select_test {name sql result} {
+ uplevel [list doPassiveTest 1 $name $sql [list 0 $result]]
+}
+
+proc do_error_test {name sql error} {
+ uplevel [list doPassiveTest 0 $name $sql [list 1 $error]]
+}
+
+proc doPassiveTest {isRestart name sql catchres} {
+ if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
+
+ switch $::DO_MALLOC_TEST {
+ 0 { # No malloc failures.
+ do_test $name [list set {} [uplevel [list catchsql $sql]]] $catchres
+ return
+ }
+ 1 { # Simulate transient failures.
+ set nRepeat 1
+ set zName "transient"
+ set nStartLimit 100000
+ set nBackup 1
+ }
+ 2 { # Simulate persistent failures.
+ set nRepeat 1
+ set zName "persistent"
+ set nStartLimit 100000
+ set nBackup 1
+ }
+ 3 { # Simulate transient failures with extra brute force.
+ set nRepeat 100000
+ set zName "ridiculous"
+ set nStartLimit 1
+ set nBackup 10
+ }
+ }
+
+ # The set of acceptable results from running [catchsql $sql].
+ #
+ set answers [list {1 {out of memory}} $catchres]
+ set str [join $answers " OR "]
+
+ set nFail 1
+ for {set iLimit $nStartLimit} {$nFail} {incr iLimit} {
+ for {set iFail 1} {$nFail && $iFail<=$iLimit} {incr iFail} {
+ for {set iTest 0} {$iTest<$nBackup && ($iFail-$iTest)>0} {incr iTest} {
+
+ if {$isRestart} { sqlite3 db test.db }
+
+ sqlite3_memdebug_fail [expr $iFail-$iTest] -repeat $nRepeat
+ set res [uplevel [list catchsql $sql]]
+ if {[lsearch -exact $answers $res]>=0} { set res $str }
+ set testname "$name.$zName.$iFail"
+ do_test "$name.$zName.$iLimit.$iFail" [list set {} $res] $str
+
+ set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
+ }
+ }
+ }
+}
+
+
+#-------------------------------------------------------------------------
+# Test a single write to the database. In this case a "write" is a
+# DELETE, UPDATE or INSERT statement.
+#
+# If OOM testing is performed, there are several acceptable outcomes:
+#
+# 1) The write succeeds. No error is returned.
+#
+# 2) An "out of memory" exception is thrown and:
+#
+# a) The statement has no effect, OR
+# b) The current transaction is rolled back, OR
+# c) The statement succeeds. This can only happen if the connection
+# is in auto-commit mode (after the statement is executed, so this
+# includes COMMIT statements).
+#
+# If the write operation eventually succeeds, zero is returned. If a
+# transaction is rolled back, non-zero is returned.
+#
+# Parameter $name is the name to use for the test case (or test cases).
+# The second parameter, $tbl, should be the name of the database table
+# being modified. Parameter $sql contains the SQL statement to test.
+#
+proc do_write_test {name tbl sql} {
+ if {![info exists ::DO_MALLOC_TEST]} { set ::DO_MALLOC_TEST 1 }
+
+ # Figure out an statement to get a checksum for table $tbl.
+ db eval "SELECT * FROM $tbl" V break
+ set cksumsql "SELECT md5sum([join [concat rowid $V(*)] ,]) FROM $tbl"
+
+ # Calculate the initial table checksum.
+ set cksum1 [db one $cksumsql]
+
+ if {$::DO_MALLOC_TEST } {
+ set answers [list {1 {out of memory}} {0 {}}]
+ if {$::DO_MALLOC_TEST==1} {
+ set modes {100000 transient}
+ } else {
+ set modes {1 persistent}
+ }
+ } else {
+ set answers [list {0 {}}]
+ set modes [list 0 nofail]
+ }
+ set str [join $answers " OR "]
+
+ foreach {nRepeat zName} $modes {
+ for {set iFail 1} 1 {incr iFail} {
+ if {$::DO_MALLOC_TEST} {sqlite3_memdebug_fail $iFail -repeat $nRepeat}
+
+ set res [uplevel [list catchsql $sql]]
+ set nFail [sqlite3_memdebug_fail -1 -benigncnt nBenign]
+ if {$nFail==0} {
+ do_test $name.$zName.$iFail [list set {} $res] {0 {}}
+ return
+ } else {
+ if {[lsearch $answers $res]>=0} {
+ set res $str
+ }
+ do_test $name.$zName.$iFail [list set {} $res] $str
+ set cksum2 [db one $cksumsql]
+ if {$cksum1 != $cksum2} return
+ }
+ }
+ }
+}
PRAGMA journal_mode = WAL;
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
- PRAGMA checkpoint;
+ PRAGMA wal_checkpoint;
}
do_malloc_test walfault-oom-2 -tclprep {
projects / thirdparty / sqlite.git / commitdiff
