/*

** 2001 September 15

**

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

**

*************************************************************************

** Internal interface definitions for SQLite.

**

** @(#) $Id: sqliteInt.h,v 1.784 2008/10/13 15:35:09 drh Exp $

*/

#ifndef _SQLITEINT_H_

#define _SQLITEINT_H_

/*

** Include the configuration header output by 'configure' if we're using the

** autoconf-based build

*/

#ifdef _HAVE_SQLITE_CONFIG_H

#include "config.h"

#endif

#include "sqliteLimit.h"

/* Disable nuisance warnings on Borland compilers */

#if defined(__BORLANDC__)

#pragma warn -rch /* unreachable code */

#pragma warn -ccc /* Condition is always true or false */

#pragma warn -aus /* Assigned value is never used */

#pragma warn -csu /* Comparing signed and unsigned */

#pragma warn -spa /* Suspicous pointer arithmetic */

#endif

/* Needed for various definitions... */

#ifndef _GNU_SOURCE

# define _GNU_SOURCE

#endif

/*

** Include standard header files as necessary

*/

#ifdef HAVE_STDINT_H

#include <stdint.h>

#endif

#ifdef HAVE_INTTYPES_H

#include <inttypes.h>

#endif

/*

** A macro used to aid in coverage testing.  When doing coverage

** testing, the condition inside the argument must be evaluated 

** both true and false in order to get full branch coverage.

** This macro can be inserted to ensure adequate test coverage

** in places where simple condition/decision coverage is inadequate.

*/

#ifdef SQLITE_COVERAGE_TEST

  void sqlite3Coverage(int);

# define testcase(X)  if( X ){ sqlite3Coverage(__LINE__); }

#else

# define testcase(X)

#endif

/*

** The ALWAYS and NEVER macros surround boolean expressions which 

** are intended to always be true or false, respectively.  Such

** expressions could be omitted from the code completely.  But they

** are included in a few cases in order to enhance the resilience

** of SQLite to unexpected behavior - to make the code "self-healing"

** or "ductile" rather than being "brittle" and crashing at the first

** hint of unplanned behavior.

**

** When doing coverage testing ALWAYS and NEVER are hard-coded to

** be true and false so that the unreachable code then specify will

** not be counted as untested code.

*/

#ifdef SQLITE_COVERAGE_TEST

# define ALWAYS(X)      (1)

# define NEVER(X)       (0)

#else

# define ALWAYS(X)      (X)

# define NEVER(X)       (X)

#endif

/*

** The macro unlikely() is a hint that surrounds a boolean

** expression that is usually false.  Macro likely() surrounds

** a boolean expression that is usually true.  GCC is able to

** use these hints to generate better code, sometimes.

*/

#if defined(__GNUC__) && 0

# define likely(X)    __builtin_expect((X),1)

# define unlikely(X)  __builtin_expect((X),0)

#else

# define likely(X)    !!(X)

# define unlikely(X)  !!(X)

#endif

/*

 * This macro is used to "hide" some ugliness in casting an int

 * value to a ptr value under the MSVC 64-bit compiler.   Casting

 * non 64-bit values to ptr types results in a "hard" error with 

 * the MSVC 64-bit compiler which this attempts to avoid.  

 *

 * A simple compiler pragma or casting sequence could not be found

 * to correct this in all situations, so this macro was introduced.

 *

 * It could be argued that the intptr_t type could be used in this

 * case, but that type is not available on all compilers, or 

 * requires the #include of specific headers which differs between

 * platforms.

 */

#define SQLITE_INT_TO_PTR(X)   ((void*)&((char*)0)[X])

#define SQLITE_PTR_TO_INT(X)   ((int)(((char*)X)-(char*)0))

/*

** These #defines should enable >2GB file support on Posix if the

** underlying operating system supports it.  If the OS lacks

** large file support, or if the OS is windows, these should be no-ops.

**

** Ticket #2739:  The _LARGEFILE_SOURCE macro must appear before any

** system #includes.  Hence, this block of code must be the very first

** code in all source files.

**

** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch

** on the compiler command line.  This is necessary if you are compiling

** on a recent machine (ex: RedHat 7.2) but you want your code to work

** on an older machine (ex: RedHat 6.0).  If you compile on RedHat 7.2

** without this option, LFS is enable.  But LFS does not exist in the kernel

** in RedHat 6.0, so the code won't work.  Hence, for maximum binary

** portability you should omit LFS.

**

** Similar is true for MacOS.  LFS is only supported on MacOS 9 and later.

*/

#ifndef SQLITE_DISABLE_LFS

# define _LARGE_FILE       1

# ifndef _FILE_OFFSET_BITS

