/*

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

**

** The previous paragraph was written in 2005. (This paragraph is written

** on 2008-11-28.) These days, all Linux kernels support large files, so

** you should probably leave LFS enabled. But some embedded platforms might

** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.

**

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

/*

** For MinGW, check to see if we can include the header file containing its

** version information, among other things. Normally, this internal MinGW

** header file would [only] be included automatically by other MinGW header

** files; however, the contained version information is now required by this

** header file to work around binary compatibility issues (see below) and

** this is the only known way to reliably obtain it. This entire #if block

** would be completely unnecessary if there was any other way of detecting

** MinGW via their preprocessor (e.g. if they customized their GCC to define

** some MinGW-specific macros). When compiling for MinGW, either the

** _HAVE_MINGW_H or _HAVE__MINGW_H (note the extra underscore) macro must be

** defined; otherwise, detection of conditions specific to MinGW will be

** disabled.

*/

#if defined(_HAVE_MINGW_H)

# include "mingw.h"

#elif defined(_HAVE__MINGW_H)

# include "_mingw.h"

#endif

/*

** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T

** define is required to maintain binary compatibility with the MSVC runtime

** library in use (e.g. for Windows XP).

*/

#if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \

defined(_WIN32) && !defined(_WIN64) && \

defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \

defined(__MSVCRT__)

# define _USE_32BIT_TIME_T

#endif

/* The public SQLite interface. The _FILE_OFFSET_BITS macro must appear

** first in QNX. Also, the _USE_32BIT_TIME_T macro must appear first for

** MinGW.

*/

#include "sqlite3.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 /* Suspicious pointer arithmetic */

#endif

/* Needed for various definitions... */

#ifndef _GNU_SOURCE

# define _GNU_SOURCE

#endif

#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)

# define _BSD_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 library 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_ZERO_MALLOC // Use a stub allocator that always fails

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

**

** 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_ZERO_MALLOC) \

+ defined(SQLITE_MEMDEBUG)>1

# error "Two or more of the following compile-time configuration options\

are defined but at most one is allowed:\

SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\

SQLITE_ZERO_MALLOC"

#endif

#if defined(SQLITE_SYSTEM_MALLOC) \

+ defined(SQLITE_WIN32_MALLOC) \

+ defined(SQLITE_ZERO_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 and fchmod() on OpenBSD.

** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit

** it.

*/

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

# define _XOPEN_SOURCE 600

#endif

/*

** NDEBUG and SQLITE_DEBUG are opposites. It should always be true that

** defined(NDEBUG)==!defined(SQLITE_DEBUG). If this is not currently true,

** make it true by defining or undefining NDEBUG.

**

** Setting NDEBUG makes the code smaller and faster by disabling the

** assert() statements in the code. So we want the default action

** to be for NDEBUG to be set and NDEBUG to be undefined only if SQLITE_DEBUG

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

** feature.

*/

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

# define NDEBUG 1

#endif

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

# undef NDEBUG

#endif

/*

** Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.

*/

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

# define SQLITE_ENABLE_EXPLAIN_COMMENTS 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 they 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. These hints could,

** in theory, be used by the compiler to generate better code, but

** currently they are just comments for human readers.

*/

#define likely(X) (X)

#define unlikely(X) (X)

#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

# define SQLITE_TEMP_STORE_xc 1 /* Exclude from ctime.c */

#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

/*

** Macros to compute minimum and maximum of two numbers.

*/

#define MIN(A,B) ((A)<(B)?(A):(B))

#define MAX(A,B) ((A)>(B)?(A):(B))

/*

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

/*

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

** logarithms. For quantity X, the value stored is 10*log2(X). This

** gives a possible range of values of approximately 1.0e986 to 1e-986.

** But the allowed values are "grainy". Not every value is representable.

** For example, quantities 16 and 17 are both represented by a LogEst

** of 40. However, since LogEst quantatites are suppose to be estimates,

** not exact values, this imprecision is not a problem.

**

** "LogEst" is short for "Logarithimic Estimate".

**

** Examples:

** 1 -> 0 20 -> 43 10000 -> 132

** 2 -> 10 25 -> 46 25000 -> 146

** 3 -> 16 100 -> 66 1000000 -> 199

** 4 -> 20 1000 -> 99 1048576 -> 200

** 10 -> 33 1024 -> 100 4294967296 -> 320

**

** The LogEst can be negative to indicate fractional values.

** Examples:

**

** 0.5 -> -10 0.1 -> -33 0.0625 -> -40

*/

typedef INT16_TYPE LogEst;

/*

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

/*

** Disable MMAP on platforms where it is known to not work

*/

#if defined(__OpenBSD__) || defined(__QNXNTO__)

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

#endif

/*

** Default maximum size of memory used by memory-mapped I/O in the VFS

*/

#ifdef __APPLE__

# include <TargetConditionals.h>

# if TARGET_OS_IPHONE

# undef SQLITE_MAX_MMAP_SIZE

# define SQLITE_MAX_MMAP_SIZE 0

# endif

#endif

#ifndef SQLITE_MAX_MMAP_SIZE

# if defined(__linux__) \

|| defined(_WIN32) \

|| (defined(__APPLE__) && defined(__MACH__)) \

|| defined(__sun)

# define SQLITE_MAX_MMAP_SIZE 0x7fff0000 /* 2147418112 */

# else

# define SQLITE_MAX_MMAP_SIZE 0

# endif

# define SQLITE_MAX_MMAP_SIZE_xc 1 /* exclude from ctime.c */

#endif

/*

** The default MMAP_SIZE is zero on all platforms. Or, even if a larger

** default MMAP_SIZE is specified at compile-time, make sure that it does

** not exceed the maximum mmap size.

*/

#ifndef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE 0

# define SQLITE_DEFAULT_MMAP_SIZE_xc 1 /* Exclude from ctime.c */

#endif

#if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE

# undef SQLITE_DEFAULT_MMAP_SIZE

# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE

#endif

/*

** Only one of SQLITE_ENABLE_STAT3 or SQLITE_ENABLE_STAT4 can be defined.

** Priority is given to SQLITE_ENABLE_STAT4. If either are defined, also

** define SQLITE_ENABLE_STAT3_OR_STAT4

*/

#ifdef SQLITE_ENABLE_STAT4

# undef SQLITE_ENABLE_STAT3

# define SQLITE_ENABLE_STAT3_OR_STAT4 1

#elif SQLITE_ENABLE_STAT3

# define SQLITE_ENABLE_STAT3_OR_STAT4 1

#elif SQLITE_ENABLE_STAT3_OR_STAT4

# undef SQLITE_ENABLE_STAT3_OR_STAT4

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

/*

** Determine if the argument is a power of two

*/

#define IsPowerOfTwo(X) (((X)&((X)-1))==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 PrintfArguments PrintfArguments;

typedef struct RowSet RowSet;

typedef struct Savepoint Savepoint;

typedef struct Select Select;

typedef struct SelectDest SelectDest;

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

typedef struct With With;

/*

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

i64 szMmap; /* Default mmap_size setting */

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

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

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

u16 dbOptFlags; /* Flags to enable/disable optimizations */

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 nVdbeActive; /* Number of VDBEs currently running */

int nVdbeRead; /* Number of active VDBEs that read or write */

int nVdbeWrite; /* Number of active VDBEs that read and write */

int nVdbeExec; /* 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 */

union {