Version 3.18.1

FossilOrigin-Name: 77bb46233db03a3338bacf7e56f439be3dfd1926ea0c44d252eeafa7a7b31c06
An unintentional fork was created due to a typo when creating branch-3.18.
2017-06-16 13:41:15 +00:00 · 2017-06-16 12:15:25 +00:00 · 2017-06-15 07:47:09 +00:00 · 2017-06-12 23:44:37 +00:00 · 2017-03-28 18:48:43 +00:00 · 2017-03-25 19:16:41 +00:00
64 changed files with 2227 additions and 1350 deletions
@@ -566,6 +566,7 @@ SHELL_OPT += -DSQLITE_ENABLE_EXPLAIN_COMMENTS
 SHELL_OPT += -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
 FUZZERSHELL_OPT = -DSQLITE_ENABLE_JSON1
 FUZZCHECK_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ
+FUZZCHECK_OPT += -DSQLITE_MAX_MEMORY=50000000
 FUZZCHECK_SRC = $(TOP)/test/fuzzcheck.c $(TOP)/test/ossfuzz.c
 DBFUZZ_OPT = 

@@ -620,7 +621,8 @@ fuzzcheck$(TEXE):	$(FUZZCHECK_SRC) sqlite3.c sqlite3.h
 	$(LTLINK) -o $@ $(FUZZCHECK_OPT) $(FUZZCHECK_SRC) sqlite3.c $(TLIBS)

 ossshell$(TEXE):	$(TOP)/test/ossfuzz.c $(TOP)/test/ossshell.c sqlite3.c sqlite3.h
-	$(LTLINK) -o $@ $(FUZZCHECK_OPT) $(TOP)/test/ossshell.c sqlite3.c sqlite3.h $(TLIBS)
+	$(LTLINK) -o $@ $(FUZZCHECK_OPT) $(TOP)/test/ossshell.c \
+             $(TOP)/test/ossfuzz.c sqlite3.c $(TLIBS)

 dbfuzz$(TEXE):	$(TOP)/test/dbfuzz.c sqlite3.c sqlite3.h
 	$(LTLINK) -o $@ $(DBFUZZ_OPT) $(TOP)/test/dbfuzz.c sqlite3.c $(TLIBS)
@@ -1153,6 +1155,10 @@ sqlite3_analyzer.c: sqlite3.c $(TOP)/src/tclsqlite.c $(TOP)/tool/spaceanal.tcl
 sqlite3_analyzer$(TEXE): sqlite3_analyzer.c
 	$(LTLINK) sqlite3_analyzer.c -o $@ $(LIBTCL) $(TLIBS)

+dbdump$(TEXE): $(TOP)/ext/misc/dbdump.c sqlite3.lo
+	$(LTLINK) -DDBDUMP_STANDALONE -o $@ \
+           $(TOP)/ext/misc/dbdump.c sqlite3.lo $(TLIBS)
+
 showdb$(TEXE):	$(TOP)/tool/showdb.c sqlite3.lo
 	$(LTLINK) -o $@ $(TOP)/tool/showdb.c sqlite3.lo $(TLIBS)

@@ -1185,11 +1191,6 @@ KV_OPT += -DSQLITE_DIRECT_OVERFLOW_READ
 kvtest$(TEXE):	$(TOP)/test/kvtest.c sqlite3.c
 	$(LTLINK) $(KV_OPT) -o $@ $(TOP)/test/kvtest.c sqlite3.c $(TLIBS)

-DBSELFTEST_OPT += -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_FTS4
-
-dbselftest$(TEXE):	$(TOP)/test/dbselftest.c sqlite3.c
-	$(LTLINK) $(DBSELFTEST_OPT) -o $@ $(TOP)/test/dbselftest.c sqlite3.c $(TLIBS)
-
 rbu$(EXE): $(TOP)/ext/rbu/rbu.c $(TOP)/ext/rbu/sqlite3rbu.c sqlite3.lo 
 	$(LTLINK) -I. -o $@ $(TOP)/ext/rbu/rbu.c sqlite3.lo $(TLIBS)

@@ -1510,7 +1510,7 @@ SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_SHELL_JSON1 -DSQLITE_ENABLE_
 #
 MPTESTER_COMPILE_OPTS = -DSQLITE_SHELL_JSON1 -DSQLITE_ENABLE_FTS5
 FUZZERSHELL_COMPILE_OPTS = -DSQLITE_ENABLE_JSON1
-FUZZCHECK_COMPILE_OPTS = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ
+FUZZCHECK_COMPILE_OPTS = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ -DSQLITE_MAX_MEMORY=50000000
 FUZZCHECK_SRC = $(TOP)\test\fuzzcheck.c $(TOP)\test\ossfuzz.c
 OSSSHELL_SRC = $(TOP)\test\ossshell.c $(TOP)\test\ossfuzz.c
 DBFUZZ_COMPILE_OPTS = -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION
@@ -2178,6 +2178,10 @@ sqlite3_analyzer.exe:	sqlite3_analyzer.c $(LIBRESOBJS)
 	$(LTLINK) $(NO_WARN) -DBUILD_sqlite -I$(TCLINCDIR) sqlite3_analyzer.c \
 		/link $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) $(LIBRESOBJS) $(LTLIBS) $(TLIBS)

+dbdump.exe:	$(TOP)\ext\misc\dbdump.c $(SQLITE3C) $(SQLITE3H)
+	$(LTLINK) $(NO_WARN) -DDBDUMP_STANDALONE $(TOP)\ext\misc\dbdump.c $(SQLITE3C) \
+		/link $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) $(LIBRESOBJS) $(LTLIBS)
+
 testloadext.lo:	$(TOP)\src\test_loadext.c
 	$(LTCOMPILE) $(NO_WARN) -c $(TOP)\src\test_loadext.c

@@ -2256,7 +2260,7 @@ clean:
 	del /Q tclsqlite3.exe $(SQLITETCLH) $(SQLITETCLDECLSH) 2>NUL
 	del /Q testloadext.dll 2>NUL
 	del /Q testfixture.exe test.db 2>NUL
-	del /Q LogEst.exe fts3view.exe rollback-test.exe showdb.exe 2>NUL
+	del /Q LogEst.exe fts3view.exe rollback-test.exe showdb.exe dbdump.exe 2>NUL
 	del /Q changeset.exe 2>NUL
 	del /Q showjournal.exe showstat4.exe showwal.exe speedtest1.exe 2>NUL
 	del /Q mptester.exe wordcount.exe rbu.exe srcck1.exe 2>NUL