#   define _FILE_OFFSET_BITS 64

# endif

# define _LARGEFILE_SOURCE 1

#endif

/*

** The SQLITE_THREADSAFE macro must be defined as either 0 or 1.

** Older versions of SQLite used an optional THREADSAFE macro.

** We support that for legacy

*/

#if !defined(SQLITE_THREADSAFE)

#if defined(THREADSAFE)

# define SQLITE_THREADSAFE THREADSAFE

#else

# define SQLITE_THREADSAFE 1

#endif

#endif

/*

** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.

** It determines whether or not the features related to 

** SQLITE_CONFIG_MEMSTATUS are availabe by default or not. This value can

** be overridden at runtime using the sqlite3_config() API.

*/

#if !defined(SQLITE_DEFAULT_MEMSTATUS)

# define SQLITE_DEFAULT_MEMSTATUS 1

#endif

/*

** Exactly one of the following macros must be defined in order to

** specify which memory allocation subsystem to use.

**

**     SQLITE_SYSTEM_MALLOC          // Use normal system malloc()

**     SQLITE_MEMDEBUG               // Debugging version of system malloc()

**     SQLITE_MEMORY_SIZE            // internal allocator #1

**     SQLITE_MMAP_HEAP_SIZE         // internal mmap() allocator

**     SQLITE_POW2_MEMORY_SIZE       // internal power-of-two allocator

**

** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as

** the default.

*/

#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)+\

    defined(SQLITE_MEMORY_SIZE)+defined(SQLITE_MMAP_HEAP_SIZE)+\

    defined(SQLITE_POW2_MEMORY_SIZE)>1

# error "At most one of the following compile-time configuration options\

 is allows: SQLITE_SYSTEM_MALLOC, SQLITE_MEMDEBUG, SQLITE_MEMORY_SIZE,\

 SQLITE_MMAP_HEAP_SIZE, SQLITE_POW2_MEMORY_SIZE"

#endif

#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_MEMDEBUG)+\

    defined(SQLITE_MEMORY_SIZE)+defined(SQLITE_MMAP_HEAP_SIZE)+\

    defined(SQLITE_POW2_MEMORY_SIZE)==0

# define SQLITE_SYSTEM_MALLOC 1

#endif

/*

** If SQLITE_MALLOC_SOFT_LIMIT is defined, then try to keep the

** sizes of memory allocations below this value where possible.

*/

#if defined(SQLITE_POW2_MEMORY_SIZE) && !defined(SQLITE_MALLOC_SOFT_LIMIT)

# define SQLITE_MALLOC_SOFT_LIMIT 1024

#endif

/*

** We need to define _XOPEN_SOURCE as follows in order to enable

** recursive mutexes on most unix systems.  But Mac OS X is different.

** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,

** so it is omitted there.  See ticket #2673.

**

** Later we learn that _XOPEN_SOURCE is poorly or incorrectly

** implemented on some systems.  So we avoid defining it at all

** if it is already defined or if it is unneeded because we are

** not doing a threadsafe build.  Ticket #2681.

**

** See also ticket #2741.

*/

#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE

#  define _XOPEN_SOURCE 500  /* Needed to enable pthread recursive mutexes */

#endif

/*

** The TCL headers are only needed when compiling the TCL bindings.

*/

#if defined(SQLITE_TCL) || defined(TCLSH)

# include <tcl.h>

#endif

/*

** Many people are failing to set -DNDEBUG=1 when compiling SQLite.

** Setting NDEBUG makes the code smaller and run faster.  So the following

** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1

** option is set.  Thus NDEBUG becomes an opt-in rather than an opt-out

** feature.

*/

#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 

# define NDEBUG 1

#endif

#include "sqlite3.h"

#include "hash.h"

#include "parse.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include <stddef.h>

/*

** If compiling for a processor that lacks floating point support,

** substitute integer for floating-point

*/

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite_int64

# define LONGDOUBLE_TYPE sqlite_int64

# ifndef SQLITE_BIG_DBL

#   define SQLITE_BIG_DBL (0x7fffffffffffffff)

# endif

# define SQLITE_OMIT_DATETIME_FUNCS 1

# define SQLITE_OMIT_TRACE 1

# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT

#endif

#ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (1e99)

#endif

/*

** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0

** afterward. Having this macro allows us to cause the C compiler 

** to omit code used by TEMP tables without messy #ifndef statements.

*/

#ifdef SQLITE_OMIT_TEMPDB

#define OMIT_TEMPDB 1

#else

#define OMIT_TEMPDB 0

#endif

