# 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.9 2006/01/24 16:37:59 danielk1977 Exp $proc skip {args} {}set testdir [file dirname $argv0]source $testdir/tester.tcldb closeifcapable !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 <test number> <options...>## The first argument, <test number>, 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}# Only run these tests if memory debugging is turned on.#if {[info command sqlite_malloc_stat]==""} {   puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."   db close   sqlite3_enable_shared_cache $::enable_shared_cache   finish_test   return}# 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 {    set ::rc [sqlite3_step $::STMT]    expr {$::rc=="SQLITE_ROW" || $::rc=="SQLITE_ABORT"}  } {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 {    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}}do_malloc_test 6 -tclbody {  catch {db close}  sqlite3_thread_cleanup  sqlite3_enable_shared_cache 0} -cleanup {  sqlite3_enable_shared_cache 1}do_test shared_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 0do_malloc_test 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 {  do_test shared_malloc-8.$::n.cleanup.1 {    lrange [execsql {      SELECT a FROM t1;    } db2] 0 1  } {0000000000 1111111111}  do_test shared_malloc-8.$::n.cleanup.2 {    set rc1 [sqlite3_step $::STMT]    set rc2 [sqlite3_finalize $::STMT]    if {$rc1=="SQLITE_ABORT"} {      incr ::aborted    }    expr {      ($rc1=="SQLITE_DONE" && $rc2=="SQLITE_OK") ||       ($rc1=="SQLITE_ABORT" && $rc2=="SQLITE_OK")    }  } {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}catch {db close}sqlite3_enable_shared_cache $::enable_shared_cachefinish_test