Annotation of embedaddon/sqlite3/test/pagerfault.test, revision 1.1.1.1
1.1 misho 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: #
12:
13: set testdir [file dirname $argv0]
14: source $testdir/tester.tcl
15: source $testdir/lock_common.tcl
16: source $testdir/malloc_common.tcl
17:
18: if {[permutation] == "inmemory_journal"} {
19: finish_test
20: return
21: }
22:
23: if {$::tcl_platform(platform)=="windows"} {
24: finish_test
25: return
26: }
27:
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
35:
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: }
66:
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: }
111:
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
120:
121: proc xDeleteCallback {method file args} {
122: set file [file tail $file]
123: if { [string match *mj* $file] } { faultsim_save }
124: }
125:
126: faultsim_delete_and_reopen
127: db func a_string a_string
128:
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;
134:
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;
141:
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: }
150:
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: }
172:
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: }
189:
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 {}}
252:
253: catchsql { COMMIT }
254: catchsql { ROLLBACK }
255:
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: }
261:
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: } {}
275:
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: }
287:
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
299:
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: }
310:
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: #
353:
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: }
399:
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: }
436:
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);
450:
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
477:
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: }
483:
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: }
511:
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: }
558:
559:
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;
569:
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: } {}
586:
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: }
599:
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 }
614:
615: db eval { SELECT rowid FROM t1 LIMIT 2 } { db eval $sql($rowid) }
616:
617: } -test {
618: faultsim_test_result {0 {}}
619: faultsim_integrity_check
620: }
621:
622: catch { db close }
623: ss_layer delete
624:
625:
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: }
654:
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: } {}
673:
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: }
681:
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: }
704:
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: }
724:
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: }
751:
752:
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: }
777:
778:
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: }
860:
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: }
889:
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: }
909:
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: }
943:
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: }
969:
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: }
989:
990:
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: } {}
1016:
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
1035:
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
1044:
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: }
1061:
1062:
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: }
1094:
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: }
1126:
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: }
1139:
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: }
1146:
1147:
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: }
1182:
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 {}}
1200:
1201: set contents [db eval {SELECT * FROM t1}]
1202: if {$contents != "1 2"} { error "Bad database contents ($contents)" }
1203:
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: }
1212:
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: }
1248:
1249: finish_test
1250:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pagerfault.test CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test