Debian Codegraph @

test/walro2.test

raw
1 # 2011 May 09
2 #
3 # The author disclaims copyright to this source code. In place of
4 # a legal notice, here is a blessing:
5 #
6 # May you do good and not evil.
7 # May you find forgiveness for yourself and forgive others.
8 # May you share freely, never taking more than you give.
9 #
10 #***********************************************************************
11 #
12 # This file contains tests for using WAL databases in read-only mode.
13 #
14
15 set testdir [file dirname $argv0]
16 source $testdir/tester.tcl
17 source $testdir/lock_common.tcl
18 source $testdir/wal_common.tcl
19 set ::testprefix walro2
20
21 # And only if the build is WAL-capable.
22 #
23 ifcapable !wal {
24 finish_test
25 return
26 }
27
28 proc copy_to_test2 {bZeroShm} {
29 forcecopy test.db test.db2
30 forcecopy test.db-wal test.db2-wal
31 if {$bZeroShm} {
32 forcedelete test.db2-shm
33 set fd [open test.db2-shm w]
34 seek $fd [expr [file size test.db-shm]-1]
35 puts -nonewline $fd "\0"
36 close $fd
37 } else {
38 forcecopy test.db-shm test.db2-shm
39 }
40 }
41
42 # Most systems allocate the *-shm file in 32KB trunks. But on UNIX systems
43 # for which the getpagesize() call returns greater than 32K, the *-shm
44 # file is allocated in page-sized units (since you cannot mmap part of
45 # a page). The following code sets variable $MINSHMSZ to the smallest
46 # possible *-shm file (i.e. the greater of 32KB and the system page-size).
47 #
48 do_execsql_test 0.0 {
49 PRAGMA journal_mode = wal;
50 CREATE TABLE t1(x);
51 } {wal}
52 set MINSHMSZ [file size test.db-shm]
53 set dfltpgsz [db one {PRAGMA page_size}]
54
55 foreach bZeroShm {0 1} {
56 for {set pgsz 512} {$pgsz<=65536} {set pgsz [expr {$pgsz*2}]} {
57 set TN [expr $bZeroShm+1]-$pgsz
58 do_multiclient_test tn {
59
60 # Close all connections and delete the database.
61 #
62 code1 { db close }
63 code2 { db2 close }
64 code3 { db3 close }
65 forcedelete test.db
66
67 # Do not run tests with the connections in the same process.
68 #
69 if {$tn==2} continue
70
71 foreach c {code1 code2 code3} {
72 $c {
73 sqlite3_shutdown
74 sqlite3_config_uri 1
75 }
76 }
77
78 do_test $TN.1.1 {
79 code2 { sqlite3 db2 test.db }
80 sql2 "PRAGMA page_size=$::pgsz"
81 sql2 {
82 CREATE TABLE t1(x, y);
83 PRAGMA journal_mode = WAL;
84 INSERT INTO t1 VALUES('a', 'b');
85 INSERT INTO t1 VALUES('c', 'd');
86 }
87 file exists test.db-shm
88 } {1}
89
90 do_test $TN.1.2.1 {
91 copy_to_test2 $bZeroShm
92 code1 {
93 sqlite3 db file:test.db2?readonly_shm=1
94 }
95
96 sql1 { SELECT * FROM t1 }
97 } {a b c d}
98 do_test $TN.1.2.2 {
99 sql1 { SELECT * FROM t1 }
100 } {a b c d}
101
102 do_test $TN.1.3.1 {
103 code3 { sqlite3 db3 test.db2 }
104 sql3 { SELECT * FROM t1 }
105 } {a b c d}
106
107 do_test $TN.1.3.2 {
108 sql1 { SELECT * FROM t1 }
109 } {a b c d}
110
111 code1 { db close }
112 code2 { db2 close }
113 code3 { db3 close }
114
115 do_test $TN.2.1 {
116 code2 { sqlite3 db2 test.db }
117 sql2 "PRAGMA page_size=$::pgsz;"
118 sql2 {
119 INSERT INTO t1 VALUES('e', 'f');
120 INSERT INTO t1 VALUES('g', 'h');
121 }
122 file exists test.db-shm
123 } {1}
124
125 do_test $TN.2.2 {
126 copy_to_test2 $bZeroShm
127 code1 {
128 sqlite3 db file:test.db2?readonly_shm=1
129 }
130 sql1 {
131 BEGIN;
132 SELECT * FROM t1;
133 }
134 } {a b c d e f g h}
135
136 do_test $TN.2.3.1 {
137 code3 { sqlite3 db3 test.db2 }
138 sql3 { SELECT * FROM t1 }
139 } {a b c d e f g h}
140 do_test $TN.2.3.2 {
141 sql3 { INSERT INTO t1 VALUES('i', 'j') }
142 code3 { db3 close }
143 sql1 { COMMIT }
144 } {}
145 do_test $TN.2.3.3 {
146 sql1 { SELECT * FROM t1 }
147 } {a b c d e f g h i j}
148
149
150 #-----------------------------------------------------------------------
151 # 3.1.*: That a readonly_shm connection can read a database file if both
152 # the *-wal and *-shm files are zero bytes in size.
153 #
154 # 3.2.*: That it flushes the cache if, between transactions on a db with a
155 # zero byte *-wal file, some other connection modifies the db, then
156 # does "PRAGMA wal_checkpoint=truncate" to truncate the wal file
157 # back to zero bytes in size.
158 #
159 # 3.3.*: That, if between transactions some other process wraps the wal
160 # file, the readonly_shm client reruns recovery.
161 #
162 catch { code1 { db close } }
163 catch { code2 { db2 close } }
164 catch { code3 { db3 close } }
165 do_test $TN.3.1.0 {
166 list [file exists test.db-wal] [file exists test.db-shm]
167 } {0 0}
168 do_test $TN.3.1.1 {
169 close [open test.db-wal w]
170 close [open test.db-shm w]
171 code1 {
172 sqlite3 db file:test.db?readonly_shm=1
173 }
174 sql1 { SELECT * FROM t1 }
175 } {a b c d e f g h}
176
177 do_test $TN.3.2.0 {
178 list [file size test.db-wal] [file size test.db-shm]
179 } {0 0}
180 do_test $TN.3.2.1 {
181 code2 { sqlite3 db2 test.db }
182 sql2 { INSERT INTO t1 VALUES(1, 2) ; PRAGMA wal_checkpoint=truncate }
183 code2 { db2 close }
184 sql1 { SELECT * FROM t1 }
185 } {a b c d e f g h 1 2}
186 if {$pgsz!=$dfltpgsz} continue
187 do_test $TN.3.2.2 {
188 list [file size test.db-wal] [file size test.db-shm]
189 } [list 0 $MINSHMSZ]
190 do_test $TN.3.3.0 {
191 code2 { sqlite3 db2 test.db }
192 sql2 {
193 INSERT INTO t1 VALUES(3, 4);
194 INSERT INTO t1 VALUES(5, 6);
195 INSERT INTO t1 VALUES(7, 8);
196 INSERT INTO t1 VALUES(9, 10);
197 }
198 code2 { db2 close }
199 code1 { db close }
200 list [file size test.db-wal] [file size test.db-shm]
201 } [list [wal_file_size 4 1024] $MINSHMSZ]
202 do_test $TN.3.3.1 {
203 code1 { sqlite3 db file:test.db?readonly_shm=1 }
204 sql1 { SELECT * FROM t1 }
205 } {a b c d e f g h 1 2 3 4 5 6 7 8 9 10}
206 do_test $TN.3.3.2 {
207 code2 { sqlite3 db2 test.db }
208 sql2 {
209 PRAGMA wal_checkpoint;
210 DELETE FROM t1;
211 INSERT INTO t1 VALUES('i', 'ii');
212 }
213 code2 { db2 close }
214 list [file size test.db-wal] [file size test.db-shm]
215 } [list [wal_file_size 4 1024] $MINSHMSZ]
216 do_test $TN.3.3.3 {
217 sql1 { SELECT * FROM t1 }
218 } {i ii}
219
220 #-----------------------------------------------------------------------
221 #
222 #
223 catch { code1 { db close } }
224 catch { code2 { db2 close } }
225 catch { code3 { db3 close } }
226
227 do_test $TN.4.0 {
228 code1 { forcedelete test.db }
229 code1 { sqlite3 db test.db }
230 sql1 {
231 PRAGMA journal_mode = wal;
232 CREATE TABLE t1(x);
233 INSERT INTO t1 VALUES('hello');
234 INSERT INTO t1 VALUES('world');
235 }
236
237 copy_to_test2 $bZeroShm
238
239 code1 { db close }
240 } {}
241
242 do_test $TN.4.1.1 {
243 code2 { sqlite3 db2 file:test.db2?readonly_shm=1 }
244 sql2 { SELECT * FROM t1 }
245 } {hello world}
246
247 do_test $TN.4.1.2 {
248 code3 { sqlite3 db3 test.db2 }
249 sql3 {
250 INSERT INTO t1 VALUES('!');
251 PRAGMA wal_checkpoint = truncate;
252 }
253 code3 { db3 close }
254 } {}
255 do_test $TN.4.1.3 {
256 sql2 { SELECT * FROM t1 }
257 } {hello world !}
258
259 catch { code1 { db close } }
260 catch { code2 { db2 close } }
261 catch { code3 { db3 close } }
262
263 do_test $TN.4.2.1 {
264 code1 { sqlite3 db test.db }
265 sql1 {
266 INSERT INTO t1 VALUES('!');
267 INSERT INTO t1 VALUES('!');
268
269 PRAGMA cache_size = 10;
270 CREATE TABLE t2(x);
271
272 BEGIN;
273 WITH s(i) AS (
274 SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<500
275 )
276 INSERT INTO t2 SELECT randomblob(500) FROM s;
277 SELECT count(*) FROM t2;
278 }
279 } {500}
280 set sz [file size test.db-wal]
281 do_test $TN.4.2.2.(sz=$sz) {
282 expr {$sz>400000}
283 } {1}
284 do_test $TN.4.2.4 {
285 file_control_persist_wal db 1; db close
286
287 copy_to_test2 $bZeroShm
288 code2 { sqlite3 db2 file:test.db2?readonly_shm=1 }
289 sql2 {
290 SELECT * FROM t1;
291 SELECT count(*) FROM t2;
292 }
293 } {hello world ! ! 0}
294
295 #-----------------------------------------------------------------------
296 #
297 #
298 catch { code1 { db close } }
299 catch { code2 { db2 close } }
300 catch { code3 { db3 close } }
301
302 do_test $TN.5.0 {
303 code1 { forcedelete test.db }
304 code1 { sqlite3 db test.db }
305 sql1 {
306 PRAGMA journal_mode = wal;
307 CREATE TABLE t1(x);
308 INSERT INTO t1 VALUES('hello');
309 INSERT INTO t1 VALUES('world');
310 INSERT INTO t1 VALUES('!');
311 INSERT INTO t1 VALUES('world');
312 INSERT INTO t1 VALUES('hello');
313 }
314
315 copy_to_test2 $bZeroShm
316
317 code1 { db close }
318 } {}
319
320 do_test $TN.5.1 {
321 code2 { sqlite3 db2 file:test.db2?readonly_shm=1 }
322 sql2 {
323 SELECT * FROM t1;
324 }
325 } {hello world ! world hello}
326
327 do_test $TN.5.2 {
328 code1 {
329 proc handle_read {op args} {
330 if {$op=="xRead" && [file tail [lindex $args 0]]=="test.db2-wal"} {
331 set ::res2 [sql2 { SELECT * FROM t1 }]
332 }
333 puts "$msg xRead $args"
334 return "SQLITE_OK"
335 }
336 testvfs tvfs -fullshm 1
337
338 sqlite3 db file:test.db2?vfs=tvfs
339 db eval { SELECT * FROM sqlite_master }
340
341 tvfs filter xRead
342 tvfs script handle_read
343 }
344 sql1 {
345 PRAGMA wal_checkpoint = truncate;
346 }
347 code1 { set ::res2 }
348 } {hello world ! world hello}
349
350 do_test $TN.5.3 {
351 code1 { db close }
352 code1 { tvfs delete }
353 } {}
354
355 #-----------------------------------------------------------------------
356 #
357 #
358 catch { code1 { db close } }
359 catch { code2 { db2 close } }
360 catch { code3 { db3 close } }
361
362 do_test $TN.6.1 {
363 code1 { forcedelete test.db }
364 code1 { sqlite3 db test.db }
365 sql1 {
366 PRAGMA journal_mode = wal;
367 CREATE TABLE t1(x);
368 INSERT INTO t1 VALUES('hello');
369 INSERT INTO t1 VALUES('world');
370 INSERT INTO t1 VALUES('!');
371 INSERT INTO t1 VALUES('world');
372 INSERT INTO t1 VALUES('hello');
373 }
374
375 copy_to_test2 $bZeroShm
376
377 code1 { db close }
378 } {}
379
380 do_test $TN.6.2 {
381 code1 {
382 set ::nRem 5
383 proc handle_read {op args} {
384 if {$op=="xRead" && [file tail [lindex $args 0]]=="test.db2-wal"} {
385 incr ::nRem -1
386 if {$::nRem==0} {
387 code2 { sqlite3 db2 test.db2 }
388 sql2 { PRAGMA wal_checkpoint = truncate }
389 }
390 }
391 return "SQLITE_OK"
392 }
393 testvfs tvfs -fullshm 1
394
395 tvfs filter xRead
396 tvfs script handle_read
397
398 sqlite3 db file:test.db2?readonly_shm=1&vfs=tvfs
399 db eval { SELECT * FROM t1 }
400 }
401 } {hello world ! world hello}
402
403 do_test $TN.6.3 {
404 code1 { db close }
405 code1 { tvfs delete }
406 } {}
407 }
408 } ;# for pgsz
409 } ;# foreach bZeroShm
410
411 finish_test