Debian Codegraph @

test/snapshot_fault.test

raw
1 # 2015 December 10
2 #
3 # The author disclaims copyright to this source code. In place of
4 # a legal notice, here is a blessing:
5 #
6 # May you do good and not evil.
7 # May you find forgiveness for yourself and forgive others.
8 # May you share freely, never taking more than you give.
9 #
10 #***********************************************************************
11 # This file implements regression tests for SQLite library. The focus
12 # of this file is the sqlite3_snapshot_xxx() APIs.
13 #
14
15 set testdir [file dirname $argv0]
16 source $testdir/tester.tcl
17 ifcapable !snapshot {finish_test; return}
18 set testprefix snapshot_fault
19
20 #-------------------------------------------------------------------------
21 # Check that an sqlite3_snapshot_open() client cannot be tricked into
22 # reading a corrupt snapshot even if a second client fails while
23 # checkpointing the db.
24 #
25 do_faultsim_test 1.0 -prep {
26 catch { db2 close }
27 faultsim_delete_and_reopen
28 sqlite3 db2 test.db
29 db2 eval {
30 CREATE TABLE t1(a, b UNIQUE, c UNIQUE);
31 INSERT INTO t1 VALUES(1, randomblob(500), randomblob(500));
32 INSERT INTO t1 VALUES(2, randomblob(500), randomblob(500));
33 PRAGMA journal_mode = wal;
34 INSERT INTO t1 VALUES(3, randomblob(500), randomblob(500));
35 BEGIN;
36 SELECT a FROM t1;
37 }
38 set ::snapshot [sqlite3_snapshot_get db2 main]
39 db2 eval COMMIT
40 db2 eval {
41 UPDATE t1 SET b=randomblob(501), c=randomblob(501) WHERE a=1;
42 INSERT INTO t1 VALUES(4, randomblob(500), randomblob(500));
43 INSERT INTO t1 VALUES(5, randomblob(500), randomblob(500));
44 INSERT INTO t1 VALUES(6, randomblob(500), randomblob(500));
45 }
46 } -body {
47 db eval { PRAGMA wal_checkpoint }
48 } -test {
49 db2 eval BEGIN
50 if {[catch { sqlite3_snapshot_open db2 main $::snapshot } msg]} {
51 if {$msg != "SQLITE_ERROR_SNAPSHOT" && $msg != "SQLITE_BUSY"} {
52 error "error is $msg"
53 }
54 } else {
55 set res [db2 eval {
56 SELECT a FROM t1;
57 PRAGMA integrity_check;
58 }]
59 if {$res != "1 2 3 ok"} { error "res is $res" }
60 }
61
62 sqlite3_snapshot_free $::snapshot
63 }
64
65 #-------------------------------------------------------------------------
66 # This test is similar to the previous one. Except, after the
67 # "PRAGMA wal_checkpoint" command fails the db is closed and reopened
68 # so as to require wal file recovery. It should not be possible to open
69 # a snapshot that is part of the body of a recovered wal file.
70 #
71 do_faultsim_test 2.0 -prep {
72 faultsim_delete_and_reopen
73 db eval {
74 CREATE TABLE t1(a, b UNIQUE, c UNIQUE);
75 INSERT INTO t1 VALUES(1, randomblob(500), randomblob(500));
76 INSERT INTO t1 VALUES(2, randomblob(500), randomblob(500));
77 PRAGMA journal_mode = wal;
78 INSERT INTO t1 VALUES(3, randomblob(500), randomblob(500));
79 BEGIN;
80 SELECT a FROM t1;
81 }
82 set ::snapshot [sqlite3_snapshot_get db main]
83 db eval COMMIT
84
85 db eval {
86 UPDATE t1 SET b=randomblob(501), c=randomblob(501) WHERE a=1;
87 INSERT INTO t1 VALUES(4, randomblob(500), randomblob(500));
88 INSERT INTO t1 VALUES(5, randomblob(500), randomblob(500));
89 INSERT INTO t1 VALUES(6, randomblob(500), randomblob(500));
90 }
91 } -body {
92 db eval { PRAGMA wal_checkpoint }
93 } -test {
94
95 db_save
96 db close
97 db_restore_and_reopen
98 db eval { SELECT * FROM t1 }
99
100 db eval BEGIN
101 if {[catch { sqlite3_snapshot_open db main $::snapshot } msg]} {
102 if {$msg != "SQLITE_ERROR_SNAPSHOT" && $msg != "SQLITE_BUSY"} {
103 error "error is $msg"
104 }
105 } else {
106 # This branch should actually never be taken. But it was useful in
107 # determining whether or not this test was actually working (by
108 # running a modified version of SQLite that allowed snapshots to be
109 # opened following a recovery).
110 error "TEST HAS FAILED"
111
112 set res [db eval {
113 SELECT a FROM t1;
114 PRAGMA integrity_check;
115 }]
116 if {$res != "1 2 3 ok"} { error "res is $res" }
117 }
118
119 sqlite3_snapshot_free $::snapshot
120 }
121
122 #-------------------------------------------------------------------------
123 # Test the handling of faults that occur within sqlite3_snapshot_open().
124 #
125 do_faultsim_test 3.0 -prep {
126 faultsim_delete_and_reopen
127 db eval {
128 CREATE TABLE t1(a, b UNIQUE, c UNIQUE);
129 INSERT INTO t1 VALUES(1, randomblob(500), randomblob(500));
130 INSERT INTO t1 VALUES(2, randomblob(500), randomblob(500));
131 PRAGMA journal_mode = wal;
132 INSERT INTO t1 VALUES(3, randomblob(500), randomblob(500));
133 BEGIN;
134 SELECT a FROM t1;
135 }
136 set ::snapshot [sqlite3_snapshot_get db main]
137 db eval COMMIT
138 db eval {
139 UPDATE t1 SET b=randomblob(501), c=randomblob(501) WHERE a=1;
140 INSERT INTO t1 VALUES(4, randomblob(500), randomblob(500));
141 INSERT INTO t1 VALUES(5, randomblob(500), randomblob(500));
142 INSERT INTO t1 VALUES(6, randomblob(500), randomblob(500));
143 BEGIN;
144 }
145 } -body {
146 if { [catch { sqlite3_snapshot_open db main $::snapshot } msg] } {
147 error $msg
148 }
149 } -test {
150 faultsim_test_result {0 {}} {1 SQLITE_IOERR} {1 SQLITE_NOMEM} \
151 {1 SQLITE_IOERR_NOMEM} {1 SQLITE_IOERR_READ}
152 if {$testrc==0} {
153 set res [db eval {
154 SELECT a FROM t1;
155 PRAGMA integrity_check;
156 }]
157 if {$res != "1 2 3 ok"} { error "res is $res" }
158 }
159
160 sqlite3_snapshot_free $::snapshot
161 }
162
163 #-------------------------------------------------------------------------
164 # Test the handling of faults that occur within sqlite3_snapshot_recover().
165 #
166 reset_db
167 do_execsql_test 4.0 {
168 PRAGMA journal_mode = wal;
169 CREATE TABLE t1(zzz);
170 INSERT INTO t1 VALUES('abc');
171 INSERT INTO t1 VALUES('def');
172 } {wal}
173 faultsim_save_and_close
174
175 do_test 4.0.1 {
176 faultsim_restore_and_reopen
177 db eval { SELECT * FROM sqlite_master }
178 sqlite3_snapshot_recover db main
179 } {}
180 db close
181
182 do_faultsim_test 4.0 -faults oom* -prep {
183 faultsim_restore_and_reopen
184 db eval { SELECT * FROM sqlite_master }
185 } -body {
186 sqlite3_snapshot_recover db main
187 } -test {
188 faultsim_test_result {0 {}} {1 SQLITE_NOMEM} {1 SQLITE_IOERR_NOMEM}
189 }
190
191 # The following test cases contrive to call sqlite3_snapshot_recover()
192 # before all pages of the *-shm file have been mapped. This tests an
193 # extra branch of error handling logic in snapshot_recover().
194 #
195 reset_db
196 do_execsql_test 4.1.0 {
197 PRAGMA page_size = 512;
198 PRAGMA journal_mode = wal;
199 PRAGMA wal_autocheckpoint = 0;
200 CREATE TABLE t1(zzz);
201 INSERT INTO t1 VALUES(randomblob( 500 * 9500 ));
202 PRAGMA user_version = 211;
203 } {wal 0}
204
205 do_test 4.1.1 {
206 list [file size test.db-shm] [file size test.db]
207 } {98304 512}
208
209 faultsim_save_and_close
210 do_faultsim_test 4.1 -faults shm* -prep {
211 catch { db2 close }
212 catch { db close }
213 faultsim_restore_and_reopen
214 sqlite3 db2 test.db
215 db2 eval { SELECT * FROM sqlite_master }
216 db eval BEGIN
217 sqlite3_snapshot_get_blob db main
218 db eval COMMIT
219 } -body {
220 sqlite3_snapshot_recover db main
221 } -test {
222 faultsim_test_result {0 {}} {1 SQLITE_IOERR}
223 }
224
225 #-------------------------------------------------------------------------
226 # Test the handling of faults that occur within sqlite3_snapshot_get().
227 #
228 reset_db
229 do_execsql_test 5.0 {
230 PRAGMA page_size = 512;
231 PRAGMA journal_mode = wal;
232 PRAGMA wal_autocheckpoint = 0;
233 CREATE TABLE t1(zzz);
234 INSERT INTO t1 VALUES(randomblob( 5000 ));
235 PRAGMA user_version = 211;
236 } {wal 0}
237 faultsim_save_and_close
238
239 do_faultsim_test 5 -prep {
240 faultsim_restore_and_reopen
241 execsql { SELECT count(*) FROM sqlite_master }
242 execsql BEGIN
243 } -body {
244 sqlite3_snapshot_get_blob db main
245 set {} {}
246 } -test {
247 execsql END
248 faultsim_test_result {0 {}} {1 SQLITE_IOERR} {1 SQLITE_NOMEM}
249 }
250
251
252 finish_test