Index: Makefile.in
==================================================================
--- Makefile.in
+++ Makefile.in
@@ -167,10 +167,11 @@
          backup.lo bitvec.lo btmutex.lo btree.lo build.lo \
          callback.lo complete.lo ctime.lo date.lo delete.lo \
          expr.lo fault.lo fkey.lo \
          fts3.lo fts3_aux.lo fts3_expr.lo fts3_hash.lo fts3_icu.lo \
          fts3_porter.lo fts3_snippet.lo fts3_tokenizer.lo fts3_tokenizer1.lo \
+         fts3_tokenize_vtab.lo \
          fts3_unicode.lo fts3_unicode2.lo fts3_write.lo \
          func.lo global.lo hash.lo \
          icu.lo insert.lo journal.lo legacy.lo loadext.lo \
          main.lo malloc.lo mem0.lo mem1.lo mem2.lo mem3.lo mem5.lo \
          memjournal.lo \
@@ -317,10 +318,11 @@
   $(TOP)/ext/fts3/fts3_porter.c \
   $(TOP)/ext/fts3/fts3_snippet.c \
   $(TOP)/ext/fts3/fts3_tokenizer.h \
   $(TOP)/ext/fts3/fts3_tokenizer.c \
   $(TOP)/ext/fts3/fts3_tokenizer1.c \
+  $(TOP)/ext/fts3/fts3_tokenize_vtab.c \
   $(TOP)/ext/fts3/fts3_unicode.c \
   $(TOP)/ext/fts3/fts3_unicode2.c \
   $(TOP)/ext/fts3/fts3_write.c
 SRC += \
   $(TOP)/ext/icu/sqliteicu.h \
@@ -508,10 +510,15 @@
 
 sqlite3$(TEXE):	$(TOP)/src/shell.c libsqlite3.la sqlite3.h
 	$(LTLINK) $(READLINE_FLAGS) \
 		-o $@ $(TOP)/src/shell.c libsqlite3.la \
 		$(LIBREADLINE) $(TLIBS) -rpath "$(libdir)"
+
+mptester$(EXE):	sqlite3.c $(TOP)/mptest/mptest.c
+	$(LTLINK) -o $@ -I. $(TOP)/mptest/mptest.c sqlite3.c \
+		$(TLIBS) -rpath "$(libdir)"
+
 
 # This target creates a directory named "tsrc" and fills it with
 # copies of all of the C source code and header files needed to
 # build on the target system.  Some of the C source code and header
 # files are automatically generated.  This target takes care of
@@ -861,10 +868,13 @@
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer.c
 
 fts3_tokenizer1.lo:	$(TOP)/ext/fts3/fts3_tokenizer1.c $(HDR) $(EXTHDR)
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer1.c
 
+fts3_tokenizer_vtab.lo:	$(TOP)/ext/fts3/fts3_tokenizer_vtab.c $(HDR) $(EXTHDR)
+	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer_vtab.c
+
 fts3_unicode.lo:	$(TOP)/ext/fts3/fts3_unicode.c $(HDR) $(EXTHDR)
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_unicode.c
 
 fts3_unicode2.lo:	$(TOP)/ext/fts3/fts3_unicode2.c $(HDR) $(EXTHDR)
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_unicode2.c
@@ -957,12 +967,15 @@
 	rm -rf tsrc .target_source
 	rm -f tclsqlite3$(TEXE)
 	rm -f testfixture$(TEXE) test.db
 	rm -f sqlite3.dll sqlite3.lib sqlite3.exp sqlite3.def
 	rm -f sqlite3.c
+	rm -f sqlite3rc.h
+	rm -f shell.c sqlite3ext.h
 	rm -f sqlite3_analyzer$(TEXE) sqlite3_analyzer.c
 	rm -f sqlite-*-output.vsix
+	rm -f mptester mptester.exe
 
 distclean:	clean
 	rm -f config.log config.status libtool Makefile sqlite3.pc
 
 #

Index: Makefile.msc
==================================================================
--- Makefile.msc
+++ Makefile.msc
@@ -480,11 +480,11 @@
          backup.lo bitvec.lo btmutex.lo btree.lo build.lo \
          callback.lo complete.lo ctime.lo date.lo delete.lo \
          expr.lo fault.lo fkey.lo \
          fts3.lo fts3_aux.lo fts3_expr.lo fts3_hash.lo fts3_icu.lo \
          fts3_porter.lo fts3_snippet.lo fts3_tokenizer.lo fts3_tokenizer1.lo \
-         fts3_unicode.lo fts3_unicode2.lo fts3_write.lo \
+         fts3_tokenize_vtab.lo fts3_unicode.lo fts3_unicode2.lo fts3_write.lo \
          func.lo global.lo hash.lo \
          icu.lo insert.lo journal.lo legacy.lo loadext.lo \
          main.lo malloc.lo mem0.lo mem1.lo mem2.lo mem3.lo mem5.lo \
          memjournal.lo \
          mutex.lo mutex_noop.lo mutex_unix.lo mutex_w32.lo \
@@ -641,10 +641,11 @@
   $(TOP)\ext\fts3\fts3_porter.c \
   $(TOP)\ext\fts3\fts3_snippet.c \
   $(TOP)\ext\fts3\fts3_tokenizer.h \
   $(TOP)\ext\fts3\fts3_tokenizer.c \
   $(TOP)\ext\fts3\fts3_tokenizer1.c \
+  $(TOP)\ext\fts3\fts3_tokenize_vtab.c \
   $(TOP)\ext\fts3\fts3_unicode.c \
   $(TOP)\ext\fts3\fts3_unicode2.c \
   $(TOP)\ext\fts3\fts3_write.c
 SRC = $(SRC) \
   $(TOP)\ext\icu\sqliteicu.h \
@@ -756,10 +757,11 @@
   parse.c \
   $(TOP)\ext\fts3\fts3.c \
   $(TOP)\ext\fts3\fts3_aux.c \
   $(TOP)\ext\fts3\fts3_expr.c \
   $(TOP)\ext\fts3\fts3_tokenizer.c \
+  $(TOP)\ext\fts3\fts3_tokenize_vtab.c \
   $(TOP)\ext\fts3\fts3_unicode.c \
   $(TOP)\ext\fts3\fts3_unicode2.c \
   $(TOP)\ext\fts3\fts3_write.c \
   $(TOP)\ext\async\sqlite3async.c \
   $(TOP)\ext\session\sqlite3session.c
@@ -830,10 +832,14 @@
 sqlite3.exe:	$(TOP)\src\shell.c libsqlite3.lib $(LIBRESOBJS) sqlite3.h
 	$(LTLINK) $(READLINE_FLAGS) \
 		$(TOP)\src\shell.c \
 		/link $(LTLINKOPTS) $(LTLIBPATHS) libsqlite3.lib $(LIBRESOBJS) $(LIBREADLINE) $(LTLIBS) $(TLIBS)
 
+mptester.exe:	$(TOP)\mptest\mptest.c libsqlite3.lib $(LIBRESOBJS) sqlite3.h
+	$(LTLINK) $(TOP)\mptest\mptest.c \
+		/link $(LTLINKOPTS) $(LTLIBPATHS) libsqlite3.lib $(LIBRESOBJS) $(LIBREADLINE) $(LTLIBS) $(TLIBS)
+
 # This target creates a directory named "tsrc" and fills it with
 # copies of all of the C source code and header files needed to
 # build on the target system.  Some of the C source code and header
 # files are automatically generated.  This target takes care of
 # all that automatic generation.
@@ -1190,10 +1196,13 @@
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)\ext\fts3\fts3_tokenizer.c
 
 fts3_tokenizer1.lo:	$(TOP)\ext\fts3\fts3_tokenizer1.c $(HDR) $(EXTHDR)
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)\ext\fts3\fts3_tokenizer1.c
 
+fts3_tokenize_vtab.lo:	$(TOP)\ext\fts3\fts3_tokenize_vtab.c $(HDR) $(EXTHDR)
+	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)\ext\fts3\fts3_tokenize_vtab.c
+
 fts3_unicode.lo:	$(TOP)\ext\fts3\fts3_unicode.c $(HDR) $(EXTHDR)
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)\ext\fts3\fts3_unicode.c
 
 fts3_unicode2.lo:	$(TOP)\ext\fts3\fts3_unicode2.c $(HDR) $(EXTHDR)
 	$(LTCOMPILE) -DSQLITE_CORE -c $(TOP)\ext\fts3\fts3_unicode2.c
@@ -1271,12 +1280,14 @@
 	del /Q tclsqlite3.exe tclsqlite3.exp
 	del /Q testfixture.exe testfixture.exp test.db
 	del /Q sqlite3.dll sqlite3.lib sqlite3.exp sqlite3.def
 	del /Q sqlite3.c
 	del /Q sqlite3rc.h
+	del /Q shell.c sqlite3ext.h
 	del /Q sqlite3_analyzer.exe sqlite3_analyzer.exp sqlite3_analyzer.c
 	del /Q sqlite-*-output.vsix
+	del /Q mptester.exe
 
 # Dynamic link library section.
 #
 dll: sqlite3.dll
 

Index: Makefile.vxworks
==================================================================
--- Makefile.vxworks
+++ Makefile.vxworks
@@ -660,6 +660,8 @@
 	rm -f *.da *.bb *.bbg gmon.out
 	rm -rf quota2a quota2b quota2c
 	rm -rf tsrc target_source
 	rm -f testloadext.dll libtestloadext.so
 	rm -f sqlite3.c fts?amal.c tclsqlite3.c
+	rm -f sqlite3rc.h
+	rm -f shell.c sqlite3ext.h
 	rm -f $(SHPREFIX)sqlite3.$(SO)

Index: ext/fts3/fts3.c
==================================================================
--- ext/fts3/fts3.c
+++ ext/fts3/fts3.c
@@ -3591,10 +3591,13 @@
 #endif
 
   rc = sqlite3Fts3InitAux(db);
   if( rc!=SQLITE_OK ) return rc;
 
+  rc = sqlite3Fts3InitTok(db);
+  if( rc!=SQLITE_OK ) return rc;
+
   sqlite3Fts3SimpleTokenizerModule(&pSimple);
   sqlite3Fts3PorterTokenizerModule(&pPorter);
 
   /* Allocate and initialize the hash-table used to store tokenizers. */
   pHash = sqlite3_malloc(sizeof(Fts3Hash));

Index: ext/fts3/fts3Int.h
==================================================================
--- ext/fts3/fts3Int.h
+++ ext/fts3/fts3Int.h
@@ -547,14 +547,17 @@
     Fts3Table *, Fts3MultiSegReader *, sqlite3_int64 *, char **, int *);
 int sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol, char **); 
 int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *);
 int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
 
+/* fts3_tokenize_vtab.c */
+int sqlite3Fts3InitTok(sqlite3*);
+
 /* fts3_unicode2.c (functions generated by parsing unicode text files) */
 #ifdef SQLITE_ENABLE_FTS4_UNICODE61
 int sqlite3FtsUnicodeFold(int, int);
 int sqlite3FtsUnicodeIsalnum(int);
 int sqlite3FtsUnicodeIsdiacritic(int);
 #endif
 
 #endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */
 #endif /* _FTSINT_H */

Index: ext/fts3/fts3_aux.c
==================================================================
--- ext/fts3/fts3_aux.c
+++ ext/fts3/fts3_aux.c
@@ -68,21 +68,30 @@
   int rc;                         /* value returned by declare_vtab() */
   Fts3auxTable *p;                /* Virtual table object to return */
 
   UNUSED_PARAMETER(pUnused);
 
-  /* The user should specify a single argument - the name of an fts3 table. */
-  if( argc!=4 ){
-    *pzErr = sqlite3_mprintf(
-        "wrong number of arguments to fts4aux constructor"
-    );
-    return SQLITE_ERROR;
-  }
+  /* The user should invoke this in one of two forms:
+  **
+  **     CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table);
+  **     CREATE VIRTUAL TABLE xxx USING fts4aux(fts4-table-db, fts4-table);
+  */
+  if( argc!=4 && argc!=5 ) goto bad_args;
 
   zDb = argv[1]; 
   nDb = (int)strlen(zDb);
-  zFts3 = argv[3];
+  if( argc==5 ){
+    if( nDb==4 && 0==sqlite3_strnicmp("temp", zDb, 4) ){
+      zDb = argv[3]; 
+      nDb = (int)strlen(zDb);
+      zFts3 = argv[4];
+    }else{
+      goto bad_args;
+    }
+  }else{
+    zFts3 = argv[3];
+  }
   nFts3 = (int)strlen(zFts3);
 
   rc = sqlite3_declare_vtab(db, FTS3_TERMS_SCHEMA);
   if( rc!=SQLITE_OK ) return rc;
 
@@ -101,10 +110,14 @@
   memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
   sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
 
   *ppVtab = (sqlite3_vtab *)p;
   return SQLITE_OK;
+
+ bad_args:
+  *pzErr = sqlite3_mprintf("invalid arguments to fts4aux constructor");
+  return SQLITE_ERROR;
 }
 
 /*
 ** This function does the work for both the xDisconnect and xDestroy methods.
 ** These tables have no persistent representation of their own, so xDisconnect

ADDED   ext/fts3/fts3_tokenize_vtab.c
Index: ext/fts3/fts3_tokenize_vtab.c
==================================================================
--- ext/fts3/fts3_tokenize_vtab.c
+++ ext/fts3/fts3_tokenize_vtab.c
@@ -0,0 +1,464 @@
+/*
+** 2013 Apr 22
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This file contains code for the "fts3tokenize" virtual table module.
+** An fts3tokenize virtual table is created as follows:
+**
+**   CREATE VIRTUAL TABLE <tbl> USING fts3tokenize(
+**       <tokenizer-name>, <arg-1>, ...
+**   );
+**
+** The table created has the following schema:
+**
+**   CREATE TABLE <tbl>(input, token, start, end, position)
+**
+** When queried, the query must include a WHERE clause of type:
+**
+**   input = <string>
+**
+** The virtual table module tokenizes this <string>, using the FTS3 
+** tokenizer specified by the arguments to the CREATE VIRTUAL TABLE 
+** statement and returns one row for each token in the result. With
+** fields set as follows:
+**
+**   input:   Always set to a copy of <string>
+**   token:   A token from the input.
+**   start:   Byte offset of the token within the input <string>.
+**   end:     Byte offset of the byte immediately following the end of the
+**            token within the input string.
+**   pos:     Token offset of token within input.
+**
+*/
+#include "fts3Int.h"
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
+
+#include <string.h>
+#include <assert.h>
+
+typedef struct Fts3tokTable Fts3tokTable;
+typedef struct Fts3tokCursor Fts3tokCursor;
+
+/*
+** Virtual table structure.
+*/
+struct Fts3tokTable {
+  sqlite3_vtab base;              /* Base class used by SQLite core */
+  const sqlite3_tokenizer_module *pMod;
+  sqlite3_tokenizer *pTok;
+};
+
+/*
+** Virtual table cursor structure.
+*/
+struct Fts3tokCursor {
+  sqlite3_vtab_cursor base;       /* Base class used by SQLite core */
+  char *zInput;                   /* Input string */
+  sqlite3_tokenizer_cursor *pCsr; /* Cursor to iterate through zInput */
+  int iRowid;                     /* Current 'rowid' value */
+  const char *zToken;             /* Current 'token' value */
+  int nToken;                     /* Size of zToken in bytes */
+  int iStart;                     /* Current 'start' value */
+  int iEnd;                       /* Current 'end' value */
+  int iPos;                       /* Current 'pos' value */
+};
+
+/*
+** Query FTS for the tokenizer implementation named zName.
+*/
+static int fts3tokQueryTokenizer(
+  sqlite3 *db,
+  const char *zName,
+  const sqlite3_tokenizer_module **pp
+){
+  int rc;
+  sqlite3_stmt *pStmt;
+  const char *zSql = "SELECT fts3_tokenizer(?)";
+
+  *pp = 0;
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    return rc;
+  }
+
+  sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
+  if( SQLITE_ROW==sqlite3_step(pStmt) ){
+    if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
+      memcpy((void*)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
+    }
+  }
+
+  return sqlite3_finalize(pStmt);
+}
+
+/*
+** The second argument, argv[], is an array of pointers to nul-terminated
+** strings. This function makes a copy of the array and strings into a 
+** single block of memory. It then dequotes any of the strings that appear
+** to be quoted.
+**
+** If successful, output parameter *pazDequote is set to point at the
+** array of dequoted strings and SQLITE_OK is returned. The caller is
+** responsible for eventually calling sqlite3_free() to free the array
+** in this case. Or, if an error occurs, an SQLite error code is returned.
+** The final value of *pazDequote is undefined in this case.
+*/
+static int fts3tokDequoteArray(
+  int argc,                       /* Number of elements in argv[] */
+  const char * const *argv,       /* Input array */
+  char ***pazDequote              /* Output array */
+){
+  int rc = SQLITE_OK;             /* Return code */
+  if( argc==0 ){
+    *pazDequote = 0;
+  }else{
+    int i;
+    int nByte = 0;
+    char **azDequote;
+
+    for(i=0; i<argc; i++){
+      nByte += (int)(strlen(argv[i]) + 1);
+    }
+
+    *pazDequote = azDequote = sqlite3_malloc(sizeof(char *)*argc + nByte);
+    if( azDequote==0 ){
+      rc = SQLITE_NOMEM;
+    }else{
+      char *pSpace = (char *)&azDequote[argc];
+      for(i=0; i<argc; i++){
+        int n = (int)strlen(argv[i]);
+        azDequote[i] = pSpace;
+        memcpy(pSpace, argv[i], n+1);
+        sqlite3Fts3Dequote(pSpace);
+        pSpace += (n+1);
+      }
+    }
+  }
+
+  return rc;
+}
+
+/*
+** Schema of the tokenizer table.
+*/
+#define FTS3_TOK_SCHEMA "CREATE TABLE x(input, token, start, end, position)"
+
+/*
+** This function does all the work for both the xConnect and xCreate methods.
+** These tables have no persistent representation of their own, so xConnect
+** and xCreate are identical operations.
+**
+**   argv[0]: module name
+**   argv[1]: database name 
+**   argv[2]: table name
+**   argv[3]: first argument (tokenizer name)
+*/
+static int fts3tokConnectMethod(
+  sqlite3 *db,                    /* Database connection */
+  void *pUnused,                  /* Unused */
+  int argc,                       /* Number of elements in argv array */
+  const char * const *argv,       /* xCreate/xConnect argument array */
+  sqlite3_vtab **ppVtab,          /* OUT: New sqlite3_vtab object */
+  char **pzErr                    /* OUT: sqlite3_malloc'd error message */
+){
+  Fts3tokTable *pTab;
+  const sqlite3_tokenizer_module *pMod = 0;
+  sqlite3_tokenizer *pTok = 0;
+  int rc;
+  char **azDequote = 0;
+  int nDequote;
+  UNUSED_PARAMETER(pUnused);
+
+  rc = sqlite3_declare_vtab(db, FTS3_TOK_SCHEMA);
+  if( rc!=SQLITE_OK ) return rc;
+
+  nDequote = argc-3;
+  rc = fts3tokDequoteArray(nDequote, &argv[3], &azDequote);
+
+  if( rc==SQLITE_OK ){
+    const char *zModule;
+    if( nDequote<1 ){
+      zModule = "simple";
+    }else{
+      zModule = azDequote[0];
+    }
+    rc = fts3tokQueryTokenizer(db, zModule, &pMod);
+  }
+
+  if( rc!=SQLITE_OK ){
+    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
+  }else if( pMod==0 ){
+    rc = SQLITE_ERROR;
+  }else{
+    const char * const *azArg = (const char * const *)&azDequote[1];
+    rc = pMod->xCreate((nDequote>1 ? nDequote-1 : 0), azArg, &pTok);
+  }
+
+  if( rc==SQLITE_OK ){
+    pTab = (Fts3tokTable *)sqlite3_malloc(sizeof(Fts3tokTable));
+    if( pTab==0 ){
+      rc = SQLITE_NOMEM;
+    }
+  }
+
+  if( rc==SQLITE_OK ){
+    memset(pTab, 0, sizeof(Fts3tokTable));
+    pTab->pMod = pMod;
+    pTab->pTok = pTok;
+    *ppVtab = &pTab->base;
+  }else{
+    if( pTok ){
+      pMod->xDestroy(pTok);
+    }
+  }
+
+  sqlite3_free(azDequote);
+  return rc;
+}
+
+/*
+** This function does the work for both the xDisconnect and xDestroy methods.
+** These tables have no persistent representation of their own, so xDisconnect
+** and xDestroy are identical operations.
+*/
+static int fts3tokDisconnectMethod(sqlite3_vtab *pVtab){
+  Fts3tokTable *pTab = (Fts3tokTable *)pVtab;
+
+  pTab->pMod->xDestroy(pTab->pTok);
+  sqlite3_free(pTab);
+  return SQLITE_OK;
+}
+
+/*
+** xBestIndex - Analyze a WHERE and ORDER BY clause.
+*/
+static int fts3tokBestIndexMethod(
+  sqlite3_vtab *pVTab, 
+  sqlite3_index_info *pInfo
+){
+  int i;
+  UNUSED_PARAMETER(pVTab);
+
+  for(i=0; i<pInfo->nConstraint; i++){
+    if( pInfo->aConstraint[i].usable 
+     && pInfo->aConstraint[i].iColumn==0 
+     && pInfo->aConstraint[i].op==SQLITE_INDEX_CONSTRAINT_EQ 
+    ){
+      pInfo->idxNum = 1;
+      pInfo->aConstraintUsage[i].argvIndex = 1;
+      pInfo->aConstraintUsage[i].omit = 1;
+      pInfo->estimatedCost = 1;
+      return SQLITE_OK;
+    }
+  }
+
+  pInfo->idxNum = 0;
+  assert( pInfo->estimatedCost>1000000.0 );
+
+  return SQLITE_OK;
+}
+
+/*
+** xOpen - Open a cursor.
+*/
+static int fts3tokOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
+  Fts3tokCursor *pCsr;
+  UNUSED_PARAMETER(pVTab);
+
+  pCsr = (Fts3tokCursor *)sqlite3_malloc(sizeof(Fts3tokCursor));
+  if( pCsr==0 ){
+    return SQLITE_NOMEM;
+  }
+  memset(pCsr, 0, sizeof(Fts3tokCursor));
+
+  *ppCsr = (sqlite3_vtab_cursor *)pCsr;
+  return SQLITE_OK;
+}
+
+/*
+** Reset the tokenizer cursor passed as the only argument. As if it had
+** just been returned by fts3tokOpenMethod().
+*/
+static void fts3tokResetCursor(Fts3tokCursor *pCsr){
+  if( pCsr->pCsr ){
+    Fts3tokTable *pTab = (Fts3tokTable *)(pCsr->base.pVtab);
+    pTab->pMod->xClose(pCsr->pCsr);
+    pCsr->pCsr = 0;
+  }
+  sqlite3_free(pCsr->zInput);
+  pCsr->zInput = 0;
+  pCsr->zToken = 0;
+  pCsr->nToken = 0;
+  pCsr->iStart = 0;
+  pCsr->iEnd = 0;
+  pCsr->iPos = 0;
+  pCsr->iRowid = 0;
+}
+
+/*
+** xClose - Close a cursor.
+*/
+static int fts3tokCloseMethod(sqlite3_vtab_cursor *pCursor){
+  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
+
+  fts3tokResetCursor(pCsr);
+  sqlite3_free(pCsr);
+  return SQLITE_OK;
+}
+
+/*
+** xNext - Advance the cursor to the next row, if any.
+*/
+static int fts3tokNextMethod(sqlite3_vtab_cursor *pCursor){
+  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
+  Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
+  int rc;                         /* Return code */
+
+  pCsr->iRowid++;
+  rc = pTab->pMod->xNext(pCsr->pCsr,
+      &pCsr->zToken, &pCsr->nToken,
+      &pCsr->iStart, &pCsr->iEnd, &pCsr->iPos
+  );
+
+  if( rc!=SQLITE_OK ){
+    fts3tokResetCursor(pCsr);
+    if( rc==SQLITE_DONE ) rc = SQLITE_OK;
+  }
+
+  return rc;
+}
+
+/*
+** xFilter - Initialize a cursor to point at the start of its data.
+*/
+static int fts3tokFilterMethod(
+  sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
+  int idxNum,                     /* Strategy index */
+  const char *idxStr,             /* Unused */
+  int nVal,                       /* Number of elements in apVal */
+  sqlite3_value **apVal           /* Arguments for the indexing scheme */
+){
+  int rc = SQLITE_ERROR;
+  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
+  Fts3tokTable *pTab = (Fts3tokTable *)(pCursor->pVtab);
+  UNUSED_PARAMETER(idxStr);
+  UNUSED_PARAMETER(nVal);
+
+  fts3tokResetCursor(pCsr);
+  if( idxNum==1 ){
+    const char *zByte = (const char *)sqlite3_value_text(apVal[0]);
+    int nByte = sqlite3_value_bytes(apVal[0]);
+    pCsr->zInput = sqlite3_malloc(nByte+1);
+    if( pCsr->zInput==0 ){
+      rc = SQLITE_NOMEM;
+    }else{
+      memcpy(pCsr->zInput, zByte, nByte);
+      pCsr->zInput[nByte] = 0;
+      rc = pTab->pMod->xOpen(pTab->pTok, pCsr->zInput, nByte, &pCsr->pCsr);
+      if( rc==SQLITE_OK ){
+        pCsr->pCsr->pTokenizer = pTab->pTok;
+      }
+    }
+  }
+
+  if( rc!=SQLITE_OK ) return rc;
+  return fts3tokNextMethod(pCursor);
+}
+
+/*
+** xEof - Return true if the cursor is at EOF, or false otherwise.
+*/
+static int fts3tokEofMethod(sqlite3_vtab_cursor *pCursor){
+  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
+  return (pCsr->zToken==0);
+}
+
+/*
+** xColumn - Return a column value.
+*/
+static int fts3tokColumnMethod(
+  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
+  sqlite3_context *pCtx,          /* Context for sqlite3_result_xxx() calls */
+  int iCol                        /* Index of column to read value from */
+){
+  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
+
+  /* CREATE TABLE x(input, token, start, end, position) */
+  switch( iCol ){
+    case 0:
+      sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
+      break;
+    case 1:
+      sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
+      break;
+    case 2:
+      sqlite3_result_int(pCtx, pCsr->iStart);
+      break;
+    case 3:
+      sqlite3_result_int(pCtx, pCsr->iEnd);
+      break;
+    default:
+      assert( iCol==4 );
+      sqlite3_result_int(pCtx, pCsr->iPos);
+      break;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** xRowid - Return the current rowid for the cursor.
+*/
+static int fts3tokRowidMethod(
+  sqlite3_vtab_cursor *pCursor,   /* Cursor to retrieve value from */
+  sqlite_int64 *pRowid            /* OUT: Rowid value */
+){
+  Fts3tokCursor *pCsr = (Fts3tokCursor *)pCursor;
+  *pRowid = (sqlite3_int64)pCsr->iRowid;
+  return SQLITE_OK;
+}
+
+/*
+** Register the fts3tok module with database connection db. Return SQLITE_OK
+** if successful or an error code if sqlite3_create_module() fails.
+*/
+int sqlite3Fts3InitTok(sqlite3 *db){
+  static const sqlite3_module fts3tok_module = {
+     0,                           /* iVersion      */
+     fts3tokConnectMethod,        /* xCreate       */
+     fts3tokConnectMethod,        /* xConnect      */
+     fts3tokBestIndexMethod,      /* xBestIndex    */
+     fts3tokDisconnectMethod,     /* xDisconnect   */
+     fts3tokDisconnectMethod,     /* xDestroy      */
+     fts3tokOpenMethod,           /* xOpen         */
+     fts3tokCloseMethod,          /* xClose        */
+     fts3tokFilterMethod,         /* xFilter       */
+     fts3tokNextMethod,           /* xNext         */
+     fts3tokEofMethod,            /* xEof          */
+     fts3tokColumnMethod,         /* xColumn       */
+     fts3tokRowidMethod,          /* xRowid        */
+     0,                           /* xUpdate       */
+     0,                           /* xBegin        */
+     0,                           /* xSync         */
+     0,                           /* xCommit       */
+     0,                           /* xRollback     */
+     0,                           /* xFindFunction */
+     0,                           /* xRename       */
+     0,                           /* xSavepoint    */
+     0,                           /* xRelease      */
+     0                            /* xRollbackTo   */
+  };
+  int rc;                         /* Return code */
+
+  rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, 0);
+  return rc;
+}
+
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */

Index: ext/rtree/rtree1.test
==================================================================
--- ext/rtree/rtree1.test
+++ ext/rtree/rtree1.test
@@ -15,10 +15,11 @@
 if {![info exists testdir]} {
   set testdir [file join [file dirname [info script]] .. .. test]
 }
 source [file join [file dirname [info script]] rtree_util.tcl]
 source $testdir/tester.tcl
+set testprefix rtree1
 
 # Test plan:
 #
 #   rtree-1.*: Creating/destroying r-tree tables.
 #   rtree-2.*: Test the implicit constraints - unique rowid and

Index: ext/rtree/rtree5.test
==================================================================
--- ext/rtree/rtree5.test
+++ ext/rtree/rtree5.test
@@ -59,11 +59,11 @@
 } {1}
 
 do_test rtree5-1.10 { 
   execsql { SELECT (1<<31)-5, (1<<31)-1, -1*(1<<31), -1*(1<<31)+5 }
 } {2147483643 2147483647 -2147483648 -2147483643}
-do_test rtree5-1.10 { 
+do_test rtree5-1.11 { 
   execsql { 
     INSERT INTO t1 VALUES(2, (1<<31)-5, (1<<31)-1, -1*(1<<31), -1*(1<<31)+5) 
   }
 } {}
 do_test rtree5-1.12 { 

Index: main.mk
==================================================================
--- main.mk
+++ main.mk
@@ -54,10 +54,11 @@
 LIBOBJ+= alter.o analyze.o attach.o auth.o \
          backup.o bitvec.o btmutex.o btree.o build.o \
          callback.o complete.o ctime.o date.o delete.o expr.o fault.o fkey.o \
          fts3.o fts3_aux.o fts3_expr.o fts3_hash.o fts3_icu.o fts3_porter.o \
          fts3_snippet.o fts3_tokenizer.o fts3_tokenizer1.o \
+         fts3_tokenize_vtab.o \
 	 fts3_unicode.o fts3_unicode2.o \
          fts3_write.o func.o global.o hash.o \
          icu.o insert.o journal.o legacy.o loadext.o \
          main.o malloc.o mem0.o mem1.o mem2.o mem3.o mem5.o \
          memjournal.o \
@@ -196,10 +197,11 @@
   $(TOP)/ext/fts3/fts3_porter.c \
   $(TOP)/ext/fts3/fts3_snippet.c \
   $(TOP)/ext/fts3/fts3_tokenizer.h \
   $(TOP)/ext/fts3/fts3_tokenizer.c \
   $(TOP)/ext/fts3/fts3_tokenizer1.c \
+  $(TOP)/ext/fts3/fts3_tokenize_vtab.c \
   $(TOP)/ext/fts3/fts3_unicode.c \
   $(TOP)/ext/fts3/fts3_unicode2.c \
   $(TOP)/ext/fts3/fts3_write.c
 SRC += \
   $(TOP)/ext/icu/sqliteicu.h \
@@ -369,10 +371,14 @@
 sqlite3$(EXE):	$(TOP)/src/shell.c libsqlite3.a sqlite3.h
 	$(TCCX) $(READLINE_FLAGS) -o sqlite3$(EXE)                  \
 		$(TOP)/src/shell.c                                  \
 		libsqlite3.a $(LIBREADLINE) $(TLIBS) $(THREADLIB)
 
+mptester$(EXE):	sqlite3.c $(TOP)/mptest/mptest.c
+	$(TCCX) -o $@ -I. $(TOP)/mptest/mptest.c sqlite3.c \
+		$(TLIBS) $(THREADLIB)
+
 sqlite3.o:	sqlite3.c
 	$(TCCX) -c sqlite3.c
 
 # This target creates a directory named "tsrc" and fills it with
 # copies of all of the C source code and header files needed to
@@ -516,10 +522,13 @@
 fts3_tokenizer.o:	$(TOP)/ext/fts3/fts3_tokenizer.c $(HDR) $(EXTHDR)
 	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer.c
 
 fts3_tokenizer1.o:	$(TOP)/ext/fts3/fts3_tokenizer1.c $(HDR) $(EXTHDR)
 	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenizer1.c
+
+fts3_tokenize_vtab.o:	$(TOP)/ext/fts3/fts3_tokenize_vtab.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_tokenize_vtab.c
 
 fts3_unicode.o:	$(TOP)/ext/fts3/fts3_unicode.c $(HDR) $(EXTHDR)
 	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_unicode.c
 
 fts3_unicode2.o:	$(TOP)/ext/fts3/fts3_unicode2.c $(HDR) $(EXTHDR)
@@ -631,7 +640,10 @@
 	rm -f amalgamation-testfixture amalgamation-testfixture.exe
 	rm -f fts3-testfixture fts3-testfixture.exe
 	rm -f testfixture testfixture.exe
 	rm -f threadtest3 threadtest3.exe
 	rm -f sqlite3.c fts?amal.c tclsqlite3.c
+	rm -f sqlite3rc.h
+	rm -f shell.c sqlite3ext.h
 	rm -f sqlite3_analyzer sqlite3_analyzer.exe sqlite3_analyzer.c
 	rm -f sqlite-*-output.vsix
+	rm -f mptester mptester.exe

ADDED   mptest/config01.test
Index: mptest/config01.test
==================================================================
--- mptest/config01.test
+++ mptest/config01.test
@@ -0,0 +1,46 @@
+/*
+** Configure five tasks in different ways, then run tests.
+*/
+--if vfsname() GLOB 'unix'
+PRAGMA page_size=8192;
+--task 1
+  PRAGMA journal_mode=PERSIST;
+  PRAGMA mmap_size=0;
+--end
+--task 2
+  PRAGMA journal_mode=TRUNCATE;
+  PRAGMA mmap_size=28672;
+--end
+--task 3
+  PRAGMA journal_mode=MEMORY;
+--end
+--task 4
+  PRAGMA journal_mode=OFF;
+--end
+--task 4
+  PRAGMA mmap_size(268435456);
+--end
+--source multiwrite01.test
+--wait all
+PRAGMA page_size=16384;
+VACUUM;
+CREATE TABLE pgsz(taskid, sz INTEGER);
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--wait all
+SELECT sz FROM pgsz;
+--match 16384 16384 16384 16384 16384

ADDED   mptest/config02.test
Index: mptest/config02.test
==================================================================
--- mptest/config02.test
+++ mptest/config02.test
@@ -0,0 +1,123 @@
+/*
+** Configure five tasks in different ways, then run tests.
+*/
+PRAGMA page_size=512;
+--task 1
+  PRAGMA mmap_size=0;
+--end
+--task 2
+  PRAGMA mmap_size=28672;
+--end
+--task 3
+  PRAGMA mmap_size=8192;
+--end
+--task 4
+  PRAGMA mmap_size=65536;
+--end
+--task 5
+  PRAGMA mmap_size=268435456;
+--end
+--source multiwrite01.test
+--source crash02.subtest
+PRAGMA page_size=1024;
+VACUUM;
+CREATE TABLE pgsz(taskid, sz INTEGER);
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 1024 1024 1024 1024 1024
+PRAGMA page_size=2048;
+VACUUM;
+DELETE FROM pgsz;
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 2048 2048 2048 2048 2048
+PRAGMA page_size=8192;
+VACUUM;
+DELETE FROM pgsz;
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 8192 8192 8192 8192 8192
+PRAGMA page_size=16384;
+VACUUM;
+DELETE FROM pgsz;
+--task 1
+  INSERT INTO pgsz VALUES(1, eval('PRAGMA page_size'));
+--end
+--task 2
+  INSERT INTO pgsz VALUES(2, eval('PRAGMA page_size'));
+--end
+--task 3
+  INSERT INTO pgsz VALUES(3, eval('PRAGMA page_size'));
+--end
+--task 4
+  INSERT INTO pgsz VALUES(4, eval('PRAGMA page_size'));
+--end
+--task 5
+  INSERT INTO pgsz VALUES(5, eval('PRAGMA page_size'));
+--end
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+SELECT sz FROM pgsz;
+--match 16384 16384 16384 16384 16384
+PRAGMA auto_vacuum=FULL;
+VACUUM;
+--source multiwrite01.test
+--source crash02.subtest
+--wait all
+PRAGMA auto_vacuum=FULL;
+PRAGMA page_size=512;
+VACUUM;
+--source multiwrite01.test
+--source crash02.subtest

ADDED   mptest/crash01.test
Index: mptest/crash01.test
==================================================================
--- mptest/crash01.test
+++ mptest/crash01.test
@@ -0,0 +1,102 @@
+/* Test cases involving incomplete transactions that must be rolled back.
+*/
+--task 1
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t1 VALUES(1, randomblob(2000));
+  INSERT INTO t1 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t1 SELECT a+2, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+4, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+8, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+16, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+32, randomblob(1500) FROM t1;
+  SELECT count(*) FROM t1;
+  --match 64
+  SELECT avg(length(b)) FROM t1;
+  --match 1500.0
+  --sleep 2
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t1;
+  --match 247
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t1b ON t1(b);
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t1 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--wait 1
+--task 2
+  CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t2 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t2;
+  --match 247
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t2b ON t2(b);
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t2 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--task 3
+  CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t3 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t3;
+  --match 247
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t3b ON t3(b);
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t3 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--task 4
+  CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t4 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t4;
+  --match 247
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t4b ON t4(b);
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t4 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+--task 5
+  CREATE TABLE t5(a INTEGER PRIMARY KEY, b);
+  INSERT INTO t5 SELECT a, b FROM t1;
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t5;
+  --match 247
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t5b ON t5(b);
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t5 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--wait all
+/* After the database file has been set up, run the crash2 subscript
+** multiple times. */
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest
+--source crash02.subtest

ADDED   mptest/crash02.subtest
Index: mptest/crash02.subtest
==================================================================
--- mptest/crash02.subtest
+++ mptest/crash02.subtest
@@ -0,0 +1,53 @@
+/*
+** This script is called from crash01.test and config02.test and perhaps other
+** script.  After the database file has been set up, make a big rollback 
+** journal in client 1, then crash client 1.
+** Then in the other clients, do an integrity check.
+*/
+--task 1 leave-hot-journal
+  --sleep 5
+  --finish
+  PRAGMA cache_size=10;
+  BEGIN;
+  UPDATE t1 SET b=randomblob(20000);
+  UPDATE t2 SET b=randomblob(20000);
+  UPDATE t3 SET b=randomblob(20000);
+  UPDATE t4 SET b=randomblob(20000);
+  UPDATE t5 SET b=randomblob(20000);
+  UPDATE t1 SET b=NULL;
+  UPDATE t2 SET b=NULL;
+  UPDATE t3 SET b=NULL;
+  UPDATE t4 SET b=NULL;
+  UPDATE t5 SET b=NULL;
+  --print Task one crashing an incomplete transaction
+  --exit 1
+--end
+--task 2 integrity_check-2
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--task 3 integrity_check-3
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--task 4 integrity_check-4
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--task 5 integrity_check-5
+  SELECT count(*) FROM t1;
+  --match 64
+  --sleep 100
+  PRAGMA integrity_check(10);
+  --match ok
+--end
+--wait all

ADDED   mptest/mptest.c
Index: mptest/mptest.c
==================================================================
--- mptest/mptest.c
+++ mptest/mptest.c
@@ -0,0 +1,1401 @@
+/*
+** 2013-04-05
+**
+** 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 is a program used for testing SQLite, and specifically for testing
+** the ability of independent processes to access the same SQLite database
+** concurrently.
+**
+** Compile this program as follows:
+**
+**    gcc -g -c -Wall sqlite3.c $(OPTS)
+**    gcc -g -o mptest mptest.c sqlite3.o $(LIBS)
+**
+** Recommended options:
+**
+**    -DHAVE_USLEEP
+**    -DSQLITE_NO_SYNC
+**    -DSQLITE_THREADSAFE=0
+**    -DSQLITE_OMIT_LOAD_EXTENSION
+**
+** Run like this:
+**
+**     ./mptest $database $script
+**
+** where $database is the database to use for testing and $script is a
+** test script.
+*/
+#include "sqlite3.h"
+#include <stdio.h>
+#if defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#else
+# include <unistd.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+
+/* The suffix to append to the child command lines, if any */
+#if defined(_WIN32)
+# define GETPID (int)GetCurrentProcessId
+#else
+# define GETPID getpid
+#endif
+
+/* Mark a parameter as unused to suppress compiler warnings */
+#define UNUSED_PARAMETER(x)  (void)x
+
+/* Global data
+*/
+static struct Global {
+  char *argv0;           /* Name of the executable */
+  const char *zVfs;      /* Name of VFS to use. Often NULL meaning "default" */
+  char *zDbFile;         /* Name of the database */
+  sqlite3 *db;           /* Open connection to database */
+  char *zErrLog;         /* Filename for error log */
+  FILE *pErrLog;         /* Where to write errors */
+  char *zLog;            /* Name of output log file */
+  FILE *pLog;            /* Where to write log messages */
+  char zName[32];        /* Symbolic name of this process */
+  int taskId;            /* Task ID.  0 means supervisor. */
+  int iTrace;            /* Tracing level */
+  int bSqlTrace;         /* True to trace SQL commands */
+  int bIgnoreSqlErrors;  /* Ignore errors in SQL statements */
+  int nError;            /* Number of errors */
+  int nTest;             /* Number of --match operators */
+  int iTimeout;          /* Milliseconds until a busy timeout */
+  int bSync;             /* Call fsync() */
+} g;
+
+/* Default timeout */
+#define DEFAULT_TIMEOUT 10000
+
+/*
+** Print a message adding zPrefix[] to the beginning of every line.
+*/
+static void printWithPrefix(FILE *pOut, const char *zPrefix, const char *zMsg){
+  while( zMsg && zMsg[0] ){
+    int i;
+    for(i=0; zMsg[i] && zMsg[i]!='\n' && zMsg[i]!='\r'; i++){}
+    fprintf(pOut, "%s%.*s\n", zPrefix, i, zMsg);
+    zMsg += i;
+    while( zMsg[0]=='\n' || zMsg[0]=='\r' ) zMsg++;
+  }
+}
+
+/*
+** Compare two pointers to strings, where the pointers might be NULL.
+*/
+static int safe_strcmp(const char *a, const char *b){
+  if( a==b ) return 0;
+  if( a==0 ) return -1;
+  if( b==0 ) return 1;
+  return strcmp(a,b);
+}
+
+/*
+** Return TRUE if string z[] matches glob pattern zGlob[].
+** Return FALSE if the pattern does not match.
+**
+** Globbing rules:
+**
+**      '*'       Matches any sequence of zero or more characters.
+**
+**      '?'       Matches exactly one character.
+**
+**     [...]      Matches one character from the enclosed list of
+**                characters.
+**
+**     [^...]     Matches one character not in the enclosed list.
+**
+**      '#'       Matches any sequence of one or more digits with an
+**                optional + or - sign in front
+*/
+int strglob(const char *zGlob, const char *z){
+  int c, c2;
+  int invert;
+  int seen;
+
+  while( (c = (*(zGlob++)))!=0 ){
+    if( c=='*' ){
+      while( (c=(*(zGlob++))) == '*' || c=='?' ){
+        if( c=='?' && (*(z++))==0 ) return 0;
+      }
+      if( c==0 ){
+        return 1;
+      }else if( c=='[' ){
+        while( *z && strglob(zGlob-1,z) ){
+          z++;
+        }
+        return (*z)!=0;
+      }
+      while( (c2 = (*(z++)))!=0 ){
+        while( c2!=c ){
+          c2 = *(z++);
+          if( c2==0 ) return 0;
+        }
+        if( strglob(zGlob,z) ) return 1;
+      }
+      return 0;
+    }else if( c=='?' ){
+      if( (*(z++))==0 ) return 0;
+    }else if( c=='[' ){
+      int prior_c = 0;
+      seen = 0;
+      invert = 0;
+      c = *(z++);
+      if( c==0 ) return 0;
+      c2 = *(zGlob++);
+      if( c2=='^' ){
+        invert = 1;
+        c2 = *(zGlob++);
+      }
+      if( c2==']' ){
+        if( c==']' ) seen = 1;
+        c2 = *(zGlob++);
+      }
+      while( c2 && c2!=']' ){
+        if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
+          c2 = *(zGlob++);
+          if( c>=prior_c && c<=c2 ) seen = 1;
+          prior_c = 0;
+        }else{
+          if( c==c2 ){
+            seen = 1;
+          }
+          prior_c = c2;
+        }
+        c2 = *(zGlob++);
+      }
+      if( c2==0 || (seen ^ invert)==0 ) return 0;
+    }else if( c=='#' ){
+      if( (z[0]=='-' || z[0]=='+') && isdigit(z[1]) ) z++;
+      if( !isdigit(z[0]) ) return 0;
+      z++;
+      while( isdigit(z[0]) ){ z++; }
+    }else{
+      if( c!=(*(z++)) ) return 0;
+    }
+  }
+  return *z==0;
+}
+
+/*
+** Close output stream pOut if it is not stdout or stderr
+*/
+static void maybeClose(FILE *pOut){
+  if( pOut!=stdout && pOut!=stderr ) fclose(pOut);
+}
+
+/*
+** Print an error message
+*/
+static void errorMessage(const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  char zPrefix[30];
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:ERROR: ", g.zName);
+  if( g.pLog ){
+    printWithPrefix(g.pLog, zPrefix, zMsg);
+    fflush(g.pLog);
+  }
+  if( g.pErrLog && safe_strcmp(g.zErrLog,g.zLog) ){
+    printWithPrefix(g.pErrLog, zPrefix, zMsg);
+    fflush(g.pErrLog);
+  }
+  sqlite3_free(zMsg);
+  g.nError++;
+}
+
+/* Forward declaration */
+static int trySql(const char*, ...);
+
+/*
+** Print an error message and then quit.
+*/
+static void fatalError(const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  char zPrefix[30];
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:FATAL: ", g.zName);
+  if( g.pLog ){
+    printWithPrefix(g.pLog, zPrefix, zMsg);
+    fflush(g.pLog);
+    maybeClose(g.pLog);
+  }
+  if( g.pErrLog && safe_strcmp(g.zErrLog,g.zLog) ){
+    printWithPrefix(g.pErrLog, zPrefix, zMsg);
+    fflush(g.pErrLog);
+    maybeClose(g.pErrLog);
+  }
+  sqlite3_free(zMsg);
+  if( g.db ){
+    int nTry = 0;
+    g.iTimeout = 0;
+    while( trySql("UPDATE client SET wantHalt=1;")==SQLITE_BUSY
+           && (nTry++)<100 ){
+      sqlite3_sleep(10);
+    }
+  }
+  sqlite3_close(g.db);
+  exit(1);  
+}
+
+
+/*
+** Print a log message
+*/
+static void logMessage(const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  char zPrefix[30];
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s: ", g.zName);
+  if( g.pLog ){
+    printWithPrefix(g.pLog, zPrefix, zMsg);
+    fflush(g.pLog);
+  }
+  sqlite3_free(zMsg);
+}
+
+/*
+** Return the length of a string omitting trailing whitespace
+*/
+static int clipLength(const char *z){
+  int n = (int)strlen(z);
+  while( n>0 && isspace(z[n-1]) ){ n--; }
+  return n;
+}
+
+/*
+** Auxiliary SQL function to return the name of the VFS
+*/
+static void vfsNameFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_context_db_handle(context);
+  char *zVfs = 0;
+  UNUSED_PARAMETER(argc);
+  UNUSED_PARAMETER(argv);
+  sqlite3_file_control(db, "main", SQLITE_FCNTL_VFSNAME, &zVfs);
+  if( zVfs ){
+    sqlite3_result_text(context, zVfs, -1, sqlite3_free);
+  }
+}
+
+/*
+** Busy handler with a g.iTimeout-millisecond timeout
+*/
+static int busyHandler(void *pCD, int count){
+  UNUSED_PARAMETER(pCD);
+  if( count*10>g.iTimeout ){
+    if( g.iTimeout>0 ) errorMessage("timeout after %dms", g.iTimeout);
+    return 0;
+  }
+  sqlite3_sleep(10);
+  return 1;
+}
+
+/*
+** SQL Trace callback
+*/
+static void sqlTraceCallback(void *NotUsed1, const char *zSql){
+  UNUSED_PARAMETER(NotUsed1);
+  logMessage("[%.*s]", clipLength(zSql), zSql);
+}
+
+/*
+** SQL error log callback
+*/
+static void sqlErrorCallback(void *pArg, int iErrCode, const char *zMsg){
+  UNUSED_PARAMETER(pArg);
+  if( iErrCode==SQLITE_ERROR && g.bIgnoreSqlErrors ) return;
+  if( (iErrCode&0xff)==SQLITE_SCHEMA && g.iTrace<3 ) return;
+  if( g.iTimeout==0 && (iErrCode&0xff)==SQLITE_BUSY && g.iTrace<3 ) return;
+  if( (iErrCode&0xff)==SQLITE_NOTICE ){
+    logMessage("(info) %s", zMsg);
+  }else{
+    errorMessage("(errcode=%d) %s", iErrCode, zMsg);
+  }
+}
+
+/*
+** Prepare an SQL statement.  Issue a fatal error if unable.
+*/
+static sqlite3_stmt *prepareSql(const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  sqlite3_stmt *pStmt = 0;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  rc = sqlite3_prepare_v2(g.db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    sqlite3_finalize(pStmt);
+    fatalError("%s\n%s\n", sqlite3_errmsg(g.db), zSql);
+  }
+  sqlite3_free(zSql);
+  return pStmt;
+}
+
+/*
+** Run arbitrary SQL.  Issue a fatal error on failure.
+*/
+static void runSql(const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  rc = sqlite3_exec(g.db, zSql, 0, 0, 0);
+  if( rc!=SQLITE_OK ){
+    fatalError("%s\n%s\n", sqlite3_errmsg(g.db), zSql);
+  }
+  sqlite3_free(zSql);
+}
+
+/*
+** Try to run arbitrary SQL.  Return success code.
+*/
+static int trySql(const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  rc = sqlite3_exec(g.db, zSql, 0, 0, 0);
+  sqlite3_free(zSql);
+  return rc;
+}
+
+/* Structure for holding an arbitrary length string
+*/
+typedef struct String String;
+struct String {
+  char *z;         /* the string */
+  int n;           /* Slots of z[] used */
+  int nAlloc;      /* Slots of z[] allocated */
+};
+
+/* Free a string */
+static void stringFree(String *p){
+  if( p->z ) sqlite3_free(p->z);
+  memset(p, 0, sizeof(*p));
+}
+
+/* Append n bytes of text to a string.  If n<0 append the entire string. */
+static void stringAppend(String *p, const char *z, int n){
+  if( n<0 ) n = (int)strlen(z);
+  if( p->n+n>=p->nAlloc ){
+    int nAlloc = p->nAlloc*2 + n + 100;
+    char *z = sqlite3_realloc(p->z, nAlloc);
+    if( z==0 ) fatalError("out of memory");
+    p->z = z;
+    p->nAlloc = nAlloc;
+  }
+  memcpy(p->z+p->n, z, n);
+  p->n += n;
+  p->z[p->n] = 0;
+}
+
+/* Reset a string to an empty string */
+static void stringReset(String *p){
+  if( p->z==0 ) stringAppend(p, " ", 1);
+  p->n = 0;
+  p->z[0] = 0;
+}
+
+/* Append a new token onto the end of the string */
+static void stringAppendTerm(String *p, const char *z){
+  int i;
+  if( p->n ) stringAppend(p, " ", 1);
+  if( z==0 ){
+    stringAppend(p, "nil", 3);
+    return;
+  }
+  for(i=0; z[i] && !isspace(z[i]); i++){}
+  if( i>0 && z[i]==0 ){
+    stringAppend(p, z, i);
+    return;
+  }
+  stringAppend(p, "'", 1);
+  while( z[0] ){
+    for(i=0; z[i] && z[i]!='\''; i++){}
+    if( z[i] ){
+      stringAppend(p, z, i+1);
+      stringAppend(p, "'", 1);
+      z += i+1;
+    }else{
+      stringAppend(p, z, i);
+      break;
+    }
+  }
+  stringAppend(p, "'", 1);
+}
+
+/*
+** Callback function for evalSql()
+*/
+static int evalCallback(void *pCData, int argc, char **argv, char **azCol){
+  String *p = (String*)pCData;
+  int i;
+  UNUSED_PARAMETER(azCol);
+  for(i=0; i<argc; i++) stringAppendTerm(p, argv[i]);
+  return 0;
+}
+
+/*
+** Run arbitrary SQL and record the results in an output string
+** given by the first parameter.
+*/
+static int evalSql(String *p, const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  char *zErrMsg = 0;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  assert( g.iTimeout>0 );
+  rc = sqlite3_exec(g.db, zSql, evalCallback, p, &zErrMsg);
+  sqlite3_free(zSql);
+  if( rc ){
+    char zErr[30];
+    sqlite3_snprintf(sizeof(zErr), zErr, "error(%d)", rc);
+    stringAppendTerm(p, zErr);
+    if( zErrMsg ){
+      stringAppendTerm(p, zErrMsg);
+      sqlite3_free(zErrMsg);
+    }
+  }
+  return rc;
+}
+
+/*
+** Auxiliary SQL function to recursively evaluate SQL.
+*/
+static void evalFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_context_db_handle(context);
+  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
+  String res;
+  char *zErrMsg = 0;
+  int rc;
+  UNUSED_PARAMETER(argc);
+  memset(&res, 0, sizeof(res));
+  rc = sqlite3_exec(db, zSql, evalCallback, &res, &zErrMsg);
+  if( zErrMsg ){
+    sqlite3_result_error(context, zErrMsg, -1);
+    sqlite3_free(zErrMsg);
+  }else if( rc ){
+    sqlite3_result_error_code(context, rc);
+  }else{
+    sqlite3_result_text(context, res.z, -1, SQLITE_TRANSIENT);
+  }
+  stringFree(&res);
+}
+
+/*
+** Look up the next task for client iClient in the database.
+** Return the task script and the task number and mark that
+** task as being under way.
+*/
+static int startScript(
+  int iClient,              /* The client number */
+  char **pzScript,          /* Write task script here */
+  int *pTaskId,             /* Write task number here */
+  char **pzTaskName         /* Name of the task */
+){
+  sqlite3_stmt *pStmt = 0;
+  int taskId;
+  int rc;
+  int totalTime = 0;
+
+  *pzScript = 0;
+  g.iTimeout = 0;
+  while(1){
+    rc = trySql("BEGIN IMMEDIATE");
+    if( rc==SQLITE_BUSY ){
+      sqlite3_sleep(10);
+      totalTime += 10;
+      continue;
+    }
+    if( rc!=SQLITE_OK ){
+      fatalError("in startScript: %s", sqlite3_errmsg(g.db));
+    }
+    if( g.nError || g.nTest ){
+      runSql("UPDATE counters SET nError=nError+%d, nTest=nTest+%d",
+             g.nError, g.nTest);
+      g.nError = 0;
+      g.nTest = 0;
+    }
+    pStmt = prepareSql("SELECT 1 FROM client WHERE id=%d AND wantHalt",iClient);
+    rc = sqlite3_step(pStmt);
+    sqlite3_finalize(pStmt);
+    if( rc==SQLITE_ROW ){
+      runSql("DELETE FROM client WHERE id=%d", iClient);
+      g.iTimeout = DEFAULT_TIMEOUT;
+      runSql("COMMIT TRANSACTION;");
+      return SQLITE_DONE;
+    }
+    pStmt = prepareSql(
+              "SELECT script, id, name FROM task"
+              " WHERE client=%d AND starttime IS NULL"
+              " ORDER BY id LIMIT 1", iClient);
+    rc = sqlite3_step(pStmt);
+    if( rc==SQLITE_ROW ){
+      int n = sqlite3_column_bytes(pStmt, 0);
+      *pzScript = sqlite3_malloc(n+1);
+      strcpy(*pzScript, (const char*)sqlite3_column_text(pStmt, 0));
+      *pTaskId = taskId = sqlite3_column_int(pStmt, 1);
+      *pzTaskName = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 2));
+      sqlite3_finalize(pStmt);
+      runSql("UPDATE task"
+             "   SET starttime=strftime('%%Y-%%m-%%d %%H:%%M:%%f','now')"
+             " WHERE id=%d;", taskId);
+      g.iTimeout = DEFAULT_TIMEOUT;
+      runSql("COMMIT TRANSACTION;");
+      return SQLITE_OK;
+    }
+    sqlite3_finalize(pStmt);
+    if( rc==SQLITE_DONE ){
+      if( totalTime>30000 ){
+        errorMessage("Waited over 30 seconds with no work.  Giving up.");
+        runSql("DELETE FROM client WHERE id=%d; COMMIT;", iClient);
+        sqlite3_close(g.db);
+        exit(1);
+      }
+      while( trySql("COMMIT")==SQLITE_BUSY ){
+        sqlite3_sleep(10);
+        totalTime += 10;
+      }
+      sqlite3_sleep(100);
+      totalTime += 100;
+      continue;
+    }
+    fatalError("%s", sqlite3_errmsg(g.db));
+  }
+  g.iTimeout = DEFAULT_TIMEOUT;
+}
+
+/*
+** Mark a script as having finished.   Remove the CLIENT table entry
+** if bShutdown is true.
+*/
+static int finishScript(int iClient, int taskId, int bShutdown){
+  runSql("UPDATE task"
+         "   SET endtime=strftime('%%Y-%%m-%%d %%H:%%M:%%f','now')"
+         " WHERE id=%d;", taskId);
+  if( bShutdown ){
+    runSql("DELETE FROM client WHERE id=%d", iClient);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Start up a client process for iClient, if it is not already
+** running.  If the client is already running, then this routine
+** is a no-op.
+*/
+static void startClient(int iClient){
+  runSql("INSERT OR IGNORE INTO client VALUES(%d,0)", iClient);
+  if( sqlite3_changes(g.db) ){
+    char *zSys;
+    int rc;
+    zSys = sqlite3_mprintf("%s \"%s\" --client %d --trace %d",
+                 g.argv0, g.zDbFile, iClient, g.iTrace);
+    if( g.bSqlTrace ){
+      zSys = sqlite3_mprintf("%z --sqltrace", zSys);
+    }
+    if( g.bSync ){
+      zSys = sqlite3_mprintf("%z --sync", zSys);
+    }
+    if( g.zVfs ){
+      zSys = sqlite3_mprintf("%z --vfs \"%s\"", zSys, g.zVfs);
+    }
+    if( g.iTrace>=2 ) logMessage("system('%q')", zSys);
+#if !defined(_WIN32)
+    zSys = sqlite3_mprintf("%z &", zSys);
+    rc = system(zSys);
+    if( rc ) errorMessage("system() fails with error code %d", rc);
+#else
+    {
+      STARTUPINFOA startupInfo;
+      PROCESS_INFORMATION processInfo;
+      memset(&startupInfo, 0, sizeof(startupInfo));
+      startupInfo.cb = sizeof(startupInfo);
+      memset(&processInfo, 0, sizeof(processInfo));
+      rc = CreateProcessA(NULL, zSys, NULL, NULL, FALSE, 0, NULL, NULL,
+                        &startupInfo, &processInfo);
+      if( rc ){
+        CloseHandle(processInfo.hThread);
+        CloseHandle(processInfo.hProcess);
+      }else{
+        errorMessage("CreateProcessA() fails with error code %lu",
+                     GetLastError());
+      }
+    }
+#endif
+    sqlite3_free(zSys);
+  }
+}
+
+/*
+** Read the entire content of a file into memory
+*/
+static char *readFile(const char *zFilename){
+  FILE *in = fopen(zFilename, "rb");
+  long sz;
+  char *z;
+  if( in==0 ){
+    fatalError("cannot open \"%s\" for reading", zFilename);
+  }
+  fseek(in, 0, SEEK_END);
+  sz = ftell(in);
+  rewind(in);
+  z = sqlite3_malloc( sz+1 );
+  sz = (long)fread(z, 1, sz, in);
+  z[sz] = 0;
+  fclose(in);
+  return z;
+}
+
+/*
+** Return the length of the next token.
+*/
+static int tokenLength(const char *z, int *pnLine){
+  int n = 0;
+  if( isspace(z[0]) || (z[0]=='/' && z[1]=='*') ){
+    int inC = 0;
+    int c;
+    if( z[0]=='/' ){
+      inC = 1;
+      n = 2;
+    }
+    while( (c = z[n++])!=0 ){
+      if( c=='\n' ) (*pnLine)++;
+      if( isspace(c) ) continue;
+      if( inC && c=='*' && z[n]=='/' ){
+        n++;
+        inC = 0;
+      }else if( !inC && c=='/' && z[n]=='*' ){
+        n++;
+        inC = 1;
+      }else if( !inC ){
+        break;
+      }
+    }
+    n--;
+  }else if( z[0]=='-' && z[1]=='-' ){
+    for(n=2; z[n] && z[n]!='\n'; n++){}
+    if( z[n] ){ (*pnLine)++; n++; }
+  }else if( z[0]=='"' || z[0]=='\'' ){
+    int delim = z[0];
+    for(n=1; z[n]; n++){
+      if( z[n]=='\n' ) (*pnLine)++;
+      if( z[n]==delim ){
+        n++;
+        if( z[n+1]!=delim ) break;
+      }
+    }
+  }else{
+    int c;
+    for(n=1; (c = z[n])!=0 && !isspace(c) && c!='"' && c!='\'' && c!=';'; n++){}
+  }
+  return n;
+}
+
+/*
+** Copy a single token into a string buffer.
+*/
+static int extractToken(const char *zIn, int nIn, char *zOut, int nOut){
+  int i;
+  if( nIn<=0 ){
+    zOut[0] = 0;
+    return 0;
+  }
+  for(i=0; i<nIn && i<nOut-1 && !isspace(zIn[i]); i++){ zOut[i] = zIn[i]; }
+  zOut[i] = 0;
+  return i;
+}
+
+/*
+** Find the number of characters up to the start of the next "--end" token.
+*/
+static int findEnd(const char *z, int *pnLine){
+  int n = 0;
+  while( z[n] && (strncmp(z+n,"--end",5) || !isspace(z[n+5])) ){
+    n += tokenLength(z+n, pnLine);
+  }
+  return n;
+}
+
+/*
+** Find the number of characters up to the first character past the
+** of the next "--endif"  or "--else" token. Nested --if commands are
+** also skipped.
+*/
+static int findEndif(const char *z, int stopAtElse, int *pnLine){
+  int n = 0;
+  while( z[n] ){
+    int len = tokenLength(z+n, pnLine);
+    if( (strncmp(z+n,"--endif",7)==0 && isspace(z[n+7]))
+     || (stopAtElse && strncmp(z+n,"--else",6)==0 && isspace(z[n+6]))
+    ){
+      return n+len;
+    }
+    if( strncmp(z+n,"--if",4)==0 && isspace(z[n+4]) ){
+      int skip = findEndif(z+n+len, 0, pnLine);
+      n += skip + len;
+    }else{
+      n += len;
+    }
+  }
+  return n;
+}
+
+/*
+** Wait for a client process to complete all its tasks
+*/
+static void waitForClient(int iClient, int iTimeout, char *zErrPrefix){
+  sqlite3_stmt *pStmt;
+  int rc;
+  if( iClient>0 ){
+    pStmt = prepareSql(
+               "SELECT 1 FROM task"
+               " WHERE client=%d"
+               "   AND client IN (SELECT id FROM client)"
+               "  AND endtime IS NULL",
+               iClient);
+  }else{
+    pStmt = prepareSql(
+               "SELECT 1 FROM task"
+               " WHERE client IN (SELECT id FROM client)"
+               "   AND endtime IS NULL");
+  }
+  g.iTimeout = 0;
+  while( ((rc = sqlite3_step(pStmt))==SQLITE_BUSY || rc==SQLITE_ROW)
+    && iTimeout>0
+  ){
+    sqlite3_reset(pStmt);
+    sqlite3_sleep(50);
+    iTimeout -= 50;
+  }
+  sqlite3_finalize(pStmt);
+  g.iTimeout = DEFAULT_TIMEOUT;
+  if( rc!=SQLITE_DONE ){
+    if( zErrPrefix==0 ) zErrPrefix = "";
+    if( iClient>0 ){
+      errorMessage("%stimeout waiting for client %d", zErrPrefix, iClient);
+    }else{
+      errorMessage("%stimeout waiting for all clients", zErrPrefix);
+    }
+  }
+}
+
+/* Return a pointer to the tail of a filename
+*/
+static char *filenameTail(char *z){
+  int i, j;
+  for(i=j=0; z[i]; i++) if( z[i]=='/' ) j = i+1;
+  return z+j;
+}
+
+/*
+** Interpret zArg as a boolean value.  Return either 0 or 1.
+*/
+static int booleanValue(char *zArg){
+  int i;
+  if( zArg==0 ) return 0;
+  for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
+  if( i>0 && zArg[i]==0 ) return atoi(zArg);
+  if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
+    return 1;
+  }
+  if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
+    return 0;
+  }
+  errorMessage("unknown boolean: [%s]", zArg);
+  return 0;
+}
+
+
+/* This routine exists as a convenient place to set a debugger
+** breakpoint.
+*/
+static void test_breakpoint(void){ static volatile int cnt = 0; cnt++; }
+
+/* Maximum number of arguments to a --command */
+#define MX_ARG 2
+
+/*
+** Run a script.
+*/
+static void runScript(
+  int iClient,       /* The client number, or 0 for the master */
+  int taskId,        /* The task ID for clients.  0 for master */
+  char *zScript,     /* Text of the script */
+  char *zFilename    /* File from which script was read. */
+){
+  int lineno = 1;
+  int prevLine = 1;
+  int ii = 0;
+  int iBegin = 0;
+  int n, c, j;
+  int len;
+  int nArg;
+  String sResult;
+  char zCmd[30];
+  char zError[1000];
+  char azArg[MX_ARG][100];
+
+  memset(&sResult, 0, sizeof(sResult));
+  stringReset(&sResult);
+  while( (c = zScript[ii])!=0 ){
+    prevLine = lineno;
+    len = tokenLength(zScript+ii, &lineno);
+    if( isspace(c) || (c=='/' && zScript[ii+1]=='*') ){
+      ii += len;
+      continue;
+    }
+    if( c!='-' || zScript[ii+1]!='-' || !isalpha(zScript[ii+2]) ){
+      ii += len;
+      continue;
+    }
+
+    /* Run any prior SQL before processing the new --command */
+    if( ii>iBegin ){
+      char *zSql = sqlite3_mprintf("%.*s", ii-iBegin, zScript+iBegin);
+      evalSql(&sResult, zSql);
+      sqlite3_free(zSql);
+      iBegin = ii + len;
+    }
+
+    /* Parse the --command */
+    if( g.iTrace>=2 ) logMessage("%.*s", len, zScript+ii);
+    n = extractToken(zScript+ii+2, len-2, zCmd, sizeof(zCmd));
+    for(nArg=0; n<len-2 && nArg<MX_ARG; nArg++){
+      while( n<len-2 && isspace(zScript[ii+2+n]) ){ n++; }
+      if( n>=len-2 ) break;
+      n += extractToken(zScript+ii+2+n, len-2-n,
+                        azArg[nArg], sizeof(azArg[nArg]));
+    }
+    for(j=nArg; j<MX_ARG; j++) azArg[j++][0] = 0;
+
+    /*
+    **  --sleep N
+    **
+    ** Pause for N milliseconds
+    */
+    if( strcmp(zCmd, "sleep")==0 ){
+      sqlite3_sleep(atoi(azArg[0]));
+    }else 
+
+    /*
+    **   --exit N
+    **
+    ** Exit this process.  If N>0 then exit without shutting down
+    ** SQLite.  (In other words, simulate a crash.)
+    */
+    if( strcmp(zCmd, "exit")==0 ){
+      int rc = atoi(azArg[0]);
+      finishScript(iClient, taskId, 1);
+      if( rc==0 ) sqlite3_close(g.db);
+      exit(rc);
+    }else
+
+    /*
+    **   --testcase NAME
+    **
+    ** Begin a new test case.  Announce in the log that the test case
+    ** has begun.
+    */
+    if( strcmp(zCmd, "testcase")==0 ){
+      if( g.iTrace==1 ) logMessage("%.*s", len - 1, zScript+ii);
+      stringReset(&sResult);
+    }else
+
+    /*
+    **   --finish
+    **
+    ** Mark the current task as having finished, even if it is not.
+    ** This can be used in conjunction with --exit to simulate a crash.
+    */
+    if( strcmp(zCmd, "finish")==0 && iClient>0 ){
+      finishScript(iClient, taskId, 1);
+    }else
+
+    /*
+    **  --reset
+    **
+    ** Reset accumulated results back to an empty string
+    */
+    if( strcmp(zCmd, "reset")==0 ){
+      stringReset(&sResult);
+    }else
+
+    /*
+    **  --match ANSWER...
+    **
+    ** Check to see if output matches ANSWER.  Report an error if not.
+    */
+    if( strcmp(zCmd, "match")==0 ){
+      int jj;
+      char *zAns = zScript+ii;
+      for(jj=7; jj<len-1 && isspace(zAns[jj]); jj++){}
+      zAns += jj;
+      if( len-jj-1!=sResult.n || strncmp(sResult.z, zAns, len-jj-1) ){
+        errorMessage("line %d of %s:\nExpected [%.*s]\n     Got [%s]",
+          prevLine, zFilename, len-jj-1, zAns, sResult.z);
+      }
+      g.nTest++;
+      stringReset(&sResult);
+    }else
+
+    /*
+    **  --glob ANSWER...
+    **  --notglob ANSWER....
+    **
+    ** Check to see if output does or does not match the glob pattern
+    ** ANSWER.
+    */
+    if( strcmp(zCmd, "glob")==0 || strcmp(zCmd, "notglob")==0 ){
+      int jj;
+      char *zAns = zScript+ii;
+      char *zCopy;
+      int isGlob = (zCmd[0]=='g');
+      for(jj=9-3*isGlob; jj<len-1 && isspace(zAns[jj]); jj++){}
+      zAns += jj;
+      zCopy = sqlite3_mprintf("%.*s", len-jj-1, zAns);
+      if( (sqlite3_strglob(zCopy, sResult.z)==0)^isGlob ){
+        errorMessage("line %d of %s:\nExpected [%s]\n     Got [%s]",
+          prevLine, zFilename, zCopy, sResult.z);
+      }
+      sqlite3_free(zCopy);
+      g.nTest++;
+      stringReset(&sResult);
+    }else
+
+    /*
+    **  --output
+    **
+    ** Output the result of the previous SQL.
+    */
+    if( strcmp(zCmd, "output")==0 ){
+      logMessage("%s", sResult.z);
+    }else
+
+    /*
+    **  --source FILENAME
+    **
+    ** Run a subscript from a separate file.
+    */
+    if( strcmp(zCmd, "source")==0 ){
+      char *zNewFile, *zNewScript;
+      char *zToDel = 0;
+      zNewFile = azArg[0];
+      if( zNewFile[0]!='/' ){
+        int k;
+        for(k=(int)strlen(zFilename)-1; k>=0 && zFilename[k]!='/'; k--){}
+        if( k>0 ){
+          zNewFile = zToDel = sqlite3_mprintf("%.*s/%s", k,zFilename,zNewFile);
+        }
+      }
+      zNewScript = readFile(zNewFile);
+      if( g.iTrace ) logMessage("begin script [%s]\n", zNewFile);
+      runScript(0, 0, zNewScript, zNewFile);
+      sqlite3_free(zNewScript);
+      if( g.iTrace ) logMessage("end script [%s]\n", zNewFile);
+      sqlite3_free(zToDel);
+    }else
+
+    /*
+    **  --print MESSAGE....
+    **
+    ** Output the remainder of the line to the log file
+    */
+    if( strcmp(zCmd, "print")==0 ){
+      int jj;
+      for(jj=7; jj<len && isspace(zScript[ii+jj]); jj++){}
+      logMessage("%.*s", len-jj, zScript+ii+jj);
+    }else
+
+    /*
+    **  --if EXPR
+    **
+    ** Skip forward to the next matching --endif or --else if EXPR is false.
+    */
+    if( strcmp(zCmd, "if")==0 ){
+      int jj, rc;
+      sqlite3_stmt *pStmt;
+      for(jj=4; jj<len && isspace(zScript[ii+jj]); jj++){}
+      pStmt = prepareSql("SELECT %.*s", len-jj, zScript+ii+jj);
+      rc = sqlite3_step(pStmt);
+      if( rc!=SQLITE_ROW || sqlite3_column_int(pStmt, 0)==0 ){
+        ii += findEndif(zScript+ii+len, 1, &lineno);
+      }
+      sqlite3_finalize(pStmt);
+    }else
+
+    /*
+    **  --else
+    **
+    ** This command can only be encountered if currently inside an --if that
+    ** is true.  Skip forward to the next matching --endif.
+    */
+    if( strcmp(zCmd, "else")==0 ){
+      ii += findEndif(zScript+ii+len, 0, &lineno);
+    }else
+
+    /*
+    **  --endif
+    **
+    ** This command can only be encountered if currently inside an --if that
+    ** is true or an --else of a false if.  This is a no-op.
+    */
+    if( strcmp(zCmd, "endif")==0 ){
+      /* no-op */
+    }else
+
+    /*
+    **  --start CLIENT
+    **
+    ** Start up the given client.
+    */
+    if( strcmp(zCmd, "start")==0 && iClient==0 ){
+      int iNewClient = atoi(azArg[0]);
+      if( iNewClient>0 ){
+        startClient(iNewClient);
+      }
+    }else
+
+    /*
+    **  --wait CLIENT TIMEOUT
+    **
+    ** Wait until all tasks complete for the given client.  If CLIENT is
+    ** "all" then wait for all clients to complete.  Wait no longer than
+    ** TIMEOUT milliseconds (default 10,000)
+    */
+    if( strcmp(zCmd, "wait")==0 && iClient==0 ){
+      int iTimeout = nArg>=2 ? atoi(azArg[1]) : 10000;
+      sqlite3_snprintf(sizeof(zError),zError,"line %d of %s\n",
+                       prevLine, zFilename);
+      waitForClient(atoi(azArg[0]), iTimeout, zError);
+    }else
+
+    /*
+    **  --task CLIENT
+    **     <task-content-here>
+    **  --end
+    **
+    ** Assign work to a client.  Start the client if it is not running
+    ** already.
+    */
+    if( strcmp(zCmd, "task")==0 && iClient==0 ){
+      int iTarget = atoi(azArg[0]);
+      int iEnd;
+      char *zTask;
+      char *zTName;
+      iEnd = findEnd(zScript+ii+len, &lineno);
+      if( iTarget<0 ){
+        errorMessage("line %d of %s: bad client number: %d",
+                     prevLine, zFilename, iTarget);
+      }else{
+        zTask = sqlite3_mprintf("%.*s", iEnd, zScript+ii+len);
+        if( nArg>1 ){
+          zTName = sqlite3_mprintf("%s", azArg[1]);
+        }else{
+          zTName = sqlite3_mprintf("%s:%d", filenameTail(zFilename), prevLine);
+        }
+        startClient(iTarget);
+        runSql("INSERT INTO task(client,script,name)"
+               " VALUES(%d,'%q',%Q)", iTarget, zTask, zTName);
+        sqlite3_free(zTask);
+        sqlite3_free(zTName);
+      }
+      iEnd += tokenLength(zScript+ii+len+iEnd, &lineno);
+      len += iEnd;
+      iBegin = ii+len;
+    }else
+
+    /*
+    **  --breakpoint
+    **
+    ** This command calls "test_breakpoint()" which is a routine provided
+    ** as a convenient place to set a debugger breakpoint.
+    */
+    if( strcmp(zCmd, "breakpoint")==0 ){
+      test_breakpoint();
+    }else
+
+    /*
+    **  --show-sql-errors BOOLEAN
+    **
+    ** Turn display of SQL errors on and off.
+    */
+    if( strcmp(zCmd, "show-sql-errors")==0 ){
+      g.bIgnoreSqlErrors = nArg>=1 ? !booleanValue(azArg[0]) : 1;
+    }else
+
+
+    /* error */{
+      errorMessage("line %d of %s: unknown command --%s",
+                   prevLine, zFilename, zCmd);
+    }
+    ii += len;
+  }
+  if( iBegin<ii ){
+    char *zSql = sqlite3_mprintf("%.*s", ii-iBegin, zScript+iBegin);
+    runSql(zSql);
+    sqlite3_free(zSql);
+  }
+  stringFree(&sResult);
+}
+
+/*
+** Look for a command-line option.  If present, return a pointer.
+** Return NULL if missing.
+**
+** hasArg==0 means the option is a flag.  It is either present or not.
+** hasArg==1 means the option has an argument.  Return a pointer to the
+** argument.
+*/
+static char *findOption(
+  char **azArg,
+  int *pnArg,
+  const char *zOption,
+  int hasArg
+){
+  int i, j;
+  char *zReturn = 0;
+  int nArg = *pnArg;
+
+  assert( hasArg==0 || hasArg==1 );
+  for(i=0; i<nArg; i++){
+    const char *z;
+    if( i+hasArg >= nArg ) break;
+    z = azArg[i];
+    if( z[0]!='-' ) continue;
+    z++;
+    if( z[0]=='-' ){
+      if( z[1]==0 ) break;
+      z++;
+    }
+    if( strcmp(z,zOption)==0 ){
+      if( hasArg && i==nArg-1 ){
+        fatalError("command-line option \"--%s\" requires an argument", z);
+      }
+      if( hasArg ){
+        zReturn = azArg[i+1];
+      }else{
+        zReturn = azArg[i];
+      }
+      j = i+1+(hasArg!=0);
+      while( j<nArg ) azArg[i++] = azArg[j++];
+      *pnArg = i;
+      return zReturn;
+    }
+  }
+  return zReturn;
+}
+
+/* Print a usage message for the program and exit */
+static void usage(const char *argv0){
+  int i;
+  const char *zTail = argv0;
+  for(i=0; argv0[i]; i++){
+    if( argv0[i]=='/' ) zTail = argv0+i+1;
+  }
+  fprintf(stderr,"Usage: %s DATABASE ?OPTIONS? ?SCRIPT?\n", zTail);
+  exit(1);
+}
+
+/* Report on unrecognized arguments */
+static void unrecognizedArguments(
+  const char *argv0,
+  int nArg,
+  char **azArg
+){
+  int i;
+  fprintf(stderr,"%s: unrecognized arguments:", argv0);
+  for(i=0; i<nArg; i++){
+    fprintf(stderr," %s", azArg[i]);
+  }
+  fprintf(stderr,"\n");
+  exit(1);
+}
+
+int main(int argc, char **argv){
+  const char *zClient;
+  int iClient;
+  int n, i;
+  int openFlags = SQLITE_OPEN_READWRITE;
+  int rc;
+  char *zScript;
+  int taskId;
+  const char *zTrace;
+  const char *zCOption;
+
+  g.argv0 = argv[0];
+  g.iTrace = 1;
+  if( argc<2 ) usage(argv[0]);
+  g.zDbFile = argv[1];
+  if( strglob("*.test", g.zDbFile) ) usage(argv[0]);
+  if( strcmp(sqlite3_sourceid(), SQLITE_SOURCE_ID)!=0 ){
+    fprintf(stderr, "SQLite library and header mismatch\n"
+                    "Library: %s\n"
+                    "Header:  %s\n",
+                    sqlite3_sourceid(), SQLITE_SOURCE_ID);
+    exit(1);
+  }
+  n = argc-2;
+  sqlite3_snprintf(sizeof(g.zName), g.zName, "%05d.mptest", GETPID());
+  g.zVfs = findOption(argv+2, &n, "vfs", 1);
+  zClient = findOption(argv+2, &n, "client", 1);
+  g.zErrLog = findOption(argv+2, &n, "errlog", 1);
+  g.zLog = findOption(argv+2, &n, "log", 1);
+  zTrace = findOption(argv+2, &n, "trace", 1);
+  if( zTrace ) g.iTrace = atoi(zTrace);
+  if( findOption(argv+2, &n, "quiet", 0)!=0 ) g.iTrace = 0;
+  g.bSqlTrace = findOption(argv+2, &n, "sqltrace", 0)!=0;
+  g.bSync = findOption(argv+2, &n, "sync", 0)!=0;
+  if( g.zErrLog ){
+    g.pErrLog = fopen(g.zErrLog, "a");
+  }else{
+    g.pErrLog = stderr;
+  }
+  if( g.zLog ){
+    g.pLog = fopen(g.zLog, "a");
+  }else{
+    g.pLog = stdout;
+  }
+  
+  sqlite3_config(SQLITE_CONFIG_LOG, sqlErrorCallback, 0);
+  if( zClient ){
+    iClient = atoi(zClient);
+    if( iClient<1 ) fatalError("illegal client number: %d\n", iClient);
+    sqlite3_snprintf(sizeof(g.zName), g.zName, "%05d.client%02d",
+                     GETPID(), iClient);
+  }else{
+    if( g.iTrace>0 ){
+      printf("With SQLite " SQLITE_VERSION " " SQLITE_SOURCE_ID "\n" );
+      for(i=0; (zCOption = sqlite3_compileoption_get(i))!=0; i++){
+        printf("-DSQLITE_%s\n", zCOption);
+      }
+      fflush(stdout);
+    }
+    iClient =  0;
+    unlink(g.zDbFile);
+    openFlags |= SQLITE_OPEN_CREATE;
+  }
+  rc = sqlite3_open_v2(g.zDbFile, &g.db, openFlags, g.zVfs);
+  if( rc ) fatalError("cannot open [%s]", g.zDbFile);
+  sqlite3_enable_load_extension(g.db, 1);
+  sqlite3_busy_handler(g.db, busyHandler, 0);
+  sqlite3_create_function(g.db, "vfsname", 0, SQLITE_UTF8, 0,
+                          vfsNameFunc, 0, 0);
+  sqlite3_create_function(g.db, "eval", 1, SQLITE_UTF8, 0,
+                          evalFunc, 0, 0);
+  g.iTimeout = DEFAULT_TIMEOUT;
+  if( g.bSqlTrace ) sqlite3_trace(g.db, sqlTraceCallback, 0);
+  if( !g.bSync ) trySql("PRAGMA synchronous=OFF");
+  if( iClient>0 ){
+    if( n>0 ) unrecognizedArguments(argv[0], n, argv+2);
+    if( g.iTrace ) logMessage("start-client");
+    while(1){
+      char *zTaskName = 0;
+      rc = startScript(iClient, &zScript, &taskId, &zTaskName);
+      if( rc==SQLITE_DONE ) break;
+      if( g.iTrace ) logMessage("begin %s (%d)", zTaskName, taskId);
+      runScript(iClient, taskId, zScript, zTaskName);
+      if( g.iTrace ) logMessage("end %s (%d)", zTaskName, taskId);
+      finishScript(iClient, taskId, 0);
+      sqlite3_free(zTaskName);
+      sqlite3_sleep(10);
+    }
+    if( g.iTrace ) logMessage("end-client");
+  }else{
+    sqlite3_stmt *pStmt;
+    int iTimeout;
+    if( n==0 ){
+      fatalError("missing script filename");
+    }
+    if( n>1 ) unrecognizedArguments(argv[0], n, argv+2);
+    runSql(
+      "CREATE TABLE task(\n"
+      "  id INTEGER PRIMARY KEY,\n"
+      "  name TEXT,\n"
+      "  client INTEGER,\n"
+      "  starttime DATE,\n"
+      "  endtime DATE,\n"
+      "  script TEXT\n"
+      ");"
+      "CREATE INDEX task_i1 ON task(client, starttime);\n"
+      "CREATE INDEX task_i2 ON task(client, endtime);\n"
+      "CREATE TABLE counters(nError,nTest);\n"
+      "INSERT INTO counters VALUES(0,0);\n"
+      "CREATE TABLE client(id INTEGER PRIMARY KEY, wantHalt);\n"
+    );
+    zScript = readFile(argv[2]);
+    if( g.iTrace ) logMessage("begin script [%s]\n", argv[2]);
+    runScript(0, 0, zScript, argv[2]);
+    sqlite3_free(zScript);
+    if( g.iTrace ) logMessage("end script [%s]\n", argv[2]);
+    waitForClient(0, 2000, "during shutdown...\n");
+    trySql("UPDATE client SET wantHalt=1");
+    sqlite3_sleep(10);
+    g.iTimeout = 0;
+    iTimeout = 1000;
+    while( ((rc = trySql("SELECT 1 FROM client"))==SQLITE_BUSY
+        || rc==SQLITE_ROW) && iTimeout>0 ){
+      sqlite3_sleep(10);
+      iTimeout -= 10;
+    }
+    sqlite3_sleep(100);
+    pStmt = prepareSql("SELECT nError, nTest FROM counters");
+    iTimeout = 1000;
+    while( (rc = sqlite3_step(pStmt))==SQLITE_BUSY && iTimeout>0 ){
+      sqlite3_sleep(10);
+      iTimeout -= 10;
+    }
+    if( rc==SQLITE_ROW ){
+      g.nError += sqlite3_column_int(pStmt, 0);
+      g.nTest += sqlite3_column_int(pStmt, 1);
+    }
+    sqlite3_finalize(pStmt);
+  }
+  sqlite3_close(g.db);  
+  maybeClose(g.pLog);
+  maybeClose(g.pErrLog);
+  if( iClient==0 ){
+    printf("Summary: %d errors in %d tests\n", g.nError, g.nTest);
+  }
+  return g.nError>0;
+}

ADDED   mptest/multiwrite01.test
Index: mptest/multiwrite01.test
==================================================================
--- mptest/multiwrite01.test
+++ mptest/multiwrite01.test
@@ -0,0 +1,405 @@
+/*
+** This script sets up five different tasks all writing and updating
+** the database at the same time, but each in its own table.
+*/
+--task 1 build-t1
+  DROP TABLE IF EXISTS t1;
+  CREATE TABLE t1(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t1 VALUES(1, randomblob(2000));
+  INSERT INTO t1 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t1 SELECT a+2, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+4, randomblob(1500) FROM t1;
+  INSERT INTO t1 SELECT a+8, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+16, randomblob(1500) FROM t1;
+  --sleep 1
+  INSERT INTO t1 SELECT a+32, randomblob(1500) FROM t1;
+  SELECT count(*) FROM t1;
+  --match 64
+  SELECT avg(length(b)) FROM t1;
+  --match 1500.0
+  --sleep 2
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t1;
+  --match 247
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t1b ON t1(b);
+  SELECT a FROM t1 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t1 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+
+--task 2 build-t2
+  DROP TABLE IF EXISTS t2;
+  CREATE TABLE t2(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t2 VALUES(1, randomblob(2000));
+  INSERT INTO t2 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t2 SELECT a+2, randomblob(1500) FROM t2;
+  INSERT INTO t2 SELECT a+4, randomblob(1500) FROM t2;
+  INSERT INTO t2 SELECT a+8, randomblob(1500) FROM t2;
+  --sleep 1
+  INSERT INTO t2 SELECT a+16, randomblob(1500) FROM t2;
+  --sleep 1
+  INSERT INTO t2 SELECT a+32, randomblob(1500) FROM t2;
+  SELECT count(*) FROM t2;
+  --match 64
+  SELECT avg(length(b)) FROM t2;
+  --match 1500.0
+  --sleep 2
+  UPDATE t2 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t2;
+  --match 247
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t2b ON t2(b);
+  SELECT a FROM t2 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t2 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--task 3 build-t3
+  DROP TABLE IF EXISTS t3;
+  CREATE TABLE t3(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t3 VALUES(1, randomblob(2000));
+  INSERT INTO t3 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t3 SELECT a+2, randomblob(1500) FROM t3;
+  INSERT INTO t3 SELECT a+4, randomblob(1500) FROM t3;
+  INSERT INTO t3 SELECT a+8, randomblob(1500) FROM t3;
+  --sleep 1
+  INSERT INTO t3 SELECT a+16, randomblob(1500) FROM t3;
+  --sleep 1
+  INSERT INTO t3 SELECT a+32, randomblob(1500) FROM t3;
+  SELECT count(*) FROM t3;
+  --match 64
+  SELECT avg(length(b)) FROM t3;
+  --match 1500.0
+  --sleep 2
+  UPDATE t3 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t3;
+  --match 247
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t3b ON t3(b);
+  SELECT a FROM t3 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t3 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--task 4 build-t4
+  DROP TABLE IF EXISTS t4;
+  CREATE TABLE t4(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t4 VALUES(1, randomblob(2000));
+  INSERT INTO t4 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t4 SELECT a+2, randomblob(1500) FROM t4;
+  INSERT INTO t4 SELECT a+4, randomblob(1500) FROM t4;
+  INSERT INTO t4 SELECT a+8, randomblob(1500) FROM t4;
+  --sleep 1
+  INSERT INTO t4 SELECT a+16, randomblob(1500) FROM t4;
+  --sleep 1
+  INSERT INTO t4 SELECT a+32, randomblob(1500) FROM t4;
+  SELECT count(*) FROM t4;
+  --match 64
+  SELECT avg(length(b)) FROM t4;
+  --match 1500.0
+  --sleep 2
+  UPDATE t4 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t4;
+  --match 247
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t4b ON t4(b);
+  SELECT a FROM t4 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t4 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--task 5 build-t5
+  DROP TABLE IF EXISTS t5;
+  CREATE TABLE t5(a INTEGER PRIMARY KEY, b);
+  --sleep 1
+  INSERT INTO t5 VALUES(1, randomblob(2000));
+  INSERT INTO t5 VALUES(2, randomblob(1000));
+  --sleep 1
+  INSERT INTO t5 SELECT a+2, randomblob(1500) FROM t5;
+  INSERT INTO t5 SELECT a+4, randomblob(1500) FROM t5;
+  INSERT INTO t5 SELECT a+8, randomblob(1500) FROM t5;
+  --sleep 1
+  INSERT INTO t5 SELECT a+16, randomblob(1500) FROM t5;
+  --sleep 1
+  INSERT INTO t5 SELECT a+32, randomblob(1500) FROM t5;
+  SELECT count(*) FROM t5;
+  --match 64
+  SELECT avg(length(b)) FROM t5;
+  --match 1500.0
+  --sleep 2
+  UPDATE t5 SET b='x'||a||'y';
+  SELECT total(length(b)) FROM t5;
+  --match 247
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  CREATE INDEX t5b ON t5(b);
+  SELECT a FROM t5 WHERE b='x17y';
+  --match 17
+  SELECT a FROM t5 WHERE b GLOB 'x2?y' ORDER BY b DESC LIMIT 5;
+  --match 29 28 27 26 25
+--end
+
+--wait all
+SELECT count(*), total(length(b)) FROM t1;
+--match 64 247
+SELECT count(*), total(length(b)) FROM t2;
+--match 64 247
+SELECT count(*), total(length(b)) FROM t3;
+--match 64 247
+SELECT count(*), total(length(b)) FROM t4;
+--match 64 247
+SELECT count(*), total(length(b)) FROM t5;
+--match 64 247
+
+--task 1
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 5
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 3
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 2
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 4
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--wait all
+
+--task 5
+  DROP INDEX t5b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t5b ON t5(b DESC);
+--end
+--task 3
+  DROP INDEX t3b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t3b ON t3(b DESC);
+--end
+--task 1
+  DROP INDEX t1b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t1b ON t1(b DESC);
+--end
+--task 2
+  DROP INDEX t2b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t2b ON t2(b DESC);
+--end
+--task 4
+  DROP INDEX t4b;
+  --sleep 5
+  PRAGMA integrity_check(10);
+  --match ok
+  CREATE INDEX t4b ON t4(b DESC);
+--end
+--wait all
+
+--task 1
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 5
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 3
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 2
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 4
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--wait all
+
+VACUUM;
+PRAGMA integrity_check(10);
+--match ok
+
+--task 1
+  UPDATE t1 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t1 SET b='x'||a||'y';
+  SELECT a FROM t1 WHERE b='x63y';
+  --match 63
+--end
+--task 2
+  UPDATE t2 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t2 SET b='x'||a||'y';
+  SELECT a FROM t2 WHERE b='x63y';
+  --match 63
+--end
+--task 3
+  UPDATE t3 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t3 SET b='x'||a||'y';
+  SELECT a FROM t3 WHERE b='x63y';
+  --match 63
+--end
+--task 4
+  UPDATE t4 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t4 SET b='x'||a||'y';
+  SELECT a FROM t4 WHERE b='x63y';
+  --match 63
+--end
+--task 5
+  UPDATE t5 SET b=randomblob(20000);
+  --sleep 5
+  UPDATE t5 SET b='x'||a||'y';
+  SELECT a FROM t5 WHERE b='x63y';
+  --match 63
+--end
+--wait all
+
+--task 1
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 5
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 3
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 2
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--task 4
+  SELECT t1.a FROM t1, t2
+   WHERE t2.b GLOB 'x3?y' AND t1.b=('x'||(t2.a+3)||'y')
+   ORDER BY t1.a LIMIT 4
+  --match 33 34 35 36
+  SELECT t3.a FROM t3, t4
+   WHERE t4.b GLOB 'x4?y' AND t3.b=('x'||(t4.a+5)||'y')
+   ORDER BY t3.a LIMIT 7
+  --match 45 46 47 48 49 50 51
+--end
+--wait all

Index: src/backup.c
==================================================================
--- src/backup.c
+++ src/backup.c
@@ -395,11 +395,12 @@
     assert( nSrcPage>=0 );
     for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
       const Pgno iSrcPg = p->iNext;                 /* Source page number */
       if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
         DbPage *pSrcPg;                             /* Source page object */
-        rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
+        rc = sqlite3PagerAcquire(pSrcPager, iSrcPg, &pSrcPg,
+                                 PAGER_ACQUIRE_READONLY);
         if( rc==SQLITE_OK ){
           rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0);
           sqlite3PagerUnref(pSrcPg);
         }
       }

Index: src/btree.c
==================================================================
--- src/btree.c
+++ src/btree.c
@@ -1579,17 +1579,21 @@
 */
 static int btreeGetPage(
   BtShared *pBt,       /* The btree */
   Pgno pgno,           /* Number of the page to fetch */
   MemPage **ppPage,    /* Return the page in this parameter */
-  int noContent        /* Do not load page content if true */
+  int noContent,       /* Do not load page content if true */
+  int bReadonly        /* True if a read-only (mmap) page is ok */
 ){
   int rc;
   DbPage *pDbPage;
+  int flags = (noContent ? PAGER_ACQUIRE_NOCONTENT : 0) 
+            | (bReadonly ? PAGER_ACQUIRE_READONLY : 0);
 
+  assert( noContent==0 || bReadonly==0 );
   assert( sqlite3_mutex_held(pBt->mutex) );
-  rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
+  rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, flags);
   if( rc ) return rc;
   *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
   return SQLITE_OK;
 }
 
@@ -1628,21 +1632,22 @@
 **
 ** If an error occurs, then the value *ppPage is set to is undefined. It
 ** may remain unchanged, or it may be set to an invalid value.
 */
 static int getAndInitPage(
-  BtShared *pBt,          /* The database file */
-  Pgno pgno,           /* Number of the page to get */
-  MemPage **ppPage     /* Write the page pointer here */
+  BtShared *pBt,                  /* The database file */
+  Pgno pgno,                      /* Number of the page to get */
+  MemPage **ppPage,               /* Write the page pointer here */
+  int bReadonly                   /* True if a read-only (mmap) page is ok */
 ){
   int rc;
   assert( sqlite3_mutex_held(pBt->mutex) );
 
   if( pgno>btreePagecount(pBt) ){
     rc = SQLITE_CORRUPT_BKPT;
   }else{
-    rc = btreeGetPage(pBt, pgno, ppPage, 0);
+    rc = btreeGetPage(pBt, pgno, ppPage, 0, bReadonly);
     if( rc==SQLITE_OK ){
       rc = btreeInitPage(*ppPage);
       if( rc!=SQLITE_OK ){
         releasePage(*ppPage);
       }
@@ -1869,10 +1874,11 @@
       goto btree_open_out;
     }
     rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
                           EXTRA_SIZE, flags, vfsFlags, pageReinit);
     if( rc==SQLITE_OK ){
+      sqlite3PagerSetMmapLimit(pBt->pPager, db->szMmap);
       rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
     }
     if( rc!=SQLITE_OK ){
       goto btree_open_out;
     }
@@ -2134,10 +2140,23 @@
   sqlite3BtreeEnter(p);
   sqlite3PagerSetCachesize(pBt->pPager, mxPage);
   sqlite3BtreeLeave(p);
   return SQLITE_OK;
 }
+
+/*
+** Change the limit on the amount of the database file that may be
+** memory mapped.
+*/
+int sqlite3BtreeSetMmapLimit(Btree *p, sqlite3_int64 szMmap){
+  BtShared *pBt = p->pBt;
+  assert( sqlite3_mutex_held(p->db->mutex) );
+  sqlite3BtreeEnter(p);
+  sqlite3PagerSetMmapLimit(pBt->pPager, szMmap);
+  sqlite3BtreeLeave(p);
+  return SQLITE_OK;
+}
 
 /*
 ** Change the way data is synced to disk in order to increase or decrease
 ** how well the database resists damage due to OS crashes and power
 ** failures.  Level 1 is the same as asynchronous (no syncs() occur and
@@ -2360,11 +2379,11 @@
 
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( pBt->pPage1==0 );
   rc = sqlite3PagerSharedLock(pBt->pPager);
   if( rc!=SQLITE_OK ) return rc;
-  rc = btreeGetPage(pBt, 1, &pPage1, 0);
+  rc = btreeGetPage(pBt, 1, &pPage1, 0, 0);
   if( rc!=SQLITE_OK ) return rc;
 
   /* Do some checking to help insure the file we opened really is
   ** a valid database file. 
   */
@@ -2919,11 +2938,11 @@
   /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
   ** that it points at iFreePage. Also fix the pointer map entry for
   ** iPtrPage.
   */
   if( eType!=PTRMAP_ROOTPAGE ){
-    rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
+    rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0, 0);
     if( rc!=SQLITE_OK ){
       return rc;
     }
     rc = sqlite3PagerWrite(pPtrPage->pDbPage);
     if( rc!=SQLITE_OK ){
@@ -3003,11 +3022,11 @@
       Pgno iFreePg;             /* Index of free page to move pLastPg to */
       MemPage *pLastPg;
       u8 eMode = BTALLOC_ANY;   /* Mode parameter for allocateBtreePage() */
       Pgno iNear = 0;           /* nearby parameter for allocateBtreePage() */
 
-      rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
+      rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0, 0);
       if( rc!=SQLITE_OK ){
         return rc;
       }
 
       /* If bCommit is zero, this loop runs exactly once and page pLastPg
@@ -3095,12 +3114,15 @@
     Pgno nFin = finalDbSize(pBt, nOrig, nFree);
 
     if( nOrig<nFin ){
       rc = SQLITE_CORRUPT_BKPT;
     }else if( nFree>0 ){
-      invalidateAllOverflowCache(pBt);
-      rc = incrVacuumStep(pBt, nFin, nOrig, 0);
+      rc = saveAllCursors(pBt, 0, 0);
+      if( rc==SQLITE_OK ){
+        invalidateAllOverflowCache(pBt);
+        rc = incrVacuumStep(pBt, nFin, nOrig, 0);
+      }
       if( rc==SQLITE_OK ){
         rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
         put4byte(&pBt->pPage1->aData[28], pBt->nPage);
       }
     }else{
@@ -3144,11 +3166,13 @@
     }
 
     nFree = get4byte(&pBt->pPage1->aData[36]);
     nFin = finalDbSize(pBt, nOrig, nFree);
     if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT;
-
+    if( nFin<nOrig ){
+      rc = saveAllCursors(pBt, 0, 0);
+    }
     for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
       rc = incrVacuumStep(pBt, nFin, iFree, 1);
     }
     if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
       rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
@@ -3161,11 +3185,11 @@
     if( rc!=SQLITE_OK ){
       sqlite3PagerRollback(pPager);
     }
   }
 
-  assert( nRef==sqlite3PagerRefcount(pPager) );
+  assert( nRef>=sqlite3PagerRefcount(pPager) );
   return rc;
 }
 
 #else /* ifndef SQLITE_OMIT_AUTOVACUUM */
 # define setChildPtrmaps(x) SQLITE_OK
@@ -3417,11 +3441,11 @@
     }
 
     /* The rollback may have destroyed the pPage1->aData value.  So
     ** call btreeGetPage() on page 1 again to make
     ** sure pPage1->aData is set correctly. */
-    if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
+    if( btreeGetPage(pBt, 1, &pPage1, 0, 0)==SQLITE_OK ){
       int nPage = get4byte(28+(u8*)pPage1->aData);
       testcase( nPage==0 );
       if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
       testcase( pBt->nPage!=nPage );
       pBt->nPage = nPage;
@@ -3851,11 +3875,11 @@
   }
 #endif
 
   assert( next==0 || rc==SQLITE_DONE );
   if( rc==SQLITE_OK ){
-    rc = btreeGetPage(pBt, ovfl, &pPage, 0);
+    rc = btreeGetPage(pBt, ovfl, &pPage, 0, (ppPage==0));
     assert( rc==SQLITE_OK || pPage==0 );
     if( rc==SQLITE_OK ){
       next = get4byte(pPage->aData);
     }
   }
@@ -4072,11 +4096,13 @@
         }else
 #endif
 
         {
           DbPage *pDbPage;
-          rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
+          rc = sqlite3PagerAcquire(pBt->pPager, nextPage, &pDbPage,
+              (eOp==0 ? PAGER_ACQUIRE_READONLY : 0)
+          );
           if( rc==SQLITE_OK ){
             aPayload = sqlite3PagerGetData(pDbPage);
             nextPage = get4byte(aPayload);
             rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
             sqlite3PagerUnref(pDbPage);
@@ -4251,14 +4277,15 @@
   BtShared *pBt = pCur->pBt;
 
   assert( cursorHoldsMutex(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
+  assert( pCur->iPage>=0 );
   if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
     return SQLITE_CORRUPT_BKPT;
   }
-  rc = getAndInitPage(pBt, newPgno, &pNewPage);
+  rc = getAndInitPage(pBt, newPgno, &pNewPage, (pCur->wrFlag==0));
   if( rc ) return rc;
   pCur->apPage[i+1] = pNewPage;
   pCur->aiIdx[i+1] = 0;
   pCur->iPage++;
 
@@ -4371,11 +4398,11 @@
     pCur->iPage = 0;
   }else if( pCur->pgnoRoot==0 ){
     pCur->eState = CURSOR_INVALID;
     return SQLITE_OK;
   }else{
-    rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
+    rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0], pCur->wrFlag==0);
     if( rc!=SQLITE_OK ){
       pCur->eState = CURSOR_INVALID;
       return rc;
     }
     pCur->iPage = 0;
@@ -4985,11 +5012,11 @@
       }
       testcase( iTrunk==mxPage );
       if( iTrunk>mxPage ){
         rc = SQLITE_CORRUPT_BKPT;
       }else{
-        rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
+        rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0, 0);
       }
       if( rc ){
         pTrunk = 0;
         goto end_allocate_page;
       }
@@ -5049,11 +5076,11 @@
           if( iNewTrunk>mxPage ){ 
             rc = SQLITE_CORRUPT_BKPT;
             goto end_allocate_page;
           }
           testcase( iNewTrunk==mxPage );
-          rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
+          rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0, 0);
           if( rc!=SQLITE_OK ){
             goto end_allocate_page;
           }
           rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
           if( rc!=SQLITE_OK ){
@@ -5129,11 +5156,11 @@
           if( closest<k-1 ){
             memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
           }
           put4byte(&aData[4], k-1);
           noContent = !btreeGetHasContent(pBt, *pPgno);
-          rc = btreeGetPage(pBt, *pPgno, ppPage, noContent);
+          rc = btreeGetPage(pBt, *pPgno, ppPage, noContent, 0);
           if( rc==SQLITE_OK ){
             rc = sqlite3PagerWrite((*ppPage)->pDbPage);
             if( rc!=SQLITE_OK ){
               releasePage(*ppPage);
             }
@@ -5177,11 +5204,11 @@
       ** becomes a new pointer-map page, the second is used by the caller.
       */
       MemPage *pPg = 0;
       TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
       assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
-      rc = btreeGetPage(pBt, pBt->nPage, &pPg, bNoContent);
+      rc = btreeGetPage(pBt, pBt->nPage, &pPg, bNoContent, 0);
       if( rc==SQLITE_OK ){
         rc = sqlite3PagerWrite(pPg->pDbPage);
         releasePage(pPg);
       }
       if( rc ) return rc;
@@ -5191,11 +5218,11 @@
 #endif
     put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
     *pPgno = pBt->nPage;
 
     assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
-    rc = btreeGetPage(pBt, *pPgno, ppPage, bNoContent);
+    rc = btreeGetPage(pBt, *pPgno, ppPage, bNoContent, 0);
     if( rc ) return rc;
     rc = sqlite3PagerWrite((*ppPage)->pDbPage);
     if( rc!=SQLITE_OK ){
       releasePage(*ppPage);
     }
@@ -5259,11 +5286,11 @@
 
   if( pBt->btsFlags & BTS_SECURE_DELETE ){
     /* If the secure_delete option is enabled, then
     ** always fully overwrite deleted information with zeros.
     */
-    if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
+    if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0, 0))!=0) )
      ||            ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0)
     ){
       goto freepage_out;
     }
     memset(pPage->aData, 0, pPage->pBt->pageSize);
@@ -5286,11 +5313,11 @@
   */
   if( nFree!=0 ){
     u32 nLeaf;                /* Initial number of leaf cells on trunk page */
 
     iTrunk = get4byte(&pPage1->aData[32]);
-    rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
+    rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0, 0);
     if( rc!=SQLITE_OK ){
       goto freepage_out;
     }
 
     nLeaf = get4byte(&pTrunk->aData[4]);
@@ -5332,11 +5359,11 @@
   ** the page being freed as a leaf page of the first trunk in the free-list.
   ** Possibly because the free-list is empty, or possibly because the 
   ** first trunk in the free-list is full. Either way, the page being freed
   ** will become the new first trunk page in the free-list.
   */
-  if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
+  if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0, 0)) ){
     goto freepage_out;
   }
   rc = sqlite3PagerWrite(pPage->pDbPage);
   if( rc!=SQLITE_OK ){
     goto freepage_out;
@@ -6133,11 +6160,11 @@
   }else{
     pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
   }
   pgno = get4byte(pRight);
   while( 1 ){
-    rc = getAndInitPage(pBt, pgno, &apOld[i]);
+    rc = getAndInitPage(pBt, pgno, &apOld[i], 0);
     if( rc ){
       memset(apOld, 0, (i+1)*sizeof(MemPage*));
       goto balance_cleanup;
     }
     nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
@@ -7221,14 +7248,21 @@
       ** is already journaled.
       */
       u8 eType = 0;
       Pgno iPtrPage = 0;
 
+      /* Save the positions of any open cursors. This is required in
+      ** case they are holding a reference to an xFetch reference
+      ** corresponding to page pgnoRoot.  */
+      rc = saveAllCursors(pBt, 0, 0);
       releasePage(pPageMove);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
 
       /* Move the page currently at pgnoRoot to pgnoMove. */
-      rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
+      rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0, 0);
       if( rc!=SQLITE_OK ){
         return rc;
       }
       rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
       if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
@@ -7245,11 +7279,11 @@
 
       /* Obtain the page at pgnoRoot */
       if( rc!=SQLITE_OK ){
         return rc;
       }
-      rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
+      rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0, 0);
       if( rc!=SQLITE_OK ){
         return rc;
       }
       rc = sqlite3PagerWrite(pRoot->pDbPage);
       if( rc!=SQLITE_OK ){
@@ -7321,11 +7355,11 @@
   assert( sqlite3_mutex_held(pBt->mutex) );
   if( pgno>btreePagecount(pBt) ){
     return SQLITE_CORRUPT_BKPT;
   }
 
-  rc = getAndInitPage(pBt, pgno, &pPage);
+  rc = getAndInitPage(pBt, pgno, &pPage, 0);
   if( rc ) return rc;
   for(i=0; i<pPage->nCell; i++){
     pCell = findCell(pPage, i);
     if( !pPage->leaf ){
       rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
@@ -7423,11 +7457,11 @@
   if( NEVER(pBt->pCursor) ){
     sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
     return SQLITE_LOCKED_SHAREDCACHE;
   }
 
-  rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
+  rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0, 0);
   if( rc ) return rc;
   rc = sqlite3BtreeClearTable(p, iTable, 0);
   if( rc ){
     releasePage(pPage);
     return rc;
@@ -7458,21 +7492,21 @@
         ** number in the database. So move the page that does into the 
         ** gap left by the deleted root-page.
         */
         MemPage *pMove;
         releasePage(pPage);
-        rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
+        rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0, 0);
         if( rc!=SQLITE_OK ){
           return rc;
         }
         rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
         releasePage(pMove);
         if( rc!=SQLITE_OK ){
           return rc;
         }
         pMove = 0;
-        rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
+        rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0, 0);
         freePage(pMove, &rc);
         releasePage(pMove);
         if( rc!=SQLITE_OK ){
           return rc;
         }
@@ -7880,11 +7914,11 @@
   */
   pBt = pCheck->pBt;
   usableSize = pBt->usableSize;
   if( iPage==0 ) return 0;
   if( checkRef(pCheck, iPage, zParentContext) ) return 0;
-  if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
+  if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0, 0))!=0 ){
     checkAppendMsg(pCheck, zContext,
        "unable to get the page. error code=%d", rc);
     return 0;
   }
 
@@ -8351,10 +8385,21 @@
   }
   assert( pCsr->eState!=CURSOR_REQUIRESEEK );
   if( pCsr->eState!=CURSOR_VALID ){
     return SQLITE_ABORT;
   }
+
+  /* Save the positions of all other cursors open on this table. This is
+  ** required in case any of them are holding references to an xFetch
+  ** version of the b-tree page modified by the accessPayload call below.
+  **
+  ** Note that pCsr must be open on a BTREE_INTKEY table and saveCursorPosition()
+  ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence
+  ** saveAllCursors can only return SQLITE_OK.
+  */
+  VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
+  assert( rc==SQLITE_OK );
 
   /* Check some assumptions: 
   **   (a) the cursor is open for writing,
   **   (b) there is a read/write transaction open,
   **   (c) the connection holds a write-lock on the table (if required),

Index: src/btree.h
==================================================================
--- src/btree.h
+++ src/btree.h
@@ -61,10 +61,11 @@
 #define BTREE_SINGLE        4  /* The file contains at most 1 b-tree */
 #define BTREE_UNORDERED     8  /* Use of a hash implementation is OK */
 
 int sqlite3BtreeClose(Btree*);
 int sqlite3BtreeSetCacheSize(Btree*,int);
+int sqlite3BtreeSetMmapLimit(Btree*,sqlite3_int64);
 int sqlite3BtreeSetSafetyLevel(Btree*,int,int,int);
 int sqlite3BtreeSyncDisabled(Btree*);
 int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix);
 int sqlite3BtreeGetPageSize(Btree*);
 int sqlite3BtreeMaxPageCount(Btree*,int);

Index: src/ctime.c
==================================================================
--- src/ctime.c
+++ src/ctime.c
@@ -46,18 +46,18 @@
   "CHECK_PAGES",
 #endif
 #ifdef SQLITE_COVERAGE_TEST
   "COVERAGE_TEST",
 #endif
-#ifdef SQLITE_CURDIR
-  "CURDIR",
-#endif
 #ifdef SQLITE_DEBUG
   "DEBUG",
 #endif
 #ifdef SQLITE_DEFAULT_LOCKING_MODE
   "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
+#endif
+#if defined(SQLITE_DEFAULT_MMAP_SIZE) && !defined(SQLITE_DEFAULT_MMAP_SIZE_xc)
+  "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
 #endif
 #ifdef SQLITE_DISABLE_DIRSYNC
   "DISABLE_DIRSYNC",
 #endif
 #ifdef SQLITE_DISABLE_LFS
@@ -145,10 +145,13 @@
   "INT64_TYPE",
 #endif
 #ifdef SQLITE_LOCK_TRACE
   "LOCK_TRACE",
 #endif
+#if defined(SQLITE_MAX_MMAP_SIZE) && !defined(SQLITE_MAX_MMAP_SIZE_xc)
+  "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),
+#endif
 #ifdef SQLITE_MAX_SCHEMA_RETRY
   "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
 #endif
 #ifdef SQLITE_MEMDEBUG
   "MEMDEBUG",
@@ -202,15 +205,10 @@
   "OMIT_CAST",
 #endif
 #ifdef SQLITE_OMIT_CHECK
   "OMIT_CHECK",
 #endif
-/* // redundant
-** #ifdef SQLITE_OMIT_COMPILEOPTION_DIAGS
-**   "OMIT_COMPILEOPTION_DIAGS",
-** #endif
-*/
 #ifdef SQLITE_OMIT_COMPLETE
   "OMIT_COMPLETE",
 #endif
 #ifdef SQLITE_OMIT_COMPOUND_SELECT
   "OMIT_COMPOUND_SELECT",
@@ -348,17 +346,17 @@
   "SOUNDEX",
 #endif
 #ifdef SQLITE_TCL
   "TCL",
 #endif
-#ifdef SQLITE_TEMP_STORE
+#if defined(SQLITE_TEMP_STORE) && !defined(SQLITE_TEMP_STORE_xc)
   "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
 #endif
 #ifdef SQLITE_TEST
   "TEST",
 #endif
-#ifdef SQLITE_THREADSAFE
+#if defined(SQLITE_THREADSAFE)
   "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
 #endif
 #ifdef SQLITE_USE_ALLOCA
   "USE_ALLOCA",
 #endif
@@ -380,12 +378,15 @@
   n = sqlite3Strlen30(zOptName);
 
   /* Since ArraySize(azCompileOpt) is normally in single digits, a
   ** linear search is adequate.  No need for a binary search. */
   for(i=0; i<ArraySize(azCompileOpt); i++){
-    if(   (sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0)
-       && ( (azCompileOpt[i][n]==0) || (azCompileOpt[i][n]=='=') ) ) return 1;
+    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
+     && sqlite3CtypeMap[(unsigned char)azCompileOpt[i][n]]==0
+    ){
+      return 1;
+    }
   }
   return 0;
 }
 
 /*

Index: src/func.c
==================================================================
--- src/func.c
+++ src/func.c
@@ -690,10 +690,17 @@
       prevEscape = 0;
     }
   }
   return *zString==0;
 }
+
+/*
+** The sqlite3_strglob() interface.
+*/
+int sqlite3_strglob(const char *zGlobPattern, const char *zString){
+  return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0;
+}
 
 /*
 ** Count the number of times that the LIKE operator (or GLOB which is
 ** just a variation of LIKE) gets called.  This is used for testing
 ** only.

Index: src/global.c
==================================================================
--- src/global.c
+++ src/global.c
@@ -154,10 +154,12 @@
    {0,0,0,0,0,0,0,0,0},       /* mutex */
    {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
    (void*)0,                  /* pHeap */
    0,                         /* nHeap */
    0, 0,                      /* mnHeap, mxHeap */
+   SQLITE_DEFAULT_MMAP_SIZE,  /* szMmap */
+   SQLITE_MAX_MMAP_SIZE,      /* mxMmap */
    (void*)0,                  /* pScratch */
    0,                         /* szScratch */
    0,                         /* nScratch */
    (void*)0,                  /* pPage */
    0,                         /* szPage */

Index: src/legacy.c
==================================================================
--- src/legacy.c
+++ src/legacy.c
@@ -36,24 +36,23 @@
 ){
   int rc = SQLITE_OK;         /* Return code */
   const char *zLeftover;      /* Tail of unprocessed SQL */
   sqlite3_stmt *pStmt = 0;    /* The current SQL statement */
   char **azCols = 0;          /* Names of result columns */
-  int nRetry = 0;             /* Number of retry attempts */
   int callbackIsInit;         /* True if callback data is initialized */
 
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
   if( zSql==0 ) zSql = "";
 
   sqlite3_mutex_enter(db->mutex);
   sqlite3Error(db, SQLITE_OK, 0);
-  while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){
+  while( rc==SQLITE_OK && zSql[0] ){
     int nCol;
     char **azVals = 0;
 
     pStmt = 0;
-    rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);
+    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
     assert( rc==SQLITE_OK || pStmt==0 );
     if( rc!=SQLITE_OK ){
       continue;
     }
     if( !pStmt ){
@@ -106,15 +105,12 @@
       }
 
       if( rc!=SQLITE_ROW ){
         rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
         pStmt = 0;
-        if( rc!=SQLITE_SCHEMA ){
-          nRetry = 0;
-          zSql = zLeftover;
-          while( sqlite3Isspace(zSql[0]) ) zSql++;
-        }
+        zSql = zLeftover;
+        while( sqlite3Isspace(zSql[0]) ) zSql++;
         break;
       }
     }
 
     sqlite3DbFree(db, azCols);

Index: src/loadext.c
==================================================================
--- src/loadext.c
+++ src/loadext.c
@@ -413,12 +413,27 @@
 ){
   sqlite3_vfs *pVfs = db->pVfs;
   void *handle;
   int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
   char *zErrmsg = 0;
+  const char *zEntry;
+  char *zAltEntry = 0;
   void **aHandle;
   int nMsg = 300 + sqlite3Strlen30(zFile);
+  int ii;
+
+  /* Shared library endings to try if zFile cannot be loaded as written */
+  static const char *azEndings[] = {
+#if SQLITE_OS_WIN
+     "dll"   
+#elif defined(__APPLE__)
+     "dylib"
+#else
+     "so"
+#endif
+  };
+
 
   if( pzErrMsg ) *pzErrMsg = 0;
 
   /* Ticket #1863.  To avoid a creating security problems for older
   ** applications that relink against newer versions of SQLite, the
@@ -431,15 +446,21 @@
       *pzErrMsg = sqlite3_mprintf("not authorized");
     }
     return SQLITE_ERROR;
   }
 
-  if( zProc==0 ){
-    zProc = "sqlite3_extension_init";
-  }
+  zEntry = zProc ? zProc : "sqlite3_extension_init";
 
   handle = sqlite3OsDlOpen(pVfs, zFile);
+#if SQLITE_OS_UNIX || SQLITE_OS_WIN
+  for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
+    char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);
+    if( zAltFile==0 ) return SQLITE_NOMEM;
+    handle = sqlite3OsDlOpen(pVfs, zAltFile);
+    sqlite3_free(zAltFile);
+  }
+#endif
   if( handle==0 ){
     if( pzErrMsg ){
       *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
       if( zErrmsg ){
         sqlite3_snprintf(nMsg, zErrmsg, 
@@ -448,24 +469,61 @@
       }
     }
     return SQLITE_ERROR;
   }
   xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
-                   sqlite3OsDlSym(pVfs, handle, zProc);
+                   sqlite3OsDlSym(pVfs, handle, zEntry);
+
+  /* If no entry point was specified and the default legacy
+  ** entry point name "sqlite3_extension_init" was not found, then
+  ** construct an entry point name "sqlite3_X_init" where the X is
+  ** replaced by the lowercase value of every ASCII alphabetic 
+  ** character in the filename after the last "/" upto the first ".",
+  ** and eliding the first three characters if they are "lib".  
+  ** Examples:
+  **
+  **    /usr/local/lib/libExample5.4.3.so ==>  sqlite3_example_init
+  **    C:/lib/mathfuncs.dll              ==>  sqlite3_mathfuncs_init
+  */
+  if( xInit==0 && zProc==0 ){
+    int iFile, iEntry, c;
+    int ncFile = sqlite3Strlen30(zFile);
+    zAltEntry = sqlite3_malloc(ncFile+30);
+    if( zAltEntry==0 ){
+      sqlite3OsDlClose(pVfs, handle);
+      return SQLITE_NOMEM;
+    }
+    memcpy(zAltEntry, "sqlite3_", 8);
+    for(iFile=ncFile-1; iFile>=0 && zFile[iFile]!='/'; iFile--){}
+    iFile++;
+    if( sqlite3_strnicmp(zFile+iFile, "lib", 3)==0 ) iFile += 3;
+    for(iEntry=8; (c = zFile[iFile])!=0 && c!='.'; iFile++){
+      if( sqlite3Isalpha(c) ){
+        zAltEntry[iEntry++] = (char)sqlite3UpperToLower[(unsigned)c];
+      }
+    }
+    memcpy(zAltEntry+iEntry, "_init", 6);
+    zEntry = zAltEntry;
+    xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
+                     sqlite3OsDlSym(pVfs, handle, zEntry);
+  }
   if( xInit==0 ){
     if( pzErrMsg ){
-      nMsg += sqlite3Strlen30(zProc);
+      nMsg += sqlite3Strlen30(zEntry);
       *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
       if( zErrmsg ){
         sqlite3_snprintf(nMsg, zErrmsg,
-            "no entry point [%s] in shared library [%s]", zProc,zFile);
+            "no entry point [%s] in shared library [%s]", zEntry, zFile);
         sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
       }
-      sqlite3OsDlClose(pVfs, handle);
     }
+    sqlite3OsDlClose(pVfs, handle);
+    sqlite3_free(zAltEntry);
     return SQLITE_ERROR;
-  }else if( xInit(db, &zErrmsg, &sqlite3Apis) ){
+  }
+  sqlite3_free(zAltEntry);
+  if( xInit(db, &zErrmsg, &sqlite3Apis) ){
     if( pzErrMsg ){
       *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
     }
     sqlite3_free(zErrmsg);
     sqlite3OsDlClose(pVfs, handle);

Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -493,10 +493,23 @@
       sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
       sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
       break;
     }
 #endif
+
+    case SQLITE_CONFIG_MMAP_SIZE: {
+      sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
+      sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
+      if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
+        mxMmap = SQLITE_MAX_MMAP_SIZE;
+      }
+      sqlite3GlobalConfig.mxMmap = mxMmap;
+      if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
+      if( szMmap>mxMmap) szMmap = mxMmap;
+      sqlite3GlobalConfig.szMmap = szMmap;
+      break;
+    }
 
     default: {
       rc = SQLITE_ERROR;
       break;
     }
@@ -2335,10 +2348,11 @@
 
   assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
   memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
   db->autoCommit = 1;
   db->nextAutovac = -1;
+  db->szMmap = sqlite3GlobalConfig.szMmap;
   db->nextPagesize = 0;
   db->flags |= SQLITE_ShortColNames | SQLITE_AutoIndex | SQLITE_EnableTrigger
 #if SQLITE_DEFAULT_FILE_FORMAT<4
                  | SQLITE_LegacyFileFmt
 #endif

Index: src/memjournal.c
==================================================================
--- src/memjournal.c
+++ src/memjournal.c
@@ -228,11 +228,13 @@
   0,                /* xSectorSize */
   0,                /* xDeviceCharacteristics */
   0,                /* xShmMap */
   0,                /* xShmLock */
   0,                /* xShmBarrier */
-  0                 /* xShmUnlock */
+  0,                /* xShmUnmap */
+  0,                /* xFetch */
+  0                 /* xUnfetch */
 };
 
 /* 
 ** Open a journal file.
 */

Index: src/os.c
==================================================================
--- src/os.c
+++ src/os.c
@@ -138,10 +138,30 @@
   void volatile **pp              /* OUT: Pointer to mapping */
 ){
   DO_OS_MALLOC_TEST(id);
   return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
 }
+
+#if SQLITE_MAX_MMAP_SIZE>0
+/* The real implementation of xFetch and xUnfetch */
+int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){
+  DO_OS_MALLOC_TEST(id);
+  return id->pMethods->xFetch(id, iOff, iAmt, pp);
+}
+int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){
+  return id->pMethods->xUnfetch(id, iOff, p);
+}
+#else
+/* No-op stubs to use when memory-mapped I/O is disabled */
+int sqlite3OsFetch(sqlite3_file *id, i64 iOff, int iAmt, void **pp){
+  *pp = 0;
+  return SQLITE_OK;
+}
+int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){
+  return SQLITE_OK;
+}
+#endif
 
 /*
 ** The next group of routines are convenience wrappers around the
 ** VFS methods.
 */

Index: src/os.h
==================================================================
--- src/os.h
+++ src/os.h
@@ -97,18 +97,10 @@
 */
 #if !defined(SQLITE_OS_WINRT)
 # define SQLITE_OS_WINRT 0
 #endif
 
-/*
-** When compiled for WinCE or WinRT, there is no concept of the current
-** directory.
- */
-#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
-# define SQLITE_CURDIR 1
-#endif
-
 /* If the SET_FULLSYNC macro is not defined above, then make it
 ** a no-op
 */
 #ifndef SET_FULLSYNC
 # define SET_FULLSYNC(x,y)
@@ -257,10 +249,12 @@
 int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
 int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **);
 int sqlite3OsShmLock(sqlite3_file *id, int, int, int);
 void sqlite3OsShmBarrier(sqlite3_file *id);
 int sqlite3OsShmUnmap(sqlite3_file *id, int);
+int sqlite3OsFetch(sqlite3_file *id, i64, int, void **);
+int sqlite3OsUnfetch(sqlite3_file *, i64, void *);
 
 
 /* 
 ** Functions for accessing sqlite3_vfs methods 
 */

Index: src/os_unix.c
==================================================================
--- src/os_unix.c
+++ src/os_unix.c
@@ -223,10 +223,15 @@
   void *lockingContext;               /* Locking style specific state */
   UnixUnusedFd *pUnused;              /* Pre-allocated UnixUnusedFd */
   const char *zPath;                  /* Name of the file */
   unixShm *pShm;                      /* Shared memory segment information */
   int szChunk;                        /* Configured by FCNTL_CHUNK_SIZE */
+  int nFetchOut;                      /* Number of outstanding xFetch refs */
+  sqlite3_int64 mmapSize;             /* Usable size of mapping at pMapRegion */
+  sqlite3_int64 mmapSizeActual;       /* Actual size of mapping at pMapRegion */
+  sqlite3_int64 mmapSizeMax;          /* Configured FCNTL_MMAP_SIZE value */
+  void *pMapRegion;                   /* Memory mapped region */
 #ifdef __QNXNTO__
   int sectorSize;                     /* Device sector size */
   int deviceCharacteristics;          /* Precomputed device characteristics */
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE
@@ -247,11 +252,13 @@
   ** one described by ticket #3584. 
   */
   unsigned char transCntrChng;   /* True if the transaction counter changed */
   unsigned char dbUpdate;        /* True if any part of database file changed */
   unsigned char inNormalWrite;   /* True if in a normal write operation */
+
 #endif
+
 #ifdef SQLITE_TEST
   /* In test mode, increase the size of this structure a bit so that 
   ** it is larger than the struct CrashFile defined in test6.c.
   */
   char aPadding[32];
@@ -271,10 +278,11 @@
 #endif
 #define UNIXFILE_PSOW        0x10     /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
 #define UNIXFILE_DELETE      0x20     /* Delete on close */
 #define UNIXFILE_URI         0x40     /* Filename might have query parameters */
 #define UNIXFILE_NOLOCK      0x80     /* Do no file locking */
+#define UNIXFILE_WARNED    0x0100     /* verifyDbFile() warnings have been issued */
 
 /*
 ** Include code that is common to all os_*.c files
 */
 #include "os_common.h"
@@ -304,10 +312,21 @@
 #define threadid pthread_self()
 #else
 #define threadid 0
 #endif
 
+/*
+** HAVE_MREMAP defaults to true on Linux and false everywhere else.
+*/
+#if !defined(HAVE_MREMAP)
+# if defined(__linux__) && defined(_GNU_SOURCE)
+#  define HAVE_MREMAP 1
+# else
+#  define HAVE_MREMAP 0
+# endif
+#endif
+
 /*
 ** Different Unix systems declare open() in different ways.  Same use
 ** open(const char*,int,mode_t).  Others use open(const char*,int,...).
 ** The difference is important when using a pointer to the function.
 **
@@ -435,10 +454,23 @@
 #define osRmdir     ((int(*)(const char*))aSyscall[19].pCurrent)
 
   { "fchown",       (sqlite3_syscall_ptr)posixFchown,     0 },
 #define osFchown    ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)
 
+  { "mmap",       (sqlite3_syscall_ptr)mmap,     0 },
+#define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[21].pCurrent)
+
+  { "munmap",       (sqlite3_syscall_ptr)munmap,          0 },
+#define osMunmap ((void*(*)(void*,size_t))aSyscall[22].pCurrent)
+
+#if HAVE_MREMAP
+  { "mremap",       (sqlite3_syscall_ptr)mremap,          0 },
+#else
+  { "mremap",       (sqlite3_syscall_ptr)0,               0 },
+#endif
+#define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[23].pCurrent)
+
 }; /* End of the overrideable system calls */
 
 /*
 ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
 ** "unix" VFSes.  Return SQLITE_OK opon successfully updating the
@@ -764,11 +796,10 @@
     
   default: 
     return sqliteIOErr;
   }
 }
-
 
 
 /******************************************************************************
 ****************** Begin Unique File ID Utility Used By VxWorks ***************
 **
@@ -1102,11 +1133,10 @@
 #else
   /* Non-threadsafe build, use strerror(). */
   zErr = strerror(iErrno);
 #endif
 
-  assert( errcode!=SQLITE_OK );
   if( zPath==0 ) zPath = "";
   sqlite3_log(errcode,
       "os_unix.c:%d: (%d) %s(%s) - %s",
       iLine, iErrno, zFunc, zPath, zErr
   );
@@ -1267,10 +1297,54 @@
   }
   *ppInode = pInode;
   return SQLITE_OK;
 }
 
+
+/*
+** Check a unixFile that is a database.  Verify the following:
+**
+** (1) There is exactly one hard link on the file
+** (2) The file is not a symbolic link
+** (3) The file has not been renamed or unlinked
+**
+** Issue sqlite3_log(SQLITE_WARNING,...) messages if anything is not right.
+*/
+static void verifyDbFile(unixFile *pFile){
+  struct stat buf;
+  int rc;
+  if( pFile->ctrlFlags & UNIXFILE_WARNED ){
+    /* One or more of the following warnings have already been issued.  Do not
+    ** repeat them so as not to clutter the error log */
+    return;
+  }
+  rc = osFstat(pFile->h, &buf);
+  if( rc!=0 ){
+    sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
+    pFile->ctrlFlags |= UNIXFILE_WARNED;
+    return;
+  }
+  if( buf.st_nlink==0 && (pFile->ctrlFlags & UNIXFILE_DELETE)==0 ){
+    sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
+    pFile->ctrlFlags |= UNIXFILE_WARNED;
+    return;
+  }
+  if( buf.st_nlink>1 ){
+    sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
+    pFile->ctrlFlags |= UNIXFILE_WARNED;
+    return;
+  }
+  if( pFile->pInode!=0
+   && ((rc = osStat(pFile->zPath, &buf))!=0
+       || buf.st_ino!=pFile->pInode->fileId.ino)
+  ){
+    sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
+    pFile->ctrlFlags |= UNIXFILE_WARNED;
+    return;
+  }
+}
+
 
 /*
 ** This routine checks if there is a RESERVED lock held on the specified
 ** file by this or any other process. If such a lock is held, set *pResOut
 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
@@ -1798,12 +1872,16 @@
 **
 ** If the locking level of the file descriptor is already at or below
 ** the requested locking level, this routine is a no-op.
 */
 static int unixUnlock(sqlite3_file *id, int eFileLock){
+  assert( eFileLock==SHARED_LOCK || ((unixFile *)id)->nFetchOut==0 );
   return posixUnlock(id, eFileLock, 0);
 }
+
+static int unixMapfile(unixFile *pFd, i64 nByte);
+static void unixUnmapfile(unixFile *pFd);
 
 /*
 ** This function performs the parts of the "close file" operation 
 ** common to all locking schemes. It closes the directory and file
 ** handles, if they are valid, and sets all fields of the unixFile
@@ -1813,10 +1891,11 @@
 ** even on VxWorks.  A mutex will be acquired on VxWorks by the
 ** vxworksReleaseFileId() routine.
 */
 static int closeUnixFile(sqlite3_file *id){
   unixFile *pFile = (unixFile*)id;
+  unixUnmapfile(pFile);
   if( pFile->h>=0 ){
     robust_close(pFile, pFile->h, __LINE__);
     pFile->h = -1;
   }
 #if OS_VXWORKS
@@ -1839,10 +1918,11 @@
 ** Close a file.
 */
 static int unixClose(sqlite3_file *id){
   int rc = SQLITE_OK;
   unixFile *pFile = (unixFile *)id;
+  verifyDbFile(pFile);
   unixUnlock(id, NO_LOCK);
   unixEnterMutex();
 
   /* unixFile.pInode is always valid here. Otherwise, a different close
   ** routine (e.g. nolockClose()) would be called instead.
@@ -3079,10 +3159,27 @@
   assert( pFile->pUnused==0
        || offset>=PENDING_BYTE+512
        || offset+amt<=PENDING_BYTE 
   );
 #endif
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  /* Deal with as much of this read request as possible by transfering
+  ** data from the memory mapping using memcpy().  */
+  if( offset<pFile->mmapSize ){
+    if( offset+amt <= pFile->mmapSize ){
+      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
+      return SQLITE_OK;
+    }else{
+      int nCopy = pFile->mmapSize - offset;
+      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
+      pBuf = &((u8 *)pBuf)[nCopy];
+      amt -= nCopy;
+      offset += nCopy;
+    }
+  }
+#endif
 
   got = seekAndRead(pFile, offset, pBuf, amt);
   if( got==amt ){
     return SQLITE_OK;
   }else if( got<0 ){
@@ -3181,10 +3278,27 @@
       SimulateIOErrorBenign(0);
       if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
         pFile->transCntrChng = 1;  /* The transaction counter has changed */
       }
     }
+  }
+#endif
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  /* Deal with as much of this write request as possible by transfering
+  ** data from the memory mapping using memcpy().  */
+  if( offset<pFile->mmapSize ){
+    if( offset+amt <= pFile->mmapSize ){
+      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
+      return SQLITE_OK;
+    }else{
+      int nCopy = pFile->mmapSize - offset;
+      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
+      pBuf = &((u8 *)pBuf)[nCopy];
+      amt -= nCopy;
+      offset += nCopy;
+    }
   }
 #endif
 
   while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
     amt -= wrote;
@@ -3465,10 +3579,18 @@
     */
     if( pFile->inNormalWrite && nByte==0 ){
       pFile->transCntrChng = 1;
     }
 #endif
+
+    /* If the file was just truncated to a size smaller than the currently
+    ** mapped region, reduce the effective mapping size as well. SQLite will
+    ** use read() and write() to access data beyond this point from now on.  
+    */
+    if( nByte<pFile->mmapSize ){
+      pFile->mmapSize = nByte;
+    }
 
     return SQLITE_OK;
   }
 }
 
@@ -3553,10 +3675,23 @@
         iWrite += nBlk;
       }
 #endif
     }
   }
+
+  if( pFile->mmapSizeMax>0 && nByte>pFile->mmapSize ){
+    int rc;
+    if( pFile->szChunk<=0 ){
+      if( robust_ftruncate(pFile->h, nByte) ){
+        pFile->lastErrno = errno;
+        return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
+      }
+    }
+
+    rc = unixMapfile(pFile, nByte);
+    return rc;
+  }
 
   return SQLITE_OK;
 }
 
 /*
@@ -3620,10 +3755,22 @@
       if( zTFile ){
         unixGetTempname(pFile->pVfs->mxPathname, zTFile);
         *(char**)pArg = zTFile;
       }
       return SQLITE_OK;
+    }
+    case SQLITE_FCNTL_MMAP_SIZE: {
+      i64 newLimit = *(i64*)pArg;
+      if( newLimit>sqlite3GlobalConfig.mxMmap ){
+        newLimit = sqlite3GlobalConfig.mxMmap;
+      }
+      *(i64*)pArg = pFile->mmapSizeMax;
+      if( newLimit>=0 ){
+        pFile->mmapSizeMax = newLimit;
+        if( newLimit<pFile->mmapSize ) pFile->mmapSize = newLimit;
+      }
+      return SQLITE_OK;
     }
 #ifdef SQLITE_DEBUG
     /* The pager calls this method to signal that it has done
     ** a rollback and that the database is therefore unchanged and
     ** it hence it is OK for the transaction change counter to be
@@ -3933,11 +4080,11 @@
     int i;
     assert( p->pInode==pFd->pInode );
     sqlite3_mutex_free(p->mutex);
     for(i=0; i<p->nRegion; i++){
       if( p->h>=0 ){
-        munmap(p->apRegion[i], p->szRegion);
+        osMunmap(p->apRegion[i], p->szRegion);
       }else{
         sqlite3_free(p->apRegion[i]);
       }
     }
     sqlite3_free(p->apRegion);
@@ -4206,11 +4353,11 @@
     }
     pShmNode->apRegion = apNew;
     while(pShmNode->nRegion<=iRegion){
       void *pMem;
       if( pShmNode->h>=0 ){
-        pMem = mmap(0, szRegion,
+        pMem = osMmap(0, szRegion,
             pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE, 
             MAP_SHARED, pShmNode->h, szRegion*(i64)pShmNode->nRegion
         );
         if( pMem==MAP_FAILED ){
           rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
@@ -4422,10 +4569,240 @@
 # define unixShmMap     0
 # define unixShmLock    0
 # define unixShmBarrier 0
 # define unixShmUnmap   0
 #endif /* #ifndef SQLITE_OMIT_WAL */
+
+/*
+** If it is currently memory mapped, unmap file pFd.
+*/
+static void unixUnmapfile(unixFile *pFd){
+  assert( pFd->nFetchOut==0 );
+#if SQLITE_MAX_MMAP_SIZE>0
+  if( pFd->pMapRegion ){
+    osMunmap(pFd->pMapRegion, pFd->mmapSizeActual);
+    pFd->pMapRegion = 0;
+    pFd->mmapSize = 0;
+    pFd->mmapSizeActual = 0;
+  }
+#endif
+}
+
+#if SQLITE_MAX_MMAP_SIZE>0
+/*
+** Return the system page size.
+*/
+static int unixGetPagesize(void){
+#if HAVE_MREMAP
+  return 512;
+#elif defined(_BSD_SOURCE)
+  return getpagesize();
+#else
+  return (int)sysconf(_SC_PAGESIZE);
+#endif
+}
+#endif /* SQLITE_MAX_MMAP_SIZE>0 */
+
+#if SQLITE_MAX_MMAP_SIZE>0
+/*
+** Attempt to set the size of the memory mapping maintained by file 
+** descriptor pFd to nNew bytes. Any existing mapping is discarded.
+**
+** If successful, this function sets the following variables:
+**
+**       unixFile.pMapRegion
+**       unixFile.mmapSize
+**       unixFile.mmapSizeActual
+**
+** If unsuccessful, an error message is logged via sqlite3_log() and
+** the three variables above are zeroed. In this case SQLite should
+** continue accessing the database using the xRead() and xWrite()
+** methods.
+*/
+static void unixRemapfile(
+  unixFile *pFd,                  /* File descriptor object */
+  i64 nNew                        /* Required mapping size */
+){
+  const char *zErr = "mmap";
+  int h = pFd->h;                      /* File descriptor open on db file */
+  u8 *pOrig = (u8 *)pFd->pMapRegion;   /* Pointer to current file mapping */
+  i64 nOrig = pFd->mmapSizeActual;     /* Size of pOrig region in bytes */
+  u8 *pNew = 0;                        /* Location of new mapping */
+  int flags = PROT_READ;               /* Flags to pass to mmap() */
+
+  assert( pFd->nFetchOut==0 );
+  assert( nNew>pFd->mmapSize );
+  assert( nNew<=pFd->mmapSizeMax );
+  assert( nNew>0 );
+  assert( pFd->mmapSizeActual>=pFd->mmapSize );
+  assert( MAP_FAILED!=0 );
+
+  if( (pFd->ctrlFlags & UNIXFILE_RDONLY)==0 ) flags |= PROT_WRITE;
+
+  if( pOrig ){
+    const int szSyspage = unixGetPagesize();
+    i64 nReuse = (pFd->mmapSize & ~(szSyspage-1));
+    u8 *pReq = &pOrig[nReuse];
+
+    /* Unmap any pages of the existing mapping that cannot be reused. */
+    if( nReuse!=nOrig ){
+      osMunmap(pReq, nOrig-nReuse);
+    }
+
+#if HAVE_MREMAP
+    pNew = osMremap(pOrig, nReuse, nNew, MREMAP_MAYMOVE);
+    zErr = "mremap";
+#else
+    pNew = osMmap(pReq, nNew-nReuse, flags, MAP_SHARED, h, nReuse);
+    if( pNew!=MAP_FAILED ){
+      if( pNew!=pReq ){
+        osMunmap(pNew, nNew - nReuse);
+        pNew = 0;
+      }else{
+        pNew = pOrig;
+      }
+    }
+#endif
+
+    /* The attempt to extend the existing mapping failed. Free it. */
+    if( pNew==MAP_FAILED || pNew==0 ){
+      osMunmap(pOrig, nReuse);
+    }
+  }
+
+  /* If pNew is still NULL, try to create an entirely new mapping. */
+  if( pNew==0 ){
+    pNew = osMmap(0, nNew, flags, MAP_SHARED, h, 0);
+  }
+
+  if( pNew==MAP_FAILED ){
+    pNew = 0;
+    nNew = 0;
+    unixLogError(SQLITE_OK, zErr, pFd->zPath);
+
+    /* If the mmap() above failed, assume that all subsequent mmap() calls
+    ** will probably fail too. Fall back to using xRead/xWrite exclusively
+    ** in this case.  */
+    pFd->mmapSizeMax = 0;
+  }
+  pFd->pMapRegion = (void *)pNew;
+  pFd->mmapSize = pFd->mmapSizeActual = nNew;
+}
+#endif
+
+/*
+** Memory map or remap the file opened by file-descriptor pFd (if the file
+** is already mapped, the existing mapping is replaced by the new). Or, if 
+** there already exists a mapping for this file, and there are still 
+** outstanding xFetch() references to it, this function is a no-op.
+**
+** If parameter nByte is non-negative, then it is the requested size of 
+** the mapping to create. Otherwise, if nByte is less than zero, then the 
+** requested size is the size of the file on disk. The actual size of the
+** created mapping is either the requested size or the value configured 
+** using SQLITE_FCNTL_MMAP_LIMIT, whichever is smaller.
+**
+** SQLITE_OK is returned if no error occurs (even if the mapping is not
+** recreated as a result of outstanding references) or an SQLite error
+** code otherwise.
+*/
+static int unixMapfile(unixFile *pFd, i64 nByte){
+#if SQLITE_MAX_MMAP_SIZE>0
+  i64 nMap = nByte;
+  int rc;
+
+  assert( nMap>=0 || pFd->nFetchOut==0 );
+  if( pFd->nFetchOut>0 ) return SQLITE_OK;
+
+  if( nMap<0 ){
+    struct stat statbuf;          /* Low-level file information */
+    rc = osFstat(pFd->h, &statbuf);
+    if( rc!=SQLITE_OK ){
+      return SQLITE_IOERR_FSTAT;
+    }
+    nMap = statbuf.st_size;
+  }
+  if( nMap>pFd->mmapSizeMax ){
+    nMap = pFd->mmapSizeMax;
+  }
+
+  if( nMap!=pFd->mmapSize ){
+    if( nMap>0 ){
+      unixRemapfile(pFd, nMap);
+    }else{
+      unixUnmapfile(pFd);
+    }
+  }
+#endif
+
+  return SQLITE_OK;
+}
+
+/*
+** If possible, return a pointer to a mapping of file fd starting at offset
+** iOff. The mapping must be valid for at least nAmt bytes.
+**
+** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
+** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
+** Finally, if an error does occur, return an SQLite error code. The final
+** value of *pp is undefined in this case.
+**
+** If this function does return a pointer, the caller must eventually 
+** release the reference by calling unixUnfetch().
+*/
+static int unixFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
+#if SQLITE_MAX_MMAP_SIZE>0
+  unixFile *pFd = (unixFile *)fd;   /* The underlying database file */
+#endif
+  *pp = 0;
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  if( pFd->mmapSizeMax>0 ){
+    if( pFd->pMapRegion==0 ){
+      int rc = unixMapfile(pFd, -1);
+      if( rc!=SQLITE_OK ) return rc;
+    }
+    if( pFd->mmapSize >= iOff+nAmt ){
+      *pp = &((u8 *)pFd->pMapRegion)[iOff];
+      pFd->nFetchOut++;
+    }
+  }
+#endif
+  return SQLITE_OK;
+}
+
+/*
+** If the third argument is non-NULL, then this function releases a 
+** reference obtained by an earlier call to unixFetch(). The second
+** argument passed to this function must be the same as the corresponding
+** argument that was passed to the unixFetch() invocation. 
+**
+** Or, if the third argument is NULL, then this function is being called 
+** to inform the VFS layer that, according to POSIX, any existing mapping 
+** may now be invalid and should be unmapped.
+*/
+static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){
+  unixFile *pFd = (unixFile *)fd;   /* The underlying database file */
+  UNUSED_PARAMETER(iOff);
+
+  /* If p==0 (unmap the entire file) then there must be no outstanding 
+  ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference),
+  ** then there must be at least one outstanding.  */
+  assert( (p==0)==(pFd->nFetchOut==0) );
+
+  /* If p!=0, it must match the iOff value. */
+  assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
+
+  if( p ){
+    pFd->nFetchOut--;
+  }else{
+    unixUnmapfile(pFd);
+  }
+
+  assert( pFd->nFetchOut>=0 );
+  return SQLITE_OK;
+}
 
 /*
 ** Here ends the implementation of all sqlite3_file methods.
 **
 ********************** End sqlite3_file Methods *******************************
@@ -4481,11 +4858,13 @@
    unixSectorSize,             /* xSectorSize */                             \
    unixDeviceCharacteristics,  /* xDeviceCapabilities */                     \
    unixShmMap,                 /* xShmMap */                                 \
    unixShmLock,                /* xShmLock */                                \
    unixShmBarrier,             /* xShmBarrier */                             \
-   unixShmUnmap                /* xShmUnmap */                               \
+   unixShmUnmap,               /* xShmUnmap */                               \
+   unixFetch,                  /* xFetch */                                  \
+   unixUnfetch,                /* xUnfetch */                                \
 };                                                                           \
 static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){   \
   UNUSED_PARAMETER(z); UNUSED_PARAMETER(p);                                  \
   return &METHOD;                                                            \
 }                                                                            \
@@ -4498,11 +4877,11 @@
 ** are also created.
 */
 IOMETHODS(
   posixIoFinder,            /* Finder function name */
   posixIoMethods,           /* sqlite3_io_methods object name */
-  2,                        /* shared memory is enabled */
+  3,                        /* shared memory and mmap are enabled */
   unixClose,                /* xClose method */
   unixLock,                 /* xLock method */
   unixUnlock,               /* xUnlock method */
   unixCheckReservedLock     /* xCheckReservedLock method */
 )
@@ -4749,10 +5128,11 @@
   OSTRACE(("OPEN    %-3d %s\n", h, zFilename));
   pNew->h = h;
   pNew->pVfs = pVfs;
   pNew->zPath = zFilename;
   pNew->ctrlFlags = (u8)ctrlFlags;
+  pNew->mmapSizeMax = sqlite3GlobalConfig.mxMmap;
   if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0),
                            "psow", SQLITE_POWERSAFE_OVERWRITE) ){
     pNew->ctrlFlags |= UNIXFILE_PSOW;
   }
   if( strcmp(pVfs->zName,"unix-excl")==0 ){
@@ -4893,10 +5273,11 @@
   if( rc!=SQLITE_OK ){
     if( h>=0 ) robust_close(pNew, h, __LINE__);
   }else{
     pNew->pMethod = pLockingStyle;
     OpenCounter(+1);
+    verifyDbFile(pNew);
   }
   return rc;
 }
 
 /*
@@ -6986,11 +7367,11 @@
   };
   unsigned int i;          /* Loop counter */
 
   /* Double-check that the aSyscall[] array has been constructed
   ** correctly.  See ticket [bb3a86e890c8e96ab] */
-  assert( ArraySize(aSyscall)==21 );
+  assert( ArraySize(aSyscall)==24 );
 
   /* Register all VFSes defined in the aVfs[] array */
   for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
     sqlite3_vfs_register(&aVfs[i], i==0);
   }

Index: src/os_win.c
==================================================================
--- src/os_win.c
+++ src/os_win.c
@@ -148,15 +148,24 @@
   HANDLE hMutex;          /* Mutex used to control access to shared lock */  
   HANDLE hShared;         /* Shared memory segment used for locking */
   winceLock local;        /* Locks obtained by this instance of winFile */
   winceLock *shared;      /* Global shared lock memory for the file  */
 #endif
+#if SQLITE_MAX_MMAP_SIZE>0
+  int nFetchOut;                /* Number of outstanding xFetch references */
+  HANDLE hMap;                  /* Handle for accessing memory mapping */
+  void *pMapRegion;             /* Area memory mapped */
+  sqlite3_int64 mmapSize;       /* Usable size of mapped region */
+  sqlite3_int64 mmapSizeActual; /* Actual size of mapped region */
+  sqlite3_int64 mmapSizeMax;    /* Configured FCNTL_MMAP_SIZE value */
+#endif
 };
 
 /*
 ** Allowed values for winFile.ctrlFlags
 */
+#define WINFILE_RDONLY          0x02   /* Connection is read only */
 #define WINFILE_PERSIST_WAL     0x04   /* Persistent WAL mode */
 #define WINFILE_PSOW            0x10   /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
 
 /*
  * The size of the buffer used by sqlite3_win32_write_debug().
@@ -2059,10 +2068,15 @@
 
   return 0;
 #endif
 }
 
+#if SQLITE_MAX_MMAP_SIZE>0
+/* Forward references to VFS methods */
+static int winUnmapfile(winFile*);
+#endif
+
 /*
 ** Close a file.
 **
 ** It is reported that an attempt to close a handle might sometimes
 ** fail.  This is a very unreasonable result, but Windows is notorious
@@ -2080,10 +2094,16 @@
 #ifndef SQLITE_OMIT_WAL
   assert( pFile->pShm==0 );
 #endif
   OSTRACE(("CLOSE %d\n", pFile->h));
   assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  rc = winUnmapfile(pFile);
+  if( rc!=SQLITE_OK ) return rc;
+#endif
+
   do{
     rc = osCloseHandle(pFile->h);
     /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */
   }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (sqlite3_win32_sleep(100), 1) );
 #if SQLITE_OS_WINCE
@@ -2128,12 +2148,30 @@
   winFile *pFile = (winFile*)id;  /* file handle */
   DWORD nRead;                    /* Number of bytes actually read from file */
   int nRetry = 0;                 /* Number of retrys */
 
   assert( id!=0 );
+  assert( amt>0 );
   SimulateIOError(return SQLITE_IOERR_READ);
   OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  /* Deal with as much of this read request as possible by transfering
+  ** data from the memory mapping using memcpy().  */
+  if( offset<pFile->mmapSize ){
+    if( offset+amt <= pFile->mmapSize ){
+      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
+      return SQLITE_OK;
+    }else{
+      int nCopy = (int)(pFile->mmapSize - offset);
+      memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
+      pBuf = &((u8 *)pBuf)[nCopy];
+      amt -= nCopy;
+      offset += nCopy;
+    }
+  }
+#endif
 
 #if SQLITE_OS_WINCE
   if( seekWinFile(pFile, offset) ){
     return SQLITE_FULL;
   }
@@ -2179,10 +2217,27 @@
   assert( pFile );
   SimulateIOError(return SQLITE_IOERR_WRITE);
   SimulateDiskfullError(return SQLITE_FULL);
 
   OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype));
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  /* Deal with as much of this write request as possible by transfering
+  ** data from the memory mapping using memcpy().  */
+  if( offset<pFile->mmapSize ){
+    if( offset+amt <= pFile->mmapSize ){
+      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
+      return SQLITE_OK;
+    }else{
+      int nCopy = (int)(pFile->mmapSize - offset);
+      memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
+      pBuf = &((u8 *)pBuf)[nCopy];
+      amt -= nCopy;
+      offset += nCopy;
+    }
+  }
+#endif
 
 #if SQLITE_OS_WINCE
   rc = seekWinFile(pFile, offset);
   if( rc==0 ){
 #else
@@ -2247,10 +2302,11 @@
 ** Truncate an open file to a specified size
 */
 static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
   winFile *pFile = (winFile*)id;  /* File handle object */
   int rc = SQLITE_OK;             /* Return code for this function */
+  DWORD lastErrno;
 
   assert( pFile );
 
   OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
   SimulateIOError(return SQLITE_IOERR_TRUNCATE);
@@ -2265,16 +2321,27 @@
   }
 
   /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
   if( seekWinFile(pFile, nByte) ){
     rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
-             "winTruncate1", pFile->zPath);
-  }else if( 0==osSetEndOfFile(pFile->h) ){
-    pFile->lastErrno = osGetLastError();
+                     "winTruncate1", pFile->zPath);
+  }else if( 0==osSetEndOfFile(pFile->h) &&
+            ((lastErrno = osGetLastError())!=ERROR_USER_MAPPED_FILE) ){
+    pFile->lastErrno = lastErrno;
     rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
-             "winTruncate2", pFile->zPath);
+                     "winTruncate2", pFile->zPath);
   }
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  /* If the file was truncated to a size smaller than the currently
+  ** mapped region, reduce the effective mapping size as well. SQLite will
+  ** use read() and write() to access data beyond this point from now on.
+  */
+  if( pFile->pMapRegion && nByte<pFile->mmapSize ){
+    pFile->mmapSize = nByte;
+  }
+#endif
 
   OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
   return rc;
 }
 
@@ -2779,10 +2846,21 @@
         getTempname(pFile->pVfs->mxPathname, zTFile);
         *(char**)pArg = zTFile;
       }
       return SQLITE_OK;
     }
+#if SQLITE_MAX_MMAP_SIZE>0
+    case SQLITE_FCNTL_MMAP_SIZE: {
+      i64 newLimit = *(i64*)pArg;
+      if( newLimit>sqlite3GlobalConfig.mxMmap ){
+        newLimit = sqlite3GlobalConfig.mxMmap;
+      }
+      *(i64*)pArg = pFile->mmapSizeMax;
+      if( newLimit>=0 ) pFile->mmapSizeMax = newLimit;
+      return SQLITE_OK;
+    }
+#endif
   }
   return SQLITE_NOTFOUND;
 }
 
 /*
@@ -3448,10 +3526,196 @@
 # define winShmMap     0
 # define winShmLock    0
 # define winShmBarrier 0
 # define winShmUnmap   0
 #endif /* #ifndef SQLITE_OMIT_WAL */
+
+/*
+** Cleans up the mapped region of the specified file, if any.
+*/
+#if SQLITE_MAX_MMAP_SIZE>0
+static int winUnmapfile(winFile *pFile){
+  assert( pFile!=0 );
+  if( pFile->pMapRegion ){
+    if( !osUnmapViewOfFile(pFile->pMapRegion) ){
+      pFile->lastErrno = osGetLastError();
+      return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
+                         "winUnmap1", pFile->zPath);
+    }
+    pFile->pMapRegion = 0;
+    pFile->mmapSize = 0;
+    pFile->mmapSizeActual = 0;
+  }
+  if( pFile->hMap!=NULL ){
+    if( !osCloseHandle(pFile->hMap) ){
+      pFile->lastErrno = osGetLastError();
+      return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
+                         "winUnmap2", pFile->zPath);
+    }
+    pFile->hMap = NULL;
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Memory map or remap the file opened by file-descriptor pFd (if the file
+** is already mapped, the existing mapping is replaced by the new). Or, if 
+** there already exists a mapping for this file, and there are still 
+** outstanding xFetch() references to it, this function is a no-op.
+**
+** If parameter nByte is non-negative, then it is the requested size of 
+** the mapping to create. Otherwise, if nByte is less than zero, then the 
+** requested size is the size of the file on disk. The actual size of the
+** created mapping is either the requested size or the value configured 
+** using SQLITE_FCNTL_MMAP_SIZE, whichever is smaller.
+**
+** SQLITE_OK is returned if no error occurs (even if the mapping is not
+** recreated as a result of outstanding references) or an SQLite error
+** code otherwise.
+*/
+static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
+  sqlite3_int64 nMap = nByte;
+  int rc;
+
+  assert( nMap>=0 || pFd->nFetchOut==0 );
+  if( pFd->nFetchOut>0 ) return SQLITE_OK;
+
+  if( nMap<0 ){
+    rc = winFileSize((sqlite3_file*)pFd, &nMap);
+    if( rc ){
+      return SQLITE_IOERR_FSTAT;
+    }
+  }
+  if( nMap>pFd->mmapSizeMax ){
+    nMap = pFd->mmapSizeMax;
+  }
+  nMap &= ~(sqlite3_int64)(winSysInfo.dwPageSize - 1);
+ 
+  if( nMap==0 && pFd->mmapSize>0 ){
+    winUnmapfile(pFd);
+  }
+  if( nMap!=pFd->mmapSize ){
+    void *pNew = 0;
+    DWORD protect = PAGE_READONLY;
+    DWORD flags = FILE_MAP_READ;
+
+    winUnmapfile(pFd);
+    if( (pFd->ctrlFlags & WINFILE_RDONLY)==0 ){
+      protect = PAGE_READWRITE;
+      flags |= FILE_MAP_WRITE;
+    }
+#if SQLITE_OS_WINRT
+    pFd->hMap = osCreateFileMappingFromApp(pFd->h, NULL, protect, nMap, NULL);
+#elif defined(SQLITE_WIN32_HAS_WIDE)
+    pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect,
+                                (DWORD)((nMap>>32) & 0xffffffff),
+                                (DWORD)(nMap & 0xffffffff), NULL);
+#elif defined(SQLITE_WIN32_HAS_ANSI)
+    pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect,
+                                (DWORD)((nMap>>32) & 0xffffffff),
+                                (DWORD)(nMap & 0xffffffff), NULL);
+#endif
+    if( pFd->hMap==NULL ){
+      pFd->lastErrno = osGetLastError();
+      rc = winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno,
+                       "winMapfile", pFd->zPath);
+      /* Log the error, but continue normal operation using xRead/xWrite */
+      return SQLITE_OK;
+    }
+    assert( (nMap % winSysInfo.dwPageSize)==0 );
+#if SQLITE_OS_WINRT
+    pNew = osMapViewOfFileFromApp(pFd->hMap, flags, 0, nMap);
+#else
+    assert( sizeof(SIZE_T)==sizeof(sqlite3_int64) || nMap<=0xffffffff );
+    pNew = osMapViewOfFile(pFd->hMap, flags, 0, 0, (SIZE_T)nMap);
+#endif
+    if( pNew==NULL ){
+      osCloseHandle(pFd->hMap);
+      pFd->hMap = NULL;
+      pFd->lastErrno = osGetLastError();
+      winLogError(SQLITE_IOERR_MMAP, pFd->lastErrno,
+                  "winMapfile", pFd->zPath);
+      return SQLITE_OK;
+    }
+    pFd->pMapRegion = pNew;
+    pFd->mmapSize = nMap;
+    pFd->mmapSizeActual = nMap;
+  }
+
+  return SQLITE_OK;
+}
+#endif /* SQLITE_MAX_MMAP_SIZE>0 */
+
+/*
+** If possible, return a pointer to a mapping of file fd starting at offset
+** iOff. The mapping must be valid for at least nAmt bytes.
+**
+** If such a pointer can be obtained, store it in *pp and return SQLITE_OK.
+** Or, if one cannot but no error occurs, set *pp to 0 and return SQLITE_OK.
+** Finally, if an error does occur, return an SQLite error code. The final
+** value of *pp is undefined in this case.
+**
+** If this function does return a pointer, the caller must eventually 
+** release the reference by calling unixUnfetch().
+*/
+static int winFetch(sqlite3_file *fd, i64 iOff, int nAmt, void **pp){
+#if SQLITE_MAX_MMAP_SIZE>0
+  winFile *pFd = (winFile*)fd;   /* The underlying database file */
+#endif
+  *pp = 0;
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  if( pFd->mmapSizeMax>0 ){
+    if( pFd->pMapRegion==0 ){
+      int rc = winMapfile(pFd, -1);
+      if( rc!=SQLITE_OK ) return rc;
+    }
+    if( pFd->mmapSize >= iOff+nAmt ){
+      *pp = &((u8 *)pFd->pMapRegion)[iOff];
+      pFd->nFetchOut++;
+    }
+  }
+#endif
+  return SQLITE_OK;
+}
+
+/*
+** If the third argument is non-NULL, then this function releases a 
+** reference obtained by an earlier call to unixFetch(). The second
+** argument passed to this function must be the same as the corresponding
+** argument that was passed to the unixFetch() invocation. 
+**
+** Or, if the third argument is NULL, then this function is being called 
+** to inform the VFS layer that, according to POSIX, any existing mapping 
+** may now be invalid and should be unmapped.
+*/
+static int winUnfetch(sqlite3_file *fd, i64 iOff, void *p){
+#if SQLITE_MAX_MMAP_SIZE>0
+  winFile *pFd = (winFile*)fd;   /* The underlying database file */
+
+  /* If p==0 (unmap the entire file) then there must be no outstanding 
+  ** xFetch references. Or, if p!=0 (meaning it is an xFetch reference),
+  ** then there must be at least one outstanding.  */
+  assert( (p==0)==(pFd->nFetchOut==0) );
+
+  /* If p!=0, it must match the iOff value. */
+  assert( p==0 || p==&((u8 *)pFd->pMapRegion)[iOff] );
+
+  if( p ){
+    pFd->nFetchOut--;
+  }else{
+    /* FIXME:  If Windows truly always prevents truncating or deleting a
+    ** file while a mapping is held, then the following winUnmapfile() call
+    ** is unnecessary can can be omitted - potentially improving
+    ** performance.  */
+    winUnmapfile(pFd);
+  }
+
+  assert( pFd->nFetchOut>=0 );
+#endif
+  return SQLITE_OK;
+}
 
 /*
 ** Here ends the implementation of all sqlite3_file methods.
 **
 ********************** End sqlite3_file Methods *******************************
@@ -3460,11 +3724,11 @@
 /*
 ** This vector defines all the methods that can operate on an
 ** sqlite3_file for win32.
 */
 static const sqlite3_io_methods winIoMethod = {
-  2,                              /* iVersion */
+  3,                              /* iVersion */
   winClose,                       /* xClose */
   winRead,                        /* xRead */
   winWrite,                       /* xWrite */
   winTruncate,                    /* xTruncate */
   winSync,                        /* xSync */
@@ -3476,11 +3740,13 @@
   winSectorSize,                  /* xSectorSize */
   winDeviceCharacteristics,       /* xDeviceCharacteristics */
   winShmMap,                      /* xShmMap */
   winShmLock,                     /* xShmLock */
   winShmBarrier,                  /* xShmBarrier */
-  winShmUnmap                     /* xShmUnmap */
+  winShmUnmap,                    /* xShmUnmap */
+  winFetch,                       /* xFetch */
+  winUnfetch                      /* xUnfetch */
 };
 
 /****************************************************************************
 **************************** sqlite3_vfs methods ****************************
 **
@@ -3652,13 +3918,11 @@
 #endif
 
   int isExclusive  = (flags & SQLITE_OPEN_EXCLUSIVE);
   int isDelete     = (flags & SQLITE_OPEN_DELETEONCLOSE);
   int isCreate     = (flags & SQLITE_OPEN_CREATE);
-#ifndef NDEBUG
   int isReadonly   = (flags & SQLITE_OPEN_READONLY);
-#endif
   int isReadWrite  = (flags & SQLITE_OPEN_READWRITE);
 
 #ifndef NDEBUG
   int isOpenJournal = (isCreate && (
         eType==SQLITE_OPEN_MASTER_JOURNAL 
@@ -3865,15 +4129,25 @@
   }
 
   pFile->pMethod = &winIoMethod;
   pFile->pVfs = pVfs;
   pFile->h = h;
+  if( isReadonly ){
+    pFile->ctrlFlags |= WINFILE_RDONLY;
+  }
   if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){
     pFile->ctrlFlags |= WINFILE_PSOW;
   }
   pFile->lastErrno = NO_ERROR;
   pFile->zPath = zName;
+#if SQLITE_MAX_MMAP_SIZE>0
+  pFile->hMap = NULL;
+  pFile->pMapRegion = 0;
+  pFile->mmapSize = 0;
+  pFile->mmapSizeActual = 0;
+  pFile->mmapSizeMax = sqlite3GlobalConfig.mxMmap;
+#endif
 
   OpenCounter(+1);
   return rc;
 }
 
@@ -4498,20 +4772,19 @@
 
   /* Double-check that the aSyscall[] array has been constructed
   ** correctly.  See ticket [bb3a86e890c8e96ab] */
   assert( ArraySize(aSyscall)==74 );
 
-#ifndef SQLITE_OMIT_WAL
   /* get memory map allocation granularity */
   memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
 #if SQLITE_OS_WINRT
   osGetNativeSystemInfo(&winSysInfo);
 #else
   osGetSystemInfo(&winSysInfo);
 #endif
-  assert(winSysInfo.dwAllocationGranularity > 0);
-#endif
+  assert( winSysInfo.dwAllocationGranularity>0 );
+  assert( winSysInfo.dwPageSize>0 );
 
   sqlite3_vfs_register(&winVfs, 1);
   return SQLITE_OK; 
 }
 

Index: src/pager.c
==================================================================
--- src/pager.c
+++ src/pager.c
@@ -653,10 +653,15 @@
   i64 journalHdr;             /* Byte offset to previous journal header */
   sqlite3_backup *pBackup;    /* Pointer to list of ongoing backup processes */
   PagerSavepoint *aSavepoint; /* Array of active savepoints */
   int nSavepoint;             /* Number of elements in aSavepoint[] */
   char dbFileVers[16];        /* Changes whenever database file changes */
+
+  u8 bUseFetch;               /* True to use xFetch() */
+  int nMmapOut;               /* Number of mmap pages currently outstanding */
+  sqlite3_int64 szMmap;       /* Desired maximum mmap size */
+  PgHdr *pMmapFreelist;       /* List of free mmap page headers (pDirty) */
   /*
   ** End of the routinely-changing class members
   ***************************************************************************/
 
   u16 nExtra;                 /* Add this many bytes to each in-memory page */
@@ -763,10 +768,20 @@
 # define MEMDB 0
 #else
 # define MEMDB pPager->memDb
 #endif
 
+/*
+** The macro USEFETCH is true if we are allowed to use the xFetch and xUnfetch
+** interfaces to access the database using memory-mapped I/O.
+*/
+#if SQLITE_MAX_MMAP_SIZE>0
+# define USEFETCH(x) ((x)->bUseFetch)
+#else
+# define USEFETCH(x) 0
+#endif
+
 /*
 ** The maximum legal page number is (2^31 - 1).
 */
 #define PAGER_MAX_PGNO 2147483647
 
@@ -2250,11 +2265,11 @@
    && isSynced
   ){
     i64 ofst = (pgno-1)*(i64)pPager->pageSize;
     testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
     assert( !pagerUseWal(pPager) );
-    rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
+    rc = sqlite3OsWrite(pPager->fd, (u8 *)aData, pPager->pageSize, ofst);
     if( pgno>pPager->dbFileSize ){
       pPager->dbFileSize = pgno;
     }
     if( pPager->pBackup ){
       CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
@@ -2641,10 +2656,11 @@
   Pgno mxPg = 0;           /* Size of the original file in pages */
   int rc;                  /* Result code of a subroutine */
   int res = 1;             /* Value returned by sqlite3OsAccess() */
   char *zMaster = 0;       /* Name of master journal file if any */
   int needPagerReset;      /* True to reset page prior to first page rollback */
+  int nPlayback = 0;       /* Total number of pages restored from journal */
 
   /* Figure out how many records are in the journal.  Abort early if
   ** the journal is empty.
   */
   assert( isOpen(pPager->jfd) );
@@ -2741,11 +2757,13 @@
       if( needPagerReset ){
         pager_reset(pPager);
         needPagerReset = 0;
       }
       rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
-      if( rc!=SQLITE_OK ){
+      if( rc==SQLITE_OK ){
+        nPlayback++;
+      }else{
         if( rc==SQLITE_DONE ){
           pPager->journalOff = szJ;
           break;
         }else if( rc==SQLITE_IOERR_SHORT_READ ){
           /* If the journal has been truncated, simply stop reading and
@@ -2811,10 +2829,14 @@
     ** see if it is possible to delete the master journal.
     */
     rc = pager_delmaster(pPager, zMaster);
     testcase( rc!=SQLITE_OK );
   }
+  if( isHot && nPlayback ){
+    sqlite3_log(SQLITE_NOTICE_RECOVER_ROLLBACK, "recovered %d pages from %s",
+                nPlayback, pPager->zJournal);
+  }
 
   /* The Pager.sectorSize variable may have been updated while rolling
   ** back a journal created by a process with a different sector size
   ** value. Reset it to the correct value for this process.
   */
@@ -2832,15 +2854,14 @@
 ** the value read from the database file.
 **
 ** If an IO error occurs, then the IO error is returned to the caller.
 ** Otherwise, SQLITE_OK is returned.
 */
-static int readDbPage(PgHdr *pPg){
+static int readDbPage(PgHdr *pPg, u32 iFrame){
   Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
   Pgno pgno = pPg->pgno;       /* Page number to read */
   int rc = SQLITE_OK;          /* Return code */
-  int isInWal = 0;             /* True if page is in log file */
   int pgsz = pPager->pageSize; /* Number of bytes to read */
 
   assert( pPager->eState>=PAGER_READER && !MEMDB );
   assert( isOpen(pPager->fd) );
 
@@ -2848,15 +2869,14 @@
     assert( pPager->tempFile );
     memset(pPg->pData, 0, pPager->pageSize);
     return SQLITE_OK;
   }
 
-  if( pagerUseWal(pPager) ){
+  if( iFrame ){
     /* Try to pull the page from the write-ahead log. */
-    rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
-  }
-  if( rc==SQLITE_OK && !isInWal ){
+    rc = sqlite3WalReadFrame(pPager->pWal, iFrame, pgsz, pPg->pData);
+  }else{
     i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
     rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
     if( rc==SQLITE_IOERR_SHORT_READ ){
       rc = SQLITE_OK;
     }
@@ -2931,16 +2951,21 @@
 static int pagerUndoCallback(void *pCtx, Pgno iPg){
   int rc = SQLITE_OK;
   Pager *pPager = (Pager *)pCtx;
   PgHdr *pPg;
 
+  assert( pagerUseWal(pPager) );
   pPg = sqlite3PagerLookup(pPager, iPg);
   if( pPg ){
     if( sqlite3PcachePageRefcount(pPg)==1 ){
       sqlite3PcacheDrop(pPg);
     }else{
-      rc = readDbPage(pPg);
+      u32 iFrame = 0;
+      rc = sqlite3WalFindFrame(pPager->pWal, pPg->pgno, &iFrame);
+      if( rc==SQLITE_OK ){
+        rc = readDbPage(pPg, iFrame);
+      }
       if( rc==SQLITE_OK ){
         pPager->xReiniter(pPg);
       }
       sqlite3PagerUnref(pPg);
     }
@@ -3080,10 +3105,11 @@
   sqlite3WalEndReadTransaction(pPager->pWal);
 
   rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
   if( rc!=SQLITE_OK || changed ){
     pager_reset(pPager);
+    if( USEFETCH(pPager) ) sqlite3OsUnfetch(pPager->fd, 0, 0);
   }
 
   return rc;
 }
 #endif
@@ -3340,10 +3366,33 @@
 ** Change the maximum number of in-memory pages that are allowed.
 */
 void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
   sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
 }
+
+/*
+** Invoke SQLITE_FCNTL_MMAP_SIZE based on the current value of szMmap.
+*/
+static void pagerFixMaplimit(Pager *pPager){
+#if SQLITE_MAX_MMAP_SIZE>0
+  sqlite3_file *fd = pPager->fd;
+  if( isOpen(fd) ){
+    sqlite3_int64 sz;
+    pPager->bUseFetch = (fd->pMethods->iVersion>=3) && pPager->szMmap>0;
+    sz = pPager->szMmap;
+    sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_MMAP_SIZE, &sz);
+  }
+#endif
+}
+
+/*
+** Change the maximum size of any memory mapping made of the database file.
+*/
+void sqlite3PagerSetMmapLimit(Pager *pPager, sqlite3_int64 szMmap){
+  pPager->szMmap = szMmap;
+  pagerFixMaplimit(pPager);
+}
 
 /*
 ** Free as much memory as possible from the pager.
 */
 void sqlite3PagerShrink(Pager *pPager){
@@ -3576,10 +3625,11 @@
   if( rc==SQLITE_OK ){
     if( nReserve<0 ) nReserve = pPager->nReserve;
     assert( nReserve>=0 && nReserve<1000 );
     pPager->nReserve = (i16)nReserve;
     pagerReportSize(pPager);
+    pagerFixMaplimit(pPager);
   }
   return rc;
 }
 
 /*
@@ -3800,10 +3850,85 @@
   if( rc==SQLITE_OK ){
     rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
   }
   return rc;
 }
+
+/*
+** Obtain a reference to a memory mapped page object for page number pgno. 
+** The new object will use the pointer pData, obtained from xFetch().
+** If successful, set *ppPage to point to the new page reference
+** and return SQLITE_OK. Otherwise, return an SQLite error code and set
+** *ppPage to zero.
+**
+** Page references obtained by calling this function should be released
+** by calling pagerReleaseMapPage().
+*/
+static int pagerAcquireMapPage(
+  Pager *pPager,                  /* Pager object */
+  Pgno pgno,                      /* Page number */
+  void *pData,                    /* xFetch()'d data for this page */
+  PgHdr **ppPage                  /* OUT: Acquired page object */
+){
+  PgHdr *p;                       /* Memory mapped page to return */
+
+  if( pPager->pMmapFreelist ){
+    *ppPage = p = pPager->pMmapFreelist;
+    pPager->pMmapFreelist = p->pDirty;
+    p->pDirty = 0;
+    memset(p->pExtra, 0, pPager->nExtra);
+  }else{
+    *ppPage = p = (PgHdr *)sqlite3MallocZero(sizeof(PgHdr) + pPager->nExtra);
+    if( p==0 ){
+      sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1) * pPager->pageSize, pData);
+      return SQLITE_NOMEM;
+    }
+    p->pExtra = (void *)&p[1];
+    p->flags = PGHDR_MMAP;
+    p->nRef = 1;
+    p->pPager = pPager;
+  }
+
+  assert( p->pExtra==(void *)&p[1] );
+  assert( p->pPage==0 );
+  assert( p->flags==PGHDR_MMAP );
+  assert( p->pPager==pPager );
+  assert( p->nRef==1 );
+
+  p->pgno = pgno;
+  p->pData = pData;
+  pPager->nMmapOut++;
+
+  return SQLITE_OK;
+}
+
+/*
+** Release a reference to page pPg. pPg must have been returned by an 
+** earlier call to pagerAcquireMapPage().
+*/
+static void pagerReleaseMapPage(PgHdr *pPg){
+  Pager *pPager = pPg->pPager;
+  pPager->nMmapOut--;
+  pPg->pDirty = pPager->pMmapFreelist;
+  pPager->pMmapFreelist = pPg;
+
+  assert( pPager->fd->pMethods->iVersion>=3 );
+  sqlite3OsUnfetch(pPager->fd, (i64)(pPg->pgno-1)*pPager->pageSize, pPg->pData);
+}
+
+/*
+** Free all PgHdr objects stored in the Pager.pMmapFreelist list.
+*/
+static void pagerFreeMapHdrs(Pager *pPager){
+  PgHdr *p;
+  PgHdr *pNext;
+  for(p=pPager->pMmapFreelist; p; p=pNext){
+    pNext = p->pDirty;
+    sqlite3_free(p);
+  }
+}
+
 
 /*
 ** Shutdown the page cache.  Free all memory and close all files.
 **
 ** If a transaction was in progress when this routine is called, that
@@ -3821,10 +3946,11 @@
   u8 *pTmp = (u8 *)pPager->pTmpSpace;
 
   assert( assert_pager_state(pPager) );
   disable_simulated_io_errors();
   sqlite3BeginBenignMalloc();
+  pagerFreeMapHdrs(pPager);
   /* pPager->errCode = 0; */
   pPager->exclusiveMode = 0;
 #ifndef SQLITE_OMIT_WAL
   sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
   pPager->pWal = 0;
@@ -4082,11 +4208,13 @@
 
   /* Before the first write, give the VFS a hint of what the final
   ** file size will be.
   */
   assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
-  if( rc==SQLITE_OK && pPager->dbSize>pPager->dbHintSize ){
+  if( rc==SQLITE_OK 
+   && (pList->pDirty ? pPager->dbSize : pList->pgno+1)>pPager->dbHintSize 
+  ){
     sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
     sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
     pPager->dbHintSize = pPager->dbSize;
   }
 
@@ -4636,10 +4764,11 @@
   }
   /* pPager->xBusyHandler = 0; */
   /* pPager->pBusyHandlerArg = 0; */
   pPager->xReiniter = xReinit;
   /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
+  /* pPager->szMmap = SQLITE_DEFAULT_MMAP_SIZE // will be set by btree.c */
 
   *ppPager = pPager;
   return SQLITE_OK;
 }
 
@@ -4927,13 +5056,15 @@
       assert( (pPager->eLock==SHARED_LOCK)
            || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
       );
     }
 
-    if( !pPager->tempFile 
-     && (pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0) 
-    ){
+    if( !pPager->tempFile && (
+        pPager->pBackup 
+     || sqlite3PcachePagecount(pPager->pPCache)>0 
+     || USEFETCH(pPager)
+    )){
       /* The shared-lock has just been acquired on the database file
       ** and there are already pages in the cache (from a previous
       ** read or write transaction).  Check to see if the database
       ** has been modified.  If the database has changed, flush the
       ** cache.
@@ -4955,19 +5086,29 @@
       if( rc ) goto failed;
 
       if( nPage>0 ){
         IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
         rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
-        if( rc!=SQLITE_OK ){
+        if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
           goto failed;
         }
       }else{
         memset(dbFileVers, 0, sizeof(dbFileVers));
       }
 
       if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
         pager_reset(pPager);
+
+        /* Unmap the database file. It is possible that external processes
+        ** may have truncated the database file and then extended it back
+        ** to its original size while this process was not holding a lock.
+        ** In this case there may exist a Pager.pMap mapping that appears
+        ** to be the right size but is not actually valid. Avoid this
+        ** possibility by unmapping the db here. */
+        if( USEFETCH(pPager) ){
+          sqlite3OsUnfetch(pPager->fd, 0, 0);
+        }
       }
     }
 
     /* If there is a WAL file in the file-system, open this database in WAL
     ** mode. Otherwise, the following function call is a no-op.
@@ -5005,11 +5146,11 @@
 ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
 ** the rollback journal, the unlock is not performed and there is
 ** nothing to rollback, so this routine is a no-op.
 */ 
 static void pagerUnlockIfUnused(Pager *pPager){
-  if( (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
+  if( pPager->nMmapOut==0 && (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
     pagerUnlockAndRollback(pPager);
   }
 }
 
 /*
@@ -5064,17 +5205,31 @@
 */
 int sqlite3PagerAcquire(
   Pager *pPager,      /* The pager open on the database file */
   Pgno pgno,          /* Page number to fetch */
   DbPage **ppPage,    /* Write a pointer to the page here */
-  int noContent       /* Do not bother reading content from disk if true */
+  int flags           /* PAGER_ACQUIRE_XXX flags */
 ){
-  int rc;
-  PgHdr *pPg;
+  int rc = SQLITE_OK;
+  PgHdr *pPg = 0;
+  u32 iFrame = 0;                 /* Frame to read from WAL file */
+  const int noContent = (flags & PAGER_ACQUIRE_NOCONTENT);
+
+  /* It is acceptable to use a read-only (mmap) page for any page except
+  ** page 1 if there is no write-transaction open or the ACQUIRE_READONLY
+  ** flag was specified by the caller. And so long as the db is not a 
+  ** temporary or in-memory database.  */
+  const int bMmapOk = (pgno!=1 && USEFETCH(pPager)
+   && (pPager->eState==PAGER_READER || (flags & PAGER_ACQUIRE_READONLY))
+#ifdef SQLITE_HAS_CODEC
+   && pPager->xCodec==0
+#endif
+  );
 
   assert( pPager->eState>=PAGER_READER );
   assert( assert_pager_state(pPager) );
+  assert( noContent==0 || bMmapOk==0 );
 
   if( pgno==0 ){
     return SQLITE_CORRUPT_BKPT;
   }
 
@@ -5081,10 +5236,43 @@
   /* If the pager is in the error state, return an error immediately. 
   ** Otherwise, request the page from the PCache layer. */
   if( pPager->errCode!=SQLITE_OK ){
     rc = pPager->errCode;
   }else{
+
+    if( bMmapOk && pagerUseWal(pPager) ){
+      rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
+      if( rc!=SQLITE_OK ) goto pager_acquire_err;
+    }
+
+    if( iFrame==0 && bMmapOk ){
+      void *pData = 0;
+
+      rc = sqlite3OsFetch(pPager->fd, 
+          (i64)(pgno-1) * pPager->pageSize, pPager->pageSize, &pData
+      );
+
+      if( rc==SQLITE_OK && pData ){
+        if( pPager->eState>PAGER_READER ){
+          (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
+        }
+        if( pPg==0 ){
+          rc = pagerAcquireMapPage(pPager, pgno, pData, &pPg);
+        }else{
+          sqlite3OsUnfetch(pPager->fd, (i64)(pgno-1)*pPager->pageSize, pData);
+        }
+        if( pPg ){
+          assert( rc==SQLITE_OK );
+          *ppPage = pPg;
+          return SQLITE_OK;
+        }
+      }
+      if( rc!=SQLITE_OK ){
+        goto pager_acquire_err;
+      }
+    }
+
     rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
   }
 
   if( rc!=SQLITE_OK ){
     /* Either the call to sqlite3PcacheFetch() returned an error or the
@@ -5139,13 +5327,17 @@
         sqlite3EndBenignMalloc();
       }
       memset(pPg->pData, 0, pPager->pageSize);
       IOTRACE(("ZERO %p %d\n", pPager, pgno));
     }else{
+      if( pagerUseWal(pPager) && bMmapOk==0 ){
+        rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iFrame);
+        if( rc!=SQLITE_OK ) goto pager_acquire_err;
+      }
       assert( pPg->pPager==pPager );
       pPager->aStat[PAGER_STAT_MISS]++;
-      rc = readDbPage(pPg);
+      rc = readDbPage(pPg, iFrame);
       if( rc!=SQLITE_OK ){
         goto pager_acquire_err;
       }
     }
     pager_set_pagehash(pPg);
@@ -5194,11 +5386,15 @@
 ** removed.
 */
 void sqlite3PagerUnref(DbPage *pPg){
   if( pPg ){
     Pager *pPager = pPg->pPager;
-    sqlite3PcacheRelease(pPg);
+    if( pPg->flags & PGHDR_MMAP ){
+      pagerReleaseMapPage(pPg);
+    }else{
+      sqlite3PcacheRelease(pPg);
+    }
     pagerUnlockIfUnused(pPager);
   }
 }
 
 /*
@@ -5529,10 +5725,11 @@
 
   PgHdr *pPg = pDbPage;
   Pager *pPager = pPg->pPager;
   Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
 
+  assert( (pPg->flags & PGHDR_MMAP)==0 );
   assert( pPager->eState>=PAGER_WRITER_LOCKED );
   assert( pPager->eState!=PAGER_ERROR );
   assert( assert_pager_state(pPager) );
 
   if( nPagePerSector>1 ){
@@ -6085,11 +6282,11 @@
   }else{
     rc = pager_playback(pPager, 0);
   }
 
   assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
-  assert( rc==SQLITE_OK || rc==SQLITE_FULL
+  assert( rc==SQLITE_OK || rc==SQLITE_FULL || rc==SQLITE_CORRUPT
           || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR );
 
   /* If an error occurs during a ROLLBACK, we can no longer trust the pager
   ** cache. So call pager_error() on the way out to make any error persistent.
   */
@@ -6819,15 +7016,16 @@
 
   /* Open the connection to the log file. If this operation fails, 
   ** (e.g. due to malloc() failure), return an error code.
   */
   if( rc==SQLITE_OK ){
-    rc = sqlite3WalOpen(pPager->pVfs, 
+    rc = sqlite3WalOpen(pPager->pVfs,
         pPager->fd, pPager->zWal, pPager->exclusiveMode,
         pPager->journalSizeLimit, &pPager->pWal
     );
   }
+  pagerFixMaplimit(pPager);
 
   return rc;
 }
 
 
@@ -6914,10 +7112,11 @@
     rc = pagerExclusiveLock(pPager);
     if( rc==SQLITE_OK ){
       rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
                            pPager->pageSize, (u8*)pPager->pTmpSpace);
       pPager->pWal = 0;
+      pagerFixMaplimit(pPager);
     }
   }
   return rc;
 }
 

Index: src/pager.h
==================================================================
--- src/pager.h
+++ src/pager.h
@@ -76,10 +76,16 @@
 #define PAGER_JOURNALMODE_OFF         2   /* Journal omitted.  */
 #define PAGER_JOURNALMODE_TRUNCATE    3   /* Commit by truncating journal */
 #define PAGER_JOURNALMODE_MEMORY      4   /* In-memory journal file */
 #define PAGER_JOURNALMODE_WAL         5   /* Use write-ahead logging */
 
+/*
+** Flags that make up the mask passed to sqlite3PagerAcquire().
+*/
+#define PAGER_ACQUIRE_NOCONTENT     0x01  /* Do not load data from disk */
+#define PAGER_ACQUIRE_READONLY      0x02  /* Read-only page is acceptable */
+
 /*
 ** The remainder of this file contains the declarations of the functions
 ** that make up the Pager sub-system API. See source code comments for 
 ** a detailed description of each routine.
 */
@@ -100,10 +106,11 @@
 /* Functions used to configure a Pager object. */
 void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
 int sqlite3PagerSetPagesize(Pager*, u32*, int);
 int sqlite3PagerMaxPageCount(Pager*, int);
 void sqlite3PagerSetCachesize(Pager*, int);
+void sqlite3PagerSetMmapLimit(Pager *, sqlite3_int64);
 void sqlite3PagerShrink(Pager*);
 void sqlite3PagerSetSafetyLevel(Pager*,int,int,int);
 int sqlite3PagerLockingMode(Pager *, int);
 int sqlite3PagerSetJournalMode(Pager *, int);
 int sqlite3PagerGetJournalMode(Pager*);

Index: src/pcache.h
==================================================================
--- src/pcache.h
+++ src/pcache.h
@@ -50,10 +50,12 @@
 #define PGHDR_NEED_SYNC         0x004  /* Fsync the rollback journal before
                                        ** writing this page to the database */
 #define PGHDR_NEED_READ         0x008  /* Content is unread */
 #define PGHDR_REUSE_UNLIKELY    0x010  /* A hint that reuse is unlikely */
 #define PGHDR_DONT_WRITE        0x020  /* Do not write content to disk */
+
+#define PGHDR_MMAP              0x040  /* This is an mmap page object */
 
 /* Initialize and shutdown the page cache subsystem */
 int sqlite3PcacheInitialize(void);
 void sqlite3PcacheShutdown(void);
 

Index: src/pragma.c
==================================================================
--- src/pragma.c
+++ src/pragma.c
@@ -317,11 +317,11 @@
   int iDb;               /* Database index for <database> */
   char *aFcntl[4];       /* Argument to SQLITE_FCNTL_PRAGMA */
   int rc;                      /* return value form SQLITE_FCNTL_PRAGMA */
   sqlite3 *db = pParse->db;    /* The database connection */
   Db *pDb;                     /* The specific database being pragmaed */
-  Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);  /* Prepared statement */
+  Vdbe *v = sqlite3GetVdbe(pParse);  /* Prepared statement */
 
   if( v==0 ) return;
   sqlite3VdbeRunOnlyOnce(v);
   pParse->nMem = 2;
 
@@ -400,15 +400,16 @@
   */
   if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
     static const VdbeOpList getCacheSize[] = {
       { OP_Transaction, 0, 0,        0},                         /* 0 */
       { OP_ReadCookie,  0, 1,        BTREE_DEFAULT_CACHE_SIZE},  /* 1 */
-      { OP_IfPos,       1, 7,        0},
+      { OP_IfPos,       1, 8,        0},
       { OP_Integer,     0, 2,        0},
       { OP_Subtract,    1, 2,        1},
-      { OP_IfPos,       1, 7,        0},
+      { OP_IfPos,       1, 8,        0},
       { OP_Integer,     0, 1,        0},                         /* 6 */
+      { OP_Noop,        0, 0,        0},
       { OP_ResultRow,   1, 1,        0},
     };
     int addr;
     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
     sqlite3VdbeUsesBtree(v, iDb);
@@ -742,10 +743,47 @@
       pDb->pSchema->cache_size = size;
       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
     }
   }else
 
+  /*
+  **  PRAGMA [database.]mmap_size(N)
+  **
+  ** Used to set mapping size limit. The mapping size limit is
+  ** used to limit the aggregate size of all memory mapped regions of the
+  ** database file. If this parameter is set to zero, then memory mapping
+  ** is not used at all.  If N is negative, then the default memory map
+  ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.
+  ** The parameter N is measured in bytes.
+  **
+  ** This value is advisory.  The underlying VFS is free to memory map
+  ** as little or as much as it wants.  Except, if N is set to 0 then the
+  ** upper layers will never invoke the xFetch interfaces to the VFS.
+  */
+  if( sqlite3StrICmp(zLeft,"mmap_size")==0 ){
+    sqlite3_int64 sz;
+    assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
+    if( zRight ){
+      int ii;
+      sqlite3Atoi64(zRight, &sz, 1000, SQLITE_UTF8);
+      if( sz<0 ) sz = sqlite3GlobalConfig.szMmap;
+      if( pId2->n==0 ) db->szMmap = sz;
+      for(ii=db->nDb-1; ii>=0; ii--){
+        if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
+          sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz);
+        }
+      }
+    }
+    sz = -1;
+    if( sqlite3_file_control(db,zDb,SQLITE_FCNTL_MMAP_SIZE,&sz)==SQLITE_OK ){
+#if SQLITE_MAX_MMAP_SIZE==0
+      sz = 0;
+#endif
+      returnSingleInt(pParse, "mmap_size", sz);
+    }
+  }else
+
   /*
   **   PRAGMA temp_store
   **   PRAGMA temp_store = "default"|"memory"|"file"
   **
   ** Return or set the local value of the temp_store flag.  Changing

Index: src/prepare.c
==================================================================
--- src/prepare.c
+++ src/prepare.c
@@ -652,11 +652,10 @@
                             azColName[i], SQLITE_STATIC);
     }
   }
 #endif
 
-  assert( db->init.busy==0 || saveSqlFlag==0 );
   if( db->init.busy==0 ){
     Vdbe *pVdbe = pParse->pVdbe;
     sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
   }
   if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){

Index: src/resolve.c
==================================================================
--- src/resolve.c
+++ src/resolve.c
@@ -386,11 +386,14 @@
     ** In cases like this, replace pExpr with a copy of the expression that
     ** forms the result set entry ("a+b" in the example) and return immediately.
     ** Note that the expression in the result set should have already been
     ** resolved by the time the WHERE clause is resolved.
     */
-    if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){
+    if( (pEList = pNC->pEList)!=0
+     && zTab==0
+     && ((pNC->ncFlags & NC_AsMaybe)==0 || cnt==0)
+    ){
       for(j=0; j<pEList->nExpr; j++){
         char *zAs = pEList->a[j].zName;
         if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
           Expr *pOrig;
           assert( pExpr->pLeft==0 && pExpr->pRight==0 );
@@ -477,11 +480,13 @@
   pExpr->pRight = 0;
   pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
 lookupname_end:
   if( cnt==1 ){
     assert( pNC!=0 );
-    sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
+    if( pExpr->op!=TK_AS ){
+      sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
+    }
     /* Increment the nRef value on all name contexts from TopNC up to
     ** the point where the name matched. */
     for(;;){
       assert( pTopNC!=0 );
       pTopNC->nRef++;
@@ -1152,15 +1157,14 @@
     **
     ** Minor point: If this is the case, then the expression will be
     ** re-evaluated for each reference to it.
     */
     sNC.pEList = p->pEList;
-    if( sqlite3ResolveExprNames(&sNC, p->pWhere) ||
-       sqlite3ResolveExprNames(&sNC, p->pHaving)
-    ){
-      return WRC_Abort;
-    }
+    if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort;
+    sNC.ncFlags |= NC_AsMaybe;
+    if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort;
+    sNC.ncFlags &= ~NC_AsMaybe;
 
     /* The ORDER BY and GROUP BY clauses may not refer to terms in
     ** outer queries 
     */
     sNC.pNext = 0;

Index: src/shell.c
==================================================================
--- src/shell.c
+++ src/shell.c
@@ -1549,10 +1549,47 @@
   }
   fprintf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
           zArg);
   return 0;
 }
+
+/*
+** Interpret zArg as an integer value, possibly with suffixes.
+*/
+static sqlite3_int64 integerValue(const char *zArg){
+  sqlite3_int64 v = 0;
+  static const struct { char *zSuffix; int iMult; } aMult[] = {
+    { "KiB", 1024 },
+    { "MiB", 1024*1024 },
+    { "GiB", 1024*1024*1024 },
+    { "KB",  1000 },
+    { "MB",  1000000 },
+    { "GB",  1000000000 },
+    { "K",   1000 },
+    { "M",   1000000 },
+    { "G",   1000000000 },
+  };
+  int i;
+  int isNeg = 0;
+  if( zArg[0]=='-' ){
+    isNeg = 1;
+    zArg++;
+  }else if( zArg[0]=='+' ){
+    zArg++;
+  }
+  while( isdigit(zArg[0]) ){
+    v = v*10 + zArg[0] - '0';
+    zArg++;
+  }
+  for(i=0; i<sizeof(aMult)/sizeof(aMult[0]); i++){
+    if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
+      v *= aMult[i].iMult;
+      break;
+    }
+  }
+  return isNeg? -v : v;
+}
 
 /*
 ** Close an output file, assuming it is not stderr or stdout
 */
 static void output_file_close(FILE *f){
@@ -2467,11 +2504,11 @@
           break;
 
         /* sqlite3_test_control(int, uint) */
         case SQLITE_TESTCTRL_PENDING_BYTE:        
           if( nArg==3 ){
-            unsigned int opt = (unsigned int)atoi(azArg[2]);        
+            unsigned int opt = (unsigned int)integerValue(azArg[2]);        
             rc = sqlite3_test_control(testctrl, opt);
             printf("%d (0x%08x)\n", rc, rc);
           } else {
             fprintf(stderr,"Error: testctrl %s takes a single unsigned"
                            " int option\n", azArg[1]);
@@ -2559,11 +2596,11 @@
   }else
 
 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
   if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
     extern int sqlite3WhereTrace;
-    sqlite3WhereTrace = atoi(azArg[1]);
+    sqlite3WhereTrace = booleanValue(azArg[1]);
   }else
 #endif
 
   if( c=='w' && strncmp(azArg[0], "width", n)==0 && nArg>1 ){
     int j;
@@ -2745,10 +2782,14 @@
         errCnt++;
       }
       free(zSql);
       zSql = 0;
       nSql = 0;
+    }else if( zSql && _all_whitespace(zSql) ){
+      free(zSql);
+      zSql = 0;
+      nSql = 0;
     }
   }
   if( zSql ){
     if( !_all_whitespace(zSql) ){
       fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);
@@ -2880,10 +2921,11 @@
   "   -help                show this message\n"
   "   -html                set output mode to HTML\n"
   "   -interactive         force interactive I/O\n"
   "   -line                set output mode to 'line'\n"
   "   -list                set output mode to 'list'\n"
+  "   -mmap N              default mmap size set to N\n"
 #ifdef SQLITE_ENABLE_MULTIPLEX
   "   -multiplex           enable the multiplexor VFS\n"
 #endif
   "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
   "   -separator SEP       set output field separator. Default: '|'\n"
@@ -2999,16 +3041,11 @@
       int j, c;
       const char *zSize;
       sqlite3_int64 szHeap;
 
       zSize = cmdline_option_value(argc, argv, ++i);
-      szHeap = atoi(zSize);
-      for(j=0; (c = zSize[j])!=0; j++){
-        if( c=='M' ){ szHeap *= 1000000; break; }
-        if( c=='K' ){ szHeap *= 1000; break; }
-        if( c=='G' ){ szHeap *= 1000000000; break; }
-      }
+      szHeap = integerValue(zSize);
       if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
       sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
 #endif
 #ifdef SQLITE_ENABLE_VFSTRACE
     }else if( strcmp(z,"-vfstrace")==0 ){
@@ -3024,10 +3061,13 @@
 #ifdef SQLITE_ENABLE_MULTIPLEX
     }else if( strcmp(z,"-multiplex")==0 ){
       extern int sqlite3_multiple_initialize(const char*,int);
       sqlite3_multiplex_initialize(0, 1);
 #endif
+    }else if( strcmp(z,"-mmap")==0 ){
+      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
+      sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
     }else if( strcmp(z,"-vfs")==0 ){
       sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
       if( pVfs ){
         sqlite3_vfs_register(pVfs, 1);
       }else{
@@ -3109,10 +3149,12 @@
       stdin_is_interactive = 1;
     }else if( strcmp(z,"-batch")==0 ){
       stdin_is_interactive = 0;
     }else if( strcmp(z,"-heap")==0 ){
       i++;
+    }else if( strcmp(z,"-mmap")==0 ){
+      i++;
     }else if( strcmp(z,"-vfs")==0 ){
       i++;
 #ifdef SQLITE_ENABLE_VFSTRACE
     }else if( strcmp(z,"-vfstrace")==0 ){
       i++;
@@ -3126,11 +3168,11 @@
     }else if( strcmp(z,"-cmd")==0 ){
       if( i==argc-1 ) break;
       z = cmdline_option_value(argc,argv,++i);
       if( z[0]=='.' ){
         rc = do_meta_command(z, &data);
-        if( rc && bail_on_error ) return rc;
+        if( rc && bail_on_error ) return rc==2 ? 0 : rc;
       }else{
         open_db(&data);
         rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
         if( zErrMsg!=0 ){
           fprintf(stderr,"Error: %s\n", zErrMsg);
@@ -3150,10 +3192,11 @@
   if( zFirstCmd ){
     /* Run just the command that follows the database name
     */
     if( zFirstCmd[0]=='.' ){
       rc = do_meta_command(zFirstCmd, &data);
+      if( rc==2 ) rc = 0;
     }else{
       open_db(&data);
       rc = shell_exec(data.db, zFirstCmd, shell_callback, &data, &zErrMsg);
       if( zErrMsg!=0 ){
         fprintf(stderr,"Error: %s\n", zErrMsg);

Index: src/sqlite.h.in
==================================================================
--- src/sqlite.h.in
+++ src/sqlite.h.in
@@ -418,10 +418,12 @@
 #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
 #define SQLITE_AUTH        23   /* Authorization denied */
 #define SQLITE_FORMAT      24   /* Auxiliary database format error */
 #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
 #define SQLITE_NOTADB      26   /* File opened that is not a database file */
+#define SQLITE_NOTICE      27   /* Notifications from sqlite3_log() */
+#define SQLITE_WARNING     28   /* Warnings from sqlite3_log() */
 #define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
 #define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
 /* end-of-error-codes */
 
 /*
@@ -468,10 +470,11 @@
 #define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
 #define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
 #define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
 #define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
 #define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))
+#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))
 #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
 #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
 #define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
 #define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
 #define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
@@ -487,10 +490,12 @@
 #define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
 #define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
 #define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
 #define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
 #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
+#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
+#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
 
 /*
 ** CAPI3REF: Flags For File Open Operations
 **
 ** These bit values are intended for use in the
@@ -726,10 +731,13 @@
   int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
   int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
   void (*xShmBarrier)(sqlite3_file*);
   int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
   /* Methods above are valid for version 2 */
+  int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
+  int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p);
+  /* Methods above are valid for version 3 */
   /* Additional methods may be added in future releases */
 };
 
 /*
 ** CAPI3REF: Standard File Control Opcodes
@@ -862,11 +870,12 @@
 ** compilation of the PRAGMA fails with an error.  ^The [SQLITE_FCNTL_PRAGMA]
 ** file control occurs at the beginning of pragma statement analysis and so
 ** it is able to override built-in [PRAGMA] statements.
 **
 ** <li>[[SQLITE_FCNTL_BUSYHANDLER]]
-** ^This file-control may be invoked by SQLite on the database file handle
+** ^The [SQLITE_FCNTL_BUSYHANDLER]
+** file-control may be invoked by SQLite on the database file handle
 ** shortly after it is opened in order to provide a custom VFS with access
 ** to the connections busy-handler callback. The argument is of type (void **)
 ** - an array of two (void *) values. The first (void *) actually points
 ** to a function of type (int (*)(void *)). In order to invoke the connections
 ** busy-handler, this function should be invoked with the second (void *) in
@@ -873,17 +882,28 @@
 ** the array as the only argument. If it returns non-zero, then the operation
 ** should be retried. If it returns zero, the custom VFS should abandon the
 ** current operation.
 **
 ** <li>[[SQLITE_FCNTL_TEMPFILENAME]]
-** ^Application can invoke this file-control to have SQLite generate a
+** ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control
+** to have SQLite generate a
 ** temporary filename using the same algorithm that is followed to generate
 ** temporary filenames for TEMP tables and other internal uses.  The
 ** argument should be a char** which will be filled with the filename
 ** written into memory obtained from [sqlite3_malloc()].  The caller should
 ** invoke [sqlite3_free()] on the result to avoid a memory leak.
 **
+** <li>[[SQLITE_FCNTL_MMAP_SIZE]]
+** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the
+** maximum number of bytes that will be used for memory-mapped I/O.
+** The argument is a pointer to a value of type sqlite3_int64 that
+** is an advisory maximum number of bytes in the file to memory map.  The
+** pointer is overwritten with the old value.  The limit is not changed if
+** the value originally pointed to is negative, and so the current limit 
+** can be queried by passing in a pointer to a negative number.  This
+** file-control is used internally to implement [PRAGMA mmap_size].
+**
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
 #define SQLITE_GET_LOCKPROXYFILE             2
 #define SQLITE_SET_LOCKPROXYFILE             3
@@ -898,10 +918,11 @@
 #define SQLITE_FCNTL_VFSNAME                12
 #define SQLITE_FCNTL_POWERSAFE_OVERWRITE    13
 #define SQLITE_FCNTL_PRAGMA                 14
 #define SQLITE_FCNTL_BUSYHANDLER            15
 #define SQLITE_FCNTL_TEMPFILENAME           16
+#define SQLITE_FCNTL_MMAP_SIZE              18
 
 /*
 ** CAPI3REF: Mutex Handle
 **
 ** The mutex module within SQLite defines [sqlite3_mutex] to be an
@@ -1610,26 +1631,42 @@
 **
 ** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]]
 ** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE
 ** <dd> These options are obsolete and should not be used by new code.
 ** They are retained for backwards compatibility but are now no-ops.
-** </dl>
+** </dd>
 **
 ** [[SQLITE_CONFIG_SQLLOG]]
 ** <dt>SQLITE_CONFIG_SQLLOG
 ** <dd>This option is only available if sqlite is compiled with the
-** SQLITE_ENABLE_SQLLOG pre-processor macro defined. The first argument should
+** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should
 ** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int).
 ** The second should be of type (void*). The callback is invoked by the library
 ** in three separate circumstances, identified by the value passed as the
 ** fourth parameter. If the fourth parameter is 0, then the database connection
 ** passed as the second argument has just been opened. The third argument
 ** points to a buffer containing the name of the main database file. If the
 ** fourth parameter is 1, then the SQL statement that the third parameter
 ** points to has just been executed. Or, if the fourth parameter is 2, then
 ** the connection being passed as the second parameter is being closed. The
-** third parameter is passed NULL In this case.
+** third parameter is passed NULL In this case.  An example of using this
+** configuration option can be seen in the "test_sqllog.c" source file in
+** the canonical SQLite source tree.</dd>
+**
+** [[SQLITE_CONFIG_MMAP_SIZE]]
+** <dt>SQLITE_CONFIG_MMAP_SIZE
+** <dd>SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values
+** that are the default mmap size limit (the default setting for
+** [PRAGMA mmap_size]) and the maximum allowed mmap size limit.
+** The default setting can be overridden by each database connection using
+** either the [PRAGMA mmap_size] command, or by using the
+** [SQLITE_FCNTL_MMAP_SIZE] file control.  The maximum allowed mmap size
+** cannot be changed at run-time.  Nor may the maximum allowed mmap size
+** exceed the compile-time maximum mmap size set by the
+** [SQLITE_MAX_MMAP_SIZE] compile-time option.  
+** If either argument to this option is negative, then that argument is
+** changed to its compile-time default.
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
 #define SQLITE_CONFIG_MULTITHREAD   2  /* nil */
 #define SQLITE_CONFIG_SERIALIZED    3  /* nil */
@@ -1649,10 +1686,11 @@
 #define SQLITE_CONFIG_URI          17  /* int */
 #define SQLITE_CONFIG_PCACHE2      18  /* sqlite3_pcache_methods2* */
 #define SQLITE_CONFIG_GETPCACHE2   19  /* sqlite3_pcache_methods2* */
 #define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */
 #define SQLITE_CONFIG_SQLLOG       21  /* xSqllog, void* */
+#define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */
 
 /*
 ** CAPI3REF: Database Connection Configuration Options
 **
 ** These constants are the available integer configuration options that
@@ -4180,11 +4218,11 @@
 ** SQLITE_TRANSIENT value means that the content will likely change in
 ** the near future and that SQLite should make its own private copy of
 ** the content before returning.
 **
 ** The typedef is necessary to work around problems in certain
-** C++ compilers.  See ticket #2191.
+** C++ compilers.
 */
 typedef void (*sqlite3_destructor_type)(void*);
 #define SQLITE_STATIC      ((sqlite3_destructor_type)0)
 #define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
 
@@ -4979,15 +5017,24 @@
 ** CAPI3REF: Load An Extension
 **
 ** ^This interface loads an SQLite extension library from the named file.
 **
 ** ^The sqlite3_load_extension() interface attempts to load an
-** SQLite extension library contained in the file zFile.
+** [SQLite extension] library contained in the file zFile.  If
+** the file cannot be loaded directly, attempts are made to load
+** with various operating-system specific extensions added.
+** So for example, if "samplelib" cannot be loaded, then names like
+** "samplelib.so" or "samplelib.dylib" or "samplelib.dll" might
+** be tried also.
 **
 ** ^The entry point is zProc.
-** ^zProc may be 0, in which case the name of the entry point
-** defaults to "sqlite3_extension_init".
+** ^(zProc may be 0, in which case SQLite will try to come up with an
+** entry point name on its own.  It first tries "sqlite3_extension_init".
+** If that does not work, it constructs a name "sqlite3_X_init" where the
+** X is consists of the lower-case equivalent of all ASCII alphabetic
+** characters in the filename from the last "/" to the first following
+** "." and omitting any initial "lib".)^
 ** ^The sqlite3_load_extension() interface returns
 ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
 ** ^If an error occurs and pzErrMsg is not 0, then the
 ** [sqlite3_load_extension()] interface shall attempt to
 ** fill *pzErrMsg with error message text stored in memory
@@ -5009,15 +5056,15 @@
 
 /*
 ** CAPI3REF: Enable Or Disable Extension Loading
 **
 ** ^So as not to open security holes in older applications that are
-** unprepared to deal with extension loading, and as a means of disabling
-** extension loading while evaluating user-entered SQL, the following API
+** unprepared to deal with [extension loading], and as a means of disabling
+** [extension loading] while evaluating user-entered SQL, the following API
 ** is provided to turn the [sqlite3_load_extension()] mechanism on and off.
 **
-** ^Extension loading is off by default. See ticket #1863.
+** ^Extension loading is off by default.
 ** ^Call the sqlite3_enable_load_extension() routine with onoff==1
 ** to turn extension loading on and call it with onoff==0 to turn
 ** it back off again.
 */
 int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
@@ -5025,11 +5072,11 @@
 /*
 ** CAPI3REF: Automatically Load Statically Linked Extensions
 **
 ** ^This interface causes the xEntryPoint() function to be invoked for
 ** each new [database connection] that is created.  The idea here is that
-** xEntryPoint() is the entry point for a statically linked SQLite extension
+** xEntryPoint() is the entry point for a statically linked [SQLite extension]
 ** that is to be automatically loaded into all new database connections.
 **
 ** ^(Even though the function prototype shows that xEntryPoint() takes
 ** no arguments and returns void, SQLite invokes xEntryPoint() with three
 ** arguments and expects and integer result as if the signature of the
@@ -6805,10 +6852,25 @@
 ** independence" that SQLite uses internally when comparing identifiers.
 */
 int sqlite3_stricmp(const char *, const char *);
 int sqlite3_strnicmp(const char *, const char *, int);
 
+/*
+** CAPI3REF: String Globbing
+*
+** ^The [sqlite3_strglob(P,X)] interface returns zero if string X matches
+** the glob pattern P, and it returns non-zero if string X does not match
+** the glob pattern P.  ^The definition of glob pattern matching used in
+** [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the
+** SQL dialect used by SQLite.  ^The sqlite3_strglob(P,X) function is case
+** sensitive.
+**
+** Note that this routine returns zero on a match and non-zero if the strings
+** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
+*/
+int sqlite3_strglob(const char *zGlob, const char *zStr);
+
 /*
 ** CAPI3REF: Error Logging Interface
 **
 ** ^The [sqlite3_log()] interface writes a message into the error log
 ** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].

Index: src/sqlite3ext.h
==================================================================
--- src/sqlite3ext.h
+++ src/sqlite3ext.h
@@ -467,9 +467,18 @@
 #define sqlite3_uri_parameter          sqlite3_api->uri_parameter
 #define sqlite3_uri_vsnprintf          sqlite3_api->vsnprintf
 #define sqlite3_wal_checkpoint_v2      sqlite3_api->wal_checkpoint_v2
 #endif /* SQLITE_CORE */
 
-#define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api = 0;
-#define SQLITE_EXTENSION_INIT2(v)  sqlite3_api = v;
+#ifndef SQLITE_CORE
+  /* This case when the file really is being compiled as a loadable 
+  ** extension */
+# define SQLITE_EXTENSION_INIT1     const sqlite3_api_routines *sqlite3_api=0;
+# define SQLITE_EXTENSION_INIT2(v)  sqlite3_api=v;
+#else
+  /* This case when the file is being statically linked into the 
+  ** application */
+# define SQLITE_EXTENSION_INIT1     /*no-op*/
+# define SQLITE_EXTENSION_INIT2(v)  (void)v; /* unused parameter */
+#endif
 
 #endif /* _SQLITE3EXT_H_ */

Index: src/sqliteInt.h
==================================================================
--- src/sqliteInt.h
+++ src/sqliteInt.h
@@ -120,15 +120,15 @@
 **
 ** Older versions of SQLite used an optional THREADSAFE macro.
 ** We support that for legacy.
 */
 #if !defined(SQLITE_THREADSAFE)
-#if defined(THREADSAFE)
-# define SQLITE_THREADSAFE THREADSAFE
-#else
-# define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
-#endif
+# if defined(THREADSAFE)
+#   define SQLITE_THREADSAFE THREADSAFE
+# else
+#   define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
+# endif
 #endif
 
 /*
 ** Powersafe overwrite is on by default.  But can be turned off using
 ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
@@ -390,10 +390,11 @@
 ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
 ** on the command-line
 */
 #ifndef SQLITE_TEMP_STORE
 # define SQLITE_TEMP_STORE 1
+# define SQLITE_TEMP_STORE_xc 1  /* Exclude from ctime.c */
 #endif
 
 /*
 ** GCC does not define the offsetof() macro so we'll have to do it
 ** ourselves.
@@ -537,10 +538,53 @@
 # define EIGHT_BYTE_ALIGNMENT(X)   ((((char*)(X) - (char*)0)&3)==0)
 #else
 # define EIGHT_BYTE_ALIGNMENT(X)   ((((char*)(X) - (char*)0)&7)==0)
 #endif
 
+/*
+** Disable MMAP on platforms where it is known to not work
+*/
+#if defined(__OpenBSD__) || defined(__QNXNTO__)
+# undef SQLITE_MAX_MMAP_SIZE
+# define SQLITE_MAX_MMAP_SIZE 0
+#endif
+
+/*
+** Default maximum size of memory used by memory-mapped I/O in the VFS
+*/
+#ifdef __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#   undef SQLITE_MAX_MMAP_SIZE
+#   define SQLITE_MAX_MMAP_SIZE 0
+# endif
+#endif
+#ifndef SQLITE_MAX_MMAP_SIZE
+# if defined(__linux__) \
+  || defined(_WIN32) \
+  || (defined(__APPLE__) && defined(__MACH__)) \
+  || defined(__sun)
+#   define SQLITE_MAX_MMAP_SIZE 2147483648
+# else
+#   define SQLITE_MAX_MMAP_SIZE 0
+# endif
+# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */
+#endif
+
+/*
+** The default MMAP_SIZE is zero on all platforms.  Or, even if a larger
+** default MMAP_SIZE is specified at compile-time, make sure that it does
+** not exceed the maximum mmap size.
+*/
+#ifndef SQLITE_DEFAULT_MMAP_SIZE
+# define SQLITE_DEFAULT_MMAP_SIZE 0
+# define SQLITE_DEFAULT_MMAP_SIZE_xc 1  /* Exclude from ctime.c */
+#endif
+#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE
+# undef SQLITE_DEFAULT_MMAP_SIZE
+# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
+#endif
 
 /*
 ** An instance of the following structure is used to store the busy-handler
 ** callback for a given sqlite handle. 
 **
@@ -833,10 +877,11 @@
   sqlite3_mutex *mutex;         /* Connection mutex */
   Db *aDb;                      /* All backends */
   int nDb;                      /* Number of backends currently in use */
   int flags;                    /* Miscellaneous flags. See below */
   i64 lastRowid;                /* ROWID of most recent insert (see above) */
+  i64 szMmap;                   /* Default mmap_size setting */
   unsigned int openFlags;       /* Flags passed to sqlite3_vfs.xOpen() */
   int errCode;                  /* Most recent error code (SQLITE_*) */
   int errMask;                  /* & result codes with this before returning */
   u16 dbOptFlags;               /* Flags to enable/disable optimizations */
   u8 autoCommit;                /* The auto-commit flag. */
@@ -2076,10 +2121,12 @@
 */
 #define NC_AllowAgg  0x01    /* Aggregate functions are allowed here */
 #define NC_HasAgg    0x02    /* One or more aggregate functions seen */
 #define NC_IsCheck   0x04    /* True if resolving names in a CHECK constraint */
 #define NC_InAggFunc 0x08    /* True if analyzing arguments to an agg func */
+#define NC_AsMaybe   0x10    /* Resolve to AS terms of the result set only
+                             ** if no other resolution is available */
 
 /*
 ** An instance of the following structure contains all information
 ** needed to generate code for a single SELECT statement.
 **
@@ -2515,10 +2562,12 @@
   sqlite3_mutex_methods mutex;      /* Low-level mutex interface */
   sqlite3_pcache_methods2 pcache2;  /* Low-level page-cache interface */
   void *pHeap;                      /* Heap storage space */
   int nHeap;                        /* Size of pHeap[] */
   int mnReq, mxReq;                 /* Min and max heap requests sizes */
+  sqlite3_int64 szMmap;             /* mmap() space per open file */
+  sqlite3_int64 mxMmap;             /* Maximum value for szMmap */
   void *pScratch;                   /* Scratch memory */
   int szScratch;                    /* Size of each scratch buffer */
   int nScratch;                     /* Number of scratch buffers */
   void *pPage;                      /* Page cache memory */
   int szPage;                       /* Size of each page in pPage[] */

Index: src/test1.c
==================================================================
--- src/test1.c
+++ src/test1.c
@@ -114,75 +114,80 @@
 }
 
 
 const char *sqlite3TestErrorName(int rc){
   const char *zName = 0;
-  switch( rc ){
-    case SQLITE_OK:                  zName = "SQLITE_OK";                break;
-    case SQLITE_ERROR:               zName = "SQLITE_ERROR";             break;
-    case SQLITE_INTERNAL:            zName = "SQLITE_INTERNAL";          break;
-    case SQLITE_PERM:                zName = "SQLITE_PERM";              break;
-    case SQLITE_ABORT:               zName = "SQLITE_ABORT";             break;
-    case SQLITE_BUSY:                zName = "SQLITE_BUSY";              break;
-    case SQLITE_LOCKED:              zName = "SQLITE_LOCKED";            break;
-    case SQLITE_LOCKED_SHAREDCACHE:  zName = "SQLITE_LOCKED_SHAREDCACHE";break;
-    case SQLITE_NOMEM:               zName = "SQLITE_NOMEM";             break;
-    case SQLITE_READONLY:            zName = "SQLITE_READONLY";          break;
-    case SQLITE_INTERRUPT:           zName = "SQLITE_INTERRUPT";         break;
-    case SQLITE_IOERR:               zName = "SQLITE_IOERR";             break;
-    case SQLITE_CORRUPT:             zName = "SQLITE_CORRUPT";           break;
-    case SQLITE_NOTFOUND:            zName = "SQLITE_NOTFOUND";          break;
-    case SQLITE_FULL:                zName = "SQLITE_FULL";              break;
-    case SQLITE_CANTOPEN:            zName = "SQLITE_CANTOPEN";          break;
-    case SQLITE_PROTOCOL:            zName = "SQLITE_PROTOCOL";          break;
-    case SQLITE_EMPTY:               zName = "SQLITE_EMPTY";             break;
-    case SQLITE_SCHEMA:              zName = "SQLITE_SCHEMA";            break;
-    case SQLITE_TOOBIG:              zName = "SQLITE_TOOBIG";            break;
-    case SQLITE_CONSTRAINT:          zName = "SQLITE_CONSTRAINT";        break;
-    case SQLITE_CONSTRAINT_UNIQUE:   zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
-    case SQLITE_CONSTRAINT_TRIGGER:  zName = "SQLITE_CONSTRAINT_TRIGGER";break;
-    case SQLITE_CONSTRAINT_FOREIGNKEY:
-                                 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
-    case SQLITE_CONSTRAINT_CHECK:    zName = "SQLITE_CONSTRAINT_CHECK";  break;
-    case SQLITE_CONSTRAINT_PRIMARYKEY:
-                                 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
-    case SQLITE_CONSTRAINT_NOTNULL:  zName = "SQLITE_CONSTRAINT_NOTNULL";break;
-    case SQLITE_CONSTRAINT_COMMITHOOK:
-                                 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
-    case SQLITE_CONSTRAINT_VTAB:     zName = "SQLITE_CONSTRAINT_VTAB";   break;
-    case SQLITE_CONSTRAINT_FUNCTION: zName = "SQLITE_CONSTRAINT_FUNCTION";break;
-    case SQLITE_MISMATCH:            zName = "SQLITE_MISMATCH";          break;
-    case SQLITE_MISUSE:              zName = "SQLITE_MISUSE";            break;
-    case SQLITE_NOLFS:               zName = "SQLITE_NOLFS";             break;
-    case SQLITE_AUTH:                zName = "SQLITE_AUTH";              break;
-    case SQLITE_FORMAT:              zName = "SQLITE_FORMAT";            break;
-    case SQLITE_RANGE:               zName = "SQLITE_RANGE";             break;
-    case SQLITE_NOTADB:              zName = "SQLITE_NOTADB";            break;
-    case SQLITE_ROW:                 zName = "SQLITE_ROW";               break;
-    case SQLITE_DONE:                zName = "SQLITE_DONE";              break;
-    case SQLITE_IOERR_READ:          zName = "SQLITE_IOERR_READ";        break;
-    case SQLITE_IOERR_SHORT_READ:    zName = "SQLITE_IOERR_SHORT_READ";  break;
-    case SQLITE_IOERR_WRITE:         zName = "SQLITE_IOERR_WRITE";       break;
-    case SQLITE_IOERR_FSYNC:         zName = "SQLITE_IOERR_FSYNC";       break;
-    case SQLITE_IOERR_DIR_FSYNC:     zName = "SQLITE_IOERR_DIR_FSYNC";   break;
-    case SQLITE_IOERR_TRUNCATE:      zName = "SQLITE_IOERR_TRUNCATE";    break;
-    case SQLITE_IOERR_FSTAT:         zName = "SQLITE_IOERR_FSTAT";       break;
-    case SQLITE_IOERR_UNLOCK:        zName = "SQLITE_IOERR_UNLOCK";      break;
-    case SQLITE_IOERR_RDLOCK:        zName = "SQLITE_IOERR_RDLOCK";      break;
-    case SQLITE_IOERR_DELETE:        zName = "SQLITE_IOERR_DELETE";      break;
-    case SQLITE_IOERR_BLOCKED:       zName = "SQLITE_IOERR_BLOCKED";     break;
-    case SQLITE_IOERR_NOMEM:         zName = "SQLITE_IOERR_NOMEM";       break;
-    case SQLITE_IOERR_ACCESS:        zName = "SQLITE_IOERR_ACCESS";      break;
-    case SQLITE_IOERR_CHECKRESERVEDLOCK:
-                               zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
-    case SQLITE_IOERR_LOCK:          zName = "SQLITE_IOERR_LOCK";        break;
-    case SQLITE_CORRUPT_VTAB:        zName = "SQLITE_CORRUPT_VTAB";      break;
-    case SQLITE_READONLY_RECOVERY:   zName = "SQLITE_READONLY_RECOVERY"; break;
-    case SQLITE_READONLY_CANTLOCK:   zName = "SQLITE_READONLY_CANTLOCK"; break;
-    case SQLITE_READONLY_ROLLBACK:   zName = "SQLITE_READONLY_ROLLBACK"; break;
-    default:                         zName = "SQLITE_Unknown";           break;
-  }
+  int i;
+  for(i=0; i<2 && zName==0; i++, rc &= 0xff){
+    switch( rc ){
+      case SQLITE_OK:                  zName = "SQLITE_OK";                break;
+      case SQLITE_ERROR:               zName = "SQLITE_ERROR";             break;
+      case SQLITE_INTERNAL:            zName = "SQLITE_INTERNAL";          break;
+      case SQLITE_PERM:                zName = "SQLITE_PERM";              break;
+      case SQLITE_ABORT:               zName = "SQLITE_ABORT";             break;
+      case SQLITE_BUSY:                zName = "SQLITE_BUSY";              break;
+      case SQLITE_LOCKED:              zName = "SQLITE_LOCKED";            break;
+      case SQLITE_LOCKED_SHAREDCACHE:  zName = "SQLITE_LOCKED_SHAREDCACHE";break;
+      case SQLITE_NOMEM:               zName = "SQLITE_NOMEM";             break;
+      case SQLITE_READONLY:            zName = "SQLITE_READONLY";          break;
+      case SQLITE_INTERRUPT:           zName = "SQLITE_INTERRUPT";         break;
+      case SQLITE_IOERR:               zName = "SQLITE_IOERR";             break;
+      case SQLITE_CORRUPT:             zName = "SQLITE_CORRUPT";           break;
+      case SQLITE_NOTFOUND:            zName = "SQLITE_NOTFOUND";          break;
+      case SQLITE_FULL:                zName = "SQLITE_FULL";              break;
+      case SQLITE_CANTOPEN:            zName = "SQLITE_CANTOPEN";          break;
+      case SQLITE_PROTOCOL:            zName = "SQLITE_PROTOCOL";          break;
+      case SQLITE_EMPTY:               zName = "SQLITE_EMPTY";             break;
+      case SQLITE_SCHEMA:              zName = "SQLITE_SCHEMA";            break;
+      case SQLITE_TOOBIG:              zName = "SQLITE_TOOBIG";            break;
+      case SQLITE_CONSTRAINT:          zName = "SQLITE_CONSTRAINT";        break;
+      case SQLITE_CONSTRAINT_UNIQUE:   zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
+      case SQLITE_CONSTRAINT_TRIGGER:  zName = "SQLITE_CONSTRAINT_TRIGGER";break;
+      case SQLITE_CONSTRAINT_FOREIGNKEY:
+                                   zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
+      case SQLITE_CONSTRAINT_CHECK:    zName = "SQLITE_CONSTRAINT_CHECK";  break;
+      case SQLITE_CONSTRAINT_PRIMARYKEY:
+                                   zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
+      case SQLITE_CONSTRAINT_NOTNULL:  zName = "SQLITE_CONSTRAINT_NOTNULL";break;
+      case SQLITE_CONSTRAINT_COMMITHOOK:
+                                   zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
+      case SQLITE_CONSTRAINT_VTAB:     zName = "SQLITE_CONSTRAINT_VTAB";   break;
+      case SQLITE_CONSTRAINT_FUNCTION: zName = "SQLITE_CONSTRAINT_FUNCTION";break;
+      case SQLITE_MISMATCH:            zName = "SQLITE_MISMATCH";          break;
+      case SQLITE_MISUSE:              zName = "SQLITE_MISUSE";            break;
+      case SQLITE_NOLFS:               zName = "SQLITE_NOLFS";             break;
+      case SQLITE_AUTH:                zName = "SQLITE_AUTH";              break;
+      case SQLITE_FORMAT:              zName = "SQLITE_FORMAT";            break;
+      case SQLITE_RANGE:               zName = "SQLITE_RANGE";             break;
+      case SQLITE_NOTADB:              zName = "SQLITE_NOTADB";            break;
+      case SQLITE_ROW:                 zName = "SQLITE_ROW";               break;
+      case SQLITE_NOTICE:              zName = "SQLITE_NOTICE";            break;
+      case SQLITE_WARNING:             zName = "SQLITE_WARNING";           break;
+      case SQLITE_DONE:                zName = "SQLITE_DONE";              break;
+      case SQLITE_IOERR_READ:          zName = "SQLITE_IOERR_READ";        break;
+      case SQLITE_IOERR_SHORT_READ:    zName = "SQLITE_IOERR_SHORT_READ";  break;
+      case SQLITE_IOERR_WRITE:         zName = "SQLITE_IOERR_WRITE";       break;
+      case SQLITE_IOERR_FSYNC:         zName = "SQLITE_IOERR_FSYNC";       break;
+      case SQLITE_IOERR_DIR_FSYNC:     zName = "SQLITE_IOERR_DIR_FSYNC";   break;
+      case SQLITE_IOERR_TRUNCATE:      zName = "SQLITE_IOERR_TRUNCATE";    break;
+      case SQLITE_IOERR_FSTAT:         zName = "SQLITE_IOERR_FSTAT";       break;
+      case SQLITE_IOERR_UNLOCK:        zName = "SQLITE_IOERR_UNLOCK";      break;
+      case SQLITE_IOERR_RDLOCK:        zName = "SQLITE_IOERR_RDLOCK";      break;
+      case SQLITE_IOERR_DELETE:        zName = "SQLITE_IOERR_DELETE";      break;
+      case SQLITE_IOERR_BLOCKED:       zName = "SQLITE_IOERR_BLOCKED";     break;
+      case SQLITE_IOERR_NOMEM:         zName = "SQLITE_IOERR_NOMEM";       break;
+      case SQLITE_IOERR_ACCESS:        zName = "SQLITE_IOERR_ACCESS";      break;
+      case SQLITE_IOERR_CHECKRESERVEDLOCK:
+                                 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
+      case SQLITE_IOERR_LOCK:          zName = "SQLITE_IOERR_LOCK";        break;
+      case SQLITE_CORRUPT_VTAB:        zName = "SQLITE_CORRUPT_VTAB";      break;
+      case SQLITE_READONLY_RECOVERY:   zName = "SQLITE_READONLY_RECOVERY"; break;
+      case SQLITE_READONLY_CANTLOCK:   zName = "SQLITE_READONLY_CANTLOCK"; break;
+      case SQLITE_READONLY_ROLLBACK:   zName = "SQLITE_READONLY_ROLLBACK"; break;
+    }
+  }
+  if( zName==0 ) zName = "SQLITE_Unknown";
   return zName;
 }
 #define t1ErrorName sqlite3TestErrorName
 
 /*
@@ -5841,10 +5846,35 @@
   }
 
   Tcl_ResetResult(interp);
   return TCL_OK;
 }
+
+#if SQLITE_OS_UNIX
+#include <sys/time.h>
+#include <sys/resource.h>
+
+static int test_getrusage(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  char buf[1024];
+  struct rusage r;
+  memset(&r, 0, sizeof(r));
+  getrusage(RUSAGE_SELF, &r);
+
+  sprintf(buf, "ru_utime=%d.%06d ru_stime=%d.%06d ru_minflt=%d ru_majflt=%d", 
+    (int)r.ru_utime.tv_sec, (int)r.ru_utime.tv_usec, 
+    (int)r.ru_stime.tv_sec, (int)r.ru_stime.tv_usec, 
+    (int)r.ru_minflt, (int)r.ru_majflt
+  );
+  Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, -1));
+  return TCL_OK;
+}
+#endif
 
 #if SQLITE_OS_WIN
 /*
 ** Information passed from the main thread into the windows file locker
 ** background thread.
@@ -6231,10 +6261,13 @@
      { "test_sqlite3_log",         test_sqlite3_log, 0  },
 #ifndef SQLITE_OMIT_EXPLAIN
      { "print_explain_query_plan", test_print_eqp, 0  },
 #endif
      { "sqlite3_test_control", test_test_control },
+#if SQLITE_OS_UNIX
+     { "getrusage", test_getrusage },
+#endif
   };
   static int bitmask_size = sizeof(Bitmask)*8;
   int i;
   extern int sqlite3_sync_count, sqlite3_fullsync_count;
   extern int sqlite3_opentemp_count;

Index: src/test2.c
==================================================================
--- src/test2.c
+++ src/test2.c
@@ -17,39 +17,11 @@
 #include "tcl.h"
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
 
-/*
-** Interpret an SQLite error number
-*/
-static char *errorName(int rc){
-  char *zName;
-  switch( rc ){
-    case SQLITE_OK:         zName = "SQLITE_OK";          break;
-    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
-    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
-    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
-    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
-    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
-    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
-    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
-    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
-    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
-    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
-    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
-    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
-    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
-    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
-    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
-    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
-    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
-    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
-    default:                zName = "SQLITE_Unknown";     break;
-  }
-  return zName;
-}
+extern const char *sqlite3TestErrorName(int rc);
 
 /*
 ** Page size and reserved size used for testing.
 */
 static int test_pagesize = 1024;
@@ -85,11 +57,11 @@
   if( Tcl_GetInt(interp, argv[2], &nPage) ) return TCL_ERROR;
   rc = sqlite3PagerOpen(sqlite3_vfs_find(0), &pPager, argv[1], 0, 0,
       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB,
       pager_test_reiniter);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   sqlite3PagerSetCachesize(pPager, nPage);
   pageSize = test_pagesize;
   sqlite3PagerSetPagesize(pPager, &pageSize, -1);
@@ -117,11 +89,11 @@
     return TCL_ERROR;
   }
   pPager = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerClose(pPager);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -144,11 +116,11 @@
     return TCL_ERROR;
   }
   pPager = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerRollback(pPager);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -171,16 +143,16 @@
     return TCL_ERROR;
   }
   pPager = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerCommitPhaseOne(pPager, 0, 0);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   rc = sqlite3PagerCommitPhaseTwo(pPager);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -203,11 +175,11 @@
     return TCL_ERROR;
   }
   pPager = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerOpenSavepoint(pPager, 1);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -231,11 +203,11 @@
   }
   pPager = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, 0);
   sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -258,11 +230,11 @@
     return TCL_ERROR;
   }
   pPager = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_RELEASE, 0);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -351,11 +323,11 @@
   rc = sqlite3PagerSharedLock(pPager);
   if( rc==SQLITE_OK ){
     rc = sqlite3PagerGet(pPager, pgno, &pPage);
   }
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   sqlite3_snprintf(sizeof(zBuf),zBuf,"%p",pPage);
   Tcl_AppendResult(interp, zBuf, 0);
   return TCL_OK;
@@ -505,11 +477,11 @@
     return TCL_ERROR;
   }
   pPage = (DbPage *)sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3PagerWrite(pPage);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   pData = sqlite3PagerGetData(pPage);
   strncpy(pData, argv[2], test_pagesize-1);
   pData[test_pagesize-1] = 0;
@@ -554,21 +526,21 @@
   zFile[nFile+1] = 0;
   rc = sqlite3OsOpenMalloc(pVfs, zFile, &fd, 
       (SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_DB), 0
   );
   if( rc ){
-    Tcl_AppendResult(interp, "open failed: ", errorName(rc), 0);
+    Tcl_AppendResult(interp, "open failed: ", sqlite3TestErrorName(rc), 0);
     sqlite3_free(zFile);
     return TCL_ERROR;
   }
   offset = n;
   offset *= 1024*1024;
   rc = sqlite3OsWrite(fd, "Hello, World!", 14, offset);
   sqlite3OsCloseFree(fd);
   sqlite3_free(zFile);
   if( rc ){
-    Tcl_AppendResult(interp, "write failed: ", errorName(rc), 0);
+    Tcl_AppendResult(interp, "write failed: ", sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 #endif

Index: src/test3.c
==================================================================
--- src/test3.c
+++ src/test3.c
@@ -17,35 +17,11 @@
 #include "btreeInt.h"
 #include "tcl.h"
 #include <stdlib.h>
 #include <string.h>
 
-/*
-** Interpret an SQLite error number
-*/
-static char *errorName(int rc){
-  char *zName;
-  switch( rc ){
-    case SQLITE_OK:         zName = "SQLITE_OK";          break;
-    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
-    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
-    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
-    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
-    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
-    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
-    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
-    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
-    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
-    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
-    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
-    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
-    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
-    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
-    default:                zName = "SQLITE_Unknown";     break;
-  }
-  return zName;
-}
+extern const char *sqlite3TestErrorName(int rc);
 
 /*
 ** A bogus sqlite3 connection structure for use in the btree
 ** tests.
 */
@@ -87,11 +63,11 @@
   zFilename[n+1] = 0;
   rc = sqlite3BtreeOpen(sDb.pVfs, zFilename, &sDb, &pBt, 0, 
      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB);
   sqlite3_free(zFilename);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   sqlite3BtreeSetCacheSize(pBt, nCache);
   sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pBt);
   Tcl_AppendResult(interp, zBuf, 0);
@@ -117,11 +93,11 @@
     return TCL_ERROR;
   }
   pBt = sqlite3TestTextToPtr(argv[1]);
   rc = sqlite3BtreeClose(pBt);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   nRefSqlite3--;
   if( nRefSqlite3==0 ){
     sqlite3_mutex_leave(sDb.mutex);
@@ -154,11 +130,11 @@
   pBt = sqlite3TestTextToPtr(argv[1]);
   sqlite3BtreeEnter(pBt);
   rc = sqlite3BtreeBeginTrans(pBt, 1);
   sqlite3BtreeLeave(pBt);
   if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return TCL_OK;
 }
 
@@ -248,11 +224,11 @@
     rc = sqlite3BtreeCursor(pBt, iTable, wrFlag, 0, pCur);
   }
   sqlite3BtreeLeave(pBt);
   if( rc ){
     ckfree((char *)pCur);
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pCur);
   Tcl_AppendResult(interp, zBuf, 0);
   return SQLITE_OK;
@@ -283,11 +259,11 @@
   sqlite3BtreeEnter(pBt);
   rc = sqlite3BtreeCloseCursor(pCur);
   sqlite3BtreeLeave(pBt);
   ckfree((char *)pCur);
   if( rc ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   return SQLITE_OK;
 }
 
@@ -317,11 +293,11 @@
   pCur = sqlite3TestTextToPtr(argv[1]);
   sqlite3BtreeEnter(pCur->pBtree);
   rc = sqlite3BtreeNext(pCur, &res);
   sqlite3BtreeLeave(pCur->pBtree);
   if( rc ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
   Tcl_AppendResult(interp, zBuf, 0);
   return SQLITE_OK;
@@ -352,11 +328,11 @@
   pCur = sqlite3TestTextToPtr(argv[1]);
   sqlite3BtreeEnter(pCur->pBtree);
   rc = sqlite3BtreeFirst(pCur, &res);
   sqlite3BtreeLeave(pCur->pBtree);
   if( rc ){
-    Tcl_AppendResult(interp, errorName(rc), 0);
+    Tcl_AppendResult(interp, sqlite3TestErrorName(rc), 0);
     return TCL_ERROR;
   }
   sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
   Tcl_AppendResult(interp, zBuf, 0);
   return SQLITE_OK;

Index: src/test4.c
==================================================================
--- src/test4.c
+++ src/test4.c
@@ -18,10 +18,12 @@
 #include <string.h>
 #include <pthread.h>
 #include <sched.h>
 #include <ctype.h>
 
+extern const char *sqlite3TestErrorName(int rc);
+
 /*
 ** Each thread is controlled by an instance of the following
 ** structure.
 */
 typedef struct Thread Thread;
@@ -370,38 +372,11 @@
   if( !threadset[i].busy ){
     Tcl_AppendResult(interp, "no such thread", 0);
     return TCL_ERROR;
   }
   thread_wait(&threadset[i]);
-  switch( threadset[i].rc ){
-    case SQLITE_OK:         zName = "SQLITE_OK";          break;
-    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
-    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
-    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
-    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
-    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
-    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
-    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
-    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
-    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
-    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
-    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
-    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
-    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
-    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
-    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
-    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
-    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
-    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
-    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
-    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
-    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
-    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
-    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
-    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
-    default:                zName = "SQLITE_Unknown";     break;
-  }
+  zName = sqlite3TestErrorName(threadset[i].rc);
   Tcl_AppendResult(interp, zName, 0);
   return TCL_OK;
 }
 
 /*

Index: src/test7.c
==================================================================
--- src/test7.c
+++ src/test7.c
@@ -374,10 +374,12 @@
   }
   Tcl_AppendResult(interp, threadset[i].colv[n], 0);
   return TCL_OK;
 }
 
+extern const char *sqlite3TestErrorName(int rc);
+
 /*
 ** Usage: client_result  ID
 **
 ** Wait on the most recent operation to complete, then return the
 ** result code from that operation.
@@ -401,38 +403,11 @@
   if( !threadset[i].busy ){
     Tcl_AppendResult(interp, "no such thread", 0);
     return TCL_ERROR;
   }
   client_wait(&threadset[i]);
-  switch( threadset[i].rc ){
-    case SQLITE_OK:         zName = "SQLITE_OK";          break;
-    case SQLITE_ERROR:      zName = "SQLITE_ERROR";       break;
-    case SQLITE_PERM:       zName = "SQLITE_PERM";        break;
-    case SQLITE_ABORT:      zName = "SQLITE_ABORT";       break;
-    case SQLITE_BUSY:       zName = "SQLITE_BUSY";        break;
-    case SQLITE_LOCKED:     zName = "SQLITE_LOCKED";      break;
-    case SQLITE_NOMEM:      zName = "SQLITE_NOMEM";       break;
-    case SQLITE_READONLY:   zName = "SQLITE_READONLY";    break;
-    case SQLITE_INTERRUPT:  zName = "SQLITE_INTERRUPT";   break;
-    case SQLITE_IOERR:      zName = "SQLITE_IOERR";       break;
-    case SQLITE_CORRUPT:    zName = "SQLITE_CORRUPT";     break;
-    case SQLITE_FULL:       zName = "SQLITE_FULL";        break;
-    case SQLITE_CANTOPEN:   zName = "SQLITE_CANTOPEN";    break;
-    case SQLITE_PROTOCOL:   zName = "SQLITE_PROTOCOL";    break;
-    case SQLITE_EMPTY:      zName = "SQLITE_EMPTY";       break;
-    case SQLITE_SCHEMA:     zName = "SQLITE_SCHEMA";      break;
-    case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT";  break;
-    case SQLITE_MISMATCH:   zName = "SQLITE_MISMATCH";    break;
-    case SQLITE_MISUSE:     zName = "SQLITE_MISUSE";      break;
-    case SQLITE_NOLFS:      zName = "SQLITE_NOLFS";       break;
-    case SQLITE_AUTH:       zName = "SQLITE_AUTH";        break;
-    case SQLITE_FORMAT:     zName = "SQLITE_FORMAT";      break;
-    case SQLITE_RANGE:      zName = "SQLITE_RANGE";       break;
-    case SQLITE_ROW:        zName = "SQLITE_ROW";         break;
-    case SQLITE_DONE:       zName = "SQLITE_DONE";        break;
-    default:                zName = "SQLITE_Unknown";     break;
-  }
+  zName = sqlite3TestErrorName(threadset[i].rc);
   Tcl_AppendResult(interp, zName, 0);
   return TCL_OK;
 }
 
 /*

Index: src/test_autoext.c
==================================================================
--- src/test_autoext.c
+++ src/test_autoext.c
@@ -13,11 +13,11 @@
 */
 #include "tcl.h"
 #include "sqlite3ext.h"
 
 #ifndef SQLITE_OMIT_LOAD_EXTENSION
-static SQLITE_EXTENSION_INIT1
+SQLITE_EXTENSION_INIT1
 
 /*
 ** The sqr() SQL function returns the square of its input value.
 */
 static void sqrFunc(

Index: src/test_config.c
==================================================================
--- src/test_config.c
+++ src/test_config.c
@@ -55,11 +55,11 @@
   Tcl_SetVar2(interp, "sqlite_options","casesensitivelike","1",TCL_GLOBAL_ONLY);
 #else
   Tcl_SetVar2(interp, "sqlite_options","casesensitivelike","0",TCL_GLOBAL_ONLY);
 #endif
 
-#ifdef SQLITE_CURDIR
+#if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT
   Tcl_SetVar2(interp, "sqlite_options", "curdir", "1", TCL_GLOBAL_ONLY);
 #else
   Tcl_SetVar2(interp, "sqlite_options", "curdir", "0", TCL_GLOBAL_ONLY);
 #endif
 
@@ -84,10 +84,16 @@
 #ifdef SQLITE_DISABLE_LFS
   Tcl_SetVar2(interp, "sqlite_options", "lfs", "0", TCL_GLOBAL_ONLY);
 #else
   Tcl_SetVar2(interp, "sqlite_options", "lfs", "1", TCL_GLOBAL_ONLY);
 #endif
+
+#if SQLITE_MAX_MMAP_SIZE>0
+  Tcl_SetVar2(interp, "sqlite_options", "mmap", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "mmap", "0", TCL_GLOBAL_ONLY);
+#endif
 
 #if 1 /* def SQLITE_MEMDEBUG */
   Tcl_SetVar2(interp, "sqlite_options", "memdebug", "1", TCL_GLOBAL_ONLY);
 #else
   Tcl_SetVar2(interp, "sqlite_options", "memdebug", "0", TCL_GLOBAL_ONLY);

Index: src/test_sqllog.c
==================================================================
--- src/test_sqllog.c
+++ src/test_sqllog.c
@@ -11,26 +11,36 @@
 *************************************************************************
 **
 ** OVERVIEW
 **
 **   This file contains experimental code used to record data from live
-**   SQLite applications that may be useful for offline analysis. Specifically:
+**   SQLite applications that may be useful for offline analysis. 
+**   Specifically, this module can be used to capture the following
+**   information:
 **
 **     1) The initial contents of all database files opened by the 
 **        application, and
 **
 **     2) All SQL statements executed by the application.
 **
+**   The captured information can then be used to run (for example)
+**   performance analysis looking for slow queries or to look for
+**   optimization opportunities in either the application or in SQLite
+**   itself.
+**
 ** USAGE
 **
 **   To use this module, SQLite must be compiled with the SQLITE_ENABLE_SQLLOG
-**   pre-processor symbol defined and this file linked into the application
-**   somehow.
+**   pre-processor symbol defined and this file linked into the application.
+**   One way to link this file into the application is to append the content
+**   of this file onto the end of the "sqlite3.c" amalgamation and then 
+**   recompile the application as normal except with the addition  of the
+**   -DSQLITE_ENABLE_SQLLOG option.
 **
 **   At runtime, logging is enabled by setting environment variable
 **   SQLITE_SQLLOG_DIR to the name of a directory in which to store logged 
-**   data. The directory must already exist.
+**   data. The logging directory must already exist.
 **
 **   Usually, if the application opens the same database file more than once
 **   (either by attaching it or by using more than one database handle), only
 **   a single copy is made. This behavior may be overridden (so that a 
 **   separate copy is taken each time the database file is opened or attached)
@@ -55,27 +65,29 @@
 **   IO or other error is encountered. For example, if a log file cannot 
 **   be opened logs are not collected for that connection, but other
 **   logging proceeds as expected. Errors are logged by calling sqlite3_log().
 */
 
+#ifndef _SQLITE3_H_
 #include "sqlite3.h"
-#include "stdio.h"
-#include "stdlib.h"
-#include "string.h"
-#include "assert.h"
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
 
-#include "sys/types.h"
-#include "unistd.h"
+#include <sys/types.h>
+#include <unistd.h>
 static int getProcessId(void){
 #if SQLITE_OS_WIN
   return (int)_getpid();
 #else
   return (int)getpid();
 #endif
 }
 
-
+/* Names of environment variables to be used */
 #define ENVIRONMENT_VARIABLE1_NAME "SQLITE_SQLLOG_DIR"
 #define ENVIRONMENT_VARIABLE2_NAME "SQLITE_SQLLOG_REUSE_FILES"
 
 /* Assume that all database and database file names are shorted than this. */
 #define SQLLOG_NAMESZ 512
@@ -84,18 +96,23 @@
 ** open (if any more are opened an error is logged using sqlite3_log()
 ** and processing is halted).
 */
 #define MAX_CONNECTIONS 256
 
+/* There is one instance of this object for each SQLite database connection
+** that is being logged.
+*/
 struct SLConn {
   int isErr;                      /* True if an error has occurred */
   sqlite3 *db;                    /* Connection handle */
   int iLog;                       /* First integer value used in file names */
   FILE *fd;                       /* File descriptor for log file */
 };
 
-struct SLGlobal {
+/* This object is a singleton that keeps track of all data loggers.
+*/
+static struct SLGlobal {
   /* Protected by MUTEX_STATIC_MASTER */
   sqlite3_mutex *mutex;           /* Recursive mutex */
   int nConn;                      /* Size of aConn[] array */
 
   /* Protected by SLGlobal.mutex */
@@ -386,10 +403,28 @@
   }
 }
 
 /*
 ** The SQLITE_CONFIG_SQLLOG callback registered by sqlite3_init_sqllog().
+**
+** The eType parameter has the following values:
+**
+**    0:  Opening a new database connection.  zSql is the name of the
+**        file being opened.  db is a pointer to the newly created database
+**        connection.
+**
+**    1:  An SQL statement has run to completion.  zSql is the text of the
+**        SQL statement with all parameters expanded to their actual values.
+**
+**    2:  Closing a database connection.  zSql is NULL.  The db pointer to
+**        the database connection being closed has already been shut down
+**        and cannot be used for any further SQL.
+**
+** The pCtx parameter is a copy of the pointer that was originally passed
+** into the sqlite3_config(SQLITE_CONFIG_SQLLOG) statement.  In this
+** particular implementation, pCtx is always a pointer to the 
+** sqllogglobal global variable define above.
 */
 static void testSqllog(void *pCtx, sqlite3 *db, const char *zSql, int eType){
   struct SLConn *p = 0;
   sqlite3_mutex *master = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_MASTER);
 

Index: src/test_syscall.c
==================================================================
--- src/test_syscall.c
+++ src/test_syscall.c
@@ -21,11 +21,11 @@
 **     LIST must be a list consisting of zero or more of the following
 **     literal values:
 **
 **         open        close      access   getcwd   stat      fstat    
 **         ftruncate   fcntl      read     pread    pread64   write
-**         pwrite      pwrite64   fchmod   fallocate
+**         pwrite      pwrite64   fchmod   fallocate mmap
 **
 **   test_syscall uninstall
 **     Uninstall all wrapper functions.
 **
 **   test_syscall fault ?COUNT PERSIST?
@@ -79,10 +79,11 @@
 #if SQLITE_OS_UNIX
 
 /* From test1.c */
 extern const char *sqlite3TestErrorName(int);
 
+#include <sys/mman.h>
 #include <sys/types.h>
 #include <errno.h>
 
 static struct TestSyscallGlobal {
   int bPersist;                   /* 1 for persistent errors, 0 for transient */
@@ -104,11 +105,12 @@
 static int ts_write(int fd, const void *aBuf, size_t nBuf);
 static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off);
 static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off);
 static int ts_fchmod(int fd, mode_t mode);
 static int ts_fallocate(int fd, off_t off, off_t len);
-
+static void *ts_mmap(void *, size_t, int, int, int, off_t);
+static void *ts_mremap(void*, size_t, size_t, int, ...);
 
 struct TestSyscallArray {
   const char *zName;
   sqlite3_syscall_ptr xTest;
   sqlite3_syscall_ptr xOrig;
@@ -129,10 +131,12 @@
   /* 11 */ { "write",     (sqlite3_syscall_ptr)ts_write,     0, 0, 0 },
   /* 12 */ { "pwrite",    (sqlite3_syscall_ptr)ts_pwrite,    0, 0, 0 },
   /* 13 */ { "pwrite64",  (sqlite3_syscall_ptr)ts_pwrite64,  0, 0, 0 },
   /* 14 */ { "fchmod",    (sqlite3_syscall_ptr)ts_fchmod,    0, 0, 0 },
   /* 15 */ { "fallocate", (sqlite3_syscall_ptr)ts_fallocate, 0, 0, 0 },
+  /* 16 */ { "mmap",      (sqlite3_syscall_ptr)ts_mmap,      0, 0, 0 },
+  /* 17 */ { "mremap",    (sqlite3_syscall_ptr)ts_mremap,    0, 0, 0 },
            { 0, 0, 0, 0, 0 }
 };
 
 #define orig_open      ((int(*)(const char *, int, int))aSyscall[0].xOrig)
 #define orig_close     ((int(*)(int))aSyscall[1].xOrig)
@@ -150,10 +154,12 @@
                        aSyscall[12].xOrig)
 #define orig_pwrite64  ((ssize_t(*)(int,const void*,size_t,off_t))\
                        aSyscall[13].xOrig)
 #define orig_fchmod    ((int(*)(int,mode_t))aSyscall[14].xOrig)
 #define orig_fallocate ((int(*)(int,off_t,off_t))aSyscall[15].xOrig)
+#define orig_mmap      ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[16].xOrig)
+#define orig_mremap    ((void*(*)(void*,size_t,size_t,int,...))aSyscall[17].xOrig)
 
 /*
 ** This function is called exactly once from within each invocation of a
 ** system call wrapper in this file. It returns 1 if the function should
 ** fail, or 0 if it should succeed.
@@ -374,10 +380,35 @@
   if( tsIsFail() ){
     return tsErrno("fallocate");
   }
   return orig_fallocate(fd, off, len);
 }
+
+static void *ts_mmap(
+  void *pAddr, 
+  size_t nByte, 
+  int prot, 
+  int flags, 
+  int fd, 
+  off_t iOff
+){
+  if( tsIsFailErrno("mmap") ){
+    return MAP_FAILED;
+  }
+  return orig_mmap(pAddr, nByte, prot, flags, fd, iOff);
+}
+
+static void *ts_mremap(void *a, size_t b, size_t c, int d, ...){
+  va_list ap;
+  void *pArg;
+  if( tsIsFailErrno("mremap") ){
+    return MAP_FAILED;
+  }
+  va_start(ap, d);
+  pArg = va_arg(ap, void *);
+  return orig_mremap(a, b, c, d, pArg);
+}
 
 static int test_syscall_install(
   void * clientData,
   Tcl_Interp *interp,
   int objc,

Index: src/test_vfs.c
==================================================================
--- src/test_vfs.c
+++ src/test_vfs.c
@@ -123,12 +123,13 @@
 #define TESTVFS_WRITE_MASK        0x00001000
 #define TESTVFS_TRUNCATE_MASK     0x00002000
 #define TESTVFS_ACCESS_MASK       0x00004000
 #define TESTVFS_FULLPATHNAME_MASK 0x00008000
 #define TESTVFS_READ_MASK         0x00010000
+#define TESTVFS_UNLOCK_MASK       0x00020000
 
-#define TESTVFS_ALL_MASK          0x0001FFFF
+#define TESTVFS_ALL_MASK          0x0003FFFF
 
 
 #define TESTVFS_MAX_PAGES 1024
 
 /*
@@ -465,12 +466,16 @@
 
 /*
 ** Unlock an tvfs-file.
 */
 static int tvfsUnlock(sqlite3_file *pFile, int eLock){
-  TestvfsFd *p = tvfsGetFd(pFile);
-  return sqlite3OsUnlock(p->pReal, eLock);
+  TestvfsFd *pFd = tvfsGetFd(pFile);
+  Testvfs *p = (Testvfs *)pFd->pVfs->pAppData;
+  if( p->mask&TESTVFS_WRITE_MASK && tvfsInjectIoerr(p) ){
+    return SQLITE_IOERR_UNLOCK;
+  }
+  return sqlite3OsUnlock(pFd->pReal, eLock);
 }
 
 /*
 ** Check if another file-handle holds a RESERVED lock on an tvfs-file.
 */
@@ -1099,10 +1104,11 @@
         { "xTruncate",     TESTVFS_TRUNCATE_MASK },
         { "xOpen",         TESTVFS_OPEN_MASK },
         { "xClose",        TESTVFS_CLOSE_MASK },
         { "xAccess",       TESTVFS_ACCESS_MASK },
         { "xFullPathname", TESTVFS_FULLPATHNAME_MASK },
+        { "xUnlock",       TESTVFS_UNLOCK_MASK },
       };
       Tcl_Obj **apElem = 0;
       int nElem = 0;
       int i;
       int mask = 0;

Index: src/vdbe.c
==================================================================
--- src/vdbe.c
+++ src/vdbe.c
@@ -3523,11 +3523,11 @@
       **     r.flags = UNPACKED_INCRKEY;
       **   }else{
       **     r.flags = 0;
       **   }
       */
-      r.flags = (u16)(UNPACKED_INCRKEY * (1 & (oc - OP_SeekLt)));
+      r.flags = (u8)(UNPACKED_INCRKEY * (1 & (oc - OP_SeekLt)));
       assert( oc!=OP_SeekGt || r.flags==UNPACKED_INCRKEY );
       assert( oc!=OP_SeekLe || r.flags==UNPACKED_INCRKEY );
       assert( oc!=OP_SeekGe || r.flags==0 );
       assert( oc!=OP_SeekLt || r.flags==0 );
 

Index: src/vdbeInt.h
==================================================================
--- src/vdbeInt.h
+++ src/vdbeInt.h
@@ -16,10 +16,18 @@
 ** this header information was factored out.
 */
 #ifndef _VDBEINT_H_
 #define _VDBEINT_H_
 
+/*
+** The maximum number of times that a statement will try to reparse
+** itself before giving up and returning SQLITE_SCHEMA.
+*/
+#ifndef SQLITE_MAX_SCHEMA_RETRY
+# define SQLITE_MAX_SCHEMA_RETRY 50
+#endif
+
 /*
 ** SQL is translated into a sequence of instructions to be
 ** executed by a virtual machine.  Each instruction is an instance
 ** of the following structure.
 */

Index: src/vdbeapi.c
==================================================================
--- src/vdbeapi.c
+++ src/vdbeapi.c
@@ -451,18 +451,10 @@
     rc = sqlite3VdbeTransferError(p);
   }
   return (rc&db->errMask);
 }
 
-/*
-** The maximum number of times that a statement will try to reparse
-** itself before giving up and returning SQLITE_SCHEMA.
-*/
-#ifndef SQLITE_MAX_SCHEMA_RETRY
-# define SQLITE_MAX_SCHEMA_RETRY 5
-#endif
-
 /*
 ** This is the top-level implementation of sqlite3_step().  Call
 ** sqlite3Step() to do most of the work.  If a schema error occurs,
 ** call sqlite3Reprepare() and try again.
 */

Index: src/vdbeblob.c
==================================================================
--- src/vdbeblob.c
+++ src/vdbeblob.c
@@ -315,11 +315,11 @@
     if( db->mallocFailed ){
       goto blob_open_out;
     }
     sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
     rc = blobSeekToRow(pBlob, iRow, &zErr);
-  } while( (++nAttempt)<5 && rc==SQLITE_SCHEMA );
+  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );
 
 blob_open_out:
   if( rc==SQLITE_OK && db->mallocFailed==0 ){
     *ppBlob = (sqlite3_blob *)pBlob;
   }else{

Index: src/vdbetrace.c
==================================================================
--- src/vdbetrace.c
+++ src/vdbetrace.c
@@ -50,10 +50,15 @@
 ** obtained from sqlite3DbMalloc(). If sqlite3.vdbeExecCnt is 1, then the
 ** string contains a copy of zRawSql but with host parameters expanded to 
 ** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1, 
 ** then the returned string holds a copy of zRawSql with "-- " prepended
 ** to each line of text.
+**
+** If the SQLITE_TRACE_SIZE_LIMIT macro is defined to an integer, then
+** then long strings and blobs are truncated to that many bytes.  This
+** can be used to prevent unreasonably large trace strings when dealing
+** with large (multi-megabyte) strings and blobs.
 **
 ** The calling function is responsible for making sure the memory returned
 ** is eventually freed.
 **
 ** ALGORITHM:  Scan the input string looking for host parameters in any of
@@ -121,34 +126,53 @@
       }else if( pVar->flags & MEM_Int ){
         sqlite3XPrintf(&out, "%lld", pVar->u.i);
       }else if( pVar->flags & MEM_Real ){
         sqlite3XPrintf(&out, "%!.15g", pVar->r);
       }else if( pVar->flags & MEM_Str ){
+        int nOut;  /* Number of bytes of the string text to include in output */
 #ifndef SQLITE_OMIT_UTF16
         u8 enc = ENC(db);
+        Mem utf8;
         if( enc!=SQLITE_UTF8 ){
-          Mem utf8;
           memset(&utf8, 0, sizeof(utf8));
           utf8.db = db;
           sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
           sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8);
-          sqlite3XPrintf(&out, "'%.*q'", utf8.n, utf8.z);
-          sqlite3VdbeMemRelease(&utf8);
-        }else
+          pVar = &utf8;
+        }
 #endif
-        {
-          sqlite3XPrintf(&out, "'%.*q'", pVar->n, pVar->z);
+        nOut = pVar->n;
+#ifdef SQLITE_TRACE_SIZE_LIMIT
+        if( n>SQLITE_TRACE_SIZE_LIMIT ){
+          nOut = SQLITE_TRACE_SIZE_LIMIT;
+          while( nOut<pVar->n && (pVar->z[n]&0xc0)==0x80 ){ n++; }
         }
+#endif    
+        sqlite3XPrintf(&out, "'%.*q'", nOut, pVar->z);
+#ifdef SQLITE_TRACE_SIZE_LIMIT
+        if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-n);
+#endif
+#ifndef SQLITE_OMIT_UTF16
+        if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
+#endif
       }else if( pVar->flags & MEM_Zero ){
         sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
       }else{
+        int nOut;  /* Number of bytes of the blob to include in output */
         assert( pVar->flags & MEM_Blob );
         sqlite3StrAccumAppend(&out, "x'", 2);
-        for(i=0; i<pVar->n; i++){
+        nOut = pVar->n;
+#ifdef SQLITE_TRACE_SIZE_LIMIT
+        if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT;
+#endif
+        for(i=0; i<nOut; i++){
           sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);
         }
         sqlite3StrAccumAppend(&out, "'", 1);
+#ifdef SQLITE_TRACE_SIZE_LIMIT
+        if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-n);
+#endif
       }
     }
   }
   return sqlite3StrAccumFinish(&out);
 }

Index: src/wal.c
==================================================================
--- src/wal.c
+++ src/wal.c
@@ -1205,12 +1205,13 @@
     ** event via sqlite3_log(). This is to help with identifying performance
     ** problems caused by applications routinely shutting down without
     ** checkpointing the log file.
     */
     if( pWal->hdr.nPage ){
-      sqlite3_log(SQLITE_OK, "Recovered %d frames from WAL file %s",
-          pWal->hdr.nPage, pWal->zWalName
+      sqlite3_log(SQLITE_NOTICE_RECOVER_WAL,
+          "recovered %d frames from WAL file %s",
+          pWal->hdr.mxFrame, pWal->zWalName
       );
     }
   }
 
 recovery_error:
@@ -1720,20 +1721,21 @@
     /* Sync the WAL to disk */
     if( sync_flags ){
       rc = sqlite3OsSync(pWal->pWalFd, sync_flags);
     }
 
-    /* If the database file may grow as a result of this checkpoint, hint
-    ** about the eventual size of the db file to the VFS layer. 
+    /* If the database may grow as a result of this checkpoint, hint
+    ** about the eventual size of the db file to the VFS layer.
     */
     if( rc==SQLITE_OK ){
       i64 nReq = ((i64)mxPage * szPage);
       rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
       if( rc==SQLITE_OK && nSize<nReq ){
         sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT, &nReq);
       }
     }
+
 
     /* Iterate through the contents of the WAL, copying data to the db file. */
     while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
       i64 iOffset;
       assert( walFramePgno(pWal, iFrame)==iDbpage );
@@ -2285,23 +2287,21 @@
     pWal->readLock = -1;
   }
 }
 
 /*
-** Read a page from the WAL, if it is present in the WAL and if the 
-** current read transaction is configured to use the WAL.  
+** Search the wal file for page pgno. If found, set *piRead to the frame that
+** contains the page. Otherwise, if pgno is not in the wal file, set *piRead
+** to zero.
 **
-** The *pInWal is set to 1 if the requested page is in the WAL and
-** has been loaded.  Or *pInWal is set to 0 if the page was not in 
-** the WAL and needs to be read out of the database.
+** Return SQLITE_OK if successful, or an error code if an error occurs. If an
+** error does occur, the final value of *piRead is undefined.
 */
-int sqlite3WalRead(
+int sqlite3WalFindFrame(
   Wal *pWal,                      /* WAL handle */
   Pgno pgno,                      /* Database page number to read data for */
-  int *pInWal,                    /* OUT: True if data is read from WAL */
-  int nOut,                       /* Size of buffer pOut in bytes */
-  u8 *pOut                        /* Buffer to write page data to */
+  u32 *piRead                     /* OUT: Frame number (or zero) */
 ){
   u32 iRead = 0;                  /* If !=0, WAL frame to return data from */
   u32 iLast = pWal->hdr.mxFrame;  /* Last page in WAL for this reader */
   int iHash;                      /* Used to loop through N hash tables */
 
@@ -2313,11 +2313,11 @@
   ** in this case as an optimization.  Likewise, if pWal->readLock==0, 
   ** then the WAL is ignored by the reader so return early, as if the 
   ** WAL were empty.
   */
   if( iLast==0 || pWal->readLock==0 ){
-    *pInWal = 0;
+    *piRead = 0;
     return SQLITE_OK;
   }
 
   /* Search the hash table or tables for an entry matching page number
   ** pgno. Each iteration of the following for() loop searches one
@@ -2384,30 +2384,35 @@
     }
     assert( iRead==iRead2 );
   }
 #endif
 
-  /* If iRead is non-zero, then it is the log frame number that contains the
-  ** required page. Read and return data from the log file.
-  */
-  if( iRead ){
-    int sz;
-    i64 iOffset;
-    sz = pWal->hdr.szPage;
-    sz = (sz&0xfe00) + ((sz&0x0001)<<16);
-    testcase( sz<=32768 );
-    testcase( sz>=65536 );
-    iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
-    *pInWal = 1;
-    /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
-    return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
-  }
-
-  *pInWal = 0;
+  *piRead = iRead;
   return SQLITE_OK;
 }
 
+/*
+** Read the contents of frame iRead from the wal file into buffer pOut
+** (which is nOut bytes in size). Return SQLITE_OK if successful, or an
+** error code otherwise.
+*/
+int sqlite3WalReadFrame(
+  Wal *pWal,                      /* WAL handle */
+  u32 iRead,                      /* Frame to read */
+  int nOut,                       /* Size of buffer pOut in bytes */
+  u8 *pOut                        /* Buffer to write page data to */
+){
+  int sz;
+  i64 iOffset;
+  sz = pWal->hdr.szPage;
+  sz = (sz&0xfe00) + ((sz&0x0001)<<16);
+  testcase( sz<=32768 );
+  testcase( sz>=65536 );
+  iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
+  /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
+  return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
+}
 
 /* 
 ** Return the size of the database in pages (or zero, if unknown).
 */
 Pgno sqlite3WalDbsize(Wal *pWal){
@@ -2950,10 +2955,13 @@
   }
 
   /* Read the wal-index header. */
   if( rc==SQLITE_OK ){
     rc = walIndexReadHdr(pWal, &isChanged);
+    if( isChanged && pWal->pDbFd->pMethods->iVersion>=3 ){
+      sqlite3OsUnfetch(pWal->pDbFd, 0, 0);
+    }
   }
 
   /* Copy data from the log to the database file. */
   if( rc==SQLITE_OK ){
     if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){

Index: src/wal.h
==================================================================
--- src/wal.h
+++ src/wal.h
@@ -29,11 +29,10 @@
 # define sqlite3WalOpen(x,y,z)                   0
 # define sqlite3WalLimit(x,y)
 # define sqlite3WalClose(w,x,y,z)                0
 # define sqlite3WalBeginReadTransaction(y,z)     0
 # define sqlite3WalEndReadTransaction(z)
-# define sqlite3WalRead(v,w,x,y,z)               0
 # define sqlite3WalDbsize(y)                     0
 # define sqlite3WalBeginWriteTransaction(y)      0
 # define sqlite3WalEndWriteTransaction(x)        0
 # define sqlite3WalUndo(x,y,z)                   0
 # define sqlite3WalSavepoint(y,z)
@@ -69,11 +68,12 @@
 */
 int sqlite3WalBeginReadTransaction(Wal *pWal, int *);
 void sqlite3WalEndReadTransaction(Wal *pWal);
 
 /* Read a page from the write-ahead log, if it is present. */
-int sqlite3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
+int sqlite3WalFindFrame(Wal *, Pgno, u32 *);
+int sqlite3WalReadFrame(Wal *, u32, int, u8 *);
 
 /* If the WAL is not empty, return the size of the database. */
 Pgno sqlite3WalDbsize(Wal *pWal);
 
 /* Obtain or release the WRITER lock. */

Index: src/where.c
==================================================================
--- src/where.c
+++ src/where.c
@@ -2273,13 +2273,12 @@
   Table *pTab = pSrc->pTab;
   sqlite3_index_info *pIdxInfo;
   struct sqlite3_index_constraint *pIdxCons;
   struct sqlite3_index_constraint_usage *pUsage;
   WhereTerm *pTerm;
-  int i, j, k;
+  int i, j;
   int nOrderBy;
-  int sortOrder;                  /* Sort order for IN clauses */
   int bAllowIN;                   /* Allow IN optimizations */
   double rCost;
 
   /* Make sure wsFlags is initialized to some sane value. Otherwise, if the 
   ** malloc in allocateIndexInfo() fails and this function returns leaving
@@ -2374,11 +2373,10 @@
   
     if( vtabBestIndex(pParse, pTab, pIdxInfo) ){
       return;
     }
   
-    sortOrder = SQLITE_SO_ASC;
     pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
     for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){
       if( pUsage[i].argvIndex>0 ){
         j = pIdxCons->iTermOffset;
         pTerm = &pWC->a[j];
@@ -2389,21 +2387,32 @@
             ** says that the equivalent EQ constraint cannot be safely omitted.
             ** If we do attempt to use such a constraint, some rows might be
             ** repeated in the output. */
             break;
           }
-          for(k=0; k<pIdxInfo->nOrderBy; k++){
-            if( pIdxInfo->aOrderBy[k].iColumn==pIdxCons->iColumn ){
-              sortOrder = pIdxInfo->aOrderBy[k].desc;
-              break;
-            }
-          }
+          /* A virtual table that is constrained by an IN clause may not
+          ** consume the ORDER BY clause because (1) the order of IN terms
+          ** is not necessarily related to the order of output terms and
+          ** (2) Multiple outputs from a single IN value will not merge
+          ** together.  */
+          pIdxInfo->orderByConsumed = 0;
         }
       }
     }
     if( i>=pIdxInfo->nConstraint ) break;
   }
+
+  /* The orderByConsumed signal is only valid if all outer loops collectively
+  ** generate just a single row of output.
+  */
+  if( pIdxInfo->orderByConsumed ){
+    for(i=0; i<p->i; i++){
+      if( (p->aLevel[i].plan.wsFlags & WHERE_UNIQUE)==0 ){
+        pIdxInfo->orderByConsumed = 0;
+      }
+    }
+  }
   
   /* If there is an ORDER BY clause, and the selected virtual table index
   ** does not satisfy it, increase the cost of the scan accordingly. This
   ** matches the processing for non-virtual tables in bestBtreeIndex().
   */
@@ -2424,12 +2433,11 @@
   }else{
     p->cost.rCost = rCost;
   }
   p->cost.plan.u.pVtabIdx = pIdxInfo;
   if( pIdxInfo->orderByConsumed ){
-    assert( sortOrder==0 || sortOrder==1 );
-    p->cost.plan.wsFlags |= WHERE_ORDERED + sortOrder*WHERE_REVERSE;
+    p->cost.plan.wsFlags |= WHERE_ORDERED;
     p->cost.plan.nOBSat = nOrderBy;
   }else{
     p->cost.plan.nOBSat = p->i ? p->aLevel[p->i-1].plan.nOBSat : 0;
   }
   p->cost.plan.nEq = 0;
@@ -4162,10 +4170,11 @@
   struct SrcList_item *pTabItem;  /* FROM clause term being coded */
   int addrBrk;                    /* Jump here to break out of the loop */
   int addrCont;                   /* Jump here to continue with next cycle */
   int iRowidReg = 0;        /* Rowid is stored in this register, if not zero */
   int iReleaseReg = 0;      /* Temp register to free before returning */
+  Bitmask newNotReady;      /* Return value */
 
   pParse = pWInfo->pParse;
   v = pParse->pVdbe;
   pWC = pWInfo->pWC;
   pLevel = &pWInfo->a[iLevel];
@@ -4172,10 +4181,11 @@
   pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
   iCur = pTabItem->iCursor;
   bRev = (pLevel->plan.wsFlags & WHERE_REVERSE)!=0;
   omitTable = (pLevel->plan.wsFlags & WHERE_IDX_ONLY)!=0 
            && (wctrlFlags & WHERE_FORCE_TABLE)==0;
+  VdbeNoopComment((v, "Begin Join Loop %d", iLevel));
 
   /* Create labels for the "break" and "continue" instructions
   ** for the current loop.  Jump to addrBrk to break out of a loop.
   ** Jump to cont to go immediately to the next iteration of the
   ** loop.
@@ -4822,11 +4832,11 @@
     pLevel->op = aStep[bRev];
     pLevel->p1 = iCur;
     pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
     pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
   }
-  notReady &= ~getMask(pWC->pMaskSet, iCur);
+  newNotReady = notReady & ~getMask(pWC->pMaskSet, iCur);
 
   /* Insert code to test every subexpression that can be completely
   ** computed using the current set of tables.
   **
   ** IMPLEMENTATION-OF: R-49525-50935 Terms that cannot be satisfied through
@@ -4836,11 +4846,11 @@
   for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
     Expr *pE;
     testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* IMP: R-30575-11662 */
     testcase( pTerm->wtFlags & TERM_CODED );
     if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
-    if( (pTerm->prereqAll & notReady)!=0 ){
+    if( (pTerm->prereqAll & newNotReady)!=0 ){
       testcase( pWInfo->untestedTerms==0
                && (pWInfo->wctrlFlags & WHERE_ONETABLE_ONLY)!=0 );
       pWInfo->untestedTerms = 1;
       continue;
     }
@@ -4850,10 +4860,36 @@
       continue;
     }
     sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
     pTerm->wtFlags |= TERM_CODED;
   }
+
+  /* Insert code to test for implied constraints based on transitivity
+  ** of the "==" operator.
+  **
+  ** Example: If the WHERE clause contains "t1.a=t2.b" and "t2.b=123"
+  ** and we are coding the t1 loop and the t2 loop has not yet coded,
+  ** then we cannot use the "t1.a=t2.b" constraint, but we can code
+  ** the implied "t1.a=123" constraint.
+  */
+  for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
+    Expr *pE;
+    WhereTerm *pAlt;
+    Expr sEq;
+    if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
+    if( pTerm->eOperator!=(WO_EQUIV|WO_EQ) ) continue;
+    if( pTerm->leftCursor!=iCur ) continue;
+    pE = pTerm->pExpr;
+    assert( !ExprHasProperty(pE, EP_FromJoin) );
+    assert( (pTerm->prereqRight & newNotReady)!=0 );
+    pAlt = findTerm(pWC, iCur, pTerm->u.leftColumn, notReady, WO_EQ|WO_IN, 0);
+    if( pAlt==0 ) continue;
+    VdbeNoopComment((v, "begin transitive constraint"));
+    sEq = *pAlt->pExpr;
+    sEq.pLeft = pE->pLeft;
+    sqlite3ExprIfFalse(pParse, &sEq, addrCont, SQLITE_JUMPIFNULL);
+  }
 
   /* For a LEFT OUTER JOIN, generate code that will record the fact that
   ** at least one row of the right table has matched the left table.  
   */
   if( pLevel->iLeftJoin ){
@@ -4863,11 +4899,11 @@
     sqlite3ExprCacheClear(pParse);
     for(pTerm=pWC->a, j=0; j<pWC->nTerm; j++, pTerm++){
       testcase( pTerm->wtFlags & TERM_VIRTUAL );  /* IMP: R-30575-11662 */
       testcase( pTerm->wtFlags & TERM_CODED );
       if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
-      if( (pTerm->prereqAll & notReady)!=0 ){
+      if( (pTerm->prereqAll & newNotReady)!=0 ){
         assert( pWInfo->untestedTerms );
         continue;
       }
       assert( pTerm->pExpr );
       sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
@@ -4874,11 +4910,11 @@
       pTerm->wtFlags |= TERM_CODED;
     }
   }
   sqlite3ReleaseTempReg(pParse, iReleaseReg);
 
-  return notReady;
+  return newNotReady;
 }
 
 #if defined(SQLITE_TEST)
 /*
 ** The following variable holds a text description of query plan generated

ADDED   test/btreefault.test
Index: test/btreefault.test
==================================================================
--- test/btreefault.test
+++ test/btreefault.test
@@ -0,0 +1,50 @@
+# 2013 April 02
+#
+# 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 contains fault injection tests designed to test the btree.c 
+# module.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+set testprefix btreefault
+
+do_test 1-pre1 {
+  execsql {
+    PRAGMA auto_vacuum = incremental;
+    PRAGMA journal_mode = DELETE;
+    CREATE TABLE t1(a PRIMARY KEY, b);
+    INSERT INTO t1 VALUES(randomblob(1000), randomblob(100));
+    INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+    INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+    INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+    INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+    DELETE FROM t1 WHERE rowid%2;
+  }
+  faultsim_save_and_close
+} {}
+
+do_faultsim_test 1 -prep {
+  faultsim_restore_and_reopen
+  set ::STMT [sqlite3_prepare db "SELECT * FROM t1 ORDER BY a" -1 DUMMY]
+  sqlite3_step $::STMT
+  sqlite3_step $::STMT
+} -body {
+  execsql { PRAGMA incremental_vacuum = 10 }
+} -test {
+  sqlite3_finalize $::STMT
+  faultsim_test_result {0 {}} 
+  faultsim_integrity_check
+}
+
+finish_test
+

Index: test/dbstatus2.test
==================================================================
--- test/dbstatus2.test
+++ test/dbstatus2.test
@@ -38,10 +38,11 @@
 }
 
 do_test 1.1 {
   db close
   sqlite3 db test.db
+  execsql { PRAGMA mmap_size = 0 }
   expr {[file size test.db] / 1024}
 } 6
 
 do_test 1.2 {
   execsql { SELECT b FROM t1 WHERE a=2 }

Index: test/exclusive2.test
==================================================================
--- test/exclusive2.test
+++ test/exclusive2.test
@@ -22,10 +22,18 @@
 
 ifcapable {!pager_pragmas} {
   finish_test
   return
 }
+
+# Tests in this file verify that locking_mode=exclusive causes SQLite to
+# use cached pages even if the database is changed on disk. This doesn't
+# work with mmap.
+if {[permutation]=="mmap"} {
+  finish_test
+  return
+}
 
 # This module does not work right if the cache spills at unexpected
 # moments.  So disable the soft-heap-limit.
 #
 sqlite3_soft_heap_limit 0

Index: test/fts3aux1.test
==================================================================
--- test/fts3aux1.test
+++ test/fts3aux1.test
@@ -352,14 +352,14 @@
   CREATE VIRTUAL TABLE t2 USING fts4;
 }
 
 do_catchsql_test 3.1.2 {
   CREATE VIRTUAL TABLE terms2 USING fts4aux;
-} {1 {wrong number of arguments to fts4aux constructor}}
+} {1 {invalid arguments to fts4aux constructor}}
 do_catchsql_test 3.1.3 {
   CREATE VIRTUAL TABLE terms2 USING fts4aux(t2, t2);
-} {1 {wrong number of arguments to fts4aux constructor}}
+} {1 {invalid arguments to fts4aux constructor}}
 
 do_execsql_test 3.2.1 {
   CREATE VIRTUAL TABLE terms3 USING fts4aux(does_not_exist)
 }
 do_catchsql_test 3.2.2 {
@@ -442,11 +442,10 @@
 #-------------------------------------------------------------------------
 # The following tests check that fts4aux can handle an fts table with an
 # odd name (one that requires quoting for use in SQL statements). And that
 # the argument to the fts4aux constructor is properly dequoted before use.
 #
-#
 do_execsql_test 5.1 {
   CREATE VIRTUAL TABLE "abc '!' def" USING fts4(x, y);
   INSERT INTO "abc '!' def" VALUES('XX', 'YY');
 
   CREATE VIRTUAL TABLE terms3 USING fts4aux("abc '!' def");
@@ -456,7 +455,68 @@
 do_execsql_test 5.2 {
   CREATE VIRTUAL TABLE "%%^^%%" USING fts4aux('abc ''!'' def');
   SELECT * FROM "%%^^%%";
 } {xx * 1 1 xx 0 1 1 yy * 1 1 yy 1 1 1}
 
+#-------------------------------------------------------------------------
+# Test that we can create an fts4aux table in the temp database.
+#
+forcedelete test.db2
+do_execsql_test 6.1 {
+  CREATE VIRTUAL TABLE ft1 USING fts4(x, y);
+  INSERT INTO ft1 VALUES('a b', 'c d');
+  INSERT INTO ft1 VALUES('e e', 'c d');
+  INSERT INTO ft1 VALUES('a a', 'b b');
+  CREATE VIRTUAL TABLE temp.aux1 USING fts4aux(main, ft1);
+  SELECT * FROM aux1;
+} {
+    a * 2 3 a 0 2 3 
+    b * 2 3 b 0 1 1 b 1 1 2 
+    c * 2 2 c 1 2 2 
+    d * 2 2 d 1 2 2 
+    e * 1 2 e 0 1 2
+}
+
+do_execsql_test 6.2 {
+  ATTACH 'test.db2' AS att;
+  CREATE VIRTUAL TABLE att.ft1 USING fts4(x, y);
+  INSERT INTO att.ft1 VALUES('v w', 'x y');
+  INSERT INTO att.ft1 VALUES('z z', 'x y');
+  INSERT INTO att.ft1 VALUES('v v', 'w w');
+  CREATE VIRTUAL TABLE temp.aux2 USING fts4aux(att, ft1);
+  SELECT * FROM aux2;
+} {
+    v * 2 3 v 0 2 3 
+    w * 2 3 w 0 1 1 w 1 1 2 
+    x * 2 2 x 1 2 2 
+    y * 2 2 y 1 2 2 
+    z * 1 2 z 0 1 2
+}
+
+foreach {tn q res1 res2} {
+  1  { SELECT * FROM %%% WHERE term = 'a' } {a * 2 3 a 0 2 3} {}
+  2  { SELECT * FROM %%% WHERE term = 'x' } {} {x * 2 2 x 1 2 2} 
+
+  3  { SELECT * FROM %%% WHERE term >= 'y' } 
+     {} {y * 2 2 y 1 2 2 z * 1 2 z 0 1 2}
+
+  4  { SELECT * FROM %%% WHERE term <= 'c' } 
+     {a * 2 3 a 0 2 3 b * 2 3 b 0 1 1 b 1 1 2 c * 2 2 c 1 2 2} {}
+} {
+  set sql1 [string map {%%% aux1} $q]
+  set sql2 [string map {%%% aux2} $q]
+
+  do_execsql_test 7.$tn.1 $sql1 $res1
+  do_execsql_test 7.$tn.2 $sql2 $res2
+}
+
+do_test 8.1 {
+  catchsql { CREATE VIRTUAL TABLE att.aux3 USING fts4aux(main, ft1) }
+} {1 {invalid arguments to fts4aux constructor}}
+
+do_test 8.2 {
+  execsql {DETACH att}
+  catchsql { SELECT * FROM aux2 }
+} {1 {SQL logic error or missing database}}
 
 finish_test
+

ADDED   test/fts3tok1.test
Index: test/fts3tok1.test
==================================================================
--- test/fts3tok1.test
+++ test/fts3tok1.test
@@ -0,0 +1,125 @@
+# 2013 April 22
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the "fts3tokenize" virtual table
+# that is part of the FTS3 module.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+ifcapable !fts3 { finish_test ; return }
+set ::testprefix fts3tok1
+
+#-------------------------------------------------------------------------
+# Simple test cases. Using the default (simple) tokenizer.
+#
+do_execsql_test 1.0 {
+  CREATE VIRTUAL TABLE t1 USING fts3tokenize(simple);
+  CREATE VIRTUAL TABLE t2 USING fts3tokenize();
+  CREATE VIRTUAL TABLE t3 USING fts3tokenize(simple, '', 'xyz ');
+}
+
+foreach {tn tbl} {1 t1 2 t2 3 t3} {
+  do_execsql_test 1.$tn.1 "SELECT * FROM $tbl WHERE input = 'one two three'" {
+    {one two three} one   0  3 0 
+    {one two three} two   4  7 1 
+    {one two three} three 8 13 2
+  }
+
+  do_execsql_test 1.$tn.2 "
+    SELECT token FROM $tbl WHERE input = 'OnE tWo tHrEe'
+  " {
+    one two three
+  }
+}
+
+do_execsql_test 1.4 {
+  SELECT token FROM t3 WHERE input = '1x2x3x'
+} {1 2 3}
+
+do_execsql_test 1.5 {
+  SELECT token FROM t1 WHERE input = '1x2x3x'
+} {1x2x3x}
+
+do_execsql_test 1.6 {
+  SELECT token FROM t3 WHERE input = '1''2x3x'
+} {1'2 3}
+
+do_execsql_test 1.7 {
+  SELECT token FROM t3 WHERE input = ''
+} {}
+
+do_execsql_test 1.8 {
+  SELECT token FROM t3 WHERE input = NULL
+} {}
+
+do_execsql_test 1.9 {
+  SELECT * FROM t3 WHERE input = 123
+} {123 123 0 3 0}
+
+do_execsql_test 1.10 {
+  SELECT * FROM t1 WHERE input = 'a b c' AND token = 'b';
+} {
+  {a b c} b 2 3 1
+}
+
+do_execsql_test 1.11 {
+  SELECT * FROM t1 WHERE token = 'b' AND input = 'a b c';
+} {
+  {a b c} b 2 3 1
+}
+
+do_execsql_test 1.12 {
+  SELECT * FROM t1 WHERE input < 'b' AND input = 'a b c';
+} {
+  {a b c} a 0 1 0 
+  {a b c} b 2 3 1 
+  {a b c} c 4 5 2
+}
+
+do_execsql_test 1.13.1 {
+  CREATE TABLE c1(x);
+  INSERT INTO c1(x) VALUES('a b c');
+  INSERT INTO c1(x) VALUES('d e f');
+}
+breakpoint
+do_execsql_test 1.13.2 {
+  SELECT * FROM c1, t1 WHERE input = x AND c1.rowid=t1.rowid;
+} {
+  {a b c} {a b c} a 0 1 0 
+  {d e f} {d e f} e 2 3 1 
+}
+
+
+#-------------------------------------------------------------------------
+# Error cases.
+#
+do_catchsql_test 2.0 {
+  CREATE VIRTUAL TABLE tX USING fts3tokenize(nosuchtokenizer);
+} {1 {unknown tokenizer: nosuchtokenizer}}
+
+proc fts3_tokenizer {args} { return 1 }
+db function fts3_tokenizer -argcount 1 fts3_tokenizer
+do_catchsql_test 2.1 {
+  CREATE VIRTUAL TABLE tX USING fts3tokenize(simple);
+} {1 {vtable constructor failed: tX}}
+
+db close
+sqlite3 db test.db
+do_catchsql_test 2.2 {
+  CREATE VIRTUAL TABLE t4 USING fts3tokenize;
+  SELECT * FROM t4;
+} {1 {SQL logic error or missing database}}
+
+
+finish_test
+
+

ADDED   test/fts3tok_err.test
Index: test/fts3tok_err.test
==================================================================
--- test/fts3tok_err.test
+++ test/fts3tok_err.test
@@ -0,0 +1,49 @@
+# 2013 April 22
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#*************************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is testing the "fts3tokenize" virtual table
+# that is part of the FTS3 module.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+source $testdir/malloc_common.tcl
+ifcapable !fts3 { finish_test ; return }
+set ::testprefix fts3tok_err
+
+
+faultsim_save_and_close
+do_faultsim_test fts3tok_err-1 -faults oom* -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql { CREATE VIRTUAL TABLE t1 USING fts3tokenize("simple"); }
+} -test {
+  faultsim_test_result {0 {}} 
+}
+
+do_test fts3tok_err-2.prep {
+  faultsim_delete_and_reopen 
+  execsql { CREATE VIRTUAL TABLE t1 USING fts3tokenize("simple"); }
+  faultsim_save_and_close
+} {}
+
+do_faultsim_test fts3tok_err-2 -faults oom* -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql { SELECT token FROM t1 WHERE input = 'A galaxy far, far away' } 
+} -test {
+  faultsim_test_result {0 {a galaxy far far away}} 
+}
+
+
+finish_test
+
+

Index: test/func.test
==================================================================
--- test/func.test
+++ test/func.test
@@ -1271,15 +1271,17 @@
   db close
   sqlite3 db test.db
   sqlite3_db_status db CACHE_MISS 1
   db eval {SELECT typeof(+x) FROM t29 ORDER BY id}
 } {integer null real blob text}
-do_test func-29.4 {
-  set x [lindex [sqlite3_db_status db CACHE_MISS 1] 1]
-  if {$x>100} {set x many}
-  set x
-} {many}
+if {[permutation] != "mmap"} {
+  do_test func-29.4 {
+    set x [lindex [sqlite3_db_status db CACHE_MISS 1] 1]
+    if {$x>100} {set x many}
+    set x
+  } {many}
+}
 do_test func-29.5 {
   db close
   sqlite3 db test.db
   sqlite3_db_status db CACHE_MISS 1
   db eval {SELECT sum(length(x)) FROM t29}

Index: test/incrblob.test
==================================================================
--- test/incrblob.test
+++ test/incrblob.test
@@ -121,10 +121,11 @@
 
   db close
   forcedelete test.db test.db-journal
 
   sqlite3 db test.db
+  execsql "PRAGMA mmap_size = 0"
   execsql "PRAGMA auto_vacuum = $AutoVacuumMode"
 
   do_test incrblob-2.$AutoVacuumMode.1 {
     set ::str [string repeat abcdefghij 2900]
     execsql {
@@ -147,10 +148,11 @@
 
   do_test incrblob-2.$AutoVacuumMode.3 {
     # Open and close the db to make sure the page cache is empty.
     db close
     sqlite3 db test.db
+    execsql "PRAGMA mmap_size = 0"
   
     # Read the last 20 bytes of the blob via a blob handle.
     set ::blob [db incrblob blobs v 1]
     seek $::blob -20 end
     set ::fragment [read $::blob]
@@ -169,10 +171,11 @@
 
   do_test incrblob-2.$AutoVacuumMode.5 {
     # Open and close the db to make sure the page cache is empty.
     db close
     sqlite3 db test.db
+    execsql "PRAGMA mmap_size = 0"
   
     # Write the second-to-last 20 bytes of the blob via a blob handle.
     #
     set ::blob [db incrblob blobs v 1]
     seek $::blob -40 end
@@ -198,10 +201,11 @@
 
   do_test incrblob-2.$AutoVacuumMode.8 {
     # Open and close the db to make sure the page cache is empty.
     db close
     sqlite3 db test.db
+    execsql { PRAGMA mmap_size = 0 }
 
     execsql { SELECT i FROM blobs } 
   } {45}
 
   do_test incrblob-2.$AutoVacuumMode.9 {

Index: test/loadext.test
==================================================================
--- test/loadext.test
+++ test/loadext.test
@@ -137,24 +137,26 @@
   forcedelete ${testextension}xx
   set rc [catch {
     sqlite3_load_extension db "${testextension}xx"
   } msg]
   list $rc $msg
-} [list 1 [format $dlerror_nosuchfile ${testextension}xx]]
+} /[list 1 [format $dlerror_nosuchfile ${testextension}xx.*]]/
 
 # Try to load an extension for which the file is not a shared object
 #
 do_test loadext-2.2 {
-  set fd [open "${testextension}xx" w]
+  set fd [open "./notasharedlib.so" w]
+  puts $fd blah
+  close $fd
+  set fd [open "./notasharedlib.dll" w]
   puts $fd blah
   close $fd
   set rc [catch {
-    sqlite3_load_extension db "${testextension}xx"
+    sqlite3_load_extension db "./notasharedlib"
   } msg]
-  set expected_error_pattern [format $dlerror_notadll ${testextension}xx]
-  list $rc [string match $expected_error_pattern $msg]
-} [list 1 1]
+  list $rc $msg
+} /[list 1 [format $dlerror_notadll ./notasharedlib.*]]/
 
 # Try to load an extension for which the file is present but the
 # entry point is not.
 #
 do_test loadext-2.3 {
@@ -194,11 +196,11 @@
   }]
   if {$::tcl_platform(os) eq "Darwin"} {
     regsub {0x[1234567890abcdefABCDEF]*} $res XXX res
   }
   set res
-} [list 1 [format $dlerror_nosymbol $testextension sqlite3_extension_init]]
+} /[list 1 [format $dlerror_nosymbol $testextension sqlite3_.*_init]]/
 do_test loadext-3.3 {
   catchsql {
     SELECT load_extension($::testextension,'testloadext_init')
   }
 } {0 {{}}}

Index: test/malloc_common.tcl
==================================================================
--- test/malloc_common.tcl
+++ test/malloc_common.tcl
@@ -262,11 +262,11 @@
 proc faultsim_test_result_int {args} {
   upvar testrc testrc testresult testresult testnfail testnfail
   set t [list $testrc $testresult]
   set r $args
   if { ($testnfail==0 && $t != [lindex $r 0]) || [lsearch $r $t]<0 } {
-    error "nfail=$testnfail rc=$testrc result=$testresult"
+    error "nfail=$testnfail rc=$testrc result=$testresult list=$r"
   }
 }
 
 #--------------------------------------------------------------------------
 # Usage do_one_faultsim_test NAME ?OPTIONS...? 

ADDED   test/mmap1.test
Index: test/mmap1.test
==================================================================
--- test/mmap1.test
+++ test/mmap1.test
@@ -0,0 +1,317 @@
+# 2013 March 20
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+ifcapable !mmap {
+  finish_test
+  return
+}
+source $testdir/lock_common.tcl
+set testprefix mmap1
+
+proc nRead {db} {
+  set bt [btree_from_db $db]
+  db_enter $db
+  array set stats [btree_pager_stats $bt]
+  db_leave $db
+  # puts [array get stats]
+  return $stats(read)
+}
+
+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
+  }]
+}
+
+foreach {t mmap_size nRead c2init} {
+  1.1 { PRAGMA mmap_size = 67108864 }   4 {PRAGMA mmap_size = 0}
+  1.2 { PRAGMA mmap_size =    53248 } 150 {PRAGMA mmap_size = 0}
+  1.3 { PRAGMA mmap_size =        0 } 344 {PRAGMA mmap_size = 0}
+  1.4 { PRAGMA mmap_size = 67108864 }   4 {PRAGMA mmap_size = 67108864 }
+  1.5 { PRAGMA mmap_size =    53248 } 150 {PRAGMA mmap_size = 67108864 }
+  1.6 { PRAGMA mmap_size =        0 } 344 {PRAGMA mmap_size = 67108864 }
+} {
+  do_multiclient_test tn {
+    sql1 {PRAGMA page_size=1024}
+    sql1 $mmap_size
+    sql2 $c2init
+
+    code2 [register_rblob_code db2 0]
+
+    sql2 {
+      PRAGMA page_size=1024;
+      PRAGMA auto_vacuum = 1;
+      CREATE TABLE t1(a, b, UNIQUE(a, b));
+      INSERT INTO t1 VALUES(rblob(500), rblob(500));
+      INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    2
+      INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    4
+      INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    8
+      INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --   16
+      INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --   32
+    }
+    do_test $t.$tn.1 {
+      sql1 "SELECT count(*) FROM t1; PRAGMA integrity_check ; PRAGMA page_count"
+    } {32 ok 77}
+
+    # Have connection 2 shrink the file. Check connection 1 can still read it.
+    sql2 { DELETE FROM t1 WHERE rowid%2; }
+    do_test $t.$tn.2 {
+      sql1 "SELECT count(*) FROM t1; PRAGMA integrity_check ; PRAGMA page_count"
+    } {16 ok 42}
+
+    # Have connection 2 grow the file. Check connection 1 can still read it.
+    sql2 { INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1 }
+    do_test $t.$tn.3 {
+      sql1 "SELECT count(*) FROM t1; PRAGMA integrity_check ; PRAGMA page_count"
+    } {32 ok 79}
+
+    # Have connection 2 grow the file again. Check connection 1 is still ok.
+    sql2 { INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1 }
+    do_test $t.$tn.4 {
+      sql1 "SELECT count(*) FROM t1; PRAGMA integrity_check ; PRAGMA page_count"
+    } {64 ok 149}
+
+    # Check that the number of pages read by connection 1 indicates that the
+    # "PRAGMA mmap_size" command worked.
+    do_test $t.$tn.5 { nRead db } $nRead
+  }
+}
+
+set ::rcnt 0
+proc rblob {n} {
+  set ::rcnt [expr (($::rcnt << 3) + $::rcnt + 456) & 0xFFFFFFFF]
+  set str [format %.8x [expr $::rcnt ^ 0xbdf20da3]] 
+  string range [string repeat $str [expr $n/4]] 1 $n
+}
+
+reset_db
+db func rblob rblob
+
+do_execsql_test 2.1 {
+  PRAGMA auto_vacuum = 1;
+  PRAGMA mmap_size = 67108864;
+  PRAGMA journal_mode = wal;
+  CREATE TABLE t1(a, b, UNIQUE(a, b));
+  INSERT INTO t1 VALUES(rblob(500), rblob(500));
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    2
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    4
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    8
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --   16
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --   32
+  PRAGMA wal_checkpoint;
+} {67108864 wal 0 103 103}
+
+do_execsql_test 2.2 {
+  PRAGMA auto_vacuum;
+  SELECT count(*) FROM t1;
+} {1 32}
+
+do_test 2.3 {
+  sqlite3 db2 test.db
+  db2 func rblob rblob
+  db2 eval { 
+    DELETE FROM t1 WHERE (rowid%4);
+    PRAGMA wal_checkpoint;
+  }
+  db2 eval { 
+    INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    16
+    SELECT count(*) FROM t1;
+  }
+} {16}
+
+do_execsql_test 2.4 {
+  PRAGMA wal_checkpoint;
+} {0 24 24}
+
+db2 close
+reset_db
+db func rblob rblob
+do_execsql_test 3.1 {
+  PRAGMA auto_vacuum = 1;
+
+  CREATE TABLE t1(a, b, UNIQUE(a, b));
+  INSERT INTO t1 VALUES(rblob(500), rblob(500));
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    2
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    4
+  INSERT INTO t1 SELECT rblob(500), rblob(500) FROM t1; --    8
+
+  CREATE TABLE t2(a, b, UNIQUE(a, b));
+  INSERT INTO t2 SELECT * FROM t1;
+} {}
+
+do_test 3.2 {
+  set nRow 0
+  db eval {SELECT * FROM t2 ORDER BY a, b} {
+    if {$nRow==4} { db eval { DELETE FROM t1 } }
+    incr nRow
+  }
+  set nRow
+} {8}
+
+#-------------------------------------------------------------------------
+# Ensure that existing cursors using xFetch() pages see changes made
+# to rows using the incrblob API.
+#
+reset_db
+set aaa [string repeat a 400]
+set bbb [string repeat b 400]
+set ccc [string repeat c 400]
+set ddd [string repeat d 400]
+set eee [string repeat e 400]
+
+do_execsql_test 4.1 {
+  PRAGMA page_size = 1024;
+  CREATE TABLE t1(x);
+  INSERT INTO t1 VALUES($aaa);
+  INSERT INTO t1 VALUES($bbb);
+  INSERT INTO t1 VALUES($ccc);
+  INSERT INTO t1 VALUES($ddd);
+  SELECT * FROM t1;
+  BEGIN;
+} [list $aaa $bbb $ccc $ddd]
+
+do_test 4.2 {
+  set ::STMT [sqlite3_prepare db "SELECT * FROM t1 ORDER BY rowid" -1 dummy]
+  sqlite3_step $::STMT
+  sqlite3_column_text $::STMT 0
+} $aaa
+
+do_test 4.3 {
+  foreach r {2 3 4} {
+    set fd [db incrblob t1 x $r]
+    puts -nonewline $fd $eee
+    close $fd
+  }
+
+  set res [list]
+  while {"SQLITE_ROW" == [sqlite3_step $::STMT]} {
+    lappend res [sqlite3_column_text $::STMT 0]
+  }
+  set res
+} [list $eee $eee $eee]
+
+do_test 4.4 {
+  sqlite3_finalize $::STMT
+} SQLITE_OK
+
+do_execsql_test 4.5 { COMMIT }
+
+#-------------------------------------------------------------------------
+# Ensure that existing cursors holding xFetch() references are not 
+# confused if those pages are moved to make way for the root page of a
+# new table or index.
+#
+reset_db
+do_execsql_test 5.1 {
+  PRAGMA auto_vacuum = 2;
+  PRAGMA page_size = 1024;
+  CREATE TABLE t1(x);
+  INSERT INTO t1 VALUES($aaa);
+  INSERT INTO t1 VALUES($bbb);
+  INSERT INTO t1 VALUES($ccc);
+  INSERT INTO t1 VALUES($ddd);
+
+  PRAGMA auto_vacuum;
+  SELECT * FROM t1;
+} [list 2 $aaa $bbb $ccc $ddd]
+
+do_test 5.2 {
+  set ::STMT [sqlite3_prepare db "SELECT * FROM t1 ORDER BY rowid" -1 dummy]
+  sqlite3_step $::STMT
+  sqlite3_column_text $::STMT 0
+} $aaa
+
+do_execsql_test 5.3 {
+  CREATE TABLE t2(x);
+  INSERT INTO t2 VALUES('tricked you!');
+  INSERT INTO t2 VALUES('tricked you!');
+}
+
+do_test 5.4 {
+  sqlite3_step $::STMT
+  sqlite3_column_text $::STMT 0
+} $bbb
+
+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

ADDED   test/mmap2.test
Index: test/mmap2.test
==================================================================
--- test/mmap2.test
+++ test/mmap2.test
@@ -0,0 +1,86 @@
+# 2013 March 20
+#
+# 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
+set testprefix mmap2
+
+if {$::tcl_platform(platform)!="unix" || [test_syscall defaultvfs] != "unix"} {
+  finish_test
+  return
+}
+ifcapable !mmap {
+  finish_test
+  return
+}
+
+db close
+sqlite3_shutdown
+test_sqlite3_log xLog
+proc xLog {error_code msg} {
+  if {[string match os_unix.c* $msg]} {
+    lappend ::log $msg 
+  }
+}
+
+foreach syscall {mmap mremap} {
+  test_syscall uninstall 
+  if {[catch {test_syscall install $syscall}]} continue
+
+  for {set i 1} {$i < 20} {incr i} {
+    reset_db
+
+    test_syscall fault $i 1
+    test_syscall errno $syscall ENOMEM
+    set ::log ""
+
+    do_execsql_test 1.$syscall.$i.1 {
+      CREATE TABLE t1(a, b, UNIQUE(a, b));
+      INSERT INTO t1 VALUES(randomblob(1000), randomblob(1000));
+      INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+      INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+      INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+      INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+      INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+      INSERT INTO t1 SELECT randomblob(1000), randomblob(1000) FROM t1;
+    }
+
+    set nFail [test_syscall fault 0 0]
+
+    do_execsql_test 1.$syscall.$i.2 {
+      SELECT count(*) FROM t1;
+      PRAGMA integrity_check;
+    } {64 ok}
+
+    do_test 1.$syscall.$i.3 {
+      expr {$nFail==0 || $nFail==1}
+    } {1}
+
+    do_test 1.$syscall.$i.4.nFail=$nFail {
+      regexp ".*${syscall}.*" $::log
+    } [expr $nFail>0]
+  }
+}
+
+db close
+test_syscall uninstall 
+sqlite3_shutdown
+test_sqlite3_log 
+sqlite3_initialize
+finish_test

Index: test/pager1.test
==================================================================
--- test/pager1.test
+++ test/pager1.test
@@ -13,10 +13,11 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/lock_common.tcl
 source $testdir/malloc_common.tcl
 source $testdir/wal_common.tcl
+set testprefix pager1
 
 # Do not use a codec for tests in this file, as the database file is
 # manipulated directly using tcl scripts (using the [hexio_write] command).
 #
 do_not_use_codec
@@ -1380,10 +1381,11 @@
 # Test that regardless of the value returned by xSectorSize(), the
 # minimum effective sector-size is 512 and the maximum 65536 bytes.
 #
 testvfs tv -default 1
 foreach sectorsize {
+    16
     32   64   128   256   512   1024   2048 
     4096 8192 16384 32768 65536 131072 262144
 } {
   tv sectorsize $sectorsize
   tv devchar {}
@@ -1402,11 +1404,11 @@
         CREATE TABLE t2(a, b);
         CREATE TABLE t3(a, b);
       COMMIT;
     }
     file size test.db-journal
-  } [expr $sectorsize > 65536 ? 65536 : $sectorsize]
+  } [expr $sectorsize > 65536 ? 65536 : ($sectorsize<32 ? 512 : $sectorsize)]
 
   do_test pager1-10.$sectorsize.2 {
     execsql { 
       INSERT INTO t3 VALUES(a_string(300), a_string(300));
       INSERT INTO t3 SELECT * FROM t3;        /*  2 */
@@ -2241,11 +2243,10 @@
       ROLLBACK TO abc;
     COMMIT;
   }
   db close
 } {}
-breakpoint
 do_test pager1-25-2 {
   faultsim_delete_and_reopen
   execsql {
     SAVEPOINT abc;
       CREATE TABLE t1(a, b);
@@ -2520,7 +2521,298 @@
   do_test pager1-33.2 {
     file rename bak-journal test.db-journal
     execsql { SELECT * FROM t1 }
   } {one two}
 }
+
+#-------------------------------------------------------------------------
+# Test that appending pages to the database file then moving those pages
+# to the free-list before the transaction is committed does not cause
+# an error.
+#
+foreach {tn pragma strsize} {
+  1 { PRAGMA mmap_size = 0 } 2400
+  2 { }                       2400
+  3 { PRAGMA mmap_size = 0 } 4400
+  4 { }                       4400
+} {
+  reset_db
+  db func a_string a_string
+  db eval $pragma
+  do_execsql_test 34.$tn.1 {
+    CREATE TABLE t1(a, b);
+    INSERT INTO t1 VALUES(1, 2);
+  }
+  do_execsql_test 34.$tn.2 {
+    BEGIN;
+    INSERT INTO t1 VALUES(2, a_string($strsize));
+    DELETE FROM t1 WHERE oid=2;
+    COMMIT;
+    PRAGMA integrity_check;
+  } {ok}
+}
+
+#-------------------------------------------------------------------------
+#
+reset_db
+do_test 35 {
+  sqlite3 db test.db
+
+  execsql {
+    CREATE TABLE t1(x, y);
+    PRAGMA journal_mode = WAL;
+    INSERT INTO t1 VALUES(1, 2);
+  }
+
+  execsql {
+    BEGIN;
+      CREATE TABLE t2(a, b);
+  }
+
+  hexio_write test.db-shm [expr 16*1024] [string repeat 0055 8192]
+  catchsql ROLLBACK
+} {0 {}}
+
+do_multiclient_test tn {
+  sql1 {
+    PRAGMA auto_vacuum = 0;
+    CREATE TABLE t1(x, y);
+    INSERT INTO t1 VALUES(1, 2);
+  }
+
+  do_test 36.$tn.1 { 
+    sql2 { PRAGMA max_page_count = 2 }
+    list [catch { sql2 { CREATE TABLE t2(x) } } msg] $msg
+  } {1 {database or disk is full}}
+
+  sql1 { PRAGMA checkpoint_fullfsync = 1 }
+  sql1 { CREATE TABLE t2(x) }
+
+  do_test 36.$tn.2 { 
+    sql2 { INSERT INTO t2 VALUES('xyz') }
+    list [catch { sql2 { CREATE TABLE t3(x) } } msg] $msg
+  } {1 {database or disk is full}}
+}
+
+forcedelete test1 test2
+foreach {tn uri} {
+  1   {file:?mode=memory&cache=shared}
+  2   {file:one?mode=memory&cache=shared}
+  3   {file:test1?cache=shared}
+  4   {file:test2?another=parameter&yet=anotherone}
+} {
+  do_test 37.$tn {
+    catch { db close }
+    sqlite3_shutdown
+    sqlite3_config_uri 1
+    sqlite3 db $uri
+
+    db eval {
+      CREATE TABLE t1(x);
+      INSERT INTO t1 VALUES(1);
+      SELECT * FROM t1;
+    }
+  } {1}
+
+  do_execsql_test 37.$tn.2 {
+    VACUUM;
+    SELECT * FROM t1;
+  } {1}
+
+  db close
+  sqlite3_shutdown
+  sqlite3_config_uri 0
+}
+
+do_test 38.1 {
+  catch { db close }
+  forcedelete test.db
+  set fd [open test.db w]
+  puts $fd "hello world"
+  close $fd
+  sqlite3 db test.db
+  catchsql { CREATE TABLE t1(x) }
+} {1 {file is encrypted or is not a database}}
+do_test 38.2 {
+  catch { db close }
+  forcedelete test.db
+} {}
+
+do_test 39.1 {
+  sqlite3 db test.db
+  execsql {
+    PRAGMA auto_vacuum = 1;
+    CREATE TABLE t1(x);
+    INSERT INTO t1 VALUES('xxx');
+    INSERT INTO t1 VALUES('two');
+    INSERT INTO t1 VALUES(randomblob(400));
+    INSERT INTO t1 VALUES(randomblob(400));
+    INSERT INTO t1 VALUES(randomblob(400));
+    INSERT INTO t1 VALUES(randomblob(400));
+    BEGIN;
+    UPDATE t1 SET x = 'one' WHERE rowid=1;
+  }
+  set ::stmt [sqlite3_prepare db "SELECT * FROM t1 ORDER BY rowid" -1 dummy]
+  sqlite3_step $::stmt
+  sqlite3_column_text $::stmt 0
+} {one}
+do_test 39.2 {
+  execsql { CREATE TABLE t2(x) }
+  sqlite3_step $::stmt
+  sqlite3_column_text $::stmt 0
+} {two}
+do_test 39.3 {
+  sqlite3_finalize $::stmt
+  execsql COMMIT
+} {}
+
+do_execsql_test 39.4 {
+  PRAGMA auto_vacuum = 2;
+  CREATE TABLE t3(x);
+  CREATE TABLE t4(x);
+
+  DROP TABLE t2;
+  DROP TABLE t3;
+  DROP TABLE t4;
+}
+do_test 39.5 {
+  db close
+  sqlite3 db test.db
+  execsql {
+    PRAGMA cache_size = 1;
+    PRAGMA incremental_vacuum;
+    PRAGMA integrity_check;
+  }
+} {ok}
+
+do_test 40.1 {
+  reset_db
+  execsql {
+    PRAGMA auto_vacuum = 1;
+    CREATE TABLE t1(x PRIMARY KEY);
+    INSERT INTO t1 VALUES(randomblob(1200));
+    PRAGMA page_count;
+  }
+} {6}
+do_test 40.2 {
+  execsql {
+    INSERT INTO t1 VALUES(randomblob(1200));
+    INSERT INTO t1 VALUES(randomblob(1200));
+    INSERT INTO t1 VALUES(randomblob(1200));
+  }
+} {}
+do_test 40.3 {
+  db close
+  sqlite3 db test.db
+  execsql {
+    PRAGMA cache_size = 1;
+    CREATE TABLE t2(x);
+    PRAGMA integrity_check;
+  }
+} {ok}
+
+do_test 41.1 {
+  reset_db
+  execsql {
+    CREATE TABLE t1(x PRIMARY KEY);
+    INSERT INTO t1 VALUES(randomblob(200));
+    INSERT INTO t1 SELECT randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200) FROM t1;
+  }
+} {}
+do_test 41.2 {
+  testvfs tv -default 1
+  tv sectorsize 16384;
+  tv devchar [list]
+  db close
+  sqlite3 db test.db
+  execsql {
+    PRAGMA cache_size = 1;
+    DELETE FROM t1 WHERE rowid%4;
+    PRAGMA integrity_check;
+  }
+} {ok}
+db close
+tv delete
+
+set pending_prev [sqlite3_test_control_pending_byte 0x1000000]
+do_test 42.1 {
+  reset_db
+  execsql {
+    CREATE TABLE t1(x, y);
+    INSERT INTO t1 VALUES(randomblob(200), randomblob(200));
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+  }
+  db close
+  sqlite3_test_control_pending_byte 0x0010000
+  sqlite3 db test.db
+  db eval { PRAGMA mmap_size = 0 }
+  catchsql { SELECT sum(length(y)) FROM t1 }
+} {1 {database disk image is malformed}}
+do_test 42.2 {
+  reset_db
+  execsql {
+    CREATE TABLE t1(x, y);
+    INSERT INTO t1 VALUES(randomblob(200), randomblob(200));
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+  }
+  db close
+
+  testvfs tv -default 1
+  tv sectorsize 16384;
+  tv devchar [list]
+  sqlite3 db test.db -vfs tv
+  execsql { UPDATE t1 SET x = randomblob(200) }
+} {}
+db close
+tv delete
+sqlite3_test_control_pending_byte $pending_prev
+
+do_test 43.1 {
+  reset_db
+  execsql {
+    CREATE TABLE t1(x, y);
+    INSERT INTO t1 VALUES(1, 2);
+    CREATE TABLE t2(x, y);
+    INSERT INTO t2 VALUES(1, 2);
+    CREATE TABLE t3(x, y);
+    INSERT INTO t3 VALUES(1, 2);
+  }
+  db close
+  sqlite3 db test.db
+
+  db eval { PRAGMA mmap_size = 0 }
+  db eval { SELECT * FROM t1 }
+  sqlite3_db_status db CACHE_MISS 0
+} {0 2 0}
+
+do_test 43.2 {
+  db eval { SELECT * FROM t2 }
+  sqlite3_db_status db CACHE_MISS 1
+} {0 3 0}
+
+do_test 43.3 {
+  db eval { SELECT * FROM t3 }
+  sqlite3_db_status db CACHE_MISS 0
+} {0 1 0}
 
 finish_test
+

Index: test/pager2.test
==================================================================
--- test/pager2.test
+++ test/pager2.test
@@ -116,11 +116,10 @@
 db close
 tv delete
 
 
 #-------------------------------------------------------------------------
-#
 # pager2-2.1: Test a ROLLBACK with journal_mode=off.
 # pager2-2.2: Test shrinking the database (auto-vacuum) with 
 #             journal_mode=off
 #
 do_test pager2-2.1 {
@@ -145,7 +144,25 @@
     DELETE FROM t1;
     PRAGMA incremental_vacuum;
   }
   file size test.db
 } {3072}
+
+#-------------------------------------------------------------------------
+# Test that shared in-memory databases seem to work.
+#
+db close
+do_test pager2-3.1 {
+  forcedelete test.db
+  sqlite3_shutdown
+  sqlite3_config_uri 1
+
+  sqlite3 db1 {file:test.db?mode=memory&cache=shared}
+  sqlite3 db2 {file:test.db?mode=memory&cache=shared}
+  sqlite3 db3 test.db
+
+  db1 eval { CREATE TABLE t1(a, b) }
+  db2 eval { INSERT INTO t1 VALUES(1, 2) }
+  list [catch { db3 eval { INSERT INTO t1 VALUES(3, 4) } } msg] $msg
+} {1 {no such table: t1}}
 
 finish_test

Index: test/pagerfault.test
==================================================================
--- test/pagerfault.test
+++ test/pagerfault.test
@@ -1244,7 +1244,306 @@
   catch { close $::channel }
   catchsql { ROLLBACK }
   faultsim_integrity_check
 }
 
+
+#-------------------------------------------------------------------------
+#
+do_test pagerfault-28-pre {
+  faultsim_delete_and_reopen
+  db func a_string a_string
+  execsql {
+    PRAGMA page_size = 512;
+
+    PRAGMA journal_mode = wal;
+    PRAGMA wal_autocheckpoint = 0;
+    PRAGMA cache_size = 100000;
+
+    BEGIN;
+      CREATE TABLE t2(a UNIQUE, b UNIQUE);
+      INSERT INTO t2 VALUES( a_string(800), a_string(800) );
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+    COMMIT;
+    CREATE TABLE t1(a PRIMARY KEY, b);
+  }
+  expr {[file size test.db-shm] >= 96*1024}
+} {1}
+faultsim_save_and_close
+
+do_faultsim_test pagerfault-28a -faults oom* -prep {
+  faultsim_restore_and_reopen
+  execsql { PRAGMA mmap_size=0 }
+
+  sqlite3 db2 test.db
+  db2 eval { SELECT count(*) FROM t2 }
+
+  db func a_string a_string
+  execsql { 
+    BEGIN;
+      INSERT INTO t1 VALUES(a_string(2000), a_string(2000));
+      INSERT INTO t1 VALUES(a_string(2000), a_string(2000));
+  }
+  set ::STMT [sqlite3_prepare db "SELECT * FROM t1 ORDER BY a" -1 DUMMY]
+  sqlite3_step $::STMT
+} -body {
+  execsql { ROLLBACK }
+} -test {
+  db2 close
+  sqlite3_finalize $::STMT
+  catchsql { ROLLBACK }
+  faultsim_integrity_check
+}
+
+faultsim_restore_and_reopen
+sqlite3 db2 test.db
+db2 eval {SELECT count(*) FROM t2}
+db close
+
+do_faultsim_test pagerfault-28b -faults oom* -prep {
+  sqlite3 db test.db
+} -body {
+  execsql { SELECT count(*) FROM t2 }
+} -test {
+  faultsim_test_result {0 2048}
+  db close
+}
+
+db2 close
+
+#-------------------------------------------------------------------------
+# Try this:
+#
+#    1) Put the pager in ERROR state (error during rollback)
+#
+#    2) Next time the connection is used inject errors into all xWrite() and
+#       xUnlock() calls. This causes the hot-journal rollback to fail and
+#       the pager to declare its locking state UNKNOWN.
+#
+#    3) Same again.
+#
+#    4a) Stop injecting errors. Allow the rollback to succeed. Check that
+#        the database is Ok. Or, 
+#
+#    4b) Close and reopen the db. Check that the db is Ok.
+#
+proc custom_injectinstall {} {
+  testvfs custom -default true
+  custom filter {xWrite xUnlock}
+}
+proc custom_injectuninstall {} {
+  catch {db  close}
+  catch {db2 close}
+  custom delete
+}
+proc custom_injectstart {iFail} {
+  custom ioerr $iFail 1
+}
+proc custom_injectstop {} {
+  custom ioerr
+}
+set ::FAULTSIM(custom)          [list      \
+  -injectinstall   custom_injectinstall    \
+  -injectstart     custom_injectstart      \
+  -injectstop      custom_injectstop       \
+  -injecterrlist   {{1 {disk I/O error}}}  \
+  -injectuninstall custom_injectuninstall  \
+]
+
+do_test pagerfault-29-pre {
+  faultsim_delete_and_reopen
+  db func a_string a_string
+  execsql {
+    PRAGMA page_size = 1024;
+    PRAGMA cache_size = 5;
+
+    BEGIN;
+      CREATE TABLE t2(a UNIQUE, b UNIQUE);
+      INSERT INTO t2 VALUES( a_string(800), a_string(800) );
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+      INSERT INTO t2 SELECT a_string(800), a_string(800) FROM t2;
+    COMMIT;
+  }
+  expr {[file size test.db] >= 50*1024}
+} {1}
+faultsim_save_and_close
+foreach {tn tt} {
+  29 { catchsql ROLLBACK }
+  30 { db close ; sqlite3 db test.db }
+} {
+  do_faultsim_test pagerfault-$tn -faults custom -prep {
+    faultsim_restore_and_reopen
+      db func a_string a_string
+      execsql {
+        PRAGMA cache_size = 5;
+        BEGIN;
+        UPDATE t2 SET a = a_string(799);
+      }
+  } -body {
+    catchsql ROLLBACK
+    catchsql ROLLBACK
+    catchsql ROLLBACK
+  } -test {
+    eval $::tt
+    if {"ok" != [db one {PRAGMA integrity_check}]} {
+      error "integrity check failed"
+    }
+  }
+}
+
+do_test pagerfault-31-pre {
+  sqlite3_shutdown
+  sqlite3_config_uri 1
+} {SQLITE_OK}
+do_faultsim_test pagerfault-31 -faults oom* -body {
+  sqlite3 db {file:one?mode=memory&cache=shared}
+  db eval {
+    CREATE TABLE t1(x);
+    INSERT INTO t1 VALUES(1);
+    SELECT * FROM t1;
+  }
+} -test {
+  faultsim_test_result {0 1} {1 {}}
+  catch { db close }
+}
+sqlite3_shutdown
+sqlite3_config_uri 0
+
+do_test pagerfault-32-pre {
+  reset_db
+  execsql {
+    CREATE TABLE t1(x);
+    INSERT INTO t1 VALUES('one');
+  }
+} {}
+faultsim_save_and_close
+
+do_faultsim_test pagerfault-32 -prep {
+  faultsim_restore_and_reopen
+  db eval { SELECT * FROM t1; }
+} -body {
+  execsql { SELECT * FROM t1; }
+} -test {
+  faultsim_test_result {0 one}
+}
+sqlite3_shutdown
+sqlite3_config_uri 0
+
+do_faultsim_test pagerfault-33a -prep {
+  sqlite3 db :memory:
+  execsql {
+    CREATE TABLE t1(a, b);
+    INSERT INTO t1 VALUES(1, 2);
+  }
+} -body {
+  execsql { VACUUM }
+} -test {
+  faultsim_test_result {0 {}}
+} 
+do_faultsim_test pagerfault-33b -prep {
+  sqlite3 db ""
+  execsql {
+    CREATE TABLE t1(a, b);
+    INSERT INTO t1 VALUES(1, 2);
+  }
+} -body {
+  execsql { VACUUM }
+} -test {
+  faultsim_test_result {0 {}}
+} 
+
+do_test pagerfault-34-pre {
+  reset_db
+  execsql {
+    CREATE TABLE t1(x PRIMARY KEY);
+  }
+} {}
+faultsim_save_and_close
+do_faultsim_test pagerfault-34 -prep {
+  faultsim_restore_and_reopen
+  execsql {
+    BEGIN;
+      INSERT INTO t1 VALUES( randomblob(4000) );
+      DELETE FROM t1;
+  }
+} -body {
+  execsql COMMIT
+} -test {
+  faultsim_test_result {0 {}}
+} 
+
+do_test pagerfault-35-pre {
+  faultsim_delete_and_reopen
+  execsql {
+    CREATE TABLE t1(x PRIMARY KEY, y);
+    INSERT INTO t1 VALUES(randomblob(200), randomblob(200));
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+  }
+  faultsim_save_and_close
+} {}
+testvfs tv -default 1
+tv sectorsize 8192;
+tv devchar [list]
+do_faultsim_test pagerfault-35 -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql { UPDATE t1 SET x=randomblob(200) }
+} -test {
+  faultsim_test_result {0 {}}
+}
+catch {db close}
+tv delete
+
+sqlite3_shutdown
+sqlite3_config_uri 1
+do_test pagerfault-36-pre {
+  faultsim_delete_and_reopen
+  execsql {
+    CREATE TABLE t1(x PRIMARY KEY, y);
+    INSERT INTO t1 VALUES(randomblob(200), randomblob(200));
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+    INSERT INTO t1 SELECT randomblob(200), randomblob(200) FROM t1;
+  }
+  faultsim_save_and_close
+} {}
+do_faultsim_test pagerfault-36 -prep {
+  faultsim_restore
+  sqlite3 db file:test.db?cache=shared
+  sqlite3 db2 file:test.db?cache=shared
+  db2 eval {
+    BEGIN;
+    SELECT count(*) FROM sqlite_master;
+  }
+  db eval {
+    PRAGMA cache_size = 1;
+    BEGIN;
+      UPDATE t1 SET x = randomblob(200);
+  }
+} -body {
+  execsql ROLLBACK db
+} -test {
+  catch { db eval {UPDATE t1 SET x = randomblob(200)} }
+  faultsim_test_result {0 {}}
+  catch { db close }
+  catch { db2 close }
+}
+
+sqlite3_shutdown
+sqlite3_config_uri 0
+
 finish_test
 

Index: test/pageropt.test
==================================================================
--- test/pageropt.test
+++ test/pageropt.test
@@ -85,16 +85,21 @@
 } [list 0 0 0 $blobcontent]
 
 # But if the other thread modifies the database, then the cache
 # must refill.
 #
+ifcapable mmap {
+  set x [expr {[permutation]=="mmap" ? 1 : 6}]
+} else {
+  set x 6
+}
 do_test pageropt-1.5 {
   db2 eval {CREATE TABLE t2(y)}
   pagercount_sql {
     SELECT hex(x) FROM t1
   }
-} [list 6 0 0 $blobcontent]
+} [list $x 0 0 $blobcontent]
 do_test pageropt-1.6 {
   pagercount_sql {
     SELECT hex(x) FROM t1
   }
 } [list 0 0 0 $blobcontent]

Index: test/permutations.test
==================================================================
--- test/permutations.test
+++ test/permutations.test
@@ -138,10 +138,18 @@
   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_suite "mmap" -prefix "mm-" -description {
+  Similar to veryquick. Except with memory mapping disabled.
+} -presql {
+  pragma mmap_size = 268435456;
+} -files [
+  test_set $allquicktests -exclude *malloc* *ioerr* *fault* -include malloc.test
+]
 
 test_suite "valgrind" -prefix "" -description {
   Run the "veryquick" test suite with a couple of multi-process tests (that
   fail under valgrind) omitted.
 } -files [

ADDED   test/resolver01.test
Index: test/resolver01.test
==================================================================
--- test/resolver01.test
+++ test/resolver01.test
@@ -0,0 +1,39 @@
+# 2013-04-13
+#
+# The author disclaims copyright to this source code. In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+#
+# This file tests features of the name resolver (the component that
+# figures out what identifiers in the SQL statement refer to) that
+# were fixed by ticket [2500cdb9be]
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+do_test resolver01-1.1 {
+  catchsql {
+    CREATE TABLE t1(x, y); INSERT INTO t1 VALUES(11,22);
+    CREATE TABLE t2(y, z); INSERT INTO t2 VALUES(33,44);
+    SELECT 1 AS y FROM t1, t2 ORDER BY y;
+  }
+} {0 1}
+do_test resolver01-1.2 {
+  catchsql {
+    SELECT 2 AS y FROM t1, t2 ORDER BY y COLLATE nocase;
+  }
+} {0 2}
+do_test resolver01-1.3 {
+  catchsql {
+    SELECT 3 AS y FROM t1, t2 ORDER BY +y;
+  }
+} {0 3}
+
+
+finish_test

Index: test/speed1p.test
==================================================================
--- test/speed1p.test
+++ test/speed1p.test
@@ -22,10 +22,12 @@
 #sqlite3_config_pagecache 1024 11000
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 speed_trial_init speed1
 
+sqlite3_memdebug_vfs_oom_test 0
+
 # Set a uniform random seed
 expr srand(0)
 
 # The number_name procedure below converts its argment (an integer)
 # into a string which is the English-language name for that number.
@@ -75,11 +77,10 @@
   }
   execsql {
     SELECT name FROM sqlite_master ORDER BY 1;
   }
 } {i2a i2b t1 t2}
-
 
 # 50000 INSERTs on an unindexed table
 #
 set list {}
 for {set i 1} {$i<=50000} {incr i} {

Index: test/syscall.test
==================================================================
--- test/syscall.test
+++ test/syscall.test
@@ -58,11 +58,11 @@
 #
 foreach s {
     open close access getcwd stat fstat ftruncate
     fcntl read pread write pwrite fchmod fallocate
     pread64 pwrite64 unlink openDirectory mkdir rmdir 
-    statvfs fchown umask
+    statvfs fchown umask mmap munmap mremap
 } {
   if {[test_syscall exists $s]} {lappend syscall_list $s}
 }
 do_test 3.1 { lsort [test_syscall list] } [lsort $syscall_list]
 

Index: test/sysfault.test
==================================================================
--- test/sysfault.test
+++ test/sysfault.test
@@ -241,7 +241,37 @@
   }
 } -test {
   faultsim_test_result {0 20000}
 }
 
-finish_test
+#-------------------------------------------------------------------------
+# Test errors in mmap().
+#
+proc vfsfault_install {} { 
+  test_syscall reset
+  test_syscall install {mmap}
+}
+
+faultsim_delete_and_reopen
+execsql {
+  CREATE TABLE t1(a, b);
+  INSERT INTO t1 VALUES(1, 2);
+}
+faultsim_save_and_close
+
+do_faultsim_test 4 -faults vfsfault-* -prep {
+  faultsim_restore_and_reopen
+  file_control_chunksize_test db main 8192
+  execsql { 
+    PRAGMA mmap_size = 1000000;
+  }
+} -body {
+  test_syscall errno mmap     EACCES
+
+  execsql {
+    SELECT * FROM t1;
+  }
+} -test {
+  faultsim_test_result {0 {1 2}} {1 {disk I/O error}}
+}
 
+finish_test

Index: test/tester.tcl
==================================================================
--- test/tester.tcl
+++ test/tester.tcl
@@ -460,10 +460,11 @@
 if {0==[info exists ::SLAVE]} {
   set TC(errors)    0
   set TC(count)     0
   set TC(fail_list) [list]
   set TC(omit_list) [list]
+  set TC(warn_list) [list]
 
   proc set_test_counter {counter args} {
     if {[llength $args]} {
       set ::TC($counter) [lindex $args 0]
     }
@@ -493,10 +494,22 @@
   if {$nFail>=$::cmdlinearg(maxerror)} {
     puts "*** Giving up..."
     finalize_testing
   }
 }
+
+# Remember a warning message to be displayed at the conclusion of all testing
+#
+proc warning {msg {append 1}} {
+  puts "Warning: $msg"
+  set warnList [set_test_counter warn_list]
+  if {$append} {
+    lappend warnList $msg
+  }
+  set_test_counter warn_list $warnList
+}
+
 
 # Increment the number of tests run
 #
 proc incr_ntest {} {
   set_test_counter count [expr [set_test_counter count] + 1]
@@ -787,10 +800,13 @@
   set nErr [set_test_counter errors]
 
   puts "$nErr errors out of $nTest tests"
   if {$nErr>0} {
     puts "Failures on these tests: [set_test_counter fail_list]"
+  }
+  foreach warning [set_test_counter warn_list] {
+    puts "Warning: $warning"
   }
   run_thread_tests 1
   if {[llength $omitList]>0} {
     puts "Omitted test cases:"
     set prec {}

Index: test/tkt2822.test
==================================================================
--- test/tkt2822.test
+++ test/tkt2822.test
@@ -206,16 +206,19 @@
   }
 } {1 9}
 
 # In "ORDER BY +b" the term is now an expression rather than
 # a label.  It therefore matches by rule (3) instead of rule (2).
+#
+# 2013-04-13:  This is busted.  Changed to conform to PostgreSQL and
+# MySQL and Oracle behavior.
 # 
 do_test tkt2822-5.5 {
   execsql {
     SELECT a AS b FROM t3 ORDER BY +b;
   }
-} {9 1}
+} {1 9}
 
 # Tests for rule 2 in compound queries
 #
 do_test tkt2822-6.1 {
   execsql {

Index: test/wal.test
==================================================================
--- test/wal.test
+++ test/wal.test
@@ -725,39 +725,42 @@
 do_test wal-11.9 {
   db close
   list [expr [file size test.db]/1024] [log_deleted test.db-wal]
 } {37 1}
 sqlite3_wal db test.db
+set nWal 39
+if {[permutation]!="mmap"} {set nWal 37}
+ifcapable !mmap {set nWal 37}
 do_test wal-11.10 {
   execsql {
     PRAGMA cache_size = 10;
     BEGIN;
       INSERT INTO t1 SELECT blob(900) FROM t1;   -- 32
       SELECT count(*) FROM t1;
   }
   list [expr [file size test.db]/1024] [file size test.db-wal]
-} [list 37 [wal_file_size 37 1024]]
+} [list 37 [wal_file_size $nWal 1024]]
 do_test wal-11.11 {
   execsql {
       SELECT count(*) FROM t1;
     ROLLBACK;
     SELECT count(*) FROM t1;
   }
 } {32 16}
 do_test wal-11.12 {
   list [expr [file size test.db]/1024] [file size test.db-wal]
-} [list 37 [wal_file_size 37 1024]]
+} [list 37 [wal_file_size $nWal 1024]]
 do_test wal-11.13 {
   execsql {
     INSERT INTO t1 VALUES( blob(900) );
     SELECT count(*) FROM t1;
     PRAGMA integrity_check;
   }
 } {17 ok}
 do_test wal-11.14 {
   list [expr [file size test.db]/1024] [file size test.db-wal]
-} [list 37 [wal_file_size 37 1024]]
+} [list 37 [wal_file_size $nWal 1024]]
 
 
 #-------------------------------------------------------------------------
 # This block of tests, wal-12.*, tests the fix for a problem that 
 # could occur if a log that is a prefix of an older log is written 
@@ -1510,11 +1513,11 @@
   execsql { SELECT * FROM t1 }
 } {1 2 3 4}
 set nPage [expr 2+$AUTOVACUUM]
 do_test wal-23.4 { 
   set ::log 
-} [list SQLITE_OK "Recovered $nPage frames from WAL file $walfile"]
+} [list SQLITE_NOTICE "recovered $nPage frames from WAL file $walfile"]
 
 
 ifcapable autovacuum {
   # This block tests that if the size of a database is reduced by a 
   # transaction (because of an incremental or auto-vacuum), that no

Index: test/wal5.test
==================================================================
--- test/wal5.test
+++ test/wal5.test
@@ -233,11 +233,20 @@
     do_test 2.3.$tn.3 { sql2 { BEGIN; SELECT * FROM t1 } } {1 2}
     do_test 2.3.$tn.4 { sql1 { INSERT INTO t1 VALUES(3, 4) } } {}
     do_test 2.3.$tn.5 { sql1 { INSERT INTO t2 VALUES(3, 4) } } {}
     do_test 2.3.$tn.6 { file_page_counts } {1 4 1 4}
     do_test 2.3.$tn.7 { code1 { do_wal_checkpoint db -mode full } } {1 4 3}
-    do_test 2.3.$tn.8 { file_page_counts } {1 4 2 4}
+
+    # The checkpoint above only writes page 1 of the db file. The other
+    # page (page 2) is locked by the read-transaction opened by the
+    # [sql2] commmand above. So normally, the db is 1 page in size here.
+    # However, in mmap() mode, the db is pre-allocated to 2 pages at the
+    # start of the checkpoint, even though page 2 cannot be written.
+    set nDb 2
+    if {[permutation]!="mmap"} {set nDb 1}
+    ifcapable !mmap {set nDb 1}
+    do_test 2.3.$tn.8 { file_page_counts } [list $nDb 4 2 4]
   }
 
   # Check that checkpoints block on the correct locks. And respond correctly
   # if they cannot obtain those locks. There are three locks that a checkpoint
   # may block on (in the following order):
@@ -341,6 +350,5 @@
   }
 }
 
 
 finish_test
-

Index: test/walfault.test
==================================================================
--- test/walfault.test
+++ test/walfault.test
@@ -546,8 +546,46 @@
   faultsim_test_result {0 {0 9 9}}
   faultsim_integrity_check
   set nRow [db eval {SELECT count(*) FROM abc}]
   if {!(($nRow==2 && $testrc) || $nRow==3)} { error "Bad db content" }
 }
-finish_test
+
+#-------------------------------------------------------------------------
+# Test fault-handling when switching out of exclusive-locking mode.
+#
+do_test walfault-14-pre {
+  faultsim_delete_and_reopen
+  execsql {
+    PRAGMA auto_vacuum = 0;
+    PRAGMA journal_mode = WAL;
+    BEGIN;
+      CREATE TABLE abc(a PRIMARY KEY);
+      INSERT INTO abc VALUES(randomblob(1500));
+      INSERT INTO abc VALUES(randomblob(1500));
+    COMMIT;
+  }
+  faultsim_save_and_close
+} {}
+do_faultsim_test walfault-14 -prep {
+  faultsim_restore_and_reopen
+  breakpoint
+  execsql {
+    SELECT count(*) FROM abc;
+    PRAGMA locking_mode = exclusive;
+    BEGIN;
+      INSERT INTO abc VALUES(randomblob(1500));
+    COMMIT;
+  }
+} -body {
+  db eval { 
+    PRAGMA locking_mode = normal;
+    BEGIN;
+      INSERT INTO abc VALUES(randomblob(1500));
+    COMMIT;
+  }
+} -test {
+  faultsim_integrity_check
+  set nRow [db eval {SELECT count(*) FROM abc}]
+  if {$nRow!=3 && $nRow!=4} { error "Bad db content" }
+}
 
 finish_test

Index: test/win32lock.test
==================================================================
--- test/win32lock.test
+++ test/win32lock.test
@@ -25,10 +25,11 @@
 test_sqlite3_log xLog
 proc xLog {error_code msg} {
   lappend ::log $msg 
 }
 sqlite3 db test.db
+db eval {PRAGMA mmap_size=0}
 
 do_test win32lock-1.1 {
   db eval {
     PRAGMA cache_size=10;
     CREATE TABLE t1(x,y);

Index: tool/mksqlite3c.tcl
==================================================================
--- tool/mksqlite3c.tcl
+++ tool/mksqlite3c.tcl
@@ -311,10 +311,11 @@
    fts3_expr.c
    fts3_hash.c
    fts3_porter.c
    fts3_tokenizer.c
    fts3_tokenizer1.c
+   fts3_tokenize_vtab.c
    fts3_write.c
    fts3_snippet.c
    fts3_unicode.c
    fts3_unicode2.c