#  include <dirent.h>

#  include <utime.h>

#  include <sys/time.h>

#else

#  include "windows.h"

#  include <io.h>

#  include <direct.h>

/* #  include "test_windirent.h" */

#  define dirent DIRENT

#  define chmod(path,mode) fileio_chmod(path,mode)

#  define mkdir(path,mode) fileio_mkdir(path)

#endif

*/

static void statTimesToUtc(

  const char *zPath,

){

  HANDLE hFindFile;

  WIN32_FIND_DATAW fd;

*/

static int fileStat(

  const char *zPath,

){

#if defined(_WIN32)

  sqlite3_int64 sz = strlen(zPath);

*/

static int fileLinkStat(

  const char *zPath,

){

#if defined(_WIN32)

  return fileStat(zPath, pStatBuf);

    int i = 1;

    while( rc==SQLITE_OK ){

      int rc2;

      for(; zCopy[i]!='/' && i<nCopy; i++);

        ** be an error though - if there is already a directory at the same

        ** path and either the permissions already match or can be changed

        ** to do so using chmod(), it is not an error.  */

        if( errno!=EEXIST

         || 0!=fileStat(zFile, &sStat)

         || !S_ISDIR(sStat.st_mode)

  const char *zBase;

  int nBase;

  char *zPath;               /* Path to current entry */

  sqlite3_int64 iRowid;      /* Current rowid */

};

**   }

**   rc = sqlite3_intck_error(p, &zErr);

**   if( rc!=SQLITE_OK ){

**   }

**   sqlite3_intck_close(p);

**

/******************************************************************************

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

** 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

** separate file. This file contains only code for the core SQLite library.

**

** The content in this amalgamation comes from Fossil check-in

**

**    

*/

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

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

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

**

** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of

** database filename D with corresponding journal file J and WAL file W and

** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that

** is safe to pass to routines like:

** <ul>

** METHOD: sqlite3_stmt

**

** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,

** templates:

**

** <ul>

**

** [[byte-order determination rules]] ^The byte-order of

** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)

** the byte order is the native byte order of the host

** machine for sqlite3_bind_text16() or the byte order specified in

** the 6th parameter for sqlite3_bind_text64().)^

** or sqlite3_bind_text16() or sqlite3_bind_text64() then

** that parameter must be the byte offset

** where the NUL terminator would occur assuming the string were NUL

** the value of the fourth parameter then the resulting string value will

** contain embedded NULs.  The result of expressions involving strings

** with embedded NULs is undefined.

** METHOD: sqlite3_stmt

**

** ^These routines provide a means to determine the database, table, and

** [SELECT] statement.

** ^The name of the database or table or column can be returned as

** either a UTF-8 or UTF-16 string.  ^The _database_ routines return

**

** For best security, the [SQLITE_DIRECTONLY] flag is recommended for

** all application-defined SQL functions that do not need to be

** functions that have side effects or reveal internal application state.

** Without this flag, an attacker might be able to modify the schema of

** a database file to include invocations of the function with parameters

** [user-defined window functions|available here].

**

** ^(If the final parameter to sqlite3_create_function_v2() or

** the application data pointer. The destructor is invoked when the function

** is deleted, either by being overloaded or when the database connection

** closes.)^ ^The destructor is also invoked if the call to

** METHOD: sqlite3_value

**

** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value]

** is a [protected sqlite3_value] object even if the input is not.

** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a

** memory allocation fails. ^If V is a [pointer value], then the result

** allocation error occurs.

**

** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is

** value of N in any subsequent call to sqlite3_aggregate_context() within

** the same aggregate function instance will not resize the memory

** allocation.)^  Within the xFinal callback, it is customary to set

**

** Security Warning:  These interfaces should not be exposed in scripting

** languages or in other circumstances where it might be possible for an

** can probably also take control of the process.

**

** Database connection client data is only available for SQLite

** pointed to by the 2nd parameter are taken as the application-defined

** function result.  If the 3rd parameter is non-negative, then it

** must be the byte offset into the string where the NUL terminator would

** in the string at a byte offset that is less than the value of the 3rd

** parameter, then the resulting string will contain embedded NULs and the

** result of expressions operating on strings with embedded NULs is undefined.

** string and preferably a string literal. The sqlite3_result_pointer()

** routine is part of the [pointer passing interface] added for SQLite 3.20.0.

**

** than the one containing the application-defined function that received

** the [sqlite3_context] pointer, the results are undefined.

*/

** METHOD: sqlite3

**

** ^The sqlite3_db_name(D,N) interface returns a pointer to the schema name

** out of range.  An N value of 0 means the main database file.  An N of 1 is

** the "temp" schema.  Larger values of N correspond to various ATTACH-ed

** databases.

