f68ec6b Update sqlite to 3.8.9 — HardenedBSD-pkg

HardenedBSD-pkg

rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9

HardenedBSD Package Manager

Update sqlite to 3.8.9

Baptiste Daroussin committed 11 years ago

commit f68ec6b8d88c9b557a654bdaf4b30386ae167708
parent d21816c

3 files changed +3137 -1634

modified external/sqlite/shell.c

@@ -25,6 +25,13 @@

 #endif
 /*
 ** No support for loadable extensions in VxWorks.
 */
 #if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
 # define SQLITE_OMIT_LOAD_EXTENSION 1
 #endif
 /*
 ** Enable large-file support for fopen() and friends on unix.
 */
 #ifndef SQLITE_DISABLE_LFS

@@ -59,18 +66,38 @@

 # include <readline/readline.h>
 # include <readline/history.h>
 #endif
 #if HAVE_EDITLINE
 # undef HAVE_READLINE
 # define HAVE_READLINE 1
 # include <editline/readline.h>
 #endif
 #if !HAVE_READLINE
 # define add_history(X)
 # define read_history(X)
 # define write_history(X)
 # define stifle_history(X)
 #if HAVE_EDITLINE || HAVE_READLINE
 # define shell_add_history(X) add_history(X)
 # define shell_read_history(X) read_history(X)
 # define shell_write_history(X) write_history(X)
 # define shell_stifle_history(X) stifle_history(X)
 # define shell_readline(X) readline(X)
 #elif HAVE_LINENOISE
 # include "linenoise.h"
 # define shell_add_history(X) linenoiseHistoryAdd(X)
 # define shell_read_history(X) linenoiseHistoryLoad(X)
 # define shell_write_history(X) linenoiseHistorySave(X)
 # define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
 # define shell_readline(X) linenoise(X)
 #else
 # define shell_read_history(X)
 # define shell_write_history(X)
 # define shell_stifle_history(X)
 # define SHELL_USE_LOCAL_GETLINE 1
 #endif
 #if defined(_WIN32) || defined(WIN32)
 # include <io.h>
 # include <fcntl.h>

@@ -87,10 +114,15 @@

 */
 extern int isatty(int);
 /* popen and pclose are not C89 functions and so are sometimes omitted from
 ** the <stdio.h> header */
 extern FILE *popen(const char*,const char*);
 extern int pclose(FILE*);
 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
   /* popen and pclose are not C89 functions and so are sometimes omitted from
   ** the <stdio.h> header */
   extern FILE *popen(const char*,const char*);
   extern int pclose(FILE*);
 #else
 # define SQLITE_OMIT_POPEN 1
 #endif
 #endif
 #if defined(_WIN32_WCE)

@@ -106,6 +138,26 @@ extern int pclose(FILE*);

 #define IsDigit(X)  isdigit((unsigned char)X)
 #define ToLower(X)  (char)tolower((unsigned char)X)
 /* On Windows, we normally run with output mode of TEXT so that \n characters
 ** are automatically translated into \r\n.  However, this behavior needs
 ** to be disabled in some cases (ex: when generating CSV output and when
 ** rendering quoted strings that contain \n characters).  The following
 ** routines take care of that.
 */
 #if defined(_WIN32) || defined(WIN32)
 static void setBinaryMode(FILE *out){
   fflush(out);
   _setmode(_fileno(out), _O_BINARY);
 }
 static void setTextMode(FILE *out){
   fflush(out);
   _setmode(_fileno(out), _O_TEXT);
 }
 #else
 # define setBinaryMode(X)
 # define setTextMode(X)
 #endif
 /* True if the timer is enabled */
 static int enableTimer = 0;

@@ -125,11 +177,19 @@ static sqlite3_int64 timeOfDay(void){

   return t;
 }
 #if !defined(_WIN32) && !defined(WIN32) && !defined(_WRS_KERNEL) \
  && !defined(__minux)
 #if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
 #include <sys/time.h>
 #include <sys/resource.h>
 /* VxWorks does not support getrusage() as far as we can determine */
 #if defined(_WRS_KERNEL) || defined(__RTP__)
 struct rusage {
   struct timeval ru_utime; /* user CPU time used */
   struct timeval ru_stime; /* system CPU time used */
 };
 #define getrusage(A,B) memset(B,0,sizeof(*B))
 #endif
 /* Saved resource information for the beginning of an operation */
 static struct rusage sBegin;  /* CPU time at start */
 static sqlite3_int64 iBegin;  /* Wall-clock time at start */

@@ -155,8 +215,8 @@ static double timeDiff(struct timeval *pStart, struct timeval *pEnd){

 */
 static void endTimer(void){
   if( enableTimer ){
     struct rusage sEnd;
     sqlite3_int64 iEnd = timeOfDay();
     struct rusage sEnd;
     getrusage(RUSAGE_SELF, &sEnd);
     printf("Run Time: real %.3f user %f sys %f\n",
        (iEnd - iBegin)*0.001,

@@ -310,7 +370,7 @@ static FILE *iotrace = 0;

 ** is written to iotrace.
 */
 #ifdef SQLITE_ENABLE_IOTRACE
 static void iotracePrintf(const char *zFormat, ...){
 static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
   va_list ap;
   char *z;
   if( iotrace==0 ) return;

@@ -431,14 +491,14 @@ static char *one_input_line(FILE *in, char *zPrior, int isContinuation){

     zResult = local_getline(zPrior, in);
   }else{
     zPrompt = isContinuation ? continuePrompt : mainPrompt;
 #if HAVE_READLINE
     free(zPrior);
     zResult = readline(zPrompt);
     if( zResult && *zResult ) add_history(zResult);
 #else
 #if SHELL_USE_LOCAL_GETLINE
     printf("%s", zPrompt);
     fflush(stdout);
     zResult = local_getline(zPrior, stdin);
 #else
     free(zPrior);
     zResult = shell_readline(zPrompt);
     if( zResult && *zResult ) shell_add_history(zResult);
 #endif
   }
   return zResult;

@@ -584,6 +644,7 @@ static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){

 static void output_quoted_string(FILE *out, const char *z){
   int i;
   int nSingle = 0;
   setBinaryMode(out);
   for(i=0; z[i]; i++){
     if( z[i]=='\'' ) nSingle++;
   }

@@ -606,6 +667,7 @@ static void output_quoted_string(FILE *out, const char *z){

     }
     fprintf(out,"'");
   }
   setTextMode(out);
 }
 /*

@@ -908,10 +970,7 @@ static int shell_callback(

       break;
     }
     case MODE_Csv: {
 #if defined(WIN32) || defined(_WIN32)
       fflush(p->out);
       _setmode(_fileno(p->out), _O_BINARY);
 #endif
       setBinaryMode(p->out);
       if( p->cnt++==0 && p->showHeader ){
         for(i=0; i<nArg; i++){
           output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);

@@ -924,10 +983,7 @@ static int shell_callback(

         }
         fprintf(p->out, "%s", p->rowSeparator);
       }
 #if defined(WIN32) || defined(_WIN32)
       fflush(p->out);
       _setmode(_fileno(p->out), _O_TEXT);
 #endif
       setTextMode(p->out);
       break;
     }
     case MODE_Insert: {

@@ -1717,6 +1773,7 @@ static char zHelp[] =

   ".bail on|off           Stop after hitting an error.  Default OFF\n"
   ".clone NEWDB           Clone data into NEWDB from the existing database\n"
   ".databases             List names and files of attached databases\n"
   ".dbinfo ?DB?           Show status information about the database\n"
   ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
   "                         If TABLE specified, only dump tables matching\n"
   "                         LIKE pattern TABLE.\n"

@@ -1729,8 +1786,8 @@ static char zHelp[] =

   ".headers on|off        Turn display of headers on or off\n"
   ".help                  Show this message\n"
   ".import FILE TABLE     Import data from FILE into TABLE\n"
   ".indices ?TABLE?       Show names of all indices\n"
   "                         If TABLE specified, only show indices for tables\n"
   ".indexes ?TABLE?       Show names of all indexes\n"
   "                         If TABLE specified, only show indexes for tables\n"
   "                         matching LIKE pattern TABLE.\n"
 #ifdef SQLITE_ENABLE_IOTRACE
   ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"

@@ -2086,7 +2143,7 @@ static void import_append_char(ImportCtx *p, int c){

 **      EOF on end-of-file.
 **   +  Report syntax errors on stderr
 */
 static char *csv_read_one_field(ImportCtx *p){
 static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
   int c;
   int cSep = p->cColSep;
   int rSep = p->cRowSep;

@@ -2160,7 +2217,7 @@ static char *csv_read_one_field(ImportCtx *p){

 **      EOF on end-of-file.
 **   +  Report syntax errors on stderr
 */
 static char *ascii_read_one_field(ImportCtx *p){
 static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
   int c;
   int cSep = p->cColSep;
   int rSep = p->cRowSep;

@@ -2402,7 +2459,9 @@ static void tryToClone(ShellState *p, const char *zNewDb){

 */
 static void output_reset(ShellState *p){
   if( p->outfile[0]=='|' ){
 #ifndef SQLITE_OMIT_POPEN
     pclose(p->out);
 #endif
   }else{
     output_file_close(p->out);
   }

@@ -2411,6 +2470,115 @@ static void output_reset(ShellState *p){

 }
 /*
 ** Run an SQL command and return the single integer result.
 */
 static int db_int(ShellState *p, const char *zSql){
   sqlite3_stmt *pStmt;
   int res = 0;
   sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
   if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
     res = sqlite3_column_int(pStmt,0);
   }
   sqlite3_finalize(pStmt);
   return res;
 }
 /*
 ** Convert a 2-byte or 4-byte big-endian integer into a native integer
 */
 unsigned int get2byteInt(unsigned char *a){
   return (a[0]<<8) + a[1];
 }
 unsigned int get4byteInt(unsigned char *a){
   return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
 }
 /*
 ** Implementation of the ".info" command.
 **
 ** Return 1 on error, 2 to exit, and 0 otherwise.
 */
 static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
   static const struct { const char *zName; int ofst; } aField[] = {
      { "file change counter:",  24  },
      { "database page count:",  28  },
      { "freelist page count:",  36  },
      { "schema cookie:",        40  },
      { "schema format:",        44  },
      { "default cache size:",   48  },
      { "autovacuum top root:",  52  },
      { "incremental vacuum:",   64  },
      { "text encoding:",        56  },
      { "user version:",         60  },
      { "application id:",       68  },
      { "software version:",     96  },
   };
   static const struct { const char *zName; const char *zSql; } aQuery[] = {
      { "number of tables:",
        "SELECT count(*) FROM %s WHERE type='table'" },
      { "number of indexes:",
        "SELECT count(*) FROM %s WHERE type='index'" },
      { "number of triggers:",
        "SELECT count(*) FROM %s WHERE type='trigger'" },
      { "number of views:",
        "SELECT count(*) FROM %s WHERE type='view'" },
      { "schema size:",
        "SELECT total(length(sql)) FROM %s" },
   };
   sqlite3_file *pFile;
   int i;
   char *zSchemaTab;
   char *zDb = nArg>=2 ? azArg[1] : "main";
   unsigned char aHdr[100];
   open_db(p, 0);
   if( p->db==0 ) return 1;
   sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
   if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
     return 1;
   }
   i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
   if( i!=SQLITE_OK ){
     fprintf(stderr, "unable to read database header\n");
     return 1;
   }
   i = get2byteInt(aHdr+16);
   if( i==1 ) i = 65536;
   fprintf(p->out, "%-20s %d\n", "database page size:", i);
   fprintf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
   fprintf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
   fprintf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
   for(i=0; i<sizeof(aField)/sizeof(aField[0]); i++){
     int ofst = aField[i].ofst;
     unsigned int val = get4byteInt(aHdr + ofst);
     fprintf(p->out, "%-20s %u", aField[i].zName, val);
     switch( ofst ){
       case 56: {
         if( val==1 ) fprintf(p->out, " (utf8)");
         if( val==2 ) fprintf(p->out, " (utf16le)");
         if( val==3 ) fprintf(p->out, " (utf16be)");
       }
     }
     fprintf(p->out, "\n");
   }
   if( zDb==0 ){
     zSchemaTab = sqlite3_mprintf("main.sqlite_master");
   }else if( strcmp(zDb,"temp")==0 ){
     zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
   }else{
     zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
   }
   for(i=0; i<sizeof(aQuery)/sizeof(aQuery[0]); i++){
     char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
     int val = db_int(p, zSql);
     sqlite3_free(zSql);
     fprintf(p->out, "%-20s %d\n", aQuery[i].zName, val);
   }
   sqlite3_free(zSchemaTab);
   return 0;
 }
 /*
 ** If an input line begins with "." then invoke this routine to
 ** process that line.
 **

@@ -2552,6 +2720,10 @@ static int do_meta_command(char *zLine, ShellState *p){

     }
   }else
   if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
     rc = shell_dbinfo_command(p, nArg, azArg);
   }else
   if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
     open_db(p, 0);
     /* When playing back a "dump", the content might appear in an order

@@ -2739,8 +2911,8 @@ static int do_meta_command(char *zLine, ShellState *p){

     int nSep;                   /* Number of bytes in p->colSeparator[] */
     char *zSql;                 /* An SQL statement */
     ImportCtx sCtx;             /* Reader context */
     char *(*xRead)(ImportCtx*); /* Procedure to read one value */
     int (*xCloser)(FILE*);      /* Procedure to close th3 connection */
     char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
     int (SQLITE_CDECL *xCloser)(FILE*);      /* Func to close file */
     if( nArg!=3 ){
       fprintf(stderr, "Usage: .import FILE TABLE\n");

@@ -2782,9 +2954,14 @@ static int do_meta_command(char *zLine, ShellState *p){

     sCtx.zFile = zFile;
     sCtx.nLine = 1;
     if( sCtx.zFile[0]=='|' ){
 #ifdef SQLITE_OMIT_POPEN
       fprintf(stderr, "Error: pipes are not supported in this OS\n");
       return 1;
 #else
       sCtx.in = popen(sCtx.zFile+1, "r");
       sCtx.zFile = "<pipe>";
       xCloser = pclose;
 #endif
     }else{
       sCtx.in = fopen(sCtx.zFile, "rb");
       xCloser = fclose;

@@ -2891,7 +3068,7 @@ static int do_meta_command(char *zLine, ShellState *p){

           fprintf(stderr, "%s:%d: expected %d columns but found %d - "
                           "filling the rest with NULL\n",
                           sCtx.zFile, startLine, nCol, i+1);
           i++;
           i += 2;
           while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
         }
       }

@@ -2920,7 +3097,8 @@ static int do_meta_command(char *zLine, ShellState *p){

     if( needCommit ) sqlite3_exec(db, "COMMIT", 0, 0, 0);
   }else
   if( c=='i' && strncmp(azArg[0], "indices", n)==0 ){
   if( c=='i' && (strncmp(azArg[0], "indices", n)==0
                  || strncmp(azArg[0], "indexes", n)==0) ){
     ShellState data;
     char *zErrMsg = 0;
     open_db(p, 0);

@@ -2950,7 +3128,7 @@ static int do_meta_command(char *zLine, ShellState *p){

       );
       zShellStatic = 0;
     }else{
       fprintf(stderr, "Usage: .indices ?LIKE-PATTERN?\n");
       fprintf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
       rc = 1;
       goto meta_command_exit;
     }

@@ -2966,7 +3144,7 @@ static int do_meta_command(char *zLine, ShellState *p){

 #ifdef SQLITE_ENABLE_IOTRACE
   if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
     extern void (*sqlite3IoTrace)(const char*, ...);
     SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
     if( iotrace && iotrace!=stdout ) fclose(iotrace);
     iotrace = 0;
     if( nArg<2 ){

@@ -3106,6 +3284,11 @@ static int do_meta_command(char *zLine, ShellState *p){

     }
     output_reset(p);
     if( zFile[0]=='|' ){
 #ifdef SQLITE_OMIT_POPEN
       fprintf(stderr,"Error: pipes are not supported in this OS\n");
       rc = 1;
       p->out = stdout;
 #else
       p->out = popen(zFile + 1, "w");
       if( p->out==0 ){
         fprintf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);

@@ -3114,6 +3297,7 @@ static int do_meta_command(char *zLine, ShellState *p){

       }else{
         sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
       }
 #endif
     }else{
       p->out = output_file_open(zFile);
       if( p->out==0 ){

@@ -3313,7 +3497,7 @@ static int do_meta_command(char *zLine, ShellState *p){

 #if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
   if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
     extern int sqlite3SelectTrace;
     sqlite3SelectTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
     sqlite3SelectTrace = integerValue(azArg[1]);
   }else
 #endif

@@ -3519,6 +3703,8 @@ static int do_meta_command(char *zLine, ShellState *p){

       { "iskeyword",             SQLITE_TESTCTRL_ISKEYWORD              },
       { "scratchmalloc",         SQLITE_TESTCTRL_SCRATCHMALLOC          },
       { "byteorder",             SQLITE_TESTCTRL_BYTEORDER              },
       { "never_corrupt",         SQLITE_TESTCTRL_NEVER_CORRUPT          },
       { "imposter",              SQLITE_TESTCTRL_IMPOSTER               },
     };
     int testctrl = -1;
     int rc = 0;

@@ -3585,7 +3771,8 @@ static int do_meta_command(char *zLine, ShellState *p){

         /* sqlite3_test_control(int, int) */
         case SQLITE_TESTCTRL_ASSERT:
         case SQLITE_TESTCTRL_ALWAYS:
         case SQLITE_TESTCTRL_ALWAYS:
         case SQLITE_TESTCTRL_NEVER_CORRUPT:
           if( nArg==3 ){
             int opt = booleanValue(azArg[2]);
             rc = sqlite3_test_control(testctrl, opt);

@@ -3610,6 +3797,18 @@ static int do_meta_command(char *zLine, ShellState *p){

           break;
 #endif
         case SQLITE_TESTCTRL_IMPOSTER:
           if( nArg==5 ){
             rc = sqlite3_test_control(testctrl, p->db,
                           azArg[2],
                           integerValue(azArg[3]),
                           integerValue(azArg[4]));
             fprintf(p->out, "%d (0x%08x)\n", rc, rc);
           }else{
             fprintf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
           }
           break;
         case SQLITE_TESTCTRL_BITVEC_TEST:
         case SQLITE_TESTCTRL_FAULT_INSTALL:
         case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS:

@@ -3642,12 +3841,12 @@ static int do_meta_command(char *zLine, ShellState *p){

   if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
     open_db(p, 0);
     output_file_close(p->traceOut);
     if( nArg!=2 ){
       fprintf(stderr, "Usage: .trace FILE|off\n");
       rc = 1;
       goto meta_command_exit;
     }
     output_file_close(p->traceOut);
     p->traceOut = output_file_open(azArg[1]);
 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
     if( p->traceOut==0 ){

@@ -4023,7 +4222,7 @@ static char *find_home_dir(void){

 **
 ** Returns the number of errors.
 */
 static int process_sqliterc(
 static void process_sqliterc(
   ShellState *p,                  /* Configuration data */
   const char *sqliterc_override   /* Name of config file. NULL to use default */
 ){

@@ -4031,15 +4230,13 @@ static int process_sqliterc(

   const char *sqliterc = sqliterc_override;
   char *zBuf = 0;
   FILE *in = NULL;
   int rc = 0;
   if (sqliterc == NULL) {
     home_dir = find_home_dir();
     if( home_dir==0 ){
 #if !defined(__RTP__) && !defined(_WRS_KERNEL)
       fprintf(stderr,"%s: Error: cannot locate your home directory\n", Argv0);
 #endif
       return 1;
       fprintf(stderr, "-- warning: cannot find home directory;"
                       " cannot read ~/.sqliterc\n");
       return;
     }
     sqlite3_initialize();
     zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);

@@ -4050,11 +4247,10 @@ static int process_sqliterc(

     if( stdin_is_interactive ){
       fprintf(stderr,"-- Loading resources from %s\n",sqliterc);
     }
     rc = process_input(p,in);
     process_input(p,in);
     fclose(in);
   }
   sqlite3_free(zBuf);
   return rc;
 }
 /*

@@ -4158,7 +4354,7 @@ static char *cmdline_option_value(int argc, char **argv, int i){

   return argv[i];
 }
 int sqlite3_shell(int argc, char **argv){
 int SQLITE_CDECL sqlite3_shell(int argc, char **argv){
   char *zErrMsg = 0;
   ShellState data;
   const char *zInitFile = 0;

@@ -4176,6 +4372,8 @@ int sqlite3_shell(int argc, char **argv){

     exit(1);
   }
 #endif
   setBinaryMode(stdin);
   setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
   Argv0 = argv[0];
   main_init(&data);
   stdin_is_interactive = isatty(0);

@@ -4208,9 +4406,11 @@ int sqlite3_shell(int argc, char **argv){

     char *z;
     z = argv[i];
     if( z[0]!='-' ){
 #if 0
       if( data.zDbFilename==0 ){
         data.zDbFilename = z;
       }else{
 #endif
         /* Excesss arguments are interpreted as SQL (or dot-commands) and
         ** mean that nothing is read from stdin */
         readStdin = 0;

@@ -4221,7 +4421,9 @@ int sqlite3_shell(int argc, char **argv){

           exit(1);
         }
         azCmd[nCmd-1] = z;
 #if 0
       }
 #endif
     }
     if( z[1]=='-' ) z++;
     if( strcmp(z,"-separator")==0

@@ -4328,10 +4530,7 @@ int sqlite3_shell(int argc, char **argv){

   ** is given on the command line, look for a file named ~/.sqliterc and
   ** try to process it.
   */
   rc = process_sqliterc(&data,zInitFile);
   if( rc>0 ){
     return rc;
   }
   process_sqliterc(&data,zInitFile);
   /* Make a second pass through the command-line argument and set
   ** options.  This second pass is delayed until after the initialization

@@ -4488,13 +4687,11 @@ int sqlite3_shell(int argc, char **argv){

           sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
         }
       }
 #if HAVE_READLINE
       if( zHistory ) read_history(zHistory);
 #endif
       if( zHistory ) shell_read_history(zHistory);
       rc = process_input(&data, 0);
       if( zHistory ){
         stifle_history(100);
         write_history(zHistory);
         shell_stifle_history(100);
         shell_write_history(zHistory);
         free(zHistory);
       }
     }else{

modified external/sqlite/sqlite3.c

@@ -1,6 +1,6 @@

 /******************************************************************************
 ** This file is an amalgamation of many separate C source files from SQLite
 ** version 3.8.8.2.  By combining all the individual C code files into this
 ** version 3.8.9.  By combining all the individual C code files into this
 ** single large file, the entire code can be compiled as a single translation
 ** unit.  This allows many compilers to do optimizations that would not be
 ** possible if the files were compiled separately.  Performance improvements

@@ -22,9 +22,6 @@

 #ifndef SQLITE_PRIVATE
 # define SQLITE_PRIVATE static
 #endif
 #ifndef SQLITE_API
 # define SQLITE_API
 #endif
 /************** Begin file sqliteInt.h ***************************************/
 /*
 ** 2001 September 15

@@ -91,6 +88,44 @@

 /************** Continuing where we left off in sqliteInt.h ******************/
 /*
 ** Special setup for VxWorks
 */
 /************** Include vxworks.h in the middle of sqliteInt.h ***************/
 /************** Begin file vxworks.h *****************************************/
 /*
 ** 2015-03-02
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
 ******************************************************************************
 **
 ** This file contains code that is specific to Wind River's VxWorks
 */
 #if defined(__RTP__) || defined(_WRS_KERNEL)
 /* This is VxWorks.  Set up things specially for that OS
 */
 #include <vxWorks.h>
 #include <pthread.h>  /* amalgamator: dontcache */
 #define OS_VXWORKS 1
 #define SQLITE_OS_OTHER 0
 #define SQLITE_HOMEGROWN_RECURSIVE_MUTEX 1
 #define SQLITE_OMIT_LOAD_EXTENSION 1
 #define SQLITE_ENABLE_LOCKING_STYLE 0
 #define HAVE_UTIME 1
 #else
 /* This is not VxWorks. */
 #define OS_VXWORKS 0
 #endif /* defined(_WRS_KERNEL) */
 /************** End of vxworks.h *********************************************/
 /************** Continuing where we left off in sqliteInt.h ******************/
 /*
 ** These #defines should enable >2GB file support on POSIX if the
 ** underlying operating system supports it.  If the OS lacks
 ** large file support, or if the OS is windows, these should be no-ops.

@@ -214,16 +249,20 @@ extern "C" {

 /*
 ** Add the ability to override 'extern'
 ** Provide the ability to override linkage features of the interface.
 */
 #ifndef SQLITE_EXTERN
 # define SQLITE_EXTERN extern
 #endif
 #ifndef SQLITE_API
 # define SQLITE_API
 #endif
 #ifndef SQLITE_CDECL
 # define SQLITE_CDECL
 #endif
 #ifndef SQLITE_STDCALL
 # define SQLITE_STDCALL
 #endif
 /*
 ** These no-op macros are used in front of interfaces to mark those

@@ -278,9 +317,9 @@ extern "C" {

 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
 #define SQLITE_VERSION        "3.8.8.2"
 #define SQLITE_VERSION_NUMBER 3008008
 #define SQLITE_SOURCE_ID      "2015-01-30 14:30:45 7757fc721220e136620a89c9d28247f28bbbc098"
 #define SQLITE_VERSION        "3.8.9"
 #define SQLITE_VERSION_NUMBER 3008009
 #define SQLITE_SOURCE_ID      "2015-04-08 12:16:33 8a8ffc862e96f57aa698f93de10dee28e69f6e09"
 /*
 ** CAPI3REF: Run-Time Library Version Numbers

@@ -313,9 +352,9 @@ extern "C" {

 ** See also: [sqlite_version()] and [sqlite_source_id()].
 */
 SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;
 SQLITE_API const char *sqlite3_libversion(void);
 SQLITE_API const char *sqlite3_sourceid(void);
 SQLITE_API int sqlite3_libversion_number(void);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion(void);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number(void);
 /*
 ** CAPI3REF: Run-Time Library Compilation Options Diagnostics

@@ -340,8 +379,8 @@ SQLITE_API int sqlite3_libversion_number(void);

 ** [sqlite_compileoption_get()] and the [compile_options pragma].
 */
 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
 SQLITE_API const char *sqlite3_compileoption_get(int N);
 SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_compileoption_get(int N);
 #endif
 /*

@@ -380,7 +419,7 @@ SQLITE_API const char *sqlite3_compileoption_get(int N);

 **
 ** See the [threading mode] documentation for additional information.
 */
 SQLITE_API int sqlite3_threadsafe(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe(void);
 /*
 ** CAPI3REF: Database Connection Handle

@@ -476,8 +515,8 @@ typedef sqlite_uint64 sqlite3_uint64;

 ** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer
 ** argument is a harmless no-op.
 */
 SQLITE_API int sqlite3_close(sqlite3*);
 SQLITE_API int sqlite3_close_v2(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3*);
 /*
 ** The type for a callback function.

@@ -547,7 +586,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);

 **      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
 ** </ul>
 */
 SQLITE_API int sqlite3_exec(
 SQLITE_API int SQLITE_STDCALL sqlite3_exec(
   sqlite3*,                                  /* An open database */
   const char *sql,                           /* SQL to be evaluated */
   int (*callback)(void*,int,char**,char**),  /* Callback function */

@@ -927,14 +966,16 @@ struct sqlite3_io_methods {

 ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
 ** interface.
 **
 ** <ul>
 ** <li>[[SQLITE_FCNTL_LOCKSTATE]]
 ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
 ** opcode causes the xFileControl method to write the current state of
 ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
 ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
 ** into an integer that the pArg argument points to. This capability
 ** is used during testing and only needs to be supported when SQLITE_TEST
 ** is defined.
 ** <ul>
 ** is used during testing and is only available when the SQLITE_TEST
 ** compile-time option is used.
 **
 ** <li>[[SQLITE_FCNTL_SIZE_HINT]]
 ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
 ** layer a hint of how large the database file will grow to be during the

@@ -1059,7 +1100,9 @@ struct sqlite3_io_methods {

 ** [PRAGMA] processing continues.  ^If the [SQLITE_FCNTL_PRAGMA]
 ** file control returns [SQLITE_OK], then the parser assumes that the
 ** VFS has handled the PRAGMA itself and the parser generates a no-op
 ** prepared statement.  ^If the [SQLITE_FCNTL_PRAGMA] file control returns
 ** prepared statement if result string is NULL, or that returns a copy
 ** of the result string if the string is non-NULL.
 ** ^If the [SQLITE_FCNTL_PRAGMA] file control returns
 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
 ** that the VFS encountered an error while handling the [PRAGMA] and the
 ** compilation of the PRAGMA fails with an error.  ^The [SQLITE_FCNTL_PRAGMA]

@@ -1117,12 +1160,19 @@ struct sqlite3_io_methods {

 ** pointed to by the pArg argument.  This capability is used during testing
 ** and only needs to be supported when SQLITE_TEST is defined.
 **
 ** <li>[[SQLITE_FCNTL_WAL_BLOCK]]
 ** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might
 ** be advantageous to block on the next WAL lock if the lock is not immediately
 ** available.  The WAL subsystem issues this signal during rare
 ** circumstances in order to fix a problem with priority inversion.
 ** Applications should <em>not</em> use this file-control.
 **
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
 #define SQLITE_GET_LOCKPROXYFILE             2
 #define SQLITE_SET_LOCKPROXYFILE             3
 #define SQLITE_LAST_ERRNO                    4
 #define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
 #define SQLITE_FCNTL_SET_LOCKPROXYFILE       3
 #define SQLITE_FCNTL_LAST_ERRNO              4
 #define SQLITE_FCNTL_SIZE_HINT               5
 #define SQLITE_FCNTL_CHUNK_SIZE              6
 #define SQLITE_FCNTL_FILE_POINTER            7

@@ -1141,6 +1191,13 @@ struct sqlite3_io_methods {

 #define SQLITE_FCNTL_SYNC                   21
 #define SQLITE_FCNTL_COMMIT_PHASETWO        22
 #define SQLITE_FCNTL_WIN32_SET_HANDLE       23
 #define SQLITE_FCNTL_WAL_BLOCK              24
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
 #define SQLITE_SET_LOCKPROXYFILE      SQLITE_FCNTL_SET_LOCKPROXYFILE
 #define SQLITE_LAST_ERRNO             SQLITE_FCNTL_LAST_ERRNO
 /*
 ** CAPI3REF: Mutex Handle

@@ -1489,10 +1546,10 @@ struct sqlite3_vfs {

 ** must return [SQLITE_OK] on success and some other [error code] upon
 ** failure.
 */
 SQLITE_API int sqlite3_initialize(void);
 SQLITE_API int sqlite3_shutdown(void);
 SQLITE_API int sqlite3_os_init(void);
 SQLITE_API int sqlite3_os_end(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_initialize(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_shutdown(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void);
 /*
 ** CAPI3REF: Configuring The SQLite Library

@@ -1523,7 +1580,7 @@ SQLITE_API int sqlite3_os_end(void);

 ** ^If the option is unknown or SQLite is unable to set the option
 ** then this routine returns a non-zero [error code].
 */
 SQLITE_API int sqlite3_config(int, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_config(int, ...);
 /*
 ** CAPI3REF: Configure database connections

@@ -1541,7 +1598,7 @@ SQLITE_API int sqlite3_config(int, ...);

 ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
 ** the call is considered successful.
 */
 SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3*, int op, ...);
 /*
 ** CAPI3REF: Memory Allocation Routines

@@ -1701,7 +1758,7 @@ struct sqlite3_mem_methods {

 **   <li> [sqlite3_memory_used()]
 **   <li> [sqlite3_memory_highwater()]
 **   <li> [sqlite3_soft_heap_limit64()]
 **   <li> [sqlite3_status()]
 **   <li> [sqlite3_status64()]
 **   </ul>)^
 ** ^Memory allocation statistics are enabled by default unless SQLite is
 ** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory

@@ -1912,7 +1969,6 @@ struct sqlite3_mem_methods {

 ** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro
 ** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
 ** that specifies the maximum size of the created heap.
 ** </dl>
 **
 ** [[SQLITE_CONFIG_PCACHE_HDRSZ]]
 ** <dt>SQLITE_CONFIG_PCACHE_HDRSZ

@@ -2030,7 +2086,7 @@ struct sqlite3_mem_methods {

 ** [extended result codes] feature of SQLite. ^The extended result
 ** codes are disabled by default for historical compatibility.
 */
 SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
 SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3*, int onoff);
 /*
 ** CAPI3REF: Last Insert Rowid

@@ -2081,7 +2137,7 @@ SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);

 ** unpredictable and might not equal either the old or the new
 ** last insert [rowid].
 */
 SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(sqlite3*);
 /*
 ** CAPI3REF: Count The Number Of Rows Modified

@@ -2133,7 +2189,7 @@ SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);

 ** while [sqlite3_changes()] is running then the value returned
 ** is unpredictable and not meaningful.
 */
 SQLITE_API int sqlite3_changes(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3*);
 /*
 ** CAPI3REF: Total Number Of Rows Modified

@@ -2156,7 +2212,7 @@ SQLITE_API int sqlite3_changes(sqlite3*);

 ** while [sqlite3_total_changes()] is running then the value
 ** returned is unpredictable and not meaningful.
 */
 SQLITE_API int sqlite3_total_changes(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3*);
 /*
 ** CAPI3REF: Interrupt A Long-Running Query

@@ -2195,7 +2251,7 @@ SQLITE_API int sqlite3_total_changes(sqlite3*);

 ** If the database connection closes while [sqlite3_interrupt()]
 ** is running then bad things will likely happen.
 */
 SQLITE_API void sqlite3_interrupt(sqlite3*);
 SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3*);
 /*
 ** CAPI3REF: Determine If An SQL Statement Is Complete

@@ -2230,8 +2286,8 @@ SQLITE_API void sqlite3_interrupt(sqlite3*);

 ** The input to [sqlite3_complete16()] must be a zero-terminated
 ** UTF-16 string in native byte order.
 */
 SQLITE_API int sqlite3_complete(const char *sql);
 SQLITE_API int sqlite3_complete16(const void *sql);
 SQLITE_API int SQLITE_STDCALL sqlite3_complete(const char *sql);
 SQLITE_API int SQLITE_STDCALL sqlite3_complete16(const void *sql);
 /*
 ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors

@@ -2291,7 +2347,7 @@ SQLITE_API int sqlite3_complete16(const void *sql);

 ** A busy handler must not close the database connection
 ** or [prepared statement] that invoked the busy handler.
 */
 SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
 SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
 /*
 ** CAPI3REF: Set A Busy Timeout

@@ -2313,7 +2369,7 @@ SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);

 **
 ** See also:  [PRAGMA busy_timeout]
 */
 SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
 SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3*, int ms);
 /*
 ** CAPI3REF: Convenience Routines For Running Queries

@@ -2387,7 +2443,7 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);

 ** reflected in subsequent calls to [sqlite3_errcode()] or
 ** [sqlite3_errmsg()].
 */
 SQLITE_API int sqlite3_get_table(
 SQLITE_API int SQLITE_STDCALL sqlite3_get_table(
   sqlite3 *db,          /* An open database */
   const char *zSql,     /* SQL to be evaluated */
   char ***pazResult,    /* Results of the query */

@@ -2395,13 +2451,17 @@ SQLITE_API int sqlite3_get_table(

   int *pnColumn,        /* Number of result columns written here */
   char **pzErrmsg       /* Error msg written here */
 );
 SQLITE_API void sqlite3_free_table(char **result);
 SQLITE_API void SQLITE_STDCALL sqlite3_free_table(char **result);
 /*
 ** CAPI3REF: Formatted String Printing Functions
 **
 ** These routines are work-alikes of the "printf()" family of functions
 ** from the standard C library.
 ** These routines understand most of the common K&R formatting options,
 ** plus some additional non-standard formats, detailed below.
 ** Note that some of the more obscure formatting options from recent
 ** C-library standards are omitted from this implementation.
 **
 ** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
 ** results into memory obtained from [sqlite3_malloc()].

@@ -2434,7 +2494,7 @@ SQLITE_API void sqlite3_free_table(char **result);

 ** These routines all implement some additional formatting
 ** options that are useful for constructing SQL statements.
 ** All of the usual printf() formatting options apply.  In addition, there
 ** is are "%q", "%Q", and "%z" options.
 ** is are "%q", "%Q", "%w" and "%z" options.
 **
 ** ^(The %q option works like %s in that it substitutes a nul-terminated
 ** string from the argument list.  But %q also doubles every '\'' character.

@@ -2487,14 +2547,20 @@ SQLITE_API void sqlite3_free_table(char **result);

 ** The code above will render a correct SQL statement in the zSQL
 ** variable even if the zText variable is a NULL pointer.
 **
 ** ^(The "%w" formatting option is like "%q" except that it expects to
 ** be contained within double-quotes instead of single quotes, and it
 ** escapes the double-quote character instead of the single-quote
 ** character.)^  The "%w" formatting option is intended for safely inserting
 ** table and column names into a constructed SQL statement.
 **
 ** ^(The "%z" formatting option works like "%s" but with the
 ** addition that after the string has been read and copied into
 ** the result, [sqlite3_free()] is called on the input string.)^
 */
 SQLITE_API char *sqlite3_mprintf(const char*,...);
 SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
 SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
 SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
 SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char*,...);
 SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char*, va_list);
 SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int,char*,const char*, ...);
 SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int,char*,const char*, va_list);
 /*
 ** CAPI3REF: Memory Allocation Subsystem

@@ -2584,12 +2650,12 @@ SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);

 ** a block of memory after it has been released using
 ** [sqlite3_free()] or [sqlite3_realloc()].
 */
 SQLITE_API void *sqlite3_malloc(int);
 SQLITE_API void *sqlite3_malloc64(sqlite3_uint64);
 SQLITE_API void *sqlite3_realloc(void*, int);
 SQLITE_API void *sqlite3_realloc64(void*, sqlite3_uint64);
 SQLITE_API void sqlite3_free(void*);
 SQLITE_API sqlite3_uint64 sqlite3_msize(void*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int);
 SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64);
 SQLITE_API void *SQLITE_STDCALL sqlite3_realloc(void*, int);
 SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64(void*, sqlite3_uint64);
 SQLITE_API void SQLITE_STDCALL sqlite3_free(void*);
 SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void*);
 /*
 ** CAPI3REF: Memory Allocator Statistics

@@ -2614,8 +2680,8 @@ SQLITE_API sqlite3_uint64 sqlite3_msize(void*);

 ** by [sqlite3_memory_highwater(1)] is the high-water mark
 ** prior to the reset.
 */
 SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
 SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(void);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(int resetFlag);
 /*
 ** CAPI3REF: Pseudo-Random Number Generator

@@ -2638,7 +2704,7 @@ SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);

 ** internally and without recourse to the [sqlite3_vfs] xRandomness
 ** method.
 */
 SQLITE_API void sqlite3_randomness(int N, void *P);
 SQLITE_API void SQLITE_STDCALL sqlite3_randomness(int N, void *P);
 /*
 ** CAPI3REF: Compile-Time Authorization Callbacks

@@ -2720,7 +2786,7 @@ SQLITE_API void sqlite3_randomness(int N, void *P);

 ** as stated in the previous paragraph, sqlite3_step() invokes
 ** sqlite3_prepare_v2() to reprepare a statement after a schema change.
 */
 SQLITE_API int sqlite3_set_authorizer(
 SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer(
   sqlite3*,
   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
   void *pUserData

@@ -2824,8 +2890,8 @@ SQLITE_API int sqlite3_set_authorizer(

 ** sqlite3_profile() function is considered experimental and is
 ** subject to change in future versions of SQLite.
 */
 SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
 SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
 SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
 SQLITE_API SQLITE_EXPERIMENTAL void *SQLITE_STDCALL sqlite3_profile(sqlite3*,
    void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
 /*

@@ -2859,7 +2925,7 @@ SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,

 ** database connections for the meaning of "modify" in this paragraph.
 **
 */
 SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 /*
 ** CAPI3REF: Opening A New Database Connection

@@ -3087,15 +3153,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);

 **
 ** See also: [sqlite3_temp_directory]
 */
 SQLITE_API int sqlite3_open(
 SQLITE_API int SQLITE_STDCALL sqlite3_open(
   const char *filename,   /* Database filename (UTF-8) */
   sqlite3 **ppDb          /* OUT: SQLite db handle */
 );
 SQLITE_API int sqlite3_open16(
 SQLITE_API int SQLITE_STDCALL sqlite3_open16(
   const void *filename,   /* Database filename (UTF-16) */
   sqlite3 **ppDb          /* OUT: SQLite db handle */
 );
 SQLITE_API int sqlite3_open_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_open_v2(
   const char *filename,   /* Database filename (UTF-8) */
   sqlite3 **ppDb,         /* OUT: SQLite db handle */
   int flags,              /* Flags */

@@ -3141,19 +3207,21 @@ SQLITE_API int sqlite3_open_v2(

 ** VFS method, then the behavior of this routine is undefined and probably
 ** undesirable.
 */
 SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
 SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
 SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam);
 SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
 /*
 ** CAPI3REF: Error Codes And Messages
 **
 ** ^The sqlite3_errcode() interface returns the numeric [result code] or
 ** [extended result code] for the most recent failed sqlite3_* API call
 ** associated with a [database connection]. If a prior API call failed
 ** but the most recent API call succeeded, the return value from
 ** sqlite3_errcode() is undefined.  ^The sqlite3_extended_errcode()
 ** ^If the most recent sqlite3_* API call associated with
 ** [database connection] D failed, then the sqlite3_errcode(D) interface
 ** returns the numeric [result code] or [extended result code] for that
 ** API call.
 ** If the most recent API call was successful,
 ** then the return value from sqlite3_errcode() is undefined.
 ** ^The sqlite3_extended_errcode()
 ** interface is the same except that it always returns the
 ** [extended result code] even when extended result codes are
 ** disabled.

@@ -3184,11 +3252,11 @@ SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int

 ** was invoked incorrectly by the application.  In that case, the
 ** error code and message may or may not be set.
 */
 SQLITE_API int sqlite3_errcode(sqlite3 *db);
 SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
 SQLITE_API const char *sqlite3_errmsg(sqlite3*);
 SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
 SQLITE_API const char *sqlite3_errstr(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db);
 SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3*);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr(int);
 /*
 ** CAPI3REF: SQL Statement Object

@@ -3255,7 +3323,7 @@ typedef struct sqlite3_stmt sqlite3_stmt;

 **
 ** New run-time limit categories may be added in future releases.
 */
 SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3*, int id, int newVal);
 /*
 ** CAPI3REF: Run-Time Limit Categories

@@ -3342,16 +3410,14 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);

 ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
 ** use UTF-16.
 **
 ** ^If the nByte argument is less than zero, then zSql is read up to the
 ** first zero terminator. ^If nByte is non-negative, then it is the maximum
 ** number of  bytes read from zSql.  ^When nByte is non-negative, the
 ** zSql string ends at either the first '\000' or '\u0000' character or
 ** the nByte-th byte, whichever comes first. If the caller knows
 ** that the supplied string is nul-terminated, then there is a small
 ** performance advantage to be gained by passing an nByte parameter that
 ** is equal to the number of bytes in the input string <i>including</i>
 ** the nul-terminator bytes as this saves SQLite from having to
 ** make a copy of the input string.
 ** ^If the nByte argument is negative, then zSql is read up to the
 ** first zero terminator. ^If nByte is positive, then it is the
 ** number of bytes read from zSql.  ^If nByte is zero, then no prepared
 ** statement is generated.
 ** If the caller knows that the supplied string is nul-terminated, then
 ** there is a small performance advantage to passing an nByte parameter that
 ** is the number of bytes in the input string <i>including</i>
 ** the nul-terminator.
 **
 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
 ** past the end of the first SQL statement in zSql.  These routines only

@@ -3407,28 +3473,28 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);

 ** </li>
 ** </ol>
 */
 SQLITE_API int sqlite3_prepare(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare(
   sqlite3 *db,            /* Database handle */
   const char *zSql,       /* SQL statement, UTF-8 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */
   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
 );
 SQLITE_API int sqlite3_prepare_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2(
   sqlite3 *db,            /* Database handle */
   const char *zSql,       /* SQL statement, UTF-8 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */
   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
 );
 SQLITE_API int sqlite3_prepare16(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare16(
   sqlite3 *db,            /* Database handle */
   const void *zSql,       /* SQL statement, UTF-16 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */
   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
   const void **pzTail     /* OUT: Pointer to unused portion of zSql */
 );
 SQLITE_API int sqlite3_prepare16_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2(
   sqlite3 *db,            /* Database handle */
   const void *zSql,       /* SQL statement, UTF-16 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */

@@ -3443,7 +3509,7 @@ SQLITE_API int sqlite3_prepare16_v2(

 ** SQL text used to create a [prepared statement] if that statement was
 ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
 */
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Determine If An SQL Statement Writes The Database

@@ -3474,7 +3540,7 @@ SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);

 ** change the configuration of a database connection, they do not make
 ** changes to the content of the database files on disk.
 */
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Determine If A Prepared Statement Has Been Reset

@@ -3493,7 +3559,7 @@ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

 ** for example, in diagnostic routines to search for prepared
 ** statements that are holding a transaction open.
 */
 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt*);
 /*
 ** CAPI3REF: Dynamically Typed Value Object

@@ -3654,19 +3720,19 @@ typedef struct sqlite3_context sqlite3_context;

 ** See also: [sqlite3_bind_parameter_count()],
 ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
 */
 SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
 SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
                         void(*)(void*));
 SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
 SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
 SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
 SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
 SQLITE_API int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
 SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
 SQLITE_API int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt*, int, double);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt*, int, int);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*, int);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
                          void(*)(void*), unsigned char encoding);
 SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
 /*
 ** CAPI3REF: Number Of SQL Parameters

@@ -3686,7 +3752,7 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);

 ** [sqlite3_bind_parameter_name()], and
 ** [sqlite3_bind_parameter_index()].
 */
 SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt*);
 /*
 ** CAPI3REF: Name Of A Host Parameter

@@ -3713,7 +3779,7 @@ SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);

 ** [sqlite3_bind_parameter_count()], and
 ** [sqlite3_bind_parameter_index()].
 */
 SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt*, int);
 /*
 ** CAPI3REF: Index Of A Parameter With A Given Name

@@ -3729,7 +3795,7 @@ SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);

 ** [sqlite3_bind_parameter_count()], and
 ** [sqlite3_bind_parameter_index()].
 */
 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
 /*
 ** CAPI3REF: Reset All Bindings On A Prepared Statement

@@ -3738,7 +3804,7 @@ SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);

 ** the [sqlite3_bind_blob | bindings] on a [prepared statement].
 ** ^Use this routine to reset all host parameters to NULL.
 */
 SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt*);
 /*
 ** CAPI3REF: Number Of Columns In A Result Set

@@ -3749,7 +3815,7 @@ SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);

 **
 ** See also: [sqlite3_data_count()]
 */
 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Column Names In A Result Set

@@ -3777,8 +3843,8 @@ SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);

 ** then the name of the column is unspecified and may change from
 ** one release of SQLite to the next.
 */
 SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt*, int N);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt*, int N);
 /*
 ** CAPI3REF: Source Of Data In A Query Result

@@ -3825,12 +3891,12 @@ SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);

 ** for the same [prepared statement] and result column
 ** at the same time then the results are undefined.
 */
 SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
 SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
 SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt*,int);
 /*
 ** CAPI3REF: Declared Datatype Of A Query Result

@@ -3861,8 +3927,8 @@ SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);

 ** is associated with individual values, not with the containers
 ** used to hold those values.
 */
 SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt*,int);
 /*
 ** CAPI3REF: Evaluate An SQL Statement

@@ -3941,7 +4007,7 @@ SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);

 ** then the more specific [error codes] are returned directly
 ** by sqlite3_step().  The use of the "v2" interface is recommended.
 */
 SQLITE_API int sqlite3_step(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_step(sqlite3_stmt*);
 /*
 ** CAPI3REF: Number of columns in a result set

@@ -3961,7 +4027,7 @@ SQLITE_API int sqlite3_step(sqlite3_stmt*);

 **
 ** See also: [sqlite3_column_count()]
 */
 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Fundamental Datatypes

@@ -4157,16 +4223,16 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);

 ** pointer.  Subsequent calls to [sqlite3_errcode()] will return
 ** [SQLITE_NOMEM].)^
 */
 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
 SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt*, int iCol);
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt*, int iCol);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt*, int iCol);
 /*
 ** CAPI3REF: Destroy A Prepared Statement Object

@@ -4193,7 +4259,7 @@ SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);

 ** statement after it has been finalized can result in undefined and
 ** undesirable behavior such as segfaults and heap corruption.
 */
 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Reset A Prepared Statement Object

@@ -4219,7 +4285,7 @@ SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);

 ** ^The [sqlite3_reset(S)] interface does not change the values
 ** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
 */
 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Create Or Redefine SQL Functions

@@ -4318,7 +4384,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);

 ** close the database connection nor finalize or reset the prepared
 ** statement in which the function is running.
 */
 SQLITE_API int sqlite3_create_function(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function(
   sqlite3 *db,
   const char *zFunctionName,
   int nArg,

@@ -4328,7 +4394,7 @@ SQLITE_API int sqlite3_create_function(

   void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   void (*xFinal)(sqlite3_context*)
 );
 SQLITE_API int sqlite3_create_function16(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function16(
   sqlite3 *db,
   const void *zFunctionName,
   int nArg,

@@ -4338,7 +4404,7 @@ SQLITE_API int sqlite3_create_function16(

   void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   void (*xFinal)(sqlite3_context*)
 );
 SQLITE_API int sqlite3_create_function_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2(
   sqlite3 *db,
   const char *zFunctionName,
   int nArg,

@@ -4380,16 +4446,16 @@ SQLITE_API int sqlite3_create_function_v2(

 ** These functions are [deprecated].  In order to maintain
 ** backwards compatibility with older code, these functions continue
 ** to be supported.  However, new applications should avoid
 ** the use of these functions.  To help encourage people to avoid
 ** using these functions, we are not going to tell you what they do.
 ** the use of these functions.  To encourage programmers to avoid
 ** these functions, we will not explain what they do.
 */
 #ifndef SQLITE_OMIT_DEPRECATED
 SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
 SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context*);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_global_recover(void);
 SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_thread_cleanup(void);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
                       void*,sqlite3_int64);
 #endif

@@ -4438,18 +4504,18 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6

 ** These routines must be called from the same thread as
 ** the SQL function that supplied the [sqlite3_value*] parameters.
 */
 SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
 SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
 SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
 SQLITE_API double sqlite3_value_double(sqlite3_value*);
 SQLITE_API int sqlite3_value_int(sqlite3_value*);
 SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
 SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
 SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
 SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value*);
 SQLITE_API double SQLITE_STDCALL sqlite3_value_double(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_int(sqlite3_value*);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value*);
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_type(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value*);
 /*
 ** CAPI3REF: Obtain Aggregate Function Context

@@ -4493,7 +4559,7 @@ SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);

 ** This routine must be called from the same thread in which
 ** the aggregate SQL function is running.
 */
 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
 SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context*, int nBytes);
 /*
 ** CAPI3REF: User Data For Functions

@@ -4507,7 +4573,7 @@ SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);

 ** This routine must be called from the same thread in which
 ** the application-defined function is running.
 */
 SQLITE_API void *sqlite3_user_data(sqlite3_context*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context*);
 /*
 ** CAPI3REF: Database Connection For Functions

@@ -4518,7 +4584,7 @@ SQLITE_API void *sqlite3_user_data(sqlite3_context*);

 ** and [sqlite3_create_function16()] routines that originally
 ** registered the application defined function.
 */
 SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context*);
 /*
 ** CAPI3REF: Function Auxiliary Data

@@ -4570,8 +4636,8 @@ SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);

 ** These routines must be called from the same thread in which
 ** the SQL function is running.
 */
 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
 SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
 SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context*, int N);
 SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
 /*

@@ -4706,26 +4772,26 @@ typedef void (*sqlite3_destructor_type)(void*);

 ** than the one containing the application-defined function that received
 ** the [sqlite3_context] pointer, the results are undefined.
 */
 SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void sqlite3_result_blob64(sqlite3_context*,const void*,
 SQLITE_API void SQLITE_STDCALL sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64(sqlite3_context*,const void*,
                            sqlite3_uint64,void(*)(void*));
 SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
 SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
 SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
 SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
 SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
 SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
 SQLITE_API void sqlite3_result_null(sqlite3_context*);
 SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
 SQLITE_API void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
 SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context*, double);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context*, const char*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context*, const void*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
                            void(*)(void*), unsigned char encoding);
 SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*, int n);
 /*
 ** CAPI3REF: Define New Collating Sequences

@@ -4806,14 +4872,14 @@ SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);

 **
 ** See also:  [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
 */
 SQLITE_API int sqlite3_create_collation(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation(
   sqlite3*,
   const char *zName,
   int eTextRep,
   void *pArg,
   int(*xCompare)(void*,int,const void*,int,const void*)
 );
 SQLITE_API int sqlite3_create_collation_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2(
   sqlite3*,
   const char *zName,
   int eTextRep,

@@ -4821,7 +4887,7 @@ SQLITE_API int sqlite3_create_collation_v2(

   int(*xCompare)(void*,int,const void*,int,const void*),
   void(*xDestroy)(void*)
 );
 SQLITE_API int sqlite3_create_collation16(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16(
   sqlite3*,
   const void *zName,
   int eTextRep,

@@ -4855,12 +4921,12 @@ SQLITE_API int sqlite3_create_collation16(

 ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
 ** [sqlite3_create_collation_v2()].
 */
 SQLITE_API int sqlite3_collation_needed(
 SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed(
   sqlite3*,
   void*,
   void(*)(void*,sqlite3*,int eTextRep,const char*)
 );
 SQLITE_API int sqlite3_collation_needed16(
 SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16(
   sqlite3*,
   void*,
   void(*)(void*,sqlite3*,int eTextRep,const void*)

@@ -4874,11 +4940,11 @@ SQLITE_API int sqlite3_collation_needed16(

 ** The code to implement this API is not available in the public release
 ** of SQLite.
 */
 SQLITE_API int sqlite3_key(
 SQLITE_API int SQLITE_STDCALL sqlite3_key(
   sqlite3 *db,                   /* Database to be rekeyed */
   const void *pKey, int nKey     /* The key */
 );
 SQLITE_API int sqlite3_key_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_key_v2(
   sqlite3 *db,                   /* Database to be rekeyed */
   const char *zDbName,           /* Name of the database */
   const void *pKey, int nKey     /* The key */

@@ -4892,11 +4958,11 @@ SQLITE_API int sqlite3_key_v2(

 ** The code to implement this API is not available in the public release
 ** of SQLite.
 */
 SQLITE_API int sqlite3_rekey(
 SQLITE_API int SQLITE_STDCALL sqlite3_rekey(
   sqlite3 *db,                   /* Database to be rekeyed */
   const void *pKey, int nKey     /* The new key */
 );
 SQLITE_API int sqlite3_rekey_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_rekey_v2(
   sqlite3 *db,                   /* Database to be rekeyed */
   const char *zDbName,           /* Name of the database */
   const void *pKey, int nKey     /* The new key */

@@ -4906,7 +4972,7 @@ SQLITE_API int sqlite3_rekey_v2(

 ** Specify the activation key for a SEE database.  Unless
 ** activated, none of the SEE routines will work.
 */
 SQLITE_API void sqlite3_activate_see(
 SQLITE_API void SQLITE_STDCALL sqlite3_activate_see(
   const char *zPassPhrase        /* Activation phrase */
 );
 #endif

@@ -4916,7 +4982,7 @@ SQLITE_API void sqlite3_activate_see(

 ** Specify the activation key for a CEROD database.  Unless
 ** activated, none of the CEROD routines will work.
 */
 SQLITE_API void sqlite3_activate_cerod(
 SQLITE_API void SQLITE_STDCALL sqlite3_activate_cerod(
   const char *zPassPhrase        /* Activation phrase */
 );
 #endif

@@ -4938,7 +5004,7 @@ SQLITE_API void sqlite3_activate_cerod(

 ** all, then the behavior of sqlite3_sleep() may deviate from the description
 ** in the previous paragraphs.
 */
 SQLITE_API int sqlite3_sleep(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_sleep(int);
 /*
 ** CAPI3REF: Name Of The Folder Holding Temporary Files

@@ -5056,7 +5122,7 @@ SQLITE_API char *sqlite3_data_directory;

 ** connection while this routine is running, then the return value
 ** is undefined.
 */
 SQLITE_API int sqlite3_get_autocommit(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3*);
 /*
 ** CAPI3REF: Find The Database Handle Of A Prepared Statement

@@ -5068,7 +5134,7 @@ SQLITE_API int sqlite3_get_autocommit(sqlite3*);

 ** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
 ** create the statement in the first place.
 */
 SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt*);
 /*
 ** CAPI3REF: Return The Filename For A Database Connection

@@ -5084,7 +5150,7 @@ SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);

 ** will be an absolute pathname, even if the filename used
 ** to open the database originally was a URI or relative pathname.
 */
 SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName);
 /*
 ** CAPI3REF: Determine if a database is read-only

@@ -5093,7 +5159,7 @@ SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);

 ** of connection D is read-only, 0 if it is read/write, or -1 if N is not
 ** the name of a database on connection D.
 */
 SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
 SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
 /*
 ** CAPI3REF: Find the next prepared statement

@@ -5108,7 +5174,7 @@ SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);

 ** [sqlite3_next_stmt(D,S)] must refer to an open database
 ** connection and in particular must not be a NULL pointer.
 */
 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
 SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Commit And Rollback Notification Callbacks

@@ -5156,8 +5222,8 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);

 **
 ** See also the [sqlite3_update_hook()] interface.
 */
 SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
 SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 /*
 ** CAPI3REF: Data Change Notification Callbacks

@@ -5207,7 +5273,7 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

 ** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
 ** interfaces.
 */
 SQLITE_API void *sqlite3_update_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook(
   sqlite3*,
   void(*)(void *,int ,char const *,char const *,sqlite3_int64),
   void*

@@ -5237,12 +5303,17 @@ SQLITE_API void *sqlite3_update_hook(

 ** future releases of SQLite.  Applications that care about shared
 ** cache setting should set it explicitly.
 **
 ** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0
 ** and will always return SQLITE_MISUSE. On those systems,
 ** shared cache mode should be enabled per-database connection via
 ** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE].
 **
 ** This interface is threadsafe on processors where writing a
 ** 32-bit integer is atomic.
 **
 ** See Also:  [SQLite Shared-Cache Mode]
 */
 SQLITE_API int sqlite3_enable_shared_cache(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache(int);
 /*
 ** CAPI3REF: Attempt To Free Heap Memory

@@ -5258,7 +5329,7 @@ SQLITE_API int sqlite3_enable_shared_cache(int);

 **
 ** See also: [sqlite3_db_release_memory()]
 */
 SQLITE_API int sqlite3_release_memory(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_release_memory(int);
 /*
 ** CAPI3REF: Free Memory Used By A Database Connection

@@ -5271,7 +5342,7 @@ SQLITE_API int sqlite3_release_memory(int);

 **
 ** See also: [sqlite3_release_memory()]
 */
 SQLITE_API int sqlite3_db_release_memory(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3*);
 /*
 ** CAPI3REF: Impose A Limit On Heap Size

@@ -5323,7 +5394,7 @@ SQLITE_API int sqlite3_db_release_memory(sqlite3*);

 ** The circumstances under which SQLite will enforce the soft heap limit may
 ** changes in future releases of SQLite.
 */
 SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 N);
 /*
 ** CAPI3REF: Deprecated Soft Heap Limit Interface

@@ -5334,7 +5405,7 @@ SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);

 ** only.  All new applications should use the
 ** [sqlite3_soft_heap_limit64()] interface rather than this one.
 */
 SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
 SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_soft_heap_limit(int N);
 /*

@@ -5403,7 +5474,7 @@ SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);

 ** parsed, if that has not already been done, and returns an error if
 ** any errors are encountered while loading the schema.
 */
 SQLITE_API int sqlite3_table_column_metadata(
 SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata(
   sqlite3 *db,                /* Connection handle */
   const char *zDbName,        /* Database name or NULL */
   const char *zTableName,     /* Table name */

@@ -5449,7 +5520,7 @@ SQLITE_API int sqlite3_table_column_metadata(

 **
 ** See also the [load_extension() SQL function].
 */
 SQLITE_API int sqlite3_load_extension(
 SQLITE_API int SQLITE_STDCALL sqlite3_load_extension(
   sqlite3 *db,          /* Load the extension into this database connection */
   const char *zFile,    /* Name of the shared library containing extension */
   const char *zProc,    /* Entry point.  Derived from zFile if 0 */

@@ -5469,7 +5540,7 @@ SQLITE_API int sqlite3_load_extension(

 ** to turn extension loading on and call it with onoff==0 to turn
 ** it back off again.
 */
 SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
 SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff);
 /*
 ** CAPI3REF: Automatically Load Statically Linked Extensions

@@ -5507,7 +5578,7 @@ SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);

 ** See also: [sqlite3_reset_auto_extension()]
 ** and [sqlite3_cancel_auto_extension()]
 */
 SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
 SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension(void (*xEntryPoint)(void));
 /*
 ** CAPI3REF: Cancel Automatic Extension Loading

@@ -5519,7 +5590,7 @@ SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));

 ** unregistered and it returns 0 if X was not on the list of initialization
 ** routines.
 */
 SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
 SQLITE_API int SQLITE_STDCALL sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
 /*
 ** CAPI3REF: Reset Automatic Extension Loading

@@ -5527,7 +5598,7 @@ SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));

 ** ^This interface disables all automatic extensions previously
 ** registered using [sqlite3_auto_extension()].
 */
 SQLITE_API void sqlite3_reset_auto_extension(void);
 SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension(void);
 /*
 ** The interface to the virtual-table mechanism is currently considered

@@ -5730,13 +5801,13 @@ struct sqlite3_index_info {

 ** interface is equivalent to sqlite3_create_module_v2() with a NULL
 ** destructor.
 */
 SQLITE_API int sqlite3_create_module(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_module(
   sqlite3 *db,               /* SQLite connection to register module with */
   const char *zName,         /* Name of the module */
   const sqlite3_module *p,   /* Methods for the module */
   void *pClientData          /* Client data for xCreate/xConnect */
 );
 SQLITE_API int sqlite3_create_module_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2(
   sqlite3 *db,               /* SQLite connection to register module with */
   const char *zName,         /* Name of the module */
   const sqlite3_module *p,   /* Methods for the module */

@@ -5764,7 +5835,7 @@ SQLITE_API int sqlite3_create_module_v2(

 */
 struct sqlite3_vtab {
   const sqlite3_module *pModule;  /* The module for this virtual table */
   int nRef;                       /* NO LONGER USED */
   int nRef;                       /* Number of open cursors */
   char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
   /* Virtual table implementations will typically add additional fields */
 };

@@ -5799,7 +5870,7 @@ struct sqlite3_vtab_cursor {

 ** to declare the format (the names and datatypes of the columns) of
 ** the virtual tables they implement.
 */
 SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
 SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3*, const char *zSQL);
 /*
 ** CAPI3REF: Overload A Function For A Virtual Table

@@ -5817,7 +5888,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);

 ** purpose is to be a placeholder function that can be overloaded
 ** by a [virtual table].
 */
 SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
 SQLITE_API int SQLITE_STDCALL sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
 /*
 ** The interface to the virtual-table mechanism defined above (back up

@@ -5914,7 +5985,7 @@ typedef struct sqlite3_blob sqlite3_blob;

 ** To avoid a resource leak, every open [BLOB handle] should eventually
 ** be released by a call to [sqlite3_blob_close()].
 */
 SQLITE_API int sqlite3_blob_open(
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_open(
   sqlite3*,
   const char *zDb,
   const char *zTable,

@@ -5946,7 +6017,7 @@ SQLITE_API int sqlite3_blob_open(

 **
 ** ^This function sets the database handle error code and message.
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
 SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
 /*
 ** CAPI3REF: Close A BLOB Handle

@@ -5968,7 +6039,7 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_i

 ** is passed a valid open blob handle, the values returned by the
 ** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning.
 */
 SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *);
 /*
 ** CAPI3REF: Return The Size Of An Open BLOB

@@ -5983,7 +6054,7 @@ SQLITE_API int sqlite3_blob_close(sqlite3_blob *);

 ** been closed by [sqlite3_blob_close()].  Passing any other pointer in
 ** to this routine results in undefined and probably undesirable behavior.
 */
 SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *);
 /*
 ** CAPI3REF: Read Data From A BLOB Incrementally

@@ -6011,7 +6082,7 @@ SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);

 **
 ** See also: [sqlite3_blob_write()].
 */
 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
 /*
 ** CAPI3REF: Write Data Into A BLOB Incrementally

@@ -6052,7 +6123,7 @@ SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);

 **
 ** See also: [sqlite3_blob_read()].
 */
 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
 /*
 ** CAPI3REF: Virtual File System Objects

@@ -6083,9 +6154,9 @@ SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOff

 ** ^(If the default VFS is unregistered, another VFS is chosen as
 ** the default.  The choice for the new VFS is arbitrary.)^
 */
 SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
 SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
 SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
 SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(const char *zVfsName);
 SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
 SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs*);
 /*
 ** CAPI3REF: Mutexes

@@ -6198,11 +6269,11 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);

 **
 ** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
 */
 SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
 SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(int);
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex*);
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex*);
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex*);
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex*);
 /*
 ** CAPI3REF: Mutex Methods Object

@@ -6312,8 +6383,8 @@ struct sqlite3_mutex_methods {

 ** interface should also return 1 when given a NULL pointer.
 */
 #ifndef NDEBUG
 SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
 SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex*);
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex*);
 #endif
 /*

@@ -6349,7 +6420,7 @@ SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);

 ** ^If the [threading mode] is Single-thread or Multi-thread then this
 ** routine returns a NULL pointer.
 */
 SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3*);
 /*
 ** CAPI3REF: Low-Level Control Of Database Files

@@ -6383,7 +6454,7 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);

 **
 ** See also: [SQLITE_FCNTL_LOCKSTATE]
 */
 SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
 SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
 /*
 ** CAPI3REF: Testing Interface

@@ -6402,7 +6473,7 @@ SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*

 ** Unlike most of the SQLite API, this function is not guaranteed to
 ** operate consistently from one release to the next.
 */
 SQLITE_API int sqlite3_test_control(int op, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...);
 /*
 ** CAPI3REF: Testing Interface Operation Codes

@@ -6436,12 +6507,13 @@ SQLITE_API int sqlite3_test_control(int op, ...);

 #define SQLITE_TESTCTRL_BYTEORDER               22
 #define SQLITE_TESTCTRL_ISINIT                  23
 #define SQLITE_TESTCTRL_SORTER_MMAP             24
 #define SQLITE_TESTCTRL_LAST                    24
 #define SQLITE_TESTCTRL_IMPOSTER                25
 #define SQLITE_TESTCTRL_LAST                    25
 /*
 ** CAPI3REF: SQLite Runtime Status
 **
 ** ^This interface is used to retrieve runtime status information
 ** ^These interfaces are used to retrieve runtime status information
 ** about the performance of SQLite, and optionally to reset various
 ** highwater marks.  ^The first argument is an integer code for
 ** the specific parameter to measure.  ^(Recognized integer codes

@@ -6455,19 +6527,22 @@ SQLITE_API int sqlite3_test_control(int op, ...);

 ** ^(Other parameters record only the highwater mark and not the current
 ** value.  For these latter parameters nothing is written into *pCurrent.)^
 **
 ** ^The sqlite3_status() routine returns SQLITE_OK on success and a
 ** non-zero [error code] on failure.
 ** ^The sqlite3_status() and sqlite3_status64() routines return
 ** SQLITE_OK on success and a non-zero [error code] on failure.
 **
 ** This routine is threadsafe but is not atomic.  This routine can be
 ** called while other threads are running the same or different SQLite
 ** interfaces.  However the values returned in *pCurrent and
 ** *pHighwater reflect the status of SQLite at different points in time
 ** and it is possible that another thread might change the parameter
 ** in between the times when *pCurrent and *pHighwater are written.
 ** If either the current value or the highwater mark is too large to
 ** be represented by a 32-bit integer, then the values returned by
 ** sqlite3_status() are undefined.
 **
 ** See also: [sqlite3_db_status()]
 */
 SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
 SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
 SQLITE_API int SQLITE_STDCALL sqlite3_status64(
   int op,
   sqlite3_int64 *pCurrent,
   sqlite3_int64 *pHighwater,
   int resetFlag
 );
 /*

@@ -6585,7 +6660,7 @@ SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetF

 **
 ** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
 */
 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
 SQLITE_API int SQLITE_STDCALL sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
 /*
 ** CAPI3REF: Status Parameters for database connections

@@ -6714,7 +6789,7 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r

 **
 ** See also: [sqlite3_status()] and [sqlite3_db_status()].
 */
 SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
 /*
 ** CAPI3REF: Status Parameters for prepared statements

@@ -7137,20 +7212,20 @@ typedef struct sqlite3_backup sqlite3_backup;

 ** is not a permanent error and does not affect the return value of
 ** sqlite3_backup_finish().
 **
 ** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]]
 ** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]]
 ** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
 **
 ** ^Each call to sqlite3_backup_step() sets two values inside
 ** the [sqlite3_backup] object: the number of pages still to be backed
 ** up and the total number of pages in the source database file.
 ** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces
 ** retrieve these two values, respectively.
 **
 ** ^The values returned by these functions are only updated by
 ** sqlite3_backup_step(). ^If the source database is modified during a backup
 ** operation, then the values are not updated to account for any extra
 ** pages that need to be updated or the size of the source database file
 ** changing.
 ** ^The sqlite3_backup_remaining() routine returns the number of pages still
 ** to be backed up at the conclusion of the most recent sqlite3_backup_step().
 ** ^The sqlite3_backup_pagecount() routine returns the total number of pages
 ** in the source database at the conclusion of the most recent
 ** sqlite3_backup_step().
 ** ^(The values returned by these functions are only updated by
 ** sqlite3_backup_step(). If the source database is modified in a way that
 ** changes the size of the source database or the number of pages remaining,
 ** those changes are not reflected in the output of sqlite3_backup_pagecount()
 ** and sqlite3_backup_remaining() until after the next
 ** sqlite3_backup_step().)^
 **
 ** <b>Concurrent Usage of Database Handles</b>
 **

@@ -7183,16 +7258,16 @@ typedef struct sqlite3_backup sqlite3_backup;

 ** same time as another thread is invoking sqlite3_backup_step() it is
 ** possible that they return invalid values.
 */
 SQLITE_API sqlite3_backup *sqlite3_backup_init(
 SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init(
   sqlite3 *pDest,                        /* Destination database handle */
   const char *zDestName,                 /* Destination database name */
   sqlite3 *pSource,                      /* Source database handle */
   const char *zSourceName                /* Source database name */
 );
 SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
 SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
 SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
 SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p);
 /*
 ** CAPI3REF: Unlock Notification

@@ -7308,7 +7383,7 @@ SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);

 ** the special "DROP TABLE/INDEX" case, the extended error code is just
 ** SQLITE_LOCKED.)^
 */
 SQLITE_API int sqlite3_unlock_notify(
 SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify(
   sqlite3 *pBlocked,                          /* Waiting connection */
   void (*xNotify)(void **apArg, int nArg),    /* Callback function to invoke */
   void *pNotifyArg                            /* Argument to pass to xNotify */

@@ -7323,8 +7398,8 @@ SQLITE_API int sqlite3_unlock_notify(

 ** strings in a case-independent fashion, using the same definition of "case
 ** independence" that SQLite uses internally when comparing identifiers.
 */
 SQLITE_API int sqlite3_stricmp(const char *, const char *);
 SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
 SQLITE_API int SQLITE_STDCALL sqlite3_stricmp(const char *, const char *);
 SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp(const char *, const char *, int);
 /*
 ** CAPI3REF: String Globbing

@@ -7339,7 +7414,7 @@ SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);

 ** Note that this routine returns zero on a match and non-zero if the strings
 ** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
 */
 SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);
 SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlob, const char *zStr);
 /*
 ** CAPI3REF: Error Logging Interface

@@ -7362,7 +7437,7 @@ SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);

 ** a few hundred characters, it will be truncated to the length of the
 ** buffer.
 */
 SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
 SQLITE_API void SQLITE_CDECL sqlite3_log(int iErrCode, const char *zFormat, ...);
 /*
 ** CAPI3REF: Write-Ahead Log Commit Hook

@@ -7397,7 +7472,7 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);

 ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
 ** those overwrite any prior [sqlite3_wal_hook()] settings.
 */
 SQLITE_API void *sqlite3_wal_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook(
   sqlite3*,
   int(*)(void *,sqlite3*,const char*,int),
   void*

@@ -7431,7 +7506,7 @@ SQLITE_API void *sqlite3_wal_hook(

 ** is only necessary if the default setting is found to be suboptimal
 ** for a particular application.
 */
 SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
 /*
 ** CAPI3REF: Checkpoint a database

@@ -7452,7 +7527,7 @@ SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);

 ** start a callback but which do not need the full power (and corresponding
 ** complication) of [sqlite3_wal_checkpoint_v2()].
 */
 SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
 /*
 ** CAPI3REF: Checkpoint a database

@@ -7545,7 +7620,7 @@ SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);

 ** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface
 ** from SQL.
 */
 SQLITE_API int sqlite3_wal_checkpoint_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2(
   sqlite3 *db,                    /* Database handle */
   const char *zDb,                /* Name of attached database (or NULL) */
   int eMode,                      /* SQLITE_CHECKPOINT_* value */

@@ -7581,7 +7656,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(

 ** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].)  Further options
 ** may be added in the future.
 */
 SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3*, int op, ...);
 /*
 ** CAPI3REF: Virtual Table Configuration Options

@@ -7634,7 +7709,7 @@ SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);

 ** of the SQL statement that triggered the call to the [xUpdate] method of the
 ** [virtual table].
 */
 SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
 SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *);
 /*
 ** CAPI3REF: Conflict resolution modes

@@ -7738,7 +7813,7 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);

 **
 ** See also: [sqlite3_stmt_scanstatus_reset()]
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_scanstatus(
 SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL sqlite3_stmt_scanstatus(
   sqlite3_stmt *pStmt,      /* Prepared statement for which info desired */
   int idx,                  /* Index of loop to report on */
   int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */

@@ -7753,7 +7828,7 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_scanstatus(

 ** This API is only available if the library is built with pre-processor
 ** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined.
 */
 SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
 SQLITE_API SQLITE_EXPERIMENTAL void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
 /*

@@ -7808,7 +7883,7 @@ typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info;

 **
 **   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
 */
 SQLITE_API int sqlite3_rtree_geometry_callback(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback(
   sqlite3 *db,
   const char *zGeom,
   int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*),

@@ -7834,7 +7909,7 @@ struct sqlite3_rtree_geometry {

 **
 **   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zQueryFunc(... params ...)
 */
 SQLITE_API int sqlite3_rtree_query_callback(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback(
   sqlite3 *db,
   const char *zQueryFunc,
   int (*xQueryFunc)(sqlite3_rtree_query_info*),

@@ -7998,15 +8073,17 @@ struct sqlite3_rtree_query_info {

 #endif
 /*
 ** The maximum number of in-memory pages to use for the main database
 ** table and for temporary tables.  The SQLITE_DEFAULT_CACHE_SIZE
 ** The suggested maximum number of in-memory pages to use for
 ** the main database table and for temporary tables.
 **
 ** IMPLEMENTATION-OF: R-31093-59126 The default suggested cache size
 ** is 2000 pages.
 ** IMPLEMENTATION-OF: R-48205-43578 The default suggested cache size can be
 ** altered using the SQLITE_DEFAULT_CACHE_SIZE compile-time options.
 */
 #ifndef SQLITE_DEFAULT_CACHE_SIZE
 # define SQLITE_DEFAULT_CACHE_SIZE  2000
 #endif
 #ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
 # define SQLITE_DEFAULT_TEMP_CACHE_SIZE  500
 #endif
 /*
 ** The default number of frames to accumulate in the log file before

@@ -8851,6 +8928,20 @@ typedef INT8_TYPE i8; /* 1-byte signed integer */

 typedef INT16_TYPE LogEst;
 /*
 ** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer
 */
 #ifndef SQLITE_PTRSIZE
 # if defined(__SIZEOF_POINTER__)
 #   define SQLITE_PTRSIZE __SIZEOF_POINTER__
 # elif defined(i386)     || defined(__i386__)   || defined(_M_IX86) ||    \
        defined(_M_ARM)   || defined(__arm__)    || defined(__x86)
 #   define SQLITE_PTRSIZE 4
 # else
 #   define SQLITE_PTRSIZE 8
 # endif
 #endif
 /*
 ** Macros to determine whether the machine is big or little endian,
 ** and whether or not that determination is run-time or compile-time.
 **

@@ -9062,8 +9153,8 @@ struct BusyHandler {

   #define SQLITE_WSD const
   #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
   #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
 SQLITE_API   int sqlite3_wsd_init(int N, int J);
 SQLITE_API   void *sqlite3_wsd_find(void *K, int L);
 SQLITE_API int SQLITE_STDCALL sqlite3_wsd_init(int N, int J);
 SQLITE_API void *SQLITE_STDCALL sqlite3_wsd_find(void *K, int L);
 #else
   #define SQLITE_WSD
   #define GLOBAL(t,v) v

@@ -9221,10 +9312,8 @@ SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*);

 SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int);
 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
 SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int);
 SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*);
 #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_DEBUG)
 SQLITE_PRIVATE int sqlite3BtreeGetOptimalReserve(Btree*);
 SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p);
 #endif
 SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int);
 SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *);
 SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int);

@@ -9302,8 +9391,18 @@ SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p);

 /*
 ** Values that may be OR'd together to form the second argument of an
 ** sqlite3BtreeCursorHints() call.
 **
 ** The BTREE_BULKLOAD flag is set on index cursors when the index is going
 ** to be filled with content that is already in sorted order.
 **
 ** The BTREE_SEEK_EQ flag is set on cursors that will get OP_SeekGE or
 ** OP_SeekLE opcodes for a range search, but where the range of entries
 ** selected will all have the same key.  In other words, the cursor will
 ** be used only for equality key searches.
 **
 */
 #define BTREE_BULKLOAD 0x00000001
 #define BTREE_BULKLOAD 0x00000001  /* Used to full index in sorted order */
 #define BTREE_SEEK_EQ  0x00000002  /* EQ seeks only - no range seeks */
 SQLITE_PRIVATE int sqlite3BtreeCursor(
   Btree*,                              /* BTree containing table to open */

@@ -9349,6 +9448,9 @@ SQLITE_PRIVATE void sqlite3BtreeIncrblobCursor(BtCursor *);

 SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *);
 SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion);
 SQLITE_PRIVATE void sqlite3BtreeCursorHints(BtCursor *, unsigned int mask);
 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor*, unsigned int mask);
 #endif
 SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *pBt);
 SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void);

@@ -9715,23 +9817,25 @@ typedef struct VdbeOpList VdbeOpList;

 #define OP_MemMax        136 /* synopsis: r[P1]=max(r[P1],r[P2])           */
 #define OP_IfPos         137 /* synopsis: if r[P1]>0 goto P2               */
 #define OP_IfNeg         138 /* synopsis: r[P1]+=P3, if r[P1]<0 goto P2    */
 #define OP_IfZero        139 /* synopsis: r[P1]+=P3, if r[P1]==0 goto P2   */
 #define OP_AggFinal      140 /* synopsis: accum=r[P1] N=P2                 */
 #define OP_IncrVacuum    141
 #define OP_Expire        142
 #define OP_TableLock     143 /* synopsis: iDb=P1 root=P2 write=P3          */
 #define OP_VBegin        144
 #define OP_VCreate       145
 #define OP_VDestroy      146
 #define OP_VOpen         147
 #define OP_VColumn       148 /* synopsis: r[P3]=vcolumn(P2)                */
 #define OP_VNext         149
 #define OP_VRename       150
 #define OP_Pagecount     151
 #define OP_MaxPgcnt      152
 #define OP_Init          153 /* synopsis: Start at P2                      */
 #define OP_Noop          154
 #define OP_Explain       155
 #define OP_IfNotZero     139 /* synopsis: if r[P1]!=0 then r[P1]+=P3, goto P2 */
 #define OP_DecrJumpZero  140 /* synopsis: if (--r[P1])==0 goto P2          */
 #define OP_JumpZeroIncr  141 /* synopsis: if (r[P1]++)==0 ) goto P2        */
 #define OP_AggFinal      142 /* synopsis: accum=r[P1] N=P2                 */
 #define OP_IncrVacuum    143
 #define OP_Expire        144
 #define OP_TableLock     145 /* synopsis: iDb=P1 root=P2 write=P3          */
 #define OP_VBegin        146
 #define OP_VCreate       147
 #define OP_VDestroy      148
 #define OP_VOpen         149
 #define OP_VColumn       150 /* synopsis: r[P3]=vcolumn(P2)                */
 #define OP_VNext         151
 #define OP_VRename       152
 #define OP_Pagecount     153
 #define OP_MaxPgcnt      154
 #define OP_Init          155 /* synopsis: Start at P2                      */
 #define OP_Noop          156
 #define OP_Explain       157
 /* Properties such as "out2" or "jump" that are specified in

@@ -9763,9 +9867,9 @@ typedef struct VdbeOpList VdbeOpList;

 /* 112 */ 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x00, 0x00,\
 /* 120 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
 /* 128 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x02, 0x00, 0x01,\
 /* 136 */ 0x08, 0x05, 0x05, 0x05, 0x00, 0x01, 0x00, 0x00,\
 /* 144 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02,\
 /* 152 */ 0x02, 0x01, 0x00, 0x00,}
 /* 136 */ 0x08, 0x05, 0x05, 0x05, 0x05, 0x05, 0x00, 0x01,\
 /* 144 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\
 /* 152 */ 0x00, 0x02, 0x02, 0x01, 0x00, 0x00,}
 /************** End of opcodes.h *********************************************/
 /************** Continuing where we left off in vdbe.h ***********************/

@@ -10841,11 +10945,13 @@ struct sqlite3 {

     u8 iDb;                     /* Which db file is being initialized */
     u8 busy;                    /* TRUE if currently initializing */
     u8 orphanTrigger;           /* Last statement is orphaned TEMP trigger */
     u8 imposterTable;           /* Building an imposter table */
   } init;
   int nVdbeActive;              /* Number of VDBEs currently running */
   int nVdbeRead;                /* Number of active VDBEs that read or write */
   int nVdbeWrite;               /* Number of active VDBEs that read and write */
   int nVdbeExec;                /* Number of nested calls to VdbeExec() */
   int nVDestroy;                /* Number of active OP_VDestroy operations */
   int nExtension;               /* Number of loaded extensions */
   void **aExtension;            /* Array of shared library handles */
   void (*xTrace)(void*,const char*);        /* Trace function */

@@ -11797,8 +11903,14 @@ struct Expr {

 #define EP_MemToken  0x010000 /* Need to sqlite3DbFree() Expr.zToken */
 #define EP_NoReduce  0x020000 /* Cannot EXPRDUP_REDUCE this Expr */
 #define EP_Unlikely  0x040000 /* unlikely() or likelihood() function */
 #define EP_Constant  0x080000 /* Node is a constant */
 #define EP_ConstFunc 0x080000 /* Node is a SQLITE_FUNC_CONSTANT function */
 #define EP_CanBeNull 0x100000 /* Can be null despite NOT NULL constraint */
 #define EP_Subquery  0x200000 /* Tree contains a TK_SELECT operator */
 /*
 ** Combinations of two or more EP_* flags
 */
 #define EP_Propagate (EP_Collate|EP_Subquery) /* Propagate these bits up tree */
 /*
 ** These macros can be used to test, set, or clear bits in the

@@ -11997,7 +12109,7 @@ struct SrcList {

 #define WHERE_OMIT_OPEN_CLOSE  0x0010 /* Table cursors are already open */
 #define WHERE_FORCE_TABLE      0x0020 /* Do not use an index-only search */
 #define WHERE_ONETABLE_ONLY    0x0040 /* Only code the 1st table in pTabList */
                           /*   0x0080 // not currently used */
 #define WHERE_NO_AUTOINDEX     0x0080 /* Disallow automatic indexes */
 #define WHERE_GROUPBY          0x0100 /* pOrderBy is really a GROUP BY */
 #define WHERE_DISTINCTBY       0x0200 /* pOrderby is really a DISTINCT clause */
 #define WHERE_WANT_DISTINCT    0x0400 /* All output needs to be distinct */

@@ -12116,6 +12228,7 @@ struct Select {

 #define SF_MaybeConvert    0x0400  /* Need convertCompoundSelectToSubquery() */
 #define SF_Recursive       0x0800  /* The recursive part of a recursive CTE */
 #define SF_MinMaxAgg       0x1000  /* Aggregate containing min() or max() */
 #define SF_Converted       0x2000  /* By convertCompoundSelectToSubquery() */
 /*

@@ -12434,7 +12547,8 @@ struct AuthContext {

 #define OPFLAG_LENGTHARG     0x40    /* OP_Column only used for length() */
 #define OPFLAG_TYPEOFARG     0x80    /* OP_Column only used for typeof() */
 #define OPFLAG_BULKCSR       0x01    /* OP_Open** used to open bulk cursor */
 #define OPFLAG_P2ISREG       0x02    /* P2 to OP_Open** is a register number */
 #define OPFLAG_SEEKEQ        0x02    /* OP_Open** cursor uses EQ seek only */
 #define OPFLAG_P2ISREG       0x04    /* P2 to OP_Open** is a register number */
 #define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */
 /*

@@ -12838,10 +12952,15 @@ SQLITE_PRIVATE int sqlite3MutexInit(void);

 SQLITE_PRIVATE   int sqlite3MutexEnd(void);
 #endif
 SQLITE_PRIVATE int sqlite3StatusValue(int);
 SQLITE_PRIVATE void sqlite3StatusAdd(int, int);
 SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int);
 SQLITE_PRIVATE void sqlite3StatusUp(int, int);
 SQLITE_PRIVATE void sqlite3StatusDown(int, int);
 SQLITE_PRIVATE void sqlite3StatusSet(int, int);
 /* Access to mutexes used by sqlite3_status() */
 SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void);
 SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void);
 #ifndef SQLITE_OMIT_FLOATING_POINT
 SQLITE_PRIVATE   int sqlite3IsNaN(double);
 #else

@@ -12906,6 +13025,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);

 SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
 SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*);
 SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**);
 SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);
 SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);

@@ -13220,7 +13340,7 @@ SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);

 SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*);
 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*, int);
 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse*,Expr*,const char*);
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*);
 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *);

@@ -13489,12 +13609,11 @@ SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *);

 SQLITE_PRIVATE int sqlite3MemJournalSize(void);
 SQLITE_PRIVATE int sqlite3IsMemJournal(sqlite3_file *);
 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
 #if SQLITE_MAX_EXPR_DEPTH>0
 SQLITE_PRIVATE   void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
 SQLITE_PRIVATE   int sqlite3SelectExprHeight(Select *);
 SQLITE_PRIVATE   int sqlite3ExprCheckHeight(Parse*, int);
 #else
   #define sqlite3ExprSetHeight(x,y)
   #define sqlite3SelectExprHeight(x) 0
   #define sqlite3ExprCheckHeight(x,y)
 #endif

@@ -13524,7 +13643,7 @@ SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *);

 #ifdef SQLITE_ENABLE_IOTRACE
 # define IOTRACE(A)  if( sqlite3IoTrace ){ sqlite3IoTrace A; }
 SQLITE_PRIVATE   void sqlite3VdbeIOTraceSql(Vdbe*);
 void (*sqlite3IoTrace)(const char*,...);
 SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(const char*,...);
 #else
 # define IOTRACE(A)
 # define sqlite3VdbeIOTraceSql(X)

@@ -13631,16 +13750,16 @@ SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = {

 , 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
 , 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
 , 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
 , 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
 , 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
 , 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, /* 6x */
 ,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127, /* 7x */
 ,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
 ,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */
 ,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, /* 9x */
 ,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
 ,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
 ,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
 ,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
 ,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */
 ,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */
 ,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239, /* Ex */
 ,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255, /* Fx */
 #endif
 };

@@ -14237,7 +14356,7 @@ static const char * const azCompileOpt[] = {

 ** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
 ** is not required for a match.
 */
 SQLITE_API int sqlite3_compileoption_used(const char *zOptName){
 SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName){
   int i, n;
 #if SQLITE_ENABLE_API_ARMOR

@@ -14265,7 +14384,7 @@ SQLITE_API int sqlite3_compileoption_used(const char *zOptName){

 ** Return the N-th compile-time option string.  If N is out of range,
 ** return a NULL pointer.
 */
 SQLITE_API const char *sqlite3_compileoption_get(int N){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_compileoption_get(int N){
   if( N>=0 && N<ArraySize(azCompileOpt) ){
     return azCompileOpt[N];
   }

@@ -14608,14 +14727,6 @@ struct ScanStatus {

 **
 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
 ** is really a pointer to an instance of this structure.
 **
 ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
 ** any virtual table method invocations made by the vdbe program. It is
 ** set to 2 for xDestroy method calls and 1 for all other methods. This
 ** variable is used for two purposes: to allow xDestroy methods to execute
 ** "DROP TABLE" statements and to prevent some nasty side effects of
 ** malloc failure when SQLite is invoked recursively by a virtual table
 ** method function.
 */
 struct Vdbe {
   sqlite3 *db;            /* The database connection that owns this statement */

@@ -14639,11 +14750,13 @@ struct Vdbe {

   u32 cacheCtr;           /* VdbeCursor row cache generation counter */
   int pc;                 /* The program counter */
   int rc;                 /* Value to return */
 #ifdef SQLITE_DEBUG
   int rcApp;              /* errcode set by sqlite3_result_error_code() */
 #endif
   u16 nResColumn;         /* Number of columns in one row of the result set */
   u8 errorAction;         /* Recovery action to do in case of an error */
   u8 minWriteFileFormat;  /* Minimum file format for writable database files */
   bft explain:2;          /* True if EXPLAIN present on SQL command */
   bft inVtabMethod:2;     /* See comments above */
   bft changeCntOn:1;      /* True to update the change-counter */
   bft expired:1;          /* True if the VM needs to be recompiled */
   bft runOnlyOnce:1;      /* Automatically expire on reset */

@@ -14803,10 +14916,32 @@ SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *);

 */
 typedef struct sqlite3StatType sqlite3StatType;
 static SQLITE_WSD struct sqlite3StatType {
   int nowValue[10];         /* Current value */
   int mxValue[10];          /* Maximum value */
 #if SQLITE_PTRSIZE>4
   sqlite3_int64 nowValue[10];         /* Current value */
   sqlite3_int64 mxValue[10];          /* Maximum value */
 #else
   u32 nowValue[10];                   /* Current value */
   u32 mxValue[10];                    /* Maximum value */
 #endif
 } sqlite3Stat = { {0,}, {0,} };
 /*
 ** Elements of sqlite3Stat[] are protected by either the memory allocator
 ** mutex, or by the pcache1 mutex.  The following array determines which.
 */
 static const char statMutex[] = {
 ,  /* SQLITE_STATUS_MEMORY_USED */
 ,  /* SQLITE_STATUS_PAGECACHE_USED */
 ,  /* SQLITE_STATUS_PAGECACHE_OVERFLOW */
 ,  /* SQLITE_STATUS_SCRATCH_USED */
 ,  /* SQLITE_STATUS_SCRATCH_OVERFLOW */
 ,  /* SQLITE_STATUS_MALLOC_SIZE */
 ,  /* SQLITE_STATUS_PARSER_STACK */
 ,  /* SQLITE_STATUS_PAGECACHE_SIZE */
 ,  /* SQLITE_STATUS_SCRATCH_SIZE */
 ,  /* SQLITE_STATUS_MALLOC_COUNT */
 };
 /* The "wsdStat" macro will resolve to the status information
 ** state vector.  If writable static data is unsupported on the target,

@@ -14823,33 +14958,60 @@ static SQLITE_WSD struct sqlite3StatType {

 #endif
 /*
 ** Return the current value of a status parameter.
 ** Return the current value of a status parameter.  The caller must
 ** be holding the appropriate mutex.
 */
 SQLITE_PRIVATE int sqlite3StatusValue(int op){
 SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int op){
   wsdStatInit;
   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
   assert( op>=0 && op<ArraySize(statMutex) );
   assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
                                            : sqlite3MallocMutex()) );
   return wsdStat.nowValue[op];
 }
 /*
 ** Add N to the value of a status record.  It is assumed that the
 ** caller holds appropriate locks.
 ** Add N to the value of a status record.  The caller must hold the
 ** appropriate mutex.  (Locking is checked by assert()).
 **
 ** The StatusUp() routine can accept positive or negative values for N.
 ** The value of N is added to the current status value and the high-water
 ** mark is adjusted if necessary.
 **
 ** The StatusDown() routine lowers the current value by N.  The highwater
 ** mark is unchanged.  N must be non-negative for StatusDown().
 */
 SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
 SQLITE_PRIVATE void sqlite3StatusUp(int op, int N){
   wsdStatInit;
   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
   assert( op>=0 && op<ArraySize(statMutex) );
   assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
                                            : sqlite3MallocMutex()) );
   wsdStat.nowValue[op] += N;
   if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
     wsdStat.mxValue[op] = wsdStat.nowValue[op];
   }
 }
 SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){
   wsdStatInit;
   assert( N>=0 );
   assert( op>=0 && op<ArraySize(statMutex) );
   assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
                                            : sqlite3MallocMutex()) );
   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
   wsdStat.nowValue[op] -= N;
 }
 /*
 ** Set the value of a status to X.
 ** Set the value of a status to X.  The highwater mark is adjusted if
 ** necessary.  The caller must hold the appropriate mutex.
 */
 SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){
   wsdStatInit;
   assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
   assert( op>=0 && op<ArraySize(statMutex) );
   assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
                                            : sqlite3MallocMutex()) );
   wsdStat.nowValue[op] = X;
   if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
     wsdStat.mxValue[op] = wsdStat.nowValue[op];

@@ -14858,12 +15020,14 @@ SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){

 /*
 ** Query status information.
 **
 ** This implementation assumes that reading or writing an aligned
 ** 32-bit integer is an atomic operation.  If that assumption is not true,
 ** then this routine is not threadsafe.
 */
 SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
 SQLITE_API int SQLITE_STDCALL sqlite3_status64(
   int op,
   sqlite3_int64 *pCurrent,
   sqlite3_int64 *pHighwater,
   int resetFlag
 ){
   sqlite3_mutex *pMutex;
   wsdStatInit;
   if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
     return SQLITE_MISUSE_BKPT;

@@ -14871,18 +15035,35 @@ SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetF

 #ifdef SQLITE_ENABLE_API_ARMOR
   if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
   sqlite3_mutex_enter(pMutex);
   *pCurrent = wsdStat.nowValue[op];
   *pHighwater = wsdStat.mxValue[op];
   if( resetFlag ){
     wsdStat.mxValue[op] = wsdStat.nowValue[op];
   }
   sqlite3_mutex_leave(pMutex);
   (void)pMutex;  /* Prevent warning when SQLITE_THREADSAFE=0 */
   return SQLITE_OK;
 }
 SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
   sqlite3_int64 iCur, iHwtr;
   int rc;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
   if( rc==0 ){
     *pCurrent = (int)iCur;
     *pHighwater = (int)iHwtr;
   }
   return rc;
 }
 /*
 ** Query status information for a single database connection
 */
 SQLITE_API int sqlite3_db_status(
 SQLITE_API int SQLITE_STDCALL sqlite3_db_status(
   sqlite3 *db,          /* The database connection whose status is desired */
   int op,               /* Status verb */
   int *pCurrent,        /* Write current value here */

@@ -16506,7 +16687,7 @@ static sqlite3_vfs * SQLITE_WSD vfsList = 0;

 ** Locate a VFS by name.  If no name is given, simply return the
 ** first VFS on the list.
 */
 SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
 SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(const char *zVfs){
   sqlite3_vfs *pVfs = 0;
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex;

@@ -16552,7 +16733,7 @@ static void vfsUnlink(sqlite3_vfs *pVfs){

 ** VFS multiple times.  The new VFS becomes the default if makeDflt is
 ** true.
 */
 SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
 SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
   MUTEX_LOGIC(sqlite3_mutex *mutex;)
 #ifndef SQLITE_OMIT_AUTOINIT
   int rc = sqlite3_initialize();

@@ -16580,7 +16761,7 @@ SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){

 /*
 ** Unregister a VFS so that it is no longer accessible.
 */
 SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
 SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif

@@ -18916,7 +19097,7 @@ SQLITE_PRIVATE int sqlite3MutexEnd(void){

 /*
 ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
 */
 SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int id){
 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(int id){
 #ifndef SQLITE_OMIT_AUTOINIT
   if( id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() ) return 0;
   if( id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() ) return 0;

@@ -18935,7 +19116,7 @@ SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){

 /*
 ** Free a dynamic mutex.
 */
 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex *p){
   if( p ){
     sqlite3GlobalConfig.mutex.xMutexFree(p);
   }

@@ -18945,7 +19126,7 @@ SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){

 ** Obtain the mutex p. If some other thread already has the mutex, block
 ** until it can be obtained.
 */
 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex *p){
   if( p ){
     sqlite3GlobalConfig.mutex.xMutexEnter(p);
   }

@@ -18955,7 +19136,7 @@ SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){

 ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
 ** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
 */
 SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex *p){
   int rc = SQLITE_OK;
   if( p ){
     return sqlite3GlobalConfig.mutex.xMutexTry(p);

@@ -18969,7 +19150,7 @@ SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){

 ** is not currently entered. If a NULL pointer is passed as an argument
 ** this function is a no-op.
 */
 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex *p){
   if( p ){
     sqlite3GlobalConfig.mutex.xMutexLeave(p);
   }

@@ -18980,10 +19161,10 @@ SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){

 ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
 ** intended for use inside assert() statements.
 */
 SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex *p){
   return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
 }
 SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex *p){
   return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
 }
 #endif

@@ -19113,8 +19294,12 @@ static sqlite3_mutex *debugMutexAlloc(int id){

       break;
     }
     default: {
       assert( id-2 >= 0 );
       assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
 #ifdef SQLITE_ENABLE_API_ARMOR
       if( id-2<0 || id-2>=ArraySize(aStatic) ){
         (void)SQLITE_MISUSE_BKPT;
         return 0;
       }
 #endif
       pNew = &aStatic[id-2];
       pNew->id = id;
       break;

@@ -19129,8 +19314,13 @@ static sqlite3_mutex *debugMutexAlloc(int id){

 static void debugMutexFree(sqlite3_mutex *pX){
   sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
   assert( p->cnt==0 );
   assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
   sqlite3_free(p);
   if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){
     sqlite3_free(p);
   }else{
 #ifdef SQLITE_ENABLE_API_ARMOR
     (void)SQLITE_MISUSE_BKPT;
 #endif
   }
 }
 /*

@@ -19241,8 +19431,10 @@ SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){

 */
 struct sqlite3_mutex {
   pthread_mutex_t mutex;     /* Mutex controlling the lock */
 #if SQLITE_MUTEX_NREF
 #if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
   int id;                    /* Mutex type */
 #endif
 #if SQLITE_MUTEX_NREF
   volatile int nRef;         /* Number of entrances */
   volatile pthread_t owner;  /* Thread that is within this mutex */
   int trace;                 /* True to trace changes */

@@ -19359,18 +19551,12 @@ static sqlite3_mutex *pthreadMutexAlloc(int iType){

         pthread_mutex_init(&p->mutex, &recursiveAttr);
         pthread_mutexattr_destroy(&recursiveAttr);
 #endif
 #if SQLITE_MUTEX_NREF
         p->id = iType;
 #endif
       }
       break;
     }
     case SQLITE_MUTEX_FAST: {
       p = sqlite3MallocZero( sizeof(*p) );
       if( p ){
 #if SQLITE_MUTEX_NREF
         p->id = iType;
 #endif
         pthread_mutex_init(&p->mutex, 0);
       }
       break;

@@ -19383,12 +19569,12 @@ static sqlite3_mutex *pthreadMutexAlloc(int iType){

       }
 #endif
       p = &staticMutexes[iType-2];
 #if SQLITE_MUTEX_NREF
       p->id = iType;
 #endif
       break;
     }
   }
 #if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
   if( p ) p->id = iType;
 #endif
   return p;
 }

@@ -19400,9 +19586,18 @@ static sqlite3_mutex *pthreadMutexAlloc(int iType){

 */
 static void pthreadMutexFree(sqlite3_mutex *p){
   assert( p->nRef==0 );
   assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
   pthread_mutex_destroy(&p->mutex);
   sqlite3_free(p);
 #if SQLITE_ENABLE_API_ARMOR
   if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE )
 #endif
   {
     pthread_mutex_destroy(&p->mutex);
     sqlite3_free(p);
   }
 #ifdef SQLITE_ENABLE_API_ARMOR
   else{
     (void)SQLITE_MISUSE_BKPT;
   }
 #endif
 }
 /*

@@ -19872,6 +20067,17 @@ SQLITE_API int sqlite3_open_file_count = 0;

 # define SQLITE_WIN32_VOLATILE volatile
 #endif
 /*
 ** For some Windows sub-platforms, the _beginthreadex() / _endthreadex()
 ** functions are not available (e.g. those not using MSVC, Cygwin, etc).
 */
 #if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \
     SQLITE_THREADSAFE>0 && !defined(__CYGWIN__)
 # define SQLITE_OS_WIN_THREADS 1
 #else
 # define SQLITE_OS_WIN_THREADS 0
 #endif
 #endif /* _OS_WIN_H_ */
 /************** End of os_win.h **********************************************/

@@ -19954,8 +20160,8 @@ static int winMutex_isNt = -1; /* <0 means "need to query" */

 */
 static LONG SQLITE_WIN32_VOLATILE winMutex_lock = 0;
 SQLITE_API int sqlite3_win32_is_nt(void); /* os_win.c */
 SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */
 SQLITE_API int SQLITE_STDCALL sqlite3_win32_is_nt(void); /* os_win.c */
 SQLITE_API void SQLITE_STDCALL sqlite3_win32_sleep(DWORD milliseconds); /* os_win.c */
 static int winMutexInit(void){
   /* The first to increment to 1 does actual initialization */

@@ -20047,8 +20253,8 @@ static sqlite3_mutex *winMutexAlloc(int iType){

     case SQLITE_MUTEX_RECURSIVE: {
       p = sqlite3MallocZero( sizeof(*p) );
       if( p ){
 #ifdef SQLITE_DEBUG
         p->id = iType;
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC
         p->trace = 1;
 #endif

@@ -20068,12 +20274,9 @@ static sqlite3_mutex *winMutexAlloc(int iType){

         return 0;
       }
 #endif
       assert( iType-2 >= 0 );
       assert( iType-2 < ArraySize(winMutex_staticMutexes) );
       assert( winMutex_isInit==1 );
       p = &winMutex_staticMutexes[iType-2];
 #ifdef SQLITE_DEBUG
       p->id = iType;
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC
       p->trace = 1;
 #endif

@@ -20092,13 +20295,15 @@ static sqlite3_mutex *winMutexAlloc(int iType){

 */
 static void winMutexFree(sqlite3_mutex *p){
   assert( p );
 #ifdef SQLITE_DEBUG
   assert( p->nRef==0 && p->owner==0 );
   assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
   if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){
     DeleteCriticalSection(&p->mutex);
     sqlite3_free(p);
   }else{
 #ifdef SQLITE_ENABLE_API_ARMOR
     (void)SQLITE_MISUSE_BKPT;
 #endif
   assert( winMutex_isInit==1 );
   DeleteCriticalSection(&p->mutex);
   sqlite3_free(p);
   }
 }
 /*

@@ -20252,7 +20457,7 @@ SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){

 ** held by SQLite. An example of non-essential memory is memory used to
 ** cache database pages that are not currently in use.
 */
 SQLITE_API int sqlite3_release_memory(int n){
 SQLITE_API int SQLITE_STDCALL sqlite3_release_memory(int n){
 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
   return sqlite3PcacheReleaseMemory(n);
 #else

@@ -20308,6 +20513,13 @@ static SQLITE_WSD struct Mem0Global {

 #define mem0 GLOBAL(struct Mem0Global, mem0)
 /*
 ** Return the memory allocator mutex. sqlite3_status() needs it.
 */
 SQLITE_PRIVATE sqlite3_mutex *sqlite3MallocMutex(void){
   return mem0.mutex;
 }
 /*
 ** This routine runs when the memory allocator sees that the
 ** total memory allocation is about to exceed the soft heap
 ** limit.

@@ -20329,7 +20541,7 @@ static int sqlite3MemoryAlarm(

   void *pArg,
   sqlite3_int64 iThreshold
 ){
   int nUsed;
   sqlite3_int64 nUsed;
   sqlite3_mutex_enter(mem0.mutex);
   mem0.alarmCallback = xCallback;
   mem0.alarmArg = pArg;

@@ -20345,7 +20557,7 @@ static int sqlite3MemoryAlarm(

 ** Deprecated external interface.  Internal/core SQLite code
 ** should call sqlite3MemoryAlarm.
 */
 SQLITE_API int sqlite3_memory_alarm(
 SQLITE_API int SQLITE_STDCALL sqlite3_memory_alarm(
   void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
   void *pArg,
   sqlite3_int64 iThreshold

@@ -20358,7 +20570,7 @@ SQLITE_API int sqlite3_memory_alarm(

 ** Set the soft heap-size limit for the library. Passing a zero or
 ** negative value indicates no limit.
 */
 SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 n){
   sqlite3_int64 priorLimit;
   sqlite3_int64 excess;
 #ifndef SQLITE_OMIT_AUTOINIT

@@ -20378,7 +20590,7 @@ SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){

   if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
   return priorLimit;
 }
 SQLITE_API void sqlite3_soft_heap_limit(int n){
 SQLITE_API void SQLITE_STDCALL sqlite3_soft_heap_limit(int n){
   if( n<0 ) n = 0;
   sqlite3_soft_heap_limit64(n);
 }

@@ -20387,6 +20599,7 @@ SQLITE_API void sqlite3_soft_heap_limit(int n){

 ** Initialize the memory allocation subsystem.
 */
 SQLITE_PRIVATE int sqlite3MallocInit(void){
   int rc;
   if( sqlite3GlobalConfig.m.xMalloc==0 ){
     sqlite3MemSetDefault();
   }

@@ -20422,7 +20635,9 @@ SQLITE_PRIVATE int sqlite3MallocInit(void){

     sqlite3GlobalConfig.szPage = 0;
     sqlite3GlobalConfig.nPage = 0;
   }
   return sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
   rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
   if( rc!=SQLITE_OK ) memset(&mem0, 0, sizeof(mem0));
   return rc;
 }
 /*

@@ -20447,7 +20662,7 @@ SQLITE_PRIVATE void sqlite3MallocEnd(void){

 /*
 ** Return the amount of memory currently checked out.
 */
 SQLITE_API sqlite3_int64 sqlite3_memory_used(void){
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(void){
   int n, mx;
   sqlite3_int64 res;
   sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);

@@ -20460,7 +20675,7 @@ SQLITE_API sqlite3_int64 sqlite3_memory_used(void){

 ** checked out since either the beginning of this process
 ** or since the most recent reset.
 */
 SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(int resetFlag){
   int n, mx;
   sqlite3_int64 res;
   sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);

@@ -20498,7 +20713,7 @@ static int mallocWithAlarm(int n, void **pp){

   nFull = sqlite3GlobalConfig.m.xRoundup(n);
   sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
   if( mem0.alarmCallback!=0 ){
     int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
     sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
     if( nUsed >= mem0.alarmThreshold - nFull ){
       mem0.nearlyFull = 1;
       sqlite3MallocAlarm(nFull);

@@ -20515,8 +20730,8 @@ static int mallocWithAlarm(int n, void **pp){

 #endif
   if( p ){
     nFull = sqlite3MallocSize(p);
     sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
     sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, 1);
     sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull);
     sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);
   }
   *pp = p;
   return nFull;

@@ -20551,13 +20766,13 @@ SQLITE_PRIVATE void *sqlite3Malloc(u64 n){

 ** First make sure the memory subsystem is initialized, then do the
 ** allocation.
 */
 SQLITE_API void *sqlite3_malloc(int n){
 SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int n){
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   return n<=0 ? 0 : sqlite3Malloc(n);
 }
 SQLITE_API void *sqlite3_malloc64(sqlite3_uint64 n){
 SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64 n){
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif

@@ -20593,14 +20808,14 @@ SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){

     p = mem0.pScratchFree;
     mem0.pScratchFree = mem0.pScratchFree->pNext;
     mem0.nScratchFree--;
     sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
     sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1);
     sqlite3_mutex_leave(mem0.mutex);
   }else{
     sqlite3_mutex_leave(mem0.mutex);
     p = sqlite3Malloc(n);
     if( sqlite3GlobalConfig.bMemstat && p ){
       sqlite3_mutex_enter(mem0.mutex);
       sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p));
       sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p));
       sqlite3_mutex_leave(mem0.mutex);
     }
     sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);

@@ -20641,19 +20856,19 @@ SQLITE_PRIVATE void sqlite3ScratchFree(void *p){

       mem0.pScratchFree = pSlot;
       mem0.nScratchFree++;
       assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
       sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
       sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1);
       sqlite3_mutex_leave(mem0.mutex);
     }else{
       /* Release memory back to the heap */
       assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
       assert( sqlite3MemdebugNoType(p, ~MEMTYPE_SCRATCH) );
       assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_SCRATCH) );
       sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
       if( sqlite3GlobalConfig.bMemstat ){
         int iSize = sqlite3MallocSize(p);
         sqlite3_mutex_enter(mem0.mutex);
         sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
         sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
         sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
         sqlite3StatusDown(SQLITE_STATUS_SCRATCH_OVERFLOW, iSize);
         sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, iSize);
         sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
         sqlite3GlobalConfig.m.xFree(p);
         sqlite3_mutex_leave(mem0.mutex);
       }else{

@@ -20684,7 +20899,7 @@ SQLITE_PRIVATE int sqlite3MallocSize(void *p){

 }
 SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
   if( db==0 ){
     assert( sqlite3MemdebugNoType(p, ~MEMTYPE_HEAP) );
     assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
     assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
     return sqlite3MallocSize(p);
   }else{

@@ -20693,13 +20908,13 @@ SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){

       return db->lookaside.sz;
     }else{
       assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
       assert( sqlite3MemdebugNoType(p, ~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
       assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
       return sqlite3GlobalConfig.m.xSize(p);
     }
   }
 }
 SQLITE_API sqlite3_uint64 sqlite3_msize(void *p){
   assert( sqlite3MemdebugNoType(p, ~MEMTYPE_HEAP) );
 SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void *p){
   assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
   assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
   return (sqlite3_uint64)sqlite3GlobalConfig.m.xSize(p);
 }

@@ -20707,14 +20922,14 @@ SQLITE_API sqlite3_uint64 sqlite3_msize(void *p){

 /*
 ** Free memory previously obtained from sqlite3Malloc().
 */
 SQLITE_API void sqlite3_free(void *p){
 SQLITE_API void SQLITE_STDCALL sqlite3_free(void *p){
   if( p==0 ) return;  /* IMP: R-49053-54554 */
   assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
   assert( sqlite3MemdebugNoType(p, ~MEMTYPE_HEAP) );
   assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
   if( sqlite3GlobalConfig.bMemstat ){
     sqlite3_mutex_enter(mem0.mutex);
     sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
     sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
     sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
     sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
     sqlite3GlobalConfig.m.xFree(p);
     sqlite3_mutex_leave(mem0.mutex);
   }else{

@@ -20755,7 +20970,7 @@ SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){

     }
   }
   assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
   assert( sqlite3MemdebugNoType(p, ~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
   assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
   assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
   sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
   sqlite3_free(p);

@@ -20768,7 +20983,7 @@ SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){

   int nOld, nNew, nDiff;
   void *pNew;
   assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
   assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
   assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
   if( pOld==0 ){
     return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */
   }

@@ -20802,7 +21017,7 @@ SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){

     }
     if( pNew ){
       nNew = sqlite3MallocSize(pNew);
       sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
       sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
     }
     sqlite3_mutex_leave(mem0.mutex);
   }else{

@@ -20816,14 +21031,14 @@ SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){

 ** The public interface to sqlite3Realloc.  Make sure that the memory
 ** subsystem is initialized prior to invoking sqliteRealloc.
 */
 SQLITE_API void *sqlite3_realloc(void *pOld, int n){
 SQLITE_API void *SQLITE_STDCALL sqlite3_realloc(void *pOld, int n){
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif
   if( n<0 ) n = 0;  /* IMP: R-26507-47431 */
   return sqlite3Realloc(pOld, n);
 }
 SQLITE_API void *sqlite3_realloc64(void *pOld, sqlite3_uint64 n){
 SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64(void *pOld, sqlite3_uint64 n){
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize() ) return 0;
 #endif

@@ -20935,7 +21150,7 @@ SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){

       }
     }else{
       assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
       assert( sqlite3MemdebugNoType(p, ~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
       assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
       sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
       pNew = sqlite3_realloc64(p, n);
       if( !pNew ){

@@ -21262,13 +21477,6 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

   PrintfArguments *pArgList = 0; /* Arguments for SQLITE_PRINTF_SQLFUNC */
   char buf[etBUFSIZE];       /* Conversion buffer */
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( ap==0 ){
     (void)SQLITE_MISUSE_BKPT;
     sqlite3StrAccumReset(pAccum);
     return;
   }
 #endif
   bufpt = 0;
   if( bFlags ){
     if( (bArgList = (bFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){

@@ -21318,15 +21526,19 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

       }
       if( width<0 ){
         flag_leftjustify = 1;
         width = -width;
         width = width >= -2147483647 ? -width : 0;
       }
       c = *++fmt;
     }else{
       unsigned wx = 0;
       while( c>='0' && c<='9' ){
         width = width*10 + c - '0';
         wx = wx*10 + c - '0';
         c = *++fmt;
       }
       testcase( wx>0x7fffffff );
       width = wx & 0x7fffffff;
     }
     /* Get the precision */
     if( c=='.' ){
       precision = 0;

@@ -21337,13 +21549,18 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         }else{
           precision = va_arg(ap,int);
         }
         if( precision<0 ) precision = -precision;
         c = *++fmt;
         if( precision<0 ){
           precision = precision >= -2147483647 ? -precision : -1;
         }
       }else{
         unsigned px = 0;
         while( c>='0' && c<='9' ){
           precision = precision*10 + c - '0';
           px = px*10 + c - '0';
           c = *++fmt;
         }
         testcase( px>0x7fffffff );
         precision = px & 0x7fffffff;
       }
     }else{
       precision = -1;

@@ -21507,7 +21724,8 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

           else                         prefix = 0;
         }
         if( xtype==etGENERIC && precision>0 ) precision--;
         for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
         testcase( precision>0xfff );
         for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){}
         if( xtype==etFLOAT ) realvalue += rounder;
         /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
         exp = 0;

@@ -21562,8 +21780,9 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

         }else{
           e2 = exp;
         }
         if( MAX(e2,0)+precision+width > etBUFSIZE - 15 ){
           bufpt = zExtra = sqlite3Malloc( MAX(e2,0)+precision+width+15 );
         if( MAX(e2,0)+(i64)precision+(i64)width > etBUFSIZE - 15 ){
           bufpt = zExtra
               = sqlite3Malloc( MAX(e2,0)+(i64)precision+(i64)width+15 );
           if( bufpt==0 ){
             setStrAccumError(pAccum, STRACCUM_NOMEM);
             return;

@@ -21795,7 +22014,7 @@ SQLITE_PRIVATE void sqlite3VXPrintf(

 */
 static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
   char *zNew;
   assert( p->nChar+N >= p->nAlloc ); /* Only called if really needed */
   assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
   if( p->accError ){
     testcase(p->accError==STRACCUM_TOOBIG);
     testcase(p->accError==STRACCUM_NOMEM);

@@ -21844,7 +22063,10 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){

 ** Append N copies of character c to the given string buffer.
 */
 SQLITE_PRIVATE void sqlite3AppendChar(StrAccum *p, int N, char c){
   if( p->nChar+N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ) return;
   testcase( p->nChar + (i64)N > 0x7fffffff );
   if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
     return;
   }
   while( (N--)>0 ) p->zText[p->nChar++] = c;
 }

@@ -21996,7 +22218,7 @@ SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zForma

 ** Print into memory obtained from sqlite3_malloc().  Omit the internal
 ** %-conversion extensions.
 */
 SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){
 SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char *zFormat, va_list ap){
   char *z;
   char zBase[SQLITE_PRINT_BUF_SIZE];
   StrAccum acc;

@@ -22021,7 +22243,7 @@ SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){

 ** Print into memory obtained from sqlite3_malloc()().  Omit the internal
 ** %-conversion extensions.
 */
 SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){
 SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char *zFormat, ...){
   va_list ap;
   char *z;
 #ifndef SQLITE_OMIT_AUTOINIT

@@ -22046,13 +22268,13 @@ SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){

 **
 ** sqlite3_vsnprintf() is the varargs version.
 */
 SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
 SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
   StrAccum acc;
   if( n<=0 ) return zBuf;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( zBuf==0 || zFormat==0 ) {
     (void)SQLITE_MISUSE_BKPT;
     if( zBuf && n>0 ) zBuf[0] = 0;
     if( zBuf ) zBuf[0] = 0;
     return zBuf;
   }
 #endif

@@ -22061,7 +22283,7 @@ SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_li

   sqlite3VXPrintf(&acc, 0, zFormat, ap);
   return sqlite3StrAccumFinish(&acc);
 }
 SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
 SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
   char *z;
   va_list ap;
   va_start(ap,zFormat);

@@ -22093,7 +22315,7 @@ static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){

 /*
 ** Format and write a message to the log if logging is enabled.
 */
 SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){
 SQLITE_API void SQLITE_CDECL sqlite3_log(int iErrCode, const char *zFormat, ...){
   va_list ap;                             /* Vararg list */
   if( sqlite3GlobalConfig.xLog ){
     va_start(ap, zFormat);

@@ -22229,7 +22451,7 @@ static SQLITE_WSD struct sqlite3PrngType {

 /*
 ** Return N random bytes.
 */
 SQLITE_API void sqlite3_randomness(int N, void *pBuf){
 SQLITE_API void SQLITE_STDCALL sqlite3_randomness(int N, void *pBuf){
   unsigned char t;
   unsigned char *zBuf = pBuf;

@@ -22435,7 +22657,7 @@ SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){

 /********************************* Win32 Threads ****************************/
 #if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_THREADSAFE>0
 #if SQLITE_OS_WIN_THREADS
 #define SQLITE_THREADS_IMPLEMENTED 1  /* Prevent the single-thread code below */
 #include <process.h>

@@ -22528,7 +22750,7 @@ SQLITE_PRIVATE int sqlite3ThreadJoin(SQLiteThread *p, void **ppOut){

   return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR;
 }
 #endif /* SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT */
 #endif /* SQLITE_OS_WIN_THREADS */
 /******************************** End Win32 Threads *************************/

@@ -23381,7 +23603,7 @@ SQLITE_PRIVATE int sqlite3Dequote(char *z){

 ** case-independent fashion, using the same definition of "case
 ** independence" that SQLite uses internally when comparing identifiers.
 */
 SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){
 SQLITE_API int SQLITE_STDCALL sqlite3_stricmp(const char *zLeft, const char *zRight){
   register unsigned char *a, *b;
   if( zLeft==0 ){
     return zRight ? -1 : 0;

@@ -23393,7 +23615,7 @@ SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){

   while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
   return UpperToLower[*a] - UpperToLower[*b];
 }
 SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
 SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
   register unsigned char *a, *b;
   if( zLeft==0 ){
     return zRight ? -1 : 0;

@@ -24924,23 +25146,25 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){

      /* 136 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
      /* 137 */ "IfPos"            OpHelp("if r[P1]>0 goto P2"),
      /* 138 */ "IfNeg"            OpHelp("r[P1]+=P3, if r[P1]<0 goto P2"),
      /* 139 */ "IfZero"           OpHelp("r[P1]+=P3, if r[P1]==0 goto P2"),
      /* 140 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
      /* 141 */ "IncrVacuum"       OpHelp(""),
      /* 142 */ "Expire"           OpHelp(""),
      /* 143 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
      /* 144 */ "VBegin"           OpHelp(""),
      /* 145 */ "VCreate"          OpHelp(""),
      /* 146 */ "VDestroy"         OpHelp(""),
      /* 147 */ "VOpen"            OpHelp(""),
      /* 148 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
      /* 149 */ "VNext"            OpHelp(""),
      /* 150 */ "VRename"          OpHelp(""),
      /* 151 */ "Pagecount"        OpHelp(""),
      /* 152 */ "MaxPgcnt"         OpHelp(""),
      /* 153 */ "Init"             OpHelp("Start at P2"),
      /* 154 */ "Noop"             OpHelp(""),
      /* 155 */ "Explain"          OpHelp(""),
      /* 139 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]+=P3, goto P2"),
      /* 140 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
      /* 141 */ "JumpZeroIncr"     OpHelp("if (r[P1]++)==0 ) goto P2"),
      /* 142 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
      /* 143 */ "IncrVacuum"       OpHelp(""),
      /* 144 */ "Expire"           OpHelp(""),
      /* 145 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
      /* 146 */ "VBegin"           OpHelp(""),
      /* 147 */ "VCreate"          OpHelp(""),
      /* 148 */ "VDestroy"         OpHelp(""),
      /* 149 */ "VOpen"            OpHelp(""),
      /* 150 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
      /* 151 */ "VNext"            OpHelp(""),
      /* 152 */ "VRename"          OpHelp(""),
      /* 153 */ "Pagecount"        OpHelp(""),
      /* 154 */ "MaxPgcnt"         OpHelp(""),
      /* 155 */ "Init"             OpHelp("Start at P2"),
      /* 156 */ "Noop"             OpHelp(""),
      /* 157 */ "Explain"          OpHelp(""),
   };
   return azName[i];
 }

@@ -25021,18 +25245,6 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){

 #endif
 /*
 ** Define the OS_VXWORKS pre-processor macro to 1 if building on
 ** vxworks, or 0 otherwise.
 */
 #ifndef OS_VXWORKS
 #  if defined(__RTP__) || defined(_WRS_KERNEL)
 #    define OS_VXWORKS 1
 #  else
 #    define OS_VXWORKS 0
 #  endif
 #endif
 /*
 ** standard include files.
 */
 #include <sys/types.h>

@@ -25046,18 +25258,19 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){

 # include <sys/mman.h>
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS
 #if SQLITE_ENABLE_LOCKING_STYLE
 # include <sys/ioctl.h>
 # if OS_VXWORKS
 #  include <semaphore.h>
 #  include <limits.h>
 # else
 #  include <sys/file.h>
 #  include <sys/param.h>
 # endif
 # include <sys/file.h>
 # include <sys/param.h>
 #endif /* SQLITE_ENABLE_LOCKING_STYLE */
 #if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
 #if OS_VXWORKS
 /* # include <sys/ioctl.h> */
 # include <semaphore.h>
 # include <limits.h>
 #endif /* OS_VXWORKS */
 #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
 # include <sys/mount.h>
 #endif

@@ -25098,6 +25311,10 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){

 */
 #define MAX_PATHNAME 512
 /* Always cast the getpid() return type for compatibility with
 ** kernel modules in VxWorks. */
 #define osGetpid(X) (pid_t)getpid()
 /*
 ** Only set the lastErrno if the error code is a real error and not
 ** a normal expected return code of SQLITE_BUSY or SQLITE_OK

@@ -25186,7 +25403,7 @@ struct unixFile {

 ** method was called.  If xOpen() is called from a different process id,
 ** indicating that a fork() has occurred, the PRNG will be reset.
 */
 static int randomnessPid = 0;
 static pid_t randomnessPid = 0;
 /*
 ** Allowed values for the unixFile.ctrlFlags bitmask:

@@ -25203,7 +25420,8 @@ static int randomnessPid = 0;

 #define UNIXFILE_DELETE      0x20     /* Delete on close */
 #define UNIXFILE_URI         0x40     /* Filename might have query parameters */
 #define UNIXFILE_NOLOCK      0x80     /* Do no file locking */
 #define UNIXFILE_WARNED    0x0100     /* verifyDbFile() warnings have been issued */
 #define UNIXFILE_WARNED    0x0100     /* verifyDbFile() warnings issued */
 #define UNIXFILE_BLOCK     0x0200     /* Next SHM lock might block */
 /*
 ** Include code that is common to all os_*.c files

@@ -25542,7 +25760,7 @@ static struct unix_syscall {

   { "read",         (sqlite3_syscall_ptr)read,       0  },
 #define osRead      ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
 #if defined(USE_PREAD) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
 #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
   { "pread",        (sqlite3_syscall_ptr)pread,      0  },
 #else
   { "pread",        (sqlite3_syscall_ptr)0,          0  },

@@ -25559,7 +25777,7 @@ static struct unix_syscall {

   { "write",        (sqlite3_syscall_ptr)write,      0  },
 #define osWrite     ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
 #if defined(USE_PREAD) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
 #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
   { "pwrite",       (sqlite3_syscall_ptr)pwrite,     0  },
 #else
   { "pwrite",       (sqlite3_syscall_ptr)0,          0  },

@@ -25874,9 +26092,9 @@ static int lockTrace(int fd, int op, struct flock *p){

 /*
 ** Retry ftruncate() calls that fail due to EINTR
 **
 ** All calls to ftruncate() within this file should be made through this wrapper.
 ** On the Android platform, bypassing the logic below could lead to a corrupt
 ** database.
 ** All calls to ftruncate() within this file should be made through
 ** this wrapper.  On the Android platform, bypassing the logic below
 ** could lead to a corrupt database.
 */
 static int robust_ftruncate(int h, sqlite3_int64 sz){
   int rc;

@@ -26336,6 +26554,14 @@ static void robust_close(unixFile *pFile, int h, int lineno){

 }
 /*
 ** Set the pFile->lastErrno.  Do this in a subroutine as that provides
 ** a convenient place to set a breakpoint.
 */
 static void storeLastErrno(unixFile *pFile, int error){
   pFile->lastErrno = error;
 }
 /*
 ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
 */
 static void closePendingFds(unixFile *pFile){

@@ -26408,7 +26634,7 @@ static int findInodeInfo(

   fd = pFile->h;
   rc = osFstat(fd, &statbuf);
   if( rc!=0 ){
     pFile->lastErrno = errno;
     storeLastErrno(pFile, errno);
 #ifdef EOVERFLOW
     if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
 #endif

@@ -26429,12 +26655,12 @@ static int findInodeInfo(

   if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
     do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
     if( rc!=1 ){
       pFile->lastErrno = errno;
       storeLastErrno(pFile, errno);
       return SQLITE_IOERR;
     }
     rc = osFstat(fd, &statbuf);
     if( rc!=0 ){
       pFile->lastErrno = errno;
       storeLastErrno(pFile, errno);
       return SQLITE_IOERR;
     }
   }

@@ -26557,7 +26783,7 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){

     lock.l_type = F_WRLCK;
     if( osFcntl(pFile->h, F_GETLK, &lock) ){
       rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
       pFile->lastErrno = errno;
       storeLastErrno(pFile, errno);
     } else if( lock.l_type!=F_UNLCK ){
       reserved = 1;
     }

@@ -26690,7 +26916,8 @@ static int unixLock(sqlite3_file *id, int eFileLock){

   assert( pFile );
   OSTRACE(("LOCK    %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
       azFileLock(eFileLock), azFileLock(pFile->eFileLock),
       azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared , getpid()));
       azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
       osGetpid(0)));
   /* If there is already a lock of this type or more restrictive on the
   ** unixFile, do nothing. Don't use the end_lock: exit path, as

@@ -26757,7 +26984,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){

       tErrno = errno;
       rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
       if( rc!=SQLITE_BUSY ){
         pFile->lastErrno = tErrno;
         storeLastErrno(pFile, tErrno);
       }
       goto end_lock;
     }

@@ -26792,7 +27019,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){

     if( rc ){
       if( rc!=SQLITE_BUSY ){
         pFile->lastErrno = tErrno;
         storeLastErrno(pFile, tErrno);
       }
       goto end_lock;
     }else{

@@ -26825,7 +27052,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){

       tErrno = errno;
       rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
       if( rc!=SQLITE_BUSY ){
         pFile->lastErrno = tErrno;
         storeLastErrno(pFile, tErrno);
       }
     }
   }

@@ -26898,7 +27125,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

   assert( pFile );
   OSTRACE(("UNLOCK  %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
       pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
       getpid()));
       osGetpid(0)));
   assert( eFileLock<=SHARED_LOCK );
   if( pFile->eFileLock<=eFileLock ){

@@ -26932,7 +27159,6 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

     **  4:   [RRRR.]
     */
     if( eFileLock==SHARED_LOCK ){
 #if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE
       (void)handleNFSUnlock;
       assert( handleNFSUnlock==0 );

@@ -26950,7 +27176,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

           tErrno = errno;
           rc = SQLITE_IOERR_UNLOCK;
           if( IS_LOCK_ERROR(rc) ){
             pFile->lastErrno = tErrno;
             storeLastErrno(pFile, tErrno);
           }
           goto end_unlock;
         }

@@ -26962,7 +27188,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

           tErrno = errno;
           rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
           if( IS_LOCK_ERROR(rc) ){
             pFile->lastErrno = tErrno;
             storeLastErrno(pFile, tErrno);
           }
           goto end_unlock;
         }

@@ -26974,7 +27200,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

           tErrno = errno;
           rc = SQLITE_IOERR_UNLOCK;
           if( IS_LOCK_ERROR(rc) ){
             pFile->lastErrno = tErrno;
             storeLastErrno(pFile, tErrno);
           }
           goto end_unlock;
         }

@@ -26993,7 +27219,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

           ** SQLITE_BUSY would confuse the upper layer (in practice it causes
           ** an assert to fail). */
           rc = SQLITE_IOERR_RDLOCK;
           pFile->lastErrno = errno;
           storeLastErrno(pFile, errno);
           goto end_unlock;
         }
       }

@@ -27006,7 +27232,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

       pInode->eFileLock = SHARED_LOCK;
     }else{
       rc = SQLITE_IOERR_UNLOCK;
       pFile->lastErrno = errno;
       storeLastErrno(pFile, errno);
       goto end_unlock;
     }
   }

@@ -27024,7 +27250,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){

         pInode->eFileLock = NO_LOCK;
       }else{
         rc = SQLITE_IOERR_UNLOCK;
         pFile->lastErrno = errno;
         storeLastErrno(pFile, errno);
         pInode->eFileLock = NO_LOCK;
         pFile->eFileLock = NO_LOCK;
       }

@@ -27299,7 +27525,7 @@ static int dotlockLock(sqlite3_file *id, int eFileLock) {

     } else {
       rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
       if( IS_LOCK_ERROR(rc) ){
         pFile->lastErrno = tErrno;
         storeLastErrno(pFile, tErrno);
       }
     }
     return rc;

@@ -27326,7 +27552,7 @@ static int dotlockUnlock(sqlite3_file *id, int eFileLock) {

   assert( pFile );
   OSTRACE(("UNLOCK  %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
            pFile->eFileLock, getpid()));
            pFile->eFileLock, osGetpid(0)));
   assert( eFileLock<=SHARED_LOCK );
   /* no-op if possible */

@@ -27353,7 +27579,7 @@ static int dotlockUnlock(sqlite3_file *id, int eFileLock) {

       rc = SQLITE_IOERR_UNLOCK;
     }
     if( IS_LOCK_ERROR(rc) ){
       pFile->lastErrno = tErrno;
       storeLastErrno(pFile, tErrno);
     }
     return rc;
   }

@@ -27389,10 +27615,9 @@ static int dotlockClose(sqlite3_file *id) {

 ** still works when you do this, but concurrency is reduced since
 ** only a single process can be reading the database at a time.
 **
 ** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off or if
 ** compiling for VXWORKS.
 ** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off
 */
 #if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
 #if SQLITE_ENABLE_LOCKING_STYLE
 /*
 ** Retry flock() calls that fail with EINTR

@@ -27440,7 +27665,7 @@ static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){

         /* unlock failed with an error */
         lrc = SQLITE_IOERR_UNLOCK;
         if( IS_LOCK_ERROR(lrc) ){
           pFile->lastErrno = tErrno;
           storeLastErrno(pFile, tErrno);
           rc = lrc;
         }
       }

@@ -27450,7 +27675,7 @@ static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){

       /* someone else might have it reserved */
       lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
       if( IS_LOCK_ERROR(lrc) ){
         pFile->lastErrno = tErrno;
         storeLastErrno(pFile, tErrno);
         rc = lrc;
       }
     }

@@ -27516,7 +27741,7 @@ static int flockLock(sqlite3_file *id, int eFileLock) {

     /* didn't get, must be busy */
     rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
     if( IS_LOCK_ERROR(rc) ){
       pFile->lastErrno = tErrno;
       storeLastErrno(pFile, tErrno);
     }
   } else {
     /* got it, set the type and return ok */

@@ -27545,7 +27770,7 @@ static int flockUnlock(sqlite3_file *id, int eFileLock) {

   assert( pFile );
   OSTRACE(("UNLOCK  %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
            pFile->eFileLock, getpid()));
            pFile->eFileLock, osGetpid(0)));
   assert( eFileLock<=SHARED_LOCK );
   /* no-op if possible */

@@ -27606,7 +27831,7 @@ static int flockClose(sqlite3_file *id) {

 ** to a non-zero value otherwise *pResOut is set to zero.  The return value
 ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
 */
 static int semCheckReservedLock(sqlite3_file *id, int *pResOut) {
 static int semXCheckReservedLock(sqlite3_file *id, int *pResOut) {
   int rc = SQLITE_OK;
   int reserved = 0;
   unixFile *pFile = (unixFile*)id;

@@ -27628,7 +27853,7 @@ static int semCheckReservedLock(sqlite3_file *id, int *pResOut) {

       int tErrno = errno;
       if( EAGAIN != tErrno ){
         rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
         pFile->lastErrno = tErrno;
         storeLastErrno(pFile, tErrno);
       } else {
         /* someone else has the lock when we are in NO_LOCK */
         reserved = (pFile->eFileLock < SHARED_LOCK);

@@ -27673,7 +27898,7 @@ static int semCheckReservedLock(sqlite3_file *id, int *pResOut) {

 ** This routine will only increase a lock.  Use the sqlite3OsUnlock()
 ** routine to lower a locking level.
 */
 static int semLock(sqlite3_file *id, int eFileLock) {
 static int semXLock(sqlite3_file *id, int eFileLock) {
   unixFile *pFile = (unixFile*)id;
   sem_t *pSem = pFile->pInode->pSem;
   int rc = SQLITE_OK;

@@ -27706,14 +27931,14 @@ static int semLock(sqlite3_file *id, int eFileLock) {

 ** If the locking level of the file descriptor is already at or below
 ** the requested locking level, this routine is a no-op.
 */
 static int semUnlock(sqlite3_file *id, int eFileLock) {
 static int semXUnlock(sqlite3_file *id, int eFileLock) {
   unixFile *pFile = (unixFile*)id;
   sem_t *pSem = pFile->pInode->pSem;
   assert( pFile );
   assert( pSem );
   OSTRACE(("UNLOCK  %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
            pFile->eFileLock, getpid()));
            pFile->eFileLock, osGetpid(0)));
   assert( eFileLock<=SHARED_LOCK );
   /* no-op if possible */

@@ -27732,7 +27957,7 @@ static int semUnlock(sqlite3_file *id, int eFileLock) {

     int rc, tErrno = errno;
     rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
     if( IS_LOCK_ERROR(rc) ){
       pFile->lastErrno = tErrno;
       storeLastErrno(pFile, tErrno);
     }
     return rc;
   }

@@ -27743,10 +27968,10 @@ static int semUnlock(sqlite3_file *id, int eFileLock) {

 /*
  ** Close a file.
  */
 static int semClose(sqlite3_file *id) {
 static int semXClose(sqlite3_file *id) {
   if( id ){
     unixFile *pFile = (unixFile*)id;
     semUnlock(id, NO_LOCK);
     semXUnlock(id, NO_LOCK);
     assert( pFile );
     unixEnterMutex();
     releaseInodeInfo(pFile);

@@ -27834,7 +28059,7 @@ static int afpSetLock(

                     setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK);
 #endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */
     if( IS_LOCK_ERROR(rc) ){
       pFile->lastErrno = tErrno;
       storeLastErrno(pFile, tErrno);
     }
     return rc;
   } else {

@@ -27927,7 +28152,7 @@ static int afpLock(sqlite3_file *id, int eFileLock){

   assert( pFile );
   OSTRACE(("LOCK    %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
            azFileLock(eFileLock), azFileLock(pFile->eFileLock),
            azFileLock(pInode->eFileLock), pInode->nShared , getpid()));
            azFileLock(pInode->eFileLock), pInode->nShared , osGetpid(0)));
   /* If there is already a lock of this type or more restrictive on the
   ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as

@@ -28017,7 +28242,7 @@ static int afpLock(sqlite3_file *id, int eFileLock){

     lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
     if( IS_LOCK_ERROR(lrc1) ) {
       pFile->lastErrno = lrc1Errno;
       storeLastErrno(pFile, lrc1Errno);
       rc = lrc1;
       goto afp_end_lock;
     } else if( IS_LOCK_ERROR(lrc2) ){

@@ -28113,7 +28338,7 @@ static int afpUnlock(sqlite3_file *id, int eFileLock) {

   assert( pFile );
   OSTRACE(("UNLOCK  %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
            pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
            getpid()));
            osGetpid(0)));
   assert( eFileLock<=SHARED_LOCK );
   if( pFile->eFileLock<=eFileLock ){

@@ -28304,9 +28529,9 @@ static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){

     SimulateIOError( newOffset-- );
     if( newOffset!=offset ){
       if( newOffset == -1 ){
         ((unixFile*)id)->lastErrno = errno;
         storeLastErrno((unixFile*)id, errno);
       }else{
         ((unixFile*)id)->lastErrno = 0;
         storeLastErrno((unixFile*)id, 0);
       }
       return -1;
     }

@@ -28316,7 +28541,7 @@ static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){

     if( got<0 ){
       if( errno==EINTR ){ got = 1; continue; }
       prior = 0;
       ((unixFile*)id)->lastErrno = errno;
       storeLastErrno((unixFile*)id,  errno);
       break;
     }else if( got>0 ){
       cnt -= got;

@@ -28381,7 +28606,7 @@ static int unixRead(

     /* lastErrno set by seekAndRead */
     return SQLITE_IOERR_READ;
   }else{
     pFile->lastErrno = 0; /* not a system error */
     storeLastErrno(pFile, 0);   /* not a system error */
     /* Unread parts of the buffer must be zero-filled */
     memset(&((char*)pBuf)[got], 0, amt-got);
     return SQLITE_IOERR_SHORT_READ;

@@ -28410,9 +28635,9 @@ static int seekAndWriteFd(

   TIMER_START;
 #if defined(USE_PREAD)
   do{ rc = osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR );
   do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR );
 #elif defined(USE_PREAD64)
   do{ rc = osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR);
   do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR);
 #else
   do{
     i64 iSeek = lseek(fd, iOff, SEEK_SET);

@@ -28522,7 +28747,7 @@ static int unixWrite(

       /* lastErrno set by seekAndWrite */
       return SQLITE_IOERR_WRITE;
     }else{
       pFile->lastErrno = 0; /* not a system error */
       storeLastErrno(pFile, 0); /* not a system error */
       return SQLITE_FULL;
     }
   }

@@ -28731,7 +28956,7 @@ static int unixSync(sqlite3_file *id, int flags){

   rc = full_fsync(pFile->h, isFullsync, isDataOnly);
   SimulateIOError( rc=1 );
   if( rc ){
     pFile->lastErrno = errno;
     storeLastErrno(pFile, errno);
     return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
   }

@@ -28775,7 +29000,7 @@ static int unixTruncate(sqlite3_file *id, i64 nByte){

   rc = robust_ftruncate(pFile->h, nByte);
   if( rc ){
     pFile->lastErrno = errno;
     storeLastErrno(pFile, errno);
     return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
   }else{
 #ifdef SQLITE_DEBUG

@@ -28815,7 +29040,7 @@ static int unixFileSize(sqlite3_file *id, i64 *pSize){

   rc = osFstat(((unixFile*)id)->h, &buf);
   SimulateIOError( rc=1 );
   if( rc!=0 ){
     ((unixFile*)id)->lastErrno = errno;
     storeLastErrno((unixFile*)id, errno);
     return SQLITE_IOERR_FSTAT;
   }
   *pSize = buf.st_size;

@@ -28851,7 +29076,9 @@ static int fcntlSizeHint(unixFile *pFile, i64 nByte){

     i64 nSize;                    /* Required file size */
     struct stat buf;              /* Used to hold return values of fstat() */
     if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT;
     if( osFstat(pFile->h, &buf) ){
       return SQLITE_IOERR_FSTAT;
     }
     nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
     if( nSize>(i64)buf.st_size ){

@@ -28898,7 +29125,7 @@ static int fcntlSizeHint(unixFile *pFile, i64 nByte){

     int rc;
     if( pFile->szChunk<=0 ){
       if( robust_ftruncate(pFile->h, nByte) ){
         pFile->lastErrno = errno;
         storeLastErrno(pFile, errno);
         return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
       }
     }

@@ -28936,11 +29163,15 @@ static int unixGetTempname(int nBuf, char *zBuf);

 static int unixFileControl(sqlite3_file *id, int op, void *pArg){
   unixFile *pFile = (unixFile*)id;
   switch( op ){
     case SQLITE_FCNTL_WAL_BLOCK: {
       /* pFile->ctrlFlags |= UNIXFILE_BLOCK; // Deferred feature */
       return SQLITE_OK;
     }
     case SQLITE_FCNTL_LOCKSTATE: {
       *(int*)pArg = pFile->eFileLock;
       return SQLITE_OK;
     }
     case SQLITE_LAST_ERRNO: {
     case SQLITE_FCNTL_LAST_ERRNO: {
       *(int*)pArg = pFile->lastErrno;
       return SQLITE_OK;
     }

@@ -29009,8 +29240,8 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){

     }
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
     case SQLITE_SET_LOCKPROXYFILE:
     case SQLITE_GET_LOCKPROXYFILE: {
     case SQLITE_FCNTL_SET_LOCKPROXYFILE:
     case SQLITE_FCNTL_GET_LOCKPROXYFILE: {
       return proxyFileControl(id,op,pArg);
     }
 #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */

@@ -29150,7 +29381,9 @@ static int unixDeviceCharacteristics(sqlite3_file *id){

 ** Instead, it should be called via macro osGetpagesize().
 */
 static int unixGetpagesize(void){
 #if defined(_BSD_SOURCE)
 #if OS_VXWORKS
   return 1024;
 #elif defined(_BSD_SOURCE)
   return getpagesize();
 #else
   return (int)sysconf(_SC_PAGESIZE);

@@ -29243,15 +29476,17 @@ struct unixShm {

 ** otherwise.
 */
 static int unixShmSystemLock(
   unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
   unixFile *pFile,       /* Open connection to the WAL file */
   int lockType,          /* F_UNLCK, F_RDLCK, or F_WRLCK */
   int ofst,              /* First byte of the locking range */
   int n                  /* Number of bytes to lock */
 ){
   struct flock f;       /* The posix advisory locking structure */
   int rc = SQLITE_OK;   /* Result code form fcntl() */
   unixShmNode *pShmNode; /* Apply locks to this open shared-memory segment */
   struct flock f;        /* The posix advisory locking structure */
   int rc = SQLITE_OK;    /* Result code form fcntl() */
   /* Access to the unixShmNode object is serialized by the caller */
   pShmNode = pFile->pInode->pShmNode;
   assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
   /* Shared locks never span more than one byte */

@@ -29261,6 +29496,7 @@ static int unixShmSystemLock(

   assert( n>=1 && n<SQLITE_SHM_NLOCK );
   if( pShmNode->h>=0 ){
     int lkType;
     /* Initialize the locking parameters */
     memset(&f, 0, sizeof(f));
     f.l_type = lockType;

@@ -29268,8 +29504,10 @@ static int unixShmSystemLock(

     f.l_start = ofst;
     f.l_len = n;
     rc = osFcntl(pShmNode->h, F_SETLK, &f);
     lkType = (pFile->ctrlFlags & UNIXFILE_BLOCK)!=0 ? F_SETLKW : F_SETLK;
     rc = osFcntl(pShmNode->h, lkType, &f);
     rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
     pFile->ctrlFlags &= ~UNIXFILE_BLOCK;
   }
   /* Update the global lock state and do debug tracing */

@@ -29415,6 +29653,9 @@ static int unixOpenSharedMemory(unixFile *pDbFd){

   pShmNode = pInode->pShmNode;
   if( pShmNode==0 ){
     struct stat sStat;                 /* fstat() info for database file */
 #ifndef SQLITE_SHM_DIRECTORY
     const char *zBasePath = pDbFd->zPath;
 #endif
     /* Call fstat() to figure out the permissions on the database file. If
     ** a new *-shm file is created, an attempt will be made to create it

@@ -29428,7 +29669,7 @@ static int unixOpenSharedMemory(unixFile *pDbFd){

 #ifdef SQLITE_SHM_DIRECTORY
     nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31;
 #else
     nShmFilename = 6 + (int)strlen(pDbFd->zPath);
     nShmFilename = 6 + (int)strlen(zBasePath);
 #endif
     pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
     if( pShmNode==0 ){

@@ -29442,7 +29683,7 @@ static int unixOpenSharedMemory(unixFile *pDbFd){

                      SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
                      (u32)sStat.st_ino, (u32)sStat.st_dev);
 #else
     sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
     sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", zBasePath);
     sqlite3FileSuffix3(pDbFd->zPath, zShmFilename);
 #endif
     pShmNode->h = -1;

@@ -29476,13 +29717,13 @@ static int unixOpenSharedMemory(unixFile *pDbFd){

       ** If not, truncate the file to zero length.
       */
       rc = SQLITE_OK;
       if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
       if( unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
         if( robust_ftruncate(pShmNode->h, 0) ){
           rc = unixLogError(SQLITE_IOERR_SHMOPEN, "ftruncate", zShmFilename);
         }
       }
       if( rc==SQLITE_OK ){
         rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1);
         rc = unixShmSystemLock(pDbFd, F_RDLCK, UNIX_SHM_DMS, 1);
       }
       if( rc ) goto shm_open_err;
     }

@@ -29714,7 +29955,7 @@ static int unixShmLock(

     /* Unlock the system-level locks */
     if( (mask & allMask)==0 ){
       rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n);
       rc = unixShmSystemLock(pDbFd, F_UNLCK, ofst+UNIX_SHM_BASE, n);
     }else{
       rc = SQLITE_OK;
     }

@@ -29742,7 +29983,7 @@ static int unixShmLock(

     /* Get shared locks at the system level, if necessary */
     if( rc==SQLITE_OK ){
       if( (allShared & mask)==0 ){
         rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n);
         rc = unixShmSystemLock(pDbFd, F_RDLCK, ofst+UNIX_SHM_BASE, n);
       }else{
         rc = SQLITE_OK;
       }

@@ -29767,7 +30008,7 @@ static int unixShmLock(

     ** also mark the local connection as being locked.
     */
     if( rc==SQLITE_OK ){
       rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n);
       rc = unixShmSystemLock(pDbFd, F_WRLCK, ofst+UNIX_SHM_BASE, n);
       if( rc==SQLITE_OK ){
         assert( (p->sharedMask & mask)==0 );
         p->exclMask |= mask;

@@ -29776,7 +30017,7 @@ static int unixShmLock(

   }
   sqlite3_mutex_leave(pShmNode->mutex);
   OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
            p->id, getpid(), p->sharedMask, p->exclMask));
            p->id, osGetpid(0), p->sharedMask, p->exclMask));
   return rc;
 }

@@ -29835,7 +30076,9 @@ static int unixShmUnmap(

   assert( pShmNode->nRef>0 );
   pShmNode->nRef--;
   if( pShmNode->nRef==0 ){
     if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
     if( deleteFlag && pShmNode->h>=0 ){
       osUnlink(pShmNode->zFilename);
     }
     unixShmPurge(pDbFd);
   }
   unixLeaveMutex();

@@ -30112,7 +30355,7 @@ static int unixUnfetch(sqlite3_file *fd, i64 iOff, void *p){

 **   *  An I/O method finder function called FINDER that returns a pointer
 **      to the METHOD object in the previous bullet.
 */
 #define IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK, SHMMAP) \
 #define IOMETHODS(FINDER,METHOD,VERSION,CLOSE,LOCK,UNLOCK,CKLOCK,SHMMAP)     \
 static const sqlite3_io_methods METHOD = {                                   \
    VERSION,                    /* iVersion */                                \
    CLOSE,                      /* xClose */                                  \

@@ -30177,7 +30420,7 @@ IOMETHODS(

 /* xShmMap method */
 )
 #if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
 #if SQLITE_ENABLE_LOCKING_STYLE
 IOMETHODS(
   flockIoFinder,            /* Finder function name */
   flockIoMethods,           /* sqlite3_io_methods object name */

@@ -30195,10 +30438,10 @@ IOMETHODS(

   semIoFinder,              /* Finder function name */
   semIoMethods,             /* sqlite3_io_methods object name */
 ,                        /* shared memory is disabled */
   semClose,                 /* xClose method */
   semLock,                  /* xLock method */
   semUnlock,                /* xUnlock method */
   semCheckReservedLock,     /* xCheckReservedLock method */
   semXClose,                /* xClose method */
   semXLock,                 /* xLock method */
   semXUnlock,               /* xUnlock method */
   semXCheckReservedLock,    /* xCheckReservedLock method */
 /* xShmMap method */
 )
 #endif

@@ -30322,15 +30565,13 @@ static const sqlite3_io_methods

 #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
 #if OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE
 /*
 ** This "finder" function attempts to determine the best locking strategy
 ** for the database file "filePath".  It then returns the sqlite3_io_methods
 ** object that implements that strategy.
 **
 ** This is for VXWorks only.
 #if OS_VXWORKS
 /*
 ** This "finder" function for VxWorks checks to see if posix advisory
 ** locking works.  If it does, then that is what is used.  If it does not
 ** work, then fallback to named semaphore locking.
 */
 static const sqlite3_io_methods *autolockIoFinderImpl(
 static const sqlite3_io_methods *vxworksIoFinderImpl(
   const char *filePath,    /* name of the database file */
   unixFile *pNew           /* the open file object */
 ){

@@ -30356,9 +30597,9 @@ static const sqlite3_io_methods *autolockIoFinderImpl(

   }
 }
 static const sqlite3_io_methods
   *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
   *(*const vxworksIoFinder)(const char*,unixFile*) = vxworksIoFinderImpl;
 #endif /* OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE */
 #endif /* OS_VXWORKS */
 /*
 ** An abstract type for a pointer to an IO method finder function:

@@ -30540,7 +30781,7 @@ static int fillInUnixFile(

   }
 #endif
   pNew->lastErrno = 0;
   storeLastErrno(pNew, 0);
 #if OS_VXWORKS
   if( rc!=SQLITE_OK ){
     if( h>=0 ) robust_close(pNew, h, __LINE__);

@@ -30871,8 +31112,8 @@ static int unixOpen(

   ** the same instant might all reset the PRNG.  But multiple resets
   ** are harmless.
   */
   if( randomnessPid!=getpid() ){
     randomnessPid = getpid();
   if( randomnessPid!=osGetpid(0) ){
     randomnessPid = osGetpid(0);
     sqlite3_randomness(0,0);
   }

@@ -30988,13 +31229,16 @@ static int unixOpen(

 #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
   if( fstatfs(fd, &fsInfo) == -1 ){
     ((unixFile*)pFile)->lastErrno = errno;
     storeLastErrno(p, errno);
     robust_close(p, fd, __LINE__);
     return SQLITE_IOERR_ACCESS;
   }
   if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
     ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
   }
   if (0 == strncmp("exfat", fsInfo.f_fstypename, 5)) {
     ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
   }
 #endif
   /* Set up appropriate ctrlFlags */

@@ -31017,19 +31261,6 @@ static int unixOpen(

     if( envforce!=NULL ){
       useProxy = atoi(envforce)>0;
     }else{
       if( statfs(zPath, &fsInfo) == -1 ){
         /* In theory, the close(fd) call is sub-optimal. If the file opened
         ** with fd is a database file, and there are other connections open
         ** on that file that are currently holding advisory locks on it,
         ** then the call to close() will cancel those locks. In practice,
         ** we're assuming that statfs() doesn't fail very often. At least
         ** not while other file descriptors opened by the same process on
         ** the same file are working.  */
         p->lastErrno = errno;
         robust_close(p, fd, __LINE__);
         rc = SQLITE_IOERR_ACCESS;
         goto open_finished;
       }
       useProxy = !(fsInfo.f_flags&MNT_LOCAL);
     }
     if( useProxy ){

@@ -31273,7 +31504,7 @@ static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){

   ** tests repeatable.
   */
   memset(zBuf, 0, nBuf);
   randomnessPid = getpid();
   randomnessPid = osGetpid(0);
 #if !defined(SQLITE_TEST)
   {
     int fd, got;

@@ -31455,9 +31686,10 @@ static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){

 **
 ** C APIs
 **
 **  sqlite3_file_control(db, dbname, SQLITE_SET_LOCKPROXYFILE,
 **  sqlite3_file_control(db, dbname, SQLITE_FCNTL_SET_LOCKPROXYFILE,
 **                       <proxy_path> | ":auto:");
 **  sqlite3_file_control(db, dbname, SQLITE_GET_LOCKPROXYFILE, &<proxy_path>);
 **  sqlite3_file_control(db, dbname, SQLITE_FCNTL_GET_LOCKPROXYFILE,
 **                       &<proxy_path>);
 **
 **
 ** SQL pragmas

@@ -31550,7 +31782,7 @@ static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){

 ** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will
 ** force proxy locking to be used for every database file opened, and 0
 ** will force automatic proxy locking to be disabled for all database
 ** files (explicitly calling the SQLITE_SET_LOCKPROXYFILE pragma or
 ** files (explicitly calling the SQLITE_FCNTL_SET_LOCKPROXYFILE pragma or
 ** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
 */

@@ -31571,6 +31803,7 @@ struct proxyLockingContext {

   char *lockProxyPath;         /* Name of the proxy lock file */
   char *dbPath;                /* Name of the open file */
   int conchHeld;               /* 1 if the conch is held, -1 if lockless */
   int nFails;                  /* Number of conch taking failures */
   void *oldLockingContext;     /* Original lockingcontext to restore on close */
   sqlite3_io_methods const *pOldMethod;     /* Original I/O methods for close */
 };

@@ -31592,7 +31825,7 @@ static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){

   {
     if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){
       OSTRACE(("GETLOCKPATH  failed %s errno=%d pid=%d\n",
                lPath, errno, getpid()));
                lPath, errno, osGetpid(0)));
       return SQLITE_IOERR_LOCK;
     }
     len = strlcat(lPath, "sqliteplocks", maxLen);

@@ -31614,7 +31847,7 @@ static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){

   }
   lPath[i+len]='\0';
   strlcat(lPath, ":auto:", maxLen);
   OSTRACE(("GETLOCKPATH  proxy lock path=%s pid=%d\n", lPath, getpid()));
   OSTRACE(("GETLOCKPATH  proxy lock path=%s pid=%d\n", lPath, osGetpid(0)));
   return SQLITE_OK;
 }

@@ -31641,7 +31874,7 @@ static int proxyCreateLockPath(const char *lockPath){

           if( err!=EEXIST ) {
             OSTRACE(("CREATELOCKPATH  FAILED creating %s, "
                      "'%s' proxy lock path=%s pid=%d\n",
                      buf, strerror(err), lockPath, getpid()));
                      buf, strerror(err), lockPath, osGetpid(0)));
             return err;
           }
         }

@@ -31650,7 +31883,7 @@ static int proxyCreateLockPath(const char *lockPath){

     }
     buf[i] = lockPath[i];
   }
   OSTRACE(("CREATELOCKPATH  proxy lock path=%s pid=%d\n", lockPath, getpid()));
   OSTRACE(("CREATELOCKPATH  proxy lock path=%s pid=%d\n", lockPath, osGetpid(0)));
   return 0;
 }

@@ -31759,10 +31992,10 @@ extern int gethostuuid(uuid_t id, const struct timespec *wait);

 static int proxyGetHostID(unsigned char *pHostID, int *pError){
   assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
   memset(pHostID, 0, PROXY_HOSTIDLEN);
 #if defined(__MAX_OS_X_VERSION_MIN_REQUIRED)\
                && __MAC_OS_X_VERSION_MIN_REQUIRED<1050
 # if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \
                             (__IPHONE_OS_VERSION_MIN_REQUIRED > 2000))
   {
     static const struct timespec timeout = {1, 0}; /* 1 sec timeout */
     struct timespec timeout = {1, 0}; /* 1 sec timeout */
     if( gethostuuid(pHostID, &timeout) ){
       int err = errno;
       if( pError ){

@@ -31877,7 +32110,7 @@ static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){

        */
       struct stat buf;
       if( osFstat(conchFile->h, &buf) ){
         pFile->lastErrno = errno;
         storeLastErrno(pFile, errno);
         return SQLITE_IOERR_LOCK;
       }

@@ -31897,7 +32130,7 @@ static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){

         char tBuf[PROXY_MAXCONCHLEN];
         int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
         if( len<0 ){
           pFile->lastErrno = errno;
           storeLastErrno(pFile, errno);
           return SQLITE_IOERR_LOCK;
         }
         if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){

@@ -31917,7 +32150,7 @@ static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){

       if( 0==proxyBreakConchLock(pFile, myHostID) ){
         rc = SQLITE_OK;
         if( lockType==EXCLUSIVE_LOCK ){
           rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK);
           rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK);
         }
         if( !rc ){
           rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);

@@ -31955,11 +32188,12 @@ static int proxyTakeConch(unixFile *pFile){

     int forceNewLockPath = 0;
     OSTRACE(("TAKECONCH  %d for %s pid=%d\n", conchFile->h,
              (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), getpid()));
              (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
              osGetpid(0)));
     rc = proxyGetHostID(myHostID, &pError);
     if( (rc&0xff)==SQLITE_IOERR ){
       pFile->lastErrno = pError;
       storeLastErrno(pFile, pError);
       goto end_takeconch;
     }
     rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);

@@ -31970,7 +32204,7 @@ static int proxyTakeConch(unixFile *pFile){

     readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN);
     if( readLen<0 ){
       /* I/O error: lastErrno set by seekAndRead */
       pFile->lastErrno = conchFile->lastErrno;
       storeLastErrno(pFile, conchFile->lastErrno);
       rc = SQLITE_IOERR_READ;
       goto end_takeconch;
     }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) ||

@@ -32043,7 +32277,7 @@ static int proxyTakeConch(unixFile *pFile){

           rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
         }
       }else{
         rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, EXCLUSIVE_LOCK);
         rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
       }
       if( rc==SQLITE_OK ){
         char writeBuffer[PROXY_MAXCONCHLEN];

@@ -32052,7 +32286,8 @@ static int proxyTakeConch(unixFile *pFile){

         writeBuffer[0] = (char)PROXY_CONCHVERSION;
         memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
         if( pCtx->lockProxyPath!=NULL ){
           strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, MAXPATHLEN);
           strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath,
                   MAXPATHLEN);
         }else{
           strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN);
         }

@@ -32164,7 +32399,7 @@ static int proxyReleaseConch(unixFile *pFile){

   conchFile = pCtx->conchFile;
   OSTRACE(("RELEASECONCH  %d for %s pid=%d\n", conchFile->h,
            (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
            getpid()));
            osGetpid(0)));
   if( pCtx->conchHeld>0 ){
     rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
   }

@@ -32264,7 +32499,8 @@ static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){

     /* afp style keeps a reference to the db path in the filePath field
     ** of the struct */
     assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
     strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, MAXPATHLEN);
     strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath,
             MAXPATHLEN);
   } else
 #endif
   if( pFile->pMethod == &dotlockIoMethods ){

@@ -32305,7 +32541,7 @@ static int proxyTransformUnixFile(unixFile *pFile, const char *path) {

   }
   OSTRACE(("TRANSPROXY  %d for %s pid=%d\n", pFile->h,
            (lockPath ? lockPath : ":auto:"), getpid()));
            (lockPath ? lockPath : ":auto:"), osGetpid(0)));
   pCtx = sqlite3_malloc( sizeof(*pCtx) );
   if( pCtx==0 ){

@@ -32377,7 +32613,7 @@ static int proxyTransformUnixFile(unixFile *pFile, const char *path) {

 */
 static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
   switch( op ){
     case SQLITE_GET_LOCKPROXYFILE: {
     case SQLITE_FCNTL_GET_LOCKPROXYFILE: {
       unixFile *pFile = (unixFile*)id;
       if( pFile->pMethod == &proxyIoMethods ){
         proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;

@@ -32392,13 +32628,16 @@ static int proxyFileControl(sqlite3_file *id, int op, void *pArg){

       }
       return SQLITE_OK;
     }
     case SQLITE_SET_LOCKPROXYFILE: {
     case SQLITE_FCNTL_SET_LOCKPROXYFILE: {
       unixFile *pFile = (unixFile*)id;
       int rc = SQLITE_OK;
       int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
       if( pArg==NULL || (const char *)pArg==0 ){
         if( isProxyStyle ){
           /* turn off proxy locking - not supported */
           /* turn off proxy locking - not supported.  If support is added for
           ** switching proxy locking mode off then it will need to fail if
           ** the journal mode is WAL mode.
           */
           rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/;
         }else{
           /* turn off proxy locking - already off - NOOP */

@@ -32589,7 +32828,7 @@ static int proxyClose(sqlite3_file *id) {

 ** necessarily been initialized when this routine is called, and so they
 ** should not be used.
 */
 SQLITE_API int sqlite3_os_init(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void){
   /*
   ** The following macro defines an initializer for an sqlite3_vfs object.
   ** The name of the VFS is NAME.  The pAppData is a pointer to a pointer

@@ -32643,8 +32882,10 @@ SQLITE_API int sqlite3_os_init(void){

   ** array cannot be const.
   */
   static sqlite3_vfs aVfs[] = {
 #if SQLITE_ENABLE_LOCKING_STYLE && (OS_VXWORKS || defined(__APPLE__))
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
     UNIXVFS("unix",          autolockIoFinder ),
 #elif OS_VXWORKS
     UNIXVFS("unix",          vxworksIoFinder ),
 #else
     UNIXVFS("unix",          posixIoFinder ),
 #endif

@@ -32654,11 +32895,11 @@ SQLITE_API int sqlite3_os_init(void){

 #if OS_VXWORKS
     UNIXVFS("unix-namedsem", semIoFinder ),
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE
 #if SQLITE_ENABLE_LOCKING_STYLE || OS_VXWORKS
     UNIXVFS("unix-posix",    posixIoFinder ),
 #if !OS_VXWORKS
     UNIXVFS("unix-flock",    flockIoFinder ),
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE
     UNIXVFS("unix-flock",    flockIoFinder ),
 #endif
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
     UNIXVFS("unix-afp",      afpIoFinder ),

@@ -32686,7 +32927,7 @@ SQLITE_API int sqlite3_os_init(void){

 ** to release dynamically allocated objects.  But not on unix.
 ** This routine is a no-op for unix.
 */
 SQLITE_API int sqlite3_os_end(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void){
   return SQLITE_OK;
 }

@@ -33099,8 +33340,10 @@ WINBASEAPI LPVOID WINAPI MapViewOfFile(HANDLE, DWORD, DWORD, DWORD, SIZE_T);

 #endif /* SQLITE_OS_WINRT */
 /*
 ** This file mapping API is common to both Win32 and WinRT.
 ** These file mapping APIs are common to both Win32 and WinRT.
 */
 WINBASEAPI BOOL WINAPI FlushViewOfFile(LPCVOID, SIZE_T);
 WINBASEAPI BOOL WINAPI UnmapViewOfFile(LPCVOID);
 #endif /* SQLITE_WIN32_FILEMAPPING_API */

@@ -33968,6 +34211,32 @@ static struct win_syscall {

         SQLITE_WIN32_VOLATILE*, LONG,LONG))aSyscall[76].pCurrent)
 #endif /* defined(InterlockedCompareExchange) */
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID
   { "UuidCreate",               (SYSCALL)UuidCreate,             0 },
 #else
   { "UuidCreate",               (SYSCALL)0,                      0 },
 #endif
 #define osUuidCreate ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[77].pCurrent)
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID
   { "UuidCreateSequential",     (SYSCALL)UuidCreateSequential,   0 },
 #else
   { "UuidCreateSequential",     (SYSCALL)0,                      0 },
 #endif
 #define osUuidCreateSequential \
         ((RPC_STATUS(RPC_ENTRY*)(UUID*))aSyscall[78].pCurrent)
 #if !defined(SQLITE_NO_SYNC) && SQLITE_MAX_MMAP_SIZE>0
   { "FlushViewOfFile",          (SYSCALL)FlushViewOfFile,        0 },
 #else
   { "FlushViewOfFile",          (SYSCALL)0,                      0 },
 #endif
 #define osFlushViewOfFile \
         ((BOOL(WINAPI*)(LPCVOID,SIZE_T))aSyscall[79].pCurrent)
 }; /* End of the overrideable system calls */
 /*

@@ -34061,7 +34330,7 @@ static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){

 ** "pnLargest" argument, if non-zero, will be used to return the size of the
 ** largest committed free block in the heap, in bytes.
 */
 SQLITE_API int sqlite3_win32_compact_heap(LPUINT pnLargest){
 SQLITE_API int SQLITE_STDCALL sqlite3_win32_compact_heap(LPUINT pnLargest){
   int rc = SQLITE_OK;
   UINT nLargest = 0;
   HANDLE hHeap;

@@ -34101,7 +34370,7 @@ SQLITE_API int sqlite3_win32_compact_heap(LPUINT pnLargest){

 ** the sqlite3_memory_used() function does not return zero, SQLITE_BUSY will
 ** be returned and no changes will be made to the Win32 native heap.
 */
 SQLITE_API int sqlite3_win32_reset_heap(){
 SQLITE_API int SQLITE_STDCALL sqlite3_win32_reset_heap(){
   int rc;
   MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */
   MUTEX_LOGIC( sqlite3_mutex *pMem; )    /* The memsys static mutex */

@@ -34146,7 +34415,7 @@ SQLITE_API int sqlite3_win32_reset_heap(){

 ** (if available).
 */
 SQLITE_API void sqlite3_win32_write_debug(const char *zBuf, int nBuf){
 SQLITE_API void SQLITE_STDCALL sqlite3_win32_write_debug(const char *zBuf, int nBuf){
   char zDbgBuf[SQLITE_WIN32_DBG_BUF_SIZE];
   int nMin = MIN(nBuf, (SQLITE_WIN32_DBG_BUF_SIZE - 1)); /* may be negative. */
   if( nMin<-1 ) nMin = -1; /* all negative values become -1. */

@@ -34186,7 +34455,7 @@ SQLITE_API void sqlite3_win32_write_debug(const char *zBuf, int nBuf){

 static HANDLE sleepObj = NULL;
 #endif
 SQLITE_API void sqlite3_win32_sleep(DWORD milliseconds){
 SQLITE_API void SQLITE_STDCALL sqlite3_win32_sleep(DWORD milliseconds){
 #if SQLITE_OS_WINRT
   if ( sleepObj==NULL ){
     sleepObj = osCreateEventExW(NULL, NULL, CREATE_EVENT_MANUAL_RESET,

@@ -34235,7 +34504,7 @@ SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject){

 ** This function determines if the machine is running a version of Windows
 ** based on the NT kernel.
 */
 SQLITE_API int sqlite3_win32_is_nt(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_win32_is_nt(void){
 #if SQLITE_OS_WINRT
   /*
   ** NOTE: The WinRT sub-platform is always assumed to be based on the NT

@@ -34589,7 +34858,7 @@ static char *winUnicodeToMbcs(LPCWSTR zWideFilename){

 ** Convert multibyte character string to UTF-8.  Space to hold the
 ** returned string is obtained from sqlite3_malloc().
 */
 SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char *zFilename){
 SQLITE_API char *SQLITE_STDCALL sqlite3_win32_mbcs_to_utf8(const char *zFilename){
   char *zFilenameUtf8;
   LPWSTR zTmpWide;

@@ -34606,7 +34875,7 @@ SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char *zFilename){

 ** Convert UTF-8 to multibyte character string.  Space to hold the
 ** returned string is obtained from sqlite3_malloc().
 */
 SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char *zFilename){
 SQLITE_API char *SQLITE_STDCALL sqlite3_win32_utf8_to_mbcs(const char *zFilename){
   char *zFilenameMbcs;
   LPWSTR zTmpWide;

@@ -34626,7 +34895,7 @@ SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char *zFilename){

 ** argument is the name of the directory to use.  The return value will be
 ** SQLITE_OK if successful.
 */
 SQLITE_API int sqlite3_win32_set_directory(DWORD type, LPCWSTR zValue){
 SQLITE_API int SQLITE_STDCALL sqlite3_win32_set_directory(DWORD type, LPCWSTR zValue){
   char **ppDirectory = 0;
 #ifndef SQLITE_OMIT_AUTOINIT
   int rc = sqlite3_initialize();

@@ -34851,11 +35120,11 @@ static int winRetryIoerr(int *pnRetry, DWORD *pError){

 /*
 ** Log a I/O error retry episode.
 */
 static void winLogIoerr(int nRetry){
 static void winLogIoerr(int nRetry, int lineno){
   if( nRetry ){
     sqlite3_log(SQLITE_IOERR,
       "delayed %dms for lock/sharing conflict",
       winIoerrRetryDelay*nRetry*(nRetry+1)/2
     sqlite3_log(SQLITE_NOTICE,
       "delayed %dms for lock/sharing conflict at line %d",
       winIoerrRetryDelay*nRetry*(nRetry+1)/2, lineno
     );
   }
 }

@@ -35335,7 +35604,8 @@ static int winClose(sqlite3_file *id){

   assert( pFile->pShm==0 );
 #endif
   assert( pFile->h!=NULL && pFile->h!=INVALID_HANDLE_VALUE );
   OSTRACE(("CLOSE file=%p\n", pFile->h));
   OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p\n",
            osGetCurrentProcessId(), pFile, pFile->h));
 #if SQLITE_MAX_MMAP_SIZE>0
   winUnmapfile(pFile);

@@ -35364,7 +35634,8 @@ static int winClose(sqlite3_file *id){

     pFile->h = NULL;
   }
   OpenCounter(-1);
   OSTRACE(("CLOSE file=%p, rc=%s\n", pFile->h, rc ? "ok" : "failed"));
   OSTRACE(("CLOSE pid=%lu, pFile=%p, file=%p, rc=%s\n",
            osGetCurrentProcessId(), pFile, pFile->h, rc ? "ok" : "failed"));
   return rc ? SQLITE_OK
             : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(),
                           "winClose", pFile->zPath);

@@ -35392,7 +35663,8 @@ static int winRead(

   assert( amt>0 );
   assert( offset>=0 );
   SimulateIOError(return SQLITE_IOERR_READ);
   OSTRACE(("READ file=%p, buffer=%p, amount=%d, offset=%lld, lock=%d\n",
   OSTRACE(("READ pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, "
            "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
            pFile->h, pBuf, amt, offset, pFile->locktype));
 #if SQLITE_MAX_MMAP_SIZE>0

@@ -35401,7 +35673,8 @@ static int winRead(

   if( offset<pFile->mmapSize ){
     if( offset+amt <= pFile->mmapSize ){
       memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
       OSTRACE(("READ-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
       OSTRACE(("READ-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
                osGetCurrentProcessId(), pFile, pFile->h));
       return SQLITE_OK;
     }else{
       int nCopy = (int)(pFile->mmapSize - offset);

@@ -35415,7 +35688,8 @@ static int winRead(

 #if SQLITE_OS_WINCE || defined(SQLITE_WIN32_NO_OVERLAPPED)
   if( winSeekFile(pFile, offset) ){
     OSTRACE(("READ file=%p, rc=SQLITE_FULL\n", pFile->h));
     OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n",
              osGetCurrentProcessId(), pFile, pFile->h));
     return SQLITE_FULL;
   }
   while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){

@@ -35429,19 +35703,22 @@ static int winRead(

     DWORD lastErrno;
     if( winRetryIoerr(&nRetry, &lastErrno) ) continue;
     pFile->lastErrno = lastErrno;
     OSTRACE(("READ file=%p, rc=SQLITE_IOERR_READ\n", pFile->h));
     OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_READ\n",
              osGetCurrentProcessId(), pFile, pFile->h));
     return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
                        "winRead", pFile->zPath);
   }
   winLogIoerr(nRetry);
   winLogIoerr(nRetry, __LINE__);
   if( nRead<(DWORD)amt ){
     /* Unread parts of the buffer must be zero-filled */
     memset(&((char*)pBuf)[nRead], 0, amt-nRead);
     OSTRACE(("READ file=%p, rc=SQLITE_IOERR_SHORT_READ\n", pFile->h));
     OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_SHORT_READ\n",
              osGetCurrentProcessId(), pFile, pFile->h));
     return SQLITE_IOERR_SHORT_READ;
   }
   OSTRACE(("READ file=%p, rc=SQLITE_OK\n", pFile->h));
   OSTRACE(("READ pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
            osGetCurrentProcessId(), pFile, pFile->h));
   return SQLITE_OK;
 }

@@ -35464,7 +35741,8 @@ static int winWrite(

   SimulateIOError(return SQLITE_IOERR_WRITE);
   SimulateDiskfullError(return SQLITE_FULL);
   OSTRACE(("WRITE file=%p, buffer=%p, amount=%d, offset=%lld, lock=%d\n",
   OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, buffer=%p, amount=%d, "
            "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
            pFile->h, pBuf, amt, offset, pFile->locktype));
 #if SQLITE_MAX_MMAP_SIZE>0

@@ -35473,7 +35751,8 @@ static int winWrite(

   if( offset<pFile->mmapSize ){
     if( offset+amt <= pFile->mmapSize ){
       memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
       OSTRACE(("WRITE-MMAP file=%p, rc=SQLITE_OK\n", pFile->h));
       OSTRACE(("WRITE-MMAP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
                osGetCurrentProcessId(), pFile, pFile->h));
       return SQLITE_OK;
     }else{
       int nCopy = (int)(pFile->mmapSize - offset);

@@ -35536,17 +35815,20 @@ static int winWrite(

   if( rc ){
     if(   ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
        || ( pFile->lastErrno==ERROR_DISK_FULL )){
       OSTRACE(("WRITE file=%p, rc=SQLITE_FULL\n", pFile->h));
       OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_FULL\n",
                osGetCurrentProcessId(), pFile, pFile->h));
       return winLogError(SQLITE_FULL, pFile->lastErrno,
                          "winWrite1", pFile->zPath);
     }
     OSTRACE(("WRITE file=%p, rc=SQLITE_IOERR_WRITE\n", pFile->h));
     OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_WRITE\n",
              osGetCurrentProcessId(), pFile, pFile->h));
     return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
                        "winWrite2", pFile->zPath);
   }else{
     winLogIoerr(nRetry);
     winLogIoerr(nRetry, __LINE__);
   }
   OSTRACE(("WRITE file=%p, rc=SQLITE_OK\n", pFile->h));
   OSTRACE(("WRITE pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
            osGetCurrentProcessId(), pFile, pFile->h));
   return SQLITE_OK;
 }

@@ -35560,8 +35842,8 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){

   assert( pFile );
   SimulateIOError(return SQLITE_IOERR_TRUNCATE);
   OSTRACE(("TRUNCATE file=%p, size=%lld, lock=%d\n",
            pFile->h, nByte, pFile->locktype));
   OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, size=%lld, lock=%d\n",
            osGetCurrentProcessId(), pFile, pFile->h, nByte, pFile->locktype));
   /* If the user has configured a chunk-size for this file, truncate the
   ** file so that it consists of an integer number of chunks (i.e. the

@@ -35593,7 +35875,8 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){

   }
 #endif
   OSTRACE(("TRUNCATE file=%p, rc=%s\n", pFile->h, sqlite3ErrName(rc)));
   OSTRACE(("TRUNCATE pid=%lu, pFile=%p, file=%p, rc=%s\n",
            osGetCurrentProcessId(), pFile, pFile->h, sqlite3ErrName(rc)));
   return rc;
 }

@@ -35638,8 +35921,9 @@ static int winSync(sqlite3_file *id, int flags){

   */
   SimulateDiskfullError( return SQLITE_FULL );
   OSTRACE(("SYNC file=%p, flags=%x, lock=%d\n",
            pFile->h, flags, pFile->locktype));
   OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, flags=%x, lock=%d\n",
            osGetCurrentProcessId(), pFile, pFile->h, flags,
            pFile->locktype));
 #ifndef SQLITE_TEST
   UNUSED_PARAMETER(flags);

@@ -35654,19 +35938,38 @@ static int winSync(sqlite3_file *id, int flags){

   ** no-op
   */
 #ifdef SQLITE_NO_SYNC
   OSTRACE(("SYNC-NOP file=%p, rc=SQLITE_OK\n", pFile->h));
   OSTRACE(("SYNC-NOP pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
            osGetCurrentProcessId(), pFile, pFile->h));
   return SQLITE_OK;
 #else
 #if SQLITE_MAX_MMAP_SIZE>0
   if( pFile->pMapRegion ){
     if( osFlushViewOfFile(pFile->pMapRegion, 0) ){
       OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, "
                "rc=SQLITE_OK\n", osGetCurrentProcessId(),
                pFile, pFile->pMapRegion));
     }else{
       pFile->lastErrno = osGetLastError();
       OSTRACE(("SYNC-MMAP pid=%lu, pFile=%p, pMapRegion=%p, "
                "rc=SQLITE_IOERR_MMAP\n", osGetCurrentProcessId(),
                pFile, pFile->pMapRegion));
       return winLogError(SQLITE_IOERR_MMAP, pFile->lastErrno,
                          "winSync1", pFile->zPath);
     }
   }
 #endif
   rc = osFlushFileBuffers(pFile->h);
   SimulateIOError( rc=FALSE );
   if( rc ){
     OSTRACE(("SYNC file=%p, rc=SQLITE_OK\n", pFile->h));
     OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_OK\n",
              osGetCurrentProcessId(), pFile, pFile->h));
     return SQLITE_OK;
   }else{
     pFile->lastErrno = osGetLastError();
     OSTRACE(("SYNC file=%p, rc=SQLITE_IOERR_FSYNC\n", pFile->h));
     OSTRACE(("SYNC pid=%lu, pFile=%p, file=%p, rc=SQLITE_IOERR_FSYNC\n",
              osGetCurrentProcessId(), pFile, pFile->h));
     return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
                        "winSync", pFile->zPath);
                        "winSync2", pFile->zPath);
   }
 #endif
 }

@@ -36716,16 +37019,16 @@ static int winShmMap(

   void volatile **pp              /* OUT: Mapped memory */
 ){
   winFile *pDbFd = (winFile*)fd;
   winShm *p = pDbFd->pShm;
   winShm *pShm = pDbFd->pShm;
   winShmNode *pShmNode;
   int rc = SQLITE_OK;
   if( !p ){
   if( !pShm ){
     rc = winOpenSharedMemory(pDbFd);
     if( rc!=SQLITE_OK ) return rc;
     p = pDbFd->pShm;
     pShm = pDbFd->pShm;
   }
   pShmNode = p->pShmNode;
   pShmNode = pShm->pShmNode;
   sqlite3_mutex_enter(pShmNode->mutex);
   assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );

@@ -37637,7 +37940,7 @@ static int winOpen(

     }
   }
 #endif
   winLogIoerr(cnt);
   winLogIoerr(cnt, __LINE__);
   OSTRACE(("OPEN file=%p, name=%s, access=%lx, rc=%s\n", h, zUtf8Name,
            dwDesiredAccess, (h==INVALID_HANDLE_VALUE) ? "failed" : "ok"));

@@ -37821,7 +38124,7 @@ static int winDelete(

   if( rc && rc!=SQLITE_IOERR_DELETE_NOENT ){
     rc = winLogError(SQLITE_IOERR_DELETE, lastErrno, "winDelete", zFilename);
   }else{
     winLogIoerr(cnt);
     winLogIoerr(cnt, __LINE__);
   }
   sqlite3_free(zConverted);
   OSTRACE(("DELETE name=%s, rc=%s\n", zFilename, sqlite3ErrName(rc)));

@@ -37871,7 +38174,7 @@ static int winAccess(

         attr = sAttrData.dwFileAttributes;
       }
     }else{
       winLogIoerr(cnt);
       winLogIoerr(cnt, __LINE__);
       if( lastErrno!=ERROR_FILE_NOT_FOUND && lastErrno!=ERROR_PATH_NOT_FOUND ){
         sqlite3_free(zConverted);
         return winLogError(SQLITE_IOERR_ACCESS, lastErrno, "winAccess",

@@ -38247,6 +38550,22 @@ static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){

     n += sizeof(i);
   }
 #endif
 #if !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && SQLITE_WIN32_USE_UUID
   if( sizeof(UUID)<=nBuf-n ){
     UUID id;
     memset(&id, 0, sizeof(UUID));
     osUuidCreate(&id);
     memcpy(zBuf, &id, sizeof(UUID));
     n += sizeof(UUID);
   }
   if( sizeof(UUID)<=nBuf-n ){
     UUID id;
     memset(&id, 0, sizeof(UUID));
     osUuidCreateSequential(&id);
     memcpy(zBuf, &id, sizeof(UUID));
     n += sizeof(UUID);
   }
 #endif
   return n;
 }

@@ -38370,7 +38689,7 @@ static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){

 /*
 ** Initialize and deinitialize the operating system interface.
 */
 SQLITE_API int sqlite3_os_init(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void){
   static sqlite3_vfs winVfs = {
 ,                   /* iVersion */
     sizeof(winFile),     /* szOsFile */

@@ -38424,7 +38743,7 @@ SQLITE_API int sqlite3_os_init(void){

   /* Double-check that the aSyscall[] array has been constructed
   ** correctly.  See ticket [bb3a86e890c8e96ab] */
   assert( ArraySize(aSyscall)==77 );
   assert( ArraySize(aSyscall)==80 );
   /* get memory map allocation granularity */
   memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));

@@ -38445,7 +38764,7 @@ SQLITE_API int sqlite3_os_init(void){

   return SQLITE_OK;
 }
 SQLITE_API int sqlite3_os_end(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void){
 #if SQLITE_OS_WINRT
   if( sleepObj!=NULL ){
     osCloseHandle(sleepObj);

@@ -38983,12 +39302,20 @@ static void pcacheUnpin(PgHdr *p){

 }
 /*
 ** Compute the number of pages of cache requested.
 ** Compute the number of pages of cache requested.  p->szCache is the
 ** cache size requested by the "PRAGMA cache_size" statement.
 **
 **
 */
 static int numberOfCachePages(PCache *p){
   if( p->szCache>=0 ){
     /* IMPLEMENTATION-OF: R-42059-47211 If the argument N is positive then the
     ** suggested cache size is set to N. */
     return p->szCache;
   }else{
     /* IMPLEMENTATION-OF: R-61436-13639 If the argument N is negative, then
     ** the number of cache pages is adjusted to use approximately abs(N*1024)
     ** bytes of memory. */
     return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
   }
 }

@@ -39728,7 +40055,6 @@ SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){

 static void *pcache1Alloc(int nByte){
   void *p = 0;
   assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
   sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
   if( nByte<=pcache1.szSlot ){
     sqlite3_mutex_enter(pcache1.mutex);
     p = (PgHdr1 *)pcache1.pFree;

@@ -39737,7 +40063,8 @@ static void *pcache1Alloc(int nByte){

       pcache1.nFreeSlot--;
       pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
       assert( pcache1.nFreeSlot>=0 );
       sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
       sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
       sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_USED, 1);
     }
     sqlite3_mutex_leave(pcache1.mutex);
   }

@@ -39750,7 +40077,8 @@ static void *pcache1Alloc(int nByte){

     if( p ){
       int sz = sqlite3MallocSize(p);
       sqlite3_mutex_enter(pcache1.mutex);
       sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
       sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
       sqlite3StatusUp(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
       sqlite3_mutex_leave(pcache1.mutex);
     }
 #endif

@@ -39768,7 +40096,7 @@ static int pcache1Free(void *p){

   if( p>=pcache1.pStart && p<pcache1.pEnd ){
     PgFreeslot *pSlot;
     sqlite3_mutex_enter(pcache1.mutex);
     sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
     sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_USED, 1);
     pSlot = (PgFreeslot*)p;
     pSlot->pNext = pcache1.pFree;
     pcache1.pFree = pSlot;

@@ -39782,7 +40110,7 @@ static int pcache1Free(void *p){

     nFreed = sqlite3MallocSize(p);
 #ifndef SQLITE_DISABLE_PAGECACHE_OVERFLOW_STATS
     sqlite3_mutex_enter(pcache1.mutex);
     sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -nFreed);
     sqlite3StatusDown(SQLITE_STATUS_PAGECACHE_OVERFLOW, nFreed);
     sqlite3_mutex_leave(pcache1.mutex);
 #endif
     sqlite3_free(p);

@@ -40519,6 +40847,14 @@ SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){

 */
 SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void){ return ROUND8(sizeof(PgHdr1)); }
 /*
 ** Return the global mutex used by this PCACHE implementation.  The
 ** sqlite3_status() routine needs access to this mutex.
 */
 SQLITE_PRIVATE sqlite3_mutex *sqlite3Pcache1Mutex(void){
   return pcache1.mutex;
 }
 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
 /*
 ** This function is called to free superfluous dynamically allocated memory

@@ -49291,9 +49627,10 @@ static void walUnlockShared(Wal *pWal, int lockIdx){

                          SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED);
   WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
 }
 static int walLockExclusive(Wal *pWal, int lockIdx, int n){
 static int walLockExclusive(Wal *pWal, int lockIdx, int n, int fBlock){
   int rc;
   if( pWal->exclusiveMode ) return SQLITE_OK;
   if( fBlock ) sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_WAL_BLOCK, 0);
   rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
                         SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE);
   WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,

@@ -49579,7 +49916,7 @@ static int walIndexRecover(Wal *pWal){

   assert( pWal->writeLock );
   iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
   nLock = SQLITE_SHM_NLOCK - iLock;
   rc = walLockExclusive(pWal, iLock, nLock);
   rc = walLockExclusive(pWal, iLock, nLock, 0);
   if( rc ){
     return rc;
   }

@@ -50113,7 +50450,7 @@ static int walBusyLock(

 ){
   int rc;
   do {
     rc = walLockExclusive(pWal, lockIdx, n);
     rc = walLockExclusive(pWal, lockIdx, n, 0);
   }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) );
   return rc;
 }

@@ -50546,7 +50883,7 @@ static int walIndexReadHdr(Wal *pWal, int *pChanged){

         walUnlockShared(pWal, WAL_WRITE_LOCK);
         rc = SQLITE_READONLY_RECOVERY;
       }
     }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
     }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1, 1)) ){
       pWal->writeLock = 1;
       if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
         badHdr = walIndexTryHdr(pWal, pChanged);

@@ -50752,7 +51089,7 @@ static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){

      && (mxReadMark<pWal->hdr.mxFrame || mxI==0)
     ){
       for(i=1; i<WAL_NREADER; i++){
         rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
         rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1, 0);
         if( rc==SQLITE_OK ){
           mxReadMark = pInfo->aReadMark[i] = pWal->hdr.mxFrame;
           mxI = i;

@@ -51008,7 +51345,7 @@ SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){

   /* Only one writer allowed at a time.  Get the write lock.  Return
   ** SQLITE_BUSY if unable.
   */
   rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
   rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1, 0);
   if( rc ){
     return rc;
   }

@@ -51153,7 +51490,7 @@ static int walRestartLog(Wal *pWal){

     if( pInfo->nBackfill>0 ){
       u32 salt1;
       sqlite3_randomness(4, &salt1);
       rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
       rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1, 0);
       if( rc==SQLITE_OK ){
         /* If all readers are using WAL_READ_LOCK(0) (in other words if no
         ** readers are currently using the WAL), then the transactions

@@ -51478,7 +51815,7 @@ SQLITE_PRIVATE int sqlite3WalCheckpoint(

   /* IMPLEMENTATION-OF: R-62028-47212 All calls obtain an exclusive
   ** "checkpoint" lock on the database file. */
   rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
   rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1, 0);
   if( rc ){
     /* EVIDENCE-OF: R-10421-19736 If any other process is running a
     ** checkpoint operation at the same time, the lock cannot be obtained and

@@ -51953,6 +52290,7 @@ struct MemPage {

   u8 hdrOffset;        /* 100 for page 1.  0 otherwise */
   u8 childPtrSize;     /* 0 if leaf==1.  4 if leaf==0 */
   u8 max1bytePayload;  /* min(maxLocal,127) */
   u8 bBusy;            /* Prevent endless loops on corrupt database files */
   u16 maxLocal;        /* Copy of BtShared.maxLocal or BtShared.maxLeaf */
   u16 minLocal;        /* Copy of BtShared.minLocal or BtShared.minLeaf */
   u16 cellOffset;      /* Index in aData of first cell pointer */

@@ -52091,6 +52429,9 @@ struct BtShared {

 #endif
   u8 inTransaction;     /* Transaction state */
   u8 max1bytePayload;   /* Maximum first byte of cell for a 1-byte payload */
 #ifdef SQLITE_HAS_CODEC
   u8 optimalReserve;    /* Desired amount of reserved space per page */
 #endif
   u16 btsFlags;         /* Boolean parameters.  See BTS_* macros below */
   u16 maxLocal;         /* Maximum local payload in non-LEAFDATA tables */
   u16 minLocal;         /* Minimum local payload in non-LEAFDATA tables */

@@ -52477,6 +52818,7 @@ static void SQLITE_NOINLINE btreeLockCarefully(Btree *p){

 ** Exit the recursive mutex on a Btree.
 */
 SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
   assert( sqlite3_mutex_held(p->db->mutex) );
   if( p->sharable ){
     assert( p->wantToLock>0 );
     p->wantToLock--;

@@ -52724,7 +53066,7 @@ static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;

 ** The shared cache setting effects only future calls to
 ** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
 */
 SQLITE_API int sqlite3_enable_shared_cache(int enable){
 SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache(int enable){
   sqlite3GlobalConfig.sharedCacheEnabled = enable;
   return SQLITE_OK;
 }

@@ -52813,6 +53155,12 @@ static int hasSharedCacheTableLock(

     for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){
       Index *pIdx = (Index *)sqliteHashData(p);
       if( pIdx->tnum==(int)iRoot ){
         if( iTab ){
           /* Two or more indexes share the same root page.  There must
           ** be imposter tables.  So just return true.  The assert is not
           ** useful in that case. */
           return 1;
         }
         iTab = pIdx->pTable->tnum;
       }
     }

@@ -53232,10 +53580,15 @@ static void btreeReleaseAllCursorPages(BtCursor *pCur){

 static int saveCursorPosition(BtCursor *pCur){
   int rc;
   assert( CURSOR_VALID==pCur->eState );
   assert( CURSOR_VALID==pCur->eState || CURSOR_SKIPNEXT==pCur->eState );
   assert( 0==pCur->pKey );
   assert( cursorHoldsMutex(pCur) );
   if( pCur->eState==CURSOR_SKIPNEXT ){
     pCur->eState = CURSOR_VALID;
   }else{
     pCur->skipNext = 0;
   }
   rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
   assert( rc==SQLITE_OK );  /* KeySize() cannot fail */

@@ -53306,7 +53659,7 @@ static int SQLITE_NOINLINE saveCursorsOnList(

 ){
   do{
     if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) ){
       if( p->eState==CURSOR_VALID ){
       if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
         int rc = saveCursorPosition(p);
         if( SQLITE_OK!=rc ){
           return rc;

@@ -53378,17 +53731,19 @@ static int btreeMoveto(

 */
 static int btreeRestoreCursorPosition(BtCursor *pCur){
   int rc;
   int skipNext;
   assert( cursorHoldsMutex(pCur) );
   assert( pCur->eState>=CURSOR_REQUIRESEEK );
   if( pCur->eState==CURSOR_FAULT ){
     return pCur->skipNext;
   }
   pCur->eState = CURSOR_INVALID;
   rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
   rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
   if( rc==SQLITE_OK ){
     sqlite3_free(pCur->pKey);
     pCur->pKey = 0;
     assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
     pCur->skipNext |= skipNext;
     if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
       pCur->eState = CURSOR_SKIPNEXT;
     }

@@ -53440,9 +53795,10 @@ SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor *pCur, int *pDifferentRow)

     *pDifferentRow = 1;
     return rc;
   }
   if( pCur->eState!=CURSOR_VALID || NEVER(pCur->skipNext!=0) ){
   if( pCur->eState!=CURSOR_VALID ){
     *pDifferentRow = 1;
   }else{
     assert( pCur->skipNext==0 );
     *pDifferentRow = 0;
   }
   return SQLITE_OK;

@@ -54583,16 +54939,18 @@ SQLITE_PRIVATE int sqlite3BtreeOpen(

   */
   if( isTempDb==0 && (isMemdb==0 || (vfsFlags&SQLITE_OPEN_URI)!=0) ){
     if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){
       int nFilename = sqlite3Strlen30(zFilename)+1;
       int nFullPathname = pVfs->mxPathname+1;
       char *zFullPathname = sqlite3Malloc(nFullPathname);
       char *zFullPathname = sqlite3Malloc(MAX(nFullPathname,nFilename));
       MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
       p->sharable = 1;
       if( !zFullPathname ){
         sqlite3_free(p);
         return SQLITE_NOMEM;
       }
       if( isMemdb ){
         memcpy(zFullPathname, zFilename, sqlite3Strlen30(zFilename)+1);
         memcpy(zFullPathname, zFilename, nFilename);
       }else{
         rc = sqlite3OsFullPathname(pVfs, zFilename,
                                    nFullPathname, zFullPathname);

@@ -54649,8 +55007,8 @@ SQLITE_PRIVATE int sqlite3BtreeOpen(

     ** the right size.  This is to guard against size changes that result
     ** when compiling on a different architecture.
     */
     assert( sizeof(i64)==8 || sizeof(i64)==4 );
     assert( sizeof(u64)==8 || sizeof(u64)==4 );
     assert( sizeof(i64)==8 );
     assert( sizeof(u64)==8 );
     assert( sizeof(u32)==4 );
     assert( sizeof(u16)==2 );
     assert( sizeof(Pgno)==4 );

@@ -55037,6 +55395,9 @@ SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve,

   BtShared *pBt = p->pBt;
   assert( nReserve>=-1 && nReserve<=255 );
   sqlite3BtreeEnter(p);
 #if SQLITE_HAS_CODEC
   if( nReserve>pBt->optimalReserve ) pBt->optimalReserve = (u8)nReserve;
 #endif
   if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
     sqlite3BtreeLeave(p);
     return SQLITE_READONLY;

@@ -55066,7 +55427,6 @@ SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){

   return p->pBt->pageSize;
 }
 #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_DEBUG)
 /*
 ** This function is similar to sqlite3BtreeGetReserve(), except that it
 ** may only be called if it is guaranteed that the b-tree mutex is already

@@ -55079,25 +55439,33 @@ SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){

 ** database handle that owns *p, causing undefined behavior.
 */
 SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p){
   int n;
   assert( sqlite3_mutex_held(p->pBt->mutex) );
   return p->pBt->pageSize - p->pBt->usableSize;
   n = p->pBt->pageSize - p->pBt->usableSize;
   return n;
 }
 #endif /* SQLITE_HAS_CODEC || SQLITE_DEBUG */
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM)
 /*
 ** Return the number of bytes of space at the end of every page that
 ** are intentually left unused.  This is the "reserved" space that is
 ** sometimes used by extensions.
 **
 ** If SQLITE_HAS_MUTEX is defined then the number returned is the
 ** greater of the current reserved space and the maximum requested
 ** reserve space.
 */
 SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree *p){
 SQLITE_PRIVATE int sqlite3BtreeGetOptimalReserve(Btree *p){
   int n;
   sqlite3BtreeEnter(p);
   n = p->pBt->pageSize - p->pBt->usableSize;
   n = sqlite3BtreeGetReserveNoMutex(p);
 #ifdef SQLITE_HAS_CODEC
   if( n<p->pBt->optimalReserve ) n = p->pBt->optimalReserve;
 #endif
   sqlite3BtreeLeave(p);
   return n;
 }
 /*
 ** Set the maximum page count for a database if mxPage is positive.
 ** No changes are made if mxPage is 0 or negative.

@@ -55128,7 +55496,6 @@ SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){

   sqlite3BtreeLeave(p);
   return b;
 }
 #endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */
 /*
 ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'

@@ -56248,7 +56615,7 @@ SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int wr

     for(p=pBtree->pBt->pCursor; p; p=p->pNext){
       int i;
       if( writeOnly && (p->curFlags & BTCF_WriteFlag)==0 ){
         if( p->eState==CURSOR_VALID ){
         if( p->eState==CURSOR_VALID || p->eState==CURSOR_SKIPNEXT ){
           rc = saveCursorPosition(p);
           if( rc!=SQLITE_OK ){
             (void)sqlite3BtreeTripAllCursors(pBtree, rc, 0);

@@ -56654,6 +57021,8 @@ SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){

 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
   assert( cursorHoldsMutex(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage>=0 );
   assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
   assert( pCur->apPage[pCur->iPage]->intKeyLeaf==1 );
   getCellInfo(pCur);
   *pSize = pCur->info.nPayload;

@@ -57132,7 +57501,7 @@ static int moveToChild(BtCursor *pCur, u32 newPgno){

   return SQLITE_OK;
 }
 #if 0
 #if SQLITE_DEBUG
 /*
 ** Page pParent is an internal (non-leaf) tree page. This function
 ** asserts that page number iChild is the left-child if the iIdx'th

@@ -57141,6 +57510,8 @@ static int moveToChild(BtCursor *pCur, u32 newPgno){

 ** the page.
 */
 static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
   if( CORRUPT_DB ) return;  /* The conditions tested below might not be true
                             ** in a corrupt database */
   assert( iIdx<=pParent->nCell );
   if( iIdx==pParent->nCell ){
     assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );

@@ -57165,19 +57536,11 @@ static void moveToParent(BtCursor *pCur){

   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage>0 );
   assert( pCur->apPage[pCur->iPage] );
   /* UPDATE: It is actually possible for the condition tested by the assert
   ** below to be untrue if the database file is corrupt. This can occur if
   ** one cursor has modified page pParent while a reference to it is held
   ** by a second cursor. Which can only happen if a single page is linked
   ** into more than one b-tree structure in a corrupt database.  */
 #if 0
   assertParentIndex(
     pCur->apPage[pCur->iPage-1],
     pCur->aiIdx[pCur->iPage-1],
     pCur->apPage[pCur->iPage]->pgno
   );
 #endif
   testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
   releasePage(pCur->apPage[pCur->iPage]);

@@ -60103,7 +60466,8 @@ static int balance(BtCursor *pCur){

           ** pSpace buffer passed to the latter call to balance_nonroot().
           */
           u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
           rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1, pCur->hints);
           rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1,
                                pCur->hints&BTREE_BULKLOAD);
           if( pFree ){
             /* If pFree is not NULL, it points to the pSpace buffer used
             ** by a previous call to balance_nonroot(). Its contents are

@@ -60124,6 +60488,7 @@ static int balance(BtCursor *pCur){

       /* The next iteration of the do-loop balances the parent page. */
       releasePage(pPage);
       pCur->iPage--;
       assert( pCur->iPage>=0 );
     }
   }while( rc==SQLITE_OK );

@@ -60600,9 +60965,13 @@ static int clearDatabasePage(

   if( pgno>btreePagecount(pBt) ){
     return SQLITE_CORRUPT_BKPT;
   }
   rc = getAndInitPage(pBt, pgno, &pPage, 0);
   if( rc ) return rc;
   if( pPage->bBusy ){
     rc = SQLITE_CORRUPT_BKPT;
     goto cleardatabasepage_out;
   }
   pPage->bBusy = 1;
   hdr = pPage->hdrOffset;
   for(i=0; i<pPage->nCell; i++){
     pCell = findCell(pPage, i);

@@ -60627,6 +60996,7 @@ static int clearDatabasePage(

   }
 cleardatabasepage_out:
   pPage->bBusy = 0;
   releasePage(pPage);
   return rc;
 }

@@ -61766,14 +62136,23 @@ SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){

 }
 /*
 ** set the mask of hint flags for cursor pCsr. Currently the only valid
 ** values are 0 and BTREE_BULKLOAD.
 ** set the mask of hint flags for cursor pCsr.
 */
 SQLITE_PRIVATE void sqlite3BtreeCursorHints(BtCursor *pCsr, unsigned int mask){
   assert( mask==BTREE_BULKLOAD || mask==0 );
   assert( mask==BTREE_BULKLOAD || mask==BTREE_SEEK_EQ || mask==0 );
   pCsr->hints = mask;
 }
 #ifdef SQLITE_DEBUG
 /*
 ** Return true if the cursor has a hint specified.  This routine is
 ** only used from within assert() statements
 */
 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){
   return (pCsr->hints & mask)!=0;
 }
 #endif
 /*
 ** Return true if the given Btree is read-only.
 */

@@ -61932,7 +62311,7 @@ static int checkReadTransaction(sqlite3 *db, Btree *p){

 ** If an error occurs, NULL is returned and an error code and error message
 ** stored in database handle pDestDb.
 */
 SQLITE_API sqlite3_backup *sqlite3_backup_init(
 SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init(
   sqlite3* pDestDb,                     /* Database to write to */
   const char *zDestDb,                  /* Name of database within pDestDb */
   sqlite3* pSrcDb,                      /* Database connection to read from */

@@ -62035,7 +62414,7 @@ static int backupOnePage(

   ** guaranteed that the shared-mutex is held by this thread, handle
   ** p->pSrc may not actually be the owner.  */
   int nSrcReserve = sqlite3BtreeGetReserveNoMutex(p->pSrc);
   int nDestReserve = sqlite3BtreeGetReserve(p->pDest);
   int nDestReserve = sqlite3BtreeGetOptimalReserve(p->pDest);
 #endif
   int rc = SQLITE_OK;
   i64 iOff;

@@ -62140,7 +62519,7 @@ static void attachBackupObject(sqlite3_backup *p){

 /*
 ** Copy nPage pages from the source b-tree to the destination.
 */
 SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage){
   int rc;
   int destMode;       /* Destination journal mode */
   int pgszSrc = 0;    /* Source page size */

@@ -62385,7 +62764,7 @@ SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){

 /*
 ** Release all resources associated with an sqlite3_backup* handle.
 */
 SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p){
   sqlite3_backup **pp;                 /* Ptr to head of pagers backup list */
   sqlite3 *pSrcDb;                     /* Source database connection */
   int rc;                              /* Value to return */

@@ -62437,7 +62816,7 @@ SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){

 ** Return the number of pages still to be backed up as of the most recent
 ** call to sqlite3_backup_step().
 */
 SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( p==0 ){
     (void)SQLITE_MISUSE_BKPT;

@@ -62451,7 +62830,7 @@ SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p){

 ** Return the total number of pages in the source database as of the most
 ** recent call to sqlite3_backup_step().
 */
 SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( p==0 ){
     (void)SQLITE_MISUSE_BKPT;

@@ -63666,7 +64045,7 @@ struct ValueNewStat4Ctx {

 ** Otherwise, if the second argument is non-zero, then this function is
 ** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not
 ** already been allocated, allocate the UnpackedRecord structure that
 ** that function will return to its caller here. Then return a pointer
 ** that function will return to its caller here. Then return a pointer to
 ** an sqlite3_value within the UnpackedRecord.a[] array.
 */
 static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){

@@ -63711,6 +64090,113 @@ static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){

 }
 /*
 ** The expression object indicated by the second argument is guaranteed
 ** to be a scalar SQL function. If
 **
 **   * all function arguments are SQL literals,
 **   * the SQLITE_FUNC_CONSTANT function flag is set, and
 **   * the SQLITE_FUNC_NEEDCOLL function flag is not set,
 **
 ** then this routine attempts to invoke the SQL function. Assuming no
 ** error occurs, output parameter (*ppVal) is set to point to a value
 ** object containing the result before returning SQLITE_OK.
 **
 ** Affinity aff is applied to the result of the function before returning.
 ** If the result is a text value, the sqlite3_value object uses encoding
 ** enc.
 **
 ** If the conditions above are not met, this function returns SQLITE_OK
 ** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to
 ** NULL and an SQLite error code returned.
 */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
 static int valueFromFunction(
   sqlite3 *db,                    /* The database connection */
   Expr *p,                        /* The expression to evaluate */
   u8 enc,                         /* Encoding to use */
   u8 aff,                         /* Affinity to use */
   sqlite3_value **ppVal,          /* Write the new value here */
   struct ValueNewStat4Ctx *pCtx   /* Second argument for valueNew() */
 ){
   sqlite3_context ctx;            /* Context object for function invocation */
   sqlite3_value **apVal = 0;      /* Function arguments */
   int nVal = 0;                   /* Size of apVal[] array */
   FuncDef *pFunc = 0;             /* Function definition */
   sqlite3_value *pVal = 0;        /* New value */
   int rc = SQLITE_OK;             /* Return code */
   int nName;                      /* Size of function name in bytes */
   ExprList *pList = 0;            /* Function arguments */
   int i;                          /* Iterator variable */
   assert( pCtx!=0 );
   assert( (p->flags & EP_TokenOnly)==0 );
   pList = p->x.pList;
   if( pList ) nVal = pList->nExpr;
   nName = sqlite3Strlen30(p->u.zToken);
   pFunc = sqlite3FindFunction(db, p->u.zToken, nName, nVal, enc, 0);
   assert( pFunc );
   if( (pFunc->funcFlags & SQLITE_FUNC_CONSTANT)==0
    || (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
   ){
     return SQLITE_OK;
   }
   if( pList ){
     apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal);
     if( apVal==0 ){
       rc = SQLITE_NOMEM;
       goto value_from_function_out;
     }
     for(i=0; i<nVal; i++){
       rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
       if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out;
     }
   }
   pVal = valueNew(db, pCtx);
   if( pVal==0 ){
     rc = SQLITE_NOMEM;
     goto value_from_function_out;
   }
   assert( pCtx->pParse->rc==SQLITE_OK );
   memset(&ctx, 0, sizeof(ctx));
   ctx.pOut = pVal;
   ctx.pFunc = pFunc;
   pFunc->xFunc(&ctx, nVal, apVal);
   if( ctx.isError ){
     rc = ctx.isError;
     sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
   }else{
     sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);
     assert( rc==SQLITE_OK );
     rc = sqlite3VdbeChangeEncoding(pVal, enc);
     if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){
       rc = SQLITE_TOOBIG;
       pCtx->pParse->nErr++;
     }
   }
   pCtx->pParse->rc = rc;
  value_from_function_out:
   if( rc!=SQLITE_OK ){
     pVal = 0;
   }
   if( apVal ){
     for(i=0; i<nVal; i++){
       sqlite3ValueFree(apVal[i]);
     }
     sqlite3DbFree(db, apVal);
   }
   *ppVal = pVal;
   return rc;
 }
 #else
 # define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
 #endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */
 /*
 ** Extract a value from the supplied expression in the manner described
 ** above sqlite3ValueFromExpr(). Allocate the sqlite3_value object
 ** using valueNew().

@@ -63742,6 +64228,12 @@ static int valueFromExpr(

   while( (op = pExpr->op)==TK_UPLUS ) pExpr = pExpr->pLeft;
   if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
   /* Compressed expressions only appear when parsing the DEFAULT clause
   ** on a table column definition, and hence only when pCtx==0.  This
   ** check ensures that an EP_TokenOnly expression is never passed down
   ** into valueFromFunction(). */
   assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
   if( op==TK_CAST ){
     u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
     rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);

@@ -63818,6 +64310,12 @@ static int valueFromExpr(

   }
 #endif
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   else if( op==TK_FUNCTION && pCtx!=0 ){
     rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
   }
 #endif
   *ppVal = pVal;
   return rc;

@@ -64207,7 +64705,7 @@ SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepa

 /*
 ** Return the SQL associated with a prepared statement
 */
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt){
   Vdbe *p = (Vdbe *)pStmt;
   return (p && p->isPrepareV2) ? p->zSql : 0;
 }

@@ -65270,7 +65768,7 @@ static char *displayP4(Op *pOp, char *zTemp, int nTemp){

 #ifndef SQLITE_OMIT_VIRTUALTABLE
     case P4_VTAB: {
       sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
       sqlite3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule);
       sqlite3_snprintf(nTemp, zTemp, "vtab:%p", pVtab);
       break;
     }
 #endif

@@ -65934,9 +66432,9 @@ SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){

   else if( pCx->pVtabCursor ){
     sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
     const sqlite3_module *pModule = pVtabCursor->pVtab->pModule;
     p->inVtabMethod = 1;
     assert( pVtabCursor->pVtab->nRef>0 );
     pVtabCursor->pVtab->nRef--;
     pModule->xClose(pVtabCursor);
     p->inVtabMethod = 0;
   }
 #endif
 }

@@ -66295,7 +66793,7 @@ static int vdbeCommit(sqlite3 *db, Vdbe *p){

     ** doing this the directory is synced again before any individual
     ** transaction files are deleted.
     */
     rc = sqlite3OsDelete(pVfs, zMaster, 1);
     rc = sqlite3OsDelete(pVfs, zMaster, needSync);
     sqlite3DbFree(db, zMaster);
     zMaster = 0;
     if( rc ){

@@ -67525,7 +68023,8 @@ static void vdbeAssertFieldCountWithinLimits(

   if( CORRUPT_DB ) return;
   idx = getVarint32(aKey, szHdr);
   assert( szHdr<=nKey );
   assert( nKey>=0 );
   assert( szHdr<=(u32)nKey );
   while( idx<szHdr ){
     idx += getVarint32(aKey+idx, notUsed);
     nField++;

@@ -68362,7 +68861,7 @@ SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){

 ** collating sequences are registered or if an authorizer function is
 ** added or changed.
 */
 SQLITE_API int sqlite3_expired(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt *pStmt){
   Vdbe *p = (Vdbe*)pStmt;
   return p==0 || p->expired;
 }

@@ -68399,7 +68898,7 @@ static int vdbeSafetyNotNull(Vdbe *p){

 ** This routine sets the error code and string returned by
 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
 */
 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt){
   int rc;
   if( pStmt==0 ){
     /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL

@@ -68425,7 +68924,7 @@ SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){

 ** This routine sets the error code and string returned by
 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
 */
 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt){
   int rc;
   if( pStmt==0 ){
     rc = SQLITE_OK;

@@ -68444,7 +68943,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){

 /*
 ** Set all the parameters in the compiled SQL statement to NULL.
 */
 SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt *pStmt){
   int i;
   int rc = SQLITE_OK;
   Vdbe *p = (Vdbe*)pStmt;

@@ -68468,7 +68967,7 @@ SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){

 ** The following routines extract information from a Mem or sqlite3_value
 ** structure.
 */
 SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value *pVal){
   Mem *p = (Mem*)pVal;
   if( p->flags & (MEM_Blob|MEM_Str) ){
     sqlite3VdbeMemExpandBlob(p);

@@ -68478,36 +68977,40 @@ SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){

     return sqlite3_value_text(pVal);
   }
 }
 SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){
 SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value *pVal){
   return sqlite3ValueBytes(pVal, SQLITE_UTF8);
 }
 SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){
 SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value *pVal){
   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
 }
 SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){
 SQLITE_API double SQLITE_STDCALL sqlite3_value_double(sqlite3_value *pVal){
   return sqlite3VdbeRealValue((Mem*)pVal);
 }
 SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){
 SQLITE_API int SQLITE_STDCALL sqlite3_value_int(sqlite3_value *pVal){
   return (int)sqlite3VdbeIntValue((Mem*)pVal);
 }
 SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
 SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value *pVal){
   return sqlite3VdbeIntValue((Mem*)pVal);
 }
 SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value *pVal){
   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value* pVal){
   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
 }
 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value *pVal){
   return sqlite3ValueText(pVal, SQLITE_UTF16BE);
 }
 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value *pVal){
   return sqlite3ValueText(pVal, SQLITE_UTF16LE);
 }
 #endif /* SQLITE_OMIT_UTF16 */
 SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
 /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
 ** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
 ** point number string BLOB NULL
 */
 SQLITE_API int SQLITE_STDCALL sqlite3_value_type(sqlite3_value* pVal){
   static const u8 aType[] = {
      SQLITE_BLOB,     /* 0x00 */
      SQLITE_NULL,     /* 0x01 */

@@ -68583,7 +69086,7 @@ static int invokeValueDestructor(

   if( pCtx ) sqlite3_result_error_toobig(pCtx);
   return SQLITE_TOOBIG;
 }
 SQLITE_API void sqlite3_result_blob(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_blob(
   sqlite3_context *pCtx,
   const void *z,
   int n,

@@ -68593,7 +69096,7 @@ SQLITE_API void sqlite3_result_blob(

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, 0, xDel);
 }
 SQLITE_API void sqlite3_result_blob64(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64(
   sqlite3_context *pCtx,
   const void *z,
   sqlite3_uint64 n,

@@ -68607,37 +69110,37 @@ SQLITE_API void sqlite3_result_blob64(

     setResultStrOrError(pCtx, z, (int)n, 0, xDel);
   }
 }
 SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context *pCtx, double rVal){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
 }
 SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   pCtx->isError = SQLITE_ERROR;
   pCtx->fErrorOrAux = 1;
   sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   pCtx->isError = SQLITE_ERROR;
   pCtx->fErrorOrAux = 1;
   sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
 }
 #endif
 SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context *pCtx, int iVal){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
 }
 SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
 }
 SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context *pCtx){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetNull(pCtx->pOut);
 }
 SQLITE_API void sqlite3_result_text(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text(
   sqlite3_context *pCtx,
   const char *z,
   int n,

@@ -68646,7 +69149,7 @@ SQLITE_API void sqlite3_result_text(

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
 }
 SQLITE_API void sqlite3_result_text64(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(
   sqlite3_context *pCtx,
   const char *z,
   sqlite3_uint64 n,

@@ -68663,7 +69166,7 @@ SQLITE_API void sqlite3_result_text64(

   }
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API void sqlite3_result_text16(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(
   sqlite3_context *pCtx,
   const void *z,
   int n,

@@ -68672,7 +69175,7 @@ SQLITE_API void sqlite3_result_text16(

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
 }
 SQLITE_API void sqlite3_result_text16be(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(
   sqlite3_context *pCtx,
   const void *z,
   int n,

@@ -68681,7 +69184,7 @@ SQLITE_API void sqlite3_result_text16be(

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
 }
 SQLITE_API void sqlite3_result_text16le(
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(
   sqlite3_context *pCtx,
   const void *z,
   int n,

@@ -68691,17 +69194,20 @@ SQLITE_API void sqlite3_result_text16le(

   setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
 }
 #endif /* SQLITE_OMIT_UTF16 */
 SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemCopy(pCtx->pOut, pValue);
 }
 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
 }
 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
   pCtx->isError = errCode;
   pCtx->fErrorOrAux = 1;
 #ifdef SQLITE_DEBUG
   if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
 #endif
   if( pCtx->pOut->flags & MEM_Null ){
     sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,
                          SQLITE_UTF8, SQLITE_STATIC);

@@ -68709,7 +69215,7 @@ SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){

 }
 /* Force an SQLITE_TOOBIG error. */
 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context *pCtx){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   pCtx->isError = SQLITE_TOOBIG;
   pCtx->fErrorOrAux = 1;

@@ -68718,7 +69224,7 @@ SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){

 }
 /* An SQLITE_NOMEM error. */
 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context *pCtx){
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   sqlite3VdbeMemSetNull(pCtx->pOut);
   pCtx->isError = SQLITE_NOMEM;

@@ -68782,7 +69288,7 @@ static int sqlite3Step(Vdbe *p){

     ** or SQLITE_BUSY error.
     */
 #ifdef SQLITE_OMIT_AUTORESET
     if( p->rc==SQLITE_BUSY || p->rc==SQLITE_LOCKED ){
     if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
       sqlite3_reset((sqlite3_stmt*)p);
     }else{
       return SQLITE_MISUSE_BKPT;

@@ -68828,6 +69334,9 @@ static int sqlite3Step(Vdbe *p){

     if( p->bIsReader ) db->nVdbeRead++;
     p->pc = 0;
   }
 #ifdef SQLITE_DEBUG
   p->rcApp = SQLITE_OK;
 #endif
 #ifndef SQLITE_OMIT_EXPLAIN
   if( p->explain ){
     rc = sqlite3VdbeList(p);

@@ -68872,7 +69381,7 @@ end_of_step:

   assert( rc==SQLITE_ROW  || rc==SQLITE_DONE   || rc==SQLITE_ERROR
        || rc==SQLITE_BUSY || rc==SQLITE_MISUSE
   );
   assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );
   assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp );
   if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
     /* If this statement was prepared using sqlite3_prepare_v2(), and an
     ** error has occurred, then return the error code in p->rc to the

@@ -68888,7 +69397,7 @@ end_of_step:

 ** sqlite3Step() to do most of the work.  If a schema error occurs,
 ** call sqlite3Reprepare() and try again.
 */
 SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_step(sqlite3_stmt *pStmt){
   int rc = SQLITE_OK;      /* Result from sqlite3Step() */
   int rc2 = SQLITE_OK;     /* Result from sqlite3Reprepare() */
   Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */

@@ -68939,7 +69448,7 @@ SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){

 ** Extract the user data from a sqlite3_context structure and return a
 ** pointer to it.
 */
 SQLITE_API void *sqlite3_user_data(sqlite3_context *p){
 SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context *p){
   assert( p && p->pFunc );
   return p->pFunc->pUserData;
 }

@@ -68954,22 +69463,32 @@ SQLITE_API void *sqlite3_user_data(sqlite3_context *p){

 ** sqlite3_create_function16() routines that originally registered the
 ** application defined function.
 */
 SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context *p){
   assert( p && p->pFunc );
   return p->pOut->db;
 }
 /*
 ** Return the current time for a statement
 ** Return the current time for a statement.  If the current time
 ** is requested more than once within the same run of a single prepared
 ** statement, the exact same time is returned for each invocation regardless
 ** of the amount of time that elapses between invocations.  In other words,
 ** the time returned is always the time of the first call.
 */
 SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){
   Vdbe *v = p->pVdbe;
   int rc;
   if( v->iCurrentTime==0 ){
     rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, &v->iCurrentTime);
     if( rc ) v->iCurrentTime = 0;
 #ifndef SQLITE_ENABLE_STAT3_OR_STAT4
   sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
   assert( p->pVdbe!=0 );
 #else
   sqlite3_int64 iTime = 0;
   sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime;
 #endif
   if( *piTime==0 ){
     rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
     if( rc ) *piTime = 0;
   }
   return v->iCurrentTime;
   return *piTime;
 }
 /*

@@ -69020,7 +69539,7 @@ static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){

 ** context is allocated on the first call.  Subsequent calls return the
 ** same context that was returned on prior calls.
 */
 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
 SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context *p, int nByte){
   assert( p && p->pFunc && p->pFunc->xStep );
   assert( sqlite3_mutex_held(p->pOut->db->mutex) );
   testcase( nByte<0 );

@@ -69035,10 +69554,15 @@ SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){

 ** Return the auxiliary data pointer, if any, for the iArg'th argument to
 ** the user-function defined by pCtx.
 */
 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
 SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
   AuxData *pAuxData;
   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
 #if SQLITE_ENABLE_STAT3_OR_STAT4
   if( pCtx->pVdbe==0 ) return 0;
 #else
   assert( pCtx->pVdbe!=0 );
 #endif
   for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
     if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
   }

@@ -69051,7 +69575,7 @@ SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){

 ** argument to the user-function defined by pCtx. Any previous value is
 ** deleted by calling the delete function specified when it was set.
 */
 SQLITE_API void sqlite3_set_auxdata(
 SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata(
   sqlite3_context *pCtx,
   int iArg,
   void *pAux,

@@ -69062,6 +69586,11 @@ SQLITE_API void sqlite3_set_auxdata(

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
   if( iArg<0 ) goto failed;
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   if( pVdbe==0 ) goto failed;
 #else
   assert( pVdbe!=0 );
 #endif
   for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
     if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;

@@ -69101,7 +69630,7 @@ failed:

 ** implementations should keep their own counts within their aggregate
 ** context.
 */
 SQLITE_API int sqlite3_aggregate_count(sqlite3_context *p){
 SQLITE_API int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context *p){
   assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
   return p->pMem->n;
 }

@@ -69110,7 +69639,7 @@ SQLITE_API int sqlite3_aggregate_count(sqlite3_context *p){

 /*
 ** Return the number of columns in the result set for the statement pStmt.
 */
 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt){
   Vdbe *pVm = (Vdbe *)pStmt;
   return pVm ? pVm->nResColumn : 0;
 }

@@ -69119,7 +69648,7 @@ SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){

 ** Return the number of values available from the current row of the
 ** currently executing statement pStmt.
 */
 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt){
   Vdbe *pVm = (Vdbe *)pStmt;
   if( pVm==0 || pVm->pResultSet==0 ) return 0;
   return pVm->nResColumn;

@@ -69221,7 +69750,7 @@ static void columnMallocFailure(sqlite3_stmt *pStmt)

 ** The following routines are used to access elements of the current row
 ** in the result set.
 */
 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
   const void *val;
   val = sqlite3_value_blob( columnMem(pStmt,i) );
   /* Even though there is no encoding conversion, value_blob() might

@@ -69231,37 +69760,37 @@ SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){

   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
   int val = sqlite3_value_bytes( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
 SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt *pStmt, int i){
   double val = sqlite3_value_double( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
 SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt *pStmt, int i){
   int val = sqlite3_value_int( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
 SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt *pStmt, int i){
   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
 SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt *pStmt, int i){
   Mem *pOut = columnMem(pStmt, i);
   if( pOut->flags&MEM_Static ){
     pOut->flags &= ~MEM_Static;

@@ -69271,13 +69800,13 @@ SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){

   return (sqlite3_value *)pOut;
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return val;
 }
 #endif /* SQLITE_OMIT_UTF16 */
 SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
 SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt *pStmt, int i){
   int iType = sqlite3_value_type( columnMem(pStmt,i) );
   columnMallocFailure(pStmt);
   return iType;

@@ -69341,12 +69870,12 @@ static const void *columnName(

 ** Return the name of the Nth column of the result set returned by SQL
 ** statement pStmt.
 */
 SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
 }

@@ -69366,12 +69895,12 @@ SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){

 ** Return the column declaration type (if applicable) of the 'i'th column
 ** of the result set of SQL statement pStmt.
 */
 SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
 }

@@ -69384,12 +69913,12 @@ SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){

 ** NULL is returned if the result column is an expression or constant or
 ** anything else which is not an unambiguous reference to a database column.
 */
 SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
 }

@@ -69400,12 +69929,12 @@ SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N

 ** NULL is returned if the result column is an expression or constant or
 ** anything else which is not an unambiguous reference to a database column.
 */
 SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
 }

@@ -69416,12 +69945,12 @@ SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){

 ** NULL is returned if the result column is an expression or constant or
 ** anything else which is not an unambiguous reference to a database column.
 */
 SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
   return columnName(
       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
 }

@@ -69522,7 +70051,7 @@ static int bindText(

 /*
 ** Bind a blob value to an SQL statement variable.
 */
 SQLITE_API int sqlite3_bind_blob(
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob(
   sqlite3_stmt *pStmt,
   int i,
   const void *zData,

@@ -69531,7 +70060,7 @@ SQLITE_API int sqlite3_bind_blob(

 ){
   return bindText(pStmt, i, zData, nData, xDel, 0);
 }
 SQLITE_API int sqlite3_bind_blob64(
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64(
   sqlite3_stmt *pStmt,
   int i,
   const void *zData,

@@ -69545,7 +70074,7 @@ SQLITE_API int sqlite3_bind_blob64(

     return bindText(pStmt, i, zData, (int)nData, xDel, 0);
   }
 }
 SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
   int rc;
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);

@@ -69555,10 +70084,10 @@ SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){

   }
   return rc;
 }
 SQLITE_API int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
   return sqlite3_bind_int64(p, i, (i64)iValue);
 }
 SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
   int rc;
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);

@@ -69568,7 +70097,7 @@ SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValu

   }
   return rc;
 }
 SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
   int rc;
   Vdbe *p = (Vdbe*)pStmt;
   rc = vdbeUnbind(p, i);

@@ -69577,7 +70106,7 @@ SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){

   }
   return rc;
 }
 SQLITE_API int sqlite3_bind_text(
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(
   sqlite3_stmt *pStmt,
   int i,
   const char *zData,

@@ -69586,7 +70115,7 @@ SQLITE_API int sqlite3_bind_text(

 ){
   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
 }
 SQLITE_API int sqlite3_bind_text64(
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(
   sqlite3_stmt *pStmt,
   int i,
   const char *zData,

@@ -69603,7 +70132,7 @@ SQLITE_API int sqlite3_bind_text64(

   }
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API int sqlite3_bind_text16(
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(
   sqlite3_stmt *pStmt,
   int i,
   const void *zData,

@@ -69613,7 +70142,7 @@ SQLITE_API int sqlite3_bind_text16(

   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
 }
 #endif /* SQLITE_OMIT_UTF16 */
 SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
   int rc;
   switch( sqlite3_value_type((sqlite3_value*)pValue) ){
     case SQLITE_INTEGER: {

@@ -69644,7 +70173,7 @@ SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_valu

   }
   return rc;
 }
 SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
   int rc;
   Vdbe *p = (Vdbe *)pStmt;
   rc = vdbeUnbind(p, i);

@@ -69659,7 +70188,7 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){

 ** Return the number of wildcards that can be potentially bound to.
 ** This routine is added to support DBD::SQLite.
 */
 SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
   Vdbe *p = (Vdbe*)pStmt;
   return p ? p->nVar : 0;
 }

@@ -69670,7 +70199,7 @@ SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){

 **
 ** The result is always UTF-8.
 */
 SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
   Vdbe *p = (Vdbe*)pStmt;
   if( p==0 || i<1 || i>p->nzVar ){
     return 0;

@@ -69698,7 +70227,7 @@ SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nNa

   }
   return 0;
 }
 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
   return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
 }

@@ -69732,7 +70261,7 @@ SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt

 ** an SQLITE_ERROR is returned.  Nothing else can go wrong, so otherwise
 ** SQLITE_OK is returned.
 */
 SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
   Vdbe *pFrom = (Vdbe*)pFromStmt;
   Vdbe *pTo = (Vdbe*)pToStmt;
   if( pFrom->nVar!=pTo->nVar ){

@@ -69754,7 +70283,7 @@ SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *

 ** the first argument to the sqlite3_prepare() that was used to create
 ** the statement in the first place.
 */
 SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt *pStmt){
   return pStmt ? ((Vdbe*)pStmt)->db : 0;
 }

@@ -69762,14 +70291,14 @@ SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){

 ** Return true if the prepared statement is guaranteed to not modify the
 ** database.
 */
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
   return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
 }
 /*
 ** Return true if the prepared statement is in need of being reset.
 */
 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt *pStmt){
   Vdbe *v = (Vdbe*)pStmt;
   return v!=0 && v->pc>=0 && v->magic==VDBE_MAGIC_RUN;
 }

@@ -69780,7 +70309,7 @@ SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){

 ** prepared statement for the database connection.  Return NULL if there
 ** are no more.
 */
 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
 SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
   sqlite3_stmt *pNext;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(pDb) ){

@@ -69801,7 +70330,7 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){

 /*
 ** Return the value of a status counter for a prepared statement
 */
 SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
   Vdbe *pVdbe = (Vdbe*)pStmt;
   u32 v;
 #ifdef SQLITE_ENABLE_API_ARMOR

@@ -69819,7 +70348,7 @@ SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){

 /*
 ** Return status data for a single loop within query pStmt.
 */
 SQLITE_API int sqlite3_stmt_scanstatus(
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_scanstatus(
   sqlite3_stmt *pStmt,            /* Prepared statement being queried */
   int idx,                        /* Index of loop to report on */
   int iScanStatusOp,              /* Which metric to return */

@@ -69878,7 +70407,7 @@ SQLITE_API int sqlite3_stmt_scanstatus(

 /*
 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
 */
 SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
 SQLITE_API void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
   Vdbe *p = (Vdbe*)pStmt;
   memset(p->anExec, 0, p->nOp * sizeof(i64));
 }

@@ -70377,7 +70906,7 @@ static void applyAffinity(

 ** is appropriate.  But only do the conversion if it is possible without
 ** loss of information and return the revised type of the argument.
 */
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
 SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value *pVal){
   int eType = sqlite3_value_type(pVal);
   if( eType==SQLITE_TEXT ){
     Mem *pMem = (Mem*)pVal;

@@ -71176,7 +71705,7 @@ case OP_Real: { /* same as TK_FLOAT, out2-prerelease */

 ** Synopsis: r[P2]='P4'
 **
 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
 ** into a String before it is executed for the first time.  During
 ** into a String opcode before it is executed for the first time.  During
 ** this transformation, the length of string P4 is computed and stored
 ** as the P1 parameter.
 */

@@ -71208,10 +71737,15 @@ case OP_String8: { /* same as TK_STRING, out2-prerelease */

   /* Fall through to the next case, OP_String */
 }
 /* Opcode: String P1 P2 * P4 *
 /* Opcode: String P1 P2 P3 P4 P5
 ** Synopsis: r[P2]='P4' (len=P1)
 **
 ** The string value P4 of length P1 (bytes) is stored in register P2.
 **
 ** If P5!=0 and the content of register P3 is greater than zero, then
 ** the datatype of the register P2 is converted to BLOB.  The content is
 ** the same sequence of bytes, it is merely interpreted as a BLOB instead
 ** of a string, as if it had been CAST.
 */
 case OP_String: {          /* out2-prerelease */
   assert( pOp->p4.z!=0 );

@@ -71220,6 +71754,13 @@ case OP_String: { /* out2-prerelease */

   pOut->n = pOp->p1;
   pOut->enc = encoding;
   UPDATE_MAX_BLOBSIZE(pOut);
   if( pOp->p5 ){
     assert( pOp->p3>0 );
     assert( pOp->p3<=(p->nMem-p->nCursor) );
     pIn3 = &aMem[pOp->p3];
     assert( pIn3->flags & MEM_Int );
     if( pIn3->u.i ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
   }
   break;
 }

@@ -71666,7 +72207,7 @@ arithmetic_result_is_null:

 **
 ** The interface used by the implementation of the aforementioned functions
 ** to retrieve the collation sequence set by this opcode is not available
 ** publicly, only to user functions defined in func.c.
 ** publicly.  Only built-in functions have access to this feature.
 */
 case OP_CollSeq: {
   assert( pOp->p4type==P4_COLLSEQ );

@@ -72069,11 +72610,15 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */

         testcase( pIn1->flags & MEM_Int );
         testcase( pIn1->flags & MEM_Real );
         sqlite3VdbeMemStringify(pIn1, encoding, 1);
         testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
         flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
       }
       if( (pIn3->flags & MEM_Str)==0 && (pIn3->flags & (MEM_Int|MEM_Real))!=0 ){
         testcase( pIn3->flags & MEM_Int );
         testcase( pIn3->flags & MEM_Real );
         sqlite3VdbeMemStringify(pIn3, encoding, 1);
         testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
         flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
       }
     }
     assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );

@@ -72110,7 +72655,9 @@ case OP_Ge: { /* same as TK_GE, jump, in1, in3 */

     }
   }
   /* Undo any changes made by applyAffinity() to the input registers. */
   assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
   pIn1->flags = flags1;
   assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
   pIn3->flags = flags3;
   break;
 }

@@ -73211,7 +73758,12 @@ case OP_Transaction: {

       p->nStmtDefImmCons = db->nDeferredImmCons;
     }
     /* Gather the schema version number for checking */
     /* Gather the schema version number for checking:
     ** IMPLEMENTATION-OF: R-32195-19465 The schema version is used by SQLite
     ** each time a query is executed to ensure that the internal cache of the
     ** schema used when compiling the SQL query matches the schema of the
     ** database against which the compiled query is actually executed.
     */
     sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
     iGen = db->aDb[pOp->p1].pSchema->iGeneration;
   }else{

@@ -73379,31 +73931,29 @@ case OP_SetCookie: { /* in3 */

 ** See also OpenRead.
 */
 case OP_ReopenIdx: {
   int nField;
   KeyInfo *pKeyInfo;
   int p2;
   int iDb;
   int wrFlag;
   Btree *pX;
   VdbeCursor *pCur;
   Db *pDb;
   assert( pOp->p5==0 );
   assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
   assert( pOp->p4type==P4_KEYINFO );
   pCur = p->apCsr[pOp->p1];
   if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
     assert( pCur->iDb==pOp->p3 );      /* Guaranteed by the code generator */
     break;
     goto open_cursor_set_hints;
   }
   /* If the cursor is not currently open or is open on a different
   ** index, then fall through into OP_OpenRead to force a reopen */
 }
 case OP_OpenRead:
 case OP_OpenWrite: {
   int nField;
   KeyInfo *pKeyInfo;
   int p2;
   int iDb;
   int wrFlag;
   Btree *pX;
   VdbeCursor *pCur;
   Db *pDb;
 case OP_OpenWrite:
   assert( (pOp->p5&(OPFLAG_P2ISREG|OPFLAG_BULKCSR))==pOp->p5 );
   assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 );
   assert( (pOp->p5&(OPFLAG_P2ISREG|OPFLAG_BULKCSR|OPFLAG_SEEKEQ))==pOp->p5 );
   assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
   assert( p->bIsReader );
   assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
           || p->readOnly==0 );

@@ -73466,14 +74016,17 @@ case OP_OpenWrite: {

   pCur->pgnoRoot = p2;
   rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->pCursor);
   pCur->pKeyInfo = pKeyInfo;
   assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
   sqlite3BtreeCursorHints(pCur->pCursor, (pOp->p5 & OPFLAG_BULKCSR));
   /* Set the VdbeCursor.isTable variable. Previous versions of
   ** SQLite used to check if the root-page flags were sane at this point
   ** and report database corruption if they were not, but this check has
   ** since moved into the btree layer.  */
   pCur->isTable = pOp->p4type!=P4_KEYINFO;
 open_cursor_set_hints:
   assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
   assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
   sqlite3BtreeCursorHints(pCur->pCursor,
                           (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
   break;
 }

@@ -73734,6 +74287,22 @@ case OP_SeekGT: { /* jump, in3 */

 #ifdef SQLITE_DEBUG
   pC->seekOp = pOp->opcode;
 #endif
   /* For a cursor with the BTREE_SEEK_EQ hint, only the OP_SeekGE and
   ** OP_SeekLE opcodes are allowed, and these must be immediately followed
   ** by an OP_IdxGT or OP_IdxLT opcode, respectively, with the same key.
   */
 #ifdef SQLITE_DEBUG
   if( sqlite3BtreeCursorHasHint(pC->pCursor, BTREE_SEEK_EQ) ){
     assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
     assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
     assert( pOp[1].p1==pOp[0].p1 );
     assert( pOp[1].p2==pOp[0].p2 );
     assert( pOp[1].p3==pOp[0].p3 );
     assert( pOp[1].p4.i==pOp[0].p4.i );
   }
 #endif
   if( pC->isTable ){
     /* The input value in P3 might be of any type: integer, real, string,
     ** blob, or NULL.  But it needs to be an integer before we can do

@@ -75073,30 +75642,15 @@ case OP_IdxGE: { /* jump */

 */
 case OP_Destroy: {     /* out2-prerelease */
   int iMoved;
   int iCnt;
   Vdbe *pVdbe;
   int iDb;
   assert( p->readOnly==0 );
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   iCnt = 0;
   for(pVdbe=db->pVdbe; pVdbe; pVdbe = pVdbe->pNext){
     if( pVdbe->magic==VDBE_MAGIC_RUN && pVdbe->bIsReader
      && pVdbe->inVtabMethod<2 && pVdbe->pc>=0
     ){
       iCnt++;
     }
   }
 #else
   iCnt = db->nVdbeRead;
 #endif
   pOut->flags = MEM_Null;
   if( iCnt>1 ){
   if( db->nVdbeRead > db->nVDestroy+1 ){
     rc = SQLITE_LOCKED;
     p->errorAction = OE_Abort;
   }else{
     iDb = pOp->p3;
     assert( iCnt==1 );
     assert( DbMaskTest(p->btreeMask, iDb) );
     iMoved = 0;  /* Not needed.  Only to silence a warning. */
     rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);

@@ -75729,10 +76283,12 @@ case OP_MemMax: { /* in2 */

 /* Opcode: IfPos P1 P2 * * *
 ** Synopsis: if r[P1]>0 goto P2
 **
 ** If the value of register P1 is 1 or greater, jump to P2.
 ** Register P1 must contain an integer.
 ** If the value of register P1 is 1 or greater, jump to P2 and
 ** add the literal value P3 to register P1.
 **
 ** It is illegal to use this instruction on a register that does
 ** not contain an integer.  An assertion fault will result if you try.
 ** If the initial value of register P1 is less than 1, then the
 ** value is unchanged and control passes through to the next instruction.
 */
 case OP_IfPos: {        /* jump, in1 */
   pIn1 = &aMem[pOp->p1];

@@ -75761,16 +76317,34 @@ case OP_IfNeg: { /* jump, in1 */

   break;
 }
 /* Opcode: IfZero P1 P2 P3 * *
 ** Synopsis: r[P1]+=P3, if r[P1]==0 goto P2
 /* Opcode: IfNotZero P1 P2 P3 * *
 ** Synopsis: if r[P1]!=0 then r[P1]+=P3, goto P2
 **
 ** The register P1 must contain an integer.  Add literal P3 to the
 ** value in register P1.  If the result is exactly 0, jump to P2.
 ** Register P1 must contain an integer.  If the content of register P1 is
 ** initially nonzero, then add P3 to P1 and jump to P2.  If register P1 is
 ** initially zero, leave it unchanged and fall through.
 */
 case OP_IfZero: {        /* jump, in1 */
 case OP_IfNotZero: {        /* jump, in1 */
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags&MEM_Int );
   pIn1->u.i += pOp->p3;
   VdbeBranchTaken(pIn1->u.i<0, 2);
   if( pIn1->u.i ){
      pIn1->u.i += pOp->p3;
      pc = pOp->p2 - 1;
   }
   break;
 }
 /* Opcode: DecrJumpZero P1 P2 * * *
 ** Synopsis: if (--r[P1])==0 goto P2
 **
 ** Register P1 must hold an integer.  Decrement the value in register P1
 ** then jump to P2 if the new value is exactly zero.
 */
 case OP_DecrJumpZero: {      /* jump, in1 */
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags&MEM_Int );
   pIn1->u.i--;
   VdbeBranchTaken(pIn1->u.i==0, 2);
   if( pIn1->u.i==0 ){
      pc = pOp->p2 - 1;

@@ -75778,6 +76352,24 @@ case OP_IfZero: { /* jump, in1 */

   break;
 }
 /* Opcode: JumpZeroIncr P1 P2 * * *
 ** Synopsis: if (r[P1]++)==0 ) goto P2
 **
 ** The register P1 must contain an integer.  If register P1 is initially
 ** zero, then jump to P2.  Increment register P1 regardless of whether or
 ** not the jump is taken.
 */
 case OP_JumpZeroIncr: {        /* jump, in1 */
   pIn1 = &aMem[pOp->p1];
   assert( pIn1->flags&MEM_Int );
   VdbeBranchTaken(pIn1->u.i==0, 2);
   if( (pIn1->u.i++)==0 ){
      pc = pOp->p2 - 1;
   }
   break;
 }
 /* Opcode: AggStep * P2 P3 P4 P5
 ** Synopsis: accum=r[P3] step(r[P2@P5])
 **

@@ -76115,13 +76707,29 @@ case OP_VBegin: {

 #endif /* SQLITE_OMIT_VIRTUALTABLE */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /* Opcode: VCreate P1 * * P4 *
 /* Opcode: VCreate P1 P2 * * *
 **
 ** P4 is the name of a virtual table in database P1. Call the xCreate method
 ** for that table.
 ** P2 is a register that holds the name of a virtual table in database
 ** P1. Call the xCreate method for that table.
 */
 case OP_VCreate: {
   rc = sqlite3VtabCallCreate(db, pOp->p1, pOp->p4.z, &p->zErrMsg);
   Mem sMem;          /* For storing the record being decoded */
   const char *zTab;  /* Name of the virtual table */
   memset(&sMem, 0, sizeof(sMem));
   sMem.db = db;
   /* Because P2 is always a static string, it is impossible for the
   ** sqlite3VdbeMemCopy() to fail */
   assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
   assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
   rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
   assert( rc==SQLITE_OK );
   zTab = (const char*)sqlite3_value_text(&sMem);
   assert( zTab || db->mallocFailed );
   if( zTab ){
     rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
   }
   sqlite3VdbeMemRelease(&sMem);
   break;
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */

@@ -76133,9 +76741,9 @@ case OP_VCreate: {

 ** of that table.
 */
 case OP_VDestroy: {
   p->inVtabMethod = 2;
   db->nVDestroy++;
   rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
   p->inVtabMethod = 0;
   db->nVDestroy--;
   break;
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */

@@ -76151,14 +76759,17 @@ case OP_VOpen: {

   VdbeCursor *pCur;
   sqlite3_vtab_cursor *pVtabCursor;
   sqlite3_vtab *pVtab;
   sqlite3_module *pModule;
   const sqlite3_module *pModule;
   assert( p->bIsReader );
   pCur = 0;
   pVtabCursor = 0;
   pVtab = pOp->p4.pVtab->pVtab;
   pModule = (sqlite3_module *)pVtab->pModule;
   assert(pVtab && pModule);
   if( pVtab==0 || NEVER(pVtab->pModule==0) ){
     rc = SQLITE_LOCKED;
     break;
   }
   pModule = pVtab->pModule;
   rc = pModule->xOpen(pVtab, &pVtabCursor);
   sqlite3VtabImportErrmsg(p, pVtab);
   if( SQLITE_OK==rc ){

@@ -76169,6 +76780,7 @@ case OP_VOpen: {

     pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
     if( pCur ){
       pCur->pVtabCursor = pVtabCursor;
       pVtab->nRef++;
     }else{
       db->mallocFailed = 1;
       pModule->xClose(pVtabCursor);

@@ -76234,9 +76846,7 @@ case OP_VFilter: { /* jump */

       apArg[i] = &pArgc[i+1];
     }
     p->inVtabMethod = 1;
     rc = pModule->xFilter(pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
     p->inVtabMethod = 0;
     sqlite3VtabImportErrmsg(p, pVtab);
     if( rc==SQLITE_OK ){
       res = pModule->xEof(pVtabCursor);

@@ -76326,9 +76936,7 @@ case OP_VNext: { /* jump */

   ** data is available) and the error code returned when xColumn or
   ** some other method is next invoked on the save virtual table cursor.
   */
   p->inVtabMethod = 1;
   rc = pModule->xNext(pCur->pVtabCursor);
   p->inVtabMethod = 0;
   sqlite3VtabImportErrmsg(p, pVtab);
   if( rc==SQLITE_OK ){
     res = pModule->xEof(pCur->pVtabCursor);

@@ -76403,7 +77011,7 @@ case OP_VRename: {

 */
 case OP_VUpdate: {
   sqlite3_vtab *pVtab;
   sqlite3_module *pModule;
   const sqlite3_module *pModule;
   int nArg;
   int i;
   sqlite_int64 rowid;

@@ -76415,7 +77023,11 @@ case OP_VUpdate: {

   );
   assert( p->readOnly==0 );
   pVtab = pOp->p4.pVtab->pVtab;
   pModule = (sqlite3_module *)pVtab->pModule;
   if( pVtab==0 || NEVER(pVtab->pModule==0) ){
     rc = SQLITE_LOCKED;
     break;
   }
   pModule = pVtab->pModule;
   nArg = pOp->p2;
   assert( pOp->p4type==P4_VTAB );
   if( ALWAYS(pModule->xUpdate) ){

@@ -76762,7 +77374,7 @@ static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){

 /*
 ** Open a blob handle.
 */
 SQLITE_API int sqlite3_blob_open(
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_open(
   sqlite3* db,            /* The database connection */
   const char *zDb,        /* The attached database containing the blob */
   const char *zTable,     /* The table containing the blob */

@@ -76812,12 +77424,17 @@ SQLITE_API int sqlite3_blob_open(

   Incrblob *pBlob = 0;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || ppBlob==0 || zTable==0 ){
   if( ppBlob==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   flags = !!flags;                /* flags = (flags ? 1 : 0); */
   *ppBlob = 0;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zTable==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   flags = !!flags;                /* flags = (flags ? 1 : 0); */
   sqlite3_mutex_enter(db->mutex);

@@ -76994,7 +77611,7 @@ blob_open_out:

 ** Close a blob handle that was previously created using
 ** sqlite3_blob_open().
 */
 SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *pBlob){
   Incrblob *p = (Incrblob *)pBlob;
   int rc;
   sqlite3 *db;

@@ -77031,7 +77648,7 @@ static int blobReadWrite(

   sqlite3_mutex_enter(db->mutex);
   v = (Vdbe*)p->pStmt;
   if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
   if( n<0 || iOffset<0 || ((sqlite3_int64)iOffset+n)>p->nByte ){
     /* Request is out of range. Return a transient error. */
     rc = SQLITE_ERROR;
   }else if( v==0 ){

@@ -77063,14 +77680,14 @@ static int blobReadWrite(

 /*
 ** Read data from a blob handle.
 */
 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
   return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
 }
 /*
 ** Write data to a blob handle.
 */
 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
   return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
 }

@@ -77080,7 +77697,7 @@ SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int

 ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
 ** so no mutex is required for access.
 */
 SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *pBlob){
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *pBlob){
   Incrblob *p = (Incrblob *)pBlob;
   return (p && p->pStmt) ? p->nByte : 0;
 }

@@ -77095,7 +77712,7 @@ SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *pBlob){

 ** subsequent calls to sqlite3_blob_xxx() functions (except blob_close())
 ** immediately return SQLITE_ABORT.
 */
 SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
   int rc;
   Incrblob *p = (Incrblob *)pBlob;
   sqlite3 *db;

@@ -78280,6 +78897,7 @@ static int vdbeSorterOpenTempFile(

   sqlite3_file **ppFd
 ){
   int rc;
   if( sqlite3FaultSim(202) ) return SQLITE_IOERR_ACCESS;
   rc = sqlite3OsOpenMalloc(db->pVfs, 0, ppFd,
       SQLITE_OPEN_TEMP_JOURNAL |
       SQLITE_OPEN_READWRITE    | SQLITE_OPEN_CREATE |

@@ -80575,9 +81193,10 @@ static int lookupName(

     testcase( pNC->ncFlags & NC_PartIdx );
     testcase( pNC->ncFlags & NC_IsCheck );
     if( (pNC->ncFlags & (NC_PartIdx|NC_IsCheck))!=0 ){
       /* Silently ignore database qualifiers inside CHECK constraints and partial
       ** indices.  Do not raise errors because that might break legacy and
       ** because it does not hurt anything to just ignore the database name. */
       /* Silently ignore database qualifiers inside CHECK constraints and
       ** partial indices.  Do not raise errors because that might break
       ** legacy and because it does not hurt anything to just ignore the
       ** database name. */
       zDb = 0;
     }else{
       for(i=0; i<db->nDb; i++){

@@ -80648,7 +81267,8 @@ static int lookupName(

       if( pMatch ){
         pExpr->iTable = pMatch->iCursor;
         pExpr->pTab = pMatch->pTab;
         assert( (pMatch->jointype & JT_RIGHT)==0 ); /* RIGHT JOIN not (yet) supported */
         /* RIGHT JOIN not (yet) supported */
         assert( (pMatch->jointype & JT_RIGHT)==0 );
         if( (pMatch->jointype & JT_LEFT)!=0 ){
           ExprSetProperty(pExpr, EP_CanBeNull);
         }

@@ -80969,7 +81589,8 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){

       pExpr->affinity = SQLITE_AFF_INTEGER;
       break;
     }
 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
 #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT)
           && !defined(SQLITE_OMIT_SUBQUERY) */
     /* A lone identifier is the name of a column.
     */

@@ -81034,19 +81655,20 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){

           if( n==2 ){
             pExpr->iTable = exprProbability(pList->a[1].pExpr);
             if( pExpr->iTable<0 ){
               sqlite3ErrorMsg(pParse, "second argument to likelihood() must be a "
                                       "constant between 0.0 and 1.0");
               sqlite3ErrorMsg(pParse,
                 "second argument to likelihood() must be a "
                 "constant between 0.0 and 1.0");
               pNC->nErr++;
             }
           }else{
             /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is equivalent to
             ** likelihood(X, 0.0625).
             ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is short-hand for
             ** likelihood(X,0.0625).
             ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand for
             ** likelihood(X,0.9375).
             ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent to
             ** likelihood(X,0.9375). */
             /* EVIDENCE-OF: R-61304-29449 The unlikely(X) function is
             ** equivalent to likelihood(X, 0.0625).
             ** EVIDENCE-OF: R-01283-11636 The unlikely(X) function is
             ** short-hand for likelihood(X,0.0625).
             ** EVIDENCE-OF: R-36850-34127 The likely(X) function is short-hand
             ** for likelihood(X,0.9375).
             ** EVIDENCE-OF: R-53436-40973 The likely(X) function is equivalent
             ** to likelihood(X,0.9375). */
             /* TUNING: unlikely() probability is 0.0625.  likely() is 0.9375 */
             pExpr->iTable = pDef->zName[0]=='u' ? 8388608 : 125829120;
           }

@@ -81063,7 +81685,9 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){

           return WRC_Prune;
         }
 #endif
         if( pDef->funcFlags & SQLITE_FUNC_CONSTANT ) ExprSetProperty(pExpr,EP_Constant);
         if( pDef->funcFlags & SQLITE_FUNC_CONSTANT ){
           ExprSetProperty(pExpr,EP_ConstFunc);
         }
       }
       if( is_agg && (pNC->ncFlags & NC_AllowAgg)==0 ){
         sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);

@@ -81374,7 +81998,8 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(

         resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
         return 1;
       }
       resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, zType,0);
       resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,
                    zType,0);
     }
   }
   return 0;

@@ -81507,6 +82132,20 @@ static int resolveSelectStep(Walker *pWalker, Select *p){

         sqlite3ResolveExprNames(&sNC, p->pOffset) ){
       return WRC_Abort;
     }
     /* If the SF_Converted flags is set, then this Select object was
     ** was created by the convertCompoundSelectToSubquery() function.
     ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
     ** as if it were part of the sub-query, not the parent. This block
     ** moves the pOrderBy down to the sub-query. It will be moved back
     ** after the names have been resolved.  */
     if( p->selFlags & SF_Converted ){
       Select *pSub = p->pSrc->a[0].pSelect;
       assert( p->pSrc->nSrc==1 && isCompound==0 && p->pOrderBy );
       assert( pSub->pPrior && pSub->pOrderBy==0 );
       pSub->pOrderBy = p->pOrderBy;
       p->pOrderBy = 0;
     }
     /* Recursively resolve names in all subqueries
     */

@@ -81589,6 +82228,17 @@ static int resolveSelectStep(Walker *pWalker, Select *p){

     sNC.pNext = 0;
     sNC.ncFlags |= NC_AllowAgg;
     /* If this is a converted compound query, move the ORDER BY clause from
     ** the sub-query back to the parent query. At this point each term
     ** within the ORDER BY clause has been transformed to an integer value.
     ** These integers will be replaced by copies of the corresponding result
     ** set expressions by the call to resolveOrderGroupBy() below.  */
     if( p->selFlags & SF_Converted ){
       Select *pSub = p->pSrc->a[0].pSelect;
       p->pOrderBy = pSub->pOrderBy;
       pSub->pOrderBy = 0;
     }
     /* Process the ORDER BY clause for singleton SELECT statements.
     ** The ORDER BY clause for compounds SELECT statements is handled
     ** below, after all of the result-sets for all of the elements of

@@ -81864,10 +82514,11 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){

 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(
   Parse *pParse,           /* Parsing context */
   Expr *pExpr,             /* Add the "COLLATE" clause to this expression */
   const Token *pCollName   /* Name of collating sequence */
   const Token *pCollName,  /* Name of collating sequence */
   int dequote              /* True to dequote pCollName */
 ){
   if( pCollName->n>0 ){
     Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, 1);
     Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
     if( pNew ){
       pNew->pLeft = pExpr;
       pNew->flags |= EP_Collate|EP_Skip;

@@ -81881,7 +82532,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, con

   assert( zC!=0 );
   s.z = zC;
   s.n = sqlite3Strlen30(s.z);
   return sqlite3ExprAddCollateToken(pParse, pExpr, &s);
   return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
 }
 /*

@@ -81927,9 +82578,9 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){

       pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
       break;
     }
     if( p->pTab!=0
      && (op==TK_AGG_COLUMN || op==TK_COLUMN
     if( (op==TK_AGG_COLUMN || op==TK_COLUMN
           || op==TK_REGISTER || op==TK_TRIGGER)
      && p->pTab!=0
     ){
       /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
       ** a TK_COLUMN but was previously evaluated and cached in a register */

@@ -81941,10 +82592,25 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){

       break;
     }
     if( p->flags & EP_Collate ){
       if( ALWAYS(p->pLeft) && (p->pLeft->flags & EP_Collate)!=0 ){
       if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
         p = p->pLeft;
       }else{
         p = p->pRight;
         Expr *pNext  = p->pRight;
         /* The Expr.x union is never used at the same time as Expr.pRight */
         assert( p->x.pList==0 || p->pRight==0 );
         /* p->flags holds EP_Collate and p->pLeft->flags does not.  And
         ** p->x.pSelect cannot.  So if p->x.pLeft exists, it must hold at
         ** least one EP_Collate. Thus the following two ALWAYS. */
         if( p->x.pList!=0 && ALWAYS(!ExprHasProperty(p, EP_xIsSelect)) ){
           int i;
           for(i=0; ALWAYS(i<p->x.pList->nExpr); i++){
             if( ExprHasProperty(p->x.pList->a[i].pExpr, EP_Collate) ){
               pNext = p->x.pList->a[i].pExpr;
               break;
             }
           }
         }
         p = pNext;
       }
     }else{
       break;

@@ -82150,6 +82816,9 @@ static void heightOfSelect(Select *p, int *pnHeight){

 ** Expr.pSelect member has a height of 1. Any other expression
 ** has a height equal to the maximum height of any other
 ** referenced Expr plus one.
 **
 ** Also propagate EP_Propagate flags up from Expr.x.pList to Expr.flags,
 ** if appropriate.
 */
 static void exprSetHeight(Expr *p){
   int nHeight = 0;

@@ -82157,8 +82826,9 @@ static void exprSetHeight(Expr *p){

   heightOfExpr(p->pRight, &nHeight);
   if( ExprHasProperty(p, EP_xIsSelect) ){
     heightOfSelect(p->x.pSelect, &nHeight);
   }else{
   }else if( p->x.pList ){
     heightOfExprList(p->x.pList, &nHeight);
     p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
   }
   p->nHeight = nHeight + 1;
 }

@@ -82167,8 +82837,12 @@ static void exprSetHeight(Expr *p){

 ** Set the Expr.nHeight variable using the exprSetHeight() function. If
 ** the height is greater than the maximum allowed expression depth,
 ** leave an error in pParse.
 **
 ** Also propagate all EP_Propagate flags from the Expr.x.pList into
 ** Expr.flags.
 */
 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
   if( pParse->nErr ) return;
   exprSetHeight(p);
   sqlite3ExprCheckHeight(pParse, p->nHeight);
 }

@@ -82182,8 +82856,17 @@ SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){

   heightOfSelect(p, &nHeight);
   return nHeight;
 }
 #else
   #define exprSetHeight(y)
 #else /* ABOVE:  Height enforcement enabled.  BELOW: Height enforcement off */
 /*
 ** Propagate all EP_Propagate flags from the Expr.x.pList into
 ** Expr.flags.
 */
 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
   if( p && p->x.pList && !ExprHasProperty(p, EP_xIsSelect) ){
     p->flags |= EP_Propagate & sqlite3ExprListFlags(p->x.pList);
   }
 }
 #define exprSetHeight(y)
 #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
 /*

@@ -82285,11 +82968,11 @@ SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(

   }else{
     if( pRight ){
       pRoot->pRight = pRight;
       pRoot->flags |= EP_Collate & pRight->flags;
       pRoot->flags |= EP_Propagate & pRight->flags;
     }
     if( pLeft ){
       pRoot->pLeft = pLeft;
       pRoot->flags |= EP_Collate & pLeft->flags;
       pRoot->flags |= EP_Propagate & pLeft->flags;
     }
     exprSetHeight(pRoot);
   }

@@ -82389,7 +83072,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *

   }
   pNew->x.pList = pList;
   assert( !ExprHasProperty(pNew, EP_xIsSelect) );
   sqlite3ExprSetHeight(pParse, pNew);
   sqlite3ExprSetHeightAndFlags(pParse, pNew);
   return pNew;
 }

@@ -83005,6 +83688,21 @@ SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){

 }
 /*
 ** Return the bitwise-OR of all Expr.flags fields in the given
 ** ExprList.
 */
 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList *pList){
   int i;
   u32 m = 0;
   if( pList ){
     for(i=0; i<pList->nExpr; i++){
        m |= pList->a[i].pExpr->flags;
     }
   }
   return m;
 }
 /*
 ** These routines are Walker callbacks used to check expressions to
 ** see if they are "constant" for some definition of constant.  The
 ** Walker.eCode value determines the type of "constant" we are looking

@@ -83044,7 +83742,7 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){

     ** and either pWalker->eCode==4 or 5 or the function has the
     ** SQLITE_FUNC_CONST flag. */
     case TK_FUNCTION:
       if( pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_Constant) ){
       if( pWalker->eCode>=4 || ExprHasProperty(pExpr,EP_ConstFunc) ){
         return WRC_Continue;
       }else{
         pWalker->eCode = 0;

@@ -84051,7 +84749,8 @@ SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int

   int idxLru;
   struct yColCache *p;
   assert( iReg>0 );  /* Register numbers are always positive */
   /* Unless an error has occurred, register numbers are always positive. */
   assert( iReg>0 || pParse->nErr || pParse->db->mallocFailed );
   assert( iCol>=-1 && iCol<32768 );  /* Finite column numbers */
   /* The SQLITE_ColumnCache flag disables the column cache.  This is used

@@ -86858,7 +87557,10 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){

   */
   if( pDflt ){
     sqlite3_value *pVal = 0;
     if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
     int rc;
     rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal);
     assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
     if( rc!=SQLITE_OK ){
       db->mallocFailed = 1;
       return;
     }

@@ -89080,7 +89782,7 @@ static void attachFunc(

       case SQLITE_NULL:
         /* No key specified.  Use the key from the main database */
         sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
         if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
         if( nKey>0 || sqlite3BtreeGetOptimalReserve(db->aDb[0].pBt)>0 ){
           rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
         }
         break;

@@ -89543,7 +90245,7 @@ SQLITE_PRIVATE int sqlite3FixTriggerStep(

 ** Setting the auth function to NULL disables this hook.  The default
 ** setting of the auth function is NULL.
 */
 SQLITE_API int sqlite3_set_authorizer(
 SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer(
   sqlite3 *db,
   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
   void *pArg

@@ -90046,10 +90748,6 @@ SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const cha

   Table *p = 0;
   int i;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 ) return 0;
 #endif
   /* All mutexes are required for schema access.  Make sure we hold them. */
   assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
 #if SQLITE_USER_AUTHENTICATION

@@ -91469,11 +92167,14 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){

   assert( pPk!=0 );
   nPk = pPk->nKeyCol;
   /* Make sure every column of the PRIMARY KEY is NOT NULL */
   for(i=0; i<nPk; i++){
     pTab->aCol[pPk->aiColumn[i]].notNull = 1;
   /* Make sure every column of the PRIMARY KEY is NOT NULL.  (Except,
   ** do not enforce this for imposter tables.) */
   if( !db->init.imposterTable ){
     for(i=0; i<nPk; i++){
       pTab->aCol[pPk->aiColumn[i]].notNull = 1;
     }
     pPk->uniqNotNull = 1;
   }
   pPk->uniqNotNull = 1;
   /* The root page of the PRIMARY KEY is the table root page */
   pPk->tnum = pTab->tnum;

@@ -92922,6 +93623,7 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(

             pIdx->onError = pIndex->onError;
           }
         }
         pRet = pIdx;
         goto exit_create_index;
       }
     }

@@ -94708,7 +95410,7 @@ SQLITE_PRIVATE Expr *sqlite3LimitWhere(

   pInClause->x.pSelect = pSelect;
   pInClause->flags |= EP_xIsSelect;
   sqlite3ExprSetHeight(pParse, pInClause);
   sqlite3ExprSetHeightAndFlags(pParse, pInClause);
   return pInClause;
   /* something went wrong. clean up anything allocated. */

@@ -95381,7 +96083,9 @@ SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){

 ** Return the collating function associated with a function.
 */
 static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
   VdbeOp *pOp = &context->pVdbe->aOp[context->iOp-1];
   VdbeOp *pOp;
   assert( context->pVdbe!=0 );
   pOp = &context->pVdbe->aOp[context->iOp-1];
   assert( pOp->opcode==OP_CollSeq );
   assert( pOp->p4type==P4_COLLSEQ );
   return pOp->p4.pColl;

@@ -95650,6 +96354,14 @@ static void substrFunc(

       }
     }
   }
 #ifdef SQLITE_SUBSTR_COMPATIBILITY
   /* If SUBSTR_COMPATIBILITY is defined then substr(X,0,N) work the same as
   ** as substr(X,1,N) - it returns the first N characters of X.  This
   ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
   ** from 2009-02-02 for compatibility of applications that exploited the
   ** old buggy behavior. */
   if( p1==0 ) p1 = 1; /* <rdar://problem/6778339> */
 #endif
   if( argc==3 ){
     p2 = sqlite3_value_int(argv[2]);
     if( p2<0 ){

@@ -96111,7 +96823,7 @@ static int patternCompare(

 /*
 ** The sqlite3_strglob() interface.
 */
 SQLITE_API int sqlite3_strglob(const char *zGlobPattern, const char *zString){
 SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlobPattern, const char *zString){
   return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0;
 }

@@ -97001,6 +97713,11 @@ SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive)

 ** then set aWc[0] through aWc[2] to the wildcard characters and
 ** return TRUE.  If the function is not a LIKE-style function then
 ** return FALSE.
 **
 ** *pIsNocase is set to true if uppercase and lowercase are equivalent for
 ** the function (default for LIKE).  If the function makes the distinction
 ** between uppercase and lowercase (as does GLOB) then *pIsNocase is set to
 ** false.
 */
 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
   FuncDef *pDef;

@@ -100601,7 +101318,7 @@ static int xferOptimization(

 ** argument to xCallback().  If xCallback=NULL then no callback
 ** is invoked, even for queries.
 */
 SQLITE_API int sqlite3_exec(
 SQLITE_API int SQLITE_STDCALL sqlite3_exec(
   sqlite3 *db,                /* The database on which the SQL executes */
   const char *zSql,           /* The SQL to be executed */
   sqlite3_callback xCallback, /* Invoke this callback routine */

@@ -101796,7 +102513,7 @@ static int sqlite3LoadExtension(

   db->aExtension[db->nExtension++] = handle;
   return SQLITE_OK;
 }
 SQLITE_API int sqlite3_load_extension(
 SQLITE_API int SQLITE_STDCALL sqlite3_load_extension(
   sqlite3 *db,          /* Load the extension into this database connection */
   const char *zFile,    /* Name of the shared library containing extension */
   const char *zProc,    /* Entry point.  Use "sqlite3_extension_init" if 0 */

@@ -101827,7 +102544,7 @@ SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){

 ** Enable or disable extension loading.  Extension loading is disabled by
 ** default so as not to open security holes in older applications.
 */
 SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
 SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff){
   sqlite3_mutex_enter(db->mutex);
   if( onoff ){
     db->flags |= SQLITE_LoadExtension;

@@ -101884,7 +102601,7 @@ static SQLITE_WSD struct sqlite3AutoExtList {

 ** Register a statically linked extension that is automatically
 ** loaded by every new database connection.
 */
 SQLITE_API int sqlite3_auto_extension(void (*xInit)(void)){
 SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension(void (*xInit)(void)){
   int rc = SQLITE_OK;
 #ifndef SQLITE_OMIT_AUTOINIT
   rc = sqlite3_initialize();

@@ -101929,7 +102646,7 @@ SQLITE_API int sqlite3_auto_extension(void (*xInit)(void)){

 ** Return 1 if xInit was found on the list and removed.  Return 0 if xInit
 ** was not on the list.
 */
 SQLITE_API int sqlite3_cancel_auto_extension(void (*xInit)(void)){
 SQLITE_API int SQLITE_STDCALL sqlite3_cancel_auto_extension(void (*xInit)(void)){
 #if SQLITE_THREADSAFE
   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
 #endif

@@ -101952,7 +102669,7 @@ SQLITE_API int sqlite3_cancel_auto_extension(void (*xInit)(void)){

 /*
 ** Reset the automatic extension loading mechanism.
 */
 SQLITE_API void sqlite3_reset_auto_extension(void){
 SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension(void){
 #ifndef SQLITE_OMIT_AUTOINIT
   if( sqlite3_initialize()==SQLITE_OK )
 #endif

@@ -102034,11 +102751,18 @@ SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){

 #endif
 /***************************************************************************
 ** The next block of code, including the PragTyp_XXXX macro definitions and
 ** the aPragmaName[] object is composed of generated code. DO NOT EDIT.
 **
 ** To add new pragmas, edit the code in ../tool/mkpragmatab.tcl and rerun
 ** that script.  Then copy/paste the output in place of the following:
 ** The "pragma.h" include file is an automatically generated file that
 ** that includes the PragType_XXXX macro definitions and the aPragmaName[]
 ** object.  This ensures that the aPragmaName[] table is arranged in
 ** lexicographical order to facility a binary search of the pragma name.
 ** Do not edit pragma.h directly.  Edit and rerun the script in at
 ** ../tool/mkpragmatab.tcl. */
 /************** Include pragma.h in the middle of pragma.c *******************/
 /************** Begin file pragma.h ******************************************/
 /* DO NOT EDIT!
 ** This file is automatically generated by the script at
 ** ../tool/mkpragmatab.tcl.  To update the set of pragmas, edit
 ** that script and rerun it.
 */
 #define PragTyp_HEADER_VALUE                   0
 #define PragTyp_AUTO_VACUUM                    1

@@ -102273,6 +102997,10 @@ static const struct sPragmaNames {

     /* ePragTyp:  */ PragTyp_INDEX_LIST,
     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 0 },
   { /* zName:     */ "index_xinfo",
     /* ePragTyp:  */ PragTyp_INDEX_INFO,
     /* ePragFlag: */ PragFlag_NeedSchema,
     /* iArg:      */ 1 },
 #endif
 #if !defined(SQLITE_OMIT_INTEGRITY_CHECK)
   { /* zName:     */ "integrity_check",

@@ -102489,9 +103217,10 @@ static const struct sPragmaNames {

     /* iArg:      */ SQLITE_WriteSchema|SQLITE_RecoveryMode },
 #endif
 };
 /* Number of pragmas: 58 on by default, 71 total. */
 /* End of the automatically generated pragma table.
 ***************************************************************************/
 /* Number of pragmas: 59 on by default, 72 total. */
 /************** End of pragma.h **********************************************/
 /************** Continuing where we left off in pragma.c *********************/
 /*
 ** Interpret the given string as a safety level.  Return 0 for OFF,

@@ -102744,6 +103473,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

   sqlite3 *db = pParse->db;    /* The database connection */
   Db *pDb;                     /* The specific database being pragmaed */
   Vdbe *v = sqlite3GetVdbe(pParse);  /* Prepared statement */
   const struct sPragmaNames *pPragma;
   if( v==0 ) return;
   sqlite3VdbeRunOnlyOnce(v);

@@ -102779,6 +103509,17 @@ SQLITE_PRIVATE void sqlite3Pragma(

   /* Send an SQLITE_FCNTL_PRAGMA file-control to the underlying VFS
   ** connection.  If it returns SQLITE_OK, then assume that the VFS
   ** handled the pragma and generate a no-op prepared statement.
   **
   ** IMPLEMENTATION-OF: R-12238-55120 Whenever a PRAGMA statement is parsed,
   ** an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file
   ** object corresponding to the database file to which the pragma
   ** statement refers.
   **
   ** IMPLEMENTATION-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA
   ** file control is an array of pointers to strings (char**) in which the
   ** second element of the array is the name of the pragma and the third
   ** element is the argument to the pragma or NULL if the pragma has no
   ** argument.
   */
   aFcntl[0] = 0;
   aFcntl[1] = zLeft;

@@ -102821,14 +103562,15 @@ SQLITE_PRIVATE void sqlite3Pragma(

     }
   }
   if( lwr>upr ) goto pragma_out;
   pPragma = &aPragmaNames[mid];
   /* Make sure the database schema is loaded if the pragma requires that */
   if( (aPragmaNames[mid].mPragFlag & PragFlag_NeedSchema)!=0 ){
   if( (pPragma->mPragFlag & PragFlag_NeedSchema)!=0 ){
     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
   }
   /* Jump to the appropriate pragma handler */
   switch( aPragmaNames[mid].ePragTyp ){
   switch( pPragma->ePragTyp ){
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
   /*

@@ -103407,10 +104149,9 @@ SQLITE_PRIVATE void sqlite3Pragma(

 #ifndef SQLITE_OMIT_FLAG_PRAGMAS
   case PragTyp_FLAG: {
     if( zRight==0 ){
       returnSingleInt(pParse, aPragmaNames[mid].zName,
                      (db->flags & aPragmaNames[mid].iArg)!=0 );
       returnSingleInt(pParse, pPragma->zName, (db->flags & pPragma->iArg)!=0 );
     }else{
       int mask = aPragmaNames[mid].iArg;    /* Mask of bits to set or clear. */
       int mask = pPragma->iArg;    /* Mask of bits to set or clear. */
       if( db->autoCommit==0 ){
         /* Foreign key support may not be enabled or disabled while not
         ** in auto-commit mode.  */

@@ -103539,20 +104280,42 @@ SQLITE_PRIVATE void sqlite3Pragma(

     pIdx = sqlite3FindIndex(db, zRight, zDb);
     if( pIdx ){
       int i;
       int mx;
       if( pPragma->iArg ){
         /* PRAGMA index_xinfo (newer version with more rows and columns) */
         mx = pIdx->nColumn;
         pParse->nMem = 6;
       }else{
         /* PRAGMA index_info (legacy version) */
         mx = pIdx->nKeyCol;
         pParse->nMem = 3;
       }
       pTab = pIdx->pTable;
       sqlite3VdbeSetNumCols(v, 3);
       pParse->nMem = 3;
       sqlite3VdbeSetNumCols(v, pParse->nMem);
       sqlite3CodeVerifySchema(pParse, iDb);
       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLITE_STATIC);
       for(i=0; i<pIdx->nKeyCol; i++){
       if( pPragma->iArg ){
         sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "desc", SQLITE_STATIC);
         sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "coll", SQLITE_STATIC);
         sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "key", SQLITE_STATIC);
       }
       for(i=0; i<mx; i++){
         i16 cnum = pIdx->aiColumn[i];
         sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
         sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
         assert( pTab->nCol>cnum );
         sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
         if( cnum<0 ){
           sqlite3VdbeAddOp2(v, OP_Null, 0, 3);
         }else{
           sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
         }
         if( pPragma->iArg ){
           sqlite3VdbeAddOp2(v, OP_Integer, pIdx->aSortOrder[i], 4);
           sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, pIdx->azColl[i], 0);
           sqlite3VdbeAddOp2(v, OP_Integer, i<pIdx->nKeyCol, 6);
         }
         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem);
       }
     }
   }

@@ -103565,17 +104328,22 @@ SQLITE_PRIVATE void sqlite3Pragma(

     pTab = sqlite3FindTable(db, zRight, zDb);
     if( pTab ){
       v = sqlite3GetVdbe(pParse);
       sqlite3VdbeSetNumCols(v, 3);
       pParse->nMem = 3;
       sqlite3VdbeSetNumCols(v, 5);
       pParse->nMem = 5;
       sqlite3CodeVerifySchema(pParse, iDb);
       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "origin", SQLITE_STATIC);
       sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "partial", SQLITE_STATIC);
       for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
         const char *azOrigin[] = { "c", "u", "pk" };
         sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
         sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
         sqlite3VdbeAddOp2(v, OP_Integer, IsUniqueIndex(pIdx), 3);
         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
         sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0, azOrigin[pIdx->idxType], 0);
         sqlite3VdbeAddOp2(v, OP_Integer, pIdx->pPartIdxWhere!=0, 5);
         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
       }
     }
   }

@@ -104145,9 +104913,9 @@ SQLITE_PRIVATE void sqlite3Pragma(

   ** applications for any purpose.
   */
   case PragTyp_HEADER_VALUE: {
     int iCookie = aPragmaNames[mid].iArg;  /* Which cookie to read or write */
     int iCookie = pPragma->iArg;  /* Which cookie to read or write */
     sqlite3VdbeUsesBtree(v, iDb);
     if( zRight && (aPragmaNames[mid].mPragFlag & PragFlag_ReadOnly)==0 ){
     if( zRight && (pPragma->mPragFlag & PragFlag_ReadOnly)==0 ){
       /* Write the specified cookie value */
       static const VdbeOpList setCookie[] = {
         { OP_Transaction,    0,  1,  0},    /* 0 */

@@ -104249,8 +105017,9 @@ SQLITE_PRIVATE void sqlite3Pragma(

   /*
   **  PRAGMA shrink_memory
   **
   ** This pragma attempts to free as much memory as possible from the
   ** current database connection.
   ** IMPLEMENTATION-OF: R-23445-46109 This pragma causes the database
   ** connection on which it is invoked to free up as much memory as it
   ** can, by calling sqlite3_db_release_memory().
   */
   case PragTyp_SHRINK_MEMORY: {
     sqlite3_db_release_memory(db);

@@ -104267,7 +105036,7 @@ SQLITE_PRIVATE void sqlite3Pragma(

   ** disables the timeout.
   */
   /*case PragTyp_BUSY_TIMEOUT*/ default: {
     assert( aPragmaNames[mid].ePragTyp==PragTyp_BUSY_TIMEOUT );
     assert( pPragma->ePragTyp==PragTyp_BUSY_TIMEOUT );
     if( zRight ){
       sqlite3_busy_timeout(db, sqlite3Atoi(zRight));
     }

@@ -104279,8 +105048,12 @@ SQLITE_PRIVATE void sqlite3Pragma(

   **   PRAGMA soft_heap_limit
   **   PRAGMA soft_heap_limit = N
   **
   ** Call sqlite3_soft_heap_limit64(N).  Return the result.  If N is omitted,
   ** use -1.
   ** IMPLEMENTATION-OF: R-26343-45930 This pragma invokes the
   ** sqlite3_soft_heap_limit64() interface with the argument N, if N is
   ** specified and is a non-negative integer.
   ** IMPLEMENTATION-OF: R-64451-07163 The soft_heap_limit pragma always
   ** returns the same integer that would be returned by the
   ** sqlite3_soft_heap_limit64(-1) C-language function.
   */
   case PragTyp_SOFT_HEAP_LIMIT: {
     sqlite3_int64 N;

@@ -105176,7 +105949,7 @@ SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){

 ** and the statement is automatically recompiled if an schema change
 ** occurs.
 */
 SQLITE_API int sqlite3_prepare(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare(
   sqlite3 *db,              /* Database handle. */
   const char *zSql,         /* UTF-8 encoded SQL statement. */
   int nBytes,               /* Length of zSql in bytes. */

@@ -105188,7 +105961,7 @@ SQLITE_API int sqlite3_prepare(

   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
   return rc;
 }
 SQLITE_API int sqlite3_prepare_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2(
   sqlite3 *db,              /* Database handle. */
   const char *zSql,         /* UTF-8 encoded SQL statement. */
   int nBytes,               /* Length of zSql in bytes. */

@@ -105264,7 +106037,7 @@ static int sqlite3Prepare16(

 ** and the statement is automatically recompiled if an schema change
 ** occurs.
 */
 SQLITE_API int sqlite3_prepare16(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare16(
   sqlite3 *db,              /* Database handle. */
   const void *zSql,         /* UTF-16 encoded SQL statement. */
   int nBytes,               /* Length of zSql in bytes. */

@@ -105276,7 +106049,7 @@ SQLITE_API int sqlite3_prepare16(

   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
   return rc;
 }
 SQLITE_API int sqlite3_prepare16_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2(
   sqlite3 *db,              /* Database handle. */
   const void *zSql,         /* UTF-16 encoded SQL statement. */
   int nBytes,               /* Length of zSql in bytes. */

@@ -105857,20 +106630,17 @@ static void pushOntoSorter(

   }
   sqlite3VdbeAddOp2(v, op, pSort->iECursor, regRecord);
   if( pSelect->iLimit ){
     int addr1, addr2;
     int addr;
     int iLimit;
     if( pSelect->iOffset ){
       iLimit = pSelect->iOffset+1;
     }else{
       iLimit = pSelect->iLimit;
     }
     addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
     addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
     sqlite3VdbeJumpHere(v, addr1);
     addr = sqlite3VdbeAddOp3(v, OP_IfNotZero, iLimit, 0, -1); VdbeCoverage(v);
     sqlite3VdbeAddOp1(v, OP_Last, pSort->iECursor);
     sqlite3VdbeAddOp1(v, OP_Delete, pSort->iECursor);
     sqlite3VdbeJumpHere(v, addr2);
     sqlite3VdbeJumpHere(v, addr);
   }
 }

@@ -106267,7 +107037,7 @@ static void selectInnerLoop(

   ** the output for us.
   */
   if( pSort==0 && p->iLimit ){
     sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
   }
 }

@@ -107120,7 +107890,7 @@ static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){

       sqlite3ExprCode(pParse, p->pLimit, iLimit);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
       VdbeComment((v, "LIMIT counter"));
       sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak); VdbeCoverage(v);
       sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
     }
     if( p->pOffset ){
       p->iOffset = iOffset = ++pParse->nMem;

@@ -107339,7 +108109,7 @@ static void generateWithRecursiveQuery(

   selectInnerLoop(pParse, p, p->pEList, iCurrent,
 , 0, pDest, addrCont, addrBreak);
   if( regLimit ){
     sqlite3VdbeAddOp3(v, OP_IfZero, regLimit, addrBreak, -1);
     sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
     VdbeCoverage(v);
   }
   sqlite3VdbeResolveLabel(v, addrCont);

@@ -107564,7 +108334,7 @@ static int multiSelect(

       p->iLimit = pPrior->iLimit;
       p->iOffset = pPrior->iOffset;
       if( p->iLimit ){
         addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit); VdbeCoverage(v);
         addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
         VdbeComment((v, "Jump ahead if LIMIT reached"));
       }
       explainSetInteger(iSub2, pParse->iNextSelectId);

@@ -107965,7 +108735,7 @@ static int generateOutputSubroutine(

   /* Jump to the end of the loop if the LIMIT is reached.
   */
   if( p->iLimit ){
     sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
   }
   /* Generate the subroutine return

@@ -108488,7 +109258,10 @@ static void substSelect(

 **
 **   (1)  The subquery and the outer query do not both use aggregates.
 **
 **   (2)  The subquery is not an aggregate or the outer query is not a join.
 **   (2)  The subquery is not an aggregate or (2a) the outer query is not a join
 **        and (2b) the outer query does not use subqueries other than the one
 **        FROM-clause subquery that is a candidate for flattening.  (2b is
 **        due to ticket [2f7170d73bf9abf80] from 2015-02-09.)
 **
 **   (3)  The subquery is not the right operand of a left outer join
 **        (Originally ticket #306.  Strengthened by ticket #3300)

@@ -108625,8 +109398,17 @@ static int flattenSubquery(

   iParent = pSubitem->iCursor;
   pSub = pSubitem->pSelect;
   assert( pSub!=0 );
   if( isAgg && subqueryIsAgg ) return 0;                 /* Restriction (1)  */
   if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;          /* Restriction (2)  */
   if( subqueryIsAgg ){
     if( isAgg ) return 0;                                /* Restriction (1)   */
     if( pSrc->nSrc>1 ) return 0;                         /* Restriction (2a)  */
     if( (p->pWhere && ExprHasProperty(p->pWhere,EP_Subquery))
      || (sqlite3ExprListFlags(p->pEList) & EP_Subquery)!=0
      || (sqlite3ExprListFlags(p->pOrderBy) & EP_Subquery)!=0
     ){
       return 0;                                          /* Restriction (2b)  */
     }
   }
   pSubSrc = pSub->pSrc;
   assert( pSubSrc );
   /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,

@@ -109169,6 +109951,8 @@ static int convertCompoundSelectToSubquery(Walker *pWalker, Select *p){

   p->pPrior = 0;
   p->pNext = 0;
   p->selFlags &= ~SF_Compound;
   assert( (p->selFlags & SF_Converted)==0 );
   p->selFlags |= SF_Converted;
   assert( pNew->pPrior!=0 );
   pNew->pPrior->pNext = pNew;
   pNew->pLimit = 0;

@@ -109320,7 +110104,7 @@ static int withExpand(

     for(pLeft=pSel; pLeft->pPrior; pLeft=pLeft->pPrior);
     pEList = pLeft->pEList;
     if( pCte->pCols ){
       if( pEList->nExpr!=pCte->pCols->nExpr ){
       if( pEList && pEList->nExpr!=pCte->pCols->nExpr ){
         sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
             pCte->zName, pEList->nExpr, pCte->pCols->nExpr
         );

@@ -109447,7 +110231,7 @@ static int selectExpander(Walker *pWalker, Select *p){

       /* A sub-query in the FROM clause of a SELECT */
       assert( pSel!=0 );
       assert( pFrom->pTab==0 );
       sqlite3WalkSelect(pWalker, pSel);
       if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
       pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
       if( pTab==0 ) return WRC_Abort;
       pTab->nRef = 1;

@@ -110046,6 +110830,13 @@ SQLITE_PRIVATE int sqlite3Select(

   }
   isAgg = (p->selFlags & SF_Aggregate)!=0;
   assert( pEList!=0 );
 #if SELECTTRACE_ENABLED
   if( sqlite3SelectTrace & 0x100 ){
     SELECTTRACE(0x100,pParse,p, ("after name resolution:\n"));
     sqlite3TreeViewSelect(0, p, 0);
   }
 #endif
   /* Begin generating code.
   */

@@ -110791,9 +111582,9 @@ select_end:

 SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 moreToFollow){
   int n = 0;
   pView = sqlite3TreeViewPush(pView, moreToFollow);
   sqlite3TreeViewLine(pView, "SELECT%s%s",
   sqlite3TreeViewLine(pView, "SELECT%s%s (0x%p)",
     ((p->selFlags & SF_Distinct) ? " DISTINCT" : ""),
     ((p->selFlags & SF_Aggregate) ? " agg_flag" : "")
     ((p->selFlags & SF_Aggregate) ? " agg_flag" : ""), p
   );
   if( p->pSrc && p->pSrc->nSrc ) n++;
   if( p->pWhere ) n++;

@@ -110996,7 +111787,7 @@ malloc_failed:

 ** Instead, the entire table should be passed to sqlite3_free_table() when
 ** the calling procedure is finished using it.
 */
 SQLITE_API int sqlite3_get_table(
 SQLITE_API int SQLITE_STDCALL sqlite3_get_table(
   sqlite3 *db,                /* The database on which the SQL executes */
   const char *zSql,           /* The SQL to be executed */
   char ***pazResult,          /* Write the result table here */

@@ -111065,7 +111856,7 @@ SQLITE_API int sqlite3_get_table(

 /*
 ** This routine frees the space the sqlite3_get_table() malloced.
 */
 SQLITE_API void sqlite3_free_table(
 SQLITE_API void SQLITE_STDCALL sqlite3_free_table(
   char **azResult            /* Result returned from sqlite3_get_table() */
 ){
   if( azResult ){

@@ -113163,7 +113954,7 @@ SQLITE_PRIVATE int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){

   ** cause problems for the call to BtreeSetPageSize() below.  */
   sqlite3BtreeCommit(pTemp);
   nRes = sqlite3BtreeGetReserve(pMain);
   nRes = sqlite3BtreeGetOptimalReserve(pMain);
   /* A VACUUM cannot change the pagesize of an encrypted database. */
 #ifdef SQLITE_HAS_CODEC

@@ -113425,7 +114216,7 @@ static int createModule(

 /*
 ** External API function used to create a new virtual-table module.
 */
 SQLITE_API int sqlite3_create_module(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_module(
   sqlite3 *db,                    /* Database in which module is registered */
   const char *zName,              /* Name assigned to this module */
   const sqlite3_module *pModule,  /* The definition of the module */

@@ -113440,7 +114231,7 @@ SQLITE_API int sqlite3_create_module(

 /*
 ** External API function used to create a new virtual-table module.
 */
 SQLITE_API int sqlite3_create_module_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2(
   sqlite3 *db,                    /* Database in which module is registered */
   const char *zName,              /* Name assigned to this module */
   const sqlite3_module *pModule,  /* The definition of the module */

@@ -113739,6 +114530,7 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){

     char *zStmt;
     char *zWhere;
     int iDb;
     int iReg;
     Vdbe *v;
     /* Compute the complete text of the CREATE VIRTUAL TABLE statement */

@@ -113773,8 +114565,10 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){

     sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
     zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
     sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
     sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0,
                          pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
     iReg = ++pParse->nMem;
     sqlite3VdbeAddOp4(v, OP_String8, 0, iReg, 0, pTab->zName, 0);
     sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
   }
   /* If we are rereading the sqlite_master table create the in-memory

@@ -114052,7 +114846,7 @@ SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab,

 ** valid to call this function from within the xCreate() or xConnect() of a
 ** virtual table module.
 */
 SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
 SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   Parse *pParse;
   int rc = SQLITE_OK;

@@ -114060,7 +114854,9 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){

   char *zErr = 0;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
   if( !sqlite3SafetyCheckOk(db) || zCreateTable==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
   if( !db->pVtabCtx || !(pTab = db->pVtabCtx->pTab) ){

@@ -114125,11 +114921,15 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab

   pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
   if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
     VTable *p = vtabDisconnectAll(db, pTab);
     assert( rc==SQLITE_OK );
     VTable *p;
     for(p=pTab->pVTable; p; p=p->pNext){
       assert( p->pVtab );
       if( p->pVtab->nRef>0 ){
         return SQLITE_LOCKED;
       }
     }
     p = vtabDisconnectAll(db, pTab);
     rc = p->pMod->pModule->xDestroy(p->pVtab);
     /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
     if( rc==SQLITE_OK ){
       assert( pTab->pVTable==p && p->pNext==0 );

@@ -114414,7 +115214,7 @@ SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){

 ** The results of this routine are undefined unless it is called from
 ** within an xUpdate method.
 */
 SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *db){
   static const unsigned char aMap[] = {
     SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
   };

@@ -114432,7 +115232,7 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *db){

 ** the SQLite core with additional information about the behavior
 ** of the virtual table being implemented.
 */
 SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){
 SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3 *db, int op, ...){
   va_list ap;
   int rc = SQLITE_OK;

@@ -114558,6 +115358,8 @@ struct WhereLevel {

   int addrCont;         /* Jump here to continue with the next loop cycle */
   int addrFirst;        /* First instruction of interior of the loop */
   int addrBody;         /* Beginning of the body of this loop */
   int iLikeRepCntr;     /* LIKE range processing counter register */
   int addrLikeRep;      /* LIKE range processing address */
   u8 iFrom;             /* Which entry in the FROM clause */
   u8 op, p3, p5;        /* Opcode, P3 & P5 of the opcode that ends the loop */
   int p1, p2;           /* Operands of the opcode used to ends the loop */

@@ -114742,7 +115544,7 @@ struct WhereTerm {

   } u;
   LogEst truthProb;       /* Probability of truth for this expression */
   u16 eOperator;          /* A WO_xx value describing <op> */
   u8 wtFlags;             /* TERM_xxx bit flags.  See below */
   u16 wtFlags;            /* TERM_xxx bit flags.  See below */
   u8 nChild;              /* Number of children that must disable us */
   WhereClause *pWC;       /* The clause this term is part of */
   Bitmask prereqRight;    /* Bitmask of tables used by pExpr->pRight */

@@ -114764,6 +115566,9 @@ struct WhereTerm {

 #else
 #  define TERM_VNULL    0x00   /* Disabled if not using stat3 */
 #endif
 #define TERM_LIKEOPT    0x100  /* Virtual terms from the LIKE optimization */
 #define TERM_LIKECOND   0x200  /* Conditionally this LIKE operator term */
 #define TERM_LIKE       0x400  /* The original LIKE operator */
 /*
 ** An instance of the WhereScan object is used as an iterator for locating

@@ -115139,7 +115944,7 @@ static void whereClauseClear(WhereClause *pWC){

 ** calling this routine.  Such pointers may be reinitialized by referencing
 ** the pWC->a[] array.
 */
 static int whereClauseInsert(WhereClause *pWC, Expr *p, u8 wtFlags){
 static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
   WhereTerm *pTerm;
   int idx;
   testcase( wtFlags & TERM_VIRTUAL );

@@ -115564,7 +116369,11 @@ static void exprAnalyzeAll(

 ** so and false if not.
 **
 ** In order for the operator to be optimizible, the RHS must be a string
 ** literal that does not begin with a wildcard.
 ** literal that does not begin with a wildcard.  The LHS must be a column
 ** that may only be NULL, a string, or a BLOB, never a number. (This means
 ** that virtual tables cannot participate in the LIKE optimization.)  If the
 ** collating sequence for the column on the LHS must be appropriate for
 ** the operator.
 */
 static int isLikeOrGlob(
   Parse *pParse,    /* Parsing and code generating context */

@@ -115593,7 +116402,7 @@ static int isLikeOrGlob(

   pLeft = pList->a[1].pExpr;
   if( pLeft->op!=TK_COLUMN
    || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
    || IsVirtual(pLeft->pTab)
    || IsVirtual(pLeft->pTab)  /* Value might be numeric */
   ){
     /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
     ** be the name of an indexed column with TEXT affinity. */

@@ -115703,6 +116512,79 @@ static void markTermAsChild(WhereClause *pWC, int iChild, int iParent){

   pWC->a[iParent].nChild++;
 }
 /*
 ** Return the N-th AND-connected subterm of pTerm.  Or if pTerm is not
 ** a conjunction, then return just pTerm when N==0.  If N is exceeds
 ** the number of available subterms, return NULL.
 */
 static WhereTerm *whereNthSubterm(WhereTerm *pTerm, int N){
   if( pTerm->eOperator!=WO_AND ){
     return N==0 ? pTerm : 0;
   }
   if( N<pTerm->u.pAndInfo->wc.nTerm ){
     return &pTerm->u.pAndInfo->wc.a[N];
   }
   return 0;
 }
 /*
 ** Subterms pOne and pTwo are contained within WHERE clause pWC.  The
 ** two subterms are in disjunction - they are OR-ed together.
 **
 ** If these two terms are both of the form:  "A op B" with the same
 ** A and B values but different operators and if the operators are
 ** compatible (if one is = and the other is <, for example) then
 ** add a new virtual AND term to pWC that is the combination of the
 ** two.
 **
 ** Some examples:
 **
 **    x<y OR x=y    -->     x<=y
 **    x=y OR x=y    -->     x=y
 **    x<=y OR x<y   -->     x<=y
 **
 ** The following is NOT generated:
 **
 **    x<y OR x>y    -->     x!=y
 */
 static void whereCombineDisjuncts(
   SrcList *pSrc,         /* the FROM clause */
   WhereClause *pWC,      /* The complete WHERE clause */
   WhereTerm *pOne,       /* First disjunct */
   WhereTerm *pTwo        /* Second disjunct */
 ){
   u16 eOp = pOne->eOperator | pTwo->eOperator;
   sqlite3 *db;           /* Database connection (for malloc) */
   Expr *pNew;            /* New virtual expression */
   int op;                /* Operator for the combined expression */
   int idxNew;            /* Index in pWC of the next virtual term */
   if( (pOne->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
   if( (pTwo->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE))==0 ) return;
   if( (eOp & (WO_EQ|WO_LT|WO_LE))!=eOp
    && (eOp & (WO_EQ|WO_GT|WO_GE))!=eOp ) return;
   assert( pOne->pExpr->pLeft!=0 && pOne->pExpr->pRight!=0 );
   assert( pTwo->pExpr->pLeft!=0 && pTwo->pExpr->pRight!=0 );
   if( sqlite3ExprCompare(pOne->pExpr->pLeft, pTwo->pExpr->pLeft, -1) ) return;
   if( sqlite3ExprCompare(pOne->pExpr->pRight, pTwo->pExpr->pRight, -1) )return;
   /* If we reach this point, it means the two subterms can be combined */
   if( (eOp & (eOp-1))!=0 ){
     if( eOp & (WO_LT|WO_LE) ){
       eOp = WO_LE;
     }else{
       assert( eOp & (WO_GT|WO_GE) );
       eOp = WO_GE;
     }
   }
   db = pWC->pWInfo->pParse->db;
   pNew = sqlite3ExprDup(db, pOne->pExpr, 0);
   if( pNew==0 ) return;
   for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( op<TK_GE ); }
   pNew->op = op;
   idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
   exprAnalyze(pSrc, pWC, idxNew);
 }
 #if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
 /*
 ** Analyze a term that consists of two or more OR-connected

@@ -115727,6 +116609,7 @@ static void markTermAsChild(WhereClause *pWC, int iChild, int iParent){

 **     (C)     t1.x=t2.y OR (t1.x=t2.z AND t1.y=15)
 **     (D)     x=expr1 OR (y>11 AND y<22 AND z LIKE '*hello*')
 **     (E)     (p.a=1 AND q.b=2 AND r.c=3) OR (p.x=4 AND q.y=5 AND r.z=6)
 **     (F)     x>A OR (x=A AND y>=B)
 **
 ** CASE 1:
 **

@@ -115743,6 +116626,16 @@ static void markTermAsChild(WhereClause *pWC, int iChild, int iParent){

 **
 ** CASE 2:
 **
 ** If there are exactly two disjuncts one side has x>A and the other side
 ** has x=A (for the same x and A) then add a new virtual conjunct term to the
 ** WHERE clause of the form "x>=A".  Example:
 **
 **      x>A OR (x=A AND y>B)    adds:    x>=A
 **
 ** The added conjunct can sometimes be helpful in query planning.
 **
 ** CASE 3:
 **
 ** If all subterms are indexable by a single table T, then set
 **
 **     WhereTerm.eOperator              =  WO_OR

@@ -115869,12 +116762,26 @@ static void exprAnalyzeOrTerm(

   }
   /*
   ** Record the set of tables that satisfy case 2.  The set might be
   ** Record the set of tables that satisfy case 3.  The set might be
   ** empty.
   */
   pOrInfo->indexable = indexable;
   pTerm->eOperator = indexable==0 ? 0 : WO_OR;
   /* For a two-way OR, attempt to implementation case 2.
   */
   if( indexable && pOrWc->nTerm==2 ){
     int iOne = 0;
     WhereTerm *pOne;
     while( (pOne = whereNthSubterm(&pOrWc->a[0],iOne++))!=0 ){
       int iTwo = 0;
       WhereTerm *pTwo;
       while( (pTwo = whereNthSubterm(&pOrWc->a[1],iTwo++))!=0 ){
         whereCombineDisjuncts(pSrc, pWC, pOne, pTwo);
       }
     }
   }
   /*
   ** chngToIN holds a set of tables that *might* satisfy case 1.  But
   ** we have to do some additional checking to see if case 1 really

@@ -116004,7 +116911,7 @@ static void exprAnalyzeOrTerm(

       }else{
         sqlite3ExprListDelete(db, pList);
       }
       pTerm->eOperator = WO_NOOP;  /* case 1 trumps case 2 */
       pTerm->eOperator = WO_NOOP;  /* case 1 trumps case 3 */
     }
   }
 }

@@ -116042,7 +116949,7 @@ static void exprAnalyze(

   Bitmask extraRight = 0;          /* Extra dependencies on LEFT JOIN */
   Expr *pStr1 = 0;                 /* RHS of LIKE/GLOB operator */
   int isComplete = 0;              /* RHS of LIKE/GLOB ends with wildcard */
   int noCase = 0;                  /* LIKE/GLOB distinguishes case */
   int noCase = 0;                  /* uppercase equivalent to lowercase */
   int op;                          /* Top-level operator.  pExpr->op */
   Parse *pParse = pWInfo->pParse;  /* Parsing context */
   sqlite3 *db = pParse->db;        /* Database connection */

@@ -116180,12 +117087,15 @@ static void exprAnalyze(

   /* Add constraints to reduce the search space on a LIKE or GLOB
   ** operator.
   **
   ** A like pattern of the form "x LIKE 'abc%'" is changed into constraints
   ** A like pattern of the form "x LIKE 'aBc%'" is changed into constraints
   **
   **          x>='abc' AND x<'abd' AND x LIKE 'abc%'
   **          x>='ABC' AND x<'abd' AND x LIKE 'aBc%'
   **
   ** The last character of the prefix "abc" is incremented to form the
   ** termination condition "abd".
   ** termination condition "abd".  If case is not significant (the default
   ** for LIKE) then the lower-bound is made all uppercase and the upper-
   ** bound is made all lowercase so that the bounds also work when comparing
   ** BLOBs.
   */
   if( pWC->op==TK_AND
    && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)

@@ -116196,10 +117106,26 @@ static void exprAnalyze(

     Expr *pNewExpr2;
     int idxNew1;
     int idxNew2;
     Token sCollSeqName;  /* Name of collating sequence */
     const char *zCollSeqName;     /* Name of collating sequence */
     const u16 wtFlags = TERM_LIKEOPT | TERM_VIRTUAL | TERM_DYNAMIC;
     pLeft = pExpr->x.pList->a[1].pExpr;
     pStr2 = sqlite3ExprDup(db, pStr1, 0);
     /* Convert the lower bound to upper-case and the upper bound to
     ** lower-case (upper-case is less than lower-case in ASCII) so that
     ** the range constraints also work for BLOBs
     */
     if( noCase && !pParse->db->mallocFailed ){
       int i;
       char c;
       pTerm->wtFlags |= TERM_LIKE;
       for(i=0; (c = pStr1->u.zToken[i])!=0; i++){
         pStr1->u.zToken[i] = sqlite3Toupper(c);
         pStr2->u.zToken[i] = sqlite3Tolower(c);
       }
     }
     if( !db->mallocFailed ){
       u8 c, *pC;       /* Last character before the first wildcard */
       pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];

@@ -116216,22 +117142,21 @@ static void exprAnalyze(

       }
       *pC = c + 1;
     }
     sCollSeqName.z = noCase ? "NOCASE" : "BINARY";
     sCollSeqName.n = 6;
     zCollSeqName = noCase ? "NOCASE" : "BINARY";
     pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
     pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
            sqlite3ExprAddCollateToken(pParse,pNewExpr1,&sCollSeqName),
     pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
            sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName),
            pStr1, 0);
     transferJoinMarkings(pNewExpr1, pExpr);
     idxNew1 = whereClauseInsert(pWC, pNewExpr1, TERM_VIRTUAL|TERM_DYNAMIC);
     idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags);
     testcase( idxNew1==0 );
     exprAnalyze(pSrc, pWC, idxNew1);
     pNewExpr2 = sqlite3ExprDup(db, pLeft, 0);
     pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
            sqlite3ExprAddCollateToken(pParse,pNewExpr2,&sCollSeqName),
            sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName),
            pStr2, 0);
     transferJoinMarkings(pNewExpr2, pExpr);
     idxNew2 = whereClauseInsert(pWC, pNewExpr2, TERM_VIRTUAL|TERM_DYNAMIC);
     idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags);
     testcase( idxNew2==0 );
     exprAnalyze(pSrc, pWC, idxNew2);
     pTerm = &pWC->a[idxTerm];

@@ -116549,11 +117474,16 @@ static void constructAutomaticIndex(

   pLoop = pLevel->pWLoop;
   idxCols = 0;
   for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
     Expr *pExpr = pTerm->pExpr;
     assert( !ExprHasProperty(pExpr, EP_FromJoin)    /* prereq always non-zero */
          || pExpr->iRightJoinTable!=pSrc->iCursor   /*   for the right-hand   */
          || pLoop->prereq!=0 );                     /*   table of a LEFT JOIN */
     if( pLoop->prereq==0
      && (pTerm->wtFlags & TERM_VIRTUAL)==0
      && sqlite3ExprIsTableConstant(pTerm->pExpr, pSrc->iCursor) ){
      && !ExprHasProperty(pExpr, EP_FromJoin)
      && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){
       pPartial = sqlite3ExprAnd(pParse->db, pPartial,
                                 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
                                 sqlite3ExprDup(pParse->db, pExpr, 0));
     }
     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
       int iCol = pTerm->u.leftColumn;

@@ -116840,11 +117770,14 @@ static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){

 ** Estimate the location of a particular key among all keys in an
 ** index.  Store the results in aStat as follows:
 **
 **    aStat[0]      Est. number of rows less than pVal
 **    aStat[1]      Est. number of rows equal to pVal
 **    aStat[0]      Est. number of rows less than pRec
 **    aStat[1]      Est. number of rows equal to pRec
 **
 ** Return the index of the sample that is the smallest sample that
 ** is greater than or equal to pRec.
 ** is greater than or equal to pRec. Note that this index is not an index
 ** into the aSample[] array - it is an index into a virtual set of samples
 ** based on the contents of aSample[] and the number of fields in record
 ** pRec.
 */
 static int whereKeyStats(
   Parse *pParse,              /* Database connection */

@@ -116855,67 +117788,158 @@ static int whereKeyStats(

 ){
   IndexSample *aSample = pIdx->aSample;
   int iCol;                   /* Index of required stats in anEq[] etc. */
   int i;                      /* Index of first sample >= pRec */
   int iSample;                /* Smallest sample larger than or equal to pRec */
   int iMin = 0;               /* Smallest sample not yet tested */
   int i = pIdx->nSample;      /* Smallest sample larger than or equal to pRec */
   int iTest;                  /* Next sample to test */
   int res;                    /* Result of comparison operation */
   int nField;                 /* Number of fields in pRec */
   tRowcnt iLower = 0;         /* anLt[] + anEq[] of largest sample pRec is > */
 #ifndef SQLITE_DEBUG
   UNUSED_PARAMETER( pParse );
 #endif
   assert( pRec!=0 );
   iCol = pRec->nField - 1;
   assert( pIdx->nSample>0 );
   assert( pRec->nField>0 && iCol<pIdx->nSampleCol );
   assert( pRec->nField>0 && pRec->nField<=pIdx->nSampleCol );
   /* Do a binary search to find the first sample greater than or equal
   ** to pRec. If pRec contains a single field, the set of samples to search
   ** is simply the aSample[] array. If the samples in aSample[] contain more
   ** than one fields, all fields following the first are ignored.
   **
   ** If pRec contains N fields, where N is more than one, then as well as the
   ** samples in aSample[] (truncated to N fields), the search also has to
   ** consider prefixes of those samples. For example, if the set of samples
   ** in aSample is:
   **
   **     aSample[0] = (a, 5)
   **     aSample[1] = (a, 10)
   **     aSample[2] = (b, 5)
   **     aSample[3] = (c, 100)
   **     aSample[4] = (c, 105)
   **
   ** Then the search space should ideally be the samples above and the
   ** unique prefixes [a], [b] and [c]. But since that is hard to organize,
   ** the code actually searches this set:
   **
   **     0: (a)
   **     1: (a, 5)
   **     2: (a, 10)
   **     3: (a, 10)
   **     4: (b)
   **     5: (b, 5)
   **     6: (c)
   **     7: (c, 100)
   **     8: (c, 105)
   **     9: (c, 105)
   **
   ** For each sample in the aSample[] array, N samples are present in the
   ** effective sample array. In the above, samples 0 and 1 are based on
   ** sample aSample[0]. Samples 2 and 3 on aSample[1] etc.
   **
   ** Often, sample i of each block of N effective samples has (i+1) fields.
   ** Except, each sample may be extended to ensure that it is greater than or
   ** equal to the previous sample in the array. For example, in the above,
   ** sample 2 is the first sample of a block of N samples, so at first it
   ** appears that it should be 1 field in size. However, that would make it
   ** smaller than sample 1, so the binary search would not work. As a result,
   ** it is extended to two fields. The duplicates that this creates do not
   ** cause any problems.
   */
   nField = pRec->nField;
   iCol = 0;
   iSample = pIdx->nSample * nField;
   do{
     iTest = (iMin+i)/2;
     res = sqlite3VdbeRecordCompare(aSample[iTest].n, aSample[iTest].p, pRec);
     int iSamp;                    /* Index in aSample[] of test sample */
     int n;                        /* Number of fields in test sample */
     iTest = (iMin+iSample)/2;
     iSamp = iTest / nField;
     if( iSamp>0 ){
       /* The proposed effective sample is a prefix of sample aSample[iSamp].
       ** Specifically, the shortest prefix of at least (1 + iTest%nField)
       ** fields that is greater than the previous effective sample.  */
       for(n=(iTest % nField) + 1; n<nField; n++){
         if( aSample[iSamp-1].anLt[n-1]!=aSample[iSamp].anLt[n-1] ) break;
       }
     }else{
       n = iTest + 1;
     }
     pRec->nField = n;
     res = sqlite3VdbeRecordCompare(aSample[iSamp].n, aSample[iSamp].p, pRec);
     if( res<0 ){
       iLower = aSample[iSamp].anLt[n-1] + aSample[iSamp].anEq[n-1];
       iMin = iTest+1;
     }else if( res==0 && n<nField ){
       iLower = aSample[iSamp].anLt[n-1];
       iMin = iTest+1;
       res = -1;
     }else{
       i = iTest;
       iSample = iTest;
       iCol = n-1;
     }
   }while( res && iMin<i );
   }while( res && iMin<iSample );
   i = iSample / nField;
 #ifdef SQLITE_DEBUG
   /* The following assert statements check that the binary search code
   ** above found the right answer. This block serves no purpose other
   ** than to invoke the asserts.  */
   if( res==0 ){
     /* If (res==0) is true, then sample $i must be equal to pRec */
     assert( i<pIdx->nSample );
     assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)
          || pParse->db->mallocFailed );
   }else{
     /* Otherwise, pRec must be smaller than sample $i and larger than
     ** sample ($i-1).  */
     assert( i==pIdx->nSample
          || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0
          || pParse->db->mallocFailed );
     assert( i==0
          || sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
          || pParse->db->mallocFailed );
   if( pParse->db->mallocFailed==0 ){
     if( res==0 ){
       /* If (res==0) is true, then pRec must be equal to sample i. */
       assert( i<pIdx->nSample );
       assert( iCol==nField-1 );
       pRec->nField = nField;
       assert( 0==sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)
            || pParse->db->mallocFailed
       );
     }else{
       /* Unless i==pIdx->nSample, indicating that pRec is larger than
       ** all samples in the aSample[] array, pRec must be smaller than the
       ** (iCol+1) field prefix of sample i.  */
       assert( i<=pIdx->nSample && i>=0 );
       pRec->nField = iCol+1;
       assert( i==pIdx->nSample
            || sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)>0
            || pParse->db->mallocFailed );
       /* if i==0 and iCol==0, then record pRec is smaller than all samples
       ** in the aSample[] array. Otherwise, if (iCol>0) then pRec must
       ** be greater than or equal to the (iCol) field prefix of sample i.
       ** If (i>0), then pRec must also be greater than sample (i-1).  */
       if( iCol>0 ){
         pRec->nField = iCol;
         assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0
              || pParse->db->mallocFailed );
       }
       if( i>0 ){
         pRec->nField = nField;
         assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0
              || pParse->db->mallocFailed );
       }
     }
   }
 #endif /* ifdef SQLITE_DEBUG */
   /* At this point, aSample[i] is the first sample that is greater than
   ** or equal to pVal.  Or if i==pIdx->nSample, then all samples are less
   ** than pVal.  If aSample[i]==pVal, then res==0.
   */
   if( res==0 ){
     /* Record pRec is equal to sample i */
     assert( iCol==nField-1 );
     aStat[0] = aSample[i].anLt[iCol];
     aStat[1] = aSample[i].anEq[iCol];
   }else{
     tRowcnt iLower, iUpper, iGap;
     if( i==0 ){
       iLower = 0;
       iUpper = aSample[0].anLt[iCol];
     /* At this point, the (iCol+1) field prefix of aSample[i] is the first
     ** sample that is greater than pRec. Or, if i==pIdx->nSample then pRec
     ** is larger than all samples in the array. */
     tRowcnt iUpper, iGap;
     if( i>=pIdx->nSample ){
       iUpper = sqlite3LogEstToInt(pIdx->aiRowLogEst[0]);
     }else{
       i64 nRow0 = sqlite3LogEstToInt(pIdx->aiRowLogEst[0]);
       iUpper = i>=pIdx->nSample ? nRow0 : aSample[i].anLt[iCol];
       iLower = aSample[i-1].anEq[iCol] + aSample[i-1].anLt[iCol];
       iUpper = aSample[i].anLt[iCol];
     }
     aStat[1] = pIdx->aAvgEq[iCol];
     if( iLower>=iUpper ){
       iGap = 0;
     }else{

@@ -116927,7 +117951,11 @@ static int whereKeyStats(

       iGap = iGap/3;
     }
     aStat[0] = iLower + iGap;
     aStat[1] = pIdx->aAvgEq[iCol];
   }
   /* Restore the pRec->nField value before returning.  */
   pRec->nField = nField;
   return i;
 }
 #endif /* SQLITE_ENABLE_STAT3_OR_STAT4 */

@@ -117401,20 +118429,43 @@ static int whereInScanEst(

 ** but joins might run a little slower.  The trick is to disable as much
 ** as we can without disabling too much.  If we disabled in (1), we'd get
 ** the wrong answer.  See ticket #813.
 **
 ** If all the children of a term are disabled, then that term is also
 ** automatically disabled.  In this way, terms get disabled if derived
 ** virtual terms are tested first.  For example:
 **
 **      x GLOB 'abc*' AND x>='abc' AND x<'acd'
 **      \___________/     \______/     \_____/
 **         parent          child1       child2
 **
 ** Only the parent term was in the original WHERE clause.  The child1
 ** and child2 terms were added by the LIKE optimization.  If both of
 ** the virtual child terms are valid, then testing of the parent can be
 ** skipped.
 **
 ** Usually the parent term is marked as TERM_CODED.  But if the parent
 ** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead.
 ** The TERM_LIKECOND marking indicates that the term should be coded inside
 ** a conditional such that is only evaluated on the second pass of a
 ** LIKE-optimization loop, when scanning BLOBs instead of strings.
 */
 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
   if( pTerm
   int nLoop = 0;
   while( pTerm
       && (pTerm->wtFlags & TERM_CODED)==0
       && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
       && (pLevel->notReady & pTerm->prereqAll)==0
   ){
     pTerm->wtFlags |= TERM_CODED;
     if( pTerm->iParent>=0 ){
       WhereTerm *pOther = &pTerm->pWC->a[pTerm->iParent];
       if( (--pOther->nChild)==0 ){
         disableTerm(pLevel, pOther);
       }
     if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){
       pTerm->wtFlags |= TERM_LIKECOND;
     }else{
       pTerm->wtFlags |= TERM_CODED;
     }
     if( pTerm->iParent<0 ) break;
     pTerm = &pTerm->pWC->a[pTerm->iParent];
     pTerm->nChild--;
     if( pTerm->nChild!=0 ) break;
     nLoop++;
   }
 }

@@ -117898,7 +118949,34 @@ static void addScanStatus(

 # define addScanStatus(a, b, c, d) ((void)d)
 #endif
 /*
 ** If the most recently coded instruction is a constant range contraint
 ** that originated from the LIKE optimization, then change the P3 to be
 ** pLoop->iLikeRepCntr and set P5.
 **
 ** The LIKE optimization trys to evaluate "x LIKE 'abc%'" as a range
 ** expression: "x>='ABC' AND x<'abd'".  But this requires that the range
 ** scan loop run twice, once for strings and a second time for BLOBs.
 ** The OP_String opcodes on the second pass convert the upper and lower
 ** bound string contants to blobs.  This routine makes the necessary changes
 ** to the OP_String opcodes for that to happen.
 */
 static void whereLikeOptimizationStringFixup(
   Vdbe *v,                /* prepared statement under construction */
   WhereLevel *pLevel,     /* The loop that contains the LIKE operator */
   WhereTerm *pTerm        /* The upper or lower bound just coded */
 ){
   if( pTerm->wtFlags & TERM_LIKEOPT ){
     VdbeOp *pOp;
     assert( pLevel->iLikeRepCntr>0 );
     pOp = sqlite3VdbeGetOp(v, -1);
     assert( pOp!=0 );
     assert( pOp->opcode==OP_String8
             || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
     pOp->p3 = pLevel->iLikeRepCntr;
     pOp->p5 = 1;
   }
 }
 /*
 ** Generate code for the start of the iLevel-th loop in the WHERE clause

@@ -118228,10 +119306,25 @@ static Bitmask codeOneLoopStart(

     if( pLoop->wsFlags & WHERE_BTM_LIMIT ){
       pRangeStart = pLoop->aLTerm[j++];
       nExtraReg = 1;
       /* Like optimization range constraints always occur in pairs */
       assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 ||
               (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 );
     }
     if( pLoop->wsFlags & WHERE_TOP_LIMIT ){
       pRangeEnd = pLoop->aLTerm[j++];
       nExtraReg = 1;
       if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){
         assert( pRangeStart!=0 );                     /* LIKE opt constraints */
         assert( pRangeStart->wtFlags & TERM_LIKEOPT );   /* occur in pairs */
         pLevel->iLikeRepCntr = ++pParse->nMem;
         testcase( bRev );
         testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
         sqlite3VdbeAddOp2(v, OP_Integer,
                           bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC),
                           pLevel->iLikeRepCntr);
         VdbeComment((v, "LIKE loop counter"));
         pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v);
       }
       if( pRangeStart==0
        && (j = pIdx->aiColumn[nEq])>=0
        && pIdx->pTable->aCol[j].notNull==0

@@ -118274,6 +119367,7 @@ static Bitmask codeOneLoopStart(

     if( pRangeStart ){
       Expr *pRight = pRangeStart->pExpr->pRight;
       sqlite3ExprCode(pParse, pRight, regBase+nEq);
       whereLikeOptimizationStringFixup(v, pLevel, pRangeStart);
       if( (pRangeStart->wtFlags & TERM_VNULL)==0
        && sqlite3ExprCanBeNull(pRight)
       ){

@@ -118319,6 +119413,7 @@ static Bitmask codeOneLoopStart(

       Expr *pRight = pRangeEnd->pExpr->pRight;
       sqlite3ExprCacheRemove(pParse, regBase+nEq, 1);
       sqlite3ExprCode(pParse, pRight, regBase+nEq);
       whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd);
       if( (pRangeEnd->wtFlags & TERM_VNULL)==0
        && sqlite3ExprCanBeNull(pRight)
       ){

@@ -118546,7 +119641,8 @@ static Bitmask codeOneLoopStart(

     */
     wctrlFlags =  WHERE_OMIT_OPEN_CLOSE
                 | WHERE_FORCE_TABLE
                 | WHERE_ONETABLE_ONLY;
                 | WHERE_ONETABLE_ONLY
                 | WHERE_NO_AUTOINDEX;
     for(ii=0; ii<pOrWc->nTerm; ii++){
       WhereTerm *pOrTerm = &pOrWc->a[ii];
       if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){

@@ -118708,6 +119804,7 @@ static Bitmask codeOneLoopStart(

   */
   for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
     Expr *pE;
     int skipLikeAddr = 0;
     testcase( pTerm->wtFlags & TERM_VIRTUAL );
     testcase( pTerm->wtFlags & TERM_CODED );
     if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;

@@ -118722,7 +119819,13 @@ static Bitmask codeOneLoopStart(

     if( pLevel->iLeftJoin && !ExprHasProperty(pE, EP_FromJoin) ){
       continue;
     }
     if( pTerm->wtFlags & TERM_LIKECOND ){
       assert( pLevel->iLikeRepCntr>0 );
       skipLikeAddr = sqlite3VdbeAddOp1(v, OP_IfNot, pLevel->iLikeRepCntr);
       VdbeCoverage(v);
     }
     sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
     if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr);
     pTerm->wtFlags |= TERM_CODED;
   }

@@ -119387,6 +120490,10 @@ static int whereLoopAddBtreeIndex(

     }
     if( pTerm->prereqRight & pNew->maskSelf ) continue;
     /* Do not allow the upper bound of a LIKE optimization range constraint
     ** to mix with a lower range bound from some other source */
     if( pTerm->wtFlags & TERM_LIKEOPT && pTerm->eOperator==WO_LT ) continue;
     pNew->wsFlags = saved_wsFlags;
     pNew->u.btree.nEq = saved_nEq;
     pNew->nLTerm = saved_nLTerm;

@@ -119430,6 +120537,17 @@ static int whereLoopAddBtreeIndex(

       pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT;
       pBtm = pTerm;
       pTop = 0;
       if( pTerm->wtFlags & TERM_LIKEOPT ){
         /* Range contraints that come from the LIKE optimization are
         ** always used in pairs. */
         pTop = &pTerm[1];
         assert( (pTop-(pTerm->pWC->a))<pTerm->pWC->nTerm );
         assert( pTop->wtFlags & TERM_LIKEOPT );
         assert( pTop->eOperator==WO_LT );
         if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */
         pNew->aLTerm[pNew->nLTerm++] = pTop;
         pNew->wsFlags |= WHERE_TOP_LIMIT;
       }
     }else{
       assert( eOp & (WO_LT|WO_LE) );
       testcase( eOp & WO_LT );

@@ -119631,7 +120749,12 @@ static int whereUsablePartialIndex(int iTab, WhereClause *pWC, Expr *pWhere){

   int i;
   WhereTerm *pTerm;
   for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
     if( sqlite3ExprImpliesExpr(pTerm->pExpr, pWhere, iTab) ) return 1;
     Expr *pExpr = pTerm->pExpr;
     if( sqlite3ExprImpliesExpr(pExpr, pWhere, iTab)
      && (!ExprHasProperty(pExpr, EP_FromJoin) || pExpr->iRightJoinTable==iTab)
     ){
       return 1;
     }
   }
   return 0;
 }

@@ -119735,6 +120858,7 @@ static int whereLoopAddBtree(

 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
   /* Automatic indexes */
   if( !pBuilder->pOrSet
    && (pWInfo->wctrlFlags & WHERE_NO_AUTOINDEX)==0
    && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
    && pSrc->pIndex==0
    && !pSrc->viaCoroutine

@@ -120618,10 +121742,10 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){

   /* Seed the search with a single WherePath containing zero WhereLoops.
   **
   ** TUNING: Do not let the number of iterations go above 25.  If the cost
   ** of computing an automatic index is not paid back within the first 25
   ** TUNING: Do not let the number of iterations go above 28.  If the cost
   ** of computing an automatic index is not paid back within the first 28
   ** rows, then do not use the automatic index. */
   aFrom[0].nRow = MIN(pParse->nQueryLoop, 46);  assert( 46==sqlite3LogEst(25) );
   aFrom[0].nRow = MIN(pParse->nQueryLoop, 48);  assert( 48==sqlite3LogEst(28) );
   nFrom = 1;
   assert( aFrom[0].isOrdered==0 );
   if( nOrderBy ){

@@ -121419,6 +122543,12 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(

       if( op ){
         sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
         sqlite3VdbeSetP4KeyInfo(pParse, pIx);
         if( (pLoop->wsFlags & WHERE_CONSTRAINT)!=0
          && (pLoop->wsFlags & (WHERE_COLUMN_RANGE|WHERE_SKIPSCAN))==0
          && (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0
         ){
           sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ); /* Hint to COMDB2 */
         }
         VdbeComment((v, "%s", pIx->zName));
       }
     }

@@ -121520,6 +122650,16 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){

       sqlite3VdbeJumpHere(v, pLevel->addrSkip);
       sqlite3VdbeJumpHere(v, pLevel->addrSkip-2);
     }
     if( pLevel->addrLikeRep ){
       int op;
       if( sqlite3VdbeGetOp(v, pLevel->addrLikeRep-1)->p1 ){
         op = OP_DecrJumpZero;
       }else{
         op = OP_JumpZeroIncr;
       }
       sqlite3VdbeAddOp2(v, op, pLevel->iLikeRepCntr, pLevel->addrLikeRep);
       VdbeCoverage(v);
     }
     if( pLevel->iLeftJoin ){
       addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
       assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0

@@ -124410,7 +125550,7 @@ static void yy_reduce(

         break;
       case 193: /* expr ::= expr COLLATE ID|STRING */
 {
   yygotominor.yy346.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0);
   yygotominor.yy346.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0, 1);
   yygotominor.yy346.zStart = yymsp[-2].minor.yy346.zStart;
   yygotominor.yy346.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
 }

@@ -124573,7 +125713,7 @@ static void yy_reduce(

       yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
       if( yygotominor.yy346.pExpr ){
         yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy14;
         sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
         sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr);
       }else{
         sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
       }

@@ -124588,8 +125728,8 @@ static void yy_reduce(

     yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
     if( yygotominor.yy346.pExpr ){
       yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect|EP_Subquery);
       sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr);
     }else{
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
     }

@@ -124602,8 +125742,8 @@ static void yy_reduce(

     yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
     if( yygotominor.yy346.pExpr ){
       yygotominor.yy346.pExpr->x.pSelect = yymsp[-1].minor.yy3;
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect|EP_Subquery);
       sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr);
     }else{
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
     }

@@ -124618,8 +125758,8 @@ static void yy_reduce(

     yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0);
     if( yygotominor.yy346.pExpr ){
       yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
       ExprSetProperty(yygotominor.yy346.pExpr, EP_xIsSelect|EP_Subquery);
       sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr);
     }else{
       sqlite3SrcListDelete(pParse->db, pSrc);
     }

@@ -124633,8 +125773,8 @@ static void yy_reduce(

     Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
     if( p ){
       p->x.pSelect = yymsp[-1].minor.yy3;
       ExprSetProperty(p, EP_xIsSelect);
       sqlite3ExprSetHeight(pParse, p);
       ExprSetProperty(p, EP_xIsSelect|EP_Subquery);
       sqlite3ExprSetHeightAndFlags(pParse, p);
     }else{
       sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
     }

@@ -124647,7 +125787,7 @@ static void yy_reduce(

   yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, 0, 0);
   if( yygotominor.yy346.pExpr ){
     yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy132 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy132) : yymsp[-2].minor.yy14;
     sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
     sqlite3ExprSetHeightAndFlags(pParse, yygotominor.yy346.pExpr);
   }else{
     sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
     sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy132);

@@ -124690,7 +125830,7 @@ static void yy_reduce(

         break;
       case 244: /* idxlist ::= idxlist COMMA nm collate sortorder */
 {
   Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0);
   Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0, 1);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, p);
   sqlite3ExprListSetName(pParse,yygotominor.yy14,&yymsp[-2].minor.yy0,1);
   sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");

@@ -124699,7 +125839,7 @@ static void yy_reduce(

         break;
       case 245: /* idxlist ::= nm collate sortorder */
 {
   Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0);
   Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0, 1);
   yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, p);
   sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
   sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");

@@ -125889,10 +127029,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr

   sqlite3 *db = pParse->db;       /* The database connection */
   int mxSqlLen;                   /* Max length of an SQL string */
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( zSql==0 || pzErrMsg==0 ) return SQLITE_MISUSE_BKPT;
 #endif
   assert( zSql!=0 );
   mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
   if( db->nVdbeActive==0 ){
     db->u1.isInterrupted = 0;

@@ -125961,9 +127098,11 @@ abort_parse:

     sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse);
   }
 #ifdef YYTRACKMAXSTACKDEPTH
   sqlite3_mutex_enter(sqlite3MallocMutex());
   sqlite3StatusSet(SQLITE_STATUS_PARSER_STACK,
       sqlite3ParserStackPeak(pEngine)
   );
   sqlite3_mutex_leave(sqlite3MallocMutex());
 #endif /* YYDEBUG */
   sqlite3ParserFree(pEngine, sqlite3_free);
   db->lookaside.bEnabled = enableLookaside;

@@ -126127,7 +127266,7 @@ SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[];

 ** to recognize the end of a trigger can be omitted.  All we have to do
 ** is look for a semicolon that is not part of an string or comment.
 */
 SQLITE_API int sqlite3_complete(const char *zSql){
 SQLITE_API int SQLITE_STDCALL sqlite3_complete(const char *zSql){
   u8 state = 0;   /* Current state, using numbers defined in header comment */
   u8 token;       /* Value of the next token */

@@ -126292,7 +127431,7 @@ SQLITE_API int sqlite3_complete(const char *zSql){

 ** above, except that the parameter is required to be UTF-16 encoded, not
 ** UTF-8.
 */
 SQLITE_API int sqlite3_complete16(const void *zSql){
 SQLITE_API int SQLITE_STDCALL sqlite3_complete16(const void *zSql){
   sqlite3_value *pVal;
   char const *zSql8;
   int rc = SQLITE_NOMEM;

@@ -126442,24 +127581,24 @@ SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;

 /* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
 ** a pointer to the to the sqlite3_version[] string constant.
 */
 SQLITE_API const char *sqlite3_libversion(void){ return sqlite3_version; }
 SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion(void){ return sqlite3_version; }
 /* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a
 ** pointer to a string constant whose value is the same as the
 ** SQLITE_SOURCE_ID C preprocessor macro.
 */
 SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
 SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
 /* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
 ** returns an integer equal to SQLITE_VERSION_NUMBER.
 */
 SQLITE_API int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
 SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
 /* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
 ** zero if and only if SQLite was compiled with mutexing code omitted due to
 ** the SQLITE_THREADSAFE compile-time option being set to 0.
 */
 SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
 SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
 /*

@@ -126468,7 +127607,7 @@ SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }

 ** I/O active are written using this function.  These messages
 ** are intended for debugging activity only.
 */
 /* not-private */ void (*sqlite3IoTrace)(const char*, ...) = 0;
 SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0;
 #endif
 /*

@@ -126520,7 +127659,7 @@ SQLITE_API char *sqlite3_data_directory = 0;

 **    *  Recursive calls to this routine from thread X return immediately
 **       without blocking.
 */
 SQLITE_API int sqlite3_initialize(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_initialize(void){
   MUTEX_LOGIC( sqlite3_mutex *pMaster; )       /* The main static mutex */
   int rc;                                      /* Result code */
 #ifdef SQLITE_EXTRA_INIT

@@ -126534,6 +127673,11 @@ SQLITE_API int sqlite3_initialize(void){

   }
 #endif
   /* If the following assert() fails on some obscure processor/compiler
   ** combination, the work-around is to set the correct pointer
   ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
   assert( SQLITE_PTRSIZE==sizeof(char*) );
   /* If SQLite is already completely initialized, then this call
   ** to sqlite3_initialize() should be a no-op.  But the initialization
   ** must be complete.  So isInit must not be set until the very end

@@ -126676,7 +127820,7 @@ SQLITE_API int sqlite3_initialize(void){

 ** on when SQLite is already shut down.  If SQLite is already shut down
 ** when this routine is invoked, then this routine is a harmless no-op.
 */
 SQLITE_API int sqlite3_shutdown(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_shutdown(void){
 #ifdef SQLITE_OMIT_WSD
   int rc = sqlite3_wsd_init(4096, 24);
   if( rc!=SQLITE_OK ){

@@ -126730,7 +127874,7 @@ SQLITE_API int sqlite3_shutdown(void){

 ** threadsafe.  Failure to heed these warnings can lead to unpredictable
 ** behavior.
 */
 SQLITE_API int sqlite3_config(int op, ...){
 SQLITE_API int SQLITE_CDECL sqlite3_config(int op, ...){
   va_list ap;
   int rc = SQLITE_OK;

@@ -126746,26 +127890,28 @@ SQLITE_API int sqlite3_config(int op, ...){

     */
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0  /* IMP: R-54466-46756 */
     case SQLITE_CONFIG_SINGLETHREAD: {
       /* Disable all mutexing */
       sqlite3GlobalConfig.bCoreMutex = 0;
       sqlite3GlobalConfig.bFullMutex = 0;
       /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
       ** Single-thread. */
       sqlite3GlobalConfig.bCoreMutex = 0;  /* Disable mutex on core */
       sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
     case SQLITE_CONFIG_MULTITHREAD: {
       /* Disable mutexing of database connections */
       /* Enable mutexing of core data structures */
       sqlite3GlobalConfig.bCoreMutex = 1;
       sqlite3GlobalConfig.bFullMutex = 0;
       /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
       ** Multi-thread. */
       sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
       sqlite3GlobalConfig.bFullMutex = 0;  /* Disable mutex on connections */
       break;
     }
 #endif
 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
     case SQLITE_CONFIG_SERIALIZED: {
       /* Enable all mutexing */
       sqlite3GlobalConfig.bCoreMutex = 1;
       sqlite3GlobalConfig.bFullMutex = 1;
       /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
       ** Serialized. */
       sqlite3GlobalConfig.bCoreMutex = 1;  /* Enable mutex on core */
       sqlite3GlobalConfig.bFullMutex = 1;  /* Enable mutex on connections */
       break;
     }
 #endif

@@ -126877,7 +128023,8 @@ SQLITE_API int sqlite3_config(int op, ...){

     case SQLITE_CONFIG_HEAP: {
       /* EVIDENCE-OF: R-19854-42126 There are three arguments to
       ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
       ** number of bytes in the memory buffer, and the minimum allocation size. */
       ** number of bytes in the memory buffer, and the minimum allocation size.
       */
       sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
       sqlite3GlobalConfig.nHeap = va_arg(ap, int);
       sqlite3GlobalConfig.mnReq = va_arg(ap, int);

@@ -126982,7 +128129,9 @@ SQLITE_API int sqlite3_config(int op, ...){

       ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
       ** compile-time option.
       */
       if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ) mxMmap = SQLITE_MAX_MMAP_SIZE;
       if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
         mxMmap = SQLITE_MAX_MMAP_SIZE;
       }
       if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
       if( szMmap>mxMmap) szMmap = mxMmap;
       sqlite3GlobalConfig.mxMmap = mxMmap;

@@ -127082,7 +128231,7 @@ static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){

 /*
 ** Return the mutex associated with a database connection.
 */
 SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){
 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;

@@ -127096,7 +128245,7 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){

 ** Free up as much memory as we can from the given database
 ** connection.
 */
 SQLITE_API int sqlite3_db_release_memory(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3 *db){
   int i;
 #ifdef SQLITE_ENABLE_API_ARMOR

@@ -127119,7 +128268,7 @@ SQLITE_API int sqlite3_db_release_memory(sqlite3 *db){

 /*
 ** Configuration settings for an individual database connection
 */
 SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
 SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3 *db, int op, ...){
   va_list ap;
   int rc;
   va_start(ap, op);

@@ -127238,7 +128387,7 @@ static int nocaseCollatingFunc(

 /*
 ** Return the ROWID of the most recent insert
 */
 SQLITE_API sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
 SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;

@@ -127251,7 +128400,7 @@ SQLITE_API sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){

 /*
 ** Return the number of changes in the most recent call to sqlite3_exec().
 */
 SQLITE_API int sqlite3_changes(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;

@@ -127264,7 +128413,7 @@ SQLITE_API int sqlite3_changes(sqlite3 *db){

 /*
 ** Return the number of changes since the database handle was opened.
 */
 SQLITE_API int sqlite3_total_changes(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;

@@ -127406,8 +128555,8 @@ static int sqlite3Close(sqlite3 *db, int forceZombie){

 ** unclosed resources, and arranges for deallocation when the last
 ** prepare statement or sqlite3_backup closes.
 */
 SQLITE_API int sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); }
 SQLITE_API int sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); }
 SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); }
 SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); }
 /*

@@ -127814,13 +128963,13 @@ SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){

 ** This routine sets the busy callback for an Sqlite database to the
 ** given callback function with the given argument.
 */
 SQLITE_API int sqlite3_busy_handler(
 SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler(
   sqlite3 *db,
   int (*xBusy)(void*,int),
   void *pArg
 ){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE;
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
   db->busyHandler.xFunc = xBusy;

@@ -127837,7 +128986,7 @@ SQLITE_API int sqlite3_busy_handler(

 ** given callback function with the given argument. The progress callback will
 ** be invoked every nOps opcodes.
 */
 SQLITE_API void sqlite3_progress_handler(
 SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler(
   sqlite3 *db,
   int nOps,
   int (*xProgress)(void*),

@@ -127868,7 +129017,7 @@ SQLITE_API void sqlite3_progress_handler(

 ** This routine installs a default busy handler that waits for the
 ** specified number of milliseconds before returning 0.
 */
 SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){
 SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3 *db, int ms){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif

@@ -127884,7 +129033,7 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){

 /*
 ** Cause any pending operation to stop at its earliest opportunity.
 */
 SQLITE_API void sqlite3_interrupt(sqlite3 *db){
 SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;

@@ -128001,7 +129150,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc(

 /*
 ** Create new user functions.
 */
 SQLITE_API int sqlite3_create_function(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function(
   sqlite3 *db,
   const char *zFunc,
   int nArg,

@@ -128015,7 +129164,7 @@ SQLITE_API int sqlite3_create_function(

                                     xFinal, 0);
 }
 SQLITE_API int sqlite3_create_function_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2(
   sqlite3 *db,
   const char *zFunc,
   int nArg,

@@ -128058,7 +129207,7 @@ SQLITE_API int sqlite3_create_function_v2(

 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API int sqlite3_create_function16(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function16(
   sqlite3 *db,
   const void *zFunctionName,
   int nArg,

@@ -128098,7 +129247,7 @@ SQLITE_API int sqlite3_create_function16(

 ** A global function must exist in order for name resolution to work
 ** properly.
 */
 SQLITE_API int sqlite3_overload_function(
 SQLITE_API int SQLITE_STDCALL sqlite3_overload_function(
   sqlite3 *db,
   const char *zName,
   int nArg

@@ -128130,7 +129279,7 @@ SQLITE_API int sqlite3_overload_function(

 ** trace is a pointer to a function that is invoked at the start of each
 ** SQL statement.
 */
 SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
 SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
   void *pOld;
 #ifdef SQLITE_ENABLE_API_ARMOR

@@ -128154,7 +129303,7 @@ SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), v

 ** profile is a pointer to a function that is invoked at the conclusion of
 ** each SQL statement that is run.
 */
 SQLITE_API void *sqlite3_profile(
 SQLITE_API void *SQLITE_STDCALL sqlite3_profile(
   sqlite3 *db,
   void (*xProfile)(void*,const char*,sqlite_uint64),
   void *pArg

@@ -128181,7 +129330,7 @@ SQLITE_API void *sqlite3_profile(

 ** If the invoked function returns non-zero, then the commit becomes a
 ** rollback.
 */
 SQLITE_API void *sqlite3_commit_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook(
   sqlite3 *db,              /* Attach the hook to this database */
   int (*xCallback)(void*),  /* Function to invoke on each commit */
   void *pArg                /* Argument to the function */

@@ -128206,7 +129355,7 @@ SQLITE_API void *sqlite3_commit_hook(

 ** Register a callback to be invoked each time a row is updated,
 ** inserted or deleted using this database connection.
 */
 SQLITE_API void *sqlite3_update_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook(
   sqlite3 *db,              /* Attach the hook to this database */
   void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
   void *pArg                /* Argument to the function */

@@ -128231,7 +129380,7 @@ SQLITE_API void *sqlite3_update_hook(

 ** Register a callback to be invoked each time a transaction is rolled
 ** back by this database connection.
 */
 SQLITE_API void *sqlite3_rollback_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook(
   sqlite3 *db,              /* Attach the hook to this database */
   void (*xCallback)(void*), /* Callback function */
   void *pArg                /* Argument to the function */

@@ -128285,7 +129434,7 @@ SQLITE_PRIVATE int sqlite3WalDefaultHook(

 ** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
 ** configured by this function.
 */
 SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
 #ifdef SQLITE_OMIT_WAL
   UNUSED_PARAMETER(db);
   UNUSED_PARAMETER(nFrame);

@@ -128306,7 +129455,7 @@ SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){

 ** Register a callback to be invoked each time a transaction is written
 ** into the write-ahead-log by this database connection.
 */
 SQLITE_API void *sqlite3_wal_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook(
   sqlite3 *db,                    /* Attach the hook to this db handle */
   int(*xCallback)(void *, sqlite3*, const char*, int),
   void *pArg                      /* First argument passed to xCallback() */

@@ -128333,7 +129482,7 @@ SQLITE_API void *sqlite3_wal_hook(

 /*
 ** Checkpoint database zDb.
 */
 SQLITE_API int sqlite3_wal_checkpoint_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2(
   sqlite3 *db,                    /* Database handle */
   const char *zDb,                /* Name of attached database (or NULL) */
   int eMode,                      /* SQLITE_CHECKPOINT_* value */

@@ -128388,7 +129537,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(

 ** to contains a zero-length string, all attached databases are
 ** checkpointed.
 */
 SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
   /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to
   ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */
   return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0);

@@ -128477,7 +129626,7 @@ SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3 *db){

 ** Return UTF-8 encoded English language explanation of the most recent
 ** error.
 */
 SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3 *db){
   const char *z;
   if( !db ){
     return sqlite3ErrStr(SQLITE_NOMEM);

@@ -128505,7 +129654,7 @@ SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){

 ** Return UTF-16 encoded English language explanation of the most recent
 ** error.
 */
 SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){
 SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3 *db){
   static const u16 outOfMem[] = {
     'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
   };

@@ -128550,7 +129699,7 @@ SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){

 ** Return the most recent error code generated by an SQLite routine. If NULL is
 ** passed to this function, we assume a malloc() failed during sqlite3_open().
 */
 SQLITE_API int sqlite3_errcode(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db){
   if( db && !sqlite3SafetyCheckSickOrOk(db) ){
     return SQLITE_MISUSE_BKPT;
   }

@@ -128559,7 +129708,7 @@ SQLITE_API int sqlite3_errcode(sqlite3 *db){

   }
   return db->errCode & db->errMask;
 }
 SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db){
   if( db && !sqlite3SafetyCheckSickOrOk(db) ){
     return SQLITE_MISUSE_BKPT;
   }

@@ -128574,7 +129723,7 @@ SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){

 ** argument.  For now, this simply calls the internal sqlite3ErrStr()
 ** function.
 */
 SQLITE_API const char *sqlite3_errstr(int rc){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr(int rc){
   return sqlite3ErrStr(rc);
 }

@@ -128722,7 +129871,7 @@ static const int aHardLimit[] = {

 ** It merely prevents new constructs that exceed the limit
 ** from forming.
 */
 SQLITE_API int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
 SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
   int oldLimit;
 #ifdef SQLITE_ENABLE_API_ARMOR

@@ -128826,7 +129975,19 @@ SQLITE_PRIVATE int sqlite3ParseUri(

     if( !zFile ) return SQLITE_NOMEM;
     iIn = 5;
 #ifndef SQLITE_ALLOW_URI_AUTHORITY
 #ifdef SQLITE_ALLOW_URI_AUTHORITY
     if( strncmp(zUri+5, "///", 3)==0 ){
       iIn = 7;
       /* The following condition causes URIs with five leading / characters
       ** like file://///host/path to be converted into UNCs like //host/path.
       ** The correct URI for that UNC has only two or four leading / characters
       ** file://host/path or file:////host/path.  But 5 leading slashes is a
       ** common error, we are told, so we handle it as a special case. */
       if( strncmp(zUri+7, "///", 3)==0 ){ iIn++; }
     }else if( strncmp(zUri+5, "//localhost/", 12)==0 ){
       iIn = 16;
     }
 #else
     /* Discard the scheme and authority segments of the URI. */
     if( zUri[5]=='/' && zUri[6]=='/' ){
       iIn = 7;

@@ -129113,6 +130274,9 @@ static int openDatabase(

 #if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX
                  | SQLITE_AutoIndex
 #endif
 #if SQLITE_DEFAULT_CKPTFULLFSYNC
                  | SQLITE_CkptFullFSync
 #endif
 #if SQLITE_DEFAULT_FILE_FORMAT<4
                  | SQLITE_LegacyFileFmt
 #endif

@@ -129266,7 +130430,8 @@ static int openDatabase(

 opendb_out:
   sqlite3_free(zOpen);
   if( db ){
     assert( db->mutex!=0 || isThreadsafe==0 || sqlite3GlobalConfig.bFullMutex==0 );
     assert( db->mutex!=0 || isThreadsafe==0
            || sqlite3GlobalConfig.bFullMutex==0 );
     sqlite3_mutex_leave(db->mutex);
   }
   rc = sqlite3_errcode(db);

@@ -129291,14 +130456,14 @@ opendb_out:

 /*
 ** Open a new database handle.
 */
 SQLITE_API int sqlite3_open(
 SQLITE_API int SQLITE_STDCALL sqlite3_open(
   const char *zFilename,
   sqlite3 **ppDb
 ){
   return openDatabase(zFilename, ppDb,
                       SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
 }
 SQLITE_API int sqlite3_open_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_open_v2(
   const char *filename,   /* Database filename (UTF-8) */
   sqlite3 **ppDb,         /* OUT: SQLite db handle */
   int flags,              /* Flags */

@@ -129311,7 +130476,7 @@ SQLITE_API int sqlite3_open_v2(

 /*
 ** Open a new database handle.
 */
 SQLITE_API int sqlite3_open16(
 SQLITE_API int SQLITE_STDCALL sqlite3_open16(
   const void *zFilename,
   sqlite3 **ppDb
 ){

@@ -129350,7 +130515,7 @@ SQLITE_API int sqlite3_open16(

 /*
 ** Register a new collation sequence with the database handle db.
 */
 SQLITE_API int sqlite3_create_collation(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation(
   sqlite3* db,
   const char *zName,
   int enc,

@@ -129363,7 +130528,7 @@ SQLITE_API int sqlite3_create_collation(

 /*
 ** Register a new collation sequence with the database handle db.
 */
 SQLITE_API int sqlite3_create_collation_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2(
   sqlite3* db,
   const char *zName,
   int enc,

@@ -129388,7 +130553,7 @@ SQLITE_API int sqlite3_create_collation_v2(

 /*
 ** Register a new collation sequence with the database handle db.
 */
 SQLITE_API int sqlite3_create_collation16(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16(
   sqlite3* db,
   const void *zName,
   int enc,

@@ -129418,7 +130583,7 @@ SQLITE_API int sqlite3_create_collation16(

 ** Register a collation sequence factory callback with the database handle
 ** db. Replace any previously installed collation sequence factory.
 */
 SQLITE_API int sqlite3_collation_needed(
 SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed(
   sqlite3 *db,
   void *pCollNeededArg,
   void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)

@@ -129439,7 +130604,7 @@ SQLITE_API int sqlite3_collation_needed(

 ** Register a collation sequence factory callback with the database handle
 ** db. Replace any previously installed collation sequence factory.
 */
 SQLITE_API int sqlite3_collation_needed16(
 SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16(
   sqlite3 *db,
   void *pCollNeededArg,
   void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)

@@ -129461,7 +130626,7 @@ SQLITE_API int sqlite3_collation_needed16(

 ** This function is now an anachronism. It used to be used to recover from a
 ** malloc() failure, but SQLite now does this automatically.
 */
 SQLITE_API int sqlite3_global_recover(void){
 SQLITE_API int SQLITE_STDCALL sqlite3_global_recover(void){
   return SQLITE_OK;
 }
 #endif

@@ -129472,7 +130637,7 @@ SQLITE_API int sqlite3_global_recover(void){

 ** by default.  Autocommit is disabled by a BEGIN statement and reenabled
 ** by the next COMMIT or ROLLBACK.
 */
 SQLITE_API int sqlite3_get_autocommit(sqlite3 *db){
 SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3 *db){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){
     (void)SQLITE_MISUSE_BKPT;

@@ -129524,7 +130689,7 @@ SQLITE_PRIVATE int sqlite3CantopenError(int lineno){

 ** SQLite no longer uses thread-specific data so this routine is now a
 ** no-op.  It is retained for historical compatibility.
 */
 SQLITE_API void sqlite3_thread_cleanup(void){
 SQLITE_API void SQLITE_STDCALL sqlite3_thread_cleanup(void){
 }
 #endif

@@ -129532,7 +130697,7 @@ SQLITE_API void sqlite3_thread_cleanup(void){

 ** Return meta information about a specific column of a database table.
 ** See comment in sqlite3.h (sqlite.h.in) for details.
 */
 SQLITE_API int sqlite3_table_column_metadata(
 SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata(
   sqlite3 *db,                /* Connection handle */
   const char *zDbName,        /* Database name or NULL */
   const char *zTableName,     /* Table name */

@@ -129548,13 +130713,19 @@ SQLITE_API int sqlite3_table_column_metadata(

   Table *pTab = 0;
   Column *pCol = 0;
   int iCol = 0;
   char const *zDataType = 0;
   char const *zCollSeq = 0;
   int notnull = 0;
   int primarykey = 0;
   int autoinc = 0;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
     return SQLITE_MISUSE_BKPT;
   }
 #endif
   /* Ensure the database schema has been loaded */
   sqlite3_mutex_enter(db->mutex);
   sqlite3BtreeEnterAll(db);

@@ -129644,7 +130815,7 @@ error_out:

 /*
 ** Sleep for a little while.  Return the amount of time slept.
 */
 SQLITE_API int sqlite3_sleep(int ms){
 SQLITE_API int SQLITE_STDCALL sqlite3_sleep(int ms){
   sqlite3_vfs *pVfs;
   int rc;
   pVfs = sqlite3_vfs_find(0);

@@ -129660,7 +130831,7 @@ SQLITE_API int sqlite3_sleep(int ms){

 /*
 ** Enable or disable the extended result codes.
 */
 SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
 SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3 *db, int onoff){
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif

@@ -129673,7 +130844,7 @@ SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){

 /*
 ** Invoke the xFileControl method on a particular database.
 */
 SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
 SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
   int rc = SQLITE_ERROR;
   Btree *pBtree;

@@ -129701,13 +130872,13 @@ SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, vo

     sqlite3BtreeLeave(pBtree);
   }
   sqlite3_mutex_leave(db->mutex);
   return rc;
   return rc;
 }
 /*
 ** Interface to the testing logic.
 */
 SQLITE_API int sqlite3_test_control(int op, ...){
 SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...){
   int rc = 0;
 #ifndef SQLITE_OMIT_BUILTIN_TEST
   va_list ap;

@@ -130004,6 +131175,35 @@ SQLITE_API int sqlite3_test_control(int op, ...){

       if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
       break;
     }
     /*  sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
     **
     ** This test control is used to create imposter tables.  "db" is a pointer
     ** to the database connection.  dbName is the database name (ex: "main" or
     ** "temp") which will receive the imposter.  "onOff" turns imposter mode on
     ** or off.  "tnum" is the root page of the b-tree to which the imposter
     ** table should connect.
     **
     ** Enable imposter mode only when the schema has already been parsed.  Then
     ** run a single CREATE TABLE statement to construct the imposter table in
     ** the parsed schema.  Then turn imposter mode back off again.
     **
     ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
     ** the schema to be reparsed the next time it is needed.  This has the
     ** effect of erasing all imposter tables.
     */
     case SQLITE_TESTCTRL_IMPOSTER: {
       sqlite3 *db = va_arg(ap, sqlite3*);
       sqlite3_mutex_enter(db->mutex);
       db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
       db->init.busy = db->init.imposterTable = va_arg(ap,int);
       db->init.newTnum = va_arg(ap,int);
       if( db->init.busy==0 && db->init.newTnum>0 ){
         sqlite3ResetAllSchemasOfConnection(db);
       }
       sqlite3_mutex_leave(db->mutex);
       break;
     }
   }
   va_end(ap);
 #endif /* SQLITE_OMIT_BUILTIN_TEST */

@@ -130021,7 +131221,7 @@ SQLITE_API int sqlite3_test_control(int op, ...){

 ** parameter if it exists.  If the parameter does not exist, this routine
 ** returns a NULL pointer.
 */
 SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam){
   if( zFilename==0 || zParam==0 ) return 0;
   zFilename += sqlite3Strlen30(zFilename) + 1;
   while( zFilename[0] ){

@@ -130036,7 +131236,7 @@ SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *

 /*
 ** Return a boolean value for a query parameter.
 */
 SQLITE_API int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){
 SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){
   const char *z = sqlite3_uri_parameter(zFilename, zParam);
   bDflt = bDflt!=0;
   return z ? sqlite3GetBoolean(z, bDflt) : bDflt;

@@ -130045,7 +131245,7 @@ SQLITE_API int sqlite3_uri_boolean(const char *zFilename, const char *zParam, in

 /*
 ** Return a 64-bit integer value for a query parameter.
 */
 SQLITE_API sqlite3_int64 sqlite3_uri_int64(
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64(
   const char *zFilename,    /* Filename as passed to xOpen */
   const char *zParam,       /* URI parameter sought */
   sqlite3_int64 bDflt       /* return if parameter is missing */

@@ -130077,7 +131277,7 @@ SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){

 ** Return the filename of the database associated with a database
 ** connection.
 */
 SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){
 SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName){
   Btree *pBt;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){

@@ -130093,7 +131293,7 @@ SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){

 ** Return 1 if database is read-only or 0 if read/write.  Return -1 if
 ** no such database exists.
 */
 SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
 SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
   Btree *pBt;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) ){

@@ -130252,7 +131452,7 @@ static void leaveMutex(void){

 ** on the same "db".  If xNotify==0 then any prior callbacks are immediately
 ** cancelled.
 */
 SQLITE_API int sqlite3_unlock_notify(
 SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify(
   sqlite3 *db,
   void (*xNotify)(void **, int),
   void *pArg

@@ -131387,6 +132587,11 @@ struct Fts3Phrase {

   int bIncr;                 /* True if doclist is loaded incrementally */
   int iDoclistToken;
   /* Used by sqlite3Fts3EvalPhrasePoslist() if this is a descendent of an
   ** OR condition.  */
   char *pOrPoslist;
   i64 iOrDocid;
   /* Variables below this point are populated by fts3_expr.c when parsing
   ** a MATCH expression. Everything above is part of the evaluation phase.
   */

@@ -132227,11 +133432,16 @@ static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){

 ** This function is used when parsing the "prefix=" FTS4 parameter.
 */
 static int fts3GobbleInt(const char **pp, int *pnOut){
   const int MAX_NPREFIX = 10000000;
   const char *p;                  /* Iterator pointer */
   int nInt = 0;                   /* Output value */
   for(p=*pp; p[0]>='0' && p[0]<='9'; p++){
     nInt = nInt * 10 + (p[0] - '0');
     if( nInt>MAX_NPREFIX ){
       nInt = 0;
       break;
     }
   }
   if( p==*pp ) return SQLITE_ERROR;
   *pnOut = nInt;

@@ -132274,7 +133484,6 @@ static int fts3PrefixParameter(

   aIndex = sqlite3_malloc(sizeof(struct Fts3Index) * nIndex);
   *apIndex = aIndex;
   *pnIndex = nIndex;
   if( !aIndex ){
     return SQLITE_NOMEM;
   }

@@ -132284,13 +133493,20 @@ static int fts3PrefixParameter(

     const char *p = zParam;
     int i;
     for(i=1; i<nIndex; i++){
       int nPrefix;
       int nPrefix = 0;
       if( fts3GobbleInt(&p, &nPrefix) ) return SQLITE_ERROR;
       aIndex[i].nPrefix = nPrefix;
       assert( nPrefix>=0 );
       if( nPrefix==0 ){
         nIndex--;
         i--;
       }else{
         aIndex[i].nPrefix = nPrefix;
       }
       p++;
     }
   }
   *pnIndex = nIndex;
   return SQLITE_OK;
 }

@@ -132414,7 +133630,7 @@ static int fts3InitVtab(

   const char **aCol;              /* Array of column names */
   sqlite3_tokenizer *pTokenizer = 0;        /* Tokenizer for this table */
   int nIndex;                     /* Size of aIndex[] array */
   int nIndex = 0;                 /* Size of aIndex[] array */
   struct Fts3Index *aIndex = 0;   /* Array of indexes for this table */
   /* The results of parsing supported FTS4 key=value options: */

@@ -133808,26 +135024,33 @@ static int fts3DoclistOrMerge(

 **
 ** The right-hand input doclist is overwritten by this function.
 */
 static void fts3DoclistPhraseMerge(
 static int fts3DoclistPhraseMerge(
   int bDescDoclist,               /* True if arguments are desc */
   int nDist,                      /* Distance from left to right (1=adjacent) */
   char *aLeft, int nLeft,         /* Left doclist */
   char *aRight, int *pnRight      /* IN/OUT: Right/output doclist */
   char **paRight, int *pnRight    /* IN/OUT: Right/output doclist */
 ){
   sqlite3_int64 i1 = 0;
   sqlite3_int64 i2 = 0;
   sqlite3_int64 iPrev = 0;
   char *aRight = *paRight;
   char *pEnd1 = &aLeft[nLeft];
   char *pEnd2 = &aRight[*pnRight];
   char *p1 = aLeft;
   char *p2 = aRight;
   char *p;
   int bFirstOut = 0;
   char *aOut = aRight;
   char *aOut;
   assert( nDist>0 );
   if( bDescDoclist ){
     aOut = sqlite3_malloc(*pnRight + FTS3_VARINT_MAX);
     if( aOut==0 ) return SQLITE_NOMEM;
   }else{
     aOut = aRight;
   }
   p = aOut;
   fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1);
   fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);

@@ -133856,6 +135079,12 @@ static void fts3DoclistPhraseMerge(

   }
   *pnRight = (int)(p - aOut);
   if( bDescDoclist ){
     sqlite3_free(aRight);
     *paRight = aOut;
   }
   return SQLITE_OK;
 }
 /*

@@ -133980,8 +135209,22 @@ static int fts3TermSelectMerge(

 ){
   if( pTS->aaOutput[0]==0 ){
     /* If this is the first term selected, copy the doclist to the output
     ** buffer using memcpy(). */
     pTS->aaOutput[0] = sqlite3_malloc(nDoclist);
     ** buffer using memcpy().
     **
     ** Add FTS3_VARINT_MAX bytes of unused space to the end of the
     ** allocation. This is so as to ensure that the buffer is big enough
     ** to hold the current doclist AND'd with any other doclist. If the
     ** doclists are stored in order=ASC order, this padding would not be
     ** required (since the size of [doclistA AND doclistB] is always less
     ** than or equal to the size of [doclistA] in that case). But this is
     ** not true for order=DESC. For example, a doclist containing (1, -1)
     ** may be smaller than (-1), as in the first example the -1 may be stored
     ** as a single-byte delta, whereas in the second it must be stored as a
     ** FTS3_VARINT_MAX byte varint.
     **
     ** Similar padding is added in the fts3DoclistOrMerge() function.
     */
     pTS->aaOutput[0] = sqlite3_malloc(nDoclist + FTS3_VARINT_MAX + 1);
     pTS->anOutput[0] = nDoclist;
     if( pTS->aaOutput[0] ){
       memcpy(pTS->aaOutput[0], aDoclist, nDoclist);

@@ -134481,10 +135724,17 @@ static int fts3FilterMethod(

   ** row by docid.
   */
   if( eSearch==FTS3_FULLSCAN_SEARCH ){
     zSql = sqlite3_mprintf(
         "SELECT %s ORDER BY rowid %s",
         p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
     );
     if( pDocidGe || pDocidLe ){
       zSql = sqlite3_mprintf(
           "SELECT %s WHERE rowid BETWEEN %lld AND %lld ORDER BY rowid %s",
           p->zReadExprlist, pCsr->iMinDocid, pCsr->iMaxDocid,
           (pCsr->bDesc ? "DESC" : "ASC")
       );
     }else{
       zSql = sqlite3_mprintf("SELECT %s ORDER BY rowid %s",
           p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
       );
     }
     if( zSql ){
       rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
       sqlite3_free(zSql);

@@ -135230,14 +136480,17 @@ static void fts3EvalAllocateReaders(

 ** This function assumes that pList points to a buffer allocated using
 ** sqlite3_malloc(). This function takes responsibility for eventually
 ** freeing the buffer.
 **
 ** SQLITE_OK is returned if successful, or SQLITE_NOMEM if an error occurs.
 */
 static void fts3EvalPhraseMergeToken(
 static int fts3EvalPhraseMergeToken(
   Fts3Table *pTab,                /* FTS Table pointer */
   Fts3Phrase *p,                  /* Phrase to merge pList/nList into */
   int iToken,                     /* Token pList/nList corresponds to */
   char *pList,                    /* Pointer to doclist */
   int nList                       /* Number of bytes in pList */
 ){
   int rc = SQLITE_OK;
   assert( iToken!=p->iDoclistToken );
   if( pList==0 ){

@@ -135276,13 +136529,16 @@ static void fts3EvalPhraseMergeToken(

       nDiff = p->iDoclistToken - iToken;
     }
     fts3DoclistPhraseMerge(pTab->bDescIdx, nDiff, pLeft, nLeft, pRight,&nRight);
     rc = fts3DoclistPhraseMerge(
         pTab->bDescIdx, nDiff, pLeft, nLeft, &pRight, &nRight
     );
     sqlite3_free(pLeft);
     p->doclist.aAll = pRight;
     p->doclist.nAll = nRight;
   }
   if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken;
   return rc;
 }
 /*

@@ -135308,7 +136564,7 @@ static int fts3EvalPhraseLoad(

       char *pThis = 0;
       rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
       if( rc==SQLITE_OK ){
         fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
         rc = fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
       }
     }
     assert( pToken->pSegcsr==0 );

@@ -136111,8 +137367,12 @@ static int fts3EvalSelectDeferred(

         rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
         assert( rc==SQLITE_OK || pList==0 );
         if( rc==SQLITE_OK ){
           rc = fts3EvalPhraseMergeToken(
               pTab, pTC->pPhrase, pTC->iToken,pList,nList
           );
         }
         if( rc==SQLITE_OK ){
           int nCount;
           fts3EvalPhraseMergeToken(pTab, pTC->pPhrase, pTC->iToken,pList,nList);
           nCount = fts3DoclistCountDocids(
               pTC->pPhrase->doclist.aAll, pTC->pPhrase->doclist.nAll
           );

@@ -136337,6 +137597,22 @@ static void fts3EvalNextRow(

           }
           pExpr->iDocid = pLeft->iDocid;
           pExpr->bEof = (pLeft->bEof || pRight->bEof);
           if( pExpr->eType==FTSQUERY_NEAR && pExpr->bEof ){
             if( pRight->pPhrase && pRight->pPhrase->doclist.aAll ){
               Fts3Doclist *pDl = &pRight->pPhrase->doclist;
               while( *pRc==SQLITE_OK && pRight->bEof==0 ){
                 memset(pDl->pList, 0, pDl->nList);
                 fts3EvalNextRow(pCsr, pRight, pRc);
               }
             }
             if( pLeft->pPhrase && pLeft->pPhrase->doclist.aAll ){
               Fts3Doclist *pDl = &pLeft->pPhrase->doclist;
               while( *pRc==SQLITE_OK && pLeft->bEof==0 ){
                 memset(pDl->pList, 0, pDl->nList);
                 fts3EvalNextRow(pCsr, pLeft, pRc);
               }
             }
           }
         }
         break;
       }

@@ -136709,6 +137985,7 @@ static void fts3EvalRestart(

       }
       pPhrase->doclist.pNextDocid = 0;
       pPhrase->doclist.iDocid = 0;
       pPhrase->pOrPoslist = 0;
     }
     pExpr->iDocid = 0;

@@ -136954,8 +138231,8 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(

   iDocid = pExpr->iDocid;
   pIter = pPhrase->doclist.pList;
   if( iDocid!=pCsr->iPrevId || pExpr->bEof ){
     int rc = SQLITE_OK;
     int bDescDoclist = pTab->bDescIdx;      /* For DOCID_CMP macro */
     int iMul;                     /* +1 if csr dir matches index dir, else -1 */
     int bOr = 0;
     u8 bEof = 0;
     u8 bTreeEof = 0;

@@ -136979,72 +138256,43 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(

     ** an incremental phrase. Load the entire doclist for the phrase
     ** into memory in this case.  */
     if( pPhrase->bIncr ){
       int rc = SQLITE_OK;
       int bEofSave = pExpr->bEof;
       fts3EvalRestart(pCsr, pExpr, &rc);
       while( rc==SQLITE_OK && !pExpr->bEof ){
         fts3EvalNextRow(pCsr, pExpr, &rc);
         if( bEofSave==0 && pExpr->iDocid==iDocid ) break;
       int bEofSave = pNear->bEof;
       fts3EvalRestart(pCsr, pNear, &rc);
       while( rc==SQLITE_OK && !pNear->bEof ){
         fts3EvalNextRow(pCsr, pNear, &rc);
         if( bEofSave==0 && pNear->iDocid==iDocid ) break;
       }
       pIter = pPhrase->doclist.pList;
       assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );
       if( rc!=SQLITE_OK ) return rc;
     }
     iMul = ((pCsr->bDesc==bDescDoclist) ? 1 : -1);
     while( bTreeEof==1
         && pNear->bEof==0
         && (DOCID_CMP(pNear->iDocid, pCsr->iPrevId) * iMul)<0
     ){
       int rc = SQLITE_OK;
       fts3EvalNextRow(pCsr, pExpr, &rc);
       if( rc!=SQLITE_OK ) return rc;
       iDocid = pExpr->iDocid;
       pIter = pPhrase->doclist.pList;
     if( bTreeEof ){
       while( rc==SQLITE_OK && !pNear->bEof ){
         fts3EvalNextRow(pCsr, pNear, &rc);
       }
     }
     if( rc!=SQLITE_OK ) return rc;
     bEof = (pPhrase->doclist.nAll==0);
     assert( bDescDoclist==0 || bDescDoclist==1 );
     assert( pCsr->bDesc==0 || pCsr->bDesc==1 );
     if( bEof==0 ){
       if( pCsr->bDesc==bDescDoclist ){
     pIter = pPhrase->pOrPoslist;
     iDocid = pPhrase->iOrDocid;
     if( pCsr->bDesc==bDescDoclist ){
       bEof = (pIter >= (pPhrase->doclist.aAll + pPhrase->doclist.nAll));
       while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
         sqlite3Fts3DoclistNext(
             bDescDoclist, pPhrase->doclist.aAll, pPhrase->doclist.nAll,
             &pIter, &iDocid, &bEof
         );
       }
     }else{
       bEof = !pPhrase->doclist.nAll || (pIter && pIter<=pPhrase->doclist.aAll);
       while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
         int dummy;
         if( pNear->bEof ){
           /* This expression is already at EOF. So position it to point to the
           ** last entry in the doclist at pPhrase->doclist.aAll[]. Variable
           ** iDocid is already set for this entry, so all that is required is
           ** to set pIter to point to the first byte of the last position-list
           ** in the doclist.
           **
           ** It would also be correct to set pIter and iDocid to zero. In
           ** this case, the first call to sqltie3Fts4DoclistPrev() below
           ** would also move the iterator to point to the last entry in the
           ** doclist. However, this is expensive, as to do so it has to
           ** iterate through the entire doclist from start to finish (since
           ** it does not know the docid for the last entry).  */
           pIter = &pPhrase->doclist.aAll[pPhrase->doclist.nAll-1];
           fts3ReversePoslist(pPhrase->doclist.aAll, &pIter);
         }
         while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)>0 ) && bEof==0 ){
           sqlite3Fts3DoclistPrev(
               bDescDoclist, pPhrase->doclist.aAll, pPhrase->doclist.nAll,
               &pIter, &iDocid, &dummy, &bEof
           );
         }
       }else{
         if( pNear->bEof ){
           pIter = 0;
           iDocid = 0;
         }
         while( (pIter==0 || DOCID_CMP(iDocid, pCsr->iPrevId)<0 ) && bEof==0 ){
           sqlite3Fts3DoclistNext(
               bDescDoclist, pPhrase->doclist.aAll, pPhrase->doclist.nAll,
               &pIter, &iDocid, &bEof
           );
         }
         sqlite3Fts3DoclistPrev(
             bDescDoclist, pPhrase->doclist.aAll, pPhrase->doclist.nAll,
             &pIter, &iDocid, &dummy, &bEof
         );
       }
     }
     pPhrase->pOrPoslist = pIter;
     pPhrase->iOrDocid = iDocid;
     if( bEof || iDocid!=pCsr->iPrevId ) pIter = 0;
   }

@@ -137058,10 +138306,13 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(

   }
   while( iThis<iCol ){
     fts3ColumnlistCopy(0, &pIter);
     if( *pIter==0x00 ) return 0;
     if( *pIter==0x00 ) return SQLITE_OK;
     pIter++;
     pIter += fts3GetVarint32(pIter, &iThis);
   }
   if( *pIter==0x00 ){
     pIter = 0;
   }
   *ppOut = ((iCol==iThis)?pIter:0);
   return SQLITE_OK;

@@ -137104,7 +138355,7 @@ SQLITE_PRIVATE int sqlite3Fts3Corrupt(){

 #ifdef _WIN32
 __declspec(dllexport)
 #endif
 SQLITE_API int sqlite3_fts3_init(
 SQLITE_API int SQLITE_STDCALL sqlite3_fts3_init(
   sqlite3 *db,
   char **pzErrMsg,
   const sqlite3_api_routines *pApi

@@ -140072,7 +141323,7 @@ static void scalarFunc(

   if( argc==2 ){
     void *pOld;
     int n = sqlite3_value_bytes(argv[1]);
     if( n!=sizeof(pPtr) ){
     if( zName==0 || n!=sizeof(pPtr) ){
       sqlite3_result_error(context, "argument type mismatch", -1);
       return;
     }

@@ -140083,7 +141334,9 @@ static void scalarFunc(

       return;
     }
   }else{
     pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
     if( zName ){
       pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
     }
     if( !pPtr ){
       char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
       sqlite3_result_error(context, zErr, -1);

@@ -140164,6 +141417,10 @@ SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(

   zEnd = &zCopy[strlen(zCopy)];
   z = (char *)sqlite3Fts3NextToken(zCopy, &n);
   if( z==0 ){
     assert( n==0 );
     z = zCopy;
   }
   z[n] = '\0';
   sqlite3Fts3Dequote(z);

@@ -142809,7 +144066,10 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(

 ** an array of pending terms by term. This occurs as part of flushing
 ** the contents of the pending-terms hash table to the database.
 */
 static int fts3CompareElemByTerm(const void *lhs, const void *rhs){
 static int SQLITE_CDECL fts3CompareElemByTerm(
   const void *lhs,
   const void *rhs
 ){
   char *z1 = fts3HashKey(*(Fts3HashElem **)lhs);
   char *z2 = fts3HashKey(*(Fts3HashElem **)rhs);
   int n1 = fts3HashKeysize(*(Fts3HashElem **)lhs);

@@ -147288,37 +148548,39 @@ static int fts3BestSnippet(

   sIter.nSnippet = nSnippet;
   sIter.nPhrase = nList;
   sIter.iCurrent = -1;
   (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sIter);
   rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sIter);
   if( rc==SQLITE_OK ){
   /* Set the *pmSeen output variable. */
   for(i=0; i<nList; i++){
     if( sIter.aPhrase[i].pHead ){
       *pmSeen |= (u64)1 << i;
     /* Set the *pmSeen output variable. */
     for(i=0; i<nList; i++){
       if( sIter.aPhrase[i].pHead ){
         *pmSeen |= (u64)1 << i;
       }
     }
   }
   /* Loop through all candidate snippets. Store the best snippet in
   ** *pFragment. Store its associated 'score' in iBestScore.
   */
   pFragment->iCol = iCol;
   while( !fts3SnippetNextCandidate(&sIter) ){
     int iPos;
     int iScore;
     u64 mCover;
     u64 mHighlight;
     fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover, &mHighlight);
     assert( iScore>=0 );
     if( iScore>iBestScore ){
       pFragment->iPos = iPos;
       pFragment->hlmask = mHighlight;
       pFragment->covered = mCover;
       iBestScore = iScore;
     /* Loop through all candidate snippets. Store the best snippet in
      ** *pFragment. Store its associated 'score' in iBestScore.
      */
     pFragment->iCol = iCol;
     while( !fts3SnippetNextCandidate(&sIter) ){
       int iPos;
       int iScore;
       u64 mCover;
       u64 mHighlite;
       fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover,&mHighlite);
       assert( iScore>=0 );
       if( iScore>iBestScore ){
         pFragment->iPos = iPos;
         pFragment->hlmask = mHighlite;
         pFragment->covered = mCover;
         iBestScore = iScore;
       }
     }
   }
     *piScore = iBestScore;
   }
   sqlite3_free(sIter.aPhrase);
   *piScore = iBestScore;
   return SQLITE_OK;
   return rc;
 }

@@ -147526,8 +148788,12 @@ static int fts3SnippetText(

       ** required. They are required if (a) this is not the first fragment,
       ** or (b) this fragment does not begin at position 0 of its column.
       */
       if( rc==SQLITE_OK && (iPos>0 || iFragment>0) ){
         rc = fts3StringAppend(pOut, zEllipsis, -1);
       if( rc==SQLITE_OK ){
         if( iPos>0 || iFragment>0 ){
           rc = fts3StringAppend(pOut, zEllipsis, -1);
         }else if( iBegin ){
           rc = fts3StringAppend(pOut, zDoc, iBegin);
         }
       }
       if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
     }

@@ -148093,7 +149359,7 @@ SQLITE_PRIVATE void sqlite3Fts3Snippet(

       */
       for(iRead=0; iRead<pTab->nColumn; iRead++){
         SnippetFragment sF = {0, 0, 0, 0};
         int iS;
         int iS = 0;
         if( iCol>=0 && iRead!=iCol ) continue;
         /* Find the best snippet of nFToken tokens in column iRead. */

@@ -152536,7 +153802,7 @@ static void geomCallback(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){

 /*
 ** Register a new geometry function for use with the r-tree MATCH operator.
 */
 SQLITE_API int sqlite3_rtree_geometry_callback(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback(
   sqlite3 *db,                  /* Register SQL function on this connection */
   const char *zGeom,            /* Name of the new SQL function */
   int (*xGeom)(sqlite3_rtree_geometry*,int,RtreeDValue*,int*), /* Callback */

@@ -152560,7 +153826,7 @@ SQLITE_API int sqlite3_rtree_geometry_callback(

 ** Register a new 2nd-generation geometry function for use with the
 ** r-tree MATCH operator.
 */
 SQLITE_API int sqlite3_rtree_query_callback(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback(
   sqlite3 *db,                 /* Register SQL function on this connection */
   const char *zQueryFunc,      /* Name of new SQL function */
   int (*xQueryFunc)(sqlite3_rtree_query_info*), /* Callback */

@@ -152585,7 +153851,7 @@ SQLITE_API int sqlite3_rtree_query_callback(

 #ifdef _WIN32
 __declspec(dllexport)
 #endif
 SQLITE_API int sqlite3_rtree_init(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_init(
   sqlite3 *db,
   char **pzErrMsg,
   const sqlite3_api_routines *pApi

@@ -153090,7 +154356,7 @@ SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db){

 #ifdef _WIN32
 __declspec(dllexport)
 #endif
 SQLITE_API int sqlite3_icu_init(
 SQLITE_API int SQLITE_STDCALL sqlite3_icu_init(
   sqlite3 *db,
   char **pzErrMsg,
   const sqlite3_api_routines *pApi

modified external/sqlite/sqlite3.h

@@ -43,16 +43,20 @@ extern "C" {

 /*
 ** Add the ability to override 'extern'
 ** Provide the ability to override linkage features of the interface.
 */
 #ifndef SQLITE_EXTERN
 # define SQLITE_EXTERN extern
 #endif
 #ifndef SQLITE_API
 # define SQLITE_API
 #endif
 #ifndef SQLITE_CDECL
 # define SQLITE_CDECL
 #endif
 #ifndef SQLITE_STDCALL
 # define SQLITE_STDCALL
 #endif
 /*
 ** These no-op macros are used in front of interfaces to mark those

@@ -107,9 +111,9 @@ extern "C" {

 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
 #define SQLITE_VERSION        "3.8.8.2"
 #define SQLITE_VERSION_NUMBER 3008008
 #define SQLITE_SOURCE_ID      "2015-01-30 14:30:45 7757fc721220e136620a89c9d28247f28bbbc098"
 #define SQLITE_VERSION        "3.8.9"
 #define SQLITE_VERSION_NUMBER 3008009
 #define SQLITE_SOURCE_ID      "2015-04-08 12:16:33 8a8ffc862e96f57aa698f93de10dee28e69f6e09"
 /*
 ** CAPI3REF: Run-Time Library Version Numbers

@@ -142,9 +146,9 @@ extern "C" {

 ** See also: [sqlite_version()] and [sqlite_source_id()].
 */
 SQLITE_API SQLITE_EXTERN const char sqlite3_version[];
 SQLITE_API const char *sqlite3_libversion(void);
 SQLITE_API const char *sqlite3_sourceid(void);
 SQLITE_API int sqlite3_libversion_number(void);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion(void);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number(void);
 /*
 ** CAPI3REF: Run-Time Library Compilation Options Diagnostics

@@ -169,8 +173,8 @@ SQLITE_API int sqlite3_libversion_number(void);

 ** [sqlite_compileoption_get()] and the [compile_options pragma].
 */
 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
 SQLITE_API const char *sqlite3_compileoption_get(int N);
 SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_compileoption_get(int N);
 #endif
 /*

@@ -209,7 +213,7 @@ SQLITE_API const char *sqlite3_compileoption_get(int N);

 **
 ** See the [threading mode] documentation for additional information.
 */
 SQLITE_API int sqlite3_threadsafe(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe(void);
 /*
 ** CAPI3REF: Database Connection Handle

@@ -305,8 +309,8 @@ typedef sqlite_uint64 sqlite3_uint64;

 ** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer
 ** argument is a harmless no-op.
 */
 SQLITE_API int sqlite3_close(sqlite3*);
 SQLITE_API int sqlite3_close_v2(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3*);
 /*
 ** The type for a callback function.

@@ -376,7 +380,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);

 **      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
 ** </ul>
 */
 SQLITE_API int sqlite3_exec(
 SQLITE_API int SQLITE_STDCALL sqlite3_exec(
   sqlite3*,                                  /* An open database */
   const char *sql,                           /* SQL to be evaluated */
   int (*callback)(void*,int,char**,char**),  /* Callback function */

@@ -756,14 +760,16 @@ struct sqlite3_io_methods {

 ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
 ** interface.
 **
 ** <ul>
 ** <li>[[SQLITE_FCNTL_LOCKSTATE]]
 ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
 ** opcode causes the xFileControl method to write the current state of
 ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
 ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
 ** into an integer that the pArg argument points to. This capability
 ** is used during testing and only needs to be supported when SQLITE_TEST
 ** is defined.
 ** <ul>
 ** is used during testing and is only available when the SQLITE_TEST
 ** compile-time option is used.
 **
 ** <li>[[SQLITE_FCNTL_SIZE_HINT]]
 ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
 ** layer a hint of how large the database file will grow to be during the

@@ -888,7 +894,9 @@ struct sqlite3_io_methods {

 ** [PRAGMA] processing continues.  ^If the [SQLITE_FCNTL_PRAGMA]
 ** file control returns [SQLITE_OK], then the parser assumes that the
 ** VFS has handled the PRAGMA itself and the parser generates a no-op
 ** prepared statement.  ^If the [SQLITE_FCNTL_PRAGMA] file control returns
 ** prepared statement if result string is NULL, or that returns a copy
 ** of the result string if the string is non-NULL.
 ** ^If the [SQLITE_FCNTL_PRAGMA] file control returns
 ** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
 ** that the VFS encountered an error while handling the [PRAGMA] and the
 ** compilation of the PRAGMA fails with an error.  ^The [SQLITE_FCNTL_PRAGMA]

@@ -946,12 +954,19 @@ struct sqlite3_io_methods {

 ** pointed to by the pArg argument.  This capability is used during testing
 ** and only needs to be supported when SQLITE_TEST is defined.
 **
 ** <li>[[SQLITE_FCNTL_WAL_BLOCK]]
 ** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might
 ** be advantageous to block on the next WAL lock if the lock is not immediately
 ** available.  The WAL subsystem issues this signal during rare
 ** circumstances in order to fix a problem with priority inversion.
 ** Applications should <em>not</em> use this file-control.
 **
 ** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
 #define SQLITE_GET_LOCKPROXYFILE             2
 #define SQLITE_SET_LOCKPROXYFILE             3
 #define SQLITE_LAST_ERRNO                    4
 #define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
 #define SQLITE_FCNTL_SET_LOCKPROXYFILE       3
 #define SQLITE_FCNTL_LAST_ERRNO              4
 #define SQLITE_FCNTL_SIZE_HINT               5
 #define SQLITE_FCNTL_CHUNK_SIZE              6
 #define SQLITE_FCNTL_FILE_POINTER            7

@@ -970,6 +985,13 @@ struct sqlite3_io_methods {

 #define SQLITE_FCNTL_SYNC                   21
 #define SQLITE_FCNTL_COMMIT_PHASETWO        22
 #define SQLITE_FCNTL_WIN32_SET_HANDLE       23
 #define SQLITE_FCNTL_WAL_BLOCK              24
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
 #define SQLITE_SET_LOCKPROXYFILE      SQLITE_FCNTL_SET_LOCKPROXYFILE
 #define SQLITE_LAST_ERRNO             SQLITE_FCNTL_LAST_ERRNO
 /*
 ** CAPI3REF: Mutex Handle

@@ -1318,10 +1340,10 @@ struct sqlite3_vfs {

 ** must return [SQLITE_OK] on success and some other [error code] upon
 ** failure.
 */
 SQLITE_API int sqlite3_initialize(void);
 SQLITE_API int sqlite3_shutdown(void);
 SQLITE_API int sqlite3_os_init(void);
 SQLITE_API int sqlite3_os_end(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_initialize(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_shutdown(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void);
 SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void);
 /*
 ** CAPI3REF: Configuring The SQLite Library

@@ -1352,7 +1374,7 @@ SQLITE_API int sqlite3_os_end(void);

 ** ^If the option is unknown or SQLite is unable to set the option
 ** then this routine returns a non-zero [error code].
 */
 SQLITE_API int sqlite3_config(int, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_config(int, ...);
 /*
 ** CAPI3REF: Configure database connections

@@ -1370,7 +1392,7 @@ SQLITE_API int sqlite3_config(int, ...);

 ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
 ** the call is considered successful.
 */
 SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3*, int op, ...);
 /*
 ** CAPI3REF: Memory Allocation Routines

@@ -1530,7 +1552,7 @@ struct sqlite3_mem_methods {

 **   <li> [sqlite3_memory_used()]
 **   <li> [sqlite3_memory_highwater()]
 **   <li> [sqlite3_soft_heap_limit64()]
 **   <li> [sqlite3_status()]
 **   <li> [sqlite3_status64()]
 **   </ul>)^
 ** ^Memory allocation statistics are enabled by default unless SQLite is
 ** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory

@@ -1741,7 +1763,6 @@ struct sqlite3_mem_methods {

 ** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro
 ** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
 ** that specifies the maximum size of the created heap.
 ** </dl>
 **
 ** [[SQLITE_CONFIG_PCACHE_HDRSZ]]
 ** <dt>SQLITE_CONFIG_PCACHE_HDRSZ

@@ -1859,7 +1880,7 @@ struct sqlite3_mem_methods {

 ** [extended result codes] feature of SQLite. ^The extended result
 ** codes are disabled by default for historical compatibility.
 */
 SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
 SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3*, int onoff);
 /*
 ** CAPI3REF: Last Insert Rowid

@@ -1910,7 +1931,7 @@ SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);

 ** unpredictable and might not equal either the old or the new
 ** last insert [rowid].
 */
 SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(sqlite3*);
 /*
 ** CAPI3REF: Count The Number Of Rows Modified

@@ -1962,7 +1983,7 @@ SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);

 ** while [sqlite3_changes()] is running then the value returned
 ** is unpredictable and not meaningful.
 */
 SQLITE_API int sqlite3_changes(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3*);
 /*
 ** CAPI3REF: Total Number Of Rows Modified

@@ -1985,7 +2006,7 @@ SQLITE_API int sqlite3_changes(sqlite3*);

 ** while [sqlite3_total_changes()] is running then the value
 ** returned is unpredictable and not meaningful.
 */
 SQLITE_API int sqlite3_total_changes(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3*);
 /*
 ** CAPI3REF: Interrupt A Long-Running Query

@@ -2024,7 +2045,7 @@ SQLITE_API int sqlite3_total_changes(sqlite3*);

 ** If the database connection closes while [sqlite3_interrupt()]
 ** is running then bad things will likely happen.
 */
 SQLITE_API void sqlite3_interrupt(sqlite3*);
 SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3*);
 /*
 ** CAPI3REF: Determine If An SQL Statement Is Complete

@@ -2059,8 +2080,8 @@ SQLITE_API void sqlite3_interrupt(sqlite3*);

 ** The input to [sqlite3_complete16()] must be a zero-terminated
 ** UTF-16 string in native byte order.
 */
 SQLITE_API int sqlite3_complete(const char *sql);
 SQLITE_API int sqlite3_complete16(const void *sql);
 SQLITE_API int SQLITE_STDCALL sqlite3_complete(const char *sql);
 SQLITE_API int SQLITE_STDCALL sqlite3_complete16(const void *sql);
 /*
 ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors

@@ -2120,7 +2141,7 @@ SQLITE_API int sqlite3_complete16(const void *sql);

 ** A busy handler must not close the database connection
 ** or [prepared statement] that invoked the busy handler.
 */
 SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
 SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
 /*
 ** CAPI3REF: Set A Busy Timeout

@@ -2142,7 +2163,7 @@ SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);

 **
 ** See also:  [PRAGMA busy_timeout]
 */
 SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
 SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3*, int ms);
 /*
 ** CAPI3REF: Convenience Routines For Running Queries

@@ -2216,7 +2237,7 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);

 ** reflected in subsequent calls to [sqlite3_errcode()] or
 ** [sqlite3_errmsg()].
 */
 SQLITE_API int sqlite3_get_table(
 SQLITE_API int SQLITE_STDCALL sqlite3_get_table(
   sqlite3 *db,          /* An open database */
   const char *zSql,     /* SQL to be evaluated */
   char ***pazResult,    /* Results of the query */

@@ -2224,13 +2245,17 @@ SQLITE_API int sqlite3_get_table(

   int *pnColumn,        /* Number of result columns written here */
   char **pzErrmsg       /* Error msg written here */
 );
 SQLITE_API void sqlite3_free_table(char **result);
 SQLITE_API void SQLITE_STDCALL sqlite3_free_table(char **result);
 /*
 ** CAPI3REF: Formatted String Printing Functions
 **
 ** These routines are work-alikes of the "printf()" family of functions
 ** from the standard C library.
 ** These routines understand most of the common K&R formatting options,
 ** plus some additional non-standard formats, detailed below.
 ** Note that some of the more obscure formatting options from recent
 ** C-library standards are omitted from this implementation.
 **
 ** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
 ** results into memory obtained from [sqlite3_malloc()].

@@ -2263,7 +2288,7 @@ SQLITE_API void sqlite3_free_table(char **result);

 ** These routines all implement some additional formatting
 ** options that are useful for constructing SQL statements.
 ** All of the usual printf() formatting options apply.  In addition, there
 ** is are "%q", "%Q", and "%z" options.
 ** is are "%q", "%Q", "%w" and "%z" options.
 **
 ** ^(The %q option works like %s in that it substitutes a nul-terminated
 ** string from the argument list.  But %q also doubles every '\'' character.

@@ -2316,14 +2341,20 @@ SQLITE_API void sqlite3_free_table(char **result);

 ** The code above will render a correct SQL statement in the zSQL
 ** variable even if the zText variable is a NULL pointer.
 **
 ** ^(The "%w" formatting option is like "%q" except that it expects to
 ** be contained within double-quotes instead of single quotes, and it
 ** escapes the double-quote character instead of the single-quote
 ** character.)^  The "%w" formatting option is intended for safely inserting
 ** table and column names into a constructed SQL statement.
 **
 ** ^(The "%z" formatting option works like "%s" but with the
 ** addition that after the string has been read and copied into
 ** the result, [sqlite3_free()] is called on the input string.)^
 */
 SQLITE_API char *sqlite3_mprintf(const char*,...);
 SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
 SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
 SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
 SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char*,...);
 SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char*, va_list);
 SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int,char*,const char*, ...);
 SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int,char*,const char*, va_list);
 /*
 ** CAPI3REF: Memory Allocation Subsystem

@@ -2413,12 +2444,12 @@ SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);

 ** a block of memory after it has been released using
 ** [sqlite3_free()] or [sqlite3_realloc()].
 */
 SQLITE_API void *sqlite3_malloc(int);
 SQLITE_API void *sqlite3_malloc64(sqlite3_uint64);
 SQLITE_API void *sqlite3_realloc(void*, int);
 SQLITE_API void *sqlite3_realloc64(void*, sqlite3_uint64);
 SQLITE_API void sqlite3_free(void*);
 SQLITE_API sqlite3_uint64 sqlite3_msize(void*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int);
 SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64);
 SQLITE_API void *SQLITE_STDCALL sqlite3_realloc(void*, int);
 SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64(void*, sqlite3_uint64);
 SQLITE_API void SQLITE_STDCALL sqlite3_free(void*);
 SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void*);
 /*
 ** CAPI3REF: Memory Allocator Statistics

@@ -2443,8 +2474,8 @@ SQLITE_API sqlite3_uint64 sqlite3_msize(void*);

 ** by [sqlite3_memory_highwater(1)] is the high-water mark
 ** prior to the reset.
 */
 SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
 SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(void);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(int resetFlag);
 /*
 ** CAPI3REF: Pseudo-Random Number Generator

@@ -2467,7 +2498,7 @@ SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);

 ** internally and without recourse to the [sqlite3_vfs] xRandomness
 ** method.
 */
 SQLITE_API void sqlite3_randomness(int N, void *P);
 SQLITE_API void SQLITE_STDCALL sqlite3_randomness(int N, void *P);
 /*
 ** CAPI3REF: Compile-Time Authorization Callbacks

@@ -2549,7 +2580,7 @@ SQLITE_API void sqlite3_randomness(int N, void *P);

 ** as stated in the previous paragraph, sqlite3_step() invokes
 ** sqlite3_prepare_v2() to reprepare a statement after a schema change.
 */
 SQLITE_API int sqlite3_set_authorizer(
 SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer(
   sqlite3*,
   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
   void *pUserData

@@ -2653,8 +2684,8 @@ SQLITE_API int sqlite3_set_authorizer(

 ** sqlite3_profile() function is considered experimental and is
 ** subject to change in future versions of SQLite.
 */
 SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
 SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
 SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
 SQLITE_API SQLITE_EXPERIMENTAL void *SQLITE_STDCALL sqlite3_profile(sqlite3*,
    void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
 /*

@@ -2688,7 +2719,7 @@ SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,

 ** database connections for the meaning of "modify" in this paragraph.
 **
 */
 SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 /*
 ** CAPI3REF: Opening A New Database Connection

@@ -2916,15 +2947,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);

 **
 ** See also: [sqlite3_temp_directory]
 */
 SQLITE_API int sqlite3_open(
 SQLITE_API int SQLITE_STDCALL sqlite3_open(
   const char *filename,   /* Database filename (UTF-8) */
   sqlite3 **ppDb          /* OUT: SQLite db handle */
 );
 SQLITE_API int sqlite3_open16(
 SQLITE_API int SQLITE_STDCALL sqlite3_open16(
   const void *filename,   /* Database filename (UTF-16) */
   sqlite3 **ppDb          /* OUT: SQLite db handle */
 );
 SQLITE_API int sqlite3_open_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_open_v2(
   const char *filename,   /* Database filename (UTF-8) */
   sqlite3 **ppDb,         /* OUT: SQLite db handle */
   int flags,              /* Flags */

@@ -2970,19 +3001,21 @@ SQLITE_API int sqlite3_open_v2(

 ** VFS method, then the behavior of this routine is undefined and probably
 ** undesirable.
 */
 SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
 SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
 SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam);
 SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
 /*
 ** CAPI3REF: Error Codes And Messages
 **
 ** ^The sqlite3_errcode() interface returns the numeric [result code] or
 ** [extended result code] for the most recent failed sqlite3_* API call
 ** associated with a [database connection]. If a prior API call failed
 ** but the most recent API call succeeded, the return value from
 ** sqlite3_errcode() is undefined.  ^The sqlite3_extended_errcode()
 ** ^If the most recent sqlite3_* API call associated with
 ** [database connection] D failed, then the sqlite3_errcode(D) interface
 ** returns the numeric [result code] or [extended result code] for that
 ** API call.
 ** If the most recent API call was successful,
 ** then the return value from sqlite3_errcode() is undefined.
 ** ^The sqlite3_extended_errcode()
 ** interface is the same except that it always returns the
 ** [extended result code] even when extended result codes are
 ** disabled.

@@ -3013,11 +3046,11 @@ SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int

 ** was invoked incorrectly by the application.  In that case, the
 ** error code and message may or may not be set.
 */
 SQLITE_API int sqlite3_errcode(sqlite3 *db);
 SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
 SQLITE_API const char *sqlite3_errmsg(sqlite3*);
 SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
 SQLITE_API const char *sqlite3_errstr(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db);
 SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3*);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr(int);
 /*
 ** CAPI3REF: SQL Statement Object

@@ -3084,7 +3117,7 @@ typedef struct sqlite3_stmt sqlite3_stmt;

 **
 ** New run-time limit categories may be added in future releases.
 */
 SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3*, int id, int newVal);
 /*
 ** CAPI3REF: Run-Time Limit Categories

@@ -3171,16 +3204,14 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);

 ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
 ** use UTF-16.
 **
 ** ^If the nByte argument is less than zero, then zSql is read up to the
 ** first zero terminator. ^If nByte is non-negative, then it is the maximum
 ** number of  bytes read from zSql.  ^When nByte is non-negative, the
 ** zSql string ends at either the first '\000' or '\u0000' character or
 ** the nByte-th byte, whichever comes first. If the caller knows
 ** that the supplied string is nul-terminated, then there is a small
 ** performance advantage to be gained by passing an nByte parameter that
 ** is equal to the number of bytes in the input string <i>including</i>
 ** the nul-terminator bytes as this saves SQLite from having to
 ** make a copy of the input string.
 ** ^If the nByte argument is negative, then zSql is read up to the
 ** first zero terminator. ^If nByte is positive, then it is the
 ** number of bytes read from zSql.  ^If nByte is zero, then no prepared
 ** statement is generated.
 ** If the caller knows that the supplied string is nul-terminated, then
 ** there is a small performance advantage to passing an nByte parameter that
 ** is the number of bytes in the input string <i>including</i>
 ** the nul-terminator.
 **
 ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
 ** past the end of the first SQL statement in zSql.  These routines only

@@ -3236,28 +3267,28 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);

 ** </li>
 ** </ol>
 */
 SQLITE_API int sqlite3_prepare(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare(
   sqlite3 *db,            /* Database handle */
   const char *zSql,       /* SQL statement, UTF-8 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */
   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
 );
 SQLITE_API int sqlite3_prepare_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2(
   sqlite3 *db,            /* Database handle */
   const char *zSql,       /* SQL statement, UTF-8 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */
   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
   const char **pzTail     /* OUT: Pointer to unused portion of zSql */
 );
 SQLITE_API int sqlite3_prepare16(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare16(
   sqlite3 *db,            /* Database handle */
   const void *zSql,       /* SQL statement, UTF-16 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */
   sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
   const void **pzTail     /* OUT: Pointer to unused portion of zSql */
 );
 SQLITE_API int sqlite3_prepare16_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2(
   sqlite3 *db,            /* Database handle */
   const void *zSql,       /* SQL statement, UTF-16 encoded */
   int nByte,              /* Maximum length of zSql in bytes. */

@@ -3272,7 +3303,7 @@ SQLITE_API int sqlite3_prepare16_v2(

 ** SQL text used to create a [prepared statement] if that statement was
 ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
 */
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Determine If An SQL Statement Writes The Database

@@ -3303,7 +3334,7 @@ SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);

 ** change the configuration of a database connection, they do not make
 ** changes to the content of the database files on disk.
 */
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Determine If A Prepared Statement Has Been Reset

@@ -3322,7 +3353,7 @@ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

 ** for example, in diagnostic routines to search for prepared
 ** statements that are holding a transaction open.
 */
 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt*);
 /*
 ** CAPI3REF: Dynamically Typed Value Object

@@ -3483,19 +3514,19 @@ typedef struct sqlite3_context sqlite3_context;

 ** See also: [sqlite3_bind_parameter_count()],
 ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
 */
 SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
 SQLITE_API int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
                         void(*)(void*));
 SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
 SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
 SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
 SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
 SQLITE_API int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
 SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
 SQLITE_API int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt*, int, double);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt*, int, int);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*, int);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
                          void(*)(void*), unsigned char encoding);
 SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
 /*
 ** CAPI3REF: Number Of SQL Parameters

@@ -3515,7 +3546,7 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);

 ** [sqlite3_bind_parameter_name()], and
 ** [sqlite3_bind_parameter_index()].
 */
 SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt*);
 /*
 ** CAPI3REF: Name Of A Host Parameter

@@ -3542,7 +3573,7 @@ SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);

 ** [sqlite3_bind_parameter_count()], and
 ** [sqlite3_bind_parameter_index()].
 */
 SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt*, int);
 /*
 ** CAPI3REF: Index Of A Parameter With A Given Name

@@ -3558,7 +3589,7 @@ SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);

 ** [sqlite3_bind_parameter_count()], and
 ** [sqlite3_bind_parameter_index()].
 */
 SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
 SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
 /*
 ** CAPI3REF: Reset All Bindings On A Prepared Statement

@@ -3567,7 +3598,7 @@ SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);

 ** the [sqlite3_bind_blob | bindings] on a [prepared statement].
 ** ^Use this routine to reset all host parameters to NULL.
 */
 SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt*);
 /*
 ** CAPI3REF: Number Of Columns In A Result Set

@@ -3578,7 +3609,7 @@ SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);

 **
 ** See also: [sqlite3_data_count()]
 */
 SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Column Names In A Result Set

@@ -3606,8 +3637,8 @@ SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);

 ** then the name of the column is unspecified and may change from
 ** one release of SQLite to the next.
 */
 SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt*, int N);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt*, int N);
 /*
 ** CAPI3REF: Source Of Data In A Query Result

@@ -3654,12 +3685,12 @@ SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);

 ** for the same [prepared statement] and result column
 ** at the same time then the results are undefined.
 */
 SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
 SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
 SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt*,int);
 /*
 ** CAPI3REF: Declared Datatype Of A Query Result

@@ -3690,8 +3721,8 @@ SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);

 ** is associated with individual values, not with the containers
 ** used to hold those values.
 */
 SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt*,int);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt*,int);
 /*
 ** CAPI3REF: Evaluate An SQL Statement

@@ -3770,7 +3801,7 @@ SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);

 ** then the more specific [error codes] are returned directly
 ** by sqlite3_step().  The use of the "v2" interface is recommended.
 */
 SQLITE_API int sqlite3_step(sqlite3_stmt*);
 SQLITE_API int SQLITE_STDCALL sqlite3_step(sqlite3_stmt*);
 /*
 ** CAPI3REF: Number of columns in a result set

@@ -3790,7 +3821,7 @@ SQLITE_API int sqlite3_step(sqlite3_stmt*);

 **
 ** See also: [sqlite3_column_count()]
 */
 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Fundamental Datatypes

@@ -3986,16 +4017,16 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);

 ** pointer.  Subsequent calls to [sqlite3_errcode()] will return
 ** [SQLITE_NOMEM].)^
 */
 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
 SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
 SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
 SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
 SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt*, int iCol);
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt*, int iCol);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt*, int iCol);
 SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt*, int iCol);
 SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt*, int iCol);
 /*
 ** CAPI3REF: Destroy A Prepared Statement Object

@@ -4022,7 +4053,7 @@ SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);

 ** statement after it has been finalized can result in undefined and
 ** undesirable behavior such as segfaults and heap corruption.
 */
 SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Reset A Prepared Statement Object

@@ -4048,7 +4079,7 @@ SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);

 ** ^The [sqlite3_reset(S)] interface does not change the values
 ** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
 */
 SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 SQLITE_API int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Create Or Redefine SQL Functions

@@ -4147,7 +4178,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);

 ** close the database connection nor finalize or reset the prepared
 ** statement in which the function is running.
 */
 SQLITE_API int sqlite3_create_function(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function(
   sqlite3 *db,
   const char *zFunctionName,
   int nArg,

@@ -4157,7 +4188,7 @@ SQLITE_API int sqlite3_create_function(

   void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   void (*xFinal)(sqlite3_context*)
 );
 SQLITE_API int sqlite3_create_function16(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function16(
   sqlite3 *db,
   const void *zFunctionName,
   int nArg,

@@ -4167,7 +4198,7 @@ SQLITE_API int sqlite3_create_function16(

   void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   void (*xFinal)(sqlite3_context*)
 );
 SQLITE_API int sqlite3_create_function_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2(
   sqlite3 *db,
   const char *zFunctionName,
   int nArg,

@@ -4209,16 +4240,16 @@ SQLITE_API int sqlite3_create_function_v2(

 ** These functions are [deprecated].  In order to maintain
 ** backwards compatibility with older code, these functions continue
 ** to be supported.  However, new applications should avoid
 ** the use of these functions.  To help encourage people to avoid
 ** using these functions, we are not going to tell you what they do.
 ** the use of these functions.  To encourage programmers to avoid
 ** these functions, we will not explain what they do.
 */
 #ifndef SQLITE_OMIT_DEPRECATED
 SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
 SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
 SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context*);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_global_recover(void);
 SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_thread_cleanup(void);
 SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
                       void*,sqlite3_int64);
 #endif

@@ -4267,18 +4298,18 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6

 ** These routines must be called from the same thread as
 ** the SQL function that supplied the [sqlite3_value*] parameters.
 */
 SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
 SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
 SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
 SQLITE_API double sqlite3_value_double(sqlite3_value*);
 SQLITE_API int sqlite3_value_int(sqlite3_value*);
 SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
 SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
 SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
 SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value*);
 SQLITE_API double SQLITE_STDCALL sqlite3_value_double(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_int(sqlite3_value*);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value*);
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value*);
 SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_type(sqlite3_value*);
 SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value*);
 /*
 ** CAPI3REF: Obtain Aggregate Function Context

@@ -4322,7 +4353,7 @@ SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);

 ** This routine must be called from the same thread in which
 ** the aggregate SQL function is running.
 */
 SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
 SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context*, int nBytes);
 /*
 ** CAPI3REF: User Data For Functions

@@ -4336,7 +4367,7 @@ SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);

 ** This routine must be called from the same thread in which
 ** the application-defined function is running.
 */
 SQLITE_API void *sqlite3_user_data(sqlite3_context*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context*);
 /*
 ** CAPI3REF: Database Connection For Functions

@@ -4347,7 +4378,7 @@ SQLITE_API void *sqlite3_user_data(sqlite3_context*);

 ** and [sqlite3_create_function16()] routines that originally
 ** registered the application defined function.
 */
 SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context*);
 /*
 ** CAPI3REF: Function Auxiliary Data

@@ -4399,8 +4430,8 @@ SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);

 ** These routines must be called from the same thread in which
 ** the SQL function is running.
 */
 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
 SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
 SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context*, int N);
 SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
 /*

@@ -4535,26 +4566,26 @@ typedef void (*sqlite3_destructor_type)(void*);

 ** than the one containing the application-defined function that received
 ** the [sqlite3_context] pointer, the results are undefined.
 */
 SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void sqlite3_result_blob64(sqlite3_context*,const void*,
 SQLITE_API void SQLITE_STDCALL sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64(sqlite3_context*,const void*,
                            sqlite3_uint64,void(*)(void*));
 SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
 SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
 SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
 SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
 SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
 SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
 SQLITE_API void sqlite3_result_null(sqlite3_context*);
 SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
 SQLITE_API void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
 SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context*, double);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context*, const char*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context*, const void*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context*, int);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
                            void(*)(void*), unsigned char encoding);
 SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
 SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*);
 SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*, int n);
 /*
 ** CAPI3REF: Define New Collating Sequences

@@ -4635,14 +4666,14 @@ SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);

 **
 ** See also:  [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
 */
 SQLITE_API int sqlite3_create_collation(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation(
   sqlite3*,
   const char *zName,
   int eTextRep,
   void *pArg,
   int(*xCompare)(void*,int,const void*,int,const void*)
 );
 SQLITE_API int sqlite3_create_collation_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2(
   sqlite3*,
   const char *zName,
   int eTextRep,

@@ -4650,7 +4681,7 @@ SQLITE_API int sqlite3_create_collation_v2(

   int(*xCompare)(void*,int,const void*,int,const void*),
   void(*xDestroy)(void*)
 );
 SQLITE_API int sqlite3_create_collation16(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16(
   sqlite3*,
   const void *zName,
   int eTextRep,

@@ -4684,12 +4715,12 @@ SQLITE_API int sqlite3_create_collation16(

 ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
 ** [sqlite3_create_collation_v2()].
 */
 SQLITE_API int sqlite3_collation_needed(
 SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed(
   sqlite3*,
   void*,
   void(*)(void*,sqlite3*,int eTextRep,const char*)
 );
 SQLITE_API int sqlite3_collation_needed16(
 SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16(
   sqlite3*,
   void*,
   void(*)(void*,sqlite3*,int eTextRep,const void*)

@@ -4703,11 +4734,11 @@ SQLITE_API int sqlite3_collation_needed16(

 ** The code to implement this API is not available in the public release
 ** of SQLite.
 */
 SQLITE_API int sqlite3_key(
 SQLITE_API int SQLITE_STDCALL sqlite3_key(
   sqlite3 *db,                   /* Database to be rekeyed */
   const void *pKey, int nKey     /* The key */
 );
 SQLITE_API int sqlite3_key_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_key_v2(
   sqlite3 *db,                   /* Database to be rekeyed */
   const char *zDbName,           /* Name of the database */
   const void *pKey, int nKey     /* The key */

@@ -4721,11 +4752,11 @@ SQLITE_API int sqlite3_key_v2(

 ** The code to implement this API is not available in the public release
 ** of SQLite.
 */
 SQLITE_API int sqlite3_rekey(
 SQLITE_API int SQLITE_STDCALL sqlite3_rekey(
   sqlite3 *db,                   /* Database to be rekeyed */
   const void *pKey, int nKey     /* The new key */
 );
 SQLITE_API int sqlite3_rekey_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_rekey_v2(
   sqlite3 *db,                   /* Database to be rekeyed */
   const char *zDbName,           /* Name of the database */
   const void *pKey, int nKey     /* The new key */

@@ -4735,7 +4766,7 @@ SQLITE_API int sqlite3_rekey_v2(

 ** Specify the activation key for a SEE database.  Unless
 ** activated, none of the SEE routines will work.
 */
 SQLITE_API void sqlite3_activate_see(
 SQLITE_API void SQLITE_STDCALL sqlite3_activate_see(
   const char *zPassPhrase        /* Activation phrase */
 );
 #endif

@@ -4745,7 +4776,7 @@ SQLITE_API void sqlite3_activate_see(

 ** Specify the activation key for a CEROD database.  Unless
 ** activated, none of the CEROD routines will work.
 */
 SQLITE_API void sqlite3_activate_cerod(
 SQLITE_API void SQLITE_STDCALL sqlite3_activate_cerod(
   const char *zPassPhrase        /* Activation phrase */
 );
 #endif

@@ -4767,7 +4798,7 @@ SQLITE_API void sqlite3_activate_cerod(

 ** all, then the behavior of sqlite3_sleep() may deviate from the description
 ** in the previous paragraphs.
 */
 SQLITE_API int sqlite3_sleep(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_sleep(int);
 /*
 ** CAPI3REF: Name Of The Folder Holding Temporary Files

@@ -4885,7 +4916,7 @@ SQLITE_API SQLITE_EXTERN char *sqlite3_data_directory;

 ** connection while this routine is running, then the return value
 ** is undefined.
 */
 SQLITE_API int sqlite3_get_autocommit(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3*);
 /*
 ** CAPI3REF: Find The Database Handle Of A Prepared Statement

@@ -4897,7 +4928,7 @@ SQLITE_API int sqlite3_get_autocommit(sqlite3*);

 ** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
 ** create the statement in the first place.
 */
 SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
 SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt*);
 /*
 ** CAPI3REF: Return The Filename For A Database Connection

@@ -4913,7 +4944,7 @@ SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);

 ** will be an absolute pathname, even if the filename used
 ** to open the database originally was a URI or relative pathname.
 */
 SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
 SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName);
 /*
 ** CAPI3REF: Determine if a database is read-only

@@ -4922,7 +4953,7 @@ SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);

 ** of connection D is read-only, 0 if it is read/write, or -1 if N is not
 ** the name of a database on connection D.
 */
 SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
 SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
 /*
 ** CAPI3REF: Find the next prepared statement

@@ -4937,7 +4968,7 @@ SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);

 ** [sqlite3_next_stmt(D,S)] must refer to an open database
 ** connection and in particular must not be a NULL pointer.
 */
 SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
 SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
 /*
 ** CAPI3REF: Commit And Rollback Notification Callbacks

@@ -4985,8 +5016,8 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);

 **
 ** See also the [sqlite3_update_hook()] interface.
 */
 SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
 SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
 SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
 /*
 ** CAPI3REF: Data Change Notification Callbacks

@@ -5036,7 +5067,7 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

 ** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
 ** interfaces.
 */
 SQLITE_API void *sqlite3_update_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook(
   sqlite3*,
   void(*)(void *,int ,char const *,char const *,sqlite3_int64),
   void*

@@ -5066,12 +5097,17 @@ SQLITE_API void *sqlite3_update_hook(

 ** future releases of SQLite.  Applications that care about shared
 ** cache setting should set it explicitly.
 **
 ** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0
 ** and will always return SQLITE_MISUSE. On those systems,
 ** shared cache mode should be enabled per-database connection via
 ** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE].
 **
 ** This interface is threadsafe on processors where writing a
 ** 32-bit integer is atomic.
 **
 ** See Also:  [SQLite Shared-Cache Mode]
 */
 SQLITE_API int sqlite3_enable_shared_cache(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache(int);
 /*
 ** CAPI3REF: Attempt To Free Heap Memory

@@ -5087,7 +5123,7 @@ SQLITE_API int sqlite3_enable_shared_cache(int);

 **
 ** See also: [sqlite3_db_release_memory()]
 */
 SQLITE_API int sqlite3_release_memory(int);
 SQLITE_API int SQLITE_STDCALL sqlite3_release_memory(int);
 /*
 ** CAPI3REF: Free Memory Used By A Database Connection

@@ -5100,7 +5136,7 @@ SQLITE_API int sqlite3_release_memory(int);

 **
 ** See also: [sqlite3_release_memory()]
 */
 SQLITE_API int sqlite3_db_release_memory(sqlite3*);
 SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3*);
 /*
 ** CAPI3REF: Impose A Limit On Heap Size

@@ -5152,7 +5188,7 @@ SQLITE_API int sqlite3_db_release_memory(sqlite3*);

 ** The circumstances under which SQLite will enforce the soft heap limit may
 ** changes in future releases of SQLite.
 */
 SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 N);
 /*
 ** CAPI3REF: Deprecated Soft Heap Limit Interface

@@ -5163,7 +5199,7 @@ SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);

 ** only.  All new applications should use the
 ** [sqlite3_soft_heap_limit64()] interface rather than this one.
 */
 SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
 SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_soft_heap_limit(int N);
 /*

@@ -5232,7 +5268,7 @@ SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);

 ** parsed, if that has not already been done, and returns an error if
 ** any errors are encountered while loading the schema.
 */
 SQLITE_API int sqlite3_table_column_metadata(
 SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata(
   sqlite3 *db,                /* Connection handle */
   const char *zDbName,        /* Database name or NULL */
   const char *zTableName,     /* Table name */

@@ -5278,7 +5314,7 @@ SQLITE_API int sqlite3_table_column_metadata(

 **
 ** See also the [load_extension() SQL function].
 */
 SQLITE_API int sqlite3_load_extension(
 SQLITE_API int SQLITE_STDCALL sqlite3_load_extension(
   sqlite3 *db,          /* Load the extension into this database connection */
   const char *zFile,    /* Name of the shared library containing extension */
   const char *zProc,    /* Entry point.  Derived from zFile if 0 */

@@ -5298,7 +5334,7 @@ SQLITE_API int sqlite3_load_extension(

 ** to turn extension loading on and call it with onoff==0 to turn
 ** it back off again.
 */
 SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
 SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff);
 /*
 ** CAPI3REF: Automatically Load Statically Linked Extensions

@@ -5336,7 +5372,7 @@ SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);

 ** See also: [sqlite3_reset_auto_extension()]
 ** and [sqlite3_cancel_auto_extension()]
 */
 SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
 SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension(void (*xEntryPoint)(void));
 /*
 ** CAPI3REF: Cancel Automatic Extension Loading

@@ -5348,7 +5384,7 @@ SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));

 ** unregistered and it returns 0 if X was not on the list of initialization
 ** routines.
 */
 SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
 SQLITE_API int SQLITE_STDCALL sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
 /*
 ** CAPI3REF: Reset Automatic Extension Loading

@@ -5356,7 +5392,7 @@ SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));

 ** ^This interface disables all automatic extensions previously
 ** registered using [sqlite3_auto_extension()].
 */
 SQLITE_API void sqlite3_reset_auto_extension(void);
 SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension(void);
 /*
 ** The interface to the virtual-table mechanism is currently considered

@@ -5559,13 +5595,13 @@ struct sqlite3_index_info {

 ** interface is equivalent to sqlite3_create_module_v2() with a NULL
 ** destructor.
 */
 SQLITE_API int sqlite3_create_module(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_module(
   sqlite3 *db,               /* SQLite connection to register module with */
   const char *zName,         /* Name of the module */
   const sqlite3_module *p,   /* Methods for the module */
   void *pClientData          /* Client data for xCreate/xConnect */
 );
 SQLITE_API int sqlite3_create_module_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2(
   sqlite3 *db,               /* SQLite connection to register module with */
   const char *zName,         /* Name of the module */
   const sqlite3_module *p,   /* Methods for the module */

@@ -5593,7 +5629,7 @@ SQLITE_API int sqlite3_create_module_v2(

 */
 struct sqlite3_vtab {
   const sqlite3_module *pModule;  /* The module for this virtual table */
   int nRef;                       /* NO LONGER USED */
   int nRef;                       /* Number of open cursors */
   char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
   /* Virtual table implementations will typically add additional fields */
 };

@@ -5628,7 +5664,7 @@ struct sqlite3_vtab_cursor {

 ** to declare the format (the names and datatypes of the columns) of
 ** the virtual tables they implement.
 */
 SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
 SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3*, const char *zSQL);
 /*
 ** CAPI3REF: Overload A Function For A Virtual Table

@@ -5646,7 +5682,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);

 ** purpose is to be a placeholder function that can be overloaded
 ** by a [virtual table].
 */
 SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
 SQLITE_API int SQLITE_STDCALL sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
 /*
 ** The interface to the virtual-table mechanism defined above (back up

@@ -5743,7 +5779,7 @@ typedef struct sqlite3_blob sqlite3_blob;

 ** To avoid a resource leak, every open [BLOB handle] should eventually
 ** be released by a call to [sqlite3_blob_close()].
 */
 SQLITE_API int sqlite3_blob_open(
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_open(
   sqlite3*,
   const char *zDb,
   const char *zTable,

@@ -5775,7 +5811,7 @@ SQLITE_API int sqlite3_blob_open(

 **
 ** ^This function sets the database handle error code and message.
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
 SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
 /*
 ** CAPI3REF: Close A BLOB Handle

@@ -5797,7 +5833,7 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_i

 ** is passed a valid open blob handle, the values returned by the
 ** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning.
 */
 SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *);
 /*
 ** CAPI3REF: Return The Size Of An Open BLOB

@@ -5812,7 +5848,7 @@ SQLITE_API int sqlite3_blob_close(sqlite3_blob *);

 ** been closed by [sqlite3_blob_close()].  Passing any other pointer in
 ** to this routine results in undefined and probably undesirable behavior.
 */
 SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *);
 /*
 ** CAPI3REF: Read Data From A BLOB Incrementally

@@ -5840,7 +5876,7 @@ SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);

 **
 ** See also: [sqlite3_blob_write()].
 */
 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
 /*
 ** CAPI3REF: Write Data Into A BLOB Incrementally

@@ -5881,7 +5917,7 @@ SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);

 **
 ** See also: [sqlite3_blob_read()].
 */
 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
 SQLITE_API int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
 /*
 ** CAPI3REF: Virtual File System Objects

@@ -5912,9 +5948,9 @@ SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOff

 ** ^(If the default VFS is unregistered, another VFS is chosen as
 ** the default.  The choice for the new VFS is arbitrary.)^
 */
 SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
 SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
 SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
 SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(const char *zVfsName);
 SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
 SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs*);
 /*
 ** CAPI3REF: Mutexes

@@ -6027,11 +6063,11 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);

 **
 ** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
 */
 SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
 SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
 SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
 SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
 SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(int);
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex*);
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex*);
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex*);
 SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex*);
 /*
 ** CAPI3REF: Mutex Methods Object

@@ -6141,8 +6177,8 @@ struct sqlite3_mutex_methods {

 ** interface should also return 1 when given a NULL pointer.
 */
 #ifndef NDEBUG
 SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
 SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex*);
 SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex*);
 #endif
 /*

@@ -6178,7 +6214,7 @@ SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);

 ** ^If the [threading mode] is Single-thread or Multi-thread then this
 ** routine returns a NULL pointer.
 */
 SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3*);
 /*
 ** CAPI3REF: Low-Level Control Of Database Files

@@ -6212,7 +6248,7 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);

 **
 ** See also: [SQLITE_FCNTL_LOCKSTATE]
 */
 SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
 SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
 /*
 ** CAPI3REF: Testing Interface

@@ -6231,7 +6267,7 @@ SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*

 ** Unlike most of the SQLite API, this function is not guaranteed to
 ** operate consistently from one release to the next.
 */
 SQLITE_API int sqlite3_test_control(int op, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...);
 /*
 ** CAPI3REF: Testing Interface Operation Codes

@@ -6265,12 +6301,13 @@ SQLITE_API int sqlite3_test_control(int op, ...);

 #define SQLITE_TESTCTRL_BYTEORDER               22
 #define SQLITE_TESTCTRL_ISINIT                  23
 #define SQLITE_TESTCTRL_SORTER_MMAP             24
 #define SQLITE_TESTCTRL_LAST                    24
 #define SQLITE_TESTCTRL_IMPOSTER                25
 #define SQLITE_TESTCTRL_LAST                    25
 /*
 ** CAPI3REF: SQLite Runtime Status
 **
 ** ^This interface is used to retrieve runtime status information
 ** ^These interfaces are used to retrieve runtime status information
 ** about the performance of SQLite, and optionally to reset various
 ** highwater marks.  ^The first argument is an integer code for
 ** the specific parameter to measure.  ^(Recognized integer codes

@@ -6284,19 +6321,22 @@ SQLITE_API int sqlite3_test_control(int op, ...);

 ** ^(Other parameters record only the highwater mark and not the current
 ** value.  For these latter parameters nothing is written into *pCurrent.)^
 **
 ** ^The sqlite3_status() routine returns SQLITE_OK on success and a
 ** non-zero [error code] on failure.
 ** ^The sqlite3_status() and sqlite3_status64() routines return
 ** SQLITE_OK on success and a non-zero [error code] on failure.
 **
 ** This routine is threadsafe but is not atomic.  This routine can be
 ** called while other threads are running the same or different SQLite
 ** interfaces.  However the values returned in *pCurrent and
 ** *pHighwater reflect the status of SQLite at different points in time
 ** and it is possible that another thread might change the parameter
 ** in between the times when *pCurrent and *pHighwater are written.
 ** If either the current value or the highwater mark is too large to
 ** be represented by a 32-bit integer, then the values returned by
 ** sqlite3_status() are undefined.
 **
 ** See also: [sqlite3_db_status()]
 */
 SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
 SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
 SQLITE_API int SQLITE_STDCALL sqlite3_status64(
   int op,
   sqlite3_int64 *pCurrent,
   sqlite3_int64 *pHighwater,
   int resetFlag
 );
 /*

@@ -6414,7 +6454,7 @@ SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetF

 **
 ** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
 */
 SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
 SQLITE_API int SQLITE_STDCALL sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
 /*
 ** CAPI3REF: Status Parameters for database connections

@@ -6543,7 +6583,7 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r

 **
 ** See also: [sqlite3_status()] and [sqlite3_db_status()].
 */
 SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
 /*
 ** CAPI3REF: Status Parameters for prepared statements

@@ -6966,20 +7006,20 @@ typedef struct sqlite3_backup sqlite3_backup;

 ** is not a permanent error and does not affect the return value of
 ** sqlite3_backup_finish().
 **
 ** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]]
 ** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]]
 ** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
 **
 ** ^Each call to sqlite3_backup_step() sets two values inside
 ** the [sqlite3_backup] object: the number of pages still to be backed
 ** up and the total number of pages in the source database file.
 ** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces
 ** retrieve these two values, respectively.
 **
 ** ^The values returned by these functions are only updated by
 ** sqlite3_backup_step(). ^If the source database is modified during a backup
 ** operation, then the values are not updated to account for any extra
 ** pages that need to be updated or the size of the source database file
 ** changing.
 ** ^The sqlite3_backup_remaining() routine returns the number of pages still
 ** to be backed up at the conclusion of the most recent sqlite3_backup_step().
 ** ^The sqlite3_backup_pagecount() routine returns the total number of pages
 ** in the source database at the conclusion of the most recent
 ** sqlite3_backup_step().
 ** ^(The values returned by these functions are only updated by
 ** sqlite3_backup_step(). If the source database is modified in a way that
 ** changes the size of the source database or the number of pages remaining,
 ** those changes are not reflected in the output of sqlite3_backup_pagecount()
 ** and sqlite3_backup_remaining() until after the next
 ** sqlite3_backup_step().)^
 **
 ** <b>Concurrent Usage of Database Handles</b>
 **

@@ -7012,16 +7052,16 @@ typedef struct sqlite3_backup sqlite3_backup;

 ** same time as another thread is invoking sqlite3_backup_step() it is
 ** possible that they return invalid values.
 */
 SQLITE_API sqlite3_backup *sqlite3_backup_init(
 SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init(
   sqlite3 *pDest,                        /* Destination database handle */
   const char *zDestName,                 /* Destination database name */
   sqlite3 *pSource,                      /* Source database handle */
   const char *zSourceName                /* Source database name */
 );
 SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
 SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
 SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
 SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p);
 SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p);
 /*
 ** CAPI3REF: Unlock Notification

@@ -7137,7 +7177,7 @@ SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);

 ** the special "DROP TABLE/INDEX" case, the extended error code is just
 ** SQLITE_LOCKED.)^
 */
 SQLITE_API int sqlite3_unlock_notify(
 SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify(
   sqlite3 *pBlocked,                          /* Waiting connection */
   void (*xNotify)(void **apArg, int nArg),    /* Callback function to invoke */
   void *pNotifyArg                            /* Argument to pass to xNotify */

@@ -7152,8 +7192,8 @@ SQLITE_API int sqlite3_unlock_notify(

 ** strings in a case-independent fashion, using the same definition of "case
 ** independence" that SQLite uses internally when comparing identifiers.
 */
 SQLITE_API int sqlite3_stricmp(const char *, const char *);
 SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
 SQLITE_API int SQLITE_STDCALL sqlite3_stricmp(const char *, const char *);
 SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp(const char *, const char *, int);
 /*
 ** CAPI3REF: String Globbing

@@ -7168,7 +7208,7 @@ SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);

 ** Note that this routine returns zero on a match and non-zero if the strings
 ** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
 */
 SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);
 SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlob, const char *zStr);
 /*
 ** CAPI3REF: Error Logging Interface

@@ -7191,7 +7231,7 @@ SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);

 ** a few hundred characters, it will be truncated to the length of the
 ** buffer.
 */
 SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
 SQLITE_API void SQLITE_CDECL sqlite3_log(int iErrCode, const char *zFormat, ...);
 /*
 ** CAPI3REF: Write-Ahead Log Commit Hook

@@ -7226,7 +7266,7 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);

 ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
 ** those overwrite any prior [sqlite3_wal_hook()] settings.
 */
 SQLITE_API void *sqlite3_wal_hook(
 SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook(
   sqlite3*,
   int(*)(void *,sqlite3*,const char*,int),
   void*

@@ -7260,7 +7300,7 @@ SQLITE_API void *sqlite3_wal_hook(

 ** is only necessary if the default setting is found to be suboptimal
 ** for a particular application.
 */
 SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
 /*
 ** CAPI3REF: Checkpoint a database

@@ -7281,7 +7321,7 @@ SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);

 ** start a callback but which do not need the full power (and corresponding
 ** complication) of [sqlite3_wal_checkpoint_v2()].
 */
 SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
 /*
 ** CAPI3REF: Checkpoint a database

@@ -7374,7 +7414,7 @@ SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);

 ** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface
 ** from SQL.
 */
 SQLITE_API int sqlite3_wal_checkpoint_v2(
 SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2(
   sqlite3 *db,                    /* Database handle */
   const char *zDb,                /* Name of attached database (or NULL) */
   int eMode,                      /* SQLITE_CHECKPOINT_* value */

@@ -7410,7 +7450,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(

 ** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].)  Further options
 ** may be added in the future.
 */
 SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
 SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3*, int op, ...);
 /*
 ** CAPI3REF: Virtual Table Configuration Options

@@ -7463,7 +7503,7 @@ SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);

 ** of the SQL statement that triggered the call to the [xUpdate] method of the
 ** [virtual table].
 */
 SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
 SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *);
 /*
 ** CAPI3REF: Conflict resolution modes

@@ -7567,7 +7607,7 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);

 **
 ** See also: [sqlite3_stmt_scanstatus_reset()]
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_scanstatus(
 SQLITE_API SQLITE_EXPERIMENTAL int SQLITE_STDCALL sqlite3_stmt_scanstatus(
   sqlite3_stmt *pStmt,      /* Prepared statement for which info desired */
   int idx,                  /* Index of loop to report on */
   int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */

@@ -7582,7 +7622,7 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_stmt_scanstatus(

 ** This API is only available if the library is built with pre-processor
 ** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined.
 */
 SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
 SQLITE_API SQLITE_EXPERIMENTAL void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
 /*

@@ -7637,7 +7677,7 @@ typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info;

 **
 **   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
 */
 SQLITE_API int sqlite3_rtree_geometry_callback(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback(
   sqlite3 *db,
   const char *zGeom,
   int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*),

@@ -7663,7 +7703,7 @@ struct sqlite3_rtree_geometry {

 **
 **   SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zQueryFunc(... params ...)
 */
 SQLITE_API int sqlite3_rtree_query_callback(
 SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback(
   sqlite3 *db,
   const char *zQueryFunc,
   int (*xQueryFunc)(sqlite3_rtree_query_info*),