Debian Codegraph @

test/swarmvtab3.test

raw
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
15 set testdir [file dirname $argv0]
16 source $testdir/tester.tcl
17 set testprefix swarmvtab3
18 do_not_use_codec
19
20 ifcapable !vtab {
21 finish_test
22 return
23 }
24
25 load_static_extension db unionvtab
26
27 set nFile $sqlite_open_file_count
28
29 do_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.
35 do_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
53 proc missing_db {filename} {
54 set remote "remote_$filename"
55 forcedelete $filename
56 file copy $remote $filename
57 }
58 db func missing_db missing_db
59
60 proc 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 }
70 db func openclose_db openclose_db
71
72 proc 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
84 foreach {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
133 execsql { DROP TABLE IF EXISTS s }
134 for {set i 0} {$i < 100} {incr i} {
135 forcedelete remote_test.db$i
136 }
137
138 #----------------------------------------------------------------------------
139 #
140 do_execsql_test 2.0 {
141 DROP TABLE IF EXISTS swarm;
142 CREATE TEMP TABLE swarm(file, tbl, minval, maxval, ctx);
143 }
144
145 catch { 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.
150 do_test 2.1 {
151 catch { array unset ctx_used }
152 for {set i 0} {$i < 100} {incr i} {
153 while 1 {
154 set ctx [expr abs(int(rand() *1000000))]
155 if {[info exists ctx_used($ctx)]==0} break
156 }
157 set ctx_used($ctx) 1
158
159 set file test_remote.db$ctx
160 forcedelete $file
161 forcedelete test.db$i
162 sqlite3 rrr $file
163 rrr eval {
164 CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
165 INSERT INTO t1 VALUES($i, $i);
166 }
167 rrr close
168 db eval {
169 INSERT INTO swarm VALUES('test.db' || $i, 't1', $i, $i, $file)
170 }
171 set ::dbcache(test.db$i) 0
172 }
173 } {}
174
175 proc missing_db {filename ctx} {
176 file copy $ctx $filename
177 }
178 db func missing_db missing_db
179
180 proc openclose_db {filename ctx bClose} {
181 if {$bClose} {
182 incr ::dbcache($filename) -1
183 } else {
184 incr ::dbcache($filename) 1
185 }
186 if {$::dbcache($filename)==0} {
187 forcedelete $filename
188 }
189 }
190 db func openclose_db openclose_db
191
192 proc check_dbcache {} {
193 set n 0
194 foreach k [array names ::dbcache] {
195 set exists [file exists $k]
196 if {$exists!=($::dbcache($k)!=0)} {
197 error "inconsistent ::dbcache and disk ($k) - $exists"
198 }
199 incr n $exists
200 }
201 return $n
202 }
203
204 foreach {tn nMaxOpen cvt} {
205 2 5 {
206 CREATE VIRTUAL TABLE temp.s USING swarmvtab(
207 'SELECT file, tbl, minval, minval, ctx FROM swarm',
208 missing=missing_db,
209 openclose=openclose_db,
210 maxopen=5
211 )
212 }
213 } {
214 execsql { DROP TABLE IF EXISTS s }
215
216 do_execsql_test 3.$tn.1 $cvt
217
218 do_execsql_test 3.$tn.2 {
219 SELECT b FROM s WHERE a<10;
220 } {0 1 2 3 4 5 6 7 8 9}
221
222 do_test 3.$tn.3 { check_dbcache } $nMaxOpen
223
224 do_execsql_test 3.$tn.4 {
225 SELECT b FROM s WHERE (b%10)=0;
226 } {0 10 20 30 40 50 60 70 80 90}
227
228 do_test 3.$tn.5 { check_dbcache } $nMaxOpen
229 }
230
231 db close
232 forcedelete {*}[glob test.db*]
233 forcedelete {*}[glob test_remote.db*]
234
235 finish_test