# 2005 December 30 # # 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. # #*********************************************************************** # # The focus of the tests in this file are IO errors that occur in a shared # cache context. What happens to connection B if one connection A encounters # an IO-error whilst reading or writing the file-system? # # $Id: shared_err.test,v 1.5 2006/01/23 13:09:47 danielk1977 Exp $ proc skip {args} {} set testdir [file dirname $argv0] source $testdir/tester.tcl db close ifcapable !shared_cache||!subquery { finish_test return } set ::enable_shared_cache [sqlite3_enable_shared_cache 1] # Todo: This is a copy of the [do_malloc_test] proc in malloc.test # It would be better if these were consolidated. # Usage: do_malloc_test # # The first argument, , is an integer used to name the # tests executed by this proc. Options are as follows: # # -tclprep TCL script to run to prepare test. # -sqlprep SQL script to run to prepare test. # -tclbody TCL script to run with malloc failure simulation. # -sqlbody TCL script to run with malloc failure simulation. # -cleanup TCL script to run after the test. # # This command runs a series of tests to verify SQLite's ability # to handle an out-of-memory condition gracefully. It is assumed # that if this condition occurs a malloc() call will return a # NULL pointer. Linux, for example, doesn't do that by default. See # the "BUGS" section of malloc(3). # # Each iteration of a loop, the TCL commands in any argument passed # to the -tclbody switch, followed by the SQL commands in any argument # passed to the -sqlbody switch are executed. Each iteration the # Nth call to sqliteMalloc() is made to fail, where N is increased # each time the loop runs starting from 1. When all commands execute # successfully, the loop ends. # proc do_malloc_test {tn args} { array unset ::mallocopts array set ::mallocopts $args set ::go 1 for {set ::n 1} {$::go && $::n < 50000} {incr ::n} { do_test shared_malloc-$tn.$::n { # Remove all traces of database files test.db and test2.db from the files # system. Then open (empty database) "test.db" with the handle [db]. # sqlite_malloc_fail 0 catch {db close} catch {file delete -force test.db} catch {file delete -force test.db-journal} catch {file delete -force test2.db} catch {file delete -force test2.db-journal} catch {sqlite3 db test.db} set ::DB [sqlite3_connection_pointer db] # Execute any -tclprep and -sqlprep scripts. # if {[info exists ::mallocopts(-tclprep)]} { eval $::mallocopts(-tclprep) } if {[info exists ::mallocopts(-sqlprep)]} { execsql $::mallocopts(-sqlprep) } # Now set the ${::n}th malloc() to fail and execute the -tclbody and # -sqlbody scripts. # sqlite_malloc_fail $::n set ::mallocbody {} if {[info exists ::mallocopts(-tclbody)]} { append ::mallocbody "$::mallocopts(-tclbody)\n" } if {[info exists ::mallocopts(-sqlbody)]} { append ::mallocbody "db eval {$::mallocopts(-sqlbody)}" } set v [catch $::mallocbody msg] set leftover [lindex [sqlite_malloc_stat] 2] if {$leftover>0} { if {$leftover>1} {puts "\nLeftover: $leftover\nReturn=$v Message=$msg"} set ::go 0 if {$v} { puts "\nError message returned: $msg" } else { set v {1 1} } } else { set v2 [expr {$msg=="" || $msg=="out of memory"}] if {!$v2} {puts "\nError message returned: $msg"} lappend v $v2 } } {1 1} sqlite_malloc_fail 0 if {[info exists ::mallocopts(-cleanup)]} { catch [list uplevel #0 $::mallocopts(-cleanup)] msg } } unset ::mallocopts } do_ioerr_test shared_ioerr-1 -tclprep { sqlite3 db2 test.db execsql { PRAGMA read_uncommitted = 1; CREATE TABLE t1(a,b,c); BEGIN; SELECT * FROM sqlite_master; } db2 } -sqlbody { SELECT * FROM sqlite_master; INSERT INTO t1 VALUES(1,2,3); BEGIN TRANSACTION; INSERT INTO t1 VALUES(1,2,3); INSERT INTO t1 VALUES(4,5,6); ROLLBACK; SELECT * FROM t1; BEGIN TRANSACTION; INSERT INTO t1 VALUES(1,2,3); INSERT INTO t1 VALUES(4,5,6); COMMIT; SELECT * FROM t1; DELETE FROM t1 WHERE a<100; } -cleanup { do_test shared_ioerr-1.$n.cleanup.1 { set res [catchsql { SELECT * FROM t1; } db2] set possible_results [list \ "1 {disk I/O error}" \ "0 {1 2 3}" \ "0 {1 2 3 1 2 3 4 5 6}" \ "0 {1 2 3 1 2 3 4 5 6 1 2 3 4 5 6}" \ "0 {}" \ ] set rc [expr [lsearch -exact $possible_results $res] >= 0] if {$rc != 1} { puts "" puts "Result: $res" } set rc } {1} db2 close } do_ioerr_test shared_ioerr-2 -tclprep { sqlite3 db2 test.db execsql { PRAGMA read_uncommitted = 1; BEGIN; CREATE TABLE t1(a, b); INSERT INTO t1(oid) VALUES(NULL); INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; INSERT INTO t1(oid) SELECT NULL FROM t1; UPDATE t1 set a = oid, b = 'abcdefghijklmnopqrstuvwxyz0123456789'; CREATE INDEX i1 ON t1(a); COMMIT; BEGIN; SELECT * FROM sqlite_master; } db2 } -tclbody { set ::residx 0 execsql {DELETE FROM t1 WHERE 0 = (a % 2);} incr ::residx # When this transaction begins the table contains 512 entries. The # two statements together add 512+146 more if it succeeds. # (1024/7==146) execsql {BEGIN;} execsql {INSERT INTO t1 SELECT a+1, b FROM t1;} execsql {INSERT INTO t1 SELECT 'string' || a, b FROM t1 WHERE 0 = (a%7);} execsql {COMMIT;} incr ::residx } -cleanup { do_test shared_ioerr-2.$n.cleanup.1 { set res [catchsql { SELECT max(a), min(a), count(*) FROM (SELECT a FROM t1 order by a); } db2] set possible_results [list \ {0 {1024 1 1024}} \ {0 {1023 1 512}} \ {0 {string994 1 1170}} \ ] set idx [lsearch -exact $possible_results $res] set success [expr {$idx==$::residx || $res=="1 {disk I/O error}"}] if {!$success} { puts "" puts "Result: \"$res\" ($::residx)" } set success } {1} db2 close } # This test is designed to provoke an IO error when a cursor position is # "saved" (because another cursor is going to modify the underlying table). # do_ioerr_test shared_ioerr-3 -tclprep { sqlite3 db2 test.db execsql { PRAGMA read_uncommitted = 1; PRAGMA cache_size = 10; BEGIN; CREATE TABLE t1(a, b, UNIQUE(a, b)); } db2 for {set i 0} {$i < 200} {incr i} { set a [string range [string repeat "[format %03d $i]." 5] 0 end-1] set b [string repeat $i 2000] execsql {INSERT INTO t1 VALUES($a, $b)} db2 } execsql {COMMIT} db2 set ::DB2 [sqlite3_connection_pointer db2] set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY] sqlite3_step $::STMT ;# Cursor points at 000.000.000.000 sqlite3_step $::STMT ;# Cursor points at 001.001.001.001 } -tclbody { execsql { BEGIN; INSERT INTO t1 VALUES('201.201.201.201.201', NULL); UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%'; COMMIT; } } -cleanup { do_test shared_ioerr-3.$n.cleanup.1 { sqlite3_step $::STMT } {SQLITE_ROW} do_test shared_ioerr-3.$n.cleanup.2 { sqlite3_column_text $::STMT 0 } {002.002.002.002.002} do_test shared_ioerr-3.$n.cleanup.3 { sqlite3_finalize $::STMT } {SQLITE_OK} # db2 eval {select * from sqlite_master} db2 close } # Provoke a malloc() failure when a cursor position is being saved. This # only happens with index cursors (because they malloc() space to save the # current key value). It does not happen with tables, because an integer # key does not require a malloc() to store. # # The library should return an SQLITE_NOMEM to the caller. The query that # owns the cursor (the one for which the position is not saved) should # continue unaffected. # do_malloc_test 4 -tclprep { sqlite3 db2 test.db execsql { PRAGMA read_uncommitted = 1; BEGIN; CREATE TABLE t1(a, b, UNIQUE(a, b)); } db2 for {set i 0} {$i < 5} {incr i} { set a [string repeat $i 10] set b [string repeat $i 2000] execsql {INSERT INTO t1 VALUES($a, $b)} db2 } execsql {COMMIT} db2 set ::DB2 [sqlite3_connection_pointer db2] set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY] sqlite3_step $::STMT ;# Cursor points at 0000000000 sqlite3_step $::STMT ;# Cursor points at 1111111111 } -tclbody { execsql { INSERT INTO t1 VALUES(6, NULL); } } -cleanup { do_test shared_malloc-4.$::n.cleanup.1 { sqlite3_step $::STMT } {SQLITE_ROW} do_test shared_malloc-4.$::n.cleanup.2 { sqlite3_column_text $::STMT 0 } {2222222222} do_test shared_malloc-4.$::n.cleanup.3 { sqlite3_finalize $::STMT } {SQLITE_OK} # db2 eval {select * from sqlite_master} db2 close } do_malloc_test 5 -tclbody { sqlite3 dbX test.db sqlite3 dbY test.db dbX close dbY close } -cleanup { catch {dbX close} catch {dbY close} } catch {db close} sqlite3_enable_shared_cache $::enable_shared_cache finish_test