# 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.23 2008/09/29 14:12:57 danielk1977 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}

  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