embedaddon/sqlite3/test/pagerfault.test - view

File: [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test / pagerfault.test
Revision 1.1: download - view: text, annotated - select for diffs - revision graph
Tue Feb 21 17:04:16 2012 UTC (12 years, 8 months ago) by misho
CVS tags: MAIN, HEAD

Initial revision

# 2010 June 15 # # 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. # #*********************************************************************** # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl source $testdir/malloc_common.tcl if {[permutation] == "inmemory_journal"} { finish_test return } if {$::tcl_platform(platform)=="windows"} { 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 #------------------------------------------------------------------------- # Test fault-injection while rolling back a hot-journal file. # do_test pagerfault-1-pre1 { execsql { PRAGMA journal_mode = DELETE; PRAGMA cache_size = 10; CREATE TABLE t1(a UNIQUE, b UNIQUE); INSERT INTO t1 VALUES(a_string(200), a_string(300)); INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; BEGIN; INSERT INTO t1 SELECT a_string(201), a_string(301) FROM t1; INSERT INTO t1 SELECT a_string(202), a_string(302) FROM t1; INSERT INTO t1 SELECT a_string(203), a_string(303) FROM t1; INSERT INTO t1 SELECT a_string(204), a_string(304) FROM t1; } faultsim_save_and_close } {} do_faultsim_test pagerfault-1 -prep { faultsim_restore_and_reopen } -body { execsql { SELECT count(*) FROM t1 } } -test { faultsim_test_result {0 4} faultsim_integrity_check if {[db one { SELECT count(*) FROM t1 }] != 4} { error "Database content appears incorrect" } } #------------------------------------------------------------------------- # Test fault-injection while rolling back a hot-journal file with a # page-size different from the current value stored on page 1 of the # database file. # do_test pagerfault-2-pre1 { testvfs tv -default 1 tv filter xSync tv script xSyncCb proc xSyncCb {filename args} { if {[string match *journal filename]==0} faultsim_save } faultsim_delete_and_reopen execsql { PRAGMA page_size = 4096; BEGIN; CREATE TABLE abc(a, b, c); INSERT INTO abc VALUES('o', 't', 't'); INSERT INTO abc VALUES('f', 'f', 's'); INSERT INTO abc SELECT * FROM abc; -- 4 INSERT INTO abc SELECT * FROM abc; -- 8 INSERT INTO abc SELECT * FROM abc; -- 16 INSERT INTO abc SELECT * FROM abc; -- 32 INSERT INTO abc SELECT * FROM abc; -- 64 INSERT INTO abc SELECT * FROM abc; -- 128 INSERT INTO abc SELECT * FROM abc; -- 256 COMMIT; PRAGMA page_size = 1024; VACUUM; } db close tv delete } {} do_faultsim_test pagerfault-2 -prep { faultsim_restore_and_reopen } -body { execsql { SELECT * FROM abc } } -test { set answer [split [string repeat "ottffs" 128] ""] faultsim_test_result [list 0 $answer] faultsim_integrity_check set res [db eval { SELECT * FROM abc }] if {$res != $answer} { error "Database content appears incorrect ($res)" } } #------------------------------------------------------------------------- # Test fault-injection while rolling back hot-journals that were created # as part of a multi-file transaction. # do_test pagerfault-3-pre1 { testvfs tstvfs -default 1 tstvfs filter xDelete tstvfs script xDeleteCallback proc xDeleteCallback {method file args} { set file [file tail $file] if { [string match *mj* $file] } { faultsim_save } } faultsim_delete_and_reopen db func a_string a_string execsql { ATTACH 'test.db2' AS aux; PRAGMA journal_mode = DELETE; PRAGMA main.cache_size = 10; PRAGMA aux.cache_size = 10; CREATE TABLE t1(a UNIQUE, b UNIQUE); CREATE TABLE aux.t2(a UNIQUE, b UNIQUE); INSERT INTO t1 VALUES(a_string(200), a_string(300)); INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; INSERT INTO t2 SELECT * FROM t1; BEGIN; INSERT INTO t1 SELECT a_string(201), a_string(301) FROM t1; INSERT INTO t1 SELECT a_string(202), a_string(302) FROM t1; INSERT INTO t1 SELECT a_string(203), a_string(303) FROM t1; INSERT INTO t1 SELECT a_string(204), a_string(304) FROM t1; REPLACE INTO t2 SELECT * FROM t1; COMMIT; } db close tstvfs delete } {} do_faultsim_test pagerfault-3 -prep { faultsim_restore_and_reopen } -body { execsql { ATTACH 'test.db2' AS aux; SELECT count(*) FROM t2; SELECT count(*) FROM t1; } } -test { faultsim_test_result {0 {4 4}} {1 {unable to open database: test.db2}} faultsim_integrity_check catchsql { ATTACH 'test.db2' AS aux } if {[db one { SELECT count(*) FROM t1 }] != 4 || [db one { SELECT count(*) FROM t2 }] != 4 } { error "Database content appears incorrect" } } #------------------------------------------------------------------------- # Test fault-injection as part of a vanilla, no-transaction, INSERT # statement. # do_faultsim_test pagerfault-4 -prep { faultsim_delete_and_reopen } -body { execsql { CREATE TABLE x(y); INSERT INTO x VALUES('z'); SELECT * FROM x; } } -test { faultsim_test_result {0 z} faultsim_integrity_check } #------------------------------------------------------------------------- # Test fault-injection as part of a commit when using journal_mode=PERSIST. # Three different cases: # # pagerfault-5.1: With no journal_size_limit configured. # pagerfault-5.2: With a journal_size_limit configured. # pagerfault-5.4: Multi-file transaction. One connection has a # journal_size_limit of 0, the other has no limit. # do_test pagerfault-5-pre1 { faultsim_delete_and_reopen db func a_string a_string execsql { CREATE TABLE t1(a UNIQUE, b UNIQUE); INSERT INTO t1 VALUES(a_string(200), a_string(300)); INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; } faultsim_save_and_close } {} do_faultsim_test pagerfault-5.1 -prep { faultsim_restore_and_reopen db func a_string a_string execsql { PRAGMA journal_mode = PERSIST } } -body { execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_faultsim_test pagerfault-5.2 -prep { faultsim_restore_and_reopen db func a_string a_string execsql { PRAGMA journal_mode = PERSIST; PRAGMA journal_size_limit = 2048; } } -body { execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_faultsim_test pagerfault-5.3 -faults oom-transient -prep { faultsim_restore_and_reopen db func a_string a_string forcedelete test2.db test2.db-journal test2.db-wal execsql { PRAGMA journal_mode = PERSIST; ATTACH 'test2.db' AS aux; PRAGMA aux.journal_mode = PERSIST; PRAGMA aux.journal_size_limit = 0; } } -body { execsql { BEGIN; INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; CREATE TABLE aux.t2 AS SELECT * FROM t1; COMMIT; } } -test { faultsim_test_result {0 {}} catchsql { COMMIT } catchsql { ROLLBACK } faultsim_integrity_check set res "" set rc [catch { set res [db one { PRAGMA aux.integrity_check }] }] if {$rc!=0 || $res != "ok"} {error "integrity-check problem:$rc $res"} } #------------------------------------------------------------------------- # Test fault-injection as part of a commit when using # journal_mode=TRUNCATE. # do_test pagerfault-6-pre1 { faultsim_delete_and_reopen db func a_string a_string execsql { CREATE TABLE t1(a UNIQUE, b UNIQUE); INSERT INTO t1 VALUES(a_string(200), a_string(300)); } faultsim_save_and_close } {} do_faultsim_test pagerfault-6.1 -prep { faultsim_restore_and_reopen db func a_string a_string execsql { PRAGMA journal_mode = TRUNCATE } } -body { execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } # The unix vfs xAccess() method considers a file zero bytes in size to # "not exist". This proc overrides that behaviour so that a zero length # file is considered to exist. # proc xAccess {method filename op args} { if {$op != "SQLITE_ACCESS_EXISTS"} { return "" } return [file exists $filename] } do_faultsim_test pagerfault-6.2 -faults cantopen-* -prep { shmfault filter xAccess shmfault script xAccess faultsim_restore_and_reopen db func a_string a_string execsql { PRAGMA journal_mode = TRUNCATE } } -body { execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } # The following was an attempt to get a bitvec malloc to fail. Didn't work. # # do_test pagerfault-6-pre1 { # faultsim_delete_and_reopen # execsql { # CREATE TABLE t1(x, y, UNIQUE(x, y)); # INSERT INTO t1 VALUES(1, randomblob(1501)); # INSERT INTO t1 VALUES(2, randomblob(1502)); # INSERT INTO t1 VALUES(3, randomblob(1503)); # INSERT INTO t1 VALUES(4, randomblob(1504)); # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # INSERT INTO t1 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1; # } # faultsim_save_and_close # } {} # do_faultsim_test pagerfault-6 -prep { # faultsim_restore_and_reopen # } -body { # execsql { # BEGIN; # UPDATE t1 SET x=x+4 WHERE x=1; # SAVEPOINT one; # UPDATE t1 SET x=x+4 WHERE x=2; # SAVEPOINT three; # UPDATE t1 SET x=x+4 WHERE x=3; # SAVEPOINT four; # UPDATE t1 SET x=x+4 WHERE x=4; # RELEASE three; # COMMIT; # SELECT DISTINCT x FROM t1; # } # } -test { # faultsim_test_result {0 {5 6 7 8}} # faultsim_integrity_check # } # # This is designed to provoke a special case in the pager code: # # If an error (specifically, a FULL or IOERR error) occurs while writing a # dirty page to the file-system in order to free up memory, the pager enters # the "error state". An IO error causes SQLite to roll back the current # transaction (exiting the error state). A FULL error, however, may only # rollback the current statement. # # This block tests that nothing goes wrong if a FULL error occurs while # writing a dirty page out to free memory from within a statement that has # opened a statement transaction. # do_test pagerfault-7-pre1 { faultsim_delete_and_reopen execsql { CREATE TABLE t2(a INTEGER PRIMARY KEY, b); BEGIN; INSERT INTO t2 VALUES(NULL, randomblob(1500)); INSERT INTO t2 VALUES(NULL, randomblob(1500)); INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 4 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 8 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 16 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 32 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 64 COMMIT; CREATE TABLE t1(a PRIMARY KEY, b); INSERT INTO t1 SELECT * FROM t2; DROP TABLE t2; } faultsim_save_and_close } {} do_faultsim_test pagerfault-7 -prep { faultsim_restore_and_reopen execsql { PRAGMA cache_size = 10; BEGIN; UPDATE t1 SET b = randomblob(1500); } } -body { execsql { UPDATE t1 SET a = 65, b = randomblob(1500) WHERE (a+1)>200 } execsql COMMIT } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_test pagerfault-8-pre1 { faultsim_delete_and_reopen execsql { PRAGMA auto_vacuum = 1; CREATE TABLE t1(a INTEGER PRIMARY KEY, b); BEGIN; INSERT INTO t1 VALUES(NULL, randomblob(1500)); INSERT INTO t1 VALUES(NULL, randomblob(1500)); INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 4 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 8 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 16 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 32 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 64 COMMIT; } faultsim_save_and_close set filesize [file size test.db] set {} {} } {} do_test pagerfault-8-pre2 { faultsim_restore_and_reopen execsql { DELETE FROM t1 WHERE a>32 } expr {[file size test.db] < $filesize} } {1} do_faultsim_test pagerfault-8 -prep { faultsim_restore_and_reopen execsql { BEGIN; DELETE FROM t1 WHERE a>32; } } -body { execsql COMMIT } -test { faultsim_test_result {0 {}} faultsim_integrity_check } #------------------------------------------------------------------------- # This test case is specially designed so that during a savepoint # rollback, a new cache entry must be allocated (see comments surrounding # the call to sqlite3PagerAcquire() from within pager_playback_one_page() # for details). Test the effects of injecting an OOM at this point. # do_test pagerfault-9-pre1 { faultsim_delete_and_reopen execsql { PRAGMA auto_vacuum = incremental; CREATE TABLE t1(x); CREATE TABLE t2(y); CREATE TABLE t3(z); INSERT INTO t1 VALUES(randomblob(900)); INSERT INTO t1 VALUES(randomblob(900)); DELETE FROM t1; } faultsim_save_and_close } {} do_faultsim_test pagerfault-9.1 -prep { faultsim_restore_and_reopen execsql { BEGIN; INSERT INTO t1 VALUES(randomblob(900)); INSERT INTO t1 VALUES(randomblob(900)); DROP TABLE t3; DROP TABLE t2; SAVEPOINT abc; PRAGMA incremental_vacuum; } } -body { execsql { ROLLBACK TO abc; COMMIT; PRAGMA freelist_count } } -test { faultsim_test_result {0 2} faultsim_integrity_check set sl [db one { SELECT COALESCE(sum(length(x)), 'null') FROM t1 }] if {$sl!="null" && $sl!=1800} { error "Content looks no good... ($sl)" } } #------------------------------------------------------------------------- # Test fault injection with a temporary database file. # foreach v {a b} { do_faultsim_test pagerfault-10$v -prep { sqlite3 db "" db func a_string a_string; execsql { PRAGMA cache_size = 10; BEGIN; CREATE TABLE xx(a, b, UNIQUE(a, b)); INSERT INTO xx VALUES(a_string(200), a_string(200)); INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx; INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx; INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx; INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx; COMMIT; } } -body { execsql { UPDATE xx SET a = a_string(300) } } -test { faultsim_test_result {0 {}} if {$::v == "b"} { execsql { PRAGMA journal_mode = TRUNCATE } } faultsim_integrity_check faultsim_integrity_check } } #------------------------------------------------------------------------- # Test fault injection with transaction savepoints (savepoints created # when a SAVEPOINT command is executed outside of any other savepoint # or transaction context). # do_test pagerfault-9-pre1 { faultsim_delete_and_reopen db func a_string a_string; execsql { PRAGMA auto_vacuum = on; CREATE TABLE t1(x UNIQUE); CREATE TABLE t2(y UNIQUE); CREATE TABLE t3(z UNIQUE); BEGIN; INSERT INTO t1 VALUES(a_string(202)); INSERT INTO t2 VALUES(a_string(203)); INSERT INTO t3 VALUES(a_string(204)); INSERT INTO t1 SELECT a_string(202) FROM t1; INSERT INTO t1 SELECT a_string(203) FROM t1; INSERT INTO t1 SELECT a_string(204) FROM t1; INSERT INTO t1 SELECT a_string(205) FROM t1; INSERT INTO t2 SELECT a_string(length(x)) FROM t1; INSERT INTO t3 SELECT a_string(length(x)) FROM t1; COMMIT; } faultsim_save_and_close } {} do_faultsim_test pagerfault-11 -prep { faultsim_restore_and_reopen execsql { PRAGMA cache_size = 10 } } -body { execsql { SAVEPOINT trans; UPDATE t2 SET y = y||'2'; INSERT INTO t3 SELECT * FROM t2; DELETE FROM t1; ROLLBACK TO trans; UPDATE t1 SET x = x||'3'; INSERT INTO t2 SELECT * FROM t1; DELETE FROM t3; RELEASE trans; } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } #------------------------------------------------------------------------- # Test fault injection when writing to a database file that resides on # a file-system with a sector-size larger than the database page-size. # do_test pagerfault-12-pre1 { testvfs ss_layer -default 1 ss_layer sectorsize 4096 faultsim_delete_and_reopen db func a_string a_string; execsql { PRAGMA page_size = 1024; PRAGMA journal_mode = PERSIST; PRAGMA cache_size = 10; BEGIN; CREATE TABLE t1(x, y UNIQUE); INSERT INTO t1 VALUES(a_string(333), a_string(444)); INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1; INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1; INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1; INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1; INSERT INTO t1 SELECT a_string(44), a_string(55) FROM t1 LIMIT 13; COMMIT; } faultsim_save_and_close } {} do_faultsim_test pagerfault-12a -prep { faultsim_restore_and_reopen execsql { PRAGMA cache_size = 10 } db func a_string a_string; } -body { execsql { UPDATE t1 SET x = a_string(length(x)), y = a_string(length(y)); } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_test pagerfault-12-pre2 { faultsim_restore_and_reopen execsql { CREATE TABLE t2 AS SELECT * FROM t1 LIMIT 10; } faultsim_save_and_close } {} do_faultsim_test pagerfault-12b -prep { faultsim_restore_and_reopen db func a_string a_string; execsql { SELECT * FROM t1 } } -body { set sql(1) { UPDATE t2 SET x = a_string(280) } set sql(2) { UPDATE t1 SET x = a_string(280) WHERE rowid = 5 } db eval { SELECT rowid FROM t1 LIMIT 2 } { db eval $sql($rowid) } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } catch { db close } ss_layer delete #------------------------------------------------------------------------- # Test fault injection when SQLite opens a database where the size of the # database file is zero bytes but the accompanying journal file is larger # than that. In this scenario SQLite should delete the journal file # without rolling it back, even if it is in all other respects a valid # hot-journal file. # do_test pagerfault-13-pre1 { faultsim_delete_and_reopen db func a_string a_string; execsql { PRAGMA journal_mode = PERSIST; BEGIN; CREATE TABLE t1(x, y UNIQUE); INSERT INTO t1 VALUES(a_string(333), a_string(444)); COMMIT; } db close forcedelete test.db faultsim_save } {} do_faultsim_test pagerfault-13 -prep { faultsim_restore_and_reopen } -body { execsql { CREATE TABLE xx(a, b) } } -test { faultsim_test_result {0 {}} } #--------------------------------------------------------------------------- # Test fault injection into a small backup operation. # do_test pagerfault-14-pre1 { faultsim_delete_and_reopen db func a_string a_string; execsql { PRAGMA journal_mode = PERSIST; ATTACH 'test.db2' AS two; BEGIN; CREATE TABLE t1(x, y UNIQUE); CREATE TABLE two.t2(x, y UNIQUE); INSERT INTO t1 VALUES(a_string(333), a_string(444)); INSERT INTO t2 VALUES(a_string(333), a_string(444)); COMMIT; } faultsim_save_and_close } {} do_faultsim_test pagerfault-14a -prep { faultsim_restore_and_reopen } -body { if {[catch {db backup test.db2} msg]} { error [regsub {.*: } $msg {}] } } -test { faultsim_test_result {0 {}} {1 {}} {1 {SQL logic error or missing database}} } # If TEMP_STORE is 2 or greater, then the database [db2] will be created # as an in-memory database. This test will not work in that case, as it # is not possible to change the page-size of an in-memory database. Even # using the backup API. # if {$TEMP_STORE<2} { do_faultsim_test pagerfault-14b -prep { catch { db2 close } faultsim_restore_and_reopen sqlite3 db2 "" db2 eval { PRAGMA page_size = 4096; CREATE TABLE xx(a) } } -body { sqlite3_backup B db2 main db main B step 200 set rc [B finish] if {[string match SQLITE_IOERR_* $rc]} {set rc SQLITE_IOERR} if {$rc != "SQLITE_OK"} { error [sqlite3_test_errstr $rc] } set {} {} } -test { faultsim_test_result {0 {}} {1 {sqlite3_backup_init() failed}} } } do_faultsim_test pagerfault-14c -prep { catch { db2 close } faultsim_restore_and_reopen sqlite3 db2 test.db2 db2 eval { PRAGMA synchronous = off; PRAGMA page_size = 4096; CREATE TABLE xx(a); } } -body { sqlite3_backup B db2 main db main B step 200 set rc [B finish] if {[string match SQLITE_IOERR_* $rc]} {set rc SQLITE_IOERR} if {$rc != "SQLITE_OK"} { error [sqlite3_test_errstr $rc] } set {} {} } -test { faultsim_test_result {0 {}} {1 {sqlite3_backup_init() failed}} } do_test pagerfault-15-pre1 { faultsim_delete_and_reopen db func a_string a_string; execsql { BEGIN; CREATE TABLE t1(x, y UNIQUE); INSERT INTO t1 VALUES(a_string(11), a_string(22)); INSERT INTO t1 VALUES(a_string(11), a_string(22)); COMMIT; } faultsim_save_and_close } {} do_faultsim_test pagerfault-15 -prep { faultsim_restore_and_reopen db func a_string a_string; } -body { db eval { SELECT * FROM t1 LIMIT 1 } { execsql { BEGIN; INSERT INTO t1 VALUES(a_string(333), a_string(555)); COMMIT; BEGIN; INSERT INTO t1 VALUES(a_string(333), a_string(555)); COMMIT; } } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_test pagerfault-16-pre1 { faultsim_delete_and_reopen execsql { CREATE TABLE t1(x, y UNIQUE) } faultsim_save_and_close } {} do_faultsim_test pagerfault-16 -prep { faultsim_restore_and_reopen } -body { execsql { PRAGMA locking_mode = exclusive; PRAGMA journal_mode = wal; INSERT INTO t1 VALUES(1, 2); INSERT INTO t1 VALUES(3, 4); PRAGMA journal_mode = delete; INSERT INTO t1 VALUES(4, 5); PRAGMA journal_mode = wal; INSERT INTO t1 VALUES(6, 7); PRAGMA journal_mode = persist; INSERT INTO t1 VALUES(8, 9); } } -test { faultsim_test_result {0 {exclusive wal delete wal persist}} faultsim_integrity_check } #------------------------------------------------------------------------- # Test fault injection while changing into and out of WAL mode. # do_test pagerfault-17-pre1 { faultsim_delete_and_reopen execsql { CREATE TABLE t1(a PRIMARY KEY, b); INSERT INTO t1 VALUES(1862, 'Botha'); INSERT INTO t1 VALUES(1870, 'Smuts'); INSERT INTO t1 VALUES(1866, 'Hertzog'); } faultsim_save_and_close } {} do_faultsim_test pagerfault-17a -prep { faultsim_restore_and_reopen } -body { execsql { PRAGMA journal_mode = wal; PRAGMA journal_mode = delete; } } -test { faultsim_test_result {0 {wal delete}} faultsim_integrity_check } do_faultsim_test pagerfault-17b -prep { faultsim_restore_and_reopen execsql { PRAGMA synchronous = OFF } } -body { execsql { PRAGMA journal_mode = wal; INSERT INTO t1 VALUES(22, 'Clarke'); PRAGMA journal_mode = delete; } } -test { faultsim_test_result {0 {wal delete}} faultsim_integrity_check } do_faultsim_test pagerfault-17c -prep { faultsim_restore_and_reopen execsql { PRAGMA locking_mode = exclusive; PRAGMA journal_mode = wal; } } -body { execsql { PRAGMA journal_mode = delete } } -test { faultsim_test_result {0 delete} faultsim_integrity_check } do_faultsim_test pagerfault-17d -prep { catch { db2 close } faultsim_restore_and_reopen sqlite3 db2 test.db execsql { PRAGMA journal_mode = delete } execsql { PRAGMA journal_mode = wal } execsql { INSERT INTO t1 VALUES(99, 'Bradman') } db2 } -body { execsql { PRAGMA journal_mode = delete } } -test { faultsim_test_result {1 {database is locked}} faultsim_integrity_check } do_faultsim_test pagerfault-17e -prep { catch { db2 close } faultsim_restore_and_reopen sqlite3 db2 test.db execsql { PRAGMA journal_mode = delete } execsql { PRAGMA journal_mode = wal } set ::chan [launch_testfixture] testfixture $::chan { sqlite3 db test.db db eval { INSERT INTO t1 VALUES(101, 'Latham') } } catch { testfixture $::chan sqlite_abort } catch { close $::chan } } -body { execsql { PRAGMA journal_mode = delete } } -test { faultsim_test_result {0 delete} faultsim_integrity_check } #------------------------------------------------------------------------- # Test fault-injection when changing from journal_mode=persist to # journal_mode=delete (this involves deleting the journal file). # do_test pagerfault-18-pre1 { faultsim_delete_and_reopen execsql { CREATE TABLE qq(x); INSERT INTO qq VALUES('Herbert'); INSERT INTO qq VALUES('Macalister'); INSERT INTO qq VALUES('Mackenzie'); INSERT INTO qq VALUES('Lilley'); INSERT INTO qq VALUES('Palmer'); } faultsim_save_and_close } {} do_faultsim_test pagerfault-18 -prep { faultsim_restore_and_reopen execsql { PRAGMA journal_mode = PERSIST; INSERT INTO qq VALUES('Beatty'); } } -body { execsql { PRAGMA journal_mode = delete } } -test { faultsim_test_result {0 delete} faultsim_integrity_check } do_faultsim_test pagerfault-19a -prep { sqlite3 db :memory: db func a_string a_string execsql { PRAGMA auto_vacuum = FULL; BEGIN; CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(a_string(5000), a_string(6000)); COMMIT; } } -body { execsql { CREATE TABLE t2(a, b); INSERT INTO t2 SELECT * FROM t1; DELETE FROM t1; } } -test { faultsim_test_result {0 {}} } do_test pagerfault-19-pre1 { faultsim_delete_and_reopen execsql { PRAGMA auto_vacuum = FULL; CREATE TABLE t1(x); INSERT INTO t1 VALUES(1); CREATE TABLE t2(x); INSERT INTO t2 VALUES(2); CREATE TABLE t3(x); INSERT INTO t3 VALUES(3); CREATE TABLE t4(x); INSERT INTO t4 VALUES(4); CREATE TABLE t5(x); INSERT INTO t5 VALUES(5); CREATE TABLE t6(x); INSERT INTO t6 VALUES(6); } faultsim_save_and_close } {} do_faultsim_test pagerfault-19b -prep { faultsim_restore_and_reopen } -body { execsql { BEGIN; UPDATE t4 SET x = x+1; UPDATE t6 SET x = x+1; SAVEPOINT one; UPDATE t3 SET x = x+1; SAVEPOINT two; DROP TABLE t2; ROLLBACK TO one; COMMIT; SELECT * FROM t3; SELECT * FROM t4; SELECT * FROM t6; } } -test { faultsim_test_result {0 {3 5 7}} } #------------------------------------------------------------------------- # This tests fault-injection in a special case in the auto-vacuum code. # do_test pagerfault-20-pre1 { faultsim_delete_and_reopen execsql { PRAGMA cache_size = 10; PRAGMA auto_vacuum = FULL; CREATE TABLE t0(a, b); } faultsim_save_and_close } {} do_faultsim_test pagerfault-20 -prep { faultsim_restore_and_reopen } -body { execsql { BEGIN; CREATE TABLE t1(a, b); CREATE TABLE t2(a, b); DROP TABLE t1; COMMIT; } } -test { faultsim_test_result {0 {}} } do_test pagerfault-21-pre1 { faultsim_delete_and_reopen execsql { PRAGMA cache_size = 10; CREATE TABLE t0(a PRIMARY KEY, b); INSERT INTO t0 VALUES(1, 2); } faultsim_save_and_close } {} do_faultsim_test pagerfault-21 -prep { faultsim_restore_and_reopen } -body { db eval { SELECT * FROM t0 LIMIT 1 } { db eval { INSERT INTO t0 SELECT a+1, b FROM t0 } db eval { INSERT INTO t0 SELECT a+2, b FROM t0 } } } -test { faultsim_test_result {0 {}} } #------------------------------------------------------------------------- # Test fault-injection and rollback when the nReserve header value # is non-zero. # do_test pagerfault-21-pre1 { faultsim_delete_and_reopen execsql { PRAGMA page_size = 1024; PRAGMA journal_mode = WAL; PRAGMA journal_mode = DELETE; } db close hexio_write test.db 20 10 hexio_write test.db 105 03F0 sqlite3 db test.db db func a_string a_string execsql { CREATE TABLE t0(a PRIMARY KEY, b UNIQUE); INSERT INTO t0 VALUES(a_string(222), a_string(333)); INSERT INTO t0 VALUES(a_string(223), a_string(334)); INSERT INTO t0 VALUES(a_string(224), a_string(335)); INSERT INTO t0 VALUES(a_string(225), a_string(336)); } faultsim_save_and_close } {} do_faultsim_test pagerfault-21 -prep { faultsim_restore_and_reopen } -body { execsql { INSERT INTO t0 SELECT a||'x', b||'x' FROM t0 } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } ifcapable crashtest { faultsim_delete_and_reopen execsql { PRAGMA page_size = 1024; PRAGMA journal_mode = WAL; PRAGMA journal_mode = DELETE; } db close hexio_write test.db 20 10 hexio_write test.db 105 03F0 sqlite3 db test.db db func a_string a_string execsql { CREATE TABLE t0(a PRIMARY KEY, b UNIQUE); INSERT INTO t0 VALUES(a_string(222), a_string(333)); INSERT INTO t0 VALUES(a_string(223), a_string(334)); } faultsim_save_and_close for {set iTest 1} {$iTest<50} {incr iTest} { do_test pagerfault-21.crash.$iTest.1 { crashsql -delay 1 -file test.db -seed $iTest { BEGIN; CREATE TABLE t1(a PRIMARY KEY, b UNIQUE); INSERT INTO t1 SELECT a, b FROM t0; COMMIT; } } {1 {child process exited abnormally}} do_test pagerfault-22.$iTest.2 { sqlite3 db test.db execsql { PRAGMA integrity_check } } {ok} db close } } #------------------------------------------------------------------------- # When a 3.7.0 client opens a write-transaction on a database file that # has been appended to or truncated by a pre-370 client, it updates # the db-size in the file header immediately. This test case provokes # errors during that operation. # do_test pagerfault-22-pre1 { faultsim_delete_and_reopen db func a_string a_string execsql { PRAGMA page_size = 1024; PRAGMA auto_vacuum = 0; CREATE TABLE t1(a); CREATE INDEX i1 ON t1(a); INSERT INTO t1 VALUES(a_string(3000)); CREATE TABLE t2(a); INSERT INTO t2 VALUES(1); } db close sql36231 { INSERT INTO t1 VALUES(a_string(3000)) } faultsim_save_and_close } {} do_faultsim_test pagerfault-22 -prep { faultsim_restore_and_reopen } -body { execsql { INSERT INTO t2 VALUES(2) } execsql { SELECT * FROM t2 } } -test { faultsim_test_result {0 {1 2}} faultsim_integrity_check } #------------------------------------------------------------------------- # Provoke an OOM error during a commit of multi-file transaction. One of # the databases written during the transaction is an in-memory database. # This test causes rollback of the in-memory database after CommitPhaseOne() # has successfully returned. i.e. the series of calls for the aborted commit # is: # # PagerCommitPhaseOne(<in-memory-db>) -> SQLITE_OK # PagerCommitPhaseOne(<file-db>) -> SQLITE_IOERR # PagerRollback(<in-memory-db>) # PagerRollback(<file-db>) # do_faultsim_test pagerfault-23 -prep { sqlite3 db :memory: foreach f [glob -nocomplain test.db*] { forcedelete $f } db eval { ATTACH 'test.db2' AS aux; CREATE TABLE t1(a, b); CREATE TABLE aux.t2(a, b); } } -body { execsql { BEGIN; INSERT INTO t1 VALUES(1,2); INSERT INTO t2 VALUES(3,4); COMMIT; } } -test { faultsim_test_result {0 {}} faultsim_integrity_check } do_faultsim_test pagerfault-24 -prep { faultsim_delete_and_reopen db eval { PRAGMA temp_store = file } execsql { CREATE TABLE x(a, b) } } -body { execsql { CREATE TEMP TABLE t1(a, b) } } -test { faultsim_test_result {0 {}} \ {1 {unable to open a temporary database file for storing temporary tables}} set ic [db eval { PRAGMA temp.integrity_check }] if {$ic != "ok"} { error "Integrity check: $ic" } } proc lockrows {n} { if {$n==0} { return "" } db eval { SELECT * FROM t1 WHERE oid = $n } { return [lockrows [expr {$n-1}]] } } do_test pagerfault-25-pre1 { faultsim_delete_and_reopen db func a_string a_string execsql { PRAGMA page_size = 1024; PRAGMA auto_vacuum = 0; CREATE TABLE t1(a); INSERT INTO t1 VALUES(a_string(500)); INSERT INTO t1 SELECT a_string(500) FROM t1; INSERT INTO t1 SELECT a_string(500) FROM t1; INSERT INTO t1 SELECT a_string(500) FROM t1; INSERT INTO t1 SELECT a_string(500) FROM t1; INSERT INTO t1 SELECT a_string(500) FROM t1; } faultsim_save_and_close } {} do_faultsim_test pagerfault-25 -prep { faultsim_restore_and_reopen db func a_string a_string set ::channel [db incrblob -readonly t1 a 1] execsql { PRAGMA cache_size = 10; BEGIN; INSERT INTO t1 VALUES(a_string(3000)); INSERT INTO t1 VALUES(a_string(3000)); } } -body { lockrows 30 } -test { catch { lockrows 30 } catch { db eval COMMIT } close $::channel faultsim_test_result {0 {}} } do_faultsim_test pagerfault-26 -prep { faultsim_delete_and_reopen execsql { PRAGMA page_size = 1024; PRAGMA journal_mode = truncate; PRAGMA auto_vacuum = full; PRAGMA locking_mode=exclusive; CREATE TABLE t1(a, b); INSERT INTO t1 VALUES(1, 2); PRAGMA page_size = 4096; } } -body { execsql { VACUUM; } } -test { faultsim_test_result {0 {}} set contents [db eval {SELECT * FROM t1}] if {$contents != "1 2"} { error "Bad database contents ($contents)" } set sz [file size test.db] if {$testrc!=0 && $sz!=1024*3 && $sz!=4096*3} { error "Expected file size to be 3072 or 12288 bytes - actual size $sz bytes" } if {$testrc==0 && $sz!=4096*3} { error "Expected file size to be 12288 bytes - actual size $sz bytes" } } do_test pagerfault-27-pre { faultsim_delete_and_reopen db func a_string a_string execsql { PRAGMA page_size = 1024; CREATE TABLE t1(a, b); CREATE TABLE t2(a UNIQUE, b UNIQUE); INSERT INTO t2 VALUES( a_string(800), a_string(800) ); INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2; INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2; INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2; INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2; INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2; INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2; INSERT INTO t1 VALUES (a_string(20000), a_string(20000)); } faultsim_save_and_close } {} do_faultsim_test pagerfault-27 -faults ioerr-persistent -prep { faultsim_restore_and_reopen db func a_string a_string execsql { PRAGMA cache_size = 10; BEGIN EXCLUSIVE; } set ::channel [db incrblob t1 a 1] } -body { puts $::channel [string repeat abc 6000] flush $::channel } -test { catchsql { UPDATE t2 SET a = a_string(800), b = a_string(800) } catch { close $::channel } catchsql { ROLLBACK } faultsim_integrity_check } finish_test