# 2012 October 5 # # 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. # #*********************************************************************** # # The tests in this file are intended to show if two connections attach # to the same shared cache using different database names, views and # virtual tables may still be accessed. # set testdir [file dirname $argv0] source $testdir/tester.tcl source $testdir/lock_common.tcl set testprefix shared9 ifcapable !view||!trigger { finish_test return } db close set enable_shared_cache [sqlite3_enable_shared_cache 1] sqlite3 db1 test.db sqlite3 db2 test.db forcedelete test.db2 do_test 1.1 { db1 eval { ATTACH 'test.db2' AS 'fred'; CREATE TABLE fred.t1(a, b, c); CREATE VIEW fred.v1 AS SELECT * FROM t1; CREATE TABLE fred.t2(a, b); CREATE TABLE fred.t3(a, b); CREATE TRIGGER fred.trig AFTER INSERT ON t2 BEGIN DELETE FROM t3; INSERT INTO t3 SELECT * FROM t2; END; INSERT INTO t2 VALUES(1, 2); SELECT * FROM t3; } } {1 2} do_test 1.2 { db2 eval "ATTACH 'test.db2' AS 'jones'" } {} do_test 1.3 { db2 eval "SELECT * FROM v1" } {} do_test 1.4 { db2 eval "INSERT INTO t2 VALUES(3, 4)" } {} ifcapable fts3 { do_test 1.5 { db1 eval { CREATE VIRTUAL TABLE fred.t4 USING fts4; INSERT INTO t4 VALUES('hello world'); } } {} do_test 1.6 { db2 eval { INSERT INTO t4 VALUES('shared cache'); SELECT * FROM t4 WHERE t4 MATCH 'hello'; } } {{hello world}} do_test 1.7 { db1 eval { SELECT * FROM t4 WHERE t4 MATCH 'c*'; } } {{shared cache}} } db1 close db2 close #------------------------------------------------------------------------- # The following tests attempt to find a similar problem with collation # sequence names - pointers to database handle specific allocations leaking # into schema objects and being used after the original handle has been # closed. # forcedelete test.db test.db2 sqlite3 db1 test.db sqlite3 db2 test.db foreach x {collate1 collate2 collate3} { proc $x {a b} { string compare $a $b } db1 collate $x $x db2 collate $x $x } do_test 2.1 { db1 eval { CREATE TABLE t1(a, b, c COLLATE collate1); CREATE INDEX i1 ON t1(a COLLATE collate2, c, b); } } {} do_test 2.2 { db1 close db2 eval "INSERT INTO t1 VALUES('abc', 'def', 'ghi')" } {} db2 close #------------------------------------------------------------------------- # At one point, the following would cause a collation sequence belonging # to connection [db1] to be invoked by a call to [db2 eval]. Which is a # problem if [db1] has already been closed. # forcedelete test.db test.db2 sqlite3 db1 test.db sqlite3 db2 test.db proc mycollate_db1 {a b} {set ::invoked_mycollate_db1 1 ; string compare $a $b} proc mycollate_db2 {a b} {string compare $a $b} db1 collate mycollate mycollate_db1 db2 collate mycollate mycollate_db2 do_test 2.3 { set ::invoked_mycollate_db1 0 db1 eval { CREATE TABLE t1(a COLLATE mycollate, CHECK (a IN ('one', 'two', 'three'))); INSERT INTO t1 VALUES('one'); } db1 close set ::invoked_mycollate_db1 } {1} do_test 2.4 { set ::invoked_mycollate_db1 0 db2 eval { INSERT INTO t1 VALUES('two'); } db2 close set ::invoked_mycollate_db1 } {0} forcedelete test.db test.db2 sqlite3 db1 test.db sqlite3 db2 test.db db1 collate mycollate mycollate_db1 db2 collate mycollate mycollate_db2 do_test 2.13 { set ::invoked_mycollate_db1 0 db1 eval { CREATE TABLE t1(a, CHECK (a COLLATE mycollate IN ('one', 'two', 'three'))); INSERT INTO t1 VALUES('one'); } db1 close set ::invoked_mycollate_db1 } {1} do_test 2.14 { set ::invoked_mycollate_db1 0 db2 eval { INSERT INTO t1 VALUES('two'); } db2 close set ::invoked_mycollate_db1 } {0} #------------------------------------------------------------------------- # This test verifies that a bug causing a busy-handler belonging to one # shared-cache connection to be executed as a result of an sqlite3_step() # on another has been fixed. # forcedelete test.db test.db2 sqlite3 db1 test.db sqlite3 db2 test.db proc busyhandler {handle args} { set ::busyhandler_invoked_for $handle return 1 } db1 busy [list busyhandler db1] db2 busy [list busyhandler db2] do_test 3.1 { db1 eval { BEGIN; CREATE TABLE t1(a, b); CREATE TABLE t2(a, b); INSERT INTO t1 VALUES(1, 2); INSERT INTO t2 VALUES(1, 2); } # Keep this next COMMIT as a separate statement. This ensures that COMMIT # has already been compiled and loaded into the tcl interface statement # cache when it is attempted below. db1 eval COMMIT db1 eval { BEGIN; INSERT INTO t1 VALUES(3, 4); } } {} do_test 3.2 { set ::tf [launch_testfixture] testfixture $::tf { sqlite3 db test.db db eval { BEGIN; SELECT * FROM t1; } } } {1 2} do_test 3.3 { db2 eval { SELECT * FROM t2 } } {1 2} do_test 3.4 { list [catch { db1 eval COMMIT } msg] $msg } {1 {database is locked}} # At one point the following would fail, showing that the busy-handler # belonging to [db2] was invoked instead. do_test 3.5 { set ::busyhandler_invoked_for } {db1} do_test 3.6 { close $::tf db1 eval COMMIT } {} db1 close db2 close sqlite3_enable_shared_cache $::enable_shared_cache finish_test