status-im
/
sqlcipher
mirror of https://github.com/status-im/sqlcipher.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
sqlcipher/test/malloc.test

891 lines
26 KiB
Plaintext
Raw Blame History

# 2001 September 15
#
# The author disclaims copyright to this source code. In place of
# a legal notice, here is a blessing:
#
# May you do good and not evil.
# May you find forgiveness for yourself and forgive others.
# May you share freely, never taking more than you give.
#
#***********************************************************************
#
# This file attempts to check the behavior of the SQLite library in
# an out-of-memory situation. When compiled with -DSQLITE_DEBUG=1,
# the SQLite library accepts a special command (sqlite3_memdebug_fail N C)
# which causes the N-th malloc to fail. This special feature is used
# to see what happens in the library if a malloc were to really fail
# due to an out-of-memory situation.
#
# $Id: malloc.test,v 1.81 2009/06/24 13:13:45 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# Only run these tests if memory debugging is turned on.
#
source $testdir/malloc_common.tcl
if {!$MEMDEBUG} {
puts "Skipping malloc tests: not compiled with -DSQLITE_MEMDEBUG..."
finish_test
return
}
# Do a couple of memory dumps just to exercise the memory dump logic
# that that we can say that we have.
#
puts stderr "This is a test. Ignore the error that follows:"
sqlite3_memdebug_dump $testdir
puts "Memory dump to file memdump.txt..."
sqlite3_memdebug_dump memdump.txt
ifcapable bloblit&&subquery {
do_malloc_test 1 -tclprep {
db close
} -tclbody {
if {[catch {sqlite3 db test.db}]} {
error "out of memory"
}
sqlite3_extended_result_codes db 1
} -sqlbody {
DROP TABLE IF EXISTS t1;
CREATE TABLE t1(
a int, b float, c double, d text, e varchar(20),
primary key(a,b,c)
);
CREATE INDEX i1 ON t1(a,b);
INSERT INTO t1 VALUES(1,2.3,4.5,'hi',x'746865726500');
INSERT INTO t1 VALUES(6,7.0,0.8,'hello','out yonder');
SELECT * FROM t1;
SELECT avg(b) FROM t1 GROUP BY a HAVING b>20.0;
DELETE FROM t1 WHERE a IN (SELECT min(a) FROM t1);
SELECT count(*), group_concat(e) FROM t1;
SELECT b FROM t1 ORDER BY 1 COLLATE nocase;
}
}
# Ensure that no file descriptors were leaked.
do_test malloc-1.X {
catch {db close}
set sqlite_open_file_count
} {0}
ifcapable subquery {
do_malloc_test 2 -sqlbody {
CREATE TABLE t1(a int, b int default 'abc', c int default 1);
CREATE INDEX i1 ON t1(a,b);
INSERT INTO t1 VALUES(1,1,'99 abcdefghijklmnopqrstuvwxyz');
INSERT INTO t1 VALUES(2,4,'98 abcdefghijklmnopqrstuvwxyz');
INSERT INTO t1 VALUES(3,9,'97 abcdefghijklmnopqrstuvwxyz');
INSERT INTO t1 VALUES(4,16,'96 abcdefghijklmnopqrstuvwxyz');
INSERT INTO t1 VALUES(5,25,'95 abcdefghijklmnopqrstuvwxyz');
INSERT INTO t1 VALUES(6,36,'94 abcdefghijklmnopqrstuvwxyz');
SELECT 'stuff', count(*) as 'other stuff', max(a+10) FROM t1;
UPDATE t1 SET b=b||b||b||b;
UPDATE t1 SET b=a WHERE a in (10,12,22);
INSERT INTO t1(c,b,a) VALUES(20,10,5);
INSERT INTO t1 SELECT * FROM t1
WHERE a IN (SELECT a FROM t1 WHERE a<10);
DELETE FROM t1 WHERE a>=10;
DROP INDEX i1;
DELETE FROM t1;
}
}
# Ensure that no file descriptors were leaked.
do_test malloc-2.X {
catch {db close}
set sqlite_open_file_count
} {0}
do_malloc_test 3 -sqlbody {
BEGIN TRANSACTION;
CREATE TABLE t1(a int, b int, c int);
CREATE INDEX i1 ON t1(a,b);
INSERT INTO t1 VALUES(1,1,99);
INSERT INTO t1 VALUES(2,4,98);
INSERT INTO t1 VALUES(3,9,97);
INSERT INTO t1 VALUES(4,16,96);
INSERT INTO t1 VALUES(5,25,95);
INSERT INTO t1 VALUES(6,36,94);
INSERT INTO t1(c,b,a) VALUES(20,10,5);
DELETE FROM t1 WHERE a>=10;
DROP INDEX i1;
DELETE FROM t1;
ROLLBACK;
}
# Ensure that no file descriptors were leaked.
do_test malloc-3.X {
catch {db close}
set sqlite_open_file_count
} {0}
ifcapable subquery {
do_malloc_test 4 -sqlbody {
BEGIN TRANSACTION;
CREATE TABLE t1(a int, b int, c int);
CREATE INDEX i1 ON t1(a,b);
INSERT INTO t1 VALUES(1,1,99);
INSERT INTO t1 VALUES(2,4,98);
INSERT INTO t1 VALUES(3,9,97);
INSERT INTO t1 VALUES(4,16,96);
INSERT INTO t1 VALUES(5,25,95);
INSERT INTO t1 VALUES(6,36,94);
UPDATE t1 SET b=a WHERE a in (10,12,22);
INSERT INTO t1 SELECT * FROM t1
WHERE a IN (SELECT a FROM t1 WHERE a<10);
DROP INDEX i1;
DELETE FROM t1;
COMMIT;
}
}
# Ensure that no file descriptors were leaked.
do_test malloc-4.X {
catch {db close}
set sqlite_open_file_count
} {0}
ifcapable trigger {
do_malloc_test 5 -sqlbody {
BEGIN TRANSACTION;
CREATE TABLE t1(a,b);
CREATE TABLE t2(x,y);
CREATE TRIGGER r1 AFTER INSERT ON t1 WHEN new.a = 2 BEGIN
INSERT INTO t2(x,y) VALUES(new.rowid,1);
INSERT INTO t2(x,y) SELECT * FROM t2;
INSERT INTO t2 SELECT * FROM t2;
UPDATE t2 SET y=y+1 WHERE x=new.rowid;
SELECT 123;
DELETE FROM t2 WHERE x=new.rowid;
END;
INSERT INTO t1(a,b) VALUES(2,3);
COMMIT;
}
}
# Ensure that no file descriptors were leaked.
do_test malloc-5.X {
catch {db close}
set sqlite_open_file_count
} {0}
ifcapable vacuum {
do_malloc_test 6 -sqlprep {
BEGIN TRANSACTION;
CREATE TABLE t1(a);
INSERT INTO t1 VALUES(1);
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
INSERT INTO t1 SELECT a*2 FROM t1;
DELETE FROM t1 where rowid%5 = 0;
COMMIT;
} -sqlbody {
VACUUM;
}
}
autoinstall_test_functions
do_malloc_test 7 -sqlprep {
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
INSERT INTO t1 VALUES(3, 4);
INSERT INTO t1 VALUES(5, 6);
INSERT INTO t1 VALUES(7, randstr(1200,1200));
} -sqlbody {
SELECT min(a) FROM t1 WHERE a<6 GROUP BY b;
SELECT a FROM t1 WHERE a<6 ORDER BY a;
SELECT b FROM t1 WHERE a>6;
}
# This block is designed to test that some malloc failures that may
# occur in vdbeapi.c. Specifically, if a malloc failure that occurs
# when converting UTF-16 text to integers and real numbers is handled
# correctly.
#
# This is done by retrieving a string from the database engine and
# manipulating it using the sqlite3_column_*** APIs. This doesn't
# actually return an error to the user when a malloc() fails.. That
# could be viewed as a bug.
#
# These tests only run if UTF-16 support is compiled in.
#
ifcapable utf16 {
set ::STMT {}
do_malloc_test 8 -tclprep {
set sql "SELECT '[string repeat abc 20]', '[string repeat def 20]', ?"
set ::STMT [sqlite3_prepare db $sql -1 X]
sqlite3_step $::STMT
if { $::tcl_platform(byteOrder)=="littleEndian" } {
set ::bomstr "\xFF\xFE"
} else {
set ::bomstr "\xFE\xFF"
}
append ::bomstr [encoding convertto unicode "123456789_123456789_123456789"]
} -tclbody {
sqlite3_column_text16 $::STMT 0
sqlite3_column_int $::STMT 0
sqlite3_column_text16 $::STMT 1
sqlite3_column_double $::STMT 1
set rc [sqlite3_reset $::STMT]
if {$rc eq "SQLITE_NOMEM"} {error "out of memory"}
sqlite3_bind_text16 $::STMT 1 $::bomstr 60
#catch {sqlite3_finalize $::STMT}
#if {[lindex [sqlite_malloc_stat] 2]<=0} {
# error "out of memory"
#}
} -cleanup {
if {$::STMT!=""} {
sqlite3_finalize $::STMT
set ::STMT {}
}
}
}
# This block tests that malloc() failures that occur whilst commiting
# a multi-file transaction are handled correctly.
#
do_malloc_test 9 -sqlprep {
ATTACH 'test2.db' as test2;
CREATE TABLE abc1(a, b, c);
CREATE TABLE test2.abc2(a, b, c);
} -sqlbody {
BEGIN;
INSERT INTO abc1 VALUES(1, 2, 3);
INSERT INTO abc2 VALUES(1, 2, 3);
COMMIT;
}
# This block tests malloc() failures that occur while opening a
# connection to a database.
do_malloc_test 10 -tclprep {
catch {db2 close}
db close
forcedelete test.db test.db-journal
sqlite3 db test.db
sqlite3_extended_result_codes db 1
db eval {CREATE TABLE abc(a, b, c)}
} -tclbody {
db close
sqlite3 db2 test.db
sqlite3_extended_result_codes db2 1
db2 eval {SELECT * FROM sqlite_master}
db2 close
}
# This block tests malloc() failures that occur within calls to
# sqlite3_create_function().
do_malloc_test 11 -tclbody {
set rc [sqlite3_create_function db]
if {[string match $rc SQLITE_OK]} {
set rc [sqlite3_create_aggregate db]
}
if {[string match $rc SQLITE_NOMEM]} {
error "out of memory"
}
}
do_malloc_test 12 -tclbody {
set sql16 [encoding convertto unicode "SELECT * FROM sqlite_master"]
append sql16 "\00\00"
set ::STMT [sqlite3_prepare16 db $sql16 -1 DUMMY]
sqlite3_finalize $::STMT
}
# Test malloc errors when replaying two hot journals from a 2-file
# transaction.
ifcapable crashtest&&attach {
do_malloc_test 13 -tclprep {
set rc [crashsql -delay 1 -file test2.db {
ATTACH 'test2.db' as aux;
PRAGMA cache_size = 10;
BEGIN;
CREATE TABLE aux.t2(a, b, c);
CREATE TABLE t1(a, b, c);
COMMIT;
}]
if {$rc!="1 {child process exited abnormally}"} {
error "Wrong error message: $rc"
}
} -tclbody {
db eval {ATTACH 'test2.db' as aux;}
set rc [catch {db eval {
SELECT * FROM t1;
SELECT * FROM t2;
}} err]
if {$rc && $err!="no such table: t1"} {
error $err
}
}
}
if {$tcl_platform(platform)!="windows"} {
do_malloc_test 14 -tclprep {
catch {db close}
sqlite3 db2 test2.db
sqlite3_extended_result_codes db2 1
db2 eval {
PRAGMA journal_mode = DELETE; /* For inmemory_journal permutation */
PRAGMA synchronous = 0;
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
BEGIN;
INSERT INTO t1 VALUES(3, 4);
}
forcecopy test2.db test.db
forcecopy test2.db-journal test.db-journal
db2 close
} -tclbody {
sqlite3 db test.db
sqlite3_extended_result_codes db 1
# If an out-of-memory occurs within a call to a VFS layer function during
# hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit
# [5668] for details.
set rc [catch {db eval { SELECT * FROM t1 }} msg]
if {$msg eq "database disk image is malformed"} { set msg "out of memory" }
if {$rc} { error $msg }
set msg
}
}
proc string_compare {a b} {
return [string compare $a $b]
}
# Test for malloc() failures in sqlite3_create_collation() and
# sqlite3_create_collation16().
#
ifcapable utf16 {
do_malloc_test 15 -start 4 -tclbody {
db collate string_compare string_compare
if {[catch {add_test_collate db 1 1 1} msg]} {
if {$msg=="SQLITE_NOMEM"} {set msg "out of memory"}
error $msg
}
db complete {SELECT "hello """||'world"' [microsoft], * FROM anicetable;}
db complete {-- Useful comment}
execsql {
CREATE TABLE t1(a, b COLLATE string_compare);
INSERT INTO t1 VALUES(10, 'string');
INSERT INTO t1 VALUES(10, 'string2');
}
}
}
# Also test sqlite3_complete(). There are (currently) no malloc()
# calls in this function, but test anyway against future changes.
#
do_malloc_test 16 -tclbody {
db complete {SELECT "hello """||'world"' [microsoft], * FROM anicetable;}
db complete {-- Useful comment}
db eval {
SELECT * FROM sqlite_master;
}
}
# Test handling of malloc() failures in sqlite3_open16().
#
ifcapable utf16 {
do_malloc_test 17 -tclbody {
set DB2 0
set STMT 0
# open database using sqlite3_open16()
set filename [encoding convertto unicode test.db]
append filename "\x00\x00"
set DB2 [sqlite3_open16 $filename -unused]
if {0==$DB2} {
error "out of memory"
}
sqlite3_extended_result_codes $DB2 1
# Prepare statement
set rc [catch {sqlite3_prepare $DB2 {SELECT * FROM sqlite_master} -1 X} msg]
if {[sqlite3_errcode $DB2] eq "SQLITE_IOERR+12"} {
error "out of memory"
}
if {[regexp ".*automatic extension loading.*" [sqlite3_errmsg $DB2]]} {
error "out of memory"
}
if {$rc} {
error [string range $msg 4 end]
}
set STMT $msg
# Finalize statement
set rc [sqlite3_finalize $STMT]
if {$rc!="SQLITE_OK"} {
error [sqlite3_errmsg $DB2]
}
set STMT 0
# Close database
set rc [sqlite3_close $DB2]
if {$rc!="SQLITE_OK"} {
error [sqlite3_errmsg $DB2]
}
set DB2 0
} -cleanup {
if {$STMT!="0"} {
sqlite3_finalize $STMT
}
if {$DB2!="0"} {
set rc [sqlite3_close $DB2]
}
}
}
# Test handling of malloc() failures in sqlite3_errmsg16().
#
ifcapable utf16 {
do_malloc_test 18 -tclprep {
catch {
db eval "SELECT [string repeat longcolumnname 10] FROM sqlite_master"
}
} -tclbody {
set utf16 [sqlite3_errmsg16 [sqlite3_connection_pointer db]]
binary scan $utf16 c* bytes
if {[llength $bytes]==0} {
error "out of memory"
}
}
}
# This test is aimed at coverage testing. Specificly, it is supposed to
# cause a malloc() only used when converting between the two utf-16
# encodings to fail (i.e. little-endian->big-endian). It only actually
# hits this malloc() on little-endian hosts.
#
set static_string "\x00h\x00e\x00l\x00l\x00o"
for {set l 0} {$l<10} {incr l} {
append static_string $static_string
}
append static_string "\x00\x00"
do_malloc_test 19 -tclprep {
execsql {
PRAGMA encoding = "UTF16be";
CREATE TABLE abc(a, b, c);
}
} -tclbody {
unset -nocomplain ::STMT
set r [catch {
set ::STMT [sqlite3_prepare db {SELECT ?} -1 DUMMY]
sqlite3_bind_text16 -static $::STMT 1 $static_string 112
} msg]
if {$r} {error [string range $msg 4 end]}
set msg
} -cleanup {
if {[info exists ::STMT]} {
sqlite3_finalize $::STMT
}
}
unset static_string
# Make sure SQLITE_NOMEM is reported out on an ATTACH failure even
# when the malloc failure occurs within the nested parse.
#
ifcapable attach {
do_malloc_test 20 -tclprep {
db close
forcedelete test2.db test2.db-journal
sqlite3 db test2.db
sqlite3_extended_result_codes db 1
db eval {CREATE TABLE t1(x);}
db close
} -tclbody {
if {[catch {sqlite3 db test.db}]} {
error "out of memory"
}
sqlite3_extended_result_codes db 1
} -sqlbody {
ATTACH DATABASE 'test2.db' AS t2;
SELECT * FROM t1;
DETACH DATABASE t2;
}
}
# Test malloc failure whilst installing a foreign key.
#
ifcapable foreignkey {
do_malloc_test 21 -sqlbody {
CREATE TABLE abc(a, b, c, FOREIGN KEY(a) REFERENCES abc(b))
}
}
# Test malloc failure in an sqlite3_prepare_v2() call.
#
do_malloc_test 22 -tclbody {
set ::STMT ""
set r [catch {
set ::STMT [
sqlite3_prepare_v2 db "SELECT * FROM sqlite_master" -1 DUMMY
]
} msg]
if {$r} {error [string range $msg 4 end]}
} -cleanup {
if {$::STMT ne ""} {
sqlite3_finalize $::STMT
set ::STMT ""
}
}
ifcapable {pager_pragmas} {
# This tests a special case - that an error that occurs while the pager
# is trying to recover from error-state in exclusive-access mode works.
#
do_malloc_test 23 -tclprep {
db eval {
PRAGMA cache_size = 10;
PRAGMA locking_mode = exclusive;
BEGIN;
CREATE TABLE abc(a, b, c);
CREATE INDEX abc_i ON abc(a, b, c);
INSERT INTO abc
VALUES(randstr(100,100), randstr(100,100), randstr(100,100));
INSERT INTO abc
SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
INSERT INTO abc
SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
INSERT INTO abc
SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
INSERT INTO abc
SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
INSERT INTO abc
SELECT randstr(100,100), randstr(100,100), randstr(100,100) FROM abc;
COMMIT;
}
# This puts the pager into error state.
#
db eval BEGIN
db eval {UPDATE abc SET a = 0 WHERE oid%2}
set ::sqlite_io_error_pending 10
catch {db eval {ROLLBACK}} msg
} -tclbody {
# If an out-of-memory occurs within a call to a VFS layer function during
# hot-journal rollback, sqlite will report SQLITE_CORRUPT. See commit
# [5668] for details.
set rc [catch {db eval { SELECT * FROM abc LIMIT 10 }} msg]
if {$msg eq "database disk image is malformed"} { set msg "out of memory" }
if {$rc} { error $msg }
set msg
} -cleanup {
set e [db eval {PRAGMA integrity_check}]
if {$e ne "ok"} {error $e}
}
}
ifcapable compound {
do_malloc_test 24 -sqlprep {
CREATE TABLE t1(a, b, c)
} -sqlbody {
SELECT 1 FROM t1 UNION SELECT 2 FROM t1 ORDER BY 1
}
}
ifcapable view&&trigger {
do_malloc_test 25 -sqlprep {
CREATE TABLE t1(a, b, c);
CREATE VIEW v1 AS SELECT * FROM t1;
CREATE TRIGGER v1t1 INSTEAD OF DELETE ON v1 BEGIN SELECT 1; END;
CREATE TRIGGER v1t2 INSTEAD OF INSERT ON v1 BEGIN SELECT 1; END;
CREATE TRIGGER v1t3 INSTEAD OF UPDATE ON v1 BEGIN SELECT 1; END;
} -sqlbody {
DELETE FROM v1 WHERE a = 1;
INSERT INTO v1 VALUES(1, 2, 3);
UPDATE v1 SET a = 1 WHERE b = 2;
}
}
do_malloc_test 25 -sqlprep {
CREATE TABLE abc(a, b, c);
CREATE INDEX i1 ON abc(a, b);
INSERT INTO abc VALUES(1, 2, 3);
INSERT INTO abc VALUES(4, 5, 6);
} -tclbody {
# For each UPDATE executed, the cursor used for the SELECT statement
# must be "saved". Because the cursor is open on an index, this requires
# a malloc() to allocate space to save the index key. This test case is
# aimed at testing the response of the library to a failure in that
# particular malloc() call.
db eval {SELECT a FROM abc ORDER BY a} {
db eval {UPDATE abc SET b = b - 1 WHERE a = $a}
}
}
# This test is designed to test a specific juncture in the sqlite code.
# The database set up by -sqlprep script contains a single table B-Tree
# of height 2. In the -tclbody script, the existing database connection
# is closed and a new one opened and used to insert a new row into the
# table B-Tree. By using a new connection, the outcome of a malloc()
# failure while seeking to the right-hand side of the B-Tree to insert
# a new record can be tested.
#
do_malloc_test 26 -sqlprep {
BEGIN;
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, randomblob(210));
INSERT INTO t1 VALUES(1, randomblob(210));
INSERT INTO t1 VALUES(1, randomblob(210));
INSERT INTO t1 VALUES(1, randomblob(210));
INSERT INTO t1 VALUES(1, randomblob(210));
COMMIT;
} -tclbody {
db close
sqlite3 db test.db
db eval { INSERT INTO t1 VALUES(1, randomblob(210)) }
}
# Test that no memory is leaked following a malloc() failure in
# sqlite3_initialize().
#
do_malloc_test 27 -tclprep {
db close
sqlite3_shutdown
} -tclbody {
set rc [sqlite3_initialize]
if {$rc == "SQLITE_NOMEM"} {
error "out of memory"
}
}
autoinstall_test_functions
# Test that malloc failures that occur while processing INDEXED BY
# clauses are handled correctly.
do_malloc_test 28 -sqlprep {
CREATE TABLE t1(a, b);
CREATE INDEX i1 ON t1(a);
CREATE VIEW v1 AS SELECT * FROM t1 INDEXED BY i1 WHERE a = 10;
} -sqlbody {
SELECT * FROM t1 INDEXED BY i1 ORDER BY a;
SELECT * FROM v1;
}
do_malloc_test 29 -sqlprep {
CREATE TABLE t1(a TEXT, b TEXT);
} -sqlbody {
INSERT INTO t1 VALUES(1, -234);
INSERT INTO t1 SELECT * FROM t1 UNION ALL SELECT * FROM t1;
}
do_malloc_test 30 -tclprep {
db eval {
CREATE TABLE t1(x PRIMARY KEY);
INSERT INTO t1 VALUES(randstr(500,500));
INSERT INTO t1 VALUES(randstr(500,500));
INSERT INTO t1 VALUES(randstr(500,500));
}
db close
sqlite3 db test.db
# The DELETE command in the following block moves the overflow pages that
# are part of the primary key index to the free-list. But it does not
# actually load the content of the pages. This leads to the peculiar
# situation where cache entries exist, but are not populated with data.
# They are populated next time they are requested by the b-tree layer.
#
db eval {
BEGIN;
DELETE FROM t1;
ROLLBACK;
}
} -sqlbody {
-- This statement requires the 'no-content' pages loaded by the DELETE
-- statement above. When requesting the pages, the content is loaded
-- from the database file. The point of this test case is to test handling
-- of malloc errors (including SQLITE_IOERR_NOMEM errors) when loading
-- the content.
SELECT * FROM t1 ORDER BY x;
}
# After committing a transaction in persistent-journal mode, if a journal
# size limit is configured SQLite may attempt to truncate the journal file.
# This test verifies the libraries response to a malloc() failure during
# this operation.
#
do_malloc_test 31 -sqlprep {
PRAGMA journal_mode = persist;
PRAGMA journal_size_limit = 1024;
CREATE TABLE t1(a PRIMARY KEY, b);
} -sqlbody {
INSERT INTO t1 VALUES(1, 2);
}
# When written, this test provoked an obscure change-counter bug.
#
# If, when running in exclusive mode, a malloc() failure occurs
# after the database file change-counter has been written but
# before the transaction has been committed, then the transaction
# is automatically rolled back. However, internally the
# Pager.changeCounterDone flag was being left set. This means
# that if the same connection attempts another transaction following
# the malloc failure and rollback, the change counter will not
# be updated. This could corrupt another processes cache.
#
do_malloc_test 32 -tclprep {
# Build a small database containing an indexed table.
#
db eval {
PRAGMA locking_mode = normal;
BEGIN;
CREATE TABLE t1(a PRIMARY KEY, b);
INSERT INTO t1 VALUES(1, 'one');
INSERT INTO t1 VALUES(2, 'two');
INSERT INTO t1 VALUES(3, 'three');
COMMIT;
PRAGMA locking_mode = exclusive;
}
# Open a second database connection. Load the table (but not index)
# into the second connections pager cache.
#
sqlite3 db2 test.db
db2 eval {
PRAGMA locking_mode = normal;
SELECT b FROM t1;
}
} -tclbody {
# Running in exclusive mode, perform a database transaction that
# modifies both the database table and index. For iterations where
# the malloc failure occurs after updating the change counter but
# before committing the transaction, this should result in the
# transaction being rolled back but the changeCounterDone flag
# left set.
#
db eval { UPDATE t1 SET a = a + 3 }
} -cleanup {
# Perform another transaction using the first connection. Unlock
# the database after doing so. If this is one of the right iterations,
# then this should result in the database contents being updated but
# the change-counter left as it is.
#
db eval {
PRAGMA locking_mode = normal;
UPDATE t1 SET a = a + 3;
}
# Now do an integrity check with the second connection. The second
# connection still has the database table in its cache. If this is
# one of the magic iterations and the change counter was not modified,
# then it won't realize that the cached data is out of date. Since
# the cached data won't match the up to date index data read from
# the database file, the integrity check should fail.
#
set zRepeat "transient"
if {$::iRepeat} {set zRepeat "persistent"}
do_test malloc-32.$zRepeat.${::n}.integrity {
execsql {PRAGMA integrity_check} db2
} {ok}
db2 close
}
# The following two OOM tests verify that OOM handling works in the
# code used to optimize "SELECT count(*) FROM <tbl>".
#
do_malloc_test 33 -tclprep {
db eval { PRAGMA cache_size = 10 }
db transaction {
db eval { CREATE TABLE abc(a, b) }
for {set i 0} {$i<500} {incr i} {
db eval {INSERT INTO abc VALUES(randstr(100,100), randstr(1000,1000))}
}
}
} -sqlbody {
SELECT count(*) FROM abc;
}
do_malloc_test 34 -tclprep {
db eval { PRAGMA cache_size = 10 }
db transaction {
db eval { CREATE TABLE abc(a PRIMARY KEY, b) }
for {set i 0} {$i<500} {incr i} {
db eval {INSERT INTO abc VALUES(randstr(100,100), randstr(1000,1000))}
}
}
} -sqlbody {
SELECT count(*) FROM abc;
}
proc f {args} { error "Quite a long error!" }
do_malloc_test 35 -tclprep {
db func f f
set ::STMT [sqlite3_prepare db "SELECT f()" -1 DUMMY]
sqlite3_step $::STMT
} -tclbody {
sqlite3_finalize $::STMT
} -cleanup {
# At one point an assert( !db->mallocFailed ) could fail in the following
# call to sqlite3_errmsg(). Because sqlite3_finalize() had failed to clear
# the flag before returning.
sqlite3_errmsg16 db
}
do_malloc_test 36 -sqlprep {
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
INSERT INTO t1 VALUES(3, 4);
} -sqlbody {
SELECT test_agg_errmsg16(), group_concat(a) FROM t1
}
# At one point, if an OOM occurred immediately after obtaining a shared lock
# on the database file, the file remained locked. This test case ensures
# that bug has been fixed.i
if {[db eval {PRAGMA locking_mode}]!="exclusive"} {
do_malloc_test 37 -tclprep {
sqlite3 db2 test.db
execsql {
CREATE TABLE t1(a, b);
INSERT INTO t1 VALUES(1, 2);
} db2
} -sqlbody {
SELECT * FROM t1;
} -cleanup {
# Try to write to the database using connection [db2]. If connection [db]
# has correctly released the shared lock, this write attempt should
# succeed. If [db] has not released the lock, this should hit an
# SQLITE_BUSY error.
do_test malloc-36.$zRepeat.${::n}.unlocked {
execsql {INSERT INTO t1 VALUES(3, 4)} db2
} {}
db2 close
}
catch { db2 close }
}
# Test that if an OOM error occurs, aux-data is still correctly destroyed.
# This test case was causing either a memory-leak or an assert() failure
# at one point, depending on the configuration.
#
do_malloc_test 39 -tclprep {
sqlite3 db test.db
} -sqlbody {
SELECT test_auxdata('abc', 'def');
} -cleanup {
db close
}
# Ensure that no file descriptors were leaked.
do_test malloc-99.X {
catch {db close}
set sqlite_open_file_count
} {0}
puts open-file-count=$sqlite_open_file_count
finish_test
Reference in New Issue View Git Blame Copy Permalink