test/swarmvtab3.test

   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   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
 173 proc missing_db {filename ctx} {
 174   file copy $ctx $filename
 175 }
 176 db func missing_db missing_db
 177
 178 proc 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 }
 188 db func openclose_db openclose_db
 189
 190 proc 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
 202 foreach {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
 229 db close
 230 forcedelete {*}[glob test.db*]
 231 forcedelete {*}[glob test_remote.db*]
 232
 233 finish_test
 234