/*** 2001 September 15 load_extension**** 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 __cplusplusextern "C" {#endif /*** Add the ability to override 'extern'*/#ifndef SQLITE_EXTERN# define SQLITE_EXTERN extern#endif #ifndef SQLITE_API# define SQLITE_API#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**** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header** evaluates to a string literal that is the SQLite version in the** format "X.Y.Z" where X is the major version number (always 3 for** SQLite3) and Y is the minor version number and Z is the release number.)^** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same** numbers used in [SQLITE_VERSION].)^** The SQLITE_VERSION_NUMBER for any given release of SQLite will also** be larger than the release from which it is derived. Either Y will** be held constant and Z will be incremented or else Y will be incremented** and Z will be reset to zero.**** 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 evaluates to** a string which identifies a particular check-in of SQLite** within its configuration management system. ^The SQLITE_SOURCE_ID** 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()].*/#define SQLITE_VERSION "3.7.15.1"#define SQLITE_VERSION_NUMBER 3007015#define SQLITE_SOURCE_ID "2012-12-19 20:39:10 6b85b767d0ff7975146156a99ad673f2c1a23318" /*** CAPI3REF: Run-Time Library Version Numbers** KEYWORDS: sqlite3_version, sqlite3_sourceid**** These interfaces provide the same information as the [SQLITE_VERSION],** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros** 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_version[] string constant contains the text of [SQLITE_VERSION]** macro. ^The sqlite3_libversion() function returns a pointer to the** to the sqlite3_version[] string constant. The sqlite3_libversion()** function is provided for use in DLLs since DLL users usually do not have** direct access to string constants within the DLL. ^The** sqlite3_libversion_number() function returns an integer equal to** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns ** a pointer to a string constant whose value is the same as the ** [SQLITE_SOURCE_ID] C preprocessor macro.**** See also: [sqlite_version()] and [sqlite_source_id()].*/SQLITE_API SQLITE_EXTERN const char sqlite3_version[];SQLITE_API const char *sqlite3_libversion(void);SQLITE_API const char *sqlite3_sourceid(void);SQLITE_API int sqlite3_libversion_number(void); /*** CAPI3REF: Run-Time Library Compilation Options Diagnostics**** ^The sqlite3_compileoption_used() function returns 0 or 1 ** indicating whether the specified option was defined at ** compile time. ^The SQLITE_ prefix may be omitted from the ** option name passed to sqlite3_compileoption_used(). **** ^The sqlite3_compileoption_get() function allows iterating** over the list of options that were defined at compile time by** returning the N-th compile time option string. ^If N is out of range,** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ ** prefix is omitted from any strings returned by ** sqlite3_compileoption_get().**** ^Support for the diagnostic functions sqlite3_compileoption_used()** and sqlite3_compileoption_get() may be omitted by specifying the ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.**** See also: SQL functions [sqlite_compileoption_used()] and** [sqlite_compileoption_get()] and the [compile_options pragma].*/#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGSSQLITE_API int sqlite3_compileoption_used(const char *zOptName);SQLITE_API const char *sqlite3_compileoption_get(int N);#endif /*** CAPI3REF: Test To See If The Library Is Threadsafe**** ^The sqlite3_threadsafe() function returns zero if and only if** SQLite was compiled with mutexing code omitted due to the** [SQLITE_THREADSAFE] compile-time option being set to 0.**** 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 or =2 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 the** sqlite3_threadsafe() function shows only the compile-time setting of** thread safety, not any run-time changes to that setting made by** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()** is unchanged by calls to sqlite3_config().)^**** See the [threading mode] documentation for additional information.*/SQLITE_API int sqlite3_threadsafe(void); /*** CAPI3REF: Database Connection Handle** 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()]** and [sqlite3_close_v2()] are its destructors. 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** 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.**** ^The sqlite3_int64 and sqlite_int64 types can store integer values** between -9223372036854775808 and +9223372036854775807 inclusive. ^The** sqlite3_uint64 and sqlite_uint64 types can store integer values ** between 0 and +18446744073709551615 inclusive.*/#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;#endiftypedef 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**** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors** for the [sqlite3] object.** ^Calls to sqlite3_close() and sqlite3_close_v2() return SQLITE_OK if** the [sqlite3] object is successfully destroyed and all associated** resources are deallocated.**** ^If the database connection is associated with unfinalized prepared** statements or unfinished sqlite3_backup objects then sqlite3_close()** will leave the database connection open and return [SQLITE_BUSY].** ^If sqlite3_close_v2() is called with unfinalized prepared statements** and unfinished sqlite3_backups, then the database connection becomes** an unusable "zombie" which will automatically be deallocated when the** last prepared statement is finalized or the last sqlite3_backup is** finished. The sqlite3_close_v2() interface is intended for use with** host languages that are garbage collected, and where the order in which** destructors are called is arbitrary.**** Applications should [sqlite3_finalize | finalize] all [prepared statements],** [sqlite3_blob_close | close] all [BLOB handles], and ** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated** with the [sqlite3] object prior to attempting to close the object. ^If** sqlite3_close() is called on a [database connection] that still has** outstanding [prepared statements], [BLOB handles], and/or** [sqlite3_backup] objects then it returns SQLITE_OK but the deallocation** of resources is deferred until all [prepared statements], [BLOB handles],** and [sqlite3_backup] objects are also destroyed.**** ^If an [sqlite3] object is destroyed while a transaction is open,** the transaction is automatically rolled back.**** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(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.** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer** argument is a harmless no-op.*/SQLITE_API int sqlite3_close(sqlite3*);SQLITE_API int sqlite3_close_v2(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**** The sqlite3_exec() interface is a convenience wrapper around** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],** that allows an application to run multiple statements of SQL** without having to use a lot of C code. **** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,** semicolon-separate SQL statements passed into its 2nd argument,** in the context of the [database connection] passed in as its 1st** argument. ^If the callback function of the 3rd argument to** sqlite3_exec() is not NULL, then it is invoked for each result row** coming out of the evaluated SQL statements. ^The 4th argument to** sqlite3_exec() is relayed through to the 1st argument of each** callback invocation. ^If the callback pointer to sqlite3_exec()** is NULL, then no callback is ever invoked and result rows are** ignored.**** ^If an error occurs while evaluating the SQL statements passed into** sqlite3_exec(), then execution of the current statement stops and** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec()** is not NULL then any error message is written into memory obtained** from [sqlite3_malloc()] and passed back through the 5th parameter.** To avoid memory leaks, the application should invoke [sqlite3_free()]** on error message strings returned through the 5th parameter of** of sqlite3_exec() after the error message string is no longer needed.** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors** occur, then sqlite3_exec() sets the pointer in its 5th parameter to** NULL before returning.**** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()** routine returns SQLITE_ABORT without invoking the callback again and** without running any subsequent SQL statements.**** ^The 2nd argument to the sqlite3_exec() callback function is the** number of columns in the result. ^The 3rd argument to the sqlite3_exec()** callback is an array of pointers to strings obtained as if from** [sqlite3_column_text()], one for each column. ^If an element of a** result row is NULL then the corresponding string pointer for the** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the** sqlite3_exec() callback is an array of pointers to strings where each** entry represents the name of corresponding result column as obtained** from [sqlite3_column_name()].**** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer** to an empty string, or a pointer that contains only whitespace and/or ** SQL comments, then no SQL statements are evaluated and the database** is not changed.**** Restrictions:**** <ul>** <li> The application must insure that the 1st parameter to sqlite3_exec()** is a valid and open [database connection].** <li> The application must not close [database connection] specified by** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.** <li> The application must not modify the SQL statement text passed into** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.** </ul>*/SQLITE_API 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** 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 indicate success or failure.**** New error codes may be added in future versions of SQLite.**** See also: [SQLITE_IOERR_READ | extended result codes],** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | 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 /* Unknown opcode in sqlite3_file_control() */#define SQLITE_FULL 13 /* Insertion failed because database is full */#define SQLITE_CANTOPEN 14 /* Unable to open the database file */#define SQLITE_PROTOCOL 15 /* 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** 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_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8))#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8))#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8))#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) /*** CAPI3REF: Flags For File Open Operations**** These bit values are intended for use in the** 3rd parameter to the [sqlite3_open_v2()] interface and** in the 4th parameter to the [sqlite3_vfs.xOpen] method.*/#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_AUTOPROXY 0x00000020 /* VFS only */Lines 1–500 of 7164. Load more
/* ** 2001 September 15 load_extension ** ** 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 #ifndef SQLITE_API # define SQLITE_API #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 ** ** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header ** evaluates to a string literal that is the SQLite version in the ** format "X.Y.Z" where X is the major version number (always 3 for ** SQLite3) and Y is the minor version number and Z is the release number.)^ ** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same ** numbers used in [SQLITE_VERSION].)^ ** The SQLITE_VERSION_NUMBER for any given release of SQLite will also ** be larger than the release from which it is derived. Either Y will ** be held constant and Z will be incremented or else Y will be incremented ** and Z will be reset to zero. ** ** 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 evaluates to ** a string which identifies a particular check-in of SQLite ** within its configuration management system. ^The SQLITE_SOURCE_ID ** 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()]. */ #define SQLITE_VERSION "3.7.15.1" #define SQLITE_VERSION_NUMBER 3007015 #define SQLITE_SOURCE_ID "2012-12-19 20:39:10 6b85b767d0ff7975146156a99ad673f2c1a23318" /* ** CAPI3REF: Run-Time Library Version Numbers ** KEYWORDS: sqlite3_version, sqlite3_sourceid ** ** These interfaces provide the same information as the [SQLITE_VERSION], ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros ** 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_version[] string constant contains the text of [SQLITE_VERSION] ** macro. ^The sqlite3_libversion() function returns a pointer to the ** to the sqlite3_version[] string constant. The sqlite3_libversion() ** function is provided for use in DLLs since DLL users usually do not have ** direct access to string constants within the DLL. ^The ** sqlite3_libversion_number() function returns an integer equal to ** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns ** a pointer to a string constant whose value is the same as the ** [SQLITE_SOURCE_ID] C preprocessor macro. ** ** See also: [sqlite_version()] and [sqlite_source_id()]. */ SQLITE_API SQLITE_EXTERN const char sqlite3_version[]; SQLITE_API const char *sqlite3_libversion(void); SQLITE_API const char *sqlite3_sourceid(void); SQLITE_API int sqlite3_libversion_number(void); /* ** CAPI3REF: Run-Time Library Compilation Options Diagnostics ** ** ^The sqlite3_compileoption_used() function returns 0 or 1 ** indicating whether the specified option was defined at ** compile time. ^The SQLITE_ prefix may be omitted from the ** option name passed to sqlite3_compileoption_used(). ** ** ^The sqlite3_compileoption_get() function allows iterating ** over the list of options that were defined at compile time by ** returning the N-th compile time option string. ^If N is out of range, ** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ ** prefix is omitted from any strings returned by ** sqlite3_compileoption_get(). ** ** ^Support for the diagnostic functions sqlite3_compileoption_used() ** and sqlite3_compileoption_get() may be omitted by specifying the ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. ** ** See also: SQL functions [sqlite_compileoption_used()] and ** [sqlite_compileoption_get()] and the [compile_options pragma]. */ #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS SQLITE_API int sqlite3_compileoption_used(const char *zOptName); SQLITE_API const char *sqlite3_compileoption_get(int N); #endif /* ** CAPI3REF: Test To See If The Library Is Threadsafe ** ** ^The sqlite3_threadsafe() function returns zero if and only if ** SQLite was compiled with mutexing code omitted due to the ** [SQLITE_THREADSAFE] compile-time option being set to 0. ** ** 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 or =2 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 the ** sqlite3_threadsafe() function shows only the compile-time setting of ** thread safety, not any run-time changes to that setting made by ** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() ** is unchanged by calls to sqlite3_config().)^ ** ** See the [threading mode] documentation for additional information. */ SQLITE_API int sqlite3_threadsafe(void); /* ** CAPI3REF: Database Connection Handle ** 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()] ** and [sqlite3_close_v2()] are its destructors. 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 ** 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. ** ** ^The sqlite3_int64 and sqlite_int64 types can store integer values ** between -9223372036854775808 and +9223372036854775807 inclusive. ^The ** sqlite3_uint64 and sqlite_uint64 types can store integer values ** between 0 and +18446744073709551615 inclusive. */ #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 ** ** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors ** for the [sqlite3] object. ** ^Calls to sqlite3_close() and sqlite3_close_v2() return SQLITE_OK if ** the [sqlite3] object is successfully destroyed and all associated ** resources are deallocated. ** ** ^If the database connection is associated with unfinalized prepared ** statements or unfinished sqlite3_backup objects then sqlite3_close() ** will leave the database connection open and return [SQLITE_BUSY]. ** ^If sqlite3_close_v2() is called with unfinalized prepared statements ** and unfinished sqlite3_backups, then the database connection becomes ** an unusable "zombie" which will automatically be deallocated when the ** last prepared statement is finalized or the last sqlite3_backup is ** finished. The sqlite3_close_v2() interface is intended for use with ** host languages that are garbage collected, and where the order in which ** destructors are called is arbitrary. ** ** Applications should [sqlite3_finalize | finalize] all [prepared statements], ** [sqlite3_blob_close | close] all [BLOB handles], and ** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated ** with the [sqlite3] object prior to attempting to close the object. ^If ** sqlite3_close() is called on a [database connection] that still has ** outstanding [prepared statements], [BLOB handles], and/or ** [sqlite3_backup] objects then it returns SQLITE_OK but the deallocation ** of resources is deferred until all [prepared statements], [BLOB handles], ** and [sqlite3_backup] objects are also destroyed. ** ** ^If an [sqlite3] object is destroyed while a transaction is open, ** the transaction is automatically rolled back. ** ** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(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. ** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer ** argument is a harmless no-op. */ SQLITE_API int sqlite3_close(sqlite3*); SQLITE_API int sqlite3_close_v2(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 ** ** The sqlite3_exec() interface is a convenience wrapper around ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], ** that allows an application to run multiple statements of SQL ** without having to use a lot of C code. ** ** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, ** semicolon-separate SQL statements passed into its 2nd argument, ** in the context of the [database connection] passed in as its 1st ** argument. ^If the callback function of the 3rd argument to ** sqlite3_exec() is not NULL, then it is invoked for each result row ** coming out of the evaluated SQL statements. ^The 4th argument to ** sqlite3_exec() is relayed through to the 1st argument of each ** callback invocation. ^If the callback pointer to sqlite3_exec() ** is NULL, then no callback is ever invoked and result rows are ** ignored. ** ** ^If an error occurs while evaluating the SQL statements passed into ** sqlite3_exec(), then execution of the current statement stops and ** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() ** is not NULL then any error message is written into memory obtained ** from [sqlite3_malloc()] and passed back through the 5th parameter. ** To avoid memory leaks, the application should invoke [sqlite3_free()] ** on error message strings returned through the 5th parameter of ** of sqlite3_exec() after the error message string is no longer needed. ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to ** NULL before returning. ** ** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() ** routine returns SQLITE_ABORT without invoking the callback again and ** without running any subsequent SQL statements. ** ** ^The 2nd argument to the sqlite3_exec() callback function is the ** number of columns in the result. ^The 3rd argument to the sqlite3_exec() ** callback is an array of pointers to strings obtained as if from ** [sqlite3_column_text()], one for each column. ^If an element of a ** result row is NULL then the corresponding string pointer for the ** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the ** sqlite3_exec() callback is an array of pointers to strings where each ** entry represents the name of corresponding result column as obtained ** from [sqlite3_column_name()]. ** ** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer ** to an empty string, or a pointer that contains only whitespace and/or ** SQL comments, then no SQL statements are evaluated and the database ** is not changed. ** ** Restrictions: ** ** <ul> ** <li> The application must insure that the 1st parameter to sqlite3_exec() ** is a valid and open [database connection]. ** <li> The application must not close [database connection] specified by ** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. ** <li> The application must not modify the SQL statement text passed into ** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. ** </ul> */ SQLITE_API 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 ** 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 indicate success or failure. ** ** New error codes may be added in future versions of SQLite. ** ** See also: [SQLITE_IOERR_READ | extended result codes], ** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | 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 /* Unknown opcode in sqlite3_file_control() */ #define SQLITE_FULL 13 /* Insertion failed because database is full */ #define SQLITE_CANTOPEN 14 /* Unable to open the database file */ #define SQLITE_PROTOCOL 15 /* 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 ** 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_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) #define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) #define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) #define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) #define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) #define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) #define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) #define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) #define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) #define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) #define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) #define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) #define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) #define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) #define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) /* ** CAPI3REF: Flags For File Open Operations ** ** These bit values are intended for use in the ** 3rd parameter to the [sqlite3_open_v2()] interface and ** in the 4th parameter to the [sqlite3_vfs.xOpen] method. */ #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_AUTOPROXY 0x00000020 /* VFS only */