Annotation of embedaddon/sqlite3/test/shared_err.test, revision 1.1.1.1
1.1 misho 1: # 2005 December 30
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: # The focus of the tests in this file are IO errors that occur in a shared
13: # cache context. What happens to connection B if one connection A encounters
14: # an IO-error whilst reading or writing the file-system?
15: #
16: # $Id: shared_err.test,v 1.24 2008/10/12 00:27:54 shane Exp $
17:
18: proc skip {args} {}
19:
20:
21: set testdir [file dirname $argv0]
22: source $testdir/tester.tcl
23: source $testdir/malloc_common.tcl
24: db close
25:
26: ifcapable !shared_cache||!subquery {
27: finish_test
28: return
29: }
30:
31: set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
32:
33: do_ioerr_test shared_ioerr-1 -tclprep {
34: sqlite3 db2 test.db
35: execsql {
36: PRAGMA read_uncommitted = 1;
37: CREATE TABLE t1(a,b,c);
38: BEGIN;
39: SELECT * FROM sqlite_master;
40: } db2
41: } -sqlbody {
42: SELECT * FROM sqlite_master;
43: INSERT INTO t1 VALUES(1,2,3);
44: BEGIN TRANSACTION;
45: INSERT INTO t1 VALUES(1,2,3);
46: INSERT INTO t1 VALUES(4,5,6);
47: ROLLBACK;
48: SELECT * FROM t1;
49: BEGIN TRANSACTION;
50: INSERT INTO t1 VALUES(1,2,3);
51: INSERT INTO t1 VALUES(4,5,6);
52: COMMIT;
53: SELECT * FROM t1;
54: DELETE FROM t1 WHERE a<100;
55: } -cleanup {
56: do_test shared_ioerr-1.$n.cleanup.1 {
57: set res [catchsql {
58: SELECT * FROM t1;
59: } db2]
60: set possible_results [list \
61: "1 {disk I/O error}" \
62: "0 {1 2 3}" \
63: "0 {1 2 3 1 2 3 4 5 6}" \
64: "0 {1 2 3 1 2 3 4 5 6 1 2 3 4 5 6}" \
65: "0 {}" \
66: "1 {database disk image is malformed}" \
67: ]
68: set rc [expr [lsearch -exact $possible_results $res] >= 0]
69: if {$rc != 1} {
70: puts ""
71: puts "Result: $res"
72: }
73: set rc
74: } {1}
75:
76: # The "database disk image is malformed" is a special case that can
77: # occur if an IO error occurs during a rollback in the {SELECT * FROM t1}
78: # statement above. This test is to make sure there is no real database
79: # corruption.
80: db2 close
81: do_test shared_ioerr-1.$n.cleanup.2 {
82: execsql {pragma integrity_check} db
83: } {ok}
84: }
85:
86: do_ioerr_test shared_ioerr-2 -tclprep {
87: sqlite3 db2 test.db
88: execsql {
89: PRAGMA read_uncommitted = 1;
90: BEGIN;
91: CREATE TABLE t1(a, b);
92: INSERT INTO t1(oid) VALUES(NULL);
93: INSERT INTO t1(oid) SELECT NULL FROM t1;
94: INSERT INTO t1(oid) SELECT NULL FROM t1;
95: INSERT INTO t1(oid) SELECT NULL FROM t1;
96: INSERT INTO t1(oid) SELECT NULL FROM t1;
97: INSERT INTO t1(oid) SELECT NULL FROM t1;
98: INSERT INTO t1(oid) SELECT NULL FROM t1;
99: INSERT INTO t1(oid) SELECT NULL FROM t1;
100: INSERT INTO t1(oid) SELECT NULL FROM t1;
101: INSERT INTO t1(oid) SELECT NULL FROM t1;
102: INSERT INTO t1(oid) SELECT NULL FROM t1;
103: UPDATE t1 set a = oid, b = 'abcdefghijklmnopqrstuvwxyz0123456789';
104: CREATE INDEX i1 ON t1(a);
105: COMMIT;
106: BEGIN;
107: SELECT * FROM sqlite_master;
108: } db2
109: } -tclbody {
110: set ::residx 0
111: execsql {DELETE FROM t1 WHERE 0 = (a % 2);}
112: incr ::residx
113:
114: # When this transaction begins the table contains 512 entries. The
115: # two statements together add 512+146 more if it succeeds.
116: # (1024/7==146)
117: execsql {BEGIN;}
118: execsql {INSERT INTO t1 SELECT a+1, b FROM t1;}
119: execsql {INSERT INTO t1 SELECT 'string' || a, b FROM t1 WHERE 0 = (a%7);}
120: execsql {COMMIT;}
121:
122: incr ::residx
123: } -cleanup {
124: catchsql ROLLBACK
125: do_test shared_ioerr-2.$n.cleanup.1 {
126: set res [catchsql {
127: SELECT max(a), min(a), count(*) FROM (SELECT a FROM t1 order by a);
128: } db2]
129: set possible_results [list \
130: {0 {1024 1 1024}} \
131: {0 {1023 1 512}} \
132: {0 {string994 1 1170}} \
133: ]
134: set idx [lsearch -exact $possible_results $res]
135: set success [expr {$idx==$::residx || $res=="1 {disk I/O error}"}]
136: if {!$success} {
137: puts ""
138: puts "Result: \"$res\" ($::residx)"
139: }
140: set success
141: } {1}
142: db2 close
143: }
144:
145: # This test is designed to provoke an IO error when a cursor position is
146: # "saved" (because another cursor is going to modify the underlying table).
147: #
148: do_ioerr_test shared_ioerr-3 -tclprep {
149: sqlite3 db2 test.db
150: execsql {
151: PRAGMA read_uncommitted = 1;
152: PRAGMA cache_size = 10;
153: BEGIN;
154: CREATE TABLE t1(a, b, UNIQUE(a, b));
155: } db2
156: for {set i 0} {$i < 200} {incr i} {
157: set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]
158:
159: set b [string repeat $i 2000]
160: execsql {INSERT INTO t1 VALUES($a, $b)} db2
161: }
162: execsql {COMMIT} db2
163: set ::DB2 [sqlite3_connection_pointer db2]
164: set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
165: sqlite3_step $::STMT ;# Cursor points at 000.000.000.000
166: sqlite3_step $::STMT ;# Cursor points at 001.001.001.001
167:
168: } -tclbody {
169: execsql {
170: BEGIN;
171: INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
172: UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
173: COMMIT;
174: }
175: } -cleanup {
176: set ::steprc [sqlite3_step $::STMT]
177: set ::column [sqlite3_column_text $::STMT 0]
178: set ::finalrc [sqlite3_finalize $::STMT]
179:
180: # There are three possible outcomes here (assuming persistent IO errors):
181: #
182: # 1. If the [sqlite3_step] did not require any IO (required pages in
183: # the cache), then the next row ("002...") may be retrieved
184: # successfully.
185: #
186: # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
187: # SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
188: #
189: # 3. If, after the initial IO error, SQLite tried to rollback the
190: # active transaction and a second IO error was encountered, then
191: # statement $::STMT will have been aborted. This means [sqlite3_stmt]
192: # returns SQLITE_ABORT, and the statement cursor does not move. i.e.
193: # [sqlite3_column] still returns the current row ("001...") and
194: # [sqlite3_finalize] returns SQLITE_OK.
195: #
196:
197: do_test shared_ioerr-3.$n.cleanup.1 {
198: expr {
199: $::steprc eq "SQLITE_ROW" ||
200: $::steprc eq "SQLITE_ERROR" ||
201: $::steprc eq "SQLITE_ABORT"
202: }
203: } {1}
204: do_test shared_ioerr-3.$n.cleanup.2 {
205: expr {
206: ($::steprc eq "SQLITE_ROW" && $::column eq "002.002.002.002.002") ||
207: ($::steprc eq "SQLITE_ERROR" && $::column eq "") ||
208: ($::steprc eq "SQLITE_ABORT" && $::column eq "001.001.001.001.001")
209: }
210: } {1}
211: do_test shared_ioerr-3.$n.cleanup.3 {
212: expr {
213: ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") ||
214: ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") ||
215: ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
216: }
217: } {1}
218:
219: # db2 eval {select * from sqlite_master}
220: db2 close
221: }
222:
223: # This is a repeat of the previous test except that this time we
224: # are doing a reverse-order scan of the table when the cursor is
225: # "saved".
226: #
227: do_ioerr_test shared_ioerr-3rev -tclprep {
228: sqlite3 db2 test.db
229: execsql {
230: PRAGMA read_uncommitted = 1;
231: PRAGMA cache_size = 10;
232: BEGIN;
233: CREATE TABLE t1(a, b, UNIQUE(a, b));
234: } db2
235: for {set i 0} {$i < 200} {incr i} {
236: set a [string range [string repeat "[format %03d $i]." 5] 0 end-1]
237:
238: set b [string repeat $i 2000]
239: execsql {INSERT INTO t1 VALUES($a, $b)} db2
240: }
241: execsql {COMMIT} db2
242: set ::DB2 [sqlite3_connection_pointer db2]
243: set ::STMT [sqlite3_prepare $::DB2 \
244: "SELECT a FROM t1 ORDER BY a DESC" -1 DUMMY]
245: sqlite3_step $::STMT ;# Cursor points at 199.199.199.199.199
246: sqlite3_step $::STMT ;# Cursor points at 198.198.198.198.198
247:
248: } -tclbody {
249: execsql {
250: BEGIN;
251: INSERT INTO t1 VALUES('201.201.201.201.201', NULL);
252: UPDATE t1 SET a = '202.202.202.202.202' WHERE a LIKE '201%';
253: COMMIT;
254: }
255: } -cleanup {
256: set ::steprc [sqlite3_step $::STMT]
257: set ::column [sqlite3_column_text $::STMT 0]
258: set ::finalrc [sqlite3_finalize $::STMT]
259:
260: # There are three possible outcomes here (assuming persistent IO errors):
261: #
262: # 1. If the [sqlite3_step] did not require any IO (required pages in
263: # the cache), then the next row ("002...") may be retrieved
264: # successfully.
265: #
266: # 2. If the [sqlite3_step] does require IO, then [sqlite3_step] returns
267: # SQLITE_ERROR and [sqlite3_finalize] returns IOERR.
268: #
269: # 3. If, after the initial IO error, SQLite tried to rollback the
270: # active transaction and a second IO error was encountered, then
271: # statement $::STMT will have been aborted. This means [sqlite3_stmt]
272: # returns SQLITE_ABORT, and the statement cursor does not move. i.e.
273: # [sqlite3_column] still returns the current row ("001...") and
274: # [sqlite3_finalize] returns SQLITE_OK.
275: #
276:
277: do_test shared_ioerr-3rev.$n.cleanup.1 {
278: expr {
279: $::steprc eq "SQLITE_ROW" ||
280: $::steprc eq "SQLITE_ERROR" ||
281: $::steprc eq "SQLITE_ABORT"
282: }
283: } {1}
284: do_test shared_ioerr-3rev.$n.cleanup.2 {
285: expr {
286: ($::steprc eq "SQLITE_ROW" && $::column eq "197.197.197.197.197") ||
287: ($::steprc eq "SQLITE_ERROR" && $::column eq "") ||
288: ($::steprc eq "SQLITE_ABORT" && $::column eq "198.198.198.198.198")
289: }
290: } {1}
291: do_test shared_ioerr-3rev.$n.cleanup.3 {
292: expr {
293: ($::steprc eq "SQLITE_ROW" && $::finalrc eq "SQLITE_OK") ||
294: ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_IOERR") ||
295: ($::steprc eq "SQLITE_ERROR" && $::finalrc eq "SQLITE_ABORT")
296: }
297: } {1}
298:
299: # db2 eval {select * from sqlite_master}
300: db2 close
301: }
302:
303: # Provoke a malloc() failure when a cursor position is being saved. This
304: # only happens with index cursors (because they malloc() space to save the
305: # current key value). It does not happen with tables, because an integer
306: # key does not require a malloc() to store.
307: #
308: # The library should return an SQLITE_NOMEM to the caller. The query that
309: # owns the cursor (the one for which the position is not saved) should
310: # continue unaffected.
311: #
312: do_malloc_test shared_err-4 -tclprep {
313: sqlite3 db2 test.db
314: execsql {
315: PRAGMA read_uncommitted = 1;
316: BEGIN;
317: CREATE TABLE t1(a, b, UNIQUE(a, b));
318: } db2
319: for {set i 0} {$i < 5} {incr i} {
320: set a [string repeat $i 10]
321: set b [string repeat $i 2000]
322: execsql {INSERT INTO t1 VALUES($a, $b)} db2
323: }
324: execsql {COMMIT} db2
325: set ::DB2 [sqlite3_connection_pointer db2]
326: set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
327: sqlite3_step $::STMT ;# Cursor points at 0000000000
328: sqlite3_step $::STMT ;# Cursor points at 1111111111
329: } -tclbody {
330: execsql {
331: INSERT INTO t1 VALUES(6, NULL);
332: }
333: } -cleanup {
334: do_test shared_malloc-4.$::n.cleanup.1 {
335: set ::rc [sqlite3_step $::STMT]
336: expr {$::rc=="SQLITE_ROW" || $::rc=="SQLITE_ERROR"}
337: } {1}
338: if {$::rc=="SQLITE_ROW"} {
339: do_test shared_malloc-4.$::n.cleanup.2 {
340: sqlite3_column_text $::STMT 0
341: } {2222222222}
342: }
343: do_test shared_malloc-4.$::n.cleanup.3 {
344: set rc [sqlite3_finalize $::STMT]
345: expr {$rc=="SQLITE_OK" || $rc=="SQLITE_ABORT" ||
346: $rc=="SQLITE_NOMEM" || $rc=="SQLITE_IOERR"}
347: } {1}
348: # db2 eval {select * from sqlite_master}
349: db2 close
350: }
351:
352: do_malloc_test shared_err-5 -tclbody {
353: db close
354: sqlite3 dbX test.db
355: sqlite3 dbY test.db
356: dbX close
357: dbY close
358: } -cleanup {
359: catch {dbX close}
360: catch {dbY close}
361: }
362:
363: do_malloc_test shared_err-6 -tclbody {
364: catch {db close}
365: ifcapable deprecated {
366: sqlite3_thread_cleanup
367: }
368: sqlite3_enable_shared_cache 0
369: } -cleanup {
370: sqlite3_enable_shared_cache 1
371: }
372:
373: # As of 3.5.0, sqlite3_enable_shared_cache can be called at
374: # any time and from any thread
375: #do_test shared_err-misuse-7.1 {
376: # sqlite3 db test.db
377: # catch {
378: # sqlite3_enable_shared_cache 0
379: # } msg
380: # set msg
381: #} {library routine called out of sequence}
382:
383: # Again provoke a malloc() failure when a cursor position is being saved,
384: # this time during a ROLLBACK operation by some other handle.
385: #
386: # The library should return an SQLITE_NOMEM to the caller. The query that
387: # owns the cursor (the one for which the position is not saved) should
388: # be aborted.
389: #
390: set ::aborted 0
391: do_malloc_test shared_err-8 -tclprep {
392: sqlite3 db2 test.db
393: execsql {
394: PRAGMA read_uncommitted = 1;
395: BEGIN;
396: CREATE TABLE t1(a, b, UNIQUE(a, b));
397: } db2
398: for {set i 0} {$i < 2} {incr i} {
399: set a [string repeat $i 10]
400: set b [string repeat $i 2000]
401: execsql {INSERT INTO t1 VALUES($a, $b)} db2
402: }
403: execsql {COMMIT} db2
404: set ::DB2 [sqlite3_connection_pointer db2]
405: set ::STMT [sqlite3_prepare $::DB2 "SELECT a FROM t1 ORDER BY a" -1 DUMMY]
406: sqlite3_step $::STMT ;# Cursor points at 0000000000
407: sqlite3_step $::STMT ;# Cursor points at 1111111111
408: } -tclbody {
409: execsql {
410: BEGIN;
411: INSERT INTO t1 VALUES(6, NULL);
412: ROLLBACK;
413: }
414: } -cleanup {
415: # UPDATE: As of [5668], if the rollback fails SQLITE_CORRUPT is returned.
416: # So these tests have been updated to expect SQLITE_CORRUPT and its
417: # associated English language error message.
418: #
419: do_test shared_malloc-8.$::n.cleanup.1 {
420: set res [catchsql {SELECT a FROM t1} db2]
421: set ans [lindex $res 1]
422: if {[lindex $res 0]} {
423: set r [expr {
424: $ans=="disk I/O error" ||
425: $ans=="out of memory" ||
426: $ans=="database disk image is malformed"
427: }]
428: } else {
429: set r [expr {[lrange $ans 0 1]=="0000000000 1111111111"}]
430: }
431: } {1}
432: do_test shared_malloc-8.$::n.cleanup.2 {
433: set rc1 [sqlite3_step $::STMT]
434: set rc2 [sqlite3_finalize $::STMT]
435: if {$rc2=="SQLITE_ABORT"} {
436: incr ::aborted
437: }
438: expr {
439: ($rc1=="SQLITE_DONE" && $rc2=="SQLITE_OK") ||
440: ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_ABORT") ||
441: ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_NOMEM") ||
442: ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_IOERR") ||
443: ($rc1=="SQLITE_ERROR" && $rc2=="SQLITE_CORRUPT")
444: }
445: } {1}
446: db2 close
447: }
448: do_test shared_malloc-8.X {
449: # Test that one or more queries were aborted due to the malloc() failure.
450: expr $::aborted>=1
451: } {1}
452:
453: # This test is designed to catch a specific bug that was present during
454: # development of 3.5.0. If a malloc() failed while setting the page-size,
455: # a buffer (Pager.pTmpSpace) was being freed. This could cause a seg-fault
456: # later if another connection tried to use the pager.
457: #
458: # This test will crash 3.4.2.
459: #
460: do_malloc_test shared_err-9 -tclprep {
461: sqlite3 db2 test.db
462: } -sqlbody {
463: PRAGMA page_size = 4096;
464: PRAGMA page_size = 1024;
465: } -cleanup {
466: db2 eval {
467: CREATE TABLE abc(a, b, c);
468: BEGIN;
469: INSERT INTO abc VALUES(1, 2, 3);
470: ROLLBACK;
471: }
472: db2 close
473: }
474:
475: catch {db close}
476: catch {db2 close}
477: do_malloc_test shared_err-10 -tclprep {
478: sqlite3 db test.db
479: sqlite3 db2 test.db
480:
481: db eval { SELECT * FROM sqlite_master }
482: db2 eval {
483: BEGIN;
484: CREATE TABLE abc(a, b, c);
485: }
486: } -tclbody {
487: catch {db eval {SELECT * FROM sqlite_master}}
488: error 1
489: } -cleanup {
490: execsql { SELECT * FROM sqlite_master }
491: }
492:
493: do_malloc_test shared_err-11 -tclprep {
494: sqlite3 db test.db
495: sqlite3 db2 test.db
496:
497: db eval { SELECT * FROM sqlite_master }
498: db2 eval {
499: BEGIN;
500: CREATE TABLE abc(a, b, c);
501: }
502: } -tclbody {
503: catch {db eval {SELECT * FROM sqlite_master}}
504: catch {sqlite3_errmsg16 db}
505: error 1
506: } -cleanup {
507: execsql { SELECT * FROM sqlite_master }
508: }
509:
510: catch {db close}
511: catch {db2 close}
512:
513: do_malloc_test shared_err-12 -sqlbody {
514: CREATE TABLE abc(a, b, c);
515: INSERT INTO abc VALUES(1, 2, 3);
516: }
517:
518: catch {db close}
519: catch {db2 close}
520: sqlite3_enable_shared_cache $::enable_shared_cache
521: finish_test
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to shared_err.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