# 2008 May 12

#

# 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.

#

#***********************************************************************

#

# This file tests that if sqlite3_release_memory() is called to reclaim

# memory from a pager that is in the error-state, SQLite does not 

# incorrectly write dirty pages out to the database (not safe to do

# once the pager is in error state).

#

# $Id: ioerr5.test,v 1.5 2008/08/28 18:35:34 danielk1977 Exp $

set testdir [file dirname $argv0]

source $testdir/tester.tcl

ifcapable !memorymanage||!shared_cache {

  finish_test

  return

}

db close

set ::enable_shared_cache [sqlite3_enable_shared_cache 1]

set ::soft_limit [sqlite3_soft_heap_limit 1048576]

# This procedure prepares, steps and finalizes an SQL statement via the

# UTF-16 APIs. The text representation of an SQLite error code is returned

# ("SQLITE_OK", "SQLITE_IOERR" etc.). The actual results returned by the

# SQL statement, if it is a SELECT, are not available.

#

# This can be useful for testing because it forces SQLite to make an extra 

# call to sqlite3_malloc() when translating from the supplied UTF-16 to

# the UTF-8 encoding used internally.

#

proc dosql16 {zSql {db db}} {

  set sql [encoding convertto unicode $zSql]

  append sql "\00\00"

  set stmt [sqlite3_prepare16 $db $sql -1 {}]

  sqlite3_step $stmt

  set rc [sqlite3_finalize $stmt]

}

proc compilesql16 {zSql {db db}} {

  set sql [encoding convertto unicode $zSql]

  append sql "\00\00"

  set stmt [sqlite3_prepare16 $db $sql -1 {}]

  set rc [sqlite3_finalize $stmt]

}

# Open two database connections (handle db and db2) to database "test.db".

#

proc opendatabases {} {

  catch {db close}

  catch {db2 close}

  sqlite3 db test.db

  sqlite3 db2 test.db

  db2 cache size 0

  db cache size 0

  execsql {

    pragma page_size=512;

    pragma auto_vacuum=2;

    pragma cache_size=16;

  }

}

# Open two database connections and create a single table in the db.

#

do_test ioerr5-1.0 {

  opendatabases

  execsql { CREATE TABLE A(Id INTEGER, Name TEXT) }

} {}

foreach locking_mode {normal exclusive} {

  set nPage 2

  for {set iFail 1} {$iFail<200} {incr iFail} {

    sqlite3_soft_heap_limit 1048576

    opendatabases

    execsql { pragma locking_mode=exclusive }

    set nRow [db one {SELECT count(*) FROM a}]

    # Dirty (at least) one of the pages in the cache.

    do_test ioerr5-1.$locking_mode-$iFail.1 {

      execsql {

        BEGIN EXCLUSIVE;

        INSERT INTO a VALUES(1, 'ABCDEFGHIJKLMNOP');

      }

    } {}

    # Now try to commit the transaction. Cause an IO error to occur

    # within this operation, which moves the pager into the error state.

    #

    set ::sqlite_io_error_persist 1

    set ::sqlite_io_error_pending $iFail

    do_test ioerr5-1.$locking_mode-$iFail.2 {

      set rc [catchsql {COMMIT}]

      list

    } {}

    set ::sqlite_io_error_hit 0

    set ::sqlite_io_error_persist 0

    set ::sqlite_io_error_pending 0

    # Read the contents of the database file into a Tcl variable.

    #

    set fd [open test.db]

    fconfigure $fd -translation binary -encoding binary

    set zDatabase [read $fd]

    close $fd

    # Set a very low soft-limit and then try to compile an SQL statement 

    # from UTF-16 text. To do this, SQLite will need to reclaim memory

    # from the pager that is in error state. Including that associated

    # with the dirty page.

    #

    do_test ioerr5-1.$locking_mode-$iFail.3 {

      set bt [btree_from_db db]

      sqlite3_soft_heap_limit 1024

      compilesql16 "SELECT 10"

      array set stats [btree_pager_stats $bt]

      # If the pager made it all the way to PAGER_SYNCED state, then 

      # both in-memory pages are clean. Following the calls to 

      # release_memory() that were made as part of the [compilesql16]

      # above, there will be zero pages left in the cache.

      #

      # If the pager did not make it as far as PAGER_SYNCED, the two

      # in memory pages are still dirty. So there will be 2 pages left

      # in the cache following the release_memory() calls.

      #

      if {$stats(state)==5} {

        set nPage 0

      }

      expr {$stats(page)==$nPage}

    } {1}

    # Ensure that nothing was written to the database while reclaiming

    # memory from the pager in error state.

    #

    do_test ioerr5-1.$locking_mode-$iFail.4 {

      set fd [open test.db]

      fconfigure $fd -translation binary -encoding binary

      set zDatabase2 [read $fd]

      close $fd

      expr {$zDatabase eq $zDatabase2}

    } {1}

    if {$rc eq [list 0 {}]} {

      do_test ioerr5.1-$locking_mode-$iFail.3 {

        execsql { SELECT count(*) FROM a }

      } [expr $nRow+1]

      break

    }

  }

}

# Make sure this test script doesn't leave any files open.

#

do_test ioerr5-1.X {

  catch { db close }

  catch { db2 close }

  set sqlite_open_file_count

} 0

do_test ioerr5-2.0 {

  sqlite3 db test.db

  execsql { CREATE INDEX i1 ON a(id, name); }

} {}

foreach locking_mode {exclusive normal} {

  for {set iFail 1} {$iFail<200} {incr iFail} {

    sqlite3_soft_heap_limit 1048576

    opendatabases

    execsql { pragma locking_mode=exclusive }

    set nRow [db one {SELECT count(*) FROM a}]

    do_test ioerr5-2.$locking_mode-$iFail.1 {

      execsql {

        BEGIN EXCLUSIVE;

        INSERT INTO a VALUES(1, 'ABCDEFGHIJKLMNOP');

      }

    } {}

    set ::sqlite_io_error_persist 1

    set ::sqlite_io_error_pending $iFail

    sqlite3_release_memory 10000

    set error_hit $::sqlite_io_error_hit

    set ::sqlite_io_error_hit 0

    set ::sqlite_io_error_persist 0

    set ::sqlite_io_error_pending 0

    if {$error_hit} {

      do_test ioerr5-2.$locking_mode-$iFail.3a {

        catchsql COMMIT

      } {1 {disk I/O error}}

    } else {

      do_test ioerr5-2.$locking_mode-$iFail.3b {

        execsql COMMIT

      } {}

      break

    }

  }

}

# Make sure this test script doesn't leave any files open.

#

do_test ioerr5-2.X {

  catch { db close }

  catch { db2 close }

  set sqlite_open_file_count

} 0

sqlite3_enable_shared_cache $::enable_shared_cache

sqlite3_soft_heap_limit $::soft_limit

finish_test