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

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

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

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

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

** argument.  ^If the callback function of the 3rd argument to

** sqlite3_exec() is not NULL, then it is invoked for each result row

** coming out of the evaluated SQL statements.  ^The 4th argument to

** callback invocation.  ^If the callback pointer to sqlite3_exec()

** is NULL, then no callback is ever invoked and result rows are

** ignored.

**

** New error codes may be added in future versions of SQLite.

**

*/

#define SQLITE_OK           0   /* Successful result */

/* beginning-of-error-codes */

#define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))

#define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))

#define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))

#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))

#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))

#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))

/*

** CAPI3REF: Flags For File Open Operations

**

** These bit values are intended for use in the

** 3rd parameter to the [sqlite3_open_v2()] interface and

*/

#define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */

#define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */

#define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */

#define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */

#define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */

#define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */

/*

** CAPI3REF: OS Interface File Virtual Methods Object

**

** [sqlite3_file] object (or, more commonly, a subclass of the

** [sqlite3_file] object) with a pointer to an instance of this object.

** This object defines the methods used to perform various operations

** against the open file represented by the [sqlite3_file] object.

**

** to a non-NULL pointer, then the sqlite3_io_methods.xClose method

**

** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or

** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().

**

** An instance of the sqlite3_vfs object defines the interface between

** the SQLite core and the underlying operating system.  The "vfs"

**

** The value of the iVersion field is initially 1 but may be larger in

** future versions of SQLite.  Additional fields may be appended to this

** The zName field holds the name of the VFS module.  The name must

** be unique across all VFS modules.

**

** ^SQLite guarantees that the zFilename parameter to xOpen

** is either a NULL pointer or string obtained

** from xFullPathname() with an optional suffix added.

** element will be valid after xOpen returns regardless of the success

** or failure of the xOpen call.

**

** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]

** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to

** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]

** method returns a Julian Day Number for the current date and time as

** a floating point value.

** ^The xCurrentTimeInt64() method returns, as an integer, the Julian

** a 24-hour day).  

** ^SQLite will use the xCurrentTimeInt64() method to get the current

** date and time if that method is available (if iVersion is 2 or 

** implementation of an application-defined [sqlite3_os_init()].

**

** The first argument to sqlite3_config() is an integer

** what property of SQLite is to be configured.  Subsequent arguments

** in the first argument.

**

** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].

/*

** CAPI3REF: Configuration Options

**

** These constants are the available integer configuration options that

** can be passed as the first argument to the [sqlite3_config()] interface.

** is invoked.

**

** <dl>

** <dd>There are no arguments to this option.  ^This option sets the

** [threading mode] to Single-thread.  In other words, it disables

** all mutexing and puts SQLite into a mode where it can only be used

** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD

** configuration option.</dd>

**

** <dd>There are no arguments to this option.  ^This option sets the

** [threading mode] to Multi-thread.  In other words, it disables

** mutexing on [database connection] and [prepared statement] objects.

** [sqlite3_config()] will return [SQLITE_ERROR] if called with the

** SQLITE_CONFIG_MULTITHREAD configuration option.</dd>

**

** <dd>There are no arguments to this option.  ^This option sets the

** [threading mode] to Serialized. In other words, this option enables

** all mutexes including the recursive

** [sqlite3_config()] will return [SQLITE_ERROR] if called with the

** SQLITE_CONFIG_SERIALIZED configuration option.</dd>

**

** <dd> ^(This option takes a single argument which is a pointer to an

** instance of the [sqlite3_mem_methods] structure.  The argument specifies

** alternative low-level memory allocation routines to be used in place of

** its own private copy of the content of the [sqlite3_mem_methods] structure

** before the [sqlite3_config()] call returns.</dd>

**

** <dd> ^(This option takes a single argument which is a pointer to an

** instance of the [sqlite3_mem_methods] structure.  The [sqlite3_mem_methods]

** structure is filled with the currently defined memory allocation routines.)^

** routines with a wrapper that simulations memory allocation failure or

** tracks memory usage, for example. </dd>

**

** <dd> ^This option takes single argument of type int, interpreted as a 

** boolean, which enables or disables the collection of memory allocation 

** statistics. ^(When memory allocation statistics are disabled, the 

** allocation statistics are disabled by default.

** </dd>

**

** <dd> ^This option specifies a static memory buffer that SQLite can use for

** scratch memory.  There are three arguments:  A pointer an 8-byte

** aligned memory buffer from which the scratch allocations will be

** scratch memory beyond what is provided by this configuration option, then 

** [sqlite3_malloc()] will be used to obtain the memory needed.</dd>

**

** <dd> ^This option specifies a static memory buffer that SQLite can use for

** This configuration should not be used if an application-define page

** cache implementation is loaded using the SQLITE_CONFIG_PCACHE option.

** There are three arguments to this option: A pointer to 8-byte aligned

** be aligned to an 8-byte boundary or subsequent behavior of SQLite

** will be undefined.</dd>

**

** <dd> ^This option specifies a static memory buffer that SQLite will use

** for all of its dynamic memory allocation needs beyond those provided

** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].

** The minimum allocation size is capped at 2^12. Reasonable values

** for the minimum allocation size are 2^5 through 2^8.</dd>

**

** <dd> ^(This option takes a single argument which is a pointer to an

** instance of the [sqlite3_mutex_methods] structure.  The argument specifies

** alternative low-level mutex routines to be used in place

** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will

** return [SQLITE_ERROR].</dd>

**

** <dd> ^(This option takes a single argument which is a pointer to an

** instance of the [sqlite3_mutex_methods] structure.  The

** [sqlite3_mutex_methods]

** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will

** return [SQLITE_ERROR].</dd>

**

** <dd> ^(This option takes two arguments that determine the default

** memory allocation for the lookaside memory allocator on each

** [database connection].  The first argument is the

** verb to [sqlite3_db_config()] can be used to change the lookaside

** configuration on individual connections.)^ </dd>

**

** <dd> ^(This option takes a single argument which is a pointer to

** an [sqlite3_pcache_methods] object.  This object specifies the interface

** to a custom page cache implementation.)^  ^SQLite makes a copy of the

** object and uses it for page cache memory allocations.</dd>

**

** <dd> ^(This option takes a single argument which is a pointer to an

** [sqlite3_pcache_methods] object.  SQLite copies of the current

** page cache implementation into that object.)^ </dd>

**

** <dd> ^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a

** function with a call signature of void(*)(void*,int,const char*), 

** and a pointer to void. ^If the function pointer is not NULL, it is

** In a multi-threaded application, the application-defined logger

** function must be threadsafe. </dd>

**

** </dl>

*/

