Annotation of embedaddon/sqlite3/test/notify1.test, revision 1.1.1.1
1.1 misho 1: # 2009 March 04
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 sqlite3_unlock_notify() API.
13: #
14: # $Id: notify1.test,v 1.4 2009/06/05 17:09:12 drh Exp $
15:
16: set testdir [file dirname $argv0]
17: source $testdir/tester.tcl
18:
19: ifcapable !unlock_notify||!shared_cache {
20: finish_test
21: return
22: }
23: db close
24: set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
25:
26: #-------------------------------------------------------------------------
27: # Warm body test. Test that an unlock-notify callback can be registered
28: # and that it is invoked.
29: #
30: do_test notify1-1.1 {
31: sqlite3 db test.db
32: sqlite3 db2 test.db
33: execsql { CREATE TABLE t1(a, b) }
34: } {}
35: do_test notify1-1.2 {
36: execsql {
37: BEGIN;
38: INSERT INTO t1 VALUES(1, 2);
39: }
40: catchsql { INSERT INTO t1 VALUES(3, 4) } db2
41: } {1 {database table is locked}}
42: do_test notify1-1.3 {
43: set zScript ""
44: db2 unlock_notify {
45: set zScript "db2 eval { INSERT INTO t1 VALUES(3, 4) }"
46: }
47: execsql { SELECT * FROM t1 }
48: } {1 2}
49: do_test notify1-1.4 {
50: set zScript
51: } {}
52: do_test notify1-1.5 {
53: execsql { COMMIT }
54: eval $zScript
55: execsql { SELECT * FROM t1 }
56: } {1 2 3 4}
57:
58: #-------------------------------------------------------------------------
59: # Verify that invoking the "unlock_notify" method with no arguments
60: # (which is the equivalent of invoking sqlite3_unlock_notify() with
61: # a NULL xNotify argument) cancels a pending notify callback.
62: #
63: do_test notify1-1.11 {
64: execsql { DROP TABLE t1; CREATE TABLE t1(a, b) }
65: } {}
66: do_test notify1-1.12 {
67: execsql {
68: BEGIN;
69: INSERT INTO t1 VALUES(1, 2);
70: }
71: catchsql { INSERT INTO t1 VALUES(3, 4) } db2
72: } {1 {database table is locked}}
73: do_test notify1-1.13 {
74: set zScript ""
75: db2 unlock_notify {
76: set zScript "db2 eval { INSERT INTO t1 VALUES(3, 4) }"
77: }
78: execsql { SELECT * FROM t1 }
79: } {1 2}
80: do_test notify1-1.14 {
81: set zScript
82: } {}
83: do_test notify1-1.15 {
84: db2 unlock_notify
85: execsql { COMMIT }
86: eval $zScript
87: execsql { SELECT * FROM t1 }
88: } {1 2}
89:
90: #-------------------------------------------------------------------------
91: # The following tests, notify1-2.*, test that deadlock is detected
92: # correctly.
93: #
94: do_test notify1-2.1 {
95: execsql {
96: CREATE TABLE t2(a, b);
97: INSERT INTO t2 VALUES('I', 'II');
98: }
99: } {}
100:
101: #
102: # Test for simple deadlock involving two database connections.
103: #
104: # 1. Grab a write-lock on t1 with [db]. Then grab a read-lock on t2 with [db2].
105: # 2. Try to grab a read-lock on t1 with [db2] (fails).
106: # 3. Have [db2] wait on the read-lock it failed to obtain in step 2.
107: # 4. Try to grab a write-lock on t2 with [db] (fails).
108: # 5. Try to have [db] wait on the lock from step 4. Fails, as the system
109: # would be deadlocked (since [db2] is already waiting on [db], and this
110: # operation would have [db] wait on [db2]).
111: #
112: do_test notify1-2.2.1 {
113: execsql {
114: BEGIN;
115: INSERT INTO t1 VALUES(5, 6);
116: }
117: execsql {
118: BEGIN;
119: SELECT * FROM t2;
120: } db2
121: } {I II}
122: do_test notify1-2.2.2 {
123: catchsql { SELECT * FROM t1 } db2
124: } {1 {database table is locked: t1}}
125: do_test notify1-2.2.3 {
126: db2 unlock_notify {lappend unlock_notify db2}
127: } {}
128: do_test notify1-2.2.4 {
129: catchsql { INSERT INTO t2 VALUES('III', 'IV') }
130: } {1 {database table is locked: t2}}
131: do_test notify1-2.2.5 {
132: set rc [catch { db unlock_notify {lappend unlock_notify db} } msg]
133: list $rc $msg
134: } {1 {database is deadlocked}}
135:
136: #
137: # Test for slightly more complex deadlock involving three database
138: # connections: db, db2 and db3.
139: #
140: do_test notify1-2.3.1 {
141: db close
142: db2 close
143: forcedelete test.db test2.db test3.db
144: foreach con {db db2 db3} {
145: sqlite3 $con test.db
146: $con eval { ATTACH 'test2.db' AS aux2 }
147: $con eval { ATTACH 'test3.db' AS aux3 }
148: }
149: execsql {
150: CREATE TABLE main.t1(a, b);
151: CREATE TABLE aux2.t2(a, b);
152: CREATE TABLE aux3.t3(a, b);
153: }
154: } {}
155: do_test notify1-2.3.2 {
156: execsql { BEGIN ; INSERT INTO t1 VALUES(1, 2) } db
157: execsql { BEGIN ; INSERT INTO t2 VALUES(1, 2) } db2
158: execsql { BEGIN ; INSERT INTO t3 VALUES(1, 2) } db3
159: } {}
160: do_test notify1-2.3.3 {
161: catchsql { SELECT * FROM t2 } db
162: } {1 {database table is locked: t2}}
163: do_test notify1-2.3.4 {
164: catchsql { SELECT * FROM t3 } db2
165: } {1 {database table is locked: t3}}
166: do_test notify1-2.3.5 {
167: catchsql { SELECT * FROM t1 } db3
168: } {1 {database table is locked: t1}}
169: do_test notify1-2.3.6 {
170: set lUnlock [list]
171: db unlock_notify {lappend lUnlock db}
172: db2 unlock_notify {lappend lUnlock db2}
173: } {}
174: do_test notify1-2.3.7 {
175: set rc [catch { db3 unlock_notify {lappend lUnlock db3} } msg]
176: list $rc $msg
177: } {1 {database is deadlocked}}
178: do_test notify1-2.3.8 {
179: execsql { COMMIT }
180: set lUnlock
181: } {}
182: do_test notify1-2.3.9 {
183: db3 unlock_notify {lappend lUnlock db3}
184: set lUnlock
185: } {db3}
186: do_test notify1-2.3.10 {
187: execsql { COMMIT } db2
188: set lUnlock
189: } {db3 db}
190: do_test notify1-2.3.11 {
191: execsql { COMMIT } db3
192: set lUnlock
193: } {db3 db db2}
194: catch { db3 close }
195: catch { db2 close }
196: catch { db close }
197:
198: #-------------------------------------------------------------------------
199: # The following tests, notify1-3.* and notify1-4.*, test that callbacks
200: # can be issued when there are many (>16) connections waiting on a single
201: # unlock event.
202: #
203: foreach {tn nConn} {3 20 4 76} {
204: do_test notify1-$tn.1 {
205: sqlite3 db test.db
206: execsql {
207: BEGIN;
208: INSERT INTO t1 VALUES('a', 'b');
209: }
210: } {}
211: set lUnlock [list]
212: set lUnlockFinal [list]
213: for {set ii 1} {$ii <= $nConn} {incr ii} {
214: do_test notify1-$tn.2.$ii.1 {
215: set cmd "db$ii"
216: sqlite3 $cmd test.db
217: catchsql { SELECT * FROM t1 } $cmd
218: } {1 {database table is locked: t1}}
219: do_test notify1-$tn.2.$ii.2 {
220: $cmd unlock_notify "lappend lUnlock $ii"
221: } {}
222: lappend lUnlockFinal $ii
223: }
224: do_test notify1-$tn.3 {
225: set lUnlock
226: } {}
227: do_test notify1-$tn.4 {
228: execsql {COMMIT}
229: lsort -integer $lUnlock
230: } $lUnlockFinal
231: do_test notify1-$tn.5 {
232: for {set ii 1} {$ii <= $nConn} {incr ii} {
233: "db$ii" close
234: }
235: } {}
236: }
237: db close
238:
239: #-------------------------------------------------------------------------
240: # These tests, notify1-5.*, test that a malloc() failure that occurs while
241: # allocating an array to use as an argument to an unlock-notify callback
242: # is handled correctly.
243: #
244: source $testdir/malloc_common.tcl
245: do_malloc_test notify1-5 -tclprep {
246: set ::lUnlock [list]
247: execsql {
248: CREATE TABLE t1(a, b);
249: BEGIN;
250: INSERT INTO t1 VALUES('a', 'b');
251: }
252: for {set ii 1} {$ii <= 60} {incr ii} {
253: set cmd "db$ii"
254: sqlite3 $cmd test.db
255: catchsql { SELECT * FROM t1 } $cmd
256: $cmd unlock_notify "lappend ::lUnlock $ii"
257: }
258: } -sqlbody {
259: COMMIT;
260: } -cleanup {
261: # One of two things should have happened:
262: #
263: # 1) The transaction opened by [db] was not committed. No unlock-notify
264: # callbacks were invoked, OR
265: # 2) The transaction opened by [db] was committed and 60 unlock-notify
266: # callbacks were invoked.
267: #
268: do_test notify1-5.systemstate {
269: expr { ([llength $::lUnlock]==0 && [sqlite3_get_autocommit db]==0)
270: || ([llength $::lUnlock]==60 && [sqlite3_get_autocommit db]==1)
271: }
272: } {1}
273: for {set ii 1} {$ii <= 60} {incr ii} { "db$ii" close }
274: }
275:
276: #-------------------------------------------------------------------------
277: # Test cases notify1-6.* test cases where the following occur:
278: #
279: # notify1-6.1.*: Test encountering an SQLITE_LOCKED error when the
280: # "blocking connection" has already been set by a previous
281: # SQLITE_LOCKED.
282: #
283: # notify1-6.2.*: Test encountering an SQLITE_LOCKED error when already
284: # waiting on an unlock-notify callback.
285: #
286: # notify1-6.3.*: Test that if an SQLITE_LOCKED error is encountered while
287: # already waiting on an unlock-notify callback, and then
288: # the blocker that caused the SQLITE_LOCKED commits its
289: # transaction, the unlock-notify callback is not invoked.
290: #
291: # notify1-6.4.*: Like 6.3.*, except that instead of the second blocker
292: # committing its transaction, the first does. The
293: # unlock-notify callback is therefore invoked.
294: #
295: db close
296: do_test notify1-6.1.1 {
297: forcedelete test.db test2.db
298: foreach conn {db db2 db3} {
299: sqlite3 $conn test.db
300: execsql { ATTACH 'test2.db' AS two } $conn
301: }
302: execsql {
303: CREATE TABLE t1(a, b);
304: CREATE TABLE two.t2(a, b);
305: }
306: execsql {
307: BEGIN;
308: INSERT INTO t1 VALUES(1, 2);
309: } db2
310: execsql {
311: BEGIN;
312: INSERT INTO t2 VALUES(1, 2);
313: } db3
314: } {}
315: do_test notify1-6.1.2 {
316: catchsql { SELECT * FROM t2 }
317: } {1 {database table is locked: t2}}
318: do_test notify1-6.1.3 {
319: catchsql { SELECT * FROM t1 }
320: } {1 {database table is locked: t1}}
321:
322: do_test notify1-6.2.1 {
323: set unlocked 0
324: db unlock_notify {set unlocked 1}
325: set unlocked
326: } {0}
327: do_test notify1-6.2.2 {
328: catchsql { SELECT * FROM t2 }
329: } {1 {database table is locked: t2}}
330: do_test notify1-6.2.3 {
331: execsql { COMMIT } db2
332: set unlocked
333: } {1}
334:
335: do_test notify1-6.3.1 {
336: execsql {
337: BEGIN;
338: INSERT INTO t1 VALUES(3, 4);
339: } db2
340: } {}
341: do_test notify1-6.3.2 {
342: catchsql { SELECT * FROM t1 }
343: } {1 {database table is locked: t1}}
344: do_test notify1-6.3.3 {
345: set unlocked 0
346: db unlock_notify {set unlocked 1}
347: set unlocked
348: } {0}
349: do_test notify1-6.3.4 {
350: catchsql { SELECT * FROM t2 }
351: } {1 {database table is locked: t2}}
352: do_test notify1-6.3.5 {
353: execsql { COMMIT } db3
354: set unlocked
355: } {0}
356:
357: do_test notify1-6.4.1 {
358: execsql {
359: BEGIN;
360: INSERT INTO t2 VALUES(3, 4);
361: } db3
362: catchsql { SELECT * FROM t2 }
363: } {1 {database table is locked: t2}}
364: do_test notify1-6.4.2 {
365: execsql { COMMIT } db2
366: set unlocked
367: } {1}
368: do_test notify1-6.4.3 {
369: execsql { COMMIT } db3
370: } {}
371: db close
372: db2 close
373: db3 close
374:
375: #-------------------------------------------------------------------------
376: # Test cases notify1-7.* tests that when more than one distinct
377: # unlock-notify function is registered, all are invoked correctly.
378: #
379: proc unlock_notify {} {
380: incr ::unlock_notify
381: }
382: do_test notify1-7.1 {
383: foreach conn {db db2 db3} {
384: sqlite3 $conn test.db
385: }
386: execsql {
387: BEGIN;
388: INSERT INTO t1 VALUES(5, 6);
389: }
390: } {}
391: do_test notify1-7.2 {
392: catchsql { SELECT * FROM t1 } db2
393: } {1 {database table is locked: t1}}
394: do_test notify1-7.3 {
395: catchsql { SELECT * FROM t1 } db3
396: } {1 {database table is locked: t1}}
397: do_test notify1-7.4 {
398: set unlock_notify 0
399: db2 unlock_notify unlock_notify
400: sqlite3_unlock_notify db3
401: } {SQLITE_OK}
402: do_test notify1-7.5 {
403: set unlock_notify
404: } {0}
405: do_test notify1-7.6 {
406: execsql { COMMIT }
407: set unlock_notify
408: } {2}
409:
410: #-------------------------------------------------------------------------
411: # Test cases notify1-8.* tests that the correct SQLITE_LOCKED extended
412: # error code is returned in various scenarios.
413: #
414: do_test notify1-8.1 {
415: execsql {
416: BEGIN;
417: INSERT INTO t1 VALUES(7, 8);
418: }
419: catchsql { SELECT * FROM t1 } db2
420: } {1 {database table is locked: t1}}
421: do_test notify1-8.2 {
422: sqlite3_extended_errcode db2
423: } {SQLITE_LOCKED_SHAREDCACHE}
424:
425: do_test notify1-8.3 {
426: execsql {
427: COMMIT;
428: BEGIN EXCLUSIVE;
429: }
430: catchsql { SELECT * FROM t1 } db2
431: } {1 {database schema is locked: main}}
432: do_test notify1-8.4 {
433: sqlite3_extended_errcode db2
434: } {SQLITE_LOCKED_SHAREDCACHE}
435:
436: do_test notify1-8.X {
437: execsql { COMMIT }
438: } {}
439:
440: #-------------------------------------------------------------------------
441: # Test cases notify1-9.* test the shared-cache 'pending-lock' feature.
442: #
443: do_test notify1-9.1 {
444: execsql {
445: CREATE TABLE t2(a, b);
446: BEGIN;
447: SELECT * FROM t1;
448: } db2
449: } {1 2 3 4 5 6 7 8}
450: do_test notify1-9.2 {
451: execsql { SELECT * FROM t1 } db3
452: } {1 2 3 4 5 6 7 8}
453: do_test notify1-9.3 {
454: catchsql {
455: BEGIN;
456: INSERT INTO t1 VALUES(9, 10);
457: }
458: } {1 {database table is locked: t1}}
459: do_test notify1-9.4 {
460: catchsql { SELECT * FROM t2 } db3
461: } {1 {database table is locked}}
462: do_test notify1-9.5 {
463: execsql { COMMIT } db2
464: execsql { SELECT * FROM t2 } db3
465: } {}
466: do_test notify1-9.6 {
467: execsql { COMMIT }
468: } {}
469:
470: do_test notify1-9.7 {
471: execsql {
472: BEGIN;
473: SELECT * FROM t1;
474: } db2
475: } {1 2 3 4 5 6 7 8}
476: do_test notify1-9.8 {
477: execsql { SELECT * FROM t1 } db3
478: } {1 2 3 4 5 6 7 8}
479: do_test notify1-9.9 {
480: catchsql {
481: BEGIN;
482: INSERT INTO t1 VALUES(9, 10);
483: }
484: } {1 {database table is locked: t1}}
485: do_test notify1-9.10 {
486: catchsql { SELECT * FROM t2 } db3
487: } {1 {database table is locked}}
488: do_test notify1-9.11 {
489: execsql { COMMIT }
490: execsql { SELECT * FROM t2 } db3
491: } {}
492: do_test notify1-9.12 {
493: execsql { COMMIT } db2
494: } {}
495:
496: db close
497: db2 close
498: db3 close
499: sqlite3_enable_shared_cache $::enable_shared_cache
500: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to notify1.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