1# 2010 October 29 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# 12 13set testdir [file dirname $argv0] 14source $testdir/tester.tcl 15source $testdir/malloc_common.tcl 16 17# The tests in this file assume that SQLite is compiled without 18# ENABLE_8_3_NAMES. 19# 20ifcapable 8_3_names { 21 puts -nonewline "SQLite compiled with SQLITE_ENABLE_8_3_NAMES. " 22 puts "Skipping tests multiplex-*." 23 finish_test 24 return 25} 26 27set g_chunk_size [ expr ($::SQLITE_MAX_PAGE_SIZE*16384) ] 28set g_max_chunks 32 29 30# This handles appending the chunk number 31# to the end of the filename. if 32# SQLITE_MULTIPLEX_EXT_OVWR is defined, then 33# it overwrites the last 2 bytes of the 34# file name with the chunk number. 35proc multiplex_name {name chunk} { 36 if {$chunk==0} { return $name } 37 set num [format "%03d" $chunk] 38 ifcapable {multiplex_ext_overwrite} { 39 set name [string range $name 0 [expr [string length $name]-2-1]] 40 } 41 return $name$num 42} 43 44# This saves off the parameters and calls the 45# underlying sqlite3_multiplex_control() API. 46proc multiplex_set {db name chunk_size max_chunks} { 47 global g_chunk_size 48 global g_max_chunks 49 set g_chunk_size [ expr (($chunk_size+($::SQLITE_MAX_PAGE_SIZE-1)) & ~($::SQLITE_MAX_PAGE_SIZE-1)) ] 50 set g_max_chunks $max_chunks 51 set rc [catch {sqlite3_multiplex_control $db $name chunk_size $chunk_size} msg] 52 if { $rc==0 } { 53 set rc [catch {sqlite3_multiplex_control $db $name max_chunks $max_chunks} msg] 54 } 55 list $msg 56} 57 58# This attempts to delete the base file and 59# and files with the chunk extension. 60proc multiplex_delete {name} { 61 global g_max_chunks 62 forcedelete $name 63 for {set i 0} {$i<$g_max_chunks} {incr i} { 64 forcedelete [multiplex_name $name $i] 65 forcedelete [multiplex_name $name-journal $i] 66 forcedelete [multiplex_name $name-wal $i] 67 } 68} 69 70db close 71 72multiplex_delete test.db 73multiplex_delete test2.db 74 75#------------------------------------------------------------------------- 76# multiplex-1.1.*: Test initialize and shutdown. 77 78do_test multiplex-1.1 { sqlite3_multiplex_initialize nosuchvfs 1 } {SQLITE_ERROR} 79do_test multiplex-1.2 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 80do_test multiplex-1.3 { sqlite3_multiplex_initialize "" 1 } {SQLITE_MISUSE} 81do_test multiplex-1.4 { sqlite3_multiplex_shutdown } {SQLITE_OK} 82 83do_test multiplex-1.5 { sqlite3_multiplex_initialize "" 0 } {SQLITE_OK} 84do_test multiplex-1.6 { sqlite3_multiplex_shutdown } {SQLITE_OK} 85do_test multiplex-1.7 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 86do_test multiplex-1.8 { sqlite3_multiplex_shutdown } {SQLITE_OK} 87 88 89do_test multiplex-1.9.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 90do_test multiplex-1.9.2 { sqlite3 db test.db } {} 91do_test multiplex-1.9.3 { multiplex_set db main 32768 16 } {SQLITE_OK} 92do_test multiplex-1.9.4 { multiplex_set db main 32768 -1 } {SQLITE_OK} 93do_test multiplex-1.9.6 { multiplex_set db main 31 16 } {SQLITE_OK} 94do_test multiplex-1.9.7 { multiplex_set db main 32768 100 } {SQLITE_OK} 95do_test multiplex-1.9.8 { multiplex_set db main 1073741824 1 } {SQLITE_OK} 96do_test multiplex-1.9.9 { db close } {} 97do_test multiplex-1.9.10 { sqlite3_multiplex_shutdown } {SQLITE_OK} 98 99do_test multiplex-1.10.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 100do_test multiplex-1.10.2 { sqlite3 db test.db } {} 101do_test multiplex-1.10.3 { lindex [ catchsql { SELECT multiplex_control(2, 32768); } ] 0 } {0} 102do_test multiplex-1.10.4 { lindex [ catchsql { SELECT multiplex_control(3, -1); } ] 0 } {0} 103do_test multiplex-1.10.6 { lindex [ catchsql { SELECT multiplex_control(2, 31); } ] 0 } {0} 104do_test multiplex-1.10.7 { lindex [ catchsql { SELECT multiplex_control(3, 100); } ] 0 } {0} 105do_test multiplex-1.10.8 { lindex [ catchsql { SELECT multiplex_control(2, 1073741824); } ] 0 } {0} 106do_test multiplex-1.10.9 { db close } {} 107do_test multiplex-1.10.10 { sqlite3_multiplex_shutdown } {SQLITE_OK} 108 109do_test multiplex-1.11.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 110do_test multiplex-1.11.2 { sqlite3 db test.db } {} 111do_test multiplex-1.11.3 { sqlite3_multiplex_control db main enable 0 } {SQLITE_OK} 112do_test multiplex-1.11.4 { sqlite3_multiplex_control db main enable 1 } {SQLITE_OK} 113do_test multiplex-1.11.5 { sqlite3_multiplex_control db main enable -1 } {SQLITE_OK} 114do_test multiplex-1.11.6 { db close } {} 115do_test multiplex-1.11.7 { sqlite3_multiplex_shutdown } {SQLITE_OK} 116 117do_test multiplex-1.12.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 118do_test multiplex-1.12.2 { sqlite3 db test.db } {} 119do_test multiplex-1.12.3 { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 } {0} 120do_test multiplex-1.12.4 { lindex [ catchsql { SELECT multiplex_control(1, 1); } ] 0 } {0} 121do_test multiplex-1.12.5 { lindex [ catchsql { SELECT multiplex_control(1, -1); } ] 0 } {0} 122do_test multiplex-1.12.6 { db close } {} 123do_test multiplex-1.12.7 { sqlite3_multiplex_shutdown } {SQLITE_OK} 124 125do_test multiplex-1.13.1 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 126do_test multiplex-1.13.2 { sqlite3 db test.db } {} 127do_test multiplex-1.13.3 { lindex [ catchsql { SELECT multiplex_control(-1, 0); } ] 0 } {1} 128do_test multiplex-1.13.4 { lindex [ catchsql { SELECT multiplex_control(4, 1); } ] 0 } {1} 129do_test multiplex-1.13.6 { db close } {} 130do_test multiplex-1.13.7 { sqlite3_multiplex_shutdown } {SQLITE_OK} 131 132#------------------------------------------------------------------------- 133# Some simple warm-body tests with a single database file in rollback 134# mode: 135# 136# multiplex-2.1.*: Test simple writing to a multiplex file. 137# 138# multiplex-2.2.*: More writing. 139# 140# multiplex-2.3.*: Open and close a second db. 141# 142# multiplex-2.4.*: Try to shutdown the multiplex system before closing the db 143# file. Check that this fails and the multiplex system still works 144# afterwards. Then close the database and successfully shut 145# down the multiplex system. 146# 147# multiplex-2.5.*: More reading/writing. 148# 149# multiplex-2.6.*: More reading/writing with varying small chunk sizes, as 150# well as varying journal mode. 151# 152# multiplex-2.7.*: Disable/enable tests. 153# 154 155sqlite3_multiplex_initialize "" 1 156multiplex_set db main 32768 16 157 158forcedelete test.x 159foreach f [glob -nocomplain {test.x*[0-9][0-9][0-9]}] { 160 forcedelete $f 161} 162do_test multiplex-2.1.2 { 163 sqlite3 db test.x 164 execsql { 165 PRAGMA page_size=1024; 166 PRAGMA auto_vacuum=OFF; 167 PRAGMA journal_mode=DELETE; 168 } 169 execsql { 170 CREATE TABLE t1(a, b); 171 INSERT INTO t1 VALUES(1, randomblob(1100)); 172 INSERT INTO t1 VALUES(2, randomblob(1100)); 173 } 174} {} 175do_test multiplex-2.1.3 { file size [multiplex_name test.x 0] } {4096} 176do_test multiplex-2.1.4 { 177 execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) } 178} {} 179 180do_test multiplex-2.2.1 { 181 execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) } 182} {} 183do_test multiplex-2.2.3 { file size [multiplex_name test.x 0] } {6144} 184 185do_test multiplex-2.3.1 { 186 sqlite3 db2 test2.x 187 db2 close 188} {} 189 190 191do_test multiplex-2.4.1 { 192 sqlite3_multiplex_shutdown 193} {SQLITE_MISUSE} 194do_test multiplex-2.4.2 { 195 execsql { INSERT INTO t1 VALUES(3, randomblob(1100)) } 196} {} 197do_test multiplex-2.4.4 { file size [multiplex_name test.x 0] } {7168} 198do_test multiplex-2.4.5 { 199 db close 200 sqlite3 db test.x 201 db eval vacuum 202 db close 203 glob test.x* 204} {test.x} 205do_test multiplex-2.4.99 { 206 sqlite3_multiplex_shutdown 207} {SQLITE_OK} 208 209do_test multiplex-2.5.1 { 210 multiplex_delete test.x 211 sqlite3_multiplex_initialize "" 1 212 sqlite3 db test.x 213 multiplex_set db main 4096 16 214} {SQLITE_OK} 215 216do_test multiplex-2.5.2 { 217 execsql { 218 PRAGMA page_size = 1024; 219 PRAGMA journal_mode = delete; 220 PRAGMA auto_vacuum = off; 221 CREATE TABLE t1(a PRIMARY KEY, b); 222 } 223} {delete} 224 225do_test multiplex-2.5.3 { 226 execsql { 227 INSERT INTO t1 VALUES(1, 'one'); 228 INSERT INTO t1 VALUES(2, randomblob(4000)); 229 INSERT INTO t1 VALUES(3, 'three'); 230 INSERT INTO t1 VALUES(4, randomblob(4000)); 231 INSERT INTO t1 VALUES(5, 'five'); 232 INSERT INTO t1 VALUES(6, randomblob($g_chunk_size)); 233 INSERT INTO t1 VALUES(7, randomblob($g_chunk_size)); 234 } 235} {} 236 237do_test multiplex-2.5.4 { 238 db eval {SELECT * FROM t1 WHERE a=1} 239} {1 one} 240 241do_test multiplex-2.5.5 { 242 db eval {SELECT * FROM t1 WHERE a=3} 243} {3 three} 244 245do_test multiplex-2.5.6 { 246 db eval {SELECT * FROM t1 WHERE a=5} 247} {5 five} 248 249do_test multiplex-2.5.7 { 250 db eval {SELECT a,length(b) FROM t1 WHERE a=2} 251} {2 4000} 252 253do_test multiplex-2.5.8 { 254 db eval {SELECT a,length(b) FROM t1 WHERE a=4} 255} {4 4000} 256 257do_test multiplex-2.5.9 { file size [multiplex_name test.x 0] } [list $g_chunk_size] 258do_test multiplex-2.5.10 { file size [multiplex_name test.x 1] } [list $g_chunk_size] 259 260do_test multiplex-2.5.99 { 261 db close 262 sqlite3_multiplex_shutdown 263} {SQLITE_OK} 264 265 266set all_journal_modes {delete persist truncate memory off} 267foreach jmode $all_journal_modes { 268 for {set sz 151} {$sz<8000} {set sz [expr $sz+419]} { 269 270 do_test multiplex-2.6.1.$sz.$jmode { 271 multiplex_delete test.db 272 sqlite3_multiplex_initialize "" 1 273 sqlite3 db test.db 274 multiplex_set db main $sz 32 275 } {SQLITE_OK} 276 277 do_test multiplex-2.6.2.$sz.$jmode { 278 db eval { 279 PRAGMA page_size = 1024; 280 PRAGMA auto_vacuum = off; 281 } 282 db eval "PRAGMA journal_mode = $jmode;" 283 } $jmode 284 285 do_test multiplex-2.6.3.$sz.$jmode { 286 execsql { 287 CREATE TABLE t1(a PRIMARY KEY, b); 288 INSERT INTO t1 VALUES(1, 'one'); 289 INSERT INTO t1 VALUES(2, randomblob($g_chunk_size)); 290 } 291 } {} 292 293 do_test multiplex-2.6.4.$sz.$jmode { 294 db eval {SELECT b FROM t1 WHERE a=1} 295 } {one} 296 297 do_test multiplex-2.6.5.$sz.$jmode { 298 db eval {SELECT length(b) FROM t1 WHERE a=2} 299 } [list $g_chunk_size] 300 301 do_test multiplex-2.6.6.$sz.$jmode { file size [multiplex_name test.db 0] } [list $g_chunk_size] 302 303 do_test multiplex-2.6.99.$sz.$jmode { 304 db close 305 sqlite3_multiplex_shutdown 306 } {SQLITE_OK} 307 308 } 309} 310 311do_test multiplex-2.7.1 { multiplex_delete test.db } {} 312do_test multiplex-2.7.2 { sqlite3_multiplex_initialize "" 1 } {SQLITE_OK} 313do_test multiplex-2.7.3 { sqlite3 db test.db } {} 314do_test multiplex-2.7.4 { lindex [ catchsql { SELECT multiplex_control(2, 65536); } ] 0 } {0} 315do_test multiplex-2.7.5 { lindex [ catchsql { SELECT multiplex_control(1, 0); } ] 0 } {0} 316do_test multiplex-2.7.6 { 317 execsql { 318 CREATE TABLE t1(a PRIMARY KEY, b); 319 INSERT INTO t1 VALUES(1, randomblob(1000)); 320 } 321} {} 322# verify only one file, and file size is less than chunks size 323do_test multiplex-2.7.7 { expr ([file size [multiplex_name test.db 0]] < 65536) } {1} 324do_test multiplex-2.7.8 { file exists [multiplex_name test.db 1] } {0} 325do_test multiplex-2.7.9 { 326 execsql { 327 INSERT INTO t1 VALUES(2, randomblob(65536)); 328 } 329} {} 330# verify only one file, and file size exceeds chunks size 331do_test multiplex-2.7.10 { expr ([file size [multiplex_name test.db 0]] > 65536) } {1} 332do_test multiplex-2.7.11 { file exists [multiplex_name test.db 1] } {0} 333do_test multiplex-2.7.12 { db close } {} 334do_test multiplex-2.7.13 { sqlite3_multiplex_shutdown } {SQLITE_OK} 335 336#------------------------------------------------------------------------- 337# Try some tests with more than one connection to a database file. Still 338# in rollback mode. 339# 340# multiplex-3.1.*: Two connections to a single database file. 341# 342# multiplex-3.2.*: Two connections to each of several database files (that 343# are in the same multiplex group). 344# 345do_test multiplex-3.1.1 { 346 multiplex_delete test.db 347 sqlite3_multiplex_initialize "" 1 348 sqlite3 db test.db 349 multiplex_set db main 32768 16 350} {SQLITE_OK} 351do_test multiplex-3.1.2 { 352 execsql { 353 PRAGMA page_size = 1024; 354 PRAGMA journal_mode = delete; 355 PRAGMA auto_vacuum = off; 356 CREATE TABLE t1(a PRIMARY KEY, b); 357 INSERT INTO t1 VALUES(1, 'one'); 358 } 359 file size [multiplex_name test.db 0] 360} {3072} 361do_test multiplex-3.1.3 { 362 sqlite3 db2 test.db 363 execsql { CREATE TABLE t2(a, b) } db2 364} {} 365do_test multiplex-3.1.4 { 366 execsql { CREATE TABLE t3(a, b) } 367} {} 368do_test multiplex-3.1.5 { 369 catchsql { CREATE TABLE t3(a, b) } 370} {1 {table t3 already exists}} 371do_test multiplex-3.1.6 { 372 db close 373 db2 close 374} {} 375 376do_test multiplex-3.2.1a { 377 378 multiplex_delete test.db 379 multiplex_delete test2.db 380 381 sqlite3 db1a test.db 382 sqlite3 db2a test2.db 383 384 foreach db {db1a db2a} { 385 execsql { 386 PRAGMA page_size = 1024; 387 PRAGMA journal_mode = delete; 388 PRAGMA auto_vacuum = off; 389 CREATE TABLE t1(a, b); 390 } $db 391 } 392 393 list [file size [multiplex_name test.db 0]] [file size [multiplex_name test2.db 0]] 394} {2048 2048} 395 396do_test multiplex-3.2.1b { 397 sqlite3 db1b test.db 398 sqlite3 db2b test2.db 399} {} 400 401do_test multiplex-3.2.2 { execsql { INSERT INTO t1 VALUES('x', 'y') } db1a } {} 402do_test multiplex-3.2.3 { execsql { INSERT INTO t1 VALUES('v', 'w') } db1b } {} 403do_test multiplex-3.2.4 { execsql { INSERT INTO t1 VALUES('t', 'u') } db2a } {} 404do_test multiplex-3.2.5 { execsql { INSERT INTO t1 VALUES('r', 's') } db2b } {} 405 406do_test multiplex-3.2.6 { 407 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a 408} {} 409do_test multiplex-3.2.7 { 410 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b 411} {} 412do_test multiplex-3.2.8 { 413 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a 414} {} 415do_test multiplex-3.2.9 { 416 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b 417} {} 418 419do_test multiplex-3.3.1 { 420 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1a 421 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db1b 422 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2a 423 execsql { INSERT INTO t1 VALUES(randomblob(500), randomblob(500)) } db2b 424} {} 425 426do_test multiplex-3.2.X { 427 foreach db {db1a db2a db2b db1b} { catch { $db close } } 428} {} 429 430#------------------------------------------------------------------------- 431# 432 433sqlite3_multiplex_initialize "" 1 434multiplex_set db main 32768 16 435 436# Return a list of all currently defined multiplexs. 437proc multiplex_list {} { 438 set allq {} 439 foreach q [sqlite3_multiplex_dump] { 440 lappend allq [lindex $q 0] 441 } 442 return [lsort $allq] 443} 444 445do_test multiplex-4.1.6 { 446 multiplex_delete test2.db 447 sqlite3 db test2.db 448 db eval {CREATE TABLE t2(x); INSERT INTO t2 VALUES('tab-t2');} 449 set res [multiplex_list] 450 list [regexp {test2.db} $res] 451} {1} 452do_test multiplex-4.1.6a { 453 sqlite3 db2 test2.db 454 db2 eval {SELECT * FROM t2} 455} {tab-t2} 456do_test multiplex-4.1.7 { 457 execsql {INSERT INTO t2 VALUES(zeroblob(200000))} 458} {} 459do_test multiplex-4.1.8 { 460 sqlite3 db2 test2.db 461 db2 eval {SELECT count(*) FROM t2} 462} {2} 463do_test multiplex-4.1.8a { 464 db2 eval { DELETE FROM t2 WHERE x = 'tab-t2' } 465} {} 466do_test multiplex-4.1.8b { 467 sqlite3 db2 test2.db 468 db2 eval {SELECT count(*) FROM t2} 469} {1} 470 471 472do_test multiplex-4.1.9 { 473 execsql {INSERT INTO t2 VALUES(zeroblob(200000))} 474} {} 475do_test multiplex-4.1.10 { 476 set res [multiplex_list] 477 list [regexp {test2.db} $res] 478} {1} 479do_test multiplex-4.1.11 { 480 db2 close 481 set res [multiplex_list] 482 list [regexp {test2.db} $res] 483} {1} 484do_test multiplex-4.1.12 { 485 db close 486 multiplex_list 487} {} 488 489 490#------------------------------------------------------------------------- 491# The following tests test that the multiplex VFS handles malloc and IO 492# errors. 493# 494 495sqlite3_multiplex_initialize "" 1 496multiplex_set db main 32768 16 497 498do_faultsim_test multiplex-5.1 -prep { 499 catch {db close} 500} -body { 501 sqlite3 db test2.db 502} 503do_faultsim_test multiplex-5.2 -prep { 504 catch {db close} 505} -body { 506 sqlite3 db test.db 507} 508 509catch { db close } 510multiplex_delete test.db 511multiplex_delete test2.db 512 513do_test multiplex-5.3.prep { 514 sqlite3 db test.db 515 execsql { 516 PRAGMA auto_vacuum = 1; 517 PRAGMA page_size = 1024; 518 CREATE TABLE t1(a, b); 519 INSERT INTO t1 VALUES(10, zeroblob(1200)); 520 } 521 faultsim_save_and_close 522} {} 523do_faultsim_test multiplex-5.3 -prep { 524 faultsim_restore_and_reopen 525} -body { 526 execsql { DELETE FROM t1 } 527} 528 529do_test multiplex-5.4.1 { 530 catch { db close } 531 multiplex_delete test.db 532 file mkdir test.db 533 list [catch { sqlite3 db test.db } msg] $msg 534} {1 {unable to open database file}} 535catch { delete_file test.db } 536 537do_faultsim_test multiplex-5.5 -prep { 538 catch { sqlite3_multiplex_shutdown } 539} -body { 540 sqlite3_multiplex_initialize "" 1 541 multiplex_set db main 32768 16 542} 543 544#------------------------------------------------------------------------- 545# Test that you can vacuum a multiplex'ed DB. 546 547ifcapable vacuum { 548 549sqlite3_multiplex_shutdown 550do_test multiplex-6.0.0 { 551 multiplex_delete test.db 552 multiplex_delete test.x 553 sqlite3_multiplex_initialize "" 1 554 sqlite3 db test.x 555 multiplex_set db main 4096 16 556} {SQLITE_OK} 557 558do_test multiplex-6.1.0 { 559 execsql { 560 PRAGMA page_size=1024; 561 PRAGMA journal_mode=DELETE; 562 PRAGMA auto_vacuum=OFF; 563 } 564 execsql { 565 CREATE TABLE t1(a, b); 566 INSERT INTO t1 VALUES(1, randomblob($g_chunk_size)); 567 INSERT INTO t1 VALUES(2, randomblob($g_chunk_size)); 568 } 569} {} 570do_test multiplex-6.2.1 { file size [multiplex_name test.x 0] } [list $g_chunk_size] 571do_test multiplex-6.2.2 { file size [multiplex_name test.x 1] } [list $g_chunk_size] 572 573do_test multiplex-6.3.0 { 574 execsql { VACUUM } 575} {} 576 577do_test multiplex-6.99 { 578 db close 579 multiplex_delete test.x 580 sqlite3_multiplex_shutdown 581} {SQLITE_OK} 582 583} 584 585 586catch { sqlite3_multiplex_shutdown } 587finish_test 588