/*

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

*/

#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 interfaces - 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 "W.X.Y" or "W.X.Y.Z".

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

** The W value only changes when backwards compatibility is

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

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

** there are major feature enhancements that are forwards compatible

** but not backwards compatible.

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

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

** The Z value only appears on branch releases.

**

** The SQLITE_VERSION_NUMBER is an integer that is computed as

** follows:

**

** <blockquote><pre>

** SQLITE_VERSION_NUMBER = W*1000000 + X*1000 + Y

** </pre></blockquote>

**

** Since version 3.6.18, SQLite source code has been stored in the

** <a href="http://www.fossil-scm.org/">fossil configuration management

** system</a>. The SQLITE_SOURCE_ID

** macro is a string which identifies a particular check-in of SQLite

** within its configuration management system. The string contains the

** date and time of the check-in (UTC) and an SHA1 hash of the entire

** source tree.

**

** See also: [sqlite3_libversion()],

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

** [sqlite_version()] and [sqlite_source_id()].

**

** Requirements: [H10011] [H10014]

*/

#define SQLITE_VERSION "--VERS--"

#define SQLITE_VERSION_NUMBER --VERSION-NUMBER--

#define SQLITE_SOURCE_ID "--SOURCE-ID--"

/*

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

** KEYWORDS: sqlite3_version

**

** These interfaces provide the same information as the [SQLITE_VERSION],

** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] #defines in the header,

** but are associated with the library instead of the header file. Cautious

** programmers might include assert() statements in their application to

** verify that values returned by these interfaces match the macros in

** the header, and thus insure that the application is

** compiled with matching library and header files.

**

** <blockquote><pre>

** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );

** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );

** assert( strcmp(sqlite3_libversion,SQLITE_VERSION)==0 );

** </pre></blockquote>

**

** 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. Similarly, the sqlite3_sourceid() function

** returns the same information as is in the [SQLITE_SOURCE_ID] #define of

** the header file.

**

** See also: [sqlite_version()] and [sqlite_source_id()].

**

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

*/

SQLITE_EXTERN const char sqlite3_version[];

const char *sqlite3_libversion(void);

const char *sqlite3_sourceid(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 is 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 an application 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 must [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.

**

** 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 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */

#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */

#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */

#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */

#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */

#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */

#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */

#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */

#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */

#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */

#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */

/*

** 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. If the lower four bits of the flag

** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.

** If the lower four bits equal SQLITE_SYNC_FULL, that 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

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

**

** If the xOpen method sets the sqlite3_file.pMethods element

** to a non-NULL pointer, then the sqlite3_io_methods.xClose method

** may be invoked even if the xOpen reported that it failed. The

** only way to prevent a call to xClose following a failed xOpen

** is for the xOpen to set the sqlite3_file.pMethods element to NULL.

**

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

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

** <li> [SQLITE_IOCAP_ATOMIC512]

** <li> [SQLITE_IOCAP_ATOMIC1K]

** <li> [SQLITE_IOCAP_ATOMIC2K]

** <li> [SQLITE_IOCAP_ATOMIC4K]

** <li> [SQLITE_IOCAP_ATOMIC8K]

** <li> [SQLITE_IOCAP_ATOMIC16K]

** <li> [SQLITE_IOCAP_ATOMIC32K]

** <li> [SQLITE_IOCAP_ATOMIC64K]

** <li> [SQLITE_IOCAP_SAFE_APPEND]

** <li> [SQLITE_IOCAP_SEQUENTIAL]

** </ul>

**

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

**

** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill

** in the unread portions of the buffer with zeros. A VFS that

** fails to zero-fill short reads might seem to work. However,

** failure to zero-fill short reads will eventually lead to

** database corruption.

*/

typedef struct sqlite3_io_methods sqlite3_io_methods;

struct sqlite3_io_methods {

int iVersion;

int (*xClose)(sqlite3_file*);

int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);

int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);

int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);

int (*xSync)(sqlite3_file*, int flags);

int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);

int (*xLock)(sqlite3_file*, int);

int (*xUnlock)(sqlite3_file*, int);