** <dd>The SQLITE_TXN_READ state means that the database is currently

** in a read transaction.  Content has been read from the database file

** but nothing in the database file has changed.  The transaction state

** no other conflicting concurrent write transactions.  The transaction

** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or

** [COMMIT].</dd>

** <dd>The SQLITE_TXN_WRITE state means that the database is currently

** in a write transaction.  Content has been written to the database file

** but has not yet committed.  The transaction state will change to

*/

#define SQLITE_TXN_NONE  0

#define SQLITE_TXN_READ  1

** CAPI3REF: Impose A Limit On Heap Size

**

** These interfaces impose limits on the amount of heap memory that will be

**

** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the

** soft limit on the amount of heap memory that may be allocated by SQLite.

** </ul>)^

**

** The circumstances under which SQLite will enforce the heap limits may

*/

SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);

SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 N);

** ^The entry point is zProc.

** ^(zProc may be 0, in which case SQLite will try to come up with an

** entry point name on its own.  It first tries "sqlite3_extension_init".

** characters in the filename from the last "/" to the first following

** "." and omitting any initial "lib".)^

** ^The sqlite3_load_extension() interface returns

** ^(Even though the function prototype shows that xEntryPoint() takes

** no arguments and returns void, SQLite invokes xEntryPoint() with three

** arguments and expects an integer result as if the signature of the

**

** <blockquote><pre>

**    int xEntryPoint(

** virtual table and might not be checked again by the byte code.)^ ^(The

** aConstraintUsage[].omit flag is an optimization hint. When the omit flag

** is left in its default setting of false, the constraint will always be

** the constraint may or may not be checked in byte code.  In other words,

** when the omit flag is true there is no guarantee that the constraint will

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

** The xBestIndex method may optionally populate the idxFlags field with a

** mask of SQLITE_INDEX_SCAN_* flags. One such flag is

** [SQLITE_INDEX_SCAN_HEX], which if set causes the [EXPLAIN QUERY PLAN]

** SQLITE_INDEX_SCAN_UNIQUE, which if set indicates that the query plan will

** return at most one row.

**

** the implementation of the [virtual table module].   ^The fourth

** parameter is an arbitrary client data pointer that is passed through

** into the [xCreate] and [xConnect] methods of the virtual table module

**

** ^The sqlite3_create_module_v2() interface has a fifth parameter which

** is a pointer to a destructor for the pClientData.  ^SQLite will

** in *ppBlob. Otherwise an [error code] is returned and, unless the error

** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided

** the API is not misused, it is always safe to call [sqlite3_blob_close()]

**

** This function fails with SQLITE_ERROR if any of the following are true:

** <ul>

**

** ^Returns the size in bytes of the BLOB accessible via the

** successfully opened [BLOB handle] in its only argument.  ^The

** blob content; they cannot change the size of a blob.

**

** This routine only works on a [BLOB handle] which has been created

** ^The sqlite3_mutex_alloc() routine allocates a new

** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc()

** routine returns NULL if it is unable to allocate the requested

** integer constants:

**

** <ul>

** CAPI3REF: Retrieve the mutex for a database connection

** METHOD: sqlite3

**

** serializes access to the [database connection] given in the argument

** when the [threading mode] is Serialized.

** ^If the [threading mode] is Single-thread or Multi-thread then this

** CAPI3REF: SQL Keyword Checking

**

** These routines provide access to the set of SQL language keywords

** whether or not a specific identifier needs to be escaped (for example,

** by enclosing in double-quotes) so as not to confuse the parser.

**

** content of the dynamic string under construction in X.  The value

** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X

** and might be freed or altered by any subsequent method on the same

** [sqlite3_str_value(X)] after any subsequent method call on the same

** object.  ^Applications may change the content of the string returned

** by [sqlite3_str_value(X)] as long as they do not write into any bytes

** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]

** buffer and where forced to overflow to [sqlite3_malloc()].  The

** returned value includes allocations that overflowed because they

** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because

** no space was left in the page cache.</dd>)^

**

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

** <dd>This parameter returns the number of malloc attempts that were

** satisfied using lookaside memory. Only the high-water value is meaningful;

**

** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>

** been satisfied using lookaside memory but failed due to the amount of

** memory requested being larger than the lookaside slot size.

** Only the high-water value is meaningful;

**

** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>

** been satisfied using lookaside memory but failed due to all lookaside

** memory already being in use.

** Only the high-water value is meaningful;

**

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

** <dd>This parameter returns the approximate number of bytes of heap

** memory used by all pager caches associated with the database connection.)^

** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.

**

** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]]

** ^(<dt>SQLITE_DBSTATUS_CACHE_USED_SHARED</dt>

** memory used by that pager cache is divided evenly between the attached

** connections.)^  In other words, if none of the pager caches associated

