wasCSharpSQLite – Blame information for rev 7
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | office | 1 | # 2010 February 8 |
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 | # This file implements regression tests for SQLite library. The |
||
12 | # focus of this file is testing the operation of the library when |
||
13 | # recovering a database following a simulated system failure in |
||
14 | # "PRAGMA journal_mode=WAL" mode. |
||
15 | # |
||
16 | |||
17 | # |
||
18 | # These are 'warm-body' tests of database recovery used while developing |
||
19 | # the WAL code. They serve to prove that a few really simple cases work: |
||
20 | # |
||
21 | # walcrash-1.*: Recover a database. |
||
22 | # walcrash-2.*: Recover a database where the failed transaction spanned more |
||
23 | # than one page. |
||
24 | # walcrash-3.*: Recover multiple databases where the failed transaction |
||
25 | # was a multi-file transaction. |
||
26 | # |
||
27 | |||
28 | set testdir [file dirname $argv0] |
||
29 | source $testdir/tester.tcl |
||
30 | ifcapable !wal {finish_test ; return } |
||
31 | |||
32 | db close |
||
33 | |||
34 | set seed 0 |
||
35 | set REPEATS 100 |
||
36 | |||
37 | # walcrash-1.* |
||
38 | # |
||
39 | for {set i 1} {$i < $REPEATS} {incr i} { |
||
40 | file delete -force test.db test.db-wal |
||
41 | do_test walcrash-1.$i.1 { |
||
42 | crashsql -delay 4 -file test.db-wal -seed [incr seed] { |
||
43 | PRAGMA journal_mode = WAL; |
||
44 | CREATE TABLE t1(a, b); |
||
45 | INSERT INTO t1 VALUES(1, 1); |
||
46 | INSERT INTO t1 VALUES(2, 3); |
||
47 | INSERT INTO t1 VALUES(3, 6); |
||
48 | } |
||
49 | } {1 {child process exited abnormally}} |
||
50 | do_test walcrash-1.$i.2 { |
||
51 | sqlite3 db test.db |
||
52 | execsql { SELECT sum(a)==max(b) FROM t1 } |
||
53 | } {1} |
||
54 | integrity_check walcrash-1.$i.3 |
||
55 | db close |
||
56 | |||
57 | do_test walcrash-1.$i.4 { |
||
58 | crashsql -delay 2 -file test.db-wal -seed [incr seed] { |
||
59 | INSERT INTO t1 VALUES(4, (SELECT sum(a) FROM t1) + 4); |
||
60 | INSERT INTO t1 VALUES(5, (SELECT sum(a) FROM t1) + 5); |
||
61 | } |
||
62 | } {1 {child process exited abnormally}} |
||
63 | do_test walcrash-1.$i.5 { |
||
64 | sqlite3 db test.db |
||
65 | execsql { SELECT sum(a)==max(b) FROM t1 } |
||
66 | } {1} |
||
67 | integrity_check walcrash-1.$i.6 |
||
68 | do_test walcrash-1.$i.7 { |
||
69 | execsql { PRAGMA main.journal_mode } |
||
70 | } {wal} |
||
71 | db close |
||
72 | } |
||
73 | |||
74 | # walcrash-2.* |
||
75 | # |
||
76 | for {set i 1} {$i < $REPEATS} {incr i} { |
||
77 | file delete -force test.db test.db-wal |
||
78 | do_test walcrash-2.$i.1 { |
||
79 | crashsql -delay 4 -file test.db-wal -seed [incr seed] { |
||
80 | PRAGMA journal_mode = WAL; |
||
81 | CREATE TABLE t1(a PRIMARY KEY, b); |
||
82 | INSERT INTO t1 VALUES(1, 2); |
||
83 | INSERT INTO t1 VALUES(3, 4); |
||
84 | INSERT INTO t1 VALUES(5, 9); |
||
85 | } |
||
86 | } {1 {child process exited abnormally}} |
||
87 | do_test walcrash-2.$i.2 { |
||
88 | sqlite3 db test.db |
||
89 | execsql { SELECT sum(a)==max(b) FROM t1 } |
||
90 | } {1} |
||
91 | integrity_check walcrash-2.$i.3 |
||
92 | db close |
||
93 | |||
94 | do_test walcrash-2.$i.4 { |
||
95 | crashsql -delay 2 -file test.db-wal -seed [incr seed] { |
||
96 | INSERT INTO t1 VALUES(6, (SELECT sum(a) FROM t1) + 6); |
||
97 | INSERT INTO t1 VALUES(7, (SELECT sum(a) FROM t1) + 7); |
||
98 | } |
||
99 | } {1 {child process exited abnormally}} |
||
100 | do_test walcrash-2.$i.5 { |
||
101 | sqlite3 db test.db |
||
102 | execsql { SELECT sum(a)==max(b) FROM t1 } |
||
103 | } {1} |
||
104 | integrity_check walcrash-2.$i.6 |
||
105 | do_test walcrash-2.$i.6 { |
||
106 | execsql { PRAGMA main.journal_mode } |
||
107 | } {wal} |
||
108 | db close |
||
109 | } |
||
110 | |||
111 | # walcrash-3.* |
||
112 | # |
||
113 | # for {set i 1} {$i < $REPEATS} {incr i} { |
||
114 | # file delete -force test.db test.db-wal |
||
115 | # file delete -force test2.db test2.db-wal |
||
116 | # |
||
117 | # do_test walcrash-3.$i.1 { |
||
118 | # crashsql -delay 2 -file test2.db-wal -seed [incr seed] { |
||
119 | # PRAGMA journal_mode = WAL; |
||
120 | # ATTACH 'test2.db' AS aux; |
||
121 | # CREATE TABLE t1(a PRIMARY KEY, b); |
||
122 | # CREATE TABLE aux.t2(a PRIMARY KEY, b); |
||
123 | # BEGIN; |
||
124 | # INSERT INTO t1 VALUES(1, 2); |
||
125 | # INSERT INTO t2 VALUES(1, 2); |
||
126 | # COMMIT; |
||
127 | # } |
||
128 | # } {1 {child process exited abnormally}} |
||
129 | # |
||
130 | # do_test walcrash-3.$i.2 { |
||
131 | # sqlite3_wal db test.db |
||
132 | # execsql { |
||
133 | # ATTACH 'test2.db' AS aux; |
||
134 | # SELECT * FROM t1 EXCEPT SELECT * FROM t2; |
||
135 | # } |
||
136 | # } {} |
||
137 | # do_test walcrash-3.$i.3 { execsql { PRAGMA main.integrity_check } } {ok} |
||
138 | # do_test walcrash-3.$i.4 { execsql { PRAGMA aux.integrity_check } } {ok} |
||
139 | # |
||
140 | # db close |
||
141 | # } |
||
142 | |||
143 | # walcrash-4.* |
||
144 | # |
||
145 | for {set i 1} {$i < $REPEATS} {incr i} { |
||
146 | file delete -force test.db test.db-wal |
||
147 | file delete -force test2.db test2.db-wal |
||
148 | |||
149 | do_test walcrash-4.$i.1 { |
||
150 | crashsql -delay 3 -file test.db-wal -seed [incr seed] -blocksize 4096 { |
||
151 | PRAGMA journal_mode = WAL; |
||
152 | PRAGMA page_size = 1024; |
||
153 | CREATE TABLE t1(a PRIMARY KEY, b); |
||
154 | INSERT INTO t1 VALUES(1, 2); |
||
155 | INSERT INTO t1 VALUES(3, 4); |
||
156 | } |
||
157 | } {1 {child process exited abnormally}} |
||
158 | |||
159 | do_test walcrash-4.$i.2 { |
||
160 | sqlite3 db test.db |
||
161 | execsql { |
||
162 | SELECT * FROM t1 WHERE a = 1; |
||
163 | } |
||
164 | } {1 2} |
||
165 | do_test walcrash-4.$i.3 { execsql { PRAGMA main.integrity_check } } {ok} |
||
166 | do_test walcrash-4.$i.4 { execsql { PRAGMA main.journal_mode } } {wal} |
||
167 | |||
168 | db close |
||
169 | } |
||
170 | |||
171 | # walcrash-5.* |
||
172 | # |
||
173 | for {set i 1} {$i < $REPEATS} {incr i} { |
||
174 | file delete -force test.db test.db-wal |
||
175 | file delete -force test2.db test2.db-wal |
||
176 | |||
177 | do_test walcrash-5.$i.1 { |
||
178 | crashsql -delay 11 -file test.db-wal -seed [incr seed] -blocksize 4096 { |
||
179 | PRAGMA journal_mode = WAL; |
||
180 | PRAGMA page_size = 1024; |
||
181 | BEGIN; |
||
182 | CREATE TABLE t1(x PRIMARY KEY); |
||
183 | INSERT INTO t1 VALUES(randomblob(900)); |
||
184 | INSERT INTO t1 VALUES(randomblob(900)); |
||
185 | INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 4 */ |
||
186 | COMMIT; |
||
187 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 8 */ |
||
188 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 12 */ |
||
189 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 16 */ |
||
190 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 20 */ |
||
191 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 24 */ |
||
192 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 28 */ |
||
193 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 32 */ |
||
194 | |||
195 | PRAGMA wal_checkpoint; |
||
196 | INSERT INTO t1 VALUES(randomblob(900)); |
||
197 | INSERT INTO t1 VALUES(randomblob(900)); |
||
198 | INSERT INTO t1 VALUES(randomblob(900)); |
||
199 | } |
||
200 | } {1 {child process exited abnormally}} |
||
201 | |||
202 | do_test walcrash-5.$i.2 { |
||
203 | sqlite3 db test.db |
||
204 | execsql { SELECT count(*)==33 OR count(*)==34 FROM t1 WHERE x != 1 } |
||
205 | } {1} |
||
206 | do_test walcrash-5.$i.3 { execsql { PRAGMA main.integrity_check } } {ok} |
||
207 | do_test walcrash-5.$i.4 { execsql { PRAGMA main.journal_mode } } {wal} |
||
208 | |||
209 | db close |
||
210 | } |
||
211 | |||
212 | # walcrash-6.* |
||
213 | # |
||
214 | for {set i 1} {$i < $REPEATS} {incr i} { |
||
215 | file delete -force test.db test.db-wal |
||
216 | file delete -force test2.db test2.db-wal |
||
217 | |||
218 | do_test walcrash-6.$i.1 { |
||
219 | crashsql -delay 12 -file test.db-wal -seed [incr seed] -blocksize 512 { |
||
220 | PRAGMA journal_mode = WAL; |
||
221 | PRAGMA page_size = 1024; |
||
222 | BEGIN; |
||
223 | CREATE TABLE t1(x PRIMARY KEY); |
||
224 | INSERT INTO t1 VALUES(randomblob(900)); |
||
225 | INSERT INTO t1 VALUES(randomblob(900)); |
||
226 | INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 4 */ |
||
227 | COMMIT; |
||
228 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 8 */ |
||
229 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 12 */ |
||
230 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 16 */ |
||
231 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 20 */ |
||
232 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 24 */ |
||
233 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 28 */ |
||
234 | INSERT INTO t1 SELECT randomblob(900) FROM t1 LIMIT 4; /* 32 */ |
||
235 | |||
236 | PRAGMA wal_checkpoint; |
||
237 | INSERT INTO t1 VALUES(randomblob(900)); |
||
238 | INSERT INTO t1 VALUES(randomblob(900)); |
||
239 | INSERT INTO t1 VALUES(randomblob(900)); |
||
240 | } |
||
241 | } {1 {child process exited abnormally}} |
||
242 | |||
243 | do_test walcrash-6.$i.2 { |
||
244 | sqlite3 db test.db |
||
245 | execsql { SELECT count(*)==34 OR count(*)==35 FROM t1 WHERE x != 1 } |
||
246 | } {1} |
||
247 | do_test walcrash-6.$i.3 { execsql { PRAGMA main.integrity_check } } {ok} |
||
248 | do_test walcrash-6.$i.4 { execsql { PRAGMA main.journal_mode } } {wal} |
||
249 | |||
250 | db close |
||
251 | } |
||
252 | |||
253 | #------------------------------------------------------------------------- |
||
254 | # This test case simulates a crash while checkpointing the database. Page |
||
255 | # 1 is one of the pages overwritten by the checkpoint. This is a special |
||
256 | # case because it means the content of page 1 may be damaged. SQLite will |
||
257 | # have to determine: |
||
258 | # |
||
259 | # (a) that the database is a WAL database, and |
||
260 | # (b) the database page-size |
||
261 | # |
||
262 | # based on the log file. |
||
263 | # |
||
264 | for {set i 1} {$i < $REPEATS} {incr i} { |
||
265 | file delete -force test.db test.db-wal |
||
266 | |||
267 | # Select a page-size for this test. |
||
268 | # |
||
269 | set pgsz [lindex {512 1024 2048 4096 8192 16384} [expr $i%6]] |
||
270 | |||
271 | do_test walcrash-7.$i.1 { |
||
272 | crashsql -delay 3 -file test.db -seed [incr seed] -blocksize 512 " |
||
273 | PRAGMA page_size = $pgsz; |
||
274 | PRAGMA journal_mode = wal; |
||
275 | BEGIN; |
||
276 | CREATE TABLE t1(a, b); |
||
277 | INSERT INTO t1 VALUES(1, 2); |
||
278 | COMMIT; |
||
279 | PRAGMA wal_checkpoint; |
||
280 | CREATE INDEX i1 ON t1(a); |
||
281 | PRAGMA wal_checkpoint; |
||
282 | " |
||
283 | } {1 {child process exited abnormally}} |
||
284 | |||
285 | do_test walcrash-7.$i.2 { |
||
286 | sqlite3 db test.db |
||
287 | execsql { SELECT b FROM t1 WHERE a = 1 } |
||
288 | } {2} |
||
289 | do_test walcrash-7.$i.3 { execsql { PRAGMA main.integrity_check } } {ok} |
||
290 | do_test walcrash-7.$i.4 { execsql { PRAGMA main.journal_mode } } {wal} |
||
291 | |||
292 | db close |
||
293 | } |
||
294 | |||
295 | finish_test |
||
296 |