1# 2010 June 16
2#
3# The author disclaims copyright to this source code.  In place of
4# a legal notice, here is a blessing:
5#
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.
9#
10#***********************************************************************
11# This file implements regression tests for SQLite library. Specifically,
12# it tests SQLite when using a VFS that claims the SAFE_DELETE property.
13#
14
15set testdir [file dirname $argv0]
16source $testdir/tester.tcl
17source $testdir/lock_common.tcl
18source $testdir/malloc_common.tcl
19db close
20
21if {[permutation] == "inmemory_journal"} {
22  finish_test
23  return
24}
25
26set a_string_counter 1
27proc a_string {n} {
28  global a_string_counter
29  incr a_string_counter
30  string range [string repeat "${a_string_counter}." $n] 1 $n
31}
32
33# Create a [testvfs] and install it as the default VFS. Set the device
34# characteristics flags to "SAFE_DELETE".
35#
36testvfs tvfs -default 1
37tvfs devchar undeletable_when_open
38
39# Set up a hook so that each time a journal file is opened, closed or
40# deleted, the method name ("xOpen", "xClose" or "xDelete") and the final
41# segment of the journal file-name (i.e. "test.db-journal") are appended to
42# global list variable $::oplog.
43#
44tvfs filter {xOpen xClose xDelete}
45tvfs script journal_op_catcher
46proc journal_op_catcher {method filename args} {
47
48  # If global variable ::tvfs_error_on_write is defined, then return an
49  # IO error to every attempt to modify the file-system. Otherwise, return
50  # SQLITE_OK.
51  #
52  if {[info exists ::tvfs_error_on_write]} {
53    if {[lsearch {xDelete xWrite xTruncate} $method]>=0} {
54      return SQLITE_IOERR 
55    }
56  }
57
58  # The rest of this command only deals with xOpen(), xClose() and xDelete()
59  # operations on journal files. If this invocation does not represent such
60  # an operation, return with no further ado.
61  #
62  set f [file tail $filename]
63  if {[string match *journal $f]==0} return
64  if {[lsearch {xOpen xDelete xClose} $method]<0} return
65
66  # Append a record of this operation to global list variable $::oplog.
67  #
68  lappend ::oplog $method $f
69
70  # If this is an attempt to delete a journal file for which there exists
71  # one ore more open handles, return an error. The code in test_vfs.c
72  # will not invoke the xDelete method of the "real" VFS in this case.
73  #
74  if {[info exists ::open_journals($f)]==0} { set ::open_journals($f) 0 }
75  switch -- $method {
76    xOpen   { incr ::open_journals($f) +1 }
77    xClose  { incr ::open_journals($f) -1 }
78    xDelete { if {$::open_journals($f)>0} { return SQLITE_IOERR } }
79  }
80
81  return ""
82}
83
84
85do_test journal2-1.1 {
86  set ::oplog [list]
87  sqlite3 db test.db
88  execsql { CREATE TABLE t1(a, b) }
89  set ::oplog
90} {xOpen test.db-journal xClose test.db-journal xDelete test.db-journal}
91do_test journal2-1.2 {
92  set ::oplog [list]
93  execsql { 
94    PRAGMA journal_mode = truncate;
95    INSERT INTO t1 VALUES(1, 2);
96  }
97  set ::oplog
98} {xOpen test.db-journal}
99do_test journal2-1.3 {
100  set ::oplog [list]
101  execsql { INSERT INTO t1 VALUES(3, 4) }
102  set ::oplog
103} {}
104do_test journal2-1.4 { execsql { SELECT * FROM t1 } } {1 2 3 4}
105
106# Add a second connection. This connection attempts to commit data in
107# journal_mode=DELETE mode. When it tries to delete the journal file,
108# the VFS layer returns an IO error.
109#
110do_test journal2-1.5 {
111  set ::oplog [list]
112  sqlite3 db2 test.db
113  execsql  { PRAGMA journal_mode = delete } db2
114  catchsql { INSERT INTO t1 VALUES(5, 6)  } db2
115} {1 {disk I/O error}}
116do_test journal2-1.6 { file exists test.db-journal } 1
117do_test journal2-1.7 { execsql { SELECT * FROM t1 } } {1 2 3 4}
118do_test journal2-1.8 {
119  execsql { PRAGMA journal_mode = truncate } db2
120  execsql { INSERT INTO t1 VALUES(5, 6)  } db2
121} {}
122do_test journal2-1.9 { execsql { SELECT * FROM t1 } } {1 2 3 4 5 6}
123
124# Grow the database until it is reasonably large.
125#
126do_test journal2-1.10 {
127  db2 close
128  db func a_string a_string
129  execsql {
130    CREATE TABLE t2(a UNIQUE, b UNIQUE);
131    INSERT INTO t2 VALUES(a_string(200), a_string(300));
132    INSERT INTO t2 SELECT a_string(200), a_string(300) FROM t2;  --  2
133    INSERT INTO t2 SELECT a_string(200), a_string(300) FROM t2;  --  4
134    INSERT INTO t2 SELECT a_string(200), a_string(300) FROM t2;  --  8
135    INSERT INTO t2 SELECT a_string(200), a_string(300) FROM t2;  -- 16
136    INSERT INTO t2 SELECT a_string(200), a_string(300) FROM t2;  -- 32
137    INSERT INTO t2 SELECT a_string(200), a_string(300) FROM t2;  -- 64
138  }
139  file size test.db-journal
140} {0}
141do_test journal2-1.11 {
142  set sz [expr [file size test.db] / 1024]
143  expr {$sz>120 && $sz<200}
144} 1
145
146# Using new connection [db2] (with journal_mode=DELETE), write a lot of
147# data to the database. So that many pages within the database file are
148# modified before the transaction is committed.
149#
150# Then, enable simulated IO errors in all calls to xDelete, xWrite
151# and xTruncate before committing the transaction and closing the 
152# database file. From the point of view of other file-system users, it
153# appears as if the process hosting [db2] unexpectedly exited.
154# 
155do_test journal2-1.12 {
156  sqlite3 db2 test.db
157  execsql {
158    PRAGMA cache_size = 10;
159    BEGIN;
160      INSERT INTO t2 SELECT randomblob(200), randomblob(300) FROM t2;  -- 128
161  } db2
162} {}
163do_test journal2-1.13 {
164  tvfs filter {xOpen xClose xDelete xWrite xTruncate}
165  set ::tvfs_error_on_write 1
166  catchsql { COMMIT } db2
167} {1 {disk I/O error}}
168db2 close
169unset ::tvfs_error_on_write
170file copy -force test.db testX.db
171
172do_test journal2-1.14 { file exists test.db-journal } 1
173do_test journal2-1.15 {
174  execsql {
175    SELECT count(*) FROM t2;
176    PRAGMA integrity_check;
177  }
178} {64 ok}
179
180# This block checks that in the test case above, connection [db2] really
181# did begin writing to the database file before it hit IO errors. If
182# this is true, then the copy of the database file made before [db]
183# rolled back the hot journal should fail the integrity-check.
184#
185do_test journal2-1.16 {
186  set sz [expr [file size testX.db] / 1024]
187  expr {$sz>240 && $sz<400}
188} 1
189do_test journal2-1.17 {
190  expr {[catchsql { PRAGMA integrity_check } db] == "0 ok"}
191} {1}
192do_test journal2-1.20 {
193  sqlite3 db2 testX.db
194  expr {[catchsql { PRAGMA integrity_check } db2] == "0 ok"}
195} {0}
196do_test journal2-1.21 {
197  db2 close
198} {}
199db close
200
201#-------------------------------------------------------------------------
202# Test that it is possible to switch from journal_mode=truncate to
203# journal_mode=WAL on a SAFE_DELETE file-system. SQLite should close and
204# delete the journal file when committing the transaction that switches
205# the system to WAL mode.
206#
207ifcapable wal {
208  do_test journal2-2.1 {
209    faultsim_delete_and_reopen
210    set ::oplog [list]
211    execsql { PRAGMA journal_mode = persist }
212    set ::oplog
213  } {}
214  do_test journal2-2.2 {
215    execsql { 
216      CREATE TABLE t1(x);
217      INSERT INTO t1 VALUES(3.14159);
218    }
219    set ::oplog
220  } {xOpen test.db-journal}
221  do_test journal2-2.3 {
222    expr {[file size test.db-journal] > 512}
223  } {1}
224  do_test journal2-2.4 {
225    set ::oplog [list]
226    execsql { PRAGMA journal_mode = WAL }
227    set ::oplog
228  } {xClose test.db-journal xDelete test.db-journal}
229  db close
230}
231
232tvfs delete
233finish_test
234
235