More work on Windows 10 SDK integration.

FossilOrigin-Name: ebace2c99b6af9230c4bbc31a764c7f397200148
Further streamlining of fts5 prefix query code.
2016-02-05 19:40:23 +00:00 · 2016-02-05 19:18:02 +00:00 · 2016-02-05 17:49:43 +00:00 · 2016-02-05 16:46:09 +00:00 · 2016-02-05 14:11:12 +00:00 · 2016-02-05 13:38:36 +00:00
117 changed files with 1223 additions and 951 deletions
@@ -356,6 +356,16 @@ NSDKLIBPATH = $(WINDOWSSDKDIR)\lib

 NSDKLIBPATH = $(NSDKLIBPATH:\\=\)

+# Check for the UCRT library path macro.  Othertise, this value will
+# default to the version-specific, platform-specific 'lib' directory
+# underneath the Windows SDK installation directory.
+#
+!IFNDEF UCRTLIBPATH
+UCRTLIBPATH = $(WINDOWSSDKDIR)\lib\$(WINDOWSSDKLIBVERSION)\ucrt\$(PLATFORM)
+!ENDIF
+
+UCRTLIBPATH = $(UCRTLIBPATH:\\=\)
+
 # C compiler and options for use in building executables that
 # will run on the platform that is doing the build.
 #
@@ -541,7 +551,7 @@ BCC = $(BCC) /guard:cf -D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE
 # USE_CRT_DLL option is set to force dynamically linking to the
 # MSVC runtime library.
 #
-!IF $(FOR_WINRT)!=0 || $(FOR_WIN10)!=0 || $(USE_CRT_DLL)!=0
+!IF $(FOR_WINRT)!=0 || $(USE_CRT_DLL)!=0
 !IF $(DEBUG)>1
 TCC = $(TCC) -MDd
 BCC = $(BCC) -MDd
@@ -888,7 +898,8 @@ LTLINKOPTS = $(LTLINKOPTS) WindowsPhoneCore.lib RuntimeObject.lib PhoneAppModelH
 LTLINKOPTS = $(LTLINKOPTS) /NODEFAULTLIB:kernel32.lib /NODEFAULTLIB:ole32.lib
 !ENDIF

-# When compiling for UAP, some extra linker options are also required.
+# When compiling for UAP or the Windows 10 platform, some extra
+# linker options are also required.
 #
 !IF $(FOR_UAP)!=0 || $(FOR_WIN10)!=0
 LTLINKOPTS = $(LTLINKOPTS) /DYNAMICBASE /NODEFAULTLIB:kernel32.lib
@@ -898,6 +909,15 @@ LTLINKOPTS = $(LTLINKOPTS) "/LIBPATH:$(PSDKLIBPATH)"
 !ENDIF
 !ENDIF

+!IF $(FOR_WIN10)!=0
+LTLINKOPTS = $(LTLINKOPTS) "/LIBPATH:$(UCRTLIBPATH)"
+!IF $(DEBUG)>1
+LTLINKOPTS = $(LTLINKOPTS) /NODEFAULTLIB:libucrtd.lib /DEFAULTLIB:ucrtd.lib
+!ELSE
+LTLINKOPTS = $(LTLINKOPTS) /NODEFAULTLIB:libucrt.lib /DEFAULTLIB:ucrt.lib
+!ENDIF
+!ENDIF
+
 # If either debugging or symbols are enabled, enable PDBs.
 #
 !IF $(DEBUG)>1 || $(SYMBOLS)!=0
@@ -282,6 +282,7 @@ struct Fts5PoslistWriter {
  i64 iPrev;
 };
 int sqlite3Fts5PoslistWriterAppend(Fts5Buffer*, Fts5PoslistWriter*, i64);
+void sqlite3Fts5PoslistSafeAppend(Fts5Buffer*, i64*, i64);

 int sqlite3Fts5PoslistNext64(
  const u8 *a, int n,             /* Buffer containing poslist */
@@ -16,18 +16,20 @@
 #include "fts5Int.h"

 int sqlite3Fts5BufferSize(int *pRc, Fts5Buffer *pBuf, u32 nByte){
-  u32 nNew = pBuf->nSpace ? pBuf->nSpace*2 : 64;
-  u8 *pNew;
-  while( nNew<nByte ){
-    nNew = nNew * 2;
-  }
-  pNew = sqlite3_realloc(pBuf->p, nNew);
-  if( pNew==0 ){
-    *pRc = SQLITE_NOMEM;
-    return 1;
-  }else{
-    pBuf->nSpace = nNew;
-    pBuf->p = pNew;
+  if( pBuf->nSpace<nByte ){
+    u32 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
+    u8 *pNew;
+    while( nNew<nByte ){
+      nNew = nNew * 2;
+    }
+    pNew = sqlite3_realloc(pBuf->p, nNew);
+    if( pNew==0 ){
+      *pRc = SQLITE_NOMEM;
+      return 1;
+    }else{
+      pBuf->nSpace = nNew;
+      pBuf->p = pNew;
+    }
  }
  return 0;
 }
@@ -208,23 +210,37 @@ int sqlite3Fts5PoslistReaderInit(
  return pIter->bEof;
 }

+/*
+** Append position iPos to the position list being accumulated in buffer
+** pBuf, which must be already be large enough to hold the new data.
+** The previous position written to this list is *piPrev. *piPrev is set
+** to iPos before returning.
+*/
+void sqlite3Fts5PoslistSafeAppend(
+  Fts5Buffer *pBuf, 
+  i64 *piPrev, 
+  i64 iPos
+){
+  static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
+  if( (iPos & colmask) != (*piPrev & colmask) ){
+    pBuf->p[pBuf->n++] = 1;
+    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
+    *piPrev = (iPos & colmask);
+  }
+  pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2);
+  *piPrev = iPos;
+}
+
 int sqlite3Fts5PoslistWriterAppend(
  Fts5Buffer *pBuf, 
  Fts5PoslistWriter *pWriter,
  i64 iPos
 ){
  static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
-  int rc = SQLITE_OK;
-  if( 0==fts5BufferGrow(&rc, pBuf, 5+5+5) ){
-    if( (iPos & colmask) != (pWriter->iPrev & colmask) ){
-      pBuf->p[pBuf->n++] = 1;
-      pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
-      pWriter->iPrev = (iPos & colmask);
-    }
-    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-pWriter->iPrev)+2);
-    pWriter->iPrev = iPos;
-  }
-  return rc;
+  int rc;
+  if( fts5BufferGrow(&rc, pBuf, 5+5+5) ) return rc;
+  sqlite3Fts5PoslistSafeAppend(pBuf, &pWriter->iPrev, iPos);
+  return SQLITE_OK;
 }

 void *sqlite3Fts5MallocZero(int *pRc, int nByte){
@@ -4704,77 +4704,120 @@ static void fts5MergePrefixLists(
  Fts5Buffer *p1,                 /* First list to merge */
  Fts5Buffer *p2                  /* Second list to merge */
 ){
+
  if( p2->n ){
-    i64 iLastRowid = 0;
-    Fts5DoclistIter i1;
-    Fts5DoclistIter i2;
-    Fts5Buffer out;
-    Fts5Buffer tmp;
-    memset(&out, 0, sizeof(out));
-    memset(&tmp, 0, sizeof(tmp));
+    if( p1->n==0 ){
+      fts5BufferSwap(p1, p2);
+    }else{
+      i64 iLastRowid = 0;
+      Fts5DoclistIter i1;
+      Fts5DoclistIter i2;
+      Fts5Buffer out = {0, 0, 0};
+      Fts5Buffer tmp = {0, 0, 0};

-    sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
-    fts5DoclistIterInit(p1, &i1);
-    fts5DoclistIterInit(p2, &i2);
-    while( p->rc==SQLITE_OK && (i1.aPoslist!=0 || i2.aPoslist!=0) ){
-      if( i2.aPoslist==0 || (i1.aPoslist && i1.iRowid<i2.iRowid) ){
-        /* Copy entry from i1 */
-        fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
-        fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.nPoslist+i1.nSize);
-        fts5DoclistIterNext(&i1);
-      }
-      else if( i1.aPoslist==0 || i2.iRowid!=i1.iRowid ){
-        /* Copy entry from i2 */
-        fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
-        fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.nPoslist+i2.nSize);
-        fts5DoclistIterNext(&i2);
-      }
-      else{
-        i64 iPos1 = 0;
-        i64 iPos2 = 0;
-        int iOff1 = 0;
-        int iOff2 = 0;
-        u8 *a1 = &i1.aPoslist[i1.nSize];
-        u8 *a2 = &i2.aPoslist[i2.nSize];
+      if( sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n) ) return;
+      fts5DoclistIterInit(p1, &i1);
+      fts5DoclistIterInit(p2, &i2);

-        Fts5PoslistWriter writer;
-        memset(&writer, 0, sizeof(writer));
+      while( 1 ){
+        if( i1.iRowid<i2.iRowid ){
+          /* Copy entry from i1 */
+          fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
+          fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.nPoslist+i1.nSize);
+          fts5DoclistIterNext(&i1);
+          if( i1.aPoslist==0 ) break;
+        }
+        else if( i2.iRowid!=i1.iRowid ){
+          /* Copy entry from i2 */
+          fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
+          fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.nPoslist+i2.nSize);
+          fts5DoclistIterNext(&i2);
+          if( i2.aPoslist==0 ) break;
+        }
+        else{
+          i64 iPos1 = 0;
+          i64 iPos2 = 0;
+          int iOff1 = 0;
+          int iOff2 = 0;
+          u8 *a1 = &i1.aPoslist[i1.nSize];
+          u8 *a2 = &i2.aPoslist[i2.nSize];

-        /* Merge the two position lists. */ 
-        fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
-        fts5BufferZero(&tmp);
+          i64 iPrev = 0;
+          Fts5PoslistWriter writer;
+          memset(&writer, 0, sizeof(writer));

-        sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
-        sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
+          /* Merge the two position lists. */ 
+          fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
+          fts5BufferZero(&tmp);
+          sqlite3Fts5BufferSize(&p->rc, &tmp, i1.nPoslist + i2.nPoslist);
+          if( p->rc ) break;

-        while( p->rc==SQLITE_OK && (iPos1>=0 || iPos2>=0) ){
-          i64 iNew;
-          if( iPos2<0 || (iPos1>=0 && iPos1<iPos2) ){
-            iNew = iPos1;
+          sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
+          sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
+          assert( iPos1>=0 && iPos2>=0 );
+
+          if( iPos1<iPos2 ){
+            sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
            sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
          }else{
-            iNew = iPos2;
+            sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
            sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
-            if( iPos1==iPos2 ){
-              sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1,&iPos1);
+          }
+
+          if( iPos1>=0 && iPos2>=0 ){
+            while( 1 ){
+              if( iPos1<iPos2 ){
+                if( iPos1!=iPrev ){
+                  sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
+                }
+                sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
+                if( iPos1<0 ) break;
+              }else{
+                if( iPos2!=iPrev ){
+                  sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
+                }
+                sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
+                if( iPos2<0 ) break;
+              }
            }
          }
-          if( iNew!=writer.iPrev || tmp.n==0 ){
-            p->rc = sqlite3Fts5PoslistWriterAppend(&tmp, &writer, iNew);
+
+          if( iPos1>=0 ){
+            if( iPos1!=iPrev ){
+              sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
+            }
+            fts5BufferSafeAppendBlob(&tmp, &a1[iOff1], i1.nPoslist-iOff1);
          }
+          else if( iPos2>=0 ){
+            if( iPos2!=iPrev ){
+              sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
+            }
+            fts5BufferSafeAppendBlob(&tmp, &a2[iOff2], i2.nPoslist-iOff2);
+          }
+
+          /* WRITEPOSLISTSIZE */
+          fts5BufferSafeAppendVarint(&out, tmp.n * 2);
+          fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
+          fts5DoclistIterNext(&i1);
+          fts5DoclistIterNext(&i2);
+          if( i1.aPoslist==0 || i2.aPoslist==0 ) break;
        }
-
-        /* WRITEPOSLISTSIZE */
-        fts5BufferSafeAppendVarint(&out, tmp.n * 2);
-        fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
-        fts5DoclistIterNext(&i1);
-        fts5DoclistIterNext(&i2);
      }
-    }

-    fts5BufferSet(&p->rc, p1, out.n, out.p);
-    fts5BufferFree(&tmp);
-    fts5BufferFree(&out);
+      if( i1.aPoslist ){
+        fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
+        fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.aEof - i1.aPoslist);
+      }
+      else if( i2.aPoslist ){
+        fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
+        fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.aEof - i2.aPoslist);
+      }
+
+     error_out:
+      fts5BufferSet(&p->rc, p1, out.n, out.p);
+      fts5BufferFree(&tmp);
+      fts5BufferFree(&out);
+    }
  }
 }

