/*

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

/*

** Include the header file used to customize the compiler options for MSVC.

** This should be done first so that it can successfully prevent spurious

** compiler warnings due to subsequent content in this file and other files

** that are included by this file.

*/

#include "msvc.h"

/*

** Special setup for VxWorks

*/

#include "vxworks.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

/* What version of GCC is being used. 0 means GCC is not being used */

#ifdef __GNUC__

# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)

#else

# define GCC_VERSION 0

#endif

/* Needed for various definitions... */

#if defined(__GNUC__) && !defined(_GNU_SOURCE)

# define _GNU_SOURCE

#endif

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

# define _BSD_SOURCE

#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

/*

** 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_WITHIN(P,S,E) macro checks to see if pointer P points to

** something between S (inclusive) and E (exclusive).

**

** In other words, S is a buffer and E is a pointer to the first byte after

** the end of buffer S. This macro returns true if P points to something

** contained within the buffer S.

*/

#if defined(HAVE_STDINT_H)

# define SQLITE_WITHIN(P,S,E) \

((uintptr_t)(P)>=(uintptr_t)(S) && (uintptr_t)(P)<(uintptr_t)(E))

#else

# define SQLITE_WITHIN(P,S,E) ((P)>=(S) && (P)<(E))

#endif

/*

** A macro to hint to the compiler that a function should not be

** inlined.

*/

#if defined(__GNUC__)

# define SQLITE_NOINLINE __attribute__((noinline))

#elif defined(_MSC_VER) && _MSC_VER>=1310

# define SQLITE_NOINLINE __declspec(noinline)

#else

# define SQLITE_NOINLINE

#endif

/*

** Make sure that the compiler intrinsics we desire are enabled when

** compiling with an appropriate version of MSVC unless prevented by

** the SQLITE_DISABLE_INTRINSIC define.

*/

#if !defined(SQLITE_DISABLE_INTRINSIC)

# if defined(_MSC_VER) && _MSC_VER>=1300

# if !defined(_WIN32_WCE)

# include <intrin.h>

# pragma intrinsic(_byteswap_ushort)

# pragma intrinsic(_byteswap_ulong)

# pragma intrinsic(_ReadWriteBarrier)

# else

# include <cmnintrin.h>

# endif

# endif

#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

/*

** EVIDENCE-OF: R-25715-37072 Memory allocation statistics are enabled by

** default unless SQLite is compiled with SQLITE_DEFAULT_MEMSTATUS=0 in

** which case memory allocation statistics are disabled by default.

*/

#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

/*

** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is

** defined. We need to defend against those failures when testing with

** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches

** during a normal build. The following macro can be used to disable tests

** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.

*/

#if defined(SQLITE_TEST_REALLOC_STRESS)

# define ONLY_IF_REALLOC_STRESS(X) (X)

#elif !defined(NDEBUG)

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

#else

# define ONLY_IF_REALLOC_STRESS(X) (0)

#endif

/*

** Declarations used for tracing the operating system interfaces.

*/

#if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \

(defined(SQLITE_DEBUG) && SQLITE_OS_WIN)

extern int sqlite3OSTrace;

# define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X

# define SQLITE_HAVE_OS_TRACE

#else

# define OSTRACE(X)

# undef SQLITE_HAVE_OS_TRACE

#endif

/*

** Is the sqlite3ErrName() function needed in the build? Currently,

** it is needed by "mutex_w32.c" (when debugging), "os_win.c" (when

** OSTRACE is enabled), and by several "test*.c" files (which are

** compiled using SQLITE_TEST).

*/

#if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \

(defined(SQLITE_DEBUG) && SQLITE_OS_WIN)

# define SQLITE_NEED_ERR_NAME

#else

# undef SQLITE_NEED_ERR_NAME

#endif

/*

** Return true (non-zero) if the input is an 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

/*

** If no value has been provided for SQLITE_MAX_WORKER_THREADS, or if

** SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it

** to zero.

*/

#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0

# undef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS 0

#endif

#ifndef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS 8

#endif

#ifndef SQLITE_DEFAULT_WORKER_THREADS

# define SQLITE_DEFAULT_WORKER_THREADS 0

#endif

#if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS

# undef SQLITE_MAX_WORKER_THREADS

# define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS

#endif

/*

** The default initial allocation for the pagecache when using separate

** pagecaches for each database connection. A positive number is the

** number of pages. A negative number N translations means that a buffer

** of -1024*N bytes is allocated and used for as many pages as it will hold.

*/

#ifndef SQLITE_DEFAULT_PCACHE_INITSZ

# define SQLITE_DEFAULT_PCACHE_INITSZ 100

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

/*

** Swap two objects of type TYPE.

*/

#define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}

/*

** 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 quantities are suppose to be estimates,

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

**

** "LogEst" is short for "Logarithmic 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;

/*

** Set the SQLITE_PTRSIZE macro to the number of bytes in a pointer

*/

#ifndef SQLITE_PTRSIZE

# if defined(__SIZEOF_POINTER__)

# define SQLITE_PTRSIZE __SIZEOF_POINTER__

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

defined(_M_ARM) || defined(__arm__) || defined(__x86)

# define SQLITE_PTRSIZE 4

# else

# define SQLITE_PTRSIZE 8

# endif

#endif

/*

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

** and whether or not that determination is run-time or compile-time.

**

** For best performance, an attempt is made to guess at the byte-order

** using C-preprocessor macros. If that is unsuccessful, or if

** -DSQLITE_RUNTIME_BYTEORDER=1 is set, then byte-order is determined

** at run-time.

*/

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

defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \

defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \

defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER)

# define SQLITE_BYTEORDER 1234

# define SQLITE_BIGENDIAN 0

# define SQLITE_LITTLEENDIAN 1

# define SQLITE_UTF16NATIVE SQLITE_UTF16LE

#endif

#if (defined(sparc) || defined(__ppc__)) \

&& !defined(SQLITE_RUNTIME_BYTEORDER)

# define SQLITE_BYTEORDER 4321

# define SQLITE_BIGENDIAN 1

# define SQLITE_LITTLEENDIAN 0

# define SQLITE_UTF16NATIVE SQLITE_UTF16BE

#endif

#if !defined(SQLITE_BYTEORDER)

# ifdef SQLITE_AMALGAMATION

const int sqlite3one = 1;

# else

extern const int sqlite3one;

# endif

# define SQLITE_BYTEORDER 0 /* 0 means "unknown at compile-time" */

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

#endif

#ifndef SQLITE_MAX_MMAP_SIZE

# if defined(__linux__) \

|| defined(_WIN32) \

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

|| defined(__sun) \

|| defined(__FreeBSD__) \

|| defined(__DragonFly__)

# 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

/*

** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not

** the Select query generator tracing logic is turned on.

*/

#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_SELECTTRACE)

# define SELECTTRACE_ENABLED 1

#else

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

/*

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

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

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"