Return to ioerr5.test CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

sqlite3

    1: # 2008 May 12
    2: #
    3: # The author disclaims copyright to this source code.  In place of
    4: # a legal notice, here is a blessing:
    5: #
    6: #    May you do good and not evil.
    7: #    May you find forgiveness for yourself and forgive others.
    8: #    May you share freely, never taking more than you give.
    9: #
   10: #***********************************************************************
   11: #
   12: # This file tests that if sqlite3_release_memory() is called to reclaim
   13: # memory from a pager that is in the error-state, SQLite does not 
   14: # incorrectly write dirty pages out to the database (not safe to do
   15: # once the pager is in error state).
   16: #
   17: # $Id: ioerr5.test,v 1.1.1.1 2012/02/21 17:04:16 misho Exp $
   18: 
   19: set testdir [file dirname $argv0]
   20: source $testdir/tester.tcl
   21: 
   22: ifcapable !memorymanage||!shared_cache {
   23:   finish_test
   24:   return
   25: }
   26: 
   27: db close
   28: 
   29: set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
   30: set ::soft_limit [sqlite3_soft_heap_limit 1048576]
   31: 
   32: # This procedure prepares, steps and finalizes an SQL statement via the
   33: # UTF-16 APIs. The text representation of an SQLite error code is returned
   34: # ("SQLITE_OK", "SQLITE_IOERR" etc.). The actual results returned by the
   35: # SQL statement, if it is a SELECT, are not available.
   36: #
   37: # This can be useful for testing because it forces SQLite to make an extra 
   38: # call to sqlite3_malloc() when translating from the supplied UTF-16 to
   39: # the UTF-8 encoding used internally.
   40: #
   41: proc dosql16 {zSql {db db}} {
   42:   set sql [encoding convertto unicode $zSql]
   43:   append sql "\00\00"
   44:   set stmt [sqlite3_prepare16 $db $sql -1 {}]
   45:   sqlite3_step $stmt
   46:   set rc [sqlite3_finalize $stmt]
   47: }
   48: 
   49: proc compilesql16 {zSql {db db}} {
   50:   set sql [encoding convertto unicode $zSql]
   51:   append sql "\00\00"
   52:   set stmt [sqlite3_prepare16 $db $sql -1 {}]
   53:   set rc [sqlite3_finalize $stmt]
   54: }
   55: 
   56: # Open two database connections (handle db and db2) to database "test.db".
   57: #
   58: proc opendatabases {} {
   59:   catch {db close}
   60:   catch {db2 close}
   61:   sqlite3 db test.db
   62:   sqlite3 db2 test.db
   63:   db2 cache size 0
   64:   db cache size 0
   65:   execsql {
   66:     pragma page_size=512;
   67:     pragma auto_vacuum=2;
   68:     pragma cache_size=16;
   69:   }
   70: }
   71: 
   72: # Open two database connections and create a single table in the db.
   73: #
   74: do_test ioerr5-1.0 {
   75:   opendatabases
   76:   execsql { CREATE TABLE A(Id INTEGER, Name TEXT) }
   77: } {}
   78: 
   79: foreach locking_mode {normal exclusive} {
   80:   set nPage 2
   81:   for {set iFail 1} {$iFail<200} {incr iFail} {
   82:     sqlite3_soft_heap_limit 1048576
   83:     opendatabases
   84:     execsql { pragma locking_mode=exclusive }
   85:     set nRow [db one {SELECT count(*) FROM a}]
   86:   
   87:     # Dirty (at least) one of the pages in the cache.
   88:     do_test ioerr5-1.$locking_mode-$iFail.1 {
   89:       execsql {
   90:         BEGIN EXCLUSIVE;
   91:         INSERT INTO a VALUES(1, 'ABCDEFGHIJKLMNOP');
   92:       }
   93:     } {}
   94: 
   95:     # Open a read-only cursor on table "a". If the COMMIT below is
   96:     # interrupted by a persistent IO error, the pager will transition to 
   97:     # PAGER_ERROR state. If there are no other read-only cursors open,
   98:     # from there the pager immediately discards all cached data and 
   99:     # switches to PAGER_OPEN state. This read-only cursor stops that
  100:     # from happening, leaving the pager stuck in PAGER_ERROR state.
  101:     #
  102:     set channel [db incrblob -readonly a Name [db last_insert_rowid]]
  103:   
  104:     # Now try to commit the transaction. Cause an IO error to occur
  105:     # within this operation, which moves the pager into the error state.
  106:     #
  107:     set ::sqlite_io_error_persist 1
  108:     set ::sqlite_io_error_pending $iFail
  109:     do_test ioerr5-1.$locking_mode-$iFail.2 {
  110:       set rc [catchsql {COMMIT}]
  111:       list
  112:     } {}
  113:     set ::sqlite_io_error_hit 0
  114:     set ::sqlite_io_error_persist 0
  115:     set ::sqlite_io_error_pending 0
  116:   
  117:     # Read the contents of the database file into a Tcl variable.
  118:     #
  119:     set fd [open test.db]
  120:     fconfigure $fd -translation binary -encoding binary
  121:     set zDatabase [read $fd]
  122:     close $fd
  123: 
  124:     # Set a very low soft-limit and then try to compile an SQL statement 
  125:     # from UTF-16 text. To do this, SQLite will need to reclaim memory
  126:     # from the pager that is in error state. Including that associated
  127:     # with the dirty page.
  128:     #
  129:     do_test ioerr5-1.$locking_mode-$iFail.3 {
  130:       sqlite3_soft_heap_limit 1024
  131:       compilesql16 "SELECT 10"
  132:     } {SQLITE_OK}
  133: 
  134:     close $channel
  135: 
  136:     # Ensure that nothing was written to the database while reclaiming
  137:     # memory from the pager in error state.
  138:     #
  139:     do_test ioerr5-1.$locking_mode-$iFail.4 {
  140:       set fd [open test.db]
  141:       fconfigure $fd -translation binary -encoding binary
  142:       set zDatabase2 [read $fd]
  143:       close $fd
  144:       expr {$zDatabase eq $zDatabase2}
  145:     } {1}
  146: 
  147:     if {$rc eq [list 0 {}]} {
  148:       do_test ioerr5.1-$locking_mode-$iFail.3 {
  149:         execsql { SELECT count(*) FROM a }
  150:       } [expr $nRow+1]
  151:       break
  152:     }
  153:   }
  154: }
  155: 
  156: # Make sure this test script doesn't leave any files open.
  157: #
  158: do_test ioerr5-1.X {
  159:   catch { db close }
  160:   catch { db2 close }
  161:   set sqlite_open_file_count
  162: } 0
  163: 
  164: do_test ioerr5-2.0 {
  165:   sqlite3 db test.db
  166:   execsql { CREATE INDEX i1 ON a(id, name); }
  167: } {}
  168: 
  169: foreach locking_mode {exclusive normal} {
  170:   for {set iFail 1} {$iFail<200} {incr iFail} {
  171:     sqlite3_soft_heap_limit 1048576
  172:     opendatabases
  173:     execsql { pragma locking_mode=exclusive }
  174:     set nRow [db one {SELECT count(*) FROM a}]
  175:   
  176:     do_test ioerr5-2.$locking_mode-$iFail.1 {
  177:       execsql {
  178:         BEGIN EXCLUSIVE;
  179:         INSERT INTO a VALUES(1, 'ABCDEFGHIJKLMNOP');
  180:       }
  181:     } {}
  182: 
  183:     set ::sqlite_io_error_persist 1
  184:     set ::sqlite_io_error_pending $iFail
  185: 
  186:     sqlite3_release_memory 10000
  187: 
  188:     set error_hit $::sqlite_io_error_hit
  189:     set ::sqlite_io_error_hit 0
  190:     set ::sqlite_io_error_persist 0
  191:     set ::sqlite_io_error_pending 0
  192:     if {$error_hit} {
  193:       do_test ioerr5-2.$locking_mode-$iFail.3a {
  194:         catchsql COMMIT
  195:       } {1 {disk I/O error}}
  196:     } else {
  197:       do_test ioerr5-2.$locking_mode-$iFail.3b {
  198:         execsql COMMIT
  199:       } {}
  200:       break
  201:     }
  202:   }
  203: }
  204: 
  205: # Make sure this test script doesn't leave any files open.
  206: #
  207: do_test ioerr5-2.X {
  208:   catch { db close }
  209:   catch { db2 close }
  210:   set sqlite_open_file_count
  211: } 0
  212: 
  213: sqlite3_enable_shared_cache $::enable_shared_cache
  214: sqlite3_soft_heap_limit $::soft_limit
  215: 
  216: finish_test