#define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */

#define SQLITE_CONFIG_PCACHE       14  /* sqlite3_pcache_methods* */

#define SQLITE_CONFIG_GETPCACHE    15  /* sqlite3_pcache_methods* */

#define SQLITE_CONFIG_LOG          16  /* xFunc, void* */

/*

** CAPI3REF: Database Connection Configuration Options

**

** ^This routine returns the [rowid] of the most recent

** successful [INSERT] into the database from the [database connection]

** have ever occurred on that database connection, zero is returned.

**

**

** ^An [INSERT] that fails due to a constraint violation is not a

** successful [INSERT] and does not change the value returned by this

** to signal SQLite whether or not the action is permitted.  See the

** [sqlite3_set_authorizer | authorizer documentation] for additional

** information.

*/

#define SQLITE_DENY   1   /* Abort the SQL statement with an error */

#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */

/*

** CAPI3REF: Opening A New Database Connection

**

** filename argument. ^The filename argument is interpreted as UTF-8 for

** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte

** order for sqlite3_open16(). ^(A [database connection] handle is usually

** sqlite3_open_v2() can take one of

** the following three values, optionally combined with the 

** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],

**

** <dl>

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

** </dl>

**

** If the 3rd parameter to sqlite3_open_v2() is not one of the

** then the behavior is undefined.

**

** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection

** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not

** participate in [shared cache mode] even if it is enabled.

**

** ^If the filename is ":memory:", then a private, temporary in-memory database

** is created for the connection.  ^This in-memory database will vanish when

** the database connection is closed.  Future versions of SQLite might

** on-disk database will be created.  ^This private database will be

** automatically deleted as soon as the database connection is closed.

**

**

** <b>Note to Windows users:</b>  The encoding used for the filename argument

** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever

);

/*

** CAPI3REF: Error Codes And Messages

**

** ^The sqlite3_errcode() interface returns the numeric [result code] or

** Additional information is available at [limits | Limits in SQLite].

**

** <dl>

** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^

**

** <dd>The maximum length of an SQL statement, in bytes.</dd>)^

**

** <dd>The maximum number of columns in a table definition or in the

** result set of a [SELECT] or the maximum number of columns in an index

** or in an ORDER BY or GROUP BY clause.</dd>)^

**

** <dd>The maximum depth of the parse tree on any expression.</dd>)^

**

** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^

**

** <dd>The maximum number of instructions in a virtual machine program

** used to implement an SQL statement.  This limit is not currently

** enforced, though that might be added in some future release of

** SQLite.</dd>)^

**

** <dd>The maximum number of arguments on a function.</dd>)^

**

** <dd>The maximum number of [ATTACH | attached databases].)^</dd>

**

** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>

** <dd>The maximum length of the pattern argument to the [LIKE] or

** [GLOB] operators.</dd>)^

**

** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>

** <dd>The maximum index number of any [parameter] in an SQL statement.)^

**

** <dd>The maximum depth of recursion for triggers.</dd>)^

** </dl>

*/