/*

** If the following macro is set to 1, then NULL values are considered

** distinct when determining whether or not two entries are the same

** in a UNIQUE index.  This is the way PostgreSQL, Oracle, DB2, MySQL,

** OCELOT, and Firebird all work.  The SQL92 spec explicitly says this

** is the way things are suppose to work.

**

** If the following macro is set to 0, the NULLs are indistinct for

** a UNIQUE index.  In this mode, you can only have a single NULL entry

** for a column declared UNIQUE.  This is the way Informix and SQL Server

** work.

*/

#define NULL_DISTINCT_FOR_UNIQUE 1

/*

** The "file format" number is an integer that is incremented whenever

** the VDBE-level file format changes.  The following macros define the

** the default file format for new databases and the maximum file format

** that the library can read.

*/

#define SQLITE_MAX_FILE_FORMAT 4

#ifndef SQLITE_DEFAULT_FILE_FORMAT

# define SQLITE_DEFAULT_FILE_FORMAT 1

#endif

/*

** Provide a default value for SQLITE_TEMP_STORE in case it is not specified

** on the command-line

*/

#ifndef SQLITE_TEMP_STORE

# define SQLITE_TEMP_STORE 1

#endif

/*

** GCC does not define the offsetof() macro so we'll have to do it

** ourselves.

*/

#ifndef offsetof

#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))

#endif

/*

** Check to see if this machine uses EBCDIC.  (Yes, believe it or

** not, there are still machines out there that use EBCDIC.)

*/

#if 'A' == '\301'

# define SQLITE_EBCDIC 1

#else

# define SQLITE_ASCII 1

#endif

/*

** Integers of known sizes.  These typedefs might change for architectures

** where the sizes very.  Preprocessor macros are available so that the

** types can be conveniently redefined at compile-type.  Like this:

**

**         cc '-DUINTPTR_TYPE=long long int' ...

*/

#ifndef UINT32_TYPE

# ifdef HAVE_UINT32_T

#  define UINT32_TYPE uint32_t

# else

#  define UINT32_TYPE unsigned int

# endif

#endif

#ifndef UINT16_TYPE

# ifdef HAVE_UINT16_T

#  define UINT16_TYPE uint16_t

# else

#  define UINT16_TYPE unsigned short int

# endif

#endif

#ifndef INT16_TYPE

# ifdef HAVE_INT16_T

#  define INT16_TYPE int16_t

# else

#  define INT16_TYPE short int

# endif

#endif

#ifndef UINT8_TYPE

# ifdef HAVE_UINT8_T

#  define UINT8_TYPE uint8_t

# else

#  define UINT8_TYPE unsigned char

# endif

#endif

#ifndef INT8_TYPE

# ifdef HAVE_INT8_T

#  define INT8_TYPE int8_t

# else

#  define INT8_TYPE signed char

# endif

#endif

#ifndef LONGDOUBLE_TYPE

# define LONGDOUBLE_TYPE long double

#endif

typedef sqlite_int64 i64;          /* 8-byte signed integer */

typedef sqlite_uint64 u64;         /* 8-byte unsigned integer */

typedef UINT32_TYPE u32;           /* 4-byte unsigned integer */

typedef UINT16_TYPE u16;           /* 2-byte unsigned integer */

typedef INT16_TYPE i16;            /* 2-byte signed integer */

typedef UINT8_TYPE u8;             /* 1-byte unsigned integer */

typedef INT8_TYPE i8;              /* 1-byte signed integer */

/*

** Macros to determine whether the machine is big or little endian,

** evaluated at runtime.

*/

#ifdef SQLITE_AMALGAMATION

const int sqlite3one;

#else

extern const int sqlite3one;

#endif

#if defined(i386) || defined(__i386__) || defined(_M_IX86)\

                             || defined(__x86_64) || defined(__x86_64__)

# define SQLITE_BIGENDIAN    0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE  SQLITE_UTF16LE

#else

# define SQLITE_BIGENDIAN    (*(char *)(&sqlite3one)==0)

# define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)

# define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)

#endif

/*

** Constants for the largest and smallest possible 64-bit signed integers.

** These macros are designed to work correctly on both 32-bit and 64-bit

** compilers.

*/

#define LARGEST_INT64  (0xffffffff|(((i64)0x7fffffff)<<32))

#define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)

/*

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

** callback for a given sqlite handle. 

**

** The sqlite.busyHandler member of the sqlite struct contains the busy

** callback for the database handle. Each pager opened via the sqlite

** handle is passed a pointer to sqlite.busyHandler. The busy-handler

** callback is currently invoked only from within pager.c.

*/

typedef struct BusyHandler BusyHandler;

struct BusyHandler {

  int (*xFunc)(void *,int);  /* The busy callback */

  void *pArg;                /* First arg to busy callback */

  int nBusy;                 /* Incremented with each busy call */

};

