/*

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

**

*/

#ifndef _SQLITEINT_H_

#define _SQLITEINT_H_

/*

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

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

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

**

** 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: Red Hat 7.2) but you want your code to work

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

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

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

** portability you should omit LFS.

**

** Similar is true for Mac OS X. LFS is only supported on Mac OS X 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

/*

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

/*

** The following macros are used to cast pointers to integers and

** integers to pointers. The way you do this varies from one compiler

** to the next, so we have developed the following set of #if statements

** to generate appropriate macros for a wide range of compilers.

**

** The correct "ANSI" way to do this is to use the intptr_t type.

** Unfortunately, that typedef is not available on all compilers, or

** if it is available, it requires an #include of specific headers

** that vary from one machine to the next.

**

** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on

** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).

** So we have to define the macros in different ways depending on the

** compiler.

*/

#if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */

# define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))

#elif !defined(__GNUC__) /* Works for compilers other than LLVM */

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

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

#elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */

# define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))

#else /* Generates a warning - but it always works */

# define SQLITE_INT_TO_PTR(X) ((void*)(X))

# define SQLITE_PTR_TO_INT(X) ((int)(X))

#endif

/*

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

** 0 means mutexes are permanently disable and the library is never

** threadsafe. 1 means the library is serialized which is the highest

** level of threadsafety. 2 means the libary is multithreaded - multiple

** threads can use SQLite as long as no two threads try to use the same

** database connection at the same time.

**

** 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 /* IMP: R-07272-22309 */

#endif

#endif

/*

** Powersafe overwrite is on by default. But can be turned off using

** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.

*/

#ifndef SQLITE_POWERSAFE_OVERWRITE

# define SQLITE_POWERSAFE_OVERWRITE 1

#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 available 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_WIN32_MALLOC // Use Win32 native heap API

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

**

** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the

** assert() macro is enabled, each call into the Win32 native heap subsystem

** will cause HeapValidate to be called. If heap validation should fail, an

** assertion will be triggered.

**

** (Historical note: There used to be several other options, but we've

** pared it down to just these three.)

**

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

** the default.

*/

#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)>1

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

is allows: SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG"

#endif

#if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)==0

# define SQLITE_SYSTEM_MALLOC 1

#endif

/*

** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the

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

*/

#if !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

/*

** The testcase() macro is used to aid in coverage testing. When

** doing coverage testing, the condition inside the argument to

** testcase() must be evaluated both true and false in order to

** get full branch coverage. The testcase() macro is inserted

** to help ensure adequate test coverage in places where simple

** condition/decision coverage is inadequate. For example, testcase()

** can be used to make sure boundary values are tested. For

** bitmask tests, testcase() can be used to make sure each bit

** is significant and used at least once. On switch statements

** where multiple cases go to the same block of code, testcase()

** can insure that all cases are evaluated.

**

*/

#ifdef SQLITE_COVERAGE_TEST

void sqlite3Coverage(int);

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

#else

# define testcase(X)

#endif

/*

** The TESTONLY macro is used to enclose variable declarations or

** other bits of code that are needed to support the arguments

** within testcase() and assert() macros.

*/

#if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)

# define TESTONLY(X) X

#else

# define TESTONLY(X)

#endif

/*

** Sometimes we need a small amount of code such as a variable initialization

** to setup for a later assert() statement. We do not want this code to

** appear when assert() is disabled. The following macro is therefore

** used to contain that setup code. The "VVA" acronym stands for

** "Verification, Validation, and Accreditation". In other words, the

** code within VVA_ONLY() will only run during verification processes.

*/

#ifndef NDEBUG

# define VVA_ONLY(X) X

#else

# define VVA_ONLY(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.

**

** In other words, ALWAYS and NEVER are added for defensive code.

**

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

*/

#if defined(SQLITE_COVERAGE_TEST)

# define ALWAYS(X) (1)

# define NEVER(X) (0)

#elif !defined(NDEBUG)

# define ALWAYS(X) ((X)?1:(assert(0),0))

# define NEVER(X) ((X)?(assert(0),1):0)

#else

# define ALWAYS(X) (X)

# define NEVER(X) (X)

#endif

/*

** Return true (non-zero) if the input is a integer that is too large

** to fit in 32-bits. This macro is used inside of various testcase()

** macros to verify that we have tested SQLite for large-file support.

*/

#define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)

