# 2007 June 13
#
# 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 implements regression tests for SQLite library.
#
# This file implements tests to verify that ticket #2409 has been
# fixed. More specifically, they verify that if SQLite cannot
# obtain an EXCLUSIVE lock while trying to spill the cache during
# any statement other than a COMMIT, an I/O error is returned instead
# of SQLITE4_BUSY.
#
# $Id: tkt2409.test,v 1.6 2008/08/28 17:46:19 drh Exp $

# Test Outline:
#
#   tkt-2409-1.*: Cause a cache-spill during an INSERT that is within
#       a db transaction but does not start a statement transaction.
#       Verify that the transaction is automatically rolled back
#       and SQLITE4_IOERR_BLOCKED is returned
#
#       UPDATE: As of the pcache modifications, failing to upgrade to
#       an exclusive lock when attempting a cache-spill is no longer an
#       error. The pcache module allocates more space and keeps working
#       in memory if this occurs.
#
#   tkt-2409-2.*: Cause a cache-spill while updating the change-counter
#       during a database COMMIT. Verify that the transaction is not
#       rolled back and SQLITE4_BUSY is returned.
#
#   tkt-2409-3.*: Similar to 2409-1.*, but using many INSERT statements
#       within a transaction instead of just one.
#
#       UPDATE: Again, pcache now just keeps working in main memory.
#
#   tkt-2409-4.*: Similar to 2409-1.*, but rig it so that the
#       INSERT statement starts a statement transaction. Verify that
#       SQLITE4_BUSY is returned and the transaction is not rolled back.
#
#       UPDATE: This time, SQLITE4_BUSY is not returned. pcache just uses
#       more malloc()'d memory.
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl

ifcapable !pager_pragmas {
  finish_test
  return
}

sqlite4_extended_result_codes $::DB 1

# Aquire a read-lock on the database using handle [db2].
#
proc read_lock_db {} {
  if {$::STMT eq ""} {
    set ::STMT [sqlite4_prepare db2 {SELECT rowid FROM sqlite_master} -1 TAIL]
    set rc [sqlite4_step $::STMT]
    if {$rc eq "SQLITE4_ERROR"} {
      unread_lock_db
      read_lock_db
    }
  }
}

# Release any read-lock obtained using [read_lock_db]
#
proc unread_lock_db {} {
  if {$::STMT ne ""} {
    sqlite4_finalize $::STMT
    set ::STMT ""
  }
}

# Open the db handle used by [read_lock_db].
#
sqlite4 db2 test.db
set ::STMT ""

do_test tkt2409-1.1 {
  execsql {
    PRAGMA cache_size=10;
    CREATE TABLE t1(x TEXT UNIQUE NOT NULL, y BLOB);
  }
  read_lock_db
  set ::zShort [string repeat 0123456789 1]
  set ::zLong  [string repeat 0123456789 1500]
  catchsql {
    BEGIN;
    INSERT INTO t1 VALUES($::zShort, $::zLong);
  }
} {0 {}}

do_test tkt2409-1.2 {
  sqlite4_errcode $::DB
} {SQLITE4_OK}

# Check the integrity of the cache.
#
integrity_check tkt2409-1.3

# Check that the transaction was rolled back. Because the INSERT
# statement in which the "I/O error" occured did not open a statement
# transaction, SQLite had no choice but to roll back the transaction.
#
do_test tkt2409-1.4 {
  unread_lock_db
  catchsql { ROLLBACK }
} {0 {}}

set ::zShort [string repeat 0123456789 1]
set ::zLong  [string repeat 0123456789 1500]
set ::rc 1
for {set iCache 10} {$::rc} {incr iCache} {
  execsql "PRAGMA cache_size = $iCache"
  do_test tkt2409-2.1.$iCache {
    read_lock_db
    set ::rc [catch {
      execsql {
        BEGIN;
        INSERT INTO t1 VALUES($::zShort, $::zLong);
      }
    } msg]
    expr {($::rc == 1 && $msg eq "disk I/O error") || $::rc == 0}
  } {1}
}

do_test tkt2409-2.2 {
  catchsql {
    ROLLBACK;
    BEGIN;
    INSERT INTO t1 VALUES($::zShort, $::zLong);
    COMMIT;
  }
} {1 {database is locked}}

do_test tkt2409-2.3 {
  unread_lock_db
  catchsql {
    COMMIT;
  }
} {0 {}}


do_test tkt2409-3.1 {
  db close
  set ::DB [sqlite4 db test.db; sqlite4_connection_pointer db]
  sqlite4_extended_result_codes $::DB 1
  execsql {
    PRAGMA cache_size=10;
    DELETE FROM t1;
  }
  read_lock_db
  set ::zShort [string repeat 0123456789 1]
  set ::zLong  [string repeat 0123456789 1500]
  catchsql {
    BEGIN;
    INSERT INTO t1 SELECT $::zShort, $::zLong;
  }
} {0 {}}

do_test tkt2409-3.2 {
  sqlite4_errcode $::DB
} {SQLITE4_OK}

# Check the integrity of the cache.
#
integrity_check tkt2409-3.3

# Check that the transaction was rolled back. Because the INSERT
# statement in which the "I/O error" occured did not open a statement
# transaction, SQLite had no choice but to roll back the transaction.
#
do_test tkt2409-3.4 {
  unread_lock_db
  catchsql { ROLLBACK }
} {0 {}}
integrity_check tkt2409-3.5

expr {srand(1)}
do_test tkt2409-4.1 {
  execsql {
    PRAGMA cache_size=20;
    DROP TABLE t1;
    CREATE TABLE t1 (x TEXT UNIQUE NOT NULL);
  }

  unset -nocomplain t1
  array unset t1
  set t1(0) 1
  set sql ""
  for {set i 0} {$i<5000} {incr i} {
    set r 0
    while {[info exists t1($r)]} {
      set r [expr {int(rand()*1000000000)}]
    }
    set t1($r) 1
    append sql "INSERT INTO t1 VALUES('some-text-$r');"
  }

  read_lock_db
  execsql BEGIN
  catchsql $sql
} {0 {}}

do_test tkt2409-4.2 {
  sqlite4_errcode $::DB
} {SQLITE4_OK}

# Check the integrity of the cache.
#
integrity_check tkt2409-4.3

do_test tkt2409-4.4 {
  catchsql { ROLLBACK }
} {0 {}}
integrity_check tkt2409-4.5

unread_lock_db
db2 close
unset -nocomplain t1
finish_test