/*

** Name of the master database table.  The master database table

** is a special table that holds the names and attributes of all

** user tables and indices.

*/

#define MASTER_NAME       "sqlite_master"

#define TEMP_MASTER_NAME  "sqlite_temp_master"

/*

** The root-page of the master database table.

*/

#define MASTER_ROOT       1

/*

** The name of the schema table.

*/

#define SCHEMA_TABLE(x)  ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

/*

** A convenience macro that returns the number of elements in

** an array.

*/

#define ArraySize(X)    (sizeof(X)/sizeof(X[0]))

/*

** The following value as a destructor means to use sqlite3DbFree().

** This is an internal extension to SQLITE_STATIC and SQLITE_TRANSIENT.

*/

#define SQLITE_DYNAMIC   ((sqlite3_destructor_type)sqlite3DbFree)

/*

** When SQLITE_OMIT_WSD is defined, it means that the target platform does

** not support Writable Static Data (WSD) such as global and static variables.

** All variables must either be on the stack or dynamically allocated from

** the heap.  When WSD is unsupported, the variable declarations scattered

** throughout the SQLite code must become constants instead.  The SQLITE_WSD

** macro is used for this purpose.  And instead of referencing the variable

** directly, we use its constant as a key to lookup the run-time allocated

** buffer that holds real variable.  The constant is also the initializer

** for the run-time allocated buffer.

**

** In the usually case where WSD is supported, the SQLITE_WSD and GLOBAL

** macros become no-ops and have zero performance impact.

*/

#ifdef SQLITE_OMIT_WSD

  #define SQLITE_WSD const

  #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))

  #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)

  int sqlite3_wsd_init(int N, int J);

  void *sqlite3_wsd_find(void *K, int L);

#else

  #define SQLITE_WSD 

  #define GLOBAL(t,v) v

  #define sqlite3GlobalConfig sqlite3Config

#endif

/*

** Forward references to structures

*/

typedef struct AggInfo AggInfo;

typedef struct AuthContext AuthContext;

typedef struct Bitvec Bitvec;

typedef struct CollSeq CollSeq;

typedef struct Column Column;

typedef struct Db Db;

typedef struct Schema Schema;

typedef struct Expr Expr;

typedef struct ExprList ExprList;

typedef struct FKey FKey;

typedef struct FuncDef FuncDef;

typedef struct FuncDefHash FuncDefHash;

typedef struct IdList IdList;

typedef struct Index Index;

typedef struct KeyClass KeyClass;

typedef struct KeyInfo KeyInfo;

typedef struct Lookaside Lookaside;

typedef struct LookasideSlot LookasideSlot;

typedef struct Module Module;

typedef struct NameContext NameContext;

typedef struct Parse Parse;

typedef struct Select Select;

typedef struct SrcList SrcList;

typedef struct StrAccum StrAccum;

typedef struct Table Table;

typedef struct TableLock TableLock;

typedef struct Token Token;

typedef struct TriggerStack TriggerStack;

typedef struct TriggerStep TriggerStep;

typedef struct Trigger Trigger;

typedef struct UnpackedRecord UnpackedRecord;

typedef struct Walker Walker;

typedef struct WhereInfo WhereInfo;

typedef struct WhereLevel WhereLevel;

/*

** Defer sourcing vdbe.h and btree.h until after the "u8" and 

** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque

** pointer types (i.e. FuncDef) defined above.

*/

#include "btree.h"

#include "vdbe.h"

#include "pager.h"

#include "pcache.h"

#include "os.h"

#include "mutex.h"

/*

** Each database file to be accessed by the system is an instance

** of the following structure.  There are normally two of these structures

** in the sqlite.aDb[] array.  aDb[0] is the main database file and

** aDb[1] is the database file used to hold temporary tables.  Additional

** databases may be attached.

*/

struct Db {

  char *zName;         /* Name of this database */

  Btree *pBt;          /* The B*Tree structure for this database file */

  u8 inTrans;          /* 0: not writable.  1: Transaction.  2: Checkpoint */

  u8 safety_level;     /* How aggressive at synching data to disk */

  void *pAux;               /* Auxiliary data.  Usually NULL */

  void (*xFreeAux)(void*);  /* Routine to free pAux */

  Schema *pSchema;     /* Pointer to database schema (possibly shared) */

};

/*

** An instance of the following structure stores a database schema.

**

** If there are no virtual tables configured in this schema, the

** Schema.db variable is set to NULL. After the first virtual table

** has been added, it is set to point to the database connection 

** used to create the connection. Once a virtual table has been

** added to the Schema structure and the Schema.db variable populated, 

** only that database connection may use the Schema to prepare 

** statements.

*/

