| blob | 86145672a218a671aa2573307e8282b0ff0fdda9 |
1 # 2001 September 15
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 attempts to check the behavior of the SQLite library in
13 # an out-of-memory situation. When compiled with -DSQLITE_DEBUG=1,
14 # the SQLite library accepts a special command (sqlite3_memdebug_fail N C)
15 # which causes the N-th malloc to fail. This special feature is used
16 # to see what happens in the library if a malloc were to really fail
17 # due to an out-of-memory situation.
18 #
19 # $Id: malloc.test,v 1.81 2009/06/24 13:13:45 drh Exp $
21 set testdir [file dirname $argv0]
22 source $testdir/tester.tcl
23 set ::testprefix malloc
26 # Only run these tests if memory debugging is turned on.
27 #
28 source $testdir/malloc_common.tcl
29 if {!$MEMDEBUG} {
30 puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
31 finish_test
32 return
33 }
35 # Do a couple of memory dumps just to exercise the memory dump logic
36 # that that we can say that we have.
37 #
38 puts stderr "This is a test. Ignore the error that follows:"
39 sqlite3_memdebug_dump $testdir
40 puts "Memory dump to file memdump.txt..."
41 sqlite3_memdebug_dump memdump.txt
43 ifcapable bloblit&&subquery {
44 do_malloc_test 1 -tclprep {
45 db close
46 } -tclbody {
47 if {[catch {sqlite3 db test.db}]} {
48 error "out of memory"
49 }
50 sqlite3_extended_result_codes db 1
51 } -sqlbody {
52 DROP TABLE IF EXISTS t1;
53 CREATE TABLE t1(
54 a int, b float, c double, d text, e varchar(20),
55 primary key(a,b,c)
56 );
57 CREATE INDEX i1 ON t1(a,b);
58 INSERT INTO t1 VALUES(1,2.3,4.5,'hi',x'746865726500');
59 INSERT INTO t1 VALUES(6,7.0,0.8,'hello','out yonder');
60 SELECT * FROM t1;
61 SELECT avg(b) FROM t1 GROUP BY a HAVING b>20.0;
62 DELETE FROM t1 WHERE a IN (SELECT min(a) FROM t1);
63 SELECT count(*), group_concat(e) FROM t1;
64 SELECT b FROM t1 ORDER BY 1 COLLATE nocase;
65 }
66 }
68 # Ensure that no file descriptors were leaked.
69 do_test malloc-1.X {
70 catch {db close}
71 set sqlite_open_file_count
72 } {0}
74 ifcapable subquery {
75 do_malloc_test 2 -sqlbody {
76 CREATE TABLE t1(a int, b int default 'abc', c int default 1);
77 CREATE INDEX i1 ON t1(a,b);
78 INSERT INTO t1 VALUES(1,1,'99 abcdefghijklmnopqrstuvwxyz');
79 INSERT INTO t1 VALUES(2,4,'98 abcdefghijklmnopqrstuvwxyz');
80 INSERT INTO t1 VALUES(3,9,'97 abcdefghijklmnopqrstuvwxyz');
81 INSERT INTO t1 VALUES(4,16,'96 abcdefghijklmnopqrstuvwxyz');
82 INSERT INTO t1 VALUES(5,25,'95 abcdefghijklmnopqrstuvwxyz');
83 INSERT INTO t1 VALUES(6,36,'94 abcdefghijklmnopqrstuvwxyz');
84 SELECT 'stuff', count(*) as 'other stuff', max(a+10) FROM t1;
85 UPDATE t1 SET b=b||b||b||b;
86 UPDATE t1 SET b=a WHERE a in (10,12,22);
87 INSERT INTO t1(c,b,a) VALUES(20,10,5);
88 INSERT INTO t1 SELECT * FROM t1
89 WHERE a IN (SELECT a FROM t1 WHERE a<10);
90 DELETE FROM t1 WHERE a>=10;
91 DROP INDEX i1;
92 DELETE FROM t1;
93 }
94 }
96 # Ensure that no file descriptors were leaked.
97 do_test malloc-2.X {
98 catch {db close}
99 set sqlite_open_file_count
100 } {0}
102 do_malloc_test 3 -sqlbody {
103 BEGIN TRANSACTION;
104 CREATE TABLE t1(a int, b int, c int);
105 CREATE INDEX i1 ON t1(a,b);
106 INSERT INTO t1 VALUES(1,1,99);
107 INSERT INTO t1 VALUES(2,4,98);
108 INSERT INTO t1 VALUES(3,9,97);
109 INSERT INTO t1 VALUES(4,16,96);
110 INSERT INTO t1 VALUES(5,25,95);
111 INSERT INTO t1 VALUES(6,36,94);
112 INSERT INTO t1(c,b,a) VALUES(20,10,5);
113 DELETE FROM t1 WHERE a>=10;
114 DROP INDEX i1;
115 DELETE FROM t1;
116 ROLLBACK;
117 }
120 # Ensure that no file descriptors were leaked.
121 do_test malloc-3.X {
122 catch {db close}
123 set sqlite_open_file_count
124 } {0}
126 ifcapable subquery {
127 do_malloc_test 4 -sqlbody {
128 BEGIN TRANSACTION;
129 CREATE TABLE t1(a int, b int, c int);
130 CREATE INDEX i1 ON t1(a,b);
131 INSERT INTO t1 VALUES(1,1,99);
132 INSERT INTO t1 VALUES(2,4,98);
133 INSERT INTO t1 VALUES(3,9,97);
134 INSERT INTO t1 VALUES(4,16,96);
135 INSERT INTO t1 VALUES(5,25,95);
136 INSERT INTO t1 VALUES(6,36,94);
137 UPDATE t1 SET b=a WHERE a in (10,12,22);
138 INSERT INTO t1 SELECT * FROM t1
139 WHERE a IN (SELECT a FROM t1 WHERE a<10);
140 DROP INDEX i1;
141 DELETE FROM t1;
142 COMMIT;
143 }
144 }
146 # Ensure that no file descriptors were leaked.
147 do_test malloc-4.X {
148 catch {db close}
149 set sqlite_open_file_count
150 } {0}
152 ifcapable trigger {
153 do_malloc_test 5 -sqlbody {
154 BEGIN TRANSACTION;
155 CREATE TABLE t1(a,b);
156 CREATE TABLE t2(x,y);
157 CREATE TRIGGER r1 AFTER INSERT ON t1 WHEN new.a = 2 BEGIN
158 INSERT INTO t2(x,y) VALUES(new.rowid,1);
159 INSERT INTO t2(x,y) SELECT * FROM t2;
160 INSERT INTO t2 SELECT * FROM t2;
161 UPDATE t2 SET y=y+1 WHERE x=new.rowid;
162 SELECT 123;
163 DELETE FROM t2 WHERE x=new.rowid;
164 END;
165 INSERT INTO t1(a,b) VALUES(2,3);
166 COMMIT;
167 }
168 }
170 # Ensure that no file descriptors were leaked.
171 do_test malloc-5.X {
172 catch {db close}
173 set sqlite_open_file_count
174 } {0}
176 ifcapable vacuum {
177 do_malloc_test 6 -sqlprep {
178 BEGIN TRANSACTION;
179 CREATE TABLE t1(a);
180 INSERT INTO t1 VALUES(1);
181 INSERT INTO t1 SELECT a*2 FROM t1;
182 INSERT INTO t1 SELECT a*2 FROM t1;
183 INSERT INTO t1 SELECT a*2 FROM t1;
184 INSERT INTO t1 SELECT a*2 FROM t1;
185 INSERT INTO t1 SELECT a*2 FROM t1;
186 INSERT INTO t1 SELECT a*2 FROM t1;
187 INSERT INTO t1 SELECT a*2 FROM t1;
188 INSERT INTO t1 SELECT a*2 FROM t1;
189 INSERT INTO t1 SELECT a*2 FROM t1;
190 INSERT INTO t1 SELECT a*2 FROM t1;
191 DELETE FROM t1 where rowid%5 = 0;
192 COMMIT;
193 } -sqlbody {
194 VACUUM;
195 }
196 }
198 autoinstall_test_functions
199 do_malloc_test 7 -sqlprep {
200 CREATE TABLE t1(a, b);
201 INSERT INTO t1 VALUES(1, 2);
202 INSERT INTO t1 VALUES(3, 4);
203 INSERT INTO t1 VALUES(5, 6);
204 INSERT INTO t1 VALUES(7, randstr(1200,1200));
205 } -sqlbody {
206 SELECT min(a) FROM t1 WHERE a<6 GROUP BY b;
207 SELECT a FROM t1 WHERE a<6 ORDER BY a;
208 SELECT b FROM t1 WHERE a>6;
209 }
211 # This block is designed to test that some malloc failures that may
212 # occur in vdbeapi.c. Specifically, if a malloc failure that occurs
213 # when converting UTF-16 text to integers and real numbers is handled
214 # correctly.
215 #
216 # This is done by retrieving a string from the database engine and
217 # manipulating it using the sqlite3_column_*** APIs. This doesn't
218 # actually return an error to the user when a malloc() fails.. That
219 # could be viewed as a bug.
220 #
221 # These tests only run if UTF-16 support is compiled in.
222 #
223 ifcapable utf16 {
224 set ::STMT {}
225 do_malloc_test 8 -tclprep {
226 set sql "SELECT '[string repeat abc 20]', '[string repeat def 20]', ?"
227 set ::STMT [sqlite3_prepare db $sql -1 X]
228 sqlite3_step $::STMT
229 if { $::tcl_platform(byteOrder)=="littleEndian" } {
230 set ::bomstr "\xFF\xFE"
231 } else {
232 set ::bomstr "\xFE\xFF"
233 }
234 append ::bomstr [encoding convertto unicode "123456789_123456789_123456789"]
235 } -tclbody {
236 sqlite3_column_text16 $::STMT 0
237 sqlite3_column_int $::STMT 0
238 sqlite3_column_text16 $::STMT 1
239 sqlite3_column_double $::STMT 1
240 set rc [sqlite3_reset $::STMT]
241 if {$rc eq "SQLITE_NOMEM"} {error "out of memory"}
242 sqlite3_bind_text16 $::STMT 1 $::bomstr 60
243 #catch {sqlite3_finalize $::STMT}
244 #if {[lindex [sqlite_malloc_stat] 2]<=0} {
245 # error "out of memory"
246 #}
247 } -cleanup {
248 if {$::STMT!=""} {
249 sqlite3_finalize $::STMT
250 set ::STMT {}
251 }
252 }
253 }
255 # This block tests that malloc() failures that occur whilst commiting
256 # a multi-file transaction are handled correctly.
257 #
258 do_malloc_test 9 -sqlprep {
259 ATTACH 'test2.db' as test2;
260 CREATE TABLE abc1(a, b, c);
261 CREATE TABLE test2.abc2(a, b, c);
262 } -sqlbody {
263 BEGIN;
264 INSERT INTO abc1 VALUES(1, 2, 3);
265 INSERT INTO abc2 VALUES(1, 2, 3);
266 COMMIT;
267 }
269 # This block tests malloc() failures that occur while opening a
270 # connection to a database.
271 do_malloc_test 10 -tclprep {
272 catch {db2 close}
273 db close
274 forcedelete test.db test.db-journal
275 sqlite3 db test.db
276 sqlite3_extended_result_codes db 1
277 db eval {CREATE TABLE abc(a, b, c)}
278 } -tclbody {
279 db close
280 sqlite3 db2 test.db
281 sqlite3_extended_result_codes db2 1
282 db2 eval {SELECT * FROM sqlite_master}
283 db2 close
284 }
286 # This block tests malloc() failures that occur within calls to
287 # sqlite3_create_function().
288 do_malloc_test 11 -tclbody {
289 set rc [sqlite3_create_function db]
290 if {[string match $rc SQLITE_OK]} {
291 set rc [sqlite3_create_aggregate db]
292 }
293 if {[string match $rc SQLITE_NOMEM]} {
294 error "out of memory"
295 }
296 }
298 do_malloc_test 12 -tclbody {
299 set sql16 [encoding convertto unicode "SELECT * FROM sqlite_master"]
300 append sql16 "\00\00"
301 set ::STMT [sqlite3_prepare16 db $sql16 -1 DUMMY]
302 sqlite3_finalize $::STMT
303 }
305 # Test malloc errors when replaying two hot journals from a 2-file
306 # transaction.
307 ifcapable crashtest&&attach {
308 do_malloc_test 13 -tclprep {
309 set rc [crashsql -delay 1 -file test2.db {
310 ATTACH 'test2.db' as aux;
311 PRAGMA cache_size = 10;
312 BEGIN;
313 CREATE TABLE aux.t2(a, b, c);
314 CREATE TABLE t1(a, b, c);
315 COMMIT;
316 }]
317 if {$rc!="1 {child process exited abnormally}"} {
318 error "Wrong error message: $rc"
319 }
320 } -tclbody {
321 db eval {ATTACH 'test2.db' as aux;}
322 set rc [catch {db eval {
323 SELECT * FROM t1;
324 SELECT * FROM t2;
325 }} err]
326 if {$rc && $err!="no such table: t1"} {
327 error $err
328 }
329 }
330 }
332 if {$tcl_platform(platform)!="windows"} {
333 do_malloc_test 14 -tclprep {
334 catch {db close}
335 sqlite3 db2 test2.db
336 sqlite3_extended_result_codes db2 1
337 db2 eval {
338 PRAGMA journal_mode = DELETE; /* For inmemory_journal permutation */
339 PRAGMA synchronous = 0;
340 CREATE TABLE t1(a, b);
341 INSERT INTO t1 VALUES(1, 2);
342 BEGIN;
343 INSERT INTO t1 VALUES(3, 4);
344 }
345 forcecopy test2.db test.db
346 forcecopy test2.db-journal test.db-journal
347 db2 close
348 } -tclbody {
349 sqlite3 db test.db
350 sqlite3_extended_result_codes db 1
352 # If an out-of-memory occurs within a call to a VFS layer function during
353 # hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit
354 # [5668] for details.
355 set rc [catch {db eval { SELECT * FROM t1 }} msg]
356 if {$msg eq "database disk image is malformed"} { set msg "out of memory" }
357 if {$rc} { error $msg }
358 set msg
359 }
360 }
362 proc string_compare {a b} {
363 return [string compare $a $b]
364 }
366 # Test for malloc() failures in sqlite3_create_collation() and
367 # sqlite3_create_collation16().
368 #
369 ifcapable utf16 {
370 do_malloc_test 15 -start 4 -tclbody {
371 db collate string_compare string_compare
372 if {[catch {add_test_collate db 1 1 1} msg]} {
373 if {$msg=="SQLITE_NOMEM"} {set msg "out of memory"}
374 error $msg
375 }
377 db complete {SELECT "hello """||'world"' [microsoft], * FROM anicetable;}
378 db complete {-- Useful comment}
380 execsql {
381 CREATE TABLE t1(a, b COLLATE string_compare);
382 INSERT INTO t1 VALUES(10, 'string');
383 INSERT INTO t1 VALUES(10, 'string2');
384 }
385 }
386 }
388 # Also test sqlite3_complete(). There are (currently) no malloc()
389 # calls in this function, but test anyway against future changes.
390 #
391 do_malloc_test 16 -tclbody {
392 db complete {SELECT "hello """||'world"' [microsoft], * FROM anicetable;}
393 db complete {-- Useful comment}
394 db eval {
395 SELECT * FROM sqlite_master;
396 }
397 }
399 # Test handling of malloc() failures in sqlite3_open16().
400 #
401 ifcapable utf16 {
402 do_malloc_test 17 -tclbody {
403 set DB2 0
404 set STMT 0
406 # open database using sqlite3_open16()
407 set filename [encoding convertto unicode test.db]
408 append filename "\x00\x00"
409 set DB2 [sqlite3_open16 $filename -unused]
410 if {0==$DB2} {
411 error "out of memory"
412 }
413 sqlite3_extended_result_codes $DB2 1
415 # Prepare statement
416 set rc [catch {sqlite3_prepare $DB2 {SELECT * FROM sqlite_master} -1 X} msg]
417 if {[sqlite3_errcode $DB2] eq "SQLITE_IOERR+12"} {
418 error "out of memory"
419 }
420 if {[regexp ".*automatic extension loading.*" [sqlite3_errmsg $DB2]]} {
421 error "out of memory"
422 }
423 if {$rc} {
424 error [string range $msg 4 end]
425 }
426 set STMT $msg
428 # Finalize statement
429 set rc [sqlite3_finalize $STMT]
430 if {$rc!="SQLITE_OK"} {
431 error [sqlite3_errmsg $DB2]
432 }
433 set STMT 0
435 # Close database
436 set rc [sqlite3_close $DB2]
437 if {$rc!="SQLITE_OK"} {
438 error [sqlite3_errmsg $DB2]
439 }
440 set DB2 0
441 } -cleanup {
442 if {$STMT!="0"} {
443 sqlite3_finalize $STMT
444 }
445 if {$DB2!="0"} {
446 set rc [sqlite3_close $DB2]
447 }
448 }
449 }
451 # Test handling of malloc() failures in sqlite3_errmsg16().
452 #
453 ifcapable utf16 {
454 do_malloc_test 18 -tclprep {
455 catch {
456 db eval "SELECT [string repeat longcolumnname 10] FROM sqlite_master"
457 }
458 } -tclbody {
459 set utf16 [sqlite3_errmsg16 [sqlite3_connection_pointer db]]
460 binary scan $utf16 c* bytes
461 if {[llength $bytes]==0} {
462 error "out of memory"
463 }
464 }
465 }
467 # This test is aimed at coverage testing. Specificly, it is supposed to
468 # cause a malloc() only used when converting between the two utf-16
469 # encodings to fail (i.e. little-endian->big-endian). It only actually
470 # hits this malloc() on little-endian hosts.
471 #
472 set static_string "\x00h\x00e\x00l\x00l\x00o"
473 for {set l 0} {$l<10} {incr l} {
474 append static_string $static_string
475 }
476 append static_string "\x00\x00"
477 do_malloc_test 19 -tclprep {
478 execsql {
479 PRAGMA encoding = "UTF16be";
480 CREATE TABLE abc(a, b, c);
481 }
482 } -tclbody {
483 unset -nocomplain ::STMT
484 set r [catch {
485 set ::STMT [sqlite3_prepare db {SELECT ?} -1 DUMMY]
486 sqlite3_bind_text16 -static $::STMT 1 $static_string 112
487 } msg]
488 if {$r} {error [string range $msg 4 end]}
489 set msg
490 } -cleanup {
491 if {[info exists ::STMT]} {
492 sqlite3_finalize $::STMT
493 }
494 }
495 unset static_string
497 # Make sure SQLITE_NOMEM is reported out on an ATTACH failure even
498 # when the malloc failure occurs within the nested parse.
499 #
500 ifcapable attach {
501 do_malloc_test 20 -tclprep {
502 db close
503 forcedelete test2.db test2.db-journal
504 sqlite3 db test2.db
505 sqlite3_extended_result_codes db 1
506 db eval {CREATE TABLE t1(x);}
507 db close
508 } -tclbody {
509 if {[catch {sqlite3 db test.db}]} {
510 error "out of memory"
511 }
512 sqlite3_extended_result_codes db 1
513 } -sqlbody {
514 ATTACH DATABASE 'test2.db' AS t2;
515 SELECT * FROM t1;
516 DETACH DATABASE t2;
517 }
518 }
520 # Test malloc failure whilst installing a foreign key.
521 #
522 ifcapable foreignkey {
523 do_malloc_test 21 -sqlbody {
524 CREATE TABLE abc(a, b, c, FOREIGN KEY(a) REFERENCES abc(b))
525 }
526 }
528 # Test malloc failure in an sqlite3_prepare_v2() call.
529 #
530 do_malloc_test 22 -tclbody {
531 set ::STMT ""
532 set r [catch {
533 set ::STMT [
534 sqlite3_prepare_v2 db "SELECT * FROM sqlite_master" -1 DUMMY
535 ]
536 } msg]
537 if {$r} {error [string range $msg 4 end]}
538 } -cleanup {
539 if {$::STMT ne ""} {
540 sqlite3_finalize $::STMT
541 set ::STMT ""
542 }
543 }
545 ifcapable {pager_pragmas} {
546 # This tests a special case - that an error that occurs while the pager
547 # is trying to recover from error-state in exclusive-access mode works.
548 #
549 do_malloc_test 23 -tclprep {
550 db eval {
551 PRAGMA cache_size = 10;
552 PRAGMA locking_mode = exclusive;
553 BEGIN;
554 CREATE TABLE abc(a, b, c);
555 CREATE INDEX abc_i ON abc(a, b, c);
556 INSERT INTO abc
557 VALUES(randstr(100,100), randstr(100,100), randstr(100,100));
558 INSERT INTO abc
559 SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
560 INSERT INTO abc
561 SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
562 INSERT INTO abc
563 SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
564 INSERT INTO abc
565 SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
566 INSERT INTO abc
567 SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
568 COMMIT;
569 }
571 # This puts the pager into error state.
572 #
573 db eval BEGIN
574 db eval {UPDATE abc SET a = 0 WHERE oid%2}
575 set ::sqlite_io_error_pending 10
576 catch {db eval {ROLLBACK}} msg
578 } -tclbody {
579 # If an out-of-memory occurs within a call to a VFS layer function during
580 # hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit
581 # [5668] for details.
582 set rc [catch {db eval { SELECT * FROM abc LIMIT 10 }} msg]
583 if {$msg eq "database disk image is malformed"} { set msg "out of memory" }
584 if {$rc} { error $msg }
585 set msg
586 } -cleanup {
587 set e [db eval {PRAGMA integrity_check}]
588 if {$e ne "ok"} {error $e}
589 }
590 }
592 ifcapable compound {
593 do_malloc_test 24 -sqlprep {
594 CREATE TABLE t1(a, b, c)
595 } -sqlbody {
596 SELECT 1 FROM t1 UNION SELECT 2 FROM t1 ORDER BY 1
597 }
598 }
600 ifcapable view&&trigger {
601 do_malloc_test 25 -sqlprep {
602 CREATE TABLE t1(a, b, c);
603 CREATE VIEW v1 AS SELECT * FROM t1;
604 CREATE TRIGGER v1t1 INSTEAD OF DELETE ON v1 BEGIN SELECT 1; END;
605 CREATE TRIGGER v1t2 INSTEAD OF INSERT ON v1 BEGIN SELECT 1; END;
606 CREATE TRIGGER v1t3 INSTEAD OF UPDATE ON v1 BEGIN SELECT 1; END;
607 } -sqlbody {
608 DELETE FROM v1 WHERE a = 1;
609 INSERT INTO v1 VALUES(1, 2, 3);
610 UPDATE v1 SET a = 1 WHERE b = 2;
611 }
612 }
614 do_malloc_test 25 -sqlprep {
615 CREATE TABLE abc(a, b, c);
616 CREATE INDEX i1 ON abc(a, b);
617 INSERT INTO abc VALUES(1, 2, 3);
618 INSERT INTO abc VALUES(4, 5, 6);
619 } -tclbody {
620 # For each UPDATE executed, the cursor used for the SELECT statement
621 # must be "saved". Because the cursor is open on an index, this requires
622 # a malloc() to allocate space to save the index key. This test case is
623 # aimed at testing the response of the library to a failure in that
624 # particular malloc() call.
625 db eval {SELECT a FROM abc ORDER BY a} {
626 db eval {UPDATE abc SET b = b - 1 WHERE a = $a}
627 }
628 }
630 # This test is designed to test a specific juncture in the sqlite code.
631 # The database set up by -sqlprep script contains a single table B-Tree
632 # of height 2. In the -tclbody script, the existing database connection
633 # is closed and a new one opened and used to insert a new row into the
634 # table B-Tree. By using a new connection, the outcome of a malloc()
635 # failure while seeking to the right-hand side of the B-Tree to insert
636 # a new record can be tested.
637 #
638 do_malloc_test 26 -sqlprep {
639 BEGIN;
640 CREATE TABLE t1(a, b);
641 INSERT INTO t1 VALUES(1, randomblob(210));
642 INSERT INTO t1 VALUES(1, randomblob(210));
643 INSERT INTO t1 VALUES(1, randomblob(210));
644 INSERT INTO t1 VALUES(1, randomblob(210));
645 INSERT INTO t1 VALUES(1, randomblob(210));
646 COMMIT;
647 } -tclbody {
648 db close
649 sqlite3 db test.db
650 db eval { INSERT INTO t1 VALUES(1, randomblob(210)) }
651 }
653 # Test that no memory is leaked following a malloc() failure in
654 # sqlite3_initialize().
655 #
656 do_malloc_test 27 -tclprep {
657 db close
658 sqlite3_shutdown
659 } -tclbody {
660 set rc [sqlite3_initialize]
661 if {$rc == "SQLITE_NOMEM"} {
662 error "out of memory"
663 }
664 }
665 autoinstall_test_functions
667 # Test that malloc failures that occur while processing INDEXED BY
668 # clauses are handled correctly.
669 do_malloc_test 28 -sqlprep {
670 CREATE TABLE t1(a, b);
671 CREATE INDEX i1 ON t1(a);
672 CREATE VIEW v1 AS SELECT * FROM t1 INDEXED BY i1 WHERE a = 10;
673 } -sqlbody {
674 SELECT * FROM t1 INDEXED BY i1 ORDER BY a;
675 SELECT * FROM v1;
676 }
678 do_malloc_test 29 -sqlprep {
679 CREATE TABLE t1(a TEXT, b TEXT);
680 } -sqlbody {
681 INSERT INTO t1 VALUES(1, -234);
682 INSERT INTO t1 SELECT * FROM t1 UNION ALL SELECT * FROM t1;
683 }
685 do_malloc_test 30 -tclprep {
686 db eval {
687 CREATE TABLE t1(x PRIMARY KEY);
688 INSERT INTO t1 VALUES(randstr(500,500));
689 INSERT INTO t1 VALUES(randstr(500,500));
690 INSERT INTO t1 VALUES(randstr(500,500));
691 }
692 db close
693 sqlite3 db test.db
695 # The DELETE command in the following block moves the overflow pages that
696 # are part of the primary key index to the free-list. But it does not
697 # actually load the content of the pages. This leads to the peculiar
698 # situation where cache entries exist, but are not populated with data.
699 # They are populated next time they are requested by the b-tree layer.
700 #
701 db eval {
702 BEGIN;
703 DELETE FROM t1;
704 ROLLBACK;
705 }
706 } -sqlbody {
707 -- This statement requires the 'no-content' pages loaded by the DELETE
708 -- statement above. When requesting the pages, the content is loaded
709 -- from the database file. The point of this test case is to test handling
710 -- of malloc errors (including SQLITE_IOERR_NOMEM errors) when loading
711 -- the content.
712 SELECT * FROM t1 ORDER BY x;
713 }
715 # After committing a transaction in persistent-journal mode, if a journal
716 # size limit is configured SQLite may attempt to truncate the journal file.
717 # This test verifies the libraries response to a malloc() failure during
718 # this operation.
719 #
720 do_malloc_test 31 -sqlprep {
721 PRAGMA journal_mode = persist;
722 PRAGMA journal_size_limit = 1024;
723 CREATE TABLE t1(a PRIMARY KEY, b);
724 } -sqlbody {
725 INSERT INTO t1 VALUES(1, 2);
726 }
728 # When written, this test provoked an obscure change-counter bug.
729 #
730 # If, when running in exclusive mode, a malloc() failure occurs
731 # after the database file change-counter has been written but
732 # before the transaction has been committed, then the transaction
733 # is automatically rolled back. However, internally the
734 # Pager.changeCounterDone flag was being left set. This means
735 # that if the same connection attempts another transaction following
736 # the malloc failure and rollback, the change counter will not
737 # be updated. This could corrupt another processes cache.
738 #
739 do_malloc_test 32 -tclprep {
740 # Build a small database containing an indexed table.
741 #
742 db eval {
743 PRAGMA locking_mode = normal;
744 BEGIN;
745 CREATE TABLE t1(a PRIMARY KEY, b);
746 INSERT INTO t1 VALUES(1, 'one');
747 INSERT INTO t1 VALUES(2, 'two');
748 INSERT INTO t1 VALUES(3, 'three');
749 COMMIT;
750 PRAGMA locking_mode = exclusive;
751 }
753 # Open a second database connection. Load the table (but not index)
754 # into the second connections pager cache.
755 #
756 sqlite3 db2 test.db
757 db2 eval {
758 PRAGMA locking_mode = normal;
759 SELECT b FROM t1;
760 }
762 } -tclbody {
763 # Running in exclusive mode, perform a database transaction that
764 # modifies both the database table and index. For iterations where
765 # the malloc failure occurs after updating the change counter but
766 # before committing the transaction, this should result in the
767 # transaction being rolled back but the changeCounterDone flag
768 # left set.
769 #
770 db eval { UPDATE t1 SET a = a + 3 }
771 } -cleanup {
773 # Perform another transaction using the first connection. Unlock
774 # the database after doing so. If this is one of the right iterations,
775 # then this should result in the database contents being updated but
776 # the change-counter left as it is.
777 #
778 db eval {
779 PRAGMA locking_mode = normal;
780 UPDATE t1 SET a = a + 3;
781 }
783 # Now do an integrity check with the second connection. The second
784 # connection still has the database table in its cache. If this is
785 # one of the magic iterations and the change counter was not modified,
786 # then it won't realize that the cached data is out of date. Since
787 # the cached data won't match the up to date index data read from
788 # the database file, the integrity check should fail.
789 #
790 set zRepeat "transient"
791 if {$::iRepeat} {set zRepeat "persistent"}
792 do_test malloc-32.$zRepeat.${::n}.integrity {
793 execsql {PRAGMA integrity_check} db2
794 } {ok}
795 db2 close
796 }
798 # The following two OOM tests verify that OOM handling works in the
799 # code used to optimize "SELECT count(*) FROM <tbl>".
800 #
801 do_malloc_test 33 -tclprep {
802 db eval { PRAGMA cache_size = 10 }
803 db transaction {
804 db eval { CREATE TABLE abc(a, b) }
805 for {set i 0} {$i<500} {incr i} {
806 db eval {INSERT INTO abc VALUES(randstr(100,100), randstr(1000,1000))}
807 }
808 }
809 } -sqlbody {
810 SELECT count(*) FROM abc;
811 }
812 do_malloc_test 34 -tclprep {
813 db eval { PRAGMA cache_size = 10 }
814 db transaction {
815 db eval { CREATE TABLE abc(a PRIMARY KEY, b) }
816 for {set i 0} {$i<500} {incr i} {
817 db eval {INSERT INTO abc VALUES(randstr(100,100), randstr(1000,1000))}
818 }
819 }
820 } -sqlbody {
821 SELECT count(*) FROM abc;
822 }
824 proc f {args} { error "Quite a long error!" }
825 do_malloc_test 35 -tclprep {
826 db func f f
827 set ::STMT [sqlite3_prepare db "SELECT f()" -1 DUMMY]
828 sqlite3_step $::STMT
829 } -tclbody {
830 sqlite3_finalize $::STMT
831 } -cleanup {
832 # At one point an assert( !db->mallocFailed ) could fail in the following
833 # call to sqlite3_errmsg(). Because sqlite3_finalize() had failed to clear
834 # the flag before returning.
835 sqlite3_errmsg16 db
836 }
838 do_malloc_test 36 -sqlprep {
839 CREATE TABLE t1(a, b);
840 INSERT INTO t1 VALUES(1, 2);
841 INSERT INTO t1 VALUES(3, 4);
842 } -sqlbody {
843 SELECT test_agg_errmsg16(), group_concat(a) FROM t1
844 }
846 # At one point, if an OOM occurred immediately after obtaining a shared lock
847 # on the database file, the file remained locked. This test case ensures
848 # that bug has been fixed.i
849 if {[db eval {PRAGMA locking_mode}]!="exclusive"} {
850 do_malloc_test 37 -tclprep {
851 sqlite3 db2 test.db
852 execsql {
853 CREATE TABLE t1(a, b);
854 INSERT INTO t1 VALUES(1, 2);
855 } db2
856 } -sqlbody {
857 SELECT * FROM t1;
858 } -cleanup {
859 # Try to write to the database using connection [db2]. If connection [db]
860 # has correctly released the shared lock, this write attempt should
861 # succeed. If [db] has not released the lock, this should hit an
862 # SQLITE_BUSY error.
863 do_test malloc-36.$zRepeat.${::n}.unlocked {
864 execsql {INSERT INTO t1 VALUES(3, 4)} db2
865 } {}
866 db2 close
867 }
868 catch { db2 close }
869 }
872 # Test that if an OOM error occurs, aux-data is still correctly destroyed.
873 # This test case was causing either a memory-leak or an assert() failure
874 # at one point, depending on the configuration.
875 #
876 do_malloc_test 39 -tclprep {
877 sqlite3 db test.db
878 } -sqlbody {
879 SELECT test_auxdata('abc', 'def');
880 } -cleanup {
881 db close
882 }
884 reset_db
885 add_test_utf16bin_collate db
886 do_execsql_test 40.1 {
887 CREATE TABLE t1(a);
888 INSERT INTO t1 VALUES('fghij');
889 INSERT INTO t1 VALUES('pqrst');
890 INSERT INTO t1 VALUES('abcde');
891 INSERT INTO t1 VALUES('uvwxy');
892 INSERT INTO t1 VALUES('klmno');
893 }
894 do_execsql_test 40.2 {
895 SELECT * FROM t1 ORDER BY 1 COLLATE utf16bin;
896 } {abcde fghij klmno pqrst uvwxy}
897 do_faultsim_test 40.3 -faults oom-trans* -body {
898 execsql {
899 SELECT * FROM t1 ORDER BY 1 COLLATE utf16bin;
900 }
901 } -test {
902 faultsim_test_result {0 {abcde fghij klmno pqrst uvwxy}}
903 faultsim_integrity_check
904 }
906 reset_db
907 add_test_utf16bin_collate db
908 set big [string repeat x 200]
909 do_execsql_test 41.1 {
910 DROP TABLE IF EXISTS t1;
911 CREATE TABLE t1(a COLLATE utf16bin);
912 INSERT INTO t1 VALUES('fghij' || $::big);
913 INSERT INTO t1 VALUES('pqrst' || $::big);
914 INSERT INTO t1 VALUES('abcde' || $::big);
915 INSERT INTO t1 VALUES('uvwxy' || $::big);
916 INSERT INTO t1 VALUES('klmno' || $::big);
917 CREATE INDEX i1 ON t1(a);
918 }
919 do_faultsim_test 41.2 -faults oom* -body {
920 execsql { SELECT * FROM t1 WHERE a = ('abcde' || $::big)}
921 } -test {
922 faultsim_test_result [list 0 "abcde$::big"]
923 faultsim_integrity_check
924 }
926 # Ensure that no file descriptors were leaked.
927 do_test malloc-99.X {
928 catch {db close}
929 set sqlite_open_file_count
930 } {0}
932 puts open-file-count=$sqlite_open_file_count
933 finish_test