1# 2017-07-15
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.  The
12# focus of this file is the "swarmvtab" extension
13#
14
15set testdir [file dirname $argv0]
16source $testdir/tester.tcl
17set testprefix swarmvtab3
18do_not_use_codec
19
20ifcapable !vtab {
21  finish_test
22  return
23}
24
25load_static_extension db unionvtab
26
27set nFile $sqlite_open_file_count
28
29do_execsql_test 1.0 {
30  CREATE TEMP TABLE swarm(id, tbl, minval, maxval);
31}
32
33# Set up 100 databases with filenames "remote_test.dbN", where N is between
34# 0 and 99.
35do_test 1.1 {
36  for {set i 0} {$i < 100} {incr i} {
37    set file remote_test.db$i
38    forcedelete $file
39    forcedelete test.db$i
40    sqlite3 rrr $file
41    rrr eval {
42      CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
43      INSERT INTO t1 VALUES($i, $i);
44    }
45    rrr close
46    db eval {
47      INSERT INTO swarm VALUES($i, 't1', $i, $i);
48    }
49    set ::dbcache(test.db$i) 0
50  }
51} {}
52
53proc missing_db {filename} {
54  set remote "remote_$filename"
55  forcedelete $filename
56  file copy $remote $filename
57}
58db func missing_db missing_db
59
60proc openclose_db {filename bClose} {
61  if {$bClose} {
62    incr ::dbcache($filename) -1
63  } else {
64    incr ::dbcache($filename) 1
65  }
66  if {$::dbcache($filename)==0} {
67    forcedelete $filename
68  }
69}
70db func openclose_db openclose_db
71
72proc check_dbcache {} {
73  set n 0
74  for {set i 0} {$i<100} {incr i} {
75    set exists [file exists test.db$i]
76    if {$exists!=($::dbcache(test.db$i)!=0)} {
77      error "inconsistent ::dbcache and disk ($i) - $exists"
78    }
79    incr n $exists
80  }
81  return $n
82}
83
84foreach {tn nMaxOpen cvt} {
85  1 5 {
86    CREATE VIRTUAL TABLE temp.s USING swarmvtab(
87        'SELECT :prefix || id, tbl, minval, minval FROM swarm',
88        :prefix='test.db',
89        missing=missing_db,
90        openclose=openclose_db,
91        maxopen=5
92    )
93  }
94
95  2 3 {
96    CREATE VIRTUAL TABLE temp.s USING swarmvtab(
97        'SELECT :prefix || id, tbl, minval, minval FROM swarm',
98        :prefix='test.db',
99        missing =       'missing_db',
100        openclose=[openclose_db],
101        maxopen = 3
102    )
103  }
104
105  3 1 {
106    CREATE VIRTUAL TABLE temp.s USING swarmvtab(
107        'SELECT :prefix||''.''||:suffix||id, tbl, minval, minval FROM swarm',
108        :prefix=test, :suffix=db,
109        missing =       'missing_db',
110        openclose=[openclose_db],
111        maxopen = 1
112    )
113  }
114
115} {
116  execsql { DROP TABLE IF EXISTS s }
117
118  do_execsql_test 1.$tn.1 $cvt
119
120  do_execsql_test 1.$tn.2 {
121    SELECT b FROM s WHERE a<10;
122  } {0 1 2 3 4 5 6 7 8 9}
123
124  do_test 1.$tn.3 { check_dbcache } $nMaxOpen
125
126  do_execsql_test 1.$tn.4 {
127    SELECT b FROM s WHERE (b%10)=0;
128  } {0 10 20 30 40 50 60 70 80 90}
129
130  do_test 1.$tn.5 { check_dbcache } $nMaxOpen
131}
132
133execsql { DROP TABLE IF EXISTS s }
134for {set i 0} {$i < 100} {incr i} {
135  forcedelete remote_test.db$i
136}
137
138#----------------------------------------------------------------------------
139#
140do_execsql_test 2.0 {
141  DROP TABLE IF EXISTS swarm;
142  CREATE TEMP TABLE swarm(file, tbl, minval, maxval, ctx);
143}
144
145catch { array unset ::dbcache }
146
147# Set up 100 databases with filenames "remote_test.dbN", where N is a
148# random integer between 0 and 1,000,000
149# 0 and 99.
150do_test 2.1 {
151  for {set i 0} {$i < 100} {incr i} {
152    while 1 {
153      set ctx [expr abs(int(rand() *1000000))]
154      if {[info exists ::dbcache($ctx)]==0} break
155    }
156
157    set file test_remote.db$ctx
158    forcedelete $file
159    forcedelete test.db$i
160    sqlite3 rrr $file
161    rrr eval {
162      CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
163      INSERT INTO t1 VALUES($i, $i);
164    }
165    rrr close
166    db eval {
167      INSERT INTO swarm VALUES('test.db' || $i, 't1', $i, $i, $file)
168    }
169    set ::dbcache(test.db$i) 0
170  }
171} {}
172
173proc missing_db {filename ctx} {
174  file copy $ctx $filename
175}
176db func missing_db missing_db
177
178proc openclose_db {filename ctx bClose} {
179  if {$bClose} {
180    incr ::dbcache($filename) -1
181  } else {
182    incr ::dbcache($filename) 1
183  }
184  if {$::dbcache($filename)==0} {
185    forcedelete $filename
186  }
187}
188db func openclose_db openclose_db
189
190proc check_dbcache {} {
191  set n 0
192  foreach k [array names ::dbcache] {
193    set exists [file exists $k]
194    if {$exists!=($::dbcache($k)!=0)} {
195      error "inconsistent ::dbcache and disk ($k) - $exists"
196    }
197    incr n $exists
198  }
199  return $n
200}
201
202foreach {tn nMaxOpen cvt} {
203  2 5 {
204    CREATE VIRTUAL TABLE temp.s USING swarmvtab(
205        'SELECT file, tbl, minval, minval, ctx FROM swarm',
206        missing=missing_db,
207        openclose=openclose_db,
208        maxopen=5
209    )
210  }
211} {
212  execsql { DROP TABLE IF EXISTS s }
213
214  do_execsql_test 3.$tn.1 $cvt
215
216  do_execsql_test 3.$tn.2 {
217    SELECT b FROM s WHERE a<10;
218  } {0 1 2 3 4 5 6 7 8 9}
219
220  do_test 3.$tn.3 { check_dbcache } $nMaxOpen
221
222  do_execsql_test 3.$tn.4 {
223    SELECT b FROM s WHERE (b%10)=0;
224  } {0 10 20 30 40 50 60 70 80 90}
225
226  do_test 3.$tn.5 { check_dbcache } $nMaxOpen
227}
228
229db close
230forcedelete {*}[glob test.db*]
231forcedelete {*}[glob test_remote.db*]
232
233finish_test
234