Debian Codegraph @

test/crash8.test

raw
1 # 2009 January 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 #
12 # This test verifies a couple of specific potential data corruption
13 # scenarios involving crashes or power failures.
14 #
15 # Later: Also, some other specific scenarios required for coverage
16 # testing that do not lead to corruption.
17 #
18 # $Id: crash8.test,v 1.4 2009/01/11 00:44:48 drh Exp $
19
20
21 set testdir [file dirname $argv0]
22 source $testdir/tester.tcl
23
24 ifcapable !crashtest {
25 finish_test
26 return
27 }
28 do_not_use_codec
29
30 do_test crash8-1.1 {
31 execsql {
32 PRAGMA auto_vacuum=OFF;
33 CREATE TABLE t1(a, b);
34 CREATE INDEX i1 ON t1(a, b);
35 INSERT INTO t1 VALUES(1, randstr(1000,1000));
36 INSERT INTO t1 VALUES(2, randstr(1000,1000));
37 INSERT INTO t1 VALUES(3, randstr(1000,1000));
38 INSERT INTO t1 VALUES(4, randstr(1000,1000));
39 INSERT INTO t1 VALUES(5, randstr(1000,1000));
40 INSERT INTO t1 VALUES(6, randstr(1000,1000));
41 CREATE TABLE t2(a, b);
42 CREATE TABLE t3(a, b);
43 CREATE TABLE t4(a, b);
44 CREATE TABLE t5(a, b);
45 CREATE TABLE t6(a, b);
46 CREATE TABLE t7(a, b);
47 CREATE TABLE t8(a, b);
48 CREATE TABLE t9(a, b);
49 CREATE TABLE t10(a, b);
50 PRAGMA integrity_check
51 }
52 } {ok}
53
54
55 # Potential corruption scenario 1. A second process opens the database
56 # and modifies a large portion of it. It then opens a second transaction
57 # and modifies a small part of the database, but crashes before it commits
58 # the transaction.
59 #
60 # When the first process accessed the database again, it was rolling back
61 # the aborted transaction, but was not purging its in-memory cache (which
62 # was loaded before the second process made its first, successful,
63 # modification). Producing an inconsistent cache.
64 #
65 do_test crash8-1.2 {
66 crashsql -delay 2 -file test.db {
67 PRAGMA cache_size = 10;
68 UPDATE t1 SET b = randstr(1000,1000);
69 INSERT INTO t9 VALUES(1, 2);
70 }
71 } {1 {child process exited abnormally}}
72 do_test crash8-1.3 {
73 execsql {PRAGMA integrity_check}
74 } {ok}
75
76 # Potential corruption scenario 2. The second process, operating in
77 # persistent-journal mode, makes a large change to the database file
78 # with a small in-memory cache. Such that more than one journal-header
79 # was written to the file. It then opens a second transaction and makes
80 # a smaller change that requires only a single journal-header to be
81 # written to the journal file. The second change is such that the
82 # journal content written to the persistent journal file exactly overwrites
83 # the first journal-header and set of subsequent records written by the
84 # first, successful, change. The second process crashes before it can
85 # commit its second change.
86 #
87 # When the first process accessed the database again, it was rolling back
88 # the second aborted transaction, then continuing to rollback the second
89 # and subsequent journal-headers written by the first, successful, change.
90 # Database corruption.
91 #
92 do_test crash8.2.1 {
93 crashsql -delay 2 -file test.db {
94 PRAGMA journal_mode = persist;
95 PRAGMA cache_size = 10;
96 UPDATE t1 SET b = randstr(1000,1000);
97 PRAGMA cache_size = 100;
98 BEGIN;
99 INSERT INTO t2 VALUES('a', 'b');
100 INSERT INTO t3 VALUES('a', 'b');
101 INSERT INTO t4 VALUES('a', 'b');
102 INSERT INTO t5 VALUES('a', 'b');
103 INSERT INTO t6 VALUES('a', 'b');
104 INSERT INTO t7 VALUES('a', 'b');
105 INSERT INTO t8 VALUES('a', 'b');
106 INSERT INTO t9 VALUES('a', 'b');
107 INSERT INTO t10 VALUES('a', 'b');
108 COMMIT;
109 }
110 } {1 {child process exited abnormally}}
111
112 do_test crash8-2.3 {
113 execsql {PRAGMA integrity_check}
114 } {ok}
115
116 proc read_file {zFile} {
117 set fd [open $zFile]
118 fconfigure $fd -translation binary
119 set zData [read $fd]
120 close $fd
121 return $zData
122 }
123 proc write_file {zFile zData} {
124 set fd [open $zFile w]
125 fconfigure $fd -translation binary
126 puts -nonewline $fd $zData
127 close $fd
128 }
129
130 # The following tests check that SQLite will not roll back a hot-journal
131 # file if the sector-size field in the first journal file header is
132 # suspect. Definition of suspect:
133 #
134 # a) Not a power of 2, or (crash8-3.5)
135 # b) Greater than 0x01000000 (16MB), or (crash8-3.6)
136 # c) Less than 512. (crash8-3.7)
137 #
138 # Also test that SQLite will not rollback a hot-journal file with a
139 # suspect page-size. In this case "suspect" means:
140 #
141 # a) Not a power of 2, or
142 # b) Less than 512, or
143 # c) Greater than SQLITE_MAX_PAGE_SIZE
144 #
145 if {[atomic_batch_write test.db]==0} {
146 do_test crash8-3.1 {
147 list [file exists test.db-joural] [file exists test.db]
148 } {0 1}
149 do_test crash8-3.2 {
150 execsql {
151 PRAGMA synchronous = off;
152 BEGIN;
153 DELETE FROM t1;
154 SELECT count(*) FROM t1;
155 }
156 } {0}
157 do_test crash8-3.3 {
158 set zJournal [read_file test.db-journal]
159 execsql {
160 COMMIT;
161 SELECT count(*) FROM t1;
162 }
163 } {0}
164 do_test crash8-3.4 {
165 binary scan [string range $zJournal 20 23] I nSector
166 set nSector
167 } {512}
168
169 do_test crash8-3.5 {
170 set zJournal2 [string replace $zJournal 20 23 [binary format I 513]]
171 write_file test.db-journal $zJournal2
172
173 execsql {
174 SELECT count(*) FROM t1;
175 PRAGMA integrity_check
176 }
177 } {0 ok}
178 do_test crash8-3.6 {
179 set zJournal2 [string replace $zJournal 20 23 [binary format I 0x2000000]]
180 write_file test.db-journal $zJournal2
181 execsql {
182 SELECT count(*) FROM t1;
183 PRAGMA integrity_check
184 }
185 } {0 ok}
186 do_test crash8-3.7 {
187 set zJournal2 [string replace $zJournal 20 23 [binary format I 256]]
188 write_file test.db-journal $zJournal2
189 execsql {
190 SELECT count(*) FROM t1;
191 PRAGMA integrity_check
192 }
193 } {0 ok}
194
195 do_test crash8-3.8 {
196 set zJournal2 [string replace $zJournal 24 27 [binary format I 513]]
197 write_file test.db-journal $zJournal2
198
199 execsql {
200 SELECT count(*) FROM t1;
201 PRAGMA integrity_check
202 }
203 } {0 ok}
204 do_test crash8-3.9 {
205 set big [expr $SQLITE_MAX_PAGE_SIZE * 2]
206 set zJournal2 [string replace $zJournal 24 27 [binary format I $big]]
207 write_file test.db-journal $zJournal2
208 execsql {
209 SELECT count(*) FROM t1;
210 PRAGMA integrity_check
211 }
212 } {0 ok}
213 do_test crash8-3.10 {
214 set zJournal2 [string replace $zJournal 24 27 [binary format I 256]]
215 write_file test.db-journal $zJournal2
216 execsql {
217 SELECT count(*) FROM t1;
218 PRAGMA integrity_check
219 }
220 } {0 ok}
221
222 do_test crash8-3.11 {
223 set fd [open test.db-journal w]
224 fconfigure $fd -translation binary
225 puts -nonewline $fd $zJournal
226 close $fd
227 execsql {
228 SELECT count(*) FROM t1;
229 PRAGMA integrity_check
230 }
231 } {6 ok}
232 }
233
234
235 # If a connection running in persistent-journal mode is part of a
236 # multi-file transaction, it must ensure that the master-journal name
237 # appended to the journal file contents during the commit is located
238 # at the end of the physical journal file. If there was already a
239 # large journal file allocated at the start of the transaction, this
240 # may mean truncating the file so that the master journal name really
241 # is at the physical end of the file.
242 #
243 # This block of tests test that SQLite correctly truncates such
244 # journal files, and that the results behave correctly if a hot-journal
245 # rollback occurs.
246 #
247 ifcapable pragma {
248 reset_db
249 forcedelete test2.db
250
251 do_test crash8-4.1 {
252 execsql {
253 PRAGMA journal_mode = persist;
254 CREATE TABLE ab(a, b);
255 INSERT INTO ab VALUES(0, 'abc');
256 INSERT INTO ab VALUES(1, NULL);
257 INSERT INTO ab VALUES(2, NULL);
258 INSERT INTO ab VALUES(3, NULL);
259 INSERT INTO ab VALUES(4, NULL);
260 INSERT INTO ab VALUES(5, NULL);
261 INSERT INTO ab VALUES(6, NULL);
262 UPDATE ab SET b = randstr(1000,1000);
263 ATTACH 'test2.db' AS aux;
264 PRAGMA aux.journal_mode = persist;
265 CREATE TABLE aux.ab(a, b);
266 INSERT INTO aux.ab SELECT * FROM main.ab;
267
268 UPDATE aux.ab SET b = randstr(1000,1000) WHERE a>=1;
269 UPDATE ab SET b = randstr(1000,1000) WHERE a>=1;
270 }
271 } {persist persist}
272 if {[atomic_batch_write test.db]==0} {
273 do_test crash8.4.1.1 {
274 list [file exists test.db-journal] [file exists test2.db-journal]
275 } {1 1}
276 }
277
278 do_test crash8-4.2 {
279 execsql {
280 BEGIN;
281 UPDATE aux.ab SET b = 'def' WHERE a = 0;
282 UPDATE main.ab SET b = 'def' WHERE a = 0;
283 COMMIT;
284 }
285 } {}
286
287 do_test crash8-4.3 {
288 execsql {
289 UPDATE aux.ab SET b = randstr(1000,1000) WHERE a>=1;
290 UPDATE ab SET b = randstr(1000,1000) WHERE a>=1;
291 }
292 } {}
293
294 set contents_main [db eval {SELECT b FROM main.ab WHERE a = 1}]
295 set contents_aux [db eval {SELECT b FROM aux.ab WHERE a = 1}]
296
297 do_test crash8-4.4 {
298 crashsql -file test2.db -delay 1 {
299 ATTACH 'test2.db' AS aux;
300 BEGIN;
301 UPDATE aux.ab SET b = 'ghi' WHERE a = 0;
302 UPDATE main.ab SET b = 'ghi' WHERE a = 0;
303 COMMIT;
304 }
305 } {1 {child process exited abnormally}}
306
307 do_test crash8-4.5 {
308 list [file exists test.db-journal] [file exists test2.db-journal]
309 } {1 1}
310
311 do_test crash8-4.6 {
312 execsql {
313 SELECT b FROM main.ab WHERE a = 0;
314 SELECT b FROM aux.ab WHERE a = 0;
315 }
316 } {def def}
317
318 do_test crash8-4.7 {
319 crashsql -file test2.db -delay 1 {
320 ATTACH 'test2.db' AS aux;
321 BEGIN;
322 UPDATE aux.ab SET b = 'jkl' WHERE a = 0;
323 UPDATE main.ab SET b = 'jkl' WHERE a = 0;
324 COMMIT;
325 }
326 } {1 {child process exited abnormally}}
327
328 do_test crash8-4.8 {
329 set fd [open test.db-journal]
330 fconfigure $fd -translation binary
331 seek $fd -16 end
332 binary scan [read $fd 4] I len
333
334 seek $fd [expr {-1 * ($len + 16)}] end
335 set zMasterJournal [read $fd $len]
336 close $fd
337
338 file exists $zMasterJournal
339 } {1}
340
341 do_test crash8-4.9 {
342 execsql { SELECT b FROM aux.ab WHERE a = 0 }
343 } {def}
344
345 do_test crash8-4.10 {
346 delete_file $zMasterJournal
347 execsql { SELECT b FROM main.ab WHERE a = 0 }
348 } {jkl}
349 }
350
351 #
352 # Since the following tests (crash8-5.*) rely upon being able
353 # to copy a file while open, they will not work on Windows.
354 #
355 # They also depend on being able to copy the journal file, which
356 # is not created on F2FS file-systems that support atomic
357 # write. So do not run these tests in that case either.
358 #
359 if {$::tcl_platform(os) ne "Windows NT" && [atomic_batch_write test.db]==0 } {
360 for {set i 1} {$i < 10} {incr i} {
361 catch { db close }
362 forcedelete test.db test.db-journal
363 sqlite3 db test.db
364 do_test crash8-5.$i.1 {
365 execsql {
366 CREATE TABLE t1(x PRIMARY KEY);
367 INSERT INTO t1 VALUES(randomblob(900));
368 INSERT INTO t1 SELECT randomblob(900) FROM t1;
369 INSERT INTO t1 SELECT randomblob(900) FROM t1;
370 INSERT INTO t1 SELECT randomblob(900) FROM t1;
371 INSERT INTO t1 SELECT randomblob(900) FROM t1;
372 INSERT INTO t1 SELECT randomblob(900) FROM t1;
373 INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 64 rows */
374 }
375 crashsql -file test.db -delay [expr ($::i%2) + 1] {
376 PRAGMA cache_size = 10;
377 BEGIN;
378 UPDATE t1 SET x = randomblob(900);
379 ROLLBACK;
380 INSERT INTO t1 VALUES(randomblob(900));
381 }
382 execsql { PRAGMA integrity_check }
383 } {ok}
384
385 catch { db close }
386 forcedelete test.db test.db-journal
387 sqlite3 db test.db
388 do_test crash8-5.$i.2 {
389 execsql {
390 PRAGMA cache_size = 10;
391 CREATE TABLE t1(x PRIMARY KEY);
392 INSERT INTO t1 VALUES(randomblob(900));
393 INSERT INTO t1 SELECT randomblob(900) FROM t1;
394 INSERT INTO t1 SELECT randomblob(900) FROM t1;
395 INSERT INTO t1 SELECT randomblob(900) FROM t1;
396 INSERT INTO t1 SELECT randomblob(900) FROM t1;
397 INSERT INTO t1 SELECT randomblob(900) FROM t1;
398 INSERT INTO t1 SELECT randomblob(900) FROM t1; /* 64 rows */
399 BEGIN;
400 UPDATE t1 SET x = randomblob(900);
401 }
402 forcedelete testX.db testX.db-journal testX.db-wal
403 forcecopy test.db testX.db
404 forcecopy test.db-journal testX.db-journal
405 db close
406
407 crashsql -file test.db -delay [expr ($::i%2) + 1] {
408 SELECT * FROM sqlite_master;
409 INSERT INTO t1 VALUES(randomblob(900));
410 }
411
412 sqlite3 db2 testX.db
413 execsql { PRAGMA integrity_check } db2
414 } {ok}
415 }
416 catch {db2 close}
417 }
418
419 finish_test