@@ -8,6 +8,48 @@ If you are reading this on a Git mirror someplace, you are doing it wrong.
 The [official repository](https://www.sqlite.org/src/) is better.  Go there
 now.

+## Obtaining The Code
+
+SQLite sources are managed using the
+[Fossil](https://www.fossil-scm.org/), a distributed version control system
+that was specifically designed to support SQLite development.
+If you do not want to use Fossil, you can download tarballs or ZIP
+archives as follows:
+
+  *  Lastest trunk check-in:
+     <https://www.sqlite.org/src/tarball/sqlite.tar.gz> or
+     <https://www.sqlite.org/src/zip/sqlite.zip>.
+
+  *  Latest release:
+     <https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=release> or
+     <https://www.sqlite.org/src/zip/sqlite.zip?r=release>.
+
+  *  For other check-ins, substitute an appropriate branch name or
+     tag or hash prefix for "release" in the URLs of the previous
+     bullet.  Or browse the [timeline](https://www.sqlite.org/src/timeline)
+     to locate the check-in desired, click on its information page link,
+     then click on the "Tarball" or "ZIP Archive" links on the information
+     page.
+
+If you do want to use Fossil to check out the source tree, 
+first install Fossil version 2.0 or later.
+(Source tarballs and precompiled binaries available
+[here](https://www.fossil-scm.org/fossil/uv/download.html).)
+Then run commands like this:
+
+        mkdir ~/sqlite
+        cd ~/sqlite
+        fossil clone https://www.sqlite.org/src sqlite.fossil
+        fossil open sqlite.fossil
+    
+After setting up a repository using the steps above, you can always
+update to the lastest version using:
+
+        fossil update trunk   ;# latest trunk check-in
+        fossil update release ;# latest official release
+
+Or type "fossil ui" to get a web-based user interface.
+
 ## Compiling

 First create a directory in which to place
@@ -18,13 +60,13 @@ script found at the root of the source tree.  Then run "make".

 For example:

-    tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
-    mkdir bld                ;#  Build will occur in a sibling directory
-    cd bld                   ;#  Change to the build directory
-    ../sqlite/configure      ;#  Run the configure script
-    make                     ;#  Run the makefile.
-    make sqlite3.c           ;#  Build the "amalgamation" source file
-    make test                ;#  Run some tests (requires Tcl)
+        tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
+        mkdir bld                ;#  Build will occur in a sibling directory
+        cd bld                   ;#  Change to the build directory
+        ../sqlite/configure      ;#  Run the configure script
+        make                     ;#  Run the makefile.
+        make sqlite3.c           ;#  Build the "amalgamation" source file
+        make test                ;#  Run some tests (requires Tcl)

 See the makefile for additional targets.

@@ -43,13 +85,13 @@ with the provided "Makefile.msc" to build one of the supported targets.

 For example:

-    mkdir bld
-    cd bld
-    nmake /f Makefile.msc TOP=..\sqlite
-    nmake /f Makefile.msc sqlite3.c TOP=..\sqlite
-    nmake /f Makefile.msc sqlite3.dll TOP=..\sqlite
-    nmake /f Makefile.msc sqlite3.exe TOP=..\sqlite
-    nmake /f Makefile.msc test TOP=..\sqlite
+        mkdir bld
+        cd bld
+        nmake /f Makefile.msc TOP=..\sqlite
+        nmake /f Makefile.msc sqlite3.c TOP=..\sqlite
+        nmake /f Makefile.msc sqlite3.dll TOP=..\sqlite
+        nmake /f Makefile.msc sqlite3.exe TOP=..\sqlite
+        nmake /f Makefile.msc test TOP=..\sqlite

 There are several build options that can be set via the NMAKE command
 line.  For example, to build for WinRT, simply add "FOR_WINRT=1" argument
@@ -1 +1 @@
-3.18.0
+3.18.1
@@ -644,6 +644,7 @@ RCC = $(RCC) -DSQLITE_ENABLE_API_ARMOR=1

 !IF $(DEBUG)>2
 TCC = $(TCC) -DSQLITE_DEBUG=1
+TCC = $(TCC) -DSQLITE_ENABLE_WHERETRACE -DSQLITE_ENABLE_SELECTTRACE
 RCC = $(RCC) -DSQLITE_DEBUG=1
 !ENDIF

@@ -55,9 +55,9 @@ AS_IF([ test x"$enable_editline" != xno ],[
    LIBS=""
    AC_SEARCH_LIBS([readline],[edit],[
      AC_DEFINE([HAVE_EDITLINE],1,Define to use BSD editline)
-      READLINE_LIBS=$LIBS
+      READLINE_LIBS="$LIBS -ltinfo"
      enable_readline=no
-    ])
+    ],[],[-ltinfo])
    AS_UNSET(ac_cv_search_readline)
    LIBS=$sLIBS
  ])
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for sqlite 3.18.0.
+# Generated by GNU Autoconf 2.69 for sqlite 3.18.1.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -726,8 +726,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='sqlite'
 PACKAGE_TARNAME='sqlite'
-PACKAGE_VERSION='3.18.0'
-PACKAGE_STRING='sqlite 3.18.0'
+PACKAGE_VERSION='3.18.1'
+PACKAGE_STRING='sqlite 3.18.1'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''

@@ -1463,7 +1463,7 @@ if test "$ac_init_help" = "long"; then
  # Omit some internal or obsolete options to make the list less imposing.
  # This message is too long to be a string in the A/UX 3.1 sh.
  cat <<_ACEOF
-\`configure' configures sqlite 3.18.0 to adapt to many kinds of systems.
+\`configure' configures sqlite 3.18.1 to adapt to many kinds of systems.

 Usage: $0 [OPTION]... [VAR=VALUE]...

@@ -1528,7 +1528,7 @@ fi

 if test -n "$ac_init_help"; then
  case $ac_init_help in
-     short | recursive ) echo "Configuration of sqlite 3.18.0:";;
+     short | recursive ) echo "Configuration of sqlite 3.18.1:";;
   esac
  cat <<\_ACEOF

@@ -1652,7 +1652,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
  cat <<\_ACEOF
-sqlite configure 3.18.0
+sqlite configure 3.18.1
 generated by GNU Autoconf 2.69

 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2071,7 +2071,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.

-It was created by sqlite $as_me 3.18.0, which was
+It was created by sqlite $as_me 3.18.1, which was
 generated by GNU Autoconf 2.69.  Invocation command line was

  $ $0 $@
@@ -12151,7 +12151,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by sqlite $as_me 3.18.0, which was
+This file was extended by sqlite $as_me 3.18.1, which was
 generated by GNU Autoconf 2.69.  Invocation command line was

  CONFIG_FILES    = $CONFIG_FILES
@@ -12217,7 +12217,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-sqlite config.status 3.18.0
+sqlite config.status 3.18.1
 configured by $0, generated by GNU Autoconf 2.69,
  with options \\"\$ac_cs_config\\"

@@ -13829,4 +13829,3 @@ if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
 fi
-
@@ -0,0 +1,8 @@
+## Loadable Extensions
+
+Various [loadable extensions](https://www.sqlite.org/loadext.html) for
+SQLite are found in subfolders.
+
+Most subfolders are dedicated to a single loadable extension (for
+example FTS5, or RTREE).  But the misc/ subfolder contains a collection
+of smaller single-file extensions.
@@ -1,2 +0,0 @@
-Version loadable extensions to SQLite are found in subfolders
-of this folder.
@@ -349,8 +349,9 @@ int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){
 ** Return the number of bytes read, or 0 on error.
 ** The value is stored in *v.
 */
-int sqlite3Fts3GetVarint(const char *p, sqlite_int64 *v){
-  const char *pStart = p;
+int sqlite3Fts3GetVarint(const char *pBuf, sqlite_int64 *v){
+  const unsigned char *p = (const unsigned char*)pBuf;
+  const unsigned char *pStart = p;
  u32 a;
  u64 b;
  int shift;
@@ -1397,7 +1398,9 @@ static int fts3InitVtab(
    char *z; 
    int n = 0;
    z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
-    memcpy(zCsr, z, n);
+    if( n>0 ){
+      memcpy(zCsr, z, n);
+    }
    zCsr[n] = '\0';
    sqlite3Fts3Dequote(zCsr);
    p->azColumn[iCol] = zCsr;
@@ -136,16 +136,16 @@ static int unicodeAddExceptions(
 ){
  const unsigned char *z = (const unsigned char *)zIn;
  const unsigned char *zTerm = &z[nIn];
-  int iCode;
+  unsigned int iCode;
  int nEntry = 0;

  assert( bAlnum==0 || bAlnum==1 );

  while( z<zTerm ){
    READ_UTF8(z, zTerm, iCode);
-    assert( (sqlite3FtsUnicodeIsalnum(iCode) & 0xFFFFFFFE)==0 );
-    if( sqlite3FtsUnicodeIsalnum(iCode)!=bAlnum 
-     && sqlite3FtsUnicodeIsdiacritic(iCode)==0 
+    assert( (sqlite3FtsUnicodeIsalnum((int)iCode) & 0xFFFFFFFE)==0 );
+    if( sqlite3FtsUnicodeIsalnum((int)iCode)!=bAlnum 
+     && sqlite3FtsUnicodeIsdiacritic((int)iCode)==0 
    ){
      nEntry++;
    }
@@ -162,13 +162,13 @@ static int unicodeAddExceptions(
    z = (const unsigned char *)zIn;
    while( z<zTerm ){
      READ_UTF8(z, zTerm, iCode);
-      if( sqlite3FtsUnicodeIsalnum(iCode)!=bAlnum 
-       && sqlite3FtsUnicodeIsdiacritic(iCode)==0
+      if( sqlite3FtsUnicodeIsalnum((int)iCode)!=bAlnum 
+       && sqlite3FtsUnicodeIsdiacritic((int)iCode)==0
      ){
        int i, j;
-        for(i=0; i<nNew && aNew[i]<iCode; i++);
+        for(i=0; i<nNew && aNew[i]<(int)iCode; i++);
        for(j=nNew; j>i; j--) aNew[j] = aNew[j-1];
-        aNew[i] = iCode;
+        aNew[i] = (int)iCode;
        nNew++;
      }
    }
@@ -318,7 +318,7 @@ static int unicodeNext(
 ){
  unicode_cursor *pCsr = (unicode_cursor *)pC;
  unicode_tokenizer *p = ((unicode_tokenizer *)pCsr->base.pTokenizer);
-  int iCode = 0;
+  unsigned int iCode = 0;
  char *zOut;
  const unsigned char *z = &pCsr->aInput[pCsr->iOff];
  const unsigned char *zStart = z;
@@ -330,7 +330,7 @@ static int unicodeNext(
  ** the input.  */
  while( z<zTerm ){
    READ_UTF8(z, zTerm, iCode);
-    if( unicodeIsAlnum(p, iCode) ) break;
+    if( unicodeIsAlnum(p, (int)iCode) ) break;
    zStart = z;
  }
  if( zStart>=zTerm ) return SQLITE_DONE;
@@ -350,7 +350,7 @@ static int unicodeNext(

    /* Write the folded case of the last character read to the output */
    zEnd = z;
-    iOut = sqlite3FtsUnicodeFold(iCode, p->bRemoveDiacritic);
+    iOut = sqlite3FtsUnicodeFold((int)iCode, p->bRemoveDiacritic);
    if( iOut ){
      WRITE_UTF8(zOut, iOut);
    }
@@ -358,8 +358,8 @@ static int unicodeNext(
    /* If the cursor is not at EOF, read the next character */
    if( z>=zTerm ) break;
    READ_UTF8(z, zTerm, iCode);
-  }while( unicodeIsAlnum(p, iCode) 
-       || sqlite3FtsUnicodeIsdiacritic(iCode)
+  }while( unicodeIsAlnum(p, (int)iCode) 
+       || sqlite3FtsUnicodeIsdiacritic((int)iCode)
  );

  /* Set the output variables and return. */
@@ -127,9 +127,9 @@ int sqlite3FtsUnicodeIsalnum(int c){
    0xFFFFFFFF, 0xFC00FFFF, 0xF8000001, 0xF8000001,
  };

-  if( c<128 ){
-    return ( (aAscii[c >> 5] & (1 << (c & 0x001F)))==0 );
-  }else if( c<(1<<22) ){
+  if( (unsigned int)c<128 ){
+    return ( (aAscii[c >> 5] & ((unsigned int)1 << (c & 0x001F)))==0 );
+  }else if( (unsigned int)c<(1<<22) ){
    unsigned int key = (((unsigned int)c)<<10) | 0x000003FF;
    int iRes = 0;
    int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1;
@@ -322,16 +322,17 @@ int sqlite3FtsUnicodeFold(int c, int bRemoveDiacritic){

  int ret = c;

-  assert( c>=0 );
  assert( sizeof(unsigned short)==2 && sizeof(unsigned char)==1 );

  if( c<128 ){
    if( c>='A' && c<='Z' ) ret = c + ('a' - 'A');
  }else if( c<65536 ){
+    const struct TableEntry *p;
    int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1;
    int iLo = 0;
    int iRes = -1;

+    assert( c>aEntry[0].iCode );
    while( iHi>=iLo ){
      int iTest = (iHi + iLo) / 2;
      int cmp = (c - aEntry[iTest].iCode);
@@ -342,14 +343,12 @@ int sqlite3FtsUnicodeFold(int c, int bRemoveDiacritic){
        iHi = iTest-1;
      }
    }
-    assert( iRes<0 || c>=aEntry[iRes].iCode );

-    if( iRes>=0 ){
-      const struct TableEntry *p = &aEntry[iRes];
-      if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
-        ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
-        assert( ret>0 );
-      }
+    assert( iRes>=0 && c>=aEntry[iRes].iCode );
+    p = &aEntry[iRes];
+    if( c<(p->iCode + p->nRange) && 0==(0x01 & p->flags & (p->iCode ^ c)) ){
+      ret = (c + (aiOff[p->flags>>1])) & 0x0000FFFF;
+      assert( ret>0 );
    }

    if( bRemoveDiacritic ) ret = remove_diacritic(ret);
@@ -4956,11 +4956,14 @@ int sqlite3Fts3Incrmerge(Fts3Table *p, int nMerge, int nMin){
 ** Convert the text beginning at *pz into an integer and return
 ** its value.  Advance *pz to point to the first character past
 ** the integer.
+**
+** This function used for parameters to merge= and incrmerge=
+** commands. 
 */
 static int fts3Getint(const char **pz){
  const char *z = *pz;
  int i = 0;
-  while( (*z)>='0' && (*z)<='9' ) i = 10*i + *(z++) - '0';
+  while( (*z)>='0' && (*z)<='9' && i<214748363 ) i = 10*i + *(z++) - '0';
  *pz = z;
  return i;
 }
@@ -0,0 +1,16 @@
+#!/bin/sh
+
+set -e
+
+srcdir=`dirname $(dirname $(dirname $(dirname $0)))`
+./testfixture $srcdir/test/fts3.test --output=fts3cov-out.txt
+
+echo ""
+
+for f in `ls $srcdir/ext/fts3/*.c` 
+do
+  f=`basename $f`
+  echo -ne "$f: "
+  gcov -b $f | grep Taken | sed 's/Taken at least once://'
+done
+
@@ -227,7 +227,7 @@ proc print_isalnum {zFunc lRange} {
  an_print_ascii_bitmap $lRange
  puts {
  if( (unsigned int)c<128 ){
-    return ( (aAscii[c >> 5] & (1 << (c & 0x001F)))==0 );
+    return ( (aAscii[c >> 5] & ((unsigned int)1 << (c & 0x001F)))==0 );
  }else if( (unsigned int)c<(1<<22) ){
    unsigned int key = (((unsigned int)c)<<10) | 0x000003FF;
    int iRes = 0;
@@ -0,0 +1,40 @@
+## Miscellaneous Extensions
+
+This folder contains a collection of smaller loadable extensions.
+See <https://www.sqlite.org/loadext.html> for instructions on how
+to compile and use loadable extensions.
+Each extension in this folder is implemented in a single file of C code.
+
+Each source file contains a description in its header comment.  See the
+header comments for details about each extension.  Additional notes are
+as follows:
+
+  *  **carray.c** &mdash;  This module implements the
+     [carray](https://www.sqlite.org/carray.html) table-valued function.
+     It is a good example of how to go about implementing a custom
+     [table-valued function](https://www.sqlite.org/vtab.html#tabfunc2).
+
+  *  **dbdump.c** &mdash;  This is not actually a loadable extension, but
+     rather a library that implements an approximate equivalent to the
+     ".dump" command of the
+     [command-line shell](https://www.sqlite.org/cli.html).
+
+  *  **memvfs.c** &mdash;  This file implements a custom
+     [VFS](https://www.sqlite.org/vfs.html) that stores an entire database
+     file in a single block of RAM.  It serves as a good example of how
+     to implement a simple custom VFS.
+
+  *  **rot13.c** &mdash;  This file implements the very simple rot13()
+     substitution function.  This file makes a good template for implementing
+     new custom SQL functions for SQLite.
+
+  *  **series.c** &mdash;  This is an implementation of the
+     "generate_series" [virtual table](https://www.sqlite.org/vtab.html).
+     It can make a good template for new custom virtual table implementations.
+
+  *  **shathree.c** &mdash;  An implementation of the sha3() and
+     sha3_query() SQL functions.  The file is named "shathree.c" instead
+     of "sha3.c" because the default entry point names in SQLite are based
+     on the source filename with digits removed, so if we used the name
+     "sha3.c" then the entry point would conflict with the prior "sha1.c"
+     extension.
@@ -0,0 +1,717 @@
+/*
+** 2016-03-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 a C-language subroutine that converts the content
+** of an SQLite database into UTF-8 text SQL statements that can be used
+** to exactly recreate the original database.  ROWID values are preserved.
+**
+** A prototype of the implemented subroutine is this:
+**
+**   int sqlite3_db_dump(
+**          sqlite3 *db,
+**          const char *zSchema,
+**          const char *zTable,
+**          void (*xCallback)(void*, const char*),
+**          void *pArg
+**   );
+**
+** The db parameter is the database connection.  zSchema is the schema within
+** that database which is to be dumped.  Usually the zSchema is "main" but
+** can also be "temp" or any ATTACH-ed database.  If zTable is not NULL, then
+** only the content of that one table is dumped.  If zTable is NULL, then all
+** tables are dumped.
+**
+** The generate text is passed to xCallback() in multiple calls.  The second
+** argument to xCallback() is a copy of the pArg parameter.  The first
+** argument is some of the output text that this routine generates.  The
+** signature to xCallback() is designed to make it compatible with fputs().
+**
+** The sqlite3_db_dump() subroutine returns SQLITE_OK on success or some error
+** code if it encounters a problem.
+**
+** If this file is compiled with -DDBDUMP_STANDALONE then a "main()" routine
+** is included so that this routine becomes a command-line utility.  The
+** command-line utility takes two or three arguments which are the name
+** of the database file, the schema, and optionally the table, forming the
+** first three arguments of a single call to the library routine.
+*/
+#include "sqlite3.h"
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+
+/*
+** The state of the dump process.
+*/
+typedef struct DState DState;
+struct DState {
+  sqlite3 *db;                /* The database connection */
+  int nErr;                   /* Number of errors seen so far */
+  int rc;                     /* Error code */
+  int writableSchema;                    /* True if in writable_schema mode */
+  int (*xCallback)(const char*,void*);   /* Send output here */
+  void *pArg;                            /* Argument to xCallback() */
+};
+
+/*
+** A variable length string to which one can append text.
+*/
+typedef struct DText DText;
+struct DText {
+  char *z;           /* The text */
+  int n;             /* Number of bytes of content in z[] */
+  int nAlloc;        /* Number of bytes allocated to z[] */
+};
+
+/*
+** Initialize and destroy a DText object
+*/
+static void initText(DText *p){
+  memset(p, 0, sizeof(*p));
+}
+static void freeText(DText *p){
+  sqlite3_free(p->z);
+  initText(p);
+}
+
+/* zIn is either a pointer to a NULL-terminated string in memory obtained
+** from malloc(), or a NULL pointer. The string pointed to by zAppend is
+** added to zIn, and the result returned in memory obtained from malloc().
+** zIn, if it was not NULL, is freed.
+**
+** If the third argument, quote, is not '\0', then it is used as a
+** quote character for zAppend.
+*/
+static void appendText(DText *p, char const *zAppend, char quote){
+  int len;
+  int i;
+  int nAppend = (int)(strlen(zAppend) & 0x3fffffff);
+
+  len = nAppend+p->n+1;
+  if( quote ){
+    len += 2;
+    for(i=0; i<nAppend; i++){
+      if( zAppend[i]==quote ) len++;
+    }
+  }
+
+  if( p->n+len>=p->nAlloc ){
+    char *zNew;
+    p->nAlloc = p->nAlloc*2 + len + 20;
+    zNew = sqlite3_realloc(p->z, p->nAlloc);
+    if( zNew==0 ){
+      freeText(p);
+      return;
+    }
+    p->z = zNew;
+  }
+
+  if( quote ){
+    char *zCsr = p->z+p->n;
+    *zCsr++ = quote;
+    for(i=0; i<nAppend; i++){
+      *zCsr++ = zAppend[i];
+      if( zAppend[i]==quote ) *zCsr++ = quote;
+    }
+    *zCsr++ = quote;
+    p->n = (int)(zCsr - p->z);
+    *zCsr = '\0';
+  }else{
+    memcpy(p->z+p->n, zAppend, nAppend);
+    p->n += nAppend;
+    p->z[p->n] = '\0';
+  }
+}
+
+/*
+** Attempt to determine if identifier zName needs to be quoted, either
+** because it contains non-alphanumeric characters, or because it is an
+** SQLite keyword.  Be conservative in this estimate:  When in doubt assume
+** that quoting is required.
+**
+** Return '"' if quoting is required.  Return 0 if no quoting is required.
+*/
+static char quoteChar(const char *zName){
+  /* All SQLite keywords, in alphabetical order */
+  static const char *azKeywords[] = {
+    "ABORT", "ACTION", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "AS",
+    "ASC", "ATTACH", "AUTOINCREMENT", "BEFORE", "BEGIN", "BETWEEN", "BY",
+    "CASCADE", "CASE", "CAST", "CHECK", "COLLATE", "COLUMN", "COMMIT",
+    "CONFLICT", "CONSTRAINT", "CREATE", "CROSS", "CURRENT_DATE",
+    "CURRENT_TIME", "CURRENT_TIMESTAMP", "DATABASE", "DEFAULT", "DEFERRABLE",
+    "DEFERRED", "DELETE", "DESC", "DETACH", "DISTINCT", "DROP", "EACH",
+    "ELSE", "END", "ESCAPE", "EXCEPT", "EXCLUSIVE", "EXISTS", "EXPLAIN",
+    "FAIL", "FOR", "FOREIGN", "FROM", "FULL", "GLOB", "GROUP", "HAVING", "IF",
+    "IGNORE", "IMMEDIATE", "IN", "INDEX", "INDEXED", "INITIALLY", "INNER",
+    "INSERT", "INSTEAD", "INTERSECT", "INTO", "IS", "ISNULL", "JOIN", "KEY",
+    "LEFT", "LIKE", "LIMIT", "MATCH", "NATURAL", "NO", "NOT", "NOTNULL",
+    "NULL", "OF", "OFFSET", "ON", "OR", "ORDER", "OUTER", "PLAN", "PRAGMA",
+    "PRIMARY", "QUERY", "RAISE", "RECURSIVE", "REFERENCES", "REGEXP",
+    "REINDEX", "RELEASE", "RENAME", "REPLACE", "RESTRICT", "RIGHT",
+    "ROLLBACK", "ROW", "SAVEPOINT", "SELECT", "SET", "TABLE", "TEMP",
+    "TEMPORARY", "THEN", "TO", "TRANSACTION", "TRIGGER", "UNION", "UNIQUE",
+    "UPDATE", "USING", "VACUUM", "VALUES", "VIEW", "VIRTUAL", "WHEN", "WHERE",
+    "WITH", "WITHOUT",
+  };
+  int i, lwr, upr, mid, c;
+  if( !isalpha((unsigned char)zName[0]) && zName[0]!='_' ) return '"';
+  for(i=0; zName[i]; i++){
+    if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ) return '"';
+  }
+  lwr = 0;
+  upr = sizeof(azKeywords)/sizeof(azKeywords[0]) - 1;
+  while( lwr<=upr ){
+    mid = (lwr+upr)/2;
+    c = sqlite3_stricmp(azKeywords[mid], zName);
+    if( c==0 ) return '"';
+    if( c<0 ){
+      lwr = mid+1;
+    }else{
+      upr = mid-1;
+    }
+  }
+  return 0;
+}
+
+
+/*
+** Release memory previously allocated by tableColumnList().
+*/
+static void freeColumnList(char **azCol){
+  int i;
+  for(i=1; azCol[i]; i++){
+    sqlite3_free(azCol[i]);
+  }
+  /* azCol[0] is a static string */
+  sqlite3_free(azCol);
+}
+
+/*
+** Return a list of pointers to strings which are the names of all
+** columns in table zTab.   The memory to hold the names is dynamically
+** allocated and must be released by the caller using a subsequent call
+** to freeColumnList().
+**
+** The azCol[0] entry is usually NULL.  However, if zTab contains a rowid
+** value that needs to be preserved, then azCol[0] is filled in with the
+** name of the rowid column.
+**
+** The first regular column in the table is azCol[1].  The list is terminated
+** by an entry with azCol[i]==0.
+*/
+static char **tableColumnList(DState *p, const char *zTab){
+  char **azCol = 0;
+  sqlite3_stmt *pStmt = 0;
+  char *zSql;
+  int nCol = 0;
+  int nAlloc = 0;
+  int nPK = 0;       /* Number of PRIMARY KEY columns seen */
+  int isIPK = 0;     /* True if one PRIMARY KEY column of type INTEGER */
+  int preserveRowid = 1;
+  int rc;
+
+  zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
+  if( zSql==0 ) return 0;
+  rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
+  sqlite3_free(zSql);
+  if( rc ) return 0;
+  while( sqlite3_step(pStmt)==SQLITE_ROW ){
+    if( nCol>=nAlloc-2 ){
+      char **azNew;
+      nAlloc = nAlloc*2 + nCol + 10;
+      azNew = sqlite3_realloc(azCol, nAlloc*sizeof(azCol[0]));
+      if( azNew==0 ) goto col_oom;
+      azCol = azNew;
+      azCol[0] = 0;
+    }
+    azCol[++nCol] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 1));
+    if( azCol[nCol]==0 ) goto col_oom;
+    if( sqlite3_column_int(pStmt, 5) ){
+      nPK++;
+      if( nPK==1
+       && sqlite3_stricmp((const char*)sqlite3_column_text(pStmt,2),
+                          "INTEGER")==0 
+      ){
+        isIPK = 1;
+      }else{
+        isIPK = 0;
+      }
+    }
+  }
+  sqlite3_finalize(pStmt);
+  pStmt = 0;
+  azCol[nCol+1] = 0;
+
+  /* The decision of whether or not a rowid really needs to be preserved
+  ** is tricky.  We never need to preserve a rowid for a WITHOUT ROWID table
+  ** or a table with an INTEGER PRIMARY KEY.  We are unable to preserve
+  ** rowids on tables where the rowid is inaccessible because there are other
+  ** columns in the table named "rowid", "_rowid_", and "oid".
+  */
+  if( isIPK ){
+    /* If a single PRIMARY KEY column with type INTEGER was seen, then it
+    ** might be an alise for the ROWID.  But it might also be a WITHOUT ROWID
+    ** table or a INTEGER PRIMARY KEY DESC column, neither of which are
+    ** ROWID aliases.  To distinguish these cases, check to see if
+    ** there is a "pk" entry in "PRAGMA index_list".  There will be
+    ** no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
+    */
+    zSql = sqlite3_mprintf("SELECT 1 FROM pragma_index_list(%Q)"
+                           " WHERE origin='pk'", zTab);
+    if( zSql==0 ) goto col_oom;
+    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
+    sqlite3_free(zSql);
+    if( rc ){
+      freeColumnList(azCol);
+      return 0;
+    }
+    rc = sqlite3_step(pStmt);
+    sqlite3_finalize(pStmt);
+    pStmt = 0;
+    preserveRowid = rc==SQLITE_ROW;
+  }
+  if( preserveRowid ){
+    /* Only preserve the rowid if we can find a name to use for the
+    ** rowid */
+    static char *azRowid[] = { "rowid", "_rowid_", "oid" };
+    int i, j;
+    for(j=0; j<3; j++){
+      for(i=1; i<=nCol; i++){
+        if( sqlite3_stricmp(azRowid[j],azCol[i])==0 ) break;
+      }
+      if( i>nCol ){
+        /* At this point, we know that azRowid[j] is not the name of any
+        ** ordinary column in the table.  Verify that azRowid[j] is a valid
+        ** name for the rowid before adding it to azCol[0].  WITHOUT ROWID
+        ** tables will fail this last check */
+        int rc;
+        rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
+        if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
+        break;
+      }
+    }
+  }
+  return azCol;
+
+col_oom:
+  sqlite3_finalize(pStmt);
+  freeColumnList(azCol);
+  p->nErr++;
+  p->rc = SQLITE_NOMEM;
+  return 0;
+}
+
+/*
+** Send mprintf-formatted content to the output callback.
+*/
+static void output_formatted(DState *p, const char *zFormat, ...){
+  va_list ap;
+  char *z;
+  va_start(ap, zFormat);
+  z = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  p->xCallback(z, p->pArg);
+  sqlite3_free(z);
+}
+
+/*
+** Output the given string as a quoted string using SQL quoting conventions.
+**
+** The "\n" and "\r" characters are converted to char(10) and char(13)
+** to prevent them from being transformed by end-of-line translators.
+*/
+static void output_quoted_string(DState *p, const unsigned char *z){
+  int i;
+  char c;
+  int inQuote = 0;
+  int bStarted = 0;
+
+  for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
+  if( c==0 ){
+    output_formatted(p, "'%s'", z);
+    return;
+  }
+  while( *z ){
+    for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
+    if( c=='\'' ) i++;
+    if( i ){
+      if( !inQuote ){
+        if( bStarted ) p->xCallback("||", p->pArg);
+        p->xCallback("'", p->pArg);
+        inQuote = 1;
+      }
+      output_formatted(p, "%.*s", i, z);
+      z += i;
+      bStarted = 1;
+    }
+    if( c=='\'' ){
+      p->xCallback("'", p->pArg);
+      continue;
+    }
+    if( inQuote ){
+      p->xCallback("'", p->pArg);
+      inQuote = 0;
+    }
+    if( c==0 ){
+      break;
+    }
+    for(i=0; (c = z[i])=='\r' || c=='\n'; i++){
+      if( bStarted ) p->xCallback("||", p->pArg);
+      output_formatted(p, "char(%d)", c);
+      bStarted = 1;
+    }
+    z += i;
+  }
+  if( inQuote ) p->xCallback("'", p->pArg);
+}
+
+/*
+** This is an sqlite3_exec callback routine used for dumping the database.
+** Each row received by this callback consists of a table name,
+** the table type ("index" or "table") and SQL to create the table.
+** This routine should print text sufficient to recreate the table.
+*/
+static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
+  int rc;
+  const char *zTable;
+  const char *zType;
+  const char *zSql;
+  DState *p = (DState*)pArg;
+  sqlite3_stmt *pStmt;
+
+  (void)azCol;
+  if( nArg!=3 ) return 1;
+  zTable = azArg[0];
+  zType = azArg[1];
+  zSql = azArg[2];
+
+  if( strcmp(zTable, "sqlite_sequence")==0 ){
+    p->xCallback("DELETE FROM sqlite_sequence;\n", p->pArg);
+  }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
+    p->xCallback("ANALYZE sqlite_master;\n", p->pArg);
+  }else if( strncmp(zTable, "sqlite_", 7)==0 ){
+    return 0;
+  }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
+    if( !p->writableSchema ){
+      p->xCallback("PRAGMA writable_schema=ON;\n", p->pArg);
+      p->writableSchema = 1;
+    }
+    output_formatted(p,
+       "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
+       "VALUES('table','%q','%q',0,'%q');",
+       zTable, zTable, zSql);
+    return 0;
+  }else{
+    if( sqlite3_strglob("CREATE TABLE ['\"]*", zSql)==0 ){
+      p->xCallback("CREATE TABLE IF NOT EXISTS ", p->pArg);
+      p->xCallback(zSql+13, p->pArg);
+    }else{
+      p->xCallback(zSql, p->pArg);
+    }
+    p->xCallback(";\n", p->pArg);
+  }
+
+  if( strcmp(zType, "table")==0 ){
+    DText sSelect;
+    DText sTable;
+    char **azCol;
+    int i;
+    int nCol;
+
+    azCol = tableColumnList(p, zTable);
+    if( azCol==0 ) return 0;
+
+    initText(&sTable);
+    appendText(&sTable, "INSERT INTO ", 0);
+
+    /* Always quote the table name, even if it appears to be pure ascii,
+    ** in case it is a keyword. Ex:  INSERT INTO "table" ... */
+    appendText(&sTable, zTable, quoteChar(zTable));
+
+    /* If preserving the rowid, add a column list after the table name.
+    ** In other words:  "INSERT INTO tab(rowid,a,b,c,...) VALUES(...)"
+    ** instead of the usual "INSERT INTO tab VALUES(...)".
+    */
+    if( azCol[0] ){
+      appendText(&sTable, "(", 0);
+      appendText(&sTable, azCol[0], 0);
+      for(i=1; azCol[i]; i++){
+        appendText(&sTable, ",", 0);
+        appendText(&sTable, azCol[i], quoteChar(azCol[i]));
+      }
+      appendText(&sTable, ")", 0);
+    }
+    appendText(&sTable, " VALUES(", 0);
+
+    /* Build an appropriate SELECT statement */
+    initText(&sSelect);
+    appendText(&sSelect, "SELECT ", 0);
+    if( azCol[0] ){
+      appendText(&sSelect, azCol[0], 0);
+      appendText(&sSelect, ",", 0);
+    }
+    for(i=1; azCol[i]; i++){
+      appendText(&sSelect, azCol[i], quoteChar(azCol[i]));
+      if( azCol[i+1] ){
+        appendText(&sSelect, ",", 0);
+      }
+    }
+    nCol = i;
+    if( azCol[0]==0 ) nCol--;
+    freeColumnList(azCol);
+    appendText(&sSelect, " FROM ", 0);
+    appendText(&sSelect, zTable, quoteChar(zTable));
+
+    rc = sqlite3_prepare_v2(p->db, sSelect.z, -1, &pStmt, 0);
+    if( rc!=SQLITE_OK ){
+      p->nErr++;
+      if( p->rc==SQLITE_OK ) p->rc = rc;
+    }else{
+      while( SQLITE_ROW==sqlite3_step(pStmt) ){
+        p->xCallback(sTable.z, p->pArg);
+        for(i=0; i<nCol; i++){
+          if( i ) p->xCallback(",", p->pArg);
+          switch( sqlite3_column_type(pStmt,i) ){
+            case SQLITE_INTEGER: {
+              output_formatted(p, "%lld", sqlite3_column_int64(pStmt,i));
+              break;
+            }
+            case SQLITE_FLOAT: {
+              double r = sqlite3_column_double(pStmt,i);
+              output_formatted(p, "%!.20g", r);
+              break;
+            }
+            case SQLITE_NULL: {
+              p->xCallback("NULL", p->pArg);
+              break;
+            }
+            case SQLITE_TEXT: {
+              output_quoted_string(p, sqlite3_column_text(pStmt,i));
+              break;
+            }
+            case SQLITE_BLOB: {
+              int nByte = sqlite3_column_bytes(pStmt,i);
+              unsigned char *a = (unsigned char*)sqlite3_column_blob(pStmt,i);
+              int j;
+              p->xCallback("x'", p->pArg);
+              for(j=0; j<nByte; j++){
+                char zWord[3];
+                zWord[0] = "0123456789abcdef"[(a[j]>>4)&15];
+                zWord[1] = "0123456789abcdef"[a[j]&15];
+                zWord[2] = 0;
+                p->xCallback(zWord, p->pArg);
+              }
+              p->xCallback("'", p->pArg);
+              break;
+            }
+          }
+        }
+        p->xCallback(");\n", p->pArg);
+      }
+    }
+    sqlite3_finalize(pStmt);
+    freeText(&sTable);
+    freeText(&sSelect);
+  }
+  return 0;
+}
+
+
+/*
+** Execute a query statement that will generate SQL output.  Print
+** the result columns, comma-separated, on a line and then add a
+** semicolon terminator to the end of that line.
+**
+** If the number of columns is 1 and that column contains text "--"
+** then write the semicolon on a separate line.  That way, if a
+** "--" comment occurs at the end of the statement, the comment
+** won't consume the semicolon terminator.
+*/
+static void output_sql_from_query(
+  DState *p,               /* Query context */
+  const char *zSelect,     /* SELECT statement to extract content */
+  ...
+){
+  sqlite3_stmt *pSelect;
+  int rc;
+  int nResult;
+  int i;
+  const char *z;
+  char *zSql;
+  va_list ap;
+  va_start(ap, zSelect);
+  zSql = sqlite3_vmprintf(zSelect, ap);
+  va_end(ap);
+  if( zSql==0 ){
+    p->rc = SQLITE_NOMEM;
+    p->nErr++;
+    return;
+  }
+  rc = sqlite3_prepare_v2(p->db, zSql, -1, &pSelect, 0);
+  sqlite3_free(zSql);
+  if( rc!=SQLITE_OK || !pSelect ){
+    output_formatted(p, "/**** ERROR: (%d) %s *****/\n", rc,
+                sqlite3_errmsg(p->db));
+    p->nErr++;
+    return;
+  }
+  rc = sqlite3_step(pSelect);
+  nResult = sqlite3_column_count(pSelect);
+  while( rc==SQLITE_ROW ){
+    z = (const char*)sqlite3_column_text(pSelect, 0);
+    p->xCallback(z, p->pArg);
+    for(i=1; i<nResult; i++){
+      p->xCallback(",", p->pArg);
+      p->xCallback((const char*)sqlite3_column_text(pSelect,i), p->pArg);
+    }
+    if( z==0 ) z = "";
+    while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
+    if( z[0] ){
+      p->xCallback("\n;\n", p->pArg);
+    }else{
+      p->xCallback(";\n", p->pArg);
+    }
+    rc = sqlite3_step(pSelect);
+  }
+  rc = sqlite3_finalize(pSelect);
+  if( rc!=SQLITE_OK ){
+    output_formatted(p, "/**** ERROR: (%d) %s *****/\n", rc,
+                     sqlite3_errmsg(p->db));
+    if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
+  }
+}
+
+/*
+** Run zQuery.  Use dump_callback() as the callback routine so that
+** the contents of the query are output as SQL statements.
+**
+** If we get a SQLITE_CORRUPT error, rerun the query after appending
+** "ORDER BY rowid DESC" to the end.
+*/
+static void run_schema_dump_query(
+  DState *p,
+  const char *zQuery,
+  ...
+){
+  char *zErr = 0;
+  char *z;
+  va_list ap;
+  va_start(ap, zQuery);
+  z = sqlite3_vmprintf(zQuery, ap);
+  va_end(ap); 
+  sqlite3_exec(p->db, z, dump_callback, p, &zErr);
+  sqlite3_free(z);
+  if( zErr ){
+    output_formatted(p, "/****** %s ******/\n", zErr);
+    sqlite3_free(zErr);
+    p->nErr++;
+    zErr = 0;
+  }
+}
+
+/*
+** Convert an SQLite database into SQL statements that will recreate that
+** database.
+*/
+int sqlite3_db_dump(
+  sqlite3 *db,               /* The database connection */
+  const char *zSchema,       /* Which schema to dump.  Usually "main". */
+  const char *zTable,        /* Which table to dump.  NULL means everything. */
+  int (*xCallback)(const char*,void*),   /* Output sent to this callback */
+  void *pArg                             /* Second argument of the callback */
+){
+  DState x;
+  memset(&x, 0, sizeof(x));
+  x.rc = sqlite3_exec(db, "BEGIN", 0, 0, 0);
+  if( x.rc ) return x.rc;
+  x.db = db;
+  x.xCallback = xCallback;
+  x.pArg = pArg;
+  xCallback("PRAGMA foreign_keys=OFF;\nBEGIN TRANSACTION;\n", pArg);
+  if( zTable==0 ){
+    run_schema_dump_query(&x,
+      "SELECT name, type, sql FROM \"%w\".sqlite_master "
+      "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'",
+      zSchema
+    );
+    run_schema_dump_query(&x,
+      "SELECT name, type, sql FROM \"%w\".sqlite_master "
+      "WHERE name=='sqlite_sequence'", zSchema
+    );
+    output_sql_from_query(&x,
+      "SELECT sql FROM sqlite_master "
+      "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
+    );
+  }else{
+    run_schema_dump_query(&x,
+      "SELECT name, type, sql FROM \"%w\".sqlite_master "
+      "WHERE tbl_name=%Q COLLATE nocase AND type=='table'"
+      "  AND sql NOT NULL",
+      zSchema, zTable
+    );
+    output_sql_from_query(&x,
+      "SELECT sql FROM \"%w\".sqlite_master "
+      "WHERE sql NOT NULL"
+      "  AND type IN ('index','trigger','view')"
+      "  AND tbl_name=%Q COLLATE nocase",
+      zSchema, zTable
+    ); 
+  }
+  if( x.writableSchema ){
+    xCallback("PRAGMA writable_schema=OFF;\n", pArg);
+  }
+  xCallback(x.nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n", pArg);
+  sqlite3_exec(db, "COMMIT", 0, 0, 0);
+  return x.rc;
+}
+
+
+
+/* The generic subroutine is above.  The code the follows implements
+** the command-line interface.
+*/
+#ifdef DBDUMP_STANDALONE
+#include <stdio.h>
+
+/*
+** Command-line interface
+*/
+int main(int argc, char **argv){
+  sqlite3 *db;
+  const char *zDb;
+  const char *zSchema;
+  const char *zTable = 0;
+  int rc;
+
+  if( argc<2 || argc>4 ){
+    fprintf(stderr, "Usage: %s DATABASE ?SCHEMA? ?TABLE?\n", argv[0]);
+    return 1;
+  }
+  zDb = argv[1];
+  zSchema = argc>=3 ? argv[2] : "main";
+  zTable = argc==4 ? argv[3] : 0;
+
+  rc = sqlite3_open(zDb, &db);
+  if( rc ){
+    fprintf(stderr, "Cannot open \"%s\": %s\n", zDb, sqlite3_errmsg(db));
+    sqlite3_close(db);
+    return 1;
+  }
+  rc = sqlite3_db_dump(db, zSchema, zTable, 
+          (int(*)(const char*,void*))fputs, (void*)stdout);
+  if( rc ){
+    fprintf(stderr, "Error: sqlite3_db_dump() returns %d\n", rc);
+  }
+  sqlite3_close(db);
+  return rc!=SQLITE_OK;  
+}
+#endif /* DBDUMP_STANDALONE */
@@ -138,9 +138,10 @@ static const char * const jsonType[] = {
 #define JNODE_RAW     0x01         /* Content is raw, not JSON encoded */
 #define JNODE_ESCAPE  0x02         /* Content is text with \ escapes */
 #define JNODE_REMOVE  0x04         /* Do not output */
-#define JNODE_REPLACE 0x08         /* Replace with JsonNode.iVal */
-#define JNODE_APPEND  0x10         /* More ARRAY/OBJECT entries at u.iAppend */
-#define JNODE_LABEL   0x20         /* Is a label of an object */
+#define JNODE_REPLACE 0x08         /* Replace with JsonNode.u.iReplace */
+#define JNODE_PATCH   0x10         /* Patch with JsonNode.u.pPatch */
+#define JNODE_APPEND  0x20         /* More ARRAY/OBJECT entries at u.iAppend */
+#define JNODE_LABEL   0x40         /* Is a label of an object */


 /* A single node of parsed JSON
@@ -148,12 +149,13 @@ static const char * const jsonType[] = {
 struct JsonNode {
  u8 eType;              /* One of the JSON_ type values */
  u8 jnFlags;            /* JNODE flags */
-  u8 iVal;               /* Replacement value when JNODE_REPLACE */
  u32 n;                 /* Bytes of content, or number of sub-nodes */
  union {
    const char *zJContent; /* Content for INT, REAL, and STRING */
    u32 iAppend;           /* More terms for ARRAY and OBJECT */
    u32 iKey;              /* Key for ARRAY objects in json_tree() */
+    u32 iReplace;          /* Replacement content for JNODE_REPLACE */
+    JsonNode *pPatch;      /* Node chain of patch for JNODE_PATCH */
  } u;
 };

@@ -410,6 +412,13 @@ static void jsonRenderNode(
  JsonString *pOut,              /* Write JSON here */
  sqlite3_value **aReplace       /* Replacement values */
 ){
+  if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){
+    if( pNode->jnFlags & JNODE_REPLACE ){
+      jsonAppendValue(pOut, aReplace[pNode->u.iReplace]);
+      return;
+    }
+    pNode = pNode->u.pPatch;
+  }
  switch( pNode->eType ){
    default: {
      assert( pNode->eType==JSON_NULL );
@@ -441,12 +450,7 @@ static void jsonRenderNode(
      jsonAppendChar(pOut, '[');
      for(;;){
        while( j<=pNode->n ){
-          if( pNode[j].jnFlags & (JNODE_REMOVE|JNODE_REPLACE) ){
-            if( pNode[j].jnFlags & JNODE_REPLACE ){
-              jsonAppendSeparator(pOut);
-              jsonAppendValue(pOut, aReplace[pNode[j].iVal]);
-            }
-          }else{
+          if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){
            jsonAppendSeparator(pOut);
            jsonRenderNode(&pNode[j], pOut, aReplace);
          }
@@ -468,11 +472,7 @@ static void jsonRenderNode(
            jsonAppendSeparator(pOut);
            jsonRenderNode(&pNode[j], pOut, aReplace);
            jsonAppendChar(pOut, ':');
-            if( pNode[j+1].jnFlags & JNODE_REPLACE ){
-              jsonAppendValue(pOut, aReplace[pNode[j+1].iVal]);
-            }else{
-              jsonRenderNode(&pNode[j+1], pOut, aReplace);
-            }
+            jsonRenderNode(&pNode[j+1], pOut, aReplace);
          }
          j += 1 + jsonNodeSize(&pNode[j+1]);
        }
@@ -699,7 +699,6 @@ static int jsonParseAddNode(
  p = &pParse->aNode[pParse->nNode];
  p->eType = (u8)eType;
  p->jnFlags = 0;
-  p->iVal = 0;
  p->n = n;
  p->u.zJContent = zContent;
  return pParse->nNode++;
@@ -1165,6 +1164,25 @@ static void jsonWrongNumArgs(
  sqlite3_free(zMsg);     
 }

+/*
+** Mark all NULL entries in the Object passed in as JNODE_REMOVE.
+*/
+static void jsonRemoveAllNulls(JsonNode *pNode){
+  int i, n;
+  assert( pNode->eType==JSON_OBJECT );
+  n = pNode->n;
+  for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){
+    switch( pNode[i].eType ){
+      case JSON_NULL:
+        pNode[i].jnFlags |= JNODE_REMOVE;
+        break;
+      case JSON_OBJECT:
+        jsonRemoveAllNulls(&pNode[i]);
+        break;
+    }
+  }
+}
+

 /****************************************************************************
 ** SQL functions used for testing and debugging
@@ -1357,6 +1375,105 @@ static void jsonExtractFunc(
  jsonParseReset(&x);
 }

+/* This is the RFC 7396 MergePatch algorithm.
+*/
+static JsonNode *jsonMergePatch(
+  JsonParse *pParse,   /* The JSON parser that contains the TARGET */
+  int iTarget,         /* Node of the TARGET in pParse */
+  JsonNode *pPatch     /* The PATCH */
+){
+  u32 i, j;
+  u32 iRoot;
+  JsonNode *pTarget;
+  if( pPatch->eType!=JSON_OBJECT ){
+    return pPatch;
+  }
+  assert( iTarget>=0 && iTarget<pParse->nNode );
+  pTarget = &pParse->aNode[iTarget];
+  assert( (pPatch->jnFlags & JNODE_APPEND)==0 );
+  if( pTarget->eType!=JSON_OBJECT ){
+    jsonRemoveAllNulls(pPatch);
+    return pPatch;
+  }
+  iRoot = iTarget;
+  for(i=1; i<pPatch->n; i += jsonNodeSize(&pPatch[i+1])+1){
+    u32 nKey;
+    const char *zKey;
+    assert( pPatch[i].eType==JSON_STRING );
+    assert( pPatch[i].jnFlags & JNODE_LABEL );
+    nKey = pPatch[i].n;
+    zKey = pPatch[i].u.zJContent;
+    assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
+    for(j=1; j<pTarget->n; j += jsonNodeSize(&pTarget[j+1])+1 ){
+      assert( pTarget[j].eType==JSON_STRING );
+      assert( pTarget[j].jnFlags & JNODE_LABEL );
+      assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
+      if( pTarget[j].n==nKey && strncmp(pTarget[j].u.zJContent,zKey,nKey)==0 ){
+        if( pTarget[j+1].jnFlags & (JNODE_REMOVE|JNODE_PATCH) ) break;
+        if( pPatch[i+1].eType==JSON_NULL ){
+          pTarget[j+1].jnFlags |= JNODE_REMOVE;
+        }else{
+          JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]);
+          if( pNew==0 ) return 0;
+          pTarget = &pParse->aNode[iTarget];
+          if( pNew!=&pTarget[j+1] ){
+            pTarget[j+1].u.pPatch = pNew;
+            pTarget[j+1].jnFlags |= JNODE_PATCH;
+          }
+        }
+        break;
+      }
+    }
+    if( j>=pTarget->n && pPatch[i+1].eType!=JSON_NULL ){
+      int iStart, iPatch;
+      iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0);
+      jsonParseAddNode(pParse, JSON_STRING, nKey, zKey);
+      iPatch = jsonParseAddNode(pParse, JSON_TRUE, 0, 0);
+      if( pParse->oom ) return 0;
+      jsonRemoveAllNulls(pPatch);
+      pTarget = &pParse->aNode[iTarget];
+      pParse->aNode[iRoot].jnFlags |= JNODE_APPEND;
+      pParse->aNode[iRoot].u.iAppend = iStart - iRoot;
+      iRoot = iStart;
+      pParse->aNode[iPatch].jnFlags |= JNODE_PATCH;
+      pParse->aNode[iPatch].u.pPatch = &pPatch[i+1];
+    }
+  }
+  return pTarget;
+}
+
+/*
+** Implementation of the json_mergepatch(JSON1,JSON2) function.  Return a JSON
+** object that is the result of running the RFC 7396 MergePatch() algorithm
+** on the two arguments.
+*/
+static void jsonPatchFunc(
+  sqlite3_context *ctx,
+  int argc,
+  sqlite3_value **argv
+){
+  JsonParse x;     /* The JSON that is being patched */
+  JsonParse y;     /* The patch */
+  JsonNode *pResult;   /* The result of the merge */
+
+  UNUSED_PARAM(argc);
+  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
+  if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){
+    jsonParseReset(&x);
+    return;
+  }
+  pResult = jsonMergePatch(&x, 0, y.aNode);
+  assert( pResult!=0 || x.oom );
+  if( pResult ){
+    jsonReturnJson(pResult, ctx, 0);
+  }else{
+    sqlite3_result_error_nomem(ctx);
+  }
+  jsonParseReset(&x);
+  jsonParseReset(&y);
+}
+
+
 /*
 ** Implementation of the json_object(NAME,VALUE,...) function.  Return a JSON
 ** object that contains all name/value given in arguments.  Or if any name
@@ -1460,11 +1577,11 @@ static void jsonReplaceFunc(
    if( x.nErr ) goto replace_err;
    if( pNode ){
      pNode->jnFlags |= (u8)JNODE_REPLACE;
-      pNode->iVal = (u8)(i+1);
+      pNode->u.iReplace = i + 1;
    }
  }
  if( x.aNode[0].jnFlags & JNODE_REPLACE ){
-    sqlite3_result_value(ctx, argv[x.aNode[0].iVal]);
+    sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]);
  }else{
    jsonReturnJson(x.aNode, ctx, argv);
  }
@@ -1514,11 +1631,11 @@ static void jsonSetFunc(
      goto jsonSetDone;
    }else if( pNode && (bApnd || bIsSet) ){
      pNode->jnFlags |= (u8)JNODE_REPLACE;
-      pNode->iVal = (u8)(i+1);
+      pNode->u.iReplace = i + 1;
    }
  }
  if( x.aNode[0].jnFlags & JNODE_REPLACE ){
-    sqlite3_result_value(ctx, argv[x.aNode[0].iVal]);
+    sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]);
  }else{
    jsonReturnJson(x.aNode, ctx, argv);
  }
@@ -2161,6 +2278,7 @@ int sqlite3Json1Init(sqlite3 *db){
    { "json_extract",        -1, 0,   jsonExtractFunc       },
    { "json_insert",         -1, 0,   jsonSetFunc           },
    { "json_object",         -1, 0,   jsonObjectFunc        },
+    { "json_patch",           2, 0,   jsonPatchFunc         },
    { "json_quote",           1, 0,   jsonQuoteFunc         },
    { "json_remove",         -1, 0,   jsonRemoveFunc        },
    { "json_replace",        -1, 0,   jsonReplaceFunc       },
@@ -21,6 +21,10 @@
 **
 ** The sha3_query(Y) function evalutes all queries in the SQL statements of Y
 ** and returns a hash of their results.
+**
+** The SIZE argument is optional.  If omitted, the SHA3-256 hash algorithm
+** is used.  If SIZE is included it must be one of the integers 224, 256,
+** 384, or 512, to determine SHA3 hash variant that is computed.
 */
 #include "sqlite3ext.h"
 SQLITE_EXTENSION_INIT1
@@ -1,205 +0,0 @@
-##########################################################################
-# 2016 Mar 8
-#
-# 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.
-#
-proc process_cmdline {} { 
-  cmdline::process ::A $::argv {
-    {make                 "try to build missing tools"}
-    {verbose              "make more noise"}
-    database
-    database2
-  } {
- This script uses/tests the following tools:
-
-   dbselftest
-   rbu
-   sqldiff
-   sqlite3
- 
- The user passes the names of two database files - a.db and b.db below - as
- arguments. This program:
-
- 1. Runs [dbselftest --init] against both databases.
- 2. Runs [sqldiff --rbu --vtab a.db b.db | sqlite3 <tmpname>.db] to create an 
-    RBU database.
- 3. Runs [rbu b.db <tmpname>.db] to patch b.db to a.db.
- 4. Runs [sqldiff --table selftest a.db b.db] to check that the selftest
-    tables are now identical.
- 5. Runs [dbselftest] against both databases.
-  }
-}
-
-###########################################################################
-###########################################################################
-# Command line options processor. This is generic code that can be copied
-# between scripts.
-#
-namespace eval cmdline {
-  proc cmdline_error {O E {msg ""}} {
-    if {$msg != ""} {
-      puts stderr "Error: $msg"
-      puts stderr ""
-    }
-  
-    set L [list]
-    foreach o $O {
-      if {[llength $o]==1} {
-        lappend L [string toupper $o]
-      }
-    }
-  
-    puts stderr "Usage: $::argv0 ?SWITCHES? $L"
-    puts stderr ""
-    puts stderr "Switches are:"
-    foreach o $O {
-      if {[llength $o]==3} {
-        foreach {a b c} $o {}
-        puts stderr [format "    -%-15s %s (default \"%s\")" "$a VAL" $c $b]
-      } elseif {[llength $o]==2} {
-        foreach {a b} $o {}
-        puts stderr [format "    -%-15s %s" $a $b]
-      }
-    }
-    puts stderr ""
-    puts stderr $E
-    exit -1
-  }
-  
-  proc process {avar lArgs O E} {
-    upvar $avar A
-    set zTrailing ""       ;# True if ... is present in $O
-    set lPosargs [list]
-  
-    # Populate A() with default values. Also, for each switch in the command
-    # line spec, set an entry in the idx() array as follows:
-    #
-    #  {tblname t1 "table name to use"}  
-    #      -> [set idx(-tblname) {tblname t1 "table name to use"}  
-    #
-    # For each position parameter, append its name to $lPosargs. If the ...
-    # specifier is present, set $zTrailing to the name of the prefix.
-    #
-    foreach o $O {
-      set nm [lindex $o 0]
-      set nArg [llength $o]
-      switch -- $nArg {
-        1 {
-          if {[string range $nm end-2 end]=="..."} {
-            set zTrailing [string range $nm 0 end-3]
-          } else {
-            lappend lPosargs $nm
-          }
-        }
-        2 {
-          set A($nm) 0
-          set idx(-$nm) $o
-        }
-        3 {
-          set A($nm) [lindex $o 1]
-          set idx(-$nm) $o
-        }
-        default {
-          error "Error in command line specification"
-        }
-      }
-    }
-  
-    # Set explicitly specified option values
-    #
-    set nArg [llength $lArgs]
-    for {set i 0} {$i < $nArg} {incr i} {
-      set opt [lindex $lArgs $i]
-      if {[string range $opt 0 0]!="-" || $opt=="--"} break
-      set c [array names idx "${opt}*"]
-      if {[llength $c]==0} { cmdline_error $O $E "Unrecognized option: $opt"}
-      if {[llength $c]>1}  { cmdline_error $O $E "Ambiguous option: $opt"}
-  
-      if {[llength $idx($c)]==3} {
-        if {$i==[llength $lArgs]-1} {
-          cmdline_error $O $E "Option requires argument: $c" 
-        }
-        incr i
-        set A([lindex $idx($c) 0]) [lindex $lArgs $i]
-      } else {
-        set A([lindex $idx($c) 0]) 1
-      }
-    }
-  
-    # Deal with position arguments.
-    #
-    set nPosarg [llength $lPosargs]
-    set nRem [expr $nArg - $i]
-    if {$nRem < $nPosarg || ($zTrailing=="" && $nRem > $nPosarg)} {
-      cmdline_error $O $E
-    }
-    for {set j 0} {$j < $nPosarg} {incr j} {
-      set A([lindex $lPosargs $j]) [lindex $lArgs [expr $j+$i]]
-    }
-    if {$zTrailing!=""} {
-      set A($zTrailing) [lrange $lArgs [expr $j+$i] end]
-    }
-  }
-} ;# namespace eval cmdline
-# End of command line options processor.
-###########################################################################
-###########################################################################
-
-process_cmdline
-
-# Check that the specified tool is present.
-#
-proc check_for_tool {tool} {
-  if {[file exists $tool]==0 || [file executable $tool]==0} {
-    puts stderr "Missing $tool... exiting. (run \[make $tool\])"
-    exit -1
-  }
-}
-
-if {$A(make)} {
-  if {$A(verbose)} { puts "building tools..." }
-  exec make dbselftest rbu sqlite3 sqldiff
-}
-
-check_for_tool dbselftest
-check_for_tool rbu
-check_for_tool sqlite3
-check_for_tool sqldiff
-
-exec ./sqlite3 $A(database) "DROP TABLE selftest;"
-exec ./sqlite3 $A(database2) "DROP TABLE selftest;"
-
-# Run [dbselftest --init] on both databases
-if {$A(verbose)} { puts "Running \[dbselftest --init\]" }
-exec ./dbselftest --init $A(database)
-exec ./dbselftest --init $A(database2)
-
-# Create an RBU patch.
-set tmpname "./rrt-[format %x [expr int(rand()*0x7FFFFFFF)]].db"
-if {$A(verbose)} { puts "rbu database is $tmpname" }
-exec ./sqldiff --rbu --vtab $A(database2) $A(database) | ./sqlite3 $tmpname
-
-# Run the [rbu] patch.
-if {$A(verbose)} { puts "Running \[rbu]" }
-exec ./rbu $A(database2) $tmpname
-
-set selftest_diff [exec ./sqldiff --table selftest $A(database) $A(database2)]
-if {$selftest_diff != ""} {
-  puts stderr "patching table \"selftest\" failed: $selftest_diff"
-  exit -1
-}
-
-# Run [dbselftest] on both databases
-if {$A(verbose)} { puts "Running \[dbselftest]" }
-exec ./dbselftest $A(database)
-exec ./dbselftest $A(database2)
-
-# Remove the RBU database
-file delete $tmpname
-puts "round trip test successful."
-
@@ -458,15 +458,15 @@ static i64 readInt64(u8 *p){
  memcpy(&x, p, 8);
  return x;
 #else
-  return (
-    (((i64)p[0]) << 56) + 
-    (((i64)p[1]) << 48) + 
-    (((i64)p[2]) << 40) + 
-    (((i64)p[3]) << 32) + 
-    (((i64)p[4]) << 24) + 
-    (((i64)p[5]) << 16) + 
-    (((i64)p[6]) <<  8) + 
-    (((i64)p[7]) <<  0)
+  return (i64)(
+    (((u64)p[0]) << 56) + 
+    (((u64)p[1]) << 48) + 
+    (((u64)p[2]) << 40) + 
+    (((u64)p[3]) << 32) + 
+    (((u64)p[4]) << 24) + 
+    (((u64)p[5]) << 16) + 
+    (((u64)p[6]) <<  8) + 
+    (((u64)p[7]) <<  0)
  );
 #endif
 }
@@ -477,10 +477,9 @@ SHELL_OPT += -DSQLITE_ENABLE_EXPLAIN_COMMENTS
 SHELL_OPT += -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
 FUZZERSHELL_OPT = -DSQLITE_ENABLE_JSON1
 FUZZCHECK_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5
+FUZZCHECK_OPT += -DSQLITE_MAX_MEMORY=50000000
 DBFUZZ_OPT =
 KV_OPT = -DSQLITE_THREADSAFE=0 -DSQLITE_DIRECT_OVERFLOW_READ
-DBSELFTEST_OPT = -DSQLITE_THREADSAFE=0 -DSQLITE_OMIT_LOAD_EXTENSION
-DBSELFTEST_OPT += -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5
 ST_OPT = -DSQLITE_THREADSAFE=0

 # This is the default Makefile target.  The objects listed here
@@ -762,6 +761,10 @@ sqlite3_analyzer.c: sqlite3.c $(TOP)/src/tclsqlite.c $(TOP)/tool/spaceanal.tcl
 sqlite3_analyzer$(EXE): sqlite3_analyzer.c
 	$(TCCX) $(TCL_FLAGS) sqlite3_analyzer.c -o $@ $(LIBTCL) $(THREADLIB) 

+dbdump$(EXE):	$(TOP)/ext/misc/dbdump.c sqlite3.o
+	$(TCCX) -DDBDUMP_STANDALONE -o dbdump$(EXE) \
+            $(TOP)/ext/misc/dbdump.c sqlite3.o $(THREADLIB)
+
 # Rules to build the 'testfixture' application.
 #
 TESTFIXTURE_FLAGS  = -DSQLITE_TEST=1 -DSQLITE_CRASH_TEST=1
@@ -902,9 +905,6 @@ speedtest1$(EXE):	$(TOP)/test/speedtest1.c sqlite3.c
 kvtest$(EXE):	$(TOP)/test/kvtest.c sqlite3.c
 	$(TCCX) -I. $(KV_OPT) -o kvtest$(EXE) $(TOP)/test/kvtest.c sqlite3.c $(THREADLIB) 

-dbselftest$(EXE):	$(TOP)/test/dbselftest.c sqlite3.c
-	$(TCCX) -I. $(DBSELFTEST_OPT) -o dbselftest$(EXE) $(TOP)/test/dbselftest.c sqlite3.c $(THREADLIB)
-
 rbu$(EXE): $(TOP)/ext/rbu/rbu.c $(TOP)/ext/rbu/sqlite3rbu.c sqlite3.o 
 	$(TCC) -I. -o rbu$(EXE) $(TOP)/ext/rbu/rbu.c sqlite3.o \
 	  $(THREADLIB)
@@ -1,20 +1,20 @@
-C Make\ssure\sthe\sdatabase\sconnection\sis\sopen\sprior\sto\srunning\sthe\s".sha3sum"\ncommand.
-D 2017-03-08T18:06:20.965
-F Makefile.in edb6bcdd37748d2b1c3422ff727c748df7ffe918
+C Version\s3.18.1
+D 2017-06-16T13:41:15.259
+F Makefile.in 1cc758ce3374a32425e4d130c2fe7b026b20de5b8843243de75f087c0a2661fb
 F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
-F Makefile.msc a89ea37ab5928026001569f056973b9059492fe2
-F README.md 8ecc12493ff9f820cdea6520a9016001cb2e59b7
-F VERSION 3605fa447e4623f5ff4a6adc97b1fde9a257b8f2
+F Makefile.msc 1faf9f06aadc9284c212dea7bbc7c0dea7e8337f0287c81001eff500912c790a
+F README.md 2b15fae33852f2f53996774c21fb41e1d94181c4401a0e43ac93e11f2cc901b9
+F VERSION a73b61aacb663dcb9138eab9671807e76c9144089c08330304cfbf348437c6cc
 F aclocal.m4 a5c22d164aff7ed549d53a90fa56d56955281f50
 F art/sqlite370.eps aa97a671332b432a54e1d74ff5e8775be34200c2
 F art/sqlite370.ico af56c1d00fee7cd4753e8631ed60703ed0fc6e90
 F art/sqlite370.jpg d512473dae7e378a67e28ff96a34da7cb331def2
 F autoconf/INSTALL 83e4a25da9fd053c7b3665eaaaf7919707915903
 F autoconf/Makefile.am 1a47d071e3d5435f8f7ebff7eb6703848bbd65d4
-F autoconf/Makefile.msc 3de603bcec5c07462801a20fd7dc1b871400af99
+F autoconf/Makefile.msc 92e3d7fd64dc5c23a23d33824ee4709aaea00a6331c4bb41a1aadcf6600a49f7
 F autoconf/README.first 6c4f34fe115ff55d4e8dbfa3cecf04a0188292f7
 F autoconf/README.txt 4f04b0819303aabaa35fff5f7b257fb0c1ef95f1
-F autoconf/configure.ac cacf2616abf6e4a569bde2ef365c143caeec40bc
+F autoconf/configure.ac 2893b823ecc86cea13739f6c8109a41392254d1db08235c5615e0af5722c8578
 F autoconf/tea/Makefile.in b438a7020446c8a8156e8d97c8914a04833da6fd
 F autoconf/tea/README 3e9a3c060f29a44344ab50aec506f4db903fb873
 F autoconf/tea/aclocal.m4 52c47aac44ce0ddb1f918b6993e8beb8eee88f43
@@ -30,13 +30,13 @@ F autoconf/tea/win/rules.vc c511f222b80064096b705dbeb97060ee1d6b6d63
 F config.guess 226d9a188c6196f3033ffc651cbc9dcee1a42977
 F config.h.in 6376abec766e9a0785178b1823b5a587e9f1ccbc
 F config.sub 9ebe4c3b3dab6431ece34f16828b594fb420da55
-F configure b15d030a8ae2e672d76c97b6667dacb98934a467 x
+F configure a1aa988953489a1e33654109193e3a6b0090b26aa9ddd0a21da827deb80271e4 x
 F configure.ac 605173e829ab64514ed89f9b53d0da1739d7b0a0
 F contrib/sqlitecon.tcl 210a913ad63f9f991070821e599d600bd913e0ad
 F doc/lemon.html b5a3c07d33ecb8e019ce8f7660fe2dbbad9d7977
 F doc/pager-invariants.txt 27fed9a70ddad2088750c4a2b493b63853da2710
 F doc/vfs-shm.txt e101f27ea02a8387ce46a05be2b1a902a021d37a
-F ext/README.txt 913a7bd3f4837ab14d7e063304181787658b14e1
+F ext/README.md fd5f78013b0a2bc6f0067afb19e6ad040e89a10179b4f6f03eee58fac5f169bd
 F ext/async/README.txt e12275968f6fde133a80e04387d0e839b0c51f91
 F ext/async/sqlite3async.c 0f3070cc3f5ede78f2b9361fb3b629ce200d7d74
 F ext/async/sqlite3async.h f489b080af7e72aec0e1ee6f1d98ab6cf2e4dcef
@@ -70,7 +70,7 @@ F ext/fts3/README.content fdc666a70d5257a64fee209f97cf89e0e6e32b51
 F ext/fts3/README.syntax a19711dc5458c20734b8e485e75fb1981ec2427a
 F ext/fts3/README.tokenizers e0a8b81383ea60d0334d274fadf305ea14a8c314
 F ext/fts3/README.txt 8c18f41574404623b76917b9da66fcb0ab38328d
-F ext/fts3/fts3.c 95c7041ea75d82d2d9a4cd058904ba889751f5b8
+F ext/fts3/fts3.c f0d5de1bc2155ba7cd7c0c1a751779a3a8857fa34d5c12f3b233a23fa2e79ea2
 F ext/fts3/fts3.h 3a10a0af180d502cecc50df77b1b22df142817fe
 F ext/fts3/fts3Int.h eb2502000148e80913b965db3e59f29251266d0a
 F ext/fts3/fts3_aux.c 9edc3655fcb287f0467d0a4b886a01c6185fe9f1
@@ -86,15 +86,16 @@ F ext/fts3/fts3_tokenize_vtab.c a27593ab19657166f6fa5ec073b678cc29a75860
 F ext/fts3/fts3_tokenizer.c a22bf311a71f3efa9d7012d8cc48fc9b0f3dace7
 F ext/fts3/fts3_tokenizer.h 64c6ef6c5272c51ebe60fc607a896e84288fcbc3
 F ext/fts3/fts3_tokenizer1.c 5c98225a53705e5ee34824087478cf477bdb7004
-F ext/fts3/fts3_unicode.c a93f5edc0aff44ef8b06d7cb55b52026541ca145
-F ext/fts3/fts3_unicode2.c c3d01968d497bd7001e7dc774ba75b372738c057
-F ext/fts3/fts3_write.c c3863f23b6b4623c8b9d5cf31c12ce4469f78ca9
+F ext/fts3/fts3_unicode.c 525a3bd9a7564603c5c061b7de55403a565307758a94600e8a2f6b00d1c40d9d
+F ext/fts3/fts3_unicode2.c cc04fc672bfd42b1e650398cb0bf71f64f9aae032cfe75bbcfe75b9cf966029c
+F ext/fts3/fts3_write.c a51d48d646974ee2fb4b17fcd5da0416a5759a32dcacc2cce2ba00d5a767848e
 F ext/fts3/fts3speed.tcl b54caf6a18d38174f1a6e84219950d85e98bb1e9
 F ext/fts3/mkfts3amal.tcl 252ecb7fe6467854f2aa237bf2c390b74e71f100
+F ext/fts3/tool/fts3cov.sh c331d006359456cf6f8f953e37f2b9c7d568f3863f00bb5f7eb87fea4ac01b73
 F ext/fts3/tool/fts3view.c 202801a2056995b763864d60c2dee744d46f1677
 F ext/fts3/unicode/CaseFolding.txt 8c678ca52ecc95e16bc7afc2dbf6fc9ffa05db8c
 F ext/fts3/unicode/UnicodeData.txt cd07314edb62d49fde34debdaf92fa2aa69011e7
-F ext/fts3/unicode/mkunicode.tcl 2debed3f582d77b3fdd0b8830880250021571fd8
+F ext/fts3/unicode/mkunicode.tcl ab0543a3b2399092ea2dd75df1bef333405b0d7f6b8c4951a0fbb60e780cb69f
 F ext/fts3/unicode/parseunicode.tcl da577d1384810fb4e2b209bf3313074353193e95
 F ext/fts5/extract_api_docs.tcl a36e54ec777172ddd3f9a88daf593b00848368e0
 F ext/fts5/fts5.h 62f3e33ceeb9a428db139f9c012186b371da1cc7
@@ -206,16 +207,18 @@ F ext/fts5/tool/showfts5.tcl d54da0e067306663e2d5d523965ca487698e722c
 F ext/icu/README.txt d9fbbad0c2f647c3fdf715fc9fd64af53aedfc43
 F ext/icu/icu.c 84900472a088a3a172c6c079f58a1d3a1952c332
 F ext/icu/sqliteicu.h 728867a802baa5a96de7495e9689a8e01715ef37
+F ext/misc/README.md 8e008c8d2b02e09096b31dfba033253ac27c6c06a18aa5826e299fa7601d90b2
 F ext/misc/amatch.c 211108e201105e4bb0c076527b8cfd34330fc234
 F ext/misc/carray.c 40c27641010a4dc67e3690bdb7c9d36ca58b3c2d
 F ext/misc/closure.c 0d2a038df8fbae7f19de42e7c7d71f2e4dc88704
 F ext/misc/compress.c 122faa92d25033d6c3f07c39231de074ab3d2e83
 F ext/misc/csv.c 531a46cbad789fca0aa9db69a0e6c8ac9e68767d
+F ext/misc/dbdump.c 34174d537318027b159e3341105866c05a4149376ede59988c82280bed144e6d
 F ext/misc/eval.c f971962e92ebb8b0a4e6b62949463ee454d88fa2
 F ext/misc/fileio.c d4171c815d6543a9edef8308aab2951413cd8d0f
 F ext/misc/fuzzer.c 7c64b8197bb77b7d64eff7cac7848870235d4c25
 F ext/misc/ieee754.c f190d0cc5182529acb15babd177781be1ac1718c
-F ext/misc/json1.c 552a7d730863419e05dc947265b28bd411680e2e
+F ext/misc/json1.c 92b9e404bd79cc76d3ef2b3a9e37bf775700f7d645466fd41d2e8742e3fa16fb
 F ext/misc/memvfs.c e5225bc22e79dde6b28380f3a068ddf600683a33
 F ext/misc/nextchar.c 35c8b8baacb96d92abbb34a83a997b797075b342
 F ext/misc/percentile.c 92699c8cd7d517ff610e6037e56506f8904dae2e
@@ -225,7 +228,7 @@ F ext/misc/rot13.c 1ac6f95f99b575907b9b09c81a349114cf9be45a
 F ext/misc/scrub.c 1c5bfb8b0cd18b602fcb55755e84abf0023ac2fb
 F ext/misc/series.c e11e534ada797d5b816d7e7a93c022306563ca35
 F ext/misc/sha1.c 0b9e9b855354910d3ca467bf39099d570e73db56
-F ext/misc/shathree.c 38aa4c3c3d3c3fc34b8ea367bed299d8d8a224b2
+F ext/misc/shathree.c fa185d7aee0ad0aca5e091b4a2db7baff11796170e5793b5de99e511a13af448
 F ext/misc/showauth.c 732578f0fe4ce42d577e1c86dc89dd14a006ab52
 F ext/misc/spellfix.c a4723b6aff748a417b5091b68a46443265c40f0d
 F ext/misc/totype.c 4a167594e791abeed95e0a8db028822b5e8fe512
@@ -250,7 +253,6 @@ F ext/rbu/rbuA.test c1a7b3e2d926b8f8448bb3b4ae787e314ee4b2b3
 F ext/rbu/rbuB.test c25bc325b8072a766e56bb76c001866b405925c2
 F ext/rbu/rbuC.test efe47db508a0269b683cb2a1913a425ffd39a831
 F ext/rbu/rbu_common.tcl a38e8e2d4a50fd6aaf151633714c1b1d2fae3ead
-F ext/rbu/rbu_round_trip.tcl f3216836bbaeb10d76a2c70b89c13f59eabbd117
 F ext/rbu/rbucrash.test 8d2ed5d4b05fef6c00c2a6b5f7ead71fa172a695
 F ext/rbu/rbucrash2.test b2ecbdd7bb72c88bd217c65bd00dafa07f7f2d4d
 F ext/rbu/rbudiff.test 3e605cf624d00d04d0fb1316a3acec4fbe3b3ac5
@@ -269,7 +271,7 @@ F ext/rbu/sqlite3rbu.c 2a89efba9eeba8e6c89a498dc195e8efbdde2694
 F ext/rbu/sqlite3rbu.h 6fb6294c34a9ca93b5894a33bca530c6f08decba
 F ext/rbu/test_rbu.c 5aa22616afac6f71ebd3d9bc9bf1006cfabcca88
 F ext/rtree/README 6315c0d73ebf0ec40dedb5aa0e942bc8b54e3761
-F ext/rtree/rtree.c 3f3a595dba485e340246fa2c8ba330a6b9768b00
+F ext/rtree/rtree.c 0acd285bfacc347579a5df9fe947212fb99e2775a40c43f027c3a16936c58e7e
 F ext/rtree/rtree.h 834dbcb82dc85b2481cde6a07cdadfddc99e9b9e
 F ext/rtree/rtree1.test 42dadfc7b44a436cd74a1bebc0b9b689e4eaf7ec
 F ext/rtree/rtree2.test acbb3a4ce0f4fbc2c304d2b4b784cfa161856bba
@@ -323,7 +325,7 @@ F ext/userauth/userauth.c 3410be31283abba70255d71fd24734e017a4497f
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 08e0b151abb46353c677ac4974b50c6077f85eee
+F main.mk 9abb506e717887d57f754bae139b85c1a06d6f2ac25b589f3e792e310567f278
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -336,38 +338,38 @@ F sqlite.pc.in 42b7bf0d02e08b9e77734a47798d1a55a9e0716b
 F sqlite3.1 fc7ad8990fc8409983309bb80de8c811a7506786
 F sqlite3.pc.in 48fed132e7cb71ab676105d2a4dc77127d8c1f3a
 F src/alter.c 3b23977620ce9662ac54443f65b87ba996e36121
-F src/analyze.c 6d8234916c29be943e6ea28b5bef67dff98d9905
+F src/analyze.c 0d0ccf7520a201d8747ea2f02c92c26e26f801bc161f714f27b9f7630dde0421
 F src/attach.c 8c476f8bd5d2afe11d925f890d30e527e5b0ce43
 F src/auth.c 930b376a9c56998557367e6f7f8aaeac82a2a792
 F src/backup.c faf17e60b43233c214aae6a8179d24503a61e83b
 F src/bitvec.c 17ea48eff8ba979f1f5b04cc484c7bb2be632f33
 F src/btmutex.c 0e9ce2d56159b89b9bc8e197e023ee11e39ff8ca
-F src/btree.c e2bae0a03f73d119910fb35c9550987564065137
+F src/btree.c 5aa6108269a84fa9c4b1212754deaf9aed9cbcec603f2e7ea5652e9bf22d9b50
 F src/btree.h bf64dfeeddeebdb775a5eba0098bbc00d073290d
 F src/btreeInt.h cd55d39d9916270837a88c12e701047cba0729b0
 F src/build.c 43f903c9082040ced2b421543cb0300c2973647d
 F src/callback.c 2e76147783386374bf01b227f752c81ec872d730
 F src/complete.c a3634ab1e687055cd002e11b8f43eb75c17da23e
-F src/ctime.c a9984df73898c042a5cfc8f9d8e7723d02bc35c9
+F src/ctime.c 47d91a25ad8f199a71a5b1b7b169d6dd0d6e98c5719eca801568798743d1161c
 F src/date.c ee676e7694dfadbdd2fde1a258a71be8360ba5ae
 F src/dbstat.c 19ee7a4e89979d4df8e44cfac7a8f905ec89b77d
 F src/delete.c 0d9d5549d42e79ce4d82ff1db1e6c81e36d2f67c
-F src/expr.c 8a29e9b72d4b642189999c41782cd6c5bc43512f
+F src/expr.c f12a581f342a6fd85d14c31e4fb84f16b3dd107f54d7728dddb62cebc79d7ce1
 F src/fault.c 460f3e55994363812d9d60844b2a6de88826e007
 F src/fkey.c 2e9aabe1aee76273aff8a84ee92c464e095400ae
-F src/func.c c67273e1ec08abbdcc14c189892a3ff6eeece86b
+F src/func.c 9d52522cc8ae7f5cdadfe14594262f1618bc1f86083c4cd6da861b4cf5af6174
 F src/global.c 4a34512d82fc5aa13c802db06bcfff5e1d3de955
 F src/hash.c 63d0ee752a3b92d4695b2b1f5259c4621b2cfebd
 F src/hash.h ab34c5c54a9e9de2e790b24349ba5aab3dbb4fd4
 F src/hwtime.h 747c1bbe9df21a92e9c50f3bbec1de841dc5e5da
 F src/in-operator.md 10cd8f4bcd225a32518407c2fb2484089112fd71
-F src/insert.c 3ed64afc49c0a2221e397b9f65d231ffbef506fe
+F src/insert.c d4bb3a135948553d18cf992f76f7ed7b18aa0327f250607b5a6671e55d9947d5
 F src/legacy.c e88ed13c2d531decde75d42c2e35623fb9ce3cb0
-F src/loadext.c a68d8d1d14cf7488bb29dc5311cb1ce9a4404258
+F src/loadext.c a72909474dadce771d3669bf84bf689424f6f87d471fee898589c3ef9b2acfd9
 F src/main.c 158326243c5ddc8b98a1e983fa488650cf76d760
-F src/malloc.c d0a1474236486165bcb349af82e2a6560178bf7b
+F src/malloc.c 89c98e3619d362dcffa5c1c639b364b65b474751
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
-F src/mem1.c fd7cd6fe21d46fe0a4186367dd8dc26d87b787eb
+F src/mem1.c c12a42539b1ba105e3707d0e628ad70e611040d8f5e38cf942cee30c867083de
 F src/mem2.c f1940d9e91948dd6a908fbb9ce3835c36b5d83c3
 F src/mem3.c 8768ac94694f31ffaf8b4d0ea5dc08af7010a35a
 F src/mem5.c 9bf955937b07f8c32541c8a9991f33ce3173d944
@@ -392,20 +394,20 @@ F src/parse.y 48b03113704ee8bd78ee6996d81de7fbee22e105
 F src/pcache.c 62835bed959e2914edd26afadfecce29ece0e870
 F src/pcache.h 2cedcd8407eb23017d92790b112186886e179490
 F src/pcache1.c e3967219b2a92b9edcb9324a4ba75009090d3953
-F src/pragma.c b7bf4f1dd9cdcdd3f72f0bdbce3502d69d0f48ba
+F src/pragma.c 2b244434e76c7075edbcfd9e4d634899af0944ff01183b126d4671f7407c2368
 F src/pragma.h c9c763958fec92b04125571472c9500b351c5f7f
 F src/prepare.c b1140c3d0cf59bc85ace00ce363153041b424b7a
-F src/printf.c 67427bbee66d891fc6f6f5aada857e9cdb368c1c
+F src/printf.c 8757834f1b54dae512fb25eb1acc8e94a0d15dd2290b58f2563f65973265adb2
 F src/random.c 80f5d666f23feb3e6665a6ce04c7197212a88384
 F src/resolve.c 3e518b962d932a997fae373366880fc028c75706
 F src/rowset.c 7b7e7e479212e65b723bf40128c7b36dc5afdfac
-F src/select.c d12f3539f80db38b09015561b569e0eb1c4b6c5f
-F src/shell.c 1160c054a483d15213ceb70fdbc383b07eebdf78
-F src/sqlite.h.in 4d0c08f8640c586564a7032b259c5f69bf397850
+F src/select.c 2496d0cc6368dabe7ad2e4c7f5ed3ad9aa3b4d11cd90f33fa1d1ef72493f43aa
+F src/shell.c ceb2b2f1f958ea2c47a7f37972d0f715fbf9dcf6a34a5e98c886b85e3ce6a238
+F src/sqlite.h.in 723107d97f2345a7c103632169dc61366121c4ab65d75a7d83c6dc0e5bbe5ca4
 F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
-F src/sqlite3ext.h 8648034aa702469afb553231677306cc6492a1ae
-F src/sqliteInt.h df268ce1d04df042cf43b557d2309eb0b71e86c4
-F src/sqliteLimit.h c0373387c287c8d0932510b5547ecde31b5da247
+F src/sqlite3ext.h 58fd0676d3111d02e62e5a35992a7d3da5d3f88753acc174f2d37b774fbbdd28
+F src/sqliteInt.h a530e5baf5e559154d5c2e5cc57471bc780a7af4cd0a5d72750b1d850fef1e22
+F src/sqliteLimit.h 1513bfb7b20378aa0041e7022d04acb73525de35b80b252f1b83fedb4de6a76b
 F src/status.c a9e66593dfb28a9e746cba7153f84d49c1ddc4b1
 F src/table.c b46ad567748f24a326d9de40e5b9659f96ffff34
 F src/tclsqlite.c 6c2151b6d8d98e183a04466d40df8889c0574d79
@@ -424,7 +426,7 @@ F src/test_backup.c bf5da90c9926df0a4b941f2d92825a01bbe090a0
 F src/test_bestindex.c d23f80d334c59662af69191854c76b8d3d0c8c96
 F src/test_blob.c f65ac717da2618691cf9dad094e6da0219dcd208
 F src/test_btree.c 8b2dc8b8848cf3a4db93f11578f075e82252a274
-F src/test_config.c 83179ea845479b5be9a651d014649e3f2722a1fe
+F src/test_config.c edcba290248dc18736dd814c9b95863c6762e0b35753048d8cbe5bf65f7abfbb
 F src/test_delete.c af7eab5702f853fb1c62a5f7665e2234cf1ae17b
 F src/test_demovfs.c a0c3bdd45ed044115c2c9f7779e56eafff18741e
 F src/test_devsym.c 4e58dec2602d8e139ca08659f62a62450587cb58
@@ -434,7 +436,7 @@ F src/test_hexio.c 1d4469ca61ab202a1fcec6543f584d2407205e8d
 F src/test_init.c 4413c211a94b62157ca4c145b3f27c497f03c664
 F src/test_intarray.c 988fc61cb0ff539f4172c0d95f15287c92516f64
 F src/test_intarray.h f3b7672f5d1056eac563c0d6ea8480a660b1475c
-F src/test_journal.c d3b83f2bcb7792c709e57abddc456a2b1818643a
+F src/test_journal.c 619f2aa10e0d7a5f87c0f06825bc61dfce1c6b9c7f3ad990fb13de6c3b8874a3
 F src/test_loadext.c 337056bae59f80b9eb00ba82088b39d0f4fe6dfd
 F src/test_malloc.c c05f6c40bd6c8bfe5f1718212f81fd5687f91766
 F src/test_multiplex.c e054459f7633f3ff8ce1245da724f9a8be189e4e
@@ -460,17 +462,17 @@ F src/test_windirent.h 5d67483a55442e31e1bde0f4a230e6e932ad5906
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/threads.c 4ae07fa022a3dc7c5beb373cf744a85d3c5c6c3c
 F src/tokenize.c dc748c5afcb9e5beb3ef5651bc99a4622e30f6a1
-F src/treeview.c 4e44ade3bfe59d82005039f72e09333ce2b4162c
+F src/treeview.c 84d0ac737e1231702679f0289180021e19c5cc186ec413e8dcb704a887c76ec8
 F src/trigger.c c9f0810043b265724fdb1bdd466894f984dfc182
 F src/update.c 456d4a4656f8a03c2abc88a51b19172197400e58
 F src/utf.c 699001c79f28e48e9bcdf8a463da029ea660540c
 F src/util.c ca8440ede81e155d15cff7c101654f60b55a9ae6
 F src/vacuum.c 1fe4555cd8c9b263afb85b5b4ee3a4a4181ad569
-F src/vdbe.c f520378e510fd36bbf289921798dbc8f2b3dc30d
-F src/vdbe.h 59998ffd71d7caa8886bc78dafaf8caeccd4c13c
-F src/vdbeInt.h 4e4b15b2e1330e1636e4e01974eab2b0b985092f
+F src/vdbe.c f1acf5744cef62cbfd0b503d84289f840b6cdc980ac47b0d9632dfdb89cc79eb
+F src/vdbe.h caa5346d52bae2a3c8c1dcfa60a7a4dc878a9e3865cb8239da55808b316c8158
+F src/vdbeInt.h 5db089ce18c4feff8820ec6e4cac2d2c82e03d4b1d96f10a6e43832147b8dffe
 F src/vdbeapi.c 5b08d82592bcff4470601fe78aaabebd50837860
-F src/vdbeaux.c 57361f2e761d92a254638bdbfc03fc68ae6aebc6
+F src/vdbeaux.c ecd0468611925d218e1eb4b3f538907904b136f0e15e333291a232b521bfcef1
 F src/vdbeblob.c 359891617358deefc85bef7bcf787fa6b77facb9
 F src/vdbemem.c 3b5a9a5b375458d3e12a50ae1aaa41eeec2175fd
 F src/vdbesort.c eda25cb2d1727efca6f7862fea32b8aa33c0face
@@ -480,7 +482,7 @@ F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
 F src/wal.c 40c543f0a2195d1b0dc88ef12142bea690009344
 F src/wal.h 06b2a0b599cc0f53ea97f497cf8c6b758c999f71
 F src/walker.c b71a992b413b3a022572eccf29ef4b4890223791
-F src/where.c 1a3a8adb717a20f17c186f3baa22b0b5f3a5ab13
+F src/where.c e815093e5ee039b6b4eb19b646d22deb1a3a523f
 F src/whereInt.h 2d50c2b74a33be44cb68fdecee30b4d93552f1f4
 F src/wherecode.c 677e95413c472c0b413023b6b69a47f40fce1b04
 F src/whereexpr.c 130cdd1a43af71b19755270fb1224874cf55158c
@@ -526,14 +528,14 @@ F test/attachmalloc.test 3a4bfca9545bfe906a8d2e622de10fbac5b711b0
 F test/auth.test c6ede04bee65637ff354b43fc1235aa560c0863e
 F test/auth2.test 9eb7fce9f34bf1f50d3f366fb3e606be5a2000a1
 F test/auth3.test 0d48b901cf111c14b4b1b5205c7d28f1a278190f
-F test/autoanalyze1.test 1ba80d5e1412d46503566b70741a5eea060da929
+F test/autoanalyze1.test b9cc3f32a990fa56669b668d237c6d53e983554ae80c0604992e18869a0b2dec
 F test/autoinc.test 6ae8fb69c9f656962464ae4e6667045d0dfc3b46
 F test/autoindex1.test 14b63a9f1e405fe6d5bfc8c8d00249c2ebaf13ea
 F test/autoindex2.test 12ef578928102baaa0dc23ad397601a2f4ecb0df
 F test/autoindex3.test a3be0d1a53a7d2edff208a5e442312957047e972
 F test/autoindex4.test 49d3cd791a9baa16fb461d7ea3de80d019a819cf
 F test/autoindex5.test 96f084a5e6024ea07cace5888df3223f3ea86990
-F test/autovacuum.test 92c24eedbdb68e49f3fb71f26f9ce6d8988cac15
+F test/autovacuum.test 0831cd34e14695d297187f7f6519265e3121c5b0a1720e548e86829e796129e9
 F test/autovacuum_ioerr2.test 8a367b224183ad801e0e24dcb7d1501f45f244b4
 F test/avtrans.test 0252654f4295ddda3b2cce0e894812259e655a85
 F test/backcompat.test 3e64cedda754c778ef6bbe417b6e7a295e662a4d
@@ -581,7 +583,7 @@ F test/capi3d.test 485048dc5cd07bc68011e4917ad035ad6047ab82
 F test/capi3e.test 3d49c01ef2a1a55f41d73cba2b23b5059ec460fe
 F test/cast.test 4c275cbdc8202d6f9c54a3596701719868ac7dc3
 F test/cffault.test 9d6b20606afe712374952eec4f8fd74b1a8097ef
-F test/check.test 92b23a91fb7be12fba7ee9ce518217e2919a21da
+F test/check.test 33a698e8c63613449d85d624a38ef669bf20331daabebe3891c9405dd6df463a
 F test/close.test 83947daf3b700631f90f4850ddaab455be4af73d
 F test/closure01.test b1703ba40639cfc9b295cf478d70739415eec6a4
 F test/coalesce.test cee0dccb9fbd2d494b77234bccf9dc6c6786eb91
@@ -595,7 +597,7 @@ F test/collate7.test 8ec29d98f3ee4ccebce6e16ce3863fb6b8c7b868
 F test/collate8.test cd9b3d3f999b8520ffaa7cc1647061fc5bab1334
 F test/collate9.test 3adcc799229545940df2f25308dd1ad65869145a
 F test/collateA.test b8218ab90d1fa5c59dcf156efabb1b2599c580d6
-F test/collateB.test 8ec2accd2d7166c1eff0d2a39bc90262c6f89632
+F test/collateB.test 1e68906951b846570f29f20102ed91d29e634854ee47454d725f2151ecac0b95
 F test/colmeta.test 2c765ea61ee37bc43bbe6d6047f89004e6508eb1
 F test/colname.test 08948a4809d22817e0e5de89c7c0a8bd90cb551b
 F test/conflict.test 029faa2d81a0d1cafb5f88614beb663d972c01db
@@ -643,7 +645,6 @@ F test/cursorhint.test 7bc346788390475e77a345da2b92270d04d35856
 F test/cursorhint2.test 8457e93d97f665f23f97cdbc8477d16e3480331b
 F test/date.test 9b73bbeb1b82d9c1f44dec5cf563bf7da58d2373
 F test/dbfuzz.c 73047c920d6210e5912c87cdffd9a1c281d4252e
-F test/dbselftest.c b2e6cfac59066dbcb7334b66304bb15a5508dd42
 F test/dbstatus.test 73149851b3aff14fc6db478e58f9083a66422cf5
 F test/dbstatus2.test e93ab03bfae6d62d4d935f20de928c19ca0ed0ab
 F test/default.test 0cb49b1c315a0d81c81d775e407f66906a2a604d
@@ -833,7 +834,7 @@ F test/fuzz2.test 76dc35b32b6d6f965259508508abce75a6c4d7e1
 F test/fuzz3.test b47377143f0c80f91ed29d722861077ff34415d5
 F test/fuzz_common.tcl a87dfbb88c2a6b08a38e9a070dabd129e617b45b
 F test/fuzz_malloc.test 328f70aaca63adf29b4c6f06505ed0cf57ca7c26
-F test/fuzzcheck.c a87e6067a8d19844bade916841cb76150ecf24a2
+F test/fuzzcheck.c 2152602232c96d9c790eff3013e1369ce59de3203fa0b75bc613531448454e61
 F test/fuzzdata1.db 7ee3227bad0e7ccdeb08a9e6822916777073c664
 F test/fuzzdata2.db f03a420d3b822cc82e4f894ca957618fbe9c4973
 F test/fuzzdata3.db c6586d3e3cef0fbc18108f9bb649aa77bfc38aba
@@ -912,6 +913,7 @@ F test/jrnlmode3.test 556b447a05be0e0963f4311e95ab1632b11c9eaa
 F test/json101.test c0897616f32d95431f37fd291cb78742181980ac
 F test/json102.test bf3fe7a706d30936a76a0f7a0375e1e8e73aff5a
 F test/json103.test c5f6b85e69de05f6b3195f9f9d5ce9cd179099a0
+F test/json104.test 877d5845f6303899b7889ea5dd1bea99076e3100574d5c536082245c5805dcaa
 F test/keyword1.test 37ef6bba5d2ed5b07ecdd6810571de2956599dff
 F test/kvtest.c b9a9822dda05a1aa481215a52e2fc93cd8b22ee5
 F test/lastinsert.test 42e948fd6442f07d60acbd15d33fb86473e0ef63
@@ -955,6 +957,7 @@ F test/mallocI.test 6c23a71df077fa5d387be90e7e669c5b368ca38a
 F test/mallocJ.test b5d1839da331d96223e5f458856f8ffe1366f62e
 F test/mallocK.test 27cb5566a6e5f2d76f9d4aa2eca45524401fd61e
 F test/mallocL.test fb311ff80afddf3b1a75e52289081f4754d901dc
+F test/mallocM.test 78bbe9d3da84a5c679123cdb40d7b2010b18fc46e13897e4f253c6ba6fbff134
 F test/malloc_common.tcl aac62499b76be719fac31e7a3e54a7fd53272e7f
 F test/manydb.test 28385ae2087967aa05c38624cec7d96ec74feb3e
 F test/mem5.test c6460fba403c5703141348cd90de1c294188c68f
@@ -1008,8 +1011,8 @@ F test/orderby7.test 3d1383d52ade5b9eb3a173b3147fdd296f0202da
 F test/orderby8.test 23ef1a5d72bd3adcc2f65561c654295d1b8047bd
 F test/orderby9.test 87fb9548debcc2cd141c5299002dd94672fa76a3
 F test/oserror.test b32dc34f2363ef18532e3a0a7358e3e7e321974f
-F test/ossfuzz.c e469138f4be3e92df6173b79b3b216ab6e17b407
-F test/ossshell.c d9f1a6f43e7bab45d6be857a5800f5d4a1861db3
+F test/ossfuzz.c f5abed3177f719df3c3109901fcdd26b9fb7f581c8da50fc26f3a81ddfb2c2ae
+F test/ossshell.c 296ab63067841bd1b1e97b46a0b2af48ee7f69d50d1a723008bee12dd7122622
 F test/ovfl.test 199c482696defceacee8c8e0e0ef36da62726b2f
 F test/pager1.test 841868017e9dd3cb459b8d78862091a7d9cff21d
 F test/pager2.test 67b8f40ae98112bcdba1f2b2d03ea83266418c71
@@ -1024,7 +1027,7 @@ F test/parser1.test 391b9bf9a229547a129c61ac345ed1a6f5eb1854
 F test/pcache.test c8acbedd3b6fd0f9a7ca887a83b11d24a007972b
 F test/pcache2.test af7f3deb1a819f77a6d0d81534e97d1cf62cd442
 F test/percentile.test 4243af26b8f3f4555abe166f723715a1f74c77ff
-F test/permutations.test 46ad98770d3c04ce2418cab2cc527647bfe961a7
+F test/permutations.test af720e7d139e7e5417341d0f0eef2b911c0b067852138dc2f5b6a451b5725118
 F test/pragma.test 1e94755164a3a3264cd39836de4bebcb7809e5f8
 F test/pragma2.test e5d5c176360c321344249354c0c16aec46214c9f
 F test/pragma3.test 14c12bc5352b1e100e0b6b44f371053a81ccf8ed
@@ -1111,7 +1114,7 @@ F test/sharedA.test 0cdf1a76dfa00e6beee66af5b534b1e8df2720f5
 F test/sharedB.test 16cc7178e20965d75278f410943109b77b2e645e
 F test/shared_err.test 2f2aee20db294b9924e81f6ccbe60f19e21e8506
 F test/sharedlock.test 5ede3c37439067c43b0198f580fd374ebf15d304
-F test/shell1.test bc1ca4161e1f459c9cd412d3f21f4ee635cf2322
+F test/shell1.test 50226a3a66bbd42a902e9f7698f768927eb33a56e9cfc55b7c157c38eb3e80ac
 F test/shell2.test e242a9912f44f4c23c3d1d802a83e934e84c853b
 F test/shell3.test 9b95ba643eaa228376f06a898fb410ee9b6e57c1
 F test/shell4.test 89ad573879a745974ff2df20ff97c5d6ffffbd5d
@@ -1164,6 +1167,7 @@ F test/subtype1.test 7fe09496352f97053af1437150751be2d0a0cae8
 F test/superlock.test ec94f0556b6488d97f71c79f9061ae08d9ab8f12
 F test/symlink.test c9ebe7330d228249e447038276bfc8a7b22f4849
 F test/sync.test 2f84bdbc2b2df1fcb0220575b4b9f8cea94b7529
+F test/sync2.test 29af00fe9e468a1e20315d1edced8f8a32ac156df983ae9b53802e7d472675d5
 F test/syscall.test f59ba4e25f7ba4a4c031026cc2ef8b6e4b4c639c
 F test/sysfault.test c9f2b0d8d677558f74de750c75e12a5454719d04
 F test/tabfunc01.test 699251cb99651415218a891384510a685c7ab012
@@ -1356,6 +1360,7 @@ F test/triggerC.test 302d8995f5ffe63bbc15053abb3ef7a39cf5a092
 F test/triggerD.test 8e7f3921a92a5797d472732108109e44575fa650
 F test/triggerE.test 15fa63f1097db1f83dd62d121616006978063d1f
 F test/triggerF.test 55b1eb13433997faac3a4948c1d8252f6c8c636b
+F test/triggerG.test 175cafdc6399d85231a09e82e051b0e45a2fd1f23dd08ae715bc359716149ab6
 F test/tt3_checkpoint.c 9e75cf7c1c364f52e1c47fd0f14c4340a9db0fe1
 F test/tt3_index.c 39eec10a35f57672225be4d182862152896dee4a
 F test/tt3_lookaside1.c 0377e202c3c2a50d688cb65ba203afeda6fafeb9
@@ -1517,7 +1522,7 @@ F tool/replace.tcl 60f91e8dd06ab81f74d213ecbd9c9945f32ac048
 F tool/restore_jrnl.tcl 6957a34f8f1f0f8285e07536225ec3b292a9024a
 F tool/rollback-test.c 9fc98427d1e23e84429d7e6d07d9094fbdec65a5
 F tool/run-speed-test.sh f95d19fd669b68c4c38b6b475242841d47c66076
-F tool/showdb.c c695a5d5c8110640e0d9fadf5e254da90c79c36e
+F tool/showdb.c e6bc9dba233bf1b57ca0a525a2bba762db4e223de84990739db3f09c46151b1e
 F tool/showjournal.c 5bad7ae8784a43d2b270d953060423b8bd480818
 F tool/showlocks.c 9920bcc64f58378ff1118caead34147201f48c68
 F tool/showstat4.c b14159aa062f661b394ba37b6b7b94bfb8012ab9
@@ -1564,7 +1569,10 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 30f878832820ce7ccc4627c4f0f98fbe82f8b0f6
-R 15b9925a544b33052292bf7b7cba23e6
+P 20e5ffb1ceed514bf812ea5a2ce027b55203612bdbf8116a69f0cd52c67dbb84
+R eff70f988c3d37d60a840932b2823aa3
+T +bgcolor * #d0c0ff
+T +sym-release *
+T +sym-version-3.18.1 *
 U drh
-Z d079eee20e78bccc69196e077d629480
+Z 9e969511e8738c156bb93a567a3e9c78
@@ -1 +1 @@
-2ea300fb8f7c497f3f092dc91f4305d8431c27d9
+77bb46233db03a3338bacf7e56f439be3dfd1926ea0c44d252eeafa7a7b31c06
@@ -1204,7 +1204,7 @@ static void analyzeOneTable(
      regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
      for(j=0; j<pPk->nKeyCol; j++){
        k = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[j]);
-        assert( k>=0 && k<pTab->nCol );
+        assert( k>=0 && k<pIdx->nColumn );
        sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j);
        VdbeComment((v, "%s", pTab->aCol[pPk->aiColumn[j]].zName));
      }
@@ -2861,6 +2861,31 @@ int sqlite3BtreeGetAutoVacuum(Btree *p){
 #endif
 }

+/*
+** If the user has not set the safety-level for this database connection
+** using "PRAGMA synchronous", and if the safety-level is not already
+** set to the value passed to this function as the second parameter,
+** set it so.
+*/
+#if SQLITE_DEFAULT_SYNCHRONOUS!=SQLITE_DEFAULT_WAL_SYNCHRONOUS
+static void setDefaultSyncFlag(BtShared *pBt, u8 safety_level){
+  sqlite3 *db;
+  Db *pDb;
+  if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){
+    while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; }
+    if( pDb->bSyncSet==0 
+     && pDb->safety_level!=safety_level 
+     && pDb!=&db->aDb[1] 
+    ){
+      pDb->safety_level = safety_level;
+      sqlite3PagerSetFlags(pBt->pPager,
+          pDb->safety_level | (db->flags & PAGER_FLAGS_MASK));
+    }
+  }
+}
+#else
+# define setDefaultSyncFlag(pBt,safety_level)
+#endif

 /*
 ** Get a reference to pPage1 of the database file.  This will
@@ -2934,26 +2959,15 @@ static int lockBtree(BtShared *pBt){
      if( rc!=SQLITE_OK ){
        goto page1_init_failed;
      }else{
-#if SQLITE_DEFAULT_SYNCHRONOUS!=SQLITE_DEFAULT_WAL_SYNCHRONOUS
-        sqlite3 *db;
-        Db *pDb;
-        if( (db=pBt->db)!=0 && (pDb=db->aDb)!=0 ){
-          while( pDb->pBt==0 || pDb->pBt->pBt!=pBt ){ pDb++; }
-          if( pDb->bSyncSet==0
-           && pDb->safety_level==SQLITE_DEFAULT_SYNCHRONOUS+1
-          ){
-            pDb->safety_level = SQLITE_DEFAULT_WAL_SYNCHRONOUS+1;
-            sqlite3PagerSetFlags(pBt->pPager,
-               pDb->safety_level | (db->flags & PAGER_FLAGS_MASK));
-          }
-        }
-#endif
+        setDefaultSyncFlag(pBt, SQLITE_DEFAULT_WAL_SYNCHRONOUS+1);
        if( isOpen==0 ){
          releasePage(pPage1);
          return SQLITE_OK;
        }
      }
      rc = SQLITE_NOTADB;
+    }else{
+      setDefaultSyncFlag(pBt, SQLITE_DEFAULT_SYNCHRONOUS+1);
    }
 #endif

@@ -8161,12 +8175,18 @@ int sqlite3BtreeInsert(
      memcpy(newCell, oldCell, 4);
    }
    rc = clearCell(pPage, oldCell, &info);
-    if( info.nSize==szNew && info.nLocal==info.nPayload ){
+    if( info.nSize==szNew && info.nLocal==info.nPayload 
+     && (!ISAUTOVACUUM || szNew<pPage->minLocal)
+    ){
      /* Overwrite the old cell with the new if they are the same size.
      ** We could also try to do this if the old cell is smaller, then add
      ** the leftover space to the free list.  But experiments show that
      ** doing that is no faster then skipping this optimization and just
-      ** calling dropCell() and insertCell(). */
+      ** calling dropCell() and insertCell(). 
+      **
+      ** This optimization cannot be used on an autovacuum database if the
+      ** new entry uses overflow pages, as the insertCell() call below is
+      ** necessary to add the PTRMAP_OVERFLOW1 pointer-map entry.  */
      assert( rc==SQLITE_OK ); /* clearCell never fails when nLocal==nPayload */
      if( oldCell+szNew > pPage->aDataEnd ) return SQLITE_CORRUPT_BKPT;
      memcpy(oldCell, newCell, szNew);