int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);

int (*xFileControl)(sqlite3_file*, int op, void *pArg);

int (*xSectorSize)(sqlite3_file*);

int (*xDeviceCharacteristics)(sqlite3_file*);

/* Additional methods may be added in future releases */

};

/*

** CAPI3REF: Standard File Control Opcodes {H11310} <S30800>

**

** These integer constants are opcodes for the xFileControl method

** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]

** interface.

**

** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This

** opcode causes the xFileControl method to write the current state of

** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],

** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])

** into an integer that the pArg argument points to. This capability

** is used during testing and only needs to be supported when SQLITE_TEST

** is defined.

*/

#define SQLITE_FCNTL_LOCKSTATE 1

#define SQLITE_GET_LOCKPROXYFILE 2

#define SQLITE_SET_LOCKPROXYFILE 3

#define SQLITE_LAST_ERRNO 4

/*

** CAPI3REF: Mutex Handle {H17110} <S20130>

**

** The mutex module within SQLite defines [sqlite3_mutex] to be an

** abstract type for a mutex object. The SQLite core never looks

** at the internal representation of an [sqlite3_mutex]. It only

** deals with pointers to the [sqlite3_mutex] object.

**

** Mutexes are created using [sqlite3_mutex_alloc()].

*/

typedef struct sqlite3_mutex sqlite3_mutex;

/*

** CAPI3REF: OS Interface Object {H11140} <S20100>

**

** An instance of the sqlite3_vfs object defines the interface between

** the SQLite core and the underlying operating system. The "vfs"

** in the name of the object stands for "virtual file system".

**

** The value of the iVersion field is initially 1 but may be larger in

** future versions of SQLite. Additional fields may be appended to this

** object when the iVersion value is increased. Note that the structure

** of the sqlite3_vfs object changes in the transaction between

** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not

** modified.

**

** The szOsFile field is the size of the subclassed [sqlite3_file]

** structure used by this VFS. mxPathname is the maximum length of

** a pathname in this VFS.

**

** Registered sqlite3_vfs objects are kept on a linked list formed by

** the pNext pointer. The [sqlite3_vfs_register()]

** and [sqlite3_vfs_unregister()] interfaces manage this list

** in a thread-safe way. The [sqlite3_vfs_find()] interface

** searches the list. Neither the application code nor the VFS

** implementation should use the pNext pointer.

**

** The pNext field is the only field in the sqlite3_vfs

** structure that SQLite will ever modify. SQLite will only access

** or modify this field while holding a particular static mutex.

** The application should never modify anything within the sqlite3_vfs

** object once the object has been registered.

**

** The zName field holds the name of the VFS module. The name must

** be unique across all VFS modules.

**

** SQLite will guarantee that the zFilename parameter to xOpen

** is either a NULL pointer or string obtained

** from xFullPathname(). SQLite further guarantees that

** the string will be valid and unchanged until xClose() is

** called. Because of the previous sentence,

** the [sqlite3_file] can safely store a pointer to the

** filename if it needs to remember the filename for some reason.

** If the zFilename parameter is xOpen is a NULL pointer then xOpen

** must invent its own temporary name for the file. Whenever the

** xFilename parameter is NULL it will also be the case that the

** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].

**

** The flags argument to xOpen() includes all bits set in

** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]

** or [sqlite3_open16()] is used, then flags includes at least

** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].

** If xOpen() opens a file read-only then it sets *pOutFlags to

** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set.

**

** SQLite will also add one of the following flags to the xOpen()

** call, depending on the object being opened:

**

** <ul>

** <li> [SQLITE_OPEN_MAIN_DB]

** <li> [SQLITE_OPEN_MAIN_JOURNAL]

** <li> [SQLITE_OPEN_TEMP_DB]

** <li> [SQLITE_OPEN_TEMP_JOURNAL]

** <li> [SQLITE_OPEN_TRANSIENT_DB]

** <li> [SQLITE_OPEN_SUBJOURNAL]

** <li> [SQLITE_OPEN_MASTER_JOURNAL]

** </ul>

**

** The file I/O implementation can use the object type flags to

** change the way it deals with files. For example, an application

** that does not care about crash recovery or rollback might make

** the open of a journal file a no-op. Writes to this journal would

** also be no-ops, and any attempt to read the journal would return

** SQLITE_IOERR. Or the implementation might recognize that a database

** file will be doing page-aligned sector reads and writes in a random

** order and set up its I/O subsystem accordingly.

**

** SQLite might also add one of the following flags to the xOpen method:

**

** <ul>

** <li> [SQLITE_OPEN_DELETEONCLOSE]

** <li> [SQLITE_OPEN_EXCLUSIVE]

** </ul>

**

** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be

** deleted when it is closed. The [SQLITE_OPEN_DELETEONCLOSE]

** will be set for TEMP databases, journals and for subjournals.

**

** The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction

** with the [SQLITE_OPEN_CREATE] flag, which are both directly

** analogous to the O_EXCL and O_CREAT flags of the POSIX open()

** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the

** SQLITE_OPEN_CREATE, is used to indicate that file should always

** be created, and that it is an error if it already exists.

** It is <i>not</i> used to indicate the file should be opened

** for exclusive access.

**

** At least szOsFile bytes of memory are allocated by SQLite

** to hold the [sqlite3_file] structure passed as the third

** argument to xOpen. The xOpen method does not have to

** allocate the structure; it should just fill it in. Note that

** the xOpen method must set the sqlite3_file.pMethods to either

** a valid [sqlite3_io_methods] object or to NULL. xOpen must do

** this even if the open fails. SQLite expects that the sqlite3_file.pMethods

** element will be valid after xOpen returns regardless of the success

** or failure of the xOpen call.

**

** The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]

** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to

** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]

** to test whether a file is at least readable. The file can be a

** directory.

**

** SQLite will always allocate at least mxPathname+1 bytes for the

** output buffer xFullPathname. The exact size of the output buffer

** is also passed as a parameter to both methods. If the output buffer

** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is

** handled as a fatal error by SQLite, vfs implementations should endeavor

** to prevent this by setting mxPathname to a sufficiently large value.

**

** The xRandomness(), xSleep(), and xCurrentTime() interfaces

** are not strictly a part of the filesystem, but they are

** included in the VFS structure for completeness.

** The xRandomness() function attempts to return nBytes bytes

** of good-quality randomness into zOut. The return value is

** the actual number of bytes of randomness obtained.

** The xSleep() method causes the calling thread to sleep for at

** least the number of microseconds given. The xCurrentTime()

** method returns a Julian Day Number for the current date and time.

**

*/

