#define SQLITE_MAX_EXPR_DEPTH

using System;

using System.Diagnostics;

using System.Runtime.InteropServices;

using System.Text;

using Bitmask = System.UInt64;

using i16 = System.Int16;

using i64 = System.Int64;

using sqlite3_int64 = System.Int64;

using u8 = System.Byte;

using u16 = System.UInt16;

using u32 = System.UInt32;

using u64 = System.UInt64;

using unsigned = System.UInt64;

using Pgno = System.UInt32;

#if !SQLITE_MAX_VARIABLE_NUMBER

using ynVar = System.Int16;

#else

using ynVar = System.Int32;

#endif

/*

** The yDbMask datatype for the bitmask of all attached databases.

*/

#if SQLITE_MAX_ATTACHED//>30

// typedef sqlite3_uint64 yDbMask;

using yDbMask = System.Int64;

#else

// typedef unsigned int yDbMask;

using yDbMask = System.Int32;

#endif

namespace Community.CsharpSqlite

{

using sqlite3_value = Sqlite3.Mem;

public partial class Sqlite3

{

/*

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

**

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

** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart

** C#-SQLite is an independent reimplementation of the SQLite software library

**

** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2

**

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

*/

//#if !_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.

*/

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

*/

#if _HAVE_SQLITE_CONFIG_H

//#include "config.h"

#endif

//#include "sqliteLimit.h"

/* Disable nuisance warnings on Borland compilers */

//#if (__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... */

//#if !_GNU_SOURCE

//#define _GNU_SOURCE

//#endif

/*

** Include standard header files as necessary

*/

#if HAVE_STDINT_H

//#include <stdint.h>

#endif

#if HAVE_INTTYPES_H

//#include <inttypes.h>

#endif

/*

** The number of samples of an index that SQLite takes in order to

** construct a histogram of the table content when running ANALYZE

** and with SQLITE_ENABLE_STAT2

*/

//#define SQLITE_INDEX_SAMPLES 10

public const int SQLITE_INDEX_SAMPLES = 10;

/*

** 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 (__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 !SQLITE_THREADSAFE

//# define SQLITE_THREADSAFE 2

const int SQLITE_THREADSAFE = 2;

#else

const int SQLITE_THREADSAFE = 2; /* IMP: R-07272-22309 */

#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 !(SQLITE_DEFAULT_MEMSTATUS)

//# define SQLITE_DEFAULT_MEMSTATUS 1

const int SQLITE_DEFAULT_MEMSTATUS = 0;

#else

const int SQLITE_DEFAULT_MEMSTATUS = 1;

#endif

/*

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

** specify which memory allocation subsystem to use.

**

** SQLITE_SYSTEM_MALLOC // Use normal system malloc()

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

**

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

** pared it down to just these two.)

**

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

** the default.

*/

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

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

// is allows: SQLITE_SYSTEM_MALLOC, SQLITE_MEMDEBUG"

//#endif

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

//# 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 !(SQLITE_MALLOC_SOFT_LIMIT)

const int 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 !_XOPEN_SOURCE && !__DARWIN__ && !__APPLE__ && SQLITE_THREADSAFE

const int _XOPEN_SOURCE = 500;//#define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */

#endif

/*

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

*/

#if SQLITE_TCL || 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 !NDEBUG && !SQLITE_DEBUG

const int NDEBUG = 1;//# 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.

**

*/

#if SQLITE_COVERAGE_TEST

void sqlite3Coverage(int);

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

#else

//# define testcase(X)

static void testcase<T>( T 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 Debug.Assert() macros.

*/

#if !NDEBUG || SQLITE_COVERAGE_TEST

//# define TESTONLY(X) X

// -- Need workaround for C#, since inline macros don't exist

#else

//# define TESTONLY(X)

#endif

/*

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

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

** appear when Debug.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.

*/

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

//# define ALWAYS(X) (1)

//# define NEVER(X) (0)

#elif !NDEBUG

//# define ALWAYS(X) ((X)?1:(Debug.Assert(0),0))

static bool ALWAYS( bool X )

{

if ( X != true )

Debug.Assert( false );

return true;

}

static int ALWAYS( int X )

{

if ( X == 0 )

Debug.Assert( false );

return 1;

}

static bool ALWAYS<T>( T X )

{

if ( X == null )

Debug.Assert( false );

return true;

}

//# define NEVER(X) ((X)?(Debug.Assert(0),1):0)

static bool NEVER( bool X )

{

if ( X == true )

Debug.Assert( false );

return false;

}

static byte NEVER( byte X )

{

if ( X != 0 )

Debug.Assert( false );

return 0;

}

static int NEVER( int X )

{

if ( X != 0 )

Debug.Assert( false );

return 0;

}

static bool NEVER<T>( T X )

{

if ( X != null )

Debug.Assert( false );

return false;

}

#else

//# define ALWAYS(X) (X)

static bool ALWAYS(bool X) { return X; }

static byte ALWAYS(byte X) { return X; }

static int ALWAYS(int X) { return X; }

static bool ALWAYS<T>( T X ) { return true; }

//# define NEVER(X) (X)

static bool NEVER(bool X) { return X; }

static byte NEVER(byte X) { return X; }

static int NEVER(int X) { return X; }

static bool NEVER<T>(T X) { return false; }

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

*/

static bool IS_BIG_INT( i64 X )

{

return ( ( ( X ) & ~(i64)0xffffffff ) != 0 );

}//#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 (__GNUC__) && FALSE

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

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

#else

//# define likely(X) !!(X)

static bool likely( bool X )

{

return !!X;

}

//# define unlikely(X) !!(X)

static bool unlikely( bool X )

{

return !!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

*/

#if SQLITE_OMIT_FLOATING_POINT

//# define double sqlite_int64

//# define float sqlite_int64

//# define LONGDOUBLE_TYPE sqlite_int64

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

#if !SQLITE_BIG_DBL

const double SQLITE_BIG_DBL = ( ( (sqlite3_int64)1 ) << 60 );//# 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 #if !statements.

*/

#if SQLITE_OMIT_TEMPDB

//#define OMIT_TEMPDB 1

#else

static int 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.

*/

static public int SQLITE_MAX_FILE_FORMAT = 4;//#define SQLITE_MAX_FILE_FORMAT 4

//#if !SQLITE_DEFAULT_FILE_FORMAT

static int SQLITE_DEFAULT_FILE_FORMAT = 1;//# define SQLITE_DEFAULT_FILE_FORMAT 1

//#endif

/*

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

** changed at run-time using a pragma.

*/

#if !SQLITE_DEFAULT_RECURSIVE_TRIGGERS

//# define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0

static public bool SQLITE_DEFAULT_RECURSIVE_TRIGGERS = false;

#else

static public bool SQLITE_DEFAULT_RECURSIVE_TRIGGERS = true;

#endif

/*

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

** on the command-line

*/

//#if !SQLITE_TEMP_STORE

static int SQLITE_TEMP_STORE = 1;//#define SQLITE_TEMP_STORE 1

//#endif

/*

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

** ourselves.

*/

#if !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 FALSE //'A' == '\301'

//# define SQLITE_EBCDIC 1

#else

const int SQLITE_ASCII = 1;//#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 '-Du32PTR_TYPE=long long int' ...

*/

//#if !u32_TYPE

//# ifdef HAVE_u32_T

//# define u32_TYPE u32_t

//# else

//# define u32_TYPE unsigned int

//# endif

//#endif

//#if !u3216_TYPE

//# ifdef HAVE_u3216_T

//# define u3216_TYPE u3216_t

//# else

//# define u3216_TYPE unsigned short int

//# endif

//#endif

//#if !INT16_TYPE

//# ifdef HAVE_INT16_T

//# define INT16_TYPE int16_t

//# else

//# define INT16_TYPE short int

//# endif

//#endif

//#if !u328_TYPE

//# ifdef HAVE_u328_T

//# define u328_TYPE u328_t

//# else

//# define u328_TYPE unsigned char

//# endif

//#endif

//#if !INT8_TYPE

//# ifdef HAVE_INT8_T

//# define INT8_TYPE int8_t

//# else

//# define INT8_TYPE signed char

//# endif

//#endif

//#if !LONGDOUBLE_TYPE

//# define LONGDOUBLE_TYPE long double

//#endif

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

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

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

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

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

//typedef u328_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)

const u32 SQLITE_MAX_U32 = (u32)( ( ( (u64)1 ) << 32 ) - 1 );

/*

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

** evaluated at runtime.

*/

#if SQLITE_AMALGAMATION

//const int sqlite3one = 1;

#else

const bool sqlite3one = true;

#endif

#if i386 || __i386__ || _M_IX86

const int ;//#define SQLITE_BIGENDIAN 0

const int ;//#define SQLITE_LITTLEENDIAN 1

const int ;//#define SQLITE_UTF16NATIVE SQLITE_UTF16LE

#else

static u8 SQLITE_BIGENDIAN = 0;//#define SQLITE_BIGENDIAN (*(char )(&sqlite3one)==0)

static u8 SQLITE_LITTLEENDIAN = 1;//#define SQLITE_LITTLEENDIAN (*(char )(&sqlite3one)==1)

static u8 SQLITE_UTF16NATIVE = ( SQLITE_BIGENDIAN != 0 ? SQLITE_UTF16BE : SQLITE_UTF16LE );//#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)

const i64 LARGEST_INT64 = i64.MaxValue;//( 0xffffffff | ( ( (i64)0x7fffffff ) << 32 ) );

const i64 SMALLEST_INT64 = i64.MinValue;//( ( ( 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)

static int ROUND8( int x )

{

return ( x + 7 ) & ~7;

}

/*

** Round down to the nearest multiple of 8

*/

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

static int ROUNDDOWN8( int x )

{

return x & ~7;

}

/*

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

** macro is used only within Debug.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.

*/

//#if 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;

public class BusyHandler

{

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

public object pArg; /* First arg to busy callback */

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

*/

const string MASTER_NAME = "sqlite_master";//#define MASTER_NAME "sqlite_master"

const string TEMP_MASTER_NAME = "sqlite_temp_master";//#define TEMP_MASTER_NAME "sqlite_temp_master"

/*

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

*/

const int MASTER_ROOT = 1;//#define MASTER_ROOT 1

/*

** The name of the schema table.

*/

static string SCHEMA_TABLE( int x ) //#define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)

{

return ( ( OMIT_TEMPDB == 0 ) && ( 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])))

static int ArraySize<T>( T[] x )

{

return x.Length;

}

/*

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

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

*/

//#define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3DbFree)

static dxDel SQLITE_DYNAMIC;

/*

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

*/

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

static Sqlite3Config sqlite3GlobalConfig;

#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 Debug.Assert() statements. In these

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

*/

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

static void UNUSED_PARAMETER<T>( T x )

{

}

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

static void UNUSED_PARAMETER2<T1, T2>( T1 x, T2 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 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_g.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.

*/

public class Db

{

public string zName; /* Name of this database */

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

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

public u8 safety_level; /* How aggressive at syncing data to disk */

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

*/

public class Schema

{

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

public u32 iGeneration; /* Generation counter. Incremented with each change */

public Hash tblHash = new Hash(); /* All tables indexed by name */

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

public Hash trigHash = new Hash();/* All triggers indexed by name */

public Hash fkeyHash = new Hash();/* All foreign keys by referenced table name */

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

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

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

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

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

public Schema Copy()

{

if ( this == null )

return null;

else

{

Schema cp = (Schema)MemberwiseClone();

return cp;

}

}

public void Clear()

{

if ( this != null )

{

schema_cookie = 0;

tblHash = new Hash();

idxHash = new Hash();

trigHash = new Hash();

fkeyHash = new Hash();

pSeqTab = null;

}

}

};

/*

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

static bool DbHasProperty( sqlite3 D, int I, ushort P )

{

return ( 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)

static void DbSetProperty( sqlite3 D, int I, ushort P )

{

D.aDb[I].pSchema.flags = (u16)( D.aDb[I].pSchema.flags | P );

}

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

static void DbClearProperty( sqlite3 D, int I, ushort P )

{

D.aDb[I].pSchema.flags = (u16)( 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) */

const u16 DB_SchemaLoaded = 0x0001;

const u16 DB_UnresetViews = 0x0002;

const u16 DB_Empty = 0x0004;

/*

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

const int 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.

*/

public class Lookaside

{

public int sz; /* Size of each buffer in bytes */

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

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

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

public int mxOut; /* Highwater mark for nOut */

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

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

public int pStart; /* First byte of available memory space */

public int pEnd; /* First byte past end of available space */

};

public class LookasideSlot

{

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

*/

public class FuncDefHash

{

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

};

/*

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

**

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

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

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

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

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

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

**

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

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

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

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

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

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

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

** affect the value of lsChange.

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

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

**

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

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

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

** consistently.

*/

public class sqlite3

{

public sqlite3_vfs pVfs; /* OS Interface */

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

public Db[] aDb = new Db[SQLITE_MAX_ATTACHED]; /* All backends */

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