A WIP checkin, progress toward what .help promises

FossilOrigin-Name: 4688e6dff88527dbff436b811512206d31a9695095776c4e1fdff95da0b0c4d4
Initial help changes for .script (and enhanced .parameter)
2022-01-20 05:20:27 +00:00 · 2022-01-19 21:11:23 +00:00
122 changed files with 1653 additions and 4819 deletions
@@ -460,7 +460,6 @@ TESTSRC += \
  $(TOP)/ext/misc/normalize.c \
  $(TOP)/ext/misc/percentile.c \
  $(TOP)/ext/misc/prefixes.c \
-  $(TOP)/ext/misc/qpvtab.c \
  $(TOP)/ext/misc/regexp.c \
  $(TOP)/ext/misc/remember.c \
  $(TOP)/ext/misc/series.c \
@@ -609,7 +608,7 @@ TESTOPTS = --verbose=file --output=test-out.txt

 # Extra compiler options for various shell tools
 #
-SHELL_OPT = -DSQLITE_ENABLE_FTS4
+SHELL_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_FTS4
 #SHELL_OPT += -DSQLITE_ENABLE_FTS5
 SHELL_OPT += -DSQLITE_ENABLE_RTREE
 SHELL_OPT += -DSQLITE_ENABLE_EXPLAIN_COMMENTS
@@ -619,8 +618,8 @@ SHELL_OPT += -DSQLITE_ENABLE_DBPAGE_VTAB
 SHELL_OPT += -DSQLITE_ENABLE_DBSTAT_VTAB
 SHELL_OPT += -DSQLITE_ENABLE_BYTECODE_VTAB
 SHELL_OPT += -DSQLITE_ENABLE_OFFSET_SQL_FUNC
-FUZZERSHELL_OPT = 
-FUZZCHECK_OPT = -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ
+FUZZERSHELL_OPT = -DSQLITE_ENABLE_JSON1
+FUZZCHECK_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ
 FUZZCHECK_OPT += -DSQLITE_MAX_MEMORY=50000000
 FUZZCHECK_OPT += -DSQLITE_PRINTF_PRECISION_LIMIT=1000
 FUZZCHECK_OPT += -DSQLITE_ENABLE_FTS4
@@ -363,6 +363,7 @@ SQLITE_TCL_DEP =
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_FTS3=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_RTREE=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_GEOPOLY=1
+OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_JSON1=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_STMTVTAB=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_DBPAGE_VTAB=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_DBSTAT_VTAB=1
@@ -1578,7 +1579,6 @@ TESTEXT = \
  $(TOP)\ext\misc\normalize.c \
  $(TOP)\ext\misc\percentile.c \
  $(TOP)\ext\misc\prefixes.c \
-  $(TOP)\ext\misc\qpvtab.c \
  $(TOP)\ext\misc\regexp.c \
  $(TOP)\ext\misc\remember.c \
  $(TOP)\ext\misc\series.c \
@@ -1695,9 +1695,9 @@ SHELL_COMPILE_OPTS = $(SHELL_COMPILE_OPTS) -DSQLITE_ENABLE_OFFSET_SQL_FUNC=1
 # <<mark>>
 # Extra compiler options for various test tools.
 #
-MPTESTER_COMPILE_OPTS = -DSQLITE_ENABLE_FTS5
-FUZZERSHELL_COMPILE_OPTS =
-FUZZCHECK_OPTS = -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ -DSQLITE_MAX_MEMORY=50000000 -DSQLITE_PRINTF_PRECISION_LIMIT=1000
+MPTESTER_COMPILE_OPTS = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_FTS5
+FUZZERSHELL_COMPILE_OPTS = -DSQLITE_ENABLE_JSON1
+FUZZCHECK_OPTS = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5 -DSQLITE_OSS_FUZZ -DSQLITE_MAX_MEMORY=50000000 -DSQLITE_PRINTF_PRECISION_LIMIT=1000
 FUZZCHECK_OPTS = $(FUZZCHECK_OPTS) -DSQLITE_ENABLE_FTS4
 FUZZCHECK_OPTS = $(FUZZCHECK_OPTS) -DSQLITE_ENABLE_FTS5
 FUZZCHECK_OPTS = $(FUZZCHECK_OPTS) -DSQLITE_ENABLE_RTREE
@@ -2392,6 +2392,7 @@ TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_DEFAULT_PAGE_SIZE=1024
 TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_ENABLE_STMTVTAB=1
 TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_ENABLE_DBPAGE_VTAB=1
 TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_ENABLE_BYTECODE_VTAB=1
+TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_ENABLE_JSON1=1
 TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) -DSQLITE_CKSUMVFS_STATIC=1
 TESTFIXTURE_FLAGS = $(TESTFIXTURE_FLAGS) $(TEST_CCONV_OPTS)

@@ -1 +1 @@
-3.39.0
+3.38.0
@@ -285,6 +285,7 @@ SQLITE3EXEPDB = /pdb:sqlite3sh.pdb
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_FTS3=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_RTREE=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_GEOPOLY=1
+OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_JSON1=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_STMTVTAB=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_DBPAGE_VTAB=1
 OPT_FEATURE_FLAGS = $(OPT_FEATURE_FLAGS) -DSQLITE_ENABLE_DBSTAT_VTAB=1
@@ -105,7 +105,7 @@ may be specified in this manner as some require the amalgamation to be built
 with them enabled (see http://www.sqlite.org/compile.html). For example, the
 following will work:

-  "OPTS=-DSQLITE_ENABLE_STAT4=1 -DSQLITE_OMIT_JSON=1"
+  "OPTS=-DSQLITE_ENABLE_STAT4=1 -DSQLITE_ENABLE_JSON1=1"

 However, the following will not compile unless the amalgamation was built
 with it enabled:
@@ -173,6 +173,21 @@ else
 fi
 #-----------------------------------------------------------------------

+#-----------------------------------------------------------------------
+#   --enable-json1
+#
+AC_ARG_ENABLE(json1, [AS_HELP_STRING(
+  [--enable-json1], [include json1 support [default=yes]])], 
+  [],[enable_json1=yes])
+AC_MSG_CHECKING([JSON functions])
+if test x"$enable_json1" = "xyes"; then
+  BUILD_CFLAGS="$BUILD_CFLAGS -DSQLITE_ENABLE_JSON1"
+  AC_MSG_RESULT([enabled])
+else
+  AC_MSG_RESULT([disabled])
+fi
+#-----------------------------------------------------------------------
+
 #-----------------------------------------------------------------------
 #   --enable-rtree
 #
@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for sqlite 3.39.0.
+# Generated by GNU Autoconf 2.69 for sqlite 3.38.0.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -726,8 +726,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='sqlite'
 PACKAGE_TARNAME='sqlite'
-PACKAGE_VERSION='3.39.0'
-PACKAGE_STRING='sqlite 3.39.0'
+PACKAGE_VERSION='3.38.0'
+PACKAGE_STRING='sqlite 3.38.0'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''

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

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

@@ -1533,7 +1533,7 @@ fi

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

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

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

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

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

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

@@ -26,7 +26,7 @@
 **
 ** The virtual table contains read-only hidden columns:
 **
-**     lsm1_key       A BLOB which is the raw LSM key.  If the "keytype"
+**     lsm1_key	      A BLOB which is the raw LSM key.  If the "keytype"
 **                    is BLOB or TEXT then this column is exactly the
 **                    same as the key.  For the UINT keytype, this column
 **                    will be a variable-length integer encoding of the key.
@@ -941,7 +941,7 @@ int sqlite3_csv_init(
  char **pzErrMsg, 
  const sqlite3_api_routines *pApi
 ){
-#ifndef SQLITE_OMIT_VIRTUALTABLE
+#ifndef SQLITE_OMIT_VIRTUALTABLE	
  int rc;
  SQLITE_EXTENSION_INIT2(pApi);
  rc = sqlite3_create_module(db, "csv", &CsvModule, 0);
@@ -284,7 +284,7 @@ int sqlite3_ieee_init(
  SQLITE_EXTENSION_INIT2(pApi);
  (void)pzErrMsg;  /* Unused parameter */
  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
-    rc = sqlite3_create_function(db, aFunc[i].zFName, aFunc[i].nArg,
+    rc = sqlite3_create_function(db, aFunc[i].zFName, aFunc[i].nArg,	
                               SQLITE_UTF8|SQLITE_INNOCUOUS,
                               (void*)&aFunc[i].iAux,
                               aFunc[i].xFunc, 0, 0);
@@ -1,461 +0,0 @@
-/*
-** 2022-01-19
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-**
-** This file implements a virtual-table that returns information about
-** how the query planner called the xBestIndex method.  This virtual table
-** is intended for testing and debugging only.
-**
-** The schema of the virtual table is this:
-**
-**    CREATE TABLE qpvtab(
-**      vn     TEXT,           -- Name of an sqlite3_index_info field
-**      ix     INTEGER,        -- Array index or value
-**      cn     TEXT,           -- Column name
-**      op     INTEGER,        -- operator
-**      ux     BOOLEAN,        -- "usable" field
-**      rhs    TEXT,           -- sqlite3_vtab_rhs_value()
-**
-**      a, b, c, d, e,         -- Extra columns to attach constraints to
-**
-**      flags    INTEGER HIDDEN  -- control flags
-**    );
-**
-** The virtual table returns a description of the sqlite3_index_info object
-** that was provided to the (successful) xBestIndex method.  There is one
-** row in the result table for each field in the sqlite3_index_info object.
-**
-** The values of the "a" through "e" columns are one of:
-**
-**    1.   TEXT - the same as the column name
-**    2.   INTEGER - 1 for "a", 2 for "b", and so forth
-**
-** Option 1 is the default behavior.  2 is use if there is a usable
-** constraint on "flags" with an integer right-hand side that where the
-** value of the right-hand side has its 0x001 bit set.
-**
-** All constraints on columns "a" through "e" are marked as "omit".
-**
-** If there is a usable constraint on "flags" that has a RHS value that
-** is an integer and that integer has its 0x02 bit set, then the
-** orderByConsumed flag is set.
-**
-** FLAGS SUMMARY:
-**
-**   0x001               Columns 'a' through 'e' have INT values
-**   0x002               orderByConsumed is set
-**   0x004               OFFSET and LIMIT have omit set
-**
-** COMPILE:
-**
-**   gcc -Wall -g -shared -fPIC -I. qpvtab.c -o qqvtab.so
-**
-** EXAMPLE USAGE:
-**
-**   .load ./qpvtab
-**   SELECT rowid, *, flags FROM qpvtab(102)
-**    WHERE a=19
-**      AND b BETWEEN 4.5 and 'hello'
-**      AND c<>x'aabbcc'
-**    ORDER BY d, e DESC;
-*/
-#if !defined(SQLITEINT_H)
-#include "sqlite3ext.h"
-#endif
-SQLITE_EXTENSION_INIT1
-#include <string.h>
-#include <assert.h>
-#include <stdlib.h>
-
-#if !defined(SQLITE_OMIT_VIRTUALTABLE)
-
-/* qpvtab_vtab is a subclass of sqlite3_vtab which is
-** underlying representation of the virtual table
-*/
-typedef struct qpvtab_vtab qpvtab_vtab;
-struct qpvtab_vtab {
-  sqlite3_vtab base;  /* Base class - must be first */
-};
-
-/* qpvtab_cursor is a subclass of sqlite3_vtab_cursor which will
-** serve as the underlying representation of a cursor that scans
-** over rows of the result
-*/
-typedef struct qpvtab_cursor qpvtab_cursor;
-struct qpvtab_cursor {
-  sqlite3_vtab_cursor base;  /* Base class - must be first */
-  sqlite3_int64 iRowid;      /* The rowid */
-  const char *zData;         /* Data to return */
-  int nData;                 /* Number of bytes of data */
-  int flags;                 /* Flags value */
-};
-
-/*
-** Names of columns
-*/
-static const char *azColname[] = {
-  "vn",
-  "ix",
-  "cn",
-  "op",
-  "ux",
-  "rhs",
-  "a", "b", "c", "d", "e",
-  "flags",
-  ""
-};
-
-/*
-** The qpvtabConnect() method is invoked to create a new
-** qpvtab virtual table.
-*/
-static int qpvtabConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  qpvtab_vtab *pNew;
-  int rc;
-
-  rc = sqlite3_declare_vtab(db,
-         "CREATE TABLE x("
-         " vn TEXT,"
-         " ix INT,"
-         " cn TEXT,"
-         " op INT,"
-         " ux BOOLEAN,"
-         " rhs TEXT,"
-         " a, b, c, d, e,"
-         " flags INT HIDDEN)"
-       );
-#define QPVTAB_VN      0
-#define QPVTAB_IX      1
-#define QPVTAB_CN      2
-#define QPVTAB_OP      3
-#define QPVTAB_UX      4
-#define QPVTAB_RHS     5
-#define QPVTAB_A       6
-#define QPVTAB_B       7
-#define QPVTAB_C       8
-#define QPVTAB_D       9
-#define QPVTAB_E      10
-#define QPVTAB_FLAGS  11
-#define QPVTAB_NONE   12
-  if( rc==SQLITE_OK ){
-    pNew = sqlite3_malloc( sizeof(*pNew) );
-    *ppVtab = (sqlite3_vtab*)pNew;
-    if( pNew==0 ) return SQLITE_NOMEM;
-    memset(pNew, 0, sizeof(*pNew));
-  }
-  return rc;
-}
-
-/*
-** This method is the destructor for qpvtab_vtab objects.
-*/
-static int qpvtabDisconnect(sqlite3_vtab *pVtab){
-  qpvtab_vtab *p = (qpvtab_vtab*)pVtab;
-  sqlite3_free(p);
-  return SQLITE_OK;
-}
-
-/*
-** Constructor for a new qpvtab_cursor object.
-*/
-static int qpvtabOpen(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
-  qpvtab_cursor *pCur;
-  pCur = sqlite3_malloc( sizeof(*pCur) );
-  if( pCur==0 ) return SQLITE_NOMEM;
-  memset(pCur, 0, sizeof(*pCur));
-  *ppCursor = &pCur->base;
-  return SQLITE_OK;
-}
-
-/*
-** Destructor for a qpvtab_cursor.
-*/
-static int qpvtabClose(sqlite3_vtab_cursor *cur){
-  qpvtab_cursor *pCur = (qpvtab_cursor*)cur;
-  sqlite3_free(pCur);
-  return SQLITE_OK;
-}
-
-
-/*
-** Advance a qpvtab_cursor to its next row of output.
-*/
-static int qpvtabNext(sqlite3_vtab_cursor *cur){
-  qpvtab_cursor *pCur = (qpvtab_cursor*)cur;
-  if( pCur->iRowid<pCur->nData ){
-    const char *z = &pCur->zData[pCur->iRowid];
-    const char *zEnd = strchr(z, '\n');
-    if( zEnd ) zEnd++;
-    pCur->iRowid = (int)(zEnd - pCur->zData);
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Return values of columns for the row at which the qpvtab_cursor
-** is currently pointing.
-*/
-static int qpvtabColumn(
-  sqlite3_vtab_cursor *cur,   /* The cursor */
-  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
-  int i                       /* Which column to return */
-){
-  qpvtab_cursor *pCur = (qpvtab_cursor*)cur;
-  if( i>=QPVTAB_VN && i<=QPVTAB_RHS && pCur->iRowid<pCur->nData ){
-    const char *z = &pCur->zData[pCur->iRowid];
-    const char *zEnd;
-    int j;
-    j = QPVTAB_VN;
-    while(1){
-      zEnd = strchr(z, j==QPVTAB_RHS ? '\n' : ',');
-      if( j==i || zEnd==0 ) break;
-      z = zEnd+1;
-      j++;
-    }
-    if( zEnd==z ){
-      sqlite3_result_null(ctx);
-    }else if( i==QPVTAB_IX || i==QPVTAB_OP || i==QPVTAB_UX ){
-      sqlite3_result_int(ctx, atoi(z));
-    }else{
-      sqlite3_result_text64(ctx, z, zEnd-z, SQLITE_TRANSIENT, SQLITE_UTF8);
-    }
-  }else if( i>=QPVTAB_A && i<=QPVTAB_E ){
-    if( pCur->flags & 0x001 ){
-      sqlite3_result_int(ctx, i-QPVTAB_A+1);
-    }else{
-      char x = 'a'+i-QPVTAB_A;
-      sqlite3_result_text64(ctx, &x, 1, SQLITE_TRANSIENT, SQLITE_UTF8);
-    }
-  }else if( i==QPVTAB_FLAGS ){
-    sqlite3_result_int(ctx, pCur->flags);
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Return the rowid for the current row.  In this implementation, the
-** rowid is the same as the output value.
-*/
-static int qpvtabRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
-  qpvtab_cursor *pCur = (qpvtab_cursor*)cur;
-  *pRowid = pCur->iRowid;
-  return SQLITE_OK;
-}
-
-/*
-** Return TRUE if the cursor has been moved off of the last
-** row of output.
-*/
-static int qpvtabEof(sqlite3_vtab_cursor *cur){
-  qpvtab_cursor *pCur = (qpvtab_cursor*)cur;
-  return pCur->iRowid>=pCur->nData;
-}
-
-/*
-** This method is called to "rewind" the qpvtab_cursor object back
-** to the first row of output.  This method is always called at least
-** once prior to any call to qpvtabColumn() or qpvtabRowid() or 
-** qpvtabEof().
-*/
-static int qpvtabFilter(
-  sqlite3_vtab_cursor *pVtabCursor, 
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  qpvtab_cursor *pCur = (qpvtab_cursor *)pVtabCursor;
-  pCur->iRowid = 0;
-  pCur->zData = idxStr;
-  pCur->nData = (int)strlen(idxStr);
-  pCur->flags = idxNum;
-  return SQLITE_OK;
-}
-
-/*
-** Append the text of a value to pStr
-*/
-static void qpvtabStrAppendValue(
-  sqlite3_str *pStr,
-  sqlite3_value *pVal
-){
-  switch( sqlite3_value_type(pVal) ){
-    case SQLITE_NULL:
-      sqlite3_str_appendf(pStr, "NULL");
-      break;
-    case SQLITE_INTEGER:
-      sqlite3_str_appendf(pStr, "%lld", sqlite3_value_int64(pVal));
-      break;
-    case SQLITE_FLOAT:
-      sqlite3_str_appendf(pStr, "%!f", sqlite3_value_double(pVal));
-      break;
-    case SQLITE_TEXT: {
-      int i;
-      const char *a = (const char*)sqlite3_value_text(pVal);
-      int n = sqlite3_value_bytes(pVal);
-      sqlite3_str_append(pStr, "'", 1);
-      for(i=0; i<n; i++){
-        char c = a[i];
-        if( c=='\n' ) c = ' ';
-        sqlite3_str_append(pStr, &c, 1);
-        if( c=='\'' ) sqlite3_str_append(pStr, &c, 1);
-      }
-      sqlite3_str_append(pStr, "'", 1);
-      break;
-    }
-    case SQLITE_BLOB: {
-      int i;
-      const unsigned char *a = sqlite3_value_blob(pVal);
-      int n = sqlite3_value_bytes(pVal);
-      sqlite3_str_append(pStr, "x'", 2);
-      for(i=0; i<n; i++){
-        sqlite3_str_appendf(pStr, "%02x", a[i]);
-      }
-      sqlite3_str_append(pStr, "'", 1);
-      break;
-    }
-  }
-}
-
-/*
-** SQLite will invoke this method one or more times while planning a query
-** that uses the virtual table.  This routine needs to create
-** a query plan for each invocation and compute an estimated cost for that
-** plan.
-*/
-static int qpvtabBestIndex(
-  sqlite3_vtab *tab,
-  sqlite3_index_info *pIdxInfo
-){
-  sqlite3_str *pStr = sqlite3_str_new(0);
-  int i, k = 0;
-  int rc;
-  sqlite3_str_appendf(pStr, "nConstraint,%d,,,,\n", pIdxInfo->nConstraint);
-  for(i=0; i<pIdxInfo->nConstraint; i++){
-    sqlite3_value *pVal;
-    int iCol = pIdxInfo->aConstraint[i].iColumn;
-    int op = pIdxInfo->aConstraint[i].op;
-    if( iCol==QPVTAB_FLAGS &&  pIdxInfo->aConstraint[i].usable ){
-      pVal = 0;
-      rc = sqlite3_vtab_rhs_value(pIdxInfo, i, &pVal);
-      assert( rc==SQLITE_OK || pVal==0 );
-      if( pVal ){
-        pIdxInfo->idxNum = sqlite3_value_int(pVal);
-        if( pIdxInfo->idxNum & 0x002 ) pIdxInfo->orderByConsumed = 1;
-      }
-    }
-    if( op==SQLITE_INDEX_CONSTRAINT_LIMIT
-     || op==SQLITE_INDEX_CONSTRAINT_OFFSET
-    ){
-      iCol = QPVTAB_NONE;
-    }
-    sqlite3_str_appendf(pStr,"aConstraint,%d,%s,%d,%d,",
-       i,
-       azColname[iCol],
-       op,
-       pIdxInfo->aConstraint[i].usable);
-    pVal = 0;
-    rc = sqlite3_vtab_rhs_value(pIdxInfo, i, &pVal);
-    assert( rc==SQLITE_OK || pVal==0 );
-    if( pVal ){
-      qpvtabStrAppendValue(pStr, pVal);
-    }
-    sqlite3_str_append(pStr, "\n", 1);
-  }
-  for(i=0; i<pIdxInfo->nConstraint; i++){
-    int iCol = pIdxInfo->aConstraint[i].iColumn;
-    int op = pIdxInfo->aConstraint[i].op;
-    if( op==SQLITE_INDEX_CONSTRAINT_LIMIT
-     || op==SQLITE_INDEX_CONSTRAINT_OFFSET
-    ){
-      iCol = QPVTAB_NONE;
-    }
-    if( iCol>=QPVTAB_A && pIdxInfo->aConstraint[i].usable ){
-      pIdxInfo->aConstraintUsage[i].argvIndex = ++k;
-      if( iCol<=QPVTAB_FLAGS || (pIdxInfo->idxNum & 0x004)!=0 ){
-        pIdxInfo->aConstraintUsage[i].omit = 1;
-      }
-    }
-  }
-  sqlite3_str_appendf(pStr, "nOrderBy,%d,,,,\n", pIdxInfo->nOrderBy);
-  for(i=0; i<pIdxInfo->nOrderBy; i++){
-    int iCol = pIdxInfo->aOrderBy[i].iColumn;
-    sqlite3_str_appendf(pStr, "aOrderBy,%d,%s,%d,,\n",i,
-      iCol>=0 ? azColname[iCol] : "rowid",
-      pIdxInfo->aOrderBy[i].desc
-    );
-  }
-  sqlite3_str_appendf(pStr, "sqlite3_vtab_distinct,%d,,,,\n", 
-                      sqlite3_vtab_distinct(pIdxInfo));
-  sqlite3_str_appendf(pStr, "idxFlags,%d,,,,\n", pIdxInfo->idxFlags);
-  sqlite3_str_appendf(pStr, "colUsed,%d,,,,\n", (int)pIdxInfo->colUsed);
-  pIdxInfo->estimatedCost = (double)10;
-  pIdxInfo->estimatedRows = 10;
-  sqlite3_str_appendf(pStr, "idxNum,%d,,,,\n", pIdxInfo->idxNum);
-  sqlite3_str_appendf(pStr, "orderByConsumed,%d,,,,\n",
-                      pIdxInfo->orderByConsumed);
-  pIdxInfo->idxStr = sqlite3_str_finish(pStr);
-  pIdxInfo->needToFreeIdxStr = 1;
-  return SQLITE_OK;
-}
-
-/*
-** This following structure defines all the methods for the 
-** virtual table.
-*/
-static sqlite3_module qpvtabModule = {
-  /* iVersion    */ 0,
-  /* xCreate     */ 0,
-  /* xConnect    */ qpvtabConnect,
-  /* xBestIndex  */ qpvtabBestIndex,
-  /* xDisconnect */ qpvtabDisconnect,
-  /* xDestroy    */ 0,
-  /* xOpen       */ qpvtabOpen,
-  /* xClose      */ qpvtabClose,
-  /* xFilter     */ qpvtabFilter,
-  /* xNext       */ qpvtabNext,
-  /* xEof        */ qpvtabEof,
-  /* xColumn     */ qpvtabColumn,
-  /* xRowid      */ qpvtabRowid,
-  /* xUpdate     */ 0,
-  /* xBegin      */ 0,
-  /* xSync       */ 0,
-  /* xCommit     */ 0,
-  /* xRollback   */ 0,
-  /* xFindMethod */ 0,
-  /* xRename     */ 0,
-  /* xSavepoint  */ 0,
-  /* xRelease    */ 0,
-  /* xRollbackTo */ 0,
-  /* xShadowName */ 0
-};
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-
-
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-int sqlite3_qpvtab_init(
-  sqlite3 *db, 
-  char **pzErrMsg, 
-  const sqlite3_api_routines *pApi
-){
-  int rc = SQLITE_OK;
-  SQLITE_EXTENSION_INIT2(pApi);
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  rc = sqlite3_create_module(db, "qpvtab", &qpvtabModule, 0);
-#endif
-  return rc;
-}
@@ -19,7 +19,7 @@
 ** The sha3(X) function computes the SHA3 hash of the input X, or NULL if
 ** X is NULL.
 **
-** The sha3_query(Y) function evaluates all queries in the SQL statements of Y
+** The sha3_query(Y) function evalutes all queries in the SQL statements of Y
 ** and returns a hash of their results.
 **
 ** The SIZE argument is optional.  If omitted, the SHA3-256 hash algorithm
@@ -4,6 +4,7 @@
 */
 #define TCLSH_INIT_PROC sqlite3_checker_init_proc
 #define SQLITE_ENABLE_DBPAGE_VTAB 1
+#define SQLITE_ENABLE_JSON1 1
 #undef SQLITE_THREADSAFE
 #define SQLITE_THREADSAFE 0
 #undef SQLITE_ENABLE_COLUMN_METADATA
@@ -324,7 +324,7 @@ static int SQLITE_TCLAPI register_box_query(
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;

-  pCtx = (BoxQueryCtx*)ckalloc(sizeof(BoxQueryCtx));
+  pCtx = (BoxQueryCtx*)ckalloc(sizeof(BoxQueryCtx*));
  pCtx->interp = interp;
  pCtx->pScript = Tcl_DuplicateObj(objv[2]);
  Tcl_IncrRefCount(pCtx->pScript);
@@ -377,7 +377,6 @@ TESTSRC += \
  $(TOP)/ext/misc/normalize.c \
  $(TOP)/ext/misc/percentile.c \
  $(TOP)/ext/misc/prefixes.c \
-  $(TOP)/ext/misc/qpvtab.c \
  $(TOP)/ext/misc/regexp.c \
  $(TOP)/ext/misc/remember.c \
  $(TOP)/ext/misc/series.c \
@@ -529,7 +528,7 @@ TESTOPTS = --verbose=file --output=test-out.txt

 # Extra compiler options for various shell tools
 #
-SHELL_OPT += -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5
+SHELL_OPT += -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_FTS4 -DSQLITE_ENABLE_FTS5
 SHELL_OPT += -DSQLITE_ENABLE_RTREE
 SHELL_OPT += -DSQLITE_ENABLE_EXPLAIN_COMMENTS
 SHELL_OPT += -DSQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
@@ -538,7 +537,8 @@ SHELL_OPT += -DSQLITE_ENABLE_DBPAGE_VTAB
 SHELL_OPT += -DSQLITE_ENABLE_DBSTAT_VTAB
 SHELL_OPT += -DSQLITE_ENABLE_BYTECODE_VTAB
 SHELL_OPT += -DSQLITE_ENABLE_OFFSET_SQL_FUNC
-FUZZCHECK_OPT = -DSQLITE_ENABLE_MEMSYS5
+FUZZERSHELL_OPT = -DSQLITE_ENABLE_JSON1
+FUZZCHECK_OPT = -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMSYS5
 FUZZCHECK_OPT += -DSQLITE_MAX_MEMORY=50000000
 FUZZCHECK_OPT += -DSQLITE_PRINTF_PRECISION_LIMIT=1000
 FUZZCHECK_OPT += -DSQLITE_ENABLE_FTS4
@@ -1,13 +1,13 @@
-C The\sperformance\sincrease\sin\sthe\sprevious\scheck-in\sof\sthis\sbranch\swas\sdue\sto\nthe\srevised\sloop\sin\sinitMemArray()\sand\sreordering\sfields\sof\sMem\s-\snot\sthe\ncall\sthe\smemcpy().\s\sChanging\sthe\scode\sto\savoid\smemcpy()\sresults\sin\san\seven\nbetter\sgain,\sand\scode\sthat\sis\sfar\sless\sdodgy.
-D 2022-02-28T12:08:09.462
+C A\sWIP\scheckin,\sprogress\stoward\swhat\s.help\spromises
+D 2022-01-20T05:20:27.018
 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
 F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724
-F Makefile.in b210ad2733317f1a4353085dfb9d385ceec30b0e6a61d20a5accabecac6b1949
+F Makefile.in fd537743957bfe87997dc5727783d8eec82098921e15eab984d6711cd46f001b
 F Makefile.linux-gcc f609543700659711fbd230eced1f01353117621dccae7b9fb70daa64236c5241
-F Makefile.msc b28a8a7a977e7312f6859f560348e1eb110c21bd6cf9fab0d16537c0a514eef3
+F Makefile.msc 22ce0007874c61c8eb51fc22b84f72af175ce2d7431c242253bdffa39c163da4
 F README.md 2dd87a5c1d108b224921f3dd47dea567973f706e1f6959386282a626f459a70c
-F VERSION fa8e7d2d1cc962f9e14c6d410387cf75860ee139462763fda887c1be4261f824
+F VERSION 392c2f83569705069415a5d98b1c138ec8fe8a56a663a0d94cea019e806537b2
 F aclocal.m4 a5c22d164aff7ed549d53a90fa56d56955281f50
 F art/sqlite370.eps aa97a671332b432a54e1d74ff5e8775be34200c2
 F art/sqlite370.ico af56c1d00fee7cd4753e8631ed60703ed0fc6e90
@@ -15,10 +15,10 @@ F art/sqlite370.jpg d512473dae7e378a67e28ff96a34da7cb331def2
 F autoconf/INSTALL 83e4a25da9fd053c7b3665eaaaf7919707915903
 F autoconf/Makefile.am a8d1d24affe52ebf8d7ddcf91aa973fa0316618ab95bb68c87cabf8faf527dc8
 F autoconf/Makefile.fallback 22fe523eb36dfce31e0f6349f782eb084e86a5620b2b0b4f84a2d6133f53f5ac
-F autoconf/Makefile.msc 8401a514e4e70add3c6448348ae31322d5cb7db427b05a20828f943c3ddb2733
+F autoconf/Makefile.msc 262dad10223b39a6853c4faefadb0f71931ca55c742fa285f8ee8d56b7543ddc
 F autoconf/README.first 6c4f34fe115ff55d4e8dbfa3cecf04a0188292f7
-F autoconf/README.txt 42cfd21d0b19dc7d5d85fb5c405c5f3c6a4c923021c39128f6ba685355d8fd56
-F autoconf/configure.ac ec7fa914c5e74ff212fe879f9bb6918e1234497e05facfb641f30c4d5893b277
+F autoconf/README.txt 4f04b0819303aabaa35fff5f7b257fb0c1ef95f1
+F autoconf/configure.ac a8ba2a9e61216f5093d44f3b7d2cb8fe1890d6b7dc330a02f802d8efaa1fdc79
 F autoconf/tea/Makefile.in b438a7020446c8a8156e8d97c8914a04833da6fd
 F autoconf/tea/README 3e9a3c060f29a44344ab50aec506f4db903fb873
 F autoconf/tea/aclocal.m4 52c47aac44ce0ddb1f918b6993e8beb8eee88f43
@@ -34,7 +34,7 @@ F autoconf/tea/win/rules.vc c511f222b80064096b705dbeb97060ee1d6b6d63
 F config.guess 883205ddf25b46f10c181818bf42c09da9888884af96f79e1719264345053bd6
 F config.h.in 6376abec766e9a0785178b1823b5a587e9f1ccbc
 F config.sub c2d0260f17f3e4bc0b6808fccf1b291cb5e9126c14fc5890efc77b9fd0175559
-F configure 00378d14cca0ce02fa9eca28fd494789c2eda7d10d86003a5f9a42f34b0af418 x
+F configure a2877fe63cc821af0df41abe70f1f7c4e97cb7e23a42e0a1402e8a2f55a88aa2 x
 F configure.ac 3ef6eeff4387585bfcab76b0c3f6e15a0618587bb90245dd5d44e4378141bb35
 F contrib/sqlitecon.tcl 210a913ad63f9f991070821e599d600bd913e0ad
 F doc/F2FS.txt c1d4a0ae9711cfe0e1d8b019d154f1c29e0d3abfe820787ba1e9ed7691160fcd
@@ -280,7 +280,7 @@ F ext/lsm1/lsm_str.c 65e361b488c87b10bf3e5c0070b14ffc602cf84f094880bece77bbf6678
 F ext/lsm1/lsm_tree.c 682679d7ef2b8b6f2fe77aeb532c8d29695bca671c220b0abac77069de5fb9fb
 F ext/lsm1/lsm_unix.c 11e0a5c19d754a4e1d93dfad06de8cc201f10f886b8e61a4c599ed34e334fc24
 F ext/lsm1/lsm_varint.c 43f954af668a66c7928b81597c14d6ad4be9fedbc276bbd80f52fa28a02fdb62
-F ext/lsm1/lsm_vtab.c e57aa3eb456bf2b98064014027e097c9402d6dec7b59564ddbfa1c0ead8f96c5
+F ext/lsm1/lsm_vtab.c 169bfe7ef8e6c9de9c77e17c4c50c9ae55fb0167d80be3d1be82c991184b6f35
 F ext/lsm1/lsm_win32.c 0a4acbd7e8d136dd3a5753f0a9e7a9802263a9d96cef3278cf120bcaa724db7c
 F ext/lsm1/test/lsm1_common.tcl 5ed4bab07c93be2e4f300ebe46007ecf4b3e20bc5fbe1dedaf04a8774a6d8d82
 F ext/lsm1/test/lsm1_simple.test a04d08e8661ae6fc53786c67f0bd102c6692f003e859dde03ed9ac3f12e066e5
@@ -297,7 +297,7 @@ F ext/misc/cksumvfs.c b42ef52eaaa510d54ec320c87bea149e934a3b06cd232be2093562bf66
 F ext/misc/closure.c dbfd8543b2a017ae6b1a5843986b22ddf99ff126ec9634a2f4047cd14c85c243
 F ext/misc/completion.c 6dafd7f4348eecc7be9e920d4b419d1fb2af75d938cd9c59a20cfe8beb2f22b9
 F ext/misc/compress.c 3354c77a7c8e86e07d849916000cdac451ed96500bfb5bd83b20eb61eee012c9
-F ext/misc/csv.c d14709096280dc0e20c533f184568952bf4b8022ea80afc4aa9fec5ab3637bb3
+F ext/misc/csv.c 53b3338d4fa812eda51a2637df30233a4dae16b964ee5666e2051b9672ed8bb4
 F ext/misc/dbdata.c e316fba936571584e55abd5b974a32a191727a6b746053a0c9d439bd2cf93940
 F ext/misc/dbdump.c b8592f6f2da292c62991a13864a60d6c573c47a9cc58362131b9e6a64f823e01
 F ext/misc/decimal.c 09f967dcf4a1ee35a76309829308ec278d3648168733f4a1147820e11ebefd12
@@ -306,7 +306,7 @@ F ext/misc/explain.c 0086fab288d4352ea638cf40ac382aad3b0dc5e845a1ea829a694c015fd
 F ext/misc/fileio.c 4e7f7cd30de8df4820c552f14af3c9ca451c5ffe1f2e7bef34d598a12ebfb720
 F ext/misc/fossildelta.c 1240b2d3e52eab1d50c160c7fe1902a9bd210e052dc209200a750bbf885402d5
 F ext/misc/fuzzer.c eae560134f66333e9e1ca4c8ffea75df42056e2ce8456734565dbe1c2a92bf3d
-F ext/misc/ieee754.c 984d51fe23e956484ec1049df6f5257002e3ab338cabceb39761c2e80ad10bf4
+F ext/misc/ieee754.c 91a5594071143a4ab79c638fe9f059af1db09932faf2e704c3e29216a7d4f511
 F ext/misc/memstat.c 3017a0832c645c0f8c773435620d663855f04690172316bd127270d1a7523d4d
 F ext/misc/memtrace.c 7c0d115d2ef716ad0ba632c91e05bd119cb16c1aedf3bec9f06196ead2d5537b
 F ext/misc/memvfs.c 7dffa8cc89c7f2d73da4bd4ccea1bcbd2bd283e3bb4cea398df7c372a197291b
@@ -316,14 +316,13 @@ F ext/misc/noop.c 81efe4cad9ec740e64388b14281cb983e6e2c223fed43eb77ab3e34946e0c1
 F ext/misc/normalize.c bd84355c118e297522aba74de34a4fd286fc775524e0499b14473918d09ea61f
 F ext/misc/percentile.c b9086e223d583bdaf8cb73c98a6539d501a2fc4282654adbfea576453d82e691
 F ext/misc/prefixes.c 0f4f8cff5aebc00a7e3ac4021fd59cfe1a8e17c800ceaf592859ecb9cbc38196
-F ext/misc/qpvtab.c 09738419e25f603a35c0ac8bd0a04daab794f48d08a9bc07a6085b9057b99009
 F ext/misc/regexp.c b267fd05ff8d38b22f4c2809d7b7a2c61d522e9faf2feb928dbb9662e4a3a386
 F ext/misc/remember.c add730f0f7e7436cd15ea3fd6a90fd83c3f706ab44169f7f048438b7d6baa69c
 F ext/misc/rot13.c 51ac5f51e9d5fd811db58a9c23c628ad5f333c173f1fc53c8491a3603d38556c
 F ext/misc/scrub.c 2a44b0d44c69584c0580ad2553f6290a307a49df4668941d2812135bfb96a946
 F ext/misc/series.c 8d79354f2c3d46b95ee21272a07cf0bcabb58d1f2b06d9e7b8a31dca1dacb3e5
 F ext/misc/sha1.c 4011aef176616872b2a0d5bccf0ecfb1f7ce3fe5c3d107f3a8e949d8e1e3f08d
-F ext/misc/shathree.c 7b17615869a495659f1569ada1d8d3d21b4a24614f2746d93cc87ef7c0b6b36d
+F ext/misc/shathree.c 9b6fce315bf8b37bd72786086d1f0974701f651e83022a93244e0e8f56f98a45
 F ext/misc/showauth.c 732578f0fe4ce42d577e1c86dc89dd14a006ab52
 F ext/misc/spellfix.c 94df9bbfa514a563c1484f684a2df3d128a2f7209a84ca3ca100c68a0163e29f
 F ext/misc/sqlar.c 0ace5d3c10fe736dc584bf1159a36b8e2e60fab309d310cd8a0eecd9036621b6
@@ -388,7 +387,7 @@ F ext/rbu/test_rbu.c 03f6f177096a5f822d68d8e4069ad8907fe572c62ff2d19b141f5974282
 F ext/repair/README.md 92f5e8aae749a4dae14f02eea8e1bb42d4db2b6ce5e83dbcdd6b1446997e0c15
 F ext/repair/checkfreelist.c e21f06995ff4efdc1622dcceaea4dcba2caa83ca2f31a1607b98a8509168a996
 F ext/repair/checkindex.c 4383e4469c21e5b9ae321d0d63cec53e981af9d7a6564be6374f0eeb93dfc890
-F ext/repair/sqlite3_checker.c.in 445118c5f7fea958b36fba1b2c464283e60ed4842039ddee3265f1698115ebf7
+F ext/repair/sqlite3_checker.c.in 4a5a3af3f450fe503e5a2985e98516dc2a6b9ad247449e284c1cf140fc91720f
 F ext/repair/sqlite3_checker.tcl a9a2caa9660567257c177a91124d8c0dccdfa341e25c51e6da7f1fd9e601eafa
 F ext/repair/test/README.md 34b2f542cf5be7bffe479242b33ee3492cea30711e447cc4a1a86cb5915f419e
 F ext/repair/test/checkfreelist01.test 3e8aa6aeb4007680c94a8d07b41c339aa635cc78249442da72ff3f8297398a69
@@ -426,7 +425,7 @@ F ext/rtree/rtreedoc2.test 194ebb7d561452dcdc10bf03f44e30c082c2f0c14efeb07f5e02c
 F ext/rtree/rtreedoc3.test 555a878c4d79c4e37fa439a1c3b02ee65d3ebaf75d9e8d96a9c55d66db3efbf8
 F ext/rtree/rtreefuzz001.test 0fc793f67897c250c5fde96cefee455a5e2fb92f4feeabde5b85ea02040790ee
 F ext/rtree/sqlite3rtree.h 03c8db3261e435fbddcfc961471795cbf12b24e03001d0015b2636b0f3881373
-F ext/rtree/test_rtreedoc.c de76b3472bc74b788d079342fdede22ff598796dd3d97acffe46e09228af83a3
+F ext/rtree/test_rtreedoc.c 5ad4029d6804eb9efafcac1598a9e0582f6119e48f818854f5b4db1788ca8bd4
 F ext/rtree/tkt3363.test 142ab96eded44a3615ec79fba98c7bde7d0f96de
 F ext/rtree/util/randomshape.tcl 54ee03d0d4a1c621806f7f44d5b78d2db8fac26e0e8687c36c4bd0203b27dbff
 F ext/rtree/viewrtree.tcl eea6224b3553599ae665b239bd827e182b466024
@@ -473,7 +472,7 @@ F ext/userauth/userauth.c 7f00cded7dcaa5d47f54539b290a43d2e59f4b1eb5f447545fa865
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 80ac3d2f82eb21c6fb4423f9c7f8e207abb51be6676845a00e246cfb22f9c77c
+F main.mk 32e8c752386520016933873a23a9c649f1a9cfd5c75c218614e622f0510b8f42
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -485,46 +484,46 @@ F spec.template 86a4a43b99ebb3e75e6b9a735d5fd293a24e90ca
 F sqlite.pc.in 42b7bf0d02e08b9e77734a47798d1a55a9e0716b
 F sqlite3.1 fc7ad8990fc8409983309bb80de8c811a7506786
 F sqlite3.pc.in 48fed132e7cb71ab676105d2a4dc77127d8c1f3a
-F src/alter.c e31cae888bc3077e34f9a82c6b4a96e4e44d37861eeb6472d68a378f1e8e46ba
-F src/analyze.c 3a119baeb03053c154029877454d41bb8fd79d4d1eb583392f2289b3554a75bc
-F src/attach.c f26d400f3ffe2cdca01406bca70e5f58c5488bf165b4fc37c228136dfcf1b583
+F src/alter.c e3943d8fbcaf60f79f39d4aecc56a6a8092f51f93d6a7c5b1db2633c5fa10c30
+F src/analyze.c 7518b99e07c5494111fe3bd867f28f804b6c5c1ad0703ec3d116de9bab3fa516
+F src/attach.c e3f9d9a2a4a844750f3f348f37afb244535f21382cbfcd840152cb21cb41cfaf
 F src/auth.c f4fa91b6a90bbc8e0d0f738aa284551739c9543a367071f55574681e0f24f8cf
-F src/backup.c a2891172438e385fdbe97c11c9745676bec54f518d4447090af97189fd8e52d7
+F src/backup.c 3014889fa06e20e6adfa0d07b60097eec1f6e5b06671625f476a714d2356513d
 F src/bitvec.c 7c849aac407230278445cb069bebc5f89bf2ddd87c5ed9459b070a9175707b3d
 F src/btmutex.c 8acc2f464ee76324bf13310df5692a262b801808984c1b79defb2503bbafadb6
-F src/btree.c 11dfaa11397d415fe760ed96d447a1d0cd50db8bd1ee11a91c81a97e364f648c
+F src/btree.c ddab31c38d5f16114bc68392430556b1063fe14e0020f9a56d2c35ddd58ba7e3
 F src/btree.h 74d64b8f28cfa4a894d14d4ed64fa432cd697b98b61708d4351482ae15913e22
-F src/btreeInt.h 7282a6e77775f93a6eb78d3a41dab372a01a4ec1d93d3b4728d191d15fda42e2
-F src/build.c 9891c2160886cf7e344d7e8f1f7177f9612916c7c67ffeacd64cb34a92d387a8
+F src/btreeInt.h ee9348c4cb9077243b049edc93a82c1f32ca48baeabf2140d41362b9f9139ff7
+F src/build.c c72407a27a28982a384cd453a3a6b6992a1ceae8bd8d95e96d7fb9c0d645a32f
 F src/callback.c 4c19af69835787bfe790ac560f3071a824eb629f34e41f97b52ce5235c77de1c
 F src/complete.c a3634ab1e687055cd002e11b8f43eb75c17da23e
 F src/ctime.c 2cce39df1a13e05b7633e6d21b651f21492471f991dd7b323a4ee4e7b7f0b7f1
-F src/date.c 1abbd739ae1d3fc8e0aaff995f57332af10d0b332728e4d3f241c494515495f0
+F src/date.c ab8e01d928f201f5dee0bc6d54d6702fdcec96dff4d58c387447671f6a46d191
 F src/dbpage.c 8a01e865bf8bc6d7b1844b4314443a6436c07c3efe1d488ed89e81719047833a
 F src/dbstat.c 861e08690fcb0f2ee1165eff0060ea8d4f3e2ea10f80dab7d32ad70443a6ff2d
-F src/delete.c b5f1716b4d723db48254ee0f896e362cd029e865e05414139ea7f539f3884e1d
-F src/expr.c b90a029105a93a93a0ed5e5f8c5eaed8f19043a3b62e4c4d235a4611d9ada178
+F src/delete.c 19814f621cde10b1771a0dea7fe25d3d7d39975b8d4be4888537d30860e7c08c
+F src/expr.c 827179c78d2ca7cc318392811de8151c60eacf7ce804b13e61bb7ef38f954846
 F src/fault.c 460f3e55994363812d9d60844b2a6de88826e007
-F src/fkey.c 06e4ac33031b02dde7130c12e79cddf4dc5cfa72b23d8e63a3c26878fc9c1d3c
-F src/func.c f801c6bc8b30afea51817d86a6c46259d3cca180c612cfa0a30b18d661e9c8df
-F src/global.c a3daa18a1696aadd94f18d37cbbdebf0bbdb827b8397a534f021cd56c15cd0f9
+F src/fkey.c 5b73f7a7c00f06017531a5bd258cbc2c7a294e55a7f84a729fe27aa525242560
+F src/func.c 8fddc42bce95d17938252a543f86fe29e479366e80fbd112a1822913b6247776
+F src/global.c 1f56aead86e8a18c4415638f5e6c4d0a0550427f4b3f5d065ba5164cc09c22e8
 F src/hash.c 8d7dda241d0ebdafb6ffdeda3149a412d7df75102cecfc1021c98d6219823b19
 F src/hash.h 3340ab6e1d13e725571d7cee6d3e3135f0779a7d8e76a9ce0a85971fa3953c51
 F src/hwtime.h cb1d7e3e1ed94b7aa6fde95ae2c2daccc3df826be26fc9ed7fd90d1750ae6144
 F src/in-operator.md 10cd8f4bcd225a32518407c2fb2484089112fd71
-F src/insert.c 1eea44389de3768ac98588c1410171cd53e7c6ad1af74049983dcbac82093de0
-F src/json.c 225b00422112ecd7094a555f3ace16b25d7d5894062b823269ed03899907c2a2
+F src/insert.c e528416ff5d86fc5d656ea6a26f03fde39836b6175f93048c32a03cb2ee16743
+F src/json.c 78fdec9af3a8bfb5ae685707b2701276fec1942b8f5f26689b2701debe32bcd2
 F src/legacy.c d7874bc885906868cd51e6c2156698f2754f02d9eee1bae2d687323c3ca8e5aa
-F src/loadext.c aa919a6a7884f8b34d7b791841b24d14b1b0ab43f45b3940f4851043b2855c0c
-F src/main.c 0840cee6984034c7e73cc747a1562c7eaed4673694bf20b00980aaa0672c0405
-F src/malloc.c fec841aa0a0400a6f7d20706178a5d8e8219a6bf562b6fe712c17f6c26813266
+F src/loadext.c 95db1fe62c5973f1c5d9c53f6083e21a73ece14cdd47eeca0639691332e85c4d
+F src/main.c 2b6b0dbfeb14d4bb57e368604b0736b2aa42b51b00339d399b01d6b1fc9b4960
+F src/malloc.c ef796bcc0e81d845d59a469f1cf235056caf9024172fd524e32136e65593647b
 F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
 F src/mem1.c c12a42539b1ba105e3707d0e628ad70e611040d8f5e38cf942cee30c867083de
 F src/mem2.c c8bfc9446fd0798bddd495eb5d9dbafa7d4b7287d8c22d50a83ac9daa26d8a75
 F src/mem3.c 30301196cace2a085cbedee1326a49f4b26deff0af68774ca82c1f7c06fda4f6
 F src/mem5.c 9bf955937b07f8c32541c8a9991f33ce3173d944
 F src/memdb.c c2dc88f97c410eb68a24468344b65526685e18354ddfd15906750c1eaf9dc2dd
-F src/memjournal.c 8bd50ae6d9c6d34b3a96cc3b4f567f9935dc358444d872ab48901a8c11ad82a6
+F src/memjournal.c ff4336a98b05ede2adee7595f22d6f7d1cdc6bf0f0a5c3d77b0acdf017b2e8b2
 F src/msvc.h 3a15918220367a8876be3fa4f2abe423a861491e84b864fb2b7426bf022a28f8
 F src/mutex.c 5e3409715552348732e97b9194abe92fdfcd934cfb681df4ba0ab87ac6c18d25
 F src/mutex.h a7b2293c48db5f27007c3bdb21d438873637d12658f5a0bf8ad025bb96803c4a
@@ -539,30 +538,30 @@ F src/os_setup.h 0dbaea40a7d36bf311613d31342e0b99e2536586
 F src/os_unix.c f5ad51cfd024116db8531feab9efd831c2621436dca1464e4ff1e8af9bf3252e
 F src/os_win.c 77d39873836f1831a9b0b91894fec45ab0e9ca8e067dc8c549e1d1eca1566fe9
 F src/os_win.h 7b073010f1451abe501be30d12f6bc599824944a
-F src/pager.c 90a3721b4ab007a835c751a441c1b1fc68bfe68d99dd298f28d91cc163730194
-F src/pager.h f82e9844166e1585f5786837ddc7709966138ced17f568c16af7ccf946c2baa3
-F src/parse.y 0f02b27cdaa334441463153fff3ceb780fea006ab53ffd6ef566d4468f93e924
+F src/pager.c f6183fb7370425cd8642759693d9994649217cf7111caef89bc2c4946afbc36d
+F src/pager.h 4bf9b3213a4b2bebbced5eaa8b219cf25d4a82f385d093cd64b7e93e5285f66f
+F src/parse.y 04f61db1cdd7036c6d74baad1c342d3e3110cb0765c48fcfd3bdf4e974a1e5bb
 F src/pcache.c 084e638432c610f95aea72b8509f0845d2791293f39d1b82f0c0a7e089c3bb6b
 F src/pcache.h 4f87acd914cef5016fae3030343540d75f5b85a1877eed1a2a19b9f284248586
 F src/pcache1.c 54881292a9a5db202b2c0ac541c5e3ef9a5e8c4f1c1383adb2601d5499a60e65
-F src/pragma.c a7323cd175587afa0b82c213b9bba5789fe9ea67f9e5d66e35df00742a923bcc
-F src/pragma.h e690a356c18e98414d2e870ea791c1be1545a714ba623719deb63f7f226d8bb7
-F src/prepare.c a187dade741c1f09ae118fcbbf0302511807bfc0355880927d7152eb75b8260d
-F src/printf.c 05d8dfd2018bc4fc3ddb8b37eb97ccef7abf985643fa1caebdcf2916ca90fa32
+F src/pragma.c c536665ce8431c8b1efbf7e0a5c01852f49f7bf28f1954f8118b2d28e4a3797f
+F src/pragma.h 87330ed2fbfa2a1274de93ca0ab850fba336189228cb256089202c3b52766fad
+F src/prepare.c 45fe7408eb78d80eca8392669070a6e5caf231b09e5c7b1ff65c1ad64a3734c5
+F src/printf.c 975f1f5417f2526365b6e6d7f22332e3e11806dad844701d92846292b654ba9a
 F src/random.c 097dc8b31b8fba5a9aca1697aeb9fd82078ec91be734c16bffda620ced7ab83c
-F src/resolve.c ea935b87d6fb36c78b70cdc7b28561dc8f33f2ef37048389549c7b5ef9b0ba5e
+F src/resolve.c 359bc0e445d427583d2ab6110433a5dc777f64a0ecdf8d24826d8b475233ead9
 F src/rowset.c ba9515a922af32abe1f7d39406b9d35730ed65efab9443dc5702693b60854c92
-F src/select.c 4890a3cfee0bc60ff231c3a44db37968859ab0be156983dbcc0c096109832cdd
-F src/shell.c.in 14cdfba32c73cb06169e50cd448632c28359f2bab2a0f803dc4a7f46dfc5b6fa
-F src/sqlite.h.in e82ac380b307659d0892f502b742f825504e78729f4edaadce946003b9c00816
+F src/select.c a4a23a70f0a24a1103ac9698f6be181a6ec7ff6c19e03e8899c43cb6d2af09d6
+F src/shell.c.in 732a2ee32b11825b797754bacd77cb4b09ff813c2f77786fc5d9f3a803fa4997
+F src/sqlite.h.in a5e0d6bd47e67aabf1475986d36bdcc7bfa9e06566790ebf8e3aa7fa551c9f99
 F src/sqlite3.rc 5121c9e10c3964d5755191c80dd1180c122fc3a8
-F src/sqlite3ext.h a95cb9ed106e3d39e2118e4dcc15a14faec3fa50d0093425083d340d9dfd96e6
-F src/sqliteInt.h 4a8b7d685781df55ce546b6c72bdbd72bb23ca93f59b6d70d81ed6df22607d75
+F src/sqlite3ext.h 01eb85e4f2759a5ee79c183f4b2877889d4ffdc49d27ae74529c9579e3c8c0ef
+F src/sqliteInt.h 21a31abf60222f50c1d654cdc27ad9d4040249f0341129dd8286b8b5b32bcd30
 F src/sqliteLimit.h d7323ffea5208c6af2734574bae933ca8ed2ab728083caa117c9738581a31657
 F src/status.c 4b8bc2a6905163a38b739854a35b826c737333fab5b1f8e03fa7eb9a4799c4c1
 F src/table.c 0f141b58a16de7e2fbe81c308379e7279f4c6b50eb08efeec5892794a0ba30d1
-F src/tclsqlite.c 1f6673991147bc2cecc08a40d22f9803b84c805b24b499fe727f392256f73474
-F src/test1.c 87fda59eea3ac1eba1baef37c1967565cb1b8d6d264649f2e57f252ca5989914
+F src/tclsqlite.c 48f291e1a7e672a7204884d4c164a8ed3a522ff087c361ada2991f5d54e987f6
+F src/test1.c f13fe747afc7d9af189ce0cdaaf641252c5803db2a32bd3525eec2905c7b4f37
 F src/test2.c 3efb99ab7f1fc8d154933e02ae1378bac9637da5
 F src/test3.c 61798bb0d38b915067a8c8e03f5a534b431181f802659a6616f9b4ff7d872644
 F src/test4.c 7c4420e01c577b5c4add2cb03119743b1a357543d347773b9e717195ea967159
@@ -574,10 +573,10 @@ F src/test9.c 12e5ba554d2d1cbe0158f6ab3f7ffcd7a86ee4e5
 F src/test_async.c 195ab49da082053fdb0f949c114b806a49ca770a
 F src/test_autoext.c 915d245e736652a219a907909bb6710f0d587871
 F src/test_backup.c bf5da90c9926df0a4b941f2d92825a01bbe090a0
-F src/test_bestindex.c 8294d8223b7f18a3ddb7f9a0e30815dcca4e61681f78b538c870f7d934f88b81
+F src/test_bestindex.c 78809f11026f18a93fcfd798d9479cba37e1201c830260bf1edc674b2fa9b857
 F src/test_blob.c ae4a0620b478548afb67963095a7417cd06a4ec0a56adb453542203bfdcb31ce
 F src/test_btree.c 8b2dc8b8848cf3a4db93f11578f075e82252a274
-F src/test_config.c 8264637b06a3c1f0727c88d1ea32dcf7986b9e7e358a970cae87cdac8a5b2708
+F src/test_config.c 284c29912736f68b0a583a920bf63fd8f9125dffb8a75cb0676e58502b2f7908
 F src/test_delete.c e2fe07646dff6300b48d49b2fee2fe192ed389e834dd635e3b3bac0ce0bf9f8f
 F src/test_demovfs.c 86142ba864d4297d54c5b2e972e74f3141ae4b30f05b3a95824184ed2d3d7f91
 F src/test_devsym.c aff2255ea290d7718da08af30cdf18e470ff7325a5eff63e0057b1496ed66593
@@ -616,34 +615,34 @@ F src/test_windirent.h 90dfbe95442c9762357fe128dc7ae3dc199d006de93eb33ba3972e0a9
 F src/test_window.c cdae419fdcea5bad6dcd9368c685abdad6deb59e9fc8b84b153de513d394ba3f
 F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
 F src/threads.c 4ae07fa022a3dc7c5beb373cf744a85d3c5c6c3c
-F src/tokenize.c 6661a9fa660ecbd3ac0df1acd2ec788b3a8122b4316022bcdaf476ea6754a8de
-F src/treeview.c a84b57d15e46007d8b1ae249344b3f0b7f3c62def908b98baaa54935a57c8476
-F src/trigger.c 19fc6fe696a2409b04496df1ff044e6a942dad6ed3b6e897b1c9093b88cc2c62
-F src/update.c f875b0d59da5c3055a0b2ac20560e1650229c6787e78de5e9836267b5cbb8359
+F src/tokenize.c b74d878aa7c82ec8460779468061a96185e22257f68ab785b69abce354b70446
+F src/treeview.c 9dfdb7ff7f6645d0a6458dbdf4ffac041c071c4533a6db8bb6e502b979ac67bc
+F src/trigger.c 40e7c3dcff57a770d5fa38ba21ed4725572fd2e224c58af61eb980598b60f9c8
+F src/update.c d6f5c7b9e072660757ac7d58175aca11c07cb95ebbb297ae7f38853700f52328
 F src/upsert.c 8789047a8f0a601ea42fa0256d1ba3190c13746b6ba940fe2d25643a7e991937
 F src/utf.c ee39565f0843775cc2c81135751ddd93eceb91a673ea2c57f61c76f288b041a0
-F src/util.c 602fe229f32a96ceccae4f40824129669582096f7c355f53dbac156c9fecef23
+F src/util.c 89e51820bcb468ff3877a8d942f5cc807208087f021227e0927693e928a195bc
 F src/vacuum.c 6c38ddc52f0619865c91dae9c441d4d48bf3040d7dc1bc5b22da1e45547ed0b3
-F src/vdbe.c 4b969ebe6b61f87a90aebf817bc6ebda5075fe56987591091a9bf22556262484
-F src/vdbe.h a1d0e3b934e835e73edd146f2e7c4eadb711b5c9875c18159a57483fd78e550e
-F src/vdbeInt.h 2ff02995d153d30d362c99d27248b8a3bf825617a8e0d4d8d1e0231eca3bc4f7
-F src/vdbeapi.c 1c80efbe51118bbecc7279023e75d18edcfa4b3dc441287e1718ee70ad594f58
-F src/vdbeaux.c 0f3ce77dabb1f897cc7d3812ed162ec5d31d2298d1aa41b606f8048a742c4b9e
-F src/vdbeblob.c 5e61ce31aca17db8fb60395407457a8c1c7fb471dde405e0cd675974611dcfcd
-F src/vdbemem.c 7737f0b1c480a32b057849c804d2f21d5389649bb8be80f77ad75df700adc9a1
+F src/vdbe.c 71fbbf8da3d8aadf14a574b35b48f488166793e5add34908380ee2dc7c732c99
+F src/vdbe.h 25dabb25c7e157b84e59260cfb5b466c3ac103ede9f36f4db371332c47601abe
+F src/vdbeInt.h d89d5d2150500cfb08615329fd20aea9d746bba5f2c3ecb8a17e2d2d9be029e5
+F src/vdbeapi.c 22c79072ae7d8a01e9bcae8ba16e918d60d202eaa9553b5fda38f99f7464d99a
+F src/vdbeaux.c c1b452cc17f5887b3d36bc277a2181914d6bed508ea45827b5f348160491e6a6
+F src/vdbeblob.c 29c4118f7ee615cdee829e8401f6ead1b96b95d545b4de0042f6de39c962c652
+F src/vdbemem.c da4d594084d581be6436582bb44bb128feeb138a3e6c313eda6749ebdc3a65ec
 F src/vdbesort.c 43756031ca7430f7aec3ef904824a7883c4ede783e51f280d99b9b65c0796e35
 F src/vdbetrace.c fe0bc29ebd4e02c8bc5c1945f1d2e6be5927ec12c06d89b03ef2a4def34bf823
 F src/vdbevtab.c f99b275366c5fc5e2d99f734729880994ab9500bdafde7fae3b02d562b9d323c
-F src/vtab.c e0eaf5b8f7f8929088485a76bea2ff6124adb12e0eb5c0997287ff5e0e4c0517
+F src/vtab.c a47cc12ebaa350800c0c87b6b0095debbb5a6ed32727bcab9d82ad070a81b738
 F src/vxworks.h d2988f4e5a61a4dfe82c6524dd3d6e4f2ce3cdb9
-F src/wal.c b9df133a705093da8977da5eb202eaadb844839f1c7297c08d33471f5491843d
+F src/wal.c ed0398a7adf02c31e34aada42cc86c58f413a7afe5f741a5d373ad087abde028
 F src/wal.h c3aa7825bfa2fe0d85bef2db94655f99870a285778baa36307c0a16da32b226a
 F src/walker.c f890a3298418d7cba3b69b8803594fdc484ea241206a8dfa99db6dd36f8cbb3b
-F src/where.c 0d75d7514764726409ea945520fe9fb515e7d9ae52a5a3c0a136142cfaa19087
-F src/whereInt.h 15d2975c3b4c193c78c26674400a840da8647fe1777ae3b026e2d15937b38a03
-F src/wherecode.c d34d3980f35e504a558f788ad9ac4bc6876b119409d597e7e234a4564a94c6ab
-F src/whereexpr.c 2a71f5491798460c9590317329234d332d9eb1717cba4f3403122189a75c465e
-F src/window.c dfaec4abc6012cbc18e4a202ca3a5d5a0efcc4011d86a06d882ddaab8aedee4d
+F src/where.c eedf0311d59095bcd8523bd13bf25865e1caf1fab9beddbff9093340a1a409c7
+F src/whereInt.h 91865afa4a3540bb3bd643619acc56fbceff7defeb8f249b8e157fd5325d88be
+F src/wherecode.c 6a594ed25bfbeb60d455868b7be62637575e4f1949152de4336e4825e0c54ba6
+F src/whereexpr.c 9f64c39e53070584e99e4d20c1dd3397e125fabbae8fd414ffec574c410ac7d3
+F src/window.c 5d3b397b0c026d0ff5890244ac41359e524c01ae31e78782e1ff418c3e271a9e
 F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
 F test/affinity2.test ce1aafc86e110685b324e9a763eab4f2a73f737842ec3b687bd965867de90627
 F test/affinity3.test eecb0dabee4b7765a8465439d5e99429279ffba23ca74a7eae270a452799f9e7
@@ -657,18 +656,18 @@ F test/alter3.test ffc4ab29ce78a3517a66afd69b2730667e3471622509c283b2bd4c46f680f
 F test/alter4.test 716caa071dd8a3c6d57225778d15d3c3cbf5e34b2e84ae44199aeb2bbf50a707
 F test/alterauth.test 63442ba61ceb0c1eeb63aac1f4f5cebfa509d352276059d27106ae256bafc959
 F test/alterauth2.test 48967abae0494d9a300d1c92473d99fcb66edfcc23579c89322f033f49410adc
-F test/altercol.test 8465ca659c2c55a359cf16cc261df4fcb5c45a5f104a50827c337ae66c09dc15
+F test/altercol.test 9471187fe155d9c4211ae185e104ff48ce8f114262ee1256cf1e110b339c725f
 F test/altercorrupt.test 2e1d705342cf9d7de884518ddbb053fd52d7e60d2b8869b7b63b2fda68435c12
 F test/alterdropcol.test a653a3945f964d26845ec0cd0a8e74189f46de3119a984c5bc45457da392612e
 F test/alterdropcol2.test 527fce683b200d620f560f666c44ae33e22728e990a10a48a543280dfd4b4d41
 F test/alterfault.test 289067108947bedca27534edd4ff251bcd298cf84402d7b24eaa3749305418c6
 F test/alterlegacy.test f38c6d06cda39e1f7b955bbce57f2e3ef5b7cb566d3d1234502093e228c15811
 F test/altermalloc.test 167a47de41b5c638f5f5c6efb59784002b196fff70f98d9b4ed3cd74a3fb80c9
-F test/altermalloc2.test 17fb3724c4b004c469c27dc4ef181608aa644555fbd3f3236767584f73747c81
-F test/altermalloc3.test 55e606edf4b0acfbbd851ddfe93cfdddfae43d103644dcfd6008ae4ab3c44adf
+F test/altermalloc2.test ca3ebc01670d9313953a2b7628d8cc00dc5ea9988f229b3cbbbe1cca506dae45
+F test/altermalloc3.test 4660ac6240a8c82ba3947b927612dcc7c05a8eec3fe3c9f38e047ca69a789a33
 F test/alterqf.test 3008318ba9e16b4ac0b5f83cf7683caa4b0a3154aafe3b4099838a250d4ba74a
 F test/altertab.test 7273b8506eab46342be016af78028df49f3bd99037412f997a8f1011b37a6912
-F test/altertab2.test 62597b6fd08feaba1b6bfe7d31dac6117c67e06dc9ce9c478a3abe75b5926de0
+F test/altertab2.test b0d62f323ca5dab42b0bc028c52e310ebdd13e655e8fac070fe622bad7852c2b
 F test/altertab3.test 5929f522fd6fd708396ad9f317d4af9ff1a93e460df85bb1d54d4499eeb94960
 F test/amatch1.test b5ae7065f042b7f4c1c922933f4700add50cdb9f
 F test/analyze.test 547bb700f903107b38611b014ca645d6b5bb819f5210d7bf39c40802aafeb7d7
@@ -715,7 +714,7 @@ F test/autovacuum_ioerr2.test 8a367b224183ad801e0e24dcb7d1501f45f244b4
 F test/avfs.test 0c3a38e03cccb0fc3127838462dc05dc3f4c1480d770c084b388304c25de3652
 F test/avtrans.test b7dc25459ecbd86c6fa9c606ee3068f59d81e225118617dcf2bbb6ded2ade89e
 F test/backcompat.test 3e64cedda754c778ef6bbe417b6e7a295e662a4d
-F test/backup.test fc1ecefce723fad5199b55cec7a5a992ec8c3ad6873419e5e8919066dec457f3
+F test/backup.test dd4a5ff756e3df3931dacb1791db0584d4bad989
 F test/backup2.test 8facb54df1388419d34b362ab1f7e233310ff3a3af64e8ad5ec47ba3c2bbe5cf
 F test/backup4.test 8f6fd48e0dfde77b9a3bb26dc471ede3e101df32
 F test/backup5.test ee5da6d7fe5082f5b9b0bbfa31d016f52412a2e4
@@ -724,14 +723,13 @@ F test/backup_malloc.test 0c9abdf74c51e7bedb66d504cd684f28d4bd4027
 F test/badutf.test d5360fc31f643d37a973ab0d8b4fb85799c3169f
 F test/badutf2.test f310fd3b24a491b6b77bccdf14923b85d6ebcce751068c180d93a6b8ff854399
 F test/bc_common.tcl b5e42d80305be95697e6370e015af571e5333a1c
-F test/bestindex1.test 856a453dff8c68b4568601eed5a8b5e20b4763af9229f3947c215729ed878db0
-F test/bestindex2.test 394ff8fbf34703391247116d6a44e1c50ee7282236ee77909044573cefc37bc0
-F test/bestindex3.test 34bea272b0e0f835651b16a3931dbe7ac927039be6b2e1cb617bbe1d584b492b
-F test/bestindex4.test 3039894f2dad50f3a68443dffad1b44c9b067ac03870102df1ce3d9a46ea602e
-F test/bestindex5.test a0c90b2dad7836e80a01379e200e5f8ec9476d49b349af02c0dbff2fb75dc98d
-F test/bestindex6.test 16942535b551273f3ad9df8d7cc4b7f22b1fcd8882714358859eb049a6f99dd4
-F test/bestindex7.test f094c669a6400777f4d2ddc3ed28e39169f1adb5be3d59b55f22ccf8c414b71e
-F test/bestindex8.test abd0016fc04f19dc382976750b06df5463d2757e11e78a8ba7d7dc50671f3337
+F test/bestindex1.test 7cc626f1f4a7483bb6b38487d467db4477083be5cd93958aeda5d5127640dc81
+F test/bestindex2.test 60266e2854055788459cbfd86cef575601eabe74a2c61faba72601739fea4398
+F test/bestindex3.test e061a6ed0f519beee037ba7e7a4c37f80c8a7e4a303e2559ed1f760e4b0235eb
+F test/bestindex4.test 82250e7dcc6d5b15244edc9d6554b1760583af1b8548c2a255a1c4f28e744c0e
+F test/bestindex5.test 67c1166131bb59f9e47c00118f7d432ca5491e6cae6ca3f87ca9db20103a78f9
+F test/bestindex6.test d856a9bb63d927493575823eed44053bc36251e241aa364e54d0f2a2d302e1d4
+F test/bestindex7.test a11348824aed0de2bb9030f092636929000cd72882bdf919adacc3792f67ccbd
 F test/between.test b9a65fb065391980119e8a781a7409d3fcf059d89968279c750e190a9a1d5263
 F test/bigfile.test aa74f4e5db51c8e54a1d9de9fa65d01d1eb20b59
 F test/bigfile2.test 1b489a3a39ae90c7f027b79110d6b4e1dbc71bfc
@@ -739,7 +737,6 @@ F test/bigmmap.test b820c234daa56d24bc3bf006e3ac7aa9d9623c8ac656a38f59063b444a2d
 F test/bigrow.test f0aeb7573dcb8caaafea76454be3ade29b7fc747
 F test/bigsort.test 8299fa9298f4f1e02fc7d2712e8b77d6cd60e5a2
 F test/bind.test 1e136709b306f7ed3192d349c2930d89df6ab621654ad6f1a72381d3fe76f483
-F test/bind2.test 918bc35135f4141809ead7585909cde57d44db90a7a62aef540127148f91aab7
 F test/bindxfer.test efecd12c580c14df5f4ad3b3e83c667744a4f7e0
 F test/bitvec.test 75894a880520164d73b1305c1c3f96882615e142
 F test/blob.test e7ac6c7d3a985cc4678c64f325292529a69ae252
@@ -763,7 +760,7 @@ F test/capi2.test 4ee545824adc3eb33bf57ef89f77440b28188ec3da72e5425ff0fcdba32e8d
 F test/capi3.test 3910a73c38ac76d69778dd9eb481ab7cd6ed59117fc047b4f6056a5c72529de1
 F test/capi3b.test efb2b9cfd127efa84433cd7a2d72ce0454ae0dc4
 F test/capi3c.test 54e2dc0c8fd7c34ad1590d1be6864397da2438c95a9f5aee2f8fbc60c112e44b
-F test/capi3d.test 8b778794af891b0dca3d900bd345fbc8ebd2aa2aae425a9dccdd10d5233dfbde
+F test/capi3d.test aba917805573a03deed961a21f07a5a84505ad0a616f7e3fc1508844a15bccc4
 F test/capi3e.test 3d49c01ef2a1a55f41d73cba2b23b5059ec460fe
 F test/carray01.test d55d57bf66b1af1c7ac55fae66ff4910884a8f5d21a90a18797ce386212a2634
 F test/cast.test 336fa21989b5170ebcaf90c24266be22dd97b3e23d1fad5ecf6ad4efb04c4423
@@ -837,9 +834,8 @@ F test/ctime.test 340f362f41f92972bbd71f44e10569a5cc694062b692231bd08aa6fe6c1c47
 F test/cursorhint.test 0175e4404181ace3ceca8b114eb0a98eae600d565aa4e2705abbe6614c7fe201
 F test/cursorhint2.test 6f3aa9cb19e7418967a10ec6905209bcbb5968054da855fc36c8beee9ae9c42f
 F test/dataversion1.test 6e5e86ac681f0782e766ebcb56c019ae001522d114e0e111e5ebf68ccf2a7bb8
-F test/date.test 50d5b1eeec57041c000d2be5e9ab995026ded4255507f0206c81c1ca3b34b840
+F test/date.test 9b73bbeb1b82d9c1f44dec5cf563bf7da58d2373
 F test/date2.test 7e12ec14aaf4d5e6294b4ba140445b0eca06ea50062a9c3a69c4ee13d0b6f8b1
-F test/date3.test a1b77abf05c6772fe5ca2337cac1398892f2a41e62bce7e6be0f4a08a0e64ae5
 F test/dbdata.test 042f49acff3438f940eeba5868d3af080ae64ddf26ae78f80c92bec3ca7d8603
 F test/dbfuzz.c 73047c920d6210e5912c87cdffd9a1c281d4252e
 F test/dbfuzz001.test 55e1a3504f8dea84155e09912fe3b1c3ad77e0b1a938ec42ca03b8e51b321e30
@@ -867,12 +863,12 @@ F test/e_blobclose.test 692fc02a058476c2222a63d97e3f3b2b809c1842e5525ded7f854d54
 F test/e_blobopen.test 29f6055ee453b8e679fe9570c4d3acfedbef821622c5dad16875148c5952ef50
 F test/e_blobwrite.test 3075ff539827576d9a34cbb5a2ac75eb65fb49cd5aadc27686b0719fbf99c156
 F test/e_changes.test 0f8c3e6aab7335cb772d5a3ea34ca4c82f98d0eb896e2eb3add971c16984b405
-F test/e_createtable.test e3b9782e80c0cf2898ac0eb1d9cd058412955ff53a8e47307a60c8289d62ff9c
+F test/e_createtable.test 04c50b7fe41c12ed9cd88fbbc09b4900bcfc66f98ad198874fc993a2771f3913
 F test/e_delete.test ab39084f26ae1f033c940b70ebdbbd523dc4962e
 F test/e_droptrigger.test 235c610f8bf8ec44513e222b9085c7e49fad65ad0c1975ac2577109dd06fd8fa
 F test/e_dropview.test 74e405df7fa0f762e0c9445b166fe03955856532e2bb234c372f7c51228d75e7
-F test/e_expr.test bc6aa5906ba967587525bc746ea403011557cf6d8e4fc9efb1fab5dae7fb4fd6
-F test/e_fkey.test feeba6238aeff9d809fb6236b351da8df4ae9bda89e088e54526b31a0cbfeec5
+F test/e_expr.test e164550b9f8fd9c130283d1eae692dff9e2ba67f4dbd35f7325021f5d4b8851c
+F test/e_fkey.test ee321dbca3c53204da46cb40b8ec80192e995035f9ea26576ddcd842b1f0877f
 F test/e_fts3.test 17ba7c373aba4d4f5696ba147ee23fd1a1ef70782af050e03e262ca187c5ee07
 F test/e_insert.test f02f7f17852b2163732c6611d193f84fc67bc641fb4882c77a464076e5eba80e
 F test/e_reindex.test 2b0e29344497d9a8a999453a003cb476b6b1d2eef2d6c120f83c2d3a429f3164
@@ -1058,13 +1054,13 @@ F test/func5.test 863e6d1bd0013d09c17236f8a13ea34008dd857d87d85a13a673960e4c25d8
 F test/func6.test 90e42b64c4f9fb6f04f44cb8a1da586c8542502e926b19c76504fe74ff2a9b7c
 F test/func7.test b9e2a1a30a8562b00841b4a21a5d2d81754fa3ab99275fd71fd5279287b44b1c
 F test/fuzz-oss1.test 514dcabb24687818ea949fa6760229eaacad74ca70157743ef36d35bbe01ffb0
-F test/fuzz.test 4608c1310cff4c3014a84bcced6278139743e080046e5f6784b0de7b069371d8
+F test/fuzz.test 96083052bf5765e4518c1ba686ce2bab785670d1
 F test/fuzz2.test 76dc35b32b6d6f965259508508abce75a6c4d7e1
 F test/fuzz3.test 9c813e6613b837cb7a277b0383cd66bfa07042b4cf0317157c35852f30043c31
 F test/fuzz4.test c229bcdb45518a89e1d208a21343e061503460ac69fae1539320a89f572eb634
 F test/fuzz_common.tcl b7197de6ed1ee8250a4f82d67876f4561b42ee8cbbfc6160dcb66331bad3f830
 F test/fuzz_malloc.test f348276e732e814802e39f042b1f6da6362a610af73a528d8f76898fde6b22f2
-F test/fuzzcheck.c e34696a5db46738118b2efd14fb71f8458ecf0f482df8bbae18fa1d64db9ab7b
+F test/fuzzcheck.c bdb852815048a0beebbe5768bca61e75295324a811a8d7216f97b96501befd1e
 F test/fuzzdata1.db d36e88741b4f23bcbaaf55b006290669d03c6c891cf13c7b3a53bc1b097b693f
 F test/fuzzdata2.db 128b3feeb78918d075c9b14b48610145a0dd4c8d6f1ca7c2870c7e425f5bf31f
 F test/fuzzdata3.db c6586d3e3cef0fbc18108f9bb649aa77bfc38aba
@@ -1072,7 +1068,7 @@ F test/fuzzdata4.db b502c7d5498261715812dd8b3c2005bad08b3a26e6489414bd13926cd3e4
 F test/fuzzdata5.db e35f64af17ec48926481cfaf3b3855e436bd40d1cfe2d59a9474cb4b748a52a5
 F test/fuzzdata6.db 92a80e4afc172c24f662a10a612d188fb272de4a9bd19e017927c95f737de6d7
 F test/fuzzdata7.db 0166b56fd7a6b9636a1d60ef0a060f86ddaecf99400a666bb6e5bbd7199ad1f2
-F test/fuzzdata8.db ca9a97f401b06b0d5376139ec7e1f9e773e13345a9a2d9ccc0032cdbfedea230
+F test/fuzzdata8.db a0c7af954bcbb226ed7ae087b3b6d6e48eaac8fac5671150ffd23c35b55bffe6
 F test/fuzzer1.test 3d4c4b7e547aba5e5511a2991e3e3d07166cfbb8
 F test/fuzzer2.test a85ef814ce071293bce1ad8dffa217cbbaad4c14
 F test/fuzzerfault.test f64c4aef4c9e9edf1d6dc0d3f1e65dcc81e67c996403c88d14f09b74807a42bc
@@ -1143,7 +1139,7 @@ F test/join.test 25cf0ac11c3b81fedfd166f9062166bdb39dea92f5a7c16cacbf6dc1f7f6702
 F test/join2.test 9bdc615841b91c97a16d68bad9508aea11fa0c6b34e5689847bcc4dac70e4990
 F test/join3.test 6f0c774ff1ba0489e6c88a3e77b9d3528fb4fda0
 F test/join4.test 1a352e4e267114444c29266ce79e941af5885916
-F test/join5.test 37864d567928652cab79a7872ebde74b3c67a1feb0366d98bb3bc7832885f388
+F test/join5.test d22395f7d4020a58cabbc8316f300a5cfef84aee9e8ba7ce79b33cc43a3e1e2e
 F test/join6.test f809c025fa253f9e150c0e9afd4cef8813257bceeb6f46e04041228c9403cc2c
 F test/journal1.test c7b768041b7f494471531e17abc2f4f5ebf9e5096984f43ed17c4eb80ba34497
 F test/journal2.test 9dac6b4ba0ca79c3b21446bbae993a462c2397c4
@@ -1151,11 +1147,11 @@ F test/journal3.test 7c3cf23ffc77db06601c1fcfc9743de8441cb77db9d1aa931863d94f5ff
 F test/jrnlmode.test 9b5bc01dac22223cb60ec2d5f97acf568d73820794386de5634dcadbea9e1946
 F test/jrnlmode2.test 8759a1d4657c064637f8b079592651530db738419e1d649c6df7048cd724363d
 F test/jrnlmode3.test 556b447a05be0e0963f4311e95ab1632b11c9eaa
-F test/json101.test d7c84854acafaf80f883e183ac4248ea2742615086c94a61a46ad7d7382ce123
-F test/json102.test 327e77275f338c028faefa2da5164daf6b142a165e3015ff2a6e4251ddc6a0ac
-F test/json103.test 53df87f83a4e5fa0c0a56eb29ff6c94055c6eb919f33316d62161a8880112dbe
-F test/json104.test a502dc01853aada95d721b3b275afbe2dc18fffdac1fea6e96fb20c13586bbb5
-F test/json105.test 11670a4387f4308ae0318cadcbd6a918ea7edcd19fbafde020720a073952675d
+F test/json101.test bb71538005f2d9e18620bdd3b76839a93ca0be61903eb8d751a64e78cf99b8fb
+F test/json102.test 86edc7d283085addff8593b178997e75875530d1385f5926717543d3475e6b01
+F test/json103.test aff6b7a4c17d5a20b487a7bc1a274bfdc63b829413bdfb83bedac42ec7f67e3b
+F test/json104.test 2cb7ff2cca2c8214d3e5260eeb9ce45faec0926f68b3e40c1aaa6ca247284144
+F test/json105.test 45f7d6a9a54c85f8a9589b68d3e7a1f42d02f2359911a8cdbad1f9988f571173
 F test/keyword1.test 37ef6bba5d2ed5b07ecdd6810571de2956599dff
 F test/kvtest.c feb4358fb022da8ebd098c45811f2f6507688bb6c43aa72b3e840df19026317b
 F test/lastinsert.test 42e948fd6442f07d60acbd15d33fb86473e0ef63
@@ -1212,7 +1208,7 @@ F test/memjournal2.test 89a4e0d1084170a281efa4d54c2677599f986f44227f98f7dfae2828
 F test/memleak.test 10b9c6c57e19fc68c32941495e9ba1c50123f6e2
 F test/memsubsys1.test 9e7555a22173b8f1c96c281ce289b338fcba2abe8b157f8798ca195bbf1d347e
 F test/memsubsys2.test 3e4a8d0c05fd3e5fa92017c64666730a520c7e08
-F test/merge1.test 0ade470d77b689c4a64dc7f736527fcd893140bcafa70af8f7b98523cfb83f16
+F test/merge1.test c5abf7d4eca25b3d5ee96927efff18efc3cee5a8af54b8415cbddd6d4471fd70
 F test/minmax.test fe638b55d77d2375531a8f549b338eafcd9adfbd2f72df37ed77d9b26ca0a71a
 F test/minmax2.test cf9311babb6f0518d04e42fd6a42c619531c4309a9dd790a2c4e9b3bc595e0de
 F test/minmax3.test cc1e8b010136db0d01a6f2a29ba5a9f321034354
@@ -1295,7 +1291,7 @@ F test/pragma5.test 7b33fc43e2e41abf17f35fb73f71b49671a380ea92a6c94b6ce530a25f8d
 F test/pragmafault.test 275edaf3161771d37de60e5c2b412627ac94cef11739236bec12ed1258b240f8
 F test/prefixes.test b524a1c44bffec225b9aec98bd728480352aa8532ac4c15771fb85e8beef65d9
 F test/printf.test 390d0d7fcffc3c4ea3c1bb4cbb267444e32b33b048ae21895f23a291844fe1da
-F test/printf2.test 3f55c1871a5a65507416076f6eb97e738d5210aeda7595a74ee895f2224cce60
+F test/printf2.test 30b5dd0b4b992dc5626496846ecce17ff592cacbcb11c3e589f3ac4d7e129dae
 F test/progress.test ebab27f670bd0d4eb9d20d49cef96e68141d92fb
 F test/ptrchng.test ef1aa72d6cf35a2bbd0869a649b744e9d84977fc
 F test/pushdown.test 5e72c51c5e33253ed639ccee1e01ce62d62b6eee5ca893cd82334e4ee7b1d7fc
@@ -1313,7 +1309,7 @@ F test/recover.test ccb8c2623902a92ebb76770edd075cb4f75a4760bb7afde38026572c6e79
 F test/regexp1.test 0c3ff80f66b0eff80e623eb5db7a3dad512095c573d78ac23009785f6d8f51ce
 F test/regexp2.test 55ed41da802b0e284ac7e2fe944be3948f93ff25abbca0361a609acfed1368b5
 F test/reindex.test cd9d6021729910ece82267b4f5e1b5ac2911a7566c43b43c176a6a4732e2118d
-F test/releasetest_data.tcl 11ba48a21ed1c808147b0e77c6e93d204577f4327ffe6d7c3b34cd3c01eac3a2
+F test/releasetest_data.tcl 7cea6c852ae6bb3a9ff1a2b910e4dd13c16a05f74443984dfd52159b0b01ea55
 F test/resetdb.test 8062cf10a09d8c048f8de7711e94571c38b38168db0e5877ba7561789e5eeb2b
 F test/resolver01.test f4022acafda7f4d40eca94dbf16bc5fc4ac30ceb
 F test/returning1.test ee0b115162b17f59fe486767899596b1e8290bcd845db05d7d1d9e6c2dad1b8b
@@ -1325,11 +1321,11 @@ F test/round1.test 768018b04522ca420b1aba8a24bd76091d269f3bce3902af3ec6ebcee41ab
 F test/rowallock.test 3f88ec6819489d0b2341c7a7528ae17c053ab7cc
 F test/rowhash.test 0bc1d31415e4575d10cacf31e1a66b5cc0f8be81
 F test/rowid.test e29025be95baf6b32f0d5edef59a7633028325896a98f1caa8019559ca910350
-F test/rowvalue.test 228b312f8526ed000ecda559a6a9adf30aa2d79dcb12afa5c04eebaafcf55eae
+F test/rowvalue.test 37effea4dd83555ea969a9461dfcffb25e6731a5db7c388e232410999c100853
 F test/rowvalue2.test 060d238b7e5639a7c5630cb5e63e311b44efef2b
 F test/rowvalue3.test 3068f508753af69884b12125995f023da0dbb256
 F test/rowvalue4.test 441e7e366ac6d939a3a95a574031c56ec2a854077a91d66eee5ff1d86cb5be58
-F test/rowvalue5.test 00740304ea6a53a8704640c7405690f0045d5d2a6b4b04dde7bccc14c3068ea7
+F test/rowvalue5.test c81c7d8cf36711ab37675ad7376084ae2a359cb6
 F test/rowvalue6.test d19b54feb604d5601f8614b15e214e0774c01087
 F test/rowvalue7.test c1cbdbf407029db01f87764097c6ac02a1c5a37efd2776eff32a9cdfdf6f2dba
 F test/rowvalue8.test 5900eddad9e2c3c2e26f1a95f74aafc1232ee5e0
@@ -1388,11 +1384,11 @@ F test/sharedA.test 49d87ec54ab640fbbc3786ee3c01de94aaa482a3a9f834ad3fe92770eb69
 F test/sharedB.test 16cc7178e20965d75278f410943109b77b2e645e
 F test/shared_err.test 32634e404a3317eeb94abc7a099c556a346fdb8fb3858dbe222a4cbb8926a939
 F test/sharedlock.test 5ede3c37439067c43b0198f580fd374ebf15d304
-F test/shell1.test b224e0793c5f48aa3749e65d8c64b93a30731bd206f2e41e6c5f1bee1bdb16c6
-F test/shell2.test 89e4b2db062d52baed75022227b462d085cff495809de1699652779d8e0257d6
-F test/shell3.test a50628ab1d78d90889d9d3f32fb2c084ee15674771e96afe954aaa0accd1de3c
-F test/shell4.test 8f6c0fce4abed19a8a7f7262517149812a04caa905d01bdc8f5e92573504b759
-F test/shell5.test 2b521446f55146c9aafccd0946bdb44ae288b0d25bd48f722e041974fdeeb04a
+F test/shell1.test 70f46b5d07776a107335c3c2c9cbd0431d44637bfeae1f6b9ded5e33b4c7c0bf
+F test/shell2.test f00a0501c00583cbc46f7510e1d713366326b2b3e63d06d15937284171a8787c
+F test/shell3.test cb4b835a901742c9719437a89171172ecc4a8823ad97349af8e4e841e6f82566
+F test/shell4.test 3ed6c4b42fd695efcbc25d69ef759dbb15855ca8e52ba6c5ee076f8b435f48be
+F test/shell5.test b85069bfcf3159b225228629ab2c3e69aa923d098fea8ea074b5dcd743522e2c
 F test/shell6.test 1ceb51b2678c472ba6cf1e5da96679ce8347889fe2c3bf93a0e0fa73f00b00d3
 F test/shell7.test 115132f66d0463417f408562cc2cf534f6bbc6d83a6d50f0072a9eb171bae97f
 F test/shell8.test 388471d16e4de767333107e30653983f186232c0e863f4490bb230419e830aae
@@ -1465,7 +1461,7 @@ F test/tabfunc01.test 241425ce3998687ab24adba09cb95e8012e17499b84a0ed47e128ab45e
 F test/table.test eb3463b7add9f16a5bb836badf118cf391b809d09fdccd1f79684600d07ec132
 F test/tableapi.test ecbcc29c4ab62c1912c3717c48ea5c5e59f7d64e4a91034e6148bd2b82f177f4
 F test/tableopts.test dba698ba97251017b7c80d738c198d39ab747930
-F test/tclsqlite.test ad0bbd92edabe64cc91d990a0748142fe5ab962d74ac71fa3bfa94d50d2f4c87
+F test/tclsqlite.test 97cda6e4843e9f3e06c56f656d9b77ee0178fe1ee33fb09a6eeae8f125757ac1
 F test/tempdb.test 4cdaa23ddd8acb4d79cbb1b68ccdfd09b0537aaba909ca69a876157c2a2cbd08
 F test/tempdb2.test 353864e96fd3ae2f70773d0ffbf8b1fe48589b02c2ec05013b540879410c3440
 F test/tempfault.test 0c0d349c9a99bf5f374655742577f8712c647900
@@ -1727,9 +1723,7 @@ F test/vtabK.test 13293177528fada1235c0112db0d187d754af1355c5a39371abd365104e3af
 F test/vtab_alter.test 736e66fb5ec7b4fee58229aa3ada2f27ec58bc58c00edae4836890c3784c6783
 F test/vtab_err.test dcc8b7b9cb67522b3fe7a272c73856829dae4ab7fdb30399aea1b6981bda2b65
 F test/vtab_shared.test 5253bff2355a9a3f014c15337da7e177ab0ef8ad
-F test/vtabdistinct.test 7688f0889358f849fd60bbfde1ded38b014b18066076d4bfbb75395804dfe072
 F test/vtabdrop.test 65d4cf6722972e5499bdaf0c0d70ee3b8133944a4e4bc31862563f32a7edca12
-F test/vtabrhs1.test 9b5ecbc74a689500c33a4b2b36761f9bcc22fcc4e3f9d21066ee0c9c74cf5f6c
 F test/wal.test b7cc6984709f54afbf8441747ced1f646af120bf0c1b1d847bfa39306fbea089
 F test/wal2.test 31f6e2c404b9f2cdf9ca19b105a1742fdc19653c2c936da39e3658c617524046
 F test/wal3.test 2a93004bc0fb2b5c29888964024695bade278ab2
@@ -1759,7 +1753,7 @@ F test/walpersist.test 8c6b7e3ec1ba91b5e4dc4e0921d6d3f87cd356a6
 F test/walprotocol.test 1b3f922125e341703f6e946d77fdc564d38fb3e07a9385cfdc6c99cac1ecf878
 F test/walprotocol2.test 7d3b6b4bf0b12f8007121b1e6ef714bc99101fb3b48e46371df1db868eebc131
 F test/walro.test cb438d05ba0d191f10b688e39c4f0cd5b71569a1d1f4440e5bdf3c6880e08c20
-F test/walro2.test 33955a6fd874dd9724005e17f77fef89d334b3171454a1256fe4941a96766cdc
+F test/walro2.test 0e79dd15cbdb4f482c01ea248373669c732414a726b357d04846a816afafb768
 F test/walrofault.test c70cb6e308c443867701856cce92ad8288cd99488fa52afab77cca6cfd51af68
 F test/walsetlk.test 3185bebc90557e0d611442c8d64f7a0cb7b06f8e156eea37a4a7358f722715be
 F test/walshared.test 0befc811dcf0b287efae21612304d15576e35417
@@ -1826,7 +1820,7 @@ F test/with4.test 257be66c0c67fee1defbbac0f685c3465e2cad037f21ce65f23f86084f1982
 F test/with5.test 6248213c41fab36290b5b73aa3f937309dfba337004d9d8434c3fabc8c7d4be8
 F test/with6.test 661d7e416bef6c0a2556b2c9f0c8178a5b15932bed65246abed99723a8d4e7c0
 F test/withM.test 693b61765f2b387b5e3e24a4536e2e82de15ff64
-F test/without_rowid1.test a5210b8770dc4736bca4e74bc96588f43025ad03ad6a80f885afd36d9890e217
+F test/without_rowid1.test 78fd9b437f4cdb46f76e6a510d545334e4f58e3e4ce37aaf19384eda5b27de8c
 F test/without_rowid2.test af260339f79d13cb220288b67cd287fbcf81ad99
 F test/without_rowid3.test 39ab0dd773eaa62e59b17093f875327630f54c4145458f6d2b053d68d4b2f67b
 F test/without_rowid4.test 4e08bcbaee0399f35d58b5581881e7a6243d458a
@@ -1875,9 +1869,9 @@ F tool/mkctimec.tcl 3147e9dfc4ad774e94f80084789ebaada9da9b6e66ddab16438cfc07999b
 F tool/mkkeywordhash.c 35bfc41adacc4aa6ef6fca7fd0c63e0ec0534b78daf4d0cfdebe398216bbffc3
 F tool/mkmsvcmin.tcl 6ecab9fe22c2c8de4d82d4c46797bda3d2deac8e763885f5a38d0c44a895ab33
 F tool/mkopcodec.tcl 33d20791e191df43209b77d37f0ff0904620b28465cca6990cf8d60da61a07ef
-F tool/mkopcodeh.tcl 5dab48c49a25452257494e9601702ab63adaba6bd54a9b382615fa52661c8f8c
+F tool/mkopcodeh.tcl 130b88697da6ec5b89b41844d955d08fb62c2552e889dec8c7bcecb28d8f50bd
 F tool/mkopts.tcl 680f785fdb09729fd9ac50632413da4eadbdf9071535e3f26d03795828ab07fa
-F tool/mkpragmatab.tcl bd07bd59d45d0f3448e123d6937e9811195f9908a51e09d774609883055bfd3d
+F tool/mkpragmatab.tcl de206c64b6e9ac8cd5e3cbd0ffe456f07d5710605ef8385d677e60ce3335ea12
 F tool/mkshellc.tcl df5d249617f9cc94d5c48eb0401673eb3f31f383ecbc54e8a13ca3dd97e89450
 F tool/mksourceid.c 36aa8020014aed0836fd13c51d6dc9219b0df1761d6b5f58ff5b616211b079b9
 F tool/mkspeedsql.tcl a1a334d288f7adfe6e996f2e712becf076745c97
@@ -1887,7 +1881,7 @@ F tool/mksqlite3h.tcl 1f5e4a1dbbbc43c83cc6e74fe32c6c620502240b66c7c0f33a51378e78
 F tool/mksqlite3internalh.tcl eb994013e833359137eb53a55acdad0b5ae1049b
 F tool/mkvsix.tcl b9e0777a213c23156b6542842c238479e496ebf5
 F tool/offsets.c 8ed2b344d33f06e71366a9b93ccedaa38c096cc1dbd4c3c26ad08c6115285845
-F tool/omittest.tcl 3bc9609aceea871e1ca6ed6749df9ce79b89369d22b492f6ce6078f40647cc3f
+F tool/omittest.tcl 3d222272b1d840b4e3d67bff0cb743ce3f633faddadb3702b2056b726775db8f
 F tool/opcodesum.tcl 740ed206ba8c5040018988129abbf3089a0ccf4a
 F tool/pagesig.c ff0ca355fd3c2398e933da5e22439bbff89b803b
 F tool/replace.tcl 937c931ad560688e85bdd6258bdc754371bb1e2732e1fb28ef441e44c9228fce
@@ -1909,7 +1903,7 @@ F tool/speedtest2.tcl ee2149167303ba8e95af97873c575c3e0fab58ff
 F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
 F tool/speedtest8inst1.c 7ce07da76b5e745783e703a834417d725b7d45fd
 F tool/split-sqlite3c.tcl 3efcd4240b738f6bb2b5af0aea7e1e0ef9bc1c61654f645076cec883030b710c
-F tool/sqldiff.c 4f967c199c5f93eec64978e3a625d6c07fb1162212b1d48f65740d9eb4607eee
+F tool/sqldiff.c 9c639de9fa541a947ea9776435c84adf00f43945e262556e15219ef09f0d912c
 F tool/sqlite3_analyzer.c.in f88615bf33098945e0a42f17733f472083d150b58bdaaa5555a7129d0a51621c
 F tool/sqltclsh.c.in 1bcc2e9da58fadf17b0bf6a50e68c1159e602ce057210b655d50bad5aaaef898
 F tool/sqltclsh.tcl 862f4cf1418df5e1315b5db3b5ebe88969e2a784525af5fbf9596592f14ed848
@@ -1918,10 +1912,10 @@ F tool/stack_usage.tcl f8e71b92cdb099a147dad572375595eae55eca43
 F tool/symbols-mingw.sh 4dbcea7e74768305384c9fd2ed2b41bbf9f0414d
 F tool/symbols.sh 1612bd947750e21e7b47befad5f6b3825b06cce0705441f903bf35ced65ae9b9
 F tool/varint.c 5d94cb5003db9dbbcbcc5df08d66f16071aee003
-F tool/vdbe-compress.tcl 1dcb7632e57cf57105248029e6e162fddaf6c0fccb3bb9e6215603752c5a2d4a
+F tool/vdbe-compress.tcl 5926c71f9c12d2ab73ef35c29376e756eb68361c
 F tool/vdbe_profile.tcl 246d0da094856d72d2c12efec03250d71639d19f
 F tool/warnings-clang.sh bbf6a1e685e534c92ec2bfba5b1745f34fb6f0bc2a362850723a9ee87c1b31a7
-F tool/warnings.sh d58dc38367cc776550f90327e205d7946802d4004fb9f291fd8b81256bc1eedd
+F tool/warnings.sh 09311479bdc290e20ec8e35a3d1b14b096bbd96222277cfd6274c3a99b3d012f
 F tool/win/sqlite.vsix deb315d026cc8400325c5863eef847784a219a2f
 F vsixtest/App.xaml b76d3b48860e7454775c47ea38ffea9c4abe3e85
 F vsixtest/App.xaml.cpp 41158ee43269820136fa3bba00c0bd91b26cc38b650ee392aec2a8d823e54318
@@ -1944,8 +1938,8 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 7fefd8676110a53e6c98a697e2dbf820740fe602a1e83b6caa8d099c41a15d80
-R 0cbe8ba68087a6c2d38d406f08a0fa0f
-U drh
-Z d7015a158f91cecfa6d5c894c1220cae
+P a94ab403eb836d3fcb9710d22da5129f58db05d3be145bc77ce1c017761e7894
+R df6ba47c6584db70fd023a69e282f313
+U larrybr
+Z 2d0ff93e3043918f6083e9631f60e14c
 # Remove this line to create a well-formed Fossil manifest.
@@ -1 +1 @@
-d74aa979530d4236f5900d2ef998b27065d352d7c18bcd822e5c8f1041a1a81c
+4688e6dff88527dbff436b811512206d31a9695095776c4e1fdff95da0b0c4d4
@@ -324,9 +324,7 @@ void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
  int r1;                   /* Temporary registers */

  db = pParse->db;
-  assert( db->pParse==pParse );
-  if( pParse->nErr ) return;
-  assert( db->mallocFailed==0 );
+  if( pParse->nErr || db->mallocFailed ) return;
  pNew = pParse->pNewTable;
  assert( pNew );

@@ -631,7 +629,7 @@ void sqlite3AlterRenameColumn(
    if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
  }
  if( iCol==pTab->nCol ){
-    sqlite3ErrorMsg(pParse, "no such column: \"%T\"", pOld);
+    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld);
    goto exit_rename_column;
  }

@@ -737,9 +735,7 @@ struct RenameCtx {
 ** following a valid object, it may not be used in comparison operations.
 */
 static void renameTokenCheckAll(Parse *pParse, const void *pPtr){
-  assert( pParse==pParse->db->pParse );
-  assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
-  if( pParse->nErr==0 ){
+  if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){
    const RenameToken *p;
    u8 i = 0;
    for(p=pParse->pRename; p; p=p->pNext){
@@ -1061,12 +1057,12 @@ static void renameColumnParseError(
  const char *zN = (const char*)sqlite3_value_text(pObject);
  char *zErr;

-  zErr = sqlite3MPrintf(pParse->db, "error in %s %s%s%s: %s", 
+  zErr = sqlite3_mprintf("error in %s %s%s%s: %s", 
      zT, zN, (zWhen[0] ? " " : ""), zWhen,
      pParse->zErrMsg
  );
  sqlite3_result_error(pCtx, zErr, -1);
-  sqlite3DbFree(pParse->db, zErr);
+  sqlite3_free(zErr);
 }

 /*
@@ -1136,7 +1132,7 @@ static int renameParseSql(
  /* Parse the SQL statement passed as the first argument. If no error
  ** occurs and the parse does not result in a new table, index or
  ** trigger object, the database must be corrupt. */
-  sqlite3ParseObjectInit(p, db);
+  memset(p, 0, sizeof(Parse));
  p->eParseMode = PARSE_MODE_RENAME;
  p->db = db;
  p->nQueryLoop = 1;
@@ -1421,13 +1417,13 @@ static void renameParseCleanup(Parse *pParse){
  sqlite3DeleteTrigger(db, pParse->pNewTrigger);
  sqlite3DbFree(db, pParse->zErrMsg);
  renameTokenFree(db, pParse->pRename);
-  sqlite3ParseObjectReset(pParse);
+  sqlite3ParserReset(pParse);
 }

 /*
 ** SQL function:
 **
-**     sqlite_rename_column(SQL,TYPE,OBJ,DB,TABLE,COL,NEWNAME,QUOTE,TEMP)
+**     sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld)
 **
 **   0. zSql:     SQL statement to rewrite
 **   1. type:     Type of object ("table", "view" etc.)
@@ -1445,8 +1441,7 @@ static void renameParseCleanup(Parse *pParse){
 **
 ** This function is used internally by the ALTER TABLE RENAME COLUMN command.
 ** It is only accessible to SQL created using sqlite3NestedParse().  It is
-** not reachable from ordinary SQL passed into sqlite3_prepare() unless the
-** SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test setting is enabled.
+** not reachable from ordinary SQL passed into sqlite3_prepare().
 */
 static void renameColumnFunc(
  sqlite3_context *context,
@@ -1595,9 +1590,7 @@ static void renameColumnFunc(

 renameColumnFunc_done:
  if( rc!=SQLITE_OK ){
-    if( rc==SQLITE_ERROR && sqlite3WritableSchema(db) ){
-      sqlite3_result_value(context, argv[0]);
-    }else if( sParse.zErrMsg ){
+    if( sParse.zErrMsg ){
      renameColumnParseError(context, "", argv[1], argv[2], &sParse);
    }else{
      sqlite3_result_error_code(context, rc);
@@ -1796,9 +1789,7 @@ static void renameTableFunc(
      rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote);
    }
    if( rc!=SQLITE_OK ){
-      if( rc==SQLITE_ERROR && sqlite3WritableSchema(db) ){
-        sqlite3_result_value(context, argv[3]);
-      }else if( sParse.zErrMsg ){
+      if( sParse.zErrMsg ){
        renameColumnParseError(context, "", argv[1], argv[2], &sParse);
      }else{
        sqlite3_result_error_code(context, rc);
@@ -1823,10 +1814,10 @@ static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
  return WRC_Continue;
 }

-/* SQL function: sqlite_rename_quotefix(DB,SQL)
-**
-** Rewrite the DDL statement "SQL" so that any string literals that use
-** double-quotes use single quotes instead.
+/*
+** The implementation of an SQL scalar function that rewrites DDL statements
+** so that any string literals that use double-quotes are modified so that
+** they use single quotes.
 **
 ** Two arguments must be passed:
 **
@@ -1845,10 +1836,6 @@ static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
 ** returns the string:
 ** 
 **   CREATE VIEW v1 AS SELECT "a", 'string' FROM t1
-**
-** If there is a error in the input SQL, then raise an error, except
-** if PRAGMA writable_schema=ON, then just return the input string
-** unmodified following an error.
 */
 static void renameQuotefixFunc(
  sqlite3_context *context,
@@ -1923,11 +1910,7 @@ static void renameQuotefixFunc(
      renameTokenFree(db, sCtx.pList);
    }
    if( rc!=SQLITE_OK ){
-      if( sqlite3WritableSchema(db) && rc==SQLITE_ERROR ){
-        sqlite3_result_value(context, argv[1]);
-      }else{
-        sqlite3_result_error_code(context, rc);
-      }
+      sqlite3_result_error_code(context, rc);
    }
    renameParseCleanup(&sParse);
  }
@@ -1939,8 +1922,7 @@ static void renameQuotefixFunc(
  sqlite3BtreeLeaveAll(db);
 }

-/* Function:  sqlite_rename_test(DB,SQL,TYPE,NAME,ISTEMP,WHEN,DQS)
-**
+/*
 ** An SQL user function that checks that there are no parse or symbol
 ** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement.
 ** After an ALTER TABLE .. RENAME operation is performed and the schema
@@ -1955,13 +1937,11 @@ static void renameQuotefixFunc(
 **   5: "when" part of error message.
 **   6: True to disable the DQS quirk when parsing SQL.
 **
-** The return value is computed as follows:
+** Unless it finds an error, this function normally returns NULL. However, it
+** returns integer value 1 if:
 **
-**   A. If an error is seen and not in PRAGMA writable_schema=ON mode,
-**      then raise the error.
-**   B. Else if a trigger is created and the the table that the trigger is
-**      attached to is in database zDb, then return 1.
-**   C. Otherwise return NULL.
+**   * the SQL argument creates a trigger, and
+**   * the table that the trigger is attached to is in database zDb.
 */
 static void renameTableTest(
  sqlite3_context *context,
@@ -2006,16 +1986,12 @@ static void renameTableTest(
        if( rc==SQLITE_OK ){
          int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema);
          int i2 = sqlite3FindDbName(db, zDb);
-          if( i1==i2 ){
-            /* Handle output case B */
-            sqlite3_result_int(context, 1);
-          }
+          if( i1==i2 ) sqlite3_result_int(context, 1);
        }
      }
    }

-    if( rc!=SQLITE_OK && zWhen && !sqlite3WritableSchema(db) ){
-      /* Output case A */
+    if( rc!=SQLITE_OK && zWhen ){
      renameColumnParseError(context, zWhen, argv[2], argv[3],&sParse);
    }
    renameParseCleanup(&sParse);
@@ -2131,7 +2107,7 @@ void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, const Token *pName){
  }
  iCol = sqlite3ColumnIndex(pTab, zCol);
  if( iCol<0 ){
-    sqlite3ErrorMsg(pParse, "no such column: \"%T\"", pName);
+    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zCol);
    goto exit_drop_column;
  }

@@ -1023,7 +1023,7 @@ static void analyzeOneTable(
    memcpy(pStat1->zName, "sqlite_stat1", 13);
    pStat1->nCol = 3;
    pStat1->iPKey = -1;
-    sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNAMIC);
+    sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNBLOB);
  }
 #endif

@@ -354,7 +354,7 @@ static void codeAttach(
  }

 #ifndef SQLITE_OMIT_AUTHORIZATION
-  if( ALWAYS(pAuthArg) ){
+  if( pAuthArg ){
    char *zAuthArg;
    if( pAuthArg->op==TK_STRING ){
      assert( !ExprHasProperty(pAuthArg, EP_IntValue) );
@@ -85,13 +85,14 @@ static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
  if( i==1 ){
    Parse sParse;
    int rc = 0;
-    sqlite3ParseObjectInit(&sParse,pDb);
+    memset(&sParse, 0, sizeof(sParse));
+    sParse.db = pDb;
    if( sqlite3OpenTempDatabase(&sParse) ){
      sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s", sParse.zErrMsg);
      rc = SQLITE_ERROR;
    }
    sqlite3DbFree(pErrorDb, sParse.zErrMsg);
-    sqlite3ParseObjectReset(&sParse);
+    sqlite3ParserReset(&sParse);
    if( rc ){
      return 0;
    }
@@ -1327,7 +1327,6 @@ static void btreeParseCell(
 ** the space used by the cell pointer.
 **
 ** cellSizePtrNoPayload()    =>   table internal nodes
-** cellSizePtrTableLeaf()    =>   table leaf nodes
 ** cellSizePtr()             =>   all index nodes & table leaf nodes
 */
 static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
@@ -1353,6 +1352,13 @@ static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
    }while( *(pIter)>=0x80 && pIter<pEnd );
  }
  pIter++;
+  if( pPage->intKey ){
+    /* pIter now points at the 64-bit integer key value, a variable length 
+    ** integer. The following block moves pIter to point at the first byte
+    ** past the end of the key value. */
+    pEnd = &pIter[9];
+    while( (*pIter++)&0x80 && pIter<pEnd );
+  }
  testcase( nSize==pPage->maxLocal );
  testcase( nSize==(u32)pPage->maxLocal+1 );
  if( nSize<=pPage->maxLocal ){
@@ -1392,58 +1398,6 @@ static u16 cellSizePtrNoPayload(MemPage *pPage, u8 *pCell){
  assert( debuginfo.nSize==(u16)(pIter - pCell) || CORRUPT_DB );
  return (u16)(pIter - pCell);
 }
-static u16 cellSizePtrTableLeaf(MemPage *pPage, u8 *pCell){
-  u8 *pIter = pCell;   /* For looping over bytes of pCell */
-  u8 *pEnd;            /* End mark for a varint */
-  u32 nSize;           /* Size value to return */
-
-#ifdef SQLITE_DEBUG
-  /* The value returned by this function should always be the same as
-  ** the (CellInfo.nSize) value found by doing a full parse of the
-  ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
-  ** this function verifies that this invariant is not violated. */
-  CellInfo debuginfo;
-  pPage->xParseCell(pPage, pCell, &debuginfo);
-#endif
-
-  nSize = *pIter;
-  if( nSize>=0x80 ){
-    pEnd = &pIter[8];
-    nSize &= 0x7f;
-    do{
-      nSize = (nSize<<7) | (*++pIter & 0x7f);
-    }while( *(pIter)>=0x80 && pIter<pEnd );
-  }
-  pIter++;
-  /* pIter now points at the 64-bit integer key value, a variable length 
-  ** integer. The following block moves pIter to point at the first byte
-  ** past the end of the key value. */
-  if( (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80
-   && (*pIter++)&0x80 ){ pIter++; }
-  testcase( nSize==pPage->maxLocal );
-  testcase( nSize==(u32)pPage->maxLocal+1 );
-  if( nSize<=pPage->maxLocal ){
-    nSize += (u32)(pIter - pCell);
-    if( nSize<4 ) nSize = 4;
-  }else{
-    int minLocal = pPage->minLocal;
-    nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
-    testcase( nSize==pPage->maxLocal );
-    testcase( nSize==(u32)pPage->maxLocal+1 );
-    if( nSize>pPage->maxLocal ){
-      nSize = minLocal;
-    }
-    nSize += 4 + (u16)(pIter - pCell);
-  }
-  assert( nSize==debuginfo.nSize || CORRUPT_DB );
-  return (u16)nSize;
-}


 #ifdef SQLITE_DEBUG
@@ -1632,8 +1586,7 @@ static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
  const int hdr = pPg->hdrOffset;            /* Offset to page header */
  u8 * const aData = pPg->aData;             /* Page data */
  int iAddr = hdr + 1;                       /* Address of ptr to pc */
-  u8 *pTmp = &aData[iAddr];                  /* Temporary ptr into aData[] */
-  int pc = get2byte(pTmp);                   /* Address of a free slot */
+  int pc = get2byte(&aData[iAddr]);          /* Address of a free slot */
  int x;                                     /* Excess size of the slot */
  int maxPC = pPg->pBt->usableSize - nByte;  /* Max address for a usable slot */
  int size;                                  /* Size of the free slot */
@@ -1643,8 +1596,7 @@ static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
    /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each
    ** freeblock form a big-endian integer which is the size of the freeblock
    ** in bytes, including the 4-byte header. */
-    pTmp = &aData[pc+2];
-    size = get2byte(pTmp);
+    size = get2byte(&aData[pc+2]);
    if( (x = size - nByte)>=0 ){
      testcase( x==4 );
      testcase( x==3 );
@@ -1669,8 +1621,7 @@ static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
      return &aData[pc + x];
    }
    iAddr = pc;
-    pTmp = &aData[pc];
-    pc = get2byte(pTmp);
+    pc = get2byte(&aData[pc]);
    if( pc<=iAddr+size ){
      if( pc ){
        /* The next slot in the chain is not past the end of the current slot */
@@ -1704,7 +1655,6 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
  u8 * const data = pPage->aData;      /* Local cache of pPage->aData */
  int top;                             /* First byte of cell content area */
  int rc = SQLITE_OK;                  /* Integer return code */
-  u8 *pTmp;                            /* Temp ptr into data[] */
  int gap;        /* First byte of gap between cell pointers and cell content */
  
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
@@ -1723,8 +1673,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
  ** then the cell content offset of an empty page wants to be 65536.
  ** However, that integer is too large to be stored in a 2-byte unsigned
  ** integer, so a value of 0 is used in its place. */
-  pTmp = &data[hdr+5];
-  top = get2byte(pTmp);
+  top = get2byte(&data[hdr+5]);
  assert( top<=(int)pPage->pBt->usableSize ); /* by btreeComputeFreeSpace() */
  if( gap>top ){
    if( top==0 && pPage->pBt->usableSize==65536 ){
@@ -1806,7 +1755,6 @@ static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){
  u16 x;                                /* Offset to cell content area */
  u32 iEnd = iStart + iSize;            /* First byte past the iStart buffer */
  unsigned char *data = pPage->aData;   /* Page content */
-  u8 *pTmp;                             /* Temporary ptr into data[] */

  assert( pPage->pBt!=0 );
  assert( sqlite3PagerIswriteable(pPage->pDbPage) );
@@ -1834,7 +1782,7 @@ static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){
    if( iFreeBlk>pPage->pBt->usableSize-4 ){ /* TH3: corrupt081.100 */
      return SQLITE_CORRUPT_PAGE(pPage);
    }
-    assert( iFreeBlk>iPtr || iFreeBlk==0 || CORRUPT_DB );
+    assert( iFreeBlk>iPtr || iFreeBlk==0 );
  
    /* At this point:
    **    iFreeBlk:   First freeblock after iStart, or zero if none
@@ -1869,8 +1817,7 @@ static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){
    if( nFrag>data[hdr+7] ) return SQLITE_CORRUPT_PAGE(pPage);
    data[hdr+7] -= nFrag;
  }
-  pTmp = &data[hdr+5];
-  x = get2byte(pTmp);
+  x = get2byte(&data[hdr+5]);
  if( iStart<=x ){
    /* The new freeblock is at the beginning of the cell content area,
    ** so just extend the cell content area rather than create another
@@ -1926,7 +1873,6 @@ static int decodeFlags(MemPage *pPage, int flagByte){
    pPage->intKey = 1;
    if( pPage->leaf ){
      pPage->intKeyLeaf = 1;
-      pPage->xCellSize = cellSizePtrTableLeaf;
      pPage->xParseCell = btreeParseCellPtr;
    }else{
      pPage->intKeyLeaf = 0;
@@ -2303,9 +2249,7 @@ getAndInitPage_error1:
    pCur->pPage = pCur->apPage[pCur->iPage];
  }
  testcase( pgno==0 );
-  assert( pgno!=0 || rc==SQLITE_CORRUPT 
-                  || rc==SQLITE_IOERR_NOMEM
-                  || rc==SQLITE_NOMEM );
+  assert( pgno!=0 || rc==SQLITE_CORRUPT );
  return rc;
 }

@@ -6467,7 +6411,7 @@ static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
  assert( CORRUPT_DB || iPage>1 );
  assert( !pMemPage || pMemPage->pgno==iPage );

-  if( iPage<2 || iPage>pBt->nPage ){
+  if( NEVER(iPage<2) || iPage>pBt->nPage ){
    return SQLITE_CORRUPT_BKPT;
  }
  if( pMemPage ){
@@ -6902,12 +6846,6 @@ static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
  assert( pPage->pBt->usableSize > (u32)(ptr-data) );
  pc = get2byte(ptr);
  hdr = pPage->hdrOffset;
-#if 0  /* Not required.  Omit for efficiency */
-  if( pc<hdr+pPage->nCell*2 ){
-    *pRC = SQLITE_CORRUPT_BKPT;
-    return;
-  }
-#endif
  testcase( pc==(u32)get2byte(&data[hdr+5]) );
  testcase( pc+sz==pPage->pBt->usableSize );
  if( pc+sz > pPage->pBt->usableSize ){
@@ -9359,7 +9297,7 @@ int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
  bPreserve = (flags & BTREE_SAVEPOSITION)!=0;
  if( bPreserve ){
    if( !pPage->leaf 
-     || (pPage->nFree+pPage->xCellSize(pPage,pCell)+2)>(int)(pBt->usableSize*2/3)
+     || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3)
     || pPage->nCell==1  /* See dbfuzz001.test for a test case */
    ){
      /* A b-tree rebalance will be required after deleting this entry.
@@ -9678,7 +9616,7 @@ static int clearDatabasePage(
  rc = getAndInitPage(pBt, pgno, &pPage, 0, 0);
  if( rc ) return rc;
  if( (pBt->openFlags & BTREE_SINGLE)==0 
-   && sqlite3PagerPageRefcount(pPage->pDbPage) != (1 + (pgno==1))
+   && sqlite3PagerPageRefcount(pPage->pDbPage)!=1
  ){
    rc = SQLITE_CORRUPT_BKPT;
    goto cleardatabasepage_out;
@@ -598,7 +598,7 @@ struct BtCursor {
 /* 
 ** The database page the PENDING_BYTE occupies. This page is never used.
 */
-#define PENDING_BYTE_PAGE(pBt)  ((Pgno)((PENDING_BYTE/((pBt)->pageSize))+1))
+# define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)

 /*
 ** These macros define the location of the pointer-map entry for a 
@@ -143,13 +143,11 @@ void sqlite3FinishCoding(Parse *pParse){

  assert( pParse->pToplevel==0 );
  db = pParse->db;
-  assert( db->pParse==pParse );
  if( pParse->nested ) return;
-  if( pParse->nErr ){
-    if( db->mallocFailed ) pParse->rc = SQLITE_NOMEM;
+  if( db->mallocFailed || pParse->nErr ){
+    if( pParse->rc==SQLITE_OK ) pParse->rc = SQLITE_ERROR;
    return;
  }
-  assert( db->mallocFailed==0 );

  /* Begin by generating some termination code at the end of the
  ** vdbe program
@@ -282,9 +280,7 @@ void sqlite3FinishCoding(Parse *pParse){

  /* Get the VDBE program ready for execution
  */
-  assert( v!=0 || pParse->nErr );
-  assert( db->mallocFailed==0 || pParse->nErr );
-  if( pParse->nErr==0 ){
+  if( v && pParse->nErr==0 && !db->mallocFailed ){
    /* A minimum of one cursor is required if autoincrement is used
    *  See ticket [a696379c1f08866] */
    assert( pParse->pAinc==0 || pParse->nTab>0 );
@@ -333,8 +329,6 @@ void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
  memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
  db->mDbFlags |= DBFLAG_PreferBuiltin;
  sqlite3RunParser(pParse, zSql);
-  sqlite3DbFree(db, pParse->zErrMsg);
-  pParse->zErrMsg = 0;
  db->mDbFlags = savedDbFlags;
  sqlite3DbFree(db, zSql);
  memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
@@ -1295,8 +1289,7 @@ void sqlite3StartTable(
    pTable = sqlite3FindTable(db, zName, zDb);
    if( pTable ){
      if( !noErr ){
-        sqlite3ErrorMsg(pParse, "%s %T already exists",
-                        (IsView(pTable)? "view" : "table"), pName);
+        sqlite3ErrorMsg(pParse, "table %T already exists", pName);
      }else{
        assert( !db->init.busy || CORRUPT_DB );
        sqlite3CodeVerifySchema(pParse, iDb);
@@ -2391,11 +2384,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
    pTab->iPKey = -1;
    sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
                       SQLITE_IDXTYPE_PRIMARYKEY);
-    if( pParse->nErr ){
+    if( db->mallocFailed || pParse->nErr ){
      pTab->tabFlags &= ~TF_WithoutRowid;
      return;
    }
-    assert( db->mallocFailed==0 );
    pPk = sqlite3PrimaryKeyIndex(pTab);
    assert( pPk->nKeyCol==1 );
  }else{
@@ -3136,10 +3128,10 @@ int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
      */
      sqlite3ColumnsFromExprList(pParse, pTable->pCheck, 
                                 &pTable->nCol, &pTable->aCol);
-      if( pParse->nErr==0
+      if( db->mallocFailed==0 
+       && pParse->nErr==0
       && pTable->nCol==pSel->pEList->nExpr
      ){
-        assert( db->mallocFailed==0 );
        sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel,
                                               SQLITE_AFF_NONE);
      }
@@ -3758,7 +3750,7 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
    tnum = pIndex->tnum;
  }
  pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
-  assert( pKey!=0 || pParse->nErr );
+  assert( pKey!=0 || db->mallocFailed || pParse->nErr );

  /* Open the sorter cursor if we are to use one. */
  iSorter = pParse->nTab++;
@@ -3922,11 +3914,9 @@ void sqlite3CreateIndex(
  char *zExtra = 0;                /* Extra space after the Index object */
  Index *pPk = 0;      /* PRIMARY KEY index for WITHOUT ROWID tables */

-  assert( db->pParse==pParse );
-  if( pParse->nErr ){
+  if( db->mallocFailed || pParse->nErr>0 ){
    goto exit_create_index;
  }
-  assert( db->mallocFailed==0 );
  if( IN_DECLARE_VTAB && idxType!=SQLITE_IDXTYPE_PRIMARYKEY ){
    goto exit_create_index;
  }
@@ -3990,6 +3980,7 @@ void sqlite3CreateIndex(
  pDb = &db->aDb[iDb];

  assert( pTab!=0 );
+  assert( pParse->nErr==0 );
  if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 
       && db->init.busy==0
       && pTblName!=0
@@ -4553,10 +4544,10 @@ void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
  sqlite3 *db = pParse->db;
  int iDb;

+  assert( pParse->nErr==0 );   /* Never called with prior errors */
  if( db->mallocFailed ){
    goto exit_drop_index;
  }
-  assert( pParse->nErr==0 );   /* Never called with prior non-OOM errors */
  assert( pName->nSrc==1 );
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    goto exit_drop_index;
@@ -503,10 +503,8 @@ static void clearYMD_HMS_TZ(DateTime *p){
 ** is available.  This routine returns 0 on success and
 ** non-zero on any kind of error.
 **
-** If the sqlite3GlobalConfig.bLocaltimeFault variable is non-zero then this
-** routine will always fail.  If bLocaltimeFault is nonzero and
-** sqlite3GlobalConfig.xAltLocaltime is not NULL, then xAltLocaltime() is
-** invoked in place of the OS-defined localtime() function.
+** If the sqlite3GlobalConfig.bLocaltimeFault variable is true then this
+** routine will always fail.
 **
 ** EVIDENCE-OF: R-62172-00036 In this implementation, the standard C
 ** library function localtime_r() is used to assist in the calculation of
@@ -522,15 +520,7 @@ static int osLocaltime(time_t *t, struct tm *pTm){
  sqlite3_mutex_enter(mutex);
  pX = localtime(t);
 #ifndef SQLITE_UNTESTABLE
-  if( sqlite3GlobalConfig.bLocaltimeFault ){
-    if( sqlite3GlobalConfig.xAltLocaltime!=0
-     && 0==sqlite3GlobalConfig.xAltLocaltime((const void*)t,(void*)pTm)
-    ){
-      pX = pTm;
-    }else{
-      pX = 0;
-    }
-  }
+  if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0;
 #endif
  if( pX ) *pTm = *pX;
 #if SQLITE_THREADSAFE>0
@@ -539,13 +529,7 @@ static int osLocaltime(time_t *t, struct tm *pTm){
  rc = pX==0;
 #else
 #ifndef SQLITE_UNTESTABLE
-  if( sqlite3GlobalConfig.bLocaltimeFault ){
-    if( sqlite3GlobalConfig.xAltLocaltime!=0 ){
-      return sqlite3GlobalConfig.xAltLocaltime((const void*)t,(void*)pTm);
-    }else{
-      return 1;
-    }
-  }
+  if( sqlite3GlobalConfig.bLocaltimeFault ) return 1;
 #endif
 #if HAVE_LOCALTIME_R
  rc = localtime_r(t, pTm)==0;
@@ -560,56 +544,67 @@ static int osLocaltime(time_t *t, struct tm *pTm){

 #ifndef SQLITE_OMIT_LOCALTIME
 /*
-** Assuming the input DateTime is UTC, move it to its localtime equivalent.
+** Compute the difference (in milliseconds) between localtime and UTC
+** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs,
+** return this value and set *pRc to SQLITE_OK. 
+**
+** Or, if an error does occur, set *pRc to SQLITE_ERROR. The returned value
+** is undefined in this case.
 */
-static int toLocaltime(
-  DateTime *p,                   /* Date at which to calculate offset */
-  sqlite3_context *pCtx          /* Write error here if one occurs */
+static sqlite3_int64 localtimeOffset(
+  DateTime *p,                    /* Date at which to calculate offset */
+  sqlite3_context *pCtx,          /* Write error here if one occurs */
+  int *pRc                        /* OUT: Error code. SQLITE_OK or ERROR */
 ){
+  DateTime x, y;
  time_t t;
  struct tm sLocal;
-  int iYearDiff;

  /* Initialize the contents of sLocal to avoid a compiler warning. */
  memset(&sLocal, 0, sizeof(sLocal));

-  computeJD(p);
-  if( p->iJD<2108667600*(i64)100000 /* 1970-01-01 */
-   || p->iJD>2130141456*(i64)100000 /* 2038-01-18 */
-  ){
+  x = *p;
+  computeYMD_HMS(&x);
+  if( x.Y<1971 || x.Y>=2038 ){
    /* EVIDENCE-OF: R-55269-29598 The localtime_r() C function normally only
    ** works for years between 1970 and 2037. For dates outside this range,
    ** SQLite attempts to map the year into an equivalent year within this
    ** range, do the calculation, then map the year back.
    */
-    DateTime x = *p;
-    computeYMD_HMS(&x);
-    iYearDiff = (2000 + x.Y%4) - x.Y;
-    x.Y += iYearDiff;
-    x.validJD = 0;
-    computeJD(&x);
-    t = (time_t)(x.iJD/1000 -  21086676*(i64)10000);
-  }else{
-    iYearDiff = 0;
-    t = (time_t)(p->iJD/1000 -  21086676*(i64)10000);
+    x.Y = 2000;
+    x.M = 1;
+    x.D = 1;
+    x.h = 0;
+    x.m = 0;
+    x.s = 0.0;
+  } else {
+    int s = (int)(x.s + 0.5);
+    x.s = s;
  }
+  x.tz = 0;
+  x.validJD = 0;
+  computeJD(&x);
+  t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
  if( osLocaltime(&t, &sLocal) ){
    sqlite3_result_error(pCtx, "local time unavailable", -1);
-    return SQLITE_ERROR;
+    *pRc = SQLITE_ERROR;
+    return 0;
  }
-  p->Y = sLocal.tm_year + 1900 - iYearDiff;
-  p->M = sLocal.tm_mon + 1;
-  p->D = sLocal.tm_mday;
-  p->h = sLocal.tm_hour;
-  p->m = sLocal.tm_min;
-  p->s = sLocal.tm_sec;
-  p->validYMD = 1;
-  p->validHMS = 1;
-  p->validJD = 0;
-  p->rawS = 0;
-  p->validTZ = 0;
-  p->isError = 0;
-  return SQLITE_OK;
+  y.Y = sLocal.tm_year + 1900;
+  y.M = sLocal.tm_mon + 1;
+  y.D = sLocal.tm_mday;
+  y.h = sLocal.tm_hour;
+  y.m = sLocal.tm_min;
+  y.s = sLocal.tm_sec;
+  y.validYMD = 1;
+  y.validHMS = 1;
+  y.validJD = 0;
+  y.rawS = 0;
+  y.validTZ = 0;
+  y.isError = 0;
+  computeJD(&y);
+  *pRc = SQLITE_OK;
+  return y.iJD - x.iJD;
 }
 #endif /* SQLITE_OMIT_LOCALTIME */

@@ -663,8 +658,7 @@ static int parseModifier(
  sqlite3_context *pCtx,      /* Function context */
  const char *z,              /* The text of the modifier */
  int n,                      /* Length of zMod in bytes */
-  DateTime *p,                /* The date/time value to be modified */
-  int idx                     /* Parameter index of the modifier */
+  DateTime *p                 /* The date/time value to be modified */
 ){
  int rc = 1;
  double r;
@@ -677,13 +671,10 @@ static int parseModifier(
      ** a unix timestamp, depending on its magnitude.
      */
      if( sqlite3_stricmp(z, "auto")==0 ){
-        if( idx>1 ) return 1; /* IMP: R-33611-57934 */
        if( !p->rawS || p->validJD ){
          rc = 0;
          p->rawS = 0;
-        }else if( p->s>=-21086676*(i64)10000        /* -4713-11-24 12:00:00 */
-               && p->s<=(25340230*(i64)10000)+799   /*  9999-12-31 23:59:59 */
-        ){
+        }else if( p->s>=-210866760000 && p->s<=253402300799 ){
          r = p->s*1000.0 + 210866760000000.0;
          clearYMD_HMS_TZ(p);
          p->iJD = (sqlite3_int64)(r + 0.5);
@@ -704,7 +695,6 @@ static int parseModifier(
      ** SQLite (0..5373484.5) then the result will be NULL.
      */
      if( sqlite3_stricmp(z, "julianday")==0 ){
-        if( idx>1 ) return 1;  /* IMP: R-31176-64601 */
        if( p->validJD && p->rawS ){
          rc = 0;
          p->rawS = 0;
@@ -720,7 +710,9 @@ static int parseModifier(
      ** show local time.
      */
      if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){
-        rc = toLocaltime(p, pCtx);
+        computeJD(p);
+        p->iJD += localtimeOffset(p, pCtx, &rc);
+        clearYMD_HMS_TZ(p);
      }
      break;
    }
@@ -733,7 +725,6 @@ static int parseModifier(
      ** seconds since 1970.  Convert to a real julian day number.
      */
      if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){
-        if( idx>1 ) return 1;  /* IMP: R-49255-55373 */
        r = p->s*1000.0 + 210866760000000.0;
        if( r>=0.0 && r<464269060800000.0 ){
          clearYMD_HMS_TZ(p);
@@ -746,31 +737,18 @@ static int parseModifier(
 #ifndef SQLITE_OMIT_LOCALTIME
      else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){
        if( p->tzSet==0 ){
-          i64 iOrigJD;              /* Original localtime */
-          i64 iGuess;               /* Guess at the corresponding utc time */
-          int cnt = 0;              /* Safety to prevent infinite loop */
-          int iErr;                 /* Guess is off by this much */
-
+          sqlite3_int64 c1;
          computeJD(p);
-          iGuess = iOrigJD = p->iJD;
-          iErr = 0;
-          do{
-            DateTime new;
-            memset(&new, 0, sizeof(new));
-            iGuess -= iErr;
-            new.iJD = iGuess;
-            new.validJD = 1;
-            rc = toLocaltime(&new, pCtx);
-            if( rc ) return rc;
-            computeJD(&new);
-            iErr = new.iJD - iOrigJD;
-          }while( iErr && cnt++<3 );
-          memset(p, 0, sizeof(*p));
-          p->iJD = iGuess;
-          p->validJD = 1;
+          c1 = localtimeOffset(p, pCtx, &rc);
+          if( rc==SQLITE_OK ){
+            p->iJD -= c1;
+            clearYMD_HMS_TZ(p);
+            p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
+          }
          p->tzSet = 1;
+        }else{
+          rc = SQLITE_OK;
        }
-        rc = SQLITE_OK;
      }
 #endif
      break;
@@ -960,7 +938,7 @@ static int isDate(
  for(i=1; i<argc; i++){
    z = sqlite3_value_text(argv[i]);
    n = sqlite3_value_bytes(argv[i]);
-    if( z==0 || parseModifier(context, (char*)z, n, p, i) ) return 1;
+    if( z==0 || parseModifier(context, (char*)z, n, p) ) return 1;
  }
  computeJD(p);
  if( p->isError || !validJulianDay(p->iJD) ) return 1;
@@ -1020,38 +998,11 @@ static void datetimeFunc(
 ){
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
-    int Y, s;
-    char zBuf[24];
+    char zBuf[100];
    computeYMD_HMS(&x);
-    Y = x.Y;
-    if( Y<0 ) Y = -Y;
-    zBuf[1] = '0' + (Y/1000)%10;
-    zBuf[2] = '0' + (Y/100)%10;
-    zBuf[3] = '0' + (Y/10)%10;
-    zBuf[4] = '0' + (Y)%10;
-    zBuf[5] = '-';
-    zBuf[6] = '0' + (x.M/10)%10;
-    zBuf[7] = '0' + (x.M)%10;
-    zBuf[8] = '-';
-    zBuf[9] = '0' + (x.D/10)%10;
-    zBuf[10] = '0' + (x.D)%10;
-    zBuf[11] = ' ';
-    zBuf[12] = '0' + (x.h/10)%10;
-    zBuf[13] = '0' + (x.h)%10;
-    zBuf[14] = ':';
-    zBuf[15] = '0' + (x.m/10)%10;
-    zBuf[16] = '0' + (x.m)%10;
-    zBuf[17] = ':';
-    s = (int)x.s;
-    zBuf[18] = '0' + (s/10)%10;
-    zBuf[19] = '0' + (s)%10;
-    zBuf[20] = 0;
-    if( x.Y<0 ){
-      zBuf[0] = '-';
-      sqlite3_result_text(context, zBuf, 20, SQLITE_TRANSIENT);
-    }else{
-      sqlite3_result_text(context, &zBuf[1], 19, SQLITE_TRANSIENT);
-    }
+    sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
+                     x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
+    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  }
 }

@@ -1067,20 +1018,10 @@ static void timeFunc(
 ){
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
-    int s;
-    char zBuf[16];
+    char zBuf[100];
    computeHMS(&x);
-    zBuf[0] = '0' + (x.h/10)%10;
-    zBuf[1] = '0' + (x.h)%10;
-    zBuf[2] = ':';
-    zBuf[3] = '0' + (x.m/10)%10;
-    zBuf[4] = '0' + (x.m)%10;
-    zBuf[5] = ':';
-    s = (int)x.s;
-    zBuf[6] = '0' + (s/10)%10;
-    zBuf[7] = '0' + (s)%10;
-    zBuf[8] = 0;
-    sqlite3_result_text(context, zBuf, 8, SQLITE_TRANSIENT);
+    sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
+    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  }
 }

@@ -1096,28 +1037,10 @@ static void dateFunc(
 ){
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
-    int Y;
-    char zBuf[16];
+    char zBuf[100];
    computeYMD(&x);
-    Y = x.Y;
-    if( Y<0 ) Y = -Y;
-    zBuf[1] = '0' + (Y/1000)%10;
-    zBuf[2] = '0' + (Y/100)%10;
-    zBuf[3] = '0' + (Y/10)%10;
-    zBuf[4] = '0' + (Y)%10;
-    zBuf[5] = '-';
-    zBuf[6] = '0' + (x.M/10)%10;
-    zBuf[7] = '0' + (x.M)%10;
-    zBuf[8] = '-';
-    zBuf[9] = '0' + (x.D/10)%10;
-    zBuf[10] = '0' + (x.D)%10;
-    zBuf[11] = 0;
-    if( x.Y<0 ){
-      zBuf[0] = '-';
-      sqlite3_result_text(context, zBuf, 11, SQLITE_TRANSIENT);
-    }else{
-      sqlite3_result_text(context, &zBuf[1], 10, SQLITE_TRANSIENT);
-    }
+    sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
+    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  }
 }

@@ -293,11 +293,9 @@ void sqlite3DeleteFrom(

  memset(&sContext, 0, sizeof(sContext));
  db = pParse->db;
-  assert( db->pParse==pParse );
-  if( pParse->nErr ){
+  if( pParse->nErr || db->mallocFailed ){
    goto delete_from_cleanup;
  }
-  assert( db->mallocFailed==0 );
  assert( pTabList->nSrc==1 );


@@ -478,7 +476,7 @@ void sqlite3DeleteFrom(
    **  ONEPASS_SINGLE: One-pass approach - at most one row deleted.
    **  ONEPASS_MULTI:  One-pass approach - any number of rows may be deleted.
    */
-    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,0,wcf,iTabCur+1);
+    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, wcf, iTabCur+1);
    if( pWInfo==0 ) goto delete_from_cleanup;
    eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
    assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
@@ -769,8 +769,9 @@ static void heightOfSelect(const Select *pSelect, int *pnHeight){
 ** if appropriate.
 */
 static void exprSetHeight(Expr *p){
-  int nHeight = p->pLeft ? p->pLeft->nHeight : 0;
-  if( p->pRight && p->pRight->nHeight>nHeight ) nHeight = p->pRight->nHeight;
+  int nHeight = 0;
+  heightOfExpr(p->pLeft, &nHeight);
+  heightOfExpr(p->pRight, &nHeight);
  if( ExprUseXSelect(p) ){
    heightOfSelect(p->x.pSelect, &nHeight);
  }else if( p->x.pList ){
@@ -1069,7 +1070,6 @@ Expr *sqlite3ExprFunction(
    sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
    return 0;
  }
-  pNew->w.iOfst = (int)(pToken->z - pParse->zTail);
  if( pList 
   && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG]
   && !pParse->nested
@@ -1113,7 +1113,7 @@ void sqlite3ExprFunctionUsable(
      **         SQLITE_DBCONFIG_TRUSTED_SCHEMA is off (meaning
      **         that the schema is possibly tainted).
      */
-      sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr);
+      sqlite3ErrorMsg(pParse, "unsafe use of %s()", pDef->zName);
    }
  }
 }
@@ -1169,7 +1169,6 @@ void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
      if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
        sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
            db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
-        sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
        return;
      }
      x = (ynVar)i;
@@ -1197,7 +1196,6 @@ void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
  pExpr->iColumn = x;
  if( x>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
    sqlite3ErrorMsg(pParse, "too many SQL variables");
-    sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
  }
 }

@@ -2805,7 +2803,8 @@ int sqlite3FindInIndex(
            CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
            int j;
  
-            assert( pReq!=0 || pRhs->iColumn==XN_ROWID || pParse->nErr );
+            assert( pReq!=0 || pRhs->iColumn==XN_ROWID 
+                   || pParse->nErr || db->mallocFailed );
            for(j=0; j<nExpr; j++){
              if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue;
              assert( pIdx->azColl[j] );
@@ -3281,8 +3280,10 @@ int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
  }
  pSel->iLimit = 0;
  if( sqlite3Select(pParse, pSel, &dest) ){
-    pExpr->op2 = pExpr->op;
-    pExpr->op = TK_ERROR;
+    if( pParse->nErr ){
+      pExpr->op2 = pExpr->op;
+      pExpr->op = TK_ERROR;
+    }
    return 0;
  }
  pExpr->iTable = rReg = dest.iSDParm;
@@ -3499,9 +3500,10 @@ static void sqlite3ExprCodeIN(
  }else{
    destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse);
  }
+  if( pParse->nErr ) goto sqlite3ExprCodeIN_finished;
  for(i=0; i<nVector; i++){
    Expr *p = sqlite3VectorFieldSubexpr(pExpr->pLeft, i);
-    if( pParse->nErr ) goto sqlite3ExprCodeIN_oom_error;
+    if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
    if( sqlite3ExprCanBeNull(p) ){
      sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2);
      VdbeCoverage(v);
@@ -3639,12 +3641,11 @@ static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
    c = sqlite3DecOrHexToI64(z, &value);
    if( (c==3 && !negFlag) || (c==2) || (negFlag && value==SMALLEST_INT64)){
 #ifdef SQLITE_OMIT_FLOATING_POINT
-      sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
+      sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
 #else
 #ifndef SQLITE_OMIT_HEX_INTEGER
      if( sqlite3_strnicmp(z,"0x",2)==0 ){
-        sqlite3ErrorMsg(pParse, "hex literal too big: %s%#T",
-                        negFlag?"-":"",pExpr);
+        sqlite3ErrorMsg(pParse, "hex literal too big: %s%s", negFlag?"-":"",z);
      }else
 #endif
      {
@@ -4320,7 +4321,7 @@ expr_code_doover:
       || NEVER(pExpr->iAgg>=pInfo->nFunc)
      ){
        assert( !ExprHasProperty(pExpr, EP_IntValue) );
-        sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);
+        sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
      }else{
        return pInfo->aFunc[pExpr->iAgg].iMem;
      }
@@ -4361,7 +4362,7 @@ expr_code_doover:
      }
 #endif
      if( pDef==0 || pDef->xFinalize!=0 ){
-        sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr);
+        sqlite3ErrorMsg(pParse, "unknown function: %s()", zId);
        break;
      }
      if( pDef->funcFlags & SQLITE_FUNC_INLINE ){
@@ -651,7 +651,7 @@ static void fkScanChildren(
  ** clause. For each row found, increment either the deferred or immediate
  ** foreign key constraint counter. */
  if( pParse->nErr==0 ){
-    pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0, 0);
+    pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0);
    sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
    if( pWInfo ){
      sqlite3WhereEnd(pWInfo);
@@ -106,7 +106,6 @@ static void subtypeFunc(
  int argc,
  sqlite3_value **argv
 ){
-  UNUSED_PARAMETER(argc);
  sqlite3_result_int(context, sqlite3_value_subtype(argv[0]));
 }

@@ -1120,9 +1119,8 @@ static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
  sqlite3QuoteValue(&str,argv[0]);
  sqlite3_result_text(context, sqlite3StrAccumFinish(&str), str.nChar,
                      SQLITE_DYNAMIC);
-  if( str.accError!=SQLITE_OK ){
-    sqlite3_result_null(context);
-    sqlite3_result_error_code(context, str.accError);
+  if( str.accError==SQLITE_NOMEM ){
+    sqlite3_result_error_nomem(context);
  }
 }

@@ -286,7 +286,6 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = {
   0,                         /* xTestCallback */
 #endif
   0,                         /* bLocaltimeFault */
-   0,                         /* xAltLocaltime */
   0x7ffffffe,                /* iOnceResetThreshold */
   SQLITE_DEFAULT_SORTERREF_SIZE,   /* szSorterRef */
   0,                         /* iPrngSeed */
@@ -715,11 +715,9 @@ void sqlite3Insert(
 #endif

  db = pParse->db;
-  assert( db->pParse==pParse );
-  if( pParse->nErr ){
+  if( pParse->nErr || db->mallocFailed ){
    goto insert_cleanup;
  }
-  assert( db->mallocFailed==0 );
  dest.iSDParm = 0;  /* Suppress a harmless compiler warning */

  /* If the Select object is really just a simple VALUES() list with a
@@ -895,9 +893,7 @@ void sqlite3Insert(
    dest.nSdst = pTab->nCol;
    rc = sqlite3Select(pParse, pSelect, &dest);
    regFromSelect = dest.iSdst;
-    assert( db->pParse==pParse );
-    if( rc || pParse->nErr ) goto insert_cleanup;
-    assert( db->mallocFailed==0 );
+    if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup;
    sqlite3VdbeEndCoroutine(v, regYield);
    sqlite3VdbeJumpHere(v, addrTop - 1);                       /* label B: */
    assert( pSelect->pEList );
@@ -2666,7 +2666,7 @@ int sqlite3JsonTableFunctions(sqlite3 *db){
    { "json_each",            &jsonEachModule               },
    { "json_tree",            &jsonTreeModule               },
  };
-  unsigned int i;
+  int i;
  for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){
    rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
  }
@@ -487,11 +487,6 @@ static const sqlite3_api_routines sqlite3Apis = {
  sqlite3_autovacuum_pages,
  /* Version 3.38.0 and later */
  sqlite3_error_offset,
-  sqlite3_vtab_rhs_value,
-  sqlite3_vtab_distinct,
-  sqlite3_vtab_in,
-  sqlite3_vtab_in_first,
-  sqlite3_vtab_in_next
 };

 /* True if x is the directory separator character
@@ -4029,16 +4029,12 @@ int sqlite3_test_control(int op, ...){
    ** sqlite3_test_control().
    */
    case SQLITE_TESTCTRL_FAULT_INSTALL: {
-      /* A bug in MSVC prevents it from understanding pointers to functions
-      ** types in the second argument to va_arg().  Work around the problem
-      ** using a typedef.
-      ** http://support.microsoft.com/kb/47961  <-- dead hyperlink
-      ** Search at http://web.archive.org/ to find the 2015-03-16 archive
-      ** of the link above to see the original text.
+      /* MSVC is picky about pulling func ptrs from va lists.
+      ** http://support.microsoft.com/kb/47961
      ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
      */
-      typedef int(*sqlite3FaultFuncType)(int);
-      sqlite3GlobalConfig.xTestCallback = va_arg(ap, sqlite3FaultFuncType);
+      typedef int(*TESTCALLBACKFUNC_t)(int);
+      sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t);
      rc = sqlite3FaultSim(0);
      break;
    }
@@ -4165,27 +4161,13 @@ int sqlite3_test_control(int op, ...){
      break;
    }

-    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, onoff, xAlt);
+    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
    **
-    ** If parameter onoff is 1, subsequent calls to localtime() fail.
-    ** If 2, then invoke xAlt() instead of localtime().  If 0, normal
-    ** processing.
-    **
-    ** xAlt arguments are void pointers, but they really want to be:
-    **
-    **    int xAlt(const time_t*, struct tm*);
-    **
-    ** xAlt should write results in to struct tm object of its 2nd argument
-    ** and return zero on success, or return non-zero on failure.
+    ** If parameter onoff is non-zero, subsequent calls to localtime()
+    ** and its variants fail. If onoff is zero, undo this setting.
    */
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
-      if( sqlite3GlobalConfig.bLocaltimeFault==2 ){
-        typedef int(*sqlite3LocaltimeType)(const void*,void*);
-        sqlite3GlobalConfig.xAltLocaltime = va_arg(ap, sqlite3LocaltimeType);
-      }else{
-        sqlite3GlobalConfig.xAltLocaltime = 0;
-      }
      break;
    }

@@ -759,15 +759,8 @@ void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){
 ** has happened.  This routine will set db->mallocFailed, and also
 ** temporarily disable the lookaside memory allocator and interrupt
 ** any running VDBEs.
-**
-** Always return a NULL pointer so that this routine can be invoked using
-**
-**      return sqlite3OomFault(db);
-**
-** and thereby avoid unnecessary stack frame allocations for the overwhelmingly
-** common case where no OOM occurs.
 */
-void *sqlite3OomFault(sqlite3 *db){
+void sqlite3OomFault(sqlite3 *db){
  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
    db->mallocFailed = 1;
    if( db->nVdbeExec>0 ){
@@ -775,11 +768,9 @@ void *sqlite3OomFault(sqlite3 *db){
    }
    DisableLookaside;
    if( db->pParse ){
-      sqlite3ErrorMsg(db->pParse, "out of memory");
      db->pParse->rc = SQLITE_NOMEM_BKPT;
    }
  }
-  return 0;
 }

 /*
@@ -178,9 +178,6 @@ static int memjrnlCreateFile(MemJournal *p){
 }


-/* Forward reference */
-static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size);
-
 /*
 ** Write data to the file.
 */
@@ -210,21 +207,23 @@ static int memjrnlWrite(
    ** access writes are not required. The only exception to this is when
    ** the in-memory journal is being used by a connection using the
    ** atomic-write optimization. In this case the first 28 bytes of the
-    ** journal file may be written as part of committing the transaction. */
-    assert( iOfst<=p->endpoint.iOffset );
-    if( iOfst>0 && iOfst!=p->endpoint.iOffset ){
-      memjrnlTruncate(pJfd, iOfst);
-    }
+    ** journal file may be written as part of committing the transaction. */ 
+    assert( iOfst==p->endpoint.iOffset || iOfst==0 );
+#if defined(SQLITE_ENABLE_ATOMIC_WRITE) \
+ || defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
    if( iOfst==0 && p->pFirst ){
      assert( p->nChunkSize>iAmt );
      memcpy((u8*)p->pFirst->zChunk, zBuf, iAmt);
-    }else{
+    }else
+#else
+    assert( iOfst>0 || p->pFirst==0 );
+#endif
+    {
      while( nWrite>0 ){
        FileChunk *pChunk = p->endpoint.pChunk;
        int iChunkOffset = (int)(p->endpoint.iOffset%p->nChunkSize);
        int iSpace = MIN(nWrite, p->nChunkSize - iChunkOffset);

-        assert( pChunk!=0 || iChunkOffset==0 );
        if( iChunkOffset==0 ){
          /* New chunk is required to extend the file. */
          FileChunk *pNew = sqlite3_malloc(fileChunkSize(p->nChunkSize));
@@ -239,11 +238,10 @@ static int memjrnlWrite(
            assert( !p->pFirst );
            p->pFirst = pNew;
          }
-          pChunk = p->endpoint.pChunk = pNew;
+          p->endpoint.pChunk = pNew;
        }

-        assert( pChunk!=0 );
-        memcpy((u8*)pChunk->zChunk + iChunkOffset, zWrite, iSpace);
+        memcpy((u8*)p->endpoint.pChunk->zChunk + iChunkOffset, zWrite, iSpace);
        zWrite += iSpace;
        nWrite -= iSpace;
        p->endpoint.iOffset += iSpace;
@@ -681,7 +681,6 @@ struct Pager {
  u32 vfsFlags;               /* Flags for sqlite3_vfs.xOpen() */
  u32 sectorSize;             /* Assumed sector size during rollback */
  Pgno mxPgno;                /* Maximum allowed size of the database */
-  Pgno lckPgno;               /* Page number for the locking page */
  i64 pageSize;               /* Number of bytes in a page */
  i64 journalSizeLimit;       /* Size limit for persistent journal files */
  char *zFilename;            /* Name of the database file */
@@ -1668,7 +1667,7 @@ static int readJournalHdr(
 ** journal file descriptor is advanced to the next sector boundary before
 ** anything is written. The format is:
 **
-**   + 4 bytes: PAGER_SJ_PGNO.
+**   + 4 bytes: PAGER_MJ_PGNO.
 **   + N bytes: super-journal filename in utf-8.
 **   + 4 bytes: N (length of super-journal name in bytes, no nul-terminator).
 **   + 4 bytes: super-journal name checksum.
@@ -1716,7 +1715,7 @@ static int writeSuperJournal(Pager *pPager, const char *zSuper){
  /* Write the super-journal data to the end of the journal file. If
  ** an error occurs, return the error code to the caller.
  */
-  if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_SJ_PGNO(pPager))))
+  if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
   || (0 != (rc = sqlite3OsWrite(pPager->jfd, zSuper, nSuper, iHdrOff+4)))
   || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper, nSuper)))
   || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nSuper+4, cksum)))
@@ -2226,7 +2225,7 @@ static u32 pager_cksum(Pager *pPager, const u8 *aData){
 ** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
 ** two circumstances:
 ** 
-**   * If the record page-number is illegal (0 or PAGER_SJ_PGNO), or
+**   * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
 **   * If the record is being rolled back from the main journal file
 **     and the checksum field does not match the record content.
 **
@@ -2286,7 +2285,7 @@ static int pager_playback_one_page(
  ** it could cause invalid data to be written into the journal.  We need to
  ** detect this invalid data (with high probability) and ignore it.
  */
-  if( pgno==0 || pgno==PAGER_SJ_PGNO(pPager) ){
+  if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
    assert( !isSavepnt );
    return SQLITE_DONE;
  }
@@ -3741,7 +3740,6 @@ int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
      pPager->pTmpSpace = pNew;
      pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
      pPager->pageSize = pageSize;
-      pPager->lckPgno = (Pgno)(PENDING_BYTE/pageSize) + 1;
    }else{
      sqlite3PageFree(pNew);
    }
@@ -3947,7 +3945,7 @@ static void assertTruncateConstraint(Pager *pPager){
 ** then continue writing to the database.
 */
 void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
-  assert( pPager->dbSize>=nPage || CORRUPT_DB );
+  assert( pPager->dbSize>=nPage );
  assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
  pPager->dbSize = nPage;

@@ -5491,6 +5489,7 @@ static int getPageNormal(
  assert( assert_pager_state(pPager) );
  assert( pPager->hasHeldSharedLock==1 );

+  if( pgno==0 ) return SQLITE_CORRUPT_BKPT;
  pBase = sqlite3PcacheFetch(pPager->pPCache, pgno, 3);
  if( pBase==0 ){
    pPg = 0;
@@ -5510,7 +5509,7 @@ static int getPageNormal(
  if( pPg->pPager && !noContent ){
    /* In this case the pcache already contains an initialized copy of
    ** the page. Return without further ado.  */
-    assert( pgno!=PAGER_SJ_PGNO(pPager) );
+    assert( pgno!=PAGER_MJ_PGNO(pPager) );
    pPager->aStat[PAGER_STAT_HIT]++;
    return SQLITE_OK;

@@ -5518,10 +5517,10 @@ static int getPageNormal(
    /* The pager cache has created a new page. Its content needs to 
    ** be initialized. But first some error checks:
    **
-    ** (1) Never try to fetch the locking page
-    ** (2) Never try to fetch page 0, which does not exist
+    ** (*) obsolete.  Was: maximum page number is 2^31
+    ** (2) Never try to fetch the locking page
    */
-    if( pgno==PAGER_SJ_PGNO(pPager) || pgno==0 ){
+    if( pgno==PAGER_MJ_PGNO(pPager) ){
      rc = SQLITE_CORRUPT_BKPT;
      goto pager_acquire_err;
    }
@@ -5920,7 +5919,7 @@ static SQLITE_NOINLINE int pagerAddPageToRollbackJournal(PgHdr *pPg){
  /* We should never write to the journal file the page that
  ** contains the database locks.  The following assert verifies
  ** that we do not. */
-  assert( pPg->pgno!=PAGER_SJ_PGNO(pPager) );
+  assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );

  assert( pPager->journalHdr<=pPager->journalOff );
  pData2 = pPg->pData;
@@ -6099,7 +6098,7 @@ static SQLITE_NOINLINE int pagerWriteLargeSector(PgHdr *pPg){
    Pgno pg = pg1+ii;
    PgHdr *pPage;
    if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
-      if( pg!=PAGER_SJ_PGNO(pPager) ){
+      if( pg!=PAGER_MJ_PGNO(pPager) ){
        rc = sqlite3PagerGet(pPager, pg, &pPage, 0);
        if( rc==SQLITE_OK ){
          rc = pager_write(pPage);
@@ -6577,7 +6576,7 @@ int sqlite3PagerCommitPhaseOne(
      ** last page is never written out to disk, leaving the database file
      ** undersized. Fix this now if it is the case.  */
      if( pPager->dbSize>pPager->dbFileSize ){
-        Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_SJ_PGNO(pPager));
+        Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
        assert( pPager->eState==PAGER_WRITER_DBMOD );
        rc = pager_truncate(pPager, nNew);
        if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
@@ -7426,18 +7425,6 @@ int sqlite3PagerCheckpoint(
  int *pnCkpt                     /* OUT: Final number of checkpointed frames */
 ){
  int rc = SQLITE_OK;
-  if( pPager->pWal==0 && pPager->journalMode==PAGER_JOURNALMODE_WAL ){
-    /* This only happens when a database file is zero bytes in size opened and
-    ** then "PRAGMA journal_mode=WAL" is run and then sqlite3_wal_checkpoint()
-    ** is invoked without any intervening transactions.  We need to start
-    ** a transaction to initialize pWal.  The PRAGMA table_list statement is
-    ** used for this since it starts transactions on every database file,
-    ** including all ATTACHed databases.  This seems expensive for a single
-    ** sqlite3_wal_checkpoint() call, but it happens very rarely.
-    ** https://sqlite.org/forum/forumpost/fd0f19d229156939
-    */
-    sqlite3_exec(db, "PRAGMA table_list",0,0,0);
-  }
  if( pPager->pWal ){
    rc = sqlite3WalCheckpoint(pPager->pWal, db, eMode,
        (eMode==SQLITE_CHECKPOINT_PASSIVE ? 0 : pPager->xBusyHandler),
@@ -43,15 +43,14 @@ typedef struct Pager Pager;
 typedef struct PgHdr DbPage;

 /*
-** Page number PAGER_SJ_PGNO is never used in an SQLite database (it is
+** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
 ** reserved for working around a windows/posix incompatibility). It is
 ** used in the journal to signify that the remainder of the journal file 
 ** is devoted to storing a super-journal name - there are no more pages to
 ** roll back. See comments for function writeSuperJournal() in pager.c 
 ** for details.
 */
-#define PAGER_SJ_PGNO_COMPUTED(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
-#define PAGER_SJ_PGNO(x)          ((x)->lckPgno)
+#define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))

 /*
 ** Allowed values for the flags parameter to sqlite3PagerOpen().
@@ -659,7 +659,7 @@ selcollist(A) ::= sclp(A) scanpt STAR. {
 }
 selcollist(A) ::= sclp(A) scanpt nm(X) DOT STAR. {
  Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
-  Expr *pLeft = tokenExpr(pParse, TK_ID, X);
+  Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);
  Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
  A = sqlite3ExprListAppend(pParse,A, pDot);
 }
@@ -1025,7 +1025,10 @@ idlist(A) ::= nm(Y).

 %include {

-  /* Construct a new Expr object from a single token */
+  /* Construct a new Expr object from a single identifier.  Use the
+  ** new Expr to populate pOut.  Set the span of pOut to be the identifier
+  ** that created the expression.
+  */
  static Expr *tokenExpr(Parse *pParse, int op, Token t){
    Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
    if( p ){
@@ -1045,7 +1048,6 @@ idlist(A) ::= nm(Y).
      p->u.zToken = (char*)&p[1];
      memcpy(p->u.zToken, t.z, t.n);
      p->u.zToken[t.n] = 0;
-      p->w.iOfst = (int)(t.z - pParse->zTail);
      if( sqlite3Isquote(p->u.zToken[0]) ){
        sqlite3DequoteExpr(p);
      }
@@ -1066,17 +1068,22 @@ expr(A) ::= LP expr(X) RP. {A = X;}
 expr(A) ::= id(X).          {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/}
 expr(A) ::= JOIN_KW(X).     {A=tokenExpr(pParse,TK_ID,X); /*A-overwrites-X*/}
 expr(A) ::= nm(X) DOT nm(Y). {
-  Expr *temp1 = tokenExpr(pParse,TK_ID,X);
-  Expr *temp2 = tokenExpr(pParse,TK_ID,Y);
+  Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);
+  Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1);
+  if( IN_RENAME_OBJECT ){
+    sqlite3RenameTokenMap(pParse, (void*)temp2, &Y);
+    sqlite3RenameTokenMap(pParse, (void*)temp1, &X);
+  }
  A = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
 }
 expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). {
-  Expr *temp1 = tokenExpr(pParse,TK_ID,X);
-  Expr *temp2 = tokenExpr(pParse,TK_ID,Y);
-  Expr *temp3 = tokenExpr(pParse,TK_ID,Z);
+  Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1);
+  Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &Y, 1);
+  Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &Z, 1);
  Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
  if( IN_RENAME_OBJECT ){
-    sqlite3RenameTokenRemap(pParse, 0, temp1);
+    sqlite3RenameTokenMap(pParse, (void*)temp3, &Z);
+    sqlite3RenameTokenMap(pParse, (void*)temp2, &Y);
  }
  A = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
 }
@@ -1084,7 +1091,6 @@ term(A) ::= NULL|FLOAT|BLOB(X). {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/}
 term(A) ::= STRING(X).          {A=tokenExpr(pParse,@X,X); /*A-overwrites-X*/}
 term(A) ::= INTEGER(X). {
  A = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &X, 1);
-  if( A ) A->w.iOfst = (int)(X.z - pParse->zTail);
 }
 expr(A) ::= VARIABLE(X).     {
  if( !(X.z[0]=='#' && sqlite3Isdigit(X.z[1])) ){
@@ -1587,7 +1593,7 @@ expr(A) ::= RAISE LP IGNORE RP.  {
  }
 }
 expr(A) ::= RAISE LP raisetype(T) COMMA nm(Z) RP.  {
-  A = sqlite3ExprAlloc(pParse->db, TK_RAISE, &Z, 1);
+  A = sqlite3ExprAlloc(pParse->db, TK_RAISE, &Z, 1); 
  if( A ) {
    A->affExpr = (char)T;
  }
@@ -307,16 +307,15 @@ static void pragmaFunclistLine(
  int isBuiltin,         /* True if this is a built-in function */
  int showInternFuncs    /* True if showing internal functions */
 ){
-  u32 mask = 
-      SQLITE_DETERMINISTIC |
-      SQLITE_DIRECTONLY |
-      SQLITE_SUBTYPE |
-      SQLITE_INNOCUOUS |
-      SQLITE_FUNC_INTERNAL
-  ;
-  if( showInternFuncs ) mask = -1;
  for(; p; p=p->pNext){
    const char *zType;
+    static const u32 mask = 
+        SQLITE_DETERMINISTIC |
+        SQLITE_DIRECTONLY |
+        SQLITE_SUBTYPE |
+        SQLITE_INNOCUOUS |
+        SQLITE_FUNC_INTERNAL
+    ;
    static const char *azEnc[] = { 0, "utf8", "utf16le", "utf16be" };

    assert( SQLITE_FUNC_ENCMASK==0x3 );
@@ -1251,10 +1250,6 @@ void sqlite3Pragma(
              (void)sqlite3_finalize(pDummy);
              sqlite3DbFree(db, zSql);
            }
-            if( db->mallocFailed ){
-              sqlite3ErrorMsg(db->pParse, "out of memory");
-              db->pParse->rc = SQLITE_NOMEM_BKPT;
-            }
            pHash = &db->aDb[ii].pSchema->tblHash;
            break;
          }
@@ -251,7 +251,7 @@ static const PragmaName aPragmaName[] = {
 #if !defined(SQLITE_OMIT_SCHEMA_PRAGMAS)
 {/* zName:     */ "database_list",
  /* ePragTyp:  */ PragTyp_DATABASE_LIST,
-  /* ePragFlg:  */ PragFlg_Result0,
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result0,
  /* ColNames:  */ 47, 3,
  /* iArg:      */ 0 },
 #endif
@@ -568,10 +568,8 @@ int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
 /*
 ** Free all memory allocations in the pParse object
 */
-void sqlite3ParseObjectReset(Parse *pParse){
+void sqlite3ParserReset(Parse *pParse){
  sqlite3 *db = pParse->db;
-  assert( db!=0 );
-  assert( db->pParse==pParse );
  assert( pParse->nested==0 );
 #ifndef SQLITE_OMIT_SHARED_CACHE
  sqlite3DbFree(db, pParse->aTableLock);
@@ -586,12 +584,11 @@ void sqlite3ParseObjectReset(Parse *pParse){
  if( pParse->pConstExpr ){
    sqlite3ExprListDelete(db, pParse->pConstExpr);
  }
-  assert( db->lookaside.bDisable >= pParse->disableLookaside );
-  db->lookaside.bDisable -= pParse->disableLookaside;
-  db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue;
-  assert( pParse->db->pParse==pParse );
-  db->pParse = pParse->pOuterParse;
-  pParse->db = 0;
+  if( db ){
+    assert( db->lookaside.bDisable >= pParse->disableLookaside );
+    db->lookaside.bDisable -= pParse->disableLookaside;
+    db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue;
+  }
  pParse->disableLookaside = 0;
 }

@@ -604,7 +601,7 @@ void sqlite3ParseObjectReset(Parse *pParse){
 ** cost for this mechansim (an extra malloc), so it should not be used
 ** for common cleanups that happen on most calls.  But for less
 ** common cleanups, we save a single NULL-pointer comparison in
-** sqlite3ParseObjectReset(), which reduces the total CPU cycle count.
+** sqlite3ParserReset(), which reduces the total CPU cycle count.
 **
 ** If a memory allocation error occurs, then the cleanup happens immediately.
 ** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the
@@ -644,25 +641,6 @@ void *sqlite3ParserAddCleanup(
  return pPtr;
 }

-/*
-** Turn bulk memory into a valid Parse object and link that Parse object
-** into database connection db.
-**
-** Call sqlite3ParseObjectReset() to undo this operation.
-**
-** Caution:  Do not confuse this routine with sqlite3ParseObjectInit() which
-** is generated by Lemon.
-*/
-void sqlite3ParseObjectInit(Parse *pParse, sqlite3 *db){
-  memset(PARSE_HDR(pParse), 0, PARSE_HDR_SZ);
-  memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
-  assert( db->pParse!=pParse );
-  pParse->pOuterParse = db->pParse;
-  db->pParse = pParse;
-  pParse->db = db;
-  if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory");
-}
-
 /*
 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
 */
@@ -679,15 +657,11 @@ static int sqlite3Prepare(
  int i;                    /* Loop counter */
  Parse sParse;             /* Parsing context */

-  /* sqlite3ParseObjectInit(&sParse, db); // inlined for performance */
-  memset(PARSE_HDR(&sParse), 0, PARSE_HDR_SZ);
+  memset(&sParse, 0, PARSE_HDR_SZ);
  memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ);
-  sParse.pOuterParse = db->pParse;
-  db->pParse = &sParse;
-  sParse.db = db;
  sParse.pReprepare = pReprepare;
  assert( ppStmt && *ppStmt==0 );
-  if( db->mallocFailed ) sqlite3ErrorMsg(&sParse, "out of memory");
+  /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
  assert( sqlite3_mutex_held(db->mutex) );

  /* For a long-term use prepared statement avoid the use of
@@ -740,6 +714,7 @@ static int sqlite3Prepare(

  sqlite3VtabUnlockList(db);

+  sParse.db = db;
  if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
    char *zSqlCopy;
    int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
@@ -806,7 +781,7 @@ static int sqlite3Prepare(

 end_prepare:

-  sqlite3ParseObjectReset(&sParse);
+  sqlite3ParserReset(&sParse);
  return rc;
 }
 static int sqlite3LockAndPrepare(
@@ -849,22 +849,13 @@ void sqlite3_str_vappendf(
        goto adjust_width_for_utf8;
      }
      case etTOKEN: {
+        Token *pToken;
        if( (pAccum->printfFlags & SQLITE_PRINTF_INTERNAL)==0 ) return;
-        if( flag_alternateform ){
-          /* %#T means an Expr pointer that uses Expr.u.zToken */
-          Expr *pExpr = va_arg(ap,Expr*);
-          if( ALWAYS(pExpr) && ALWAYS(!ExprHasProperty(pExpr,EP_IntValue)) ){
-            sqlite3_str_appendall(pAccum, (const char*)pExpr->u.zToken);
-            sqlite3RecordErrorOffsetOfExpr(pAccum->db, pExpr);
-          }
-        }else{
-          /* %T means a Token pointer */
-          Token *pToken = va_arg(ap, Token*);
-          assert( bArgList==0 );
-          if( pToken && pToken->n ){
-            sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
-            sqlite3RecordErrorByteOffset(pAccum->db, pToken->z);
-          }
+        pToken = va_arg(ap, Token*);
+        assert( bArgList==0 );
+        if( pToken && pToken->n ){
+          sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
+          sqlite3RecordErrorByteOffset(pAccum->db, pToken->z);
        }
        length = width = 0;
        break;
@@ -943,18 +934,6 @@ void sqlite3RecordErrorByteOffset(sqlite3 *db, const char *z){
  }
 }

-/*
-** If pExpr has a byte offset for the start of a token, record that as
-** as the error offset.
-*/
-void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExpr){
-  while( pExpr && (ExprHasProperty(pExpr,EP_FromJoin) || pExpr->w.iOfst<=0) ){
-    pExpr = pExpr->pLeft;
-  }
-  if( pExpr==0 ) return;
-  db->errByteOffset = pExpr->w.iOfst;
-}
-
 /*
 ** Enlarge the memory allocation on a StrAccum object so that it is
 ** able to accept at least N more bytes of text.
@@ -620,7 +620,6 @@ static int lookupName(
    }else{
      sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
    }
-    sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
    pParse->checkSchema = 1;
    pTopNC->nNcErr++;
  }
@@ -729,8 +728,7 @@ static void notValidImpl(
   Parse *pParse,       /* Leave error message here */
   NameContext *pNC,    /* The name context */
   const char *zMsg,    /* Type of error */
-   Expr *pExpr,         /* Invalidate this expression on error */
-   Expr *pError         /* Associate error with this expression */
+   Expr *pExpr          /* Invalidate this expression on error */
 ){
  const char *zIn = "partial index WHERE clauses";
  if( pNC->ncFlags & NC_IdxExpr )      zIn = "index expressions";
@@ -742,11 +740,10 @@ static void notValidImpl(
 #endif
  sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
  if( pExpr ) pExpr->op = TK_NULL;
-  sqlite3RecordErrorOffsetOfExpr(pParse->db, pError);
 }
-#define sqlite3ResolveNotValid(P,N,M,X,E,R) \
+#define sqlite3ResolveNotValid(P,N,M,X,E) \
  assert( ((X)&~(NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol))==0 ); \
-  if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E,R);
+  if( ((N)->ncFlags & (X))!=0 ) notValidImpl(P,N,M,E);

 /*
 ** Expression p should encode a floating point value between 1.0 and 0.0.
@@ -881,7 +878,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
        testcase( pNC->ncFlags & NC_IdxExpr );
        testcase( pNC->ncFlags & NC_GenCol );
        sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
-                               NC_IdxExpr|NC_GenCol, 0, pExpr);
+                               NC_IdxExpr|NC_GenCol, 0);
        pRight = pExpr->pRight;
        if( pRight->op==TK_ID ){
          zDb = 0;
@@ -912,6 +909,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
      int no_such_func = 0;       /* True if no such function exists */
      int wrong_num_args = 0;     /* True if wrong number of arguments */
      int is_agg = 0;             /* True if is an aggregate function */
+      int nId;                    /* Number of characters in function name */
      const char *zId;            /* The function name. */
      FuncDef *pDef;              /* Information about the function */
      u8 enc = ENC(pParse->db);   /* The database encoding */
@@ -921,6 +919,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #endif
      assert( !ExprHasProperty(pExpr, EP_xIsSelect|EP_IntValue) );
      zId = pExpr->u.zToken;
+      nId = sqlite3Strlen30(zId);
      pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
      if( pDef==0 ){
        pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
@@ -937,8 +936,8 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
            pExpr->iTable = exprProbability(pList->a[1].pExpr);
            if( pExpr->iTable<0 ){
              sqlite3ErrorMsg(pParse,
-                "second argument to %#T() must be a "
-                "constant between 0.0 and 1.0", pExpr);
+                "second argument to likelihood() must be a "
+                "constant between 0.0 and 1.0");
              pNC->nNcErr++;
            }
          }else{
@@ -959,8 +958,8 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
          int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
          if( auth!=SQLITE_OK ){
            if( auth==SQLITE_DENY ){
-              sqlite3ErrorMsg(pParse, "not authorized to use function: %#T",
-                                      pExpr);
+              sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
+                                      pDef->zName);
              pNC->nNcErr++;
            }
            pExpr->op = TK_NULL;
@@ -983,7 +982,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
          ** in a CHECK constraint.  SQLServer, MySQL, and PostgreSQL all
          ** all this. */
          sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
-                                 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0, pExpr);
+                                 NC_IdxExpr|NC_PartIdx|NC_GenCol, 0);
        }else{
          assert( (NC_SelfRef & 0xff)==NC_SelfRef ); /* Must fit in 8 bits */
          pExpr->op2 = pNC->ncFlags & NC_SelfRef;
@@ -996,7 +995,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
          /* Internal-use-only functions are disallowed unless the
          ** SQL is being compiled using sqlite3NestedParse() or
          ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
-          ** used to activate internal functions for testing purposes */
+          ** used to activate internal functionsn for testing purposes */
          no_such_func = 1;
          pDef = 0;
        }else
@@ -1015,7 +1014,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
        );
        if( pDef && pDef->xValue==0 && pWin ){
          sqlite3ErrorMsg(pParse, 
-              "%#T() may not be used as a window function", pExpr
+              "%.*s() may not be used as a window function", nId, zId
          );
          pNC->nNcErr++;
        }else if( 
@@ -1029,13 +1028,13 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
          }else{
            zType = "aggregate";
          }
-          sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr);
+          sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
          pNC->nNcErr++;
          is_agg = 0;
        }
 #else
        if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
-          sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr);
+          sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
          pNC->nNcErr++;
          is_agg = 0;
        }
@@ -1045,18 +1044,18 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
                  && pParse->explain==0
 #endif
        ){
-          sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr);
+          sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
          pNC->nNcErr++;
        }else if( wrong_num_args ){
-          sqlite3ErrorMsg(pParse,"wrong number of arguments to function %#T()",
-               pExpr);
+          sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
+               nId, zId);
          pNC->nNcErr++;
        }
 #ifndef SQLITE_OMIT_WINDOWFUNC
        else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
          sqlite3ErrorMsg(pParse, 
-              "FILTER may not be used with non-aggregate %#T()",
-              pExpr
+              "FILTER may not be used with non-aggregate %.*s()", 
+              nId, zId
          );
          pNC->nNcErr++;
        }
@@ -1141,7 +1140,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
        testcase( pNC->ncFlags & NC_IdxExpr );
        testcase( pNC->ncFlags & NC_GenCol );
        if( pNC->ncFlags & NC_SelfRef ){
-          notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
+          notValidImpl(pParse, pNC, "subqueries", pExpr);
        }else{
          sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
        }
@@ -1159,7 +1158,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
      testcase( pNC->ncFlags & NC_IdxExpr );
      testcase( pNC->ncFlags & NC_GenCol );
      sqlite3ResolveNotValid(pParse, pNC, "parameters",
-               NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr, pExpr);
+               NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
      break;
    }
    case TK_IS:
@@ -1211,13 +1210,11 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
        testcase( pExpr->op==TK_ISNOT );
        testcase( pExpr->op==TK_BETWEEN );
        sqlite3ErrorMsg(pParse, "row value misused");
-        sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
      }
      break; 
    }
  }
-  assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
-  return pParse->nErr ? WRC_Abort : WRC_Continue;
+  return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
 }

 /*
@@ -1325,13 +1322,11 @@ static void resolveOutOfRangeError(
  Parse *pParse,         /* The error context into which to write the error */
  const char *zType,     /* "ORDER" or "GROUP" */
  int i,                 /* The index (1-based) of the term out of range */
-  int mx,                /* Largest permissible value of i */
-  Expr *pError           /* Associate the error with the expression */
+  int mx                 /* Largest permissible value of i */
 ){
  sqlite3ErrorMsg(pParse, 
    "%r %s BY term out of range - should be "
    "between 1 and %d", i, zType, mx);
-  sqlite3RecordErrorOffsetOfExpr(pParse->db, pError);
 }

 /*
@@ -1387,7 +1382,7 @@ static int resolveCompoundOrderBy(
      if( NEVER(pE==0) ) continue;
      if( sqlite3ExprIsInteger(pE, &iCol) ){
        if( iCol<=0 || iCol>pEList->nExpr ){
-          resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr, pE);
+          resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
          return 1;
        }
      }else{
@@ -1483,7 +1478,7 @@ int sqlite3ResolveOrderGroupBy(
  for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
    if( pItem->u.x.iOrderByCol ){
      if( pItem->u.x.iOrderByCol>pEList->nExpr ){
-        resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr, 0);
+        resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
        return 1;
      }
      resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
@@ -1575,7 +1570,7 @@ static int resolveOrderGroupBy(
      ** number so that sqlite3ResolveOrderGroupBy() will convert the
      ** order-by term to a copy of the result-set expression */
      if( iCol<1 || iCol>0xffff ){
-        resolveOutOfRangeError(pParse, zType, i+1, nResult, pE2);
+        resolveOutOfRangeError(pParse, zType, i+1, nResult);
        return 1;
      }
      pItem->u.x.iOrderByCol = (u16)iCol;
@@ -1633,7 +1628,7 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
  */
  if( (p->selFlags & SF_Expanded)==0 ){
    sqlite3SelectPrep(pParse, p, pOuterNC);
-    return pParse->nErr ? WRC_Abort : WRC_Prune;
+    return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
  }

  isCompound = p->pPrior!=0;
@@ -1681,8 +1676,7 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
        if( pItem->zName ) pParse->zAuthContext = pItem->zName;
        sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
        pParse->zAuthContext = zSavedContext;
-        if( pParse->nErr ) return WRC_Abort;
-        assert( db->mallocFailed==0 );
+        if( pParse->nErr || db->mallocFailed ) return WRC_Abort;

        /* If the number of references to the outer context changed when
        ** expressions in the sub-select were resolved, the sub-select
@@ -354,14 +354,14 @@ static void addWhereTerm(
    ExprSetProperty(pEq, EP_FromJoin);
    assert( !ExprHasProperty(pEq, EP_TokenOnly|EP_Reduced) );
    ExprSetVVAProperty(pEq, EP_NoReduce);
-    pEq->w.iRightJoinTable = pE2->iTable;
+    pEq->iRightJoinTable = pE2->iTable;
  }
  *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq);
 }

 /*
 ** Set the EP_FromJoin property on all terms of the given expression.
-** And set the Expr.w.iRightJoinTable to iTable for every term in the
+** And set the Expr.iRightJoinTable to iTable for every term in the
 ** expression.
 **
 ** The EP_FromJoin property is used on terms of an expression to tell
@@ -371,8 +371,8 @@ static void addWhereTerm(
 ** WHERE clause during join processing but we need to remember that they
 ** originated in the ON or USING clause.
 **
-** The Expr.w.iRightJoinTable tells the WHERE clause processing that the
-** expression depends on table w.iRightJoinTable even if that table is not
+** The Expr.iRightJoinTable tells the WHERE clause processing that the
+** expression depends on table iRightJoinTable even if that table is not
 ** explicitly mentioned in the expression.  That information is needed
 ** for cases like this:
 **
@@ -390,7 +390,7 @@ void sqlite3SetJoinExpr(Expr *p, int iTable){
    ExprSetProperty(p, EP_FromJoin);
    assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
    ExprSetVVAProperty(p, EP_NoReduce);
-    p->w.iRightJoinTable = iTable;
+    p->iRightJoinTable = iTable;
    if( p->op==TK_FUNCTION ){
      assert( ExprUseXList(p) );
      if( p->x.pList ){
@@ -406,7 +406,7 @@ void sqlite3SetJoinExpr(Expr *p, int iTable){
 }

 /* Undo the work of sqlite3SetJoinExpr(). In the expression p, convert every
-** term that is marked with EP_FromJoin and w.iRightJoinTable==iTable into
+** term that is marked with EP_FromJoin and iRightJoinTable==iTable into
 ** an ordinary term that omits the EP_FromJoin mark.
 **
 ** This happens when a LEFT JOIN is simplified into an ordinary JOIN.
@@ -414,7 +414,7 @@ void sqlite3SetJoinExpr(Expr *p, int iTable){
 static void unsetJoinExpr(Expr *p, int iTable){
  while( p ){
    if( ExprHasProperty(p, EP_FromJoin)
-     && (iTable<0 || p->w.iRightJoinTable==iTable) ){
+     && (iTable<0 || p->iRightJoinTable==iTable) ){
      ExprClearProperty(p, EP_FromJoin);
    }
    if( p->op==TK_COLUMN && p->iTable==iTable ){
@@ -1404,7 +1404,7 @@ KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
    p->nRef = 1;
    memset(&p[1], 0, nExtra);
  }else{
-    return (KeyInfo*)sqlite3OomFault(db);
+    sqlite3OomFault(db);
  }
  return p;
 }
@@ -2623,7 +2623,7 @@ static int multiSelectOrderBy(
 ** The "LIMIT of exactly 1" case of condition (1) comes about when a VALUES
 ** clause occurs within scalar expression (ex: "SELECT (VALUES(1),(2),(3))").
 ** The sqlite3CodeSubselect will have added the LIMIT 1 clause in tht case.
-** Since the limit is exactly 1, we only need to evaluate the left-most VALUES.
+** Since the limit is exactly 1, we only need to evalutes the left-most VALUES.
 */
 static int multiSelectValues(
  Parse *pParse,        /* Parsing context */
@@ -3436,7 +3436,6 @@ static int multiSelectOrderBy(
    for(i=2; i<nSelect; i+=2){ pSplit = pSplit->pPrior; }
  }
  pPrior = pSplit->pPrior;
-  assert( pPrior!=0 );
  pSplit->pPrior = 0;
  pPrior->pNext = 0;
  assert( p->pOrderBy == pOrderBy );
@@ -3648,9 +3647,9 @@ static Expr *substExpr(
 ){
  if( pExpr==0 ) return 0;
  if( ExprHasProperty(pExpr, EP_FromJoin)
-   && pExpr->w.iRightJoinTable==pSubst->iTable
+   && pExpr->iRightJoinTable==pSubst->iTable
  ){
-    pExpr->w.iRightJoinTable = pSubst->iNewTable;
+    pExpr->iRightJoinTable = pSubst->iNewTable;
  }
  if( pExpr->op==TK_COLUMN
   && pExpr->iTable==pSubst->iTable
@@ -3689,7 +3688,7 @@ static Expr *substExpr(
          ExprSetProperty(pNew, EP_CanBeNull);
        }
        if( ExprHasProperty(pExpr,EP_FromJoin) ){
-          sqlite3SetJoinExpr(pNew, pExpr->w.iRightJoinTable);
+          sqlite3SetJoinExpr(pNew, pExpr->iRightJoinTable);
        }
        sqlite3ExprDelete(db, pExpr);
        pExpr = pNew;
@@ -3854,7 +3853,7 @@ static int renumberCursorsCb(Walker *pWalker, Expr *pExpr){
    renumberCursorDoMapping(pWalker, &pExpr->iTable);
  }
  if( ExprHasProperty(pExpr, EP_FromJoin) ){
-    renumberCursorDoMapping(pWalker, &pExpr->w.iRightJoinTable);
+    renumberCursorDoMapping(pWalker, &pExpr->iRightJoinTable);
  }
  return WRC_Continue;
 }
@@ -4864,13 +4863,11 @@ static int pushDownWhereTerms(
  }
  if( isLeftJoin
   && (ExprHasProperty(pWhere,EP_FromJoin)==0
-         || pWhere->w.iRightJoinTable!=iCursor)
+         || pWhere->iRightJoinTable!=iCursor)
  ){
    return 0; /* restriction (4) */
  }
-  if( ExprHasProperty(pWhere,EP_FromJoin)
-   && pWhere->w.iRightJoinTable!=iCursor 
-  ){
+  if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
    return 0; /* restriction (5) */
  }
  if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
@@ -5590,8 +5587,7 @@ static int selectExpander(Walker *pWalker, Select *p){

  /* Process NATURAL keywords, and ON and USING clauses of joins.
  */
-  assert( db->mallocFailed==0 || pParse->nErr!=0 );
-  if( pParse->nErr || sqliteProcessJoin(pParse, p) ){
+  if( pParse->nErr || db->mallocFailed || sqliteProcessJoin(pParse, p) ){
    return WRC_Abort;
  }

@@ -5888,13 +5884,12 @@ void sqlite3SelectPrep(
  NameContext *pOuterNC  /* Name context for container */
 ){
  assert( p!=0 || pParse->db->mallocFailed );
-  assert( pParse->db->pParse==pParse );
  if( pParse->db->mallocFailed ) return;
  if( p->selFlags & SF_HasTypeInfo ) return;
  sqlite3SelectExpand(pParse, p);
-  if( pParse->nErr ) return;
+  if( pParse->nErr || pParse->db->mallocFailed ) return;
  sqlite3ResolveSelectNames(pParse, p, pOuterNC);
-  if( pParse->nErr ) return;
+  if( pParse->nErr || pParse->db->mallocFailed ) return;
  sqlite3SelectAddTypeInfo(pParse, p);
 }

@@ -5911,10 +5906,8 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
  int i;
  struct AggInfo_func *pFunc;
  int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
-  assert( pParse->db->pParse==pParse );
-  assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
  if( nReg==0 ) return;
-  if( pParse->nErr ) return;
+  if( pParse->nErr || pParse->db->mallocFailed ) return;
 #ifdef SQLITE_DEBUG
  /* Verify that all AggInfo registers are within the range specified by
  ** AggInfo.mnReg..AggInfo.mxReg */
@@ -6337,12 +6330,10 @@ int sqlite3Select(
  u8 minMaxFlag;                 /* Flag for min/max queries */

  db = pParse->db;
-  assert( pParse==db->pParse );
  v = sqlite3GetVdbe(pParse);
-  if( p==0 || pParse->nErr ){
+  if( p==0 || db->mallocFailed || pParse->nErr ){
    return 1;
  }
-  assert( db->mallocFailed==0 );
  if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
 #if SELECTTRACE_ENABLED
  SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
@@ -6377,10 +6368,9 @@ int sqlite3Select(
    p->selFlags |= SF_NoopOrderBy;
  }
  sqlite3SelectPrep(pParse, p, 0);
-  if( pParse->nErr ){
+  if( pParse->nErr || db->mallocFailed ){
    goto select_end;
  }
-  assert( db->mallocFailed==0 );
  assert( p->pEList!=0 );
 #if SELECTTRACE_ENABLED
  if( sqlite3SelectTrace & 0x104 ){
@@ -6424,7 +6414,7 @@ int sqlite3Select(

 #ifndef SQLITE_OMIT_WINDOWFUNC
  if( sqlite3WindowRewrite(pParse, p) ){
-    assert( pParse->nErr );
+    assert( db->mallocFailed || pParse->nErr>0 );
    goto select_end;
  }
 #if SELECTTRACE_ENABLED
@@ -6900,7 +6890,7 @@ int sqlite3Select(
    /* Begin the database scan. */
    SELECTTRACE(1,pParse,p,("WhereBegin\n"));
    pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
-                               p->pEList, p, wctrlFlags, p->nSelectRow);
+                               p->pEList, wctrlFlags, p->nSelectRow);
    if( pWInfo==0 ) goto select_end;
    if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){
      p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo);
@@ -7164,7 +7154,7 @@ int sqlite3Select(
      sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
      SELECTTRACE(1,pParse,p,("WhereBegin\n"));
      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct,
-          0, (WHERE_GROUPBY|(orderByGrp ? WHERE_SORTBYGROUP : 0)|distFlag), 0
+          WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0) | distFlag, 0
      );
      if( pWInfo==0 ){
        sqlite3ExprListDelete(db, pDistinct);
@@ -7462,7 +7452,7 @@ int sqlite3Select(

        SELECTTRACE(1,pParse,p,("WhereBegin\n"));
        pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
-                                   pDistinct, 0, minMaxFlag|distFlag, 0);
+                                   pDistinct, minMaxFlag|distFlag, 0);
        if( pWInfo==0 ){
          goto select_end;
        }
@@ -7519,7 +7509,7 @@ int sqlite3Select(
  */
 select_end:
  assert( db->mallocFailed==0 || db->mallocFailed==1 );
-  assert( db->mallocFailed==0 || pParse->nErr!=0 );
+  pParse->nErr += db->mallocFailed;
  sqlite3ExprListDelete(db, pMinMaxOrderBy);
 #ifdef SQLITE_DEBUG
  if( pAggInfo && !db->mallocFailed ){
@@ -566,7 +566,7 @@ int sqlite3_exec(
 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
 #define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))
 #define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
-#define SQLITE_OK_SYMLINK              (SQLITE_OK | (2<<8)) /* internal use only */
+#define SQLITE_OK_SYMLINK              (SQLITE_OK | (2<<8))

 /*
 ** CAPI3REF: Flags For File Open Operations
@@ -3850,7 +3850,7 @@ void sqlite3_free_filename(char*);
 ** SQL, the sqlite3_error_offset() interface returns the byte offset
 ** of the start of that token.  ^The byte offset returned by
 ** sqlite3_error_offset() assumes that the input SQL is UTF8.
-** ^If the most recent error does not reference a specific token in the input
+** ^If the most error does not reference a specific token in the input
 ** SQL, then the sqlite3_error_offset() function returns -1.
 **
 ** When the serialized [threading mode] is in use, it might be the
@@ -4284,10 +4284,6 @@ const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
 ** be false.  ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a
 ** read-only no-op if the table already exists, but 
 ** sqlite3_stmt_readonly() still returns false for such a statement.
-**
-** ^If prepared statement X is an [EXPLAIN] or [EXPLAIN QUERY PLAN]
-** statement, then sqlite3_stmt_readonly(X) returns the same value as
-** if the EXPLAIN or EXPLAIN QUERY PLAN prefix were omitted.
 */
 int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

@@ -4356,8 +4352,6 @@ int sqlite3_stmt_busy(sqlite3_stmt*);
 **
 ** ^The sqlite3_value objects that are passed as parameters into the
 ** implementation of [application-defined SQL functions] are protected.
-** ^The sqlite3_value objects returned by [sqlite3_vtab_rhs_value()]
-** are protected.
 ** ^The sqlite3_value object returned by
 ** [sqlite3_column_value()] is unprotected.
 ** Unprotected sqlite3_value objects may only be used as arguments
@@ -7137,56 +7131,24 @@ struct sqlite3_index_info {
 **
 ** These macros define the allowed values for the
 ** [sqlite3_index_info].aConstraint[].op field.  Each value represents
-** an operator that is part of a constraint term in the WHERE clause of
+** an operator that is part of a constraint term in the wHERE clause of
 ** a query that uses a [virtual table].
-**
-** ^The left-hand operand of the operator is given by the corresponding
-** aConstraint[].iColumn field.  ^An iColumn of -1 indicates the left-hand
-** operand is the rowid.
-** The SQLITE_INDEX_CONSTRAINT_LIMIT and SQLITE_INDEX_CONSTRAINT_OFFSET
-** operators have no left-hand operand, and so for those operators the
-** corresponding aConstraint[].iColumn is meaningless and should not be
-** used.
-**
-** All operator values from SQLITE_INDEX_CONSTRAINT_FUNCTION through
-** value 255 are reserved to represent functions that are overloaded
-** by the [xFindFunction|xFindFunction method] of the virtual table
-** implementation.
-**
-** The right-hand operands for each constraint might be accessible using
-** the [sqlite3_vtab_rhs_value()] interface.  Usually the right-hand
-** operand is only available if it appears as a single constant literal
-** in the input SQL.  If the right-hand operand is another column or an
-** expression (even a constant expression) or a parameter, then the
-** sqlite3_vtab_rhs_value() probably will not be able to extract it.
-** ^The SQLITE_INDEX_CONSTRAINT_ISNULL and
-** SQLITE_INDEX_CONSTRAINT_ISNOTNULL operators have no right-hand operand
-** and hence calls to sqlite3_vtab_rhs_value() for those operators will
-** always return SQLITE_NOTFOUND.
-**
-** The collating sequence to be used for comparison can be found using
-** the [sqlite3_vtab_collation()] interface.  For most real-world virtual
-** tables, the collating sequence of constraints does not matter (for example
-** because the constraints are numeric) and so the sqlite3_vtab_collation()
-** interface is no commonly needed.
 */
-#define SQLITE_INDEX_CONSTRAINT_EQ          2
-#define SQLITE_INDEX_CONSTRAINT_GT          4
-#define SQLITE_INDEX_CONSTRAINT_LE          8
-#define SQLITE_INDEX_CONSTRAINT_LT         16
-#define SQLITE_INDEX_CONSTRAINT_GE         32
-#define SQLITE_INDEX_CONSTRAINT_MATCH      64
-#define SQLITE_INDEX_CONSTRAINT_LIKE       65
-#define SQLITE_INDEX_CONSTRAINT_GLOB       66
-#define SQLITE_INDEX_CONSTRAINT_REGEXP     67
-#define SQLITE_INDEX_CONSTRAINT_NE         68
-#define SQLITE_INDEX_CONSTRAINT_ISNOT      69
-#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL  70
-#define SQLITE_INDEX_CONSTRAINT_ISNULL     71
-#define SQLITE_INDEX_CONSTRAINT_IS         72
-#define SQLITE_INDEX_CONSTRAINT_LIMIT      73
-#define SQLITE_INDEX_CONSTRAINT_OFFSET     74
-#define SQLITE_INDEX_CONSTRAINT_FUNCTION  150
+#define SQLITE_INDEX_CONSTRAINT_EQ         2
+#define SQLITE_INDEX_CONSTRAINT_GT         4
+#define SQLITE_INDEX_CONSTRAINT_LE         8
+#define SQLITE_INDEX_CONSTRAINT_LT        16
+#define SQLITE_INDEX_CONSTRAINT_GE        32
+#define SQLITE_INDEX_CONSTRAINT_MATCH     64
+#define SQLITE_INDEX_CONSTRAINT_LIKE      65
+#define SQLITE_INDEX_CONSTRAINT_GLOB      66
+#define SQLITE_INDEX_CONSTRAINT_REGEXP    67
+#define SQLITE_INDEX_CONSTRAINT_NE        68
+#define SQLITE_INDEX_CONSTRAINT_ISNOT     69
+#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70
+#define SQLITE_INDEX_CONSTRAINT_ISNULL    71
+#define SQLITE_INDEX_CONSTRAINT_IS        72
+#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150

 /*
 ** CAPI3REF: Register A Virtual Table Implementation
@@ -7215,7 +7177,7 @@ struct sqlite3_index_info {
 ** destructor.
 **
 ** ^If the third parameter (the pointer to the sqlite3_module object) is
-** NULL then no new module is created and any existing modules with the
+** NULL then no new module is create and any existing modules with the
 ** same name are dropped.
 **
 ** See also: [sqlite3_drop_modules()]
@@ -9509,14 +9471,13 @@ int sqlite3_vtab_nochange(sqlite3_context*);

 /*
 ** CAPI3REF: Determine The Collation For a Virtual Table Constraint
-** METHOD: sqlite3_index_info
 **
 ** This function may only be called from within a call to the [xBestIndex]
 ** method of a [virtual table].  This function returns a pointer to a string
 ** that is the name of the appropriate collation sequence to use for text
 ** comparisons on the constraint identified by its arguments.
 **
-** The first argument must be the pointer to the [sqlite3_index_info] object
+** The first argument must be the pointer to the sqlite3_index_info object
 ** that is the first parameter to the xBestIndex() method. The second argument
 ** must be an index into the aConstraint[] array belonging to the
 ** sqlite3_index_info structure passed to xBestIndex.
@@ -9524,7 +9485,7 @@ int sqlite3_vtab_nochange(sqlite3_context*);
 ** Important:
 ** The first parameter must be the same pointer that is passed into the
 ** xBestMethod() method.  The first parameter may not be a pointer to a
-** different [sqlite3_index_info] object, even an exact copy.
+** different sqlite3_index_info object, even an exact copy.
 **
 ** The return value is computed as follows:
 **
@@ -9542,236 +9503,6 @@ int sqlite3_vtab_nochange(sqlite3_context*);
 */
 SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

-/*
-** CAPI3REF: Determine if a virtual table query is DISTINCT
-** METHOD: sqlite3_index_info
-**
-** This API may only be used from within an [xBestIndex|xBestIndex method]
-** of a [virtual table] implementation. The result of calling this
-** interface from outside of xBestIndex() is undefined and probably harmful.
-**
-** ^The sqlite3_vtab_distinct() interface returns an integer that is
-** either 0, 1, or 2.  The integer returned by sqlite3_vtab_distinct()
-** gives the virtual table additional information about how the query
-** planner wants the output to be ordered. As long as the virtual table
-** can meet the ordering requirements of the query planner, it may set
-** the "orderByConsumed" flag.
-**
-** <ol><li value="0"><p>
-** ^If the sqlite3_vtab_distinct() interface returns 0, that means
-** that the query planner needs the virtual table to return all rows in the
-** sort order defined by the "nOrderBy" and "aOrderBy" fields of the
-** [sqlite3_index_info] object.  This is the default expectation.  If the
-** virtual table outputs all rows in sorted order, then it is always safe for
-** the xBestIndex method to set the "orderByConsumed" flag, regardless of
-** the return value from sqlite3_vtab_distinct().
-** <li value="1"><p>
-** ^(If the sqlite3_vtab_distinct() interface returns 1, that means
-** that the query planner does not need the rows to be returned in sorted order
-** as long as all rows with the same values in all columns identified by the
-** "aOrderBy" field are adjacent.)^  This mode is used when the query planner
-** is doing a GROUP BY.
-** <li value="2"><p>
-** ^(If the sqlite3_vtab_distinct() interface returns 2, that means
-** that the query planner does not need the rows returned in any particular
-** order, as long as rows with the same values in all "aOrderBy" columns
-** are adjacent.)^  ^(Furthermore, only a single row for each particular
-** combination of values in the columns identified by the "aOrderBy" field
-** needs to be returned.)^  ^It is always ok for two or more rows with the same
-** values in all "aOrderBy" columns to be returned, as long as all such rows
-** are adjacent.  ^The virtual table may, if it chooses, omit extra rows
-** that have the same value for all columns identified by "aOrderBy".
-** ^However omitting the extra rows is optional.
-** This mode is used for a DISTINCT query.
-** </ol>
-**
-** ^For the purposes of comparing virtual table output values to see if the
-** values are same value for sorting purposes, two NULL values are considered
-** to be the same.  In other words, the comparison operator is "IS"
-** (or "IS NOT DISTINCT FROM") and not "==".
-**
-** If a virtual table implementation is unable to meet the requirements
-** specified above, then it must not set the "orderByConsumed" flag in the
-** [sqlite3_index_info] object or an incorrect answer may result.
-**
-** ^A virtual table implementation is always free to return rows in any order
-** it wants, as long as the "orderByConsumed" flag is not set.  ^When the
-** the "orderByConsumed" flag is unset, the query planner will add extra
-** [bytecode] to ensure that the final results returned by the SQL query are
-** ordered correctly.  The use of the "orderByConsumed" flag and the
-** sqlite3_vtab_distinct() interface is merely an optimization.  ^Careful
-** use of the sqlite3_vtab_distinct() interface and the "orderByConsumed"
-** flag might help queries against a virtual table to run faster.  Being
-** overly aggressive and setting the "orderByConsumed" flag when it is not
-** valid to do so, on the other hand, might cause SQLite to return incorrect
-** results.
-*/
-int sqlite3_vtab_distinct(sqlite3_index_info*);
-
-/*
-** CAPI3REF: Identify and handle IN constraints in xBestIndex
-**
-** This interface may only be used from within an 
-** [xBestIndex|xBestIndex() method] of a [virtual table] implementation.
-** The result of invoking this interface from any other context is
-** undefined and probably harmful.
-**
-** ^(A constraint on a virtual table of the form
-** "[IN operator|column IN (...)]" is
-** communicated to the xBestIndex method as a
-** [SQLITE_INDEX_CONSTRAINT_EQ] constraint.)^  If xBestIndex wants to use
-** this constraint, it must set the corresponding
-** aConstraintUsage[].argvIndex to a postive integer.  ^(Then, under
-** the usual mode of handling IN operators, SQLite generates [bytecode]
-** that invokes the [xFilter|xFilter() method] once for each value
-** on the right-hand side of the IN operator.)^  Thus the virtual table
-** only sees a single value from the right-hand side of the IN operator
-** at a time.
-**
-** In some cases, however, it would be advantageous for the virtual
-** table to see all values on the right-hand of the IN operator all at
-** once.  The sqlite3_vtab_in() interfaces facilitates this in two ways:
-**
-** <ol>
-** <li><p>
-**   ^A call to sqlite3_vtab_in(P,N,-1) will return true (non-zero)
-**   if and only if the [sqlite3_index_info|P->aConstraint][N] constraint
-**   is an [IN operator] that can be processed all at once.  ^In other words,
-**   sqlite3_vtab_in() with -1 in the third argument is a mechanism
-**   by which the virtual table can ask SQLite if all-at-once processing
-**   of the IN operator is even possible.
-**
-** <li><p>
-**   ^A call to sqlite3_vtab_in(P,N,F) with F==1 or F==0 indicates
-**   to SQLite that the virtual table does or does not want to process
-**   the IN operator all-at-once, respectively.  ^Thus when the third
-**   parameter (F) is non-negative, this interface is the mechanism by
-**   which the virtual table tells SQLite how it wants to process the
-**   IN operator.
-** </ol>
-**
-** ^The sqlite3_vtab_in(P,N,F) interface can be invoked multiple times
-** within the same xBestIndex method call.  ^For any given P,N pair,
-** the return value from sqlite3_vtab_in(P,N,F) will always be the same
-** within the same xBestIndex call.  ^If the interface returns true
-** (non-zero), that means that the constraint is an IN operator
-** that can be processed all-at-once.  ^If the constraint is not an IN
-** operator or cannot be processed all-at-once, then the interface returns
-** false.
-**
-** ^(All-at-once processing of the IN operator is selected if both of the
-** following conditions are met:
-**
-** <ol>
-** <li><p> The P->aConstraintUsage[N].argvIndex value is set to a positive
-** integer.  This is how the virtual table tells SQLite that it wants to
-** use the N-th constraint.
-**
-** <li><p> The last call to sqlite3_vtab_in(P,N,F) for which F was
-** non-negative had F>=1.
-** </ol>)^
-** 
-** ^If either or both of the conditions above are false, then SQLite uses
-** the traditional one-at-a-time processing strategy for the IN constraint.
-** ^If both conditions are true, then the argvIndex-th parameter to the
-** xFilter method will be an [sqlite3_value] that appears to be NULL,
-** but which can be passed to [sqlite3_vtab_in_first()] and
-** [sqlite3_vtab_in_next()] to find all values on the right-hand side
-** of the IN constraint.
-*/
-int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle);
-
-/*
-** CAPI3REF: Find all elements on the right-hand side of an IN constraint.
-**
-** These interfaces are only useful from within the
-** [xFilter|xFilter() method] of a [virtual table] implementation.
-** The result of invoking these interfaces from any other context
-** is undefined and probably harmful.
-**
-** The X parameter in a call to sqlite3_vtab_in_first(X,P) or
-** sqlite3_vtab_in_next(X,P) must be one of the parameters to the
-** xFilter method which invokes these routines, and specifically
-** a parameter that was previously selected for all-at-once IN constraint
-** processing use the [sqlite3_vtab_in()] interface in the
-** [xBestIndex|xBestIndex method].  ^(If the X parameter is not
-** an xFilter argument that was selected for all-at-once IN constraint
-** processing, then these routines return [SQLITE_MISUSE])^ or perhaps
-** exhibit some other undefined or harmful behavior.
-**
-** ^(Use these routines to access all values on the right-hand side
-** of the IN constraint using code like the following:
-**
-** <blockquote><pre>
-** &nbsp;  for(rc=sqlite3_vtab_in_first(pList, &pVal);
-** &nbsp;      rc==SQLITE_OK && pVal
-** &nbsp;      rc=sqlite3_vtab_in_next(pList, &pVal)
-** &nbsp;  ){
-** &nbsp;    // do something with pVal
-** &nbsp;  }
-** &nbsp;  if( rc!=SQLITE_OK ){
-** &nbsp;    // an error has occurred
-** &nbsp;  }
-** </pre></blockquote>)^
-**
-** ^On success, the sqlite3_vtab_in_first(X,P) and sqlite3_vtab_in_next(X,P)
-** routines return SQLITE_OK and set *P to point to the first or next value
-** on the RHS of the IN constraint.  ^If there are no more values on the
-** right hand side of the IN constraint, then *P is set to NULL and these
-** routines return [SQLITE_DONE].  ^The return value might be
-** some other value, such as SQLITE_NOMEM, in the event of a malfunction.
-**
-** The *ppOut values returned by these routines are only valid until the
-** next call to either of these routines or until the end of the xFilter
-** method from which these routines were called.  If the virtual table
-** implementation needs to retain the *ppOut values for longer, it must make
-** copies.  The *ppOut values are [protected sqlite3_value|protected].
-*/
-int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut);
-int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut);
-
-/*
-** CAPI3REF: Constraint values in xBestIndex()
-** METHOD: sqlite3_index_info
-**
-** This API may only be used from within the [xBestIndex|xBestIndex method]
-** of a [virtual table] implementation. The result of calling this interface
-** from outside of an xBestIndex method are undefined and probably harmful.
-**
-** ^When the sqlite3_vtab_rhs_value(P,J,V) interface is invoked from within
-** the [xBestIndex] method of a [virtual table] implementation, with P being
-** a copy of the [sqlite3_index_info] object pointer passed into xBestIndex and
-** J being a 0-based index into P->aConstraint[], then this routine
-** attempts to set *V to the value of the right-hand operand of
-** that constraint if the right-hand operand is known.  ^If the
-** right-hand operand is not known, then *V is set to a NULL pointer.
-** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
-** and only if *V is set to a value.  ^The sqlite3_vtab_rhs_value(P,J,V) 
-** inteface returns SQLITE_NOTFOUND if the right-hand side of the J-th
-** constraint is not available.  ^The sqlite3_vtab_rhs_value() interface
-** can return an result code other than SQLITE_OK or SQLITE_NOTFOUND if
-** something goes wrong.
-**
-** The sqlite3_vtab_rhs_value() interface is usually only successful if
-** the right-hand operand of a constraint is a literal value in the original
-** SQL statement.  If the right-hand operand is an expression or a reference
-** to some other column or a [host parameter], then sqlite3_vtab_rhs_value()
-** will probably return [SQLITE_NOTFOUND].
-**
-** ^(Some constraints, such as [SQLITE_INDEX_CONSTRAINT_ISNULL] and
-** [SQLITE_INDEX_CONSTRAINT_ISNOTNULL], have no right-hand operand.  For such
-** constraints, sqlite3_vtab_rhs_value() always returns SQLITE_NOTFOUND.)^
-**
-** ^The [sqlite3_value] object returned in *V is a protected sqlite3_value
-** and remains valid for the duration of the xBestIndex method call.
-** ^When xBestIndex returns, the sqlite3_value object returned by
-** sqlite3_vtab_rhs_value() is automatically deallocated.
-**
-** The "_rhs_" in the name of this routine is an abbreviation for
-** "Right-Hand Side".
-*/
-int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);
-
 /*
 ** CAPI3REF: Conflict resolution modes
 ** KEYWORDS: {conflict resolution mode}
@@ -346,11 +346,6 @@ struct sqlite3_api_routines {
     void*, void(*)(void*));
  /* Version 3.38.0 and later */
  int (*error_offset)(sqlite3*);
-  int (*vtab_rhs_value)(sqlite3_index_info*,int,sqlite3_value**);
-  int (*vtab_distinct)(sqlite3_index_info*);
-  int (*vtab_in)(sqlite3_index_info*,int,int);
-  int (*vtab_in_first)(sqlite3_value*,sqlite3_value**);
-  int (*vtab_in_next)(sqlite3_value*,sqlite3_value**);
 };

 /*
@@ -664,11 +659,6 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_autovacuum_pages       sqlite3_api->autovacuum_pages
 /* Version 3.38.0 and later */
 #define sqlite3_error_offset           sqlite3_api->error_offset
-#define sqlite3_vtab_rhs_value         sqlite3_api->vtab_rhs_value
-#define sqlite3_vtab_distinct          sqlite3_api->vtab_distinct
-#define sqlite3_vtab_in                sqlite3_api->vtab_in
-#define sqlite3_vtab_in_first          sqlite3_api->vtab_in_first
-#define sqlite3_vtab_in_next           sqlite3_api->vtab_in_next
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */

 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)
@@ -1231,11 +1231,10 @@ typedef struct With With;
 /*
 ** A bit in a Bitmask
 */
-#define MASKBIT(n)    (((Bitmask)1)<<(n))
-#define MASKBIT64(n)  (((u64)1)<<(n))
-#define MASKBIT32(n)  (((unsigned int)1)<<(n))
-#define SMASKBIT32(n) ((n)<=31?((unsigned int)1)<<(n):0)
-#define ALLBITS       ((Bitmask)-1)
+#define MASKBIT(n)   (((Bitmask)1)<<(n))
+#define MASKBIT64(n) (((u64)1)<<(n))
+#define MASKBIT32(n) (((unsigned int)1)<<(n))
+#define ALLBITS      ((Bitmask)-1)

 /* A VList object records a mapping between parameters/variables/wildcards
 ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
@@ -2517,11 +2516,6 @@ struct KeyInfo {
 struct UnpackedRecord {
  KeyInfo *pKeyInfo;  /* Collation and sort-order information */
  Mem *aMem;          /* Values */
-  union {
-    char *z;            /* Cache of aMem[0].z for vdbeRecordCompareString() */
-    i64 i;              /* Cache of aMem[0].u.i for vdbeRecordCompareInt() */
-  } u;
-  int n;              /* Cache of aMem[0].n used by vdbeRecordCompareString() */
  u16 nField;         /* Number of entries in apMem[] */
  i8 default_rc;      /* Comparison result if keys are equal */
  u8 errCode;         /* Error detected by xRecordCompare (CORRUPT or NOMEM) */
@@ -2829,10 +2823,7 @@ struct Expr {
                         ** TK_VARIABLE: variable number (always >= 1).
                         ** TK_SELECT_COLUMN: column of the result vector */
  i16 iAgg;              /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
-  union {
-    int iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
-    int iOfst;             /* else: start of token from start of statement */
-  } w;
+  int iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
  AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
  union {
    Table *pTab;           /* TK_COLUMN: Table containing column. Can be NULL
@@ -3594,7 +3585,6 @@ struct Parse {
  **************************************************************************/

  int aTempReg[8];        /* Holding area for temporary registers */
-  Parse *pOuterParse;     /* Outer Parse object when nested */
  Token sNameToken;       /* Token with unqualified schema object name */

  /************************************************************************
@@ -3645,8 +3635,7 @@ struct Parse {
 /*
 ** Sizes and pointers of various parts of the Parse object.
 */
-#define PARSE_HDR(X)  (((char*)(X))+offsetof(Parse,zErrMsg))
-#define PARSE_HDR_SZ (offsetof(Parse,aTempReg)-offsetof(Parse,zErrMsg)) /* Recursive part w/o aColCache*/
+#define PARSE_HDR_SZ offsetof(Parse,aTempReg) /* Recursive part w/o aColCache*/
 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken)    /* Recursive part */
 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ)  /* Pointer to tail */
@@ -3941,7 +3930,6 @@ struct Sqlite3Config {
  int (*xTestCallback)(int);        /* Invoked by sqlite3FaultSim() */
 #endif
  int bLocaltimeFault;              /* True to fail localtime() calls */
-  int (*xAltLocaltime)(const void*,void*); /* Alternative localtime() routine */
  int iOnceResetThreshold;          /* When to reset OP_Once counters */
  u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */
  unsigned int iPrngSeed;           /* Alternative fixed seed for the PRNG */
@@ -4587,8 +4575,7 @@ void sqlite3CodeChangeCount(Vdbe*,int,const char*);
 void sqlite3DeleteFrom(Parse*, SrcList*, Expr*, ExprList*, Expr*);
 void sqlite3Update(Parse*, SrcList*, ExprList*,Expr*,int,ExprList*,Expr*,
                   Upsert*);
-WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,
-                             ExprList*,Select*,u16,int);
+WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int);
 void sqlite3WhereEnd(WhereInfo*);
 LogEst sqlite3WhereOutputRowCount(WhereInfo*);
 int sqlite3WhereIsDistinct(WhereInfo*);
@@ -4988,7 +4975,7 @@ int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
  FuncDestructor *pDestructor
 );
 void sqlite3NoopDestructor(void*);
-void *sqlite3OomFault(sqlite3*);
+void sqlite3OomFault(sqlite3*);
 void sqlite3OomClear(sqlite3*);
 int sqlite3ApiExit(sqlite3 *db, int);
 int sqlite3OpenTempDatabase(Parse *);
@@ -5001,7 +4988,6 @@ void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*);
 void sqlite3SelectDestInit(SelectDest*,int,int);
 Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
 void sqlite3RecordErrorByteOffset(sqlite3*,const char*);
-void sqlite3RecordErrorOffsetOfExpr(sqlite3*,const Expr*);

 void sqlite3BackupRestart(sqlite3_backup *);
 void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
@@ -5110,8 +5096,7 @@ FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
 sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context*);
 int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
 int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
-void sqlite3ParseObjectInit(Parse*,sqlite3*);
-void sqlite3ParseObjectReset(Parse*);
+void sqlite3ParserReset(Parse*);
 void *sqlite3ParserAddCleanup(Parse*,void(*)(sqlite3*,void*),void*);
 #ifdef SQLITE_ENABLE_NORMALIZE
 char *sqlite3Normalize(Vdbe*, const char*);
@@ -1943,16 +1943,15 @@ static int SQLITE_TCLAPI DbObjCmd(
    "close",                  "collate",               "collation_needed",
    "commit_hook",            "complete",              "config",
    "copy",                   "deserialize",           "enable_load_extension",
-    "errorcode",              "erroroffset",           "eval",
-    "exists",                 "function",              "incrblob",
-    "interrupt",              "last_insert_rowid",     "nullvalue",
-    "onecolumn",              "preupdate",             "profile",
-    "progress",               "rekey",                 "restore",
-    "rollback_hook",          "serialize",             "status",
-    "timeout",                "total_changes",         "trace",
-    "trace_v2",               "transaction",           "unlock_notify",
-    "update_hook",            "version",               "wal_hook",
-    0                        
+    "errorcode",              "eval",                  "exists",
+    "function",               "incrblob",              "interrupt",
+    "last_insert_rowid",      "nullvalue",             "onecolumn",
+    "preupdate",              "profile",               "progress",
+    "rekey",                  "restore",               "rollback_hook",
+    "serialize",              "status",                "timeout",
+    "total_changes",          "trace",                 "trace_v2",
+    "transaction",            "unlock_notify",         "update_hook",
+    "version",                "wal_hook",              0
  };
  enum DB_enum {
    DB_AUTHORIZER,            DB_BACKUP,               DB_BIND_FALLBACK,
@@ -1960,15 +1959,15 @@ static int SQLITE_TCLAPI DbObjCmd(
    DB_CLOSE,                 DB_COLLATE,              DB_COLLATION_NEEDED,
    DB_COMMIT_HOOK,           DB_COMPLETE,             DB_CONFIG,
    DB_COPY,                  DB_DESERIALIZE,          DB_ENABLE_LOAD_EXTENSION,
-    DB_ERRORCODE,             DB_ERROROFFSET,          DB_EVAL,
-    DB_EXISTS,                DB_FUNCTION,             DB_INCRBLOB,
-    DB_INTERRUPT,             DB_LAST_INSERT_ROWID,    DB_NULLVALUE,
-    DB_ONECOLUMN,             DB_PREUPDATE,            DB_PROFILE,
-    DB_PROGRESS,              DB_REKEY,                DB_RESTORE,
-    DB_ROLLBACK_HOOK,         DB_SERIALIZE,            DB_STATUS,
-    DB_TIMEOUT,               DB_TOTAL_CHANGES,        DB_TRACE,
-    DB_TRACE_V2,              DB_TRANSACTION,          DB_UNLOCK_NOTIFY,
-    DB_UPDATE_HOOK,           DB_VERSION,              DB_WAL_HOOK,
+    DB_ERRORCODE,             DB_EVAL,                 DB_EXISTS,
+    DB_FUNCTION,              DB_INCRBLOB,             DB_INTERRUPT,
+    DB_LAST_INSERT_ROWID,     DB_NULLVALUE,            DB_ONECOLUMN,
+    DB_PREUPDATE,             DB_PROFILE,              DB_PROGRESS,
+    DB_REKEY,                 DB_RESTORE,              DB_ROLLBACK_HOOK,
+    DB_SERIALIZE,             DB_STATUS,               DB_TIMEOUT,
+    DB_TOTAL_CHANGES,         DB_TRACE,                DB_TRACE_V2,
+    DB_TRANSACTION,           DB_UNLOCK_NOTIFY,        DB_UPDATE_HOOK,
+    DB_VERSION,               DB_WAL_HOOK             
  };
  /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */

@@ -2731,17 +2730,6 @@ deserialize_error:
    break;
  }

-  /*
-  **    $db erroroffset
-  **
-  ** Return the numeric error code that was returned by the most recent
-  ** call to sqlite3_exec().
-  */
-  case DB_ERROROFFSET: {
-    Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_error_offset(pDb->db)));
-    break;
-  }
-
  /*
  **    $db exists $sql
  **    $db onecolumn $sql
@@ -3977,102 +3977,6 @@ static int SQLITE_TCLAPI test_bind_blob(
  return TCL_OK;
 }

-/*
-** Usage:   sqlite3_bind_value_from_preupdate STMT N NEW|OLD IDX
-**
-** Test the sqlite3_bind_value interface using sqlite3_value objects
-** obtained from either sqlite3_preupdate_new() (if arg[3]=="new") or
-** sqlite3_preupdate_old() if (arg[3]=="old"). IDX is the index to
-** pass to the sqlite3_preupdate_xxx() function.
-*/
-static int SQLITE_TCLAPI test_bind_value_from_preupdate(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  sqlite3_stmt *pStmt;
-  int idx;
-  int bidx;
-  const char *z3 = 0;
-  sqlite3 *db = 0;
-  sqlite3_value *pVal = 0;
-
-  if( objc!=5 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "STMT N NEW|OLD IDX");
-    return TCL_ERROR;
-  }
-
-  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
-  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
-  z3 = Tcl_GetString(objv[3]);
-  if( Tcl_GetIntFromObj(interp, objv[4], &bidx) ) return TCL_ERROR;
-  db = sqlite3_db_handle(pStmt);
-
-#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
-  if( z3[0]=='n' ){
-    sqlite3_preupdate_new(db, bidx, &pVal);
-  }else if( z3[0]=='o' ){
-    sqlite3_preupdate_old(db, bidx, &pVal);
-  }else{
-    Tcl_AppendResult(interp, "expected new or old, got: ", z3, (char*)0);
-    return TCL_ERROR;
-  }
-  sqlite3_bind_value(pStmt, idx, pVal);
-#endif
-
-  return TCL_OK;
-}
-
-/*
-** Usage:   sqlite3_bind_value_from_select STMT N SELECT
-**
-** Test the sqlite3_bind_value interface.  STMT is a prepared statement.
-** N is the index of a wildcard in the prepared statement. 
-*/
-static int SQLITE_TCLAPI test_bind_value_from_select(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  sqlite3_stmt *pStmt;
-  sqlite3_stmt *pStmt2;
-  int idx;
-  const char *zSql = 0;
-  sqlite3 *db = 0;
-  int rc = SQLITE_OK;
-
-  if( objc!=4 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "STMT N SELECT");
-    return TCL_ERROR;
-  }
-
-  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
-  if( Tcl_GetIntFromObj(interp, objv[2], &idx) ) return TCL_ERROR;
-  zSql = Tcl_GetString(objv[3]);
-  db = sqlite3_db_handle(pStmt);
-
-  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt2, 0);
-  if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, "error in SQL: ", sqlite3_errmsg(db), (char*)0);
-    return TCL_ERROR;
-  }
-  if( sqlite3_step(pStmt2)==SQLITE_ROW ){
-    sqlite3_value *pVal = sqlite3_column_value(pStmt2, 0);
-    sqlite3_bind_value(pStmt, idx, pVal);
-  }
-  rc = sqlite3_finalize(pStmt2);
-  if( rc!=SQLITE_OK ){
-    Tcl_AppendResult(interp, 
-        "error runnning SQL: ", sqlite3_errmsg(db), (char*)0
-    );
-    return TCL_ERROR;
-  }
-
-  return TCL_OK;
-}
-

 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /*
@@ -7207,55 +7111,6 @@ static int SQLITE_TCLAPI test_print_eqp(
 }
 #endif /* SQLITE_OMIT_EXPLAIN */

-#include <time.h>
-/*
-** This is an alternative localtime_r() implementation used for testing
-** the 'localtime' and 'utc' modifiers of date-time functions.  Because
-** the OS-supplied localtime_r() is locale-dependent, this alternative is
-** provided as a stable test platform.
-**
-** Operation:
-**
-**     (1)  Localtime is 30 minutes earlier than (west of) UTC on
-**          even days (counting from 1970-01-01)
-**
-**     (2)  Localtime is 30 minutes later than (east of) UTC on odd days.
-**
-**     (3)  The function fails for the specific date/time value
-**          of 2000-05-29 14:16:00 in order to test the ability of
-**          SQLite to deal with localtime_r() failures.
-*/
-static int testLocaltime(const void *aliasT, void *aliasTM){
-  const time_t t = *(const time_t*)aliasT;
-  struct tm *pTm = (struct tm *)aliasTM;
-  time_t altT;
-  sqlite3_int64 iJD;
-  int Z, A, B, C, D, E, X1, S;
-
-  if( (t/86400) & 1 ){
-    altT = t + 1800;  /* 30 minutes later on odd days */
-  }else{
-    altT = t - 1800;  /* 30 minutes earlier on even days */
-  }
-  iJD = (sqlite3_int64)(altT + 210866760000);
-  Z = (int)((iJD + 43200)/86400);
-  A = (int)((Z - 1867216.25)/36524.25);
-  A = Z + 1 + A - (A/4);
-  B = A + 1524;
-  C = (int)((B - 122.1)/365.25);
-  D = (36525*(C&32767))/100;
-  E = (int)((B-D)/30.6001);
-  X1 = (int)(30.6001*E);
-  pTm->tm_mday = B - D - X1;
-  pTm->tm_mon = E<14 ? E-2 : E-14;
-  pTm->tm_year = (pTm->tm_mon>1 ? C - 4716 : C - 4715) - 1900;
-  S = (int)((iJD + 43200)%86400);
-  pTm->tm_hour = S/3600;
-  pTm->tm_min = (S/60)%60;
-  pTm->tm_sec = S % 60;
-  return t==959609760; /* Special case: 2000-05-29 14:16:00 fails */
-}
-
 /*
 ** sqlite3_test_control VERB ARGS...
 */
@@ -7303,11 +7158,11 @@ static int SQLITE_TCLAPI test_test_control(
    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
      int val;
      if( objc!=3 ){
-        Tcl_WrongNumArgs(interp, 2, objv, "0|1|2");
+        Tcl_WrongNumArgs(interp, 2, objv, "ONOFF");
        return TCL_ERROR;
      }
-      if( Tcl_GetIntFromObj(interp, objv[2], &val) ) return TCL_ERROR;
-      sqlite3_test_control(iFlag, val, testLocaltime);
+      if( Tcl_GetBooleanFromObj(interp, objv[2], &val) ) return TCL_ERROR;
+      sqlite3_test_control(iFlag, val);
      break;
    }

@@ -7713,7 +7568,6 @@ static int SQLITE_TCLAPI tclLoadStaticExtensionCmd(
 #ifndef SQLITE_OMIT_VIRTUALTABLE
  extern int sqlite3_prefixes_init(sqlite3*,char**,const sqlite3_api_routines*);
 #endif
-  extern int sqlite3_qpvtab_init(sqlite3*,char**,const sqlite3_api_routines*);
  extern int sqlite3_regexp_init(sqlite3*,char**,const sqlite3_api_routines*);
  extern int sqlite3_remember_init(sqlite3*,char**,const sqlite3_api_routines*);
  extern int sqlite3_series_init(sqlite3*,char**,const sqlite3_api_routines*);
@@ -7744,7 +7598,6 @@ static int SQLITE_TCLAPI tclLoadStaticExtensionCmd(
 #ifndef SQLITE_OMIT_VIRTUALTABLE
    { "prefixes",              sqlite3_prefixes_init             },
 #endif
-    { "qpvtab",                sqlite3_qpvtab_init               },
    { "regexp",                sqlite3_regexp_init               },
    { "remember",              sqlite3_remember_init             },
    { "series",                sqlite3_series_init               },
@@ -8587,8 +8440,6 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
     { "sqlite3_bind_text",             test_bind_text     ,0 },
     { "sqlite3_bind_text16",           test_bind_text16   ,0 },
     { "sqlite3_bind_blob",             test_bind_blob     ,0 },
-     { "sqlite3_bind_value_from_select",test_bind_value_from_select ,0 },
-     { "sqlite3_bind_value_from_preupdate",test_bind_value_from_preupdate ,0 },
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     { "sqlite3_carray_bind",           test_carray_bind   ,0 },
 #endif
@@ -299,21 +299,7 @@ static int tclFilter(
    const char *zVal = (const char*)sqlite3_value_text(argv[ii]);
    Tcl_Obj *pVal;
    if( zVal==0 ){
-      sqlite3_value *pMem;
      pVal = Tcl_NewObj();
-      for(rc=sqlite3_vtab_in_first(argv[ii], &pMem); 
-          rc==SQLITE_OK && pMem;
-          rc=sqlite3_vtab_in_next(argv[ii], &pMem)
-      ){
-        Tcl_Obj *pVal2 = 0;
-        zVal = (const char*)sqlite3_value_text(pMem);
-        if( zVal ){
-          pVal2 = Tcl_NewStringObj(zVal, -1);
-        }else{
-          pVal2 = Tcl_NewObj();
-        }
-        Tcl_ListObjAppendElement(interp, pVal, pVal2);
-      }
    }else{
      pVal = Tcl_NewStringObj(zVal, -1);
    }
@@ -388,13 +374,20 @@ static int tclEof(sqlite3_vtab_cursor *pVtabCursor){
  return (pCsr->pStmt==0);
 }

-static void testBestIndexObjConstraints(
-  Tcl_Interp *interp, 
-  sqlite3_index_info *pIdxInfo
-){
+static int tclBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
+  tcl_vtab *pTab = (tcl_vtab*)tab;
+  Tcl_Interp *interp = pTab->interp;
+  Tcl_Obj *pArg;
+  Tcl_Obj *pScript;
  int ii;
-  Tcl_Obj *pRes = Tcl_NewObj();
-  Tcl_IncrRefCount(pRes);
+  int rc = SQLITE_OK;
+
+  pScript = Tcl_DuplicateObj(pTab->pCmd);
+  Tcl_IncrRefCount(pScript);
+  Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xBestIndex", -1));
+
+  pArg = Tcl_NewObj();
+  Tcl_IncrRefCount(pArg);
  for(ii=0; ii<pIdxInfo->nConstraint; ii++){
    struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];
    Tcl_Obj *pElem = Tcl_NewObj();
@@ -431,10 +424,6 @@ static void testBestIndexObjConstraints(
        zOp = "isnull"; break;
      case SQLITE_INDEX_CONSTRAINT_IS:
        zOp = "is"; break;
-      case SQLITE_INDEX_CONSTRAINT_LIMIT:
-        zOp = "limit"; break;
-      case SQLITE_INDEX_CONSTRAINT_OFFSET:
-        zOp = "offset"; break;
    }

    Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("op", -1));
@@ -444,21 +433,15 @@ static void testBestIndexObjConstraints(
    Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("usable", -1));
    Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->usable));

-    Tcl_ListObjAppendElement(0, pRes, pElem);
+    Tcl_ListObjAppendElement(0, pArg, pElem);
    Tcl_DecrRefCount(pElem);
  }

-  Tcl_SetObjResult(interp, pRes);
-  Tcl_DecrRefCount(pRes);
-}
+  Tcl_ListObjAppendElement(0, pScript, pArg);
+  Tcl_DecrRefCount(pArg);

-static void testBestIndexObjOrderby(
-  Tcl_Interp *interp, 
-  sqlite3_index_info *pIdxInfo
-){
-  int ii;
-  Tcl_Obj *pRes = Tcl_NewObj();
-  Tcl_IncrRefCount(pRes);
+  pArg = Tcl_NewObj();
+  Tcl_IncrRefCount(pArg);
  for(ii=0; ii<pIdxInfo->nOrderBy; ii++){
    struct sqlite3_index_orderby const *pOrder = &pIdxInfo->aOrderBy[ii];
    Tcl_Obj *pElem = Tcl_NewObj();
@@ -469,150 +452,17 @@ static void testBestIndexObjOrderby(
    Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("desc", -1));
    Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->desc));

-    Tcl_ListObjAppendElement(0, pRes, pElem);
+    Tcl_ListObjAppendElement(0, pArg, pElem);
    Tcl_DecrRefCount(pElem);
  }

-  Tcl_SetObjResult(interp, pRes);
-  Tcl_DecrRefCount(pRes);
-}
+  Tcl_ListObjAppendElement(0, pScript, pArg);
+  Tcl_DecrRefCount(pArg);

-/*
-** Implementation of the handle passed to each xBestIndex callback. This
-** object features the following sub-commands:
-**
-**    $hdl constraints
-**    $hdl orderby
-**    $hdl mask
-**
-**    $hdl distinct
-**      Return the result (an integer) of calling sqlite3_vtab_distinct()
-**      on the index-info structure.
-**
-**    $hdl in IDX BOOLEAN
-**      Wrapper around sqlite3_vtab_in(). Returns an integer.
-**
-**    $hdl rhs_value IDX ?DEFAULT?
-**      Wrapper around sqlite3_vtab_rhs_value().
-*/
-static int SQLITE_TCLAPI testBestIndexObj(
-  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 */
-){
-  const char *azSub[] = {
-    "constraints",                /* 0 */
-    "orderby",                    /* 1 */
-    "mask",                       /* 2 */
-    "distinct",                   /* 3 */
-    "in",                         /* 4 */
-    "rhs_value",                  /* 5 */
-    0
-  };
-  int ii;
-  sqlite3_index_info *pIdxInfo = (sqlite3_index_info*)clientData;
+  Tcl_ListObjAppendElement(0, pScript, Tcl_NewWideIntObj(pIdxInfo->colUsed));

-  if( objc<2 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND");
-    return TCL_ERROR;
-  }
-  if( Tcl_GetIndexFromObj(interp, objv[1], azSub, "sub-command", 0, &ii) ){
-    return TCL_ERROR;
-  }
-
-  if( ii<4 && objc!=2 ){
-    Tcl_WrongNumArgs(interp, 2, objv, "");
-    return TCL_ERROR;
-  }
-  if( ii==4 && objc!=4 ){
-    Tcl_WrongNumArgs(interp, 2, objv, "INDEX BOOLEAN");
-    return TCL_ERROR;
-  }
-  if( ii==5 && objc!=3 && objc!=4 ){
-    Tcl_WrongNumArgs(interp, 2, objv, "INDEX ?DEFAULT?");
-    return TCL_ERROR;
-  }
-
-  switch( ii ){
-    case 0: assert( sqlite3_stricmp(azSub[ii], "constraints")==0 );
-      testBestIndexObjConstraints(interp, pIdxInfo);
-      break;
-
-    case 1: assert( sqlite3_stricmp(azSub[ii], "orderby")==0 );
-      testBestIndexObjOrderby(interp, pIdxInfo);
-      break;
-
-    case 2: assert( sqlite3_stricmp(azSub[ii], "mask")==0 );
-      Tcl_SetObjResult(interp, Tcl_NewWideIntObj(pIdxInfo->colUsed));
-      break;
-
-    case 3: assert( sqlite3_stricmp(azSub[ii], "distinct")==0 ); {
-      int bDistinct = sqlite3_vtab_distinct(pIdxInfo);
-      Tcl_SetObjResult(interp, Tcl_NewIntObj(bDistinct));
-      break;
-    }
-
-    case 4: assert( sqlite3_stricmp(azSub[ii], "in")==0 ); {
-      int iCons;
-      int bHandle;
-      if( Tcl_GetIntFromObj(interp, objv[2], &iCons) 
-       || Tcl_GetBooleanFromObj(interp, objv[3], &bHandle) 
-      ){
-        return TCL_ERROR;
-      }
-      Tcl_SetObjResult(interp, 
-          Tcl_NewIntObj(sqlite3_vtab_in(pIdxInfo, iCons, bHandle))
-      );
-      break;
-    }
-
-    case 5: assert( sqlite3_stricmp(azSub[ii], "rhs_value")==0 ); {
-      int iCons = 0;
-      int rc;
-      sqlite3_value *pVal = 0;
-      const char *zVal = "";
-      if( Tcl_GetIntFromObj(interp, objv[2], &iCons) ){
-        return TCL_ERROR;
-      }
-      rc = sqlite3_vtab_rhs_value(pIdxInfo, iCons, &pVal);
-      if( rc!=SQLITE_OK && rc!=SQLITE_NOTFOUND ){
-        Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
-        return TCL_ERROR;
-      }
-      if( pVal ){
-        zVal = (const char*)sqlite3_value_text(pVal);
-      }else if( objc==4 ){
-        zVal = Tcl_GetString(objv[3]);
-      }
-      Tcl_SetObjResult(interp, Tcl_NewStringObj(zVal, -1));
-      break;
-    }
-  }
-
-  return TCL_OK;
-}
-
-static int tclBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
-  tcl_vtab *pTab = (tcl_vtab*)tab;
-  Tcl_Interp *interp = pTab->interp;
-  int rc = SQLITE_OK;
-
-  static int iNext = 43;
-  char zHdl[24];
-  Tcl_Obj *pScript;
-
-  pScript = Tcl_DuplicateObj(pTab->pCmd);
-  Tcl_IncrRefCount(pScript);
-  Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xBestIndex", -1));
-
-  sqlite3_snprintf(sizeof(zHdl), zHdl, "bestindex%d", iNext++);
-  Tcl_CreateObjCommand(interp, zHdl, testBestIndexObj, pIdxInfo, 0);
-  Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj(zHdl, -1));
  rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL);
-  Tcl_DeleteCommand(interp, zHdl);
  Tcl_DecrRefCount(pScript);
-
  if( rc!=TCL_OK ){
    const char *zErr = Tcl_GetStringResult(interp);
    rc = SQLITE_ERROR;
@@ -639,7 +489,6 @@ static int tclBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
      rc = SQLITE_ERROR;
      pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
    }else{
-      int ii;
      int iArgv = 1;
      for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){
        const char *zCmd = Tcl_GetString(apElem[ii]);
@@ -239,7 +239,7 @@ static void set_options(Tcl_Interp *interp){
  Tcl_SetVar2(interp, "sqlite_options", "geopoly", "0", TCL_GLOBAL_ONLY);
 #endif

-#ifndef SQLITE_OMIT_JSON
+#ifdef SQLITE_ENABLE_JSON1
  Tcl_SetVar2(interp, "sqlite_options", "json1", "1", TCL_GLOBAL_ONLY);
 #else
  Tcl_SetVar2(interp, "sqlite_options", "json1", "0", TCL_GLOBAL_ONLY);
@@ -657,10 +657,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql){
        tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed);
 #endif /* SQLITE_OMIT_WINDOWFUNC */
      }else{
-        Token x;
-        x.z = zSql;
-        x.n = n;
-        sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"", &x);
+        sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);
        break;
      }
    }
@@ -412,7 +412,7 @@ void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
    sqlite3_str_appendf(&x, " fg.af=%x.%c",
      pExpr->flags, pExpr->affExpr ? pExpr->affExpr : 'n');
    if( ExprHasProperty(pExpr, EP_FromJoin) ){
-      sqlite3_str_appendf(&x, " iRJT=%d", pExpr->w.iRightJoinTable);
+      sqlite3_str_appendf(&x, " iRJT=%d", pExpr->iRightJoinTable);
    }
    if( ExprHasProperty(pExpr, EP_FromDDL) ){
      sqlite3_str_appendf(&x, " DDL");
@@ -918,7 +918,6 @@ static void codeReturningTrigger(

  assert( v!=0 );
  assert( pParse->bReturning );
-  assert( db->pParse==pParse );
  pReturning = pParse->u1.pReturning;
  assert( pTrigger == &(pReturning->retTrig) );
  memset(&sSelect, 0, sizeof(sSelect));
@@ -929,8 +928,7 @@ static void codeReturningTrigger(
  sFrom.a[0].pTab = pTab;
  sFrom.a[0].iCursor = -1;
  sqlite3SelectPrep(pParse, &sSelect, 0);
-  if( pParse->nErr==0 ){
-    assert( db->mallocFailed==0 );
+  if( db->mallocFailed==0 && pParse->nErr==0 ){
    sqlite3GenerateColumnNames(pParse, &sSelect);
  }
  sqlite3ExprListDelete(db, sSelect.pEList);
@@ -948,7 +946,7 @@ static void codeReturningTrigger(
    pParse->eTriggerOp = pTrigger->op;
    pParse->pTriggerTab = pTab;
    if( sqlite3ResolveExprListNames(&sNC, pNew)==SQLITE_OK
-     && ALWAYS(!db->mallocFailed)
+     && !db->mallocFailed
    ){
      int i;
      int nCol = pNew->nExpr;
@@ -1112,8 +1110,8 @@ static TriggerPrg *codeRowTrigger(
  Vdbe *v;                    /* Temporary VM */
  NameContext sNC;            /* Name context for sub-vdbe */
  SubProgram *pProgram = 0;   /* Sub-vdbe for trigger program */
+  Parse *pSubParse;           /* Parse context for sub-vdbe */
  int iEndTrigger = 0;        /* Label to jump to if WHEN is false */
-  Parse sSubParse;            /* Parse context for sub-vdbe */

  assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
  assert( pTop->pVdbe );
@@ -1135,17 +1133,19 @@ static TriggerPrg *codeRowTrigger(

  /* Allocate and populate a new Parse context to use for coding the 
  ** trigger sub-program.  */
-  sqlite3ParseObjectInit(&sSubParse, db);
+  pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
+  if( !pSubParse ) return 0;
  memset(&sNC, 0, sizeof(sNC));
-  sNC.pParse = &sSubParse;
-  sSubParse.pTriggerTab = pTab;
-  sSubParse.pToplevel = pTop;
-  sSubParse.zAuthContext = pTrigger->zName;
-  sSubParse.eTriggerOp = pTrigger->op;
-  sSubParse.nQueryLoop = pParse->nQueryLoop;
-  sSubParse.disableVtab = pParse->disableVtab;
+  sNC.pParse = pSubParse;
+  pSubParse->db = db;
+  pSubParse->pTriggerTab = pTab;
+  pSubParse->pToplevel = pTop;
+  pSubParse->zAuthContext = pTrigger->zName;
+  pSubParse->eTriggerOp = pTrigger->op;
+  pSubParse->nQueryLoop = pParse->nQueryLoop;
+  pSubParse->disableVtab = pParse->disableVtab;

-  v = sqlite3GetVdbe(&sSubParse);
+  v = sqlite3GetVdbe(pSubParse);
  if( v ){
    VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)", 
      pTrigger->zName, onErrorText(orconf),
@@ -1171,14 +1171,14 @@ static TriggerPrg *codeRowTrigger(
      if( db->mallocFailed==0
       && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen) 
      ){
-        iEndTrigger = sqlite3VdbeMakeLabel(&sSubParse);
-        sqlite3ExprIfFalse(&sSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
+        iEndTrigger = sqlite3VdbeMakeLabel(pSubParse);
+        sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
      }
      sqlite3ExprDelete(db, pWhen);
    }

    /* Code the trigger program into the sub-vdbe. */
-    codeTriggerProgram(&sSubParse, pTrigger->step_list, orconf);
+    codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);

    /* Insert an OP_Halt at the end of the sub-program. */
    if( iEndTrigger ){
@@ -1186,24 +1186,23 @@ static TriggerPrg *codeRowTrigger(
    }
    sqlite3VdbeAddOp0(v, OP_Halt);
    VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
-    transferParseError(pParse, &sSubParse);

-    if( pParse->nErr==0 ){
-      assert( db->mallocFailed==0 );
+    transferParseError(pParse, pSubParse);
+    if( db->mallocFailed==0 && pParse->nErr==0 ){
      pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
    }
-    pProgram->nMem = sSubParse.nMem;
-    pProgram->nCsr = sSubParse.nTab;
+    pProgram->nMem = pSubParse->nMem;
+    pProgram->nCsr = pSubParse->nTab;
    pProgram->token = (void *)pTrigger;
-    pPrg->aColmask[0] = sSubParse.oldmask;
-    pPrg->aColmask[1] = sSubParse.newmask;
+    pPrg->aColmask[0] = pSubParse->oldmask;
+    pPrg->aColmask[1] = pSubParse->newmask;
    sqlite3VdbeDelete(v);
-  }else{
-    transferParseError(pParse, &sSubParse);
  }

-  assert( !sSubParse.pTriggerPrg && !sSubParse.nMaxArg );
-  sqlite3ParseObjectReset(&sSubParse);
+  assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
+  sqlite3ParserReset(pSubParse);
+  sqlite3StackFree(db, pSubParse);
+
  return pPrg;
 }
    
@@ -1236,7 +1235,6 @@ static TriggerPrg *getRowTrigger(
  /* If an existing TriggerPrg could not be located, create a new one. */
  if( !pPrg ){
    pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
-    pParse->db->errByteOffset = -1;
  }

  return pPrg;
@@ -1259,7 +1257,7 @@ void sqlite3CodeRowTriggerDirect(
  Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
  TriggerPrg *pPrg;
  pPrg = getRowTrigger(pParse, p, pTab, orconf);
-  assert( pPrg || pParse->nErr );
+  assert( pPrg || pParse->nErr || pParse->db->mallocFailed );

  /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program 
  ** is a pointer to the sub-vdbe containing the trigger program.  */
@@ -347,11 +347,9 @@ void sqlite3Update(

  memset(&sContext, 0, sizeof(sContext));
  db = pParse->db;
-  assert( db->pParse==pParse );
-  if( pParse->nErr ){
+  if( pParse->nErr || db->mallocFailed ){
    goto update_cleanup;
  }
-  assert( db->mallocFailed==0 );

  /* Locate the table which we want to update. 
  */
@@ -723,7 +721,7 @@ void sqlite3Update(
      if( !pParse->nested && !pTrigger && !hasFK && !chngKey && !bReplace ){
        flags |= WHERE_ONEPASS_MULTIROW;
      }
-      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,0,0,flags,iIdxCur);
+      pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0, flags,iIdxCur);
      if( pWInfo==0 ) goto update_cleanup;

      /* A one-pass strategy that might update more than one row may not
@@ -1245,9 +1243,7 @@ static void updateVirtualTable(
    regRowid = ++pParse->nMem;

    /* Start scanning the virtual table */
-    pWInfo = sqlite3WhereBegin(
-        pParse, pSrc, pWhere, 0, 0, 0, WHERE_ONEPASS_DESIRED, 0
-    );
+    pWInfo = sqlite3WhereBegin(pParse, pSrc,pWhere,0,0,WHERE_ONEPASS_DESIRED,0);
    if( pWInfo==0 ) return;

    /* Populate the argument registers. */
@@ -189,8 +189,6 @@ void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
  char *zMsg;
  va_list ap;
  sqlite3 *db = pParse->db;
-  assert( db!=0 );
-  assert( db->pParse==pParse );
  db->errByteOffset = -2;
  va_start(ap, zFormat);
  zMsg = sqlite3VMPrintf(db, zFormat, ap);
@@ -198,10 +196,6 @@ void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
  if( db->errByteOffset<-1 ) db->errByteOffset = -1;
  if( db->suppressErr ){
    sqlite3DbFree(db, zMsg);
-    if( db->mallocFailed ){
-      pParse->nErr++;
-      pParse->rc = SQLITE_NOMEM;
-    }
  }else{
    pParse->nErr++;
    sqlite3DbFree(db, pParse->zErrMsg);
@@ -677,6 +677,7 @@ static u64 filterHash(const Mem *aMem, const Op *pOp){
  int i, mx;
  u64 h = 0;

+  i = pOp->p3;
  assert( pOp->p4type==P4_INT32 );
  for(i=pOp->p3, mx=i+pOp->p4.i; i<mx; i++){
    const Mem *p = &aMem[i];
@@ -2659,7 +2660,7 @@ case OP_Offset: {          /* out3 */
 case OP_Column: {
  u32 p2;            /* column number to retrieve */
  VdbeCursor *pC;    /* The VDBE cursor */
-  BtCursor *pCrsr;   /* The B-Tree cursor corresponding to pC */
+  BtCursor *pCrsr;   /* The BTree cursor */
  u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
  int len;           /* The length of the serialized data for the column */
  int i;             /* Loop counter */
@@ -2673,11 +2674,19 @@ case OP_Column: {
  Mem *pReg;         /* PseudoTable input register */

  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
  pC = p->apCsr[pOp->p1];
+  assert( pC!=0 );
  p2 = (u32)pOp->p2;

-op_column_restart:
+  /* If the cursor cache is stale (meaning it is not currently point at
+  ** the correct row) then bring it up-to-date by doing the necessary 
+  ** B-Tree seek. */
+  rc = sqlite3VdbeCursorMoveto(&pC, &p2);
+  if( rc ) goto abort_due_to_error;
+
+  assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
+  pDest = &aMem[pOp->p3];
+  memAboutToChange(p, pDest);
  assert( pC!=0 );
  assert( p2<(u32)pC->nField );
  aOffset = pC->aOffset;
@@ -2698,28 +2707,11 @@ op_column_restart:
        pC->payloadSize = pC->szRow = pReg->n;
        pC->aRow = (u8*)pReg->z;
      }else{
-        pDest = &aMem[pOp->p3];
-        memAboutToChange(p, pDest);
        sqlite3VdbeMemSetNull(pDest);
        goto op_column_out;
      }
    }else{
      pCrsr = pC->uc.pCursor;
-      if( pC->deferredMoveto ){
-        u32 iMap;
-        assert( !pC->isEphemeral );
-        if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0  ){
-          pC = pC->pAltCursor;
-          p2 = iMap - 1;
-          goto op_column_restart;
-        }
-        rc = sqlite3VdbeFinishMoveto(pC);
-        if( rc ) goto abort_due_to_error;
-      }else if( sqlite3BtreeCursorHasMoved(pCrsr) ){
-        rc = sqlite3VdbeHandleMovedCursor(pC);
-        if( rc ) goto abort_due_to_error;
-        goto op_column_restart;
-      }
      assert( pC->eCurType==CURTYPE_BTREE );
      assert( pCrsr );
      assert( sqlite3BtreeCursorIsValid(pCrsr) );
@@ -2727,11 +2719,15 @@ op_column_restart:
      pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
      assert( pC->szRow<=pC->payloadSize );
      assert( pC->szRow<=65536 );  /* Maximum page size is 64KiB */
+      if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
+        goto too_big;
+      }
    }
    pC->cacheStatus = p->cacheCtr;
    pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
    pC->nHdrParsed = 0;

+
    if( pC->szRow<aOffset[0] ){      /*OPTIMIZATION-IF-FALSE*/
      /* pC->aRow does not have to hold the entire row, but it does at least
      ** need to cover the header of the record.  If pC->aRow does not contain
@@ -2771,10 +2767,6 @@ op_column_restart:
      testcase( aOffset[0]==0 );
      goto op_column_read_header;
    }
-  }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){
-    rc = sqlite3VdbeHandleMovedCursor(pC);
-    if( rc ) goto abort_due_to_error;
-    goto op_column_restart;
  }

  /* Make sure at least the first p2+1 entries of the header have been
@@ -2843,8 +2835,6 @@ op_column_restart:
    ** columns.  So the result will be either the default value or a NULL.
    */
    if( pC->nHdrParsed<=p2 ){
-      pDest = &aMem[pOp->p3];
-      memAboutToChange(p, pDest);
      if( pOp->p4type==P4_MEM ){
        sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
      }else{
@@ -2862,8 +2852,6 @@ op_column_restart:
  */
  assert( p2<pC->nHdrParsed );
  assert( rc==SQLITE_OK );
-  pDest = &aMem[pOp->p3];
-  memAboutToChange(p, pDest);
  assert( sqlite3VdbeCheckMemInvariants(pDest) );
  if( VdbeMemDynamic(pDest) ){
    sqlite3VdbeMemSetNull(pDest);
@@ -2884,7 +2872,6 @@ op_column_restart:
      pDest->n = len = (t-12)/2;
      pDest->enc = encoding;
      if( pDest->szMalloc < len+2 ){
-        if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big;
        pDest->flags = MEM_Null;
        if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem;
      }else{
@@ -2917,7 +2904,6 @@ op_column_restart:
      */
      sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest);
    }else{
-      if( len>db->aLimit[SQLITE_LIMIT_LENGTH] ) goto too_big;
      rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
      if( rc!=SQLITE_OK ) goto abort_due_to_error;
      sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
@@ -3130,6 +3116,7 @@ case OP_MakeRecord: {
  Mem *pLast;            /* Last field of the record */
  int nField;            /* Number of fields in the record */
  char *zAffinity;       /* The affinity string for the record */
+  int file_format;       /* File format to use for encoding */
  u32 len;               /* Length of a field */
  u8 *zHdr;              /* Where to write next byte of the header */
  u8 *zPayload;          /* Where to write next byte of the payload */
@@ -3158,6 +3145,7 @@ case OP_MakeRecord: {
  pData0 = &aMem[nField];
  nField = pOp->p2;
  pLast = &pData0[nField-1];
+  file_format = p->minWriteFileFormat;

  /* Identify the output register */
  assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
@@ -3256,10 +3244,10 @@ case OP_MakeRecord: {
      testcase( uu==127 );               testcase( uu==128 );
      testcase( uu==32767 );             testcase( uu==32768 );
      testcase( uu==8388607 );           testcase( uu==8388608 );
-      testcase( uu==2147483647 );        testcase( uu==2147483648LL );
+      testcase( uu==2147483647 );        testcase( uu==2147483648 );
      testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL );
      if( uu<=127 ){
-        if( (i&1)==i && p->minWriteFileFormat>=4 ){
+        if( (i&1)==i && file_format>=4 ){
          pRec->uTemp = 8+(u32)uu;
        }else{
          nData++;
@@ -5722,10 +5710,6 @@ case OP_Rowid: {                 /* out2 */
 ** Move the cursor P1 to a null row.  Any OP_Column operations
 ** that occur while the cursor is on the null row will always
 ** write a NULL.
-**
-** Or, if P1 is a Pseudo-Cursor (a cursor opened using OP_OpenPseudo)
-** just reset the cache for that cursor.  This causes the row of
-** content held by the pseudo-cursor to be reparsed.
 */
 case OP_NullRow: {
  VdbeCursor *pC;
@@ -5905,7 +5889,7 @@ case OP_Rewind: {        /* jump */
  break;
 }

-/* Opcode: Next P1 P2 P3 * P5
+/* Opcode: Next P1 P2 P3 P4 P5
 **
 ** Advance cursor P1 so that it points to the next key/data pair in its
 ** table or index.  If there are no more key/value pairs then fall through
@@ -5924,12 +5908,15 @@ case OP_Rewind: {        /* jump */
 ** omitted if that index had been unique.  P3 is usually 0.  P3 is
 ** always either 0 or 1.
 **
+** P4 is always of type P4_ADVANCE. The function pointer points to
+** sqlite3BtreeNext().
+**
 ** If P5 is positive and the jump is taken, then event counter
 ** number P5-1 in the prepared statement is incremented.
 **
 ** See also: Prev
 */
-/* Opcode: Prev P1 P2 P3 * P5
+/* Opcode: Prev P1 P2 P3 P4 P5
 **
 ** Back up cursor P1 so that it points to the previous key/data pair in its
 ** table or index.  If there is no previous key/value pairs then fall through
@@ -5949,6 +5936,9 @@ case OP_Rewind: {        /* jump */
 ** omitted if that index had been unique.  P3 is usually 0.  P3 is
 ** always either 0 or 1.
 **
+** P4 is always of type P4_ADVANCE. The function pointer points to
+** sqlite3BtreePrevious().
+**
 ** If P5 is positive and the jump is taken, then event counter
 ** number P5-1 in the prepared statement is incremented.
 */
@@ -5966,20 +5956,7 @@ case OP_SorterNext: {  /* jump */
  assert( isSorter(pC) );
  rc = sqlite3VdbeSorterNext(db, pC);
  goto next_tail;
-
 case OP_Prev:          /* jump */
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  assert( pOp->p5<ArraySize(p->aCounter) );
-  pC = p->apCsr[pOp->p1];
-  assert( pC!=0 );
-  assert( pC->deferredMoveto==0 );
-  assert( pC->eCurType==CURTYPE_BTREE );
-  assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
-       || pC->seekOp==OP_Last   || pC->seekOp==OP_IfNoHope
-       || pC->seekOp==OP_NullRow);
-  rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
-  goto next_tail;
-
 case OP_Next:          /* jump */
  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  assert( pOp->p5<ArraySize(p->aCounter) );
@@ -5987,12 +5964,22 @@ case OP_Next:          /* jump */
  assert( pC!=0 );
  assert( pC->deferredMoveto==0 );
  assert( pC->eCurType==CURTYPE_BTREE );
-  assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
+  assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
+  assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
+
+  /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found.
+  ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */
+  assert( pOp->opcode!=OP_Next
+       || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
       || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
       || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
       || pC->seekOp==OP_IfNoHope);
-  rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3);
+  assert( pOp->opcode!=OP_Prev
+       || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
+       || pC->seekOp==OP_Last   || pC->seekOp==OP_IfNoHope
+       || pC->seekOp==OP_NullRow);

+  rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
 next_tail:
  pC->cacheStatus = CACHE_STALE;
  VdbeBranchTaken(rc==SQLITE_OK,2);
@@ -6210,7 +6197,6 @@ case OP_IdxRowid: {           /* out2 */
      pTabCur->nullRow = 0;
      pTabCur->movetoTarget = rowid;
      pTabCur->deferredMoveto = 1;
-      pTabCur->cacheStatus = CACHE_STALE;
      assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
      assert( !pTabCur->isEphemeral );
      pTabCur->ub.aAltMap = pOp->p4.ai;
@@ -7749,34 +7735,6 @@ case OP_VOpen: {
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */

-#ifndef SQLITE_OMIT_VIRTUALTABLE
-/* Opcode: VInitIn P1 P2 P3 * *
-** Synopsis: r[P2]=ValueList(P1,P3)
-**
-** Set register P2 to be a pointer to a ValueList object for cursor P1
-** with cache register P3 and output register P3+1.  This ValueList object
-** can be used as the first argument to sqlite3_vtab_in_first() and
-** sqlite3_vtab_in_next() to extract all of the values stored in the P1
-** cursor.  Register P3 is used to hold the values returned by
-** sqlite3_vtab_in_first() and sqlite3_vtab_in_next().
-*/
-case OP_VInitIn: {        /* out2 */
-  VdbeCursor *pC;         /* The cursor containing the RHS values */
-  ValueList *pRhs;        /* New ValueList object to put in reg[P2] */
-
-  pC = p->apCsr[pOp->p1];
-  pRhs = sqlite3_malloc64( sizeof(*pRhs) );
-  if( pRhs==0 ) goto no_mem;
-  pRhs->pCsr = pC->uc.pCursor;
-  pRhs->pOut = &aMem[pOp->p3];
-  pOut = out2Prerelease(p, pOp);
-  pOut->flags = MEM_Null;
-  sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3_free);
-  break;
-}
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-
-
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /* Opcode: VFilter P1 P2 P3 P4 *
 ** Synopsis: iplan=r[P3] zplan='P4'
@@ -63,6 +63,7 @@ struct VdbeOp {
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
    Expr *pExpr;           /* Used when p4type is P4_EXPR */
 #endif
+    int (*xAdvance)(BtCursor *, int);
  } p4;
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
  char *zComment;          /* Comment to improve readability */
@@ -113,19 +114,21 @@ typedef struct VdbeOpList VdbeOpList;
 #define P4_COLLSEQ    (-2)  /* P4 is a pointer to a CollSeq structure */
 #define P4_INT32      (-3)  /* P4 is a 32-bit signed integer */
 #define P4_SUBPROGRAM (-4)  /* P4 is a pointer to a SubProgram structure */
-#define P4_TABLE      (-5)  /* P4 is a pointer to a Table structure */
+#define P4_ADVANCE    (-5)  /* P4 is a pointer to BtreeNext() or BtreePrev() */
+#define P4_TABLE      (-6)  /* P4 is a pointer to a Table structure */
 /* Above do not own any resources.  Must free those below */
-#define P4_FREE_IF_LE (-6)
-#define P4_DYNAMIC    (-6)  /* Pointer to memory from sqliteMalloc() */
-#define P4_FUNCDEF    (-7)  /* P4 is a pointer to a FuncDef structure */
-#define P4_KEYINFO    (-8)  /* P4 is a pointer to a KeyInfo structure */
-#define P4_EXPR       (-9) /* P4 is a pointer to an Expr tree */
-#define P4_MEM        (-10) /* P4 is a pointer to a Mem*    structure */
-#define P4_VTAB       (-11) /* P4 is a pointer to an sqlite3_vtab structure */
-#define P4_REAL       (-12) /* P4 is a 64-bit floating point value */
-#define P4_INT64      (-13) /* P4 is a 64-bit signed integer */
-#define P4_INTARRAY   (-14) /* P4 is a vector of 32-bit integers */
-#define P4_FUNCCTX    (-15) /* P4 is a pointer to an sqlite3_context object */
+#define P4_FREE_IF_LE (-7)
+#define P4_DYNAMIC    (-7)  /* Pointer to memory from sqliteMalloc() */
+#define P4_FUNCDEF    (-8)  /* P4 is a pointer to a FuncDef structure */
+#define P4_KEYINFO    (-9)  /* P4 is a pointer to a KeyInfo structure */
+#define P4_EXPR       (-10) /* P4 is a pointer to an Expr tree */
+#define P4_MEM        (-11) /* P4 is a pointer to a Mem*    structure */
+#define P4_VTAB       (-12) /* P4 is a pointer to an sqlite3_vtab structure */
+#define P4_REAL       (-13) /* P4 is a 64-bit floating point value */
+#define P4_INT64      (-14) /* P4 is a 64-bit signed integer */
+#define P4_INTARRAY   (-15) /* P4 is a vector of 32-bit integers */
+#define P4_FUNCCTX    (-16) /* P4 is a pointer to an sqlite3_context object */
+#define P4_DYNBLOB    (-17) /* Pointer to memory from sqliteMalloc() */

 /* Error message codes for OP_Halt */
 #define P5_ConstraintNotNull 1
@@ -208,16 +208,16 @@ struct sqlite3_value {
    const char *zPType; /* Pointer type when MEM_Term|MEM_Subtype|MEM_Null */
    FuncDef *pDef;      /* Used only when flags==MEM_Agg */
  } u;
-  char *z;            /* String or BLOB value */
-  int n;              /* Number of characters in string value, excluding '\0' */
  u16 flags;          /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
  u8  enc;            /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
  u8  eSubtype;       /* Subtype for this value */
+  int n;              /* Number of characters in string value, excluding '\0' */
+  char *z;            /* String or BLOB value */
  /* ShallowCopy only needs to copy the information above */
-  sqlite3 *db;        /* The associated database connection */
+  char *zMalloc;      /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */
  int szMalloc;       /* Size of the zMalloc allocation */
  u32 uTemp;          /* Transient storage for serial_type in OP_MakeRecord */
-  char *zMalloc;      /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */
+  sqlite3 *db;        /* The associated database connection */
  void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
 #ifdef SQLITE_DEBUG
  Mem *pScopyFrom;    /* This Mem is a shallow copy of pScopyFrom */
@@ -229,7 +229,7 @@ struct sqlite3_value {
 ** Size of struct Mem not including the Mem.zMalloc member or anything that
 ** follows.
 */
-#define MEMCELLSIZE offsetof(Mem,db)
+#define MEMCELLSIZE offsetof(Mem,zMalloc)

 /* One or more of the following flags are set to indicate the validOK
 ** representations of the value stored in the Mem struct.
@@ -482,32 +482,14 @@ struct PreUpdate {
  Index *pPk;                     /* PK index if pTab is WITHOUT ROWID */
 };

-/*
-** An instance of this object is used to pass an vector of values into
-** OP_VFilter, the xFilter method of a virtual table.  The vector is the
-** set of values on the right-hand side of an IN constraint.
-**
-** The value as passed into xFilter is an sqlite3_value with a "pointer"
-** type, such as is generated by sqlite3_result_pointer() and read by
-** sqlite3_value_pointer.  Such values have MEM_Term|MEM_Subtype|MEM_Null
-** and a subtype of 'p'.  The sqlite3_vtab_in_first() and _next() interfaces
-** know how to use this object to step through all the values in the
-** right operand of the IN constraint.
-*/
-typedef struct ValueList ValueList;
-struct ValueList {
-  BtCursor *pCsr;          /* An ephemeral table holding all values */
-  sqlite3_value *pOut;     /* Register to hold each decoded output value */
-};
-
 /*
 ** Function prototypes
 */
 void sqlite3VdbeError(Vdbe*, const char *, ...);
 void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
 void sqliteVdbePopStack(Vdbe*,int);
-int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p);
 int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor*);
+int sqlite3VdbeCursorMoveto(VdbeCursor**, u32*);
 int sqlite3VdbeCursorRestore(VdbeCursor*);
 u32 sqlite3VdbeSerialTypeLen(u32);
 u8 sqlite3VdbeOneByteSerialTypeLen(u8);
@@ -846,70 +846,6 @@ int sqlite3_vtab_nochange(sqlite3_context *p){
  return sqlite3_value_nochange(p->pOut);
 }

-/*
-** Implementation of sqlite3_vtab_in_first() (if bNext==0) and
-** sqlite3_vtab_in_next() (if bNext!=0).
-*/
-static int valueFromValueList(
-  sqlite3_value *pVal,        /* Pointer to the ValueList object */
-  sqlite3_value **ppOut,      /* Store the next value from the list here */
-  int bNext                   /* 1 for _next(). 0 for _first() */
-){
-  int rc;
-  ValueList *pRhs;
-
-  *ppOut = 0;
-  if( pVal==0 ) return SQLITE_MISUSE;
-  pRhs = (ValueList*)sqlite3_value_pointer(pVal, "ValueList");
-  if( pRhs==0 ) return SQLITE_MISUSE;
-  if( bNext ){
-    rc = sqlite3BtreeNext(pRhs->pCsr, 0);
-  }else{
-    int dummy = 0;
-    rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy);
-    assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
-    if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE;
-  }
-  if( rc==SQLITE_OK ){
-    u32 sz;       /* Size of current row in bytes */
-    Mem sMem;     /* Raw content of current row */
-    memset(&sMem, 0, sizeof(sMem));
-    sz = sqlite3BtreePayloadSize(pRhs->pCsr);
-    rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem);
-    if( rc==SQLITE_OK ){
-      u8 *zBuf = (u8*)sMem.z;
-      u32 iSerial;
-      sqlite3_value *pOut = pRhs->pOut;
-      int iOff = 1 + getVarint32(&zBuf[1], iSerial);
-      sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut);
-      pOut->enc = ENC(pOut->db);
-      if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
-        rc = SQLITE_NOMEM;
-      }else{
-        *ppOut = pOut;
-      }
-    }
-    sqlite3VdbeMemRelease(&sMem);
-  }
-  return rc;
-}
-
-/*
-** Set the iterator value pVal to point to the first value in the set.
-** Set (*ppOut) to point to this value before returning.
-*/
-int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut){
-  return valueFromValueList(pVal, ppOut, 0);
-}
-
-/*
-** Set the iterator value pVal to point to the next value in the set.
-** Set (*ppOut) to point to this value before returning.
-*/
-int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut){
-  return valueFromValueList(pVal, ppOut, 1);
-}
-
 /*
 ** Return the current time for a statement.  If the current time
 ** is requested more than once within the same run of a single prepared
@@ -1104,15 +1040,15 @@ static const Mem *columnNullValue(void){
 #endif
    = {
        /* .u          = */ {0},
-        /* .z          = */ (char*)0,
-        /* .n          = */ (int)0,
        /* .flags      = */ (u16)MEM_Null,
        /* .enc        = */ (u8)0,
        /* .eSubtype   = */ (u8)0,
-        /* .db         = */ (sqlite3*)0,
+        /* .n          = */ (int)0,
+        /* .z          = */ (char*)0,
+        /* .zMalloc    = */ (char*)0,
        /* .szMalloc   = */ (int)0,
        /* .uTemp      = */ (u32)0,
-        /* .zMalloc    = */ (char*)0,
+        /* .db         = */ (sqlite3*)0,
        /* .xDel       = */ (void(*)(void*))0,
 #ifdef SQLITE_DEBUG
        /* .pScopyFrom = */ (Mem*)0,
@@ -1594,10 +1530,7 @@ int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
      break;
    }
    case SQLITE_FLOAT: {
-      assert( pValue->flags & (MEM_Real|MEM_IntReal) );
-      rc = sqlite3_bind_double(pStmt, i, 
-          (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i
-      );
+      rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
      break;
    }
    case SQLITE_BLOB: {
@@ -782,7 +782,7 @@ void sqlite3VdbeAssertAbortable(Vdbe *p){
 ** (3) Update the Vdbe.readOnly and Vdbe.bIsReader flags to accurately
 **     indicate what the prepared statement actually does.
 **
-** (4) (discontinued)
+** (4) Initialize the p4.xAdvance pointer on opcodes that use it.
 **
 ** (5) Reclaim the memory allocated for storing labels.
 **
@@ -828,6 +828,25 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
          p->bIsReader = 1;
          break;
        }
+        case OP_Next:
+        case OP_SorterNext: {
+          pOp->p4.xAdvance = sqlite3BtreeNext;
+          pOp->p4type = P4_ADVANCE;
+          /* The code generator never codes any of these opcodes as a jump
+          ** to a label.  They are always coded as a jump backwards to a 
+          ** known address */
+          assert( pOp->p2>=0 );
+          break;
+        }
+        case OP_Prev: {
+          pOp->p4.xAdvance = sqlite3BtreePrevious;
+          pOp->p4type = P4_ADVANCE;
+          /* The code generator never codes any of these opcodes as a jump
+          ** to a label.  They are always coded as a jump backwards to a 
+          ** known address */
+          assert( pOp->p2>=0 );
+          break;
+        }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
        case OP_VUpdate: {
          if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
@@ -1111,6 +1130,7 @@ static void freeP4(sqlite3 *db, int p4type, void *p4){
    case P4_REAL:
    case P4_INT64:
    case P4_DYNAMIC:
+    case P4_DYNBLOB:
    case P4_INTARRAY: {
      sqlite3DbFree(db, p4);
      break;
@@ -1358,7 +1378,8 @@ void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
 */
 static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){
  assert( p->nOp>0 || p->aOp==0 );
-  assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->pParse->nErr>0 );
+  assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed
+          || p->pParse->nErr>0 );
  if( p->nOp ){
    assert( p->aOp );
    sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
@@ -1707,6 +1728,10 @@ char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
      zP4 = "program";
      break;
    }
+    case P4_DYNBLOB:
+    case P4_ADVANCE: {
+      break;
+    }
    case P4_TABLE: {
      zP4 = pOp->p4.pTab->zName;
      break;
@@ -1838,30 +1863,16 @@ void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){

 /*
 ** Initialize an array of N Mem element.
-**
-** This is a high-runner, so only those fields that really do need to
-** be initialized are set.  The Mem structure is organized so that
-** the fields that get initialized are nearby and hopefully on the same
-** cache line.
-**
-**    Mem.flags = flags
-**    Mem.db = db
-**    Mem.szMalloc = 0
-**
-** All other fields of Mem can safely remain uninitialized for now.  They
-** will be initialized before use.
 */
 static void initMemArray(Mem *p, int N, sqlite3 *db, u16 flags){
-  if( N>0 ){
-    do{
-      p->flags = flags;
-      p->db = db;
-      p->szMalloc = 0;
+  while( (N--)>0 ){
+    p->db = db;
+    p->flags = flags;
+    p->szMalloc = 0;
 #ifdef SQLITE_DEBUG
-      p->pScopyFrom = 0;
+    p->pScopyFrom = 0;
 #endif
-      p++;
-    }while( (--N)>0 );
+    p++;
  }
 }

@@ -1903,9 +1914,8 @@ static void releaseMemArray(Mem *p, int N){
        sqlite3DbFreeNN(db, p->zMalloc);
        p->szMalloc = 0;
      }
-#ifdef SQLITE_DEBUG
+
      p->flags = MEM_Undefined;
-#endif
    }while( (++p)<pEnd );
  }
 }
@@ -3240,7 +3250,6 @@ int sqlite3VdbeTransferError(Vdbe *p){
    sqlite3ValueSetNull(db->pErr);
  }
  db->errCode = rc;
-  db->errByteOffset = -1;
  return rc;
 }

@@ -3520,7 +3529,7 @@ int SQLITE_NOINLINE sqlite3VdbeFinishMoveto(VdbeCursor *p){
 ** is supposed to be pointing.  If the row was deleted out from under the
 ** cursor, set the cursor to point to a NULL row.
 */
-int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p){
+static int SQLITE_NOINLINE handleMovedCursor(VdbeCursor *p){
  int isDifferentRow, rc;
  assert( p->eCurType==CURTYPE_BTREE );
  assert( p->uc.pCursor!=0 );
@@ -3538,7 +3547,39 @@ int SQLITE_NOINLINE sqlite3VdbeHandleMovedCursor(VdbeCursor *p){
 int sqlite3VdbeCursorRestore(VdbeCursor *p){
  assert( p->eCurType==CURTYPE_BTREE );
  if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
-    return sqlite3VdbeHandleMovedCursor(p);
+    return handleMovedCursor(p);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Make sure the cursor p is ready to read or write the row to which it
+** was last positioned.  Return an error code if an OOM fault or I/O error
+** prevents us from positioning the cursor to its correct position.
+**
+** If a MoveTo operation is pending on the given cursor, then do that
+** MoveTo now.  If no move is pending, check to see if the row has been
+** deleted out from under the cursor and if it has, mark the row as
+** a NULL row.
+**
+** If the cursor is already pointing to the correct row and that row has
+** not been deleted out from under the cursor, then this routine is a no-op.
+*/
+int sqlite3VdbeCursorMoveto(VdbeCursor **pp, u32 *piCol){
+  VdbeCursor *p = *pp;
+  assert( p->eCurType==CURTYPE_BTREE || p->eCurType==CURTYPE_PSEUDO );
+  if( p->deferredMoveto ){
+    u32 iMap;
+    assert( !p->isEphemeral );
+    if( p->ub.aAltMap && (iMap = p->ub.aAltMap[1+*piCol])>0 && !p->nullRow ){
+      *pp = p->pAltCursor;
+      *piCol = iMap - 1;
+      return SQLITE_OK;
+    }
+    return sqlite3VdbeFinishMoveto(p);
+  }
+  if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
+    return handleMovedCursor(p);
  }
  return SQLITE_OK;
 }
@@ -4725,8 +4766,7 @@ static int vdbeRecordCompareInt(
      return sqlite3VdbeRecordCompare(nKey1, pKey1, pPKey2);
  }

-  assert( pPKey2->u.i == pPKey2->aMem[0].u.i );
-  v = pPKey2->u.i;
+  v = pPKey2->aMem[0].u.i;
  if( v>lhs ){
    res = pPKey2->r1;
  }else if( v<lhs ){
@@ -4761,18 +4801,12 @@ static int vdbeRecordCompareString(
  int res;

  assert( pPKey2->aMem[0].flags & MEM_Str );
-  assert( pPKey2->aMem[0].n == pPKey2->n );
-  assert( pPKey2->aMem[0].z == pPKey2->u.z );
  vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
-  serial_type = (signed char)(aKey1[1]);
-
-vrcs_restart:
+  serial_type = (u8)(aKey1[1]);
+  if( serial_type >= 0x80 ){
+    sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type);
+  }
  if( serial_type<12 ){
-    if( serial_type<0 ){
-      sqlite3GetVarint32(&aKey1[1], (u32*)&serial_type);
-      if( serial_type>=12 ) goto vrcs_restart;
-      assert( CORRUPT_DB );
-    }
    res = pPKey2->r1;      /* (pKey1/nKey1) is a number or a null */
  }else if( !(serial_type & 0x01) ){ 
    res = pPKey2->r2;      /* (pKey1/nKey1) is a blob */
@@ -4786,15 +4820,15 @@ vrcs_restart:
      pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
      return 0;    /* Corruption */
    }
-    nCmp = MIN( pPKey2->n, nStr );
-    res = memcmp(&aKey1[szHdr], pPKey2->u.z, nCmp);
+    nCmp = MIN( pPKey2->aMem[0].n, nStr );
+    res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);

    if( res>0 ){
      res = pPKey2->r2;
    }else if( res<0 ){
      res = pPKey2->r1;
    }else{
-      res = nStr - pPKey2->n;
+      res = nStr - pPKey2->aMem[0].n;
      if( res==0 ){
        if( pPKey2->nField>1 ){
          res = sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 1);
@@ -4849,7 +4883,6 @@ RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
      p->r2 = 1;
    }
    if( (flags & MEM_Int) ){
-      p->u.i = p->aMem[0].u.i;
      return vdbeRecordCompareInt;
    }
    testcase( flags & MEM_Real );
@@ -4859,8 +4892,6 @@ RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
     && p->pKeyInfo->aColl[0]==0
    ){
      assert( flags & MEM_Str );
-      p->u.z = p->aMem[0].z;
-      p->n = p->aMem[0].n;
      return vdbeRecordCompareString;
    }
  }
@@ -152,9 +152,10 @@ int sqlite3_blob_open(
  sqlite3_mutex_enter(db->mutex);

  pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
-  while(1){
-    sqlite3ParseObjectInit(&sParse,db);
+  do {
+    memset(&sParse, 0, sizeof(Parse));
    if( !pBlob ) goto blob_open_out;
+    sParse.db = db;
    sqlite3DbFree(db, zErr);
    zErr = 0;

@@ -331,9 +332,7 @@ int sqlite3_blob_open(
      goto blob_open_out;
    }
    rc = blobSeekToRow(pBlob, iRow, &zErr);
-    if( (++nAttempt)>=SQLITE_MAX_SCHEMA_RETRY || rc!=SQLITE_SCHEMA ) break;
-    sqlite3ParseObjectReset(&sParse);
-  }
+  } while( (++nAttempt)<SQLITE_MAX_SCHEMA_RETRY && rc==SQLITE_SCHEMA );

 blob_open_out:
  if( rc==SQLITE_OK && db->mallocFailed==0 ){
@@ -344,7 +343,7 @@ blob_open_out:
  }
  sqlite3ErrorWithMsg(db, rc, (zErr ? "%s" : 0), zErr);
  sqlite3DbFree(db, zErr);
-  sqlite3ParseObjectReset(&sParse);
+  sqlite3ParserReset(&sParse);
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
@@ -1530,7 +1530,11 @@ static int valueFromExpr(

  assert( pExpr!=0 );
  while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
+#if defined(SQLITE_ENABLE_STAT4)
  if( op==TK_REGISTER ) op = pExpr->op2;
+#else
+  if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
+#endif

  /* Compressed expressions only appear when parsing the DEFAULT clause
  ** on a table column definition, and hence only when pCtx==0.  This
@@ -1645,7 +1649,7 @@ static int valueFromExpr(

 no_mem:
 #ifdef SQLITE_ENABLE_STAT4
-  if( pCtx==0 || NEVER(pCtx->pParse->nErr==0) )
+  if( pCtx==0 || pCtx->pParse->nErr==0 )
 #endif
    sqlite3OomFault(db);
  sqlite3DbFree(db, zVal);
@@ -825,8 +825,9 @@ int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
  pTab = pCtx->pTab;
  assert( IsVirtual(pTab) );

-  sqlite3ParseObjectInit(&sParse, db);
+  memset(&sParse, 0, sizeof(sParse));
  sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
+  sParse.db = db;
  /* We should never be able to reach this point while loading the
  ** schema.  Nevertheless, defend against that (turn off db->init.busy)
  ** in case a bug arises. */
@@ -880,7 +881,7 @@ int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
    sqlite3VdbeFinalize(sParse.pVdbe);
  }
  sqlite3DeleteTable(db, sParse.pNewTable);
-  sqlite3ParseObjectReset(&sParse);
+  sqlite3ParserReset(&sParse);
  db->init.busy = initBusy;

  assert( (rc&0xff)==rc );
@@ -2603,9 +2603,7 @@ static int walBeginShmUnreliable(Wal *pWal, int *pChanged){
  }

  /* Allocate a buffer to read frames into */
-  assert( (pWal->szPage & (pWal->szPage-1))==0 );
-  assert( pWal->szPage>=512 && pWal->szPage<=65536 );
-  szFrame = pWal->szPage + WAL_FRAME_HDRSIZE;
+  szFrame = pWal->hdr.szPage + WAL_FRAME_HDRSIZE;
  aFrame = (u8 *)sqlite3_malloc64(szFrame);
  if( aFrame==0 ){
    rc = SQLITE_NOMEM_BKPT;
@@ -2619,7 +2617,7 @@ static int walBeginShmUnreliable(Wal *pWal, int *pChanged){
  ** the caller.  */
  aSaveCksum[0] = pWal->hdr.aFrameCksum[0];
  aSaveCksum[1] = pWal->hdr.aFrameCksum[1];
-  for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->szPage); 
+  for(iOffset=walFrameOffset(pWal->hdr.mxFrame+1, pWal->hdr.szPage); 
      iOffset+szFrame<=szWal; 
      iOffset+=szFrame
  ){
@@ -30,14 +30,8 @@
 */
 typedef struct HiddenIndexInfo HiddenIndexInfo;
 struct HiddenIndexInfo {
-  WhereClause *pWC;        /* The Where clause being analyzed */
-  Parse *pParse;           /* The parsing context */
-  int eDistinct;           /* Value to return from sqlite3_vtab_distinct() */
-  u32 mIn;                 /* Mask of terms that are <col> IN (...) */
-  u32 mHandleIn;           /* Terms that vtab will handle as <col> IN (...) */
-  sqlite3_value *aRhs[1];  /* RHS values for constraints. MUST BE LAST
-                           ** because extra space is allocated to hold up
-                           ** to nTerm such values */
+  WhereClause *pWC;   /* The Where clause being analyzed */
+  Parse *pParse;      /* The parsing context */
 };

 /* Forward declaration of methods */
@@ -1101,18 +1095,18 @@ static SQLITE_NOINLINE void sqlite3ConstructBloomFilter(
 /*
 ** Allocate and populate an sqlite3_index_info structure. It is the 
 ** responsibility of the caller to eventually release the structure
-** by passing the pointer returned by this function to freeIndexInfo().
+** by passing the pointer returned by this function to sqlite3_free().
 */
 static sqlite3_index_info *allocateIndexInfo(
-  WhereInfo *pWInfo,              /* The WHERE clause */
+  Parse *pParse,                  /* The parsing context */
  WhereClause *pWC,               /* The WHERE clause being analyzed */
  Bitmask mUnusable,              /* Ignore terms with these prereqs */
  SrcItem *pSrc,                  /* The FROM clause term that is the vtab */
+  ExprList *pOrderBy,             /* The ORDER BY clause */
  u16 *pmNoOmit                   /* Mask of terms not to omit */
 ){
  int i, j;
  int nTerm;
-  Parse *pParse = pWInfo->pParse;
  struct sqlite3_index_constraint *pIdxCons;
  struct sqlite3_index_orderby *pIdxOrderBy;
  struct sqlite3_index_constraint_usage *pUsage;
@@ -1122,9 +1116,7 @@ static sqlite3_index_info *allocateIndexInfo(
  sqlite3_index_info *pIdxInfo;
  u16 mNoOmit = 0;
  const Table *pTab;
-  int eDistinct = 0;
-  ExprList *pOrderBy = pWInfo->pOrderBy;
- 
+
  assert( pSrc!=0 );
  pTab = pSrc->pTab;
  assert( pTab!=0 );
@@ -1145,7 +1137,6 @@ static sqlite3_index_info *allocateIndexInfo(
    testcase( pTerm->eOperator & WO_ALL );
    if( (pTerm->eOperator & ~(WO_EQUIV))==0 ) continue;
    if( pTerm->wtFlags & TERM_VNULL ) continue;
-
    assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
    assert( pTerm->u.x.leftColumn>=XN_ROWID );
    assert( pTerm->u.x.leftColumn<pTab->nCol );
@@ -1207,11 +1198,8 @@ static sqlite3_index_info *allocateIndexInfo(
      /* No matches cause a break out of the loop */
      break;
    }
-    if( i==n ){
+    if( i==n){
      nOrderBy = n;
-      if( (pWInfo->wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY)) ){
-        eDistinct = 1 + ((pWInfo->wctrlFlags & WHERE_DISTINCTBY)!=0);
-      }
    }
  }

@@ -1219,14 +1207,13 @@ static sqlite3_index_info *allocateIndexInfo(
  */
  pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
                           + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
-                           + sizeof(*pIdxOrderBy)*nOrderBy + sizeof(*pHidden)
-                           + sizeof(sqlite3_value*)*nTerm );
+                           + sizeof(*pIdxOrderBy)*nOrderBy + sizeof(*pHidden) );
  if( pIdxInfo==0 ){
    sqlite3ErrorMsg(pParse, "out of memory");
    return 0;
  }
  pHidden = (struct HiddenIndexInfo*)&pIdxInfo[1];
-  pIdxCons = (struct sqlite3_index_constraint*)&pHidden->aRhs[nTerm];
+  pIdxCons = (struct sqlite3_index_constraint*)&pHidden[1];
  pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm];
  pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy];
  pIdxInfo->aConstraint = pIdxCons;
@@ -1234,20 +1221,13 @@ static sqlite3_index_info *allocateIndexInfo(
  pIdxInfo->aConstraintUsage = pUsage;
  pHidden->pWC = pWC;
  pHidden->pParse = pParse;
-  pHidden->eDistinct = eDistinct;
-  pHidden->mIn = 0;
  for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    u16 op;
    if( (pTerm->wtFlags & TERM_OK)==0 ) continue;
    pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
    pIdxCons[j].iTermOffset = i;
    op = pTerm->eOperator & WO_ALL;
-    if( op==WO_IN ){
-      if( (pTerm->wtFlags & TERM_SLICE)==0 ){
-        pHidden->mIn |= SMASKBIT32(j);
-      }
-      op = WO_EQ;
-    }
+    if( op==WO_IN ) op = WO_EQ;
    if( op==WO_AUX ){
      pIdxCons[j].op = pTerm->eMatchOp;
    }else if( op & (WO_ISNULL|WO_IS) ){
@@ -1298,24 +1278,6 @@ static sqlite3_index_info *allocateIndexInfo(
  return pIdxInfo;
 }

-/*
-** Free an sqlite3_index_info structure allocated by allocateIndexInfo()
-** and possibly modified by xBestIndex methods.
-*/
-static void freeIndexInfo(sqlite3 *db, sqlite3_index_info *pIdxInfo){
-  HiddenIndexInfo *pHidden;
-  int i;
-  assert( pIdxInfo!=0 );
-  pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
-  assert( pHidden->pParse!=0 );
-  assert( pHidden->pParse->db==db );
-  for(i=0; i<pIdxInfo->nConstraint; i++){
-    sqlite3ValueFree(pHidden->aRhs[i]); /* IMP: R-14553-25174 */
-    pHidden->aRhs[i] = 0;
-  }
-  sqlite3DbFree(db, pIdxInfo);
-}
-
 /*
 ** The table object reference passed as the second argument to this function
 ** must represent a virtual table. This function invokes the xBestIndex()
@@ -1337,9 +1299,7 @@ static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
  int rc;

  whereTraceIndexInfoInputs(p);
-  pParse->db->nSchemaLock++;
  rc = pVtab->pModule->xBestIndex(pVtab, p);
-  pParse->db->nSchemaLock--;
  whereTraceIndexInfoOutputs(p);

  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
@@ -3168,7 +3128,7 @@ static int whereUsablePartialIndex(
  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
    Expr *pExpr;
    pExpr = pTerm->pExpr;
-    if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->w.iRightJoinTable==iTab)
+    if( (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
     && (isLeft==0 || ExprHasProperty(pExpr, EP_FromJoin))
     && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
     && (pTerm->wtFlags & TERM_VNULL)==0
@@ -3470,15 +3430,6 @@ static int whereLoopAddBtree(

 #ifndef SQLITE_OMIT_VIRTUALTABLE

-/*
-** Return true if pTerm is a virtual table LIMIT or OFFSET term.
-*/
-static int isLimitTerm(WhereTerm *pTerm){
-  assert( pTerm->eOperator==WO_AUX || pTerm->eMatchOp==0 );
-  return pTerm->eMatchOp>=SQLITE_INDEX_CONSTRAINT_LIMIT 
-      && pTerm->eMatchOp<=SQLITE_INDEX_CONSTRAINT_OFFSET;
-}
-
 /*
 ** Argument pIdxInfo is already populated with all constraints that may
 ** be used by the virtual table identified by pBuilder->pNew->iTab. This
@@ -3506,11 +3457,9 @@ static int whereLoopAddVirtualOne(
  u16 mExclude,                   /* Exclude terms using these operators */
  sqlite3_index_info *pIdxInfo,   /* Populated object for xBestIndex */
  u16 mNoOmit,                    /* Do not omit these constraints */
-  int *pbIn,                      /* OUT: True if plan uses an IN(...) op */
-  int *pbRetryLimit               /* OUT: Retry without LIMIT/OFFSET */
+  int *pbIn                       /* OUT: True if plan uses an IN(...) op */
 ){
  WhereClause *pWC = pBuilder->pWC;
-  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
  struct sqlite3_index_constraint *pIdxCons;
  struct sqlite3_index_constraint_usage *pUsage = pIdxInfo->aConstraintUsage;
  int i;
@@ -3533,7 +3482,6 @@ static int whereLoopAddVirtualOne(
    pIdxCons->usable = 0;
    if( (pTerm->prereqRight & mUsable)==pTerm->prereqRight 
     && (pTerm->eOperator & mExclude)==0
-     && (pbRetryLimit || !isLimitTerm(pTerm))
    ){
      pIdxCons->usable = 1;
    }
@@ -3549,7 +3497,6 @@ static int whereLoopAddVirtualOne(
  pIdxInfo->estimatedRows = 25;
  pIdxInfo->idxFlags = 0;
  pIdxInfo->colUsed = (sqlite3_int64)pSrc->colUsed;
-  pHidden->mHandleIn = 0;

  /* Invoke the virtual table xBestIndex() method */
  rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
@@ -3567,8 +3514,8 @@ static int whereLoopAddVirtualOne(

  mxTerm = -1;
  assert( pNew->nLSlot>=nConstraint );
-  memset(pNew->aLTerm, 0, sizeof(pNew->aLTerm[0])*nConstraint );
-  memset(&pNew->u.vtab, 0, sizeof(pNew->u.vtab));
+  for(i=0; i<nConstraint; i++) pNew->aLTerm[i] = 0;
+  pNew->u.vtab.omitMask = 0;
  pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
  for(i=0; i<nConstraint; i++, pIdxCons++){
    int iTerm;
@@ -3602,13 +3549,8 @@ static int whereLoopAddVirtualOne(
        }else{
          testcase( i!=iTerm );
        }
-        if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET ){
-          pNew->u.vtab.bOmitOffset = 1;
-        }
      }
-      if( SMASKBIT32(i) & pHidden->mHandleIn ){ 
-        pNew->u.vtab.mHandleIn |= MASKBIT32(iTerm);
-      }else if( (pTerm->eOperator & WO_IN)!=0 ){
+      if( (pTerm->eOperator & WO_IN)!=0 ){
        /* A virtual table that is constrained by an IN clause may not
        ** consume the ORDER BY clause because (1) the order of IN terms
        ** is not necessarily related to the order of output terms and
@@ -3618,21 +3560,6 @@ static int whereLoopAddVirtualOne(
        pIdxInfo->idxFlags &= ~SQLITE_INDEX_SCAN_UNIQUE;
        *pbIn = 1; assert( (mExclude & WO_IN)==0 );
      }
-
-      if( isLimitTerm(pTerm) && *pbIn ){
-        /* If there is an IN(...) term handled as an == (separate call to
-        ** xFilter for each value on the RHS of the IN) and a LIMIT or
-        ** OFFSET term handled as well, the plan is unusable. Set output
-        ** variable *pbRetryLimit to true to tell the caller to retry with
-        ** LIMIT and OFFSET disabled. */
-        if( pIdxInfo->needToFreeIdxStr ){
-          sqlite3_free(pIdxInfo->idxStr);
-          pIdxInfo->idxStr = 0;
-          pIdxInfo->needToFreeIdxStr = 0;
-        }
-        *pbRetryLimit = 1;
-        return SQLITE_OK;
-      }
    }
  }

@@ -3706,73 +3633,6 @@ const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int iCons){
  return zRet;
 }

-/*
-** Return true if constraint iCons is really an IN(...) constraint, or
-** false otherwise. If iCons is an IN(...) constraint, set (if bHandle!=0)
-** or clear (if bHandle==0) the flag to handle it using an iterator.
-*/
-int sqlite3_vtab_in(sqlite3_index_info *pIdxInfo, int iCons, int bHandle){
-  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
-  u32 m = SMASKBIT32(iCons);
-  if( m & pHidden->mIn ){
-    if( bHandle==0 ){ 
-      pHidden->mHandleIn &= ~m;
-    }else if( bHandle>0 ){
-      pHidden->mHandleIn |= m;
-    }
-    return 1;
-  }
-  return 0;
-}
-
-/*
-** This interface is callable from within the xBestIndex callback only.
-**
-** If possible, set (*ppVal) to point to an object containing the value 
-** on the right-hand-side of constraint iCons.
-*/
-int sqlite3_vtab_rhs_value(
-  sqlite3_index_info *pIdxInfo,   /* Copy of first argument to xBestIndex */
-  int iCons,                      /* Constraint for which RHS is wanted */
-  sqlite3_value **ppVal           /* Write value extracted here */
-){
-  HiddenIndexInfo *pH = (HiddenIndexInfo*)&pIdxInfo[1];
-  sqlite3_value *pVal = 0;
-  int rc = SQLITE_OK;
-  if( iCons<0 || iCons>=pIdxInfo->nConstraint ){
-    rc = SQLITE_MISUSE; /* EV: R-30545-25046 */
-  }else{
-    if( pH->aRhs[iCons]==0 ){
-      WhereTerm *pTerm = &pH->pWC->a[pIdxInfo->aConstraint[iCons].iTermOffset];
-      rc = sqlite3ValueFromExpr(
-          pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
-          SQLITE_AFF_BLOB, &pH->aRhs[iCons]
-      );
-      testcase( rc!=SQLITE_OK );
-    }
-    pVal = pH->aRhs[iCons];
-  }
-  *ppVal = pVal;
-
-  if( rc==SQLITE_OK && pVal==0 ){  /* IMP: R-19933-32160 */
-    rc = SQLITE_NOTFOUND;          /* IMP: R-36424-56542 */
-  }
-
-  return rc;
-}
-
-
-/*
-** Return true if ORDER BY clause may be handled as DISTINCT.
-*/
-int sqlite3_vtab_distinct(sqlite3_index_info *pIdxInfo){
-  HiddenIndexInfo *pHidden = (HiddenIndexInfo*)&pIdxInfo[1];
-  assert( pHidden->eDistinct==0
-       || pHidden->eDistinct==1
-       || pHidden->eDistinct==2 );
-  return pHidden->eDistinct;
-}
-
 /*
 ** Add all WhereLoop objects for a table of the join identified by
 ** pBuilder->pNew->iTab.  That table is guaranteed to be a virtual table.
@@ -3814,7 +3674,6 @@ static int whereLoopAddVirtual(
  WhereLoop *pNew;
  Bitmask mBest;               /* Tables used by best possible plan */
  u16 mNoOmit;
-  int bRetry = 0;              /* True to retry with LIMIT/OFFSET disabled */

  assert( (mPrereq & mUnusable)==0 );
  pWInfo = pBuilder->pWInfo;
@@ -3823,7 +3682,8 @@ static int whereLoopAddVirtual(
  pNew = pBuilder->pNew;
  pSrc = &pWInfo->pTabList->a[pNew->iTab];
  assert( IsVirtual(pSrc->pTab) );
-  p = allocateIndexInfo(pWInfo, pWC, mUnusable, pSrc, &mNoOmit);
+  p = allocateIndexInfo(pParse, pWC, mUnusable, pSrc, pBuilder->pOrderBy, 
+      &mNoOmit);
  if( p==0 ) return SQLITE_NOMEM_BKPT;
  pNew->rSetup = 0;
  pNew->wsFlags = WHERE_VIRTUALTABLE;
@@ -3831,22 +3691,14 @@ static int whereLoopAddVirtual(
  pNew->u.vtab.needFree = 0;
  nConstraint = p->nConstraint;
  if( whereLoopResize(pParse->db, pNew, nConstraint) ){
-    freeIndexInfo(pParse->db, p);
+    sqlite3DbFree(pParse->db, p);
    return SQLITE_NOMEM_BKPT;
  }

  /* First call xBestIndex() with all constraints usable. */
  WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
  WHERETRACE(0x40, ("  VirtualOne: all usable\n"));
-  rc = whereLoopAddVirtualOne(
-      pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn, &bRetry
-  );
-  if( bRetry ){
-    assert( rc==SQLITE_OK );
-    rc = whereLoopAddVirtualOne(
-        pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn, 0
-    );
-  }
+  rc = whereLoopAddVirtualOne(pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn);

  /* If the call to xBestIndex() with all terms enabled produced a plan
  ** that does not require any source tables (IOW: a plan with mBest==0)
@@ -3864,7 +3716,7 @@ static int whereLoopAddVirtual(
    if( bIn ){
      WHERETRACE(0x40, ("  VirtualOne: all usable w/o IN\n"));
      rc = whereLoopAddVirtualOne(
-          pBuilder, mPrereq, ALLBITS, WO_IN, p, mNoOmit, &bIn, 0);
+          pBuilder, mPrereq, ALLBITS, WO_IN, p, mNoOmit, &bIn);
      assert( bIn==0 );
      mBestNoIn = pNew->prereq & ~mPrereq;
      if( mBestNoIn==0 ){
@@ -3891,7 +3743,7 @@ static int whereLoopAddVirtual(
      WHERETRACE(0x40, ("  VirtualOne: mPrev=%04llx mNext=%04llx\n",
                       (sqlite3_uint64)mPrev, (sqlite3_uint64)mNext));
      rc = whereLoopAddVirtualOne(
-          pBuilder, mPrereq, mNext|mPrereq, 0, p, mNoOmit, &bIn, 0);
+          pBuilder, mPrereq, mNext|mPrereq, 0, p, mNoOmit, &bIn);
      if( pNew->prereq==mPrereq ){
        seenZero = 1;
        if( bIn==0 ) seenZeroNoIN = 1;
@@ -3904,7 +3756,7 @@ static int whereLoopAddVirtual(
    if( rc==SQLITE_OK && seenZero==0 ){
      WHERETRACE(0x40, ("  VirtualOne: all disabled\n"));
      rc = whereLoopAddVirtualOne(
-          pBuilder, mPrereq, mPrereq, 0, p, mNoOmit, &bIn, 0);
+          pBuilder, mPrereq, mPrereq, 0, p, mNoOmit, &bIn);
      if( bIn==0 ) seenZeroNoIN = 1;
    }

@@ -3914,12 +3766,12 @@ static int whereLoopAddVirtual(
    if( rc==SQLITE_OK && seenZeroNoIN==0 ){
      WHERETRACE(0x40, ("  VirtualOne: all disabled and w/o IN\n"));
      rc = whereLoopAddVirtualOne(
-          pBuilder, mPrereq, mPrereq, WO_IN, p, mNoOmit, &bIn, 0);
+          pBuilder, mPrereq, mPrereq, WO_IN, p, mNoOmit, &bIn);
    }
  }

  if( p->needToFreeIdxStr ) sqlite3_free(p->idxStr);
-  freeIndexInfo(pParse->db, p);
+  sqlite3DbFreeNN(pParse->db, p);
  WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
  return rc;
 }
@@ -3963,6 +3815,7 @@ static int whereLoopAddOr(
      int i, j;
    
      sSubBuild = *pBuilder;
+      sSubBuild.pOrderBy = 0;
      sSubBuild.pOrSet = &sCur;

      WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm));
@@ -5148,7 +5001,7 @@ static SQLITE_NOINLINE Bitmask whereOmitNoopJoin(
    for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){
      if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){
        if( !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
-         || pTerm->pExpr->w.iRightJoinTable!=pItem->iCursor
+         || pTerm->pExpr->iRightJoinTable!=pItem->iCursor
        ){
          break;
        }
@@ -5320,7 +5173,6 @@ WhereInfo *sqlite3WhereBegin(
  Expr *pWhere,           /* The WHERE clause */
  ExprList *pOrderBy,     /* An ORDER BY (or GROUP BY) clause, or NULL */
  ExprList *pResultSet,   /* Query result set.  Req'd for DISTINCT */
-  Select *pLimit,         /* Use this LIMIT/OFFSET clause, if any */
  u16 wctrlFlags,         /* The WHERE_* flags defined in sqliteInt.h */
  int iAuxArg             /* If WHERE_OR_SUBCLAUSE is set, index cursor number
                          ** If WHERE_USE_LIMIT, then the limit amount */
@@ -5355,6 +5207,7 @@ WhereInfo *sqlite3WhereBegin(
  /* An ORDER/GROUP BY clause of more than 63 terms cannot be optimized */
  testcase( pOrderBy && pOrderBy->nExpr==BMS-1 );
  if( pOrderBy && pOrderBy->nExpr>=BMS ) pOrderBy = 0;
+  sWLB.pOrderBy = pOrderBy;

  /* The number of tables in the FROM clause is limited by the number of
  ** bits in a Bitmask 
@@ -5397,9 +5250,6 @@ WhereInfo *sqlite3WhereBegin(
  pWInfo->wctrlFlags = wctrlFlags;
  pWInfo->iLimit = iAuxArg;
  pWInfo->savedNQueryLoop = pParse->nQueryLoop;
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  pWInfo->pLimit = pLimit;
-#endif
  memset(&pWInfo->nOBSat, 0, 
         offsetof(WhereInfo,sWC) - offsetof(WhereInfo,nOBSat));
  memset(&pWInfo->a[0], 0, sizeof(WhereLoop)+nTabList*sizeof(WhereLevel));
@@ -5468,7 +5318,6 @@ WhereInfo *sqlite3WhereBegin(
  
  /* Analyze all of the subexpressions. */
  sqlite3WhereExprAnalyze(pTabList, &pWInfo->sWC);
-  sqlite3WhereAddLimit(&pWInfo->sWC, pLimit);
  if( db->mallocFailed ) goto whereBeginError;

  /* Special case: WHERE terms that do not refer to any tables in the join
@@ -5568,10 +5417,9 @@ WhereInfo *sqlite3WhereBegin(
  if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){
     pWInfo->revMask = ALLBITS;
  }
-  if( pParse->nErr ){
+  if( pParse->nErr || db->mallocFailed ){
    goto whereBeginError;
  }
-  assert( db->mallocFailed==0 );
 #ifdef WHERETRACE_ENABLED
  if( sqlite3WhereTrace ){
    sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut);
@@ -5715,7 +5563,6 @@ WhereInfo *sqlite3WhereBegin(
      if( pWInfo->eOnePass==ONEPASS_OFF 
       && pTab->nCol<BMS
       && (pTab->tabFlags & (TF_HasGenerated|TF_WithoutRowid))==0
-       && (pLoop->wsFlags & (WHERE_AUTO_INDEX|WHERE_BLOOMFILTER))==0
      ){
        /* If we know that only a prefix of the record will be used,
        ** it is advantageous to reduce the "column count" field in
@@ -123,12 +123,10 @@ struct WhereLoop {
    } btree;
    struct {               /* Information for virtual tables */
      int idxNum;            /* Index number */
-      u32 needFree : 1;      /* True if sqlite3_free(idxStr) is needed */
-      u32 bOmitOffset : 1;   /* True to let virtual table handle offset */
+      u8 needFree;           /* True if sqlite3_free(idxStr) is needed */
      i8 isOrdered;          /* True if satisfies ORDER BY */
      u16 omitMask;          /* Terms that may be omitted */
      char *idxStr;          /* Index identifier string */
-      u32 mHandleIn;         /* Terms to handle as IN(...) instead of == */
    } vtab;
  } u;
  u32 wsFlags;          /* WHERE_* flags describing the plan */
@@ -285,7 +283,6 @@ struct WhereTerm {
 #else
 #  define TERM_HIGHTRUTH  0      /* Only used with STAT4 */
 #endif
-#define TERM_SLICE      0x8000 /* One slice of a row-value/vector comparison */

 /*
 ** An instance of the WhereScan object is used as an iterator for locating
@@ -389,6 +386,7 @@ struct WhereMaskSet {
 struct WhereLoopBuilder {
  WhereInfo *pWInfo;        /* Information about this WHERE */
  WhereClause *pWC;         /* WHERE clause terms */
+  ExprList *pOrderBy;       /* ORDER BY clause */
  WhereLoop *pNew;          /* Template WhereLoop */
  WhereOrSet *pOrSet;       /* Record best loops here, if not NULL */
 #ifdef SQLITE_ENABLE_STAT4
@@ -456,9 +454,6 @@ struct WhereInfo {
  ExprList *pOrderBy;       /* The ORDER BY clause or NULL */
  ExprList *pResultSet;     /* Result set of the query */
  Expr *pWhere;             /* The complete WHERE clause */
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  Select *pLimit;           /* Used to access LIMIT expr/registers for vtabs */
-#endif
  int aiCurOnePass[2];      /* OP_OpenWrite cursors for the ONEPASS opt */
  int iContinue;            /* Jump here to continue with next record */
  int iBreak;               /* Jump here to break out of the loop */
@@ -544,7 +539,6 @@ Bitmask sqlite3WhereCodeOneLoopStart(
 void sqlite3WhereClauseInit(WhereClause*,WhereInfo*);
 void sqlite3WhereClauseClear(WhereClause*);
 void sqlite3WhereSplit(WhereClause*,Expr*,u8);
-void sqlite3WhereAddLimit(WhereClause*, Select*);
 Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*);
 Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*);
 Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*);
@@ -615,6 +609,5 @@ void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*);
 #define WHERE_TRANSCONS    0x00200000  /* Uses a transitive constraint */
 #define WHERE_BLOOMFILTER  0x00400000  /* Consider using a Bloom-filter */
 #define WHERE_SELFCULL     0x00800000  /* nOut reduced by extra WHERE terms */
-#define WHERE_OMIT_OFFSET  0x01000000  /* Set offset counter to zero */

 #endif /* !defined(SQLITE_WHEREINT_H) */
@@ -824,9 +824,6 @@ static int codeAllEqualityTerms(
        sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j);
      }
    }
-  }
-  for(j=nSkip; j<nEq; j++){
-    pTerm = pLoop->aLTerm[j];
    if( pTerm->eOperator & WO_IN ){
      if( pTerm->pExpr->flags & EP_xIsSelect ){
        /* No affinity ever needs to be (or should be) applied to a value
@@ -841,8 +838,7 @@ static int codeAllEqualityTerms(
        sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
        VdbeCoverage(v);
      }
-      if( pParse->nErr==0 ){
-        assert( pParse->db->mallocFailed==0 );
+      if( pParse->db->mallocFailed==0 && pParse->nErr==0 ){
        if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){
          zAff[j] = SQLITE_AFF_BLOB;
        }
@@ -1062,7 +1058,7 @@ static void codeCursorHint(
    if( pTabItem->fg.jointype & JT_LEFT ){
      Expr *pExpr = pTerm->pExpr;
      if( !ExprHasProperty(pExpr, EP_FromJoin) 
-       || pExpr->w.iRightJoinTable!=pTabItem->iCursor
+       || pExpr->iRightJoinTable!=pTabItem->iCursor
      ){
        sWalker.eCode = 0;
        sWalker.xExprCallback = codeCursorHintIsOrFunction;
@@ -1118,21 +1114,13 @@ static void codeCursorHint(
 **
 **   OP_DeferredSeek $iCur $iRowid
 **
-** Which causes a seek on $iCur to the row with rowid $iRowid.
-**
 ** However, if the scan currently being coded is a branch of an OR-loop and
-** the statement currently being coded is a SELECT, then additional information
-** is added that might allow OP_Column to omit the seek and instead do its
-** lookup on the index, thus avoiding an expensive seek operation.  To
-** enable this optimization, the P3 of OP_DeferredSeek is set to iIdxCur
-** and P4 is set to an array of integers containing one entry for each column
-** in the table.  For each table column, if the column is the i'th
-** column of the index, then the corresponding array entry is set to (i+1).
-** If the column does not appear in the index at all, the array entry is set
-** to 0.  The OP_Column opcode can check this array to see if the column it
-** wants is in the index and if it is, it will substitute the index cursor
-** and column number and continue with those new values, rather than seeking
-** the table cursor.
+** the statement currently being coded is a SELECT, then P3 of OP_DeferredSeek
+** is set to iIdxCur and P4 is set to point to an array of integers
+** containing one entry for each column of the table cursor iCur is open 
+** on. For each table column, if the column is the i'th column of the 
+** index, then the corresponding array entry is set to (i+1). If the column
+** does not appear in the index at all, the array entry is set to 0.
 */
 static void codeDeferredSeek(
  WhereInfo *pWInfo,              /* Where clause context */
@@ -1540,27 +1528,11 @@ Bitmask sqlite3WhereCodeOneLoopStart(
      pTerm = pLoop->aLTerm[j];
      if( NEVER(pTerm==0) ) continue;
      if( pTerm->eOperator & WO_IN ){
-        if( SMASKBIT32(j) & pLoop->u.vtab.mHandleIn ){
-          int iTab = pParse->nTab++;
-          int iCache = ++pParse->nMem;
-          sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab);
-          sqlite3VdbeAddOp3(v, OP_VInitIn, iTab, iTarget, iCache);
-        }else{
-          codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
-          addrNotFound = pLevel->addrNxt;
-        }
+        codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
+        addrNotFound = pLevel->addrNxt;
      }else{
        Expr *pRight = pTerm->pExpr->pRight;
        codeExprOrVector(pParse, pRight, iTarget, 1);
-        if( pTerm->eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET
-         && pLoop->u.vtab.bOmitOffset
-        ){
-          assert( pTerm->eOperator==WO_AUX );
-          assert( pWInfo->pLimit!=0 );
-          assert( pWInfo->pLimit->iOffset>0 );
-          sqlite3VdbeAddOp2(v, OP_Integer, 0, pWInfo->pLimit->iOffset);
-          VdbeComment((v,"Zero OFFSET counter"));
-        }
      }
    }
    sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
@@ -1583,19 +1555,13 @@ Bitmask sqlite3WhereCodeOneLoopStart(
      iIn = 0;
    }
    for(j=nConstraint-1; j>=0; j--){
-      int bIn;     /* True to generate byte code to loop over RHS IN values */
      pTerm = pLoop->aLTerm[j];
-      if( (pTerm->eOperator & WO_IN)!=0
-       && (SMASKBIT32(j) & pLoop->u.vtab.mHandleIn)==0
-      ){
-        bIn = 1;
-      }else{
-        bIn = 0;
-      }
-      if( bIn ) iIn--;
+      if( (pTerm->eOperator & WO_IN)!=0 ) iIn--;
      if( j<16 && (pLoop->u.vtab.omitMask>>j)&1 ){
        disableTerm(pLevel, pTerm);
-      }else if( bIn && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1 ){
+      }else if( (pTerm->eOperator & WO_IN)!=0
+        && sqlite3ExprVectorSize(pTerm->pExpr->pLeft)==1
+      ){
        Expr *pCompare;  /* The comparison operator */
        Expr *pRight;    /* RHS of the comparison */
        VdbeOp *pOp;     /* Opcode to access the value of the IN constraint */
@@ -2325,7 +2291,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
    iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn);

    /* If the original WHERE clause is z of the form:  (x1 OR x2 OR ...) AND y
-    ** Then for every term xN, evaluate as the subexpression: xN AND y
+    ** Then for every term xN, evaluate as the subexpression: xN AND z
    ** That way, terms in y that are factored into the disjunction will
    ** be picked up by the recursive calls to sqlite3WhereBegin() below.
    **
@@ -2337,12 +2303,6 @@ Bitmask sqlite3WhereCodeOneLoopStart(
    ** This optimization also only applies if the (x1 OR x2 OR ...) term
    ** is not contained in the ON clause of a LEFT JOIN.
    ** See ticket http://www.sqlite.org/src/info/f2369304e4
-    **
-    ** 2022-02-04:  Do not push down slices of a row-value comparison.
-    ** In other words, "w" or "y" may not be a slice of a vector.  Otherwise,
-    ** the initialization of the right-hand operand of the vector comparison
-    ** might not occur, or might occur only in an OR branch that is not
-    ** taken.  dbsqlfuzz 80a9fade844b4fb43564efc972bcb2c68270f5d1.
    */
    if( pWC->nTerm>1 ){
      int iTerm;
@@ -2351,10 +2311,7 @@ Bitmask sqlite3WhereCodeOneLoopStart(
        if( &pWC->a[iTerm] == pTerm ) continue;
        testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL );
        testcase( pWC->a[iTerm].wtFlags & TERM_CODED );
-        testcase( pWC->a[iTerm].wtFlags & TERM_SLICE );
-        if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED|TERM_SLICE))!=0 ){
-          continue;
-        }
+        if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED))!=0 ) continue;
        if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue;
        testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
        pExpr = sqlite3ExprDup(db, pExpr, 0);
@@ -2397,9 +2354,9 @@ Bitmask sqlite3WhereCodeOneLoopStart(
        /* Loop through table entries that match term pOrTerm. */
        ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1));
        WHERETRACE(0xffff, ("Subplan for OR-clause:\n"));
-        pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, 0,
+        pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
                                      WHERE_OR_SUBCLAUSE, iCovCur);
-        assert( pSubWInfo || pParse->nErr );
+        assert( pSubWInfo || pParse->nErr || db->mallocFailed );
        if( pSubWInfo ){
          WhereLoop *pSubLoop;
          int addrExplain = sqlite3WhereExplainOneScan(
@@ -422,7 +422,7 @@ static int isAuxiliaryVtabOperator(
      assert( pVtab!=0 );
      assert( pVtab->pModule!=0 );
      assert( !ExprHasProperty(pExpr, EP_IntValue) );
-      pMod = (sqlite3_module *)pVtab->pModule;
+       pMod = (sqlite3_module *)pVtab->pModule;
      if( pMod->xFindFunction!=0 ){
        i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
        if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){
@@ -466,7 +466,7 @@ static int isAuxiliaryVtabOperator(
 static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
  if( pDerived ){
    pDerived->flags |= pBase->flags & EP_FromJoin;
-    pDerived->w.iRightJoinTable = pBase->w.iRightJoinTable;
+    pDerived->iRightJoinTable = pBase->iRightJoinTable;
  }
 }

@@ -1111,7 +1111,7 @@ static void exprAnalyze(
 #endif

  if( ExprHasProperty(pExpr, EP_FromJoin) ){
-    Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->w.iRightJoinTable);
+    Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);
    prereqAll |= x;
    extraRight = x-1;  /* ON clause terms may not be used with an index
                       ** on left table of a LEFT JOIN.  Ticket #3015 */
@@ -1379,10 +1379,7 @@ static void exprAnalyze(
  ** no longer used.
  **
  ** This is only required if at least one side of the comparison operation
-  ** is not a sub-select.
-  **
-  ** tag-20220128a
-  */
+  ** is not a sub-select.  */
  if( (pExpr->op==TK_EQ || pExpr->op==TK_IS)
   && (nLeft = sqlite3ExprVectorSize(pExpr->pLeft))>1
   && sqlite3ExprVectorSize(pExpr->pRight)==nLeft
@@ -1399,7 +1396,7 @@ static void exprAnalyze(

      pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
      transferJoinMarkings(pNew, pExpr);
-      idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_SLICE);
+      idxNew = whereClauseInsert(pWC, pNew, TERM_DYNAMIC);
      exprAnalyze(pSrc, pWC, idxNew);
    }
    pTerm = &pWC->a[idxTerm];
@@ -1429,7 +1426,7 @@ static void exprAnalyze(
    int i;
    for(i=0; i<sqlite3ExprVectorSize(pExpr->pLeft); i++){
      int idxNew;
-      idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL|TERM_SLICE);
+      idxNew = whereClauseInsert(pWC, pExpr, TERM_VIRTUAL);
      pWC->a[idxNew].u.x.iField = i+1;
      exprAnalyze(pSrc, pWC, idxNew);
      markTermAsChild(pWC, idxNew, idxTerm);
@@ -1462,7 +1459,7 @@ static void exprAnalyze(
            0, sqlite3ExprDup(db, pRight, 0));
        if( ExprHasProperty(pExpr, EP_FromJoin) && pNewExpr ){
          ExprSetProperty(pNewExpr, EP_FromJoin);
-          pNewExpr->w.iRightJoinTable = pExpr->w.iRightJoinTable;
+          pNewExpr->iRightJoinTable = pExpr->iRightJoinTable;
        }
        idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
        testcase( idxNew==0 );
@@ -1525,113 +1522,6 @@ void sqlite3WhereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
  }
 }

-/*
-** Add either a LIMIT (if eMatchOp==SQLITE_INDEX_CONSTRAINT_LIMIT) or 
-** OFFSET (if eMatchOp==SQLITE_INDEX_CONSTRAINT_OFFSET) term to the 
-** where-clause passed as the first argument. The value for the term
-** is found in register iReg.
-**
-** In the common case where the value is a simple integer 
-** (example: "LIMIT 5 OFFSET 10") then the expression codes as a
-** TK_INTEGER so that it will be available to sqlite3_vtab_rhs_value().
-** If not, then it codes as a TK_REGISTER expression.
-*/
-static void whereAddLimitExpr(
-  WhereClause *pWC,   /* Add the constraint to this WHERE clause */
-  int iReg,           /* Register that will hold value of the limit/offset */
-  Expr *pExpr,        /* Expression that defines the limit/offset */
-  int iCsr,           /* Cursor to which the constraint applies */
-  int eMatchOp        /* SQLITE_INDEX_CONSTRAINT_LIMIT or _OFFSET */
-){
-  Parse *pParse = pWC->pWInfo->pParse;
-  sqlite3 *db = pParse->db;
-  Expr *pNew;
-  int iVal = 0;
-
-  if( sqlite3ExprIsInteger(pExpr, &iVal) && iVal>=0 ){
-    Expr *pVal = sqlite3Expr(db, TK_INTEGER, 0);
-    if( pVal==0 ) return;
-    ExprSetProperty(pVal, EP_IntValue);
-    pVal->u.iValue = iVal;
-    pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
-  }else{
-    Expr *pVal = sqlite3Expr(db, TK_REGISTER, 0);
-    if( pVal==0 ) return;
-    pVal->iTable = iReg;
-    pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
-  }
-  if( pNew ){
-    WhereTerm *pTerm;
-    int idx;
-    idx = whereClauseInsert(pWC, pNew, TERM_DYNAMIC|TERM_VIRTUAL);
-    pTerm = &pWC->a[idx];
-    pTerm->leftCursor = iCsr;
-    pTerm->eOperator = WO_AUX;
-    pTerm->eMatchOp = eMatchOp;
-  }
-}
-
-/*
-** Possibly add terms corresponding to the LIMIT and OFFSET clauses of the
-** SELECT statement passed as the second argument. These terms are only
-** added if:
-**
-**   1. The SELECT statement has a LIMIT clause, and
-**   2. The SELECT statement is not an aggregate or DISTINCT query, and
-**   3. The SELECT statement has exactly one object in its from clause, and
-**      that object is a virtual table, and
-**   4. There are no terms in the WHERE clause that will not be passed
-**      to the virtual table xBestIndex method.
-**   5. The ORDER BY clause, if any, will be made available to the xBestIndex
-**      method.
-**
-** LIMIT and OFFSET terms are ignored by most of the planner code. They
-** exist only so that they may be passed to the xBestIndex method of the
-** single virtual table in the FROM clause of the SELECT.
-*/
-void sqlite3WhereAddLimit(WhereClause *pWC, Select *p){
-  assert( p==0 || (p->pGroupBy==0 && (p->selFlags & SF_Aggregate)==0) );
-  if( (p && p->pLimit)                                          /* 1 */
-   && (p->selFlags & (SF_Distinct|SF_Aggregate))==0             /* 2 */
-   && (p->pSrc->nSrc==1 && IsVirtual(p->pSrc->a[0].pTab))       /* 3 */
-  ){
-    ExprList *pOrderBy = p->pOrderBy;
-    int iCsr = p->pSrc->a[0].iCursor;
-    int ii;
-
-    /* Check condition (4). Return early if it is not met. */
-    for(ii=0; ii<pWC->nTerm; ii++){
-      if( pWC->a[ii].wtFlags & TERM_CODED ){
-        /* This term is a vector operation that has been decomposed into
-        ** other, subsequent terms.  It can be ignored. See tag-20220128a */
-        assert( pWC->a[ii].wtFlags & TERM_VIRTUAL );
-        assert( pWC->a[ii].eOperator==0 );
-        continue;
-      }
-      if( pWC->a[ii].leftCursor!=iCsr ) return;
-    }
-
-    /* Check condition (5). Return early if it is not met. */
-    if( pOrderBy ){
-      for(ii=0; ii<pOrderBy->nExpr; ii++){
-        Expr *pExpr = pOrderBy->a[ii].pExpr;
-        if( pExpr->op!=TK_COLUMN ) return;
-        if( pExpr->iTable!=iCsr ) return;
-        if( pOrderBy->a[ii].sortFlags & KEYINFO_ORDER_BIGNULL ) return;
-      }
-    }
-
-    /* All conditions are met. Add the terms to the where-clause object. */
-    assert( p->pLimit->op==TK_LIMIT );
-    whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft,
-                      iCsr, SQLITE_INDEX_CONSTRAINT_LIMIT);
-    if( p->iOffset>0 ){
-      whereAddLimitExpr(pWC, p->iOffset, p->pLimit->pRight,
-                        iCsr, SQLITE_INDEX_CONSTRAINT_OFFSET);
-    }
-  }
-}
-
 /*
 ** Initialize a preallocated WhereClause structure.
 */
@@ -1667,7 +1557,6 @@ void sqlite3WhereClauseClear(WhereClause *pWC){
    }
 #endif
    while(1){
-      assert( a->eMatchOp==0 || a->eOperator==WO_AUX );
      if( a->wtFlags & TERM_DYNAMIC ){
        sqlite3ExprDelete(db, a->pExpr);
      }
@@ -1825,7 +1714,6 @@ void sqlite3WhereTabFuncArgs(
    pColRef->iColumn = k++;
    assert( ExprUseYTab(pColRef) );
    pColRef->y.pTab = pTab;
-    pItem->colUsed |= sqlite3ExprColUsed(pColRef);
    pRhs = sqlite3PExpr(pParse, TK_UPLUS, 
        sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
    pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);
@@ -1106,7 +1106,12 @@ int sqlite3WindowRewrite(Parse *pParse, Select *p){
    sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab);
  }

-  assert( rc==SQLITE_OK || pParse->nErr!=0 );
+  if( rc ){
+    if( pParse->nErr==0 ){
+      assert( pParse->db->mallocFailed );
+      sqlite3ErrorToParser(pParse->db, SQLITE_NOMEM);
+    }
+  }
  return rc;
 }

@@ -553,9 +553,8 @@ do_execsql_test 13.1.3 {

 sqlite3_db_config db DEFENSIVE 0
 do_execsql_test 13.1.4 {
-  PRAGMA writable_schema = ON;
+  PRAGMA writable_schema = 1;
  UPDATE sqlite_master SET sql = 'CREATE INDEX x1i ON x1(j)' WHERE name='x1i';
-  PRAGMA writable_schema = OFF;
 } {}

 do_catchsql_test 13.1.5 {
@@ -563,9 +562,7 @@ do_catchsql_test 13.1.5 {
 } {1 {error in index x1i: no such column: j}}

 do_execsql_test 13.1.6 {
-  PRAGMA writable_schema = ON;
  UPDATE sqlite_master SET sql = '' WHERE name='x1i';
-  PRAGMA writable_schema = OFF;
 } {}

 do_catchsql_test 13.1.7 {
@@ -573,9 +570,7 @@ do_catchsql_test 13.1.7 {
 } {1 {error in index x1i: }}

 do_execsql_test 13.1.8 {
-  PRAGMA writable_schema = ON;
  DELETE FROM sqlite_master WHERE name = 'x1i';
-  PRAGMA writable_schema = OFF;
 }

 do_execsql_test 13.2.0 {
@@ -866,69 +861,5 @@ do_execsql_test 23.0 {

 } {ok {CREATE TABLE t1("x" "b",c)}}

-# 2022-02-04
-# Do not complain about syntax errors in the schema if
-# in PRAGMA writable_schema=ON mode.
-#
-reset_db
-do_execsql_test 23.0 {
-  CREATE TABLE t1(a INT, b REAL, c TEXT, d BLOB, e ANY);
-  CREATE INDEX t1abx ON t1(a, b, a+b) WHERE c IS NOT NULL;
-  CREATE VIEW t2 AS SELECT a+10, b*5.0, xyz FROM t1; -- unknown column "xyz"
-  CREATE TABLE schema_copy(name TEXT, sql TEXT);
-  INSERT INTO schema_copy(name,sql) SELECT name, sql FROM sqlite_schema WHERE sql IS NOT NULL;
-} {}
-do_catchsql_test 23.1 {
-  ALTER TABLE t1 RENAME COLUMN e TO eeee;
-} {1 {error in view t2: no such column: xyz}}
-do_execsql_test 23.2 {
-  SELECT name, sql FROM sqlite_master
-    EXCEPT SELECT name, sql FROM schema_copy;
-} {}
-do_execsql_test 23.3 {
-  BEGIN;
-  PRAGMA writable_schema=ON;
-  ALTER TABLE t1 RENAME COLUMN e TO eeee;
-  PRAGMA writable_schema=OFF;
-  SELECT name FROM sqlite_master
-     WHERE (name, sql) NOT IN (SELECT name, sql FROM schema_copy);
-  ROLLBACK;
-} {t1}
-do_execsql_test 23.10 {
-  DROP VIEW t2;
-  CREATE TRIGGER r3 AFTER INSERT ON t1 BEGIN
-    INSERT INTO t3(x,y) VALUES(new.a, new.b);
-    INSERT INTO t4(p) VALUES(new.c);    -- no such table "t4"
-  END;
-  DELETE FROM schema_copy;
-  INSERT INTO schema_copy(name,sql) SELECT name, sql FROM sqlite_schema WHERE sql IS NOT NULL;
-} {}
-do_catchsql_test 23.11 {
-  ALTER TABLE t1 RENAME COLUMN e TO eeee;
-} {1 {error in trigger r3: no such table: main.t3}}
-do_execsql_test 23.12 {
-  SELECT name, sql FROM sqlite_master
-    EXCEPT SELECT name, sql FROM schema_copy;
-} {}
-do_execsql_test 23.13 {
-  BEGIN;
-  PRAGMA writable_schema=ON;
-  ALTER TABLE t1 RENAME COLUMN e TO eeee;
-  PRAGMA writable_schema=OFF;
-  SELECT name FROM sqlite_master
-     WHERE (name, sql) NOT IN (SELECT name, sql FROM schema_copy);
-  ROLLBACK;
-} {t1}
-do_execsql_test 23.20 {
-  CREATE TABLE t4(id INTEGER PRIMARY KEY, c1 INT, c2 INT);
-  CREATE VIEW t4v1 AS SELECT id, c1, c99 FROM t4;
-  DELETE FROM schema_copy;
-  INSERT INTO schema_copy SELECT name, sql FROM sqlite_schema;
-  BEGIN;
-  PRAGMA writable_schema=ON;
-  ALTER TABLE t4 RENAME to t4new;
-  SELECT name FROM sqlite_schema WHERE (name,sql) NOT IN (SELECT * FROM schema_copy);
-  ROLLBACK;
-} {t4new}

 finish_test
@@ -26,11 +26,6 @@ do_execsql_test 1.0 {
 }
 faultsim_save_and_close

-set ::TMPDBERROR [list 1 \
-  {unable to open a temporary database file for storing temporary tables}
-]
-
-
 do_faultsim_test 1 -prep {
  faultsim_restore_and_reopen
 } -body {
@@ -38,7 +33,7 @@ do_faultsim_test 1 -prep {
    ALTER TABLE t1 RENAME abcd TO dcba
  }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}}
 }

 catch {db close}
@@ -57,7 +52,7 @@ do_faultsim_test 2 -prep {
    ALTER TABLE t1 RENAME abcd TO dcba
  }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}}
 }


@@ -75,7 +70,7 @@ do_faultsim_test 3 -prep {
    ALTER TABLE t1 RENAME abcd TO dcba
  }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}}
 }

 reset_db
@@ -100,7 +95,7 @@ do_faultsim_test 4 -faults oom-* -prep {
    ALTER TABLE rr RENAME a TO c;
  }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}} 
 }

 reset_db
@@ -121,7 +116,7 @@ do_faultsim_test 5 -faults oom-* -prep {
    ALTER TABLE rr RENAME TO c;
  }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}} 
 }

 finish_test
@@ -21,10 +21,6 @@ ifcapable !altertable {
  return
 }

-set ::TMPDBERROR [list 1 \
-  {unable to open a temporary database file for storing temporary tables}
-]
-
 do_execsql_test 1.0 {
  CREATE TABLE x1(
      one, two, three, PRIMARY KEY(one), 
@@ -44,7 +40,7 @@ do_faultsim_test 1 -prep {
 } -body {
  execsql { ALTER TABLE t1 DROP COLUMN c }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}}
 }

 #-------------------------------------------------------------------------
@@ -76,7 +72,7 @@ do_faultsim_test 2.2 -prep {
    ALTER TABLE t2 RENAME TO t2x;
  }
 } -test {
-  faultsim_test_result {0 {}} $::TMPDBERROR
+  faultsim_test_result {0 {}}
 }

 finish_test
@@ -355,7 +355,7 @@ do_execsql_test 8.5 {
 reset_db
 do_catchsql_test 8.6 {
  CREATE TABLE t0(c0);
-  CREATE INDEX i0 ON t0(likelihood(1,2) AND 0);
+  CREATE INDEX i0 ON t0(LIKELIHOOD(1,2) AND 0);
  ALTER TABLE t0 RENAME TO t1;
  SELECT sql FROM sqlite_master WHERE name='i0';
 } {1 {error in index i0: second argument to likelihood() must be a constant between 0.0 and 1.0}}
@@ -969,13 +969,4 @@ foreach {tn file rc} {
  db2 close
 }

-# 2021-01-31 https://sqlite.org/forum/forumpost/8b39fbf3e7
-#
-do_test backup-11.1 {
-  sqlite3 db1 :memory:
-  sqlite3 db2 :memory:
-  sqlite3_backup B db1 main db2 temp
-  B finish
-} {SQLITE_OK}
-
 finish_test
@@ -29,10 +29,7 @@ proc vtab_command {method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      
+      set clist [lindex $args 0]
      if {[llength $clist]!=1} { error "unexpected constraint list" }
      catch { array unset C }
      array set C [lindex $clist 0]
@@ -79,13 +76,10 @@ proc t1_vtab {mode method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-
      set SQL_FILTER {SELECT * FROM t1x WHERE a='%1%'}
      set SQL_SCAN   {SELECT * FROM t1x}

+      set clist [lindex $args 0]
      set idx 0
      for {set idx 0} {$idx < [llength $clist]} {incr idx} {
        array unset C
@@ -183,10 +177,7 @@ proc vtab_command {method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      
+      set clist [lindex $args 0]
      #puts $clist
      set W [list]
      set U [list]
@@ -296,17 +287,12 @@ proc vtab_command {method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      
+      set clist [lindex $args 0]
      lappend ::bestindex_calls $clist
      set ret "cost 1000000 idxnum 555"
      for {set i 0} {$i < [llength $clist]} {incr i} {
        array set C [lindex $clist $i]
-        if {$C(usable)} { 
-          lappend ret use $i 
-        }
+        if {$C(usable)} { lappend ret use $i }
      }
      return $ret
    }
@@ -47,10 +47,7 @@ proc vtab_cmd {tbl cols method args} {
      return "CREATE TABLE $tbl ([join $cols ,])"
    }
    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
+      foreach {clist orderby mask} $args {}

      set cons [list]
      set used [list]
@@ -34,10 +34,7 @@ proc vtab_cmd {bOmit method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
+      foreach {clist orderby mask} $args {}

      set ret [list]
      set use use
@@ -48,10 +48,7 @@ proc vtab_cmd {param method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
+      foreach {clist orderby mask} $args {}

      set ret [list]

@@ -138,11 +135,7 @@ proc vtab_command {method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
-      
+      set clist [lindex $args 0]
      if {[llength $clist]!=1} { error "unexpected constraint list" }
      catch { array unset C }
      array set C [lindex $clist 0]
@@ -14,7 +14,7 @@

 set testdir [file dirname $argv0]
 source $testdir/tester.tcl
-set testprefix bestindex5
+set testprefix bestindex4

 ifcapable !vtab {
  finish_test
@@ -44,10 +44,7 @@ proc vtab_cmd {method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
+      foreach {clist orderby mask} $args {}

      set cost 1000000.0
      set ret [list]
@@ -28,11 +28,7 @@ proc vtab_command {src method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
-
+      set clist [lindex $args 0]
      set wlist 1

      set iCons 0
@@ -28,11 +28,7 @@ proc vtab_command {src method args} {
    }

    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      set mask [$hdl mask]
-      
+      set clist [lindex $args 0]
      set iCons 0
      set ret [list]
      foreach cons $clist {
@@ -1,463 +0,0 @@
-# 2020-01-29
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#    May you do good and not evil.
-#    May you find forgiveness for yourself and forgive others.
-#    May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# 
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix bestindex8
-
-ifcapable !vtab {
-  finish_test
-  return
-}
-
-register_tcl_module db
-
-proc vtab_command {src method args} {
-  switch -- $method {
-    xConnect {
-      return "CREATE TABLE xxx(a, b)"
-    }
-
-    xBestIndex {
-      set hdl [lindex $args 0]
-      set clist [$hdl constraints]
-      set orderby [$hdl orderby]
-      lappend ::lBestIndexDistinct [$hdl distinct]
-
-      #puts "ORDERBY: $orderby" 
-      set iCons 0
-      set ret [list]
-      foreach cons $clist {
-        catch { array unset C }
-        array set C $cons
-        if {$C(usable)} {
-          lappend ret use $iCons
-        }
-        incr iCons
-      }
-      if {$orderby=="{column 0 desc 0} {column 1 desc 0}"
-       || $orderby=="{column 0 desc 0}"
-      } {
-        lappend ret orderby 1
-        lappend ret idxnum 1
-        set ::lOrderByConsumed 1
-      }
-      return $ret
-    }
-
-    xFilter {
-      set idxnum [lindex $args 0]
-      if {$idxnum} {
-        return [list sql "SELECT rowid, a, b FROM $src order by 2, 3"]
-      }
-      return [list sql "SELECT rowid, a, b FROM $src"]
-    }
-
-  }
-
-  return {}
-}
-
-do_execsql_test 1.0 {
-  CREATE TABLE t1(a, b);
-  CREATE INDEX i1 ON t1(a, b);
-  INSERT INTO t1 VALUES('a', 'b'), ('c', 'd');
-  INSERT INTO t1 VALUES('a', 'b'), ('c', 'd');
-  CREATE VIRTUAL TABLE vt1 USING tcl(vtab_command t1);
-
-  CREATE TABLE t0(c0);
-  INSERT INTO t0(c0) VALUES (1), (0);
-}
-
-foreach {tn sql bDistinct idxinsert bConsumed res} {
-  1 "SELECT a, b FROM vt1"                              0 0 0 {a b c d a b c d}
-  2 "SELECT DISTINCT a, b FROM vt1"                     2 1 1 {a b c d}
-  3 "SELECT DISTINCT a FROM vt1"                        2 1 1 {a c}
-  4 "SELECT DISTINCT b FROM vt1"                        2 1 0 {b d}
-  5 "SELECT DISTINCT b FROM vt1 ORDER BY a"             0 1 1 {b d}
-  6 "SELECT DISTINCT t0.c0 FROM vt1, t0 ORDER BY vt1.a" 0 1 1 {1 0}
-  7 "SELECT DISTINCT a, b FROM vt1 ORDER BY a, b"       1 0 1 {a b c d}
-  8 "SELECT DISTINCT a, b FROM vt1 ORDER BY a"          0 1 1 {a b c d}
-  9 "SELECT DISTINCT a FROM vt1 ORDER BY a, b"          0 1 1 {a c}
-
- 10 "SELECT DISTINCT a, b FROM vt1 WHERE b='b'"         2 1 1 {a b}
- 11 "SELECT DISTINCT a, b FROM vt1 WHERE +b='b'"        2 1 1 {a b}
-} {
-  set ::lBestIndexDistinct ""
-  set ::lOrderByConsumed 0
-  do_execsql_test 1.$tn.1 $sql $res
-  do_test 1.$tn.2 {
-    set ::lBestIndexDistinct
-  } $bDistinct
-  do_test 1.$tn.3 {
-    expr {[lsearch [execsql "explain $sql"] IdxInsert]>=0}
-  } $idxinsert
-  do_test 1.$tn.4 {
-    set ::lOrderByConsumed
-  } $bConsumed
-}
-
-#-------------------------------------------------------------------------
-reset_db
-register_tcl_module db
-
-proc vtab_command {src method args} {
-  switch -- $method {
-    xConnect {
-      return "CREATE TABLE xxx(a, b)"
-    }
-
-    xBestIndex {
-      set hdl [lindex $args 0]
-      set ret [list]
-
-      set iCons 0
-      foreach cons [$hdl constraints] {
-        array set C $cons
-        if {($C(op)=="limit" || $C(op)=="offset") && $C(usable)} {
-          lappend ret use $iCons
-        }
-        incr iCons
-      }
-
-      return $ret
-    }
-
-    xFilter {
-      lappend ::lFilterArgs [lindex $args 2]
-      return [list sql "SELECT rowid, a, b FROM $src"]
-    }
-
-  }
-
-  return {}
-}
-
-do_execsql_test 2.0 {
-  CREATE TABLE t1(a, b);
-  CREATE INDEX i1 ON t1(a, b);
-  CREATE VIRTUAL TABLE vt1 USING tcl(vtab_command t1);
-}
-
-do_test 2.1 {
-  set ::lFilterArgs [list]
-  execsql { SELECT * FROM vt1 LIMIT 10 }
-  set ::lFilterArgs
-} {10}
-
-do_test 2.2 {
-  set ::lFilterArgs [list]
-  execsql { SELECT * FROM vt1 LIMIT 5 OFFSET 50 }
-  set ::lFilterArgs
-} {{5 50}}
-
-do_test 2.3 {
-  set ::lFilterArgs [list]
-  execsql { SELECT * FROM vt1 ORDER BY a, b LIMIT 1 OFFSET 1 }
-  set ::lFilterArgs
-} {{1 1}}
-
-do_test 2.4 {
-  set ::lFilterArgs [list]
-  execsql { SELECT * FROM vt1 ORDER BY a, +b LIMIT 1 OFFSET 1 }
-  set ::lFilterArgs
-} {{}}
-
-#-------------------------------------------------------------------------
-reset_db
-register_tcl_module db
-
-proc vtab_command {src method args} {
-  switch -- $method {
-    xConnect {
-      return "CREATE TABLE xxx(a, b)"
-    }
-
-    xBestIndex {
-      set hdl [lindex $args 0]
-      set lCons [$hdl constraints]
-
-      set ret [list]
-      for {set i 0} {$i < [llength $lCons]} {incr i} {
-        array set C [lindex $lCons $i]
-        if {$C(usable)} {
-          lappend ret use $i
-          $hdl in $i 1
-        }
-      }
-      return $ret
-    }
-
-    xFilter {
-      set lArg [lindex $args 2]
-      lappend ::lFilterArg {*}$lArg
-      return [list sql "SELECT rowid, a, b FROM $src"]
-    }
-
-  }
-
-  return {}
-}
-
-do_execsql_test 3.0 {
-  CREATE TABLE t1(a, b);
-  CREATE INDEX i1 ON t1(a, b);
-  CREATE VIRTUAL TABLE vt1 USING tcl(vtab_command t1);
-}
-
-foreach {tn sql lfa} {
-  1 "SELECT * FROM vt1 WHERE b IN (10, 20, 30)" {{10 20 30}}
-  2 "SELECT * FROM vt1 WHERE b IN ('abc', 'def')" {{abc def}}
-  3 "SELECT * FROM vt1 WHERE a IS NULL AND b IN ('abc', 'def')" {{} {abc def}}
-  4 "SELECT * FROM vt1 WHERE a IN (1,2,3) AND b IN ('abc', 'def')" 
-     {{1 2 3} {abc def}}
-
-  5 "SELECT * FROM vt1 
-     WHERE a IN (SELECT 1 UNION SELECT 2) AND b IN ('abc', 'def')"
-     {{1 2} {abc def}}
-
-  6 "SELECT * FROM vt1 
-     WHERE b IN ('abc', 'def') AND a IN (SELECT 1 UNION SELECT 2)"
-     {{abc def} {1 2}}
-} {
-  do_test 3.$tn {
-    set ::lFilterArg [list]
-    execsql $sql
-    set ::lFilterArg
-  } $lfa
-}
-
-#explain_i { SELECT * FROM vt1 WHERE b IN (10, 20, 30) }
-
-#-------------------------------------------------------------------------
-reset_db
-register_tcl_module db
-
-proc vtab_command {src method args} {
-  switch -- $method {
-    xConnect {
-      return "CREATE TABLE xxx(a, b, c)"
-    }
-
-    xBestIndex {
-      set hdl [lindex $args 0]
-      set lCons [$hdl constraints]
-
-      set ret [list]
-      for {set i 0} {$i < [llength $lCons]} {incr i} {
-        lappend ::lBestIndexRhs [$hdl rhs_value $i -]
-      }
-      return $ret
-    }
-
-    xFilter {
-      return [list sql "SELECT rowid, a, b, c FROM $src"]
-    }
-
-  }
-
-  return {}
-}
-
-do_execsql_test 4.0 {
-  CREATE TABLE t1(a, b, c);
-  CREATE VIRTUAL TABLE vt1 USING tcl(vtab_command t1);
-}
-
-foreach {tn sql lbir} {
-  1 "SELECT * FROM vt1 WHERE b = 10" {10}
-  2 "SELECT * FROM vt1 WHERE a = 'abc' AND b < 30" {abc 30}
-  3 "SELECT * FROM vt1 WHERE a = 'abc' AND b < 30+2" {abc -}
-  4 "SELECT * FROM vt1 WHERE a IN (1,2,3) AND b < 30+2" {- -}
-  5 "SELECT * FROM vt1 WHERE a IS 111 AND b < 30+2" {111 -}
-} {
-  do_test 4.$tn {
-    set ::lBestIndexRhs [list]
-    execsql $sql
-    set ::lBestIndexRhs
-  } $lbir
-}
-
-#-------------------------------------------------------------------------
-reset_db
-db cache size 0
-register_tcl_module db
-
-set ::vtab_handle_in 1
-proc vtab_command {src method args} {
-  switch -- $method {
-    xConnect {
-      return "CREATE TABLE xxx(a, b, c)"
-    }
-
-    xBestIndex {
-      set lCols [list a b c]
-
-      set hdl [lindex $args 0]
-      set lCons [$hdl constraints]
-      set lOrder [$hdl order]
-
-      set L ""
-      set O ""
-      set W [list]
-      set a 0
-      for {set i 0} {$i < [llength $lCons]} {incr i} {
-        array set C [lindex $lCons $i]
-        if {$C(usable)} {
-          if { $C(op)=="eq" } {
-            set bIn 0
-            if {$::vtab_handle_in} { set bIn [$hdl in $i 1] }
-            if {$bIn} {
-              lappend W "[lindex $lCols $C(column)] IN (%I$a%)"
-            } else {
-              lappend W "[lindex $lCols $C(column)] = %$a%"
-            }
-            lappend ret omit $i
-          }
-          if { $C(op)=="limit"  } { set L " LIMIT %$a%"  ; lappend ret use $i }
-          if { $C(op)=="offset" } { set O " OFFSET %$a%" ; lappend ret use $i }
-          incr a
-        }
-      }
-
-      set order ""
-      set selectlist "rowid, a, b, c"
-      if {[llength $lOrder]} {
-        array set sl [list]
-        set lO [list]
-        foreach s $lOrder {
-          array set C $s
-          set ad ""
-          if {$C(desc)} { set ad " DESC" }
-          lappend lO "[lindex $lCols $C(column)]$ad"
-          set sl($C(column)) 1
-        }
-        if {[$hdl distinct]==2} {
-          set selectlist "DISTINCT 0"
-          foreach i {0 1 2} {
-            if {[info exists sl($i)]} {
-              append selectlist ", [lindex $lCols $i]"
-            } else {
-              append selectlist ", 0"
-            }
-          }
-        } else {
-          set order " ORDER BY [join $lO ,]"
-        }
-      }
-
-      set where ""
-      if {[llength $W]} { set where " WHERE [join $W { AND }]" }
-      set sql "SELECT $selectlist FROM $src$where$order$L$O"
-
-      lappend ret idxStr $sql
-      return $ret
-    }
-
-    xFilter {
-      foreach {idxnum idxstr lArg} $args {}
-      set ii 0
-      set sql $idxstr
-      foreach a $lArg {
-        set sql [string map [list %$ii% $a] $sql]
-        set sql [string map [list %I$ii% [join $a ,]] $sql]
-        incr ii
-      }
-      lappend ::lFilterSql $sql
-
-      if {[regexp {OFFSET (.*)$} $sql -> off]} {
-        set real_sql "
-          WITH c(i) AS ( SELECT 1 UNION ALL SELECT i+1 FROM c WHERE i<$off )
-          SELECT 0,0,0,0 FROM c
-          UNION ALL SELECT * FROM (
-            $sql
-          )
-        "
-      } else {
-        set real_sql $sql
-      }
-
-      return [list sql $real_sql]
-    }
-
-  }
-
-  return {}
-}
-
-do_execsql_test 5.0 {
-  CREATE TABLE t1(a, b, c);
-  CREATE VIRTUAL TABLE vt1 USING tcl(vtab_command t1);
-  INSERT INTO t1 VALUES(1, 2, 3);
-  INSERT INTO t1 VALUES(2, 3, 4);
-  INSERT INTO t1 VALUES(3, 4, 5);
-  INSERT INTO t1 VALUES(1, 5, 6);
-  INSERT INTO t1 VALUES(2, 6, 7);
-  INSERT INTO t1 VALUES(3, 7, 8);
-  INSERT INTO t1 VALUES(1, 8, 9);
-  INSERT INTO t1 VALUES(2, 9, 0);
-}
-
-proc do_vtab_test {tn sql vtsql {res {}}} {
-  set ::lFilterSql [list]
-  uplevel [list do_execsql_test $tn.1 $sql $res]
-  uplevel [list do_test $tn.2 {set ::lFilterSql} [list {*}$vtsql]]
-}
-
-do_vtab_test 5.1.1 {
-  SELECT DISTINCT a FROM vt1
-} {
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1}
-} {1 2 3}
-
-do_vtab_test 5.1.2 {
-  SELECT DISTINCT a FROM vt1 ORDER BY a
-} {
-  {SELECT rowid, a, b, c FROM t1 ORDER BY a}
-} {1 2 3}
-
-do_vtab_test 5.1.3 {
-  SELECT DISTINCT a FROM vt1 WHERE c IN (4,5,6,7,8)
-} {
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1 WHERE c IN (4,5,6,7,8)}
-} {2 3 1}
-
-set ::vtab_handle_in 0
-do_vtab_test 5.1.4 {
-  SELECT  DISTINCT a FROM vt1 WHERE c IN (4,5,6,7,8)
-} {
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1 WHERE c = 4}
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1 WHERE c = 5}
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1 WHERE c = 6}
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1 WHERE c = 7}
-  {SELECT DISTINCT 0, a, 0, 0 FROM t1 WHERE c = 8}
-} {2 3 1}
-
-set ::vtab_handle_in 1
-do_vtab_test 5.1.5a {
-  SELECT a, b, c FROM vt1 WHERE c IN (4,5,6,7,8) LIMIT 2 OFFSET 2
-} {
-  {SELECT rowid, a, b, c FROM t1 WHERE c IN (4,5,6,7,8) LIMIT 2 OFFSET 2}
-} {1 5 6 2 6 7}
-
-set ::vtab_handle_in 0
-do_vtab_test 5.1.5b {
-  SELECT a, b, c FROM vt1 WHERE c IN (4,5,6,7,8) LIMIT 2 OFFSET 2
-} {
-  {SELECT rowid, a, b, c FROM t1 WHERE c = 4}
-  {SELECT rowid, a, b, c FROM t1 WHERE c = 5}
-  {SELECT rowid, a, b, c FROM t1 WHERE c = 6}
-  {SELECT rowid, a, b, c FROM t1 WHERE c = 7}
-} {1 5 6 2 6 7}
-set ::vtab_handle_in 1
-
-finish_test
@@ -1,63 +0,0 @@
-# 2022 Feb 10
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#    May you do good and not evil.
-#    May you find forgiveness for yourself and forgive others.
-#    May you share freely, never taking more than you give.
-#
-#***********************************************************************
-#
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-set testprefix bind2
-
-
-# Test that using bind_value() on a REAL sqlite3_value that was stored
-# as an INTEGER works properly.
-#
-#   1.1: An IntReal value read from a table,
-#   1.2: IntReal values obtained via the sqlite3_preupdate_old|new() 
-#        interfaces.
-# 
-do_execsql_test 1.0 { 
-  CREATE TABLE t1(a REAL);
-  INSERT INTO t1 VALUES(42.0);
-  SELECT * FROM t1;
-} {42.0}
-
-do_test 1.1 {
-  set stmt [sqlite3_prepare db "SELECT ?" -1 tail]
-  sqlite3_bind_value_from_select $stmt 1 "SELECT a FROM t1"
-  sqlite3_step $stmt
-  sqlite3_column_text $stmt 0
-} {42.0}
-sqlite3_finalize $stmt
-
-ifcapable !preupdate {
-  finish_test
-  return
-}
-
-proc preup {args} {
-  set stmt [sqlite3_prepare db "SELECT ?" -1 tail]
-  sqlite3_bind_value_from_preupdate $stmt 1 old 0
-  sqlite3_step $stmt
-  lappend ::reslist [sqlite3_column_text $stmt 0]
-  sqlite3_reset $stmt
-  sqlite3_bind_value_from_preupdate $stmt 1 new 0
-  sqlite3_step $stmt
-  lappend ::reslist [sqlite3_column_text $stmt 0]
-  sqlite3_finalize $stmt
-}
-db preupdate hook preup
-
-do_test 1.2 {
-  set ::reslist [list]
-  execsql { UPDATE t1 SET a=43; }
-  set ::reslist
-} {42.0 43.0}
-
-finish_test
@@ -100,32 +100,8 @@ proc test_is_readonly {testname sql truth} {
    sqlite3_finalize $STMT
    set rc
  } $sql] $truth
-
-  # EVIDENCE-OF: R-61212-30018 If prepared statement X is an EXPLAIN or
-  # EXPLAIN QUERY PLAN statement, then sqlite3_stmt_readonly(X) returns
-  # the same value as if the EXPLAIN or EXPLAIN QUERY PLAN prefix were
-  # omitted.
-  #
-  do_test $testname.explain [format {
-    set DB [sqlite3_connection_pointer db]
-    set STMT [sqlite3_prepare $DB {EXPLAIN %s} -1 TAIL]
-    set rc [sqlite3_stmt_readonly $STMT]
-    sqlite3_finalize $STMT
-    set rc
-  } $sql] $truth
-  do_test $testname.eqp [format {
-    set DB [sqlite3_connection_pointer db]
-    set STMT [sqlite3_prepare $DB {EXPLAIN QUERY PLAN %s} -1 TAIL]
-    set rc [sqlite3_stmt_readonly $STMT]
-    sqlite3_finalize $STMT
-    set rc
-  } $sql] $truth
 }

-# EVIDENCE-OF: R-23332-64992 The sqlite3_stmt_readonly(X) interface
-# returns true (non-zero) if and only if the prepared statement X makes
-# no direct changes to the content of the database file.
-#
 test_is_readonly capi3d-2.1 {SELECT * FROM sqlite_master} 1
 test_is_readonly capi3d-2.2 {CREATE TABLE t1(x)} 0
 db eval {CREATE TABLE t1(x)}
@@ -144,68 +120,6 @@ do_test capi3-2.49 {
 } 1


-# EVIDENCE-OF: R-04929-09147 This routine returns false if there is any
-# possibility that the statement might change the database file.
-#
-# EVIDENCE-OF: R-13288-53765 A false return does not guarantee that the
-# statement will change the database file.
-#
-# EVIDENCE-OF: R-22182-18548 For example, an UPDATE statement might have
-# a WHERE clause that makes it a no-op, but the sqlite3_stmt_readonly()
-# result would still be false.
-#
-# EVIDENCE-OF: R-50998-48593 Similarly, a CREATE TABLE IF NOT EXISTS
-# statement is a read-only no-op if the table already exists, but
-# sqlite3_stmt_readonly() still returns false for such a statement.
-#
-db eval {
-  CREATE TABLE t2(a,b,c);
-  INSERT INTO t2 VALUES(1,2,3);
-}
-test_is_readonly capi3d-2.11 {UPDATE t2 SET a=a+1 WHERE false} 0
-test_is_readonly capi3d-2.12 {CREATE TABLE IF NOT EXISTS t2(x,y)} 0
-
-
-# EVIDENCE-OF: R-37014-01401 The ATTACH and DETACH statements also cause
-# sqlite3_stmt_readonly() to return true since, while those statements
-# change the configuration of a database connection, they do not make
-# changes to the content of the database files on disk.
-#
-test_is_readonly capi3d-2.13 {ATTACH ':memory:' AS mem1} 1
-db eval {ATTACH ':memory:' AS mem1}
-test_is_readonly capi3d-2.14 {DETACH mem1} 1
-db eval {DETACH mem1}
-
-# EVIDENCE-OF: R-07474-04783 Transaction control statements such as
-# BEGIN, COMMIT, ROLLBACK, SAVEPOINT, and RELEASE cause
-# sqlite3_stmt_readonly() to return true, since the statements
-# themselves do not actually modify the database but rather they control
-# the timing of when other statements modify the database.
-#
-test_is_readonly capi3d-2.15 {BEGIN} 1
-test_is_readonly capi3d-2.16 {COMMIT} 1
-test_is_readonly capi3d-2.17 {SAVEPOINT one} 1
-test_is_readonly capi3d-2.18 {RELEASE one} 1
-
-# EVIDENCE-OF: R-36961-63052 The sqlite3_stmt_readonly() interface
-# returns true for BEGIN since BEGIN merely sets internal flags, but the
-# BEGIN IMMEDIATE and BEGIN EXCLUSIVE commands do touch the database and
-# so sqlite3_stmt_readonly() returns false for those commands.
-#
-test_is_readonly capi3d-2.19 {BEGIN IMMEDIATE} 0
-test_is_readonly capi3d-2.20 {BEGIN EXCLUSIVE} 0
-
-# EVIDENCE-OF: R-21769-42523 For example, if an application defines a
-# function "eval()" that calls sqlite3_exec(), then the following SQL
-# statement would change the database file through side-effects: SELECT
-# eval('DELETE FROM t1') FROM t2; But because the SELECT statement does
-# not change the database file directly, sqlite3_stmt_readonly() would
-# still return true.
-#
-proc evalsql {sql} {db eval $sql}
-db func eval evalsql
-test_is_readonly capi3d-2.21 {SELECT eval('DELETE FROM t1') FROM t2} 1
-
 # Tests for the is-explain interface.
 #
 proc test_is_explain {testname sql truth} {
@@ -239,70 +239,138 @@ datetest 5.13 {datetime('1994-04-16 14:00:00Zulu')} NULL
 datetest 5.14 {datetime('1994-04-16 14:00:00Z +05:00')} NULL
 datetest 5.15 {datetime('1994-04-16 14:00:00 +05:00 Z')} NULL

-# localtime->utc and utc->localtime conversions.
+# localtime->utc and utc->localtime conversions.  These tests only work
+# if the localtime is in the US Eastern Time (the time in Charlotte, NC
+# and in New York.)
 #
-# Use SQLITE_TESTCTRL_LOCALTIME_FAULT=2 to set an alternative localtime_r()
-# implementation that is not locale-dependent.  This testing localtime_r()
-# operates as follows:
+# On non-Vista Windows platform, '2006-03-31' is treated incorrectly as being
+# in DST giving a 4 hour offset instead of 5.  In 2007, DST was extended to 
+# start three weeks earlier (second Sunday in March) and end one week
+# later (first Sunday in November).  Older Windows systems apply this
+# new rule incorrectly to dates prior to 2007.
 #
-#     (1)  Localtime is 30 minutes earlier than (west of) UTC on
-#          even days (counting from 1970-01-01)
+# It might be argued that this is masking a problem on non-Vista Windows
+# platform.  A ticket has already been opened for this issue 
+# (http://www.sqlite.org/cvstrac/tktview?tn=2322).  This is just to prevent
+# more confusion/reports of the issue.
 #
-#     (2)  Localtime is 30 minutes later than (east of) UTC on odd days.
-#
-#     (3)  The function fails for the specific date/time value
-#          of 2000-05-29 14:16:00 in order to test the ability of
-#          SQLite to deal with localtime_r() failures.
-#
-proc local_to_utc {tn utc local} {
-  do_execsql_test date-$tn "SELECT datetime('$utc','localtime')" [list $local]
-}
-proc utc_to_local {tn local utc} {
-  do_execsql_test date-$tn "SELECT datetime('$local','utc')" [list $utc]
+
+# $tzoffset_old should be 5 if DST is working correctly.
+set tzoffset_old [db one {
+  SELECT CAST(24*(julianday('2006-03-31') -
+                  julianday('2006-03-31','localtime'))+0.5
+              AS INT)
+}]
+
+# $tzoffset_new should be 4 if DST is working correctly.
+set tzoffset_new [db one {
+  SELECT CAST(24*(julianday('2007-03-31') -
+                  julianday('2007-03-31','localtime'))+0.5
+              AS INT)
+}]
+
+# Warn about possibly broken Windows DST implementations.
+if {$::tcl_platform(platform)=="windows" && $tzoffset_new==4 && $tzoffset_old==4} {
+  puts "******************************************************************"
+  puts "N.B.:  The DST support provided by your current O/S seems to be"
+  puts "suspect in that it is reporting incorrect DST values for dates"
+  puts "prior to 2007.  This is the known case for most (all?) non-Vista"
+  puts "Windows versions.  Please see ticket #2322 for more information."
+  puts "******************************************************************"
 }

-sqlite3_test_control SQLITE_TESTCTRL_LOCALTIME_FAULT 2
-local_to_utc 6.1  {2000-10-29 12:00:00} {2000-10-29 12:30:00}
-utc_to_local 6.2  {2000-10-29 12:30:00} {2000-10-29 12:00:00}
-local_to_utc 6.3  {2000-10-30 12:00:00} {2000-10-30 11:30:00}
-utc_to_local 6.4  {2000-10-30 11:30:00} {2000-10-30 12:00:00}
+if {$tzoffset_new==4} {
+  datetest 6.1 {datetime('2000-10-29 05:59:00','localtime')}\
+      {2000-10-29 01:59:00}
+  datetest 6.1.1 {datetime('2006-10-29 05:59:00','localtime')}\
+      {2006-10-29 01:59:00}
+  datetest 6.1.2 {datetime('2007-11-04 05:59:00','localtime')}\
+      {2007-11-04 01:59:00}

-local_to_utc 6.5  {2000-10-28 23:59:59} {2000-10-28 23:29:59}
-local_to_utc 6.6  {2000-10-29 00:00:00} {2000-10-29 00:30:00}
+  # If the new and old DST rules seem to be working correctly...
+  if {$tzoffset_new==4 && $tzoffset_old==5} {
+    datetest 6.2 {datetime('2000-10-29 06:00:00','localtime')}\
+        {2000-10-29 01:00:00}
+    datetest 6.2.1 {datetime('2006-10-29 06:00:00','localtime')}\
+        {2006-10-29 01:00:00}
+  }
+  datetest 6.2.2 {datetime('2007-11-04 06:00:00','localtime')}\
+      {2007-11-04 01:00:00}

-# The previous two cases establish that no such localtime as
-# 2000-10-29 00:10:00 exists.  Verify that we get a reasonable
-# answer if we try to convert this non-existant localtime to utc?
+  # If the new and old DST rules seem to be working correctly...
+  if {$tzoffset_new==4 && $tzoffset_old==5} {
+    datetest 6.3 {datetime('2000-04-02 06:59:00','localtime')}\
+        {2000-04-02 01:59:00}
+    datetest 6.3.1 {datetime('2006-04-02 06:59:00','localtime')}\
+        {2006-04-02 01:59:00}
+  }
+  datetest 6.3.2 {datetime('2007-03-11 07:00:00','localtime')}\
+      {2007-03-11 03:00:00}
+
+  datetest 6.4 {datetime('2000-04-02 07:00:00','localtime')}\
+      {2000-04-02 03:00:00}
+  datetest 6.4.1 {datetime('2006-04-02 07:00:00','localtime')}\
+      {2006-04-02 03:00:00}
+  datetest 6.4.2 {datetime('2007-03-11 07:00:00','localtime')}\
+      {2007-03-11 03:00:00}
+      
+  datetest 6.5 {datetime('2000-10-29 01:59:00','utc')} {2000-10-29 05:59:00}
+  datetest 6.5.1 {datetime('2006-10-29 01:59:00','utc')} {2006-10-29 05:59:00}
+  datetest 6.5.2 {datetime('2007-11-04 01:59:00','utc')} {2007-11-04 05:59:00}
+
+  # If the new and old DST rules seem to be working correctly...
+  if {$tzoffset_new==4 && $tzoffset_old==5} {
+    datetest 6.6 {datetime('2000-10-29 02:00:00','utc')} {2000-10-29 07:00:00}
+    datetest 6.6.1 {datetime('2006-10-29 02:00:00','utc')} {2006-10-29 07:00:00}
+  }
+  datetest 6.6.2 {datetime('2007-11-04 02:00:00','utc')} {2007-11-04 07:00:00}
+
+  # If the new and old DST rules seem to be working correctly...
+  if {$tzoffset_new==4 && $tzoffset_old==5} {
+    datetest 6.7 {datetime('2000-04-02 01:59:00','utc')} {2000-04-02 06:59:00}
+    datetest 6.7.1 {datetime('2006-04-02 01:59:00','utc')} {2006-04-02 06:59:00}
+  }
+  datetest 6.7.2 {datetime('2007-03-11 01:59:00','utc')} {2007-03-11 06:59:00}
+
+  datetest 6.8 {datetime('2000-04-02 02:00:00','utc')} {2000-04-02 06:00:00}
+  datetest 6.8.1 {datetime('2006-04-02 02:00:00','utc')} {2006-04-02 06:00:00}
+  datetest 6.8.2 {datetime('2007-03-11 02:00:00','utc')} {2007-03-11 06:00:00}
+
+  # The 'utc' modifier is a no-op if the LHS is known to already be in UTC
+  datetest 6.9.1 {datetime('2015-12-23 12:00:00','utc')} {2015-12-23 17:00:00}
+  datetest 6.9.2 {datetime('2015-12-23 12:00:00z','utc')} {2015-12-23 12:00:00}
+  datetest 6.9.3 {datetime('2015-12-23 12:00:00-03:00','utc')} \
+         {2015-12-23 15:00:00}
+  datetest 6.9.4 {datetime('2015-12-23 12:00:00','utc','utc','utc')} \
+         {2015-12-23 17:00:00}
+
+
+  datetest 6.10 {datetime('2000-01-01 12:00:00','localtime')} \
+      {2000-01-01 07:00:00}
+  datetest 6.11 {datetime('1969-01-01 12:00:00','localtime')} \
+      {1969-01-01 07:00:00}
+  datetest 6.12 {datetime('2039-01-01 12:00:00','localtime')} \
+      {2039-01-01 07:00:00}
+  datetest 6.13 {datetime('2000-07-01 12:00:00','localtime')} \
+      {2000-07-01 08:00:00}
+  datetest 6.14 {datetime('1969-07-01 12:00:00','localtime')} \
+      {1969-07-01 07:00:00}
+  datetest 6.15 {datetime('2039-07-01 12:00:00','localtime')} \
+      {2039-07-01 07:00:00}
+  set sqlite_current_time \
+     [db eval {SELECT strftime('%s','2000-07-01 12:34:56')}]
+  datetest 6.16 {datetime('now','localtime')} {2000-07-01 08:34:56}
+  datetest 6.17 {datetime('now','localtimex')} NULL
+  datetest 6.18 {datetime('now','localtim')} NULL
+  set sqlite_current_time 0
+}
+
+# These two are a bit of a scam. They are added to ensure that 100% of
+# the date.c file is covered by testing, even when the time-zone
+# is not -0400 (the condition for running of the block of tests above).
 #
-utc_to_local 6.7  {2000-10-29 00:10:00} {2000-10-28 23:40:00}
-
-local_to_utc 6.8  {2022-02-10 23:59:59} {2022-02-11 00:29:59}
-local_to_utc 6.9  {2022-02-11 00:00:00} {2022-02-10 23:30:00}
-local_to_utc 6.10 {2022-02-10 23:45:00} {2022-02-11 00:15:00}
-local_to_utc 6.11 {2022-02-11 00:45:00} {2022-02-11 00:15:00}
-
-# The previous two cases show that two different UTC values give
-# the same localtime of 2022-02-11 00:15:00.  When converting from
-# that localtime back to UTC, we should get one or the other of
-# the two UTC values.
-#
-utc_to_local 6.12 {2022-02-11 00:15:00} {2022-02-11 00:45:00}
-
-# If localtime_r() fails, the datetime() SQL function should raise an error
-#
-do_catchsql_test date-6.20 {
-  SELECT datetime('2000-05-29 14:16:00','localtime');
-} {1 {local time unavailable}}
-
-# Modifiers work for dates that are way out of band for localtime_r()
-#
-local_to_utc 6.21 {1800-10-29 12:00:00} {1800-10-29 12:30:00}
-utc_to_local 6.22 {1800-10-29 12:30:00} {1800-10-29 12:00:00}
-local_to_utc 6.23 {3000-10-30 12:00:00} {3000-10-30 11:30:00}
-utc_to_local 6.24 {3000-10-30 11:30:00} {3000-10-30 12:00:00}
-
-# Restore the use of the OS localtime_r() before going on...
-sqlite3_test_control SQLITE_TESTCTRL_LOCALTIME_FAULT 0
+datetest 6.19 {datetime('2039-07-01 12:00:00','localtime',null)} NULL
+datetest 6.20 {datetime('2039-07-01 12:00:00','utc',null)} NULL

 # Date-time functions that contain NULL arguments return a NULL
 # result.
@@ -1,149 +0,0 @@
-# 2022-01-27
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#    May you do good and not evil.
-#    May you find forgiveness for yourself and forgive others.
-#    May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library.  The
-# focus of this file is testing date and time functions.
-#
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-# Skip this whole file if date and time functions are omitted
-# at compile-time
-#
-ifcapable {!datetime} {
-  finish_test
-  return
-}
-
-proc datetest {tnum expr result} {
-  do_test date3-$tnum [subst {
-    execsql "SELECT coalesce($expr,'NULL')"
-  }] [list $result]
-}
-set tcl_precision 15
-
-# EVIDENCE-OF: R-45708-63005 unixepoch(time-value, modifier, modifier,
-# ...)
-#
-datetest 1.1 {unixepoch('1970-01-01')} {0}
-datetest 1.2 {unixepoch('1969-12-31 23:59:59')} {-1}
-datetest 1.3 {unixepoch('2106-02-07 06:28:15')} {4294967295}
-datetest 1.4 {unixepoch('2106-02-07 06:28:16')} {4294967296}
-datetest 1.5 {unixepoch('9999-12-31 23:59:59')} {253402300799}
-datetest 1.6 {unixepoch('0000-01-01 00:00:00')} {-62167219200}
-
-# EVIDENCE-OF: R-30877-63179 The unixepoch() function returns a unix
-# timestamp - the number of seconds since 1970-01-01 00:00:00 UTC.
-#
-for {set i 1} {$i<=100} {incr i} {
-  set x [expr {int(rand()*0xfffffffff)-0xffffffff}]
-  datetest 1.7.$i "unixepoch($x,'unixepoch')==$x" {1}
-}
-
-# EVIDENCE-OF: R-62992-54137 The unixepoch() always returns an integer,
-# even if the input time-value has millisecond precision.
-#
-datetest 1.8 {unixepoch('2022-01-27 12:59:28.052')} {1643288368}
-
-# EVIDENCE-OF: R-05412-24332 If the time-value is numeric (the
-# DDDDDDDDDD format) then the 'auto' modifier causes the time-value to
-# interpreted as either a julian day number or a unix timestamp,
-# depending on its magnitude.
-#
-# EVIDENCE-OF: R-56763-40111 If the value is between 0.0 and
-# 5373484.499999, then it is interpreted as a julian day number
-# (corresponding to dates between -4713-11-24 12:00:00 and 9999-12-31
-# 23:59:59, inclusive).
-#
-# EVIDENCE-OF: R-07289-49223 For numeric values outside of the range of
-# valid julian day numbers, but within the range of -210866760000 to
-# 253402300799, the 'auto' modifier causes the value to be interpreted
-# as a unix timestamp.
-#
-# EVIDENCE-OF: R-20795-34947 Other numeric values are out of range and
-# cause a NULL return.
-#
-foreach {tn jd date} {
-  2.1  0.0              {-4713-11-24 12:00:00}
-  2.2  5373484.4999999  {9999-12-31 23:59:59}
-  2.3  2440587.5        {1970-01-01 00:00:00}
-  2.4  2440587.49998843 {1969-12-31 23:59:59}
-  2.5  2440615.7475463  {1970-01-29 05:56:28}
-
-  2.10 -1               {1969-12-31 23:59:59}
-  2.11 5373485          {1970-03-04 04:38:05}
-  2.12 -210866760000    {-4713-11-24 12:00:00}
-  2.13 253402300799     {9999-12-31 23:59:59}
-
-  2.20 -210866760001    {NULL}
-  2.21 253402300800     {NULL}
-} {
-  datetest $tn "datetime($jd,'auto')" $date
-}
-
-# EVIDENCE-OF: R-38886-35357 The 'auto' modifier is a no-op for text
-# time-values.
-#
-datetest 2.30 {date('2022-01-29','auto')==date('2022-01-29')} {1}
-
-# EVIDENCE-OF: R-53132-26856 The 'auto' modifier can be used to work
-# with date/time values even in cases where it is not known if the
-# julian day number or unix timestamp formats are in use.
-#
-do_execsql_test date3-2.40 {
-  WITH tx(timeval,datetime) AS (
-     VALUES('2022-01-27 13:15:44','2022-01-27 13:15:44'),
-           (2459607.05260275,'2022-01-27 13:15:44'),
-           (1643289344,'2022-01-27 13:15:44')
-  )
-  SELECT datetime(timeval,'auto') == datetime FROM tx;
-} {1 1 1}
-
-# EVIDENCE-OF: R-49255-55373 The "unixepoch" modifier (11) only works if
-# it immediately follows a time value in the DDDDDDDDDD format.
-#
-# EVIDENCE-OF: R-23075-39245 This modifier causes the DDDDDDDDDD to be
-# interpreted not as a Julian day number as it normally would be, but as
-# Unix Time - the number of seconds since 1970.
-#
-datetest 3.1 {datetime(2459607.05,'+1 hour','unixepoch')} {NULL}
-datetest 3.2 {datetime(2459607.05,'unixepoch','+1 hour')} {1970-01-29 12:13:27}
-
-# EVIDENCE-OF: R-21150-52363 The "julianday" modifier must immediately
-# follow the initial time-value which must be of the form DDDDDDDDD.
-#
-# EVIDENCE-OF: R-31176-64601 Any other use of the 'julianday' modifier
-# is an error and causes the function to return NULL.
-#
-# EVIDENCE-OF: R-32483-36353 The 'julianday' modifier forces the
-# time-value number to be interpreted as a julian-day number.
-#
-# EVIDENCE-OF: R-25859-20124 The only difference is that adding
-# 'julianday' forces the DDDDDDDDD time-value format, and causes a NULL
-# to be returned if any other time-value format is used.
-#
-datetest 4.1 {datetime(2459607,'julianday')}           {2022-01-27 12:00:00}
-datetest 4.2 {datetime(2459607,'+1 hour','julianday')} {NULL}
-datetest 4.3 {datetime('2022-01-27','julianday')}      {NULL}
-
-
-
-# EVIDENCE-OF: R-33431-18865 Unix timestamps for the first 63 days of
-# 1970 will be interpreted as julian day numbers.
-#
-do_execsql_test date3-5.0 {
-  WITH inc(x) AS (VALUES(-10) UNION ALL SELECT x+1 FROM inc WHERE x<100)
-  SELECT count(*) FROM inc
-  WHERE datetime('1970-01-01',format('%+d days',x))
-     <> datetime(unixepoch('1970-01-01',format('%+d days',x)),'auto');
-} {63}
-
-finish_test
@@ -493,10 +493,10 @@ do_execsql_test e_createtable-1.7.0 {
 do_createtable_tests 1.7.1 -error { %s } {
  1    "CREATE TABLE t1(a, b)"   {{table t1 already exists}}
  2    "CREATE TABLE i1(a, b)"   {{there is already an index named i1}}
-  3    "CREATE TABLE v1(a, b)"   {{view v1 already exists}}
+  3    "CREATE TABLE v1(a, b)"   {{table v1 already exists}}
  4    "CREATE TABLE auxa.tbl1(a, b)"   {{table tbl1 already exists}}
  5    "CREATE TABLE auxa.idx1(a, b)"   {{there is already an index named idx1}}
-  6    "CREATE TABLE auxa.view1(a, b)"  {{view view1 already exists}}
+  6    "CREATE TABLE auxa.view1(a, b)"  {{table view1 already exists}}
 }
 do_createtable_tests 1.7.2 {
  1    "CREATE TABLE auxa.t1(a, b)"   {}
@@ -265,10 +265,13 @@ do_execsql_test e_expr-6.4 {SELECT -72%5}  {-2}
 do_execsql_test e_expr-6.5 {SELECT 72.35%5} {2.0}

 #-------------------------------------------------------------------------
-# EVIDENCE-OF: R-15904-00746 The result of any binary operator is either
-# a numeric value or NULL, except for the || concatenation operator, and
-# the -> and ->> extract operators which evaluate to either
-# NULL or a text value.
+# Test that the results of all binary operators are either numeric or 
+# NULL, except for the || operator, which may evaluate to either a text
+# value or NULL.
+#
+# EVIDENCE-OF: R-20665-17792 The result of any binary operator is either
+# a numeric value or NULL, except for the || concatenation operator
+# which always evaluates to either NULL or a text value.
 #
 set literals {
  1 'abc'        2 'hexadecimal'       3 ''
@@ -48,9 +48,9 @@ proc do_detail_test {tn sql res} {
 ###########################################################################

 #-------------------------------------------------------------------------
-# EVIDENCE-OF: R-37672-59189 In order to use foreign key constraints in
+# EVIDENCE-OF: R-33710-56344 In order to use foreign key constraints in
 # SQLite, the library must be compiled with neither
-# SQLITE_OMIT_FOREIGN_KEY nor SQLITE_OMIT_TRIGGER defined.
+# SQLITE_OMIT_FOREIGN_KEY or SQLITE_OMIT_TRIGGER defined.
 #
 ifcapable trigger&&foreignkey {
  do_test e_fkey-1 {
@@ -372,7 +372,7 @@ integrity_check fuzz-7.5.integrity
 #----------------------------------------------------------------
 # Many CREATE and DROP TABLE statements:
 #
-set E [list table view duplicate {no such col} {ambiguous column name} {use DROP}]
+set E [list table duplicate {no such col} {ambiguous column name} {use DROP}]
 do_fuzzy_test fuzz-8.1 -template {[CreateOrDropTableOrView]} -errorlist $E

 close $::log
@@ -156,14 +156,6 @@ static struct GlobalVars {
  char zTestName[100];             /* Name of current test */
 } g;

-/*
-** Include the external vt02.c module, if requested by compile-time
-** options.
-*/
-#ifdef VT02_SOURCES
-# include "vt02.c"
-#endif
-
 /*
 ** Print an error message and quit.
 */
@@ -1060,10 +1052,6 @@ int runCombinedDbSqlInput(
  ** deserialize to do this because deserialize depends on ATTACH */
  sqlite3_set_authorizer(cx.db, block_troublesome_sql, 0);

-#ifdef VT02_SOURCES
-  sqlite3_vt02_init(cx.db, 0, 0);
-#endif
-
  /* Consistent PRNG seed */
 #ifdef SQLITE_TESTCTRL_PRNG_SEED
  sqlite3_table_column_metadata(cx.db, 0, "x", 0, 0, 0, 0, 0, 0);
@@ -328,18 +328,4 @@ do_execsql_test 8.1 {
  2 10 2
 }

-
-# 2022-01-31 dbsqlfuzz 787d9bd73164c6f0c85469e2e48b2aff19af6938
-#
-reset_db
-do_execsql_test 9.1 {
-  CREATE TABLE t1(a ,b FLOAT);
-  INSERT INTO t1 VALUES(1,1);
-  CREATE INDEX t1x1 ON t1(a,b,a,a,a,a,a,a,a,a,a,b);
-  ANALYZE sqlite_schema;
-  INSERT INTO sqlite_stat1 VALUES('t1','t1x1','648 324 81 81 81 81 81 81 81081 81 81 81');
-  ANALYZE sqlite_schema;
-  SELECT a FROM (SELECT a FROM t1 NATURAL LEFT JOIN t1) NATURAL LEFT JOIN t1 WHERE (rowid,1)<=(5,0);
-} {1}
-
 finish_test
@@ -15,6 +15,11 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl

+ifcapable !json1 {
+  finish_test
+  return
+}
+
 do_execsql_test json101-1.1.00 {
  SELECT json_array(1,2.5,null,'hello');
 } {[1,2.5,null,"hello"]}
@@ -841,13 +846,5 @@ do_execsql_test json-16.30 {
  SELECT unicode(json_extract('"\uD834\uDD1E"','$'));
 } {119070}

-# 2022-01-30 dbsqlfuzz 4678cf825d27f87c9b8343720121e12cf944b71a
-do_execsql_test json-17.1 {
-  DROP TABLE IF EXISTS t1;
-  DROP TABLE IF EXISTS t2;
-  CREATE TABLE t1(a,b,c);
-  CREATE TABLE t2(d);
-  SELECT * FROM t1 LEFT JOIN t2 ON (SELECT b FROM json_each ORDER BY 1);
-} {}

 finish_test
@@ -18,6 +18,11 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl

+ifcapable !json1 {
+  finish_test
+  return
+}
+
 do_execsql_test json102-100 {
  SELECT json_object('ex','[52,3.14159]');
 } {{{"ex":"[52,3.14159]"}}}
@@ -14,6 +14,11 @@
 set testdir [file dirname $argv0]
 source $testdir/tester.tcl

+ifcapable !json1 {
+  finish_test
+  return
+}
+
 do_execsql_test json103-100 {
  CREATE TABLE t1(a,b,c);
  WITH RECURSIVE c(x) AS (VALUES(1) UNION SELECT x+1 FROM c WHERE x<100)
@@ -15,6 +15,11 @@ set testdir [file dirname $argv0]
 source $testdir/tester.tcl
 set testprefix json104

+ifcapable !json1 {
+  finish_test
+  return
+}
+
 # This is the example from pages 2 and 3 of RFC-7396
 do_execsql_test json104-100 {
  SELECT json_patch('{
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
larrybr	b6265f854c	A WIP checkin, progress toward what .help promises FossilOrigin-Name: 4688e6dff88527dbff436b811512206d31a9695095776c4e1fdff95da0b0c4d4	2022-01-20 05:20:27 +00:00
larrybr	96b922020c	Initial help changes for .script (and enhanced .parameter) FossilOrigin-Name: a94ab403eb836d3fcb9710d22da5129f58db05d3be145bc77ce1c017761e7894	2022-01-19 21:11:23 +00:00
@@ -1 +1 @@
 .39.0
 .38.0