typedef struct sqlite3_vfs sqlite3_vfs;

struct sqlite3_vfs {

int iVersion; /* Structure version number */

int szOsFile; /* Size of subclassed sqlite3_file */

int mxPathname; /* Maximum file pathname length */

sqlite3_vfs *pNext; /* Next registered VFS */

const char *zName; /* Name of this virtual file system */

void *pAppData; /* Pointer to application-specific data */

int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,

int flags, int *pOutFlags);

int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);

int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);

int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);

void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);

void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);

void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);

void (*xDlClose)(sqlite3_vfs*, void*);

int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);

int (*xSleep)(sqlite3_vfs*, int microseconds);

int (*xCurrentTime)(sqlite3_vfs*, double*);

int (*xGetLastError)(sqlite3_vfs*, int, char *);

/* New fields may be appended in figure versions. The iVersion

** value will increment whenever this happens. */

};

/*

** CAPI3REF: Flags for the xAccess VFS method {H11190} <H11140>

**

** These integer constants can be used as the third parameter to

** the xAccess method of an [sqlite3_vfs] object. {END} They determine

** what kind of permissions the xAccess method is looking for.

** With SQLITE_ACCESS_EXISTS, the xAccess method

** simply checks whether the file exists.

** With SQLITE_ACCESS_READWRITE, the xAccess method

** checks whether the file is both readable and writable.

** With SQLITE_ACCESS_READ, the xAccess method

** checks whether the file is readable.

*/

#define SQLITE_ACCESS_EXISTS 0