@@ -4918,7 +4961,7 @@ int sqlite3Fts5IndexSync(Fts5Index *p, int bCommit){
 int sqlite3Fts5IndexRollback(Fts5Index *p){
  fts5CloseReader(p);
  fts5IndexDiscardData(p);
-  assert( p->rc==SQLITE_OK );
+  /* assert( p->rc==SQLITE_OK ); */
  return SQLITE_OK;
 }

@@ -803,7 +803,7 @@ static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
 */
 static int fts5NextMethod(sqlite3_vtab_cursor *pCursor){
  Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  int rc = SQLITE_OK;
+  int rc;

  assert( (pCsr->ePlan<3)==
          (pCsr->ePlan==FTS5_PLAN_MATCH || pCsr->ePlan==FTS5_PLAN_SOURCE) 
@@ -820,6 +820,7 @@ static int fts5NextMethod(sqlite3_vtab_cursor *pCursor){
    switch( pCsr->ePlan ){
      case FTS5_PLAN_SPECIAL: {
        CsrFlagSet(pCsr, FTS5CSR_EOF);
+        rc = SQLITE_OK;
        break;
      }
  
@@ -11,6 +11,8 @@
 # This file implements regression tests for SQLite library.  The
 # focus of this script is testing the FTS5 module.
 #
+# More specifically, the focus is on testing prefix queries, both with and
+# without prefix indexes.
 #

 source [file join [file dirname [info script]] fts5_common.tcl]
@@ -85,6 +85,10 @@ do_execsql_test 2.2 {
  SELECT fts5_test_poslist(t2) FROM t2('aa');
 } {0.0.0}

+do_execsql_test 2.3 {
+  SELECT fts5_test_collist(t2) FROM t2('aa');
+} {0.0}
+
 set ::pc 0
 #puts [nearset {{ax bx cx}} -pc ::pc -near 10 -- b*]
 #exit
@@ -276,10 +276,33 @@ static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
  if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return;
  p->zBuf[p->nUsed++] = '"';
  for(i=0; i<N; i++){
-    char c = zIn[i];
+    unsigned char c = ((unsigned const char*)zIn)[i];
    if( c=='"' || c=='\\' ){
+      json_simple_escape:
      if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return;
      p->zBuf[p->nUsed++] = '\\';
+    }else if( c<=0x1f ){
+      static const char aSpecial[] = {
+         0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
+         0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0, 0, 0
+      };
+      assert( sizeof(aSpecial)==32 );
+      assert( aSpecial['\b']=='b' );
+      assert( aSpecial['\f']=='f' );
+      assert( aSpecial['\n']=='n' );
+      assert( aSpecial['\r']=='r' );
+      assert( aSpecial['\t']=='t' );
+      if( aSpecial[c] ){
+        c = aSpecial[c];
+        goto json_simple_escape;
+      }
+      if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return;
+      p->zBuf[p->nUsed++] = '\\';
+      p->zBuf[p->nUsed++] = 'u';
+      p->zBuf[p->nUsed++] = '0';
+      p->zBuf[p->nUsed++] = '0';
+      p->zBuf[p->nUsed++] = '0' + (c>>4);
+      c = "0123456789abcdef"[c&0xf];
    }
    p->zBuf[p->nUsed++] = c;
  }
@@ -320,7 +343,7 @@ static void jsonAppendValue(
    default: {
      if( p->bErr==0 ){
        sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
-        p->bErr = 1;
+        p->bErr = 2;
        jsonReset(p);
      }
      break;
@@ -1548,7 +1571,7 @@ static void jsonArrayFinal(sqlite3_context *ctx){
    pStr->pCtx = ctx;
    jsonAppendChar(pStr, ']');
    if( pStr->bErr ){
-      sqlite3_result_error_nomem(ctx);
+      if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
      assert( pStr->bStatic );
    }else{
      sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
@@ -1596,7 +1619,7 @@ static void jsonObjectFinal(sqlite3_context *ctx){
  if( pStr ){
    jsonAppendChar(pStr, '}');
    if( pStr->bErr ){
-      sqlite3_result_error_nomem(ctx);
+      if( pStr->bErr==0 ) sqlite3_result_error_nomem(ctx);
      assert( pStr->bStatic );
    }else{
      sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
@@ -186,7 +186,7 @@ static const unsigned char className[] = ".ABCDHLRMY9 ?";
 ** Return NULL if memory allocation fails.  
 */
 static unsigned char *phoneticHash(const unsigned char *zIn, int nIn){
-  unsigned char *zOut = sqlite3_malloc( nIn + 1 );
+  unsigned char *zOut = sqlite3_malloc64( nIn + 1 );
  int i;
  int nOut = 0;
  char cPrev = 0x77;
@@ -413,7 +413,7 @@ static int editdist1(const char *zA, const char *zB, int *pnMatch){
  if( nB<(sizeof(mStack)*4)/(sizeof(mStack[0])*5) ){
    m = mStack;
  }else{
-    m = toFree = sqlite3_malloc( (nB+1)*5*sizeof(m[0])/4 );
+    m = toFree = sqlite3_malloc64( (nB+1)*5*sizeof(m[0])/4 );
    if( m==0 ) return -3;
  }
  cx = (char*)&m[nB+1];
@@ -687,7 +687,7 @@ static int editDist3ConfigLoad(
    if( iCost<0 ) continue;
    if( pLang==0 || iLang!=iLangPrev ){
      EditDist3Lang *pNew;
-      pNew = sqlite3_realloc(p->a, (p->nLang+1)*sizeof(p->a[0]));
+      pNew = sqlite3_realloc64(p->a, (p->nLang+1)*sizeof(p->a[0]));
      if( pNew==0 ){ rc = SQLITE_NOMEM; break; }
      p->a = pNew;
      pLang = &p->a[p->nLang];
@@ -709,7 +709,7 @@ static int editDist3ConfigLoad(
      EditDist3Cost *pCost;
      int nExtra = nFrom + nTo - 4;
      if( nExtra<0 ) nExtra = 0;
-      pCost = sqlite3_malloc( sizeof(*pCost) + nExtra );
+      pCost = sqlite3_malloc64( sizeof(*pCost) + nExtra );
      if( pCost==0 ){ rc = SQLITE_NOMEM; break; }
      pCost->nFrom = nFrom;
      pCost->nTo = nTo;
@@ -808,7 +808,7 @@ static EditDist3FromString *editDist3FromStringNew(

  if( z==0 ) return 0;
  if( n<0 ) n = (int)strlen(z);
-  pStr = sqlite3_malloc( sizeof(*pStr) + sizeof(pStr->a[0])*n + n + 1 );
+  pStr = sqlite3_malloc64( sizeof(*pStr) + sizeof(pStr->a[0])*n + n + 1 );
  if( pStr==0 ) return 0;
  pStr->a = (EditDist3From*)&pStr[1];
  memset(pStr->a, 0, sizeof(pStr->a[0])*n);
@@ -833,13 +833,13 @@ static EditDist3FromString *editDist3FromStringNew(
      if( i+p->nFrom>n ) continue;
      if( matchFrom(p, z+i, n-i)==0 ) continue;
      if( p->nTo==0 ){
-        apNew = sqlite3_realloc(pFrom->apDel,
+        apNew = sqlite3_realloc64(pFrom->apDel,
                                sizeof(*apNew)*(pFrom->nDel+1));
        if( apNew==0 ) break;
        pFrom->apDel = apNew;
        apNew[pFrom->nDel++] = p;
      }else{
-        apNew = sqlite3_realloc(pFrom->apSubst,
+        apNew = sqlite3_realloc64(pFrom->apSubst,
                                sizeof(*apNew)*(pFrom->nSubst+1));
        if( apNew==0 ) break;
        pFrom->apSubst = apNew;
@@ -925,7 +925,7 @@ static int editDist3Core(
    m = stackSpace;
    pToFree = 0;
  }else{
-    m = pToFree = sqlite3_malloc( nByte );
+    m = pToFree = sqlite3_malloc64( nByte );
    if( m==0 ) return -1;            /* Out of memory */
  }
  a2 = (EditDist3To*)&m[n];
@@ -940,7 +940,7 @@ static int editDist3Core(
      if( i2+p->nTo>n2 ) continue;
      if( matchTo(p, z2+i2, n2-i2)==0 ) continue;
      a2[i2].nIns++;
-      apNew = sqlite3_realloc(a2[i2].apIns, sizeof(*apNew)*a2[i2].nIns);
+      apNew = sqlite3_realloc64(a2[i2].apIns, sizeof(*apNew)*a2[i2].nIns);
      if( apNew==0 ){
        res = -1;  /* Out of memory */
        goto editDist3Abort;
@@ -1118,7 +1118,7 @@ static void editDist3SqlFunc(
 */
 static int editDist3Install(sqlite3 *db){
  int rc;
-  EditDist3Config *pConfig = sqlite3_malloc( sizeof(*pConfig) );
+  EditDist3Config *pConfig = sqlite3_malloc64( sizeof(*pConfig) );
  if( pConfig==0 ) return SQLITE_NOMEM;
  memset(pConfig, 0, sizeof(*pConfig));
  rc = sqlite3_create_function_v2(db, "editdist3",
@@ -1607,7 +1607,7 @@ static const struct {
 ** should be freed by the caller.
 */
 static unsigned char *transliterate(const unsigned char *zIn, int nIn){
-  unsigned char *zOut = sqlite3_malloc( nIn*4 + 1 );
+  unsigned char *zOut = sqlite3_malloc64( nIn*4 + 1 );
  int c, sz, nOut;
  if( zOut==0 ) return 0;
  nOut = 0;
@@ -1930,7 +1930,7 @@ static int spellfix1Init(
  int i;

  nDbName = (int)strlen(zDbName);
-  pNew = sqlite3_malloc( sizeof(*pNew) + nDbName + 1);
+  pNew = sqlite3_malloc64( sizeof(*pNew) + nDbName + 1);
  if( pNew==0 ){
    rc = SQLITE_NOMEM;
  }else{
@@ -2044,7 +2044,7 @@ static void spellfix1ResetCursor(spellfix1_cursor *pCur){
 static void spellfix1ResizeCursor(spellfix1_cursor *pCur, int N){
  struct spellfix1_row *aNew;
  assert( N>=pCur->nRow );
-  aNew = sqlite3_realloc(pCur->a, sizeof(pCur->a[0])*N);
+  aNew = sqlite3_realloc64(pCur->a, sizeof(pCur->a[0])*N);
  if( aNew==0 && N>0 ){
    spellfix1ResetCursor(pCur);
    sqlite3_free(pCur->a);
@@ -2203,7 +2203,7 @@ static int spellfix1BestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
 static int spellfix1Open(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
  spellfix1_vtab *p = (spellfix1_vtab*)pVTab;
  spellfix1_cursor *pCur;
-  pCur = sqlite3_malloc( sizeof(*pCur) );
+  pCur = sqlite3_malloc64( sizeof(*pCur) );
  if( pCur==0 ) return SQLITE_NOMEM;
  memset(pCur, 0, sizeof(*pCur));
  pCur->pVTab = p;
@@ -2417,7 +2417,7 @@ static int spellfix1FilterForMatch(

  /* Load the cost table if we have not already done so */
  if( p->zCostTable!=0 && p->pConfig3==0 ){
-    p->pConfig3 = sqlite3_malloc( sizeof(p->pConfig3[0]) );
+    p->pConfig3 = sqlite3_malloc64( sizeof(p->pConfig3[0]) );
    if( p->pConfig3==0 ) return SQLITE_NOMEM;
    memset(p->pConfig3, 0, sizeof(p->pConfig3[0]));
    rc = editDist3ConfigLoad(p->pConfig3, p->db, p->zCostTable);
@@ -1,8 +1,8 @@
-C In\sthe\sVDBE\sloop,\sonly\scheck\sfor\sOOM\serrors\sat\sjumps\srather\sthan\safter\severy\nopcode,\sfor\sabout\sa\s0.5%\sperformance\sincrease.
-D 2016-02-03T22:14:38.812
+C More\swork\son\sWindows\s10\sSDK\sintegration.
+D 2016-02-05T19:40:23.877
 F Makefile.in 027c1603f255390c43a426671055a31c0a65fdb4
 F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
-F Makefile.msc 72b7858f02017611c3ac1ddc965251017fed0845
+F Makefile.msc 9eadde083c1ef0d0d2a253671c76e0b7e48a3dc6
 F README.md 8ecc12493ff9f820cdea6520a9016001cb2e59b7
 F VERSION 866588d1edf0ccb5b0d33896974338f97564f719
 F aclocal.m4 a5c22d164aff7ed549d53a90fa56d56955281f50
@@ -98,14 +98,14 @@ F ext/fts3/unicode/mkunicode.tcl 95cf7ec186e48d4985e433ff8a1c89090a774252
 F ext/fts3/unicode/parseunicode.tcl da577d1384810fb4e2b209bf3313074353193e95
 F ext/fts5/extract_api_docs.tcl a36e54ec777172ddd3f9a88daf593b00848368e0
 F ext/fts5/fts5.h ff9c2782e8ed890b0de2f697a8d63971939e70c7
-F ext/fts5/fts5Int.h 2095cc38e776f19cc083ca90e00772ea0b204ab3
+F ext/fts5/fts5Int.h efb02807dbe5a2bfb0ea592a472d1171cb553d53
 F ext/fts5/fts5_aux.c b9bcce753ef5b451267b2232f0ca153ddeb3951d
-F ext/fts5/fts5_buffer.c f6e0c6018ffc8e39fc0b333b5daa8b8d528ae6e4
+F ext/fts5/fts5_buffer.c ad4bb545c866eea6add1b0f84c2c5029cd689092
 F ext/fts5/fts5_config.c 0c384ebdd23fd055e2e50a93277b8d59da538238
 F ext/fts5/fts5_expr.c ff5c451a6d025909639ac0f0d0af0cc595b50feb
 F ext/fts5/fts5_hash.c 1b113977296cf4212c6ec667d5e3f2bd18036955
-F ext/fts5/fts5_index.c e634a4a05b066f7122db93558c871148bd9893f2
-F ext/fts5/fts5_main.c 7e8a5f27d504bc04e3de7f1cba8867f0332aee9d
+F ext/fts5/fts5_index.c 9706959f2188d97d72df750519fee7baccef9964
+F ext/fts5/fts5_main.c 6e23df904049edb498538bd3e22e53ec1ab6f4f7
 F ext/fts5/fts5_storage.c 2a1f44deae090cd711f02cec0c2af8e660360d24
 F ext/fts5/fts5_tcl.c f8731e0508299bd43f1a2eff7dbeaac870768966
 F ext/fts5/fts5_test_mi.c 1ec66ffdf7632077fbd773b7a6df5153272ec070
@@ -120,7 +120,7 @@ F ext/fts5/test/fts5_common.tcl 61ff0d1a29d98a91c4553b20b3f410d858834ee9
 F ext/fts5/test/fts5aa.test 7e814df4a0e6c22a6fe2d84f210fdc0b5068a084
 F ext/fts5/test/fts5ab.test 30325a89453280160106be411bba3acf138e6d1b
 F ext/fts5/test/fts5ac.test 55cad4275a1f5acabfe14d8442a8046b47e49e5f
-F ext/fts5/test/fts5ad.test 0ddaa5b692ff220100ee396228838f4331399eaa
+F ext/fts5/test/fts5ad.test 36995f0586f30f5602074e012b9224c71ec5171c
 F ext/fts5/test/fts5ae.test 612dcb51f4069226791ff14c17dbfb3138c56f20
 F ext/fts5/test/fts5af.test be858a96b1f5de66ba6d64f0021bd8b2408e126c
 F ext/fts5/test/fts5ag.test 27180de76c03036be75ee80b93d8c5f540014071
@@ -142,7 +142,7 @@ F ext/fts5/test/fts5content.test 9a952c95518a14182dc3b59e3c8fa71cda82a4e1
 F ext/fts5/test/fts5corrupt.test c2ad090192708150d50d961278df10ae7a4b8b62
 F ext/fts5/test/fts5corrupt2.test 26c0a39dd9ff73207e6229f83b50b21d37c7658c
 F ext/fts5/test/fts5corrupt3.test a2b537c120bdd43c79c42fe2438d7b8c81fe5599
-F ext/fts5/test/fts5detail.test 4e971d28e7336c61ab916fc287900355dab7054d
+F ext/fts5/test/fts5detail.test ef5c690535a797413acaf5ad9b8ab5d49972df69
 F ext/fts5/test/fts5dlidx.test 13871a14641017ae42f6f1055a8067bafd44cb3d
 F ext/fts5/test/fts5doclist.test 8edb5b57e5f144030ed74ec00ef6fa4294fed79b
 F ext/fts5/test/fts5ea.test b01e3a18cdfabbff8104a96a5242a06a68a998a0
@@ -206,14 +206,14 @@ F ext/misc/eval.c f971962e92ebb8b0a4e6b62949463ee454d88fa2
 F ext/misc/fileio.c d4171c815d6543a9edef8308aab2951413cd8d0f
 F ext/misc/fuzzer.c 4c84635c71c26cfa7c2e5848cf49fe2d2cfcd767
 F ext/misc/ieee754.c f190d0cc5182529acb15babd177781be1ac1718c
-F ext/misc/json1.c 7b1155f520d5e8ec1c005d978ac675e8a7f2688a
+F ext/misc/json1.c a27cf1eca6583f9b6e18abab5c2a9a82c4540ca9
 F ext/misc/nextchar.c 35c8b8baacb96d92abbb34a83a997b797075b342
 F ext/misc/percentile.c bcbee3c061b884eccb80e21651daaae8e1e43c63
 F ext/misc/regexp.c af92cdaa5058fcec1451e49becc7ba44dba023dc
 F ext/misc/rot13.c 1ac6f95f99b575907b9b09c81a349114cf9be45a
 F ext/misc/series.c b8fb7befd85b3a9b4a10e701b30b2b79ca92b6d4
 F ext/misc/showauth.c 732578f0fe4ce42d577e1c86dc89dd14a006ab52
-F ext/misc/spellfix.c db4cc4b7aa12384e6c19a289a39cd232d355413d
+F ext/misc/spellfix.c 525190484b7a9dbc6be646c4842274fff4f27d53
 F ext/misc/totype.c 4a167594e791abeed95e0a8db028822b5e8fe512
 F ext/misc/vfslog.c fe40fab5c077a40477f7e5eba994309ecac6cc95
 F ext/misc/vtshim.c babb0dc2bf116029e3e7c9a618b8a1377045303e
@@ -284,37 +284,37 @@ F spec.template 86a4a43b99ebb3e75e6b9a735d5fd293a24e90ca
 F sqlite.pc.in 42b7bf0d02e08b9e77734a47798d1a55a9e0716b
 F sqlite3.1 fc7ad8990fc8409983309bb80de8c811a7506786
 F sqlite3.pc.in 48fed132e7cb71ab676105d2a4dc77127d8c1f3a
-F src/alter.c 3fe13e97ab38317b092e2f3ae11267b40c9b5cbd
-F src/analyze.c 0043d3e501f04297fed2bb50b488bc08d5c39f36
-F src/attach.c 07b3a34a1702dce92a7f1d3888c0c06222b63760
+F src/alter.c e4a5132e6264e002ab87c268108f416df3f1fb10
+F src/analyze.c fbf0e80d83cc893734e872f932f249a056b86e11
+F src/attach.c c16c2648a577fa3def2adfa48c28901376389bc5
 F src/auth.c b56c78ebe40a2110fd361379f7e8162d23f92240
 F src/backup.c 2869a76c03eb393ee795416e2387005553df72bc
 F src/bitvec.c 1a78d450a17c5016710eec900bedfc5729bf9bdf
 F src/btmutex.c bc87dd3b062cc26edfe79918de2200ccb8d41e73
-F src/btree.c a2a0244ea3f0b3f57f75019c2f229c744ca5d202
+F src/btree.c 0b359bcc2316a57acf12f583253974ad22b4654f
 F src/btree.h 368ceeb4bd9312dc8df2ffd64b4b7dbcf4db5f8e
 F src/btreeInt.h c18b7d2a3494695133e4e60ee36061d37f45d9a5
-F src/build.c 33dea2cef04c16a902c55f9d83b1a2065f213979
-F src/callback.c 29ae4faba226c7ebb9aee93016b5ce8a8f071261
+F src/build.c 198eaa849c193f28b802ed135b2483c68ef7a35c
+F src/callback.c ed6c2a4a712eb7287ff64e20e3c23265dfb8a7ce
 F src/complete.c addcd8160b081131005d5bc2d34adf20c1c5c92f
 F src/ctime.c 60e135af364d777a9ab41c97e5e89cd224da6198
-F src/date.c 997651e3ee6c2818fbf7fcdb7156cef9eb3ece20
+F src/date.c ca17321bc17cca8f40e0843edea4fafff974998e
 F src/dbstat.c b2ec6793eef97aebb4d171d490a4ffdfa9f2475c
-F src/delete.c 33ed87dc0746b1f8ce186f62b608bf40801af9c0
-F src/expr.c d10c1cdef5810cdbf73adc9f9b383684230b360a
+F src/delete.c 48802aa3ee6339f576d074336d3ae1b5f40e240f
+F src/expr.c fbf0706199aea23c54efe36b6932d8307c4eb872
 F src/fault.c 160a0c015b6c2629d3899ed2daf63d75754a32bb
-F src/fkey.c c66d3e5b35d4d95b5c1e2ee6c12f5df13a7f9ad6
-F src/func.c 42b24923328f65849f52f1659efb2a0907ad78fd
+F src/fkey.c 08edad1fce30f761f14b3997e89bad58f9f7f4e0
+F src/func.c 86e55fee35b9577e485f47d9dd5c1d34cd513288
 F src/global.c bd5a0af3f30b0c01be6db756c626cd3c33a3d260
 F src/hash.c 4263fbc955f26c2e8cdc0cf214bc42435aa4e4f5
 F src/hash.h c8f3c31722cf3277d03713909761e152a5b81094
 F src/hwtime.h d32741c8f4df852c7d959236615444e2b1063b08
-F src/insert.c 3e2462294fc8bc6e46f377ec824ff315e79fc36d
+F src/insert.c b84359365bace233919db550a15f131923190efc
 F src/journal.c b4124532212b6952f42eb2c12fa3c25701d8ba8d
-F src/legacy.c ba1863ea58c4c840335a84ec276fc2b25e22bc4e
+F src/legacy.c b1b0880fc474abfab89e737b0ecfde0bd7a60902
 F src/loadext.c 84996d7d70a605597d79c1f1d7b2012a5fd34f2b
-F src/main.c b686dabe9a7ece9121da87120d5c7bf402d77eb3
-F src/malloc.c b67c26c359c13836d370350b3f43d228dff5b360
+F src/main.c 62b7fe3ed245757d1ff2e6268a7ec0bc30100308
+F src/malloc.c 55ebb1701ebd39985dbcc497aaecb09192b69682
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c 6919bcf12f221868ea066eec27e579fed95ce98b
 F src/mem2.c f1940d9e91948dd6a908fbb9ce3835c36b5d83c3
@@ -332,28 +332,28 @@ F src/os.c 8fd25588eeba74068d41102d26810e216999b6c8
 F src/os.h 3e57a24e2794a94d3cf2342c6d9a884888cd96bf
 F src/os_common.h abdb9a191a367793268fe553d25bab894e986a0e
 F src/os_setup.h c9d4553b5aaa6f73391448b265b89bed0b890faa
-F src/os_unix.c 5bb20172d0c9a6afcfa829a88c406970593c848d
+F src/os_unix.c 821ed110197175165cf2f50b0930c7ff9a24504c
 F src/os_win.c ccf29ddded3e41e506b6bd98c1171aa0963b23f2
 F src/os_win.h eb7a47aa17b26b77eb97e4823f20a00b8bda12ca
-F src/pager.c 3e189231fc662710964b54862450bc7f69f313c2
+F src/pager.c 67cd2fbab58d0e35fed5f81432856f4f0af9fc6d
 F src/pager.h f3eb324a3ff2408b28bab7e81c1c55c13720f865
-F src/parse.y 426a91fbbbf7cdde3fd4b8798de7317a8782bec5
+F src/parse.y d7bff41d460f2df96fb890f36700e85cb0fc5634
 F src/pcache.c 73895411fa6b7bd6f0091212feabbe833b358d23
 F src/pcache.h 4d0ccaad264d360981ec5e6a2b596d6e85242545
 F src/pcache1.c 72f644dc9e1468c72922eff5904048427b817051
-F src/pragma.c 3c4f3fadf05893e289f2adf3a20c671a842cadec
+F src/pragma.c 80ee77226d0008d9188356a6cbbe6010866e1bee
 F src/pragma.h 64c78a648751b9f4f297276c4eb7507b14b4628c
-F src/prepare.c db85f0451ba93ecb3c1e497c279abece5cb5aead
-F src/printf.c 98a5cef7fc84577ab8a3098cfa48ecfa5a70b9f8
+F src/prepare.c c12b786713df3e8270c0f85f988c5359d8b4d87c
+F src/printf.c 63e6fb12bbe702dd664dc3703776c090383a5a26
 F src/random.c ba2679f80ec82c4190062d756f22d0c358180696
 F src/resolve.c 9f7ce3a3c087afb7597b7c916c99126ff3f12f0c
-F src/rowset.c eccf6af6d620aaa4579bd3b72c1b6395d9e9fa1e
-F src/select.c ea6f3b0c279aa37eb3701792d094673a7ad1bf88
+F src/rowset.c 9fe4b3ad7cc00944386bb600233d8f523de07a6e
+F src/select.c 57646a44ba9a0bc4aa926ae9c79b8199c246844b
 F src/shell.c dcd7a83645ef2a58ee9c6d0ea4714d877d7835c4
 F src/sqlite.h.in cf22ad1d52dca2c9862d63833e581028119aab7e
 F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
 F src/sqlite3ext.h dfbe62ffd95b99afe2140d8c35b180d11924072d
-F src/sqliteInt.h bf8c17fb55d7cd09b477111212b19d661b134989
+F src/sqliteInt.h 3aeaff9611acd790c8e76719b33db09ab885d537
 F src/sqliteLimit.h 216557999cb45f2e3578ed53ebefe228d779cb46
 F src/status.c 70912d7be68e9e2dbc4010c93d344af61d4c59ba
 F src/table.c 51b46b2a62d1b3a959633d593b89bab5e2c9155e
@@ -376,7 +376,7 @@ F src/test_config.c 0dee90328e3dedf8ba002ee94b6a7e7ea7726fe4
 F src/test_demovfs.c 0de72c2c89551629f58486fde5734b7d90758852
 F src/test_devsym.c e7498904e72ba7491d142d5c83b476c4e76993bc
 F src/test_fs.c a61f54247fdb843761d709879c3bcd1989b2050c
-F src/test_func.c 0d9c25956152adefee8881c6fadc8354793764d0
+F src/test_func.c 37453d346cfcf118774efd5bf6187f7e6a7e3254
 F src/test_hexio.c abfdecb6fa58c354623978efceb088ca18e379cd
 F src/test_init.c 66b33120ffe9cd853b5a905ec850d51151337b32
 F src/test_intarray.c 870124b95ec4c645d4eb84f15efb7133528fb1a5
@@ -406,31 +406,31 @@ F src/test_windirent.c 8f5fada630348558d5745b334702f301da1ffc61
 F src/test_windirent.h b12055cab6227f7be10f5c19296f67c60cc5e2a5
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/threads.c bbfb74450643cb5372a43ad4f6cffd7e9dfcecb0
-F src/tokenize.c 5606871a377f390af7040ec3c12e0d183512d785
+F src/tokenize.c 214b783d6138e9f9fbb6b225ce9a376db3b03d42
 F src/treeview.c dc39ccf04e9331237388b9cb73289c9d87ea050b
-F src/trigger.c 72d876b2d0c66604a112362bdae07dae9b104816
-F src/update.c 17332f9fe818cbc0444c36a811800af8498af4c3
+F src/trigger.c e14840ee0c3e549e758ec9bf3e4146e166002280
+F src/update.c 310ca7adb86a7d1f2afae46905b21c83580f3e17
 F src/utf.c 10cc2519e82e3369344d0969ad4b1a333dc86d18
-F src/util.c 72d40df0a52d3f30b462a15f0e094fcbade6dc82
+F src/util.c 49ce0a65306c1c51d61cb5bc214c71cb62452de6
 F src/vacuum.c 2ddd5cad2a7b9cef7f9e431b8c7771634c6b1701
-F src/vdbe.c f0c2e2fb8cbff761ea8602058406c151b9325e8d
+F src/vdbe.c c193299e595a13eba247738e22fce25c49346a6c
 F src/vdbe.h 7a733ea8aac1b77305a67698e784fa3484ee3337
 F src/vdbeInt.h 4b69d5451bcadd473e745af53ef1e8abfdce0a79
-F src/vdbeapi.c 9d640d5efd9a140a6bda8da53b220aa258167993
-F src/vdbeaux.c 23b38b447ebf5991de1d3d456003c58cf523a5da
+F src/vdbeapi.c 9324f6baee1a1b2284c6543e98f916888a81e459
+F src/vdbeaux.c 49b536284c2b8a823dd342d653e18145ca2b393a
 F src/vdbeblob.c 3b570b730109e8f653d9d2081649f6e7015113db
-F src/vdbemem.c b9181e77eca2a095929d46250daf85c8d2621fc0
+F src/vdbemem.c 68fcfac37dc6601d98c32cc5adee4d39f2c1b7b4
 F src/vdbesort.c ef3c6d1f1a7d44cf67bb2bee59ea3d1fe5bad174
 F src/vdbetrace.c f75c5455d8cf389ef86a8bfdfd3177e0e3692484
-F src/vtab.c 320682cca733115b4cbe71320b5c5eeb1074ebde
+F src/vtab.c bef51b4f693d82b4b0184457faa8625654534091
 F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
 F src/wal.c d21b99fd1458159d0b1ecdccc8ee6ada4fdc4c54
 F src/wal.h 2f7c831cf3b071fa548bf2d5cac640846a7ff19c
 F src/walker.c 0f142b5bd3ed2041fc52d773880748b212e63354
-F src/where.c af9bf5dcec1a0e52726c550924aa91d837166251
+F src/where.c d89fd5cff448ab5c5ca492dd9793b35ffe31ab35
 F src/whereInt.h 78b6b4de94db84aecbdc07fe3e38f648eb391e9a
-F src/wherecode.c 923f5d04b379b7417bc29f3b86b5eae9d1923d72
-F src/whereexpr.c 197a448b52073aee43eca3a2233fc113369eb2d4
+F src/wherecode.c 791a784bbf8749d560fdb0b990b607bc4f44a38d
+F src/whereexpr.c de117970b29471177a6901d60ad83a194671dc03
 F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
 F test/affinity2.test a6d901b436328bd67a79b41bb0ac2663918fe3bd
 F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
@@ -450,11 +450,11 @@ F test/analyze5.test 765c4e284aa69ca172772aa940946f55629bc8c4
 F test/analyze6.test f1c552ce39cca4ec922a7e4e0e5d0203d6b3281f
 F test/analyze7.test bb1409afc9e8629e414387ef048b8e0e3e0bdc4f
 F test/analyze8.test c05a461d0a6b05991106467d0c47480f2e709c82
-F test/analyze9.test 3dd9e203fad353ec8027b18a6d9a92af59f4e727
+F test/analyze9.test 88c1f2aa20b614236f03e1cc38c3619e7e8a38b4
 F test/analyzeA.test 3335697f6700c7052295cfd0067fc5b2aacddf9a
-F test/analyzeB.test 8bf35ee0a548aea831bf56762cb8e7fdb1db083d
+F test/analyzeB.test a4c1c3048f6d9e090eb76e83eecb18bcf6d31a70
 F test/analyzeC.test 555a6cc388b9818b6eda6df816f01ce0a75d3a93
-F test/analyzeD.test 08f9d0bee4e118a66fff3a32d02dbe0ee0a2b594
+F test/analyzeD.test f3d77cd0fefe2849d784897d52df13beee19271d
 F test/analyzeE.test 8684e8ac5722fb97c251887ad97e5d496a98af1d
 F test/analyzeF.test 5d1fe1024ba2dfea3c18bede8c1ccef8aba1ab34
 F test/analyzer1.test 498e2ff4b62740c2751c3a2f8b744fe26689fae9
@@ -513,7 +513,7 @@ F test/btree02.test fe69453d474d8154d19b904157ff1db4812fed99
 F test/btreefault.test c2bcb542685eea44621275cfedbd8a13f65201e3
 F test/busy.test 76b4887f8b9160ba903c1ac22e8ff406ad6ae2f0
 F test/cache.test 13bc046b26210471ca6f2889aceb1ea52dc717de
-F test/cacheflush.test a755c93482ce2e20c04825304bef27e7b7ea0111
+F test/cacheflush.test af25bb1509df04c1da10e38d8f322d66eceedf61
 F test/capi2.test 011c16da245fdc0106a2785035de6b242c05e738
 F test/capi3.test bf6f0308bbbba1e770dac13aa08e5c2ac61c7324
 F test/capi3b.test efb2b9cfd127efa84433cd7a2d72ce0454ae0dc4
@@ -521,7 +521,7 @@ F test/capi3c.test 06f6261f9e9b4ef6f76afcd9900f3665408af1c8
 F test/capi3d.test 485048dc5cd07bc68011e4917ad035ad6047ab82
 F test/capi3e.test 3d49c01ef2a1a55f41d73cba2b23b5059ec460fe
 F test/cast.test 4c275cbdc8202d6f9c54a3596701719868ac7dc3
-F test/cffault.test 1647eef45512817265c360ed4539538eed26ac69
+F test/cffault.test aadc1f61f8811cb600e3e069acbf8796f472a096
 F test/check.test 5831ddb6f2c687782eaf2e1a07b6e17f24c4f763
 F test/close.test 340bd24cc58b16c6bc01967402755027c37eb815
 F test/closure01.test b1703ba40639cfc9b295cf478d70739415eec6a4
@@ -558,10 +558,10 @@ F test/corruptD.test b3c205fac7952b1de645ce44bb02335cd9e3e040
 F test/corruptE.test be8e5088c369fc7979c662cd644efdaafc0f7f6d
 F test/corruptF.test be9fde98e4c93648f1ba52b74e5318edc8f59fe4
 F test/corruptG.test 1ab3bf97ee7bdba70e0ff3ba2320657df55d1804
-F test/corruptH.test 5dd4fa98c6c1ed33b178f9e8a48c4fdd3cfc9067
-F test/corruptI.test f2b10e4fec2a4315bca2b936ffa52ccbffac3422
+F test/corruptH.test 99ad81a4bda7cc078c589ef7542ecbc64e453c80
+F test/corruptI.test 347babbf970e7947e3f91dccf7a1bec28a1bab04
 F test/corruptJ.test 9e29e7a81ee3b6ac50f77ea7a9e2f3fa03f32d91
-F test/cost.test 19d314526616ce4473eb4e4e450fcb94499ce318
+F test/cost.test 1eedbfd868f806f3fa08ff072b04cf270dcf61c8
 F test/count.test cb2e0f934c6eb33670044520748d2ecccd46259c
 F test/coveridxscan.test cdb47d01acc4a634a34fd25abe85189e0d0f1e62
 F test/crash.test fb9dc4a02dcba30d4aa5c2c226f98b220b2b959f
@@ -592,10 +592,10 @@ F test/descidx3.test 09ddbe3f5295f482d2f8b687cf6db8bad7acd9a2
 F test/diskfull.test 106391384780753ea6896b7b4f005d10e9866b6e
 F test/distinct.test a1783b960ad8c15a77cd9f207be072898db1026c
 F test/distinctagg.test 1a6ef9c87a58669438fc771450d7a72577417376
-F test/e_blobbytes.test 9bea1d3e2b20f3010b04abba58f6ba172301f49f
-F test/e_blobclose.test df756753f571bc30e42e3a6cba2807576e49e716
-F test/e_blobopen.test 234f960d90235a9b51ec3ca1e062e8541dd558d8
-F test/e_blobwrite.test 615b405f29feb2cfb5a1f03dab7933258294fa26
+F test/e_blobbytes.test 439a945953b35cb6948a552edaec4dc31fd70a05
+F test/e_blobclose.test 4b3c8c60c2171164d472059c73e9f3c1844bb66d
+F test/e_blobopen.test e95e1d40f995056f6f322cd5e1a1b83a27e1a145
+F test/e_blobwrite.test 650ded42ee5e0c2dbf263583ce01adf280129599
 F test/e_changes.test fd66105385153dbf21fdb35eb8ef6c3e1eade579
 F test/e_createtable.test d4c6059d44dcd4b636de9aae322766062b471844
 F test/e_delete.test ab39084f26ae1f033c940b70ebdbbd523dc4962e
@@ -615,7 +615,7 @@ F test/e_uri.test eed3eb41b22d051a1164110dacdc778899126e14
 F test/e_vacuum.test 5bfbdc21b65c0abf24398d0ba31dc88d93ca77a9
 F test/e_wal.test ae9a593207a77d711443ee69ffe081fda9243625
 F test/e_walauto.test 280714ddf14e1a47dcbc59d515cd0b026dfd5567
-F test/e_walckpt.test 65e29b6631e51f210f83e4ff11571e647ba93608
+F test/e_walckpt.test 28c371a6bb5e5fe7f31679c1df1763a19d19e8a0
 F test/e_walhook.test da3ea8b3483d1af72190337bda50155a91a4b664
 F test/enc.test e54531cd6bf941ee6760be041dff19a104c7acea
 F test/enc2.test 83437a79ba1545a55fb549309175c683fb334473
@@ -641,9 +641,9 @@ F test/fkey4.test 86446017011273aad8f9a99c1a65019e7bd9ca9d
 F test/fkey5.test 5a373303f201ac03c22ba1ef17a733d3f56e611a
 F test/fkey6.test abb59f866c1b44926fd02d1fdd217d831fe04f48
 F test/fkey7.test 72e915890ee4a005daaf3002cb208e8fe973ac13
-F test/fkey8.test 8f08203458321e6c19a263829de4cfc936274ab0
+F test/fkey8.test 7bd1dd0174a0e29a90c62c517b9e2a410a0b345d
 F test/fkey_malloc.test 594a7ea1fbab553c036c70813cd8bd9407d63749
-F test/fordelete.test 57ed9b953eeace09dd2eac3251b40bf9d6990aec
+F test/fordelete.test eb93a2f34137bb87bdab88fcab06c0bd92719aff
 F test/format4.test 1f0cac8ff3895e9359ed87e41aaabee982a812eb
 F test/fts-9fd058691.test 78b887e30ae6816df0e1fed6259de4b5a64ad33c
 F test/fts1a.test 46090311f85da51bb33bd5ce84f7948359c6d8d7
@@ -704,7 +704,7 @@ F test/fts3aux2.test 7ae2b2c13aefdf4169279a27a5f51780ce57f6ba
 F test/fts3b.test e93bbb653e52afde110ad53bbd793f14fe7a8984
 F test/fts3c.test fc723a9cf10b397fdfc2b32e73c53c8b1ec02958
 F test/fts3comp1.test a0f5b16a2df44dd0b15751787130af2183167c0c
-F test/fts3conf.test ff90127b2462c788348c0dd7f6f8c573ef9cb5d9
+F test/fts3conf.test 1c8b8adb0ab28a41b68d1514df44380bd7353402
 F test/fts3corrupt.test 2710b77983cc7789295ddbffea52c1d3b7506dbb
 F test/fts3corrupt2.test 6d96efae2f8a6af3eeaf283aba437e6d0e5447ba
 F test/fts3cov.test e0fb00d8b715ddae4a94c305992dfc3ef70353d7
@@ -717,40 +717,40 @@ F test/fts3e.test 1f6c6ac9cc8b772ca256e6b22aaeed50c9350851
 F test/fts3expr.test 3401d47b229c4504424caf362cc4ff704cad4162
 F test/fts3expr2.test 18da930352e5693eaa163a3eacf96233b7290d1a
 F test/fts3expr3.test c4d4a7d6327418428c96e0a3a1137c251b8dfbf8
-F test/fts3expr4.test e1be1248566f43c252d4404d52914f1fc4bfa065
+F test/fts3expr4.test c39a15d676b14fc439d9bf845aa7bddcf4a74dc3
 F test/fts3expr5.test f9abfffbf5e53d48a33e12a1e8f8ba2c551c9b49
 F test/fts3fault.test da49627b280b210ebc6657f76344c7851f10ce66
 F test/fts3fault2.test f953bb3cf903988172270a9a0aafd5a890b0f98f
 F test/fts3first.test dbdedd20914c8d539aa3206c9b34a23775644641
-F test/fts3join.test 53e66a0c21eb568580674a43b21c059acb26f499
+F test/fts3join.test 34750f3ce1e29b2749eaf0f1be2fa6301c5d50da
 F test/fts3malloc.test b0e4c133b8d61d4f6d112d8110f8320e9e453ef6
-F test/fts3matchinfo.test 07009313ad6c082f94d8c9c3228eb8940c93ac71
+F test/fts3matchinfo.test ce864e0bd92429df8008f31cf557269ba172482a
 F test/fts3near.test 7e3354d46f155a822b59c0e957fd2a70c1d7e905
-F test/fts3offsets.test 5b8ec5be27dd2070af3538b23c67f1ca8c822853
+F test/fts3offsets.test b85fd382abdc78ebce721d8117bd552dfb75094c
 F test/fts3prefix.test fa794eaab0bdae466494947b0b153d7844478ab2
 F test/fts3prefix2.test e1f0a822ca661dced7f12ce392e14eaf65609dce
 F test/fts3query.test f33eb71a1fe1084ea585eeb7ee76b390729f5170
 F test/fts3rnd.test 1320d8826a845e38a96e769562bf83d7a92a15d0
 F test/fts3shared.test 57e26a801f21027b7530da77db54286a6fe4997e
-F test/fts3snippet.test 63dbd687d5bf5191f1b8e6a0977aa9c1e28a7004
+F test/fts3snippet.test 01a4231816e03a0660ae53ba2404fe69012fe0db
 F test/fts3sort.test ed34c716a11cc2009a35210e84ad5f9c102362ca
 F test/fts3tok1.test 178c050199af8c05299b1ad572514ce1c54b7827
 F test/fts3tok_err.test 52273cd193b9036282f7bacb43da78c6be87418d
 F test/fts3varint.test 752c08ed5d32c5d7dc211b056f4ed68a76b7e36e
 F test/fts4aa.test 10aac8e9d62c7357590acfabe3fad01e9a9ce1cb
-F test/fts4check.test 9d9e818fd6cb29c0e007cd6d00447739d4fde430
-F test/fts4content.test 8707425b926663f8ca81de866c007900442b5ec0
+F test/fts4check.test c3056eab9524232e4c9bdcd119912947e07bcc1c
+F test/fts4content.test 05716af19a899cd70d5cd916c580043c03f30db4
 F test/fts4docid.test e33c383cfbdff0284685604d256f347a18fdbf01
-F test/fts4growth.test df10fde9f47cf5c71861e63fd8efcd573c4f7e53
-F test/fts4growth2.test 2f063be1902a73cd087355837c52fed42ac11a5d
+F test/fts4growth.test 60d6bb3f78e25b34f533797dd9f2f9402310a13a
+F test/fts4growth2.test 13ad4e76451af6e6906c95cdc725d01b00044269
 F test/fts4incr.test 4e353a0bd886ea984e56fce9e77724fc923b8d0d
 F test/fts4langid.test 24a6e41063b416bbdf371ff6b4476fa41c194aa7
 F test/fts4merge.test c424309743fdd203f8e56a1f1cd7872cd66cc0ee
 F test/fts4merge2.test 5faa558d1b672f82b847d2a337465fa745e46891
 F test/fts4merge3.test aab02a09f50fe6baaddc2e159c3eabc116d45fc7
 F test/fts4merge4.test d895b1057a7798b67e03455d0fa50e9ea836c47b
-F test/fts4noti.test 524807f0c36d49deea7920cdd4cd687408b58849
-F test/fts4onepass.test bfca61f69c6ca74cd71e6dca12a0cdd47192fc24
+F test/fts4noti.test 5553d7bb2e20bf4a06b23e849352efc022ce6309
+F test/fts4onepass.test 7319d61a2ed1325fc54afd0c060a0513b462303a
 F test/fts4unicode.test 27378af76394542cf490cf001d8d1505fe55f6a9
 F test/full.test 6b3c8fb43c6beab6b95438c1675374b95fab245d
 F test/func.test ae97561957aba6ca9e3a7b8a13aac41830d701ef
@@ -761,7 +761,7 @@ F test/func5.test cdd224400bc3e48d891827cc913a57051a426fa4
 F test/fuzz-oss1.test 4912e528ec9cf2f42134456933659d371c9e0d74
 F test/fuzz.test 96083052bf5765e4518c1ba686ce2bab785670d1
 F test/fuzz2.test 76dc35b32b6d6f965259508508abce75a6c4d7e1
-F test/fuzz3.test 53fabcd5f0f430f8b221282f6c12c4d0903c21eb
+F test/fuzz3.test b47377143f0c80f91ed29d722861077ff34415d5
 F test/fuzz_common.tcl a87dfbb88c2a6b08a38e9a070dabd129e617b45b
 F test/fuzz_malloc.test 328f70aaca63adf29b4c6f06505ed0cf57ca7c26
 F test/fuzzcheck.c 3309d793165ca61a9996271cb799694839348f9a
@@ -769,7 +769,8 @@ F test/fuzzdata1.db 7ee3227bad0e7ccdeb08a9e6822916777073c664
 F test/fuzzdata2.db f03a420d3b822cc82e4f894ca957618fbe9c4973
 F test/fuzzdata3.db c6586d3e3cef0fbc18108f9bb649aa77bfc38aba
 F test/fuzzdata4.db 1882f0055fb63214d8407ddc7aca9b0b1c59af21
-F test/fuzzer1.test d4c52aaf3ef923da293a2653cfab33d02f718a36
+F test/fuzzer1.test 3d4c4b7e547aba5e5511a2991e3e3d07166cfbb8
+F test/fuzzer2.test a85ef814ce071293bce1ad8dffa217cbbaad4c14
 F test/fuzzerfault.test 8792cd77fd5bce765b05d0c8e01b9edcf8af8536
 F test/genesis.tcl 1e2e2e8e5cc4058549a154ff1892fe5c9de19f98
 F test/hexlit.test d7b0a5f41123df1e43985b91b8b2e70f95282d21
@@ -789,7 +790,7 @@ F test/incrblob3.test d8d036fde015d4a159cd3cbae9d29003b37227a4
 F test/incrblob4.test f26502a5697893e5acea268c910f16478c2f0fab
 F test/incrblob_err.test af1f12ba60d220c9752073ff2bda2ad59e88960d
 F test/incrblobfault.test 280474078f6da9e732cd2a215d3d854969014b6e
-F test/incrcorrupt.test 9786cba68c5832f01887fde1c06b43c3904d86f6
+F test/incrcorrupt.test 6c567fbf870aa9e91866fe52ce6f200cd548939a
 F test/incrvacuum.test d2a6ddf5e429720b5fe502766af747915ccf6c32
 F test/incrvacuum2.test 676c41428765d58f1da7dbe659ef27726d3d30ac
 F test/incrvacuum3.test 75256fb1377e7c39ef2de62bfc42bbff67be295a
@@ -833,7 +834,7 @@ F test/journal3.test ff8af941f9e06161d3db1b46bb9f965ff0e7f307
 F test/jrnlmode.test 7864d59cf7f6e552b9b99ba0f38acd167edc10fa
 F test/jrnlmode2.test 81610545a4e6ed239ea8fa661891893385e23a1d
 F test/jrnlmode3.test 556b447a05be0e0963f4311e95ab1632b11c9eaa
-F test/json101.test f0178422b3a2418f423fd0d3caf3571c8d1b9863
+F test/json101.test ef42283f0b60d8bacbc2243448e7c84988578e52
 F test/json102.test bf3fe7a706d30936a76a0f7a0375e1e8e73aff5a
 F test/json103.test c5f6b85e69de05f6b3195f9f9d5ce9cd179099a0
 F test/keyword1.test 37ef6bba5d2ed5b07ecdd6810571de2956599dff
@@ -875,8 +876,8 @@ F test/mallocG.test 0ff91b65c50bdaba680fb75d87fe4ad35bb7934f
 F test/mallocH.test 79b65aed612c9b3ed2dcdaa727c85895fd1bfbdb
 F test/mallocI.test a88c2b9627c8506bf4703d8397420043a786cdb6
 F test/mallocJ.test b5d1839da331d96223e5f458856f8ffe1366f62e
-F test/mallocK.test da01dcdd316767b8356741f8d33a23a06a23def5
-F test/mallocL.test 252ddc7eb4fbf75364eab17b938816085ff1fc17
+F test/mallocK.test 27cb5566a6e5f2d76f9d4aa2eca45524401fd61e
+F test/mallocL.test fb311ff80afddf3b1a75e52289081f4754d901dc
 F test/malloc_common.tcl aac62499b76be719fac31e7a3e54a7fd53272e7f
 F test/manydb.test 28385ae2087967aa05c38624cec7d96ec74feb3e
 F test/mem5.test c6460fba403c5703141348cd90de1c294188c68f
@@ -897,9 +898,10 @@ F test/misc6.test 953cc693924d88e6117aeba16f46f0bf5abede91
 F test/misc7.test edd0b63e2ee29a256900b0514f6fff27e19e9bb2
 F test/misc8.test fc2754d38892f7dac30c22db3616c2764f117d66
 F test/misuse.test 3c34719944ba045cc6c188a4852ba04680728912
-F test/mmap1.test 1bfd611b9841eafb44f7d83c0788e146d84a33c9
+F test/mmap1.test 44a5ff1c1bcc7dcf2de50227d1f997e75a8ef1ae
 F test/mmap2.test 9d6dd9ddb4ad2379f29cc78f38ce1e63ed418022
 F test/mmap3.test c92273e16eb8d23c1d55c9815b446bb72ef0512e
+F test/mmap4.test 2e2b4e32555b58da15176e6fe750f17c9dcf7f93
 F test/mmapfault.test d4c9eff9cd8c2dc14bc43e71e042f175b0a26fe3
 F test/multiplex.test efd015ca0b5b4a57dc9535b8feb1273eebeadb60
 F test/multiplex2.test 580ca5817c7edbe4cc68fa150609c9473393003a
@@ -928,7 +930,7 @@ F test/orderby7.test 3d1383d52ade5b9eb3a173b3147fdd296f0202da
 F test/orderby8.test 23ef1a5d72bd3adcc2f65561c654295d1b8047bd
 F test/orderby9.test 87fb9548debcc2cd141c5299002dd94672fa76a3
 F test/oserror.test b32dc34f2363ef18532e3a0a7358e3e7e321974f
-F test/ovfl.test 4f7ca651cba5c059a12d8c67dddd49bec5747799
+F test/ovfl.test 199c482696defceacee8c8e0e0ef36da62726b2f
 F test/pager1.test 1acbdb14c5952a72dd43129cabdbf69aaa3ed1fa
 F test/pager2.test 67b8f40ae98112bcdba1f2b2d03ea83266418c71
 F test/pager3.test 3856d9c80839be0668efee1b74811b1b7f7fc95f
@@ -942,9 +944,9 @@ F test/parser1.test 222b5cbf3e2e659fec1bf7d723488c8b9c94f1d0
 F test/pcache.test c8acbedd3b6fd0f9a7ca887a83b11d24a007972b
 F test/pcache2.test af7f3deb1a819f77a6d0d81534e97d1cf62cd442
 F test/percentile.test 4243af26b8f3f4555abe166f723715a1f74c77ff
-F test/permutations.test 4ea119731c62d2f7d0aa86dd5b184cbb61ca411b
+F test/permutations.test 382a43c49f49bafe6fddffe904ea33d6bb3ff33e
 F test/pragma.test 507ac7ef2ea5682241ea0ef041799ca70bb5e0bf
-F test/pragma2.test a9400a7289605280576098b97f5cde3f204075c0
+F test/pragma2.test e5d5c176360c321344249354c0c16aec46214c9f
 F test/pragma3.test 6f849ccffeee7e496d2f2b5e74152306c0b8757c
 F test/printf.test b3ff34e73d59124140eaf89f7672e21bc2ca5fcc
 F test/printf2.test 0b61566dd1c0f0b802f59dffa228c5dc5aa6b054
@@ -953,7 +955,7 @@ F test/ptrchng.test ef1aa72d6cf35a2bbd0869a649b744e9d84977fc
 F test/queryonly.test 5f653159e0f552f0552d43259890c1089391dcca
 F test/quick.test 1681febc928d686362d50057c642f77a02c62e57
 F test/quota-glob.test 32901e9eed6705d68ca3faee2a06b73b57cb3c26
-F test/quota.test 2379902c25e291eac5c12b4cf96946a3447e3744
+F test/quota.test 36cd78b178c4eb0401d4f25754ef410fbd9df2a7
 F test/quota2.test 7dc12e08b11cbc4c16c9ba2aa2e040ea8d8ab4b8
 F test/quote.test 215897dbe8de1a6f701265836d6601cc6ed103e6
 F test/randexpr1.tcl 40dec52119ed3a2b8b2a773bce24b63a3a746459
@@ -965,8 +967,8 @@ F test/reindex.test 44edd3966b474468b823d481eafef0c305022254
 F test/releasetest.tcl 975449bf742b8bb9025208292208af816a1fcb58
 F test/resolver01.test f4022acafda7f4d40eca94dbf16bc5fc4ac30ceb
 F test/rollback.test 458fe73eb3ffdfdf9f6ba3e9b7350a6220414dea
-F test/rollback2.test fc14cf6d1a2b250d2735ef16124b971bce152f14
-F test/rollbackfault.test 6a004f71087cc399296cffbb5429ea6da655ae65
+F test/rollback2.test 8435d6ff0f13f51d2a4181c232e706005fa90fc5
+F test/rollbackfault.test 0e646aeab8840c399cfbfa43daab46fd609cf04a
 F test/rowallock.test 3f88ec6819489d0b2341c7a7528ae17c053ab7cc
 F test/rowhash.test 0bc1d31415e4575d10cacf31e1a66b5cc0f8be81
 F test/rowid.test 5b7509f384f4f6fae1af3c8c104c8ca299fea18d
@@ -974,11 +976,11 @@ F test/rtree.test 0c8d9dd458d6824e59683c19ab2ffa9ef946f798
 F test/run-wordcount.sh 891e89c4c2d16e629cd45951d4ed899ad12afc09
 F test/savepoint.test c671fdbd34cd3bfe1518a777526ada595180cf8d
 F test/savepoint2.test 9b8543940572a2f01a18298c3135ad0c9f4f67d7
-F test/savepoint3.test e328085853b14898d78ceea00dfe7db18bb6a9ec
 F test/savepoint4.test c8f8159ade6d2acd9128be61e1230f1c1edc6cc0
 F test/savepoint5.test 0735db177e0ebbaedc39812c8d065075d563c4fd
 F test/savepoint6.test f41279c5e137139fa5c21485773332c7adb98cd7
 F test/savepoint7.test db3db281486c925095f305aad09fe806e5188ff3
+F test/savepointfault.test f044eac64b59f09746c7020ee261734de82bf9b2
 F test/scanstatus.test 5253c219e331318a437f436268e0e82345700285
 F test/schema.test 8f7999be894260f151adf15c2c7540f1c6d6a481
 F test/schema2.test 906408621ea881fdb496d878b1822572a34e32c5
@@ -993,7 +995,7 @@ F test/select3.test 2ce595f8fb8e2ac10071d3b4e424cadd4634a054
 F test/select4.test 6d5bc6d178a367e8b48fa1c1d3ea12cae9c2d650
 F test/select5.test e758b8ef94f69b111df4cb819008856655dcd535
 F test/select6.test 39eac4a5c03650b2b473c532882273283ee8b7a0
-F test/select7.test 71f06cd37cb6f65bb08ba1ccf8e2f5818c09329f
+F test/select7.test 95e370c42d47c3c52377d05e9ffc01ccff7c1f61
 F test/select8.test 8c8f5ae43894c891efc5755ed905467d1d67ad5d
 F test/select9.test aebc2bb0c3bc44606125033cbcaac2c8d1f33a95
 F test/selectA.test e452bdb975f488ea46d091382a9185b5853ed2c7
@@ -1006,7 +1008,7 @@ F test/selectG.test e8600e379589e85e9fefd2fe4d44a4cdd63f6982
 F test/server1.test 46803bd3fe8b99b30dbc5ff38ffc756f5c13a118
 F test/shared.test 1da9dbad400cee0d93f252ccf76e1ae007a63746
 F test/shared2.test 03eb4a8d372e290107d34b6ce1809919a698e879
-F test/shared3.test fcd65cb11d189eff5f5c85cc4fad246fb0933108
+F test/shared3.test ab693f9b6e156b8bfb2a0ad94f29fe69602a5d38
 F test/shared4.test c75f476804e76e26bf6fa0e7b421fb0ca7d07558
 F test/shared6.test 866bb4982c45ce216c61ded5e8fde4e7e2f3ffa9
 F test/shared7.test a81e99f83e6c51b02ac99c96fb3a2a7b5978c956
@@ -1030,15 +1032,15 @@ F test/skipscan2.test d1d1450952b7275f0b0a3a981f0230532743951a
 F test/skipscan3.test ec5bab3f81c7038b43450e7b3062e04a198bdbb5
 F test/skipscan5.test 67817a4b6857c47e0e33ba3e506da6f23ef68de2
 F test/skipscan6.test 5866039d03a56f5bd0b3d172a012074a1d90a15b
-F test/snapshot.test efc6b4edc5d571161835f9dd8552e181ad1f0ac2
+F test/snapshot.test 5ec4651d16c3d1eb6c010d102febe32b3614bf56
 F test/snapshot_fault.test 25973aeb1b86a280800e0bcf1eb5ce70e9ef57ab
 F test/soak.test 0b5b6375c9f4110c828070b826b3b4b0bb65cd5f
 F test/softheap1.test 843cd84db9891b2d01b9ab64cef3e9020f98d087
-F test/sort.test 3f492e5b7be1d3f756728d2ff6edf4f6091e84cb
-F test/sort2.test 37afbc03f5559f2eb0f18940b55d38dfbb5172ac
-F test/sort3.test 6178ade30810ac9166fcdf14b7065e49c0f534e2
+F test/sort.test c2adc635c2564241fefec0b3a68391ef6868fd3b
+F test/sort2.test cc23b7c19d684657559e8a55b02f7fcee03851d0
+F test/sort3.test 1480ed7c4c157682542224e05e3b75faf4a149e5
 F test/sort4.test 5c34d9623a4ae5921d956dfa2b70e77ed0fc6e5c
-F test/sort5.test a448240a42b49239edc00f85d6d7ac7a1b261e1f
+F test/sort5.test d3041ce3c475aa04142a959ae56ef6593f98a99f
 F test/sortfault.test d4ccf606a0c77498e2beb542764fd9394acb4d66
 F test/speed1.test f2974a91d79f58507ada01864c0e323093065452
 F test/speed1p.explain d841e650a04728b39e6740296b852dccdca9b2cb
@@ -1049,12 +1051,12 @@ F test/speed4.test abc0ad3399dcf9703abed2fff8705e4f8e416715
 F test/speed4p.explain 6b5f104ebeb34a038b2f714150f51d01143e59aa
 F test/speed4p.test 0e51908951677de5a969b723e03a27a1c45db38b
 F test/speedtest1.c f8bf04214e7b5f745feea99f7bde68b1c4870666
-F test/spellfix.test 0597065ff57042df1f138e6a2611ae19c2698135
+F test/spellfix.test f9c1f431e2c096c8775fec032952320c0e4700db
 F test/spellfix2.test dfc8f519a3fc204cb2dfa8b4f29821ae90f6f8c3
 F test/spellfix3.test f7bf7b3482971473d32b6b00f6944c5c066cff97
 F test/sqldiff1.test 8f6bc7c6a5b3585d350d779c6078869ba402f8f5
 F test/sqllimits1.test a74ee2a3740b9f9c2437c246d8fb77354862a142
-F test/sqllog.test a8faa2df39610a037dd372ed872d124260d32953
+F test/sqllog.test 6af6cb0b09f4e44e1917e06ce85be7670302517a
 F test/stat.test acc91e80517fff447ae8adcfd953cfdaa5efc0af
 F test/statfault.test f525a7bf633e50afd027700e9a486090684b1ac1
 F test/stmt.test 25d64e3dbf9a3ce89558667d7f39d966fe2a71b9
@@ -1065,7 +1067,7 @@ F test/substr.test 18f57c4ca8a598805c4d64e304c418734d843c1a
 F test/subtype1.test 7fe09496352f97053af1437150751be2d0a0cae8
 F test/superlock.test 1cde669f68d2dd37d6c9bd35eee1d95491ae3fc2
 F test/symlink.test c9ebe7330d228249e447038276bfc8a7b22f4849
-F test/sync.test a34cd43e98b7fb84eabbf38f7ed8f7349b3f3d85
+F test/sync.test 2f607e1821aa3af3c5c53b58835c05e511c95899
 F test/syscall.test f59ba4e25f7ba4a4c031026cc2ef8b6e4b4c639c
 F test/sysfault.test c9f2b0d8d677558f74de750c75e12a5454719d04
 F test/tabfunc01.test cc33684f9480fcf1fd5ce287ac28d22971cad1cc
@@ -1076,7 +1078,7 @@ F test/tclsqlite.test 7fb866443c7deceed22b63948ccd6f76b52ad054
 F test/tempdb.test 19d0f66e2e3eeffd68661a11c83ba5e6ace9128c
 F test/temptable.test d2c9b87a54147161bcd1822e30c1d1cd891e5b30
 F test/temptrigger.test 8ec228b0db5d7ebc4ee9b458fc28cb9e7873f5e1
-F test/tester.tcl af4749cf4abf04291710c5e73f40bc8f411bae86
+F test/tester.tcl 462376b478c1429030911b4cb7c8c517ef1fbd9b
 F test/thread001.test 9f22fd3525a307ff42a326b6bc7b0465be1745a5
 F test/thread002.test e630504f8a06c00bf8bbe68528774dd96aeb2e58
 F test/thread003.test ee4c9efc3b86a6a2767516a37bd64251272560a7
@@ -1123,14 +1125,14 @@ F test/tkt-91e2e8ba6f.test 08c4f94ae07696b05c9b822da0b4e5337a2f54c5
 F test/tkt-94c04eaadb.test f738c57c7f68ab8be1c054415af7774617cb6223
 F test/tkt-9a8b09f8e6.test b2ef151d0984b2ebf237760dbeaa50724e5a0667
 F test/tkt-9d68c883.test 458f7d82a523d7644b54b497c986378a7d8c8b67
-F test/tkt-9f2eb3abac.test 85bc63e749f050e6a61c8f9207f1eee65c9d3395
+F test/tkt-9f2eb3abac.test cb6123ac695a08b4454c3792fbe85108f67fabf8
 F test/tkt-a7b7803e.test 159ef554234fa1f9fb318c751b284bd1cf858da4
 F test/tkt-a8a0d2996a.test eb597379dbcefa24765763d7f682c00cb5924fa9
 F test/tkt-b1d3a2e531.test 8f7576e41ca179289ee1a8fee28386fd8e4b0550
 F test/tkt-b351d95f9.test d14a503c414c5c58fdde3e80f9a3cfef986498c0
 F test/tkt-b72787b1.test a95e8cdad0b98af1853ac7f0afd4ab27b77bf5f3
 F test/tkt-b75a9ca6b0.test 97cc2d5eeaf82799eb42138c0a1ff64370238ce4
-F test/tkt-ba7cbfaedc.test e76d88e572e489ee0d64fe4caf4af18b3d1dc688
+F test/tkt-ba7cbfaedc.test b4c0deccc12aeb55cfdb57935b16b5d67c5a9877
 F test/tkt-bd484a090c.test 60460bf946f79a79712b71f202eda501ca99b898
 F test/tkt-bdc6bbbb38.test fc38bb09bdd440e3513a1f5f98fc60a075182d7d
 F test/tkt-c48d99d690.test ba61977d62ab612fc515b3c488a6fbd6464a2447
@@ -1250,7 +1252,7 @@ F test/triggerA.test fe5597f47ee21bacb4936dc827994ed94161e332
 F test/triggerB.test 56780c031b454abac2340dbb3b71ac5c56c3d7fe
 F test/triggerC.test 302d8995f5ffe63bbc15053abb3ef7a39cf5a092
 F test/triggerD.test 8e7f3921a92a5797d472732108109e44575fa650
-F test/triggerE.test 355e9c5cbaed5cd039a60baad1fb2197caeb8e52
+F test/triggerE.test 15fa63f1097db1f83dd62d121616006978063d1f
 F test/tt3_checkpoint.c 9e75cf7c1c364f52e1c47fd0f14c4340a9db0fe1
 F test/tt3_index.c 39eec10a35f57672225be4d182862152896dee4a
 F test/tt3_lookaside1.c 0377e202c3c2a50d688cb65ba203afeda6fafeb9
@@ -1293,13 +1295,13 @@ F test/vtabH.test 5f5157a1501d9889ec35c1a1832f69612dd31444
 F test/vtabI.test 751b07636700dbdea328e4265b6077ccd6811a3f
 F test/vtab_alter.test 9e374885248f69e251bdaacf480b04a197f125e5
 F test/vtab_err.test 0d4d8eb4def1d053ac7c5050df3024fd47a3fbd8
-F test/vtab_shared.test ea8778d5b0df200adef2ca7c00c3c37d4375f772
-F test/wal.test 65bfc68f3f09dcbc62cee9f794e560428d96cec7
+F test/vtab_shared.test 5253bff2355a9a3f014c15337da7e177ab0ef8ad
+F test/wal.test 0148c8b3421a25fdb4d9c160e84a681d0646371b
 F test/wal2.test 1f841d2048080d32f552942e333fd99ce541dada
-F test/wal3.test b1d425f68a1f61d12563f0fa1ee6fca7d5afabf4
+F test/wal3.test 5dd734147f1f8f958c5261a1f2775d346d7013ce
 F test/wal4.test 4744e155cd6299c6bd99d3eab1c82f77db9cdb3c
 F test/wal5.test 88b5d9a6a3d1532497ee9f4296f010d66f07e33c
-F test/wal6.test 4421cd5a2fa99d29cc91ef12fb23bed171ed3a4c
+F test/wal6.test a9d6aa635b9d63607dabdc11406f5f96ca986635
 F test/wal64k.test 163655ecd2cb8afef4737cac2a40fdd2eeaf20b8
 F test/wal7.test 2ae8f427d240099cc4b2dfef63cff44e2a68a1bd
 F test/wal8.test 75c42e1bc4545c277fed212f8fc9b7723cd02216
@@ -1308,7 +1310,7 @@ F test/wal_common.tcl a98f17fba96206122eff624db0ab13ec377be4fe
 F test/walbak.test b9f68e39646375c2b877be906babcc15d38b4877
 F test/walbig.test f437473a16cfb314867c6b5d1dbcd519e73e3434
 F test/walblock.test be48f3a75eff0b4456209f26b3ce186c2015497d
-F test/walcksum.test 9afeb96240296c08c72fc524d199c912cfe34daa
+F test/walcksum.test bb234a1bb42248b3515d992b719708015c384278
 F test/walcrash.test 21038858cc552077b0522f50b0fa87e38139306a
 F test/walcrash2.test a0edab4e5390f03b99a790de89aad15d6ec70b36
 F test/walcrash3.test e426aa58122d20f2b9fbe9a507f9eb8cab85b8af
@@ -1316,11 +1318,12 @@ F test/walfault.test 1f8389f7709877e9b4cc679033d71d6fe529056b
 F test/walhook.test ed00a40ba7255da22d6b66433ab61fab16a63483
 F test/walmode.test 4022fe03ae6e830583672caa101f046438a0473c
 F test/walnoshm.test 84ca10c544632a756467336b7c3b864d493ee496
-F test/waloverwrite.test a0d2ae0783187374c1e6a9571e0916152977cb81
+F test/waloverwrite.test dad2f26567f1b45174e54fbf9a8dc1cb876a7f03
 F test/walpersist.test 8c6b7e3ec1ba91b5e4dc4e0921d6d3f87cd356a6
+F test/walprotocol.test 059cb75484a1ecf6357a2c1b3324b8156749221e
 F test/walro.test 34422d1d95aaff0388f0791ec20edb34e2a3ed57
 F test/walshared.test 0befc811dcf0b287efae21612304d15576e35417
-F test/walslow.test e7be6d9888f83aa5d3d3c7c08aa9b5c28b93609a
+F test/walslow.test c05c68d4dc2700a982f89133ce103a1a84cc285f
 F test/walthread.test de8dbaf6d9e41481c460ba31ca61e163d7348f8e
 F test/where.test 9902a3d84e9bc80357a2c54ed0e76c0d6d04a867
 F test/where2.test af78c55589cbc82d793449493adba0dc3d659f23
@@ -1330,7 +1333,6 @@ F test/where5.test fdf66f96d29a064b63eb543e28da4dfdccd81ad2
 F test/where6.test 5da5a98cec820d488e82708301b96cb8c18a258b
 F test/where7.test f520bcec2c3d12dc4615623b06b2aec7c2d67e94
 F test/where8.test 98eedca0d375fb400b8377269c4b4686582dfb45
-F test/where8m.test da346596e19d54f0aba35ebade032a7c47d79739
 F test/where9.test 729c3ba9b47e8f9f1aab96bae7dad2a524f1d1a2
 F test/whereA.test 4d253178d135ec46d1671e440cd8f2b916aa6e6b
 F test/whereB.test 0def95db3bdec220a731c7e4bec5930327c1d8c5
@@ -1340,9 +1342,10 @@ F test/whereE.test b3a055eef928c992b0a33198a7b8dc10eea5ad2f
 F test/whereF.test 5b2ba0dbe8074aa13e416b37c753991f0a2492d7
 F test/whereG.test dde4c52a97385a55be6a7cd46be8373f0cf35501
 F test/whereH.test e4b07f7a3c2f5d31195cd33710054c78667573b2
-F test/whereI.test 1d89199697919d4930be05a71e7fe620f114e622
+F test/whereI.test eab5b226bbc344ac70d7dc09b963a064860ae6d7
 F test/whereJ.test 55a3221706a7ab706293f17cc8f96da563bf0767
 F test/whereK.test f8e3cf26a8513ecc7f514f54df9f0572c046c42b
+F test/wherefault.test 1374c3aa198388925246475f84ad4cd5f9528864
 F test/wherelimit.test 5e9fd41e79bb2b2d588ed999d641d9c965619b31
 F test/wild001.test bca33f499866f04c24510d74baf1e578d4e44b1c
 F test/win32heap.test ea19770974795cff26e11575e12d422dbd16893c
@@ -1351,7 +1354,7 @@ F test/win32longpath.test 169c75a3b2e43481f4a62122510210c67b08f26d
 F test/with1.test cef099a491eac9874f2c28bd2dc86394fb3e47b3
 F test/with2.test 2b40da883658eb74ad8ad06afabe11a408e7fb87
 F test/with3.test 511bacdbe41c49cf34f9fd1bd3245fe1575bca98
-F test/withM.test e97f2a8c506ab3ea9eab94e6f6072f6cc924c991
+F test/withM.test 693b61765f2b387b5e3e24a4536e2e82de15ff64
 F test/without_rowid1.test 1a7b9bd51b899928d327052df9741d2fe8dbe701
 F test/without_rowid2.test af260339f79d13cb220288b67cd287fbcf81ad99
 F test/without_rowid3.test aad4f9d383e199349b6c7e508a778f7dff5dff79
@@ -1364,7 +1367,7 @@ F test/zerodamage.test cf6748bad89553cc1632be51a6f54e487e4039ac
 F tool/GetFile.cs a15e08acb5dd7539b75ba23501581d7c2b462cb5
 F tool/GetTclKit.bat 629d87562e0487c386db630033931d12d62e6372
 F tool/addopcodes.tcl 4ca9c3ef196f08da30add5d07ce0c9458dc8c633
-F tool/build-all-msvc.bat 77f85f4268c2711d637c629610d0cf3df5338638 x
+F tool/build-all-msvc.bat 31866578036cd1d962628059b0760d407c3ce4d8 x
 F tool/build-shell.sh 950f47c6174f1eea171319438b93ba67ff5bf367
 F tool/cg_anno.tcl 692ce4b8693d59e3a3de77ca97f4139ecfa641b0 x
 F tool/checkSpacing.c 810e51703529a204fc4e1eb060e9ab663e3c06d2
@@ -1423,7 +1426,10 @@ F tool/vdbe_profile.tcl 246d0da094856d72d2c12efec03250d71639d19f
 F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
 F tool/warnings.sh 48bd54594752d5be3337f12c72f28d2080cb630b
 F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
-P ca11f46db047e7f131cef3893f73824758a2076b
-R 59ea01ed7c88b6674116d0bfaf73cf15
-U drh
-Z 96f5f7409c64154023cc6759eed6c5b3
+P ca91bd8ac70a5b3fef127364f73ec675e58bb92c
+R 1ddcbe680d5a6ea9a1dc01ec422c820c
+T *branch * win10sdk
+T *sym-win10sdk *
+T -sym-trunk *
+U mistachkin
+Z 9a5014635472c911640e985821bf4dea
@@ -1 +1 @@
-632071bac5ff324a74cec9bdbba2deb60c0945e9
+ebace2c99b6af9230c4bbc31a764c7f397200148
@@ -695,7 +695,7 @@ void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
    rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);
    assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
    if( rc!=SQLITE_OK ){
-      db->mallocFailed = 1;
+      assert( db->mallocFailed = 1 );
      return;
    }
    if( !pVal ){
@@ -803,7 +803,7 @@ void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
  pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
  pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
  if( !pNew->aCol || !pNew->zName ){
-    db->mallocFailed = 1;
+    assert( db->mallocFailed );
    goto exit_begin_add_column;
  }
  memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
@@ -313,7 +313,7 @@ static void sampleClear(sqlite3 *db, Stat4Sample *p){
 static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){
  assert( db!=0 );
  if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
-  p->u.aRowid = sqlite3DbMallocRaw(db, n);
+  p->u.aRowid = sqlite3DbMallocRawNN(db, n);
  if( p->u.aRowid ){
    p->nRowid = n;
    memcpy(p->u.aRowid, pData, n);
@@ -1115,7 +1115,7 @@ static void analyzeOneTable(
    if( nColTest>0 ){
      int endDistinctTest = sqlite3VdbeMakeLabel(v);
      int *aGotoChng;               /* Array of jump instruction addresses */
-      aGotoChng = sqlite3DbMallocRaw(db, sizeof(int)*nColTest);
+      aGotoChng = sqlite3DbMallocRawNN(db, sizeof(int)*nColTest);
      if( aGotoChng==0 ) continue;

      /*
@@ -1523,7 +1523,7 @@ static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
    ** the old data with the new instead of allocating a new array.  */
    if( pIndex->aiRowEst==0 ){
      pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
-      if( pIndex->aiRowEst==0 ) pInfo->db->mallocFailed = 1;
+      if( pIndex->aiRowEst==0 ) sqlite3OomFault(pInfo->db);
    }
    aiRowEst = pIndex->aiRowEst;
 #endif
@@ -1670,7 +1670,7 @@ static int loadStatTbl(
  Index *pPrevIdx = 0;          /* Previous index in the loop */
  IndexSample *pSample;         /* A slot in pIdx->aSample[] */

-  assert( db->lookaside.bEnabled==0 );
+  assert( db->lookaside.bDisable );
  zSql = sqlite3MPrintf(db, zSql1, zDb);
  if( !zSql ){
    return SQLITE_NOMEM;
@@ -1784,7 +1784,7 @@ static int loadStatTbl(
 static int loadStat4(sqlite3 *db, const char *zDb){
  int rc = SQLITE_OK;             /* Result codes from subroutines */

-  assert( db->lookaside.bEnabled==0 );
+  assert( db->lookaside.bDisable );
  if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){
    rc = loadStatTbl(db, 0,
      "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx", 
@@ -1866,10 +1866,9 @@ int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
  /* Load the statistics from the sqlite_stat4 table. */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
-    int lookasideEnabled = db->lookaside.bEnabled;
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable++;
    rc = loadStat4(db, sInfo.zDatabase);
-    db->lookaside.bEnabled = lookasideEnabled;
+    db->lookaside.bDisable--;
  }
  for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
    Index *pIdx = sqliteHashData(i);
@@ -1879,7 +1878,7 @@ int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
 #endif

  if( rc==SQLITE_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
  }
  return rc;
 }
@@ -109,7 +109,7 @@ static void attachFunc(
  ** hash tables.
  */
  if( db->aDb==db->aDbStatic ){
-    aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
+    aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
    if( aNew==0 ) return;
    memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
  }else{
@@ -127,7 +127,7 @@ static void attachFunc(
  flags = db->openFlags;
  rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
  if( rc!=SQLITE_OK ){
-    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
+    if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
    sqlite3_result_error(context, zErr, -1);
    sqlite3_free(zErr);
    return;
@@ -156,7 +156,8 @@ static void attachFunc(
    sqlite3BtreeSecureDelete(aNew->pBt,
                             sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
-    sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK));
+    sqlite3BtreeSetPagerFlags(aNew->pBt,
+                      PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
 #endif
    sqlite3BtreeLeave(aNew->pBt);
  }
@@ -229,7 +230,7 @@ static void attachFunc(
    sqlite3ResetAllSchemasOfConnection(db);
    db->nDb = iDb;
    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      sqlite3DbFree(db, zErrDyn);
      zErrDyn = sqlite3MPrintf(db, "out of memory");
    }else if( zErrDyn==0 ){
@@ -2338,7 +2338,6 @@ int sqlite3BtreeOpen(
        pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
        if( pBt->mutex==0 ){
          rc = SQLITE_NOMEM;
-          db->mallocFailed = 0;
          goto btree_open_out;
        }
      }
@@ -78,7 +78,7 @@ void sqlite3TableLock(
    p->zName = zName;
  }else{
    pToplevel->nTableLock = 0;
-    pToplevel->db->mallocFailed = 1;
+    sqlite3OomFault(pToplevel->db);
  }
 }

@@ -926,7 +926,7 @@ void sqlite3StartTable(

  pTable = sqlite3DbMallocZero(db, sizeof(Table));
  if( pTable==0 ){
-    db->mallocFailed = 1;
+    assert( db->mallocFailed );
    pParse->rc = SQLITE_NOMEM;
    pParse->nErr++;
    goto begin_table_error;
@@ -1555,7 +1555,7 @@ static char *createTableStmt(sqlite3 *db, Table *p){
  n += 35 + 6*p->nCol;
  zStmt = sqlite3DbMallocRaw(0, n);
  if( zStmt==0 ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
    return 0;
  }
  sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
@@ -2038,7 +2038,7 @@ void sqlite3EndTable(
    pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
    if( pOld ){
      assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      return;
    }
    pParse->pNewTable = 0;
@@ -2142,7 +2142,6 @@ int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
  int n;            /* Temporarily holds the number of cursors assigned */
  sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
  sqlite3_xauth xAuth;       /* Saved xAuth pointer */
-  u8 bEnabledLA;             /* Saved db->lookaside.bEnabled state */

  assert( pTable );

@@ -2188,18 +2187,18 @@ int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
  ** statement that defines the view.
  */
  assert( pTable->pSelect );
-  bEnabledLA = db->lookaside.bEnabled;
  if( pTable->pCheck ){
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable++;
    sqlite3ColumnsFromExprList(pParse, pTable->pCheck, 
                               &pTable->nCol, &pTable->aCol);
+    db->lookaside.bDisable--;
  }else{
    pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
    if( pSel ){
      n = pParse->nTab;
      sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
      pTable->nCol = -1;
-      db->lookaside.bEnabled = 0;
+      db->lookaside.bDisable++;
 #ifndef SQLITE_OMIT_AUTHORIZATION
      xAuth = db->xAuth;
      db->xAuth = 0;
@@ -2208,6 +2207,7 @@ int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
 #else
      pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
 #endif
+      db->lookaside.bDisable--;
      pParse->nTab = n;
      if( pSelTab ){
        assert( pTable->aCol==0 );
@@ -2226,7 +2226,6 @@ int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
      nErr++;
    }
  }
-  db->lookaside.bEnabled = bEnabledLA;
  pTable->pSchema->schemaFlags |= DB_UnresetViews;
 #endif /* SQLITE_OMIT_VIEW */
  return nErr;  
@@ -2692,7 +2691,7 @@ void sqlite3CreateForeignKey(
      pFKey->zTo, (void *)pFKey
  );
  if( pNextTo==pFKey ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
    goto fk_end;
  }
  if( pNextTo ){
@@ -3274,7 +3273,7 @@ Index *sqlite3CreateIndex(
                          pIndex->zName, pIndex);
    if( p ){
      assert( p==pIndex );  /* Malloc must have failed */
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      goto exit_create_index;
    }
    db->flags |= SQLITE_InternChanges;
@@ -3703,8 +3702,9 @@ SrcList *sqlite3SrcListAppend(
 ){
  struct SrcList_item *pItem;
  assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
+  assert( db!=0 );
  if( pList==0 ){
-    pList = sqlite3DbMallocRaw(db, sizeof(SrcList) );
+    pList = sqlite3DbMallocRawNN(db, sizeof(SrcList) );
    if( pList==0 ) return 0;
    pList->nAlloc = 1;
    pList->nSrc = 0;
@@ -3992,7 +3992,7 @@ int sqlite3OpenTempDatabase(Parse *pParse){
    db->aDb[1].pBt = pBt;
    assert( db->aDb[1].pSchema );
    if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      return 1;
    }
  }
@@ -4367,10 +4367,9 @@ With *sqlite3WithAdd(
  }else{
    pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
  }
-  assert( zName!=0 || pNew==0 );
-  assert( db->mallocFailed==0 || pNew==0 );
+  assert( (pNew!=0 && zName!=0) || db->mallocFailed );

-  if( pNew==0 ){
+  if( db->mallocFailed ){
    sqlite3ExprListDelete(db, pArglist);
    sqlite3SelectDelete(db, pQuery);
    sqlite3DbFree(db, zName);
@@ -177,7 +177,7 @@ static CollSeq *findCollSeqEntry(
      */
      assert( pDel==0 || pDel==pColl );
      if( pDel!=0 ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
        sqlite3DbFree(db, pDel);
        pColl = 0;
      }
@@ -465,7 +465,7 @@ Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
    p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
  }
  if( !p ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
  }else if ( 0==p->file_format ){
    sqlite3HashInit(&p->tblHash);
    sqlite3HashInit(&p->idxHash);
@@ -967,7 +967,7 @@ static void strftimeFunc(
    sqlite3_result_error_toobig(context);
    return;
  }else{
-    z = sqlite3DbMallocRaw(db, (int)n);
+    z = sqlite3DbMallocRawNN(db, (int)n);
    if( z==0 ){
      sqlite3_result_error_nomem(context);
      return;
@@ -439,7 +439,7 @@ void sqlite3DeleteFrom(
      ** one, so just keep it in its register(s) and fall through to the
      ** delete code.  */
      nKey = nPk; /* OP_Found will use an unpacked key */
-      aToOpen = sqlite3DbMallocRaw(db, nIdx+2);
+      aToOpen = sqlite3DbMallocRawNN(db, nIdx+2);
      if( aToOpen==0 ){
        sqlite3WhereEnd(pWInfo);
        goto delete_from_cleanup;
@@ -453,6 +453,7 @@ Expr *sqlite3ExprAlloc(
  int nExtra = 0;
  int iValue = 0;

+  assert( db!=0 );
  if( pToken ){
    if( op!=TK_INTEGER || pToken->z==0
          || sqlite3GetInt32(pToken->z, &iValue)==0 ){
@@ -460,7 +461,7 @@ Expr *sqlite3ExprAlloc(
      assert( iValue>=0 );
    }
  }
-  pNew = sqlite3DbMallocRaw(db, sizeof(Expr)+nExtra);
+  pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
  if( pNew ){
    memset(pNew, 0, sizeof(Expr));
    pNew->op = (u8)op;
@@ -699,7 +700,10 @@ void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
      if( x>pParse->nzVar ){
        char **a;
        a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
-        if( a==0 ) return;  /* Error reported through db->mallocFailed */
+        if( a==0 ){
+          assert( db->mallocFailed ); /* Error reported through mallocFailed */
+          return;
+        }
        pParse->azVar = a;
        memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
        pParse->nzVar = x;
@@ -854,6 +858,7 @@ static int dupedExprSize(Expr *p, int flags){
 static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
  Expr *pNew = 0;                      /* Value to return */
  assert( flags==0 || flags==EXPRDUP_REDUCE );
+  assert( db!=0 );
  if( p ){
    const int isReduced = (flags&EXPRDUP_REDUCE);
    u8 *zAlloc;
@@ -866,7 +871,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
      zAlloc = *pzBuffer;
      staticFlag = EP_Static;
    }else{
-      zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
+      zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, flags));
    }
    pNew = (Expr *)zAlloc;

@@ -989,12 +994,13 @@ ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
  ExprList *pNew;
  struct ExprList_item *pItem, *pOldItem;
  int i;
+  assert( db!=0 );
  if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
  if( pNew==0 ) return 0;
  pNew->nExpr = i = p->nExpr;
  if( (flags & EXPRDUP_REDUCE)==0 ) for(i=1; i<p->nExpr; i+=i){}
-  pNew->a = pItem = sqlite3DbMallocRaw(db,  i*sizeof(p->a[0]) );
+  pNew->a = pItem = sqlite3DbMallocRawNN(db,  i*sizeof(p->a[0]) );
  if( pItem==0 ){
    sqlite3DbFree(db, pNew);
    return 0;
@@ -1025,9 +1031,10 @@ SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
  SrcList *pNew;
  int i;
  int nByte;
+  assert( db!=0 );
  if( p==0 ) return 0;
  nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
-  pNew = sqlite3DbMallocRaw(db, nByte );
+  pNew = sqlite3DbMallocRawNN(db, nByte );
  if( pNew==0 ) return 0;
  pNew->nSrc = pNew->nAlloc = p->nSrc;
  for(i=0; i<p->nSrc; i++){
@@ -1064,11 +1071,12 @@ SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
 IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
  IdList *pNew;
  int i;
+  assert( db!=0 );
  if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
  if( pNew==0 ) return 0;
  pNew->nId = p->nId;
-  pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
+  pNew->a = sqlite3DbMallocRawNN(db, p->nId*sizeof(p->a[0]) );
  if( pNew->a==0 ){
    sqlite3DbFree(db, pNew);
    return 0;
@@ -1086,8 +1094,9 @@ IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
 }
 Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
  Select *pNew, *pPrior;
+  assert( db!=0 );
  if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*p) );
  if( pNew==0 ) return 0;
  pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
  pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
@@ -1133,13 +1142,14 @@ ExprList *sqlite3ExprListAppend(
  Expr *pExpr             /* Expression to be appended. Might be NULL */
 ){
  sqlite3 *db = pParse->db;
+  assert( db!=0 );
  if( pList==0 ){
-    pList = sqlite3DbMallocRaw(db, sizeof(ExprList) );
+    pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) );
    if( pList==0 ){
      goto no_mem;
    }
    pList->nExpr = 0;
-    pList->a = sqlite3DbMallocRaw(db, sizeof(pList->a[0]));
+    pList->a = sqlite3DbMallocRawNN(db, sizeof(pList->a[0]));
    if( pList->a==0 ) goto no_mem;
  }else if( (pList->nExpr & (pList->nExpr-1))==0 ){
    struct ExprList_item *a;
@@ -219,7 +219,7 @@ int sqlite3FkLocateIndex(
    }
  }else if( paiCol ){
    assert( nCol>1 );
-    aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
+    aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
    if( !aiCol ) return 1;
    *paiCol = aiCol;
  }
@@ -1165,7 +1165,6 @@ static Trigger *fkActionTrigger(
  pTrigger = pFKey->apTrigger[iAction];

  if( action!=OE_None && !pTrigger ){
-    u8 enableLookaside;           /* Copy of db->lookaside.bEnabled */
    char const *zFrom;            /* Name of child table */
    int nFrom;                    /* Length in bytes of zFrom */
    Index *pIdx = 0;              /* Parent key index for this FK */
@@ -1274,8 +1273,7 @@ static Trigger *fkActionTrigger(
    }

    /* Disable lookaside memory allocation */
-    enableLookaside = db->lookaside.bEnabled;
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable++;

    pTrigger = (Trigger *)sqlite3DbMallocZero(db, 
        sizeof(Trigger) +         /* struct Trigger */
@@ -1297,7 +1295,7 @@ static Trigger *fkActionTrigger(
    }

    /* Re-enable the lookaside buffer, if it was disabled earlier. */
-    db->lookaside.bEnabled = enableLookaside;
+    db->lookaside.bDisable--;

    sqlite3ExprDelete(db, pWhere);
    sqlite3ExprDelete(db, pWhen);
@@ -1615,7 +1615,7 @@ void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
  int rc = sqlite3_overload_function(db, "MATCH", 2);
  assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
  if( rc==SQLITE_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
  }
 }

@@ -83,7 +83,7 @@ const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
    Table *pTab = pIdx->pTable;
    pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
    if( !pIdx->zColAff ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      return 0;
    }
    for(n=0; n<pIdx->nColumn; n++){
@@ -134,7 +134,7 @@ void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
    sqlite3 *db = sqlite3VdbeDb(v);
    zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
    if( !zColAff ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      return;
    }

@@ -230,7 +230,7 @@ static int autoIncBegin(
    pInfo = pToplevel->pAinc;
    while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
    if( pInfo==0 ){
-      pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
+      pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
      if( pInfo==0 ) return 0;
      pInfo->pNext = pToplevel->pAinc;
      pToplevel->pAinc = pInfo;
@@ -787,7 +787,7 @@ void sqlite3Insert(
    int nIdx;
    nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
                                      &iDataCur, &iIdxCur);
-    aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
+    aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+1));
    if( aRegIdx==0 ){
      goto insert_cleanup;
    }
@@ -90,7 +90,7 @@ int sqlite3_exec(
          for(i=0; i<nCol; i++){
            azVals[i] = (char *)sqlite3_column_text(pStmt, i);
            if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
-              db->mallocFailed = 1;
+              sqlite3OomFault(db);
              goto exec_out;
            }
          }
@@ -698,12 +698,12 @@ static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
      p = (LookasideSlot*)&((u8*)p)[sz];
    }
    db->lookaside.pEnd = p;
-    db->lookaside.bEnabled = 1;
+    db->lookaside.bDisable = 0;
    db->lookaside.bMalloced = pBuf==0 ?1:0;
  }else{
    db->lookaside.pStart = db;
    db->lookaside.pEnd = db;
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable = 1;
    db->lookaside.bMalloced = 0;
  }
 #endif /* SQLITE_OMIT_LOOKASIDE */
@@ -2208,7 +2208,7 @@ const void *sqlite3_errmsg16(sqlite3 *db){
    ** be cleared before returning. Do this directly, instead of via
    ** sqlite3ApiExit(), to avoid setting the database handle error message.
    */
-    db->mallocFailed = 0;
+    sqlite3OomClear(db);
  }
  sqlite3_mutex_leave(db->mutex);
  return z;
@@ -2846,7 +2846,7 @@ static int openDatabase(
  db->openFlags = flags;
  rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
  if( rc!=SQLITE_OK ){
-    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
+    if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
    sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
    sqlite3_free(zErrMsg);
    goto opendb_out;
@@ -575,10 +575,24 @@ void *sqlite3MallocZero(u64 n){
 ** the mallocFailed flag in the connection pointer.
 */
 void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
-  void *p = sqlite3DbMallocRaw(db, n);
-  if( p ){
-    memset(p, 0, (size_t)n);
-  }
+  void *p;
+  testcase( db==0 );
+  p = sqlite3DbMallocRaw(db, n);
+  if( p ) memset(p, 0, (size_t)n);
+  return p;
+}
+
+
+/* Finish the work of sqlite3DbMallocRawNN for the unusual and
+** slower case when the allocation cannot be fulfilled using lookaside.
+*/
+static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){
+  void *p;
+  assert( db!=0 );
+  p = sqlite3Malloc(n);
+  if( !p ) sqlite3OomFault(db);
+  sqlite3MemdebugSetType(p, 
+         (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
  return p;
 }

@@ -600,67 +614,70 @@ void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
 **
 ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
 ** that all prior mallocs (ex: "a") worked too.
+**
+** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is
+** not a NULL pointer.
 */
-static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n);
 void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){
-  assert( db==0 || sqlite3_mutex_held(db->mutex) );
-  assert( db==0 || db->pnBytesFreed==0 );
+  void *p;
+  if( db ) return sqlite3DbMallocRawNN(db, n);
+  p = sqlite3Malloc(n);
+  sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
+  return p;
+}
+void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){
+  assert( db!=0 );
+  assert( sqlite3_mutex_held(db->mutex) );
+  assert( db->pnBytesFreed==0 );
 #ifndef SQLITE_OMIT_LOOKASIDE
-  if( db ){
-    LookasideSlot *pBuf;
-    if( db->mallocFailed ){
-      return 0;
-    }
-    if( db->lookaside.bEnabled ){
-      if( n>db->lookaside.sz ){
-        db->lookaside.anStat[1]++;
-      }else if( (pBuf = db->lookaside.pFree)==0 ){
-        db->lookaside.anStat[2]++;
-      }else{
-        db->lookaside.pFree = pBuf->pNext;
-        db->lookaside.nOut++;
-        db->lookaside.anStat[0]++;
-        if( db->lookaside.nOut>db->lookaside.mxOut ){
-          db->lookaside.mxOut = db->lookaside.nOut;
-        }
-        return (void*)pBuf;
+  LookasideSlot *pBuf;
+  if( db->lookaside.bDisable==0 ){
+    assert( db->mallocFailed==0 );
+    if( n>db->lookaside.sz ){
+      db->lookaside.anStat[1]++;
+    }else if( (pBuf = db->lookaside.pFree)==0 ){
+      db->lookaside.anStat[2]++;
+    }else{
+      db->lookaside.pFree = pBuf->pNext;
+      db->lookaside.nOut++;
+      db->lookaside.anStat[0]++;
+      if( db->lookaside.nOut>db->lookaside.mxOut ){
+        db->lookaside.mxOut = db->lookaside.nOut;
      }
+      return (void*)pBuf;
    }
+  }else if( db->mallocFailed ){
+    return 0;
  }
 #else
-  if( db && db->mallocFailed ){
+  if( db->mallocFailed ){
    return 0;
  }
 #endif
  return dbMallocRawFinish(db, n);
 }
-static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){
-  void *p = sqlite3Malloc(n);
-  if( !p && db ){
-    db->mallocFailed = 1;
-  }
-  sqlite3MemdebugSetType(p, 
-         (db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
-  return p;
-}
+
+/* Forward declaration */
+static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n);

 /*
 ** Resize the block of memory pointed to by p to n bytes. If the
 ** resize fails, set the mallocFailed flag in the connection object.
 */
 void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
+  assert( db!=0 );
+  if( p==0 ) return sqlite3DbMallocRawNN(db, n);
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( isLookaside(db,p) && n<=db->lookaside.sz ) return p;
+  return dbReallocFinish(db, p, n);
+}
+static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){
  void *pNew = 0;
  assert( db!=0 );
-  assert( sqlite3_mutex_held(db->mutex) );
+  assert( p!=0 );
  if( db->mallocFailed==0 ){
-    if( p==0 ){
-      return sqlite3DbMallocRaw(db, n);
-    }
    if( isLookaside(db, p) ){
-      if( n<=db->lookaside.sz ){
-        return p;
-      }
-      pNew = sqlite3DbMallocRaw(db, n);
+      pNew = sqlite3DbMallocRawNN(db, n);
      if( pNew ){
        memcpy(pNew, p, db->lookaside.sz);
        sqlite3DbFree(db, p);
@@ -671,10 +688,10 @@ void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
      sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
      pNew = sqlite3_realloc64(p, n);
      if( !pNew ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
      }
      sqlite3MemdebugSetType(pNew,
-            (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
+            (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
    }
  }
  return pNew;
@@ -716,11 +733,12 @@ char *sqlite3DbStrDup(sqlite3 *db, const char *z){
 }
 char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
  char *zNew;
+  assert( db!=0 );
  if( z==0 ){
    return 0;
  }
  assert( (n&0x7fffffff)==n );
-  zNew = sqlite3DbMallocRaw(db, n+1);
+  zNew = sqlite3DbMallocRawNN(db, n+1);
  if( zNew ){
    memcpy(zNew, z, (size_t)n);
    zNew[n] = 0;
@@ -736,11 +754,43 @@ void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){
  *pz = sqlite3DbStrDup(db, zNew);
 }

+/*
+** Call this routine to record the fact that an OOM (out-of-memory) error
+** has happened.  This routine will set db->mallocFailed, and also
+** temporarily disable the lookaside memory allocator and interrupt
+** any running VDBEs.
+*/
+void sqlite3OomFault(sqlite3 *db){
+  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
+    db->mallocFailed = 1;
+    if( db->nVdbeExec>0 ){
+      db->u1.isInterrupted = 1;
+    }
+    db->lookaside.bDisable++;
+  }
+}
+
+/*
+** This routine reactivates the memory allocator and clears the
+** db->mallocFailed flag as necessary.
+**
+** The memory allocator is not restarted if there are running
+** VDBEs.
+*/
+void sqlite3OomClear(sqlite3 *db){
+  if( db->mallocFailed && db->nVdbeExec==0 ){
+    db->mallocFailed = 0;
+    db->u1.isInterrupted = 0;
+    assert( db->lookaside.bDisable>0 );
+    db->lookaside.bDisable--;
+  }
+}
+
 /*
 ** Take actions at the end of an API call to indicate an OOM error
 */
 static SQLITE_NOINLINE int apiOomError(sqlite3 *db){
-  db->mallocFailed = 0;
+  sqlite3OomClear(db);
  sqlite3Error(db, SQLITE_NOMEM);
  return SQLITE_NOMEM;
 }
@@ -5887,12 +5887,7 @@ static int unixDelete(
    int fd;
    rc = osOpenDirectory(zPath, &fd);
    if( rc==SQLITE_OK ){
-#if OS_VXWORKS
-      if( fsync(fd)==-1 )
-#else
-      if( fsync(fd) )
-#endif
-      {
+      if( full_fsync(fd,0,0) ){
        rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
      }
      robust_close(0, fd, __LINE__);
@@ -6936,7 +6931,7 @@ static int proxyTakeConch(unixFile *pFile){
        writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
        robust_ftruncate(conchFile->h, writeSize);
        rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0);
-        fsync(conchFile->h);
+        full_fsync(conchFile->h,0,0);
        /* If we created a new conch file (not just updated the contents of a 
         ** valid conch file), try to match the permissions of the database 
         */
@@ -4823,7 +4823,7 @@ act_like_temp_file:
    assert( pPager->ckptSyncFlags==0 );
  }else{
    pPager->fullSync = 1;
-#ifdef SQLITE_EXTRA_DURABLE
+#if SQLITE_EXTRA_DURABLE
    pPager->extraSync = 1;
 #else
    pPager->extraSync = 0;
@@ -106,6 +106,15 @@ struct TrigEvent { int a; IdList * b; };
 */
 struct AttachKey { int type;  Token key; };

+/*
+** Disable lookaside memory allocation for objects that might be
+** shared across database connections.
+*/
+static void disableLookaside(Parse *pParse){
+  pParse->disableLookaside++;
+  pParse->db->lookaside.bDisable++;
+}
+
 } // end %include

 // Input is a single SQL command
@@ -156,7 +165,7 @@ create_table ::= createkw temp(T) TABLE ifnotexists(E) nm(Y) dbnm(Z). {
   sqlite3StartTable(pParse,&Y,&Z,T,0,0,E);
 }
 createkw(A) ::= CREATE(X).  {
-  pParse->db->lookaside.bEnabled = 0;
+  disableLookaside(pParse);
  A = X;
 }
 %type ifnotexists {int}
@@ -1507,7 +1516,7 @@ cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column(Y). {
  sqlite3AlterFinishAddColumn(pParse, &Y);
 }
 add_column_fullname ::= fullname(X). {
-  pParse->db->lookaside.bEnabled = 0;
+  disableLookaside(pParse);
  sqlite3AlterBeginAddColumn(pParse, X);
 }
 kwcolumn_opt ::= .
@@ -478,7 +478,7 @@ void sqlite3Pragma(
      */
      db->nextPagesize = sqlite3Atoi(zRight);
      if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
      }
    }
    break;
@@ -28,11 +28,10 @@ static void corruptSchema(
  if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
    char *z;
    if( zObj==0 ) zObj = "?";
-    z = sqlite3_mprintf("malformed database schema (%s)", zObj);
-    if( z && zExtra ) z = sqlite3_mprintf("%z - %s", z, zExtra);
+    z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
+    if( zExtra ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
    sqlite3DbFree(db, *pData->pzErrMsg);
    *pData->pzErrMsg = z;
-    if( z==0 ) db->mallocFailed = 1;
  }
  pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
 }
@@ -91,7 +90,7 @@ int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
      }else{
        pData->rc = rc;
        if( rc==SQLITE_NOMEM ){
-          db->mallocFailed = 1;
+          sqlite3OomFault(db);
        }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
          corruptSchema(pData, argv[0], sqlite3_errmsg(db));
        }
@@ -336,7 +335,7 @@ initone_error_out:

 error_out:
  if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
  }
  return rc;
 }
@@ -434,7 +433,7 @@ static void schemaIsValid(Parse *pParse){
    if( !sqlite3BtreeIsInReadTrans(pBt) ){
      rc = sqlite3BtreeBeginTrans(pBt, 0);
      if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
      }
      if( rc!=SQLITE_OK ) return;
      openedTransaction = 1;
@@ -497,6 +496,11 @@ void sqlite3ParserReset(Parse *pParse){
    sqlite3 *db = pParse->db;
    sqlite3DbFree(db, pParse->aLabel);
    sqlite3ExprListDelete(db, pParse->pConstExpr);
+    if( db ){
+      assert( db->lookaside.bDisable >= pParse->disableLookaside );
+      db->lookaside.bDisable -= pParse->disableLookaside;
+    }
+    pParse->disableLookaside = 0;
  }
 }

@@ -592,9 +596,6 @@ static int sqlite3Prepare(
  }
  assert( 0==pParse->nQueryLoop );

-  if( db->mallocFailed ){
-    pParse->rc = SQLITE_NOMEM;
-  }
  if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
  if( pParse->checkSchema ){
    schemaIsValid(pParse);
@@ -716,7 +717,7 @@ int sqlite3Reprepare(Vdbe *p){
  rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
  if( rc ){
    if( rc==SQLITE_NOMEM ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
    }
    assert( pNew==0 );
    return rc;
@@ -929,7 +929,7 @@ char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
  sqlite3VXPrintf(&acc, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  if( acc.accError==STRACCUM_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
  }
  return z;
 }
@@ -181,7 +181,7 @@ static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){
  assert( p!=0 );
  if( p->nFresh==0 ){
    struct RowSetChunk *pNew;
-    pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
+    pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
    if( pNew==0 ){
      return 0;
    }
@@ -112,7 +112,7 @@ Select *sqlite3SelectNew(
  Select *pNew;
  Select standin;
  sqlite3 *db = pParse->db;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
  if( pNew==0 ){
    assert( db->mallocFailed );
    pNew = &standin;
@@ -1016,7 +1016,7 @@ KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
    p->nRef = 1;
    memset(&p[1], 0, nExtra);
  }else{
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
  }
  return p;
 }
@@ -1677,7 +1677,7 @@ int sqlite3ColumnsFromExprList(
    pCol->zName = zName;
    sqlite3ColumnPropertiesFromName(0, pCol);
    if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
    }
  }
  sqlite3HashClear(&ht);
@@ -1764,7 +1764,7 @@ Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
  }
  /* The sqlite3ResultSetOfSelect() is only used n contexts where lookaside
  ** is disabled */
-  assert( db->lookaside.bEnabled==0 );
+  assert( db->lookaside.bDisable );
  pTab->nRef = 1;
  pTab->zName = 0;
  pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
@@ -2870,7 +2870,7 @@ static int multiSelectOrderBy(
  ** to the right and the left are evaluated, they use the correct
  ** collation.
  */
-  aPermute = sqlite3DbMallocRaw(db, sizeof(int)*(nOrderBy + 1));
+  aPermute = sqlite3DbMallocRawNN(db, sizeof(int)*(nOrderBy + 1));
  if( aPermute ){
    struct ExprList_item *pItem;
    aPermute[0] = nOrderBy;
@@ -5562,7 +5562,8 @@ int sqlite3Select(
        if( flag ){
          pMinMax = sqlite3ExprListDup(db, pMinMax, 0);
          pDel = pMinMax;
-          if( pMinMax && !db->mallocFailed ){
+          assert( db->mallocFailed || pMinMax!=0 );
+          if( !db->mallocFailed ){
            pMinMax->a[0].sortOrder = flag!=WHERE_ORDERBY_MIN ?1:0;
            pMinMax->a[0].pExpr->op = TK_COLUMN;
          }
@@ -1094,8 +1094,8 @@ struct Schema {
 ** lookaside allocations are not used to construct the schema objects.
 */
 struct Lookaside {
+  u32 bDisable;           /* Only operate the lookaside when zero */
  u16 sz;                 /* Size of each buffer in bytes */
-  u8 bEnabled;            /* False to disable new lookaside allocations */
  u8 bMalloced;           /* True if pStart obtained from sqlite3_malloc() */
  int nOut;               /* Number of buffers currently checked out */
  int mxOut;              /* Highwater mark for nOut */
@@ -1178,6 +1178,7 @@ struct sqlite3 {
  u8 autoCommit;                /* The auto-commit flag. */
  u8 temp_store;                /* 1: file 2: memory 0: default */
  u8 mallocFailed;              /* True if we have seen a malloc failure */
+  u8 bBenignMalloc;             /* Do not require OOMs if true */
  u8 dfltLockMode;              /* Default locking-mode for attached dbs */
  signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
  u8 suppressErr;               /* Do not issue error messages if true */
@@ -2733,6 +2734,7 @@ struct Parse {
  u8 mayAbort;         /* True if statement may throw an ABORT exception */
  u8 hasCompound;      /* Need to invoke convertCompoundSelectToSubquery() */
  u8 okConstFactor;    /* OK to factor out constants */
+  u8 disableLookaside; /* Number of times lookaside has been disabled */
  int aTempReg[8];     /* Holding area for temporary registers */
  int nRangeReg;       /* Size of the temporary register block */
  int iRangeReg;       /* First register in temporary register block */
@@ -3225,6 +3227,7 @@ void *sqlite3Malloc(u64);
 void *sqlite3MallocZero(u64);
 void *sqlite3DbMallocZero(sqlite3*, u64);
 void *sqlite3DbMallocRaw(sqlite3*, u64);
+void *sqlite3DbMallocRawNN(sqlite3*, u64);
 char *sqlite3DbStrDup(sqlite3*,const char*);
 char *sqlite3DbStrNDup(sqlite3*,const char*, u64);
 void *sqlite3Realloc(void*, u64);
@@ -3777,6 +3780,8 @@ int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
  void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
  FuncDestructor *pDestructor
 );
+void sqlite3OomFault(sqlite3*);
+void sqlite3OomClear(sqlite3*);
 int sqlite3ApiExit(sqlite3 *db, int);
 int sqlite3OpenTempDatabase(Parse *);

@@ -166,9 +166,7 @@ static void test_agg_errmsg16_final(sqlite3_context *ctx){
  const void *z;
  sqlite3 * db = sqlite3_context_db_handle(ctx);
  sqlite3_aggregate_context(ctx, 2048);
-  sqlite3BeginBenignMalloc();
  z = sqlite3_errmsg16(db);
-  sqlite3EndBenignMalloc();
  sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT);
 #endif
 }
@@ -390,7 +390,6 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
  void *pEngine;                  /* The LEMON-generated LALR(1) parser */
  int tokenType;                  /* type of the next token */
  int lastTokenParsed = -1;       /* type of the previous token */
-  u8 enableLookaside;             /* Saved value of db->lookaside.bEnabled */
  sqlite3 *db = pParse->db;       /* The database connection */
  int mxSqlLen;                   /* Max length of an SQL string */

@@ -406,7 +405,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
  /* sqlite3ParserTrace(stdout, "parser: "); */
  pEngine = sqlite3ParserAlloc(sqlite3Malloc);
  if( pEngine==0 ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
    return SQLITE_NOMEM;
  }
  assert( pParse->pNewTable==0 );
@@ -414,8 +413,6 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
  assert( pParse->nVar==0 );
  assert( pParse->nzVar==0 );
  assert( pParse->azVar==0 );
-  enableLookaside = db->lookaside.bEnabled;
-  if( db->lookaside.pStart ) db->lookaside.bEnabled = 1;
  while( zSql[i]!=0 ){
    assert( i>=0 );
    pParse->sLastToken.z = &zSql[i];
@@ -428,7 +425,6 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
    if( tokenType>=TK_SPACE ){
      assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
      if( db->u1.isInterrupted ){
-        sqlite3ErrorMsg(pParse, "interrupt");
        pParse->rc = SQLITE_INTERRUPT;
        break;
      }
@@ -463,7 +459,6 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
  sqlite3_mutex_leave(sqlite3MallocMutex());
 #endif /* YYDEBUG */
  sqlite3ParserFree(pEngine, sqlite3_free);
-  db->lookaside.bEnabled = enableLookaside;
  if( db->mallocFailed ){
    pParse->rc = SQLITE_NOMEM;
  }
@@ -323,7 +323,7 @@ void sqlite3FinishTrigger(
    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
    pTrig = sqlite3HashInsert(pHash, zName, pTrig);
    if( pTrig ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
    }else if( pLink->pSchema==pLink->pTabSchema ){
      Table *pTab;
      pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
@@ -197,7 +197,7 @@ void sqlite3Update(
  /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].  
  ** Initialize aXRef[] and aToOpen[] to their default values.
  */
-  aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
+  aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
  if( aXRef==0 ) goto update_cleanup;
  aRegIdx = aXRef+pTab->nCol;
  aToOpen = (u8*)(aRegIdx+nIdx);
@@ -1150,7 +1150,7 @@ void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
  char *zBlob;
  int i;

-  zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
+  zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
  n--;
  if( zBlob ){
    for(i=0; i<n; i+=2){
@@ -753,16 +753,14 @@ jump_to_p2_and_check_for_interrupt:
  /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
  ** OP_VNext, OP_RowSetNext, or OP_SorterNext) all jump here upon
  ** completion.  Check to see if sqlite3_interrupt() has been called
-  ** or if the progress callback needs to be invoked. Also check for
-  ** OOM conditions and abort if seen.
+  ** or if the progress callback needs to be invoked. 
  **
  ** This code uses unstructured "goto" statements and does not look clean.
  ** But that is not due to sloppy coding habits. The code is written this
  ** way for performance, to avoid having to run the interrupt and progress
-  ** checks on every opcode.  This helps sqlite3_step() to run over 2.0%
+  ** checks on every opcode.  This helps sqlite3_step() to run about 1.5%
  ** faster according to "valgrind --tool=cachegrind" */
 check_for_interrupt:
-  if( db->mallocFailed ) goto no_mem;
  if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  /* Call the progress callback if it is configured and the required number
@@ -1628,7 +1626,7 @@ case OP_Function0: {
  assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
  assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
  assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-  pCtx = sqlite3DbMallocRaw(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
+  pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
  if( pCtx==0 ) goto no_mem;
  pCtx->pOut = 0;
  pCtx->pFunc = pOp->p4.pFunc;
@@ -2872,7 +2870,7 @@ case OP_Savepoint: {
 #endif

      /* Create a new savepoint structure. */
-      pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+nName+1);
+      pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
      if( pNew ){
        pNew->zName = (char *)&pNew[1];
        memcpy(pNew->zName, zName, nName+1);
@@ -5422,7 +5420,7 @@ case OP_IntegrityCk: {
  assert( p->bIsReader );
  nRoot = pOp->p2;
  assert( nRoot>0 );
-  aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(nRoot+1) );
+  aRoot = sqlite3DbMallocRawNN(db, sizeof(int)*(nRoot+1) );
  if( aRoot==0 ) goto no_mem;
  assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
  pnErr = &aMem[pOp->p3];
@@ -5919,7 +5917,7 @@ case OP_AggStep0: {
  assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
  assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
  assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-  pCtx = sqlite3DbMallocRaw(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
+  pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
  if( pCtx==0 ) goto no_mem;
  pCtx->pMem = 0;
  pCtx->pFunc = pOp->p4.pFunc;
@@ -6786,7 +6784,7 @@ vdbe_error_halt:
  sqlite3_log(rc, "statement aborts at %d: [%s] %s", 
                   (int)(pOp - aOp), p->zSql, p->zErrMsg);
  sqlite3VdbeHalt(p);
-  if( rc==SQLITE_IOERR_NOMEM ) db->mallocFailed = 1;
+  if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
  rc = SQLITE_ERROR;
  if( resetSchemaOnFault>0 ){
    sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
@@ -6816,7 +6814,7 @@ too_big:
  /* Jump to here if a malloc() fails.
  */
 no_mem:
-  db->mallocFailed = 1;
+  sqlite3OomFault(db);
  sqlite3VdbeError(p, "out of memory");
  rc = SQLITE_NOMEM;
  goto vdbe_error_halt;
@@ -6837,7 +6835,7 @@ abort_due_to_error:
  */
 abort_due_to_interrupt:
  assert( db->u1.isInterrupted );
-  rc = SQLITE_INTERRUPT;
+  rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_INTERRUPT;
  p->rc = rc;
  sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
  goto vdbe_error_halt;
@@ -473,7 +473,7 @@ void sqlite3_result_error_nomem(sqlite3_context *pCtx){
  sqlite3VdbeMemSetNull(pCtx->pOut);
  pCtx->isError = SQLITE_NOMEM;
  pCtx->fErrorOrAux = 1;
-  pCtx->pOut->db->mallocFailed = 1;
+  sqlite3OomFault(pCtx->pOut->db);
 }

 /*
@@ -1101,7 +1101,7 @@ static const void *columnName(
    ** is the case, clear the mallocFailed flag and return NULL.
    */
    if( db->mallocFailed ){
-      db->mallocFailed = 0;
+      sqlite3OomClear(db);
      ret = 0;
    }
    sqlite3_mutex_leave(db->mutex);
@@ -289,7 +289,7 @@ int sqlite3VdbeAddOp4Dup8(
  const u8 *zP4,      /* The P4 operand */
  int p4type          /* P4 operand type */
 ){
-  char *p4copy = sqlite3DbMallocRaw(sqlite3VdbeDb(p), 8);
+  char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8);
  if( p4copy ) memcpy(p4copy, zP4, 8);
  return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type);
 }
@@ -1423,7 +1423,6 @@ static void releaseMemArray(Mem *p, int N){
  if( p && N ){
    Mem *pEnd = &p[N];
    sqlite3 *db = p->db;
-    u8 malloc_failed = db->mallocFailed;
    if( db->pnBytesFreed ){
      do{
        if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
@@ -1459,7 +1458,6 @@ static void releaseMemArray(Mem *p, int N){

      p->flags = MEM_Undefined;
    }while( (++p)<pEnd );
-    db->mallocFailed = malloc_failed;
  }
 }

@@ -1520,7 +1518,7 @@ int sqlite3VdbeList(
  if( p->rc==SQLITE_NOMEM ){
    /* This happens if a malloc() inside a call to sqlite3_column_text() or
    ** sqlite3_column_text16() failed.  */
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
    return SQLITE_ERROR;
  }

@@ -2513,7 +2511,7 @@ int sqlite3VdbeHalt(Vdbe *p){
  ** one, or the complete transaction if there is no statement transaction.
  */

-  if( p->db->mallocFailed ){
+  if( db->mallocFailed ){
    p->rc = SQLITE_NOMEM;
  }
  if( p->aOnceFlag ) memset(p->aOnceFlag, 0, p->nOnceFlag);
@@ -2674,7 +2672,7 @@ int sqlite3VdbeHalt(Vdbe *p){
  }
  p->magic = VDBE_MAGIC_HALT;
  checkActiveVdbeCnt(db);
-  if( p->db->mallocFailed ){
+  if( db->mallocFailed ){
    p->rc = SQLITE_NOMEM;
  }

@@ -2711,12 +2709,12 @@ int sqlite3VdbeTransferError(Vdbe *p){
  sqlite3 *db = p->db;
  int rc = p->rc;
  if( p->zErrMsg ){
-    u8 mallocFailed = db->mallocFailed;
+    db->bBenignMalloc++;
    sqlite3BeginBenignMalloc();
    if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
    sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
    sqlite3EndBenignMalloc();
-    db->mallocFailed = mallocFailed;
+    db->bBenignMalloc--;
    db->errCode = rc;
  }else{
    sqlite3Error(db, rc);
@@ -116,6 +116,7 @@ int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
 SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
  assert( sqlite3VdbeCheckMemInvariants(pMem) );
  assert( (pMem->flags&MEM_RowSet)==0 );
+  testcase( pMem->db==0 );

  /* If the bPreserve flag is set to true, then the memory cell must already
  ** contain a valid string or blob value.  */
@@ -719,7 +720,7 @@ void sqlite3VdbeMemSetRowSet(Mem *pMem){
  assert( db!=0 );
  assert( (pMem->flags & MEM_RowSet)==0 );
  sqlite3VdbeMemRelease(pMem);
-  pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
+  pMem->zMalloc = sqlite3DbMallocRawNN(db, 64);
  if( db->mallocFailed ){
    pMem->flags = MEM_Null;
    pMem->szMalloc = 0;
@@ -1381,7 +1382,7 @@ static int valueFromExpr(
  return rc;

 no_mem:
-  db->mallocFailed = 1;
+  sqlite3OomFault(db);
  sqlite3DbFree(db, zVal);
  assert( *ppVal==0 );
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
@@ -1440,7 +1441,7 @@ static void recordFunc(
  db = sqlite3_context_db_handle(context);

  nRet = 1 + nSerial + nVal;
-  aRet = sqlite3DbMallocRaw(db, nRet);
+  aRet = sqlite3DbMallocRawNN(db, nRet);
  if( aRet==0 ){
    sqlite3_result_error_nomem(context);
  }else{
@@ -49,7 +49,7 @@ static int createModule(
    rc = SQLITE_MISUSE_BKPT;
  }else{
    Module *pMod;
-    pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
+    pMod = (Module *)sqlite3DbMallocRawNN(db, sizeof(Module) + nName + 1);
    if( pMod ){
      Module *pDel;
      char *zCopy = (char *)(&pMod[1]);
@@ -62,7 +62,7 @@ static int createModule(
      pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
      assert( pDel==0 || pDel==pMod );
      if( pDel ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
        sqlite3DbFree(db, pDel);
      }
    }
@@ -439,7 +439,7 @@ void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
    assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
    pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
    if( pOld ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
      assert( pTab==pOld );  /* Malloc must have failed inside HashInsert() */
      return;
    }
@@ -530,7 +530,7 @@ static int vtabCallConstructor(
  db->pVtabCtx = &sCtx;
  rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
  db->pVtabCtx = sCtx.pPrior;
-  if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
+  if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
  assert( sCtx.pTab==pTab );

  if( SQLITE_OK!=rc ){
@@ -1088,7 +1088,7 @@ void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
    pToplevel->apVtabLock = apVtabLock;
    pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
  }else{
-    pToplevel->db->mallocFailed = 1;
+    sqlite3OomFault(pToplevel->db);
  }
 }

@@ -943,7 +943,7 @@ static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){

  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM ){
-      pParse->db->mallocFailed = 1;
+      sqlite3OomFault(pParse->db);
    }else if( !pVtab->zErrMsg ){
      sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
    }else{
@@ -1735,7 +1735,7 @@ static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
  WhereTerm **paNew;
  if( p->nLSlot>=n ) return SQLITE_OK;
  n = (n+7)&~7;
-  paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n);
+  paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n);
  if( paNew==0 ) return SQLITE_NOMEM;
  memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
  if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
@@ -2032,7 +2032,7 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){
 #endif
  if( p==0 ){
    /* Allocate a new WhereLoop to add to the end of the list */
-    *ppPrev = p = sqlite3DbMallocRaw(db, sizeof(WhereLoop));
+    *ppPrev = p = sqlite3DbMallocRawNN(db, sizeof(WhereLoop));
    if( p==0 ) return SQLITE_NOMEM;
    whereLoopInit(p);
    p->pNextLoop = 0;
@@ -3529,7 +3529,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
  /* Allocate and initialize space for aTo, aFrom and aSortCost[] */
  nSpace = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2;
  nSpace += sizeof(LogEst) * nOrderBy;
-  pSpace = sqlite3DbMallocRaw(db, nSpace);
+  pSpace = sqlite3DbMallocRawNN(db, nSpace);
  if( pSpace==0 ) return SQLITE_NOMEM;
  aTo = (WherePath*)pSpace;
  aFrom = aTo+mxChoice;
@@ -495,9 +495,7 @@ static int codeAllEqualityTerms(
  pParse->nMem += nReg;

  zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx));
-  if( !zAff ){
-    pParse->db->mallocFailed = 1;
-  }
+  assert( zAff!=0 || pParse->db->mallocFailed );

  if( nSkip ){
    int iIdxCur = pLevel->iIdxCur;
@@ -64,7 +64,7 @@ static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
  if( pWC->nTerm>=pWC->nSlot ){
    WhereTerm *pOld = pWC->a;
    sqlite3 *db = pWC->pWInfo->pParse->db;
-    pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
+    pWC->a = sqlite3DbMallocRawNN(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
    if( pWC->a==0 ){
      if( wtFlags & TERM_DYNAMIC ){
        sqlite3ExprDelete(db, p);
@@ -549,7 +549,7 @@ static void exprAnalyzeOrTerm(
      WhereAndInfo *pAndInfo;
      assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
      chngToIN = 0;
-      pAndInfo = sqlite3DbMallocRaw(db, sizeof(*pAndInfo));
+      pAndInfo = sqlite3DbMallocRawNN(db, sizeof(*pAndInfo));
      if( pAndInfo ){
        WhereClause *pAndWC;
        WhereTerm *pAndTerm;
@@ -563,7 +563,6 @@ static void exprAnalyzeOrTerm(
        sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
        sqlite3WhereExprAnalyze(pSrc, pAndWC);
        pAndWC->pOuter = pWC;
-        testcase( db->mallocFailed );
        if( !db->mallocFailed ){
          for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
            assert( pAndTerm->pExpr );
@@ -1244,6 +1244,3 @@ do_eqp_test 26.2.2 {


 finish_test
-
-
-
@@ -680,4 +680,3 @@ for {set i 0} {$i<16} {incr i} {
 }

 finish_test
-
@@ -114,4 +114,3 @@ do_eqp_test 1.8 {
 }

 finish_test
-
@@ -321,4 +321,3 @@ do_test 4.5 {

 test_restore_config_pagecache
 finish_test
-
@@ -156,4 +156,3 @@ do_faultsim_test 2.4 -prep {
 }

 finish_test
-
@@ -174,4 +174,3 @@ do_test 3.3 {
 } {1 {database disk image is malformed}}

 finish_test
-
@@ -206,7 +206,6 @@ do_test 6.1 {
  db close
  hexio_write test.db 616 8FFFFFFF7F02
  sqlite3 db test.db
-  breakpoint
  execsql { DELETE FROM t1 WHERE rowid=2 }
 } {}

@@ -287,6 +287,3 @@ ifcapable stat4 {
 }

 finish_test
-
-
-
@@ -72,5 +72,3 @@ do_test 2.1 {
 sqlite3_blob_close $B

 finish_test
-
-
@@ -168,4 +168,3 @@ do_execsql_test 3.5 {
 do_test 4.0 { sqlite3_blob_close 0 } {}

 finish_test
-
@@ -546,4 +546,3 @@ do_test 13.5 {


 finish_test
-
@@ -201,4 +201,3 @@ do_execsql_test 3.2.4 {


 finish_test
-
@@ -751,4 +751,3 @@ do_test 6.5 {


 finish_test
-
@@ -103,4 +103,3 @@ foreach {tn use_stmt sql schema} {


 finish_test
-
@@ -207,4 +207,3 @@ do_execsql_test 5.3 {


 finish_test
-
@@ -212,4 +212,3 @@ do_execsql_test 4.2.2 {
 } {}

 finish_test
-
@@ -79,4 +79,3 @@ do_icu_expr_test    3.9 { "ab*c" } { PHRASE 3 0 ab+ * c }
 do_icu_expr_test    3.10 { ab*c } { AND {PHRASE 3 0 ab+} {PHRASE 3 0 c}}

 finish_test
-
@@ -62,5 +62,3 @@ do_catchsql_test 2.5 {
 } {1 {unable to use function MATCH in the requested context}}

 finish_test
-
-
@@ -524,7 +524,6 @@ foreach {tn expr res} {
  do_execsql_test 11.1.$tn.2  {
    SELECT rowid, mit(matchinfo(tt, 'b')) FROM tt WHERE tt MATCH $expr
  } $r2
-  breakpoint

  do_execsql_test 11.1.$tn.2  {
    SELECT rowid, mit(matchinfo(tt, 'b')) FROM tt WHERE tt MATCH $expr
@@ -552,4 +551,3 @@ do_execsql_test 12.1 {

 set sqlite_fts3_enable_parentheses 0
 finish_test
-
@@ -121,4 +121,3 @@ do_execsql_test 1.4.1 {

 set sqlite_fts3_enable_parentheses 0
 finish_test
-
@@ -559,4 +559,3 @@ do_test 4.2 {

 set sqlite_fts3_enable_parentheses 0
 finish_test
-
@@ -210,4 +210,3 @@ do_execsql_test 5.4 {
 } {}

 finish_test
-
@@ -636,4 +636,3 @@ do_catchsql_test 11.1 {


 finish_test
-
@@ -434,4 +434,3 @@ do_execsql_test 7.7 {


 finish_test
-
@@ -90,4 +90,3 @@ for {set tn 0} {$tn < 40} {incr tn} {


 finish_test
-
@@ -228,6 +228,3 @@ do_execsql_test 6.3.1 {
 } {0 1 1 0 1 1}

 finish_test
-
-
-
@@ -144,4 +144,3 @@ foreach {tn tcl1 tcl2}  {
 }

 finish_test
-
@@ -173,4 +173,3 @@ for {set ii 0} {$ii < 5000} {incr ii} {

 test_restore_config_pagecache
 finish_test
-
@@ -23,7 +23,6 @@ ifcapable !vtab {
 }

 set ::testprefix fuzzer1
-
 load_static_extension db fuzzer

 # Check configuration errors.
@@ -1648,51 +1647,6 @@ do_catchsql_test 5.5.4 {
  CREATE VIRTUAL TABLE x USING fuzzer('fuzzer [x] rules table');
 } {1 {fuzzer: ruleset must be between 0 and 2147483647}}

-#-------------------------------------------------------------------------
-# This test uses a fuzzer table with many rules. There is one rule to
-# map each possible two character string, where characters are lower-case
-# letters used in the English language, to all other possible two character
-# strings. In total, (26^4)-(26^2) mappings (the subtracted term represents
-# the no-op mappings discarded automatically by the fuzzer).
-#
-#
-do_execsql_test 6.1.1 {
-  DROP TABLE IF EXISTS x1;
-  DROP TABLE IF EXISTS x1_rules;
-  CREATE TABLE x1_rules(ruleset, cFrom, cTo, cost);
-}
-puts "This test is slow - perhaps around 7 seconds on an average pc"
-do_test 6.1.2 {
-  set LETTERS {a b c d e f g h i j k l m n o p q r s t u v w x y z}
-  set cost 1
-  db transaction {
-    foreach c1 $LETTERS { 
-      foreach c2 $LETTERS { 
-        foreach c3 $LETTERS { 
-          foreach c4 $LETTERS { 
-            db eval {INSERT INTO x1_rules VALUES(0, $c1||$c2, $c3||$c4, $cost)}
-            set cost [expr ($cost%1000) + 1]
-          }
-        }
-      }
-    }
-    db eval {UPDATE x1_rules SET cost = 20 WHERE cost<20 AND cFrom!='xx'}
-  }
-} {}
-
-do_execsql_test 6.2 {
-  SELECT count(*) FROM x1_rules WHERE cTo!=cFrom;
-} [expr 26*26*26*26 - 26*26]
-
-do_execsql_test 6.2.1 {
-  CREATE VIRTUAL TABLE x1 USING fuzzer(x1_rules);
-  SELECT word FROM x1 WHERE word MATCH 'xx' LIMIT 10;
-} {xx hw hx hy hz ia ib ic id ie}
-do_execsql_test 6.2.2 {
-  SELECT cTo FROM x1_rules WHERE cFrom='xx' 
-  ORDER BY cost asc, rowid asc LIMIT 9;
-} {hw hx hy hz ia ib ic id ie}
-
 #-------------------------------------------------------------------------
 # Test using different types of quotes with CREATE VIRTUAL TABLE 
 # arguments.
@@ -0,0 +1,72 @@
+# 2016 February 4
+#
+# 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.
+#
+#***********************************************************************
+# The focus of the tests is the word-fuzzer virtual table. The tests
+# in this file are slower than those in fuzzer1.test. So this file does
+# not run as part of veryquick.test etc.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+ifcapable !vtab {
+  finish_test
+  return
+}
+
+set ::testprefix fuzzer2
+load_static_extension db fuzzer
+
+#-------------------------------------------------------------------------
+# This test uses a fuzzer table with many rules. There is one rule to
+# map each possible two character string, where characters are lower-case
+# letters used in the English language, to all other possible two character
+# strings. In total, (26^4)-(26^2) mappings (the subtracted term represents
+# the no-op mappings discarded automatically by the fuzzer).
+#
+#
+do_execsql_test 1.1.1 {
+  DROP TABLE IF EXISTS x1;
+  DROP TABLE IF EXISTS x1_rules;
+  CREATE TABLE x1_rules(ruleset, cFrom, cTo, cost);
+}
+puts "This test is slow - perhaps around 7 seconds on an average pc"
+do_test 1.1.2 {
+  set LETTERS {a b c d e f g h i j k l m n o p q r s t u v w x y z}
+  set cost 1
+  db transaction {
+    foreach c1 $LETTERS { 
+      foreach c2 $LETTERS { 
+        foreach c3 $LETTERS { 
+          foreach c4 $LETTERS { 
+            db eval {INSERT INTO x1_rules VALUES(0, $c1||$c2, $c3||$c4, $cost)}
+            set cost [expr ($cost%1000) + 1]
+          }
+        }
+      }
+    }
+    db eval {UPDATE x1_rules SET cost = 20 WHERE cost<20 AND cFrom!='xx'}
+  }
+} {}
+
+do_execsql_test 1.2 {
+  SELECT count(*) FROM x1_rules WHERE cTo!=cFrom;
+} [expr 26*26*26*26 - 26*26]
+
+do_execsql_test 1.2.1 {
+  CREATE VIRTUAL TABLE x1 USING fuzzer(x1_rules);
+  SELECT word FROM x1 WHERE word MATCH 'xx' LIMIT 10;
+} {xx hw hx hy hz ia ib ic id ie}
+do_execsql_test 1.2.2 {
+  SELECT cTo FROM x1_rules WHERE cFrom='xx' 
+  ORDER BY cost asc, rowid asc LIMIT 9;
+} {hw hx hy hz ia ib ic id ie}
+
+finish_test
@@ -124,4 +124,3 @@ do_test 2.16 { sqlite3_errcode db } {SQLITE_CORRUPT}
 do_test 2.17 { sqlite3_errmsg db } {database disk image is malformed}

 finish_test
-
@@ -342,4 +342,19 @@ foreach {tn isvalid ws} {
  $isvalid
 }

+# Ticket https://www.sqlite.org/src/info/ad2559db380abf8e
+# Control characters must be escaped in JSON strings.
+#
+do_execsql_test json-8.1 {
+  DROP TABLE IF EXISTS t8;
+  CREATE TABLE t8(a,b);
+  INSERT INTO t8(a) VALUES('abc' || char(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35) || 'xyz');
+  UPDATE t8 SET b=json_array(a);
+  SELECT b FROM t8;
+} {{["abc\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f !\"#xyz"]}}
+do_execsql_test json-8.2 {
+  SELECT a=json_extract(b,'$[0]') FROM t8;
+} {1}
+
+
 finish_test
@@ -172,4 +172,3 @@ do_faultsim_test 8 -faults oom* -body {


 finish_test
-
@@ -40,4 +40,3 @@ for {set j 1} {$j < 40} {incr j} {


 finish_test
-
@@ -28,6 +28,10 @@ proc nRead {db} {
  return $stats(read)
 }

+# Return a Tcl script that registers a user-defined scalar function 
+# named rblob() with database handle $dbname. The function returns a
+# sequence of pseudo-random blobs based on seed value $seed.
+#
 proc register_rblob_code {dbname seed} {
  return [subst -nocommands {
    set ::rcnt $seed
@@ -40,6 +44,7 @@ proc register_rblob_code {dbname seed} {
  }]
 }

+
 # For cases 1.1 and 1.4, the number of pages read using xRead() is 4 on
 # unix and 9 on windows. The difference is that windows only ever maps
 # an integer number of OS pages (i.e. creates mappings that are a multiple
@@ -269,65 +274,5 @@ do_test 5.5 {
  sqlite3_finalize $::STMT
 } SQLITE_OK

-#-------------------------------------------------------------------------
-# Test various mmap_size settings.
-#
-foreach {tn1 mmap1 mmap2} {
-     1 6144       167773
-     2 18432      140399
-     3 43008      401302
-     4 92160      253899
-     5 190464          2
-     6 387072     752431
-     7 780288     291143
-     8 1566720    594306
-     9 3139584    829137
-     10 6285312   793963
-     11 12576768 1015590
-} {
-  do_multiclient_test tn {
-    sql1 {
-      CREATE TABLE t1(a PRIMARY KEY);
-      CREATE TABLE t2(x);
-      INSERT INTO t2 VALUES('');
-    }
-
-    code1 [register_rblob_code db  0]
-    code2 [register_rblob_code db2 444]
-
-    sql1 "PRAGMA mmap_size = $mmap1"
-    sql2 "PRAGMA mmap_size = $mmap2"
-
-    do_test $tn1.$tn {
-      for {set i 1} {$i <= 100} {incr i} {
-        if {$i % 2} {
-          set c1 sql1
-            set c2 sql2
-        } else {
-          set c1 sql2
-            set c2 sql1
-        }
-
-        $c1 {
-          INSERT INTO t1 VALUES( rblob(5000) );
-          UPDATE t2 SET x = (SELECT md5sum(a) FROM t1);
-        }
-
-        set res [$c2 {
-            SELECT count(*) FROM t1;
-            SELECT x == (SELECT md5sum(a) FROM t1) FROM t2;
-            PRAGMA integrity_check;
-        }]
-        if {$res != [list $i 1 ok]} {
-          do_test $tn1.$tn.$i {
-            set ::res
-          } [list $i 1 ok]
-        }
-      }
-      set res 1
-    } {1}
-  }
-}
-

 finish_test
@@ -0,0 +1,104 @@
+# 2016 February 04
+#
+# 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 tests the effect of the mmap() or mremap() system calls 
+# returning an error on the library. 
+#
+# If either mmap() or mremap() fails, SQLite should log an error 
+# message, then continue accessing the database using read() and 
+# write() exclusively.
+# 
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+ifcapable !mmap {
+  finish_test
+  return
+}
+source $testdir/lock_common.tcl
+set testprefix mmap4
+
+# Return a Tcl script that registers a user-defined scalar function 
+# named rblob() with database handle $dbname. The function returns a
+# sequence of pseudo-random blobs based on seed value $seed.
+#
+proc register_rblob_code {dbname seed} {
+  return [subst -nocommands {
+    set ::rcnt $seed
+    proc rblob {n} {
+      set ::rcnt [expr (([set ::rcnt] << 3) + [set ::rcnt] + 456) & 0xFFFFFFFF]
+      set str [format %.8x [expr [set ::rcnt] ^ 0xbdf20da3]]
+      string range [string repeat [set str] [expr [set n]/4]] 1 [set n]
+    }
+    $dbname func rblob rblob
+  }]
+}
+
+#-------------------------------------------------------------------------
+# Test various mmap_size settings.
+#
+foreach {tn1 mmap1 mmap2} {
+     1 6144       167773
+     2 18432      140399
+     3 43008      401302
+     4 92160      253899
+     5 190464          2
+     6 387072     752431
+     7 780288     291143
+     8 1566720    594306
+     9 3139584    829137
+     10 6285312   793963
+     11 12576768 1015590
+} {
+  do_multiclient_test tn {
+    sql1 {
+      CREATE TABLE t1(a PRIMARY KEY);
+      CREATE TABLE t2(x);
+      INSERT INTO t2 VALUES('');
+    }
+
+    code1 [register_rblob_code db  0]
+    code2 [register_rblob_code db2 444]
+
+    sql1 "PRAGMA mmap_size = $mmap1"
+    sql2 "PRAGMA mmap_size = $mmap2"
+
+    do_test $tn1.$tn {
+      for {set i 1} {$i <= 100} {incr i} {
+        if {$i % 2} {
+          set c1 sql1
+            set c2 sql2
+        } else {
+          set c1 sql2
+            set c2 sql1
+        }
+
+        $c1 {
+          INSERT INTO t1 VALUES( rblob(5000) );
+          UPDATE t2 SET x = (SELECT md5sum(a) FROM t1);
+        }
+
+        set res [$c2 {
+            SELECT count(*) FROM t1;
+            SELECT x == (SELECT md5sum(a) FROM t1) FROM t2;
+            PRAGMA integrity_check;
+        }]
+        if {$res != [list $i 1 ok]} {
+          do_test $tn1.$tn.$i {
+            set ::res
+          } [list $i 1 ok]
+        }
+      }
+      set res 1
+    } {1}
+  }
+}
+
+finish_test
@@ -45,5 +45,3 @@ do_execsql_test 1.2 {
 } [expr 2000 * 2000]

 finish_test
-
-
@@ -113,7 +113,14 @@ set allquicktests [test_set $alltests -exclude {
  vtab_err.test walslow.test walcrash.test walcrash3.test
  walthread.test rtree3.test indexfault.test securedel2.test
  sort3.test sort4.test fts4growth.test fts4growth2.test
-  bigsort.test rbu.test
+  bigsort.test rbu.test walprotocol.test mmap4.test fuzzer2.test
+  walcrash2.test e_fkey.test backup.test
+
+  fts4merge.test fts4merge2.test fts4merge4.test fts4check.test
+  fts3cov.test fts3snippet.test fts3corrupt2.test fts3an.test
+  fts3defer.test fts4langid.test fts3sort.test fts5unicode.test
+
+  rtree4.test
 }]
 if {[info exists ::env(QUICKTEST_INCLUDE)]} {
  set allquicktests [concat $allquicktests $::env(QUICKTEST_INCLUDE)]
@@ -150,7 +157,7 @@ test_suite "veryquick" -prefix "" -description {
  This test suite is the same as the "quick" tests, except that some files
  that test malloc and IO errors are omitted.
 } -files [
-  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile*
+  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile* *_err*
 ]

 test_suite "extraquick" -prefix "" -description {
@@ -158,7 +165,7 @@ test_suite "extraquick" -prefix "" -description {
  This test suite is the same as the "veryquick" tests, except that
  slower tests are omitted.
 } -files [
-  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile* \
+  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *bigfile* *_err* \
     wal3.test fts4merge* sort2.test mmap1.test walcrash* \
     percentile.test where8m.test walcksum.test savepoint3.test \
     fuzzer1.test fuzzer3.test fts3expr3.test
@@ -176,7 +183,7 @@ test_suite "valgrind" -prefix "" -description {
  Run the "veryquick" test suite with a couple of multi-process tests (that
  fail under valgrind) omitted.
 } -files [
-  test_set $allquicktests -exclude *malloc* *ioerr* *fault* wal.test \
+  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *_err* wal.test \
              shell*.test crash8.test atof1.test selectG.test \
              tkt-fc62af4523.test numindex1.test
 ] -initialize {
@@ -189,7 +196,8 @@ test_suite "valgrind-nolookaside" -prefix "" -description {
  Run the "veryquick" test suite with a couple of multi-process tests (that
  fail under valgrind) omitted.
 } -files [
-  test_set $allquicktests -exclude *malloc* *ioerr* *fault* wal.test atof1.test
+  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *_err* \
+      wal.test atof1.test
 ] -initialize {
  set ::G(valgrind) 1
  catch {db close}
@@ -266,7 +274,7 @@ test_suite "nofaultsim" -prefix "" -description {
  This test suite is the same as the "quick" tests, except that some files
  that test malloc and IO errors are omitted.
 } -files [
-  test_set $allquicktests -exclude *malloc* *ioerr* *fault*
+  test_set $allquicktests -exclude *malloc* *ioerr* *fault* *_err*
 ] -initialize {
  catch {db close}
  sqlite3_shutdown
@@ -255,7 +255,6 @@ db close
 forcedelete test.db
 sqlite3 db test.db

-breakpoint
 do_execsql_test pragma2-5.1 {
  PRAGMA page_size=16384;
  CREATE TABLE t1(x);
@@ -21,6 +21,7 @@ ifcapable !curdir {

 source $testdir/malloc_common.tcl

+forcedelete bak.db
 unset -nocomplain defaultVfs
 set defaultVfs [file_control_vfsname db]
 db close
@@ -154,4 +154,3 @@ do_rollback_test 4.4 -setup {
 }

 finish_test
-
@@ -80,5 +80,3 @@ foreach f {oom ioerr} {


 finish_test
-
-
@@ -9,14 +9,15 @@
 #
 #***********************************************************************
 #
-# $Id: savepoint3.test,v 1.5 2009/06/05 17:09:12 drh Exp $

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

 source $testdir/malloc_common.tcl

-do_malloc_test savepoint3-1 -sqlprep {
+set testprefix savepointfault
+
+do_malloc_test 1 -sqlprep {
  CREATE TABLE t1(a, b, c);
  INSERT INTO t1 VALUES(1, 2, 3);
 } -sqlbody {
@@ -28,7 +29,7 @@ do_malloc_test savepoint3-1 -sqlprep {
  RELEASE one;
 }

-do_malloc_test savepoint3-2 -sqlprep {
+do_malloc_test 2 -sqlprep {
  PRAGMA cache_size = 10;
  CREATE TABLE t1(a, b, c);
  INSERT INTO t1 VALUES(randstr(400,400), randstr(400,400), randstr(400,400));
@@ -59,7 +60,7 @@ do_malloc_test savepoint3-2 -sqlprep {
  RELEASE one;
 }

-do_ioerr_test savepoint3.3 -sqlprep {
+do_ioerr_test 3 -sqlprep {
  CREATE TABLE t1(a, b, c);
  INSERT INTO t1 VALUES(1, randstr(1000,1000), randstr(1000,1000));
  INSERT INTO t1 VALUES(2, randstr(1000,1000), randstr(1000,1000));
@@ -79,7 +80,7 @@ do_ioerr_test savepoint3.3 -sqlprep {
 # The following test does a really big savepoint rollback. One involving
 # more than 4000 pages. The idea is to get a specific sqlite3BitvecSet()
 # operation in pagerPlaybackSavepoint() to fail.
-#do_malloc_test savepoint3-4 -sqlprep {
+#do_malloc_test 4 -sqlprep {
 #  BEGIN;
 #    CREATE TABLE t1(a, b);
 #    CREATE INDEX i1 ON t1(a);
@@ -107,7 +108,7 @@ do_ioerr_test savepoint3.3 -sqlprep {

 # Cause a specific malloc in savepoint rollback code to fail.
 #
-do_malloc_test savepoint3-4 -start 7 -sqlprep {
+do_malloc_test 4 -start 7 -sqlprep {
  PRAGMA auto_vacuum = incremental;
  PRAGMA cache_size = 1000;

@@ -220,5 +220,3 @@ do_catchsql_test 8.2 {


 finish_test
-
-
@@ -139,4 +139,3 @@ do_test 3.5 {

 sqlite3_enable_shared_cache $::enable_shared_cache
 finish_test
-
@@ -55,7 +55,6 @@ do_execsql_test 2.1.0 {
    SELECT * FROM t1;
 } {1 2 3 4 5 6 7 8}

-breakpoint
 do_test 2.1.1 {
  set snapshot [sqlite3_snapshot_get db main]
  execsql {
@@ -491,52 +491,6 @@ do_execsql_test sort-13.3 {
  SELECT a, b FROM t10 ORDER BY a;
 } [db eval {SELECT a, b FROM t10 ORDER BY a, b}]

-#-------------------------------------------------------------------------
-# Sort some large ( > 4KiB) records.
-#
-proc cksum {x} {
-  set i1 1
-  set i2 2
-  binary scan $x c* L
-  foreach {a b} $L {
-    set i1 [expr (($i2<<3) + $a) & 0x7FFFFFFF]
-    set i2 [expr (($i1<<3) + $b) & 0x7FFFFFFF]
-  }
-  list $i1 $i2
-}
-db func cksum cksum
-
-do_execsql_test sort-14.0 {
-  PRAGMA cache_size = 5;
-  CREATE TABLE t11(a, b);
-  INSERT INTO t11 VALUES(randomblob(5000), NULL);
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --2
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --3
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --4
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --5
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --6
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --7
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --8
-  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --9
-  UPDATE t11 SET b = cksum(a);
-}
-
-foreach {tn mmap_limit} {
-  1 0
-  2 1000000
-} {
-  do_test sort-14.$tn {
-    sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $mmap_limit
-    set prev ""
-    db eval { SELECT * FROM t11 ORDER BY b } {
-      if {$b != [cksum $a]} {error "checksum failed"}
-      if {[string compare $b $prev] < 0} {error "sort failed"}
-      set prev $b
-    }
-    set {} {}
-  } {}
-}
-
 #-------------------------------------------------------------------------
 #
 foreach {tn mmap_limit nWorker tmpstore coremutex fakeheap softheaplimit} {
@@ -31,7 +31,6 @@ foreach {tn script} {
    catch { db eval {PRAGMA threads=7} }
  }
 } {
-
  eval $script

  do_execsql_test $tn.1 {
@@ -67,17 +66,22 @@ foreach {tn script} {
  
  do_execsql_test $tn.2.4 { PRAGMA integrity_check } {ok}
  
-  do_execsql_test $tn.3 {
-    PRAGMA cache_size = 5;
-    WITH r(x,y) AS (
-      SELECT 1, randomblob(100)
-      UNION ALL
-      SELECT x+1, randomblob(100) FROM r
-      LIMIT 1000000
-    )
-    SELECT count(x), length(y) FROM r GROUP BY (x%5)
-  } {
-    200000 100 200000 100 200000 100 200000 100 200000 100
+  # Because it uses so much data, this test can take 12-13 seconds even on
+  # a modern workstation. So it is omitted from "veryquick" and other
+  # permutations.test tests.
+  if {[isquick]==0} {
+    do_execsql_test $tn.3 {
+      PRAGMA cache_size = 5;
+      WITH r(x,y) AS (
+          SELECT 1, randomblob(100)
+          UNION ALL
+          SELECT x+1, randomblob(100) FROM r
+          LIMIT 1000000
+          )
+        SELECT count(x), length(y) FROM r GROUP BY (x%5)
+    } {
+      200000 100 200000 100 200000 100 200000 100 200000 100
+    }
  }
 }

@@ -19,6 +19,53 @@ set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 set testprefix sort3

+#-------------------------------------------------------------------------
+# Sort some large ( > 4KiB) records.
+#
+proc cksum {x} {
+  set i1 1
+  set i2 2
+  binary scan $x c* L
+  foreach {a b} $L {
+    set i1 [expr (($i2<<3) + $a) & 0x7FFFFFFF]
+    set i2 [expr (($i1<<3) + $b) & 0x7FFFFFFF]
+  }
+  list $i1 $i2
+}
+db func cksum cksum
+
+do_execsql_test 1.0 {
+  PRAGMA cache_size = 5;
+  CREATE TABLE t11(a, b);
+  INSERT INTO t11 VALUES(randomblob(5000), NULL);
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --2
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --3
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --4
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --5
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --6
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --7
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --8
+  INSERT INTO t11 SELECT randomblob(5000), NULL FROM t11; --9
+  UPDATE t11 SET b = cksum(a);
+}
+
+foreach {tn mmap_limit} {
+  1 0
+  2 1000000
+} {
+  do_test 1.$tn {
+    sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $mmap_limit
+    set prev ""
+    db eval { SELECT * FROM t11 ORDER BY b } {
+      if {$b != [cksum $a]} {error "checksum failed"}
+      if {[string compare $b $prev] < 0} {error "sort failed"}
+      set prev $b
+    }
+    set {} {}
+  } {}
+}
+
+
 # Sort roughly 20MB of data. Once with a mmap limit of 5MB and once without.
 #
 foreach {itest limit} {
@@ -26,7 +73,7 @@ foreach {itest limit} {
  2 0x7FFFFFFF
 } {
  sqlite3_test_control SQLITE_TESTCTRL_SORTER_MMAP db $limit
-  do_execsql_test 1.$itest {
+  do_execsql_test 2.$itest {
    WITH r(x,y) AS (
        SELECT 1, randomblob(1000)
        UNION ALL
@@ -46,7 +93,7 @@ foreach {itest limit} {
 # Sort more than 2GB of data. At one point this was causing a problem.
 # This test might take one minute or more to run.
 #
-do_execsql_test 2 {
+do_execsql_test 3 {
  PRAGMA cache_size = 20000;
  WITH r(x,y) AS (
    SELECT 1, randomblob(1000)
@@ -64,4 +111,3 @@ do_execsql_test 2 {
 }

 finish_test
-
@@ -42,4 +42,3 @@ do_execsql_test 1.2 {
 db close
 tvfs delete
 finish_test
-
@@ -403,4 +403,3 @@ foreach {tn conflict err bRollback res} {
 }

 finish_test
-
@@ -110,7 +110,4 @@ unset ::env(SQLITE_SQLLOG_DIR)
 unset ::env(SQLITE_SQLLOG_CONDITIONAL)
 sqlite3_config_sqllog
 sqlite3_initialize
-breakpoint
 finish_test
-
-
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mistachkin	a6f28893ed	More work on Windows 10 SDK integration. FossilOrigin-Name: ebace2c99b6af9230c4bbc31a764c7f397200148	2016-02-05 19:40:23 +00:00
dan	b80b8f482c	Further streamlining of fts5 prefix query code. FossilOrigin-Name: ca91bd8ac70a5b3fef127364f73ec675e58bb92c	2016-02-05 19:18:02 +00:00
drh	1cd0f05492	Make sure the "bak.db" database file does not actually exist before starting the "quota.test" testing. FossilOrigin-Name: 1cac6c45eeb7dbbcda0c76ba7d3a2ca77bc725cd	2016-02-05 17:49:43 +00:00
drh	a23bc8a345	From test scripts, remove stray "breakpoint" commands and blank lines at the ends of files. FossilOrigin-Name: a6b35273239669189f33402144f58328b133d182	2016-02-05 16:46:09 +00:00
drh	0539702b8e	Improvements to the way out-of-memory conditions are handled, resulting in an almost 1% performance gain in the commmon case where OOM errors do not occur. FossilOrigin-Name: b082538da774ac77f284fd7e22f9b1b9c2abc343	2016-02-05 14:11:12 +00:00
drh	575fad6500	Add the slightly faster sqlite3DbMallocRawNN(db,n) routine for the majority cases where db is guaranteed to be not NULL. FossilOrigin-Name: 0a802e96ab06e2643834b83671fa8353da1a348d	2016-02-05 13:38:36 +00:00
mistachkin	b91d2214fe	Improve ERRORLEVEL handling in the MSVC batch build tool sub-routine 'fn_UnsetVariable'. FossilOrigin-Name: fe123ab4f17f97ba9d64a7e0589ac47fd9d43877	2016-02-05 04:55:01 +00:00
drh	98c7a12c00	OOM failures on sqlite3_errmsg16() in an app-defined function are no longer benign. FossilOrigin-Name: 9efb223f4ce8ccc00515f8f016f7c494c9ae5096	2016-02-05 04:50:27 +00:00
mistachkin	02de84e562	Another small tweak to the MSVC batch build tool. FossilOrigin-Name: 76718bbce775e13a82893be519ddd98b2f3a4942	2016-02-05 04:39:11 +00:00
drh	17a936f84a	Minor simplification of schema error reporting. FossilOrigin-Name: a8846aeed9992c6c9f1c8bd6e996a4cbe891751e	2016-02-05 02:50:11 +00:00
drh	b84e574c89	Further performance improvements that fall out of the mallocFailed changes. FossilOrigin-Name: d94416ddca8f7ed727dd335d38155ea5945a86b7	2016-02-05 02:42:54 +00:00
drh	4a642b6060	Improvements to the way that OOM errors are processed. FossilOrigin-Name: c3ef03478a5788c855b3aef385d43ae7f494f440	2016-02-05 01:55:27 +00:00
drh	e514f651d0	Temporarily back out the 0.5% performance improvement from check-in [632071bac5ff32]. Need a more elaborate solution that works with reentrant virtual tables and SQL functions. FossilOrigin-Name: 42736fb0adc82a0fb692850ff3dd3f9b501cbf1f	2016-02-04 19:50:33 +00:00
dan	4786cf5a20	Further improve performance of unindexed fts5 prefix queries. FossilOrigin-Name: c9c6457d8ea911f6cc63967127e58da3146fd3ef	2016-02-04 19:45:19 +00:00
dan	be7721d103	Avoid running some particularly time-consuming tests as part of veryquick.test. FossilOrigin-Name: f465944b75a800ddc6920229ad32c2f39ff91e19	2016-02-04 17:31:03 +00:00
drh	4df86af329	Remove unnecessary sets of db->mallocFailed. FossilOrigin-Name: b787165b25a240fd5b4a5c7f73b395f30213a1d7	2016-02-04 11:48:00 +00:00
drh	c4703eedab	Use sqlite3_malloc64() instead of sqlite3_malloc() in the spellfix extension. FossilOrigin-Name: 634d008c34bd237fc9cfb88dc291394fc5d31efa	2016-02-04 11:15:57 +00:00
drh	3b7f9a68d5	Escape control characters in JSON. Fix for ticket [ad2559db380abf8]. FossilOrigin-Name: 4f1b5229a3bbc9d40b7433a5eb3139d59d31dcb1	2016-02-04 10:28:57 +00:00
drh	6d258995e6	Refinements to synchronous logic: (1) Use PAGER_SYNCHRONOUS_FULL rather than the corresponding magic number. (2) Honor SQLITE_NO_SYNC on xDelete calls with sync (3) Count xDelete syncs during testing (4) Fix #ifs on SQLITE_EXTRA_DURABLE so that directory syncs on journal unlink are off by default. FossilOrigin-Name: e3157cb5ad0d22758e766a95fb1463a7810f7d7f	2016-02-04 09:48:12 +00:00
				`@@ -103,4 +103,3 @@ foreach {tn use_stmt sql schema} {`


				`finish_test`
				`@@ -90,4 +90,3 @@ for {set tn 0} {$tn < 40} {incr tn} {`


				`finish_test`
				`@@ -172,4 +172,3 @@ do_faultsim_test 8 -faults oom* -body {`


				`finish_test`
				`@@ -40,4 +40,3 @@ for {set j 1} {$j < 40} {incr j} {`


				`finish_test`