| blob | c0f5de69acc0a6a0bed37bc8157e5fb4c9214e4f |
1 # 2010 June 15
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 #
13 set testdir [file dirname $argv0]
14 source $testdir/tester.tcl
15 source $testdir/lock_common.tcl
16 source $testdir/malloc_common.tcl
18 if {[permutation] == "inmemory_journal"} {
19 finish_test
20 return
21 }
23 if {$::tcl_platform(platform)=="windows"} {
24 finish_test
25 return
26 }
28 set a_string_counter 1
29 proc a_string {n} {
30 global a_string_counter
31 incr a_string_counter
32 string range [string repeat "${a_string_counter}." $n] 1 $n
33 }
34 db func a_string a_string
36 #-------------------------------------------------------------------------
37 # Test fault-injection while rolling back a hot-journal file.
38 #
39 do_test pagerfault-1-pre1 {
40 execsql {
41 PRAGMA journal_mode = DELETE;
42 PRAGMA cache_size = 10;
43 CREATE TABLE t1(a UNIQUE, b UNIQUE);
44 INSERT INTO t1 VALUES(a_string(200), a_string(300));
45 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
46 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
47 BEGIN;
48 INSERT INTO t1 SELECT a_string(201), a_string(301) FROM t1;
49 INSERT INTO t1 SELECT a_string(202), a_string(302) FROM t1;
50 INSERT INTO t1 SELECT a_string(203), a_string(303) FROM t1;
51 INSERT INTO t1 SELECT a_string(204), a_string(304) FROM t1;
52 }
53 faultsim_save_and_close
54 } {}
55 do_faultsim_test pagerfault-1 -prep {
56 faultsim_restore_and_reopen
57 } -body {
58 execsql { SELECT count(*) FROM t1 }
59 } -test {
60 faultsim_test_result {0 4}
61 faultsim_integrity_check
62 if {[db one { SELECT count(*) FROM t1 }] != 4} {
63 error "Database content appears incorrect"
64 }
65 }
67 #-------------------------------------------------------------------------
68 # Test fault-injection while rolling back a hot-journal file with a
69 # page-size different from the current value stored on page 1 of the
70 # database file.
71 #
72 do_test pagerfault-2-pre1 {
73 testvfs tv -default 1
74 tv filter xSync
75 tv script xSyncCb
76 proc xSyncCb {filename args} {
77 if {[string match *journal filename]==0} faultsim_save
78 }
79 faultsim_delete_and_reopen
80 execsql {
81 PRAGMA page_size = 4096;
82 BEGIN;
83 CREATE TABLE abc(a, b, c);
84 INSERT INTO abc VALUES('o', 't', 't');
85 INSERT INTO abc VALUES('f', 'f', 's');
86 INSERT INTO abc SELECT * FROM abc; -- 4
87 INSERT INTO abc SELECT * FROM abc; -- 8
88 INSERT INTO abc SELECT * FROM abc; -- 16
89 INSERT INTO abc SELECT * FROM abc; -- 32
90 INSERT INTO abc SELECT * FROM abc; -- 64
91 INSERT INTO abc SELECT * FROM abc; -- 128
92 INSERT INTO abc SELECT * FROM abc; -- 256
93 COMMIT;
94 PRAGMA page_size = 1024;
95 VACUUM;
96 }
97 db close
98 tv delete
99 } {}
100 do_faultsim_test pagerfault-2 -prep {
101 faultsim_restore_and_reopen
102 } -body {
103 execsql { SELECT * FROM abc }
104 } -test {
105 set answer [split [string repeat "ottffs" 128] ""]
106 faultsim_test_result [list 0 $answer]
107 faultsim_integrity_check
108 set res [db eval { SELECT * FROM abc }]
109 if {$res != $answer} { error "Database content appears incorrect ($res)" }
110 }
112 #-------------------------------------------------------------------------
113 # Test fault-injection while rolling back hot-journals that were created
114 # as part of a multi-file transaction.
115 #
116 do_test pagerfault-3-pre1 {
117 testvfs tstvfs -default 1
118 tstvfs filter xDelete
119 tstvfs script xDeleteCallback
121 proc xDeleteCallback {method file args} {
122 set file [file tail $file]
123 if { [string match *mj* $file] } { faultsim_save }
124 }
126 faultsim_delete_and_reopen
127 db func a_string a_string
129 execsql {
130 ATTACH 'test.db2' AS aux;
131 PRAGMA journal_mode = DELETE;
132 PRAGMA main.cache_size = 10;
133 PRAGMA aux.cache_size = 10;
135 CREATE TABLE t1(a UNIQUE, b UNIQUE);
136 CREATE TABLE aux.t2(a UNIQUE, b UNIQUE);
137 INSERT INTO t1 VALUES(a_string(200), a_string(300));
138 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
139 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
140 INSERT INTO t2 SELECT * FROM t1;
142 BEGIN;
143 INSERT INTO t1 SELECT a_string(201), a_string(301) FROM t1;
144 INSERT INTO t1 SELECT a_string(202), a_string(302) FROM t1;
145 INSERT INTO t1 SELECT a_string(203), a_string(303) FROM t1;
146 INSERT INTO t1 SELECT a_string(204), a_string(304) FROM t1;
147 REPLACE INTO t2 SELECT * FROM t1;
148 COMMIT;
149 }
151 db close
152 tstvfs delete
153 } {}
154 do_faultsim_test pagerfault-3 -prep {
155 faultsim_restore_and_reopen
156 } -body {
157 execsql {
158 ATTACH 'test.db2' AS aux;
159 SELECT count(*) FROM t2;
160 SELECT count(*) FROM t1;
161 }
162 } -test {
163 faultsim_test_result {0 {4 4}} {1 {unable to open database: test.db2}}
164 faultsim_integrity_check
165 catchsql { ATTACH 'test.db2' AS aux }
166 if {[db one { SELECT count(*) FROM t1 }] != 4
167 || [db one { SELECT count(*) FROM t2 }] != 4
168 } {
169 error "Database content appears incorrect"
170 }
171 }
173 #-------------------------------------------------------------------------
174 # Test fault-injection as part of a vanilla, no-transaction, INSERT
175 # statement.
176 #
177 do_faultsim_test pagerfault-4 -prep {
178 faultsim_delete_and_reopen
179 } -body {
180 execsql {
181 CREATE TABLE x(y);
182 INSERT INTO x VALUES('z');
183 SELECT * FROM x;
184 }
185 } -test {
186 faultsim_test_result {0 z}
187 faultsim_integrity_check
188 }
190 #-------------------------------------------------------------------------
191 # Test fault-injection as part of a commit when using journal_mode=PERSIST.
192 # Three different cases:
193 #
194 # pagerfault-5.1: With no journal_size_limit configured.
195 # pagerfault-5.2: With a journal_size_limit configured.
196 # pagerfault-5.4: Multi-file transaction. One connection has a
197 # journal_size_limit of 0, the other has no limit.
198 #
199 do_test pagerfault-5-pre1 {
200 faultsim_delete_and_reopen
201 db func a_string a_string
202 execsql {
203 CREATE TABLE t1(a UNIQUE, b UNIQUE);
204 INSERT INTO t1 VALUES(a_string(200), a_string(300));
205 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
206 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
207 }
208 faultsim_save_and_close
209 } {}
210 do_faultsim_test pagerfault-5.1 -prep {
211 faultsim_restore_and_reopen
212 db func a_string a_string
213 execsql { PRAGMA journal_mode = PERSIST }
214 } -body {
215 execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 }
216 } -test {
217 faultsim_test_result {0 {}}
218 faultsim_integrity_check
219 }
220 do_faultsim_test pagerfault-5.2 -prep {
221 faultsim_restore_and_reopen
222 db func a_string a_string
223 execsql {
224 PRAGMA journal_mode = PERSIST;
225 PRAGMA journal_size_limit = 2048;
226 }
227 } -body {
228 execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 }
229 } -test {
230 faultsim_test_result {0 {}}
231 faultsim_integrity_check
232 }
233 do_faultsim_test pagerfault-5.3 -faults oom-transient -prep {
234 faultsim_restore_and_reopen
235 db func a_string a_string
236 forcedelete test2.db test2.db-journal test2.db-wal
237 execsql {
238 PRAGMA journal_mode = PERSIST;
239 ATTACH 'test2.db' AS aux;
240 PRAGMA aux.journal_mode = PERSIST;
241 PRAGMA aux.journal_size_limit = 0;
242 }
243 } -body {
244 execsql {
245 BEGIN;
246 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1;
247 CREATE TABLE aux.t2 AS SELECT * FROM t1;
248 COMMIT;
249 }
250 } -test {
251 faultsim_test_result {0 {}}
253 catchsql { COMMIT }
254 catchsql { ROLLBACK }
256 faultsim_integrity_check
257 set res ""
258 set rc [catch { set res [db one { PRAGMA aux.integrity_check }] }]
259 if {$rc!=0 || $res != "ok"} {error "integrity-check problem:$rc $res"}
260 }
262 #-------------------------------------------------------------------------
263 # Test fault-injection as part of a commit when using
264 # journal_mode=TRUNCATE.
265 #
266 do_test pagerfault-6-pre1 {
267 faultsim_delete_and_reopen
268 db func a_string a_string
269 execsql {
270 CREATE TABLE t1(a UNIQUE, b UNIQUE);
271 INSERT INTO t1 VALUES(a_string(200), a_string(300));
272 }
273 faultsim_save_and_close
274 } {}
276 do_faultsim_test pagerfault-6.1 -prep {
277 faultsim_restore_and_reopen
278 db func a_string a_string
279 execsql { PRAGMA journal_mode = TRUNCATE }
280 } -body {
281 execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 }
282 execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 }
283 } -test {
284 faultsim_test_result {0 {}}
285 faultsim_integrity_check
286 }
288 # The unix vfs xAccess() method considers a file zero bytes in size to
289 # "not exist". This proc overrides that behaviour so that a zero length
290 # file is considered to exist.
291 #
292 proc xAccess {method filename op args} {
293 if {$op != "SQLITE_ACCESS_EXISTS"} { return "" }
294 return [file exists $filename]
295 }
296 do_faultsim_test pagerfault-6.2 -faults cantopen-* -prep {
297 shmfault filter xAccess
298 shmfault script xAccess
300 faultsim_restore_and_reopen
301 db func a_string a_string
302 execsql { PRAGMA journal_mode = TRUNCATE }
303 } -body {
304 execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 }
305 execsql { INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1 }
306 } -test {
307 faultsim_test_result {0 {}}
308 faultsim_integrity_check
309 }
311 # The following was an attempt to get a bitvec malloc to fail. Didn't work.
312 #
313 # do_test pagerfault-6-pre1 {
314 # faultsim_delete_and_reopen
315 # execsql {
316 # CREATE TABLE t1(x, y, UNIQUE(x, y));
317 # INSERT INTO t1 VALUES(1, randomblob(1501));
318 # INSERT INTO t1 VALUES(2, randomblob(1502));
319 # INSERT INTO t1 VALUES(3, randomblob(1503));
320 # INSERT INTO t1 VALUES(4, randomblob(1504));
321 # INSERT INTO t1
322 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1;
323 # INSERT INTO t1
324 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1;
325 # INSERT INTO t1
326 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1;
327 # INSERT INTO t1
328 # SELECT x, randomblob(1500+oid+(SELECT max(oid) FROM t1)) FROM t1;
329 # }
330 # faultsim_save_and_close
331 # } {}
332 # do_faultsim_test pagerfault-6 -prep {
333 # faultsim_restore_and_reopen
334 # } -body {
335 # execsql {
336 # BEGIN;
337 # UPDATE t1 SET x=x+4 WHERE x=1;
338 # SAVEPOINT one;
339 # UPDATE t1 SET x=x+4 WHERE x=2;
340 # SAVEPOINT three;
341 # UPDATE t1 SET x=x+4 WHERE x=3;
342 # SAVEPOINT four;
343 # UPDATE t1 SET x=x+4 WHERE x=4;
344 # RELEASE three;
345 # COMMIT;
346 # SELECT DISTINCT x FROM t1;
347 # }
348 # } -test {
349 # faultsim_test_result {0 {5 6 7 8}}
350 # faultsim_integrity_check
351 # }
352 #
354 # This is designed to provoke a special case in the pager code:
355 #
356 # If an error (specifically, a FULL or IOERR error) occurs while writing a
357 # dirty page to the file-system in order to free up memory, the pager enters
358 # the "error state". An IO error causes SQLite to roll back the current
359 # transaction (exiting the error state). A FULL error, however, may only
360 # rollback the current statement.
361 #
362 # This block tests that nothing goes wrong if a FULL error occurs while
363 # writing a dirty page out to free memory from within a statement that has
364 # opened a statement transaction.
365 #
366 do_test pagerfault-7-pre1 {
367 faultsim_delete_and_reopen
368 execsql {
369 CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
370 BEGIN;
371 INSERT INTO t2 VALUES(NULL, randomblob(1500));
372 INSERT INTO t2 VALUES(NULL, randomblob(1500));
373 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 4
374 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 8
375 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 16
376 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 32
377 INSERT INTO t2 SELECT NULL, randomblob(1500) FROM t2; -- 64
378 COMMIT;
379 CREATE TABLE t1(a PRIMARY KEY, b);
380 INSERT INTO t1 SELECT * FROM t2;
381 DROP TABLE t2;
382 }
383 faultsim_save_and_close
384 } {}
385 do_faultsim_test pagerfault-7 -prep {
386 faultsim_restore_and_reopen
387 execsql {
388 PRAGMA cache_size = 10;
389 BEGIN;
390 UPDATE t1 SET b = randomblob(1500);
391 }
392 } -body {
393 execsql { UPDATE t1 SET a = 65, b = randomblob(1500) WHERE (a+1)>200 }
394 execsql COMMIT
395 } -test {
396 faultsim_test_result {0 {}}
397 faultsim_integrity_check
398 }
400 do_test pagerfault-8-pre1 {
401 faultsim_delete_and_reopen
402 execsql {
403 PRAGMA auto_vacuum = 1;
404 CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
405 BEGIN;
406 INSERT INTO t1 VALUES(NULL, randomblob(1500));
407 INSERT INTO t1 VALUES(NULL, randomblob(1500));
408 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 4
409 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 8
410 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 16
411 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 32
412 INSERT INTO t1 SELECT NULL, randomblob(1500) FROM t1; -- 64
413 COMMIT;
414 }
415 faultsim_save_and_close
416 set filesize [file size test.db]
417 set {} {}
418 } {}
419 do_test pagerfault-8-pre2 {
420 faultsim_restore_and_reopen
421 execsql { DELETE FROM t1 WHERE a>32 }
422 expr {[file size test.db] < $filesize}
423 } {1}
424 do_faultsim_test pagerfault-8 -prep {
425 faultsim_restore_and_reopen
426 execsql {
427 BEGIN;
428 DELETE FROM t1 WHERE a>32;
429 }
430 } -body {
431 execsql COMMIT
432 } -test {
433 faultsim_test_result {0 {}}
434 faultsim_integrity_check
435 }
437 #-------------------------------------------------------------------------
438 # This test case is specially designed so that during a savepoint
439 # rollback, a new cache entry must be allocated (see comments surrounding
440 # the call to sqlite3PagerAcquire() from within pager_playback_one_page()
441 # for details). Test the effects of injecting an OOM at this point.
442 #
443 do_test pagerfault-9-pre1 {
444 faultsim_delete_and_reopen
445 execsql {
446 PRAGMA auto_vacuum = incremental;
447 CREATE TABLE t1(x);
448 CREATE TABLE t2(y);
449 CREATE TABLE t3(z);
451 INSERT INTO t1 VALUES(randomblob(900));
452 INSERT INTO t1 VALUES(randomblob(900));
453 DELETE FROM t1;
454 }
455 faultsim_save_and_close
456 } {}
457 do_faultsim_test pagerfault-9.1 -prep {
458 faultsim_restore_and_reopen
459 execsql {
460 BEGIN;
461 INSERT INTO t1 VALUES(randomblob(900));
462 INSERT INTO t1 VALUES(randomblob(900));
463 DROP TABLE t3;
464 DROP TABLE t2;
465 SAVEPOINT abc;
466 PRAGMA incremental_vacuum;
467 }
468 } -body {
469 execsql {
470 ROLLBACK TO abc;
471 COMMIT;
472 PRAGMA freelist_count
473 }
474 } -test {
475 faultsim_test_result {0 2}
476 faultsim_integrity_check
478 set sl [db one { SELECT COALESCE(sum(length(x)), 'null') FROM t1 }]
479 if {$sl!="null" && $sl!=1800} {
480 error "Content looks no good... ($sl)"
481 }
482 }
484 #-------------------------------------------------------------------------
485 # Test fault injection with a temporary database file.
486 #
487 foreach v {a b} {
488 do_faultsim_test pagerfault-10$v -prep {
489 sqlite3 db ""
490 db func a_string a_string;
491 execsql {
492 PRAGMA cache_size = 10;
493 BEGIN;
494 CREATE TABLE xx(a, b, UNIQUE(a, b));
495 INSERT INTO xx VALUES(a_string(200), a_string(200));
496 INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx;
497 INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx;
498 INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx;
499 INSERT INTO xx SELECT a_string(200), a_string(200) FROM xx;
500 COMMIT;
501 }
502 } -body {
503 execsql { UPDATE xx SET a = a_string(300) }
504 } -test {
505 faultsim_test_result {0 {}}
506 if {$::v == "b"} { execsql { PRAGMA journal_mode = TRUNCATE } }
507 faultsim_integrity_check
508 faultsim_integrity_check
509 }
510 }
512 #-------------------------------------------------------------------------
513 # Test fault injection with transaction savepoints (savepoints created
514 # when a SAVEPOINT command is executed outside of any other savepoint
515 # or transaction context).
516 #
517 do_test pagerfault-9-pre1 {
518 faultsim_delete_and_reopen
519 db func a_string a_string;
520 execsql {
521 PRAGMA auto_vacuum = on;
522 CREATE TABLE t1(x UNIQUE);
523 CREATE TABLE t2(y UNIQUE);
524 CREATE TABLE t3(z UNIQUE);
525 BEGIN;
526 INSERT INTO t1 VALUES(a_string(202));
527 INSERT INTO t2 VALUES(a_string(203));
528 INSERT INTO t3 VALUES(a_string(204));
529 INSERT INTO t1 SELECT a_string(202) FROM t1;
530 INSERT INTO t1 SELECT a_string(203) FROM t1;
531 INSERT INTO t1 SELECT a_string(204) FROM t1;
532 INSERT INTO t1 SELECT a_string(205) FROM t1;
533 INSERT INTO t2 SELECT a_string(length(x)) FROM t1;
534 INSERT INTO t3 SELECT a_string(length(x)) FROM t1;
535 COMMIT;
536 }
537 faultsim_save_and_close
538 } {}
539 do_faultsim_test pagerfault-11 -prep {
540 faultsim_restore_and_reopen
541 execsql { PRAGMA cache_size = 10 }
542 } -body {
543 execsql {
544 SAVEPOINT trans;
545 UPDATE t2 SET y = y||'2';
546 INSERT INTO t3 SELECT * FROM t2;
547 DELETE FROM t1;
548 ROLLBACK TO trans;
549 UPDATE t1 SET x = x||'3';
550 INSERT INTO t2 SELECT * FROM t1;
551 DELETE FROM t3;
552 RELEASE trans;
553 }
554 } -test {
555 faultsim_test_result {0 {}}
556 faultsim_integrity_check
557 }
560 #-------------------------------------------------------------------------
561 # Test fault injection when writing to a database file that resides on
562 # a file-system with a sector-size larger than the database page-size.
563 #
564 do_test pagerfault-12-pre1 {
565 testvfs ss_layer -default 1
566 ss_layer sectorsize 4096
567 faultsim_delete_and_reopen
568 db func a_string a_string;
570 execsql {
571 PRAGMA page_size = 1024;
572 PRAGMA journal_mode = PERSIST;
573 PRAGMA cache_size = 10;
574 BEGIN;
575 CREATE TABLE t1(x, y UNIQUE);
576 INSERT INTO t1 VALUES(a_string(333), a_string(444));
577 INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1;
578 INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1;
579 INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1;
580 INSERT INTO t1 SELECT a_string(333+rowid), a_string(444+rowid) FROM t1;
581 INSERT INTO t1 SELECT a_string(44), a_string(55) FROM t1 LIMIT 13;
582 COMMIT;
583 }
584 faultsim_save_and_close
585 } {}
587 do_faultsim_test pagerfault-12a -prep {
588 faultsim_restore_and_reopen
589 execsql { PRAGMA cache_size = 10 }
590 db func a_string a_string;
591 } -body {
592 execsql {
593 UPDATE t1 SET x = a_string(length(x)), y = a_string(length(y));
594 }
595 } -test {
596 faultsim_test_result {0 {}}
597 faultsim_integrity_check
598 }
600 do_test pagerfault-12-pre2 {
601 faultsim_restore_and_reopen
602 execsql {
603 CREATE TABLE t2 AS SELECT * FROM t1 LIMIT 10;
604 }
605 faultsim_save_and_close
606 } {}
607 do_faultsim_test pagerfault-12b -prep {
608 faultsim_restore_and_reopen
609 db func a_string a_string;
610 execsql { SELECT * FROM t1 }
611 } -body {
612 set sql(1) { UPDATE t2 SET x = a_string(280) }
613 set sql(2) { UPDATE t1 SET x = a_string(280) WHERE rowid = 5 }
615 db eval { SELECT rowid FROM t1 LIMIT 2 } { db eval $sql($rowid) }
617 } -test {
618 faultsim_test_result {0 {}}
619 faultsim_integrity_check
620 }
622 catch { db close }
623 ss_layer delete
626 #-------------------------------------------------------------------------
627 # Test fault injection when SQLite opens a database where the size of the
628 # database file is zero bytes but the accompanying journal file is larger
629 # than that. In this scenario SQLite should delete the journal file
630 # without rolling it back, even if it is in all other respects a valid
631 # hot-journal file.
632 #
633 do_test pagerfault-13-pre1 {
634 faultsim_delete_and_reopen
635 db func a_string a_string;
636 execsql {
637 PRAGMA journal_mode = PERSIST;
638 BEGIN;
639 CREATE TABLE t1(x, y UNIQUE);
640 INSERT INTO t1 VALUES(a_string(333), a_string(444));
641 COMMIT;
642 }
643 db close
644 forcedelete test.db
645 faultsim_save
646 } {}
647 do_faultsim_test pagerfault-13 -prep {
648 faultsim_restore_and_reopen
649 } -body {
650 execsql { CREATE TABLE xx(a, b) }
651 } -test {
652 faultsim_test_result {0 {}}
653 }
655 #---------------------------------------------------------------------------
656 # Test fault injection into a small backup operation.
657 #
658 do_test pagerfault-14-pre1 {
659 faultsim_delete_and_reopen
660 db func a_string a_string;
661 execsql {
662 PRAGMA journal_mode = PERSIST;
663 ATTACH 'test.db2' AS two;
664 BEGIN;
665 CREATE TABLE t1(x, y UNIQUE);
666 CREATE TABLE two.t2(x, y UNIQUE);
667 INSERT INTO t1 VALUES(a_string(333), a_string(444));
668 INSERT INTO t2 VALUES(a_string(333), a_string(444));
669 COMMIT;
670 }
671 faultsim_save_and_close
672 } {}
674 do_faultsim_test pagerfault-14a -prep {
675 faultsim_restore_and_reopen
676 } -body {
677 if {[catch {db backup test.db2} msg]} { error [regsub {.*: } $msg {}] }
678 } -test {
679 faultsim_test_result {0 {}} {1 {}} {1 {SQL logic error or missing database}}
680 }
682 # If TEMP_STORE is 2 or greater, then the database [db2] will be created
683 # as an in-memory database. This test will not work in that case, as it
684 # is not possible to change the page-size of an in-memory database. Even
685 # using the backup API.
686 #
687 if {$TEMP_STORE<2} {
688 do_faultsim_test pagerfault-14b -prep {
689 catch { db2 close }
690 faultsim_restore_and_reopen
691 sqlite3 db2 ""
692 db2 eval { PRAGMA page_size = 4096; CREATE TABLE xx(a) }
693 } -body {
694 sqlite3_backup B db2 main db main
695 B step 200
696 set rc [B finish]
697 if {[string match SQLITE_IOERR_* $rc]} {set rc SQLITE_IOERR}
698 if {$rc != "SQLITE_OK"} { error [sqlite3_test_errstr $rc] }
699 set {} {}
700 } -test {
701 faultsim_test_result {0 {}} {1 {sqlite3_backup_init() failed}}
702 }
703 }
705 do_faultsim_test pagerfault-14c -prep {
706 catch { db2 close }
707 faultsim_restore_and_reopen
708 sqlite3 db2 test.db2
709 db2 eval {
710 PRAGMA synchronous = off;
711 PRAGMA page_size = 4096;
712 CREATE TABLE xx(a);
713 }
714 } -body {
715 sqlite3_backup B db2 main db main
716 B step 200
717 set rc [B finish]
718 if {[string match SQLITE_IOERR_* $rc]} {set rc SQLITE_IOERR}
719 if {$rc != "SQLITE_OK"} { error [sqlite3_test_errstr $rc] }
720 set {} {}
721 } -test {
722 faultsim_test_result {0 {}} {1 {sqlite3_backup_init() failed}}
723 }
725 do_test pagerfault-15-pre1 {
726 faultsim_delete_and_reopen
727 db func a_string a_string;
728 execsql {
729 BEGIN;
730 CREATE TABLE t1(x, y UNIQUE);
731 INSERT INTO t1 VALUES(a_string(11), a_string(22));
732 INSERT INTO t1 VALUES(a_string(11), a_string(22));
733 COMMIT;
734 }
735 faultsim_save_and_close
736 } {}
737 do_faultsim_test pagerfault-15 -prep {
738 faultsim_restore_and_reopen
739 db func a_string a_string;
740 } -body {
741 db eval { SELECT * FROM t1 LIMIT 1 } {
742 execsql {
743 BEGIN; INSERT INTO t1 VALUES(a_string(333), a_string(555)); COMMIT;
744 BEGIN; INSERT INTO t1 VALUES(a_string(333), a_string(555)); COMMIT;
745 }
746 }
747 } -test {
748 faultsim_test_result {0 {}}
749 faultsim_integrity_check
750 }
753 do_test pagerfault-16-pre1 {
754 faultsim_delete_and_reopen
755 execsql { CREATE TABLE t1(x, y UNIQUE) }
756 faultsim_save_and_close
757 } {}
758 do_faultsim_test pagerfault-16 -prep {
759 faultsim_restore_and_reopen
760 } -body {
761 execsql {
762 PRAGMA locking_mode = exclusive;
763 PRAGMA journal_mode = wal;
764 INSERT INTO t1 VALUES(1, 2);
765 INSERT INTO t1 VALUES(3, 4);
766 PRAGMA journal_mode = delete;
767 INSERT INTO t1 VALUES(4, 5);
768 PRAGMA journal_mode = wal;
769 INSERT INTO t1 VALUES(6, 7);
770 PRAGMA journal_mode = persist;
771 INSERT INTO t1 VALUES(8, 9);
772 }
773 } -test {
774 faultsim_test_result {0 {exclusive wal delete wal persist}}
775 faultsim_integrity_check
776 }
779 #-------------------------------------------------------------------------
780 # Test fault injection while changing into and out of WAL mode.
781 #
782 do_test pagerfault-17-pre1 {
783 faultsim_delete_and_reopen
784 execsql {
785 CREATE TABLE t1(a PRIMARY KEY, b);
786 INSERT INTO t1 VALUES(1862, 'Botha');
787 INSERT INTO t1 VALUES(1870, 'Smuts');
788 INSERT INTO t1 VALUES(1866, 'Hertzog');
789 }
790 faultsim_save_and_close
791 } {}
792 do_faultsim_test pagerfault-17a -prep {
793 faultsim_restore_and_reopen
794 } -body {
795 execsql {
796 PRAGMA journal_mode = wal;
797 PRAGMA journal_mode = delete;
798 }
799 } -test {
800 faultsim_test_result {0 {wal delete}}
801 faultsim_integrity_check
802 }
803 do_faultsim_test pagerfault-17b -prep {
804 faultsim_restore_and_reopen
805 execsql { PRAGMA synchronous = OFF }
806 } -body {
807 execsql {
808 PRAGMA journal_mode = wal;
809 INSERT INTO t1 VALUES(22, 'Clarke');
810 PRAGMA journal_mode = delete;
811 }
812 } -test {
813 faultsim_test_result {0 {wal delete}}
814 faultsim_integrity_check
815 }
816 do_faultsim_test pagerfault-17c -prep {
817 faultsim_restore_and_reopen
818 execsql {
819 PRAGMA locking_mode = exclusive;
820 PRAGMA journal_mode = wal;
821 }
822 } -body {
823 execsql { PRAGMA journal_mode = delete }
824 } -test {
825 faultsim_test_result {0 delete}
826 faultsim_integrity_check
827 }
828 do_faultsim_test pagerfault-17d -prep {
829 catch { db2 close }
830 faultsim_restore_and_reopen
831 sqlite3 db2 test.db
832 execsql { PRAGMA journal_mode = delete }
833 execsql { PRAGMA journal_mode = wal }
834 execsql { INSERT INTO t1 VALUES(99, 'Bradman') } db2
835 } -body {
836 execsql { PRAGMA journal_mode = delete }
837 } -test {
838 faultsim_test_result {1 {database is locked}}
839 faultsim_integrity_check
840 }
841 do_faultsim_test pagerfault-17e -prep {
842 catch { db2 close }
843 faultsim_restore_and_reopen
844 sqlite3 db2 test.db
845 execsql { PRAGMA journal_mode = delete }
846 execsql { PRAGMA journal_mode = wal }
847 set ::chan [launch_testfixture]
848 testfixture $::chan {
849 sqlite3 db test.db
850 db eval { INSERT INTO t1 VALUES(101, 'Latham') }
851 }
852 catch { testfixture $::chan sqlite_abort }
853 catch { close $::chan }
854 } -body {
855 execsql { PRAGMA journal_mode = delete }
856 } -test {
857 faultsim_test_result {0 delete}
858 faultsim_integrity_check
859 }
861 #-------------------------------------------------------------------------
862 # Test fault-injection when changing from journal_mode=persist to
863 # journal_mode=delete (this involves deleting the journal file).
864 #
865 do_test pagerfault-18-pre1 {
866 faultsim_delete_and_reopen
867 execsql {
868 CREATE TABLE qq(x);
869 INSERT INTO qq VALUES('Herbert');
870 INSERT INTO qq VALUES('Macalister');
871 INSERT INTO qq VALUES('Mackenzie');
872 INSERT INTO qq VALUES('Lilley');
873 INSERT INTO qq VALUES('Palmer');
874 }
875 faultsim_save_and_close
876 } {}
877 do_faultsim_test pagerfault-18 -prep {
878 faultsim_restore_and_reopen
879 execsql {
880 PRAGMA journal_mode = PERSIST;
881 INSERT INTO qq VALUES('Beatty');
882 }
883 } -body {
884 execsql { PRAGMA journal_mode = delete }
885 } -test {
886 faultsim_test_result {0 delete}
887 faultsim_integrity_check
888 }
890 do_faultsim_test pagerfault-19a -prep {
891 sqlite3 db :memory:
892 db func a_string a_string
893 execsql {
894 PRAGMA auto_vacuum = FULL;
895 BEGIN;
896 CREATE TABLE t1(a, b);
897 INSERT INTO t1 VALUES(a_string(5000), a_string(6000));
898 COMMIT;
899 }
900 } -body {
901 execsql {
902 CREATE TABLE t2(a, b);
903 INSERT INTO t2 SELECT * FROM t1;
904 DELETE FROM t1;
905 }
906 } -test {
907 faultsim_test_result {0 {}}
908 }
910 do_test pagerfault-19-pre1 {
911 faultsim_delete_and_reopen
912 execsql {
913 PRAGMA auto_vacuum = FULL;
914 CREATE TABLE t1(x); INSERT INTO t1 VALUES(1);
915 CREATE TABLE t2(x); INSERT INTO t2 VALUES(2);
916 CREATE TABLE t3(x); INSERT INTO t3 VALUES(3);
917 CREATE TABLE t4(x); INSERT INTO t4 VALUES(4);
918 CREATE TABLE t5(x); INSERT INTO t5 VALUES(5);
919 CREATE TABLE t6(x); INSERT INTO t6 VALUES(6);
920 }
921 faultsim_save_and_close
922 } {}
923 do_faultsim_test pagerfault-19b -prep {
924 faultsim_restore_and_reopen
925 } -body {
926 execsql {
927 BEGIN;
928 UPDATE t4 SET x = x+1;
929 UPDATE t6 SET x = x+1;
930 SAVEPOINT one;
931 UPDATE t3 SET x = x+1;
932 SAVEPOINT two;
933 DROP TABLE t2;
934 ROLLBACK TO one;
935 COMMIT;
936 SELECT * FROM t3;
937 SELECT * FROM t4;
938 SELECT * FROM t6;
939 }
940 } -test {
941 faultsim_test_result {0 {3 5 7}}
942 }
944 #-------------------------------------------------------------------------
945 # This tests fault-injection in a special case in the auto-vacuum code.
946 #
947 do_test pagerfault-20-pre1 {
948 faultsim_delete_and_reopen
949 execsql {
950 PRAGMA cache_size = 10;
951 PRAGMA auto_vacuum = FULL;
952 CREATE TABLE t0(a, b);
953 }
954 faultsim_save_and_close
955 } {}
956 do_faultsim_test pagerfault-20 -prep {
957 faultsim_restore_and_reopen
958 } -body {
959 execsql {
960 BEGIN;
961 CREATE TABLE t1(a, b);
962 CREATE TABLE t2(a, b);
963 DROP TABLE t1;
964 COMMIT;
965 }
966 } -test {
967 faultsim_test_result {0 {}}
968 }
970 do_test pagerfault-21-pre1 {
971 faultsim_delete_and_reopen
972 execsql {
973 PRAGMA cache_size = 10;
974 CREATE TABLE t0(a PRIMARY KEY, b);
975 INSERT INTO t0 VALUES(1, 2);
976 }
977 faultsim_save_and_close
978 } {}
979 do_faultsim_test pagerfault-21 -prep {
980 faultsim_restore_and_reopen
981 } -body {
982 db eval { SELECT * FROM t0 LIMIT 1 } {
983 db eval { INSERT INTO t0 SELECT a+1, b FROM t0 }
984 db eval { INSERT INTO t0 SELECT a+2, b FROM t0 }
985 }
986 } -test {
987 faultsim_test_result {0 {}}
988 }
991 #-------------------------------------------------------------------------
992 # Test fault-injection and rollback when the nReserve header value
993 # is non-zero.
994 #
995 do_test pagerfault-21-pre1 {
996 faultsim_delete_and_reopen
997 execsql {
998 PRAGMA page_size = 1024;
999 PRAGMA journal_mode = WAL;
1000 PRAGMA journal_mode = DELETE;
1001 }
1002 db close
1003 hexio_write test.db 20 10
1004 hexio_write test.db 105 03F0
1005 sqlite3 db test.db
1006 db func a_string a_string
1007 execsql {
1008 CREATE TABLE t0(a PRIMARY KEY, b UNIQUE);
1009 INSERT INTO t0 VALUES(a_string(222), a_string(333));
1010 INSERT INTO t0 VALUES(a_string(223), a_string(334));
1011 INSERT INTO t0 VALUES(a_string(224), a_string(335));
1012 INSERT INTO t0 VALUES(a_string(225), a_string(336));
1013 }
1014 faultsim_save_and_close
1015 } {}
1017 do_faultsim_test pagerfault-21 -prep {
1018 faultsim_restore_and_reopen
1019 } -body {
1020 execsql { INSERT INTO t0 SELECT a||'x', b||'x' FROM t0 }
1021 } -test {
1022 faultsim_test_result {0 {}}
1023 faultsim_integrity_check
1024 }
1025 ifcapable crashtest {
1026 faultsim_delete_and_reopen
1027 execsql {
1028 PRAGMA page_size = 1024;
1029 PRAGMA journal_mode = WAL;
1030 PRAGMA journal_mode = DELETE;
1031 }
1032 db close
1033 hexio_write test.db 20 10
1034 hexio_write test.db 105 03F0
1036 sqlite3 db test.db
1037 db func a_string a_string
1038 execsql {
1039 CREATE TABLE t0(a PRIMARY KEY, b UNIQUE);
1040 INSERT INTO t0 VALUES(a_string(222), a_string(333));
1041 INSERT INTO t0 VALUES(a_string(223), a_string(334));
1042 }
1043 faultsim_save_and_close
1045 for {set iTest 1} {$iTest<50} {incr iTest} {
1046 do_test pagerfault-21.crash.$iTest.1 {
1047 crashsql -delay 1 -file test.db -seed $iTest {
1048 BEGIN;
1049 CREATE TABLE t1(a PRIMARY KEY, b UNIQUE);
1050 INSERT INTO t1 SELECT a, b FROM t0;
1051 COMMIT;
1052 }
1053 } {1 {child process exited abnormally}}
1054 do_test pagerfault-22.$iTest.2 {
1055 sqlite3 db test.db
1056 execsql { PRAGMA integrity_check }
1057 } {ok}
1058 db close
1059 }
1060 }
1063 #-------------------------------------------------------------------------
1064 # When a 3.7.0 client opens a write-transaction on a database file that
1065 # has been appended to or truncated by a pre-370 client, it updates
1066 # the db-size in the file header immediately. This test case provokes
1067 # errors during that operation.
1068 #
1069 do_test pagerfault-22-pre1 {
1070 faultsim_delete_and_reopen
1071 db func a_string a_string
1072 execsql {
1073 PRAGMA page_size = 1024;
1074 PRAGMA auto_vacuum = 0;
1075 CREATE TABLE t1(a);
1076 CREATE INDEX i1 ON t1(a);
1077 INSERT INTO t1 VALUES(a_string(3000));
1078 CREATE TABLE t2(a);
1079 INSERT INTO t2 VALUES(1);
1080 }
1081 db close
1082 sql36231 { INSERT INTO t1 VALUES(a_string(3000)) }
1083 faultsim_save_and_close
1084 } {}
1085 do_faultsim_test pagerfault-22 -prep {
1086 faultsim_restore_and_reopen
1087 } -body {
1088 execsql { INSERT INTO t2 VALUES(2) }
1089 execsql { SELECT * FROM t2 }
1090 } -test {
1091 faultsim_test_result {0 {1 2}}
1092 faultsim_integrity_check
1093 }
1095 #-------------------------------------------------------------------------
1096 # Provoke an OOM error during a commit of multi-file transaction. One of
1097 # the databases written during the transaction is an in-memory database.
1098 # This test causes rollback of the in-memory database after CommitPhaseOne()
1099 # has successfully returned. i.e. the series of calls for the aborted commit
1100 # is:
1101 #
1102 # PagerCommitPhaseOne(<in-memory-db>) -> SQLITE_OK
1103 # PagerCommitPhaseOne(<file-db>) -> SQLITE_IOERR
1104 # PagerRollback(<in-memory-db>)
1105 # PagerRollback(<file-db>)
1106 #
1107 do_faultsim_test pagerfault-23 -prep {
1108 sqlite3 db :memory:
1109 foreach f [glob -nocomplain test.db*] { forcedelete $f }
1110 db eval {
1111 ATTACH 'test.db2' AS aux;
1112 CREATE TABLE t1(a, b);
1113 CREATE TABLE aux.t2(a, b);
1114 }
1115 } -body {
1116 execsql {
1117 BEGIN;
1118 INSERT INTO t1 VALUES(1,2);
1119 INSERT INTO t2 VALUES(3,4);
1120 COMMIT;
1121 }
1122 } -test {
1123 faultsim_test_result {0 {}}
1124 faultsim_integrity_check
1125 }
1127 do_faultsim_test pagerfault-24 -prep {
1128 faultsim_delete_and_reopen
1129 db eval { PRAGMA temp_store = file }
1130 execsql { CREATE TABLE x(a, b) }
1131 } -body {
1132 execsql { CREATE TEMP TABLE t1(a, b) }
1133 } -test {
1134 faultsim_test_result {0 {}} \
1135 {1 {unable to open a temporary database file for storing temporary tables}}
1136 set ic [db eval { PRAGMA temp.integrity_check }]
1137 if {$ic != "ok"} { error "Integrity check: $ic" }
1138 }
1140 proc lockrows {n} {
1141 if {$n==0} { return "" }
1142 db eval { SELECT * FROM t1 WHERE oid = $n } {
1143 return [lockrows [expr {$n-1}]]
1144 }
1145 }
1148 do_test pagerfault-25-pre1 {
1149 faultsim_delete_and_reopen
1150 db func a_string a_string
1151 execsql {
1152 PRAGMA page_size = 1024;
1153 PRAGMA auto_vacuum = 0;
1154 CREATE TABLE t1(a);
1155 INSERT INTO t1 VALUES(a_string(500));
1156 INSERT INTO t1 SELECT a_string(500) FROM t1;
1157 INSERT INTO t1 SELECT a_string(500) FROM t1;
1158 INSERT INTO t1 SELECT a_string(500) FROM t1;
1159 INSERT INTO t1 SELECT a_string(500) FROM t1;
1160 INSERT INTO t1 SELECT a_string(500) FROM t1;
1161 }
1162 faultsim_save_and_close
1163 } {}
1164 do_faultsim_test pagerfault-25 -prep {
1165 faultsim_restore_and_reopen
1166 db func a_string a_string
1167 set ::channel [db incrblob -readonly t1 a 1]
1168 execsql {
1169 PRAGMA cache_size = 10;
1170 BEGIN;
1171 INSERT INTO t1 VALUES(a_string(3000));
1172 INSERT INTO t1 VALUES(a_string(3000));
1173 }
1174 } -body {
1175 lockrows 30
1176 } -test {
1177 catch { lockrows 30 }
1178 catch { db eval COMMIT }
1179 close $::channel
1180 faultsim_test_result {0 {}}
1181 }
1183 do_faultsim_test pagerfault-26 -prep {
1184 faultsim_delete_and_reopen
1185 execsql {
1186 PRAGMA page_size = 1024;
1187 PRAGMA journal_mode = truncate;
1188 PRAGMA auto_vacuum = full;
1189 PRAGMA locking_mode=exclusive;
1190 CREATE TABLE t1(a, b);
1191 INSERT INTO t1 VALUES(1, 2);
1192 PRAGMA page_size = 4096;
1193 }
1194 } -body {
1195 execsql {
1196 VACUUM;
1197 }
1198 } -test {
1199 faultsim_test_result {0 {}}
1201 set contents [db eval {SELECT * FROM t1}]
1202 if {$contents != "1 2"} { error "Bad database contents ($contents)" }
1204 set sz [file size test.db]
1205 if {$testrc!=0 && $sz!=1024*3 && $sz!=4096*3} {
1206 error "Expected file size to be 3072 or 12288 bytes - actual size $sz bytes"
1207 }
1208 if {$testrc==0 && $sz!=4096*3} {
1209 error "Expected file size to be 12288 bytes - actual size $sz bytes"
1210 }
1211 }
1213 do_test pagerfault-27-pre {
1214 faultsim_delete_and_reopen
1215 db func a_string a_string
1216 execsql {
1217 PRAGMA page_size = 1024;
1218 CREATE TABLE t1(a, b);
1219 CREATE TABLE t2(a UNIQUE, b UNIQUE);
1220 INSERT INTO t2 VALUES( a_string(800), a_string(800) );
1221 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1222 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1223 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1224 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1225 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1226 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1227 INSERT INTO t1 VALUES (a_string(20000), a_string(20000));
1228 }
1229 faultsim_save_and_close
1230 } {}
1231 do_faultsim_test pagerfault-27 -faults ioerr-persistent -prep {
1232 faultsim_restore_and_reopen
1233 db func a_string a_string
1234 execsql {
1235 PRAGMA cache_size = 10;
1236 BEGIN EXCLUSIVE;
1237 }
1238 set ::channel [db incrblob t1 a 1]
1239 } -body {
1240 puts $::channel [string repeat abc 6000]
1241 flush $::channel
1242 } -test {
1243 catchsql { UPDATE t2 SET a = a_string(800), b = a_string(800) }
1244 catch { close $::channel }
1245 catchsql { ROLLBACK }
1246 faultsim_integrity_check
1247 }
1250 #-------------------------------------------------------------------------
1251 #
1252 do_test pagerfault-28-pre {
1253 faultsim_delete_and_reopen
1254 db func a_string a_string
1255 execsql {
1256 PRAGMA page_size = 512;
1258 PRAGMA journal_mode = wal;
1259 PRAGMA wal_autocheckpoint = 0;
1260 PRAGMA cache_size = 100000;
1262 BEGIN;
1263 CREATE TABLE t2(a UNIQUE, b UNIQUE);
1264 INSERT INTO t2 VALUES( a_string(800), a_string(800) );
1265 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1266 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1267 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1268 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1269 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1270 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1271 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1272 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1273 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1274 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1275 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1276 COMMIT;
1277 CREATE TABLE t1(a PRIMARY KEY, b);
1278 }
1279 expr {[file size test.db-shm] >= 96*1024}
1280 } {1}
1281 faultsim_save_and_close
1283 do_faultsim_test pagerfault-28a -faults oom* -prep {
1284 faultsim_restore_and_reopen
1285 execsql { PRAGMA mmap_size=0 }
1287 sqlite3 db2 test.db
1288 db2 eval { SELECT count(*) FROM t2 }
1290 db func a_string a_string
1291 execsql {
1292 BEGIN;
1293 INSERT INTO t1 VALUES(a_string(2000), a_string(2000));
1294 INSERT INTO t1 VALUES(a_string(2000), a_string(2000));
1295 }
1296 set ::STMT [sqlite3_prepare db "SELECT * FROM t1 ORDER BY a" -1 DUMMY]
1297 sqlite3_step $::STMT
1298 } -body {
1299 execsql { ROLLBACK }
1300 } -test {
1301 db2 close
1302 sqlite3_finalize $::STMT
1303 catchsql { ROLLBACK }
1304 faultsim_integrity_check
1305 }
1307 faultsim_restore_and_reopen
1308 sqlite3 db2 test.db
1309 db2 eval {SELECT count(*) FROM t2}
1310 db close
1312 do_faultsim_test pagerfault-28b -faults oom* -prep {
1313 sqlite3 db test.db
1314 } -body {
1315 execsql { SELECT count(*) FROM t2 }
1316 } -test {
1317 faultsim_test_result {0 2048}
1318 db close
1319 }
1321 db2 close
1323 #-------------------------------------------------------------------------
1324 # Try this:
1325 #
1326 # 1) Put the pager in ERROR state (error during rollback)
1327 #
1328 # 2) Next time the connection is used inject errors into all xWrite() and
1329 # xUnlock() calls. This causes the hot-journal rollback to fail and
1330 # the pager to declare its locking state UNKNOWN.
1331 #
1332 # 3) Same again.
1333 #
1334 # 4a) Stop injecting errors. Allow the rollback to succeed. Check that
1335 # the database is Ok. Or,
1336 #
1337 # 4b) Close and reopen the db. Check that the db is Ok.
1338 #
1339 proc custom_injectinstall {} {
1340 testvfs custom -default true
1341 custom filter {xWrite xUnlock}
1342 }
1343 proc custom_injectuninstall {} {
1344 catch {db close}
1345 catch {db2 close}
1346 custom delete
1347 }
1348 proc custom_injectstart {iFail} {
1349 custom ioerr $iFail 1
1350 }
1351 proc custom_injectstop {} {
1352 custom ioerr
1353 }
1354 set ::FAULTSIM(custom) [list \
1355 -injectinstall custom_injectinstall \
1356 -injectstart custom_injectstart \
1357 -injectstop custom_injectstop \
1358 -injecterrlist {{1 {disk I/O error}}} \
1359 -injectuninstall custom_injectuninstall \
1360 ]
1362 do_test pagerfault-29-pre {
1363 faultsim_delete_and_reopen
1364 db func a_string a_string
1365 execsql {
1366 PRAGMA page_size = 1024;
1367 PRAGMA cache_size = 5;
1369 BEGIN;
1370 CREATE TABLE t2(a UNIQUE, b UNIQUE);
1371 INSERT INTO t2 VALUES( a_string(800), a_string(800) );
1372 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1373 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1374 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1375 INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
1376 COMMIT;
1377 }
1378 expr {[file size test.db] >= 50*1024}
1379 } {1}
1380 faultsim_save_and_close
1381 foreach {tn tt} {
1382 29 { catchsql ROLLBACK }
1383 30 { db close ; sqlite3 db test.db }
1384 } {
1385 do_faultsim_test pagerfault-$tn -faults custom -prep {
1386 faultsim_restore_and_reopen
1387 db func a_string a_string
1388 execsql {
1389 PRAGMA cache_size = 5;
1390 BEGIN;
1391 UPDATE t2 SET a = a_string(799);
1392 }
1393 } -body {
1394 catchsql ROLLBACK
1395 catchsql ROLLBACK
1396 catchsql ROLLBACK
1397 } -test {
1398 eval $::tt
1399 if {"ok" != [db one {PRAGMA integrity_check}]} {
1400 error "integrity check failed"
1401 }
1402 }
1403 }
1405 do_test pagerfault-31-pre {
1406 sqlite3_shutdown
1407 sqlite3_config_uri 1
1408 } {SQLITE_OK}
1409 do_faultsim_test pagerfault-31 -faults oom* -body {
1410 sqlite3 db {file:one?mode=memory&cache=shared}
1411 db eval {
1412 CREATE TABLE t1(x);
1413 INSERT INTO t1 VALUES(1);
1414 SELECT * FROM t1;
1415 }
1416 } -test {
1417 faultsim_test_result {0 1} {1 {}}
1418 catch { db close }
1419 }
1420 sqlite3_shutdown
1421 sqlite3_config_uri 0
1423 do_test pagerfault-32-pre {
1424 reset_db
1425 execsql {
1426 CREATE TABLE t1(x);
1427 INSERT INTO t1 VALUES('one');
1428 }
1429 } {}
1430 faultsim_save_and_close
1432 do_faultsim_test pagerfault-32 -prep {
1433 faultsim_restore_and_reopen
1434 db eval { SELECT * FROM t1; }
1435 } -body {
1436 execsql { SELECT * FROM t1; }
1437 } -test {
1438 faultsim_test_result {0 one}
1439 }
1440 sqlite3_shutdown
1441 sqlite3_config_uri 0
1443 do_faultsim_test pagerfault-33a -prep {
1444 sqlite3 db :memory:
1445 execsql {
1446 CREATE TABLE t1(a, b);
1447 INSERT INTO t1 VALUES(1, 2);
1448 }
1449 } -body {
1450 execsql { VACUUM }
1451 } -test {
1452 faultsim_test_result {0 {}}
1453 }
1454 do_faultsim_test pagerfault-33b -prep {
1455 sqlite3 db ""
1456 execsql {
1457 CREATE TABLE t1(a, b);
1458 INSERT INTO t1 VALUES(1, 2);
1459 }
1460 } -body {
1461 execsql { VACUUM }
1462 } -test {
1463 faultsim_test_result {0 {}}
1464 }
1466 do_test pagerfault-34-pre {
1467 reset_db
1468 execsql {
1469 CREATE TABLE t1(x PRIMARY KEY);
1470 }
1471 } {}
1472 faultsim_save_and_close
1473 do_faultsim_test pagerfault-34 -prep {
1474 faultsim_restore_and_reopen
1475 execsql {
1476 BEGIN;
1477 INSERT INTO t1 VALUES( randomblob(4000) );
1478 DELETE FROM t1;
1479 }
1480 } -body {
1481 execsql COMMIT
1482 } -test {
1483 faultsim_test_result {0 {}}
1484 }
1486 do_test pagerfault-35-pre {
1487 faultsim_delete_and_reopen
1488 execsql {
1489 CREATE TABLE t1(x PRIMARY KEY, y);
1490 INSERT INTO t1 VALUES(randomblob(200), randomblob(200));
1491 INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
1492 INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
1493 INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
1494 }
1495 faultsim_save_and_close
1496 } {}
1497 testvfs tv -default 1
1498 tv sectorsize 8192;
1499 tv devchar [list]
1500 do_faultsim_test pagerfault-35 -prep {
1501 faultsim_restore_and_reopen
1502 } -body {
1503 execsql { UPDATE t1 SET x=randomblob(200) }
1504 } -test {
1505 faultsim_test_result {0 {}}
1506 }
1507 catch {db close}
1508 tv delete
1510 sqlite3_shutdown
1511 sqlite3_config_uri 1
1512 do_test pagerfault-36-pre {
1513 faultsim_delete_and_reopen
1514 execsql {
1515 CREATE TABLE t1(x PRIMARY KEY, y);
1516 INSERT INTO t1 VALUES(randomblob(200), randomblob(200));
1517 INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
1518 INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
1519 INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
1520 }
1521 faultsim_save_and_close
1522 } {}
1523 do_faultsim_test pagerfault-36 -prep {
1524 faultsim_restore
1525 sqlite3 db file:test.db?cache=shared
1526 sqlite3 db2 file:test.db?cache=shared
1527 db2 eval {
1528 BEGIN;
1529 SELECT count(*) FROM sqlite_master;
1530 }
1531 db eval {
1532 PRAGMA cache_size = 1;
1533 BEGIN;
1534 UPDATE t1 SET x = randomblob(200);
1535 }
1536 } -body {
1537 execsql ROLLBACK db
1538 } -test {
1539 catch { db eval {UPDATE t1 SET x = randomblob(200)} }
1540 faultsim_test_result {0 {}}
1541 catch { db close }
1542 catch { db2 close }
1543 }
1545 sqlite3_shutdown
1546 sqlite3_config_uri 0
1547 sqlite3_initialize
1549 finish_test