/*

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

#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 float sqlite_int64

# define LONGDOUBLE_TYPE sqlite_int64

# ifndef SQLITE_BIG_DBL

# define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)

# endif

# define SQLITE_OMIT_DATETIME_FUNCS 1

# define SQLITE_OMIT_TRACE 1

# undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT

# undef SQLITE_HAVE_ISNAN

#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

/*

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

#endif

/*

** Determine whether triggers are recursive by default. This can be

** changed at run-time using a pragma.

*/

#ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS

# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

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

/*

** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value

** that can be stored in a u32 without loss of data. The value

** is 0x00000000ffffffff. But because of quirks of some compilers, we

** have to specify the value in the less intuitive manner shown:

*/

#define SQLITE_MAX_U32 ((((u64)1)<<32)-1)

/*

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

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

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

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

*/

#ifdef SQLITE_64BIT_STATS

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

#else

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

#endif

/*

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

** evaluated at runtime.

*/

#ifdef SQLITE_AMALGAMATION

const int sqlite3one = 1;

#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)

/*

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

** to force 8-byte alignment on 64-bit architectures.

*/

#define ROUND8(x) (((x)+7)&~7)

/*

** Round down to the nearest multiple of 8

*/

#define ROUNDDOWN8(x) ((x)&~7)

/*

** Assert that the pointer X is aligned to an 8-byte boundary. This

** macro is used only within assert() to verify that the code gets

** all alignment restrictions correct.

**

** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the

** underlying malloc() implemention might return us 4-byte aligned

** pointers. In that case, only verify 4-byte alignment.

*/

#ifdef SQLITE_4_BYTE_ALIGNED_MALLOC

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

#else

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

#endif

/*

** 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) ((int)(sizeof(X)/sizeof(X[0])))

/*

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

** The sqlite3DbFree() routine requires two parameters instead of the

** one parameter that destructors normally want. So we have to introduce

** this magic value that the code knows to handle differently. Any

** pointer will work here as long as it is distinct from SQLITE_STATIC

** and SQLITE_TRANSIENT.

*/

#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize)

/*

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

/*

** The following macros are used to suppress compiler warnings and to

** make it clear to human readers when a function parameter is deliberately

** left unused within the body of a function. This usually happens when

** a function is called via a function pointer. For example the

** implementation of an SQL aggregate step callback may not use the

** parameter indicating the number of arguments passed to the aggregate,

** if it knows that this is enforced elsewhere.

**

** When a function parameter is not used at all within the body of a function,

** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.

** However, these macros may also be used to suppress warnings related to

** parameters that may or may not be used depending on compilation options.

** For example those parameters only used in assert() statements. In these

** cases the parameters are named as per the usual conventions.

*/

#define UNUSED_PARAMETER(x) (void)(x)

#define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)

/*

** Forward references to structures

*/

typedef struct AggInfo AggInfo;

typedef struct AuthContext AuthContext;

typedef struct AutoincInfo AutoincInfo;

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 ExprSpan ExprSpan;

typedef struct FKey FKey;

typedef struct FuncDestructor FuncDestructor;

typedef struct FuncDef FuncDef;

typedef struct FuncDefHash FuncDefHash;

typedef struct IdList IdList;

typedef struct Index Index;

typedef struct IndexSample IndexSample;

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 RowSet RowSet;

typedef struct Savepoint Savepoint;

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 Trigger Trigger;

typedef struct TriggerPrg TriggerPrg;

typedef struct TriggerStep TriggerStep;

typedef struct UnpackedRecord UnpackedRecord;

typedef struct VTable VTable;

typedef struct VtabCtx VtabCtx;

typedef struct Walker Walker;

typedef struct WherePlan WherePlan;

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 syncing data to disk */

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

};

/*

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

**

** Most Schema objects are associated with a Btree. The exception is

** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.

** In shared cache mode, a single Schema object can be shared by multiple

** Btrees that refer to the same underlying BtShared object.

**

** Schema objects are automatically deallocated when the last Btree that

** references them is destroyed. The TEMP Schema is manually freed by

** sqlite3_close().

*

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

** For a TEMP Schema, only the connection mutex is required.

*/

struct Schema {

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

int iGeneration; /* Generation counter. Incremented with each change */

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

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

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

Hash fkeyHash; /* All foreign keys by referenced table name */

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

};

/*

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

** Db.pSchema->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.pSchema->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_TRIGGER_DEPTH+1)

/*

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

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

**

** Lookaside allocations are only allowed for objects that are associated

** with a particular database connection. Hence, schema information cannot

** be stored in lookaside because in shared cache mode the schema information

** is shared by multiple database connections. Therefore, while parsing

** schema information, the Lookaside.bEnabled flag is cleared so that

** lookaside allocations are not used to construct the schema objects.

*/