struct Schema {

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

  Hash tblHash;        /* All tables indexed by name */

  Hash idxHash;        /* All (named) indices indexed by name */

  Hash trigHash;       /* All triggers indexed by name */

  Hash aFKey;          /* Foreign keys indexed by to-table */

  Table *pSeqTab;      /* The sqlite_sequence table used by AUTOINCREMENT */

  u8 file_format;      /* Schema format version for this file */

  u8 enc;              /* Text encoding used by this database */

  u16 flags;           /* Flags associated with this schema */

  int cache_size;      /* Number of pages to use in the cache */

#ifndef SQLITE_OMIT_VIRTUALTABLE

  sqlite3 *db;         /* "Owner" connection. See comment above */

#endif

};

/*

** These macros can be used to test, set, or clear bits in the 

** Db.flags field.

*/

#define DbHasProperty(D,I,P)     (((D)->aDb[I].pSchema->flags&(P))==(P))

#define DbHasAnyProperty(D,I,P)  (((D)->aDb[I].pSchema->flags&(P))!=0)

#define DbSetProperty(D,I,P)     (D)->aDb[I].pSchema->flags|=(P)

#define DbClearProperty(D,I,P)   (D)->aDb[I].pSchema->flags&=~(P)

/*

** Allowed values for the DB.flags field.

**

** The DB_SchemaLoaded flag is set after the database schema has been

** read into internal hash tables.

**

** DB_UnresetViews means that one or more views have column names that

** have been filled out.  If the schema changes, these column names might

** changes and so the view will need to be reset.

*/

#define DB_SchemaLoaded    0x0001  /* The schema has been loaded */

#define DB_UnresetViews    0x0002  /* Some views have defined column names */

#define DB_Empty           0x0004  /* The file is empty (length 0 bytes) */

/*

** The number of different kinds of things that can be limited

** using the sqlite3_limit() interface.

*/

#define SQLITE_N_LIMIT (SQLITE_LIMIT_VARIABLE_NUMBER+1)

/*

** Lookaside malloc is a set of fixed-size buffers that can be used

** to satisify small transient memory allocation requests for objects

** associated with a particular database connection.  The use of

** lookaside malloc provides a significant performance enhancement

** (approx 10%) by avoiding numerous malloc/free requests while parsing

** SQL statements.

**

** The Lookaside structure holds configuration information about the

** lookaside malloc subsystem.  Each available memory allocation in

** the lookaside subsystem is stored on a linked list of LookasideSlot

** objects.

*/

struct Lookaside {

  u16 sz;                 /* Size of each buffer in bytes */

  u8 bEnabled;            /* True if use lookaside.  False to ignore it */

  u8 bMalloced;           /* True if pStart obtained from sqlite3_malloc() */

  int nOut;               /* Number of buffers currently checked out */

  int mxOut;              /* Highwater mark for nOut */

  LookasideSlot *pFree;   /* List of available buffers */

  void *pStart;           /* First byte of available memory space */

  void *pEnd;             /* First byte past end of available space */

};

struct LookasideSlot {

  LookasideSlot *pNext;    /* Next buffer in the list of free buffers */

};

/*

** A hash table for function definitions.

**

** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.

** Collisions are on the FuncDef.pHash chain.

*/

struct FuncDefHash {

  FuncDef *a[23];       /* Hash table for functions */

};

/*

** Each database is an instance of the following structure.

**

** The sqlite.lastRowid records the last insert rowid generated by an

** insert statement.  Inserts on views do not affect its value.  Each

** trigger has its own context, so that lastRowid can be updated inside

** triggers as usual.  The previous value will be restored once the trigger

** exits.  Upon entering a before or instead of trigger, lastRowid is no

** longer (since after version 2.8.12) reset to -1.

**

** The sqlite.nChange does not count changes within triggers and keeps no

** context.  It is reset at start of sqlite3_exec.

** The sqlite.lsChange represents the number of changes made by the last

** insert, update, or delete statement.  It remains constant throughout the

** length of a statement and is then updated by OP_SetCounts.  It keeps a

** context stack just like lastRowid so that the count of changes

** within a trigger is not seen outside the trigger.  Changes to views do not

** affect the value of lsChange.

** The sqlite.csChange keeps track of the number of current changes (since

** the last statement) and is used to update sqlite_lsChange.

**

** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16

** store the most recent error code and, if applicable, string. The

** internal function sqlite3Error() is used to set these variables

** consistently.

*/

struct sqlite3 {

  sqlite3_vfs *pVfs;            /* OS Interface */

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

  Db *aDb;                      /* All backends */

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

  int openFlags;                /* Flags passed to sqlite3_vfs.xOpen() */

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

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

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

