/*

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

**

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

** This header file defines the interface that the SQLite library

** presents to client programs.  If a C-function, structure, datatype,

** or constant definition does not appear in this file, then it is

** not a published API of SQLite, is subject to change without

** notice, and should not be referenced by programs that use SQLite.

**

** Some of the definitions that are in this file are marked as

** "experimental".  Experimental interfaces are normally new

** features recently added to SQLite.  We do not anticipate changes 

** to experimental interfaces but reserve to make minor changes if

** experience from use "in the wild" suggest such changes are prudent.

**

** The official C-language API documentation for SQLite is derived

** from comments in this file.  This file is the authoritative source

** on how SQLite interfaces are suppose to operate.

**

** The name of this file under configuration management is "sqlite.h.in".

** The makefile makes some minor changes to this file (such as inserting

** the version number) and changes its name to "sqlite3.h" as

** part of the build process.

**

** @(#) $Id: sqlite3.h 1420 2009-01-13 15:06:30Z teknolog $

*/

#ifndef _SQLITE3_H_

#define _SQLITE3_H_

/*

** Make sure we can call this stuff from C++.

*/

#ifdef __cplusplus

extern "C" {

#endif

//#define EXPORT_C

//#define /*IMPORT_C*/

/*

** Add the ability to override 'extern'

*/

#ifndef SQLITE_EXTERN

# define SQLITE_EXTERN extern

#endif

/*

** Make sure these symbols where not defined by some previous header

** file.

*/

#ifdef SQLITE_VERSION

# undef SQLITE_VERSION

#endif

#ifdef SQLITE_VERSION_NUMBER

# undef SQLITE_VERSION_NUMBER

#endif

/*

** CAPI3REF: Compile-Time Library Version Numbers {F10010}

**

** {F10011} The #define in the sqlite3.h header file named

** SQLITE_VERSION resolves to a string literal that identifies

** the version of the SQLite library in the format "X.Y.Z", where

** X is the major version number, Y is the minor version number and Z

** is the release number.  The X.Y.Z might be followed by "alpha" or "beta".

** {END} For example "3.1.1beta".

**

** The X value is always 3 in SQLite.  The X value only changes when

** backwards compatibility is broken and we intend to never break

** backwards compatibility.  The Y value only changes when

** there are major feature enhancements that are forwards compatible

** but not backwards compatible.  The Z value is incremented with

** each release but resets back to 0 when Y is incremented.

**

** {F10014} The SQLITE_VERSION_NUMBER #define resolves to an integer

** with the value  (X*1000000 + Y*1000 + Z) where X, Y, and Z are as

** with SQLITE_VERSION. {END} For example, for version "3.1.1beta", 

** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using 

** version 3.1.1 or greater at compile time, programs may use the test 

** (SQLITE_VERSION_NUMBER>=3001001).

**

** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()].

*/

#define SQLITE_VERSION         "3.5.4"

#define SQLITE_VERSION_NUMBER 3005004

/*

** CAPI3REF: Run-Time Library Version Numbers {F10020}

**

** {F10021} The sqlite3_libversion_number() interface returns an integer

** equal to [SQLITE_VERSION_NUMBER].  {END} The value returned

** by this routine should only be different from the header values

** if the application is compiled using an sqlite3.h header from a

** different version of SQLite than library.  Cautious programmers might

** include a check in their application to verify that 

** sqlite3_libversion_number() always returns the value 

** [SQLITE_VERSION_NUMBER].

**

** {F10022} The sqlite3_version[] string constant contains the text of the

** [SQLITE_VERSION] string. {F10023} The sqlite3_libversion() function returns

** a pointer to the sqlite3_version[] string constant. {END} The 

** sqlite3_libversion() function

** is provided for DLL users who can only access functions and not

** constants within the DLL.

*/

const char sqlite3_version[] = SQLITE_VERSION;

/*IMPORT_C*/ const char *sqlite3_libversion(void);

/*IMPORT_C*/ int sqlite3_libversion_number(void);

void LogMessage(char *message);

/*

** CAPI3REF: Test To See If The Library Is Threadsafe {F10100}

**

** {F10101} The sqlite3_threadsafe() routine returns nonzero

** if SQLite was compiled with its mutexes enabled or zero if

** SQLite was compiled with mutexes disabled. {END}  If this

** routine returns false, then it is not safe for simultaneously

** running threads to both invoke SQLite interfaces.

**

** Really all this routine does is return true if SQLite was

** compiled with the -DSQLITE_THREADSAFE=1 option and false if

** compiled with -DSQLITE_THREADSAFE=0.  If SQLite uses an

** application-defined mutex subsystem, malloc subsystem, collating

** sequence, VFS, SQL function, progress callback, commit hook,

** extension, or other accessories and these add-ons are not

** threadsafe, then clearly the combination will not be threadsafe

** either.  Hence, this routine never reports that the library

** is guaranteed to be threadsafe, only when it is guaranteed not

** to be.

*/

/*IMPORT_C*/ int sqlite3_threadsafe(void);

/*

** CAPI3REF: Database Connection Handle {F12000}

**

** Each open SQLite database is represented by pointer to an instance of the

** opaque structure named "sqlite3".  It is useful to think of an sqlite3

** pointer as an object.  The [sqlite3_open()], [sqlite3_open16()], and

** [sqlite3_open_v2()] interfaces are its constructors

** and [sqlite3_close()] is its destructor.  There are many other interfaces

** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and

** [sqlite3_busy_timeout()] to name but three) that are methods on this

** object.

*/

typedef struct sqlite3 sqlite3;

/*

** CAPI3REF: 64-Bit Integer Types {F10200}

**

** Because there is no cross-platform way to specify such types

** SQLite includes typedefs for 64-bit signed and unsigned integers.

** {F10201} The sqlite_int64 and sqlite3_int64 types specify a

** 64-bit signed integer. {F10202} The sqlite_uint64 and

** sqlite3_uint64 types specify a 64-bit unsigned integer. {END}

**

** The sqlite3_int64 and sqlite3_uint64 are the preferred type

** definitions.  The sqlite_int64 and sqlite_uint64 types are

** supported for backwards compatibility only.

*/

#ifdef SQLITE_INT64_TYPE

  typedef SQLITE_INT64_TYPE sqlite_int64;

  typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;

#elif defined(_MSC_VER) || defined(__BORLANDC__)

  typedef __int64 sqlite_int64;

  typedef unsigned __int64 sqlite_uint64;

#else

  typedef long long int sqlite_int64;

  typedef unsigned long long int sqlite_uint64;

#endif

typedef sqlite_int64 sqlite3_int64;

typedef sqlite_uint64 sqlite3_uint64;

/*

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

** substitute integer for floating-point

*/

#ifdef SQLITE_OMIT_FLOATING_POINT

# define double sqlite3_int64

#endif

/*

** CAPI3REF: Closing A Database Connection {F12010}

**

** {F12011} The sqlite3_close() interfaces destroys an [sqlite3] object

** allocated by a prior call to [sqlite3_open()], [sqlite3_open16()], or

** [sqlite3_open_v2()]. {F12012} Sqlite3_close() releases all

** memory used by the connection and closes all open files. {END}.

**

** {F12013} If the database connection contains

** [sqlite3_stmt | prepared statements] that have not been finalized

** by [sqlite3_finalize()], then sqlite3_close() returns SQLITE_BUSY

** and leaves the connection open.  {F12014} Giving sqlite3_close()

** a NULL pointer is a harmless no-op. {END}

**

** {U12015} Passing this routine a database connection that has already been

** closed results in undefined behavior. {U12016} If other interfaces that

** reference the same database connection are pending (either in the

** same thread or in different threads) when this routine is called,

** then the behavior is undefined and is almost certainly undesirable.

*/

/*IMPORT_C*/ int sqlite3_close(sqlite3 *);

/*

** The type for a callback function.

** This is legacy and deprecated.  It is included for historical

** compatibility and is not documented.

*/

typedef int (*sqlite3_callback)(void*,int,char**, char**);

/*

** CAPI3REF: One-Step Query Execution Interface {F12100}

**

** {F12101} The sqlite3_exec() interface evaluates zero or more 

** UTF-8 encoded, semicolon-separated SQL statements in the zero-terminated

** string of its second argument.  {F12102} The SQL

** statements are evaluated in the context of the database connection

** specified by in the first argument.

** {F12103} SQL statements are prepared one by one using

** [sqlite3_prepare()] or the equivalent, evaluated

** using one or more calls to [sqlite3_step()], then destroyed

** using [sqlite3_finalize()]. {F12104} The return value of

** sqlite3_exec() is SQLITE_OK if all SQL statement run

** successfully.

**

** {F12105} If one or more of the SQL statements handed to

** sqlite3_exec() are queries, then

** the callback function specified by the 3rd parameter is

** invoked once for each row of the query result. {F12106}

** If the callback returns a non-zero value then the query

** is aborted, all subsequent SQL statements

** are skipped and the sqlite3_exec() function returns the [SQLITE_ABORT].

**

** {F12107} The 4th parameter to sqlite3_exec() is an arbitrary pointer

** that is passed through to the callback function as its first parameter.

**

** {F12108} The 2nd parameter to the callback function is the number of

** columns in the query result.  {F12109} The 3rd parameter to the callback

** is an array of pointers to strings holding the values for each column

** as extracted using [sqlite3_column_text()].  NULL values in the result

** set result in a NULL pointer.  All other value are in their UTF-8

** string representation. {F12117}

** The 4th parameter to the callback is an array of strings

** obtained using [sqlite3_column_name()] and holding

** the names of each column, also in UTF-8.

**

** {F12110} The callback function may be NULL, even for queries.  A NULL

** callback is not an error.  It just means that no callback

** will be invoked. 

**

** {F12112} If an error occurs while parsing or evaluating the SQL

** then an appropriate error message is written into memory obtained

** from [sqlite3_malloc()] and *errmsg is made to point to that message

** assuming errmsg is not NULL.  

** {U12113} The calling function is responsible for freeing the memory

** using [sqlite3_free()].

** {F12116} If [sqlite3_malloc()] fails while attempting to generate

** the error message, *errmsg is set to NULL.

** {F12114} If errmsg is NULL then no attempt is made to generate an

** error message. <todo>Is the return code SQLITE_NOMEM or the original

** error code?</todo> <todo>What happens if there are multiple errors?

** Do we get code for the first error, or is the choice of reported

** error arbitrary?</todo>

**

** {F12115} The return value is is SQLITE_OK if there are no errors and

** some other [SQLITE_OK | return code] if there is an error.  

** The particular return value depends on the type of error.  {END}

*/

/*IMPORT_C*/ int sqlite3_exec(

  sqlite3*,                                  /* An open database */

  const char *sql,                           /* SQL to be evaluted */

  int (*callback)(void*,int,char**,char**),  /* Callback function */

  void *,                                    /* 1st argument to callback */

  char **errmsg                              /* Error msg written here */

);

/*

** CAPI3REF: Result Codes {F10210}

** KEYWORDS: SQLITE_OK

**

** Many SQLite functions return an integer result code from the set shown

** above in order to indicates success or failure.

**

** {F10211} The result codes shown here are the only ones returned 

** by SQLite in its default configuration. {F10212} However, the

** [sqlite3_extended_result_codes()] API can be used to set a database

** connectoin to return more detailed result codes. {END}

**

** See also: [SQLITE_IOERR_READ | extended result codes]

**

*/

#define SQLITE_OK           0   /* Successful result */

/* beginning-of-error-codes */

#define SQLITE_ERROR        1   /* SQL error or missing database */

#define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */

#define SQLITE_PERM         3   /* Access permission denied */

#define SQLITE_ABORT        4   /* Callback routine requested an abort */

#define SQLITE_BUSY         5   /* The database file is locked */

#define SQLITE_LOCKED       6   /* A table in the database is locked */

#define SQLITE_NOMEM        7   /* A malloc() failed */

#define SQLITE_READONLY     8   /* Attempt to write a readonly database */

#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/

#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */

#define SQLITE_CORRUPT     11   /* The database disk image is malformed */

#define SQLITE_NOTFOUND    12   /* NOT USED. Table or record not found */

#define SQLITE_FULL        13   /* Insertion failed because database is full */

#define SQLITE_CANTOPEN    14   /* Unable to open the database file */

#define SQLITE_PROTOCOL    15   /* NOT USED. Database lock protocol error */

#define SQLITE_EMPTY       16   /* Database is empty */

#define SQLITE_SCHEMA      17   /* The database schema changed */

#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */

#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */

#define SQLITE_MISMATCH    20   /* Data type mismatch */

#define SQLITE_MISUSE      21   /* Library used incorrectly */

#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */

#define SQLITE_AUTH        23   /* Authorization denied */

#define SQLITE_FORMAT      24   /* Auxiliary database format error */

#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */

#define SQLITE_NOTADB      26   /* File opened that is not a database file */

#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */

#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */

/* end-of-error-codes */

/*

** CAPI3REF: Extended Result Codes {F10220}

**

** In its default configuration, SQLite API routines return one of 26 integer

** [SQLITE_OK | result codes].  However, experience has shown that

** many of these result codes are too course-grained.  They do not provide as

** much information about problems as programmers might like.  In an effort to

** address this, newer versions of SQLite (version 3.3.8 and later) include

** support for additional result codes that provide more detailed information

** about errors. {F10221} The extended result codes are enabled or disabled

** for each database connection using the [sqlite3_extended_result_codes()]

** API. {END}

** 

** Some of the available extended result codes are listed above.

** We expect the number of extended result codes will be expand

** over time.  {U10422} Software that uses extended result codes should expect

** to see new result codes in future releases of SQLite. {END}

** 

** {F10223} The symbolic name for an extended result code always contains

** a related primary result code as a prefix. {F10224} Primary result

** codes contain a single "_" character.  {F10225} Extended result codes

** contain two or more "_" characters. {F10226} The numeric value of an

** extended result code can be converted to its

** corresponding primary result code by masking off the lower 8 bytes. {END}

**

** The SQLITE_OK result code will never be extended.  It will always

** be exactly zero.

*/

#define SQLITE_IOERR_READ          (SQLITE_IOERR | (1<<8))

#define SQLITE_IOERR_SHORT_READ    (SQLITE_IOERR | (2<<8))

#define SQLITE_IOERR_WRITE         (SQLITE_IOERR | (3<<8))

#define SQLITE_IOERR_FSYNC         (SQLITE_IOERR | (4<<8))

#define SQLITE_IOERR_DIR_FSYNC     (SQLITE_IOERR | (5<<8))

#define SQLITE_IOERR_TRUNCATE      (SQLITE_IOERR | (6<<8))

#define SQLITE_IOERR_FSTAT         (SQLITE_IOERR | (7<<8))

#define SQLITE_IOERR_UNLOCK        (SQLITE_IOERR | (8<<8))

#define SQLITE_IOERR_RDLOCK        (SQLITE_IOERR | (9<<8))

#define SQLITE_IOERR_DELETE        (SQLITE_IOERR | (10<<8))

#define SQLITE_IOERR_BLOCKED       (SQLITE_IOERR | (11<<8))

#define SQLITE_IOERR_NOMEM         (SQLITE_IOERR | (12<<8))

/*

** CAPI3REF: Flags For File Open Operations {F10230}

**

** {F10231} Some combination of the these bit values are used as the

** third argument to the [sqlite3_open_v2()] interface and

** as fourth argument to the xOpen method of the

** [sqlite3_vfs] object.

*/

#define SQLITE_OPEN_READONLY         0x00000001

#define SQLITE_OPEN_READWRITE        0x00000002

#define SQLITE_OPEN_CREATE           0x00000004

#define SQLITE_OPEN_DELETEONCLOSE    0x00000008

#define SQLITE_OPEN_EXCLUSIVE        0x00000010

#define SQLITE_OPEN_MAIN_DB          0x00000100

#define SQLITE_OPEN_TEMP_DB          0x00000200

#define SQLITE_OPEN_TRANSIENT_DB     0x00000400

#define SQLITE_OPEN_MAIN_JOURNAL     0x00000800

#define SQLITE_OPEN_TEMP_JOURNAL     0x00001000

#define SQLITE_OPEN_SUBJOURNAL       0x00002000

#define SQLITE_OPEN_MASTER_JOURNAL   0x00004000

/*

** CAPI3REF: Device Characteristics {F10240}

**

** {F10241} The xDeviceCapabilities method of the [sqlite3_io_methods]

** object returns an integer which is a vector of the these

** bit values expressing I/O characteristics of the mass storage

** device that holds the file that the [sqlite3_io_methods]

** refers to. {END}

**

** {F10242} The SQLITE_IOCAP_ATOMIC property means that all writes of

** any size are atomic.  {F10243} The SQLITE_IOCAP_ATOMICnnn values

** mean that writes of blocks that are nnn bytes in size and

** are aligned to an address which is an integer multiple of

** nnn are atomic.  {F10244} The SQLITE_IOCAP_SAFE_APPEND value means

** that when data is appended to a file, the data is appended

** first then the size of the file is extended, never the other

** way around.  {F10245} The SQLITE_IOCAP_SEQUENTIAL property means that

** information is written to disk in the same order as calls

** to xWrite().

*/

#define SQLITE_IOCAP_ATOMIC          0x00000001

#define SQLITE_IOCAP_ATOMIC512       0x00000002

#define SQLITE_IOCAP_ATOMIC1K        0x00000004

#define SQLITE_IOCAP_ATOMIC2K        0x00000008

#define SQLITE_IOCAP_ATOMIC4K        0x00000010

#define SQLITE_IOCAP_ATOMIC8K        0x00000020

#define SQLITE_IOCAP_ATOMIC16K       0x00000040

#define SQLITE_IOCAP_ATOMIC32K       0x00000080

#define SQLITE_IOCAP_ATOMIC64K       0x00000100

#define SQLITE_IOCAP_SAFE_APPEND     0x00000200

#define SQLITE_IOCAP_SEQUENTIAL      0x00000400

/*

** CAPI3REF: File Locking Levels {F10250}

**

** {F10251} SQLite uses one of the following integer values as the second

** argument to calls it makes to the xLock() and xUnlock() methods

** of an [sqlite3_io_methods] object. {END}

*/

#define SQLITE_LOCK_NONE          0

#define SQLITE_LOCK_SHARED        1

#define SQLITE_LOCK_RESERVED      2

#define SQLITE_LOCK_PENDING       3

#define SQLITE_LOCK_EXCLUSIVE     4

/*

** CAPI3REF: Synchronization Type Flags {F10260}

**

** {F10261} When SQLite invokes the xSync() method of an

** [sqlite3_io_methods] object it uses a combination of the

** these integer values as the second argument.

**

** {F10262} When the SQLITE_SYNC_DATAONLY flag is used, it means that the

** sync operation only needs to flush data to mass storage.  Inode

** information need not be flushed. {F10263} The SQLITE_SYNC_NORMAL means 

** to use normal fsync() semantics. {F10264} The SQLITE_SYNC_FULL flag means 

** to use Mac OS-X style fullsync instead of fsync().

*/

#define SQLITE_SYNC_NORMAL        0x00002

#define SQLITE_SYNC_FULL          0x00003

#define SQLITE_SYNC_DATAONLY      0x00010

/*

** CAPI3REF: OS Interface Open File Handle {F11110}

**

** An [sqlite3_file] object represents an open file in the OS

** interface layer.  Individual OS interface implementations will

** want to subclass this object by appending additional fields

** for their own use.  The pMethods entry is a pointer to an

** [sqlite3_io_methods] object that defines methods for performing

** I/O operations on the open file.

*/

typedef struct sqlite3_file sqlite3_file;

struct sqlite3_file {

	int isOpen;

  //const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */

};

/*

** CAPI3REF: OS Interface File Virtual Methods Object {F11120}

**

** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to

** an instance of the this object.  This object defines the

** methods used to perform various operations against the open file.

**

** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or

** [SQLITE_SYNC_FULL].  The first choice is the normal fsync().

*  The second choice is an

** OS-X style fullsync.  The SQLITE_SYNC_DATA flag may be ORed in to

** indicate that only the data of the file and not its inode needs to be

** synced.

** 

** The integer values to xLock() and xUnlock() are one of

** <ul>

** <li> [SQLITE_LOCK_NONE],

** <li> [SQLITE_LOCK_SHARED],

** <li> [SQLITE_LOCK_RESERVED],

** <li> [SQLITE_LOCK_PENDING], or

** <li> [SQLITE_LOCK_EXCLUSIVE].

** </ul>

** xLock() increases the lock. xUnlock() decreases the lock.  

** The xCheckReservedLock() method looks

** to see if any database connection, either in this

** process or in some other process, is holding an RESERVED,

** PENDING, or EXCLUSIVE lock on the file.  It returns true

** if such a lock exists and false if not.

** 

** The xFileControl() method is a generic interface that allows custom

** VFS implementations to directly control an open file using the

** [sqlite3_file_control()] interface.  The second "op" argument

** is an integer opcode.   The third

** argument is a generic pointer which is intended to be a pointer

** to a structure that may contain arguments or space in which to

** write return values.  Potential uses for xFileControl() might be

** functions to enable blocking locks with timeouts, to change the

** locking strategy (for example to use dot-file locks), to inquire

** about the status of a lock, or to break stale locks.  The SQLite

** core reserves opcodes less than 100 for its own use. 

** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.

** Applications that define a custom xFileControl method should use opcodes 

** greater than 100 to avoid conflicts.

**

** The xSectorSize() method returns the sector size of the

** device that underlies the file.  The sector size is the

** minimum write that can be performed without disturbing

** other bytes in the file.  The xDeviceCharacteristics()

** method returns a bit vector describing behaviors of the

** underlying device:

**

** <ul>

** <li> [SQLITE_IOCAP_ATOMIC]