/*

** 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: sqlite.h.in,v 1.436 2009/03/20 13:15:30 drh Exp $

*/

#ifndef _SQLITE3_H_

#define _SQLITE3_H_

#include <stdarg.h>     /* Needed for the definition of va_list */

/*

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

*/

#ifdef __cplusplus

extern "C" {

#endif

/*

** Add the ability to override 'extern'

*/

#ifndef SQLITE_EXTERN

# define SQLITE_EXTERN extern

#endif

/*

** These no-op macros are used in front of interfaces to mark those

** interfaces as either deprecated or experimental.  New applications

** should not use deprecated intrfaces - they are support for backwards

** compatibility only.  Application writers should be aware that

** experimental interfaces are subject to change in point releases.

**

** These macros used to resolve to various kinds of compiler magic that

** would generate warning messages when they were used.  But that

** compiler magic ended up generating such a flurry of bug reports

** that we have taken it all out and gone back to using simple

** noop macros.

*/

#define SQLITE_DEPRECATED

#define SQLITE_EXPERIMENTAL

/*

** Ensure these symbols were 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 {H10010} <S60100>

**

** The SQLITE_VERSION and SQLITE_VERSION_NUMBER #defines in

** the sqlite3.h file specify the version of SQLite with which

** that header file is associated.

**

** The "version" of SQLite is a string of the form "X.Y.Z".

** The phrase "alpha" or "beta" might be appended after the Z.

** The X value is major version number always 3 in SQLite3.

** The X value only changes when backwards compatibility is

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

** The Y value is the minor version number and only changes when

** there are major feature enhancements that are forwards compatible

** but not backwards compatible.

** The Z value is the release number and is incremented with

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

**

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

**

** Requirements: [H10011] [H10014]

*/

#define SQLITE_VERSION         "3.6.12"

#define SQLITE_VERSION_NUMBER  3006012

/*

** CAPI3REF: Run-Time Library Version Numbers {H10020} <S60100>

** KEYWORDS: sqlite3_version

**

** These features provide the same information as the [SQLITE_VERSION]

** and [SQLITE_VERSION_NUMBER] #defines in the header, but are associated

** with the library instead of the header file.  Cautious programmers might

** include a check in their application to verify that

** sqlite3_libversion_number() always returns the value

** [SQLITE_VERSION_NUMBER].

**

** The sqlite3_libversion() function returns the same information as is

** in the sqlite3_version[] string constant.  The function is provided

** for use in DLLs since DLL users usually do not have direct access to string

** constants within the DLL.

**

** Requirements: [H10021] [H10022] [H10023]

*/

SQLITE_EXTERN const char sqlite3_version[];

const char *sqlite3_libversion(void);

int sqlite3_libversion_number(void);

/*

** CAPI3REF: Test To See If The Library Is Threadsafe {H10100} <S60100>

**

** SQLite can be compiled with or without mutexes.  When

** the [SQLITE_THREADSAFE] C preprocessor macro 1 or 2, mutexes

** are enabled and SQLite is threadsafe.  When the

** [SQLITE_THREADSAFE] macro is 0, 

** the mutexes are omitted.  Without the mutexes, it is not safe

** to use SQLite concurrently from more than one thread.

**

** Enabling mutexes incurs a measurable performance penalty.

** So if speed is of utmost importance, it makes sense to disable

** the mutexes.  But for maximum safety, mutexes should be enabled.

** The default behavior is for mutexes to be enabled.

**

** This interface can be used by a program to make sure that the

** version of SQLite that it is linking against was compiled with

** the desired setting of the [SQLITE_THREADSAFE] macro.

**

** This interface only reports on the compile-time mutex setting

** of the [SQLITE_THREADSAFE] flag.  If SQLite is compiled with

** SQLITE_THREADSAFE=1 then mutexes are enabled by default but

** can be fully or partially disabled using a call to [sqlite3_config()]

** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],

** or [SQLITE_CONFIG_MUTEX].  The return value of this function shows

** only the default compile-time setting, not any run-time changes

** to that setting.

**

** See the [threading mode] documentation for additional information.

**

** Requirements: [H10101] [H10102]

*/

int sqlite3_threadsafe(void);

/*

** CAPI3REF: Database Connection Handle {H12000} <S40200>

** KEYWORDS: {database connection} {database connections}

**

** Each open SQLite database is represented by a 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 an

** sqlite3 object.

*/

typedef struct sqlite3 sqlite3;

/*

** CAPI3REF: 64-Bit Integer Types {H10200} <S10110>

** KEYWORDS: sqlite_int64 sqlite_uint64

**

** Because there is no cross-platform way to specify 64-bit integer types

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

**

** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.

** The sqlite_int64 and sqlite_uint64 types are supported for backwards

** compatibility only.

**

** Requirements: [H10201] [H10202]

*/

#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 {H12010} <S30100><S40200>

**

** This routine is the destructor for the [sqlite3] object.

**

** Applications should [sqlite3_finalize | finalize] all [prepared statements]

** and [sqlite3_blob_close | close] all [BLOB handles] associated with

** the [sqlite3] object prior to attempting to close the object.

** The [sqlite3_next_stmt()] interface can be used to locate all

** [prepared statements] associated with a [database connection] if desired.

** Typical code might look like this:

**

** <blockquote><pre>

** sqlite3_stmt *pStmt;

** while( (pStmt = sqlite3_next_stmt(db, 0))!=0 ){

**     sqlite3_finalize(pStmt);

** }

** </pre></blockquote>

**

** If [sqlite3_close()] is invoked while a transaction is open,

** the transaction is automatically rolled back.

**

** The C parameter to [sqlite3_close(C)] must be either a NULL

** pointer or an [sqlite3] object pointer obtained

** from [sqlite3_open()], [sqlite3_open16()], or

** [sqlite3_open_v2()], and not previously closed.

**

** Requirements:

** [H12011] [H12012] [H12013] [H12014] [H12015] [H12019]

*/

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 {H12100} <S10000>

**

** The sqlite3_exec() interface is a convenient way of running one or more

** SQL statements without having to write a lot of C code.  The UTF-8 encoded

** SQL statements are passed in as the second parameter to sqlite3_exec().

** The statements are evaluated one by one until either an error or

** an interrupt is encountered, or until they are all done.  The 3rd parameter

** is an optional callback that is invoked once for each row of any query

** results produced by the SQL statements.  The 5th parameter tells where

** to write any error messages.

**

** The error message passed back through the 5th parameter is held

** in memory obtained from [sqlite3_malloc()].  To avoid a memory leak,

** the calling application should call [sqlite3_free()] on any error

** message returned through the 5th parameter when it has finished using

** the error message.

**

** If the SQL statement in the 2nd parameter is NULL or an empty string

** or a string containing only whitespace and comments, then no SQL

** statements are evaluated and the database is not changed.

**

** The sqlite3_exec() interface is implemented in terms of

** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].

