Debian Codegraph @

test/walvfs.test

raw
1 # 2018 December 23
2 #
3 # The author disclaims copyright to this source code. In place of
4 # a legal notice, here is a blessing:
5 #
6 # May you do good and not evil.
7 # May you find forgiveness for yourself and forgive others.
8 # May you share freely, never taking more than you give.
9 #
10 #***********************************************************************
11 # This file implements regression tests for SQLite library. The
12 # focus of this file is testing the operation of the library in
13 # "PRAGMA journal_mode=WAL" mode.
14 #
15 # TESTRUNNER: slow
16
17 set testdir [file dirname $argv0]
18 source $testdir/tester.tcl
19 source $testdir/lock_common.tcl
20 source $testdir/malloc_common.tcl
21 source $testdir/wal_common.tcl
22 set testprefix walvfs
23
24 ifcapable !wal {finish_test ; return }
25
26 db close
27 testvfs tvfs
28 tvfs script xSync
29 tvfs filter xSync
30 set ::sync_count 0
31 proc xSync {method file args} {
32 if {[file tail $file]=="test.db-wal"} {
33 incr ::sync_count
34 }
35 }
36
37
38 #-------------------------------------------------------------------------
39 # Test that if IOCAP_SEQUENTIAL is set, the wal-header is not synced to
40 # disk immediately after it is written.
41 #
42 sqlite3 db test.db -vfs tvfs
43 do_execsql_test 1.0 {
44 PRAGMA auto_vacuum = 0;
45 PRAGMA journal_mode = wal;
46 PRAGMA synchronous = normal;
47 CREATE TABLE t1(a, b, c);
48 INSERT INTO t1 VALUES(1, 2, 3);
49 INSERT INTO t1 VALUES(4, 5, 6);
50 INSERT INTO t1 VALUES(7, 8, 9);
51 PRAGMA wal_checkpoint;
52 } {wal 0 5 5}
53
54 set ::sync_count 0
55 do_test 1.1 {
56 execsql { INSERT INTO t1 VALUES(10, 11, 12) }
57 set ::sync_count
58 } 1
59
60 db close
61 tvfs devchar sequential
62 sqlite3 db test.db -vfs tvfs
63 do_execsql_test 1.2 {
64 PRAGMA synchronous = normal;
65 INSERT INTO t1 VALUES(13, 14, 15);
66 INSERT INTO t1 VALUES(16, 17, 18);
67 PRAGMA wal_checkpoint;
68 } {0 4 4}
69
70 set ::sync_count 0
71 do_test 1.3 {
72 execsql { INSERT INTO t1 VALUES(10, 11, 12) }
73 set ::sync_count
74 } 0
75
76 #-------------------------------------------------------------------------
77 # Test that "PRAGMA journal_size_limit" works in wal mode.
78 #
79 reset_db
80 do_execsql_test 2.0 {
81 PRAGMA journal_size_limit = 10000;
82 CREATE TABLE t1(x);
83 PRAGMA journal_mode = wal;
84 WITH s(i) AS (
85 SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20
86 )
87 INSERT INTO t1 SELECT randomblob(750) FROM s;
88 } {10000 wal}
89 do_test 2.1 {
90 expr [file size test.db-wal]>12000
91 } {1}
92 do_test 2.2 {
93 execsql {
94 PRAGMA wal_checkpoint;
95 INSERT INTO t1 VALUES(randomblob(750));
96 }
97 file size test.db-wal
98 } {10000}
99 do_test 2.3 {
100 execsql {
101 PRAGMA journal_size_limit = 8000;
102 PRAGMA wal_checkpoint;
103 INSERT INTO t1 VALUES(randomblob(750));
104 }
105 file size test.db-wal
106 } {8000}
107
108 #-------------------------------------------------------------------------
109 # Test that a checkpoint may be interrupted using sqlite3_interrupt().
110 # And that the error code is SQLITE_NOMEM, not SQLITE_INTERRUPT, if
111 # an OOM error occurs just before the sqlite3_interrupt() call.
112 #
113 reset_db
114 db close
115 sqlite3 db test.db -vfs tvfs
116 tvfs filter {}
117
118 do_execsql_test 3.0 {
119 CREATE TABLE t1(x);
120 PRAGMA journal_mode = wal;
121 WITH s(i) AS (
122 SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20
123 )
124 INSERT INTO t1 SELECT randomblob(750) FROM s;
125 } {wal}
126
127 tvfs filter xWrite
128 tvfs script xWrite
129 set ::cnt 2
130 proc xWrite {method file args} {
131 if {[file tail $file]=="test.db"} {
132 incr ::cnt -1
133 if {$::cnt==0} {
134 sqlite3_interrupt db
135 }
136 }
137 return SQLITE_OK
138 }
139
140 do_catchsql_test 3.1 {
141 PRAGMA wal_checkpoint
142 } {1 interrupted}
143
144 set ::cnt 2
145 proc xWrite {method file args} {
146 if {[file tail $file]=="test.db"} {
147 incr ::cnt -1
148 if {$::cnt==0} {
149 sqlite3_memdebug_fail 1 -repeat 0
150 # For this test to pass, the following statement must call malloc() at
151 # least once. Even if the lookaside is enabled.
152 set ::xwrite_stmt_res [catchsql { SELECT hex(randomblob(4000)) }]
153 sqlite3_interrupt db
154 }
155 }
156 return SQLITE_OK
157 }
158
159 set ::xwrite_stmt_res ""
160 do_catchsql_test 3.2 {
161 PRAGMA wal_checkpoint
162 } {1 {out of memory}}
163 do_test 3.2.2 {
164 set ::xwrite_stmt_res
165 } {1 {out of memory}}
166 unset ::xwrite_stmt_res
167
168 #-------------------------------------------------------------------------
169 #
170 reset_db
171 db close
172 do_test 4.0 {
173 sqlite3 db test.db -vfs tvfs
174 execsql {
175 CREATE TABLE t1(x);
176 PRAGMA journal_mode = wal;
177 WITH s(i) AS (
178 SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20
179 )
180 INSERT INTO t1 SELECT randomblob(750) FROM s;
181 } db
182 } {wal}
183 db close
184
185 tvfs filter xShmMap
186 tvfs script xShmMap
187 proc xShmMap {method file args} {
188 return SQLITE_READONLY
189 }
190 sqlite3 db test.db -vfs tvfs
191 do_catchsql_test 4.1 {
192 SELECT count(*) FROM t1
193 } {1 {attempt to write a readonly database}}
194
195 set ::cnt 5
196 tvfs filter {xShmMap xShmLock}
197 proc xShmMap {method file name args} {
198 switch -- $method {
199 xShmMap { return SQLITE_READONLY }
200 xShmLock {
201 if {$args == "{0 1 lock shared}"} {
202 incr ::cnt -1
203 if {$::cnt>0} { return SQLITE_BUSY }
204 }
205 }
206 }
207 return SQLITE_OK
208 }
209 do_catchsql_test 4.2 {
210 SELECT count(*) FROM t1
211 } {1 {attempt to write a readonly database}}
212
213 #-------------------------------------------------------------------------
214 #
215 reset_db
216 db close
217 sqlite3 db test.db -vfs tvfs
218 tvfs filter {}
219 do_execsql_test 5.0 {
220 PRAGMA auto_vacuum = 0;
221 PRAGMA page_size = 1024;
222 CREATE TABLE t1(x);
223 PRAGMA journal_mode = wal;
224 WITH s(i) AS (
225 SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20
226 )
227 INSERT INTO t1 SELECT randomblob(750) FROM s;
228 } {wal}
229
230 do_execsql_test 5.1 {
231 SELECT count(*) FROM t1
232 } {20}
233
234 do_test 5.2 {
235 vfs_set_readmark db main 1 100
236 vfs_set_readmark db main 2 100
237 vfs_set_readmark db main 3 100
238 vfs_set_readmark db main 4 100
239 } {100}
240
241 do_execsql_test 5.3 {
242 SELECT count(*) FROM t1
243 } {20}
244
245 do_test 5.3 {
246 list [vfs_set_readmark db main 1] \
247 [vfs_set_readmark db main 2] \
248 [vfs_set_readmark db main 3] \
249 [vfs_set_readmark db main 4]
250 } {24 100 100 100}
251
252 tvfs script xShmLock
253 tvfs filter xShmLock
254 set ::cnt 20
255 proc xShmLock {args} {
256 incr ::cnt -1
257 if {$::cnt>0} { return SQLITE_BUSY }
258 return SQLITE_OK
259 }
260
261 do_test 5.4 {
262 vfs_set_readmark db main 1 100
263 execsql { SELECT count(*) FROM t1 }
264 } {20}
265
266 vfs_set_readmark db main 1 100
267 vfs_set_readmark db main 2 100
268 vfs_set_readmark db main 3 100
269 vfs_set_readmark db main 4 100
270
271 tvfs script xShmMapLock
272 tvfs filter {xShmLock xShmMap}
273 proc xShmMapLock {method args} {
274 if {$method=="xShmMap"} {
275 return "SQLITE_READONLY"
276 }
277 return SQLITE_BUSY
278 }
279
280 sqlite3 db2 test.db -vfs tvfs
281 breakpoint
282 do_test 5.5 {
283 list [catch { execsql { SELECT count(*) FROM t1 } db2 } msg] $msg
284 } {1 {attempt to write a readonly database}}
285
286 tvfs filter {}
287 vfs_set_readmark db main 1 1
288
289 do_test 5.6 {
290 list [catch { execsql { SELECT count(*) FROM t1 } db2 } msg] $msg
291 } {0 20}
292 db2 close
293 db close
294
295 #-------------------------------------------------------------------------
296 # Cause an SQLITE_PROTOCOL while attempting to restart the wal file.
297 #
298 reset_db
299 tvfs filter {}
300 db close
301 sqlite3 db test.db -vfs tvfs
302 do_execsql_test 6.0 {
303 PRAGMA auto_vacuum = 0;
304 PRAGMA page_size = 1024;
305 CREATE TABLE t1(x);
306 PRAGMA journal_mode = wal;
307 WITH s(i) AS (
308 SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20
309 )
310 INSERT INTO t1 SELECT randomblob(750) FROM s;
311 } {wal}
312
313 do_test 6.1 {
314 execsql { PRAGMA wal_checkpoint }
315 set {} {}
316 } {}
317
318 tvfs filter xShmLock
319 tvfs script xShmLock
320 set ::flag 0
321 proc xShmLock {method file handle spec} {
322 if {$::flag && [lrange $spec 2 end]=="lock shared"} {
323 return SQLITE_BUSY
324 }
325 if {$spec=="3 1 unlock shared"} {
326 set ::flag 1
327 }
328 return SQLITE_OK
329 }
330
331 puts "# WARNING: This next test takes around 12 seconds"
332 do_catchsql_test 6.2 {
333 INSERT INTO t1 VALUES(1);
334 } {1 {locking protocol}}
335
336 #-------------------------------------------------------------------------
337 # Check that a checkpoint fails if it cannot get the CHECKPOINTER lock
338 #
339 reset_db
340 tvfs filter {}
341 db close
342 sqlite3 db test.db -vfs tvfs
343 do_execsql_test 7.0 {
344 PRAGMA auto_vacuum = 0;
345 PRAGMA page_size = 1024;
346 CREATE TABLE t1(x);
347 PRAGMA journal_mode = wal;
348 WITH s(i) AS (
349 SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20
350 )
351 INSERT INTO t1 SELECT randomblob(750) FROM s;
352 } {wal}
353
354 tvfs script xShmLock
355 tvfs filter xShmLock
356 proc xShmLock {method file handle spec} {
357 if {$spec=="1 1 lock exclusive"} {
358 return SQLITE_BUSY
359 }
360 return SQLITE_OK
361 }
362
363 do_execsql_test 7.1 {
364 PRAGMA wal_checkpoint
365 } {1 -1 -1}
366
367 #-------------------------------------------------------------------------
368 # Check that the page cache is correctly flushed if a checkpointer using
369 # a version 2 VFS makes a checkpoint with an out-of-date cache.
370 #
371 reset_db
372 testvfs tvfs2 -iversion 2
373 db close
374 sqlite3 db test.db -vfs tvfs2
375 do_execsql_test 8.0 {
376 PRAGMA auto_vacuum = 0;
377 PRAGMA page_size = 1024;
378 CREATE TABLE t1(x);
379 PRAGMA journal_mode = wal;
380 WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20 )
381 INSERT INTO t1 SELECT randomblob(75) FROM s;
382 } {wal}
383
384 do_execsql_test 8.1 { SELECT count(*) FROM t1 } {20}
385
386 do_test 8.2 {
387 sqlite3 db2 test.db -vfs tvfs2
388 execsql {
389 INSERT INTO t1 VALUES(randomblob(75));
390 } db2
391 db2 close
392 } {}
393
394 do_execsql_test 8.3 {
395 PRAGMA wal_checkpoint;
396 SELECT count(*) FROM t1
397 } {0 5 5 21}
398 db close
399 tvfs2 delete
400
401 #-------------------------------------------------------------------------
402 reset_db
403 db close
404 sqlite3 db test.db -vfs tvfs
405 do_execsql_test 9.0 {
406 PRAGMA auto_vacuum = 0;
407 PRAGMA page_size = 1024;
408 CREATE TABLE t1(x);
409 PRAGMA journal_mode = wal;
410 WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 20 )
411 INSERT INTO t1 SELECT randomblob(75) FROM s;
412 } {wal}
413
414 sqlite3 db2 test.db -vfs tvfs
415 tvfs filter {xShmMap xShmLock}
416 tvfs script xShmMap
417 proc xShmMap {method file handle args} {
418 switch -- $method {
419 xShmMap {
420 return "SQLITE_READONLY_CANTINIT"
421 }
422 xShmLock {
423 if {$args=="{3 1 lock shared}"} {
424 return "SQLITE_IOERR"
425 }
426 }
427 }
428 }
429
430 do_test 9.1 {
431 catchsql { SELECT count(*) FROM t1 } db2
432 } {1 {disk I/O error}}
433
434 db close
435 db2 close
436 tvfs delete
437 finish_test