** ^[SQLITE_BUSY] means that the database engine was unable to acquire the

** database locks it needs to do its job.  ^If the statement is a [COMMIT]

** or occurs outside of an explicit transaction, then you can retry the

** explicit transaction then you should rollback the transaction before

** continuing.

**

** CAPI3REF: Destroy A Prepared Statement Object

**

** ^The sqlite3_finalize() function is called to delete a [prepared statement].

** or if the statement is never been evaluated, then sqlite3_finalize() returns

** SQLITE_OK.  ^If the most recent evaluation of statement S failed, then

** sqlite3_finalize(S) returns the appropriate [error code] or

                       void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),

                       void **ppArg);

  int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);

};

/*

**

** ^If the argument to sqlite3_mutex_held() is a NULL pointer then

** the routine should return 1.   This seems counter-intuitive since

** the reason the mutex does not exist is because the build is not

** using mutexes.  And we do not want the assert() containing the

** call to sqlite3_mutex_held() to fail, so a non-zero return is

#define SQLITE_TESTCTRL_ISKEYWORD               16

#define SQLITE_TESTCTRL_PGHDRSZ                 17

#define SQLITE_TESTCTRL_SCRATCHMALLOC           18

/*

** CAPI3REF: SQLite Runtime Status

** about the performance of SQLite, and optionally to reset various

** highwater marks.  ^The first argument is an integer code for

** the specific parameter to measure.  ^(Recognized integer codes

** ^The current value of the parameter is returned into *pCurrent.

** ^The highest recorded value is returned in *pHighwater.  ^If the

** resetFlag is true, then the highest record value is reset after

/*

** CAPI3REF: Status Parameters

**

** These integer constants designate various run-time status parameters

** that can be returned by [sqlite3_status()].

**

** <dl>

** <dd>This parameter is the current amount of memory checked out

** using [sqlite3_malloc()], either directly or indirectly.  The

** figure includes calls made to [sqlite3_malloc()] by the application

** this parameter.  The amount returned is the sum of the allocation

** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^

**

** <dd>This parameter records the largest memory allocation request

** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their

** internal equivalents).  Only the value returned in the

** *pHighwater parameter to [sqlite3_status()] is of interest.  

** The value written into the *pCurrent parameter is undefined.</dd>)^

**

** <dd>This parameter records the number of separate memory allocations

** currently checked out.</dd>)^

**

** <dd>This parameter returns the number of pages used out of the

** [pagecache memory allocator] that was configured using 

** [SQLITE_CONFIG_PAGECACHE].  The

** value returned is in pages, not in bytes.</dd>)^

**

** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>

** <dd>This parameter returns the number of bytes of page cache

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

** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because

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

**

** <dd>This parameter records the largest memory allocation request

** handed to [pagecache memory allocator].  Only the value returned in the

** *pHighwater parameter to [sqlite3_status()] is of interest.  

** The value written into the *pCurrent parameter is undefined.</dd>)^

**

** <dd>This parameter returns the number of allocations used out of the

** [scratch memory allocator] configured using

** [SQLITE_CONFIG_SCRATCH].  The value returned is in allocations, not

** outstanding at time, this parameter also reports the number of threads

** using scratch memory at the same time.</dd>)^

**

** <dd>This parameter returns the number of bytes of scratch memory

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

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

** slots were available.

** </dd>)^

**

** <dd>This parameter records the largest memory allocation request

** handed to [scratch memory allocator].  Only the value returned in the

** *pHighwater parameter to [sqlite3_status()] is of interest.  

** The value written into the *pCurrent parameter is undefined.</dd>)^

**

** <dd>This parameter records the deepest parser stack.  It is only

** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^

** </dl>

** about a single [database connection].  ^The first argument is the

** database connection object to be interrogated.  ^The second argument

** is an integer constant, taken from the set of

** determines the parameter to interrogate.  The set of 

** to grow in future releases of SQLite.

**

** ^The current value of the requested parameter is written into *pCur

/*

** CAPI3REF: Status Parameters for database connections

**

** These constants are the available integer "verbs" that can be passed as

** the second argument to the [sqlite3_db_status()] interface.

** if a discontinued or unsupported verb is invoked.

**

** <dl>

** <dd>This parameter returns the number of lookaside memory slots currently

** checked out.</dd>)^

**

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

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

** the current value is always zero.)^

**

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

** <dd>This parameter returns the number malloc attempts that might have

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

** Only the high-water value is meaningful;

** the current value is always zero.)^

**

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

** <dd>This parameter returns the number malloc attempts that might have

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

** Only the high-water value is meaningful;

** the current value is always zero.)^

**

** <dd>This parameter returns the approximate number of 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.

**

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

** memory used to store the schema for all databases associated

** with the connection - main, temp, and any [ATTACH]-ed databases.)^ 

** [shared cache mode] being enabled.

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

**

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

** and lookaside memory used by all prepared statements associated with

** the database connection.)^

** CAPI3REF: Prepared Statement Status

**

** ^(Each prepared statement maintains various

** of times it has performed specific operations.)^  These counters can

** be used to monitor the performance characteristics of the prepared

** statements.  For example, if the number of table steps greatly exceeds

** ^(This interface is used to retrieve and reset counter values from

** a [prepared statement].  The first argument is the prepared statement

** object to be interrogated.  The second argument

** to be interrogated.)^

** ^The current value of the requested counter is returned.

** ^If the resetFlg is true, then the counter is reset to zero after this

/*

** CAPI3REF: Status Parameters for prepared statements

**

** These preprocessor macros define integer codes that name counter

** values associated with the [sqlite3_stmt_status()] interface.

** The meanings of the various counters are as follows:

**

** <dl>

** <dd>^This is the number of times that SQLite has stepped forward in

** a table as part of a full table scan.  Large numbers for this counter

** may indicate opportunities for performance improvement through 

** careful use of indices.</dd>

**

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

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

** improvement performance through careful use of indices.</dd>

**

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

** the application may discard the parameter after the call to

** [sqlite3_config()] returns.)^

**

** ^(The xInit() method is called once for each effective 

** call to [sqlite3_initialize()])^

** (usually only once during the lifetime of the process). ^(The xInit()

** built-in default page cache is used instead of the application defined

** page cache.)^

**

** ^The xShutdown() method is called by [sqlite3_shutdown()].

** It can be used to clean up 

** any outstanding resources before process shutdown, if required.

** ^SQLite will never invoke xInit() more than once without an intervening

** call to xShutdown().

**

** ^SQLite invokes the xCreate() method to construct a new cache instance.

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

** though this is not guaranteed. ^The

** ^Hence, a cache created with bPurgeable false will

** never contain any unpinned pages.

**

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

** suggested maximum cache-size (number of pages stored by) the cache

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

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

** value; it is advisory only.

**

** The xPagecount() method must return the number of pages currently

** stored in the cache, both pinned and unpinned.

** 

** The xFetch() method locates a page in the cache and returns a pointer to 

** the page, or a NULL pointer.

** A "page", in this context, means a buffer of szPage bytes aligned at an

** 8-byte boundary. The page to be fetched is determined by the key. ^The

** is considered to be "pinned".

**

** If the requested page is already in the page cache, then the page cache

** attempt to unpin one or more cache pages by spilling the content of

** pinned pages to disk and synching the operating system disk cache.

**

** ^xUnpin() is called by SQLite with a pointer to a currently pinned page

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

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

** call to xUnpin() unpins the page regardless of the number of prior calls 

** to xFetch().

**

** The xRekey() method is used to change the key value associated with the

** page passed as the second argument. If the cache

** previously contains an entry associated with newKey, it must be

** of these pages are pinned, they are implicitly unpinned, meaning that

** they can be safely discarded.

**

** ^The xDestroy() method is used to delete a cache allocated by xCreate().

** All resources associated with the specified cache should be freed. ^After

** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]

** There should be exactly one call to sqlite3_backup_finish() for each

** successful call to sqlite3_backup_init().

**

**

** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the 

** [database connection] associated with the destination database 

** sqlite3_backup_finish() functions to perform the specified backup 

** operation.

**

**

** ^Function sqlite3_backup_step(B,N) will copy up to N pages between 

** the source and destination databases specified by [sqlite3_backup] object B.

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

** updated at the same time.

**

**

** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the 

** application wishes to abandon the backup operation, the application

** is not a permanent error and does not affect the return value of

** sqlite3_backup_finish().

**

**

** ^Each call to sqlite3_backup_step() sets two values inside

** the [sqlite3_backup] object: the number of pages still to be backed

#define SQLITE_CHECKPOINT_FULL    1

#define SQLITE_CHECKPOINT_RESTART 2

/*

** Undo the hack that converts floating point types to integer for

typedef struct TriggerStep TriggerStep;

typedef struct UnpackedRecord UnpackedRecord;

typedef struct VTable VTable;

typedef struct Walker Walker;

typedef struct WherePlan WherePlan;

typedef struct WhereInfo WhereInfo;

SQLITE_PRIVATE int sqlite3BtreeOpen(

  const char *zFilename,   /* Name of database file to open */

  sqlite3 *db,             /* Associated database connection */

  Btree **ppBtree,         /* Return open Btree* here */

SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);

SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);

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

SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);

SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, int addr, int P2);

SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, int addr, int P3);

SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*);

SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);

SQLITE_PRIVATE void sqlite3VdbeDeleteObject(sqlite3*,Vdbe*);

SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*);

SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);

SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*);

SQLITE_PRIVATE   void sqlite3VdbeTrace(Vdbe*,FILE*);

#endif

SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);

SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*);

SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int);

SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));

** A thread must be holding a mutex on the corresponding Btree in order

** to access Schema content.  This implies that the thread must also be

** holding a mutex on the sqlite3 connection pointer that owns the Btree.

*/

struct Schema {

  int schema_cookie;   /* Database schema version number for this file */

  int nDb;                      /* Number of backends currently in use */

  Db *aDb;                      /* All backends */

  int flags;                    /* Miscellaneous flags. See below */

  int errCode;                  /* Most recent error code (SQLITE_*) */

  int errMask;                  /* & result codes with this before returning */

  u8 autoCommit;                /* The auto-commit flag. */

  u8 dfltLockMode;              /* Default locking-mode for attached dbs */

  signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */

  u8 suppressErr;               /* Do not issue error messages if true */

  int nextPagesize;             /* Pagesize after VACUUM if >0 */

  int nTable;                   /* Number of tables in the database */