#define SQLITE_ACCESS_READWRITE 1

#define SQLITE_ACCESS_READ 2

/*

** CAPI3REF: Initialize The SQLite Library {H10130} <S20000><S30100>

**

** The sqlite3_initialize() routine initializes the

** SQLite library. The sqlite3_shutdown() routine

** deallocates any resources that were allocated by sqlite3_initialize().

** These routines are designed to aid in process initialization and

** shutdown on embedded systems. Workstation applications using

** SQLite normally do not need to invoke either of these routines.

**

** A call to sqlite3_initialize() is an "effective" call if it is

** the first time sqlite3_initialize() is invoked during the lifetime of

** the process, or if it is the first time sqlite3_initialize() is invoked

** following a call to sqlite3_shutdown(). Only an effective call

** of sqlite3_initialize() does any initialization. All other calls

** are harmless no-ops.

**

** A call to sqlite3_shutdown() is an "effective" call if it is the first

** call to sqlite3_shutdown() since the last sqlite3_initialize(). Only

** an effective call to sqlite3_shutdown() does any deinitialization.

** All other valid calls to sqlite3_shutdown() are harmless no-ops.

**

** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown()

** is not. The sqlite3_shutdown() interface must only be called from a

** single thread. All open [database connections] must be closed and all

** other SQLite resources must be deallocated prior to invoking

** sqlite3_shutdown().

**

** Among other things, sqlite3_initialize() will invoke

** sqlite3_os_init(). Similarly, sqlite3_shutdown()

** will invoke sqlite3_os_end().

**

** The sqlite3_initialize() routine returns [SQLITE_OK] on success.

** If for some reason, sqlite3_initialize() is unable to initialize

** the library (perhaps it is unable to allocate a needed resource such

** as a mutex) it returns an [error code] other than [SQLITE_OK].

**

** The sqlite3_initialize() routine is called internally by many other

** SQLite interfaces so that an application usually does not need to

** invoke sqlite3_initialize() directly. For example, [sqlite3_open()]

** calls sqlite3_initialize() so the SQLite library will be automatically

** initialized when [sqlite3_open()] is called if it has not be initialized

** already. However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]

** compile-time option, then the automatic calls to sqlite3_initialize()

** are omitted and the application must call sqlite3_initialize() directly

** prior to using any other SQLite interface. For maximum portability,

** it is recommended that applications always invoke sqlite3_initialize()

** directly prior to using any other SQLite interface. Future releases

** of SQLite may require this. In other words, the behavior exhibited

** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the

** default behavior in some future release of SQLite.

**

** The sqlite3_os_init() routine does operating-system specific

** initialization of the SQLite library. The sqlite3_os_end()

** routine undoes the effect of sqlite3_os_init(). Typical tasks

** performed by these routines include allocation or deallocation

** of static resources, initialization of global variables,

** setting up a default [sqlite3_vfs] module, or setting up

** a default configuration using [sqlite3_config()].

**

** The application should never invoke either sqlite3_os_init()

** or sqlite3_os_end() directly. The application should only invoke

** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init()

** interface is called automatically by sqlite3_initialize() and

** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate

** implementations for sqlite3_os_init() and sqlite3_os_end()

** are built into SQLite when it is compiled for Unix, Windows, or OS/2.

** When [custom builds | built for other platforms]

** (using the [SQLITE_OS_OTHER=1] compile-time

** option) the application must supply a suitable implementation for

** sqlite3_os_init() and sqlite3_os_end(). An application-supplied

** implementation of sqlite3_os_init() or sqlite3_os_end()

** must return [SQLITE_OK] on success and some other [error code] upon

** failure.

*/

int sqlite3_initialize(void);

int sqlite3_shutdown(void);

int sqlite3_os_init(void);

int sqlite3_os_end(void);

