sqlite/test/notify1.test

501 lines
13 KiB
Plaintext
Raw Normal View History

# 2009 March 04
#
# 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 implements regression tests for SQLite library. The
# focus of this file is testing the sqlite3_unlock_notify() API.
#
# $Id: notify1.test,v 1.4 2009/06/05 17:09:12 drh Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
ifcapable !unlock_notify||!shared_cache {
finish_test
return
}
db close
set ::enable_shared_cache [sqlite3_enable_shared_cache 1]
#-------------------------------------------------------------------------
# Warm body test. Test that an unlock-notify callback can be registered
# and that it is invoked.
#
do_test notify1-1.1 {
sqlite3 db test.db
sqlite3 db2 test.db
execsql { CREATE TABLE t1(a, b) }
} {}
do_test notify1-1.2 {
execsql {
BEGIN;
INSERT INTO t1 VALUES(1, 2);
}
catchsql { INSERT INTO t1 VALUES(3, 4) } db2
} {1 {database table is locked}}
do_test notify1-1.3 {
set zScript ""
db2 unlock_notify {
set zScript "db2 eval { INSERT INTO t1 VALUES(3, 4) }"
}
execsql { SELECT * FROM t1 }
} {1 2}
do_test notify1-1.4 {
set zScript
} {}
do_test notify1-1.5 {
execsql { COMMIT }
eval $zScript
execsql { SELECT * FROM t1 }
} {1 2 3 4}
#-------------------------------------------------------------------------
# Verify that invoking the "unlock_notify" method with no arguments
# (which is the equivalent of invoking sqlite3_unlock_notify() with
# a NULL xNotify argument) cancels a pending notify callback.
#
do_test notify1-1.11 {
execsql { DROP TABLE t1; CREATE TABLE t1(a, b) }
} {}
do_test notify1-1.12 {
execsql {
BEGIN;
INSERT INTO t1 VALUES(1, 2);
}
catchsql { INSERT INTO t1 VALUES(3, 4) } db2
} {1 {database table is locked}}
do_test notify1-1.13 {
set zScript ""
db2 unlock_notify {
set zScript "db2 eval { INSERT INTO t1 VALUES(3, 4) }"
}
execsql { SELECT * FROM t1 }
} {1 2}
do_test notify1-1.14 {
set zScript
} {}
do_test notify1-1.15 {
db2 unlock_notify
execsql { COMMIT }
eval $zScript
execsql { SELECT * FROM t1 }
} {1 2}
#-------------------------------------------------------------------------
# The following tests, notify1-2.*, test that deadlock is detected
# correctly.
#
do_test notify1-2.1 {
execsql {
CREATE TABLE t2(a, b);
INSERT INTO t2 VALUES('I', 'II');
}
} {}
#
# Test for simple deadlock involving two database connections.
#
# 1. Grab a write-lock on t1 with [db]. Then grab a read-lock on t2 with [db2].
# 2. Try to grab a read-lock on t1 with [db2] (fails).
# 3. Have [db2] wait on the read-lock it failed to obtain in step 2.
# 4. Try to grab a write-lock on t2 with [db] (fails).
# 5. Try to have [db] wait on the lock from step 4. Fails, as the system
# would be deadlocked (since [db2] is already waiting on [db], and this
# operation would have [db] wait on [db2]).
#
do_test notify1-2.2.1 {
execsql {
BEGIN;
INSERT INTO t1 VALUES(5, 6);
}
execsql {
BEGIN;
SELECT * FROM t2;
} db2
} {I II}
do_test notify1-2.2.2 {
catchsql { SELECT * FROM t1 } db2
} {1 {database table is locked: t1}}
do_test notify1-2.2.3 {
db2 unlock_notify {lappend unlock_notify db2}
} {}
do_test notify1-2.2.4 {
catchsql { INSERT INTO t2 VALUES('III', 'IV') }
} {1 {database table is locked: t2}}
do_test notify1-2.2.5 {
set rc [catch { db unlock_notify {lappend unlock_notify db} } msg]
list $rc $msg
} {1 {database is deadlocked}}
#
# Test for slightly more complex deadlock involving three database
# connections: db, db2 and db3.
#
do_test notify1-2.3.1 {
db close
db2 close
forcedelete test.db test2.db test3.db
foreach con {db db2 db3} {
sqlite3 $con test.db
$con eval { ATTACH 'test2.db' AS aux2 }
$con eval { ATTACH 'test3.db' AS aux3 }
}
execsql {
CREATE TABLE main.t1(a, b);
CREATE TABLE aux2.t2(a, b);
CREATE TABLE aux3.t3(a, b);
}
} {}
do_test notify1-2.3.2 {
execsql { BEGIN ; INSERT INTO t1 VALUES(1, 2) } db
execsql { BEGIN ; INSERT INTO t2 VALUES(1, 2) } db2
execsql { BEGIN ; INSERT INTO t3 VALUES(1, 2) } db3
} {}
do_test notify1-2.3.3 {
catchsql { SELECT * FROM t2 } db
} {1 {database table is locked: t2}}
do_test notify1-2.3.4 {
catchsql { SELECT * FROM t3 } db2
} {1 {database table is locked: t3}}
do_test notify1-2.3.5 {
catchsql { SELECT * FROM t1 } db3
} {1 {database table is locked: t1}}
do_test notify1-2.3.6 {
set lUnlock [list]
db unlock_notify {lappend lUnlock db}
db2 unlock_notify {lappend lUnlock db2}
} {}
do_test notify1-2.3.7 {
set rc [catch { db3 unlock_notify {lappend lUnlock db3} } msg]
list $rc $msg
} {1 {database is deadlocked}}
do_test notify1-2.3.8 {
execsql { COMMIT }
set lUnlock
} {}
do_test notify1-2.3.9 {
db3 unlock_notify {lappend lUnlock db3}
set lUnlock
} {db3}
do_test notify1-2.3.10 {
execsql { COMMIT } db2
set lUnlock
} {db3 db}
do_test notify1-2.3.11 {
execsql { COMMIT } db3
set lUnlock
} {db3 db db2}
catch { db3 close }
catch { db2 close }
catch { db close }
#-------------------------------------------------------------------------
# The following tests, notify1-3.* and notify1-4.*, test that callbacks
# can be issued when there are many (>16) connections waiting on a single
# unlock event.
#
foreach {tn nConn} {3 20 4 76} {
do_test notify1-$tn.1 {
sqlite3 db test.db
execsql {
BEGIN;
INSERT INTO t1 VALUES('a', 'b');
}
} {}
set lUnlock [list]
set lUnlockFinal [list]
for {set ii 1} {$ii <= $nConn} {incr ii} {
do_test notify1-$tn.2.$ii.1 {
set cmd "db$ii"
sqlite3 $cmd test.db
catchsql { SELECT * FROM t1 } $cmd
} {1 {database table is locked: t1}}
do_test notify1-$tn.2.$ii.2 {
$cmd unlock_notify "lappend lUnlock $ii"
} {}
lappend lUnlockFinal $ii
}
do_test notify1-$tn.3 {
set lUnlock
} {}
do_test notify1-$tn.4 {
execsql {COMMIT}
lsort -integer $lUnlock
} $lUnlockFinal
do_test notify1-$tn.5 {
for {set ii 1} {$ii <= $nConn} {incr ii} {
"db$ii" close
}
} {}
}
db close
#-------------------------------------------------------------------------
# These tests, notify1-5.*, test that a malloc() failure that occurs while
# allocating an array to use as an argument to an unlock-notify callback
# is handled correctly.
#
source $testdir/malloc_common.tcl
do_malloc_test notify1-5 -tclprep {
set ::lUnlock [list]
execsql {
CREATE TABLE t1(a, b);
BEGIN;
INSERT INTO t1 VALUES('a', 'b');
}
for {set ii 1} {$ii <= 60} {incr ii} {
set cmd "db$ii"
sqlite3 $cmd test.db
catchsql { SELECT * FROM t1 } $cmd
$cmd unlock_notify "lappend ::lUnlock $ii"
}
} -sqlbody {
COMMIT;
} -cleanup {
# One of two things should have happened:
#
# 1) The transaction opened by [db] was not committed. No unlock-notify
# callbacks were invoked, OR
# 2) The transaction opened by [db] was committed and 60 unlock-notify
# callbacks were invoked.
#
do_test notify1-5.systemstate {
expr { ([llength $::lUnlock]==0 && [sqlite3_get_autocommit db]==0)
|| ([llength $::lUnlock]==60 && [sqlite3_get_autocommit db]==1)
}
} {1}
for {set ii 1} {$ii <= 60} {incr ii} { "db$ii" close }
}
#-------------------------------------------------------------------------
# Test cases notify1-6.* test cases where the following occur:
#
# notify1-6.1.*: Test encountering an SQLITE_LOCKED error when the
# "blocking connection" has already been set by a previous
# SQLITE_LOCKED.
#
# notify1-6.2.*: Test encountering an SQLITE_LOCKED error when already
# waiting on an unlock-notify callback.
#
# notify1-6.3.*: Test that if an SQLITE_LOCKED error is encountered while
# already waiting on an unlock-notify callback, and then
# the blocker that caused the SQLITE_LOCKED commits its
# transaction, the unlock-notify callback is not invoked.
#
# notify1-6.4.*: Like 6.3.*, except that instead of the second blocker
# committing its transaction, the first does. The
# unlock-notify callback is therefore invoked.
#
db close
do_test notify1-6.1.1 {
forcedelete test.db test2.db
foreach conn {db db2 db3} {
sqlite3 $conn test.db
execsql { ATTACH 'test2.db' AS two } $conn
}
execsql {
CREATE TABLE t1(a, b);
CREATE TABLE two.t2(a, b);
}
execsql {
BEGIN;
INSERT INTO t1 VALUES(1, 2);
} db2
execsql {
BEGIN;
INSERT INTO t2 VALUES(1, 2);
} db3
} {}
do_test notify1-6.1.2 {
catchsql { SELECT * FROM t2 }
} {1 {database table is locked: t2}}
do_test notify1-6.1.3 {
catchsql { SELECT * FROM t1 }
} {1 {database table is locked: t1}}
do_test notify1-6.2.1 {
set unlocked 0
db unlock_notify {set unlocked 1}
set unlocked
} {0}
do_test notify1-6.2.2 {
catchsql { SELECT * FROM t2 }
} {1 {database table is locked: t2}}
do_test notify1-6.2.3 {
execsql { COMMIT } db2
set unlocked
} {1}
do_test notify1-6.3.1 {
execsql {
BEGIN;
INSERT INTO t1 VALUES(3, 4);
} db2
} {}
do_test notify1-6.3.2 {
catchsql { SELECT * FROM t1 }
} {1 {database table is locked: t1}}
do_test notify1-6.3.3 {
set unlocked 0
db unlock_notify {set unlocked 1}
set unlocked
} {0}
do_test notify1-6.3.4 {
catchsql { SELECT * FROM t2 }
} {1 {database table is locked: t2}}
do_test notify1-6.3.5 {
execsql { COMMIT } db3
set unlocked
} {0}
do_test notify1-6.4.1 {
execsql {
BEGIN;
INSERT INTO t2 VALUES(3, 4);
} db3
catchsql { SELECT * FROM t2 }
} {1 {database table is locked: t2}}
do_test notify1-6.4.2 {
execsql { COMMIT } db2
set unlocked
} {1}
do_test notify1-6.4.3 {
execsql { COMMIT } db3
} {}
db close
db2 close
db3 close
#-------------------------------------------------------------------------
# Test cases notify1-7.* tests that when more than one distinct
# unlock-notify function is registered, all are invoked correctly.
#
proc unlock_notify {} {
incr ::unlock_notify
}
do_test notify1-7.1 {
foreach conn {db db2 db3} {
sqlite3 $conn test.db
}
execsql {
BEGIN;
INSERT INTO t1 VALUES(5, 6);
}
} {}
do_test notify1-7.2 {
catchsql { SELECT * FROM t1 } db2
} {1 {database table is locked: t1}}
do_test notify1-7.3 {
catchsql { SELECT * FROM t1 } db3
} {1 {database table is locked: t1}}
do_test notify1-7.4 {
set unlock_notify 0
db2 unlock_notify unlock_notify
sqlite3_unlock_notify db3
} {SQLITE_OK}
do_test notify1-7.5 {
set unlock_notify
} {0}
do_test notify1-7.6 {
execsql { COMMIT }
set unlock_notify
} {2}
#-------------------------------------------------------------------------
# Test cases notify1-8.* tests that the correct SQLITE_LOCKED extended
# error code is returned in various scenarios.
#
do_test notify1-8.1 {
execsql {
BEGIN;
INSERT INTO t1 VALUES(7, 8);
}
catchsql { SELECT * FROM t1 } db2
} {1 {database table is locked: t1}}
do_test notify1-8.2 {
sqlite3_extended_errcode db2
} {SQLITE_LOCKED_SHAREDCACHE}
do_test notify1-8.3 {
execsql {
COMMIT;
BEGIN EXCLUSIVE;
}
catchsql { SELECT * FROM t1 } db2
} {1 {database schema is locked: main}}
do_test notify1-8.4 {
sqlite3_extended_errcode db2
} {SQLITE_LOCKED_SHAREDCACHE}
do_test notify1-8.X {
execsql { COMMIT }
} {}
#-------------------------------------------------------------------------
# Test cases notify1-9.* test the shared-cache 'pending-lock' feature.
#
do_test notify1-9.1 {
execsql {
CREATE TABLE t2(a, b);
BEGIN;
SELECT * FROM t1;
} db2
} {1 2 3 4 5 6 7 8}
do_test notify1-9.2 {
execsql { SELECT * FROM t1 } db3
} {1 2 3 4 5 6 7 8}
do_test notify1-9.3 {
catchsql {
BEGIN;
INSERT INTO t1 VALUES(9, 10);
}
} {1 {database table is locked: t1}}
do_test notify1-9.4 {
catchsql { SELECT * FROM t2 } db3
} {1 {database table is locked}}
do_test notify1-9.5 {
execsql { COMMIT } db2
execsql { SELECT * FROM t2 } db3
} {}
do_test notify1-9.6 {
execsql { COMMIT }
} {}
do_test notify1-9.7 {
execsql {
BEGIN;
SELECT * FROM t1;
} db2
} {1 2 3 4 5 6 7 8}
do_test notify1-9.8 {
execsql { SELECT * FROM t1 } db3
} {1 2 3 4 5 6 7 8}
do_test notify1-9.9 {
catchsql {
BEGIN;
INSERT INTO t1 VALUES(9, 10);
}
} {1 {database table is locked: t1}}
do_test notify1-9.10 {
catchsql { SELECT * FROM t2 } db3
} {1 {database table is locked}}
do_test notify1-9.11 {
execsql { COMMIT }
execsql { SELECT * FROM t2 } db3
} {}
do_test notify1-9.12 {
execsql { COMMIT } db2
} {}
db close
db2 close
db3 close
sqlite3_enable_shared_cache $::enable_shared_cache
finish_test