  CollSeq *pDfltColl;           /* The default collating sequence (BINARY) */

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

  Hash aModule;                 /* populated by sqlite3_create_module() */

  VTable **aVTrans;             /* Virtual tables with open transactions */

  int nVTrans;                  /* Allocated size of aVTrans */

  VTable *pDisconnect;    /* Disconnect these in next sqlite3_prepare() */

#define SQLITE_IndexCover     0x10        /* Disable index covering table */

#define SQLITE_GroupByOrder   0x20        /* Disable GROUPBY cover of ORDERBY */

#define SQLITE_FactorOutConst 0x40        /* Disable factoring out constants */

#define SQLITE_OptMask        0xff        /* Mask of all disablable opts */

/*

  Module *pMod;             /* Pointer to module implementation */

  sqlite3_vtab *pVtab;      /* Pointer to vtab instance */

  int nRef;                 /* Number of pointers to this structure */

  VTable *pNext;            /* Next in linked list (see above) */

};

  ** each recursion */

  int nVar;            /* Number of '?' variables seen in the SQL so far */

  Vdbe *pReprepare;    /* VM being reprepared (sqlite3Reprepare()) */

  int nAlias;          /* Number of aliased result set columns */

  int nAliasAlloc;     /* Number of allocated slots for aAlias[] */

  int bMemstat;                     /* True to enable memory status */

  int bCoreMutex;                   /* True to enable core mutexing */

  int bFullMutex;                   /* True to enable full mutexing */

  int mxStrlen;                     /* Maximum string length */

  int szLookaside;                  /* Default lookaside buffer size */

  int nLookaside;                   /* Default lookaside buffer count */

  int nRefInitMutex;                /* Number of users of pInitMutex */

  void (*xLog)(void*,int,const char*); /* Function for logging */

  void *pLogArg;                       /* First argument to xLog() */

};