  u8 temp_store;                /* 1: file 2: memory 0: default */

  u8 mallocFailed;              /* True if we have seen a malloc failure */

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

  u8 dfltJournalMode;           /* Default journal mode for attached dbs */

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

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

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

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

  i64 lastRowid;                /* ROWID of most recent insert (see above) */

  i64 priorNewRowid;            /* Last randomly generated ROWID */

  int magic;                    /* Magic number for detect library misuse */

  int nChange;                  /* Value returned by sqlite3_changes() */

  int nTotalChange;             /* Value returned by sqlite3_total_changes() */

  sqlite3_mutex *mutex;         /* Connection mutex */

  int aLimit[SQLITE_N_LIMIT];   /* Limits */

  struct sqlite3InitInfo {      /* Information used during initialization */

    int iDb;                    /* When back is being initialized */

    int newTnum;                /* Rootpage of table being initialized */

    u8 busy;                    /* TRUE if currently initializing */

  } init;

  int nExtension;               /* Number of loaded extensions */

  void **aExtension;            /* Array of shared libraray handles */

  struct Vdbe *pVdbe;           /* List of active virtual machines */

  int activeVdbeCnt;            /* Number of vdbes currently executing */

  void (*xTrace)(void*,const char*);        /* Trace function */

  void *pTraceArg;                          /* Argument to the trace function */

  void (*xProfile)(void*,const char*,u64);  /* Profiling function */

  void *pProfileArg;                        /* Argument to profile function */

  void *pCommitArg;                 /* Argument to xCommitCallback() */   

  int (*xCommitCallback)(void*);    /* Invoked at every commit. */

  void *pRollbackArg;               /* Argument to xRollbackCallback() */   

  void (*xRollbackCallback)(void*); /* Invoked at every commit. */

  void *pUpdateArg;

  void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);

  void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);

  void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);

  void *pCollNeededArg;

  sqlite3_value *pErr;          /* Most recent error message */

  char *zErrMsg;                /* Most recent error message (UTF-8 encoded) */

  char *zErrMsg16;              /* Most recent error message (UTF-16 encoded) */

  union {

    volatile int isInterrupted; /* True if sqlite3_interrupt has been called */

    double notUsed1;            /* Spacer */

  } u1;

  Lookaside lookaside;          /* Lookaside malloc configuration */

#ifndef SQLITE_OMIT_AUTHORIZATION

  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);

                                /* Access authorization function */

  void *pAuthArg;               /* 1st argument to the access auth function */

#endif

#ifndef SQLITE_OMIT_PROGRESS_CALLBACK

  int (*xProgress)(void *);     /* The progress callback */

  void *pProgressArg;           /* Argument to the progress callback */

  int nProgressOps;             /* Number of opcodes for progress callback */

#endif

#ifndef SQLITE_OMIT_VIRTUALTABLE

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

  Table *pVTab;                 /* vtab with active Connect/Create method */

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

  int nVTrans;                  /* Allocated size of aVTrans */

#endif

  FuncDefHash aFunc;            /* Hash table of connection functions */

  Hash aCollSeq;                /* All collating sequences */

  BusyHandler busyHandler;      /* Busy callback */

  int busyTimeout;              /* Busy handler timeout, in msec */

  Db aDbStatic[2];              /* Static space for the 2 default backends */

#ifdef SQLITE_SSE

  sqlite3_stmt *pFetch;         /* Used by SSE to fetch stored statements */

#endif

};

/*

** A macro to discover the encoding of a database.

*/

#define ENC(db) ((db)->aDb[0].pSchema->enc)

/*

** Possible values for the sqlite.flags and or Db.flags fields.

**

** On sqlite.flags, the SQLITE_InTrans value means that we have

** executed a BEGIN.  On Db.flags, SQLITE_InTrans means a statement

** transaction is active on that particular database file.

*/

#define SQLITE_VdbeTrace      0x00000001  /* True to trace VDBE execution */

#define SQLITE_InTrans        0x00000008  /* True if in a transaction */

#define SQLITE_InternChanges  0x00000010  /* Uncommitted Hash table changes */

#define SQLITE_FullColNames   0x00000020  /* Show full column names on SELECT */

#define SQLITE_ShortColNames  0x00000040  /* Show short columns names */

#define SQLITE_CountRows      0x00000080  /* Count rows changed by INSERT, */

                                          /*   DELETE, or UPDATE and return */

                                          /*   the count using a callback. */

#define SQLITE_NullCallback   0x00000100  /* Invoke the callback once if the */

                                          /*   result set is empty */

#define SQLITE_SqlTrace       0x00000200  /* Debug print SQL as it executes */