** with the database connection are shared, this request returns the same

** shared, the value returned by this call will be smaller than that returned

** by DBSTATUS_CACHE_USED. ^The highwater mark associated with

**

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

** <dd>This parameter returns the approximate number of bytes of heap

** schema memory is shared with other database connections due to

** [shared cache mode] being enabled.

** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.

**

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

** <dd>This parameter returns the approximate number of bytes of heap

** been written to disk in the middle of a transaction due to the page

** cache overflowing. Transactions are more efficient if they are written

** to disk all at once. When pages spill mid-transaction, that introduces

** inefficiencies that can be resolved by increasing the cache size.

** </dd>

**

** [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>

** <dd>^This is the number of sort operations that have occurred.

** A non-zero value in this counter may indicate an opportunity to

**

** [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>

** <dd>^This is the number of rows inserted into transient indices that

** were created automatically in order to help joins run faster.

** A non-zero value in this counter may indicate an opportunity to

** need to be reinitialized each time the statement is run.</dd>

**

** [[SQLITE_STMTSTATUS_VM_STEP]] <dt>SQLITE_STMTSTATUS_VM_STEP</dt>

** to 2147483647.  The number of virtual machine operations can be

** used as a proxy for the total work done by the prepared statement.

** If the number of virtual machine operations exceeds 2147483647

**

** [[SQLITE_STMTSTATUS_REPREPARE]] <dt>SQLITE_STMTSTATUS_REPREPARE</dt>

** <dd>^This is the number of times that the prepare statement has been

** automatically regenerated due to schema changes or changes to

**

** [[SQLITE_STMTSTATUS_RUN]] <dt>SQLITE_STMTSTATUS_RUN</dt>

** <dd>^This is the number of times that the prepared statement has

** been run.  A single "run" for the purposes of this counter is one

** or more calls to [sqlite3_step()] followed by a call to [sqlite3_reset()].

** The counter is incremented on the first [sqlite3_step()] call of each

**

** [[SQLITE_STMTSTATUS_FILTER_MISS]]

** [[SQLITE_STMTSTATUS_FILTER HIT]]

** step was bypassed because a Bloom filter returned not-found.  The

** corresponding SQLITE_STMTSTATUS_FILTER_MISS value is the number of

** times that the Bloom filter returned a find, and thus the join step

**

** [[SQLITE_STMTSTATUS_MEMUSED]] <dt>SQLITE_STMTSTATUS_MEMUSED</dt>

** <dd>^This is the approximate number of bytes of heap memory

** SQLite will typically create one cache instance for each open database file,

** though this is not guaranteed. ^The

** first parameter, szPage, is the size in bytes of the pages that must

** second parameter szExtra is a number of bytes of extra storage

** a number less than 250.  SQLite will use the

** extra szExtra bytes on each page to store metadata about the underlying

** database page on disk.  The value passed into szExtra depends

** ^The third argument to xCreate(), bPurgeable, is true if the cache being

** created will be used to cache database pages of a file stored on disk, or

** false if it is used for an in-memory database. The cache implementation

** it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will

** never invoke xUnpin() except to deliberately delete a page.

** ^In other words, calls to xUnpin() on a cache with bPurgeable set to

** false will always have the "discard" flag set to true.

** never contain any unpinned pages.

**

** [[the xCachesize() page cache method]]

** ^(The xCachesize() method may be called at any time by SQLite to set the

** instance passed as the first argument. This is the value configured using

** the SQLite "[PRAGMA cache_size]" command.)^  As with the bPurgeable

** parameter, the implementation is not required to do anything with this

** implementation must return a pointer to the page buffer with its content

** intact.  If the requested page is not already in the cache, then the

** cache implementation should use the value of the createFlag

**

** <table border=1 width=85% align=center>

** <tr><th> createFlag <th> Behavior when page is not already in cache

** <tr><td> 0 <td> Do not allocate a new page.  Return NULL.

**                 Otherwise return NULL.

** <tr><td> 2 <td> Make every effort to allocate a new page.  Only return

**                 NULL if allocating a new page is effectively impossible.

** as its second argument.  If the third parameter, discard, is non-zero,

** then the page must be evicted from the cache.

** ^If the discard parameter is

** page cache implementation. ^The page cache implementation

** may choose to evict unpinned pages at any time.

**

** When SQLite calls the xTruncate() method, the cache must discard all

** existing cache entries with page numbers (keys) greater than or equal

** to the value of the iLimit parameter passed to xTruncate(). If any

** they can be safely discarded.

**

** [[the xDestroy() page cache method]]

** external process or via a database connection other than the one being

** used by the backup operation, then the backup will be automatically

** restarted by the next call to sqlite3_backup_step(). ^If the source

** by the backup operation, then the backup database is automatically

** updated at the same time.

**

** and may not be used following a call to sqlite3_backup_finish().

**

** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no

** sqlite3_backup_step() completed.

** ^If an out-of-memory condition or IO error occurred during any prior

** sqlite3_backup_step() call on the same [sqlite3_backup] object, then

** application receives an SQLITE_LOCKED error, it may call the

** sqlite3_unlock_notify() method with the blocked connection handle as

** the first argument to register for a callback that will be invoked

** callback is invoked from within the [sqlite3_step] or [sqlite3_close]

** call that concludes the blocking connection's transaction.

**

** blocked connection already has a registered unlock-notify callback,

** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is

** called with a NULL pointer as its second argument, then any existing

** unlock-notify callback may also be canceled by closing the blocked

** connection using [sqlite3_close()].

**

** support constraints.  In this configuration (which is the default) if

** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire

** statement is rolled back as if [ON CONFLICT | OR ABORT] had been

** ON CONFLICT mode specified.

**

** If X is non-zero, then the virtual table implementation guarantees

** [[SQLITE_VTAB_INNOCUOUS]]<dt>SQLITE_VTAB_INNOCUOUS</dt>

** <dd>Calls of the form

** [sqlite3_vtab_config](db,SQLITE_VTAB_INNOCUOUS) from within the

** identify that virtual table as being safe to use from within triggers

** and views.  Conceptually, the SQLITE_VTAB_INNOCUOUS tag means that the

** virtual table can do no serious harm even if it is controlled by a

** </table>

**

** ^For the purposes of comparing virtual table output values to see if the

** to be the same.  In other words, the comparison operator is "IS"

** (or "IS NOT DISTINCT FROM") and not "==".

**

**

** ^A virtual table implementation is always free to return rows in any order

** it wants, as long as the "orderByConsumed" flag is not set.  ^When the

** [bytecode] to ensure that the final results returned by the SQL query are

** ordered correctly.  The use of the "orderByConsumed" flag and the

** sqlite3_vtab_distinct() interface is merely an optimization.  ^Careful

** 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

** [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_ERROR].)^

** and only if *V is set to a value.  ^The sqlite3_vtab_rhs_value(P,J,V)

** inteface returns SQLITE_NOTFOUND if the right-hand side of the J-th

** constraint is not available.  ^The sqlite3_vtab_rhs_value() interface

** something goes wrong.

**

** The sqlite3_vtab_rhs_value() interface is usually only successful if

** KEYWORDS: {conflict resolution mode}

**

** These constants are returned by [sqlite3_vtab_on_conflict()] to

**

** Note that the [SQLITE_IGNORE] constant is also used as a potential

** return value from the [sqlite3_set_authorizer()] callback and that

** [[SQLITE_SCANSTAT_EST]] <dt>SQLITE_SCANSTAT_EST</dt>

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

** query planner's estimate for the average number of rows output from each

** then this value will approximate the quotient NVISIT/NLOOP and the

** product of this value for all prior loops with the same SELECTID will

**

** [[SQLITE_SCANSTAT_NAME]] <dt>SQLITE_SCANSTAT_NAME</dt>

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

** to a zero-terminated UTF-8 string containing the name of the index or table

**

** [[SQLITE_SCANSTAT_EXPLAIN]] <dt>SQLITE_SCANSTAT_EXPLAIN</dt>

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

** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]