/*

SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*);

SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);

SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);

SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);

SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32);

SQLITE_PRIVATE int sqlite3Atoi(const char*);

SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);

SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);

/*

** Routines to read and write variable-length integers.  These used to

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

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

SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);

SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);

SQLITE_PRIVATE const char *sqlite3ErrStr(int);

SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);

SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64);

SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64);

SQLITE_PRIVATE int sqlite3AbsInt32(int);

SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);

SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8);

#  define sqlite3VtabLock(X) 

#  define sqlite3VtabUnlock(X)

#  define sqlite3VtabUnlockList(X)

#else

SQLITE_PRIVATE    void sqlite3VtabClear(sqlite3 *db, Table*);

SQLITE_PRIVATE    int sqlite3VtabSync(sqlite3 *db, char **);

SQLITE_PRIVATE    void sqlite3VtabLock(VTable *);

SQLITE_PRIVATE    void sqlite3VtabUnlock(VTable *);

SQLITE_PRIVATE    void sqlite3VtabUnlockList(sqlite3*);

#  define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)

#endif

SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*);

};

#endif

/*

** The following singleton contains the global configuration for

   SQLITE_DEFAULT_MEMSTATUS,  /* bMemstat */

   1,                         /* bCoreMutex */

   SQLITE_THREADSAFE==1,      /* bFullMutex */

   0x7ffffffe,                /* mxStrlen */

   100,                       /* szLookaside */

   500,                       /* nLookaside */

   0,                         /* nRefInitMutex */

   0,                         /* xLog */

   0,                         /* pLogArg */

};

  Mem *aVar;              /* Values for the OP_Variable opcode. */

  char **azVar;           /* Name of variables */

  ynVar nVar;             /* Number of entries in aVar[] */

  u32 cacheCtr;           /* VdbeCursor row cache generation counter */

  int pc;                 /* The program counter */

  int rc;                 /* Value to return */

  u8 errorAction;         /* Recovery action to do in case of an error */

  u8 explain;             /* True if EXPLAIN present on SQL command */

  u8 changeCntOn;         /* True to update the change-counter */

  u8 expired;             /* True if the VM needs to be recompiled */

#ifndef SQLITE_OMIT_DATETIME_FUNCS

/*

** A structure for holding a single date and time.

  p->validTZ = 0;

}

#ifndef SQLITE_OMIT_LOCALTIME

/*

*/

  DateTime x, y;

  time_t t;

  x = *p;

  computeYMD_HMS(&x);

  if( x.Y<1971 || x.Y>=2038 ){

  x.validJD = 0;

  computeJD(&x);

  t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);

  }

  y.validYMD = 1;

  y.validHMS = 1;

  y.validJD = 0;

  y.validTZ = 0;

  computeJD(&y);

  return y.iJD - x.iJD;

}

#endif /* SQLITE_OMIT_LOCALTIME */

**     localtime

**     utc

**

*/

  int rc = 1;

  int n;

  double r;

      */

      if( strcmp(z, "localtime")==0 ){

        computeJD(p);

        clearYMD_HMS_TZ(p);

      }

      break;

    }

      else if( strcmp(z, "utc")==0 ){

        sqlite3_int64 c1;

        computeJD(p);

      }

#endif

      break;

    }

  }

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

  }

  return 0;

}

  sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);

  if( mem0.alarmCallback!=0 ){

    int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);

      mem0.nearlyFull = 1;

      sqlite3MallocAlarm(nFull);

    }else{

** Change the size of an existing memory allocation

*/

SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){

  void *pNew;

  if( pOld==0 ){

    return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */

  }else if( sqlite3GlobalConfig.bMemstat ){

    sqlite3_mutex_enter(mem0.mutex);

    sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);

    }

    assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );

    assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );

        || (c&0xFFFFF800)==0xD800                          \

        || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }        \

  }

  const unsigned char *zIn,       /* First byte of UTF-8 character */

  const unsigned char **pzNext    /* Write first byte past UTF-8 char here */

){

/*

** Translate a single byte of Hex into an integer.

** This routine only works if h really is a valid hexadecimal

** character:  0..9a..fA..F

*/

  assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );

#ifdef SQLITE_ASCII

  h += 9*(1&(h>>6));

#endif

  return (u8)(h & 0xf);