| blob | 18e6075a4a870799821b667995b9b3f01344fb5c |
1 # 2010 April 13
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 #
16 set testdir [file dirname $argv0]
17 source $testdir/tester.tcl
18 source $testdir/lock_common.tcl
19 source $testdir/wal_common.tcl
20 source $testdir/malloc_common.tcl
21 ifcapable !wal {finish_test ; return }
23 set a_string_counter 1
24 proc a_string {n} {
25 global a_string_counter
26 incr a_string_counter
27 string range [string repeat "${a_string_counter}." $n] 1 $n
28 }
29 db func a_string a_string
31 #-------------------------------------------------------------------------
32 # When a rollback or savepoint rollback occurs, the client may remove
33 # elements from one of the hash tables in the wal-index. This block
34 # of test cases tests that nothing appears to go wrong when this is
35 # done.
36 #
37 do_test wal3-1.0 {
38 execsql {
39 PRAGMA cache_size = 2000;
40 PRAGMA page_size = 1024;
41 PRAGMA auto_vacuum = off;
42 PRAGMA synchronous = normal;
43 PRAGMA journal_mode = WAL;
44 PRAGMA wal_autocheckpoint = 0;
45 BEGIN;
46 CREATE TABLE t1(x);
47 INSERT INTO t1 VALUES( a_string(800) ); /* 1 */
48 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2 */
49 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 4 */
50 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 8 */
51 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 16 */
52 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 32 */
53 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 64 */
54 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 128*/
55 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 256 */
56 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 512 */
57 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 1024 */
58 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2048 */
59 INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 1970; /* 4018 */
60 COMMIT;
61 PRAGMA cache_size = 10;
62 }
63 wal_frame_count test.db-wal 1024
64 } 4056
66 for {set i 1} {$i < 50} {incr i} {
68 do_test wal3-1.$i.1 {
69 set str [a_string 800]
70 execsql { UPDATE t1 SET x = $str WHERE rowid = $i }
71 lappend L [wal_frame_count test.db-wal 1024]
72 execsql {
73 BEGIN;
74 INSERT INTO t1 SELECT a_string(800) FROM t1 LIMIT 100;
75 ROLLBACK;
76 PRAGMA integrity_check;
77 }
78 } {ok}
80 # Check that everything looks OK from the point of view of an
81 # external connection.
82 #
83 sqlite3 db2 test.db
84 do_test wal3-1.$i.2 {
85 execsql { SELECT count(*) FROM t1 } db2
86 } 4018
87 do_test wal3-1.$i.3 {
88 execsql { SELECT x FROM t1 WHERE rowid = $i }
89 } $str
90 do_test wal3-1.$i.4 {
91 execsql { PRAGMA integrity_check } db2
92 } {ok}
93 db2 close
95 # Check that the file-system in its current state can be recovered.
96 #
97 forcecopy test.db test2.db
98 forcecopy test.db-wal test2.db-wal
99 forcedelete test2.db-journal
100 sqlite3 db2 test2.db
101 do_test wal3-1.$i.5 {
102 execsql { SELECT count(*) FROM t1 } db2
103 } 4018
104 do_test wal3-1.$i.6 {
105 execsql { SELECT x FROM t1 WHERE rowid = $i }
106 } $str
107 do_test wal3-1.$i.7 {
108 execsql { PRAGMA integrity_check } db2
109 } {ok}
110 db2 close
111 }
113 proc byte_is_zero {file offset} {
114 if {[file size test.db] <= $offset} { return 1 }
115 expr { [hexio_read $file $offset 1] == "00" }
116 }
118 do_multiclient_test i {
120 set testname(1) multiproc
121 set testname(2) singleproc
122 set tn $testname($i)
124 do_test wal3-2.$tn.1 {
125 sql1 {
126 PRAGMA page_size = 1024;
127 PRAGMA journal_mode = WAL;
128 }
129 sql1 {
130 CREATE TABLE t1(a, b);
131 INSERT INTO t1 VALUES(1, 'one');
132 BEGIN;
133 SELECT * FROM t1;
134 }
135 } {1 one}
136 do_test wal3-2.$tn.2 {
137 sql2 {
138 CREATE TABLE t2(a, b);
139 INSERT INTO t2 VALUES(2, 'two');
140 BEGIN;
141 SELECT * FROM t2;
142 }
143 } {2 two}
144 do_test wal3-2.$tn.3 {
145 sql3 {
146 CREATE TABLE t3(a, b);
147 INSERT INTO t3 VALUES(3, 'three');
148 BEGIN;
149 SELECT * FROM t3;
150 }
151 } {3 three}
153 # Try to checkpoint the database using [db]. It should be possible to
154 # checkpoint everything except the table added by [db3] (checkpointing
155 # these frames would clobber the snapshot currently being used by [db2]).
156 #
157 # After [db2] has committed, a checkpoint can copy the entire log to the
158 # database file. Checkpointing after [db3] has committed is therefore a
159 # no-op, as the entire log has already been backfilled.
160 #
161 do_test wal3-2.$tn.4 {
162 sql1 {
163 COMMIT;
164 PRAGMA wal_checkpoint;
165 }
166 byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]
167 } {1}
168 do_test wal3-2.$tn.5 {
169 sql2 {
170 COMMIT;
171 PRAGMA wal_checkpoint;
172 }
173 list [byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]] \
174 [byte_is_zero test.db [expr $AUTOVACUUM ? 5*1024 : 4*1024]]
175 } {0 1}
176 do_test wal3-2.$tn.6 {
177 sql3 {
178 COMMIT;
179 PRAGMA wal_checkpoint;
180 }
181 list [byte_is_zero test.db [expr $AUTOVACUUM ? 4*1024 : 3*1024]] \
182 [byte_is_zero test.db [expr $AUTOVACUUM ? 5*1024 : 4*1024]]
183 } {0 1}
184 }
185 catch {db close}
187 #-------------------------------------------------------------------------
188 # Test that that for the simple test:
189 #
190 # CREATE TABLE x(y);
191 # INSERT INTO x VALUES('z');
192 # PRAGMA wal_checkpoint;
193 #
194 # in WAL mode the xSync method is invoked as expected for each of
195 # synchronous=off, synchronous=normal and synchronous=full.
196 #
197 foreach {tn syncmode synccount} {
198 1 off
199 {}
200 2 normal
201 {test.db-wal normal test.db normal}
202 3 full
203 {test.db-wal normal test.db-wal normal test.db-wal normal test.db normal}
204 } {
206 proc sync_counter {args} {
207 foreach {method filename id flags} $args break
208 lappend ::syncs [file tail $filename] $flags
209 }
210 do_test wal3-3.$tn {
211 forcedelete test.db test.db-wal test.db-journal
213 testvfs T
214 T filter {}
215 T script sync_counter
216 sqlite3 db test.db -vfs T
218 execsql "PRAGMA synchronous = $syncmode"
219 execsql { PRAGMA journal_mode = WAL }
220 execsql { CREATE TABLE filler(a,b,c); }
222 set ::syncs [list]
223 T filter xSync
224 execsql {
225 CREATE TABLE x(y);
226 INSERT INTO x VALUES('z');
227 PRAGMA wal_checkpoint;
228 }
229 T filter {}
230 set ::syncs
231 } $synccount
233 db close
234 T delete
235 }
237 #-------------------------------------------------------------------------
238 # When recovering the contents of a WAL file, a process obtains the WRITER
239 # lock, then locks all other bytes before commencing recovery. If it fails
240 # to lock all other bytes (because some other process is holding a read
241 # lock) it should retry up to 100 times. Then return SQLITE_PROTOCOL to the
242 # caller. Test this (test case wal3-4.3).
243 #
244 # Also test the effect of hitting an SQLITE_BUSY while attempting to obtain
245 # the WRITER lock (should be the same). Test case wal3-4.4.
246 #
247 proc lock_callback {method filename handle lock} {
248 lappend ::locks $lock
249 }
250 do_test wal3-4.1 {
251 testvfs T
252 T filter xShmLock
253 T script lock_callback
254 set ::locks [list]
255 sqlite3 db test.db -vfs T
256 execsql { SELECT * FROM x }
257 lrange $::locks 0 3
258 } [list {0 1 lock exclusive} {1 7 lock exclusive} \
259 {1 7 unlock exclusive} {0 1 unlock exclusive} \
260 ]
261 do_test wal3-4.2 {
262 db close
263 set ::locks [list]
264 sqlite3 db test.db -vfs T
265 execsql { SELECT * FROM x }
266 lrange $::locks 0 3
267 } [list {0 1 lock exclusive} {1 7 lock exclusive} \
268 {1 7 unlock exclusive} {0 1 unlock exclusive} \
269 ]
270 proc lock_callback {method filename handle lock} {
271 if {$lock == "1 7 lock exclusive"} { return SQLITE_BUSY }
272 return SQLITE_OK
273 }
274 puts " Warning: This next test case causes SQLite to call xSleep(1) 100 times."
275 puts " Normally this equates to a 100ms delay, but if SQLite is built on unix"
276 puts " without HAVE_USLEEP defined, it may be 100 seconds."
277 do_test wal3-4.3 {
278 db close
279 set ::locks [list]
280 sqlite3 db test.db -vfs T
281 catchsql { SELECT * FROM x }
282 } {1 {locking protocol}}
284 puts " Warning: Same again!"
285 proc lock_callback {method filename handle lock} {
286 if {$lock == "0 1 lock exclusive"} { return SQLITE_BUSY }
287 return SQLITE_OK
288 }
289 do_test wal3-4.4 {
290 db close
291 set ::locks [list]
292 sqlite3 db test.db -vfs T
293 catchsql { SELECT * FROM x }
294 } {1 {locking protocol}}
295 db close
296 T delete
299 #-------------------------------------------------------------------------
300 # Only one client may run recovery at a time. Test this mechanism.
301 #
302 # When client-2 tries to open a read transaction while client-1 is
303 # running recovery, it fails to obtain a lock on an aReadMark[] slot
304 # (because they are all locked by recovery). It then tries to obtain
305 # a shared lock on the RECOVER lock to see if there really is a
306 # recovery running or not.
307 #
308 # This block of tests checks the effect of an SQLITE_BUSY or SQLITE_IOERR
309 # being returned when client-2 attempts a shared lock on the RECOVER byte.
310 #
311 # An SQLITE_BUSY should be converted to an SQLITE_BUSY_RECOVERY. An
312 # SQLITE_IOERR should be returned to the caller.
313 #
314 do_test wal3-5.1 {
315 faultsim_delete_and_reopen
316 execsql {
317 PRAGMA journal_mode = WAL;
318 CREATE TABLE t1(a, b);
319 INSERT INTO t1 VALUES(1, 2);
320 INSERT INTO t1 VALUES(3, 4);
321 }
322 faultsim_save_and_close
323 } {}
325 testvfs T -default 1
326 T script method_callback
328 proc method_callback {method args} {
329 if {$method == "xShmBarrier"} {
330 incr ::barrier_count
331 if {$::barrier_count == 2} {
332 # This code is executed within the xShmBarrier() callback invoked
333 # by the client running recovery as part of writing the recovered
334 # wal-index header. If a second client attempts to access the
335 # database now, it reads a corrupt (partially written) wal-index
336 # header. But it cannot even get that far, as the first client
337 # is still holding all the locks (recovery takes an exclusive lock
338 # on *all* db locks, preventing access by any other client).
339 #
340 # If global variable ::wal3_do_lockfailure is non-zero, then set
341 # things up so that an IO error occurs within an xShmLock() callback
342 # made by the second client (aka [db2]).
343 #
344 sqlite3 db2 test.db
345 if { $::wal3_do_lockfailure } { T filter xShmLock }
346 set ::testrc [ catch { db2 eval "SELECT * FROM t1" } ::testmsg ]
347 T filter {}
348 db2 close
349 }
350 }
352 if {$method == "xShmLock"} {
353 foreach {file handle spec} $args break
354 if { $spec == "2 1 lock shared" } {
355 return SQLITE_IOERR
356 }
357 }
359 return SQLITE_OK
360 }
362 # Test a normal SQLITE_BUSY return.
363 #
364 T filter xShmBarrier
365 set testrc ""
366 set testmsg ""
367 set barrier_count 0
368 set wal3_do_lockfailure 0
369 do_test wal3-5.2 {
370 faultsim_restore_and_reopen
371 execsql { SELECT * FROM t1 }
372 } {1 2 3 4}
373 do_test wal3-5.3 {
374 list $::testrc $::testmsg
375 } {1 {database is locked}}
376 db close
378 # Test an SQLITE_IOERR return.
379 #
380 T filter xShmBarrier
381 set barrier_count 0
382 set wal3_do_lockfailure 1
383 set testrc ""
384 set testmsg ""
385 do_test wal3-5.4 {
386 faultsim_restore_and_reopen
387 execsql { SELECT * FROM t1 }
388 } {1 2 3 4}
389 do_test wal3-5.5 {
390 list $::testrc $::testmsg
391 } {1 {disk I/O error}}
393 db close
394 T delete
396 #-------------------------------------------------------------------------
397 # When opening a read-transaction on a database, if the entire log has
398 # already been copied to the database file, the reader grabs a special
399 # kind of read lock (on aReadMark[0]). This set of test cases tests the
400 # outcome of the following:
401 #
402 # + The reader discovering that between the time when it determined
403 # that the log had been completely backfilled and the lock is obtained
404 # that a writer has written to the log. In this case the reader should
405 # acquire a different read-lock (not aReadMark[0]) and read the new
406 # snapshot.
407 #
408 # + The attempt to obtain the lock on aReadMark[0] fails with SQLITE_BUSY.
409 # This can happen if a checkpoint is ongoing. In this case also simply
410 # obtain a different read-lock.
411 #
412 catch {db close}
413 testvfs T -default 1
414 do_test wal3-6.1.1 {
415 forcedelete test.db test.db-journal test.db wal
416 sqlite3 db test.db
417 execsql { PRAGMA auto_vacuum = off }
418 execsql { PRAGMA journal_mode = WAL }
419 execsql {
420 CREATE TABLE t1(a, b);
421 INSERT INTO t1 VALUES('o', 't');
422 INSERT INTO t1 VALUES('t', 'f');
423 }
424 } {}
425 do_test wal3-6.1.2 {
426 sqlite3 db2 test.db
427 sqlite3 db3 test.db
428 execsql { BEGIN ; SELECT * FROM t1 } db3
429 } {o t t f}
430 do_test wal3-6.1.3 {
431 execsql { PRAGMA wal_checkpoint } db2
432 } {0 4 4}
434 # At this point the log file has been fully checkpointed. However,
435 # connection [db3] holds a lock that prevents the log from being wrapped.
436 # Test case 3.6.1.4 has [db] attempt a read-lock on aReadMark[0]. But
437 # as it is obtaining the lock, [db2] appends to the log file.
438 #
439 T filter xShmLock
440 T script lock_callback
441 proc lock_callback {method file handle spec} {
442 if {$spec == "3 1 lock shared"} {
443 # This is the callback for [db] to obtain the read lock on aReadMark[0].
444 # Disable future callbacks using [T filter {}] and write to the log
445 # file using [db2]. [db3] is preventing [db2] from wrapping the log
446 # here, so this is an append.
447 T filter {}
448 db2 eval { INSERT INTO t1 VALUES('f', 's') }
449 }
450 return SQLITE_OK
451 }
452 do_test wal3-6.1.4 {
453 execsql {
454 BEGIN;
455 SELECT * FROM t1;
456 }
457 } {o t t f f s}
459 # [db] should be left holding a read-lock on some slot other than
460 # aReadMark[0]. Test this by demonstrating that the read-lock is preventing
461 # the log from being wrapped.
462 #
463 do_test wal3-6.1.5 {
464 db3 eval COMMIT
465 db2 eval { PRAGMA wal_checkpoint }
466 set sz1 [file size test.db-wal]
467 db2 eval { INSERT INTO t1 VALUES('s', 'e') }
468 set sz2 [file size test.db-wal]
469 expr {$sz2>$sz1}
470 } {1}
472 # Test that if [db2] had not interfered when [db] was trying to grab
473 # aReadMark[0], it would have been possible to wrap the log in 3.6.1.5.
474 #
475 do_test wal3-6.1.6 {
476 execsql { COMMIT }
477 execsql { PRAGMA wal_checkpoint } db2
478 execsql {
479 BEGIN;
480 SELECT * FROM t1;
481 }
482 } {o t t f f s s e}
483 do_test wal3-6.1.7 {
484 db2 eval { PRAGMA wal_checkpoint }
485 set sz1 [file size test.db-wal]
486 db2 eval { INSERT INTO t1 VALUES('n', 't') }
487 set sz2 [file size test.db-wal]
488 expr {$sz2==$sz1}
489 } {1}
491 db3 close
492 db2 close
493 db close
495 do_test wal3-6.2.1 {
496 forcedelete test.db test.db-journal test.db wal
497 sqlite3 db test.db
498 sqlite3 db2 test.db
499 execsql { PRAGMA auto_vacuum = off }
500 execsql { PRAGMA journal_mode = WAL }
501 execsql {
502 CREATE TABLE t1(a, b);
503 INSERT INTO t1 VALUES('h', 'h');
504 INSERT INTO t1 VALUES('l', 'b');
505 }
506 } {}
508 T filter xShmLock
509 T script lock_callback
510 proc lock_callback {method file handle spec} {
511 if {$spec == "3 1 unlock exclusive"} {
512 T filter {}
513 set ::R [db2 eval {
514 BEGIN;
515 SELECT * FROM t1;
516 }]
517 }
518 }
519 do_test wal3-6.2.2 {
520 execsql { PRAGMA wal_checkpoint }
521 } {0 4 4}
522 do_test wal3-6.2.3 {
523 set ::R
524 } {h h l b}
525 do_test wal3-6.2.4 {
526 set sz1 [file size test.db-wal]
527 execsql { INSERT INTO t1 VALUES('b', 'c'); }
528 set sz2 [file size test.db-wal]
529 expr {$sz2 > $sz1}
530 } {1}
531 do_test wal3-6.2.5 {
532 db2 eval { COMMIT }
533 execsql { PRAGMA wal_checkpoint }
534 set sz1 [file size test.db-wal]
535 execsql { INSERT INTO t1 VALUES('n', 'o'); }
536 set sz2 [file size test.db-wal]
537 expr {$sz2 == $sz1}
538 } {1}
540 db2 close
541 db close
542 T delete
544 #-------------------------------------------------------------------------
545 # When opening a read-transaction on a database, if the entire log has
546 # not yet been copied to the database file, the reader grabs a read
547 # lock on aReadMark[x], where x>0. The following test cases experiment
548 # with the outcome of the following:
549 #
550 # + The reader discovering that between the time when it read the
551 # wal-index header and the lock was obtained that a writer has
552 # written to the log. In this case the reader should re-read the
553 # wal-index header and lock a snapshot corresponding to the new
554 # header.
555 #
556 # + The value in the aReadMark[x] slot has been modified since it was
557 # read.
558 #
559 catch {db close}
560 testvfs T -default 1
561 do_test wal3-7.1.1 {
562 forcedelete test.db test.db-journal test.db wal
563 sqlite3 db test.db
564 execsql {
565 PRAGMA journal_mode = WAL;
566 CREATE TABLE blue(red PRIMARY KEY, green);
567 }
568 } {wal}
570 T script method_callback
571 T filter xOpen
572 proc method_callback {method args} {
573 if {$method == "xOpen"} { return "reader" }
574 }
575 do_test wal3-7.1.2 {
576 sqlite3 db2 test.db
577 execsql { SELECT * FROM blue } db2
578 } {}
580 T filter xShmLock
581 set ::locks [list]
582 proc method_callback {method file handle spec} {
583 if {$handle != "reader" } { return }
584 if {$method == "xShmLock"} {
585 catch { execsql { INSERT INTO blue VALUES(1, 2) } }
586 catch { execsql { INSERT INTO blue VALUES(3, 4) } }
587 }
588 lappend ::locks $spec
589 }
590 do_test wal3-7.1.3 {
591 execsql { SELECT * FROM blue } db2
592 } {1 2 3 4}
593 do_test wal3-7.1.4 {
594 set ::locks
595 } {{4 1 lock shared} {4 1 unlock shared} {5 1 lock shared} {5 1 unlock shared}}
597 set ::locks [list]
598 proc method_callback {method file handle spec} {
599 if {$handle != "reader" } { return }
600 if {$method == "xShmLock"} {
601 catch { execsql { INSERT INTO blue VALUES(5, 6) } }
602 }
603 lappend ::locks $spec
604 }
605 do_test wal3-7.2.1 {
606 execsql { SELECT * FROM blue } db2
607 } {1 2 3 4 5 6}
608 do_test wal3-7.2.2 {
609 set ::locks
610 } {{5 1 lock shared} {5 1 unlock shared} {4 1 lock shared} {4 1 unlock shared}}
612 db close
613 db2 close
614 T delete
616 #-------------------------------------------------------------------------
617 #
618 do_test wal3-8.1 {
619 forcedelete test.db test.db-journal test.db wal
620 sqlite3 db test.db
621 sqlite3 db2 test.db
622 execsql {
623 PRAGMA auto_vacuum = off;
624 PRAGMA journal_mode = WAL;
625 CREATE TABLE b(c);
626 INSERT INTO b VALUES('Tehran');
627 INSERT INTO b VALUES('Qom');
628 INSERT INTO b VALUES('Markazi');
629 PRAGMA wal_checkpoint;
630 }
631 } {wal 0 5 5}
632 do_test wal3-8.2 {
633 execsql { SELECT * FROM b }
634 } {Tehran Qom Markazi}
635 do_test wal3-8.3 {
636 db eval { SELECT * FROM b } {
637 db eval { INSERT INTO b VALUES('Qazvin') }
638 set r [db2 eval { SELECT * FROM b }]
639 break
640 }
641 set r
642 } {Tehran Qom Markazi Qazvin}
643 do_test wal3-8.4 {
644 execsql {
645 INSERT INTO b VALUES('Gilan');
646 INSERT INTO b VALUES('Ardabil');
647 }
648 } {}
649 db2 close
651 faultsim_save_and_close
652 testvfs T -default 1
653 faultsim_restore_and_reopen
654 T filter xShmLock
655 T script lock_callback
657 proc lock_callback {method file handle spec} {
658 if {$spec == "1 7 unlock exclusive"} {
659 T filter {}
660 set ::r [catchsql { SELECT * FROM b } db2]
661 }
662 }
663 sqlite3 db test.db
664 sqlite3 db2 test.db
665 do_test wal3-8.5 {
666 execsql { SELECT * FROM b }
667 } {Tehran Qom Markazi Qazvin Gilan Ardabil}
668 do_test wal3-8.6 {
669 set ::r
670 } {1 {locking protocol}}
672 db close
673 db2 close
675 faultsim_restore_and_reopen
676 sqlite3 db2 test.db
677 T filter xShmLock
678 T script lock_callback
679 proc lock_callback {method file handle spec} {
680 if {$spec == "1 7 unlock exclusive"} {
681 T filter {}
682 set ::r [catchsql { SELECT * FROM b } db2]
683 }
684 }
685 unset ::r
686 do_test wal3-8.5 {
687 execsql { SELECT * FROM b }
688 } {Tehran Qom Markazi Qazvin Gilan Ardabil}
689 do_test wal3-8.6 {
690 set ::r
691 } {1 {locking protocol}}
693 db close
694 db2 close
695 T delete
697 #-------------------------------------------------------------------------
698 # When a connection opens a read-lock on the database, it searches for
699 # an aReadMark[] slot that is already set to the mxFrame value for the
700 # new transaction. If it cannot find one, it attempts to obtain an
701 # exclusive lock on an aReadMark[] slot for the purposes of modifying
702 # the value, then drops back to a shared-lock for the duration of the
703 # transaction.
704 #
705 # This test case verifies that if an exclusive lock cannot be obtained
706 # on any aReadMark[] slot (because there are already several readers),
707 # the client takes a shared-lock on a slot without modifying the value
708 # and continues.
709 #
710 set nConn 50
711 if { [string match *BSD $tcl_platform(os)] } { set nConn 25 }
712 do_test wal3-9.0 {
713 forcedelete test.db test.db-journal test.db wal
714 sqlite3 db test.db
715 execsql {
716 PRAGMA page_size = 1024;
717 PRAGMA journal_mode = WAL;
718 CREATE TABLE whoami(x);
719 INSERT INTO whoami VALUES('nobody');
720 }
721 } {wal}
722 for {set i 0} {$i < $nConn} {incr i} {
723 set c db$i
724 do_test wal3-9.1.$i {
725 sqlite3 $c test.db
726 execsql { UPDATE whoami SET x = $c }
727 execsql {
728 BEGIN;
729 SELECT * FROM whoami
730 } $c
731 } $c
732 }
733 for {set i 0} {$i < $nConn} {incr i} {
734 set c db$i
735 do_test wal3-9.2.$i {
736 execsql { SELECT * FROM whoami } $c
737 } $c
738 }
740 set sz [expr 1024 * (2+$AUTOVACUUM)]
741 do_test wal3-9.3 {
742 for {set i 0} {$i < ($nConn-1)} {incr i} { db$i close }
743 execsql { PRAGMA wal_checkpoint }
744 byte_is_zero test.db [expr $sz-1024]
745 } {1}
746 do_test wal3-9.4 {
747 db[expr $nConn-1] close
748 execsql { PRAGMA wal_checkpoint }
749 set sz2 [file size test.db]
750 byte_is_zero test.db [expr $sz-1024]
751 } {0}
753 do_multiclient_test tn {
754 do_test wal3-10.$tn.1 {
755 sql1 {
756 PRAGMA page_size = 1024;
757 CREATE TABLE t1(x);
758 PRAGMA journal_mode = WAL;
759 PRAGMA wal_autocheckpoint = 100000;
760 BEGIN;
761 INSERT INTO t1 VALUES(randomblob(800));
762 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 2
763 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 4
764 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 8
765 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 16
766 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 32
767 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 64
768 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 128
769 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 256
770 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 512
771 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 1024
772 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 2048
773 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 4096
774 INSERT INTO t1 SELECT randomblob(800) FROM t1; -- 8192
775 COMMIT;
776 CREATE INDEX i1 ON t1(x);
777 }
779 expr {[file size test.db-wal] > [expr 1032*9000]}
780 } 1
782 do_test wal3-10.$tn.2 {
783 sql2 {PRAGMA integrity_check}
784 } {ok}
785 }
787 finish_test