Add the exprNodeCopy() routine that will safely memcpy() an Expr node that

might be a size-reduced node. FossilOrigin-Name: ab2ba8e732d4a813a336e37e06bbc98842d22d4896120b1b97e8577684e9ea53
Merge changes from trunk.
2019-05-07 02:57:28 +00:00 · 2018-06-04 14:10:15 +00:00 · 2018-06-02 19:14:58 +00:00 · 2018-06-02 19:01:54 +00:00 · 2018-06-02 17:00:57 +00:00 · 2018-06-02 16:32:04 +00:00
122 changed files with 4196 additions and 641 deletions
@@ -63,7 +63,7 @@ LIBREADLINE = @TARGET_READLINE_LIBS@

 # Should the database engine be compiled threadsafe
 #
-TCC += -DSQLITE_THREADSAFE=@SQLITE_THREADSAFE@
+#TCC += -DSQLITE_THREADSAFE=@SQLITE_THREADSAFE@

 # Any target libraries which libsqlite must be linked against
 # 
@@ -117,7 +117,7 @@ TCLSH_CMD = @TCLSH_CMD@

 # Where do we want to install the tcl plugin
 #
-TCLLIBDIR = @TCLLIBDIR@
+TCLLIBDIR = /System/Library/Tcl

 # The suffix used on shared libraries.  Ex:  ".dll", ".so", ".dylib"
 #
@@ -350,6 +350,9 @@ SRC += \
 SRC += \
  $(TOP)/ext/rtree/rtree.h \
  $(TOP)/ext/rtree/rtree.c
+SRC += \
+  $(TOP)/ext/sqlrr/sqlrr.h \
+  $(TOP)/ext/sqlrr/sqlrr.c
 SRC += \
  $(TOP)/ext/session/sqlite3session.c \
  $(TOP)/ext/session/sqlite3session.h
@@ -554,6 +557,17 @@ EXTHDR += \
  $(TOP)/ext/icu/sqliteicu.h
 EXTHDR += \
  $(TOP)/ext/rtree/sqlite3rtree.h
+EXTHDR += \
+  $(TOP)/ext/sqlrr/sqlrr.h
+
+# If using the amalgamation, use sqlite3.c directly to build the test
+# fixture.  Otherwise link against libsqlite3.la.  (This distinction is
+# necessary because the test fixture requires non-API symbols which are
+# hidden when the library is built via the amalgamation).
+#
+TESTFIXTURE_SRC0 = $(TESTSRC2) libsqlite3.la
+TESTFIXTURE_SRC1 = sqlite3.c
+TESTFIXTURE_SRC = $(TESTSRC) $(TOP)/src/tclsqlite.c $(TESTFIXTURE_SRC$(USE_AMALGAMATION))

 # executables needed for testing
 #
@@ -616,9 +630,8 @@ libsqlite3.la:	$(LIBOBJ)
 libtclsqlite3.la:	tclsqlite.lo libsqlite3.la
 	$(LTLINK) -no-undefined -o $@ tclsqlite.lo \
 		libsqlite3.la @TCL_STUB_LIB_SPEC@ $(TLIBS) \
-		-rpath "$(TCLLIBDIR)" \
-		-version-info "8:6:8" \
-		-avoid-version
+                -rpath "$(TCLLIBDIR)/sqlite3" \
+		-version-info "8:6:8"

 sqlite3$(TEXE):	shell.c sqlite3.c
 	$(LTLINK) $(READLINE_FLAGS) $(SHELL_OPT) -o $@ \
@@ -1347,10 +1360,10 @@ install:	sqlite3$(TEXE) lib_install sqlite3.h sqlite3.pc ${HAVE_TCL:1=tcl_instal
 pkgIndex.tcl:
 	echo 'package ifneeded sqlite3 $(RELEASE) [list load $(TCLLIBDIR)/libtclsqlite3$(SHLIB_SUFFIX) sqlite3]' > $@
 tcl_install:	lib_install libtclsqlite3.la pkgIndex.tcl
-	$(INSTALL) -d $(DESTDIR)$(TCLLIBDIR)
-	$(LTINSTALL) libtclsqlite3.la $(DESTDIR)$(TCLLIBDIR)
-	rm -f $(DESTDIR)$(TCLLIBDIR)/libtclsqlite3.la $(DESTDIR)$(TCLLIBDIR)/libtclsqlite3.a
-	$(INSTALL) -m 0644 pkgIndex.tcl $(DESTDIR)$(TCLLIBDIR)
+	$(INSTALL) -d $(DESTDIR)$(TCLLIBDIR)/sqlite3
+	$(LTINSTALL) libtclsqlite3.la $(DESTDIR)$(TCLLIBDIR)/sqlite3
+	rm -f $(DESTDIR)$(TCLLIBDIR)/sqlite3/libtclsqlite3.la $(DESTDIR)$(TCLLIBDIR)/sqlite3/libtclsqlite3.a
+	$(INSTALL) -m 0644 pkgIndex.tcl $(DESTDIR)$(TCLLIBDIR)/sqlite3

 clean:	
 	rm -f *.lo *.la *.o sqlite3$(TEXE) libsqlite3.la
@@ -1609,6 +1609,7 @@ FUZZDATA = \
 !IF $(DYNAMIC_SHELL)==0 && $(FOR_WIN10)==0
 SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_EXPLAIN_COMMENTS -DSQLITE_ENABLE_STMTVTAB
 SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_ENABLE_DBPAGE_VTAB -DSQLITE_ENABLE_DBSTAT_VTAB
+SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
 SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_ENABLE_OFFSET_SQL_FUNC -DSQLITE_INTROSPECTION_PRAGMAS
 SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_ENABLE_RTREE
 !ENDIF
@@ -14,7 +14,7 @@ sqlite3_CFLAGS = $(AM_CFLAGS) -DSQLITE_ENABLE_EXPLAIN_COMMENTS -DSQLITE_ENABLE_D

 include_HEADERS = sqlite3.h sqlite3ext.h

-EXTRA_DIST = sqlite3.1 tea Makefile.msc sqlite3.rc README.txt Replace.cs
+EXTRA_DIST = sqlite3.1 tea Makefile.msc sqlite3.rc README.txt Replace.cs Makefile.fallback
 pkgconfigdir = ${libdir}/pkgconfig
 pkgconfig_DATA = sqlite3.pc

@@ -0,0 +1,19 @@
+#!/usr/bin/make
+#
+# If the configure script does not work, then this Makefile is available
+# as a backup.  Manually configure the variables below.
+#
+# Note:  This makefile works out-of-the-box on MacOS 10.2 (Jaguar)
+#
+CC = gcc
+CFLAGS = -O0 -I.
+LIBS = -lz
+COPTS += -D_BSD_SOURCE
+COPTS += -DSQLITE_ENABLE_LOCKING_STYLE=0
+COPTS += -DSQLITE_THREADSAFE=0
+COPTS += -DSQLITE_OMIT_LOAD_EXTENSION
+COPTS += -DSQLITE_WITHOUT_ZONEMALLOC
+COPTS += -DSQLITE_ENABLE_RTREE
+
+sqlite3:	shell.c sqlite3.c
+	$(CC) $(CFLAGS) $(COPTS) -o sqlite3 shell.c sqlite3.c $(LIBS)
@@ -286,7 +286,6 @@ do_setup_rec_test $tn.14 {
  INSERT INTO t9 VALUES(?, ?, ?);
 } {
  CREATE INDEX t10_idx_00000062 ON t10(b); 
-  -- TRIGGER t9t
  SEARCH TABLE t10 USING INDEX t10_idx_00000062 (b=?)
 }

@@ -1152,7 +1152,9 @@ int idxFindIndexes(
        }
      }

