1# 2010 June 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# 12 13set testdir [file dirname $argv0] 14source $testdir/tester.tcl 15source $testdir/lock_common.tcl 16source $testdir/malloc_common.tcl 17source $testdir/wal_common.tcl 18 19# Do not use a codec for tests in this file, as the database file is 20# manipulated directly using tcl scripts (using the [hexio_write] command). 21# 22do_not_use_codec 23 24# 25# pager1-1.*: Test inter-process locking (clients in multiple processes). 26# 27# pager1-2.*: Test intra-process locking (multiple clients in this process). 28# 29# pager1-3.*: Savepoint related tests. 30# 31# pager1-4.*: Hot-journal related tests. 32# 33# pager1-5.*: Cases related to multi-file commits. 34# 35# pager1-6.*: Cases related to "PRAGMA max_page_count" 36# 37# pager1-7.*: Cases specific to "PRAGMA journal_mode=TRUNCATE" 38# 39# pager1-8.*: Cases using temporary and in-memory databases. 40# 41# pager1-9.*: Tests related to the backup API. 42# 43# pager1-10.*: Test that the assumed file-system sector-size is limited to 44# 64KB. 45# 46# pager1-12.*: Tests involving "PRAGMA page_size" 47# 48# pager1-13.*: Cases specific to "PRAGMA journal_mode=PERSIST" 49# 50# pager1-14.*: Cases specific to "PRAGMA journal_mode=OFF" 51# 52# pager1-15.*: Varying sqlite3_vfs.szOsFile 53# 54# pager1-16.*: Varying sqlite3_vfs.mxPathname 55# 56# pager1-17.*: Tests related to "PRAGMA omit_readlock" 57# 58# pager1-18.*: Test that the pager layer responds correctly if the b-tree 59# requests an invalid page number (due to db corruption). 60# 61 62proc recursive_select {id table {script {}}} { 63 set cnt 0 64 db eval "SELECT rowid, * FROM $table WHERE rowid = ($id-1)" { 65 recursive_select $rowid $table $script 66 incr cnt 67 } 68 if {$cnt==0} { eval $script } 69} 70 71set a_string_counter 1 72proc a_string {n} { 73 global a_string_counter 74 incr a_string_counter 75 string range [string repeat "${a_string_counter}." $n] 1 $n 76} 77db func a_string a_string 78 79do_multiclient_test tn { 80 81 # Create and populate a database table using connection [db]. Check 82 # that connections [db2] and [db3] can see the schema and content. 83 # 84 do_test pager1-$tn.1 { 85 sql1 { 86 CREATE TABLE t1(a PRIMARY KEY, b); 87 CREATE INDEX i1 ON t1(b); 88 INSERT INTO t1 VALUES(1, 'one'); INSERT INTO t1 VALUES(2, 'two'); 89 } 90 } {} 91 do_test pager1-$tn.2 { sql2 { SELECT * FROM t1 } } {1 one 2 two} 92 do_test pager1-$tn.3 { sql3 { SELECT * FROM t1 } } {1 one 2 two} 93 94 # Open a transaction and add a row using [db]. This puts [db] in 95 # RESERVED state. Check that connections [db2] and [db3] can still 96 # read the database content as it was before the transaction was 97 # opened. [db] should see the inserted row. 98 # 99 do_test pager1-$tn.4 { 100 sql1 { 101 BEGIN; 102 INSERT INTO t1 VALUES(3, 'three'); 103 } 104 } {} 105 do_test pager1-$tn.5 { sql2 { SELECT * FROM t1 } } {1 one 2 two} 106 do_test pager1-$tn.7 { sql1 { SELECT * FROM t1 } } {1 one 2 two 3 three} 107 108 # [db] still has an open write transaction. Check that this prevents 109 # other connections (specifically [db2]) from writing to the database. 110 # 111 # Even if [db2] opens a transaction first, it may not write to the 112 # database. After the attempt to write the db within a transaction, 113 # [db2] is left with an open transaction, but not a read-lock on 114 # the main database. So it does not prevent [db] from committing. 115 # 116 do_test pager1-$tn.8 { 117 csql2 { UPDATE t1 SET a = a + 10 } 118 } {1 {database is locked}} 119 do_test pager1-$tn.9 { 120 csql2 { 121 BEGIN; 122 UPDATE t1 SET a = a + 10; 123 } 124 } {1 {database is locked}} 125 126 # Have [db] commit its transactions. Check the other connections can 127 # now see the new database content. 128 # 129 do_test pager1-$tn.10 { sql1 { COMMIT } } {} 130 do_test pager1-$tn.11 { sql1 { SELECT * FROM t1 } } {1 one 2 two 3 three} 131 do_test pager1-$tn.12 { sql2 { SELECT * FROM t1 } } {1 one 2 two 3 three} 132 do_test pager1-$tn.13 { sql3 { SELECT * FROM t1 } } {1 one 2 two 3 three} 133 134 # Check that, as noted above, [db2] really did keep an open transaction 135 # after the attempt to write the database failed. 136 # 137 do_test pager1-$tn.14 { 138 csql2 { BEGIN } 139 } {1 {cannot start a transaction within a transaction}} 140 do_test pager1-$tn.15 { sql2 { ROLLBACK } } {} 141 142 # Have [db2] open a transaction and take a read-lock on the database. 143 # Check that this prevents [db] from writing to the database (outside 144 # of any transaction). After this fails, check that [db3] can read 145 # the db (showing that [db] did not take a PENDING lock etc.) 146 # 147 do_test pager1-$tn.15 { 148 sql2 { BEGIN; SELECT * FROM t1; } 149 } {1 one 2 two 3 three} 150 do_test pager1-$tn.16 { 151 csql1 { UPDATE t1 SET a = a + 10 } 152 } {1 {database is locked}} 153 do_test pager1-$tn.17 { sql3 { SELECT * FROM t1 } } {1 one 2 two 3 three} 154 155 # This time, have [db] open a transaction before writing the database. 156 # This works - [db] gets a RESERVED lock which does not conflict with 157 # the SHARED lock [db2] is holding. 158 # 159 do_test pager1-$tn.18 { 160 sql1 { 161 BEGIN; 162 UPDATE t1 SET a = a + 10; 163 } 164 } {} 165 do_test pager1-$tn-19 { 166 sql1 { PRAGMA lock_status } 167 } {main reserved temp closed} 168 do_test pager1-$tn-20 { 169 sql2 { PRAGMA lock_status } 170 } {main shared temp closed} 171 172 # Check that all connections can still read the database. Only [db] sees 173 # the updated content (as the transaction has not been committed yet). 174 # 175 do_test pager1-$tn.21 { sql1 { SELECT * FROM t1 } } {11 one 12 two 13 three} 176 do_test pager1-$tn.22 { sql2 { SELECT * FROM t1 } } {1 one 2 two 3 three} 177 do_test pager1-$tn.23 { sql3 { SELECT * FROM t1 } } {1 one 2 two 3 three} 178 179 # Because [db2] still has the SHARED lock, [db] is unable to commit the 180 # transaction. If it tries, an error is returned and the connection 181 # upgrades to a PENDING lock. 182 # 183 # Once this happens, [db] can read the database and see the new content, 184 # [db2] (still holding SHARED) can still read the old content, but [db3] 185 # (not holding any lock) is prevented by [db]'s PENDING from reading 186 # the database. 187 # 188 do_test pager1-$tn.24 { csql1 { COMMIT } } {1 {database is locked}} 189 do_test pager1-$tn-25 { 190 sql1 { PRAGMA lock_status } 191 } {main pending temp closed} 192 do_test pager1-$tn.26 { sql1 { SELECT * FROM t1 } } {11 one 12 two 13 three} 193 do_test pager1-$tn.27 { sql2 { SELECT * FROM t1 } } {1 one 2 two 3 three} 194 do_test pager1-$tn.28 { csql3 { SELECT * FROM t1 } } {1 {database is locked}} 195 196 # Have [db2] commit its read transaction, releasing the SHARED lock it 197 # is holding. Now, neither [db2] nor [db3] may read the database (as [db] 198 # is still holding a PENDING). 199 # 200 do_test pager1-$tn.29 { sql2 { COMMIT } } {} 201 do_test pager1-$tn.30 { csql2 { SELECT * FROM t1 } } {1 {database is locked}} 202 do_test pager1-$tn.31 { csql3 { SELECT * FROM t1 } } {1 {database is locked}} 203 204 # [db] is now able to commit the transaction. Once the transaction is 205 # committed, all three connections can read the new content. 206 # 207 do_test pager1-$tn.25 { sql1 { UPDATE t1 SET a = a+10 } } {} 208 do_test pager1-$tn.26 { sql1 { COMMIT } } {} 209 do_test pager1-$tn.27 { sql1 { SELECT * FROM t1 } } {21 one 22 two 23 three} 210 do_test pager1-$tn.27 { sql2 { SELECT * FROM t1 } } {21 one 22 two 23 three} 211 do_test pager1-$tn.28 { sql3 { SELECT * FROM t1 } } {21 one 22 two 23 three} 212 213 # Install a busy-handler for connection [db]. 214 # 215 set ::nbusy [list] 216 proc busy {n} { 217 lappend ::nbusy $n 218 if {$n>5} { sql2 COMMIT } 219 return 0 220 } 221 db busy busy 222 223 do_test pager1-$tn.29 { 224 sql1 { BEGIN ; INSERT INTO t1 VALUES('x', 'y') } 225 } {} 226 do_test pager1-$tn.30 { 227 sql2 { BEGIN ; SELECT * FROM t1 } 228 } {21 one 22 two 23 three} 229 do_test pager1-$tn.31 { sql1 COMMIT } {} 230 do_test pager1-$tn.32 { set ::nbusy } {0 1 2 3 4 5 6} 231} 232 233#------------------------------------------------------------------------- 234# Savepoint related test cases. 235# 236# pager1-3.1.2.*: Force a savepoint rollback to cause the database file 237# to grow. 238# 239# pager1-3.1.3.*: Use a journal created in synchronous=off mode as part 240# of a savepoint rollback. 241# 242do_test pager1-3.1.1 { 243 faultsim_delete_and_reopen 244 execsql { 245 CREATE TABLE t1(a PRIMARY KEY, b); 246 CREATE TABLE counter( 247 i CHECK (i<5), 248 u CHECK (u<10) 249 ); 250 INSERT INTO counter VALUES(0, 0); 251 CREATE TRIGGER tr1 AFTER INSERT ON t1 BEGIN 252 UPDATE counter SET i = i+1; 253 END; 254 CREATE TRIGGER tr2 AFTER UPDATE ON t1 BEGIN 255 UPDATE counter SET u = u+1; 256 END; 257 } 258 execsql { SELECT * FROM counter } 259} {0 0} 260 261do_execsql_test pager1-3.1.2 { 262 PRAGMA cache_size = 10; 263 BEGIN; 264 INSERT INTO t1 VALUES(1, randomblob(1500)); 265 INSERT INTO t1 VALUES(2, randomblob(1500)); 266 INSERT INTO t1 VALUES(3, randomblob(1500)); 267 SELECT * FROM counter; 268} {3 0} 269do_catchsql_test pager1-3.1.3 { 270 INSERT INTO t1 SELECT a+3, randomblob(1500) FROM t1 271} {1 {constraint failed}} 272do_execsql_test pager1-3.4 { SELECT * FROM counter } {3 0} 273do_execsql_test pager1-3.5 { SELECT a FROM t1 } {1 2 3} 274do_execsql_test pager1-3.6 { COMMIT } {} 275 276foreach {tn sql tcl} { 277 7 { PRAGMA synchronous = NORMAL ; PRAGMA temp_store = 0 } { 278 testvfs tv -default 1 279 tv devchar safe_append 280 } 281 8 { PRAGMA synchronous = NORMAL ; PRAGMA temp_store = 2 } { 282 testvfs tv -default 1 283 tv devchar sequential 284 } 285 9 { PRAGMA synchronous = FULL } { } 286 10 { PRAGMA synchronous = NORMAL } { } 287 11 { PRAGMA synchronous = OFF } { } 288 12 { PRAGMA synchronous = FULL ; PRAGMA fullfsync = 1 } { } 289 13 { PRAGMA synchronous = FULL } { 290 testvfs tv -default 1 291 tv devchar sequential 292 } 293 14 { PRAGMA locking_mode = EXCLUSIVE } { 294 } 295} { 296 do_test pager1-3.$tn.1 { 297 eval $tcl 298 faultsim_delete_and_reopen 299 db func a_string a_string 300 execsql $sql 301 execsql { 302 PRAGMA auto_vacuum = 2; 303 PRAGMA cache_size = 10; 304 CREATE TABLE z(x INTEGER PRIMARY KEY, y); 305 BEGIN; 306 INSERT INTO z VALUES(NULL, a_string(800)); 307 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 2 308 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 4 309 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 8 310 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 16 311 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 32 312 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 64 313 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 128 314 INSERT INTO z SELECT NULL, a_string(800) FROM z; -- 256 315 COMMIT; 316 } 317 execsql { PRAGMA auto_vacuum } 318 } {2} 319 do_execsql_test pager1-3.$tn.2 { 320 BEGIN; 321 INSERT INTO z VALUES(NULL, a_string(800)); 322 INSERT INTO z VALUES(NULL, a_string(800)); 323 SAVEPOINT one; 324 UPDATE z SET y = NULL WHERE x>256; 325 PRAGMA incremental_vacuum; 326 SELECT count(*) FROM z WHERE x < 100; 327 ROLLBACK TO one; 328 COMMIT; 329 } {99} 330 331 do_execsql_test pager1-3.$tn.3 { 332 BEGIN; 333 SAVEPOINT one; 334 UPDATE z SET y = y||x; 335 ROLLBACK TO one; 336 COMMIT; 337 SELECT count(*) FROM z; 338 } {258} 339 340 do_execsql_test pager1-3.$tn.4 { 341 SAVEPOINT one; 342 UPDATE z SET y = y||x; 343 ROLLBACK TO one; 344 } {} 345 do_execsql_test pager1-3.$tn.5 { 346 SELECT count(*) FROM z; 347 RELEASE one; 348 PRAGMA integrity_check; 349 } {258 ok} 350 351 do_execsql_test pager1-3.$tn.6 { 352 SAVEPOINT one; 353 RELEASE one; 354 } {} 355 356 db close 357 catch { tv delete } 358} 359 360#------------------------------------------------------------------------- 361# Hot journal rollback related test cases. 362# 363# pager1.4.1.*: Test that the pager module deletes very small invalid 364# journal files. 365# 366# pager1.4.2.*: Test that if the master journal pointer at the end of a 367# hot-journal file appears to be corrupt (checksum does not 368# compute) the associated journal is rolled back (and no 369# xAccess() call to check for the presence of any master 370# journal file is made). 371# 372# pager1.4.3.*: Test that the contents of a hot-journal are ignored if the 373# page-size or sector-size in the journal header appear to 374# be invalid (too large, too small or not a power of 2). 375# 376# pager1.4.4.*: Test hot-journal rollback of journal file with a master 377# journal pointer generated in various "PRAGMA synchronous" 378# modes. 379# 380# pager1.4.5.*: Test that hot-journal rollback stops if it encounters a 381# journal-record for which the checksum fails. 382# 383# pager1.4.6.*: Test that when rolling back a hot-journal that contains a 384# master journal pointer, the master journal file is deleted 385# after all the hot-journals that refer to it are deleted. 386# 387# pager1.4.7.*: Test that if a hot-journal file exists but a client can 388# open it for reading only, the database cannot be accessed and 389# SQLITE_CANTOPEN is returned. 390# 391do_test pager1.4.1.1 { 392 faultsim_delete_and_reopen 393 execsql { 394 CREATE TABLE x(y, z); 395 INSERT INTO x VALUES(1, 2); 396 } 397 set fd [open test.db-journal w] 398 puts -nonewline $fd "helloworld" 399 close $fd 400 file exists test.db-journal 401} {1} 402do_test pager1.4.1.2 { execsql { SELECT * FROM x } } {1 2} 403do_test pager1.4.1.3 { file exists test.db-journal } {0} 404 405# Set up a [testvfs] to snapshot the file-system just before SQLite 406# deletes the master-journal to commit a multi-file transaction. 407# 408# In subsequent test cases, invoking [faultsim_restore_and_reopen] sets 409# up the file system to contain two databases, two hot-journal files and 410# a master-journal. 411# 412do_test pager1.4.2.1 { 413 testvfs tstvfs -default 1 414 tstvfs filter xDelete 415 tstvfs script xDeleteCallback 416 proc xDeleteCallback {method file args} { 417 set file [file tail $file] 418 if { [string match *mj* $file] } { faultsim_save } 419 } 420 faultsim_delete_and_reopen 421 db func a_string a_string 422 execsql { 423 ATTACH 'test.db2' AS aux; 424 PRAGMA journal_mode = DELETE; 425 PRAGMA main.cache_size = 10; 426 PRAGMA aux.cache_size = 10; 427 CREATE TABLE t1(a UNIQUE, b UNIQUE); 428 CREATE TABLE aux.t2(a UNIQUE, b UNIQUE); 429 INSERT INTO t1 VALUES(a_string(200), a_string(300)); 430 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; 431 INSERT INTO t1 SELECT a_string(200), a_string(300) FROM t1; 432 INSERT INTO t2 SELECT * FROM t1; 433 BEGIN; 434 INSERT INTO t1 SELECT a_string(201), a_string(301) FROM t1; 435 INSERT INTO t1 SELECT a_string(202), a_string(302) FROM t1; 436 INSERT INTO t1 SELECT a_string(203), a_string(303) FROM t1; 437 INSERT INTO t1 SELECT a_string(204), a_string(304) FROM t1; 438 REPLACE INTO t2 SELECT * FROM t1; 439 COMMIT; 440 } 441 db close 442 tstvfs delete 443} {} 444do_test pager1.4.2.2 { 445 faultsim_restore_and_reopen 446 execsql { 447 SELECT count(*) FROM t1; 448 PRAGMA integrity_check; 449 } 450} {4 ok} 451do_test pager1.4.2.3 { 452 faultsim_restore_and_reopen 453 foreach f [glob test.db-mj*] { file delete -force $f } 454 execsql { 455 SELECT count(*) FROM t1; 456 PRAGMA integrity_check; 457 } 458} {64 ok} 459do_test pager1.4.2.4 { 460 faultsim_restore_and_reopen 461 hexio_write test.db-journal [expr [file size test.db-journal]-20] 123456 462 execsql { 463 SELECT count(*) FROM t1; 464 PRAGMA integrity_check; 465 } 466} {4 ok} 467do_test pager1.4.2.5 { 468 faultsim_restore_and_reopen 469 hexio_write test.db-journal [expr [file size test.db-journal]-20] 123456 470 foreach f [glob test.db-mj*] { file delete -force $f } 471 execsql { 472 SELECT count(*) FROM t1; 473 PRAGMA integrity_check; 474 } 475} {4 ok} 476 477do_test pager1.4.3.1 { 478 testvfs tstvfs -default 1 479 tstvfs filter xSync 480 tstvfs script xSyncCallback 481 proc xSyncCallback {method file args} { 482 set file [file tail $file] 483 if { 0==[string match *journal $file] } { faultsim_save } 484 } 485 faultsim_delete_and_reopen 486 execsql { 487 PRAGMA journal_mode = DELETE; 488 CREATE TABLE t1(a, b); 489 INSERT INTO t1 VALUES(1, 2); 490 INSERT INTO t1 VALUES(3, 4); 491 } 492 db close 493 tstvfs delete 494} {} 495 496foreach {tn ofst value result} { 497 2 20 31 {1 2 3 4} 498 3 20 32 {1 2 3 4} 499 4 20 33 {1 2 3 4} 500 5 20 65536 {1 2 3 4} 501 6 20 131072 {1 2 3 4} 502 503 7 24 511 {1 2 3 4} 504 8 24 513 {1 2 3 4} 505 9 24 131072 {1 2 3 4} 506 507 10 32 65536 {1 2} 508} { 509 do_test pager1.4.3.$tn { 510 faultsim_restore_and_reopen 511 hexio_write test.db-journal $ofst [format %.8x $value] 512 execsql { SELECT * FROM t1 } 513 } $result 514} 515db close 516 517# Set up a VFS that snapshots the file-system just before a master journal 518# file is deleted to commit a multi-file transaction. Specifically, the 519# file-system is saved just before the xDelete() call to remove the 520# master journal file from the file-system. 521# 522testvfs tv -default 1 523tv script copy_on_mj_delete 524set ::mj_filename_length 0 525proc copy_on_mj_delete {method filename args} { 526 if {[string match *mj* [file tail $filename]]} { 527 set ::mj_filename_length [string length $filename] 528 faultsim_save 529 } 530 return SQLITE_OK 531} 532 533set pwd [pwd] 534foreach {tn1 tcl} { 535 1 { set prefix "test.db" } 536 2 { 537 # This test depends on the underlying VFS being able to open paths 538 # 512 bytes in length. The idea is to create a hot-journal file that 539 # contains a master-journal pointer so large that it could contain 540 # a valid page record (if the file page-size is 512 bytes). So as to 541 # make sure SQLite doesn't get confused by this. 542 # 543 set nPadding [expr 511 - $::mj_filename_length] 544 if {$tcl_platform(platform)=="windows"} { 545 # TBD need to figure out how to do this correctly for Windows!!! 546 set nPadding [expr 255 - $::mj_filename_length] 547 } 548 549 # We cannot just create a really long database file name to open, as 550 # Linux limits a single component of a path to 255 bytes by default 551 # (and presumably other systems have limits too). So create a directory 552 # hierarchy to work in. 553 # 554 set dirname "d123456789012345678901234567890/" 555 set nDir [expr $nPadding / 32] 556 if { $nDir } { 557 set p [string repeat $dirname $nDir] 558 file mkdir $p 559 cd $p 560 } 561 562 set padding [string repeat x [expr $nPadding %32]] 563 set prefix "test.db${padding}" 564 } 565} { 566 eval $tcl 567 foreach {tn2 sql} { 568 o { 569 PRAGMA main.synchronous=OFF; 570 PRAGMA aux.synchronous=OFF; 571 PRAGMA journal_mode = DELETE; 572 } 573 o512 { 574 PRAGMA main.synchronous=OFF; 575 PRAGMA aux.synchronous=OFF; 576 PRAGMA main.page_size = 512; 577 PRAGMA aux.page_size = 512; 578 PRAGMA journal_mode = DELETE; 579 } 580 n { 581 PRAGMA main.synchronous=NORMAL; 582 PRAGMA aux.synchronous=NORMAL; 583 PRAGMA journal_mode = DELETE; 584 } 585 f { 586 PRAGMA main.synchronous=FULL; 587 PRAGMA aux.synchronous=FULL; 588 PRAGMA journal_mode = DELETE; 589 } 590 } { 591 592 set tn "${tn1}.${tn2}" 593 594 # Set up a connection to have two databases, test.db (main) and 595 # test.db2 (aux). Then run a multi-file transaction on them. The 596 # VFS will snapshot the file-system just before the master-journal 597 # file is deleted to commit the transaction. 598 # 599 tv filter xDelete 600 do_test pager1-4.4.$tn.1 { 601 faultsim_delete_and_reopen $prefix 602 execsql " 603 ATTACH '${prefix}2' AS aux; 604 $sql 605 CREATE TABLE a(x); 606 CREATE TABLE aux.b(x); 607 INSERT INTO a VALUES('double-you'); 608 INSERT INTO a VALUES('why'); 609 INSERT INTO a VALUES('zed'); 610 INSERT INTO b VALUES('won'); 611 INSERT INTO b VALUES('too'); 612 INSERT INTO b VALUES('free'); 613 " 614 execsql { 615 BEGIN; 616 INSERT INTO a SELECT * FROM b WHERE rowid<=3; 617 INSERT INTO b SELECT * FROM a WHERE rowid<=3; 618 COMMIT; 619 } 620 } {} 621 tv filter {} 622 623 # Check that the transaction was committed successfully. 624 # 625 do_execsql_test pager1-4.4.$tn.2 { 626 SELECT * FROM a 627 } {double-you why zed won too free} 628 do_execsql_test pager1-4.4.$tn.3 { 629 SELECT * FROM b 630 } {won too free double-you why zed} 631 632 # Restore the file-system and reopen the databases. Check that it now 633 # appears that the transaction was not committed (because the file-system 634 # was restored to the state where it had not been). 635 # 636 do_test pager1-4.4.$tn.4 { 637 faultsim_restore_and_reopen $prefix 638 execsql "ATTACH '${prefix}2' AS aux" 639 } {} 640 do_execsql_test pager1-4.4.$tn.5 {SELECT * FROM a} {double-you why zed} 641 do_execsql_test pager1-4.4.$tn.6 {SELECT * FROM b} {won too free} 642 643 # Restore the file-system again. This time, before reopening the databases, 644 # delete the master-journal file from the file-system. It now appears that 645 # the transaction was committed (no master-journal file == no rollback). 646 # 647 do_test pager1-4.4.$tn.7 { 648 faultsim_restore_and_reopen $prefix 649 foreach f [glob ${prefix}-mj*] { file delete -force $f } 650 execsql "ATTACH '${prefix}2' AS aux" 651 } {} 652 do_execsql_test pager1-4.4.$tn.8 { 653 SELECT * FROM a 654 } {double-you why zed won too free} 655 do_execsql_test pager1-4.4.$tn.9 { 656 SELECT * FROM b 657 } {won too free double-you why zed} 658 } 659 660 cd $pwd 661} 662db close 663tv delete 664file delete -force $dirname 665 666 667# Set up a VFS to make a copy of the file-system just before deleting a 668# journal file to commit a transaction. The transaction modifies exactly 669# two database pages (and page 1 - the change counter). 670# 671testvfs tv -default 1 672tv sectorsize 512 673tv script copy_on_journal_delete 674tv filter xDelete 675proc copy_on_journal_delete {method filename args} { 676 if {[string match *journal $filename]} faultsim_save 677 return SQLITE_OK 678} 679faultsim_delete_and_reopen 680do_execsql_test pager1.4.5.1 { 681 PRAGMA journal_mode = DELETE; 682 PRAGMA page_size = 1024; 683 CREATE TABLE t1(a, b); 684 CREATE TABLE t2(a, b); 685 INSERT INTO t1 VALUES('I', 'II'); 686 INSERT INTO t2 VALUES('III', 'IV'); 687 BEGIN; 688 INSERT INTO t1 VALUES(1, 2); 689 INSERT INTO t2 VALUES(3, 4); 690 COMMIT; 691} {delete} 692tv filter {} 693 694# Check the transaction was committed: 695# 696do_execsql_test pager1.4.5.2 { 697 SELECT * FROM t1; 698 SELECT * FROM t2; 699} {I II 1 2 III IV 3 4} 700 701# Now try four tests: 702# 703# pager1-4.5.3: Restore the file-system. Check that the whole transaction 704# is rolled back. 705# 706# pager1-4.5.4: Restore the file-system. Corrupt the first record in the 707# journal. Check the transaction is not rolled back. 708# 709# pager1-4.5.5: Restore the file-system. Corrupt the second record in the 710# journal. Check that the first record in the transaction is 711# played back, but not the second. 712# 713# pager1-4.5.6: Restore the file-system. Try to open the database with a 714# readonly connection. This should fail, as a read-only 715# connection cannot roll back the database file. 716# 717faultsim_restore_and_reopen 718do_execsql_test pager1.4.5.3 { 719 SELECT * FROM t1; 720 SELECT * FROM t2; 721} {I II III IV} 722faultsim_restore_and_reopen 723hexio_write test.db-journal [expr 512+4+1024 - 202] 0123456789ABCDEF 724do_execsql_test pager1.4.5.4 { 725 SELECT * FROM t1; 726 SELECT * FROM t2; 727} {I II 1 2 III IV 3 4} 728faultsim_restore_and_reopen 729hexio_write test.db-journal [expr 512+4+1024+4+4+1024 - 202] 0123456789ABCDEF 730do_execsql_test pager1.4.5.5 { 731 SELECT * FROM t1; 732 SELECT * FROM t2; 733} {I II III IV 3 4} 734 735faultsim_restore_and_reopen 736db close 737sqlite3 db test.db -readonly 1 738do_catchsql_test pager1.4.5.6 { 739 SELECT * FROM t1; 740 SELECT * FROM t2; 741} {1 {disk I/O error}} 742db close 743 744# Snapshot the file-system just before multi-file commit. Save the name 745# of the master journal file in $::mj_filename. 746# 747tv script copy_on_mj_delete 748tv filter xDelete 749proc copy_on_mj_delete {method filename args} { 750 if {[string match *mj* [file tail $filename]]} { 751 set ::mj_filename $filename 752 faultsim_save 753 } 754 return SQLITE_OK 755} 756do_test pager1.4.6.1 { 757 faultsim_delete_and_reopen 758 execsql { 759 PRAGMA journal_mode = DELETE; 760 ATTACH 'test.db2' AS two; 761 CREATE TABLE t1(a, b); 762 CREATE TABLE two.t2(a, b); 763 INSERT INTO t1 VALUES(1, 't1.1'); 764 INSERT INTO t2 VALUES(1, 't2.1'); 765 BEGIN; 766 UPDATE t1 SET b = 't1.2'; 767 UPDATE t2 SET b = 't2.2'; 768 COMMIT; 769 } 770 tv filter {} 771 db close 772} {} 773 774faultsim_restore_and_reopen 775do_execsql_test pager1.4.6.2 { SELECT * FROM t1 } {1 t1.1} 776do_test pager1.4.6.3 { file exists $::mj_filename } {1} 777do_execsql_test pager1.4.6.4 { 778 ATTACH 'test.db2' AS two; 779 SELECT * FROM t2; 780} {1 t2.1} 781do_test pager1.4.6.5 { file exists $::mj_filename } {0} 782 783faultsim_restore_and_reopen 784db close 785do_test pager1.4.6.8 { 786 set ::mj_filename1 $::mj_filename 787 tv filter xDelete 788 sqlite3 db test.db2 789 execsql { 790 PRAGMA journal_mode = DELETE; 791 ATTACH 'test.db3' AS three; 792 CREATE TABLE three.t3(a, b); 793 INSERT INTO t3 VALUES(1, 't3.1'); 794 BEGIN; 795 UPDATE t2 SET b = 't2.3'; 796 UPDATE t3 SET b = 't3.3'; 797 COMMIT; 798 } 799 expr {$::mj_filename1 != $::mj_filename} 800} {1} 801faultsim_restore_and_reopen 802tv filter {} 803 804# The file-system now contains: 805# 806# * three databases 807# * three hot-journal files 808# * two master-journal files. 809# 810# The hot-journals associated with test.db2 and test.db3 point to 811# master journal $::mj_filename. The hot-journal file associated with 812# test.db points to master journal $::mj_filename1. So reading from 813# test.db should delete $::mj_filename1. 814# 815do_test pager1.4.6.9 { 816 lsort [glob test.db*] 817} [lsort [list \ 818 test.db test.db2 test.db3 \ 819 test.db-journal test.db2-journal test.db3-journal \ 820 [file tail $::mj_filename] [file tail $::mj_filename1] 821]] 822 823# The master-journal $::mj_filename1 contains pointers to test.db and 824# test.db2. However the hot-journal associated with test.db2 points to 825# a different master-journal. Therefore, reading from test.db only should 826# be enough to cause SQLite to delete $::mj_filename1. 827# 828do_test pager1.4.6.10 { file exists $::mj_filename } {1} 829do_test pager1.4.6.11 { file exists $::mj_filename1 } {1} 830do_execsql_test pager1.4.6.12 { SELECT * FROM t1 } {1 t1.1} 831do_test pager1.4.6.13 { file exists $::mj_filename } {1} 832do_test pager1.4.6.14 { file exists $::mj_filename1 } {0} 833 834do_execsql_test pager1.4.6.12 { 835 ATTACH 'test.db2' AS two; 836 SELECT * FROM t2; 837} {1 t2.1} 838do_test pager1.4.6.13 { file exists $::mj_filename } {1} 839do_execsql_test pager1.4.6.14 { 840 ATTACH 'test.db3' AS three; 841 SELECT * FROM t3; 842} {1 t3.1} 843do_test pager1.4.6.15 { file exists $::mj_filename } {0} 844 845db close 846tv delete 847 848testvfs tv -default 1 849tv sectorsize 512 850tv script copy_on_journal_delete 851tv filter xDelete 852proc copy_on_journal_delete {method filename args} { 853 if {[string match *journal $filename]} faultsim_save 854 return SQLITE_OK 855} 856faultsim_delete_and_reopen 857do_execsql_test pager1.4.7.1 { 858 PRAGMA journal_mode = DELETE; 859 CREATE TABLE t1(x PRIMARY KEY, y); 860 CREATE INDEX i1 ON t1(y); 861 INSERT INTO t1 VALUES('I', 'one'); 862 INSERT INTO t1 VALUES('II', 'four'); 863 INSERT INTO t1 VALUES('III', 'nine'); 864 BEGIN; 865 INSERT INTO t1 VALUES('IV', 'sixteen'); 866 INSERT INTO t1 VALUES('V' , 'twentyfive'); 867 COMMIT; 868} {delete} 869tv filter {} 870db close 871tv delete 872do_test pager1.4.7.2 { 873 faultsim_restore_and_reopen 874 catch {file attributes test.db-journal -permissions r--------} 875 catch {file attributes test.db-journal -readonly 1} 876 catchsql { SELECT * FROM t1 } 877} {1 {unable to open database file}} 878do_test pager1.4.7.3 { 879 db close 880 catch {file attributes test.db-journal -permissions rw-rw-rw-} 881 catch {file attributes test.db-journal -readonly 0} 882 file delete test.db-journal 883 file exists test.db-journal 884} {0} 885 886#------------------------------------------------------------------------- 887# The following tests deal with multi-file commits. 888# 889# pager1-5.1.*: The case where a multi-file cannot be committed because 890# another connection is holding a SHARED lock on one of the 891# files. After the SHARED lock is removed, the COMMIT succeeds. 892# 893# pager1-5.2.*: Multi-file commits with journal_mode=memory. 894# 895# pager1-5.3.*: Multi-file commits with journal_mode=memory. 896# 897# pager1-5.4.*: Check that with synchronous=normal, the master-journal file 898# name is added to a journal file immediately after the last 899# journal record. But with synchronous=full, extra unused space 900# is allocated between the last journal record and the 901# master-journal file name so that the master-journal file 902# name does not lie on the same sector as the last journal file 903# record. 904# 905# pager1-5.5.*: Check that in journal_mode=PERSIST mode, a journal file is 906# truncated to zero bytes when a multi-file transaction is 907# committed (instead of the first couple of bytes being zeroed). 908# 909# 910do_test pager1-5.1.1 { 911 faultsim_delete_and_reopen 912 execsql { 913 ATTACH 'test.db2' AS aux; 914 CREATE TABLE t1(a, b); 915 CREATE TABLE aux.t2(a, b); 916 INSERT INTO t1 VALUES(17, 'Lenin'); 917 INSERT INTO t1 VALUES(22, 'Stalin'); 918 INSERT INTO t1 VALUES(53, 'Khrushchev'); 919 } 920} {} 921do_test pager1-5.1.2 { 922 execsql { 923 BEGIN; 924 INSERT INTO t1 VALUES(64, 'Brezhnev'); 925 INSERT INTO t2 SELECT * FROM t1; 926 } 927 sqlite3 db2 test.db2 928 execsql { 929 BEGIN; 930 SELECT * FROM t2; 931 } db2 932} {} 933do_test pager1-5.1.3 { 934 catchsql COMMIT 935} {1 {database is locked}} 936do_test pager1-5.1.4 { 937 execsql COMMIT db2 938 execsql COMMIT 939 execsql { SELECT * FROM t2 } db2 940} {17 Lenin 22 Stalin 53 Khrushchev 64 Brezhnev} 941do_test pager1-5.1.5 { 942 db2 close 943} {} 944 945do_test pager1-5.2.1 { 946 execsql { 947 PRAGMA journal_mode = memory; 948 BEGIN; 949 INSERT INTO t1 VALUES(84, 'Andropov'); 950 INSERT INTO t2 VALUES(84, 'Andropov'); 951 COMMIT; 952 } 953} {memory} 954do_test pager1-5.3.1 { 955 execsql { 956 PRAGMA journal_mode = off; 957 BEGIN; 958 INSERT INTO t1 VALUES(85, 'Gorbachev'); 959 INSERT INTO t2 VALUES(85, 'Gorbachev'); 960 COMMIT; 961 } 962} {off} 963 964do_test pager1-5.4.1 { 965 db close 966 testvfs tv 967 sqlite3 db test.db -vfs tv 968 execsql { ATTACH 'test.db2' AS aux } 969 970 tv filter xDelete 971 tv script max_journal_size 972 tv sectorsize 512 973 set ::max_journal 0 974 proc max_journal_size {method args} { 975 set sz 0 976 catch { set sz [file size test.db-journal] } 977 if {$sz > $::max_journal} { 978 set ::max_journal $sz 979 } 980 return SQLITE_OK 981 } 982 execsql { 983 PRAGMA journal_mode = DELETE; 984 PRAGMA synchronous = NORMAL; 985 BEGIN; 986 INSERT INTO t1 VALUES(85, 'Gorbachev'); 987 INSERT INTO t2 VALUES(85, 'Gorbachev'); 988 COMMIT; 989 } 990 set ::max_journal 991} [expr 2615+[string length [pwd]]] 992do_test pager1-5.4.2 { 993 set ::max_journal 0 994 execsql { 995 PRAGMA synchronous = full; 996 BEGIN; 997 DELETE FROM t1 WHERE b = 'Lenin'; 998 DELETE FROM t2 WHERE b = 'Lenin'; 999 COMMIT; 1000 } 1001 set ::max_journal 1002} [expr 3111+[string length [pwd]]] 1003db close 1004tv delete 1005 1006do_test pager1-5.5.1 { 1007 sqlite3 db test.db 1008 execsql { 1009 ATTACH 'test.db2' AS aux; 1010 PRAGMA journal_mode = PERSIST; 1011 CREATE TABLE t3(a, b); 1012 INSERT INTO t3 SELECT randomblob(1500), randomblob(1500) FROM t1; 1013 UPDATE t3 SET b = randomblob(1500); 1014 } 1015 expr [file size test.db-journal] > 15000 1016} {1} 1017do_test pager1-5.5.2 { 1018 execsql { 1019 PRAGMA synchronous = full; 1020 BEGIN; 1021 DELETE FROM t1 WHERE b = 'Stalin'; 1022 DELETE FROM t2 WHERE b = 'Stalin'; 1023 COMMIT; 1024 } 1025 file size test.db-journal 1026} {0} 1027 1028 1029#------------------------------------------------------------------------- 1030# The following tests work with "PRAGMA max_page_count" 1031# 1032do_test pager1-6.1 { 1033 faultsim_delete_and_reopen 1034 execsql { 1035 PRAGMA auto_vacuum = none; 1036 PRAGMA max_page_count = 10; 1037 CREATE TABLE t2(a, b); 1038 CREATE TABLE t3(a, b); 1039 CREATE TABLE t4(a, b); 1040 CREATE TABLE t5(a, b); 1041 CREATE TABLE t6(a, b); 1042 CREATE TABLE t7(a, b); 1043 CREATE TABLE t8(a, b); 1044 CREATE TABLE t9(a, b); 1045 CREATE TABLE t10(a, b); 1046 } 1047} {10} 1048do_catchsql_test pager1-6.2 { 1049 CREATE TABLE t11(a, b) 1050} {1 {database or disk is full}} 1051do_execsql_test pager1-6.4 { PRAGMA max_page_count } {10} 1052do_execsql_test pager1-6.5 { PRAGMA max_page_count = 15 } {15} 1053do_execsql_test pager1-6.6 { CREATE TABLE t11(a, b) } {} 1054do_execsql_test pager1-6.7 { 1055 BEGIN; 1056 INSERT INTO t11 VALUES(1, 2); 1057 PRAGMA max_page_count = 13; 1058} {13} 1059do_execsql_test pager1-6.8 { 1060 INSERT INTO t11 VALUES(3, 4); 1061 PRAGMA max_page_count = 10; 1062} {11} 1063do_execsql_test pager1-6.9 { COMMIT } {} 1064 1065do_execsql_test pager1-6.10 { PRAGMA max_page_count = 10 } {11} 1066do_execsql_test pager1-6.11 { SELECT * FROM t11 } {1 2 3 4} 1067do_execsql_test pager1-6.12 { PRAGMA max_page_count } {11} 1068 1069 1070#------------------------------------------------------------------------- 1071# The following tests work with "PRAGMA journal_mode=TRUNCATE" and 1072# "PRAGMA locking_mode=EXCLUSIVE". 1073# 1074# Each test is specified with 5 variables. As follows: 1075# 1076# $tn: Test Number. Used as part of the [do_test] test names. 1077# $sql: SQL to execute. 1078# $res: Expected result of executing $sql. 1079# $js: The expected size of the journal file, in bytes, after executing 1080# the SQL script. Or -1 if the journal is not expected to exist. 1081# $ws: The expected size of the WAL file, in bytes, after executing 1082# the SQL script. Or -1 if the WAL is not expected to exist. 1083# 1084ifcapable wal { 1085 faultsim_delete_and_reopen 1086 foreach {tn sql res js ws} [subst { 1087 1088 1 { 1089 CREATE TABLE t1(a, b); 1090 PRAGMA auto_vacuum=OFF; 1091 PRAGMA synchronous=NORMAL; 1092 PRAGMA page_size=1024; 1093 PRAGMA locking_mode=EXCLUSIVE; 1094 PRAGMA journal_mode=TRUNCATE; 1095 INSERT INTO t1 VALUES(1, 2); 1096 } {exclusive truncate} 0 -1 1097 1098 2 { 1099 BEGIN IMMEDIATE; 1100 SELECT * FROM t1; 1101 COMMIT; 1102 } {1 2} 0 -1 1103 1104 3 { 1105 BEGIN; 1106 SELECT * FROM t1; 1107 COMMIT; 1108 } {1 2} 0 -1 1109 1110 4 { PRAGMA journal_mode = WAL } wal -1 -1 1111 5 { INSERT INTO t1 VALUES(3, 4) } {} -1 [wal_file_size 1 1024] 1112 6 { PRAGMA locking_mode = NORMAL } exclusive -1 [wal_file_size 1 1024] 1113 7 { INSERT INTO t1 VALUES(5, 6); } {} -1 [wal_file_size 2 1024] 1114 1115 8 { PRAGMA journal_mode = TRUNCATE } truncate 0 -1 1116 9 { INSERT INTO t1 VALUES(7, 8) } {} 0 -1 1117 10 { SELECT * FROM t1 } {1 2 3 4 5 6 7 8} 0 -1 1118 1119 }] { 1120 do_execsql_test pager1-7.1.$tn.1 $sql $res 1121 catch { set J -1 ; set J [file size test.db-journal] } 1122 catch { set W -1 ; set W [file size test.db-wal] } 1123 do_test pager1-7.1.$tn.2 { list $J $W } [list $js $ws] 1124 } 1125} 1126 1127do_test pager1-7.2.1 { 1128 faultsim_delete_and_reopen 1129 execsql { 1130 PRAGMA locking_mode = EXCLUSIVE; 1131 CREATE TABLE t1(a, b); 1132 BEGIN; 1133 PRAGMA journal_mode = delete; 1134 PRAGMA journal_mode = truncate; 1135 } 1136} {exclusive delete truncate} 1137do_test pager1-7.2.2 { 1138 execsql { INSERT INTO t1 VALUES(1, 2) } 1139 execsql { PRAGMA journal_mode = persist } 1140} {truncate} 1141do_test pager1-7.2.3 { 1142 execsql { COMMIT } 1143 execsql { 1144 PRAGMA journal_mode = persist; 1145 PRAGMA journal_size_limit; 1146 } 1147} {persist -1} 1148 1149#------------------------------------------------------------------------- 1150# The following tests, pager1-8.*, test that the special filenames 1151# ":memory:" and "" open temporary databases. 1152# 1153foreach {tn filename} { 1154 1 :memory: 1155 2 "" 1156} { 1157 do_test pager1-8.$tn.1 { 1158 faultsim_delete_and_reopen 1159 db close 1160 sqlite3 db $filename 1161 execsql { 1162 PRAGMA auto_vacuum = 1; 1163 CREATE TABLE x1(x); 1164 INSERT INTO x1 VALUES('Charles'); 1165 INSERT INTO x1 VALUES('James'); 1166 INSERT INTO x1 VALUES('Mary'); 1167 SELECT * FROM x1; 1168 } 1169 } {Charles James Mary} 1170 1171 do_test pager1-8.$tn.2 { 1172 sqlite3 db2 $filename 1173 catchsql { SELECT * FROM x1 } db2 1174 } {1 {no such table: x1}} 1175 1176 do_execsql_test pager1-8.$tn.3 { 1177 BEGIN; 1178 INSERT INTO x1 VALUES('William'); 1179 INSERT INTO x1 VALUES('Anne'); 1180 ROLLBACK; 1181 } {} 1182} 1183 1184#------------------------------------------------------------------------- 1185# The next block of tests - pager1-9.* - deal with interactions between 1186# the pager and the backup API. Test cases: 1187# 1188# pager1-9.1.*: Test that a backup completes successfully even if the 1189# source db is written to during the backup op. 1190# 1191# pager1-9.2.*: Test that a backup completes successfully even if the 1192# source db is written to and then rolled back during a 1193# backup operation. 1194# 1195do_test pager1-9.0.1 { 1196 faultsim_delete_and_reopen 1197 db func a_string a_string 1198 execsql { 1199 PRAGMA cache_size = 10; 1200 BEGIN; 1201 CREATE TABLE ab(a, b, UNIQUE(a, b)); 1202 INSERT INTO ab VALUES( a_string(200), a_string(300) ); 1203 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1204 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1205 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1206 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1207 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1208 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1209 INSERT INTO ab SELECT a_string(200), a_string(300) FROM ab; 1210 COMMIT; 1211 } 1212} {} 1213do_test pager1-9.0.2 { 1214 sqlite3 db2 test.db2 1215 db2 eval { PRAGMA cache_size = 10 } 1216 sqlite3_backup B db2 main db main 1217 list [B step 10000] [B finish] 1218} {SQLITE_DONE SQLITE_OK} 1219do_test pager1-9.0.3 { 1220 db one {SELECT md5sum(a, b) FROM ab} 1221} [db2 one {SELECT md5sum(a, b) FROM ab}] 1222 1223do_test pager1-9.1.1 { 1224 execsql { UPDATE ab SET a = a_string(201) } 1225 sqlite3_backup B db2 main db main 1226 B step 30 1227} {SQLITE_OK} 1228do_test pager1-9.1.2 { 1229 execsql { UPDATE ab SET b = a_string(301) } 1230 list [B step 10000] [B finish] 1231} {SQLITE_DONE SQLITE_OK} 1232do_test pager1-9.1.3 { 1233 db one {SELECT md5sum(a, b) FROM ab} 1234} [db2 one {SELECT md5sum(a, b) FROM ab}] 1235do_test pager1-9.1.4 { execsql { SELECT count(*) FROM ab } } {128} 1236 1237do_test pager1-9.2.1 { 1238 execsql { UPDATE ab SET a = a_string(202) } 1239 sqlite3_backup B db2 main db main 1240 B step 30 1241} {SQLITE_OK} 1242do_test pager1-9.2.2 { 1243 execsql { 1244 BEGIN; 1245 UPDATE ab SET b = a_string(301); 1246 ROLLBACK; 1247 } 1248 list [B step 10000] [B finish] 1249} {SQLITE_DONE SQLITE_OK} 1250do_test pager1-9.2.3 { 1251 db one {SELECT md5sum(a, b) FROM ab} 1252} [db2 one {SELECT md5sum(a, b) FROM ab}] 1253do_test pager1-9.2.4 { execsql { SELECT count(*) FROM ab } } {128} 1254db close 1255db2 close 1256 1257do_test pager1-9.3.1 { 1258 testvfs tv -default 1 1259 tv sectorsize 4096 1260 faultsim_delete_and_reopen 1261 1262 execsql { PRAGMA page_size = 1024 } 1263 for {set ii 0} {$ii < 4} {incr ii} { execsql "CREATE TABLE t${ii}(a, b)" } 1264} {} 1265do_test pager1-9.3.2 { 1266 sqlite3 db2 test.db2 1267 1268 execsql { 1269 PRAGMA page_size = 4096; 1270 PRAGMA synchronous = OFF; 1271 CREATE TABLE t1(a, b); 1272 CREATE TABLE t2(a, b); 1273 } db2 1274 1275 sqlite3_backup B db2 main db main 1276 B step 30 1277 list [B step 10000] [B finish] 1278} {SQLITE_DONE SQLITE_OK} 1279do_test pager1-9.3.3 { 1280 db2 close 1281 db close 1282 tv delete 1283 file size test.db2 1284} [file size test.db] 1285 1286do_test pager1-9.4.1 { 1287 faultsim_delete_and_reopen 1288 sqlite3 db2 test.db2 1289 execsql { 1290 PRAGMA page_size = 4096; 1291 CREATE TABLE t1(a, b); 1292 CREATE TABLE t2(a, b); 1293 } db2 1294 sqlite3_backup B db2 main db main 1295 list [B step 10000] [B finish] 1296} {SQLITE_DONE SQLITE_OK} 1297do_test pager1-9.4.2 { 1298 list [file size test.db2] [file size test.db] 1299} {0 0} 1300db2 close 1301 1302#------------------------------------------------------------------------- 1303# Test that regardless of the value returned by xSectorSize(), the 1304# minimum effective sector-size is 512 and the maximum 65536 bytes. 1305# 1306testvfs tv -default 1 1307foreach sectorsize { 1308 32 64 128 256 512 1024 2048 1309 4096 8192 16384 32768 65536 131072 262144 1310} { 1311 tv sectorsize $sectorsize 1312 set eff $sectorsize 1313 if {$sectorsize < 512} { set eff 512 } 1314 if {$sectorsize > 65536} { set eff 65536 } 1315 1316 do_test pager1-10.$sectorsize.1 { 1317 faultsim_delete_and_reopen 1318 db func a_string a_string 1319 execsql { 1320 PRAGMA journal_mode = PERSIST; 1321 PRAGMA page_size = 1024; 1322 BEGIN; 1323 CREATE TABLE t1(a, b); 1324 CREATE TABLE t2(a, b); 1325 CREATE TABLE t3(a, b); 1326 COMMIT; 1327 } 1328 file size test.db-journal 1329 } [expr $sectorsize > 65536 ? 65536 : $sectorsize] 1330 1331 do_test pager1-10.$sectorsize.2 { 1332 execsql { 1333 INSERT INTO t3 VALUES(a_string(300), a_string(300)); 1334 INSERT INTO t3 SELECT * FROM t3; /* 2 */ 1335 INSERT INTO t3 SELECT * FROM t3; /* 4 */ 1336 INSERT INTO t3 SELECT * FROM t3; /* 8 */ 1337 INSERT INTO t3 SELECT * FROM t3; /* 16 */ 1338 INSERT INTO t3 SELECT * FROM t3; /* 32 */ 1339 } 1340 } {} 1341 1342 do_test pager1-10.$sectorsize.3 { 1343 db close 1344 sqlite3 db test.db 1345 execsql { 1346 PRAGMA cache_size = 10; 1347 BEGIN; 1348 } 1349 recursive_select 32 t3 {db eval "INSERT INTO t2 VALUES(1, 2)"} 1350 execsql { 1351 COMMIT; 1352 SELECT * FROM t2; 1353 } 1354 } {1 2} 1355 1356 do_test pager1-10.$sectorsize.4 { 1357 execsql { 1358 CREATE TABLE t6(a, b); 1359 CREATE TABLE t7(a, b); 1360 CREATE TABLE t5(a, b); 1361 DROP TABLE t6; 1362 DROP TABLE t7; 1363 } 1364 execsql { 1365 BEGIN; 1366 CREATE TABLE t6(a, b); 1367 } 1368 recursive_select 32 t3 {db eval "INSERT INTO t5 VALUES(1, 2)"} 1369 execsql { 1370 COMMIT; 1371 SELECT * FROM t5; 1372 } 1373 } {1 2} 1374 1375} 1376db close 1377 1378tv sectorsize 4096 1379do_test pager1.10.x.1 { 1380 faultsim_delete_and_reopen 1381 execsql { 1382 PRAGMA auto_vacuum = none; 1383 PRAGMA page_size = 1024; 1384 CREATE TABLE t1(x); 1385 } 1386 for {set i 0} {$i<30} {incr i} { 1387 execsql { INSERT INTO t1 VALUES(zeroblob(900)) } 1388 } 1389 file size test.db 1390} {32768} 1391do_test pager1.10.x.2 { 1392 execsql { 1393 CREATE TABLE t2(x); 1394 DROP TABLE t2; 1395 } 1396 file size test.db 1397} {33792} 1398do_test pager1.10.x.3 { 1399 execsql { 1400 BEGIN; 1401 CREATE TABLE t2(x); 1402 } 1403 recursive_select 30 t1 1404 execsql { 1405 CREATE TABLE t3(x); 1406 COMMIT; 1407 } 1408} {} 1409 1410db close 1411tv delete 1412 1413testvfs tv -default 1 1414faultsim_delete_and_reopen 1415db func a_string a_string 1416do_execsql_test pager1-11.1 { 1417 PRAGMA journal_mode = DELETE; 1418 PRAGMA cache_size = 10; 1419 BEGIN; 1420 CREATE TABLE zz(top PRIMARY KEY); 1421 INSERT INTO zz VALUES(a_string(222)); 1422 INSERT INTO zz SELECT a_string((SELECT 222+max(rowid) FROM zz)) FROM zz; 1423 INSERT INTO zz SELECT a_string((SELECT 222+max(rowid) FROM zz)) FROM zz; 1424 INSERT INTO zz SELECT a_string((SELECT 222+max(rowid) FROM zz)) FROM zz; 1425 INSERT INTO zz SELECT a_string((SELECT 222+max(rowid) FROM zz)) FROM zz; 1426 INSERT INTO zz SELECT a_string((SELECT 222+max(rowid) FROM zz)) FROM zz; 1427 COMMIT; 1428 BEGIN; 1429 UPDATE zz SET top = a_string(345); 1430} {delete} 1431 1432proc lockout {method args} { return SQLITE_IOERR } 1433tv script lockout 1434tv filter {xWrite xTruncate xSync} 1435do_catchsql_test pager1-11.2 { COMMIT } {1 {disk I/O error}} 1436 1437tv script {} 1438do_test pager1-11.3 { 1439 sqlite3 db2 test.db 1440 execsql { 1441 PRAGMA journal_mode = TRUNCATE; 1442 PRAGMA integrity_check; 1443 } db2 1444} {truncate ok} 1445do_test pager1-11.4 { 1446 db2 close 1447 file exists test.db-journal 1448} {0} 1449do_execsql_test pager1-11.5 { SELECT count(*) FROM zz } {32} 1450db close 1451tv delete 1452 1453#------------------------------------------------------------------------- 1454# Test "PRAGMA page_size" 1455# 1456testvfs tv -default 1 1457tv sectorsize 1024 1458foreach pagesize { 1459 512 1024 2048 4096 8192 16384 32768 1460} { 1461 faultsim_delete_and_reopen 1462 1463 # The sector-size (according to the VFS) is 1024 bytes. So if the 1464 # page-size requested using "PRAGMA page_size" is greater than the 1465 # compile time value of SQLITE_MAX_PAGE_SIZE, then the effective 1466 # page-size remains 1024 bytes. 1467 # 1468 set eff $pagesize 1469 if {$eff > $::SQLITE_MAX_PAGE_SIZE} { set eff 1024 } 1470 1471 do_test pager1-12.$pagesize.1 { 1472 sqlite3 db2 test.db 1473 execsql " 1474 PRAGMA page_size = $pagesize; 1475 CREATE VIEW v AS SELECT * FROM sqlite_master; 1476 " db2 1477 file size test.db 1478 } $eff 1479 do_test pager1-12.$pagesize.2 { 1480 sqlite3 db2 test.db 1481 execsql { 1482 SELECT count(*) FROM v; 1483 PRAGMA main.page_size; 1484 } db2 1485 } [list 1 $eff] 1486 do_test pager1-12.$pagesize.3 { 1487 execsql { 1488 SELECT count(*) FROM v; 1489 PRAGMA main.page_size; 1490 } 1491 } [list 1 $eff] 1492 db2 close 1493} 1494db close 1495tv delete 1496 1497#------------------------------------------------------------------------- 1498# Test specal "PRAGMA journal_mode=PERSIST" test cases. 1499# 1500# pager1-13.1.*: This tests a special case encountered in persistent 1501# journal mode: If the journal associated with a transaction 1502# is smaller than the journal file (because a previous 1503# transaction left a very large non-hot journal file in the 1504# file-system), then SQLite has to be careful that there is 1505# not a journal-header left over from a previous transaction 1506# immediately following the journal content just written. 1507# If there is, and the process crashes so that the journal 1508# becomes a hot-journal and must be rolled back by another 1509# process, there is a danger that the other process may roll 1510# back the aborted transaction, then continue copying data 1511# from an older transaction from the remainder of the journal. 1512# See the syncJournal() function for details. 1513# 1514# pager1-13.2.*: Same test as the previous. This time, throw an index into 1515# the mix to make the integrity-check more likely to catch 1516# errors. 1517# 1518testvfs tv -default 1 1519tv script xSyncCb 1520tv filter xSync 1521proc xSyncCb {method filename args} { 1522 set t [file tail $filename] 1523 if {$t == "test.db"} faultsim_save 1524 return SQLITE_OK 1525} 1526faultsim_delete_and_reopen 1527db func a_string a_string 1528 1529# The UPDATE statement at the end of this test case creates a really big 1530# journal. Since the cache-size is only 10 pages, the journal contains 1531# frequent journal headers. 1532# 1533do_execsql_test pager1-13.1.1 { 1534 PRAGMA page_size = 1024; 1535 PRAGMA journal_mode = PERSIST; 1536 PRAGMA cache_size = 10; 1537 BEGIN; 1538 CREATE TABLE t1(a INTEGER PRIMARY KEY, b BLOB); 1539 INSERT INTO t1 VALUES(NULL, a_string(400)); 1540 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 2 */ 1541 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 4 */ 1542 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 8 */ 1543 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 16 */ 1544 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 32 */ 1545 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 64 */ 1546 INSERT INTO t1 SELECT NULL, a_string(400) FROM t1; /* 128 */ 1547 COMMIT; 1548 UPDATE t1 SET b = a_string(400); 1549} {persist} 1550 1551# Run transactions of increasing sizes. Eventually, one (or more than one) 1552# of these will write just enough content that one of the old headers created 1553# by the transaction in the block above lies immediately after the content 1554# journalled by the current transaction. 1555# 1556for {set nUp 1} {$nUp<64} {incr nUp} { 1557 do_execsql_test pager1-13.1.2.$nUp.1 { 1558 UPDATE t1 SET b = a_string(399) WHERE a <= $nUp 1559 } {} 1560 do_execsql_test pager1-13.1.2.$nUp.2 { PRAGMA integrity_check } {ok} 1561 1562 # Try to access the snapshot of the file-system. 1563 # 1564 sqlite3 db2 sv_test.db 1565 do_test pager1-13.1.2.$nUp.3 { 1566 execsql { SELECT sum(length(b)) FROM t1 } db2 1567 } [expr {128*400 - ($nUp-1)}] 1568 do_test pager1-13.1.2.$nUp.4 { 1569 execsql { PRAGMA integrity_check } db2 1570 } {ok} 1571 db2 close 1572} 1573 1574# Same test as above. But this time with an index on the table. 1575# 1576do_execsql_test pager1-13.2.1 { 1577 CREATE INDEX i1 ON t1(b); 1578 UPDATE t1 SET b = a_string(400); 1579} {} 1580for {set nUp 1} {$nUp<64} {incr nUp} { 1581 do_execsql_test pager1-13.2.2.$nUp.1 { 1582 UPDATE t1 SET b = a_string(399) WHERE a <= $nUp 1583 } {} 1584 do_execsql_test pager1-13.2.2.$nUp.2 { PRAGMA integrity_check } {ok} 1585 sqlite3 db2 sv_test.db 1586 do_test pager1-13.2.2.$nUp.3 { 1587 execsql { SELECT sum(length(b)) FROM t1 } db2 1588 } [expr {128*400 - ($nUp-1)}] 1589 do_test pager1-13.2.2.$nUp.4 { 1590 execsql { PRAGMA integrity_check } db2 1591 } {ok} 1592 db2 close 1593} 1594 1595db close 1596tv delete 1597 1598#------------------------------------------------------------------------- 1599# Test specal "PRAGMA journal_mode=OFF" test cases. 1600# 1601faultsim_delete_and_reopen 1602do_execsql_test pager1-14.1.1 { 1603 PRAGMA journal_mode = OFF; 1604 CREATE TABLE t1(a, b); 1605 BEGIN; 1606 INSERT INTO t1 VALUES(1, 2); 1607 COMMIT; 1608 SELECT * FROM t1; 1609} {off 1 2} 1610do_catchsql_test pager1-14.1.2 { 1611 BEGIN; 1612 INSERT INTO t1 VALUES(3, 4); 1613 ROLLBACK; 1614} {0 {}} 1615do_execsql_test pager1-14.1.3 { 1616 SELECT * FROM t1; 1617} {1 2} 1618do_catchsql_test pager1-14.1.4 { 1619 BEGIN; 1620 INSERT INTO t1(rowid, a, b) SELECT a+3, b, b FROM t1; 1621 INSERT INTO t1(rowid, a, b) SELECT a+3, b, b FROM t1; 1622} {1 {PRIMARY KEY must be unique}} 1623do_execsql_test pager1-14.1.5 { 1624 COMMIT; 1625 SELECT * FROM t1; 1626} {1 2 2 2} 1627 1628#------------------------------------------------------------------------- 1629# Test opening and closing the pager sub-system with different values 1630# for the sqlite3_vfs.szOsFile variable. 1631# 1632faultsim_delete_and_reopen 1633do_execsql_test pager1-15.0 { 1634 CREATE TABLE tx(y, z); 1635 INSERT INTO tx VALUES('Ayutthaya', 'Beijing'); 1636 INSERT INTO tx VALUES('London', 'Tokyo'); 1637} {} 1638db close 1639for {set i 0} {$i<513} {incr i 3} { 1640 testvfs tv -default 1 -szosfile $i 1641 sqlite3 db test.db 1642 do_execsql_test pager1-15.$i.1 { 1643 SELECT * FROM tx; 1644 } {Ayutthaya Beijing London Tokyo} 1645 db close 1646 tv delete 1647} 1648 1649#------------------------------------------------------------------------- 1650# Check that it is not possible to open a database file if the full path 1651# to the associated journal file will be longer than sqlite3_vfs.mxPathname. 1652# 1653testvfs tv -default 1 1654tv script xOpenCb 1655tv filter xOpen 1656proc xOpenCb {method filename} { 1657 set ::file_len [string length $filename] 1658} 1659sqlite3 db test.db 1660db close 1661tv delete 1662 1663for {set ii [expr $::file_len-5]} {$ii < [expr $::file_len+20]} {incr ii} { 1664 testvfs tv -default 1 -mxpathname $ii 1665 1666 # The length of the full path to file "test.db-journal" is ($::file_len+8). 1667 # If the configured sqlite3_vfs.mxPathname value greater than or equal to 1668 # this, then the file can be opened. Otherwise, it cannot. 1669 # 1670 if {$ii >= [expr $::file_len+8]} { 1671 set res {0 {}} 1672 } else { 1673 set res {1 {unable to open database file}} 1674 } 1675 1676 do_test pager1-16.1.$ii { 1677 list [catch { sqlite3 db test.db } msg] $msg 1678 } $res 1679 1680 catch {db close} 1681 tv delete 1682} 1683 1684#------------------------------------------------------------------------- 1685# Test "PRAGMA omit_readlock". 1686# 1687# pager1-17.$tn.1.*: Test that if a second connection has an open 1688# read-transaction, it is not usually possible to write 1689# the database. 1690# 1691# pager1-17.$tn.2.*: Test that if the second connection was opened with 1692# the SQLITE_OPEN_READONLY flag, and 1693# "PRAGMA omit_readlock = 1" is executed before attaching 1694# the database and opening a read-transaction on it, it is 1695# possible to write the db. 1696# 1697# pager1-17.$tn.3.*: Test that if the second connection was *not* opened with 1698# the SQLITE_OPEN_READONLY flag, executing 1699# "PRAGMA omit_readlock = 1" has no effect. 1700# 1701do_multiclient_test tn { 1702 do_test pager1-17.$tn.1.1 { 1703 sql1 { 1704 CREATE TABLE t1(a, b); 1705 INSERT INTO t1 VALUES(1, 2); 1706 } 1707 sql2 { 1708 BEGIN; 1709 SELECT * FROM t1; 1710 } 1711 } {1 2} 1712 do_test pager1-17.$tn.1.2 { 1713 csql1 { INSERT INTO t1 VALUES(3, 4) } 1714 } {1 {database is locked}} 1715 do_test pager1-17.$tn.1.3 { 1716 sql2 { COMMIT } 1717 sql1 { INSERT INTO t1 VALUES(3, 4) } 1718 } {} 1719 1720 do_test pager1-17.$tn.2.1 { 1721 code2 { 1722 db2 close 1723 sqlite3 db2 :memory: -readonly 1 1724 } 1725 sql2 { 1726 PRAGMA omit_readlock = 1; 1727 ATTACH 'test.db' AS two; 1728 BEGIN; 1729 SELECT * FROM t1; 1730 } 1731 } {1 2 3 4} 1732 do_test pager1-17.$tn.2.2 { sql1 "INSERT INTO t1 VALUES(5, 6)" } {} 1733 do_test pager1-17.$tn.2.3 { sql2 "SELECT * FROM t1" } {1 2 3 4} 1734 do_test pager1-17.$tn.2.4 { sql2 "COMMIT ; SELECT * FROM t1" } {1 2 3 4 5 6} 1735 1736 do_test pager1-17.$tn.3.1 { 1737 code2 { 1738 db2 close 1739 sqlite3 db2 :memory: 1740 } 1741 sql2 { 1742 PRAGMA omit_readlock = 1; 1743 ATTACH 'test.db' AS two; 1744 BEGIN; 1745 SELECT * FROM t1; 1746 } 1747 } {1 2 3 4 5 6} 1748 do_test pager1-17.$tn.3.2 { 1749 csql1 { INSERT INTO t1 VALUES(3, 4) } 1750 } {1 {database is locked}} 1751 do_test pager1-17.$tn.3.3 { sql2 COMMIT } {} 1752} 1753 1754#------------------------------------------------------------------------- 1755# Test the pagers response to the b-tree layer requesting illegal page 1756# numbers: 1757# 1758# + The locking page, 1759# + Page 0, 1760# + A page with a page number greater than (2^31-1). 1761# 1762do_test pager1-18.1 { 1763 faultsim_delete_and_reopen 1764 db func a_string a_string 1765 execsql { 1766 PRAGMA page_size = 1024; 1767 CREATE TABLE t1(a, b); 1768 INSERT INTO t1 VALUES(a_string(500), a_string(200)); 1769 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1770 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1771 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1772 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1773 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1774 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1775 INSERT INTO t1 SELECT a_string(500), a_string(200) FROM t1; 1776 } 1777} {} 1778do_test pager1-18.2 { 1779 set root [db one "SELECT rootpage FROM sqlite_master"] 1780 set lockingpage [expr (0x10000/1024) + 1] 1781 execsql { 1782 PRAGMA writable_schema = 1; 1783 UPDATE sqlite_master SET rootpage = $lockingpage; 1784 } 1785 sqlite3 db2 test.db 1786 catchsql { SELECT count(*) FROM t1 } db2 1787} {1 {database disk image is malformed}} 1788db2 close 1789do_test pager1-18.3 { 1790 execsql { 1791 CREATE TABLE t2(x); 1792 INSERT INTO t2 VALUES(a_string(5000)); 1793 } 1794 set pgno [expr ([file size test.db] / 1024)-2] 1795 hexio_write test.db [expr ($pgno-1)*1024] 00000000 1796 sqlite3 db2 test.db 1797 catchsql { SELECT length(x) FROM t2 } db2 1798} {1 {database disk image is malformed}} 1799db2 close 1800do_test pager1-18.4 { 1801 hexio_write test.db [expr ($pgno-1)*1024] 90000000 1802 sqlite3 db2 test.db 1803 catchsql { SELECT length(x) FROM t2 } db2 1804} {1 {database disk image is malformed}} 1805db2 close 1806do_test pager1-18.5 { 1807 sqlite3 db "" 1808 execsql { 1809 CREATE TABLE t1(a, b); 1810 CREATE TABLE t2(a, b); 1811 PRAGMA writable_schema = 1; 1812 UPDATE sqlite_master SET rootpage=5 WHERE tbl_name = 't1'; 1813 PRAGMA writable_schema = 0; 1814 ALTER TABLE t1 RENAME TO x1; 1815 } 1816 catchsql { SELECT * FROM x1 } 1817} {1 {database disk image is malformed}} 1818db close 1819 1820do_test pager1-18.6 { 1821 faultsim_delete_and_reopen 1822 db func a_string a_string 1823 execsql { 1824 PRAGMA page_size = 1024; 1825 CREATE TABLE t1(x); 1826 INSERT INTO t1 VALUES(a_string(800)); 1827 INSERT INTO t1 VALUES(a_string(800)); 1828 } 1829 1830 set root [db one "SELECT rootpage FROM sqlite_master"] 1831 db close 1832 1833 hexio_write test.db [expr ($root-1)*1024 + 8] 00000000 1834 sqlite3 db test.db 1835 catchsql { SELECT length(x) FROM t1 } 1836} {1 {database disk image is malformed}} 1837 1838do_test pager1-19.1 { 1839 sqlite3 db "" 1840 db func a_string a_string 1841 execsql { 1842 PRAGMA page_size = 512; 1843 PRAGMA auto_vacuum = 1; 1844 CREATE TABLE t1(aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, 1845 ba, bb, bc, bd, be, bf, bg, bh, bi, bj, bk, bl, bm, bn, 1846 ca, cb, cc, cd, ce, cf, cg, ch, ci, cj, ck, cl, cm, cn, 1847 da, db, dc, dd, de, df, dg, dh, di, dj, dk, dl, dm, dn, 1848 ea, eb, ec, ed, ee, ef, eg, eh, ei, ej, ek, el, em, en, 1849 fa, fb, fc, fd, fe, ff, fg, fh, fi, fj, fk, fl, fm, fn, 1850 ga, gb, gc, gd, ge, gf, gg, gh, gi, gj, gk, gl, gm, gn, 1851 ha, hb, hc, hd, he, hf, hg, hh, hi, hj, hk, hl, hm, hn, 1852 ia, ib, ic, id, ie, if, ig, ih, ii, ij, ik, il, im, ix, 1853 ja, jb, jc, jd, je, jf, jg, jh, ji, jj, jk, jl, jm, jn, 1854 ka, kb, kc, kd, ke, kf, kg, kh, ki, kj, kk, kl, km, kn, 1855 la, lb, lc, ld, le, lf, lg, lh, li, lj, lk, ll, lm, ln, 1856 ma, mb, mc, md, me, mf, mg, mh, mi, mj, mk, ml, mm, mn 1857 ); 1858 CREATE TABLE t2(aa, ab, ac, ad, ae, af, ag, ah, ai, aj, ak, al, am, an, 1859 ba, bb, bc, bd, be, bf, bg, bh, bi, bj, bk, bl, bm, bn, 1860 ca, cb, cc, cd, ce, cf, cg, ch, ci, cj, ck, cl, cm, cn, 1861 da, db, dc, dd, de, df, dg, dh, di, dj, dk, dl, dm, dn, 1862 ea, eb, ec, ed, ee, ef, eg, eh, ei, ej, ek, el, em, en, 1863 fa, fb, fc, fd, fe, ff, fg, fh, fi, fj, fk, fl, fm, fn, 1864 ga, gb, gc, gd, ge, gf, gg, gh, gi, gj, gk, gl, gm, gn, 1865 ha, hb, hc, hd, he, hf, hg, hh, hi, hj, hk, hl, hm, hn, 1866 ia, ib, ic, id, ie, if, ig, ih, ii, ij, ik, il, im, ix, 1867 ja, jb, jc, jd, je, jf, jg, jh, ji, jj, jk, jl, jm, jn, 1868 ka, kb, kc, kd, ke, kf, kg, kh, ki, kj, kk, kl, km, kn, 1869 la, lb, lc, ld, le, lf, lg, lh, li, lj, lk, ll, lm, ln, 1870 ma, mb, mc, md, me, mf, mg, mh, mi, mj, mk, ml, mm, mn 1871 ); 1872 INSERT INTO t1(aa) VALUES( a_string(100000) ); 1873 INSERT INTO t2(aa) VALUES( a_string(100000) ); 1874 VACUUM; 1875 } 1876} {} 1877 1878#------------------------------------------------------------------------- 1879# Test a couple of special cases that come up while committing 1880# transactions: 1881# 1882# pager1-20.1.*: Committing an in-memory database transaction when the 1883# database has not been modified at all. 1884# 1885# pager1-20.2.*: As above, but with a normal db in exclusive-locking mode. 1886# 1887# pager1-20.3.*: Committing a transaction in WAL mode where the database has 1888# been modified, but all dirty pages have been flushed to 1889# disk before the commit. 1890# 1891do_test pager1-20.1.1 { 1892 catch {db close} 1893 sqlite3 db :memory: 1894 execsql { 1895 CREATE TABLE one(two, three); 1896 INSERT INTO one VALUES('a', 'b'); 1897 } 1898} {} 1899do_test pager1-20.1.2 { 1900 execsql { 1901 BEGIN EXCLUSIVE; 1902 COMMIT; 1903 } 1904} {} 1905 1906do_test pager1-20.2.1 { 1907 faultsim_delete_and_reopen 1908 execsql { 1909 PRAGMA locking_mode = exclusive; 1910 PRAGMA journal_mode = persist; 1911 CREATE TABLE one(two, three); 1912 INSERT INTO one VALUES('a', 'b'); 1913 } 1914} {exclusive persist} 1915do_test pager1-20.2.2 { 1916 execsql { 1917 BEGIN EXCLUSIVE; 1918 COMMIT; 1919 } 1920} {} 1921 1922ifcapable wal { 1923 do_test pager1-20.3.1 { 1924 faultsim_delete_and_reopen 1925 db func a_string a_string 1926 execsql { 1927 PRAGMA cache_size = 10; 1928 PRAGMA journal_mode = wal; 1929 BEGIN; 1930 CREATE TABLE t1(x); 1931 CREATE TABLE t2(y); 1932 INSERT INTO t1 VALUES(a_string(800)); 1933 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 2 */ 1934 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 4 */ 1935 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 8 */ 1936 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 16 */ 1937 INSERT INTO t1 SELECT a_string(800) FROM t1; /* 32 */ 1938 COMMIT; 1939 } 1940 } {wal} 1941 do_test pager1-20.3.2 { 1942 execsql { 1943 BEGIN; 1944 INSERT INTO t2 VALUES('xxxx'); 1945 } 1946 recursive_select 32 t1 1947 execsql COMMIT 1948 } {} 1949} 1950 1951#------------------------------------------------------------------------- 1952# Test that a WAL database may not be opened if: 1953# 1954# pager1-21.1.*: The VFS has an iVersion less than 2, or 1955# pager1-21.2.*: The VFS does not provide xShmXXX() methods. 1956# 1957ifcapable wal { 1958 do_test pager1-21.0 { 1959 faultsim_delete_and_reopen 1960 execsql { 1961 PRAGMA journal_mode = WAL; 1962 CREATE TABLE ko(c DEFAULT 'abc', b DEFAULT 'def'); 1963 INSERT INTO ko DEFAULT VALUES; 1964 } 1965 } {wal} 1966 do_test pager1-21.1 { 1967 testvfs tv -noshm 1 1968 sqlite3 db2 test.db -vfs tv 1969 catchsql { SELECT * FROM ko } db2 1970 } {1 {unable to open database file}} 1971 db2 close 1972 tv delete 1973 do_test pager1-21.2 { 1974 testvfs tv -iversion 1 1975 sqlite3 db2 test.db -vfs tv 1976 catchsql { SELECT * FROM ko } db2 1977 } {1 {unable to open database file}} 1978 db2 close 1979 tv delete 1980} 1981 1982#------------------------------------------------------------------------- 1983# Test that a "PRAGMA wal_checkpoint": 1984# 1985# pager1-22.1.*: is a no-op on a non-WAL db, and 1986# pager1-22.2.*: does not cause xSync calls with a synchronous=off db. 1987# 1988do_test pager1-22.1.1 { 1989 faultsim_delete_and_reopen 1990 execsql { 1991 CREATE TABLE ko(c DEFAULT 'abc', b DEFAULT 'def'); 1992 INSERT INTO ko DEFAULT VALUES; 1993 } 1994 execsql { PRAGMA wal_checkpoint } 1995} {0 -1 -1} 1996do_test pager1-22.2.1 { 1997 testvfs tv -default 1 1998 tv filter xSync 1999 tv script xSyncCb 2000 proc xSyncCb {args} {incr ::synccount} 2001 set ::synccount 0 2002 sqlite3 db test.db 2003 execsql { 2004 PRAGMA synchronous = off; 2005 PRAGMA journal_mode = WAL; 2006 INSERT INTO ko DEFAULT VALUES; 2007 } 2008 execsql { PRAGMA wal_checkpoint } 2009 set synccount 2010} {0} 2011db close 2012tv delete 2013 2014#------------------------------------------------------------------------- 2015# Tests for changing journal mode. 2016# 2017# pager1-23.1.*: Test that when changing from PERSIST to DELETE mode, 2018# the journal file is deleted. 2019# 2020# pager1-23.2.*: Same test as above, but while a shared lock is held 2021# on the database file. 2022# 2023# pager1-23.3.*: Same test as above, but while a reserved lock is held 2024# on the database file. 2025# 2026# pager1-23.4.*: And, for fun, while holding an exclusive lock. 2027# 2028# pager1-23.5.*: Try to set various different journal modes with an 2029# in-memory database (only MEMORY and OFF should work). 2030# 2031# pager1-23.6.*: Try to set locking_mode=normal on an in-memory database 2032# (doesn't work - in-memory databases always use 2033# locking_mode=exclusive). 2034# 2035do_test pager1-23.1.1 { 2036 faultsim_delete_and_reopen 2037 execsql { 2038 PRAGMA journal_mode = PERSIST; 2039 CREATE TABLE t1(a, b); 2040 } 2041 file exists test.db-journal 2042} {1} 2043do_test pager1-23.1.2 { 2044 execsql { PRAGMA journal_mode = DELETE } 2045 file exists test.db-journal 2046} {0} 2047 2048do_test pager1-23.2.1 { 2049 execsql { 2050 PRAGMA journal_mode = PERSIST; 2051 INSERT INTO t1 VALUES('Canberra', 'ACT'); 2052 } 2053 db eval { SELECT * FROM t1 } { 2054 db eval { PRAGMA journal_mode = DELETE } 2055 } 2056 execsql { PRAGMA journal_mode } 2057} {delete} 2058do_test pager1-23.2.2 { 2059 file exists test.db-journal 2060} {0} 2061 2062do_test pager1-23.3.1 { 2063 execsql { 2064 PRAGMA journal_mode = PERSIST; 2065 INSERT INTO t1 VALUES('Darwin', 'NT'); 2066 BEGIN IMMEDIATE; 2067 } 2068 db eval { PRAGMA journal_mode = DELETE } 2069 execsql { PRAGMA journal_mode } 2070} {delete} 2071do_test pager1-23.3.2 { 2072 file exists test.db-journal 2073} {0} 2074do_test pager1-23.3.3 { 2075 execsql COMMIT 2076} {} 2077 2078do_test pager1-23.4.1 { 2079 execsql { 2080 PRAGMA journal_mode = PERSIST; 2081 INSERT INTO t1 VALUES('Adelaide', 'SA'); 2082 BEGIN EXCLUSIVE; 2083 } 2084 db eval { PRAGMA journal_mode = DELETE } 2085 execsql { PRAGMA journal_mode } 2086} {delete} 2087do_test pager1-23.4.2 { 2088 file exists test.db-journal 2089} {0} 2090do_test pager1-23.4.3 { 2091 execsql COMMIT 2092} {} 2093 2094do_test pager1-23.5.1 { 2095 faultsim_delete_and_reopen 2096 sqlite3 db :memory: 2097} {} 2098foreach {tn mode possible} { 2099 2 off 1 2100 3 memory 1 2101 4 persist 0 2102 5 delete 0 2103 6 wal 0 2104 7 truncate 0 2105} { 2106 do_test pager1-23.5.$tn.1 { 2107 execsql "PRAGMA journal_mode = off" 2108 execsql "PRAGMA journal_mode = $mode" 2109 } [if $possible {list $mode} {list off}] 2110 do_test pager1-23.5.$tn.2 { 2111 execsql "PRAGMA journal_mode = memory" 2112 execsql "PRAGMA journal_mode = $mode" 2113 } [if $possible {list $mode} {list memory}] 2114} 2115do_test pager1-23.6.1 { 2116 execsql {PRAGMA locking_mode = normal} 2117} {exclusive} 2118do_test pager1-23.6.2 { 2119 execsql {PRAGMA locking_mode = exclusive} 2120} {exclusive} 2121do_test pager1-23.6.3 { 2122 execsql {PRAGMA locking_mode} 2123} {exclusive} 2124do_test pager1-23.6.4 { 2125 execsql {PRAGMA main.locking_mode} 2126} {exclusive} 2127 2128#------------------------------------------------------------------------- 2129# 2130do_test pager1-24.1.1 { 2131 faultsim_delete_and_reopen 2132 db func a_string a_string 2133 execsql { 2134 PRAGMA cache_size = 10; 2135 PRAGMA auto_vacuum = FULL; 2136 CREATE TABLE x1(x, y, z, PRIMARY KEY(y, z)); 2137 CREATE TABLE x2(x, y, z, PRIMARY KEY(y, z)); 2138 INSERT INTO x2 VALUES(a_string(400), a_string(500), a_string(600)); 2139 INSERT INTO x2 SELECT a_string(600), a_string(400), a_string(500) FROM x2; 2140 INSERT INTO x2 SELECT a_string(500), a_string(600), a_string(400) FROM x2; 2141 INSERT INTO x2 SELECT a_string(400), a_string(500), a_string(600) FROM x2; 2142 INSERT INTO x2 SELECT a_string(600), a_string(400), a_string(500) FROM x2; 2143 INSERT INTO x2 SELECT a_string(500), a_string(600), a_string(400) FROM x2; 2144 INSERT INTO x2 SELECT a_string(400), a_string(500), a_string(600) FROM x2; 2145 INSERT INTO x1 SELECT * FROM x2; 2146 } 2147} {} 2148do_test pager1-24.1.2 { 2149 execsql { 2150 BEGIN; 2151 DELETE FROM x1 WHERE rowid<32; 2152 } 2153 recursive_select 64 x2 2154} {} 2155do_test pager1-24.1.3 { 2156 execsql { 2157 UPDATE x1 SET z = a_string(300) WHERE rowid>40; 2158 COMMIT; 2159 PRAGMA integrity_check; 2160 SELECT count(*) FROM x1; 2161 } 2162} {ok 33} 2163 2164do_test pager1-24.1.4 { 2165 execsql { 2166 DELETE FROM x1; 2167 INSERT INTO x1 SELECT * FROM x2; 2168 BEGIN; 2169 DELETE FROM x1 WHERE rowid<32; 2170 UPDATE x1 SET z = a_string(299) WHERE rowid>40; 2171 } 2172 recursive_select 64 x2 {db eval COMMIT} 2173 execsql { 2174 PRAGMA integrity_check; 2175 SELECT count(*) FROM x1; 2176 } 2177} {ok 33} 2178 2179do_test pager1-24.1.5 { 2180 execsql { 2181 DELETE FROM x1; 2182 INSERT INTO x1 SELECT * FROM x2; 2183 } 2184 recursive_select 64 x2 { db eval {CREATE TABLE x3(x, y, z)} } 2185 execsql { SELECT * FROM x3 } 2186} {} 2187 2188#------------------------------------------------------------------------- 2189# 2190do_test pager1-25-1 { 2191 faultsim_delete_and_reopen 2192 execsql { 2193 BEGIN; 2194 SAVEPOINT abc; 2195 CREATE TABLE t1(a, b); 2196 ROLLBACK TO abc; 2197 COMMIT; 2198 } 2199 db close 2200} {} 2201breakpoint 2202do_test pager1-25-2 { 2203 faultsim_delete_and_reopen 2204 execsql { 2205 SAVEPOINT abc; 2206 CREATE TABLE t1(a, b); 2207 ROLLBACK TO abc; 2208 COMMIT; 2209 } 2210 db close 2211} {} 2212 2213#------------------------------------------------------------------------- 2214# Sector-size tests. 2215# 2216do_test pager1-26.1 { 2217 testvfs tv -default 1 2218 tv sectorsize 4096 2219 faultsim_delete_and_reopen 2220 db func a_string a_string 2221 execsql { 2222 PRAGMA page_size = 512; 2223 CREATE TABLE tbl(a PRIMARY KEY, b UNIQUE); 2224 BEGIN; 2225 INSERT INTO tbl VALUES(a_string(25), a_string(600)); 2226 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2227 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2228 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2229 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2230 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2231 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2232 INSERT INTO tbl SELECT a_string(25), a_string(600) FROM tbl; 2233 COMMIT; 2234 } 2235} {} 2236do_execsql_test pager1-26.1 { 2237 UPDATE tbl SET b = a_string(550); 2238} {} 2239db close 2240tv delete 2241 2242#------------------------------------------------------------------------- 2243# 2244do_test pager1.27.1 { 2245 faultsim_delete_and_reopen 2246 sqlite3_pager_refcounts db 2247 execsql { 2248 BEGIN; 2249 CREATE TABLE t1(a, b); 2250 } 2251 sqlite3_pager_refcounts db 2252 execsql COMMIT 2253} {} 2254 2255#------------------------------------------------------------------------- 2256# Test that attempting to open a write-transaction with 2257# locking_mode=exclusive in WAL mode fails if there are other clients on 2258# the same database. 2259# 2260catch { db close } 2261ifcapable wal { 2262 do_multiclient_test tn { 2263 do_test pager1-28.$tn.1 { 2264 sql1 { 2265 PRAGMA journal_mode = WAL; 2266 CREATE TABLE t1(a, b); 2267 INSERT INTO t1 VALUES('a', 'b'); 2268 } 2269 } {wal} 2270 do_test pager1-28.$tn.2 { sql2 { SELECT * FROM t1 } } {a b} 2271 2272 do_test pager1-28.$tn.3 { sql1 { PRAGMA locking_mode=exclusive } } {exclusive} 2273 do_test pager1-28.$tn.4 { 2274 csql1 { BEGIN; INSERT INTO t1 VALUES('c', 'd'); } 2275 } {1 {database is locked}} 2276 code2 { db2 close ; sqlite3 db2 test.db } 2277 do_test pager1-28.$tn.4 { 2278 sql1 { INSERT INTO t1 VALUES('c', 'd'); COMMIT } 2279 } {} 2280 } 2281} 2282 2283#------------------------------------------------------------------------- 2284# Normally, when changing from journal_mode=PERSIST to DELETE the pager 2285# attempts to delete the journal file. However, if it cannot obtain a 2286# RESERVED lock on the database file, this step is skipped. 2287# 2288do_multiclient_test tn { 2289 do_test pager1-28.$tn.1 { 2290 sql1 { 2291 PRAGMA journal_mode = PERSIST; 2292 CREATE TABLE t1(a, b); 2293 INSERT INTO t1 VALUES('a', 'b'); 2294 } 2295 } {persist} 2296 do_test pager1-28.$tn.2 { file exists test.db-journal } 1 2297 do_test pager1-28.$tn.3 { sql1 { PRAGMA journal_mode = DELETE } } delete 2298 do_test pager1-28.$tn.4 { file exists test.db-journal } 0 2299 2300 do_test pager1-28.$tn.5 { 2301 sql1 { 2302 PRAGMA journal_mode = PERSIST; 2303 INSERT INTO t1 VALUES('c', 'd'); 2304 } 2305 } {persist} 2306 do_test pager1-28.$tn.6 { file exists test.db-journal } 1 2307 do_test pager1-28.$tn.7 { 2308 sql2 { BEGIN; INSERT INTO t1 VALUES('e', 'f'); } 2309 } {} 2310 do_test pager1-28.$tn.8 { file exists test.db-journal } 1 2311 do_test pager1-28.$tn.9 { sql1 { PRAGMA journal_mode = DELETE } } delete 2312 do_test pager1-28.$tn.10 { file exists test.db-journal } 1 2313 2314 do_test pager1-28.$tn.11 { sql2 COMMIT } {} 2315 do_test pager1-28.$tn.12 { file exists test.db-journal } 0 2316 2317 do_test pager1-28-$tn.13 { 2318 code1 { set channel [db incrblob -readonly t1 a 2] } 2319 sql1 { 2320 PRAGMA journal_mode = PERSIST; 2321 INSERT INTO t1 VALUES('g', 'h'); 2322 } 2323 } {persist} 2324 do_test pager1-28.$tn.14 { file exists test.db-journal } 1 2325 do_test pager1-28.$tn.15 { 2326 sql2 { BEGIN; INSERT INTO t1 VALUES('e', 'f'); } 2327 } {} 2328 do_test pager1-28.$tn.16 { sql1 { PRAGMA journal_mode = DELETE } } delete 2329 do_test pager1-28.$tn.17 { file exists test.db-journal } 1 2330 2331 do_test pager1-28.$tn.17 { csql2 { COMMIT } } {1 {database is locked}} 2332 do_test pager1-28-$tn.18 { code1 { read $channel } } c 2333 do_test pager1-28-$tn.19 { code1 { close $channel } } {} 2334 do_test pager1-28.$tn.20 { sql2 { COMMIT } } {} 2335} 2336 2337do_test pager1-29.1 { 2338 faultsim_delete_and_reopen 2339 execsql { 2340 PRAGMA page_size = 1024; 2341 PRAGMA auto_vacuum = full; 2342 PRAGMA locking_mode=exclusive; 2343 CREATE TABLE t1(a, b); 2344 INSERT INTO t1 VALUES(1, 2); 2345 } 2346 file size test.db 2347} [expr 1024*3] 2348do_test pager1-29.2 { 2349 execsql { 2350 PRAGMA page_size = 4096; 2351 VACUUM; 2352 } 2353 file size test.db 2354} [expr 4096*3] 2355 2356#------------------------------------------------------------------------- 2357# Test that if an empty database file (size 0 bytes) is opened in 2358# exclusive-locking mode, any journal file is deleted from the file-system 2359# without being rolled back. And that the RESERVED lock obtained while 2360# doing this is not released. 2361# 2362do_test pager1-30.1 { 2363 db close 2364 file delete test.db 2365 file delete test.db-journal 2366 set fd [open test.db-journal w] 2367 seek $fd [expr 512+1032*2] 2368 puts -nonewline $fd x 2369 close $fd 2370 2371 sqlite3 db test.db 2372 execsql { 2373 PRAGMA locking_mode=EXCLUSIVE; 2374 SELECT count(*) FROM sqlite_master; 2375 PRAGMA lock_status; 2376 } 2377} {exclusive 0 main reserved temp closed} 2378 2379#------------------------------------------------------------------------- 2380# Test that if the "page-size" field in a journal-header is 0, the journal 2381# file can still be rolled back. This is required for backward compatibility - 2382# versions of SQLite prior to 3.5.8 always set this field to zero. 2383# 2384do_test pager1-31.1 { 2385 faultsim_delete_and_reopen 2386 execsql { 2387 PRAGMA cache_size = 10; 2388 PRAGMA page_size = 1024; 2389 CREATE TABLE t1(x, y, UNIQUE(x, y)); 2390 INSERT INTO t1 VALUES(randomblob(1500), randomblob(1500)); 2391 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2392 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2393 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2394 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2395 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2396 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2397 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2398 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2399 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2400 INSERT INTO t1 SELECT randomblob(1500), randomblob(1500) FROM t1; 2401 BEGIN; 2402 UPDATE t1 SET y = randomblob(1499); 2403 } 2404 file copy test.db test.db2 2405 file copy test.db-journal test.db2-journal 2406 2407 hexio_write test.db2-journal 24 00000000 2408 sqlite3 db2 test.db2 2409 execsql { PRAGMA integrity_check } db2 2410} {ok} 2411 2412 2413 2414finish_test 2415