mirror of
https://github.com/tursodatabase/libsql.git
synced 2024-12-16 09:08:54 +00:00
199 lines
5.1 KiB
Plaintext
199 lines
5.1 KiB
Plaintext
# 2013 May 14
|
|
#
|
|
# 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.
|
|
#
|
|
#***********************************************************************
|
|
#
|
|
# Test some specific circumstances to do with shared cache mode.
|
|
#
|
|
|
|
|
|
set testdir [file dirname $argv0]
|
|
source $testdir/tester.tcl
|
|
if {[run_thread_tests]==0} { finish_test ; return }
|
|
db close
|
|
set ::testprefix sharedA
|
|
|
|
ifcapable !shared_cache {
|
|
finish_test
|
|
return
|
|
}
|
|
|
|
if {[atomic_batch_write test.db]} {
|
|
finish_test
|
|
return
|
|
}
|
|
|
|
set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
do_test 0.1 {
|
|
sqlite3 db1 test.db
|
|
sqlite3 db2 test.db
|
|
|
|
db1 eval {
|
|
CREATE TABLE t1(x);
|
|
INSERT INTO t1 VALUES(randomblob(100));
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
CREATE INDEX i1 ON t1(x);
|
|
}
|
|
|
|
db1 eval {
|
|
BEGIN;
|
|
DROP INDEX i1;
|
|
}
|
|
|
|
db2 close
|
|
|
|
db1 eval {
|
|
INSERT INTO t1 SELECT randomblob(100) FROM t1;
|
|
ROLLBACK;
|
|
PRAGMA integrity_check;
|
|
}
|
|
} {ok}
|
|
|
|
db1 close
|
|
forcedelete test.db
|
|
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
do_test 1.1 {
|
|
sqlite3 db1 test.db
|
|
sqlite3 db2 test.db
|
|
db2 eval {
|
|
CREATE TABLE t1(x);
|
|
INSERT INTO t1 VALUES(123);
|
|
}
|
|
db1 eval {
|
|
SELECT * FROM t1;
|
|
CREATE INDEX i1 ON t1(x);
|
|
}
|
|
} {123}
|
|
|
|
do_test 1.2 {
|
|
db2 eval { SELECT * FROM t1 ORDER BY x; }
|
|
|
|
db1 eval {
|
|
BEGIN; DROP INDEX i1;
|
|
}
|
|
db1 close
|
|
|
|
db2 eval { SELECT * FROM t1 ORDER BY x; }
|
|
} {123}
|
|
|
|
do_test 1.3 {
|
|
db2 close
|
|
} {}
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# sqlite3RollbackAll() loops through all attached b-trees and rolls
|
|
# back each one separately. Then if the SQLITE_InternChanges flag is
|
|
# set, it resets the schema. Both of the above steps must be done
|
|
# while holding a mutex, otherwise another thread might slip in and
|
|
# try to use the new schema with the old data.
|
|
#
|
|
# The following sequence of tests attempt to verify that the actions
|
|
# taken by sqlite3RollbackAll() are thread-atomic (that they cannot be
|
|
# interrupted by a separate thread.)
|
|
#
|
|
# Note that a TCL interpreter can only be used within the thread in which
|
|
# it was originally created (because it uses thread-local-storage).
|
|
# The tvfs callbacks must therefore only run on the main thread.
|
|
# There is some trickery in the read_callback procedure to ensure that
|
|
# this is the case.
|
|
#
|
|
testvfs tvfs
|
|
|
|
# Set up two databases and two database connections.
|
|
#
|
|
# db1: main(test.db), two(test2.db)
|
|
# db2: main(test.db)
|
|
#
|
|
# The cache for test.db is shared between db1 and db2.
|
|
#
|
|
do_test 2.1 {
|
|
forcedelete test.db test.db2
|
|
sqlite3 db1 test.db -vfs tvfs
|
|
db1 eval { ATTACH 'test.db2' AS two }
|
|
|
|
db1 eval {
|
|
CREATE TABLE t1(x);
|
|
INSERT INTO t1 VALUES(1);
|
|
INSERT INTO t1 VALUES(2);
|
|
INSERT INTO t1 VALUES(3);
|
|
CREATE TABLE two.t2(x);
|
|
INSERT INTO t2 SELECT * FROM t1;
|
|
}
|
|
|
|
sqlite3 db2 test.db -vfs tvfs
|
|
db2 eval { SELECT * FROM t1 }
|
|
} {1 2 3}
|
|
|
|
# Create a prepared statement on db2 that will attempt a schema change
|
|
# in test.db. Meanwhile, start a transaction on db1 that changes
|
|
# the schema of test.db and that creates a rollback journal on test2.db
|
|
#
|
|
do_test 2.2 {
|
|
set ::STMT [sqlite3_prepare db2 "CREATE INDEX i1 ON t1(x)" -1 tail]
|
|
db1 eval {
|
|
BEGIN;
|
|
CREATE INDEX i1 ON t1(x);
|
|
INSERT INTO t2 VALUES('value!');
|
|
}
|
|
} {}
|
|
|
|
# Set up a callback that will cause db2 to try to execute its
|
|
# schema change when db1 accesses the journal file of test2.db.
|
|
#
|
|
# This callback will be invoked after the content of test.db has
|
|
# be rolled back but before the schema has been reset. If the
|
|
# sqlite3RollbackAll() operation is not thread-atomic, then the
|
|
# db2 statement in the callback will see old content with the newer
|
|
# schema, which is wrong.
|
|
#
|
|
tvfs filter xRead
|
|
tvfs script read_callback
|
|
unset -nocomplain ::some_time_laster
|
|
unset -nocomplain ::thread_result
|
|
proc read_callback {call file args} {
|
|
if {[string match *test.db2-journal $file]} {
|
|
tvfs filter {} ;# Ensure that tvfs callbacks to do run on the
|
|
# child thread
|
|
sqlthread spawn ::thread_result [subst -nocommands {
|
|
sqlite3_step $::STMT
|
|
set rc [sqlite3_finalize $::STMT]
|
|
}]
|
|
after 1000 { set ::some_time_later 1 }
|
|
vwait ::some_time_later
|
|
}
|
|
}
|
|
do_test 2.3 { db1 eval ROLLBACK } {}
|
|
|
|
# Verify that the db2 statement invoked by the callback detected the
|
|
# schema change.
|
|
#
|
|
if {[info exists ::thread_result]==0} { vwait ::thread_result }
|
|
do_test 2.4 {
|
|
list $::thread_result [sqlite3_errmsg db2]
|
|
} {SQLITE_SCHEMA {database schema has changed}}
|
|
|
|
db1 close
|
|
db2 close
|
|
tvfs delete
|
|
|
|
sqlite3_enable_shared_cache $::enable_shared_cache
|
|
finish_test
|