third_party/sqlite/src/test/backcompat.test

   1 # 2010 August 19
   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 testing that the current version of SQLite
  13 # is capable of reading and writing databases created by previous
  14 # versions, and vice-versa.
  15 #
  16 # To use this test, old versions of the testfixture process should be
  17 # copied into the working directory alongside the new version. The old
  18 # versions should be named "testfixtureXXX" (or testfixtureXXX.exe on
  19 # windows), where XXX can be any string.
  20 #
  21 # This test file uses the tcl code for controlling a second testfixture
  22 # process located in lock_common.tcl. See the commments in lock_common.tcl
  23 # for documentation of the available commands.
  24 #
  25
  26 set testdir [file dirname $argv0]
  27 source $testdir/tester.tcl
  28 source $testdir/lock_common.tcl
  29 source $testdir/malloc_common.tcl
  30 source $testdir/bc_common.tcl
  31 db close
  32
  33 if {"" == [bc_find_binaries backcompat.test]} {
  34   finish_test
  35   return
  36 }
  37
  38 proc do_backcompat_test {rv bin1 bin2 script} {
  39
  40   forcedelete test.db
  41
  42   if {$bin1 != ""} { set ::bc_chan1 [launch_testfixture $bin1] }
  43   set ::bc_chan2 [launch_testfixture $bin2]
  44
  45   if { $rv } {
  46     proc code2 {tcl} { uplevel #0 $tcl }
  47     if {$bin1 != ""} { proc code2 {tcl} { testfixture $::bc_chan1 $tcl } }
  48     proc code1 {tcl} { testfixture $::bc_chan2 $tcl }
  49   } else {
  50     proc code1 {tcl} { uplevel #0 $tcl }
  51     if {$bin1 != ""} { proc code1 {tcl} { testfixture $::bc_chan1 $tcl } }
  52     proc code2 {tcl} { testfixture $::bc_chan2 $tcl }
  53   }
  54
  55   proc sql1 sql { code1 [list db eval $sql] }
  56   proc sql2 sql { code2 [list db eval $sql] }
  57
  58   code1 { sqlite3 db test.db }
  59   code2 { sqlite3 db test.db }
  60
  61   foreach c {code1 code2} {
  62     $c {
  63       set v [split [db version] .]
  64       if {[llength $v]==3} {lappend v 0}
  65       set ::sqlite_libversion [format \
  66         "%d%.2d%.2d%2d" [lindex $v 0] [lindex $v 1] [lindex $v 2] [lindex $v 3]
  67       ]
  68     }
  69   }
  70
  71   uplevel $script
  72
  73   catch { code1 { db close } }
  74   catch { code2 { db close } }
  75   catch { close $::bc_chan2 }
  76   catch { close $::bc_chan1 }
  77
  78
  79 }
  80
  81 array set ::incompatible [list]
  82 proc do_allbackcompat_test {script} {
  83
  84   foreach bin $::BC(binaries) {
  85     set nErr [set_test_counter errors]
  86     foreach dir {0 1} {
  87
  88       set bintag [string map {testfixture {}} $bin]
  89       set bintag [string map {\.exe {}} $bintag]
  90       if {$bintag == ""} {set bintag self}
  91       set ::bcname ".$bintag.$dir."
  92
  93       rename do_test _do_test
  94       proc do_test {nm sql res} {
  95         set nm [regsub {\.} $nm $::bcname]
  96         uplevel [list _do_test $nm $sql $res]
  97       }
  98
  99       do_backcompat_test $dir {} $bin $script
 100
 101       rename do_test {}
 102       rename _do_test do_test
 103     }
 104     if { $nErr < [set_test_counter errors] } {
 105       set ::incompatible([get_version $bin]) 1
 106     }
 107   }
 108 }
 109
 110 proc read_file {zFile} {
 111   set zData {}
 112   if {[file exists $zFile]} {
 113     set fd [open $zFile]
 114     fconfigure $fd -translation binary -encoding binary
 115
 116     if {[file size $zFile]<=$::sqlite_pending_byte || $zFile != "test.db"} {
 117       set zData [read $fd]
 118     } else {
 119       set zData [read $fd $::sqlite_pending_byte]
 120       append zData [string repeat x 512]
 121       seek $fd [expr $::sqlite_pending_byte+512] start
 122       append zData [read $fd]
 123     }
 124
 125     close $fd
 126   }
 127   return $zData
 128 }
 129 proc write_file {zFile zData} {
 130   set fd [open $zFile w]
 131   fconfigure $fd -translation binary -encoding binary
 132   puts -nonewline $fd $zData
 133   close $fd
 134 }
 135 proc read_file_system {} {
 136   set ret [list]
 137   foreach f {test.db test.db-journal test.db-wal} { lappend ret [read_file $f] }
 138   set ret
 139 }
 140 proc write_file_system {data} {
 141   foreach f {test.db test.db-journal test.db-wal} d $data {
 142     if {[string length $d] == 0} {
 143       forcedelete $f
 144     } else {
 145       write_file $f $d
 146     }
 147   }
 148 }
 149
 150 #-------------------------------------------------------------------------
 151 # Actual tests begin here.
 152 #
 153 # This first block of tests checks to see that the same database and
 154 # journal files can be used by old and new versions. WAL and wal-index
 155 # files are tested separately below.
 156 #
 157 do_allbackcompat_test {
 158
 159   # Test that database files are backwards compatible.
 160   #
 161   do_test backcompat-1.1.1 { sql1 {
 162     CREATE TABLE t1(a PRIMARY KEY, b UNIQUE);
 163     INSERT INTO t1 VALUES('abc', 'def');
 164   } } {}
 165   do_test backcompat-1.1.2 { sql2 { SELECT * FROM t1; } } {abc def}
 166   do_test backcompat-1.1.3 { sql2 { INSERT INTO t1 VALUES('ghi', 'jkl'); } } {}
 167   do_test backcompat-1.1.4 { sql1 { SELECT * FROM t1; } } {abc def ghi jkl}
 168   do_test backcompat-1.1.5 { sql1 { PRAGMA integrity_check } } {ok}
 169   do_test backcompat-1.1.6 { sql2 { PRAGMA integrity_check } } {ok}
 170
 171   # Test that one version can roll back a hot-journal file left in the
 172   # file-system by the other version.
 173   #
 174   # Each test case is named "backcompat-1.X...", where X is either 0 or
 175   # 1. If it is 0, then the current version creates a journal file that
 176   # the old versions try to read. Otherwise, if X is 1, then the old version
 177   # creates the journal file and we try to read it with the current version.
 178   #
 179   do_test backcompat-1.2.1 { sql1 {
 180     PRAGMA cache_size = 10;
 181     BEGIN;
 182       INSERT INTO t1 VALUES(randomblob(400), randomblob(400));
 183       INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1;
 184       INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1;
 185       INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1;
 186       INSERT INTO t1 SELECT randomblob(400), randomblob(400) FROM t1;
 187     COMMIT;
 188   } } {}
 189   set cksum1 [sql1 {SELECT md5sum(a), md5sum(b) FROM t1}]
 190   set cksum2 [sql2 {SELECT md5sum(a), md5sum(b) FROM t1}]
 191   do_test backcompat-1.2.2 [list string compare $cksum1 $cksum2] 0
 192
 193   do_test backcompat-1.2.3 { sql1 {
 194     BEGIN;
 195       UPDATE t1 SET a = randomblob(500);
 196   } } {}
 197   set data [read_file_system]
 198
 199   do_test backcompat-1.2.4 { sql1 { COMMIT } } {}
 200
 201   set same [expr {[sql2 {SELECT md5sum(a), md5sum(b) FROM t1}] == $cksum2}]
 202   do_test backcompat-1.2.5 [list set {} $same] 0
 203
 204   code1 { db close }
 205   code2 { db close }
 206   write_file_system $data
 207   code1 { sqlite3 db test.db }
 208   code2 { sqlite3 db test.db }
 209
 210   set same [expr {[sql2 {SELECT md5sum(a), md5sum(b) FROM t1}] == $cksum2}]
 211   do_test backcompat-1.2.6 [list set {} $same] 1
 212
 213   do_test backcompat-1.2.7 { sql1 { PRAGMA integrity_check } } {ok}
 214   do_test backcompat-1.2.8 { sql2 { PRAGMA integrity_check } } {ok}
 215
 216   do_test backcompat-2.1 {
 217     sql1 {
 218       CREATE TABLE t2(a UNIQUE, b PRIMARY KEY, c UNIQUE);
 219       INSERT INTO t2 VALUES(1,9,5);
 220       INSERT INTO t2 VALUES(5,5,1);
 221       INSERT INTO t2 VALUES(9,1,9);
 222       SELECT * FROM t2 ORDER BY a;
 223     }
 224   } {1 9 5 5 5 1 9 1 9}
 225   do_test backcompat-2.2 {
 226     sql2 {
 227       SELECT * FROM sqlite_master WHERE rootpage=-1;
 228       SELECT * FROM t2 ORDER BY a;
 229     }
 230   } {1 9 5 5 5 1 9 1 9}
 231   do_test backcompat-2.3 {
 232     sql1 {
 233       SELECT * FROM t2 ORDER BY b;
 234     }
 235   } {9 1 9 5 5 1 1 9 5}
 236   do_test backcompat-2.4 {
 237     sql2 {
 238       SELECT * FROM t2 ORDER BY b;
 239     }
 240   } {9 1 9 5 5 1 1 9 5}
 241   do_test backcompat-2.5 {
 242     sql1 {
 243       SELECT * FROM t2 ORDER BY c;
 244     }
 245   } {5 5 1 1 9 5 9 1 9}
 246   do_test backcompat-2.6 {
 247     sql2 {
 248       SELECT * FROM t2 ORDER BY c;
 249     }
 250   } {5 5 1 1 9 5 9 1 9}
 251 }
 252 foreach k [lsort [array names ::incompatible]] {
 253   puts "ERROR: Detected journal incompatibility with version $k"
 254 }
 255 unset ::incompatible
 256
 257
 258 #-------------------------------------------------------------------------
 259 # Test that WAL and wal-index files may be shared between different
 260 # SQLite versions.
 261 #
 262 do_allbackcompat_test {
 263   if {[code1 {sqlite3 -version}] >= "3.7.0"
 264    && [code1 {set ::sqlite_options(wal)}]
 265    && [code2 {sqlite3 -version}] >= "3.7.0"
 266    && [code2 {set ::sqlite_options(wal)}]
 267   } {
 268
 269     do_test backcompat-2.1.1 { sql1 {
 270       PRAGMA journal_mode = WAL;
 271       CREATE TABLE t1(a PRIMARY KEY, b UNIQUE);
 272       INSERT INTO t1 VALUES('I', 1);
 273       INSERT INTO t1 VALUES('II', 2);
 274       INSERT INTO t1 VALUES('III', 3);
 275       SELECT * FROM t1;
 276     } } {wal I 1 II 2 III 3}
 277     do_test backcompat-2.1.2 { sql2 {
 278       SELECT * FROM t1;
 279     } } {I 1 II 2 III 3}
 280
 281     set data [read_file_system]
 282     code1 {db close}
 283     code2 {db close}
 284     write_file_system $data
 285     code1 {sqlite3 db test.db}
 286     code2 {sqlite3 db test.db}
 287
 288     # The WAL file now in the file-system was created by the [code1]
 289     # process. Check that the [code2] process can recover the log.
 290     #
 291     do_test backcompat-2.1.3 { sql2 {
 292       SELECT * FROM t1;
 293     } } {I 1 II 2 III 3}
 294     do_test backcompat-2.1.4 { sql1 {
 295       SELECT * FROM t1;
 296     } } {I 1 II 2 III 3}
 297   }
 298 }
 299
 300 #-------------------------------------------------------------------------
 301 # Test that FTS3 tables may be read/written by different versions of
 302 # SQLite.
 303 #
 304 ifcapable fts3 {
 305   set contents {
 306     CREATE VIRTUAL TABLE t1 USING fts3(a, b);
 307   }
 308   foreach {num doc} {
 309     one "jk zm jk eczkjblu urvysbnykk sk gnl jk ttvgf hmjf"
 310     two "jk bnhc jjrxpjkb mjpavjuhw fibokdry igju jk zm zm xh"
 311     three "wxe ogttbykvt uhzq xr iaf zf urvysbnykk aayxpmve oacaxgjoo mjpavjuhw"
 312     four "gazrt jk ephknonq myjp uenvbm wuvajhwqz jk zm xnxhf nvfasfh"
 313     five "zm aayxpmve csjqxhgj xnxhf xr jk aayxpmve xnxhf zm zm"
 314     six "sokcyf zm ogyavjvv jk zm fibokdry zm jk igju igju"
 315     seven "vgsld bvgimjik xuprtlyle jk akmikrqyt jk aayxpmve hkfoudzftq ddjj"
 316     eight "zm uhzq ovkyevlgv zk uenvbm csjqxhgj jk vgsld pgybs jk"
 317     nine  "zm agmckuiu zexh fibokdry jk uhzq bu tugflixoex xnxhf sk"
 318   } {
 319     append contents "INSERT INTO t1 VALUES('$num', '$doc');"
 320   }
 321   do_allbackcompat_test {
 322     if {[code1 {set ::sqlite_options(fts3)}]
 323      && [code2 {set ::sqlite_options(fts3)}]
 324     } {
 325
 326       do_test backcompat-3.1 { sql1 $contents } {}
 327
 328       foreach {n q} {
 329         1    "SELECT * FROM t1 ORDER BY a, b"
 330         2    "SELECT rowid FROM t1 WHERE a MATCH 'five'"
 331         3    "SELECT * FROM t1 WHERE a MATCH 'five'"
 332         4    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'jk'"
 333         5    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'tug* OR eight'"
 334       } {
 335         do_test backcompat-3.2 [list sql1 $q] [sql2 $q]
 336       }
 337
 338       do_test backcompat-3.3 { sql1 {
 339         INSERT INTO t1 SELECT * FROM t1;
 340         INSERT INTO t1 SELECT * FROM t1;
 341         INSERT INTO t1 SELECT * FROM t1;
 342         INSERT INTO t1 SELECT * FROM t1;
 343         INSERT INTO t1 SELECT * FROM t1;
 344         INSERT INTO t1 SELECT * FROM t1;
 345         INSERT INTO t1 SELECT * FROM t1;
 346         INSERT INTO t1 SELECT * FROM t1;
 347       } } {}
 348
 349       foreach {n q} {
 350         1    "SELECT * FROM t1 ORDER BY a, b"
 351         2    "SELECT rowid FROM t1 WHERE a MATCH 'five'"
 352         3    "SELECT * FROM t1 WHERE a MATCH 'five'"
 353         4    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'jk'"
 354         5    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'tug* OR eight'"
 355       } {
 356         do_test backcompat-3.4 [list sql1 $q] [sql2 $q]
 357       }
 358
 359       set alphabet "a b c d e f g h i j k l m n o p q r s t u v w x y z 1 2 3 4"
 360       for {set i 0} {$i < 900} {incr i} {
 361         set term "[lindex $alphabet [expr $i/30]][lindex $alphabet [expr $i%30]] "
 362         sql1 "INSERT INTO t1 VALUES($i, '[string repeat $term 14]')"
 363       }
 364
 365       foreach {n q} {
 366         1    "SELECT * FROM t1 ORDER BY a, b"
 367         2    "SELECT rowid FROM t1 WHERE a MATCH 'five'"
 368         3    "SELECT * FROM t1 WHERE a MATCH 'five'"
 369         4    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'jk'"
 370         5    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'tug* OR eight'"
 371
 372         6    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'aa'"
 373         7    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH '44'"
 374         8    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'a*'"
 375       } {
 376         do_test backcompat-3.5 [list sql1 $q] [sql2 $q]
 377       }
 378
 379       do_test backcompat-3.6 {
 380         sql1 "SELECT optimize(t1) FROM t1 LIMIT 1"
 381       } {{Index optimized}}
 382
 383       foreach {n q} {
 384         1    "SELECT * FROM t1 ORDER BY a, b"
 385         2    "SELECT rowid FROM t1 WHERE a MATCH 'five'"
 386         3    "SELECT * FROM t1 WHERE a MATCH 'five'"
 387         4    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'jk'"
 388         5    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'tug* OR eight'"
 389
 390         6    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'aa'"
 391         7    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH '44'"
 392         8    "SELECT offsets(t1) FROM t1 WHERE t1 MATCH 'a*'"
 393       } {
 394         do_test backcompat-3.7 [list sql1 $q] [sql2 $q]
 395       }
 396
 397       # Now test that an incremental merge can be started by one version
 398       # and finished by another. And that the integrity-check still
 399       # passes.
 400       do_test backcompat-3.8 {
 401         sql1 {
 402           DROP TABLE IF EXISTS t1;
 403           DROP TABLE IF EXISTS t2;
 404           CREATE TABLE t1(docid, words);
 405           CREATE VIRTUAL TABLE t2 USING fts3(words);
 406         }
 407         code1 [list source $testdir/genesis.tcl]
 408         code1 { fts_kjv_genesis }
 409         sql1 {
 410           INSERT INTO t2 SELECT words FROM t1;
 411           INSERT INTO t2 SELECT words FROM t1;
 412           INSERT INTO t2 SELECT words FROM t1;
 413           INSERT INTO t2 SELECT words FROM t1;
 414           INSERT INTO t2 SELECT words FROM t1;
 415           INSERT INTO t2 SELECT words FROM t1;
 416           SELECT level, group_concat(idx, ' ') FROM t2_segdir GROUP BY level;
 417         }
 418       } {0 {0 1 2 3 4 5}}
 419
 420       if {[code1 { set ::sqlite_libversion }] >=3071200
 421        && [code2 { set ::sqlite_libversion }] >=3071200
 422       } {
 423         do_test backcompat-3.9 {
 424           sql1 { INSERT INTO t2(t2) VALUES('merge=100,4'); }
 425           sql2 { INSERT INTO t2(t2) VALUES('merge=100,4'); }
 426           sql1 { INSERT INTO t2(t2) VALUES('merge=100,4'); }
 427           sql2 { INSERT INTO t2(t2) VALUES('merge=2500,4'); }
 428           sql2 {
 429             SELECT level, group_concat(idx, ' ') FROM t2_segdir GROUP BY level;
 430           }
 431         } {0 {0 1} 1 0}
 432
 433         do_test backcompat-3.10 {
 434           sql1 { INSERT INTO t2(t2) VALUES('integrity-check') }
 435           sql2 { INSERT INTO t2(t2) VALUES('integrity-check') }
 436         } {}
 437       }
 438     }
 439   }
 440 }
 441
 442 #-------------------------------------------------------------------------
 443 # Test that Rtree tables may be read/written by different versions of
 444 # SQLite.
 445 #
 446 ifcapable rtree {
 447   set contents {
 448     CREATE VIRTUAL TABLE t1 USING rtree(id, x1, x2, y1, y2);
 449   }
 450   foreach {id x1 x2 y1 y2} {
 451     1    -47.64 43.87    33.86 34.42        2    -21.51 17.32    2.05 31.04
 452     3    -43.67 -38.33    -19.79 3.43       4    32.41 35.16    9.12 19.82
 453     5    33.28 34.87    14.78 28.26         6    49.31 116.59    -9.87 75.09
 454     7    -14.93 34.51    -17.64 64.09       8    -43.05 23.43    -1.19 69.44
 455     9    44.79 133.56    28.09 80.30        10    -2.66 81.47    -41.38 -10.46
 456     11    -42.89 -3.54    15.76 71.63       12    -3.50 84.96    -11.64 64.95
 457     13    -45.69 26.25    11.14 55.06       14    -44.09 11.23    17.52 44.45
 458     15    36.23 133.49    -19.38 53.67      16    -17.89 81.54    14.64 50.61
 459     17    -41.97 -24.04    -39.43 28.95     18    -5.85 7.76    -6.38 47.02
 460     19    18.82 27.10    42.82 100.09       20    39.17 113.45    26.14 73.47
 461     21    22.31 103.17    49.92 106.05      22    -43.06 40.38    -1.75 76.08
 462     23    2.43 57.27    -14.19 -3.83        24    -47.57 -4.35    8.93 100.06
 463     25    -37.47 49.14    -29.11 8.81       26    -7.86 75.72    49.34 107.42
 464     27    1.53 45.49    20.36 49.74         28    -48.48 32.54    28.81 54.45
 465     29    2.67 39.77    -4.05 13.67         30    4.11 62.88    -47.44 -5.72
 466     31    -21.47 51.75    37.25 116.09      32    45.59 111.37    -6.43 43.64
 467     33    35.23 48.29    23.54 113.33       34    16.61 68.35    -14.69 65.97
 468     35    13.98 16.60    48.66 102.87       36    19.74 23.84    31.15 77.27
 469     37    -27.61 24.43    7.96 94.91        38    -34.77 12.05    -22.60 -6.29
 470     39    -25.83 8.71    -13.48 -12.53      40    -17.11 -1.01    18.06 67.89
 471     41    14.13 71.72    -3.78 39.25        42    23.75 76.00    -16.30 8.23
 472     43    -39.15 28.63    38.12 125.88      44    48.62 86.09    36.49 102.95
 473     45    -31.39 -21.98    2.52 89.78       46    5.65 56.04    15.94 89.10
 474     47    18.28 95.81    46.46 143.08       48    30.93 102.82    -20.08 37.36
 475     49    -20.78 -3.48    -5.58 35.46       50    49.85 90.58    -24.48 46.29
 476   } {
 477   if {$x1 >= $x2 || $y1 >= $y2} { error "$x1 $x2 $y1 $y2" }
 478     append contents "INSERT INTO t1 VALUES($id, $x1, $x2, $y1, $y2);"
 479   }
 480   set queries {
 481     1    "SELECT id FROM t1 WHERE x1>10 AND x2<44"
 482     2    "SELECT id FROM t1 WHERE y1<100"
 483     3    "SELECT id FROM t1 WHERE y1<100 AND x1>0"
 484     4    "SELECT id FROM t1 WHERE y1>10 AND x1>0 AND x2<50 AND y2<550"
 485   }
 486   do_allbackcompat_test {
 487     if {[code1 {set ::sqlite_options(fts3)}]
 488      && [code2 {set ::sqlite_options(fts3)}]
 489     } {
 490
 491       do_test backcompat-4.1 { sql1 $contents } {}
 492
 493       foreach {n q} $::queries {
 494         do_test backcompat-4.2.$n [list sql1 $q] [sql2 $q]
 495       }
 496
 497       do_test backcompat-4.3 { sql1 {
 498         INSERT INTO t1 SELECT id+100, x1+10.0, x2+10.0, y1-10.0, y2-10.0 FROM t1;
 499       } } {}
 500
 501       foreach {n q} $::queries {
 502         do_test backcompat-4.4.$n [list sql1 $q] [sql2 $q]
 503       }
 504
 505       do_test backcompat-4.5 { sql2 {
 506         INSERT INTO t1 SELECT id+200, x1+20.0, x2+20.0, y1-20.0, y2-20.0 FROM t1;
 507       } } {}
 508
 509       foreach {n q} $::queries {
 510         do_test backcompat-4.6.$n [list sql1 $q] [sql2 $q]
 511       }
 512
 513     }
 514   }
 515 }
 516
 517 finish_test