src/third_party/sqlite/src/test/wal.test

   1 # 2010 April 13
   2 #
   3 # The author disclaims copyright to this source code.  In place of
   4 # a legal notice, here is a blessing:
   5 #
   6 #    May you do good and not evil.
   7 #    May you find forgiveness for yourself and forgive others.
   8 #    May you share freely, never taking more than you give.
   9 #
  10 #***********************************************************************
  11 # This file implements regression tests for SQLite library.  The
  12 # focus of this file is testing the operation of the library in
  13 # "PRAGMA journal_mode=WAL" mode.
  14 #
  15
  16 set testdir [file dirname $argv0]
  17 source $testdir/tester.tcl
  18 source $testdir/lock_common.tcl
  19 source $testdir/malloc_common.tcl
  20 source $testdir/wal_common.tcl
  21
  22 set testprefix wal
  23
  24 ifcapable !wal {finish_test ; return }
  25
  26 proc reopen_db {} {
  27   catch { db close }
  28   file delete -force test.db test.db-wal test.db-wal-summary
  29   sqlite3_wal db test.db
  30 }
  31
  32 set ::blobcnt 0
  33 proc blob {nByte} {
  34   incr ::blobcnt
  35   return [string range [string repeat "${::blobcnt}x" $nByte] 1 $nByte]
  36 }
  37
  38 proc sqlite3_wal {args} {
  39   eval sqlite3 $args
  40   [lindex $args 0] eval { PRAGMA auto_vacuum = 0 }
  41   [lindex $args 0] eval { PRAGMA page_size = 1024 }
  42   [lindex $args 0] eval { PRAGMA journal_mode = wal }
  43   [lindex $args 0] eval { PRAGMA synchronous = normal }
  44   [lindex $args 0] function blob blob
  45 }
  46
  47 proc log_deleted {logfile} {
  48   return [expr [file exists $logfile]==0]
  49 }
  50
  51 #
  52 # These are 'warm-body' tests used while developing the WAL code. They
  53 # serve to prove that a few really simple cases work:
  54 #
  55 # wal-1.*: Read and write the database.
  56 # wal-2.*: Test MVCC with one reader, one writer.
  57 # wal-3.*: Test transaction rollback.
  58 # wal-4.*: Test savepoint/statement rollback.
  59 # wal-5.*: Test the temp database.
  60 # wal-6.*: Test creating databases with different page sizes.
  61 #
  62 #
  63 #
  64 do_test wal-0.1 {
  65   execsql { PRAGMA auto_vacuum = 0 }
  66   execsql { PRAGMA synchronous = normal }
  67   execsql { PRAGMA journal_mode = wal }
  68 } {wal}
  69 do_test wal-0.2 {
  70   file size test.db
  71 } {1024}
  72
  73 do_test wal-1.0 {
  74   execsql {
  75     BEGIN;
  76     CREATE TABLE t1(a, b);
  77   }
  78   list [file exists test.db-journal] \
  79        [file exists test.db-wal]     \
  80        [file size test.db]
  81 } {0 1 1024}
  82 do_test wal-1.1 {
  83   execsql COMMIT
  84   list [file exists test.db-journal] [file exists test.db-wal]
  85 } {0 1}
  86 do_test wal-1.2 {
  87   # There are now two pages in the log.
  88   file size test.db-wal
  89 } [wal_file_size 2 1024]
  90
  91 do_test wal-1.3 {
  92   execsql { SELECT * FROM sqlite_master }
  93 } {table t1 t1 2 {CREATE TABLE t1(a, b)}}
  94
  95 do_test wal-1.4 {
  96   execsql { INSERT INTO t1 VALUES(1, 2) }
  97   execsql { INSERT INTO t1 VALUES(3, 4) }
  98   execsql { INSERT INTO t1 VALUES(5, 6) }
  99   execsql { INSERT INTO t1 VALUES(7, 8) }
 100   execsql { INSERT INTO t1 VALUES(9, 10) }
 101 } {}
 102
 103 do_test wal-1.5 {
 104   execsql { SELECT * FROM t1 }
 105 } {1 2 3 4 5 6 7 8 9 10}
 106
 107 do_test wal-2.1 {
 108   sqlite3_wal db2 ./test.db
 109   execsql { BEGIN; SELECT * FROM t1 } db2
 110 } {1 2 3 4 5 6 7 8 9 10}
 111
 112 do_test wal-2.2 {
 113   execsql { INSERT INTO t1 VALUES(11, 12) }
 114   execsql { SELECT * FROM t1 }
 115 } {1 2 3 4 5 6 7 8 9 10 11 12}
 116
 117 do_test wal-2.3 {
 118   execsql { SELECT * FROM t1 } db2
 119 } {1 2 3 4 5 6 7 8 9 10}
 120
 121 do_test wal-2.4 {
 122   execsql { INSERT INTO t1 VALUES(13, 14) }
 123   execsql { SELECT * FROM t1 }
 124 } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 125
 126 do_test wal-2.5 {
 127   execsql { SELECT * FROM t1 } db2
 128 } {1 2 3 4 5 6 7 8 9 10}
 129
 130 do_test wal-2.6 {
 131   execsql { COMMIT; SELECT * FROM t1 } db2
 132 } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 133
 134 do_test wal-3.1 {
 135   execsql { BEGIN; DELETE FROM t1 }
 136   execsql { SELECT * FROM t1 }
 137 } {}
 138 do_test wal-3.2 {
 139   execsql { SELECT * FROM t1 } db2
 140 } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 141 do_test wal-3.3 {
 142   execsql { ROLLBACK }
 143   execsql { SELECT * FROM t1 }
 144 } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 145 db2 close
 146
 147 #-------------------------------------------------------------------------
 148 # The following tests, wal-4.*, test that savepoints work with WAL
 149 # databases.
 150 #
 151 do_test wal-4.1 {
 152   execsql {
 153     DELETE FROM t1;
 154     BEGIN;
 155       INSERT INTO t1 VALUES('a', 'b');
 156       SAVEPOINT sp;
 157         INSERT INTO t1 VALUES('c', 'd');
 158         SELECT * FROM t1;
 159   }
 160 } {a b c d}
 161 do_test wal-4.2 {
 162   execsql {
 163       ROLLBACK TO sp;
 164       SELECT * FROM t1;
 165   }
 166 } {a b}
 167 do_test wal-4.3 {
 168   execsql {
 169     COMMIT;
 170     SELECT * FROM t1;
 171   }
 172 } {a b}
 173
 174 do_test wal-4.4.1 {
 175   db close
 176   sqlite3 db test.db
 177   db func blob blob
 178   list [execsql { SELECT * FROM t1 }] [file size test.db-wal]
 179 } {{a b} 0}
 180 do_test wal-4.4.2 {
 181   execsql { PRAGMA cache_size = 10 }
 182   execsql {
 183     CREATE TABLE t2(a, b);
 184     INSERT INTO t2 VALUES(blob(400), blob(400));
 185     SAVEPOINT tr;
 186       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /*  2 */
 187       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /*  4 */
 188       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /*  8 */
 189       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /* 16 */
 190       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /* 32 */
 191       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /*  2 */
 192       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /*  4 */
 193       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /*  8 */
 194       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /* 16 */
 195       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /* 32 */
 196       SELECT count(*) FROM t2;
 197   }
 198 } {32}
 199 do_test wal-4.4.3 {
 200   execsql { ROLLBACK TO tr }
 201 } {}
 202 do_test wal-4.4.4 {
 203   set logsize [file size test.db-wal]
 204   execsql {
 205       INSERT INTO t1 VALUES('x', 'y');
 206     RELEASE tr;
 207   }
 208   expr { $logsize == [file size test.db-wal] }
 209 } {1}
 210 do_test wal-4.4.5 {
 211   execsql { SELECT count(*) FROM t2 }
 212 } {1}
 213 do_test wal-4.4.6 {
 214   file copy -force test.db test2.db
 215   file copy -force test.db-wal test2.db-wal
 216   sqlite3 db2 test2.db
 217   execsql { SELECT count(*) FROM t2 ; SELECT count(*) FROM t1 } db2
 218 } {1 2}
 219 do_test wal-4.4.7 {
 220   execsql { PRAGMA integrity_check } db2
 221 } {ok}
 222 db2 close
 223
 224 do_test wal-4.5.1 {
 225   reopen_db
 226   db func blob blob
 227   execsql {
 228     PRAGMA journal_mode = WAL;
 229     CREATE TABLE t1(a, b);
 230     INSERT INTO t1 VALUES('a', 'b');
 231   }
 232   sqlite3 db test.db
 233   db func blob blob
 234   list [execsql { SELECT * FROM t1 }] [file size test.db-wal]
 235 } {{a b} 0}
 236 do_test wal-4.5.2 {
 237   execsql { PRAGMA cache_size = 10 }
 238   execsql {
 239     CREATE TABLE t2(a, b);
 240     BEGIN;
 241     INSERT INTO t2 VALUES(blob(400), blob(400));
 242     SAVEPOINT tr;
 243       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /*  2 */
 244       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /*  4 */
 245       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /*  8 */
 246       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /* 16 */
 247       INSERT INTO t2 SELECT blob(400), blob(400) FROM t2; /* 32 */
 248       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /*  2 */
 249       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /*  4 */
 250       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /*  8 */
 251       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /* 16 */
 252       INSERT INTO t1 SELECT blob(400), blob(400) FROM t1; /* 32 */
 253       SELECT count(*) FROM t2;
 254   }
 255 } {32}
 256 do_test wal-4.5.3 {
 257   execsql { ROLLBACK TO tr }
 258 } {}
 259 do_test wal-4.5.4 {
 260   set logsize [file size test.db-wal]
 261   execsql {
 262       INSERT INTO t1 VALUES('x', 'y');
 263     RELEASE tr;
 264     COMMIT;
 265   }
 266   expr { $logsize == [file size test.db-wal] }
 267 } {1}
 268 do_test wal-4.5.5 {
 269   execsql { SELECT count(*) FROM t2 ; SELECT count(*) FROM t1 }
 270 } {1 2}
 271 do_test wal-4.5.6 {
 272   file copy -force test.db test2.db
 273   file copy -force test.db-wal test2.db-wal
 274   sqlite3 db2 test2.db
 275   execsql { SELECT count(*) FROM t2 ; SELECT count(*) FROM t1 } db2
 276 } {1 2}
 277 do_test wal-4.5.7 {
 278   execsql { PRAGMA integrity_check } db2
 279 } {ok}
 280 db2 close
 281
 282 do_test wal-4.6.1 {
 283   execsql {
 284     DELETE FROM t2;
 285     PRAGMA wal_checkpoint;
 286     BEGIN;
 287       INSERT INTO t2 VALUES('w', 'x');
 288       SAVEPOINT save;
 289         INSERT INTO t2 VALUES('y', 'z');
 290       ROLLBACK TO save;
 291     COMMIT;
 292   }
 293   execsql { SELECT * FROM t2 }
 294 } {w x}
 295
 296
 297 reopen_db
 298 do_test wal-5.1 {
 299   execsql {
 300     CREATE TEMP TABLE t2(a, b);
 301     INSERT INTO t2 VALUES(1, 2);
 302   }
 303 } {}
 304 do_test wal-5.2 {
 305   execsql {
 306     BEGIN;
 307       INSERT INTO t2 VALUES(3, 4);
 308       SELECT * FROM t2;
 309   }
 310 } {1 2 3 4}
 311 do_test wal-5.3 {
 312   execsql {
 313     ROLLBACK;
 314     SELECT * FROM t2;
 315   }
 316 } {1 2}
 317 do_test wal-5.4 {
 318   execsql {
 319     CREATE TEMP TABLE t3(x UNIQUE);
 320     BEGIN;
 321       INSERT INTO t2 VALUES(3, 4);
 322       INSERT INTO t3 VALUES('abc');
 323   }
 324   catchsql { INSERT INTO t3 VALUES('abc') }
 325 } {1 {column x is not unique}}
 326 do_test wal-5.5 {
 327   execsql {
 328     COMMIT;
 329     SELECT * FROM t2;
 330   }
 331 } {1 2 3 4}
 332 db close
 333
 334 foreach sector {512 4096} {
 335   sqlite3_simulate_device -sectorsize $sector
 336   foreach pgsz {512 1024 2048 4096} {
 337     file delete -force test.db test.db-wal
 338     do_test wal-6.$sector.$pgsz.1 {
 339       sqlite3 db test.db -vfs devsym
 340       execsql "
 341         PRAGMA page_size = $pgsz;
 342         PRAGMA auto_vacuum = 0;
 343         PRAGMA journal_mode = wal;
 344       "
 345       execsql "
 346         CREATE TABLE t1(a, b);
 347         INSERT INTO t1 VALUES(1, 2);
 348       "
 349       db close
 350       file size test.db
 351     } [expr $pgsz*2]
 352
 353     do_test wal-6.$sector.$pgsz.2 {
 354       log_deleted test.db-wal
 355     } {1}
 356   }
 357 }
 358
 359 do_test wal-7.1 {
 360   file delete -force test.db test.db-wal
 361   sqlite3_wal db test.db
 362   execsql {
 363     PRAGMA page_size = 1024;
 364     CREATE TABLE t1(a, b);
 365     INSERT INTO t1 VALUES(1, 2);
 366   }
 367   list [file size test.db] [file size test.db-wal]
 368 } [list 1024 [wal_file_size 3 1024]]
 369 do_test wal-7.2 {
 370   execsql { PRAGMA wal_checkpoint }
 371   list [file size test.db] [file size test.db-wal]
 372 } [list 2048 [wal_file_size 3 1024]]
 373
 374 # Execute some transactions in auto-vacuum mode to test database file
 375 # truncation.
 376 #
 377 do_test wal-8.1 {
 378   reopen_db
 379   catch { db close }
 380   file delete -force test.db test.db-wal
 381
 382   sqlite3 db test.db
 383   db function blob blob
 384   execsql {
 385     PRAGMA auto_vacuum = 1;
 386     PRAGMA journal_mode = wal;
 387     PRAGMA auto_vacuum;
 388   }
 389 } {wal 1}
 390 do_test wal-8.2 {
 391   execsql {
 392     PRAGMA page_size = 1024;
 393     CREATE TABLE t1(x);
 394     INSERT INTO t1 VALUES(blob(900));
 395     INSERT INTO t1 VALUES(blob(900));
 396     INSERT INTO t1 SELECT blob(900) FROM t1;       /*  4 */
 397     INSERT INTO t1 SELECT blob(900) FROM t1;       /*  8 */
 398     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 16 */
 399     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 32 */
 400     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 64 */
 401     PRAGMA wal_checkpoint;
 402   }
 403   file size test.db
 404 } [expr 68*1024]
 405 do_test wal-8.3 {
 406   execsql {
 407     DELETE FROM t1 WHERE rowid<54;
 408     PRAGMA wal_checkpoint;
 409   }
 410   file size test.db
 411 } [expr 14*1024]
 412
 413 # Run some "warm-body" tests to ensure that log-summary files with more
 414 # than 256 entries (log summaries that contain index blocks) work Ok.
 415 #
 416 do_test wal-9.1 {
 417   reopen_db
 418   execsql {
 419     CREATE TABLE t1(x PRIMARY KEY);
 420     INSERT INTO t1 VALUES(blob(900));
 421     INSERT INTO t1 VALUES(blob(900));
 422     INSERT INTO t1 SELECT blob(900) FROM t1;       /*  4 */
 423     INSERT INTO t1 SELECT blob(900) FROM t1;       /*  8 */
 424     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 16 */
 425     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 32 */
 426     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 64 */
 427     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 128 */
 428     INSERT INTO t1 SELECT blob(900) FROM t1;       /* 256 */
 429   }
 430   file size test.db
 431 } 1024
 432 do_test wal-9.2 {
 433   sqlite3_wal db2 test.db
 434   execsql {PRAGMA integrity_check } db2
 435 } {ok}
 436
 437 do_test wal-9.3 {
 438   file delete -force test2.db test2.db-wal
 439   file copy test.db test2.db
 440   file copy test.db-wal test2.db-wal
 441   sqlite3_wal db3 test2.db
 442   execsql {PRAGMA integrity_check } db3
 443 } {ok}
 444 db3 close
 445
 446 do_test wal-9.4 {
 447   execsql { PRAGMA wal_checkpoint }
 448   db2 close
 449   sqlite3_wal db2 test.db
 450   execsql {PRAGMA integrity_check } db2
 451 } {ok}
 452
 453 foreach handle {db db2 db3} { catch { $handle close } }
 454 unset handle
 455
 456 #-------------------------------------------------------------------------
 457 # The following block of tests - wal-10.* - test that the WAL locking
 458 # scheme works in simple cases. This block of tests is run twice. Once
 459 # using multiple connections in the address space of the current process,
 460 # and once with all connections except one running in external processes.
 461 #
 462 do_multiclient_test tn {
 463
 464   # Initialize the database schema and contents.
 465   #
 466   do_test wal-10.$tn.1 {
 467     execsql {
 468       PRAGMA auto_vacuum = 0;
 469       PRAGMA journal_mode = wal;
 470       CREATE TABLE t1(a, b);
 471       INSERT INTO t1 VALUES(1, 2);
 472       SELECT * FROM t1;
 473     }
 474   } {wal 1 2}
 475
 476   # Open a transaction and write to the database using [db]. Check that [db2]
 477   # is still able to read the snapshot before the transaction was opened.
 478   #
 479   do_test wal-10.$tn.2 {
 480     execsql { BEGIN; INSERT INTO t1 VALUES(3, 4); }
 481     sql2 {SELECT * FROM t1}
 482   } {1 2}
 483
 484   # Have [db] commit the transaction. Check that [db2] is now seeing the
 485   # new, updated snapshot.
 486   #
 487   do_test wal-10.$tn.3 {
 488     execsql { COMMIT }
 489     sql2 {SELECT * FROM t1}
 490   } {1 2 3 4}
 491
 492   # Have [db2] open a read transaction. Then write to the db via [db]. Check
 493   # that [db2] is still seeing the original snapshot. Then read with [db3].
 494   # [db3] should see the newly committed data.
 495   #
 496   do_test wal-10.$tn.4 {
 497     sql2 { BEGIN ; SELECT * FROM t1}
 498   } {1 2 3 4}
 499   do_test wal-10.$tn.5 {
 500     execsql { INSERT INTO t1 VALUES(5, 6); }
 501     sql2 {SELECT * FROM t1}
 502   } {1 2 3 4}
 503   do_test wal-10.$tn.6 {
 504     sql3 {SELECT * FROM t1}
 505   } {1 2 3 4 5 6}
 506   do_test wal-10.$tn.7 {
 507     sql2 COMMIT
 508   } {}
 509
 510   # Have [db2] open a write transaction. Then attempt to write to the
 511   # database via [db]. This should fail (writer lock cannot be obtained).
 512   #
 513   # Then open a read-transaction with [db]. Commit the [db2] transaction
 514   # to disk. Verify that [db] still cannot write to the database (because
 515   # it is reading an old snapshot).
 516   #
 517   # Close the current [db] transaction. Open a new one. [db] can now write
 518   # to the database (as it is not locked and [db] is reading the latest
 519   # snapshot).
 520   #
 521   do_test wal-10.$tn.7 {
 522     sql2 { BEGIN; INSERT INTO t1 VALUES(7, 8) ; }
 523     catchsql { INSERT INTO t1 VALUES(9, 10) }
 524   } {1 {database is locked}}
 525   do_test wal-10.$tn.8 {
 526     execsql { BEGIN ; SELECT * FROM t1 }
 527   } {1 2 3 4 5 6}
 528   do_test wal-10.$tn.9 {
 529     sql2 COMMIT
 530     catchsql { INSERT INTO t1 VALUES(9, 10) }
 531   } {1 {database is locked}}
 532   do_test wal-10.$tn.10 {
 533     execsql { COMMIT }
 534     execsql { BEGIN }
 535     execsql { INSERT INTO t1 VALUES(9, 10) }
 536     execsql { COMMIT }
 537     execsql { SELECT * FROM t1 }
 538   } {1 2 3 4 5 6 7 8 9 10}
 539
 540   # Open a read transaction with [db2]. Check that this prevents [db] from
 541   # checkpointing the database. But not from writing to it.
 542   #
 543   do_test wal-10.$tn.11 {
 544     sql2 { BEGIN; SELECT * FROM t1 }
 545   } {1 2 3 4 5 6 7 8 9 10}
 546   do_test wal-10.$tn.12 {
 547     catchsql { PRAGMA wal_checkpoint }
 548   } {0 {0 13 13}}   ;# Reader no longer block checkpoints
 549   do_test wal-10.$tn.13 {
 550     execsql { INSERT INTO t1 VALUES(11, 12) }
 551     sql2 {SELECT * FROM t1}
 552   } {1 2 3 4 5 6 7 8 9 10}
 553
 554   # Writers do not block checkpoints any more either.
 555   #
 556   do_test wal-10.$tn.14 {
 557     catchsql { PRAGMA wal_checkpoint }
 558   } {0 {0 15 13}}
 559
 560   # The following series of test cases used to verify another blocking
 561   # case in WAL - a case which no longer blocks.
 562   #
 563   do_test wal-10.$tn.15 {
 564     sql2 { COMMIT; BEGIN; SELECT * FROM t1; }
 565   } {1 2 3 4 5 6 7 8 9 10 11 12}
 566   do_test wal-10.$tn.16 {
 567     catchsql { PRAGMA wal_checkpoint }
 568   } {0 {0 15 15}}
 569   do_test wal-10.$tn.17 {
 570     execsql { PRAGMA wal_checkpoint }
 571   } {0 15 15}
 572   do_test wal-10.$tn.18 {
 573     sql3 { BEGIN; SELECT * FROM t1 }
 574   } {1 2 3 4 5 6 7 8 9 10 11 12}
 575   do_test wal-10.$tn.19 {
 576     catchsql { INSERT INTO t1 VALUES(13, 14) }
 577   } {0 {}}
 578   do_test wal-10.$tn.20 {
 579     execsql { SELECT * FROM t1 }
 580   } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 581   do_test wal-10.$tn.21 {
 582     sql3 COMMIT
 583     sql2 COMMIT
 584   } {}
 585   do_test wal-10.$tn.22 {
 586     execsql { SELECT * FROM t1 }
 587   } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 588
 589   # Another series of tests that used to demonstrate blocking behavior
 590   # but which now work.
 591   #
 592   do_test wal-10.$tn.23 {
 593     execsql { PRAGMA wal_checkpoint }
 594   } {0 17 17}
 595   do_test wal-10.$tn.24 {
 596     sql2 { BEGIN; SELECT * FROM t1; }
 597   } {1 2 3 4 5 6 7 8 9 10 11 12 13 14}
 598   do_test wal-10.$tn.25 {
 599     execsql { PRAGMA wal_checkpoint }
 600   } {0 17 17}
 601   do_test wal-10.$tn.26 {
 602     catchsql { INSERT INTO t1 VALUES(15, 16) }
 603   } {0 {}}
 604   do_test wal-10.$tn.27 {
 605     sql3 { INSERT INTO t1 VALUES(17, 18) }
 606   } {}
 607   do_test wal-10.$tn.28 {
 608     code3 {
 609       set ::STMT [sqlite3_prepare db3 "SELECT * FROM t1" -1 TAIL]
 610       sqlite3_step $::STMT
 611     }
 612     execsql { SELECT * FROM t1 }
 613   } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18}
 614   do_test wal-10.$tn.29 {
 615     execsql { INSERT INTO t1 VALUES(19, 20) }
 616     catchsql { PRAGMA wal_checkpoint }
 617   } {0 {0 6 0}}
 618   do_test wal-10.$tn.30 {
 619     code3 { sqlite3_finalize $::STMT }
 620     execsql { PRAGMA wal_checkpoint }
 621   } {0 6 0}
 622
 623   # At one point, if a reader failed to upgrade to a writer because it
 624   # was reading an old snapshot, the write-locks were not being released.
 625   # Test that this bug has been fixed.
 626   #
 627   do_test wal-10.$tn.31 {
 628     sql2 COMMIT
 629     execsql { BEGIN ; SELECT * FROM t1 }
 630     sql2 { INSERT INTO t1 VALUES(21, 22) }
 631     catchsql { INSERT INTO t1 VALUES(23, 24) }
 632   } {1 {database is locked}}
 633   do_test wal-10.$tn.32 {
 634     # This statement would fail when the bug was present.
 635     sql2 { INSERT INTO t1 VALUES(23, 24) }
 636   } {}
 637   do_test wal-10.$tn.33 {
 638     execsql { SELECT * FROM t1 ; COMMIT }
 639   } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}
 640   do_test wal-10.$tn.34 {
 641     execsql { SELECT * FROM t1 }
 642   } {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24}
 643
 644   # Test that if a checkpointer cannot obtain the required locks, it
 645   # releases all locks before returning a busy error.
 646   #
 647   do_test wal-10.$tn.35 {
 648     execsql {
 649       DELETE FROM t1;
 650       INSERT INTO t1 VALUES('a', 'b');
 651       INSERT INTO t1 VALUES('c', 'd');
 652     }
 653     sql2 {
 654       BEGIN;
 655         SELECT * FROM t1;
 656     }
 657   } {a b c d}
 658   do_test wal-10.$tn.36 {
 659     catchsql { PRAGMA wal_checkpoint }
 660   } {0 {0 16 16}}
 661   do_test wal-10.$tn.36 {
 662     sql3 { INSERT INTO t1 VALUES('e', 'f') }
 663     sql2 { SELECT * FROM t1 }
 664   } {a b c d}
 665   do_test wal-10.$tn.37 {
 666     sql2 COMMIT
 667     execsql { PRAGMA wal_checkpoint }
 668   } {0 18 18}
 669 }
 670
 671 #-------------------------------------------------------------------------
 672 # This block of tests, wal-11.*, test that nothing goes terribly wrong
 673 # if frames must be written to the log file before a transaction is
 674 # committed (in order to free up memory).
 675 #
 676 do_test wal-11.1 {
 677   reopen_db
 678   execsql {
 679     PRAGMA cache_size = 10;
 680     PRAGMA page_size = 1024;
 681     CREATE TABLE t1(x PRIMARY KEY);
 682   }
 683   list [expr [file size test.db]/1024] [expr [file size test.db-wal]/1044]
 684 } {1 3}
 685 do_test wal-11.2 {
 686   execsql { PRAGMA wal_checkpoint }
 687   list [expr [file size test.db]/1024] [file size test.db-wal]
 688 } [list 3 [wal_file_size 3 1024]]
 689 do_test wal-11.3 {
 690   execsql { INSERT INTO t1 VALUES( blob(900) ) }
 691   list [expr [file size test.db]/1024] [file size test.db-wal]
 692 } [list 3 [wal_file_size 4 1024]]
 693
 694 do_test wal-11.4 {
 695   execsql {
 696     BEGIN;
 697       INSERT INTO t1 SELECT blob(900) FROM t1;   -- 2
 698       INSERT INTO t1 SELECT blob(900) FROM t1;   -- 4
 699       INSERT INTO t1 SELECT blob(900) FROM t1;   -- 8
 700       INSERT INTO t1 SELECT blob(900) FROM t1;   -- 16
 701   }
 702   list [expr [file size test.db]/1024] [file size test.db-wal]
 703 } [list 3 [wal_file_size 32 1024]]
 704 do_test wal-11.5 {
 705   execsql {
 706     SELECT count(*) FROM t1;
 707     PRAGMA integrity_check;
 708   }
 709 } {16 ok}
 710 do_test wal-11.6 {
 711   execsql COMMIT
 712   list [expr [file size test.db]/1024] [file size test.db-wal]
 713 } [list 3 [wal_file_size 41 1024]]
 714 do_test wal-11.7 {
 715   execsql {
 716     SELECT count(*) FROM t1;
 717     PRAGMA integrity_check;
 718   }
 719 } {16 ok}
 720 do_test wal-11.8 {
 721   execsql { PRAGMA wal_checkpoint }
 722   list [expr [file size test.db]/1024] [file size test.db-wal]
 723 } [list 37 [wal_file_size 41 1024]]
 724 do_test wal-11.9 {
 725   db close
 726   list [expr [file size test.db]/1024] [log_deleted test.db-wal]
 727 } {37 1}
 728 sqlite3_wal db test.db
 729 do_test wal-11.10 {
 730   execsql {
 731     PRAGMA cache_size = 10;
 732     BEGIN;
 733       INSERT INTO t1 SELECT blob(900) FROM t1;   -- 32
 734       SELECT count(*) FROM t1;
 735   }
 736   list [expr [file size test.db]/1024] [file size test.db-wal]
 737 } [list 37 [wal_file_size 37 1024]]
 738 do_test wal-11.11 {
 739   execsql {
 740       SELECT count(*) FROM t1;
 741     ROLLBACK;
 742     SELECT count(*) FROM t1;
 743   }
 744 } {32 16}
 745 do_test wal-11.12 {
 746   list [expr [file size test.db]/1024] [file size test.db-wal]
 747 } [list 37 [wal_file_size 37 1024]]
 748 do_test wal-11.13 {
 749   execsql {
 750     INSERT INTO t1 VALUES( blob(900) );
 751     SELECT count(*) FROM t1;
 752     PRAGMA integrity_check;
 753   }
 754 } {17 ok}
 755 do_test wal-11.14 {
 756   list [expr [file size test.db]/1024] [file size test.db-wal]
 757 } [list 37 [wal_file_size 37 1024]]
 758
 759
 760 #-------------------------------------------------------------------------
 761 # This block of tests, wal-12.*, tests the fix for a problem that
 762 # could occur if a log that is a prefix of an older log is written
 763 # into a reused log file.
 764 #
 765 reopen_db
 766 do_test wal-12.1 {
 767   execsql {
 768     PRAGMA page_size = 1024;
 769     CREATE TABLE t1(x, y);
 770     CREATE TABLE t2(x, y);
 771     INSERT INTO t1 VALUES('A', 1);
 772   }
 773   list [expr [file size test.db]/1024] [file size test.db-wal]
 774 } [list 1 [wal_file_size 5 1024]]
 775 do_test wal-12.2 {
 776   db close
 777   sqlite3 db test.db
 778   execsql {
 779     PRAGMA synchronous = normal;
 780     UPDATE t1 SET y = 0 WHERE x = 'A';
 781   }
 782   list [expr [file size test.db]/1024] [expr [file size test.db-wal]/1044]
 783 } {3 1}
 784 do_test wal-12.3 {
 785   execsql { INSERT INTO t2 VALUES('B', 1) }
 786   list [expr [file size test.db]/1024] [expr [file size test.db-wal]/1044]
 787 } {3 2}
 788 do_test wal-12.4 {
 789   file copy -force test.db test2.db
 790   file copy -force test.db-wal test2.db-wal
 791   sqlite3_wal db2 test2.db
 792   execsql { SELECT * FROM t2 } db2
 793 } {B 1}
 794 db2 close
 795 do_test wal-12.5 {
 796   execsql {
 797     PRAGMA wal_checkpoint;
 798     UPDATE t2 SET y = 2 WHERE x = 'B';
 799     PRAGMA wal_checkpoint;
 800     UPDATE t1 SET y = 1 WHERE x = 'A';
 801     PRAGMA wal_checkpoint;
 802     UPDATE t1 SET y = 0 WHERE x = 'A';
 803   }
 804   execsql {  SELECT * FROM t2 }
 805 } {B 2}
 806 do_test wal-12.6 {
 807   file copy -force test.db test2.db
 808   file copy -force test.db-wal test2.db-wal
 809   sqlite3_wal db2 test2.db
 810   execsql { SELECT * FROM t2 } db2
 811 } {B 2}
 812 db2 close
 813 db close
 814
 815 #-------------------------------------------------------------------------
 816 # Test large log summaries.
 817 #
 818 # In this case "large" usually means a log file that requires a wal-index
 819 # mapping larger than 64KB (the default initial allocation). A 64KB wal-index
 820 # is large enough for a log file that contains approximately 13100 frames.
 821 # So the following tests create logs containing at least this many frames.
 822 #
 823 # wal-13.1.*: This test case creates a very large log file within the
 824 #             file-system (around 200MB). The log file does not contain
 825 #             any valid frames. Test that the database file can still be
 826 #             opened and queried, and that the invalid log file causes no
 827 #             problems.
 828 #
 829 # wal-13.2.*: Test that a process may create a large log file and query
 830 #             the database (including the log file that it itself created).
 831 #
 832 # wal-13.3.*: Test that if a very large log file is created, and then a
 833 #             second connection is opened on the database file, it is possible
 834 #             to query the database (and the very large log) using the
 835 #             second connection.
 836 #
 837 # wal-13.4.*: Same test as wal-13.3.*. Except in this case the second
 838 #             connection is opened by an external process.
 839 #
 840 do_test wal-13.1.1 {
 841   list [file exists test.db] [file exists test.db-wal]
 842 } {1 0}
 843 do_test wal-13.1.2 {
 844   set fd [open test.db-wal w]
 845   seek $fd [expr 200*1024*1024]
 846   puts $fd ""
 847   close $fd
 848   sqlite3 db test.db
 849   execsql { SELECT * FROM t2 }
 850 } {B 2}
 851 breakpoint
 852 do_test wal-13.1.3 {
 853   db close
 854   file exists test.db-wal
 855 } {0}
 856
 857 do_test wal-13.2.1 {
 858   sqlite3 db test.db
 859   execsql { SELECT count(*) FROM t2 }
 860 } {1}
 861 do_test wal-13.2.2 {
 862   db function blob blob
 863   for {set i 0} {$i < 16} {incr i} {
 864     execsql { INSERT INTO t2 SELECT blob(400), blob(400) FROM t2 }
 865   }
 866   execsql { SELECT count(*) FROM t2 }
 867 } [expr int(pow(2, 16))]
 868 do_test wal-13.2.3 {
 869   expr [file size test.db-wal] > [wal_file_size 33000 1024]
 870 } 1
 871
 872 do_multiclient_test tn {
 873   incr tn 2
 874
 875   do_test wal-13.$tn.0 {
 876     sql1 {
 877       PRAGMA journal_mode = WAL;
 878       CREATE TABLE t1(x);
 879       INSERT INTO t1 SELECT randomblob(800);
 880     }
 881     sql1 { SELECT count(*) FROM t1 }
 882   } {1}
 883
 884   for {set ii 1} {$ii<16} {incr ii} {
 885     do_test wal-13.$tn.$ii.a {
 886       sql2 { INSERT INTO t1 SELECT randomblob(800) FROM t1 }
 887       sql2 { SELECT count(*) FROM t1 }
 888     } [expr (1<<$ii)]
 889     do_test wal-13.$tn.$ii.b {
 890       sql1 { SELECT count(*) FROM t1 }
 891     } [expr (1<<$ii)]
 892     do_test wal-13.$tn.$ii.c {
 893       sql1 { SELECT count(*) FROM t1 }
 894     } [expr (1<<$ii)]
 895     do_test wal-13.$tn.$ii.d {
 896       sql1 { PRAGMA integrity_check }
 897     } {ok}
 898   }
 899 }
 900
 901 #-------------------------------------------------------------------------
 902 # Check a fun corruption case has been fixed.
 903 #
 904 # The problem was that after performing a checkpoint using a connection
 905 # that had an out-of-date pager-cache, the next time the connection was
 906 # used it did not realize the cache was out-of-date and proceeded to
 907 # operate with an inconsistent cache. Leading to corruption.
 908 #
 909 catch { db close }
 910 catch { db2 close }
 911 catch { db3 close }
 912 file delete -force test.db test.db-wal
 913 sqlite3 db test.db
 914 sqlite3 db2 test.db
 915 do_test wal-14 {
 916   execsql {
 917     PRAGMA journal_mode = WAL;
 918     CREATE TABLE t1(a PRIMARY KEY, b);
 919     INSERT INTO t1 VALUES(randomblob(10), randomblob(100));
 920     INSERT INTO t1 SELECT randomblob(10), randomblob(100) FROM t1;
 921     INSERT INTO t1 SELECT randomblob(10), randomblob(100) FROM t1;
 922     INSERT INTO t1 SELECT randomblob(10), randomblob(100) FROM t1;
 923   }
 924
 925   db2 eval {
 926     INSERT INTO t1 SELECT randomblob(10), randomblob(100);
 927     INSERT INTO t1 SELECT randomblob(10), randomblob(100);
 928     INSERT INTO t1 SELECT randomblob(10), randomblob(100);
 929     INSERT INTO t1 SELECT randomblob(10), randomblob(100);
 930   }
 931
 932   # After executing the "PRAGMA wal_checkpoint", connection [db] was being
 933   # left with an inconsistent cache. Running the CREATE INDEX statement
 934   # in this state led to database corruption.
 935   catchsql {
 936     PRAGMA wal_checkpoint;
 937     CREATE INDEX i1 on t1(b);
 938   }
 939
 940   db2 eval { PRAGMA integrity_check }
 941 } {ok}
 942
 943 catch { db close }
 944 catch { db2 close }
 945
 946 #-------------------------------------------------------------------------
 947 # The following block of tests - wal-15.* - focus on testing the
 948 # implementation of the sqlite3_wal_checkpoint() interface.
 949 #
 950 file delete -force test.db test.db-wal
 951 sqlite3 db test.db
 952 do_test wal-15.1 {
 953   execsql {
 954     PRAGMA auto_vacuum = 0;
 955     PRAGMA page_size = 1024;
 956     PRAGMA journal_mode = WAL;
 957   }
 958   execsql {
 959     CREATE TABLE t1(a, b);
 960     INSERT INTO t1 VALUES(1, 2);
 961   }
 962 } {}
 963
 964 # Test that an error is returned if the database name is not recognized
 965 #
 966 do_test wal-15.2.1 {
 967   sqlite3_wal_checkpoint db aux
 968 } {SQLITE_ERROR}
 969 do_test wal-15.2.2 {
 970   sqlite3_errcode db
 971 } {SQLITE_ERROR}
 972 do_test wal-15.2.3 {
 973   sqlite3_errmsg db
 974 } {unknown database: aux}
 975
 976 # Test that an error is returned if an attempt is made to checkpoint
 977 # if a transaction is open on the database.
 978 #
 979 do_test wal-15.3.1 {
 980   execsql {
 981     BEGIN;
 982     INSERT INTO t1 VALUES(3, 4);
 983   }
 984   sqlite3_wal_checkpoint db main
 985 } {SQLITE_LOCKED}
 986 do_test wal-15.3.2 {
 987   sqlite3_errcode db
 988 } {SQLITE_LOCKED}
 989 do_test wal-15.3.3 {
 990   sqlite3_errmsg db
 991 } {database table is locked}
 992
 993 # Earlier versions returned an error is returned if the db cannot be
 994 # checkpointed because of locks held by another connection. Check that
 995 # this is no longer the case.
 996 #
 997 sqlite3 db2 test.db
 998 do_test wal-15.4.1 {
 999   execsql {
1000     BEGIN;
1001     SELECT * FROM t1;
1002   } db2
1003 } {1 2}
1004 do_test wal-15.4.2 {
1005   execsql { COMMIT }
1006   sqlite3_wal_checkpoint db
1007 } {SQLITE_OK}
1008 do_test wal-15.4.3 {
1009   sqlite3_errmsg db
1010 } {not an error}
1011
1012 # After [db2] drops its lock, [db] may checkpoint the db.
1013 #
1014 do_test wal-15.4.4 {
1015   execsql { COMMIT } db2
1016   sqlite3_wal_checkpoint db
1017 } {SQLITE_OK}
1018 do_test wal-15.4.5 {
1019   sqlite3_errmsg db
1020 } {not an error}
1021 do_test wal-15.4.6 {
1022   file size test.db
1023 } [expr 1024*2]
1024
1025 catch { db2 close }
1026 catch { db close }
1027
1028 #-------------------------------------------------------------------------
1029 # The following block of tests - wal-16.* - test that if a NULL pointer or
1030 # an empty string is passed as the second argument of the wal_checkpoint()
1031 # API, an attempt is made to checkpoint all attached databases.
1032 #
1033 foreach {tn ckpt_cmd ckpt_res ckpt_main ckpt_aux} {
1034   1 {sqlite3_wal_checkpoint db}              SQLITE_OK     1 1
1035   2 {sqlite3_wal_checkpoint db ""}           SQLITE_OK     1 1
1036   3 {db eval "PRAGMA wal_checkpoint"}        {0 10 10}     1 1
1037
1038   4 {sqlite3_wal_checkpoint db main}         SQLITE_OK     1 0
1039   5 {sqlite3_wal_checkpoint db aux}          SQLITE_OK     0 1
1040   6 {sqlite3_wal_checkpoint db temp}         SQLITE_OK     0 0
1041   7 {db eval "PRAGMA main.wal_checkpoint"}   {0 10 10}     1 0
1042   8 {db eval "PRAGMA aux.wal_checkpoint"}    {0 16 16}     0 1
1043   9 {db eval "PRAGMA temp.wal_checkpoint"}   {0 -1 -1}     0 0
1044 } {
1045   do_test wal-16.$tn.1 {
1046     file delete -force test2.db test2.db-wal test2.db-journal
1047     file delete -force test.db test.db-wal test.db-journal
1048
1049     sqlite3 db test.db
1050     execsql {
1051       ATTACH 'test2.db' AS aux;
1052       PRAGMA main.auto_vacuum = 0;
1053       PRAGMA aux.auto_vacuum = 0;
1054       PRAGMA main.journal_mode = WAL;
1055       PRAGMA aux.journal_mode = WAL;
1056       PRAGMA synchronous = NORMAL;
1057     }
1058   } {wal wal}
1059
1060   do_test wal-16.$tn.2 {
1061     execsql {
1062       CREATE TABLE main.t1(a, b, PRIMARY KEY(a, b));
1063       CREATE TABLE aux.t2(a, b, PRIMARY KEY(a, b));
1064
1065       INSERT INTO t2 VALUES(1, randomblob(1000));
1066       INSERT INTO t2 VALUES(2, randomblob(1000));
1067       INSERT INTO t1 SELECT * FROM t2;
1068     }
1069
1070     list [file size test.db] [file size test.db-wal]
1071   } [list [expr 1*1024] [wal_file_size 10 1024]]
1072   do_test wal-16.$tn.3 {
1073     list [file size test2.db] [file size test2.db-wal]
1074   } [list [expr 1*1024] [wal_file_size 16 1024]]
1075
1076   do_test wal-16.$tn.4 [list eval $ckpt_cmd] $ckpt_res
1077
1078   do_test wal-16.$tn.5 {
1079     list [file size test.db] [file size test.db-wal]
1080   } [list [expr ($ckpt_main ? 7 : 1)*1024] [wal_file_size 10 1024]]
1081
1082   do_test wal-16.$tn.6 {
1083     list [file size test2.db] [file size test2.db-wal]
1084   } [list [expr ($ckpt_aux ? 7 : 1)*1024] [wal_file_size 16 1024]]
1085
1086   catch { db close }
1087 }
1088
1089 #-------------------------------------------------------------------------
1090 # The following tests - wal-17.* - attempt to verify that the correct
1091 # number of "padding" frames are appended to the log file when a transaction
1092 # is committed in synchronous=FULL mode.
1093 #
1094 # Do this by creating a database that uses 512 byte pages. Then writing
1095 # a transaction that modifies 171 pages. In synchronous=NORMAL mode, this
1096 # produces a log file of:
1097 #
1098 #   32 + (24+512)*171 = 90312 bytes.
1099 #
1100 # Slightly larger than 11*8192 = 90112 bytes.
1101 #
1102 # Run the test using various different sector-sizes. In each case, the
1103 # WAL code should write the 90300 bytes of log file containing the
1104 # transaction, then append as may frames as are required to extend the
1105 # log file so that no part of the next transaction will be written into
1106 # a disk-sector used by transaction just committed.
1107 #
1108 set old_pending_byte [sqlite3_test_control_pending_byte 0x10000000]
1109 catch { db close }
1110 foreach {tn sectorsize logsize} "
1111   1   128  [wal_file_size 172 512]
1112   2   256  [wal_file_size 172 512]
1113   3   512  [wal_file_size 172 512]
1114   4  1024  [wal_file_size 172 512]
1115   5  2048  [wal_file_size 172 512]
1116   6  4096  [wal_file_size 176 512]
1117   7  8192  [wal_file_size 184 512]
1118 " {
1119   file delete -force test.db test.db-wal test.db-journal
1120   sqlite3_simulate_device -sectorsize $sectorsize
1121   sqlite3 db test.db -vfs devsym
1122
1123   do_test wal-17.$tn.1 {
1124     execsql {
1125       PRAGMA auto_vacuum = 0;
1126       PRAGMA page_size = 512;
1127       PRAGMA journal_mode = WAL;
1128       PRAGMA synchronous = FULL;
1129     }
1130     execsql {
1131       BEGIN;
1132       CREATE TABLE t(x);
1133     }
1134     for {set i 0} {$i<166} {incr i} {
1135       execsql { INSERT INTO t VALUES(randomblob(400)) }
1136     }
1137     execsql COMMIT
1138
1139     file size test.db-wal
1140   } $logsize
1141
1142   do_test wal-17.$tn.2 {
1143     file size test.db
1144   } 512
1145
1146   do_test wal-17.$tn.3 {
1147     db close
1148     file size test.db
1149   } [expr 512*171]
1150 }
1151 sqlite3_test_control_pending_byte $old_pending_byte
1152
1153 #-------------------------------------------------------------------------
1154 # This test - wal-18.* - verifies a couple of specific conditions that
1155 # may be encountered while recovering a log file are handled correctly:
1156 #
1157 #   wal-18.1.* When the first 32-bits of a frame checksum is correct but
1158 #              the second 32-bits are false, and
1159 #
1160 #   wal-18.2.* When the page-size field that occurs at the start of a log
1161 #              file is a power of 2 greater than 16384 or smaller than 512.
1162 #
1163 file delete -force test.db test.db-wal test.db-journal
1164 do_test wal-18.0 {
1165   sqlite3 db test.db
1166   execsql {
1167     PRAGMA page_size = 1024;
1168     PRAGMA auto_vacuum = 0;
1169     PRAGMA journal_mode = WAL;
1170     PRAGMA synchronous = OFF;
1171
1172     CREATE TABLE t1(a, b, UNIQUE(a, b));
1173     INSERT INTO t1 VALUES(0, 0);
1174     PRAGMA wal_checkpoint;
1175
1176     INSERT INTO t1 VALUES(1, 2);          -- frames 1 and 2
1177     INSERT INTO t1 VALUES(3, 4);          -- frames 3 and 4
1178     INSERT INTO t1 VALUES(5, 6);          -- frames 5 and 6
1179   }
1180
1181   file copy -force test.db testX.db
1182   file copy -force test.db-wal testX.db-wal
1183   db close
1184   list [file size testX.db] [file size testX.db-wal]
1185 } [list [expr 3*1024] [wal_file_size 6 1024]]
1186
1187 unset -nocomplain nFrame result
1188 foreach {nFrame result} {
1189          0      {0 0}
1190          1      {0 0}
1191          2      {0 0 1 2}
1192          3      {0 0 1 2}
1193          4      {0 0 1 2 3 4}
1194          5      {0 0 1 2 3 4}
1195          6      {0 0 1 2 3 4 5 6}
1196 } {
1197   do_test wal-18.1.$nFrame {
1198     file copy -force testX.db test.db
1199     file copy -force testX.db-wal test.db-wal
1200
1201     hexio_write test.db-wal [expr 24 + $nFrame*(24+1024) + 20] 00000000
1202
1203     sqlite3 db test.db
1204     execsql {
1205       SELECT * FROM t1;
1206       PRAGMA integrity_check;
1207     }
1208   } [concat $result ok]
1209   db close
1210 }
1211
1212 proc randomblob {pgsz} {
1213   sqlite3 rbdb :memory:
1214   set blob [rbdb one {SELECT randomblob($pgsz)}]
1215   rbdb close
1216   set blob
1217 }
1218
1219 proc logcksum {ckv1 ckv2 blob} {
1220   upvar $ckv1 c1
1221   upvar $ckv2 c2
1222
1223   set scanpattern I*
1224   if {$::tcl_platform(byteOrder) eq "littleEndian"} {
1225     set scanpattern i*
1226   }
1227
1228   binary scan $blob $scanpattern values
1229   foreach {v1 v2} $values {
1230     set c1 [expr {($c1 + $v1 + $c2)&0xFFFFFFFF}]
1231     set c2 [expr {($c2 + $v2 + $c1)&0xFFFFFFFF}]
1232   }
1233 }
1234
1235 file copy -force test.db testX.db
1236 foreach {tn pgsz works} {
1237   1    128    0
1238   2    256    0
1239   3    512    1
1240   4   1024    1
1241   5   2048    1
1242   6   4096    1
1243   7   8192    1
1244   8  16384    1
1245   9  32768    1
1246  10  65536    1
1247  11 131072    0
1248  11   1016    0
1249 } {
1250
1251   if {$::SQLITE_MAX_PAGE_SIZE < $pgsz} {
1252     set works 0
1253   }
1254
1255   for {set pg 1} {$pg <= 3} {incr pg} {
1256     file copy -force testX.db test.db
1257     file delete -force test.db-wal
1258
1259     # Check that the database now exists and consists of three pages. And
1260     # that there is no associated wal file.
1261     #
1262     do_test wal-18.2.$tn.$pg.1 { file exists test.db-wal } 0
1263     do_test wal-18.2.$tn.$pg.2 { file exists test.db } 1
1264     do_test wal-18.2.$tn.$pg.3 { file size test.db } [expr 1024*3]
1265
1266     do_test wal-18.2.$tn.$pg.4 {
1267
1268       # Create a wal file that contains a single frame (database page
1269       # number $pg) with the commit flag set. The frame checksum is
1270       # correct, but the contents of the database page are corrupt.
1271       #
1272       # The page-size in the log file header is set to $pgsz. If the
1273       # WAL code considers $pgsz to be a valid SQLite database file page-size,
1274       # the database will be corrupt (because the garbage frame contents
1275       # will be treated as valid content). If $pgsz is invalid (too small
1276       # or too large), the db will not be corrupt as the log file will
1277       # be ignored.
1278       #
1279       set walhdr [binary format IIIIII 931071618 3007000 $pgsz 1234 22 23]
1280       set framebody [randomblob $pgsz]
1281       set framehdr  [binary format IIII $pg 5 22 23]
1282       set c1 0
1283       set c2 0
1284       logcksum c1 c2 $walhdr
1285
1286       append walhdr [binary format II $c1 $c2]
1287       logcksum c1 c2 [string range $framehdr 0 7]
1288       logcksum c1 c2 $framebody
1289       set framehdr [binary format IIIIII $pg 5 22 23 $c1 $c2]
1290
1291       set fd [open test.db-wal w]
1292       fconfigure $fd -encoding binary -translation binary
1293       puts -nonewline $fd $walhdr
1294       puts -nonewline $fd $framehdr
1295       puts -nonewline $fd $framebody
1296       close $fd
1297
1298       file size test.db-wal
1299     } [wal_file_size 1 $pgsz]
1300
1301     do_test wal-18.2.$tn.$pg.5 {
1302       sqlite3 db test.db
1303       set rc [catch { db one {PRAGMA integrity_check} } msg]
1304       expr { $rc!=0 || $msg!="ok" }
1305     } $works
1306
1307     db close
1308   }
1309 }
1310
1311 #-------------------------------------------------------------------------
1312 # The following test - wal-19.* - fixes a bug that was present during
1313 # development.
1314 #
1315 # When a database connection in WAL mode is closed, it attempts an
1316 # EXCLUSIVE lock on the database file. If the lock is obtained, the
1317 # connection knows that it is the last connection to disconnect from
1318 # the database, so it runs a checkpoint operation. The bug was that
1319 # the connection was not updating its private copy of the wal-index
1320 # header before doing so, meaning that it could checkpoint an old
1321 # snapshot.
1322 #
1323 do_test wal-19.1 {
1324   file delete -force test.db test.db-wal test.db-journal
1325   sqlite3 db test.db
1326   sqlite3 db2 test.db
1327   execsql {
1328     PRAGMA journal_mode = WAL;
1329     CREATE TABLE t1(a, b);
1330     INSERT INTO t1 VALUES(1, 2);
1331     INSERT INTO t1 VALUES(3, 4);
1332   }
1333   execsql { SELECT * FROM t1 } db2
1334 } {1 2 3 4}
1335 do_test wal-19.2 {
1336   execsql {
1337     INSERT INTO t1 VALUES(5, 6);
1338     SELECT * FROM t1;
1339   }
1340 } {1 2 3 4 5 6}
1341 do_test wal-19.3 {
1342   db close
1343   db2 close
1344   file exists test.db-wal
1345 } {0}
1346 do_test wal-19.4 {
1347   # When the bug was present, the following was returning {1 2 3 4} only,
1348   # as [db2] had an out-of-date copy of the wal-index header when it was
1349   # closed.
1350   #
1351   sqlite3 db test.db
1352   execsql { SELECT * FROM t1 }
1353 } {1 2 3 4 5 6}
1354
1355 #-------------------------------------------------------------------------
1356 # This test - wal-20.* - uses two connections. One in this process and
1357 # the other in an external process. The procedure is:
1358 #
1359 #   1. Using connection 1, create the database schema.
1360 #
1361 #   2. Using connection 2 (in an external process), add so much
1362 #      data to the database without checkpointing that a wal-index
1363 #      larger than 64KB is required.
1364 #
1365 #   3. Using connection 1, checkpoint the database. Make sure all
1366 #      the data is present and the database is not corrupt.
1367 #
1368 # At one point, SQLite was failing to grow the mapping of the wal-index
1369 # file in step 3 and the checkpoint was corrupting the database file.
1370 #
1371 do_test wal-20.1 {
1372   catch {db close}
1373   file delete -force test.db test.db-wal test.db-journal
1374   sqlite3 db test.db
1375   execsql {
1376     PRAGMA journal_mode = WAL;
1377     CREATE TABLE t1(x);
1378     INSERT INTO t1 VALUES(randomblob(900));
1379     SELECT count(*) FROM t1;
1380   }
1381 } {wal 1}
1382 do_test wal-20.2 {
1383   set ::buddy [launch_testfixture]
1384   testfixture $::buddy {
1385     sqlite3 db test.db
1386     db transaction { db eval {
1387       PRAGMA wal_autocheckpoint = 0;
1388       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 2 */
1389       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 4 */
1390       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 8 */
1391       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 16 */
1392       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 32 */
1393       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 64 */
1394       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 128 */
1395       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 256 */
1396       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 512 */
1397       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 1024 */
1398       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 2048 */
1399       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 4096 */
1400       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 8192 */
1401       INSERT INTO t1 SELECT randomblob(900) FROM t1;       /* 16384 */
1402     } }
1403   }
1404 } {0}
1405 do_test wal-20.3 {
1406   close $::buddy
1407   execsql { PRAGMA wal_checkpoint }
1408   execsql { SELECT count(*) FROM t1 }
1409 } {16384}
1410 do_test wal-20.4 {
1411   db close
1412   sqlite3 db test.db
1413   execsql { SELECT count(*) FROM t1 }
1414 } {16384}
1415 integrity_check wal-20.5
1416
1417 catch { db2 close }
1418 catch { db close }
1419
1420 do_test wal-21.1 {
1421   faultsim_delete_and_reopen
1422   execsql {
1423     PRAGMA journal_mode = WAL;
1424     CREATE TABLE t1(a, b);
1425     INSERT INTO t1 VALUES(1, 2);
1426     INSERT INTO t1 VALUES(3, 4);
1427     INSERT INTO t1 VALUES(5, 6);
1428     INSERT INTO t1 VALUES(7, 8);
1429     INSERT INTO t1 VALUES(9, 10);
1430     INSERT INTO t1 VALUES(11, 12);
1431   }
1432 } {wal}
1433 do_test wal-21.2 {
1434   execsql {
1435     PRAGMA cache_size = 10;
1436     PRAGMA wal_checkpoint;
1437     BEGIN;
1438       SAVEPOINT s;
1439         INSERT INTO t1 SELECT randomblob(900), randomblob(900) FROM t1;
1440       ROLLBACK TO s;
1441     COMMIT;
1442   }
1443   execsql { SELECT * FROM t1 }
1444 } {1 2 3 4 5 6 7 8 9 10 11 12}
1445 do_test wal-21.3 {
1446   execsql { PRAGMA integrity_check }
1447 } {ok}
1448
1449 #-------------------------------------------------------------------------
1450 # Test reading and writing of databases with different page-sizes.
1451 #
1452 foreach pgsz {512 1024 2048 4096 8192 16384 32768 65536} {
1453   do_multiclient_test tn [string map [list %PGSZ% $pgsz] {
1454     do_test wal-22.%PGSZ%.$tn.1 {
1455       sql1 {
1456         PRAGMA main.page_size = %PGSZ%;
1457         PRAGMA auto_vacuum = 0;
1458         PRAGMA journal_mode = WAL;
1459         CREATE TABLE t1(x UNIQUE);
1460         INSERT INTO t1 SELECT randomblob(800);
1461         INSERT INTO t1 SELECT randomblob(800);
1462         INSERT INTO t1 SELECT randomblob(800);
1463       }
1464     } {wal}
1465     do_test wal-22.%PGSZ%.$tn.2 { sql2 { PRAGMA integrity_check } } {ok}
1466     do_test wal-22.%PGSZ%.$tn.3 {
1467       sql1 {PRAGMA wal_checkpoint}
1468       expr {[file size test.db] % %PGSZ%}
1469     } {0}
1470   }]
1471 }
1472
1473 #-------------------------------------------------------------------------
1474 # Test that when 1 or more pages are recovered from a WAL file,
1475 # sqlite3_log() is invoked to report this to the user.
1476 #
1477 set walfile [file nativename [file join [pwd] test.db-wal]]
1478 catch {db close}
1479 file delete -force test.db
1480 do_test wal-23.1 {
1481   faultsim_delete_and_reopen
1482   execsql {
1483     CREATE TABLE t1(a, b);
1484     PRAGMA journal_mode = WAL;
1485     INSERT INTO t1 VALUES(1, 2);
1486     INSERT INTO t1 VALUES(3, 4);
1487   }
1488   faultsim_save_and_close
1489
1490   sqlite3_shutdown
1491   test_sqlite3_log [list lappend ::log]
1492   set ::log [list]
1493   sqlite3 db test.db
1494   execsql { SELECT * FROM t1 }
1495 } {1 2 3 4}
1496 do_test wal-23.2 { set ::log } {}
1497
1498 do_test wal-23.3 {
1499   db close
1500   set ::log [list]
1501   faultsim_restore_and_reopen
1502   execsql { SELECT * FROM t1 }
1503 } {1 2 3 4}
1504 set nPage [expr 2+$AUTOVACUUM]
1505 do_test wal-23.4 {
1506   set ::log
1507 } [list SQLITE_OK "Recovered $nPage frames from WAL file $walfile"]
1508
1509
1510 ifcapable autovacuum {
1511   # This block tests that if the size of a database is reduced by a
1512   # transaction (because of an incremental or auto-vacuum), that no
1513   # data is written to the WAL file for the truncated pages as part
1514   # of the commit. e.g. if a transaction reduces the size of a database
1515   # to N pages, data for page N+1 should not be written to the WAL file
1516   # when committing the transaction. At one point such data was being
1517   # written.
1518   #
1519   catch {db close}
1520   forcedelete test.db
1521   sqlite3 db test.db
1522   do_execsql_test 24.1 {
1523     PRAGMA auto_vacuum = 2;
1524     PRAGMA journal_mode = WAL;
1525     PRAGMA page_size = 1024;
1526     CREATE TABLE t1(x);
1527     INSERT INTO t1 VALUES(randomblob(5000));
1528     INSERT INTO t1 SELECT * FROM t1;
1529     INSERT INTO t1 SELECT * FROM t1;
1530     INSERT INTO t1 SELECT * FROM t1;
1531     INSERT INTO t1 SELECT * FROM t1;
1532   } {wal}
1533   do_test 24.2 {
1534     execsql {
1535       DELETE FROM t1;
1536       PRAGMA wal_checkpoint;
1537     }
1538     db close
1539     sqlite3 db test.db
1540     file exists test.db-wal
1541   } 0
1542   do_test 24.3 {
1543     file size test.db
1544   } [expr 84 * 1024]
1545   do_test 24.4 {
1546     execsql {
1547       PRAGMA cache_size = 200;
1548       PRAGMA incremental_vacuum;
1549       PRAGMA wal_checkpoint;
1550     }
1551     file size test.db
1552   } [expr 3 * 1024]
1553   do_test 24.5 {
1554     file size test.db-wal
1555   } 2128
1556 }
1557
1558 db close
1559 sqlite3_shutdown
1560 test_sqlite3_log
1561 sqlite3_initialize
1562
1563 finish_test