#define SQLITE_VdbeListing    0x00000400  /* Debug listings of VDBE programs */

#define SQLITE_WriteSchema    0x00000800  /* OK to update SQLITE_MASTER */

#define SQLITE_NoReadlock     0x00001000  /* Readlocks are omitted when 

                                          ** accessing read-only databases */

#define SQLITE_IgnoreChecks   0x00002000  /* Do not enforce check constraints */

#define SQLITE_ReadUncommitted 0x00004000 /* For shared-cache mode */

#define SQLITE_LegacyFileFmt  0x00008000  /* Create new databases in format 1 */

#define SQLITE_FullFSync      0x00010000  /* Use full fsync on the backend */

#define SQLITE_LoadExtension  0x00020000  /* Enable load_extension */

#define SQLITE_RecoveryMode   0x00040000  /* Ignore schema errors */

#define SQLITE_SharedCache    0x00080000  /* Cache sharing is enabled */

#define SQLITE_Vtab           0x00100000  /* There exists a virtual table */

/*

** Possible values for the sqlite.magic field.

** The numbers are obtained at random and have no special meaning, other

** than being distinct from one another.

*/

#define SQLITE_MAGIC_OPEN     0xa029a697  /* Database is open */

#define SQLITE_MAGIC_CLOSED   0x9f3c2d33  /* Database is closed */

#define SQLITE_MAGIC_SICK     0x4b771290  /* Error and awaiting close */

#define SQLITE_MAGIC_BUSY     0xf03b7906  /* Database currently in use */

#define SQLITE_MAGIC_ERROR    0xb5357930  /* An SQLITE_MISUSE error occurred */

/*

** Each SQL function is defined by an instance of the following

** structure.  A pointer to this structure is stored in the sqlite.aFunc

** hash table.  When multiple functions have the same name, the hash table

** points to a linked list of these structures.

*/

struct FuncDef {

  i16 nArg;            /* Number of arguments.  -1 means unlimited */

  u8 iPrefEnc;         /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */

  u8 flags;            /* Some combination of SQLITE_FUNC_* */

  void *pUserData;     /* User data parameter */

  FuncDef *pNext;      /* Next function with same name */

  void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */

  void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */

  void (*xFinalize)(sqlite3_context*);                /* Aggregate finializer */

  char *zName;         /* SQL name of the function. */

  FuncDef *pHash;      /* Next with a different name but the same hash */

};

/*

** Possible values for FuncDef.flags

*/

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

#define SQLITE_FUNC_CASE     0x02 /* Case-sensitive LIKE-type function */

#define SQLITE_FUNC_EPHEM    0x04 /* Ephermeral.  Delete with VDBE */

#define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */

/*

** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are

** used to create the initializers for the FuncDef structures.

**

**   FUNCTION(zName, nArg, iArg, bNC, xFunc)

**     Used to create a scalar function definition of a function zName 

**     implemented by C function xFunc that accepts nArg arguments. The

**     value passed as iArg is cast to a (void*) and made available

**     as the user-data (sqlite3_user_data()) for the function. If 

**     argument bNC is true, then the FuncDef.needCollate flag is set.

**

**   AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)

**     Used to create an aggregate function definition implemented by

**     the C functions xStep and xFinal. The first four parameters

**     are interpreted in the same way as the first 4 parameters to

**     FUNCTION().

**

**   LIKEFUNC(zName, nArg, pArg, flags)

**     Used to create a scalar function definition of a function zName 

**     that accepts nArg arguments and is implemented by a call to C 

**     function likeFunc. Argument pArg is cast to a (void *) and made

**     available as the function user-data (sqlite3_user_data()). The

**     FuncDef.flags variable is set to the value passed as the flags

**     parameter.

*/

#define FUNCTION(zName, nArg, iArg, bNC, xFunc) \

  {nArg, SQLITE_UTF8, bNC*8, SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName}