**

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

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

** 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

**

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

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

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

**

** [[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

** </dl>

*/

#define SQLITE_SCANSTAT_NLOOP    0

** sqlite3_stmt_scanstatus_v2() with a zeroed flags parameter.

**

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

** - 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.

** METHOD: sqlite3

**

** ^If a write-transaction is open on [database connection] D when the

** pages in the pager-cache that are not currently in use are written out

** to disk. A dirty page may be in use if a database cursor created by an

** active SQL statement is reading from it, or if it is page 1 of a database

** triggers; and so forth.

**

** When the [sqlite3_blob_write()] API is used to update a blob column,

** callback made with op==SQLITE_DELETE is actually a write using the

** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns

** the index of the column being written. In other cases, where the

** For an ordinary on-disk database file, the serialization is just a

** copy of the disk file.  For an in-memory database or a "TEMP" database,

** the serialization is the same sequence of bytes which would be written

**

** The usual case is that sqlite3_serialize() copies the serialization of

** the database into memory obtained from [sqlite3_malloc64()] and returns

** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations

** are made, and the sqlite3_serialize() function will return a pointer

** to the contiguous memory representation of the database that SQLite

** memory representation of the database exists.  A contiguous memory

** representation of the database will usually only exist if there has

** been a prior call to [sqlite3_deserialize(D,S,...)] with the same

** database is currently in a read transaction or is involved in a backup

** operation.

**

** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the

** function returns SQLITE_ERROR.

**

  sqlite3 *db,            /* The database connection */

  const char *zSchema,    /* Which DB to reopen with the deserialization */

  unsigned char *pData,   /* The serialized database content */

  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */

  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */

);

/*

** CAPI3REF: Flags for sqlite3_deserialize()

**

** the [sqlite3_deserialize(D,S,P,N,M,F)] interface.

**

** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization

** assuming n is a signed integer type.  UMXV(n) is similar for unsigned

** integer types.

*/

/*

** Round up a number to the next larger multiple of 8.  This is used

  unsigned hasStat1:1;     /* aiRowLogEst values come from sqlite_stat1 */

  unsigned bNoQuery:1;     /* Do not use this index to optimize queries */

  unsigned bAscKeyBug:1;   /* True if the bba7b69f9849b5bf bug applies */

  unsigned bHasVCol:1;     /* Index references one or more VIRTUAL columns */

  unsigned bHasExpr:1;     /* Index contains an expression, either a literal

                           ** expression, or a reference to a VIRTUAL column */

                          ** from source tables rather than from accumulators */

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

                          ** than the source table */

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

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

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

    Table *pTab;             /* Source table */

    Expr *pCExpr;            /* The original expression */

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

  } *aCol;

  int nColumn;            /* Number of used entries in aCol[] */

  int nAccumulator;       /* Number of columns that show through to the output.

    Table *pTab;           /* TK_COLUMN: Table containing column. Can be NULL

                           ** for a column of an index on an expression */

    Window *pWin;          /* EP_WinFunc: Window/Filter defn for a function */

    struct {               /* TK_IN, TK_SELECT, and TK_EXISTS */

      int iAddr;             /* Subroutine entry address */

      int regReturn;         /* Register used to hold return address */

SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, Expr*, int);

SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse*, Expr*, int);

SQLITE_PRIVATE int sqlite3ExprCodeRunJustOnce(Parse*, Expr*, int);

SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*);

SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int);

SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int, u8);

    }else{

      memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));

      memset(p->u.apSub, 0, sizeof(p->u.apSub));

      rc = sqlite3BitvecSet(p, i);

      for(j=0; j<BITVEC_NINT; j++){

        if( aiValues[j] ) rc |= sqlite3BitvecSet(p, aiValues[j]);

      if( iMax!=pWal->hdr.mxFrame ) walCleanupHash(pWal);

    }

    SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )

  }

  return rc;

}

      walCleanupHash(pWal);

    }

    SEH_EXCEPT( rc = SQLITE_IOERR_IN_PAGE; )

  }

  return rc;

    return pLeft;

  }else{

    u32 f = pLeft->flags | pRight->flags;

     && !IN_RENAME_OBJECT

    ){

      sqlite3ExprDeferredDelete(pParse, pLeft);

      sqlite3VdbeLoadString(v, target, pExpr->u.zToken);

      return target;

    }

    default: {

      /* Make NULL the default case so that if a bug causes an illegal

      ** Expr node to be passed into this function, it will be handled

}

/*

** Generate code to evaluate an expression and store the results

** into a register.  Return the register number where the results

** are stored.

){

  struct AggInfo_col *pCol;

  int k;

  assert( pAggInfo->iFirstReg==0 );

  pCol = pAggInfo->aCol;

  for(k=0; k<pAggInfo->nColumn; k++, pCol++){

    assert( pParse->db->mallocFailed );

    return;

  }

  pCol = &pAggInfo->aCol[k];

  assert( ExprUseYTab(pExpr) );

  pCol->pTab = pExpr->y.pTab;

  if( pExpr->op==TK_COLUMN ){

    pExpr->op = TK_AGG_COLUMN;

  }

  pExpr->iAgg = (i16)k;

}

        ** function that is already in the pAggInfo structure

        */

        struct AggInfo_func *pItem = pAggInfo->aFunc;

        for(i=0; i<pAggInfo->nFunc; i++, pItem++){

          if( NEVER(pItem->pFExpr==pExpr) ) break;

          if( sqlite3ExprCompare(0, pItem->pFExpr, pExpr, -1)==0 ){

            break;

          }

        }

          /* pExpr is original.  Make a new entry in pAggInfo->aFunc[]

          */

          u8 enc = ENC(pParse->db);

        */

        assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );

        ExprSetVVAProperty(pExpr, EP_NoReduce);

        pExpr->iAgg = (i16)i;

        pExpr->pAggInfo = pAggInfo;

        return WRC_Prune;

      assert( j<=0x7fff );

      if( j<0 ){

        j = pTab->iPKey;

      }else{

        if( pTab->aCol[j].notNull==0 ){

          pIndex->uniqNotNull = 0;

  int nSep,

  const char *zSep

){

  int i;

  char *z;

  for(i=0; i<argc; i++){

  }

  j = 0;

  for(i=0; i<argc; i++){

      const char *v = (const char*)sqlite3_value_text(argv[i]);

      if( v!=0 ){

        if( j>0 && nSep>0 ){

      sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);

      VdbeComment((v, "clear abort flag"));

      sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);

      /* Begin a loop that will extract all source rows in GROUP BY order.

      ** This might involve two separate loops with an OP_Sort in between, or

          int iField;

          assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 );

          iField = pLoop->aLTerm[i]->u.x.iField - 1;

          pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);

          pOrigRhs->a[iField].pExpr = 0;

          if( pRhs ) pRhs->a[pRhs->nExpr-1].u.x.iOrderByCol = iField+1;

      return;

    }

  }

    assert( pLoop->aLTerm[i]!=0 );

    if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;

  }

  if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){

    eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);

  }else{

    }

  }

  if( eType==IN_INDEX_INDEX_DESC ){

  if( pIn ){

    int iMap = 0;               /* Index in aiMap[] */

    pIn += i;

      if( pLoop->aLTerm[i]->pExpr==pX ){

        int iOut = iTarget + i - iEq;

        if( eType==IN_INDEX_ROWID ){

**   1.  The SQLITE_Transitive optimization must be enabled

**   2.  Must be either an == or an IS operator

**   3.  Not originating in the ON clause of an OUTER JOIN

** If this routine returns TRUE, that means that the RHS can be substituted

** for the LHS anyplace else in the WHERE clause where the LHS column occurs.

** This is an optimization.  No harm comes from returning 0.  But if 1 is

** returned when it should not be, then incorrect answers might result.

*/

  char aff1, aff2;

  CollSeq *pColl;

  aff1 = sqlite3ExprAffinity(pExpr->pLeft);

  aff2 = sqlite3ExprAffinity(pExpr->pRight);

  if( aff1!=aff2

   && (!sqlite3IsNumericAffinity(aff1) || !sqlite3IsNumericAffinity(aff2))

  ){

  }

  pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);

}

/*

        if( op==TK_IS ) pNew->wtFlags |= TERM_IS;

        pTerm = &pWC->a[idxTerm];

        pTerm->wtFlags |= TERM_COPIED;

          pTerm->eOperator |= WO_EQUIV;

          eExtraOp = WO_EQUIV;

        }

      if( ExprUseXSelect(pExpr) ){

        /* "x IN (SELECT ...)":  TUNING: the SELECT returns 25 rows */

        int i;

        nIn = 46;  assert( 46==sqlite3LogEst(25) );

        /* The expression may actually be of the form (x, y) IN (SELECT...).

        ** for each such term. The following loop checks that pTerm is the

        ** first such term in use, and sets nIn back to 0 if it is not. */

        for(i=0; i<pNew->nLTerm-1; i++){

        }

      }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){

        /* "x IN (value, value, ...)" */

    if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0

     && pNew->u.btree.nEq<pProbe->nColumn

     && (pNew->u.btree.nEq<pProbe->nKeyCol ||

    ){

      if( pNew->u.btree.nEq>3 ){

        sqlite3ProgressCheck(pParse);

    pNew->u.btree.nEq = 0;

    pNew->u.btree.nBtm = 0;

    pNew->u.btree.nTop = 0;

    pNew->nSkip = 0;

    pNew->nLTerm = 0;

    pNew->iSortIdx = 0;

        obSat = obDone;

      }

      break;

    }

    iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor;

      **      expr1 IN ()

      **      expr1 NOT IN ()

      **

      */

    }else{

      Expr *pRHS = yymsp[-1].minor.yy402->a[0].pExpr;

      if( yymsp[-1].minor.yy402->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy590->op!=TK_VECTOR ){

  int t;                          /* Token type to return */

  do {

    z += sqlite3GetToken(z, &t);

  if( t==TK_ID

   || t==TK_STRING

   || t==TK_JOIN_KW

#endif

  if( ms<-1 ) return SQLITE_RANGE;

#ifdef SQLITE_ENABLE_SETLK_TIMEOUT

  db->setlkTimeout = ms;

  db->setlkFlags = flags;

  sqlite3BtreeEnterAll(db);

    }

  }

  sqlite3BtreeLeaveAll(db);

#endif

#if !defined(SQLITE_ENABLE_API_ARMOR) && !defined(SQLITE_ENABLE_SETLK_TIMEOUT)

  UNUSED_PARAMETER(db);

** iterator pIter points to to the SELECT and attempts to seek to the table

** entry. If a row is found, the SELECT statement left pointing at the row

** and SQLITE_ROW is returned. Otherwise, if no row is found and no error

** error occurs, the statement is reset and an SQLite error code is returned.

**

** If this function returns SQLITE_ROW, the caller must eventually reset()

** leave an error in the Fts5Index object.

*/

static void fts5SegIterAllocTombstone(Fts5Index *p, Fts5SegIter *pIter){

  if( nTomb>0 ){

    Fts5TombstoneArray *pNew;

    pNew = (Fts5TombstoneArray*)sqlite3Fts5MallocZero(&p->rc, nByte);

    if( pNew ){

){

  assert( nArg==0 );

  UNUSED_PARAM2(nArg, apUnused);

}

/*

  for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){

    if( pConfig->abUnindexed[iCol-1]==0 ){

      sqlite3_value *pVal = 0;

      const char *pText = 0;

      int nText = 0;

      const char *pLoc = 0;

      if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){

        rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);

      }else{

        }

      }

        }

        sqlite3Fts5ClearLocale(pConfig);

      }

    }

  }

  if( rc==SQLITE_OK && p->nTotalRow<1 ){

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

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

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

**

** The sqlite3_create_filename(D,J,W,N,P) allocates memory to hold a version of

** database filename D with corresponding journal file J and WAL file W and

** sqlite3_create_filename(D,J,W,N,P) is a pointer to a database filename that

** is safe to pass to routines like:

** <ul>

** METHOD: sqlite3_stmt

**

** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,

** templates:

**

** <ul>

**

** [[byte-order determination rules]] ^The byte-order of

** UTF16 input text is determined by the byte-order mark (BOM, U+FEFF)

** the byte order is the native byte order of the host

** machine for sqlite3_bind_text16() or the byte order specified in

** the 6th parameter for sqlite3_bind_text64().)^

** or sqlite3_bind_text16() or sqlite3_bind_text64() then

** that parameter must be the byte offset

** where the NUL terminator would occur assuming the string were NUL

** the value of the fourth parameter then the resulting string value will

** contain embedded NULs.  The result of expressions involving strings

** with embedded NULs is undefined.

** METHOD: sqlite3_stmt

**

** ^These routines provide a means to determine the database, table, and

** [SELECT] statement.

** ^The name of the database or table or column can be returned as

** either a UTF-8 or UTF-16 string.  ^The _database_ routines return

**

** For best security, the [SQLITE_DIRECTONLY] flag is recommended for

** all application-defined SQL functions that do not need to be

** functions that have side effects or reveal internal application state.

** Without this flag, an attacker might be able to modify the schema of

** a database file to include invocations of the function with parameters

** [user-defined window functions|available here].

**

** ^(If the final parameter to sqlite3_create_function_v2() or

** the application data pointer. The destructor is invoked when the function

** is deleted, either by being overloaded or when the database connection

** closes.)^ ^The destructor is also invoked if the call to

** METHOD: sqlite3_value

**

** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value]

** is a [protected sqlite3_value] object even if the input is not.

** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a

** memory allocation fails. ^If V is a [pointer value], then the result

** allocation error occurs.

**

** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is

** value of N in any subsequent call to sqlite3_aggregate_context() within

** the same aggregate function instance will not resize the memory

** allocation.)^  Within the xFinal callback, it is customary to set

**

** Security Warning:  These interfaces should not be exposed in scripting

** languages or in other circumstances where it might be possible for an

** can probably also take control of the process.

**

** Database connection client data is only available for SQLite

** pointed to by the 2nd parameter are taken as the application-defined

** function result.  If the 3rd parameter is non-negative, then it

** must be the byte offset into the string where the NUL terminator would

** in the string at a byte offset that is less than the value of the 3rd

** parameter, then the resulting string will contain embedded NULs and the

** result of expressions operating on strings with embedded NULs is undefined.

** string and preferably a string literal. The sqlite3_result_pointer()

** routine is part of the [pointer passing interface] added for SQLite 3.20.0.

**

** than the one containing the application-defined function that received

** the [sqlite3_context] pointer, the results are undefined.

*/

** METHOD: sqlite3

**

** ^The sqlite3_db_name(D,N) interface returns a pointer to the schema name

** out of range.  An N value of 0 means the main database file.  An N of 1 is

** the "temp" schema.  Larger values of N correspond to various ATTACH-ed

** databases.

** <dd>The SQLITE_TXN_READ state means that the database is currently

** in a read transaction.  Content has been read from the database file

** but nothing in the database file has changed.  The transaction state

** no other conflicting concurrent write transactions.  The transaction

** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or

** [COMMIT].</dd>

** <dd>The SQLITE_TXN_WRITE state means that the database is currently

** in a write transaction.  Content has been written to the database file

** but has not yet committed.  The transaction state will change to

*/

#define SQLITE_TXN_NONE  0

#define SQLITE_TXN_READ  1

** CAPI3REF: Impose A Limit On Heap Size

**

** These interfaces impose limits on the amount of heap memory that will be

**

** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the

** soft limit on the amount of heap memory that may be allocated by SQLite.

** </ul>)^

**

** The circumstances under which SQLite will enforce the heap limits may

*/

SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);

SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 N);

** ^The entry point is zProc.

** ^(zProc may be 0, in which case SQLite will try to come up with an

** entry point name on its own.  It first tries "sqlite3_extension_init".

** characters in the filename from the last "/" to the first following

** "." and omitting any initial "lib".)^

** ^The sqlite3_load_extension() interface returns

** ^(Even though the function prototype shows that xEntryPoint() takes

** no arguments and returns void, SQLite invokes xEntryPoint() with three

** arguments and expects an integer result as if the signature of the

**

** <blockquote><pre>

**    int xEntryPoint(

** virtual table and might not be checked again by the byte code.)^ ^(The

** aConstraintUsage[].omit flag is an optimization hint. When the omit flag

** is left in its default setting of false, the constraint will always be

** the constraint may or may not be checked in byte code.  In other words,

** when the omit flag is true there is no guarantee that the constraint will

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

** The xBestIndex method may optionally populate the idxFlags field with a

** mask of SQLITE_INDEX_SCAN_* flags. One such flag is

** [SQLITE_INDEX_SCAN_HEX], which if set causes the [EXPLAIN QUERY PLAN]

** SQLITE_INDEX_SCAN_UNIQUE, which if set indicates that the query plan will

** return at most one row.

**

** the implementation of the [virtual table module].   ^The fourth

** parameter is an arbitrary client data pointer that is passed through

** into the [xCreate] and [xConnect] methods of the virtual table module

**

** ^The sqlite3_create_module_v2() interface has a fifth parameter which

** is a pointer to a destructor for the pClientData.  ^SQLite will

** in *ppBlob. Otherwise an [error code] is returned and, unless the error

** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided

** the API is not misused, it is always safe to call [sqlite3_blob_close()]

**

** This function fails with SQLITE_ERROR if any of the following are true:

** <ul>

**

** ^Returns the size in bytes of the BLOB accessible via the

** successfully opened [BLOB handle] in its only argument.  ^The

** blob content; they cannot change the size of a blob.

**

** This routine only works on a [BLOB handle] which has been created

** ^The sqlite3_mutex_alloc() routine allocates a new

** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc()

** routine returns NULL if it is unable to allocate the requested

** integer constants:

**

** <ul>

** CAPI3REF: Retrieve the mutex for a database connection

** METHOD: sqlite3

**

** serializes access to the [database connection] given in the argument

** when the [threading mode] is Serialized.

** ^If the [threading mode] is Single-thread or Multi-thread then this

** CAPI3REF: SQL Keyword Checking

**

** These routines provide access to the set of SQL language keywords

** whether or not a specific identifier needs to be escaped (for example,

** by enclosing in double-quotes) so as not to confuse the parser.

**

** content of the dynamic string under construction in X.  The value

** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X

** and might be freed or altered by any subsequent method on the same

** [sqlite3_str_value(X)] after any subsequent method call on the same

** object.  ^Applications may change the content of the string returned

** by [sqlite3_str_value(X)] as long as they do not write into any bytes

** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]

** buffer and where forced to overflow to [sqlite3_malloc()].  The

** returned value includes allocations that overflowed because they

** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because

** no space was left in the page cache.</dd>)^

**

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

** <dd>This parameter returns the number of malloc attempts that were

** satisfied using lookaside memory. Only the high-water value is meaningful;

**

** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>

** been satisfied using lookaside memory but failed due to the amount of

** memory requested being larger than the lookaside slot size.

** Only the high-water value is meaningful;

**

** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]

** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>

** been satisfied using lookaside memory but failed due to all lookaside

** memory already being in use.

** Only the high-water value is meaningful;

**

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

** <dd>This parameter returns the approximate number of bytes of heap

** memory used by all pager caches associated with the database connection.)^

** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.

**

** [[SQLITE_DBSTATUS_CACHE_USED_SHARED]]

** ^(<dt>SQLITE_DBSTATUS_CACHE_USED_SHARED</dt>

** memory used by that pager cache is divided evenly between the attached

** connections.)^  In other words, if none of the pager caches associated

** with the database connection are shared, this request returns the same

** shared, the value returned by this call will be smaller than that returned

** by DBSTATUS_CACHE_USED. ^The highwater mark associated with

**

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

** <dd>This parameter returns the approximate number of bytes of heap

** schema memory is shared with other database connections due to

** [shared cache mode] being enabled.

** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.

**

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

** <dd>This parameter returns the approximate number of bytes of heap