Annotation of embedaddon/sqlite3/test/exclusive.test, revision 1.1.1.1
1.1 misho 1: # 2007 March 24
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 these tests is exclusive access mode (i.e. the thing activated by
13: # "PRAGMA locking_mode = EXCLUSIVE").
14: #
15: # $Id: exclusive.test,v 1.15 2009/06/26 12:30:40 danielk1977 Exp $
16:
17: set testdir [file dirname $argv0]
18: source $testdir/tester.tcl
19:
20: ifcapable {!pager_pragmas} {
21: finish_test
22: return
23: }
24:
25: forcedelete test2.db-journal
26: forcedelete test2.db
27: forcedelete test3.db-journal
28: forcedelete test3.db
29: forcedelete test4.db-journal
30: forcedelete test4.db
31:
32: #----------------------------------------------------------------------
33: # Test cases exclusive-1.X test the PRAGMA logic.
34: #
35: do_test exclusive-1.0 {
36: execsql {
37: pragma locking_mode;
38: pragma main.locking_mode;
39: pragma temp.locking_mode;
40: }
41: } [list normal normal exclusive]
42: do_test exclusive-1.1 {
43: execsql {
44: pragma locking_mode = exclusive;
45: }
46: } {exclusive}
47: do_test exclusive-1.2 {
48: execsql {
49: pragma locking_mode;
50: pragma main.locking_mode;
51: pragma temp.locking_mode;
52: }
53: } [list exclusive exclusive exclusive]
54: do_test exclusive-1.3 {
55: execsql {
56: pragma locking_mode = normal;
57: }
58: } {normal}
59: do_test exclusive-1.4 {
60: execsql {
61: pragma locking_mode;
62: pragma main.locking_mode;
63: pragma temp.locking_mode;
64: }
65: } [list normal normal exclusive]
66: do_test exclusive-1.5 {
67: execsql {
68: pragma locking_mode = invalid;
69: }
70: } {normal}
71: do_test exclusive-1.6 {
72: execsql {
73: pragma locking_mode;
74: pragma main.locking_mode;
75: pragma temp.locking_mode;
76: }
77: } [list normal normal exclusive]
78: ifcapable attach {
79: do_test exclusive-1.7 {
80: execsql {
81: pragma locking_mode = exclusive;
82: ATTACH 'test2.db' as aux;
83: }
84: execsql {
85: pragma main.locking_mode;
86: pragma aux.locking_mode;
87: }
88: } {exclusive exclusive}
89: do_test exclusive-1.8 {
90: execsql {
91: pragma main.locking_mode = normal;
92: }
93: execsql {
94: pragma main.locking_mode;
95: pragma temp.locking_mode;
96: pragma aux.locking_mode;
97: }
98: } [list normal exclusive exclusive]
99: do_test exclusive-1.9 {
100: execsql {
101: pragma locking_mode;
102: }
103: } {exclusive}
104: do_test exclusive-1.10 {
105: execsql {
106: ATTACH 'test3.db' as aux2;
107: }
108: execsql {
109: pragma main.locking_mode;
110: pragma aux.locking_mode;
111: pragma aux2.locking_mode;
112: }
113: } {normal exclusive exclusive}
114: do_test exclusive-1.11 {
115: execsql {
116: pragma aux.locking_mode = normal;
117: }
118: execsql {
119: pragma main.locking_mode;
120: pragma aux.locking_mode;
121: pragma aux2.locking_mode;
122: }
123: } {normal normal exclusive}
124: do_test exclusive-1.12 {
125: execsql {
126: pragma locking_mode = normal;
127: }
128: execsql {
129: pragma main.locking_mode;
130: pragma temp.locking_mode;
131: pragma aux.locking_mode;
132: pragma aux2.locking_mode;
133: }
134: } [list normal exclusive normal normal]
135: do_test exclusive-1.13 {
136: execsql {
137: ATTACH 'test4.db' as aux3;
138: }
139: execsql {
140: pragma main.locking_mode;
141: pragma temp.locking_mode;
142: pragma aux.locking_mode;
143: pragma aux2.locking_mode;
144: pragma aux3.locking_mode;
145: }
146: } [list normal exclusive normal normal normal]
147:
148: do_test exclusive-1.99 {
149: execsql {
150: DETACH aux;
151: DETACH aux2;
152: DETACH aux3;
153: }
154: } {}
155: }
156:
157: #----------------------------------------------------------------------
158: # Test cases exclusive-2.X verify that connections in exclusive
159: # locking_mode do not relinquish locks.
160: #
161: do_test exclusive-2.0 {
162: execsql {
163: CREATE TABLE abc(a, b, c);
164: INSERT INTO abc VALUES(1, 2, 3);
165: PRAGMA locking_mode = exclusive;
166: }
167: } {exclusive}
168: do_test exclusive-2.1 {
169: sqlite3 db2 test.db
170: execsql {
171: INSERT INTO abc VALUES(4, 5, 6);
172: SELECT * FROM abc;
173: } db2
174: } {1 2 3 4 5 6}
175: do_test exclusive-2.2 {
176: # This causes connection 'db' (in exclusive mode) to establish
177: # a shared-lock on the db. The other connection should now be
178: # locked out as a writer.
179: execsql {
180: SELECT * FROM abc;
181: } db
182: } {1 2 3 4 5 6}
183: do_test exclusive-2.4 {
184: execsql {
185: SELECT * FROM abc;
186: } db2
187: } {1 2 3 4 5 6}
188: do_test exclusive-2.5 {
189: catchsql {
190: INSERT INTO abc VALUES(7, 8, 9);
191: } db2
192: } {1 {database is locked}}
193: sqlite3_soft_heap_limit 0
194: do_test exclusive-2.6 {
195: # Because connection 'db' only has a shared-lock, the other connection
196: # will be able to get a RESERVED, but will fail to upgrade to EXCLUSIVE.
197: execsql {
198: BEGIN;
199: INSERT INTO abc VALUES(7, 8, 9);
200: } db2
201: catchsql {
202: COMMIT
203: } db2
204: } {1 {database is locked}}
205: do_test exclusive-2.7 {
206: catchsql {
207: COMMIT
208: } db2
209: } {1 {database is locked}}
210: do_test exclusive-2.8 {
211: execsql {
212: ROLLBACK;
213: } db2
214: } {}
215: sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit)
216:
217: do_test exclusive-2.9 {
218: # Write the database to establish the exclusive lock with connection 'db.
219: execsql {
220: INSERT INTO abc VALUES(7, 8, 9);
221: } db
222: catchsql {
223: SELECT * FROM abc;
224: } db2
225: } {1 {database is locked}}
226: do_test exclusive-2.10 {
227: # Changing the locking-mode does not release any locks.
228: execsql {
229: PRAGMA locking_mode = normal;
230: } db
231: catchsql {
232: SELECT * FROM abc;
233: } db2
234: } {1 {database is locked}}
235: do_test exclusive-2.11 {
236: # After changing the locking mode, accessing the db releases locks.
237: execsql {
238: SELECT * FROM abc;
239: } db
240: execsql {
241: SELECT * FROM abc;
242: } db2
243: } {1 2 3 4 5 6 7 8 9}
244: db2 close
245:
246: #----------------------------------------------------------------------
247: # Tests exclusive-3.X - test that a connection in exclusive mode
248: # truncates instead of deletes the journal file when committing
249: # a transaction.
250: #
251: # These tests are not run on windows because the windows backend
252: # opens the journal file for exclusive access, preventing its contents
253: # from being inspected externally.
254: #
255: if {$tcl_platform(platform) != "windows"} {
256:
257: # Return a list of two booleans (either 0 or 1). The first is true
258: # if the named file exists. The second is true only if the file
259: # exists and the first 28 bytes contain at least one non-zero byte.
260: #
261: proc filestate {fname} {
262: set exists 0
263: set content 0
264: if {[file exists $fname]} {
265: set exists 1
266: set hdr [hexio_read $fname 0 28]
267: set content [expr {0==[string match $hdr [string repeat 0 56]]}]
268: }
269: list $exists $content
270: }
271:
272: do_test exclusive-3.0 {
273: filestate test.db-journal
274: } {0 0}
275: do_test exclusive-3.1 {
276: execsql {
277: PRAGMA locking_mode = exclusive;
278: BEGIN;
279: DELETE FROM abc;
280: }
281: filestate test.db-journal
282: } {1 1}
283: do_test exclusive-3.2 {
284: execsql {
285: COMMIT;
286: }
287: filestate test.db-journal
288: } {1 0}
289: do_test exclusive-3.3 {
290: execsql {
291: INSERT INTO abc VALUES('A', 'B', 'C');
292: SELECT * FROM abc;
293: }
294: } {A B C}
295: do_test exclusive-3.4 {
296: execsql {
297: BEGIN;
298: UPDATE abc SET a = 1, b = 2, c = 3;
299: ROLLBACK;
300: SELECT * FROM abc;
301: }
302: } {A B C}
303: do_test exclusive-3.5 {
304: filestate test.db-journal
305: } {1 0}
306: do_test exclusive-3.6 {
307: execsql {
308: PRAGMA locking_mode = normal;
309: SELECT * FROM abc;
310: }
311: filestate test.db-journal
312: } {0 0}
313: }
314:
315: #----------------------------------------------------------------------
316: # Tests exclusive-4.X - test that rollback works correctly when
317: # in exclusive-access mode.
318: #
319:
320: # The following procedure computes a "signature" for table "t3". If
321: # T3 changes in any way, the signature should change.
322: #
323: # This is used to test ROLLBACK. We gather a signature for t3, then
324: # make lots of changes to t3, then rollback and take another signature.
325: # The two signatures should be the same.
326: #
327: proc signature {} {
328: return [db eval {SELECT count(*), md5sum(x) FROM t3}]
329: }
330:
331: do_test exclusive-4.0 {
332: execsql { PRAGMA locking_mode = exclusive; }
333: execsql { PRAGMA default_cache_size = 10; }
334: execsql {
335: BEGIN;
336: CREATE TABLE t3(x TEXT);
337: INSERT INTO t3 VALUES(randstr(10,400));
338: INSERT INTO t3 VALUES(randstr(10,400));
339: INSERT INTO t3 SELECT randstr(10,400) FROM t3;
340: INSERT INTO t3 SELECT randstr(10,400) FROM t3;
341: INSERT INTO t3 SELECT randstr(10,400) FROM t3;
342: INSERT INTO t3 SELECT randstr(10,400) FROM t3;
343: COMMIT;
344: }
345: execsql {SELECT count(*) FROM t3;}
346: } {32}
347:
348: set ::X [signature]
349: do_test exclusive-4.1 {
350: execsql {
351: BEGIN;
352: DELETE FROM t3 WHERE random()%10!=0;
353: INSERT INTO t3 SELECT randstr(10,10)||x FROM t3;
354: INSERT INTO t3 SELECT randstr(10,10)||x FROM t3;
355: SELECT count(*) FROM t3;
356: ROLLBACK;
357: }
358: signature
359: } $::X
360:
361: do_test exclusive-4.2 {
362: execsql {
363: BEGIN;
364: DELETE FROM t3 WHERE random()%10!=0;
365: INSERT INTO t3 SELECT randstr(10,10)||x FROM t3;
366: DELETE FROM t3 WHERE random()%10!=0;
367: INSERT INTO t3 SELECT randstr(10,10)||x FROM t3;
368: ROLLBACK;
369: }
370: signature
371: } $::X
372:
373: do_test exclusive-4.3 {
374: execsql {
375: INSERT INTO t3 SELECT randstr(10,400) FROM t3 WHERE random()%10==0;
376: }
377: } {}
378:
379: do_test exclusive-4.4 {
380: catch {set ::X [signature]}
381: } {0}
382: do_test exclusive-4.5 {
383: execsql {
384: PRAGMA locking_mode = NORMAL;
385: DROP TABLE t3;
386: DROP TABLE abc;
387: }
388: } {normal}
389:
390: #----------------------------------------------------------------------
391: # Tests exclusive-5.X - test that statement journals are truncated
392: # instead of deleted when in exclusive access mode.
393: #
394:
395: # Close and reopen the database so that the temp database is no
396: # longer active.
397: #
398: db close
399: sqlite3 db test.db
400:
401: # if we're using proxy locks, we use 3 filedescriptors for a db
402: # that is open but NOT writing changes, normally
403: # sqlite uses 1 (proxy locking adds the conch and the local lock)
404: set using_proxy 0
405: foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] {
406: set using_proxy $value
407: }
408: set extrafds 0
409: if {$using_proxy!=0} {
410: set extrafds 2
411: }
412:
413: do_test exclusive-5.0 {
414: execsql {
415: CREATE TABLE abc(a UNIQUE, b UNIQUE, c UNIQUE);
416: BEGIN;
417: INSERT INTO abc VALUES(1, 2, 3);
418: INSERT INTO abc SELECT a+1, b+1, c+1 FROM abc;
419: }
420: } {}
421: do_test exclusive-5.1 {
422: # Three files are open: The db, journal and statement-journal.
423: set sqlite_open_file_count
424: expr $sqlite_open_file_count-$extrafds
425: } [expr 3 - ($TEMP_STORE>=2)]
426: do_test exclusive-5.2 {
427: execsql {
428: COMMIT;
429: }
430: # One file open: the db.
431: set sqlite_open_file_count
432: expr $sqlite_open_file_count-$extrafds
433: } {1}
434: do_test exclusive-5.3 {
435: execsql {
436: PRAGMA locking_mode = exclusive;
437: BEGIN;
438: INSERT INTO abc VALUES(5, 6, 7);
439: }
440: # Two files open: the db and journal.
441: set sqlite_open_file_count
442: expr $sqlite_open_file_count-$extrafds
443: } {2}
444: do_test exclusive-5.4 {
445: execsql {
446: INSERT INTO abc SELECT a+10, b+10, c+10 FROM abc;
447: }
448: # Three files are open: The db, journal and statement-journal.
449: set sqlite_open_file_count
450: expr $sqlite_open_file_count-$extrafds
451: } [expr 3 - ($TEMP_STORE>=2)]
452: do_test exclusive-5.5 {
453: execsql {
454: COMMIT;
455: }
456: # Three files are still open: The db, journal and statement-journal.
457: set sqlite_open_file_count
458: expr $sqlite_open_file_count-$extrafds
459: } [expr 3 - ($TEMP_STORE>=2)]
460: do_test exclusive-5.6 {
461: execsql {
462: PRAGMA locking_mode = normal;
463: SELECT * FROM abc;
464: }
465: } {normal 1 2 3 2 3 4 5 6 7 11 12 13 12 13 14 15 16 17}
466: do_test exclusive-5.7 {
467: # Just the db open.
468: set sqlite_open_file_count
469: expr $sqlite_open_file_count-$extrafds
470: } {1}
471:
472: #-------------------------------------------------------------------------
473:
474: do_execsql_test exclusive-6.1 {
475: CREATE TABLE t4(a, b);
476: INSERT INTO t4 VALUES('Eden', 1955);
477: BEGIN;
478: INSERT INTO t4 VALUES('Macmillan', 1957);
479: INSERT INTO t4 VALUES('Douglas-Home', 1963);
480: INSERT INTO t4 VALUES('Wilson', 1964);
481: }
482: do_test exclusive-6.2 {
483: forcedelete test2.db test2.db-journal
484: copy_file test.db test2.db
485: copy_file test.db-journal test2.db-journal
486: sqlite3 db test2.db
487: } {}
488:
489: do_execsql_test exclusive-6.3 {
490: PRAGMA locking_mode = EXCLUSIVE;
491: SELECT * FROM t4;
492: } {exclusive Eden 1955}
493:
494: do_test exclusive-6.4 {
495: db close
496: forcedelete test.db test.db-journal
497: set fd [open test.db-journal w]
498: puts $fd x
499: close $fd
500: sqlite3 db test.db
501: } {}
502:
503: do_execsql_test exclusive-6.5 {
504: PRAGMA locking_mode = EXCLUSIVE;
505: SELECT * FROM sqlite_master;
506: } {exclusive}
507:
508: finish_test
509:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to exclusive.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