** The sqlite3_exec() routine does nothing to the database that cannot be done

** by [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()].

**

** The first parameter to [sqlite3_exec()] must be an valid and open

** [database connection].

**

** The database connection must not be closed while

** [sqlite3_exec()] is running.

**

** The calling function should use [sqlite3_free()] to free

** the memory that *errmsg is left pointing at once the error

** message is no longer needed.

**

** The SQL statement text in the 2nd parameter to [sqlite3_exec()]

** must remain unchanged while [sqlite3_exec()] is running.

**

** Requirements:

** [H12101] [H12102] [H12104] [H12105] [H12107] [H12110] [H12113] [H12116]

** [H12119] [H12122] [H12125] [H12131] [H12134] [H12137] [H12138]

*/

int sqlite3_exec(

  sqlite3*,                                  /* An open database */

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

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

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

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

);

/*

** CAPI3REF: Result Codes {H10210} <S10700>

** KEYWORDS: SQLITE_OK {error code} {error codes}

** KEYWORDS: {result code} {result codes}

**

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

** here in order to indicates success or failure.

**

** New error codes may be added in future versions of SQLite.

**

** 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 {H10220} <S10700>

** KEYWORDS: {extended error code} {extended error codes}

** KEYWORDS: {extended result code} {extended result codes}

**

** 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 coarse-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. The extended result codes are enabled or disabled

** on a per database connection basis using the

** [sqlite3_extended_result_codes()] API.

**

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

** One may expect the number of extended result codes will be expand

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

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

**

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

#define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))

#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))

#define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))

#define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))

#define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))

#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED | (1<<8) )

/*

** CAPI3REF: Flags For File Open Operations {H10230} <H11120> <H12700>

**

** These bit values are intended for use in the

** 3rd parameter to the [sqlite3_open_v2()] interface and

** in the 4th parameter 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_AUTOPROXY        0x00000020

#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

#define SQLITE_OPEN_NOMUTEX          0x00008000

#define SQLITE_OPEN_FULLMUTEX        0x00010000

/*

** CAPI3REF: Device Characteristics {H10240} <H11120>

**

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

**

** The SQLITE_IOCAP_ATOMIC property means that all writes of

** any size are atomic.  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.  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.  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 {H10250} <H11120> <H11310>

**

** SQLite uses one of these integer values as the second

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

** of an [sqlite3_io_methods] object.

*/

#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 {H10260} <H11120>

**

** When SQLite invokes the xSync() method of an

** [sqlite3_io_methods] object it uses a combination of

** these integer values as the second argument.

**

** 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. The SQLITE_SYNC_NORMAL flag means

** to use normal fsync() semantics. 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 {H11110} <S20110>

**

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

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

};

/*

** CAPI3REF: OS Interface File Virtual Methods Object {H11120} <S20110>

**

** Every file opened by the [sqlite3_vfs] xOpen method populates an

** [sqlite3_file] object (or, more commonly, a subclass of the

** [sqlite3_file] object) with a pointer to an instance of this object.

** This object defines the methods used to perform various operations

** against the open file represented by the [sqlite3_file] object.

**

** 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 a Mac OS X style fullsync.  The [SQLITE_SYNC_DATAONLY]

** 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 checks whether any database connection,

** either in this process or in some other process, is holding a RESERVED,

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

** if such a lock exists and false otherwise.

**

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

** point 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 all opcodes less than 100 for its own use.

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