diff --git a/Makefile.msc b/Makefile.msc
index 220367810c..ee71956ad7 100644
--- a/Makefile.msc
+++ b/Makefile.msc
@@ -1578,6 +1578,7 @@ TESTEXT = \
   $(TOP)\ext\misc\amatch.c \
   $(TOP)\ext\misc\appendvfs.c \
   $(TOP)\ext\misc\basexx.c \
+  $(TOP)\ext\misc\bgckpt.c \
   $(TOP)\ext\misc\cksumvfs.c \
   $(TOP)\ext\misc\closure.c \
   $(TOP)\ext\misc\csv.c \
diff --git a/autosetup/teaish/core.tcl b/autosetup/teaish/core.tcl
index c9abfa0626..381597ec56 100644
--- a/autosetup/teaish/core.tcl
+++ b/autosetup/teaish/core.tcl
@@ -92,7 +92,6 @@ array set teaish__Config [proj-strip-hash-comments {
     -tm.tcl.in       TEAISH_TM_TCL_IN
     -options         {}
     -pragmas         {}
-    -src             {}
   }
 
   #
@@ -220,9 +219,7 @@ proc teaish-configure-core {} {
       => {Full pathname of tclsh to use.  It is used for trying to find
           tclConfig.sh.  Warning: if its containing dir has multiple tclsh
           versions, it may select the wrong tclConfig.sh!
-        Defaults to the $TCLSH environment variable.}
-
-    tcl-stubs=0 => {Enable use of Tcl stubs library.}
+          Defaults to the $TCLSH environment variable.}
 
     # TEA has --with-tclinclude but it appears to only be useful for
     # building an extension against an uninstalled copy of TCL's own
@@ -334,33 +331,29 @@ proc teaish-configure-core {} {
       -url              -       -v ""
       -tm.tcl           -       -v ""
       -tm.tcl.in        -       -v ""
-      -src              -       -v ""
     } {
-      #proj-assert 0 {Just testing}
       set isPIFlag [expr {"-" ne $pflag}]
       if {$isPIFlag} {
         if {[info exists ::teaish__PkgInfo($pflag)]} {
           # Was already set - skip it.
           continue;
         }
-        proj-assert {{-} eq $key};# "Unexpected pflag=$pflag key=$key type=$type val=$val"
+        proj-assert {{-} eq $key}
         set key $f2d($pflag)
       }
-      if {"" ne $key} {
-        if {"<nope>" ne [get-define $key "<nope>"]} {
-          # Was already set - skip it.
-          continue
-        }
+      proj-assert {"" ne $key}
+      set got [get-define $key "<nope>"]
+      if {"<nope>" ne $got} {
+        # Was already set - skip it.
+        continue
       }
       switch -exact -- $type {
         -v {}
         -e { set val [eval $val] }
         default { proj-error "Invalid type flag: $type" }
       }
-      #puts "***** defining default $pflag $key {$val} isPIFlag=$isPIFlag"
-      if {$key ne ""} {
-        define $key $val
-      }
+      #puts "***** defining default $pflag $key {$val} isPIFlag=$isPIFlag got=$got"
+      define $key $val
       if {$isPIFlag} {
         set ::teaish__PkgInfo($pflag) $val
       }
@@ -500,8 +493,6 @@ proc teaish__configure_phase1 {} {
   }
   teaish-checks-run -post
 
-  define TEAISH_USE_STUBS [opt-bool tcl-stubs]
-
   apply {{} {
     # Set up "vsatisfies" code for pkgIndex.tcl.in,
     # _teaish.tester.tcl.in, and for a configure-time check.  We would
@@ -531,7 +522,7 @@ proc teaish__configure_phase1 {} {
         set vputs "puts \[ $vsat \]"
         #puts "*** vputs = $vputs"
         scan [exec echo $vputs | $tclsh] %d vvcheck
-        if {![info exists vvcheck] || 0 == $vvcheck} {
+        if {0 == $vvcheck} {
           proj-fatal -up $tclsh "check failed:" $vsat
         }
       }
@@ -594,8 +585,7 @@ proc teaish__configure_phase1 {} {
   #
   if {0x0f & $::teaish__Config(pkginit-policy)} {
     file delete -force -- [get-define TEAISH_PKGINIT_TCL]
-    proj-dot-ins-append [get-define TEAISH_PKGINIT_TCL_IN] \
-      [get-define TEAISH_PKGINIT_TCL]
+    proj-dot-ins-append [get-define TEAISH_PKGINIT_TCL_IN]
   }
   if {0x0f & $::teaish__Config(tm-policy)} {
     file delete -force -- [get-define TEAISH_TM_TCL]
@@ -605,20 +595,17 @@ proc teaish__configure_phase1 {} {
   apply {{} {
     # Queue up any remaining dot-in files
     set dotIns [list]
-    foreach {dIn => dOut} {
-      TEAISH_TESTER_TCL_IN => TEAISH_TESTER_TCL
-      TEAISH_TEST_TCL_IN   => TEAISH_TEST_TCL
-      TEAISH_MAKEFILE_IN   => TEAISH_MAKEFILE
+    foreach d {
+      TEAISH_TESTER_TCL_IN
+      TEAISH_TEST_TCL_IN
+      TEAISH_MAKEFILE_IN
     } {
-      lappend dotIns [get-define $dIn ""] [get-define $dOut ""]
-    }
-    lappend dotIns $::autosetup(srcdir)/Makefile.in Makefile; # must be after TEAISH_MAKEFILE_IN.
-    # Much later: probably because of timestamps for deps purposes :-?
-    #puts "dotIns=$dotIns"
-    foreach {i o} $dotIns {
-      if {"" ne $i && "" ne $o} {
-        #puts " pre-dot-ins-append:  \[$i\] -> \[$o\]"
-        proj-dot-ins-append $i $o
+      lappend dotIns [get-define $d ""]
+    }
+    lappend dotIns $::autosetup(srcdir)/Makefile.in; # must be after TEAISH_MAKEFILE_IN
+    foreach f $dotIns {
+      if {"" ne $f} {
+        proj-dot-ins-append $f
       }
     }
   }}
@@ -653,10 +640,10 @@ proc teaish__configure_phase1 {} {
   #
   # NO [define]s after this point!
   #
+  proj-dot-ins-process -validate
   proj-if-opt-truthy teaish-dump-defines {
     proj-file-write config.defines.txt $tdefs
   }
-  proj-dot-ins-process -validate
 
 }; # teaish__configure_phase1
 
@@ -830,9 +817,7 @@ proc teaish__check_tcl {} {
       if {"" ne $withSh &&
           [catch {exec echo "puts stdout \$auto_path" | "$withSh"} result] == 0} {
         foreach i $result {
-          if {![string match //zip* $i] && [file isdirectory $i]} {
-            # isdirectory actually passes on //zipfs:/..., but those are
-            # useless for our purposes
+          if {[file isdirectory $i]} {
             set tcllibdir $i/$extDirName
             break
           }
@@ -1081,7 +1066,7 @@ If you are attempting an out-of-tree build, use
          ]]} {
     if {[string match *.in $extM]} {
       define TEAISH_MAKEFILE_IN $extM
-      define TEAISH_MAKEFILE _[file rootname [file tail $extM]]
+      define TEAISH_MAKEFILE [file rootname [file tail $extM]]
     } else {
       define TEAISH_MAKEFILE_IN ""
       define TEAISH_MAKEFILE $extM
@@ -1149,8 +1134,8 @@ If you are attempting an out-of-tree build, use
   set flist [list $dirExt/teaish.test.tcl.in $dirExt/teaish.test.tcl]
   if {[proj-first-file-found ttt $flist]} {
     if {[string match *.in $ttt]} {
-      # Generate _teaish.test.tcl from $ttt
-      set xt _[file rootname [file tail $ttt]]
+      # Generate teaish.test.tcl from $ttt
+      set xt [file rootname [file tail $ttt]]
       file delete -force -- $xt; # ensure no stale copy is used
       define TEAISH_TEST_TCL $xt
       define TEAISH_TEST_TCL_IN $ttt
@@ -1317,6 +1302,7 @@ proc teaish-ldflags-prepend {args} {
 # object files (which are typically in the build tree)).
 #
 proc teaish-src-add {args} {
+  set i 0
   proj-parse-simple-flags args flags {
     -dist 0 {expr 1}
     -dir  0 {expr 1}
@@ -1401,7 +1387,7 @@ proc teaish__cleanup_rule {{tgt clean}} {
   return ${tgt}-_${x}_
 }
 
-# @teaish-make-obj ?flags? ?...args?
+# @teaish-make-obj objfile srcfile ?...args?
 #
 # Uses teaish-make-add to inject makefile rules for $objfile from
 # $srcfile, which is assumed to be C code which uses libtcl. Unless
@@ -1415,45 +1401,43 @@ proc teaish__cleanup_rule {{tgt clean}} {
 # Any arguments after the 2nd may be flags described below or, if no
 # -recipe is provided, flags for the compiler call.
 #
-#   -obj obj-filename.o
-#
-#   -src src-filename.c
-#
 #   -recipe {...}
 #   Uses the trimmed value of {...} as the recipe, prefixing it with
 #   a single hard-tab character.
 #
 #   -deps {...}
-#   List of extra files to list as dependencies of $o.
+#   List of extra files to list as dependencies of $o. Good luck
+#   escaping non-trivial cases properly.
 #
 #   -clean
 #   Generate cleanup rules as well.
-proc teaish-make-obj {args} {
-  proj-parse-simple-flags args flags {
-    -clean 0 {expr 1}
-    -recipe => {}
-    -deps => {}
-    -obj => {}
-    -src => {}
-  }
-  #parray flags
-  if {"" eq $flags(-obj)} {
-    set args [lassign $args flags(-obj)]
-    if {"" eq $flags(-obj)} {
-      proj-error "Missing -obj flag."
+proc teaish-make-obj {o src args} {
+  set consume 0
+  set clean 0
+  set flag ""
+  array set flags {}
+  set xargs {}
+  foreach arg $args {
+    if {$consume} {
+      set consume 0
+      set flags($flag) $arg
+      continue
+    }
+    switch -exact -- $arg {
+      -clean {incr clean}
+      -recipe -
+      -deps {
+        set flag $arg
+        incr consume
+      }
+      default {
+        lappend xargs $arg
+      }
     }
   }
-  foreach f {-deps -src} {
-    set flags($f) [string trim [string map {\n " "} $flags($f)]]
-  }
-  foreach f {-deps -src} {
-    set flags($f) [string trim $flags($f)]
-  }
-  #parray flags
-  #puts "-- args=$args"
   teaish-make-add \
-    "# [proj-scope 1] -> [proj-scope] $flags(-obj) $flags(-src)" -nl \
-    "$flags(-obj): $flags(-src) $::teaish__Config(teaish.tcl)"
+    "# [proj-scope 1] -> [proj-scope] $o $src" -nl \
+    "$o: $src $::teaish__Config(teaish.tcl)"
   if {[info exists flags(-deps)]} {
     teaish-make-add " " [join $flags(-deps)]
   }
@@ -1461,12 +1445,12 @@ proc teaish-make-obj {args} {
   if {[info exists flags(-recipe)]} {
     teaish-make-add [string trim $flags(-recipe)] -nl
   } else {
-    teaish-make-add [join [list \$(CC.tcl) -c $flags(-src) {*}$args]] -nl
+    teaish-make-add [join [list \$(CC.tcl) -c $src {*}$xargs]] -nl
   }
-  if {$flags(-clean)} {
+  if {$clean} {
     set rule [teaish__cleanup_rule]
     teaish-make-add \
-      "clean: $rule\n$rule:\n\trm -f \"$flags(-obj)\"\n"
+      "clean: $rule\n$rule:\n\trm -f \"$o\"\n"
   }
 }
 
@@ -2094,17 +2078,6 @@ proc teaish-pkginfo-set {args} {
         set v $x
       }
 
-      -src {
-        set d $::teaish__Config(extension-dir)
-        foreach f $v {
-          lappend ::teaish__Config(dist-files) $f
-          lappend ::teaish__Config(extension-src) $d/$f
-          lappend ::teaish__PkgInfo(-src) $f
-          # ^^^ so that default-value initialization in
-          # teaish-configure-core recognizes that it's been set.
-        }
-      }
-
       -tm.tcl -
       -tm.tcl.in {
         if {0x30 & $::teaish__Config(pkgindex-policy)} {
@@ -2542,7 +2515,7 @@ proc teaish__install {{dDest ""}} {
                              ] {
     teaish__verbose 1 msg-result "Copying files to $destDir..."
     file mkdir $destDir
-    foreach f  [glob -nocomplain -directory $srcDir *] {
+    foreach f  [glob -directory $srcDir *] {
       if {[string match {*~} $f] || [string match "#*#" [file tail $f]]} {
         # Editor-generated backups and emacs lock files
         continue
diff --git a/autosetup/teaish/tester.tcl b/autosetup/teaish/tester.tcl
index a25b366e8d..d8b5f7a0e8 100644
--- a/autosetup/teaish/tester.tcl
+++ b/autosetup/teaish/tester.tcl
@@ -99,7 +99,7 @@ proc test__affert {failMode args} {
     lassign $args script msg
   }
   incr ::test__Counters($what)
-  if {![uplevel 1 expr [list $script]]} {
+  if {![uplevel 1 [concat expr [list $script]]]} {
     if {"" eq $msg} {
       set msg $script
     }
@@ -136,40 +136,6 @@ proc assert {args} {
   tailcall test__affert 1 {*}$args
 }
 
-#
-# @assert-matches ?-e? pattern ?-e? rhs ?msg?
-#
-# Equivalent to assert {[string match $pattern $rhs]} except that
-# if either of those are prefixed with an -e flag, they are eval'd
-# and their results are used.
-#
-proc assert-matches {args} {
-  set evalLhs 0
-  set evalRhs 0
-  if {"-e" eq [lindex $args 0]} {
-    incr evalLhs
-    set args [lassign $args -]
-  }
-  set args [lassign $args pattern]
-  if {"-e" eq [lindex $args 0]} {
-    incr evalRhs
-    set args [lassign $args -]
-  }
-  set args [lassign $args rhs msg]
-
-  if {$evalLhs} {
-    set pattern [uplevel 1 $pattern]
-  }
-  if {$evalRhs} {
-    set rhs [uplevel 1 $rhs]
-  }
-  #puts "***pattern=$pattern\n***rhs=$rhs"
-  tailcall test__affert 1 \
-    [join [list \[ string match [list $pattern] [list $rhs] \]]] $msg
-  # why does this not work? [list \[ string match [list $pattern] [list $rhs] \]] $msg
-  # "\[string match [list $pattern] [list $rhs]\]"
-}
-
 #
 # @test-assert testId script ?msg?
 #
@@ -191,7 +157,7 @@ proc test-expect {testId script result} {
   puts "test $testId"
   set x [string trim [uplevel 1 $script]]
   set result [string trim $result]
-  tailcall test__affert 0 [list "{$x}" eq "{$result}"] \
+  tailcall test__affert 0 [list $x eq $result] \
     "\nEXPECTED: <<$result>>\nGOT:      <<$x>>"
 }
 
@@ -203,7 +169,7 @@ proc test-expect {testId script result} {
 #
 proc test-catch {cmd args} {
   if {[catch {
-    uplevel 1 $cmd {*}$args
+    $cmd {*}$args
   } rc xopts]} {
     puts "[test-current-scope] ignoring failure of: $cmd [lindex $args 0]: $rc"
     return 1
@@ -211,37 +177,6 @@ proc test-catch {cmd args} {
   return 0
 }
 
-#
-# @test-catch-matching pattern (script|cmd args...)
-#
-# Works like test-catch, but it expects its argument(s) to to throw an
-# error matching the given string (checked with [string match]).  If
-# they do not throw, or the error does not match $pattern, this
-# function throws, else it returns 1.
-#
-# If there is no second argument, the $cmd is assumed to be a script,
-# and will be eval'd in the caller's scope.
-#
-# TODO: add -glob and -regex flags to control matching flavor.
-#
-proc test-catch-matching {pattern cmd args} {
-  if {[catch {
-    #puts "**** catch-matching cmd=$cmd args=$args"
-    if {0 == [llength $args]} {
-      uplevel 1 $cmd {*}$args
-    } else {
-      $cmd {*}$args
-    }
-  } rc xopts]} {
-    if {[string match $pattern $rc]} {
-      return 1
-    } else {
-      error "[test-current-scope] exception does not match {$pattern}: {$rc}"
-    }
-  }
-  error "[test-current-scope] expecting to see an error matching {$pattern}"
-}
-
 if {![array exists ::teaish__BuildFlags]} {
   array set ::teaish__BuildFlags {}
 }
diff --git a/doc/wal2.md b/doc/wal2.md
new file mode 100644
index 0000000000..5afd8ae606
--- /dev/null
+++ b/doc/wal2.md
@@ -0,0 +1,98 @@
+
+Wal2 Mode Notes
+===============
+
+## Activating/Deactivating Wal2 Mode
+
+"Wal2" mode is very similar to "wal" mode. To change a database to wal2 mode,
+use the command:
+
+>
+     PRAGMA journal_mode = wal2;
+
+It is not possible to change a database directly from "wal" mode to "wal2"
+mode. Instead, it must first be changed to rollback mode. So, to change a wal
+mode database to wal2 mode, the following two commands may be used:
+
+>
+     PRAGMA journal_mode = delete;
+     PRAGMA journal_mode = wal2;
+
+A database in wal2 mode may only be accessed by versions of SQLite compiled
+from this branch. Attempting to use any other version of SQLite results in an
+SQLITE&#95;NOTADB error. A wal2 mode database may be changed back to rollback mode
+(making it accessible by all versions of SQLite) using:
+
+>
+     PRAGMA journal_mode = delete;
+
+## The Advantage of Wal2 Mode
+
+In legacy wal mode, when a writer writes data to the database, it doesn't
+modify the database file directly. Instead, it appends new data to the
+"&lt;database>-wal" file. Readers read data from both the original database
+file and the "&lt;database>-wal" file. At some point, data is copied from the
+"&lt;database>-wal" file into the database file, after which the wal file can
+be deleted or overwritten. Copying data from the wal file into the database
+file is called a "checkpoint", and may be done explictly (either by "PRAGMA
+wal&#95;checkpoint" or sqlite3&#95;wal&#95;checkpoint&#95;v2()), or
+automatically (by configuring "PRAGMA wal&#95;autocheckpoint" - this is the
+default).
+
+Checkpointers do not block writers, and writers do not block checkpointers.
+However, if a writer writes to the database while a checkpoint is ongoing,
+then the new data is appended to the end of the wal file. This means that,
+even following the checkpoint, the wal file cannot be overwritten or deleted,
+and so all subsequent transactions must also be appended to the wal file. The
+work of the checkpointer is not wasted - SQLite remembers which parts of the
+wal file have already been copied into the db file so that the next checkpoint
+does not have to do so again - but it does mean that the wal file may grow
+indefinitely if the checkpointer never gets a chance to finish without a
+writer appending to the wal file. There are also circumstances in which
+long-running readers may prevent a checkpointer from checkpointing the entire
+wal file - also causing the wal file to grow indefinitely in a busy system.
+
+Wal2 mode does not have this problem. In wal2 mode, wal files do not grow
+indefinitely even if the checkpointer never has a chance to finish
+uninterrupted.
+
+In wal2 mode, the system uses two wal files instead of one. The files are named
+"&lt;database>-wal" and "&lt;database>-wal2", where "&lt;database>" is of
+course the name of the database file. When data is written to the database, the
+writer begins by appending the new data to the first wal file. Once the first
+wal file has grown large enough, writers switch to appending data to the second
+wal file. At this point the first wal file can be checkpointed (after which it
+can be overwritten). Then, once the second wal file has grown large enough and
+the first wal file has been checkpointed, writers switch back to the first wal
+file. And so on.
+
+## Application Programming
+
+From the point of view of the user, the main differences between wal and 
+wal2 mode are to do with checkpointing:
+
+  * In wal mode, a checkpoint may be attempted at any time. In wal2 
+    mode, the checkpointer has to wait until writers have switched 
+    to the "other" wal file before a checkpoint can take place.
+
+  * In wal mode, the wal-hook (callback registered using
+    sqlite3&#95;wal&#95;hook()) is invoked after a transaction is committed
+    with the total number of pages in the wal file as an argument. In wal2
+    mode, the argument is either the total number of uncheckpointed pages in
+    both wal files, or - if the "other" wal file is empty or already
+    checkpointed - 0.
+
+Clients are recommended to use the same strategies for checkpointing wal2 mode
+databases as for wal databases - by registering a wal-hook using
+sqlite3&#95;wal&#95;hook() and attempting a checkpoint when the parameter
+exceeds a certain threshold.
+
+However, it should be noted that although the wal-hook is invoked after each
+transaction is committed to disk and database locks released, it is still
+invoked from within the sqlite3&#95;step() call used to execute the "COMMIT"
+command. In BEGIN CONCURRENT systems, where the "COMMIT" is often protected by
+an application mutex, this may reduce concurrency. In such systems, instead of
+executing a checkpoint from within the wal-hook, a thread might defer this
+action until after the application mutex has been released.
+
+
diff --git a/ext/misc/bgckpt.c b/ext/misc/bgckpt.c
new file mode 100644
index 0000000000..cac3b84831
--- /dev/null
+++ b/ext/misc/bgckpt.c
@@ -0,0 +1,228 @@
+/*
+** 2017-10-11
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+*/
+
+#if !defined(SQLITE_TEST) || defined(SQLITE_OS_UNIX)
+
+#include "sqlite3.h"
+#include <string.h>
+#include <pthread.h>
+
+/*
+** API declarations.
+*/
+typedef struct Checkpointer Checkpointer;
+int sqlite3_bgckpt_create(const char *zFilename, Checkpointer **pp);
+int sqlite3_bgckpt_checkpoint(Checkpointer *p, int bBlock);
+void sqlite3_bgckpt_destroy(Checkpointer *p);
+
+
+struct Checkpointer {
+  sqlite3 *db;                    /* Database handle */
+
+  pthread_t thread;               /* Background thread */
+  pthread_mutex_t mutex;
+  pthread_cond_t cond;
+
+  int rc;                         /* Error from "PRAGMA wal_checkpoint" */
+  int bCkpt;                      /* True if checkpoint requested */
+  int bExit;                      /* True if exit requested */
+};
+
+static void *bgckptThreadMain(void *pCtx){
+  int rc = SQLITE_OK;
+  Checkpointer *p = (Checkpointer*)pCtx;
+
+  while( rc==SQLITE_OK ){
+    int bExit;
+
+    pthread_mutex_lock(&p->mutex);
+    if( p->bCkpt==0 && p->bExit==0 ){
+      pthread_cond_wait(&p->cond, &p->mutex);
+    }
+    p->bCkpt = 0;
+    bExit = p->bExit;
+    pthread_mutex_unlock(&p->mutex);
+
+    if( bExit ) break;
+    rc = sqlite3_exec(p->db, "PRAGMA wal_checkpoint", 0, 0, 0);
+    if( rc==SQLITE_BUSY ){
+      rc = SQLITE_OK;
+    }
+  }
+
+  pthread_mutex_lock(&p->mutex);
+  p->rc = rc;
+  pthread_mutex_unlock(&p->mutex);
+  return 0;
+}
+
+void sqlite3_bgckpt_destroy(Checkpointer *p){
+  if( p ){
+    void *ret = 0;
+
+    /* Signal the background thread to exit */
+    pthread_mutex_lock(&p->mutex);
+    p->bExit = 1;
+    pthread_cond_broadcast(&p->cond);
+    pthread_mutex_unlock(&p->mutex);
+
+    pthread_join(p->thread, &ret);
+    sqlite3_close(p->db);
+    sqlite3_free(p);
+  }
+}
+
+
+int sqlite3_bgckpt_create(const char *zFilename, Checkpointer **pp){
+  Checkpointer *pNew = 0;
+  int rc;
+
+  pNew = (Checkpointer*)sqlite3_malloc(sizeof(Checkpointer));
+  if( pNew==0 ){
+    rc = SQLITE_NOMEM;
+  }else{
+    memset(pNew, 0, sizeof(Checkpointer));
+    rc = sqlite3_open(zFilename, &pNew->db);
+  }
+
+  if( rc==SQLITE_OK ){
+    pthread_mutex_init(&pNew->mutex, 0);
+    pthread_cond_init(&pNew->cond, 0);
+    pthread_create(&pNew->thread, 0, bgckptThreadMain, (void*)pNew);
+  }
+
+  if( rc!=SQLITE_OK ){
+    sqlite3_bgckpt_destroy(pNew);
+    pNew = 0;
+  }
+  *pp = pNew;
+  return rc;
+}
+
+int sqlite3_bgckpt_checkpoint(Checkpointer *p, int bBlock){
+  int rc;
+  pthread_mutex_lock(&p->mutex);
+  rc = p->rc;
+  if( rc==SQLITE_OK ){
+    p->bCkpt = 1;
+    pthread_cond_broadcast(&p->cond);
+  }
+  pthread_mutex_unlock(&p->mutex);
+  return rc;
+}
+
+#ifdef SQLITE_TEST
+#include "tclsqlite.h"
+
+const char *sqlite3ErrName(int rc);
+
+static void SQLITE_TCLAPI bgckpt_del(void * clientData){
+  Checkpointer *pCkpt = (Checkpointer*)clientData;
+  sqlite3_bgckpt_destroy(pCkpt);
+}
+
+/*
+** Tclcmd: $ckpt SUBCMD ...
+*/
+static int SQLITE_TCLAPI bgckpt_obj_cmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  Checkpointer *pCkpt = (Checkpointer*)clientData;
+  const char *aCmd[] = { "checkpoint", "destroy", 0 };
+  int iCmd;
+
+  if( objc<2 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "SUBCMD ...");
+    return TCL_ERROR;
+  }
+
+  if( Tcl_GetIndexFromObj(interp, objv[1], aCmd, "sub-command", 0, &iCmd) ){
+    return TCL_ERROR;
+  }
+
+  switch( iCmd ){
+    case 0: {
+      int rc;
+      int bBlock = 0;
+
+      if( objc>3 ){
+        Tcl_WrongNumArgs(interp, 2, objv, "?BLOCKING?");
+        return TCL_ERROR;
+      }
+      if( objc==3 && Tcl_GetBooleanFromObj(interp, objv[2], &bBlock) ){
+        return TCL_ERROR;
+      }
+
+      rc = sqlite3_bgckpt_checkpoint(pCkpt, bBlock);
+      if( rc!=SQLITE_OK ){
+        Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
+        return TCL_ERROR;
+      }
+      break;
+    }
+
+    case 1: {
+      Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
+      break;
+    }
+  }
+
+  return TCL_OK;
+}
+
+/*
+** Tclcmd: bgckpt CMDNAME FILENAME
+*/
+static int SQLITE_TCLAPI bgckpt_cmd(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  const char *zCmd;
+  const char *zFilename;
+  int rc;
+  Checkpointer *pCkpt;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "CMDNAME FILENAME");
+    return TCL_ERROR;
+  }
+  zCmd = Tcl_GetString(objv[1]);
+  zFilename = Tcl_GetString(objv[2]);
+
+  rc = sqlite3_bgckpt_create(zFilename, &pCkpt);
+  if( rc!=SQLITE_OK ){
+    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
+    return TCL_ERROR;
+  }
+
+  Tcl_CreateObjCommand(interp, zCmd, bgckpt_obj_cmd, (void*)pCkpt, bgckpt_del);
+  Tcl_SetObjResult(interp, objv[1]);
+  return TCL_OK;
+}
+
+int Bgckpt_Init(Tcl_Interp *interp){
+  Tcl_CreateObjCommand(interp, "bgckpt", bgckpt_cmd, 0, 0);
+  return TCL_OK;
+}
+#endif   /* SQLITE_TEST */
+
+#else
+# include "tclsqlite.h"
+int Bgckpt_Init(Tcl_Interp *interp){ return TCL_OK; }
+#endif
diff --git a/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js b/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js
index 286db83bac..a3a86067d4 100644
--- a/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js
+++ b/ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js
@@ -49,36 +49,6 @@
   versions (approximately) 104-107 are extinct) we should change our
   usage of those methods to remove the "await".
 */
-//#if 0
-/**
-   2026-04-04: this file gets included by both the "opfs" and "opfs-wl"
-   VFSes. It would, in hindsight, hypothetically be possible to restructure
-   it very slightly to support both VFSes via a single Worker instance.
-
-   Some of the changes we would need for that:
-
-   - The xLock/xUnlock "op codes" would need to differ for each impl.
-   i.e. we'd need state.opIds.xLock{,WL} and state.opIds.xUnlock{,WL}
-   to distinguish between the two, rather than doing so when this Worker
-   is loaded.
-
-   - We would need to centralize loading of this Worker, outside of
-   the VFS-specific pieces, and change the handshake in order to be
-   able to distinguish between clients which support
-   Atomics.waitAsync() and those which do not ("opfs-wl" requires
-   waitAsync()).
-
-   One down-side would be for clients which, for whatever reason, want
-   to use both "opfs" and "opfs-wl" within the same session: because
-   both would go through the same Worker, any operations for one VFS
-   would, while they're being processed on this side of the proxy,
-   effectively block the other VFS from doing anything, potentially
-   deadlocking. This use case seems unlikely enough that it can
-   possibly be ruled out (or even reasonably flat-out prohibited by
-   the library).
-*/
-//#/if
-
 "use strict";
 const urlParams = new URL(globalThis.location.href).searchParams;
 const vfsName = urlParams.get('vfs');
@@ -112,7 +82,7 @@ const installAsyncProxy = function(){
      copies in the synchronous and async halves. This side does not
      load the SQLite library, so does not have access to that copy. */
 //#define opfs-async-proxy
-//#include "api/opfs-common-inline.c-pp.js"
+//#include api/opfs-common-inline.c-pp.js
 //#undef opfs-async-proxy
 
   /**
@@ -708,9 +678,9 @@ const installAsyncProxy = function(){
       const lockName = "sqlite3-vfs-opfs:" + fh.filenameAbs;
       const oldLockType = fh.xLock;
       return new Promise((resolveWaitLoop) => {
-        //log("xLock() initial promise entered...");
+        //error("xLock() initial promise entered...");
         navigator.locks.request(lockName, { mode: requestedMode }, async (lock) => {
-          //log("xLock() Web Lock entered.", fh);
+          //error("xLock() Web Lock entered.", fh);
           __implicitLocks.delete(fid);
           let rc = 0;
           try{
@@ -756,7 +726,7 @@ const installAsyncProxy = function(){
         storeAndNotify('xUnlock', rc);
         return rc;
       }
-      //log("xUnlock()",fid, lockType, fh);
+      //error("xUnlock()",fid, lockType, fh);
       let rc = 0;
       if( lockType === state.sq3Codes.SQLITE_LOCK_NONE ){
         /* SQLite usually unlocks all the way to NONE */
@@ -766,7 +736,7 @@ const installAsyncProxy = function(){
         fh.xLock = lockType;
       }else if( lockType === state.sq3Codes.SQLITE_LOCK_SHARED
                 && existing.mode === 'exclusive' ){
-        /* downgrade EXCLUSIVE -> SHARED */
+        /* downgrade Exclusive -> Shared */
         rc = await wlCloseHandle(fh);
         if( 0===rc ){
           fh.xLock = lockType;
@@ -912,6 +882,16 @@ const installAsyncProxy = function(){
                   operation */
         ) || [];
         //error("waitLoop() whichOp =",opId, f.opHandlers[opId].key, args);
+//#if 0
+        if( isWebLocker && (opId==opIds.xLock || opIds==opIds.xUnlock) ){
+          /* An expert suggests that this introduces a race condition,
+             but my eyes aren't seeing it. The hope was that this
+             would improve the lock speed a tick, but it does not
+             appear to. */
+          hnd(...args);
+          continue;
+        }
+//#/if
         await hnd(...args);
       }catch(e){
         error('in waitLoop():', e);
diff --git a/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js b/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js
index bcbf3fa9f8..55e497ead5 100644
--- a/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js
+++ b/ext/wasm/api/sqlite3-worker1-promiser.c-pp.js
@@ -1,4 +1,4 @@
-//#if not omit-oo1
+//#ifnot omit-oo1
 /*
   2022-08-24
 
@@ -19,12 +19,10 @@
   slightly simpler client-side interface than the slightly-lower-level
   Worker API does.
 
-  In non-ESM builds this file necessarily exposes one global symbol,
-  but clients may freely `delete` that symbol after calling it.
+  This script necessarily exposes one global symbol, but clients may
+  freely `delete` that symbol after calling it.
 */
-//#if not defined target:es6-module
 'use strict';
-//#/if
 /**
    Configures an sqlite3 Worker API #1 Worker such that it can be
    manipulated via a Promise-based interface and returns a factory
@@ -111,12 +109,10 @@
    the callback is called one time for each row of the result set,
    passed the same worker message format as the worker API emits:
 
-   {
-      type:typeString,
+     {type:typeString,
       row:VALUE,
       rowNumber:1-based-#,
-      columnNames: array
-   }
+      columnNames: array}
 
    Where `typeString` is an internally-synthesized message type string
    used temporarily for worker message dispatching. It can be ignored
@@ -127,16 +123,19 @@
    callback.
 
    At the end of the result set, the same event is fired with
-   (row=undefined, rowNumber=null) to indicate that the end of the
-   result set has been reached. The rows arrive via worker-posted
-   messages, with all the implications of that.
+   (row=undefined, rowNumber=null) to indicate that
+   the end of the result set has been reached. Note that the rows
+   arrive via worker-posted messages, with all the implications
+   of that.
 
    Notable shortcomings:
 
-   - "v1" of this this API is not suitable for use as an ESM module
-     because ESM worker modules were not widely supported when it was
-     developed. For use as an ESM module, see the "v2" interface later
-     on in this file.
+   - This API was not designed with ES6 modules in mind. Neither Firefox
+     nor Safari support, as of March 2023, the {type:"module"} flag to the
+     Worker constructor, so that particular usage is not something we're going
+     to target for the time being:
+
+     https://developer.mozilla.org/en-US/docs/Web/API/Worker/Worker
 */
 globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfig){
   // Inspired by: https://stackoverflow.com/a/52439530
@@ -255,14 +254,10 @@ globalThis.sqlite3Worker1Promiser = function callee(config = callee.defaultConfi
 
 globalThis.sqlite3Worker1Promiser.defaultConfig = {
   worker: function(){
-//#if target:es6-bundler-friendly
+//#if target=es6-module
     return new Worker(new URL("sqlite3-worker1-bundler-friendly.mjs", import.meta.url),{
       type: 'module'
     });
-//#elif target:es6-module
-    return new Worker(new URL("sqlite3-worker1.mjs", import.meta.url),{
-      type: 'module'
-    });
 //#else
     let theJs = "sqlite3-worker1.js";
     if(this.currentScript){
@@ -278,15 +273,15 @@ globalThis.sqlite3Worker1Promiser.defaultConfig = {
       }
     }
     return new Worker(theJs + globalThis.location.search);
-//#/if
+//#endif
   }
-//#if not target:es6-module
+//#ifnot target=es6-module
   .bind({
     currentScript: globalThis?.document?.currentScript
   })
-//#/if
+//#endif
   ,
-  onerror: (...args)=>console.error('sqlite3Worker1Promiser():',...args)
+  onerror: (...args)=>console.error('worker1 promiser error',...args)
 }/*defaultConfig*/;
 
 /**
@@ -301,7 +296,7 @@ globalThis.sqlite3Worker1Promiser.defaultConfig = {
    after calling the original function and will reject if that
    function throws.
 */
-globalThis.sqlite3Worker1Promiser.v2 = function callee(config = callee.defaultConfig){
+sqlite3Worker1Promiser.v2 = function(config){
   let oldFunc;
   if( 'function' == typeof config ){
     oldFunc = config;
@@ -331,25 +326,21 @@ globalThis.sqlite3Worker1Promiser.v2 = function callee(config = callee.defaultCo
   }
   return p;
 }.bind({
-   /* We do this because clients are recommended to delete
-      globalThis.sqlite3Worker1Promiser. */
+   /* We do this because clients are
+      recommended to delete globalThis.sqlite3Worker1Promiser. */
   original: sqlite3Worker1Promiser
 });
 
-globalThis.sqlite3Worker1Promiser.v2.defaultConfig =
-  globalThis.sqlite3Worker1Promiser.defaultConfig;
-
-//#if target:es6-module
+//#if target=es6-module
 /**
   When built as a module, we export sqlite3Worker1Promiser.v2()
   instead of sqlite3Worker1Promise() because (A) its interface is more
-  conventional for ESM usage and (B) the ESM export option for this
-  API did not exist until v2 was created, so there's no backwards
+  conventional for ESM usage and (B) the ESM option export option for
+  this API did not exist until v2 was created, so there's no backwards
   incompatibility.
 */
 export default sqlite3Worker1Promiser.v2;
-delete globalThis.sqlite3Worker1Promiser;
-//#/if /* target:es6-module */
+//#endif /* target=es6-module */
 //#else
 /* Built with the omit-oo1 flag. */
-//#/if if not omit-oo1
+//#endif ifnot omit-oo1
diff --git a/ext/wasm/demo-worker1-promiser.c-pp.html b/ext/wasm/demo-worker1-promiser.c-pp.html
index c54b46aadb..e0b487bdf3 100644
--- a/ext/wasm/demo-worker1-promiser.c-pp.html
+++ b/ext/wasm/demo-worker1-promiser.c-pp.html
@@ -6,11 +6,11 @@
     <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
     <link rel="stylesheet" href="common/emscripten.css"/>
     <link rel="stylesheet" href="common/testing.css"/>
-//#if target:es6-module
-    <title>Worker1-promiser (ESM) tests</title>
+//#if target=es6-module
+    <title>worker-promise (via ESM) tests</title>
 //#else
-    <title>Worker1-promiser tests</title>
-//#/if
+    <title>worker-promise tests</title>
+//#endif
   </head>
   <body>
     <header id='titlebar'><span>worker-promise tests</span></header>
@@ -32,11 +32,11 @@
     <hr>
     <div id='test-output'></div>
     <script src="common/SqliteTestUtil.js"></script>
-//#if target:es6-module
+//#if target=es6-module
     <script src="demo-worker1-promiser.mjs" type="module"></script>
 //#else
     <script src="jswasm/sqlite3-worker1-promiser.js"></script>
     <script src="demo-worker1-promiser.js"></script>
-//#/if
+//#endif
   </body>
 </html>
diff --git a/ext/wasm/demo-worker1-promiser.c-pp.js b/ext/wasm/demo-worker1-promiser.c-pp.js
index 1521edfc17..f6fc9568ae 100644
--- a/ext/wasm/demo-worker1-promiser.c-pp.js
+++ b/ext/wasm/demo-worker1-promiser.c-pp.js
@@ -13,13 +13,13 @@
   Demonstration of the sqlite3 Worker API #1 Promiser: a Promise-based
   proxy for for the sqlite3 Worker #1 API.
 */
-//#if target:es6-module
+//#if target=es6-module
 import {default as promiserFactory} from "./jswasm/sqlite3-worker1-promiser.mjs";
 //#else
 "use strict";
 const promiserFactory = globalThis.sqlite3Worker1Promiser.v2;
 delete globalThis.sqlite3Worker1Promiser;
-//#/if
+//#endif
 (async function(){
   const T = globalThis.SqliteTestUtil;
   const eOutput = document.querySelector('#test-output');
@@ -40,7 +40,7 @@ delete globalThis.sqlite3Worker1Promiser;
   };
 
   const promiserConfig = {
-//#if not target:es6-module
+//#ifnot target=es6-module
     /**
        The v1 interfaces uses an onready function. The v2 interface optionally
        accepts one but does not require it. If provided, it is called _before_
@@ -53,7 +53,7 @@ delete globalThis.sqlite3Worker1Promiser;
          before workerPromise is set. */
       console.warn("This is the v2 interface - you don't need an onready() function.");
     },
-//#/if
+//#endif
     debug: 1 ? undefined : (...args)=>console.debug('worker debug',...args),
     onunhandled: function(ev){
       error("Unhandled worker message:",ev.data);
@@ -115,7 +115,6 @@ delete globalThis.sqlite3Worker1Promiser;
             "insert into t(a,b) values(1,2),(3,4),(5,6)"
            ].join(';'),
       resultRows: [], columnNames: [],
-      lastInsertRowId: true,
       countChanges: sqConfig.bigIntEnabled ? 64 : true
     }, function(ev){
       ev = ev.result;
@@ -123,9 +122,7 @@ delete globalThis.sqlite3Worker1Promiser;
         .assert(0===ev.columnNames.length)
         .assert(sqConfig.bigIntEnabled
                 ? (3n===ev.changeCount)
-                : (3===ev.changeCount))
-        .assert('bigint'===typeof ev.lastInsertRowId)
-        .assert(ev.lastInsertRowId>=3);
+                : (3===ev.changeCount));
     });
 
     await wtest('exec',{
diff --git a/ext/wasm/fiddle/index.c-pp.html b/ext/wasm/fiddle/index.c-pp.html
index 064f888b84..1f818286b5 100644
--- a/ext/wasm/fiddle/index.c-pp.html
+++ b/ext/wasm/fiddle/index.c-pp.html
@@ -27,7 +27,7 @@
     -->
     <script src="jqterm/jquery.terminal.bundle.min.js"></script>
     <link rel="stylesheet" href="jqterm/jquery.terminal.min.css">
-//#/if
+//#endif
     <style>
       /* The following styles are for app-level use. */
       :root {
@@ -322,9 +322,8 @@ <h1>About SQLite Fiddle <button id='btn-about-close'>close</button></h1>
   <h1>Usage Summary</h1>
 
   <ul>
-    <li class='hidden unhide-if-terminal-available'>In
-      <a href="https://github.com/jcubic/jquery.terminal">"terminal
-      mode"</a> it accepts input just like the CLI shell does.</li>
+    <li class='hidden unhide-if-terminal-available'>In "terminal
+      mode" it accepts input just like the CLI shell does.</li>
     <li>In split-view mode:
       <ul>
         <li>Input can be executed with either the Run
diff --git a/main.mk b/main.mk
index 44a89c28f2..59e1f9400c 100644
--- a/main.mk
+++ b/main.mk
@@ -780,6 +780,7 @@ TESTSRC += \
   $(TOP)/ext/misc/amatch.c \
   $(TOP)/ext/misc/appendvfs.c \
   $(TOP)/ext/misc/basexx.c \
+  $(TOP)/ext/misc/bgckpt.c \
   $(TOP)/ext/misc/cksumvfs.c \
   $(TOP)/ext/misc/closure.c \
   $(TOP)/ext/misc/csv.c \
diff --git a/manifest b/manifest
index d55c013740..43ced69111 100644
--- a/manifest
+++ b/manifest
@@ -1,5 +1,5 @@
-C Performance\senhancements\s(inlining\sand\spartial\sinlining)\sin\sthe\njsonbPayloadSize()\sroutine\sof\sthe\sJSON\slogic\ssaves\sa\slittle\smore\sthan\n10\smillion\scycles\s(0.6%)\son\sthe\sstandard\sbenchmark\s(gcc\s13.3,\s-Os,\smint\slinux)\nwhile\susing\sless\sthan\s700\sextra\sbytes\sof\scode\sspace.
-D 2026-08-20T13:25:12.207
+C Merge\sthe\slatest\strunk\senhancements\sinto\swal2\sbranch.
+D 2026-08-20T14:21:31.428
 F .fossil-settings/binary-glob 61195414528fb3ea9693577e1980230d78a1f8b0a54c78cf1b9b24d0a409ed6a x
 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
@@ -7,7 +7,7 @@ F AGENTS.md 44ddfb38ef23e277888bd70ae378e6cbf5f5cab0e2a4420bd21d89b6caff7a4a
 F LICENSE.md 6bc480fc673fb4acbc4094e77edb326267dd460162d7723c7f30bee2d3d9e97d
 F Makefile.in 5fda086f33b144da08119255da1d2557f983d0764a13707f05acf0159fd89ba5
 F Makefile.linux-generic bd3e3cacd369821a6241d4ea1967395c962dfe3057e38cb0a435cee0e8b789d0
-F Makefile.msc 4f25c07ccb10cd4fb04eaefba912296664b26cf65152d51974f24272fcf4aa6d
+F Makefile.msc 3cc06531a6ac9bd375aab393172ffdcbf54389dfba3bbbaf278c23d73144533e
 F README.md 8a7487de00e6d6d360cec15cc114cbb397207e1b975901683561506401c6d48c
 F VERSION 99cf3be5f13d091183e4314b7fc2e0c0e69accfbe64608b45a313338bbdd7b62
 F art/icon-243x273.gif 9750b734f82fdb3dc43127753d5e6fbf3b62c9f4e136c2fbf573b2f57ea87af5
@@ -51,9 +51,9 @@ F autosetup/proj.tcl 67683f214977a416baafc4c1020f9940ff047a7306b2292c5872d628746
 F autosetup/sqlite-config.tcl a503f8b418547c2872348dbcb71abb09726f3970088625ec90d8000035b06b32
 F autosetup/system.tcl 51d4be76cd9a9074704b584e5c9cbba616202c8468cf9ba8a4f8294a7ab1dba9
 F autosetup/teaish/README.txt b40071e6f8506500a2f7f71d5fc69e0bf87b9d7678dd9da1e5b4d0acbf40b1ca
-F autosetup/teaish/core.tcl e014dd95900c7f9a34e8e0f460f47e94841059827bce8b4c49668b0c7ae3f1a0
+F autosetup/teaish/core.tcl 1ebbe849d8e716424a3ffe9384c7e8b352b3e1194d3d4a153b125cc5176b3715
 F autosetup/teaish/feature.tcl 18194fb79a24d30e5bbdeab40999616f39278b53a27525349ded033af2fd73be
-F autosetup/teaish/tester.tcl 1799514c2652db49561b3386c5242b94534d1663f2cfac861a955e071895fdd0
+F autosetup/teaish/tester.tcl 091745984473faea6985254b9986c6dfd0cce06f68bc515ba4afc1e6b3742fa8
 F configure 9a00b21dfd13757bbfb8d89b30660a89ec1f8f3a79402b8f9f9b6fc475c3303a x
 F contrib/sqlitecon.tcl eb4c6578e08dd353263958da0dc620f8400b869a50d06e271ab0be85a51a08d3
 F doc/F2FS.txt c1d4a0ae9711cfe0e1d8b019d154f1c29e0d3abfe820787ba1e9ed7691160fcd
@@ -69,6 +69,7 @@ F doc/trusted-schema.md 33625008620e879c7bcfbbfa079587612c434fa094d338b08242288d
 F doc/vdbesort-memory.md 4da2639c14cd24a31e0af694b1a8dd37eaf277aff3867e9a8cc14046bc49df56
 F doc/vfs-shm.txt 1a55f3f0e7b6745931b117ba5c9df3640d7a0536f532ef0052563100f4416f86
 F doc/wal-lock.md 7db0cd61e2000b545b78ce89b0c2a9a8dd8d64c097839258ac10d7c5c4156ec1
+F doc/wal2.md a807405a05e19a4945c5905a9ffa0fe45b8560dd7572461192501f565c19cdb5
 F ext/README.md 6eb1ac267d917767952ed0ef63f55de003b6a5da433ce1fa389e1a9532e73132
 F ext/expert/README.md b321c2762bb93c18ea102d5a5f7753a4b8bac646cb392b3b437f633caf2020c3
 F ext/expert/expert.c d548d603a4cc9e61f446cc179c120c6713511c413f82a4a32b1e1e69d3f086a4
@@ -367,6 +368,7 @@ F ext/misc/appendvfs.c 7ad2cdf861399bff503f7e510bfbbc18a4529752255d9766f3a24ced6
 F ext/misc/base64.c 1445761667c16356e827fc6418294c869468be934429aaa8315035e76dd58acf
 F ext/misc/base85.c c713c7c81b05558c488cbdd8c68d612d5a97f9f0b8adf1167148dd7c89ce3f96
 F ext/misc/basexx.c 89ad6b76558efbceb627afd5e2ef1d84b2e96d9aaf9b7ecb20e3d00b51be6fcf
+F ext/misc/bgckpt.c 18cfc9c39ffab3299f730f86ae2991c8574c0bd9ec80efd2f89196798a7b7181
 F ext/misc/btreeinfo.c 5fe97f798a9ee90e92b3031ed7969ec3f558661bb36b821c3ba045a17cfb951c
 F ext/misc/cksumvfs.c 83414e220e6cdfb29929f3154a24f32ff219d9794690bcb1b2db48f668651b35
 F ext/misc/closure.c e1f115c369790512634db8d19ef4f1e45b6c1658c8fe8a9c362aa65805c8a900
@@ -605,7 +607,7 @@ F ext/wasm/api/sqlite3-api-oo1.c-pp.js 58d4c3acf6152f2e792835acecf161a33a497bc9e
 F ext/wasm/api/sqlite3-api-prologue.js 0084e15d66fbcd75cacbaa58e3b473d5e57082c30f3122be7fdadff5589cf6b6
 F ext/wasm/api/sqlite3-api-worker1.c-pp.js eee70a9962c02d86d2332f2432e257ccdf5eb7a742f90d34bdc137346fbc97ae
 F ext/wasm/api/sqlite3-license-version-header.js 98d90255a12d02214db634e041c8e7f2f133d9361a8ebf000ba9c9af4c6761cc
-F ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js b0aefffd3f6023308531fdc52af0c13636c730d70aa7b30fb7f162e40f33224f
+F ext/wasm/api/sqlite3-opfs-async-proxy.c-pp.js 3f85af55609f1452b29c476e59893cbeed417c59560795f50911318e916083b1
 F ext/wasm/api/sqlite3-vfs-helper.c-pp.js 3f828cc66758acb40e9c5b4dcfd87fd478a14c8fb7f0630264e6c7fa0e57515d
 F ext/wasm/api/sqlite3-vfs-kvvfs.c-pp.js f1bbb2e98aee49fb820300c460c9f7e33ea8777f89d5bc17fab46e6f364632b4
 F ext/wasm/api/sqlite3-vfs-opfs-sahpool.c-pp.js 91f864f95c7195378b968cd4612e54b294e2e0445125a15f8626139de39c0462
@@ -613,7 +615,7 @@ F ext/wasm/api/sqlite3-vfs-opfs-wl.c-pp.js 60fa106fc11d31adb1773ac16dd60fc9335a3
 F ext/wasm/api/sqlite3-vfs-opfs.c-pp.js 5dd8410121acf623ce53005a4aab2c7b2b7f5d1ad072f69ebc208882bc7b7236
 F ext/wasm/api/sqlite3-vtab-helper.c-pp.js c67d92bc65b02a7af85b03dca06a62a82a9582af7235da7fe59a66aca783434e
 F ext/wasm/api/sqlite3-wasm.c 5ac22d03231318615112fdea462ea6abbee6cadf964f22b6dfcc813dd6b37b85
-F ext/wasm/api/sqlite3-worker1-promiser.c-pp.js 46919740f8176c10f691431a81c769c35657e3b537e2ed2bde691f9017b0ee8a
+F ext/wasm/api/sqlite3-worker1-promiser.c-pp.js 46f303ba8ddd1b2f0a391798837beddfa72e8c897038c8047eda49ce7d5ed46b
 F ext/wasm/api/sqlite3-worker1.c-pp.js 21b20d3b8d43471d1647123616a7e5435b1e4b6fa447714f91ffc7f950ea01e8
 F ext/wasm/common/SqliteTestUtil.js dae753b95e72248c4395d8de8359e0d055cd9928488e8dd84aef89e46d23b32e
 F ext/wasm/common/emscripten.css 11bd104b6c0d597c67d40cc8ecc0a60dae2b965151e3b6a37fa5708bac3acd15
@@ -625,14 +627,14 @@ F ext/wasm/demo-123.html 8c70a412ce386bd3796534257935eb1e3ea5c581e5d5aea0490b823
 F ext/wasm/demo-123.js c7b3cca50c55841c381a9ca4f9396e5bbdc6114273d0b10a43e378e32e7be5bf
 F ext/wasm/demo-jsstorage.html 409c4be4af5f207fb2877160724b91b33ea36a3cd8c204e8da1acb828ffe588e
 F ext/wasm/demo-jsstorage.js 467cb4126ff679ebcdb112d100d073af26b9808d0a0b52d66a40e28f59c5099b
-F ext/wasm/demo-worker1-promiser.c-pp.html 38e917d4dafa75b4aa0e9e1663abe734c1f701f6da141318bd01ffe3f6e47a77
-F ext/wasm/demo-worker1-promiser.c-pp.js d210aa1e8a74ea6244fe2290de5710bb55b3a9ed681aaba04e38ceb66550f417
+F ext/wasm/demo-worker1-promiser.c-pp.html 635cf90685805e21772a5f7a35d1ace80f98a9ef7c42ff04d7a125ddca7e5db8
+F ext/wasm/demo-worker1-promiser.c-pp.js fcc628cb42fcfaf07d250477801de1e6deb1e319d003976612a0db8d76b9fccc
 F ext/wasm/demo-worker1.html 2c178c1890a2beb5a5fecb1453e796d067a4b8d3d2a04d65ca2eb1ab2c68ef5d
 F ext/wasm/demo-worker1.js fdfa90aa9d6b402bfed802cf1595fe4da6cc834ac38c8ff854bf1ee01f5ff9bb
 F ext/wasm/example_extra_init.c 2347cd69d19d839ef4e5e77b7855103a7fe3ef2af86f2e8c95839afd8b05862f
 F ext/wasm/fiddle/fiddle-worker.js e45bfe9ce4cf0d0270ca0ed254af8deecc7d46c399db4a56fd1d0846d5e258ec
 F ext/wasm/fiddle/fiddle.js 2a0984cc4a35e6889c0d84ee9bf853317d5545ddb3966dfb995bbe589f923c4c
-F ext/wasm/fiddle/index.c-pp.html 5fd1f462864710d1b00d27fc4bc6190cb846cc865d7cc93b99644423f2c4cc84
+F ext/wasm/fiddle/index.c-pp.html 72c7e5517217960b3809648429ea396a7cbad0ffb2c92f6a2f5703abecb27317
 F ext/wasm/index-dist.html db23748044e286773f2768eec287669501703b5d5f72755e8db73607dc54d290
 F ext/wasm/index.html 5bf6cf1b0a3c8b9f5f54d77f2219d7ae87a15162055ce308109c49b1dcab4239
 F ext/wasm/jaccwabyt/jaccwabyt.js 4e2b797dc170851c9c530c3567679f4aa509eec0fab73b466d945b00b356574b
@@ -665,7 +667,7 @@ F ext/wasm/tests/opfs/sahpool/index.html be736567fd92d3ecb9754c145755037cbbd2bca
 F ext/wasm/tests/opfs/sahpool/sahpool-pausing.js f264925cfc82155de38cecb3d204c36e0f6991460fff0cb7c15079454679a4e2
 F ext/wasm/tests/opfs/sahpool/sahpool-worker.js bd25a43fc2ab2d1bafd8f2854ad3943ef673f7c3be03e95ecf1612ff6e8e2a61
 F magic.txt 5ade0bc977aa135e79e3faaea894d5671b26107cc91e70783aa7dc83f22f3ba0
-F main.mk 29b935cdd8bc6a1b5782a8a42d168c757aa66f4f12996bf0c6444e6c473b1eb8
+F main.mk 572bdb0a6bafe6eb9279892b975c4113feb59c17f6f9c883dd2901781df3d7ff
 F make.bat a136fd0b1c93e89854a86d5f4edcf0386d211e5d5ec2434480f6eea436c7420c
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -683,7 +685,7 @@ F src/auth.c b5ece4e1edccad082c0332fa0087df225473bae0feea9269f824312201377185
 F src/backup.c f6a1490f4ef86cca51f0f93158bbc140b5822406e0c50ec61731e3fcdc1242a2
 F src/bitvec.c e242d4496774dfc88fa278177dd23b607dce369ccafb3f61b41638eea2c9b399
 F src/btmutex.c 30dada73a819a1ef5b7583786370dce1842e12e1ad941e4d05ac29695528daea
-F src/btree.c d454bbda4b2a25b7a852c70ab61bcd6c0e5b3f6cda212d6e7529177c0518fb0e
+F src/btree.c 6b6a91dacc5cfe2b9da02f49ae2978b1b22b60d7eabcfeeb70b37fd5d6382349
 F src/btree.h 2ee0ddfdf4f8530ad1d46afffd7da21a0e243bfab10973011ac6f6b7fb4109a1
 F src/btreeInt.h df956bca48cd49d2a38886bc3b02045c039e8a16353f86fccd116c6487f79d82
 F src/build.c 6d55fcda11273ae382e1bcf9695468ca0c05547a2e2f6f09d64f30cb64f4400e
@@ -731,13 +733,13 @@ F src/os_setup.h 8efc64eda6a6c2f221387eefc2e7e45fd5a3d5c8337a7a83519ba4fbd2957ae
 F src/os_unix.c 5ccac2954679efc003330a5686cd2048ec9059f90f54f43900e60877e9158aa7
 F src/os_win.c 1227a3e962b017d676d985a8aec0d64f273991931ea0a0b99773651102f62df4
 F src/os_win.h c06ccc3a090cf54202ea58981c298817f3309d4c9e4d52ad0a02927346493721
-F src/pager.c 55fecb3d8f2c9bd751109aca1df554f3ab3f2ab1c04a7fd99478cb724d73f8b4
-F src/pager.h 6137149346e6c8a3ddc1eeb40aee46381e9bc8b0fcc6dda8a1efde993c2275b8
+F src/pager.c 14886fe1e4c8856c59216b89e524ce65e14986ff1a0361c488f184f7a6219eb7
+F src/pager.h fc0c95d27f2aefffcb39b4373b3557e89e1b4b9a36b183cc04d6f22002bf0ad2
 F src/parse.y d5a3c5b0277a441c38b35071c05e2b61ff5fc918a63309c809f4b6706179c320
 F src/pcache.c 588cc3c5ccaaadde689ed35ce5c5c891a1f7b1f4d1f56f6cf0143b74d8ee6484
 F src/pcache.h 00c5797ddf546ee0fe2828d7f75d1afbf1b40ba054f362905326c5ccca15e60c
 F src/pcache1.c 6bc38b44961f767985ae5022fb7887eda206040f57475812473929c702f6799d
-F src/pragma.c a06280cfb0048758edd4332195c95ae6744436464fb30c4cf21529dd0320802e
+F src/pragma.c 98e84591affd54be8f0318ac2e4d8f68687832b77b5ca134f3f994db76a0451d
 F src/prepare.c 8954bb69defe377cd6a926f8c61d8215ea4f1974838d3ec6f22681a2c0a2939f
 F src/printf.c b480176bd0aaed9d64e804cfa3ca27fc585f65a73e7c7ca2fe9b9016db2cf6d5
 F src/random.c 606b00941a1d7dd09c381d3279a058d771f406c5213c9932bbd93d5587be4b9c
@@ -794,7 +796,7 @@ F src/test_schema.c b06d3ddc3edc173c143878f3edb869dd200d57d918ae2f38820534f9a5e3
 F src/test_sqllog.c 5abf04865758c0a3915b4ec2b2ee5ab75f74c00e2f05bf503b9083e0ab6829d7
 F src/test_superlock.c 3387fc794a68d8c6b6ed059aabacbfe870dc502c5cf65562f36aac78b4a4d629
 F src/test_syscall.c abafb6bd50f0fb21330bb0edce03c6b0493a7dc6d948b1b2b227b11852c9cde2
-F src/test_tclsh.c c01706ac60bd3176754d3ccd37da74c6ad97c2e14489f8ed71b497c1c0ac0dd4
+F src/test_tclsh.c 179e8c9fc722240275d5d9c5d9ff0d8e652c7614f601b8699c41d9c703f7ec38
 F src/test_tclvar.c ae873248a0188459b1c16ca7cc431265dacce524399e8b46725c2b3b7e048424
 F src/test_thread.c 3edb4a5b5aeb1a6e9a275dccc848ac95acab7f496b3e9230f6d2d04953a2b862
 F src/test_vdbecov.c 5c426d9cd2b351f5f9ceb30cabf8c64a63bfcad644c507e0bd9ce2f6ae1a3bf3
@@ -810,11 +812,11 @@ F src/upsert.c dd9f0fcccbfb4f20e1026a21a7254ba3f2c08e9cfa92affaff5b5ec3b00ea549
 F src/utf.c 7267c3fb9e2467020507601af3354c2446c61f444387e094c779dccd5ca62165
 F src/util.c cfdf9c6e5323af886d5ce766709da607ba1d14193ad3a15f4f462a45420e8211
 F src/vacuum.c d3d35d8ae893d419ade5fa196d761a83bddcbb62137a1a157ae751ef38b26e82
-F src/vdbe.c a3bf71b5fc69cc0b7bf87fb8b35a1faf9ccf524e7c2e8a90c3c7a47a7728d90e
+F src/vdbe.c c6996cbab8e0e936ac0c527df267e6977418727e7f099f3fce16c7594eed89ab
 F src/vdbe.h ec2d5613f403a29934652276172b030887a7e6c109e0679dff636ab02df19a60
 F src/vdbeInt.h 39f4c8eb1e4ac0593037d5268a54a691c72d34896db9973a9d39f2a5dea14163
 F src/vdbeapi.c 6ad0c841b6cb87de068f71787f385149d794e8830176bf72d09a36b9f655ac5b
-F src/vdbeaux.c 8dfb16ec3b0768ce0bcc9596da5ddd588b893d80732b3a3b04a221238fead9c7
+F src/vdbeaux.c abebe919b5a6b66de8ea5629bddb1a5e623bd4a09f5c5526f9aa10f70314b2ee
 F src/vdbeblob.c b3f0640db9642fbdc88bd6ebcc83d6009514cafc98f062f675f2c8d505d82692
 F src/vdbemem.c 6e7ad67507c9a8e625b46256a9c003929331d6a27b99bbe139b8f0dab636e1f2
 F src/vdbesort.c a72ad2a629df2901fde4aa588e38590d0aa27b7d5bc3b2a416e5f295de839cc1
@@ -822,8 +824,8 @@ F src/vdbetrace.c 49e689f751505839742f4a243a1a566e57d5c9eaf0d33bbaa26e2de3febf7b
 F src/vdbevtab.c fc46b9cbd759dc013f0b3724549cc0d71379183c667df3a5988f7e2f1bd485f3
 F src/vtab.c 1fa9e01d3da114a634a6ba1f36de8a3af6381b675cbbca399f0de64934e50ac6
 F src/vxworks.h 9d18819c5235b49c2340a8a4d48195ec5d5afb637b152406de95a9436beeaeab
-F src/wal.c cb28ab3a71cb73ea422a2fcc26283b65a1e5a2a65c44de86951c7d6a186381ac
-F src/wal.h ba252daaa94f889f4b2c17c027e823d9be47ce39da1d3799886bbd51f0490452
+F src/wal.c 3060a6442adaadeb19ab5f3e254bd173249bc9855271b5c8c96a0a0d1d3bb78a
+F src/wal.h 97b8a9903387401377b59507e86b93a148ef1ad4e5ce0f23659a12dcdce56af2
 F src/walker.c d5006d6b005e4ea7302ad390957a8d41ed83faa177e412f89bc5600a7462a014
 F src/where.c 90c2628698dd2db741dd20ae2e2204b0844699b6f68563f6fcf05f88fe100f16
 F src/whereInt.h f039ad303bc2913de673e431821ef8db3b619d249e6e5548d90072a684e72285
@@ -1008,7 +1010,7 @@ F test/corrupt6.test fc6a891716139665dae0073b6945e3670bf92568
 F test/corrupt7.test ffa86896fe63a3d00b0a131e1e64f402e4da9f7e5d89609d6501c851e511d73a
 F test/corrupt8.test 2399dfe40d2c0c63af86706e30f3e6302a8d0516
 F test/corrupt9.test 730a3db08d4ab9aa43392ea30d9c2b4879cbff85
-F test/corruptA.test 112f4b2ae0b95ebf3ea63718642fb969a93acea557ace3a307234d19c245989b
+F test/corruptA.test 56e8f321adaf3411960e9d2c7136669d8e1a91cbde6cf401ea84e6d6c7ccbe10
 F test/corruptB.test 73a8d6c0b9833697ecf16b63e3c5c05c945b5dec
 F test/corruptC.test 7d6d9e907334ea3ccb7111a0656cafa30a28f8a5f2aaf1c45ad712236302856a
 F test/corruptD.test 614320aa519f6bf6c7dd2f581f9513ff7b6826954180cca1a606d0e25ea084a3
@@ -1523,7 +1525,7 @@ F test/pcache.test c8acbedd3b6fd0f9a7ca887a83b11d24a007972b
 F test/pcache2.test 8a801d2b8e4b0ebb99701f026a67a9e84634c8aa24799a842c44003b93250da1
 F test/pendingrace.test e99efc5ab3584da3dfc8cd6a0ec4e5a42214820574f5ea24ee93f1d84655f463
 F test/percentile.test fd78896fa882fa4fbf693640097859721f3629926c2ccf804af5bcb7001fd35b
-F test/permutations.test 2fbe05e34e126b9a40080454404ea8d08e4805b49623e9524ea5d0a84c5c7c55
+F test/permutations.test 81e96236b7e00a2e1f5ca0d561d9533d864dda45d1b31111bb32c68db4fc553f
 F test/pg_common.tcl 3b27542224db1e713ae387459b5d117c836a5f6e328846922993b6d2b7640d9f
 F test/pragma.test 7d07b7bb76e273215d6a20c4f83c3062cc28976c737ccb70a686025801e86c8f
 F test/pragma2.test e5d5c176360c321344249354c0c16aec46214c9f
@@ -1554,7 +1556,7 @@ F test/quote.test 7b01b2a261bc26d9821aea9f4941ce1e08191d62fc55ba8862440fb3a59197
 F test/randexpr1.tcl 40dec52119ed3a2b8b2a773bce24b63a3a746459
 F test/randexpr1.test eda062a97e60f9c38ae8d806b03b0ddf23d796df
 F test/rbu.test 168573d353cd0fd10196b87b0caa322c144ef736
-F test/rdonly.test 64e2696c322e3538df0b1ed624e21f9a23ed9ff8
+F test/rdonly.test 21e99ee237265d0cf95a0c84b50c784e834acaa4ef05d92a27b262626a656682
 F test/readonly.test 0d307c335b3421898cfe64a783a376138aa003849b6bff61ee2d21e805bc0051
 F test/recover.test 643139b911ac880a1e881d7621f02cfb546b608b8f2494d7d26fd5ed103b1ceb
 F test/regexp1.sql fd15d317973dd0c9cd9ee7b8bda45ef1c0a5e126223fc53c86d71b5d407e6fb4
@@ -1587,7 +1589,7 @@ F test/rowvaluefault.test 963ae9cdaed30a85a29668dd514e639f3556cae903ee9f172ea972
 F test/rowvaluevtab.test cd9747bb3f308086944c07968f547ad6b05022e698d80b9ffbdfe09ce0b8da6f
 F test/rtree.test 0c8d9dd458d6824e59683c19ab2ffa9ef946f798
 F test/run-wordcount.sh 891e89c4c2d16e629cd45951d4ed899ad12afc09
-F test/savepoint.test 6e9804a17767f08432c7a5e738b9a8f4b891d243110b63d3a41d270d3d1378ec
+F test/savepoint.test 63a120ec4fbbd5025b238c259d12ed0516fbf4bca6384041cb995ade9a5f00d2
 F test/savepoint2.test 9b8543940572a2f01a18298c3135ad0c9f4f67d7
 F test/savepoint4.test c8f8159ade6d2acd9128be61e1230f1c1edc6cc0
 F test/savepoint5.test 0735db177e0ebbaedc39812c8d065075d563c4fd
@@ -1733,7 +1735,7 @@ F test/temptable2.test 76821347810ecc88203e6ef0dd6897b6036ac788e9dd3e6b04fd4d163
 F test/temptable3.test d11a0974e52b347e45ee54ef1923c91ed91e4637
 F test/temptrigfault.tes fc5918e64f3867156fefe7cfca9d8e1f495134a5229b2b511b0dc11c07f2eab4
 F test/temptrigger.test a00f258ed8d21a0e8fd4f322f15e8cfb5cef2e43655670e07a753e3fb4769d61
-F test/tester.tcl dfd8dd05b54bc493a8db6cc1263ee364c36e3c27fab258dad7305cd79b948f3f
+F test/tester.tcl fdaee8b81973aca0d455a2137dd06d60dd9f0bfcb22258bf036be7cf50477e02
 F test/testloadext.c 862b848783eaed9985fbce46c65cd214664376b549fae252b364d5d1ef350a27
 F test/testrunner.tcl 501584fa440904f1080b9eb34f2ccb4a2e741010e80b3397cf12179ca1a2f69b x
 F test/testrunner_data.tcl 4c75dd01fe5ba96b425f3571bff1ddf927734caa3c79e19acd9c84966d7ddfa3
@@ -1957,7 +1959,7 @@ F test/upsert3.test 88d7d590a1948a9cb6eac1b54b0642f67a9f35a1fc0f19b200e97d5d39e3
 F test/upsert4.test 25d2a1da92f149331ae0c51ca6e3eee78189577585eab92de149900d62994fa5
 F test/upsert5.test 8d0230b358965e0c11f7306b87ba1238970e44b8339e34609f44d0468c4ed458
 F test/upsertfault.test f21ca47740841fdb4d61acfa7b17646d773e67724fe8c185b71c018db8a94b35
-F test/uri.test 1250724af9beeed2d6c3716f5b990c483200c54f408d3c0ec9543a3c7961f8fc
+F test/uri.test 234147e5eda1ef143a8b74ac8f8e9bae363aafa6b8c5813119052f268765d62f
 F test/uri2.test 9d3ba7a53ee167572d53a298ee4a5d38ec4a8fb7
 F test/utf16align.test 9fde0bb5d3a821594aa68c6829ab9c5453a084384137ebb9f6153e2d678039da
 F test/vacuum-into.test 5a489714feecfdabfc7b293be4111564a173dee92c0d6818dd0207f3ade65783
@@ -2003,8 +2005,20 @@ F test/vtab_shared.test 5253bff2355a9a3f014c15337da7e177ab0ef8ad
 F test/vtabdistinct.test 7688f0889358f849fd60bbfde1ded38b014b18066076d4bfbb75395804dfe072
 F test/vtabdrop.test 65d4cf6722972e5499bdaf0c0d70ee3b8133944a4e4bc31862563f32a7edca12
 F test/vtabrhs1.test 9b5ecbc74a689500c33a4b2b36761f9bcc22fcc4e3f9d21066ee0c9c74cf5f6c
-F test/wal.test 519c550255c78f55959e9159b93ebbfad2b4e9f36f5b76284da41f572f9d27da
+F test/wal.test a5d6c7f4bd79251ed344229d96d44ecdfb896bdbd32b7e65f118756699c7e473
 F test/wal2.test f058016abe4627d2664db4b4b87990298d925e66a4c5a2c8e674a0ff6f4c841d
+F test/wal2big.test 829141cbecdda4329db8fa38705424c4a73db72a06b9540b06811a825d330409
+F test/wal2fault.test 2e8e60cacd5bcd451618aeffd05f676894d17202d3e2986e288d36e2c5993249
+F test/wal2lock.test 0ef98d72dc6bcf7711dedd684760488400d9a9a6eec0dc5d3822060437793552
+F test/wal2openclose.test 2b26be723ea7f4263c8d5d70b37efd1c359561a0526e39466c45fe8e6478daee
+F test/wal2recover.test 348a3f2a4c79359790f70fd692dcd0c8f04e42a85365e688778c945e10bae02b
+F test/wal2recover2.test 3fe5d5932b16a3a38304a85bafed1f965faef40c230fd450838a0502e61343bb
+F test/wal2recover3.test 4a91689e165a38bc401736e6518188c2b0ff4fa1566d1810b8867536db128177
+F test/wal2rewrite.test 6ca6f631ffcf871240beab5f02608913fd075c6d0d31310b026c8383c65c9f9c
+F test/wal2rollback.test 23adc4a099b23f6aaea8b04fdca1c35861d887dd80f8be7da2d5273eb777e428
+F test/wal2savepoint.test c380512ec1f97012cfc753e718bf3df38f51e7c319110e1cae25094a33b371c4
+F test/wal2simple.test d2d94fe1f30700c9f30e46c16f1c3d7d245b861a1be2bfe5ead701484c6dd38e
+F test/wal2snapshot.test 7a5f4629a3c43a43c3440b8b2ea9f07de91a46b0b9eea5f08f62b5bf5b6468df
 F test/wal3.test 5de023bb862fd1eb9d2ad26fa8d9c43abb5370582e5b08b2ae0d6f93661bc310
 F test/wal4.test 4744e155cd6299c6bd99d3eab1c82f77db9cdb3c
 F test/wal5.test 9c11da7aeccd83a46d79a556ad11a18d3cb15aa9
@@ -2031,9 +2045,9 @@ F test/walnoshm.test 844b3eb7d8e8ee76c834ef723babec57b0be51fa52ef7e321c289ed0fe3
 F test/waloverwrite.test dad2f26567f1b45174e54fbf9a8dc1cb876a7f03
 F test/walpersist.test 8d78a1ec91299163451417b451a2bac3481f8eb9f455b1ca507a6625c927ca6e
 F test/walprotocol.test 1b3f922125e341703f6e946d77fdc564d38fb3e07a9385cfdc6c99cac1ecf878
-F test/walprotocol2.test 7d3b6b4bf0b12f8007121b1e6ef714bc99101fb3b48e46371df1db868eebc131
+F test/walprotocol2.test 7e4bedd5ee83607e2928ac438bf7332a396b980d3e02aa0746509ce11ad1f13c
 F test/walrestart.test 5168c0c2414d1971d8dec949c1070a0144cf15402361ba0d0e6a8054f5598a64
-F test/walro.test 78a84bc0fdae1385c06b017215c426b6845734d6a5a3ac75c918dd9b801b1b9d
+F test/walro.test 1a4d88af29f748c1eeea2c005cfc0abfe4a5e943a7b498c911532fe3911ed2ba
 F test/walro2.test 33955a6fd874dd9724005e17f77fef89d334b3171454a1256fe4941a96766cdc
 F test/walrofault.test c70cb6e308c443867701856cce92ad8288cd99488fa52afab77cca6cfd51af68
 F test/walseh1.test bae700eb99519b6d5cd3f893c04759accc5a59c391d4189fe4dd6995a533442b
@@ -2160,7 +2174,7 @@ F tool/mkamalzip.tcl 8aa5ebe7973c8b8774062d34e15fea9815c4cc2ceea3a9b184695f00591
 F tool/mkautoconfamal.sh 06fbe090b81c24e592c1f22b404334f805ba74d482a9260f2ac81e6f3d3386d8
 F tool/mkccode.tcl c42a8f8cf78f92e83795d5447460dbce7aaf78a3bbf9082f1507dc71a3665f3c x
 F tool/mkcombo.tcl 2a5189b219c4a495e1ff7fc980bd568d3cfb82ae9d50c84e77f7a161e96fc132
-F tool/mkctimec.tcl 85ce722e10f81368bc42fb194fe6af450f7f0ef9199b706cbc02b5b484ce3d4a x
+F tool/mkctimec.tcl 404b4472e783d1c5adf80f04c9e51803f37678dc82c57b8d6ef37e26ef9176ef x
 F tool/mkfptab.c 24ea40113f96584caca3f6dd06b4ad5adffa0f39023910cb83fa7ef2ffa9b0ba
 F tool/mkkeywordhash.c 82d5af1d0e677900739fba59155cddac172d8c712c2d91ab73d6e6bcb30060f0
 F tool/mkmsvcmin.tcl d76c45efda1cce2d4005bcea7b8a22bb752e3256009f331120fb4fecb14ebb7a
@@ -2214,14 +2228,13 @@ F tool/tclConfigShToMake.sh 7c065d81c2d178e15e45a77372c6e5a38b5a1b08755301cd6f20
 F tool/varint.c 5d94cb5003db9dbbcbcc5df08d66f16071aee003
 F tool/vdbe-compress.tcl fa2f37ab39b2a0087fafb6a7f3ce19503e25e624ffa8ed9951717ab72920c088
 F tool/vdbe_profile.tcl 3ac5a4a9449f4baf77059358ea050db3e34395ccf59c5464d29b91746d5b961e
-F tool/version-info.c 33d0390ef484b3b1cb685d59362be891ea162123cea181cb8e6d2cf6ddf2700c
+F tool/version-info.c 3b36468a90faf1bbd59c65fd0eb66522d9f941eedd364fabccd72273503ae7d5
 F tool/warnings-clang.sh bbf6a1e685e534c92ec2bfba5b1745f34fb6f0bc2a362850723a9ee87c1b31a7
 F tool/warnings.sh a554d13f6e5cf3760f041b87939e3d616ec6961859c3245e8ef701d1eafc2ca2
 F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
 F tool/winmain.c 00c8fb88e365c9017db14c73d3c78af62194d9644feaf60e220ab0f411f3604c
-P dc176e433555fc818fb20218d846f06477305e6524dc1d73f175de9efccb3428 cff777eeb9b3e124a775bdd284b498fedf3945b42e20bd1ff68bf0c4085971bc
-R 71f5df27cba2504fac435c3c0bd0de3d
-T +closed cff777eeb9b3e124a775bdd284b498fedf3945b42e20bd1ff68bf0c4085971bc
+P 78f78edbb7a10e9c9376ae6760d0733e0429defb1b36bdda857609d800a9a15f 3bd5456e50ef321f2cafcf67261d556a760624ce0caab430ed9454cebec233e7
+R 2974ee8cc62b45152e85673a11ad0e01
 U drh
-Z a493bffdae739d875d162754a4f66083
+Z 0883c5d5d422a08600fc8bf20c98615a
 # Remove this line to create a well-formed Fossil manifest.
diff --git a/manifest.tags b/manifest.tags
index bec971799f..cd8c36ad46 100644
--- a/manifest.tags
+++ b/manifest.tags
@@ -1,2 +1,2 @@
-branch trunk
-tag trunk
+branch wal2
+tag wal2
diff --git a/manifest.uuid b/manifest.uuid
index fce06e2d99..31c5adda7b 100644
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-3bd5456e50ef321f2cafcf67261d556a760624ce0caab430ed9454cebec233e7
+7257cc1b709e615412bbb5a802defdc82302eb0b7a9778ec48b9fff90b65c261
diff --git a/src/btree.c b/src/btree.c
index 3730108387..e1f8d437ab 100644
--- a/src/btree.c
+++ b/src/btree.c
@@ -3353,10 +3353,10 @@ static int lockBtree(BtShared *pBt){
       goto page1_init_failed;
     }
 #else
-    if( page1[18]>2 ){
+    if( page1[18]>3 ){
       pBt->btsFlags |= BTS_READ_ONLY;
     }
-    if( page1[19]>2 ){
+    if( page1[19]>3 ){
       goto page1_init_failed;
     }
 
@@ -3368,9 +3368,9 @@ static int lockBtree(BtShared *pBt){
     ** may not be the latest version - there may be a newer one in the log
     ** file.
     */
-    if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
+    if( page1[19]>=2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
       int isOpen = 0;
-      rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
+      rc = sqlite3PagerOpenWal(pBt->pPager, (page1[19]==3), &isOpen);
       if( rc!=SQLITE_OK ){
         goto page1_init_failed;
       }else{
@@ -11570,7 +11570,7 @@ int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){
   BtShared *pBt = pBtree->pBt;
   int rc;                         /* Return code */
 
-  assert( iVersion==1 || iVersion==2 );
+  assert( iVersion==1 || iVersion==2 || iVersion==3 );
 
   /* If setting the version fields to 1, do not automatically open the
   ** WAL connection, even if the version fields are currently set to 2.
diff --git a/src/pager.c b/src/pager.c
index f05d12adc8..ef5b9a0e39 100644
--- a/src/pager.c
+++ b/src/pager.c
@@ -932,6 +932,7 @@ static int assert_pager_state(Pager *p){
         assert( isOpen(p->jfd)
              || p->journalMode==PAGER_JOURNALMODE_OFF
              || p->journalMode==PAGER_JOURNALMODE_WAL
+             || p->journalMode==PAGER_JOURNALMODE_WAL2
         );
       }
       assert( pPager->dbOrigSize==pPager->dbFileSize );
@@ -946,6 +947,7 @@ static int assert_pager_state(Pager *p){
       assert( isOpen(p->jfd)
            || p->journalMode==PAGER_JOURNALMODE_OFF
            || p->journalMode==PAGER_JOURNALMODE_WAL
+           || p->journalMode==PAGER_JOURNALMODE_WAL2
            || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
       );
       assert( pPager->dbOrigSize<=pPager->dbHintSize );
@@ -958,6 +960,7 @@ static int assert_pager_state(Pager *p){
       assert( isOpen(p->jfd)
            || p->journalMode==PAGER_JOURNALMODE_OFF
            || p->journalMode==PAGER_JOURNALMODE_WAL
+           || p->journalMode==PAGER_JOURNALMODE_WAL2
            || (sqlite3OsDeviceCharacteristics(p->fd)&SQLITE_IOCAP_BATCH_ATOMIC)
       );
       break;
@@ -2152,6 +2155,7 @@ static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){
       assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
            || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
            || pPager->journalMode==PAGER_JOURNALMODE_WAL
+           || pPager->journalMode==PAGER_JOURNALMODE_WAL2
       );
       sqlite3OsClose(pPager->jfd);
       if( bDelete ){
@@ -3315,6 +3319,10 @@ static int pagerBeginReadTransaction(Pager *pPager){
   if( rc!=SQLITE_OK || changed ){
     pager_reset(pPager);
     if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
+    assert( pPager->journalMode==PAGER_JOURNALMODE_WAL
+         || pPager->journalMode==PAGER_JOURNALMODE_WAL2
+    );
+    pPager->journalMode = sqlite3WalJournalMode(pPager->pWal);
   }
 
   return rc;
@@ -3410,9 +3418,9 @@ static int pagerOpenWalIfPresent(Pager *pPager){
           rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
         }else{
           testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
-          rc = sqlite3PagerOpenWal(pPager, 0);
+          rc = sqlite3PagerOpenWal(pPager, 0, 0);
         }
-      }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
+      }else if( pPager->journalMode>=PAGER_JOURNALMODE_WAL ){
         pPager->journalMode = PAGER_JOURNALMODE_DELETE;
       }
     }
@@ -4933,6 +4941,7 @@ int sqlite3PagerOpen(
     (u64)nPathname + 8 + 1 +             /* Journal filename */
 #ifndef SQLITE_OMIT_WAL
     (u64)nPathname + 4 + 1 +             /* WAL filename */
+    nPathname + 5 + 1 +                  /* Second WAL filename */
 #endif
     3                                    /* Terminator */
   );
@@ -4985,6 +4994,8 @@ int sqlite3PagerOpen(
     sqlite3FileSuffix3(zFilename, pPager->zWal);
     pPtr = (u8*)(pPager->zWal + sqlite3Strlen30(pPager->zWal)+1);
 #endif
+    memcpy(pPtr, zPathname, nPathname);   pPtr += nPathname;
+    memcpy(pPtr, "-wal2", 5);             pPtr += 5 + 1;
   }else{
     pPager->zWal = 0;
   }
@@ -7429,7 +7440,8 @@ int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
             || eMode==PAGER_JOURNALMODE_OFF       /* 2 */
             || eMode==PAGER_JOURNALMODE_TRUNCATE  /* 3 */
             || eMode==PAGER_JOURNALMODE_MEMORY    /* 4 */
-            || eMode==PAGER_JOURNALMODE_WAL       /* 5 */ );
+            || eMode==PAGER_JOURNALMODE_WAL       /* 5 */
+            || eMode==PAGER_JOURNALMODE_WAL2      /* 6 */ );
 
   /* This routine is only called from the OP_JournalMode opcode, and
   ** the logic there will never allow a temporary file to be changed
@@ -7463,9 +7475,12 @@ int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
     assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
     assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
     assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
+    assert( (PAGER_JOURNALMODE_WAL2 & 5)==4 );
 
     assert( isOpen(pPager->fd) || pPager->exclusiveMode );
-    if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
+    if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 
+     && eMode!=PAGER_JOURNALMODE_WAL2       /* TODO: fix this if possible */
+    ){
       /* In this case we would like to delete the journal file. If it is
       ** not possible, then that is not a problem. Deleting the journal file
       ** here is an optimization only.
@@ -7640,7 +7655,7 @@ static int pagerExclusiveLock(Pager *pPager){
 ** lock on the database file and use heap-memory to store the wal-index
 ** in. Otherwise, use the normal shared-memory.
 */
-static int pagerOpenWal(Pager *pPager){
+static int pagerOpenWal(Pager *pPager, int bWal2){
   int rc = SQLITE_OK;
 
   assert( pPager->pWal==0 && pPager->tempFile==0 );
@@ -7661,7 +7676,7 @@ static int pagerOpenWal(Pager *pPager){
   if( rc==SQLITE_OK ){
     rc = sqlite3WalOpen(pPager->pVfs,
         pPager->fd, pPager->zWal, pPager->exclusiveMode,
-        pPager->journalSizeLimit, &pPager->pWal
+        pPager->journalSizeLimit, bWal2, &pPager->pWal
     );
 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
     if( rc==SQLITE_OK ){
@@ -7692,6 +7707,7 @@ static int pagerOpenWal(Pager *pPager){
 */
 int sqlite3PagerOpenWal(
   Pager *pPager,                  /* Pager object */
+  int bWal2,                      /* Open in wal2 mode if not already open */
   int *pbOpen                     /* OUT: Set to true if call is a no-op */
 ){
   int rc = SQLITE_OK;             /* Return code */
@@ -7708,9 +7724,9 @@ int sqlite3PagerOpenWal(
     /* Close any rollback journal previously open */
     sqlite3OsClose(pPager->jfd);
 
-    rc = pagerOpenWal(pPager);
+    rc = pagerOpenWal(pPager, bWal2);
     if( rc==SQLITE_OK ){
-      pPager->journalMode = PAGER_JOURNALMODE_WAL;
+      pPager->journalMode = bWal2?PAGER_JOURNALMODE_WAL2:PAGER_JOURNALMODE_WAL;
       pPager->eState = PAGER_OPEN;
     }
   }else{
@@ -7732,7 +7748,9 @@ int sqlite3PagerOpenWal(
 int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
   int rc = SQLITE_OK;
 
-  assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
+  assert( pPager->journalMode==PAGER_JOURNALMODE_WAL 
+       || pPager->journalMode==PAGER_JOURNALMODE_WAL2
+  );
 
   /* If the log file is not already open, but does exist in the file-system,
   ** it may need to be checkpointed before the connection can switch to
@@ -7747,7 +7765,7 @@ int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
       );
     }
     if( rc==SQLITE_OK && logexists ){
-      rc = pagerOpenWal(pPager);
+      rc = pagerOpenWal(pPager, 0);
     }
   }
    
diff --git a/src/pager.h b/src/pager.h
index 9b2cfc0bcf..c3ba24fbc0 100644
--- a/src/pager.h
+++ b/src/pager.h
@@ -82,8 +82,9 @@ typedef struct PgHdr DbPage;
 #define PAGER_JOURNALMODE_TRUNCATE    3   /* Commit by truncating journal */
 #define PAGER_JOURNALMODE_MEMORY      4   /* In-memory journal file */
 #define PAGER_JOURNALMODE_WAL         5   /* Use write-ahead logging */
+#define PAGER_JOURNALMODE_WAL2        6   /* Use write-ahead logging mode 2 */
 
-#define isWalMode(x) ((x)==PAGER_JOURNALMODE_WAL)
+#define isWalMode(x) ((x)==PAGER_JOURNALMODE_WAL || (x)==PAGER_JOURNALMODE_WAL2)
 
 /*
 ** The argument to this macro is a file descriptor (type sqlite3_file*).
@@ -191,7 +192,7 @@ int sqlite3PagerSharedLock(Pager *pPager);
   int sqlite3PagerCheckpoint(Pager *pPager, sqlite3*, int, int*, int*);
   int sqlite3PagerWalSupported(Pager *pPager);
   int sqlite3PagerWalCallback(Pager *pPager);
-  int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
+  int sqlite3PagerOpenWal(Pager *pPager, int, int *pisOpen);
   int sqlite3PagerCloseWal(Pager *pPager, sqlite3*);
 # ifdef SQLITE_ENABLE_SNAPSHOT
   int sqlite3PagerSnapshotGet(Pager*, sqlite3_snapshot **ppSnapshot);
diff --git a/src/pragma.c b/src/pragma.c
index a7170074bb..7016c633e7 100644
--- a/src/pragma.c
+++ b/src/pragma.c
@@ -290,7 +290,7 @@ const char *sqlite3JournalModename(int eMode){
   static char * const azModeName[] = {
     "delete", "persist", "off", "truncate", "memory"
 #ifndef SQLITE_OMIT_WAL
-     , "wal"
+     , "wal", "wal2"
 #endif
   };
   assert( PAGER_JOURNALMODE_DELETE==0 );
@@ -299,6 +299,7 @@ const char *sqlite3JournalModename(int eMode){
   assert( PAGER_JOURNALMODE_TRUNCATE==3 );
   assert( PAGER_JOURNALMODE_MEMORY==4 );
   assert( PAGER_JOURNALMODE_WAL==5 );
+  assert( PAGER_JOURNALMODE_WAL2==6 );
   assert( eMode>=0 && eMode<=ArraySize(azModeName) );
 
   if( eMode==ArraySize(azModeName) ) return 0;
diff --git a/src/test_tclsh.c b/src/test_tclsh.c
index 989cb97a62..d6892f12a7 100644
--- a/src/test_tclsh.c
+++ b/src/test_tclsh.c
@@ -90,6 +90,7 @@ const char *sqlite3TestInit(Tcl_Interp *interp){
   extern int Fts5tcl_Init(Tcl_Interp *);
   extern int SqliteRbu_Init(Tcl_Interp*);
   extern int Sqlitetesttcl_Init(Tcl_Interp*);
+  extern int Bgckpt_Init(Tcl_Interp*);
 #if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
   extern int Sqlitetestfts3_Init(Tcl_Interp *interp);
 #endif
@@ -159,6 +160,8 @@ const char *sqlite3TestInit(Tcl_Interp *interp){
   Fts5tcl_Init(interp);
   SqliteRbu_Init(interp);
   Sqlitetesttcl_Init(interp);
+  Bgckpt_Init(interp);
+
 
 #if defined(SQLITE_ENABLE_FTS3) || defined(SQLITE_ENABLE_FTS4)
   Sqlitetestfts3_Init(interp);
diff --git a/src/vdbe.c b/src/vdbe.c
index 0573b6c1d7..4c8c721d60 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -8247,6 +8247,7 @@ case OP_JournalMode: {    /* out2 */
        || eNew==PAGER_JOURNALMODE_OFF
        || eNew==PAGER_JOURNALMODE_MEMORY
        || eNew==PAGER_JOURNALMODE_WAL
+       || eNew==PAGER_JOURNALMODE_WAL2
        || eNew==PAGER_JOURNALMODE_QUERY
   );
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
@@ -8265,16 +8266,25 @@ case OP_JournalMode: {    /* out2 */
   /* Do not allow a transition to journal_mode=WAL for a database
   ** in temporary storage or if the VFS does not support shared memory
   */
-  if( eNew==PAGER_JOURNALMODE_WAL
+  if( isWalMode(eNew)
    && (sqlite3Strlen30(zFilename)==0           /* Temp file */
        || !sqlite3PagerWalSupported(pPager))   /* No shared-memory support */
   ){
     eNew = eOld;
   }
 
-  if( (eNew!=eOld)
-   && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
-  ){
+  if( eNew!=eOld && (isWalMode(eNew) || isWalMode(eOld)) ){
+
+    /* Prevent changing directly to wal2 from wal mode. And vice versa. */
+    if( isWalMode(eNew) && isWalMode(eOld) ){
+      rc = SQLITE_ERROR;
+      sqlite3VdbeError(p, "cannot change from %s to %s mode",
+          sqlite3JournalModename(eOld), sqlite3JournalModename(eNew)
+      );
+      goto abort_due_to_error;
+    }
+
+    /* Prevent switching into or out of wal/wal2 mode mid-transaction */
     if( !db->autoCommit || db->nVdbeRead>1 ){
       rc = SQLITE_ERROR;
       sqlite3VdbeError(p,
@@ -8284,7 +8294,7 @@ case OP_JournalMode: {    /* out2 */
       goto abort_due_to_error;
     }else{
 
-      if( eOld==PAGER_JOURNALMODE_WAL ){
+      if( isWalMode(eOld) ){
         /* If leaving WAL mode, close the log file. If successful, the call
         ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
         ** file. An EXCLUSIVE lock may still be held on the database file
@@ -8305,7 +8315,10 @@ case OP_JournalMode: {    /* out2 */
       */
       assert( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE );
       if( rc==SQLITE_OK ){
-        rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
+        /* 1==rollback, 2==wal, 3==wal2 */
+        rc = sqlite3BtreeSetVersion(pBt, 
+            1 + isWalMode(eNew) + (eNew==PAGER_JOURNALMODE_WAL2)
+        );
       }
     }
   }
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index 7d9574e810..972ad4ac83 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -2967,7 +2967,8 @@ static int vdbeCommit(sqlite3 *db, Vdbe *p){
         /* OFF       */ 0,
         /* TRUNCATE  */ 1,
         /* MEMORY    */ 0,
-        /* WAL       */ 0
+        /* WAL       */ 0,
+        /* WAL2      */ 0
       };
       Pager *pPager;   /* Pager associated with pBt */
       needXcommit = 1;
diff --git a/src/wal.c b/src/wal.c
index fb00b3af16..c57fe5273a 100644
--- a/src/wal.c
+++ b/src/wal.c
@@ -101,7 +101,7 @@
 **
 ** To read a page from the database (call it page number P), a reader
 ** first checks the WAL to see if it contains page P.  If so, then the
-** last valid instance of page P that is a followed by a commit frame
+** last valid instance of page P that is followed by a commit frame
 ** or is a commit frame itself becomes the value read.  If the WAL
 ** contains no copies of page P that are valid and which are a commit
 ** frame or are followed by a commit frame, then page P is read from
@@ -236,7 +236,7 @@
 ** and to the wal-index) might be using a different value K1, where K1>K0.
 ** Both readers can use the same hash table and mapping section to get
 ** the correct result.  There may be entries in the hash table with
-** K>K0 but to the first reader, those entries will appear to be unused
+** K>K0, but to the first reader those entries will appear to be unused
 ** slots in the hash table and so the first reader will get an answer as
 ** if no values greater than K0 had ever been inserted into the hash table
 ** in the first place - which is what reader one wants.  Meanwhile, the
@@ -247,6 +247,190 @@
 ** that correspond to frames greater than the new K value are removed
 ** from the hash table at this point.
 */
+
+/*
+** WAL2 NOTES
+**
+** This file also contains the implementation of "wal2" mode - activated
+** using "PRAGMA journal_mode = wal2". Wal2 mode is very similar to wal
+** mode, except that it uses two wal files instead of one. Under some
+** circumstances, wal2 mode provides more concurrency than legacy wal 
+** mode.
+**
+** THE PROBLEM WAL2 SOLVES:
+**
+** In legacy wal mode, if a writer wishes to write to the database while
+** a checkpoint is ongoing, it may append frames to the existing wal file.
+** This means that after the checkpoint has finished, the wal file consists
+** of a large block of checkpointed frames, followed by a block of
+** uncheckpointed frames. In a deployment that features a high volume of
+** write traffic, this may mean that the wal file is never completely
+** checkpointed. And so grows indefinitely.
+**
+** An alternative is to use "PRAGMA wal_checkpoint=RESTART" or similar to
+** force a complete checkpoint of the wal file. But this must:
+**
+**   1) Wait on all existing readers to finish,
+**   2) Wait on any existing writer, and then block all new writers,
+**   3) Do the checkpoint,
+**   4) Wait on any new readers that started during steps 2 and 3. Writers
+**      are still blocked during this step.
+**
+** This means that in order to avoid the wal file growing indefinitely 
+** in a busy system, writers must periodically pause to allow a checkpoint
+** to complete. In a system with long running readers, such pauses may be
+** for a non-trivial amount of time.
+**
+** OVERVIEW OF SOLUTION
+**
+** Wal2 mode uses two wal files. After writers have grown the first wal 
+** file to a pre-configured size, they begin appending transactions to 
+** the second wal file. Once all existing readers are reading snapshots
+** new enough to include the entire first wal file, a checkpointer can
+** checkpoint it.
+**
+** Meanwhile, writers are writing transactions to the second wal file.
+** Once that wal file has grown larger than the pre-configured size, each
+** new writer checks if:
+**
+**    * the first wal file has been checkpointed, and if so, if
+**    * there are no readers still reading from the first wal file (once
+**      it has been checkpointed, new readers read only from the second
+**      wal file).
+**
+** If both these conditions are true, the writer may switch back to the
+** first wal file. Eventually, a checkpointer can checkpoint the second
+** wal file, and so on.
+**
+** The wal file that writers are currently appending to (the one they
+** don't have to check the above two criteria before writing to) is called
+** the "current" wal file.
+**
+** The first wal file takes the same name as the wal file in legacy wal
+** mode systems - "<db>-wal". The second is named "<db>-wal2".
+**
+** CHECKPOINTS
+**
+** The "pre-configured size" mentioned above is the value set by 
+** "PRAGMA journal_size_limit". Or, if journal_size_limit is not set, 
+** 1000 pages.
+**
+** There is only a single type of checkpoint in wal2 mode (no "truncate",
+** "restart" etc.), and it always checkpoints the entire contents of a single
+** wal file. A wal file cannot be checkpointed until after a writer has written
+** the first transaction into the other wal file and all readers are reading a
+** snapshot that includes at least one transaction from the other wal file.
+**
+** The wal-hook, if one is registered, is invoked after a write-transaction
+** is committed, just as it is in legacy wal mode. The integer parameter
+** passed to the wal-hook is the total number of uncheckpointed frames in both
+** wal files. Except, the parameter is set to zero if there is no frames 
+** that may be checkpointed. This happens in two scenarios:
+**
+**   1. The "other" wal file (the one that the writer did not just append to)
+**      is completely empty, or
+**
+**   2. The "other" wal file (the one that the writer did not just append to)
+**      has already been checkpointed.
+**
+**
+** WAL FILE FORMAT
+**
+** The file format used for each wal file in wal2 mode is the same as for
+** legacy wal mode.  Except, the file format field is set to 3021000 
+** instead of 3007000.
+**
+** WAL-INDEX FORMAT
+**
+** The wal-index format is also very similar. Even though there are two
+** wal files, there is still a single wal-index shared-memory area (*-shm
+** file with the default unix or win32 VFS). The wal-index header is the
+** same size, with the following exceptions it has the same format:
+**
+**   * The version field is set to 3021000 instead of 3007000.
+**
+**   * An unused 32-bit field in the legacy wal-index header is
+**     now used to store (a) a single bit indicating which of the
+**     two wal files writers should append to and (b) the number
+**     of frames in the second wal file (31 bits).
+**
+** The first hash table in the wal-index contains entries corresponding
+** to the first HASHTABLE_NPAGE_ONE frames stored in the first wal file.
+** The second hash table in the wal-index contains entries indexing the
+** first HASHTABLE_NPAGE frames in the second wal file. The third hash
+** table contains the next HASHTABLE_NPAGE frames in the first wal file,
+** and so on.
+**
+** LOCKS
+**
+** Read-locks are simpler than for legacy wal mode. There are no locking
+** slots that contain frame numbers. Instead, there are four distinct
+** combinations of read locks a reader may hold:
+**
+**   WAL_LOCK_PART1:       "part" lock on first wal, none of second.
+**   WAL_LOCK_PART1_FULL2: "part" lock on first wal, "full" of second.
+**   WAL_LOCK_PART2: no lock on first wal, "part" lock on second.
+**   WAL_LOCK_PART2_FULL1: "full" lock on first wal, "part" lock on second.
+**
+** When a reader reads the wal-index header as part of opening a read
+** transaction, it takes a "part" lock on the current wal file. "Part" 
+** because the wal file may grow while the read transaction is active, in 
+** which case the reader would be reading only part of the wal file. 
+** A part lock prevents a checkpointer from checkpointing the wal file 
+** on which it is held.
+**
+** If there is data in the non-current wal file that has not been 
+** checkpointed, the reader takes a "full" lock on that wal file. A 
+** "full" lock indicates that the reader is using the entire wal file.
+** A full lock prevents a writer from overwriting the wal file on which
+** it is held, but does not prevent a checkpointer from checkpointing 
+** it.
+**
+** There is still a single WRITER and a single CHECKPOINTER lock. The
+** recovery procedure still takes the same exclusive lock on the entire
+** range of SQLITE_SHM_NLOCK shm-locks. This works because the read-locks
+** above use four of the six read-locking slots used by legacy wal mode.
+**
+** STARTUP/RECOVERY
+**
+** The read and write version fields of the database header in a wal2
+** database are set to 0x03, instead of 0x02 as in legacy wal mode.
+**
+** The wal file format used in wal2 mode is the same as the format used
+** in legacy wal mode. However, in order to support recovery, there are two
+** differences in the way wal file header fields are populated, as follows:
+**
+**   * When the first wal file is first created, the "nCkpt" field in
+**     the wal file header is set to 0. Thereafter, each time the writer
+**     switches wal file, it sets the nCkpt field in the new wal file
+**     header to ((nCkpt0 + 1) & 0x0F), where nCkpt0 is the value in
+**     the previous wal file header. This means that the first wal file
+**     always has an even value in the nCkpt field, and the second wal
+**     file always has an odd value.
+**
+**   * When a writer switches wal file, it sets the salt values in the
+**     new wal file to a copy of the checksum for the final frame in
+**     the previous wal file.
+**
+** Recovery proceeds as follows:
+**
+** 1. Each wal file is recovered separately. Except, if the first wal 
+**    file does not exist or is zero bytes in size, the second wal file
+**    is truncated to zero bytes before it is "recovered".
+**
+** 2. If both wal files contain valid headers, then the nCkpt fields
+**    are compared to see which of the two wal files is older. If the
+**    salt keys in the second wal file match the final frame checksum 
+**    in the older wal file, then both wal files are used. Otherwise,
+**    the newer wal file is ignored.
+**
+** 3. Or, if only one or neither of the wal files has a valid header, 
+**    then only a single or no wal files are recovered into the 
+**    reconstructed wal-index.
+**
+** Refer to header comments for walIndexRecover() for further details.
+*/
+
 #ifndef SQLITE_OMIT_WAL
 
 #include "wal.h"
@@ -262,20 +446,20 @@ int sqlite3WalTrace = 0;
 #endif
 
 /*
-** The maximum (and only) versions of the wal and wal-index formats
-** that may be interpreted by this version of SQLite.
-**
-** If a client begins recovering a WAL file and finds that (a) the checksum
-** values in the wal-header are correct and (b) the version field is not
-** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN.
-**
-** Similarly, if a client successfully reads a wal-index header (i.e. the
-** checksum test is successful) and finds that the version field is not
-** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
-** returns SQLITE_CANTOPEN.
+** Both the wal-file and the wal-index contain version fields 
+** indicating the current version of the system. If a client
+** reads the header of a wal file (as part of recovery), or the
+** wal-index (as part of opening a read transaction) and (a) the
+** header checksum is correct but (b) the version field is not
+** recognized, the operation fails with SQLITE_CANTOPEN.
+**
+** Currently, clients support both version-1 ("journal_mode=wal") and
+** version-2 ("journal_mode=wal2"). Legacy clients may support version-1
+** only.
 */
-#define WAL_MAX_VERSION      3007000
-#define WALINDEX_MAX_VERSION 3007000
+#define WAL_VERSION1 3007000      /* For "journal_mode=wal" */
+#define WAL_VERSION2 3021000      /* For "journal_mode=wal2" */
+
 
 /*
 ** Index numbers for various locking bytes.   WAL_NREADER is the number
@@ -298,6 +482,39 @@ int sqlite3WalTrace = 0;
 #define WAL_READ_LOCK(I)       (3+(I))
 #define WAL_NREADER            (SQLITE_SHM_NLOCK-3)
 
+/*
+** Values that may be stored in Wal.readLock in wal2 mode.
+**
+** In wal mode, the Wal.readLock member is set to -1 when no read-lock
+** is held, or else is the index of the read-mark on which a lock is
+** held.
+**
+** In wal2 mode, a value of -1 still indicates that no read-lock is held.
+** And a non-zero value still represents the index of the read-mark on
+** which a lock is held. There are two differences:
+**
+**   1. wal2 mode never uses read-mark 0.
+**
+**   2. locks on each read-mark have a different interpretation, as 
+**      indicated by the symbolic names below.
+*/
+#define WAL_LOCK_NONE        -1
+#define WAL_LOCK_PART1        1
+#define WAL_LOCK_PART1_FULL2  2
+#define WAL_LOCK_PART2_FULL1  3
+#define WAL_LOCK_PART2        4
+
+/* 
+** This constant is used in wal2 mode only.
+**
+** In wal2 mode, when committing a transaction, if the current wal file 
+** is sufficiently large and there are no conflicting locks held, the
+** writer writes the new transaction into the start of the other wal
+** file. Usually, "sufficiently large" is defined by the value configured
+** using "PRAGMA journal_size_limit". However, if no such value has been
+** configured, sufficiently large defaults to WAL_DEFAULT_WALSIZE frames.
+*/
+#define WAL_DEFAULT_WALSIZE 1000
 
 /* Object declarations */
 typedef struct WalIndexHdr WalIndexHdr;
@@ -317,21 +534,64 @@ typedef struct WalCkptInfo WalCkptInfo;
 ** The szPage value can be any power of 2 between 512 and 32768, inclusive.
 ** Or it can be 1 to represent a 65536-byte page.  The latter case was
 ** added in 3.7.1 when support for 64K pages was added.
+**
+** WAL2 mode notes: Member variable mxFrame2 is only used in wal2 mode
+** (when iVersion is set to WAL_VERSION2). The lower 31 bits store
+** the maximum frame number in file *-wal2. The most significant bit
+** is a flag - set if clients are currently appending to *-wal2, clear
+** otherwise.
 */
 struct WalIndexHdr {
   u32 iVersion;                   /* Wal-index version */
-  u32 unused;                     /* Unused (padding) field */
+  u32 mxFrame2;                   /* See "WAL2 mode notes" above */
   u32 iChange;                    /* Counter incremented each transaction */
   u8 isInit;                      /* 1 when initialized */
   u8 bigEndCksum;                 /* True if checksums in WAL are big-endian */
   u16 szPage;                     /* Database page size in bytes. 1==64K */
-  u32 mxFrame;                    /* Index of last valid frame in the WAL */
+  u32 mxFrame;                    /* Index of last valid frame in each WAL */
   u32 nPage;                      /* Size of database in pages */
   u32 aFrameCksum[2];             /* Checksum of last frame in log */
   u32 aSalt[2];                   /* Two salt values copied from WAL header */
   u32 aCksum[2];                  /* Checksum over all prior fields */
 };
 
+/*
+** The following macros and functions are get/set methods for the maximum
+** frame numbers and current wal file values stored in the WalIndexHdr
+** structure. These are helpful because of the unorthodox way in which
+** the values are stored in wal2 mode (see above). They are equivalent
+** to functions with the following signatures.
+**
+**   u32  walidxGetMxFrame(WalIndexHdr*, int iWal);          // get mxFrame
+**   void walidxSetMxFrame(WalIndexHdr*, int iWal, u32 val); // set mxFrame
+**   int  walidxGetFile(WalIndexHdr*)                        // get file
+**   void walidxSetFile(WalIndexHdr*, int val);              // set file
+*/
+#define walidxGetMxFrame(pHdr, iWal) \
+  ((iWal) ? ((pHdr)->mxFrame2 & 0x7FFFFFFF) : (pHdr)->mxFrame)
+
+static void walidxSetMxFrame(WalIndexHdr *pHdr, int iWal, u32 mxFrame){
+  if( iWal ){
+    pHdr->mxFrame2 = (pHdr->mxFrame2 & 0x80000000) | mxFrame;
+  }else{
+    pHdr->mxFrame = mxFrame;
+  }
+  assert( walidxGetMxFrame(pHdr, iWal)==mxFrame );
+}
+
+#define walidxGetFile(pHdr) (int)((pHdr)->mxFrame2 >> 31)
+
+#define walidxSetFile(pHdr, iWal) (                                          \
+    (pHdr)->mxFrame2 = ((pHdr)->mxFrame2 & 0x7FFFFFFF) | (((u32)(iWal))<<31) \
+)
+
+/*
+** Argument is a pointer to a Wal structure. Return true if the current
+** cache of the wal-index header indicates "journal_mode=wal2" mode, or
+** false otherwise.
+*/
+#define isWalMode2(pWal) ((pWal)->hdr.iVersion==WAL_VERSION2)
+
 /*
 ** A copy of the following object occurs in the wal-index immediately
 ** following the second copy of the WalIndexHdr.  This object stores
@@ -511,7 +771,7 @@ struct WalCkptInfo {
 struct Wal {
   sqlite3_vfs *pVfs;         /* The VFS used to create pDbFd */
   sqlite3_file *pDbFd;       /* File handle for the database file */
-  sqlite3_file *pWalFd;      /* File handle for WAL file */
+  sqlite3_file *apWalFd[2];  /* File handle for "*-wal" and "*-wal2" */
   u32 iCallback;             /* Value to pass to log callback (or 0) */
   i64 mxWalSize;             /* Truncate WAL to this size upon reset */
   int nWiData;               /* Size of array apWiData */
@@ -532,6 +792,7 @@ struct Wal {
   u32 minFrame;              /* Ignore wal frames before this one */
   u32 iReCksum;              /* On commit, recalculate checksums from here */
   const char *zWalName;      /* Name of WAL file */
+  const char *zWalName2;     /* Name of second WAL file */
   u32 nCkpt;                 /* Checkpoint sequence counter in the wal-header */
 #ifdef SQLITE_USE_SEH
   u32 lockMask;              /* Mask of locks held */
@@ -548,6 +809,8 @@ struct Wal {
   WalIndexHdr *pSnapshot;    /* Start transaction here if not NULL */
   int bGetSnapshot;          /* Transaction opened for sqlite3_get_snapshot() */
 #endif
+  int bClosing;              /* Set to true at start of sqlite3WalClose() */
+  int bWal2;                 /* bWal2 flag passed to WalOpen() */
 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
   sqlite3 *db;
 #endif
@@ -828,7 +1091,6 @@ static volatile WalCkptInfo *walCkptInfo(Wal *pWal){
 */
 static volatile WalIndexHdr *walIndexHdr(Wal *pWal){
   assert( pWal->nWiData>0 && pWal->apWiData[0] );
-  SEH_INJECT_FAULT;
   return (volatile WalIndexHdr*)pWal->apWiData[0];
 }
 
@@ -945,7 +1207,7 @@ static SQLITE_NO_TSAN void walIndexWriteHdr(Wal *pWal){
 
   assert( pWal->writeLock );
   pWal->hdr.isInit = 1;
-  pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
+  assert( pWal->hdr.iVersion==WAL_VERSION1||pWal->hdr.iVersion==WAL_VERSION2 );
   walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
   /* Possible TSAN false-positive.  See tag-20200519-1 */
   memcpy((void*)&aHdr[1], (const void*)&pWal->hdr, sizeof(WalIndexHdr));
@@ -1194,6 +1456,38 @@ static int walHashGet(
   return rc;
 }
 
+static u32 walExternalEncode(int iWal, u32 iFrame){
+  u32 iRet;
+  if( iWal ){
+    iRet = HASHTABLE_NPAGE_ONE + iFrame;
+    iRet += ((iFrame-1) / HASHTABLE_NPAGE) * HASHTABLE_NPAGE;
+  }else{
+    iRet = iFrame;
+    iFrame += HASHTABLE_NPAGE - HASHTABLE_NPAGE_ONE;
+    iRet += ((iFrame-1) / HASHTABLE_NPAGE) * HASHTABLE_NPAGE;
+  }
+  return iRet;
+}
+
+/*
+** Parameter iExternal is an external frame identifier. This function
+** transforms it to a wal file number (0 or 1) and frame number within
+** this wal file (reported via output parameter *piRead).
+*/
+static int walExternalDecode(u32 iExternal, u32 *piRead){
+  int iHash = (iExternal+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1)/HASHTABLE_NPAGE;
+
+  if( 0==(iHash & 0x01) ){
+    /* A frame in wal file 0 */
+    *piRead = (iExternal <= HASHTABLE_NPAGE_ONE) ? iExternal :
+      iExternal - (iHash/2) * HASHTABLE_NPAGE;
+    return 0;
+  }
+
+  *piRead = iExternal - HASHTABLE_NPAGE_ONE - ((iHash-1)/2) * HASHTABLE_NPAGE;
+  return 1;
+}
+
 /*
 ** Return the number of the wal-index page that contains the hash-table
 ** and page-number array that contain entries corresponding to WAL frame
@@ -1212,6 +1506,22 @@ static int walFramePage(u32 iFrame){
   return iHash;
 }
 
+/*
+** Return the index of the hash-table corresponding to frame iFrame of wal
+** file iWal.
+*/
+static int walFramePage2(int iWal, u32 iFrame){
+  int iRet;
+  assert( iWal==0 || iWal==1 );
+  assert( iFrame>0 );
+  if( iWal==0 ){
+    iRet = 2*((iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1)/HASHTABLE_NPAGE);
+  }else{
+    iRet = 1 + 2 * ((iFrame-1) / HASHTABLE_NPAGE);
+  }
+  return iRet;
+}
+
 /*
 ** Return the page number associated with frame iFrame in this WAL.
 */
@@ -1224,6 +1534,10 @@ static u32 walFramePgno(Wal *pWal, u32 iFrame){
   return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
 }
 
+static u32 walFramePgno2(Wal *pWal, int iWal, u32 iFrame){
+  return walFramePgno(pWal, walExternalEncode(iWal, iFrame));
+}
+
 /*
 ** Remove entries from the hash table that point to WAL slots greater
 ** than pWal->hdr.mxFrame.
@@ -1241,27 +1555,37 @@ static void walCleanupHash(Wal *pWal){
   int iLimit = 0;                 /* Zero values greater than this */
   int nByte;                      /* Number of bytes to zero in aPgno[] */
   int i;                          /* Used to iterate through aHash[] */
+  int iWal = walidxGetFile(&pWal->hdr);
+  u32 mxFrame = walidxGetMxFrame(&pWal->hdr, iWal);
+
+  u32 iExternal;
+  if( isWalMode2(pWal) ){
+    iExternal = walExternalEncode(iWal, mxFrame);
+  }else{
+    assert( iWal==0 );
+    iExternal = mxFrame;
+  }
 
   assert( pWal->writeLock );
-  testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
-  testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
-  testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
+  testcase( mxFrame==HASHTABLE_NPAGE_ONE-1 );
+  testcase( mxFrame==HASHTABLE_NPAGE_ONE );
+  testcase( mxFrame==HASHTABLE_NPAGE_ONE+1 );
 
-  if( pWal->hdr.mxFrame==0 ) return;
+  if( mxFrame==0 ) return;
 
   /* Obtain pointers to the hash-table and page-number array containing
   ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
   ** that the page said hash-table and array reside on is already mapped.(1)
   */
-  assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
-  assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
-  i = walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &sLoc);
+  assert( pWal->nWiData>walFramePage(iExternal) );
+  assert( pWal->apWiData[walFramePage(iExternal)] );
+  i = walHashGet(pWal, walFramePage(iExternal), &sLoc);
   if( NEVER(i) ) return; /* Defense-in-depth, in case (1) above is wrong */
 
   /* Zero all hash-table entries that correspond to frame numbers greater
   ** than pWal->hdr.mxFrame.
   */
-  iLimit = pWal->hdr.mxFrame - sLoc.iZero;
+  iLimit = iExternal - sLoc.iZero;
   assert( iLimit>0 );
   for(i=0; i<HASHTABLE_NSLOT; i++){
     if( sLoc.aHash[i]>iLimit ){
@@ -1293,16 +1617,23 @@ static void walCleanupHash(Wal *pWal){
 #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
 }
 
-
 /*
 ** Set an entry in the wal-index that will map database page number
 ** pPage into WAL frame iFrame.
 */
-static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
+static int walIndexAppend(Wal *pWal, int iWal, u32 iFrame, u32 iPage){
   int rc;                         /* Return code */
   WalHashLoc sLoc;                /* Wal-index hash table location */
+  u32 iExternal;
+  
+  if( isWalMode2(pWal) ){
+    iExternal = walExternalEncode(iWal, iFrame);
+  }else{
+    assert( iWal==0 );
+    iExternal = iFrame;
+  }
 
-  rc = walHashGet(pWal, walFramePage(iFrame), &sLoc);
+  rc = walHashGet(pWal, walFramePage(iExternal), &sLoc);
 
   /* Assuming the wal-index file was successfully mapped, populate the
   ** page number array and hash table entry.
@@ -1312,7 +1643,7 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     int idx;                      /* Value to write to hash-table slot */
     int nCollide;                 /* Number of hash collisions */
 
-    idx = iFrame - sLoc.iZero;
+    idx = iExternal - sLoc.iZero;
     assert( idx <= HASHTABLE_NSLOT/2 + 1 );
 
     /* If this is the first entry to be added to this hash-table, zero the
@@ -1376,6 +1707,215 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
   return rc;
 }
 
+/*
+** Recover a single wal file - *-wal if iWal==0, or *-wal2 if iWal==1.
+*/
+static int walIndexRecoverOne(Wal *pWal, int iWal, u32 *pnCkpt, int *pbZero){
+  i64 nSize;                      /* Size of log file */
+  u32 aFrameCksum[2] = {0, 0};
+  int rc;
+  sqlite3_file *pWalFd = pWal->apWalFd[iWal];
+
+  assert( iWal==0 || iWal==1 );
+
+  memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
+  rc = sqlite3OsFileSize(pWalFd, &nSize);
+  if( rc==SQLITE_OK ){
+    if( nSize>WAL_HDRSIZE ){
+      u8 aBuf[WAL_HDRSIZE];         /* Buffer to load WAL header into */
+      u32 *aPrivate = 0;            /* Heap copy of *-shm pg being populated */
+      u8 *aFrame = 0;               /* Malloc'd buffer to load entire frame */
+      int szFrame;                  /* Number of bytes in buffer aFrame[] */
+      u8 *aData;                    /* Pointer to data part of aFrame buffer */
+      int szPage;                   /* Page size according to the log */
+      u32 magic;                    /* Magic value read from WAL header */
+      u32 version;                  /* Magic value read from WAL header */
+      int isValid;                  /* True if this frame is valid */
+      int iPg;                      /* Current 32KB wal-index page */
+      int iLastFrame;               /* Last frame in wal, based on size alone */
+      int iLastPg;                  /* Last shm page used by this wal */
+  
+      /* Read in the WAL header. */
+      rc = sqlite3OsRead(pWalFd, aBuf, WAL_HDRSIZE, 0);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+  
+      /* If the database page size is not a power of two, or is greater than
+      ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid 
+      ** data. Similarly, if the 'magic' value is invalid, ignore the whole
+      ** WAL file.
+      */
+      magic = sqlite3Get4byte(&aBuf[0]);
+      szPage = sqlite3Get4byte(&aBuf[8]);
+      if( (magic&0xFFFFFFFE)!=WAL_MAGIC 
+       || szPage&(szPage-1) 
+       || szPage>SQLITE_MAX_PAGE_SIZE 
+       || szPage<512 
+      ){
+        return SQLITE_OK;
+      }
+      pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
+      pWal->szPage = szPage;
+  
+      /* Verify that the WAL header checksum is correct */
+      walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN, 
+          aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
+      );
+      if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
+       || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
+      ){
+        return SQLITE_OK;
+      }
+  
+      memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
+      *pnCkpt = sqlite3Get4byte(&aBuf[12]);
+  
+      /* Verify that the version number on the WAL format is one that
+      ** are able to understand */
+      version = sqlite3Get4byte(&aBuf[4]);
+      if( version!=WAL_VERSION1 && version!=WAL_VERSION2 ){
+        return SQLITE_CANTOPEN_BKPT;
+      }
+      pWal->hdr.iVersion = version;
+  
+      /* Malloc a buffer to read frames into. */
+      szFrame = szPage + WAL_FRAME_HDRSIZE;
+      aFrame = (u8 *)sqlite3_malloc64(szFrame + WALINDEX_PGSZ);
+      SEH_FREE_ON_ERROR(0, aFrame);
+      if( !aFrame ){
+        return SQLITE_NOMEM_BKPT;
+      }
+      aData = &aFrame[WAL_FRAME_HDRSIZE];
+      aPrivate = (u32*)&aData[szPage];
+  
+      /* Read all frames from the log file. */
+      iLastFrame = (nSize - WAL_HDRSIZE) / szFrame;
+      if( version==WAL_VERSION2 ){
+        iLastPg = walFramePage2(iWal, iLastFrame);
+      }else{
+        iLastPg = walFramePage(iLastFrame);
+      }
+      for(iPg=iWal; iPg<=iLastPg; iPg+=(version==WAL_VERSION2 ? 2 : 1)){
+        u32 *aShare;
+        int iFrame;                 /* Index of last frame read */
+        int iLast;
+        int iFirst;
+        int nHdr, nHdr32;
+
+        rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare);
+        assert( aShare!=0 || rc!=SQLITE_OK );
+        if( aShare==0 ) break;
+        SEH_SET_ON_ERROR(iPg, aShare);
+        pWal->apWiData[iPg] = aPrivate;
+
+        if( iWal ){
+          assert( version==WAL_VERSION2 );
+          iFirst = 1 + (iPg/2)*HASHTABLE_NPAGE;
+          iLast = iFirst + HASHTABLE_NPAGE - 1;
+        }else{
+          int i2 = (version==WAL_VERSION2) ? (iPg/2) : iPg;
+          iLast = HASHTABLE_NPAGE_ONE+i2*HASHTABLE_NPAGE;
+          iFirst = 1 + (i2==0?0:HASHTABLE_NPAGE_ONE+(i2-1)*HASHTABLE_NPAGE);
+        }
+        iLast = MIN(iLast, iLastFrame);
+
+        for(iFrame=iFirst; iFrame<=iLast; iFrame++){
+          i64 iOffset = walFrameOffset(iFrame, szPage);
+          u32 pgno;                 /* Database page number for frame */
+          u32 nTruncate;            /* dbsize field from frame header */
+
+          /* Read and decode the next log frame. */
+          rc = sqlite3OsRead(pWalFd, aFrame, szFrame, iOffset);
+          if( rc!=SQLITE_OK ) break;
+          isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
+          if( !isValid ) break;
+          rc = walIndexAppend(pWal, iWal, iFrame, pgno);
+          if( NEVER(rc!=SQLITE_OK) ) break;
+  
+          /* If nTruncate is non-zero, this is a commit record. */
+          if( nTruncate ){
+            pWal->hdr.mxFrame = iFrame;
+            pWal->hdr.nPage = nTruncate;
+            pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
+            testcase( szPage<=32768 );
+            testcase( szPage>=65536 );
+            aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
+            aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
+          }
+        }
+        pWal->apWiData[iPg] = aShare;
+        SEH_SET_ON_ERROR(0, 0);
+        nHdr = (iPg==0 ? WALINDEX_HDR_SIZE : 0);
+        nHdr32 = nHdr / sizeof(u32);
+#ifndef SQLITE_SAFER_WALINDEX_RECOVERY
+        /* Memcpy() should work fine here, on all reasonable implementations.
+        ** Technically, memcpy() might change the destination to some
+        ** intermediate value before setting to the final value, and that might
+        ** cause a concurrent reader to malfunction.  Memcpy() is allowed to
+        ** do that, according to the spec, but no memcpy() implementation that
+        ** we know of actually does that, which is why we say that memcpy()
+        ** is safe for this.  Memcpy() is certainly a lot faster.
+        */
+        memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr);
+#else
+        /* In the event that some platform is found for which memcpy()
+        ** changes the destination to some intermediate value before
+        ** setting the final value, this alternative copy routine is
+        ** provided.
+        */
+        {
+          int i;
+          for(i=nHdr32; i<WALINDEX_PGSZ/sizeof(u32); i++){
+            if( aShare[i]!=aPrivate[i] ){
+              /* Atomic memory operations are not required here because if
+              ** the value needs to be changed, that means it is not being
+              ** accessed concurrently. */
+              aShare[i] = aPrivate[i];
+            }
+          }
+        }
+#endif
+        SEH_INJECT_FAULT;
+        if( iFrame<=iLast ) break;
+      }
+  
+      SEH_FREE_ON_ERROR(aFrame, 0);
+      sqlite3_free(aFrame);
+    }else if( pbZero ){
+      *pbZero = 1;
+    }
+  }
+
+  pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
+  pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
+
+  return rc;
+}
+
+static int walOpenWal2(Wal *pWal){
+  int rc = SQLITE_OK;
+  if( !isOpen(pWal->apWalFd[1]) ){
+    int f = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
+    rc = sqlite3OsOpen(pWal->pVfs, pWal->zWalName2, pWal->apWalFd[1], f, &f);
+  }
+  return rc;
+}
+
+static int walTruncateWal2(Wal *pWal){
+  int bIs;
+  int rc;
+  assert( !isOpen(pWal->apWalFd[1]) );
+  rc = sqlite3OsAccess(pWal->pVfs, pWal->zWalName2, SQLITE_ACCESS_EXISTS, &bIs);
+  if( rc==SQLITE_OK && bIs ){
+    rc = walOpenWal2(pWal);
+    if( rc==SQLITE_OK ){
+      rc = sqlite3OsTruncate(pWal->apWalFd[1], 0);
+      sqlite3OsClose(pWal->apWalFd[1]);
+    }
+  }
+  return rc;
+}
 
 /*
 ** Recover the wal-index by reading the write-ahead log file.
@@ -1389,9 +1929,11 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
 */
 static int walIndexRecover(Wal *pWal){
   int rc;                         /* Return Code */
-  i64 nSize;                      /* Size of log file */
-  u32 aFrameCksum[2] = {0, 0};
   int iLock;                      /* Lock offset to lock for checkpoint */
+  u32 nCkpt1 = 0xFFFFFFFF;
+  u32 nCkpt2 = 0xFFFFFFFF;
+  int bZero = 0;
+  WalIndexHdr hdr;
 
   /* Obtain an exclusive lock on all byte in the locking range not already
   ** locked by the caller. The caller is guaranteed to have locked the
@@ -1411,164 +1953,92 @@ static int walIndexRecover(Wal *pWal){
 
   WALTRACE(("WAL%p: recovery begin...\n", pWal));
 
-  memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
-
-  rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
-  if( rc!=SQLITE_OK ){
-    goto recovery_error;
-  }
-
-  if( nSize>WAL_HDRSIZE ){
-    u8 aBuf[WAL_HDRSIZE];         /* Buffer to load WAL header into */
-    u32 *aPrivate = 0;            /* Heap copy of *-shm hash being populated */
-    u8 *aFrame = 0;               /* Malloc'd buffer to load entire frame */
-    int szFrame;                  /* Number of bytes in buffer aFrame[] */
-    u8 *aData;                    /* Pointer to data part of aFrame buffer */
-    int szPage;                   /* Page size according to the log */
-    u32 magic;                    /* Magic value read from WAL header */
-    u32 version;                  /* Magic value read from WAL header */
-    int isValid;                  /* True if this frame is valid */
-    u32 iPg;                      /* Current 32KB wal-index page */
-    u32 iLastFrame;               /* Last frame in wal, based on nSize alone */
-
-    /* Read in the WAL header. */
-    rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
-    if( rc!=SQLITE_OK ){
-      goto recovery_error;
-    }
-
-    /* If the database page size is not a power of two, or is greater than
-    ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid
-    ** data. Similarly, if the 'magic' value is invalid, ignore the whole
-    ** WAL file.
-    */
-    magic = sqlite3Get4byte(&aBuf[0]);
-    szPage = sqlite3Get4byte(&aBuf[8]);
-    if( (magic&0xFFFFFFFE)!=WAL_MAGIC
-     || szPage&(szPage-1)
-     || szPage>SQLITE_MAX_PAGE_SIZE
-     || szPage<512
-    ){
-      goto finished;
+  /* Recover the *-wal file. If a valid version-1 header is recovered
+  ** from it, do not open the *-wal2 file. Even if it exists.
+  **
+  ** Otherwise, if the *-wal2 file exists or if the "wal2" flag was 
+  ** specified when sqlite3WalOpen() was called, open and recover
+  ** the *-wal2 file. Except, if the *-wal file was zero bytes in size,
+  ** truncate the *-wal2 to zero bytes in size.
+  **
+  ** After this block has run, if the *-wal2 file is open the system
+  ** starts up in VERSION2 mode. In this case pWal->hdr contains the 
+  ** wal-index header considering only *-wal2. Stack variable hdr
+  ** contains the wal-index header considering only *-wal. The hash 
+  ** tables are populated for both.  
+  **
+  ** Or, if the *-wal2 file is not open, start up in VERSION1 mode.
+  ** pWal->hdr is already populated.
+  */
+  rc = walIndexRecoverOne(pWal, 0, &nCkpt1, &bZero);
+  assert( pWal->hdr.iVersion==0 
+      || pWal->hdr.iVersion==WAL_VERSION1 
+      || pWal->hdr.iVersion==WAL_VERSION2 
+  );
+  if( rc==SQLITE_OK && bZero ){
+    rc = walTruncateWal2(pWal);
+  }
+  if( rc==SQLITE_OK && pWal->hdr.iVersion!=WAL_VERSION1 ){
+    int bOpen = 1;
+    sqlite3_vfs *pVfs = pWal->pVfs;
+    if( pWal->hdr.iVersion==0 && pWal->bWal2==0 ){
+      rc = sqlite3OsAccess(pVfs, pWal->zWalName2, SQLITE_ACCESS_EXISTS, &bOpen);
     }
-    pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
-    pWal->szPage = szPage;
-    pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
-    memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
-
-    /* Verify that the WAL header checksum is correct */
-    walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,
-        aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
-    );
-    if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
-     || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
-    ){
-      goto finished;
+    if( rc==SQLITE_OK && bOpen ){
+      rc = walOpenWal2(pWal);
+      if( rc==SQLITE_OK ){
+        hdr = pWal->hdr;
+        rc = walIndexRecoverOne(pWal, 1, &nCkpt2, 0);
+      }
     }
+  }
 
-    /* Verify that the version number on the WAL format is one that
-    ** are able to understand */
-    version = sqlite3Get4byte(&aBuf[4]);
-    if( version!=WAL_MAX_VERSION ){
-      rc = SQLITE_CANTOPEN_BKPT;
-      goto finished;
-    }
+  if( rc==SQLITE_OK ){
+    volatile WalCkptInfo *pInfo;
 
-    /* Malloc a buffer to read frames into. */
-    szFrame = szPage + WAL_FRAME_HDRSIZE;
-    aFrame = (u8 *)sqlite3_malloc64(szFrame + WALINDEX_PGSZ);
-    SEH_FREE_ON_ERROR(0, aFrame);
-    if( !aFrame ){
-      rc = SQLITE_NOMEM_BKPT;
-      goto recovery_error;
-    }
-    aData = &aFrame[WAL_FRAME_HDRSIZE];
-    aPrivate = (u32*)&aData[szPage];
-
-    /* Read all frames from the log file. */
-    iLastFrame = (nSize - WAL_HDRSIZE) / szFrame;
-    for(iPg=0; iPg<=(u32)walFramePage(iLastFrame); iPg++){
-      u32 *aShare;
-      u32 iFrame;                 /* Index of last frame read */
-      u32 iLast = MIN(iLastFrame, HASHTABLE_NPAGE_ONE+iPg*HASHTABLE_NPAGE);
-      u32 iFirst = 1 + (iPg==0?0:HASHTABLE_NPAGE_ONE+(iPg-1)*HASHTABLE_NPAGE);
-      u32 nHdr, nHdr32;
-      rc = walIndexPage(pWal, iPg, (volatile u32**)&aShare);
-      assert( aShare!=0 || rc!=SQLITE_OK );
-      if( aShare==0 ) break;
-      SEH_SET_ON_ERROR(iPg, aShare);
-      pWal->apWiData[iPg] = aPrivate;
-
-      for(iFrame=iFirst; iFrame<=iLast; iFrame++){
-        i64 iOffset = walFrameOffset(iFrame, szPage);
-        u32 pgno;                 /* Database page number for frame */
-        u32 nTruncate;            /* dbsize field from frame header */
-
-        /* Read and decode the next log frame. */
-        rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
-        if( rc!=SQLITE_OK ) break;
-        isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
-        if( !isValid ) break;
-        rc = walIndexAppend(pWal, iFrame, pgno);
-        if( NEVER(rc!=SQLITE_OK) ) break;
-
-        /* If nTruncate is non-zero, this is a commit record. */
-        if( nTruncate ){
-          pWal->hdr.mxFrame = iFrame;
-          pWal->hdr.nPage = nTruncate;
-          pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
-          testcase( szPage<=32768 );
-          testcase( szPage>=65536 );
-          aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
-          aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
+    if( isOpen(pWal->apWalFd[1]) ){
+      /* The case where *-wal2 may follow *-wal */
+      if( nCkpt2<=0x0F && nCkpt2==nCkpt1+1 ){
+        if( pWal->hdr.mxFrame
+         && sqlite3Get4byte((u8*)(&pWal->hdr.aSalt[0]))==hdr.aFrameCksum[0]
+         && sqlite3Get4byte((u8*)(&pWal->hdr.aSalt[1]))==hdr.aFrameCksum[1]
+        ){
+          walidxSetFile(&pWal->hdr, 1);
+          walidxSetMxFrame(&pWal->hdr, 1, pWal->hdr.mxFrame);
+          walidxSetMxFrame(&pWal->hdr, 0, hdr.mxFrame);
+        }else{
+          pWal->hdr = hdr;
         }
-      }
-      pWal->apWiData[iPg] = aShare;
-      SEH_SET_ON_ERROR(0,0);
-      nHdr = (iPg==0 ? WALINDEX_HDR_SIZE : 0);
-      nHdr32 = nHdr / sizeof(u32);
-#ifndef SQLITE_SAFER_WALINDEX_RECOVERY
-      /* Memcpy() should work fine here, on all reasonable implementations.
-      ** Technically, memcpy() might change the destination to some
-      ** intermediate value before setting to the final value, and that might
-      ** cause a concurrent reader to malfunction.  Memcpy() is allowed to
-      ** do that, according to the spec, but no memcpy() implementation that
-      ** we know of actually does that, which is why we say that memcpy()
-      ** is safe for this.  Memcpy() is certainly a lot faster.
-      */
-      memcpy(&aShare[nHdr32], &aPrivate[nHdr32], WALINDEX_PGSZ-nHdr);
-#else
-      /* In the event that some platform is found for which memcpy()
-      ** changes the destination to some intermediate value before
-      ** setting the final value, this alternative copy routine is
-      ** provided.
-      */
-      {
-        int i;
-        for(i=nHdr32; i<WALINDEX_PGSZ/sizeof(u32); i++){
-          if( aShare[i]!=aPrivate[i] ){
-            /* Atomic memory operations are not required here because if
-            ** the value needs to be changed, that means it is not being
-            ** accessed concurrently. */
-            aShare[i] = aPrivate[i];
-          }
+      }else
+
+      /* When *-wal may follow *-wal2 */
+      if( (nCkpt2==0x0F && nCkpt1==0) || (nCkpt2<0x0F && nCkpt2==nCkpt1-1) ){
+        if( hdr.mxFrame
+         && sqlite3Get4byte((u8*)(&hdr.aSalt[0]))==pWal->hdr.aFrameCksum[0]
+         && sqlite3Get4byte((u8*)(&hdr.aSalt[1]))==pWal->hdr.aFrameCksum[1]
+        ){
+          SWAP(WalIndexHdr, pWal->hdr, hdr);
+          walidxSetMxFrame(&pWal->hdr, 1, hdr.mxFrame);
+        }else{
+          walidxSetFile(&pWal->hdr, 1);
+          walidxSetMxFrame(&pWal->hdr, 1, pWal->hdr.mxFrame);
+          walidxSetMxFrame(&pWal->hdr, 0, 0);
         }
+      }else
+
+      /* Fallback */
+      if( nCkpt1<=nCkpt2 ){
+        pWal->hdr = hdr;
+      }else{
+        walidxSetFile(&pWal->hdr, 1);
+        walidxSetMxFrame(&pWal->hdr, 1, pWal->hdr.mxFrame);
+        walidxSetMxFrame(&pWal->hdr, 0, 0);
       }
-#endif
-      SEH_INJECT_FAULT;
-      if( iFrame<=iLast ) break;
+      pWal->hdr.iVersion = WAL_VERSION2;
+    }else{
+      pWal->hdr.iVersion = WAL_VERSION1;
     }
 
-    SEH_FREE_ON_ERROR(aFrame, 0);
-    sqlite3_free(aFrame);
-  }
-
-finished:
-  if( rc==SQLITE_OK ){
-    volatile WalCkptInfo *pInfo;
-    int i;
-    pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
-    pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
     walIndexWriteHdr(pWal);
 
     /* Reset the checkpoint-header. This is safe because this thread is
@@ -1576,45 +2046,53 @@ static int walIndexRecover(Wal *pWal){
     ** checkpointers. Then set the values of read-mark slots 1 through N.
     */
     pInfo = walCkptInfo(pWal);
-    pInfo->nBackfill = 0;
-    pInfo->nBackfillAttempted = pWal->hdr.mxFrame;
-    pInfo->aReadMark[0] = 0;
-    for(i=1; i<WAL_NREADER; i++){
-      rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
-      if( rc==SQLITE_OK ){
-        if( i==1 && pWal->hdr.mxFrame ){
-          pInfo->aReadMark[i] = pWal->hdr.mxFrame;
-        }else{
-          pInfo->aReadMark[i] = READMARK_NOT_USED;
+    memset((void*)pInfo, 0, sizeof(WalCkptInfo));
+    if( 0==isWalMode2(pWal) ){
+      int i;
+      pInfo->nBackfillAttempted = pWal->hdr.mxFrame;
+      pInfo->aReadMark[0] = 0;
+      for(i=1; i<WAL_NREADER; i++){
+        rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
+        if( rc==SQLITE_OK ){
+          if( i==1 && pWal->hdr.mxFrame ){
+            pInfo->aReadMark[i] = pWal->hdr.mxFrame;
+          }else{
+            pInfo->aReadMark[i] = READMARK_NOT_USED;
+          }
+          walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
+        }else if( rc!=SQLITE_BUSY ){
+          break;
         }
-        SEH_INJECT_FAULT;
-        walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
-      }else if( rc!=SQLITE_BUSY ){
-        goto recovery_error;
       }
     }
 
     /* If more than one frame was recovered from the log file, report an
     ** event via sqlite3_log(). This is to help with identifying performance
     ** problems caused by applications routinely shutting down without
-    ** checkpointing the log file.
-    */
+    ** checkpointing the log file.  */
     if( pWal->hdr.nPage ){
-      sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,
-          "recovered %d frames from WAL file %s",
-          pWal->hdr.mxFrame, pWal->zWalName
-      );
+      if( isWalMode2(pWal) ){
+        sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,
+            "recovered (%d,%d) frames from WAL files %s[2] (wal2 mode)",
+            walidxGetMxFrame(&pWal->hdr, 0), walidxGetMxFrame(&pWal->hdr, 1), 
+            pWal->zWalName
+        );
+      }else{
+        sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,
+            "recovered %d frames from WAL file %s",
+            pWal->hdr.mxFrame, pWal->zWalName
+        );
+      }
     }
   }
 
-recovery_error:
   WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));
   walUnlockExclusive(pWal, iLock, WAL_READ_LOCK(0)-iLock);
   return rc;
 }
 
 /*
-** Close an open wal-index.
+** Close an open wal-index and wal files.
 */
 static void walIndexClose(Wal *pWal, int isDelete){
   if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE || pWal->bShmUnreliable ){
@@ -1627,6 +2105,8 @@ static void walIndexClose(Wal *pWal, int isDelete){
   if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
     sqlite3OsShmUnmap(pWal->pDbFd, isDelete);
   }
+  sqlite3OsClose(pWal->apWalFd[0]);
+  sqlite3OsClose(pWal->apWalFd[1]);
 }
 
 /*
@@ -1650,11 +2130,13 @@ int sqlite3WalOpen(
   const char *zWalName,           /* Name of the WAL file */
   int bNoShm,                     /* True to run in heap-memory mode */
   i64 mxWalSize,                  /* Truncate WAL to this size on reset */
+  int bWal2,                      /* True to open in wal2 mode */
   Wal **ppWal                     /* OUT: Allocated Wal handle */
 ){
   int rc;                         /* Return Code */
   Wal *pRet;                      /* Object to allocate and return */
   int flags;                      /* Flags passed to OsOpen() */
+  int nByte;                      /* Bytes of space to allocate */
 
   assert( zWalName && zWalName[0] );
   assert( pDbFd );
@@ -1703,34 +2185,37 @@ int sqlite3WalOpen(
   assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
 #endif
 
+  nByte = sizeof(Wal) + pVfs->szOsFile*2;
 
   /* Allocate an instance of struct Wal to return. */
   *ppWal = 0;
-  pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);
+  pRet = (Wal*)sqlite3MallocZero(nByte);
   if( !pRet ){
     return SQLITE_NOMEM_BKPT;
   }
 
   pRet->pVfs = pVfs;
-  pRet->pWalFd = (sqlite3_file *)&pRet[1];
+  pRet->apWalFd[0] = (sqlite3_file*)((char*)pRet+sizeof(Wal));
+  pRet->apWalFd[1] = (sqlite3_file*)((char*)pRet+sizeof(Wal)+pVfs->szOsFile);
   pRet->pDbFd = pDbFd;
-  pRet->readLock = -1;
+  pRet->readLock = WAL_LOCK_NONE;
   pRet->mxWalSize = mxWalSize;
   pRet->zWalName = zWalName;
   pRet->syncHeader = 1;
   pRet->padToSectorBoundary = 1;
   pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);
+  pRet->bWal2 = bWal2;
+  pRet->zWalName2 = &zWalName[sqlite3Strlen30(zWalName)+1];
 
-  /* Open file handle on the write-ahead log file. */
+  /* Open a file handle on the first write-ahead log file. */
   flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
-  rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
+  rc = sqlite3OsOpen(pVfs, zWalName, pRet->apWalFd[0], flags, &flags);
   if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
     pRet->readOnly = WAL_RDONLY;
   }
 
   if( rc!=SQLITE_OK ){
     walIndexClose(pRet, 0);
-    sqlite3OsClose(pRet->pWalFd);
     sqlite3_free(pRet);
   }else{
     int iDC = sqlite3OsDeviceCharacteristics(pDbFd);
@@ -1940,34 +2425,50 @@ static void walIteratorFree(WalIterator *p){
 
 /*
 ** Construct a WalInterator object that can be used to loop over all
-** pages in the WAL following frame nBackfill in ascending order. Frames
+** pages in wal file iWal following frame nBackfill in ascending order. Frames
 ** nBackfill or earlier may be included - excluding them is an optimization
 ** only. The caller must hold the checkpoint lock.
 **
-** On success, make *pp point to the newly allocated WalInterator object
-** return SQLITE_OK. Otherwise, return an error code. If this routine
-** returns an error, the value of *pp is undefined.
+** On success, make *pp point to the newly allocated WalIterator object
+** and return SQLITE_OK. Otherwise, return an error code. If this routine
+** returns an error, the final value of *pp is undefined.
 **
 ** The calling routine should invoke walIteratorFree() to destroy the
 ** WalIterator object when it has finished with it.
 */
-static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
+static int walIteratorInit(
+  Wal *pWal, 
+  int iWal, 
+  u32 nBackfill, 
+  WalIterator **pp
+){
   WalIterator *p;                 /* Return value */
   int nSegment;                   /* Number of segments to merge */
   u32 iLast;                      /* Last frame in log */
   sqlite3_int64 nByte;            /* Number of bytes to allocate */
   int i;                          /* Iterator variable */
+  int iLastSeg;                   /* Last hash table to iterate though */
   ht_slot *aTmp;                  /* Temp space used by merge-sort */
   int rc = SQLITE_OK;             /* Return Code */
+  int iMode = isWalMode2(pWal) ? 2 : 1;
+
+  assert( isWalMode2(pWal) || iWal==0 );
+  assert( 0==isWalMode2(pWal) || nBackfill==0 );
 
   /* This routine only runs while holding the checkpoint lock. And
   ** it only runs if there is actually content in the log (mxFrame>0).
   */
-  assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
-  iLast = pWal->hdr.mxFrame;
+  iLast = walidxGetMxFrame(&pWal->hdr, iWal);
+  assert( pWal->ckptLock && iLast>0 );
+
+  if( iMode==2 ){
+    iLastSeg = walFramePage2(iWal, iLast);
+  }else{
+    iLastSeg = walFramePage(iLast);
+  }
+  nSegment = 1 + (iLastSeg/iMode);
 
   /* Allocate space for the WalIterator object. */
-  nSegment = walFramePage(iLast) + 1;
   nByte = SZ_WALITERATOR(nSegment)
         + iLast*sizeof(ht_slot);
   p = (WalIterator *)sqlite3_malloc64(nByte
@@ -1980,7 +2481,8 @@ static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
   p->nSegment = nSegment;
   aTmp = (ht_slot*)&(((u8*)p)[nByte]);
   SEH_FREE_ON_ERROR(0, p);
-  for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
+  i = iMode==2 ? iWal : walFramePage(nBackfill+1);
+  for(; rc==SQLITE_OK && i<=iLastSeg; i+=iMode){
     WalHashLoc sLoc;
 
     rc = walHashGet(pWal, i, &sLoc);
@@ -1988,23 +2490,32 @@ static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
       int j;                      /* Counter variable */
       int nEntry;                 /* Number of entries in this segment */
       ht_slot *aIndex;            /* Sorted index for this segment */
+      u32 iZero;
 
-      if( (i+1)==nSegment ){
-        nEntry = (int)(iLast - sLoc.iZero);
+      if( iMode==2 ){
+        walExternalDecode(sLoc.iZero+1, &iZero);
+        iZero--;
+        assert( iZero==0 || i>=2 );
+      }else{
+        iZero = sLoc.iZero;
+      }
+
+      if( i==iLastSeg ){
+        nEntry = (int)(iLast - iZero);
       }else{
         nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno);
       }
-      aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero];
-      sLoc.iZero++;
+      aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
+      iZero++;
 
       for(j=0; j<nEntry; j++){
         aIndex[j] = (ht_slot)j;
       }
-      walMergesort((u32 *)sLoc.aPgno, aTmp, aIndex, &nEntry);
-      p->aSegment[i].iZero = sLoc.iZero;
-      p->aSegment[i].nEntry = nEntry;
-      p->aSegment[i].aIndex = aIndex;
-      p->aSegment[i].aPgno = (u32 *)sLoc.aPgno;
+      walMergesort((u32*)sLoc.aPgno, aTmp, aIndex, &nEntry);
+      p->aSegment[i/iMode].iZero = iZero;
+      p->aSegment[i/iMode].nEntry = nEntry;
+      p->aSegment[i/iMode].aIndex = aIndex;
+      p->aSegment[i/iMode].aPgno = (u32*)sLoc.aPgno;
     }
   }
   if( rc!=SQLITE_OK ){
@@ -2153,6 +2664,7 @@ static void walRestartHdr(Wal *pWal, u32 salt1){
   volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
   int i;                          /* Loop counter */
   u32 *aSalt = pWal->hdr.aSalt;   /* Big-endian salt values */
+  assert( isWalMode2(pWal)==0 );
   pWal->nCkpt++;
   pWal->hdr.mxFrame = 0;
   sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0]));
@@ -2165,6 +2677,68 @@ static void walRestartHdr(Wal *pWal, u32 salt1){
   assert( pInfo->aReadMark[0]==0 );
 }
 
+/*
+** This function is used in wal2 mode.
+**
+** This function is called when writer pWal is just about to start 
+** writing out frames. Parameter iApp is the current wal file. The "other" wal
+** file (wal file !iApp) has been fully checkpointed. This function returns
+** SQLITE_OK if there are no readers preventing the writer from switching to
+** the other wal file. Or SQLITE_BUSY if there are.
+*/
+static int wal2RestartOk(Wal *pWal, int iApp){
+  /* The other wal file (wal file !iApp) can be overwritten if there
+  ** are no readers reading from it - no "full" or "partial" locks.
+  ** Technically speaking it is not possible for any reader to hold
+  ** a "part" lock, as this would have prevented the file from being
+  ** checkpointed. But checking anyway doesn't hurt. The following
+  ** is equivalent to:
+  **
+  **   if( iApp==0 ) eLock = WAL_LOCK_PART1_FULL2;
+  **   if( iApp==1 ) eLock = WAL_LOCK_PART1;
+  */
+  int eLock = 1 + (iApp==0);
+
+  assert( WAL_LOCK_PART1==1 );
+  assert( WAL_LOCK_PART1_FULL2==2 );
+  assert( WAL_LOCK_PART2_FULL1==3 );
+  assert( WAL_LOCK_PART2==4 );
+
+  assert( iApp!=0 || eLock==WAL_LOCK_PART1_FULL2 );
+  assert( iApp!=1 || eLock==WAL_LOCK_PART1 );
+
+  return walLockExclusive(pWal, WAL_READ_LOCK(eLock), 3);
+}
+static void wal2RestartFinished(Wal *pWal, int iApp){
+  walUnlockExclusive(pWal, WAL_READ_LOCK(1 + (iApp==0)), 3);
+}
+
+/*
+** This function is used in wal2 mode.
+**
+** This function is called when a checkpointer wishes to checkpoint wal
+** file iCkpt. It takes the required lock and, if successful, returns
+** SQLITE_OK. Otherwise, an SQLite error code (e.g. SQLITE_BUSY). If this
+** function returns SQLITE_OK, it is the responsibility of the caller
+** to invoke wal2CheckpointFinished() to release the lock.
+*/
+static int wal2CheckpointOk(Wal *pWal, int iCkpt){
+  int eLock = 1 + (iCkpt*2);
+
+  assert( WAL_LOCK_PART1==1 );
+  assert( WAL_LOCK_PART1_FULL2==2 );
+  assert( WAL_LOCK_PART2_FULL1==3 );
+  assert( WAL_LOCK_PART2==4 );
+
+  assert( iCkpt!=0 || eLock==WAL_LOCK_PART1 );
+  assert( iCkpt!=1 || eLock==WAL_LOCK_PART2_FULL1 );
+
+  return walLockExclusive(pWal, WAL_READ_LOCK(eLock), 2);
+}
+static void wal2CheckpointFinished(Wal *pWal, int iCkpt){
+  walUnlockExclusive(pWal, WAL_READ_LOCK(1 + (iCkpt*2)), 2);
+}
+
 /*
 ** Copy as much content as we can from the WAL back into the database file
 ** in response to an sqlite3_wal_checkpoint() request or the equivalent.
@@ -2214,52 +2788,71 @@ static int walCheckpoint(
   u32 mxPage;                     /* Max database page to write */
   int i;                          /* Loop counter */
   volatile WalCkptInfo *pInfo;    /* The checkpoint status information */
+  int bWal2 = isWalMode2(pWal);   /* True for wal2 connections */
+  int iCkpt = bWal2 ? !walidxGetFile(&pWal->hdr) : 0;
 
+  mxSafeFrame = walidxGetMxFrame(&pWal->hdr, iCkpt);
   szPage = walPagesize(pWal);
   testcase( szPage<=32768 );
   testcase( szPage>=65536 );
   pInfo = walCkptInfo(pWal);
-  if( pInfo->nBackfill<pWal->hdr.mxFrame ){
+  if( (bWal2==1 && pInfo->nBackfill==0 && mxSafeFrame) 
+   || (bWal2==0 && pInfo->nBackfill<mxSafeFrame)
+  ){
+    sqlite3_file *pWalFd = pWal->apWalFd[iCkpt];
+    mxPage = pWal->hdr.nPage;
+
+    /* If this is a wal2 system, check for a reader holding a lock 
+    ** preventing this checkpoint operation. If one is found, return
+    ** early.  */
+    if( bWal2 ){
+      rc = wal2CheckpointOk(pWal, iCkpt);
+      if( rc!=SQLITE_OK ) return rc;
+    }
 
     /* EVIDENCE-OF: R-62920-47450 The busy-handler callback is never invoked
     ** in the SQLITE_CHECKPOINT_PASSIVE mode. */
     assert( eMode!=SQLITE_CHECKPOINT_PASSIVE || xBusy==0 );
 
-    /* Compute in mxSafeFrame the index of the last frame of the WAL that is
-    ** safe to write into the database.  Frames beyond mxSafeFrame might
-    ** overwrite database pages that are in use by active readers and thus
-    ** cannot be backfilled from the WAL.
+    /* If this is a wal system (not wal2), compute in mxSafeFrame the index 
+    ** of the last frame of the WAL that is safe to write into the database.
+    ** Frames beyond mxSafeFrame might overwrite database pages that are in 
+    ** use by active readers and thus cannot be backfilled from the WAL.
     */
-    mxSafeFrame = pWal->hdr.mxFrame;
-    mxPage = pWal->hdr.nPage;
-    for(i=1; i<WAL_NREADER; i++){
-      u32 y = AtomicLoad(pInfo->aReadMark+i); SEH_INJECT_FAULT;
-      if( mxSafeFrame>y ){
-        assert( y<=pWal->hdr.mxFrame );
-        rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
-        if( rc==SQLITE_OK ){
-          u32 iMark = (i==1 ? mxSafeFrame : READMARK_NOT_USED);
-          AtomicStore(pInfo->aReadMark+i, iMark); SEH_INJECT_FAULT;
-          walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
-        }else if( rc==SQLITE_BUSY ){
-          mxSafeFrame = y;
-          xBusy = 0;
-        }else{
-          goto walcheckpoint_out;
+    if( bWal2==0 ){
+      mxSafeFrame = pWal->hdr.mxFrame;
+      mxPage = pWal->hdr.nPage;
+      for(i=1; i<WAL_NREADER; i++){
+        u32 y = AtomicLoad(pInfo->aReadMark+i); SEH_INJECT_FAULT;
+        if( mxSafeFrame>y ){
+          assert( y<=pWal->hdr.mxFrame );
+          rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
+          if( rc==SQLITE_OK ){
+            u32 iMark = (i==1 ? mxSafeFrame : READMARK_NOT_USED);
+            AtomicStore(pInfo->aReadMark+i, iMark); SEH_INJECT_FAULT;
+            walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
+          }else if( rc==SQLITE_BUSY ){
+            mxSafeFrame = y;
+            xBusy = 0;
+          }else{
+            goto walcheckpoint_out;
+          }
         }
       }
     }
 
     /* Allocate the iterator */
-    if( pInfo->nBackfill<mxSafeFrame ){
-      rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
+    if( bWal2 || pInfo->nBackfill<mxSafeFrame ){
+      assert( bWal2==0 || pInfo->nBackfill==0 );
+      rc = walIteratorInit(pWal, iCkpt, pInfo->nBackfill, &pIter);
       assert( rc==SQLITE_OK || pIter==0 );
     }
 
-    if( pIter
-     && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
-    ){
+    if( pIter && (bWal2 
+     || (rc = walBusyLock(pWal, xBusy, pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
+    )){
       u32 nBackfill = pInfo->nBackfill;
+      assert( bWal2==0 || nBackfill==0 );
       WalIndexHdr *pLive = (WalIndexHdr*)walIndexHdr(pWal);
 
       /* Now that read-lock slot 0 is locked, check that the wal has not been
@@ -2268,13 +2861,17 @@ static int walCheckpoint(
       ** (pInfo->nBackfill<pWal->hdr.mxFrame) test above only passed because
       ** pInfo->nBackfill had already been set to 0 by the writer that wrapped
       ** the wal file. It would also be dangerous to proceed, as there may be
-      ** fewer than pWal->hdr.mxFrame valid frames in the wal file.  */
+      ** fewer than pWal->hdr.mxFrame valid frames in the wal file. 
+      **
+      ** This check is not required in wal mode, as the checkpointer has
+      ** and writers never operate on the same file. And are prevented by
+      ** locks from doing so. But it does not hurt to leave it in.  */
       int bChg = memcmp(pLive->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt));
       if( 0==bChg ){
         pInfo->nBackfillAttempted = mxSafeFrame; SEH_INJECT_FAULT;
   
-        /* Sync the WAL to disk */
-        rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
+        /* Sync the wal file being checkpointed to disk */
+        rc = sqlite3OsSync(pWalFd, CKPT_SYNC_FLAGS(sync_flags));
   
         /* If the database may grow as a result of this checkpoint, hint
         ** about the eventual size of the db file to the VFS layer.
@@ -2285,11 +2882,13 @@ static int walCheckpoint(
           sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0);
           rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
           if( rc==SQLITE_OK && nSize<nReq ){
-            if( (nSize+65536+(i64)pWal->hdr.mxFrame*szPage)<nReq ){
+            i64 mx = pWal->hdr.mxFrame + (bWal2?walidxGetMxFrame(&pWal->hdr,1):0);
+          if( (nSize+65536+mx*szPage)<nReq ){
               /* If the size of the final database is larger than the current
               ** database plus the amount of data in the wal file, plus the
               ** maximum size of the pending-byte page (65536 bytes), then
-              ** must be corruption somewhere.  */
+              ** must be corruption somewhere.  Or in the case of wal2 mode,
+            ** plus the amount of data in both wal files. */
               rc = SQLITE_CORRUPT_BKPT;
             }else{
               sqlite3OsFileControlHint(
@@ -2303,8 +2902,10 @@ static int walCheckpoint(
         ** db file */
         while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
           i64 iOffset;
-          assert( walFramePgno(pWal, iFrame)==iDbpage );
-          SEH_INJECT_FAULT;
+          assert( bWal2==1 || walFramePgno(pWal, iFrame)==iDbpage );
+          assert( bWal2==0 || walFramePgno2(pWal, iCkpt, iFrame)==iDbpage );
+
+        SEH_INJECT_FAULT;
           if( AtomicLoad(&db->u1.isInterrupted) ){
             rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT;
             break;
@@ -2314,7 +2915,7 @@ static int walCheckpoint(
           }
           iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
           /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
-          rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
+          rc = sqlite3OsRead(pWalFd, zBuf, szPage, iOffset);
           if( rc!=SQLITE_OK ) break;
           iOffset = (iDbpage-1)*(i64)szPage;
           testcase( IS_BIG_INT(iOffset) );
@@ -2323,24 +2924,34 @@ static int walCheckpoint(
         }
         sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_DONE, 0);
   
-        /* If work was actually accomplished... */
-        if( rc==SQLITE_OK ){
-          if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
+        /* If work was actually accomplished, truncate the db file, sync the wal
+        ** file and set WalCkptInfo.nBackfill to indicate so. */
+        if( rc==SQLITE_OK 
+         && (bWal2 || mxSafeFrame==walIndexHdr(pWal)->mxFrame) 
+        ){
+          if( !bWal2 ){
             i64 szDb = pWal->hdr.nPage*(i64)szPage;
             testcase( IS_BIG_INT(szDb) );
             rc = sqlite3OsTruncate(pWal->pDbFd, szDb);
-            if( rc==SQLITE_OK ){
-              rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags));
-            }
+          }
+          if( rc==SQLITE_OK ){
+            rc = sqlite3OsSync(pWal->pDbFd, CKPT_SYNC_FLAGS(sync_flags));
           }
           if( rc==SQLITE_OK ){
             AtomicStore(&pInfo->nBackfill, mxSafeFrame); SEH_INJECT_FAULT;
           }
         }
+        if( rc==SQLITE_OK ){
+          AtomicStore(&pInfo->nBackfill, (bWal2 ? 1 : mxSafeFrame));
+          SEH_INJECT_FAULT;
+        }
+
       }
 
       /* Release the reader lock held while backfilling */
-      walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
+      if( bWal2==0 ){
+        walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
+      }
     }
 
     if( rc==SQLITE_BUSY ){
@@ -2348,6 +2959,7 @@ static int walCheckpoint(
       ** just because there are active readers.  */
       rc = SQLITE_OK;
     }
+    if( bWal2 ) wal2CheckpointFinished(pWal, iCkpt);
   }
 
   /* If this is an SQLITE_CHECKPOINT_RESTART or TRUNCATE operation, and the
@@ -2355,7 +2967,7 @@ static int walCheckpoint(
   ** until all readers have finished using the wal file. This ensures that
   ** the next process to write to the database restarts the wal file.
   */
-  if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
+  if( bWal2==0 && rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
     assert( pWal->writeLock );
     SEH_INJECT_FAULT;
     if( pInfo->nBackfill<pWal->hdr.mxFrame ){
@@ -2381,7 +2993,7 @@ static int walCheckpoint(
           ** file-system. To avoid this, update the wal-index header to
           ** indicate that the log file contains zero valid frames.  */
           walRestartHdr(pWal, salt1);
-          rc = sqlite3OsTruncate(pWal->pWalFd, 0);
+          rc = sqlite3OsTruncate(pWal->apWalFd[0], 0);
         }
         walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
       }
@@ -2399,16 +3011,18 @@ static int walCheckpoint(
 ** it to exactly nMax bytes. If an error occurs while doing so, ignore it.
 */
 static void walLimitSize(Wal *pWal, i64 nMax){
-  i64 sz;
-  int rx;
-  sqlite3BeginBenignMalloc();
-  rx = sqlite3OsFileSize(pWal->pWalFd, &sz);
-  if( rx==SQLITE_OK && (sz > nMax ) ){
-    rx = sqlite3OsTruncate(pWal->pWalFd, nMax);
-  }
-  sqlite3EndBenignMalloc();
-  if( rx ){
-    sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
+  if( isWalMode2(pWal)==0 ){
+    i64 sz;
+    int rx;
+    sqlite3BeginBenignMalloc();
+    rx = sqlite3OsFileSize(pWal->apWalFd[0], &sz);
+    if( rx==SQLITE_OK && (sz > nMax ) ){
+      rx = sqlite3OsTruncate(pWal->apWalFd[0], nMax);
+    }
+    sqlite3EndBenignMalloc();
+    if( rx ){
+      sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
+    }
   }
 }
 
@@ -2516,6 +3130,7 @@ int sqlite3WalClose(
     int isDelete = 0;             /* True to unlink wal and wal-index files */
 
     assert( walAssertLockmask(pWal) );
+    pWal->bClosing = 1;
 
     /* If an EXCLUSIVE lock can be obtained on the database file (using the
     ** ordinary, rollback-mode locking methods, this guarantees that the
@@ -2528,39 +3143,53 @@ int sqlite3WalClose(
     if( zBuf!=0
      && SQLITE_OK==(rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE))
     ){
+      int i;
       if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
         pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
       }
-      rc = sqlite3WalCheckpoint(pWal, db,
-          SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0
-      );
-      if( rc==SQLITE_OK ){
-        int bPersist = -1;
-        sqlite3OsFileControlHint(
-            pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist
+      for(i=0; rc==SQLITE_OK && i<2; i++){
+        rc = sqlite3WalCheckpoint(pWal, db, 
+            SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0
         );
-        if( bPersist!=1 ){
-          /* Try to delete the WAL file if the checkpoint completed and
-          ** fsynced (rc==SQLITE_OK) and if we are not in persistent-wal
-          ** mode (!bPersist) */
-          isDelete = 1;
-        }else if( pWal->mxWalSize>=0 ){
-          /* Try to truncate the WAL file to zero bytes if the checkpoint
-          ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
-          ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
-          ** non-negative value (pWal->mxWalSize>=0).  Note that we truncate
-          ** to zero bytes as truncating to the journal_size_limit might
-          ** leave a corrupt WAL file on disk. */
-          walLimitSize(pWal, 0);
+        if( rc==SQLITE_OK ){
+          int bPersist = -1;
+          sqlite3OsFileControlHint(
+              pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist
+          );
+          if( bPersist!=1 ){
+            /* Try to delete the WAL file if the checkpoint completed and
+            ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
+            ** mode (!bPersist) */
+            isDelete = 1;
+          }else if( pWal->mxWalSize>=0 ){
+            /* Try to truncate the WAL file to zero bytes if the checkpoint
+            ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
+            ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
+            ** non-negative value (pWal->mxWalSize>=0).  Note that we truncate
+            ** to zero bytes as truncating to the journal_size_limit might
+            ** leave a corrupt WAL file on disk. */
+            walLimitSize(pWal, 0);
+          }
         }
+
+        if( isWalMode2(pWal)==0 ) break;
+
+        SEH_TRY {
+          walCkptInfo(pWal)->nBackfill = 0;
+          walidxSetFile(&pWal->hdr, !walidxGetFile(&pWal->hdr));
+          pWal->writeLock = 1;
+          walIndexWriteHdr(pWal);
+          pWal->writeLock = 0;
+        } 
+        SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
       }
     }
 
     walIndexClose(pWal, isDelete);
-    sqlite3OsClose(pWal->pWalFd);
     if( isDelete ){
       sqlite3BeginBenignMalloc();
       sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
+      sqlite3OsDelete(pWal->pVfs, pWal->zWalName2, 0);
       sqlite3EndBenignMalloc();
     }
     WALTRACE(("WAL%p: closed\n", pWal));
@@ -2743,7 +3372,9 @@ static int walIndexReadHdr(Wal *pWal, int *pChanged){
   ** sure the wal-index was not constructed with some future format that
   ** this version of SQLite cannot understand.
   */
-  if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
+  if( badHdr==0 
+   && pWal->hdr.iVersion!=WAL_VERSION1 && pWal->hdr.iVersion!=WAL_VERSION2
+  ){
     rc = SQLITE_CANTOPEN_BKPT;
   }
   if( pWal->bShmUnreliable ){
@@ -2852,7 +3483,7 @@ static int walBeginShmUnreliable(Wal *pWal, int *pChanged){
   /* Make sure some writer hasn't come in and changed the WAL file out
   ** from under us, then disconnected, while we were not looking.
   */
-  rc = sqlite3OsFileSize(pWal->pWalFd, &szWal);
+  rc = sqlite3OsFileSize(pWal->apWalFd[0], &szWal);
   if( rc!=SQLITE_OK ){
     goto begin_unreliable_shm_out;
   }
@@ -2869,7 +3500,7 @@ static int walBeginShmUnreliable(Wal *pWal, int *pChanged){
   }
 
   /* Check the salt keys at the start of the wal file still match. */
-  rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
+  rc = sqlite3OsRead(pWal->apWalFd[0], aBuf, WAL_HDRSIZE, 0);
   if( rc!=SQLITE_OK ){
     goto begin_unreliable_shm_out;
   }
@@ -2906,7 +3537,7 @@ static int walBeginShmUnreliable(Wal *pWal, int *pChanged){
     u32 nTruncate;              /* dbsize field from frame header */
 
     /* Read and decode the next log frame. */
-    rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
+    rc = sqlite3OsRead(pWal->apWalFd[0], aFrame, szFrame, iOffset);
     if( rc!=SQLITE_OK ) break;
     if( !walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame) ) break;
 
@@ -3024,7 +3655,7 @@ static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int *pCnt){
   int nBlockTmout = 0;
 #endif
 
-  assert( pWal->readLock<0 );     /* Not currently locked */
+  assert( pWal->readLock==WAL_LOCK_NONE );     /* Not currently locked */
 
   /* useWal may only be set for read/write connections */
   assert( (pWal->readOnly & WAL_SHM_RDONLY)==0 || useWal==0 );
@@ -3126,12 +3757,40 @@ static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int *pCnt){
   assert( pWal->apWiData[0]!=0 );
   pInfo = walCkptInfo(pWal);
   SEH_INJECT_FAULT;
+  if( isWalMode2(pWal) ){
+    /* This connection needs a "part" lock on the current wal file and, 
+    ** unless pInfo->nBackfill is set to indicate that it has already been
+    ** checkpointed, a "full" lock on the other wal file.  */
+    int iWal = walidxGetFile(&pWal->hdr);
+    int nBackfill = pInfo->nBackfill || walidxGetMxFrame(&pWal->hdr, !iWal)==0;
+    int eLock = 1 + (iWal*2) + (nBackfill==iWal);
+
+    assert( nBackfill==0 || nBackfill==1 );
+    assert( iWal==0 || iWal==1 );
+    assert( iWal!=0 || nBackfill!=1 || eLock==WAL_LOCK_PART1 );
+    assert( iWal!=0 || nBackfill!=0 || eLock==WAL_LOCK_PART1_FULL2 );
+    assert( iWal!=1 || nBackfill!=1 || eLock==WAL_LOCK_PART2 );
+    assert( iWal!=1 || nBackfill!=0 || eLock==WAL_LOCK_PART2_FULL1 );
+
+    rc = walLockShared(pWal, WAL_READ_LOCK(eLock));
+    if( rc!=SQLITE_OK ){
+      return (rc==SQLITE_BUSY ? WAL_RETRY : rc);
+    }
+    walShmBarrier(pWal);
+    if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){
+      walUnlockShared(pWal, WAL_READ_LOCK(eLock));
+      return WAL_RETRY;
+    }else{
+      pWal->readLock = eLock;
+    }
+    assert( pWal->minFrame==0 && walFramePage(pWal->minFrame)==0 );
+  }else
   {
     u32 mxReadMark;               /* Largest aReadMark[] value */
     int mxI;                      /* Index of largest aReadMark[] value */
     int i;                        /* Loop counter */
     u32 mxFrame;                  /* Wal frame to lock to */
-    if( !useWal && AtomicLoad(&pInfo->nBackfill)==pWal->hdr.mxFrame
+    if( !useWal && pInfo->nBackfill==pWal->hdr.mxFrame
 #ifdef SQLITE_ENABLE_SNAPSHOT
      && ((pWal->bGetSnapshot==0 && pWal->pSnapshot==0) || pWal->hdr.mxFrame==0)
 #endif
@@ -3302,7 +3961,7 @@ static int walSnapshotRecover(
 
       if( iDbOff+szPage<=szDb ){
         iWalOff = walFrameOffset(i, szPage) + WAL_FRAME_HDRSIZE;
-        rc = sqlite3OsRead(pWal->pWalFd, pBuf1, szPage, iWalOff);
+        rc = sqlite3OsRead(pWal->apWalFd[0], pBuf1, szPage, iWalOff);
 
         if( rc==SQLITE_OK ){
           rc = sqlite3OsRead(pWal->pDbFd, pBuf2, szPage, iDbOff);
@@ -3342,6 +4001,9 @@ static int walSnapshotRecover(
 int sqlite3WalSnapshotRecover(Wal *pWal){
   int rc;
 
+  /* Snapshots may not be used with wal2 mode databases. */
+  if( isWalMode2(pWal) ) return SQLITE_ERROR;
+
   assert( pWal->readLock>=0 );
   rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
   if( rc==SQLITE_OK ){
@@ -3385,6 +4047,7 @@ static int walBeginReadTransaction(Wal *pWal, int *pChanged){
 
 #ifdef SQLITE_ENABLE_SNAPSHOT
   if( pSnapshot ){
+    if( isWalMode2(pWal) ) return SQLITE_ERROR;
     if( memcmp(pSnapshot, &pWal->hdr, sizeof(WalIndexHdr))!=0 ){
       bChanged = 1;
     }
@@ -3415,6 +4078,10 @@ static int walBeginReadTransaction(Wal *pWal, int *pChanged){
   testcase( (rc&0xff)==SQLITE_IOERR );
   testcase( rc==SQLITE_PROTOCOL );
   testcase( rc==SQLITE_OK );
+  
+  if( rc==SQLITE_OK && pWal->hdr.iVersion==WAL_VERSION2 ){
+    rc = walOpenWal2(pWal);
+  }
 
 #ifdef SQLITE_ENABLE_SNAPSHOT
   if( rc==SQLITE_OK ){
@@ -3507,13 +4174,99 @@ void sqlite3WalEndReadTransaction(Wal *pWal){
 #ifndef SQLITE_ENABLE_SETLK_TIMEOUT
   assert( pWal->writeLock==0 || pWal->readLock<0 );
 #endif
-  if( pWal->readLock>=0 ){
+  if( pWal->readLock!=WAL_LOCK_NONE ){
     (void)sqlite3WalEndWriteTransaction(pWal);
     walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
-    pWal->readLock = -1;
+    pWal->readLock = WAL_LOCK_NONE;
   }
 }
 
+/* Search hash table iHash for an entry matching page number
+** pgno. Each call to this function searches a single hash table
+** (each hash table indexes up to HASHTABLE_NPAGE frames).
+**
+** This code might run concurrently to the code in walIndexAppend()
+** that adds entries to the wal-index (and possibly to this hash 
+** table). This means the value just read from the hash 
+** slot (aHash[iKey]) may have been added before or after the 
+** current read transaction was opened. Values added after the
+** read transaction was opened may have been written incorrectly -
+** i.e. these slots may contain garbage data. However, we assume
+** that any slots written before the current read transaction was
+** opened remain unmodified.
+**
+** For the reasons above, the if(...) condition featured in the inner
+** loop of the following block is more stringent that would be required 
+** if we had exclusive access to the hash-table:
+**
+**   (aPgno[iFrame]==pgno): 
+**     This condition filters out normal hash-table collisions.
+**
+**   (iFrame<=iLast): 
+**     This condition filters out entries that were added to the hash
+**     table after the current read-transaction had started.
+*/
+static int walSearchHash(
+  Wal *pWal, 
+  u32 iLast,
+  int iHash, 
+  Pgno pgno, 
+  u32 *piRead
+){
+  WalHashLoc sLoc;                /* Hash table location */
+  int iKey;                       /* Hash slot index */
+  int nCollide;                   /* Number of hash collisions remaining */
+  int rc;                         /* Error code */
+  u32 iH;
+
+  rc = walHashGet(pWal, iHash, &sLoc);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+  nCollide = HASHTABLE_NSLOT;
+  iKey = walHash(pgno);
+  SEH_INJECT_FAULT;
+  while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){
+    u32 iFrame = iH + sLoc.iZero;
+    if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){
+      assert( iFrame>*piRead || CORRUPT_DB );
+      *piRead = iFrame;
+    }
+    if( (nCollide--)==0 ){
+      *piRead = 0;
+      return SQLITE_CORRUPT_BKPT;
+    }
+    iKey = walNextHash(iKey);
+  }
+
+  return SQLITE_OK;
+}
+
+static int walSearchWal(
+  Wal *pWal, 
+  int iWal, 
+  Pgno pgno, 
+  u32 *piRead
+){
+  int rc = SQLITE_OK;
+  int bWal2 = isWalMode2(pWal);
+  u32 iLast = walidxGetMxFrame(&pWal->hdr, iWal);
+  if( iLast ){
+    int iHash;
+    int iMinHash = walFramePage(pWal->minFrame);
+    u32 iExternal = bWal2 ? walExternalEncode(iWal, iLast) : iLast;
+    assert( bWal2==0 || pWal->minFrame==0 );
+    for(iHash=walFramePage(iExternal); 
+        iHash>=iMinHash && *piRead==0; 
+        iHash-=(1+bWal2)
+    ){
+      rc = walSearchHash(pWal, iExternal, iHash, pgno, piRead);
+      if( rc!=SQLITE_OK ) break;
+    }
+  }
+  return rc;
+}
+
 /*
 ** Search the wal file for page pgno. If found, set *piRead to the frame that
 ** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
@@ -3527,87 +4280,63 @@ static int walFindFrame(
   Pgno pgno,                      /* Database page number to read data for */
   u32 *piRead                     /* OUT: Frame number (or zero) */
 ){
+  int bWal2 = isWalMode2(pWal);
+  int iApp = walidxGetFile(&pWal->hdr);
+  int rc = SQLITE_OK;
   u32 iRead = 0;                  /* If !=0, WAL frame to return data from */
-  u32 iLast = pWal->hdr.mxFrame;  /* Last page in WAL for this reader */
-  int iHash;                      /* Used to loop through N hash tables */
-  int iMinHash;
-
-  /* This routine is only be called from within a read transaction. */
-  assert( pWal->readLock>=0 || pWal->lockError );
-
-  /* If the "last page" field of the wal-index header snapshot is 0, then
-  ** no data will be read from the wal under any circumstances. Return early
-  ** in this case as an optimization.  Likewise, if pWal->readLock==0,
-  ** then the WAL is ignored by the reader so return early, as if the
-  ** WAL were empty.
-  */
-  if( iLast==0 || (pWal->readLock==0 && pWal->bShmUnreliable==0) ){
+
+  /* This routine is only be called from within a read transaction. Or,
+  ** sometimes, as part of a rollback that occurs after an error reaquiring
+  ** a read-lock in walRestartLog().  */
+  assert( pWal->readLock!=WAL_LOCK_NONE || pWal->lockError );
+
+  /* If this is a wal2 system, the client must have a partial-wal lock 
+  ** on wal file iApp. Or if it is a wal system, iApp==0 must be true.  */
+  assert( bWal2==0 || iApp==1
+       || pWal->readLock==WAL_LOCK_PART1 || pWal->readLock==WAL_LOCK_PART1_FULL2
+  );
+  assert( bWal2==0 || iApp==0
+       || pWal->readLock==WAL_LOCK_PART2 || pWal->readLock==WAL_LOCK_PART2_FULL1
+  );
+  assert( bWal2 || iApp==0 );
+
+  /* Return early if read-lock 0 is held. */
+  if( (pWal->readLock==0 && pWal->bShmUnreliable==0) ){
     *piRead = 0;
     return SQLITE_OK;
   }
 
-  /* Search the hash table or tables for an entry matching page number
-  ** pgno. Each iteration of the following for() loop searches one
-  ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames).
-  **
-  ** This code might run concurrently to the code in walIndexAppend()
-  ** that adds entries to the wal-index (and possibly to this hash
-  ** table). This means the value just read from the hash
-  ** slot (aHash[iKey]) may have been added before or after the
-  ** current read transaction was opened. Values added after the
-  ** read transaction was opened may have been written incorrectly -
-  ** i.e. these slots may contain garbage data. However, we assume
-  ** that any slots written before the current read transaction was
-  ** opened remain unmodified.
-  **
-  ** For the reasons above, the if(...) condition featured in the inner
-  ** loop of the following block is more stringent that would be required
-  ** if we had exclusive access to the hash-table:
-  **
-  **   (aPgno[iFrame]==pgno):
-  **     This condition filters out normal hash-table collisions.
-  **
-  **   (iFrame<=iLast):
-  **     This condition filters out entries that were added to the hash
-  **     table after the current read-transaction had started.
-  */
-  iMinHash = walFramePage(pWal->minFrame);
-  for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){
-    WalHashLoc sLoc;              /* Hash table location */
-    int iKey;                     /* Hash slot index */
-    int nCollide;                 /* Number of hash collisions remaining */
-    int rc;                       /* Error code */
-    u32 iH;
-
-    rc = walHashGet(pWal, iHash, &sLoc);
-    if( rc!=SQLITE_OK ){
-      return rc;
-    }
-    nCollide = HASHTABLE_NSLOT;
-    iKey = walHash(pgno);
-    SEH_INJECT_FAULT;
-    while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){
-      u32 iFrame = iH + sLoc.iZero;
-      if( iFrame<=iLast
-       && iFrame>=pWal->minFrame
-       && sLoc.aPgno[(iH-1)&(HASHTABLE_NPAGE-1)]==pgno
-      ){
-        assert( iFrame>iRead || CORRUPT_DB );
-        iRead = iFrame;
-      }
-      if( (nCollide--)==0 ){
-        *piRead = 0;
-        return SQLITE_CORRUPT_BKPT;
-      }
-      iKey = walNextHash(iKey);
-    }
-    if( iRead ) break;
+  /* Search the wal file that the client holds a partial lock on first */
+  rc = walSearchWal(pWal, iApp, pgno, &iRead);
+
+  /* If the requested page was not found, no error has occured, and 
+  ** the client holds a full-wal lock on the other wal file, search it
+  ** too.  */
+  if( rc==SQLITE_OK && bWal2 && iRead==0 && (
+        pWal->readLock==WAL_LOCK_PART1_FULL2 
+     || pWal->readLock==WAL_LOCK_PART2_FULL1
+  )){
+    rc = walSearchWal(pWal, !iApp, pgno, &iRead);
   }
+  if( rc!=SQLITE_OK ) return rc;
 
-#ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
+#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
+  if( iRead ){ 
+    u32 iFrame;
+    int iWal = walExternalDecode(iRead, &iFrame);
+    WALTRACE(("WAL%p: page %d @ frame %d wal %d\n",pWal,(int)pgno,iFrame,iWal));
+  }else{
+    WALTRACE(("WAL%p: page %d not found\n", pWal, (int)pgno));
+  }
+#endif
+
+#if  defined(SQLITE_ENABLE_EXPENSIVE_ASSERT) && /*TODO*/ 0
   /* If expensive assert() statements are available, do a linear search
   ** of the wal-index file content. Make sure the results agree with the
-  ** result obtained using the hash indexes above.  */
+  ** result obtained using the hash indexes above.  
+  **
+  ** TODO: This is broken for wal2.
+  */
   {
     u32 iRead2 = 0;
     u32 iTest;
@@ -3657,12 +4386,16 @@ int sqlite3WalFindFrame(
 */
 int sqlite3WalReadFrame(
   Wal *pWal,                      /* WAL handle */
-  u32 iRead,                      /* Frame to read */
+  u32 iExternal,                  /* Frame to read */
   int nOut,                       /* Size of buffer pOut in bytes */
   u8 *pOut                        /* Buffer to write page data to */
 ){
   int sz;
+  int iWal = 0;
+  u32 iRead;
   i64 iOffset;
+
+  /* Figure out the page size */
   sz = pWal->hdr.szPage;
   sz = (sz&0xfe00) + ((sz&0x0001)<<16);
   if( nOut>sz ){
@@ -3671,16 +4404,26 @@ int sqlite3WalReadFrame(
   }
   testcase( sz<=32768 );
   testcase( sz>=65536 );
+
+  if( isWalMode2(pWal) ){
+    /* Figure out which of the two wal files, and the frame within, that 
+    ** iExternal refers to.  */
+    iWal = walExternalDecode(iExternal, &iRead);
+  }else{
+    iRead = iExternal;
+  }
+
+  WALTRACE(("WAL%p: reading frame %d wal %d\n", pWal, iRead, iWal));
   iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
   /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
-  return sqlite3OsRead(pWal->pWalFd, pOut, nOut, iOffset);
+  return sqlite3OsRead(pWal->apWalFd[iWal], pOut, nOut, iOffset);
 }
 
 /*
 ** Return the size of the database in pages (or zero, if unknown).
 */
 Pgno sqlite3WalDbsize(Wal *pWal){
-  if( pWal && ALWAYS(pWal->readLock>=0) ){
+  if( pWal && ALWAYS(pWal->readLock!=WAL_LOCK_NONE) ){
     return pWal->hdr.nPage;
   }
   return 0;
@@ -3715,7 +4458,7 @@ int sqlite3WalBeginWriteTransaction(Wal *pWal){
 
   /* Cannot start a write transaction without first holding a read
   ** transaction. */
-  assert( pWal->readLock>=0 );
+  assert( pWal->readLock!=WAL_LOCK_NONE );
   assert( pWal->writeLock==0 && pWal->iReCksum==0 );
 
   if( pWal->readOnly ){
@@ -3778,19 +4521,22 @@ int sqlite3WalEndWriteTransaction(Wal *pWal){
 int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
   int rc = SQLITE_OK;
   if( ALWAYS(pWal->writeLock) ){
-    Pgno iMax = pWal->hdr.mxFrame;
+    int iWal = walidxGetFile(&pWal->hdr);
+    Pgno iMax = walidxGetMxFrame(&pWal->hdr, iWal);
+    Pgno iNew;
     Pgno iFrame;
 
+    assert( isWalMode2(pWal) || iWal==0 );
+
     SEH_TRY {
       /* Restore the clients cache of the wal-index header to the state it
       ** was in before the client began writing to the database.
       */
       memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
+      assert( walidxGetFile(&pWal->hdr)==iWal );
+      iNew = walidxGetMxFrame(&pWal->hdr, walidxGetFile(&pWal->hdr));
 
-      for(iFrame=pWal->hdr.mxFrame+1;
-          ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
-          iFrame++
-      ){
+      for(iFrame=iNew+1; ALWAYS(rc==SQLITE_OK) && iFrame<=iMax; iFrame++){
         /* This call cannot fail. Unless the page for which the page number
         ** is passed as the second argument is (a) in the cache and
         ** (b) has an outstanding reference, then xUndo is either a no-op
@@ -3802,10 +4548,16 @@ int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
         ** page 1 is never written to the log until the transaction is
         ** committed. As a result, the call to xUndo may not fail.
         */
-        assert( walFramePgno(pWal, iFrame)!=1 );
-        rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));
+        Pgno pgno;
+        if( isWalMode2(pWal) ){
+          pgno = walFramePgno2(pWal, iWal, iFrame);
+        }else{
+          pgno = walFramePgno(pWal, iFrame);
+        }
+        assert( pgno!=1 );
+        rc = xUndo(pUndoCtx, pgno);
       }
-      if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal);
+      if( iMax!=iNew ) walCleanupHash(pWal);
     }
     SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )
     pWal->iReCksum = 0;
@@ -3820,11 +4572,13 @@ int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
 ** point in the event of a savepoint rollback (via WalSavepointUndo()).
 */
 void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
+  int iWal = walidxGetFile(&pWal->hdr);
   assert( pWal->writeLock );
-  aWalData[0] = pWal->hdr.mxFrame;
+  assert( isWalMode2(pWal) || iWal==0 );
+  aWalData[0] = walidxGetMxFrame(&pWal->hdr, iWal);
   aWalData[1] = pWal->hdr.aFrameCksum[0];
   aWalData[2] = pWal->hdr.aFrameCksum[1];
-  aWalData[3] = pWal->nCkpt;
+  aWalData[3] = isWalMode2(pWal) ? (u32)iWal : pWal->nCkpt;
 }
 
 /*
@@ -3835,21 +4589,24 @@ void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
 */
 int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
   int rc = SQLITE_OK;
+  int iWal = walidxGetFile(&pWal->hdr);
+  u32 iCmp = isWalMode2(pWal) ? (u32)iWal : pWal->nCkpt;
 
   assert( pWal->writeLock );
-  assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
+  assert( isWalMode2(pWal) || iWal==0 );
+  assert( aWalData[3]!=iCmp || aWalData[0]<=walidxGetMxFrame(&pWal->hdr,iWal) );
 
-  if( aWalData[3]!=pWal->nCkpt ){
+  if( aWalData[3]!=iCmp ){
     /* This savepoint was opened immediately after the write-transaction
     ** was started. Right after that, the writer decided to wrap around
     ** to the start of the log. Update the savepoint values to match.
     */
     aWalData[0] = 0;
-    aWalData[3] = pWal->nCkpt;
+    aWalData[3] = iCmp;
   }
 
-  if( aWalData[0]<pWal->hdr.mxFrame ){
-    pWal->hdr.mxFrame = aWalData[0];
+  if( aWalData[0]<walidxGetMxFrame(&pWal->hdr, iWal) ){
+    walidxSetMxFrame(&pWal->hdr, iWal, aWalData[0]);
     pWal->hdr.aFrameCksum[0] = aWalData[1];
     pWal->hdr.aFrameCksum[1] = aWalData[2];
     SEH_TRY {
@@ -3867,20 +4624,68 @@ int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
 /*
 ** This function is called just before writing a set of frames to the log
 ** file (see sqlite3WalFrames()). It checks to see if, instead of appending
-** to the current log file, it is possible to overwrite the start of the
-** existing log file with the new frames (i.e. "reset" the log). If so,
-** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left
-** unchanged.
+** to the current log file, it is possible and desirable to switch to the
+** other log file and write the new transaction to the start of it.
+** If so, the wal-index header is updated accordingly - both in heap memory
+** and in the *-shm file.
 **
 ** SQLITE_OK is returned if no error is encountered (regardless of whether
-** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
+** or not the wal-index header is modified). An SQLite error code is returned
 ** if an error occurs.
 */
 static int walRestartLog(Wal *pWal){
   int rc = SQLITE_OK;
-  int cnt;
 
-  if( pWal->readLock==0 ){
+  if( isWalMode2(pWal) ){
+    int iApp = walidxGetFile(&pWal->hdr);
+    u32 nWalSize = WAL_DEFAULT_WALSIZE;
+    if( pWal->mxWalSize>0 ){
+      /* mxWalSize is in bytes. Convert this to a number of frames. */
+      nWalSize = (pWal->mxWalSize-WAL_HDRSIZE+pWal->szPage+WAL_FRAME_HDRSIZE-1) 
+        / (pWal->szPage+WAL_FRAME_HDRSIZE);
+      nWalSize = MAX(nWalSize, 1);
+    }
+
+    assert( iApp==0 || pWal->readLock==WAL_LOCK_PART2 
+                    || pWal->readLock==WAL_LOCK_PART2_FULL1 );
+    assert( iApp==1 || pWal->readLock==WAL_LOCK_PART1 
+                    || pWal->readLock==WAL_LOCK_PART1_FULL2 );
+
+    /* Switch to wal file !iApp if 
+    **
+    **   (a) Wal file iApp (the current wal file) contains >= nWalSize frames.
+    **   (b) This client is not reading from wal file !iApp.
+    **   (c) No other client is reading from wal file !iApp.
+    **
+    ** Condition (b) guarantees that wal file !iApp is either empty or
+    ** completely checkpointed. 
+    */
+    assert( (0*3)+1==WAL_LOCK_PART1 ); /* iApp==0 -> require WAL_LOCK_PART1 */
+    assert( (1*3)+1==WAL_LOCK_PART2 ); /* iApp==1 -> require WAL_LOCK_PART2 */
+    if( pWal->readLock==(iApp*3)+1
+     && walidxGetMxFrame(&pWal->hdr, iApp)>=nWalSize 
+    ){
+      rc = wal2RestartOk(pWal, iApp);
+      if( rc==SQLITE_OK ){
+        volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
+        int iNew = !iApp;
+        pWal->nCkpt++;
+        walidxSetFile(&pWal->hdr, iNew);
+        walidxSetMxFrame(&pWal->hdr, iNew, 0);
+        sqlite3Put4byte((u8*)&pWal->hdr.aSalt[0], pWal->hdr.aFrameCksum[0]);
+        sqlite3Put4byte((u8*)&pWal->hdr.aSalt[1], pWal->hdr.aFrameCksum[1]);
+        walIndexWriteHdr(pWal);
+        pInfo->nBackfill = 0;
+        wal2RestartFinished(pWal, iApp);
+        walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
+        pWal->readLock = iNew ? WAL_LOCK_PART2_FULL1 : WAL_LOCK_PART1_FULL2;
+        rc = walLockShared(pWal, WAL_READ_LOCK(pWal->readLock));
+      }else if( rc==SQLITE_BUSY ){
+        rc = SQLITE_OK;
+      }
+    }
+  }else if( pWal->readLock==0 ){
+    int cnt;
     volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
     assert( pInfo->nBackfill==pWal->hdr.mxFrame );
     if( pInfo->nBackfill>0 ){
@@ -3904,7 +4709,7 @@ static int walRestartLog(Wal *pWal){
       }
     }
     walUnlockShared(pWal, WAL_READ_LOCK(0));
-    pWal->readLock = -1;
+    pWal->readLock = WAL_LOCK_NONE;
     cnt = 0;
     do{
       int notUsed;
@@ -3973,6 +4778,18 @@ static int walWriteOneFrame(
   int rc;                         /* Result code from subfunctions */
   void *pData;                    /* Data actually written */
   u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-header in */
+
+#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
+  { 
+    int iWal = walidxGetFile(&p->pWal->hdr);
+    int iFrame = 1 + (iOffset / (WAL_FRAME_HDRSIZE + p->pWal->szPage));
+    assert( p->pWal->apWalFd[iWal]==p->pFd );
+    WALTRACE(("WAL%p: page %d written to frame %d of wal %d\n",
+          p->pWal, (int)pPage->pgno, iFrame, iWal
+    ));
+  }
+#endif
+
   pData = pPage->pData;
   walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
   rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);
@@ -3991,12 +4808,13 @@ static int walWriteOneFrame(
 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
 */
 static int walRewriteChecksums(Wal *pWal, u32 iLast){
-  const int szPage = pWal->szPage;/* Database page size */
   int rc = SQLITE_OK;             /* Return code */
+  const int szPage = pWal->szPage;/* Database page size */
   u8 *aBuf;                       /* Buffer to load data from wal file into */
   u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-headers in */
   u32 iRead;                      /* Next frame to read from wal file */
   i64 iCksumOff;
+  sqlite3_file *pWalFd = pWal->apWalFd[walidxGetFile(&pWal->hdr)];
 
   aBuf = sqlite3_malloc(szPage + WAL_FRAME_HDRSIZE);
   if( aBuf==0 ) return SQLITE_NOMEM_BKPT;
@@ -4012,7 +4830,7 @@ static int walRewriteChecksums(Wal *pWal, u32 iLast){
   }else{
     iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16;
   }
-  rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff);
+  rc = sqlite3OsRead(pWalFd, aBuf, sizeof(u32)*2, iCksumOff);
   pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf);
   pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]);
 
@@ -4020,14 +4838,14 @@ static int walRewriteChecksums(Wal *pWal, u32 iLast){
   pWal->iReCksum = 0;
   for(; rc==SQLITE_OK && iRead<=iLast; iRead++){
     i64 iOff = walFrameOffset(iRead, szPage);
-    rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff);
+    rc = sqlite3OsRead(pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff);
     if( rc==SQLITE_OK ){
       u32 iPgno, nDbSize;
       iPgno = sqlite3Get4byte(aBuf);
       nDbSize = sqlite3Get4byte(&aBuf[4]);
 
       walEncodeFrame(pWal, iPgno, nDbSize, &aBuf[WAL_FRAME_HDRSIZE], aFrame);
-      rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff);
+      rc = sqlite3OsWrite(pWalFd, aFrame, sizeof(aFrame), iOff);
     }
   }
 
@@ -4057,6 +4875,8 @@ static int walFrames(
   WalWriter w;                    /* The writer */
   u32 iFirst = 0;                 /* First frame that may be overwritten */
   WalIndexHdr *pLive;             /* Pointer to shared header */
+  int iApp;
+  int bWal2 = isWalMode2(pWal);
 
   assert( pList );
   assert( pWal->writeLock );
@@ -4065,22 +4885,16 @@ static int walFrames(
   ** nTruncate==0 then this frame set does not complete the transaction. */
   assert( (isCommit!=0)==(nTruncate!=0) );
 
-#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
-  { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
-    WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n",
-              pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
-  }
-#endif
-
   pLive = (WalIndexHdr*)walIndexHdr(pWal);
   if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){
-    iFirst = pLive->mxFrame+1;
+    /* if( isWalMode2(pWal)==0 ) */
+    iFirst = walidxGetMxFrame(pLive, walidxGetFile(pLive))+1;
   }
 
   /* See if it is possible to write these frames into the start of the
   ** log file, instead of appending to it at pWal->hdr.mxFrame.
   */
-  if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
+  else if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
     return rc;
   }
 
@@ -4088,16 +4902,38 @@ static int walFrames(
   ** header to the start of the WAL file. See comments at the top of
   ** this source file for a description of the WAL header format.
   */
-  iFrame = pWal->hdr.mxFrame;
+  iApp = walidxGetFile(&pWal->hdr);
+  iFrame = walidxGetMxFrame(&pWal->hdr, iApp);
+  assert( iApp==0 || bWal2 );
+
+#if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
+  { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
+    WALTRACE(("WAL%p: frame write begin. %d frames. iWal=%d. mxFrame=%d. %s\n",
+              pWal, cnt, iApp, iFrame, isCommit ? "Commit" : "Spill"));
+  }
+#endif
+
   if( iFrame==0 ){
+    u32 iCkpt = 0;
     u8 aWalHdr[WAL_HDRSIZE];      /* Buffer to assemble wal-header in */
     u32 aCksum[2];                /* Checksum for wal-header */
 
     sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLITE_BIGENDIAN));
-    sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION);
+    sqlite3Put4byte(&aWalHdr[4], pWal->hdr.iVersion);
     sqlite3Put4byte(&aWalHdr[8], szPage);
-    sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);
-    if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt);
+    if( bWal2 ){
+      if( walidxGetMxFrame(&pWal->hdr, !iApp)>0 ){
+        u8 aPrev[4];
+        rc = sqlite3OsRead(pWal->apWalFd[!iApp], aPrev, 4, 12);
+        if( rc!=SQLITE_OK ){
+          return rc;
+        }
+        iCkpt = (sqlite3Get4byte(aPrev) + 1) & 0x0F;
+      }
+    }else{
+      iCkpt = pWal->nCkpt;
+    }
+    sqlite3Put4byte(&aWalHdr[12], iCkpt);
     memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
     walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum);
     sqlite3Put4byte(&aWalHdr[24], aCksum[0]);
@@ -4109,7 +4945,7 @@ static int walFrames(
     pWal->hdr.aFrameCksum[1] = aCksum[1];
     pWal->truncateOnCommit = 1;
 
-    rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
+    rc = sqlite3OsWrite(pWal->apWalFd[iApp], aWalHdr, sizeof(aWalHdr), 0);
     WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
     if( rc!=SQLITE_OK ){
       return rc;
@@ -4123,7 +4959,7 @@ static int walFrames(
     **     https://sqlite.org/src/info/ff5be73dee
     */
     if( pWal->syncHeader ){
-      rc = sqlite3OsSync(pWal->pWalFd, CKPT_SYNC_FLAGS(sync_flags));
+      rc = sqlite3OsSync(pWal->apWalFd[iApp], CKPT_SYNC_FLAGS(sync_flags));
       if( rc ) return rc;
     }
   }
@@ -4133,7 +4969,7 @@ static int walFrames(
 
   /* Setup information needed to write frames into the WAL */
   w.pWal = pWal;
-  w.pFd = pWal->pWalFd;
+  w.pFd = pWal->apWalFd[iApp];
   w.iSyncPoint = 0;
   w.syncFlags = sync_flags;
   w.szPage = szPage;
@@ -4150,8 +4986,11 @@ static int walFrames(
     ** checksums must be recomputed when the transaction is committed.  */
     if( iFirst && (p->pDirty || isCommit==0) ){
       u32 iWrite = 0;
-      VVA_ONLY(rc =) walFindFrame(pWal, p->pgno, &iWrite);
+      VVA_ONLY(rc =) walSearchWal(pWal, iApp, p->pgno, &iWrite);
       assert( rc==SQLITE_OK || iWrite==0 );
+      if( iWrite && bWal2 ){
+        walExternalDecode(iWrite, &iWrite);
+      }
       if( iWrite>=iFirst ){
         i64 iOff = walFrameOffset(iWrite, szPage) + WAL_FRAME_HDRSIZE;
         void *pData;
@@ -4159,7 +4998,7 @@ static int walFrames(
           pWal->iReCksum = iWrite;
         }
         pData = p->pData;
-        rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
+        rc = sqlite3OsWrite(pWal->apWalFd[iApp], pData, szPage, iOff);
         if( rc ) return rc;
         p->flags &= ~PGHDR_WAL_APPEND;
         continue;
@@ -4199,7 +5038,7 @@ static int walFrames(
   if( isCommit && WAL_SYNC_FLAGS(sync_flags)!=0 ){
     int bSync = 1;
     if( pWal->padToSectorBoundary ){
-      int sectorSize = sqlite3SectorSize(pWal->pWalFd);
+      int sectorSize = sqlite3SectorSize(w.pFd);
       w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
       bSync = (w.iSyncPoint==iOffset);
       testcase( bSync );
@@ -4235,17 +5074,17 @@ static int walFrames(
   ** guarantees that there are no other writers, and no data that may
   ** be in use by existing readers is being overwritten.
   */
-  iFrame = pWal->hdr.mxFrame;
+  iFrame = walidxGetMxFrame(&pWal->hdr, iApp);
   for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
     if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue;
     iFrame++;
-    rc = walIndexAppend(pWal, iFrame, p->pgno);
+    rc = walIndexAppend(pWal, iApp, iFrame, p->pgno);
   }
   assert( pLast!=0 || nExtra==0 );
   while( rc==SQLITE_OK && nExtra>0 ){
     iFrame++;
     nExtra--;
-    rc = walIndexAppend(pWal, iFrame, pLast->pgno);
+    rc = walIndexAppend(pWal, iApp, iFrame, pLast->pgno);
   }
 
   if( rc==SQLITE_OK ){
@@ -4253,7 +5092,7 @@ static int walFrames(
     pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
     testcase( szPage<=32768 );
     testcase( szPage>=65536 );
-    pWal->hdr.mxFrame = iFrame;
+    walidxSetMxFrame(&pWal->hdr, iApp, iFrame);
     if( isCommit ){
       pWal->hdr.iChange++;
       pWal->hdr.nPage = nTruncate;
@@ -4261,7 +5100,17 @@ static int walFrames(
     /* If this is a commit, update the wal-index header too. */
     if( isCommit ){
       walIndexWriteHdr(pWal);
-      pWal->iCallback = iFrame;
+      if( bWal2 ){
+        int iOther = !walidxGetFile(&pWal->hdr);
+        if( walidxGetMxFrame(&pWal->hdr, iOther) 
+            && !walCkptInfo(pWal)->nBackfill 
+        ){
+          pWal->iCallback = walidxGetMxFrame(&pWal->hdr, 0);
+          pWal->iCallback += walidxGetMxFrame(&pWal->hdr, 1);
+        }
+      }else{
+        pWal->iCallback = iFrame;
+      }
     }
   }
 
@@ -4358,7 +5207,7 @@ int sqlite3WalCheckpoint(
       ** writer lock retried until either the busy-handler returns 0 or the
       ** lock is successfully obtained.
       */
-      if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){
+      if( eMode!=SQLITE_CHECKPOINT_PASSIVE && isWalMode2(pWal)==0 ){
         rc = walBusyLock(pWal, xBusy2, pBusyArg, WAL_WRITE_LOCK, 1);
         if( rc==SQLITE_OK ){
           pWal->writeLock = 1;
@@ -4393,7 +5242,9 @@ int sqlite3WalCheckpoint(
     /* Copy data from the log to the database file. */
     if( rc==SQLITE_OK ){
       sqlite3FaultSim(660);
-      if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
+      if( (walPagesize(pWal)!=nBuf) 
+       && ((pWal->hdr.mxFrame2 & 0x7FFFFFFF) || pWal->hdr.mxFrame)
+      ){
         rc = SQLITE_CORRUPT_BKPT;
       }else if( eMode2!=SQLITE_CHECKPOINT_NOOP ){
         rc = walCheckpoint(pWal, db, eMode2, xBusy2, pBusyArg, sync_flags,zBuf);
@@ -4401,21 +5252,38 @@ int sqlite3WalCheckpoint(
 
       /* If no error occurred, set the output variables. */
       if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
-        if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
+        if( pnLog ){
+          WalIndexHdr *pHdr = &pWal->hdr;
+          *pnLog = walidxGetMxFrame(pHdr, 0) + walidxGetMxFrame(pHdr, 1);
+        }
         SEH_INJECT_FAULT;
-        if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
+        if( pnCkpt ){
+          if( isWalMode2(pWal) ){
+            if( (int)(walCkptInfo(pWal)->nBackfill) ){
+              *pnCkpt = walidxGetMxFrame(&pWal->hdr,!walidxGetFile(&pWal->hdr));
+            }else{
+              *pnCkpt = 0;
+            }
+          }else{
+            *pnCkpt = walCkptInfo(pWal)->nBackfill;
+          }
+        }
       }
     }
   }
   SEH_EXCEPT( rc = walHandleException(pWal); )
 
-  if( isChanged ){
+  if( isChanged && pWal->bClosing==0 ){
     /* If a new wal-index header was loaded before the checkpoint was
     ** performed, then the pager-cache associated with pWal is now
     ** out of date. So zero the cached wal-index header to ensure that
     ** next time the pager opens a snapshot on this database it knows that
     ** the cache needs to be reset.
-    */
+    **
+    ** Except, do not do this if the wal is being closed. In this case
+    ** the caller needs the wal-index header to check if the database is
+    ** in wal2 mode and the "other" wal file also needs to be checkpointed.
+    ** Besides, the pager cache will not be used again in this case. */
     memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
   }
 
@@ -4485,14 +5353,15 @@ int sqlite3WalExclusiveMode(Wal *pWal, int op){
   ** upgrade to exclusive-mode following such an error.
   */
 #ifndef SQLITE_USE_SEH
-  assert( pWal->readLock>=0 || pWal->lockError );
+  assert( pWal->readLock!=WAL_LOCK_NONE || pWal->lockError );
 #endif
-  assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
+  assert( pWal->readLock!=WAL_LOCK_NONE || (op<=0 && pWal->exclusiveMode==0) );
 
   if( op==0 ){
-    if( pWal->exclusiveMode!=WAL_NORMAL_MODE ){
+    if( pWal->exclusiveMode ){
       pWal->exclusiveMode = WAL_NORMAL_MODE;
-      if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
+      rc = walLockShared(pWal, WAL_READ_LOCK(pWal->readLock));
+      if( rc!=SQLITE_OK ){
         pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
       }
       rc = pWal->exclusiveMode==WAL_NORMAL_MODE;
@@ -4531,6 +5400,9 @@ int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot){
   WalIndexHdr *pRet;
   static const u32 aZero[4] = { 0, 0, 0, 0 };
 
+  /* Snapshots may not be used with wal2 mode databases. */
+  if( isWalMode2(pWal) ) return SQLITE_ERROR;
+
   assert( pWal->readLock>=0 && pWal->writeLock==0 );
 
   if( memcmp(&pWal->hdr.aFrameCksum[0],aZero,16)==0 ){
@@ -4600,6 +5472,10 @@ int sqlite3_snapshot_cmp(sqlite3_snapshot *p1, sqlite3_snapshot *p2){
 */
 int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot){
   int rc;
+
+  /* Snapshots may not be used with wal2 mode databases. */
+  if( isWalMode2(pWal) ) return SQLITE_ERROR;
+
   SEH_TRY {
     rc = walLockShared(pWal, WAL_CKPT_LOCK);
     if( rc==SQLITE_OK ){
@@ -4643,7 +5519,15 @@ int sqlite3WalFramesize(Wal *pWal){
 /* Return the sqlite3_file object for the WAL file
 */
 sqlite3_file *sqlite3WalFile(Wal *pWal){
-  return pWal->pWalFd;
+  return pWal->apWalFd[0];
+}
+
+/* 
+** Return the journal mode used by this Wal object.
+*/
+int sqlite3WalJournalMode(Wal *pWal){
+  assert( pWal );
+  return (isWalMode2(pWal) ? PAGER_JOURNALMODE_WAL2 : PAGER_JOURNALMODE_WAL);
 }
 
 #endif /* #ifndef SQLITE_OMIT_WAL */
diff --git a/src/wal.h b/src/wal.h
index 1b17d2dfbe..2f320b66b0 100644
--- a/src/wal.h
+++ b/src/wal.h
@@ -26,7 +26,7 @@
 #define CKPT_SYNC_FLAGS(X)  (((X)>>2)&0x03)
 
 #ifdef SQLITE_OMIT_WAL
-# define sqlite3WalOpen(x,y,z)                   0
+# define sqlite3WalOpen(w,x,y,z)                 0
 # define sqlite3WalLimit(x,y)
 # define sqlite3WalClose(v,w,x,y,z)              0
 # define sqlite3WalBeginReadTransaction(y,z)     0
@@ -45,6 +45,7 @@
 # define sqlite3WalFramesize(z)                  0
 # define sqlite3WalFindFrame(x,y,z)              0
 # define sqlite3WalFile(x)                       0
+# define sqlite3WalJournalMode(x)                0
 # undef SQLITE_USE_SEH
 #else
 
@@ -56,7 +57,7 @@
 typedef struct Wal Wal;
 
 /* Open and close a connection to a write-ahead log. */
-int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**);
+int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *,int,i64,int,Wal**);
 int sqlite3WalClose(Wal *pWal, sqlite3*, int sync_flags, int, u8 *);
 
 /* Set the limiting size of a WAL file. */
@@ -147,6 +148,9 @@ int sqlite3WalFramesize(Wal *pWal);
 /* Return the sqlite3_file object for the WAL file */
 sqlite3_file *sqlite3WalFile(Wal *pWal);
 
+/* Return the journal mode (WAL or WAL2) used by this Wal object. */
+int sqlite3WalJournalMode(Wal *pWal);
+
 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
 int sqlite3WalWriteLock(Wal *pWal, int bLock);
 void sqlite3WalDb(Wal *pWal, sqlite3 *db);
diff --git a/test/corruptA.test b/test/corruptA.test
index 12d918615f..653b88b693 100644
--- a/test/corruptA.test
+++ b/test/corruptA.test
@@ -47,7 +47,7 @@ db close
 forcecopy test.db test.db-template
 
 set unreadable_version 02
-ifcapable wal { set unreadable_version 03 }
+ifcapable wal { set unreadable_version 04 }
 do_test corruptA-2.1 {
   forcecopy test.db-template test.db
   hexio_write test.db 19 $unreadable_version   ;# the read format number
diff --git a/test/permutations.test b/test/permutations.test
index d37767b907..f243e59dce 100644
--- a/test/permutations.test
+++ b/test/permutations.test
@@ -467,18 +467,21 @@ lappend ::testsuitelist xxx
 test_suite "coverage-wal" -description {
   Coverage tests for file wal.c.
 } -files {
-  wal.test wal2.test wal3.test wal4.test wal5.test
+  wal2big.test wal2recover.test wal2rewrite.test
+  wal2simple.test wal2snapshot.test wal2.test
+  wal3.test wal4.test wal5.test
   wal64k.test wal6.test wal7.test wal8.test wal9.test
-  walbak.test walbig.test walblock.test walcksum.test walcrash2.test
-  walcrash3.test walcrash4.test walcrash.test walfault.test walhook.test
-  walmode.test walnoshm.test waloverwrite.test walpersist.test 
-  walprotocol2.test walprotocol.test walro2.test walrofault.test 
-  walro.test walshared.test walslow.test walvfs.test
-  walfault2.test
-  nockpt.test
-
+  walbak.test walbig.test walblock.test walcksum.test 
+  walfault.test walhook.test walmode.test walnoshm.test
+  waloverwrite.test walpersist.test walprotocol2.test
+  walprotocol.test walro2.test walrofault.test walro.test
+  walshared.test walslow.test wal.test
+  wal2savepoint.test wal2lock.test wal2recover2.test
+  walvfs.test walfault2.test nockpt.test
   snapshot2.test snapshot3.test snapshot4.test
   snapshot_fault.test snapshot.test snapshot_up.test
+  walcrash2.test walcrash3.test walcrash4.test walcrash.test
+  wal2fault.test
 } 
 
 test_suite "coverage-pager" -description {
@@ -1035,6 +1038,23 @@ test_suite "wal" -description {
   fts3c.test   fts3d.test   fts3e.test   fts3query.test 
 }
 
+test_suite "wal2" -description {
+  Run tests with journal_mode=WAL2
+} -initialize {
+  set ::G(savepoint6_iterations) 100
+} -shutdown {
+  unset -nocomplain ::G(savepoint6_iterations)
+} -files {
+  savepoint.test     savepoint2.test     savepoint6.test
+  trans.test         avtrans.test
+
+  fts3aa.test  fts3ab.test  fts3ac.test  fts3ad.test
+  fts3ae.test  fts3af.test  fts3ag.test  fts3ah.test
+  fts3ai.test  fts3aj.test  fts3ak.test  fts3al.test
+  fts3am.test  fts3an.test  fts3ao.test  fts3b.test
+  fts3c.test   fts3d.test   fts3e.test   fts3query.test 
+}
+
 test_suite "rtree" -description {
   All R-tree related tests. Provides coverage of source file rtree.c.
 } -files [glob -nocomplain $::testdir/../ext/rtree/*.test]
diff --git a/test/rdonly.test b/test/rdonly.test
index 404c613b21..bdc70cdd70 100644
--- a/test/rdonly.test
+++ b/test/rdonly.test
@@ -41,7 +41,7 @@ do_test rdonly-1.1.1 {
   sqlite3_db_readonly db main
 } {0}
 
-# Changes the write version from 1 to 3.  Verify that the database
+# Changes the write version from 1 to 4.  Verify that the database
 # can be read but not written.
 #
 do_test rdonly-1.2 {
@@ -49,7 +49,7 @@ do_test rdonly-1.2 {
   hexio_get_int [hexio_read test.db 18 1]
 } 1
 do_test rdonly-1.3 {
-  hexio_write test.db 18 03
+  hexio_write test.db 18 04
   sqlite3 db test.db
   execsql {
     SELECT * FROM t1;
@@ -83,7 +83,7 @@ do_test rdonly-1.5 {
 # the database is read-only until after it is locked.
 #
 set ro_version 02
-ifcapable wal { set ro_version 03 }
+ifcapable wal { set ro_version 04 }
 do_test rdonly-1.6 {
   hexio_write test.db 18 $ro_version     ; # write-version
   hexio_write test.db 24 11223344        ; # change-counter
diff --git a/test/savepoint.test b/test/savepoint.test
index 3952981dab..048771659e 100644
--- a/test/savepoint.test
+++ b/test/savepoint.test
@@ -30,6 +30,7 @@ do_test savepoint-1.1 {
     RELEASE sp1;
   }
 } {}
+wal_check_journal_mode savepoint-1.1
 do_test savepoint-1.2 {
   execsql {
     SAVEPOINT sp1;
@@ -807,7 +808,8 @@ do_test savepoint-11.6 {
 integrity_check savepoint-11.7
 do_test savepoint-11.8 {
   execsql { ROLLBACK }
-  execsql { PRAGMA wal_checkpoint }
+  db close
+  sqlite3 db test.db
   file size test.db
 } {8192}
 
diff --git a/test/tester.tcl b/test/tester.tcl
index c4f35fccba..8cd4a200eb 100644
--- a/test/tester.tcl
+++ b/test/tester.tcl
@@ -553,6 +553,7 @@ proc reset_db {} {
   forcedelete test.db
   forcedelete test.db-journal
   forcedelete test.db-wal
+  forcedelete test.db-wal2
   sqlite3 db ./test.db
   set ::DB [sqlite3_connection_pointer db]
   if {[info exists ::SETUP_SQL]} {
@@ -2306,17 +2307,32 @@ proc drop_all_indexes {{db db}} {
 #     Returns true if this test should be run in WAL mode. False otherwise.
 #
 proc wal_is_wal_mode {} {
-  expr {[permutation] eq "wal"}
+  if {[permutation] eq "wal"} { return 1 }
+  if {[permutation] eq "wal2"} { return 2 }
+  return 0
 }
 proc wal_set_journal_mode {{db db}} {
-  if { [wal_is_wal_mode] } {
-    $db eval "PRAGMA journal_mode = WAL"
+  switch -- [wal_is_wal_mode] {
+    0 {
+    }
+
+    1 {
+      $db eval "PRAGMA journal_mode = WAL"
+    }
+
+    2 {
+      $db eval "PRAGMA journal_mode = WAL2"
+    }
   }
 }
 proc wal_check_journal_mode {testname {db db}} {
   if { [wal_is_wal_mode] } {
     $db eval { SELECT * FROM sqlite_master }
-    do_test $testname [list $db eval "PRAGMA main.journal_mode"] {wal}
+    set expected "wal"
+    if {[wal_is_wal_mode]==2} {
+      set expected "wal2"
+    }
+    do_test $testname [list $db eval "PRAGMA main.journal_mode"] $expected
   }
 }
 
diff --git a/test/uri.test b/test/uri.test
index 74da225acc..62090f46af 100644
--- a/test/uri.test
+++ b/test/uri.test
@@ -282,11 +282,11 @@ ifcapable wal {
       INSERT INTO t2 VALUES('x', 'y');
     }
     lsort [array names ::T1]
-  } {test.db1 test.db1-journal test.db1-wal}
+  } {test.db1 test.db1-journal test.db1-wal test.db1-wal2}
   
   do_test 5.1.2 {
     lsort [array names ::T2]
-  } {test.db2 test.db2-journal test.db2-wal}
+  } {test.db2 test.db2-journal test.db2-wal test.db2-wal2}
   db close
   
   tvfs1 delete
diff --git a/test/wal.test b/test/wal.test
index 50988debe3..d5bf261ed3 100644
--- a/test/wal.test
+++ b/test/wal.test
@@ -1175,7 +1175,7 @@ foreach {tn pgsz works} {
   9  32768    1
  10  65536    1
  11 131072    0
- 11   1016    0
+ 12   1016    0
 } {
 
   if {$::SQLITE_MAX_PAGE_SIZE < $pgsz} {
@@ -1185,14 +1185,14 @@ foreach {tn pgsz works} {
   for {set pg 1} {$pg <= 3} {incr pg} {
     forcecopy testX.db test.db
     forcedelete test.db-wal
-  
+
     # Check that the database now exists and consists of three pages. And
     # that there is no associated wal file.
     #
     do_test wal-18.2.$tn.$pg.1 { file exists test.db-wal } 0
     do_test wal-18.2.$tn.$pg.2 { file exists test.db } 1
     do_test wal-18.2.$tn.$pg.3 { file size test.db } [expr 1024*3]
-  
+
     do_test wal-18.2.$tn.$pg.4 {
 
       # Create a wal file that contains a single frame (database page
@@ -1224,16 +1224,16 @@ foreach {tn pgsz works} {
       puts -nonewline $fd $framehdr
       puts -nonewline $fd $framebody
       close $fd
-  
+
       file size test.db-wal
     } [wal_file_size 1 $pgsz]
-  
+
     do_test wal-18.2.$tn.$pg.5 {
       sqlite3 db test.db
       set rc [catch { db one {PRAGMA integrity_check} } msg]
       expr { $rc!=0 || $msg!="ok" }
     } $works
-  
+ 
     db close
   }
 }
diff --git a/test/wal2big.test b/test/wal2big.test
new file mode 100644
index 0000000000..77daab5af6
--- /dev/null
+++ b/test/wal2big.test
@@ -0,0 +1,73 @@
+# 2017 September 19
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# TESTRUNNER: slow
+#
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2big
+ifcapable !wal {finish_test ; return }
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b, c);
+  CREATE INDEX t1a ON t1(a);
+  CREATE INDEX t1b ON t1(b);
+  CREATE INDEX t1c ON t1(c);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 10000000;
+
+  WITH s(i) AS (
+    SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<200000
+  )
+  INSERT INTO t1 SELECT random(), random(), random() FROM s;
+} {wal2 10000000}
+
+do_execsql_test 1.1 {
+  WITH s(i) AS (
+    SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<200000
+  )
+  INSERT INTO t1 SELECT random(), random(), random() FROM s;
+}
+
+do_test 1.2 {
+  list [expr [file size test.db-wal]>10000000] \
+       [expr [file size test.db-wal2]>10000000]
+} {1 1}
+
+do_test 1.3 {
+  sqlite3 db2 test.db
+  execsql {
+    SELECT count(*) FROM t1;
+    PRAGMA integrity_check;
+  } db2
+} {400000 ok}
+
+do_test 1.4 {
+  db2 close
+  forcecopy test.db test.db2
+  forcecopy test.db-wal test.db2-wal
+  forcecopy test.db-wal2 test.db2-wal2
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    PRAGMA integrity_check;
+  }
+} {400000 ok}
+
+finish_test
diff --git a/test/wal2fault.test b/test/wal2fault.test
new file mode 100644
index 0000000000..7067e45529
--- /dev/null
+++ b/test/wal2fault.test
@@ -0,0 +1,52 @@
+# 2010 May 03
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+source $testdir/lock_common.tcl
+
+ifcapable !wal {finish_test ; return }
+set testprefix wal2fault
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(x,y);
+  PRAGMA journal_mode = wal2;
+  WITH s(i) AS ( SELECT 100 UNION ALL SELECT i-1 FROM s WHERE (i-1)>0 )
+  INSERT INTO t1 SELECT i, randomblob(i) FROM s;
+  WITH s(i) AS ( SELECT 100 UNION ALL SELECT i-1 FROM s WHERE (i-1)>0 )
+  INSERT INTO t1 SELECT i, randomblob(i) FROM s;
+} {wal2}
+
+do_test 1.1 {
+  expr [file size test.db-wal]>10000
+} {1}
+faultsim_save_and_close
+
+do_faultsim_test 1 -prep {
+  faultsim_restore_and_reopen
+  execsql {
+    PRAGMA journal_size_limit = 10000;
+    SELECT count(*) FROM sqlite_master;
+  }
+} -body {
+  execsql {
+    INSERT INTO t1 VALUES(1, 2);
+  }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
+finish_test
diff --git a/test/wal2lock.test b/test/wal2lock.test
new file mode 100644
index 0000000000..f86cf87925
--- /dev/null
+++ b/test/wal2lock.test
@@ -0,0 +1,106 @@
+# 2018 December 15
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2lock
+ifcapable !wal {finish_test ; return }
+
+db close
+testvfs tvfs 
+sqlite3 db test.db -vfs tvfs
+
+do_execsql_test 1.0 {
+  PRAGMA journal_mode = wal2;
+  CREATE TABLE y1(y, yy);
+  CREATE INDEX y1y ON y1(y);
+  CREATE INDEX y1yy ON y1(yy);
+  INSERT INTO y1 VALUES(1, 2), (3, 4), (5, 6);
+} {wal2}
+
+tvfs script vfs_callback
+tvfs filter xShmLock
+
+set ::lock [list]
+proc vfs_callback {func file name lock} {
+  lappend ::lock $lock
+  return SQLITE_OK
+}
+
+do_execsql_test 1.1.1 {
+  SELECT * FROM y1
+} {1 2 3 4 5 6}
+do_test 1.1.2 {
+  set ::lock
+} {{4 1 lock shared} {4 1 unlock shared}}
+
+set ::bFirst 1
+proc vfs_callback {func file name lock} {
+  if {$::bFirst} {
+    set ::bFirst 0
+    return SQLITE_BUSY
+  }
+  return SQLITE_OK
+}
+do_execsql_test 1.2 {
+  SELECT * FROM y1
+} {1 2 3 4 5 6}
+
+set ::bFirst 1
+proc vfs_callback {func file name lock} {
+  if {$::bFirst} {
+    set ::bFirst 0
+    return SQLITE_IOERR
+  }
+  return SQLITE_OK
+}
+do_catchsql_test 1.3 {
+  SELECT * FROM y1
+} {1 {disk I/O error}}
+
+puts "# Warning: This next test case causes SQLite to call xSleep(1) 100 times."
+puts "# Normally this equates to a delay of roughly 10 seconds, but if SQLite"
+puts "# is built on unix without HAVE_USLEEP defined, it may be much longer."
+proc vfs_callback {func file name lock} { return SQLITE_BUSY }
+do_catchsql_test 1.4 {
+  SELECT * FROM y1
+} {1 {locking protocol}}
+proc vfs_callback {func file name lock} { return SQLITE_OK }
+
+sqlite3 db2 test.db -vfs tvfs
+set ::bFirst 1
+
+proc vfs_callback {func file name lock} {
+  if {$::bFirst} {
+    set ::bFirst 0
+    db2 eval { INSERT INTO y1 VALUES(7, 8) }
+  }
+}
+
+do_execsql_test 1.5.1 {
+  SELECT * FROM y1
+} {1 2 3 4 5 6 7 8}
+do_execsql_test 1.5.2 {
+  SELECT * FROM y1
+} {1 2 3 4 5 6 7 8}
+
+db close
+db2 close
+tvfs delete
+finish_test
diff --git a/test/wal2openclose.test b/test/wal2openclose.test
new file mode 100644
index 0000000000..66e5875813
--- /dev/null
+++ b/test/wal2openclose.test
@@ -0,0 +1,81 @@
+# 2017 September 19
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2openclose
+ifcapable !wal {finish_test ; return }
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b, c);
+  PRAGMA journal_mode = wal2;
+  PRAGMA wal_autocheckpoint = 0;
+  PRAGMA journal_size_limit = 75000;
+} {wal2 0 75000}
+
+do_test 1.1 {
+  for {set ii 1} {$ii <= 200} {incr ii} {
+    execsql {
+      INSERT INTO t1 VALUES($ii, $ii, $ii);
+    }
+  }
+  expr ([file size test.db-wal2] - 75000) > 30000
+} {1}
+
+do_test 1.2 {
+  db close
+  list [file exists test.db-wal] [file exists test.db-wal2]
+} {0 0}
+
+sqlite3 db test.db
+do_execsql_test 1.3 {
+  SELECT sum(c) FROM t1
+} {20100}
+db close
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 2.0 {
+  CREATE TABLE t1(a, b, c);
+  PRAGMA journal_mode = wal2;
+  INSERT INTO t1 VALUES(1, 2, 3);
+} {wal2}
+db_save_and_close
+
+db_restore_and_reopen
+do_execsql_test 2.1 {
+  SELECT * FROM t1;
+} {1 2 3}
+
+do_test 2.2 {
+  sqlite3 db2 test.db
+  db2 eval {INSERT INTO t1 VALUES(4, 5, 6)}
+  db2 close
+} {}
+
+breakpoint
+db close
+sqlite3 db test.db
+do_execsql_test 2.2 {
+  SELECT * FROM t1;
+} {1 2 3 4 5 6}
+
+
+
+finish_test
diff --git a/test/wal2recover.test b/test/wal2recover.test
new file mode 100644
index 0000000000..b4e1022e85
--- /dev/null
+++ b/test/wal2recover.test
@@ -0,0 +1,271 @@
+# 2018 December 13
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2recover
+ifcapable !wal {finish_test ; return }
+
+proc db_copy {from to} {
+  forcecopy $from $to
+  forcecopy ${from}-wal ${to}-wal
+  forcecopy ${from}-wal2 ${to}-wal2
+}
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b, c);
+  CREATE INDEX t1a ON t1(a);
+  CREATE INDEX t1b ON t1(b);
+  CREATE INDEX t1c ON t1(c);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 15000;
+  PRAGMA wal_autocheckpoint = 0;
+} {wal2 15000 0}
+
+do_test 1.1 {
+  for {set i 1} {$i <= 1000} {incr i} {
+    execsql { INSERT INTO t1 VALUES(random(), random(), random()) }
+    db_copy test.db test.db2
+    sqlite3 db2 test.db
+    set res [execsql {
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    } db2]
+    db2 close
+    if {$res != [list $i ok]} {
+      error "failure on iteration $i"
+    }
+  }
+  set {} {}
+} {}
+
+#--------------------------------------------------------------------------
+reset_db
+do_execsql_test 2.0 {
+  CREATE TABLE t1(x UNIQUE);
+  CREATE TABLE t2(x UNIQUE);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 10000;
+  PRAGMA wal_autocheckpoint = 0;
+  BEGIN;
+    INSERT INTO t1 VALUES(randomblob(4000));
+    INSERT INTO t1 VALUES(randomblob(4000));
+    INSERT INTO t1 VALUES(randomblob(4000));
+  COMMIT;
+  BEGIN;
+    INSERT INTO t2 VALUES(randomblob(4000));
+    INSERT INTO t2 VALUES(randomblob(4000));
+    INSERT INTO t2 VALUES(randomblob(4000));
+  COMMIT;
+} {wal2 10000 0}
+do_test 2.0.1 {
+  list [file size test.db] [file size test.db-wal] [file size test.db-wal2]
+} {5120 28328 28328}
+
+# Test recovery with both wal files intact.
+#
+do_test 2.1 {
+  db_copy test.db test.db2
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+    PRAGMA integrity_check;
+  } db2
+} {3 3 ok}
+
+do_test 2.2 {
+  db2 close
+  db_copy test.db test.db2
+  hexio_write test.db2-wal 16 12345678
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+  } db2
+} {0 3}
+
+do_test 2.3 {
+  db2 close
+  db_copy test.db test.db2
+  hexio_write test.db2-wal2 16 12345678
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+    PRAGMA integrity_check;
+  } db2
+} {3 0 ok}
+
+do_test 2.4 {
+  db2 close
+  db_copy test.db test.db2
+  forcecopy test.db-wal test.db2-wal2
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+    PRAGMA integrity_check;
+  } db2
+} {3 0 ok}
+
+do_test 2.5 {
+  db2 close
+  db_copy test.db test.db2
+  forcecopy test.db-wal  test.db2-wal2
+  forcecopy test.db-wal2  test.db2-wal
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+    PRAGMA integrity_check;
+  } db2
+} {3 3 ok}
+
+do_test 2.6 {
+  db2 close
+  db_copy test.db test.db2
+  forcecopy test.db-wal test.db2-wal2
+  close [open test.db-wal w]
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+    PRAGMA integrity_check;
+  } db2
+} {3 0 ok}
+
+do_test 2.7 {
+  db2 close
+  db_copy test.db test.db2
+  forcedelete test.db2-wal
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT count(*) FROM t1;
+    SELECT count(*) FROM t2;
+    PRAGMA integrity_check;
+  } db2
+} {0 0 ok}
+db2 close
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 3.0 {
+  CREATE TABLE t1(a TEXT, b TEXT, c TEXT);
+  CREATE INDEX t1a ON t1(a);
+  CREATE INDEX t1b ON t1(b);
+  CREATE INDEX t1c ON t1(c);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 10000;
+  PRAGMA wal_autocheckpoint = 0;
+  PRAGMA cache_size = 5;
+} {wal2 10000 0}
+
+do_execsql_test 3.1 {
+  WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 200)
+  INSERT INTO t1 SELECT i, i, i FROM s;
+
+  INSERT INTO t1 VALUES(201, 201, 201);
+} {}
+
+do_test 3.2 {
+  list [file size test.db] [file size test.db-wal] [file size test.db-wal2]
+} {5120 15752 4224}
+
+do_test 3.3 {
+  forcecopy test.db test.db2
+  forcecopy test.db-wal test.db2-wal
+  forcecopy test.db-wal2 test.db2-wal2
+  sqlite3 db2 test.db2
+  execsql {
+    PRAGMA journal_size_limit = 10000;
+    PRAGMA wal_autocheckpoint = 0;
+    PRAGMA cache_size = 5;
+    BEGIN;
+      WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 200)
+      INSERT INTO t1 SELECT i, i, i FROM s;
+  } db2
+  list [file size test.db2] [file size test.db2-wal] [file size test.db2-wal2]
+} {5120 15752 23088}
+
+
+if {$tcl_platform(platform)!="windows"} {
+  # These cannot be run under windows, as the *-shm file may not be read
+  # while it is locked by the database connection. 
+  do_test 3.4 {
+    set fd [open test.db2-shm]
+    fconfigure $fd -translation binary
+    set data [read $fd]
+    close $fd
+  
+    set fd [open test.db-shm w]
+    fconfigure $fd -translation binary
+    puts -nonewline $fd $data
+    close $fd
+  
+    execsql {
+      WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 10)
+        INSERT INTO t1 SELECT i, i, i FROM s;
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    }
+  } {211 ok}
+  
+  do_test 3.5 {
+    list [file size test.db] [file size test.db-wal] [file size test.db-wal2]
+  } {5120 15752 18896}
+}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_execsql_test 4.0 {
+  PRAGMA journal_mode = wal2;
+  CREATE TABLE xyz(x, y, z);
+  INSERT INTO xyz VALUES('x', 'y', 'z');
+} {wal2}
+db close
+do_test 4.1 {
+  close [open test.db-wal w]
+  file mkdir test.db-wal2
+  sqlite3 db test.db
+  catchsql { SELECT * FROM xyz }
+} {1 {unable to open database file}}
+db close
+file delete test.db-wal2
+db2 close
+
+do_test 4.2 {
+  sqlite3 db test.db
+  execsql { 
+    INSERT INTO xyz VALUES('a', 'b', 'c');
+  }
+  forcecopy test.db test.db2
+  forcecopy test.db-wal test.db2-wal
+  forcedelete test.db2-wal2
+  file mkdir test.db2-wal2
+  sqlite3 db2 test.db2
+  catchsql { SELECT * FROM xyz } db2
+} {1 {unable to open database file}}
+db2 close
+file delete test.db2-wal2
+
+
+finish_test
diff --git a/test/wal2recover2.test b/test/wal2recover2.test
new file mode 100644
index 0000000000..c4da38e3a0
--- /dev/null
+++ b/test/wal2recover2.test
@@ -0,0 +1,273 @@
+# 2018 December 13
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2recover2
+ifcapable !wal {finish_test ; return }
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(x);
+  CREATE TABLE t2(x);
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t1 SELECT i FROM s;
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t2 SELECT i FROM s;
+
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 10000;
+} {wal2 10000}
+
+set ::L 1125750
+set ::M 1126500
+set ::H 1127250
+
+do_execsql_test 1.1 {
+  UPDATE t1 SET x=x+1;
+  UPDATE t2 SET x=x+1 WHERE rowid<=750;
+
+  SELECT sum(x) FROM t1;
+  SELECT sum(x) FROM t2;
+} [list $H $M]
+
+do_test 1.2 {
+  list [file size test.db] [file size test.db-wal] [file size test.db-wal2]
+} {31744 14704 7368}
+
+proc cksum {zIn data} {
+  if {[string length $zIn]==0} {
+    set s0 0
+    set s1 0
+  } else {
+    set s0 [hexio_get_int [string range $zIn 0 7]]
+    set s1 [hexio_get_int [string range $zIn 8 15]]
+  }
+  set n [expr [string length $data] / 8]
+
+  for {set i 0} {$i < $n} {incr i 2} {
+    set x0 [hexio_get_int -l [string range $data [expr $i*8]   [expr $i*8+7]]]
+    set x1 [hexio_get_int -l [string range $data [expr $i*8+8] [expr $i*8+8+7]]]
+
+    set s0 [expr ($s0 + $x0 + $s1) & 0xFFFFFFFF]
+    set s1 [expr ($s1 + $x1 + $s0) & 0xFFFFFFFF]
+  }
+
+  return "[hexio_render_int32 $s0][hexio_render_int32 $s1]"
+}
+
+proc fix_wal_cksums {file} {
+  # Fix the checksum on the wal header.
+  set data [hexio_read $file 0 32]
+  set cksum [cksum {} [string range $data 0 47]]
+  set salt [hexio_read $file 16 8]
+  hexio_write $file 24 $cksum
+
+  # Fix the checksums for all pages in the wal file.
+  set pgsz [hexio_get_int [hexio_read $file 8 4]]
+  set sz [file size $file]
+  for {set off 32} {$off < $sz} {incr off [expr $pgsz+24]} {
+    set e [hexio_read $file $off 8]
+    set cksum [cksum $cksum $e]
+
+    set p [hexio_read $file [expr $off+24] $pgsz]
+    set cksum [cksum $cksum $p]
+
+    hexio_write $file [expr $off+8] $salt
+    hexio_write $file [expr $off+16] $cksum
+  }
+}
+
+proc wal_incr_hdrfield {file field} {
+  switch -- $field {
+    nCkpt { set offset 12 }
+    salt0 { set offset 16 }
+    salt1 { set offset 20 }
+    default {
+      error "unknown field $field - should be \"nCkpt\", \"salt0\" or \"salt1\""
+    }
+  }
+
+  # Increment the value in the wal header.
+  set v [hexio_get_int [hexio_read $file $offset 4]]
+  incr v
+  hexio_write $file $offset [hexio_render_int32 $v]
+  
+  # Fix various checksums
+  fix_wal_cksums $file
+}
+
+proc wal_set_nckpt {file val} {
+  # Increment the value in the wal header.
+  hexio_write $file 12 [hexio_render_int32 $val]
+  
+  # Fix various checksums
+  fix_wal_cksums $file
+}
+
+proc wal_set_follow {file prevfile} {
+  set pgsz [hexio_get_int [hexio_read $prevfile 8 4]]
+  set sz [file size $prevfile]
+  set cksum [hexio_read $prevfile [expr $sz-$pgsz-8] 8]
+
+  hexio_write $file 16 $cksum
+  fix_wal_cksums $file
+}
+
+foreach {tn file field} {
+  1 test.db2-wal    salt0
+  2 test.db2-wal    salt1
+  3 test.db2-wal    nCkpt
+  4 test.db2-wal2   salt0
+  5 test.db2-wal2   salt1
+  6 test.db2-wal2   nCkpt
+} {
+  do_test 1.3.$tn {
+    forcecopy test.db test.db2
+    forcecopy test.db-wal test.db2-wal
+    forcecopy test.db-wal2 test.db2-wal2
+    wal_incr_hdrfield $file $field
+    sqlite3 db2 test.db2
+    execsql {
+      SELECT sum(x) FROM t1;
+      SELECT sum(x) FROM t2;
+    } db2
+  } [list $H $L]
+  db2 close
+}
+
+do_test 1.4 {
+  forcecopy test.db test.db2
+  forcecopy test.db-wal2 test.db2-wal
+  forcedelete test.db2-wal2
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT sum(x) FROM t1;
+    SELECT sum(x) FROM t2;
+  } db2
+} [list $L $M]
+
+do_test 1.5 {
+  db2 close
+  forcecopy test.db test.db2
+  forcecopy test.db-wal2 test.db2-wal
+  forcecopy test.db-wal test.db2-wal2
+  sqlite3 db2 test.db2
+  execsql {
+    SELECT sum(x) FROM t1;
+    SELECT sum(x) FROM t2;
+  } db2
+} [list $H $M]
+
+db2 close
+foreach {tn file field} {
+  1 test.db2-wal    salt0
+  2 test.db2-wal    salt1
+  3 test.db2-wal2   salt0
+  4 test.db2-wal2   salt1
+} {
+  do_test 1.6.$tn {
+    forcecopy test.db test.db2
+    forcecopy test.db-wal2 test.db2-wal
+    forcecopy test.db-wal test.db2-wal2
+    wal_incr_hdrfield $file $field
+    sqlite3 db2 test.db2
+    execsql {
+      SELECT sum(x) FROM t1;
+      SELECT sum(x) FROM t2;
+    } db2
+  } [list $H $L]
+  db2 close
+}
+
+foreach {tn nCkpt1 nCkpt2 res} [list \
+  1   2 1   "$H $M"                  \
+  2   2 2   "$L $M"                  \
+  3   3 1   "$H $L"                  \
+  4   15 14 "$H $M"                  \
+  5   0 15  "$H $M"                  \
+  6   1 15  "$L $M"                  \
+] {
+  do_test 1.7.$tn {
+    forcecopy test.db test.db2
+    forcecopy test.db-wal2 test.db2-wal
+    forcecopy test.db-wal test.db2-wal2
+
+    wal_set_nckpt test.db2-wal2 $nCkpt2
+    wal_set_nckpt test.db2-wal  $nCkpt1
+    wal_set_follow test.db2-wal test.db2-wal2
+
+
+    sqlite3 db2 test.db2
+    execsql {
+      SELECT sum(x) FROM t1;
+      SELECT sum(x) FROM t2;
+    } db2
+  } $res
+  db2 close
+}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 1.8.1 {
+  PRAGMA autovacuum = 0;
+  PRAGMA page_size = 4096;
+  CREATE TABLE t1(x);
+  CREATE TABLE t2(x);
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t1 SELECT i FROM s;
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t2 SELECT i FROM s;
+
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 10000;
+
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t2 SELECT i FROM s;
+} {wal2 10000}
+
+do_test 1.8.2 {
+  list [file size test.db-wal] [file size test.db-wal2]
+} {24752 0}
+
+do_execsql_test 1.8.3 { PRAGMA user_version = 123 }
+do_test 1.8.4 {
+  list [file size test.db-wal] [file size test.db-wal2]
+} {24752 4152}
+
+do_test 1.8.5 {
+  hexio_write test.db-wal2 [expr 56+16] 0400
+  fix_wal_cksums test.db-wal2
+} {}
+
+ifcapable oversize_cell_check {
+  set msg {database disk image is malformed}
+} else {
+  set msg {malformed database schema (?)}
+}
+
+do_test 1.8.6 {
+  forcecopy test.db test.db2
+  forcecopy test.db-wal test.db2-wal
+  forcecopy test.db-wal2 test.db2-wal2
+  sqlite3 db2 test.db2
+  catchsql { SELECT * FROM sqlite_master } db2
+} [list 1 $msg]
+db2 close
+
+finish_test
diff --git a/test/wal2recover3.test b/test/wal2recover3.test
new file mode 100644
index 0000000000..eab3011341
--- /dev/null
+++ b/test/wal2recover3.test
@@ -0,0 +1,52 @@
+# 2022 June 28
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2recover3
+ifcapable !wal {finish_test ; return }
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(x);
+  CREATE TABLE t2(x);
+  PRAGMA journal_mode = wal2;
+  PRAGMA wal_autocheckpoint = 0;
+  PRAGMA journal_size_limit = 10000;
+} {wal2 0 10000}
+
+do_execsql_test 1.1 {
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t1 SELECT i FROM s;
+  WITH s(i) AS ( VALUES(1) UNION ALL SELECT i+1 FROM s WHERE i<1500 )
+    INSERT INTO t2 SELECT i FROM s;
+}
+
+db_save_and_close
+set fd [open sv_test.db-wal2 r+]
+seek $fd 4000
+puts -nonewline $fd 0
+close $fd
+
+db_restore_and_reopen
+do_execsql_test 1.2 {
+  SELECT sql FROM sqlite_schema;
+} {{CREATE TABLE t1(x)} {CREATE TABLE t2(x)}}
+
+finish_test
+
diff --git a/test/wal2rewrite.test b/test/wal2rewrite.test
new file mode 100644
index 0000000000..7e3b7b17b5
--- /dev/null
+++ b/test/wal2rewrite.test
@@ -0,0 +1,92 @@
+# 2017 September 19
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2rewrite
+ifcapable !wal {finish_test ; return }
+
+proc filesize {filename} {
+  if {[file exists $filename]} {
+    return [file size $filename]
+  }
+  return 0
+}
+
+foreach {tn jrnlmode} {
+  1 wal
+  2 wal2
+} {
+  reset_db
+  execsql "PRAGMA journal_mode = $jrnlmode"
+  do_execsql_test $tn.1 {
+    PRAGMA journal_size_limit = 10000;
+    PRAGMA cache_size = 5;
+    PRAGMA wal_autocheckpoint = 10;
+  
+    CREATE TABLE t1(a INTEGER PRIMARY KEY, b INTEGER, c BLOB);
+    CREATE INDEX t1b ON t1(b);
+    CREATE INDEX t1c ON t1(c);
+  
+    WITH s(i) AS (
+      SELECT 1 UNION SELECT i+1 FROM s WHERE i<10
+    )
+    INSERT INTO t1 SELECT i, i, randomblob(800) FROM s;
+  } {10000 10}
+  
+  for {set i 0} {$i < 4} {incr i} {
+    do_execsql_test $tn.$i.1 {
+      UPDATE t1 SET c=randomblob(800) WHERE (b%10)==5 AND ($i%2)
+    }
+    do_execsql_test $tn.$i.2 {
+      BEGIN;
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+      UPDATE t1 SET b=b+10, c=randomblob(800);
+    }
+    execsql COMMIT
+
+    do_test $tn.$i.3 { expr [filesize test.db-wal]  < 100000 } 1
+    do_test $tn.$i.4 { expr [filesize test.db-wal2] < 100000 } 1
+
+    set sum [db eval {SELECT sum(b), md5sum(c) FROM t1}]
+
+    do_test $tn.$i.5 {
+      foreach f [glob -nocomplain test.db2*] {forcedelete $f}
+      foreach f [glob -nocomplain test.db*] {
+        forcecopy $f [string map {test.db test.db2} $f]
+      }
+
+      sqlite3 db2 test.db2
+      db2 eval {SELECT sum(b), md5sum(c) FROM t1}
+    } $sum
+    db2 close
+  }
+}
+    
+
+
+finish_test
diff --git a/test/wal2rollback.test b/test/wal2rollback.test
new file mode 100644
index 0000000000..91842ee220
--- /dev/null
+++ b/test/wal2rollback.test
@@ -0,0 +1,62 @@
+# 2017 September 19
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2rollback
+ifcapable !wal {finish_test ; return }
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b, c);
+  CREATE TABLE t2(a, b, c);
+  CREATE INDEX i1 ON t1(a);
+  CREATE INDEX i2 ON t1(b);
+  PRAGMA journal_mode = wal2;
+  PRAGMA cache_size = 5;
+  PRAGMA journal_size_limit = 10000;
+  WITH s(i) AS (
+    SELECT 1 UNION ALL SELECT i+1 FROM s LIMIT 1000
+  )
+  INSERT INTO t1 SELECT i, i, randomblob(200) FROM s;
+} {wal2 10000}
+
+do_test 1.1 {
+  expr [file size test.db-wal] > 10000
+} 1
+
+do_test 1.2 {
+  execsql {
+    BEGIN;
+      UPDATE t1 SET b=b+1;
+      INSERT INTO t2 VALUES(1,2,3);
+  }
+  expr [file size test.db-wal2] > 10000
+} {1}
+
+breakpoint
+do_execsql_test 1.3 {
+  ROLLBACK;
+  SELECT * FROM t2;
+  SELECT count(*) FROM t1 WHERE a=b;
+  PRAGMA integrity_check;
+} {1000 ok}
+
+
+
+finish_test
diff --git a/test/wal2savepoint.test b/test/wal2savepoint.test
new file mode 100644
index 0000000000..c9feb32259
--- /dev/null
+++ b/test/wal2savepoint.test
@@ -0,0 +1,73 @@
+# 2018 December 13
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2savepoint
+ifcapable !wal {finish_test ; return }
+
+reset_prng_state
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b, c);
+  CREATE INDEX t1a ON t1(a);
+  CREATE INDEX t1b ON t1(b);
+  CREATE INDEX t1c ON t1(c);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 15000;
+  PRAGMA wal_autocheckpoint = 0;
+  PRAGMA cache_size = 5;
+} {wal2 15000 0}
+
+do_execsql_test 1.1 {
+  WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 200)
+  INSERT INTO t1 SELECT random(), random(), random() FROM s;
+} {}
+
+do_test 1.2 {
+  list [file size test.db] [file size test.db-wal] [file size test.db-wal2]
+} {5120 23088 0}
+
+do_execsql_test 1.3 {
+  BEGIN;
+    SAVEPOINT abc;
+      WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 100)
+      INSERT INTO t1 SELECT random(), random(), random() FROM s;
+    ROLLBACK TO abc;
+    WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 10)
+    INSERT INTO t1 SELECT random(), random(), random() FROM s;
+  COMMIT;
+  SELECT count(*) FROM t1;
+  PRAGMA integrity_check;
+} {210 ok}
+
+do_execsql_test 1.4 {
+  BEGIN;
+    SAVEPOINT abc;
+      WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 100)
+      INSERT INTO t1 SELECT random(), random(), random() FROM s;
+    ROLLBACK TO abc;
+    WITH s(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM s where i < 10)
+    INSERT INTO t1 SELECT random(), random(), random() FROM s;
+  COMMIT;
+  SELECT count(*) FROM t1;
+  PRAGMA integrity_check;
+} {220 ok}
+
+
+finish_test
diff --git a/test/wal2simple.test b/test/wal2simple.test
new file mode 100644
index 0000000000..1a8c1e63bd
--- /dev/null
+++ b/test/wal2simple.test
@@ -0,0 +1,543 @@
+# 2017 September 19
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/lock_common.tcl
+source $testdir/malloc_common.tcl
+source $testdir/wal_common.tcl
+
+set testprefix wal2simple
+ifcapable !wal {finish_test ; return }
+
+#-------------------------------------------------------------------------
+# The following tests verify that a client can switch in and out of wal
+# and wal2 mode. But that it is not possible to change directly from wal
+# to wal2, or from wal2 to wal mode.
+#
+do_execsql_test 1.1.0 {
+  PRAGMA journal_mode = wal2
+} {wal2}
+execsql { SELECT * FROM sqlite_master} 
+do_execsql_test 1.x {
+  PRAGMA journal_mode;
+  PRAGMA main.journal_mode;
+} {wal2 wal2}
+db close
+do_test 1.1.1 { file size test.db } {1024}
+do_test 1.1.2 { hexio_read test.db 18 2 } 0303
+
+sqlite3 db test.db
+do_execsql_test 1.2.0 {
+  SELECT * FROM sqlite_master;
+  PRAGMA journal_mode = delete;
+} {delete}
+db close
+do_test 1.2.1 { file size test.db } {1024}
+do_test 1.2.2 { hexio_read test.db 18 2 } 0101
+
+sqlite3 db test.db
+do_execsql_test 1.3.0 {
+  SELECT * FROM sqlite_master;
+  PRAGMA journal_mode = wal;
+} {wal}
+db close
+do_test 1.3.1 { file size test.db } {1024}
+do_test 1.3.2 { hexio_read test.db 18 2 } 0202
+
+sqlite3 db test.db
+do_catchsql_test 1.4.0 {
+  PRAGMA journal_mode = wal2;
+} {1 {cannot change from wal to wal2 mode}}
+do_execsql_test 1.4.1 {
+  PRAGMA journal_mode = wal;
+  PRAGMA journal_mode = delete;
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_mode = wal2;
+} {wal delete wal2 wal2}
+do_catchsql_test 1.4.2 {
+  PRAGMA journal_mode = wal;
+} {1 {cannot change from wal2 to wal mode}}
+db close
+do_test 1.4.3 { hexio_read test.db 18 2 } 0303
+
+#-------------------------------------------------------------------------
+# Test that recovery in wal2 mode works.
+#
+forcedelete test.db test.db-wal test.db-wal2
+reset_db
+do_execsql_test 2.0 {
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 5000;
+} {wal2 5000}
+
+proc wal_hook {DB nm nFrame} { $DB eval { PRAGMA wal_checkpoint } }
+db wal_hook {wal_hook db}
+
+for {set i 1} {$i <= 200} {incr i} {
+  execsql { INSERT INTO t1 VALUES(NULL, randomblob(100)) }
+  set res [db eval { SELECT sum(a), md5sum(b) FROM t1 }]
+
+  do_test 2.1.$i {
+    foreach f [glob -nocomplain test.db2*] { forcedelete $f }
+    forcecopy test.db      test.db2
+    forcecopy test.db-wal  test.db2-wal
+    forcecopy test.db-wal2 test.db2-wal2
+
+    sqlite3 db2 test.db2
+    db2 eval { SELECT sum(a), md5sum(b) FROM t1 }
+  } $res
+
+  db2 close
+}
+
+#-------------------------------------------------------------------------
+
+reset_db
+do_execsql_test 3.0 {
+  CREATE TABLE t1(x BLOB, y INTEGER PRIMARY KEY);
+  CREATE INDEX i1 ON t1(x);
+  PRAGMA cache_size = 5;
+  PRAGMA journal_mode = wal2;
+} {wal2}
+
+do_test 3.1 {
+  execsql BEGIN
+  for {set i 1} {$i < 1000} {incr i} {
+    execsql { INSERT INTO t1 VALUES(randomblob(800), $i) }
+  }
+  execsql COMMIT
+} {}
+
+do_execsql_test 3.2 {
+  PRAGMA integrity_check;
+} {ok}
+
+#-------------------------------------------------------------------------
+catch { db close }
+foreach f [glob -nocomplain test.db*] { forcedelete $f }
+reset_db
+do_execsql_test 4.0 {
+  CREATE TABLE t1(x, y);
+  PRAGMA journal_mode = wal2;
+} {wal2}
+
+do_execsql_test 4.1 {
+  SELECT * FROM t1;
+} {}
+
+do_execsql_test 4.2 {
+  INSERT INTO t1 VALUES(1, 2);
+} {}
+
+do_execsql_test 4.3 {
+  SELECT * FROM t1;
+} {1 2}
+
+do_test 4.4 {
+  sqlite3 db2 test.db
+  execsql { SELECT * FROM t1 } db2
+} {1 2}
+
+do_test 4.5 {
+  lsort [glob test.db*]
+} {test.db test.db-shm test.db-wal test.db-wal2}
+
+do_test 4.6 {
+  db close
+  db2 close
+  sqlite3 db test.db
+  execsql { SELECT * FROM t1 }
+} {1 2}
+
+do_execsql_test 4.7 {
+  PRAGMA journal_size_limit = 4000;
+  INSERT INTO t1 VALUES(3, 4);
+  INSERT INTO t1 VALUES(5, 6);
+  INSERT INTO t1 VALUES(7, 8);
+  INSERT INTO t1 VALUES(9, 10);
+  INSERT INTO t1 VALUES(11, 12);
+  INSERT INTO t1 VALUES(13, 14);
+  INSERT INTO t1 VALUES(15, 16);
+  INSERT INTO t1 VALUES(17, 18);
+  SELECT * FROM t1;
+} {4000 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18}
+
+do_test 4.8 {
+  sqlite3 db2 test.db
+  execsql { SELECT * FROM t1 } db2
+} {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18}
+
+do_test 4.9 {
+  db close
+  db2 close
+  lsort [glob test.db*]
+} {test.db}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 5.0 {
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b, c);
+  CREATE INDEX i1 ON t1(b, c);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 4000;
+} {wal2 4000}
+
+proc wal_hook {DB nm nFrame} {
+  $DB eval { PRAGMA wal_checkpoint }
+}
+db wal_hook [list wal_hook db]
+
+
+foreach js {4000 8000 12000} {
+  foreach NROW [list 100 200 300 400 500 600 1000] {
+    do_test 5.$js.$NROW.1 {
+      db eval "DELETE FROM t1"
+      db eval "PRAGMA journal_size_limit = $js"
+      set nTotal 0
+      for {set i 0} {$i < $NROW} {incr i} {
+        db eval { INSERT INTO t1 VALUES($i, $i, randomblob(abs(random()%50))) }
+        incr nTotal $i
+      }
+      set {} {}
+    } {}
+
+    do_test 5.$js.$NROW.2 {
+      sqlite3 db2 test.db
+      db2 eval { 
+        PRAGMA integrity_check;
+        SELECT count(*), sum(b) FROM t1;
+      }
+    } [list ok $NROW $nTotal]
+
+    db2 close
+  }
+}
+
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 6.0 {
+  CREATE TABLE tx(x);
+  PRAGMA journal_mode = wal2;
+  PRAGMA journal_size_limit = 3500;
+} {wal2 3500}
+
+do_test 6.1 {
+  for {set i 0} {$i < 10} {incr i} {
+    execsql "CREATE TABLE t$i (x);"
+  }
+} {}
+
+do_test 6.2.1 {
+  foreach f [glob -nocomplain test.db2*] { forcedelete $f }
+  forcecopy test.db-wal2 test.db2-wal2
+  sqlite3 db2 test.db2
+  db2 eval { SELECT * FROM sqlite_master }
+} {}
+do_test 6.2.2 {
+  db2 eval {
+    PRAGMA journal_mode = wal2;
+    SELECT * FROM sqlite_master;
+  }
+} {wal2}
+
+do_test 6.3.1 {
+  db2 close
+  foreach f [glob -nocomplain test.db2*] { forcedelete $f }
+  forcecopy test.db-wal2 test.db2-wal2
+  forcecopy test.db test.db2
+  sqlite3 db2 test.db2
+  db2 eval { SELECT * FROM sqlite_master }
+} {table tx tx 2 {CREATE TABLE tx(x)}}
+do_test 6.3.2 {
+  db2 eval {
+    PRAGMA journal_mode = wal2;
+    SELECT * FROM sqlite_master;
+  }
+} {wal2 table tx tx 2 {CREATE TABLE tx(x)}}
+
+do_test 6.4.1 {
+  db2 close
+  foreach f [glob -nocomplain test.db2*] { forcedelete $f }
+  forcecopy test.db-wal2 test.db2-wal2
+  forcecopy test.db-wal test.db2-wal
+  sqlite3 db2 test.db2
+  db2 eval { SELECT * FROM sqlite_master }
+} {}
+do_test 6.4.2 {
+  db2 eval {
+    PRAGMA journal_mode = wal2;
+    SELECT * FROM sqlite_master;
+  }
+} {wal2}
+db2 close
+
+#-------------------------------------------------------------------------
+reset_db
+sqlite3 db2 test.db
+do_execsql_test 7.0 {
+  PRAGMA journal_size_limit = 10000;
+  PRAGMA journal_mode = wal2;
+  PRAGMA wal_autocheckpoint = 0;
+  BEGIN;
+    CREATE TABLE t1(a);
+    INSERT INTO t1 VALUES( randomblob(8000) );
+  COMMIT;
+} {10000 wal2 0}
+
+do_test 7.1 {
+  list [file size test.db-wal] [file size test.db-wal2]
+} {9464 0}
+
+# Connection db2 is holding a PART1 lock. 
+#
+#   7.2.2: Test that the PART1 does not prevent db from switching to the
+#          other wal file.
+#
+#   7.2.3: Test that the PART1 does prevent a checkpoint of test.db-wal.
+#
+#   7.2.4: Test that after the PART1 is released the checkpoint is possible.
+#
+do_test 7.2.1 {
+  execsql {
+    BEGIN;
+      SELECT count(*) FROM t1;
+  } db2
+} {1}
+do_test 7.2.2 {
+  execsql {
+    INSERT INTO t1 VALUES( randomblob(800) );
+    INSERT INTO t1 VALUES( randomblob(800) );
+  }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {13656 3176 1024}
+do_test 7.2.3 {
+  execsql { PRAGMA wal_checkpoint }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {13656 3176 1024}
+do_test 7.2.4 {
+  execsql { END } db2
+  execsql { PRAGMA wal_checkpoint }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {13656 3176 11264}
+
+# Connection db2 is holding a PART2_FULL1 lock. 
+#
+#   7.3.2: Test that the lock does not prevent checkpointing.
+#
+#   7.3.3: Test that the lock does prevent the writer from overwriting 
+#          test.db-wal.
+#
+#   7.3.4: Test that after the PART2_FULL1 is released the writer can
+#          switch wal files and overwrite test.db-wal
+#
+db close
+db2 close
+sqlite3 db test.db
+sqlite3 db2 test.db
+do_test 7.3.1 {
+  execsql {
+    PRAGMA wal_autocheckpoint = 0;
+    PRAGMA journal_size_limit = 10000;
+    INSERT INTO t1 VALUES(randomblob(10000));
+    INSERT INTO t1 VALUES(randomblob(500));
+  }
+  execsql {
+    BEGIN;
+      SELECT count(*) FROM t1;
+  } db2
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 3176 12288}
+do_test 7.3.2 {
+  execsql { PRAGMA wal_checkpoint }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 3176 22528}
+do_test 7.3.3 {
+  execsql { 
+    INSERT INTO t1 VALUES(randomblob(10000));
+    INSERT INTO t1 VALUES(randomblob(500));
+  }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 18896 22528}
+do_test 7.3.4 {
+  execsql END db2
+  execsql { INSERT INTO t1 VALUES(randomblob(5000)); }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 18896 22528}
+
+# Connection db2 is holding a PART2 lock. 
+#
+#   7.4.2: Test that the lock does not prevent writer switching to test.db-wal.
+#
+#   7.3.3: Test that the lock does prevent checkpointing of test.db-wal2.
+#
+#   7.3.4: Test that after the PART2 is released test.db-wal2 can be
+#          checkpointed.
+#
+db close
+db2 close
+breakpoint
+sqlite3 db test.db
+sqlite3 db2 test.db
+do_test 7.4.1 {
+  execsql {
+    PRAGMA wal_autocheckpoint = 0;
+    PRAGMA journal_size_limit = 10000;
+    INSERT INTO t1 VALUES(randomblob(10000));
+    INSERT INTO t1 VALUES(randomblob(10000));
+    PRAGMA wal_checkpoint;
+  }
+  execsql {
+    BEGIN;
+      SELECT count(*) FROM t1;
+  } db2
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 12608 50176}
+do_test 7.4.2 {
+  execsql { 
+    INSERT INTO t1 VALUES(randomblob(5000));
+  }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 12608 50176}
+do_test 7.4.3 {
+  execsql { PRAGMA wal_checkpoint }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 12608 50176}
+do_test 7.4.4 {
+  execsql END db2
+  execsql { PRAGMA wal_checkpoint }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 12608 60416}
+
+# Connection db2 is holding a PART1_FULL2 lock. 
+#
+#   7.5.2: Test that the lock does not prevent a checkpoint of test.db-wal2.
+#
+#   7.5.3: Test that the lock does prevent the writer from overwriting
+#          test.db-wal2.
+#
+#   7.5.4: Test that after the PART1_FULL2 lock is released, the writer
+#          can switch to test.db-wal2.
+#
+db close
+db2 close
+sqlite3 db test.db
+sqlite3 db2 test.db
+do_test 7.5.1 {
+  execsql {
+    PRAGMA wal_autocheckpoint = 0;
+    PRAGMA journal_size_limit = 10000;
+    INSERT INTO t1 VALUES(randomblob(10000));
+    INSERT INTO t1 VALUES(randomblob(10000));
+    PRAGMA wal_checkpoint;
+    INSERT INTO t1 VALUES(randomblob(5000));
+  }
+  execsql {
+    BEGIN;
+      SELECT count(*) FROM t1;
+  } db2
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 12608 76800}
+do_test 7.5.2 {
+  execsql { PRAGMA wal_checkpoint }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {12608 12608 87040}
+do_test 7.5.3.1 {
+  execsql { INSERT INTO t1 VALUES(randomblob(5000)) }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {14704 12608 87040}
+do_test 7.5.3.2 {
+  execsql { INSERT INTO t1 VALUES(randomblob(5000)) }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {22040 12608 87040}
+do_test 7.5.4 {
+  execsql END db2
+  execsql { INSERT INTO t1 VALUES(randomblob(5000)) }
+  list [file size test.db-wal] [file size test.db-wal2] [file size test.db]
+} {22040 12608 87040}
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 8.0 {
+  PRAGMA journal_size_limit = 10000;
+  PRAGMA journal_mode = wal2;
+  CREATE TABLE t1(x);
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  BEGIN;
+    INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+} {10000 wal2}
+
+sqlite3 db2 test.db
+do_execsql_test -db db2 8.1 {
+  PRAGMA wal_checkpoint;
+} {0 50 13}
+
+do_execsql_test 8.2 {
+  COMMIT;
+}
+
+db2 close
+
+
+#-------------------------------------------------------------------------
+reset_db
+do_execsql_test 9.0 {
+  PRAGMA journal_size_limit = 10000;
+  PRAGMA journal_mode = wal2;
+  CREATE TABLE t1(x);
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+} {10000 wal2}
+
+do_execsql_test 9.1 {
+  PRAGMA wal_checkpoint;
+} {0 50 13}
+
+
+#-------------------------------------------------------------------------
+# Check that it is possible to do a non-PASSIVE checkpoint on a wal2
+# db without blocking writers.
+#
+reset_db
+do_execsql_test 10.0 {
+  PRAGMA journal_size_limit = 10000;
+  PRAGMA journal_mode = wal2;
+  CREATE TABLE t1(x);
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+  BEGIN;
+    INSERT INTO t1 VALUES( hex( randomblob(5000) ) );
+} {10000 wal2}
+
+sqlite3 db2 test.db
+do_execsql_test -db db2 10.1 {
+  PRAGMA wal_checkpoint = FULL;
+} {0 50 13}
+
+do_execsql_test 10.2 {
+  COMMIT;
+}
+
+finish_test
+
diff --git a/test/wal2snapshot.test b/test/wal2snapshot.test
new file mode 100644
index 0000000000..fbc676b3da
--- /dev/null
+++ b/test/wal2snapshot.test
@@ -0,0 +1,93 @@
+# 2018 December 5
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this file is testing the operation of the library in
+# "PRAGMA journal_mode=WAL2" mode.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+set testprefix wal2snapshot
+ifcapable !wal {finish_test ; return }
+ifcapable !snapshot {finish_test; return}
+
+foreach {tn mode} {1 wal 2 wal2} {
+  reset_db
+  do_execsql_test $tn.1 "PRAGMA journal_mode = $mode" $mode
+
+  do_execsql_test $tn.2 {
+    CREATE TABLE t1(a, b);
+    INSERT INTO t1 VALUES(1, 2);
+    INSERT INTO t1 VALUES(3, 4);
+    BEGIN;
+  }
+
+  # Check that sqlite3_snapshot_get() is an error for a wal2 db.
+  #
+  if {$tn==1} {
+    do_test 1.3 {
+      set S [sqlite3_snapshot_get db main]
+      sqlite3_snapshot_free $S
+    } {}
+  } else {
+    do_test 2.3 {
+      list [catch { sqlite3_snapshot_get db main } msg] $msg
+    } {1 SQLITE_ERROR}
+  }
+  
+  # Check that sqlite3_snapshot_recover() is an error for a wal2 db.
+  #
+  do_execsql_test $tn.4 COMMIT
+  if {$tn==1} {
+    do_test 1.5 {
+      sqlite3_snapshot_recover db main
+    } {}
+  } else {
+    do_test 2.5 {
+      list [catch { sqlite3_snapshot_recover db main } msg] $msg
+    } {1 SQLITE_ERROR}
+  }
+ 
+  # Check that sqlite3_snapshot_open() is an error for a wal2 db.
+  #
+  if {$tn==1} {
+    do_test 1.6 {
+      execsql BEGIN
+      set SNAPSHOT [sqlite3_snapshot_get_blob db main]
+      sqlite3_snapshot_open_blob db main $SNAPSHOT
+      execsql COMMIT
+    } {}
+  } else {
+    do_test 2.6.1 {
+      execsql BEGIN
+      set res [
+        list [catch { sqlite3_snapshot_open_blob db main $SNAPSHOT } msg] $msg
+      ]
+      execsql COMMIT
+      set res
+    } {1 SQLITE_ERROR}
+    do_test 2.6.2 {
+      execsql BEGIN
+      execsql {SELECT * FROM sqlite_master}
+      set res [
+        list [catch { sqlite3_snapshot_open_blob db main $SNAPSHOT } msg] $msg
+      ]
+      execsql COMMIT
+      set res
+    } {1 SQLITE_ERROR}
+  }
+}
+
+
+finish_test
+
+
diff --git a/test/walprotocol2.test b/test/walprotocol2.test
index 0792c9aae0..389ccb5528 100644
--- a/test/walprotocol2.test
+++ b/test/walprotocol2.test
@@ -85,7 +85,7 @@ proc lock_callback {method filename handle lock} {
     db2 eval { INSERT INTO x VALUES('x') }
   }
 }
-db timeout 10
+db timeout 1100
 do_catchsql_test 2.4 {
   BEGIN EXCLUSIVE;
 } {0 {}}
diff --git a/test/walro.test b/test/walro.test
index a39b844d9d..ef1d2b8814 100644
--- a/test/walro.test
+++ b/test/walro.test
@@ -297,4 +297,49 @@ do_multiclient_test tn {
   } {}
 }
 
+#-------------------------------------------------------------------------
+
+proc write_hex_file {fname hex} {
+  set fd [open $fname wb]
+  fconfigure $fd -translation binary
+  puts -nonewline $fd [decode_hexdb $hex]
+  close $fd
+}
+
+write_hex_file test.db {
+| size 8192 pagesize 4096 filename badwal.db
+| page 1 offset 0
+|      0: 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00   SQLite format 3.
+|     16: 10 00 01 01 00 40 20 20 00 00 00 02 00 00 00 02   .....@  ........
+|     32: 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 04   ................
+|     48: 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00 00   ................
+|     80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02   ................
+|     96: 00 2e 76 89 0d 00 00 00 01 0f c3 00 0f c3 00 00   ..v.............
+|   4032: 00 00 00 3b 01 06 17 0f 0f 01 67 74 61 62 6c 65   ...;......gtable
+|   4048: 74 74 02 43 52 45 41 54 45 20 54 41 42 4c 45 20   tt.CREATE TABLE 
+|   4064: 74 28 78 20 49 4e 54 45 47 45 52 20 50 52 49 4d   t(x INTEGER PRIM
+|   4080: 41 52 59 20 4b 45 59 2c 20 79 20 54 45 58 54 29   ARY KEY, y TEXT)
+}
+
+write_hex_file test.db-wal {
+| size 56 pagesize 1024 filename badwal.db-wal
+| page 1 offset 0
+|      0: 37 7f 06 82 00 2d e2 18 00 00 00 00 00 00 00 00   7....-..........
+|     32: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00   ................
+| end badwal.db-wal
+}
+
+write_hex_file test.db-shm {
+| size 32 pagesize 1024 filename badwal.db-wal
+| page 1 offset 0
+|      0: 53 48 4d 2d 55 4e 55 53 45 44 2d 49 4e 2d 52 45   SHM-UNUSED-IN-RE
+|     16: 41 44 4f 4e 4c 59 2d 43 41 4e 54 49 4e 49 54 0a   ADONLY-CANTINIT.
+| end badwal.db-shm
+}
+
+sqlite3 db file:test.db?mode=ro&readonly_shm=1 -uri 1
+do_execsql_test 3.0 {
+  SELECT count(*) FROM sqlite_schema
+} {1}
+
 finish_test
diff --git a/tool/mkctimec.tcl b/tool/mkctimec.tcl
index 895182a287..8151a59b6f 100755
--- a/tool/mkctimec.tcl
+++ b/tool/mkctimec.tcl
@@ -396,6 +396,8 @@ set options(THREADSAFE) {
 #endif
 }
 
+set options(WAL2) { "WAL2", }
+
 proc trim_name {in} {
   set ret $in
   if {[string range $in 0 6]=="SQLITE_"} {
diff --git a/tool/version-info.c b/tool/version-info.c
index 149bad4f28..62fcd633c8 100644
--- a/tool/version-info.c
+++ b/tool/version-info.c
@@ -83,19 +83,11 @@ int main(int argc, char const * const * argv){
     printf("{\"libVersion\": \"%s\", "
            "\"libVersionNumber\": %d, "
            "\"sourceId\": \"%s\","
-           "\"downloadVersion\": %d,"
-           "\"scm\":{ "
-           "\"sha3-256\": \"%s\","
-           "\"branch\": \"" SQLITE_SCM_BRANCH "\","
-           "\"tags\": \"" SQLITE_SCM_TAGS "\","
-           "\"datetime\": \"" SQLITE_SCM_DATETIME "\""
-           "}"
-           "}"/*missing newline is intentional*/,
+           "\"downloadVersion\": %d}"/*missing newline is intentional*/,
            SQLITE_VERSION,
            SQLITE_VERSION_NUMBER,
            SQLITE_SOURCE_ID,
-           dlVersion,
-           SQLITE_SOURCE_ID+20);
+           dlVersion);
   }else{
     if(fQuote) printf("%c", '"');
     if( fVersion ){