| # 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.24 2008/10/12 00:27:54 shane Exp $ |
| |
| proc skip {args} {} |
| |
| |
| set testdir [file dirname $argv0] |
| source $testdir/tester.tcl |
| source $testdir/malloc_common.tcl |
| db close |
| |
| ifcapable !shared_cache||!subquery { |
| finish_test |
| return |
| } |
| |
| set ::enable_shared_cache [sqlite3_enable_shared_cache 1] |
| |
| 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 {}" \ |
| "1 {database disk image is malformed}" \ |
| ] |
| set rc [expr [lsearch -exact $possible_results $res] >= 0] |
| if {$rc != 1} { |
| puts "" |
| puts "Result: $res" |
| } |
| set rc |
| } {1} |
| |
| # The "database disk image is malformed" is a special case that can |
| # occur if an IO error occurs during a rollback in the {SELECT * FROM t1} |
| # statement above. This test is to make sure there is no real database |
| # corruption. |
| db2 close |
| do_test shared_ioerr-1.$n.cleanup.2 { |
| execsql {pragma integrity_check} db |
| } {ok} |
| } |
| |
| 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 { |
| catchsql ROLLBACK |
| 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 { |
| set ::steprc [sqlite3_step $::STMT] |
| set ::column [sqlite3_column_text $::STMT 0] |
| set ::finalrc [sqlite3_finalize $::STMT] |
| |
| # There are three possible outcomes here (assuming persistent IO errors): |
| # |
| # 1. If the [sqlite3_step] did not require any IO (required pages in |
| # the cache), then the next row ("002...") may be retrieved |
| # successfully. |
| # |
| # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns |
| # SQLITE_ERROR and [sqlite3_finalize] returns IOERR. |
| # |
| # 3. If, after the initial IO error, SQLite tried to rollback the |
| # active transaction and a second IO error was encountered, then |
| # statement $::STMT will have been aborted. This means [sqlite3_stmt] |
| # returns SQLITE_ABORT, and the statement cursor does not move. i.e. |
| # [sqlite3_column] still returns the current row ("001...") and |
| # [sqlite3_finalize] returns SQLITE_OK. |
| # |
| |
| do_test shared_ioerr-3.$n.cleanup.1 { |
| expr { |
| $::steprc eq "SQLITE_ROW" || |
| $::steprc eq "SQLITE_ERROR" || |
| $::steprc eq "SQLITE_ABORT" |
| } |
| } {1} |
| do_test shared_ioerr-3.$n.cleanup.2 { |
| expr { |
| ($::steprc eq "SQLITE_ROW" && $::column eq "002.002.002.002.002") || |
| ($::steprc eq "SQLITE_ERROR" && $::column eq "") || |
| ($::steprc eq "SQLITE_ABORT" && $::column eq "001.001.001.001.001") |
| } |
| } {1} |
| do_test shared_ioerr-3.$n.cleanup.3 { |
| expr { |
| ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") || |
| ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") || |
| ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT") |
| } |
| } {1} |
| |
| # db2 eval {select * from sqlite_master} |
| db2 close |
| } |
| |
| # This is a repeat of the previous test except that this time we |
| # are doing a reverse-order scan of the table when the cursor is |
| # "saved". |
| # |
| do_ioerr_test shared_ioerr-3rev -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 DESC" -1 DUMMY] |
| sqlite3_step $::STMT ;# Cursor points at 199.199.199.199.199 |
| sqlite3_step $::STMT ;# Cursor points at 198.198.198.198.198 |
| |
| } -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 { |
| set ::steprc [sqlite3_step $::STMT] |
| set ::column [sqlite3_column_text $::STMT 0] |
| set ::finalrc [sqlite3_finalize $::STMT] |
| |
| # There are three possible outcomes here (assuming persistent IO errors): |
| # |
| # 1. If the [sqlite3_step] did not require any IO (required pages in |
| # the cache), then the next row ("002...") may be retrieved |
| # successfully. |
| # |
| # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns |
| # SQLITE_ERROR and [sqlite3_finalize] returns IOERR. |
| # |
| # 3. If, after the initial IO error, SQLite tried to rollback the |
| # active transaction and a second IO error was encountered, then |
| # statement $::STMT will have been aborted. This means [sqlite3_stmt] |
| # returns SQLITE_ABORT, and the statement cursor does not move. i.e. |
| # [sqlite3_column] still returns the current row ("001...") and |
| # [sqlite3_finalize] returns SQLITE_OK. |
| # |
| |
| do_test shared_ioerr-3rev.$n.cleanup.1 { |
| expr { |
| $::steprc eq "SQLITE_ROW" || |
| $::steprc eq "SQLITE_ERROR" || |
| $::steprc eq "SQLITE_ABORT" |
| } |
| } {1} |
| do_test shared_ioerr-3rev.$n.cleanup.2 { |
| expr { |
| ($::steprc eq "SQLITE_ROW" && $::column eq "197.197.197.197.197") || |
| ($::steprc eq "SQLITE_ERROR" && $::column eq "") || |
| ($::steprc eq "SQLITE_ABORT" && $::column eq "198.198.198.198.198") |
| } |
| } {1} |
| do_test shared_ioerr-3rev.$n.cleanup.3 { |
| expr { |
| ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") || |
| ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") || |
| ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT") |
| } |
| } {1} |
| |
| # 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 shared_err-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 { |
| set ::rc [sqlite3_step $::STMT] |
| expr {$::rc=="SQLITE_ROW" || $::rc=="SQLITE_ERROR"} |
| } {1} |
| if {$::rc=="SQLITE_ROW"} { |
| do_test shared_malloc-4.$::n.cleanup.2 { |
| sqlite3_column_text $::STMT 0 |
| } {2222222222} |
| } |
| do_test shared_malloc-4.$::n.cleanup.3 { |
| set rc [sqlite3_finalize $::STMT] |
| expr {$rc=="SQLITE_OK" || $rc=="SQLITE_ABORT" || |
| $rc=="SQLITE_NOMEM" || $rc=="SQLITE_IOERR"} |
| } {1} |
| # db2 eval {select * from sqlite_master} |
| db2 close |
| } |
| |
| do_malloc_test shared_err-5 -tclbody { |
| db close |
| sqlite3 dbX test.db |
| sqlite3 dbY test.db |
| dbX close |
| dbY close |
| } -cleanup { |
| catch {dbX close} |
| catch {dbY close} |
| } |
| |
| do_malloc_test shared_err-6 -tclbody { |
| catch {db close} |
| ifcapable deprecated { |
| sqlite3_thread_cleanup |
| } |
| sqlite3_enable_shared_cache 0 |
| } -cleanup { |
| sqlite3_enable_shared_cache 1 |
| } |
| |
| # As of 3.5.0, sqlite3_enable_shared_cache can be called at |
| # any time and from any thread |
| #do_test shared_err-misuse-7.1 { |
| # sqlite3 db test.db |
| # catch { |
| # sqlite3_enable_shared_cache 0 |
| # } msg |
| # set msg |
| #} {library routine called out of sequence} |
| |
| # Again provoke a malloc() failure when a cursor position is being saved, |
| # this time during a ROLLBACK operation by some other handle. |
| # |
| # 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 |
| # be aborted. |
| # |
| set ::aborted 0 |
| do_malloc_test shared_err-8 -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 < 2} {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 { |
| BEGIN; |
| INSERT INTO t1 VALUES(6, NULL); |
| ROLLBACK; |
| } |
| } -cleanup { |
| # UPDATE: As of [5668], if the rollback fails SQLITE_CORRUPT is returned. |
| # So these tests have been updated to expect SQLITE_CORRUPT and its |
| # associated English language error message. |
| # |
| do_test shared_malloc-8.$::n.cleanup.1 { |
| set res [catchsql {SELECT a FROM t1} db2] |
| set ans [lindex $res 1] |
| if {[lindex $res 0]} { |
| set r [expr { |
| $ans=="disk I/O error" || |
| $ans=="out of memory" || |
| $ans=="database disk image is malformed" |
| }] |
| } else { |
| set r [expr {[lrange $ans 0 1]=="0000000000 1111111111"}] |
| } |
| } {1} |
| do_test shared_malloc-8.$::n.cleanup.2 { |
| set rc1 [sqlite3_step $::STMT] |
| set rc2 [sqlite3_finalize $::STMT] |
| if {$rc2=="SQLITE_ABORT"} { |
| incr ::aborted |
| } |
| expr { |
| ($rc1=="SQLITE_DONE" && $rc2=="SQLITE_OK") || |
| ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_ABORT") || |
| ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_NOMEM") || |
| ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_IOERR") || |
| ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_CORRUPT") |
| } |
| } {1} |
| db2 close |
| } |
| do_test shared_malloc-8.X { |
| # Test that one or more queries were aborted due to the malloc() failure. |
| expr $::aborted>=1 |
| } {1} |
| |
| # This test is designed to catch a specific bug that was present during |
| # development of 3.5.0. If a malloc() failed while setting the page-size, |
| # a buffer (Pager.pTmpSpace) was being freed. This could cause a seg-fault |
| # later if another connection tried to use the pager. |
| # |
| # This test will crash 3.4.2. |
| # |
| do_malloc_test shared_err-9 -tclprep { |
| sqlite3 db2 test.db |
| } -sqlbody { |
| PRAGMA page_size = 4096; |
| PRAGMA page_size = 1024; |
| } -cleanup { |
| db2 eval { |
| CREATE TABLE abc(a, b, c); |
| BEGIN; |
| INSERT INTO abc VALUES(1, 2, 3); |
| ROLLBACK; |
| } |
| db2 close |
| } |
| |
| catch {db close} |
| catch {db2 close} |
| do_malloc_test shared_err-10 -tclprep { |
| sqlite3 db test.db |
| sqlite3 db2 test.db |
| |
| db eval { SELECT * FROM sqlite_master } |
| db2 eval { |
| BEGIN; |
| CREATE TABLE abc(a, b, c); |
| } |
| } -tclbody { |
| catch {db eval {SELECT * FROM sqlite_master}} |
| error 1 |
| } -cleanup { |
| execsql { SELECT * FROM sqlite_master } |
| } |
| |
| do_malloc_test shared_err-11 -tclprep { |
| sqlite3 db test.db |
| sqlite3 db2 test.db |
| |
| db eval { SELECT * FROM sqlite_master } |
| db2 eval { |
| BEGIN; |
| CREATE TABLE abc(a, b, c); |
| } |
| } -tclbody { |
| catch {db eval {SELECT * FROM sqlite_master}} |
| catch {sqlite3_errmsg16 db} |
| error 1 |
| } -cleanup { |
| execsql { SELECT * FROM sqlite_master } |
| } |
| |
| catch {db close} |
| catch {db2 close} |
| |
| do_malloc_test shared_err-12 -sqlbody { |
| CREATE TABLE abc(a, b, c); |
| INSERT INTO abc VALUES(1, 2, 3); |
| } |
| |
| catch {db close} |
| catch {db2 close} |
| sqlite3_enable_shared_cache $::enable_shared_cache |
| finish_test |