# 2004 Feb 8

 #

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

 # focus of this script is the sqlite_interrupt() API.

 #

 # $Id: interrupt.test,v 1.16 2008/01/16 17:46:38 drh Exp $

 set testdir [file dirname $argv0]

 source $testdir/tester.tcl

 set DB [sqlite3_connection_pointer db]

 # This routine attempts to execute the sql in $sql.  It triggers an

 # interrupt at progressively later and later points during the processing

 # and checks to make sure SQLITE_INTERRUPT is returned.  Eventually,

 # the routine completes successfully.

 #

 proc interrupt_test {testid sql result {initcnt 0}} {

   set orig_sum [cksum]

   set i $initcnt

   while 1 {

     incr i

     set ::sqlite_interrupt_count $i

     do_test $testid.$i.1 [format {

       set ::r [catchsql %s]

       set ::code [db errorcode]

       expr {$::code==0 || $::code==9}

     } [list $sql]] 1

     if {$::code==9} {

       do_test $testid.$i.2 {

         cksum

       } $orig_sum

     } else {

       do_test $testid.$i.99 {

         set ::r

       } [list 0 $result]

       break

     }

   }

   set ::sqlite_interrupt_count 0

 }

 do_test interrupt-1.1 {

   execsql {

     CREATE TABLE t1(a,b);

     SELECT name FROM sqlite_master;

   }

 } {t1}

 interrupt_test interrupt-1.2 {DROP TABLE t1} {}

 do_test interrupt-1.3 {

   execsql {

     SELECT name FROM sqlite_master;

   }

 } {}

 integrity_check interrupt-1.4

 do_test interrrupt-2.1 {

   execsql {

     BEGIN;

     CREATE TABLE t1(a,b);

     INSERT INTO t1 VALUES(1,randstr(300,400));

     INSERT INTO t1 SELECT a+1, randstr(300,400) FROM t1;

     INSERT INTO t1 SELECT a+2, a || '-' || b FROM t1;

     INSERT INTO t1 SELECT a+4, a || '-' || b FROM t1;

     INSERT INTO t1 SELECT a+8, a || '-' || b FROM t1;

     INSERT INTO t1 SELECT a+16, a || '-' || b FROM t1;

     INSERT INTO t1 SELECT a+32, a || '-' || b FROM t1;

     COMMIT;

     UPDATE t1 SET b=substr(b,-5,5);

     SELECT count(*) from t1;

   }

 } 64

 set origsize [file size test.db]

 set cksum [db eval {SELECT md5sum(a || b) FROM t1}]

 ifcapable {vacuum} {

   interrupt_test interrupt-2.2 {VACUUM} {} 100

 }

 do_test interrupt-2.3 {

   execsql {

     SELECT md5sum(a || b) FROM t1;

   }

 } $cksum

 ifcapable {vacuum && !default_autovacuum} {

   do_test interrupt-2.4 {

     expr {$::origsize>[file size test.db]}

   } 1

 }

 ifcapable {explain} {

   do_test interrupt-2.5 {

     set sql {EXPLAIN SELECT max(a,b), a, b FROM t1}

     execsql $sql

     set rc [catch {db eval $sql {sqlite3_interrupt $DB}} msg]

     lappend rc $msg

   } {1 interrupted}

 }

 integrity_check interrupt-2.6

 # Ticket #594.  If an interrupt occurs in the middle of a transaction

 # and that transaction is later rolled back, the internal schema tables do

 # not reset.

 #

 # UPDATE: Interrupting a DML statement in the middle of a transaction now

 # causes the transaction to roll back. Leaving the transaction open after

 # an SQL statement was interrupted halfway through risks database corruption.

 #

 ifcapable tempdb {

   for {set i 1} {$i<50} {incr i 5} {

     do_test interrupt-3.$i.1 {

       execsql {

         BEGIN;

         CREATE TEMP TABLE t2(x,y);

         SELECT name FROM sqlite_temp_master;

       }

     } {t2}

     do_test interrupt-3.$i.2 {

       set ::sqlite_interrupt_count $::i

       catchsql {

         INSERT INTO t2 SELECT * FROM t1;

       }

     } {1 interrupted}

     do_test interrupt-3.$i.3 {

       execsql {

         SELECT name FROM sqlite_temp_master;

       }

     } {}

     do_test interrupt-3.$i.4 {

       catchsql {

         ROLLBACK

       }

     } {1 {cannot rollback - no transaction is active}}

     do_test interrupt-3.$i.5 {

       catchsql {SELECT name FROM sqlite_temp_master};

       execsql {

         SELECT name FROM sqlite_temp_master;

       }

     } {}

   }

 }

 # There are reports of a memory leak if an interrupt occurs during

 # the beginning of a complex query - before the first callback.  We

 # will try to reproduce it here:

 #

 execsql {

   CREATE TABLE t2(a,b,c);

   INSERT INTO t2 SELECT round(a/10), randstr(50,80), randstr(50,60) FROM t1;

 }

 set sql {

   SELECT max(min(b,c)), min(max(b,c)), a FROM t2 GROUP BY a ORDER BY a;

 }

 set sqlite_interrupt_count 1000000

 execsql $sql

 set max_count [expr {1000000-$sqlite_interrupt_count}]

 for {set i 1} {$i<$max_count-5} {incr i 1} {

   do_test interrupt-4.$i.1 {

     set ::sqlite_interrupt_count $::i

     catchsql $sql

   } {1 interrupted}

 }

 # Interrupt during parsing

 #

 do_test interrupt-5.1 {

   proc fake_interrupt {args} {

     db collate fake_collation no-op

     sqlite3_interrupt db

     return SQLITE_OK

   }

   db collation_needed fake_interrupt

   catchsql {

     CREATE INDEX fake ON fake1(a COLLATE fake_collation, b, c DESC);

   }

 } {1 interrupt}

 finish_test