-      pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail);
+      if( zDetail[0]!='-' ){
+        pStmt->zEQP = idxAppendText(&rc, pStmt->zEQP, "%s\n", zDetail);
+      }
    }

    for(pEntry=hIdx.pFirst; pEntry; pEntry=pEntry->pNext){
@@ -205,7 +205,8 @@ static int csv_append(CsvReader *p, char c){
 **   +  Store the character that terminates the field in p->cTerm.  Store
 **      EOF on end-of-file.
 **
-** Return "" at EOF.  Return 0 on an OOM error.
+** Return 0 at EOF or on OOM.  On EOF, the p->cTerm character will have
+** been set to EOF.
 */
 static char *csv_read_one_field(CsvReader *p){
  int c;
@@ -213,7 +214,7 @@ static char *csv_read_one_field(CsvReader *p){
  c = csv_getc(p);
  if( c==EOF ){
    p->cTerm = EOF;
-    return "";
+    return 0;
  }
  if( c=='"' ){
    int pc, ppc;
@@ -544,8 +545,7 @@ static int csvtabConnect(
    pNew->nCol = nCol;
  }else{
    do{
-      const char *z = csv_read_one_field(&sRdr);
-      if( z==0 ) goto csvtab_connect_oom;
+      csv_read_one_field(&sRdr);
      pNew->nCol++;
    }while( sRdr.cTerm==',' );
  }
@@ -663,7 +663,6 @@ static int csvtabNext(sqlite3_vtab_cursor *cur){
  do{
    z = csv_read_one_field(&pCur->rdr);
    if( z==0 ){
-      csv_xfer_error(pTab, &pCur->rdr);
      break;
    }
    if( i<pTab->nCol ){
@@ -65,6 +65,7 @@

 #include <string.h>
 #include <assert.h>
+#include <stdint.h>
 #include <stdio.h>

 #ifndef SQLITE_AMALGAMATION
@@ -0,0 +1,54 @@
+
+sqlrr - 10/19/2009
+
+SQL Replay Recording
+
+SUMMARY
+-------------------------------------------------------
+This extension enables recording sqlite API calls that access the database so that they can be replayed or examined.
+
+USAGE
+------------------------------------------------------
+Recording is enabled by compiling sqlite with symbolic constant SQLITE_ENABLE_SQLRR defined.  
+By default logs are written to /tmp/<databasename>_<pid>_<connection_number>.sqlrr, to choose another directory, set the environment variable SQLITE_REPLAY_RECORD_DIR to that path.
+
+FILE FORMAT
+-----------------------------------------------------
+ file:			<header>[<sql-command>]*
+ 
+ header:			<signature><format-version>
+   signature: 		SQLRR (5 bytes)
+   format-version:	n (1 byte)
+ 
+ sql-command:		<timestamp><type><arg-data>
+   timestamp:       n (16 bytes)
+   type:			n (1 byte)
+        open		0
+        close		1
+        exec		8
+        bind-text	16
+        bind-double	17
+        bind-int	18
+        bind-null	19
+        bind-value	20
+        bind-clear	21
+        prep		32
+        step		33
+        reset		34
+        finalize	35
+
+  open-arg-data:		<connection><path><flags>
+  close-arg-data:		<connection>
+  exec-arg-data:		<connection><len><statement-text>
+  bind-text-arg-data:	<statement-ref><index><len><data>
+  bind-double-arg-data:	<statement-ref><index><data>
+  bind-int-arg-data:	<statement-ref><index><data>
+  bind-null-arg-data:	<statement-ref><index>
+  bind-value-arg-data:	<statement-ref><index><len><data> ???
+  bind-clear-arg-data:	<statement-ref>
+  prep-arg-data:		<connection><len><statement-text>
+  step-arg-data:		<statement-ref>
+  reset-arg-data:		<statement-ref>
+  finalize-arg-data:	<statement-ref>
+
+NOTES
@@ -0,0 +1,581 @@
+/*
+ *  sqlrr.c
+ */
+
+#include "sqlrr.h"
+
+#if defined(SQLITE_ENABLE_SQLRR)
+
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/param.h>
+#include <errno.h>
+#include <pthread.h>
+#include <libkern/OSAtomic.h>
+
+#include "sqliteInt.h"
+#include "vdbeInt.h"
+
+#define LOGSUFFIXLEN 48
+
+/* 
+ * Data types 
+ */
+typedef struct SRRLogRef SRRLogRef;
+struct SRRLogRef {
+    int fd;
+    sqlite3 *db;
+    const char *dbPath;
+    char *logPath;
+    int connection;
+    int depth;
+    SRRLogRef *nextRef;
+};
+
+/* 
+ * Globals 
+ */
+SRRLogRef *logRefHead = NULL;
+int dbLogCount = 0;
+static int srr_enabled = 1;
+pthread_mutex_t srr_log_mutex;
+static volatile int32_t srr_initialized = 0;
+
+/* 
+ * Log management 
+ */
+extern void SRRecInitialize() {
+    int go = OSAtomicCompareAndSwap32Barrier(0, 1, &srr_initialized); 
+    if( go ){
+        pthread_mutex_init(&srr_log_mutex, NULL);
+    }
+}
+
+static SRRLogRef *createLog(sqlite3 *db, const char *dbPath) {
+    SRRLogRef *ref = NULL;
+    char *baseDir = getenv("SQLITE_REPLAY_RECORD_DIR");
+    char logPath[MAXPATHLEN] = "";
+    char suffix[LOGSUFFIXLEN] = "";
+    const char *dbName = dbPath;
+    int len = 0;
+    int index = 0;
+    int fd = -1;
+    size_t out;
+    unsigned char version = SRR_FILE_VERSION;
+    
+    SRRecInitialize();
+
+    /* construct the path for the log file 
+     * ${SQLITE_REPLAY_DIR}/<dbname>_<pid>_<connection_number>.sqlrr
+     */
+    if (baseDir == NULL) {
+        baseDir = "/tmp"; /* getenv(TMPDIR) */
+    }
+    len = strlen(baseDir);
+    strlcat(logPath, baseDir, MAXPATHLEN);
+    if ((len>0) && (baseDir[len-1] != '/')) {
+        strlcat(logPath, "/", MAXPATHLEN);
+    }
+    len = strlen(dbPath);
+    for (index = len-2; index >= 0; index --){
+        if (dbPath[index] == '/') {
+            dbName = &dbPath[index+1];
+            break;
+        }
+    }
+    strlcat(logPath, dbName, MAXPATHLEN);
+    int cNum = ++dbLogCount;
+    snprintf(suffix, sizeof(suffix), "_%d_%d_XXXX.sqlrr", getpid(), cNum);
+    len = strlcat(logPath, suffix, MAXPATHLEN);
+    /* make it unique if we have the space */
+    if ((len + 1) < MAXPATHLEN) {
+        fd = mkstemps(logPath, 6);
+    } else {
+        fprintf(stderr, "Failed to create sqlite replay log path for %s [%s]\n", dbPath, logPath);
+        return NULL;
+    }
+    if (fd == -1) {
+        fprintf(stderr, "Failed to create sqlite replay log file for %s with path %s [%s]\n", dbPath, logPath, strerror(errno));
+        return NULL;
+    }
+    fprintf(stdout, "Writing sqlite replay log file %s\n", logPath);
+    out = write(fd, SRR_FILE_SIGNATURE, SRR_FILE_SIGNATURE_LEN);
+    if (out!=-1) {
+        out = write(fd, &version, 1);
+    }
+    if (out == -1){
+        fprintf(stderr, "Write failure on log [%s]: %s\n", logPath, strerror(errno));
+        close(fd);
+        return NULL;
+    }
+
+    len = strlen(logPath) + 1;
+    ref = (SRRLogRef *)malloc(sizeof(SRRLogRef));
+
+    ref->db = db;
+    ref->dbPath = dbPath;
+    ref->logPath = (char *)malloc(len * sizeof(char));
+    strlcpy(ref->logPath, logPath, len);
+    ref->fd = fd;
+    ref->connection = cNum;
+    ref->depth = 0;
+    
+    pthread_mutex_lock(&srr_log_mutex);
+    ref->nextRef = logRefHead;
+    logRefHead = ref;
+    pthread_mutex_unlock(&srr_log_mutex);
+    return ref;
+}
+
+static void closeLog(sqlite3 *db) {
+    SRRLogRef *ref = NULL;
+    SRRLogRef *lastRef = NULL;
+
+    pthread_mutex_lock(&srr_log_mutex);
+    for (ref = logRefHead; ref != NULL; ref = ref->nextRef) {
+        if (ref->db == db) {
+            if (lastRef == NULL) {
+                logRefHead = ref->nextRef;
+            } else {
+                lastRef->nextRef = ref->nextRef;
+            }
+        }
+    }
+    pthread_mutex_unlock(&srr_log_mutex);
+
+    if (ref != NULL) {
+        fprintf(stdout, "Closing sqlite replay log file %s\n", ref->logPath);
+        close(ref->fd);
+        free(ref->logPath);
+        free(ref);
+    }
+}
+
+static SRRLogRef *getLog(sqlite3 *db) {
+    pthread_mutex_lock(&srr_log_mutex);
+    SRRLogRef *ref = logRefHead;
+    for (ref = logRefHead; ref != NULL; ref = ref->nextRef) {
+        if (ref->db == db) {
+            pthread_mutex_unlock(&srr_log_mutex);
+            return ref;
+        }
+    }
+    pthread_mutex_unlock(&srr_log_mutex);
+    return NULL;
+}
+
+
+/*
+ * SQLite recording API
+ */
+void SQLiteReplayRecorder(int flag) {
+    srr_enabled = flag;
+}
+
+// open-arg-data:		<connection><len><path><flags>
+void _SRRecOpen(sqlite3 *db, const char *path, int flags) {
+    if (!srr_enabled) return;
+    if (db) {
+        SRRLogRef *ref = createLog(db, path);
+        if (ref) {
+            SRRCommand code = SRROpen;
+            int len = strlen(path);
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out=write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { out=write(ref->fd, &(ref->connection), sizeof(ref->connection)); }
+            if (out!=-1) { out=write(ref->fd, &len, sizeof(len)); }
+            if (out!=-1) { out=write(ref->fd, path, len); }
+            if (out!=-1) { out=write(ref->fd, &flags, sizeof(flags)); }
+            if (out==-1) {
+                fprintf(stderr, "Error writing open to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(db);
+            }
+        }
+    }
+}
+
+//close-arg-data:		<connection>
+void SRRecClose(sqlite3 *db) {
+    if (!srr_enabled) return;
+    if (db) {
+        SRRLogRef *ref = getLog(db);
+        if (ref) {
+            SRRCommand code = SRRClose;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { out = write(ref->fd, &(ref->connection), sizeof(ref->connection)); }
+            if (out==-1) {
+                fprintf(stderr, "Error writing close to log file [%s]: %s\n", ref->logPath, strerror(errno));
+            }
+            closeLog(db);
+        }
+    }
+}
+
+// exec-arg-data:		<connection><len><statement-text>
+void SRRecExec(sqlite3 *db, const char *sql) {
+    if (!srr_enabled) return;
+    if (db) {
+        SRRLogRef *ref = getLog(db);
+        if (ref) {
+            if (ref->depth == 0) {
+                SRRCommand code = SRRExec;
+                int len = strlen(sql);
+                struct timeval tv;
+                size_t out;
+                
+                ref->depth = 1;
+                gettimeofday(&tv, NULL);
+                out = write(ref->fd, &tv, sizeof(tv));
+                if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+                if (out!=-1) { out = write(ref->fd, &(ref->connection), sizeof(ref->connection)); }
+                if (out!=-1) { out = write(ref->fd, &len, sizeof(len)); }
+                if (out!=-1) { out = write(ref->fd, sql, len); }
+                if (out==-1) {
+                    fprintf(stderr, "Error writing exec to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                    closeLog(db);
+                }
+            } else {
+                ref->depth ++;
+            }
+        }
+    }
+}
+
+void SRRecExecEnd(sqlite3 *db) {
+    if (!srr_enabled) return;
+    if (db) {
+        SRRLogRef *ref = getLog(db);
+        if (ref) {
+            ref->depth --;
+        }
+    }
+}
+            
+// prep-arg-data:		<connection><len><statement-text><savesql><statement-ref>
+void _SRRecPrepare(sqlite3 *db, const char *sql, int nBytes, int saveSql, sqlite3_stmt *pStmt) {
+    if (!srr_enabled) return;
+    if ((db!=NULL)&&(pStmt!=NULL)) {
+        SRRLogRef *ref = getLog(db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRPrepare;
+            struct timeval tv;
+            size_t out;
+            int sqlLen = nBytes;
+
+            if (sqlLen == -1) {
+                sqlLen = strlen(sql);
+            }
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { out = write(ref->fd, &(ref->connection), sizeof(ref->connection)); }
+            if (out!=-1) { out = write(ref->fd, &sqlLen, sizeof(sqlLen)); }
+            if (out!=-1) { out = write(ref->fd, sql, sqlLen); }
+            if (out!=-1) { out = write(ref->fd, &saveSql, sizeof(saveSql)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out==-1) {
+                fprintf(stderr, "Error writing prepare to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(db);
+            }
+        }
+    }
+}
+
+//step-arg-data:		<statement-ref>
+void SRRecStep(sqlite3_stmt *pStmt) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref) {
+            if (ref->depth == 0) {
+                SRRCommand code = SRRStep;
+                struct timeval tv;
+                size_t out;
+                
+                ref->depth = 1;
+                gettimeofday(&tv, NULL);
+                out = write(ref->fd, &tv, sizeof(tv));
+                if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+                if (out!=-1) { 
+                    int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                    out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+                }
+                if (out==-1) {
+                    fprintf(stderr, "Error writing step to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                    closeLog(ref->db);
+                }
+            } else {
+                ref->depth ++;
+            }            
+        }
+    }
+}
+
+void SRRecStepEnd(sqlite3_stmt *pStmt) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref) {
+            ref->depth --;
+        }
+    }
+}
+
+// reset-arg-data:		<statement-ref>
+void SRRecReset(sqlite3_stmt *pStmt) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRReset;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out==-1) {
+                fprintf(stderr, "Error writing reset to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// finalize-arg-data:	<statement-ref>
+void SRRecFinalize(sqlite3_stmt *pStmt) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRFinalize;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out==-1) {
+                fprintf(stderr, "Error writing finalize to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// bind-text-arg-data:	<statement-ref><index><len><data>
+void SRRecBindText(sqlite3_stmt *pStmt, int i, const char *zData, int64_t nData) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRBindText;
+            struct timeval tv;
+            size_t out;
+            int64_t textLen = nData;
+            if (textLen == -1) {
+                textLen = strlen(zData);
+            }
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out!=-1) { out = write(ref->fd, &i, sizeof(i)); }
+            if (out!=-1) { out = write(ref->fd, &textLen, sizeof(textLen)); }
+            if (out!=-1) { out = write(ref->fd, zData, textLen); }
+            if (out==-1) {
+                fprintf(stderr, "Error writing bind text to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// bind-blob-arg-data:	<statement-ref><index><len>[<data>]
+void SRRecBindBlob(sqlite3_stmt *pStmt, int i, const char *zData, int64_t nData) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRBindBlob;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out!=-1) { out = write(ref->fd, &i, sizeof(i)); }
+            if (zData == NULL) {
+                int64_t negNData = -nData;
+                if (out!=-1) { out = write(ref->fd, &negNData, sizeof(negNData)); }
+            } else {
+                if (out!=-1) { out = write(ref->fd, &nData, sizeof(nData)); }
+                if (out!=-1) { out = write(ref->fd, zData, nData); }
+            }
+            if (out==-1) {
+                fprintf(stderr, "Error writing bind blob to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// bind-double-arg-data:	<statement-ref><index><data>
+void SRRecBindDouble(sqlite3_stmt *pStmt, int i, double value) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRBindDouble;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out!=-1) { out = write(ref->fd, &i, sizeof(i)); }
+            if (out!=-1) { out = write(ref->fd, &value, sizeof(value)); }
+            if (out==-1) {
+                fprintf(stderr, "Error writing bind double to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// bind-int-arg-data:	<statement-ref><index><data>
+void SRRecBindInt64(sqlite3_stmt *pStmt, int i, int64_t value) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRBindInt;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out!=-1) { out = write(ref->fd, &i, sizeof(i)); }
+            if (out!=-1) { out = write(ref->fd, &value, sizeof(value)); }
+            if (out==-1) {
+                fprintf(stderr, "Error writing bind int to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// bind-null-arg-data:	<statement-ref><index>
+void SRRecBindNull(sqlite3_stmt *pStmt, int i) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRBindNull;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out!=-1) { out = write(ref->fd, &i, sizeof(i)); }
+            if (out==-1) {
+                fprintf(stderr, "Error writing bind null to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+// bind-value-arg-data:	<statement-ref><index><len><data> ???
+void SRRecBindValue(sqlite3_stmt *pStmt, int i, const sqlite3_value *value) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            fprintf(stderr, "SRRecBindValue(sqlite3_bind_value) is not yet supported, closing [%s]: %s\n", ref->logPath, strerror(errno));
+            closeLog(ref->db);
+        }
+    }
+}
+
+// bind-clear-arg-data:	<statement-ref>
+void SRRecClearBindings(sqlite3_stmt *pStmt) {
+    if (!srr_enabled) return;
+    if(pStmt!=NULL) {
+        Vdbe *v = (Vdbe *)pStmt;
+        SRRLogRef *ref = getLog(v->db);
+        if (ref && (ref->depth == 0)) {
+            SRRCommand code = SRRBindClear;
+            struct timeval tv;
+            size_t out;
+            
+            gettimeofday(&tv, NULL);
+            out = write(ref->fd, &tv, sizeof(tv));
+            if (out!=-1) { out = write(ref->fd, &code, sizeof(SRRCommand)); }
+            if (out!=-1) { 
+                int64_t stmtInt = (int64_t)((intptr_t)(pStmt));
+                out = write(ref->fd, &stmtInt, sizeof(int64_t)); 
+            }
+            if (out==-1) {
+                fprintf(stderr, "Error writing clear bindings to log file [%s]: %s\n", ref->logPath, strerror(errno));
+                closeLog(ref->db);
+            }
+        }
+    }
+}
+
+#endif /* SQLITE_ENABLE_SQLRR */
@@ -0,0 +1,61 @@
+/*
+ *  sqlrr.h
+ */
+
+#ifndef _SQLRR_H_
+#define _SQLRR_H_
+
+/*
+** Header constants
+*/
+#define SRR_FILE_SIGNATURE       "SQLRR"
+#define SRR_FILE_SIGNATURE_LEN   5
+#define SRR_FILE_VERSION         0x1 
+#define SRR_FILE_VERSION_LEN     1
+
+#if defined(SQLITE_ENABLE_SQLRR)
+
+#include "sqlite3.h"
+#include <sys/types.h>
+
+#define SRRecOpen(A,B,C)        if(!rc){_SRRecOpen(A,B,C);}
+#define SRRecPrepare(A,B,C,D,E) if(!rc){_SRRecPrepare(A,B,C,D,E);}
+
+typedef enum {
+    SRROpen = 0,
+    SRRClose = 1,
+    SRRExec = 8,
+    SRRBindText = 16,
+    SRRBindBlob = 17,
+    SRRBindDouble = 18,
+    SRRBindInt = 19,
+    SRRBindNull = 20,
+    SRRBindValue = 21,
+    SRRBindClear = 22,
+    SRRPrepare = 32,
+    SRRStep = 33,
+    SRRReset = 34,
+    SRRFinalize = 35
+} SRRCommand;
+
+extern void SQLiteReplayRecorder(int flag);
+extern void _SRRecOpen(sqlite3 *db, const char *path, int flags);
+extern void SRRecClose(sqlite3 *db);
+extern void SRRecExec(sqlite3 *db, const char *sql);
+extern void SRRecExecEnd(sqlite3 *db);
+extern void _SRRecPrepare(sqlite3 *db, const char *sql, int nBytes, int saveSql, sqlite3_stmt *stmt);
+extern void SRRecStep(sqlite3_stmt *pStmt);
+extern void SRRecStepEnd(sqlite3_stmt *pStmt);
+extern void SRRecReset(sqlite3_stmt *pStmt);
+extern void SRRecFinalize(sqlite3_stmt *pStmt);
+extern void SRRecBindText(sqlite3_stmt *pStmt, int i, const char *zData, int64_t nData);
+extern void SRRecBindBlob(sqlite3_stmt *pStmt, int i, const char *zData, int64_t nData);
+extern void SRRecBindDouble(sqlite3_stmt *pStmt, int i, double value);
+extern void SRRecBindInt64(sqlite3_stmt *pStmt, int i, int64_t value);
+extern void SRRecBindNull(sqlite3_stmt *pStmt, int i);
+extern void SRRecBindValue(sqlite3_stmt *pStmt, int i, const sqlite3_value *value);
+extern void SRRecClearBindings(sqlite3_stmt *pStmt);
+
+#endif /* defined(SQLITE_ENABLE_SQLRR) */
+
+#endif /* _SQLRR_H_ */
@@ -229,6 +229,9 @@ SRC += \
  $(TOP)/ext/rtree/sqlite3rtree.h \
  $(TOP)/ext/rtree/rtree.h \
  $(TOP)/ext/rtree/rtree.c
+SRC += \
+  $(TOP)/ext/sqlrr/sqlrr.h \
+  $(TOP)/ext/sqlrr/sqlrr.c
 SRC += \
  $(TOP)/ext/session/sqlite3session.c \
  $(TOP)/ext/session/sqlite3session.h
@@ -460,22 +463,7 @@ HDR = \
 # Header files used by extensions
 #
 EXTHDR += \
-  $(TOP)/ext/fts1/fts1.h \
-  $(TOP)/ext/fts1/fts1_hash.h \
-  $(TOP)/ext/fts1/fts1_tokenizer.h
-EXTHDR += \
-  $(TOP)/ext/fts2/fts2.h \
-  $(TOP)/ext/fts2/fts2_hash.h \
-  $(TOP)/ext/fts2/fts2_tokenizer.h
-EXTHDR += \
-  $(TOP)/ext/fts3/fts3.h \
-  $(TOP)/ext/fts3/fts3Int.h \
-  $(TOP)/ext/fts3/fts3_hash.h \
-  $(TOP)/ext/fts3/fts3_tokenizer.h
-EXTHDR += \
-  $(TOP)/ext/rtree/rtree.h
-EXTHDR += \
-  $(TOP)/ext/icu/sqliteicu.h
+  $(TOP)/ext/sqlrr/sqlrr.h
 EXTHDR += \
  $(TOP)/ext/fts5/fts5Int.h  \
  fts5parse.h                \
@@ -605,10 +593,10 @@ sqlite3.o:	sqlite3.c
 # files are automatically generated.  This target takes care of
 # all that automatic generation.
 #
-target_source:	$(SRC) $(TOP)/tool/vdbe-compress.tcl fts5.c
+target_source:	$(SRC) $(EXTHDR) $(TOP)/tool/vdbe-compress.tcl fts5.c
 	rm -rf tsrc
 	mkdir tsrc
-	cp -f $(SRC) tsrc
+	cp -f $(SRC) $(EXTHDR) tsrc
 	rm tsrc/sqlite.h.in tsrc/parse.y
 	tclsh $(TOP)/tool/vdbe-compress.tcl $(OPTS) <tsrc/vdbe.c >vdbe.new
 	mv vdbe.new tsrc/vdbe.c
@@ -1,10 +1,10 @@
-C When\sdoing\sa\sone-pass\sUPDATE\sor\sDELETE\son\svirtual\stables,\sclose\sthe\scursor\nprior\sto\srunning\sVUpdate.\s\sThis\sallows\sone-pass\sto\swork\son\svirtual\stables\nthat\sdo\snot\sallow\sconcurrent\sreads\sand\swrites.\s\sEnhance\srtree\sto\stake\nadvantage\sof\sthis\snew\scapability.
-D 2018-05-24T23:51:57.743
+C Add\sthe\sexprNodeCopy()\sroutine\sthat\swill\ssafely\smemcpy()\san\sExpr\snode\sthat\nmight\sbe\sa\ssize-reduced\snode.
+D 2019-05-07T02:57:28.889
 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
-F Makefile.in bfc40f350586923e0419d2ea4b559c37ec10ee4b6e210e08c14401f8e340f0da
+F Makefile.in ab754e8fb9a83a308dfef344fd3a86bb93956d8ac0b4b461b96f6201a76f75f0
 F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
-F Makefile.msc 681fb88cccf1fd58c0b9648f6a09b75332206ef72ca76012ad11699c320cec5f
+F Makefile.msc 887c54fc449b1880711e86f16f8afb1158a55884292895faeb3259a060e7e212
 F README.md 7764d56778d567913ef11c82da9ab94aefa0826f7c243351e4e2d7adaef6f373
 F VERSION b7c9d1d11cb70ef8e90cfcf3c944aa58a9f801cc2ad487eebb0a110c16dfc2df
 F aclocal.m4 a5c22d164aff7ed549d53a90fa56d56955281f50
@@ -12,7 +12,8 @@ F art/sqlite370.eps aa97a671332b432a54e1d74ff5e8775be34200c2
 F art/sqlite370.ico af56c1d00fee7cd4753e8631ed60703ed0fc6e90
 F art/sqlite370.jpg d512473dae7e378a67e28ff96a34da7cb331def2
 F autoconf/INSTALL 83e4a25da9fd053c7b3665eaaaf7919707915903
-F autoconf/Makefile.am f8c274ee0022cb6d48ff103ab6c6b0733c41b3b02cb8566228dfd602f701e0c2
+F autoconf/Makefile.am 465fb475ee5a4b8a63d26c889cb36a4edbff0325b6859eb29a13cdf5c91b005c
+F autoconf/Makefile.fallback 22fe523eb36dfce31e0f6349f782eb084e86a5620b2b0b4f84a2d6133f53f5ac
 F autoconf/Makefile.msc 6a46d0659d6e4a25346102bcba40a7fb4b0b8b2dc4faabdf0187488c6dd580d6
 F autoconf/README.first 6c4f34fe115ff55d4e8dbfa3cecf04a0188292f7
 F autoconf/README.txt 4f04b0819303aabaa35fff5f7b257fb0c1ef95f1
@@ -44,8 +45,8 @@ F ext/async/sqlite3async.c 0f3070cc3f5ede78f2b9361fb3b629ce200d7d74
 F ext/async/sqlite3async.h f489b080af7e72aec0e1ee6f1d98ab6cf2e4dcef
 F ext/expert/README.md b321c2762bb93c18ea102d5a5f7753a4b8bac646cb392b3b437f633caf2020c3
 F ext/expert/expert.c d548d603a4cc9e61f446cc179c120c6713511c413f82a4a32b1e1e69d3f086a4
-F ext/expert/expert1.test 87e54effda905d991edfe4bcd28098460a568246129ab7263f71b25420ea727f
-F ext/expert/sqlite3expert.c 95fdee74be2912d962951d984f1123e55d3f44bd643da7a48ff6ea9426a47f69
+F ext/expert/expert1.test baa05800dc1c569faa7ce6232cead0fcedc07fea038b3a2489eaaf710831d546
+F ext/expert/sqlite3expert.c 89b7b59be610b929958db02416539a46ac088fd84f81623c4190aff62e92c3c4
 F ext/expert/sqlite3expert.h af6354f8ee5c9e025024e63fec3bd640a802afcc3099a44d804752cf0791d811
 F ext/expert/test_expert.c d56c194b769bdc90cf829a14c9ecbc1edca9c850b837a4d0b13be14095c32a72
 F ext/fts1/README.txt 20ac73b006a70bcfd80069bdaf59214b6cf1db5e
@@ -274,7 +275,7 @@ F ext/misc/carray.c ed96c218ea940b85c9a274c4d9c59fe9491c299147a38a8bba537687bd6c
 F ext/misc/closure.c fe928228e8dfb2f00227311c203ccba9c2e5561f4f6de6da87e5b4a30cd8af15
 F ext/misc/completion.c e75b8886a2531f9a7ec02dab5f179bb37e6bd46b5da7665a6cbf2dfbe2daa483
 F ext/misc/compress.c dd4f8a6d0baccff3c694757db5b430f3bbd821d8686d1fc24df55cf9f035b189
-F ext/misc/csv.c d1e324fac3f87f818d684a3d752d1ef76dbcd4fc0db6746ac4034c19d0bcda21
+F ext/misc/csv.c 65297bcce8d5acd5aadef42acbe739aef5a2ef5e74c7b73361ca19f3e21de657
 F ext/misc/dbdump.c 69ef1be5b210538f77dfcc6fcb55b4b5f5e98b1e0bcfd67d818711e10761db4d
 F ext/misc/eval.c 6ea9b22a5fa0dd973b67ca4e53555be177bc0b7b263aadf1024429457c82c0e3
 F ext/misc/fileio.c 48c7751c78fc4cdd29d8c862fd2f3f98bbfefa2a3cf1ca1496df4bf02eb8cded
@@ -355,7 +356,7 @@ F ext/repair/test/checkfreelist01.test 3e8aa6aeb4007680c94a8d07b41c339aa635cc782
 F ext/repair/test/checkindex01.test 6945d0ffc0c1dc993b2ce88036b26e0f5d6fcc65da70fc9df27c2647bb358b0f
 F ext/repair/test/test.tcl 686d76d888dffd021f64260abf29a55c57b2cedfa7fc69150b42b1d6119aac3c
 F ext/rtree/README 6315c0d73ebf0ec40dedb5aa0e942bc8b54e3761
-F ext/rtree/rtree.c cb6d4bd43c118354fe5b5213843da058259467ecdbac0c6f71ead0fd89acf4ec
+F ext/rtree/rtree.c a1444c00551402b805a8d3181f80effc9f563426fa31b168f48b90537fba9f63
 F ext/rtree/rtree.h 4a690463901cb5e6127cf05eb8e642f127012fd5003830dbc974eca5802d9412
 F ext/rtree/rtree1.test 309afc04d4287542b2cd74f933296832cc681c7b014d9405cb329b62053a5349
 F ext/rtree/rtree2.test 5f25b01acd03470067a2d52783b2eb0a50bf836803d4342d20ca39e541220fe2
@@ -410,13 +411,16 @@ F ext/session/sessionwor.test 2f3744236dc8b170a695b7d8ddc8c743c7e79fdc
 F ext/session/sqlite3session.c 2d29bbd888599b94b2c8b31ff433675e008273a4d225b336508b18e6187fec1d
 F ext/session/sqlite3session.h c01820d5b6e73e86d88008f4d1c1c7dfb83422963018292b864028a0400ceccf
 F ext/session/test_session.c dba36c6c0153b22501112d3e8882b5c946cf617c955153b6712bd2f8ba1428c0
+F ext/sqlrr/README.txt 4239030e73023e72a2e727808cd433577d5bf730
+F ext/sqlrr/sqlrr.c 8d1e6571cd6a6beabdb5bcdfe3a0e723b914db41
+F ext/sqlrr/sqlrr.h 09e4f8929ad9bc2638732c0cc0db5eef8c417824
 F ext/userauth/sqlite3userauth.h 7f3ea8c4686db8e40b0a0e7a8e0b00fac13aa7a3
 F ext/userauth/user-auth.txt e6641021a9210364665fe625d067617d03f27b04
 F ext/userauth/userauth.c 3410be31283abba70255d71fd24734e017a4497f
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 3f50dfe5cb4257c1aca96e417636ed51bc2561e71d31a21e9ccdf66feb912f43
+F main.mk ec0a9fd7686a9e4f11b47403a2ae5a9de6720e3b5e48b7292ad34cf625b9a249
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -431,34 +435,34 @@ F sqlite3.pc.in 48fed132e7cb71ab676105d2a4dc77127d8c1f3a
 F src/alter.c cf7a8af45cb0ace672f47a1b29ab24092a9e8cd8d945a9974e3b5d925f548594
 F src/analyze.c 71fbbeb7b25417592f54d869fe90c28b48e4cecb9926ef9b06d90fb0aec48941
 F src/attach.c 4a3138bd771d5426ae4344d8d5e900440af29fabc5ec2f39f69a45010dfbccd7
-F src/auth.c 6277d63837357549fe14e723490d6dc1a38768d71c795c5eb5c0f8a99f918f73
+F src/auth.c a38f3c63c974787ecf75e3213f8cac6568b9a7af7591fb0372ec0517dd16dca8
 F src/backup.c faf17e60b43233c214aae6a8179d24503a61e83b
 F src/bitvec.c 17ea48eff8ba979f1f5b04cc484c7bb2be632f33
 F src/btmutex.c 8acc2f464ee76324bf13310df5692a262b801808984c1b79defb2503bbafadb6
-F src/btree.c 8270813c8f0ca91b2802e88ded3755d04ee962a923d431c13bcb6cf3e0c18f63
+F src/btree.c 194a98d932f33a8fef0873f0cabd9c221c72c140caae8e5ddfee095fd0e47ffd
 F src/btree.h 448f15b98ea85dcf7e4eb76f731cadb89636c676ad25dfaac6de77cd66556598
 F src/btreeInt.h 620ab4c7235f43572cf3ac2ac8723cbdf68073be4d29da24897c7b77dda5fd96
-F src/build.c 50ff3e0fa07646b4d797aae0f773efcdb7602f6a5e2f5da27856503f35200889
-F src/callback.c fe677cb5f5abb02f7a772a62a98c2f516426081df68856e8f2d5f950929b966a
+F src/build.c 5fc41458505331bfb0c175f40b9a13cb335f826bed3ae311aaae000c132d7b16
+F src/callback.c 36caff1e7eb7deb58572d59c41cee8f064a11d00297616995c5050ea0cfc1288
 F src/complete.c a3634ab1e687055cd002e11b8f43eb75c17da23e
 F src/ctime.c 849d4cebe008cfc6e4799b034a172b4eaf8856b100739632a852732ba66eee48
 F src/date.c ebe1dc7c8a347117bb02570f1a931c62dd78f4a2b1b516f4837d45b7d6426957
 F src/dbpage.c 8db4c97f630e7d83f884ea75caf1ffd0988c160e9d530194d93721c80821e0f6
 F src/dbstat.c edabb82611143727511a45ca0859b8cd037851ebe756ae3db289859dd18b6f91
 F src/delete.c 4c8c7604277a2041647f96b78f4b9a47858e9217e4fb333d35e7b5ab32c5b57f
-F src/expr.c af4a81a385277510bfc56df87c25d76fc365f98c33bc8797c4a8d84b88e31013
+F src/expr.c 2d96dc299acee05a59da770e9a276cceb54558d2767104d915d16d8a466b1c67
 F src/fault.c 460f3e55994363812d9d60844b2a6de88826e007
-F src/fkey.c d617daf66b5515e2b42c1405b2b4984c30ca50fb705ab164271a9bf66c69e331
+F src/fkey.c b1da9ef8dc834603bb0d28972378a7ce65897847f9a1e89ab800bbdf24c788ee
 F src/func.c e2e3c02621a528a472933fd4733a5da635676f1461be73293f6e9f62f18d4eaa
 F src/global.c 9bf034fd560bdd514715170ed8460bb7f823cec113f0569ef3f18a20c7ccd128
 F src/hash.c a12580e143f10301ed5166ea4964ae2853d3905a511d4e0c44497245c7ce1f7a
 F src/hash.h ab34c5c54a9e9de2e790b24349ba5aab3dbb4fd4
 F src/hwtime.h 747c1bbe9df21a92e9c50f3bbec1de841dc5e5da
 F src/in-operator.md 10cd8f4bcd225a32518407c2fb2484089112fd71
-F src/insert.c 25f2e3cb93821944dec28921c4cfb7729b3ac6e75d860fd7cd934265404a35b0
-F src/legacy.c 134ab3e3fae00a0f67a5187981d6935b24b337bcf0f4b3e5c9fa5763da95bf4e
+F src/insert.c 76b1dc902e4c3930d9a17a40cd8ee2e94b1fd8cce766672caef164a6d5d4df1d
+F src/legacy.c 83f4499122392b1f1527a5180b1e89951bf640611ce98768bde1a9f28f0f7dde
 F src/loadext.c 6aae5739198d96c51ae6eb97c4a5b1744c22ed7a5a565a5399a717780d48a36b
-F src/main.c b56b2d62d5d11e3f5100b25fca34c13c62a0fe73941f6873454a7fa8a454170d
+F src/main.c 0eba75a0a4a7a4ea0d68ecf01a21f145e351984fa4efe101c54caaa244d671ae
 F src/malloc.c 07295435093ce354c6d9063ac05a2eeae28bd251d2e63c48b3d67c12c76f7e18
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c c12a42539b1ba105e3707d0e628ad70e611040d8f5e38cf942cee30c867083de
@@ -474,37 +478,38 @@ F src/mutex_noop.c 9d4309c075ba9cc7249e19412d3d62f7f94839c4
 F src/mutex_unix.c aaf9ebc3f89df28483c52208497a99a02cc3650011422fc9d4c57e4392f7fe58
 F src/mutex_w32.c 7670d770c94bbfe8289bec9d7f1394c5a00a57c37f892aab6b6612d085255235
 F src/notify.c 9711a7575036f0d3040ba61bc6e217f13a9888e7
-F src/os.c 1cb0d1d1b3a4267966dee6e292d2b2cdf88e47c0c59cebff27ecafac052dd165
+F src/os.c c46d15f4cbe775cd9eb703cc3a1d59a1c32f7dd4e79f01e0123dc7daa54b24b8
 F src/os.h 48388821692e87da174ea198bf96b1b2d9d83be5dfc908f673ee21fafbe0d432
 F src/os_common.h b2f4707a603e36811d9b1a13278bffd757857b85
 F src/os_setup.h 0dbaea40a7d36bf311613d31342e0b99e2536586
-F src/os_unix.c 2b53b0b8ddc580db096252c721729e5f5f2f355b4fc056f8f3fb328aeb3c9e8a
-F src/os_win.c ac29c25cde4cfb4adacc59cdec4aa45698ca0e29164ea127859585ccd9faa354
+F src/os_unix.c 90421208ca051e062158af9ac8f3917f9af17e12fddbe40901f3c46fdf6316f9
+F src/os_win.c 9f0d1f91afc260dd95d02218c8816b49dd083f25e651739a4b27a85f0cdf15e8
 F src/os_win.h 7b073010f1451abe501be30d12f6bc599824944a
-F src/pager.c 1bb6a57fa0465296a4d6109a1a64610a0e7adde1f3acf3ef539a9d972908ce8f
-F src/pager.h c571b064df842ec8f2e90855dead9acf4cbe0d1b2c05afe0ef0d0145f7fd0388
-F src/parse.y 07784439d25f0bc64a656eece4caecc549b147d213f513cdbeb8430345ec2911
+F src/pager.c a6f2fcf933b872db6c6987a10da651f87c14253fccccc3fa35de2491da9474e3
+F src/pager.h 340c4396d108cf3858ba0f8da46143d8d6fa3af399a7056f4cc2b6ffa39da29b
+F src/parse.y 0b81472496809693a139067fea1fe3f14a7be8aa26c8f18bb327034d1252a06a
 F src/pcache.c 135ef0bc6fb2e3b7178d49ab5c9176254c8a691832c1bceb1156b2fbdd0869bd
 F src/pcache.h 072f94d29281cffd99e46c1539849f248c4b56ae7684c1f36626797fee375170
-F src/pcache1.c 716975564c15eb6679e97f734cec1bfd6c16ac3d4010f05f1f8e509fc7d19880
-F src/pragma.c c0d13c0e82a9197aef5533d63300c5b0c8a216ae1fd14ada64e1f12f398d7e82
+F src/pcache1.c 77a8848baa3d396b8f597b2e8ba85d82ba00584e45e1c1c27d413712a1b0d88a
+F src/pragma.c fc2af8cd6c0944e319a7e1efc89ea3c8fc38430651f30e1a8fed81428c34c822
 F src/pragma.h bb83728944b42f6d409c77f5838a8edbdb0fe83046c5496ffc9602b40340a324
-F src/prepare.c 95a9dba7a5d032039a77775188cb3b6fb17f2fa1a0b7cd915b30b4b823383ffa
-F src/printf.c 1d1b4a568a58d0f32a5ff26c6b98db8a6e1883467f343a6406263cacd2e60c21
+F src/prepare.c 04a30fc5382abf1b5ee8bded957770701364f9479e1bfa364152bc74aff6a362
+F src/printf.c 7f6f3cba8e0c49c19e30a1ff4e9aeda6e06814dcbad4b664a69e1b6cb6e7e365
 F src/random.c 80f5d666f23feb3e6665a6ce04c7197212a88384
-F src/resolve.c 6415381a0e9d22c0e7cba33ca4a53f81474190862f5d4838190f5eb5b0b47bc9
+F src/resolve.c 14602f46800ba182ea6a490e0f304127d29ac1f724bdadcc639e25d3223fcf6e
 F src/rowset.c 7b7e7e479212e65b723bf40128c7b36dc5afdfac
-F src/select.c a35d462ee7a3c0856ad7a9d9c8921fbf3d91d911a8f39ad9d61302eb43b24a71
-F src/shell.c.in 51c100206f4b7f86cd9affd80b764825e0edc36ca0190c442e4ca7994611bfe2
-F src/sqlite.h.in e379906b85cc3539c6a37ab972f2c28711b28854a457f54e137d20f75db5db7c
+F src/select.c 3291892add3a8f01dc3754e40ef9e30ad22c78e3404a388ae58f0390a1fb29eb
+F src/shell.c.in c29cb307d6275131e6f9874e0fa73f87acf40a22c4a82faba2059a93b4d294d1
+F src/sqlite.h.in a93959f471da0867d8fcf88d822f990679bdcd0fbb3378ef7d14e2fc20f68bfc
 F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
+F src/sqlite3_private.h aee73ebaea1963e528b61408c01ba82f49fdf3dca9cbe940f3b0f3d9cec25942
 F src/sqlite3ext.h 9887b27e69c01e79c2cbe74ef73bf01af5b5703d6a7f0a4371e386d7249cb1c7
-F src/sqliteInt.h 5abdade4744cf3bd567afb65bb144bb3c61f6132f86813b995a5ca79c7b584e8
+F src/sqliteInt.h 96b4eedd7c010ebe48b224c578e567976bf24eecbd45f9eb0e0093b9d681933e
 F src/sqliteLimit.h 1513bfb7b20378aa0041e7022d04acb73525de35b80b252f1b83fedb4de6a76b
 F src/status.c 46e7aec11f79dad50965a5ca5fa9de009f7d6bde08be2156f1538a0a296d4d0e
 F src/table.c b46ad567748f24a326d9de40e5b9659f96ffff34
 F src/tclsqlite.c 916a92de77ec5cbe27818ca194d8cf0c58aa7ad5b87527098f6aa5a6068800ce
-F src/test1.c 51aa5f3030217ca45eb62e90944838794d4faaae7a8f60e0330ae01f30bc997b
+F src/test1.c d49d47d44902032b22c484a9d6022630e3303776e1650682250854d1e5148f86
 F src/test2.c 3efb99ab7f1fc8d154933e02ae1378bac9637da5
 F src/test3.c b8434949dfb8aff8dfa082c8b592109e77844c2135ed3c492113839b6956255b
 F src/test4.c 18ec393bb4d0ad1de729f0b94da7267270f3d8e6
@@ -519,7 +524,7 @@ F src/test_backup.c bf5da90c9926df0a4b941f2d92825a01bbe090a0
 F src/test_bestindex.c 78809f11026f18a93fcfd798d9479cba37e1201c830260bf1edc674b2fa9b857
 F src/test_blob.c ae4a0620b478548afb67963095a7417cd06a4ec0a56adb453542203bfdcb31ce
 F src/test_btree.c 8b2dc8b8848cf3a4db93f11578f075e82252a274
-F src/test_config.c 097c6189803886a1fb26ec37d8bc62b90512cb53ab79a1fb6d35196c1ec42ded
+F src/test_config.c 15d4d8f38d920d20b991a4156e43c95aad465734545a6ae91d46447f1fde17a1
 F src/test_delete.c e2fe07646dff6300b48d49b2fee2fe192ed389e834dd635e3b3bac0ce0bf9f8f
 F src/test_demovfs.c a0c3bdd45ed044115c2c9f7779e56eafff18741e
 F src/test_devsym.c 1960abbb234b97e9b920f07e99503fc04b443f62bbc3c6ff2c2cea2133e3b8a2
@@ -545,7 +550,7 @@ F src/test_rtree.c 671f3fae50ff116ef2e32a3bf1fe21b5615b4b7b
 F src/test_schema.c f575932cb6274d12147a77e13ea4b49d52408513
 F src/test_server.c a2615049954cbb9cfb4a62e18e2f0616e4dc38fe
 F src/test_sqllog.c 11e6ce7575f489155c604ac4b439f2ac1d3d5aef
-F src/test_superlock.c 4839644b9201da822f181c5bc406c0b2385f672e
+F src/test_superlock.c 793bb9d43a924c21993bcd6c2e200d3db8abf34e
 F src/test_syscall.c 1073306ba2e9bfc886771871a13d3de281ed3939
 F src/test_tclsh.c 58052fe48efe8f579834f4648d239569f2efc6285f5019ebdf0040f58d16238d
 F src/test_tclvar.c 33ff42149494a39c5fbb0df3d25d6fafb2f668888e41c0688d07273dcb268dfc
@@ -560,29 +565,29 @@ F src/tokenize.c bbde32eac9eb1280f5292bcdfef66f5a57e43176cbf9347e0efab9f75e133f9
 F src/treeview.c 2c5c4bc0a443401db5fd621542150452ddf5055d38edd4eef868bc2b6bfb0260
 F src/trigger.c 4ace6d1d5ba9a89822deb287317f33c810440526eafe185c2d8a48c31df1e995
 F src/update.c 46dc24c6158446aaab45caee09b6d99327cb479268b83ffeb5b701823da3b67b
-F src/upsert.c ae4a4823b45c4daf87e8aea8c0f582a8844763271f5ed54ee5956c4c612734f4
+F src/upsert.c 47edd408cc73f8d3c00a140550d1ad180b407c146285947969dd09874802bf88
 F src/utf.c 810fbfebe12359f10bc2a011520a6e10879ab2a163bcb26c74768eab82ea62a5
 F src/util.c d9eb0a6c4aae1b00a7369eadd7ca0bbe946cb4c953b6751aa20d357c2f482157
 F src/vacuum.c 37730af7540033135909ecaee3667dddec043293428d8718546d0d64ba4a5025
-F src/vdbe.c 565f7ccc4153627ef316bcfc2da86cb0766fac4b7dcd07c45a175c347d480f0a
-F src/vdbe.h d970d9738efdd09cb2df73e3a40856e7df13e88a3486789c49fcdd322c9eb8a2
-F src/vdbeInt.h 95f7adfdc5c8f1353321f55a6c5ec00a90877e3b85af5159e393afb41ff54110
-F src/vdbeapi.c 29d2baf9c1233131ec467d7bed1b7c8a03c27579048d768c4b04acf427838858
-F src/vdbeaux.c 3b0650dbebebb196010d8af830551e61ea7dcc0e414a2b747f897305b0bd0b8f
+F src/vdbe.c e0164a0f4d4efcc9335e6e1ec74656301f79642f8524183f2d08178314967702
+F src/vdbe.h e3f43bcc27ff30b0f25a6104d0cb5657e1c4b5e1b5cd2dd2216d5bcc2156a746
+F src/vdbeInt.h 42d3e65ea0c664f6d9bc9a53de645c0baf8566ff0188409ff3b8d2abc327bc17
+F src/vdbeapi.c 409748b4bdb694bd1330cc6345f4aa47fe02224bbfb30de9afd2d2dd96026a3c
+F src/vdbeaux.c b00d35805a2b326d1371ab7ce8f3a95c8af35b1431367ffe482fc2c735d69fb1
 F src/vdbeblob.c f5c70f973ea3a9e915d1693278a5f890dc78594300cf4d54e64f2b0917c94191
-F src/vdbemem.c 0cbe9b9560e42b72983cf9e1bceba48f297e51142bfb6b57f3747cf60106b92d
+F src/vdbemem.c 803323406d8623a7619ea5d5f74016697eeaed19c02b98ce9c3013e77dbe1c38
 F src/vdbesort.c 731a09e5cb9e96b70c394c1b7cf3860fbe84acca7682e178615eb941a3a0ef2f
 F src/vdbetrace.c 79d6dbbc479267b255a7de8080eee6e729928a0ef93ed9b0bfa5618875b48392
-F src/vtab.c 0e4885495172e1bdf54b12cce23b395ac74ef5729031f15e1bc1e3e6b360ed1a
+F src/vtab.c 10ea07dec111de6fb0a4fc87a7ffa4c65fdc088a19dbfaf7d6f2b128f2e8eb7b
 F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
-F src/wal.c aa9cffc7a2bad6b826a86c8562dd4978398720ed41cb8ee7aa9d054eb8b456a0
-F src/wal.h 8de5d2d3de0956d6f6cb48c83a4012d5f227b8fe940f3a349a4b7e85ebcb492a
+F src/wal.c fe0187275982737e0576ba2572f75d48a4ac70f37911cb68905644e690d884da
+F src/wal.h bada9007800e82f2765ad9ecd9f96176b45c71db769502e24de49d68c0acef65
 F src/walker.c da987a20d40145c0a03c07d8fefcb2ed363becc7680d0500d9c79915591f5b1f
 F src/where.c 60ec752fcbe9f9e0271ac60548d159a540a1ee47a4f9fedc85e88a3d0e392dd1
 F src/whereInt.h cbae2bcd37cfebdb7812a8b188cdb19634ced2b9346470d1c270556b0c33ea53
 F src/wherecode.c 728c7f70731430ccdac807a79969873e1af6968bf1c4745dff3f9dd35f636cc8
 F src/whereexpr.c e90b2e76dcabc81edff56633bf281bc01d93b71e0c81482dc06925ce39f5844a
-F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
+F test/8_3_names.test 05034aadccd2253ffe6cbefb06662b8aa4600f77
 F test/affinity2.test a6d901b436328bd67a79b41bb0ac2663918fe3bd
 F test/affinity3.test 6a101af2fc945ce2912f6fe54dd646018551710d
 F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
@@ -617,16 +622,16 @@ F test/async4.test 1787e3952128aa10238bf39945126de7ca23685a
 F test/async5.test 383ab533fdb9f7ad228cc99ee66e1acb34cc0dc0
 F test/atof1.test ff0b0156fd705b67c506e1f2bfe9e26102bea9bd
 F test/atomic.test 065a453dde33c77ff586d91ccaa6ed419829d492dbb1a5694b8a09f3f9d7d061
-F test/attach.test f4b8918ba2f3e88e6883b8452340545f10a1388af808343c37fc5c577be8281c
+F test/attach.test 402747cea8096d238f8ee8ad3e2b27c05613eb0eb8f697eae1ed1753926763fc
 F test/attach2.test 256bd240da1835fb8408dd59fb7ef71f8358c7a756c46662434d11d07ba3a0ce
 F test/attach3.test c59d92791070c59272e00183b7353eeb94915976
-F test/attach4.test 53bf502f17647c6d6c5add46dda6bac8b6f4665c
+F test/attach4.test faaaf33fa51f986b414520cb03cecdc7999df108
 F test/attachmalloc.test 3a4bfca9545bfe906a8d2e622de10fbac5b711b0
 F test/auth.test 3d6cd8f3978ba55b1202574e6ecd79c6e00914ca44b9bfd6c1fe6fb873fcac88
 F test/auth2.test 9eb7fce9f34bf1f50d3f366fb3e606be5a2000a1
 F test/auth3.test db21405b95257c24d29273b6b31d0efc59e1d337e3d5804ba2d1fd4897b1ae49
 F test/autoanalyze1.test b9cc3f32a990fa56669b668d237c6d53e983554ae80c0604992e18869a0b2dec
-F test/autoinc.test c6df81f1de9a5499f912c58e5389d0bcb8d42459df832b65aee24338ad422a42
+F test/autoinc.test 9d202b7dce6571e52b744138eff12610214501acd635abdd72d18736cd06fd22
 F test/autoindex1.test a09958fa756129af10b6582bcbf3cbdf11e305e027b393f393caef801159dee0
 F test/autoindex2.test 12ef578928102baaa0dc23ad397601a2f4ecb0df
 F test/autoindex3.test 2dd997d6590438b53e4f715f9278aa91c9299cf3f81246a0915269c35beb790e
@@ -656,7 +661,7 @@ F test/bigfile2.test 1b489a3a39ae90c7f027b79110d6b4e1dbc71bfc
 F test/bigmmap.test 31dad31573638bd32de866cdefd11843f75685be4ba6aec1a47918f098f1899b
 F test/bigrow.test f0aeb7573dcb8caaafea76454be3ade29b7fc747
 F test/bigsort.test 8299fa9298f4f1e02fc7d2712e8b77d6cd60e5a2
-F test/bind.test 1e136709b306f7ed3192d349c2930d89df6ab621654ad6f1a72381d3fe76f483
+F test/bind.test d9134cb9300ccef302e94dfd66008dc24f14af48595e30beabb49dccbc0ef3ca
 F test/bindxfer.test efecd12c580c14df5f4ad3b3e83c667744a4f7e0
 F test/bitvec.test 75894a880520164d73b1305c1c3f96882615e142
 F test/blob.test e7ac6c7d3a985cc4678c64f325292529a69ae252
@@ -672,7 +677,7 @@ F test/btree01.test e08b3613540145b353f20c81cb18ead54ff12e0f
 F test/btree02.test fe69453d474d8154d19b904157ff1db4812fed99
 F test/btreefault.test c2bcb542685eea44621275cfedbd8a13f65201e3
 F test/busy.test 510dc6daaad18bcbbc085bcc6217d6dc418def5e73f72ce1475eea0cb7834727
-F test/cache.test 13bc046b26210471ca6f2889aceb1ea52dc717de
+F test/cache.test 0bc2195f4a7207108af2617ed356e77daf4412f7
 F test/cacheflush.test af25bb1509df04c1da10e38d8f322d66eceedf61
 F test/cachespill.test 895997f84a25b323b166aecb69baab2d6380ea98f9e0bcc688c4493c535cfab9
 F test/capi2.test 34a1a9a96d543a2ec2c209696b11b164444f57253b1f2cba1c2e53fadede6c7b
@@ -739,7 +744,7 @@ F test/crashM.test d95f59046fa749b0d0822edf18a717788c8f318d
 F test/crashtest1.c 09c1c7d728ccf4feb9e481671e29dda5669bbcc2
 F test/createtab.test b5de160630b209c4b8925bdcbbaf48cc90b67fe8
 F test/cse.test 277350a26264495e86b1785f34d2d0c8600e021c
-F test/csv01.test b99db7e57ee66fb3aa6e5d25af119003bee90bf679c5885711cbf7374f025b73
+F test/csv01.test 6e1445b3207d574cff22fc41a8e549dfcf2466ee90546ada97d22a90fa89eb58
 F test/ctime.test 78749e6c9a5f0010d67985be80788f841e3cd2da18114e2ed6010399a7d807f3
 F test/cursorhint.test 7bc346788390475e77a345da2b92270d04d35856
 F test/cursorhint2.test 0078ae1ded4afcf5eb80d06e3a72b6e1c3f1a646aab26eeb583b0a9ec6f0d56e
@@ -748,7 +753,7 @@ F test/date2.test 74c234bece1b016e94dd4ef9c8cc7a199a8806c0e2291cab7ba64bace6350b
 F test/dbfuzz.c 73047c920d6210e5912c87cdffd9a1c281d4252e
 F test/dbpage.test dbf50a4d361f9e45a979432c727506065113124478a7d2db12074fa655e65d6c
 F test/dbstatus.test c15fa97f743dac7ce996814c84b56317e138895ee15ce27f15b608aa6924c90a
-F test/dbstatus2.test f5fe0afed3fa45e57cfa70d1147606c20d2ba23feac78e9a172f2fe8ab5b78ef
+F test/dbstatus2.test ce94261a9e45cfd2d08195a82553c03b45c01e5ebad8a17888aeef818d9da69c
 F test/default.test 0cb49b1c315a0d81c81d775e407f66906a2a604d
 F test/delete.test 31832b0c45ecb51a54348c68db173be462985901e6ed7f403d6d7a8f70ab4ef0
 F test/delete2.test 3a03f2cca1f9a67ec469915cb8babd6485db43fa
@@ -772,7 +777,7 @@ F test/e_delete.test ab39084f26ae1f033c940b70ebdbbd523dc4962e
 F test/e_droptrigger.test 3cd080807622c13e5bbb61fc9a57bd7754da2412
 F test/e_dropview.test 21ce09c361227ddbc9819a5608ee2700c276bdd5
 F test/e_expr.test ca8896601ade1e27c6559614c7f32c63d44636fdfa720436a160f09b8bf66c89
-F test/e_fkey.test dcdc6ad26b1d4f07636208de4c1c22aae7c0597a685a6c10fe6da91f3191dd96
+F test/e_fkey.test 9778696ef9fceacebed8d482d02b47287981faaedf6f73db563ea8a7afb546da
 F test/e_fts3.test 8cf40550bb088a6aa187c818c00fabe26ef82900a4cd5c66b427ccafe28bedaa
 F test/e_insert.test f02f7f17852b2163732c6611d193f84fc67bc641fb4882c77a464076e5eba80e
 F test/e_reindex.test 2bebf7b393e519198b7c654407221cf171a439b8
@@ -783,9 +788,9 @@ F test/e_totalchanges.test b12ee5809d3e63aeb83238dd501a7bca7fd72c10
 F test/e_update.test f46c2554d915c9197548681e8d8c33a267e84528
 F test/e_uri.test 47eeb2960e74613f0f8722b2f13aef08fde69daa16e5380ac93df84dac8b1f72
 F test/e_vacuum.test 1b8b4772d05374aa1b8958669138bbb4213ee26a
-F test/e_wal.test ae9a593207a77d711443ee69ffe081fda9243625
+F test/e_wal.test 95c21e45eefe4cc31e820f998b14f92d1cb3a1bf
 F test/e_walauto.test 248af31e73c98df23476a22bdb815524c9dc3ba8
-F test/e_walckpt.test 28c371a6bb5e5fe7f31679c1df1763a19d19e8a0
+F test/e_walckpt.test 9f20ab843538484c57069074b126699266ee5521
 F test/e_walhook.test 01b494287ba9e60b70f6ebf3c6c62e0ffe01788e344a4846b08e5de0b344cb66
 F test/emptytable.test a38110becbdfa6325cd65cb588dca658cd885f62
 F test/enc.test e54531cd6bf941ee6760be041dff19a104c7acea
@@ -795,14 +800,14 @@ F test/enc4.test c8f1ce3618508fd0909945beb8b8831feef2c020
 F test/eqp.test 4fd69d25f21d8679f5fce13e639975879d89abf6acce4bd9cede133b7482aba7
 F test/errmsg.test eae9f091eb39ce7e20305de45d8e5d115b68fa856fba4ea6757b6ca3705ff7f9
 F test/eval.test a64c9105d6ff163df7cf09d6ac29cdad5922078c
-F test/exclusive.test 1206b87e192497d78c7f35552e86a9d05421498da300fb1cce5ca5351ccde3c3
+F test/exclusive.test e6b1f19261732fb0c32401393917b640d3b4e7df397f72ceff201d6548907f47
 F test/exclusive2.test 984090e8e9d1b331d2e8111daf6e5d61dda0bef7
 F test/exec.test e949714dc127eaa5ecc7d723efec1ec27118fdd7
 F test/exists.test 79a75323c78f02bbe9c251ea502a092f9ef63dac
 F test/expr.test 7cb55e80aeb41d65fec968c08212505123063fea60bdc355d764d747670e9eea
 F test/extension01.test 00d13cec817f331a687a243e0e5a2d87b0e358c9
 F test/extraquick.test cb254400bd42bfb777ff675356aabf3287978f79
-F test/fallocate.test 07416bd593a116d5893cb244f45a94d5c6fe030561df3bd972e6135f8106e509
+F test/fallocate.test 0ba4d7f1ca7268519f0f5515f654a924627ba1aa1efddca120d608ddb590b513
 F test/filectrl.test 6e871c2d35dead1d9a88e176e8d2ca094fec6bb3
 F test/filefmt.test f393e80c4b8d493b7a7f8f3809a8425bbf4292af1f5140f01cb1427798a2bbd4
 F test/fkey1.test d11dbb8a93ead9b5c46ae5d02da016d61245d47662fb2d844c99214f6163f768
@@ -968,13 +973,13 @@ F test/in4.test d2b38cba404bc4320f4fe1b595b3d163f212c068
 F test/in5.test 7ae37fcd4a5e198291c6ab5f31a5bb3d15397efe8b75a6736d7a95a7b8dd9e08
 F test/incrblob.test c9b96afc292aeff43d6687bcb09b0280aa599822
 F test/incrblob2.test a494c9e848560039a23974b9119cfc2cf3ad3bd15cc2694ee6367ae537ef8f1f
-F test/incrblob3.test d8d036fde015d4a159cd3cbae9d29003b37227a4
+F test/incrblob3.test 5fa6f2665ae37da05928bb16851d4f86515af78a
 F test/incrblob4.test 21a52a6843a56cdcce968c6a86b72a7066d0e6ba
 F test/incrblob_err.test 69f9247fed50278d48ea710d1a8f9cdb09e4c0b8
 F test/incrblobfault.test 74dd8ac108304cea0b4a0df6df63a1567e558758
 F test/incrcorrupt.test 6c567fbf870aa9e91866fe52ce6f200cd548939a
 F test/incrvacuum.test b729aab1d4983037da57e66c20dfd7458561a85626dcf824f60175e35f4ce152
-F test/incrvacuum2.test 7d26cfda66c7e55898d196de54ac4ec7d86a4e3d
+F test/incrvacuum2.test 1e873b6caf87ce160d4cb6d8c7a46f0570da1ddc
 F test/incrvacuum3.test 75256fb1377e7c39ef2de62bfc42bbff67be295a
 F test/incrvacuum_ioerr.test 6ae2f783424e47a0033304808fe27789cf93e635
 F test/index.test fe3c7a1aad82af92623747e9c3f3aa94ccd51238
@@ -1018,7 +1023,7 @@ F test/join5.test 5a2da0c3ea852a7063d3e72fc7d5a04a6de5ef6e6d85092582f69033f7459a
 F test/join6.test cfe6503791ceb0cbb509966740286ec423cbf10b
 F test/journal1.test c7b768041b7f494471531e17abc2f4f5ebf9e5096984f43ed17c4eb80ba34497
 F test/journal2.test 9dac6b4ba0ca79c3b21446bbae993a462c2397c4
-F test/journal3.test c9c29883f5bf535ae82ae21c472df6263806a22e467b6db7cd0d6d545305b4f6
+F test/journal3.test eab2157ce43e68866782917aa0857de736ec2d42d825fc500d6836b707c236ba
 F test/jrnlmode.test a6693f2bed4541a21e703aaa37bb3e10de154130645952933b82b2dec0a8b539
 F test/jrnlmode2.test 8759a1d4657c064637f8b079592651530db738419e1d649c6df7048cd724363d
 F test/jrnlmode3.test 556b447a05be0e0963f4311e95ab1632b11c9eaa
@@ -1041,17 +1046,18 @@ F test/lock.test be4fe08118fb988fed741f429b7dd5d65e1c90db
 F test/lock2.test 5242d8ac4e2d59c403aebff606af449b455aceff
 F test/lock3.test f271375930711ae044080f4fe6d6eda930870d00
 F test/lock4.test 27143363eda1622f03c133efc8db808fc331afd973486cb571ea71cd717d37b8
-F test/lock5.test c6c5e0ebcb21c61a572870cc86c0cb9f14cede38
-F test/lock6.test ad5b387a3a8096afd3c68a55b9535056431b0cf5
+F test/lock5.test 1f1e0fd1670deef8c0a76e8f895bd5e124133ca4
+F test/lock6.test 83434ae8ca1d1c5e2eaf74d4e44aa24ab62b291c
 F test/lock7.test 49f1eaff1cdc491cc5dee3669f3c671d9f172431
 F test/lock_common.tcl 7ffb45accf6ee91c736df9bafe0806a44358f035
+F test/lock_proxy.test 95be9c32d79be25cf643b4e41a0aa0e53aa21621
 F test/lookaside.test b17c99ae3aef96a8c9fa6f6be33cc75b93d657cb791d3827302b6835b71941f7
-F test/main.test 6bbb3999fd461eb8fb335cbab97409a3d7f91bbb8da60635e8be3e4a04a77772
+F test/main.test ad8fa65ab7f5d5c6cc4ac287f9d70f21d285361e3ab194fcba16ddf49b7c29d7
 F test/make-where7.tcl 05c16b5d4f5d6512881dfec560cb793915932ef9
 F test/malloc.test 18dd1c4188c81ca79cf123527c71b19ee0c31feb9947fdffb0dc6ceb1436816a
 F test/malloc3.test 6e88bae6312854a4adb4ecc2a6a5ea8c59b4db778b724ba718e1c43fc8c3c136
 F test/malloc4.test 957337613002b7058a85116493a262f679f3a261
-F test/malloc5.test f6eb6eca07a4c75f2897bf43a404689b6295bb95ab2e07d4b52eda743f925a27
+F test/malloc5.test 2e4ad7684a13389a44a840499cd47173a8d05f22f082d7d083eece433a7a64eb
 F test/malloc6.test 2f039d9821927eacae43e1831f815e157659a151
 F test/malloc7.test 7c68a32942858bc715284856c5507446bba88c3a
 F test/malloc8.test 9b7a3f8cb9cf0b12fff566e80a980b1767bd961d
@@ -1070,13 +1076,13 @@ F test/mallocJ.test b5d1839da331d96223e5f458856f8ffe1366f62e
 F test/mallocK.test 1f4b5efbf61715ab79b20b38739ff4b3d110ceb53f54e5db6da1f01c083707ab
 F test/mallocL.test fb311ff80afddf3b1a75e52289081f4754d901dc
 F test/mallocM.test 78bbe9d3da84a5c679123cdb40d7b2010b18fc46e13897e4f253c6ba6fbff134
-F test/malloc_common.tcl aac62499b76be719fac31e7a3e54a7fd53272e7f
-F test/manydb.test 28385ae2087967aa05c38624cec7d96ec74feb3e
+F test/malloc_common.tcl 8d368ee0b9d77c9643b174448f137c18b68e49f4
+F test/manydb.test 3cd8e52ab3112cb8365afeedd6e8231977920577
 F test/mem5.test c6460fba403c5703141348cd90de1c294188c68f
-F test/memdb.test c1f2a343ad14398d5d6debda6ea33e80d0dafcc7
+F test/memdb.test c46019291625650d71416e770f6a54a281a1a98f
 F test/memdb1.test 61aa1dbdeea6320791d2ff42a9a6149d5716be674bf06ee0ffa0aad1bf3eb5f8
 F test/memleak.test 10b9c6c57e19fc68c32941495e9ba1c50123f6e2
-F test/memsubsys1.test 9e7555a22173b8f1c96c281ce289b338fcba2abe8b157f8798ca195bbf1d347e
+F test/memsubsys1.test 21f6e0e93302665caa03f37bf832afa1e8dde768d3f5547a5c59a03655d3bfaa
 F test/memsubsys2.test 3e4a8d0c05fd3e5fa92017c64666730a520c7e08
 F test/minmax.test 6751e87b409fe11b02e70a306d846fa544e25a41
 F test/minmax2.test dae92964ac87c1d2ef978c582e81a95e11c00f1cbef68980bfb2abaf10315063
@@ -1088,7 +1094,7 @@ F test/misc3.test cf3dda47d5dda3e53fc5804a100d3c82be736c9d
 F test/misc4.test 0d8be3466adf123a7791a66ba2bc8e8d229e87f3
 F test/misc5.test 60e1fc758a93cacd19eb2fafcd1d40d150a05047546c7a92389c98047d621901
 F test/misc6.test 953cc693924d88e6117aeba16f46f0bf5abede91
-F test/misc7.test 567e223b6497da2226a0340befaf2d663c91ad57a48aede21a35a984a2882d41
+F test/misc7.test 349855706310f0de6b91645d199f6874f518627fd057743fa4e3689b60d06efc
 F test/misc8.test 8fb0f31d7a8aed484d759773ab8ad12ec746a477f4a67394a4af0e677494c3ca
 F test/misuse.test 9e7f78402005e833af71dcab32d048003869eca5abcaccc985d4f8dc1d86bcc7
 F test/mjournal.test 9d86e697dcbc5da2c4e8caba9b176b5765fe65e80c88c278b8c09a917e436795
@@ -1098,7 +1104,7 @@ F test/mmap3.test b3c297e78e6a8520aafcc1a8f140535594c9086e
 F test/mmap4.test 2e2b4e32555b58da15176e6fe750f17c9dcf7f93
 F test/mmapfault.test d4c9eff9cd8c2dc14bc43e71e042f175b0a26fe3
 F test/mmapwarm.test 2272005969cd17a910077bd5082f70bc1fefad9a875afec7fc9af483898ecaf3
-F test/multiplex.test dc0d67b66f84b484a83cb8bbdf3f0a7f49562ccd
+F test/multiplex.test 659fdd41065d4af3fc769b87052c275d0c4685fb
 F test/multiplex2.test 580ca5817c7edbe4cc68fa150609c9473393003a
 F test/multiplex3.test d228f59eac91839a977eac19f21d053f03e4d101
 F test/multiplex4.test e8ae4c4bd70606a5727743241f13b5701990abe4
@@ -1129,28 +1135,28 @@ F test/orderby6.test 8b38138ab0972588240b3fca0985d2e400432859
 F test/orderby7.test 3d1383d52ade5b9eb3a173b3147fdd296f0202da
 F test/orderby8.test 23ef1a5d72bd3adcc2f65561c654295d1b8047bd
 F test/orderby9.test 87fb9548debcc2cd141c5299002dd94672fa76a3
-F test/oserror.test b32dc34f2363ef18532e3a0a7358e3e7e321974f
+F test/oserror.test e7b3416be4b9d5dd2fe0b42dd394daaddbb6c83eeec1f0e47b120b53e0ad3ace
 F test/ossfuzz.c c4c4547e2c92ac52f10038b073a03248251a23c1c559728f63a18aeca0e79f03
 F test/ossshell.c f125c5bd16e537a2549aa579b328dd1c59905e7ab1338dfc210e755bb7b69f17
 F test/ovfl.test 199c482696defceacee8c8e0e0ef36da62726b2f
-F test/pager1.test a32ce299ed01ffb06e84a3af467ae1f3389786b316f40c4359f442c79144736b
+F test/pager1.test cfd1c1dd00c5d5dece44476e817cfb57b578a4c1ef1425307001da6bdfa6a24f
 F test/pager2.test 67b8f40ae98112bcdba1f2b2d03ea83266418c71
 F test/pager3.test 4e9a83d6ca0838d7c602c9eb93d1357562d9059c1e02ffb138a8271020838370
 F test/pager4.test a122e9e6925d5b23b31e3dfef8c6a44bbf19590e
-F test/pagerfault.test 63c5da625562c66345ab4528790327ca63db2f6f9cbae2aba8cb7c51de3d1628
+F test/pagerfault.test 4934ada4438c6bb3f58bbffed5147cd22208ae2dda7837b6e012cf212a3eff51
 F test/pagerfault2.test caf4c7facb914fd3b03a17b31ae2b180c8d6ca1f
 F test/pagerfault3.test 1003fcda009bf48a8e22a516e193b6ef0dd1bbd8
 F test/pageropt.test 84e4cc5cbca285357f7906e99b21be4f2bf5abc0
 F test/pagesize.test 5769fc62d8c890a83a503f67d47508dfdc543305
 F test/parser1.test 391b9bf9a229547a129c61ac345ed1a6f5eb1854
-F test/pcache.test c8acbedd3b6fd0f9a7ca887a83b11d24a007972b
+F test/pcache.test 9a04fa260cb47dd4fdc5d13c5e97054e05931592
 F test/pcache2.test af7f3deb1a819f77a6d0d81534e97d1cf62cd442
 F test/percentile.test 4243af26b8f3f4555abe166f723715a1f74c77ff
 F test/permutations.test 10793f1de89a226fa22dde9ba9398de22571fee1bfb53a935a11be4aa014704f
-F test/pragma.test 7c8cfc328a1717a95663cf8edb06c52ddfeaf97bb0aee69ae7457132e8d39e7d
+F test/pragma.test 3ce8294c0f86ef7586e44fdc7be887f0cfeaec01093ad3e24d5736b96fb55984
 F test/pragma2.test e5d5c176360c321344249354c0c16aec46214c9f
 F test/pragma3.test 14c12bc5352b1e100e0b6b44f371053a81ccf8ed
-F test/pragma4.test 3046501bee2f652dc2a4f9c87781e2741361d6864439c8381aba6c3b774b335c
+F test/pragma4.test da107b2fd465e67aa9f419a4e313b26b76336fabf71059c51d0b3211a6ae3c51
 F test/pragma5.test 824ce6ced5d6b7ec71abe37fc6005ff836fe39d638273dc5192b39864b9ee983
 F test/pragmafault.test 275edaf3161771d37de60e5c2b412627ac94cef11739236bec12ed1258b240f8
 F test/printf.test b3ff34e73d59124140eaf89f7672e21bc2ca5fcc
@@ -1172,12 +1178,12 @@ F test/regexp1.test 497ea812f264d12b6198d6e50a76be4a1973a9d8
 F test/regexp2.test 40e894223b3d6672655481493f1be12012f2b33c
 F test/reindex.test 44edd3966b474468b823d481eafef0c305022254
 F test/releasetest.tcl 5f15ab8056799e9a6e26a310d49236d2e774d6a30d0ec74601e18d4ce146b79c x
-F test/resetdb.test 7fda92e443233208ec5e1825b176a9df63fb5bf962248e08b76eb4296c630cdf
+F test/resetdb.test 2107b34a8c437183f48eb833905df43818160a55f4ac69bbaf54f356fb2b27bd
 F test/resolver01.test f4022acafda7f4d40eca94dbf16bc5fc4ac30ceb
 F test/rollback.test 06680159bc6746d0f26276e339e3ae2f951c64812468308838e0a3362d911eaa
 F test/rollback2.test bc868d57899dc6972e2b4483faae0e03365a0556941474eec487ae21d8d38bb6
 F test/rollbackfault.test 0e646aeab8840c399cfbfa43daab46fd609cf04a
-F test/rowallock.test 3f88ec6819489d0b2341c7a7528ae17c053ab7cc
+F test/rowallock.test e8c576ebc92f6b9211662f495658fd39bbcacb5b
 F test/rowhash.test 0bc1d31415e4575d10cacf31e1a66b5cc0f8be81
 F test/rowid.test 5b7509f384f4f6fae1af3c8c104c8ca299fea18d
 F test/rowvalue.test ef851a80f7e6de93b51caca9e4b6b7d2dcd540bbcca7d51860e80435b8b4c0de
@@ -1228,7 +1234,7 @@ F test/server1.test 46803bd3fe8b99b30dbc5ff38ffc756f5c13a118
 F test/session.test 78fa2365e93d3663a6e933f86e7afc395adf18be
 F test/sessionfuzz-data1.db 1f8d5def831f19b1c74571037f0d53a588ea49a6c4ca2a028fc0c27ef896dbcb
 F test/sessionfuzz.c b0fcdcf757451957e17396a3af5171f1fdf9b2babc81da9fa35675df46c4729a
-F test/shared.test 1da9dbad400cee0d93f252ccf76e1ae007a63746
+F test/shared.test 13376ba3be1c5685ab1ec184189adabd15fa70be
 F test/shared2.test 03eb4a8d372e290107d34b6ce1809919a698e879
 F test/shared3.test ab693f9b6e156b8bfb2a0ad94f29fe69602a5d38
 F test/shared4.test c75f476804e76e26bf6fa0e7b421fb0ca7d07558
@@ -1250,7 +1256,7 @@ F test/shell7.test 115132f66d0463417f408562cc2cf534f6bbc6d83a6d50f0072a9eb171bae
 F test/shell8.test 96be02ea0c21f05b24c1883d7b711a1fa8525a68ab7b636aacf6057876941013
 F test/shortread1.test bb591ef20f0fd9ed26d0d12e80eee6d7ac8897a3
 F test/show_speedtest1_rtree.tcl 32e6c5f073d7426148a6936a0408f4b5b169aba5
-F test/shrink.test 1b4330b1fd9e818c04726d45cb28db73087535ce
+F test/shrink.test 09bc6e2473321e7a4711ae7d753865daffc42f4a
 F test/sidedelete.test f0ad71abe6233e3b153100f3b8d679b19a488329
 F test/skipscan1.test 8ab5d2c7c5cd3fe7f172d366e6e74e887cb33cb4
 F test/skipscan2.test ef143c6e4a5ba4f19c1d1e3f517811f7942bdf2142736cc568feb34e0b5fb763
@@ -1288,7 +1294,7 @@ F test/sqllimits1.test a74ee2a3740b9f9c2437c246d8fb77354862a142
 F test/sqllog.test 6af6cb0b09f4e44e1917e06ce85be7670302517a
 F test/stat.test f8f1279ffffabe6df825723af18cc6e0ae70a893
 F test/statfault.test f525a7bf633e50afd027700e9a486090684b1ac1
-F test/stmt.test 54ed2cc0764bf3e48a058331813c3dbd19fc1d0827c3d8369914a5d8f564ec75
+F test/stmt.test 96bf5c903079f6966498428c953e13dd0192add53230de87a52c59bd505d060a
 F test/stmtvtab1.test 6873dfb24f8e79cbb5b799b95c2e4349060eb7a3b811982749a84b359468e2d5
 F test/subjournal.test 8d4e2572c0ee9a15549f0d8e40863161295107e52f07a3e8012a2e1fdd093c49
 F test/subquery.test d7268d193dd33d5505df965399d3a594e76ae13f
@@ -1296,7 +1302,7 @@ F test/subquery2.test 8250dfd6a773b04c7a5c37ac63276f62b329157ce171244d0cbe1acc36
 F test/subselect.test 0966aa8e720224dbd6a5e769a3ec2a723e332303
 F test/substr.test 18f57c4ca8a598805c4d64e304c418734d843c1a
 F test/subtype1.test 7fe09496352f97053af1437150751be2d0a0cae8
-F test/superlock.test ec94f0556b6488d97f71c79f9061ae08d9ab8f12
+F test/superlock.test c86eacd6cead5da9c5ecd25f3d46fca30a927ef2
 F test/swarmvtab.test 9a3fd5ab3e9b3c976ad1b3d7646aab725114f2ac26b59395d0778b33bab6cdaf
 F test/swarmvtab2.test c948cb2fdfc5b01d85e8f6d6504854202dc1a0782ab2a0ed61538f27cbd0aa5c
 F test/swarmvtab3.test 6cb664669630fcec4102a09333e52068734858fd2761eee3b0465c14cdbcee29
@@ -1311,14 +1317,14 @@ F test/table.test b708f3e5fa2542fa51dfab21fc07b36ea445cb2f
 F test/tableapi.test 2674633fa95d80da917571ebdd759a14d9819126
 F test/tableopts.test dba698ba97251017b7c80d738c198d39ab747930
 F test/tclsqlite.test 5337e8890b96dad1ee541b15fbeec32e6bac2fe7fa096f91089057385aadba9b
-F test/tempdb.test 4cdaa23ddd8acb4d79cbb1b68ccdfd09b0537aaba909ca69a876157c2a2cbd08
+F test/tempdb.test 8d0c2ee1cc2286629ca1d7e4e470a8ecf3951b65fb93c6bb7e27fee8ed9f8055
 F test/tempdb2.test 4749545409c6d7438b435c3f05cdd139cf4145a954a6908d19e3443ffd8724b3
 F test/tempfault.test 0c0d349c9a99bf5f374655742577f8712c647900
 F test/temptable.test d2c9b87a54147161bcd1822e30c1d1cd891e5b30
 F test/temptable2.test d2940417496e2b9548e01d09990763fbe88c316504033256d51493e1f1a5ce6a
 F test/temptable3.test d11a0974e52b347e45ee54ef1923c91ed91e4637
 F test/temptrigger.test 38f0ca479b1822d3117069e014daabcaacefffcc
-F test/tester.tcl aa7558f20fcf7dd9151325f849d9103bd450235093bc078073bf0f080991e3c4
+F test/tester.tcl 06501adc7445d67c50bae9d0d6ede96cb44963369ab1ddeb4d770f79cfd4f974
 F test/thread001.test b61a29dd87cf669f5f6ac96124a7c97d71b0c80d9012746072055877055cf9ef
 F test/thread002.test e630504f8a06c00bf8bbe68528774dd96aeb2e58
 F test/thread003.test ee4c9efc3b86a6a2767516a37bd64251272560a7
@@ -1335,10 +1341,10 @@ F test/time-wordcount.sh 8e0b0f8109367827ad5d58f5cc849705731e4b90
 F test/tkt-02a8e81d44.test 6c80d9c7514e2a42d4918bf87bf6bc54f379110c
 F test/tkt-26ff0c2d1e.test c15bec890c4d226c0da2f35ff30f9e84c169cfef90e73a8cb5cec11d723dfa96
 F test/tkt-2a5629202f.test 0521bd25658428baa26665aa53ffed9367d33af2
-F test/tkt-2d1a5c67d.test be1326f3061caec85085f4c9ee4490561ca037c0
+F test/tkt-2d1a5c67d.test 58a56653795d1787f4ed661f9da7da153b0dc3f9
 F test/tkt-2ea2425d34.test 1cf13e6f75d149b3209a0cb32927a82d3d79fb28
 F test/tkt-31338dca7e.test 6fb8807851964da0d24e942f2e19c7c705b9fb58
-F test/tkt-313723c356.test 4b306ad45c736cedf2f5221f6155b92143244b6d
+F test/tkt-313723c356.test d78f772dd71d632f3d3f6d3d588c3105b2ab1bb3
 F test/tkt-385a5b56b9.test 5204a7cba0e28c99df0acbf95af5e1af4d32965a7a14de6eccebf949607618b1
 F test/tkt-38cb5df375.test f3cc8671f1eb604d4ae9cf886ed4366bec656678
 F test/tkt-3998683a16.test 6d1d04d551ed1704eb3396ca87bb9ccc8c5c1eb7
@@ -1438,7 +1444,7 @@ F test/tkt3357.test 77c37c6482b526fe89941ce951c22d011f5922ed
 F test/tkt3419.test 1bbf36d7ea03b638c15804251287c2391f5c1f6b
 F test/tkt3424.test 61f831bd2b071bd128fa5d00fbda57e656ca5812
 F test/tkt3442.test a1fc47c669e651d16494de3ff349bcb53281456f2ca02c8bc14220b6044bbfe8
-F test/tkt3457.test 5651e2cbb94645b677ec663160b9e192b87b7d365aecdfb24e19f749575a6fc2
+F test/tkt3457.test 0316b1541debab33d784e82bd41efa05fd26931a77018c6e762d79e15087210a
 F test/tkt3461.test 228ea328a5a21e8663f80ee3d212a6ad92549a19
 F test/tkt3493.test 1686cbde85f8721fc1bdc0ee72f2ef2f63139218
 F test/tkt3508.test d75704db9501625c7f7deec119fcaf1696aefb7d
@@ -1552,38 +1558,38 @@ F test/vtabJ.test d7b73675708cf63cfcb9d443bb451fc01a028347275b7311e51f9fdf3ca675
 F test/vtab_alter.test 736e66fb5ec7b4fee58229aa3ada2f27ec58bc58c00edae4836890c3784c6783
 F test/vtab_err.test 0d4d8eb4def1d053ac7c5050df3024fd47a3fbd8
 F test/vtab_shared.test 5253bff2355a9a3f014c15337da7e177ab0ef8ad
-F test/wal.test 613efec03e517e1775d86b993a54877d2e29a477
-F test/wal2.test 155b9efa999bdb38ce1cd729b9a4fcdbffd6b88be27f039bad1d2929d287d918
-F test/wal3.test 2a93004bc0fb2b5c29888964024695bade278ab2
-F test/wal4.test 4744e155cd6299c6bd99d3eab1c82f77db9cdb3c
-F test/wal5.test 9c11da7aeccd83a46d79a556ad11a18d3cb15aa9
-F test/wal6.test b602704e4b066199bc89d91ca9000f335dcf4572
+F test/wal.test 83635d428b0a3fe883939cedbaedf29e13a5affd
+F test/wal2.test a8f30a878c6c44dbdd37c9e5bb001245e78b27a8e97f15baf9842bb76f4a155a
+F test/wal3.test 82f70ca79e5db6829f9246f4a30d4a4751921c3b
+F test/wal4.test 5755887f321baa4c55de0b91066fa7d0cafcac9d
+F test/wal5.test 9304fada875d7279deb2783385b0ae1c02d96b88
+F test/wal6.test 3d9b79194d15f5b4f6e4169f89f815c049edb2df
 F test/wal64k.test 163655ecd2cb8afef4737cac2a40fdd2eeaf20b8
-F test/wal7.test 2ae8f427d240099cc4b2dfef63cff44e2a68a1bd
-F test/wal8.test d9df3fba4caad5854ed69ed673c68482514203c8
+F test/wal7.test 18cf68ab8010ae0a2baaa48e5b59567a9503e63e
+F test/wal8.test 82bf6e493002b2d1580823b40e47bce3e15f468a
 F test/wal9.test 378e76a9ad09cd9bee06c172ad3547b0129a6750
-F test/wal_common.tcl a98f17fba96206122eff624db0ab13ec377be4fe
-F test/walbak.test 018d4e5a3d45c6298d11b99f09a8ef6876527946
-F test/walbig.test f437473a16cfb314867c6b5d1dbcd519e73e3434
+F test/wal_common.tcl 15f152fd55703975878741beca6cfa4209d5b3b3
+F test/walbak.test e322af729156c121183af4847c6e2b17bc629f47
+F test/walbig.test 3ca3d94751b80054eed5bda20a1339ae1f619483
 F test/walblock.test be48f3a75eff0b4456209f26b3ce186c2015497d
-F test/walcksum.test bb234a1bb42248b3515d992b719708015c384278
-F test/walcrash.test 21038858cc552077b0522f50b0fa87e38139306a
-F test/walcrash2.test a0edab4e5390f03b99a790de89aad15d6ec70b36
-F test/walcrash3.test e426aa58122d20f2b9fbe9a507f9eb8cab85b8af
+F test/walcksum.test add42a54d7c7d9bc72a913792022a195293bef2b
+F test/walcrash.test 065a041da88f980df3830f09b7fe308337bb594a
+F test/walcrash2.test 6eb6842d34cc5955726264c80566963c32a9cbea
+F test/walcrash3.test 279640ffafa23f7564529ccd69bfb97849ccae9d
 F test/walcrash4.test e7b6e7639a950a0cca8e210e248c8dad4d63bf20
-F test/walfault.test 09b8ad7e52d2f54bce50e31aa7ea51412bb9f70ac13c74e669ddcd8b48b0d98d
-F test/walhook.test ed00a40ba7255da22d6b66433ab61fab16a63483
-F test/walmode.test cd6e7cff618eaaa5910ce57c3657aa50110397f86213886a2400afb9bfec7b7b
-F test/walnoshm.test 84ca10c544632a756467336b7c3b864d493ee496
+F test/walfault.test 3771f7c8b159438cbf3c56fdaee07b317fa25857cd30dfd9e0d080993cfba952
+F test/walhook.test 5d2bdb04fd3e220e2f96e6b566d57e00020bdaec
+F test/walmode.test edef6af21a8ef04b2acc7c14c44609e53d2a3ac4674e233673de439f258dcba4
+F test/walnoshm.test 559b878f3aab838971d820329ca35f1caa7b038e
 F test/waloverwrite.test dad2f26567f1b45174e54fbf9a8dc1cb876a7f03
-F test/walpersist.test 8c6b7e3ec1ba91b5e4dc4e0921d6d3f87cd356a6
+F test/walpersist.test abd956d66e2f36d2d9d05d3a969f48be6d2ddbec
 F test/walprotocol.test a112aba0b79e3adeaa485fed09484b32c654e97df58e454aa8489ac2cd57bf84
-F test/walro.test cb438d05ba0d191f10b688e39c4f0cd5b71569a1d1f4440e5bdf3c6880e08c20
+F test/walro.test cac7fa52dffec99f15c6e266769628d711935e4064dbcd7466ce3479b5011eb5
 F test/walro2.test 0e79dd15cbdb4f482c01ea248373669c732414a726b357d04846a816afafb768
 F test/walrofault.test c70cb6e308c443867701856cce92ad8288cd99488fa52afab77cca6cfd51af68
-F test/walshared.test 0befc811dcf0b287efae21612304d15576e35417
-F test/walslow.test c05c68d4dc2700a982f89133ce103a1a84cc285f
-F test/walthread.test 14b20fcfa6ae152f5d8e12f5dc8a8a724b7ef189f5d8ef1e2ceab79f2af51747
+F test/walshared.test 04590b10c677f75318701818c50bc0dda5da64ab
+F test/walslow.test 07a51cbe9d4895d0a90c7af76d14a62d363ac162
+F test/walthread.test c2bc173d0ca244134ab6bcf8ccd108ee787fb2e7925dbbae973e60fcc6c74851
 F test/where.test f19ea3fa31c425b04af42c8b192a5b595ee84498df8d27dcd79ec043b25fbbfb
 F test/where2.test 478d2170637b9211f593120648858593bf2445a1
 F test/where3.test 2341a294e17193a6b1699ea7f192124a5286ca6acfcc3f4b06d16c931fbcda2c
@@ -1660,14 +1666,14 @@ F tool/mkctimec.tcl dd183b73ae1c28249669741c250525f0407e579a70482371668fd5f130d9
 F tool/mkkeywordhash.c 20f366ad3794e1db42e333a6f35fa41a024f2e3528579c9d58eb13eaa3ab4913
 F tool/mkmsvcmin.tcl cad0c7b54d7dd92bc87d59f36d4cc4f070eb2e625f14159dc2f5c4204e6a13ea
 F tool/mkopcodec.tcl d1b6362bd3aa80d5520d4d6f3765badf01f6c43c
-F tool/mkopcodeh.tcl 4ee2a30ccbd900dc4d5cdb61bdab87cd2166cd2affcc78c9cc0b8d22a65b2eee
+F tool/mkopcodeh.tcl 17d1ccc05a926e19e3a9679ea3e4d1aaa15ba753e2fa7363e6e81c80e0ef8b86
 F tool/mkopts.tcl 680f785fdb09729fd9ac50632413da4eadbdf9071535e3f26d03795828ab07fa
 F tool/mkpragmatab.tcl 2144bc8550a6471a029db262a132d2df4b9e0db61b90398bf64f5b7b3f8d92cd
 F tool/mkshellc.tcl 1f45770aea226ac093a9c72f718efbb88a2a2833409ec2e1c4cecae4202626f5
 F tool/mksourceid.c d458f9004c837bee87a6382228ac20d3eae3c49ea3b0a5aace936f8b60748d3b
 F tool/mkspeedsql.tcl a1a334d288f7adfe6e996f2e712becf076745c97
 F tool/mksqlite3c-noext.tcl fef88397668ae83166735c41af99d79f56afaabb
-F tool/mksqlite3c.tcl d532ccbe81234f766bab6e5c0451c99529debcea138caccc1862a9645b2d54f2
+F tool/mksqlite3c.tcl ebc17b2cbf760b351b38de6e1714cbb7f7192cb0ca58b00f7ea139d821ebf80f
 F tool/mksqlite3h.tcl 080873e3856eceb9d289a08a00c4b30f875ea3feadcbece796bd509b1532792c
 F tool/mksqlite3internalh.tcl eb994013e833359137eb53a55acdad0b5ae1049b
 F tool/mkvsix.tcl b9e0777a213c23156b6542842c238479e496ebf5
@@ -1729,7 +1735,11 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 3ba08e53d54165f5541756ad13a4c2f0b18516cb612a256e056ed1ff76c1fa83
-R 52623d992549c096857f92f7f6ff2464
+P 95fbac39baaab1c3a84fdfc82ccb7f42398b2e92f18a2a57bce1d4a713cb0839
+Q +a874c649960ba2e2b2fd380d08c02a45884a1060d3922be8847729008ca6766e
+R a6fae0d92c2131f849bdcaa6d55fc00a
+T *branch * expr-node-copy-patch
+T *sym-expr-node-copy-patch *
+T -sym-apple-osx *
 U drh
-Z 92fa856c89ee79b753ba76005690f976
+Z b6ed866304647254c009dac674727594
@@ -1 +1 @@
-b816023ce07d01024d5769e16db924374a49bf909edd12dc1344a0a1ef693db5
+ab2ba8e732d4a813a336e37e06bbc98842d22d4896120b1b97e8577684e9ea53
@@ -150,6 +150,7 @@ void sqlite3AuthRead(
  int iDb;              /* The index of the database the expression refers to */
  int iCol;             /* Index of column in table */

+  assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
  if( db->xAuth==0 ) return;
  iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
  if( iDb<0 ){
@@ -158,7 +159,6 @@ void sqlite3AuthRead(
    return;
  }

-  assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
  if( pExpr->op==TK_TRIGGER ){
    pTab = pParse->pTriggerTab;
  }else{
@@ -87,8 +87,14 @@ static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
 ** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
 */
 int sqlite3_enable_shared_cache(int enable){
+#if defined(__APPLE__) && !defined(SQLITE_TEST) && !defined(TH3_COMPATIBILITY)
+  /* Enable global shared cache function for debugging and unit tests, 
+  ** but not for release */
+  return SQLITE_MISUSE;
+#else
  sqlite3GlobalConfig.sharedCacheEnabled = enable;
  return SQLITE_OK;
+#endif
 }
 #endif

@@ -864,7 +870,11 @@ static int btreeRestoreCursorPosition(BtCursor *pCur){
 ** back to where it ought to be if this routine returns true.
 */
 int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
-  return pCur->eState!=CURSOR_VALID;
+  assert( EIGHT_BYTE_ALIGNMENT(pCur)
+       || pCur==sqlite3BtreeFakeValidCursor() );
+  assert( offsetof(BtCursor, eState)==0 );
+  assert( sizeof(pCur->eState)==1 );
+  return CURSOR_VALID != *(u8*)pCur;
 }

 /*
@@ -2843,6 +2843,7 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
  sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
  addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
  regRecord = sqlite3GetTempReg(pParse);
+  sqlite3MultiWrite(pParse);

  sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
  sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
@@ -2856,12 +2857,13 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){

  addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
  if( IsUniqueIndex(pIndex) ){
-    int j2 = sqlite3VdbeCurrentAddr(v) + 3;
-    sqlite3VdbeGoto(v, j2);
+    int j2 = sqlite3VdbeGoto(v, 1);
    addr2 = sqlite3VdbeCurrentAddr(v);
+    sqlite3VdbeVerifyAbortable(v, OE_Abort);
    sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
                         pIndex->nKeyCol); VdbeCoverage(v);
    sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
+    sqlite3VdbeJumpHere(v, j2);
  }else{
    addr2 = sqlite3VdbeCurrentAddr(v);
  }
@@ -406,10 +406,12 @@ FuncDef *sqlite3FindFunction(
  if( createFlag && bestScore<FUNC_PERFECT_MATCH && 
      (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
    FuncDef *pOther;
+    u8 *z;
    pBest->zName = (const char*)&pBest[1];
    pBest->nArg = (u16)nArg;
    pBest->funcFlags = enc;
    memcpy((char*)&pBest[1], zName, nName+1);
+    for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
    pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
    if( pOther==pBest ){
      sqlite3DbFree(db, pBest);
@@ -1084,6 +1084,16 @@ static int exprStructSize(Expr *p){
  return EXPR_FULLSIZE;
 }

+/*
+** Copy the complete content of an Expr node, taking care not to read
+** past the end of the structure for a reduced-size version of the source
+** Expr.
+*/
+static void exprNodeCopy(Expr *pDest, Expr *pSrc){
+  memset(pDest, 0, sizeof(Expr));
+  memcpy(pDest, pSrc, exprStructSize(pSrc));
+}
+
 /*
 ** The dupedExpr*Size() routines each return the number of bytes required
 ** to store a copy of an expression or expression tree.  They differ in
@@ -3993,7 +4003,7 @@ expr_code_doover:
    case TK_COLLATE: 
    case TK_UPLUS: {
      pExpr = pExpr->pLeft;
-      goto expr_code_doover;
+      goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */
    }

    case TK_TRIGGER: {
@@ -4107,7 +4117,7 @@ expr_code_doover:
      nExpr = pEList->nExpr;
      endLabel = sqlite3VdbeMakeLabel(v);
      if( (pX = pExpr->pLeft)!=0 ){
-        tempX = *pX;
+        exprNodeCopy(&tempX, pX);
        testcase( pX->op==TK_COLUMN );
        exprToRegister(&tempX, exprCodeVector(pParse, &tempX, &regFree1));
        testcase( regFree1==0 );
@@ -4432,13 +4442,12 @@ static void exprCodeBetween(
  Expr exprX;       /* The  x  subexpression */
  int regFree1 = 0; /* Temporary use register */

-
  memset(&compLeft, 0, sizeof(Expr));
  memset(&compRight, 0, sizeof(Expr));
  memset(&exprAnd, 0, sizeof(Expr));

  assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
-  exprX = *pExpr->pLeft;
+  exprNodeCopy(&exprX, pExpr->pLeft);
  exprAnd.op = TK_AND;
  exprAnd.pLeft = &compLeft;
  exprAnd.pRight = &compRight;
@@ -331,6 +331,12 @@ static void fkLookupParent(
  int iCur = pParse->nTab - 1;              /* Cursor number to use */
  int iOk = sqlite3VdbeMakeLabel(v);        /* jump here if parent key found */

+  sqlite3VdbeVerifyAbortable(v,
+    (!pFKey->isDeferred
+      && !(pParse->db->flags & SQLITE_DeferFKs)
+      && !pParse->pToplevel 
+      && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore);
+
  /* If nIncr is less than zero, then check at runtime if there are any
  ** outstanding constraints to resolve. If there are not, there is no need
  ** to check if deleting this row resolves any outstanding violations.
@@ -738,6 +744,7 @@ void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
    ** constraints are violated.
    */
    if( (db->flags & SQLITE_DeferFKs)==0 ){
+      sqlite3VdbeVerifyAbortable(v, OE_Abort);
      sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
      VdbeCoverage(v);
      sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
@@ -1420,6 +1420,7 @@ void sqlite3GenerateConstraintChecks(
      Expr *pExpr = pCheck->a[i].pExpr;
      if( aiChng && checkConstraintUnchanged(pExpr, aiChng, pkChng) ) continue;
      allOk = sqlite3VdbeMakeLabel(v);
+      sqlite3VdbeVerifyAbortable(v, onError);
      sqlite3ExprIfTrue(pParse, pExpr, allOk, SQLITE_JUMPIFNULL);
      if( onError==OE_Ignore ){
        sqlite3VdbeGoto(v, ignoreDest);
@@ -1529,6 +1530,7 @@ void sqlite3GenerateConstraintChecks(
    /* Check to see if the new rowid already exists in the table.  Skip
    ** the following conflict logic if it does not. */
    VdbeNoopComment((v, "uniqueness check for ROWID"));
+    sqlite3VdbeVerifyAbortable(v, onError);
    sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
    VdbeCoverage(v);

@@ -1741,6 +1743,7 @@ void sqlite3GenerateConstraintChecks(

    /* Check to see if the new index entry will be unique */
    sqlite3ExprCachePush(pParse);
+    sqlite3VdbeVerifyAbortable(v, onError);
    sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
                         regIdx, pIdx->nKeyCol); VdbeCoverage(v);

@@ -1827,10 +1830,12 @@ void sqlite3GenerateConstraintChecks(
      default: {
        Trigger *pTrigger = 0;
        assert( onError==OE_Replace );
-        sqlite3MultiWrite(pParse);
        if( db->flags&SQLITE_RecTriggers ){
          pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
        }
+        if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
+          sqlite3MultiWrite(pParse);
+        }
        sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
            regR, nPkField, 0, OE_Replace,
            (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
@@ -2350,6 +2355,7 @@ static int xferOptimization(
    emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
    if( pDest->iPKey>=0 ){
      addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
+      sqlite3VdbeVerifyAbortable(v, onError);
      addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
      VdbeCoverage(v);
      sqlite3RowidConstraint(pParse, onError, pDest);
@@ -16,6 +16,9 @@
 */

 #include "sqliteInt.h"
+#ifdef SQLITE_ENABLE_SQLRR
+# include "sqlrr.h"
+#endif

 /*
 ** Execute SQL code.  Return one of the SQLITE_ success/failure
@@ -42,7 +45,9 @@ int sqlite3_exec(

  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
  if( zSql==0 ) zSql = "";
-
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecExec(db, zSql);
+#endif  
  sqlite3_mutex_enter(db->mutex);
  sqlite3Error(db, SQLITE_OK);
  while( rc==SQLITE_OK && zSql[0] ){
@@ -124,6 +129,9 @@ int sqlite3_exec(
 exec_out:
  if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
  sqlite3DbFree(db, azCols);
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecExecEnd(db);
+#endif

  rc = sqlite3ApiExit(db, rc);
  if( rc!=SQLITE_OK && pzErrMsg ){
@@ -16,6 +16,9 @@
 */
 #include "sqliteInt.h"

+#ifdef SQLITE_ENABLE_SQLRR
+# include "sqlrr.h"
+#endif 
 #ifdef SQLITE_ENABLE_FTS3
 # include "fts3.h"
 #endif
@@ -1253,6 +1256,10 @@ void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
  if( db->lookaside.bMalloced ){
    sqlite3_free(db->lookaside.pStart);
  }
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecClose(db);
+#endif
+  
  sqlite3_free(db);
 }

@@ -1364,6 +1371,7 @@ const char *sqlite3ErrName(int rc){
      case SQLITE_IOERR_MMAP:         zName = "SQLITE_IOERR_MMAP";        break;
      case SQLITE_IOERR_GETTEMPPATH:  zName = "SQLITE_IOERR_GETTEMPPATH"; break;
      case SQLITE_IOERR_CONVPATH:     zName = "SQLITE_IOERR_CONVPATH";    break;
+      case SQLITE_IOERR_VNODE:        zName = "SQLITE_IOERR_VNODE";       break;
      case SQLITE_CORRUPT:            zName = "SQLITE_CORRUPT";           break;
      case SQLITE_CORRUPT_VTAB:       zName = "SQLITE_CORRUPT_VTAB";      break;
      case SQLITE_NOTFOUND:           zName = "SQLITE_NOTFOUND";          break;
@@ -1808,11 +1816,13 @@ int sqlite3_create_function_v2(
 #endif
  sqlite3_mutex_enter(db->mutex);
  if( xDestroy ){
-    pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
+    pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor));
    if( !pArg ){
+      sqlite3OomFault(db);
      xDestroy(p);
      goto out;
    }
+    pArg->nRef = 0;
    pArg->xDestroy = xDestroy;
    pArg->pUserData = p;
  }
@@ -1820,7 +1830,7 @@ int sqlite3_create_function_v2(
  if( pArg && pArg->nRef==0 ){
    assert( rc!=SQLITE_OK );
    xDestroy(p);
-    sqlite3DbFree(db, pArg);
+    sqlite3_free(pArg);
  }

 out:
@@ -1858,6 +1868,28 @@ int sqlite3_create_function16(
 #endif


+/*
+** The following is the implementation of an SQL function that always
+** fails with an error message stating that the function is used in the
+** wrong context.  The sqlite3_overload_function() API might construct
+** SQL function that use this routine so that the functions will exist
+** for name resolution but are actually overloaded by the xFindFunction
+** method of virtual tables.
+*/
+static void sqlite3InvalidFunction(
+  sqlite3_context *context,  /* The function calling context */
+  int NotUsed,               /* Number of arguments to the function */
+  sqlite3_value **NotUsed2   /* Value of each argument */
+){
+  const char *zName = (const char*)sqlite3_user_data(context);
+  char *zErr;
+  UNUSED_PARAMETER2(NotUsed, NotUsed2);
+  zErr = sqlite3_mprintf(
+      "unable to use function %s in the requested context", zName);
+  sqlite3_result_error(context, zErr, -1);
+  sqlite3_free(zErr);
+}
+
 /*
 ** Declare that a function has been overloaded by a virtual table.
 **
@@ -1875,7 +1907,8 @@ int sqlite3_overload_function(
  const char *zName,
  int nArg
 ){
-  int rc = SQLITE_OK;
+  int rc;
+  char *zCopy;

 #ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
@@ -1883,13 +1916,13 @@ int sqlite3_overload_function(
  }
 #endif
  sqlite3_mutex_enter(db->mutex);
-  if( sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)==0 ){
-    rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
-                           0, sqlite3InvalidFunction, 0, 0, 0);
-  }
-  rc = sqlite3ApiExit(db, rc);
+  rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
  sqlite3_mutex_leave(db->mutex);
-  return rc;
+  if( rc ) return SQLITE_OK;
+  zCopy = sqlite3_mprintf(zName);
+  if( zCopy==0 ) return SQLITE_NOMEM;
+  return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
+                           zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free);
 }

 #ifndef SQLITE_OMIT_TRACE
@@ -2596,6 +2629,44 @@ int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
  }
  return oldLimit;                     /* IMP: R-53341-35419 */
 }
+#if defined(SQLITE_ENABLE_AUTO_PROFILE)
+/* stderr logging */
+void _sqlite_auto_profile(void *aux, const char *sql, u64 ns);
+void _sqlite_auto_trace(void *aux, const char *sql);
+void _sqlite_auto_profile(void *aux, const char *sql, u64 ns) {
+#pragma unused(aux)
+	fprintf(stderr, "Query: %s\n Execution Time: %llu ms\n", sql, ns / 1000000);
+}
+void _sqlite_auto_trace(void *aux, const char *sql) {
+	fprintf(stderr, "TraceSQL(%p): %s\n", aux, sql);
+}
+
+/* syslog logging */
+#include <asl.h>
+static aslclient autolog_client = NULL;
+static void _close_asl_log() {
+  if( NULL!=autolog_client ){
+    asl_close(autolog_client);
+    autolog_client = NULL;
+  }
+}
+static void _open_asl_log() {
+  if( NULL==autolog_client ){
+    autolog_client = asl_open("SQLite", NULL, 0);
+    atexit(_close_asl_log);
+  }
+}
+
+void _sqlite_auto_profile_syslog(void *aux, const char *sql, u64 ns);
+void _sqlite_auto_trace_syslog(void *aux, const char *sql);
+void _sqlite_auto_profile_syslog(void *aux, const char *sql, u64 ns) {
+#pragma unused(aux)
+	asl_log(autolog_client, NULL, ASL_LEVEL_NOTICE, "Query: %s\n Execution Time: %llu ms\n", sql, ns / 1000000);
+}
+void _sqlite_auto_trace_syslog(void *aux, const char *sql) {
+	asl_log(autolog_client, NULL, ASL_LEVEL_NOTICE, "TraceSQL(%p): %s\n", aux, sql);
+}
+#endif

 /*
 ** This function is used to parse both URIs and non-URI filenames passed by the
@@ -2851,6 +2922,57 @@ int sqlite3ParseUri(
  return rc;
 }

+#if defined(SQLITE_ENABLE_AUTO_PROFILE)
+#define SQLITE_AUTOLOGGING_STDERR 1
+#define SQLITE_AUTOLOGGING_SYSLOG 2
+static void enableAutoLogging(
+  sqlite3 *db
+){
+  char *envprofile = getenv("SQLITE_AUTO_PROFILE");
+  
+  if( envprofile!=NULL ){
+    int where = 0;
+    if( !strncasecmp("1", envprofile, 1) ){
+      if( isatty(2) ){
+        where = SQLITE_AUTOLOGGING_STDERR;
+      }else{
+        where = SQLITE_AUTOLOGGING_SYSLOG;
+      }
+    } else if( !strncasecmp("stderr", envprofile, 6) ){
+      where = SQLITE_AUTOLOGGING_STDERR;
+    } else if( !strncasecmp("syslog", envprofile, 6) ){
+      where = SQLITE_AUTOLOGGING_SYSLOG;
+    }
+    if( where==SQLITE_AUTOLOGGING_STDERR ){
+      sqlite3_profile(db, _sqlite_auto_profile, db);
+    }else if( where==SQLITE_AUTOLOGGING_SYSLOG ){
+      _open_asl_log();
+      sqlite3_profile(db, _sqlite_auto_profile_syslog, db);
+    }
+  }
+  char *envtrace = getenv("SQLITE_AUTO_TRACE");
+  if( envtrace!=NULL ){
+    int where = 0;
+    if( !strncasecmp("1", envtrace, 1) ){
+      if( isatty(2) ){
+        where = SQLITE_AUTOLOGGING_STDERR;
+      }else{
+        where = SQLITE_AUTOLOGGING_SYSLOG;
+      }
+    } else if( !strncasecmp("stderr", envtrace, 6) ){
+      where = SQLITE_AUTOLOGGING_STDERR;
+    } else if( !strncasecmp("syslog", envtrace, 6) ){
+      where = SQLITE_AUTOLOGGING_SYSLOG;
+    }
+    if( where==SQLITE_AUTOLOGGING_STDERR ){
+      sqlite3_trace(db, _sqlite_auto_trace, db);
+    }else if( where==SQLITE_AUTOLOGGING_SYSLOG ){
+      _open_asl_log();
+      sqlite3_trace(db, _sqlite_auto_trace_syslog, db);
+    }
+  }
+}
+#endif

 /*
 ** This routine does the work of opening a database on behalf of
@@ -3183,7 +3305,30 @@ opendb_out:
  }else if( rc!=SQLITE_OK ){
    db->magic = SQLITE_MAGIC_SICK;
  }
+#if defined(__APPLE__) && ENABLE_FORCE_WAL
+  if( db && !rc ){
+    if ((0 == access("/var/db/enableForceWAL", R_OK))) {
+#ifdef SQLITE_DEBUG
+      fprintf(stderr, "SQLite WAL journal_mode ENABLED by default.\n");
+#endif
+      
+      sqlite3_exec(db, "pragma journal_mode=wal", NULL, NULL, NULL);
+#ifdef SQLITE_DEBUG
+//    } else {
+//      fprintf(stderr, "SQLite WAL journal_mode NOT ENABLED by default.\n");
+#endif
+    }
+  }
+#endif
+#if defined(SQLITE_ENABLE_AUTO_PROFILE)
+  if( db && !rc ){
+    enableAutoLogging(db);
+  }
+#endif
  *ppDb = db;
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecOpen(db, zFilename, flags);
+#endif
 #ifdef SQLITE_ENABLE_SQLLOG
  if( sqlite3GlobalConfig.xSqllog ){
    /* Opening a db handle. Fourth parameter is passed 0. */
@@ -3640,11 +3785,20 @@ int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
    }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
      *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
      rc = SQLITE_OK;
+#ifndef SQLITE_OMIT_WAL
+      if( (rc==SQLITE_OK)&&(op==SQLITE_FCNTL_LAST_ERRNO)&&(*(int *)pArg==0) ){
+        sqlite3_file *pWalFd = sqlite3PagerWalFile(pPager);
+        if( pWalFd&&(pWalFd->pMethods) ){
+          rc = sqlite3OsFileControl(pWalFd, op, pArg);
+        }
+      }
+#endif
    }else{
      rc = sqlite3OsFileControl(fd, op, pArg);
    }
    sqlite3BtreeLeave(pBtree);
  }
+  sqlite3Error(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
 }
@@ -4064,6 +4218,32 @@ int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
  pBt = sqlite3DbNameToBtree(db, zDbName);
  return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
 }
+#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__)
+
+#include "sqlite3_private.h"
+
+/* 
+** Testing a file path for sqlite locks held by a process ID. 
+** Returns SQLITE_LOCKSTATE_ON if locks are present on path
+** that would prevent writing to the database.
+*/
+int _sqlite3_lockstate(const char *path, pid_t pid){
+  sqlite3 *db = NULL;
+  
+  if( sqlite3_open_v2(path, &db, SQLITE_OPEN_READONLY, NULL) == SQLITE_OK ){
+    LockstatePID lockstate = {pid, -1};
+    sqlite3_file_control(db, NULL, SQLITE_FCNTL_LOCKSTATE_PID, &lockstate);
+    sqlite3_close(db);
+    int state = lockstate.state;
+    return state;
+  }
+  if( NULL!=db ){ 
+    sqlite3_close(db); /* need to close even if open returns an error */
+  }
+  return SQLITE_LOCKSTATE_ERROR;
+}
+
+#endif /* SQLITE_ENABLE_APPLE_SPI */

 #ifdef SQLITE_ENABLE_SNAPSHOT
 /*
@@ -210,12 +210,18 @@ int sqlite3OsOpen(
  int *pFlagsOut
 ){
  int rc;
+  int openFlags;
  DO_OS_MALLOC_TEST(0);
  /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
  ** down into the VFS layer.  Some SQLITE_OPEN_ flags (for example,
  ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
  ** reaching the VFS. */
-  rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
+#if SQLITE_ENABLE_DATA_PROTECTION
+  openFlags = flags & (0x87f7f | SQLITE_OPEN_FILEPROTECTION_MASK);
+#else
+  openFlags = flags & 0x87f7f;
+#endif
+  rc = pVfs->xOpen(pVfs, zPath, pFile, openFlags, pFlagsOut);
  assert( rc==SQLITE_OK || pFile->pMethods==0 );
  return rc;
 }
@@ -3513,6 +3513,15 @@ static int winFileControl(sqlite3_file *id, int op, void *pArg){
      OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
      return SQLITE_OK;
    }
+    case SQLITE_FCNTL_PERSIST_WAL: {
+      int bPersist = *(int*)pArg;
+      if( bPersist<0 ){
+        *(int*)pArg = pFile->bPersistWal;
+      }else{
+        pFile->bPersistWal = bPersist!=0;
+      }
+      return SQLITE_OK;
+    }
    case SQLITE_FCNTL_PERSIST_WAL: {
      winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
      OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h));
@@ -2565,7 +2565,11 @@ static int pager_delmaster(Pager *pPager, const char *zMaster){
  if( !pMaster ){
    rc = SQLITE_NOMEM_BKPT;
  }else{
-    const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
+    const int flags = 
+#if SQLITE_ENABLE_DATA_PROTECTION
+      (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
+#endif
+      (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
    rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
  }
  if( rc!=SQLITE_OK ) goto delmaster_out;
@@ -2601,7 +2605,11 @@ static int pager_delmaster(Pager *pPager, const char *zMaster){
      ** so, return without deleting the master journal file.
      */
      int c;
-      int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
+      int flags = 
+#if SQLITE_ENABLE_DATA_PROTECTION
+        (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
+#endif
+        (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
      rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
      if( rc!=SQLITE_OK ){
        goto delmaster_out;
@@ -3674,7 +3682,11 @@ static int pagerOpentemp(
  sqlite3_opentemp_count++;  /* Used for testing and analysis only */
 #endif

-  vfsFlags |=  SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
+  vfsFlags |=  
+#if SQLITE_ENABLE_DATA_PROTECTION
+            (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
+#endif
+            SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
            SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
  rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
  assert( rc!=SQLITE_OK || isOpen(pFile) );
@@ -5093,7 +5105,11 @@ static int hasHotJournal(Pager *pPager, int *pExists){
          ** it can be ignored.
          */
          if( !jrnlOpen ){
-            int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
+            int f = 
+#if SQLITE_ENABLE_DATA_PROTECTION
+              (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
+#endif
+              SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
            rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
          }
          if( rc==SQLITE_OK ){
@@ -5233,7 +5249,11 @@ int sqlite3PagerSharedLock(Pager *pPager){
            pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
        if( rc==SQLITE_OK && bExists ){
          int fout = 0;
-          int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
+          int f = 
+#if SQLITE_ENABLE_DATA_PROTECTION
+            (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK)|
+#endif
+            SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
          assert( !pPager->tempFile );
          rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
          assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
@@ -5743,6 +5763,9 @@ static int pager_open_journal(Pager *pPager){
        int flags = SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
        int nSpill;

+#if SQLITE_ENABLE_DATA_PROTECTION
+        flags |= (pPager->vfsFlags&SQLITE_OPEN_FILEPROTECTION_MASK);
+#endif
        if( pPager->tempFile ){
          flags |= (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL);
          nSpill = sqlite3Config.nStmtSpill;
@@ -6964,6 +6987,18 @@ sqlite3_file *sqlite3PagerFile(Pager *pPager){
  return pPager->fd;
 }

+#if !defined(SQLITE_OMIT_WAL)
+/*
+ ** Return the file handle for the WAL journal file associated
+ ** with the pager.  This might return NULL if the file has
+ ** not yet been opened.
+ */
+sqlite3_file *sqlite3PagerWalFile(Pager *pPager){
+  return ((pPager->pWal) ? sqlite3WalFile(pPager->pWal) : (NULL));
+}
+#endif
+
+
 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
 /*
 ** Reset the lock timeout for pager.
@@ -7496,10 +7531,14 @@ static int pagerOpenWal(Pager *pPager){
  ** (e.g. due to malloc() failure), return an error code.
  */
  if( rc==SQLITE_OK ){
-    rc = sqlite3WalOpen(pPager->pVfs,
-        pPager->fd, pPager->zWal, pPager->exclusiveMode,
-        pPager->journalSizeLimit, &pPager->pWal
-    );
+#if SQLITE_ENABLE_DATA_PROTECTION
+    rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, pPager->exclusiveMode,
+        pPager->journalSizeLimit, (pPager->vfsFlags & (SQLITE_OPEN_FILEPROTECTION_MASK | SQLITE_OPEN_READONLY)), 
+        &pPager->pWal);
+#else
+    rc = sqlite3WalOpen(pPager->pVfs, pPager->fd, pPager->zWal, pPager->exclusiveMode,
+        pPager->journalSizeLimit, (pPager->vfsFlags & SQLITE_OPEN_READONLY), &pPager->pWal);
+#endif
  }
  pagerFixMaplimit(pPager);

@@ -7593,6 +7632,13 @@ int sqlite3PagerCloseWal(Pager *pPager, sqlite3 *db){
                           pPager->pageSize, (u8*)pPager->pTmpSpace);
      pPager->pWal = 0;
      pagerFixMaplimit(pPager);
+
+      /* Ensure that the WAL file is deleted even if the PERSIST_WAL
+      ** hint is enabled. */
+      if( rc==SQLITE_OK ){
+        rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
+        if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
+      }
      if( rc && !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
    }
  }
@@ -205,6 +205,7 @@ int sqlite3PagerMemUsed(Pager*);
 const char *sqlite3PagerFilename(Pager*, int);
 sqlite3_vfs *sqlite3PagerVfs(Pager*);
 sqlite3_file *sqlite3PagerFile(Pager*);
+sqlite3_file *sqlite3PagerWalFile(Pager *pPager);
 sqlite3_file *sqlite3PagerJrnlFile(Pager*);
 const char *sqlite3PagerJournalname(Pager*);
 void *sqlite3PagerTempSpace(Pager*);
@@ -467,6 +467,7 @@ cmd ::= select(X).  {
  }
 }

+%ifndef SQLITE_OMIT_CTE
 select(A) ::= WITH wqlist(W) selectnowith(X). {
  Select *p = X;
  if( p ){
@@ -487,6 +488,7 @@ select(A) ::= WITH RECURSIVE wqlist(W) selectnowith(X). {
  }
  A = p;
 }
+%endif /* SQLITE_OMIT_CTE */
 select(A) ::= selectnowith(X). {
  Select *p = X;
  if( p ){
@@ -372,8 +372,7 @@ static void pcache1Free(void *p){
    sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
 #ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
    {
-      int nFreed = 0;
-      nFreed = sqlite3MallocSize(p);
+      int nFreed = sqlite3MallocSize(p);
      sqlite3_mutex_enter(pcache1.mutex);
      sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_OVERFLOW, nFreed);
      sqlite3_mutex_leave(pcache1.mutex);
@@ -217,11 +217,11 @@ static void setAllPagerFlags(sqlite3 *db){
    assert( SQLITE_CacheSpill==PAGER_CACHESPILL );
    assert( (PAGER_FULLFSYNC | PAGER_CKPT_FULLFSYNC | PAGER_CACHESPILL)
             ==  PAGER_FLAGS_MASK );
-    assert( (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)==pDb->safety_level );
    while( (n--) > 0 ){
      if( pDb->pBt ){
        sqlite3BtreeSetPagerFlags(pDb->pBt,
-                 pDb->safety_level | (db->flags & PAGER_FLAGS_MASK) );
+                 (pDb->safety_level & PAGER_SYNCHRONOUS_MASK)
+                   | (db->flags & PAGER_FLAGS_MASK) );
      }
      pDb++;
    }
@@ -14,6 +14,9 @@
 ** from disk.
 */
 #include "sqliteInt.h"
+#ifdef SQLITE_ENABLE_SQLRR
+# include "sqlrr.h"
+#endif

 /*
 ** Fill the InitData structure with an error message that indicates
@@ -756,6 +759,9 @@ int sqlite3_prepare(
 ){
  int rc;
  rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecPrepare(db, zSql, nBytes, 0, *ppStmt);
+#endif
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
  return rc;
 }
@@ -796,6 +802,9 @@ int sqlite3_prepare_v3(
  rc = sqlite3LockAndPrepare(db,zSql,nBytes,
                 SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
                 0,ppStmt,pzTail);
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecPrepare(db, zSql, nBytes, 1, *ppStmt);
+#endif
  assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
  return rc;
 }
@@ -839,7 +848,9 @@ static int sqlite3Prepare16(
  if( zSql8 ){
    rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8);
  }
-
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecPrepare(db, zSql8, -1, 1, *ppStmt);
+#endif
  if( zTail8 && pzTail ){
    /* If sqlite3_prepare returns a tail pointer, we calculate the
    ** equivalent pointer into the UTF-16 string by counting the unicode
@@ -974,7 +974,7 @@ char *sqlite3StrAccumFinish(StrAccum *p){
 ** an SQLITE_NOMEM error.
 */
 static sqlite3_str sqlite3OomStr = {
-   0, 0, 0, 0, 0, SQLITE_NOMEM
+   0, 0, 0, 0, 0, SQLITE_NOMEM, 0
 };

 /* Finalize a string created using sqlite3_str_new().
@@ -75,29 +75,31 @@ static void resolveAlias(
  assert( pOrig!=0 );
  db = pParse->db;
  pDup = sqlite3ExprDup(db, pOrig, 0);
-  if( pDup==0 ) return;
-  if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery);
-  if( pExpr->op==TK_COLLATE ){
-    pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
-  }
-  ExprSetProperty(pDup, EP_Alias);
+  if( pDup!=0 ){
+    if( zType[0]!='G' ) incrAggFunctionDepth(pDup, nSubquery);
+    if( pExpr->op==TK_COLLATE ){
+      pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
+    }
+    ExprSetProperty(pDup, EP_Alias);

-  /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This 
-  ** prevents ExprDelete() from deleting the Expr structure itself,
-  ** allowing it to be repopulated by the memcpy() on the following line.
-  ** The pExpr->u.zToken might point into memory that will be freed by the
-  ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
-  ** make a copy of the token before doing the sqlite3DbFree().
-  */
-  ExprSetProperty(pExpr, EP_Static);
-  sqlite3ExprDelete(db, pExpr);
-  memcpy(pExpr, pDup, sizeof(*pExpr));
-  if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
-    assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
-    pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
-    pExpr->flags |= EP_MemToken;
+    /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This 
+    ** prevents ExprDelete() from deleting the Expr structure itself,
+    ** allowing it to be repopulated by the memcpy() on the following line.
+    ** The pExpr->u.zToken might point into memory that will be freed by the
+    ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
+    ** make a copy of the token before doing the sqlite3DbFree().
+    */
+    ExprSetProperty(pExpr, EP_Static);
+    sqlite3ExprDelete(db, pExpr);
+    memcpy(pExpr, pDup, sizeof(*pExpr));
+    if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
+      assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
+      pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
+      pExpr->flags |= EP_MemToken;
+    }
+    sqlite3DbFree(db, pDup);
  }
-  sqlite3DbFree(db, pDup);
+  ExprSetProperty(pExpr, EP_Alias);
 }


@@ -349,6 +351,7 @@ static int lookupName(
            testcase( iCol==(-1) );
            pExpr->iTable = pNC->uNC.pUpsert->regData + iCol;
            eNewExprOp = TK_REGISTER;
+            ExprSetProperty(pExpr, EP_Alias);
          }else
 #endif /* SQLITE_OMIT_UPSERT */
          {
@@ -817,7 +817,7 @@ static void selectExprDefer(
    if( pItem->u.x.iOrderByCol==0 ){
      Expr *pExpr = pItem->pExpr;
      Table *pTab = pExpr->pTab;
-      if( pExpr->op==TK_COLUMN && pTab && !IsVirtual(pTab)
+      if( pExpr->op==TK_COLUMN && pExpr->iColumn>=0 && pTab && !IsVirtual(pTab)
       && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)
      ){
        int j;
@@ -8243,7 +8243,7 @@ static void usage(int showDetail){
 */
 static void verify_uninitialized(void){
  if( sqlite3_config(-1)==SQLITE_MISUSE ){
-    utf8_printf(stdout, "WARNING: attempt to configuration SQLite after"
+    utf8_printf(stdout, "WARNING: attempt to configure SQLite after"
                        " initialization.\n");
  }
 }
@@ -563,6 +563,7 @@ int sqlite3_exec(
 #define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
+#define SQLITE_OPEN_FILEPROTECTION_MASK                                 0x00700000

 /* Reserved:                         0x00F00000 */

@@ -6294,6 +6295,10 @@ struct sqlite3_index_info {

 /*
 ** CAPI3REF: Virtual Table Scan Flags
+**
+** Virtual table implementations are allowed to set the 
+** [sqlite3_index_info].idxFlags field to some combination of
+** these bits.
 */
 #define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */

@@ -9034,7 +9039,7 @@ SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);
 ** been a prior call to [sqlite3_deserialize(D,S,...)] with the same
 ** values of D and S.
 ** The size of the database is written into *P even if the 
-** SQLITE_SERIALIZE_NOCOPY bit is set but no contigious copy
+** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy
 ** of the database exists.
 **
 ** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the
@@ -0,0 +1,80 @@
+/*
+ *  sqlite3_private.h
+ */
+
+#ifndef _SQLITE3_PRIVATE_H
+#define _SQLITE3_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SQLITE_LOCKSTATE_OFF    0
+#define SQLITE_LOCKSTATE_ON     1
+#define SQLITE_LOCKSTATE_NOTADB 2
+#define SQLITE_LOCKSTATE_ERROR  -1
+
+#define SQLITE_LOCKSTATE_ANYPID -1
+
+/* 
+** Test a file path for sqlite locks held by a process ID (-1 = any PID). 
+** Returns one of the following integer codes:
+** 
+**   SQLITE_LOCKSTATE_OFF    no active sqlite file locks match the specified pid
+**   SQLITE_LOCKSTATE_ON     active sqlite file locks match the specified pid
+**   SQLITE_LOCKSTATE_NOTADB path points to a file that is not an sqlite db file
+**   SQLITE_LOCKSTATE_ERROR  path was not vaild or was unreadable
+**
+** There is no support for identifying db files encrypted via SEE encryption
+** currently.  Zero byte files are tested for sqlite locks, but if no sqlite 
+** locks are present then SQLITE_LOCKSTATE_NOTADB is returned.
+*/
+extern int _sqlite3_lockstate(const char *path, pid_t pid);
+
+/*
+** Test an open database connection for sqlite locks held by a process ID,
+** if a process has an open database connection this will avoid trashing file
+** locks by re-using open file descriptors for the database file and support
+** files (-shm)
+*/
+#define SQLITE_FCNTL_LOCKSTATE_PID          103
+
+/*
+** Pass the SQLITE_TRUNCATE_DATABASE operation code to sqlite3_file_control() 
+** to truncate a database and its associated journal file to zero length.  The 
+** SQLITE_TRUNCATE_* flags represent optional flags to safely initialize an
+** empty database in the place of the truncated database, the flags are passed 
+** into sqlite3_file_control via the fourth argument using a pointer to an integer
+** configured with the ORed flags.  If the fourth argument is NULL, the default 
+** behavior is applied and the database file is truncated to zero bytes, a rollback 
+** journal (if present) is unlinked, a WAL journal (if present) is truncated to zero 
+** bytes and the first few bytes of the -shm file is scrambled to trigger existing
+** connections to rebuild the index from the database file contents.
+*/
+#define SQLITE_FCNTL_TRUNCATE_DATABASE      101
+#define SQLITE_TRUNCATE_DATABASE            SQLITE_FCNTL_TRUNCATE_DATABASE
+#define SQLITE_TRUNCATE_INITIALIZE_HEADER_MASK    (0x7F<<0)
+#define SQLITE_TRUNCATE_JOURNALMODE_WAL           (0x1<<0)
+#define SQLITE_TRUNCATE_AUTOVACUUM_MASK           (0x3<<2)
+#define SQLITE_TRUNCATE_AUTOVACUUM_OFF            (0x1<<2)
+#define SQLITE_TRUNCATE_AUTOVACUUM_FULL           (0x2<<2)
+#define SQLITE_TRUNCATE_AUTOVACUUM_INCREMENTAL    (0x3<<2)
+#define SQLITE_TRUNCATE_PAGESIZE_MASK             (0x7<<4)
+#define SQLITE_TRUNCATE_PAGESIZE_1024             (0x1<<4)
+#define SQLITE_TRUNCATE_PAGESIZE_2048             (0x2<<4)
+#define SQLITE_TRUNCATE_PAGESIZE_4096             (0x3<<4)
+#define SQLITE_TRUNCATE_PAGESIZE_8192             (0x4<<4)
+#define SQLITE_TRUNCATE_FORCE                     (0x1<<7)
+
+/*
+** Pass the SQLITE_REPLACE_DATABASE operation code to sqlite3_file_control()
+** and a sqlite3 pointer to another open database file to safely copy the 
+** contents of that database file into the receiving database.
+*/
+#define SQLITE_FCNTL_REPLACE_DATABASE       102
+#define SQLITE_REPLACE_DATABASE             SQLITE_FCNTL_REPLACE_DATABASE
+
+#ifdef __cplusplus
+}  /* End of the 'extern "C"' block */
+#endif
+#endif
@@ -4166,6 +4166,7 @@ int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
  void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
  FuncDestructor *pDestructor
 );
+void sqlite3NoopDestructor(void*);
 void sqlite3OomFault(sqlite3*);
 void sqlite3OomClear(sqlite3*);
 int sqlite3ApiExit(sqlite3 *db, int);
@@ -4268,7 +4269,6 @@ int sqlite3VtabCallConnect(Parse*, Table*);
 int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
 int sqlite3VtabBegin(sqlite3 *, VTable *);
 FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
-void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
 sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
 int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
 int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
@@ -4463,6 +4463,30 @@ SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...);
 #define MEMTYPE_LOOKASIDE  0x02  /* Heap that might have been lookaside */
 #define MEMTYPE_PCACHE     0x04  /* Page cache allocations */

+#if (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__)
+
+/*
+** An instance of the following structure is used to hold the process ID
+** and return-by-reference lockstate value.  The SQLITE_FCNTL_LOCKSTATE_PID
+** requires the 4th argument to sqlite3_file_control to be a pointer to an
+** instance of LockstatePID initialized with a LockstatePID.pid value equal
+** to a process ID to be tested, or the special value SQLITE_LOCKSTATE_ANYPID
+** The Lockstate.state value is always set to one of the following values
+** when sqlite3_file_control returns:
+** 
+**   SQLITE_LOCKSTATE_OFF    no active sqlite file locks match the specified pid
+**   SQLITE_LOCKSTATE_ON     active sqlite file locks match the specified pid
+**   SQLITE_LOCKSTATE_NOTADB path points to a file that is not an sqlite db file
+**   SQLITE_LOCKSTATE_ERROR  path was not vaild or was unreadable
+*/
+typedef struct LockstatePID LockstatePID;
+struct LockstatePID {
+  pid_t pid;                 /* Process ID to test */
+  int state;                 /* The state of the lock (return value) */
+};
+
+#endif /* (SQLITE_ENABLE_APPLE_SPI>0) && defined(__APPLE__) */
+
 /*
 ** Threading interface
 */
@@ -4001,6 +4001,24 @@ static int SQLITE_TCLAPI test_clear_bindings(
  return TCL_OK;
 }

+/*
+ ** Usage:   sqlite3_clear_bindings STMT
+ **
+ */
+static int test_clear_bindings_null(
+  void * clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){  
+  if( objc!=1 ){
+    return TCL_ERROR;
+  }
+  /* test for handling NULL <rdar://problem/6646331> */
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_clear_bindings(0)));
+  return TCL_OK;
+}
+
 /*
 ** Usage:   sqlite3_sleep MILLISECONDS
 */
@@ -5684,6 +5702,96 @@ static int SQLITE_TCLAPI file_control_lasterrno_test(
  return TCL_OK;  
 }

+#ifdef __APPLE__
+/* From sqlite3_private.h */
+# ifndef SQLITE_TRUNCATE_DATABASE
+# define SQLITE_TRUNCATE_DATABASE      101
+# define SQLITE_TRUNCATE_JOURNALMODE_WAL           (0x1<<0)
+# define SQLITE_TRUNCATE_AUTOVACUUM_MASK           (0x3<<2)
+# define SQLITE_TRUNCATE_AUTOVACUUM_OFF            (0x1<<2)
+# define SQLITE_TRUNCATE_AUTOVACUUM_FULL           (0x2<<2)
+# define SQLITE_TRUNCATE_AUTOVACUUM_INCREMENTAL    (0x3<<2)
+# define SQLITE_TRUNCATE_PAGESIZE_MASK             (0x7<<4)
+# define SQLITE_TRUNCATE_PAGESIZE_1024             (0x1<<4)
+# define SQLITE_TRUNCATE_PAGESIZE_2048             (0x2<<4)
+# define SQLITE_TRUNCATE_PAGESIZE_4096             (0x3<<4)
+# define SQLITE_TRUNCATE_PAGESIZE_8192             (0x4<<4)
+# endif
+# ifndef SQLITE_REPLACE_DATABASE
+# define SQLITE_REPLACE_DATABASE       102
+# endif
+
+/*
+** tclcmd:   file_control_truncate_test DB
+**
+** This TCL command runs the sqlite3_file_control interface and
+** verifies correct operation of the SQLITE_TRUNCATE_DATABASE verb.
+*/
+static int file_control_truncate_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *db;
+  int flags;
+  int rc;
+  
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+                     Tcl_GetStringFromObj(objv[0], 0), " DB FLAGS", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
+    return TCL_ERROR;
+  }
+  if( Tcl_GetIntFromObj(interp, objv[2], &flags) ){
+    return TCL_ERROR;
+  }
+  rc = sqlite3_file_control(db, NULL, SQLITE_TRUNCATE_DATABASE, &flags);
+  if( rc ){ 
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 
+    return TCL_ERROR; 
+  }
+  return TCL_OK;  
+}
+
+/*
+** tclcmd:   file_control_replace_test DB
+**
+** This TCL command runs the sqlite3_file_control interface and
+** verifies correct operation of the SQLITE_REPLACE_DATABASE verb.
+*/
+static int file_control_replace_test(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  sqlite3 *src_db;
+  sqlite3 *dst_db;
+  int rc;
+  
+  if( objc!=3 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+                     Tcl_GetStringFromObj(objv[0], 0), " DST_DB SRC_DB", 0);
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &dst_db) ){
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[2]), &src_db) ){
+    return TCL_ERROR;
+  }
+  rc = sqlite3_file_control(dst_db, NULL, SQLITE_REPLACE_DATABASE, src_db);
+  if( rc ){ 
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 
+    return TCL_ERROR; 
+  }
+  return TCL_OK;  
+}
+#endif /* __APPLE__ */
+
 /*
 ** tclcmd:   file_control_chunksize_test DB DBNAME SIZE
 **
@@ -5829,6 +5937,90 @@ static int SQLITE_TCLAPI file_control_lockproxy_test(
  return TCL_OK;  
 }

+#ifdef __APPLE__
+#include <sys/param.h>
+#include <sys/mount.h>
+#include <sys/errno.h>
+#endif
+
+/*
+ ** tclcmd:   path_is_local PWD
+ */
+static int path_is_local(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+#ifdef __APPLE__
+  const char *zPath;
+  int nPath;
+  struct statfs fsInfo;
+  
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+                     Tcl_GetStringFromObj(objv[0], 0), " PATH", 0);
+    return TCL_ERROR;
+  }
+  zPath = Tcl_GetStringFromObj(objv[1], &nPath);
+  if( statfs(zPath, &fsInfo) == -1 ){
+    int err = errno;
+    Tcl_AppendResult(interp, "Error calling statfs on path",
+                     Tcl_NewIntObj(err), 0);
+    return TCL_ERROR;
+  }
+  if( fsInfo.f_flags&MNT_LOCAL ){
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); 
+  } else {
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(0)); 
+  }
+#else
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); 
+#endif
+  
+  return TCL_OK;  
+}
+
+/*
+ ** tclcmd:   path_is_dos PWD
+ */
+static int path_is_dos(
+  ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+#ifdef __APPLE__
+  const char *zPath;
+  int nPath;
+  struct statfs fsInfo;
+  
+  if( objc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"",
+                     Tcl_GetStringFromObj(objv[0], 0), " PATH", 0);
+    return TCL_ERROR;
+  }
+  zPath = Tcl_GetStringFromObj(objv[1], &nPath);
+  if( statfs(zPath, &fsInfo) == -1 ){
+    int err = errno;
+    Tcl_AppendResult(interp, "Error calling statfs on path",
+                     Tcl_NewIntObj(err), 0);
+    return TCL_ERROR;
+  }
+  if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); 
+  } else if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) {
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(1)); 
+  } else {
+    Tcl_SetObjResult(interp, Tcl_NewIntObj(0)); 
+  }
+#else
+  Tcl_SetObjResult(interp, Tcl_NewIntObj(0)); 
+#endif
+  
+  return TCL_OK;  
+}
+
 #if SQLITE_OS_WIN
 /*
 ** tclcmd:   file_control_win32_av_retry DB  NRETRY  DELAY
@@ -5962,7 +6154,6 @@ static int SQLITE_TCLAPI file_control_persist_wal(
  Tcl_AppendResult(interp, z, (char*)0);
  return TCL_OK;  
 }
-
 /*
 ** tclcmd:   file_control_powersafe_overwrite DB PSOW-FLAG
 **
@@ -7590,6 +7781,7 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
     { "sqlite3_bind_parameter_name",   test_bind_parameter_name,  0},
     { "sqlite3_bind_parameter_index",  test_bind_parameter_index, 0},
     { "sqlite3_clear_bindings",        test_clear_bindings, 0},
+     { "sqlite3_clear_bindings_null",   test_clear_bindings_null, 0},
     { "sqlite3_sleep",                 test_sleep,          0},
     { "sqlite3_errcode",               test_errcode       ,0 },
     { "sqlite3_extended_errcode",      test_ex_errcode    ,0 },
@@ -7697,6 +7889,10 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
     { "file_control_test",          file_control_test,   0   },
     { "file_control_lasterrno_test", file_control_lasterrno_test,  0   },
     { "file_control_lockproxy_test", file_control_lockproxy_test,  0   },
+#ifdef __APPLE__
+     { "file_control_truncate_test", file_control_truncate_test,  0   },
+     { "file_control_replace_test", file_control_replace_test,  0   },
+#endif 
     { "file_control_chunksize_test", file_control_chunksize_test,  0   },
     { "file_control_sizehint_test",  file_control_sizehint_test,   0   },
 #if SQLITE_OS_WIN
@@ -7710,6 +7906,8 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
     { "file_control_tempfilename",   file_control_tempfilename,    0   },
     { "sqlite3_vfs_list",           vfs_list,     0   },
     { "sqlite3_create_function_v2", test_create_function_v2, 0 },
+     { "path_is_local",              path_is_local,  0   },
+     { "path_is_dos",                path_is_dos,  0   },

     /* Functions from os.h */
 #ifndef SQLITE_OMIT_UTF16
@@ -620,7 +620,21 @@ Tcl_SetVar2(interp, "sqlite_options", "mergesort", "1", TCL_GLOBAL_ONLY);
 #else
  Tcl_SetVar2(interp,"sqlite_options","prefer_proxy_locking","0",TCL_GLOBAL_ONLY);
 #endif
-    
+#if defined(SQLITE_ENABLE_PURGEABLE_PCACHE) && defined(__APPLE__)
+  Tcl_SetVar2(interp,"sqlite_options","enable_purgeable_pcache","1",TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp,"sqlite_options","enable_purgeable_pcache","0",TCL_GLOBAL_ONLY);
+#endif
+#if SQLITE_DEFAULT_CKPTFULLFSYNC
+  Tcl_SetVar2(interp,"sqlite_options","default_ckptfullfsync","1",TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp,"sqlite_options","default_ckptfullfsync","0",TCL_GLOBAL_ONLY);
+#endif
+#if SQLITE_ENABLE_PERSIST_WAL
+  Tcl_SetVar2(interp,"sqlite_options","enable_persist_wal","1",TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp,"sqlite_options","enable_persist_wal","0",TCL_GLOBAL_ONLY);
+#endif
    
 #ifdef SQLITE_OMIT_SHARED_CACHE
  Tcl_SetVar2(interp, "sqlite_options", "shared_cache", "0", TCL_GLOBAL_ONLY);
@@ -756,6 +770,22 @@ Tcl_SetVar2(interp, "sqlite_options", "mergesort", "1", TCL_GLOBAL_ONLY);
  Tcl_SetVar2(interp, "sqlite_options", "sqllog", "0", TCL_GLOBAL_ONLY);
 #endif

+#ifdef __APPLE__
+# if  defined(__ppc__)
+  Tcl_SetVar2(interp, "os_options", "arch", "ppc", TCL_GLOBAL_ONLY);
+# elif defined(__i386__)
+  Tcl_SetVar2(interp, "os_options", "arch", "i386", TCL_GLOBAL_ONLY);
+# elif defined(__x86_64__)
+  Tcl_SetVar2(interp, "os_options", "arch", "x86_64", TCL_GLOBAL_ONLY);
+# elif defined(__arm__)
+  Tcl_SetVar2(interp, "os_options", "arch", "arm", TCL_GLOBAL_ONLY);
+# else
+#  error Unrecognized architecture for exec_options
+# endif
+#else
+  Tcl_SetVar2(interp, "os_options", "arch", "unknown", TCL_GLOBAL_ONLY);
+#endif
+
 #ifdef SQLITE_ENABLE_URI_00_ERROR
  Tcl_SetVar2(interp, "sqlite_options", "uri_00_error", "1", TCL_GLOBAL_ONLY);
 #else
@@ -148,7 +148,7 @@ static int superlockWalLock(
 ** this function must have been obtained from a successful call to
 ** sqlite3demo_superlock().
 */
-void sqlite3demo_superunlock(void *pLock){
+static void sqlite3demo_superunlock(void *pLock){
  Superlock *p = (Superlock *)pLock;
  if( p->bWal ){
    int rc;                         /* Return code */
@@ -179,9 +179,10 @@ void sqlite3demo_superunlock(void *pLock){
 ** until either the lock can be obtained or the busy-handler function returns
 ** 0 (indicating "give up").
 */
-int sqlite3demo_superlock(
+static int sqlite3demo_superlock(
  const char *zPath,              /* Path to database file to lock */
  const char *zVfs,               /* VFS to use to access database file */
+  int flags,                      /* Additional flags to pass to sqlite3_open_v2 */
  int (*xBusy)(void*,int),        /* Busy handler callback */
  void *pBusyArg,                 /* Context arg for busy handler */
  void **ppLock                   /* OUT: Context to pass to superunlock() */
@@ -196,7 +197,7 @@ int sqlite3demo_superlock(

  /* Open a database handle on the file to superlock. */
  rc = sqlite3_open_v2(
-      zPath, &pLock->db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, zVfs
+    zPath, &pLock->db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|flags, zVfs
  );

  /* Install a busy-handler and execute a BEGIN EXCLUSIVE. If this is not
@@ -338,7 +339,7 @@ static int SQLITE_TCLAPI superlock_cmd(
    xBusy = superlock_busy;
  }

-  rc = sqlite3demo_superlock(zPath, zVfs, xBusy, &busy, &pLock);
+  rc = sqlite3demo_superlock(zPath, zVfs, 0, xBusy, &busy, &pLock);
  assert( rc==SQLITE_OK || pLock==0 );
  assert( rc!=SQLITE_OK || pLock!=0 );

@@ -229,6 +229,7 @@ void sqlite3UpsertDoUpdate(
        VdbeComment((v, "%s.%s", pIdx->zName,
                    pTab->aCol[pPk->aiColumn[i]].zName));
      }
+      sqlite3VdbeVerifyAbortable(v, OE_Abort);
      i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk);
      VdbeCoverage(v);
      sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0, 
@@ -597,7 +597,8 @@ int sqlite3VdbeExec(
    ** sqlite3_column_text16() failed.  */
    goto no_mem;
  }
-  assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
+  assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY
+            || (p->rc&0xFF)==SQLITE_LOCKED );
  assert( p->bIsReader || p->readOnly!=0 );
  p->iCurrentTime = 0;
  assert( p->explain==0 );
@@ -915,6 +916,9 @@ case OP_Yield: {            /* in1, jump */
 */
 case OP_HaltIfNull: {      /* in3 */
  pIn3 = &aMem[pOp->p3];
+#ifdef SQLITE_DEBUG
+  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
+#endif
  if( (pIn3->flags & MEM_Null)==0 ) break;
  /* Fall through into OP_Halt */
 }
@@ -954,6 +958,9 @@ case OP_Halt: {
  int pcx;

  pcx = (int)(pOp - aOp);
+#ifdef SQLITE_DEBUG
+  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
+#endif
  if( pOp->p1==SQLITE_OK && p->pFrame ){
    /* Halt the sub-program. Return control to the parent frame. */
    pFrame = p->pFrame;
@@ -3324,6 +3331,8 @@ case OP_ReadCookie: {               /* out2 */
 */
 case OP_SetCookie: {
  Db *pDb;
+
+  sqlite3VdbeIncrWriteCounter(p, 0);
  assert( pOp->p2<SQLITE_N_BTREE_META );
  assert( pOp->p1>=0 && pOp->p1<db->nDb );
  assert( DbMaskTest(p->btreeMask, pOp->p1) );
@@ -4457,6 +4466,7 @@ case OP_InsertInt: {
  assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
  assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
  REGISTER_TRACE(pOp->p2, pData);
+  sqlite3VdbeIncrWriteCounter(p, pC);

  if( pOp->opcode==OP_Insert ){
    pKey = &aMem[pOp->p3];
@@ -4571,6 +4581,7 @@ case OP_Delete: {
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->uc.pCursor!=0 );
  assert( pC->deferredMoveto==0 );
+  sqlite3VdbeIncrWriteCounter(p, pC);

 #ifdef SQLITE_DEBUG
  if( pOp->p4type==P4_TABLE && HasRowid(pOp->p4.pTab) && pOp->p5==0 ){
@@ -4739,10 +4750,10 @@ case OP_SorterData: {
 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
 ** of a real table, not a pseudo-table.
 **
-** If P3!=0 then this opcode is allowed to make an ephermeral pointer
+** If P3!=0 then this opcode is allowed to make an ephemeral pointer
 ** into the database page.  That means that the content of the output
 ** register will be invalidated as soon as the cursor moves - including
-** moves caused by other cursors that "save" the the current cursors
+** moves caused by other cursors that "save" the current cursors
 ** position in order that they can write to the same table.  If P3==0
 ** then a copy of the data is made into memory.  P3!=0 is faster, but
 ** P3==0 is safer.
@@ -5189,6 +5200,7 @@ case OP_IdxInsert: {        /* in2 */

  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
+  sqlite3VdbeIncrWriteCounter(p, pC);
  assert( pC!=0 );
  assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
  pIn2 = &aMem[pOp->p2];
@@ -5235,6 +5247,7 @@ case OP_IdxDelete: {
  pC = p->apCsr[pOp->p1];
  assert( pC!=0 );
  assert( pC->eCurType==CURTYPE_BTREE );
+  sqlite3VdbeIncrWriteCounter(p, pC);
  pCrsr = pC->uc.pCursor;
  assert( pCrsr!=0 );
  assert( pOp->p5==0 );
@@ -5457,6 +5470,7 @@ case OP_Destroy: {     /* out2 */
  int iMoved;
  int iDb;

+  sqlite3VdbeIncrWriteCounter(p, 0);
  assert( p->readOnly==0 );
  assert( pOp->p1>1 );
  pOut = out2Prerelease(p, pOp);
@@ -5506,6 +5520,7 @@ case OP_Destroy: {     /* out2 */
 case OP_Clear: {
  int nChange;
 
+  sqlite3VdbeIncrWriteCounter(p, 0);
  nChange = 0;
  assert( p->readOnly==0 );
  assert( DbMaskTest(p->btreeMask, pOp->p2) );
@@ -5555,13 +5570,14 @@ case OP_ResetSorter: {
 ** Allocate a new b-tree in the main database file if P1==0 or in the
 ** TEMP database file if P1==1 or in an attached database if
 ** P1>1.  The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
-** it must be 2 (BTREE_BLOBKEY) for a index or WITHOUT ROWID table.
+** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table.
 ** The root page number of the new b-tree is stored in register P2.
 */
 case OP_CreateBtree: {          /* out2 */
  int pgno;
  Db *pDb;

+  sqlite3VdbeIncrWriteCounter(p, 0);
  pOut = out2Prerelease(p, pOp);
  pgno = 0;
  assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
@@ -5581,6 +5597,7 @@ case OP_CreateBtree: {          /* out2 */
 ** Run the SQL statement or statements specified in the P4 string.
 */
 case OP_SqlExec: {
+  sqlite3VdbeIncrWriteCounter(p, 0);
  db->nSqlExec++;
  rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
  db->nSqlExec--;
@@ -5670,6 +5687,7 @@ case OP_LoadAnalysis: {
 ** schema consistent with what is on disk.
 */
 case OP_DropTable: {
+  sqlite3VdbeIncrWriteCounter(p, 0);
  sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
  break;
 }
@@ -5683,6 +5701,7 @@ case OP_DropTable: {
 ** schema consistent with what is on disk.
 */
 case OP_DropIndex: {
+  sqlite3VdbeIncrWriteCounter(p, 0);
  sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
  break;
 }
@@ -5696,6 +5715,7 @@ case OP_DropIndex: {
 ** schema consistent with what is on disk.
 */
 case OP_DropTrigger: {
+  sqlite3VdbeIncrWriteCounter(p, 0);
  sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
  break;
 }
@@ -6905,6 +6925,7 @@ case OP_VUpdate: {
       || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
  );
  assert( p->readOnly==0 );
+  sqlite3VdbeIncrWriteCounter(p, 0);
  pVtab = pOp->p4.pVtab->pVtab;
  if( pVtab==0 || NEVER(pVtab->pModule==0) ){
    rc = SQLITE_LOCKED;
@@ -7222,6 +7243,22 @@ case OP_CursorHint: {
 }
 #endif /* SQLITE_ENABLE_CURSOR_HINTS */

+#ifdef SQLITE_DEBUG
+/* Opcode:  Abortable   * * * * *
+**
+** Verify that an Abort can happen.  Assert if an Abort at this point
+** might cause database corruption.  This opcode only appears in debugging
+** builds.
+**
+** An Abort is safe if either there have been no writes, or if there is
+** an active statement journal.
+*/
+case OP_Abortable: {
+  sqlite3VdbeAssertAbortable(p);
+  break;
+}
+#endif
+
 /* Opcode: Noop * * * * *
 **
 ** Do nothing.  This instruction is often useful as a jump
@@ -7233,8 +7270,9 @@ case OP_CursorHint: {
 ** This opcode records information from the optimizer.  It is the
 ** the same as a no-op.  This opcodesnever appears in a real VM program.
 */
-default: {          /* This is really OP_Noop and OP_Explain */
+default: {          /* This is really OP_Noop, OP_Explain */
  assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
+
  break;
 }

@@ -197,6 +197,11 @@ void sqlite3VdbeEndCoroutine(Vdbe*,int);
 # define sqlite3VdbeVerifyNoMallocRequired(A,B)
 # define sqlite3VdbeVerifyNoResultRow(A)
 #endif
+#if defined(SQLITE_DEBUG)
+  void sqlite3VdbeVerifyAbortable(Vdbe *p, int);
+#else
+# define sqlite3VdbeVerifyAbortable(A,B)
+#endif
 VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno);
 #ifndef SQLITE_OMIT_EXPLAIN
  void sqlite3VdbeExplain(Parse*,u8,const char*,...);
@@ -379,6 +379,7 @@ struct Vdbe {
  int nOp;                /* Number of instructions in the program */
 #ifdef SQLITE_DEBUG
  int rcApp;              /* errcode set by sqlite3_result_error_code() */
+  u32 nWrite;             /* Number of write operations that have occurred */
 #endif
  u16 nResColumn;         /* Number of columns in one row of the result set */
  u8 errorAction;         /* Recovery action to do in case of an error */
@@ -514,6 +515,14 @@ int sqlite3VdbeSorterRewind(const VdbeCursor *, int *);
 int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);
 int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);

+#ifdef SQLITE_DEBUG
+  void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*);
+  void sqlite3VdbeAssertAbortable(Vdbe*);
+#else
+# define sqlite3VdbeIncrWriteCounter(V,C)
+# define sqlite3VdbeAssertAbortable(V)
+#endif
+
 #if !defined(SQLITE_OMIT_SHARED_CACHE) 
  void sqlite3VdbeEnter(Vdbe*);
 #else
@@ -15,6 +15,9 @@
 */
 #include "sqliteInt.h"
 #include "vdbeInt.h"
+#ifdef SQLITE_ENABLE_SQLRR
+# include "sqlrr.h"
+#endif 

 #ifndef SQLITE_OMIT_DEPRECATED
 /*
@@ -102,6 +105,9 @@ int sqlite3_finalize(sqlite3_stmt *pStmt){
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
+#ifdef SQLITE_ENABLE_SQLRR
+    SRRecFinalize(pStmt);
+#endif
    sqlite3 *db = v->db;
    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
    sqlite3_mutex_enter(db->mutex);
@@ -128,6 +134,9 @@ int sqlite3_reset(sqlite3_stmt *pStmt){
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
+#ifdef SQLITE_ENABLE_SQLRR
+    SRRecReset(pStmt);
+#endif
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    rc = sqlite3VdbeReset(v);
@@ -147,7 +156,14 @@ int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
 #if SQLITE_THREADSAFE
-  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
+  sqlite3_mutex *mutex=NULL;
+#endif
+  if( NULL==pStmt ){ return SQLITE_OK; } /* <rdar://problem/6646331> */
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecClearBindings(pStmt);  
+#endif
+#if SQLITE_THREADSAFE
+  mutex = ((Vdbe*)pStmt)->db->mutex;
 #endif
  sqlite3_mutex_enter(mutex);
  for(i=0; i<p->nVar; i++){
@@ -787,28 +803,6 @@ sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){
  return *piTime;
 }

-/*
-** The following is the implementation of an SQL function that always
-** fails with an error message stating that the function is used in the
-** wrong context.  The sqlite3_overload_function() API might construct
-** SQL function that use this routine so that the functions will exist
-** for name resolution but are actually overloaded by the xFindFunction
-** method of virtual tables.
-*/
-void sqlite3InvalidFunction(
-  sqlite3_context *context,  /* The function calling context */
-  int NotUsed,               /* Number of arguments to the function */
-  sqlite3_value **NotUsed2   /* Value of each argument */
-){
-  const char *zName = context->pFunc->zName;
-  char *zErr;
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  zErr = sqlite3_mprintf(
-      "unable to use function %s in the requested context", zName);
-  sqlite3_result_error(context, zErr, -1);
-  sqlite3_free(zErr);
-}
-
 /*
 ** Create a new aggregate context for p and return a pointer to
 ** its pMem->z element.
@@ -1368,6 +1362,9 @@ int sqlite3_bind_blob(
  int nData, 
  void (*xDel)(void*)
 ){
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindBlob(pStmt, i, zData, nData);
+#endif
 #ifdef SQLITE_ENABLE_API_ARMOR
  if( nData<0 ) return SQLITE_MISUSE_BKPT;
 #endif
@@ -1390,6 +1387,9 @@ int sqlite3_bind_blob64(
 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindDouble(pStmt, i, rValue);
+#endif
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
@@ -1398,11 +1398,17 @@ int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
  return rc;
 }
 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindInt64(p, i, (i64)iValue);
+#endif
  return sqlite3_bind_int64(p, i, (i64)iValue);
 }
 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindInt64(pStmt, i, iValue);
+#endif
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
@@ -1413,6 +1419,9 @@ int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindNull(pStmt, i);
+#endif
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3_mutex_leave(p->db->mutex);
@@ -1444,6 +1453,9 @@ int sqlite3_bind_text(
  int nData, 
  void (*xDel)(void*)
 ){
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindText(pStmt, i, zData, nData);
+#endif
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
 }
 int sqlite3_bind_text64( 
@@ -1470,6 +1482,9 @@ int sqlite3_bind_text16(
  int nData, 
  void (*xDel)(void*)
 ){
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindText(pStmt, i, zData, nData);
+#endif
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
 }
 #endif /* SQLITE_OMIT_UTF16 */
@@ -1493,6 +1508,9 @@ int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
      break;
    }
    case SQLITE_TEXT: {
+#ifdef SQLITE_ENABLE_SQLRR
+      SRRecBindText(pStmt, i, pValue->z, pValue->n);
+#endif
      rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
                              pValue->enc);
      break;
@@ -1507,6 +1525,9 @@ int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
 int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
+#ifdef SQLITE_ENABLE_SQLRR
+  SRRecBindBlob(pStmt, i, NULL, n);
+#endif
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
@@ -603,6 +603,32 @@ int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
 }
 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */

+#ifdef SQLITE_DEBUG
+/*
+** Increment the nWrite counter in the VDBE if the cursor is not an
+** ephemeral cursor, or if the cursor argument is NULL.
+*/
+void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
+  if( pC==0
+   || (pC->eCurType!=CURTYPE_SORTER
+       && pC->eCurType!=CURTYPE_PSEUDO
+       && !pC->isEphemeral)
+  ){
+    p->nWrite++;
+  }
+}
+#endif
+
+#ifdef SQLITE_DEBUG
+/*
+** Assert if an Abort at this point in time might result in a corrupt
+** database.
+*/
+void sqlite3VdbeAssertAbortable(Vdbe *p){
+  assert( p->nWrite==0 || p->usesStmtJournal );
+}
+#endif
+
 /*
 ** This routine is called after all opcodes have been inserted.  It loops
 ** through all the opcodes and fixes up some details.
@@ -762,6 +788,17 @@ void sqlite3VdbeVerifyNoResultRow(Vdbe *p){
 }
 #endif

+/*
+** Generate code (a single OP_Abortable opcode) that will
+** verify that the VDBE program can safely call Abort in the current
+** context.
+*/
+#if defined(SQLITE_DEBUG)
+void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){
+  if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable);
+}
+#endif
+
 /*
 ** This function returns a pointer to the array of opcodes associated with
 ** the Vdbe passed as the first argument. It is the callers responsibility
@@ -2995,6 +3032,9 @@ int sqlite3VdbeReset(Vdbe *p){
  sqlite3DbFree(db, p->zErrMsg);
  p->zErrMsg = 0;
  p->pResultSet = 0;
+#ifdef SQLITE_DEBUG
+  p->nWrite = 0;
+#endif

  /* Save profiling information from this VDBE run.
  */
@@ -800,7 +800,7 @@ void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
 }

 /* A no-op destructor */
-static void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); }
+void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); }

 /*
 ** Set the value stored in *pMem should already be a NULL.
@@ -1049,9 +1049,6 @@ FuncDef *sqlite3VtabOverloadFunction(
  void *pArg = 0;
  FuncDef *pNew;
  int rc = 0;
-  char *zLowerName;
-  unsigned char *z;
-

  /* Check to see the left operand is a column in a virtual table */
  if( NEVER(pExpr==0) ) return pDef;
@@ -1066,16 +1063,22 @@ FuncDef *sqlite3VtabOverloadFunction(
  if( pMod->xFindFunction==0 ) return pDef;
 
  /* Call the xFindFunction method on the virtual table implementation
-  ** to see if the implementation wants to overload this function 
+  ** to see if the implementation wants to overload this function.
+  **
+  ** Though undocumented, we have historically always invoked xFindFunction
+  ** with an all lower-case function name.  Continue in this tradition to
+  ** avoid any chance of an incompatibility.
  */
-  zLowerName = sqlite3DbStrDup(db, pDef->zName);
-  if( zLowerName ){
-    for(z=(unsigned char*)zLowerName; *z; z++){
-      *z = sqlite3UpperToLower[*z];
+#ifdef SQLITE_DEBUG
+  {
+    int i;
+    for(i=0; pDef->zName[i]; i++){
+      unsigned char x = (unsigned char)pDef->zName[i];
+      assert( x==sqlite3UpperToLower[x] );
    }
-    rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xSFunc, &pArg);
-    sqlite3DbFree(db, zLowerName);
  }
+#endif
+  rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
  if( rc==0 ){
    return pDef;
  }
@@ -1324,11 +1324,12 @@ int sqlite3WalOpen(
  const char *zWalName,           /* Name of the WAL file */
  int bNoShm,                     /* True to run in heap-memory mode */
  i64 mxWalSize,                  /* Truncate WAL to this size on reset */
+  int flags,                      /* VFS file protection flags */
  Wal **ppWal                     /* OUT: Allocated Wal handle */
 ){
  int rc;                         /* Return Code */
  Wal *pRet;                      /* Object to allocate and return */
-  int flags;                      /* Flags passed to OsOpen() */
+  int vfsFlags;                   /* Flags passed to OsOpen() */

  assert( zWalName && zWalName[0] );
  assert( pDbFd );
@@ -1367,9 +1368,13 @@ int sqlite3WalOpen(
  pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);

  /* Open file handle on the write-ahead log file. */
-  flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
-  rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
-  if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
+  if( flags&SQLITE_OPEN_READONLY ){
+    vfsFlags = flags | SQLITE_OPEN_WAL;
+  } else {
+    vfsFlags = flags | (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
+  }
+  rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, vfsFlags, &vfsFlags);
+  if( rc==SQLITE_OK && vfsFlags&SQLITE_OPEN_READONLY ){
    pRet->readOnly = WAL_RDONLY;
  }

@@ -2065,6 +2070,9 @@ static int walIndexTryHdr(Wal *pWal, int *pChanged){
  ** reordering the reads and writes.
  */
  aHdr = walIndexHdr(pWal);
+  if( aHdr==NULL ){
+    return 1; /* Shouldn't be getting NULL from walIndexHdr, but we are */
+  }
  memcpy(&h1, (void *)&aHdr[0], sizeof(h1));
  walShmBarrier(pWal);
  memcpy(&h2, (void *)&aHdr[1], sizeof(h2));
@@ -2962,7 +2970,6 @@ Pgno sqlite3WalDbsize(Wal *pWal){
  return 0;
 }

-
 /* 
 ** This function starts a write transaction on the WAL.
 **
@@ -3180,6 +3187,10 @@ typedef struct WalWriter {
  sqlite3_int64 iSyncPoint;    /* Fsync at this offset */
  int syncFlags;               /* Flags for the fsync */
  int szPage;                  /* Size of one page */
+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+  void *aFrameBuf;             /* Frame buffer */
+  size_t szFrameBuf;           /* Size of frame buffer */
+#endif
 } WalWriter;

 /*
@@ -3223,17 +3234,29 @@ static int walWriteOneFrame(
 ){
  int rc;                         /* Result code from subfunctions */
  void *pData;                    /* Data actually written */
+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+  u8 *aFrame = p->aFrameBuf;
+#else
  u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-header in */
+#endif
+  
 #if defined(SQLITE_HAS_CODEC)
  if( (pData = sqlite3PagerCodec(pPage))==0 ) return SQLITE_NOMEM_BKPT;
 #else
  pData = pPage->pData;
 #endif
+
  walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
+  
+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+  memcpy(&aFrame[WAL_FRAME_HDRSIZE], pData, p->szPage);
+  rc = walWriteToLog(p, aFrame, (p->szPage + WAL_FRAME_HDRSIZE), iOffset);
+#else
  rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);
  if( rc ) return rc;
  /* Write the page data */
  rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
+#endif
  return rc;
 }

@@ -3392,6 +3415,13 @@ int sqlite3WalFrames(
  w.szPage = szPage;
  iOffset = walFrameOffset(iFrame+1, szPage);
  szFrame = szPage + WAL_FRAME_HDRSIZE;
+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+  w.aFrameBuf = (void *)malloc(szFrame);
+  if( NULL==w.aFrameBuf ){
+    return SQLITE_NOMEM;
+  }
+#endif
+

  /* Write all frames into the log file exactly once */
  for(p=pList; p; p=p->pDirty){
@@ -3427,7 +3457,12 @@ int sqlite3WalFrames(
    assert( iOffset==walFrameOffset(iFrame, szPage) );
    nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
    rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
-    if( rc ) return rc;
+    if( rc ) {
+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+      free(w.aFrameBuf);
+#endif
+      return rc;
+    }
    pLast = p;
    iOffset += szFrame;
    p->flags |= PGHDR_WAL_APPEND;
@@ -3462,7 +3497,12 @@ int sqlite3WalFrames(
      testcase( bSync );
      while( iOffset<w.iSyncPoint ){
        rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
-        if( rc ) return rc;
+        if( rc ) {
+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+          free(w.aFrameBuf);
+#endif
+          return rc;
+        }
        iOffset += szFrame;
        nExtra++;
      }
@@ -3473,6 +3513,9 @@ int sqlite3WalFrames(
    }
  }

+#if defined(SQLITE_WRITE_WALFRAME_PREBUFFERED)
+  free(w.aFrameBuf);
+#endif
  /* If this frame set completes the first transaction in the WAL and
  ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
  ** journal size limit, if possible.
@@ -55,7 +55,7 @@
 typedef struct Wal Wal;

 /* Open and close a connection to a write-ahead log. */
-int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**);
+int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, int, Wal**);
 int sqlite3WalClose(Wal *pWal, sqlite3*, int sync_flags, int, u8 *);

 /* Set the limiting size of a WAL file. */
@@ -78,6 +78,9 @@ int sqlite3WalReadFrame(Wal *, u32, int, u8 *);
 /* If the WAL is not empty, return the size of the database. */
 Pgno sqlite3WalDbsize(Wal *pWal);

+/* If a WAL journal file has been created, return it */
+sqlite3_file *sqlite3WalFile(Wal *pWal);
+  
 /* Obtain or release the WRITER lock. */
 int sqlite3WalBeginWriteTransaction(Wal *pWal);
 int sqlite3WalEndWriteTransaction(Wal *pWal);
@@ -146,6 +146,8 @@ ifcapable !wal {
  finish_test
  return
 }
+if ![wal_is_ok] { finish_test; return }
+
 db close
 forcedelete test.db
 do_test 8_3_names-5.0 {
@@ -737,23 +737,24 @@ do_test attach-6.1 {
  }
 } {0 {}}
 if {$tcl_platform(platform)=="unix"} {
-  do_test attach-6.2 {
-    sqlite3 dbx cannot-read
-    dbx eval {CREATE TABLE t1(a,b,c)}
-    dbx close
-    file attributes cannot-read -permission 0000
-    if {[file writable cannot-read]} {
-      puts "\n**** Tests do not work when run as root ****"
-      forcedelete cannot-read
-      exit 1
-    }
-    catchsql {
-      ATTACH DATABASE 'cannot-read' AS noread;
-    }
-  } {1 {unable to open database: cannot-read}}
-  do_test attach-6.2.2 {
-    db errorcode
-  } {14}
+  sqlite3 dbx cannot-read
+  dbx eval {CREATE TABLE t1(a,b,c)}
+  dbx close
+  file attributes cannot-read -permission 0000
+  if {[file writable cannot-read]} {
+    #puts "\n**** Tests do not work when run as root ****"
+    forcedelete cannot-read
+    #exit 1
+  } else {
+    do_test attach-6.2 {
+      catchsql {
+        ATTACH DATABASE 'cannot-read' AS noread;
+      }
+    } {1 {unable to open database: cannot-read}}
+    do_test attach-6.2.2 {
+      db errorcode
+    } {14}
+  }
  forcedelete cannot-read
 }

@@ -80,6 +80,7 @@ foreach {name f} $files {
    set mode wal
  }
  ifcapable !wal { set mode delete }
+  if ![wal_is_ok] { set mode delete }
  lappend L $mode
  append S "
    PRAGMA $name.journal_mode = WAL;
@@ -25,6 +25,11 @@ ifcapable {!autoinc} {
  return
 }

+if {[permutation]=="inmemory_journal"} {
+  finish_test
+  return
+}
+
 sqlite3_db_config_lookaside db 0 0 0

 # The database is initially empty.
@@ -730,6 +735,11 @@ do_test autoinc-12.2 {
  }} msg]
  lappend res $msg
 } {1 {database disk image is malformed}}
+ifcapable vtab {
+  set err "database disk image is malformed"
+} else {
+  set err {malformed database schema (sqlite_sequence) - near "VIRTUAL": syntax error}
+}
 do_test autoinc-12.3 {
  db close
  forcedelete test.db
@@ -748,7 +758,7 @@ do_test autoinc-12.3 {
    INSERT INTO t1(b) VALUES('two');
  }} msg]
  lappend res $msg
-} {1 {database disk image is malformed}}
+} [list 1 $err]
 do_test autoinc-12.4 {
  db close
  forcedelete test.db
@@ -656,6 +656,9 @@ do_test bind-13.4 {
               [sqlite3_column_type $VM 2]
 } {NULL NULL NULL}
 sqlite3_finalize $VM
+do_test bind-13.5 {
+  sqlite3_clear_bindings_null
+} {0}

 #--------------------------------------------------------------------
 # These tests attempt to reproduce bug #3463.
@@ -107,12 +107,17 @@ do_execsql_test cache-2.3.3 {
 } {main exclusive temp closed}
 do_test cache-2.3.4 { pager_cache_size db } 2
 do_execsql_test cache-2.3.5 COMMIT
-do_test cache-2.3.6 { pager_cache_size db } 1
-
+if !$::sqlite_options(enable_purgeable_pcache) {
+  # purgeable pcache doesn't share cache between connections
+  do_test cache-2.3.6 { pager_cache_size db } 1
+}
 do_execsql_test cache-2.3.7 {
  SELECT * FROM t1 UNION SELECT * FROM t2;
 } {1 2 i j x y}
-do_test cache-2.3.8 { pager_cache_size db } 1
+if !$::sqlite_options(enable_purgeable_pcache) {
+  # purgeable pcache doesn't share cache between connections
+  do_test cache-2.3.8 { pager_cache_size db } 1
+}

 # Tests for cache_size = 0.
 #
@@ -130,11 +135,17 @@ do_execsql_test cache-2.4.3 {
 do_test cache-2.4.4 { pager_cache_size db } 2
 do_execsql_test cache-2.4.5 COMMIT

-do_test cache-2.4.6 { pager_cache_size db } 0
+if !$::sqlite_options(enable_purgeable_pcache) {
+  # purgeable pcache doesn't share cache between connections
+  do_test cache-2.4.6 { pager_cache_size db } 0
+}
 do_execsql_test cache-2.4.7 {
  SELECT * FROM t1 UNION SELECT * FROM t2;
 } {1 2 i j x y}
-do_test cache-2.4.8 { pager_cache_size db } 0
+if !$::sqlite_options(enable_purgeable_pcache) {
+  # purgeable pcache doesn't share cache between connections
+  do_test cache-2.4.8 { pager_cache_size db } 0
+}

 sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit)
 finish_test
@@ -148,4 +148,13 @@ do_catchsql_test 4.3 {
  USING csv(filename='FileDoesNotExist.csv');
 } {1 {cannot open 'FileDoesNotExist.csv' for reading}}

+# 2018-06-02
+# Problem with single-column CSV support reported on the mailing list
+# by Trent W. Buck.
+#
+do_execsql_test 4.4 {
+  CREATE VIRTUAL TABLE temp.trent USING csv(data='1');
+  SELECT * FROM trent;
+} {1}
+
 finish_test
@@ -42,6 +42,9 @@ proc db_spill {db {reset 0}} {
 }

 do_test 1.1 {
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  db close
  sqlite3 db test.db
  execsql { PRAGMA mmap_size = 0 }
@@ -24,7 +24,24 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl

-proc eqp {sql {db db}} { uplevel execsql [list "EXPLAIN QUERY PLAN $sql"] $db }
+proc eqp {sql {db db}} { 
+  uplevel [subst -nocommands {
+    set eqpres [list]
+    $db eval "$sql" {
+      lappend eqpres [set detail]
+    }
+    set eqpres
+  }]
+}
+
+proc do_detail_test {tn sql res} {
+  set normalres [list {*}$res]
+  uplevel [subst -nocommands {
+    do_test $tn {
+      eqp { $sql }
+    } {$normalres}
+  }]
+}

 ###########################################################################
 ### SECTION 2: Enabling Foreign Key Support
@@ -970,20 +987,20 @@ do_test e_fkey-25.1 {
    );
  }
 } {}
-do_execsql_test e_fkey-25.2 {
+do_detail_test e_fkey-25.2 {
  PRAGMA foreign_keys = OFF;
  EXPLAIN QUERY PLAN DELETE FROM artist WHERE 1;
  EXPLAIN QUERY PLAN SELECT rowid FROM track WHERE trackartist = ?;
 } {
-  0 0 0 {SCAN TABLE artist} 
-  0 0 0 {SCAN TABLE track}
+  {SCAN TABLE artist} 
+  {SCAN TABLE track}
 }
-do_execsql_test e_fkey-25.3 {
+do_detail_test e_fkey-25.3 {
  PRAGMA foreign_keys = ON;
  EXPLAIN QUERY PLAN DELETE FROM artist WHERE 1;
 } {
-  0 0 0 {SCAN TABLE artist} 
-  0 0 0 {SCAN TABLE track}
+  {SCAN TABLE artist} 
+  {SCAN TABLE track}
 }
 do_test e_fkey-25.4 {
  execsql {
@@ -1097,21 +1114,20 @@ do_test e_fkey-27.1 {
 do_test e_fkey-27.2 {
  eqp { INSERT INTO artist VALUES(?, ?) }
 } {}
-do_execsql_test e_fkey-27.3 {
+do_detail_test e_fkey-27.3 {
  EXPLAIN QUERY PLAN UPDATE artist SET artistid = ?, artistname = ?
 } {
-  0 0 0 {SCAN TABLE artist} 
-  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)} 
-  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)}
+  {SCAN TABLE artist} 
+  {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)} 
+  {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)}
 }
-do_execsql_test e_fkey-27.4 {
+do_detail_test e_fkey-27.4 {
  EXPLAIN QUERY PLAN DELETE FROM artist
 } {
-  0 0 0 {SCAN TABLE artist} 
-  0 0 0 {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)}
+  {SCAN TABLE artist} 
+  {SEARCH TABLE track USING COVERING INDEX trackindex (trackartist=?)}
 }

-
 ###########################################################################
 ### SECTION 4.1: Composite Foreign Key Constraints
 ###########################################################################
@@ -33,7 +33,8 @@ testvfs oldvfs -iversion 1
 #
 # All three done with VFS "oldvfs", which has iVersion==1 and so does
 # not support shared memory.
-# 
+#
+forcedelete test.db-shm
 sqlite3 db test.db -vfs oldvfs
 do_execsql_test 1.1.1 {
  PRAGMA journal_mode = WAL;
@@ -440,6 +440,7 @@ foreach {tn script} {
      #   It's not. Test case "$tp.6".
      #
      do_test $tp.4 {
+        forcedelete abc.db-shm abc.db-wal       
        forcecopy test.db abc.db
        sqlite3 db4 abc.db
        db4 eval { SELECT * FROM t1 UNION ALL SELECT * FROM t2 }
@@ -404,12 +404,8 @@ sqlite3 db test.db
 # if we're using proxy locks, we use 3 filedescriptors for a db
 # that is open but NOT writing changes, normally
 # sqlite uses 1 (proxy locking adds the conch and the local lock)
-set using_proxy 0
-foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] {
-  set using_proxy $value
-}
 set extrafds 0
-if {$using_proxy!=0} {
+if {[forced_proxy_locking]} {
  set extrafds 2
 } 

@@ -79,13 +79,24 @@ set skipwaltests [expr {
  [permutation]=="journaltest" || [permutation]=="inmemory_journal"
 }]
 ifcapable !wal { set skipwaltests 1 }
+if {![wal_is_ok]} { set skipwaltests 1 }

 if {!$skipwaltests} {
  db close
  forcedelete test.db
+  ifcapable enable_persist_wal {
+    forcedelete test.db-journal
+    forcedelete test.db-wal
+    forcedelete test.db-shm
+  }
+  if {[forced_proxy_locking]} { 
+    forcedelete .test.db-conch
+  }
  sqlite3 db test.db
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  file_control_chunksize_test db main [expr 32*1024]
-  
  do_test fallocate-2.1 {
    execsql {
      PRAGMA page_size = 1024;
@@ -260,12 +260,17 @@ proc access_method {args} {
  return ""
 }

-do_test incrblob3-7.2 {
-  sqlite3 db test.db 
-  sqlite3_db_config_lookaside db 0 0 0
-  list [catch {db incrblob blobs v 1} msg] $msg
-} {1 {database schema has changed}}
-db close
+#set sqlite_os_trace 1
+# AFP asserts because the "db incrblob blobs v 1" clears the file locks and the unlock fails (HFS doesn't care about a failed unlock)
+if {[path_is_local "."]} {
+
+  do_test incrblob3-7.2 {
+    sqlite3 db test.db 
+    sqlite3_db_config_lookaside db 0 0 0
+    list [catch {db incrblob blobs v 1} msg] $msg
+  } {1 {database schema has changed}}
+  db close
+}
 tvfs delete

 finish_test
@@ -15,6 +15,7 @@

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

 # If this build of the library does not support auto-vacuum, omit this
 # whole file.
@@ -134,6 +135,8 @@ do_test incrvacuum2-3.2 {

 integrity_check incrvacuum2-3.3

+if ![wal_is_ok] { finish_test; return }
+
 if {[wal_is_capable]} {
  # At one point, when a specific page was being extracted from the b-tree
  # free-list (e.g. during an incremental-vacuum), all trunk pages that
@@ -20,7 +20,7 @@ source $testdir/malloc_common.tcl
 # If a connection is required to create a journal file, it creates it with 
 # the same file-system permissions as the database file itself. Test this.
 #
-if {$::tcl_platform(platform) == "unix"
+if {$::tcl_platform(platform) == "unix" && ![path_is_dos "."]
 && [atomic_batch_write test.db]==0
 } {

@@ -106,88 +106,94 @@ if {[catch {sqlite3 db test.db -vfs unix-flock} msg]} {
  return
 }

-do_test lock5-flock.1 {
-  sqlite3 db test.db -vfs unix-flock
-  execsql {
-    CREATE TABLE t1(a, b);
-    BEGIN;
-    INSERT INTO t1 VALUES(1, 2);
-  }
-} {}
+# Only run the flock tests on a local file system
+if { [path_is_local "."] } {

-# Make sure we are not accidentally using the dotfile locking scheme.
-do_test lock5-flock.2 {
-  file exists test.db.lock
-} {0}
+  do_test lock5-flock.1 {
+    sqlite3 db test.db -vfs unix-flock
+    execsql {
+      CREATE TABLE t1(a, b);
+      BEGIN;
+      INSERT INTO t1 VALUES(1, 2);
+    }
+  } {}

-do_test lock5-flock.3 {
-  catch { sqlite3 db2 test.db -vfs unix-flock }
-  catchsql { SELECT * FROM t1 } db2
-} {1 {database is locked}}
+  # Make sure we are not accidentally using the dotfile locking scheme.
+  do_test lock5-flock.2 {
+    file exists test.db.lock
+  } {0}

-do_test lock5-flock.4 {
-  execsql COMMIT
-  catchsql { SELECT * FROM t1 } db2
-} {0 {1 2}}
+  do_test lock5-flock.3 {
+    catch { sqlite3 db2 test.db -vfs unix-flock }
+    catchsql { SELECT * FROM t1 } db2
+  } {1 {database is locked}}

-do_test lock5-flock.5 {
-  execsql BEGIN
-  catchsql { SELECT * FROM t1 } db2
-} {0 {1 2}}
+  do_test lock5-flock.4 {
+    execsql COMMIT
+    catchsql { SELECT * FROM t1 } db2
+  } {0 {1 2}}

-do_test lock5-flock.6 {
-  execsql {SELECT * FROM t1}
-  catchsql { SELECT * FROM t1 } db2
-} {1 {database is locked}}
+  do_test lock5-flock.5 {
+    execsql BEGIN
+    catchsql { SELECT * FROM t1 } db2
+  } {0 {1 2}}

-do_test lock5-flock.7 {
-  db close
-  catchsql { SELECT * FROM t1 } db2
-} {0 {1 2}}
+  do_test lock5-flock.6 {
+    execsql {SELECT * FROM t1}
+    catchsql { SELECT * FROM t1 } db2
+  } {1 {database is locked}}

-do_test lock5-flock.8 {
-  db2 close
-} {}
+  do_test lock5-flock.7 {
+    db close
+    catchsql { SELECT * FROM t1 } db2
+  } {0 {1 2}}

-#####################################################################
+  do_test lock5-flock.8 {
+    db2 close
+  } {}

-do_test lock5-none.1 {
-  sqlite3 db test.db -vfs unix-none
-  sqlite3 db2 test.db -vfs unix-none
-  execsql { PRAGMA mmap_size = 0 } db2
-  execsql {
-    BEGIN;
-    INSERT INTO t1 VALUES(3, 4);
-  }
-} {}
-do_test lock5-none.2 {
-  execsql { SELECT * FROM t1 }
-} {1 2 3 4}
-do_test lock5-none.3 {
-  execsql { SELECT * FROM t1; } db2
-} {1 2}
-do_test lock5-none.4 {
-  execsql { 
-    BEGIN;
-    SELECT * FROM t1;
-  } db2
-} {1 2}
-do_test lock5-none.5 {
-  execsql COMMIT
-  execsql {SELECT * FROM t1} db2
-} {1 2}
+  #####################################################################

-ifcapable memorymanage {
+  do_test lock5-none.1 {
+    sqlite3 db test.db -vfs unix-none
+    sqlite3 db2 test.db -vfs unix-none
+    execsql {
+      BEGIN;
+      INSERT INTO t1 VALUES(3, 4);
+    }
+  } {}
+  do_test lock5-none.2 {
+    execsql { SELECT * FROM t1 }
+  } {1 2 3 4}
+  do_test lock5-flock.3 {
+    execsql { SELECT * FROM t1 } db2
+  } {1 2}
+  do_test lock5-none.4 {
+    execsql { 
+      BEGIN;
+      SELECT * FROM t1;
+    } db2
+  } {1 2}
+  do_test lock5-none.5 {
+    execsql COMMIT
+  } {}
  do_test lock5-none.6 {
    sqlite3_release_memory 1000000
    execsql {SELECT * FROM t1} db2
-  } {1 2 3 4}
-}
+  } {1 2}

-do_test lock5-none.X {
-  db close
-  db2 close
-} {}
+  ifcapable memorymanage {
+    do_test lock5-none.6 {
+      sqlite3_release_memory 1000000
+      execsql {SELECT * FROM t1} db2
+    } {1 2 3 4}
+  }
+
+  do_test lock5-flock.X {
+    db close
+    db2 close
+  } {}
+}

 ifcapable lock_proxy_pragmas {
  set env(SQLITE_FORCE_PROXY_LOCKING) $::using_proxy
@@ -126,9 +126,10 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
    set lockpath
  } {{:auto: (not held)}}

+  set lpp [exec mktemp -t fail]
  do_test lock6-1.4.1 {
+    execsql "PRAGMA lock_proxy_file='$lpp'"
    catchsql {
-      PRAGMA lock_proxy_file="notmine";
      select * from sqlite_master;
    } db
  } {1 {database is locked}}
@@ -137,7 +138,7 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
    execsql {
      PRAGMA lock_proxy_file;
    } db
-  } {notmine}
+  } $lpp
    
  do_test lock6-1.5 {
    testfixture $::tf1 {
@@ -150,9 +151,10 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {

  catch {testfixture $::tf1 {db close}}

+  set lpp [exec mktemp -t ok]
  do_test lock6-1.6 {
+    execsql "PRAGMA lock_proxy_file='$lpp'"
    execsql {
-      PRAGMA lock_proxy_file="mine";
      select * from sqlite_master;
    } db
  } {}
@@ -0,0 +1,142 @@
+# 2008 June 28
+#
+# The author disclaims copyright to this source code.  In place of
+# a legal notice, here is a blessing:
+#
+#    May you do good and not evil.
+#    May you find forgiveness for yourself and forgive others.
+#    May you share freely, never taking more than you give.
+#
+#***********************************************************************
+# This file implements regression tests for SQLite library.  The
+# focus of this script is database proxy locks.
+#
+# $Id$
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# This file is only run if using the unix backend compiled with the
+# SQLITE_ENABLE_LOCKING_STYLE macro.
+db close
+if {[catch {sqlite3 db test.db -vfs unix-none} msg]} {
+  finish_test
+  return
+}
+db close
+file delete -force test.db.lock
+
+#####################################################################
+ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
+  set ::using_proxy 0
+  foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] {
+    set ::using_proxy $value
+  }
+
+  # enable the proxy locking for these tests
+  set env(SQLITE_FORCE_PROXY_LOCKING) "1"
+
+  # test conch file creation
+  #
+
+  catch { file delete lock_proxy_test.db }
+  catch { file delete .lock_proxy_test.db-conch }
+  # test that proxy locking mode creates conch files
+  do_test lock_proxy1.0 {
+    sqlite3 db2 lock_proxy_test.db
+    catchsql {
+      create table x(y);
+    } db2
+    file exists .lock_proxy_test.db-conch
+  } {1}
+  catch { db2 close }
+
+
+  # test proxy locking readonly file system handling
+  #
+
+  if {[file exists /usr/bin/hdiutil]} {
+
+    puts "Creating readonly file system for proxy locking tests..."
+    if {[file exists /Volumes/readonly]} {
+      exec hdiutil detach /Volumes/readonly
+    }
+    if {[file exists readonly.dmg]} {
+      file delete readonly.dmg
+    }
+    exec hdiutil create -megabytes 1 -fs HFS+ readonly.dmg -volname readonly
+    exec hdiutil attach readonly.dmg
+
+    # create test1.db and a .test1.db-conch for host4
+    set sqlite_hostid_num 4
+    sqlite3 db2 /Volumes/readonly/test1.db 
+    execsql {
+      create table x(y);
+    } db2
+    db2 close
+
+    # create test2.db and a .test2.db-conch for host5
+    set sqlite_hostid_num 5
+    sqlite3 db2 /Volumes/readonly/test2.db 
+    execsql {
+      create table x(y);
+    } db2
+    db2 close
+
+    # create test3.db without a conch file
+    set env(SQLITE_FORCE_PROXY_LOCKING) "0"
+    sqlite3 db2 /Volumes/readonly/test3.db 
+    execsql {
+      create table x(y);
+    } db2
+    db2 close
+    exec hdiutil detach /Volumes/readonly
+    exec hdiutil attach -readonly readonly.dmg
+
+    # test that an unwritable, host-mismatched conch file prevents 
+    # read only proxy-locking mode database access
+    set env(SQLITE_FORCE_PROXY_LOCKING) "1"
+    do_test lock_proxy2.0 {
+      sqlite3 db2 /Volumes/readonly/test1.db
+      catchsql {
+        select * from sqlite_master;
+      } db2
+    } {1 {database is locked}}
+    catch { db2 close }
+    
+    # test that an unwritable, host-matching conch file allows
+    # read only proxy-locking mode database access
+    do_test lock_proxy2.1 {
+      sqlite3 db2 /Volumes/readonly/test2.db
+      catchsql {
+        select * from sqlite_master;
+      } db2
+    } {0 {table x x 2 {CREATE TABLE x(y)}}}
+    catch { db2 close }
+
+    # test that an unwritable, nonexistant conch file allows
+    # read only proxy-locking mode database access
+    do_test lock_proxy2.2 {
+      sqlite3 db2 /Volumes/readonly/test3.db
+      catchsql {
+        select * from sqlite_master;
+      } db2
+    } {0 {table x x 2 {CREATE TABLE x(y)}}}
+    catch { db2 close }
+
+    exec hdiutil detach /Volumes/readonly
+    file delete readonly.dmg
+  }
+  set env(SQLITE_FORCE_PROXY_LOCKING) "0"
+  set sqlite_hostid_num 0
+}
+
+#####################################################################
+
+file delete -force test.db
+
+ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
+  set env(SQLITE_FORCE_PROXY_LOCKING) $::using_proxy
+}
+
+finish_test
@@ -314,7 +314,7 @@ if {[permutation] == ""} {
 #
 do_test main-3.1 {
  catch {db close}
-  foreach f [glob -nocomplain testdb/*] {forcedelete $f}
+  catch {foreach f [glob -nocomplain testdb/*] {forcedelete $f}}
  forcedelete testdb
  sqlite3 db testdb
  set v [catch {execsql {SELECT * from T1 where x!!5}} msg]
@@ -322,7 +322,7 @@ do_test main-3.1 {
 } {1 {unrecognized token: "!"}}
 do_test main-3.2 {
  catch {db close}
-  foreach f [glob -nocomplain testdb/*] {forcedelete $f}
+  catch {foreach f [glob -nocomplain testdb/*] {forcedelete $f}}
  forcedelete testdb
  sqlite3 db testdb
  set v [catch {execsql {SELECT * from T1 where ^x}} msg]
@@ -442,7 +442,7 @@ do_test main-3.2.30 {

 do_test main-3.3 {
  catch {db close}
-  foreach f [glob -nocomplain testdb/*] {forcedelete $f}
+  catch {foreach f [glob -nocomplain testdb/*] {forcedelete $f}}
  forcedelete testdb
  sqlite3 db testdb
  execsql {
@@ -174,8 +174,11 @@ do_test malloc5-2.2 {
  execsql {
    COMMIT;
  }
-  list $nRelease $data
-} [list $pgalloc [list 1 2 3 4 5 6]]
+  value_in_range $::pgalloc $::mrange $nRelease
+} [value_in_range $::pgalloc $::mrange]
+do_test malloc5-2.2.1 {
+  set data
+} {1 2 3 4 5 6}

 do_test malloc5-3.1 {
  # Simple test to show that if two pagers are opened from within this
@@ -445,7 +445,7 @@ proc do_malloc_test {tn args} {
      set zRepeat "transient"
      if {$::iRepeat} {set zRepeat "persistent"}
      restore_prng_state
-      foreach file [glob -nocomplain test.db-mj*] {forcedelete $file}
+      catch {foreach file [glob -nocomplain test.db-mj*] {forcedelete $file}}

      do_test ${tn}.${zRepeat}.${::n} {
  
@@ -22,12 +22,8 @@ set N 300
 # if we're using proxy locks, we use 5 filedescriptors for a db
 # that is open and in the middle of writing changes, normally
 # sqlite uses 3 (proxy locking adds the conch and the local lock)
-set using_proxy 0
-foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] {
-  set using_proxy value
-}
 set num_fd_per_openwrite_db 3
-if {$using_proxy>0} {
+if {[forced_proxy_locking]} {
  set num_fd_per_openwrite_db 5
 } 

@@ -11,7 +11,6 @@
 # This file implements regression tests for SQLite library.  The
 # focus of this script is in-memory database backend.
 #
-# $Id: memdb.test,v 1.19 2009/05/18 16:04:38 danielk1977 Exp $


 set testdir [file dirname $argv0]
@@ -407,23 +406,26 @@ do_test memdb-8.2 {

 # Test that auto-vacuum works with in-memory databases.
 # 
-ifcapable autovacuum {
-  do_test memdb-9.1 {
-    db close
-    sqlite3 db test.db
-    db cache size 0
-    execsql {
-      PRAGMA auto_vacuum = full;
-      CREATE TABLE t1(a);
-      INSERT INTO t1 VALUES(randstr(1000,1000));
-      INSERT INTO t1 VALUES(randstr(1000,1000));
-      INSERT INTO t1 VALUES(randstr(1000,1000));
-    }
-    set before [db one {PRAGMA page_count}]
-    execsql { DELETE FROM t1 }
-    set after [db one {PRAGMA page_count}]
-    expr {$before>$after}
-  } {1}
+set msize [sqlite3_status SQLITE_STATUS_MALLOC_SIZE 0]
+if {[lindex $msize 2]!=0} {
+  ifcapable autovacuum {
+    do_test memdb-9.1 {
+      db close
+      sqlite3 db test.db
+      db cache size 0
+      execsql {
+        PRAGMA auto_vacuum = full;
+        CREATE TABLE t1(a);
+        INSERT INTO t1 VALUES(randstr(1000,1000));
+        INSERT INTO t1 VALUES(randstr(1000,1000));
+        INSERT INTO t1 VALUES(randstr(1000,1000));
+      }
+      set before [db one {PRAGMA page_count}]
+      execsql { DELETE FROM t1 }
+      set after [db one {PRAGMA page_count}]
+      expr {$before>$after}
+    } {1}
+  }
 }

 } ;# ifcapable memorydb
@@ -124,18 +124,20 @@ sqlite3_config singlethread
 sqlite3_initialize
 reset_highwater_marks
 build_test_db memsubsys1-3.1 {PRAGMA page_size=1024}
-do_test memsubsys1-3.1.3 {
-  set pg_used [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_USED 0] 2]
-} 0
-do_test memsubsys1-3.1.4 {
-  set overflow [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_OVERFLOW 0] 2]
-  # Note:  The measured PAGECACHE_OVERFLOW is amount malloc() returns, not what
-  # was requested.  System malloc() implementations might (arbitrarily) return
-  # slightly different oversize buffers, which can result in slightly different
-  # PAGECACHE_OVERFLOW sizes between consecutive runs.  So we cannot do an
-  # exact comparison.  Simply verify that the amount is within 5%.
-  expr {$overflow>=$max_pagecache*0.95 && $overflow<=$max_pagecache*1.05}
-} 1
+if !$::sqlite_options(enable_purgeable_pcache) {
+  do_test memsubsys1-3.1.3 {
+    set pg_used [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_USED 0] 2]
+  } 0
+  do_test memsubsys1-3.1.4 {
+    set overflow [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_OVERFLOW 0] 2]
+    # Note: The measured PAGECACHE_OVERFLOW is amount malloc() returns, not what
+    # was requested.  System malloc() implementations might (arbitrarily) return
+    # slightly different oversize buffers, which can result in different
+    # PAGECACHE_OVERFLOW sizes between consecutive runs.  So we cannot do an
+    # exact comparison.  Simply verify that the amount is within 5%.
+    expr {$overflow>=$max_pagecache*0.95 && $overflow<=$max_pagecache*1.05}
+  } 1
+}
 do_test memsubsys1-3.1.5 {
  set s_used [lindex [sqlite3_status SQLITE_STATUS_SCRATCH_USED 0] 2]
 } 0
@@ -169,9 +171,11 @@ do_test memsubsys1-4.3 {
  set pg_used [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_USED 0] 2]
  expr {$pg_used>=45 && $pg_used<=50}
 } 1
-do_test memsubsys1-4.4 {
-  set pg_ovfl [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_OVERFLOW 0] 2]
-} 0
+if !$::sqlite_options(enable_purgeable_pcache) {
+  do_test memsubsys1-4.4 {
+    set pg_ovfl [lindex [sqlite3_status SQLITE_STATUS_PAGECACHE_OVERFLOW 0] 2]
+  } 0
+}
 do_test memsubsys1-4.5 {
  set maxreq [lindex [sqlite3_status SQLITE_STATUS_MALLOC_SIZE 0] 2]
  expr {$maxreq<7000}
@@ -270,22 +270,27 @@ forcedelete test.db-journal
 sqlite3 db test.db

 ifcapable explain {
-  do_execsql_test misc7-14.1 {
+  do_execsql_test misc7-14.0 {
    CREATE TABLE abc(a PRIMARY KEY, b, c);
-    EXPLAIN QUERY PLAN SELECT * FROM abc AS t2 WHERE rowid = 1;
+  }
+  do_eqp_test misc7-14.1 {
+    SELECT * FROM abc AS t2 WHERE rowid = 1;
  } {
-    0 0 0 {SEARCH TABLE abc AS t2 USING INTEGER PRIMARY KEY (rowid=?)}
-  }
-  do_execsql_test misc7-14.2 {
-    EXPLAIN QUERY PLAN SELECT * FROM abc AS t2 WHERE a = 1;
-  } {0 0 0 
-     {SEARCH TABLE abc AS t2 USING INDEX sqlite_autoindex_abc_1 (a=?)}
-  }
-  do_execsql_test misc7-14.3 {
-    EXPLAIN QUERY PLAN SELECT * FROM abc AS t2 ORDER BY a;
-  } {0 0 0 
-     {SCAN TABLE abc AS t2 USING INDEX sqlite_autoindex_abc_1}
-  }
+  QUERY PLAN
+  `--SEARCH TABLE abc AS t2 USING INTEGER PRIMARY KEY (rowid=?)
+}
+  do_eqp_test misc7-14.2 {
+    SELECT * FROM abc AS t2 WHERE a = 1;
+} {
+  QUERY PLAN
+  `--SEARCH TABLE abc AS t2 USING INDEX sqlite_autoindex_abc_1 (a=?)
+}
+  do_eqp_test misc7-14.3 {
+    SELECT * FROM abc AS t2 ORDER BY a;
+  } {
+  QUERY PLAN
+  `--SCAN TABLE abc AS t2 USING INDEX sqlite_autoindex_abc_1
+}
 }

 db close
@@ -14,6 +14,12 @@ set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/malloc_common.tcl

+# AFP doesn't like multiplex db tests
+if { ![path_is_local "."] } {
+  finish_test 
+  return 
+}
+
 # The tests in this file assume that SQLite is compiled without
 # ENABLE_8_3_NAMES.
 #
@@ -55,11 +55,11 @@ if {![clang_sanitize_address]} {
  do_test 1.1.1 {
    set ::log [list]
    list [catch {
-      for {set i 0} {$i < 2000} {incr i} { sqlite3 dbh_$i test.db -readonly 1 }
+      for {set i 0} {$i < 20000} {incr i} { sqlite3 dbh_$i test.db -readonly 1 }
    } msg] $msg
  } {1 {unable to open database file}}
  do_test 1.1.2 {
-    catch { for {set i 0} {$i < 2000} {incr i} { dbh_$i close } }
+    catch { for {set i 0} {$i < 20000} {incr i} { dbh_$i close } }
  } {1}
  do_re_test 1.1.3 { 
    lindex $::log 0 
@@ -553,6 +553,8 @@ proc copy_on_mj_delete {method filename args} {
  return SQLITE_OK
 }

+if {![forced_proxy_locking]} {
+  # proxy locking uses can't deal with auto proxy file paths longer than MAXPATHLEN
 foreach {tn1 tcl} {
  1 { set prefix "test.db" }
  2 { 
@@ -739,6 +741,7 @@ foreach {tn1 tcl} {
 db close
 tv delete
 forcedelete $dirname
+}

 # Set up a VFS to make a copy of the file-system just before deleting a
 # journal file to commit a transaction. The transaction modifies exactly
@@ -1220,7 +1223,7 @@ do_execsql_test pager1-6.12 { PRAGMA max_page_count }      {11}
 #   $ws:  The expected size of the WAL file, in bytes, after executing
 #         the SQL script. Or -1 if the WAL is not expected to exist.
 #
-ifcapable wal {
+if {$::sqlite_options(wal) && [wal_is_ok]} {
  faultsim_delete_and_reopen
  foreach {tn sql res js ws} [subst {
  
@@ -1256,6 +1259,9 @@ ifcapable wal {
    10 { SELECT * FROM t1 }               {1 2 3 4 5 6 7 8} 0 -1
  
  }] {
+    ifcapable enable_persist_wal {
+      file_control_persist_wal db 0
+    }
    do_execsql_test pager1-7.1.$tn.1 $sql $res
    catch { set J -1 ; set J [file size test.db-journal] }
    catch { set W -1 ; set W [file size test.db-wal] }
@@ -2046,7 +2052,7 @@ do_test pager1-20.2.2 {
  }
 } {}

-ifcapable wal {
+if {$::sqlite_options(wal) && [wal_is_ok]} {
  do_test pager1-20.3.1 {
    faultsim_delete_and_reopen
    db func a_string a_string
@@ -2081,7 +2087,7 @@ ifcapable wal {
 #   pager1-21.1.*: The VFS has an iVersion less than 2, or
 #   pager1-21.2.*: The VFS does not provide xShmXXX() methods.
 #
-ifcapable wal {
+if {$::sqlite_options(wal) && [wal_is_ok]} {
  do_test pager1-21.0 {
    faultsim_delete_and_reopen
    execsql {
@@ -2112,33 +2118,36 @@ ifcapable wal {
 #   pager1-22.1.*: is a no-op on a non-WAL db, and
 #   pager1-22.2.*: does not cause xSync calls with a synchronous=off db.
 #
-ifcapable wal {
-  do_test pager1-22.1.1 {
-    faultsim_delete_and_reopen
-    execsql {
-      CREATE TABLE ko(c DEFAULT 'abc', b DEFAULT 'def');
-      INSERT INTO ko DEFAULT VALUES;
-    }
-    execsql { PRAGMA wal_checkpoint }
-  } {0 -1 -1}
-  do_test pager1-22.2.1 {
-    testvfs tv -default 1
-    tv filter xSync
-    tv script xSyncCb
-    proc xSyncCb {args} {incr ::synccount}
-    set ::synccount 0
-    sqlite3 db test.db
-    execsql {
-      PRAGMA synchronous = off;
-      PRAGMA journal_mode = WAL;
-      INSERT INTO ko DEFAULT VALUES;
-    }
-    execsql { PRAGMA wal_checkpoint }
-    set synccount
-  } {0}
-  db close
-  tv delete
-}
+do_test pager1-22.1.1 {
+  faultsim_delete_and_reopen
+  execsql {
+    CREATE TABLE ko(c DEFAULT 'abc', b DEFAULT 'def');
+    INSERT INTO ko DEFAULT VALUES;
+  }
+  execsql { PRAGMA wal_checkpoint }
+} {0 -1 -1}
+do_test pager1-22.2.1 {
+  testvfs tv -default 1
+  tv filter xSync
+  tv script xSyncCb
+  proc xSyncCb {args} {incr ::synccount}
+  sqlite3 db test.db
+
+  # Switch the db to WAL mode. And then execute a SELECT to make sure
+  # that the WAL file is open. Note that this may change the synchronous
+  # setting if DEFAULT_WAL_SAFETYLEVEL is defined.
+  execsql { PRAGMA journal_mode = WAL ; SELECT * FROM ko }
+
+  # Set synchronous=OFF. Insert some data and run a checkpoint. Since
+  # sync=off, this should not cause any calls to the xSync() method.
+  set ::synccount 0
+  execsql {
+    PRAGMA synchronous = off;
+    INSERT INTO ko DEFAULT VALUES;
+    PRAGMA wal_checkpoint;
+  }
+  set synccount
+} {0}

 #-------------------------------------------------------------------------
 # Tests for changing journal mode.
@@ -2386,7 +2395,7 @@ do_test pager1.27.1 {
 # the same database.
 #
 catch { db close }
-ifcapable wal {
+if {$::sqlite_options(wal) && [wal_is_ok]} {
  do_multiclient_test tn {
    do_test pager1-28.$tn.1 {
      sql1 { 
@@ -1062,6 +1062,39 @@ ifcapable crashtest {
 }


+#-------------------------------------------------------------------------
+# When a 3.7.0 client opens a write-transaction on a database file that
+# has been appended to or truncated by a pre-370 client, it updates
+# the db-size in the file header immediately. This test case provokes
+# errors during that operation.
+#
+do_test pagerfault-22-pre1 {
+  faultsim_delete_and_reopen
+  db func a_string a_string
+  execsql {
+    PRAGMA page_size = 1024;
+    PRAGMA auto_vacuum = 0;
+    CREATE TABLE t1(a);
+    CREATE INDEX i1 ON t1(a);
+    INSERT INTO t1 VALUES(a_string(3000));
+    CREATE TABLE t2(a);
+    INSERT INTO t2 VALUES(1);
+  }
+  db close
+  sql36231 { INSERT INTO t1 VALUES(a_string(3000)) }
+  faultsim_save_and_close
+} {}
+do_faultsim_test pagerfault-22 -prep {
+  faultsim_restore_and_reopen
+} -body {
+  execsql { INSERT INTO t2 VALUES(2) }
+  execsql { SELECT * FROM t2 }
+} -test {
+  faultsim_test_result {0 {1 2}}
+  faultsim_integrity_check
+}
+
+
 #-------------------------------------------------------------------------
 # When a 3.7.0 client opens a write-transaction on a database file that
 # has been appended to or truncated by a pre-370 client, it updates
@@ -117,7 +117,9 @@ do_test pcache-1.7 {
 # page. Because the number of allocated pages is greater than the 
 # configured maximum, this page should be freed immediately instead of
 # recycled.
-#
+# Note- purgable_pcache doesn't share caches between connections and these tests
+# are only useful for testing that feature.  
+if !$::sqlite_options(enable_purgeable_pcache) {
 do_test pcache-1.8 {
  execsql {ROLLBACK} db2
  pcache_stats
@@ -178,5 +180,8 @@ do_test pcache-1.15 {
  }
  pcache_stats
 } {current 14 max 15 min 10 recyclable 14}
+} else {
+  db2 close
+}

 finish_test
@@ -1504,7 +1504,12 @@ sqlite3 dbX :memory:
 dbX eval {PRAGMA temp_store_directory = ""}
 dbX close

-ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
+set skip_lock_proxy_tests [path_is_dos "."]
+ifcapable !(lock_proxy_pragmas&&prefer_proxy_locking) {
+  set skip_lock_proxy_tests 1
+}
+
+if !$skip_lock_proxy_tests {
  set sqlite_hostid_num 1

  set using_proxy 0
@@ -1518,67 +1523,67 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
  set env(SQLITE_FORCE_PROXY_LOCKING) "0"

  sqlite3 db test.db
+  # set lock proxy name and then query it via pragma interface
+  set lpp [exec mktemp -t "proxy1"]
  do_test pragma-16.1 {
-    execsql {
-      PRAGMA lock_proxy_file="mylittleproxy";
-      select * from sqlite_master;
-    }
-    execsql {
-      PRAGMA lock_proxy_file;
-    } 
-  } {mylittleproxy}
+    execsql "PRAGMA lock_proxy_file='$lpp'"
+    execsql "select * from sqlite_master"
+    execsql "PRAGMA lock_proxy_file"
+  } $lpp

+  # 2 database connections can share a lock proxy file
  do_test pragma-16.2 {
    sqlite3 db2 test.db
-    execsql {
-      PRAGMA lock_proxy_file="mylittleproxy";
-    } db2
+    execsql "PRAGMA lock_proxy_file='$lpp'" db2
  } {}

  db2 close
+  # 2nd database connection should auto-name an existing lock proxy file
  do_test pragma-16.2.1 {
    sqlite3 db2 test.db
    execsql {
      PRAGMA lock_proxy_file=":auto:";
      select * from sqlite_master;
    } db2
-    execsql {
-      PRAGMA lock_proxy_file;
-    } db2
-  } {mylittleproxy}
+    execsql "PRAGMA lock_proxy_file" db2
+  } $lpp

  db2 close
+  set lpp2 [exec mktemp -t "proxy2"]
+
+  # 2nd database connection cannot override the lock proxy file
  do_test pragma-16.3 {
    sqlite3 db2 test.db
-    execsql {
-      PRAGMA lock_proxy_file="myotherproxy";
-    } db2
+    execsql "PRAGMA lock_proxy_file='$lpp2'" db2
    catchsql {
      select * from sqlite_master;
    } db2
  } {1 {database is locked}}

+  set lpp3 [exec mktemp -t "proxy3"]
+
+  # lock proxy file can be renamed if no other connections are active
  do_test pragma-16.4 {
    db2 close
    db close
    sqlite3 db2 test.db
-    execsql {
-      PRAGMA lock_proxy_file="myoriginalproxy";
-      PRAGMA lock_proxy_file="myotherproxy";
-      PRAGMA lock_proxy_file;
-    } db2
-  } {myotherproxy}
+    execsql "PRAGMA lock_proxy_file='$lpp3'" db2
+    execsql "PRAGMA lock_proxy_file='$lpp2'" db2
+    execsql "PRAGMA lock_proxy_file" db2
+  } $lpp2

  db2 close
  set env(SQLITE_FORCE_PROXY_LOCKING) "1"
+  # auto-naming should reuse the last proxy name when available
  do_test pragma-16.5 {
    sqlite3 db2 test.db
    execsql {
      PRAGMA lock_proxy_file=":auto:";
      PRAGMA lock_proxy_file;
    } db2
-  } {myotherproxy}
+  } $lpp2
  
+  # auto-naming a new proxy should use a predictable & unique name
  do_test pragma-16.6 {
    db2 close
    sqlite3 db2 test2.db
@@ -1590,6 +1595,7 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
  } {1}
  
  set sqlite_hostid_num 2
+  # db access should be limited to one host at a time (simulate 2nd host id)
  do_test pragma-16.7 {
    list [catch {
      sqlite3 db test2.db
@@ -1601,6 +1607,7 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
  } {1 {database is locked}}
  db close
  
+  # default to using proxy locking (simulate network file system detection)
  do_test pragma-16.8 {
    list [catch {
      sqlite3 db test2.db
@@ -1609,19 +1616,25 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
  } {1 {database is locked}}

  db2 close
+  set lpp4 [exec mktemp -t "proxy4"]
+
+  # check that db is unlocked after first host connection closes 
  do_test pragma-16.8.1 {
-    execsql {
-      PRAGMA lock_proxy_file="yetanotherproxy";
-      PRAGMA lock_proxy_file;
-    } 
-  } {yetanotherproxy}
+    execsql "PRAGMA lock_proxy_file='$lpp4'" 
+    execsql "select * from sqlite_master"
+    execsql "PRAGMA lock_proxy_file"
+  } $lpp4
+  
  do_test pragma-16.8.2 {
    execsql {
-      create table mine(x);
+      create table if not exists mine(x);
+      insert into mine values (1);
    } 
  } {}

  db close
+  file delete -force proxytest.db
+  file delete -force .proxytest.db-conch
  do_test pragma-16.9 {
    sqlite3 db proxytest.db
    set lockpath2 [execsql {
@@ -1631,6 +1644,98 @@ ifcapable lock_proxy_pragmas&&prefer_proxy_locking {
    string match "*proxytest.db:auto:" $lockpath2
  } {1}

+  # ensure creating directories for a lock proxy file works
+  set lpp5d [exec mktemp -d -t "proxy5"]
+  set lpp5 $lpp5d/sub/dir/lock
+  db close
+  do_test pragma-16.10.1 {
+    sqlite3 db proxytest.db
+    execsql "PRAGMA lock_proxy_file='$lpp5'" 
+    set lockpath2 [execsql {
+      PRAGMA lock_proxy_file;
+    } db]
+    string match "*sub/dir/lock" $lockpath2
+  } {1}
+
+  # ensure that after deleting the path, setting ":auto:" works correctly
+  db close
+  file delete -force $lpp5d
+  do_test pragma-16.10.2 {
+    sqlite3 db proxytest.db
+    set lockpath3 [execsql {
+      PRAGMA lock_proxy_file=":auto:";
+      create table if not exists pt(y);
+      PRAGMA lock_proxy_file;
+    } db]
+    string match "*sub/dir/lock" $lockpath3
+  } {1}
+
+  # ensure that if the path can not be created (file instead of dir)
+  # setting :auto: deals with it by creating a new autonamed lock file
+  db close
+  file delete -force $lpp5d
+  close [open "$lpp5d" a]
+  do_test pragma-16.10.3 {
+    sqlite3 db proxytest.db
+    set lockpath2 [execsql {
+      PRAGMA lock_proxy_file=":auto:";
+      create table if not exists zz(y);
+      PRAGMA lock_proxy_file;
+    } db]
+    string match "*proxytest.db:auto:" $lockpath2
+  } {1}
+
+  # make sure we can deal with ugly file paths correctly
+  db close
+  file delete -force $lpp5d
+  set lpp6 [exec mktemp -d -t "proxy6"]/./././////./proxytest/../proxytest/sub/dir/lock
+  do_test pragma-16.10.4 {
+    sqlite3 db proxytest.db
+    execsql "PRAGMA lock_proxy_file='$lpp6'" 
+    set lockpath4 [execsql {
+      create table if not exists aa(bb);
+      PRAGMA lock_proxy_file;
+    } db]
+    string match "*proxytest/sub/dir/lock" $lockpath4
+  } {1}
+
+  # ensure that if the path can not be created (perm), setting :auto: deals
+  db close
+  file delete -force $lpp5d
+  do_test pragma-16.10.5 {
+    sqlite3 db proxytest.db
+    execsql "PRAGMA lock_proxy_file='$lpp5'" 
+    execsql {
+      create table if not exists bb(bb);
+    }
+    db close
+    file delete -force $lpp5d
+    file mkdir $lpp5d
+    file attributes $lpp5d -permission 0000
+    sqlite3 db proxytest.db
+    set lockpath5 [execsql {
+      PRAGMA lock_proxy_file=":auto:";
+      create table if not exists cc(bb);
+      PRAGMA lock_proxy_file;
+    } db]
+    string match "*proxytest.db:auto:" $lockpath5
+  } {1}
+
+  # ensure that if the path can not be created, locking fails
+  db close
+  do_test pragma-16.10.6 {
+    sqlite3 db proxytest.db
+    execsql "PRAGMA lock_proxy_file='$lpp5'" 
+    catchsql {
+      create table if not exists faily(y);
+      PRAGMA lock_proxy_file;
+    } db
+  } {1 {database is locked}}
+  db close
+
+  file attributes $lpp5d -permission 0777
+  file delete -force $lpp5d
+
  set env(SQLITE_FORCE_PROXY_LOCKING) $using_proxy
  set sqlite_hostid_num 0
 }
@@ -23,7 +23,7 @@ proc do_pragma_ncol_test {tn sql nCol} {
 }

 # If there is no RHS argument, the following PRAGMA statements operate as
-# queries, returning a single row containing a single column.
+# queries, returning a single row containing a single column. 
 #
 # Or, if there is RHS argument, they return zero rows of zero columns.
 #
@@ -54,6 +54,8 @@ foreach {tn sql} {
 24 "PRAGMA schema_version = 211"
 25 "PRAGMA short_column_names = 1"
 26 "PRAGMA synchronous = full"
+ 27 "PRAGMA temp_store_directory = '/tmp'"
+ 28 "PRAGMA temp_store_directory = ''"
 29 "PRAGMA temp_store = memory"
 30 "PRAGMA user_version = 405"
 31 "PRAGMA writable_schema = 1"
@@ -62,7 +64,7 @@ foreach {tn sql} {

  # Without RHS:
  do_pragma_ncol_test 1.$tn.1 [lindex [split $sql =] 0] 1
-
+   
  # With RHS:
  do_pragma_ncol_test 1.$tn.2 $sql  0
 }
@@ -77,7 +79,7 @@ foreach {tn sql} {
  5 "PRAGMA case_sensitive_like"
 } {

-  do_pragma_ncol_test 1.$tn.1 $sql 0
+  do_pragma_ncol_test 2.$tn.1 $sql 0
 }

 # EXPLAIN on a PRAGMA integrity_check.
@@ -15,13 +15,30 @@ set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 set testprefix resetdb

+do_not_use_codec
+
 ifcapable !vtab||!compound {
  finish_test
  return
 }

+# In the "inmemory_journal" permutation, each new connection executes 
+# "PRAGMA journal_mode = memory". This fails with SQLITE_BUSY if attempted
+# on a wal mode database with existing connections. For this and a few
+# other reasons, this test is not run as part of "inmemory_journal".
+#
+# Permutation "journaltest" does not support wal mode.
+#
+if {[permutation]=="inmemory_journal"
+ || [permutation]=="journaltest"
+} {
+  finish_test
+  return
+}
+
 # Create a sample database
 do_execsql_test 100 {
+  PRAGMA auto_vacuum = 0;
  PRAGMA page_size=4096;
  CREATE TABLE t1(a,b);
  WITH RECURSIVE c(x) AS (VALUES(1) UNION ALL SELECT x+1 FROM c WHERE x<20)
@@ -82,6 +99,7 @@ db2 close
 forcedelete test.db
 sqlite3 db test.db
 do_execsql_test 300 {
+  PRAGMA auto_vacuum = 0;
  PRAGMA page_size=8192;
  PRAGMA journal_mode=WAL;
  CREATE TABLE t1(a,b);
@@ -118,6 +136,8 @@ do_test 330 {
  } db2
 } {1 {file is not a database}}

+db2 cache flush         ;# Required by permutation "prepare".
+
 # Reset the database yet again.  Verify that the page size and
 # journal mode are preserved.
 #
@@ -11,12 +11,18 @@
 #***********************************************************************
 # This file implements regression tests for SQLite library.  The
 # focus of this file is testing locks on read-only WAL-mode databases.
+#
+# Note that the apple-osx branch does not allow read-only WAL-mode
+# databases (per check-in from Adam Swift on 2011-06-24 20:47:06) and
+# so this test module is disabled in the apple-osx branch.

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

+finish_test; return ;# This test module disabled in the apple-osx branch
+
 set mmap_res 1000000
 ifcapable !mmap {
  set mmap_res 0
@@ -45,13 +45,9 @@ ifcapable autovacuum {
 # if we're using proxy locks, we use 2 filedescriptors for a db
 # that is open but NOT yet locked, after a lock is taken we'll have 3, 
 # normally sqlite uses 1 (proxy locking adds the conch and the local lock)
-set using_proxy 0
-foreach {name value} [array get env SQLITE_FORCE_PROXY_LOCKING] {
-  set using_proxy $value
-}
 set extrafds_prelock 0
 set extrafds_postlock 0
-if {$using_proxy>0} {
+if {[forced_proxy_locking]} {
  set extrafds_prelock 1
  set extrafds_postlock 2
 } 
@@ -17,6 +17,11 @@ set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 test_set_config_pagecache 0 0

+# purgeable pcache tracks memory differently
+ifcapable {enable_purgeable_pcache} {
+  finish_test
+  return
+}
 unset -nocomplain baseline
 do_test shrink-1.1 {
  db eval {
@@ -35,8 +35,19 @@ if {$::TEMP_STORE==3} {
  finish_test
  return
 }
+
+# if we're using proxy locks, we use 3 filedescriptors for a db
+# that is open but NOT writing changes, normally
+# sqlite uses 1 (proxy locking adds the conch and the local lock)
+set extrafds 0
+if {[forced_proxy_locking]} {
+  set extrafds 2
+} 
+
+
 do_test stmt-1.2 {
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
 } {1}
 do_test stmt-1.3 {
  execsql {
@@ -45,17 +56,20 @@ do_test stmt-1.3 {
      INSERT INTO t1 VALUES(1, 1);
  }
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
 } {2}
 do_test stmt-1.4 {
  execsql {
    INSERT INTO t1 SELECT a+1, b+1 FROM t1;
  }
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
  # 2016-03-04: statement-journal open deferred
 } {2}
 do_test stmt-1.5 {
  execsql COMMIT
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
 } {1}
 do_test stmt-1.6.1 {
  execsql {
@@ -63,35 +77,38 @@ do_test stmt-1.6.1 {
      INSERT INTO t1 SELECT a+2, b+2 FROM t1;
  }
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
 } {2}
 do_test stmt-1.6.2 {
  execsql { INSERT INTO t1 SELECT a+4, b+4 FROM t1 }
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
  # 2016-03-04: statement-journal open deferred
 } {2}
 do_test stmt-1.7 {
  execsql COMMIT
  set sqlite_open_file_count
+  expr $sqlite_open_file_count-$extrafds
 } {1}


-proc filecount {testname sql expected} {
+proc filecount {testname sql expected extrafds} {
  uplevel [list do_test $testname [subst -nocommand {
    execsql BEGIN
    execsql { $sql }
    set ret [set sqlite_open_file_count]
    execsql ROLLBACK
    set ret
-  }] $expected]
+  }] [ expr $expected+$extrafds ] ]
 }

-filecount stmt-2.1 { INSERT INTO t1 VALUES(9, 9)  } 2
-filecount stmt-2.2 { REPLACE INTO t1 VALUES(9, 9) } 2
-filecount stmt-2.3 { INSERT INTO t1 SELECT 9, 9   } 2
+filecount stmt-2.1 { INSERT INTO t1 VALUES(9, 9)  } 2 $extrafds
+filecount stmt-2.2 { REPLACE INTO t1 VALUES(9, 9) } 2 $extrafds
+filecount stmt-2.3 { INSERT INTO t1 SELECT 9, 9   } 2 $extrafds
 filecount stmt-2.4 { 
    INSERT INTO t1 SELECT 9, 9;
    INSERT INTO t1 SELECT 10, 10;
-} 2
+} 2 $extrafds

 do_test stmt-2.5 {
  execsql { CREATE INDEX i1 ON t1(b) }
@@ -99,6 +116,6 @@ do_test stmt-2.5 {
 filecount stmt-2.6 { 
  REPLACE INTO t1 VALUES(5, 5);
  REPLACE INTO t1 VALUES(5, 5); 
-} 2
+} 2 $extrafds

 finish_test
@@ -13,6 +13,7 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/lock_common.tcl
+source $testdir/wal_common.tcl

 set testprefix superlock
 do_not_use_codec
@@ -43,6 +44,11 @@ do_not_use_codec
 #        
 #

+if {[forced_proxy_locking]} {
+  finish_test 
+  return 
+}
+
 do_execsql_test 1.1 {
  CREATE TABLE t1(a, b);
  INSERT INTO t1 VALUES(1, 2);
@@ -58,6 +64,12 @@ do_test 1.2 { sqlite3demo_superlock unlock test.db } {unlock}
 do_catchsql_test 1.3 { SELECT * FROM t1 } {1 {database is locked}}
 do_test 1.4 { unlock } {}

+ifcapable !wal {finish_test ; return }
+if { ![wal_is_ok] } {
+  finish_test 
+  return 
+}
+
 do_execsql_test 2.1 { 
  INSERT INTO t1 VALUES(3, 4);
  PRAGMA journal_mode = WAL;
@@ -57,6 +57,11 @@ do_test tempdb-1.2 {
  }
 } {}

+set extrafds 0
+if {[forced_proxy_locking]} {
+  set extrafds 2
+}
+
 do_test tempdb-2.1 {
  # Set $::jrnl_in_memory if the journal file is expected to be in-memory.
  # Similarly, set $::subj_in_memory if the sub-journal file is expected
@@ -81,7 +86,7 @@ do_test tempdb-2.2 {
  }
  catchsql { INSERT INTO t1 SELECT * FROM t2 }
  set sqlite_open_file_count
-} [expr 1 + (0==$jrnl_in_memory)]
+} [expr 1 + $extrafds + (0==$jrnl_in_memory)]
 do_test tempdb-2.3 {
  execsql {
    PRAGMA temp_store = 'memory';
@@ -93,6 +98,6 @@ do_test tempdb-2.3 {
  }
  catchsql { INSERT INTO t1 SELECT * FROM t2 }
  set sqlite_open_file_count
-} [expr 1 + (0==$jrnl_in_memory)]
+} [expr 1 + $extrafds + (0==$jrnl_in_memory)]

 finish_test
@@ -579,6 +579,23 @@ if {[info exists cmdlinearg]==0} {
 #
 sqlite3_soft_heap_limit $cmdlinearg(soft-heap-limit)

+proc forced_proxy_locking {} {
+  if $::sqlite_options(lock_proxy_pragmas)&&$::sqlite_options(prefer_proxy_locking) {
+    set force_proxy_value 0
+    set force_key "SQLITE_FORCE_PROXY_LOCKING="
+    foreach {env_pair} [exec env] { 
+      if { [string first $force_key $env_pair] == 0} {
+        set force_proxy_value [string range $env_pair [string length $force_key] end]
+      }
+    }
+    if { "$force_proxy_value " == "1 " } {
+      return 1
+    } 
+  }
+  return 0
+}
+
+
 # Create a test database
 #
 proc reset_db {} {
@@ -586,6 +603,14 @@ proc reset_db {} {
  forcedelete test.db
  forcedelete test.db-journal
  forcedelete test.db-wal
+  if {[forced_proxy_locking]} {
+    sqlite3 db ./test.db
+    set lock_proxy_path [db eval "PRAGMA lock_proxy_file;"] 
+    catch {db close}
+    # puts "deleting $lock_proxy_path"
+    file delete -force $lock_proxy_path    
+    file delete -force test.db
+  }
  sqlite3 db ./test.db
  set ::DB [sqlite3_connection_pointer db]
  if {[info exists ::SETUP_SQL]} {
@@ -1284,11 +1309,15 @@ proc finalize_testing {} {
      memdebug_log_sql leaks.sql
    }
  }
-  foreach f [glob -nocomplain test.db-*-journal] {
-    forcedelete $f
+  catch {
+    foreach f [glob -nocomplain test.db-*-journal] {
+      forcedelete $f
+    }
  }
-  foreach f [glob -nocomplain test.db-mj*] {
-    forcedelete $f
+  catch {
+    foreach f [glob -nocomplain test.db-mj*] {
+      forcedelete $f
+    }
  }
  exit [expr {$nErr>0}]
 }
@@ -2155,6 +2184,19 @@ proc presql {} {
  set presql
 }

+proc wal_is_ok {} {
+  if { [forced_proxy_locking] } {
+    return 1
+  }
+  if { ![path_is_local "."] } {
+    return 0
+  }
+  if { [path_is_dos "."] } {
+    return 0
+  }
+  return 1
+}
+
 proc isquick {} {
  set ret 0
  catch {set ret $::G(isquick)}
@@ -21,6 +21,7 @@ set testprefix tkt-2d1a5c67d

 ifcapable {!vtab} {finish_test; return}
 if {[wal_is_capable]==0} {finish_test; return}
+if {![wal_is_ok]} {finish_test; return}

 for {set ii 1} {$ii<=10} {incr ii} {
  do_test tkt-2d1a5c67d.1.$ii {
@@ -19,6 +19,7 @@ source $testdir/tester.tcl
 source $testdir/malloc_common.tcl

 if {![wal_is_capable]} { finish_test ; return }
+if ![wal_is_ok] { finish_test; return }

 do_execsql_test tkt-313723c356.1 {
  PRAGMA page_size = 1024;
@@ -74,27 +74,28 @@ catch {
  test_syscall fault 1 1
 }

-do_test tkt3457-1.2 {
-  forcecopy bak.db-journal test.db-journal
-  file attributes test.db-journal -permissions ---------
-  catchsql { SELECT * FROM t1 }
-} {1 {unable to open database file}}
-do_test tkt3457-1.3 {
-  forcecopy bak.db-journal test.db-journal
-  file attributes test.db-journal -permissions -w--w--w-
-  catchsql { SELECT * FROM t1 }
-} {1 {unable to open database file}}
-do_test tkt3457-1.4 {
-  forcecopy bak.db-journal test.db-journal
-  file attributes test.db-journal -permissions r--r--r--
-  catchsql { SELECT * FROM t1 }
-} {1 {unable to open database file}}
-
-do_test tkt3457-1.5 {
-  forcecopy bak.db-journal test.db-journal
-  file attributes test.db-journal -permissions rw-rw-rw-
-  catchsql { SELECT * FROM t1 }
-} {0 {1 2 3 4 5 6}}
+if { ![path_is_dos "."] } {
+  do_test tkt3457-1.2 {
+    forcecopy bak.db-journal test.db-journal
+    file attributes test.db-journal -permissions ---------
+    catchsql { SELECT * FROM t1 }
+  } {1 {unable to open database file}}
+  do_test tkt3457-1.3 {
+    forcecopy bak.db-journal test.db-journal
+    file attributes test.db-journal -permissions -w--w--w-
+    catchsql { SELECT * FROM t1 }
+  } {1 {unable to open database file}}
+  do_test tkt3457-1.4 {
+    forcecopy bak.db-journal test.db-journal
+    file attributes test.db-journal -permissions r--r--r--
+    catchsql { SELECT * FROM t1 }
+  } {1 {unable to open database file}}
+  do_test tkt3457-1.5 {
+    forcecopy bak.db-journal test.db-journal
+    file attributes test.db-journal -permissions rw-rw-rw-
+    catchsql { SELECT * FROM t1 }
+  } {0 {1 2 3 4 5 6}}
+}

 # Reenable fchmod
 catch {
@@ -22,6 +22,10 @@ source $testdir/wal_common.tcl
 set testprefix wal

 ifcapable !wal {finish_test ; return }
+if { ![wal_is_ok] } {
+  finish_test 
+  return 
+}
 test_set_config_pagecache 0 0

 proc reopen_db {} {
@@ -173,6 +177,9 @@ do_test wal-4.3 {
 } {a b}

 do_test wal-4.4.1 {
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  db close
  sqlite3 db test.db
  db func blob blob
@@ -224,6 +231,9 @@ db2 close

 do_test wal-4.5.1 {
  reopen_db
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  db func blob blob
  execsql {
    PRAGMA journal_mode = WAL;
@@ -338,6 +348,9 @@ foreach sector {512 4096} {
    forcedelete test.db test.db-wal
    do_test wal-6.$sector.$pgsz.1 {
      sqlite3 db test.db -vfs devsym
+      ifcapable enable_persist_wal {
+        file_control_persist_wal db 0
+      }
      execsql "
        PRAGMA page_size = $pgsz;
        PRAGMA auto_vacuum = 0;
@@ -724,6 +737,9 @@ do_test wal-11.8 {
  list [expr [file size test.db]/1024] [file size test.db-wal]
 } [list 37 [wal_file_size 40 1024]]
 do_test wal-11.9 {
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  db close
  list [expr [file size test.db]/1024] [log_deleted test.db-wal]
 } {37 1}
@@ -738,6 +754,9 @@ sqlite3_wal db test.db
 #ifcapable !mmap {set nWal 37}
 set nWal 34

+ifcapable enable_persist_wal {
+  file_control_persist_wal db 0
+}
 do_test wal-11.10 {
  execsql {
    PRAGMA cache_size = 10;
@@ -785,6 +804,9 @@ do_test wal-12.1 {
  list [expr [file size test.db]/1024] [file size test.db-wal]
 } [list 1 [wal_file_size 5 1024]]
 do_test wal-12.2 {
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  db close
  sqlite3 db test.db
  execsql {
@@ -822,6 +844,9 @@ do_test wal-12.6 {
  execsql { SELECT * FROM t2 } db2
 } {B 2}
 db2 close
+ifcapable enable_persist_wal {
+  file_control_persist_wal db 0
+}
 db close

 #-------------------------------------------------------------------------
@@ -979,10 +1004,12 @@ foreach {tn ckpt_cmd ckpt_res ckpt_main ckpt_aux} {
      PRAGMA aux.auto_vacuum = 0;
      PRAGMA main.journal_mode = WAL;
      PRAGMA aux.journal_mode = WAL;
+      SELECT count(*) FROM main.sqlite_master, aux.sqlite_master;
      PRAGMA main.synchronous = NORMAL;
      PRAGMA aux.synchronous = NORMAL;
+      PRAGMA aux.synchronous = FULL;
    }
-  } {wal wal}
+  } {wal wal 0}

  do_test wal-16.$tn.2 {
    execsql {
@@ -1053,6 +1080,7 @@ foreach {tn sectorsize logsize} "
      PRAGMA page_size = 512;
      PRAGMA cache_size = -2000;
      PRAGMA journal_mode = WAL;
+      SELECT * FROM sqlite_master;
      PRAGMA synchronous = FULL;
    }
    execsql {
@@ -1268,6 +1296,9 @@ do_test wal-19.2 {
  }
 } {1 2 3 4 5 6}
 do_test wal-19.3 {
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db2 0
+  }
  db close
  db2 close
  file exists test.db-wal
@@ -1420,6 +1451,9 @@ do_test wal-23.1 {
    INSERT INTO t1 VALUES(1, 2);
    INSERT INTO t1 VALUES(3, 4);
  }
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  faultsim_save_and_close

  sqlite3_shutdown
@@ -1466,6 +1500,9 @@ ifcapable autovacuum {
    INSERT INTO t1 SELECT * FROM t1;
  } {wal}
  do_test 24.2 { 
+    ifcapable enable_persist_wal {
+      file_control_persist_wal db 0
+    }
    execsql {
      DELETE FROM t1;
      PRAGMA wal_checkpoint;
@@ -1494,6 +1531,9 @@ ifcapable autovacuum {
  } [wal_file_size 1 1024]
 }

+ifcapable enable_persist_wal {
+  file_control_persist_wal db 0
+}
 db close
 sqlite3_shutdown
 test_sqlite3_log
@@ -22,6 +22,7 @@ source $testdir/wal_common.tcl
 set testprefix wal2

 ifcapable !wal {finish_test ; return }
+if ![wal_is_ok] {finish_test ; return }

 set sqlite_sync_count 0
 proc cond_incr_sync_count {adj} {
@@ -71,6 +72,13 @@ proc incr_tvfs_hdr {file idx incrval} {
  set_tvfs_hdr $file $ints
 }

+set shmpath test.db-shm
+if {[forced_proxy_locking]} {
+  sqlite3 db test.db
+  set shmpath [execsql { pragma lock_proxy_file }]-shm
+  db close
+}
+

 #-------------------------------------------------------------------------
 # Test case wal2-1.*:
@@ -573,9 +581,15 @@ do_test wal2-6.3.1 {
  list [file exists test.db-wal] [file exists test.db-journal]
 } {1 0}
 do_test wal2-6.3.2 {
+  ifcapable enable_persist_wal {
+    file_control_persist_wal db 0
+  }
  execsql { PRAGMA journal_mode = DELETE }
  file exists test.db-wal
 } {0}
+do_test wal2-6.3.2.1 {
+  execsql { PRAGMA journal_mode; }
+} {delete}
 do_test wal2-6.3.3 {
  execsql { PRAGMA lock_status }
 } {main exclusive temp closed}
@@ -730,7 +744,9 @@ foreach {tn sql res expected_locks} {
  do_test wal2-6.4.$tn.1 { execsql $S } $res
  do_test wal2-6.4.$tn.2 { set ::locks  } $L
 }
-
+ifcapable enable_persist_wal {
+  file_control_persist_wal db 0
+}
 db close
 tvfs delete

@@ -961,6 +977,9 @@ do_test wal2-10.1.1 {
    INSERT INTO t1 VALUES(1, 2);
    INSERT INTO t1 VALUES(3, 4);
  }
+  if {[forced_proxy_locking]} {
+    forcecopy $shmpath sv_test.db-shm
+  }
  faultsim_save_and_close
 } {}
 do_test wal2-10.1.2 {
@@ -1060,6 +1079,11 @@ tvfs delete
 # file itself. Test this.
 #
 if {$::tcl_platform(platform) == "unix"} {
+  if {[forced_proxy_locking]} {
+    # faultsim_delete_and_reopen doesn't know about the shm file redirect...
+    forcedelete $shmpath
+  }
+  
  faultsim_delete_and_reopen
  # Changed on 2012-02-13: umask is deliberately ignored for -wal files.
  #set umask [exec /bin/sh -c umask]
@@ -1073,7 +1097,7 @@ if {$::tcl_platform(platform) == "unix"} {
      PRAGMA journal_mode = WAL;
    }
    db close
-    list [file exists test.db-wal] [file exists test.db-shm]
+    list [file exists test.db-wal] [file exists $shmpath]
  } {0 0}
  
  foreach {tn permissions} {
@@ -1088,19 +1112,22 @@ if {$::tcl_platform(platform) == "unix"} {
      file attributes test.db -permissions
    } $permissions
    do_test wal2-12.2.$tn.2 {
-      list [file exists test.db-wal] [file exists test.db-shm]
+      list [file exists test.db-wal] [file exists $shmpath]
    } {0 0}
    do_test wal2-12.2.$tn.3 {
      sqlite3 db test.db
      execsql { INSERT INTO tx DEFAULT VALUES }
-      list [file exists test.db-wal] [file exists test.db-shm]
+      list [file exists test.db-wal] [file exists $shmpath]
    } {1 1}
    do_test wal2-12.2.$tn.4 {
-      list [file attr test.db-wal -perm] [file attr test.db-shm -perm]
+      list [file attr test.db-wal -perm] [file attr $shmpath -perm]
    } [list $effective $effective]
    do_test wal2-12.2.$tn.5 {
+      ifcapable enable_persist_wal {
+        file_control_persist_wal db 0
+      }
      db close
-      list [file exists test.db-wal] [file exists test.db-shm]
+      list [file exists test.db-wal] [file exists $shmpath]
    } {0 0}
  }
 }
@@ -1113,7 +1140,7 @@ if {$::tcl_platform(platform) == "unix"} {
 if {$::tcl_platform(platform) == "unix"} {
  proc perm {} {
    set L [list]
-    foreach f {test.db test.db-wal test.db-shm} {
+    foreach f {test.db test.db-wal $shmpath} {
      if {[file exists $f]} {
        lappend L [file attr $f -perm]
      } else {
@@ -1123,6 +1150,10 @@ if {$::tcl_platform(platform) == "unix"} {
    set L
  }

+  if {[forced_proxy_locking]} {
+    # faultsim_delete_and_reopen doesn't know about the shm file redirect...
+    forcedelete $shmpath
+  }
  faultsim_delete_and_reopen
  execsql {
    PRAGMA journal_mode = WAL;
@@ -1131,8 +1162,11 @@ if {$::tcl_platform(platform) == "unix"} {
    INSERT INTO t1 VALUES('3.14', '2.72');
  }
  do_test wal2-13.1.1 {
-    list [file exists test.db-shm] [file exists test.db-wal]
+    list [file exists $shmpath] [file exists test.db-wal]
  } {1 1}
+  if {[forced_proxy_locking]} {
+    forcecopy $shmpath proxysv_test.db-shm 
+  }
  faultsim_save_and_close

  foreach {tn db_perm wal_perm shm_perm can_open can_read can_write} {
@@ -1146,14 +1180,17 @@ if {$::tcl_platform(platform) == "unix"} {
    9   00000   00644   00644   0   0   0
  } {
    faultsim_restore
+    if {[forced_proxy_locking]} {
+      forcecopy proxysv_test.db-shm $shmpath  
+    }
    do_test wal2-13.$tn.1 {
      file attr test.db     -perm $db_perm
      file attr test.db-wal -perm $wal_perm
-      file attr test.db-shm -perm $shm_perm
+      file attr $shmpath -perm $shm_perm

      set     L [file attr test.db -perm]
      lappend L [file attr test.db-wal -perm]
-      lappend L [file attr test.db-shm -perm]
+      lappend L [file attr $shmpath -perm]
    } [list $db_perm $wal_perm $shm_perm]

    # If $can_open is true, then it should be possible to open a database
@@ -1167,6 +1204,10 @@ if {$::tcl_platform(platform) == "unix"} {
    } $r($can_open)

    if {$can_open} {
+      # Different behavior, because Darwin does an access() call prior
+      # to attempting to open the SHM in read/write mode and demotes to
+      # read-only if the SHM is read-only.
+      if {$tn==4 && $::tcl_platform(os)=="Darwin"} {set can_read 1}

      # If $can_read is true, then the client should be able to read from
      # the database file. If $can_read is false, attempting to read should
@@ -1217,6 +1258,8 @@ foreach {tn sql reslist} {
  set sqlite_sync_count 0
  set sqlite_fullsync_count 0

+  set useres $reslist
+
  do_execsql_test wal2-14.$tn.2 {
    PRAGMA wal_autocheckpoint = 10;
    CREATE TABLE t1(a, b);                -- 2 wal syncs
@@ -1232,7 +1275,7 @@ foreach {tn sql reslist} {
  do_test wal2-14.$tn.3 {
    cond_incr_sync_count 1
    list $sqlite_sync_count $sqlite_fullsync_count
-  } [lrange $reslist 0 1]
+  } [lrange $useres 0 1]

  set sqlite_sync_count 0
  set sqlite_fullsync_count 0
@@ -1240,7 +1283,7 @@ foreach {tn sql reslist} {
  do_test wal2-14.$tn.4 {
    execsql { INSERT INTO t1 VALUES(7, zeroblob(12*4096)) }
    list $sqlite_sync_count $sqlite_fullsync_count
-  } [lrange $reslist 2 3]
+  } [lrange $useres 2 3]

  set sqlite_sync_count 0
  set sqlite_fullsync_count 0
@@ -1252,7 +1295,7 @@ foreach {tn sql reslist} {
    execsql { INSERT INTO t1 VALUES(13, 14) }
    db close
    list $sqlite_sync_count $sqlite_fullsync_count
-  } [lrange $reslist 4 5]
+  } [lrange $useres 4 5]
 }

 catch { db close }
@@ -19,6 +19,7 @@ source $testdir/lock_common.tcl
 source $testdir/wal_common.tcl
 source $testdir/malloc_common.tcl
 ifcapable !wal {finish_test ; return }
+if ![wal_is_ok] {finish_test ; return }

 set a_string_counter 1
 proc a_string {n} {
@@ -211,6 +212,8 @@ foreach {tn syncmode synccount} {
    foreach {method filename id flags} $args break
    lappend ::syncs [file tail $filename] $flags
  }
+  set usecount $synccount
+
  do_test wal3-3.$tn {
    forcedelete test.db test.db-wal test.db-journal
  
@@ -233,7 +236,7 @@ foreach {tn syncmode synccount} {
    }
    T filter {}
    set ::syncs
-  } $synccount
+  } $usecount

  db close
  T delete
@@ -16,6 +16,10 @@ set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 source $testdir/malloc_common.tcl
 ifcapable !wal {finish_test ; return }
+if { ![wal_is_ok] || [path_is_dos "."]} {
+  finish_test 
+  return 
+}

 do_test wal4-1.1 {
  execsql {
--- a/Show More
+++ b/Show More