#define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \

  {nArg, SQLITE_UTF8, bNC*8, pArg, 0, xFunc, 0, 0, #zName}

#define LIKEFUNC(zName, nArg, arg, flags) \

  {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName}

#define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \

  {nArg, SQLITE_UTF8, nc*8, SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal, #zName}

/*

** Each SQLite module (virtual table definition) is defined by an

** instance of the following structure, stored in the sqlite3.aModule

** hash table.

*/

struct Module {

  const sqlite3_module *pModule;       /* Callback pointers */

  const char *zName;                   /* Name passed to create_module() */

  void *pAux;                          /* pAux passed to create_module() */

  void (*xDestroy)(void *);            /* Module destructor function */

};

/*

** information about each column of an SQL table is held in an instance

** of this structure.

*/

struct Column {

  char *zName;     /* Name of this column */

  Expr *pDflt;     /* Default value of this column */

  char *zType;     /* Data type for this column */

  char *zColl;     /* Collating sequence.  If NULL, use the default */

  u8 notNull;      /* True if there is a NOT NULL constraint */

  u8 isPrimKey;    /* True if this column is part of the PRIMARY KEY */

  char affinity;   /* One of the SQLITE_AFF_... values */

#ifndef SQLITE_OMIT_VIRTUALTABLE

  u8 isHidden;     /* True if this column is 'hidden' */

#endif

};

/*

** A "Collating Sequence" is defined by an instance of the following

** structure. Conceptually, a collating sequence consists of a name and

** a comparison routine that defines the order of that sequence.

**

** There may two seperate implementations of the collation function, one

** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that

** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine

** native byte order. When a collation sequence is invoked, SQLite selects

** the version that will require the least expensive encoding

** translations, if any.

**

** The CollSeq.pUser member variable is an extra parameter that passed in

** as the first argument to the UTF-8 comparison function, xCmp.

** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function,

** xCmp16.

**

** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the

** collating sequence is undefined.  Indices built on an undefined

** collating sequence may not be read or written.

*/

struct CollSeq {

  char *zName;          /* Name of the collating sequence, UTF-8 encoded */

  u8 enc;               /* Text encoding handled by xCmp() */

  u8 type;              /* One of the SQLITE_COLL_... values below */

  void *pUser;          /* First argument to xCmp() */

  int (*xCmp)(void*,int, const void*, int, const void*);

  void (*xDel)(void*);  /* Destructor for pUser */

};

/*

** Allowed values of CollSeq.type:

*/

#define SQLITE_COLL_BINARY  1  /* The default memcmp() collating sequence */

#define SQLITE_COLL_NOCASE  2  /* The built-in NOCASE collating sequence */

#define SQLITE_COLL_REVERSE 3  /* The built-in REVERSE collating sequence */

#define SQLITE_COLL_USER    0  /* Any other user-defined collating sequence */

/*

** A sort order can be either ASC or DESC.

*/

#define SQLITE_SO_ASC       0  /* Sort in ascending order */

#define SQLITE_SO_DESC      1  /* Sort in ascending order */

/*

** Column affinity types.

**

** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and

** 't' for SQLITE_AFF_TEXT.  But we can save a little space and improve

** the speed a little by numbering the values consecutively.  

**

** But rather than start with 0 or 1, we begin with 'a'.  That way,

** when multiple affinity types are concatenated into a string and

** used as the P4 operand, they will be more readable.

**

** Note also that the numeric types are grouped together so that testing

** for a numeric type is a single comparison.

*/

#define SQLITE_AFF_TEXT     'a'

#define SQLITE_AFF_NONE     'b'

#define SQLITE_AFF_NUMERIC  'c'

#define SQLITE_AFF_INTEGER  'd'

#define SQLITE_AFF_REAL     'e'

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

/*

** The SQLITE_AFF_MASK values masks off the significant bits of an

** affinity value. 

*/

#define SQLITE_AFF_MASK     0x67

/*

** Additional bit values that can be ORed with an affinity without

** changing the affinity.

*/

#define SQLITE_JUMPIFNULL   0x08  /* jumps if either operand is NULL */

#define SQLITE_STOREP2      0x10  /* Store result in reg[P2] rather than jump */

/*

** Each SQL table is represented in memory by an instance of the

** following structure.

**

** Table.zName is the name of the table.  The case of the original

** CREATE TABLE statement is stored, but case is not significant for

** comparisons.

**

** Table.nCol is the number of columns in this table.  Table.aCol is a

** pointer to an array of Column structures, one for each column.

**

** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of

** the column that is that key.   Otherwise Table.iPKey is negative.  Note

** that the datatype of the PRIMARY KEY must be INTEGER for this field to

** be set.  An INTEGER PRIMARY KEY is used as the rowid for each row of

** the table.  If a table has no INTEGER PRIMARY KEY, then a random rowid

** is generated for each row of the table.  TF_HasPrimaryKey is set if

** the table has any PRIMARY KEY, INTEGER or otherwise.

**

** Table.tnum is the page number for the root BTree page of the table in the

** database file.  If Table.iDb is the index of the database table backend

** in sqlite.aDb[].  0 is for the main database and 1 is for the file that

** holds temporary tables and indices.  If TF_Ephemeral is set

** then the table is stored in a file that is automatically deleted

** when the VDBE cursor to the table is closed.  In this case Table.tnum 

** refers VDBE cursor number that holds the table open, not to the root

** page number.  Transient tables are used to hold the results of a

** sub-query that appears instead of a real table name in the FROM clause