1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
# 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}
}
if {0} { # This doesn't work anymore since the collation factor is
# no longer called during schema parsing.
# 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
|
