Update test file walprotocol.test to account for the changes in the wal
[sqlite.git] / test / lock.test
blob534aa3b9a44aa420cc12a855a3febc93c899f671
1 # 2001 September 15
3 # The author disclaims copyright to this source code.  In place of
4 # a legal notice, here is a blessing:
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.
10 #***********************************************************************
11 # This file implements regression tests for SQLite library.  The
12 # focus of this script is database locks.
14 # $Id: lock.test,v 1.40 2009/06/16 17:49:36 drh Exp $
17 set testdir [file dirname $argv0]
18 source $testdir/tester.tcl
20 # Create an alternative connection to the database
22 do_test lock-1.0 {
23   # Give a complex pathname to stress the path simplification logic in
24   # the vxworks driver and in test_async.
25   file mkdir tempdir/t1/t2
26   sqlite3 db2 ./tempdir/../tempdir/t1/.//t2/../../..//test.db
27   set dummy {}
28 } {}
29 do_test lock-1.1 {
30   execsql {SELECT name FROM sqlite_master WHERE type='table' ORDER BY name}
31 } {}
32 do_test lock-1.2 {
33   execsql {SELECT name FROM sqlite_master WHERE type='table' ORDER BY name} db2
34 } {}
35 do_test lock-1.3 {
36   execsql {CREATE TABLE t1(a int, b int)}
37   execsql {SELECT name FROM sqlite_master WHERE type='table' ORDER BY name}
38 } {t1}
39 do_test lock-1.5 {
40   catchsql {
41      SELECT name FROM sqlite_master WHERE type='table' ORDER BY name
42   } db2
43 } {0 t1}
45 do_test lock-1.6 {
46   execsql {INSERT INTO t1 VALUES(1,2)}
47   execsql {SELECT * FROM t1}
48 } {1 2}
49 # Update: The schema is now brought up to date by test lock-1.5.
50 # do_test lock-1.7.1 {
51 #   catchsql {SELECT * FROM t1} db2
52 # } {1 {no such table: t1}}
53 do_test lock-1.7.2 {
54   catchsql {SELECT * FROM t1} db2
55 } {0 {1 2}}
56 do_test lock-1.8 {
57   execsql {UPDATE t1 SET a=b, b=a} db2
58   execsql {SELECT * FROM t1} db2
59 } {2 1}
60 do_test lock-1.9 {
61   execsql {SELECT * FROM t1}
62 } {2 1}
63 do_test lock-1.10 {
64   execsql {BEGIN TRANSACTION}
65   execsql {UPDATE t1 SET a = 0 WHERE 0}
66   execsql {SELECT * FROM t1}
67 } {2 1}
68 do_test lock-1.11 {
69   catchsql {SELECT * FROM t1} db2
70 } {0 {2 1}}
71 do_test lock-1.12 {
72   execsql {ROLLBACK}
73   catchsql {SELECT * FROM t1}
74 } {0 {2 1}}
76 do_test lock-1.13 {
77   execsql {CREATE TABLE t2(x int, y int)}
78   execsql {INSERT INTO t2 VALUES(8,9)}
79   execsql {SELECT * FROM t2}
80 } {8 9}
81 do_test lock-1.14.1 {
82   catchsql {SELECT * FROM t2} db2
83 } {0 {8 9}}
84 do_test lock-1.14.2 {
85   catchsql {SELECT * FROM t1} db2
86 } {0 {2 1}}
87 do_test lock-1.15 {
88   catchsql {SELECT * FROM t2} db2
89 } {0 {8 9}}
91 do_test lock-1.16 {
92   db eval {SELECT * FROM t1} qv {
93     set x [db eval {SELECT * FROM t1}]
94   }
95   set x
96 } {2 1}
97 do_test lock-1.17 {
98   db eval {SELECT * FROM t1} qv {
99     set x [db eval {SELECT * FROM t2}]
100   }
101   set x
102 } {8 9}
104 # You cannot UPDATE a table from within the callback of a SELECT
105 # on that same table because the SELECT has the table locked.
107 # 2006-08-16:  Reads no longer block writes within the same
108 # database connection.
110 #do_test lock-1.18 {
111 #  db eval {SELECT * FROM t1} qv {
112 #    set r [catch {db eval {UPDATE t1 SET a=b, b=a}} msg]
113 #    lappend r $msg
114 #  }
115 #  set r
116 #} {1 {database table is locked}}
118 # But you can UPDATE a different table from the one that is used in
119 # the SELECT.
121 do_test lock-1.19 {
122   db eval {SELECT * FROM t1} qv {
123     set r [catch {db eval {UPDATE t2 SET x=y, y=x}} msg]
124     lappend r $msg
125   }
126   set r
127 } {0 {}}
128 do_test lock-1.20 {
129   execsql {SELECT * FROM t2}
130 } {9 8}
132 # It is possible to do a SELECT of the same table within the
133 # callback of another SELECT on that same table because two
134 # or more read-only cursors can be open at once.
136 do_test lock-1.21 {
137   db eval {SELECT * FROM t1} qv {
138     set r [catch {db eval {SELECT a FROM t1}} msg]
139     lappend r $msg
140   }
141   set r
142 } {0 2}
144 # Under UNIX you can do two SELECTs at once with different database
145 # connections, because UNIX supports reader/writer locks.  Under windows,
146 # this is not possible.
148 if {$::tcl_platform(platform)=="unix"} {
149   do_test lock-1.22 {
150     db eval {SELECT * FROM t1} qv {
151       set r [catch {db2 eval {SELECT a FROM t1}} msg]
152       lappend r $msg
153     }
154     set r
155   } {0 2}
157 integrity_check lock-1.23
159 # If one thread has a transaction another thread cannot start
160 # a transaction.  -> Not true in version 3.0.  But if one thread
161 # as a RESERVED lock another thread cannot acquire one.
163 do_test lock-2.1 {
164   execsql {BEGIN TRANSACTION}
165   execsql {UPDATE t1 SET a = 0 WHERE 0}
166   execsql {BEGIN TRANSACTION} db2
167   set r [catch {execsql {UPDATE t1 SET a = 0 WHERE 0} db2} msg]
168   execsql {ROLLBACK} db2
169   lappend r $msg
170 } {1 {database is locked}}
172 # A thread can read when another has a RESERVED lock.
174 do_test lock-2.2 {
175   catchsql {SELECT * FROM t2} db2
176 } {0 {9 8}}
178 # If the other thread (the one that does not hold the transaction with
179 # a RESERVED lock) tries to get a RESERVED lock, we do get a busy callback
180 # as long as we were not orginally holding a READ lock.
182 do_test lock-2.3.1 {
183   proc callback {count} {
184     set ::callback_value $count
185     break
186   }
187   set ::callback_value {}
188   db2 busy callback
189   # db2 does not hold a lock so we should get a busy callback here
190   set r [catch {execsql {UPDATE t1 SET a=b, b=a} db2} msg]
191   lappend r $msg
192   lappend r $::callback_value
193 } {1 {database is locked} 0}
194 do_test lock-2.3.2 {
195   set ::callback_value {}
196   execsql {BEGIN; SELECT rowid FROM sqlite_master LIMIT 1} db2
197   # This time db2 does hold a read lock.  No busy callback this time.
198   set r [catch {execsql {UPDATE t1 SET a=b, b=a} db2} msg]
199   lappend r $msg
200   lappend r $::callback_value
201 } {1 {database is locked} {}}
202 catch {execsql {ROLLBACK} db2}
203 do_test lock-2.4.1 {
204   proc callback {count} {
205     lappend ::callback_value $count
206     if {$count>4} break
207   }
208   set ::callback_value {}
209   db2 busy callback
210   # We get a busy callback because db2 is not holding a lock
211   set r [catch {execsql {UPDATE t1 SET a=b, b=a} db2} msg]
212   lappend r $msg
213   lappend r $::callback_value
214 } {1 {database is locked} {0 1 2 3 4 5}}
215 do_test lock-2.4.2 {
216   proc callback {count} {
217     lappend ::callback_value $count
218     if {$count>4} break
219   }
220   set ::callback_value {}
221   db2 busy callback
222   execsql {BEGIN; SELECT rowid FROM sqlite_master LIMIT 1} db2
223   # No busy callback this time because we are holding a lock
224   set r [catch {execsql {UPDATE t1 SET a=b, b=a} db2} msg]
225   lappend r $msg
226   lappend r $::callback_value
227 } {1 {database is locked} {}}
228 catch {execsql {ROLLBACK} db2}
229 do_test lock-2.5 {
230   proc callback {count} {
231     lappend ::callback_value $count
232     if {$count>4} break
233   }
234   set ::callback_value {}
235   db2 busy callback
236   set r [catch {execsql {SELECT * FROM t1} db2} msg]
237   lappend r $msg
238   lappend r $::callback_value
239 } {0 {2 1} {}}
240 execsql {ROLLBACK}
242 # Test the built-in busy timeout handler
244 # EVIDENCE-OF: R-23579-05241 PRAGMA busy_timeout; PRAGMA busy_timeout =
245 # milliseconds; Query or change the setting of the busy timeout.
247 do_test lock-2.8 {
248   db2 timeout 400
249   execsql BEGIN
250   execsql {UPDATE t1 SET a = 0 WHERE 0}
251   catchsql {BEGIN EXCLUSIVE;} db2
252 } {1 {database is locked}}
253 do_test lock-2.8b {
254   db2 eval {PRAGMA busy_timeout}
255 } {400}
256 do_test lock-2.9 {
257   db2 timeout 0
258   execsql COMMIT
259 } {}
260 do_test lock-2.9b {
261   db2 eval {PRAGMA busy_timeout}
262 } {0}
263 integrity_check lock-2.10
264 do_test lock-2.11 {
265   db2 eval {PRAGMA busy_timeout(400)}
266   execsql BEGIN
267   execsql {UPDATE t1 SET a = 0 WHERE 0}
268   catchsql {BEGIN EXCLUSIVE;} db2
269 } {1 {database is locked}}
270 do_test lock-2.11b {
271   db2 eval {PRAGMA busy_timeout}
272 } {400}
273 do_test lock-2.12 {
274   db2 eval {PRAGMA busy_timeout(0)}
275   execsql COMMIT
276 } {}
277 do_test lock-2.12b {
278   db2 eval {PRAGMA busy_timeout}
279 } {0}
280 integrity_check lock-2.13
282 # Try to start two transactions in a row
284 do_test lock-3.1 {
285   execsql {BEGIN TRANSACTION}
286   set r [catch {execsql {BEGIN TRANSACTION}} msg]
287   execsql {ROLLBACK}
288   lappend r $msg
289 } {1 {cannot start a transaction within a transaction}}
290 integrity_check lock-3.2
292 # Make sure the busy handler and error messages work when
293 # opening a new pointer to the database while another pointer
294 # has the database locked.
296 do_test lock-4.1 {
297   db2 close
298   catch {db eval ROLLBACK}
299   db eval BEGIN
300   db eval {UPDATE t1 SET a=0 WHERE 0}
301   sqlite3 db2 ./test.db
302   catchsql {UPDATE t1 SET a=0} db2
303 } {1 {database is locked}}
304 do_test lock-4.2 {
305   set ::callback_value {}
306   set rc [catch {db2 eval {UPDATE t1 SET a=0}} msg]
307   lappend rc $msg $::callback_value
308 } {1 {database is locked} {}}
309 do_test lock-4.3 {
310   proc callback {count} {
311     lappend ::callback_value $count
312     if {$count>4} break
313   }
314   db2 busy callback
315   set rc [catch {db2 eval {UPDATE t1 SET a=0}} msg]
316   lappend rc $msg $::callback_value
317 } {1 {database is locked} {0 1 2 3 4 5}}
318 execsql {ROLLBACK}
320 # When one thread is writing, other threads cannot read.  Except if the
321 # writing thread is writing to its temporary tables, the other threads
322 # can still read.  -> Not so in 3.0.  One thread can read while another
323 # holds a RESERVED lock.
325 proc tx_exec {sql} {
326   db2 eval $sql
328 do_test lock-5.1 {
329   execsql {
330     SELECT * FROM t1
331   }
332 } {2 1}
333 do_test lock-5.2 {
334   db function tx_exec tx_exec
335   catchsql {
336     INSERT INTO t1(a,b) SELECT 3, tx_exec('SELECT y FROM t2 LIMIT 1');
337   }
338 } {0 {}}
340 ifcapable tempdb {
341   do_test lock-5.3 {
342     execsql {
343       CREATE TEMP TABLE t3(x);
344       SELECT * FROM t3;
345     }
346   } {}
347   do_test lock-5.4 {
348     catchsql {
349       INSERT INTO t3 SELECT tx_exec('SELECT y FROM t2 LIMIT 1');
350     }
351   } {0 {}}
352   do_test lock-5.5 {
353     execsql {
354       SELECT * FROM t3;
355     }
356   } {8}
357   do_test lock-5.6 {
358     catchsql {
359       UPDATE t1 SET a=tx_exec('SELECT x FROM t2');
360     }
361   } {0 {}}
362   do_test lock-5.7 {
363     execsql {
364       SELECT * FROM t1;
365     }
366   } {9 1 9 8}
367   do_test lock-5.8 {
368     catchsql {
369       UPDATE t3 SET x=tx_exec('SELECT x FROM t2');
370     }
371   } {0 {}}
372   do_test lock-5.9 {
373     execsql {
374       SELECT * FROM t3;
375     }
376   } {9}
379 do_test lock-6.1 {
380   execsql {
381     CREATE TABLE t4(a PRIMARY KEY, b);
382     INSERT INTO t4 VALUES(1, 'one');
383     INSERT INTO t4 VALUES(2, 'two');
384     INSERT INTO t4 VALUES(3, 'three');
385   }
387   set STMT [sqlite3_prepare $DB "SELECT * FROM sqlite_master" -1 TAIL]
388   sqlite3_step $STMT
390   execsql { DELETE FROM t4 }
391   execsql { SELECT * FROM sqlite_master } db2
392   execsql { SELECT * FROM t4 } db2
393 } {}
395 do_test lock-6.2 {
396   execsql { 
397     BEGIN;
398     INSERT INTO t4 VALUES(1, 'one');
399     INSERT INTO t4 VALUES(2, 'two');
400     INSERT INTO t4 VALUES(3, 'three');
401     COMMIT;
402   }
404   execsql { SELECT * FROM t4 } db2
405 } {1 one 2 two 3 three}
407 do_test lock-6.3 {
408   execsql { SELECT a FROM t4 ORDER BY a } db2
409 } {1 2 3}
411 do_test lock-6.4 {
412   execsql { PRAGMA integrity_check } db2
413 } {ok}
415 do_test lock-6.5 {
416   sqlite3_finalize $STMT
417 } {SQLITE_OK}
419 # At one point the following set of conditions would cause SQLite to 
420 # retain a RESERVED or EXCLUSIVE lock after the transaction was committed:
422 #   * The journal-mode is set to something other than 'delete', and
423 #   * there exists one or more active read-only statements, and
424 #   * a transaction that modified zero database pages is committed.
426 #set temp_status unlocked
427 #if {$TEMP_STORE>=2} {set temp_status unknown}
428 set temp_status unknown
429 do_test lock-7.1 {
430   set STMT [sqlite3_prepare $DB "SELECT * FROM sqlite_master" -1 TAIL]
431   sqlite3_step $STMT
432 } {SQLITE_ROW}
433 do_test lock-7.2 {
434   execsql { PRAGMA lock_status }
435 } [list main shared temp $temp_status]
436 do_test lock-7.3 {
437   execsql {
438     PRAGMA journal_mode = truncate;
439     BEGIN;
440     UPDATE t4 SET a = 10 WHERE 0;
441     COMMIT;
442   }
443   execsql { PRAGMA lock_status }
444 } [list main shared temp $temp_status]
445 do_test lock-7.4 {
446   sqlite3_finalize $STMT
447 } {SQLITE_OK}
449 do_test lock-999.1 {
450   rename db2 {}
451 } {}
453 finish_test