struct Lookaside {

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

u8 bEnabled; /* False to disable new lookaside allocations */

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

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

int mxOut; /* Highwater mark for nOut */

int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */

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 connection is an instance of the following structure.

*/

struct sqlite3 {

sqlite3_vfs *pVfs; /* OS Interface */

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

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

sqlite3_mutex *mutex; /* Connection mutex */

Db *aDb; /* All backends */

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

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

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

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

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

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

u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */

u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */

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

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

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

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

int aLimit[SQLITE_N_LIMIT]; /* Limits */

struct sqlite3InitInfo { /* Information used during initialization */

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

u8 iDb; /* Which db file is being initialized */

u8 busy; /* TRUE if currently initializing */

u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */

} init;

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

int writeVdbeCnt; /* Number of active VDBEs that are writing */

int vdbeExecCnt; /* Number of nested calls to VdbeExec() */

int nExtension; /* Number of loaded extensions */

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

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);

#ifndef SQLITE_OMIT_WAL

int (*xWalCallback)(void *, sqlite3 *, const char *, int);

void *pWalArg;

#endif

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

int nVTrans; /* Allocated size of aVTrans */

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

VtabCtx *pVtabCtx; /* Context for active vtab connect/create */

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

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

#endif

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

Hash aCollSeq; /* All collating sequences */

BusyHandler busyHandler; /* Busy callback */

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

Savepoint *pSavepoint; /* List of active savepoints */

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

int nSavepoint; /* Number of non-transaction savepoints */

int nStatement; /* Number of nested statement-transactions */

i64 nDeferredCons; /* Net deferred constraints this transaction. */

int *pnBytesFreed; /* If not NULL, increment this in DbFree() */

#ifdef SQLITE_ENABLE_UNLOCK_NOTIFY

/* The following variables are all protected by the STATIC_MASTER

** mutex, not by sqlite3.mutex. They are used by code in notify.c.

**

** When X.pUnlockConnection==Y, that means that X is waiting for Y to

** unlock so that it can proceed.

**

** When X.pBlockingConnection==Y, that means that something that X tried

** tried to do recently failed with an SQLITE_LOCKED error due to locks

** held by Y.

*/

sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */

sqlite3 *pUnlockConnection; /* Connection to watch for unlock */

void *pUnlockArg; /* Argument to xUnlockNotify */

void (*xUnlockNotify)(void **, int); /* Unlock notify callback */

sqlite3 *pNextBlocked; /* Next in list of all blocked connections */

#endif

};

/*

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

*/

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

/*

** Possible values for the sqlite3.flags.

*/

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

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

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

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

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

/* DELETE, or UPDATE and return */

/* the count using a callback. */

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

/* result set is empty */

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

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

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

/* 0x00020000 Unused */

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

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

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

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

#define SQLITE_CkptFullFSync 0x00400000 /* Use full fsync for checkpoint */

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

#define SQLITE_ReverseOrder 0x01000000 /* Reverse unordered SELECTs */

#define SQLITE_RecTriggers 0x02000000 /* Enable recursive triggers */

#define SQLITE_ForeignKeys 0x04000000 /* Enforce foreign key constraints */

#define SQLITE_AutoIndex 0x08000000 /* Enable automatic indexes */

#define SQLITE_PreferBuiltin 0x10000000 /* Preference to built-in funcs */

#define SQLITE_LoadExtension 0x20000000 /* Enable load_extension */

#define SQLITE_EnableTrigger 0x40000000 /* True to enable triggers */

/*

** Bits of the sqlite3.flags field that are used by the

** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface.

** These must be the low-order bits of the flags field.

*/

#define SQLITE_QueryFlattener 0x01 /* Disable query flattening */

#define SQLITE_ColumnCache 0x02 /* Disable the column cache */

#define SQLITE_IndexSort 0x04 /* Disable indexes for sorting */

#define SQLITE_IndexSearch 0x08 /* Disable indexes for searching */

#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_IdxRealAsInt 0x80 /* Store REAL as INT in indices */

#define SQLITE_DistinctOpt 0x80 /* DISTINCT using indexes */

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

/*

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

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

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

FuncDestructor *pDestructor; /* Reference counted destructor function */

};

/*

** This structure encapsulates a user-function destructor callback (as

** configured using create_function_v2()) and a reference counter. When

** create_function_v2() is called to create a function with a destructor,

** a single object of this type is allocated. FuncDestructor.nRef is set to

** the number of FuncDef objects created (either 1 or 3, depending on whether

** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor

** member of each of the new FuncDef objects is set to point to the allocated

** FuncDestructor.

**