/*

** CAPI3REF: Configuring The SQLite Library {H14100} <S20000><S30200>

** EXPERIMENTAL

**

** The sqlite3_config() interface is used to make global configuration

** changes to SQLite in order to tune SQLite to the specific needs of

** the application. The default configuration is recommended for most

** applications and so this routine is usually not necessary. It is

** provided to support rare applications with unusual needs.

**

** The sqlite3_config() interface is not threadsafe. The application

** must insure that no other SQLite interfaces are invoked by other

** threads while sqlite3_config() is running. Furthermore, sqlite3_config()

** may only be invoked prior to library initialization using

** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].

** Note, however, that sqlite3_config() can be called as part of the

** implementation of an application-defined [sqlite3_os_init()].

**

** The first argument to sqlite3_config() is an integer

** [SQLITE_CONFIG_SINGLETHREAD | configuration option] that determines

** what property of SQLite is to be configured. Subsequent arguments

** vary depending on the [SQLITE_CONFIG_SINGLETHREAD | configuration option]

** in the first argument.

**

** When a configuration option is set, sqlite3_config() returns [SQLITE_OK].

** If the option is unknown or SQLite is unable to set the option

** then this routine returns a non-zero [error code].

**

** Requirements:

** [H14103] [H14106] [H14120] [H14123] [H14126] [H14129] [H14132] [H14135]

** [H14138] [H14141] [H14144] [H14147] [H14150] [H14153] [H14156] [H14159]

** [H14162] [H14165] [H14168]

*/

SQLITE_EXPERIMENTAL int sqlite3_config(int, ...);

/*

** CAPI3REF: Configure database connections {H14200} <S20000>

** EXPERIMENTAL

**

** The sqlite3_db_config() interface is used to make configuration

** changes to a [database connection]. The interface is similar to

** [sqlite3_config()] except that the changes apply to a single

** [database connection] (specified in the first argument). The

** sqlite3_db_config() interface can only be used immediately after

** the database connection is created using [sqlite3_open()],

** [sqlite3_open16()], or [sqlite3_open_v2()].

**

** The second argument to sqlite3_db_config(D,V,...) is the

** configuration verb - an integer code that indicates what

** aspect of the [database connection] is being configured.

** The only choice for this value is [SQLITE_DBCONFIG_LOOKASIDE].

** New verbs are likely to be added in future releases of SQLite.

** Additional arguments depend on the verb.

**

** Requirements:

** [H14203] [H14206] [H14209] [H14212] [H14215]

*/

SQLITE_EXPERIMENTAL int sqlite3_db_config(sqlite3*, int op, ...);

/*

** CAPI3REF: Memory Allocation Routines {H10155} <S20120>

** EXPERIMENTAL

**

** An instance of this object defines the interface between SQLite

** and low-level memory allocation routines.

**

** This object is used in only one place in the SQLite interface.

** A pointer to an instance of this object is the argument to

** [sqlite3_config()] when the configuration option is

** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].

** By creating an instance of this object

** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])

** during configuration, an application can specify an alternative

** memory allocation subsystem for SQLite to use for all of its

** dynamic memory needs.

**

** Note that SQLite comes with several [built-in memory allocators]

** that are perfectly adequate for the overwhelming majority of applications

** and that this object is only useful to a tiny minority of applications

** with specialized memory allocation requirements. This object is

** also used during testing of SQLite in order to specify an alternative

** memory allocator that simulates memory out-of-memory conditions in

** order to verify that SQLite recovers gracefully from such

** conditions.

**

** The xMalloc and xFree methods must work like the

** malloc() and free() functions from the standard C library.

** The xRealloc method must work like realloc() from the standard C library

** with the exception that if the second argument to xRealloc is zero,

** xRealloc must be a no-op - it must not perform any allocation or

** deallocation. SQLite guaranteeds that the second argument to

** xRealloc is always a value returned by a prior call to xRoundup.

** And so in cases where xRoundup always returns a positive number,

** xRealloc can perform exactly as the standard library realloc() and

** still be in compliance with this specification.

**

** xSize should return the allocated size of a memory allocation

** previously obtained from xMalloc or xRealloc. The allocated size

** is always at least as big as the requested size but may be larger.

**

** The xRoundup method returns what would be the allocated size of

** a memory allocation given a particular requested size. Most memory

** allocators round up memory allocations at least to the next multiple

** of 8. Some allocators round up to a larger multiple or to a power of 2.