@@ -66,6 +66,12 @@ static const char * const azCompileOpt[] = {
 #if defined(SQLITE_DEFAULT_MMAP_SIZE) && !defined(SQLITE_DEFAULT_MMAP_SIZE_xc)
  "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
 #endif
+#if SQLITE_DEFAULT_SYNCHRONOUS
+  "DEFAULT_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_SYNCHRONOUS),
+#endif
+#if SQLITE_DEFAULT_WAL_SYNCHRONOUS
+  "DEFAULT_WAL_SYNCHRONOUS=" CTIMEOPT_VAL(SQLITE_DEFAULT_WAL_SYNCHRONOUS),
+#endif
 #if SQLITE_DIRECT_OVERFLOW_READ
  "DIRECT_OVERFLOW_READ",
 #endif
@@ -1860,6 +1860,7 @@ int sqlite3ExprContainsSubquery(Expr *p){
 */
 int sqlite3ExprIsInteger(Expr *p, int *pValue){
  int rc = 0;
+  if( p==0 ) return 0;  /* Can only happen following on OOM */

  /* If an expression is an integer literal that fits in a signed 32-bit
  ** integer, then the EP_IntValue flag will have already been set */
@@ -2532,7 +2533,6 @@ int sqlite3CodeSubselect(
          int i;
          sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
          dest.zAffSdst = exprINAffinity(pParse, pExpr);
-          assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
          pSelect->iLimit = 0;
          testcase( pSelect->selFlags & SF_Distinct );
          testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
@@ -204,15 +204,13 @@ static void instrFunc(
    if( typeHaystack==SQLITE_BLOB && typeNeedle==SQLITE_BLOB ){
      zHaystack = sqlite3_value_blob(argv[0]);
      zNeedle = sqlite3_value_blob(argv[1]);
-      assert( zNeedle!=0 );
-      assert( zHaystack!=0 || nHaystack==0 );
      isText = 0;
    }else{
      zHaystack = sqlite3_value_text(argv[0]);
      zNeedle = sqlite3_value_text(argv[1]);
      isText = 1;
-      if( zHaystack==0 || zNeedle==0 ) return;
    }
+    if( zNeedle==0 || (nHaystack && zHaystack==0) ) return;
    while( nNeedle<=nHaystack && memcmp(zHaystack, zNeedle, nNeedle)!=0 ){
      N++;
      do{
@@ -2227,8 +2227,6 @@ static int xferOptimization(
      ** sorted order.  */
      for(i=0; i<pSrcIdx->nColumn; i++){
        const char *zColl = pSrcIdx->azColl[i];
-        assert( sqlite3_stricmp(sqlite3StrBINARY, zColl)!=0
-                    || sqlite3StrBINARY==zColl );
        if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
      }
      if( i==pSrcIdx->nColumn ){
@@ -421,7 +421,9 @@ static const sqlite3_api_routines sqlite3Apis = {
  sqlite3_system_errno,
  /* Version 3.14.0 and later */
  sqlite3_trace_v2,
-  sqlite3_expanded_sql
+  sqlite3_expanded_sql,
+  /* Version 3.18.0 and later */
+  sqlite3_set_last_insert_rowid
 };

 /*
@@ -230,6 +230,13 @@ static void mallocWithAlarm(int n, void **pp){
  ** following xRoundup() call. */
  nFull = sqlite3GlobalConfig.m.xRoundup(n);

+#ifdef SQLITE_MAX_MEMORY
+  if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED)+nFull>SQLITE_MAX_MEMORY ){
+    *pp = 0;
+    return;
+  }
+#endif
+
  sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
  if( mem0.alarmThreshold>0 ){
    sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
@@ -57,7 +57,9 @@
 */
 #include <sys/sysctl.h>
 #include <malloc/malloc.h>
+#ifdef SQLITE_MIGHT_BE_SINGLE_CORE
 #include <libkern/OSAtomic.h>
+#endif /* SQLITE_MIGHT_BE_SINGLE_CORE */
 static malloc_zone_t* _sqliteZone_;
 #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
 #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
@@ -250,19 +252,10 @@ static int sqlite3MemInit(void *NotUsed){
  }else{
    /* only 1 core, use our own zone to contention over global locks, 
    ** e.g. we have our own dedicated locks */
-    bool success;
-    malloc_zone_t* newzone = malloc_create_zone(4096, 0);
-    malloc_set_zone_name(newzone, "Sqlite_Heap");
-    do{
-      success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone, 
-                                 (void * volatile *)&_sqliteZone_);
-    }while(!_sqliteZone_);
-    if( !success ){
-      /* somebody registered a zone first */
-      malloc_destroy_zone(newzone);
-    }
+    _sqliteZone_ = malloc_create_zone(4096, 0);
+    malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap");
  }
-#endif
+#endif /*  defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) */
  UNUSED_PARAMETER(NotUsed);
  return SQLITE_OK;
 }
@@ -1015,7 +1015,7 @@ void sqlite3Pragma(
      if( !db->autoCommit ){
        sqlite3ErrorMsg(pParse, 
            "Safety level may not be changed inside a transaction");
-      }else{
+      }else if( iDb!=1 ){
        int iLevel = (getSafetyLevel(zRight,0,1)+1) & PAGER_SYNCHRONOUS_MASK;
        if( iLevel==0 ) iLevel = 1;
        pDb->safety_level = iLevel;
@@ -1505,6 +1505,7 @@ void sqlite3Pragma(
        int iDataCur, iIdxCur;
        int r1 = -1;

+        if( pTab->tnum<1 ) continue;  /* Skip VIEWs or VIRTUAL TABLEs */
        if( pTab->pCheck==0
         && (pTab->tabFlags & TF_HasNotNull)==0
         && (pTab->pIndex==0 || isQuick)
@@ -400,12 +400,13 @@ void sqlite3VXPrintf(
          nOut = etBUFSIZE;
          zOut = buf;
        }else{
-          nOut = precision + 10 + precision/3;
-          zOut = zExtra = sqlite3Malloc( nOut );
+          u64 n = (u64)precision + 10 + precision/3;
+          zOut = zExtra = sqlite3Malloc( n );
          if( zOut==0 ){
            setStrAccumError(pAccum, STRACCUM_NOMEM);
            return;
          }
+          nOut = (int)n;
        }
        bufpt = &zOut[nOut-1];
        if( xtype==etORDINAL ){
@@ -3749,7 +3749,9 @@ static int flattenSubquery(
    }else{
      pParent->pWhere = sqlite3ExprAnd(db, pWhere, pParent->pWhere);
    }
-    substSelect(pParse, pParent, iParent, pSub->pEList, 0);
+    if( db->mallocFailed==0 ){
+      substSelect(pParse, pParent, iParent, pSub->pEList, 0);
+    }
  
    /* The flattened query is distinct if either the inner or the
    ** outer query is distinct. 
@@ -1361,15 +1361,11 @@ struct SavedModeInfo {
 typedef struct ShellState ShellState;
 struct ShellState {
  sqlite3 *db;           /* The database */
-  int echoOn;            /* True to echo input commands */
  int autoExplain;       /* Automatically turn on .explain mode */
  int autoEQP;           /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
  int statsOn;           /* True to display memory stats before each finalize */
  int scanstatsOn;       /* True to display scan stats before each finalize */
-  int countChanges;      /* True to display change counts */
-  int backslashOn;       /* Resolve C-style \x escapes in SQL input text */
  int outCount;          /* Revert to stdout when reaching zero */
-  int preserveRowid;     /* Preserver ROWID values on a ".dump" command */
  int cnt;               /* Number of records displayed so far */
  FILE *out;             /* Write results here */
  FILE *traceOut;        /* Output for sqlite3_trace() */
@@ -1407,9 +1403,20 @@ struct ShellState {
 /*
 ** These are the allowed shellFlgs values
 */
-#define SHFLG_Scratch     0x00001     /* The --scratch option is used */
-#define SHFLG_Pagecache   0x00002     /* The --pagecache option is used */
-#define SHFLG_Lookaside   0x00004     /* Lookaside memory is used */
+#define SHFLG_Scratch        0x00000001 /* The --scratch option is used */
+#define SHFLG_Pagecache      0x00000002 /* The --pagecache option is used */
+#define SHFLG_Lookaside      0x00000004 /* Lookaside memory is used */
+#define SHFLG_Backslash      0x00000008 /* The --backslash option is used */
+#define SHFLG_PreserveRowid  0x00000010 /* .dump preserves rowid values */
+#define SHFLG_CountChanges   0x00000020 /* .changes setting */
+#define SHFLG_Echo           0x00000040 /* .echo or --echo setting */
+
+/*
+** Macros for testing and setting shellFlgs
+*/
+#define ShellHasFlag(P,X)    (((P)->shellFlgs & (X))!=0)
+#define ShellSetFlag(P,X)    ((P)->shellFlgs|=(X))
+#define ShellClearFlag(P,X)  ((P)->shellFlgs&=(~(X)))

 /*
 ** These are the allowed modes.
@@ -1483,32 +1490,52 @@ static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){

 /*
 ** Output the given string as a quoted string using SQL quoting conventions.
+**
+** The "\n" and "\r" characters are converted to char(10) and char(13)
+** to prevent them from being transformed by end-of-line translators.
 */
 static void output_quoted_string(FILE *out, const char *z){
  int i;
-  int nSingle = 0;
+  char c;
  setBinaryMode(out, 1);
-  for(i=0; z[i]; i++){
-    if( z[i]=='\'' ) nSingle++;
-  }
-  if( nSingle==0 ){
+  for(i=0; (c = z[i])!=0 && c!='\'' && c!='\n' && c!='\r'; i++){}
+  if( c==0 ){
    utf8_printf(out,"'%s'",z);
  }else{
-    raw_printf(out,"'");
+    int inQuote = 0;
+    int bStarted = 0;
    while( *z ){
-      for(i=0; z[i] && z[i]!='\''; i++){}
-      if( i==0 ){
-        raw_printf(out,"''");
-        z++;
-      }else if( z[i]=='\'' ){
-        utf8_printf(out,"%.*s''",i,z);
-        z += i+1;
-      }else{
-        utf8_printf(out,"%s",z);
+      for(i=0; (c = z[i])!=0 && c!='\n' && c!='\r' && c!='\''; i++){}
+      if( c=='\'' ) i++;
+      if( i ){
+        if( !inQuote ){
+          if( bStarted ) raw_printf(out, "||");
+          raw_printf(out, "'");
+          inQuote = 1;
+        }
+        utf8_printf(out, "%.*s", i, z);
+        z += i;
+        bStarted = 1;
+      }
+      if( c=='\'' ){
+        raw_printf(out, "'");
+        continue;
+      }
+      if( inQuote ){
+        raw_printf(out, "'");
+        inQuote = 0;
+      }
+      if( c==0 ){
        break;
      }
+      for(i=0; (c = z[i])=='\r' || c=='\n'; i++){
+        if( bStarted ) raw_printf(out, "||");
+        raw_printf(out, "char(%d)", c);
+        bStarted = 1;
+      }
+      z += i;
    }
-    raw_printf(out,"'");
+    if( inQuote ) raw_printf(out, "'");
  }
  setTextMode(out, 1);
 }
@@ -2000,9 +2027,13 @@ static int shell_callback(
        }else if( aiType && aiType[i]==SQLITE_TEXT ){
          if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
          output_quoted_string(p->out, azArg[i]);
-        }else if( aiType && (aiType[i]==SQLITE_INTEGER
-                             || aiType[i]==SQLITE_FLOAT) ){
+        }else if( aiType && aiType[i]==SQLITE_INTEGER ){
          utf8_printf(p->out,"%s%s",zSep, azArg[i]);
+        }else if( aiType && aiType[i]==SQLITE_FLOAT ){
+          char z[50];
+          double r = sqlite3_column_double(p->pStmt, i);
+          sqlite3_snprintf(50,z,"%!.20g", r);
+          raw_printf(p->out, "%s%s", zSep, z);
        }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
          const void *pBlob = sqlite3_column_blob(p->pStmt, i);
          int nBlob = sqlite3_column_bytes(p->pStmt, i);
@@ -2047,6 +2078,70 @@ static int callback(void *pArg, int nArg, char **azArg, char **azCol){
  return shell_callback(pArg, nArg, azArg, azCol, NULL);
 }

+/*
+** This is the callback routine from sqlite3_exec() that appends all
+** output onto the end of a ShellText object.
+*/
+static int captureOutputCallback(void *pArg, int nArg, char **azArg, char **az){
+  ShellText *p = (ShellText*)pArg;
+  int i;
+  UNUSED_PARAMETER(az);
+  if( p->n ) appendText(p, "|", 0);
+  for(i=0; i<nArg; i++){
+    if( i ) appendText(p, ",", 0);
+    if( azArg[i] ) appendText(p, azArg[i], 0);
+  }
+  return 0;
+}
+
+/*
+** Generate an appropriate SELFTEST table in the main database.
+*/
+static void createSelftestTable(ShellState *p){
+  char *zErrMsg = 0;
+  sqlite3_exec(p->db,
+    "SAVEPOINT selftest_init;\n"
+    "CREATE TABLE IF NOT EXISTS selftest(\n"
+    "  tno INTEGER PRIMARY KEY,\n"   /* Test number */
+    "  op TEXT,\n"                   /* Operator:  memo run */
+    "  cmd TEXT,\n"                  /* Command text */
+    "  ans TEXT\n"                   /* Desired answer */
+    ");"
+    "CREATE TEMP TABLE [_shell$self](op,cmd,ans);\n"
+    "INSERT INTO [_shell$self](rowid,op,cmd)\n"
+    "  VALUES(coalesce((SELECT (max(tno)+100)/10 FROM selftest),10),\n"
+    "         'memo','Tests generated by --init');\n"
+    "INSERT INTO [_shell$self]\n"
+    "  SELECT 'run',\n"
+    "    'SELECT hex(sha3_query(''SELECT type,name,tbl_name,sql "
+                                 "FROM sqlite_master ORDER BY 2'',224))',\n"
+    "    hex(sha3_query('SELECT type,name,tbl_name,sql "
+                          "FROM sqlite_master ORDER BY 2',224));\n"
+    "INSERT INTO [_shell$self]\n"
+    "  SELECT 'run',"
+    "    'SELECT hex(sha3_query(''SELECT * FROM \"' ||"
+    "        printf('%w',name) || '\" NOT INDEXED'',224))',\n"
+    "    hex(sha3_query(printf('SELECT * FROM \"%w\" NOT INDEXED',name),224))\n"
+    "  FROM (\n"
+    "    SELECT name FROM sqlite_master\n"
+    "     WHERE type='table'\n"
+    "       AND name<>'selftest'\n"
+    "       AND coalesce(rootpage,0)>0\n"
+    "  )\n"
+    " ORDER BY name;\n"
+    "INSERT INTO [_shell$self]\n"
+    "  VALUES('run','PRAGMA integrity_check','ok');\n"
+    "INSERT INTO selftest(tno,op,cmd,ans)"
+    "  SELECT rowid*10,op,cmd,ans FROM [_shell$self];\n"
+    "DROP TABLE [_shell$self];"
+    ,0,0,&zErrMsg);
+  if( zErrMsg ){
+    utf8_printf(stderr, "SELFTEST initialization failure: %s\n", zErrMsg);
+    sqlite3_free(zErrMsg);
+  }
+  sqlite3_exec(p->db, "RELEASE selftest_init",0,0,0);
+}
+

 /*
 ** Set the destination table field of the ShellState structure to
@@ -2189,6 +2284,31 @@ static void displayLinuxIoStats(FILE *out){
 }
 #endif

+/*
+** Display a single line of status using 64-bit values.
+*/
+static void displayStatLine(
+  ShellState *p,            /* The shell context */
+  char *zLabel,             /* Label for this one line */
+  char *zFormat,            /* Format for the result */
+  int iStatusCtrl,          /* Which status to display */
+  int bReset                /* True to reset the stats */
+){
+  sqlite3_int64 iCur = -1;
+  sqlite3_int64 iHiwtr = -1;
+  int i, nPercent;
+  char zLine[200];
+  sqlite3_status64(iStatusCtrl, &iCur, &iHiwtr, bReset);
+  for(i=0, nPercent=0; zFormat[i]; i++){
+    if( zFormat[i]=='%' ) nPercent++;
+  }
+  if( nPercent>1 ){
+    sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iCur, iHiwtr);
+  }else{
+    sqlite3_snprintf(sizeof(zLine), zLine, zFormat, iHiwtr);
+  }
+  raw_printf(p->out, "%-36s %s\n", zLabel, zLine);
+}

 /*
 ** Display memory stats.
@@ -2202,57 +2322,31 @@ static int display_stats(
  int iHiwtr;

  if( pArg && pArg->out ){
-
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out,
-            "Memory Used:                         %d (max %d) bytes\n",
-            iCur, iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Number of Outstanding Allocations:   %d (max %d)\n",
-            iCur, iHiwtr);
+    displayStatLine(pArg, "Memory Used:",
+       "%lld (max %lld) bytes", SQLITE_STATUS_MEMORY_USED, bReset);
+    displayStatLine(pArg, "Number of Outstanding Allocations:",
+       "%lld (max %lld)", SQLITE_STATUS_MALLOC_COUNT, bReset);
    if( pArg->shellFlgs & SHFLG_Pagecache ){
-      iHiwtr = iCur = -1;
-      sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out,
-              "Number of Pcache Pages Used:         %d (max %d) pages\n",
-              iCur, iHiwtr);
+      displayStatLine(pArg, "Number of Pcache Pages Used:",
+         "%lld (max %lld) pages", SQLITE_STATUS_PAGECACHE_USED, bReset);
    }
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out,
-            "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n",
-            iCur, iHiwtr);
+    displayStatLine(pArg, "Number of Pcache Overflow Bytes:",
+       "%lld (max %lld) bytes", SQLITE_STATUS_PAGECACHE_OVERFLOW, bReset);
    if( pArg->shellFlgs & SHFLG_Scratch ){
-      iHiwtr = iCur = -1;
-      sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out,
-              "Number of Scratch Allocations Used:  %d (max %d)\n",
-              iCur, iHiwtr);
+      displayStatLine(pArg, "Number of Scratch Allocations Used:",
+         "%lld (max %lld)", SQLITE_STATUS_SCRATCH_USED, bReset);
    }
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out,
-            "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n",
-            iCur, iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Largest Allocation:                  %d bytes\n",
-            iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Largest Pcache Allocation:           %d bytes\n",
-            iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Largest Scratch Allocation:          %d bytes\n",
-            iHiwtr);
+    displayStatLine(pArg, "Number of Scratch Overflow Bytes:",
+       "%lld (max %lld) bytes", SQLITE_STATUS_SCRATCH_OVERFLOW, bReset);
+    displayStatLine(pArg, "Largest Allocation:",
+       "%lld bytes", SQLITE_STATUS_MALLOC_SIZE, bReset);
+    displayStatLine(pArg, "Largest Pcache Allocation:",
+       "%lld bytes", SQLITE_STATUS_PAGECACHE_SIZE, bReset);
+    displayStatLine(pArg, "Largest Scratch Allocation:",
+       "%lld bytes", SQLITE_STATUS_SCRATCH_SIZE, bReset);
 #ifdef YYTRACKMAXSTACKDEPTH
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Deepest Parser Stack:                %d (max %d)\n",
-            iCur, iHiwtr);
+    displayStatLine(pArg, "Deepest Parser Stack:",
+       "%lld (max %lld)", SQLITE_STATUS_PARSER_STACK, bReset);
 #endif
  }

@@ -2639,7 +2733,7 @@ static int shell_exec(
      }

      /* echo the sql statement if echo on */
-      if( pArg && pArg->echoOn ){
+      if( pArg && ShellHasFlag(pArg, SHFLG_Echo) ){
        utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
      }

@@ -2760,7 +2854,7 @@ static char **tableColumnList(ShellState *p, const char *zTab){
  int nAlloc = 0;
  int nPK = 0;       /* Number of PRIMARY KEY columns seen */
  int isIPK = 0;     /* True if one PRIMARY KEY column of type INTEGER */
-  int preserveRowid = p->preserveRowid;
+  int preserveRowid = ShellHasFlag(p, SHFLG_PreserveRowid);
  int rc;

  zSql = sqlite3_mprintf("PRAGMA table_info=%Q", zTab);
@@ -2833,7 +2927,6 @@ static char **tableColumnList(ShellState *p, const char *zTab){
        ** ordinary column in the table.  Verify that azRowid[j] is a valid
        ** name for the rowid before adding it to azCol[0].  WITHOUT ROWID
        ** tables will fail this last check */
-        int rc;
        rc = sqlite3_table_column_metadata(p->db,0,zTab,azRowid[j],0,0,0,0,0);
        if( rc==SQLITE_OK ) azCol[0] = azRowid[j];
        break;
@@ -2843,20 +2936,37 @@ static char **tableColumnList(ShellState *p, const char *zTab){
  return azCol;
 }

+/*
+** Toggle the reverse_unordered_selects setting.
+*/
+static void toggleSelectOrder(sqlite3 *db){
+  sqlite3_stmt *pStmt = 0;
+  int iSetting = 0;
+  char zStmt[100];
+  sqlite3_prepare_v2(db, "PRAGMA reverse_unordered_selects", -1, &pStmt, 0);
+  if( sqlite3_step(pStmt)==SQLITE_ROW ){
+    iSetting = sqlite3_column_int(pStmt, 0);
+  }
+  sqlite3_finalize(pStmt);
+  sqlite3_snprintf(sizeof(zStmt), zStmt,
+       "PRAGMA reverse_unordered_selects(%d)", !iSetting);
+  sqlite3_exec(db, zStmt, 0, 0, 0);
+}
+
 /*
 ** This is a different callback routine used for dumping the database.
 ** Each row received by this callback consists of a table name,
 ** the table type ("index" or "table") and SQL to create the table.
 ** This routine should print text sufficient to recreate the table.
 */
-static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
+static int dump_callback(void *pArg, int nArg, char **azArg, char **azNotUsed){
  int rc;
  const char *zTable;
  const char *zType;
  const char *zSql;
  ShellState *p = (ShellState *)pArg;

-  UNUSED_PARAMETER(azCol);
+  UNUSED_PARAMETER(azNotUsed);
  if( nArg!=3 ) return 1;
  zTable = azArg[0];
  zType = azArg[1];
@@ -2939,6 +3049,12 @@ static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
    p->zDestTable = sTable.z;
    p->mode = p->cMode = MODE_Insert;
    rc = shell_exec(p->db, sSelect.z, shell_callback, p, 0);
+    if( (rc&0xff)==SQLITE_CORRUPT ){
+      raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
+      toggleSelectOrder(p->db);
+      shell_exec(p->db, sSelect.z, shell_callback, p, 0);
+      toggleSelectOrder(p->db);
+    }
    p->zDestTable = savedDestTable;
    p->mode = savedMode;
    freeText(&sTable);
@@ -3053,6 +3169,7 @@ static char zHelp[] =
  ".scanstats on|off      Turn sqlite3_stmt_scanstatus() metrics on or off\n"
  ".schema ?PATTERN?      Show the CREATE statements matching PATTERN\n"
  "                          Add --indent for pretty-printing\n"
+  ".selftest ?--init?     Run tests defined in the SELFTEST table\n"
  ".separator COL ?ROW?   Change the column separator and optionally the row\n"
  "                         separator for both the output mode and .import\n"
 #if defined(SQLITE_ENABLE_SESSION)
@@ -3394,7 +3511,7 @@ static sqlite3_int64 integerValue(const char *zArg){
 ** Interpret zArg as either an integer or a boolean value.  Return 1 or 0
 ** for TRUE and FALSE.  Return the integer value if appropriate.
 */
-static int booleanValue(char *zArg){
+static int booleanValue(const char *zArg){
  int i;
  if( zArg[0]=='0' && zArg[1]=='x' ){
    for(i=2; hexDigitValue(zArg[i])>=0; i++){}
@@ -3413,6 +3530,17 @@ static int booleanValue(char *zArg){
  return 0;
 }

+/*
+** Set or clear a shell flag according to a boolean value.
+*/
+static void setOrClearFlag(ShellState *p, unsigned mFlag, const char *zArg){
+  if( booleanValue(zArg) ){
+    ShellSetFlag(p, mFlag);
+  }else{
+    ShellClearFlag(p, mFlag);
+  }
+}
+
 /*
 ** Close an output file, assuming it is not stderr or stdout
 */
@@ -4486,7 +4614,7 @@ static int do_meta_command(char *zLine, ShellState *p){

  if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
    if( nArg==2 ){
-      p->countChanges = booleanValue(azArg[1]);
+      setOrClearFlag(p, SHFLG_CountChanges, azArg[1]);
    }else{
      raw_printf(stderr, "Usage: .changes on|off\n");
      rc = 1;
@@ -4552,13 +4680,20 @@ static int do_meta_command(char *zLine, ShellState *p){
  if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
    const char *zLike = 0;
    int i;
-    p->preserveRowid = 0;
+    ShellClearFlag(p, SHFLG_PreserveRowid);
    for(i=1; i<nArg; i++){
      if( azArg[i][0]=='-' ){
        const char *z = azArg[i]+1;
        if( z[0]=='-' ) z++;
        if( strcmp(z,"preserve-rowids")==0 ){
-          p->preserveRowid = 1;
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+          raw_printf(stderr, "The --preserve-rowids option is not compatible"
+                             " with SQLITE_OMIT_VIRTUALTABLE\n");
+          rc = 1;
+          goto meta_command_exit;
+#else
+          ShellSetFlag(p, SHFLG_PreserveRowid);
+#endif
        }else
        {
          raw_printf(stderr, "Unknown option \"%s\" on \".dump\"\n", azArg[i]);
@@ -4625,7 +4760,7 @@ static int do_meta_command(char *zLine, ShellState *p){

  if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
    if( nArg==2 ){
-      p->echoOn = booleanValue(azArg[1]);
+      setOrClearFlag(p, SHFLG_Echo, azArg[1]);
    }else{
      raw_printf(stderr, "Usage: .echo on|off\n");
      rc = 1;
@@ -5686,6 +5821,119 @@ static int do_meta_command(char *zLine, ShellState *p){
  }else
 #endif

+  if( c=='s' && n>=4 && strncmp(azArg[0],"selftest",n)==0 ){
+    int bIsInit = 0;         /* True to initialize the SELFTEST table */
+    int bVerbose = 0;        /* Verbose output */
+    int bSelftestExists;     /* True if SELFTEST already exists */
+    char **azTest = 0;       /* Content of the SELFTEST table */
+    int nRow = 0;            /* Number of rows in the SELFTEST table */
+    int nCol = 4;            /* Number of columns in the SELFTEST table */
+    int i;                   /* Loop counter */
+    int nTest = 0;           /* Number of tests runs */
+    int nErr = 0;            /* Number of errors seen */
+    ShellText str;           /* Answer for a query */
+    static char *azDefaultTest[] = {
+       0, 0, 0, 0,
+       "0", "memo", "Missing SELFTEST table - default checks only", "",
+       "1", "run", "PRAGMA integrity_check", "ok"
+    };
+    static const int nDefaultRow = 2;
+
+    open_db(p,0);
+    for(i=1; i<nArg; i++){
+      const char *z = azArg[i];
+      if( z[0]=='-' && z[1]=='-' ) z++;
+      if( strcmp(z,"-init")==0 ){
+        bIsInit = 1;
+      }else
+      if( strcmp(z,"-v")==0 ){
+        bVerbose++;
+      }else
+      {
+        utf8_printf(stderr, "Unknown option \"%s\" on \"%s\"\n",
+                    azArg[i], azArg[0]);
+        raw_printf(stderr, "Should be one of: --init -v\n");
+        rc = 1;
+        goto meta_command_exit;
+      }
+    }
+    if( sqlite3_table_column_metadata(p->db,"main","selftest",0,0,0,0,0,0)
+           != SQLITE_OK ){
+      bSelftestExists = 0;
+    }else{
+      bSelftestExists = 1;
+    }
+    if( bIsInit ){
+      createSelftestTable(p);
+      bSelftestExists = 1;
+    }
+    if( bSelftestExists ){
+      rc = sqlite3_get_table(p->db, 
+          "SELECT tno,op,cmd,ans FROM selftest ORDER BY tno",
+          &azTest, &nRow, &nCol, 0);
+      if( rc ){
+        raw_printf(stderr, "Error querying the selftest table\n");
+        rc = 1;
+        sqlite3_free_table(azTest);
+        goto meta_command_exit;
+      }else if( nRow==0 ){
+        sqlite3_free_table(azTest);
+        azTest = azDefaultTest;
+        nRow = nDefaultRow;
+      }
+    }else{
+      azTest = azDefaultTest;
+      nRow = nDefaultRow;
+    }
+    initText(&str);
+    appendText(&str, "x", 0);
+    for(i=1; i<=nRow; i++){
+      int tno = atoi(azTest[i*nCol]);
+      const char *zOp = azTest[i*nCol+1];
+      const char *zSql = azTest[i*nCol+2];
+      const char *zAns = azTest[i*nCol+3];
+  
+      if( bVerbose>0 ){
+        char *zQuote = sqlite3_mprintf("%q", zSql);
+        printf("%d: %s %s\n", tno, zOp, zSql);
+        sqlite3_free(zQuote);
+      }
+      if( strcmp(zOp,"memo")==0 ){
+        utf8_printf(p->out, "%s\n", zSql);
+      }else
+      if( strcmp(zOp,"run")==0 ){
+        char *zErrMsg = 0;
+        str.n = 0;
+        str.z[0] = 0;
+        rc = sqlite3_exec(p->db, zSql, captureOutputCallback, &str, &zErrMsg);
+        nTest++;
+        if( bVerbose ){
+          utf8_printf(p->out, "Result: %s\n", str.z);
+        }
+        if( rc || zErrMsg ){
+          nErr++;
+          rc = 1;
+          utf8_printf(p->out, "%d: error-code-%d: %s\n", tno, rc, zErrMsg);
+          sqlite3_free(zErrMsg);
+        }else if( strcmp(zAns,str.z)!=0 ){
+          nErr++;
+          rc = 1;
+          utf8_printf(p->out, "%d: Expected: [%s]\n", tno, zAns);
+          utf8_printf(p->out, "%d:      Got: [%s]\n", tno, str.z);
+        }
+      }else
+      {
+        utf8_printf(stderr,
+          "Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
+        rc = 1;
+        break;
+      }
+    }
+    freeText(&str);
+    if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
+    utf8_printf(p->out, "%d errors out of %d tests\n", nErr, nTest);
+  }else
+
  if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
    if( nArg<2 || nArg>3 ){
      raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
@@ -5845,7 +6093,8 @@ static int do_meta_command(char *zLine, ShellState *p){
      rc = 1;
      goto meta_command_exit;
    }
-    utf8_printf(p->out, "%12.12s: %s\n","echo", azBool[p->echoOn!=0]);
+    utf8_printf(p->out, "%12.12s: %s\n","echo",
+                                  azBool[ShellHasFlag(p, SHFLG_Echo)]);
    utf8_printf(p->out, "%12.12s: %s\n","eqp", azBool[p->autoEQP&3]);
    utf8_printf(p->out, "%12.12s: %s\n","explain",
         p->mode==MODE_Explain ? "on" : p->autoExplain ? "auto" : "off");
@@ -6410,7 +6659,7 @@ static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
  char *zErrMsg = 0;

  open_db(p, 0);
-  if( p->backslashOn ) resolve_backslashes(zSql);
+  if( ShellHasFlag(p,SHFLG_Backslash) ) resolve_backslashes(zSql);
  BEGIN_TIMER;
  rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
  END_TIMER;
@@ -6430,7 +6679,7 @@ static int runOneSqlLine(ShellState *p, char *zSql, FILE *in, int startline){
      utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
    }
    return 1;
-  }else if( p->countChanges ){
+  }else if( ShellHasFlag(p, SHFLG_CountChanges) ){
    raw_printf(p->out, "changes: %3d   total_changes: %d\n",
            sqlite3_changes(p->db), sqlite3_total_changes(p->db));
  }
@@ -6473,11 +6722,11 @@ static int process_input(ShellState *p, FILE *in){
    }
    lineno++;
    if( nSql==0 && _all_whitespace(zLine) ){
-      if( p->echoOn ) printf("%s\n", zLine);
+      if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
      continue;
    }
    if( zLine && zLine[0]=='.' && nSql==0 ){
-      if( p->echoOn ) printf("%s\n", zLine);
+      if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zLine);
      rc = do_meta_command(zLine, p);
      if( rc==2 ){ /* exit requested */
        break;
@@ -6520,7 +6769,7 @@ static int process_input(ShellState *p, FILE *in){
        p->outCount = 0;
      }
    }else if( nSql && _all_whitespace(zSql) ){
-      if( p->echoOn ) printf("%s\n", zSql);
+      if( ShellHasFlag(p, SHFLG_Echo) ) printf("%s\n", zSql);
      nSql = 0;
    }
  }
@@ -6989,7 +7238,7 @@ int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
    }else if( strcmp(z,"-noheader")==0 ){
      data.showHeader = 0;
    }else if( strcmp(z,"-echo")==0 ){
-      data.echoOn = 1;
+      ShellSetFlag(&data, SHFLG_Echo);
    }else if( strcmp(z,"-eqp")==0 ){
      data.autoEQP = 1;
    }else if( strcmp(z,"-eqpfull")==0 ){
@@ -7004,7 +7253,7 @@ int SQLITE_CDECL wmain(int argc, wchar_t **wargv){
      ** prior to sending the SQL into SQLite.  Useful for injecting
      ** crazy bytes in the middle of SQL statements for testing and debugging.
      */
-      data.backslashOn = 1;
+      ShellSetFlag(&data, SHFLG_Backslash);
    }else if( strcmp(z,"-bail")==0 ){
      bail_on_error = 1;
    }else if( strcmp(z,"-version")==0 ){
@@ -114,8 +114,8 @@ extern "C" {
 ** system</a>.  ^The SQLITE_SOURCE_ID macro evaluates to
 ** a string which identifies a particular check-in of SQLite
 ** within its configuration management system.  ^The SQLITE_SOURCE_ID
-** string contains the date and time of the check-in (UTC) and an SHA1
-** hash of the entire source tree.
+** string contains the date and time of the check-in (UTC) and a SHA1
+** or SHA3-256 hash of the entire source tree.
 **
 ** See also: [sqlite3_libversion()],
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
@@ -3424,9 +3424,9 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
 **
 ** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
 ** <dd>The maximum number of instructions in a virtual machine program
-** used to implement an SQL statement.  This limit is not currently
-** enforced, though that might be added in some future release of
-** SQLite.</dd>)^
+** used to implement an SQL statement.  If [sqlite3_prepare_v2()] or
+** the equivalent tries to allocate space for more than this many opcodes
+** in a single prepared statement, an SQLITE_NOMEM error is returned.</dd>)^
 **
 ** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
 ** <dd>The maximum number of arguments on a function.</dd>)^
@@ -3464,6 +3464,7 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
 #define SQLITE_LIMIT_TRIGGER_DEPTH            10
 #define SQLITE_LIMIT_WORKER_THREADS           11

+
 /*
 ** CAPI3REF: Compiling An SQL Statement
 ** KEYWORDS: {SQL statement compiler}
@@ -282,6 +282,8 @@ struct sqlite3_api_routines {
  /* Version 3.14.0 and later */
  int (*trace_v2)(sqlite3*,unsigned,int(*)(unsigned,void*,void*,void*),void*);
  char *(*expanded_sql)(sqlite3_stmt*);
+  /* Version 3.18.0 and later */
+  void (*set_last_insert_rowid)(sqlite3*,sqlite3_int64);
 };

 /*
@@ -540,6 +542,8 @@ typedef int (*sqlite3_loadext_entry)(
 /* Version 3.14.0 and later */
 #define sqlite3_trace_v2               sqlite3_api->trace_v2
 #define sqlite3_expanded_sql           sqlite3_api->expanded_sql
+/* Version 3.18.0 and later */
+#define sqlite3_set_last_insert_rowid  sqlite3_api->set_last_insert_rowid
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */

 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
@@ -1127,7 +1127,7 @@ typedef int VList;
 ** and the one-based values are used internally.
 */
 #ifndef SQLITE_DEFAULT_SYNCHRONOUS
-# define SQLITE_DEFAULT_SYNCHRONOUS (PAGER_SYNCHRONOUS_FULL-1)
+# define SQLITE_DEFAULT_SYNCHRONOUS 2
 #endif
 #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS
 # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS
@@ -87,7 +87,7 @@
 ** Not currently enforced.
 */
 #ifndef SQLITE_MAX_VDBE_OP
-# define SQLITE_MAX_VDBE_OP 25000
+# define SQLITE_MAX_VDBE_OP 250000000
 #endif

 /*
@@ -740,6 +740,8 @@ Tcl_SetVar2(interp, "sqlite_options", "mergesort", "1", TCL_GLOBAL_ONLY);
  LINKVAR( DEFAULT_CACHE_SIZE );
  LINKVAR( DEFAULT_PAGE_SIZE );
  LINKVAR( DEFAULT_FILE_FORMAT );
+  LINKVAR( DEFAULT_SYNCHRONOUS );
+  LINKVAR( DEFAULT_WAL_SYNCHRONOUS );
  LINKVAR( MAX_ATTACHED );
  LINKVAR( MAX_DEFAULT_PAGE_SIZE );
  LINKVAR( MAX_WORKER_THREADS );
@@ -557,6 +557,9 @@ static int jtWrite(
      u32 pgno = (u32)(iOfst/p->nPagesize + 1);
      assert( (iAmt==1||iAmt==(int)p->nPagesize) &&
              ((iOfst+iAmt)%p->nPagesize)==0 );
+      /* The following assert() statements may fail if this layer is used
+      ** with a connection in "PRAGMA synchronous=off" mode. If they
+      ** fail with sync=normal or sync=full, this may indicate problem.  */
      assert( pgno<=p->nPage || p->nSync>0 );
      assert( pgno>p->nPage || sqlite3BitvecTest(p->pWritable, pgno) );
    }
@@ -126,6 +126,10 @@ void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 moreToFollow){
 void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
  int n = 0;
  int cnt = 0;
+  if( p==0 ){
+    sqlite3TreeViewLine(pView, "nil-SELECT");
+    return;
+  } 
  pView = sqlite3TreeViewPush(pView, moreToFollow);
  if( p->pWith ){
    sqlite3TreeViewWith(pView, p->pWith, 1);
@@ -403,9 +403,7 @@ void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
    }else{
      c = 's';
    }
-
-    sqlite3_snprintf(100, zCsr, "%c", c);
-    zCsr += sqlite3Strlen30(zCsr);
+    *(zCsr++) = c;
    sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
    zCsr += sqlite3Strlen30(zCsr);
    for(i=0; i<16 && i<pMem->n; i++){
@@ -417,9 +415,7 @@ void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
      if( z<32 || z>126 ) *zCsr++ = '.';
      else *zCsr++ = z;
    }
-
-    sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
-    zCsr += sqlite3Strlen30(zCsr);
+    *(zCsr++) = ']';
    if( f & MEM_Zero ){
      sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
      zCsr += sqlite3Strlen30(zCsr);
@@ -2336,19 +2332,39 @@ case OP_BitNot: {             /* same as TK_BITNOT, in1, out2 */

 /* Opcode: Once P1 P2 * * *
 **
-** If the P1 value is equal to the P1 value on the OP_Init opcode at
-** instruction 0, then jump to P2.  If the two P1 values differ, then
-** set the P1 value on this opcode to equal the P1 value on the OP_Init
-** and fall through.
+** Fall through to the next instruction the first time this opcode is
+** encountered on each invocation of the byte-code program.  Jump to P2
+** on the second and all subsequent encounters during the same invocation.
+**
+** Top-level programs determine first invocation by comparing the P1
+** operand against the P1 operand on the OP_Init opcode at the beginning
+** of the program.  If the P1 values differ, then fall through and make
+** the P1 of this opcode equal to the P1 of OP_Init.  If P1 values are
+** the same then take the jump.
+**
+** For subprograms, there is a bitmask in the VdbeFrame that determines
+** whether or not the jump should be taken.  The bitmask is necessary
+** because the self-altering code trick does not work for recursive
+** triggers.
 */
 case OP_Once: {             /* jump */
+  u32 iAddr;                /* Address of this instruction */
  assert( p->aOp[0].opcode==OP_Init );
-  VdbeBranchTaken(p->aOp[0].p1==pOp->p1, 2);
-  if( p->aOp[0].p1==pOp->p1 ){
-    goto jump_to_p2;
+  if( p->pFrame ){
+    iAddr = (int)(pOp - p->aOp);
+    if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){
+      VdbeBranchTaken(1, 2);
+      goto jump_to_p2;
+    }
+    p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7);
  }else{
-    pOp->p1 = p->aOp[0].p1;
+    if( p->aOp[0].p1==pOp->p1 ){
+      VdbeBranchTaken(1, 2);
+      goto jump_to_p2;
+    }
  }
+  VdbeBranchTaken(0, 2);
+  pOp->p1 = p->aOp[0].p1;
  break;
 }

@@ -2661,8 +2677,13 @@ case OP_Column: {
      **    2. the length(X) function if X is a blob, and
      **    3. if the content length is zero.
      ** So we might as well use bogus content rather than reading
-      ** content from disk. */
-      static u8 aZero[8];  /* This is the bogus content */
+      ** content from disk. 
+      **
+      ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the
+      ** buffer passed to it, debugging function VdbeMemPrettyPrint() may
+      ** read up to 16. So 16 bytes of bogus content is supplied.
+      */
+      static u8 aZero[16];  /* This is the bogus content */
      sqlite3VdbeSerialGet(aZero, t, pDest);
    }else{
      rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
@@ -5869,7 +5890,8 @@ case OP_Program: {        /* jump */
    if( pProgram->nCsr==0 ) nMem++;
    nByte = ROUND8(sizeof(VdbeFrame))
              + nMem * sizeof(Mem)
-              + pProgram->nCsr * sizeof(VdbeCursor *);
+              + pProgram->nCsr * sizeof(VdbeCursor*)
+              + (pProgram->nOp + 7)/8;
    pFrame = sqlite3DbMallocZero(db, nByte);
    if( !pFrame ){
      goto no_mem;
@@ -5920,6 +5942,8 @@ case OP_Program: {        /* jump */
  p->nMem = pFrame->nChildMem;
  p->nCursor = (u16)pFrame->nChildCsr;
  p->apCsr = (VdbeCursor **)&aMem[p->nMem];
+  pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr];
+  memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
  p->aOp = aOp = pProgram->aOp;
  p->nOp = pProgram->nOp;
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
@@ -6949,7 +6973,11 @@ case OP_Init: {          /* jump */
      sqlite3_free(z);
    }else
 #endif
-    {
+    if( db->nVdbeExec>1 ){
+      char *z = sqlite3MPrintf(db, "-- %s", zTrace);
+      (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
+      sqlite3DbFree(db, z);
+    }else{
      (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
    }
  }
@@ -87,6 +87,7 @@ struct SubProgram {
  int nOp;                      /* Elements in aOp[] */
  int nMem;                     /* Number of memory cells required */
  int nCsr;                     /* Number of cursors required */
+  u8 *aOnce;                    /* Array of OP_Once flags */
  void *token;                  /* id that may be used to recursive triggers */
  SubProgram *pNext;            /* Next sub-program already visited */
 };
@@ -164,6 +164,7 @@ struct VdbeFrame {
  i64 *anExec;            /* Event counters from parent frame */
  Mem *aMem;              /* Array of memory cells for parent frame */
  VdbeCursor **apCsr;     /* Array of Vdbe cursors for parent frame */
+  u8 *aOnce;              /* Bitmask used by OP_Once */
  void *token;            /* Copy of SubProgram.token */
  i64 lastRowid;          /* Last insert rowid (sqlite3.lastRowid) */
  AuxData *pAuxData;      /* Linked list of auxdata allocations */
@@ -117,6 +117,12 @@ static int growOpArray(Vdbe *v, int nOp){
  UNUSED_PARAMETER(nOp);
 #endif

+  /* Ensure that the size of a VDBE does not grow too large */
+  if( nNew > p->db->aLimit[SQLITE_LIMIT_VDBE_OP] ){
+    sqlite3OomFault(p->db);
+    return SQLITE_NOMEM;
+  }
+
  assert( nOp<=(1024/sizeof(Op)) );
  assert( nNew>=(p->nOpAlloc+nOp) );
  pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
@@ -517,14 +517,16 @@ static LogEst estLog(LogEst N){
 ** value stored in its output register.
 */
 static void translateColumnToCopy(
-  Vdbe *v,            /* The VDBE containing code to translate */
+  Parse *pParse,      /* Parsing context */
  int iStart,         /* Translate from this opcode to the end */
  int iTabCur,        /* OP_Column/OP_Rowid references to this table */
  int iRegister,      /* The first column is in this register */
  int bIncrRowid      /* If non-zero, transform OP_rowid to OP_AddImm(1) */
 ){
+  Vdbe *v = pParse->pVdbe;
  VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
  int iEnd = sqlite3VdbeCurrentAddr(v);
+  if( pParse->db->mallocFailed ) return;
  for(; iStart<iEnd; iStart++, pOp++){
    if( pOp->p1!=iTabCur ) continue;
    if( pOp->opcode==OP_Column ){
@@ -802,7 +804,9 @@ static void constructAutomaticIndex(
  if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue);
  if( pTabItem->fg.viaCoroutine ){
    sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
-    translateColumnToCopy(v, addrTop, pLevel->iTabCur, pTabItem->regResult, 1);
+    testcase( pParse->db->mallocFailed );
+    translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
+                          pTabItem->regResult, 1);
    sqlite3VdbeGoto(v, addrTop);
    pTabItem->fg.viaCoroutine = 0;
  }else{
@@ -4920,8 +4924,9 @@ void sqlite3WhereEnd(WhereInfo *pWInfo){
    ** the co-routine into OP_Copy of result contained in a register.
    ** OP_Rowid becomes OP_Null.
    */
-    if( pTabItem->fg.viaCoroutine && !db->mallocFailed ){
-      translateColumnToCopy(v, pLevel->addrBody, pLevel->iTabCur,
+    if( pTabItem->fg.viaCoroutine ){
+      testcase( pParse->db->mallocFailed );
+      translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
                            pTabItem->regResult, 0);
      continue;
    }
@@ -29,7 +29,7 @@ source $testdir/tester.tcl
 # These tests also use "PRAGMA stats" which are only enabled for
 # debugging builds.
 #
-ifcapable {!debug || !analyze} {
+ifcapable {!debug || !analyze || !vtab} {
  finish_test
  return
 }
@@ -705,5 +705,12 @@ do_test autovacuum-9.5 {
  file size test.db
 } $::sqlite_pending_byte
 
+do_execsql_test autovacuum-10.1 {
+  DROP TABLE t1;
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t1 VALUES(25, randomblob(104));
+  REPLACE INTO t1 VALUES(25, randomblob(1117));
+  PRAGMA integrity_check;
+} {ok}

 finish_test
@@ -481,6 +481,16 @@ do_catchsql_test 9.3 {
  UPDATE t1 SET c=a*2 WHERE a=1;
 } {1 {CHECK constraint failed: c-check}}

-
+# Integrity check on a VIEW with columns.
+#
+db close
+db2 close
+forcedelete test.db
+sqlite3 db test.db
+do_execsql_test 10.1 {
+  CREATE TABLE t1(x);
+  CREATE VIEW v1(y) AS SELECT x FROM t1;
+  PRAGMA integrity_check;
+} {ok}

 finish_test
@@ -13,6 +13,7 @@

 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
+set testprefix collateB

 do_execsql_test collateB-1.1 {
  CREATE TABLE t1(a INTEGER PRIMARY KEY);
@@ -60,4 +61,17 @@ do_execsql_test collateB-1.17 {
  SELECT *,'|' FROM t1, t2, t3 WHERE b=x2 AND a=x1 AND 1=a;
 } {1 11 1 11 |}

+#-------------------------------------------------------------------------
+# Test an assert() failure that was occuring if an index were created
+# on a column explicitly declared "COLLATE binary".
+reset_db
+do_execsql_test 2.1 {
+  CREATE TABLE t4(a COLLATE binary);
+  CREATE INDEX i4 ON t4(a);
+  INSERT INTO t4 VALUES('one'), ('two'), ('three');
+  VACUUM;
+} 
+
+integrity_check 2.2
+
 finish_test
@@ -1,786 +0,0 @@
-/*
-** 2017-02-07
-**
-** 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 program implements an SQLite database self-verification utility.
-** Usage:
-** 
-**       dbselftest DATABASE ...
-**
-** This program reads the "selftest" table in DATABASE, in rowid order,
-** and runs each of the tests described there, reporting results at the
-** end.
-**
-** The intent of this program is to have a set of test database files that
-** can be run using future versions of SQLite in order to verify that
-** legacy database files continue to be readable.  In other words, the
-** intent is to confirm that there have been no breaking changes in the 
-** file format.  The program can also be used to verify that database files
-** are fully compatible between different architectures.
-**
-** The selftest table looks like this:
-**
-**     CREATE TABLE selftest (
-**       id INTEGER PRIMARY KEY,    -- Run tests in ascending order
-**       op TEXT,                   -- "test", "regexp", "print", etc.
-**       cmdtxt TEXT,               -- Usually the SQL to be run
-**       expected TEXT              -- Expected results
-**     );
-**
-*/
-#include <assert.h>
-#include <string.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include "sqlite3.h"
-
-static const char zHelp[] =
-  "Usage: dbselftest [OPTIONS] DBFILE ...\n"
-  "\n"
-  "    --init         Create the selftest table\n"
-  "    -q             Suppress most output.  Errors only\n"
-  "    -v             Show extra output\n"
-;
-
-
-/******************************************************************************
-** The following code from ext/misc/sha1.c
-**
-** Context for the SHA1 hash 
-*/
-typedef struct SHA1Context SHA1Context;
-struct SHA1Context {
-  unsigned int state[5];
-  unsigned int count[2];
-  unsigned char buffer[64];
-};
-
-
-#if __GNUC__ && (defined(__i386__) || defined(__x86_64__))
-/*
- * GCC by itself only generates left rotates.  Use right rotates if
- * possible to be kinder to dinky implementations with iterative rotate
- * instructions.
- */
-#define SHA_ROT(op, x, k) \
-        ({ unsigned int y; asm(op " %1,%0" : "=r" (y) : "I" (k), "0" (x)); y; })
-#define rol(x,k) SHA_ROT("roll", x, k)
-#define ror(x,k) SHA_ROT("rorl", x, k)
-
-#else
-/* Generic C equivalent */
-#define SHA_ROT(x,l,r) ((x) << (l) | (x) >> (r))
-#define rol(x,k) SHA_ROT(x,k,32-(k))
-#define ror(x,k) SHA_ROT(x,32-(k),k)
-#endif
-
-
-#define blk0le(i) (block[i] = (ror(block[i],8)&0xFF00FF00) \
-    |(rol(block[i],8)&0x00FF00FF))
-#define blk0be(i) block[i]
-#define blk(i) (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15] \
-    ^block[(i+2)&15]^block[i&15],1))
-
-/*
- * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
- *
- * Rl0() for little-endian and Rb0() for big-endian.  Endianness is
- * determined at run-time.
- */
-#define Rl0(v,w,x,y,z,i) \
-    z+=((w&(x^y))^y)+blk0le(i)+0x5A827999+rol(v,5);w=ror(w,2);
-#define Rb0(v,w,x,y,z,i) \
-    z+=((w&(x^y))^y)+blk0be(i)+0x5A827999+rol(v,5);w=ror(w,2);
-#define R1(v,w,x,y,z,i) \
-    z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=ror(w,2);
-#define R2(v,w,x,y,z,i) \
-    z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=ror(w,2);
-#define R3(v,w,x,y,z,i) \
-    z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=ror(w,2);
-#define R4(v,w,x,y,z,i) \
-    z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=ror(w,2);
-
-/*
- * Hash a single 512-bit block. This is the core of the algorithm.
- */
-void SHA1Transform(unsigned int state[5], const unsigned char buffer[64]){
-  unsigned int qq[5]; /* a, b, c, d, e; */
-  static int one = 1;
-  unsigned int block[16];
-  memcpy(block, buffer, 64);
-  memcpy(qq,state,5*sizeof(unsigned int));
-
-#define a qq[0]
-#define b qq[1]
-#define c qq[2]
-#define d qq[3]
-#define e qq[4]
-
-  /* Copy p->state[] to working vars */
-  /*
-  a = state[0];
-  b = state[1];
-  c = state[2];
-  d = state[3];
-  e = state[4];
-  */
-
-  /* 4 rounds of 20 operations each. Loop unrolled. */
-  if( 1 == *(unsigned char*)&one ){
-    Rl0(a,b,c,d,e, 0); Rl0(e,a,b,c,d, 1); Rl0(d,e,a,b,c, 2); Rl0(c,d,e,a,b, 3);
-    Rl0(b,c,d,e,a, 4); Rl0(a,b,c,d,e, 5); Rl0(e,a,b,c,d, 6); Rl0(d,e,a,b,c, 7);
-    Rl0(c,d,e,a,b, 8); Rl0(b,c,d,e,a, 9); Rl0(a,b,c,d,e,10); Rl0(e,a,b,c,d,11);
-    Rl0(d,e,a,b,c,12); Rl0(c,d,e,a,b,13); Rl0(b,c,d,e,a,14); Rl0(a,b,c,d,e,15);
-  }else{
-    Rb0(a,b,c,d,e, 0); Rb0(e,a,b,c,d, 1); Rb0(d,e,a,b,c, 2); Rb0(c,d,e,a,b, 3);
-    Rb0(b,c,d,e,a, 4); Rb0(a,b,c,d,e, 5); Rb0(e,a,b,c,d, 6); Rb0(d,e,a,b,c, 7);
-    Rb0(c,d,e,a,b, 8); Rb0(b,c,d,e,a, 9); Rb0(a,b,c,d,e,10); Rb0(e,a,b,c,d,11);
-    Rb0(d,e,a,b,c,12); Rb0(c,d,e,a,b,13); Rb0(b,c,d,e,a,14); Rb0(a,b,c,d,e,15);
-  }
-  R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
-  R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
-  R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
-  R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
-  R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
-  R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
-  R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
-  R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
-  R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
-  R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
-  R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
-  R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
-  R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
-  R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
-  R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
-  R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
-
-  /* Add the working vars back into context.state[] */
-  state[0] += a;
-  state[1] += b;
-  state[2] += c;
-  state[3] += d;
-  state[4] += e;
-
-#undef a
-#undef b
-#undef c
-#undef d
-#undef e
-}
-
-
-/* Initialize a SHA1 context */
-static void hash_init(SHA1Context *p){
-  /* SHA1 initialization constants */
-  p->state[0] = 0x67452301;
-  p->state[1] = 0xEFCDAB89;
-  p->state[2] = 0x98BADCFE;
-  p->state[3] = 0x10325476;
-  p->state[4] = 0xC3D2E1F0;
-  p->count[0] = p->count[1] = 0;
-}
-
-/* Add new content to the SHA1 hash */
-static void hash_step(
-  SHA1Context *p,                 /* Add content to this context */
-  const unsigned char *data,      /* Data to be added */
-  unsigned int len                /* Number of bytes in data */
-){
-  unsigned int i, j;
-
-  j = p->count[0];
-  if( (p->count[0] += len << 3) < j ){
-    p->count[1] += (len>>29)+1;
-  }
-  j = (j >> 3) & 63;
-  if( (j + len) > 63 ){
-    (void)memcpy(&p->buffer[j], data, (i = 64-j));
-    SHA1Transform(p->state, p->buffer);
-    for(; i + 63 < len; i += 64){
-      SHA1Transform(p->state, &data[i]);
-    }
-    j = 0;
-  }else{
-    i = 0;
-  }
-  (void)memcpy(&p->buffer[j], &data[i], len - i);
-}
-
-/* Compute a string using sqlite3_vsnprintf() and hash it */
-static void hash_step_vformat(
-  SHA1Context *p,                 /* Add content to this context */
-  const char *zFormat,
-  ...
-){
-  va_list ap;
-  int n;
-  char zBuf[50];
-  va_start(ap, zFormat);
-  sqlite3_vsnprintf(sizeof(zBuf),zBuf,zFormat,ap);
-  va_end(ap);
-  n = (int)strlen(zBuf);
-  hash_step(p, (unsigned char*)zBuf, n);
-}
-
-
-/* Add padding and compute the message digest.  Render the
-** message digest as lower-case hexadecimal and put it into
-** zOut[].  zOut[] must be at least 41 bytes long. */
-static void hash_finish(
-  SHA1Context *p,           /* The SHA1 context to finish and render */
-  char *zOut                /* Store hexadecimal hash here */
-){
-  unsigned int i;
-  unsigned char finalcount[8];
-  unsigned char digest[20];
-  static const char zEncode[] = "0123456789abcdef";
-
-  for (i = 0; i < 8; i++){
-    finalcount[i] = (unsigned char)((p->count[(i >= 4 ? 0 : 1)]
-       >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
-  }
-  hash_step(p, (const unsigned char *)"\200", 1);
-  while ((p->count[0] & 504) != 448){
-    hash_step(p, (const unsigned char *)"\0", 1);
-  }
-  hash_step(p, finalcount, 8);  /* Should cause a SHA1Transform() */
-  for (i = 0; i < 20; i++){
-    digest[i] = (unsigned char)((p->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-  }
-  for(i=0; i<20; i++){
-    zOut[i*2] = zEncode[(digest[i]>>4)&0xf];
-    zOut[i*2+1] = zEncode[digest[i] & 0xf];
-  }
-  zOut[i*2]= 0;
-}
-
-/*
-** Implementation of the sha1(X) function.
-**
-** Return a lower-case hexadecimal rendering of the SHA1 hash of the
-** argument X.  If X is a BLOB, it is hashed as is.  For all other
-** types of input, X is converted into a UTF-8 string and the string
-** is hash without the trailing 0x00 terminator.  The hash of a NULL
-** value is NULL.
-*/
-static void sha1Func(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  SHA1Context cx;
-  int eType = sqlite3_value_type(argv[0]);
-  int nByte = sqlite3_value_bytes(argv[0]);
-  char zOut[44];
-
-  assert( argc==1 );
-  if( eType==SQLITE_NULL ) return;
-  hash_init(&cx);
-  if( eType==SQLITE_BLOB ){
-    hash_step(&cx, sqlite3_value_blob(argv[0]), nByte);
-  }else{
-    hash_step(&cx, sqlite3_value_text(argv[0]), nByte);
-  }
-  hash_finish(&cx, zOut);
-  sqlite3_result_text(context, zOut, 40, SQLITE_TRANSIENT);
-}
-
-/*
-** Run a prepared statement and compute the SHA1 hash on the
-** result rows.
-*/
-static void sha1RunStatement(SHA1Context *pCtx, sqlite3_stmt *pStmt){
-  int nCol = sqlite3_column_count(pStmt);
-  const char *z = sqlite3_sql(pStmt);
-  int n = (int)strlen(z);
-
-  hash_step_vformat(pCtx,"S%d:",n);
-  hash_step(pCtx,(unsigned char*)z,n);
-
-  /* Compute a hash over the result of the query */
-  while( SQLITE_ROW==sqlite3_step(pStmt) ){
-    int i;
-    hash_step(pCtx,(const unsigned char*)"R",1);
-    for(i=0; i<nCol; i++){
-      switch( sqlite3_column_type(pStmt,i) ){
-        case SQLITE_NULL: {
-          hash_step(pCtx, (const unsigned char*)"N",1);
-          break;
-        }
-        case SQLITE_INTEGER: {
-          sqlite3_uint64 u;
-          int j;
-          unsigned char x[9];
-          sqlite3_int64 v = sqlite3_column_int64(pStmt,i);
-          memcpy(&u, &v, 8);
-          for(j=8; j>=1; j--){
-            x[j] = u & 0xff;
-            u >>= 8;
-          }
-          x[0] = 'I';
-          hash_step(pCtx, x, 9);
-          break;
-        }
-        case SQLITE_FLOAT: {
-          sqlite3_uint64 u;
-          int j;
-          unsigned char x[9];
-          double r = sqlite3_column_double(pStmt,i);
-          memcpy(&u, &r, 8);
-          for(j=8; j>=1; j--){
-            x[j] = u & 0xff;
-            u >>= 8;
-          }
-          x[0] = 'F';
-          hash_step(pCtx,x,9);
-          break;
-        }
-        case SQLITE_TEXT: {
-          int n2 = sqlite3_column_bytes(pStmt, i);
-          const unsigned char *z2 = sqlite3_column_text(pStmt, i);
-          hash_step_vformat(pCtx,"T%d:",n2);
-          hash_step(pCtx, z2, n2);
-          break;
-        }
-        case SQLITE_BLOB: {
-          int n2 = sqlite3_column_bytes(pStmt, i);
-          const unsigned char *z2 = sqlite3_column_blob(pStmt, i);
-          hash_step_vformat(pCtx,"B%d:",n2);
-          hash_step(pCtx, z2, n2);
-          break;
-        }
-      }
-    }
-  }
-}
-
-/*
-** Run one or more statements of SQL.  Compute a SHA1 hash of the output.
-*/
-static int sha1Exec(
-  sqlite3 *db,          /* Run against this database connection */
-  const char *zSql,     /* The SQL to be run */
-  char *zOut            /* Store the SHA1 hash as hexadecimal in this buffer */
-){
-  sqlite3_stmt *pStmt = 0;    /* A prepared statement */
-  int rc;                     /* Result of an API call */
-  SHA1Context cx;             /* The SHA1 hash context */
-
-  hash_init(&cx);
-  while( zSql[0] ){
-    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
-    if( rc ){
-      sqlite3_finalize(pStmt);
-      return rc;
-    }
-    sha1RunStatement(&cx, pStmt);
-    sqlite3_finalize(pStmt);
-  }
-  hash_finish(&cx, zOut);
-  return SQLITE_OK;
-}
-
-/*
-** Implementation of the sha1_query(SQL) function.
-**
-** This function compiles and runs the SQL statement(s) given in the
-** argument. The results are hashed using SHA1 and that hash is returned.
-**
-** The original SQL text is included as part of the hash.
-**
-** The hash is not just a concatenation of the outputs.  Each query
-** is delimited and each row and value within the query is delimited,
-** with all values being marked with their datatypes.
-*/
-static void sha1QueryFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
-  sqlite3_stmt *pStmt = 0;
-  int rc;
-  SHA1Context cx;
-  char zOut[44];
-
-  assert( argc==1 );
-  if( zSql==0 ) return;
-  hash_init(&cx);
-  while( zSql[0] ){
-    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zSql);
-    if( rc ){
-      char *zMsg = sqlite3_mprintf("error SQL statement [%s]: %s",
-                                   zSql, sqlite3_errmsg(db));
-      sqlite3_finalize(pStmt);
-      sqlite3_result_error(context, zMsg, -1);
-      sqlite3_free(zMsg);
-      return;
-    }
-    if( !sqlite3_stmt_readonly(pStmt) ){
-      char *zMsg = sqlite3_mprintf("non-query: [%s]", sqlite3_sql(pStmt));
-      sqlite3_finalize(pStmt);
-      sqlite3_result_error(context, zMsg, -1);
-      sqlite3_free(zMsg);
-      return;
-    }
-    sha1RunStatement(&cx, pStmt);
-    sqlite3_finalize(pStmt);
-  }
-  hash_finish(&cx, zOut);
-  sqlite3_result_text(context, zOut, 40, SQLITE_TRANSIENT);
-}
-/* End of ext/misc/sha1.c
-******************************************************************************/
-
-/* How much output to display */
-#define VOLUME_MIN          0
-#define VOLUME_OFF          0
-#define VOLUME_ERROR_ONLY   1
-#define VOLUME_LOW          2
-#define VOLUME_ECHO         3
-#define VOLUME_VERBOSE      4
-#define VOLUME_MAX          4
-
-/* A string accumulator
-*/
-typedef struct Str {
-  char *z;             /* Accumulated text */
-  int n;               /* Bytes of z[] used so far */
-  int nAlloc;          /* Bytes allocated for z[] */
-} Str;
-
-/* Append text to the Str object
-*/
-static void strAppend(Str *p, const char *z){
-  int n = (int)strlen(z);
-  if( p->n+n >= p->nAlloc ){
-    p->nAlloc += p->n+n + 100;
-    p->z = sqlite3_realloc(p->z, p->nAlloc);
-    if( z==0 ){
-      printf("Could not allocate %d bytes\n", p->nAlloc);
-      exit(1);
-    }
-  }
-  memcpy(p->z+p->n, z, n+1);
-  p->n += n;
-}
-
-/* This is an sqlite3_exec() callback that will capture all
-** output in a Str.
-**
-** Columns are separated by ",".  Rows are separated by "|".
-*/
-static int execCallback(void *pStr, int argc, char **argv, char **colv){
-  int i;
-  Str *p = (Str*)pStr;
-  if( p->n ) strAppend(p, "|");
-  for(i=0; i<argc; i++){
-    const char *z = (const char*)argv[i];
-    if( z==0 ) z = "NULL";
-    if( i>0 ) strAppend(p, ",");
-    strAppend(p, z);
-  }
-  return 0;
-}
-
-/*
-** Run an SQL statement constructing using sqlite3_vmprintf().
-** Return the number of errors.
-*/
-static int runSql(sqlite3 *db, const char *zFormat, ...){
-  char *zSql;
-  char *zErr = 0;
-  int rc;
-  int nErr = 0;
-  va_list ap;
-
-  va_start(ap, zFormat);
-  zSql = sqlite3_vmprintf(zFormat, ap);
-  va_end(ap);
-  if( zSql==0 ){
-    printf("Out of memory\n");
-    exit(1);
-  }
-  rc = sqlite3_exec(db, zSql, 0, 0, &zErr);
-  if( rc || zErr ){
-    printf("SQL error in [%s]: code=%d: %s\n", zSql, rc, zErr);
-    nErr++;
-  }
-  sqlite3_free(zSql);
-  return nErr;
-}
-
-/*
-** Generate a prepared statement using a formatted string.
-*/
-static sqlite3_stmt *prepareSql(sqlite3 *db, const char *zFormat, ...){
-  char *zSql;
-  int rc;
-  sqlite3_stmt *pStmt = 0;
-  va_list ap;
-
-  va_start(ap, zFormat);
-  zSql = sqlite3_vmprintf(zFormat, ap);
-  va_end(ap);
-  if( zSql==0 ){
-    printf("Out of memory\n");
-    exit(1);
-  }
-  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
-  if( rc ){
-    printf("SQL error in [%s]: code=%d: %s\n", zSql, rc, sqlite3_errmsg(db));
-    sqlite3_finalize(pStmt);
-    pStmt = 0;
-  }
-  sqlite3_free(zSql);
-  return pStmt;
-}
-
-/*
-** Construct the standard selftest configuration for the database.
-*/
-static int buildSelftestTable(sqlite3 *db){
-  int rc;
-  sqlite3_stmt *pStmt;
-  int tno = 110;
-  char *zSql;
-  char zHash[50];
-
-  rc = runSql(db,
-     "CREATE TABLE IF NOT EXISTS selftest(\n"
-     "  tno INTEGER PRIMARY KEY,  -- test number\n"
-     "  op TEXT,                  -- what kind of test\n"
-     "  sql TEXT,                 -- SQL text for the test\n"
-     "  ans TEXT                  -- expected answer\n"
-     ");"
-     "INSERT INTO selftest"
-     " VALUES(100,'memo','Hashes generated using --init',NULL);"
-  );
-  if( rc ) return 1;
-  tno = 110;
-  zSql = "SELECT type,name,tbl_name,sql FROM sqlite_master ORDER BY name";
-  sha1Exec(db, zSql, zHash);
-  rc = runSql(db, 
-      "INSERT INTO selftest(tno,op,sql,ans)"
-      " VALUES(%d,'sha1',%Q,%Q)", tno, zSql, zHash);
-  tno += 10;
-  pStmt = prepareSql(db,
-    "SELECT lower(name) FROM sqlite_master"
-    " WHERE type='table' AND sql NOT GLOB 'CREATE VIRTUAL*'"
-    "   AND name<>'selftest'"
-    " ORDER BY 1");
-  if( pStmt==0 ) return 1;
-  while( SQLITE_ROW==sqlite3_step(pStmt) ){
-    zSql = sqlite3_mprintf("SELECT * FROM \"%w\" NOT INDEXED",
-                            sqlite3_column_text(pStmt, 0));
-    if( zSql==0 ){
-      printf("Of of memory\n");
-      exit(1);
-    }
-    sha1Exec(db, zSql, zHash);
-    rc = runSql(db,
-      "INSERT INTO selftest(tno,op,sql,ans)"
-      " VALUES(%d,'sha1',%Q,%Q)", tno, zSql, zHash);
-    tno += 10;
-    sqlite3_free(zSql);
-    if( rc ) break;
-  }
-  sqlite3_finalize(pStmt);
-  if( rc ) return 1;
-  rc = runSql(db,
-     "INSERT INTO selftest(tno,op,sql,ans)"
-     " VALUES(%d,'run','PRAGMA integrity_check','ok');", tno);
-  if( rc ) return 1;
-  return rc;
-}
-
-/*
-** Return true if the named table exists
-*/
-static int tableExists(sqlite3 *db, const char *zTab){
-  return sqlite3_table_column_metadata(db, "main", zTab, 0, 0, 0, 0, 0, 0)
-            == SQLITE_OK;
-}
-
-/*
-** Default selftest table content, for use when there is no selftest table
-*/
-static char *azDefaultTest[] = {
-   0, 0, 0, 0,
-   "0", "memo", "Missing SELFTEST table - default checks only", "",
-   "1", "run", "PRAGMA integrity_check", "ok"
-};
-
-int main(int argc, char **argv){
-  int eVolume = VOLUME_LOW;    /* How much output to display */
-  const char **azDb = 0;       /* Name of the database file */
-  int nDb = 0;                 /* Number of database files to check */
-  int doInit = 0;              /* True if --init is present */
-  sqlite3 *db = 0;             /* Open database connection */
-  int rc;                      /* Return code from API calls */
-  char *zErrMsg = 0;           /* An error message return */
-  char **azTest;               /* Content of the selftest table */
-  int nRow = 0, nCol = 0;      /* Rows and columns in azTest[] */
-  int i;                       /* Loop counter */
-  int nErr = 0;                /* Number of errors */
-  int iDb;                     /* Loop counter for databases */
-  Str str;                     /* Result accumulator */
-  int nTest = 0;               /* Number of tests run */
-
-  for(i=1; i<argc; i++){
-    const char *z = argv[i];
-    if( z[0]=='-' ){
-      if( z[1]=='-' ) z++;
-      if( strcmp(z, "-help")==0 ){
-        printf("%s", zHelp);
-        return 0;
-      }else
-      if( strcmp(z, "-init")==0 ){
-        doInit = 1;
-      }else
-      if( strcmp(z, "-a")==0 ){
-        if( eVolume>VOLUME_MIN) eVolume--;
-      }else
-      if( strcmp(z, "-v")==0 ){
-        if( eVolume<VOLUME_MAX) eVolume++;
-      }else
-      {
-        printf("unknown option: \"%s\"\nUse --help for more information\n",
-               argv[i]);
-        return 1;
-      }
-    }else{
-      nDb++;
-      azDb = sqlite3_realloc(azDb, nDb*sizeof(azDb[0]));
-      if( azDb==0 ){
-        printf("out of memory\n");
-        exit(1);
-      }
-      azDb[nDb-1] = argv[i];
-    }
-  }
-  if( nDb==0 ){
-    printf("No databases specified.  Use --help for more info\n");
-    return 1;
-  }
-  if( eVolume>=VOLUME_LOW ){
-    printf("SQLite %s\n", sqlite3_sourceid());
-  }
-  memset(&str, 0, sizeof(str));
-  strAppend(&str, "\n");
-  for(iDb=0; iDb<nDb; iDb++, sqlite3_close(db)){
-    rc = sqlite3_open_v2(azDb[iDb], &db, 
-          doInit ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY, 0);
-    if( rc ){
-      printf("Cannot open \"%s\": %s\n", azDb[iDb], sqlite3_errmsg(db));
-      return 1;
-    }
-    rc = sqlite3_create_function(db, "sha1", 1, SQLITE_UTF8, 0,
-                                 sha1Func, 0, 0);
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_create_function(db, "sha1_query", 1, SQLITE_UTF8, 0,
-                                   sha1QueryFunc, 0, 0);
-    }
-    if( rc ){
-      printf("Initialization error: %s\n", sqlite3_errmsg(db));
-      sqlite3_close(db);
-      return 1;
-    }
-    if( doInit && !tableExists(db, "selftest") ){
-       buildSelftestTable(db);
-    }
-    if( !tableExists(db, "selftest") ){
-      azTest = azDefaultTest;
-      nCol = 4;
-      nRow = 2;
-    }else{
-      rc = sqlite3_get_table(db, 
-          "SELECT tno,op,sql,ans FROM selftest ORDER BY tno",
-          &azTest, &nRow, &nCol, &zErrMsg);
-      if( rc || zErrMsg ){
-        printf("Error querying selftest: %s\n", zErrMsg);
-        sqlite3_free_table(azTest);
-        continue;
-      }
-    }
-    for(i=1; i<=nRow; i++){
-      int tno = atoi(azTest[i*nCol]);
-      const char *zOp = azTest[i*nCol+1];
-      const char *zSql = azTest[i*nCol+2];
-      const char *zAns = azTest[i*nCol+3];
-  
-      if( eVolume>=VOLUME_ECHO ){
-        char *zQuote = sqlite3_mprintf("%q", zSql);
-        printf("%d: %s %s\n", tno, zOp, zSql);
-        sqlite3_free(zQuote);
-      }
-      if( strcmp(zOp,"memo")==0 ){
-        if( eVolume>=VOLUME_LOW ){
-          printf("%s: %s\n", azDb[iDb], zSql);
-        }
-      }else
-      if( strcmp(zOp,"sha1")==0 ){
-        char zOut[44];
-        rc = sha1Exec(db, zSql, zOut);
-        nTest++;
-        if( eVolume>=VOLUME_VERBOSE ){
-          printf("Result: %s\n", zOut);
-        }
-        if( rc ){
-          nErr++;
-          if( eVolume>=VOLUME_ERROR_ONLY ){
-            printf("%d: error-code-%d: %s\n", tno, rc, sqlite3_errmsg(db));
-          }
-        }else if( strcmp(zAns,zOut)!=0 ){
-          nErr++;
-          if( eVolume>=VOLUME_ERROR_ONLY ){
-            printf("%d: Expected: [%s]\n", tno, zAns);
-            printf("%d:      Got: [%s]\n", tno, zOut);
-          }
-        }
-      }else
-      if( strcmp(zOp,"run")==0 ){
-        str.n = 0;
-        str.z[0] = 0;
-        zErrMsg = 0;
-        rc = sqlite3_exec(db, zSql, execCallback, &str, &zErrMsg);
-        nTest++;
-        if( eVolume>=VOLUME_VERBOSE ){
-          printf("Result: %s\n", str.z);
-        }
-        if( rc || zErrMsg ){
-          nErr++;
-          if( eVolume>=VOLUME_ERROR_ONLY ){
-            printf("%d: error-code-%d: %s\n", tno, rc, zErrMsg);
-          }
-          sqlite3_free(zErrMsg);
-        }else if( strcmp(zAns,str.z)!=0 ){
-          nErr++;
-          if( eVolume>=VOLUME_ERROR_ONLY ){
-            printf("%d: Expected: [%s]\n", tno, zAns);
-            printf("%d:      Got: [%s]\n", tno, str.z);
-          }
-        }
-      }else
-      {
-        printf("Unknown operation \"%s\" on selftest line %d\n", zOp, tno);
-        return 1;
-      }
-    }
-    if( azTest!=azDefaultTest ) sqlite3_free_table(azTest);
-  }
-  if( eVolume>=VOLUME_LOW || (nErr>0 && eVolume>=VOLUME_ERROR_ONLY) ){
-    printf("%d errors out of %d tests on %d databases\n", nErr, nTest, nDb);
-  }
-  return nErr;
-}
@@ -805,6 +805,7 @@ static void showHelp(void){
 "  --load-db ARGS...    Load template databases from files into SOURCE_DB\n"
 "  -m TEXT              Add a description to the database\n"
 "  --native-vfs         Use the native VFS for initially empty database files\n"
+"  --native-malloc      Turn off MEMSYS3/5 and Lookaside\n"
 "  --oss-fuzz           Enable OSS-FUZZ testing\n"
 "  --prng-seed N        Seed value for the PRGN inside of SQLite\n"
 "  --rebuild            Rebuild and vacuum the database file\n"
@@ -851,6 +852,7 @@ int main(int argc, char **argv){
  void *pHeap = 0;             /* Heap for use by SQLite */
  int ossFuzz = 0;             /* enable OSS-FUZZ testing */
  int ossFuzzThisDb = 0;       /* ossFuzz value for this particular database */
+  int nativeMalloc = 0;        /* Turn off MEMSYS3/5 and lookaside if true */
  sqlite3_vfs *pDfltVfs;       /* The default VFS */

  iBegin = timeOfDay();
@@ -911,6 +913,9 @@ int main(int argc, char **argv){
        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
        zMsg = argv[++i];
      }else
+      if( strcmp(z,"native-malloc")==0 ){
+        nativeMalloc = 1;
+      }else
      if( strcmp(z,"native-vfs")==0 ){
        nativeFlag = 1;
      }else
@@ -972,7 +977,7 @@ int main(int argc, char **argv){
  /* Process each source database separately */
  for(iSrcDb=0; iSrcDb<nSrcDb; iSrcDb++){
    rc = sqlite3_open_v2(azSrcDb[iSrcDb], &db,
-                         SQLITE_OPEN_READONLY, pDfltVfs->zName);
+                         SQLITE_OPEN_READWRITE, pDfltVfs->zName);
    if( rc ){
      fatalError("cannot open source database %s - %s",
      azSrcDb[iSrcDb], sqlite3_errmsg(db));
@@ -1013,7 +1018,7 @@ int main(int argc, char **argv){
          ossFuzzThisDb = sqlite3_column_int(pStmt,1);
          if( verboseFlag ) printf("Config: oss-fuzz=%d\n", ossFuzzThisDb);
        }
-        if( strcmp(zName, "limit-mem")==0 ){
+        if( strcmp(zName, "limit-mem")==0 && !nativeMalloc ){
 #if !defined(SQLITE_ENABLE_MEMSYS3) && !defined(SQLITE_ENABLE_MEMSYS5)
          fatalError("the limit-mem option requires -DSQLITE_ENABLE_MEMSYS5"
                     " or _MEMSYS3");
@@ -1047,6 +1052,8 @@ int main(int argc, char **argv){
      sqlite3_close(db);
      return 0;
    }
+    rc = sqlite3_exec(db, "PRAGMA query_only=1;", 0, 0, 0);
+    if( rc ) fatalError("cannot set database to query-only");
    if( zExpDb!=0 || zExpSql!=0 ){
      sqlite3_create_function(db, "writefile", 2, SQLITE_UTF8, 0,
                              writefileFunc, 0, 0);
@@ -1141,14 +1148,19 @@ int main(int argc, char **argv){
    }

    /* Limit available memory, if requested */
-    if( nMemThisDb>0 ){
-      sqlite3_shutdown();
+    sqlite3_shutdown();
+    if( nMemThisDb>0 && !nativeMalloc ){
      pHeap = realloc(pHeap, nMemThisDb);
      if( pHeap==0 ){
        fatalError("failed to allocate %d bytes of heap memory", nMem);
      }
      sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMemThisDb, 128);
    }
+
+    /* Disable lookaside with the --native-malloc option */
+    if( nativeMalloc ){
+      sqlite3_config(SQLITE_CONFIG_LOOKASIDE, 0, 0);
+    }
  
    /* Reset the in-memory virtual filesystem */
    formatVfs();
@@ -1205,9 +1217,13 @@ int main(int argc, char **argv){
            runSql(db, (char*)pSql->a, runFlags);
          }while( timeoutTest );
          setAlarm(0);
+          sqlite3_exec(db, "PRAGMA temp_store_directory=''", 0, 0, 0);
          sqlite3_close(db);
        }
-        if( sqlite3_memory_used()>0 ) fatalError("memory leak");
+        if( sqlite3_memory_used()>0 ){
+           fatalError("memory leak: %lld bytes outstanding",
+                      sqlite3_memory_used());
+        }
        reformatVfs();
        nTest++;
        g.zTestName[0] = 0;
@@ -0,0 +1,130 @@
+# 2017-03-22
+#
+# 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 tests for json_patch(A,B) SQL function.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !json1 {
+  finish_test
+  return
+}
+
+# This is the example from pages 2 and 3 of RFC-7396
+do_execsql_test json104-100 {
+  SELECT json_patch('{
+       "a": "b",
+       "c": {
+         "d": "e",
+         "f": "g"
+       }
+     }','{
+       "a":"z",
+       "c": {
+         "f": null
+       }
+     }');
+} {{{"a":"z","c":{"d":"e"}}}}
+
+
+# This is the example from pages 4 and 5 of RFC-7396 
+do_execsql_test json104-110 {
+  SELECT json_patch('{
+       "title": "Goodbye!",
+       "author" : {
+         "givenName" : "John",
+         "familyName" : "Doe"
+       },
+       "tags":[ "example", "sample" ],
+       "content": "This will be unchanged"
+     }','{
+       "title": "Hello!",
+       "phoneNumber": "+01-123-456-7890",
+       "author": {
+         "familyName": null
+       },
+       "tags": [ "example" ]
+     }');
+} {{{"title":"Hello!","author":{"givenName":"John"},"tags":["example"],"content":"This will be unchanged","phoneNumber":"+01-123-456-7890"}}}
+
+do_execsql_test json104-200 {
+  SELECT json_patch('[1,2,3]','{"x":null}');
+} {{{}}}
+do_execsql_test json104-210 {
+  SELECT json_patch('[1,2,3]','{"x":null,"y":1,"z":null}');
+} {{{"y":1}}}
+do_execsql_test json104-220 {
+  SELECT json_patch('{}','{"a":{"bb":{"ccc":null}}}');
+} {{{"a":{"bb":{}}}}}
+do_execsql_test json104-221 {
+  SELECT json_patch('{}','{"a":{"bb":{"ccc":[1,null,3]}}}');
+} {{{"a":{"bb":{"ccc":[1,null,3]}}}}}
+do_execsql_test json104-222 {
+  SELECT json_patch('{}','{"a":{"bb":{"ccc":[1,{"dddd":null},3]}}}');
+} {{{"a":{"bb":{"ccc":[1,{"dddd":null},3]}}}}}
+
+# Example test cases at the end of the RFC-7396 document
+do_execsql_test json104-300 {
+  SELECT json_patch('{"a":"b"}','{"a":"c"}');
+} {{{"a":"c"}}}
+do_execsql_test json104-300a {
+  SELECT coalesce(json_patch(null,'{"a":"c"}'), 'real-null');
+} {{real-null}}
+do_execsql_test json104-301 {
+  SELECT json_patch('{"a":"b"}','{"b":"c"}');
+} {{{"a":"b","b":"c"}}}
+do_execsql_test json104-302 {
+  SELECT json_patch('{"a":"b"}','{"a":null}');
+} {{{}}}
+do_execsql_test json104-303 {
+  SELECT json_patch('{"a":"b","b":"c"}','{"a":null}');
+} {{{"b":"c"}}}
+do_execsql_test json104-304 {
+  SELECT json_patch('{"a":["b"]}','{"a":"c"}');
+} {{{"a":"c"}}}
+do_execsql_test json104-305 {
+  SELECT json_patch('{"a":"c"}','{"a":["b"]}');
+} {{{"a":["b"]}}}
+do_execsql_test json104-306 {
+  SELECT json_patch('{"a":{"b":"c"}}','{"a":{"b":"d","c":null}}');
+} {{{"a":{"b":"d"}}}}
+do_execsql_test json104-307 {
+  SELECT json_patch('{"a":[{"b":"c"}]}','{"a":[1]}');
+} {{{"a":[1]}}}
+do_execsql_test json104-308 {
+  SELECT json_patch('["a","b"]','["c","d"]');
+} {{["c","d"]}}
+do_execsql_test json104-309 {
+  SELECT json_patch('{"a":"b"}','["c"]');
+} {{["c"]}}
+do_execsql_test json104-310 {
+  SELECT json_patch('{"a":"foo"}','null');
+} {{null}}
+do_execsql_test json104-310a {
+  SELECT coalesce(json_patch('{"a":"foo"}',null), 'real-null');
+} {{real-null}}
+do_execsql_test json104-311 {
+  SELECT json_patch('{"a":"foo"}','"bar"');
+} {{"bar"}}
+do_execsql_test json104-312 {
+  SELECT json_patch('{"e":null}','{"a":1}');
+} {{{"e":null,"a":1}}}
+do_execsql_test json104-313 {
+  SELECT json_patch('[1,2]','{"a":"b","c":null}');
+} {{{"a":"b"}}}
+do_execsql_test json104-314 {
+  SELECT json_patch('{}','{"a":{"bb":{"ccc":null}}}');
+} {{{"a":{"bb":{}}}}}
+
+
+
+finish_test
@@ -0,0 +1,48 @@
+# 2017 March 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.
+#
+#***********************************************************************
+# Further OOM tests.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+set testprefix mallocM
+
+sqlite3_db_config_lookaside db 0 0 0
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(x);
+}
+do_faultsim_test 1 -faults oom* -body {
+  execsql {
+    SELECT 'abc' FROM ( SELECT 'xyz' FROM t1 WHERE (SELECT 1) )
+  }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
+do_execsql_test 2.0.1 { SELECT instr(x'', x'') }         {1}
+do_execsql_test 2.0.2 { SELECT instr(x'12345678', x'') } {1}
+do_execsql_test 2.0.3 { SELECT instr(x'', x'1234') }     {0}
+
+do_faultsim_test 2.1 -faults oom* -body {
+  execsql { SELECT instr (x'00', zeroblob(1)) }
+} -test {
+  faultsim_test_result {0 1}
+}
+
+do_faultsim_test 2.2 -faults oom* -body {
+  execsql { SELECT instr (zeroblob(1), x'00') }
+} -test {
+  faultsim_test_result {0 1}
+}
+
+finish_test
@@ -4,14 +4,69 @@
 */
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <string.h>
 #include "sqlite3.h"

+/* Global debugging settings.  OSS-Fuzz will have all debugging turned
+** off.  But if LLVMFuzzerTestOneInput() is called interactively from
+** the ossshell utility program, then these flags might be set.
+*/
+static unsigned mDebug = 0;
+#define FUZZ_SQL_TRACE       0x0001   /* Set an sqlite3_trace() callback */
+#define FUZZ_SHOW_MAX_DELAY  0x0002   /* Show maximum progress callback delay */
+#define FUZZ_SHOW_ERRORS     0x0004   /* Print error messages from SQLite */
+
+/* The ossshell utility program invokes this interface to see the
+** debugging flags.  Unused by OSS-Fuzz.
+*/
+void ossfuzz_set_debug_flags(unsigned x){
+  mDebug = x;
+}
+
+/* Return the current real-world time in milliseconds since the
+** Julian epoch (-4714-11-24).
+*/
+static sqlite3_int64 timeOfDay(void){
+  static sqlite3_vfs *clockVfs = 0;
+  sqlite3_int64 t;
+  if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
+  if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
+    clockVfs->xCurrentTimeInt64(clockVfs, &t);
+  }else{
+    double r;
+    clockVfs->xCurrentTime(clockVfs, &r);
+    t = (sqlite3_int64)(r*86400000.0);
+  }
+  return t;
+}
+
+/* An instance of the following object is passed by pointer as the
+** client data to various callbacks.
+*/
+typedef struct FuzzCtx {
+  sqlite3 *db;               /* The database connection */
+  sqlite3_int64 iCutoffTime; /* Stop processing at this time. */
+  sqlite3_int64 iLastCb;     /* Time recorded for previous progress callback */
+  sqlite3_int64 mxInterval;  /* Longest interval between two progress calls */
+  unsigned nCb;              /* Number of progress callbacks */
+} FuzzCtx;
+
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
 /*
-** Progress handler callback
+** Progress handler callback.
+**
+** The argument is the cutoff-time after which all processing should
+** stop.  So return non-zero if the cut-off time is exceeded.
 */
-static int progress_handler(void *pReturn) {
-  return *(int*)pReturn;
+static int progress_handler(void *pClientData) {
+  FuzzCtx *p = (FuzzCtx*)pClientData;
+  sqlite3_int64 iNow = timeOfDay();
+  int rc = iNow>=p->iCutoffTime;
+  sqlite3_int64 iDiff = iNow - p->iLastCb;
+  if( iDiff > p->mxInterval ) p->mxInterval = iDiff;
+  p->nCb++;
+  return rc;
 }
 #endif

@@ -31,14 +86,14 @@ static int exec_handler(void *pCnt, int argc, char **argv, char **namev){
 ** fuzzed input.
 */
 int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  int progressArg = 0;     /* 1 causes progress handler abort */
  int execCnt = 0;         /* Abort row callback when count reaches zero */
  char *zErrMsg = 0;       /* Error message returned by sqlite_exec() */
-  sqlite3 *db;             /* The database connection */
  uint8_t uSelector;       /* First byte of input data[] */
  int rc;                  /* Return code from various interfaces */
  char *zSql;              /* Zero-terminated copy of data[] */
+  FuzzCtx cx;              /* Fuzzing context */

+  memset(&cx, 0, sizeof(cx));
  if( size<3 ) return 0;   /* Early out if unsufficient data */

  /* Extract the selector byte from the beginning of the input.  But only
@@ -51,22 +106,26 @@ int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  }

  /* Open the database connection.  Only use an in-memory database. */
-  rc = sqlite3_open_v2("fuzz.db", &db,
+  rc = sqlite3_open_v2("fuzz.db", &cx.db,
           SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY, 0);
  if( rc ) return 0;

 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-  /* Bit 0 of the selector enables progress callbacks.  Bit 1 is the
-  ** return code from progress callbacks */
-  if( uSelector & 1 ){
-    sqlite3_progress_handler(db, 4, progress_handler, (void*)&progressArg);
-  }
+  /* Invoke the progress handler frequently to check to see if we
+  ** are taking too long.  The progress handler will return true
+  ** (which will block further processing) if more than 10 seconds have
+  ** elapsed since the start of the test.
+  */
+  cx.iLastCb = timeOfDay();
+  cx.iCutoffTime = cx.iLastCb + 10000;  /* Now + 10 seconds */
+  sqlite3_progress_handler(cx.db, 10, progress_handler, (void*)&cx);
 #endif
-  uSelector >>= 1;
-  progressArg = uSelector & 1;  uSelector >>= 1;

-  /* Bit 2 of the selector enables foreign key constraints */
-  sqlite3_db_config(db, SQLITE_DBCONFIG_ENABLE_FKEY, uSelector&1, &rc);
+  /* Set a limit on the maximum size of a prepared statement */
+  sqlite3_limit(cx.db, SQLITE_LIMIT_VDBE_OP, 25000);
+
+  /* Bit 1 of the selector enables foreign key constraints */
+  sqlite3_db_config(cx.db, SQLITE_DBCONFIG_ENABLE_FKEY, uSelector&1, &rc);
  uSelector >>= 1;

  /* Remaining bits of the selector determine a limit on the number of
@@ -76,11 +135,22 @@ int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
  /* Run the SQL.  The sqlite_exec() interface expects a zero-terminated
  ** string, so make a copy. */
  zSql = sqlite3_mprintf("%.*s", (int)size, data);
-  sqlite3_exec(db, zSql, exec_handler, (void*)&execCnt, &zErrMsg);
+  sqlite3_exec(cx.db, zSql, exec_handler, (void*)&execCnt, &zErrMsg);
+
+  /* Show any errors */
+  if( (mDebug & FUZZ_SHOW_ERRORS)!=0 && zErrMsg ){
+    printf("Error: %s\n", zErrMsg);
+  }

  /* Cleanup and return */
  sqlite3_free(zErrMsg);
  sqlite3_free(zSql);
-  sqlite3_close(db);
+  sqlite3_exec(cx.db, "PRAGMA temp_store_directory=''", 0, 0, 0);
+  sqlite3_close(cx.db);
+
+  if( mDebug & FUZZ_SHOW_MAX_DELAY ){
+    printf("Progress callback count....... %d\n", cx.nCb);
+    printf("Max time between callbacks.... %d ms\n", (int)cx.mxInterval);
+  }
  return 0;
 }
@@ -9,6 +9,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include "sqlite3.h"

 /*
@@ -16,6 +17,13 @@
 */
 int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);

+/* Must match equivalent #defines in ossfuzz.c */
+#define FUZZ_SQL_TRACE       0x0001   /* Set an sqlite3_trace() callback */
+#define FUZZ_SHOW_MAX_DELAY  0x0002   /* Show maximum progress callback delay */
+#define FUZZ_SHOW_ERRORS     0x0004   /* Show SQL errors */
+extern void ossfuzz_set_debug_flags(unsigned);
+
+

 /*
 ** Read files named on the command-line and invoke the fuzzer for
@@ -27,9 +35,32 @@ int main(int argc, char **argv){
  int nErr = 0;
  uint8_t *zBuf = 0;
  size_t sz;
+  unsigned mDebug = 0;

  for(i=1; i<argc; i++){
    const char *zFilename = argv[i];
+    if( zFilename[0]=='-' ){
+      if( zFilename[1]=='-' ) zFilename++;
+      if( strcmp(zFilename, "-show-errors")==0 ){
+        mDebug |= FUZZ_SHOW_ERRORS;
+        ossfuzz_set_debug_flags(mDebug);
+      }else
+      if( strcmp(zFilename, "-show-max-delay")==0 ){
+        mDebug |= FUZZ_SHOW_MAX_DELAY;
+        ossfuzz_set_debug_flags(mDebug);
+      }else
+      if( strcmp(zFilename, "-sql-trace")==0 ){
+        mDebug |= FUZZ_SQL_TRACE;
+        ossfuzz_set_debug_flags(mDebug);
+      }else
+      {
+        printf("unknown option \"%s\"\n", argv[i]);
+        printf("should be one of: --show-errors --show-max-delay"
+               " --sql-trace\n");
+        exit(1);
+      }
+      continue;
+    }
    in = fopen(zFilename, "rb");
    if( in==0 ){
      fprintf(stderr, "cannot open \"%s\"\n", zFilename);
@@ -50,8 +81,10 @@ int main(int argc, char **argv){
      nErr++;
    }else{
      printf("%s... ", zFilename);
+      if( mDebug ) printf("\n");
      fflush(stdout);
      (void)LLVMFuzzerTestOneInput(zBuf, sz);
+      if( mDebug ) printf("%s: ", zFilename);
      printf("ok\n");
    }
    fclose(in);
@@ -247,22 +247,24 @@ test_suite "threads" -prefix "" -description {
 test_suite "fts3" -prefix "" -description {
  All FTS3 tests except fts3rnd.test.
 } -files {
-  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
-  fts3atoken.test fts3b.test fts3c.test fts3cov.test fts3d.test
-  fts3defer.test fts3defer2.test fts3e.test fts3expr.test fts3expr2.test 
-  fts3expr3.test
-  fts3near.test fts3query.test fts3shared.test fts3snippet.test 
-  fts3sort.test
-  fts3fault.test fts3malloc.test fts3matchinfo.test
-  fts3aux1.test fts3comp1.test fts3auto.test
-  fts4aa.test fts4content.test
-  fts3conf.test fts3prefix.test fts3fault2.test fts3corrupt.test
-  fts3corrupt2.test fts3first.test fts4langid.test fts4merge.test
-  fts4check.test fts4unicode.test fts4noti.test
-  fts3varint.test
-  fts4growth.test fts4growth2.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 fts3atoken.test
+  fts3auto.test fts3aux1.test fts3aux2.test fts3b.test
+  fts3comp1.test fts3conf.test fts3corrupt2.test fts3corrupt.test
+  fts3cov.test fts3c.test fts3defer2.test fts3defer3.test
+  fts3defer.test fts3drop.test fts3d.test fts3e.test
+  fts3expr2.test fts3expr3.test fts3expr4.test fts3expr5.test
+  fts3expr.test fts3fault2.test fts3fault.test fts3first.test
+  fts3join.test fts3malloc.test fts3matchinfo.test fts3near.test
+  fts3offsets.test fts3prefix2.test fts3prefix.test fts3query.test
+  fts3shared.test fts3snippet.test fts3sort.test fts3tok1.test
+  fts3tok_err.test fts3varint.test fts4aa.test fts4check.test
+  fts4content.test fts4docid.test fts4growth2.test fts4growth.test
+  fts4incr.test fts4langid.test fts4lastrowid.test fts4merge2.test
+  fts4merge4.test fts4merge.test fts4noti.test fts4onepass.test 
+  fts4opt.test fts4unicode.test
 }

 test_suite "fts5" -prefix "" -description {
@@ -755,6 +755,9 @@ INSERT INTO t3 VALUES(5,'hello');
 INSERT INTO t3 VALUES(6,X'807f');
 COMMIT;}}

+
+ifcapable vtab {
+
 # The --preserve-rowids option to .dump
 #
 do_test shell1-4.1.1 {
@@ -868,6 +871,23 @@ INSERT INTO t1 VALUES(12,'',99);
 INSERT INTO t1 VALUES(23,1,X'b0b1b2');
 COMMIT;}}

+} else {
+
+do_test shell1-4.1.6 {
+  db close
+  forcedelete test2.db
+  sqlite3 db test2.db
+  db eval {
+    CREATE TABLE t1(x INTEGER PRIMARY KEY, y);
+    INSERT INTO t1 VALUES(1,null), (2,''), (3,1),
+                         (4,2.25), (5,'hello'), (6,x'807f');
+  }
+  catchcmd test2.db {.dump --preserve-rowids}
+} {1 {The --preserve-rowids option is not compatible with SQLITE_OMIT_VIRTUALTABLE}}
+
+}
+
+
 # Test the output of ".mode insert"
 #
 do_test shell1-4.2.1 {
@@ -0,0 +1,160 @@
+# 2017 March 16
+#
+# 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.
+#
+# Specificly, it tests that "PRAGMA synchronous" appears to work.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix sync2
+
+#
+# These tests are only applicable when pager pragma are
+# enabled. Also, since every test uses an ATTACHed database, they
+# are only run when ATTACH is enabled.
+#
+ifcapable !pager_pragmas||!attach {
+  finish_test
+  return
+}
+if {$::tcl_platform(platform)!="unix" 
+  || [permutation] == "journaltest"
+  || [permutation] == "inmemory_journal"
+} {
+  finish_test
+  return
+}
+
+proc execsql_sync {sql} {
+  set s $::sqlite_sync_count
+  set res [execsql $sql]
+  concat [expr $::sqlite_sync_count-$s] $res
+}
+
+proc do_execsql_sync_test {tn sql res} {
+  uplevel [list do_test $tn [list execsql_sync $sql] [list {*}$res]]
+}
+
+#-----------------------------------------------------------------------
+# Tests for journal mode.
+#
+sqlite3 db test.db
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b);
+  INSERT INTO t1 VALUES(1, 2);
+}
+
+do_execsql_sync_test 1.1 { INSERT INTO t1 VALUES(3, 4) } 4
+
+# synchronous=normal. So, 1 sync on the directory, 1 on the journal, 1 
+# on the db file. 3 in total.
+do_execsql_test      1.2.1 { PRAGMA main.synchronous = NORMAL }
+do_execsql_test      1.2.2 { PRAGMA main.synchronous }     1
+do_execsql_sync_test 1.2.3 { INSERT INTO t1 VALUES(5, 6) } 3
+
+# synchronous=off. No syncs.
+do_execsql_test      1.3.1 { PRAGMA main.synchronous = OFF }
+do_execsql_test      1.3.2 { PRAGMA main.synchronous }     0
+do_execsql_sync_test 1.3.3 { INSERT INTO t1 VALUES(7, 8) } 0
+ 
+# synchronous=full, journal_mode=delete. So, 1 sync on the directory,
+# 2 on the journal, 1 on the db file. 4 in total.
+do_execsql_test      1.4.1 { PRAGMA main.synchronous = FULL }
+do_execsql_test      1.4.2 { PRAGMA main.synchronous }      2
+do_execsql_sync_test 1.4.3 { INSERT INTO t1 VALUES(9, 10) } 4
+
+#-----------------------------------------------------------------------
+# Tests for wal mode.
+#
+do_execsql_test      1.5 { PRAGMA journal_mode = wal } {wal}
+
+# sync=full, journal_mode=wal. One sync on the directory, two on the 
+# wal file.
+do_execsql_sync_test 1.6 { INSERT INTO t1 VALUES(11, 12) } 3
+
+# One sync on the wal file.
+do_execsql_sync_test 1.7 { INSERT INTO t1 VALUES(13, 14) } 1
+
+# No syncs.
+do_execsql_test      1.8.1 { PRAGMA main.synchronous = NORMAL }
+do_execsql_test      1.8.2 { PRAGMA main.synchronous }          1
+do_execsql_sync_test 1.8.3 { INSERT INTO t1 VALUES(15, 16) }    0
+
+# One sync on wal file, one on the db file.
+do_execsql_sync_test 1.9   { PRAGMA wal_checkpoint }  {2 0 3 3}
+
+# No syncs.
+do_execsql_test      1.10.1 { PRAGMA main.synchronous = OFF }
+do_execsql_test      1.10.2 { PRAGMA main.synchronous }          0
+do_execsql_sync_test 1.10.3 { INSERT INTO t1 VALUES(17, 18) }    0
+
+#-----------------------------------------------------------------------
+# Tests for the compile time settings SQLITE_DEFAULT_SYNCHRONOUS and
+# SQLITE_DEFAULT_WAL_SYNCHRONOUS. These tests only run if the former
+# is set to "2" and the latter to "1". This is not the default, but
+# it is currently the recommended configuration.
+#
+#   https://sqlite.org/compile.html#recommended_compile_time_options
+#
+if {$SQLITE_DEFAULT_SYNCHRONOUS==2 && $SQLITE_DEFAULT_WAL_SYNCHRONOUS==1} {
+
+  db close
+  sqlite3 db test.db
+
+  # Wal mode, sync=normal. The first transaction does one sync on directory,
+  # one on the wal file. The second does no syncs.
+  do_execsql_sync_test 1.11.1 { INSERT INTO t1 VALUES(19, 20) } 2
+  do_execsql_sync_test 1.11.2 { INSERT INTO t1 VALUES(21, 22) } 0
+  do_execsql_test 1.11.3      { PRAGMA main.synchronous }       1
+
+  # One sync on wal file, one on the db file.
+  do_execsql_sync_test 1.12   { PRAGMA wal_checkpoint }  {2 0 2 2}
+
+  # First transaction syncs the wal file once, the second not at all.
+  # one on the wal file. The second does no syncs.
+  do_execsql_sync_test 1.13.1 { INSERT INTO t1 VALUES(22, 23) } 1
+  do_execsql_sync_test 1.13.2 { INSERT INTO t1 VALUES(24, 25) } 0
+
+  do_execsql_test 1.14 { PRAGMA journal_mode = delete } {delete}
+  
+  # Delete mode, sync=full. The first transaction does one sync on 
+  # directory, two on the journal file, one on the db. The second does 
+  # the same.
+  do_execsql_sync_test 1.15.1 { INSERT INTO t1 VALUES(26, 27) } 4
+  do_execsql_sync_test 1.15.2 { INSERT INTO t1 VALUES(28, 29) } 4
+  do_execsql_test 1.15.3      { PRAGMA main.synchronous }       2
+
+  # Switch back to wal mode.
+  do_execsql_test 1.16 { PRAGMA journal_mode = wal } {wal}
+
+  do_execsql_sync_test 1.17.1 { INSERT INTO t1 VALUES(30, 31) } 2
+  do_execsql_sync_test 1.17.2 { INSERT INTO t1 VALUES(32, 33) } 0
+  do_execsql_test 1.17.3      { PRAGMA main.synchronous }       1
+
+  # Now set synchronous=off, then switch back to delete mode. Check
+  # that the db handle is still using synchronous=off.
+  do_execsql_test 1.18.3      { PRAGMA main.synchronous=off }
+  do_execsql_test 1.18 { PRAGMA journal_mode = delete } {delete}
+
+  do_execsql_sync_test 1.19.1 { INSERT INTO t1 VALUES(34, 35) } 0
+  do_execsql_sync_test 1.19.2 { INSERT INTO t1 VALUES(36, 37) } 0
+  do_execsql_test 1.19.3      { PRAGMA main.synchronous }       0
+
+  # Close and reopen the db. Back to synchronous=normal.
+  db close
+  sqlite3 db test.db
+  do_execsql_sync_test 1.20.1 { INSERT INTO t1 VALUES(38, 39) } 4
+  do_execsql_sync_test 1.20.2 { INSERT INTO t1 VALUES(40, 41) } 4
+  do_execsql_test 1.20.3      { PRAGMA main.synchronous }       2
+}
+
+finish_test
@@ -0,0 +1,65 @@
+# 2017-03-24
+#
+# 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.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix triggerG
+ifcapable {!trigger} {
+  finish_test
+  return
+}
+
+# Test cases for ticket 
+# https://www.sqlite.org/src/tktview/06796225f59c057cd120f
+#
+# The OP_Once opcode was not working correctly for recursive triggers.
+#
+do_execsql_test 100 {
+  PRAGMA recursive_triggers = 1;
+  
+  CREATE TABLE t1(a);
+  CREATE INDEX i1 ON t1(a);
+  INSERT INTO t1(a) VALUES(0),(2),(3),(8),(9);
+  CREATE TABLE t2(b);
+  CREATE TABLE t3(c);
+  
+  CREATE TRIGGER tr AFTER INSERT ON t3 BEGIN
+    INSERT INTO t3 SELECT new.c+1 WHERE new.c<5;
+    INSERT INTO t2 SELECT new.c*100+a FROM t1 WHERE a IN (1, 2, 3, 4);
+  END;
+  
+  INSERT INTO t3 VALUES(2);
+  SELECT c FROM t3 ORDER BY c;;
+} {2 3 4 5}
+do_execsql_test 110 {
+  SELECT b FROM t2 ORDER BY b;
+} {202 203 302 303 402 403 502 503}
+
+do_execsql_test 200 {
+  DELETE FROM t1;
+  INSERT INTO t1(a) VALUES(0),(2),(3),(8),(9);
+  DELETE FROM t2;
+  DELETE FROM t3;
+  DROP TRIGGER tr;
+  CREATE TRIGGER tr AFTER INSERT ON t3 BEGIN
+    INSERT INTO t3 SELECT new.c+1 WHERE new.c<5;
+    INSERT INTO t2 SELECT new.c*10000+xx.a*100+yy.a
+                     FROM t1 AS xx, t1 AS yy
+                    WHERE xx.a IN (1,2,3,4)
+                      AND yy.a IN (2,3,4,5);
+  END;
+
+  INSERT INTO t3 VALUES(2);
+  SELECT b FROM t2 ORDER BY b;
+} {20202 20203 20302 20303 30202 30203 30302 30303 40202 40203 40302 40303 50202 50203 50302 50303}
+
+finish_test
@@ -535,7 +535,7 @@ static void decodeCell(
    j = i;
    nCol = 0;
    k = nHdr;
-    while( x+j<end && j<nHdr ){
+    while( x+j<=end && j<nHdr ){
       const char *zTypeName;
       int sz = 0;
       char zNm[30];
Author	SHA1	Message	Date
drh	86f5c3fdff	Version 3.18.1 FossilOrigin-Name: 77bb46233db03a3338bacf7e56f439be3dfd1926ea0c44d252eeafa7a7b31c06	2017-06-16 13:41:15 +00:00
drh	004ba54048	An unintentional fork was created due to a typo when creating branch-3.18. This check-in resolves the fork and is the 3.18.1 release candidate. FossilOrigin-Name: 20e5ffb1ceed514bf812ea5a2ce027b55203612bdbf8116a69f0cd52c67dbb84	2017-06-16 12:15:25 +00:00
drh	5da1cd0554	Increase the version number to 3.18.1. FossilOrigin-Name: 4be2eba8c15104e9f420738092c06a14a9c9c34b13c0c8f897302ab7613ffccc	2017-06-15 07:47:09 +00:00
drh	de415c006a	Ensure pointer map entries are always added when a row that does use overflow pages replaces one that does not in an auto-vacuum database. Fix for [fda22108]. FossilOrigin-Name: 30c50f0e06084f3c4357962ed99e2c803b21ca238d00d70d9dee40164caf2afa	2017-06-12 23:44:37 +00:00
drh	fe329a7370	Version 3.18.0 Release Candidate FossilOrigin-Name: 424a0d380332858ee55bdebc4af3789f74e70a2b3ba1cf29d84b9b4bcf3e2e37	2017-03-28 18:48:43 +00:00
drh	0d8d9c9eff	Add the new sqlite3_set_last_insert_rowid() interface to the extension loader thunk. FossilOrigin-Name: 8469fc0d48d6af0accef9b8a84e08ad2ca32351907510d177b4ca4815c1ea7cb	2017-03-25 19:16:41 +00:00
dan	b9cd86a091	Do not run tests for ".dump --preserve-rowids" when testing SQLITE_OMIT_VIRTUALTABLE builds. FossilOrigin-Name: 55df410b2cd27dc4c7670bcc1196fa3a0e9e601fc24c42e53d6b0a26ee3e4b45	2017-03-25 18:31:42 +00:00
drh	34ad36bf81	Disable the new --preserve-rowids option on the CLI ".dump" command if compiled with SQLITE_OMIT_VIRTUALTABLE. FossilOrigin-Name: bd5bbe4eece9051cc8c27d834d22fb243d34f261641984555d02a27b7038d4f6	2017-03-25 18:15:05 +00:00
drh	3e7d012eb1	Make the default value for SQLITE_DEFAULT_SYNCHRONOUS a simple integer literal, so that it does not show up goofy in the output of "PRAGMA compile_options;". FossilOrigin-Name: 833ab3212addc340ca8004e8d6a06cc5e51bf256f43dc73d87fbe67518a4891b	2017-03-25 18:03:26 +00:00
drh	2fb79e9b04	Fix two harmless compiler warnings. FossilOrigin-Name: 32be9c3faaafd736da3f49d475dc9279af4e4ba38070b60033d898345080acf0	2017-03-25 12:08:11 +00:00
drh	ba7cce317b	Fix a harmless compiler warning in the JSON1 extension. FossilOrigin-Name: c2c3dd84534bb5ea81c974847b74a166c9cba1545fc749ce625929f303bf22e4	2017-03-24 19:45:05 +00:00
drh	18333efd51	Previous check-in was not correct. This is a better fix for the OP_Once problem of ticket [06796225f59c057cd120f1]. FossilOrigin-Name: 8194dd2814b0b3f8cffbcb16306f55aabf1c1508b9d27fa806f92f0e6ecd7631	2017-03-24 18:38:41 +00:00
drh	ab087d4e67	Fix the OP_Once opcode so that it works correctly for recursive triggers. Ticket [06796225f59c057cd120f1]. FossilOrigin-Name: 2556014514f36808e6d18b25722eae0daeeb8fbb5d18af13a9698ea6c6db1679	2017-03-24 17:59:56 +00:00
drh	f9e91972c9	Add the RFC-7396 Appendix A test cases for json_patch(). FossilOrigin-Name: c5441d2df2526723f72610cc14dd243223663979e67ecdd76fe06fcd366f2b29	2017-03-24 13:31:47 +00:00
drh	29c9969871	Fix an error in the new json_patch() routine discovered by Ralf Junker. FossilOrigin-Name: 9d5350418b2f6113e0b50c57e8a872006f27753067baf08ffdfa7943c0c9a148	2017-03-24 12:35:17 +00:00
drh	adc117d40e	Add the json_patch() SQL function to the JSON1 extension. FossilOrigin-Name: 476088482024e411e2549b1697cdaf0124294c79d43f508c71c4eb66906a56fc	2017-03-23 23:44:55 +00:00
drh	37f03dfb1f	Change the name of the json_merge_patch() function to just json_patch(). FossilOrigin-Name: 04d4100445a3373986ee962618bc03ec304f6ba2f867c8e9eee415daffb593fc	2017-03-23 20:33:49 +00:00
drh	db528529bf	Improvement to the amalgamation configure.ac file contributed by Bob Friesenhahn. FossilOrigin-Name: bf28a55d8185e370fea39de297c37387f852f43fac0a316e5900e633f99b367f	2017-03-23 19:51:38 +00:00
dan	8fe3e9d882	Do not run test file autoanalyze1.test if OMIT_VIRTUALTABLE is defined. FossilOrigin-Name: e1d06a573ee56bf6a14e4dc8086d6a4df1464f2914834cf4596a0a406688f608	2017-03-23 17:22:09 +00:00
dan	a77edc69ee	Remove an invalid assert() statement failing when VACUUMing a database that contains an index on a column explicitly declared "COLLATE BINARY". FossilOrigin-Name: 9f2e04d3c3526b5ff60d941aa6d5446f602cab37cb93972937f39eefabd6868d	2017-03-23 17:03:35 +00:00
drh	1fe162fd0c	Avoid redundant edits in the json_merge_patch() function. FossilOrigin-Name: 4a8e6437dd610c5376a07867a73e5a7e2ea90357a018e1788ecce6f4e10bc939	2017-03-23 12:56:44 +00:00
drh	0002d246a9	Fix harmless compiler warnings in the new json_merge_patch() logic. FossilOrigin-Name: 5d2cf5a2f8afd88d041d89b3936042ce5a43629d23c48738cb2791b24da3e6af	2017-03-23 00:46:15 +00:00
drh	bb7aa2d85e	Various fixes to the json_merge_patch() function. FossilOrigin-Name: f49fd2554b0723eb7cf2fd765d655c6820833ee7e5f7d7629d98c27a6fffa1d9	2017-03-23 00:13:52 +00:00
drh	f07b249f92	Change the name of the new function to "json_merge_patch()". FossilOrigin-Name: 53bf70f37bbca319ea35f70849e2a34ae628a504486158fdad5c4bb7431c68e0	2017-03-22 21:45:20 +00:00
drh	633647af75	Initial implementation of the json_mergepatch(A,B) SQL function. FossilOrigin-Name: a267444039af519f088dd8f8ee33f686cc3071c087677075af2364ebc2587514	2017-03-22 21:24:31 +00:00
drh	701ff6ad2d	Fix harmless compiler warnings in the shell. FossilOrigin-Name: a786829783ef65ef270ca360712364cbd47a540d31ed1547d50808aad698bea7	2017-03-22 12:51:34 +00:00
drh	918938f9c2	New simplified memory initialization for MacOS. FossilOrigin-Name: 055b36f1c1593bb123f7319a07c476143d71af052b5b8d34afcd0d500f197882	2017-03-21 20:17:24 +00:00
drh	49297c86d2	Fix an incorrect assert in the ANALYZE logic for STAT4 on WITHOUT ROWID tables. FossilOrigin-Name: ad741976c8c29bcc94f9ea9ed7deb580bb00c8a81d1a7fba1a4e03849728433d	2017-03-21 18:56:52 +00:00
dan	119fc11eb0	Add short script ext/fts3/tool/fts3cov.sh. To help measure test-coverage of fts3 source code. FossilOrigin-Name: ee9588e873ffebcaa177957950cbb14924e154c391ed7f687116065064ff11b0	2017-03-21 17:19:31 +00:00
dan	a14b7e02e9	Do not run sync2.test as part of the "inmemory_journal" permutation. FossilOrigin-Name: 9f680bc7c47f8391adba6ea2b4b2cb6a5a041e22753543d5224da6656c3762fe	2017-03-21 10:45:38 +00:00
drh	174f855306	Add the --native-malloc option to fuzzcheck. Fix ossfuzz.c and fuzzcheck.c so that they both deallocate the temp_store_directory before closing. FossilOrigin-Name: 0dd18ec882bb28a87629d6d8dfeb5ea5d82833634b3781a7d14b917272c4dfa0	2017-03-20 22:58:27 +00:00
drh	16f0582c1b	Fix the fuzzcheck program so that it can create new databases again. FossilOrigin-Name: 021e8874a7d1bb94debae3ae04f83056a8573148ffc872cd76a186a2d22d0296	2017-03-20 20:42:21 +00:00
dan	74869e5e52	Avoid passing NULL as the second argument to memcpy() in fts3. FossilOrigin-Name: 49b93d972de9649abfd6235b65dda1c9d468956671e50704afde6181ffa56dea	2017-03-20 19:35:30 +00:00
dan	6b904f5e01	Avoid a technically undefined right-shift of a signed value in rtree.c. FossilOrigin-Name: a144875fe44ff3a30bab299d50b7dbec2ee21f8c73e692a71ee1f7c54b5f0c76	2017-03-20 19:26:27 +00:00
dan	920c83f18f	Fix some problems in fts3 found by address-sanitizer. FossilOrigin-Name: 16a8e84fa7f67a467f824bdd7f72cbd6a6e95dab8cc7aa1e0e751720b98f3e31	2017-03-20 18:53:32 +00:00
drh	5f42995a0a	Avoid the possibility of signed integer overflow with oversized precisions in %d conversions in the printf() implementation. FossilOrigin-Name: ef3a7c877a7549b351aafd983cfa96c863eb2641b6218bdd5cb563f659f879d8	2017-03-20 16:34:18 +00:00
dan	5b3a3b359a	Do not run sync2.test as part of the "journaltest" permutation, as it uses "PRAGMA synchronous = off". FossilOrigin-Name: 285005a9bcb210bb2a9aa9fed6a19d4b78641a6e7622d469bd0d2a365b2c0735	2017-03-20 16:06:48 +00:00
drh	7adbcffcb9	Ensure that a "--" prefix is added to sqlite3_trace_v2() output for nested SQL statements. FossilOrigin-Name: 673a7b67c4828acaea3baebea500ef1f8ae763588b0d9c9f2ad6ed5ceb3cfee2	2017-03-20 15:29:28 +00:00
dan	154cc74601	Only run sync2.test on unix, as it depends on instrumentation in os_unix.c. FossilOrigin-Name: ecb9321e18dd72ea18d197c61c4d69500e9c4282c0eac67822cb40b2710a2815	2017-03-20 15:11:40 +00:00
drh	978896e0eb	Fix the check.test script so that it works on Windows. FossilOrigin-Name: 8822eb5d790bf8d4302c3f2dc05ab672193b309fb11771c4b3eea8a77f37e299	2017-03-20 14:44:07 +00:00
drh	d3d52ef147	Documentation fix: SQLITE_SOURCE_ID is a now a SHA3-256 hash. FossilOrigin-Name: 2aa22509e7c8a1f09b16e4544c95d0b77503daed1f83106ccc18dee8bd9487a4	2017-03-20 13:03:39 +00:00
drh	a80e160634	Only do the specialized MacOS single-core zone_malloc initialization if compiled with the SQLITE_MIGHT_BE_SINGLE_CORE flag. This avoids a (harmless) warning about OSAtomicCompareAndSwapPtrBarrier() being deprecated. FossilOrigin-Name: 4e6a03d9e12b120d15946b025f97a97697cb8e8af543c238ffda220c9e3f28f4	2017-03-18 13:59:46 +00:00
drh	46acfc2b47	Fix an error in the newly revised documentation for SQLITE_LIMIT_VDBE_OP. No changes to code. FossilOrigin-Name: f4cf8635e6fec6f04075cc067aaa71abc4f71739068e0ad2c44609dcb8691009	2017-03-17 23:08:11 +00:00
drh	544cab7651	Set a reasonable limit on the number of opcodes in a prepared statement for ossfuzz.c. This should prevent timeouts in OSS-Fuzz when it generates totally unreasonable queries. FossilOrigin-Name: f74899ed2c78019abb406432a74dcd42a0ff8d9add005f8544dc4a8905f232eb	2017-03-17 22:51:28 +00:00
drh	1cb0266dcb	Begin enforcing the SQLITE_LIMIT_VDBE_OP. The documentation warned that this day might come. FossilOrigin-Name: ef5914617088cbf89bfae88f63ea959a07f02dff387ddc2b43948ad99c6a97b8	2017-03-17 22:50:16 +00:00
drh	f53524b4f7	Add the --show-errors and --show-max-delay command-line options to the ossshell test program. FossilOrigin-Name: 626bdca98e0cd78ae873d97e75bb7d544ca18759c9f1e67f4adf03daca7fe5bf	2017-03-17 14:59:40 +00:00
drh	59d705ab80	Fix the Makefile.in so that it builds the ossshell test program correctly. FossilOrigin-Name: 36f5602ec9fb8e404c5250e18b1db877ac7bee643918b94afd51808134ea7900	2017-03-17 14:15:06 +00:00
dan	1f9144ed41	Fix a buffer overread in debugging routine sqlite3VdbeMemPrettyPrint(). Problem discovered by OSS-Fuzz. FossilOrigin-Name: f336fba7d7d41b91a5000d01dddf785821fa79ea31dbd8d1f769d55f7e871896	2017-03-17 13:59:06 +00:00
drh	a3b2da9889	Fix a problem in the enhanced PRAGMA integrity_check where it verifies CHECK constraints: Do not be confused by the reuse of the Table.pCheck field by VIEWs with named columns. Problem discovered by OSS-Fuzz. FossilOrigin-Name: 019dd3d5ba4a596c4ec3b5f0de8402c72196af0faca9138edbc0f1f4957cae60	2017-03-17 03:21:14 +00:00
dan	af3332989f	If the user has not set it explicitly, set the "PRAGMA synchronous" setting to SQLITE_DEFAULT_SYNCHRONOUS when a database connection changes from wal to rollback journal mode. FossilOrigin-Name: 5c604479fda06714500959e121c719d1b6c8e54d1658eb9f560a4af95b7c5829	2017-03-16 18:55:21 +00:00
dan	fc8f4b658c	Fix a typo causing the build to fail if SQLITE_DEFAULT_SYNCHRONOUS==SQLITE_DEFAULT_WAL_SYNCHRONOUS. FossilOrigin-Name: df39adeaa4d73a3d4ec831843b8ec7fd449f8b2137bdc7d7c320958d00e98db6	2017-03-16 18:54:42 +00:00
dan	f5da7dbb07	If the user has not set it explicitly, set the "PRAGMA synchronous" setting to SQLITE_DEFAULT_SYNCHRONOUS when a database connection changes from wal to rollback journal mode. FossilOrigin-Name: 78030c0f52aa39fb2ab32c75c56e6bcefe6382b8df28b1909e3c911e42dbeca3	2017-03-16 18:14:39 +00:00
drh	b30574bcae	Simplified OOM detection in the instr() SQL function. FossilOrigin-Name: 6d85eb5736781b43aa674d9544c7523b849b4e634f371702f8764b33e22e1e9f	2017-03-16 14:28:52 +00:00
drh	85c2dc0ae6	Fix an uninitialized variable reference in the text generator for "PRAGMA vdbe_trace=ON" output. Problem discovered by OSS-Fuzz. FossilOrigin-Name: e3d487162d1596ce125644f754ed9531ef4412f31f6837c3e31b7542b90602fe	2017-03-16 13:30:58 +00:00
drh	970ea372c4	Fix a problem in the "showdb" utility that prevents it from correctly decoding cells with no content beyond the record header. FossilOrigin-Name: eb7680a1c047b2a33d6a0c9733fafaee11272377c627af10bbd541b6b7ed952b	2017-03-16 13:14:03 +00:00
dan	116b56a2cc	Fix a crash that could follow an OOM condition in the instr() SQL function. FossilOrigin-Name: 6e59e903e4e956617bddef0b94e5cae02d724ac8145940b57ab5b0f628759736	2017-03-16 12:11:07 +00:00
drh	6f25936c9c	Updates to README files under the ext/ hierarchy. No changes to code. FossilOrigin-Name: 029bc5d224bcbdcca2307710539b133c39e2a27b971c28b294a1f517b80cb418	2017-03-15 20:27:46 +00:00
drh	6295ff1d3e	Add the "Obtaining The Code" subsection in the top-level README.md file. No changes to code. FossilOrigin-Name: b1b1aa8b69aa80c83aec3380565f0b4ec0b6a6e033537becee098872da362e9a	2017-03-15 19:11:29 +00:00
drh	a5d75ba9ea	Mention the ".selftest" command in the ".help" output of the CLI. FossilOrigin-Name: 37f766dbad1f99ff86dd1b771bf443036e928e5b4d8abe55bbe4acf3362c7be2	2017-03-15 14:20:34 +00:00
drh	7553c82894	Make "PRAGMA temp.synchronous=N" a no-op to ensure that the TEMP schema always has synchronous=OFF. This fixes an issue discovered by OSS-Fuzz. FossilOrigin-Name: bcf6bb08d8b07d3c4567bcd367f8d4011ce8baad28c25d4e8870bdf347dd48bd	2017-03-15 14:04:03 +00:00
drh	9c4527e57d	Improved header comment on the shathree.c extension. No changes to code. FossilOrigin-Name: 84f2e3d5f611b35de16684956d842df6c93d858e8187f17eb27452758a752c57	2017-03-15 13:47:39 +00:00
mistachkin	943d825b54	Updates to the MSVC makefiles. FossilOrigin-Name: 1e4b9e7c9ee32b985c440bf3eb65bbdf28055566e66b6feba438143a3ad8dd07	2017-03-14 15:27:56 +00:00
drh	29df8d1fc2	Add the dbdump.c extension that implements functionality similar to the ".dump" command of the CLI, though in a separate library. FossilOrigin-Name: 2b9980a292d7f0d995b77d9b3fb217bb2206f6d452e036ac502fa06561af4c12	2017-03-13 22:10:05 +00:00
drh	4b34eb3bf5	Add dbdump.exe to the MSVC makefile. FossilOrigin-Name: 59241a50ad1d6fe9f5804b73b3467dcd407d359ccbdcb9d72f2f6d94c90c1f40	2017-03-13 22:02:01 +00:00
drh	d3bc75fb94	Fixes to the dump logic. All appears to be working in preliminary tests. FossilOrigin-Name: 007b11e301d444361c8eff8734dc2fb968a64343c177ff30cec74a0cf76099e8	2017-03-13 21:49:48 +00:00
drh	473af4fe03	First draft of the complete dbdump.c library. FossilOrigin-Name: 84ea4fcc52d0af02648c52989c2e69f4961071e1620382555ec59a39161a7a7d	2017-03-13 21:26:41 +00:00
drh	688633cb9e	Infrastructure for an extension C-library to implement sqlite3_db_dump() and a corresponding "dbdump" command-line utility - both of which do the same work as the ".dump" command of the CLI. FossilOrigin-Name: 74c5ace498f72d7f5495203678bedd0bc540211131a4e4db7b62115d5322a288	2017-03-13 19:26:34 +00:00
drh	d3bb79bd0f	In the output of the ".dump" command in the CLI, quote newline and carriage-return characters using the char() function, so that they do not get eaten by end-of-line processing logic in the OS or in other command-line utilities and/or libraries. FossilOrigin-Name: 68f6dc7af1013f296a11db14c007cc13cc3fe56832848bfed835ed8f74dcc676	2017-03-13 18:24:06 +00:00
drh	510b7ff536	Fix the sqlite3TreeViewSelect() routine so that it works with a null pointer to the Select object. FossilOrigin-Name: 9034cf7efc603864f51e931c7dc4fbbc2d01904e951e78c88d4d80f9936250e8	2017-03-13 17:37:13 +00:00
dan	c3becddb75	Fix a segfault that could occur following an OOM error in the flattenSubquery() routine. FossilOrigin-Name: c6dda3f752c184f441624c9993e77d5031063d79a0e177b6e25a9886514a742e	2017-03-13 14:30:40 +00:00
drh	bbc0177460	In the OSSFuzz test module, invoke the progress handler much more frequently so that timeouts are detected punctually even if the test script is running opcodes that individually take a long time (for example, an OP_Function opcode that invokes "randomblob(1.5e6)"). FossilOrigin-Name: f3b6959c04c4ef7b8ff03582b867012a869d52b4a90a0d7ab079ee4c21be5464	2017-03-13 13:45:29 +00:00
drh	ba28b5ab0a	Fix a possible NULL pointer dereference in following an OOM error in sqlite3ExprIsInteger(). Problem found by OSS-Fuzz. FossilOrigin-Name: 5ec655e8e817c1ed3bfb2e576745a7cef441494ad7baf1bf9f8895e98ac19c5a	2017-03-12 20:28:44 +00:00
drh	1ed1e616f7	Remove an obsolete assert() in the IN operator code generation. FossilOrigin-Name: 18bf6aca2ac86478fd12d5020f3a41cfd2bd2dc3defe2298411f79ad308a6f73	2017-03-12 19:39:00 +00:00
drh	202230ef5c	Make sure the translateColumnToCopy() routine in the query planner does not try to access an array that failed to be fully allocated due to a prior OOM. This fixes an issue discovered by OSSFuzz. FossilOrigin-Name: 3299a26160c239255608d1e2b15a221e28b18a3d	2017-03-11 13:02:59 +00:00
drh	708b22b1e3	The output of the ".dump" command in the CLI quotes newline and carriage-return characters using "char(10)" and "char(13)". FossilOrigin-Name: 8b2954dd8376e2de985cf5dedeb6eec32c430505	2017-03-11 01:56:41 +00:00
drh	891d6b4e9e	Increase the number of significant digits in floating point literals on ".dump" output from the shell. FossilOrigin-Name: 7359fcacaadc349f520536311dcd1d0b5cea7673	2017-03-11 00:46:57 +00:00
dan	1ba30db8bd	Remove the rbu_round_trip.tcl script. It is now part of project "test-dbs". FossilOrigin-Name: b5bf2957677e8f2acd7426b302229a966de08fd9	2017-03-10 18:36:34 +00:00
drh	a6bf20b587	Fix an error in the SQLITE_MAX_MEMORY implementation resulting from a bad merge. Update the OSSFuzz interface so that it times out after running the byte-code engine for 10 seconds. FossilOrigin-Name: f8560c60d10c0365b33342ab05b5a953987b0471	2017-03-10 17:03:11 +00:00
drh	1e45c7db56	Add the -DSQLITE_MAX_MEMORY=N compile-time option. The default is no limit. FossilOrigin-Name: eabd4ef498a0f0d97d65e321c4d06ab90523ed61	2017-03-10 16:22:40 +00:00
drh	e43d6aee45	Add the SQLITE_MAX_MEMORY compile-time option that provides a hard upper bound on the amount of memory that SQLite will use, per process. FossilOrigin-Name: 77dfe2abdae88dea81217f352d87e5ba2c822715	2017-03-10 15:55:54 +00:00
drh	a2df53bd61	Enhance the ".stats" dot-command in the CLI to use sqlite3_status64() instead of sqlite3_status(). FossilOrigin-Name: 118f5c0564fef70cbd06fc0d9dbb2baec162cc39	2017-03-10 14:36:10 +00:00
drh	f157d10f9f	Improvements to ".selftest --init". Tests are number in increments of 10 starting with 100. The tests are generated inside a SAVEPOINT. Errors are reported during test generation. Tests can be appended to existing tests. Add a test case to verify the schema. FossilOrigin-Name: b044b152aac2ec606750940ea816ad4a4aef8eb6	2017-03-10 01:05:38 +00:00
drh	fb546afb4d	Remove the test/dbselftest.c program. In its place, add the ".selftest" command to the CLI. The new CLI version is .selftest is slightly different in that it uses SHA3 hashing instead of SHA1, so the new is subtly incompatible with the old. FossilOrigin-Name: f4fcd46f08ba59d2a3e772cad98383129f648386	2017-03-09 22:00:33 +00:00
drh	f8563c00b2	Fix the ".dump" command to correctly extract tail data from corrupt WITHOUT ROWID tables. FossilOrigin-Name: 6c627e50622d8bcd25ec7d5503f3fafd725673a8	2017-03-09 18:13:52 +00:00
drh	e6e1d124db	Begin moving separate boolean variables in the ShellState object of the CLI into the shellFlgs bitmask. FossilOrigin-Name: 50eec5d9aa38fab1a85d788356ffdaf6c35d9ece	2017-03-09 13:50:49 +00:00
@@ -1 +1 @@
 .18.0
 .18.1