SQLite: update to 3.41.0

2 files changed, 2977 insertions, 1352 deletions

diff --git a/libs/sqlite3/src/sqlite3.c b/libs/sqlite3/src/sqlite3.c
index 4272550d32..6cedae5f56 100644
--- a/libs/sqlite3/src/sqlite3.c
+++ b/libs/sqlite3/src/sqlite3.c
@@ -1,6 +1,6 @@
 /******************************************************************************

 ** This file is an amalgamation of many separate C source files from SQLite

-** version 3.40.1.  By combining all the individual C code files into this

+** version 3.41.0.  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

@@ -452,9 +452,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],

 ** [sqlite_version()] and [sqlite_source_id()].

 */

-#define SQLITE_VERSION        "3.40.1"

-#define SQLITE_VERSION_NUMBER 3040001

-#define SQLITE_SOURCE_ID      "2022-12-28 14:03:47 df5c253c0b3dd24916e4ec7cf77d3db5294cc9fd45ae7b9c5e82ad8197f38a24"

+#define SQLITE_VERSION        "3.41.0"

+#define SQLITE_VERSION_NUMBER 3041000

+#define SQLITE_SOURCE_ID      "2023-02-21 18:09:37 05941c2a04037fc3ed2ffae11f5d2260706f89431f463518740f72ada350866d"

 

 /*

 ** CAPI3REF: Run-Time Library Version Numbers

@@ -869,6 +869,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_CONSTRAINT_DATATYPE     (SQLITE_CONSTRAINT |(12<<8))

 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))

 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

+#define SQLITE_NOTICE_RBU              (SQLITE_NOTICE | (3<<8))

 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))

 #define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))

 #define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))

@@ -1481,7 +1482,6 @@ struct sqlite3_io_methods {
 ** in wal mode after the client has finished copying pages from the wal

 ** file to the database file, but before the *-shm file is updated to

 ** record the fact that the pages have been checkpointed.

-** </ul>

 **

 ** <li>[[SQLITE_FCNTL_EXTERNAL_READER]]

 ** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect

@@ -1494,16 +1494,16 @@ struct sqlite3_io_methods {
 ** the database is not a wal-mode db, or if there is no such connection in any

 ** other process. This opcode cannot be used to detect transactions opened

 ** by clients within the current process, only within other processes.

-** </ul>

 **

 ** <li>[[SQLITE_FCNTL_CKSM_FILE]]

-** Used by the cksmvfs VFS module only.

+** The [SQLITE_FCNTL_CKSM_FILE] opcode is for use interally by the

+** [checksum VFS shim] only.

 **

 ** <li>[[SQLITE_FCNTL_RESET_CACHE]]

 ** If there is currently no transaction open on the database, and the

-** database is not a temp db, then this file-control purges the contents

-** of the in-memory page cache. If there is an open transaction, or if

-** the db is a temp-db, it is a no-op, not an error.

+** database is not a temp db, then the [SQLITE_FCNTL_RESET_CACHE] file-control

+** purges the contents of the in-memory page cache. If there is an open

+** transaction, or if the db is a temp-db, this opcode is a no-op, not an error.

 ** </ul>

 */

 #define SQLITE_FCNTL_LOCKSTATE               1

@@ -2490,7 +2490,7 @@ struct sqlite3_mem_methods {
 ** configuration for a database connection can only be changed when that

 ** connection is not currently using lookaside memory, or in other words

 ** when the "current value" returned by

-** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero.

+** [sqlite3_db_status](D,[SQLITE_DBSTATUS_LOOKASIDE_USED],...) is zero.

 ** Any attempt to change the lookaside memory configuration when lookaside

 ** memory is in use leaves the configuration unchanged and returns

 ** [SQLITE_BUSY].)^</dd>

@@ -2640,8 +2640,12 @@ struct sqlite3_mem_methods {
 ** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);

 ** </ol>

 ** Because resetting a database is destructive and irreversible, the

-** process requires the use of this obscure API and multiple steps to help

-** ensure that it does not happen by accident.

+** process requires the use of this obscure API and multiple steps to

+** help ensure that it does not happen by accident. Because this

+** feature must be capable of resetting corrupt databases, and

+** shutting down virtual tables may require access to that corrupt

+** storage, the library must abandon any installed virtual tables

+** without calling their xDestroy() methods.

 **

 ** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>

 ** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the

@@ -2980,8 +2984,12 @@ SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*);
 ** ^A call to sqlite3_interrupt(D) that occurs when there are no running

 ** SQL statements is a no-op and has no effect on SQL statements

 ** that are started after the sqlite3_interrupt() call returns.

+**

+** ^The [sqlite3_is_interrupted(D)] interface can be used to determine whether

+** or not an interrupt is currently in effect for [database connection] D.

 */

 SQLITE_API void sqlite3_interrupt(sqlite3*);

+SQLITE_API int sqlite3_is_interrupted(sqlite3*);

 

 /*

 ** CAPI3REF: Determine If An SQL Statement Is Complete

@@ -3599,8 +3607,8 @@ SQLITE_API SQLITE_DEPRECATED void *sqlite3_profile(sqlite3*,
 ** <dd>^An SQLITE_TRACE_PROFILE callback provides approximately the same

 ** information as is provided by the [sqlite3_profile()] callback.

 ** ^The P argument is a pointer to the [prepared statement] and the

-** X argument points to a 64-bit integer which is the estimated of

-** the number of nanosecond that the prepared statement took to run.

+** X argument points to a 64-bit integer which is approximately

+** the number of nanoseconds that the prepared statement took to run.

 ** ^The SQLITE_TRACE_PROFILE callback is invoked when the statement finishes.

 **

 ** [[SQLITE_TRACE_ROW]] <dt>SQLITE_TRACE_ROW</dt>

@@ -3663,7 +3671,7 @@ SQLITE_API int sqlite3_trace_v2(
 **

 ** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback

 ** function X to be invoked periodically during long running calls to

-** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for

+** [sqlite3_step()] and [sqlite3_prepare()] and similar for

 ** database connection D.  An example use for this

 ** interface is to keep a GUI updated during a large query.

 **

@@ -3688,6 +3696,13 @@ SQLITE_API int sqlite3_trace_v2(
 ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their

 ** database connections for the meaning of "modify" in this paragraph.

 **

+** The progress handler callback would originally only be invoked from the

+** bytecode engine.  It still might be invoked during [sqlite3_prepare()]

+** and similar because those routines might force a reparse of the schema

+** which involves running the bytecode engine.  However, beginning with

+** SQLite version 3.41.0, the progress handler callback might also be

+** invoked directly from [sqlite3_prepare()] while analyzing and generating

+** code for complex queries.

 */

 SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);

 

@@ -3724,13 +3739,18 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **

 ** <dl>

 ** ^(<dt>[SQLITE_OPEN_READONLY]</dt>

-** <dd>The database is opened in read-only mode.  If the database does not

-** already exist, an error is returned.</dd>)^

+** <dd>The database is opened in read-only mode.  If the database does

+** not already exist, an error is returned.</dd>)^

 **

 ** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>

-** <dd>The database is opened for reading and writing if possible, or reading

-** only if the file is write protected by the operating system.  In either

-** case the database must already exist, otherwise an error is returned.</dd>)^

+** <dd>The database is opened for reading and writing if possible, or

+** reading only if the file is write protected by the operating

+** system.  In either case the database must already exist, otherwise

+** an error is returned.  For historical reasons, if opening in

+** read-write mode fails due to OS-level permissions, an attempt is

+** made to open it in read-only mode. [sqlite3_db_readonly()] can be

+** used to determine whether the database is actually

+** read-write.</dd>)^

 **

 ** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>

 ** <dd>The database is opened for reading and writing, and is created if

@@ -5711,10 +5731,21 @@ SQLITE_API int sqlite3_create_window_function(
 ** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in

 ** schema structures such as [CHECK constraints], [DEFAULT clauses],

 ** [expression indexes], [partial indexes], or [generated columns].

-** The SQLITE_DIRECTONLY flags is a security feature which is recommended

-** for all [application-defined SQL functions], and especially for functions

-** that have side-effects or that could potentially leak sensitive

-** information.

+** <p>

+** The SQLITE_DIRECTONLY flag is recommended for any

+** [application-defined SQL function]

+** that has side-effects or that could potentially leak sensitive information.

+** This will prevent attacks in which an application is tricked

+** into using a database file that has had its schema surreptiously

+** modified to invoke the application-defined function in ways that are

+** harmful.

+** <p>

+** Some people say it is good practice to set SQLITE_DIRECTONLY on all

+** [application-defined SQL functions], regardless of whether or not they

+** are security sensitive, as doing so prevents those functions from being used

+** inside of the database schema, and thus ensures that the database

+** can be inspected and modified using generic tools (such as the [CLI])

+** that do not have access to the application-defined functions.

 ** </dd>

 **

 ** [[SQLITE_INNOCUOUS]] <dt>SQLITE_INNOCUOUS</dt><dd>

@@ -5855,16 +5886,6 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** then the conversion is performed.  Otherwise no conversion occurs.

 ** The [SQLITE_INTEGER | datatype] after conversion is returned.)^

 **

-** ^(The sqlite3_value_encoding(X) interface returns one of [SQLITE_UTF8],

-** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current encoding

-** of the value X, assuming that X has type TEXT.)^  If sqlite3_value_type(X)

-** returns something other than SQLITE_TEXT, then the return value from

-** sqlite3_value_encoding(X) is meaningless.  ^Calls to

-** sqlite3_value_text(X), sqlite3_value_text16(X), sqlite3_value_text16be(X),

-** sqlite3_value_text16le(X), sqlite3_value_bytes(X), or

-** sqlite3_value_bytes16(X) might change the encoding of the value X and

-** thus change the return from subsequent calls to sqlite3_value_encoding(X).

-**

 ** ^Within the [xUpdate] method of a [virtual table], the

 ** sqlite3_value_nochange(X) interface returns true if and only if

 ** the column corresponding to X is unchanged by the UPDATE operation

@@ -5929,6 +5950,27 @@ SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);

 SQLITE_API int sqlite3_value_nochange(sqlite3_value*);

 SQLITE_API int sqlite3_value_frombind(sqlite3_value*);

+

+/*

+** CAPI3REF: Report the internal text encoding state of an sqlite3_value object

+** METHOD: sqlite3_value

+**

+** ^(The sqlite3_value_encoding(X) interface returns one of [SQLITE_UTF8],

+** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current text encoding

+** of the value X, assuming that X has type TEXT.)^  If sqlite3_value_type(X)

+** returns something other than SQLITE_TEXT, then the return value from

+** sqlite3_value_encoding(X) is meaningless.  ^Calls to

+** [sqlite3_value_text(X)], [sqlite3_value_text16(X)], [sqlite3_value_text16be(X)],

+** [sqlite3_value_text16le(X)], [sqlite3_value_bytes(X)], or

+** [sqlite3_value_bytes16(X)] might change the encoding of the value X and

+** thus change the return from subsequent calls to sqlite3_value_encoding(X).

+**

+** This routine is intended for used by applications that test and validate

+** the SQLite implementation.  This routine is inquiring about the opaque

+** internal state of an [sqlite3_value] object.  Ordinary applications should

+** not need to know what the internal state of an sqlite3_value object is and

+** hence should not need to use this interface.

+*/

 SQLITE_API int sqlite3_value_encoding(sqlite3_value*);

 

 /*

@@ -7310,15 +7352,6 @@ SQLITE_API int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void));
 SQLITE_API void sqlite3_reset_auto_extension(void);

 

 /*

-** The interface to the virtual-table mechanism is currently considered

-** to be experimental.  The interface might change in incompatible ways.

-** If this is a problem for you, do not use the interface at this time.

-**

-** When the virtual-table mechanism stabilizes, we will declare the

-** interface fixed, support it indefinitely, and remove this comment.

-*/

-

-/*

 ** Structures used by the virtual table interface

 */

 typedef struct sqlite3_vtab sqlite3_vtab;

@@ -7436,10 +7469,10 @@ struct sqlite3_module {
 ** when the omit flag is true there is no guarantee that the constraint will

 ** not be checked again using byte code.)^

 **

-** ^The idxNum and idxPtr values are recorded and passed into the

+** ^The idxNum and idxStr values are recorded and passed into the

 ** [xFilter] method.

-** ^[sqlite3_free()] is used to free idxPtr if and only if

-** needToFreeIdxPtr is true.

+** ^[sqlite3_free()] is used to free idxStr if and only if

+** needToFreeIdxStr is true.

 **

 ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in

 ** the correct order to satisfy the ORDER BY clause so that no separate

@@ -7559,7 +7592,7 @@ struct sqlite3_index_info {
 ** the [sqlite3_vtab_collation()] interface.  For most real-world virtual

 ** tables, the collating sequence of constraints does not matter (for example

 ** because the constraints are numeric) and so the sqlite3_vtab_collation()

-** interface is no commonly needed.

+** interface is not commonly needed.

 */

 #define SQLITE_INDEX_CONSTRAINT_EQ          2

 #define SQLITE_INDEX_CONSTRAINT_GT          4

@@ -7719,16 +7752,6 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
 SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);

 

 /*

-** The interface to the virtual-table mechanism defined above (back up

-** to a comment remarkably similar to this one) is currently considered

-** to be experimental.  The interface might change in incompatible ways.

-** If this is a problem for you, do not use the interface at this time.

-**

-** When the virtual-table mechanism stabilizes, we will declare the

-** interface fixed, support it indefinitely, and remove this comment.

-*/

-

-/*

 ** CAPI3REF: A Handle To An Open BLOB

 ** KEYWORDS: {BLOB handle} {BLOB handles}

 **

@@ -9931,7 +9954,7 @@ SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*);
 ** <li><p> Otherwise, "BINARY" is returned.

 ** </ol>

 */

-SQLITE_API SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

+SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

 

 /*

 ** CAPI3REF: Determine if a virtual table query is DISTINCT

@@ -10088,21 +10111,20 @@ SQLITE_API int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle);
 ** is undefined and probably harmful.

 **

 ** The X parameter in a call to sqlite3_vtab_in_first(X,P) or

-** sqlite3_vtab_in_next(X,P) must be one of the parameters to the

+** sqlite3_vtab_in_next(X,P) should be one of the parameters to the

 ** xFilter method which invokes these routines, and specifically

 ** a parameter that was previously selected for all-at-once IN constraint

 ** processing use the [sqlite3_vtab_in()] interface in the

 ** [xBestIndex|xBestIndex method].  ^(If the X parameter is not

 ** an xFilter argument that was selected for all-at-once IN constraint

-** processing, then these routines return [SQLITE_MISUSE])^ or perhaps

-** exhibit some other undefined or harmful behavior.

+** processing, then these routines return [SQLITE_ERROR].)^

 **

 ** ^(Use these routines to access all values on the right-hand side

 ** of the IN constraint using code like the following:

 **

 ** <blockquote><pre>

 ** &nbsp;  for(rc=sqlite3_vtab_in_first(pList, &pVal);

-** &nbsp;      rc==SQLITE_OK && pVal

+** &nbsp;      rc==SQLITE_OK && pVal;

 ** &nbsp;      rc=sqlite3_vtab_in_next(pList, &pVal)

 ** &nbsp;  ){

 ** &nbsp;    // do something with pVal

@@ -10200,6 +10222,10 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 ** managed by the prepared statement S and will be automatically freed when

 ** S is finalized.

 **

+** Not all values are available for all query elements. When a value is

+** not available, the output variable is set to -1 if the value is numeric,

+** or to NULL if it is a string (SQLITE_SCANSTAT_NAME).

+**

 ** <dl>

 ** [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>

 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be

@@ -10227,12 +10253,24 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 ** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]

 ** description for the X-th loop.

 **

-** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECT</dt>

+** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECTID</dt>

 ** <dd>^The "int" variable pointed to by the V parameter will be set to the

-** "select-id" for the X-th loop.  The select-id identifies which query or

-** subquery the loop is part of.  The main query has a select-id of zero.

-** The select-id is the same value as is output in the first column

-** of an [EXPLAIN QUERY PLAN] query.

+** id for the X-th query plan element. The id value is unique within the

+** statement. The select-id is the same value as is output in the first

+** column of an [EXPLAIN QUERY PLAN] query.

+**

+** [[SQLITE_SCANSTAT_PARENTID]] <dt>SQLITE_SCANSTAT_PARENTID</dt>

+** <dd>The "int" variable pointed to by the V parameter will be set to the

+** the id of the parent of the current query element, if applicable, or

+** to zero if the query element has no parent. This is the same value as

+** returned in the second column of an [EXPLAIN QUERY PLAN] query.

+**

+** [[SQLITE_SCANSTAT_NCYCLE]] <dt>SQLITE_SCANSTAT_NCYCLE</dt>

+** <dd>The sqlite3_int64 output value is set to the number of cycles,

+** according to the processor time-stamp counter, that elapsed while the

+** query element was being processed. This value is not available for

+** all query elements - if it is unavailable the output variable is

+** set to -1.

 ** </dl>

 */

 #define SQLITE_SCANSTAT_NLOOP    0

@@ -10241,12 +10279,14 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 #define SQLITE_SCANSTAT_NAME     3

 #define SQLITE_SCANSTAT_EXPLAIN  4

 #define SQLITE_SCANSTAT_SELECTID 5

+#define SQLITE_SCANSTAT_PARENTID 6

+#define SQLITE_SCANSTAT_NCYCLE   7

 

 /*

 ** CAPI3REF: Prepared Statement Scan Status

 ** METHOD: sqlite3_stmt

 **

-** This interface returns information about the predicted and measured

+** These interfaces return information about the predicted and measured

 ** performance for pStmt.  Advanced applications can use this

 ** interface to compare the predicted and the measured performance and

 ** issue warnings and/or rerun [ANALYZE] if discrepancies are found.

@@ -10257,19 +10297,25 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 **

 ** The "iScanStatusOp" parameter determines which status information to return.

 ** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior

-** of this interface is undefined.

-** ^The requested measurement is written into a variable pointed to by

-** the "pOut" parameter.

-** Parameter "idx" identifies the specific loop to retrieve statistics for.

-** Loops are numbered starting from zero. ^If idx is out of range - less than

-** zero or greater than or equal to the total number of loops used to implement

-** the statement - a non-zero value is returned and the variable that pOut

-** points to is unchanged.

-**

-** ^Statistics might not be available for all loops in all statements. ^In cases

-** where there exist loops with no available statistics, this function behaves

-** as if the loop did not exist - it returns non-zero and leave the variable

-** that pOut points to unchanged.

+** of this interface is undefined. ^The requested measurement is written into

+** a variable pointed to by the "pOut" parameter.

+**

+** The "flags" parameter must be passed a mask of flags. At present only

+** one flag is defined - SQLITE_SCANSTAT_COMPLEX. If SQLITE_SCANSTAT_COMPLEX

+** is specified, then status information is available for all elements

+** of a query plan that are reported by "EXPLAIN QUERY PLAN" output. If

+** SQLITE_SCANSTAT_COMPLEX is not specified, then only query plan elements

+** that correspond to query loops (the "SCAN..." and "SEARCH..." elements of

+** the EXPLAIN QUERY PLAN output) are available. Invoking API

+** sqlite3_stmt_scanstatus() is equivalent to calling

+** sqlite3_stmt_scanstatus_v2() with a zeroed flags parameter.

+**

+** Parameter "idx" identifies the specific query element to retrieve statistics

+** for. Query elements are numbered starting from zero. A value of -1 may be

+** to query for statistics regarding the entire query. ^If idx is out of range

+** - less than -1 or greater than or equal to the total number of query

+** elements used to implement the statement - a non-zero value is returned and

+** the variable that pOut points to is unchanged.

 **

 ** See also: [sqlite3_stmt_scanstatus_reset()]

 */

@@ -10279,6 +10325,19 @@ SQLITE_API int sqlite3_stmt_scanstatus(
   int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */

   void *pOut                /* Result written here */

 );

+SQLITE_API int sqlite3_stmt_scanstatus_v2(

+  sqlite3_stmt *pStmt,      /* Prepared statement for which info desired */

+  int idx,                  /* Index of loop to report on */

+  int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */

+  int flags,                /* Mask of flags defined below */

+  void *pOut                /* Result written here */

+);

+

+/*

+** CAPI3REF: Prepared Statement Scan Status

+** KEYWORDS: {scan status flags}

+*/

+#define SQLITE_SCANSTAT_COMPLEX 0x0001

 

 /*

 ** CAPI3REF: Zero Scan-Status Counters

@@ -10369,6 +10428,10 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 ** function is not defined for operations on WITHOUT ROWID tables, or for

 ** DELETE operations on rowid tables.

 **

+** ^The sqlite3_preupdate_hook(D,C,P) function returns the P argument from

+** the previous call on the same [database connection] D, or NULL for

+** the first call on D.

+**

 ** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()],

 ** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces

 ** provide additional information about a preupdate event. These routines

@@ -10774,6 +10837,19 @@ SQLITE_API int sqlite3_deserialize(
 # undef double

 #endif

 

+#if defined(__wasi__)

+# undef SQLITE_WASI

+# define SQLITE_WASI 1

+# undef SQLITE_OMIT_WAL

+# define SQLITE_OMIT_WAL 1/* because it requires shared memory APIs */

+# ifndef SQLITE_OMIT_LOAD_EXTENSION

+#  define SQLITE_OMIT_LOAD_EXTENSION

+# endif

+# ifndef SQLITE_THREADSAFE

+#  define SQLITE_THREADSAFE 0

+# endif

+#endif

+

 #if 0

 }  /* End of the 'extern "C"' block */

 #endif

@@ -14325,15 +14401,9 @@ typedef INT8_TYPE i8;              /* 1-byte signed integer */
 

 /*

 ** The datatype used to store estimates of the number of rows in a

-** table or index.  This is an unsigned integer type.  For 99.9% of

-** the world, a 32-bit integer is sufficient.  But a 64-bit integer

-** can be used at compile-time if desired.

+** table or index.

 */

-#ifdef SQLITE_64BIT_STATS

- typedef u64 tRowcnt;    /* 64-bit only if requested at compile-time */

-#else

- typedef u32 tRowcnt;    /* 32-bit is the default */

-#endif

+typedef u64 tRowcnt;

 

 /*

 ** Estimated quantities used for query planning are stored as 16-bit

@@ -14479,9 +14549,9 @@ typedef INT16_TYPE LogEst;
 ** pointers.  In that case, only verify 4-byte alignment.

 */

 #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC

-# define EIGHT_BYTE_ALIGNMENT(X)   ((((char*)(X) - (char*)0)&3)==0)

+# define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&3)==0)

 #else

-# define EIGHT_BYTE_ALIGNMENT(X)   ((((char*)(X) - (char*)0)&7)==0)

+# define EIGHT_BYTE_ALIGNMENT(X)   ((((uptr)(X) - (uptr)0)&7)==0)

 #endif

 

 /*

@@ -14535,15 +14605,38 @@ SQLITE_PRIVATE u32 sqlite3TreeTrace;
     && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE) \

                              || defined(SQLITE_ENABLE_TREETRACE))

 # define TREETRACE_ENABLED 1

-# define SELECTTRACE(K,P,S,X)  \

+# define TREETRACE(K,P,S,X)  \

   if(sqlite3TreeTrace&(K))   \

     sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\

     sqlite3DebugPrintf X

 #else

-# define SELECTTRACE(K,P,S,X)

+# define TREETRACE(K,P,S,X)

 # define TREETRACE_ENABLED 0

 #endif

 

+/* TREETRACE flag meanings:

+**

+**   0x00000001     Beginning and end of SELECT processing

+**   0x00000002     WHERE clause processing

+**   0x00000004     Query flattener

+**   0x00000008     Result-set wildcard expansion

+**   0x00000010     Query name resolution

+**   0x00000020     Aggregate analysis

+**   0x00000040     Window functions

+**   0x00000080     Generated column names

+**   0x00000100     Move HAVING terms into WHERE

+**   0x00000200     Count-of-view optimization

+**   0x00000400     Compound SELECT processing

+**   0x00000800     Drop superfluous ORDER BY

+**   0x00001000     LEFT JOIN simplifies to JOIN

+**   0x00002000     Constant propagation

+**   0x00004000     Push-down optimization

+**   0x00008000     After all FROM-clause analysis

+**   0x00010000     Beginning of DELETE/INSERT/UPDATE processing

+**   0x00020000     Transform DISTINCT into GROUP BY

+**   0x00040000     SELECT tree dump after all code has been generated

+*/

+

 /*

 ** Macros for "wheretrace"

 */

@@ -14556,6 +14649,36 @@ SQLITE_PRIVATE u32 sqlite3WhereTrace;
 # define WHERETRACE(K,X)

 #endif

 

+/*

+** Bits for the sqlite3WhereTrace mask:

+**

+** (---any--)   Top-level block structure

+** 0x-------F   High-level debug messages

+** 0x----FFF-   More detail

+** 0xFFFF----   Low-level debug messages

+**

+** 0x00000001   Code generation

+** 0x00000002   Solver

+** 0x00000004   Solver costs

+** 0x00000008   WhereLoop inserts

+**

+** 0x00000010   Display sqlite3_index_info xBestIndex calls

+** 0x00000020   Range an equality scan metrics

+** 0x00000040   IN operator decisions

+** 0x00000080   WhereLoop cost adjustements

+** 0x00000100

+** 0x00000200   Covering index decisions

+** 0x00000400   OR optimization

+** 0x00000800   Index scanner

+** 0x00001000   More details associated with code generation

+** 0x00002000

+** 0x00004000   Show all WHERE terms at key points

+** 0x00008000   Show the full SELECT statement at key places

+**

+** 0x00010000   Show more detail when printing WHERE terms

+** 0x00020000   Show WHERE terms returned from whereScanNext()

+*/

+

 

 /*

 ** An instance of the following structure is used to store the busy-handler

@@ -15536,7 +15659,7 @@ SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p);
 **     reduce network bandwidth.

 **

 ** Note that BTREE_HINT_FLAGS with BTREE_BULKLOAD is the only hint used by

-** standard SQLite.  The other hints are provided for extentions that use

+** standard SQLite.  The other hints are provided for extensions that use

 ** the SQLite parser and code generator but substitute their own storage

 ** engine.

 */

@@ -15682,7 +15805,15 @@ SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor*, u32 *pAmt);
 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*);

 SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor*);

 

-SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(sqlite3*,Btree*,Pgno*aRoot,int nRoot,int,int*);

+SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck(

+  sqlite3 *db,  /* Database connection that is running the check */

+  Btree *p,     /* The btree to be checked */

+  Pgno *aRoot,  /* An array of root pages numbers for individual trees */

+  int nRoot,    /* Number of entries in aRoot[] */

+  int mxErr,    /* Stop reporting errors after this many */

+  int *pnErr,   /* OUT: Write number of errors seen to this variable */

+  char **pzOut  /* OUT: Write the error message string here */

+);

 SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);

 SQLITE_PRIVATE i64 sqlite3BtreeRowCountEst(BtCursor*);

 

@@ -15839,14 +15970,14 @@ struct VdbeOp {
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS

   char *zComment;          /* Comment to improve readability */

 #endif

-#ifdef VDBE_PROFILE

-  u32 cnt;                 /* Number of times this instruction was executed */

-  u64 cycles;              /* Total time spent executing this instruction */

-#endif

 #ifdef SQLITE_VDBE_COVERAGE

   u32 iSrcLine;            /* Source-code line that generated this opcode

                            ** with flags in the upper 8 bits */

 #endif

+#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)

+  u64 nExec;

+  u64 nCycle;

+#endif

 };

 typedef struct VdbeOp VdbeOp;

 

@@ -16137,29 +16268,30 @@ typedef struct VdbeOpList VdbeOpList;
 #define OPFLG_IN3         0x08  /* in3:   P3 is an input */

 #define OPFLG_OUT2        0x10  /* out2:  P2 is an output */

 #define OPFLG_OUT3        0x20  /* out3:  P3 is an output */

+#define OPFLG_NCYCLE      0x40  /* ncycle:Cycles count against P1 */

 #define OPFLG_INITIALIZER {\

-/*   0 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x01, 0x00,\

+/*   0 */ 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x41, 0x00,\

 /*   8 */ 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x01, 0x01,\

-/*  16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x09, 0x09, 0x09,\

-/*  24 */ 0x09, 0x01, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,\

-/*  32 */ 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\

-/*  40 */ 0x01, 0x01, 0x01, 0x26, 0x26, 0x01, 0x23, 0x0b,\

+/*  16 */ 0x03, 0x03, 0x01, 0x12, 0x01, 0x49, 0x49, 0x49,\

+/*  24 */ 0x49, 0x01, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,\

+/*  32 */ 0x41, 0x01, 0x01, 0x01, 0x41, 0x01, 0x41, 0x41,\

+/*  40 */ 0x41, 0x41, 0x41, 0x26, 0x26, 0x41, 0x23, 0x0b,\

 /*  48 */ 0x01, 0x01, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\

-/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x03, 0x01, 0x01,\

+/*  56 */ 0x0b, 0x0b, 0x01, 0x03, 0x03, 0x03, 0x01, 0x41,\

 /*  64 */ 0x01, 0x00, 0x00, 0x02, 0x02, 0x08, 0x00, 0x10,\

 /*  72 */ 0x10, 0x10, 0x00, 0x10, 0x00, 0x10, 0x10, 0x00,\

 /*  80 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x02, 0x02,\

-/*  88 */ 0x02, 0x00, 0x00, 0x12, 0x1e, 0x20, 0x00, 0x00,\

-/*  96 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x26, 0x26,\

+/*  88 */ 0x02, 0x00, 0x00, 0x12, 0x1e, 0x20, 0x40, 0x00,\

+/*  96 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x40, 0x26, 0x26,\

 /* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,\

-/* 112 */ 0x00, 0x00, 0x12, 0x00, 0x00, 0x10, 0x00, 0x00,\

-/* 120 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10,\

-/* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\

-/* 136 */ 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x10, 0x00,\

+/* 112 */ 0x40, 0x00, 0x12, 0x40, 0x40, 0x10, 0x40, 0x00,\

+/* 120 */ 0x00, 0x00, 0x40, 0x00, 0x40, 0x40, 0x10, 0x10,\

+/* 128 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50,\

+/* 136 */ 0x00, 0x40, 0x04, 0x04, 0x00, 0x40, 0x50, 0x40,\

 /* 144 */ 0x10, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\

 /* 152 */ 0x00, 0x10, 0x00, 0x00, 0x06, 0x10, 0x00, 0x04,\

 /* 160 */ 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\

-/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,\

+/* 168 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x50, 0x40,\

 /* 176 */ 0x00, 0x10, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00,\

 /* 184 */ 0x00, 0x00, 0x00,}

 

@@ -16214,14 +16346,20 @@ SQLITE_PRIVATE   void sqlite3VdbeNoJumpsOutsideSubrtn(Vdbe*,int,int,int);
 #endif

 SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno);

 #ifndef SQLITE_OMIT_EXPLAIN

-SQLITE_PRIVATE   void sqlite3VdbeExplain(Parse*,u8,const char*,...);

+SQLITE_PRIVATE   int sqlite3VdbeExplain(Parse*,u8,const char*,...);

 SQLITE_PRIVATE   void sqlite3VdbeExplainPop(Parse*);

 SQLITE_PRIVATE   int sqlite3VdbeExplainParent(Parse*);

 # define ExplainQueryPlan(P)        sqlite3VdbeExplain P

+# ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+#  define ExplainQueryPlan2(V,P)     (V = sqlite3VdbeExplain P)

+# else

+#  define ExplainQueryPlan2(V,P)     ExplainQueryPlan(P)

+# endif

 # define ExplainQueryPlanPop(P)     sqlite3VdbeExplainPop(P)

 # define ExplainQueryPlanParent(P)  sqlite3VdbeExplainParent(P)

 #else

 # define ExplainQueryPlan(P)

+# define ExplainQueryPlan2(V,P)

 # define ExplainQueryPlanPop(P)

 # define ExplainQueryPlanParent(P) 0

 # define sqlite3ExplainBreakpoint(A,B) /*no-op*/

@@ -16394,8 +16532,12 @@ SQLITE_PRIVATE   void sqlite3VdbeSetLineNumber(Vdbe*,int);
 

 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS

 SQLITE_PRIVATE void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const char*);

+SQLITE_PRIVATE void sqlite3VdbeScanStatusRange(Vdbe*, int, int, int);

+SQLITE_PRIVATE void sqlite3VdbeScanStatusCounters(Vdbe*, int, int, int);

 #else

-# define sqlite3VdbeScanStatus(a,b,c,d,e)

+# define sqlite3VdbeScanStatus(a,b,c,d,e,f)

+# define sqlite3VdbeScanStatusRange(a,b,c,d)

+# define sqlite3VdbeScanStatusCounters(a,b,c,d)

 #endif

 

 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)

@@ -17192,6 +17334,7 @@ struct sqlite3 {
 #define SQLITE_FlttnUnionAll  0x00800000 /* Disable the UNION ALL flattener */

    /* TH3 expects this value  ^^^^^^^^^^ See flatten04.test */

 #define SQLITE_IndexedExpr    0x01000000 /* Pull exprs from index when able */

+#define SQLITE_Coroutines     0x02000000 /* Co-routines for subqueries */

 #define SQLITE_AllOpts        0xffffffff /* All optimizations */

 

 /*

@@ -17276,8 +17419,14 @@ struct FuncDestructor {
 **     SQLITE_FUNC_TYPEOF      ==  OPFLAG_TYPEOFARG

 **     SQLITE_FUNC_CONSTANT    ==  SQLITE_DETERMINISTIC from the API

 **     SQLITE_FUNC_DIRECT      ==  SQLITE_DIRECTONLY from the API

-**     SQLITE_FUNC_UNSAFE      ==  SQLITE_INNOCUOUS

+**     SQLITE_FUNC_UNSAFE      ==  SQLITE_INNOCUOUS  -- opposite meanings!!!

 **     SQLITE_FUNC_ENCMASK   depends on SQLITE_UTF* macros in the API

+**

+** Note that even though SQLITE_FUNC_UNSAFE and SQLITE_INNOCUOUS have the

+** same bit value, their meanings are inverted.  SQLITE_FUNC_UNSAFE is

+** used internally and if set means tha the function has side effects.

+** SQLITE_INNOCUOUS is used by application code and means "not unsafe".

+** See multiple instances of tag-20230109-1.

 */

 #define SQLITE_FUNC_ENCMASK  0x0003 /* SQLITE_UTF8, SQLITE_UTF16BE or UTF16LE */

 #define SQLITE_FUNC_LIKE     0x0004 /* Candidate for the LIKE optimization */

@@ -17394,7 +17543,7 @@ struct FuncDestructor {
   {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \

    xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }

 #define JFUNCTION(zName, nArg, iArg, xFunc) \

-  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS|\

+  {nArg, SQLITE_FUNC_BUILTIN|SQLITE_DETERMINISTIC|\

    SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \

    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }

 #define INLINE_FUNC(zName, nArg, iArg, mFlags) \

@@ -17586,6 +17735,7 @@ struct CollSeq {
 #define SQLITE_AFF_NUMERIC  0x43  /* 'C' */

 #define SQLITE_AFF_INTEGER  0x44  /* 'D' */

 #define SQLITE_AFF_REAL     0x45  /* 'E' */

+#define SQLITE_AFF_FLEXNUM  0x46  /* 'F' */

 

 #define sqlite3IsNumericAffinity(X)  ((X)>=SQLITE_AFF_NUMERIC)

 

@@ -18117,16 +18267,15 @@ struct AggInfo {
                           ** from source tables rather than from accumulators */

   u8 useSortingIdx;       /* In direct mode, reference the sorting index rather

                           ** than the source table */

+  u16 nSortingColumn;     /* Number of columns in the sorting index */

   int sortingIdx;         /* Cursor number of the sorting index */

   int sortingIdxPTab;     /* Cursor number of pseudo-table */

-  int nSortingColumn;     /* Number of columns in the sorting index */

-  int mnReg, mxReg;       /* Range of registers allocated for aCol and aFunc */

+  int iFirstReg;          /* First register in range for aCol[] and aFunc[] */

   ExprList *pGroupBy;     /* The group by clause */

   struct AggInfo_col {    /* For each column used in source tables */

     Table *pTab;             /* Source table */

     Expr *pCExpr;            /* The original expression */

     int iTable;              /* Cursor number of the source table */

-    int iMem;                /* Memory location that acts as accumulator */

     i16 iColumn;             /* Column number within the source table */

     i16 iSorterColumn;       /* Column number in the sorting index */

   } *aCol;

@@ -18137,15 +18286,28 @@ struct AggInfo {
   struct AggInfo_func {   /* For each aggregate function */

     Expr *pFExpr;            /* Expression encoding the function */

     FuncDef *pFunc;          /* The aggregate function implementation */

-    int iMem;                /* Memory location that acts as accumulator */

     int iDistinct;           /* Ephemeral table used to enforce DISTINCT */

     int iDistAddr;           /* Address of OP_OpenEphemeral */

   } *aFunc;

   int nFunc;              /* Number of entries in aFunc[] */

   u32 selId;              /* Select to which this AggInfo belongs */

+#ifdef SQLITE_DEBUG

+  Select *pSelect;        /* SELECT statement that this AggInfo supports */

+#endif

 };

 

 /*

+** Macros to compute aCol[] and aFunc[] register numbers.

+**

+** These macros should not be used prior to the call to

+** assignAggregateRegisters() that computes the value of pAggInfo->iFirstReg.

+** The assert()s that are part of this macro verify that constraint.

+*/

+#define AggInfoColumnReg(A,I)  (assert((A)->iFirstReg),(A)->iFirstReg+(I))

+#define AggInfoFuncReg(A,I)    \

+                      (assert((A)->iFirstReg),(A)->iFirstReg+(A)->nColumn+(I))

+

+/*

 ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.

 ** Usually it is 16-bits.  But if SQLITE_MAX_VARIABLE_NUMBER is greater

 ** than 32767 we have to make it 32-bit.  16-bit is preferred because

@@ -18804,6 +18966,7 @@ struct Select {
 #define SF_MultiPart     0x2000000 /* Has multiple incompatible PARTITIONs */

 #define SF_CopyCte       0x4000000 /* SELECT statement is a copy of a CTE */

 #define SF_OrderByReqd   0x8000000 /* The ORDER BY clause may not be omitted */

+#define SF_UpdateFrom   0x10000000 /* Query originates with UPDATE FROM */

 

 /* True if S exists and has SF_NestedFrom */

 #define IsNestedFrom(S) ((S)!=0 && ((S)->selFlags&SF_NestedFrom)!=0)

@@ -18912,7 +19075,7 @@ struct SelectDest {
   int iSDParm2;        /* A second parameter for the eDest disposal method */

   int iSdst;           /* Base register where results are written */

   int nSdst;           /* Number of registers allocated */

-  char *zAffSdst;      /* Affinity used for SRT_Set, SRT_Table, and similar */

+  char *zAffSdst;      /* Affinity used for SRT_Set */

   ExprList *pOrderBy;  /* Key columns for SRT_Queue and SRT_DistQueue */

 };

 

@@ -18971,10 +19134,10 @@ struct TriggerPrg {
 #else

   typedef unsigned int yDbMask;

 # define DbMaskTest(M,I)    (((M)&(((yDbMask)1)<<(I)))!=0)

-# define DbMaskZero(M)      (M)=0

-# define DbMaskSet(M,I)     (M)|=(((yDbMask)1)<<(I))

-# define DbMaskAllZero(M)   (M)==0

-# define DbMaskNonZero(M)   (M)!=0

+# define DbMaskZero(M)      ((M)=0)

+# define DbMaskSet(M,I)     ((M)|=(((yDbMask)1)<<(I)))

+# define DbMaskAllZero(M)   ((M)==0)

+# define DbMaskNonZero(M)   ((M)!=0)

 #endif

 

 /*

@@ -19057,7 +19220,7 @@ struct Parse {
   int nLabelAlloc;     /* Number of slots in aLabel */

   int *aLabel;         /* Space to hold the labels */

   ExprList *pConstExpr;/* Constant expressions */

-  IndexedExpr *pIdxExpr;/* List of expressions used by active indexes */

+  IndexedExpr *pIdxEpr;/* List of expressions used by active indexes */

   Token constraintName;/* Name of the constraint currently being parsed */

   yDbMask writeMask;   /* Start a write transaction on these databases */

   yDbMask cookieMask;  /* Bitmask of schema verified databases */

@@ -19081,6 +19244,9 @@ struct Parse {
   u32 nQueryLoop;      /* Est number of iterations of a query (10*log2(N)) */

   u32 oldmask;         /* Mask of old.* columns referenced */

   u32 newmask;         /* Mask of new.* columns referenced */

+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK

+  u32 nProgressSteps;  /* xProgress steps taken during sqlite3_prepare() */

+#endif

   u8 eTriggerOp;       /* TK_UPDATE, TK_INSERT or TK_DELETE */

   u8 bReturning;       /* Coding a RETURNING trigger */

   u8 eOrconf;          /* Default ON CONFLICT policy for trigger steps */

@@ -19829,13 +19995,11 @@ SQLITE_PRIVATE int sqlite3HeapNearlyFull(void);
 #ifdef SQLITE_USE_ALLOCA

 # define sqlite3StackAllocRaw(D,N)   alloca(N)

 # define sqlite3StackAllocRawNN(D,N) alloca(N)

-# define sqlite3StackAllocZero(D,N)  memset(alloca(N), 0, N)

 # define sqlite3StackFree(D,P)

 # define sqlite3StackFreeNN(D,P)

 #else

 # define sqlite3StackAllocRaw(D,N)   sqlite3DbMallocRaw(D,N)

 # define sqlite3StackAllocRawNN(D,N) sqlite3DbMallocRawNN(D,N)

-# define sqlite3StackAllocZero(D,N)  sqlite3DbMallocZero(D,N)

 # define sqlite3StackFree(D,P)       sqlite3DbFree(D,P)

 # define sqlite3StackFreeNN(D,P)     sqlite3DbFreeNN(D,P)

 #endif

@@ -19960,6 +20124,7 @@ SQLITE_PRIVATE   void sqlite3ShowWinFunc(const Window*);
 #endif

 

 SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*);

+SQLITE_PRIVATE void sqlite3ProgressCheck(Parse*);

 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);

 SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int);

 SQLITE_PRIVATE void sqlite3Dequote(char*);

@@ -20017,7 +20182,7 @@ SQLITE_PRIVATE const char *sqlite3ColumnColl(Column*);
 SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*);

 SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse *pParse, Select *pSelect);

 SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**);

-SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(Parse*,Table*,Select*,char);

+SQLITE_PRIVATE void sqlite3SubqueryColumnTypes(Parse*,Table*,Select*,char);

 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*,char);

 SQLITE_PRIVATE void sqlite3OpenSchemaTable(Parse *, int);

 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table*);

@@ -20337,7 +20502,7 @@ SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*);
 SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);

 SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64);

 SQLITE_PRIVATE i64 sqlite3RealToI64(double);

-SQLITE_PRIVATE void sqlite3Int64ToText(i64,char*);

+SQLITE_PRIVATE int sqlite3Int64ToText(i64,char*);

 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8);

 SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*);

 SQLITE_PRIVATE int sqlite3GetUInt32(const char*, u32*);

@@ -20388,6 +20553,7 @@ SQLITE_PRIVATE char sqlite3CompareAffinity(const Expr *pExpr, char aff2);
 SQLITE_PRIVATE int sqlite3IndexAffinityOk(const Expr *pExpr, char idx_affinity);

 SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table*,int);

 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr);

+SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr);

 SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8);

 SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char*, i64*);

 SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3*, int, const char*,...);

@@ -20404,6 +20570,9 @@ SQLITE_PRIVATE const char *sqlite3ErrName(int);
 

 #ifndef SQLITE_OMIT_DESERIALIZE

 SQLITE_PRIVATE int sqlite3MemdbInit(void);

+SQLITE_PRIVATE int sqlite3IsMemdb(const sqlite3_vfs*);

+#else

+# define sqlite3IsMemdb(X) 0

 #endif

 

 SQLITE_PRIVATE const char *sqlite3ErrStr(int);

@@ -20543,7 +20712,7 @@ SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int);
 SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *);

 

 SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, sqlite3*, char*, int, int);

-SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum*, int);

+SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum*, i64);

 SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*);

 SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum*, u8);

 SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context*,StrAccum*);

@@ -20901,6 +21070,12 @@ SQLITE_PRIVATE const char **sqlite3CompileOptions(int *pnOpt);
 SQLITE_PRIVATE int sqlite3KvvfsInit(void);

 #endif

 

+#if defined(VDBE_PROFILE) \

+ || defined(SQLITE_PERFORMANCE_TRACE) \

+ || defined(SQLITE_ENABLE_STMT_SCANSTATUS)

+SQLITE_PRIVATE sqlite3_uint64 sqlite3Hwtime(void);

+#endif

+

 #endif /* SQLITEINT_H */

 

 /************** End of sqliteInt.h *******************************************/

@@ -20942,101 +21117,6 @@ SQLITE_PRIVATE int sqlite3KvvfsInit(void);
 */

 #ifdef SQLITE_PERFORMANCE_TRACE

 

-/*

-** hwtime.h contains inline assembler code for implementing

-** high-performance timing routines.

-*/

-/************** Include hwtime.h in the middle of os_common.h ****************/

-/************** Begin file hwtime.h ******************************************/

-/*

-** 2008 May 27

-**

-** The author disclaims copyright to this source code.  In place of

-** a legal notice, here is a blessing:

-**

-**    May you do good and not evil.

-**    May you find forgiveness for yourself and forgive others.

-**    May you share freely, never taking more than you give.

-**

-******************************************************************************

-**

-** This file contains inline asm code for retrieving "high-performance"

-** counters for x86 and x86_64 class CPUs.

-*/

-#ifndef SQLITE_HWTIME_H

-#define SQLITE_HWTIME_H

-

-/*

-** The following routine only works on pentium-class (or newer) processors.

-** It uses the RDTSC opcode to read the cycle count value out of the

-** processor and returns that value.  This can be used for high-res

-** profiling.

-*/

-#if !defined(__STRICT_ANSI__) && \

-    (defined(__GNUC__) || defined(_MSC_VER)) && \

-    (defined(i386) || defined(__i386__) || defined(_M_IX86))

-

-  #if defined(__GNUC__)

-

-  __inline__ sqlite_uint64 sqlite3Hwtime(void){

-     unsigned int lo, hi;

-     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));

-     return (sqlite_uint64)hi << 32 | lo;

-  }

-

-  #elif defined(_MSC_VER)

-

-  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){

-     __asm {

-        rdtsc

-        ret       ; return value at EDX:EAX

-     }

-  }

-

-  #endif

-

-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))

-

-  __inline__ sqlite_uint64 sqlite3Hwtime(void){

-      unsigned long val;

-      __asm__ __volatile__ ("rdtsc" : "=A" (val));

-      return val;

-  }

-

-#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))

-

-  __inline__ sqlite_uint64 sqlite3Hwtime(void){

-      unsigned long long retval;

-      unsigned long junk;

-      __asm__ __volatile__ ("\n\

-          1:      mftbu   %1\n\

-                  mftb    %L0\n\

-                  mftbu   %0\n\

-                  cmpw    %0,%1\n\

-                  bne     1b"

-                  : "=r" (retval), "=r" (junk));

-      return retval;

-  }

-

-#else

-

-  /*

-  ** asm() is needed for hardware timing support.  Without asm(),

-  ** disable the sqlite3Hwtime() routine.

-  **

-  ** sqlite3Hwtime() is only used for some obscure debugging

-  ** and analysis configurations, not in any deliverable, so this

-  ** should not be a great loss.

-  */

-SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }

-

-#endif

-

-#endif /* !defined(SQLITE_HWTIME_H) */

-

-/************** End of hwtime.h **********************************************/

-/************** Continuing where we left off in os_common.h ******************/

-

 static sqlite_uint64 g_start;

 static sqlite_uint64 g_elapsed;

 #define TIMER_START       g_start=sqlite3Hwtime()

@@ -22481,7 +22561,6 @@ struct VdbeFrame {
   Vdbe *v;                /* VM this frame belongs to */

   VdbeFrame *pParent;     /* Parent of this frame, or NULL if parent is main */

   Op *aOp;                /* Program instructions for parent frame */

-  i64 *anExec;            /* Event counters from parent frame */

   Mem *aMem;              /* Array of memory cells for parent frame */

   VdbeCursor **apCsr;     /* Array of Vdbe cursors for parent frame */

   u8 *aOnce;              /* Bitmask used by OP_Once */

@@ -22697,10 +22776,19 @@ typedef unsigned bft;  /* Bit Field Type */
 

 /* The ScanStatus object holds a single value for the

 ** sqlite3_stmt_scanstatus() interface.

+**

+** aAddrRange[]:

+**   This array is used by ScanStatus elements associated with EQP

+**   notes that make an SQLITE_SCANSTAT_NCYCLE value available. It is

+**   an array of up to 3 ranges of VM addresses for which the Vdbe.anCycle[]

+**   values should be summed to calculate the NCYCLE value. Each pair of

+**   integer addresses is a start and end address (both inclusive) for a range

+**   instructions. A start value of 0 indicates an empty range.

 */

 typedef struct ScanStatus ScanStatus;

 struct ScanStatus {

   int addrExplain;                /* OP_Explain for loop */

+  int aAddrRange[6];

   int addrLoop;                   /* Address of "loops" counter */

   int addrVisit;                  /* Address of "rows visited" counter */

   int iSelectID;                  /* The "Select-ID" for this loop */

@@ -22756,7 +22844,7 @@ struct Vdbe {
   int nOp;                /* Number of instructions in the program */

   int nOpAlloc;           /* Slots allocated for aOp[] */

   Mem *aColName;          /* Column names to return */

-  Mem *pResultSet;        /* Pointer to an array of results */

+  Mem *pResultRow;        /* Current output row */

   char *zErrMsg;          /* Error message written here */

   VList *pVList;          /* Name of variables */

 #ifndef SQLITE_OMIT_TRACE

@@ -22793,7 +22881,6 @@ struct Vdbe {
   SubProgram *pProgram;   /* Linked list of all sub-programs used by VM */

   AuxData *pAuxData;      /* Linked list of auxdata allocations */

 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-  i64 *anExec;            /* Number of times each op has been executed */

   int nScan;              /* Entries in aScan[] */

   ScanStatus *aScan;      /* Scan definitions for sqlite3_stmt_scanstatus() */

 #endif

@@ -22960,6 +23047,8 @@ SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *, int *);
 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);

 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);

 

+SQLITE_PRIVATE void sqlite3VdbeValueListFree(void*);

+

 #ifdef SQLITE_DEBUG

 SQLITE_PRIVATE   void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*);

 SQLITE_PRIVATE   void sqlite3VdbeAssertAbortable(Vdbe*);

@@ -24147,7 +24236,7 @@ static int parseModifier(
           i64 iOrigJD;              /* Original localtime */

           i64 iGuess;               /* Guess at the corresponding utc time */

           int cnt = 0;              /* Safety to prevent infinite loop */

-          int iErr;                 /* Guess is off by this much */

+          i64 iErr;                 /* Guess is off by this much */

 

           computeJD(p);

           iGuess = iOrigJD = p->iJD;

@@ -29215,7 +29304,7 @@ static void mallocWithAlarm(int n, void **pp){
 ** The upper bound is slightly less than 2GiB:  0x7ffffeff == 2,147,483,391

 ** This provides a 256-byte safety margin for defense against 32-bit

 ** signed integer overflow bugs when computing memory allocation sizes.

-** Parnoid applications might want to reduce the maximum allocation size

+** Paranoid applications might want to reduce the maximum allocation size

 ** further for an even larger safety margin.  0x3fffffff or 0x0fffffff

 ** or even smaller would be reasonable upper bounds on the size of a memory

 ** allocations for most applications.

@@ -29729,9 +29818,14 @@ SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
 */

 SQLITE_PRIVATE char *sqlite3DbSpanDup(sqlite3 *db, const char *zStart, const char *zEnd){

   int n;

+#ifdef SQLITE_DEBUG

+  /* Because of the way the parser works, the span is guaranteed to contain

+  ** at least one non-space character */

+  for(n=0; sqlite3Isspace(zStart[n]); n++){ assert( &zStart[n]<zEnd ); }

+#endif

   while( sqlite3Isspace(zStart[0]) ) zStart++;

   n = (int)(zEnd - zStart);

-  while( ALWAYS(n>0) && sqlite3Isspace(zStart[n-1]) ) n--;

+  while( sqlite3Isspace(zStart[n-1]) ) n--;

   return sqlite3DbStrNDup(db, zStart, n);

 }

 

@@ -30570,13 +30664,26 @@ SQLITE_API void sqlite3_str_vappendf(
           }

         }

         if( precision>1 ){

+          i64 nPrior = 1;

           width -= precision-1;

           if( width>1 && !flag_leftjustify ){

             sqlite3_str_appendchar(pAccum, width-1, ' ');

             width = 0;

           }

-          while( precision-- > 1 ){

-            sqlite3_str_append(pAccum, buf, length);

+          sqlite3_str_append(pAccum, buf, length);

+          precision--;

+          while( precision > 1 ){

+            i64 nCopyBytes;

+            if( nPrior > precision-1 ) nPrior = precision - 1;

+            nCopyBytes = length*nPrior;

+            if( nCopyBytes + pAccum->nChar >= pAccum->nAlloc ){

+              sqlite3StrAccumEnlarge(pAccum, nCopyBytes);

+            }

+            if( pAccum->accError ) break;

+            sqlite3_str_append(pAccum,

+                 &pAccum->zText[pAccum->nChar-nCopyBytes], nCopyBytes);

+            precision -= nPrior;

+            nPrior *= 2;

           }

         }

         bufpt = buf;

@@ -30804,9 +30911,9 @@ SQLITE_PRIVATE void sqlite3RecordErrorOffsetOfExpr(sqlite3 *db, const Expr *pExp
 ** Return the number of bytes of text that StrAccum is able to accept

 ** after the attempted enlargement.  The value returned might be zero.

 */

-SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum *p, int N){

+SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum *p, i64 N){

   char *zNew;

-  assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */

+  assert( p->nChar+N >= p->nAlloc ); /* Only called if really needed */

   if( p->accError ){

     testcase(p->accError==SQLITE_TOOBIG);

     testcase(p->accError==SQLITE_NOMEM);

@@ -30817,8 +30924,7 @@ SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum *p, int N){
     return p->nAlloc - p->nChar - 1;

   }else{

     char *zOld = isMalloced(p) ? p->zText : 0;

-    i64 szNew = p->nChar;

-    szNew += (sqlite3_int64)N + 1;

+    i64 szNew = p->nChar + N + 1;

     if( szNew+p->nChar<=p->mxAlloc ){

       /* Force exponential buffer size growth as long as it does not overflow,

       ** to avoid having to call this routine too often */

@@ -30848,7 +30954,8 @@ SQLITE_PRIVATE int sqlite3StrAccumEnlarge(StrAccum *p, int N){
       return 0;

     }

   }

-  return N;

+  assert( N>=0 && N<=0x7fffffff );

+  return (int)N;

 }

 

 /*

@@ -31444,6 +31551,13 @@ SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc)
     if( pItem->fg.isOn || (pItem->fg.isUsing==0 && pItem->u3.pOn!=0) ){

       sqlite3_str_appendf(&x, " ON");

     }

+    if( pItem->fg.isTabFunc )      sqlite3_str_appendf(&x, " isTabFunc");

+    if( pItem->fg.isCorrelated )   sqlite3_str_appendf(&x, " isCorrelated");

+    if( pItem->fg.isMaterialized ) sqlite3_str_appendf(&x, " isMaterialized");

+    if( pItem->fg.viaCoroutine )   sqlite3_str_appendf(&x, " viaCoroutine");

+    if( pItem->fg.notCte )         sqlite3_str_appendf(&x, " notCte");

+    if( pItem->fg.isNestedFrom )   sqlite3_str_appendf(&x, " isNestedFrom");

+

     sqlite3StrAccumFinish(&x);

     sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);

     n = 0;

@@ -31713,7 +31827,7 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     sqlite3TreeViewPop(&pView);

     return;

   }

-  if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags ){

+  if( pExpr->flags || pExpr->affExpr || pExpr->vvaFlags || pExpr->pAggInfo ){

     StrAccum x;

     sqlite3StrAccumInit(&x, 0, zFlgs, sizeof(zFlgs), 0);

     sqlite3_str_appendf(&x, " fg.af=%x.%c",

@@ -31730,6 +31844,9 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     if( ExprHasVVAProperty(pExpr, EP_Immutable) ){

       sqlite3_str_appendf(&x, " IMMUTABLE");

     }

+    if( pExpr->pAggInfo!=0 ){

+      sqlite3_str_appendf(&x, " agg-column[%d]", pExpr->iAgg);

+    }

     sqlite3StrAccumFinish(&x);

   }else{

     zFlgs[0] = 0;

@@ -33670,6 +33787,26 @@ SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *z
 }

 

 /*

+** Check for interrupts and invoke progress callback.

+*/

+SQLITE_PRIVATE void sqlite3ProgressCheck(Parse *p){

+  sqlite3 *db = p->db;

+  if( AtomicLoad(&db->u1.isInterrupted) ){

+    p->nErr++;

+    p->rc = SQLITE_INTERRUPT;

+  }

+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK

+  if( db->xProgress && (++p->nProgressSteps)>=db->nProgressOps ){

+    if( db->xProgress(db->pProgressArg) ){

+      p->nErr++;

+      p->rc = SQLITE_INTERRUPT;

+    }

+    p->nProgressSteps = 0;

+  }

+#endif

+}

+

+/*

 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.

 **

 ** This function should be used to report any error that occurs while

@@ -34126,11 +34263,14 @@ do_atof_calc:
 #endif

 

 /*

-** Render an signed 64-bit integer as text.  Store the result in zOut[].

+** Render an signed 64-bit integer as text.  Store the result in zOut[] and

+** return the length of the string that was stored, in bytes.  The value

+** returned does not include the zero terminator at the end of the output

+** string.

 **

 ** The caller must ensure that zOut[] is at least 21 bytes in size.

 */

-SQLITE_PRIVATE void sqlite3Int64ToText(i64 v, char *zOut){

+SQLITE_PRIVATE int sqlite3Int64ToText(i64 v, char *zOut){

   int i;

   u64 x;

   char zTemp[22];

@@ -34147,6 +34287,7 @@ SQLITE_PRIVATE void sqlite3Int64ToText(i64 v, char *zOut){
   }while( x );

   if( v<0 ) zTemp[i--] = '-';

   memcpy(zOut, &zTemp[i+1], sizeof(zTemp)-1-i);

+  return sizeof(zTemp)-2-i;

 }

 

 /*

@@ -35208,6 +35349,104 @@ SQLITE_PRIVATE int sqlite3VListNameToNum(VList *pIn, const char *zName, int nNam
   return 0;

 }

 

+/*

+** High-resolution hardware timer used for debugging and testing only.

+*/

+#if defined(VDBE_PROFILE)  \

+ || defined(SQLITE_PERFORMANCE_TRACE) \

+ || defined(SQLITE_ENABLE_STMT_SCANSTATUS)

+/************** Include hwtime.h in the middle of util.c *********************/

+/************** Begin file hwtime.h ******************************************/

+/*

+** 2008 May 27

+**

+** The author disclaims copyright to this source code.  In place of

+** a legal notice, here is a blessing:

+**

+**    May you do good and not evil.

+**    May you find forgiveness for yourself and forgive others.

+**    May you share freely, never taking more than you give.

+**

+******************************************************************************

+**

+** This file contains inline asm code for retrieving "high-performance"

+** counters for x86 and x86_64 class CPUs.

+*/

+#ifndef SQLITE_HWTIME_H

+#define SQLITE_HWTIME_H

+

+/*

+** The following routine only works on pentium-class (or newer) processors.

+** It uses the RDTSC opcode to read the cycle count value out of the

+** processor and returns that value.  This can be used for high-res

+** profiling.

+*/

+#if !defined(__STRICT_ANSI__) && \

+    (defined(__GNUC__) || defined(_MSC_VER)) && \

+    (defined(i386) || defined(__i386__) || defined(_M_IX86))

+

+  #if defined(__GNUC__)

+

+  __inline__ sqlite_uint64 sqlite3Hwtime(void){

+     unsigned int lo, hi;

+     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));

+     return (sqlite_uint64)hi << 32 | lo;

+  }

+

+  #elif defined(_MSC_VER)

+

+  __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){

+     __asm {

+        rdtsc

+        ret       ; return value at EDX:EAX

+     }

+  }

+

+  #endif

+

+#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__x86_64__))

+

+  __inline__ sqlite_uint64 sqlite3Hwtime(void){

+     unsigned int lo, hi;

+     __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));

+     return (sqlite_uint64)hi << 32 | lo;

+  }

+

+#elif !defined(__STRICT_ANSI__) && (defined(__GNUC__) && defined(__ppc__))

+

+  __inline__ sqlite_uint64 sqlite3Hwtime(void){

+      unsigned long long retval;

+      unsigned long junk;

+      __asm__ __volatile__ ("\n\

+          1:      mftbu   %1\n\

+                  mftb    %L0\n\

+                  mftbu   %0\n\

+                  cmpw    %0,%1\n\

+                  bne     1b"

+                  : "=r" (retval), "=r" (junk));

+      return retval;

+  }

+

+#else

+

+  /*

+  ** asm() is needed for hardware timing support.  Without asm(),

+  ** disable the sqlite3Hwtime() routine.

+  **

+  ** sqlite3Hwtime() is only used for some obscure debugging

+  ** and analysis configurations, not in any deliverable, so this

+  ** should not be a great loss.

+  */

+SQLITE_PRIVATE   sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }

+

+#endif

+

+#endif /* !defined(SQLITE_HWTIME_H) */

+

+/************** End of hwtime.h **********************************************/

+/************** Continuing where we left off in util.c ***********************/

+#endif

+

 /************** End of util.c ************************************************/

 /************** Begin file hash.c ********************************************/

 /*

@@ -35378,12 +35617,13 @@ static HashElem *findElementWithHash(
     count = pH->count;

   }

   if( pHash ) *pHash = h;

-  while( count-- ){

+  while( count ){

     assert( elem!=0 );

     if( sqlite3StrICmp(elem->pKey,pKey)==0 ){

       return elem;

     }

     elem = elem->next;

+    count--;

   }

   return &nullElement;

 }

@@ -35742,7 +35982,9 @@ struct KVVfsFile {
   char *aJrnl;                    /* Journal content */

   int szPage;                     /* Last known page size */

   sqlite3_int64 szDb;             /* Database file size.  -1 means unknown */

+  char *aData;                    /* Buffer to hold page data */

 };

+#define SQLITE_KVOS_SZ 133073

 

 /*

 ** Methods for KVVfsFile

@@ -36105,8 +36347,7 @@ static int kvvfsDecode(const char *a, char *aOut, int nOut){
       if( j+n>nOut ) return -1;

       memset(&aOut[j], 0, n);

       j += n;

-      c = aIn[i];

-      if( c==0 ) break;

+      if( c==0 || mult==1 ) break; /* progress stalled if mult==1 */

     }else{

       aOut[j] = c<<4;

       c = kvvfsHexValue[aIn[++i]];

@@ -36183,6 +36424,7 @@ static int kvvfsClose(sqlite3_file *pProtoFile){
   SQLITE_KV_LOG(("xClose %s %s\n", pFile->zClass,

              pFile->isJournal ? "journal" : "db"));

   sqlite3_free(pFile->aJrnl);

+  sqlite3_free(pFile->aData);

   return SQLITE_OK;

 }

 

@@ -36231,7 +36473,7 @@ static int kvvfsReadDb(
   unsigned int pgno;

   int got, n;

   char zKey[30];

-  char aData[133073];

+  char *aData = pFile->aData;

   assert( iOfst>=0 );

   assert( iAmt>=0 );

   SQLITE_KV_LOG(("xRead('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));

@@ -36248,7 +36490,8 @@ static int kvvfsReadDb(
     pgno = 1;

   }

   sqlite3_snprintf(sizeof(zKey), zKey, "%u", pgno);

-  got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey, aData, sizeof(aData)-1);

+  got = sqlite3KvvfsMethods.xRead(pFile->zClass, zKey,

+                                  aData, SQLITE_KVOS_SZ-1);

   if( got<0 ){

     n = 0;

   }else{

@@ -36256,7 +36499,7 @@ static int kvvfsReadDb(
     if( iOfst+iAmt<512 ){

       int k = iOfst+iAmt;

       aData[k*2] = 0;

-      n = kvvfsDecode(aData, &aData[2000], sizeof(aData)-2000);

+      n = kvvfsDecode(aData, &aData[2000], SQLITE_KVOS_SZ-2000);

       if( n>=iOfst+iAmt ){

         memcpy(zBuf, &aData[2000+iOfst], iAmt);

         n = iAmt;

@@ -36315,7 +36558,7 @@ static int kvvfsWriteDb(
   KVVfsFile *pFile = (KVVfsFile*)pProtoFile;

   unsigned int pgno;

   char zKey[30];

-  char aData[131073];

+  char *aData = pFile->aData;

   SQLITE_KV_LOG(("xWrite('%s-db',%d,%lld)\n", pFile->zClass, iAmt, iOfst));

   assert( iAmt>=512 && iAmt<=65536 );

   assert( (iAmt & (iAmt-1))==0 );

@@ -36524,6 +36767,10 @@ static int kvvfsOpen(
   }else{

     pFile->zClass = "local";

   }

+  pFile->aData = sqlite3_malloc64(SQLITE_KVOS_SZ);

+  if( pFile->aData==0 ){

+    return SQLITE_NOMEM;

+  }

   pFile->aJrnl = 0;

   pFile->nJrnl = 0;

   pFile->szPage = -1;

@@ -36760,7 +37007,8 @@ SQLITE_PRIVATE int sqlite3KvvfsInit(void){
 /* #include <time.h> */

 #include <sys/time.h>    /* amalgamator: keep */

 #include <errno.h>

-#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0

+#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \

+  && !defined(SQLITE_WASI)

 # include <sys/mman.h>

 #endif

 

@@ -36848,9 +37096,46 @@ SQLITE_PRIVATE int sqlite3KvvfsInit(void){
 */

 #define SQLITE_MAX_SYMLINKS 100

 

+/*

+** Remove and stub certain info for WASI (WebAssembly System

+** Interface) builds.

+*/

+#ifdef SQLITE_WASI

+# undef HAVE_FCHMOD

+# undef HAVE_FCHOWN

+# undef HAVE_MREMAP

+# define HAVE_MREMAP 0

+# ifndef SQLITE_DEFAULT_UNIX_VFS

+#  define SQLITE_DEFAULT_UNIX_VFS "unix-dotfile"

+   /* ^^^ should SQLITE_DEFAULT_UNIX_VFS be "unix-none"? */

+# endif

+# ifndef F_RDLCK

+#  define F_RDLCK 0

+#  define F_WRLCK 1

+#  define F_UNLCK 2

+#  if __LONG_MAX == 0x7fffffffL

+#   define F_GETLK 12

+#   define F_SETLK 13

+#   define F_SETLKW 14

+#  else

+#   define F_GETLK 5

+#   define F_SETLK 6

+#   define F_SETLKW 7

+#  endif

+# endif

+#else /* !SQLITE_WASI */

+# ifndef HAVE_FCHMOD

+#  define HAVE_FCHMOD

+# endif

+#endif /* SQLITE_WASI */

+

+#ifdef SQLITE_WASI

+# define osGetpid(X) (pid_t)1

+#else

 /* Always cast the getpid() return type for compatibility with

 ** kernel modules in VxWorks. */

-#define osGetpid(X) (pid_t)getpid()

+# define osGetpid(X) (pid_t)getpid()

+#endif

 

 /*

 ** Only set the lastErrno if the error code is a real error and not

@@ -37122,7 +37407,11 @@ static struct unix_syscall {
 #define osPwrite64  ((ssize_t(*)(int,const void*,size_t,off64_t))\

                     aSyscall[13].pCurrent)

 

+#if defined(HAVE_FCHMOD)

   { "fchmod",       (sqlite3_syscall_ptr)fchmod,          0  },

+#else

+  { "fchmod",       (sqlite3_syscall_ptr)0,               0  },

+#endif

 #define osFchmod    ((int(*)(int,mode_t))aSyscall[14].pCurrent)

 

 #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE

@@ -37158,14 +37447,16 @@ static struct unix_syscall {
 #endif

 #define osGeteuid   ((uid_t(*)(void))aSyscall[21].pCurrent)

 

-#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0

+#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \

+  && !defined(SQLITE_WASI)

   { "mmap",         (sqlite3_syscall_ptr)mmap,            0 },

 #else

   { "mmap",         (sqlite3_syscall_ptr)0,               0 },

 #endif

 #define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent)

 

-#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0

+#if (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) \

+  && !defined(SQLITE_WASI)

   { "munmap",       (sqlite3_syscall_ptr)munmap,          0 },

 #else

   { "munmap",       (sqlite3_syscall_ptr)0,               0 },

@@ -38316,7 +38607,7 @@ static int unixFileLock(unixFile *pFile, struct flock *pLock){
 **

 **    UNLOCKED -> SHARED

 **    SHARED -> RESERVED

-**    SHARED -> (PENDING) -> EXCLUSIVE

+**    SHARED -> EXCLUSIVE

 **    RESERVED -> (PENDING) -> EXCLUSIVE

 **    PENDING -> EXCLUSIVE

 **

@@ -38349,19 +38640,20 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   ** A RESERVED lock is implemented by grabbing a write-lock on the

   ** 'reserved byte'.

   **

-  ** A process may only obtain a PENDING lock after it has obtained a

-  ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock

-  ** on the 'pending byte'. This ensures that no new SHARED locks can be

-  ** obtained, but existing SHARED locks are allowed to persist. A process

-  ** does not have to obtain a RESERVED lock on the way to a PENDING lock.

-  ** This property is used by the algorithm for rolling back a journal file

-  ** after a crash.

+  ** An EXCLUSIVE lock may only be requested after either a SHARED or

+  ** RESERVED lock is held. An EXCLUSIVE lock is implemented by obtaining

+  ** a write-lock on the entire 'shared byte range'. Since all other locks

+  ** require a read-lock on one of the bytes within this range, this ensures

+  ** that no other locks are held on the database.

   **

-  ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is

-  ** implemented by obtaining a write-lock on the entire 'shared byte

-  ** range'. Since all other locks require a read-lock on one of the bytes

-  ** within this range, this ensures that no other locks are held on the

-  ** database.

+  ** If a process that holds a RESERVED lock requests an EXCLUSIVE, then

+  ** a PENDING lock is obtained first. A PENDING lock is implemented by

+  ** obtaining a write-lock on the 'pending byte'. This ensures that no new

+  ** SHARED locks can be obtained, but existing SHARED locks are allowed to

+  ** persist. If the call to this function fails to obtain the EXCLUSIVE

+  ** lock in this case, it holds the PENDING lock intead. The client may

+  ** then re-attempt the EXCLUSIVE lock later on, after existing SHARED

+  ** locks have cleared.

   */

   int rc = SQLITE_OK;

   unixFile *pFile = (unixFile*)id;

@@ -38432,7 +38724,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   lock.l_len = 1L;

   lock.l_whence = SEEK_SET;

   if( eFileLock==SHARED_LOCK

-      || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)

+   || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock==RESERVED_LOCK)

   ){

     lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);

     lock.l_start = PENDING_BYTE;

@@ -38443,6 +38735,9 @@ static int unixLock(sqlite3_file *id, int eFileLock){
         storeLastErrno(pFile, tErrno);

       }

       goto end_lock;

+    }else if( eFileLock==EXCLUSIVE_LOCK ){

+      pFile->eFileLock = PENDING_LOCK;

+      pInode->eFileLock = PENDING_LOCK;

     }

   }

 

@@ -38530,13 +38825,9 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   }

 #endif

 

-

   if( rc==SQLITE_OK ){

     pFile->eFileLock = eFileLock;

     pInode->eFileLock = eFileLock;

-  }else if( eFileLock==EXCLUSIVE_LOCK ){

-    pFile->eFileLock = PENDING_LOCK;

-    pInode->eFileLock = PENDING_LOCK;

   }

 

 end_lock:

@@ -43127,12 +43418,10 @@ static void appendOnePathElement(
   if( zName[0]=='.' ){

     if( nName==1 ) return;

     if( zName[1]=='.' && nName==2 ){

-      if( pPath->nUsed<=1 ){

-        pPath->rc = SQLITE_ERROR;

-        return;

+      if( pPath->nUsed>1 ){

+        assert( pPath->zOut[0]=='/' );

+        while( pPath->zOut[--pPath->nUsed]!='/' ){}

       }

-      assert( pPath->zOut[0]=='/' );

-      while( pPath->zOut[--pPath->nUsed]!='/' ){}

       return;

     }

   }

@@ -43344,7 +43633,7 @@ static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){
 ** than the argument.

 */

 static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){

-#if OS_VXWORKS

+#if OS_VXWORKS || _POSIX_C_SOURCE >= 199309L

   struct timespec sp;

 

   sp.tv_sec = microseconds / 1000000;

@@ -58130,7 +58419,7 @@ end_playback:
     ** see if it is possible to delete the super-journal.

     */

     assert( zSuper==&pPager->pTmpSpace[4] );

-    memset(&zSuper[-4], 0, 4);

+    memset(pPager->pTmpSpace, 0, 4);

     rc = pager_delsuper(pPager, zSuper);

     testcase( rc!=SQLITE_OK );

   }

@@ -58751,7 +59040,6 @@ SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){
 ** Numeric values associated with these states are OFF==1, NORMAL=2,

 ** and FULL=3.

 */

-#ifndef SQLITE_OMIT_PAGER_PRAGMAS

 SQLITE_PRIVATE void sqlite3PagerSetFlags(

   Pager *pPager,        /* The pager to set safety level for */

   unsigned pgFlags      /* Various flags */

@@ -58786,7 +59074,6 @@ SQLITE_PRIVATE void sqlite3PagerSetFlags(
     pPager->doNotSpill |= SPILLFLAG_OFF;

   }

 }

-#endif

 

 /*

 ** The following global variable is incremented whenever the library

@@ -59888,7 +60175,6 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
   u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE;  /* Default page size */

   const char *zUri = 0;    /* URI args to copy */

   int nUriByte = 1;        /* Number of bytes of URI args at *zUri */

-  int nUri = 0;            /* Number of URI parameters */

 

   /* Figure out how much space is required for each journal file-handle

   ** (there are two of them, the main journal and the sub-journal).  */

@@ -59936,7 +60222,6 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
     while( *z ){

       z += strlen(z)+1;

       z += strlen(z)+1;

-      nUri++;

     }

     nUriByte = (int)(&z[1] - zUri);

     assert( nUriByte>=1 );

@@ -60192,18 +60477,7 @@ act_like_temp_file:
   pPager->memDb = (u8)memDb;

   pPager->readOnly = (u8)readOnly;

   assert( useJournal || pPager->tempFile );

-  pPager->noSync = pPager->tempFile;

-  if( pPager->noSync ){

-    assert( pPager->fullSync==0 );

-    assert( pPager->extraSync==0 );

-    assert( pPager->syncFlags==0 );

-    assert( pPager->walSyncFlags==0 );

-  }else{

-    pPager->fullSync = 1;

-    pPager->extraSync = 0;

-    pPager->syncFlags = SQLITE_SYNC_NORMAL;

-    pPager->walSyncFlags = SQLITE_SYNC_NORMAL | (SQLITE_SYNC_NORMAL<<2);

-  }

+  sqlite3PagerSetFlags(pPager, (SQLITE_DEFAULT_SYNCHRONOUS+1)|PAGER_CACHESPILL);

   /* pPager->pFirst = 0; */

   /* pPager->pFirstSynced = 0; */

   /* pPager->pLast = 0; */

@@ -61464,7 +61738,7 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
 # define DIRECT_MODE isDirectMode

 #endif

 

-  if( !pPager->changeCountDone && ALWAYS(pPager->dbSize>0) ){

+  if( !pPager->changeCountDone && pPager->dbSize>0 ){

     PgHdr *pPgHdr;                /* Reference to page 1 */

 

     assert( !pPager->tempFile && isOpen(pPager->fd) );

@@ -62204,7 +62478,11 @@ SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
 */

 SQLITE_PRIVATE const char *sqlite3PagerFilename(const Pager *pPager, int nullIfMemDb){

   static const char zFake[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

-  return (nullIfMemDb && pPager->memDb) ? &zFake[4] : pPager->zFilename;

+  if( nullIfMemDb && (pPager->memDb || sqlite3IsMemdb(pPager->pVfs)) ){

+    return &zFake[4];

+  }else{

+    return pPager->zFilename;

+  }

 }

 

 /*

@@ -67787,15 +68065,15 @@ struct BtCursor {
 ** So, this macro is defined instead.

 */

 #ifndef SQLITE_OMIT_AUTOVACUUM

-#define ISAUTOVACUUM (pBt->autoVacuum)

+#define ISAUTOVACUUM(pBt) (pBt->autoVacuum)

 #else

-#define ISAUTOVACUUM 0

+#define ISAUTOVACUUM(pBt) 0

 #endif

 

 

 /*

-** This structure is passed around through all the sanity checking routines

-** in order to keep track of some global state information.

+** This structure is passed around through all the PRAGMA integrity_check

+** checking routines in order to keep track of some global state information.

 **

 ** The aRef[] array is allocated so that there is 1 bit for each page in

 ** the database. As the integrity-check proceeds, for each page used in

@@ -67811,7 +68089,8 @@ struct IntegrityCk {
   Pgno nPage;       /* Number of pages in the database */

   int mxErr;        /* Stop accumulating errors when this reaches zero */

   int nErr;         /* Number of messages written to zErrMsg so far */

-  int bOomFault;    /* A memory allocation error has occurred */

+  int rc;           /* SQLITE_OK, SQLITE_NOMEM, or SQLITE_INTERRUPT */

+  u32 nStep;        /* Number of steps into the integrity_check process */

   const char *zPfx; /* Error message prefix */

   Pgno v1;          /* Value for first %u substitution in zPfx */

   int v2;           /* Value for second %d substitution in zPfx */

@@ -70041,62 +70320,67 @@ static int freeSpace(MemPage *pPage, u16 iStart, u16 iSize){
 ** Only the following combinations are supported.  Anything different

 ** indicates a corrupt database files:

 **

-**         PTF_ZERODATA

-**         PTF_ZERODATA | PTF_LEAF

-**         PTF_LEAFDATA | PTF_INTKEY

-**         PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF

+**         PTF_ZERODATA                             (0x02,  2)

+**         PTF_LEAFDATA | PTF_INTKEY                (0x05,  5)

+**         PTF_ZERODATA | PTF_LEAF                  (0x0a, 10)

+**         PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF     (0x0d, 13)

 */

 static int decodeFlags(MemPage *pPage, int flagByte){

   BtShared *pBt;     /* A copy of pPage->pBt */

 

   assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );

   assert( sqlite3_mutex_held(pPage->pBt->mutex) );

-  pPage->leaf = (u8)(flagByte>>3);  assert( PTF_LEAF == 1<<3 );

-  flagByte &= ~PTF_LEAF;

-  pPage->childPtrSize = 4-4*pPage->leaf;

   pBt = pPage->pBt;

-  if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){

-    /* EVIDENCE-OF: R-07291-35328 A value of 5 (0x05) means the page is an

-    ** interior table b-tree page. */

-    assert( (PTF_LEAFDATA|PTF_INTKEY)==5 );

-    /* EVIDENCE-OF: R-26900-09176 A value of 13 (0x0d) means the page is a

-    ** leaf table b-tree page. */

-    assert( (PTF_LEAFDATA|PTF_INTKEY|PTF_LEAF)==13 );

-    pPage->intKey = 1;

-    if( pPage->leaf ){

+  pPage->max1bytePayload = pBt->max1bytePayload;

+  if( flagByte>=(PTF_ZERODATA | PTF_LEAF) ){

+    pPage->childPtrSize = 0;

+    pPage->leaf = 1;

+    if( flagByte==(PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF) ){

       pPage->intKeyLeaf = 1;

       pPage->xCellSize = cellSizePtrTableLeaf;

       pPage->xParseCell = btreeParseCellPtr;

+      pPage->intKey = 1;

+      pPage->maxLocal = pBt->maxLeaf;

+      pPage->minLocal = pBt->minLeaf;

+    }else if( flagByte==(PTF_ZERODATA | PTF_LEAF) ){

+      pPage->intKey = 0;

+      pPage->intKeyLeaf = 0;

+      pPage->xCellSize = cellSizePtr;

+      pPage->xParseCell = btreeParseCellPtrIndex;

+      pPage->maxLocal = pBt->maxLocal;

+      pPage->minLocal = pBt->minLocal;

     }else{

+      pPage->intKey = 0;

+      pPage->intKeyLeaf = 0;

+      pPage->xCellSize = cellSizePtr;

+      pPage->xParseCell = btreeParseCellPtrIndex;

+      return SQLITE_CORRUPT_PAGE(pPage);

+    }

+  }else{

+    pPage->childPtrSize = 4;

+    pPage->leaf = 0;

+    if( flagByte==(PTF_ZERODATA) ){

+      pPage->intKey = 0;

+      pPage->intKeyLeaf = 0;

+      pPage->xCellSize = cellSizePtr;

+      pPage->xParseCell = btreeParseCellPtrIndex;

+      pPage->maxLocal = pBt->maxLocal;

+      pPage->minLocal = pBt->minLocal;

+    }else if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){

       pPage->intKeyLeaf = 0;

       pPage->xCellSize = cellSizePtrNoPayload;

       pPage->xParseCell = btreeParseCellPtrNoPayload;

+      pPage->intKey = 1;

+      pPage->maxLocal = pBt->maxLeaf;

+      pPage->minLocal = pBt->minLeaf;

+    }else{

+      pPage->intKey = 0;

+      pPage->intKeyLeaf = 0;

+      pPage->xCellSize = cellSizePtr;

+      pPage->xParseCell = btreeParseCellPtrIndex;

+      return SQLITE_CORRUPT_PAGE(pPage);

     }

-    pPage->maxLocal = pBt->maxLeaf;

-    pPage->minLocal = pBt->minLeaf;

-  }else if( flagByte==PTF_ZERODATA ){

-    /* EVIDENCE-OF: R-43316-37308 A value of 2 (0x02) means the page is an

-    ** interior index b-tree page. */

-    assert( (PTF_ZERODATA)==2 );

-    /* EVIDENCE-OF: R-59615-42828 A value of 10 (0x0a) means the page is a

-    ** leaf index b-tree page. */

-    assert( (PTF_ZERODATA|PTF_LEAF)==10 );

-    pPage->intKey = 0;

-    pPage->intKeyLeaf = 0;

-    pPage->xCellSize = cellSizePtr;

-    pPage->xParseCell = btreeParseCellPtrIndex;

-    pPage->maxLocal = pBt->maxLocal;

-    pPage->minLocal = pBt->minLocal;

-  }else{

-    /* EVIDENCE-OF: R-47608-56469 Any other value for the b-tree page type is

-    ** an error. */

-    pPage->intKey = 0;

-    pPage->intKeyLeaf = 0;

-    pPage->xCellSize = cellSizePtr;

-    pPage->xParseCell = btreeParseCellPtrIndex;

-    return SQLITE_CORRUPT_PAGE(pPage);

   }

-  pPage->max1bytePayload = pBt->max1bytePayload;

   return SQLITE_OK;

 }

 

@@ -73636,9 +73920,25 @@ SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
 ** on success.  Set *pRes to 0 if the cursor actually points to something

 ** or set *pRes to 1 if the table is empty.

 */

+static SQLITE_NOINLINE int btreeLast(BtCursor *pCur, int *pRes){

+  int rc = moveToRoot(pCur);

+  if( rc==SQLITE_OK ){

+    assert( pCur->eState==CURSOR_VALID );

+    *pRes = 0;

+    rc = moveToRightmost(pCur);

+    if( rc==SQLITE_OK ){

+      pCur->curFlags |= BTCF_AtLast;

+    }else{

+      pCur->curFlags &= ~BTCF_AtLast;

+    }

+  }else if( rc==SQLITE_EMPTY ){

+    assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );

+    *pRes = 1;

+    rc = SQLITE_OK;

+  }

+  return rc;

+}

 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){

-  int rc;

-

   assert( cursorOwnsBtShared(pCur) );

   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );

 

@@ -73659,23 +73959,7 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
     *pRes = 0;

     return SQLITE_OK;

   }

-

-  rc = moveToRoot(pCur);

-  if( rc==SQLITE_OK ){

-    assert( pCur->eState==CURSOR_VALID );

-    *pRes = 0;

-    rc = moveToRightmost(pCur);

-    if( rc==SQLITE_OK ){

-      pCur->curFlags |= BTCF_AtLast;

-    }else{

-      pCur->curFlags &= ~BTCF_AtLast;

-    }

-  }else if( rc==SQLITE_EMPTY ){

-    assert( pCur->pgnoRoot==0 || pCur->pPage->nCell==0 );

-    *pRes = 1;

-    rc = SQLITE_OK;

-  }

-  return rc;

+  return btreeLast(pCur, pRes);

 }

 

 /* Move the cursor so that it points to an entry in a table (a.k.a INTKEY)

@@ -74742,7 +75026,7 @@ static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
   /* If the database supports auto-vacuum, write an entry in the pointer-map

   ** to indicate that the page is free.

   */

-  if( ISAUTOVACUUM ){

+  if( ISAUTOVACUUM(pBt) ){

     ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);

     if( rc ) goto freepage_out;

   }

@@ -75182,24 +75466,20 @@ static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
 ** in pTemp or the original pCell) and also record its index.

 ** Allocating a new entry in pPage->aCell[] implies that

 ** pPage->nOverflow is incremented.

-**

-** *pRC must be SQLITE_OK when this routine is called.

 */

-static void insertCell(

+static int insertCell(

   MemPage *pPage,   /* Page into which we are copying */

   int i,            /* New cell becomes the i-th cell of the page */

   u8 *pCell,        /* Content of the new cell */

   int sz,           /* Bytes of content in pCell */

   u8 *pTemp,        /* Temp storage space for pCell, if needed */

-  Pgno iChild,      /* If non-zero, replace first 4 bytes with this value */

-  int *pRC          /* Read and write return code from here */

+  Pgno iChild       /* If non-zero, replace first 4 bytes with this value */

 ){

   int idx = 0;      /* Where to write new cell content in data[] */

   int j;            /* Loop counter */

   u8 *data;         /* The content of the whole page */

   u8 *pIns;         /* The point in pPage->aCellIdx[] where no cell inserted */

 

-  assert( *pRC==SQLITE_OK );

   assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );

   assert( MX_CELL(pPage->pBt)<=10921 );

   assert( pPage->nCell<=MX_CELL(pPage->pBt) || CORRUPT_DB );

@@ -75234,14 +75514,13 @@ static void insertCell(
   }else{

     int rc = sqlite3PagerWrite(pPage->pDbPage);

     if( rc!=SQLITE_OK ){

-      *pRC = rc;

-      return;

+      return rc;

     }

     assert( sqlite3PagerIswriteable(pPage->pDbPage) );

     data = pPage->aData;

     assert( &data[pPage->cellOffset]==pPage->aCellIdx );

     rc = allocateSpace(pPage, sz, &idx);

-    if( rc ){ *pRC = rc; return; }

+    if( rc ){ return rc; }

     /* The allocateSpace() routine guarantees the following properties

     ** if it returns successfully */

     assert( idx >= 0 );

@@ -75268,13 +75547,16 @@ static void insertCell(
     assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB );

 #ifndef SQLITE_OMIT_AUTOVACUUM

     if( pPage->pBt->autoVacuum ){

+      int rc2 = SQLITE_OK;

       /* The cell may contain a pointer to an overflow page. If so, write

       ** the entry for the overflow page into the pointer map.

       */

-      ptrmapPutOvflPtr(pPage, pPage, pCell, pRC);

+      ptrmapPutOvflPtr(pPage, pPage, pCell, &rc2);

+      if( rc2 ) return rc2;

     }

 #endif

   }

+  return SQLITE_OK;

 }

 

 /*

@@ -75375,14 +75657,16 @@ struct CellArray {
 ** computed.

 */

 static void populateCellCache(CellArray *p, int idx, int N){

+  MemPage *pRef = p->pRef;

+  u16 *szCell = p->szCell;

   assert( idx>=0 && idx+N<=p->nCell );

   while( N>0 ){

     assert( p->apCell[idx]!=0 );

-    if( p->szCell[idx]==0 ){

-      p->szCell[idx] = p->pRef->xCellSize(p->pRef, p->apCell[idx]);

+    if( szCell[idx]==0 ){

+      szCell[idx] = pRef->xCellSize(pRef, p->apCell[idx]);

     }else{

       assert( CORRUPT_DB ||

-              p->szCell[idx]==p->pRef->xCellSize(p->pRef, p->apCell[idx]) );

+              szCell[idx]==pRef->xCellSize(pRef, p->apCell[idx]) );

     }

     idx++;

     N--;

@@ -75584,8 +75868,8 @@ static int pageFreeArray(
   int nRet = 0;

   int i;

   int iEnd = iFirst + nCell;

-  u8 *pFree = 0;

-  int szFree = 0;

+  u8 *pFree = 0;                  /* \__ Parameters for pending call to */

+  int szFree = 0;                 /* /   freeSpace()                    */

 

   for(i=iFirst; i<iEnd; i++){

     u8 *pCell = pCArray->apCell[i];

@@ -75606,6 +75890,9 @@ static int pageFreeArray(
           return 0;

         }

       }else{

+        /* The current cell is adjacent to and before the pFree cell.

+        ** Combine the two regions into one to reduce the number of calls

+        ** to freeSpace(). */

         pFree = pCell;

         szFree += sz;

       }

@@ -75813,7 +76100,7 @@ static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
     ** be marked as dirty. Returning an error code will cause a

     ** rollback, undoing any changes made to the parent page.

     */

-    if( ISAUTOVACUUM ){

+    if( ISAUTOVACUUM(pBt) ){

       ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);

       if( szCell>pNew->minLocal ){

         ptrmapPutOvflPtr(pNew, pNew, pCell, &rc);

@@ -75841,8 +76128,8 @@ static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
 

     /* Insert the new divider cell into pParent. */

     if( rc==SQLITE_OK ){

-      insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),

-                   0, pPage->pgno, &rc);

+      rc = insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),

+                      0, pPage->pgno);

     }

 

     /* Set the right-child pointer of pParent to point to the new page. */

@@ -75951,7 +76238,7 @@ static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
     /* If this is an auto-vacuum database, update the pointer-map entries

     ** for any b-tree or overflow pages that pTo now contains the pointers to.

     */

-    if( ISAUTOVACUUM ){

+    if( ISAUTOVACUUM(pBt) ){

       *pRC = setChildPtrmaps(pTo);

     }

   }

@@ -76375,15 +76662,17 @@ static int balance_nonroot(
     d = r + 1 - leafData;

     (void)cachedCellSize(&b, d);

     do{

+      int szR, szD;

       assert( d<nMaxCells );

       assert( r<nMaxCells );

-      (void)cachedCellSize(&b, r);

+      szR = cachedCellSize(&b, r);

+      szD = b.szCell[d];

       if( szRight!=0

-       && (bBulk || szRight+b.szCell[d]+2 > szLeft-(b.szCell[r]+(i==k-1?0:2)))){

+       && (bBulk || szRight+szD+2 > szLeft-(szR+(i==k-1?0:2)))){

         break;

       }

-      szRight += b.szCell[d] + 2;

-      szLeft -= b.szCell[r] + 2;

+      szRight += szD + 2;

+      szLeft -= szR + 2;

       cntNew[i-1] = r;

       r--;

       d--;

@@ -76437,7 +76726,7 @@ static int balance_nonroot(
       cntOld[i] = b.nCell;

 

       /* Set the pointer-map entry for the new sibling page. */

-      if( ISAUTOVACUUM ){

+      if( ISAUTOVACUUM(pBt) ){

         ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);

         if( rc!=SQLITE_OK ){

           goto balance_cleanup;

@@ -76530,7 +76819,7 @@ static int balance_nonroot(
   ** updated. This happens below, after the sibling pages have been

   ** populated, not here.

   */

-  if( ISAUTOVACUUM ){

+  if( ISAUTOVACUUM(pBt) ){

     MemPage *pOld;

     MemPage *pNew = pOld = apNew[0];

     int cntOldNext = pNew->nCell + pNew->nOverflow;

@@ -76627,7 +76916,7 @@ static int balance_nonroot(
       rc = SQLITE_CORRUPT_BKPT;

       goto balance_cleanup;

     }

-    insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno, &rc);

+    rc = insertCell(pParent, nxDiv+i, pCell, sz, pTemp, pNew->pgno);

     if( rc!=SQLITE_OK ) goto balance_cleanup;

     assert( sqlite3PagerIswriteable(pParent->pDbPage) );

   }

@@ -76723,7 +77012,7 @@ static int balance_nonroot(
     );

     copyNodeContent(apNew[0], pParent, &rc);

     freePage(apNew[0], &rc);

-  }else if( ISAUTOVACUUM && !leafCorrection ){

+  }else if( ISAUTOVACUUM(pBt) && !leafCorrection ){

     /* Fix the pointer map entries associated with the right-child of each

     ** sibling page. All other pointer map entries have already been taken

     ** care of.  */

@@ -76744,7 +77033,7 @@ static int balance_nonroot(
   }

 

 #if 0

-  if( ISAUTOVACUUM && rc==SQLITE_OK && apNew[0]->isInit ){

+  if( ISAUTOVACUUM(pBt) && rc==SQLITE_OK && apNew[0]->isInit ){

     /* The ptrmapCheckPages() contains assert() statements that verify that

     ** all pointer map pages are set correctly. This is helpful while

     ** debugging. This is usually disabled because a corrupt database may

@@ -76806,7 +77095,7 @@ static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
   if( rc==SQLITE_OK ){

     rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);

     copyNodeContent(pRoot, pChild, &rc);

-    if( ISAUTOVACUUM ){

+    if( ISAUTOVACUUM(pBt) ){

       ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);

     }

   }

@@ -77045,9 +77334,13 @@ static int btreeOverwriteContent(
 

 /*

 ** Overwrite the cell that cursor pCur is pointing to with fresh content

-** contained in pX.

+** contained in pX.  In this variant, pCur is pointing to an overflow

+** cell.

 */

-static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){

+static SQLITE_NOINLINE int btreeOverwriteOverflowCell(

+  BtCursor *pCur,                     /* Cursor pointing to cell to ovewrite */

+  const BtreePayload *pX              /* Content to write into the cell */

+){

   int iOffset;                        /* Next byte of pX->pData to write */

   int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */

   int rc;                             /* Return code */

@@ -77056,16 +77349,12 @@ static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
   Pgno ovflPgno;                      /* Next overflow page to write */

   u32 ovflPageSize;                   /* Size to write on overflow page */

 

-  if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd

-   || pCur->info.pPayload < pPage->aData + pPage->cellOffset

-  ){

-    return SQLITE_CORRUPT_BKPT;

-  }

+  assert( pCur->info.nLocal<nTotal );  /* pCur is an overflow cell */

+

   /* Overwrite the local portion first */

   rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,

                              0, pCur->info.nLocal);

   if( rc ) return rc;

-  if( pCur->info.nLocal==nTotal ) return SQLITE_OK;

 

   /* Now overwrite the overflow pages */

   iOffset = pCur->info.nLocal;

@@ -77095,6 +77384,29 @@ static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
   return SQLITE_OK;

 }

 

+/*

+** Overwrite the cell that cursor pCur is pointing to with fresh content

+** contained in pX.

+*/

+static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){

+  int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */

+  MemPage *pPage = pCur->pPage;       /* Page being written */

+

+  if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd

+   || pCur->info.pPayload < pPage->aData + pPage->cellOffset

+  ){

+    return SQLITE_CORRUPT_BKPT;

+  }

+  if( pCur->info.nLocal==nTotal ){

+    /* The entire cell is local */

+    return btreeOverwriteContent(pPage, pCur->info.pPayload, pX,

+                                 0, pCur->info.nLocal);

+  }else{

+    /* The cell contains overflow content */

+    return btreeOverwriteOverflowCell(pCur, pX);

+  }

+}

+

 

 /*

 ** Insert a new record into the BTree.  The content of the new record

@@ -77138,7 +77450,6 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   int idx;

   MemPage *pPage;

   Btree *p = pCur->pBtree;

-  BtShared *pBt = p->pBt;

   unsigned char *oldCell;

   unsigned char *newCell = 0;

 

@@ -77157,7 +77468,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   ** not to clear the cursor here.

   */

   if( pCur->curFlags & BTCF_Multiple ){

-    rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);

+    rc = saveAllCursors(p->pBt, pCur->pgnoRoot, pCur);

     if( rc ) return rc;

     if( loc && pCur->iPage<0 ){

       /* This can only happen if the schema is corrupt such that there is more

@@ -77181,8 +77492,8 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
 

   assert( cursorOwnsBtShared(pCur) );

   assert( (pCur->curFlags & BTCF_WriteFlag)!=0

-              && pBt->inTransaction==TRANS_WRITE

-              && (pBt->btsFlags & BTS_READ_ONLY)==0 );

+              && p->pBt->inTransaction==TRANS_WRITE

+              && (p->pBt->btsFlags & BTS_READ_ONLY)==0 );

   assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );

 

   /* Assert that the caller has been consistent. If this cursor was opened

@@ -77299,26 +77610,28 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
           pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,

           loc==0 ? "overwrite" : "new entry"));

   assert( pPage->isInit || CORRUPT_DB );

-  newCell = pBt->pTmpSpace;

+  newCell = p->pBt->pTmpSpace;

   assert( newCell!=0 );

+  assert( BTREE_PREFORMAT==OPFLAG_PREFORMAT );

   if( flags & BTREE_PREFORMAT ){

     rc = SQLITE_OK;

-    szNew = pBt->nPreformatSize;

+    szNew = p->pBt->nPreformatSize;

     if( szNew<4 ) szNew = 4;

-    if( ISAUTOVACUUM && szNew>pPage->maxLocal ){

+    if( ISAUTOVACUUM(p->pBt) && szNew>pPage->maxLocal ){

       CellInfo info;

       pPage->xParseCell(pPage, newCell, &info);

       if( info.nPayload!=info.nLocal ){

         Pgno ovfl = get4byte(&newCell[szNew-4]);

-        ptrmapPut(pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);

+        ptrmapPut(p->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);

+        if( NEVER(rc) ) goto end_insert;

       }

     }

   }else{

     rc = fillInCell(pPage, newCell, pX, &szNew);

+    if( rc ) goto end_insert;

   }

-  if( rc ) goto end_insert;

   assert( szNew==pPage->xCellSize(pPage, newCell) );

-  assert( szNew <= MX_CELL_SIZE(pBt) );

+  assert( szNew <= MX_CELL_SIZE(p->pBt) );

   idx = pCur->ix;

   if( loc==0 ){

     CellInfo info;

@@ -77338,7 +77651,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
     testcase( pCur->curFlags & BTCF_ValidOvfl );

     invalidateOverflowCache(pCur);

     if( info.nSize==szNew && info.nLocal==info.nPayload

-     && (!ISAUTOVACUUM || szNew<pPage->minLocal)

+     && (!ISAUTOVACUUM(p->pBt) || szNew<pPage->minLocal)

     ){

       /* Overwrite the old cell with the new if they are the same size.

       ** We could also try to do this if the old cell is smaller, then add

@@ -77368,7 +77681,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   }else{

     assert( pPage->leaf );

   }

-  insertCell(pPage, idx, newCell, szNew, 0, 0, &rc);

+  rc = insertCell(pPage, idx, newCell, szNew, 0, 0);

   assert( pPage->nOverflow==0 || rc==SQLITE_OK );

   assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );

 

@@ -77441,7 +77754,6 @@ end_insert:
 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.

 */

 SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64 iKey){

-  int rc = SQLITE_OK;

   BtShared *pBt = pDest->pBt;

   u8 *aOut = pBt->pTmpSpace;    /* Pointer to next output buffer */

   const u8 *aIn;                /* Pointer to next input buffer */

@@ -77464,7 +77776,9 @@ SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64
   if( nIn==nRem && nIn<pDest->pPage->maxLocal ){

     memcpy(aOut, aIn, nIn);

     pBt->nPreformatSize = nIn + (aOut - pBt->pTmpSpace);

+    return SQLITE_OK;

   }else{

+    int rc = SQLITE_OK;

     Pager *pSrcPager = pSrc->pBt->pPager;

     u8 *pPgnoOut = 0;

     Pgno ovflIn = 0;

@@ -77516,7 +77830,7 @@ SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64
         MemPage *pNew = 0;

         rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);

         put4byte(pPgnoOut, pgnoNew);

-        if( ISAUTOVACUUM && pPageOut ){

+        if( ISAUTOVACUUM(pBt) && pPageOut ){

           ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc);

         }

         releasePage(pPageOut);

@@ -77532,9 +77846,8 @@ SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64
 

     releasePage(pPageOut);

     sqlite3PagerUnref(pPageIn);

+    return rc;

   }

-

-  return rc;

 }

 

 /*

@@ -77689,7 +78002,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
     assert( pTmp!=0 );

     rc = sqlite3PagerWrite(pLeaf->pDbPage);

     if( rc==SQLITE_OK ){

-      insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);

+      rc = insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n);

     }

     dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);

     if( rc ) return rc;

@@ -78289,6 +78602,41 @@ SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){
 

 #ifndef SQLITE_OMIT_INTEGRITY_CHECK

 /*

+** Record an OOM error during integrity_check

+*/

+static void checkOom(IntegrityCk *pCheck){

+  pCheck->rc = SQLITE_NOMEM;

+  pCheck->mxErr = 0;  /* Causes integrity_check processing to stop */

+  if( pCheck->nErr==0 ) pCheck->nErr++;

+}

+

+/*

+** Invoke the progress handler, if appropriate.  Also check for an

+** interrupt.

+*/

+static void checkProgress(IntegrityCk *pCheck){

+  sqlite3 *db = pCheck->db;

+  if( AtomicLoad(&db->u1.isInterrupted) ){

+    pCheck->rc = SQLITE_INTERRUPT;

+    pCheck->nErr++;

+    pCheck->mxErr = 0;

+  }

+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK

+  if( db->xProgress ){

+    assert( db->nProgressOps>0 );

+    pCheck->nStep++;

+    if( (pCheck->nStep % db->nProgressOps)==0

+     && db->xProgress(db->pProgressArg)

+    ){

+      pCheck->rc = SQLITE_INTERRUPT;

+      pCheck->nErr++;

+      pCheck->mxErr = 0;

+    }

+  }

+#endif

+}

+

+/*

 ** Append a message to the error message string.

 */

 static void checkAppendMsg(

@@ -78297,6 +78645,7 @@ static void checkAppendMsg(
   ...

 ){

   va_list ap;

+  checkProgress(pCheck);

   if( !pCheck->mxErr ) return;

   pCheck->mxErr--;

   pCheck->nErr++;

@@ -78310,7 +78659,7 @@ static void checkAppendMsg(
   sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap);

   va_end(ap);

   if( pCheck->errMsg.accError==SQLITE_NOMEM ){

-    pCheck->bOomFault = 1;

+    checkOom(pCheck);

   }

 }

 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */

@@ -78352,7 +78701,6 @@ static int checkRef(IntegrityCk *pCheck, Pgno iPage){
     checkAppendMsg(pCheck, "2nd reference to page %d", iPage);

     return 1;

   }

-  if( AtomicLoad(&pCheck->db->u1.isInterrupted) ) return 1;

   setPageReferenced(pCheck, iPage);

   return 0;

 }

@@ -78375,7 +78723,7 @@ static void checkPtrmap(
 

   rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);

   if( rc!=SQLITE_OK ){

-    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->bOomFault = 1;

+    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) checkOom(pCheck);

     checkAppendMsg(pCheck, "Failed to read ptrmap key=%d", iChild);

     return;

   }

@@ -78482,7 +78830,9 @@ static void checkList(
 ** lower 16 bits are the index of the last byte of that range.

 */

 static void btreeHeapInsert(u32 *aHeap, u32 x){

-  u32 j, i = ++aHeap[0];

+  u32 j, i;

+  assert( aHeap!=0 );

+  i = ++aHeap[0];

   aHeap[i] = x;

   while( (j = i/2)>0 && aHeap[j]>aHeap[i] ){

     x = aHeap[j];

@@ -78559,6 +78909,8 @@ static int checkTreePage(
 

   /* Check that the page exists

   */

+  checkProgress(pCheck);

+  if( pCheck->mxErr==0 ) goto end_of_check;

   pBt = pCheck->pBt;

   usableSize = pBt->usableSize;

   if( iPage==0 ) return 0;

@@ -78804,13 +79156,14 @@ end_of_check:
 ** the unverified btrees.  Except, if aRoot[1] is 1, then the freelist

 ** checks are still performed.

 */

-SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(

+SQLITE_PRIVATE int sqlite3BtreeIntegrityCheck(

   sqlite3 *db,  /* Database connection that is running the check */

   Btree *p,     /* The btree to be checked */

   Pgno *aRoot,  /* An array of root pages numbers for individual trees */

   int nRoot,    /* Number of entries in aRoot[] */

   int mxErr,    /* Stop reporting errors after this many */

-  int *pnErr    /* Write number of errors seen to this variable */

+  int *pnErr,   /* OUT: Write number of errors seen to this variable */

+  char **pzOut  /* OUT: Write the error message string here */

 ){

   Pgno i;

   IntegrityCk sCheck;

@@ -78833,18 +79186,12 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
   assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );

   VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );

   assert( nRef>=0 );

+  memset(&sCheck, 0, sizeof(sCheck));

   sCheck.db = db;

   sCheck.pBt = pBt;

   sCheck.pPager = pBt->pPager;

   sCheck.nPage = btreePagecount(sCheck.pBt);

   sCheck.mxErr = mxErr;

-  sCheck.nErr = 0;

-  sCheck.bOomFault = 0;

-  sCheck.zPfx = 0;

-  sCheck.v1 = 0;

-  sCheck.v2 = 0;

-  sCheck.aPgRef = 0;

-  sCheck.heap = 0;

   sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH);

   sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL;

   if( sCheck.nPage==0 ){

@@ -78853,12 +79200,12 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
 

   sCheck.aPgRef = sqlite3MallocZero((sCheck.nPage / 8)+ 1);

   if( !sCheck.aPgRef ){

-    sCheck.bOomFault = 1;

+    checkOom(&sCheck);

     goto integrity_ck_cleanup;

   }

   sCheck.heap = (u32*)sqlite3PageMalloc( pBt->pageSize );

   if( sCheck.heap==0 ){

-    sCheck.bOomFault = 1;

+    checkOom(&sCheck);

     goto integrity_ck_cleanup;

   }

 

@@ -78939,16 +79286,17 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
 integrity_ck_cleanup:

   sqlite3PageFree(sCheck.heap);

   sqlite3_free(sCheck.aPgRef);

-  if( sCheck.bOomFault ){

+  *pnErr = sCheck.nErr;

+  if( sCheck.nErr==0 ){

     sqlite3_str_reset(&sCheck.errMsg);

-    sCheck.nErr++;

+    *pzOut = 0;

+  }else{

+    *pzOut = sqlite3StrAccumFinish(&sCheck.errMsg);

   }

-  *pnErr = sCheck.nErr;

-  if( sCheck.nErr==0 ) sqlite3_str_reset(&sCheck.errMsg);

   /* Make sure this analysis did not leave any unref() pages. */

   assert( nRef==sqlite3PagerRefcount(pBt->pPager) );

   sqlite3BtreeLeave(p);

-  return sqlite3StrAccumFinish(&sCheck.errMsg);

+  return sCheck.rc;

 }

 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */

 

@@ -80134,9 +80482,9 @@ static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
     i64 x;

     assert( (p->flags&MEM_Int)*2==sizeof(x) );

     memcpy(&x, (char*)&p->u, (p->flags&MEM_Int)*2);

-    sqlite3Int64ToText(x, zBuf);

+    p->n = sqlite3Int64ToText(x, zBuf);

 #else

-    sqlite3Int64ToText(p->u.i, zBuf);

+    p->n = sqlite3Int64ToText(p->u.i, zBuf);

 #endif

   }else{

     sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0);

@@ -80144,6 +80492,7 @@ static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
          (p->flags & MEM_IntReal)!=0 ? (double)p->u.i : p->u.r);

     assert( acc.zText==zBuf && acc.mxAlloc<=0 );

     zBuf[acc.nChar] = 0; /* Fast version of sqlite3StrAccumFinish(&acc) */

+    p->n = acc.nChar;

   }

 }

 

@@ -80171,6 +80520,7 @@ static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
 ** This routine is for use inside of assert() statements only.

 */

 SQLITE_PRIVATE int sqlite3VdbeMemValidStrRep(Mem *p){

+  Mem tmp;

   char zBuf[100];

   char *z;

   int i, j, incr;

@@ -80187,7 +80537,8 @@ SQLITE_PRIVATE int sqlite3VdbeMemValidStrRep(Mem *p){
     assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 );

   }

   if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1;

-  vdbeMemRenderNum(sizeof(zBuf), zBuf, p);

+  memcpy(&tmp, p, sizeof(tmp));

+  vdbeMemRenderNum(sizeof(zBuf), zBuf, &tmp);

   z = p->z;

   i = j = 0;

   incr = 1;

@@ -80456,7 +80807,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
 

   vdbeMemRenderNum(nByte, pMem->z, pMem);

   assert( pMem->z!=0 );

-  pMem->n = sqlite3Strlen30NN(pMem->z);

+  assert( pMem->n==sqlite3Strlen30NN(pMem->z) );

   pMem->enc = SQLITE_UTF8;

   pMem->flags |= MEM_Str|MEM_Term;

   if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);

@@ -80696,32 +81047,35 @@ SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){
 }

 

 /*

-** The MEM structure is already a MEM_Real.  Try to also make it a

-** MEM_Int if we can.

+** The MEM structure is already a MEM_Real or MEM_IntReal. Try to

+** make it a MEM_Int if we can.

 */

 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){

-  i64 ix;

   assert( pMem!=0 );

-  assert( pMem->flags & MEM_Real );

+  assert( pMem->flags & (MEM_Real|MEM_IntReal) );

   assert( !sqlite3VdbeMemIsRowSet(pMem) );

   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );

   assert( EIGHT_BYTE_ALIGNMENT(pMem) );

 

-  ix = doubleToInt64(pMem->u.r);

-

-  /* Only mark the value as an integer if

-  **

-  **    (1) the round-trip conversion real->int->real is a no-op, and

-  **    (2) The integer is neither the largest nor the smallest

-  **        possible integer (ticket #3922)

-  **

-  ** The second and third terms in the following conditional enforces

-  ** the second condition under the assumption that addition overflow causes

-  ** values to wrap around.

-  */

-  if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){

-    pMem->u.i = ix;

+  if( pMem->flags & MEM_IntReal ){

     MemSetTypeFlag(pMem, MEM_Int);

+  }else{

+    i64 ix = doubleToInt64(pMem->u.r);

+

+    /* Only mark the value as an integer if

+    **

+    **    (1) the round-trip conversion real->int->real is a no-op, and

+    **    (2) The integer is neither the largest nor the smallest

+    **        possible integer (ticket #3922)

+    **

+    ** The second and third terms in the following conditional enforces

+    ** the second condition under the assumption that addition overflow causes

+    ** values to wrap around.

+    */

+    if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){

+      pMem->u.i = ix;

+      MemSetTypeFlag(pMem, MEM_Int);

+    }

   }

 }

 

@@ -81522,8 +81876,6 @@ static int valueFromFunction(
     goto value_from_function_out;

   }

 

-  testcase( pCtx->pParse->rc==SQLITE_ERROR );

-  testcase( pCtx->pParse->rc==SQLITE_OK );

   memset(&ctx, 0, sizeof(ctx));

   ctx.pOut = pVal;

   ctx.pFunc = pFunc;

@@ -81535,17 +81887,22 @@ static int valueFromFunction(
   }else{

     sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);

     assert( rc==SQLITE_OK );

+    assert( enc==pVal->enc

+         || (pVal->flags & MEM_Str)==0

+         || db->mallocFailed  );

+#if 0  /* Not reachable except after a prior failure */

     rc = sqlite3VdbeChangeEncoding(pVal, enc);

     if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){

       rc = SQLITE_TOOBIG;

       pCtx->pParse->nErr++;

     }

+#endif

   }

-  pCtx->pParse->rc = rc;

 

  value_from_function_out:

   if( rc!=SQLITE_OK ){

     pVal = 0;

+    pCtx->pParse->rc = rc;

   }

   if( apVal ){

     for(i=0; i<nVal; i++){

@@ -82218,6 +82575,8 @@ static int growOpArray(Vdbe *v, int nOp){
 */

 static void test_addop_breakpoint(int pc, Op *pOp){

   static int n = 0;

+  (void)pc;

+  (void)pOp;

   n++;

 }

 #endif

@@ -82268,16 +82627,16 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS

   pOp->zComment = 0;

 #endif

+#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)

+  pOp->nExec = 0;

+  pOp->nCycle = 0;

+#endif

 #ifdef SQLITE_DEBUG

   if( p->db->flags & SQLITE_VdbeAddopTrace ){

     sqlite3VdbePrintOp(0, i, &p->aOp[i]);

     test_addop_breakpoint(i, &p->aOp[i]);

   }

 #endif

-#ifdef VDBE_PROFILE

-  pOp->cycles = 0;

-  pOp->cnt = 0;

-#endif

 #ifdef SQLITE_VDBE_COVERAGE

   pOp->iSrcLine = 0;

 #endif

@@ -82445,8 +82804,9 @@ SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char *z1, const char *z2){
 ** If the bPush flag is true, then make this opcode the parent for

 ** subsequent Explains until sqlite3VdbeExplainPop() is called.

 */

-SQLITE_PRIVATE void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){

-#ifndef SQLITE_DEBUG

+SQLITE_PRIVATE int sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){

+  int addr = 0;

+#if !defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_STMT_SCANSTATUS)

   /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.

   ** But omit them (for performance) during production builds */

   if( pParse->explain==2 )

@@ -82461,13 +82821,15 @@ SQLITE_PRIVATE void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt
     va_end(ap);

     v = pParse->pVdbe;

     iThis = v->nOp;

-    sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,

+    addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,

                       zMsg, P4_DYNAMIC);

     sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetLastOp(v)->p4.z);

     if( bPush){

       pParse->addrExplain = iThis;

     }

+    sqlite3VdbeScanStatus(v, iThis, 0, 0, 0, 0);

   }

+  return addr;

 }

 

 /*

@@ -82575,6 +82937,9 @@ static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
     int i;

     for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1;

 #endif

+    if( nNewSize>=100 && (nNewSize/100)>(p->nLabelAlloc/100) ){

+      sqlite3ProgressCheck(p);

+    }

     p->nLabelAlloc = nNewSize;

     p->aLabel[j] = v->nOp;

   }

@@ -83125,6 +83490,7 @@ SQLITE_PRIVATE void sqlite3VdbeScanStatus(
   aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);

   if( aNew ){

     ScanStatus *pNew = &aNew[p->nScan++];

+    memset(pNew, 0, sizeof(ScanStatus));

     pNew->addrExplain = addrExplain;

     pNew->addrLoop = addrLoop;

     pNew->addrVisit = addrVisit;

@@ -83133,6 +83499,62 @@ SQLITE_PRIVATE void sqlite3VdbeScanStatus(
     p->aScan = aNew;

   }

 }

+

+/*

+** Add the range of instructions from addrStart to addrEnd (inclusive) to

+** the set of those corresponding to the sqlite3_stmt_scanstatus() counters

+** associated with the OP_Explain instruction at addrExplain. The

+** sum of the sqlite3Hwtime() values for each of these instructions

+** will be returned for SQLITE_SCANSTAT_NCYCLE requests.

+*/

+SQLITE_PRIVATE void sqlite3VdbeScanStatusRange(

+  Vdbe *p,

+  int addrExplain,

+  int addrStart,

+  int addrEnd

+){

+  ScanStatus *pScan = 0;

+  int ii;

+  for(ii=p->nScan-1; ii>=0; ii--){

+    pScan = &p->aScan[ii];

+    if( pScan->addrExplain==addrExplain ) break;

+    pScan = 0;

+  }

+  if( pScan ){

+    if( addrEnd<0 ) addrEnd = sqlite3VdbeCurrentAddr(p)-1;

+    for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){

+      if( pScan->aAddrRange[ii]==0 ){

+        pScan->aAddrRange[ii] = addrStart;

+        pScan->aAddrRange[ii+1] = addrEnd;

+        break;

+      }

+    }

+  }

+}

+

+/*

+** Set the addresses for the SQLITE_SCANSTAT_NLOOP and SQLITE_SCANSTAT_NROW

+** counters for the query element associated with the OP_Explain at

+** addrExplain.

+*/

+SQLITE_PRIVATE void sqlite3VdbeScanStatusCounters(

+  Vdbe *p,

+  int addrExplain,

+  int addrLoop,

+  int addrVisit

+){

+  ScanStatus *pScan = 0;

+  int ii;

+  for(ii=p->nScan-1; ii>=0; ii--){

+    pScan = &p->aScan[ii];

+    if( pScan->addrExplain==addrExplain ) break;

+    pScan = 0;

+  }

+  if( pScan ){

+    pScan->addrLoop = addrLoop;

+    pScan->addrVisit = addrVisit;

+  }

+}

 #endif

 

 

@@ -84262,7 +84684,6 @@ SQLITE_PRIVATE int sqlite3VdbeList(
   ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.

   */

   releaseMemArray(pMem, 8);

-  p->pResultSet = 0;

 

   if( p->rc==SQLITE_NOMEM ){

     /* This happens if a malloc() inside a call to sqlite3_column_text() or

@@ -84319,7 +84740,7 @@ SQLITE_PRIVATE int sqlite3VdbeList(
         sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free);

         p->nResColumn = 8;

       }

-      p->pResultSet = pMem;

+      p->pResultRow = pMem;

       if( db->mallocFailed ){

         p->rc = SQLITE_NOMEM;

         rc = SQLITE_ERROR;

@@ -84430,7 +84851,7 @@ static void *allocSpace(
 ** running it.

 */

 SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){

-#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)

+#if defined(SQLITE_DEBUG)

   int i;

 #endif

   assert( p!=0 );

@@ -84459,8 +84880,8 @@ SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){
   p->nFkConstraint = 0;

 #ifdef VDBE_PROFILE

   for(i=0; i<p->nOp; i++){

-    p->aOp[i].cnt = 0;

-    p->aOp[i].cycles = 0;

+    p->aOp[i].nExec = 0;

+    p->aOp[i].nCycle = 0;

   }

 #endif

 }

@@ -84569,9 +84990,6 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));

   p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));

   p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-  p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64));

-#endif

   if( x.nNeeded ){

     x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);

     x.nFree = x.nNeeded;

@@ -84580,9 +84998,6 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
       p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));

       p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));

       p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-      p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));

-#endif

     }

   }

 

@@ -84597,9 +85012,6 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
     p->nMem = nMem;

     initMemArray(p->aMem, nMem, db, MEM_Undefined);

     memset(p->apCsr, 0, nCursor*sizeof(VdbeCursor*));

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-    memset(p->anExec, 0, p->nOp*sizeof(i64));

-#endif

   }

   sqlite3VdbeRewind(p);

 }

@@ -84657,9 +85069,6 @@ static void closeCursorsInFrame(Vdbe *p){
 SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){

   Vdbe *v = pFrame->v;

   closeCursorsInFrame(v);

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-  v->anExec = pFrame->anExec;

-#endif

   v->aOp = pFrame->aOp;

   v->nOp = pFrame->nOp;

   v->aMem = pFrame->aMem;

@@ -85463,7 +85872,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
     sqlite3DbFree(db, p->zErrMsg);

     p->zErrMsg = 0;

   }

-  p->pResultSet = 0;

+  p->pResultRow = 0;

 #ifdef SQLITE_DEBUG

   p->nWrite = 0;

 #endif

@@ -85491,10 +85900,12 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
       }

       for(i=0; i<p->nOp; i++){

         char zHdr[100];

+        i64 cnt = p->aOp[i].nExec;

+        i64 cycles = p->aOp[i].nCycle;

         sqlite3_snprintf(sizeof(zHdr), zHdr, "%6u %12llu %8llu ",

-           p->aOp[i].cnt,

-           p->aOp[i].cycles,

-           p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0

+           cnt,

+           cycles,

+           cnt>0 ? cycles/cnt : 0

         );

         fprintf(out, "%s", zHdr);

         sqlite3VdbePrintOp(out, i, &p->aOp[i]);

@@ -87349,6 +87760,7 @@ SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
 */

 /* #include "sqliteInt.h" */

 /* #include "vdbeInt.h" */

+/* #include "opcodes.h" */

 

 #ifndef SQLITE_OMIT_DEPRECATED

 /*

@@ -87839,7 +88251,10 @@ SQLITE_API void sqlite3_result_text64(
 ){

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

   assert( xDel!=SQLITE_DYNAMIC );

-  if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;

+  if( enc!=SQLITE_UTF8 ){

+    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;

+    n &= ~(u64)1;

+  }

   if( n>0x7fffffff ){

     (void)invokeValueDestructor(z, xDel, pCtx);

   }else{

@@ -87854,7 +88269,7 @@ SQLITE_API void sqlite3_result_text16(
   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

-  setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);

+  setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16NATIVE, xDel);

 }

 SQLITE_API void sqlite3_result_text16be(

   sqlite3_context *pCtx,

@@ -87863,7 +88278,7 @@ SQLITE_API void sqlite3_result_text16be(
   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

-  setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);

+  setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16BE, xDel);

 }

 SQLITE_API void sqlite3_result_text16le(

   sqlite3_context *pCtx,

@@ -87872,7 +88287,7 @@ SQLITE_API void sqlite3_result_text16le(
   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );

-  setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);

+  setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16LE, xDel);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){

@@ -88083,7 +88498,7 @@ static int sqlite3Step(Vdbe *p){
     /* If the statement completed successfully, invoke the profile callback */

     checkProfileCallback(db, p);

 #endif

-

+    p->pResultRow = 0;

     if( rc==SQLITE_DONE && db->autoCommit ){

       assert( p->rc==SQLITE_OK );

       p->rc = doWalCallbacks(db);

@@ -88213,6 +88628,17 @@ SQLITE_API int sqlite3_vtab_nochange(sqlite3_context *p){
 }

 

 /*

+** The destructor function for a ValueList object.  This needs to be

+** a separate function, unknowable to the application, to ensure that

+** calls to sqlite3_vtab_in_first()/sqlite3_vtab_in_next() that are not

+** preceeded by activation of IN processing via sqlite3_vtab_int() do not

+** try to access a fake ValueList object inserted by a hostile extension.

+*/

+SQLITE_PRIVATE void sqlite3VdbeValueListFree(void *pToDelete){

+  sqlite3_free(pToDelete);

+}

+

+/*

 ** Implementation of sqlite3_vtab_in_first() (if bNext==0) and

 ** sqlite3_vtab_in_next() (if bNext!=0).

 */

@@ -88226,8 +88652,15 @@ static int valueFromValueList(
 

   *ppOut = 0;

   if( pVal==0 ) return SQLITE_MISUSE;

-  pRhs = (ValueList*)sqlite3_value_pointer(pVal, "ValueList");

-  if( pRhs==0 ) return SQLITE_MISUSE;

+  if( (pVal->flags & MEM_Dyn)==0 || pVal->xDel!=sqlite3VdbeValueListFree ){

+    return SQLITE_ERROR;

+  }else{

+    assert( (pVal->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==

+                 (MEM_Null|MEM_Term|MEM_Subtype) );

+    assert( pVal->eSubtype=='p' );

+    assert( pVal->u.zPType!=0 && strcmp(pVal->u.zPType,"ValueList")==0 );

+    pRhs = (ValueList*)pVal->z;

+  }

   if( bNext ){

     rc = sqlite3BtreeNext(pRhs->pCsr, 0);

   }else{

@@ -88447,7 +88880,7 @@ SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){
 */

 SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){

   Vdbe *pVm = (Vdbe *)pStmt;

-  if( pVm==0 || pVm->pResultSet==0 ) return 0;

+  if( pVm==0 || pVm->pResultRow==0 ) return 0;

   return pVm->nResColumn;

 }

 

@@ -88502,8 +88935,8 @@ static Mem *columnMem(sqlite3_stmt *pStmt, int i){
   if( pVm==0 ) return (Mem*)columnNullValue();

   assert( pVm->db );

   sqlite3_mutex_enter(pVm->db->mutex);

-  if( pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){

-    pOut = &pVm->pResultSet[i];

+  if( pVm->pResultRow!=0 && i<pVm->nResColumn && i>=0 ){

+    pOut = &pVm->pResultRow[i];

   }else{

     sqlite3Error(pVm->db, SQLITE_RANGE);

     pOut = (Mem*)columnNullValue();

@@ -88937,7 +89370,10 @@ SQLITE_API int sqlite3_bind_text64(
   unsigned char enc

 ){

   assert( xDel!=SQLITE_DYNAMIC );

-  if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;

+  if( enc!=SQLITE_UTF8 ){

+    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;

+    nData &= ~(u16)1;

+  }

   return bindText(pStmt, i, zData, nData, xDel, enc);

 }

 #ifndef SQLITE_OMIT_UTF16

@@ -88945,10 +89381,10 @@ SQLITE_API int sqlite3_bind_text16(
   sqlite3_stmt *pStmt,

   int i,

   const void *zData,

-  int nData,

+  int n,

   void (*xDel)(void*)

 ){

-  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);

+  return bindText(pStmt, i, zData, n & ~(u64)1, xDel, SQLITE_UTF16NATIVE);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){

@@ -89439,23 +89875,60 @@ SQLITE_API int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppVa
 /*

 ** Return status data for a single loop within query pStmt.

 */

-SQLITE_API int sqlite3_stmt_scanstatus(

+SQLITE_API int sqlite3_stmt_scanstatus_v2(

   sqlite3_stmt *pStmt,            /* Prepared statement being queried */

-  int idx,                        /* Index of loop to report on */

+  int iScan,                      /* Index of loop to report on */

   int iScanStatusOp,              /* Which metric to return */

+  int flags,

   void *pOut                      /* OUT: Write the answer here */

 ){

   Vdbe *p = (Vdbe*)pStmt;

   ScanStatus *pScan;

-  if( idx<0 || idx>=p->nScan ) return 1;

-  pScan = &p->aScan[idx];

+  int idx;

+

+  if( iScan<0 ){

+    int ii;

+    if( iScanStatusOp==SQLITE_SCANSTAT_NCYCLE ){

+      i64 res = 0;

+      for(ii=0; ii<p->nOp; ii++){

+        res += p->aOp[ii].nCycle;

+      }

+      *(i64*)pOut = res;

+      return 0;

+    }

+    return 1;

+  }

+  if( flags & SQLITE_SCANSTAT_COMPLEX ){

+    idx = iScan;

+    pScan = &p->aScan[idx];

+  }else{

+    /* If the COMPLEX flag is clear, then this function must ignore any

+    ** ScanStatus structures with ScanStatus.addrLoop set to 0. */

+    for(idx=0; idx<p->nScan; idx++){

+      pScan = &p->aScan[idx];

+      if( pScan->zName ){

+        iScan--;

+        if( iScan<0 ) break;

+      }

+    }

+  }

+  if( idx>=p->nScan ) return 1;

+

   switch( iScanStatusOp ){

     case SQLITE_SCANSTAT_NLOOP: {

-      *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop];

+      if( pScan->addrLoop>0 ){

+        *(sqlite3_int64*)pOut = p->aOp[pScan->addrLoop].nExec;

+      }else{

+        *(sqlite3_int64*)pOut = -1;

+      }

       break;

     }

     case SQLITE_SCANSTAT_NVISIT: {

-      *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit];

+      if( pScan->addrVisit>0 ){

+        *(sqlite3_int64*)pOut = p->aOp[pScan->addrVisit].nExec;

+      }else{

+        *(sqlite3_int64*)pOut = -1;

+      }

       break;

     }

     case SQLITE_SCANSTAT_EST: {

@@ -89488,6 +89961,45 @@ SQLITE_API int sqlite3_stmt_scanstatus(
       }

       break;

     }

+    case SQLITE_SCANSTAT_PARENTID: {

+      if( pScan->addrExplain ){

+        *(int*)pOut = p->aOp[ pScan->addrExplain ].p2;

+      }else{

+        *(int*)pOut = -1;

+      }

+      break;

+    }

+    case SQLITE_SCANSTAT_NCYCLE: {

+      i64 res = 0;

+      if( pScan->aAddrRange[0]==0 ){

+        res = -1;

+      }else{

+        int ii;

+        for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){

+          int iIns = pScan->aAddrRange[ii];

+          int iEnd = pScan->aAddrRange[ii+1];

+          if( iIns==0 ) break;

+          if( iIns>0 ){

+            while( iIns<=iEnd ){

+              res += p->aOp[iIns].nCycle;

+              iIns++;

+            }

+          }else{

+            int iOp;

+            for(iOp=0; iOp<p->nOp; iOp++){

+              Op *pOp = &p->aOp[iOp];

+              if( pOp->p1!=iEnd ) continue;

+              if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_NCYCLE)==0 ){

+                continue;

+              }

+              res += p->aOp[iOp].nCycle;

+            }

+          }

+        }

+      }

+      *(i64*)pOut = res;

+      break;

+    }

     default: {

       return 1;

     }

@@ -89496,11 +90008,28 @@ SQLITE_API int sqlite3_stmt_scanstatus(
 }

 

 /*

+** Return status data for a single loop within query pStmt.

+*/

+SQLITE_API int sqlite3_stmt_scanstatus(

+  sqlite3_stmt *pStmt,            /* Prepared statement being queried */

+  int iScan,                      /* Index of loop to report on */

+  int iScanStatusOp,              /* Which metric to return */

+  void *pOut                      /* OUT: Write the answer here */

+){

+  return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut);

+}

+

+/*

 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data.

 */

 SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){

   Vdbe *p = (Vdbe*)pStmt;

-  memset(p->anExec, 0, p->nOp * sizeof(i64));

+  int ii;

+  for(ii=0; ii<p->nOp; ii++){

+    Op *pOp = &p->aOp[ii];

+    pOp->nExec = 0;

+    pOp->nCycle = 0;

+  }

 }

 #endif /* SQLITE_ENABLE_STMT_SCANSTATUS */

 

@@ -89836,6 +90365,9 @@ SQLITE_API int sqlite3_found_count = 0;
 */

 static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){

   static int n = 0;

+  (void)pc;

+  (void)pOp;

+  (void)v;

   n++;

 }

 #endif

@@ -90074,6 +90606,10 @@ static void applyNumericAffinity(Mem *pRec, int bTryForInt){
 **    always preferred, even if the affinity is REAL, because

 **    an integer representation is more space efficient on disk.

 **

+** SQLITE_AFF_FLEXNUM:

+**    If the value is text, then try to convert it into a number of

+**    some kind (integer or real) but do not make any other changes.

+**

 ** SQLITE_AFF_TEXT:

 **    Convert pRec to a text representation.

 **

@@ -90088,11 +90624,11 @@ static void applyAffinity(
 ){

   if( affinity>=SQLITE_AFF_NUMERIC ){

     assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL

-             || affinity==SQLITE_AFF_NUMERIC );

+             || affinity==SQLITE_AFF_NUMERIC || affinity==SQLITE_AFF_FLEXNUM );

     if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/

-      if( (pRec->flags & MEM_Real)==0 ){

+      if( (pRec->flags & (MEM_Real|MEM_IntReal))==0 ){

         if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);

-      }else{

+      }else if( affinity<=SQLITE_AFF_REAL ){

         sqlite3VdbeIntegerAffinity(pRec);

       }

     }

@@ -90320,17 +90856,6 @@ SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){
 #  define REGISTER_TRACE(R,M)

 #endif

 

-

-#ifdef VDBE_PROFILE

-

-/*

-** hwtime.h contains inline assembler code for implementing

-** high-performance timing routines.

-*/

-/* #include "hwtime.h" */

-

-#endif

-

 #ifndef NDEBUG

 /*

 ** This function is only called from within an assert() expression. It

@@ -90420,11 +90945,10 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
 ){

   Op *aOp = p->aOp;          /* Copy of p->aOp */

   Op *pOp = aOp;             /* Current operation */

-#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)

-  Op *pOrigOp;               /* Value of pOp at the top of the loop */

-#endif

 #ifdef SQLITE_DEBUG

+  Op *pOrigOp;               /* Value of pOp at the top of the loop */

   int nExtraDelete = 0;      /* Verifies FORDELETE and AUXDELETE flags */

+  u8 iCompareIsInit = 0;     /* iCompare is initialized */

 #endif

   int rc = SQLITE_OK;        /* Value to return */

   sqlite3 *db = p->db;       /* The database */

@@ -90440,13 +90964,15 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
   Mem *pIn2 = 0;             /* 2nd input operand */

   Mem *pIn3 = 0;             /* 3rd input operand */

   Mem *pOut = 0;             /* Output operand */

-#ifdef VDBE_PROFILE

-  u64 start;                 /* CPU clock count at start of opcode */

+#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)

+  u64 *pnCycle = 0;

 #endif

   /*** INSERT STACK UNION HERE ***/

 

   assert( p->eVdbeState==VDBE_RUN_STATE );  /* sqlite3_step() verifies this */

-  sqlite3VdbeEnter(p);

+  if( DbMaskNonZero(p->lockMask) ){

+    sqlite3VdbeEnter(p);

+  }

 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK

   if( db->xProgress ){

     u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];

@@ -90467,7 +90993,6 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
   assert( p->bIsReader || p->readOnly!=0 );

   p->iCurrentTime = 0;

   assert( p->explain==0 );

-  p->pResultSet = 0;

   db->busyHandler.nBusy = 0;

   if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;

   sqlite3VdbeIOTraceSql(p);

@@ -90504,12 +91029,14 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
     assert( rc==SQLITE_OK );

 

     assert( pOp>=aOp && pOp<&aOp[p->nOp]);

-#ifdef VDBE_PROFILE

-    start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();

-#endif

     nVmStep++;

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-    if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;

+#if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || defined(VDBE_PROFILE)

+    pOp->nExec++;

+    pnCycle = &pOp->nCycle;

+# ifdef VDBE_PROFILE

+    if( sqlite3NProfileCnt==0 )

+# endif

+      *pnCycle -= sqlite3Hwtime();

 #endif

 

     /* Only allow tracing if SQLITE_DEBUG is defined.

@@ -90571,7 +91098,7 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
       }

     }

 #endif

-#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)

+#ifdef SQLITE_DEBUG

     pOrigOp = pOp;

 #endif

 

@@ -90855,6 +91382,12 @@ case OP_Halt: {
 #ifdef SQLITE_DEBUG

   if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }

 #endif

+

+  /* A deliberately coded "OP_Halt SQLITE_INTERNAL * * * *" opcode indicates

+  ** something is wrong with the code generator.  Raise an assertion in order

+  ** to bring this to the attention of fuzzers and other testing tools. */

+  assert( pOp->p1!=SQLITE_INTERNAL );

+

   if( p->pFrame && pOp->p1==SQLITE_OK ){

     /* Halt the sub-program. Return control to the parent frame. */

     pFrame = p->pFrame;

@@ -91296,10 +91829,10 @@ case OP_ResultRow: {
   assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );

 

   p->cacheCtr = (p->cacheCtr + 2)|1;

-  p->pResultSet = &aMem[pOp->p1];

+  p->pResultRow = &aMem[pOp->p1];

 #ifdef SQLITE_DEBUG

   {

-    Mem *pMem = p->pResultSet;

+    Mem *pMem = p->pResultRow;

     int i;

     for(i=0; i<pOp->p2; i++){

       assert( memIsValid(&pMem[i]) );

@@ -91829,7 +92362,6 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
   flags1 = pIn1->flags;

   flags3 = pIn3->flags;

   if( (flags1 & flags3 & MEM_Int)!=0 ){

-    assert( (pOp->p5 & SQLITE_AFF_MASK)!=SQLITE_AFF_TEXT || CORRUPT_DB );

     /* Common case of comparison of two integers */

     if( pIn3->u.i > pIn1->u.i ){

       if( sqlite3aGTb[pOp->opcode] ){

@@ -91837,18 +92369,21 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
         goto jump_to_p2;

       }

       iCompare = +1;

+      VVA_ONLY( iCompareIsInit = 1; )

     }else if( pIn3->u.i < pIn1->u.i ){

       if( sqlite3aLTb[pOp->opcode] ){

         VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);

         goto jump_to_p2;

       }

       iCompare = -1;

+      VVA_ONLY( iCompareIsInit = 1; )

     }else{

       if( sqlite3aEQb[pOp->opcode] ){

         VdbeBranchTaken(1, (pOp->p5 & SQLITE_NULLEQ)?2:3);

         goto jump_to_p2;

       }

       iCompare = 0;

+      VVA_ONLY( iCompareIsInit = 1; )

     }

     VdbeBranchTaken(0, (pOp->p5 & SQLITE_NULLEQ)?2:3);

     break;

@@ -91880,6 +92415,7 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
         goto jump_to_p2;

       }

       iCompare = 1;    /* Operands are not equal */

+      VVA_ONLY( iCompareIsInit = 1; )

       break;

     }

   }else{

@@ -91890,14 +92426,14 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
       if( (flags1 | flags3)&MEM_Str ){

         if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){

           applyNumericAffinity(pIn1,0);

-          testcase( flags3==pIn3->flags );

+          assert( flags3==pIn3->flags || CORRUPT_DB );

           flags3 = pIn3->flags;

         }

         if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){

           applyNumericAffinity(pIn3,0);

         }

       }

-    }else if( affinity==SQLITE_AFF_TEXT ){

+    }else if( affinity==SQLITE_AFF_TEXT && ((flags1 | flags3) & MEM_Str)!=0 ){

       if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){

         testcase( pIn1->flags & MEM_Int );

         testcase( pIn1->flags & MEM_Real );

@@ -91905,7 +92441,7 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
         sqlite3VdbeMemStringify(pIn1, encoding, 1);

         testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );

         flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);

-        if( pIn1==pIn3 ) flags3 = flags1 | MEM_Str;

+        if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str;

       }

       if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){

         testcase( pIn3->flags & MEM_Int );

@@ -91936,6 +92472,7 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
     res2 = sqlite3aGTb[pOp->opcode];

   }

   iCompare = res;

+  VVA_ONLY( iCompareIsInit = 1; )

 

   /* Undo any changes made by applyAffinity() to the input registers. */

   assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );

@@ -91974,6 +92511,7 @@ case OP_ElseEq: {       /* same as TK_ESCAPE, jump */
     break;

   }

 #endif /* SQLITE_DEBUG */

+  assert( iCompareIsInit );

   VdbeBranchTaken(iCompare==0, 2);

   if( iCompare==0 ) goto jump_to_p2;

   break;

@@ -92068,6 +92606,7 @@ case OP_Compare: {
     pColl = pKeyInfo->aColl[i];

     bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);

     iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);

+    VVA_ONLY( iCompareIsInit = 1; )

     if( iCompare ){

       if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)

        && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null))

@@ -92092,6 +92631,7 @@ case OP_Compare: {
 */

 case OP_Jump: {             /* jump */

   assert( pOp>aOp && pOp[-1].opcode==OP_Compare );

+  assert( iCompareIsInit );

   if( iCompare<0 ){

     VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];

   }else if( iCompare==0 ){

@@ -92491,7 +93031,7 @@ case OP_Offset: {          /* out3 */
 ** typeof() function or the IS NULL or IS NOT NULL operators or the

 ** equivalent.  In this case, all content loading can be omitted.

 */

-case OP_Column: {

+case OP_Column: {            /* ncycle */

   u32 p2;            /* column number to retrieve */

   VdbeCursor *pC;    /* The VDBE cursor */

   BtCursor *pCrsr;   /* The B-Tree cursor corresponding to pC */

@@ -92840,7 +93380,7 @@ case OP_TypeCheck: {
         }

         case COLTYPE_REAL: {

           testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_Real );

-          testcase( (pIn1->flags & (MEM_Real|MEM_IntReal))==MEM_IntReal );

+          assert( (pIn1->flags & MEM_IntReal)==0 );

           if( pIn1->flags & MEM_Int ){

             /* When applying REAL affinity, if the result is still an MEM_Int

             ** that will fit in 6 bytes, then change the type to MEM_IntReal

@@ -93843,7 +94383,7 @@ case OP_SetCookie: {
 **

 ** See also: OP_OpenRead, OP_ReopenIdx

 */

-case OP_ReopenIdx: {

+case OP_ReopenIdx: {         /* ncycle */

   int nField;

   KeyInfo *pKeyInfo;

   u32 p2;

@@ -93864,7 +94404,7 @@ case OP_ReopenIdx: {
   }

   /* 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_OpenRead:            /* ncycle */

 case OP_OpenWrite:

 

   assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );

@@ -93958,7 +94498,7 @@ open_cursor_set_hints:
 **

 ** Duplicate ephemeral cursors are used for self-joins of materialized views.

 */

-case OP_OpenDup: {

+case OP_OpenDup: {           /* ncycle */

   VdbeCursor *pOrig;    /* The original cursor to be duplicated */

   VdbeCursor *pCx;      /* The new cursor */

 

@@ -94020,8 +94560,8 @@ case OP_OpenDup: {
 ** by this opcode will be used for automatically created transient

 ** indices in joins.

 */

-case OP_OpenAutoindex:

-case OP_OpenEphemeral: {

+case OP_OpenAutoindex:       /* ncycle */

+case OP_OpenEphemeral: {     /* ncycle */

   VdbeCursor *pCx;

   KeyInfo *pKeyInfo;

 

@@ -94179,7 +94719,7 @@ case OP_OpenPseudo: {
 ** Close a cursor previously opened as P1.  If P1 is not

 ** currently open, this instruction is a no-op.

 */

-case OP_Close: {

+case OP_Close: {             /* ncycle */

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);

   p->apCsr[pOp->p1] = 0;

@@ -94296,10 +94836,10 @@ case OP_ColumnsUsed: {
 **

 ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt

 */

-case OP_SeekLT:         /* jump, in3, group */

-case OP_SeekLE:         /* jump, in3, group */

-case OP_SeekGE:         /* jump, in3, group */

-case OP_SeekGT: {       /* jump, in3, group */

+case OP_SeekLT:         /* jump, in3, group, ncycle */

+case OP_SeekLE:         /* jump, in3, group, ncycle */

+case OP_SeekGE:         /* jump, in3, group, ncycle */

+case OP_SeekGT: {       /* jump, in3, group, ncycle */

   int res;           /* Comparison result */

   int oc;            /* Opcode */

   VdbeCursor *pC;    /* The cursor to seek */

@@ -94565,7 +95105,7 @@ seek_not_found:
 **      jump to SeekOP.P2 if This.P5==0 or to This.P2 if This.P5>0.

 ** </ol>

 */

-case OP_SeekScan: {

+case OP_SeekScan: {          /* ncycle */

   VdbeCursor *pC;

   int res;

   int nStep;

@@ -94687,7 +95227,7 @@ case OP_SeekScan: {
 **

 ** P1 must be a valid b-tree cursor.

 */

-case OP_SeekHit: {

+case OP_SeekHit: {           /* ncycle */

   VdbeCursor *pC;

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   pC = p->apCsr[pOp->p1];

@@ -94819,7 +95359,7 @@ case OP_IfNotOpen: {        /* jump */
 **

 ** See also: NotFound, Found, NotExists

 */

-case OP_IfNoHope: {     /* jump, in3 */

+case OP_IfNoHope: {     /* jump, in3, ncycle */

   VdbeCursor *pC;

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   pC = p->apCsr[pOp->p1];

@@ -94833,9 +95373,9 @@ case OP_IfNoHope: {     /* jump, in3 */
   /* Fall through into OP_NotFound */

   /* no break */ deliberate_fall_through

 }

-case OP_NoConflict:     /* jump, in3 */

-case OP_NotFound:       /* jump, in3 */

-case OP_Found: {        /* jump, in3 */

+case OP_NoConflict:     /* jump, in3, ncycle */

+case OP_NotFound:       /* jump, in3, ncycle */

+case OP_Found: {        /* jump, in3, ncycle */

   int alreadyExists;

   int ii;

   VdbeCursor *pC;

@@ -94965,7 +95505,7 @@ case OP_Found: {        /* jump, in3 */
 **

 ** See also: Found, NotFound, NoConflict, SeekRowid

 */

-case OP_SeekRowid: {        /* jump, in3 */

+case OP_SeekRowid: {        /* jump, in3, ncycle */

   VdbeCursor *pC;

   BtCursor *pCrsr;

   int res;

@@ -94990,7 +95530,7 @@ case OP_SeekRowid: {        /* jump, in3 */
   }

   /* Fall through into OP_NotExists */

   /* no break */ deliberate_fall_through

-case OP_NotExists:          /* jump, in3 */

+case OP_NotExists:          /* jump, in3, ncycle */

   pIn3 = &aMem[pOp->p3];

   assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

@@ -95270,8 +95810,11 @@ case OP_Insert: {
   if( pOp->p5 & OPFLAG_ISNOOP ) break;

 #endif

 

-  if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;

-  if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;

+  assert( (pOp->p5 & OPFLAG_LASTROWID)==0 || (pOp->p5 & OPFLAG_NCHANGE)!=0 );

+  if( pOp->p5 & OPFLAG_NCHANGE ){

+    p->nChange++;

+    if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;

+  }

   assert( (pData->flags & (MEM_Blob|MEM_Str))!=0 || pData->n==0 );

   x.pData = pData->z;

   x.nData = pData->n;

@@ -95282,6 +95825,7 @@ case OP_Insert: {
     x.nZero = 0;

   }

   x.pKey = 0;

+  assert( BTREE_PREFORMAT==OPFLAG_PREFORMAT );

   rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,

       (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),

       seekResult

@@ -95613,7 +96157,7 @@ case OP_RowData: {
 ** be a separate OP_VRowid opcode for use with virtual tables, but this

 ** one opcode now works for both table types.

 */

-case OP_Rowid: {                 /* out2 */

+case OP_Rowid: {                 /* out2, ncycle */

   VdbeCursor *pC;

   i64 v;

   sqlite3_vtab *pVtab;

@@ -95712,8 +96256,8 @@ case OP_NullRow: {
 ** from the end toward the beginning.  In other words, the cursor is

 ** configured to use Prev, not Next.

 */

-case OP_SeekEnd:

-case OP_Last: {        /* jump */

+case OP_SeekEnd:             /* ncycle */

+case OP_Last: {              /* jump, ncycle */

   VdbeCursor *pC;

   BtCursor *pCrsr;

   int res;

@@ -95814,17 +96358,22 @@ case OP_Sort: {        /* jump */
 ** If the table or index is not empty, fall through to the following

 ** instruction.

 **

+** If P2 is zero, that is an assertion that the P1 table is never

+** empty and hence the jump will never be taken.

+**

 ** This opcode leaves the cursor configured to move in forward order,

 ** from the beginning toward the end.  In other words, the cursor is

 ** configured to use Next, not Prev.

 */

-case OP_Rewind: {        /* jump */

+case OP_Rewind: {        /* jump, ncycle */

   VdbeCursor *pC;

   BtCursor *pCrsr;

   int res;

 

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   assert( pOp->p5==0 );

+  assert( pOp->p2>=0 && pOp->p2<p->nOp );

+

   pC = p->apCsr[pOp->p1];

   assert( pC!=0 );

   assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );

@@ -95844,9 +96393,10 @@ case OP_Rewind: {        /* jump */
   }

   if( rc ) goto abort_due_to_error;

   pC->nullRow = (u8)res;

-  assert( pOp->p2>0 && pOp->p2<p->nOp );

-  VdbeBranchTaken(res!=0,2);

-  if( res ) goto jump_to_p2;

+  if( pOp->p2>0 ){

+    VdbeBranchTaken(res!=0,2);

+    if( res ) goto jump_to_p2;

+  }

   break;

 }

 

@@ -95912,7 +96462,7 @@ case OP_SorterNext: {  /* jump */
   rc = sqlite3VdbeSorterNext(db, pC);

   goto next_tail;

 

-case OP_Prev:          /* jump */

+case OP_Prev:          /* jump, ncycle */

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   assert( pOp->p5==0

        || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP

@@ -95927,7 +96477,7 @@ case OP_Prev:          /* jump */
   rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);

   goto next_tail;

 

-case OP_Next:          /* jump */

+case OP_Next:          /* jump, ncycle */

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   assert( pOp->p5==0

        || pOp->p5==SQLITE_STMTSTATUS_FULLSCAN_STEP

@@ -96119,8 +96669,8 @@ case OP_IdxDelete: {
 **

 ** See also: Rowid, MakeRecord.

 */

-case OP_DeferredSeek:

-case OP_IdxRowid: {           /* out2 */

+case OP_DeferredSeek:         /* ncycle */

+case OP_IdxRowid: {           /* out2, ncycle */

   VdbeCursor *pC;             /* The P1 index cursor */

   VdbeCursor *pTabCur;        /* The P2 table cursor (OP_DeferredSeek only) */

   i64 rowid;                  /* Rowid that P1 current points to */

@@ -96182,8 +96732,8 @@ case OP_IdxRowid: {           /* out2 */
 ** seek operation now, without further delay.  If the cursor seek has

 ** already occurred, this instruction is a no-op.

 */

-case OP_FinishSeek: {

-  VdbeCursor *pC;             /* The P1 index cursor */

+case OP_FinishSeek: {        /* ncycle */

+  VdbeCursor *pC;            /* The P1 index cursor */

 

   assert( pOp->p1>=0 && pOp->p1<p->nCursor );

   pC = p->apCsr[pOp->p1];

@@ -96238,10 +96788,10 @@ case OP_FinishSeek: {
 ** If the P1 index entry is less than or equal to the key value then jump

 ** to P2. Otherwise fall through to the next instruction.

 */

-case OP_IdxLE:          /* jump */

-case OP_IdxGT:          /* jump */

-case OP_IdxLT:          /* jump */

-case OP_IdxGE:  {       /* jump */

+case OP_IdxLE:          /* jump, ncycle */

+case OP_IdxGT:          /* jump, ncycle */

+case OP_IdxLT:          /* jump, ncycle */

+case OP_IdxGE:  {       /* jump, ncycle */

   VdbeCursor *pC;

   int res;

   UnpackedRecord r;

@@ -96652,13 +97202,14 @@ case OP_IntegrityCk: {
   pIn1 = &aMem[pOp->p1];

   assert( pOp->p5<db->nDb );

   assert( DbMaskTest(p->btreeMask, pOp->p5) );

-  z = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,

-                                 (int)pnErr->u.i+1, &nErr);

+  rc = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,

+                                 (int)pnErr->u.i+1, &nErr, &z);

   sqlite3VdbeMemSetNull(pIn1);

   if( nErr==0 ){

     assert( z==0 );

-  }else if( z==0 ){

-    goto no_mem;

+  }else if( rc ){

+    sqlite3_free(z);

+    goto abort_due_to_error;

   }else{

     pnErr->u.i -= nErr-1;

     sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);

@@ -96862,9 +97413,6 @@ case OP_Program: {        /* jump */
     pFrame->aOp = p->aOp;

     pFrame->nOp = p->nOp;

     pFrame->token = pProgram->token;

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-    pFrame->anExec = p->anExec;

-#endif

 #ifdef SQLITE_DEBUG

     pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;

 #endif

@@ -96901,9 +97449,6 @@ case OP_Program: {        /* jump */
   memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);

   p->aOp = aOp = pProgram->aOp;

   p->nOp = pProgram->nOp;

-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

-  p->anExec = 0;

-#endif

 #ifdef SQLITE_DEBUG

   /* Verify that second and subsequent executions of the same trigger do not

   ** try to reuse register values from the first use. */

@@ -97660,7 +98205,7 @@ case OP_VDestroy: {
 ** P1 is a cursor number.  This opcode opens a cursor to the virtual

 ** table and stores that cursor in P1.

 */

-case OP_VOpen: {

+case OP_VOpen: {             /* ncycle */

   VdbeCursor *pCur;

   sqlite3_vtab_cursor *pVCur;

   sqlite3_vtab *pVtab;

@@ -97707,7 +98252,7 @@ case OP_VOpen: {
 ** cursor.  Register P3 is used to hold the values returned by

 ** sqlite3_vtab_in_first() and sqlite3_vtab_in_next().

 */

-case OP_VInitIn: {        /* out2 */

+case OP_VInitIn: {        /* out2, ncycle */

   VdbeCursor *pC;         /* The cursor containing the RHS values */

   ValueList *pRhs;        /* New ValueList object to put in reg[P2] */

 

@@ -97718,7 +98263,7 @@ case OP_VInitIn: {        /* out2 */
   pRhs->pOut = &aMem[pOp->p3];

   pOut = out2Prerelease(p, pOp);

   pOut->flags = MEM_Null;

-  sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3_free);

+  sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3VdbeValueListFree);

   break;

 }

 #endif /* SQLITE_OMIT_VIRTUALTABLE */

@@ -97744,7 +98289,7 @@ case OP_VInitIn: {        /* out2 */
 **

 ** A jump is made to P2 if the result set after filtering would be empty.

 */

-case OP_VFilter: {   /* jump */

+case OP_VFilter: {   /* jump, ncycle */

   int nArg;

   int iQuery;

   const sqlite3_module *pModule;

@@ -97804,7 +98349,7 @@ case OP_VFilter: {   /* jump */
 ** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are

 ** unused by OP_VColumn.

 */

-case OP_VColumn: {

+case OP_VColumn: {           /* ncycle */

   sqlite3_vtab *pVtab;

   const sqlite3_module *pModule;

   Mem *pDest;

@@ -97856,7 +98401,7 @@ case OP_VColumn: {
 ** jump to instruction P2.  Or, if the virtual table has reached

 ** the end of its result set, then fall through to the next instruction.

 */

-case OP_VNext: {   /* jump */

+case OP_VNext: {   /* jump, ncycle */

   sqlite3_vtab *pVtab;

   const sqlite3_module *pModule;

   int res;

@@ -98439,12 +98984,12 @@ default: {          /* This is really OP_Noop, OP_Explain */
 *****************************************************************************/

     }

 

-#ifdef VDBE_PROFILE

-    {

-      u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();

-      if( endTime>start ) pOrigOp->cycles += endTime - start;

-      pOrigOp->cnt++;

-    }

+#if defined(VDBE_PROFILE)

+    *pnCycle += sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();

+    pnCycle = 0;

+#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS)

+    *pnCycle += sqlite3Hwtime();

+    pnCycle = 0;

 #endif

 

     /* The following code adds nothing to the actual functionality

@@ -98520,6 +99065,18 @@ abort_due_to_error:
   ** release the mutexes on btrees that were acquired at the

   ** top. */

 vdbe_return:

+#if defined(VDBE_PROFILE)

+  if( pnCycle ){

+    *pnCycle += sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();

+    pnCycle = 0;

+  }

+#elif defined(SQLITE_ENABLE_STMT_SCANSTATUS)

+  if( pnCycle ){

+    *pnCycle += sqlite3Hwtime();

+    pnCycle = 0;

+  }

+#endif

+

 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK

   while( nVmStep>=nProgressLimit && db->xProgress!=0 ){

     nProgressLimit += db->nProgressOps;

@@ -98531,7 +99088,9 @@ vdbe_return:
   }

 #endif

   p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;

-  sqlite3VdbeLeave(p);

+  if( DbMaskNonZero(p->lockMask) ){

+    sqlite3VdbeLeave(p);

+  }

   assert( rc!=SQLITE_OK || nExtraDelete==0

        || sqlite3_strlike("DELETE%",p->zSql,0)!=0

   );

@@ -101938,6 +102497,9 @@ static int bytecodevtabConnect(
    ");"

   };

 

+  (void)argc;

+  (void)argv;

+  (void)pzErr;

   rc = sqlite3_declare_vtab(db, azSchema[isTabUsed]);

   if( rc==SQLITE_OK ){

     pNew = sqlite3_malloc( sizeof(*pNew) );

@@ -102173,6 +102735,7 @@ static int bytecodevtabFilter(
   bytecodevtab_cursor *pCur = (bytecodevtab_cursor *)pVtabCursor;

   bytecodevtab *pVTab = (bytecodevtab *)pVtabCursor->pVtab;

   int rc = SQLITE_OK;

+  (void)idxStr;

 

   bytecodevtabCursorClear(pCur);

   pCur->iRowid = 0;

@@ -103188,6 +103751,32 @@ static void extendFJMatch(
 }

 

 /*

+** Return TRUE (non-zero) if zTab is a valid name for the schema table pTab.

+*/

+static SQLITE_NOINLINE int isValidSchemaTableName(

+  const char *zTab,         /* Name as it appears in the SQL */

+  Table *pTab,              /* The schema table we are trying to match */

+  Schema *pSchema           /* non-NULL if a database qualifier is present */

+){

+  const char *zLegacy;

+  assert( pTab!=0 );

+  assert( pTab->tnum==1 );

+  if( sqlite3StrNICmp(zTab, "sqlite_", 7)!=0 ) return 0;

+  zLegacy = pTab->zName;

+  if( strcmp(zLegacy+7, &LEGACY_TEMP_SCHEMA_TABLE[7])==0 ){

+    if( sqlite3StrICmp(zTab+7, &PREFERRED_TEMP_SCHEMA_TABLE[7])==0 ){

+      return 1;

+    }

+    if( pSchema==0 ) return 0;

+    if( sqlite3StrICmp(zTab+7, &LEGACY_SCHEMA_TABLE[7])==0 ) return 1;

+    if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1;

+  }else{

+    if( sqlite3StrICmp(zTab+7, &PREFERRED_SCHEMA_TABLE[7])==0 ) return 1;

+  }

+  return 0;

+}

+

+/*

 ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up

 ** that name in the set of source tables in pSrcList and make the pExpr

 ** expression node refer back to that source column.  The following changes

@@ -103340,15 +103929,17 @@ static int lookupName(
         }

         assert( zDb==0 || zTab!=0 );

         if( zTab ){

-          const char *zTabName;

           if( zDb ){

             if( pTab->pSchema!=pSchema ) continue;

             if( pSchema==0 && strcmp(zDb,"*")!=0 ) continue;

           }

-          zTabName = pItem->zAlias ? pItem->zAlias : pTab->zName;

-          assert( zTabName!=0 );

-          if( sqlite3StrICmp(zTabName, zTab)!=0 ){

-            continue;

+          if( pItem->zAlias!=0 ){

+            if( sqlite3StrICmp(zTab, pItem->zAlias)!=0 ){

+              continue;

+            }

+          }else if( sqlite3StrICmp(zTab, pTab->zName)!=0 ){

+            if( pTab->tnum!=1 ) continue;

+            if( !isValidSchemaTableName(zTab, pTab, pSchema) ) continue;

           }

           assert( ExprUseYTab(pExpr) );

           if( IN_RENAME_OBJECT && pItem->zAlias ){

@@ -103491,6 +104082,7 @@ static int lookupName(
             if( pParse->bReturning ){

               eNewExprOp = TK_REGISTER;

               pExpr->op2 = TK_COLUMN;

+              pExpr->iColumn = iCol;

               pExpr->iTable = pNC->uNC.iBaseReg + (pTab->nCol+1)*pExpr->iTable +

                  sqlite3TableColumnToStorage(pTab, iCol) + 1;

             }else{

@@ -105167,49 +105759,122 @@ SQLITE_PRIVATE char sqlite3TableColumnAffinity(const Table *pTab, int iCol){
 */

 SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){

   int op;

-  while( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){

-    assert( pExpr->op==TK_COLLATE

-         || pExpr->op==TK_IF_NULL_ROW

-         || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );

-    pExpr = pExpr->pLeft;

-    assert( pExpr!=0 );

-  }

   op = pExpr->op;

-  if( op==TK_REGISTER ) op = pExpr->op2;

-  if( op==TK_COLUMN || op==TK_AGG_COLUMN ){

-    assert( ExprUseYTab(pExpr) );

-    assert( pExpr->y.pTab!=0 );

-    return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);

-  }

-  if( op==TK_SELECT ){

-    assert( ExprUseXSelect(pExpr) );

-    assert( pExpr->x.pSelect!=0 );

-    assert( pExpr->x.pSelect->pEList!=0 );

-    assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );

-    return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);

-  }

+  while( 1 /* exit-by-break */ ){

+    if( op==TK_COLUMN || (op==TK_AGG_COLUMN && pExpr->y.pTab!=0) ){

+      assert( ExprUseYTab(pExpr) );

+      assert( pExpr->y.pTab!=0 );

+      return sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);

+    }

+    if( op==TK_SELECT ){

+      assert( ExprUseXSelect(pExpr) );

+      assert( pExpr->x.pSelect!=0 );

+      assert( pExpr->x.pSelect->pEList!=0 );

+      assert( pExpr->x.pSelect->pEList->a[0].pExpr!=0 );

+      return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);

+    }

 #ifndef SQLITE_OMIT_CAST

-  if( op==TK_CAST ){

-    assert( !ExprHasProperty(pExpr, EP_IntValue) );

-    return sqlite3AffinityType(pExpr->u.zToken, 0);

-  }

+    if( op==TK_CAST ){

+      assert( !ExprHasProperty(pExpr, EP_IntValue) );

+      return sqlite3AffinityType(pExpr->u.zToken, 0);

+    }

 #endif

-  if( op==TK_SELECT_COLUMN ){

-    assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );

-    assert( pExpr->iColumn < pExpr->iTable );

-    assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );

-    return sqlite3ExprAffinity(

-        pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr

-    );

-  }

-  if( op==TK_VECTOR ){

-    assert( ExprUseXList(pExpr) );

-    return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);

+    if( op==TK_SELECT_COLUMN ){

+      assert( pExpr->pLeft!=0 && ExprUseXSelect(pExpr->pLeft) );

+      assert( pExpr->iColumn < pExpr->iTable );

+      assert( pExpr->iTable==pExpr->pLeft->x.pSelect->pEList->nExpr );

+      return sqlite3ExprAffinity(

+          pExpr->pLeft->x.pSelect->pEList->a[pExpr->iColumn].pExpr

+      );

+    }

+    if( op==TK_VECTOR ){

+      assert( ExprUseXList(pExpr) );

+      return sqlite3ExprAffinity(pExpr->x.pList->a[0].pExpr);

+    }

+    if( ExprHasProperty(pExpr, EP_Skip|EP_IfNullRow) ){

+      assert( pExpr->op==TK_COLLATE

+           || pExpr->op==TK_IF_NULL_ROW

+           || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );

+      pExpr = pExpr->pLeft;

+      op = pExpr->op;

+      continue;

+    }

+    if( op!=TK_REGISTER || (op = pExpr->op2)==TK_REGISTER ) break;

   }

   return pExpr->affExpr;

 }

 

 /*

+** Make a guess at all the possible datatypes of the result that could

+** be returned by an expression.  Return a bitmask indicating the answer:

+**

+**     0x01         Numeric

+**     0x02         Text

+**     0x04         Blob

+**

+** If the expression must return NULL, then 0x00 is returned.

+*/

+SQLITE_PRIVATE int sqlite3ExprDataType(const Expr *pExpr){

+  while( pExpr ){

+    switch( pExpr->op ){

+      case TK_COLLATE:

+      case TK_IF_NULL_ROW:

+      case TK_UPLUS:  {

+        pExpr = pExpr->pLeft;

+        break;

+      }

+      case TK_NULL: {

+        pExpr = 0;

+        break;

+      }

+      case TK_STRING: {

+        return 0x02;

+      }

+      case TK_BLOB: {

+        return 0x04;

+      }

+      case TK_CONCAT: {

+        return 0x06;

+      }

+      case TK_VARIABLE:

+      case TK_AGG_FUNCTION:

+      case TK_FUNCTION: {

+        return 0x07;

+      }

+      case TK_COLUMN:

+      case TK_AGG_COLUMN:

+      case TK_SELECT:

+      case TK_CAST:

+      case TK_SELECT_COLUMN:

+      case TK_VECTOR:  {

+        int aff = sqlite3ExprAffinity(pExpr);

+        if( aff>=SQLITE_AFF_NUMERIC ) return 0x05;

+        if( aff==SQLITE_AFF_TEXT )    return 0x06;

+        return 0x07;

+      }

+      case TK_CASE: {

+        int res = 0;

+        int ii;

+        ExprList *pList = pExpr->x.pList;

+        assert( ExprUseXList(pExpr) && pList!=0 );

+        assert( pList->nExpr > 0);

+        for(ii=1; ii<pList->nExpr; ii+=2){

+          res |= sqlite3ExprDataType(pList->a[ii].pExpr);

+        }

+        if( pList->nExpr % 2 ){

+          res |= sqlite3ExprDataType(pList->a[pList->nExpr-1].pExpr);

+        }

+        return res;

+      }

+      default: {

+        return 0x01;

+      }

+    } /* End of switch(op) */

+  } /* End of while(pExpr) */

+  return 0x00;

+}

+

+/*

 ** Set the collating sequence for expression pExpr to be the collating

 ** sequence named by pToken.   Return a pointer to a new Expr node that

 ** implements the COLLATE operator.

@@ -105296,7 +105961,9 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
   while( p ){

     int op = p->op;

     if( op==TK_REGISTER ) op = p->op2;

-    if( op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER ){

+    if( (op==TK_AGG_COLUMN && p->y.pTab!=0)

+     || op==TK_COLUMN || op==TK_TRIGGER

+    ){

       int j;

       assert( ExprUseYTab(p) );

       assert( p->y.pTab!=0 );

@@ -108378,6 +109045,9 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
   SelectDest dest;            /* How to deal with SELECT result */

   int nReg;                   /* Registers to allocate */

   Expr *pLimit;               /* New limit expression */

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+  int addrExplain;            /* Address of OP_Explain instruction */

+#endif

 

   Vdbe *v = pParse->pVdbe;

   assert( v!=0 );

@@ -108430,8 +109100,9 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
   ** In both cases, the query is augmented with "LIMIT 1".  Any

   ** preexisting limit is discarded in place of the new LIMIT 1.

   */

-  ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY %d",

+  ExplainQueryPlan2(addrExplain, (pParse, 1, "%sSCALAR SUBQUERY %d",

         addrOnce?"":"CORRELATED ", pSel->selId));

+  sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, -1);

   nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;

   sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);

   pParse->nMem += nReg;

@@ -108474,6 +109145,7 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
   if( addrOnce ){

     sqlite3VdbeJumpHere(v, addrOnce);

   }

+  sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);

 

   /* Subroutine return */

   assert( ExprUseYSub(pExpr) );

@@ -109146,10 +109818,13 @@ static int exprCodeInlineFunction(
       ** the type affinity of the argument.  This is used for testing of

       ** the SQLite type logic.

       */

-      const char *azAff[] = { "blob", "text", "numeric", "integer", "real" };

+      const char *azAff[] = { "blob", "text", "numeric", "integer",

+                              "real", "flexnum" };

       char aff;

       assert( nFarg==1 );

       aff = sqlite3ExprAffinity(pFarg->a[0].pExpr);

+      assert( aff<=SQLITE_AFF_NONE

+           || (aff>=SQLITE_AFF_BLOB && aff<=SQLITE_AFF_FLEXNUM) );

       sqlite3VdbeLoadString(v, target,

               (aff<=SQLITE_AFF_NONE) ? "none" : azAff[aff-SQLITE_AFF_BLOB]);

       break;

@@ -109160,7 +109835,7 @@ static int exprCodeInlineFunction(
 }

 

 /*

-** Check to see if pExpr is one of the indexed expressions on pParse->pIdxExpr.

+** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.

 ** If it is, then resolve the expression by reading from the index and

 ** return the register into which the value has been read.  If pExpr is

 ** not an indexed expression, then return negative.

@@ -109172,7 +109847,7 @@ static SQLITE_NOINLINE int sqlite3IndexedExprLookup(
 ){

   IndexedExpr *p;

   Vdbe *v;

-  for(p=pParse->pIdxExpr; p; p=p->pIENext){

+  for(p=pParse->pIdxEpr; p; p=p->pIENext){

     int iDataCur = p->iDataCur;

     if( iDataCur<0 ) continue;

     if( pParse->iSelfTab ){

@@ -109192,10 +109867,10 @@ static SQLITE_NOINLINE int sqlite3IndexedExprLookup(
       sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);

       VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));

       sqlite3VdbeGoto(v, 0);

-      p = pParse->pIdxExpr;

-      pParse->pIdxExpr = 0;

+      p = pParse->pIdxEpr;

+      pParse->pIdxEpr = 0;

       sqlite3ExprCode(pParse, pExpr, target);

-      pParse->pIdxExpr = p;

+      pParse->pIdxEpr = p;

       sqlite3VdbeJumpHere(v, addr+2);

     }else{

       sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);

@@ -109234,7 +109909,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
 expr_code_doover:

   if( pExpr==0 ){

     op = TK_NULL;

-  }else if( pParse->pIdxExpr!=0

+  }else if( pParse->pIdxEpr!=0

    && !ExprHasProperty(pExpr, EP_Leaf)

    && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0

   ){

@@ -109251,15 +109926,16 @@ expr_code_doover:
       assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );

       pCol = &pAggInfo->aCol[pExpr->iAgg];

       if( !pAggInfo->directMode ){

-        assert( pCol->iMem>0 );

-        return pCol->iMem;

+        return AggInfoColumnReg(pAggInfo, pExpr->iAgg);

       }else if( pAggInfo->useSortingIdx ){

         Table *pTab = pCol->pTab;

         sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,

                               pCol->iSorterColumn, target);

-        if( pCol->iColumn<0 ){

+        if( pTab==0 ){

+          /* No comment added */

+        }else if( pCol->iColumn<0 ){

           VdbeComment((v,"%s.rowid",pTab->zName));

-        }else if( ALWAYS(pTab!=0) ){

+        }else{

           VdbeComment((v,"%s.%s",

               pTab->zName, pTab->aCol[pCol->iColumn].zCnName));

           if( pTab->aCol[pCol->iColumn].affinity==SQLITE_AFF_REAL ){

@@ -109267,6 +109943,11 @@ expr_code_doover:
           }

         }

         return target;

+      }else if( pExpr->y.pTab==0 ){

+        /* This case happens when the argument to an aggregate function

+        ** is rewritten by aggregateConvertIndexedExprRefToColumn() */

+        sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);

+        return target;

       }

       /* Otherwise, fall thru into the TK_COLUMN case */

       /* no break */ deliberate_fall_through

@@ -109287,7 +109968,7 @@ expr_code_doover:
         assert( pExpr->y.pTab!=0 );

         aff = sqlite3TableColumnAffinity(pExpr->y.pTab, pExpr->iColumn);

         if( aff>SQLITE_AFF_BLOB ){

-          static const char zAff[] = "B\000C\000D\000E";

+          static const char zAff[] = "B\000C\000D\000E\000F";

           assert( SQLITE_AFF_BLOB=='A' );

           assert( SQLITE_AFF_TEXT=='B' );

           sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0,

@@ -109564,7 +110245,7 @@ expr_code_doover:
         assert( !ExprHasProperty(pExpr, EP_IntValue) );

         sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);

       }else{

-        return pInfo->aFunc[pExpr->iAgg].iMem;

+        return AggInfoFuncReg(pInfo, pExpr->iAgg);

       }

       break;

     }

@@ -109853,7 +110534,7 @@ expr_code_doover:
       if( pAggInfo ){

         assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );

         if( !pAggInfo->directMode ){

-          inReg = pAggInfo->aCol[pExpr->iAgg].iMem;

+          inReg = AggInfoColumnReg(pAggInfo, pExpr->iAgg);

           break;

         }

         if( pExpr->pAggInfo->useSortingIdx ){

@@ -111284,10 +111965,8 @@ SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList
 ** it does, make a copy.  This is done because the pExpr argument is

 ** subject to change.

 **

-** The copy is stored on pParse->pConstExpr with a register number of 0.

-** This will cause the expression to be deleted automatically when the

-** Parse object is destroyed, but the zero register number means that it

-** will not generate any code in the preamble.

+** The copy is scheduled for deletion using the sqlite3ExprDeferredDelete()

+** which builds on the sqlite3ParserAddCleanup() mechanism.

 */

 static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){

   if( ALWAYS(!ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced))

@@ -111298,7 +111977,6 @@ static int agginfoPersistExprCb(Walker *pWalker, Expr *pExpr){
     Parse *pParse = pWalker->pParse;

     sqlite3 *db = pParse->db;

     if( pExpr->op!=TK_AGG_FUNCTION ){

-      assert( pExpr->op==TK_AGG_COLUMN || pExpr->op==TK_IF_NULL_ROW );

       assert( iAgg>=0 && iAgg<pAggInfo->nColumn );

       if( pAggInfo->aCol[iAgg].pCExpr==pExpr ){

         pExpr = sqlite3ExprDup(db, pExpr, 0);

@@ -111366,6 +112044,73 @@ static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
 }

 

 /*

+** Search the AggInfo object for an aCol[] entry that has iTable and iColumn.

+** Return the index in aCol[] of the entry that describes that column.

+**

+** If no prior entry is found, create a new one and return -1.  The

+** new column will have an idex of pAggInfo->nColumn-1.

+*/

+static void findOrCreateAggInfoColumn(

+  Parse *pParse,       /* Parsing context */

+  AggInfo *pAggInfo,   /* The AggInfo object to search and/or modify */

+  Expr *pExpr          /* Expr describing the column to find or insert */

+){

+  struct AggInfo_col *pCol;

+  int k;

+

+  assert( pAggInfo->iFirstReg==0 );

+  pCol = pAggInfo->aCol;

+  for(k=0; k<pAggInfo->nColumn; k++, pCol++){

+    if( pCol->iTable==pExpr->iTable

+     && pCol->iColumn==pExpr->iColumn

+     && pExpr->op!=TK_IF_NULL_ROW

+    ){

+      goto fix_up_expr;

+    }

+  }

+  k = addAggInfoColumn(pParse->db, pAggInfo);

+  if( k<0 ){

+    /* OOM on resize */

+    assert( pParse->db->mallocFailed );

+    return;

+  }

+  pCol = &pAggInfo->aCol[k];

+  assert( ExprUseYTab(pExpr) );

+  pCol->pTab = pExpr->y.pTab;

+  pCol->iTable = pExpr->iTable;

+  pCol->iColumn = pExpr->iColumn;

+  pCol->iSorterColumn = -1;

+  pCol->pCExpr = pExpr;

+  if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){

+    int j, n;

+    ExprList *pGB = pAggInfo->pGroupBy;

+    struct ExprList_item *pTerm = pGB->a;

+    n = pGB->nExpr;

+    for(j=0; j<n; j++, pTerm++){

+      Expr *pE = pTerm->pExpr;

+      if( pE->op==TK_COLUMN

+       && pE->iTable==pExpr->iTable

+       && pE->iColumn==pExpr->iColumn

+      ){

+        pCol->iSorterColumn = j;

+        break;

+      }

+    }

+  }

+  if( pCol->iSorterColumn<0 ){

+    pCol->iSorterColumn = pAggInfo->nSortingColumn++;

+  }

+fix_up_expr:

+  ExprSetVVAProperty(pExpr, EP_NoReduce);

+  assert( pExpr->pAggInfo==0 || pExpr->pAggInfo==pAggInfo );

+  pExpr->pAggInfo = pAggInfo;

+  if( pExpr->op==TK_COLUMN ){

+    pExpr->op = TK_AGG_COLUMN;

+  }

+  pExpr->iAgg = (i16)k;

+}

+

+/*

 ** This is the xExprCallback for a tree walker.  It is used to

 ** implement sqlite3ExprAnalyzeAggregates().  See sqlite3ExprAnalyzeAggregates

 ** for additional information.

@@ -111378,7 +112123,37 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
   AggInfo *pAggInfo = pNC->uNC.pAggInfo;

 

   assert( pNC->ncFlags & NC_UAggInfo );

+  assert( pAggInfo->iFirstReg==0 );

   switch( pExpr->op ){

+    default: {

+      IndexedExpr *pIEpr;

+      Expr tmp;

+      assert( pParse->iSelfTab==0 );

+      if( (pNC->ncFlags & NC_InAggFunc)==0 ) break;

+      if( pParse->pIdxEpr==0 ) break;

+      for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){

+        int iDataCur = pIEpr->iDataCur;

+        if( iDataCur<0 ) continue;

+        if( sqlite3ExprCompare(0, pExpr, pIEpr->pExpr, iDataCur)==0 ) break;

+      }

+      if( pIEpr==0 ) break;

+      if( NEVER(!ExprUseYTab(pExpr)) ) break;

+      if( pExpr->pAggInfo!=0 ) break; /* Already resolved by outer context */

+

+      /* If we reach this point, it means that expression pExpr can be

+      ** translated into a reference to an index column as described by

+      ** pIEpr.

+      */

+      memset(&tmp, 0, sizeof(tmp));

+      tmp.op = TK_AGG_COLUMN;

+      tmp.iTable = pIEpr->iIdxCur;

+      tmp.iColumn = pIEpr->iIdxCol;

+      findOrCreateAggInfoColumn(pParse, pAggInfo, &tmp);

+      pAggInfo->aCol[tmp.iAgg].pCExpr = pExpr;

+      pExpr->pAggInfo = pAggInfo;

+      pExpr->iAgg = tmp.iAgg;

+      return WRC_Prune;

+    }

     case TK_IF_NULL_ROW:

     case TK_AGG_COLUMN:

     case TK_COLUMN: {

@@ -111390,67 +112165,9 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
       if( ALWAYS(pSrcList!=0) ){

         SrcItem *pItem = pSrcList->a;

         for(i=0; i<pSrcList->nSrc; i++, pItem++){

-          struct AggInfo_col *pCol;

           assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );

           if( pExpr->iTable==pItem->iCursor ){

-            /* If we reach this point, it means that pExpr refers to a table

-            ** that is in the FROM clause of the aggregate query.

-            **

-            ** Make an entry for the column in pAggInfo->aCol[] if there

-            ** is not an entry there already.

-            */

-            int k;

-            pCol = pAggInfo->aCol;

-            for(k=0; k<pAggInfo->nColumn; k++, pCol++){

-              if( pCol->iTable==pExpr->iTable

-               && pCol->iColumn==pExpr->iColumn

-               && pExpr->op!=TK_IF_NULL_ROW

-              ){

-                break;

-              }

-            }

-            if( (k>=pAggInfo->nColumn)

-             && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0

-            ){

-              pCol = &pAggInfo->aCol[k];

-              assert( ExprUseYTab(pExpr) );

-              pCol->pTab = pExpr->y.pTab;

-              pCol->iTable = pExpr->iTable;

-              pCol->iColumn = pExpr->iColumn;

-              pCol->iMem = ++pParse->nMem;

-              pCol->iSorterColumn = -1;

-              pCol->pCExpr = pExpr;

-              if( pAggInfo->pGroupBy && pExpr->op!=TK_IF_NULL_ROW ){

-                int j, n;

-                ExprList *pGB = pAggInfo->pGroupBy;

-                struct ExprList_item *pTerm = pGB->a;

-                n = pGB->nExpr;

-                for(j=0; j<n; j++, pTerm++){

-                  Expr *pE = pTerm->pExpr;

-                  if( pE->op==TK_COLUMN

-                   && pE->iTable==pExpr->iTable

-                   && pE->iColumn==pExpr->iColumn

-                  ){

-                    pCol->iSorterColumn = j;

-                    break;

-                  }

-                }

-              }

-              if( pCol->iSorterColumn<0 ){

-                pCol->iSorterColumn = pAggInfo->nSortingColumn++;

-              }

-            }

-            /* There is now an entry for pExpr in pAggInfo->aCol[] (either

-            ** because it was there before or because we just created it).

-            ** Convert the pExpr to be a TK_AGG_COLUMN referring to that

-            ** pAggInfo->aCol[] entry.

-            */

-            ExprSetVVAProperty(pExpr, EP_NoReduce);

-            pExpr->pAggInfo = pAggInfo;

-            if( pExpr->op==TK_COLUMN ){

-              pExpr->op = TK_AGG_COLUMN;

-            }

-            pExpr->iAgg = (i16)k;

+            findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr);

             break;

           } /* endif pExpr->iTable==pItem->iCursor */

         } /* end loop over pSrcList */

@@ -111480,7 +112197,6 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
             assert( !ExprHasProperty(pExpr, EP_xIsSelect) );

             pItem = &pAggInfo->aFunc[i];

             pItem->pFExpr = pExpr;

-            pItem->iMem = ++pParse->nMem;

             assert( ExprUseUToken(pExpr) );

             pItem->pFunc = sqlite3FindFunction(pParse->db,

                    pExpr->u.zToken,

@@ -112377,13 +113093,14 @@ static void renameTokenCheckAll(Parse *pParse, const void *pPtr){
   assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );

   if( pParse->nErr==0 ){

     const RenameToken *p;

-    u8 i = 0;

+    u32 i = 1;

     for(p=pParse->pRename; p; p=p->pNext){

       if( p->p ){

         assert( p->p!=pPtr );

-        i += *(u8*)(p->p);

+        i += *(u8*)(p->p) | 1;

       }

     }

+    assert( i>0 );

   }

 }

 #else

@@ -115513,6 +116230,8 @@ static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
 ** and its contents.

 */

 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){

+  assert( db!=0 );

+  assert( pIdx!=0 );

 #ifdef SQLITE_ENABLE_STAT4

   if( pIdx->aSample ){

     int j;

@@ -115522,7 +116241,7 @@ SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){
     }

     sqlite3DbFree(db, pIdx->aSample);

   }

-  if( db && db->pnBytesFreed==0 ){

+  if( db->pnBytesFreed==0 ){

     pIdx->nSample = 0;

     pIdx->aSample = 0;

   }

@@ -115941,7 +116660,7 @@ static void attachFunc(
   char *zErr = 0;

   unsigned int flags;

   Db *aNew;                 /* New array of Db pointers */

-  Db *pNew;                 /* Db object for the newly attached database */

+  Db *pNew = 0;             /* Db object for the newly attached database */

   char *zErrDyn = 0;

   sqlite3_vfs *pVfs;

 

@@ -115961,13 +116680,26 @@ static void attachFunc(
     /* This is not a real ATTACH.  Instead, this routine is being called

     ** from sqlite3_deserialize() to close database db->init.iDb and

     ** reopen it as a MemDB */

+    Btree *pNewBt = 0;

     pVfs = sqlite3_vfs_find("memdb");

     if( pVfs==0 ) return;

-    pNew = &db->aDb[db->init.iDb];

-    if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);

-    pNew->pBt = 0;

-    pNew->pSchema = 0;

-    rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);

+    rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNewBt, 0, SQLITE_OPEN_MAIN_DB);

+    if( rc==SQLITE_OK ){

+      Schema *pNewSchema = sqlite3SchemaGet(db, pNewBt);

+      if( pNewSchema ){

+        /* Both the Btree and the new Schema were allocated successfully.

+        ** Close the old db and update the aDb[] slot with the new memdb

+        ** values.  */

+        pNew = &db->aDb[db->init.iDb];

+        if( ALWAYS(pNew->pBt) ) sqlite3BtreeClose(pNew->pBt);

+        pNew->pBt = pNewBt;

+        pNew->pSchema = pNewSchema;

+      }else{

+        sqlite3BtreeClose(pNewBt);

+        rc = SQLITE_NOMEM;

+      }

+    }

+    if( rc ) goto attach_error;

   }else{

     /* This is a real ATTACH

     **

@@ -116080,7 +116812,7 @@ static void attachFunc(
   }

 #endif

   if( rc ){

-    if( !REOPEN_AS_MEMDB(db) ){

+    if( ALWAYS(!REOPEN_AS_MEMDB(db)) ){

       int iDb = db->nDb - 1;

       assert( iDb>=2 );

       if( db->aDb[iDb].pBt ){

@@ -116197,6 +116929,8 @@ static void codeAttach(
   sqlite3* db = pParse->db;

   int regArgs;

 

+  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto attach_end;

+

   if( pParse->nErr ) goto attach_end;

   memset(&sName, 0, sizeof(NameContext));

   sName.pParse = pParse;

@@ -117039,6 +117773,7 @@ SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
   char saveBuf[PARSE_TAIL_SZ];

 

   if( pParse->nErr ) return;

+  if( pParse->eParseMode ) return;

   assert( pParse->nested<10 );  /* Nesting should only be of limited depth */

   va_start(ap, zFormat);

   zSql = sqlite3VMPrintf(db, zFormat, ap);

@@ -118736,6 +119471,13 @@ SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType
   if( pCol->colFlags & COLFLAG_PRIMKEY ){

     makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */

   }

+  if( ALWAYS(pExpr) && pExpr->op==TK_ID ){

+    /* The value of a generated column needs to be a real expression, not

+    ** just a reference to another column, in order for covering index

+    ** optimizations to work correctly.  So if the value is not an expression,

+    ** turn it into one by adding a unary "+" operator. */

+    pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);

+  }

   sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);

   pExpr = 0;

   goto generated_done;

@@ -118872,7 +119614,8 @@ static char *createTableStmt(sqlite3 *db, Table *p){
         /* SQLITE_AFF_TEXT    */ " TEXT",

         /* SQLITE_AFF_NUMERIC */ " NUM",

         /* SQLITE_AFF_INTEGER */ " INT",

-        /* SQLITE_AFF_REAL    */ " REAL"

+        /* SQLITE_AFF_REAL    */ " REAL",

+        /* SQLITE_AFF_FLEXNUM */ " NUM",

     };

     int len;

     const char *zType;

@@ -118888,10 +119631,12 @@ static char *createTableStmt(sqlite3 *db, Table *p){
     testcase( pCol->affinity==SQLITE_AFF_NUMERIC );

     testcase( pCol->affinity==SQLITE_AFF_INTEGER );

     testcase( pCol->affinity==SQLITE_AFF_REAL );

+    testcase( pCol->affinity==SQLITE_AFF_FLEXNUM );

 

     zType = azType[pCol->affinity - SQLITE_AFF_BLOB];

     len = sqlite3Strlen30(zType);

     assert( pCol->affinity==SQLITE_AFF_BLOB

+            || pCol->affinity==SQLITE_AFF_FLEXNUM

             || pCol->affinity==sqlite3AffinityType(zType, 0) );

     memcpy(&zStmt[k], zType, len);

     k += len;

@@ -119306,6 +120051,7 @@ SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
 ** not pass them into code generator routines by mistake.

 */

 static int markImmutableExprStep(Walker *pWalker, Expr *pExpr){

+  (void)pWalker;

   ExprSetVVAProperty(pExpr, EP_Immutable);

   return WRC_Continue;

 }

@@ -119872,8 +120618,7 @@ static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){
        && pTable->nCol==pSel->pEList->nExpr

       ){

         assert( db->mallocFailed==0 );

-        sqlite3SelectAddColumnTypeAndCollation(pParse, pTable, pSel,

-                                               SQLITE_AFF_NONE);

+        sqlite3SubqueryColumnTypes(pParse, pTable, pSel, SQLITE_AFF_NONE);

       }

     }else{

       /* CREATE VIEW name AS...  without an argument list.  Construct

@@ -125057,7 +125802,7 @@ SQLITE_PRIVATE void sqlite3QuoteValue(StrAccum *pStr, sqlite3_value *pValue){
     }

     case SQLITE_BLOB: {

       char const *zBlob = sqlite3_value_blob(pValue);

-      int nBlob = sqlite3_value_bytes(pValue);

+      i64 nBlob = sqlite3_value_bytes(pValue);

       assert( zBlob==sqlite3_value_blob(pValue) ); /* No encoding change */

       sqlite3StrAccumEnlarge(pStr, nBlob*2 + 4);

       if( pStr->accError==0 ){

@@ -125199,6 +125944,96 @@ static void hexFunc(
 }

 

 /*

+** Buffer zStr contains nStr bytes of utf-8 encoded text. Return 1 if zStr

+** contains character ch, or 0 if it does not.

+*/

+static int strContainsChar(const u8 *zStr, int nStr, u32 ch){

+  const u8 *zEnd = &zStr[nStr];

+  const u8 *z = zStr;

+  while( z<zEnd ){

+    u32 tst = Utf8Read(z);

+    if( tst==ch ) return 1;

+  }

+  return 0;

+}

+

+/*

+** The unhex() function. This function may be invoked with either one or

+** two arguments. In both cases the first argument is interpreted as text

+** a text value containing a set of pairs of hexadecimal digits which are

+** decoded and returned as a blob.

+**

+** If there is only a single argument, then it must consist only of an

+** even number of hexadeximal digits. Otherwise, return NULL.

+**

+** Or, if there is a second argument, then any character that appears in

+** the second argument is also allowed to appear between pairs of hexadecimal

+** digits in the first argument. If any other character appears in the

+** first argument, or if one of the allowed characters appears between

+** two hexadecimal digits that make up a single byte, NULL is returned.

+**

+** The following expressions are all true:

+**

+**     unhex('ABCD')       IS x'ABCD'

+**     unhex('AB CD')      IS NULL

+**     unhex('AB CD', ' ') IS x'ABCD'

+**     unhex('A BCD', ' ') IS NULL

+*/

+static void unhexFunc(

+  sqlite3_context *pCtx,

+  int argc,

+  sqlite3_value **argv

+){

+  const u8 *zPass = (const u8*)"";

+  int nPass = 0;

+  const u8 *zHex = sqlite3_value_text(argv[0]);

+  int nHex = sqlite3_value_bytes(argv[0]);

+#ifdef SQLITE_DEBUG

+  const u8 *zEnd = zHex ? &zHex[nHex] : 0;

+#endif

+  u8 *pBlob = 0;

+  u8 *p = 0;

+

+  assert( argc==1 || argc==2 );

+  if( argc==2 ){

+    zPass = sqlite3_value_text(argv[1]);

+    nPass = sqlite3_value_bytes(argv[1]);

+  }

+  if( !zHex || !zPass ) return;

+

+  p = pBlob = contextMalloc(pCtx, (nHex/2)+1);

+  if( pBlob ){

+    u8 c;                         /* Most significant digit of next byte */

+    u8 d;                         /* Least significant digit of next byte */

+

+    while( (c = *zHex)!=0x00 ){

+      while( !sqlite3Isxdigit(c) ){

+        u32 ch = Utf8Read(zHex);

+        assert( zHex<=zEnd );

+        if( !strContainsChar(zPass, nPass, ch) ) goto unhex_null;

+        c = *zHex;

+        if( c==0x00 ) goto unhex_done;

+      }

+      zHex++;

+      assert( *zEnd==0x00 );

+      assert( zHex<=zEnd );

+      d = *(zHex++);

+      if( !sqlite3Isxdigit(d) ) goto unhex_null;

+      *(p++) = (sqlite3HexToInt(c)<<4) | sqlite3HexToInt(d);

+    }

+  }

+

+ unhex_done:

+  sqlite3_result_blob(pCtx, pBlob, (p - pBlob), sqlite3_free);

+  return;

+

+ unhex_null:

+  sqlite3_free(pBlob);

+  return;

+}

+

+

+/*

 ** The zeroblob(N) function returns a zero-filled blob of size N bytes.

 */

 static void zeroblobFunc(

@@ -125415,6 +126250,9 @@ static void unknownFunc(
   sqlite3_value **argv

 ){

   /* no-op */

+  (void)context;

+  (void)argc;

+  (void)argv;

 }

 #endif /*SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION*/

 

@@ -126081,17 +126919,15 @@ static void logFunc(
     }

     ans = log(x)/b;

   }else{

-    ans = log(x);

     switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){

       case 1:

-        /* Convert from natural logarithm to log base 10 */

-        ans /= M_LN10;

+        ans = log10(x);

         break;

       case 2:

-        /* Convert from natural logarithm to log base 2 */

-        ans /= M_LN2;

+        ans = log2(x);

         break;

       default:

+        ans = log(x);

         break;

     }

   }

@@ -126160,6 +126996,7 @@ static void piFunc(
   sqlite3_value **argv

 ){

   assert( argc==0 );

+  (void)argv;

   sqlite3_result_double(context, M_PI);

 }

 

@@ -126260,6 +127097,8 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     FUNCTION(upper,              1, 0, 0, upperFunc        ),

     FUNCTION(lower,              1, 0, 0, lowerFunc        ),

     FUNCTION(hex,                1, 0, 0, hexFunc          ),

+    FUNCTION(unhex,              1, 0, 0, unhexFunc        ),

+    FUNCTION(unhex,              2, 0, 0, unhexFunc        ),

     INLINE_FUNC(ifnull,          2, INLINEFUNC_coalesce, 0 ),

     VFUNCTION(random,            0, 0, 0, randomFunc       ),

     VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),

@@ -129644,6 +130483,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
           case OE_Fail: {

             char *zMsg = sqlite3MPrintf(db, "%s.%s", pTab->zName,

                                         pCol->zCnName);

+            testcase( zMsg==0 && db->mallocFailed==0 );

             sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,

                               onError, iReg);

             sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);

@@ -131535,6 +132375,8 @@ struct sqlite3_api_routines {
   const char *(*db_name)(sqlite3*,int);

   /* Version 3.40.0 and later */

   int (*value_encoding)(sqlite3_value*);

+  /* Version 3.41.0 and later */

+  int (*is_interrupted)(sqlite3*);

 };

 

 /*

@@ -131861,6 +132703,8 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_db_name                sqlite3_api->db_name

 /* Version 3.40.0 and later */

 #define sqlite3_value_encoding         sqlite3_api->value_encoding

+/* Version 3.41.0 and later */

+#define sqlite3_is_interrupted         sqlite3_api->is_interrupted

 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */

 

 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)

@@ -132375,7 +133219,9 @@ static const sqlite3_api_routines sqlite3Apis = {
 #endif

   sqlite3_db_name,

   /* Version 3.40.0 and later */

-  sqlite3_value_encoding

+  sqlite3_value_encoding,

+  /* Version 3.41.0 and later */

+  sqlite3_is_interrupted

 };

 

 /* True if x is the directory separator character

@@ -135212,12 +136058,21 @@ SQLITE_PRIVATE void sqlite3Pragma(
         ** will also prepopulate the cursor column cache that is used

         ** by the OP_IsType code, so it is a required step.

         */

-        mxCol = pTab->nCol-1;

-        while( mxCol>=0

-            && ((pTab->aCol[mxCol].colFlags & COLFLAG_VIRTUAL)!=0

-                || pTab->iPKey==mxCol) ) mxCol--;

+        assert( !IsVirtual(pTab) );

+        if( HasRowid(pTab) ){

+          mxCol = -1;

+          for(j=0; j<pTab->nCol; j++){

+            if( (pTab->aCol[j].colFlags & COLFLAG_VIRTUAL)==0 ) mxCol++;

+          }

+          if( mxCol==pTab->iPKey ) mxCol--;

+        }else{

+          /* COLFLAG_VIRTUAL columns are not included in the WITHOUT ROWID

+          ** PK index column-count, so there is no need to account for them

+          ** in this case. */

+          mxCol = sqlite3PrimaryKeyIndex(pTab)->nColumn-1;

+        }

         if( mxCol>=0 ){

-          sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, mxCol, 3);

+          sqlite3VdbeAddOp3(v, OP_Column, iDataCur, mxCol, 3);

           sqlite3VdbeTypeofColumn(v, 3);

         }

 

@@ -135385,7 +136240,8 @@ SQLITE_PRIVATE void sqlite3Pragma(
         if( !isQuick ){ /* Omit the remaining tests for quick_check */

           /* Validate index entries for the current row */

           for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){

-            int jmp2, jmp3, jmp4, jmp5;

+            int jmp2, jmp3, jmp4, jmp5, label6;

+            int kk;

             int ckUniq = sqlite3VdbeMakeLabel(pParse);

             if( pPk==pIdx ) continue;

             r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,

@@ -135403,13 +136259,32 @@ SQLITE_PRIVATE void sqlite3Pragma(
             sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);

             jmp4 = integrityCheckResultRow(v);

             sqlite3VdbeJumpHere(v, jmp2);

+

+            /* Any indexed columns with non-BINARY collations must still hold

+            ** the exact same text value as the table. */

+            label6 = 0;

+            for(kk=0; kk<pIdx->nKeyCol; kk++){

+              if( pIdx->azColl[kk]==sqlite3StrBINARY ) continue;

+              if( label6==0 ) label6 = sqlite3VdbeMakeLabel(pParse);

+              sqlite3VdbeAddOp3(v, OP_Column, iIdxCur+j, kk, 3);

+              sqlite3VdbeAddOp3(v, OP_Ne, 3, label6, r1+kk); VdbeCoverage(v);

+            }

+            if( label6 ){

+              int jmp6 = sqlite3VdbeAddOp0(v, OP_Goto);

+              sqlite3VdbeResolveLabel(v, label6);

+              sqlite3VdbeLoadString(v, 3, "row ");

+              sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);

+              sqlite3VdbeLoadString(v, 4, " values differ from index ");

+              sqlite3VdbeGoto(v, jmp5-1);

+              sqlite3VdbeJumpHere(v, jmp6);

+            }

+

             /* For UNIQUE indexes, verify that only one entry exists with the

             ** current key.  The entry is unique if (1) any column is NULL

             ** or (2) the next entry has a different key */

             if( IsUniqueIndex(pIdx) ){

               int uniqOk = sqlite3VdbeMakeLabel(pParse);

               int jmp6;

-              int kk;

               for(kk=0; kk<pIdx->nKeyCol; kk++){

                 int iCol = pIdx->aiColumn[kk];

                 assert( iCol!=XN_ROWID && iCol<pTab->nCol );

@@ -136582,7 +137457,12 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
 #else

       encoding = SQLITE_UTF8;

 #endif

-      sqlite3SetTextEncoding(db, encoding);

+      if( db->nVdbeActive>0 && encoding!=ENC(db) ){

+        rc = SQLITE_LOCKED;

+        goto initone_error_out;

+      }else{

+        sqlite3SetTextEncoding(db, encoding);

+      }

     }else{

       /* If opening an attached database, the encoding much match ENC(db) */

       if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){

@@ -136796,8 +137676,8 @@ static void schemaIsValid(Parse *pParse){
     sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);

     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );

     if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){

+      if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA;

       sqlite3ResetOneSchema(db, iDb);

-      pParse->rc = SQLITE_SCHEMA;

     }

 

     /* Close the transaction, if one was opened. */

@@ -137408,6 +138288,10 @@ struct SortCtx {
   } aDefer[4];

 #endif

   struct RowLoadInfo *pDeferredRowLoad;  /* Deferred row loading info or NULL */

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+  int addrPush;         /* First instruction to push data into sorter */

+  int addrPushEnd;      /* Last instruction that pushes data into sorter */

+#endif

 };

 #define SORTFLAG_UseSorter  0x01   /* Use SorterOpen instead of OpenEphemeral */

 

@@ -138064,6 +138948,10 @@ static void pushOntoSorter(
   */

   assert( nData==1 || regData==regOrigData || regOrigData==0 );

 

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+  pSort->addrPush = sqlite3VdbeCurrentAddr(v);

+#endif

+

   if( nPrefixReg ){

     assert( nPrefixReg==nExpr+bSeq );

     regBase = regData - nPrefixReg;

@@ -138164,6 +139052,9 @@ static void pushOntoSorter(
     sqlite3VdbeChangeP2(v, iSkip,

          pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));

   }

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+  pSort->addrPushEnd = sqlite3VdbeCurrentAddr(v)-1;

+#endif

 }

 

 /*

@@ -138630,9 +139521,6 @@ static void selectInnerLoop(
       testcase( eDest==SRT_Fifo );

       testcase( eDest==SRT_DistFifo );

       sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);

-      if( pDest->zAffSdst ){

-        sqlite3VdbeChangeP4(v, -1, pDest->zAffSdst, nResultCol);

-      }

 #ifndef SQLITE_OMIT_CTE

       if( eDest==SRT_DistFifo ){

         /* If the destination is DistFifo, then cursor (iParm+1) is open

@@ -138990,6 +139878,16 @@ static void generateSortTail(
   int bSeq;                       /* True if sorter record includes seq. no. */

   int nRefKey = 0;

   struct ExprList_item *aOutEx = p->pEList->a;

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+  int addrExplain;                /* Address of OP_Explain instruction */

+#endif

+

+  ExplainQueryPlan2(addrExplain, (pParse, 0,

+        "USE TEMP B-TREE FOR %sORDER BY", pSort->nOBSat>0?"RIGHT PART OF ":"")

+  );

+  sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd);

+  sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush);

+

 

   assert( addrBreak<0 );

   if( pSort->labelBkOut ){

@@ -139102,6 +140000,7 @@ static void generateSortTail(
       VdbeComment((v, "%s", aOutEx[i].zEName));

     }

   }

+  sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);

   switch( eDest ){

     case SRT_Table:

     case SRT_EphemTab: {

@@ -139163,6 +140062,7 @@ static void generateSortTail(
   }else{

     sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);

   }

+  sqlite3VdbeScanStatusRange(v, addrExplain, sqlite3VdbeCurrentAddr(v)-1, -1);

   if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);

   sqlite3VdbeResolveLabel(v, addrBreak);

 }

@@ -139434,7 +140334,7 @@ SQLITE_PRIVATE void sqlite3GenerateColumnNames(
   if( pParse->colNamesSet ) return;

   /* Column names are determined by the left-most term of a compound select */

   while( pSelect->pPrior ) pSelect = pSelect->pPrior;

-  SELECTTRACE(1,pParse,pSelect,("generating column names\n"));

+  TREETRACE(0x80,pParse,pSelect,("generating column names\n"));

   pTabList = pSelect->pSrc;

   pEList = pSelect->pEList;

   assert( v!=0 );

@@ -139534,7 +140434,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
   *pnCol = nCol;

   *paCol = aCol;

 

-  for(i=0, pCol=aCol; i<nCol && !db->mallocFailed; i++, pCol++){

+  for(i=0, pCol=aCol; i<nCol && !pParse->nErr; i++, pCol++){

     struct ExprList_item *pX = &pEList->a[i];

     struct ExprList_item *pCollide;

     /* Get an appropriate name for the column

@@ -139584,7 +140484,10 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
         if( zName[j]==':' ) nName = j;

       }

       zName = sqlite3MPrintf(db, "%.*z:%u", nName, zName, ++cnt);

-      if( cnt>3 ) sqlite3_randomness(sizeof(cnt), &cnt);

+      sqlite3ProgressCheck(pParse);

+      if( cnt>3 ){

+        sqlite3_randomness(sizeof(cnt), &cnt);

+      }

     }

     pCol->zCnName = zName;

     pCol->hName = sqlite3StrIHash(zName);

@@ -139597,71 +140500,105 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
     }

   }

   sqlite3HashClear(&ht);

-  if( db->mallocFailed ){

+  if( pParse->nErr ){

     for(j=0; j<i; j++){

       sqlite3DbFree(db, aCol[j].zCnName);

     }

     sqlite3DbFree(db, aCol);

     *paCol = 0;

     *pnCol = 0;

-    return SQLITE_NOMEM_BKPT;

+    return pParse->rc;

   }

   return SQLITE_OK;

 }

 

 /*

-** Add type and collation information to a column list based on

-** a SELECT statement.

-**

-** The column list presumably came from selectColumnNamesFromExprList().

-** The column list has only names, not types or collations.  This

-** routine goes through and adds the types and collations.

+** pTab is a transient Table object that represents a subquery of some

+** kind (maybe a parenthesized subquery in the FROM clause of a larger

+** query, or a VIEW, or a CTE).  This routine computes type information

+** for that Table object based on the Select object that implements the

+** subquery.  For the purposes of this routine, "type infomation" means:

 **

-** This routine requires that all identifiers in the SELECT

-** statement be resolved.

+**    *   The datatype name, as it might appear in a CREATE TABLE statement

+**    *   Which collating sequence to use for the column

+**    *   The affinity of the column

 */

-SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(

-  Parse *pParse,        /* Parsing contexts */

-  Table *pTab,          /* Add column type information to this table */

-  Select *pSelect,      /* SELECT used to determine types and collations */

-  char aff              /* Default affinity for columns */

+SQLITE_PRIVATE void sqlite3SubqueryColumnTypes(

+  Parse *pParse,      /* Parsing contexts */

+  Table *pTab,        /* Add column type information to this table */

+  Select *pSelect,    /* SELECT used to determine types and collations */

+  char aff            /* Default affinity. */

 ){

   sqlite3 *db = pParse->db;

-  NameContext sNC;

   Column *pCol;

   CollSeq *pColl;

-  int i;

+  int i,j;

   Expr *p;

   struct ExprList_item *a;

+  NameContext sNC;

 

   assert( pSelect!=0 );

   assert( (pSelect->selFlags & SF_Resolved)!=0 );

-  assert( pTab->nCol==pSelect->pEList->nExpr || db->mallocFailed );

+  assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );

+  assert( aff==SQLITE_AFF_NONE || aff==SQLITE_AFF_BLOB );

   if( db->mallocFailed ) return;

+  while( pSelect->pPrior ) pSelect = pSelect->pPrior;

+  a = pSelect->pEList->a;

   memset(&sNC, 0, sizeof(sNC));

   sNC.pSrcList = pSelect->pSrc;

-  a = pSelect->pEList->a;

   for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){

     const char *zType;

-    i64 n, m;

+    i64 n;

     pTab->tabFlags |= (pCol->colFlags & COLFLAG_NOINSERT);

     p = a[i].pExpr;

-    zType = columnType(&sNC, p, 0, 0, 0);

     /* pCol->szEst = ... // Column size est for SELECT tables never used */

     pCol->affinity = sqlite3ExprAffinity(p);

-    if( zType ){

-      m = sqlite3Strlen30(zType);

-      n = sqlite3Strlen30(pCol->zCnName);

-      pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+m+2);

-      if( pCol->zCnName ){

-        memcpy(&pCol->zCnName[n+1], zType, m+1);

-        pCol->colFlags |= COLFLAG_HASTYPE;

+    if( pCol->affinity<=SQLITE_AFF_NONE ){

+      pCol->affinity = aff;

+    }else if( pCol->affinity>=SQLITE_AFF_NUMERIC && p->op==TK_CAST ){

+      pCol->affinity = SQLITE_AFF_FLEXNUM;

+    }

+    if( pCol->affinity>=SQLITE_AFF_TEXT && pSelect->pNext ){

+      int m = 0;

+      Select *pS2;

+      for(m=0, pS2=pSelect->pNext; pS2; pS2=pS2->pNext){

+        m |= sqlite3ExprDataType(pS2->pEList->a[i].pExpr);

+      }

+      if( pCol->affinity==SQLITE_AFF_TEXT && (m&0x01)!=0 ){

+        pCol->affinity = SQLITE_AFF_BLOB;

+      }else

+      if( pCol->affinity>=SQLITE_AFF_NUMERIC && (m&0x02)!=0 ){

+        pCol->affinity = SQLITE_AFF_BLOB;

+      }

+    }

+    zType = columnType(&sNC, p, 0, 0, 0);

+    if( zType==0 || pCol->affinity!=sqlite3AffinityType(zType, 0) ){

+      if( pCol->affinity==SQLITE_AFF_NUMERIC

+       || pCol->affinity==SQLITE_AFF_FLEXNUM

+      ){

+        zType = "NUM";

       }else{

-        testcase( pCol->colFlags & COLFLAG_HASTYPE );

+        zType = 0;

+        for(j=1; j<SQLITE_N_STDTYPE; j++){

+          if( sqlite3StdTypeAffinity[j]==pCol->affinity ){

+            zType = sqlite3StdType[j];

+            break;

+          }

+        }

+       }

+     }

+     if( zType ){

+       i64 m = sqlite3Strlen30(zType);

+       n = sqlite3Strlen30(pCol->zCnName);

+       pCol->zCnName = sqlite3DbReallocOrFree(db, pCol->zCnName, n+m+2);

+       if( pCol->zCnName ){

+         memcpy(&pCol->zCnName[n+1], zType, m+1);

+         pCol->colFlags |= COLFLAG_HASTYPE;

+       }else{

+         testcase( pCol->colFlags & COLFLAG_HASTYPE );

         pCol->colFlags &= ~(COLFLAG_HASTYPE|COLFLAG_HASCOLL);

       }

     }

-    if( pCol->affinity<=SQLITE_AFF_NONE ) pCol->affinity = aff;

     pColl = sqlite3ExprCollSeq(pParse, p);

     if( pColl ){

       assert( pTab->pIndex==0 );

@@ -139695,7 +140632,7 @@ SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, c
   pTab->zName = 0;

   pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );

   sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);

-  sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSelect, aff);

+  sqlite3SubqueryColumnTypes(pParse, pTab, pSelect, aff);

   pTab->iPKey = -1;

   if( db->mallocFailed ){

     sqlite3DeleteTable(db, pTab);

@@ -140220,7 +141157,7 @@ static int multiSelect(
         pPrior->iLimit = p->iLimit;

         pPrior->iOffset = p->iOffset;

         pPrior->pLimit = p->pLimit;

-        SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL left...\n"));

+        TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL left...\n"));

         rc = sqlite3Select(pParse, pPrior, &dest);

         pPrior->pLimit = 0;

         if( rc ){

@@ -140238,7 +141175,7 @@ static int multiSelect(
           }

         }

         ExplainQueryPlan((pParse, 1, "UNION ALL"));

-        SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL right...\n"));

+        TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL right...\n"));

         rc = sqlite3Select(pParse, p, &dest);

         testcase( rc!=SQLITE_OK );

         pDelete = p->pPrior;

@@ -140291,7 +141228,7 @@ static int multiSelect(
         */

         assert( !pPrior->pOrderBy );

         sqlite3SelectDestInit(&uniondest, priorOp, unionTab);

-        SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));

+        TREETRACE(0x200, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));

         rc = sqlite3Select(pParse, pPrior, &uniondest);

         if( rc ){

           goto multi_select_end;

@@ -140311,7 +141248,7 @@ static int multiSelect(
         uniondest.eDest = op;

         ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",

                           sqlite3SelectOpName(p->op)));

-        SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));

+        TREETRACE(0x200, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));

         rc = sqlite3Select(pParse, p, &uniondest);

         testcase( rc!=SQLITE_OK );

         assert( p->pOrderBy==0 );

@@ -140372,7 +141309,7 @@ static int multiSelect(
         /* Code the SELECTs to our left into temporary table "tab1".

         */

         sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);

-        SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT left...\n"));

+        TREETRACE(0x400, pParse, p, ("multiSelect INTERSECT left...\n"));

         rc = sqlite3Select(pParse, pPrior, &intersectdest);

         if( rc ){

           goto multi_select_end;

@@ -140389,7 +141326,7 @@ static int multiSelect(
         intersectdest.iSDParm = tab2;

         ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",

                           sqlite3SelectOpName(p->op)));

-        SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT right...\n"));

+        TREETRACE(0x400, pParse, p, ("multiSelect INTERSECT right...\n"));

         rc = sqlite3Select(pParse, p, &intersectdest);

         testcase( rc!=SQLITE_OK );

         pDelete = p->pPrior;

@@ -141393,6 +142330,34 @@ static ExprList *findLeftmostExprlist(Select *pSel){
   return pSel->pEList;

 }

 

+/*

+** Return true if any of the result-set columns in the compound query

+** have incompatible affinities on one or more arms of the compound.

+*/

+static int compoundHasDifferentAffinities(Select *p){

+  int ii;

+  ExprList *pList;

+  assert( p!=0 );

+  assert( p->pEList!=0 );

+  assert( p->pPrior!=0 );

+  pList = p->pEList;

+  for(ii=0; ii<pList->nExpr; ii++){

+    char aff;

+    Select *pSub1;

+    assert( pList->a[ii].pExpr!=0 );

+    aff = sqlite3ExprAffinity(pList->a[ii].pExpr);

+    for(pSub1=p->pPrior; pSub1; pSub1=pSub1->pPrior){

+      assert( pSub1->pEList!=0 );

+      assert( pSub1->pEList->nExpr>ii );

+      assert( pSub1->pEList->a[ii].pExpr!=0 );

+      if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){

+        return 1;

+      }

+    }

+  }

+  return 0;

+}

+

 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)

 /*

 ** This routine attempts to flatten subqueries as a performance optimization.

@@ -141496,7 +142461,8 @@ static ExprList *findLeftmostExprlist(Select *pSel){
 **              query or there are no RIGHT or FULL JOINs in any arm

 **              of the subquery.  (This is a duplicate of condition (27b).)

 **        (17h) The corresponding result set expressions in all arms of the

-**              compound must have the same affinity.

+**              compound must have the same affinity. (See restriction (9)

+**              on the push-down optimization.)

 **

 **        The parent and sub-query may contain WHERE clauses. Subject to

 **        rules (11), (13) and (14), they may also contain ORDER BY,

@@ -141715,19 +142681,7 @@ static int flattenSubquery(
     if( (p->selFlags & SF_Recursive) ) return 0;

 

     /* Restriction (17h) */

-    for(ii=0; ii<pSub->pEList->nExpr; ii++){

-      char aff;

-      assert( pSub->pEList->a[ii].pExpr!=0 );

-      aff = sqlite3ExprAffinity(pSub->pEList->a[ii].pExpr);

-      for(pSub1=pSub->pPrior; pSub1; pSub1=pSub1->pPrior){

-        assert( pSub1->pEList!=0 );

-        assert( pSub1->pEList->nExpr>ii );

-        assert( pSub1->pEList->a[ii].pExpr!=0 );

-        if( sqlite3ExprAffinity(pSub1->pEList->a[ii].pExpr)!=aff ){

-          return 0;

-        }

-      }

-    }

+    if( compoundHasDifferentAffinities(pSub) ) return 0;

 

     if( pSrc->nSrc>1 ){

       if( pParse->nSelect>500 ) return 0;

@@ -141738,7 +142692,7 @@ static int flattenSubquery(
   }

 

   /***** If we reach this point, flattening is permitted. *****/

-  SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",

+  TREETRACE(0x4,pParse,p,("flatten %u.%p from term %d\n",

                    pSub->selId, pSub, iFrom));

 

   /* Authorize the subquery */

@@ -141817,7 +142771,7 @@ static int flattenSubquery(
       if( pPrior ) pPrior->pNext = pNew;

       pNew->pNext = p;

       p->pPrior = pNew;

-      SELECTTRACE(2,pParse,p,("compound-subquery flattener"

+      TREETRACE(0x4,pParse,p,("compound-subquery flattener"

                               " creates %u as peer\n",pNew->selId));

     }

     assert( pSubitem->pSelect==0 );

@@ -141997,8 +142951,8 @@ static int flattenSubquery(
   sqlite3SelectDelete(db, pSub1);

 

 #if TREETRACE_ENABLED

-  if( sqlite3TreeTrace & 0x100 ){

-    SELECTTRACE(0x100,pParse,p,("After flattening:\n"));

+  if( sqlite3TreeTrace & 0x4 ){

+    TREETRACE(0x4,pParse,p,("After flattening:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -142372,12 +143326,14 @@ static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
 **       be materialized.  (This restriction is implemented in the calling

 **       routine.)

 **

-**   (8) The subquery may not be a compound that uses UNION, INTERSECT,

-**       or EXCEPT.  (We could, perhaps, relax this restriction to allow

-**       this case if none of the comparisons operators between left and

-**       right arms of the compound use a collation other than BINARY.

-**       But it is a lot of work to check that case for an obscure and

-**       minor optimization, so we omit it for now.)

+**   (8) If the subquery is a compound that uses UNION, INTERSECT,

+**       or EXCEPT, then all of the result set columns for all arms of

+**       the compound must use the BINARY collating sequence.

+**

+**   (9) If the subquery is a compound, then all arms of the compound must

+**       have the same affinity.  (This is the same as restriction (17h)

+**       for query flattening.)

+**

 **

 ** Return 0 if no changes are made and non-zero if one or more WHERE clause

 ** terms are duplicated into the subquery.

@@ -142394,20 +143350,44 @@ static int pushDownWhereTerms(
   if( pSubq->selFlags & (SF_Recursive|SF_MultiPart) ) return 0;

   if( pSrc->fg.jointype & (JT_LTORJ|JT_RIGHT) ) return 0;

 

-#ifndef SQLITE_OMIT_WINDOWFUNC

   if( pSubq->pPrior ){

     Select *pSel;

+    int notUnionAll = 0;

     for(pSel=pSubq; pSel; pSel=pSel->pPrior){

       u8 op = pSel->op;

       assert( op==TK_ALL || op==TK_SELECT

            || op==TK_UNION || op==TK_INTERSECT || op==TK_EXCEPT );

-      if( op!=TK_ALL && op!=TK_SELECT ) return 0;  /* restriction (8) */

+      if( op!=TK_ALL && op!=TK_SELECT ){

+        notUnionAll = 1;

+      }

+#ifndef SQLITE_OMIT_WINDOWFUNC

       if( pSel->pWin ) return 0;    /* restriction (6b) */

+#endif

+    }

+    if( compoundHasDifferentAffinities(pSubq) ){

+      return 0;  /* restriction (9) */

+    }

+    if( notUnionAll ){

+      /* If any of the compound arms are connected using UNION, INTERSECT,

+      ** or EXCEPT, then we must ensure that none of the columns use a

+      ** non-BINARY collating sequence. */

+      for(pSel=pSubq; pSel; pSel=pSel->pPrior){

+        int ii;

+        const ExprList *pList = pSel->pEList;

+        assert( pList!=0 );

+        for(ii=0; ii<pList->nExpr; ii++){

+          CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);

+          if( !sqlite3IsBinary(pColl) ){

+            return 0;  /* Restriction (8) */

+          }

+        }

+      }

     }

   }else{

+#ifndef SQLITE_OMIT_WINDOWFUNC

     if( pSubq->pWin && pSubq->pWin->pPartition==0 ) return 0;

-  }

 #endif

+  }

 

 #ifdef SQLITE_DEBUG

   /* Only the first term of a compound can have a WITH clause.  But make

@@ -142869,9 +143849,6 @@ static int resolveFromTermToCte(
     pFrom->fg.isCte = 1;

     pFrom->u2.pCteUse = pCteUse;

     pCteUse->nUse++;

-    if( pCteUse->nUse>=2 && pCteUse->eM10d==M10d_Any ){

-      pCteUse->eM10d = M10d_Yes;

-    }

 

     /* Check if this is a recursive CTE. */

     pRecTerm = pSel = pFrom->pSelect;

@@ -143411,8 +144388,8 @@ static int selectExpander(Walker *pWalker, Select *p){
     }

   }

 #if TREETRACE_ENABLED

-  if( sqlite3TreeTrace & 0x100 ){

-    SELECTTRACE(0x100,pParse,p,("After result-set wildcard expansion:\n"));

+  if( sqlite3TreeTrace & 0x8 ){

+    TREETRACE(0x8,pParse,p,("After result-set wildcard expansion:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -143463,14 +144440,14 @@ static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
 ** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()

 ** interface.

 **

-** For each FROM-clause subquery, add Column.zType and Column.zColl

-** information to the Table structure that represents the result set

-** of that subquery.

+** For each FROM-clause subquery, add Column.zType, Column.zColl, and

+** Column.affinity information to the Table structure that represents

+** the result set of that subquery.

 **

 ** The Table structure that represents the result set was constructed

-** by selectExpander() but the type and collation information was omitted

-** at that point because identifiers had not yet been resolved.  This

-** routine is called after identifier resolution.

+** by selectExpander() but the type and collation and affinity information

+** was omitted at that point because identifiers had not yet been resolved.

+** This routine is called after identifier resolution.

 */

 static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){

   Parse *pParse;

@@ -143490,9 +144467,7 @@ static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
       /* A sub-query in the FROM clause of a SELECT */

       Select *pSel = pFrom->pSelect;

       if( pSel ){

-        while( pSel->pPrior ) pSel = pSel->pPrior;

-        sqlite3SelectAddColumnTypeAndCollation(pParse, pTab, pSel,

-                                               SQLITE_AFF_NONE);

+        sqlite3SubqueryColumnTypes(pParse, pTab, pSel, SQLITE_AFF_NONE);

       }

     }

   }

@@ -143547,6 +144522,173 @@ SQLITE_PRIVATE void sqlite3SelectPrep(
   sqlite3SelectAddTypeInfo(pParse, p);

 }

 

+#if TREETRACE_ENABLED

+/*

+** Display all information about an AggInfo object

+*/

+static void printAggInfo(AggInfo *pAggInfo){

+  int ii;

+  for(ii=0; ii<pAggInfo->nColumn; ii++){

+    struct AggInfo_col *pCol = &pAggInfo->aCol[ii];

+    sqlite3DebugPrintf(

+       "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d"

+       " iSorterColumn=%d %s\n",

+       ii, pCol->pTab ? pCol->pTab->zName : "NULL",

+       pCol->iTable, pCol->iColumn, pAggInfo->iFirstReg+ii,

+       pCol->iSorterColumn,

+       ii>=pAggInfo->nAccumulator ? "" : " Accumulator");

+    sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0);

+  }

+  for(ii=0; ii<pAggInfo->nFunc; ii++){

+    sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",

+        ii, pAggInfo->iFirstReg+pAggInfo->nColumn+ii);

+    sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0);

+  }

+}

+#endif /* TREETRACE_ENABLED */

+

+/*

+** Analyze the arguments to aggregate functions.  Create new pAggInfo->aCol[]

+** entries for columns that are arguments to aggregate functions but which

+** are not otherwise used.

+**

+** The aCol[] entries in AggInfo prior to nAccumulator are columns that

+** are referenced outside of aggregate functions.  These might be columns

+** that are part of the GROUP by clause, for example.  Other database engines

+** would throw an error if there is a column reference that is not in the

+** GROUP BY clause and that is not part of an aggregate function argument.

+** But SQLite allows this.

+**

+** The aCol[] entries beginning with the aCol[nAccumulator] and following

+** are column references that are used exclusively as arguments to

+** aggregate functions.  This routine is responsible for computing

+** (or recomputing) those aCol[] entries.

+*/

+static void analyzeAggFuncArgs(

+  AggInfo *pAggInfo,

+  NameContext *pNC

+){

+  int i;

+  assert( pAggInfo!=0 );

+  assert( pAggInfo->iFirstReg==0 );

+  pNC->ncFlags |= NC_InAggFunc;

+  for(i=0; i<pAggInfo->nFunc; i++){

+    Expr *pExpr = pAggInfo->aFunc[i].pFExpr;

+    assert( ExprUseXList(pExpr) );

+    sqlite3ExprAnalyzeAggList(pNC, pExpr->x.pList);

+#ifndef SQLITE_OMIT_WINDOWFUNC

+    assert( !IsWindowFunc(pExpr) );

+    if( ExprHasProperty(pExpr, EP_WinFunc) ){

+      sqlite3ExprAnalyzeAggregates(pNC, pExpr->y.pWin->pFilter);

+    }

+#endif

+  }

+  pNC->ncFlags &= ~NC_InAggFunc;

+}

+

+/*

+** An index on expressions is being used in the inner loop of an

+** aggregate query with a GROUP BY clause.  This routine attempts

+** to adjust the AggInfo object to take advantage of index and to

+** perhaps use the index as a covering index.

+**

+*/

+static void optimizeAggregateUseOfIndexedExpr(

+  Parse *pParse,          /* Parsing context */

+  Select *pSelect,        /* The SELECT statement being processed */

+  AggInfo *pAggInfo,      /* The aggregate info */

+  NameContext *pNC        /* Name context used to resolve agg-func args */

+){

+  assert( pAggInfo->iFirstReg==0 );

+  pAggInfo->nColumn = pAggInfo->nAccumulator;

+  if( ALWAYS(pAggInfo->nSortingColumn>0) ){

+    if( pAggInfo->nColumn==0 ){

+      pAggInfo->nSortingColumn = 0;

+    }else{

+      pAggInfo->nSortingColumn =

+        pAggInfo->aCol[pAggInfo->nColumn-1].iSorterColumn+1;

+    }

+  }

+  analyzeAggFuncArgs(pAggInfo, pNC);

+#if TREETRACE_ENABLED

+  if( sqlite3TreeTrace & 0x20 ){

+    IndexedExpr *pIEpr;

+    TREETRACE(0x20, pParse, pSelect,

+        ("AggInfo (possibly) adjusted for Indexed Exprs\n"));

+    sqlite3TreeViewSelect(0, pSelect, 0);

+    for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){

+      printf("data-cursor=%d index={%d,%d}\n",

+          pIEpr->iDataCur, pIEpr->iIdxCur, pIEpr->iIdxCol);

+      sqlite3TreeViewExpr(0, pIEpr->pExpr, 0);

+    }

+    printAggInfo(pAggInfo);

+  }

+#else

+  UNUSED_PARAMETER(pSelect);

+  UNUSED_PARAMETER(pParse);

+#endif

+}

+

+/*

+** Walker callback for aggregateConvertIndexedExprRefToColumn().

+*/

+static int aggregateIdxEprRefToColCallback(Walker *pWalker, Expr *pExpr){

+  AggInfo *pAggInfo;

+  struct AggInfo_col *pCol;

+  UNUSED_PARAMETER(pWalker);

+  if( pExpr->pAggInfo==0 ) return WRC_Continue;

+  if( pExpr->op==TK_AGG_COLUMN ) return WRC_Continue;

+  if( pExpr->op==TK_AGG_FUNCTION ) return WRC_Continue;

+  if( pExpr->op==TK_IF_NULL_ROW ) return WRC_Continue;

+  pAggInfo = pExpr->pAggInfo;

+  assert( pExpr->iAgg>=0 && pExpr->iAgg<pAggInfo->nColumn );

+  pCol = &pAggInfo->aCol[pExpr->iAgg];

+  pExpr->op = TK_AGG_COLUMN;

+  pExpr->iTable = pCol->iTable;

+  pExpr->iColumn = pCol->iColumn;

+  return WRC_Prune;

+}

+

+/*

+** Convert every pAggInfo->aFunc[].pExpr such that any node within

+** those expressions that has pAppInfo set is changed into a TK_AGG_COLUMN

+** opcode.

+*/

+static void aggregateConvertIndexedExprRefToColumn(AggInfo *pAggInfo){

+  int i;

+  Walker w;

+  memset(&w, 0, sizeof(w));

+  w.xExprCallback = aggregateIdxEprRefToColCallback;

+  for(i=0; i<pAggInfo->nFunc; i++){

+    sqlite3WalkExpr(&w, pAggInfo->aFunc[i].pFExpr);

+  }

+}

+

+

+/*

+** Allocate a block of registers so that there is one register for each

+** pAggInfo->aCol[] and pAggInfo->aFunc[] entry in pAggInfo.  The first

+** register in this block is stored in pAggInfo->iFirstReg.

+**

+** This routine may only be called once for each AggInfo object.  Prior

+** to calling this routine:

+**

+**     *  The aCol[] and aFunc[] arrays may be modified

+**     *  The AggInfoColumnReg() and AggInfoFuncReg() macros may not be used

+**

+** After clling this routine:

+**

+**     *  The aCol[] and aFunc[] arrays are fixed

+**     *  The AggInfoColumnReg() and AggInfoFuncReg() macros may be used

+**

+*/

+static void assignAggregateRegisters(Parse *pParse, AggInfo *pAggInfo){

+  assert( pAggInfo!=0 );

+  assert( pAggInfo->iFirstReg==0 );

+  pAggInfo->iFirstReg = pParse->nMem + 1;

+  pParse->nMem += pAggInfo->nColumn + pAggInfo->nFunc;

+}

+

 /*

 ** Reset the aggregate accumulator.

 **

@@ -143560,24 +144702,13 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
   int i;

   struct AggInfo_func *pFunc;

   int nReg = pAggInfo->nFunc + pAggInfo->nColumn;

+  assert( pAggInfo->iFirstReg>0 );

   assert( pParse->db->pParse==pParse );

   assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );

   if( nReg==0 ) return;

   if( pParse->nErr ) return;

-#ifdef SQLITE_DEBUG

-  /* Verify that all AggInfo registers are within the range specified by

-  ** AggInfo.mnReg..AggInfo.mxReg */

-  assert( nReg==pAggInfo->mxReg-pAggInfo->mnReg+1 );

-  for(i=0; i<pAggInfo->nColumn; i++){

-    assert( pAggInfo->aCol[i].iMem>=pAggInfo->mnReg

-         && pAggInfo->aCol[i].iMem<=pAggInfo->mxReg );

-  }

-  for(i=0; i<pAggInfo->nFunc; i++){

-    assert( pAggInfo->aFunc[i].iMem>=pAggInfo->mnReg

-         && pAggInfo->aFunc[i].iMem<=pAggInfo->mxReg );

-  }

-#endif

-  sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->mnReg, pAggInfo->mxReg);

+  sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->iFirstReg,

+                    pAggInfo->iFirstReg+nReg-1);

   for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){

     if( pFunc->iDistinct>=0 ){

       Expr *pE = pFunc->pFExpr;

@@ -143609,15 +144740,16 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
     ExprList *pList;

     assert( ExprUseXList(pF->pFExpr) );

     pList = pF->pFExpr->x.pList;

-    sqlite3VdbeAddOp2(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0);

+    sqlite3VdbeAddOp2(v, OP_AggFinal, AggInfoFuncReg(pAggInfo,i),

+                      pList ? pList->nExpr : 0);

     sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);

   }

 }

 

 

 /*

-** Update the accumulator memory cells for an aggregate based on

-** the current cursor position.

+** Generate code that will update the accumulator memory cells for an

+** aggregate based on the current cursor position.

 **

 ** If regAcc is non-zero and there are no min() or max() aggregates

 ** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator

@@ -143637,6 +144769,8 @@ static void updateAccumulator(
   struct AggInfo_func *pF;

   struct AggInfo_col *pC;

 

+  assert( pAggInfo->iFirstReg>0 );

+  if( pParse->nErr ) return;

   pAggInfo->directMode = 1;

   for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){

     int nArg;

@@ -143697,7 +144831,7 @@ static void updateAccumulator(
       if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;

       sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);

     }

-    sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem);

+    sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i));

     sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);

     sqlite3VdbeChangeP5(v, (u8)nArg);

     sqlite3ReleaseTempRange(pParse, regAgg, nArg);

@@ -143712,7 +144846,7 @@ static void updateAccumulator(
     addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);

   }

   for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){

-    sqlite3ExprCode(pParse, pC->pCExpr, pC->iMem);

+    sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i));

   }

 

   pAggInfo->directMode = 0;

@@ -143808,26 +144942,31 @@ static void havingToWhere(Parse *pParse, Select *p){
   sqlite3WalkExpr(&sWalker, p->pHaving);

 #if TREETRACE_ENABLED

   if( sWalker.eCode && (sqlite3TreeTrace & 0x100)!=0 ){

-    SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));

+    TREETRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

 }

 

 /*

-** Check to see if the pThis entry of pTabList is a self-join of a prior view.

-** If it is, then return the SrcItem for the prior view.  If it is not,

-** then return 0.

+** Check to see if the pThis entry of pTabList is a self-join of another view.

+** Search FROM-clause entries in the range of iFirst..iEnd, including iFirst

+** but stopping before iEnd.

+**

+** If pThis is a self-join, then return the SrcItem for the first other

+** instance of that view found.  If pThis is not a self-join then return 0.

 */

 static SrcItem *isSelfJoinView(

   SrcList *pTabList,           /* Search for self-joins in this FROM clause */

-  SrcItem *pThis               /* Search for prior reference to this subquery */

+  SrcItem *pThis,              /* Search for prior reference to this subquery */

+  int iFirst, int iEnd        /* Range of FROM-clause entries to search. */

 ){

   SrcItem *pItem;

   assert( pThis->pSelect!=0 );

   if( pThis->pSelect->selFlags & SF_PushDown ) return 0;

-  for(pItem = pTabList->a; pItem<pThis; pItem++){

+  while( iFirst<iEnd ){

     Select *pS1;

+    pItem = &pTabList->a[iFirst++];

     if( pItem->pSelect==0 ) continue;

     if( pItem->fg.viaCoroutine ) continue;

     if( pItem->zName==0 ) continue;

@@ -143896,6 +145035,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   assert( ExprUseXList(pExpr) );

   if( pExpr->x.pList!=0 ) return 0;                 /* Must be count(*) */

   if( p->pSrc->nSrc!=1 ) return 0;                  /* One table in FROM  */

+  if( ExprHasProperty(pExpr, EP_WinFunc) ) return 0;/* Not a window function */

   pSub = p->pSrc->a[0].pSelect;

   if( pSub==0 ) return 0;                           /* The FROM is a subquery */

   if( pSub->pPrior==0 ) return 0;                   /* Must be a compound ry */

@@ -143940,8 +145080,8 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   p->selFlags &= ~SF_Aggregate;

 

 #if TREETRACE_ENABLED

-  if( sqlite3TreeTrace & 0x400 ){

-    SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));

+  if( sqlite3TreeTrace & 0x200 ){

+    TREETRACE(0x200,pParse,p,("After count-of-view optimization:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -143973,6 +145113,68 @@ static int sameSrcAlias(SrcItem *p0, SrcList *pSrc){
 }

 

 /*

+** Return TRUE (non-zero) if the i-th entry in the pTabList SrcList can

+** be implemented as a co-routine.  The i-th entry is guaranteed to be

+** a subquery.

+**

+** The subquery is implemented as a co-routine if all of the following are

+** true:

+**

+**    (1)  The subquery will likely be implemented in the outer loop of

+**         the query.  This will be the case if any one of the following

+**         conditions hold:

+**         (a)  The subquery is the only term in the FROM clause

+**         (b)  The subquery is the left-most term and a CROSS JOIN or similar

+**              requires it to be the outer loop

+**         (c)  All of the following are true:

+**                (i) The subquery is the left-most subquery in the FROM clause

+**               (ii) There is nothing that would prevent the subquery from

+**                    being used as the outer loop if the sqlite3WhereBegin()

+**                    routine nominates it to that position.

+**              (iii) The query is not a UPDATE ... FROM

+**    (2)  The subquery is not a CTE that should be materialized because

+**         (a) the AS MATERIALIZED keyword is used, or

+**         (b) the CTE is used multiple times and does not have the

+**             NOT MATERIALIZED keyword

+**    (3)  The subquery is not part of a left operand for a RIGHT JOIN

+**    (4)  The SQLITE_Coroutine optimization disable flag is not set

+**    (5)  The subquery is not self-joined

+*/

+static int fromClauseTermCanBeCoroutine(

+  Parse *pParse,          /* Parsing context */

+  SrcList *pTabList,      /* FROM clause */

+  int i,                  /* Which term of the FROM clause holds the subquery */

+  int selFlags            /* Flags on the SELECT statement */

+){

+  SrcItem *pItem = &pTabList->a[i];

+  if( pItem->fg.isCte ){

+    const CteUse *pCteUse = pItem->u2.pCteUse;

+    if( pCteUse->eM10d==M10d_Yes ) return 0;                          /* (2a) */

+    if( pCteUse->nUse>=2 && pCteUse->eM10d!=M10d_No ) return 0;       /* (2b) */

+  }

+  if( pTabList->a[0].fg.jointype & JT_LTORJ ) return 0;               /* (3)  */

+  if( OptimizationDisabled(pParse->db, SQLITE_Coroutines) ) return 0; /* (4)  */

+  if( isSelfJoinView(pTabList, pItem, i+1, pTabList->nSrc)!=0 ){

+    return 0;                                                          /* (5) */

+  }

+  if( i==0 ){

+    if( pTabList->nSrc==1 ) return 1;                             /* (1a) */

+    if( pTabList->a[1].fg.jointype & JT_CROSS ) return 1;         /* (1b) */

+    if( selFlags & SF_UpdateFrom )              return 0;         /* (1c-iii) */

+    return 1;

+  }

+  if( selFlags & SF_UpdateFrom ) return 0;                        /* (1c-iii) */

+  while( 1 /*exit-by-break*/ ){

+    if( pItem->fg.jointype & (JT_OUTER|JT_CROSS)  ) return 0;     /* (1c-ii) */

+    if( i==0 ) break;

+    i--;

+    pItem--;

+    if( pItem->pSelect!=0 ) return 0;                             /* (1c-i) */

+  }

+  return 1;

+}

+

+/*

 ** Generate code for the SELECT statement given in the p argument.

 **

 ** The results are returned according to the SelectDest structure.

@@ -144017,8 +145219,8 @@ SQLITE_PRIVATE int sqlite3Select(
   assert( db->mallocFailed==0 );

   if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;

 #if TREETRACE_ENABLED

-  SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));

-  if( sqlite3TreeTrace & 0x10100 ){

+  TREETRACE(0x1,pParse,p, ("begin processing:\n", pParse->addrExplain));

+  if( sqlite3TreeTrace & 0x10000 ){

     if( (sqlite3TreeTrace & 0x10001)==0x10000 ){

       sqlite3TreeViewLine(0, "In sqlite3Select() at %s:%d",

                            __FILE__, __LINE__);

@@ -144038,8 +145240,8 @@ SQLITE_PRIVATE int sqlite3Select(
     /* All of these destinations are also able to ignore the ORDER BY clause */

     if( p->pOrderBy ){

 #if TREETRACE_ENABLED

-      SELECTTRACE(1,pParse,p, ("dropping superfluous ORDER BY:\n"));

-      if( sqlite3TreeTrace & 0x100 ){

+      TREETRACE(0x800,pParse,p, ("dropping superfluous ORDER BY:\n"));

+      if( sqlite3TreeTrace & 0x800 ){

         sqlite3TreeViewExprList(0, p->pOrderBy, 0, "ORDERBY");

       }

 #endif

@@ -144059,8 +145261,8 @@ SQLITE_PRIVATE int sqlite3Select(
   assert( db->mallocFailed==0 );

   assert( p->pEList!=0 );

 #if TREETRACE_ENABLED

-  if( sqlite3TreeTrace & 0x104 ){

-    SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));

+  if( sqlite3TreeTrace & 0x10 ){

+    TREETRACE(0x10,pParse,p, ("after name resolution:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -144101,8 +145303,8 @@ SQLITE_PRIVATE int sqlite3Select(
     goto select_end;

   }

 #if TREETRACE_ENABLED

-  if( p->pWin && (sqlite3TreeTrace & 0x108)!=0 ){

-    SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));

+  if( p->pWin && (sqlite3TreeTrace & 0x40)!=0 ){

+    TREETRACE(0x40,pParse,p, ("after window rewrite:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -144133,7 +145335,7 @@ SQLITE_PRIVATE int sqlite3Select(
      && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor)

      && OptimizationEnabled(db, SQLITE_SimplifyJoin)

     ){

-      SELECTTRACE(0x100,pParse,p,

+      TREETRACE(0x1000,pParse,p,

                 ("LEFT-JOIN simplifies to JOIN on term %d\n",i));

       pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);

       assert( pItem->iCursor>=0 );

@@ -144189,7 +145391,7 @@ SQLITE_PRIVATE int sqlite3Select(
      && (p->selFlags & SF_OrderByReqd)==0         /* Condition (3) and (4) */

      && OptimizationEnabled(db, SQLITE_OmitOrderBy)

     ){

-      SELECTTRACE(0x100,pParse,p,

+      TREETRACE(0x800,pParse,p,

                 ("omit superfluous ORDER BY on %r FROM-clause subquery\n",i+1));

       sqlite3ParserAddCleanup(pParse,

          (void(*)(sqlite3*,void*))sqlite3ExprListDelete,

@@ -144244,8 +145446,8 @@ SQLITE_PRIVATE int sqlite3Select(
   if( p->pPrior ){

     rc = multiSelect(pParse, p, pDest);

 #if TREETRACE_ENABLED

-    SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));

-    if( (sqlite3TreeTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){

+    TREETRACE(0x400,pParse,p,("end compound-select processing\n"));

+    if( (sqlite3TreeTrace & 0x400)!=0 && ExplainQueryPlanParent(pParse)==0 ){

       sqlite3TreeViewSelect(0, p, 0);

     }

 #endif

@@ -144265,13 +145467,13 @@ SQLITE_PRIVATE int sqlite3Select(
    && propagateConstants(pParse, p)

   ){

 #if TREETRACE_ENABLED

-    if( sqlite3TreeTrace & 0x100 ){

-      SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));

+    if( sqlite3TreeTrace & 0x2000 ){

+      TREETRACE(0x2000,pParse,p,("After constant propagation:\n"));

       sqlite3TreeViewSelect(0, p, 0);

     }

 #endif

   }else{

-    SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));

+    TREETRACE(0x2000,pParse,p,("Constant propagation not helpful\n"));

   }

 

 #ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION

@@ -144344,36 +145546,23 @@ SQLITE_PRIVATE int sqlite3Select(
      && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem)

     ){

 #if TREETRACE_ENABLED

-      if( sqlite3TreeTrace & 0x100 ){

-        SELECTTRACE(0x100,pParse,p,

+      if( sqlite3TreeTrace & 0x4000 ){

+        TREETRACE(0x4000,pParse,p,

             ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));

         sqlite3TreeViewSelect(0, p, 0);

       }

 #endif

       assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );

     }else{

-      SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));

+      TREETRACE(0x4000,pParse,p,("Push-down not possible\n"));

     }

 

     zSavedAuthContext = pParse->zAuthContext;

     pParse->zAuthContext = pItem->zName;

 

     /* Generate code to implement the subquery

-    **

-    ** The subquery is implemented as a co-routine if all of the following are

-    ** true:

-    **

-    **    (1)  the subquery is guaranteed to be the outer loop (so that

-    **         it does not need to be computed more than once), and

-    **    (2)  the subquery is not a CTE that should be materialized

-    **    (3)  the subquery is not part of a left operand for a RIGHT JOIN

     */

-    if( i==0

-     && (pTabList->nSrc==1

-            || (pTabList->a[1].fg.jointype&(JT_OUTER|JT_CROSS))!=0)  /* (1) */

-     && (pItem->fg.isCte==0 || pItem->u2.pCteUse->eM10d!=M10d_Yes)   /* (2) */

-     && (pTabList->a[0].fg.jointype & JT_LTORJ)==0                   /* (3) */

-    ){

+    if( fromClauseTermCanBeCoroutine(pParse, pTabList, i, p->selFlags) ){

       /* Implement a co-routine that will return a single row of the result

       ** set on each invocation.

       */

@@ -144404,7 +145593,7 @@ SQLITE_PRIVATE int sqlite3Select(
         VdbeComment((v, "%!S", pItem));

       }

       pSub->nSelectRow = pCteUse->nRowEst;

-    }else if( (pPrior = isSelfJoinView(pTabList, pItem))!=0 ){

+    }else if( (pPrior = isSelfJoinView(pTabList, pItem, 0, i))!=0 ){

       /* This view has already been materialized by a prior entry in

       ** this same FROM clause.  Reuse it. */

       if( pPrior->addrFillSub ){

@@ -144418,6 +145607,9 @@ SQLITE_PRIVATE int sqlite3Select(
       ** the same view can reuse the materialization. */

       int topAddr;

       int onceAddr = 0;

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+      int addrExplain;

+#endif

 

       pItem->regReturn = ++pParse->nMem;

       topAddr = sqlite3VdbeAddOp0(v, OP_Goto);

@@ -144433,15 +145625,14 @@ SQLITE_PRIVATE int sqlite3Select(
         VdbeNoopComment((v, "materialize %!S", pItem));

       }

       sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);

-      ExplainQueryPlan((pParse, 1, "MATERIALIZE %!S", pItem));

-      dest.zAffSdst = sqlite3TableAffinityStr(db, pItem->pTab);

+

+      ExplainQueryPlan2(addrExplain, (pParse, 1, "MATERIALIZE %!S", pItem));

       sqlite3Select(pParse, pSub, &dest);

-      sqlite3DbFree(db, dest.zAffSdst);

-      dest.zAffSdst = 0;

       pItem->pTab->nRowLogEst = pSub->nSelectRow;

       if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);

       sqlite3VdbeAddOp2(v, OP_Return, pItem->regReturn, topAddr+1);

       VdbeComment((v, "end %!S", pItem));

+      sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);

       sqlite3VdbeJumpHere(v, topAddr);

       sqlite3ClearTempRegCache(pParse);

       if( pItem->fg.isCte && pItem->fg.isCorrelated==0 ){

@@ -144467,8 +145658,8 @@ SQLITE_PRIVATE int sqlite3Select(
   sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;

 

 #if TREETRACE_ENABLED

-  if( sqlite3TreeTrace & 0x400 ){

-    SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));

+  if( sqlite3TreeTrace & 0x8000 ){

+    TREETRACE(0x8000,pParse,p,("After all FROM-clause analysis:\n"));

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -144504,8 +145695,8 @@ SQLITE_PRIVATE int sqlite3Select(
     sDistinct.isTnct = 2;

 

 #if TREETRACE_ENABLED

-    if( sqlite3TreeTrace & 0x400 ){

-      SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));

+    if( sqlite3TreeTrace & 0x20000 ){

+      TREETRACE(0x20000,pParse,p,("Transform DISTINCT into GROUP BY:\n"));

       sqlite3TreeViewSelect(0, p, 0);

     }

 #endif

@@ -144591,7 +145782,7 @@ SQLITE_PRIVATE int sqlite3Select(
 

 

     /* Begin the database scan. */

-    SELECTTRACE(1,pParse,p,("WhereBegin\n"));

+    TREETRACE(0x2,pParse,p,("WhereBegin\n"));

     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,

                                p->pEList, p, wctrlFlags, p->nSelectRow);

     if( pWInfo==0 ) goto select_end;

@@ -144608,7 +145799,7 @@ SQLITE_PRIVATE int sqlite3Select(
         sSort.pOrderBy = 0;

       }

     }

-    SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));

+    TREETRACE(0x2,pParse,p,("WhereBegin returns\n"));

 

     /* If sorting index that was created by a prior OP_OpenEphemeral

     ** instruction ended up not being needed, then change the OP_OpenEphemeral

@@ -144647,7 +145838,7 @@ SQLITE_PRIVATE int sqlite3Select(
 

       /* End the database scan loop.

       */

-      SELECTTRACE(1,pParse,p,("WhereEnd\n"));

+      TREETRACE(0x2,pParse,p,("WhereEnd\n"));

       sqlite3WhereEnd(pWInfo);

     }

   }else{

@@ -144728,12 +145919,14 @@ SQLITE_PRIVATE int sqlite3Select(
       goto select_end;

     }

     pAggInfo->selId = p->selId;

+#ifdef SQLITE_DEBUG

+    pAggInfo->pSelect = p;

+#endif

     memset(&sNC, 0, sizeof(sNC));

     sNC.pParse = pParse;

     sNC.pSrcList = pTabList;

     sNC.uNC.pAggInfo = pAggInfo;

     VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )

-    pAggInfo->mnReg = pParse->nMem+1;

     pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;

     pAggInfo->pGroupBy = pGroupBy;

     sqlite3ExprAnalyzeAggList(&sNC, pEList);

@@ -144754,45 +145947,17 @@ SQLITE_PRIVATE int sqlite3Select(
     }else{

       minMaxFlag = WHERE_ORDERBY_NORMAL;

     }

-    for(i=0; i<pAggInfo->nFunc; i++){

-      Expr *pExpr = pAggInfo->aFunc[i].pFExpr;

-      assert( ExprUseXList(pExpr) );

-      sNC.ncFlags |= NC_InAggFunc;

-      sqlite3ExprAnalyzeAggList(&sNC, pExpr->x.pList);

-#ifndef SQLITE_OMIT_WINDOWFUNC

-      assert( !IsWindowFunc(pExpr) );

-      if( ExprHasProperty(pExpr, EP_WinFunc) ){

-        sqlite3ExprAnalyzeAggregates(&sNC, pExpr->y.pWin->pFilter);

-      }

-#endif

-      sNC.ncFlags &= ~NC_InAggFunc;

-    }

-    pAggInfo->mxReg = pParse->nMem;

+    analyzeAggFuncArgs(pAggInfo, &sNC);

     if( db->mallocFailed ) goto select_end;

 #if TREETRACE_ENABLED

-    if( sqlite3TreeTrace & 0x400 ){

-      int ii;

-      SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo));

+    if( sqlite3TreeTrace & 0x20 ){

+      TREETRACE(0x20,pParse,p,("After aggregate analysis %p:\n", pAggInfo));

       sqlite3TreeViewSelect(0, p, 0);

       if( minMaxFlag ){

         sqlite3DebugPrintf("MIN/MAX Optimization (0x%02x) adds:\n", minMaxFlag);

         sqlite3TreeViewExprList(0, pMinMaxOrderBy, 0, "ORDERBY");

       }

-      for(ii=0; ii<pAggInfo->nColumn; ii++){

-        struct AggInfo_col *pCol = &pAggInfo->aCol[ii];

-        sqlite3DebugPrintf(

-           "agg-column[%d] pTab=%s iTable=%d iColumn=%d iMem=%d"

-           " iSorterColumn=%d\n",

-           ii, pCol->pTab ? pCol->pTab->zName : "NULL",

-           pCol->iTable, pCol->iColumn, pCol->iMem,

-           pCol->iSorterColumn);

-        sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0);

-      }

-      for(ii=0; ii<pAggInfo->nFunc; ii++){

-        sqlite3DebugPrintf("agg-func[%d]: iMem=%d\n",

-            ii, pAggInfo->aFunc[ii].iMem);

-        sqlite3TreeViewExpr(0, pAggInfo->aFunc[ii].pFExpr, 0);

-      }

+      printAggInfo(pAggInfo);

     }

 #endif

 

@@ -144861,7 +146026,7 @@ SQLITE_PRIVATE int sqlite3Select(
       ** in the right order to begin with.

       */

       sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);

-      SELECTTRACE(1,pParse,p,("WhereBegin\n"));

+      TREETRACE(0x2,pParse,p,("WhereBegin\n"));

       pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct,

           p, (sDistinct.isTnct==2 ? WHERE_DISTINCTBY : WHERE_GROUPBY)

           |  (orderByGrp ? WHERE_SORTBYGROUP : 0) | distFlag, 0

@@ -144870,8 +146035,12 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3ExprListDelete(db, pDistinct);

         goto select_end;

       }

+      if( pParse->pIdxEpr ){

+        optimizeAggregateUseOfIndexedExpr(pParse, p, pAggInfo, &sNC);

+      }

+      assignAggregateRegisters(pParse, pAggInfo);

       eDist = sqlite3WhereIsDistinct(pWInfo);

-      SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));

+      TREETRACE(0x2,pParse,p,("WhereBegin returns\n"));

       if( sqlite3WhereIsOrdered(pWInfo)==pGroupBy->nExpr ){

         /* The optimizer is able to deliver rows in group by order so

         ** we do not have to sort.  The OP_OpenEphemeral table will be

@@ -144920,7 +146089,7 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);

         sqlite3ReleaseTempReg(pParse, regRecord);

         sqlite3ReleaseTempRange(pParse, regBase, nCol);

-        SELECTTRACE(1,pParse,p,("WhereEnd\n"));

+        TREETRACE(0x2,pParse,p,("WhereEnd\n"));

         sqlite3WhereEnd(pWInfo);

         pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;

         sortOut = sqlite3GetTempReg(pParse);

@@ -144930,6 +146099,23 @@ SQLITE_PRIVATE int sqlite3Select(
         pAggInfo->useSortingIdx = 1;

       }

 

+      /* If there are entries in pAgggInfo->aFunc[] that contain subexpressions

+      ** that are indexed (and that were previously identified and tagged

+      ** in optimizeAggregateUseOfIndexedExpr()) then those subexpressions

+      ** must now be converted into a TK_AGG_COLUMN node so that the value

+      ** is correctly pulled from the index rather than being recomputed. */

+      if( pParse->pIdxEpr ){

+        aggregateConvertIndexedExprRefToColumn(pAggInfo);

+#if TREETRACE_ENABLED

+        if( sqlite3TreeTrace & 0x20 ){

+          TREETRACE(0x20, pParse, p,

+             ("AggInfo function expressions converted to reference index\n"));

+          sqlite3TreeViewSelect(0, p, 0);

+          printAggInfo(pAggInfo);

+        }

+#endif

+      }

+

       /* If the index or temporary table used by the GROUP BY sort

       ** will naturally deliver rows in the order required by the ORDER BY

       ** clause, cancel the ephemeral table open coded earlier.

@@ -144998,7 +146184,7 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);

         VdbeCoverage(v);

       }else{

-        SELECTTRACE(1,pParse,p,("WhereEnd\n"));

+        TREETRACE(0x2,pParse,p,("WhereEnd\n"));

         sqlite3WhereEnd(pWInfo);

         sqlite3VdbeChangeToNoop(v, addrSortingIdx);

       }

@@ -145108,7 +146294,8 @@ SQLITE_PRIVATE int sqlite3Select(
         if( pKeyInfo ){

           sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);

         }

-        sqlite3VdbeAddOp2(v, OP_Count, iCsr, pAggInfo->aFunc[0].iMem);

+        assignAggregateRegisters(pParse, pAggInfo);

+        sqlite3VdbeAddOp2(v, OP_Count, iCsr, AggInfoFuncReg(pAggInfo,0));

         sqlite3VdbeAddOp1(v, OP_Close, iCsr);

         explainSimpleCount(pParse, pTab, pBest);

       }else{

@@ -145144,6 +146331,7 @@ SQLITE_PRIVATE int sqlite3Select(
           pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList;

           distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0;

         }

+        assignAggregateRegisters(pParse, pAggInfo);

 

         /* This case runs if the aggregate has no GROUP BY clause.  The

         ** processing is much simpler since there is only a single row

@@ -145160,13 +146348,13 @@ SQLITE_PRIVATE int sqlite3Select(
         assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );

         assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );

 

-        SELECTTRACE(1,pParse,p,("WhereBegin\n"));

+        TREETRACE(0x2,pParse,p,("WhereBegin\n"));

         pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,

                                    pDistinct, p, minMaxFlag|distFlag, 0);

         if( pWInfo==0 ){

           goto select_end;

         }

-        SELECTTRACE(1,pParse,p,("WhereBegin returns\n"));

+        TREETRACE(0x2,pParse,p,("WhereBegin returns\n"));

         eDist = sqlite3WhereIsDistinct(pWInfo);

         updateAccumulator(pParse, regAcc, pAggInfo, eDist);

         if( eDist!=WHERE_DISTINCT_NOOP ){

@@ -145180,7 +146368,7 @@ SQLITE_PRIVATE int sqlite3Select(
         if( minMaxFlag ){

           sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);

         }

-        SELECTTRACE(1,pParse,p,("WhereEnd\n"));

+        TREETRACE(0x2,pParse,p,("WhereEnd\n"));

         sqlite3WhereEnd(pWInfo);

         finalizeAggFunctions(pParse, pAggInfo);

       }

@@ -145202,8 +146390,6 @@ SQLITE_PRIVATE int sqlite3Select(
   ** and send them to the callback one by one.

   */

   if( sSort.pOrderBy ){

-    explainTempTable(pParse,

-                     sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");

     assert( p->pEList==pEList );

     generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);

   }

@@ -145227,7 +146413,7 @@ select_end:
   if( pAggInfo && !db->mallocFailed ){

     for(i=0; i<pAggInfo->nColumn; i++){

       Expr *pExpr = pAggInfo->aCol[i].pCExpr;

-      assert( pExpr!=0 );

+      if( pExpr==0 ) continue;

       assert( pExpr->pAggInfo==pAggInfo );

       assert( pExpr->iAgg==i );

     }

@@ -145241,8 +146427,8 @@ select_end:
 #endif

 

 #if TREETRACE_ENABLED

-  SELECTTRACE(0x1,pParse,p,("end processing\n"));

-  if( (sqlite3TreeTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){

+  TREETRACE(0x1,pParse,p,("end processing\n"));

+  if( (sqlite3TreeTrace & 0x40000)!=0 && ExplainQueryPlanParent(pParse)==0 ){

     sqlite3TreeViewSelect(0, p, 0);

   }

 #endif

@@ -147196,7 +148382,8 @@ static void updateFromSelect(
     }

   }

   pSelect = sqlite3SelectNew(pParse, pList,

-      pSrc, pWhere2, pGrp, 0, pOrderBy2, SF_UFSrcCheck|SF_IncludeHidden, pLimit2

+      pSrc, pWhere2, pGrp, 0, pOrderBy2,

+      SF_UFSrcCheck|SF_IncludeHidden|SF_UpdateFrom, pLimit2

   );

   if( pSelect ) pSelect->selFlags |= SF_OrderByReqd;

   sqlite3SelectDestInit(&dest, eDest, iEph);

@@ -149230,10 +150417,10 @@ SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
   pVTab->nRef--;

   if( pVTab->nRef==0 ){

     sqlite3_vtab *p = pVTab->pVtab;

-    sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod);

     if( p ){

       p->pModule->xDisconnect(p);

     }

+    sqlite3VtabModuleUnref(pVTab->db, pVTab->pMod);

     sqlite3DbFree(db, pVTab);

   }

 }

@@ -151023,6 +152210,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*);
 #define WHERE_SELFCULL     0x00800000  /* nOut reduced by extra WHERE terms */

 #define WHERE_OMIT_OFFSET  0x01000000  /* Set offset counter to zero */

 #define WHERE_VIEWSCAN     0x02000000  /* A full-scan of a VIEW or subquery */

+#define WHERE_EXPRIDX      0x04000000  /* Uses an index-on-expressions */

 

 #endif /* !defined(SQLITE_WHEREINT_H) */

 

@@ -151279,6 +152467,8 @@ SQLITE_PRIVATE int sqlite3WhereExplainBloomFilter(
   zMsg = sqlite3StrAccumFinish(&str);

   ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),

                           pParse->addrExplain, 0, zMsg,P4_DYNAMIC);

+

+  sqlite3VdbeScanStatus(v, sqlite3VdbeCurrentAddr(v)-1, 0, 0, 0, 0);

   return ret;

 }

 #endif /* SQLITE_OMIT_EXPLAIN */

@@ -151301,14 +152491,27 @@ SQLITE_PRIVATE void sqlite3WhereAddScanStatus(
 ){

   const char *zObj = 0;

   WhereLoop *pLoop = pLvl->pWLoop;

-  if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0  &&  pLoop->u.btree.pIndex!=0 ){

+  int wsFlags = pLoop->wsFlags;

+  int viaCoroutine = 0;

+

+  if( (wsFlags & WHERE_VIRTUALTABLE)==0  &&  pLoop->u.btree.pIndex!=0 ){

     zObj = pLoop->u.btree.pIndex->zName;

   }else{

     zObj = pSrclist->a[pLvl->iFrom].zName;

+    viaCoroutine = pSrclist->a[pLvl->iFrom].fg.viaCoroutine;

   }

   sqlite3VdbeScanStatus(

       v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj

   );

+

+  if( viaCoroutine==0 ){

+    if( (wsFlags & (WHERE_MULTI_OR|WHERE_AUTO_INDEX))==0 ){

+      sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iTabCur);

+    }

+    if( wsFlags & WHERE_INDEXED ){

+      sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur);

+    }

+  }

 }

 #endif

 

@@ -151368,7 +152571,7 @@ static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
       pTerm->wtFlags |= TERM_CODED;

     }

 #ifdef WHERETRACE_ENABLED

-    if( sqlite3WhereTrace & 0x20000 ){

+    if( (sqlite3WhereTrace & 0x4001)==0x4001 ){

       sqlite3DebugPrintf("DISABLE-");

       sqlite3WhereTermPrint(pTerm, (int)(pTerm - (pTerm->pWC->a)));

     }

@@ -151483,68 +152686,75 @@ static Expr *removeUnindexableInClauseTerms(
   Expr *pX              /* The IN expression to be reduced */

 ){

   sqlite3 *db = pParse->db;

+  Select *pSelect;            /* Pointer to the SELECT on the RHS */

   Expr *pNew;

   pNew = sqlite3ExprDup(db, pX, 0);

   if( db->mallocFailed==0 ){

-    ExprList *pOrigRhs;         /* Original unmodified RHS */

-    ExprList *pOrigLhs;         /* Original unmodified LHS */

-    ExprList *pRhs = 0;         /* New RHS after modifications */

-    ExprList *pLhs = 0;         /* New LHS after mods */

-    int i;                      /* Loop counter */

-    Select *pSelect;            /* Pointer to the SELECT on the RHS */

-

-    assert( ExprUseXSelect(pNew) );

-    pOrigRhs = pNew->x.pSelect->pEList;

-    assert( pNew->pLeft!=0 );

-    assert( ExprUseXList(pNew->pLeft) );

-    pOrigLhs = pNew->pLeft->x.pList;

-    for(i=iEq; i<pLoop->nLTerm; i++){

-      if( pLoop->aLTerm[i]->pExpr==pX ){

-        int iField;

-        assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 );

-        iField = pLoop->aLTerm[i]->u.x.iField - 1;

-        if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */

-        pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);

-        pOrigRhs->a[iField].pExpr = 0;

-        assert( pOrigLhs->a[iField].pExpr!=0 );

-        pLhs = sqlite3ExprListAppend(pParse, pLhs, pOrigLhs->a[iField].pExpr);

-        pOrigLhs->a[iField].pExpr = 0;

-      }

-    }

-    sqlite3ExprListDelete(db, pOrigRhs);

-    sqlite3ExprListDelete(db, pOrigLhs);

-    pNew->pLeft->x.pList = pLhs;

-    pNew->x.pSelect->pEList = pRhs;

-    if( pLhs && pLhs->nExpr==1 ){

-      /* Take care here not to generate a TK_VECTOR containing only a

-      ** single value. Since the parser never creates such a vector, some

-      ** of the subroutines do not handle this case.  */

-      Expr *p = pLhs->a[0].pExpr;

-      pLhs->a[0].pExpr = 0;

-      sqlite3ExprDelete(db, pNew->pLeft);

-      pNew->pLeft = p;

-    }

-    pSelect = pNew->x.pSelect;

-    if( pSelect->pOrderBy ){

-      /* If the SELECT statement has an ORDER BY clause, zero the

-      ** iOrderByCol variables. These are set to non-zero when an

-      ** ORDER BY term exactly matches one of the terms of the

-      ** result-set. Since the result-set of the SELECT statement may

-      ** have been modified or reordered, these variables are no longer

-      ** set correctly.  Since setting them is just an optimization,

-      ** it's easiest just to zero them here.  */

-      ExprList *pOrderBy = pSelect->pOrderBy;

-      for(i=0; i<pOrderBy->nExpr; i++){

-        pOrderBy->a[i].u.x.iOrderByCol = 0;

+    for(pSelect=pNew->x.pSelect; pSelect; pSelect=pSelect->pPrior){

+      ExprList *pOrigRhs;         /* Original unmodified RHS */

+      ExprList *pOrigLhs = 0;     /* Original unmodified LHS */

+      ExprList *pRhs = 0;         /* New RHS after modifications */

+      ExprList *pLhs = 0;         /* New LHS after mods */

+      int i;                      /* Loop counter */

+

+      assert( ExprUseXSelect(pNew) );

+      pOrigRhs = pSelect->pEList;

+      assert( pNew->pLeft!=0 );

+      assert( ExprUseXList(pNew->pLeft) );

+      if( pSelect==pNew->x.pSelect ){

+        pOrigLhs = pNew->pLeft->x.pList;

+      }

+      for(i=iEq; i<pLoop->nLTerm; i++){

+        if( pLoop->aLTerm[i]->pExpr==pX ){

+          int iField;

+          assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 );

+          iField = pLoop->aLTerm[i]->u.x.iField - 1;

+          if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */

+          pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);

+          pOrigRhs->a[iField].pExpr = 0;

+          if( pOrigLhs ){

+            assert( pOrigLhs->a[iField].pExpr!=0 );

+            pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);

+            pOrigLhs->a[iField].pExpr = 0;

+          }

+        }

+      }

+      sqlite3ExprListDelete(db, pOrigRhs);

+      if( pOrigLhs ){

+        sqlite3ExprListDelete(db, pOrigLhs);

+        pNew->pLeft->x.pList = pLhs;

+      }

+      pSelect->pEList = pRhs;

+      if( pLhs && pLhs->nExpr==1 ){

+        /* Take care here not to generate a TK_VECTOR containing only a

+        ** single value. Since the parser never creates such a vector, some

+        ** of the subroutines do not handle this case.  */

+        Expr *p = pLhs->a[0].pExpr;

+        pLhs->a[0].pExpr = 0;

+        sqlite3ExprDelete(db, pNew->pLeft);

+        pNew->pLeft = p;

+      }

+      if( pSelect->pOrderBy ){

+        /* If the SELECT statement has an ORDER BY clause, zero the

+        ** iOrderByCol variables. These are set to non-zero when an

+        ** ORDER BY term exactly matches one of the terms of the

+        ** result-set. Since the result-set of the SELECT statement may

+        ** have been modified or reordered, these variables are no longer

+        ** set correctly.  Since setting them is just an optimization,

+        ** it's easiest just to zero them here.  */

+        ExprList *pOrderBy = pSelect->pOrderBy;

+        for(i=0; i<pOrderBy->nExpr; i++){

+          pOrderBy->a[i].u.x.iOrderByCol = 0;

+        }

       }

-    }

 

 #if 0

-    printf("For indexing, change the IN expr:\n");

-    sqlite3TreeViewExpr(0, pX, 0);

-    printf("Into:\n");

-    sqlite3TreeViewExpr(0, pNew, 0);

+      printf("For indexing, change the IN expr:\n");

+      sqlite3TreeViewExpr(0, pX, 0);

+      printf("Into:\n");

+      sqlite3TreeViewExpr(0, pNew, 0);

 #endif

+    }

   }

   return pNew;

 }

@@ -152355,13 +153565,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
   pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur);

   bRev = (pWInfo->revMask>>iLevel)&1;

   VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));

-#if WHERETRACE_ENABLED /* 0x20800 */

-  if( sqlite3WhereTrace & 0x800 ){

+#if WHERETRACE_ENABLED /* 0x4001 */

+  if( sqlite3WhereTrace & 0x1 ){

     sqlite3DebugPrintf("Coding level %d of %d:  notReady=%llx  iFrom=%d\n",

        iLevel, pWInfo->nLevel, (u64)notReady, pLevel->iFrom);

-    sqlite3WhereLoopPrint(pLoop, pWC);

+    if( sqlite3WhereTrace & 0x1000 ){

+      sqlite3WhereLoopPrint(pLoop, pWC);

+    }

   }

-  if( sqlite3WhereTrace & 0x20000 ){

+  if( (sqlite3WhereTrace & 0x4001)==0x4001 ){

     if( iLevel==0 ){

       sqlite3DebugPrintf("WHERE clause being coded:\n");

       sqlite3TreeViewExpr(0, pWInfo->pWhere, 0);

@@ -153285,7 +154497,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         }

         /* Loop through table entries that match term pOrTerm. */

         ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1));

-        WHERETRACE(0xffff, ("Subplan for OR-clause:\n"));

+        WHERETRACE(0xffffffff, ("Subplan for OR-clause:\n"));

         pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, 0,

                                       WHERE_OR_SUBCLAUSE, iCovCur);

         assert( pSubWInfo || pParse->nErr );

@@ -153522,12 +154734,12 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         }

 #endif

       }

-#ifdef WHERETRACE_ENABLED /* 0xffff */

+#ifdef WHERETRACE_ENABLED /* 0xffffffff */

       if( sqlite3WhereTrace ){

         VdbeNoopComment((v, "WhereTerm[%d] (%p) priority=%d",

                          pWC->nTerm-j, pTerm, iLoop));

       }

-      if( sqlite3WhereTrace & 0x800 ){

+      if( sqlite3WhereTrace & 0x4000 ){

         sqlite3DebugPrintf("Coding auxiliary constraint:\n");

         sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);

       }

@@ -153556,8 +154768,8 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     if( pTerm->leftCursor!=iCur ) continue;

     if( pTabItem->fg.jointype & (JT_LEFT|JT_LTORJ|JT_RIGHT) ) continue;

     pE = pTerm->pExpr;

-#ifdef WHERETRACE_ENABLED /* 0x800 */

-    if( sqlite3WhereTrace & 0x800 ){

+#ifdef WHERETRACE_ENABLED /* 0x4001 */

+    if( (sqlite3WhereTrace & 0x4001)==0x4001 ){

       sqlite3DebugPrintf("Coding transitive constraint:\n");

       sqlite3WhereTermPrint(pTerm, pWC->nTerm-j);

     }

@@ -153672,13 +154884,13 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     }

   }

 

-#if WHERETRACE_ENABLED /* 0x20800 */

-  if( sqlite3WhereTrace & 0x20000 ){

+#if WHERETRACE_ENABLED /* 0x4001 */

+  if( sqlite3WhereTrace & 0x4000 ){

     sqlite3DebugPrintf("All WHERE-clause terms after coding level %d:\n",

                        iLevel);

     sqlite3WhereClausePrint(pWC);

   }

-  if( sqlite3WhereTrace & 0x800 ){

+  if( sqlite3WhereTrace & 0x1 ){

     sqlite3DebugPrintf("End Coding level %d:  notReady=%llx\n",

        iLevel, (u64)pLevel->notReady);

   }

@@ -154754,36 +155966,40 @@ static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){
 */

 static SQLITE_NOINLINE int exprMightBeIndexed2(

   SrcList *pFrom,        /* The FROM clause */

-  Bitmask mPrereq,       /* Bitmask of FROM clause terms referenced by pExpr */

   int *aiCurCol,         /* Write the referenced table cursor and column here */

-  Expr *pExpr            /* An operand of a comparison operator */

+  Expr *pExpr,           /* An operand of a comparison operator */

+  int j                  /* Start looking with the j-th pFrom entry */

 ){

   Index *pIdx;

   int i;

   int iCur;

-  for(i=0; mPrereq>1; i++, mPrereq>>=1){}

-  iCur = pFrom->a[i].iCursor;

-  for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){

-    if( pIdx->aColExpr==0 ) continue;

-    for(i=0; i<pIdx->nKeyCol; i++){

-      if( pIdx->aiColumn[i]!=XN_EXPR ) continue;

-      assert( pIdx->bHasExpr );

-      if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){

-        aiCurCol[0] = iCur;

-        aiCurCol[1] = XN_EXPR;

-        return 1;

+  do{

+    iCur = pFrom->a[j].iCursor;

+    for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){

+      if( pIdx->aColExpr==0 ) continue;

+      for(i=0; i<pIdx->nKeyCol; i++){

+        if( pIdx->aiColumn[i]!=XN_EXPR ) continue;

+        assert( pIdx->bHasExpr );

+        if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0

+          && pExpr->op!=TK_STRING

+        ){

+          aiCurCol[0] = iCur;

+          aiCurCol[1] = XN_EXPR;

+          return 1;

+        }

       }

     }

-  }

+  }while( ++j < pFrom->nSrc );

   return 0;

 }

 static int exprMightBeIndexed(

   SrcList *pFrom,        /* The FROM clause */

-  Bitmask mPrereq,       /* Bitmask of FROM clause terms referenced by pExpr */

   int *aiCurCol,         /* Write the referenced table cursor & column here */

   Expr *pExpr,           /* An operand of a comparison operator */

   int op                 /* The specific comparison operator */

 ){

+  int i;

+

   /* If this expression is a vector to the left or right of a

   ** inequality constraint (>, <, >= or <=), perform the processing

   ** on the first element of the vector.  */

@@ -154793,7 +156009,6 @@ static int exprMightBeIndexed(
   if( pExpr->op==TK_VECTOR && (op>=TK_GT && ALWAYS(op<=TK_GE)) ){

     assert( ExprUseXList(pExpr) );

     pExpr = pExpr->x.pList->a[0].pExpr;

-

   }

 

   if( pExpr->op==TK_COLUMN ){

@@ -154801,9 +156016,16 @@ static int exprMightBeIndexed(
     aiCurCol[1] = pExpr->iColumn;

     return 1;

   }

-  if( mPrereq==0 ) return 0;                 /* No table references */

-  if( (mPrereq&(mPrereq-1))!=0 ) return 0;   /* Refs more than one table */

-  return exprMightBeIndexed2(pFrom,mPrereq,aiCurCol,pExpr);

+

+  for(i=0; i<pFrom->nSrc; i++){

+    Index *pIdx;

+    for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){

+      if( pIdx->aColExpr ){

+        return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);

+      }

+    }

+  }

+  return 0;

 }

 

 

@@ -154929,7 +156151,7 @@ static void exprAnalyze(
       pLeft = pLeft->x.pList->a[pTerm->u.x.iField-1].pExpr;

     }

 

-    if( exprMightBeIndexed(pSrc, prereqLeft, aiCurCol, pLeft, op) ){

+    if( exprMightBeIndexed(pSrc, aiCurCol, pLeft, op) ){

       pTerm->leftCursor = aiCurCol[0];

       assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );

       pTerm->u.x.leftColumn = aiCurCol[1];

@@ -154937,7 +156159,7 @@ static void exprAnalyze(
     }

     if( op==TK_IS ) pTerm->wtFlags |= TERM_IS;

     if( pRight

-     && exprMightBeIndexed(pSrc, pTerm->prereqRight, aiCurCol, pRight, op)

+     && exprMightBeIndexed(pSrc, aiCurCol, pRight, op)

      && !ExprHasProperty(pRight, EP_FixedCol)

     ){

       WhereTerm *pNew;

@@ -155148,7 +156370,6 @@ static void exprAnalyze(
     transferJoinMarkings(pNewExpr1, pExpr);

     idxNew1 = whereClauseInsert(pWC, pNewExpr1, wtFlags);

     testcase( idxNew1==0 );

-    exprAnalyze(pSrc, pWC, idxNew1);

     pNewExpr2 = sqlite3ExprDup(db, pLeft, 0);

     pNewExpr2 = sqlite3PExpr(pParse, TK_LT,

            sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName),

@@ -155156,6 +156377,7 @@ static void exprAnalyze(
     transferJoinMarkings(pNewExpr2, pExpr);

     idxNew2 = whereClauseInsert(pWC, pNewExpr2, wtFlags);

     testcase( idxNew2==0 );

+    exprAnalyze(pSrc, pWC, idxNew1);

     exprAnalyze(pSrc, pWC, idxNew2);

     pTerm = &pWC->a[idxTerm];

     if( isComplete ){

@@ -155212,7 +156434,7 @@ static void exprAnalyze(
    && pTerm->u.x.iField==0

    && pExpr->pLeft->op==TK_VECTOR

    && ALWAYS( ExprUseXSelect(pExpr) )

-   && pExpr->x.pSelect->pPrior==0

+   && (pExpr->x.pSelect->pPrior==0 || (pExpr->x.pSelect->selFlags & SF_Values))

 #ifndef SQLITE_OMIT_WINDOWFUNC

    && pExpr->x.pSelect->pWin==0

 #endif

@@ -155400,6 +156622,13 @@ SQLITE_PRIVATE void SQLITE_NOINLINE sqlite3WhereAddLimit(WhereClause *pWC, Selec
         assert( pWC->a[ii].eOperator==WO_ROWVAL );

         continue;

       }

+      if( pWC->a[ii].nChild ){

+        /* If this term has child terms, then they are also part of the

+        ** pWC->a[] array. So this term can be ignored, as a LIMIT clause

+        ** will only be added if each of the child terms passes the

+        ** (leftCursor==iCsr) test below.  */

+        continue;

+      }

       if( pWC->a[ii].leftCursor!=iCsr ) return;

     }

 

@@ -156338,7 +157567,7 @@ static void translateColumnToCopy(
 #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED)

 static void whereTraceIndexInfoInputs(sqlite3_index_info *p){

   int i;

-  if( !sqlite3WhereTrace ) return;

+  if( (sqlite3WhereTrace & 0x10)==0 ) return;

   for(i=0; i<p->nConstraint; i++){

     sqlite3DebugPrintf(

        "  constraint[%d]: col=%d termid=%d op=%d usabled=%d collseq=%s\n",

@@ -156358,7 +157587,7 @@ static void whereTraceIndexInfoInputs(sqlite3_index_info *p){
 }

 static void whereTraceIndexInfoOutputs(sqlite3_index_info *p){

   int i;

-  if( !sqlite3WhereTrace ) return;

+  if( (sqlite3WhereTrace & 0x10)==0 ) return;

   for(i=0; i<p->nConstraint; i++){

     sqlite3DebugPrintf("  usage[%d]: argvIdx=%d omit=%d\n",

        i,

@@ -156445,6 +157674,57 @@ static int termCanDriveIndex(
 

 

 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX

+

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+/*

+** Argument pIdx represents an automatic index that the current statement

+** will create and populate. Add an OP_Explain with text of the form:

+**

+**     CREATE AUTOMATIC INDEX ON <table>(<cols>) [WHERE <expr>]

+**

+** This is only required if sqlite3_stmt_scanstatus() is enabled, to

+** associate an SQLITE_SCANSTAT_NCYCLE and SQLITE_SCANSTAT_NLOOP

+** values with. In order to avoid breaking legacy code and test cases,

+** the OP_Explain is not added if this is an EXPLAIN QUERY PLAN command.

+*/

+static void explainAutomaticIndex(

+  Parse *pParse,

+  Index *pIdx,                    /* Automatic index to explain */

+  int bPartial,                   /* True if pIdx is a partial index */

+  int *pAddrExplain               /* OUT: Address of OP_Explain */

+){

+  if( pParse->explain!=2 ){

+    Table *pTab = pIdx->pTable;

+    const char *zSep = "";

+    char *zText = 0;

+    int ii = 0;

+    sqlite3_str *pStr = sqlite3_str_new(pParse->db);

+    sqlite3_str_appendf(pStr,"CREATE AUTOMATIC INDEX ON %s(", pTab->zName);

+    assert( pIdx->nColumn>1 );

+    assert( pIdx->aiColumn[pIdx->nColumn-1]==XN_ROWID );

+    for(ii=0; ii<(pIdx->nColumn-1); ii++){

+      const char *zName = 0;

+      int iCol = pIdx->aiColumn[ii];

+

+      zName = pTab->aCol[iCol].zCnName;

+      sqlite3_str_appendf(pStr, "%s%s", zSep, zName);

+      zSep = ", ";

+    }

+    zText = sqlite3_str_finish(pStr);

+    if( zText==0 ){

+      sqlite3OomFault(pParse->db);

+    }else{

+      *pAddrExplain = sqlite3VdbeExplain(

+          pParse, 0, "%s)%s", zText, (bPartial ? " WHERE <expr>" : "")

+      );

+      sqlite3_free(zText);

+    }

+  }

+}

+#else

+# define explainAutomaticIndex(a,b,c,d)

+#endif

+

 /*

 ** Generate code to construct the Index object for an automatic index

 ** and to set up the WhereLevel object pLevel so that the code generator

@@ -156480,6 +157760,9 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
   SrcItem *pTabItem;          /* FROM clause term being indexed */

   int addrCounter = 0;        /* Address where integer counter is initialized */

   int regBase;                /* Array of registers where record is assembled */

+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS

+  int addrExp = 0;            /* Address of OP_Explain */

+#endif

 

   /* Generate code to skip over the creation and initialization of the

   ** transient index on 2nd and subsequent iterations of the loop. */

@@ -156603,6 +157886,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
   pIdx->azColl[n] = sqlite3StrBINARY;

 

   /* Create the automatic index */

+  explainAutomaticIndex(pParse, pIdx, pPartial!=0, &addrExp);

   assert( pLevel->iIdxCur>=0 );

   pLevel->iIdxCur = pParse->nTab++;

   sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1);

@@ -156638,6 +157922,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
     sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0,

                          regBase, pLoop->u.btree.nEq);

   }

+  sqlite3VdbeScanStatusCounters(v, addrExp, addrExp, sqlite3VdbeCurrentAddr(v));

   sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);

   sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);

   if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue);

@@ -156658,6 +157943,7 @@ static SQLITE_NOINLINE void constructAutomaticIndex(
 

   /* Jump here when skipping the initialization */

   sqlite3VdbeJumpHere(v, addrInit);

+  sqlite3VdbeScanStatusRange(v, addrExp, addrExp, -1);

 

 end_auto_index_create:

   sqlite3ExprDelete(pParse->db, pPartial);

@@ -157197,12 +158483,12 @@ static int whereKeyStats(
       if( iCol>0 ){

         pRec->nField = iCol;

         assert( sqlite3VdbeRecordCompare(aSample[i].n, aSample[i].p, pRec)<=0

-             || pParse->db->mallocFailed );

+             || pParse->db->mallocFailed || CORRUPT_DB );

       }

       if( i>0 ){

         pRec->nField = nField;

         assert( sqlite3VdbeRecordCompare(aSample[i-1].n, aSample[i-1].p, pRec)<0

-             || pParse->db->mallocFailed );

+             || pParse->db->mallocFailed || CORRUPT_DB );

       }

     }

   }

@@ -157375,7 +158661,7 @@ static int whereRangeSkipScanEst(
       int nAdjust = (sqlite3LogEst(p->nSample) - sqlite3LogEst(nDiff));

       pLoop->nOut -= nAdjust;

       *pbDone = 1;

-      WHERETRACE(0x10, ("range skip-scan regions: %u..%u  adjust=%d est=%d\n",

+      WHERETRACE(0x20, ("range skip-scan regions: %u..%u  adjust=%d est=%d\n",

                            nLower, nUpper, nAdjust*-1, pLoop->nOut));

     }

 

@@ -157553,7 +158839,7 @@ static int whereRangeScanEst(
         if( nNew<nOut ){

           nOut = nNew;

         }

-        WHERETRACE(0x10, ("STAT4 range scan: %u..%u  est=%d\n",

+        WHERETRACE(0x20, ("STAT4 range scan: %u..%u  est=%d\n",

                            (u32)iLower, (u32)iUpper, nOut));

       }

     }else{

@@ -157586,7 +158872,7 @@ static int whereRangeScanEst(
   if( nNew<nOut ) nOut = nNew;

 #if defined(WHERETRACE_ENABLED)

   if( pLoop->nOut>nOut ){

-    WHERETRACE(0x10,("Range scan lowers nOut from %d to %d\n",

+    WHERETRACE(0x20,("Range scan lowers nOut from %d to %d\n",

                     pLoop->nOut, nOut));

   }

 #endif

@@ -157651,7 +158937,7 @@ static int whereEqualScanEst(
   pBuilder->nRecValid = nEq;

 

   whereKeyStats(pParse, p, pRec, 0, a);

-  WHERETRACE(0x10,("equality scan regions %s(%d): %d\n",

+  WHERETRACE(0x20,("equality scan regions %s(%d): %d\n",

                    p->zName, nEq-1, (int)a[1]));

   *pnRow = a[1];

 

@@ -157699,9 +158985,9 @@ static int whereInScanEst(
   }

 

   if( rc==SQLITE_OK ){

-    if( nRowEst > nRow0 ) nRowEst = nRow0;

+    if( nRowEst > (tRowcnt)nRow0 ) nRowEst = nRow0;

     *pnRow = nRowEst;

-    WHERETRACE(0x10,("IN row estimate: est=%d\n", nRowEst));

+    WHERETRACE(0x20,("IN row estimate: est=%d\n", nRowEst));

   }

   assert( pBuilder->nRecValid==nRecValid );

   return rc;

@@ -157810,7 +159096,7 @@ SQLITE_PRIVATE void sqlite3WhereLoopPrint(WhereLoop *p, WhereClause *pWC){
     sqlite3DebugPrintf(" f %06x N %d", p->wsFlags, p->nLTerm);

   }

   sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut);

-  if( p->nLTerm && (sqlite3WhereTrace & 0x100)!=0 ){

+  if( p->nLTerm && (sqlite3WhereTrace & 0x4000)!=0 ){

     int i;

     for(i=0; i<p->nLTerm; i++){

       sqlite3WhereTermPrint(p->aLTerm[i], i);

@@ -158274,6 +159560,7 @@ static void whereLoopOutputAdjust(
       if( pX->iParent>=0 && (&pWC->a[pX->iParent])==pTerm ) break;

     }

     if( j<0 ){

+      sqlite3ProgressCheck(pWC->pWInfo->pParse);

       if( pLoop->maskSelf==pTerm->prereqAll ){

         /* If there are extra terms in the WHERE clause not used by an index

         ** that depend only on the table being scanned, and that will tend to

@@ -158441,7 +159728,10 @@ static int whereLoopAddBtreeIndex(
   WhereTerm *pTop = 0, *pBtm = 0; /* Top and bottom range constraints */

 

   pNew = pBuilder->pNew;

-  if( db->mallocFailed ) return SQLITE_NOMEM_BKPT;

+  assert( db->mallocFailed==0 || pParse->nErr>0 );

+  if( pParse->nErr ){

+    return pParse->rc;

+  }

   WHERETRACE(0x800, ("BEGIN %s.addBtreeIdx(%s), nEq=%d, nSkip=%d, rRun=%d\n",

                      pProbe->pTable->zName,pProbe->zName,

                      pNew->u.btree.nEq, pNew->nSkip, pNew->rRun));

@@ -158688,7 +159978,7 @@ static int whereLoopAddBtreeIndex(
              && pNew->nOut+10 > pProbe->aiRowLogEst[0]

             ){

 #if WHERETRACE_ENABLED /* 0x01 */

-              if( sqlite3WhereTrace & 0x01 ){

+              if( sqlite3WhereTrace & 0x20 ){

                 sqlite3DebugPrintf(

                    "STAT4 determines term has low selectivity:\n");

                 sqlite3WhereTermPrint(pTerm, 999);

@@ -158725,9 +160015,17 @@ static int whereLoopAddBtreeIndex(
     ** seek only. Then, if this is a non-covering index, add the cost of

     ** visiting the rows in the main table.  */

     assert( pSrc->pTab->szTabRow>0 );

-    rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;

+    if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){

+      /* The pProbe->szIdxRow is low for an IPK table since the interior

+      ** pages are small.  Thuse szIdxRow gives a good estimate of seek cost.

+      ** But the leaf pages are full-size, so pProbe->szIdxRow would badly

+      ** under-estimate the scanning cost. */

+      rCostIdx = pNew->nOut + 16;

+    }else{

+      rCostIdx = pNew->nOut + 1 + (15*pProbe->szIdxRow)/pSrc->pTab->szTabRow;

+    }

     pNew->rRun = sqlite3LogEstAdd(rLogSize, rCostIdx);

-    if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK))==0 ){

+    if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK|WHERE_EXPRIDX))==0 ){

       pNew->rRun = sqlite3LogEstAdd(pNew->rRun, pNew->nOut + 16);

     }

     ApplyCostMultiplier(pNew->rRun, pProbe->pTable->costMult);

@@ -158749,6 +160047,9 @@ static int whereLoopAddBtreeIndex(
      && (pNew->u.btree.nEq<pProbe->nKeyCol ||

            pProbe->idxType!=SQLITE_IDXTYPE_PRIMARYKEY)

     ){

+      if( pNew->u.btree.nEq>3 ){

+        sqlite3ProgressCheck(pParse);

+      }

       whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn);

     }

     pNew->nOut = saved_nOut;

@@ -158881,15 +160182,38 @@ static int whereUsablePartialIndex(
 }

 

 /*

+** pIdx is an index containing expressions.  Check it see if any of the

+** expressions in the index match the pExpr expression.

+*/

+static int exprIsCoveredByIndex(

+  const Expr *pExpr,

+  const Index *pIdx,

+  int iTabCur

+){

+  int i;

+  for(i=0; i<pIdx->nColumn; i++){

+    if( pIdx->aiColumn[i]==XN_EXPR

+     && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0

+    ){

+      return 1;

+    }

+  }

+  return 0;

+}

+

+/*

 ** Structure passed to the whereIsCoveringIndex Walker callback.

 */

+typedef struct CoveringIndexCheck CoveringIndexCheck;

 struct CoveringIndexCheck {

   Index *pIdx;       /* The index */

   int iTabCur;       /* Cursor number for the corresponding table */

+  u8 bExpr;          /* Uses an indexed expression */

+  u8 bUnidx;         /* Uses an unindexed column not within an indexed expr */

 };

 

 /*

-** Information passed in is pWalk->u.pCovIdxCk.  Call is pCk.

+** Information passed in is pWalk->u.pCovIdxCk.  Call it pCk.

 **

 ** If the Expr node references the table with cursor pCk->iTabCur, then

 ** make sure that column is covered by the index pCk->pIdx.  We know that

@@ -158901,71 +160225,103 @@ struct CoveringIndexCheck {
 **

 ** If this node does not disprove that the index can be a covering index,

 ** then just return WRC_Continue, to continue the search.

+**

+** If pCk->pIdx contains indexed expressions and one of those expressions

+** matches pExpr, then prune the search.

 */

 static int whereIsCoveringIndexWalkCallback(Walker *pWalk, Expr *pExpr){

-  int i;                  /* Loop counter */

-  const Index *pIdx;      /* The index of interest */

-  const i16 *aiColumn;    /* Columns contained in the index */

-  u16 nColumn;            /* Number of columns in the index */

-  if( pExpr->op!=TK_COLUMN && pExpr->op!=TK_AGG_COLUMN ) return WRC_Continue;

-  if( pExpr->iColumn<(BMS-1) ) return WRC_Continue;

-  if( pExpr->iTable!=pWalk->u.pCovIdxCk->iTabCur ) return WRC_Continue;

-  pIdx = pWalk->u.pCovIdxCk->pIdx;

-  aiColumn = pIdx->aiColumn;

-  nColumn = pIdx->nColumn;

-  for(i=0; i<nColumn; i++){

-    if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;

-  }

-  pWalk->eCode = 1;

-  return WRC_Abort;

+  int i;                    /* Loop counter */

+  const Index *pIdx;        /* The index of interest */

+  const i16 *aiColumn;      /* Columns contained in the index */

+  u16 nColumn;              /* Number of columns in the index */

+  CoveringIndexCheck *pCk;  /* Info about this search */

+

+  pCk = pWalk->u.pCovIdxCk;

+  pIdx = pCk->pIdx;

+  if( (pExpr->op==TK_COLUMN || pExpr->op==TK_AGG_COLUMN) ){

+    /* if( pExpr->iColumn<(BMS-1) && pIdx->bHasExpr==0 ) return WRC_Continue;*/

+    if( pExpr->iTable!=pCk->iTabCur ) return WRC_Continue;

+    pIdx = pWalk->u.pCovIdxCk->pIdx;

+    aiColumn = pIdx->aiColumn;

+    nColumn = pIdx->nColumn;

+    for(i=0; i<nColumn; i++){

+      if( aiColumn[i]==pExpr->iColumn ) return WRC_Continue;

+    }

+    pCk->bUnidx = 1;

+    return WRC_Abort;

+  }else if( pIdx->bHasExpr

+         && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){

+    pCk->bExpr = 1;

+    return WRC_Prune;

+  }

+  return WRC_Continue;

 }

 

 

 /*

 ** pIdx is an index that covers all of the low-number columns used by

-** pWInfo->pSelect (columns from 0 through 62).  But there are columns

-** in pWInfo->pSelect beyond 62.  This routine tries to answer the question

-** of whether pIdx covers *all* columns in the query.

+** pWInfo->pSelect (columns from 0 through 62) or an index that has

+** expressions terms.  Hence, we cannot determine whether or not it is

+** a covering index by using the colUsed bitmasks.  We have to do a search

+** to see if the index is covering.  This routine does that search.

+**

+** The return value is one of these:

 **

-** Return 0 if pIdx is a covering index.   Return non-zero if pIdx is

-** not a covering index or if we are unable to determine if pIdx is a

-** covering index.

+**      0                The index is definitely not a covering index

 **

-** This routine is an optimization.  It is always safe to return non-zero.

-** But returning zero when non-zero should have been returned can lead to

-** incorrect bytecode and assertion faults.

+**      WHERE_IDX_ONLY   The index is definitely a covering index

+**

+**      WHERE_EXPRIDX    The index is likely a covering index, but it is

+**                       difficult to determine precisely because of the

+**                       expressions that are indexed.  Score it as a

+**                       covering index, but still keep the main table open

+**                       just in case we need it.

+**

+** This routine is an optimization.  It is always safe to return zero.

+** But returning one of the other two values when zero should have been

+** returned can lead to incorrect bytecode and assertion faults.

 */

 static SQLITE_NOINLINE u32 whereIsCoveringIndex(

   WhereInfo *pWInfo,     /* The WHERE clause context */

   Index *pIdx,           /* Index that is being tested */

   int iTabCur            /* Cursor for the table being indexed */

 ){

-  int i;

+  int i, rc;

   struct CoveringIndexCheck ck;

   Walker w;

   if( pWInfo->pSelect==0 ){

     /* We don't have access to the full query, so we cannot check to see

     ** if pIdx is covering.  Assume it is not. */

-    return 1;

-  }

-  for(i=0; i<pIdx->nColumn; i++){

-    if( pIdx->aiColumn[i]>=BMS-1 ) break;

+    return 0;

   }

-  if( i>=pIdx->nColumn ){

-    /* pIdx does not index any columns greater than 62, but we know from

-    ** colMask that columns greater than 62 are used, so this is not a

-    ** covering index */

-    return 1;

+  if( pIdx->bHasExpr==0 ){

+    for(i=0; i<pIdx->nColumn; i++){

+      if( pIdx->aiColumn[i]>=BMS-1 ) break;

+    }

+    if( i>=pIdx->nColumn ){

+      /* pIdx does not index any columns greater than 62, but we know from

+      ** colMask that columns greater than 62 are used, so this is not a

+      ** covering index */

+      return 0;

+    }

   }

   ck.pIdx = pIdx;

   ck.iTabCur = iTabCur;

+  ck.bExpr = 0;

+  ck.bUnidx = 0;

   memset(&w, 0, sizeof(w));

   w.xExprCallback = whereIsCoveringIndexWalkCallback;

   w.xSelectCallback = sqlite3SelectWalkNoop;

   w.u.pCovIdxCk = &ck;

-  w.eCode = 0;

   sqlite3WalkSelect(&w, pWInfo->pSelect);

-  return w.eCode;

+  if( ck.bUnidx ){

+    rc = 0;

+  }else if( ck.bExpr ){

+    rc = WHERE_EXPRIDX;

+  }else{

+    rc = WHERE_IDX_ONLY;

+  }

+  return rc;

 }

 

 /*

@@ -159050,7 +160406,7 @@ static int whereLoopAddBtree(
     sPk.aiRowLogEst = aiRowEstPk;

     sPk.onError = OE_Replace;

     sPk.pTable = pTab;

-    sPk.szIdxRow = pTab->szTabRow;

+    sPk.szIdxRow = 3;  /* TUNING: Interior rows of IPK table are very small */

     sPk.idxType = SQLITE_IDXTYPE_IPK;

     aiRowEstPk[0] = pTab->nRowLogEst;

     aiRowEstPk[1] = 0;

@@ -159101,7 +160457,8 @@ static int whereLoopAddBtree(
         if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){

           pNew->rSetup += 28;

         }else{

-          pNew->rSetup -= 10;

+          pNew->rSetup -= 25;  /* Greatly reduced setup cost for auto indexes

+                               ** on ephemeral materializations of views */

         }

         ApplyCostMultiplier(pNew->rSetup, pTab->costMult);

         if( pNew->rSetup<0 ) pNew->rSetup = 0;

@@ -159181,14 +160538,38 @@ static int whereLoopAddBtree(
     }else{

       Bitmask m;

       if( pProbe->isCovering ){

-        pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;

         m = 0;

+        pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;

       }else{

         m = pSrc->colUsed & pProbe->colNotIdxed;

-        if( m==TOPBIT ){

-          m = whereIsCoveringIndex(pWInfo, pProbe, pSrc->iCursor);

+        pNew->wsFlags = WHERE_INDEXED;

+        if( m==TOPBIT || (pProbe->bHasExpr && !pProbe->bHasVCol && m!=0) ){

+          u32 isCov = whereIsCoveringIndex(pWInfo, pProbe, pSrc->iCursor);

+          if( isCov==0 ){

+            WHERETRACE(0x200,

+               ("-> %s is not a covering index"

+                " according to whereIsCoveringIndex()\n", pProbe->zName));

+            assert( m!=0 );

+          }else{

+            m = 0;

+            pNew->wsFlags |= isCov;

+            if( isCov & WHERE_IDX_ONLY ){

+              WHERETRACE(0x200,

+                 ("-> %s is a covering expression index"

+                  " according to whereIsCoveringIndex()\n", pProbe->zName));

+            }else{

+              assert( isCov==WHERE_EXPRIDX );

+              WHERETRACE(0x200,

+                 ("-> %s might be a covering expression index"

+                  " according to whereIsCoveringIndex()\n", pProbe->zName));

+            }

+          }

+        }else if( m==0 ){

+          WHERETRACE(0x200,

+             ("-> %s a covering index according to bitmasks\n",

+             pProbe->zName, m==0 ? "is" : "is not"));

+          pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;

         }

-        pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED;

       }

 

       /* Full scan via index */

@@ -159361,7 +160742,7 @@ static int whereLoopAddVirtualOne(
       ** that the particular combination of parameters provided is unusable.

       ** Make no entries in the loop table.

       */

-      WHERETRACE(0xffff, ("  ^^^^--- non-viable plan rejected!\n"));

+      WHERETRACE(0xffffffff, ("  ^^^^--- non-viable plan rejected!\n"));

       return SQLITE_OK;

     }

     return rc;

@@ -159472,7 +160853,7 @@ static int whereLoopAddVirtualOne(
     sqlite3_free(pNew->u.vtab.idxStr);

     pNew->u.vtab.needFree = 0;

   }

-  WHERETRACE(0xffff, ("  bIn=%d prereqIn=%04llx prereqOut=%04llx\n",

+  WHERETRACE(0xffffffff, ("  bIn=%d prereqIn=%04llx prereqOut=%04llx\n",

                       *pbIn, (sqlite3_uint64)mPrereq,

                       (sqlite3_uint64)(pNew->prereq & ~mPrereq)));

 

@@ -159577,7 +160958,7 @@ SQLITE_API int sqlite3_vtab_distinct(sqlite3_index_info *pIdxInfo){
     && !defined(SQLITE_OMIT_VIRTUALTABLE)

 /*

 ** Cause the prepared statement that is associated with a call to

-** xBestIndex to potentiall use all schemas.  If the statement being

+** xBestIndex to potentially use all schemas.  If the statement being

 ** prepared is read-only, then just start read transactions on all

 ** schemas.  But if this is a write operation, start writes on all

 ** schemas.

@@ -159592,7 +160973,7 @@ SQLITE_PRIVATE void sqlite3VtabUsesAllSchemas(sqlite3_index_info *pIdxInfo){
   for(i=0; i<nDb; i++){

     sqlite3CodeVerifySchema(pParse, i);

   }

-  if( pParse->writeMask ){

+  if( DbMaskNonZero(pParse->writeMask) ){

     for(i=0; i<nDb; i++){

       sqlite3BeginWriteOperation(pParse, 0, i);

     }

@@ -159664,7 +161045,7 @@ static int whereLoopAddVirtual(
 

   /* First call xBestIndex() with all constraints usable. */

   WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));

-  WHERETRACE(0x40, ("  VirtualOne: all usable\n"));

+  WHERETRACE(0x800, ("  VirtualOne: all usable\n"));

   rc = whereLoopAddVirtualOne(

       pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn, &bRetry

   );

@@ -159689,7 +161070,7 @@ static int whereLoopAddVirtual(
     /* If the plan produced by the earlier call uses an IN(...) term, call

     ** xBestIndex again, this time with IN(...) terms disabled. */

     if( bIn ){

-      WHERETRACE(0x40, ("  VirtualOne: all usable w/o IN\n"));

+      WHERETRACE(0x800, ("  VirtualOne: all usable w/o IN\n"));

       rc = whereLoopAddVirtualOne(

           pBuilder, mPrereq, ALLBITS, WO_IN, p, mNoOmit, &bIn, 0);

       assert( bIn==0 );

@@ -159715,7 +161096,7 @@ static int whereLoopAddVirtual(
       mPrev = mNext;

       if( mNext==ALLBITS ) break;

       if( mNext==mBest || mNext==mBestNoIn ) continue;

-      WHERETRACE(0x40, ("  VirtualOne: mPrev=%04llx mNext=%04llx\n",

+      WHERETRACE(0x800, ("  VirtualOne: mPrev=%04llx mNext=%04llx\n",

                        (sqlite3_uint64)mPrev, (sqlite3_uint64)mNext));

       rc = whereLoopAddVirtualOne(

           pBuilder, mPrereq, mNext|mPrereq, 0, p, mNoOmit, &bIn, 0);

@@ -159729,7 +161110,7 @@ static int whereLoopAddVirtual(
     ** that requires no source tables at all (i.e. one guaranteed to be

     ** usable), make a call here with all source tables disabled */

     if( rc==SQLITE_OK && seenZero==0 ){

-      WHERETRACE(0x40, ("  VirtualOne: all disabled\n"));

+      WHERETRACE(0x800, ("  VirtualOne: all disabled\n"));

       rc = whereLoopAddVirtualOne(

           pBuilder, mPrereq, mPrereq, 0, p, mNoOmit, &bIn, 0);

       if( bIn==0 ) seenZeroNoIN = 1;

@@ -159739,7 +161120,7 @@ static int whereLoopAddVirtual(
     ** that requires no source tables at all and does not use an IN(...)

     ** operator, make a final call to obtain one here.  */

     if( rc==SQLITE_OK && seenZeroNoIN==0 ){

-      WHERETRACE(0x40, ("  VirtualOne: all disabled and w/o IN\n"));

+      WHERETRACE(0x800, ("  VirtualOne: all disabled and w/o IN\n"));

       rc = whereLoopAddVirtualOne(

           pBuilder, mPrereq, mPrereq, WO_IN, p, mNoOmit, &bIn, 0);

     }

@@ -159795,7 +161176,7 @@ static int whereLoopAddOr(
       sSubBuild = *pBuilder;

       sSubBuild.pOrSet = &sCur;

 

-      WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm));

+      WHERETRACE(0x400, ("Begin processing OR-clause %p\n", pTerm));

       for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){

         if( (pOrTerm->eOperator & WO_AND)!=0 ){

           sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc;

@@ -159812,9 +161193,9 @@ static int whereLoopAddOr(
         }

         sCur.n = 0;

 #ifdef WHERETRACE_ENABLED

-        WHERETRACE(0x200, ("OR-term %d of %p has %d subterms:\n",

+        WHERETRACE(0x400, ("OR-term %d of %p has %d subterms:\n",

                    (int)(pOrTerm-pOrWC->a), pTerm, sSubBuild.pWC->nTerm));

-        if( sqlite3WhereTrace & 0x400 ){

+        if( sqlite3WhereTrace & 0x20000 ){

           sqlite3WhereClausePrint(sSubBuild.pWC);

         }

 #endif

@@ -159829,8 +161210,6 @@ static int whereLoopAddOr(
         if( rc==SQLITE_OK ){

           rc = whereLoopAddOr(&sSubBuild, mPrereq, mUnusable);

         }

-        assert( rc==SQLITE_OK || rc==SQLITE_DONE || sCur.n==0

-                || rc==SQLITE_NOMEM );

         testcase( rc==SQLITE_NOMEM && sCur.n>0 );

         testcase( rc==SQLITE_DONE );

         if( sCur.n==0 ){

@@ -159876,7 +161255,7 @@ static int whereLoopAddOr(
         pNew->prereq = sSum.a[i].prereq;

         rc = whereLoopInsert(pBuilder, pNew);

       }

-      WHERETRACE(0x200, ("End processing OR-clause %p\n", pTerm));

+      WHERETRACE(0x400, ("End processing OR-clause %p\n", pTerm));

     }

   }

   return rc;

@@ -160224,8 +161603,8 @@ static i8 wherePathSatisfiesOrderBy(
             if( pOBExpr->iTable!=iCur ) continue;

             if( pOBExpr->iColumn!=iColumn ) continue;

           }else{

-            Expr *pIdxExpr = pIndex->aColExpr->a[j].pExpr;

-            if( sqlite3ExprCompareSkip(pOBExpr, pIdxExpr, iCur) ){

+            Expr *pIxExpr = pIndex->aColExpr->a[j].pExpr;

+            if( sqlite3ExprCompareSkip(pOBExpr, pIxExpr, iCur) ){

               continue;

             }

           }

@@ -160357,37 +161736,56 @@ static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){
 ** order.

 */

 static LogEst whereSortingCost(

-  WhereInfo *pWInfo,

-  LogEst nRow,

-  int nOrderBy,

-  int nSorted

+  WhereInfo *pWInfo, /* Query planning context */

+  LogEst nRow,       /* Estimated number of rows to sort */

+  int nOrderBy,      /* Number of ORDER BY clause terms */

+  int nSorted        /* Number of initial ORDER BY terms naturally in order */

 ){

-  /* TUNING: Estimated cost of a full external sort, where N is

+  /* Estimated cost of a full external sort, where N is

   ** the number of rows to sort is:

   **

-  **   cost = (3.0 * N * log(N)).

+  **   cost = (K * N * log(N)).

   **

   ** Or, if the order-by clause has X terms but only the last Y

   ** terms are out of order, then block-sorting will reduce the

   ** sorting cost to:

   **

-  **   cost = (3.0 * N * log(N)) * (Y/X)

+  **   cost = (K * N * log(N)) * (Y/X)

   **

-  ** The (Y/X) term is implemented using stack variable rScale

-  ** below.

+  ** The constant K is at least 2.0 but will be larger if there are a

+  ** large number of columns to be sorted, as the sorting time is

+  ** proportional to the amount of content to be sorted.  The algorithm

+  ** does not currently distinguish between fat columns (BLOBs and TEXTs)

+  ** and skinny columns (INTs).  It just uses the number of columns as

+  ** an approximation for the row width.

+  **

+  ** And extra factor of 2.0 or 3.0 is added to the sorting cost if the sort

+  ** is built using OP_IdxInsert and OP_Sort rather than with OP_SorterInsert.

   */

-  LogEst rScale, rSortCost;

-  assert( nOrderBy>0 && 66==sqlite3LogEst(100) );

-  rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;

-  rSortCost = nRow + rScale + 16;

+  LogEst rSortCost, nCol;

+  assert( pWInfo->pSelect!=0 );

+  assert( pWInfo->pSelect->pEList!=0 );

+  /* TUNING: sorting cost proportional to the number of output columns: */

+  nCol = sqlite3LogEst((pWInfo->pSelect->pEList->nExpr+59)/30);

+  rSortCost = nRow + nCol;

+  if( nSorted>0 ){

+    /* Scale the result by (Y/X) */

+    rSortCost += sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;

+  }

 

   /* Multiple by log(M) where M is the number of output rows.

   ** Use the LIMIT for M if it is smaller.  Or if this sort is for

   ** a DISTINCT operator, M will be the number of distinct output

   ** rows, so fudge it downwards a bit.

   */

-  if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 && pWInfo->iLimit<nRow ){

-    nRow = pWInfo->iLimit;

+  if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 ){

+    rSortCost += 10;       /* TUNING: Extra 2.0x if using LIMIT */

+    if( nSorted!=0 ){

+      rSortCost += 6;      /* TUNING: Extra 1.5x if also using partial sort */

+    }

+    if( pWInfo->iLimit<nRow ){

+      nRow = pWInfo->iLimit;

+    }

   }else if( (pWInfo->wctrlFlags & WHERE_WANT_DISTINCT) ){

     /* TUNING: In the sort for a DISTINCT operator, assume that the DISTINCT

     ** reduces the number of output rows by a factor of 2 */

@@ -160539,11 +161937,11 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
                 pWInfo, nRowEst, nOrderBy, isOrdered

             );

           }

-          /* TUNING:  Add a small extra penalty (5) to sorting as an

+          /* TUNING:  Add a small extra penalty (3) to sorting as an

           ** extra encouragment to the query planner to select a plan

           ** where the rows emerge in the correct order without any sorting

           ** required. */

-          rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 5;

+          rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 3;

 

           WHERETRACE(0x002,

               ("---- sort cost=%-3d (%d/%d) increases cost %3d to %-3d\n",

@@ -160891,7 +162289,7 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
     pLoop->cId = '0';

 #endif

 #ifdef WHERETRACE_ENABLED

-    if( sqlite3WhereTrace ){

+    if( sqlite3WhereTrace & 0x02 ){

       sqlite3DebugPrintf("whereShortCut() used to compute solution\n");

     }

 #endif

@@ -161021,7 +162419,7 @@ static SQLITE_NOINLINE Bitmask whereOmitNoopJoin(
       }

     }

     if( pTerm<pEnd ) continue;

-    WHERETRACE(0xffff, ("-> drop loop %c not used\n", pLoop->cId));

+    WHERETRACE(0xffffffff, ("-> drop loop %c not used\n", pLoop->cId));

     notReady &= ~pLoop->maskSelf;

     for(pTerm=pWInfo->sWC.a; pTerm<pEnd; pTerm++){

       if( (pTerm->prereqAll & pLoop->maskSelf)!=0 ){

@@ -161060,28 +162458,27 @@ static SQLITE_NOINLINE void whereCheckIfBloomFilterIsUseful(
   const WhereInfo *pWInfo

 ){

   int i;

-  LogEst nSearch;

+  LogEst nSearch = 0;

 

   assert( pWInfo->nLevel>=2 );

   assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_BloomFilter) );

-  nSearch = pWInfo->a[0].pWLoop->nOut;

-  for(i=1; i<pWInfo->nLevel; i++){

+  for(i=0; i<pWInfo->nLevel; i++){

     WhereLoop *pLoop = pWInfo->a[i].pWLoop;

     const unsigned int reqFlags = (WHERE_SELFCULL|WHERE_COLUMN_EQ);

-    if( (pLoop->wsFlags & reqFlags)==reqFlags

+    SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab];

+    Table *pTab = pItem->pTab;

+    if( (pTab->tabFlags & TF_HasStat1)==0 ) break;

+    pTab->tabFlags |= TF_StatsUsed;

+    if( i>=1

+     && (pLoop->wsFlags & reqFlags)==reqFlags

      /* vvvvvv--- Always the case if WHERE_COLUMN_EQ is defined */

      && ALWAYS((pLoop->wsFlags & (WHERE_IPK|WHERE_INDEXED))!=0)

     ){

-      SrcItem *pItem = &pWInfo->pTabList->a[pLoop->iTab];

-      Table *pTab = pItem->pTab;

-      pTab->tabFlags |= TF_StatsUsed;

-      if( nSearch > pTab->nRowLogEst

-       && (pTab->tabFlags & TF_HasStat1)!=0

-      ){

+      if( nSearch > pTab->nRowLogEst ){

         testcase( pItem->fg.jointype & JT_LEFT );

         pLoop->wsFlags |= WHERE_BLOOMFILTER;

         pLoop->wsFlags &= ~WHERE_IDX_ONLY;

-        WHERETRACE(0xffff, (

+        WHERETRACE(0xffffffff, (

            "-> use Bloom-filter on loop %c because there are ~%.1e "

            "lookups into %s which has only ~%.1e rows\n",

            pLoop->cId, (double)sqlite3LogEstToInt(nSearch), pTab->zName,

@@ -161094,13 +162491,13 @@ static SQLITE_NOINLINE void whereCheckIfBloomFilterIsUseful(
 

 /*

 ** This is an sqlite3ParserAddCleanup() callback that is invoked to

-** free the Parse->pIdxExpr list when the Parse object is destroyed.

+** free the Parse->pIdxEpr list when the Parse object is destroyed.

 */

 static void whereIndexedExprCleanup(sqlite3 *db, void *pObject){

   Parse *pParse = (Parse*)pObject;

-  while( pParse->pIdxExpr!=0 ){

-    IndexedExpr *p = pParse->pIdxExpr;

-    pParse->pIdxExpr = p->pIENext;

+  while( pParse->pIdxEpr!=0 ){

+    IndexedExpr *p = pParse->pIdxEpr;

+    pParse->pIdxEpr = p->pIENext;

     sqlite3ExprDelete(db, p->pExpr);

     sqlite3DbFreeNN(db, p);

   }

@@ -161112,13 +162509,13 @@ static void whereIndexedExprCleanup(sqlite3 *db, void *pObject){
 ** number for the index and iDataCur is the cursor number for the corresponding

 ** table.

 **

-** This routine adds IndexedExpr entries to the Parse->pIdxExpr field for

+** This routine adds IndexedExpr entries to the Parse->pIdxEpr field for

 ** each of the expressions in the index so that the expression code generator

 ** will know to replace occurrences of the indexed expression with

 ** references to the corresponding column of the index.

 */

 static SQLITE_NOINLINE void whereAddIndexedExpr(

-  Parse *pParse,     /* Add IndexedExpr entries to pParse->pIdxExpr */

+  Parse *pParse,     /* Add IndexedExpr entries to pParse->pIdxEpr */

   Index *pIdx,       /* The index-on-expression that contains the expressions */

   int iIdxCur,       /* Cursor number for pIdx */

   SrcItem *pTabItem  /* The FROM clause entry for the table */

@@ -161147,7 +162544,13 @@ static SQLITE_NOINLINE void whereAddIndexedExpr(
     if( sqlite3ExprIsConstant(pExpr) ) continue;

     p = sqlite3DbMallocRaw(pParse->db,  sizeof(IndexedExpr));

     if( p==0 ) break;

-    p->pIENext = pParse->pIdxExpr;

+    p->pIENext = pParse->pIdxEpr;

+#ifdef WHERETRACE_ENABLED

+    if( sqlite3WhereTrace & 0x200 ){

+      sqlite3DebugPrintf("New pParse->pIdxEpr term {%d,%d}\n", iIdxCur, i);

+      if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(pExpr);

+    }

+#endif

     p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);

     p->iDataCur = pTabItem->iCursor;

     p->iIdxCur = iIdxCur;

@@ -161156,7 +162559,7 @@ static SQLITE_NOINLINE void whereAddIndexedExpr(
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS

     p->zIdxName = pIdx->zName;

 #endif

-    pParse->pIdxExpr = p;

+    pParse->pIdxEpr = p;

     if( p->pIENext==0 ){

       sqlite3ParserAddCleanup(pParse, whereIndexedExprCleanup, pParse);

     }

@@ -161448,13 +162851,13 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
 

   /* Construct the WhereLoop objects */

 #if defined(WHERETRACE_ENABLED)

-  if( sqlite3WhereTrace & 0xffff ){

+  if( sqlite3WhereTrace & 0xffffffff ){

     sqlite3DebugPrintf("*** Optimizer Start *** (wctrlFlags: 0x%x",wctrlFlags);

     if( wctrlFlags & WHERE_USE_LIMIT ){

       sqlite3DebugPrintf(", limit: %d", iAuxArg);

     }

     sqlite3DebugPrintf(")\n");

-    if( sqlite3WhereTrace & 0x100 ){

+    if( sqlite3WhereTrace & 0x8000 ){

       Select sSelect;

       memset(&sSelect, 0, sizeof(sSelect));

       sSelect.selFlags = SF_WhereBegin;

@@ -161464,10 +162867,10 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
       sSelect.pEList = pResultSet;

       sqlite3TreeViewSelect(0, &sSelect, 0);

     }

-  }

-  if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */

-    sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n");

-    sqlite3WhereClausePrint(sWLB.pWC);

+    if( sqlite3WhereTrace & 0x4000 ){ /* Display all WHERE clause terms */

+      sqlite3DebugPrintf("---- WHERE clause at start of analysis:\n");

+      sqlite3WhereClausePrint(sWLB.pWC);

+    }

   }

 #endif

 

@@ -161483,7 +162886,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     ** loops will be built using the revised truthProb values. */

     if( sWLB.bldFlags2 & SQLITE_BLDF2_2NDPASS ){

       WHERETRACE_ALL_LOOPS(pWInfo, sWLB.pWC);

-      WHERETRACE(0xffff,

+      WHERETRACE(0xffffffff,

            ("**** Redo all loop computations due to"

             " TERM_HIGHTRUTH changes ****\n"));

       while( pWInfo->pLoops ){

@@ -161569,11 +162972,11 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   }

 

 #if defined(WHERETRACE_ENABLED)

-  if( sqlite3WhereTrace & 0x100 ){ /* Display all terms of the WHERE clause */

+  if( sqlite3WhereTrace & 0x4000 ){ /* Display all terms of the WHERE clause */

     sqlite3DebugPrintf("---- WHERE clause at end of analysis:\n");

     sqlite3WhereClausePrint(sWLB.pWC);

   }

-  WHERETRACE(0xffff,("*** Optimizer Finished ***\n"));

+  WHERETRACE(0xffffffff,("*** Optimizer Finished ***\n"));

 #endif

   pWInfo->pParse->nQueryLoop += pWInfo->nRowOut;

 

@@ -162107,9 +163510,16 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
         last = pWInfo->iEndWhere;

       }

       if( pIdx->bHasExpr ){

-        IndexedExpr *p = pParse->pIdxExpr;

+        IndexedExpr *p = pParse->pIdxEpr;

         while( p ){

           if( p->iIdxCur==pLevel->iIdxCur ){

+#ifdef WHERETRACE_ENABLED

+            if( sqlite3WhereTrace & 0x200 ){

+              sqlite3DebugPrintf("Disable pParse->pIdxEpr term {%d,%d}\n",

+                                  p->iIdxCur, p->iIdxCol);

+              if( sqlite3WhereTrace & 0x5000 ) sqlite3ShowExpr(p->pExpr);

+            }

+#endif

             p->iDataCur = -1;

             p->iIdxCur = -1;

           }

@@ -163278,7 +164688,7 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
     pSub = sqlite3SelectNew(

         pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0

     );

-    SELECTTRACE(1,pParse,pSub,

+    TREETRACE(0x40,pParse,pSub,

        ("New window-function subquery in FROM clause of (%u/%p)\n",

        p->selId, p));

     p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);

@@ -163288,6 +164698,7 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
     if( p->pSrc ){

       Table *pTab2;

       p->pSrc->a[0].pSelect = pSub;

+      p->pSrc->a[0].fg.isCorrelated = 1;

       sqlite3SrcListAssignCursors(pParse, p->pSrc);

       pSub->selFlags |= SF_Expanded|SF_OrderByReqd;

       pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE);

@@ -165153,8 +166564,7 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
     VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */

     VdbeCoverageNeverNullIf(v, op==OP_Le); /*   values previously checked */

     windowAggFinal(&s, 0);

-    sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);

-    VdbeCoverageNeverTaken(v);

+    sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);

     windowReturnOneRow(&s);

     sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);

     sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);

@@ -165166,13 +166576,10 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
   }

 

   if( pMWin->eStart!=TK_UNBOUNDED ){

-    sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1);

-    VdbeCoverageNeverTaken(v);

+    sqlite3VdbeAddOp1(v, OP_Rewind, s.start.csr);

   }

-  sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);

-  VdbeCoverageNeverTaken(v);

-  sqlite3VdbeAddOp2(v, OP_Rewind, s.end.csr, 1);

-  VdbeCoverageNeverTaken(v);

+  sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);

+  sqlite3VdbeAddOp1(v, OP_Rewind, s.end.csr);

   if( regPeer && pOrderBy ){

     sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1);

     sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);

@@ -169854,6 +171261,11 @@ static YYACTIONTYPE yy_reduce(
         sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);

         pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);

         yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy528, pRHS);

+      }else if( yymsp[-1].minor.yy322->nExpr==1 && pRHS->op==TK_SELECT ){

+        yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0);

+        sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy528, pRHS->x.pSelect);

+        pRHS->x.pSelect = 0;

+        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);

       }else{

         yymsp[-4].minor.yy528 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy528, 0);

         if( yymsp[-4].minor.yy528==0 ){

@@ -174056,6 +175468,7 @@ SQLITE_PRIVATE const char *sqlite3ErrName(int rc){
       case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;

       case SQLITE_NOTICE_RECOVER_ROLLBACK:

                                 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;

+      case SQLITE_NOTICE_RBU:         zName = "SQLITE_NOTICE_RBU"; break;

       case SQLITE_WARNING:            zName = "SQLITE_WARNING";           break;

       case SQLITE_WARNING_AUTOINDEX:  zName = "SQLITE_WARNING_AUTOINDEX"; break;

       case SQLITE_DONE:               zName = "SQLITE_DONE";              break;

@@ -174285,7 +175698,9 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){
 */

 SQLITE_API void sqlite3_interrupt(sqlite3 *db){

 #ifdef SQLITE_ENABLE_API_ARMOR

-  if( !sqlite3SafetyCheckOk(db) && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE) ){

+  if( !sqlite3SafetyCheckOk(db)

+   && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE)

+  ){

     (void)SQLITE_MISUSE_BKPT;

     return;

   }

@@ -174293,6 +175708,21 @@ SQLITE_API void sqlite3_interrupt(sqlite3 *db){
   AtomicStore(&db->u1.isInterrupted, 1);

 }

 

+/*

+** Return true or false depending on whether or not an interrupt is

+** pending on connection db.

+*/

+SQLITE_API int sqlite3_is_interrupted(sqlite3 *db){

+#ifdef SQLITE_ENABLE_API_ARMOR

+  if( !sqlite3SafetyCheckOk(db)

+   && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE)

+  ){

+    (void)SQLITE_MISUSE_BKPT;

+    return 0;

+  }

+#endif

+  return AtomicLoad(&db->u1.isInterrupted)!=0;

+}

 

 /*

 ** This function is exactly the same as sqlite3_create_function(), except

@@ -174337,7 +175767,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE.  But

   ** the meaning is inverted.  So flip the bit. */

   assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );

-  extraFlags ^= SQLITE_FUNC_UNSAFE;

+  extraFlags ^= SQLITE_FUNC_UNSAFE;  /* tag-20230109-1 */

 

 

 #ifndef SQLITE_OMIT_UTF16

@@ -174355,11 +175785,11 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
     case SQLITE_ANY: {

       int rc;

       rc = sqlite3CreateFunc(db, zFunctionName, nArg,

-           (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE,

+           (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE, /* tag-20230109-1 */

            pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);

       if( rc==SQLITE_OK ){

         rc = sqlite3CreateFunc(db, zFunctionName, nArg,

-             (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE,

+             (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE, /* tag-20230109-1*/

              pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);

       }

       if( rc!=SQLITE_OK ){

@@ -178941,6 +180371,8 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int);
 SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int);

 #endif

 

+SQLITE_PRIVATE int sqlite3Fts3ExprIterate(Fts3Expr*, int (*x)(Fts3Expr*,int,void*), void*);

+

 #endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */

 #endif /* _FTSINT_H */

 

@@ -183944,9 +185376,8 @@ static void fts3EvalNextRow(
   Fts3Expr *pExpr,                /* Expr. to advance to next matching row */

   int *pRc                        /* IN/OUT: Error code */

 ){

-  if( *pRc==SQLITE_OK ){

+  if( *pRc==SQLITE_OK && pExpr->bEof==0 ){

     int bDescDoclist = pCsr->bDesc;         /* Used by DOCID_CMP() macro */

-    assert( pExpr->bEof==0 );

     pExpr->bStart = 1;

 

     switch( pExpr->eType ){

@@ -184423,6 +185854,22 @@ static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
 }

 

 /*

+** This is an sqlite3Fts3ExprIterate() callback. If the Fts3Expr.aMI[] array

+** has not yet been allocated, allocate and zero it. Otherwise, just zero

+** it.

+*/

+static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){

+  Fts3Table *pTab = (Fts3Table*)pCtx;

+  UNUSED_PARAMETER(iPhrase);

+  if( pExpr->aMI==0 ){

+    pExpr->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));

+    if( pExpr->aMI==0 ) return SQLITE_NOMEM;

+  }

+  memset(pExpr->aMI, 0, pTab->nColumn * 3 * sizeof(u32));

+  return SQLITE_OK;

+}

+

+/*

 ** Expression pExpr must be of type FTSQUERY_PHRASE.

 **

 ** If it is not already allocated and populated, this function allocates and

@@ -184443,7 +185890,6 @@ static int fts3EvalGatherStats(
   if( pExpr->aMI==0 ){

     Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;

     Fts3Expr *pRoot;                /* Root of NEAR expression */

-    Fts3Expr *p;                    /* Iterator used for several purposes */

 

     sqlite3_int64 iPrevId = pCsr->iPrevId;

     sqlite3_int64 iDocid;

@@ -184451,7 +185897,9 @@ static int fts3EvalGatherStats(
 

     /* Find the root of the NEAR expression */

     pRoot = pExpr;

-    while( pRoot->pParent && pRoot->pParent->eType==FTSQUERY_NEAR ){

+    while( pRoot->pParent

+        && (pRoot->pParent->eType==FTSQUERY_NEAR || pRoot->bDeferred)

+    ){

       pRoot = pRoot->pParent;

     }

     iDocid = pRoot->iDocid;

@@ -184459,14 +185907,8 @@ static int fts3EvalGatherStats(
     assert( pRoot->bStart );

 

     /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */

-    for(p=pRoot; p; p=p->pLeft){

-      Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight);

-      assert( pE->aMI==0 );

-      pE->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));

-      if( !pE->aMI ) return SQLITE_NOMEM;

-      memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));

-    }

-

+    rc = sqlite3Fts3ExprIterate(pRoot, fts3AllocateMSI, (void*)pTab);

+    if( rc!=SQLITE_OK ) return rc;

     fts3EvalRestart(pCsr, pRoot, &rc);

 

     while( pCsr->isEof==0 && rc==SQLITE_OK ){

@@ -184622,6 +186064,7 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(
     u8 bTreeEof = 0;

     Fts3Expr *p;                  /* Used to iterate from pExpr to root */

     Fts3Expr *pNear;              /* Most senior NEAR ancestor (or pExpr) */

+    Fts3Expr *pRun;               /* Closest non-deferred ancestor of pNear */

     int bMatch;

 

     /* Check if this phrase descends from an OR expression node. If not,

@@ -184636,25 +186079,30 @@ SQLITE_PRIVATE int sqlite3Fts3EvalPhrasePoslist(
       if( p->bEof ) bTreeEof = 1;

     }

     if( bOr==0 ) return SQLITE_OK;

+    pRun = pNear;

+    while( pRun->bDeferred ){

+      assert( pRun->pParent );

+      pRun = pRun->pParent;

+    }

 

     /* This is the descendent of an OR node. In this case we cannot use

     ** an incremental phrase. Load the entire doclist for the phrase

     ** into memory in this case.  */

     if( pPhrase->bIncr ){

-      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;

+      int bEofSave = pRun->bEof;

+      fts3EvalRestart(pCsr, pRun, &rc);

+      while( rc==SQLITE_OK && !pRun->bEof ){

+        fts3EvalNextRow(pCsr, pRun, &rc);

+        if( bEofSave==0 && pRun->iDocid==iDocid ) break;

       }

       assert( rc!=SQLITE_OK || pPhrase->bIncr==0 );

-      if( rc==SQLITE_OK && pNear->bEof!=bEofSave ){

+      if( rc==SQLITE_OK && pRun->bEof!=bEofSave ){

         rc = FTS_CORRUPT_VTAB;

       }

     }

     if( bTreeEof ){

-      while( rc==SQLITE_OK && !pNear->bEof ){

-        fts3EvalNextRow(pCsr, pNear, &rc);

+      while( rc==SQLITE_OK && !pRun->bEof ){

+        fts3EvalNextRow(pCsr, pRun, &rc);

       }

     }

     if( rc!=SQLITE_OK ) return rc;

@@ -194761,7 +196209,7 @@ typedef sqlite3_int64 i64;
 

 

 /*

-** Used as an fts3ExprIterate() context when loading phrase doclists to

+** Used as an sqlite3Fts3ExprIterate() context when loading phrase doclists to

 ** Fts3Expr.aDoclist[]/nDoclist.

 */

 typedef struct LoadDoclistCtx LoadDoclistCtx;

@@ -194805,7 +196253,7 @@ struct SnippetFragment {
 };

 

 /*

-** This type is used as an fts3ExprIterate() context object while

+** This type is used as an sqlite3Fts3ExprIterate() context object while

 ** accumulating the data returned by the matchinfo() function.

 */

 typedef struct MatchInfo MatchInfo;

@@ -194964,7 +196412,7 @@ static void fts3GetDeltaPosition(char **pp, i64 *piPos){
 }

 

 /*

-** Helper function for fts3ExprIterate() (see below).

+** Helper function for sqlite3Fts3ExprIterate() (see below).

 */

 static int fts3ExprIterate2(

   Fts3Expr *pExpr,                /* Expression to iterate phrases of */

@@ -194998,7 +196446,7 @@ static int fts3ExprIterate2(
 ** Otherwise, SQLITE_OK is returned after a callback has been made for

 ** all eligible phrase nodes.

 */

-static int fts3ExprIterate(

+SQLITE_PRIVATE int sqlite3Fts3ExprIterate(

   Fts3Expr *pExpr,                /* Expression to iterate phrases of */

   int (*x)(Fts3Expr*,int,void*),  /* Callback function to invoke for phrases */

   void *pCtx                      /* Second argument to pass to callback */

@@ -195007,10 +196455,9 @@ static int fts3ExprIterate(
   return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);

 }

 

-

 /*

-** This is an fts3ExprIterate() callback used while loading the doclists

-** for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also

+** This is an sqlite3Fts3ExprIterate() callback used while loading the

+** doclists for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also

 ** fts3ExprLoadDoclists().

 */

 static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){

@@ -195042,9 +196489,9 @@ static int fts3ExprLoadDoclists(
   int *pnToken                    /* OUT: Number of tokens in query */

 ){

   int rc;                         /* Return Code */

-  LoadDoclistCtx sCtx = {0,0,0};  /* Context for fts3ExprIterate() */

+  LoadDoclistCtx sCtx = {0,0,0};  /* Context for sqlite3Fts3ExprIterate() */

   sCtx.pCsr = pCsr;

-  rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);

+  rc = sqlite3Fts3ExprIterate(pCsr->pExpr,fts3ExprLoadDoclistsCb,(void*)&sCtx);

   if( pnPhrase ) *pnPhrase = sCtx.nPhrase;

   if( pnToken ) *pnToken = sCtx.nToken;

   return rc;

@@ -195057,7 +196504,7 @@ static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
 }

 static int fts3ExprPhraseCount(Fts3Expr *pExpr){

   int nPhrase = 0;

-  (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);

+  (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);

   return nPhrase;

 }

 

@@ -195185,8 +196632,9 @@ static void fts3SnippetDetails(
 }

 

 /*

-** This function is an fts3ExprIterate() callback used by fts3BestSnippet().

-** Each invocation populates an element of the SnippetIter.aPhrase[] array.

+** This function is an sqlite3Fts3ExprIterate() callback used by

+** fts3BestSnippet().  Each invocation populates an element of the

+** SnippetIter.aPhrase[] array.

 */

 static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){

   SnippetIter *p = (SnippetIter *)ctx;

@@ -195276,7 +196724,9 @@ static int fts3BestSnippet(
   sIter.nSnippet = nSnippet;

   sIter.nPhrase = nList;

   sIter.iCurrent = -1;

-  rc = fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter);

+  rc = sqlite3Fts3ExprIterate(

+      pCsr->pExpr, fts3SnippetFindPositions, (void*)&sIter

+  );

   if( rc==SQLITE_OK ){

 

     /* Set the *pmSeen output variable. */

@@ -195637,10 +197087,10 @@ static int fts3ExprLHitGather(
 }

 

 /*

-** fts3ExprIterate() callback used to collect the "global" matchinfo stats

-** for a single query.

+** sqlite3Fts3ExprIterate() callback used to collect the "global" matchinfo

+** stats for a single query.

 **

-** fts3ExprIterate() callback to load the 'global' elements of a

+** sqlite3Fts3ExprIterate() callback to load the 'global' elements of a

 ** FTS3_MATCHINFO_HITS matchinfo array. The global stats are those elements

 ** of the matchinfo array that are constant for all rows returned by the

 ** current query.

@@ -195675,7 +197125,7 @@ static int fts3ExprGlobalHitsCb(
 }

 

 /*

-** fts3ExprIterate() callback used to collect the "local" part of the

+** sqlite3Fts3ExprIterate() callback used to collect the "local" part of the

 ** FTS3_MATCHINFO_HITS array. The local stats are those elements of the

 ** array that are different for each row returned by the query.

 */

@@ -195871,7 +197321,7 @@ static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
   **/

   aIter = sqlite3Fts3MallocZero(sizeof(LcsIterator) * pCsr->nPhrase);

   if( !aIter ) return SQLITE_NOMEM;

-  (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);

+  (void)sqlite3Fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);

 

   for(i=0; i<pInfo->nPhrase; i++){

     LcsIterator *pIter = &aIter[i];

@@ -196048,11 +197498,11 @@ static int fts3MatchinfoValues(
             rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc,0,0);

             if( rc!=SQLITE_OK ) break;

           }

-          rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);

+          rc = sqlite3Fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);

           sqlite3Fts3EvalTestDeferred(pCsr, &rc);

           if( rc!=SQLITE_OK ) break;

         }

-        (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);

+        (void)sqlite3Fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);

         break;

       }

     }

@@ -196275,7 +197725,7 @@ struct TermOffsetCtx {
 };

 

 /*

-** This function is an fts3ExprIterate() callback used by sqlite3Fts3Offsets().

+** This function is an sqlite3Fts3ExprIterate() callback used by sqlite3Fts3Offsets().

 */

 static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){

   TermOffsetCtx *p = (TermOffsetCtx *)ctx;

@@ -196357,7 +197807,9 @@ SQLITE_PRIVATE void sqlite3Fts3Offsets(
     */

     sCtx.iCol = iCol;

     sCtx.iTerm = 0;

-    rc = fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx);

+    rc = sqlite3Fts3ExprIterate(

+        pCsr->pExpr, fts3ExprTermOffsetInit, (void*)&sCtx

+    );

     if( rc!=SQLITE_OK ) goto offsets_out;

 

     /* Retreive the text stored in column iCol. If an SQL NULL is stored

@@ -199733,6 +201185,13 @@ static int jsonEachBestIndex(
       idxMask |= iMask;

     }

   }

+  if( pIdxInfo->nOrderBy>0

+   && pIdxInfo->aOrderBy[0].iColumn<0

+   && pIdxInfo->aOrderBy[0].desc==0

+  ){

+    pIdxInfo->orderByConsumed = 1;

+  }

+

   if( (unusableMask & ~idxMask)!=0 ){

     /* If there are any unusable constraints on JSON or ROOT, then reject

     ** this entire plan */

@@ -199928,10 +201387,10 @@ SQLITE_PRIVATE void sqlite3RegisterJsonFunctions(void){
 #endif

     WAGGREGATE(json_group_array,  1, 0, 0,

        jsonArrayStep, jsonArrayFinal, jsonArrayValue, jsonGroupInverse,

-       SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS),

+       SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC),

     WAGGREGATE(json_group_object, 2, 0, 0,

        jsonObjectStep, jsonObjectFinal, jsonObjectValue, jsonGroupInverse,

-       SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS)

+       SQLITE_SUBTYPE|SQLITE_UTF8|SQLITE_DETERMINISTIC)

   };

   sqlite3InsertBuiltinFuncs(aJsonFunc, ArraySize(aJsonFunc));

 #endif

@@ -200463,7 +201922,7 @@ static int readInt16(u8 *p){
   return (p[0]<<8) + p[1];

 }

 static void readCoord(u8 *p, RtreeCoord *pCoord){

-  assert( ((((char*)p) - (char*)0)&3)==0 );  /* p is always 4-byte aligned */

+  assert( (((sqlite3_uint64)p)&3)==0 );  /* p is always 4-byte aligned */

 #if SQLITE_BYTEORDER==1234 && MSVC_VERSION>=1300

   pCoord->u = _byteswap_ulong(*(u32*)p);

 #elif SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000

@@ -200517,7 +201976,7 @@ static void writeInt16(u8 *p, int i){
 }

 static int writeCoord(u8 *p, RtreeCoord *pCoord){

   u32 i;

-  assert( ((((char*)p) - (char*)0)&3)==0 );  /* p is always 4-byte aligned */

+  assert( (((sqlite3_uint64)p)&3)==0 );  /* p is always 4-byte aligned */

   assert( sizeof(RtreeCoord)==4 );

   assert( sizeof(u32)==4 );

 #if SQLITE_BYTEORDER==1234 && GCC_VERSION>=4003000

@@ -201245,7 +202704,7 @@ static void rtreeNonleafConstraint(
   assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE

       || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_TRUE

       || p->op==RTREE_FALSE );

-  assert( ((((char*)pCellData) - (char*)0)&3)==0 );  /* 4-byte aligned */

+  assert( (((sqlite3_uint64)pCellData)&3)==0 );  /* 4-byte aligned */

   switch( p->op ){

     case RTREE_TRUE:  return;   /* Always satisfied */

     case RTREE_FALSE: break;    /* Never satisfied */

@@ -201298,7 +202757,7 @@ static void rtreeLeafConstraint(
       || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_TRUE

       || p->op==RTREE_FALSE );

   pCellData += 8 + p->iCoord*4;

-  assert( ((((char*)pCellData) - (char*)0)&3)==0 );  /* 4-byte aligned */

+  assert( (((sqlite3_uint64)pCellData)&3)==0 );  /* 4-byte aligned */

   RTREE_DECODE_COORD(eInt, pCellData, xN);

   switch( p->op ){

     case RTREE_TRUE:  return;   /* Always satisfied */

@@ -204670,7 +206129,7 @@ static GeoPoly *geopolyFuncParam(
   int nByte;

   testcase( pCtx==0 );

   if( sqlite3_value_type(pVal)==SQLITE_BLOB

-   && (nByte = sqlite3_value_bytes(pVal))>=(4+6*sizeof(GeoCoord))

+   && (nByte = sqlite3_value_bytes(pVal))>=(int)(4+6*sizeof(GeoCoord))

   ){

     const unsigned char *a = sqlite3_value_blob(pVal);

     int nVertex;

@@ -204728,6 +206187,7 @@ static void geopolyBlobFunc(
   sqlite3_value **argv

 ){

   GeoPoly *p = geopolyFuncParam(context, argv[0], 0);

+  (void)argc;

   if( p ){

     sqlite3_result_blob(context, p->hdr,

        4+8*p->nVertex, SQLITE_TRANSIENT);

@@ -204747,6 +206207,7 @@ static void geopolyJsonFunc(
   sqlite3_value **argv

 ){

   GeoPoly *p = geopolyFuncParam(context, argv[0], 0);

+  (void)argc;

   if( p ){

     sqlite3 *db = sqlite3_context_db_handle(context);

     sqlite3_str *x = sqlite3_str_new(db);

@@ -204828,6 +206289,7 @@ static void geopolyXformFunc(
   double F = sqlite3_value_double(argv[6]);

   GeoCoord x1, y1, x0, y0;

   int ii;

+  (void)argc;

   if( p ){

     for(ii=0; ii<p->nVertex; ii++){

       x0 = GeoX(p,ii);

@@ -204878,6 +206340,7 @@ static void geopolyAreaFunc(
   sqlite3_value **argv

 ){

   GeoPoly *p = geopolyFuncParam(context, argv[0], 0);

+  (void)argc;

   if( p ){

     sqlite3_result_double(context, geopolyArea(p));

     sqlite3_free(p);

@@ -204903,6 +206366,7 @@ static void geopolyCcwFunc(
   sqlite3_value **argv

 ){

   GeoPoly *p = geopolyFuncParam(context, argv[0], 0);

+  (void)argc;

   if( p ){

     if( geopolyArea(p)<0.0 ){

       int ii, jj;

@@ -204957,6 +206421,7 @@ static void geopolyRegularFunc(
   int n = sqlite3_value_int(argv[3]);

   int i;

   GeoPoly *p;

+  (void)argc;

 

   if( n<3 || r<=0.0 ) return;

   if( n>1000 ) n = 1000;

@@ -205066,6 +206531,7 @@ static void geopolyBBoxFunc(
   sqlite3_value **argv

 ){

   GeoPoly *p = geopolyBBox(context, argv[0], 0, 0);

+  (void)argc;

   if( p ){

     sqlite3_result_blob(context, p->hdr,

        4+8*p->nVertex, SQLITE_TRANSIENT);

@@ -205093,6 +206559,7 @@ static void geopolyBBoxStep(
 ){

   RtreeCoord a[4];

   int rc = SQLITE_OK;

+  (void)argc;

   (void)geopolyBBox(context, argv[0], a, &rc);

   if( rc==SQLITE_OK ){

     GeoBBox *pBBox;

@@ -205181,6 +206648,8 @@ static void geopolyContainsPointFunc(
   int v = 0;

   int cnt = 0;

   int ii;

+  (void)argc;

+

   if( p1==0 ) return;

   for(ii=0; ii<p1->nVertex-1; ii++){

     v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),

@@ -205220,6 +206689,7 @@ static void geopolyWithinFunc(
 ){

   GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0);

   GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0);

+  (void)argc;

   if( p1 && p2 ){

     int x = geopolyOverlap(p1, p2);

     if( x<0 ){

@@ -205550,6 +207020,7 @@ static void geopolyOverlapFunc(
 ){

   GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0);

   GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0);

+  (void)argc;

   if( p1 && p2 ){

     int x = geopolyOverlap(p1, p2);

     if( x<0 ){

@@ -205570,8 +207041,12 @@ static void geopolyDebugFunc(
   int argc,

   sqlite3_value **argv

 ){

+  (void)context;

+  (void)argc;

 #ifdef GEOPOLY_ENABLE_DEBUG

   geo_debug = sqlite3_value_int(argv[0]);

+#else

+  (void)argv;

 #endif

 }

 

@@ -205599,6 +207074,7 @@ static int geopolyInit(
   sqlite3_str *pSql;

   char *zSql;

   int ii;

+  (void)pAux;

 

   sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);

 

@@ -205715,6 +207191,7 @@ static int geopolyFilter(
   RtreeNode *pRoot = 0;

   int rc = SQLITE_OK;

   int iCell = 0;

+  (void)idxStr;

 

   rtreeReference(pRtree);

 

@@ -205841,6 +207318,7 @@ static int geopolyBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   int iRowidTerm = -1;

   int iFuncTerm = -1;

   int idxNum = 0;

+  (void)tab;

 

   for(ii=0; ii<pIdxInfo->nConstraint; ii++){

     struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii];

@@ -206087,6 +207565,8 @@ static int geopolyFindFunction(
   void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),

   void **ppArg

 ){

+  (void)pVtab;

+  (void)nArg;

   if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){

     *pxFunc = geopolyOverlapFunc;

     *ppArg = 0;

@@ -206156,7 +207636,7 @@ static int sqlite3_geopoly_init(sqlite3 *db){
   } aAgg[] = {

      { geopolyBBoxStep, geopolyBBoxFinal, "geopoly_group_bbox"    },

   };

-  int i;

+  unsigned int i;

   for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){

     int enc;

     if( aFunc[i].bPure ){

@@ -207377,7 +208857,7 @@ SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(
 ** The order of the columns in the data_% table does not matter.

 **

 ** Instead of a regular table, the RBU database may also contain virtual

-** tables or view named using the data_<target> naming scheme.

+** tables or views named using the data_<target> naming scheme.

 **

 ** Instead of the plain data_<target> naming scheme, RBU database tables

 ** may also be named data<integer>_<target>, where <integer> is any sequence

@@ -207390,7 +208870,7 @@ SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(
 **

 ** If the target database table is a virtual table or a table that has no

 ** PRIMARY KEY declaration, the data_% table must also contain a column

-** named "rbu_rowid". This column is mapped to the tables implicit primary

+** named "rbu_rowid". This column is mapped to the table's implicit primary

 ** key column - "rowid". Virtual tables for which the "rowid" column does

 ** not function like a primary key value cannot be updated using RBU. For

 ** example, if the target db contains either of the following:

@@ -210856,11 +212336,11 @@ static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){
   **     no-ops. These locks will not be released until the connection

   **     is closed.

   **

-  **   * Attempting to xSync() the database file causes an SQLITE_INTERNAL

+  **   * Attempting to xSync() the database file causes an SQLITE_NOTICE

   **     error.

   **

   ** As a result, unless an error (i.e. OOM or SQLITE_BUSY) occurs, the

-  ** checkpoint below fails with SQLITE_INTERNAL, and leaves the aFrame[]

+  ** checkpoint below fails with SQLITE_NOTICE, and leaves the aFrame[]

   ** array populated with a set of (frame -> page) mappings. Because the

   ** WRITER, CHECKPOINT and READ0 locks are still held, it is safe to copy

   ** data from the wal file into the database file according to the

@@ -210870,7 +212350,7 @@ static void rbuSetupCheckpoint(sqlite3rbu *p, RbuState *pState){
     int rc2;

     p->eStage = RBU_STAGE_CAPTURE;

     rc2 = sqlite3_exec(p->dbMain, "PRAGMA main.wal_checkpoint=restart", 0, 0,0);

-    if( rc2!=SQLITE_INTERNAL ) p->rc = rc2;

+    if( rc2!=SQLITE_NOTICE ) p->rc = rc2;

   }

 

   if( p->rc==SQLITE_OK && p->nFrame>0 ){

@@ -210916,7 +212396,7 @@ static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){
 

   if( pRbu->mLock!=mReq ){

     pRbu->rc = SQLITE_BUSY;

-    return SQLITE_INTERNAL;

+    return SQLITE_NOTICE_RBU;

   }

 

   pRbu->pgsz = iAmt;

@@ -211655,7 +213135,8 @@ static void rbuSetupOal(sqlite3rbu *p, RbuState *pState){
 static void rbuDeleteOalFile(sqlite3rbu *p){

   char *zOal = rbuMPrintf(p, "%s-oal", p->zTarget);

   if( zOal ){

-    sqlite3_vfs *pVfs = sqlite3_vfs_find(0);

+    sqlite3_vfs *pVfs = 0;

+    sqlite3_file_control(p->dbMain, "main", SQLITE_FCNTL_VFS_POINTER, &pVfs);

     assert( pVfs && p->rc==SQLITE_OK && p->zErrmsg==0 );

     pVfs->xDelete(pVfs, zOal, 0);

     sqlite3_free(zOal);

@@ -212303,7 +213784,7 @@ SQLITE_API void sqlite3rbu_rename_handler(
 **     database file are recorded. xShmLock() calls to unlock the same

 **     locks are no-ops (so that once obtained, these locks are never

 **     relinquished). Finally, calls to xSync() on the target database

-**     file fail with SQLITE_INTERNAL errors.

+**     file fail with SQLITE_NOTICE errors.

 */

 

 static void rbuUnlockShm(rbu_file *p){

@@ -212412,9 +213893,12 @@ static int rbuVfsClose(sqlite3_file *pFile){
   sqlite3_free(p->zDel);

 

   if( p->openFlags & SQLITE_OPEN_MAIN_DB ){

+    const sqlite3_io_methods *pMeth = p->pReal->pMethods;

     rbuMainlistRemove(p);

     rbuUnlockShm(p);

-    p->pReal->pMethods->xShmUnmap(p->pReal, 0);

+    if( pMeth->iVersion>1 && pMeth->xShmUnmap ){

+      pMeth->xShmUnmap(p->pReal, 0);

+    }

   }

   else if( (p->openFlags & SQLITE_OPEN_DELETEONCLOSE) && p->pRbu ){

     rbuUpdateTempSize(p, 0);

@@ -212582,7 +214066,7 @@ static int rbuVfsSync(sqlite3_file *pFile, int flags){
   rbu_file *p = (rbu_file *)pFile;

   if( p->pRbu && p->pRbu->eStage==RBU_STAGE_CAPTURE ){

     if( p->openFlags & SQLITE_OPEN_MAIN_DB ){

-      return SQLITE_INTERNAL;

+      return SQLITE_NOTICE_RBU;

     }

     return SQLITE_OK;

   }

@@ -212873,6 +214357,25 @@ static int rbuVfsOpen(
     rbuVfsShmUnmap,               /* xShmUnmap */

     0, 0                          /* xFetch, xUnfetch */

   };

+  static sqlite3_io_methods rbuvfs_io_methods1 = {

+    1,                            /* iVersion */

+    rbuVfsClose,                  /* xClose */

+    rbuVfsRead,                   /* xRead */

+    rbuVfsWrite,                  /* xWrite */

+    rbuVfsTruncate,               /* xTruncate */

+    rbuVfsSync,                   /* xSync */

+    rbuVfsFileSize,               /* xFileSize */

+    rbuVfsLock,                   /* xLock */

+    rbuVfsUnlock,                 /* xUnlock */

+    rbuVfsCheckReservedLock,      /* xCheckReservedLock */

+    rbuVfsFileControl,            /* xFileControl */

+    rbuVfsSectorSize,             /* xSectorSize */

+    rbuVfsDeviceCharacteristics,  /* xDeviceCharacteristics */

+    0, 0, 0, 0, 0, 0

+  };

+

+

+

   rbu_vfs *pRbuVfs = (rbu_vfs*)pVfs;

   sqlite3_vfs *pRealVfs = pRbuVfs->pRealVfs;

   rbu_file *pFd = (rbu_file *)pFile;

@@ -212927,10 +214430,15 @@ static int rbuVfsOpen(
     rc = pRealVfs->xOpen(pRealVfs, zOpen, pFd->pReal, oflags, pOutFlags);

   }

   if( pFd->pReal->pMethods ){

+    const sqlite3_io_methods *pMeth = pFd->pReal->pMethods;

     /* The xOpen() operation has succeeded. Set the sqlite3_file.pMethods

     ** pointer and, if the file is a main database file, link it into the

     ** mutex protected linked list of all such files.  */

-    pFile->pMethods = &rbuvfs_io_methods;

+    if( pMeth->iVersion<2 || pMeth->xShmLock==0 ){

+      pFile->pMethods = &rbuvfs_io_methods1;

+    }else{

+      pFile->pMethods = &rbuvfs_io_methods;

+    }

     if( flags & SQLITE_OPEN_MAIN_DB ){

       rbuMainlistAdd(pFd);

     }

@@ -213363,6 +214871,7 @@ static int statConnect(
   StatTable *pTab = 0;

   int rc = SQLITE_OK;

   int iDb;

+  (void)pAux;

 

   if( argc>=4 ){

     Token nm;

@@ -213416,6 +214925,7 @@ static int statBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
   int iSchema = -1;

   int iName = -1;

   int iAgg = -1;

+  (void)tab;

 

   /* Look for a valid schema=? constraint.  If found, change the idxNum to

   ** 1 and request the value of that constraint be sent to xFilter.  And

@@ -213941,6 +215451,8 @@ static int statFilter(
   int iArg = 0;           /* Count of argv[] parameters used so far */

   int rc = SQLITE_OK;     /* Result of this operation */

   const char *zName = 0;  /* Only provide analysis of this table */

+  (void)argc;

+  (void)idxStr;

 

   statResetCsr(pCsr);

   sqlite3_finalize(pCsr->pStmt);

@@ -214024,16 +215536,16 @@ static int statColumn(
       }

       break;

     case 4:            /* ncell */

-      sqlite3_result_int(ctx, pCsr->nCell);

+      sqlite3_result_int64(ctx, pCsr->nCell);

       break;

     case 5:            /* payload */

-      sqlite3_result_int(ctx, pCsr->nPayload);

+      sqlite3_result_int64(ctx, pCsr->nPayload);

       break;

     case 6:            /* unused */

-      sqlite3_result_int(ctx, pCsr->nUnused);

+      sqlite3_result_int64(ctx, pCsr->nUnused);

       break;

     case 7:            /* mx_payload */

-      sqlite3_result_int(ctx, pCsr->nMxPayload);

+      sqlite3_result_int64(ctx, pCsr->nMxPayload);

       break;

     case 8:            /* pgoffset */

       if( !pCsr->isAgg ){

@@ -214041,7 +215553,7 @@ static int statColumn(
       }

       break;

     case 9:            /* pgsize */

-      sqlite3_result_int(ctx, pCsr->szPage);

+      sqlite3_result_int64(ctx, pCsr->szPage);

       break;

     case 10: {         /* schema */

       sqlite3 *db = sqlite3_context_db_handle(ctx);

@@ -214175,6 +215687,10 @@ static int dbpageConnect(
 ){

   DbpageTable *pTab = 0;

   int rc = SQLITE_OK;

+  (void)pAux;

+  (void)argc;

+  (void)argv;

+  (void)pzErr;

 

   sqlite3_vtab_config(db, SQLITE_VTAB_DIRECTONLY);

   rc = sqlite3_declare_vtab(db,

@@ -214213,6 +215729,7 @@ static int dbpageDisconnect(sqlite3_vtab *pVtab){
 static int dbpageBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){

   int i;

   int iPlan = 0;

+  (void)tab;

 

   /* If there is a schema= constraint, it must be honored.  Report a

   ** ridiculously large estimated cost if the schema= constraint is

@@ -214328,6 +215845,8 @@ static int dbpageFilter(
   sqlite3 *db = pTab->db;

   Btree *pBt;

 

+  (void)idxStr;

+

   /* Default setting is no rows of result */

   pCsr->pgno = 1;

   pCsr->mxPgno = 0;

@@ -214342,7 +215861,7 @@ static int dbpageFilter(
     pCsr->iDb = 0;

   }

   pBt = db->aDb[pCsr->iDb].pBt;

-  if( pBt==0 ) return SQLITE_OK;

+  if( NEVER(pBt==0) ) return SQLITE_OK;

   pCsr->pPager = sqlite3BtreePager(pBt);

   pCsr->szPage = sqlite3BtreeGetPageSize(pBt);

   pCsr->mxPgno = sqlite3BtreeLastPage(pBt);

@@ -214423,6 +215942,7 @@ static int dbpageUpdate(
   Pager *pPager;

   int szPage;

 

+  (void)pRowid;

   if( pTab->db->flags & SQLITE_Defensive ){

     zErr = "read-only";

     goto update_fail;

@@ -214432,18 +215952,20 @@ static int dbpageUpdate(
     goto update_fail;

   }

   pgno = sqlite3_value_int(argv[0]);

-  if( (Pgno)sqlite3_value_int(argv[1])!=pgno ){

+  if( sqlite3_value_type(argv[0])==SQLITE_NULL

+   || (Pgno)sqlite3_value_int(argv[1])!=pgno

+  ){

     zErr = "cannot insert";

     goto update_fail;

   }

   zSchema = (const char*)sqlite3_value_text(argv[4]);

-  iDb = zSchema ? sqlite3FindDbName(pTab->db, zSchema) : -1;

-  if( iDb<0 ){

+  iDb = ALWAYS(zSchema) ? sqlite3FindDbName(pTab->db, zSchema) : -1;

+  if( NEVER(iDb<0) ){

     zErr = "no such schema";

     goto update_fail;

   }

   pBt = pTab->db->aDb[iDb].pBt;

-  if( pgno<1 || pBt==0 || pgno>sqlite3BtreeLastPage(pBt) ){

+  if( NEVER(pgno<1) || NEVER(pBt==0) || NEVER(pgno>sqlite3BtreeLastPage(pBt)) ){

     zErr = "bad page number";

     goto update_fail;

   }

@@ -214482,12 +216004,11 @@ static int dbpageBegin(sqlite3_vtab *pVtab){
   DbpageTable *pTab = (DbpageTable *)pVtab;

   sqlite3 *db = pTab->db;

   int i;

-  int rc = SQLITE_OK;

-  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){

+  for(i=0; i<db->nDb; i++){

     Btree *pBt = db->aDb[i].pBt;

-    if( pBt ) rc = sqlite3BtreeBeginTrans(pBt, 1, 0);

+    if( pBt ) (void)sqlite3BtreeBeginTrans(pBt, 1, 0);

   }

-  return rc;

+  return SQLITE_OK;

 }

 

 

@@ -216030,6 +217551,8 @@ static void xPreUpdate(
   int nDb = sqlite3Strlen30(zDb);

 

   assert( sqlite3_mutex_held(db->mutex) );

+  (void)iKey1;

+  (void)iKey2;

 

   for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){

     SessionTable *pTab;

@@ -216106,6 +217629,7 @@ static int sessionDiffCount(void *pCtx){
   return p->nOldOff ? p->nOldOff : sqlite3_column_count(p->pStmt);

 }

 static int sessionDiffDepth(void *pCtx){

+  (void)pCtx;

   return 0;

 }

 

@@ -216179,7 +217703,6 @@ static char *sessionExprCompareOther(
 }

 

 static char *sessionSelectFindNew(

-  int nCol,

   const char *zDb1,      /* Pick rows in this db only */

   const char *zDb2,      /* But not in this one */

   const char *zTbl,      /* Table name */

@@ -216203,7 +217726,7 @@ static int sessionDiffFindNew(
   char *zExpr

 ){

   int rc = SQLITE_OK;

-  char *zStmt = sessionSelectFindNew(pTab->nCol, zDb1, zDb2, pTab->zName,zExpr);

+  char *zStmt = sessionSelectFindNew(zDb1, zDb2, pTab->zName,zExpr);

 

   if( zStmt==0 ){

     rc = SQLITE_NOMEM;

@@ -218720,7 +220243,6 @@ static int sessionBindRow(
 ** UPDATE, bind values from the old.* record.

 */

 static int sessionSeekToRow(

-  sqlite3 *db,                    /* Database handle */

   sqlite3_changeset_iter *pIter,  /* Changeset iterator */

   u8 *abPK,                       /* Primary key flags array */

   sqlite3_stmt *pSelect           /* SELECT statement from sessionSelectRow() */

@@ -218850,7 +220372,7 @@ static int sessionConflictHandler(
 

   /* Bind the new.* PRIMARY KEY values to the SELECT statement. */

   if( pbReplace ){

-    rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);

+    rc = sessionSeekToRow(pIter, p->abPK, p->pSelect);

   }else{

     rc = SQLITE_OK;

   }

@@ -219024,7 +220546,7 @@ static int sessionApplyOneOp(
       /* Check if there is a conflicting row. For sqlite_stat1, this needs

       ** to be done using a SELECT, as there is no PRIMARY KEY in the

       ** database schema to throw an exception if a duplicate is inserted.  */

-      rc = sessionSeekToRow(p->db, pIter, p->abPK, p->pSelect);

+      rc = sessionSeekToRow(pIter, p->abPK, p->pSelect);

       if( rc==SQLITE_ROW ){

         rc = SQLITE_CONSTRAINT;

         sqlite3_reset(p->pSelect);

@@ -225674,6 +227196,19 @@ static int sqlite3Fts5ExprNew(
 }

 

 /*

+** Assuming that buffer z is at least nByte bytes in size and contains a

+** valid utf-8 string, return the number of characters in the string.

+*/

+static int fts5ExprCountChar(const char *z, int nByte){

+  int nRet = 0;

+  int ii;

+  for(ii=0; ii<nByte; ii++){

+    if( (z[ii] & 0xC0)!=0x80 ) nRet++;

+  }

+  return nRet;

+}

+

+/*

 ** This function is only called when using the special 'trigram' tokenizer.

 ** Argument zText contains the text of a LIKE or GLOB pattern matched

 ** against column iCol. This function creates and compiles an FTS5 MATCH

@@ -225710,7 +227245,8 @@ static int sqlite3Fts5ExprPattern(
       if( i==nText

        || zText[i]==aSpec[0] || zText[i]==aSpec[1] || zText[i]==aSpec[2]

       ){

-        if( i-iFirst>=3 ){

+

+        if( fts5ExprCountChar(&zText[iFirst], i-iFirst)>=3 ){

           int jj;

           zExpr[iOut++] = '"';

           for(jj=iFirst; jj<i; jj++){

@@ -229071,6 +230607,8 @@ static void sqlite3Fts5HashScanEntry(
 # error "FTS5_MAX_PREFIX_INDEXES is too large"

 #endif

 

+#define FTS5_MAX_LEVEL 64

+

 /*

 ** Details:

 **

@@ -233785,10 +235323,10 @@ static Fts5Structure *fts5IndexOptimizeStruct(
   if( pNew ){

     Fts5StructureLevel *pLvl;

     nByte = nSeg * sizeof(Fts5StructureSegment);

-    pNew->nLevel = pStruct->nLevel+1;

+    pNew->nLevel = MIN(pStruct->nLevel+1, FTS5_MAX_LEVEL);

     pNew->nRef = 1;

     pNew->nWriteCounter = pStruct->nWriteCounter;

-    pLvl = &pNew->aLevel[pStruct->nLevel];

+    pLvl = &pNew->aLevel[pNew->nLevel-1];

     pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(&p->rc, nByte);

     if( pLvl->aSeg ){

       int iLvl, iSeg;

@@ -234090,7 +235628,7 @@ static void fts5MergePrefixLists(
   /* Initialize a doclist-iterator for each input buffer. Arrange them in

   ** a linked-list starting at pHead in ascending order of rowid. Avoid

   ** linking any iterators already at EOF into the linked list at all. */

-  assert( nBuf+1<=sizeof(aMerger)/sizeof(aMerger[0]) );

+  assert( nBuf+1<=(int)(sizeof(aMerger)/sizeof(aMerger[0])) );

   memset(aMerger, 0, sizeof(PrefixMerger)*(nBuf+1));

   pHead = &aMerger[nBuf];

   fts5DoclistIterInit(p1, &pHead->iter);

@@ -238633,7 +240171,7 @@ static void fts5SourceIdFunc(
 ){

   assert( nArg==0 );

   UNUSED_PARAM2(nArg, apUnused);

-  sqlite3_result_text(pCtx, "fts5: 2022-12-28 14:03:47 df5c253c0b3dd24916e4ec7cf77d3db5294cc9fd45ae7b9c5e82ad8197f38a24", -1, SQLITE_TRANSIENT);

+  sqlite3_result_text(pCtx, "fts5: 2023-02-21 18:09:37 05941c2a04037fc3ed2ffae11f5d2260706f89431f463518740f72ada350866d", -1, SQLITE_TRANSIENT);

 }

 

 /*

@@ -238706,7 +240244,9 @@ static int fts5Init(sqlite3 *db){
     }

     if( rc==SQLITE_OK ){

       rc = sqlite3_create_function(

-          db, "fts5_source_id", 0, SQLITE_UTF8, p, fts5SourceIdFunc, 0, 0

+          db, "fts5_source_id", 0,

+          SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS,

+          p, fts5SourceIdFunc, 0, 0

       );

     }

   }

@@ -243371,6 +244911,10 @@ static int stmtConnect(
 #define STMT_COLUMN_MEM    10   /* SQLITE_STMTSTATUS_MEMUSED */

 

 

+  (void)pAux;

+  (void)argc;

+  (void)argv;

+  (void)pzErr;

   rc = sqlite3_declare_vtab(db,

      "CREATE TABLE x(sql,ncol,ro,busy,nscan,nsort,naidx,nstep,"

                     "reprep,run,mem)");

@@ -243490,6 +245034,10 @@ static int stmtFilter(
   sqlite3_int64 iRowid = 1;

   StmtRow **ppRow = 0;

 

+  (void)idxNum;

+  (void)idxStr;

+  (void)argc;

+  (void)argv;

   stmtCsrReset(pCur);

   ppRow = &pCur->pRow;

   for(p=sqlite3_next_stmt(pCur->db, 0); p; p=sqlite3_next_stmt(pCur->db, p)){

@@ -243545,6 +245093,7 @@ static int stmtBestIndex(
   sqlite3_vtab *tab,

   sqlite3_index_info *pIdxInfo

 ){

+  (void)tab;

   pIdxInfo->estimatedCost = (double)500;

   pIdxInfo->estimatedRows = 500;

   return SQLITE_OK;

diff --git a/libs/sqlite3/src/sqlite3.h b/libs/sqlite3/src/sqlite3.h
index b4543f5fca..ce59a965b2 100644
--- a/libs/sqlite3/src/sqlite3.h
+++ b/libs/sqlite3/src/sqlite3.h
@@ -146,9 +146,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],

 ** [sqlite_version()] and [sqlite_source_id()].

 */

-#define SQLITE_VERSION        "3.40.1"

-#define SQLITE_VERSION_NUMBER 3040001

-#define SQLITE_SOURCE_ID      "2022-12-28 14:03:47 df5c253c0b3dd24916e4ec7cf77d3db5294cc9fd45ae7b9c5e82ad8197f38a24"

+#define SQLITE_VERSION        "3.41.0"

+#define SQLITE_VERSION_NUMBER 3041000

+#define SQLITE_SOURCE_ID      "2023-02-21 18:09:37 05941c2a04037fc3ed2ffae11f5d2260706f89431f463518740f72ada350866d"

 

 /*

 ** CAPI3REF: Run-Time Library Version Numbers

@@ -563,6 +563,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_CONSTRAINT_DATATYPE     (SQLITE_CONSTRAINT |(12<<8))

 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))

 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))

+#define SQLITE_NOTICE_RBU              (SQLITE_NOTICE | (3<<8))

 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))

 #define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))

 #define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))

@@ -1175,7 +1176,6 @@ struct sqlite3_io_methods {
 ** in wal mode after the client has finished copying pages from the wal

 ** file to the database file, but before the *-shm file is updated to

 ** record the fact that the pages have been checkpointed.

-** </ul>

 **

 ** <li>[[SQLITE_FCNTL_EXTERNAL_READER]]

 ** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect

@@ -1188,16 +1188,16 @@ struct sqlite3_io_methods {
 ** the database is not a wal-mode db, or if there is no such connection in any

 ** other process. This opcode cannot be used to detect transactions opened

 ** by clients within the current process, only within other processes.

-** </ul>

 **

 ** <li>[[SQLITE_FCNTL_CKSM_FILE]]

-** Used by the cksmvfs VFS module only.

+** The [SQLITE_FCNTL_CKSM_FILE] opcode is for use interally by the

+** [checksum VFS shim] only.

 **

 ** <li>[[SQLITE_FCNTL_RESET_CACHE]]

 ** If there is currently no transaction open on the database, and the

-** database is not a temp db, then this file-control purges the contents

-** of the in-memory page cache. If there is an open transaction, or if

-** the db is a temp-db, it is a no-op, not an error.

+** database is not a temp db, then the [SQLITE_FCNTL_RESET_CACHE] file-control

+** purges the contents of the in-memory page cache. If there is an open

+** transaction, or if the db is a temp-db, this opcode is a no-op, not an error.

 ** </ul>

 */

 #define SQLITE_FCNTL_LOCKSTATE               1

@@ -2184,7 +2184,7 @@ struct sqlite3_mem_methods {
 ** configuration for a database connection can only be changed when that

 ** connection is not currently using lookaside memory, or in other words

 ** when the "current value" returned by

-** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero.

+** [sqlite3_db_status](D,[SQLITE_DBSTATUS_LOOKASIDE_USED],...) is zero.

 ** Any attempt to change the lookaside memory configuration when lookaside

 ** memory is in use leaves the configuration unchanged and returns

 ** [SQLITE_BUSY].)^</dd>

@@ -2334,8 +2334,12 @@ struct sqlite3_mem_methods {
 ** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);

 ** </ol>

 ** Because resetting a database is destructive and irreversible, the

-** process requires the use of this obscure API and multiple steps to help

-** ensure that it does not happen by accident.

+** process requires the use of this obscure API and multiple steps to

+** help ensure that it does not happen by accident. Because this

+** feature must be capable of resetting corrupt databases, and

+** shutting down virtual tables may require access to that corrupt

+** storage, the library must abandon any installed virtual tables

+** without calling their xDestroy() methods.

 **

 ** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>

 ** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the

@@ -2674,8 +2678,12 @@ SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*);
 ** ^A call to sqlite3_interrupt(D) that occurs when there are no running

 ** SQL statements is a no-op and has no effect on SQL statements

 ** that are started after the sqlite3_interrupt() call returns.

+**

+** ^The [sqlite3_is_interrupted(D)] interface can be used to determine whether

+** or not an interrupt is currently in effect for [database connection] D.

 */

 SQLITE_API void sqlite3_interrupt(sqlite3*);

+SQLITE_API int sqlite3_is_interrupted(sqlite3*);

 

 /*

 ** CAPI3REF: Determine If An SQL Statement Is Complete

@@ -3293,8 +3301,8 @@ SQLITE_API SQLITE_DEPRECATED void *sqlite3_profile(sqlite3*,
 ** <dd>^An SQLITE_TRACE_PROFILE callback provides approximately the same

 ** information as is provided by the [sqlite3_profile()] callback.

 ** ^The P argument is a pointer to the [prepared statement] and the

-** X argument points to a 64-bit integer which is the estimated of

-** the number of nanosecond that the prepared statement took to run.

+** X argument points to a 64-bit integer which is approximately

+** the number of nanoseconds that the prepared statement took to run.

 ** ^The SQLITE_TRACE_PROFILE callback is invoked when the statement finishes.

 **

 ** [[SQLITE_TRACE_ROW]] <dt>SQLITE_TRACE_ROW</dt>

@@ -3357,7 +3365,7 @@ SQLITE_API int sqlite3_trace_v2(
 **

 ** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback

 ** function X to be invoked periodically during long running calls to

-** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for

+** [sqlite3_step()] and [sqlite3_prepare()] and similar for

 ** database connection D.  An example use for this

 ** interface is to keep a GUI updated during a large query.

 **

@@ -3382,6 +3390,13 @@ SQLITE_API int sqlite3_trace_v2(
 ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their

 ** database connections for the meaning of "modify" in this paragraph.

 **

+** The progress handler callback would originally only be invoked from the

+** bytecode engine.  It still might be invoked during [sqlite3_prepare()]

+** and similar because those routines might force a reparse of the schema

+** which involves running the bytecode engine.  However, beginning with

+** SQLite version 3.41.0, the progress handler callback might also be

+** invoked directly from [sqlite3_prepare()] while analyzing and generating

+** code for complex queries.

 */

 SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);

 

@@ -3418,13 +3433,18 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **

 ** <dl>

 ** ^(<dt>[SQLITE_OPEN_READONLY]</dt>

-** <dd>The database is opened in read-only mode.  If the database does not

-** already exist, an error is returned.</dd>)^

+** <dd>The database is opened in read-only mode.  If the database does

+** not already exist, an error is returned.</dd>)^

 **

 ** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>

-** <dd>The database is opened for reading and writing if possible, or reading

-** only if the file is write protected by the operating system.  In either

-** case the database must already exist, otherwise an error is returned.</dd>)^

+** <dd>The database is opened for reading and writing if possible, or

+** reading only if the file is write protected by the operating

+** system.  In either case the database must already exist, otherwise

+** an error is returned.  For historical reasons, if opening in

+** read-write mode fails due to OS-level permissions, an attempt is

+** made to open it in read-only mode. [sqlite3_db_readonly()] can be

+** used to determine whether the database is actually

+** read-write.</dd>)^

 **

 ** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>

 ** <dd>The database is opened for reading and writing, and is created if

@@ -5405,10 +5425,21 @@ SQLITE_API int sqlite3_create_window_function(
 ** from top-level SQL, and cannot be used in VIEWs or TRIGGERs nor in

 ** schema structures such as [CHECK constraints], [DEFAULT clauses],

 ** [expression indexes], [partial indexes], or [generated columns].

-** The SQLITE_DIRECTONLY flags is a security feature which is recommended

-** for all [application-defined SQL functions], and especially for functions

-** that have side-effects or that could potentially leak sensitive

-** information.

+** <p>

+** The SQLITE_DIRECTONLY flag is recommended for any

+** [application-defined SQL function]

+** that has side-effects or that could potentially leak sensitive information.

+** This will prevent attacks in which an application is tricked

+** into using a database file that has had its schema surreptiously

+** modified to invoke the application-defined function in ways that are

+** harmful.

+** <p>

+** Some people say it is good practice to set SQLITE_DIRECTONLY on all

+** [application-defined SQL functions], regardless of whether or not they

+** are security sensitive, as doing so prevents those functions from being used

+** inside of the database schema, and thus ensures that the database

+** can be inspected and modified using generic tools (such as the [CLI])

+** that do not have access to the application-defined functions.

 ** </dd>

 **

 ** [[SQLITE_INNOCUOUS]] <dt>SQLITE_INNOCUOUS</dt><dd>

@@ -5549,16 +5580,6 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** then the conversion is performed.  Otherwise no conversion occurs.

 ** The [SQLITE_INTEGER | datatype] after conversion is returned.)^

 **

-** ^(The sqlite3_value_encoding(X) interface returns one of [SQLITE_UTF8],

-** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current encoding

-** of the value X, assuming that X has type TEXT.)^  If sqlite3_value_type(X)

-** returns something other than SQLITE_TEXT, then the return value from

-** sqlite3_value_encoding(X) is meaningless.  ^Calls to

-** sqlite3_value_text(X), sqlite3_value_text16(X), sqlite3_value_text16be(X),

-** sqlite3_value_text16le(X), sqlite3_value_bytes(X), or

-** sqlite3_value_bytes16(X) might change the encoding of the value X and

-** thus change the return from subsequent calls to sqlite3_value_encoding(X).

-**

 ** ^Within the [xUpdate] method of a [virtual table], the

 ** sqlite3_value_nochange(X) interface returns true if and only if

 ** the column corresponding to X is unchanged by the UPDATE operation

@@ -5623,6 +5644,27 @@ SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);

 SQLITE_API int sqlite3_value_nochange(sqlite3_value*);

 SQLITE_API int sqlite3_value_frombind(sqlite3_value*);

+

+/*

+** CAPI3REF: Report the internal text encoding state of an sqlite3_value object

+** METHOD: sqlite3_value

+**

+** ^(The sqlite3_value_encoding(X) interface returns one of [SQLITE_UTF8],

+** [SQLITE_UTF16BE], or [SQLITE_UTF16LE] according to the current text encoding

+** of the value X, assuming that X has type TEXT.)^  If sqlite3_value_type(X)

+** returns something other than SQLITE_TEXT, then the return value from

+** sqlite3_value_encoding(X) is meaningless.  ^Calls to

+** [sqlite3_value_text(X)], [sqlite3_value_text16(X)], [sqlite3_value_text16be(X)],

+** [sqlite3_value_text16le(X)], [sqlite3_value_bytes(X)], or

+** [sqlite3_value_bytes16(X)] might change the encoding of the value X and

+** thus change the return from subsequent calls to sqlite3_value_encoding(X).

+**

+** This routine is intended for used by applications that test and validate

+** the SQLite implementation.  This routine is inquiring about the opaque

+** internal state of an [sqlite3_value] object.  Ordinary applications should

+** not need to know what the internal state of an sqlite3_value object is and

+** hence should not need to use this interface.

+*/

 SQLITE_API int sqlite3_value_encoding(sqlite3_value*);

 

 /*

@@ -7004,15 +7046,6 @@ SQLITE_API int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void));
 SQLITE_API void sqlite3_reset_auto_extension(void);

 

 /*

-** The interface to the virtual-table mechanism is currently considered

-** to be experimental.  The interface might change in incompatible ways.

-** If this is a problem for you, do not use the interface at this time.

-**

-** When the virtual-table mechanism stabilizes, we will declare the

-** interface fixed, support it indefinitely, and remove this comment.

-*/

-

-/*

 ** Structures used by the virtual table interface

 */

 typedef struct sqlite3_vtab sqlite3_vtab;

@@ -7130,10 +7163,10 @@ struct sqlite3_module {
 ** when the omit flag is true there is no guarantee that the constraint will

 ** not be checked again using byte code.)^

 **

-** ^The idxNum and idxPtr values are recorded and passed into the

+** ^The idxNum and idxStr values are recorded and passed into the

 ** [xFilter] method.

-** ^[sqlite3_free()] is used to free idxPtr if and only if

-** needToFreeIdxPtr is true.

+** ^[sqlite3_free()] is used to free idxStr if and only if

+** needToFreeIdxStr is true.

 **

 ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in

 ** the correct order to satisfy the ORDER BY clause so that no separate

@@ -7253,7 +7286,7 @@ struct sqlite3_index_info {
 ** the [sqlite3_vtab_collation()] interface.  For most real-world virtual

 ** tables, the collating sequence of constraints does not matter (for example

 ** because the constraints are numeric) and so the sqlite3_vtab_collation()

-** interface is no commonly needed.

+** interface is not commonly needed.

 */

 #define SQLITE_INDEX_CONSTRAINT_EQ          2

 #define SQLITE_INDEX_CONSTRAINT_GT          4

@@ -7413,16 +7446,6 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
 SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);

 

 /*

-** The interface to the virtual-table mechanism defined above (back up

-** to a comment remarkably similar to this one) is currently considered

-** to be experimental.  The interface might change in incompatible ways.

-** If this is a problem for you, do not use the interface at this time.

-**

-** When the virtual-table mechanism stabilizes, we will declare the

-** interface fixed, support it indefinitely, and remove this comment.

-*/

-

-/*

 ** CAPI3REF: A Handle To An Open BLOB

 ** KEYWORDS: {BLOB handle} {BLOB handles}

 **

@@ -9625,7 +9648,7 @@ SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*);
 ** <li><p> Otherwise, "BINARY" is returned.

 ** </ol>

 */

-SQLITE_API SQLITE_EXPERIMENTAL const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

+SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

 

 /*

 ** CAPI3REF: Determine if a virtual table query is DISTINCT

@@ -9782,21 +9805,20 @@ SQLITE_API int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle);
 ** is undefined and probably harmful.

 **

 ** The X parameter in a call to sqlite3_vtab_in_first(X,P) or

-** sqlite3_vtab_in_next(X,P) must be one of the parameters to the

+** sqlite3_vtab_in_next(X,P) should be one of the parameters to the

 ** xFilter method which invokes these routines, and specifically

 ** a parameter that was previously selected for all-at-once IN constraint

 ** processing use the [sqlite3_vtab_in()] interface in the

 ** [xBestIndex|xBestIndex method].  ^(If the X parameter is not

 ** an xFilter argument that was selected for all-at-once IN constraint

-** processing, then these routines return [SQLITE_MISUSE])^ or perhaps

-** exhibit some other undefined or harmful behavior.

+** processing, then these routines return [SQLITE_ERROR].)^

 **

 ** ^(Use these routines to access all values on the right-hand side

 ** of the IN constraint using code like the following:

 **

 ** <blockquote><pre>

 ** &nbsp;  for(rc=sqlite3_vtab_in_first(pList, &pVal);

-** &nbsp;      rc==SQLITE_OK && pVal

+** &nbsp;      rc==SQLITE_OK && pVal;

 ** &nbsp;      rc=sqlite3_vtab_in_next(pList, &pVal)

 ** &nbsp;  ){

 ** &nbsp;    // do something with pVal

@@ -9894,6 +9916,10 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 ** managed by the prepared statement S and will be automatically freed when

 ** S is finalized.

 **

+** Not all values are available for all query elements. When a value is

+** not available, the output variable is set to -1 if the value is numeric,

+** or to NULL if it is a string (SQLITE_SCANSTAT_NAME).

+**

 ** <dl>

 ** [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>

 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be

@@ -9921,12 +9947,24 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 ** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]

 ** description for the X-th loop.

 **

-** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECT</dt>

+** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECTID</dt>

 ** <dd>^The "int" variable pointed to by the V parameter will be set to the

-** "select-id" for the X-th loop.  The select-id identifies which query or

-** subquery the loop is part of.  The main query has a select-id of zero.

-** The select-id is the same value as is output in the first column

-** of an [EXPLAIN QUERY PLAN] query.

+** id for the X-th query plan element. The id value is unique within the

+** statement. The select-id is the same value as is output in the first

+** column of an [EXPLAIN QUERY PLAN] query.

+**

+** [[SQLITE_SCANSTAT_PARENTID]] <dt>SQLITE_SCANSTAT_PARENTID</dt>

+** <dd>The "int" variable pointed to by the V parameter will be set to the

+** the id of the parent of the current query element, if applicable, or

+** to zero if the query element has no parent. This is the same value as

+** returned in the second column of an [EXPLAIN QUERY PLAN] query.

+**

+** [[SQLITE_SCANSTAT_NCYCLE]] <dt>SQLITE_SCANSTAT_NCYCLE</dt>

+** <dd>The sqlite3_int64 output value is set to the number of cycles,

+** according to the processor time-stamp counter, that elapsed while the

+** query element was being processed. This value is not available for

+** all query elements - if it is unavailable the output variable is

+** set to -1.

 ** </dl>

 */

 #define SQLITE_SCANSTAT_NLOOP    0

@@ -9935,12 +9973,14 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 #define SQLITE_SCANSTAT_NAME     3

 #define SQLITE_SCANSTAT_EXPLAIN  4

 #define SQLITE_SCANSTAT_SELECTID 5

+#define SQLITE_SCANSTAT_PARENTID 6

+#define SQLITE_SCANSTAT_NCYCLE   7

 

 /*

 ** CAPI3REF: Prepared Statement Scan Status

 ** METHOD: sqlite3_stmt

 **

-** This interface returns information about the predicted and measured

+** These interfaces return information about the predicted and measured

 ** performance for pStmt.  Advanced applications can use this

 ** interface to compare the predicted and the measured performance and

 ** issue warnings and/or rerun [ANALYZE] if discrepancies are found.

@@ -9951,19 +9991,25 @@ SQLITE_API int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **
 **

 ** The "iScanStatusOp" parameter determines which status information to return.

 ** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior

-** of this interface is undefined.

-** ^The requested measurement is written into a variable pointed to by

-** the "pOut" parameter.

-** Parameter "idx" identifies the specific loop to retrieve statistics for.

-** Loops are numbered starting from zero. ^If idx is out of range - less than

-** zero or greater than or equal to the total number of loops used to implement

-** the statement - a non-zero value is returned and the variable that pOut

-** points to is unchanged.

-**

-** ^Statistics might not be available for all loops in all statements. ^In cases

-** where there exist loops with no available statistics, this function behaves

-** as if the loop did not exist - it returns non-zero and leave the variable

-** that pOut points to unchanged.

+** of this interface is undefined. ^The requested measurement is written into

+** a variable pointed to by the "pOut" parameter.

+**

+** The "flags" parameter must be passed a mask of flags. At present only

+** one flag is defined - SQLITE_SCANSTAT_COMPLEX. If SQLITE_SCANSTAT_COMPLEX

+** is specified, then status information is available for all elements

+** of a query plan that are reported by "EXPLAIN QUERY PLAN" output. If

+** SQLITE_SCANSTAT_COMPLEX is not specified, then only query plan elements

+** that correspond to query loops (the "SCAN..." and "SEARCH..." elements of

+** the EXPLAIN QUERY PLAN output) are available. Invoking API

+** sqlite3_stmt_scanstatus() is equivalent to calling

+** sqlite3_stmt_scanstatus_v2() with a zeroed flags parameter.

+**

+** Parameter "idx" identifies the specific query element to retrieve statistics

+** for. Query elements are numbered starting from zero. A value of -1 may be

+** to query for statistics regarding the entire query. ^If idx is out of range

+** - less than -1 or greater than or equal to the total number of query

+** elements used to implement the statement - a non-zero value is returned and

+** the variable that pOut points to is unchanged.

 **

 ** See also: [sqlite3_stmt_scanstatus_reset()]

 */

@@ -9973,6 +10019,19 @@ SQLITE_API int sqlite3_stmt_scanstatus(
   int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */

   void *pOut                /* Result written here */

 );

+SQLITE_API int sqlite3_stmt_scanstatus_v2(

+  sqlite3_stmt *pStmt,      /* Prepared statement for which info desired */

+  int idx,                  /* Index of loop to report on */

+  int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */

+  int flags,                /* Mask of flags defined below */

+  void *pOut                /* Result written here */

+);

+

+/*

+** CAPI3REF: Prepared Statement Scan Status

+** KEYWORDS: {scan status flags}

+*/

+#define SQLITE_SCANSTAT_COMPLEX 0x0001

 

 /*

 ** CAPI3REF: Zero Scan-Status Counters

@@ -10063,6 +10122,10 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 ** function is not defined for operations on WITHOUT ROWID tables, or for

 ** DELETE operations on rowid tables.

 **

+** ^The sqlite3_preupdate_hook(D,C,P) function returns the P argument from

+** the previous call on the same [database connection] D, or NULL for

+** the first call on D.

+**

 ** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()],

 ** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces

 ** provide additional information about a preupdate event. These routines

@@ -10468,6 +10531,19 @@ SQLITE_API int sqlite3_deserialize(
 # undef double

 #endif

 

+#if defined(__wasi__)

+# undef SQLITE_WASI

+# define SQLITE_WASI 1

+# undef SQLITE_OMIT_WAL

+# define SQLITE_OMIT_WAL 1/* because it requires shared memory APIs */

+# ifndef SQLITE_OMIT_LOAD_EXTENSION

+#  define SQLITE_OMIT_LOAD_EXTENSION

+# endif

+# ifndef SQLITE_THREADSAFE

+#  define SQLITE_THREADSAFE 0

+# endif

+#endif

+

 #ifdef __cplusplus

 }  /* End of the 'extern "C"' block */

 #endif